|
0
|
1 ;;; Miscellaneous functions for VM
|
|
98
|
2 ;;; Copyright (C) 1989-1997 Kyle E. Jones
|
|
0
|
3 ;;;
|
|
|
4 ;;; This program is free software; you can redistribute it and/or modify
|
|
|
5 ;;; it under the terms of the GNU General Public License as published by
|
|
|
6 ;;; the Free Software Foundation; either version 1, or (at your option)
|
|
|
7 ;;; any later version.
|
|
|
8 ;;;
|
|
|
9 ;;; This program is distributed in the hope that it will be useful,
|
|
|
10 ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
11 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
12 ;;; GNU General Public License for more details.
|
|
|
13 ;;;
|
|
|
14 ;;; You should have received a copy of the GNU General Public License
|
|
|
15 ;;; along with this program; if not, write to the Free Software
|
|
|
16 ;;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
17
|
|
|
18 (provide 'vm-misc)
|
|
|
19
|
|
|
20 (defun vm-delete-non-matching-strings (regexp list &optional destructively)
|
|
|
21 "Delete strings matching REGEXP from LIST.
|
|
|
22 Optional third arg non-nil means to destructively alter LIST, instead of
|
|
|
23 working on a copy.
|
|
|
24
|
|
|
25 The new version of the list, minus the deleted strings, is returned."
|
|
|
26 (or destructively (setq list (copy-sequence list)))
|
|
|
27 (let ((curr list) (prev nil))
|
|
|
28 (while curr
|
|
|
29 (if (string-match regexp (car curr))
|
|
|
30 (setq prev curr
|
|
|
31 curr (cdr curr))
|
|
|
32 (if (null prev)
|
|
|
33 (setq list (cdr list)
|
|
|
34 curr list)
|
|
|
35 (setcdr prev (cdr curr))
|
|
|
36 (setq curr (cdr curr)))))
|
|
|
37 list ))
|
|
|
38
|
|
|
39 (defun vm-parse (string regexp &optional matchn)
|
|
|
40 (or matchn (setq matchn 1))
|
|
|
41 (let (list)
|
|
|
42 (store-match-data nil)
|
|
|
43 (while (string-match regexp string (match-end 0))
|
|
|
44 (setq list (cons (substring string (match-beginning matchn)
|
|
|
45 (match-end matchn)) list)))
|
|
|
46 (nreverse list)))
|
|
|
47
|
|
|
48 (defun vm-parse-addresses (string)
|
|
|
49 (if (null string)
|
|
|
50 ()
|
|
|
51 (let (work-buffer)
|
|
|
52 (save-excursion
|
|
|
53 (unwind-protect
|
|
|
54 (let (list start s char)
|
|
|
55 (setq work-buffer (generate-new-buffer "*vm-work*"))
|
|
|
56 (set-buffer work-buffer)
|
|
|
57 (insert string)
|
|
|
58 (goto-char (point-min))
|
|
|
59 (skip-chars-forward "\t\f\n\r ")
|
|
|
60 (setq start (point))
|
|
|
61 (while (not (eobp))
|
|
|
62 (skip-chars-forward "^\"\\,(")
|
|
|
63 (setq char (following-char))
|
|
|
64 (cond ((= char ?\\)
|
|
|
65 (forward-char 1)
|
|
|
66 (if (not (eobp))
|
|
|
67 (forward-char 1)))
|
|
|
68 ((= char ?,)
|
|
|
69 (setq s (buffer-substring start (point)))
|
|
|
70 (if (or (null (string-match "^[\t\f\n\r ]+$" s))
|
|
|
71 (not (string= s "")))
|
|
|
72 (setq list (cons s list)))
|
|
76
|
73 (skip-chars-forward ",\t\f\n\r ")
|
|
0
|
74 (setq start (point)))
|
|
|
75 ((= char ?\")
|
|
|
76 (re-search-forward "[^\\]\"" nil 0))
|
|
|
77 ((= char ?\()
|
|
|
78 (let ((parens 1))
|
|
|
79 (forward-char 1)
|
|
|
80 (while (and (not (eobp)) (not (zerop parens)))
|
|
76
|
81 (re-search-forward "[()]" nil 0)
|
|
|
82 (cond ((or (eobp)
|
|
|
83 (= (char-after (- (point) 2)) ?\\)))
|
|
0
|
84 ((= (preceding-char) ?\()
|
|
|
85 (setq parens (1+ parens)))
|
|
76
|
86 (t
|
|
0
|
87 (setq parens (1- parens)))))))))
|
|
|
88 (setq s (buffer-substring start (point)))
|
|
|
89 (if (and (null (string-match "^[\t\f\n\r ]+$" s))
|
|
|
90 (not (string= s "")))
|
|
|
91 (setq list (cons s list)))
|
|
|
92 (nreverse list)) ; jwz: fixed order
|
|
|
93 (and work-buffer (kill-buffer work-buffer)))))))
|
|
|
94
|
|
118
|
95 (defun vm-parse-structured-header (string &optional sepchar keep-quotes)
|
|
|
96 (if (null string)
|
|
|
97 ()
|
|
|
98 (let ((work-buffer nil))
|
|
|
99 (save-excursion
|
|
|
100 (unwind-protect
|
|
|
101 (let ((list nil)
|
|
|
102 (nonspecials "^\"\\( \t\n\r\f")
|
|
|
103 start s char sp+sepchar)
|
|
|
104 (if sepchar
|
|
|
105 (setq nonspecials (concat nonspecials (list sepchar))
|
|
|
106 sp+sepchar (concat "\t\f\n\r " (list sepchar))))
|
|
|
107 (setq work-buffer (generate-new-buffer "*vm-work*"))
|
|
|
108 (buffer-disable-undo work-buffer)
|
|
|
109 (set-buffer work-buffer)
|
|
|
110 (insert string)
|
|
|
111 (goto-char (point-min))
|
|
|
112 (skip-chars-forward "\t\f\n\r ")
|
|
|
113 (setq start (point))
|
|
|
114 (while (not (eobp))
|
|
|
115 (skip-chars-forward nonspecials)
|
|
|
116 (setq char (following-char))
|
|
|
117 (cond ((looking-at "[ \t\n\r\f]")
|
|
|
118 (delete-char 1))
|
|
|
119 ((= char ?\\)
|
|
|
120 (forward-char 1)
|
|
|
121 (if (not (eobp))
|
|
|
122 (forward-char 1)))
|
|
|
123 ((and sepchar (= char sepchar))
|
|
|
124 (setq s (buffer-substring start (point)))
|
|
|
125 (if (or (null (string-match "^[\t\f\n\r ]+$" s))
|
|
|
126 (not (string= s "")))
|
|
|
127 (setq list (cons s list)))
|
|
|
128 (skip-chars-forward sp+sepchar)
|
|
|
129 (setq start (point)))
|
|
|
130 ((looking-at " \t\n\r\f")
|
|
|
131 (skip-chars-forward " \t\n\r\f"))
|
|
|
132 ((= char ?\")
|
|
|
133 (let ((done nil))
|
|
|
134 (if keep-quotes
|
|
|
135 (forward-char 1)
|
|
|
136 (delete-char 1))
|
|
|
137 (while (not done)
|
|
|
138 (if (null (re-search-forward "[\\\"]" nil t))
|
|
|
139 (setq done t)
|
|
|
140 (setq char (char-after (1- (point))))
|
|
|
141 (cond ((char-equal char ?\\)
|
|
|
142 (delete-char -1)
|
|
|
143 (if (eobp)
|
|
|
144 (setq done t)
|
|
|
145 (forward-char 1)))
|
|
|
146 (t (if (not keep-quotes)
|
|
|
147 (delete-char -1))
|
|
|
148 (setq done t)))))))
|
|
|
149 ((= char ?\()
|
|
|
150 (let ((done nil)
|
|
|
151 (pos (point))
|
|
|
152 (parens 1))
|
|
|
153 (forward-char 1)
|
|
|
154 (while (not done)
|
|
|
155 (if (null (re-search-forward "[\\()]" nil t))
|
|
|
156 (setq done t)
|
|
|
157 (setq char (char-after (1- (point))))
|
|
|
158 (cond ((char-equal char ?\\)
|
|
|
159 (if (eobp)
|
|
|
160 (setq done t)
|
|
|
161 (forward-char 1)))
|
|
|
162 ((char-equal char ?\()
|
|
|
163 (setq parens (1+ parens)))
|
|
|
164 (t
|
|
|
165 (setq parens (1- parens)
|
|
|
166 done (zerop parens))))))
|
|
|
167 (delete-region pos (point))))))
|
|
|
168 (setq s (buffer-substring start (point)))
|
|
|
169 (if (and (null (string-match "^[\t\f\n\r ]+$" s))
|
|
|
170 (not (string= s "")))
|
|
|
171 (setq list (cons s list)))
|
|
|
172 (nreverse list))
|
|
|
173 (and work-buffer (kill-buffer work-buffer)))))))
|
|
|
174
|
|
0
|
175 (defun vm-write-string (where string)
|
|
|
176 (if (bufferp where)
|
|
|
177 (vm-save-buffer-excursion
|
|
|
178 (set-buffer where)
|
|
|
179 (goto-char (point-max))
|
|
|
180 (insert string))
|
|
|
181 (let ((temp-buffer nil))
|
|
|
182 (unwind-protect
|
|
|
183 (save-excursion
|
|
|
184 (setq temp-buffer (generate-new-buffer "*vm-work*"))
|
|
|
185 (set-buffer temp-buffer)
|
|
|
186 (insert string)
|
|
100
|
187 ;; correct for VM's uses of this function---
|
|
|
188 ;; writing out message separators
|
|
|
189 (setq buffer-file-type nil)
|
|
|
190 ;; Tell XEmacs/MULE to pick the correct newline conversion.
|
|
120
|
191 (and vm-xemacs-mule-p
|
|
100
|
192 (set-file-coding-system 'no-conversion nil))
|
|
0
|
193 (write-region (point-min) (point-max) where t 'quiet))
|
|
|
194 (and temp-buffer (kill-buffer temp-buffer))))))
|
|
|
195
|
|
|
196 (defmacro vm-marker (pos &optional buffer)
|
|
|
197 (list 'set-marker '(make-marker) pos buffer))
|
|
|
198
|
|
|
199 (defmacro vm-increment (variable)
|
|
|
200 (list 'setq variable (list '1+ variable)))
|
|
|
201
|
|
|
202 (defmacro vm-decrement (variable)
|
|
|
203 (list 'setq variable (list '1- variable)))
|
|
|
204
|
|
|
205 (defmacro vm-select-folder-buffer ()
|
|
|
206 '(and vm-mail-buffer
|
|
|
207 (or (buffer-name vm-mail-buffer)
|
|
|
208 (error "Folder buffer has been killed."))
|
|
|
209 (set-buffer vm-mail-buffer)))
|
|
|
210
|
|
|
211 (defun vm-check-for-killed-summary ()
|
|
|
212 (and (bufferp vm-summary-buffer) (null (buffer-name vm-summary-buffer))
|
|
|
213 (let ((mp vm-message-list))
|
|
|
214 (setq vm-summary-buffer nil)
|
|
|
215 (while mp
|
|
|
216 (vm-set-su-start-of (car mp) nil)
|
|
|
217 (vm-set-su-end-of (car mp) nil)
|
|
|
218 (setq mp (cdr mp))))))
|
|
|
219
|
|
98
|
220 (defun vm-check-for-killed-presentation ()
|
|
|
221 (and (bufferp vm-presentation-buffer-handle)
|
|
|
222 (null (buffer-name vm-presentation-buffer-handle))
|
|
|
223 (progn
|
|
|
224 (setq vm-presentation-buffer-handle nil
|
|
|
225 vm-presentation-buffer nil))))
|
|
|
226
|
|
0
|
227 (defun vm-check-for-killed-folder ()
|
|
|
228 (and (bufferp vm-mail-buffer) (null (buffer-name vm-mail-buffer))
|
|
|
229 (setq vm-mail-buffer nil)))
|
|
|
230
|
|
|
231 (defmacro vm-error-if-folder-read-only ()
|
|
|
232 '(while vm-folder-read-only
|
|
|
233 (signal 'folder-read-only (list (current-buffer)))))
|
|
|
234
|
|
76
|
235 (put 'folder-read-only 'error-conditions '(folder-read-only error))
|
|
|
236 (put 'folder-read-only 'error-message "Folder is read-only")
|
|
0
|
237
|
|
|
238 (defmacro vm-error-if-virtual-folder ()
|
|
|
239 '(and (eq major-mode 'vm-virtual-mode)
|
|
|
240 (error "%s cannot be applied to virtual folders." this-command)))
|
|
|
241
|
|
|
242 (defmacro vm-build-threads-if-unbuilt ()
|
|
|
243 '(if (null vm-thread-obarray)
|
|
|
244 (vm-build-threads nil)))
|
|
|
245
|
|
|
246 (defun vm-abs (n) (if (< n 0) (- n) n))
|
|
|
247
|
|
|
248 ;; save-restriction flubs restoring the clipping region if you
|
|
|
249 ;; (widen) and modify text outside the old region.
|
|
|
250 ;; This should do it right.
|
|
|
251 (defmacro vm-save-restriction (&rest forms)
|
|
|
252 (let ((vm-sr-clip (make-symbol "vm-sr-clip"))
|
|
|
253 (vm-sr-min (make-symbol "vm-sr-min"))
|
|
|
254 (vm-sr-max (make-symbol "vm-sr-max")))
|
|
|
255 (list 'let (list (list vm-sr-clip '(> (buffer-size)
|
|
|
256 (- (point-max) (point-min))))
|
|
|
257 ;; this shouldn't be necessary but the
|
|
|
258 ;; byte-compiler turns these into interned symbols
|
|
|
259 ;; which utterly defeats the purpose of the
|
|
|
260 ;; make-symbol calls above. Soooo, until the compiler
|
|
|
261 ;; is fixed, these must be made into (let ...)
|
|
|
262 ;; temporaries so that nested calls to this macros
|
|
|
263 ;; won't misbehave.
|
|
|
264 vm-sr-min vm-sr-max)
|
|
|
265 (list 'and vm-sr-clip
|
|
|
266 (list 'setq vm-sr-min '(set-marker (make-marker) (point-min)))
|
|
|
267 (list 'setq vm-sr-max '(set-marker (make-marker) (point-max))))
|
|
|
268 (list 'unwind-protect (cons 'progn forms)
|
|
|
269 '(widen)
|
|
|
270 (list 'and vm-sr-clip
|
|
|
271 (list 'progn
|
|
|
272 (list 'narrow-to-region vm-sr-min vm-sr-max)
|
|
|
273 (list 'set-marker vm-sr-min nil)
|
|
|
274 (list 'set-marker vm-sr-max nil)))))))
|
|
|
275
|
|
|
276 (defmacro vm-save-buffer-excursion (&rest forms)
|
|
|
277 (list 'let '((vm-sbe-buffer (current-buffer)))
|
|
|
278 (list 'unwind-protect
|
|
|
279 (cons 'progn forms)
|
|
|
280 '(and (not (eq vm-sbe-buffer (current-buffer)))
|
|
|
281 (buffer-name vm-sbe-buffer)
|
|
|
282 (set-buffer vm-sbe-buffer)))))
|
|
|
283
|
|
|
284 (defun vm-last (list) (while (cdr-safe list) (setq list (cdr list))) list)
|
|
|
285
|
|
|
286 (defun vm-vector-to-list (vector)
|
|
|
287 (let ((i (1- (length vector)))
|
|
|
288 list)
|
|
|
289 (while (>= i 0)
|
|
|
290 (setq list (cons (aref vector i) list))
|
|
|
291 (vm-decrement i))
|
|
|
292 list ))
|
|
|
293
|
|
|
294 (defun vm-extend-vector (vector length &optional fill)
|
|
|
295 (let ((vlength (length vector)))
|
|
|
296 (if (< vlength length)
|
|
|
297 (apply 'vector (nconc (vm-vector-to-list vector)
|
|
|
298 (make-list (- length vlength) fill)))
|
|
|
299 vector )))
|
|
|
300
|
|
108
|
301 (defun vm-obarray-to-string-list (blobarray)
|
|
0
|
302 (let ((list nil))
|
|
|
303 (mapatoms (function (lambda (s) (setq list (cons (symbol-name s) list))))
|
|
108
|
304 blobarray)
|
|
0
|
305 list ))
|
|
|
306
|
|
|
307 (defun vm-mapcar (function &rest lists)
|
|
|
308 (let (arglist result)
|
|
|
309 (while (car lists)
|
|
|
310 (setq arglist (mapcar 'car lists))
|
|
|
311 (setq result (cons (apply function arglist) result))
|
|
|
312 (setq lists (mapcar 'cdr lists)))
|
|
|
313 (nreverse result)))
|
|
|
314
|
|
|
315 (defun vm-mapc (function &rest lists)
|
|
|
316 (let (arglist)
|
|
|
317 (while (car lists)
|
|
|
318 (setq arglist (mapcar 'car lists))
|
|
|
319 (apply function arglist)
|
|
|
320 (setq lists (mapcar 'cdr lists)))))
|
|
|
321
|
|
|
322 (defun vm-delete (predicate list &optional reverse)
|
|
|
323 (let ((p list) (reverse (if reverse 'not 'identity)) prev)
|
|
|
324 (while p
|
|
|
325 (if (funcall reverse (funcall predicate (car p)))
|
|
|
326 (if (null prev)
|
|
|
327 (setq list (cdr list) p list)
|
|
|
328 (setcdr prev (cdr p))
|
|
|
329 (setq p (cdr p)))
|
|
|
330 (setq prev p p (cdr p))))
|
|
|
331 list ))
|
|
|
332
|
|
98
|
333 (defun vm-delete-directory-file-names (list)
|
|
|
334 (vm-delete 'file-directory-p list))
|
|
|
335
|
|
|
336 (defun vm-delete-backup-file-names (list)
|
|
|
337 (vm-delete 'backup-file-name-p list))
|
|
|
338
|
|
|
339 (defun vm-delete-auto-save-file-names (list)
|
|
|
340 (vm-delete 'auto-save-file-name-p list))
|
|
|
341
|
|
0
|
342 (defun vm-delete-duplicates (list &optional all hack-addresses)
|
|
|
343 "Delete duplicate equivalent strings from the list.
|
|
|
344 If ALL is t, then if there is more than one occurrence of a string in the list,
|
|
|
345 then all occurrences of it are removed instead of just the subsequent ones.
|
|
|
346 If HACK-ADDRESSES is t, then the strings are considered to be mail addresses,
|
|
|
347 and only the address part is compared (so that \"Name <foo>\" and \"foo\"
|
|
|
348 would be considered to be equivalent.)"
|
|
|
349 (let ((hashtable vm-delete-duplicates-obarray)
|
|
|
350 (new-list nil)
|
|
|
351 sym-string sym)
|
|
|
352 (fillarray hashtable 0)
|
|
|
353 (while list
|
|
|
354 (setq sym-string
|
|
|
355 (if hack-addresses
|
|
|
356 (nth 1 (funcall vm-chop-full-name-function (car list)))
|
|
|
357 (car list))
|
|
100
|
358 sym-string (or sym-string "-unparseable-garbage-")
|
|
0
|
359 sym (intern sym-string hashtable))
|
|
|
360 (if (boundp sym)
|
|
|
361 (and all (setcar (symbol-value sym) nil))
|
|
|
362 (setq new-list (cons (car list) new-list))
|
|
|
363 (set sym new-list))
|
|
|
364 (setq list (cdr list)))
|
|
|
365 (delq nil (nreverse new-list))))
|
|
|
366
|
|
|
367 (defun vm-member-0 (thing list)
|
|
|
368 (catch 'done
|
|
|
369 (while list
|
|
|
370 (and (equal (car list) thing)
|
|
|
371 (throw 'done list))
|
|
|
372 (setq list (cdr list)))
|
|
|
373 nil ))
|
|
|
374
|
|
|
375 (fset 'vm-member (symbol-function (if (fboundp 'member) 'member 'vm-member-0)))
|
|
|
376
|
|
|
377 (defun vm-delqual (ob list)
|
|
|
378 (let ((prev nil)
|
|
|
379 (curr list))
|
|
|
380 (while curr
|
|
|
381 (if (not (equal ob (car curr)))
|
|
|
382 (setq prev curr
|
|
|
383 curr (cdr curr))
|
|
|
384 (if (null prev)
|
|
|
385 (setq list (cdr list)
|
|
|
386 curr list)
|
|
|
387 (setq curr (cdr curr))
|
|
|
388 (setcdr prev curr))))
|
|
|
389 list ))
|
|
|
390
|
|
|
391 (defun vm-copy-local-variables (buffer &rest variables)
|
|
|
392 (let ((values (mapcar 'symbol-value variables)))
|
|
|
393 (save-excursion
|
|
|
394 (set-buffer buffer)
|
|
|
395 (vm-mapc 'set variables values))))
|
|
|
396
|
|
76
|
397 (put 'folder-empty 'error-conditions '(folder-empty error))
|
|
|
398 (put 'folder-empty 'error-message "Folder is empty")
|
|
|
399 (put 'unrecognized-folder-type 'error-conditions
|
|
|
400 '(unrecognized-folder-type error))
|
|
|
401 (put 'unrecognized-folder-type 'error-message "Unrecognized folder type")
|
|
0
|
402
|
|
|
403 (defun vm-error-if-folder-empty ()
|
|
|
404 (while (null vm-message-list)
|
|
|
405 (if vm-folder-type
|
|
|
406 (signal 'unrecognized-folder-type nil)
|
|
|
407 (signal 'folder-empty nil))))
|
|
|
408
|
|
|
409 (defun vm-copy (object)
|
|
|
410 (cond ((consp object)
|
|
|
411 (let (return-value cons)
|
|
|
412 (setq return-value (cons (vm-copy (car object)) nil)
|
|
|
413 cons return-value
|
|
|
414 object (cdr object))
|
|
|
415 (while (consp object)
|
|
|
416 (setcdr cons (cons (vm-copy (car object)) nil))
|
|
|
417 (setq cons (cdr cons)
|
|
|
418 object (cdr object)))
|
|
|
419 (setcdr cons object)
|
|
|
420 return-value ))
|
|
|
421 ((vectorp object) (apply 'vector (mapcar 'vm-copy object)))
|
|
|
422 ((stringp object) (copy-sequence object))
|
|
98
|
423 ((markerp object) (copy-marker object))
|
|
0
|
424 (t object)))
|
|
|
425
|
|
70
|
426 ;; make-frame might be defined and still not work. This would
|
|
|
427 ;; be true since the user could be running on a tty and using
|
|
|
428 ;; XEmacs 19.12, or using FSF Emacs 19.28 (or prior FSF Emacs versions).
|
|
|
429 ;;
|
|
|
430 ;; make-frame works on ttys in FSF Emacs 19.29, but other than
|
|
|
431 ;; looking at the version number I don't know a sane way to
|
|
|
432 ;; test for it without just running make-frame. I'll just
|
|
|
433 ;; let it not work for now... someone will complain eventually
|
|
|
434 ;; and I'll think of something.
|
|
|
435
|
|
146
|
436 (defun vm-multiple-frames-possible-p ()
|
|
|
437 (cond (vm-xemacs-p
|
|
|
438 (eq (device-type) 'x))
|
|
|
439 (vm-fsfemacs-19-p
|
|
|
440 (not (eq window-system nil)))))
|
|
|
441
|
|
|
442 (defun vm-mouse-support-possible-p ()
|
|
|
443 (vm-multiple-frames-possible-p))
|
|
|
444
|
|
0
|
445 (defun vm-menu-support-possible-p ()
|
|
140
|
446 (cond (vm-xemacs-p
|
|
|
447 (featurep 'menubar))
|
|
|
448 (vm-fsfemacs-19-p
|
|
|
449 (fboundp 'menu-bar-mode))
|
|
|
450 (t nil)))
|
|
146
|
451
|
|
0
|
452 (defun vm-toolbar-support-possible-p ()
|
|
146
|
453 (and vm-xemacs-p (featurep 'toolbar)))
|
|
24
|
454
|
|
100
|
455 (defun vm-multiple-fonts-possible-p ()
|
|
146
|
456 (cond (vm-xemacs-p
|
|
|
457 (eq (device-type) 'x))
|
|
|
458 (vm-fsfemacs-19-p
|
|
|
459 (eq window-system 'x))))
|
|
100
|
460
|
|
0
|
461 (defun vm-run-message-hook (message &optional hook-variable)
|
|
|
462 (save-excursion
|
|
|
463 (set-buffer (vm-buffer-of message))
|
|
|
464 (vm-save-restriction
|
|
|
465 (widen)
|
|
|
466 (save-excursion
|
|
|
467 (narrow-to-region (vm-headers-of message) (vm-text-end-of message))
|
|
|
468 (run-hooks hook-variable)))))
|
|
|
469
|
|
|
470 (defun vm-error-free-call (function &rest args)
|
|
|
471 (condition-case nil
|
|
|
472 (apply function args)
|
|
|
473 (error nil)))
|
|
|
474
|
|
76
|
475 (put 'beginning-of-folder 'error-conditions '(beginning-of-folder error))
|
|
|
476 (put 'beginning-of-folder 'error-message "Beginning of folder")
|
|
|
477 (put 'end-of-folder 'error-conditions '(end-of-folder error))
|
|
|
478 (put 'end-of-folder 'error-message "End of folder")
|
|
0
|
479
|
|
|
480 (defun vm-trace (&rest args)
|
|
|
481 (save-excursion
|
|
|
482 (set-buffer (get-buffer-create "*vm-trace*"))
|
|
|
483 (apply 'insert args)))
|
|
|
484
|
|
|
485 (defun vm-timezone-make-date-sortable (string)
|
|
|
486 (or (cdr (assq string vm-sortable-date-alist))
|
|
|
487 (let ((vect (vm-parse-date string))
|
|
|
488 (date (vm-parse (current-time-string) " *\\([^ ]+\\)")))
|
|
|
489 ;; if specified date is incomplete fill in the holes
|
|
|
490 ;; with useful information, defaulting to the current
|
|
|
491 ;; date and timezone for everything except hh:mm:ss which
|
|
|
492 ;; defaults to midnight.
|
|
|
493 (if (equal (aref vect 1) "")
|
|
|
494 (aset vect 1 (nth 2 date)))
|
|
|
495 (if (equal (aref vect 2) "")
|
|
|
496 (aset vect 2 (nth 1 date)))
|
|
|
497 (if (equal (aref vect 3) "")
|
|
|
498 (aset vect 3 (nth 4 date)))
|
|
|
499 (if (equal (aref vect 4) "")
|
|
|
500 (aset vect 4 "00:00:00"))
|
|
|
501 (if (equal (aref vect 5) "")
|
|
|
502 (aset vect 5 (vm-current-time-zone)))
|
|
|
503 ;; save this work so we won't have to do it again
|
|
|
504 (setq vm-sortable-date-alist
|
|
|
505 (cons (cons string
|
|
118
|
506 (condition-case nil
|
|
|
507 (timezone-make-date-sortable
|
|
|
508 (format "%s %s %s %s %s"
|
|
|
509 (aref vect 1)
|
|
|
510 (aref vect 2)
|
|
|
511 (aref vect 3)
|
|
|
512 (aref vect 4)
|
|
|
513 (aref vect 5)))
|
|
|
514 (error "1970010100:00:00")))
|
|
0
|
515 vm-sortable-date-alist))
|
|
|
516 ;; return result
|
|
|
517 (cdr (car vm-sortable-date-alist)))))
|
|
|
518
|
|
|
519 (defun vm-current-time-zone ()
|
|
|
520 (or (condition-case nil
|
|
|
521 (let* ((zone (car (current-time-zone)))
|
|
|
522 (absmin (/ (vm-abs zone) 60)))
|
|
|
523 (format "%c%02d%02d" (if (< zone 0) ?- ?+)
|
|
|
524 (/ absmin 60) (% absmin 60)))
|
|
|
525 (error nil))
|
|
|
526 (let ((temp-buffer nil))
|
|
|
527 (condition-case nil
|
|
|
528 (unwind-protect
|
|
|
529 (save-excursion
|
|
|
530 (setq temp-buffer (generate-new-buffer "*vm-work*"))
|
|
|
531 (set-buffer temp-buffer)
|
|
|
532 (call-process "date" nil temp-buffer nil)
|
|
|
533 (nth 4 (vm-parse (vm-buffer-string-no-properties)
|
|
|
534 " *\\([^ ]+\\)")))
|
|
|
535 (and temp-buffer (kill-buffer temp-buffer)))
|
|
|
536 (error nil)))
|
|
|
537 ""))
|
|
|
538
|
|
|
539 (defun vm-should-generate-summary ()
|
|
|
540 (cond ((eq vm-startup-with-summary t) t)
|
|
|
541 ((integerp vm-startup-with-summary)
|
|
|
542 (let ((n vm-startup-with-summary))
|
|
|
543 (cond ((< n 0) (null (nth (vm-abs n) vm-message-list)))
|
|
|
544 (t (nth (1- n) vm-message-list)))))
|
|
|
545 (vm-startup-with-summary t)
|
|
|
546 (t nil)))
|
|
|
547
|
|
|
548 (defun vm-find-composition-buffer (&optional not-picky)
|
|
|
549 (let ((b-list (buffer-list)) choice alternate)
|
|
|
550 (save-excursion
|
|
|
551 (while b-list
|
|
|
552 (set-buffer (car b-list))
|
|
|
553 (if (eq major-mode 'mail-mode)
|
|
|
554 (if (buffer-modified-p)
|
|
|
555 (setq choice (current-buffer)
|
|
|
556 b-list nil)
|
|
|
557 (and not-picky (null alternate)
|
|
|
558 (setq alternate (current-buffer)))
|
|
|
559 (setq b-list (cdr b-list)))
|
|
|
560 (setq b-list (cdr b-list))))
|
|
|
561 (or choice alternate))))
|
|
|
562
|
|
|
563 (defun vm-get-file-buffer (file)
|
|
|
564 "Like get-file-buffer, but also checks buffers against FILE's truename"
|
|
|
565 (or (get-file-buffer file)
|
|
|
566 (and (fboundp 'file-truename)
|
|
|
567 (get-file-buffer (file-truename file)))))
|
|
|
568
|
|
|
569 (defun vm-set-region-face (start end face)
|
|
120
|
570 (let ((e (vm-make-extent start end)))
|
|
|
571 (vm-set-extent-property e 'face face)))
|
|
70
|
572
|
|
0
|
573 (defun vm-default-buffer-substring-no-properties (beg end &optional buffer)
|
|
|
574 (let ((s (if buffer
|
|
|
575 (save-excursion
|
|
|
576 (set-buffer buffer)
|
|
|
577 (buffer-substring beg end))
|
|
|
578 (buffer-substring beg end))))
|
|
|
579 (set-text-properties 0 (length s) nil s)
|
|
|
580 (copy-sequence s)))
|
|
|
581
|
|
|
582 (fset 'vm-buffer-substring-no-properties
|
|
|
583 (cond ((fboundp 'buffer-substring-no-properties)
|
|
|
584 (function buffer-substring-no-properties))
|
|
120
|
585 (vm-xemacs-p
|
|
0
|
586 (function buffer-substring))
|
|
|
587 (t (function vm-default-buffer-substring-no-properties))))
|
|
|
588
|
|
|
589 (defun vm-buffer-string-no-properties ()
|
|
|
590 (vm-buffer-substring-no-properties (point-min) (point-max)))
|
|
98
|
591
|
|
|
592 (defun vm-insert-region-from-buffer (buffer &optional start end)
|
|
|
593 (let ((target-buffer (current-buffer)))
|
|
|
594 (set-buffer buffer)
|
|
|
595 (save-restriction
|
|
|
596 (widen)
|
|
|
597 (or start (setq start (point-min)))
|
|
|
598 (or end (setq end (point-max)))
|
|
|
599 (set-buffer target-buffer)
|
|
|
600 (insert-buffer-substring buffer start end)
|
|
|
601 (set-buffer buffer))
|
|
|
602 (set-buffer target-buffer)))
|
|
|
603
|
|
120
|
604 (if (not (fboundp 'vm-extent-property))
|
|
|
605 (if (fboundp 'overlay-get)
|
|
|
606 (fset 'vm-extent-property 'overlay-get)
|
|
|
607 (fset 'vm-extent-property 'extent-property)))
|
|
98
|
608
|
|
120
|
609 (if (not (fboundp 'vm-set-extent-property))
|
|
|
610 (if (fboundp 'overlay-put)
|
|
|
611 (fset 'vm-set-extent-property 'overlay-put)
|
|
|
612 (fset 'vm-set-extent-property 'set-extent-property)))
|
|
98
|
613
|
|
120
|
614 (if (not (fboundp 'vm-set-extent-endpoints))
|
|
|
615 (if (fboundp 'move-overlay)
|
|
|
616 (fset 'vm-set-extent-endpoints 'move-overlay)
|
|
|
617 (fset 'vm-set-extent-endpoints 'set-extent-endpoints)))
|
|
108
|
618
|
|
120
|
619 (if (not (fboundp 'vm-make-extent))
|
|
|
620 (if (fboundp 'make-overlay)
|
|
|
621 (fset 'vm-make-extent 'make-overlay)
|
|
|
622 (fset 'vm-make-extent 'make-extent)))
|
|
98
|
623
|
|
120
|
624 (if (not (fboundp 'vm-extent-end-position))
|
|
|
625 (if (fboundp 'overlay-end)
|
|
|
626 (fset 'vm-extent-end-position 'overlay-end)
|
|
|
627 (fset 'vm-extent-end-position 'extent-end-position)))
|
|
98
|
628
|
|
120
|
629 (if (not (fboundp 'vm-extent-start-position))
|
|
|
630 (if (fboundp 'overlay-start)
|
|
|
631 (fset 'vm-extent-start-position 'overlay-start)
|
|
|
632 (fset 'vm-extent-start-position 'extent-start-position)))
|
|
98
|
633
|
|
120
|
634 (if (not (fboundp 'vm-detach-extent))
|
|
|
635 (if (fboundp 'delete-overlay)
|
|
|
636 (fset 'vm-detach-extent 'delete-overlay)
|
|
|
637 (fset 'vm-detach-extent 'detach-extent)))
|
|
98
|
638
|
|
120
|
639 (if (not (fboundp 'vm-extent-properties))
|
|
|
640 (if (fboundp 'overlay-properties)
|
|
|
641 (fset 'vm-extent-properties 'overlay-properties)
|
|
|
642 (fset 'vm-extent-properties 'extent-properties)))
|
|
98
|
643
|
|
|
644 (defun vm-copy-extent (e)
|
|
|
645 (let ((props (vm-extent-properties e))
|
|
|
646 (ee (vm-make-extent (vm-extent-start-position e)
|
|
|
647 (vm-extent-end-position e))))
|
|
|
648 (while props
|
|
|
649 (vm-set-extent-property ee (car props) (car (cdr props)))
|
|
100
|
650 (setq props (cdr (cdr props))))))
|
|
98
|
651
|
|
|
652 (defun vm-make-tempfile-name ()
|
|
|
653 (let ((done nil) (pid (emacs-pid)) filename)
|
|
|
654 (while (not done)
|
|
|
655 (setq filename (format "%s/vm%d.%d" vm-temp-file-directory pid
|
|
|
656 vm-tempfile-counter)
|
|
|
657 vm-tempfile-counter (1+ vm-tempfile-counter)
|
|
|
658 done (not (file-exists-p filename))))
|
|
|
659 filename ))
|
|
|
660
|
|
|
661 (defun vm-insert-char (char &optional count ignored buffer)
|
|
|
662 (condition-case nil
|
|
|
663 (progn
|
|
|
664 (insert-char char count ignored buffer)
|
|
|
665 (fset 'vm-insert-char 'insert-char))
|
|
|
666 (wrong-number-of-arguments
|
|
|
667 (fset 'vm-insert-char 'vm-xemacs-compatible-insert-char)
|
|
|
668 (vm-insert-char char count ignored buffer))))
|
|
|
669
|
|
|
670 (defun vm-xemacs-compatible-insert-char (char &optional count ignored buffer)
|
|
|
671 (if (and buffer (eq buffer (current-buffer)))
|
|
|
672 (insert-char char count)
|
|
|
673 (save-excursion
|
|
|
674 (set-buffer buffer)
|
|
|
675 (insert-char char count))))
|
|
|
676
|
|
|
677 (defun vm-symbol-lists-intersect-p (list1 list2)
|
|
|
678 (catch 'done
|
|
|
679 (while list1
|
|
|
680 (and (memq (car list1) list2)
|
|
|
681 (throw 'done t))
|
|
|
682 (setq list1 (cdr list1)))
|
|
|
683 nil ))
|
|
|
684
|
|
|
685 (defun vm-set-buffer-variable (buffer var value)
|
|
|
686 (save-excursion
|
|
|
687 (set-buffer buffer)
|
|
|
688 (set var value)))
|
|
|
689
|
|
100
|
690 (defun vm-buffer-variable-value (buffer var)
|
|
|
691 (save-excursion
|
|
|
692 (set-buffer buffer)
|
|
|
693 (symbol-value var)))
|
|
|
694
|
|
98
|
695 (defsubst vm-with-string-as-temp-buffer (string function)
|
|
|
696 (let ((work-buffer nil))
|
|
|
697 (unwind-protect
|
|
|
698 (save-excursion
|
|
|
699 (setq work-buffer (generate-new-buffer " *work*"))
|
|
|
700 (set-buffer work-buffer)
|
|
|
701 (insert string)
|
|
|
702 (funcall function)
|
|
|
703 (buffer-string))
|
|
|
704 (and work-buffer (kill-buffer work-buffer)))))
|
|
100
|
705
|
|
|
706 (defmacro vm-with-virtual-selector-variables (&rest forms)
|
|
|
707 (append '(let ((any 'vm-vs-any)
|
|
|
708 (and 'vm-vs-and)
|
|
|
709 (or 'vm-vs-or)
|
|
|
710 (not 'vm-vs-not)
|
|
|
711 (header 'vm-vs-header)
|
|
|
712 (label 'vm-vs-label)
|
|
|
713 (text 'vm-vs-text)
|
|
|
714 (recipient 'vm-vs-recipient)
|
|
|
715 (author 'vm-vs-author)
|
|
|
716 (subject 'vm-vs-subject)
|
|
|
717 (sent-before 'vm-vs-sent-before)
|
|
|
718 (sent-after 'vm-vs-sent-after)
|
|
|
719 (more-chars-than 'vm-vs-more-chars-than)
|
|
|
720 (less-chars-than 'vm-vs-less-chars-than)
|
|
|
721 (more-lines-than 'vm-vs-more-lines-than)
|
|
|
722 (less-lines-than 'vm-vs-less-lines-than)
|
|
|
723 (new 'vm-vs-new)
|
|
|
724 (unread 'vm-vs-unread)
|
|
|
725 (read 'vm-vs-read)
|
|
|
726 (deleted 'vm-vs-deleted)
|
|
|
727 (replied 'vm-vs-replied)
|
|
|
728 (forwarded 'vm-vs-forwarded)
|
|
|
729 (filed 'vm-vs-filed)
|
|
|
730 (written 'vm-vs-written)
|
|
|
731 (edited 'vm-vs-edited)
|
|
|
732 (marked 'vm-vs-marked)))
|
|
|
733 forms))
|
|
|
734
|
|
|
735 (defun vm-string-assoc (elt list)
|
|
|
736 (let ((case-fold-search t)
|
|
|
737 (found nil)
|
|
|
738 (elt (regexp-quote elt)))
|
|
|
739 (while (and list (not found))
|
|
|
740 (if (and (equal 0 (string-match elt (car (car list))))
|
|
|
741 (= (match-end 0) (length (car (car list)))))
|
|
|
742 (setq found t)
|
|
|
743 (setq list (cdr list))))
|
|
|
744 (car list)))
|
|
|
745
|
|
|
746 (defun vm-string-member (elt list)
|
|
|
747 (let ((case-fold-search t)
|
|
|
748 (found nil)
|
|
|
749 (elt (regexp-quote elt)))
|
|
|
750 (while (and list (not found))
|
|
|
751 (if (and (equal 0 (string-match elt (car list)))
|
|
|
752 (= (match-end 0) (length (car list))))
|
|
|
753 (setq found t)
|
|
|
754 (setq list (cdr list))))
|
|
|
755 list))
|
|
108
|
756
|
|
|
757 (defmacro vm-assert (expression)
|
|
|
758 (list 'or expression
|
|
|
759 (list 'progn
|
|
|
760 (list 'setq 'debug-on-error t)
|
|
|
761 (list 'error "assertion failed: %S"
|
|
|
762 (list 'quote expression)))))
|
