Commit | Line | Data |
---|---|---|
8e9caa8f | 1 | ;;; generic.el --- Defining simple major modes with comment and font-lock. |
89ada4dd RS |
2 | ;; |
3 | ;; Copyright (C) 1997 Free Software Foundation, Inc. | |
4 | ;; | |
6fe8a37a | 5 | ;; Author: Peter Breton <pbreton@cs.umb.edu> |
89ada4dd RS |
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 | |
02f853b5 | 36 | ;; which provide basic comment and font-lock support. These modes are |
89ada4dd RS |
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 | ;; | |
02f853b5 | 43 | ;; * List of comment-characters. The entries in this list should be |
89ada4dd RS |
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 | ;; | |
02f853b5 | 49 | ;; * List of keywords to font-lock. Each keyword should be a string. |
89ada4dd | 50 | ;; If you have additional keywords which should be highlighted in a face |
6fe8a37a RS |
51 | ;; different from `font-lock-keyword-face', you can use the convenience |
52 | ;; function `generic-make-keywords-list' (which see), and add the | |
89ada4dd RS |
53 | ;; result to the following list: |
54 | ;; | |
02f853b5 | 55 | ;; * Additional expressions to font-lock. This should be a list of |
89ada4dd | 56 | ;; expressions, each of which should be of the same form |
6fe8a37a | 57 | ;; as those in `font-lock-defaults-alist'. |
89ada4dd RS |
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 | ;; | |
6fe8a37a | 79 | ;; Use the `define-generic-mode' function to define new modes. |
89ada4dd RS |
80 | ;; For example: |
81 | ;; | |
6fe8a37a | 82 | ;; (require 'generic) |
89ada4dd RS |
83 | ;; (define-generic-mode 'foo-generic-mode |
84 | ;; (list ?% ) | |
85 | ;; (list "keyword") | |
86 | ;; nil | |
87 | ;; (list "\.FOO") | |
88 | ;; (list 'foo-setup-function)) | |
89 | ;; | |
6fe8a37a RS |
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 | |
89ada4dd | 92 | ;; '.FOO' are loaded, Emacs will go into foo-generic-mode and call |
6fe8a37a | 93 | ;; foo-setup-function. You can also use the function `foo-generic-mode' |
89ada4dd RS |
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 | |
6fe8a37a RS |
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 | |
89ada4dd RS |
104 | ;; options. |
105 | ;; | |
106 | ;; GOTCHAS: | |
107 | ;; | |
02f853b5 | 108 | ;; Be careful that your font-lock definitions are correct. Getting them |
89ada4dd RS |
109 | ;; wrong can cause emacs to continually attempt to fontify! This problem |
110 | ;; is not specific to generic-mode. | |
111 | ;; | |
112 | ||
5027054f | 113 | ;; Credit for suggestions, brainstorming, help with debugging: |
89ada4dd RS |
114 | ;; ACorreir@pervasive-sw.com (Alfred Correira) |
115 | ||
89ada4dd RS |
116 | ;;; Code: |
117 | ||
118 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
728f84dc | 119 | ;; Internal Variables |
89ada4dd RS |
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 | ||
728f84dc RS |
161 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
162 | ;; Customization Variables | |
163 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
164 | ||
4eea26a9 RS |
165 | (defgroup generic nil |
166 | "Define simple major modes with comment and font-lock support." | |
167 | :prefix "generic-" | |
168 | :group 'extensions) | |
169 | ||
728f84dc | 170 | (defcustom generic-use-find-file-hook t |
89ada4dd RS |
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 | |
728f84dc RS |
173 | comment character." |
174 | :group 'generic | |
175 | :type 'boolean | |
176 | ) | |
89ada4dd | 177 | |
728f84dc | 178 | (defcustom generic-lines-to-scan 3 |
89ada4dd RS |
179 | "*Number of lines that `generic-mode-find-file-hook' looks at |
180 | when deciding whether to enter generic-mode automatically. | |
728f84dc RS |
181 | This variable should be set to a small positive number." |
182 | :group 'generic | |
183 | :type 'integer | |
184 | ) | |
89ada4dd | 185 | |
728f84dc | 186 | (defcustom generic-find-file-regexp "#.*\n\\(.*\n\\)?" |
89ada4dd RS |
187 | "*Regular expression used by `generic-mode-find-file-hook' |
188 | to determine if files in fundamental mode should be put into | |
728f84dc RS |
189 | `default-generic-mode' instead." |
190 | :group 'generic | |
191 | :type 'regexp | |
192 | ) | |
89ada4dd RS |
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) | |
728f84dc | 210 | (and (not (symbolp name)) |
89ada4dd RS |
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 | ||
728f84dc | 219 | (and (not (or (null description) (stringp description))) |
89ada4dd RS |
220 | (error "Description must be a string or nil")) |
221 | ) | |
222 | ||
223 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
224 | ;; Functions | |
225 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; | |
226 | ||
1d96c2ff | 227 | ;;;###autoload |
89ada4dd RS |
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' | |
02f853b5 | 251 | is called; any old regexps with the same name are removed. |
89ada4dd RS |
252 | |
253 | FUNCTION-LIST is a list of functions to call to do some additional setup. | |
254 | ||
02f853b5 | 255 | See the file generic-x.el for some examples of `define-generic-mode'." |
89ada4dd RS |
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)))) | |
728f84dc RS |
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))))) | |
89ada4dd RS |
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)) | |
9b544de1 | 329 | (generic-mode-hooks (intern (concat (symbol-name type) "-hooks"))) |
89ada4dd RS |
330 | ) |
331 | ||
728f84dc RS |
332 | (and (not generic-mode-list) |
333 | (error "Can't find generic-mode information for type %s" | |
334 | (princ generic-mode-name))) | |
89ada4dd RS |
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) | |
3e007e81 | 345 | major-mode type |
89ada4dd RS |
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 | |
728f84dc RS |
361 | (and generic-mode-function-list |
362 | (mapcar 'funcall generic-mode-function-list)) | |
9b544de1 KH |
363 | |
364 | (run-hooks generic-mode-hooks) | |
89ada4dd RS |
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'. | |
02f853b5 | 375 | Some generic modes are defined in `generic-x.el'." |
89ada4dd RS |
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))) | |
728f84dc RS |
406 | (and (consp comment) |
407 | (generic-mode-set-comment-pair comment))) | |
89ada4dd RS |
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 | |
728f84dc RS |
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))) | |
89ada4dd RS |
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 | |
728f84dc | 506 | (and keywords |
89ada4dd RS |
507 | (setq |
508 | generic-font-lock-expressions | |
509 | (append | |
4eea26a9 RS |
510 | (list (let ((regexp (regexp-opt keywords))) |
511 | (list (concat "\\<\\(" regexp "\\)\\>") | |
512 | 1 | |
513 | 'font-lock-keyword-face))) | |
89ada4dd RS |
514 | generic-font-lock-expressions))) |
515 | ;; Other font-lock expressions | |
728f84dc | 516 | (and font-lock-expressions |
89ada4dd RS |
517 | (setq generic-font-lock-expressions |
518 | (append | |
519 | font-lock-expressions | |
520 | generic-font-lock-expressions))) | |
728f84dc RS |
521 | (and (or font-lock-expressions keywords) |
522 | (setq generic-font-lock-defaults generic-font-lock-expressions)) | |
89ada4dd RS |
523 | )) |
524 | ||
525 | ;; Support for [KEYWORD] constructs found in INF, INI and Samba files | |
526 | (defun generic-bracket-support () | |
527 | (setq imenu-generic-expression | |
c0b08eb0 DL |
528 | '((nil "^\\[\\(.*\\)\\]" 1)) |
529 | imenu-case-fold-search t)) | |
89ada4dd RS |
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 | |
728f84dc RS |
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")) | |
89ada4dd RS |
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)) | |
728f84dc RS |
559 | (and (looking-at comment-regexp) |
560 | (generic-mode-with-type 'default-generic-mode)))))) | |
89ada4dd RS |
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." | |
728f84dc RS |
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))))) | |
89ada4dd RS |
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." | |
728f84dc RS |
578 | (and (not (listp keywords-list)) |
579 | (error "Keywords argument must be a list of strings")) | |
4eea26a9 RS |
580 | (list (concat (or prefix "") |
581 | "\\<\\(" | |
582 | ;; Use an optimized regexp. | |
583 | (regexp-opt keywords-list t) | |
584 | "\\)\\>" | |
585 | (or suffix "")) | |
586 | 1 | |
5204a3a0 | 587 | face)) |
89ada4dd | 588 | |
8e9caa8f | 589 | (provide 'generic) |
89ada4dd | 590 | |
4eea26a9 | 591 | ;;; generic.el ends here |