2000-10-13 10:52:00 ShengHuo ZHU <zsh@cs.rochester.edu>
[gnus] / lisp / mm-util.el
1 ;;; mm-util.el --- Utility functions for MIME things
2 ;; Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
3
4 ;; Author: Lars Magne Ingebrigtsen <larsi@gnus.org>
5 ;;      MORIOKA Tomohiko <morioka@jaist.ac.jp>
6 ;; This file is part of GNU Emacs.
7
8 ;; GNU Emacs is free software; you can redistribute it and/or modify
9 ;; it under the terms of the GNU General Public License as published by
10 ;; the Free Software Foundation; either version 2, or (at your option)
11 ;; any later version.
12
13 ;; GNU Emacs is distributed in the hope that it will be useful,
14 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
15 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 ;; GNU General Public License for more details.
17
18 ;; You should have received a copy of the GNU General Public License
19 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
20 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 ;; Boston, MA 02111-1307, USA.
22
23 ;;; Commentary:
24
25 ;;; Code:
26
27 (require 'mail-prsvr)
28
29 (defvar mm-mime-mule-charset-alist
30   '((us-ascii ascii)
31     (iso-8859-1 latin-iso8859-1)
32     (iso-8859-2 latin-iso8859-2)
33     (iso-8859-3 latin-iso8859-3)
34     (iso-8859-4 latin-iso8859-4)
35     (iso-8859-5 cyrillic-iso8859-5)
36     ;; Non-mule (X)Emacs uses the last mule-charset for 8bit characters.
37     ;; The fake mule-charset, gnus-koi8-r, tells Gnus that the default 
38     ;; charset is koi8-r, not iso-8859-5.
39     (koi8-r cyrillic-iso8859-5 gnus-koi8-r)
40     (iso-8859-6 arabic-iso8859-6)
41     (iso-8859-7 greek-iso8859-7)
42     (iso-8859-8 hebrew-iso8859-8)
43     (iso-8859-9 latin-iso8859-9)
44     (viscii vietnamese-viscii-lower)
45     (iso-2022-jp latin-jisx0201 japanese-jisx0208 japanese-jisx0208-1978)
46     (euc-kr korean-ksc5601)
47     (cn-gb-2312 chinese-gb2312)
48     (cn-big5 chinese-big5-1 chinese-big5-2)
49     (tibetan tibetan)
50     (thai-tis620 thai-tis620)
51     (iso-2022-7bit ethiopic arabic-1-column arabic-2-column)
52     (iso-2022-jp-2 latin-iso8859-1 greek-iso8859-7
53                    latin-jisx0201 japanese-jisx0208-1978
54                    chinese-gb2312 japanese-jisx0208
55                    korean-ksc5601 japanese-jisx0212
56                    katakana-jisx0201)
57     (iso-2022-int-1 latin-iso8859-1 greek-iso8859-7
58                     latin-jisx0201 japanese-jisx0208-1978
59                     chinese-gb2312 japanese-jisx0208
60                     korean-ksc5601 japanese-jisx0212
61                     chinese-cns11643-1 chinese-cns11643-2)
62     (iso-2022-int-1 latin-iso8859-1 latin-iso8859-2
63                     cyrillic-iso8859-5 greek-iso8859-7
64                     latin-jisx0201 japanese-jisx0208-1978
65                     chinese-gb2312 japanese-jisx0208
66                     korean-ksc5601 japanese-jisx0212
67                     chinese-cns11643-1 chinese-cns11643-2
68                     chinese-cns11643-3 chinese-cns11643-4
69                     chinese-cns11643-5 chinese-cns11643-6
70                     chinese-cns11643-7)
71     (utf-8 unicode-a unicode-b unicode-c unicode-d unicode-e))
72   "Alist of MIME-charset/MULE-charsets.")
73
74 (eval-and-compile
75   (mapcar
76    (lambda (elem)
77      (let ((nfunc (intern (format "mm-%s" (car elem)))))
78        (if (fboundp (car elem))
79            (defalias nfunc (car elem))
80          (defalias nfunc (cdr elem)))))
81    '((decode-coding-string . (lambda (s a) s))
82      (encode-coding-string . (lambda (s a) s))
83      (encode-coding-region . ignore)
84      (coding-system-list . ignore)
85      (decode-coding-region . ignore)
86      (char-int . identity)
87      (device-type . ignore)
88      (coding-system-equal . equal)
89      (annotationp . ignore)
90      (set-buffer-file-coding-system . ignore)
91      (make-char
92       . (lambda (charset int)
93           (int-to-char int)))
94      (read-coding-system
95       . (lambda (prompt)
96           "Prompt the user for a coding system."
97           (completing-read
98            prompt (mapcar (lambda (s) (list (symbol-name (car s))))
99                           mm-mime-mule-charset-alist))))
100      (read-charset
101       . (lambda (prompt)
102           "Return a charset."
103           (intern
104            (completing-read
105             prompt
106             (mapcar (lambda (e) (list (symbol-name (car e))))
107                     mm-mime-mule-charset-alist)
108             nil t)))))))
109
110 (eval-and-compile
111   (defalias 'mm-char-or-char-int-p
112     (cond 
113      ((fboundp 'char-or-char-int-p) 'char-or-char-int-p)
114      ((fboundp 'char-valid-p) 'char-valid-p) 
115      (t 'identity))))
116
117 (defvar mm-coding-system-list nil)
118 (defun mm-get-coding-system-list ()
119   "Get the coding system list."
120   (or mm-coding-system-list
121       (setq mm-coding-system-list (mm-coding-system-list))))
122
123 (defvar mm-charset-synonym-alist
124   '((big5 . cn-big5)
125     (gb2312 . cn-gb-2312)
126     (x-ctext . ctext))
127   "A mapping from invalid charset names to the real charset names.")
128
129 (defun mm-coding-system-p (sym)
130   "Return non-nil if SYM is a coding system."
131   (or (and (fboundp 'coding-system-p) (coding-system-p sym))
132       (memq sym (mm-get-coding-system-list))))
133
134 (defvar mm-binary-coding-system
135   (cond 
136    ((mm-coding-system-p 'binary) 'binary)
137    ((mm-coding-system-p 'no-conversion) 'no-conversion)
138    (t nil))
139   "100% binary coding system.")
140
141 (defvar mm-text-coding-system
142   (or (if (memq system-type '(windows-nt ms-dos ms-windows))
143           (and (mm-coding-system-p 'raw-text-dos) 'raw-text-dos)
144         (and (mm-coding-system-p 'raw-text) 'raw-text))
145       mm-binary-coding-system)
146   "Text-safe coding system (For removing ^M).")
147
148 (defvar mm-text-coding-system-for-write nil
149   "Text coding system for write.")
150
151 (defvar mm-auto-save-coding-system
152   (cond 
153    ((mm-coding-system-p 'emacs-mule)
154     (if (memq system-type '(windows-nt ms-dos ms-windows))
155         (if (mm-coding-system-p 'emacs-mule-dos) 
156             'emacs-mule-dos mm-binary-coding-system)
157       'emacs-mule))
158    ((mm-coding-system-p 'escape-quoted) 'escape-quoted)
159    (t mm-binary-coding-system))
160   "Coding system of auto save file.")
161
162 ;;; Internal variables:
163
164 ;;; Functions:
165
166 (defun mm-mule-charset-to-mime-charset (charset)
167   "Return the MIME charset corresponding to MULE CHARSET."
168   (let ((alist mm-mime-mule-charset-alist)
169         out)
170     (while alist
171       (when (memq charset (cdar alist))
172         (setq out (caar alist)
173               alist nil))
174       (pop alist))
175     out))
176
177 (defun mm-charset-to-coding-system (charset &optional lbt)
178   "Return coding-system corresponding to CHARSET.
179 CHARSET is a symbol naming a MIME charset.
180 If optional argument LBT (`unix', `dos' or `mac') is specified, it is
181 used as the line break code type of the coding system."
182   (when (stringp charset)
183     (setq charset (intern (downcase charset))))
184   (setq charset
185         (or (cdr (assq charset mm-charset-synonym-alist))
186             charset))
187   (when lbt
188     (setq charset (intern (format "%s-%s" charset lbt))))
189   (cond
190    ;; Running in a non-MULE environment.
191    ((null (mm-get-coding-system-list))
192     charset)
193    ;; ascii
194    ((eq charset 'us-ascii)
195     'ascii)
196    ;; Check to see whether we can handle this charset.
197    ((memq charset (mm-get-coding-system-list))
198     charset)
199    ;; Nope.
200    (t
201     nil)))
202
203 (if (fboundp 'subst-char-in-string)
204     (defsubst mm-replace-chars-in-string (string from to)
205       (subst-char-in-string from to string))
206   (defun mm-replace-chars-in-string (string from to)
207     "Replace characters in STRING from FROM to TO."
208     (let ((string (substring string 0)) ;Copy string.
209           (len (length string))
210           (idx 0))
211       ;; Replace all occurrences of FROM with TO.
212       (while (< idx len)
213         (when (= (aref string idx) from)
214           (aset string idx to))
215         (setq idx (1+ idx)))
216       string)))
217
218 (defsubst mm-enable-multibyte ()
219   "Enable multibyte in the current buffer."
220   (when (and (fboundp 'set-buffer-multibyte)
221              (boundp 'enable-multibyte-characters)
222              (default-value 'enable-multibyte-characters))
223     (set-buffer-multibyte t)))
224
225 (defsubst mm-disable-multibyte ()
226   "Disable multibyte in the current buffer."
227   (when (fboundp 'set-buffer-multibyte)
228     (set-buffer-multibyte nil)))
229
230 (defsubst mm-enable-multibyte-mule4 ()
231   "Enable multibyte in the current buffer.
232 Only used in Emacs Mule 4."
233   (when (and (fboundp 'set-buffer-multibyte)
234              (boundp 'enable-multibyte-characters)
235              (default-value 'enable-multibyte-characters)
236              (not (charsetp 'eight-bit-control)))
237     (set-buffer-multibyte t)))
238
239 (defsubst mm-disable-multibyte-mule4 ()
240   "Disable multibyte in the current buffer.
241 Only used in Emacs Mule 4."
242   (when (and (fboundp 'set-buffer-multibyte)
243              (not (charsetp 'eight-bit-control)))
244     (set-buffer-multibyte nil)))
245
246 (defun mm-preferred-coding-system (charset)
247   ;; A typo in some Emacs versions.
248   (or (get-charset-property charset 'prefered-coding-system)
249       (get-charset-property charset 'preferred-coding-system)))
250
251 (defun mm-charset-after (&optional pos)
252   "Return charset of a character in current buffer at position POS.
253 If POS is nil, it defauls to the current point.
254 If POS is out of range, the value is nil.
255 If the charset is `composition', return the actual one."
256   (let ((char (char-after pos)) charset)
257     (if (< (mm-char-int char) 128)
258         (setq charset 'ascii)
259       ;; charset-after is fake in some Emacsen.
260       (setq charset (and (fboundp 'char-charset) (char-charset char)))
261       (if (eq charset 'composition)
262           (let ((p (or pos (point))))
263             (cadr (find-charset-region p (1+ p))))
264         (if (and charset (not (memq charset '(ascii eight-bit-control
265                                                     eight-bit-graphic))))
266             charset
267           (or
268            mail-parse-mule-charset ;; cached mule-charset
269            (progn
270              (setq mail-parse-mule-charset
271                    (and (boundp 'current-language-environment)
272                       (car (last 
273                             (assq 'charset 
274                                   (assoc current-language-environment 
275                                          language-info-alist))))))
276              (if (or (not mail-parse-mule-charset)
277                      (eq mail-parse-mule-charset 'ascii))
278                  (setq mail-parse-mule-charset
279                        (or (car (last (assq mail-parse-charset
280                                             mm-mime-mule-charset-alist)))
281                            'latin-iso8859-1)))
282              mail-parse-mule-charset)))))))
283
284 (defun mm-mime-charset (charset)
285   "Return the MIME charset corresponding to the MULE CHARSET."
286   (if (and (fboundp 'coding-system-get) (fboundp 'get-charset-property))
287       ;; This exists in Emacs 20.
288       (or
289        (and (mm-preferred-coding-system charset)
290             (coding-system-get
291              (mm-preferred-coding-system charset) 'mime-charset))
292        (and (eq charset 'ascii)
293             'us-ascii)
294        (mm-preferred-coding-system charset)
295        (mm-mule-charset-to-mime-charset charset))
296     ;; This is for XEmacs.
297     (mm-mule-charset-to-mime-charset charset)))
298
299 (defun mm-delete-duplicates (list)
300   "Simple  substitute for CL `delete-duplicates', testing with `equal'."
301   (let (result head)
302     (while list
303       (setq head (car list))
304       (setq list (delete head list))
305       (setq result (cons head result)))
306     (nreverse result)))
307
308 (defun mm-find-mime-charset-region (b e)
309   "Return the MIME charsets needed to encode the region between B and E."
310   (let ((charsets (mapcar 'mm-mime-charset
311                           (delq 'ascii
312                                 (mm-find-charset-region b e)))))
313     (when (memq 'iso-2022-jp-2 charsets)
314       (setq charsets (delq 'iso-2022-jp charsets)))
315     (setq charsets (mm-delete-duplicates charsets))
316     (if (and (> (length charsets) 1)
317              (fboundp 'find-coding-systems-region)
318              (memq 'utf-8 (find-coding-systems-region b e)))
319         '(utf-8)
320       charsets)))
321
322 (defsubst mm-multibyte-p ()
323   "Say whether multibyte is enabled."
324   (if (boundp 'enable-multibyte-characters)
325       enable-multibyte-characters
326     (featurep 'mule)))
327
328 (defmacro mm-with-unibyte-buffer (&rest forms)
329   "Create a temporary buffer, and evaluate FORMS there like `progn'.
330 See also `with-temp-file' and `with-output-to-string'."
331   (let ((temp-buffer (make-symbol "temp-buffer"))
332         (multibyte (make-symbol "multibyte")))
333     `(if (or (featurep 'xemacs)
334              (not (boundp 'enable-multibyte-characters)))
335          (with-temp-buffer ,@forms)
336        (let ((,multibyte (default-value 'enable-multibyte-characters))
337              ,temp-buffer)
338          (unwind-protect
339              (progn
340                (setq-default enable-multibyte-characters nil)
341                (setq ,temp-buffer
342                      (get-buffer-create (generate-new-buffer-name " *temp*")))
343                (unwind-protect
344                    (with-current-buffer ,temp-buffer
345                      (let ((buffer-file-coding-system mm-binary-coding-system)
346                            (coding-system-for-read mm-binary-coding-system)
347                            (coding-system-for-write mm-binary-coding-system))
348                        ,@forms))
349                  (and (buffer-name ,temp-buffer)
350                       (kill-buffer ,temp-buffer))))
351            (setq-default enable-multibyte-characters ,multibyte))))))
352 (put 'mm-with-unibyte-buffer 'lisp-indent-function 0)
353 (put 'mm-with-unibyte-buffer 'edebug-form-spec '(body))
354
355 (defmacro mm-with-unibyte-current-buffer (&rest forms)
356   "Evaluate FORMS there like `progn' in current buffer."
357   (let ((multibyte (make-symbol "multibyte")))
358     `(if (or (featurep 'xemacs)
359              (not (fboundp 'set-buffer-multibyte)))
360          (progn
361            ,@forms)
362        (let ((,multibyte (default-value 'enable-multibyte-characters)))
363          (unwind-protect
364              (let ((buffer-file-coding-system mm-binary-coding-system)
365                    (coding-system-for-read mm-binary-coding-system)
366                    (coding-system-for-write mm-binary-coding-system))
367                (set-buffer-multibyte nil)
368                (setq-default enable-multibyte-characters nil)
369                ,@forms)
370            (setq-default enable-multibyte-characters ,multibyte)
371            (set-buffer-multibyte ,multibyte))))))
372 (put 'mm-with-unibyte-current-buffer 'lisp-indent-function 0)
373 (put 'mm-with-unibyte-current-buffer 'edebug-form-spec '(body))
374
375 (defmacro mm-with-unibyte-current-buffer-mule4 (&rest forms)
376   "Evaluate FORMS there like `progn' in current buffer.
377 Mule4 only."
378   (let ((multibyte (make-symbol "multibyte")))
379     `(if (or (featurep 'xemacs)
380              (not (fboundp 'set-buffer-multibyte))
381              (charsetp 'eight-bit-control)) ;; For Emacs Mule 4 only.
382          (progn
383            ,@forms)
384        (let ((,multibyte (default-value 'enable-multibyte-characters)))
385          (unwind-protect
386              (let ((buffer-file-coding-system mm-binary-coding-system)
387                    (coding-system-for-read mm-binary-coding-system)
388                    (coding-system-for-write mm-binary-coding-system))
389                (set-buffer-multibyte nil)
390                (setq-default enable-multibyte-characters nil)
391                ,@forms)
392            (setq-default enable-multibyte-characters ,multibyte)
393            (set-buffer-multibyte ,multibyte))))))
394 (put 'mm-with-unibyte-current-buffer-mule4 'lisp-indent-function 0)
395 (put 'mm-with-unibyte-current-buffer-mule4 'edebug-form-spec '(body))
396
397 (defmacro mm-with-unibyte (&rest forms)
398   "Set default `enable-multibyte-characters' to `nil', eval the FORMS."
399   (let ((multibyte (make-symbol "multibyte")))
400     `(if (or (featurep 'xemacs)
401              (not (boundp 'enable-multibyte-characters)))
402          (progn ,@forms)
403        (let ((,multibyte (default-value 'enable-multibyte-characters)))
404          (unwind-protect
405              (progn
406                (setq-default enable-multibyte-characters nil)
407                ,@forms)
408            (setq-default enable-multibyte-characters ,multibyte))))))
409 (put 'mm-with-unibyte 'lisp-indent-function 0)
410 (put 'mm-with-unibyte 'edebug-form-spec '(body))
411
412 (defun mm-find-charset-region (b e)
413   "Return a list of charsets in the region."
414   (cond
415    ((and (mm-multibyte-p)
416          (fboundp 'find-charset-region))
417     ;; Remove composition since the base charsets have been included.
418     (delq 'composition (find-charset-region b e)))
419    (t
420     ;; We are in a unibyte buffer or XEmacs non-mule, so we futz around a bit.
421     (save-excursion
422       (save-restriction
423         (narrow-to-region b e)
424         (goto-char (point-min))
425         (skip-chars-forward "\0-\177")
426         (if (eobp)
427             '(ascii)
428           (let (charset)
429             (setq charset
430                   (and (boundp 'current-language-environment)
431                        (car (last (assq 'charset 
432                                         (assoc current-language-environment 
433                                                language-info-alist))))))
434             (if (eq charset 'ascii) (setq charset nil))
435             (or charset
436                 (setq charset
437                       (car (last (assq mail-parse-charset
438                                        mm-mime-mule-charset-alist)))))
439             (list 'ascii (or charset 'latin-iso8859-1)))))))))
440
441 (if (fboundp 'shell-quote-argument)
442     (defalias 'mm-quote-arg 'shell-quote-argument)
443   (defun mm-quote-arg (arg)
444     "Return a version of ARG that is safe to evaluate in a shell."
445     (let ((pos 0) new-pos accum)
446       ;; *** bug: we don't handle newline characters properly
447       (while (setq new-pos (string-match "[]*[;!'`\"$\\& \t{} |()<>]" arg pos))
448         (push (substring arg pos new-pos) accum)
449         (push "\\" accum)
450         (push (list (aref arg new-pos)) accum)
451         (setq pos (1+ new-pos)))
452       (if (= pos 0)
453           arg
454         (apply 'concat (nconc (nreverse accum) (list (substring arg pos))))))))
455
456 (defun mm-auto-mode-alist ()
457   "Return an `auto-mode-alist' with only the .gz (etc) thingies."
458   (let ((alist auto-mode-alist)
459         out)
460     (while alist
461       (when (listp (cdar alist))
462         (push (car alist) out))
463       (pop alist))
464     (nreverse out)))
465
466 (defvar mm-inhibit-file-name-handlers
467   '(jka-compr-handler)
468   "A list of handlers doing (un)compression (etc) thingies.")
469
470 (defun mm-insert-file-contents (filename &optional visit beg end replace
471                                          inhibit)
472   "Like `insert-file-contents', q.v., but only reads in the file.
473 A buffer may be modified in several ways after reading into the buffer due
474 to advanced Emacs features, such as file-name-handlers, format decoding,
475 find-file-hooks, etc.
476 If INHIBIT is non-nil, inhibit mm-inhibit-file-name-handlers.
477   This function ensures that none of these modifications will take place."
478   (let ((format-alist nil)
479         (auto-mode-alist (if inhibit nil (mm-auto-mode-alist)))
480         (default-major-mode 'fundamental-mode)
481         (enable-local-variables nil)
482         (after-insert-file-functions nil)
483         (enable-local-eval nil)
484         (find-file-hooks nil)
485         (inhibit-file-name-operation (if inhibit 
486                                          'insert-file-contents
487                                        inhibit-file-name-operation))
488         (inhibit-file-name-handlers
489          (if inhibit
490              (append mm-inhibit-file-name-handlers 
491                      inhibit-file-name-handlers)
492            inhibit-file-name-handlers)))
493     (insert-file-contents filename visit beg end replace)))
494
495 (defun mm-append-to-file (start end filename &optional codesys inhibit)
496   "Append the contents of the region to the end of file FILENAME.
497 When called from a function, expects three arguments,
498 START, END and FILENAME.  START and END are buffer positions
499 saying what text to write.
500 Optional fourth argument specifies the coding system to use when
501 encoding the file.
502 If INHIBIT is non-nil, inhibit mm-inhibit-file-name-handlers."
503   (let ((coding-system-for-write 
504          (or codesys mm-text-coding-system-for-write 
505              mm-text-coding-system))
506         (inhibit-file-name-operation (if inhibit 
507                                          'append-to-file
508                                        inhibit-file-name-operation))
509         (inhibit-file-name-handlers
510          (if inhibit
511              (append mm-inhibit-file-name-handlers 
512                      inhibit-file-name-handlers)
513            inhibit-file-name-handlers)))
514     (append-to-file start end filename)))
515
516 (defun mm-write-region (start end filename &optional append visit lockname 
517                               coding-system inhibit)
518
519   "Like `write-region'.
520 If INHIBIT is non-nil, inhibit mm-inhibit-file-name-handlers."
521   (let ((coding-system-for-write 
522          (or coding-system mm-text-coding-system-for-write 
523              mm-text-coding-system))
524         (inhibit-file-name-operation (if inhibit 
525                                          'write-region
526                                        inhibit-file-name-operation))
527         (inhibit-file-name-handlers
528          (if inhibit
529              (append mm-inhibit-file-name-handlers 
530                      inhibit-file-name-handlers)
531            inhibit-file-name-handlers)))
532     (write-region start end filename append visit lockname)))
533
534 (provide 'mm-util)
535
536 ;;; mm-util.el ends here