Mercurial > emacs
annotate lisp/generic-x.el @ 101169:39077981fbed
*** empty log message ***
author | Martin Rudalics <rudalics@gmx.at> |
---|---|
date | Wed, 14 Jan 2009 10:14:40 +0000 |
parents | a9dc0e7c3f2b |
children | 782b6464073e |
rev | line source |
---|---|
61903 | 1 ;;; generic-x.el --- A collection of generic modes |
21205 | 2 |
74442 | 3 ;; Copyright (C) 1997, 1998, 2001, 2002, 2003, 2004, |
100908 | 4 ;; 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. |
21205 | 5 |
6 ;; Author: Peter Breton <pbreton@cs.umb.edu> | |
7 ;; Created: Tue Oct 08 1996 | |
8 ;; Keywords: generic, comment, font-lock | |
9 | |
10 ;; This file is part of GNU Emacs. | |
11 | |
94678
ee5932bf781d
Switch to recommended form of GPLv3 permissions notice.
Glenn Morris <rgm@gnu.org>
parents:
93975
diff
changeset
|
12 ;; GNU Emacs is free software: you can redistribute it and/or modify |
21205 | 13 ;; it under the terms of the GNU General Public License as published by |
94678
ee5932bf781d
Switch to recommended form of GPLv3 permissions notice.
Glenn Morris <rgm@gnu.org>
parents:
93975
diff
changeset
|
14 ;; the Free Software Foundation, either version 3 of the License, or |
ee5932bf781d
Switch to recommended form of GPLv3 permissions notice.
Glenn Morris <rgm@gnu.org>
parents:
93975
diff
changeset
|
15 ;; (at your option) any later version. |
21205 | 16 |
17 ;; GNU Emacs is distributed in the hope that it will be useful, | |
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
20 ;; GNU General Public License for more details. | |
21 | |
22 ;; You should have received a copy of the GNU General Public License | |
94678
ee5932bf781d
Switch to recommended form of GPLv3 permissions notice.
Glenn Morris <rgm@gnu.org>
parents:
93975
diff
changeset
|
23 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. |
21205 | 24 |
25 ;;; Commentary: | |
26 ;; | |
78063
edd7a13f790e
(generic-define-mswindows-modes, generic-define-unix-modes,
Juanma Barranquero <lekktu@gmail.com>
parents:
75347
diff
changeset
|
27 ;; This file contains a collection of generic modes. |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
28 ;; |
21205 | 29 ;; INSTALLATION: |
30 ;; | |
31 ;; Add this line to your .emacs file: | |
32 ;; | |
33 ;; (require 'generic-x) | |
34 ;; | |
35 ;; You can decide which modes to load by setting the variable | |
61903 | 36 ;; `generic-extras-enable-list'. Its default value is platform- |
37 ;; specific. The recommended way to set this variable is through | |
38 ;; customize: | |
39 ;; | |
40 ;; M-x customize-option RET generic-extras-enable-list RET | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
41 ;; |
61903 | 42 ;; This lets you select generic modes from the list of available |
43 ;; modes. If you manually set `generic-extras-enable-list' in your | |
44 ;; .emacs, do it BEFORE loading generic-x with (require 'generic-x). | |
45 ;; | |
46 ;; You can also send in new modes; if the file types are reasonably | |
47 ;; common, we would like to install them. | |
21205 | 48 ;; |
61456
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
49 ;; DEFAULT GENERIC MODE: |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
50 ;; |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
51 ;; This file provides a hook which automatically puts a file into |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
52 ;; `default-generic-mode' if the first few lines of a file in |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
53 ;; fundamental mode start with a hash comment character. To disable |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
54 ;; this functionality, set the variable `generic-use-find-file-hook' |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
55 ;; to nil BEFORE loading generic-x. See the variables |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
56 ;; `generic-lines-to-scan' and `generic-find-file-regexp' for |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
57 ;; customization options. |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
58 ;; |
21205 | 59 ;; PROBLEMS WHEN USED WITH FOLDING MODE: |
60 ;; | |
24036 | 61 ;; [The following relates to the obsolete selective-display technique. |
61903 | 62 ;; Folding mode should use invisible text properties instead. -- Dave |
24036 | 63 ;; Love] |
64 ;; | |
21205 | 65 ;; From Anders Lindgren <andersl@csd.uu.se> |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
66 ;; |
21205 | 67 ;; Problem summary: Wayne Adams has found a problem when using folding |
61903 | 68 ;; mode in conjunction with font-lock for a mode defined in |
21205 | 69 ;; `generic-x.el'. |
70 ;; | |
71 ;; The problem, as Wayne described it, was that error messages of the | |
72 ;; following form appeared when both font-lock and folding are used: | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
73 ;; |
21205 | 74 ;; > - various msgs including "Fontifying region...(error Stack |
75 ;; > overflow in regexp matcher)" appear | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
76 ;; |
61903 | 77 ;; I have just tracked down the cause of the problem. The regexp's in |
78 ;; `generic-x.el' do not take into account the way that folding hides | |
79 ;; sections of the buffer. The technique is known as | |
21205 | 80 ;; `selective-display' and has been available for a very long time (I |
61903 | 81 ;; started using it back in the good old Emacs 18 days). Basically, a |
21205 | 82 ;; section is hidden by creating one very long line were the newline |
83 ;; character (C-j) is replaced by a linefeed (C-m) character. | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
84 ;; |
21205 | 85 ;; Many other hiding packages, besides folding, use the same technique, |
86 ;; the problem should occur when using them as well. | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
87 ;; |
61903 | 88 ;; The erroneous lines in `generic-x.el' look like the following (this |
21205 | 89 ;; example is from the `ini' section): |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
90 ;; |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
91 ;; '(("^\\(\\[.*\\]\\)" 1 'font-lock-constant-face) |
21205 | 92 ;; ("^\\(.*\\)=" 1 'font-lock-variable-name-face) |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
93 ;; |
21205 | 94 ;; The intention of these lines is to highlight lines of the following |
95 ;; form: | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
96 ;; |
21205 | 97 ;; [foo] |
98 ;; bar = xxx | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
99 ;; |
61903 | 100 ;; However, since the `.' regexp symbol matches the linefeed character |
101 ;; the entire folded section is searched, resulting in a regexp stack | |
21205 | 102 ;; overflow. |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
103 ;; |
61903 | 104 ;; Solution suggestion: Instead of using ".", use the sequence |
105 ;; "[^\n\r]". This will make the rules behave just as before, but | |
106 ;; they will work together with selective-display. | |
21205 | 107 |
108 ;;; Code: | |
109 | |
61903 | 110 (eval-when-compile (require 'font-lock)) |
21205 | 111 |
21947
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
112 (defgroup generic-x nil |
61456
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
113 "A collection of generic modes." |
21947
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
114 :prefix "generic-" |
61456
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
115 :group 'data |
22110
47ffa41d5ed5
*** empty log message ***
Dan Nicolaescu <done@ece.arizona.edu>
parents:
21947
diff
changeset
|
116 :version "20.3") |
21947
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
117 |
61456
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
118 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
119 ;; Default-Generic mode |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
120 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
121 |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
122 (defcustom generic-use-find-file-hook t |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
123 "If non-nil, add a hook to enter `default-generic-mode' automatically. |
61456
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
124 This is done if the first few lines of a file in fundamental mode |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
125 start with a hash comment character." |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
126 :group 'generic-x |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
127 :type 'boolean) |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
128 |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
129 (defcustom generic-lines-to-scan 3 |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
130 "Number of lines that `generic-mode-find-file-hook' looks at. |
61456
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
131 Relevant when deciding whether to enter Default-Generic mode automatically. |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
132 This variable should be set to a small positive number." |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
133 :group 'generic-x |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
134 :type 'integer) |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
135 |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
136 (defcustom generic-find-file-regexp "^#" |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
137 "Regular expression used by `generic-mode-find-file-hook'. |
61456
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
138 Files in fundamental mode whose first few lines contain a match |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
139 for this regexp, should be put into Default-Generic mode instead. |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
140 The number of lines tested for the matches is specified by the |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
141 value of the variable `generic-lines-to-scan', which see." |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
142 :group 'generic-x |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
143 :type 'regexp) |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
144 |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
145 (defcustom generic-ignore-files-regexp "[Tt][Aa][Gg][Ss]\\'" |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
146 "Regular expression used by `generic-mode-find-file-hook'. |
61456
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
147 Files whose names match this regular expression should not be put |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
148 into Default-Generic mode, even if they have lines which match |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
149 the regexp in `generic-find-file-regexp'. If the value is nil, |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
150 `generic-mode-find-file-hook' does not check the file names." |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
151 :group 'generic-x |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
152 :type '(choice (const :tag "Don't check file names" nil) regexp)) |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
153 |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
154 ;; This generic mode is always defined |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
155 (define-generic-mode default-generic-mode (list ?#) nil nil nil nil) |
61456
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
156 |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
157 ;; A more general solution would allow us to enter generic-mode for |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
158 ;; *any* comment character, but would require us to synthesize a new |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
159 ;; generic-mode on the fly. I think this gives us most of what we |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
160 ;; want. |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
161 (defun generic-mode-find-file-hook () |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
162 "Hook function to enter Default-Generic mode automatically. |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
163 |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
164 Done if the first few lines of a file in Fundamental mode start |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
165 with a match for the regexp in `generic-find-file-regexp', unless |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
166 the file's name matches the regexp which is the value of the |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
167 variable `generic-ignore-files-regexp'. |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
168 |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
169 This hook will be installed if the variable |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
170 `generic-use-find-file-hook' is non-nil. The variable |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
171 `generic-lines-to-scan' determines the number of lines to look at." |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
172 (when (and (eq major-mode 'fundamental-mode) |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
173 (or (null generic-ignore-files-regexp) |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
174 (not (string-match-p |
61456
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
175 generic-ignore-files-regexp |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
176 (file-name-sans-versions buffer-file-name))))) |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
177 (save-excursion |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
178 (goto-char (point-min)) |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
179 (when (re-search-forward generic-find-file-regexp |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
180 (save-excursion |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
181 (forward-line generic-lines-to-scan) |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
182 (point)) t) |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
183 (goto-char (point-min)) |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
184 (default-generic-mode))))) |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
185 |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
186 (and generic-use-find-file-hook |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
187 (add-hook 'find-file-hook 'generic-mode-find-file-hook)) |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
188 |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
189 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
190 ;; Other Generic modes |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
191 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
b36d454902de
(generic-x): Docstring fix. Put it in the data group.
Lute Kamstra <lute@gnu.org>
parents:
61394
diff
changeset
|
192 |
61903 | 193 ;; If you add a generic mode to this file, put it in one of these four |
194 ;; lists as well. | |
195 | |
196 (defconst generic-default-modes | |
197 '(apache-conf-generic-mode | |
198 apache-log-generic-mode | |
199 hosts-generic-mode | |
200 java-manifest-generic-mode | |
201 java-properties-generic-mode | |
202 javascript-generic-mode | |
203 show-tabs-generic-mode | |
204 vrml-generic-mode) | |
205 "List of generic modes that are defined by default.") | |
206 | |
207 (defconst generic-mswindows-modes | |
208 '(bat-generic-mode | |
209 inf-generic-mode | |
210 ini-generic-mode | |
211 rc-generic-mode | |
212 reg-generic-mode | |
213 rul-generic-mode) | |
214 "List of generic modes that are defined by default on MS-Windows.") | |
215 | |
216 (defconst generic-unix-modes | |
217 '(alias-generic-mode | |
218 etc-fstab-generic-mode | |
219 etc-modules-conf-generic-mode | |
220 etc-passwd-generic-mode | |
221 etc-services-generic-mode | |
87179
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
222 etc-sudoers-generic-mode |
61903 | 223 fvwm-generic-mode |
224 inetd-conf-generic-mode | |
225 mailagent-rules-generic-mode | |
226 mailrc-generic-mode | |
227 named-boot-generic-mode | |
228 named-database-generic-mode | |
229 prototype-generic-mode | |
230 resolve-conf-generic-mode | |
231 samba-generic-mode | |
232 x-resource-generic-mode) | |
233 "List of generic modes that are defined by default on Unix.") | |
234 | |
235 (defconst generic-other-modes | |
236 '(astap-generic-mode | |
237 ibis-generic-mode | |
238 pkginfo-generic-mode | |
239 spice-generic-mode) | |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
240 "List of generic modes that are not defined by default.") |
21205 | 241 |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
242 (defcustom generic-define-mswindows-modes |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
243 (memq system-type '(windows-nt ms-dos)) |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
244 "Non-nil means the modes in `generic-mswindows-modes' will be defined. |
61903 | 245 This is a list of MS-Windows specific generic modes. This variable |
78063
edd7a13f790e
(generic-define-mswindows-modes, generic-define-unix-modes,
Juanma Barranquero <lekktu@gmail.com>
parents:
75347
diff
changeset
|
246 only affects the default value of `generic-extras-enable-list'." |
21205 | 247 :group 'generic-x |
61903 | 248 :type 'boolean |
249 :version "22.1") | |
250 (make-obsolete-variable 'generic-define-mswindows-modes 'generic-extras-enable-list "22.1") | |
21205 | 251 |
252 (defcustom generic-define-unix-modes | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
253 (not (memq system-type '(windows-nt ms-dos))) |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
254 "Non-nil means the modes in `generic-unix-modes' will be defined. |
61903 | 255 This is a list of Unix specific generic modes. This variable only |
78063
edd7a13f790e
(generic-define-mswindows-modes, generic-define-unix-modes,
Juanma Barranquero <lekktu@gmail.com>
parents:
75347
diff
changeset
|
256 affects the default value of `generic-extras-enable-list'." |
21205 | 257 :group 'generic-x |
61903 | 258 :type 'boolean |
259 :version "22.1") | |
260 (make-obsolete-variable 'generic-define-unix-modes 'generic-extras-enable-list "22.1") | |
21205 | 261 |
61903 | 262 (defcustom generic-extras-enable-list |
263 (append generic-default-modes | |
264 (if generic-define-mswindows-modes generic-mswindows-modes) | |
265 (if generic-define-unix-modes generic-unix-modes) | |
266 nil) | |
267 "List of generic modes to define. | |
268 Each entry in the list should be a symbol. If you set this variable | |
269 directly, without using customize, you must reload generic-x to put | |
270 your changes into effect." | |
271 :group 'generic-x | |
272 :type (let (list) | |
273 (dolist (mode | |
274 (sort (append generic-default-modes | |
275 generic-mswindows-modes | |
276 generic-unix-modes | |
277 generic-other-modes | |
278 nil) | |
279 (lambda (a b) | |
280 (string< (symbol-name b) | |
281 (symbol-name a)))) | |
282 (cons 'set list)) | |
283 (push `(const ,mode) list))) | |
284 :set (lambda (s v) | |
285 (set-default s v) | |
286 (unless load-in-progress | |
287 (load "generic-x"))) | |
288 :version "22.1") | |
21205 | 289 |
290 ;;; Apache | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
291 (when (memq 'apache-conf-generic-mode generic-extras-enable-list) |
21205 | 292 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
293 (define-generic-mode apache-conf-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
294 '(?#) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
295 nil |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
296 '(("^\\s-*\\(<.*>\\)" 1 font-lock-constant-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
297 ("^\\s-*\\(\\sw+\\)\\s-" 1 font-lock-variable-name-face)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
298 '("srm\\.conf\\'" "httpd\\.conf\\'" "access\\.conf\\'") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
299 (list |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
300 (function |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
301 (lambda () |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
302 (setq imenu-generic-expression |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
303 '((nil "^\\([-A-Za-z0-9_]+\\)" 1) |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
304 ("*Directories*" "^\\s-*<Directory\\s-*\\([^>]+\\)>" 1) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
305 ("*Locations*" "^\\s-*<Location\\s-*\\([^>]+\\)>" 1)))))) |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
306 "Generic mode for Apache or HTTPD configuration files.")) |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
307 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
308 (when (memq 'apache-log-generic-mode generic-extras-enable-list) |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
309 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
310 (define-generic-mode apache-log-generic-mode |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
311 nil |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
312 nil |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
313 ;; Hostname ? user date request return-code number-of-bytes |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
314 '(("^\\([-a-zA-z0-9.]+\\) - [-A-Za-z]+ \\(\\[.*\\]\\)" |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
315 (1 font-lock-constant-face) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
316 (2 font-lock-variable-name-face))) |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
317 '("access_log\\'") |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
318 nil |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
319 "Generic mode for Apache log files.")) |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
320 |
21205 | 321 ;;; Samba |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
322 (when (memq 'samba-generic-mode generic-extras-enable-list) |
21205 | 323 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
324 (define-generic-mode samba-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
325 '(?\; ?#) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
326 nil |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
327 '(("^\\(\\[.*\\]\\)" 1 font-lock-constant-face) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
328 ("^\\s-*\\(.+\\)=\\([^\r\n]*\\)" |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
329 (1 font-lock-variable-name-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
330 (2 font-lock-type-face))) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
331 '("smb\\.conf\\'") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
332 '(generic-bracket-support) |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
333 "Generic mode for Samba configuration files.")) |
21205 | 334 |
335 ;;; Fvwm | |
336 ;; This is pretty basic. Also, modes for other window managers could | |
337 ;; be defined as well. | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
338 (when (memq 'fvwm-generic-mode generic-extras-enable-list) |
21205 | 339 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
340 (define-generic-mode fvwm-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
341 '(?#) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
342 '("AddToMenu" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
343 "AddToFunc" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
344 "ButtonStyle" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
345 "EndFunction" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
346 "EndPopup" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
347 "Function" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
348 "IconPath" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
349 "Key" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
350 "ModulePath" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
351 "Mouse" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
352 "PixmapPath" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
353 "Popup" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
354 "Style") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
355 nil |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
356 '("\\.fvwmrc\\'" "\\.fvwm2rc\\'") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
357 nil |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
358 "Generic mode for FVWM configuration files.")) |
21205 | 359 |
360 ;;; X Resource | |
361 ;; I'm pretty sure I've seen an actual mode to do this, but I don't | |
362 ;; think it's standard with Emacs | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
363 (when (memq 'x-resource-generic-mode generic-extras-enable-list) |
21205 | 364 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
365 (define-generic-mode x-resource-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
366 '(?!) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
367 nil |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
368 '(("^\\([^:\n]+:\\)" 1 font-lock-variable-name-face)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
369 '("\\.Xdefaults\\'" "\\.Xresources\\'" "\\.Xenvironment\\'" "\\.ad\\'") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
370 nil |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
371 "Generic mode for X Resource configuration files.")) |
21205 | 372 |
373 ;;; Hosts | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
374 (when (memq 'hosts-generic-mode generic-extras-enable-list) |
21205 | 375 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
376 (define-generic-mode hosts-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
377 '(?#) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
378 '("localhost") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
379 '(("\\([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+\\)" 1 font-lock-constant-face)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
380 '("[hH][oO][sS][tT][sS]\\'") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
381 nil |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
382 "Generic mode for HOSTS files.")) |
21205 | 383 |
384 ;;; Windows INF files | |
86483
99a67ed52eaa
(ini-generic-mode): Declare as a function.
Glenn Morris <rgm@gnu.org>
parents:
86290
diff
changeset
|
385 |
99a67ed52eaa
(ini-generic-mode): Declare as a function.
Glenn Morris <rgm@gnu.org>
parents:
86290
diff
changeset
|
386 ;; If i-g-m-f-f-h is defined, then so is i-g-m. |
99a67ed52eaa
(ini-generic-mode): Declare as a function.
Glenn Morris <rgm@gnu.org>
parents:
86290
diff
changeset
|
387 (declare-function ini-generic-mode "generic-x") |
99a67ed52eaa
(ini-generic-mode): Declare as a function.
Glenn Morris <rgm@gnu.org>
parents:
86290
diff
changeset
|
388 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
389 (when (memq 'inf-generic-mode generic-extras-enable-list) |
21205 | 390 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
391 (define-generic-mode inf-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
392 '(?\;) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
393 nil |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
394 '(("^\\(\\[.*\\]\\)" 1 font-lock-constant-face)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
395 '("\\.[iI][nN][fF]\\'") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
396 '(generic-bracket-support) |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
397 "Generic mode for MS-Windows INF files.")) |
21205 | 398 |
399 ;;; Windows INI files | |
400 ;; Should define escape character as well! | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
401 (when (memq 'ini-generic-mode generic-extras-enable-list) |
21205 | 402 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
403 (define-generic-mode ini-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
404 '(?\;) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
405 nil |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
406 '(("^\\(\\[.*\\]\\)" 1 font-lock-constant-face) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
407 ("^\\([^=\n\r]*\\)=\\([^\n\r]*\\)$" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
408 (1 font-lock-function-name-face) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
409 (2 font-lock-variable-name-face))) |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
410 '("\\.[iI][nN][iI]\\'") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
411 (list |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
412 (function |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
413 (lambda () |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
414 (setq imenu-generic-expression |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
415 '((nil "^\\[\\(.*\\)\\]" 1) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
416 ("*Variables*" "^\\s-*\\([^=]+\\)\\s-*=" 1)))))) |
61523
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
417 "Generic mode for MS-Windows INI files. |
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
418 You can use `ini-generic-mode-find-file-hook' to enter this mode |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
419 automatically for INI files whose names do not end in \".ini\".") |
61523
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
420 |
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
421 (defun ini-generic-mode-find-file-hook () |
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
422 "Hook function to enter Ini-Generic mode automatically for INI files. |
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
423 Done if the first few lines of a file in Fundamental mode look |
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
424 like an INI file. You can add this hook to `find-file-hook'." |
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
425 (and (eq major-mode 'fundamental-mode) |
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
426 (save-excursion |
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
427 (goto-char (point-min)) |
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
428 (and (looking-at "^\\s-*\\[.*\\]") |
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
429 (ini-generic-mode))))) |
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
430 (defalias 'generic-mode-ini-file-find-file-hook 'ini-generic-mode-find-file-hook)) |
21205 | 431 |
432 ;;; Windows REG files | |
433 ;;; Unfortunately, Windows 95 and Windows NT have different REG file syntax! | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
434 (when (memq 'reg-generic-mode generic-extras-enable-list) |
21205 | 435 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
436 (define-generic-mode reg-generic-mode |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
437 '(?\;) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
438 '("key" "classes_root" "REGEDIT" "REGEDIT4") |
69265
268da31ddfc5
(reg-generic-mode): Quote "]"s in regexps when they have no special meaning.
Eli Zaretskii <eliz@gnu.org>
parents:
68651
diff
changeset
|
439 '(("\\(\\[.*\\]\\)" 1 font-lock-constant-face) |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
440 ("^\\([^\n\r]*\\)\\s-*=" 1 font-lock-variable-name-face)) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
441 '("\\.[rR][eE][gG]\\'") |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
442 (list |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
443 (function |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
444 (lambda () |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
445 (setq imenu-generic-expression |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
446 '((nil "^\\s-*\\(.*\\)\\s-*=" 1)))))) |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
447 "Generic mode for MS-Windows Registry files.")) |
21205 | 448 |
86290
9ddedad1a7b2
*** empty log message ***
Dan Nicolaescu <dann@ics.uci.edu>
parents:
86265
diff
changeset
|
449 (declare-function w32-shell-name "w32-fns" ()) |
9ddedad1a7b2
*** empty log message ***
Dan Nicolaescu <dann@ics.uci.edu>
parents:
86265
diff
changeset
|
450 |
23375
2656333fd35e
(bat-generic-mode): Fix regexps for keywords and
Eli Zaretskii <eliz@gnu.org>
parents:
22110
diff
changeset
|
451 ;;; DOS/Windows BAT files |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
452 (when (memq 'bat-generic-mode generic-extras-enable-list) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
453 |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
454 (define-generic-mode bat-generic-mode |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
455 nil |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
456 nil |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
457 (eval-when-compile |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
458 (list |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
459 ;; Make this one first in the list, otherwise comments will |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
460 ;; be over-written by other variables |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
461 '("^[@ \t]*\\([rR][eE][mM][^\n\r]*\\)" 1 font-lock-comment-face t) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
462 '("^[ \t]*\\(::.*\\)" 1 font-lock-comment-face t) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
463 '("^[@ \t]*\\([bB][rR][eE][aA][kK]\\|[vV][eE][rR][iI][fF][yY]\\)[ \t]+\\([oO]\\([nN]\\|[fF][fF]\\)\\)" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
464 (1 font-lock-builtin-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
465 (2 font-lock-constant-face t t)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
466 ;; Any text (except ON/OFF) following ECHO is a string. |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
467 '("^[@ \t]*\\([eE][cC][hH][oO]\\)[ \t]+\\(\\([oO]\\([nN]\\|[fF][fF]\\)\\)\\|\\([^>|\r\n]+\\)\\)" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
468 (1 font-lock-builtin-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
469 (3 font-lock-constant-face t t) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
470 (5 font-lock-string-face t t)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
471 ;; These keywords appear as the first word on a line. (Actually, they |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
472 ;; can also appear after "if ..." or "for ..." clause, but since they |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
473 ;; are frequently used in simple text, we punt.) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
474 ;; In `generic-bat-mode-setup-function' we make the keywords |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
475 ;; case-insensitive |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
476 (generic-make-keywords-list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
477 '("for" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
478 "if") |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
479 font-lock-keyword-face "^[@ \t]*") |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
480 ;; These keywords can be anywhere on a line |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
481 ;; In `generic-bat-mode-setup-function' we make the keywords |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
482 ;; case-insensitive |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
483 (generic-make-keywords-list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
484 '("do" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
485 "exist" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
486 "errorlevel" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
487 "goto" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
488 "not") |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
489 font-lock-keyword-face) |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
490 ;; These are built-in commands. Only frequently-used ones are listed. |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
491 (generic-make-keywords-list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
492 '("CALL" "call" "Call" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
493 "CD" "cd" "Cd" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
494 "CLS" "cls" "Cls" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
495 "COPY" "copy" "Copy" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
496 "DEL" "del" "Del" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
497 "ECHO" "echo" "Echo" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
498 "MD" "md" "Md" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
499 "PATH" "path" "Path" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
500 "PAUSE" "pause" "Pause" |
62436 | 501 "PROMPT" "prompt" "Prompt" |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
502 "RD" "rd" "Rd" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
503 "REN" "ren" "Ren" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
504 "SET" "set" "Set" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
505 "START" "start" "Start" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
506 "SHIFT" "shift" "Shift") |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
507 font-lock-builtin-face "[ \t|\n]") |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
508 '("^[ \t]*\\(:\\sw+\\)" 1 font-lock-function-name-face t) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
509 '("\\(%\\sw+%\\)" 1 font-lock-variable-name-face t) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
510 '("\\(%[0-9]\\)" 1 font-lock-variable-name-face t) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
511 '("\\(/[^/ \"\t\n]+\\)" 1 font-lock-type-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
512 '("[\t ]+\\([+-][^\t\n\" ]+\\)" 1 font-lock-type-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
513 '("[ \t\n|]\\<\\([gG][oO][tT][oO]\\)\\>[ \t]*\\(\\sw+\\)?" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
514 (1 font-lock-keyword-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
515 (2 font-lock-function-name-face nil t)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
516 '("[ \t\n|]\\<\\([sS][eE][tT]\\)\\>[ \t]*\\(\\sw+\\)?[ \t]*=?" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
517 (1 font-lock-builtin-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
518 (2 font-lock-variable-name-face t t)))) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
519 '("\\.[bB][aA][tT]\\'" |
71434
91d47fb65033
(bat-generic-mode): Support .cmd files.
Eli Zaretskii <eliz@gnu.org>
parents:
69265
diff
changeset
|
520 "\\.[cC][mM][dD]\\'" |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
521 "\\`[cC][oO][nN][fF][iI][gG]\\." |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
522 "\\`[aA][uU][tT][oO][eE][xX][eE][cC]\\.") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
523 '(generic-bat-mode-setup-function) |
71434
91d47fb65033
(bat-generic-mode): Support .cmd files.
Eli Zaretskii <eliz@gnu.org>
parents:
69265
diff
changeset
|
524 "Generic mode for MS-Windows batch files.") |
26045
03ebfe42764f
(bat-generic-mode-keymap): Added thio variable
Peter Breton <pbreton@attbi.com>
parents:
26044
diff
changeset
|
525 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
526 (defvar bat-generic-mode-syntax-table nil |
61903 | 527 "Syntax table in use in `bat-generic-mode' buffers.") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
528 |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
529 (defvar bat-generic-mode-keymap (make-sparse-keymap) |
78063
edd7a13f790e
(generic-define-mswindows-modes, generic-define-unix-modes,
Juanma Barranquero <lekktu@gmail.com>
parents:
75347
diff
changeset
|
530 "Keymap for `bat-generic-mode'.") |
26045
03ebfe42764f
(bat-generic-mode-keymap): Added thio variable
Peter Breton <pbreton@attbi.com>
parents:
26044
diff
changeset
|
531 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
532 (defun bat-generic-mode-compile () |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
533 "Run the current BAT file in a compilation buffer." |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
534 (interactive) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
535 (let ((compilation-buffer-name-function |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
536 (function |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
537 (lambda(ign) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
538 (concat "*" (buffer-file-name) "*"))))) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
539 (compile |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
540 (concat (w32-shell-name) " -c " (buffer-file-name))))) |
26045
03ebfe42764f
(bat-generic-mode-keymap): Added thio variable
Peter Breton <pbreton@attbi.com>
parents:
26044
diff
changeset
|
541 |
61523
0428c421c463
(generic-mode-ini-file-find-file-hook):
Lute Kamstra <lute@gnu.org>
parents:
61490
diff
changeset
|
542 (eval-when-compile (require 'comint)) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
543 (defun bat-generic-mode-run-as-comint () |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
544 "Run the current BAT file in a comint buffer." |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
545 (interactive) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
546 (require 'comint) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
547 (let* ((file (buffer-file-name)) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
548 (buf-name (concat "*" file "*"))) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
549 (save-excursion |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
550 (set-buffer |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
551 (get-buffer-create buf-name)) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
552 (erase-buffer) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
553 (comint-mode) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
554 (comint-exec |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
555 buf-name |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
556 file |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
557 (w32-shell-name) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
558 nil |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
559 (list "-c" file)) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
560 (display-buffer buf-name)))) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
561 |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
562 (define-key bat-generic-mode-keymap "\C-c\C-c" 'bat-generic-mode-compile) |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
563 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
564 ;; Make underscores count as words |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
565 (unless bat-generic-mode-syntax-table |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
566 (setq bat-generic-mode-syntax-table (make-syntax-table)) |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
567 (modify-syntax-entry ?_ "w" bat-generic-mode-syntax-table)) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
568 |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
569 ;; bat-generic-mode doesn't use the comment functionality of |
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
570 ;; define-generic-mode because it has a three-letter comment-string, |
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
571 ;; so we do it here manually instead |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
572 (defun generic-bat-mode-setup-function () |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
573 (make-local-variable 'parse-sexp-ignore-comments) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
574 (make-local-variable 'comment-start) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
575 (make-local-variable 'comment-start-skip) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
576 (make-local-variable 'comment-end) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
577 (setq imenu-generic-expression '((nil "^:\\(\\sw+\\)" 1)) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
578 parse-sexp-ignore-comments t |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
579 comment-end "" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
580 comment-start "REM " |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
581 comment-start-skip "[Rr][Ee][Mm] *") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
582 (set-syntax-table bat-generic-mode-syntax-table) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
583 ;; Make keywords case-insensitive |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
584 (setq font-lock-defaults '(generic-font-lock-keywords nil t)) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
585 (use-local-map bat-generic-mode-keymap))) |
21205 | 586 |
587 ;;; Mailagent | |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
588 ;; Mailagent is a Unix mail filtering program. Anyone wanna do a |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
589 ;; generic mode for procmail? |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
590 (when (memq 'mailagent-rules-generic-mode generic-extras-enable-list) |
21205 | 591 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
592 (define-generic-mode mailagent-rules-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
593 '(?#) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
594 '("SAVE" "DELETE" "PIPE" "ANNOTATE" "REJECT") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
595 '(("^\\(\\sw+\\)\\s-*=" 1 font-lock-variable-name-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
596 ("\\s-/\\([^/]+\\)/[i, \t\n]" 1 font-lock-constant-face)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
597 '("\\.rules\\'") |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
598 (list |
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
599 (function |
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
600 (lambda () |
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
601 (setq imenu-generic-expression |
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
602 '((nil "\\s-/\\([^/]+\\)/[i, \t\n]" 1)))))) |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
603 "Generic mode for Mailagent rules files.")) |
21205 | 604 |
605 ;; Solaris/Sys V prototype files | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
606 (when (memq 'prototype-generic-mode generic-extras-enable-list) |
21205 | 607 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
608 (define-generic-mode prototype-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
609 '(?#) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
610 nil |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
611 '(("^\\([0-9]\\)?\\s-*\\([a-z]\\)\\s-+\\([A-Za-z_]+\\)\\s-+\\([^\n\r]*\\)$" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
612 (2 font-lock-constant-face) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
613 (3 font-lock-keyword-face)) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
614 ("^\\([a-z]\\) \\([A-Za-z_]+\\)=\\([^\n\r]*\\)$" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
615 (1 font-lock-constant-face) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
616 (2 font-lock-keyword-face) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
617 (3 font-lock-variable-name-face)) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
618 ("^\\(!\\s-*\\(search\\|include\\|default\\)\\)\\s-*\\([^\n\r]*\\)$" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
619 (1 font-lock-keyword-face) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
620 (3 font-lock-variable-name-face)) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
621 ("^\\(!\\s-*\\sw+\\)=\\([^\n\r]*\\)$" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
622 (1 font-lock-keyword-face) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
623 (2 font-lock-variable-name-face))) |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
624 '("prototype\\'") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
625 nil |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
626 "Generic mode for Sys V prototype files.")) |
21205 | 627 |
628 ;; Solaris/Sys V pkginfo files | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
629 (when (memq 'pkginfo-generic-mode generic-extras-enable-list) |
21205 | 630 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
631 (define-generic-mode pkginfo-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
632 '(?#) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
633 nil |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
634 '(("^\\([A-Za-z_]+\\)=\\([^\n\r]*\\)$" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
635 (1 font-lock-keyword-face) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
636 (2 font-lock-variable-name-face))) |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
637 '("pkginfo\\'") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
638 nil |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
639 "Generic mode for Sys V pkginfo files.")) |
21205 | 640 |
641 ;; Javascript mode | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
642 ;; Includes extra keywords from Armando Singer [asinger@MAIL.COLGATE.EDU] |
61903 | 643 (when (memq 'javascript-generic-mode generic-extras-enable-list) |
644 | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
645 (define-generic-mode javascript-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
646 '("//" ("/*" . "*/")) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
647 '("break" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
648 "case" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
649 "continue" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
650 "default" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
651 "delete" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
652 "do" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
653 "else" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
654 "export" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
655 "for" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
656 "function" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
657 "if" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
658 "import" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
659 "in" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
660 "new" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
661 "return" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
662 "switch" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
663 "this" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
664 "typeof" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
665 "var" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
666 "void" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
667 "while" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
668 "with" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
669 ;; words reserved for ECMA extensions below |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
670 "catch" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
671 "class" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
672 "const" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
673 "debugger" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
674 "enum" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
675 "extends" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
676 "finally" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
677 "super" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
678 "throw" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
679 "try" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
680 ;; Java Keywords reserved by JavaScript |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
681 "abstract" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
682 "boolean" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
683 "byte" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
684 "char" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
685 "double" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
686 "false" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
687 "final" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
688 "float" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
689 "goto" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
690 "implements" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
691 "instanceof" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
692 "int" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
693 "interface" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
694 "long" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
695 "native" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
696 "null" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
697 "package" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
698 "private" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
699 "protected" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
700 "public" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
701 "short" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
702 "static" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
703 "synchronized" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
704 "throws" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
705 "transient" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
706 "true") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
707 '(("^\\s-*function\\s-+\\([A-Za-z0-9_]+\\)" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
708 (1 font-lock-function-name-face)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
709 ("^\\s-*var\\s-+\\([A-Za-z0-9_]+\\)" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
710 (1 font-lock-variable-name-face))) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
711 '("\\.js\\'") |
21205 | 712 (list |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
713 (function |
21205 | 714 (lambda () |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
715 (setq imenu-generic-expression |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
716 '((nil "^function\\s-+\\([A-Za-z0-9_]+\\)" 1) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
717 ("*Variables*" "^var\\s-+\\([A-Za-z0-9_]+\\)" 1)))))) |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
718 "Generic mode for JavaScript files.")) |
21205 | 719 |
720 ;; VRML files | |
61903 | 721 (when (memq 'vrml-generic-mode generic-extras-enable-list) |
722 | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
723 (define-generic-mode vrml-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
724 '(?#) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
725 '("DEF" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
726 "NULL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
727 "USE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
728 "Viewpoint" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
729 "ambientIntensity" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
730 "appearance" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
731 "children" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
732 "color" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
733 "coord" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
734 "coordIndex" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
735 "creaseAngle" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
736 "diffuseColor" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
737 "emissiveColor" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
738 "fieldOfView" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
739 "geometry" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
740 "info" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
741 "material" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
742 "normal" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
743 "orientation" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
744 "position" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
745 "shininess" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
746 "specularColor" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
747 "texCoord" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
748 "texture" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
749 "textureTransform" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
750 "title" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
751 "transparency" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
752 "type") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
753 '(("USE\\s-+\\([-A-Za-z0-9_]+\\)" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
754 (1 font-lock-constant-face)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
755 ("DEF\\s-+\\([-A-Za-z0-9_]+\\)\\s-+\\([A-Za-z0-9]+\\)\\s-*{" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
756 (1 font-lock-type-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
757 (2 font-lock-constant-face)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
758 ("^\\s-*\\([-A-Za-z0-9_]+\\)\\s-*{" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
759 (1 font-lock-function-name-face)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
760 ("^\\s-*\\(geometry\\|appearance\\|material\\)\\s-+\\([-A-Za-z0-9_]+\\)" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
761 (2 font-lock-variable-name-face))) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
762 '("\\.wrl\\'") |
21205 | 763 (list |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
764 (function |
21205 | 765 (lambda () |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
766 (setq imenu-generic-expression |
21205 | 767 '((nil "^\\([A-Za-z0-9_]+\\)\\s-*{" 1) |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
768 ("*Definitions*" |
21205 | 769 "DEF\\s-+\\([-A-Za-z0-9_]+\\)\\s-+\\([A-Za-z0-9]+\\)\\s-*{" |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
770 1)))))) |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
771 "Generic Mode for VRML files.")) |
21205 | 772 |
773 ;; Java Manifests | |
61903 | 774 (when (memq 'java-manifest-generic-mode generic-extras-enable-list) |
775 | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
776 (define-generic-mode java-manifest-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
777 '(?#) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
778 '("Name" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
779 "Digest-Algorithms" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
780 "Manifest-Version" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
781 "Required-Version" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
782 "Signature-Version" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
783 "Magic" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
784 "Java-Bean" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
785 "Depends-On") |
21205 | 786 '(("^Name:\\s-+\\([^\n\r]*\\)$" |
787 (1 font-lock-variable-name-face)) | |
788 ("^\\(Manifest\\|Required\\|Signature\\)-Version:\\s-+\\([^\n\r]*\\)$" | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
789 (2 font-lock-constant-face))) |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
790 '("[mM][aA][nN][iI][fF][eE][sS][tT]\\.[mM][fF]\\'") |
21205 | 791 nil |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
792 "Generic mode for Java Manifest files.")) |
21205 | 793 |
794 ;; Java properties files | |
61903 | 795 (when (memq 'java-properties-generic-mode generic-extras-enable-list) |
796 | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
797 (define-generic-mode java-properties-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
798 '(?! ?#) |
21205 | 799 nil |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
800 (eval-when-compile |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
801 (let ((java-properties-key |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
802 "\\(\\([-A-Za-z0-9_\\./]\\|\\(\\\\[ =:]\\)\\)+\\)") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
803 (java-properties-value |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
804 "\\([^\r\n]*\\)")) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
805 ;; Property and value can be separated in a number of different ways: |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
806 ;; * whitespace |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
807 ;; * an equal sign |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
808 ;; * a colon |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
809 (mapcar |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
810 (function |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
811 (lambda (elt) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
812 (list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
813 (concat "^" java-properties-key elt java-properties-value "$") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
814 '(1 font-lock-constant-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
815 '(4 font-lock-variable-name-face)))) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
816 ;; These are the separators |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
817 '(":\\s-*" "\\s-+" "\\s-*=\\s-*")))) |
21205 | 818 nil |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
819 (list |
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
820 (function |
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
821 (lambda () |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
822 (setq imenu-generic-expression |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
823 '((nil "^\\([^#! \t\n\r=:]+\\)" 1)))))) |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
824 "Generic mode for Java properties files.")) |
21205 | 825 |
826 ;; C shell alias definitions | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
827 (when (memq 'alias-generic-mode generic-extras-enable-list) |
21947
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
828 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
829 (define-generic-mode alias-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
830 '(?#) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
831 '("alias" "unalias") |
21205 | 832 '(("^alias\\s-+\\([-A-Za-z0-9_]+\\)\\s-+" |
833 (1 font-lock-variable-name-face)) | |
834 ("^unalias\\s-+\\([-A-Za-z0-9_]+\\)\\s-*$" | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
835 (1 font-lock-variable-name-face))) |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
836 '("alias\\'") |
21205 | 837 (list |
838 (function | |
839 (lambda () | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
840 (setq imenu-generic-expression |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
841 '((nil "^\\(alias\\|unalias\\)\\s-+\\([-a-zA-Z0-9_]+\\)" 2)))))) |
98343
09db47fa2c88
* generic-x.el (generic-other-modes): Fix typo in docstring.
Juanma Barranquero <lekktu@gmail.com>
parents:
94678
diff
changeset
|
842 "Generic mode for C Shell alias files.")) |
21205 | 843 |
844 ;;; Windows RC files | |
845 ;; Contributed by ACorreir@pervasive-sw.com (Alfred Correira) | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
846 (when (memq 'rc-generic-mode generic-extras-enable-list) |
21205 | 847 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
848 (define-generic-mode rc-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
849 ;; '(?\/) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
850 '("//") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
851 '("ACCELERATORS" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
852 "AUTO3STATE" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
853 "AUTOCHECKBOX" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
854 "AUTORADIOBUTTON" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
855 "BITMAP" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
856 "BOTTOMMARGIN" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
857 "BUTTON" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
858 "CAPTION" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
859 "CHARACTERISTICS" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
860 "CHECKBOX" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
861 "CLASS" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
862 "COMBOBOX" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
863 "CONTROL" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
864 "CTEXT" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
865 "CURSOR" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
866 "DEFPUSHBUTTON" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
867 "DESIGNINFO" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
868 "DIALOG" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
869 "DISCARDABLE" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
870 "EDITTEXT" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
871 "EXSTYLE" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
872 "FONT" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
873 "GROUPBOX" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
874 "GUIDELINES" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
875 "ICON" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
876 "LANGUAGE" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
877 "LEFTMARGIN" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
878 "LISTBOX" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
879 "LTEXT" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
880 "MENUITEM SEPARATOR" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
881 "MENUITEM" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
882 "MENU" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
883 "MOVEABLE" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
884 "POPUP" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
885 "PRELOAD" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
886 "PURE" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
887 "PUSHBOX" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
888 "PUSHBUTTON" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
889 "RADIOBUTTON" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
890 "RCDATA" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
891 "RIGHTMARGIN" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
892 "RTEXT" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
893 "SCROLLBAR" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
894 "SEPARATOR" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
895 "STATE3" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
896 "STRINGTABLE" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
897 "STYLE" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
898 "TEXTINCLUDE" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
899 "TOOLBAR" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
900 "TOPMARGIN" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
901 "VERSIONINFO" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
902 "VERSION") |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
903 ;; the choice of what tokens go where is somewhat arbitrary, |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
904 ;; as is the choice of which value tokens are included, as |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
905 ;; the choice of face for each token group |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
906 (eval-when-compile |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
907 (list |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
908 (generic-make-keywords-list |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
909 '("FILEFLAGSMASK" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
910 "FILEFLAGS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
911 "FILEOS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
912 "FILESUBTYPE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
913 "FILETYPE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
914 "FILEVERSION" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
915 "PRODUCTVERSION") |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
916 font-lock-type-face) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
917 (generic-make-keywords-list |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
918 '("BEGIN" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
919 "BLOCK" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
920 "END" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
921 "VALUE") |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
922 font-lock-function-name-face) |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
923 '("^#[ \t]*include[ \t]+\\(<[^>\"\n]+>\\)" 1 font-lock-string-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
924 '("^#[ \t]*define[ \t]+\\(\\sw+\\)(" 1 font-lock-function-name-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
925 '("^#[ \t]*\\(elif\\|if\\)\\>" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
926 ("\\<\\(defined\\)\\>[ \t]*(?\\(\\sw+\\)?" nil nil |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
927 (1 font-lock-constant-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
928 (2 font-lock-variable-name-face nil t))) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
929 '("^#[ \t]*\\(\\sw+\\)\\>[ \t]*\\(\\sw+\\)?" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
930 (1 font-lock-constant-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
931 (2 font-lock-variable-name-face nil t)))) |
61490
e51a703b6762
(rc-generic-mode, rul-generic-mode): Fix auto-mode-alist entries.
Lute Kamstra <lute@gnu.org>
parents:
61456
diff
changeset
|
932 '("\\.[rR][cC]\\'") |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
933 nil |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
934 "Generic mode for MS-Windows Resource files.")) |
21205 | 935 |
21947
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
936 ;; InstallShield RUL files |
21205 | 937 ;; Contributed by Alfred.Correira@Pervasive.Com |
50265
e8baa2ffdd8f
Use fixes to rul-generic-mode, contributed by "Rolf Sandau" <Rolf.Sandau@marconi.com>
Peter Breton <pbreton@attbi.com>
parents:
48791
diff
changeset
|
938 ;; Bugfixes by "Rolf Sandau" <Rolf.Sandau@marconi.com> |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
939 (when (memq 'rul-generic-mode generic-extras-enable-list) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
940 |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
941 (eval-when-compile |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
942 |
21947
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
943 ;;; build the regexp strings using regexp-opt |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
944 (defconst installshield-statement-keyword-list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
945 '("abort" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
946 "begin" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
947 "call" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
948 "case" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
949 "declare" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
950 "default" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
951 "downto" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
952 "elseif" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
953 "else" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
954 "endfor" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
955 "endif" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
956 "endswitch" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
957 "endwhile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
958 "end" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
959 "exit" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
960 "external" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
961 "for" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
962 "function" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
963 ;; "goto" -- handled elsewhere |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
964 "if" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
965 "program" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
966 "prototype" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
967 "repeat" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
968 "return" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
969 "step" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
970 "switch" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
971 "then" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
972 "to" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
973 "typedef" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
974 "until" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
975 "void" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
976 "while") |
21947
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
977 "Statement keywords used in InstallShield 3 and 5.") |
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
978 |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
979 (defconst installshield-system-functions-list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
980 '("AddFolderIcon" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
981 "AddProfString" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
982 "AddressString" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
983 "AppCommand" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
984 "AskDestPath" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
985 "AskOptions" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
986 "AskPath" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
987 "AskText" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
988 "AskYesNo" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
989 "BatchDeleteEx" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
990 "BatchFileLoad" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
991 "BatchFileSave" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
992 "BatchFind" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
993 "BatchGetFileName" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
994 "BatchMoveEx" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
995 "BatchSetFileName" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
996 "ChangeDirectory" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
997 "CloseFile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
998 "CmdGetHwndDlg" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
999 "ComponentAddItem" ; differs between IS3 and IS5 |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1000 "ComponentCompareSizeRequired" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1001 "ComponentDialog" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1002 "ComponentError" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1003 "ComponentFileEnum" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1004 "ComponentFileInfo" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1005 "ComponentFilterLanguage" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1006 "ComponentFilterOS" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1007 "ComponentGetData" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1008 "ComponentGetItemInfo" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1009 "ComponentGetItemSize" ; differs between IS3 and IS5 |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1010 "ComponentIsItemSelected" ; differs between IS3 and IS5 |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1011 "ComponentListItems" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1012 "ComponentMoveData" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1013 "ComponentSelectItem" ; differs between IS3 and IS5 |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1014 "ComponentSetData" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1015 "ComponentSetItemInfo" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1016 "ComponentSetTarget" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1017 "ComponentSetupTypeEnum" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1018 "ComponentSetupTypeGetData" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1019 "ComponentSetupTypeSet" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1020 "ComponentTotalSize" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1021 "ComponentValidate" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1022 "CompressAdd" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1023 "CompressDel" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1024 "CompressEnum" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1025 "CompressGet" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1026 "CompressInfo" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1027 "CopyFile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1028 "CreateDir" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1029 "CreateFile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1030 "CreateProgramFolder" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1031 "DeinstallSetReference" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1032 "DeinstallStart" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1033 "Delay" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1034 "DeleteDir" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1035 "DeleteFile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1036 "DialogSetInfo" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1037 "Disable" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1038 "DoInstall" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1039 "Do" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1040 "Enable" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1041 "EnterDisk" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1042 "ExistsDir" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1043 "ExistsDisk" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1044 "ExitProgMan" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1045 "EzBatchAddPath" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1046 "EzBatchAddString" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1047 "EzBatchReplace" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1048 "EzConfigAddDriver" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1049 "EzConfigAddString" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1050 "EzConfigGetValue" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1051 "EzConfigSetValue" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1052 "EzDefineDialog" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1053 "FileCompare" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1054 "FileDeleteLine" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1055 "FileGrep" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1056 "FileInsertLine" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1057 "FileSetBeginDefine" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1058 "FileSetEndDefine" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1059 "FileSetPerformEz" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1060 "FileSetPerform" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1061 "FileSetReset" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1062 "FileSetRoot" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1063 "FindAllDirs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1064 "FindAllFiles" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1065 "FindFile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1066 "FindWindow" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1067 "GetDiskSpace" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1068 "GetDisk" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1069 "GetEnvVar" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1070 "GetExtents" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1071 "GetFileInfo" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1072 "GetLine" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1073 "GetProfInt" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1074 "GetProfString" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1075 "GetSystemInfo" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1076 "GetValidDrivesList" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1077 "GetVersion" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1078 "GetWindowHandle" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1079 "InstallationInfo" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1080 "Is" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1081 "LaunchApp" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1082 "LaunchAppAndWait" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1083 "ListAddItem" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1084 "ListAddString" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1085 "ListCount" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1086 "ListCreate" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1087 "ListDestroy" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1088 "ListFindItem" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1089 "ListFindString" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1090 "ListGetFirstItem" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1091 "ListGetFirstString" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1092 "ListGetNextItem" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1093 "ListGetNextString" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1094 "ListReadFromFile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1095 "ListSetCurrentItem" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1096 "ListSetNextItem" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1097 "ListSetNextString" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1098 "ListSetIndex" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1099 "ListWriteToFile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1100 "LongPathToQuote" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1101 "LongPathToShortPath" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1102 "MessageBox" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1103 "NumToStr" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1104 "OpenFileMode" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1105 "OpenFile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1106 "ParsePath" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1107 "PathAdd" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1108 "PathDelete" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1109 "PathFind" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1110 "PathGet" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1111 "PathMove" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1112 "PathSet" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1113 "Path" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1114 "PlaceBitmap" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1115 "PlaceWindow" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1116 "PlayMMedia" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1117 "ProgDefGroupType" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1118 "RegDBCreateKeyEx" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1119 "RegDBDeleteValue" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1120 "RegDBGetItem" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1121 "RegDBKeyExist" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1122 "RegDBSetItem" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1123 "RegDBGetKeyValueEx" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1124 "RegDBSetKeyValueEx" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1125 "RegDBSetDefaultRoot" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1126 "RenameFile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1127 "ReplaceFolderIcon" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1128 "ReplaceProfString" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1129 "SdAskDestPath" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1130 "SdAskOptions" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1131 "SdAskOptionsList" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1132 "SdBitmap" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1133 "SdCloseDlg" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1134 "SdComponentAdvCheckSpace" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1135 "SdComponentAdvInit" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1136 "SdComponentAdvUpdateSpace" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1137 "SdComponentDialog" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1138 "SdComponentDialog2" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1139 "SdComponentDialogAdv" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1140 "SdComponentDialogEx" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1141 "SdComponentDlgCheckSpace" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1142 "SdComponentMult" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1143 "SdConfirmNewDir" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1144 "SdConfirmRegistration" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1145 "SdDiskSpace" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1146 "SdDisplayTopics" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1147 "SdDoStdButton" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1148 "SdEnablement" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1149 "SdError" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1150 "SdFinish" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1151 "SdFinishInit32" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1152 "SdFinishReboot" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1153 "SdGeneralInit" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1154 "SdGetItemName" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1155 "SdGetTextExtent" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1156 "SdGetUserCompanyInfo" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1157 "SdInit" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1158 "SdIsShellExplorer" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1159 "SdIsStdButton" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1160 "SdLicense" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1161 "SdMakeName" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1162 "SdOptionInit" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1163 "SdOptionSetState" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1164 "SdOptionsButtons" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1165 "SdOptionsButtonsInit" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1166 "SdPlugInProductName" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1167 "SdProductName" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1168 "SdRegEnableButton" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1169 "SdRegExEnableButton" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1170 "SdRegisterUser" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1171 "SdRegisterUserEx" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1172 "SdRemoveEndSpace" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1173 "SdSelectFolder" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1174 "SdSetSequentialItems" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1175 "SdSetStatic" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1176 "SdSetupTypeEx" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1177 "SdSetupType" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1178 "SdShowAnyDialog" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1179 "SdShowDlgEdit1" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1180 "SdShowDlgEdit2" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1181 "SdShowDlgEdit3" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1182 "SdShowFileMods" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1183 "SdShowInfoList" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1184 "SdShowMsg" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1185 "SdStartCopy" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1186 "SdUnInit" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1187 "SdUpdateComponentSelection" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1188 "SdWelcome" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1189 "SendMessage" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1190 "SetColor" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1191 "SetFont" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1192 "SetDialogTitle" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1193 "SetDisplayEffect" ; IS5 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1194 "SetFileInfo" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1195 "SetForegroundWindow" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1196 "SetStatusWindow" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1197 "SetTitle" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1198 "SetupType" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1199 "ShowProgramFolder" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1200 "Split" ; IS3 only |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1201 "SprintfBox" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1202 "Sprintf" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1203 "StatusUpdate" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1204 "StrCompare" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1205 "StrFind" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1206 "StrGetTokens" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1207 "StrLength" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1208 "StrRemoveLastSlash" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1209 "StrToLower" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1210 "StrToNum" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1211 "StrToUpper" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1212 "StrSub" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1213 "VarRestore" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1214 "VarSave" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1215 "VerCompare" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1216 "VerGetFileVersion" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1217 "WaitOnDialog" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1218 "Welcome" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1219 "WriteLine" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1220 "WriteProfString" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1221 "XCopyFile") |
21947
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
1222 "System functions defined in InstallShield 3 and 5.") |
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
1223 |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1224 (defconst installshield-system-variables-list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1225 '("BATCH_INSTALL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1226 "CMDLINE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1227 "COMMONFILES" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1228 "CORECOMPONENTHANDLING" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1229 "DIALOGCACHE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1230 "ERRORFILENAME" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1231 "FOLDER_DESKTOP" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1232 "FOLDER_PROGRAMS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1233 "FOLDER_STARTMENU" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1234 "FOLDER_STARTUP" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1235 "INFOFILENAME" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1236 "ISRES" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1237 "ISUSER" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1238 "ISVERSION" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1239 "MEDIA" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1240 "MODE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1241 "PROGRAMFILES" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1242 "SELECTED_LANGUAGE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1243 "SRCDIR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1244 "SRCDISK" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1245 "SUPPORTDIR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1246 "TARGETDIR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1247 "TARGETDISK" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1248 "UNINST" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1249 "WINDIR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1250 "WINDISK" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1251 "WINMAJOR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1252 "WINSYSDIR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1253 "WINSYSDISK") |
21947
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
1254 "System variables used in InstallShield 3 and 5.") |
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
1255 |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1256 (defconst installshield-types-list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1257 '("BOOL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1258 "BYREF" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1259 "CHAR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1260 "HIWORD" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1261 "HWND" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1262 "INT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1263 "LIST" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1264 "LONG" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1265 "LOWORD" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1266 "LPSTR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1267 "NUMBER" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1268 "NUMBERLIST" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1269 "POINTER" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1270 "QUAD" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1271 "RGB" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1272 "SHORT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1273 "STRINGLIST" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1274 "STRING") |
21947
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
1275 "Type keywords used in InstallShield 3 and 5.") |
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
1276 |
18722fb8716f
(generic-x): Added defgroup declaration.
Richard M. Stallman <rms@gnu.org>
parents:
21345
diff
changeset
|
1277 ;;; some might want to skip highlighting these to improve performance |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1278 (defconst installshield-funarg-constants-list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1279 '("AFTER" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1280 "APPEND" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1281 "ALLCONTENTS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1282 "BACKBUTTON" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1283 "BACKGROUNDCAPTION" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1284 "BACKGROUND" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1285 "BACK" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1286 "BASEMEMORY" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1287 "BEFORE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1288 "BIOS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1289 "BITMAPICON" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1290 "BK_BLUE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1291 "BK_GREEN" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1292 "BK_RED" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1293 "BLUE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1294 "BOOTUPDRIVE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1295 "CANCEL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1296 "CDROM_DRIVE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1297 "CDROM" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1298 "CHECKBOX95" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1299 "CHECKBOX" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1300 "CHECKLINE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1301 "CHECKMARK" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1302 "COLORS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1303 "COMMANDEX" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1304 "COMMAND" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1305 "COMP_NORMAL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1306 "COMP_UPDATE_DATE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1307 "COMP_UPDATE_SAME" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1308 "COMP_UPDATE_VERSION" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1309 "COMPACT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1310 "CONTINUE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1311 "CPU" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1312 "CUSTOM" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1313 "DATE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1314 "DEFWINDOWMODE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1315 "DIR_WRITEABLE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1316 "DIRECTORY" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1317 "DISABLE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1318 "DISK_TOTALSPACE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1319 "DISK" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1320 "DLG_OPTIONS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1321 "DLG_PATH" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1322 "DLG_TEXT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1323 "DLG_ASK_YESNO" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1324 "DLG_ENTER_DISK" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1325 "DLG_ERR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1326 "DLG_INFO_ALTIMAGE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1327 "DLG_INFO_CHECKSELECTION" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1328 "DLG_INFO_KUNITS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1329 "DLG_INFO_USEDECIMAL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1330 "DLG_MSG_INFORMATION" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1331 "DLG_MSG_SEVERE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1332 "DLG_MSG_WARNING" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1333 "DLG_STATUS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1334 "DLG_WARNING" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1335 "DLG_USER_CAPTION" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1336 "DRIVE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1337 "ENABLE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1338 "END_OF_FILE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1339 "END_OF_LIST" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1340 "ENVSPACE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1341 "EQUALS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1342 "EXCLUDE_SUBDIR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1343 "EXCLUSIVE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1344 "EXISTS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1345 "EXIT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1346 "EXTENDED_MEMORY" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1347 "EXTENSION_ONLY" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1348 "FAILIFEXISTS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1349 "FALSE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1350 "FEEDBACK_FULL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1351 "FILE_ATTR_ARCHIVED" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1352 "FILE_ATTR_DIRECTORY" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1353 "FILE_ATTR_HIDDEN" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1354 "FILE_ATTR_NORMAL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1355 "FILE_ATTR_READONLY" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1356 "FILE_ATTR_SYSTEM" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1357 "FILE_ATTRIBUTE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1358 "FILE_DATE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1359 "FILE_LINE_LENGTH" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1360 "FILE_MODE_APPEND" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1361 "FILE_MODE_BINARYREADONLY" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1362 "FILE_MODE_BINARY" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1363 "FILE_MODE_NORMAL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1364 "FILE_NO_VERSION" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1365 "FILE_NOT_FOUND" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1366 "FILE_SIZE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1367 "FILE_TIME" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1368 "FILENAME_ONLY" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1369 "FILENAME" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1370 "FIXED_DRIVE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1371 "FOLDER_DESKTOP" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1372 "FOLDER_PROGRAMS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1373 "FOLDER_STARTMENU" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1374 "FOLDER_STARTUP" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1375 "FREEENVSPACE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1376 "FULLWINDOWMODE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1377 "FULL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1378 "FONT_TITLE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1379 "GREATER_THAN" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1380 "GREEN" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1381 "HKEY_CLASSES_ROOT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1382 "HKEY_CURRENT_USER" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1383 "HKEY_LOCAL_MACHINE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1384 "HKEY_USERS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1385 "HOURGLASS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1386 "INCLUDE_SUBDIR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1387 "INDVFILESTATUS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1388 "INFORMATION" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1389 "IS_WINDOWSNT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1390 "IS_WINDOWS95" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1391 "IS_WINDOWS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1392 "IS_WIN32S" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1393 "ISTYPE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1394 "LANGUAGE_DRV" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1395 "LANGUAGE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1396 "LESS_THAN" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1397 "LIST_NULL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1398 "LISTFIRST" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1399 "LISTNEXT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1400 "LOCKEDFILE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1401 "LOGGING" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1402 "LOWER_LEFT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1403 "LOWER_RIGHT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1404 "MAGENTA" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1405 "MOUSE_DRV" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1406 "MOUSE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1407 "NETWORK_DRV" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1408 "NETWORK" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1409 "NEXT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1410 "NONEXCLUSIVE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1411 "NORMALMODE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1412 "NOSET" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1413 "NOTEXISTS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1414 "NOWAIT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1415 "NO" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1416 "OFF" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1417 "ONLYDIR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1418 "ON" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1419 "OSMAJOR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1420 "OSMINOR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1421 "OS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1422 "OTHER_FAILURE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1423 "PARALLEL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1424 "PARTIAL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1425 "PATH_EXISTS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1426 "PATH" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1427 "RED" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1428 "REGDB_APPPATH_DEFAULT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1429 "REGDB_APPPATH" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1430 "REGDB_BINARY" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1431 "REGDB_ERR_CONNECTIONEXISTS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1432 "REGDB_ERR_CORRUPTEDREGSITRY" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1433 "REGDB_ERR_INITIALIZATION" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1434 "REGDB_ERR_INVALIDHANDLE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1435 "REGDB_ERR_INVALIDNAME" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1436 "REGDB_NUMBER" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1437 "REGDB_STRING_EXPAND" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1438 "REGDB_STRING_MULTI" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1439 "REGDB_STRING" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1440 "REGDB_UNINSTALL_NAME" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1441 "REMOTE_DRIVE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1442 "REMOVALE_DRIVE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1443 "REPLACE_ITEM" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1444 "REPLACE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1445 "RESET" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1446 "RESTART" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1447 "ROOT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1448 "SELFREGISTER" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1449 "SERIAL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1450 "SET" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1451 "SEVERE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1452 "SHAREDFILE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1453 "SHARE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1454 "SILENTMODE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1455 "SRCTARGETDIR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1456 "STATUSBAR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1457 "STATUSDLG" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1458 "STATUSOLD" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1459 "STATUS" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1460 "STYLE_NORMAL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1461 "SW_MAXIMIZE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1462 "SW_MINIMIZE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1463 "SW_RESTORE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1464 "SW_SHOW" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1465 "SYS_BOOTMACHINE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1466 "TIME" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1467 "TRUE" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1468 "TYPICAL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1469 "UPPER_LEFT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1470 "UPPER_RIGHT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1471 "VALID_PATH" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1472 "VERSION" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1473 "VIDEO" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1474 "VOLUMELABEL" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1475 "YELLOW" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1476 "YES" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1477 "WAIT" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1478 "WARNING" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1479 "WINMAJOR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1480 "WINMINOR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1481 "WIN32SINSTALLED" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1482 "WIN32SMAJOR" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1483 "WIN32SMINOR") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1484 "Function argument constants used in InstallShield 3 and 5.")) |
21205 | 1485 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1486 (defvar rul-generic-mode-syntax-table nil |
61903 | 1487 "Syntax table to use in `rul-generic-mode' buffers.") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1488 |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1489 (setq rul-generic-mode-syntax-table |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1490 (make-syntax-table c++-mode-syntax-table)) |
50265
e8baa2ffdd8f
Use fixes to rul-generic-mode, contributed by "Rolf Sandau" <Rolf.Sandau@marconi.com>
Peter Breton <pbreton@attbi.com>
parents:
48791
diff
changeset
|
1491 |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1492 (modify-syntax-entry ?\r "> b" rul-generic-mode-syntax-table) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1493 (modify-syntax-entry ?\n "> b" rul-generic-mode-syntax-table) |
50265
e8baa2ffdd8f
Use fixes to rul-generic-mode, contributed by "Rolf Sandau" <Rolf.Sandau@marconi.com>
Peter Breton <pbreton@attbi.com>
parents:
48791
diff
changeset
|
1494 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1495 (modify-syntax-entry ?/ ". 124b" rul-generic-mode-syntax-table) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1496 (modify-syntax-entry ?* ". 23" rul-generic-mode-syntax-table) |
21205 | 1497 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1498 ;; here manually instead |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1499 (defun generic-rul-mode-setup-function () |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1500 (make-local-variable 'parse-sexp-ignore-comments) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1501 (make-local-variable 'comment-start) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1502 (make-local-variable 'comment-start-skip) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1503 (make-local-variable 'comment-end) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1504 (setq imenu-generic-expression |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1505 '((nil "^function\\s-+\\([A-Za-z0-9_]+\\)" 1)) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1506 parse-sexp-ignore-comments t |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1507 comment-end "*/" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1508 comment-start "/*" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1509 ;;; comment-end "" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1510 ;;; comment-start "//" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1511 ;;; comment-start-skip "" |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1512 ) |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1513 ;; (set-syntax-table rul-generic-mode-syntax-table) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1514 (setq font-lock-syntax-table rul-generic-mode-syntax-table)) |
50265
e8baa2ffdd8f
Use fixes to rul-generic-mode, contributed by "Rolf Sandau" <Rolf.Sandau@marconi.com>
Peter Breton <pbreton@attbi.com>
parents:
48791
diff
changeset
|
1515 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1516 ;; moved mode-definition behind defun-definition to be warning-free - 15.11.02/RSan |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1517 (define-generic-mode rul-generic-mode |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1518 ;; Using "/*" and "*/" doesn't seem to be working right |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1519 '("//" ("/*" . "*/" )) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1520 (eval-when-compile installshield-statement-keyword-list) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1521 (eval-when-compile |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1522 (list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1523 ;; preprocessor constructs |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1524 '("#[ \t]*include[ \t]+\\(<[^>\"\n]+>\\)" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1525 1 font-lock-string-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1526 '("#[ \t]*\\(\\sw+\\)\\>[ \t]*\\(\\sw+\\)?" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1527 (1 font-lock-reference-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1528 (2 font-lock-variable-name-face nil t)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1529 ;; indirect string constants |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1530 '("\\(@[A-Za-z][A-Za-z0-9_]+\\)" 1 font-lock-builtin-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1531 ;; gotos |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1532 '("[ \t]*\\(\\sw+:\\)" 1 font-lock-reference-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1533 '("\\<\\(goto\\)\\>[ \t]*\\(\\sw+\\)?" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1534 (1 font-lock-keyword-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1535 (2 font-lock-reference-face nil t)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1536 ;; system variables |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1537 (generic-make-keywords-list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1538 installshield-system-variables-list |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1539 font-lock-variable-name-face "[^_]" "[^_]") |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1540 ;; system functions |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1541 (generic-make-keywords-list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1542 installshield-system-functions-list |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1543 font-lock-function-name-face "[^_]" "[^_]") |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1544 ;; type keywords |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1545 (generic-make-keywords-list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1546 installshield-types-list |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1547 font-lock-type-face "[^_]" "[^_]") |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1548 ;; function argument constants |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1549 (generic-make-keywords-list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1550 installshield-funarg-constants-list |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1551 font-lock-variable-name-face "[^_]" "[^_]"))) ; is this face the best choice? |
61490
e51a703b6762
(rc-generic-mode, rul-generic-mode): Fix auto-mode-alist entries.
Lute Kamstra <lute@gnu.org>
parents:
61456
diff
changeset
|
1552 '("\\.[rR][uU][lL]\\'") |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1553 '(generic-rul-mode-setup-function) |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1554 "Generic mode for InstallShield RUL files.") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1555 |
21205 | 1556 (define-skeleton rul-if |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1557 "Insert an if statement." |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1558 "condition: " |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1559 "if(" str ") then" \n |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1560 > _ \n |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1561 ( "other condition, %s: " |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1562 > "elseif(" str ") then" \n |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1563 > \n) |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1564 > "else" \n |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1565 > \n |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1566 resume: |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1567 > "endif;") |
21205 | 1568 |
1569 (define-skeleton rul-function | |
1570 "Insert a function statement." | |
1571 "function: " | |
1572 "function " str " ()" \n | |
1573 ( "local variables, %s: " | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1574 > " " str ";" \n) |
21205 | 1575 > "begin" \n |
1576 > _ \n | |
1577 resume: | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1578 > "end;")) |
21205 | 1579 |
1580 ;; Additions by ACorreir@pervasive-sw.com (Alfred Correira) | |
61903 | 1581 (when (memq 'mailrc-generic-mode generic-extras-enable-list) |
1582 | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1583 (define-generic-mode mailrc-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1584 '(?#) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1585 '("alias" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1586 "else" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1587 "endif" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1588 "group" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1589 "if" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1590 "ignore" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1591 "set" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1592 "source" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1593 "unset") |
21205 | 1594 '(("^\\s-*\\(alias\\|group\\)\\s-+\\([-A-Za-z0-9_]+\\)\\s-+\\([^\n\r#]*\\)\\(#.*\\)?$" |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1595 (2 font-lock-constant-face) |
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1596 (3 font-lock-variable-name-face)) |
21205 | 1597 ("^\\s-*\\(unset\\|set\\|ignore\\)\\s-+\\([-A-Za-z0-9_]+\\)=?\\([^\n\r#]*\\)\\(#.*\\)?$" |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1598 (2 font-lock-constant-face) |
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1599 (3 font-lock-variable-name-face)) |
41393
8c295b635eb8
(mailrc-generic-mode): Highlight the `source' keyword.
Francesco Potortì <pot@gnu.org>
parents:
32282
diff
changeset
|
1600 ("^\\s-*\\(source\\)\\s-+\\([^\n\r#]*\\)\\(#.*\\)?$" |
8c295b635eb8
(mailrc-generic-mode): Highlight the `source' keyword.
Francesco Potortì <pot@gnu.org>
parents:
32282
diff
changeset
|
1601 (2 font-lock-variable-name-face))) |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1602 '("\\.mailrc\\'") |
21205 | 1603 nil |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1604 "Mode for mailrc files.")) |
21205 | 1605 |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1606 ;; Inetd.conf |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1607 (when (memq 'inetd-conf-generic-mode generic-extras-enable-list) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1608 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1609 (define-generic-mode inetd-conf-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1610 '(?#) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1611 '("stream" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1612 "dgram" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1613 "tcp" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1614 "udp" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1615 "wait" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1616 "nowait" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1617 "internal") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1618 '(("^\\([-A-Za-z0-9_]+\\)" 1 font-lock-type-face)) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1619 '("/etc/inetd.conf\\'") |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1620 (list |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1621 (function |
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1622 (lambda () |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1623 (setq imenu-generic-expression |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1624 '((nil "^\\([-A-Za-z0-9_]+\\)" 1)))))))) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1625 |
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1626 ;; Services |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1627 (when (memq 'etc-services-generic-mode generic-extras-enable-list) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1628 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1629 (define-generic-mode etc-services-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1630 '(?#) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1631 '("tcp" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1632 "udp" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1633 "ddp") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1634 '(("^\\([-A-Za-z0-9_]+\\)\\s-+\\([0-9]+\\)/" |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1635 (1 font-lock-type-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1636 (2 font-lock-variable-name-face))) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1637 '("/etc/services\\'") |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1638 (list |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1639 (function |
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1640 (lambda () |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1641 (setq imenu-generic-expression |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1642 '((nil "^\\([-A-Za-z0-9_]+\\)" 1)))))))) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1643 |
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1644 ;; Password and Group files |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1645 (when (memq 'etc-passwd-generic-mode generic-extras-enable-list) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1646 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1647 (define-generic-mode etc-passwd-generic-mode |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1648 nil ;; No comment characters |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1649 '("root") ;; Only one keyword |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1650 (eval-when-compile |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1651 (list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1652 (list |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1653 (concat |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1654 "^" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1655 ;; User name -- Never blank! |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1656 "\\([^:]+\\)" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1657 ":" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1658 ;; Password, UID and GID |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1659 (mapconcat |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1660 'identity |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1661 (make-list 3 "\\([^:]+\\)") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1662 ":") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1663 ":" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1664 ;; GECOS/Name -- might be blank |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1665 "\\([^:]*\\)" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1666 ":" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1667 ;; Home directory and shell |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1668 "\\([^:]+\\)" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1669 ":?" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1670 "\\([^:]*\\)" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1671 "$") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1672 '(1 font-lock-type-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1673 '(5 font-lock-variable-name-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1674 '(6 font-lock-constant-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1675 '(7 font-lock-warning-face)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1676 '("^\\([^:]+\\):\\([^:]*\\):\\([0-9]+\\):\\(.*\\)$" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1677 (1 font-lock-type-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1678 (4 font-lock-variable-name-face)))) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1679 '("/etc/passwd\\'" "/etc/group\\'") |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1680 (list |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1681 (function |
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1682 (lambda () |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1683 (setq imenu-generic-expression |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1684 '((nil "^\\([-A-Za-z0-9_]+\\):" 1)))))))) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1685 |
32117
20c617dc8696
* generic-x.el (apache-conf-generic-mode):
Peter Breton <pbreton@attbi.com>
parents:
26045
diff
changeset
|
1686 ;; Fstab |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1687 (when (memq 'etc-fstab-generic-mode generic-extras-enable-list) |
32117
20c617dc8696
* generic-x.el (apache-conf-generic-mode):
Peter Breton <pbreton@attbi.com>
parents:
26045
diff
changeset
|
1688 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1689 (define-generic-mode etc-fstab-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1690 '(?#) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1691 '("adfs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1692 "affs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1693 "autofs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1694 "coda" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1695 "coherent" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1696 "cramfs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1697 "devpts" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1698 "efs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1699 "ext2" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1700 "ext3" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1701 "hfs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1702 "hpfs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1703 "iso9660" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1704 "jfs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1705 "minix" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1706 "msdos" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1707 "ncpfs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1708 "nfs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1709 "ntfs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1710 "proc" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1711 "qnx4" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1712 "reiserfs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1713 "romfs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1714 "smbfs" |
68644
88d2d7964574
Add file system types cifs and usbdevfs. Allow special chars in file names.
Lars Hansen <larsh@soem.dk>
parents:
64762
diff
changeset
|
1715 "cifs" |
88d2d7964574
Add file system types cifs and usbdevfs. Allow special chars in file names.
Lars Hansen <larsh@soem.dk>
parents:
64762
diff
changeset
|
1716 "usbdevfs" |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1717 "sysv" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1718 "tmpfs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1719 "udf" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1720 "ufs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1721 "umsdos" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1722 "vfat" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1723 "xenix" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1724 "xfs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1725 "swap" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1726 "auto" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1727 "ignore") |
68644
88d2d7964574
Add file system types cifs and usbdevfs. Allow special chars in file names.
Lars Hansen <larsh@soem.dk>
parents:
64762
diff
changeset
|
1728 '(("^\\([^# \t]+\\)\\s-+\\([^# \t]+\\)" |
61490
e51a703b6762
(rc-generic-mode, rul-generic-mode): Fix auto-mode-alist entries.
Lute Kamstra <lute@gnu.org>
parents:
61456
diff
changeset
|
1729 (1 font-lock-type-face t) |
e51a703b6762
(rc-generic-mode, rul-generic-mode): Fix auto-mode-alist entries.
Lute Kamstra <lute@gnu.org>
parents:
61456
diff
changeset
|
1730 (2 font-lock-variable-name-face t))) |
32117
20c617dc8696
* generic-x.el (apache-conf-generic-mode):
Peter Breton <pbreton@attbi.com>
parents:
26045
diff
changeset
|
1731 '("/etc/[v]*fstab\\'") |
20c617dc8696
* generic-x.el (apache-conf-generic-mode):
Peter Breton <pbreton@attbi.com>
parents:
26045
diff
changeset
|
1732 (list |
20c617dc8696
* generic-x.el (apache-conf-generic-mode):
Peter Breton <pbreton@attbi.com>
parents:
26045
diff
changeset
|
1733 (function |
20c617dc8696
* generic-x.el (apache-conf-generic-mode):
Peter Breton <pbreton@attbi.com>
parents:
26045
diff
changeset
|
1734 (lambda () |
20c617dc8696
* generic-x.el (apache-conf-generic-mode):
Peter Breton <pbreton@attbi.com>
parents:
26045
diff
changeset
|
1735 (setq imenu-generic-expression |
68644
88d2d7964574
Add file system types cifs and usbdevfs. Allow special chars in file names.
Lars Hansen <larsh@soem.dk>
parents:
64762
diff
changeset
|
1736 '((nil "^\\([^# \t]+\\)\\s-+" 1)))))))) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1737 |
87179
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1738 ;; /etc/sudoers |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1739 (when (memq 'etc-sudoers-generic-mode generic-extras-enable-list) |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1740 |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1741 (define-generic-mode etc-sudoers-generic-mode |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1742 '(?#) |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1743 '("User_Alias" "Runas_Alias" "Host_Alias" "Cmnd_Alias" |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1744 "NOPASSWD" "PASSWD" "NOEXEC" "EXEC" |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1745 "ALL") |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1746 '(("\\<\\(root\\|su\\)\\>" 1 font-lock-warning-face) |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1747 ("\\(\\*\\)" 1 font-lock-warning-face) |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1748 ("\\<\\(%[A-Za-z0-9_]+\\)\\>" 1 font-lock-variable-name-face)) |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1749 '("/etc/sudoers\\'") |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1750 nil |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1751 "Generic mode for sudoers configuration files.")) |
5ab752d82a12
(etc-sudoers-generic-mode): New mode.
Reiner Steib <Reiner.Steib@gmx.de>
parents:
86483
diff
changeset
|
1752 |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1753 ;; From Jacques Duthen <jacques.duthen@sncf.fr> |
61903 | 1754 (when (memq 'show-tabs-generic-mode generic-extras-enable-list) |
1755 | |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1756 (eval-when-compile |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1757 |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1758 (defconst show-tabs-generic-mode-font-lock-defaults-1 |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1759 '(;; trailing spaces must come before... |
63206
2624ddc5a43f
Revision: miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-376
Miles Bader <miles@gnu.org>
parents:
62436
diff
changeset
|
1760 ("[ \t]+$" . 'show-tabs-space) |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1761 ;; ...embedded tabs |
63206
2624ddc5a43f
Revision: miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-376
Miles Bader <miles@gnu.org>
parents:
62436
diff
changeset
|
1762 ("[^\n\t]\\(\t+\\)" (1 'show-tabs-tab)))) |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1763 |
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1764 (defconst show-tabs-generic-mode-font-lock-defaults-2 |
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1765 '(;; trailing spaces must come before... |
63206
2624ddc5a43f
Revision: miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-376
Miles Bader <miles@gnu.org>
parents:
62436
diff
changeset
|
1766 ("[ \t]+$" . 'show-tabs-space) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1767 ;; ...tabs |
63206
2624ddc5a43f
Revision: miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-376
Miles Bader <miles@gnu.org>
parents:
62436
diff
changeset
|
1768 ("\t+" . 'show-tabs-tab)))) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1769 |
63206
2624ddc5a43f
Revision: miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-376
Miles Bader <miles@gnu.org>
parents:
62436
diff
changeset
|
1770 (defface show-tabs-tab |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1771 '((((class grayscale) (background light)) (:background "DimGray" :weight bold)) |
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1772 (((class grayscale) (background dark)) (:background "LightGray" :weight bold)) |
61394
31aa9a390538
* mh-customize.el (mh-speedbar-selected-folder-face): Special case
Dan Nicolaescu <dann@ics.uci.edu>
parents:
61326
diff
changeset
|
1773 (((class color) (min-colors 88)) (:background "red1")) |
31aa9a390538
* mh-customize.el (mh-speedbar-selected-folder-face): Special case
Dan Nicolaescu <dann@ics.uci.edu>
parents:
61326
diff
changeset
|
1774 (((class color)) (:background "red")) |
42456
8a4077ab418c
(various face definitions): Use :weight, not :bold.
Richard M. Stallman <rms@gnu.org>
parents:
41393
diff
changeset
|
1775 (t (:weight bold))) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1776 "Font Lock mode face used to highlight TABs." |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1777 :group 'generic-x) |
63206
2624ddc5a43f
Revision: miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-376
Miles Bader <miles@gnu.org>
parents:
62436
diff
changeset
|
1778 ;; backward-compatibility alias |
2624ddc5a43f
Revision: miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-376
Miles Bader <miles@gnu.org>
parents:
62436
diff
changeset
|
1779 (put 'show-tabs-tab-face 'face-alias 'show-tabs-tab) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1780 |
63206
2624ddc5a43f
Revision: miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-376
Miles Bader <miles@gnu.org>
parents:
62436
diff
changeset
|
1781 (defface show-tabs-space |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1782 '((((class grayscale) (background light)) (:background "DimGray" :weight bold)) |
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1783 (((class grayscale) (background dark)) (:background "LightGray" :weight bold)) |
61394
31aa9a390538
* mh-customize.el (mh-speedbar-selected-folder-face): Special case
Dan Nicolaescu <dann@ics.uci.edu>
parents:
61326
diff
changeset
|
1784 (((class color) (min-colors 88)) (:background "yellow1")) |
31aa9a390538
* mh-customize.el (mh-speedbar-selected-folder-face): Special case
Dan Nicolaescu <dann@ics.uci.edu>
parents:
61326
diff
changeset
|
1785 (((class color)) (:background "yellow")) |
42456
8a4077ab418c
(various face definitions): Use :weight, not :bold.
Richard M. Stallman <rms@gnu.org>
parents:
41393
diff
changeset
|
1786 (t (:weight bold))) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1787 "Font Lock mode face used to highlight spaces." |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1788 :group 'generic-x) |
63206
2624ddc5a43f
Revision: miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-376
Miles Bader <miles@gnu.org>
parents:
62436
diff
changeset
|
1789 ;; backward-compatibility alias |
2624ddc5a43f
Revision: miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-376
Miles Bader <miles@gnu.org>
parents:
62436
diff
changeset
|
1790 (put 'show-tabs-space-face 'face-alias 'show-tabs-space) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1791 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1792 (define-generic-mode show-tabs-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1793 nil ;; no comment char |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1794 nil ;; no keywords |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1795 (eval-when-compile show-tabs-generic-mode-font-lock-defaults-1) |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1796 nil ;; no auto-mode-alist |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1797 ;; '(show-tabs-generic-mode-hook-fun) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1798 nil |
78063
edd7a13f790e
(generic-define-mswindows-modes, generic-define-unix-modes,
Juanma Barranquero <lekktu@gmail.com>
parents:
75347
diff
changeset
|
1799 "Generic mode to show tabs and trailing spaces.")) |
25603
db167bb5dfd8
(generic-define-unix-modes): Added new modes:
Richard M. Stallman <rms@gnu.org>
parents:
24036
diff
changeset
|
1800 |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1801 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1802 ;; DNS modes |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1803 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1804 |
61903 | 1805 (when (memq 'named-boot-generic-mode generic-extras-enable-list) |
1806 | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1807 (define-generic-mode named-boot-generic-mode |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1808 ;; List of comment characters |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1809 '(?\;) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1810 ;; List of keywords |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1811 '("cache" "primary" "secondary" "forwarders" "limit" "options" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1812 "directory" "check-names") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1813 ;; List of additional font-lock-expressions |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1814 '(("\\([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+\\)" 1 font-lock-constant-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1815 ("^directory\\s-+\\(.*\\)" 1 font-lock-variable-name-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1816 ("^\\(primary\\|cache\\)\\s-+\\([.A-Za-z]+\\)\\s-+\\(.*\\)" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1817 (2 font-lock-variable-name-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1818 (3 font-lock-constant-face))) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1819 ;; List of additional automode-alist expressions |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1820 '("/etc/named.boot\\'") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1821 ;; List of set up functions to call |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1822 nil)) |
61903 | 1823 |
1824 (when (memq 'named-database-generic-mode generic-extras-enable-list) | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1825 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1826 (define-generic-mode named-database-generic-mode |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1827 ;; List of comment characters |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1828 '(?\;) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1829 ;; List of keywords |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1830 '("IN" "NS" "CNAME" "SOA" "PTR" "MX" "A") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1831 ;; List of additional font-lock-expressions |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1832 '(("\\([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+\\)" 1 font-lock-constant-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1833 ("^\\([.A-Za-z0-9]+\\)" 1 font-lock-variable-name-face)) |
61490
e51a703b6762
(rc-generic-mode, rul-generic-mode): Fix auto-mode-alist entries.
Lute Kamstra <lute@gnu.org>
parents:
61456
diff
changeset
|
1834 ;; List of additional auto-mode-alist expressions |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1835 nil |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1836 ;; List of set up functions to call |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1837 nil) |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1838 |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1839 (defvar named-database-time-string "%Y%m%d%H" |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1840 "Timestring for named serial numbers.") |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1841 |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1842 (defun named-database-print-serial () |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1843 "Print a serial number based on the current date." |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1844 (interactive) |
61903 | 1845 (insert (format-time-string named-database-time-string (current-time))))) |
1846 | |
1847 (when (memq 'resolve-conf-generic-mode generic-extras-enable-list) | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1848 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1849 (define-generic-mode resolve-conf-generic-mode |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1850 ;; List of comment characters |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1851 '(?#) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1852 ;; List of keywords |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1853 '("nameserver" "domain" "search" "sortlist" "options") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1854 ;; List of additional font-lock-expressions |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1855 nil |
61490
e51a703b6762
(rc-generic-mode, rul-generic-mode): Fix auto-mode-alist entries.
Lute Kamstra <lute@gnu.org>
parents:
61456
diff
changeset
|
1856 ;; List of additional auto-mode-alist expressions |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1857 '("/etc/resolv[e]?.conf\\'") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1858 ;; List of set up functions to call |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1859 nil)) |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1860 |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1861 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1862 ;; Modes for spice and common electrical engineering circuit netlist formats |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1863 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1864 |
61903 | 1865 (when (memq 'spice-generic-mode generic-extras-enable-list) |
1866 | |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1867 (define-generic-mode spice-generic-mode |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1868 nil |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1869 '("and" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1870 "cccs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1871 "ccvs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1872 "delay" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1873 "nand" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1874 "nor" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1875 "npwl" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1876 "or" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1877 "par" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1878 "ppwl" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1879 "pwl" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1880 "vccap" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1881 "vccs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1882 "vcr" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1883 "vcvs") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1884 '(("^\\s-*\\([*].*\\)" 1 font-lock-comment-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1885 (" \\(\\$ .*\\)$" 1 font-lock-comment-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1886 ("^\\(\\$ .*\\)$" 1 font-lock-comment-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1887 ("\\([*].*\\)" 1 font-lock-comment-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1888 ("^\\([+]\\)" 1 font-lock-string-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1889 ("^\\s-*\\([.]\\w+\\>\\)" 1 font-lock-keyword-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1890 ("\\(\\([.]\\|_\\|\\w\\)+\\)\\s-*=" 1 font-lock-variable-name-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1891 ("\\('[^']+'\\)" 1 font-lock-string-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1892 ("\\(\"[^\"]+\"\\)" 1 font-lock-string-face)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1893 '("\\.[sS][pP]\\'" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1894 "\\.[sS][pP][iI]\\'" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1895 "\\.[sS][pP][iI][cC][eE]\\'" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1896 "\\.[iI][nN][cC]\\'") |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1897 (list |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1898 'generic-bracket-support |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1899 ;; Make keywords case-insensitive |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1900 (function |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1901 (lambda() |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1902 (setq font-lock-defaults '(generic-font-lock-keywords nil t))))) |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1903 "Generic mode for SPICE circuit netlist files.")) |
61903 | 1904 |
1905 (when (memq 'ibis-generic-mode generic-extras-enable-list) | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1906 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1907 (define-generic-mode ibis-generic-mode |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1908 '(?|) |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1909 nil |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1910 '(("[[]\\([^]]*\\)[]]" 1 font-lock-keyword-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1911 ("\\(\\(_\\|\\w\\)+\\)\\s-*=" 1 font-lock-variable-name-face)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1912 '("\\.[iI][bB][sS]\\'") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1913 '(generic-bracket-support) |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1914 "Generic mode for IBIS circuit netlist files.")) |
61903 | 1915 |
1916 (when (memq 'astap-generic-mode generic-extras-enable-list) | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1917 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1918 (define-generic-mode astap-generic-mode |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1919 nil |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1920 '("analyze" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1921 "description" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1922 "elements" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1923 "execution" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1924 "features" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1925 "functions" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1926 "ground" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1927 "model" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1928 "outputs" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1929 "print" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1930 "run" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1931 "controls" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1932 "table") |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1933 '(("^\\s-*\\([*].*\\)" 1 font-lock-comment-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1934 (";\\s-*\\([*].*\\)" 1 font-lock-comment-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1935 ("^\\s-*\\([.]\\w+\\>\\)" 1 font-lock-keyword-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1936 ("\\('[^']+'\\)" 1 font-lock-string-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1937 ("\\(\"[^\"]+\"\\)" 1 font-lock-string-face) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1938 ("[(,]\\s-*\\(\\([.]\\|_\\|\\w\\)+\\)\\s-*=" 1 font-lock-variable-name-face)) |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1939 '("\\.[aA][pP]\\'" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1940 "\\.[aA][sS][xX]\\'" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1941 "\\.[aA][sS][tT][aA][pP]\\'" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1942 "\\.[pP][sS][pP]\\'" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1943 "\\.[dD][eE][cC][kK]\\'" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1944 "\\.[gG][oO][dD][aA][tT][aA]") |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1945 (list |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1946 'generic-bracket-support |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1947 ;; Make keywords case-insensitive |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1948 (function |
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1949 (lambda() |
60872
9be398c4e5e3
Rename generic-font-lock-defaults to generic-font-lock-keywords
Lute Kamstra <lute@gnu.org>
parents:
60851
diff
changeset
|
1950 (setq font-lock-defaults '(generic-font-lock-keywords nil t))))) |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1951 "Generic mode for ASTAP circuit netlist files.")) |
61903 | 1952 |
1953 (when (memq 'etc-modules-conf-generic-mode generic-extras-enable-list) | |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1954 |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1955 (define-generic-mode etc-modules-conf-generic-mode |
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1956 ;; List of comment characters |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1957 '(?#) |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1958 ;; List of keywords |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1959 '("above" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1960 "alias" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1961 "below" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1962 "define" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1963 "depfile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1964 "else" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1965 "elseif" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1966 "endif" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1967 "if" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1968 "include" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1969 "insmod_opt" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1970 "install" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1971 "keep" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1972 "options" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1973 "path" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1974 "generic_stringfile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1975 "pcimapfile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1976 "isapnpmapfile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1977 "usbmapfile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1978 "parportmapfile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1979 "ieee1394mapfile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1980 "pnpbiosmapfile" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1981 "probe" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1982 "probeall" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1983 "prune" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1984 "post-install" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1985 "post-remove" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1986 "pre-install" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1987 "pre-remove" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1988 "remove" |
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1989 "persistdir") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1990 ;; List of additional font-lock-expressions |
50265
e8baa2ffdd8f
Use fixes to rul-generic-mode, contributed by "Rolf Sandau" <Rolf.Sandau@marconi.com>
Peter Breton <pbreton@attbi.com>
parents:
48791
diff
changeset
|
1991 nil |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1992 ;; List of additional automode-alist expressions |
60851
c96f650fe125
Code cleanup: make arguments constant whenever possible.
Lute Kamstra <lute@gnu.org>
parents:
60820
diff
changeset
|
1993 '("/etc/modules.conf" "/etc/conf.modules") |
60774
65f5b049afac
Don't prevent compilation. Don't require generic.
Lute Kamstra <lute@gnu.org>
parents:
53360
diff
changeset
|
1994 ;; List of set up functions to call |
62258
1eeee39ce994
Fix callers of define-generic-mode.
Lute Kamstra <lute@gnu.org>
parents:
61903
diff
changeset
|
1995 nil)) |
26044
a0f47d3e4a95
Added new InstallShield keywords.
Peter Breton <pbreton@attbi.com>
parents:
25624
diff
changeset
|
1996 |
21205 | 1997 (provide 'generic-x) |
1998 | |
93975
1e3a407766b9
Fix up comment convention on the arch-tag lines.
Stefan Monnier <monnier@iro.umontreal.ca>
parents:
87649
diff
changeset
|
1999 ;; arch-tag: cde692a5-9ff6-4506-9999-c67999c2bdb5 |
21205 | 2000 ;;; generic-x.el ends here |