|
13337
|
1 ;;; forms.el --- Forms mode: edit a file as a form to fill in
|
|
|
2
|
|
18215
|
3 ;; Copyright (C) 1991, 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
|
|
307
|
4
|
|
13317
|
5 ;; Author: Johan Vromans <jvromans@squirrel.nl>
|
|
3697
|
6
|
|
|
7 ;; This file is part of GNU Emacs.
|
|
276
|
8
|
|
3697
|
9 ;; GNU Emacs is free software; you can redistribute it and/or modify
|
|
|
10 ;; it under the terms of the GNU General Public License as published by
|
|
|
11 ;; the Free Software Foundation; either version 2, or (at your option)
|
|
|
12 ;; any later version.
|
|
276
|
13
|
|
3697
|
14 ;; GNU Emacs is distributed in the hope that it will be useful,
|
|
|
15 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
16 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
17 ;; GNU General Public License for more details.
|
|
307
|
18
|
|
3697
|
19 ;; You should have received a copy of the GNU General Public License
|
|
14169
|
20 ;; along with GNU Emacs; see the file COPYING. If not, write to the
|
|
|
21 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
22 ;; Boston, MA 02111-1307, USA.
|
|
3697
|
23
|
|
|
24 ;;; Commentary:
|
|
276
|
25
|
|
14169
|
26 ;; Visit a file using a form.
|
|
|
27 ;;
|
|
|
28 ;; === Naming conventions
|
|
|
29 ;;
|
|
|
30 ;; The names of all variables and functions start with 'forms-'.
|
|
|
31 ;; Names which start with 'forms--' are intended for internal use, and
|
|
|
32 ;; should *NOT* be used from the outside.
|
|
|
33 ;;
|
|
|
34 ;; All variables are buffer-local, to enable multiple forms visits
|
|
|
35 ;; simultaneously.
|
|
|
36 ;; Variable `forms--mode-setup' is local to *ALL* buffers, for it
|
|
|
37 ;; controls if forms-mode has been enabled in a buffer.
|
|
|
38 ;;
|
|
|
39 ;; === How it works ===
|
|
|
40 ;;
|
|
|
41 ;; Forms mode means visiting a data file which is supposed to consist
|
|
|
42 ;; of records each containing a number of fields. The records are
|
|
|
43 ;; separated by a newline, the fields are separated by a user-defined
|
|
|
44 ;; field separator (default: TAB).
|
|
|
45 ;; When shown, a record is transferred to an Emacs buffer and
|
|
|
46 ;; presented using a user-defined form. One record is shown at a
|
|
|
47 ;; time.
|
|
|
48 ;;
|
|
|
49 ;; Forms mode is a composite mode. It involves two files, and two
|
|
|
50 ;; buffers.
|
|
|
51 ;; The first file, called the control file, defines the name of the
|
|
|
52 ;; data file and the forms format. This file buffer will be used to
|
|
|
53 ;; present the forms.
|
|
|
54 ;; The second file holds the actual data. The buffer of this file
|
|
|
55 ;; will be buried, for it is never accessed directly.
|
|
|
56 ;;
|
|
|
57 ;; Forms mode is invoked using M-x forms-find-file control-file .
|
|
|
58 ;; Alternatively `forms-find-file-other-window' can be used.
|
|
|
59 ;;
|
|
|
60 ;; You may also visit the control file, and switch to forms mode by hand
|
|
|
61 ;; with M-x forms-mode .
|
|
|
62 ;;
|
|
|
63 ;; Automatic mode switching is supported if you specify
|
|
|
64 ;; "-*- forms -*-" in the first line of the control file.
|
|
|
65 ;;
|
|
|
66 ;; The control file is visited, evaluated using `eval-current-buffer',
|
|
|
67 ;; and should set at least the following variables:
|
|
|
68 ;;
|
|
|
69 ;; forms-file [string]
|
|
|
70 ;; The name of the data file.
|
|
|
71 ;;
|
|
|
72 ;; forms-number-of-fields [integer]
|
|
|
73 ;; The number of fields in each record.
|
|
|
74 ;;
|
|
|
75 ;; forms-format-list [list]
|
|
|
76 ;; Formatting instructions.
|
|
|
77 ;;
|
|
|
78 ;; `forms-format-list' should be a list, each element containing
|
|
|
79 ;;
|
|
|
80 ;; - a string, e.g. "hello". The string is inserted in the forms
|
|
|
81 ;; "as is".
|
|
|
82 ;;
|
|
|
83 ;; - an integer, denoting a field number.
|
|
|
84 ;; The contents of this field are inserted at this point.
|
|
|
85 ;; Fields are numbered starting with number one.
|
|
|
86 ;;
|
|
|
87 ;; - a function call, e.g. (insert "text").
|
|
|
88 ;; This function call is dynamically evaluated and should return a
|
|
|
89 ;; string. It should *NOT* have side-effects on the forms being
|
|
|
90 ;; constructed. The current fields are available to the function
|
|
|
91 ;; in the variable `forms-fields', they should *NOT* be modified.
|
|
|
92 ;;
|
|
|
93 ;; - a lisp symbol, that must evaluate to one of the above.
|
|
|
94 ;;
|
|
|
95 ;; Optional variables which may be set in the control file:
|
|
|
96 ;;
|
|
|
97 ;; forms-field-sep [string, default TAB]
|
|
|
98 ;; The field separator used to separate the
|
|
|
99 ;; fields in the data file. It may be a string.
|
|
|
100 ;;
|
|
|
101 ;; forms-read-only [bool, default nil]
|
|
|
102 ;; Non-nil means that the data file is visited
|
|
|
103 ;; read-only (view mode) as opposed to edit mode.
|
|
|
104 ;; If no write access to the data file is
|
|
|
105 ;; possible, view mode is enforced.
|
|
|
106 ;;
|
14732
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
107 ;; forms-check-number-of-fields [bool, default t]
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
108 ;; If non-nil, a warning will be issued whenever
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
109 ;; a record is found that does not have the number
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
110 ;; of fields specified by `forms-number-of-fields'.
|
|
14169
|
111 ;;
|
|
|
112 ;; forms-multi-line [string, default "^K"]
|
|
|
113 ;; If non-null the records of the data file may
|
|
|
114 ;; contain fields that can span multiple lines in
|
|
|
115 ;; the form.
|
|
|
116 ;; This variable denotes the separator character
|
|
|
117 ;; to be used for this purpose. Upon display, all
|
|
|
118 ;; occurrences of this character are translated
|
|
|
119 ;; to newlines. Upon storage they are translated
|
|
|
120 ;; back to the separator character.
|
|
|
121 ;;
|
|
|
122 ;; forms-forms-scroll [bool, default nil]
|
|
|
123 ;; Non-nil means: rebind locally the commands that
|
|
|
124 ;; perform `scroll-up' or `scroll-down' to use
|
|
|
125 ;; `forms-next-field' resp. `forms-prev-field'.
|
|
|
126 ;;
|
|
|
127 ;; forms-forms-jump [bool, default nil]
|
|
|
128 ;; Non-nil means: rebind locally the commands that
|
14732
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
129 ;;
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
130 ;; forms-insert-after [bool, default nil]
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
131 ;; Non-nil means: inserts of new records go after
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
132 ;; current record, also initial position is at last
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
133 ;; record.
|
|
14169
|
134 ;;
|
|
|
135 ;; forms-read-file-filter [symbol, default nil]
|
|
|
136 ;; If not nil: this should be the name of a
|
|
|
137 ;; function that is called after the forms data file
|
|
|
138 ;; has been read. It can be used to transform
|
|
|
139 ;; the contents of the file into a format more suitable
|
|
|
140 ;; for forms-mode processing.
|
|
|
141 ;;
|
|
|
142 ;; forms-write-file-filter [symbol, default nil]
|
|
|
143 ;; If not nil: this should be the name of a
|
|
|
144 ;; function that is called before the forms data file
|
|
|
145 ;; is written (saved) to disk. It can be used to undo
|
|
|
146 ;; the effects of `forms-read-file-filter', if any.
|
|
|
147 ;;
|
|
|
148 ;; forms-new-record-filter [symbol, default nil]
|
|
|
149 ;; If not nil: this should be the name of a
|
|
|
150 ;; function that is called when a new
|
|
|
151 ;; record is created. It can be used to fill in
|
|
|
152 ;; the new record with default fields, for example.
|
|
|
153 ;;
|
|
|
154 ;; forms-modified-record-filter [symbol, default nil]
|
|
|
155 ;; If not nil: this should be the name of a
|
|
|
156 ;; function that is called when a record has
|
|
|
157 ;; been modified. It is called after the fields
|
|
|
158 ;; are parsed. It can be used to register
|
|
|
159 ;; modification dates, for example.
|
|
|
160 ;;
|
|
|
161 ;; forms-use-text-properties [bool, see text for default]
|
|
|
162 ;; This variable controls if forms mode should use
|
|
|
163 ;; text properties to protect the form text from being
|
|
|
164 ;; modified (using text-property `read-only').
|
|
|
165 ;; Also, the read-write fields are shown using a
|
|
|
166 ;; distinct face, if possible.
|
|
|
167 ;; As of emacs 19.29, the `intangible' text property
|
|
|
168 ;; is used to prevent moving into read-only fields.
|
|
|
169 ;; This variable defaults to t if running Emacs 19
|
|
|
170 ;; with text properties.
|
|
|
171 ;; The default face to show read-write fields is
|
|
|
172 ;; copied from face `region'.
|
|
|
173 ;;
|
|
|
174 ;; forms-ro-face [symbol, default 'default]
|
|
|
175 ;; This is the face that is used to show
|
|
|
176 ;; read-only text on the screen.If used, this
|
|
|
177 ;; variable should be set to a symbol that is a
|
|
|
178 ;; valid face.
|
|
|
179 ;; E.g.
|
|
|
180 ;; (make-face 'my-face)
|
|
|
181 ;; (setq forms-ro-face 'my-face)
|
|
|
182 ;;
|
|
|
183 ;; forms-rw-face [symbol, default 'region]
|
|
|
184 ;; This is the face that is used to show
|
|
|
185 ;; read-write text on the screen.
|
|
|
186 ;;
|
|
|
187 ;; After evaluating the control file, its buffer is cleared and used
|
|
|
188 ;; for further processing.
|
|
|
189 ;; The data file (as designated by `forms-file') is visited in a buffer
|
|
|
190 ;; `forms--file-buffer' which will not normally be shown.
|
|
|
191 ;; Great malfunctioning may be expected if this file/buffer is modified
|
|
|
192 ;; outside of this package while it is being visited!
|
|
|
193 ;;
|
|
|
194 ;; Normal operation is to transfer one line (record) from the data file,
|
|
|
195 ;; split it into fields (into `forms--the-record-list'), and display it
|
|
|
196 ;; using the specs in `forms-format-list'.
|
|
|
197 ;; A format routine `forms--format' is built upon startup to format
|
|
|
198 ;; the records according to `forms-format-list'.
|
|
|
199 ;;
|
|
|
200 ;; When a form is changed the record is updated as soon as this form
|
|
|
201 ;; is left. The contents of the form are parsed using information
|
|
|
202 ;; obtained from `forms-format-list', and the fields which are
|
|
|
203 ;; deduced from the form are modified. Fields not shown on the forms
|
|
|
204 ;; retain their original values. The newly formed record then
|
|
|
205 ;; replaces the contents of the old record in `forms--file-buffer'.
|
|
|
206 ;; A parse routine `forms--parser' is built upon startup to parse
|
|
|
207 ;; the records.
|
|
|
208 ;;
|
|
|
209 ;; Two exit functions exist: `forms-exit' and `forms-exit-no-save'.
|
|
|
210 ;; `forms-exit' saves the data to the file, if modified.
|
|
|
211 ;; `forms-exit-no-save` does not. However, if `forms-exit-no-save'
|
|
|
212 ;; is executed and the file buffer has been modified, Emacs will ask
|
|
|
213 ;; questions anyway.
|
|
|
214 ;;
|
|
|
215 ;; Other functions provided by forms mode are:
|
|
|
216 ;;
|
|
|
217 ;; paging (forward, backward) by record
|
|
|
218 ;; jumping (first, last, random number)
|
|
|
219 ;; searching
|
|
|
220 ;; creating and deleting records
|
|
|
221 ;; reverting the form (NOT the file buffer)
|
|
|
222 ;; switching edit <-> view mode v.v.
|
|
|
223 ;; jumping from field to field
|
|
|
224 ;;
|
|
|
225 ;; As an documented side-effect: jumping to the last record in the
|
|
|
226 ;; file (using forms-last-record) will adjust forms--total-records if
|
|
|
227 ;; needed.
|
|
|
228 ;;
|
|
|
229 ;; The forms buffer can be in on eof two modes: edit mode or view
|
|
|
230 ;; mode. View mode is a read-only mode, you cannot modify the
|
|
|
231 ;; contents of the buffer.
|
|
|
232 ;;
|
|
|
233 ;; Edit mode commands:
|
|
|
234 ;;
|
|
|
235 ;; TAB forms-next-field
|
|
|
236 ;; \C-c TAB forms-next-field
|
|
|
237 ;; \C-c < forms-first-record
|
|
|
238 ;; \C-c > forms-last-record
|
|
|
239 ;; \C-c ? describe-mode
|
|
|
240 ;; \C-c \C-k forms-delete-record
|
|
|
241 ;; \C-c \C-q forms-toggle-read-only
|
|
|
242 ;; \C-c \C-o forms-insert-record
|
|
|
243 ;; \C-c \C-l forms-jump-record
|
|
|
244 ;; \C-c \C-n forms-next-record
|
|
|
245 ;; \C-c \C-p forms-prev-record
|
|
|
246 ;; \C-c \C-r forms-search-backward
|
|
|
247 ;; \C-c \C-s forms-search-forward
|
|
|
248 ;; \C-c \C-x forms-exit
|
|
|
249 ;;
|
|
|
250 ;; Read-only mode commands:
|
|
|
251 ;;
|
|
|
252 ;; SPC forms-next-record
|
|
|
253 ;; DEL forms-prev-record
|
|
|
254 ;; ? describe-mode
|
|
|
255 ;; \C-q forms-toggle-read-only
|
|
|
256 ;; l forms-jump-record
|
|
|
257 ;; n forms-next-record
|
|
|
258 ;; p forms-prev-record
|
|
|
259 ;; r forms-search-backward
|
|
|
260 ;; s forms-search-forward
|
|
|
261 ;; x forms-exit
|
|
|
262 ;;
|
|
|
263 ;; Of course, it is also possible to use the \C-c prefix to obtain the
|
|
|
264 ;; same command keys as in edit mode.
|
|
|
265 ;;
|
|
|
266 ;; The following bindings are available, independent of the mode:
|
|
|
267 ;;
|
|
|
268 ;; [next] forms-next-record
|
|
|
269 ;; [prior] forms-prev-record
|
|
|
270 ;; [begin] forms-first-record
|
|
|
271 ;; [end] forms-last-record
|
|
|
272 ;; [S-TAB] forms-prev-field
|
|
|
273 ;; [backtab] forms-prev-field
|
|
|
274 ;;
|
|
|
275 ;; For convenience, TAB is always bound to `forms-next-field', so you
|
|
|
276 ;; don't need the C-c prefix for this command.
|
|
|
277 ;;
|
|
|
278 ;; As mentioned above (see `forms-forms-scroll' and `forms-forms-jump')
|
|
|
279 ;; the bindings of standard functions `scroll-up', `scroll-down',
|
|
|
280 ;; `beginning-of-buffer' and `end-of-buffer' can be locally replaced with
|
|
|
281 ;; forms mode functions next/prev record and first/last
|
|
|
282 ;; record.
|
|
|
283 ;;
|
|
|
284 ;; `local-write-file hook' is defined to save the actual data file
|
|
|
285 ;; instead of the buffer data, `revert-file-hook' is defined to
|
|
|
286 ;; revert a forms to original.
|
|
3697
|
287
|
|
|
288 ;;; Code:
|
|
|
289
|
|
4121
|
290 ;;; Global variables and constants:
|
|
276
|
291
|
|
3697
|
292 (provide 'forms) ;;; official
|
|
|
293 (provide 'forms-mode) ;;; for compatibility
|
|
|
294
|
|
18223
|
295 (defconst forms-version (substring "$Revision: 2.30 $" 11 -2)
|
|
4790
|
296 "The version number of forms-mode (as string). The complete RCS id is:
|
|
|
297
|
|
18223
|
298 $Id: forms.el,v 2.30 1997/06/10 18:32:33 kwzh Exp rms $")
|
|
276
|
299
|
|
|
300 (defvar forms-mode-hooks nil
|
|
3697
|
301 "Hook functions to be run upon entering Forms mode.")
|
|
|
302
|
|
4121
|
303 ;;; Mandatory variables - must be set by evaluating the control file.
|
|
276
|
304
|
|
|
305 (defvar forms-file nil
|
|
307
|
306 "Name of the file holding the data.")
|
|
276
|
307
|
|
|
308 (defvar forms-format-list nil
|
|
307
|
309 "List of formatting specifications.")
|
|
276
|
310
|
|
|
311 (defvar forms-number-of-fields nil
|
|
|
312 "Number of fields per record.")
|
|
3697
|
313
|
|
4121
|
314 ;;; Optional variables with default values.
|
|
276
|
315
|
|
12847
|
316 (defvar forms-check-number-of-fields t
|
13569
438ebe3b6f8d
Use `buffer-substring-no-properties' instead of `buffer-substring' to
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
317 "*If non-nil, warn about records with wrong number of fields.")
|
|
12847
|
318
|
|
276
|
319 (defvar forms-field-sep "\t"
|
|
3697
|
320 "Field separator character (default TAB).")
|
|
276
|
321
|
|
|
322 (defvar forms-read-only nil
|
|
4121
|
323 "Non-nil means: visit the file in view (read-only) mode.
|
|
7639
|
324 \(Defaults to the write access on the data file).")
|
|
276
|
325
|
|
|
326 (defvar forms-multi-line "\C-k"
|
|
4121
|
327 "If not nil: use this character to separate multi-line fields (default C-k).")
|
|
276
|
328
|
|
4790
|
329 (defvar forms-forms-scroll nil
|
|
3828
|
330 "*Non-nil means replace scroll-up/down commands in Forms mode.
|
|
|
331 The replacement commands performs forms-next/prev-record.")
|
|
276
|
332
|
|
4790
|
333 (defvar forms-forms-jump nil
|
|
3828
|
334 "*Non-nil means redefine beginning/end-of-buffer in Forms mode.
|
|
|
335 The replacement commands performs forms-first/last-record.")
|
|
4121
|
336
|
|
8344
|
337 (defvar forms-read-file-filter nil
|
|
|
338 "The name of a function that is called after reading the data file.
|
|
|
339 This can be used to change the contents of the file to something more
|
|
|
340 suitable for forms processing.")
|
|
|
341
|
|
|
342 (defvar forms-write-file-filter nil
|
|
|
343 "The name of a function that is called before writing the data file.
|
|
|
344 This can be used to undo the effects of form-read-file-hook.")
|
|
|
345
|
|
4121
|
346 (defvar forms-new-record-filter nil
|
|
|
347 "The name of a function that is called when a new record is created.")
|
|
|
348
|
|
|
349 (defvar forms-modified-record-filter nil
|
|
|
350 "The name of a function that is called when a record has been modified.")
|
|
|
351
|
|
|
352 (defvar forms-fields nil
|
|
|
353 "List with fields of the current forms. First field has number 1.
|
|
|
354 This variable is for use by the filter routines only.
|
|
|
355 The contents may NOT be modified.")
|
|
|
356
|
|
|
357 (defvar forms-use-text-properties (fboundp 'set-text-properties)
|
|
|
358 "*Non-nil means: use emacs-19 text properties.
|
|
|
359 Defaults to t if this emacs is capable of handling text properties.")
|
|
|
360
|
14732
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
361 (defvar forms-insert-after nil
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
362 "*Non-nil means: inserts of new records go after current record.
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
363 Also, initial position is at last record.")
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
364
|
|
4121
|
365 (defvar forms-ro-face 'default
|
|
|
366 "The face (a symbol) that is used to display read-only text on the screen.")
|
|
|
367
|
|
|
368 (defvar forms-rw-face 'region
|
|
|
369 "The face (a symbol) that is used to display read-write text on the screen.")
|
|
3697
|
370
|
|
276
|
371 ;;; Internal variables.
|
|
|
372
|
|
|
373 (defvar forms--file-buffer nil
|
|
|
374 "Buffer which holds the file data")
|
|
|
375
|
|
|
376 (defvar forms--total-records 0
|
|
|
377 "Total number of records in the data file.")
|
|
|
378
|
|
|
379 (defvar forms--current-record 0
|
|
|
380 "Number of the record currently on the screen.")
|
|
|
381
|
|
4790
|
382 (defvar forms-mode-map nil
|
|
276
|
383 "Keymap for form buffer.")
|
|
4790
|
384 (defvar forms-mode-ro-map nil
|
|
|
385 "Keymap for form buffer in view mode.")
|
|
|
386 (defvar forms-mode-edit-map nil
|
|
|
387 "Keymap for form buffer in edit mode.")
|
|
276
|
388
|
|
|
389 (defvar forms--markers nil
|
|
|
390 "Field markers in the screen.")
|
|
|
391
|
|
4121
|
392 (defvar forms--dyntexts nil
|
|
|
393 "Dynamic texts (resulting from function calls) on the screen.")
|
|
276
|
394
|
|
|
395 (defvar forms--the-record-list nil
|
|
|
396 "List of strings of the current record, as parsed from the file.")
|
|
|
397
|
|
|
398 (defvar forms--search-regexp nil
|
|
10346
|
399 "Last regexp used by forms-search functions.")
|
|
276
|
400
|
|
|
401 (defvar forms--format nil
|
|
|
402 "Formatting routine.")
|
|
|
403
|
|
|
404 (defvar forms--parser nil
|
|
|
405 "Forms parser routine.")
|
|
|
406
|
|
|
407 (defvar forms--mode-setup nil
|
|
4121
|
408 "To keep track of forms-mode being set-up.")
|
|
276
|
409 (make-variable-buffer-local 'forms--mode-setup)
|
|
|
410
|
|
307
|
411 (defvar forms--dynamic-text nil
|
|
4121
|
412 "Array that holds dynamic texts to insert between fields.")
|
|
307
|
413
|
|
4121
|
414 (defvar forms--elements nil
|
|
|
415 "Array with the order in which the fields are displayed.")
|
|
307
|
416
|
|
4121
|
417 (defvar forms--ro-face nil
|
|
|
418 "Face used to represent read-only data on the screen.")
|
|
3697
|
419
|
|
4121
|
420 (defvar forms--rw-face nil
|
|
|
421 "Face used to represent read-write data on the screen.")
|
|
3697
|
422
|
|
3941
|
423 ;;;###autoload
|
|
276
|
424 (defun forms-mode (&optional primary)
|
|
|
425 "Major mode to visit files in a field-structured manner using a form.
|
|
|
426
|
|
4790
|
427 Commands: Equivalent keys in read-only mode:
|
|
|
428 TAB forms-next-field TAB
|
|
|
429 \\C-c TAB forms-next-field
|
|
|
430 \\C-c < forms-first-record <
|
|
|
431 \\C-c > forms-last-record >
|
|
|
432 \\C-c ? describe-mode ?
|
|
|
433 \\C-c \\C-k forms-delete-record
|
|
|
434 \\C-c \\C-q forms-toggle-read-only q
|
|
|
435 \\C-c \\C-o forms-insert-record
|
|
|
436 \\C-c \\C-l forms-jump-record l
|
|
|
437 \\C-c \\C-n forms-next-record n
|
|
|
438 \\C-c \\C-p forms-prev-record p
|
|
10346
|
439 \\C-c \\C-r forms-search-reverse r
|
|
|
440 \\C-c \\C-s forms-search-forward s
|
|
4790
|
441 \\C-c \\C-x forms-exit x
|
|
|
442 "
|
|
|
443 (interactive)
|
|
276
|
444
|
|
4121
|
445 ;; This is not a simple major mode, as usual. Therefore, forms-mode
|
|
|
446 ;; takes an optional argument `primary' which is used for the
|
|
|
447 ;; initial set-up. Normal use would leave `primary' to nil.
|
|
|
448 ;; A global buffer-local variable `forms--mode-setup' has the same
|
|
|
449 ;; effect but makes it possible to auto-invoke forms-mode using
|
|
|
450 ;; `find-file'.
|
|
|
451 ;; Note: although it seems logical to have `make-local-variable'
|
|
|
452 ;; executed where the variable is first needed, I have deliberately
|
|
|
453 ;; placed all calls in this function.
|
|
|
454
|
|
276
|
455 ;; Primary set-up: evaluate buffer and check if the mandatory
|
|
|
456 ;; variables have been set.
|
|
|
457 (if (or primary (not forms--mode-setup))
|
|
|
458 (progn
|
|
4121
|
459 ;;(message "forms: setting up...")
|
|
276
|
460 (kill-all-local-variables)
|
|
|
461
|
|
4121
|
462 ;; Make mandatory variables.
|
|
276
|
463 (make-local-variable 'forms-file)
|
|
|
464 (make-local-variable 'forms-number-of-fields)
|
|
|
465 (make-local-variable 'forms-format-list)
|
|
|
466
|
|
4121
|
467 ;; Make optional variables.
|
|
276
|
468 (make-local-variable 'forms-field-sep)
|
|
|
469 (make-local-variable 'forms-read-only)
|
|
|
470 (make-local-variable 'forms-multi-line)
|
|
|
471 (make-local-variable 'forms-forms-scroll)
|
|
|
472 (make-local-variable 'forms-forms-jump)
|
14732
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
473 (make-local-variable 'forms-insert-after)
|
|
4121
|
474 (make-local-variable 'forms-use-text-properties)
|
|
8344
|
475
|
|
|
476 ;; Filter functions.
|
|
|
477 (make-local-variable 'forms-read-file-filter)
|
|
|
478 (make-local-variable 'forms-write-file-filter)
|
|
4790
|
479 (make-local-variable 'forms-new-record-filter)
|
|
|
480 (make-local-variable 'forms-modified-record-filter)
|
|
4121
|
481
|
|
|
482 ;; Make sure no filters exist.
|
|
8344
|
483 (setq forms-read-file-filter nil)
|
|
|
484 (setq forms-write-file-filter nil)
|
|
4790
|
485 (setq forms-new-record-filter nil)
|
|
|
486 (setq forms-modified-record-filter nil)
|
|
4121
|
487
|
|
|
488 ;; If running Emacs 19 under X, setup faces to show read-only and
|
|
|
489 ;; read-write fields.
|
|
|
490 (if (fboundp 'make-face)
|
|
|
491 (progn
|
|
|
492 (make-local-variable 'forms-ro-face)
|
|
|
493 (make-local-variable 'forms-rw-face)))
|
|
276
|
494
|
|
|
495 ;; eval the buffer, should set variables
|
|
4121
|
496 ;;(message "forms: processing control file...")
|
7863
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
497 ;; If enable-local-eval is not set to t the user is asked first.
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
498 (if (or (eq enable-local-eval t)
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
499 (yes-or-no-p
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
500 (concat "Evaluate lisp code in buffer "
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
501 (buffer-name) " to display forms ")))
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
502 (eval-current-buffer)
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
503 (error "`enable-local-eval' inhibits buffer evaluation"))
|
|
276
|
504
|
|
8344
|
505 ;; Check if the mandatory variables make sense.
|
|
276
|
506 (or forms-file
|
|
4790
|
507 (error (concat "Forms control file error: "
|
|
18223
|
508 "`forms-file' has not been set")))
|
|
8344
|
509
|
|
|
510 ;; Check forms-field-sep first, since it can be needed to
|
|
|
511 ;; construct a default format list.
|
|
4790
|
512 (or (stringp forms-field-sep)
|
|
|
513 (error (concat "Forms control file error: "
|
|
18223
|
514 "`forms-field-sep' is not a string")))
|
|
8344
|
515
|
|
|
516 (if forms-number-of-fields
|
|
|
517 (or (and (numberp forms-number-of-fields)
|
|
|
518 (> forms-number-of-fields 0))
|
|
|
519 (error (concat "Forms control file error: "
|
|
18223
|
520 "`forms-number-of-fields' must be a number > 0")))
|
|
8344
|
521 (or (null forms-format-list)
|
|
|
522 (error (concat "Forms control file error: "
|
|
18223
|
523 "`forms-number-of-fields' has not been set"))))
|
|
8344
|
524
|
|
|
525 (or forms-format-list
|
|
|
526 (forms--intuit-from-file))
|
|
|
527
|
|
276
|
528 (if forms-multi-line
|
|
|
529 (if (and (stringp forms-multi-line)
|
|
|
530 (eq (length forms-multi-line) 1))
|
|
|
531 (if (string= forms-multi-line forms-field-sep)
|
|
4790
|
532 (error (concat "Forms control file error: "
|
|
18223
|
533 "`forms-multi-line' is equal to 'forms-field-sep'")))
|
|
4790
|
534 (error (concat "Forms control file error: "
|
|
18223
|
535 "`forms-multi-line' must be nil or a one-character string"))))
|
|
4121
|
536 (or (fboundp 'set-text-properties)
|
|
|
537 (setq forms-use-text-properties nil))
|
|
276
|
538
|
|
4121
|
539 ;; Validate and process forms-format-list.
|
|
|
540 ;;(message "forms: pre-processing format list...")
|
|
18215
|
541 (make-local-variable 'forms--elements)
|
|
276
|
542 (forms--process-format-list)
|
|
|
543
|
|
4121
|
544 ;; Build the formatter and parser.
|
|
|
545 ;;(message "forms: building formatter...")
|
|
276
|
546 (make-local-variable 'forms--format)
|
|
4121
|
547 (make-local-variable 'forms--markers)
|
|
|
548 (make-local-variable 'forms--dyntexts)
|
|
|
549 ;;(message "forms: building parser...")
|
|
276
|
550 (forms--make-format)
|
|
|
551 (make-local-variable 'forms--parser)
|
|
|
552 (forms--make-parser)
|
|
4121
|
553 ;;(message "forms: building parser... done.")
|
|
276
|
554
|
|
4121
|
555 ;; Check if record filters are defined.
|
|
4790
|
556 (if (and forms-new-record-filter
|
|
|
557 (not (fboundp forms-new-record-filter)))
|
|
|
558 (error (concat "Forms control file error: "
|
|
18223
|
559 "`forms-new-record-filter' is not a function")))
|
|
4790
|
560
|
|
|
561 (if (and forms-modified-record-filter
|
|
|
562 (not (fboundp forms-modified-record-filter)))
|
|
|
563 (error (concat "Forms control file error: "
|
|
18223
|
564 "`forms-modified-record-filter' is not a function")))
|
|
276
|
565
|
|
4121
|
566 ;; The filters acces the contents of the forms using `forms-fields'.
|
|
307
|
567 (make-local-variable 'forms-fields)
|
|
276
|
568
|
|
4121
|
569 ;; Dynamic text support.
|
|
|
570 (make-local-variable 'forms--dynamic-text)
|
|
276
|
571
|
|
4121
|
572 ;; Prevent accidental overwrite of the control file and autosave.
|
7381
9e7dd6d12e1f
(forms-mode): Set visited file name to nil to prevent overwrite and autosave.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
573 (set-visited-file-name nil)
|
|
276
|
574
|
|
4121
|
575 ;; Prepare this buffer for further processing.
|
|
|
576 (setq buffer-read-only nil)
|
|
|
577 (erase-buffer)
|
|
|
578
|
|
|
579 ;;(message "forms: setting up... done.")
|
|
|
580 ))
|
|
|
581
|
7863
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
582 ;; initialization done
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
583 (setq forms--mode-setup t)
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
584
|
|
4121
|
585 ;; Copy desired faces to the actual variables used by the forms formatter.
|
|
|
586 (if (fboundp 'make-face)
|
|
|
587 (progn
|
|
|
588 (make-local-variable 'forms--ro-face)
|
|
|
589 (make-local-variable 'forms--rw-face)
|
|
|
590 (if forms-read-only
|
|
|
591 (progn
|
|
|
592 (setq forms--ro-face forms-ro-face)
|
|
|
593 (setq forms--rw-face forms-ro-face))
|
|
|
594 (setq forms--ro-face forms-ro-face)
|
|
|
595 (setq forms--rw-face forms-rw-face))))
|
|
276
|
596
|
|
3941
|
597 ;; Make more local variables.
|
|
276
|
598 (make-local-variable 'forms--file-buffer)
|
|
|
599 (make-local-variable 'forms--total-records)
|
|
|
600 (make-local-variable 'forms--current-record)
|
|
|
601 (make-local-variable 'forms--the-record-list)
|
|
4121
|
602 (make-local-variable 'forms--search-regexp)
|
|
276
|
603
|
|
4790
|
604 ; The keymaps are global, so multiple forms mode buffers can share them.
|
|
|
605 ;(make-local-variable 'forms-mode-map)
|
|
|
606 ;(make-local-variable 'forms-mode-ro-map)
|
|
|
607 ;(make-local-variable 'forms-mode-edit-map)
|
|
276
|
608 (if forms-mode-map ; already defined
|
|
|
609 nil
|
|
4121
|
610 ;;(message "forms: building keymap...")
|
|
4790
|
611 (forms--mode-commands)
|
|
4121
|
612 ;;(message "forms: building keymap... done.")
|
|
|
613 )
|
|
276
|
614
|
|
6561
|
615 ;; set the major mode indicator
|
|
|
616 (setq major-mode 'forms-mode)
|
|
|
617 (setq mode-name "Forms")
|
|
|
618
|
|
276
|
619 ;; find the data file
|
|
|
620 (setq forms--file-buffer (find-file-noselect forms-file))
|
|
|
621
|
|
8344
|
622 ;; Pre-transform.
|
|
|
623 (let ((read-file-filter forms-read-file-filter)
|
|
|
624 (write-file-filter forms-write-file-filter))
|
|
|
625 (if read-file-filter
|
|
|
626 (save-excursion
|
|
|
627 (set-buffer forms--file-buffer)
|
|
10346
|
628 (let ((inhibit-read-only t)
|
|
|
629 (file-modified (buffer-modified-p)))
|
|
|
630 (run-hooks 'read-file-filter)
|
|
|
631 (if (not file-modified) (set-buffer-modified-p nil)))
|
|
8344
|
632 (if write-file-filter
|
|
|
633 (progn
|
|
|
634 (make-variable-buffer-local 'local-write-file-hooks)
|
|
|
635 (setq local-write-file-hooks (list write-file-filter)))))
|
|
|
636 (if write-file-filter
|
|
|
637 (save-excursion
|
|
|
638 (set-buffer forms--file-buffer)
|
|
|
639 (make-variable-buffer-local 'local-write-file-hooks)
|
|
12508
|
640 (setq local-write-file-hooks (list write-file-filter))))))
|
|
8344
|
641
|
|
276
|
642 ;; count the number of records, and set see if it may be modified
|
|
|
643 (let (ro)
|
|
|
644 (setq forms--total-records
|
|
|
645 (save-excursion
|
|
4121
|
646 (prog1
|
|
|
647 (progn
|
|
|
648 ;;(message "forms: counting records...")
|
|
|
649 (set-buffer forms--file-buffer)
|
|
|
650 (bury-buffer (current-buffer))
|
|
|
651 (setq ro buffer-read-only)
|
|
|
652 (count-lines (point-min) (point-max)))
|
|
|
653 ;;(message "forms: counting records... done.")
|
|
|
654 )))
|
|
276
|
655 (if ro
|
|
|
656 (setq forms-read-only t)))
|
|
|
657
|
|
4121
|
658 ;;(message "forms: proceeding setup...")
|
|
4867
|
659
|
|
|
660 ;; Since we aren't really implementing a minor mode, we hack the modeline
|
|
|
661 ;; directly to get the text " View " into forms-read-only form buffers. For
|
|
|
662 ;; that reason, this variable must be buffer only.
|
|
|
663 (make-local-variable 'minor-mode-alist)
|
|
|
664 (setq minor-mode-alist (list (list 'forms-read-only " View")))
|
|
|
665
|
|
4121
|
666 ;;(message "forms: proceeding setup (keymaps)...")
|
|
276
|
667 (forms--set-keymaps)
|
|
4121
|
668 ;;(message "forms: proceeding setup (commands)...")
|
|
3827
|
669 (forms--change-commands)
|
|
276
|
670
|
|
4121
|
671 ;;(message "forms: proceeding setup (buffer)...")
|
|
276
|
672 (set-buffer-modified-p nil)
|
|
|
673
|
|
8344
|
674 (if (= forms--total-records 0)
|
|
|
675 ;;(message "forms: proceeding setup (new file)...")
|
|
|
676 (progn
|
|
|
677 (insert
|
|
|
678 "GNU Emacs Forms Mode version " forms-version "\n\n"
|
|
|
679 (if (file-exists-p forms-file)
|
|
14356
|
680 (concat "No records available in file `" forms-file "'\n\n")
|
|
|
681 (format "Creating new file `%s'\nwith %d field%s per record\n\n"
|
|
8344
|
682 forms-file forms-number-of-fields
|
|
|
683 (if (= 1 forms-number-of-fields) "" "s")))
|
|
|
684 "Use " (substitute-command-keys "\\[forms-insert-record]")
|
|
|
685 " to create new records.\n")
|
|
|
686 (setq forms--current-record 1)
|
|
|
687 (setq buffer-read-only t)
|
|
|
688 (set-buffer-modified-p nil))
|
|
|
689
|
|
|
690 ;; setup the first (or current) record to show
|
|
|
691 (if (< forms--current-record 1)
|
|
|
692 (setq forms--current-record 1))
|
|
|
693 (forms-jump-record forms--current-record)
|
|
|
694 )
|
|
276
|
695
|
14732
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
696 (if forms-insert-after
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
697 (forms-last-record)
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
698 (forms-first-record))
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
699
|
|
276
|
700 ;; user customising
|
|
4121
|
701 ;;(message "forms: proceeding setup (user hooks)...")
|
|
276
|
702 (run-hooks 'forms-mode-hooks)
|
|
4121
|
703 ;;(message "forms: setting up... done.")
|
|
276
|
704
|
|
|
705 ;; be helpful
|
|
|
706 (forms--help)
|
7863
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
707 )
|
|
3697
|
708
|
|
4121
|
709 (defun forms--process-format-list ()
|
|
|
710 ;; Validate `forms-format-list' and set some global variables.
|
|
|
711 ;; Symbols in the list are evaluated, and consecutive strings are
|
|
|
712 ;; concatenated.
|
|
|
713 ;; Array `forms--elements' is constructed that contains the order
|
|
|
714 ;; of the fields on the display. This array is used by
|
|
|
715 ;; `forms--parser-using-text-properties' to extract the fields data
|
|
|
716 ;; from the form on the screen.
|
|
13984
|
717 ;; Upon completion, `forms-format-list' is guaranteed correct, so
|
|
4121
|
718 ;; `forms--make-format' and `forms--make-parser' do not need to perform
|
|
|
719 ;; any checks.
|
|
276
|
720
|
|
4121
|
721 ;; Verify that `forms-format-list' is not nil.
|
|
276
|
722 (or forms-format-list
|
|
4790
|
723 (error (concat "Forms control file error: "
|
|
18223
|
724 "`forms-format-list' has not been set")))
|
|
4121
|
725 ;; It must be a list.
|
|
276
|
726 (or (listp forms-format-list)
|
|
4790
|
727 (error (concat "Forms control file error: "
|
|
18223
|
728 "`forms-format-list' is not a list")))
|
|
276
|
729
|
|
4121
|
730 ;; Assume every field is painted once.
|
|
|
731 ;; `forms--elements' will grow if needed.
|
|
|
732 (setq forms--elements (make-vector forms-number-of-fields nil))
|
|
276
|
733
|
|
|
734 (let ((the-list forms-format-list) ; the list of format elements
|
|
307
|
735 (this-item 0) ; element in list
|
|
4121
|
736 (prev-item nil)
|
|
276
|
737 (field-num 0)) ; highest field number
|
|
|
738
|
|
307
|
739 (setq forms-format-list nil) ; gonna rebuild
|
|
|
740
|
|
276
|
741 (while the-list
|
|
|
742
|
|
|
743 (let ((el (car-safe the-list))
|
|
|
744 (rem (cdr-safe the-list)))
|
|
|
745
|
|
4121
|
746 ;; If it is a symbol, eval it first.
|
|
307
|
747 (if (and (symbolp el)
|
|
|
748 (boundp el))
|
|
|
749 (setq el (eval el)))
|
|
|
750
|
|
276
|
751 (cond
|
|
|
752
|
|
4121
|
753 ;; Try string ...
|
|
|
754 ((stringp el)
|
|
|
755 (if (stringp prev-item) ; try to concatenate strings
|
|
|
756 (setq prev-item (concat prev-item el))
|
|
|
757 (if prev-item
|
|
|
758 (setq forms-format-list
|
|
|
759 (append forms-format-list (list prev-item) nil)))
|
|
|
760 (setq prev-item el)))
|
|
|
761
|
|
|
762 ;; Try numeric ...
|
|
307
|
763 ((numberp el)
|
|
276
|
764
|
|
4121
|
765 ;; Validate range.
|
|
276
|
766 (if (or (<= el 0)
|
|
|
767 (> el forms-number-of-fields))
|
|
4790
|
768 (error (concat "Forms format error: "
|
|
|
769 "field number %d out of range 1..%d")
|
|
|
770 el forms-number-of-fields))
|
|
276
|
771
|
|
4121
|
772 ;; Store forms order.
|
|
18215
|
773 (if (>= field-num (length forms--elements))
|
|
4121
|
774 (setq forms--elements (vconcat forms--elements (1- el)))
|
|
|
775 (aset forms--elements field-num (1- el)))
|
|
|
776 (setq field-num (1+ field-num))
|
|
276
|
777
|
|
4121
|
778 (if prev-item
|
|
|
779 (setq forms-format-list
|
|
4723
|
780 (append forms-format-list (list prev-item) nil)))
|
|
4121
|
781 (setq prev-item el))
|
|
|
782
|
|
|
783 ;; Try function ...
|
|
307
|
784 ((listp el)
|
|
4121
|
785
|
|
|
786 ;; Validate.
|
|
307
|
787 (or (fboundp (car-safe el))
|
|
4790
|
788 (error (concat "Forms format error: "
|
|
18223
|
789 "%S is not a function")
|
|
14421
|
790 (car-safe el)))
|
|
4121
|
791
|
|
|
792 ;; Shift.
|
|
|
793 (if prev-item
|
|
|
794 (setq forms-format-list
|
|
|
795 (append forms-format-list (list prev-item) nil)))
|
|
|
796 (setq prev-item el))
|
|
307
|
797
|
|
276
|
798 ;; else
|
|
|
799 (t
|
|
4790
|
800 (error (concat "Forms format error: "
|
|
14421
|
801 "invalid element %S")
|
|
|
802 el)))
|
|
276
|
803
|
|
4121
|
804 ;; Advance to next element of the list.
|
|
|
805 (setq the-list rem)))
|
|
307
|
806
|
|
4121
|
807 ;; Append last item.
|
|
|
808 (if prev-item
|
|
|
809 (progn
|
|
|
810 (setq forms-format-list
|
|
|
811 (append forms-format-list (list prev-item) nil))
|
|
|
812 ;; Append a newline if the last item is a field.
|
|
4723
|
813 ;; This prevents parsing problems.
|
|
4121
|
814 ;; Also it makes it possible to insert an empty last field.
|
|
|
815 (if (numberp prev-item)
|
|
|
816 (setq forms-format-list
|
|
|
817 (append forms-format-list (list "\n") nil))))))
|
|
307
|
818
|
|
4121
|
819 (forms--debug 'forms-format-list
|
|
|
820 'forms--elements))
|
|
3697
|
821
|
|
4121
|
822 ;; Special treatment for read-only segments.
|
|
|
823 ;;
|
|
18215
|
824 ;; If text is inserted between two read-only segments, there seems to
|
|
|
825 ;; be no way to give the newly inserted text the RW face.
|
|
4723
|
826 ;; To solve this, read-only segments get the `insert-in-front-hooks'
|
|
18215
|
827 ;; property set with a function that temporarily switches the
|
|
|
828 ;; properties of the first character of the segment to the RW face, so
|
|
|
829 ;; the new text gets the right face. The `post-command-hook' is
|
|
|
830 ;; used to restore the original properties.
|
|
4121
|
831
|
|
4723
|
832 (defvar forms--iif-start nil
|
|
4121
|
833 "Record start of modification command.")
|
|
4723
|
834 (defvar forms--iif-properties nil
|
|
4121
|
835 "Original properties of the character being overridden.")
|
|
|
836
|
|
4723
|
837 (defun forms--iif-hook (begin end)
|
|
|
838 "`insert-in-front-hooks' function for read-only segments."
|
|
4121
|
839
|
|
4723
|
840 ;; Note start location. By making it a marker that points one
|
|
|
841 ;; character beyond the actual location, it is guaranteed to move
|
|
|
842 ;; correctly if text is inserted.
|
|
|
843 (or forms--iif-start
|
|
|
844 (setq forms--iif-start (copy-marker (1+ (point)))))
|
|
4121
|
845
|
|
4723
|
846 ;; Check if there is special treatment required.
|
|
|
847 (if (or (<= forms--iif-start 2)
|
|
|
848 (get-text-property (- forms--iif-start 2)
|
|
|
849 'read-only))
|
|
|
850 (progn
|
|
|
851 ;; Fetch current properties.
|
|
|
852 (setq forms--iif-properties
|
|
|
853 (text-properties-at (1- forms--iif-start)))
|
|
4121
|
854
|
|
4723
|
855 ;; Replace them.
|
|
|
856 (let ((inhibit-read-only t))
|
|
|
857 (set-text-properties
|
|
|
858 (1- forms--iif-start) forms--iif-start
|
|
|
859 (list 'face forms--rw-face 'front-sticky '(face))))
|
|
4121
|
860
|
|
4723
|
861 ;; Enable `post-command-hook' to restore the properties.
|
|
|
862 (setq post-command-hook
|
|
|
863 (append (list 'forms--iif-post-command-hook) post-command-hook)))
|
|
4121
|
864
|
|
4723
|
865 ;; No action needed. Clear marker.
|
|
|
866 (setq forms--iif-start nil)))
|
|
|
867
|
|
|
868 (defun forms--iif-post-command-hook ()
|
|
|
869 "`post-command-hook' function for read-only segments."
|
|
4121
|
870
|
|
|
871 ;; Disable `post-command-hook'.
|
|
|
872 (setq post-command-hook
|
|
4723
|
873 (delq 'forms--iif-hook-post-command-hook post-command-hook))
|
|
4121
|
874
|
|
|
875 ;; Restore properties.
|
|
4723
|
876 (if forms--iif-start
|
|
4121
|
877 (let ((inhibit-read-only t))
|
|
|
878 (set-text-properties
|
|
4723
|
879 (1- forms--iif-start) forms--iif-start
|
|
|
880 forms--iif-properties)))
|
|
4121
|
881
|
|
|
882 ;; Cleanup.
|
|
4723
|
883 (setq forms--iif-start nil))
|
|
4121
|
884
|
|
|
885 (defvar forms--marker)
|
|
|
886 (defvar forms--dyntext)
|
|
276
|
887
|
|
|
888 (defun forms--make-format ()
|
|
4121
|
889 "Generate `forms--format' using the information in `forms-format-list'."
|
|
|
890
|
|
|
891 ;; The real work is done using a mapcar of `forms--make-format-elt' on
|
|
|
892 ;; `forms-format-list'.
|
|
|
893 ;; This function sets up the necessary environment, and decides
|
|
|
894 ;; which function to mapcar.
|
|
|
895
|
|
|
896 (let ((forms--marker 0)
|
|
|
897 (forms--dyntext 0))
|
|
|
898 (setq
|
|
|
899 forms--format
|
|
|
900 (if forms-use-text-properties
|
|
|
901 (` (lambda (arg)
|
|
|
902 (let ((inhibit-read-only t))
|
|
|
903 (,@ (apply 'append
|
|
|
904 (mapcar 'forms--make-format-elt-using-text-properties
|
|
4723
|
905 forms-format-list)))
|
|
|
906 ;; Prevent insertion before the first text.
|
|
|
907 (,@ (if (numberp (car forms-format-list))
|
|
|
908 nil
|
|
|
909 '((add-text-properties (point-min) (1+ (point-min))
|
|
11557
|
910 '(front-sticky (read-only intangible))))))
|
|
4723
|
911 ;; Prevent insertion after the last text.
|
|
|
912 (remove-text-properties (1- (point)) (point)
|
|
|
913 '(rear-nonsticky)))
|
|
|
914 (setq forms--iif-start nil)))
|
|
4121
|
915 (` (lambda (arg)
|
|
|
916 (,@ (apply 'append
|
|
|
917 (mapcar 'forms--make-format-elt forms-format-list)))))))
|
|
|
918
|
|
|
919 ;; We have tallied the number of markers and dynamic texts,
|
|
|
920 ;; so we can allocate the arrays now.
|
|
|
921 (setq forms--markers (make-vector forms--marker nil))
|
|
|
922 (setq forms--dyntexts (make-vector forms--dyntext nil)))
|
|
307
|
923 (forms--debug 'forms--format))
|
|
276
|
924
|
|
4121
|
925 (defun forms--make-format-elt-using-text-properties (el)
|
|
|
926 "Helper routine to generate format function."
|
|
|
927
|
|
|
928 ;; The format routine `forms--format' will look like
|
|
|
929 ;;
|
|
|
930 ;; ;; preamble
|
|
|
931 ;; (lambda (arg)
|
|
|
932 ;; (let ((inhibit-read-only t))
|
|
|
933 ;;
|
|
4723
|
934 ;; ;; A string, e.g. "text: ".
|
|
4121
|
935 ;; (set-text-properties
|
|
|
936 ;; (point)
|
|
|
937 ;; (progn (insert "text: ") (point))
|
|
4723
|
938 ;; (list 'face forms--ro-face
|
|
|
939 ;; 'read-only 1
|
|
|
940 ;; 'insert-in-front-hooks 'forms--iif-hook
|
|
|
941 ;; 'rear-nonsticky '(read-only face insert-in-front-hooks)))
|
|
4121
|
942 ;;
|
|
4723
|
943 ;; ;; A field, e.g. 6.
|
|
4121
|
944 ;; (let ((here (point)))
|
|
|
945 ;; (aset forms--markers 0 (point-marker))
|
|
|
946 ;; (insert (elt arg 5))
|
|
|
947 ;; (or (= (point) here)
|
|
|
948 ;; (set-text-properties
|
|
|
949 ;; here (point)
|
|
4723
|
950 ;; (list 'face forms--rw-face
|
|
|
951 ;; 'front-sticky '(face))))
|
|
4121
|
952 ;;
|
|
4723
|
953 ;; ;; Another string, e.g. "\nmore text: ".
|
|
4121
|
954 ;; (set-text-properties
|
|
|
955 ;; (point)
|
|
|
956 ;; (progn (insert "\nmore text: ") (point))
|
|
|
957 ;; (list 'face forms--ro-face
|
|
4723
|
958 ;; 'read-only 2
|
|
|
959 ;; 'insert-in-front-hooks 'forms--iif-hook
|
|
|
960 ;; 'rear-nonsticky '(read-only face insert-in-front-hooks)))
|
|
4121
|
961 ;;
|
|
4723
|
962 ;; ;; A function, e.g. (tocol 40).
|
|
4121
|
963 ;; (set-text-properties
|
|
|
964 ;; (point)
|
|
|
965 ;; (progn
|
|
|
966 ;; (insert (aset forms--dyntexts 0 (tocol 40)))
|
|
|
967 ;; (point))
|
|
|
968 ;; (list 'face forms--ro-face
|
|
4723
|
969 ;; 'read-only 2
|
|
|
970 ;; 'insert-in-front-hooks 'forms--iif-hook
|
|
|
971 ;; 'rear-nonsticky '(read-only face insert-in-front-hooks)))
|
|
|
972 ;;
|
|
|
973 ;; ;; Prevent insertion before the first text.
|
|
|
974 ;; (add-text-properties (point-min) (1+ (point-min))
|
|
|
975 ;; '(front-sticky (read-only))))))
|
|
|
976 ;; ;; Prevent insertion after the last text.
|
|
|
977 ;; (remove-text-properties (1- (point)) (point)
|
|
|
978 ;; '(rear-nonsticky)))
|
|
4121
|
979 ;;
|
|
|
980 ;; ;; wrap up
|
|
4723
|
981 ;; (setq forms--iif-start nil)
|
|
4121
|
982 ;; ))
|
|
|
983
|
|
|
984 (cond
|
|
|
985 ((stringp el)
|
|
|
986
|
|
|
987 (` ((set-text-properties
|
|
|
988 (point) ; start at point
|
|
|
989 (progn ; until after insertion
|
|
|
990 (insert (, el))
|
|
|
991 (point))
|
|
|
992 (list 'face forms--ro-face ; read-only appearance
|
|
4723
|
993 'read-only (,@ (list (1+ forms--marker)))
|
|
11557
|
994 'intangible t
|
|
4723
|
995 'insert-in-front-hooks '(forms--iif-hook)
|
|
11557
|
996 'rear-nonsticky '(face read-only insert-in-front-hooks
|
|
|
997 intangible))))))
|
|
4723
|
998
|
|
4121
|
999 ((numberp el)
|
|
|
1000 (` ((let ((here (point)))
|
|
|
1001 (aset forms--markers
|
|
|
1002 (, (prog1 forms--marker
|
|
|
1003 (setq forms--marker (1+ forms--marker))))
|
|
|
1004 (point-marker))
|
|
|
1005 (insert (elt arg (, (1- el))))
|
|
|
1006 (or (= (point) here)
|
|
|
1007 (set-text-properties
|
|
|
1008 here (point)
|
|
4723
|
1009 (list 'face forms--rw-face
|
|
|
1010 'front-sticky '(face))))))))
|
|
4121
|
1011
|
|
|
1012 ((listp el)
|
|
|
1013 (` ((set-text-properties
|
|
|
1014 (point)
|
|
|
1015 (progn
|
|
|
1016 (insert (aset forms--dyntexts
|
|
|
1017 (, (prog1 forms--dyntext
|
|
|
1018 (setq forms--dyntext (1+ forms--dyntext))))
|
|
|
1019 (, el)))
|
|
|
1020 (point))
|
|
|
1021 (list 'face forms--ro-face
|
|
4723
|
1022 'read-only (,@ (list (1+ forms--marker)))
|
|
11557
|
1023 'intangible t
|
|
4723
|
1024 'insert-in-front-hooks '(forms--iif-hook)
|
|
11557
|
1025 'rear-nonsticky '(read-only face insert-in-front-hooks
|
|
|
1026 intangible))))))
|
|
4121
|
1027
|
|
|
1028 ;; end of cond
|
|
|
1029 ))
|
|
276
|
1030
|
|
|
1031 (defun forms--make-format-elt (el)
|
|
4121
|
1032 "Helper routine to generate format function."
|
|
|
1033
|
|
|
1034 ;; If we're not using text properties, the format routine
|
|
|
1035 ;; `forms--format' will look like
|
|
|
1036 ;;
|
|
|
1037 ;; (lambda (arg)
|
|
|
1038 ;; ;; a string, e.g. "text: "
|
|
|
1039 ;; (insert "text: ")
|
|
|
1040 ;; ;; a field, e.g. 6
|
|
|
1041 ;; (aset forms--markers 0 (point-marker))
|
|
|
1042 ;; (insert (elt arg 5))
|
|
|
1043 ;; ;; another string, e.g. "\nmore text: "
|
|
|
1044 ;; (insert "\nmore text: ")
|
|
|
1045 ;; ;; a function, e.g. (tocol 40)
|
|
|
1046 ;; (insert (aset forms--dyntexts 0 (tocol 40)))
|
|
|
1047 ;; ... )
|
|
|
1048
|
|
3697
|
1049 (cond
|
|
|
1050 ((stringp el)
|
|
|
1051 (` ((insert (, el)))))
|
|
|
1052 ((numberp el)
|
|
|
1053 (prog1
|
|
4121
|
1054 (` ((aset forms--markers (, forms--marker) (point-marker))
|
|
3697
|
1055 (insert (elt arg (, (1- el))))))
|
|
4121
|
1056 (setq forms--marker (1+ forms--marker))))
|
|
3697
|
1057 ((listp el)
|
|
|
1058 (prog1
|
|
4121
|
1059 (` ((insert (aset forms--dyntexts (, forms--dyntext) (, el)))))
|
|
|
1060 (setq forms--dyntext (1+ forms--dyntext))))))
|
|
3697
|
1061
|
|
4121
|
1062 (defvar forms--field)
|
|
|
1063 (defvar forms--recordv)
|
|
|
1064 (defvar forms--seen-text)
|
|
276
|
1065
|
|
|
1066 (defun forms--make-parser ()
|
|
4121
|
1067 "Generate `forms--parser' from the information in `forms-format-list'."
|
|
|
1068
|
|
|
1069 ;; If we can use text properties, we simply set it to
|
|
|
1070 ;; `forms--parser-using-text-properties'.
|
|
|
1071 ;; Otherwise, the function is constructed using a mapcar of
|
|
|
1072 ;; `forms--make-parser-elt on `forms-format-list'.
|
|
|
1073
|
|
|
1074 (setq
|
|
|
1075 forms--parser
|
|
|
1076 (if forms-use-text-properties
|
|
|
1077 (function forms--parser-using-text-properties)
|
|
|
1078 (let ((forms--field nil)
|
|
|
1079 (forms--seen-text nil)
|
|
|
1080 (forms--dyntext 0))
|
|
|
1081
|
|
|
1082 ;; Note: we add a nil element to the list passed to `mapcar',
|
|
|
1083 ;; see `forms--make-parser-elt' for details.
|
|
|
1084 (` (lambda nil
|
|
|
1085 (let (here)
|
|
|
1086 (goto-char (point-min))
|
|
|
1087 (,@ (apply 'append
|
|
|
1088 (mapcar
|
|
|
1089 'forms--make-parser-elt
|
|
|
1090 (append forms-format-list (list nil)))))))))))
|
|
|
1091
|
|
307
|
1092 (forms--debug 'forms--parser))
|
|
276
|
1093
|
|
4121
|
1094 (defun forms--parser-using-text-properties ()
|
|
|
1095 "Extract field info from forms when using text properties."
|
|
|
1096
|
|
|
1097 ;; Using text properties, we can simply jump to the markers, and
|
|
|
1098 ;; extract the information up to the following read-only segment.
|
|
|
1099
|
|
|
1100 (let ((i 0)
|
|
|
1101 here there)
|
|
|
1102 (while (< i (length forms--markers))
|
|
|
1103 (goto-char (setq here (aref forms--markers i)))
|
|
|
1104 (if (get-text-property here 'read-only)
|
|
|
1105 (aset forms--recordv (aref forms--elements i) nil)
|
|
|
1106 (if (setq there
|
|
|
1107 (next-single-property-change here 'read-only))
|
|
|
1108 (aset forms--recordv (aref forms--elements i)
|
13569
438ebe3b6f8d
Use `buffer-substring-no-properties' instead of `buffer-substring' to
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1109 (buffer-substring-no-properties here there))
|
|
4121
|
1110 (aset forms--recordv (aref forms--elements i)
|
13569
438ebe3b6f8d
Use `buffer-substring-no-properties' instead of `buffer-substring' to
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1111 (buffer-substring-no-properties here (point-max)))))
|
|
4121
|
1112 (setq i (1+ i)))))
|
|
276
|
1113
|
|
|
1114 (defun forms--make-parser-elt (el)
|
|
4121
|
1115 "Helper routine to generate forms parser function."
|
|
|
1116
|
|
|
1117 ;; The parse routine will look like:
|
|
|
1118 ;;
|
|
|
1119 ;; (lambda nil
|
|
|
1120 ;; (let (here)
|
|
|
1121 ;; (goto-char (point-min))
|
|
|
1122 ;;
|
|
|
1123 ;; ;; "text: "
|
|
|
1124 ;; (if (not (looking-at "text: "))
|
|
|
1125 ;; (error "Parse error: cannot find \"text: \""))
|
|
|
1126 ;; (forward-char 6) ; past "text: "
|
|
|
1127 ;;
|
|
|
1128 ;; ;; 6
|
|
|
1129 ;; ;; "\nmore text: "
|
|
|
1130 ;; (setq here (point))
|
|
|
1131 ;; (if (not (search-forward "\nmore text: " nil t nil))
|
|
|
1132 ;; (error "Parse error: cannot find \"\\nmore text: \""))
|
13569
438ebe3b6f8d
Use `buffer-substring-no-properties' instead of `buffer-substring' to
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1133 ;; (aset forms--recordv 5 (buffer-substring-no-properties here (- (point) 12)))
|
|
4121
|
1134 ;;
|
|
|
1135 ;; ;; (tocol 40)
|
|
|
1136 ;; (let ((forms--dyntext (car-safe forms--dynamic-text)))
|
|
|
1137 ;; (if (not (looking-at (regexp-quote forms--dyntext)))
|
|
|
1138 ;; (error "Parse error: not looking at \"%s\"" forms--dyntext))
|
|
|
1139 ;; (forward-char (length forms--dyntext))
|
|
|
1140 ;; (setq forms--dynamic-text (cdr-safe forms--dynamic-text)))
|
|
|
1141 ;; ...
|
|
|
1142 ;; ;; final flush (due to terminator sentinel, see below)
|
13569
438ebe3b6f8d
Use `buffer-substring-no-properties' instead of `buffer-substring' to
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1143 ;; (aset forms--recordv 7 (buffer-substring-no-properties (point) (point-max)))
|
|
4121
|
1144
|
|
307
|
1145 (cond
|
|
|
1146 ((stringp el)
|
|
|
1147 (prog1
|
|
4121
|
1148 (if forms--field
|
|
307
|
1149 (` ((setq here (point))
|
|
|
1150 (if (not (search-forward (, el) nil t nil))
|
|
18223
|
1151 (error "Parse error: cannot find `%s'" (, el)))
|
|
4121
|
1152 (aset forms--recordv (, (1- forms--field))
|
13569
438ebe3b6f8d
Use `buffer-substring-no-properties' instead of `buffer-substring' to
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1153 (buffer-substring-no-properties here
|
|
307
|
1154 (- (point) (, (length el)))))))
|
|
|
1155 (` ((if (not (looking-at (, (regexp-quote el))))
|
|
18223
|
1156 (error "Parse error: not looking at `%s'" (, el)))
|
|
307
|
1157 (forward-char (, (length el))))))
|
|
4121
|
1158 (setq forms--seen-text t)
|
|
|
1159 (setq forms--field nil)))
|
|
307
|
1160 ((numberp el)
|
|
4121
|
1161 (if forms--field
|
|
307
|
1162 (error "Cannot parse adjacent fields %d and %d"
|
|
4121
|
1163 forms--field el)
|
|
|
1164 (setq forms--field el)
|
|
307
|
1165 nil))
|
|
|
1166 ((null el)
|
|
4121
|
1167 (if forms--field
|
|
|
1168 (` ((aset forms--recordv (, (1- forms--field))
|
13569
438ebe3b6f8d
Use `buffer-substring-no-properties' instead of `buffer-substring' to
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1169 (buffer-substring-no-properties (point) (point-max)))))))
|
|
307
|
1170 ((listp el)
|
|
|
1171 (prog1
|
|
4121
|
1172 (if forms--field
|
|
307
|
1173 (` ((let ((here (point))
|
|
4121
|
1174 (forms--dyntext (aref forms--dyntexts (, forms--dyntext))))
|
|
|
1175 (if (not (search-forward forms--dyntext nil t nil))
|
|
18223
|
1176 (error "Parse error: cannot find `%s'" forms--dyntext))
|
|
4121
|
1177 (aset forms--recordv (, (1- forms--field))
|
13569
438ebe3b6f8d
Use `buffer-substring-no-properties' instead of `buffer-substring' to
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1178 (buffer-substring-no-properties here
|
|
4121
|
1179 (- (point) (length forms--dyntext)))))))
|
|
|
1180 (` ((let ((forms--dyntext (aref forms--dyntexts (, forms--dyntext))))
|
|
|
1181 (if (not (looking-at (regexp-quote forms--dyntext)))
|
|
18223
|
1182 (error "Parse error: not looking at `%s'" forms--dyntext))
|
|
4121
|
1183 (forward-char (length forms--dyntext))))))
|
|
|
1184 (setq forms--dyntext (1+ forms--dyntext))
|
|
|
1185 (setq forms--seen-text t)
|
|
|
1186 (setq forms--field nil)))
|
|
307
|
1187 ))
|
|
3697
|
1188
|
|
8344
|
1189 (defun forms--intuit-from-file ()
|
|
|
1190 "Get number of fields and a default form using the data file."
|
|
|
1191
|
|
|
1192 ;; If `forms-number-of-fields' is not set, get it from the data file.
|
|
|
1193 (if (null forms-number-of-fields)
|
|
|
1194
|
|
|
1195 ;; Need a file to do this.
|
|
|
1196 (if (not (file-exists-p forms-file))
|
|
|
1197 (error "Need existing file or explicit 'forms-number-of-records'.")
|
|
|
1198
|
|
|
1199 ;; Visit the file and extract the first record.
|
|
|
1200 (setq forms--file-buffer (find-file-noselect forms-file))
|
|
|
1201 (let ((read-file-filter forms-read-file-filter)
|
|
|
1202 (the-record))
|
|
|
1203 (setq the-record
|
|
|
1204 (save-excursion
|
|
|
1205 (set-buffer forms--file-buffer)
|
|
|
1206 (let ((inhibit-read-only t))
|
|
|
1207 (run-hooks 'read-file-filter))
|
|
|
1208 (goto-char (point-min))
|
|
|
1209 (forms--get-record)))
|
|
|
1210
|
|
|
1211 ;; This may be overkill, but try to avoid interference with
|
|
|
1212 ;; the normal processing.
|
|
|
1213 (kill-buffer forms--file-buffer)
|
|
|
1214
|
|
|
1215 ;; Count the number of fields in `the-record'.
|
|
|
1216 (let (the-result
|
|
|
1217 (start-pos 0)
|
|
|
1218 found-pos
|
|
|
1219 (field-sep-length (length forms-field-sep)))
|
|
|
1220 (setq forms-number-of-fields 1)
|
|
|
1221 (while (setq found-pos
|
|
|
1222 (string-match forms-field-sep the-record start-pos))
|
|
|
1223 (progn
|
|
|
1224 (setq forms-number-of-fields (1+ forms-number-of-fields))
|
|
|
1225 (setq start-pos (+ field-sep-length found-pos))))))))
|
|
|
1226
|
|
|
1227 ;; Construct default format list.
|
|
|
1228 (setq forms-format-list (list "Forms file \"" forms-file "\".\n\n"))
|
|
|
1229 (let ((i 0))
|
|
|
1230 (while (<= (setq i (1+ i)) forms-number-of-fields)
|
|
|
1231 (setq forms-format-list
|
|
|
1232 (append forms-format-list
|
|
|
1233 (list (format "%4d: " i) i "\n"))))))
|
|
|
1234
|
|
276
|
1235 (defun forms--set-keymaps ()
|
|
|
1236 "Set the keymaps used in this mode."
|
|
|
1237
|
|
4790
|
1238 (use-local-map (if forms-read-only
|
|
|
1239 forms-mode-ro-map
|
|
|
1240 forms-mode-edit-map)))
|
|
|
1241
|
|
|
1242 (defun forms--mode-commands ()
|
|
|
1243 "Fill the Forms mode keymaps."
|
|
276
|
1244
|
|
4790
|
1245 ;; `forms-mode-map' is always accessible via \C-c prefix.
|
|
|
1246 (setq forms-mode-map (make-keymap))
|
|
|
1247 (define-key forms-mode-map "\t" 'forms-next-field)
|
|
|
1248 (define-key forms-mode-map "\C-k" 'forms-delete-record)
|
|
|
1249 (define-key forms-mode-map "\C-q" 'forms-toggle-read-only)
|
|
|
1250 (define-key forms-mode-map "\C-o" 'forms-insert-record)
|
|
|
1251 (define-key forms-mode-map "\C-l" 'forms-jump-record)
|
|
|
1252 (define-key forms-mode-map "\C-n" 'forms-next-record)
|
|
|
1253 (define-key forms-mode-map "\C-p" 'forms-prev-record)
|
|
10346
|
1254 (define-key forms-mode-map "\C-r" 'forms-search-backward)
|
|
|
1255 (define-key forms-mode-map "\C-s" 'forms-search-forward)
|
|
4790
|
1256 (define-key forms-mode-map "\C-x" 'forms-exit)
|
|
|
1257 (define-key forms-mode-map "<" 'forms-first-record)
|
|
|
1258 (define-key forms-mode-map ">" 'forms-last-record)
|
|
|
1259 (define-key forms-mode-map "\C-?" 'forms-prev-record)
|
|
4121
|
1260
|
|
4790
|
1261 ;; `forms-mode-ro-map' replaces the local map when in read-only mode.
|
|
|
1262 (setq forms-mode-ro-map (make-keymap))
|
|
|
1263 (suppress-keymap forms-mode-ro-map)
|
|
|
1264 (define-key forms-mode-ro-map "\C-c" forms-mode-map)
|
|
|
1265 (define-key forms-mode-ro-map "\t" 'forms-next-field)
|
|
|
1266 (define-key forms-mode-ro-map "q" 'forms-toggle-read-only)
|
|
|
1267 (define-key forms-mode-ro-map "l" 'forms-jump-record)
|
|
|
1268 (define-key forms-mode-ro-map "n" 'forms-next-record)
|
|
|
1269 (define-key forms-mode-ro-map "p" 'forms-prev-record)
|
|
10346
|
1270 (define-key forms-mode-ro-map "r" 'forms-search-backward)
|
|
|
1271 (define-key forms-mode-ro-map "s" 'forms-search-forward)
|
|
4790
|
1272 (define-key forms-mode-ro-map "x" 'forms-exit)
|
|
|
1273 (define-key forms-mode-ro-map "<" 'forms-first-record)
|
|
|
1274 (define-key forms-mode-ro-map ">" 'forms-last-record)
|
|
|
1275 (define-key forms-mode-ro-map "?" 'describe-mode)
|
|
|
1276 (define-key forms-mode-ro-map " " 'forms-next-record)
|
|
|
1277 (forms--mode-commands1 forms-mode-ro-map)
|
|
10346
|
1278 (forms--mode-menu-ro forms-mode-ro-map)
|
|
4790
|
1279
|
|
|
1280 ;; This is the normal, local map.
|
|
|
1281 (setq forms-mode-edit-map (make-keymap))
|
|
|
1282 (define-key forms-mode-edit-map "\t" 'forms-next-field)
|
|
|
1283 (define-key forms-mode-edit-map "\C-c" forms-mode-map)
|
|
|
1284 (forms--mode-commands1 forms-mode-edit-map)
|
|
10346
|
1285 (forms--mode-menu-edit forms-mode-edit-map)
|
|
4790
|
1286 )
|
|
|
1287
|
|
10346
|
1288 (defun forms--mode-menu-ro (map)
|
|
|
1289 ;;; Menu initialisation
|
|
|
1290 ; (define-key map [menu-bar] (make-sparse-keymap))
|
|
|
1291 (define-key map [menu-bar forms]
|
|
|
1292 (cons "Forms" (make-sparse-keymap "Forms")))
|
|
|
1293 (define-key map [menu-bar forms menu-forms-exit]
|
14732
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1294 '("Exit Forms Mode" . forms-exit))
|
|
10346
|
1295 (define-key map [menu-bar forms menu-forms-sep1]
|
|
|
1296 '("----"))
|
|
|
1297 (define-key map [menu-bar forms menu-forms-save]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1298 '("Save Data" . forms-save-buffer))
|
|
10346
|
1299 (define-key map [menu-bar forms menu-forms-print]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1300 '("Print Data" . forms-print))
|
|
10346
|
1301 (define-key map [menu-bar forms menu-forms-describe]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1302 '("Describe Mode" . describe-mode))
|
|
10346
|
1303 (define-key map [menu-bar forms menu-forms-toggle-ro]
|
|
|
1304 '("Toggle View/Edit" . forms-toggle-read-only))
|
|
|
1305 (define-key map [menu-bar forms menu-forms-jump-record]
|
|
|
1306 '("Jump" . forms-jump-record))
|
|
|
1307 (define-key map [menu-bar forms menu-forms-search-backward]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1308 '("Search Backward" . forms-search-backward))
|
|
10346
|
1309 (define-key map [menu-bar forms menu-forms-search-forward]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1310 '("Search Forward" . forms-search-forward))
|
|
10346
|
1311 (define-key map [menu-bar forms menu-forms-delete-record]
|
|
|
1312 '("Delete" . forms-delete-record))
|
|
|
1313 (define-key map [menu-bar forms menu-forms-insert-record]
|
|
|
1314 '("Insert" . forms-insert-record))
|
|
|
1315 (define-key map [menu-bar forms menu-forms-sep2]
|
|
|
1316 '("----"))
|
|
|
1317 (define-key map [menu-bar forms menu-forms-last-record]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1318 '("Last Record" . forms-last-record))
|
|
10346
|
1319 (define-key map [menu-bar forms menu-forms-first-record]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1320 '("First Record" . forms-first-record))
|
|
10346
|
1321 (define-key map [menu-bar forms menu-forms-prev-record]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1322 '("Previous Record" . forms-prev-record))
|
|
10346
|
1323 (define-key map [menu-bar forms menu-forms-next-record]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1324 '("Next Record" . forms-next-record))
|
|
10346
|
1325 (define-key map [menu-bar forms menu-forms-sep3]
|
|
|
1326 '("----"))
|
|
|
1327 (define-key map [menu-bar forms menu-forms-prev-field]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1328 '("Previous Field" . forms-prev-field))
|
|
10346
|
1329 (define-key map [menu-bar forms menu-forms-next-field]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1330 '("Next Field" . forms-next-field))
|
|
10346
|
1331 (put 'forms-insert-record 'menu-enable '(not forms-read-only))
|
|
|
1332 (put 'forms-delete-record 'menu-enable '(not forms-read-only))
|
|
|
1333 )
|
|
|
1334 (defun forms--mode-menu-edit (map)
|
|
|
1335 ;;; Menu initialisation
|
|
|
1336 ; (define-key map [menu-bar] (make-sparse-keymap))
|
|
|
1337 (define-key map [menu-bar forms]
|
|
|
1338 (cons "Forms" (make-sparse-keymap "Forms")))
|
|
|
1339 (define-key map [menu-bar forms menu-forms-edit--exit]
|
|
|
1340 '("Exit" . forms-exit))
|
|
|
1341 (define-key map [menu-bar forms menu-forms-edit-sep1]
|
|
|
1342 '("----"))
|
|
|
1343 (define-key map [menu-bar forms menu-forms-edit-save]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1344 '("Save Data" . forms-save-buffer))
|
|
10346
|
1345 (define-key map [menu-bar forms menu-forms-edit-print]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1346 '("Print Data" . forms-print))
|
|
10346
|
1347 (define-key map [menu-bar forms menu-forms-edit-describe]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1348 '("Describe Mode" . describe-mode))
|
|
10346
|
1349 (define-key map [menu-bar forms menu-forms-edit-toggle-ro]
|
|
|
1350 '("Toggle View/Edit" . forms-toggle-read-only))
|
|
|
1351 (define-key map [menu-bar forms menu-forms-edit-jump-record]
|
|
|
1352 '("Jump" . forms-jump-record))
|
|
|
1353 (define-key map [menu-bar forms menu-forms-edit-search-backward]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1354 '("Search Backward" . forms-search-backward))
|
|
10346
|
1355 (define-key map [menu-bar forms menu-forms-edit-search-forward]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1356 '("Search Forward" . forms-search-forward))
|
|
10346
|
1357 (define-key map [menu-bar forms menu-forms-edit-delete-record]
|
|
|
1358 '("Delete" . forms-delete-record))
|
|
|
1359 (define-key map [menu-bar forms menu-forms-edit-insert-record]
|
|
|
1360 '("Insert" . forms-insert-record))
|
|
|
1361 (define-key map [menu-bar forms menu-forms-edit-sep2]
|
|
|
1362 '("----"))
|
|
|
1363 (define-key map [menu-bar forms menu-forms-edit-last-record]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1364 '("Last Record" . forms-last-record))
|
|
10346
|
1365 (define-key map [menu-bar forms menu-forms-edit-first-record]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1366 '("First Record" . forms-first-record))
|
|
10346
|
1367 (define-key map [menu-bar forms menu-forms-edit-prev-record]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1368 '("Previous Record" . forms-prev-record))
|
|
10346
|
1369 (define-key map [menu-bar forms menu-forms-edit-next-record]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1370 '("Next Record" . forms-next-record))
|
|
10346
|
1371 (define-key map [menu-bar forms menu-forms-edit-sep3]
|
|
|
1372 '("----"))
|
|
|
1373 (define-key map [menu-bar forms menu-forms-edit-prev-field]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1374 '("Previous Field" . forms-prev-field))
|
|
10346
|
1375 (define-key map [menu-bar forms menu-forms-edit-next-field]
|
12031
a59559009d7e
(forms--mode-menu-ro, forms--mode-menu-edit): Fix capitalization in menu bar.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1376 '("Next Field" . forms-next-field))
|
|
10346
|
1377 (put 'forms-insert-record 'menu-enable '(not forms-read-only))
|
|
|
1378 (put 'forms-delete-record 'menu-enable '(not forms-read-only))
|
|
|
1379 )
|
|
|
1380
|
|
|
1381 (defun forms--mode-commands1 (map)
|
|
4790
|
1382 "Helper routine to define keys."
|
|
|
1383 (define-key map [TAB] 'forms-next-field)
|
|
|
1384 (define-key map [S-tab] 'forms-prev-field)
|
|
|
1385 (define-key map [next] 'forms-next-record)
|
|
|
1386 (define-key map [prior] 'forms-prev-record)
|
|
|
1387 (define-key map [begin] 'forms-first-record)
|
|
|
1388 (define-key map [last] 'forms-last-record)
|
|
|
1389 (define-key map [backtab] 'forms-prev-field)
|
|
276
|
1390 )
|
|
3697
|
1391
|
|
276
|
1392 ;;; Changed functions
|
|
|
1393
|
|
|
1394 (defun forms--change-commands ()
|
|
3941
|
1395 "Localize some commands for Forms mode."
|
|
4121
|
1396
|
|
276
|
1397 ;; scroll-down -> forms-prev-record
|
|
|
1398 ;; scroll-up -> forms-next-record
|
|
3828
|
1399 (if forms-forms-scroll
|
|
|
1400 (progn
|
|
|
1401 (substitute-key-definition 'scroll-up 'forms-next-record
|
|
|
1402 (current-local-map)
|
|
|
1403 (current-global-map))
|
|
|
1404 (substitute-key-definition 'scroll-down 'forms-prev-record
|
|
|
1405 (current-local-map)
|
|
|
1406 (current-global-map))))
|
|
276
|
1407 ;;
|
|
|
1408 ;; beginning-of-buffer -> forms-first-record
|
|
|
1409 ;; end-of-buffer -> forms-end-record
|
|
3828
|
1410 (if forms-forms-jump
|
|
|
1411 (progn
|
|
|
1412 (substitute-key-definition 'beginning-of-buffer 'forms-first-record
|
|
|
1413 (current-local-map)
|
|
|
1414 (current-global-map))
|
|
|
1415 (substitute-key-definition 'end-of-buffer 'forms-last-record
|
|
|
1416 (current-local-map)
|
|
|
1417 (current-global-map))))
|
|
276
|
1418 ;;
|
|
8344
|
1419 ;; Save buffer
|
|
|
1420 (local-set-key "\C-x\C-s" 'forms-save-buffer)
|
|
|
1421 ;;
|
7863
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1422 ;; We have our own revert function - use it.
|
|
4790
|
1423 (make-local-variable 'revert-buffer-function)
|
7863
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1424 (setq revert-buffer-function 'forms--revert-buffer)
|
|
4790
|
1425
|
|
|
1426 t)
|
|
276
|
1427
|
|
|
1428 (defun forms--help ()
|
|
3941
|
1429 "Initial help for Forms mode."
|
14315
ab041898078d
(forms--help, forms-search-forward, forms-search-backward): Pass proper format string to message.
Karl Heuer <kwzh@gnu.org>
diff
changeset
|
1430 (message "%s" (substitute-command-keys (concat
|
|
4790
|
1431 "\\[forms-next-record]:next"
|
|
|
1432 " \\[forms-prev-record]:prev"
|
|
|
1433 " \\[forms-first-record]:first"
|
|
|
1434 " \\[forms-last-record]:last"
|
|
|
1435 " \\[describe-mode]:help"))))
|
|
276
|
1436
|
|
|
1437 (defun forms--trans (subj arg rep)
|
|
3941
|
1438 "Translate in SUBJ all chars ARG into char REP. ARG and REP should
|
|
276
|
1439 be single-char strings."
|
|
|
1440 (let ((i 0)
|
|
|
1441 (x (length subj))
|
|
|
1442 (re (regexp-quote arg))
|
|
|
1443 (k (string-to-char rep)))
|
|
|
1444 (while (setq i (string-match re subj i))
|
|
|
1445 (aset subj i k)
|
|
|
1446 (setq i (1+ i)))))
|
|
|
1447
|
|
|
1448 (defun forms--exit (query &optional save)
|
|
4121
|
1449 "Internal exit from forms mode function."
|
|
|
1450
|
|
276
|
1451 (let ((buf (buffer-name forms--file-buffer)))
|
|
|
1452 (forms--checkmod)
|
|
|
1453 (if (and save
|
|
|
1454 (buffer-modified-p forms--file-buffer))
|
|
8344
|
1455 (forms-save-buffer))
|
|
276
|
1456 (save-excursion
|
|
|
1457 (set-buffer forms--file-buffer)
|
|
|
1458 (delete-auto-save-file-if-necessary)
|
|
|
1459 (kill-buffer (current-buffer)))
|
|
|
1460 (if (get-buffer buf) ; not killed???
|
|
18215
|
1461 (if save
|
|
|
1462 (error "Problem saving buffer %s" (buffer-name buf)))
|
|
276
|
1463 (delete-auto-save-file-if-necessary)
|
|
|
1464 (kill-buffer (current-buffer)))))
|
|
|
1465
|
|
|
1466 (defun forms--get-record ()
|
|
|
1467 "Fetch the current record from the file buffer."
|
|
4121
|
1468
|
|
|
1469 ;; This function is executed in the context of the `forms--file-buffer'.
|
|
|
1470
|
|
276
|
1471 (or (bolp)
|
|
|
1472 (beginning-of-line nil))
|
|
|
1473 (let ((here (point)))
|
|
|
1474 (prog2
|
|
|
1475 (end-of-line)
|
13569
438ebe3b6f8d
Use `buffer-substring-no-properties' instead of `buffer-substring' to
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1476 (buffer-substring-no-properties here (point))
|
|
276
|
1477 (goto-char here))))
|
|
|
1478
|
|
|
1479 (defun forms--show-record (the-record)
|
|
3941
|
1480 "Format THE-RECORD and display it in the current buffer."
|
|
276
|
1481
|
|
4121
|
1482 ;; Split the-record.
|
|
276
|
1483 (let (the-result
|
|
|
1484 (start-pos 0)
|
|
|
1485 found-pos
|
|
|
1486 (field-sep-length (length forms-field-sep)))
|
|
|
1487 (if forms-multi-line
|
|
|
1488 (forms--trans the-record forms-multi-line "\n"))
|
|
4121
|
1489 ;; Add an extra separator (makes splitting easy).
|
|
276
|
1490 (setq the-record (concat the-record forms-field-sep))
|
|
|
1491 (while (setq found-pos (string-match forms-field-sep the-record start-pos))
|
|
|
1492 (let ((ent (substring the-record start-pos found-pos)))
|
|
|
1493 (setq the-result
|
|
|
1494 (append the-result (list ent)))
|
|
|
1495 (setq start-pos (+ field-sep-length found-pos))))
|
|
|
1496 (setq forms--the-record-list the-result))
|
|
|
1497
|
|
|
1498 (setq buffer-read-only nil)
|
|
4121
|
1499 (if forms-use-text-properties
|
|
|
1500 (let ((inhibit-read-only t))
|
|
|
1501 (set-text-properties (point-min) (point-max) nil)))
|
|
276
|
1502 (erase-buffer)
|
|
|
1503
|
|
4121
|
1504 ;; Verify the number of fields, extend forms--the-record-list if needed.
|
|
276
|
1505 (if (= (length forms--the-record-list) forms-number-of-fields)
|
|
|
1506 nil
|
|
12847
|
1507 (if (null forms-check-number-of-fields)
|
|
|
1508 nil
|
|
|
1509 (message "Warning: this record has %d fields instead of %d"
|
|
|
1510 (length forms--the-record-list) forms-number-of-fields))
|
|
276
|
1511 (if (< (length forms--the-record-list) forms-number-of-fields)
|
|
|
1512 (setq forms--the-record-list
|
|
|
1513 (append forms--the-record-list
|
|
|
1514 (make-list
|
|
|
1515 (- forms-number-of-fields
|
|
|
1516 (length forms--the-record-list))
|
|
|
1517 "")))))
|
|
|
1518
|
|
4121
|
1519 ;; Call the formatter function.
|
|
307
|
1520 (setq forms-fields (append (list nil) forms--the-record-list nil))
|
|
276
|
1521 (funcall forms--format forms--the-record-list)
|
|
|
1522
|
|
4121
|
1523 ;; Prepare.
|
|
276
|
1524 (goto-char (point-min))
|
|
|
1525 (set-buffer-modified-p nil)
|
|
|
1526 (setq buffer-read-only forms-read-only)
|
|
|
1527 (setq mode-line-process
|
|
|
1528 (concat " " forms--current-record "/" forms--total-records)))
|
|
|
1529
|
|
|
1530 (defun forms--parse-form ()
|
|
|
1531 "Parse contents of form into list of strings."
|
|
|
1532 ;; The contents of the form are parsed, and a new list of strings
|
|
|
1533 ;; is constructed.
|
|
|
1534 ;; A vector with the strings from the original record is
|
|
3941
|
1535 ;; constructed, which is updated with the new contents. Therefore
|
|
276
|
1536 ;; fields which were not in the form are not modified.
|
|
|
1537 ;; Finally, the vector is transformed into a list for further processing.
|
|
|
1538
|
|
4121
|
1539 (let (forms--recordv)
|
|
276
|
1540
|
|
4121
|
1541 ;; Build the vector.
|
|
|
1542 (setq forms--recordv (vconcat forms--the-record-list))
|
|
276
|
1543
|
|
4121
|
1544 ;; Parse the form and update the vector.
|
|
307
|
1545 (let ((forms--dynamic-text forms--dynamic-text))
|
|
|
1546 (funcall forms--parser))
|
|
276
|
1547
|
|
4790
|
1548 (if forms-modified-record-filter
|
|
307
|
1549 ;; As a service to the user, we add a zeroth element so she
|
|
|
1550 ;; can use the same indices as in the forms definition.
|
|
4121
|
1551 (let ((the-fields (vconcat [nil] forms--recordv)))
|
|
4790
|
1552 (setq the-fields (funcall forms-modified-record-filter the-fields))
|
|
307
|
1553 (cdr (append the-fields nil)))
|
|
|
1554
|
|
4121
|
1555 ;; Transform to a list and return.
|
|
|
1556 (append forms--recordv nil))))
|
|
276
|
1557
|
|
|
1558 (defun forms--update ()
|
|
3941
|
1559 "Update current record with contents of form.
|
|
4121
|
1560 As a side effect: sets `forms--the-record-list'."
|
|
3941
|
1561
|
|
276
|
1562 (if forms-read-only
|
|
18215
|
1563 (error "Buffer is read-only"))
|
|
8344
|
1564
|
|
18215
|
1565 (let (the-record)
|
|
|
1566 ;; Build new record.
|
|
|
1567 (setq forms--the-record-list (forms--parse-form))
|
|
|
1568 (setq the-record
|
|
|
1569 (mapconcat 'identity forms--the-record-list forms-field-sep))
|
|
|
1570
|
|
|
1571 (if (string-match (regexp-quote forms-field-sep)
|
|
|
1572 (mapconcat 'identity forms--the-record-list ""))
|
|
|
1573 (error "Field separator occurs in record - update refused"))
|
|
|
1574
|
|
|
1575 ;; Handle multi-line fields, if allowed.
|
|
|
1576 (if forms-multi-line
|
|
|
1577 (forms--trans the-record "\n" forms-multi-line))
|
|
276
|
1578
|
|
18215
|
1579 ;; A final sanity check before updating.
|
|
|
1580 (if (string-match "\n" the-record)
|
|
|
1581 (error "Multi-line fields in this record - update refused"))
|
|
276
|
1582
|
|
18215
|
1583 (save-excursion
|
|
|
1584 (set-buffer forms--file-buffer)
|
|
|
1585 ;; Use delete-region instead of kill-region, to avoid
|
|
|
1586 ;; adding junk to the kill-ring.
|
|
|
1587 (delete-region (save-excursion (beginning-of-line) (point))
|
|
|
1588 (save-excursion (end-of-line) (point)))
|
|
|
1589 (insert the-record)
|
|
|
1590 (beginning-of-line))))
|
|
276
|
1591
|
|
|
1592 (defun forms--checkmod ()
|
|
|
1593 "Check if this form has been modified, and call forms--update if so."
|
|
|
1594 (if (buffer-modified-p nil)
|
|
|
1595 (let ((here (point)))
|
|
|
1596 (forms--update)
|
|
|
1597 (set-buffer-modified-p nil)
|
|
|
1598 (goto-char here))))
|
|
3697
|
1599
|
|
276
|
1600 ;;; Start and exit
|
|
3941
|
1601
|
|
|
1602 ;;;###autoload
|
|
276
|
1603 (defun forms-find-file (fn)
|
|
3941
|
1604 "Visit a file in Forms mode."
|
|
276
|
1605 (interactive "fForms file: ")
|
7863
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1606 (let ((enable-local-eval t)
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1607 (enable-local-variables t))
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1608 (find-file-read-only fn)
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1609 (or forms--mode-setup (forms-mode t))))
|
|
276
|
1610
|
|
3941
|
1611 ;;;###autoload
|
|
276
|
1612 (defun forms-find-file-other-window (fn)
|
|
3941
|
1613 "Visit a file in Forms mode in other window."
|
|
276
|
1614 (interactive "fFbrowse file in other window: ")
|
7863
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1615 (let ((enable-local-eval t)
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1616 (enable-local-variables t))
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1617 (find-file-other-window fn)
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1618 (or forms--mode-setup (forms-mode t))))
|
|
276
|
1619
|
|
|
1620 (defun forms-exit (query)
|
|
3941
|
1621 "Normal exit from Forms mode. Modified buffers are saved."
|
|
276
|
1622 (interactive "P")
|
|
|
1623 (forms--exit query t))
|
|
|
1624
|
|
|
1625 (defun forms-exit-no-save (query)
|
|
3941
|
1626 "Exit from Forms mode without saving buffers."
|
|
276
|
1627 (interactive "P")
|
|
|
1628 (forms--exit query nil))
|
|
3697
|
1629
|
|
276
|
1630 ;;; Navigating commands
|
|
|
1631
|
|
|
1632 (defun forms-next-record (arg)
|
|
|
1633 "Advance to the ARGth following record."
|
|
|
1634 (interactive "P")
|
|
|
1635 (forms-jump-record (+ forms--current-record (prefix-numeric-value arg)) t))
|
|
|
1636
|
|
|
1637 (defun forms-prev-record (arg)
|
|
|
1638 "Advance to the ARGth previous record."
|
|
|
1639 (interactive "P")
|
|
|
1640 (forms-jump-record (- forms--current-record (prefix-numeric-value arg)) t))
|
|
|
1641
|
|
|
1642 (defun forms-jump-record (arg &optional relative)
|
|
|
1643 "Jump to a random record."
|
|
|
1644 (interactive "NRecord number: ")
|
|
|
1645
|
|
4121
|
1646 ;; Verify that the record number is within range.
|
|
276
|
1647 (if (or (> arg forms--total-records)
|
|
|
1648 (<= arg 0))
|
|
18215
|
1649 (error
|
|
4121
|
1650 ;; Don't give the message if just paging.
|
|
276
|
1651 (if (not relative)
|
|
|
1652 (message "Record number %d out of range 1..%d"
|
|
18215
|
1653 arg forms--total-records)
|
|
|
1654 "")))
|
|
276
|
1655
|
|
18215
|
1656 ;; Flush.
|
|
|
1657 (forms--checkmod)
|
|
276
|
1658
|
|
18215
|
1659 ;; Calculate displacement.
|
|
|
1660 (let ((disp (- arg forms--current-record))
|
|
|
1661 (cur forms--current-record))
|
|
276
|
1662
|
|
18215
|
1663 ;; `forms--show-record' needs it now.
|
|
|
1664 (setq forms--current-record arg)
|
|
276
|
1665
|
|
18215
|
1666 ;; Get the record and show it.
|
|
|
1667 (forms--show-record
|
|
|
1668 (save-excursion
|
|
|
1669 (set-buffer forms--file-buffer)
|
|
|
1670 (beginning-of-line)
|
|
276
|
1671
|
|
18215
|
1672 ;; Move, and adjust the amount if needed (shouldn't happen).
|
|
|
1673 (if relative
|
|
|
1674 (if (zerop disp)
|
|
|
1675 nil
|
|
|
1676 (setq cur (+ cur disp (- (forward-line disp)))))
|
|
|
1677 (setq cur (+ cur disp (- (goto-line arg)))))
|
|
276
|
1678
|
|
18215
|
1679 (forms--get-record)))
|
|
276
|
1680
|
|
18215
|
1681 ;; This shouldn't happen.
|
|
|
1682 (if (/= forms--current-record cur)
|
|
|
1683 (progn
|
|
|
1684 (setq forms--current-record cur)
|
|
|
1685 (error "Stuck at record %d" cur)))))
|
|
276
|
1686
|
|
|
1687 (defun forms-first-record ()
|
|
|
1688 "Jump to first record."
|
|
|
1689 (interactive)
|
|
|
1690 (forms-jump-record 1))
|
|
|
1691
|
|
|
1692 (defun forms-last-record ()
|
|
3941
|
1693 "Jump to last record.
|
|
|
1694 As a side effect: re-calculates the number of records in the data file."
|
|
276
|
1695 (interactive)
|
|
|
1696 (let
|
|
|
1697 ((numrec
|
|
|
1698 (save-excursion
|
|
|
1699 (set-buffer forms--file-buffer)
|
|
|
1700 (count-lines (point-min) (point-max)))))
|
|
|
1701 (if (= numrec forms--total-records)
|
|
|
1702 nil
|
|
|
1703 (setq forms--total-records numrec)
|
|
4790
|
1704 (message "Warning: number of records changed to %d" forms--total-records)))
|
|
276
|
1705 (forms-jump-record forms--total-records))
|
|
3697
|
1706
|
|
276
|
1707 ;;; Other commands
|
|
3941
|
1708
|
|
4790
|
1709 (defun forms-toggle-read-only (arg)
|
|
|
1710 "Toggles read-only mode of a forms mode buffer.
|
|
|
1711 With an argument, enables read-only mode if the argument is positive.
|
|
13984
|
1712 Otherwise enables edit mode if the visited file is writable."
|
|
4790
|
1713
|
|
|
1714 (interactive "P")
|
|
|
1715
|
|
|
1716 (if (if arg
|
|
|
1717 ;; Negative arg means switch it off.
|
|
|
1718 (<= (prefix-numeric-value arg) 0)
|
|
|
1719 ;; No arg means toggle.
|
|
|
1720 forms-read-only)
|
|
276
|
1721
|
|
4790
|
1722 ;; Enable edit mode, if possible.
|
|
|
1723 (let ((ro forms-read-only))
|
|
|
1724 (if (save-excursion
|
|
|
1725 (set-buffer forms--file-buffer)
|
|
|
1726 buffer-read-only)
|
|
|
1727 (progn
|
|
|
1728 (setq forms-read-only t)
|
|
18215
|
1729 (message "No write access to `%s'" forms-file))
|
|
4790
|
1730 (setq forms-read-only nil))
|
|
|
1731 (if (equal ro forms-read-only)
|
|
|
1732 nil
|
|
|
1733 (forms-mode)))
|
|
|
1734
|
|
|
1735 ;; Enable view mode.
|
|
|
1736 (if forms-read-only
|
|
276
|
1737 nil
|
|
4790
|
1738 (forms--checkmod) ; sync
|
|
|
1739 (setq forms-read-only t)
|
|
276
|
1740 (forms-mode))))
|
|
|
1741
|
|
|
1742 ;; Sample:
|
|
307
|
1743 ;; (defun my-new-record-filter (the-fields)
|
|
276
|
1744 ;; ;; numbers are relative to 1
|
|
|
1745 ;; (aset the-fields 4 (current-time-string))
|
|
|
1746 ;; (aset the-fields 6 (user-login-name))
|
|
|
1747 ;; the-list)
|
|
307
|
1748 ;; (setq forms-new-record-filter 'my-new-record-filter)
|
|
276
|
1749
|
|
|
1750 (defun forms-insert-record (arg)
|
|
3941
|
1751 "Create a new record before the current one.
|
|
|
1752 With ARG: store the record after the current one.
|
|
4790
|
1753 If `forms-new-record-filter' contains the name of a function,
|
14732
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1754 it is called to fill (some of) the fields with default values.
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1755 If `forms-insert-after is non-nil, the default behavior is to insert
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1756 after the current record."
|
|
276
|
1757
|
|
|
1758 (interactive "P")
|
|
|
1759
|
|
4790
|
1760 (if forms-read-only
|
|
|
1761 (error ""))
|
|
|
1762
|
14732
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1763 (let (ln the-list the-record)
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1764
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1765 (if (or (and arg forms-insert-after)
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1766 (and (not arg) (not forms-insert-after)))
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1767 (setq ln forms--current-record)
|
6bd77cce44a6
(forms-insert-after): New variable. Non-nil means: inserts of new
Johan Vromans <jvromans@squirrel.nl>
diff
changeset
|
1768 (setq ln (1+ forms--current-record)))
|
|
276
|
1769
|
|
|
1770 (forms--checkmod)
|
|
4790
|
1771 (if forms-new-record-filter
|
|
276
|
1772 ;; As a service to the user, we add a zeroth element so she
|
|
|
1773 ;; can use the same indices as in the forms definition.
|
|
|
1774 (let ((the-fields (make-vector (1+ forms-number-of-fields) "")))
|
|
4790
|
1775 (setq the-fields (funcall forms-new-record-filter the-fields))
|
|
276
|
1776 (setq the-list (cdr (append the-fields nil))))
|
|
|
1777 (setq the-list (make-list forms-number-of-fields "")))
|
|
|
1778
|
|
|
1779 (setq the-record
|
|
|
1780 (mapconcat
|
|
|
1781 'identity
|
|
|
1782 the-list
|
|
|
1783 forms-field-sep))
|
|
|
1784
|
|
|
1785 (save-excursion
|
|
|
1786 (set-buffer forms--file-buffer)
|
|
|
1787 (goto-line ln)
|
|
|
1788 (open-line 1)
|
|
|
1789 (insert the-record)
|
|
|
1790 (beginning-of-line))
|
|
|
1791
|
|
|
1792 (setq forms--current-record ln))
|
|
|
1793
|
|
|
1794 (setq forms--total-records (1+ forms--total-records))
|
|
|
1795 (forms-jump-record forms--current-record))
|
|
|
1796
|
|
|
1797 (defun forms-delete-record (arg)
|
|
3941
|
1798 "Deletes a record. With a prefix argument: don't ask."
|
|
276
|
1799 (interactive "P")
|
|
4790
|
1800
|
|
|
1801 (if forms-read-only
|
|
|
1802 (error ""))
|
|
|
1803
|
|
276
|
1804 (forms--checkmod)
|
|
|
1805 (if (or arg
|
|
|
1806 (y-or-n-p "Really delete this record? "))
|
|
|
1807 (let ((ln forms--current-record))
|
|
|
1808 (save-excursion
|
|
|
1809 (set-buffer forms--file-buffer)
|
|
|
1810 (goto-line ln)
|
|
4723
|
1811 ;; Use delete-region instead of kill-region, to avoid
|
|
|
1812 ;; adding junk to the kill-ring.
|
|
8272
|
1813 (delete-region (progn (beginning-of-line) (point))
|
|
|
1814 (progn (beginning-of-line 2) (point))))
|
|
276
|
1815 (setq forms--total-records (1- forms--total-records))
|
|
|
1816 (if (> forms--current-record forms--total-records)
|
|
|
1817 (setq forms--current-record forms--total-records))
|
|
|
1818 (forms-jump-record forms--current-record)))
|
|
|
1819 (message ""))
|
|
|
1820
|
|
10346
|
1821 (defun forms-search-forward (regexp)
|
|
|
1822 "Search forward for record containing REGEXP."
|
|
276
|
1823 (interactive
|
|
10346
|
1824 (list (read-string (concat "Search forward for"
|
|
276
|
1825 (if forms--search-regexp
|
|
|
1826 (concat " ("
|
|
|
1827 forms--search-regexp
|
|
|
1828 ")"))
|
|
|
1829 ": "))))
|
|
|
1830 (if (equal "" regexp)
|
|
|
1831 (setq regexp forms--search-regexp))
|
|
|
1832 (forms--checkmod)
|
|
|
1833
|
|
|
1834 (let (the-line the-record here
|
|
|
1835 (fld-sep forms-field-sep))
|
|
18223
|
1836 (save-excursion
|
|
|
1837 (set-buffer forms--file-buffer)
|
|
|
1838 (end-of-line)
|
|
|
1839 (setq here (point))
|
|
|
1840 (if (or (re-search-forward regexp nil t)
|
|
|
1841 (and (> here (point-min))
|
|
|
1842 (progn
|
|
|
1843 (goto-char (point-min))
|
|
|
1844 (re-search-forward regexp here t))))
|
|
|
1845 (progn
|
|
276
|
1846 (setq the-record (forms--get-record))
|
|
18223
|
1847 (setq the-line (1+ (count-lines (point-min) (point))))
|
|
|
1848 (if (< (point) here)
|
|
|
1849 (message "Wrapped")))
|
|
|
1850 (goto-char here)
|
|
|
1851 (error "Search failed: %s" regexp)))
|
|
|
1852 (setq forms--current-record the-line)
|
|
|
1853 (forms--show-record the-record))
|
|
|
1854 (re-search-forward regexp nil t)
|
|
276
|
1855 (setq forms--search-regexp regexp))
|
|
|
1856
|
|
10346
|
1857 (defun forms-search-backward (regexp)
|
|
|
1858 "Search backward for record containing REGEXP."
|
|
|
1859 (interactive
|
|
|
1860 (list (read-string (concat "Search backward for"
|
|
|
1861 (if forms--search-regexp
|
|
|
1862 (concat " ("
|
|
|
1863 forms--search-regexp
|
|
|
1864 ")"))
|
|
|
1865 ": "))))
|
|
|
1866 (if (equal "" regexp)
|
|
|
1867 (setq regexp forms--search-regexp))
|
|
|
1868 (forms--checkmod)
|
|
|
1869
|
|
|
1870 (let (the-line the-record here
|
|
|
1871 (fld-sep forms-field-sep))
|
|
18223
|
1872 (save-excursion
|
|
|
1873 (set-buffer forms--file-buffer)
|
|
|
1874 (beginning-of-line)
|
|
|
1875 (setq here (point))
|
|
|
1876 (if (or (re-search-backward regexp nil t)
|
|
|
1877 (and (< (point) (point-max))
|
|
|
1878 (progn
|
|
|
1879 (goto-char (point-max))
|
|
|
1880 (re-search-backward regexp here t))))
|
|
|
1881 (progn
|
|
10346
|
1882 (setq the-record (forms--get-record))
|
|
18223
|
1883 (setq the-line (1+ (count-lines (point-min) (point))))
|
|
|
1884 (if (> (point) here)
|
|
|
1885 (message "Wrapped")))
|
|
|
1886 (goto-char here)
|
|
|
1887 (error "Search failed: %s" regexp)))
|
|
|
1888 (setq forms--current-record the-line)
|
|
|
1889 (forms--show-record the-record))
|
|
|
1890 (re-search-forward regexp nil t)
|
|
10346
|
1891 (setq forms--search-regexp regexp))
|
|
|
1892
|
|
8344
|
1893 (defun forms-save-buffer (&optional args)
|
|
|
1894 "Forms mode replacement for save-buffer.
|
|
|
1895 It saves the data buffer instead of the forms buffer.
|
|
18215
|
1896 Calls `forms-write-file-filter' before, and `forms-read-file-filter'
|
|
|
1897 after writing out the data."
|
|
8344
|
1898 (interactive "p")
|
7863
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1899 (forms--checkmod)
|
|
18215
|
1900 (let ((write-file-filter forms-write-file-filter)
|
|
|
1901 (read-file-filter forms-read-file-filter))
|
|
8344
|
1902 (save-excursion
|
|
|
1903 (set-buffer forms--file-buffer)
|
|
|
1904 (let ((inhibit-read-only t))
|
|
18223
|
1905 ;; Write file hooks are run via local-write-file-hooks.
|
|
|
1906 ;; (if write-file-filter
|
|
|
1907 ;; (save-excursion
|
|
|
1908 ;; (run-hooks 'write-file-filter)))
|
|
8344
|
1909 (save-buffer args)
|
|
|
1910 (if read-file-filter
|
|
18215
|
1911 (save-excursion
|
|
|
1912 (run-hooks 'read-file-filter)))
|
|
8344
|
1913 (set-buffer-modified-p nil))))
|
7863
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1914 t)
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1915
|
c4adb7401604
(forms-mode): Plug security hole by disabling `eval-buffer' unless
Richard M. Stallman <rms@gnu.org>
diff
changeset
|
1916 (defun forms--revert-buffer (&optional arg noconfirm)
|
|
276
|
1917 "Reverts current form to un-modified."
|
|
|
1918 (interactive "P")
|
|
|
1919 (if (or noconfirm
|
|
|
1920 (yes-or-no-p "Revert form to unmodified? "))
|
|
|
1921 (progn
|
|
|
1922 (set-buffer-modified-p nil)
|
|
|
1923 (forms-jump-record forms--current-record))))
|
|
|
1924
|
|
|
1925 (defun forms-next-field (arg)
|
|
|
1926 "Jump to ARG-th next field."
|
|
|
1927 (interactive "p")
|
|
|
1928
|
|
|
1929 (let ((i 0)
|
|
|
1930 (here (point))
|
|
|
1931 there
|
|
11557
|
1932 (cnt 0)
|
|
|
1933 (inhibit-point-motion-hooks t))
|
|
276
|
1934
|
|
|
1935 (if (zerop arg)
|
|
|
1936 (setq cnt 1)
|
|
|
1937 (setq cnt (+ cnt arg)))
|
|
|
1938
|
|
|
1939 (if (catch 'done
|
|
4121
|
1940 (while (< i (length forms--markers))
|
|
276
|
1941 (if (or (null (setq there (aref forms--markers i)))
|
|
|
1942 (<= there here))
|
|
|
1943 nil
|
|
|
1944 (if (<= (setq cnt (1- cnt)) 0)
|
|
|
1945 (progn
|
|
|
1946 (goto-char there)
|
|
|
1947 (throw 'done t))))
|
|
|
1948 (setq i (1+ i))))
|
|
|
1949 nil
|
|
|
1950 (goto-char (aref forms--markers 0)))))
|
|
307
|
1951
|
|
4790
|
1952 (defun forms-prev-field (arg)
|
|
|
1953 "Jump to ARG-th previous field."
|
|
|
1954 (interactive "p")
|
|
|
1955
|
|
|
1956 (let ((i (length forms--markers))
|
|
|
1957 (here (point))
|
|
|
1958 there
|
|
11557
|
1959 (cnt 0)
|
|
|
1960 (inhibit-point-motion-hooks t))
|
|
4790
|
1961
|
|
|
1962 (if (zerop arg)
|
|
|
1963 (setq cnt 1)
|
|
|
1964 (setq cnt (+ cnt arg)))
|
|
|
1965
|
|
|
1966 (if (catch 'done
|
|
|
1967 (while (> i 0)
|
|
|
1968 (setq i ( 1- i))
|
|
|
1969 (if (or (null (setq there (aref forms--markers i)))
|
|
|
1970 (>= there here))
|
|
|
1971 nil
|
|
|
1972 (if (<= (setq cnt (1- cnt)) 0)
|
|
|
1973 (progn
|
|
|
1974 (goto-char there)
|
|
|
1975 (throw 'done t))))))
|
|
|
1976 nil
|
|
|
1977 (goto-char (aref forms--markers (1- (length forms--markers)))))))
|
|
10346
|
1978
|
|
|
1979 (defun forms-print ()
|
|
|
1980 "Send the records to the printer with 'print-buffer', one record per page."
|
|
|
1981 (interactive)
|
|
|
1982 (let ((inhibit-read-only t)
|
|
|
1983 (save-record forms--current-record)
|
|
|
1984 (nb-record 1)
|
|
|
1985 (record nil))
|
|
|
1986 (while (<= nb-record forms--total-records)
|
|
|
1987 (forms-jump-record nb-record)
|
|
|
1988 (setq record (buffer-string))
|
|
|
1989 (save-excursion
|
|
|
1990 (set-buffer (get-buffer-create "*forms-print*"))
|
|
|
1991 (goto-char (buffer-end 1))
|
|
|
1992 (insert record)
|
|
|
1993 (setq buffer-read-only nil)
|
|
|
1994 (if (< nb-record forms--total-records)
|
|
|
1995 (insert "\n \n")))
|
|
|
1996 (setq nb-record (1+ nb-record)))
|
|
|
1997 (save-excursion
|
|
|
1998 (set-buffer "*forms-print*")
|
|
|
1999 (print-buffer)
|
|
|
2000 (set-buffer-modified-p nil)
|
|
|
2001 (kill-buffer (current-buffer)))
|
|
|
2002 (forms-jump-record save-record)))
|
|
|
2003
|
|
307
|
2004 ;;;
|
|
|
2005 ;;; Special service
|
|
|
2006 ;;;
|
|
|
2007 (defun forms-enumerate (the-fields)
|
|
3941
|
2008 "Take a quoted list of symbols, and set their values to sequential numbers.
|
|
|
2009 The first symbol gets number 1, the second 2 and so on.
|
|
13984
|
2010 It returns the highest number.
|
|
307
|
2011
|
|
|
2012 Usage: (setq forms-number-of-fields
|
|
|
2013 (forms-enumerate
|
|
|
2014 '(field1 field2 field2 ...)))"
|
|
|
2015
|
|
|
2016 (let ((the-index 0))
|
|
|
2017 (while the-fields
|
|
|
2018 (setq the-index (1+ the-index))
|
|
|
2019 (let ((el (car-safe the-fields)))
|
|
|
2020 (setq the-fields (cdr-safe the-fields))
|
|
|
2021 (set el the-index)))
|
|
|
2022 the-index))
|
|
3697
|
2023
|
|
307
|
2024 ;;; Debugging
|
|
3941
|
2025
|
|
307
|
2026 (defvar forms--debug nil
|
|
|
2027 "*Enables forms-mode debugging if not nil.")
|
|
|
2028
|
|
|
2029 (defun forms--debug (&rest args)
|
|
3941
|
2030 "Internal debugging routine."
|
|
307
|
2031 (if forms--debug
|
|
|
2032 (let ((ret nil))
|
|
|
2033 (while args
|
|
|
2034 (let ((el (car-safe args)))
|
|
|
2035 (setq args (cdr-safe args))
|
|
|
2036 (if (stringp el)
|
|
|
2037 (setq ret (concat ret el))
|
|
|
2038 (setq ret (concat ret (prin1-to-string el) " = "))
|
|
|
2039 (if (boundp el)
|
|
|
2040 (let ((vel (eval el)))
|
|
|
2041 (setq ret (concat ret (prin1-to-string vel) "\n")))
|
|
|
2042 (setq ret (concat ret "<unbound>" "\n")))
|
|
|
2043 (if (fboundp el)
|
|
|
2044 (setq ret (concat ret (prin1-to-string (symbol-function el))
|
|
|
2045 "\n"))))))
|
|
|
2046 (save-excursion
|
|
|
2047 (set-buffer (get-buffer-create "*forms-mode debug*"))
|
|
4121
|
2048 (if (zerop (buffer-size))
|
|
|
2049 (emacs-lisp-mode))
|
|
307
|
2050 (goto-char (point-max))
|
|
|
2051 (insert ret)))))
|
|
|
2052
|
|
3697
|
2053 ;;; forms.el ends here.
|
