;;; Code:
-(defconst mm-running-xemacs (string-match "XEmacs" emacs-version))
-
-(defconst mm-binary-coding-system
- (if mm-running-xemacs
- 'binary 'no-conversion)
- "100% binary coding system.")
-
-(defconst mm-text-coding-system
- (and (fboundp 'coding-system-list)
- (if (memq system-type '(windows-nt ms-dos ms-windows))
- 'raw-text-dos 'raw-text))
- "Text-safe coding system (For removing ^M).")
+(require 'mail-prsvr)
(defvar mm-mime-mule-charset-alist
'((us-ascii ascii)
chinese-cns11643-7))
"Alist of MIME-charset/MULE-charsets.")
-
(eval-and-compile
(mapcar
(lambda (elem)
(let ((nfunc (intern (format "mm-%s" (car elem)))))
(if (fboundp (car elem))
- (fset nfunc (car elem))
- (fset nfunc (cdr elem)))))
+ (defalias nfunc (car elem))
+ (defalias nfunc (cdr elem)))))
'((decode-coding-string . (lambda (s a) s))
(encode-coding-string . (lambda (s a) s))
(encode-coding-region . ignore)
prompt (mapcar (lambda (s) (list (symbol-name (car s))))
mm-mime-mule-charset-alist)))))))
+(eval-and-compile
+ (defalias 'mm-char-or-char-int-p
+ (cond
+ ((fboundp 'char-or-char-int-p) 'char-or-char-int-p)
+ ((fboundp 'char-valid-p) 'char-valid-p)
+ (t 'identity))))
+
(defvar mm-coding-system-list nil)
(defun mm-get-coding-system-list ()
"Get the coding system list."
(x-ctext . ctext))
"A mapping from invalid charset names to the real charset names.")
+(defun mm-coding-system-p (sym)
+ "Return non-nil if SYM is a coding system."
+ (or (and (fboundp 'coding-system-p) (coding-system-p sym))
+ (memq sym (mm-get-coding-system-list))))
+
+(defvar mm-binary-coding-system
+ (cond
+ ((mm-coding-system-p 'binary) 'binary)
+ ((mm-coding-system-p 'no-conversion) 'no-conversion)
+ (t nil))
+ "100% binary coding system.")
+
+(defvar mm-text-coding-system
+ (or (if (memq system-type '(windows-nt ms-dos ms-windows))
+ (and (mm-coding-system-p 'raw-text-dos) 'raw-text-dos)
+ (and (mm-coding-system-p 'raw-text) 'raw-text))
+ mm-binary-coding-system)
+ "Text-safe coding system (For removing ^M).")
+
+(defvar mm-text-coding-system-for-write nil
+ "Text coding system for write.")
+
+(defvar mm-auto-save-coding-system
+ (cond
+ ((mm-coding-system-p 'emacs-mule)
+ (if (memq system-type '(windows-nt ms-dos ms-windows))
+ (if (mm-coding-system-p 'emacs-mule-dos)
+ 'emacs-mule-dos mm-binary-coding-system)
+ 'emacs-mule))
+ ((mm-coding-system-p 'escape-quoted) 'escape-quoted)
+ (t mm-binary-coding-system))
+ "Coding system of auto save file.")
+
;;; Internal variables:
;;; Functions:
(defsubst mm-enable-multibyte ()
"Enable multibyte in the current buffer."
(when (and (fboundp 'set-buffer-multibyte)
+ (boundp 'enable-multibyte-characters)
(default-value 'enable-multibyte-characters))
(set-buffer-multibyte t)))
(when (fboundp 'set-buffer-multibyte)
(set-buffer-multibyte nil)))
+(defun mm-preferred-coding-system (charset)
+ ;; A typo in some Emacs versions.
+ (or (get-charset-property charset 'prefered-coding-system)
+ (get-charset-property charset 'preferred-coding-system)))
+
+(defun mm-charset-after (&optional pos)
+ "Return charset of a character in current buffer at position POS.
+If POS is nil, it defauls to the current point.
+If POS is out of range, the value is nil.
+If the charset is `composition', return the actual one."
+ (let ((charset (cond
+ ((fboundp 'charset-after)
+ (charset-after pos))
+ ((fboundp 'char-charset)
+ (char-charset (char-after pos)))
+ ((< (mm-char-int (char-after pos)) 128)
+ 'ascii)
+ (mail-parse-mule-charset ;; cached mule-charset
+ mail-parse-mule-charset)
+ ((boundp 'current-language-environment)
+ (let ((entry (assoc current-language-environment
+ language-info-alist)))
+ (setq mail-parse-mule-charset
+ (or (car (last (assq 'charset entry)))
+ 'latin-iso8859-1))))
+ (t ;; figure out the charset
+ (setq mail-parse-mule-charset
+ (or (car (last (assq mail-parse-charset
+ mm-mime-mule-charset-alist)))
+ 'latin-iso8859-1))))))
+ (if (eq charset 'composition)
+ (let ((p (or pos (point))))
+ (cadr (find-charset-region p (1+ p))))
+ charset)))
+
(defun mm-mime-charset (charset)
"Return the MIME charset corresponding to the MULE CHARSET."
- (if (fboundp 'coding-system-get)
+ (if (and (fboundp 'coding-system-get) (fboundp 'get-charset-property))
;; This exists in Emacs 20.
(or
- (and (get-charset-property charset 'prefered-coding-system)
+ (and (mm-preferred-coding-system charset)
(coding-system-get
- (get-charset-property charset 'prefered-coding-system)
- 'mime-charset))
+ (mm-preferred-coding-system charset) 'mime-charset))
(and (eq charset 'ascii)
'us-ascii)
- (get-charset-property charset 'prefered-coding-system)
+ (mm-preferred-coding-system charset)
(mm-mule-charset-to-mime-charset charset))
;; This is for XEmacs.
(mm-mule-charset-to-mime-charset charset)))
+(defun mm-delete-duplicates (list)
+ "Simple substitute for CL `delete-duplicates', testing with `equal'."
+ (let (result head)
+ (while list
+ (setq head (car list))
+ (setq list (delete head list))
+ (setq result (cons head result)))
+ (nreverse result)))
+
(defun mm-find-mime-charset-region (b e)
"Return the MIME charsets needed to encode the region between B and E."
- (let ((charsets
- (mapcar 'mm-mime-charset
- (delq 'ascii
- (mm-find-charset-region b e)))))
+ (let ((charsets (mapcar 'mm-mime-charset
+ (delq 'ascii
+ (mm-find-charset-region b e)))))
(when (memq 'iso-2022-jp-2 charsets)
(setq charsets (delq 'iso-2022-jp charsets)))
- (delete-duplicates charsets)))
+ (setq charsets (mm-delete-duplicates charsets))
+ (if (and (> (length charsets) 1)
+ (fboundp 'find-coding-systems-region)
+ (memq 'utf-8 (find-coding-systems-region b e)))
+ '(utf-8)
+ charsets)))
(defsubst mm-multibyte-p ()
"Say whether multibyte is enabled."
- (and (boundp 'enable-multibyte-characters)
- enable-multibyte-characters))
+ (or (string-match "XEmacs\\|Lucid" emacs-version)
+ (and (boundp 'enable-multibyte-characters)
+ enable-multibyte-characters)))
(defmacro mm-with-unibyte-buffer (&rest forms)
"Create a temporary buffer, and evaluate FORMS there like `progn'.
See also `with-temp-file' and `with-output-to-string'."
(let ((temp-buffer (make-symbol "temp-buffer"))
(multibyte (make-symbol "multibyte")))
- `(if (not (boundp 'enable-multibyte-characters))
+ `(if (or (string-match "XEmacs\\|Lucid" emacs-version)
+ (not (boundp 'enable-multibyte-characters)))
(with-temp-buffer ,@forms)
(let ((,multibyte (default-value 'enable-multibyte-characters))
,temp-buffer)
(put 'mm-with-unibyte-buffer 'lisp-indent-function 0)
(put 'mm-with-unibyte-buffer 'edebug-form-spec '(body))
+(defmacro mm-with-unibyte-current-buffer (&rest forms)
+ "Evaluate FORMS there like `progn' in current buffer."
+ (let ((multibyte (make-symbol "multibyte")))
+ `(if (or (string-match "XEmacs\\|Lucid" emacs-version)
+ (not (fboundp 'set-buffer-multibyte)))
+ (progn
+ ,@forms)
+ (let ((,multibyte (default-value 'enable-multibyte-characters)))
+ (unwind-protect
+ (let ((buffer-file-coding-system mm-binary-coding-system)
+ (coding-system-for-read mm-binary-coding-system)
+ (coding-system-for-write mm-binary-coding-system))
+ (set-buffer-multibyte nil)
+ ,@forms)
+ (set-buffer-multibyte ,multibyte))))))
+(put 'mm-with-unibyte-current-buffer 'lisp-indent-function 0)
+(put 'mm-with-unibyte-current-buffer 'edebug-form-spec '(body))
+
+(defmacro mm-with-unibyte (&rest forms)
+ "Set default `enable-multibyte-characters' to `nil', eval the FORMS."
+ (let ((multibyte (make-symbol "multibyte")))
+ `(if (or (string-match "XEmacs\\|Lucid" emacs-version)
+ (not (boundp 'enable-multibyte-characters)))
+ (progn ,@forms)
+ (let ((,multibyte (default-value 'enable-multibyte-characters)))
+ (unwind-protect
+ (progn
+ (setq-default enable-multibyte-characters nil)
+ ,@forms)
+ (setq-default enable-multibyte-characters ,multibyte))))))
+(put 'mm-with-unibyte 'lisp-indent-function 0)
+(put 'mm-with-unibyte 'edebug-form-spec '(body))
+
(defun mm-find-charset-region (b e)
"Return a list of charsets in the region."
(cond
- ((and (boundp 'enable-multibyte-characters)
- enable-multibyte-characters
+ ((and (mm-multibyte-p)
(fboundp 'find-charset-region))
- (find-charset-region b e))
+ ;; Remove composition since the base charsets have been included.
+ (delq 'composition (find-charset-region b e)))
((not (boundp 'current-language-environment))
(save-excursion
(save-restriction
(skip-chars-forward "\0-\177")
(if (eobp)
'(ascii)
- (delq nil (list 'ascii mail-parse-charset))))))
+ (delq nil (list 'ascii
+ (or (car (last (assq mail-parse-charset
+ mm-mime-mule-charset-alist)))
+ 'latin-iso8859-1)))))))
(t
;; We are in a unibyte buffer, so we futz around a bit.
(save-excursion
(save-restriction
(narrow-to-region b e)
(goto-char (point-min))
- (let ((entry (assoc (capitalize current-language-environment)
+ (let ((entry (assoc current-language-environment
language-info-alist)))
(skip-chars-forward "\0-\177")
(if (eobp)
'(ascii)
- (list 'ascii (car (last (assq 'charset entry)))))))))))
+ (delq nil (list 'ascii
+ (or (car (last (assq 'charset entry)))
+ 'latin-iso8859-1))))))))))
(defun mm-read-charset (prompt)
"Return a charset."
(pop alist))
(nreverse out)))
-(defun mm-insert-file-contents (filename &optional visit beg end replace)
+(defvar mm-inhibit-file-name-handlers
+ '(jka-compr-handler)
+ "A list of handlers doing (un)compression (etc) thingies.")
+
+(defun mm-insert-file-contents (filename &optional visit beg end replace
+ inhibit)
"Like `insert-file-contents', q.v., but only reads in the file.
A buffer may be modified in several ways after reading into the buffer due
to advanced Emacs features, such as file-name-handlers, format decoding,
find-file-hooks, etc.
+If INHIBIT is non-nil, inhibit mm-inhibit-file-name-handlers.
This function ensures that none of these modifications will take place."
(let ((format-alist nil)
- (auto-mode-alist (mm-auto-mode-alist))
+ (auto-mode-alist (if inhibit nil (mm-auto-mode-alist)))
(default-major-mode 'fundamental-mode)
(enable-local-variables nil)
(after-insert-file-functions nil)
(enable-local-eval nil)
- (find-file-hooks nil))
+ (find-file-hooks nil)
+ (inhibit-file-name-operation (if inhibit
+ 'insert-file-contents
+ inhibit-file-name-operation))
+ (inhibit-file-name-handlers
+ (if inhibit
+ (append mm-inhibit-file-name-handlers
+ inhibit-file-name-handlers)
+ inhibit-file-name-handlers)))
(insert-file-contents filename visit beg end replace)))
+(defun mm-append-to-file (start end filename &optional codesys inhibit)
+ "Append the contents of the region to the end of file FILENAME.
+When called from a function, expects three arguments,
+START, END and FILENAME. START and END are buffer positions
+saying what text to write.
+Optional fourth argument specifies the coding system to use when
+encoding the file.
+If INHIBIT is non-nil, inhibit mm-inhibit-file-name-handlers."
+ (let ((coding-system-for-write
+ (or codesys mm-text-coding-system-for-write
+ mm-text-coding-system))
+ (inhibit-file-name-operation (if inhibit
+ 'append-to-file
+ inhibit-file-name-operation))
+ (inhibit-file-name-handlers
+ (if inhibit
+ (append mm-inhibit-file-name-handlers
+ inhibit-file-name-handlers)
+ inhibit-file-name-handlers)))
+ (append-to-file start end filename)))
+
+(defun mm-write-region (start end filename &optional append visit lockname
+ coding-system inhibit)
+
+ "Like `write-region'.
+If INHIBIT is non-nil, inhibit mm-inhibit-file-name-handlers."
+ (let ((coding-system-for-write
+ (or coding-system mm-text-coding-system-for-write
+ mm-text-coding-system))
+ (inhibit-file-name-operation (if inhibit
+ 'write-region
+ inhibit-file-name-operation))
+ (inhibit-file-name-handlers
+ (if inhibit
+ (append mm-inhibit-file-name-handlers
+ inhibit-file-name-handlers)
+ inhibit-file-name-handlers)))
+ (write-region start end filename append visit lockname)))
+
(provide 'mm-util)
;;; mm-util.el ends here
projects / elisp / gnus.git- / blobdiff