* lisp/gnus/mm-util.el (mm-special-display-p): Remove.
(mm-decode-coding-string, mm-encode-coding-string)
(mm-decode-coding-region, mm-encode-coding-region): Remove.
(mm-string-to-multibyte): Remove.
(mm-char-or-char-int-p): Remove.
(mm-ucs-to-char): Remove compat versions of the function.
(mm-read-coding-system): Remove.
(mm-coding-system-p): Remove compat code.
(mm-enrich-utf-8-by-mule-ucs): Remove.
(mm-enable-multibyte, mm-disable-multibyte): Remove compat versions.
(mm-delete-duplicates): Remove.
(mm-multibyte-p): Remove compat versions.
(mm-xemacs-find-mime-charset-1): Remove.
(mm-xemacs-find-mime-charset): Remove.
(mm-make-temp-file): Made obsolete.
(mm-find-buffer-file-coding-system): Remove XEmacs compat.
(list k (plist-get spec k))))
search-keys))))
;; needed keys (always including host, login, port, and secret)
- (returned-keys (mm-delete-duplicates (append
- '(:host :login :port :secret)
- search-keys)))
+ (returned-keys (delete-dups (append
+ '(:host :login :port :secret)
+ search-keys)))
(items
(loop for search-spec in search-specs
nconc
(list k (plist-get spec k))))
search-keys)))
;; needed keys (always including host, login, port, and secret)
- (returned-keys (mm-delete-duplicates (append
- '(:host :login :port :secret)
- search-keys)))
+ (returned-keys (delete-dups (append
+ '(:host :login :port :secret)
+ search-keys)))
;; Extract host and port from spec
(hosts (plist-get spec :host))
(hosts (if (and hosts (listp hosts)) hosts `(,hosts)))
(list k v))))
search-keys)))
;; needed keys (always including host, login, port, and secret)
- (returned-keys (mm-delete-duplicates (append
- '(:host :login :port :secret)
- search-keys)))
+ (returned-keys (delete-dups (append
+ '(:host :login :port :secret)
+ search-keys)))
(items (plstore-find store search-spec))
(item-names (mapcar #'car items))
(items (butlast items (- (length items) max)))
ctl (and ct (mail-header-parse-content-type ct))
charset (cond
(prompt
- (mm-read-coding-system "Charset to decode: "))
+ (read-coding-system "Charset to decode: "))
(ctl
(mail-content-type-get ctl 'charset)))
format (and ctl (mail-content-type-get ctl 'format)))
(if (stringp charset)
(setq charset (intern (downcase charset)))))))
(if read-charset
- (setq charset (mm-read-coding-system "Charset: " charset)))
+ (setq charset (read-coding-system "Charset: " charset)))
(unless charset
(setq charset gnus-newsgroup-charset))
(when (or force
(if (stringp charset)
(setq charset (intern (downcase charset)))))))
(if read-charset
- (setq charset (mm-read-coding-system "Charset: " charset)))
+ (setq charset (read-coding-system "Charset: " charset)))
(unless charset
(setq charset gnus-newsgroup-charset))
(when (or force
(save-restriction
(narrow-to-region (point) (point-max))
(base64-decode-region (point-min) (point-max))
- (mm-decode-coding-region
+ (decode-coding-region
(point-min) (point-max)
(mm-charset-to-coding-system charset nil t)))))))
<img[\t\n ]+\\(?:[^\t\n >]+[\t\n ]+\\)*src=\"\\(cid:\\([^\"]+\\)\\)\""
nil t)
(unless cid-dir
- (setq cid-dir (mm-make-temp-file "cid" t))
+ (setq cid-dir (make-temp-file "cid" t))
(add-to-list 'gnus-article-browse-html-temp-list cid-dir))
(setq file nil
content nil)
(replace-match cid-file nil nil nil 1))))
(unless content (setq content (buffer-string))))
(when (or charset header (not file))
- (setq tmp-file (mm-make-temp-file
+ (setq tmp-file (make-temp-file
;; Do we need to care for 8.3 filenames?
"mm-" nil ".html")))
;; Add a meta html tag to specify charset and a header.
;; charset specified in parts might be different.
(if (eq charset 'gnus-decoded)
(setq charset 'utf-8
- eheader (mm-encode-coding-string (buffer-string)
- charset)
+ eheader (encode-coding-string (buffer-string)
+ charset)
title (when title
- (mm-encode-coding-string title charset))
- body (mm-encode-coding-string content charset))
+ (encode-coding-string title charset))
+ body (encode-coding-string content charset))
(setq hcharset (mm-find-mime-charset-region (point-min)
(point-max)))
(cond ((= (length hcharset) 1)
(mm-charset-to-coding-system charset
nil t))
(if (eq coding body)
- (setq eheader (mm-encode-coding-string
+ (setq eheader (encode-coding-string
(buffer-string) coding)
title (when title
- (mm-encode-coding-string
+ (encode-coding-string
title coding))
body content)
(setq charset 'utf-8
- eheader (mm-encode-coding-string
+ eheader (encode-coding-string
(buffer-string) charset)
title (when title
- (mm-encode-coding-string
+ (encode-coding-string
title charset))
- body (mm-encode-coding-string
- (mm-decode-coding-string
+ body (encode-coding-string
+ (decode-coding-string
content body)
charset))))
(setq charset hcharset
- eheader (mm-encode-coding-string
+ eheader (encode-coding-string
(buffer-string) coding)
title (when title
- (mm-encode-coding-string
+ (encode-coding-string
title coding))
body content))
- (setq eheader (mm-string-as-unibyte (buffer-string))
+ (setq eheader (string-as-unibyte (buffer-string))
body content)))
(erase-buffer)
(mm-disable-multibyte)
(charset
(mm-with-unibyte-buffer
(insert (if (eq charset 'gnus-decoded)
- (mm-encode-coding-string content
- (setq charset 'utf-8))
+ (encode-coding-string content
+ (setq charset 'utf-8))
content))
(if (or (mm-add-meta-html-tag handle charset)
(not file))
((numberp arg)
(setq charset (or (cdr (assq arg
gnus-summary-show-article-charset-alist))
- (mm-read-coding-system "Charset: ")))))
+ (read-coding-system "Charset: ")))))
(switch-to-buffer (generate-new-buffer filename))
(if (or coding-system
(and charset
(not (eq coding-system 'ascii))))
(progn
(mm-enable-multibyte)
- (insert (mm-decode-coding-string contents coding-system))
+ (insert (decode-coding-string contents coding-system))
(setq buffer-file-coding-system
(if (boundp 'last-coding-system-used)
(symbol-value 'last-coding-system-used)
(gnus-article-check-buffer)
(let* ((handle (or handle (get-text-property (point) 'gnus-data)))
(contents (and handle (mm-get-part handle)))
- (file (mm-make-temp-file (expand-file-name "mm." mm-tmp-directory)))
+ (file (make-temp-file (expand-file-name "mm." mm-tmp-directory)))
(printer (mailcap-mime-info (mm-handle-media-type handle) "print")))
(when contents
(if printer
(or (cdr (assq
arg
gnus-summary-show-article-charset-alist))
- (mm-read-coding-system "Charset: "))))
+ (read-coding-system "Charset: "))))
(if (mm-handle-undisplayer handle)
(mm-remove-part handle)))
(gnus-mime-set-charset-parameters handle charset)
;; equivalent of string-make-multibyte which amount to decoding
;; with locale-coding-system, causing failure of
;; subsequent decoding.
- (insert (mm-string-to-multibyte
+ (insert (string-to-multibyte
(with-current-buffer gnus-original-article-buffer
(buffer-substring (point-min) (point-max)))))
'article)
(defun gnus-button-handle-info-url (url)
"Fetch an info URL."
- (setq url (mm-subst-char-in-string ?+ ?\ url))
+ (setq url (subst-char-in-string ?+ ?\ url))
(cond
((string-match "^\\([^:/]+\\)?/\\(.*\\)" url)
(gnus-info-find-node
(defun gnus-button-handle-info-url-gnome (url)
"Fetch GNOME style info URL."
- (setq url (mm-subst-char-in-string ?_ ?\ url))
+ (setq url (subst-char-in-string ?_ ?\ url))
(if (string-match "\\([^#]+\\)#?\\(.*\\)" url)
(gnus-info-find-node
(concat "("
(and (boundp 'default-file-name-coding-system)
default-file-name-coding-system))))
(push (cons group decoded) gnus-cache-decoded-group-names)
- (push (cons (mm-decode-coding-string
- (mm-encode-coding-string decoded coding)
+ (push (cons (decode-coding-string
+ (encode-coding-string decoded coding)
coding)
group)
gnus-cache-unified-group-names)
;; Decode values posting-style holds.
(dolist (style (cdr (assq 'posting-style values)))
(when (stringp (cadr style))
- (setcdr style (list (mm-decode-coding-string (cadr style) 'utf-8)))))
+ (setcdr style (list (decode-coding-string (cadr style) 'utf-8)))))
(setq gnus-custom-params
(apply 'widget-create 'group
;; Encode values posting-style holds.
(dolist (style (cdr (assq 'posting-style params)))
(when (stringp (cadr style))
- (setcdr style (list (mm-encode-coding-string (cadr style) 'utf-8)))))
+ (setcdr style (list (encode-coding-string (cadr style) 'utf-8)))))
(if gnus-custom-topic
(gnus-topic-set-parameters gnus-custom-topic params)
(gnus-group-edit-group-done 'params gnus-custom-group params)
(goto-char (point-min))
(setq gnus-group-mark-positions
(list (cons 'process (and (search-forward
- (mm-string-to-multibyte "\200") nil t)
+ (string-to-multibyte "\200") nil t)
(- (point) (point-min) 1))))))))
(defun gnus-mouse-pick-group (e)
(defun gnus-group-name-decode (string charset)
;; Fixme: Don't decode in unibyte mode.
(if (and string charset (featurep 'mule))
- (mm-decode-coding-string string charset)
+ (decode-coding-string string charset)
string))
(defun gnus-group-decoded-name (string)
(member group (mapcar 'symbol-name collection))
(symbol-value (intern-soft group collection)))
(setq group
- (mm-encode-coding-string
+ (encode-coding-string
group (gnus-group-name-charset nil group))))
(replace-regexp-in-string group "\n" "")))
(unless range (setq range 500))
(when (< range 1)
(error "Invalid range: %s" range))
- (let ((tmpfile (mm-make-temp-file
+ (let ((tmpfile (make-temp-file
(format "%s.start-%s.range-%s." group start range)))
(gnus-thread-sort-functions '(gnus-thread-sort-by-number)))
(with-temp-file tmpfile
(setq ids (string-to-number ids)))
(unless (listp ids)
(setq ids (list ids)))
- (let ((tmpfile (mm-make-temp-file "gnus-temp-group-")))
+ (let ((tmpfile (make-temp-file "gnus-temp-group-")))
(let ((coding-system-for-write 'binary)
(coding-system-for-read 'binary))
(with-temp-file tmpfile
(when (stringp method)
(setq method (or (gnus-server-to-method method) method)))
(unless encoded
- (setq name (mm-encode-coding-string
+ (setq name (encode-coding-string
name
(gnus-group-name-charset method name))))
(let* ((meth (gnus-method-simplify
"Rename group to: "
(gnus-group-real-name (gnus-group-decoded-name group)))
method (gnus-info-method (gnus-get-info group)))
- (list group (mm-encode-coding-string
+ (list group (encode-coding-string
new-name
(gnus-group-name-charset
method
(list 'nndoc-address file)
(list 'nndoc-article-type (or type 'guess))))
(coding (gnus-group-name-charset method name)))
- (setcar (cdr method) (mm-encode-coding-string file coding))
+ (setcar (cdr method) (encode-coding-string file coding))
(gnus-group-make-group
- (mm-encode-coding-string (gnus-group-real-name name) coding)
+ (encode-coding-string (gnus-group-real-name name) coding)
method nil nil t)))
(defvar nnweb-type-definition)
(coding (gnus-group-name-charset '(nnrss "") title)))
(when coding
;; Unify non-ASCII text.
- (setq title (mm-decode-coding-string
- (mm-encode-coding-string title coding)
+ (setq title (decode-coding-string
+ (encode-coding-string title coding)
coding)))
(gnus-group-make-group title '(nnrss ""))
(push (list title href desc) nnrss-group-alist)
charset nil t))
(not (eq charset 'ascii)))
(insert (prog1
- (mm-decode-coding-string (buffer-string) charset)
+ (decode-coding-string (buffer-string) charset)
(erase-buffer)
(mm-enable-multibyte))))
(call-process-region (point-min) (point-max)
(with-temp-buffer
(mm-insert-part ,handle)
(when (string= ,charset "utf-8")
- (mm-decode-coding-region (point-min) (point-max) 'utf-8))
-
+ (decode-coding-region (point-min) (point-max) 'utf-8))
,@body))))
(gnus-inews-insert-gcc)
(let ((gcc (mapcar
(lambda (group)
- (mm-encode-coding-string
+ (encode-coding-string
group
(gnus-group-name-charset (gnus-inews-group-method group)
group)))
(insert "Gcc: \"" gnus-newsgroup-name "\"\n"))
((stringp self)
(insert "Gcc: "
- (mm-encode-coding-string
+ (encode-coding-string
(if (string-match " " self)
(concat "\"" self "\"")
self)
tem)
(dolist (style styles)
(when (stringp (cadr style))
- (setcdr style (list (mm-decode-coding-string (cadr style) 'utf-8)))))
+ (setcdr style (list (decode-coding-string (cadr style) 'utf-8)))))
(dolist (style (if styles
(append gnus-posting-styles (list (cons ".*" styles)))
gnus-posting-styles))
;; Copy the article over to some group(s).
(while (setq group (pop groups))
(setq method (gnus-inews-group-method group)
- group (mm-encode-coding-string
+ group (encode-coding-string
group
(gnus-group-name-charset method group)))
(unless (gnus-check-server method)
(when tmp-style
(dolist (style tmp-style)
(when (stringp (cadr style))
- (setcdr style (list (mm-decode-coding-string (cadr style)
- 'utf-8)))))
+ (setcdr style (list (decode-coding-string (cadr style)
+ 'utf-8)))))
(setq styles (append styles (list (cons ".*" tmp-style)))))))
;; Go through all styles and look for matches.
(dolist (style styles)
(while (not (eobp))
(ignore-errors
(push (cons
- (mm-string-as-unibyte
+ (string-as-unibyte
(buffer-substring
(point)
(progn
(while (not (eobp))
(ignore-errors
(push (cons
- (mm-string-as-unibyte
+ (string-as-unibyte
(if (eq (char-after) ?\")
(read cur)
(let ((p (point)) (name ""))
(if (and (fboundp 'detect-coding-string)
(eq (detect-coding-string name t) 'undecided))
name
- (mm-decode-coding-string
+ (decode-coding-string
name
(inline (gnus-group-name-charset method name)))))))
(list 'gnus-group name)
(while lists
(setq killed (car lists))
(while killed
- (gnus-sethash (mm-string-as-unibyte (car killed)) nil hashtb)
+ (gnus-sethash (string-as-unibyte (car killed)) nil hashtb)
(setq killed (cdr killed)))
(setq lists (cdr lists)))))
(dolist (elem gnus-newsrc-alist)
;; Protect against broken .newsrc.el files.
(when (car elem)
- (setcar elem (mm-string-as-unibyte (car elem)))))
+ (setcar elem (string-as-unibyte (car elem)))))
(gnus-make-hashtable-from-newsrc-alist)
(when (file-newer-than-file-p file ding-file)
;; Old format quick file
gnus-default-charset)))
;; Fixme: Don't decode in unibyte mode.
(when (and str charset (featurep 'mule))
- (setq str (mm-decode-coding-string str charset)))
+ (setq str (decode-coding-string str charset)))
(set group str)))
(forward-line 1))))
(gnus-message 5 "Reading descriptions file...done")
(defsubst gnus-remove-odd-characters (string)
"Translate STRING into something that doesn't contain weird characters."
- (mm-subst-char-in-string
+ (subst-char-in-string
?\r ?\-
- (mm-subst-char-in-string ?\n ?\- string t) t))
+ (subst-char-in-string ?\n ?\- string t) t))
;; This function has to be called with point after the article number
;; on the beginning of the line.
(gnus-kill-buffer (current-buffer)))
(error
"Couldn't activate group %s: %s"
- (mm-decode-coding-string group charset)
- (mm-decode-coding-string (gnus-status-message group) charset))))
+ (decode-coding-string group charset)
+ (decode-coding-string (gnus-status-message group) charset))))
(unless (gnus-request-group group t nil (gnus-get-info group))
(when (derived-mode-p 'gnus-summary-mode)
(gnus-kill-buffer (current-buffer)))
(error "Couldn't request group %s: %s"
- (mm-decode-coding-string group charset)
- (mm-decode-coding-string (gnus-status-message group) charset)))
+ (decode-coding-string group charset)
+ (decode-coding-string (gnus-status-message group) charset)))
(when (and gnus-agent
(gnus-active group))
(gnus-summary-show-article t)
(let ((gnus-newsgroup-charset
(or (cdr (assq arg gnus-summary-show-article-charset-alist))
- (mm-read-coding-system
+ (read-coding-system
"View as charset: " ;; actually it is coding system.
(with-current-buffer gnus-article-buffer
(mm-detect-coding-region (point) (point-max))))))
encoded to-newsgroup
to-method (gnus-server-to-method (gnus-group-method to-newsgroup)))
(set (intern (format "gnus-current-%s-group" action))
- (mm-decode-coding-string
+ (decode-coding-string
to-newsgroup
(gnus-group-name-charset to-method to-newsgroup))))
(unless to-method
(setq to-newsgroup
(or encoded
(and to-newsgroup
- (mm-encode-coding-string
+ (encode-coding-string
to-newsgroup
(gnus-group-name-charset to-method to-newsgroup)))))
;; Check the method we are to move this article to...
(goto-char (+ forward (point)))
;; Replace the old mark with the new mark.
(let ((to-insert
- (mm-subst-char-in-string
+ (subst-char-in-string
(char-after) mark
(buffer-substring (point) (1+ (point))))))
(delete-region (point) (1+ (point)))
(setq to-newsgroup default))
(unless to-newsgroup
(error "No group name entered"))
- (setq encoded (mm-encode-coding-string
+ (setq encoded (encode-coding-string
to-newsgroup
(gnus-group-name-charset to-method to-newsgroup)))
(or (gnus-active encoded)
gnus-uu-default-dir))))
(gnus-uu-initialize)
(setq gnus-uu-binhex-article-name
- (mm-make-temp-file (expand-file-name "binhex" gnus-uu-work-dir)))
+ (make-temp-file (expand-file-name "binhex" gnus-uu-work-dir)))
(gnus-uu-decode-with-method 'gnus-uu-binhex-article n dir))
(defun gnus-uu-decode-yenc (n dir)
gnus-uu-default-dir gnus-uu-default-dir)))
(gnus-uu-initialize)
(setq gnus-uu-binhex-article-name
- (mm-make-temp-file (expand-file-name "binhex" gnus-uu-work-dir)))
+ (make-temp-file (expand-file-name "binhex" gnus-uu-work-dir)))
(let ((gnus-view-pseudos (or gnus-view-pseudos 'automatic)))
(gnus-uu-decode-binhex n file)))
(interactive "P")
(gnus-uu-initialize)
(let ((gnus-uu-save-in-digest t)
- (file (mm-make-temp-file (nnheader-concat gnus-uu-work-dir "forward")))
+ (file (make-temp-file (nnheader-concat gnus-uu-work-dir "forward")))
(message-forward-as-mime message-forward-as-mime)
(mail-parse-charset gnus-newsgroup-charset)
(mail-parse-ignored-charsets gnus-newsgroup-ignored-charsets)
gnus-uu-tmp-dir)))
(setq gnus-uu-work-dir
- (mm-make-temp-file (concat gnus-uu-tmp-dir "gnus") 'dir))
+ (make-temp-file (concat gnus-uu-tmp-dir "gnus") 'dir))
(gnus-set-file-modes gnus-uu-work-dir 448)
(setq gnus-uu-work-dir (file-name-as-directory gnus-uu-work-dir))
(push (cons gnus-newsgroup-name gnus-uu-work-dir)
4.99
(+ 5 (* 0.02
(abs
- (- (mm-char-int (aref (downcase alpha) 0))
- (mm-char-int ?t))))
+ (- (aref (downcase alpha) 0) ?t)))
-0.01))
minor least)
(format "%d.%02d%02d" major minor least))))))
(let ((i 0)
b e c out range)
(while (< i (length token))
- (setq c (mm-char-int (aref token i)))
+ (setq c (aref token i))
(incf i)
(cond
- ((eq c (mm-char-int ?-))
+ ((eq c ?-)
(if b
(setq range t)
(push c out)))
(eval-when-compile (require 'cl))
(autoload 'mail-header-parse-content-type "mail-parse")
-;; `mm-delete-duplicates' is an alias for `delete-dups' in Emacs 22.
-(defalias 'mailcap-delete-duplicates
- (if (fboundp 'delete-dups)
- 'delete-dups
- (autoload 'mm-delete-duplicates "mm-util")
- 'mm-delete-duplicates))
-
(defgroup mailcap nil
"Definition of viewers for MIME types."
:version "21.1"
;; No double encoded subject? => bogus charset.
(unless cs-coding
(setq cs-coding
- (mm-read-coding-system
+ (read-coding-system
(format-message "\
Decoded Subject \"%s\"
contains an encoded word. The charset `%s' is unknown or invalid.
(point) 'no-illegible-text)
(point-max))))
(setq char (char-after)))
- (when (or (< (mm-char-int char) 128)
+ (when (or (< char 128)
(and (mm-multibyte-p)
(memq (char-charset char)
'(eight-bit-control eight-bit-graphic
(skip-chars-forward mm-7bit-chars)
(while (not (eobp))
(when (let ((char (char-after)))
- (or (< (mm-char-int char) 128)
+ (or (< char 128)
(and (mm-multibyte-p)
;; FIXME: Wrong for Emacs 23 (unicode) and for
;; things like undecodable utf-8 (in Emacs 21?).
;; Check for control characters.
(message-check 'control-chars
(if (re-search-forward
- (mm-string-to-multibyte "[\000-\007\013\015-\032\034-\037\200-\237]")
+ (string-to-multibyte "[\000-\007\013\015-\032\034-\037\200-\237]")
nil t)
(y-or-n-p
"The article contains control characters. Really post? ")
ace)
(when field
(dolist (rhs
- (mm-delete-duplicates
+ (delete-dups
(mapcar (lambda (rhs) (or (cadr (split-string rhs "@")) ""))
(mapcar 'downcase
(mapcar
(let ((b (point))
(contents (with-current-buffer forward-buffer (buffer-string)))
e)
- (unless (mm-multibyte-string-p contents)
+ (unless (multibyte-string-p contents)
(error "Attempt to insert unibyte string from the buffer \"%s\"\
to the multibyte buffer \"%s\""
(if (bufferp forward-buffer)
(let ((b (point)) e)
(if (not message-forward-decoded-p)
(let ((contents (with-current-buffer forward-buffer (buffer-string))))
- (unless (mm-multibyte-string-p contents)
+ (unless (multibyte-string-p contents)
(error "Attempt to insert unibyte string from the buffer \"%s\"\
to the multibyte buffer \"%s\""
(if (bufferp forward-buffer)
(defun mm-dissect-archive (handle)
(let ((decoder (cddr (assoc (car (mm-handle-type handle))
mm-archive-decoders)))
- (dir (mm-make-temp-file
+ (dir (make-temp-file
(expand-file-name "emm." mm-tmp-directory) 'dir)))
(set-file-modes dir #o700)
(unwind-protect
(message-options-get 'mm-body-charset-encoding-alist)
(message-options-set
'mm-body-charset-encoding-alist
- (mm-read-coding-system "Charset used in the article: ")))
+ (read-coding-system "Charset used in the article: ")))
;; The logic in `mml-generate-mime-1' confirms that it's OK
;; to return nil here.
nil)))
(save-excursion
(if charset
(progn
- (mm-encode-coding-region (point-min) (point-max)
- (mm-charset-to-coding-system charset))
+ (encode-coding-region (point-min) (point-max)
+ (mm-charset-to-coding-system charset))
charset)
(goto-char (point-min))
(let ((charsets (mm-find-mime-charset-region (point-min) (point-max)
(t
(prog1
(setq charset (car charsets))
- (mm-encode-coding-region (point-min) (point-max)
- (mm-charset-to-coding-system charset))))
+ (encode-coding-region (point-min) (point-max)
+ (mm-charset-to-coding-system charset))))
))))))
(defun mm-long-lines-p (length)
(mm-multibyte-p)
(or (not (eq coding-system 'ascii))
(setq coding-system mail-parse-charset)))
- (mm-decode-coding-region (point-min) (point-max)
- coding-system))
+ (decode-coding-region (point-min) (point-max) coding-system))
(setq buffer-file-coding-system
(if (boundp 'last-coding-system-used)
(symbol-value 'last-coding-system-used)
(mm-multibyte-p)
(or (not (eq coding-system 'ascii))
(setq coding-system mail-parse-charset)))
- (mm-decode-coding-string string coding-system))))
+ (decode-coding-string string coding-system))))
string))
(provide 'mm-bodies)
(with-current-buffer
(generate-new-buffer " *mm*")
;; Preserve the data's unibyteness (for url-insert-file-contents).
- (mm-set-buffer-multibyte mb)
+ (set-buffer-multibyte mb)
(insert-buffer-substring obuf beg)
(current-buffer))))
(select-window win)))
(switch-to-buffer (generate-new-buffer " *mm*")))
(buffer-disable-undo)
- (mm-set-buffer-file-coding-system mm-binary-coding-system)
+ (set-buffer-file-coding-system mm-binary-coding-system)
(insert-buffer-substring cur)
(goto-char (point-min))
(when method
(with-current-buffer (mm-handle-buffer handle)
(buffer-string)))
((mm-multibyte-p)
- (mm-string-to-multibyte (mm-get-part handle no-cache)))
+ (string-to-multibyte (mm-get-part handle no-cache)))
(t
(mm-get-part handle no-cache)))))
(save-restriction
(mm-charset-to-coding-system charset
nil t))
(not (eq charset 'ascii)))
- (mm-decode-coding-string (buffer-string) charset)
+ (decode-coding-string (buffer-string) charset)
(mm-string-as-multibyte (buffer-string)))
(erase-buffer)
(mm-enable-multibyte)))
(string-to-number (substring entity 1)))))
(setq c (or (cdr (assq c mm-extra-numeric-entities))
(mm-ucs-to-char c)))
- (if (mm-char-or-char-int-p c) c ?#))
+ (if (char-valid-p c) c ?#))
(or (cdr (assq (intern entity)
mm-url-html-entities))
?#))))
((= char ? ) "+")
((memq char mm-url-unreserved-chars) (char-to-string char))
(t (upcase (format "%%%02x" char)))))
- (mm-encode-coding-string chunk
- (if (fboundp 'find-coding-systems-string)
- (car (find-coding-systems-string chunk))
- buffer-file-coding-system))
+ (encode-coding-string chunk
+ (if (fboundp 'find-coding-systems-string)
+ (car (find-coding-systems-string chunk))
+ buffer-file-coding-system))
"")))
(defun mm-url-encode-www-form-urlencoded (pairs)
(if (fboundp (car elem))
(defalias nfunc (car elem))
(defalias nfunc (cdr elem)))))
- `(;; `coding-system-list' is not available in XEmacs 21.4 built
- ;; without the `file-coding' feature.
- (coding-system-list . ignore)
- ;; `char-int' is an XEmacs function, not available in Emacs.
- (char-int . identity)
- ;; `coding-system-equal' is an Emacs function, not available in XEmacs.
- (coding-system-equal . equal)
- ;; `set-buffer-file-coding-system' is not available in XEmacs 21.4
- ;; built without the `file-coding' feature.
- (set-buffer-file-coding-system . ignore)
- ;; `read-charset' is an Emacs function, not available in XEmacs.
- (read-charset
- . ,(lambda (prompt)
- "Return a charset."
- (intern
- (gnus-completing-read
- prompt
- (mapcar (lambda (e) (symbol-name (car e)))
- mm-mime-mule-charset-alist)
- t))))
- ;; `subst-char-in-string' is not available in XEmacs 21.4.
- (subst-char-in-string
- . ,(lambda (from to string &optional inplace)
- ;; stolen (and renamed) from nnheader.el
- "Replace characters in STRING from FROM to TO.
- Unless optional argument INPLACE is non-nil, return a new string."
- (let ((string (if inplace string (copy-sequence string)))
- (len (length string))
- (idx 0))
- ;; Replace all occurrences of FROM with TO.
- (while (< idx len)
- (when (= (aref string idx) from)
- (aset string idx to))
- (setq idx (1+ idx)))
- string)))
- ;; `replace-in-string' is an XEmacs function, not available in Emacs.
- (replace-in-string
- . ,(lambda (string regexp rep &optional literal)
- "See `replace-regexp-in-string', only the order of args differs."
- (replace-regexp-in-string regexp rep string nil literal)))
- ;; `string-as-unibyte' is an Emacs function, not available in XEmacs.
- (string-as-unibyte . identity)
- ;; `string-make-unibyte' is an Emacs function, not available in XEmacs.
- (string-make-unibyte . identity)
+ `(
;; string-as-multibyte often doesn't really do what you think it does.
;; Example:
;; (aref (string-as-multibyte "\201") 0) -> 129 (aka ?\201)
;; (string-to-multibyte s) ~= (decode-coding-string s 'binary)
;; (string-make-multibyte s) ~= (decode-coding-string s locale-coding-system)
;; `string-as-multibyte' is an Emacs function, not available in XEmacs.
- (string-as-multibyte . identity)
- ;; `multibyte-string-p' is an Emacs function, not available in XEmacs.
- (multibyte-string-p . ignore)
- ;; `insert-byte' is available only in Emacs 23.1 or greater.
- (insert-byte . insert-char)
- ;; `multibyte-char-to-unibyte' is an Emacs function, not available
- ;; in XEmacs.
- (multibyte-char-to-unibyte . identity)
- ;; `set-buffer-multibyte' is an Emacs function, not available in XEmacs.
- (set-buffer-multibyte . ignore)
- ;; `substring-no-properties' is available only in Emacs 22.1 or greater.
- (substring-no-properties
- . ,(lambda (string &optional from to)
- "Return a substring of STRING, without text properties.
-It starts at index FROM and ending before TO.
-TO may be nil or omitted; then the substring runs to the end of STRING.
-If FROM is nil or omitted, the substring starts at the beginning of STRING.
-If FROM or TO is negative, it counts from the end.
-
-With one argument, just copy STRING without its properties."
- (setq string (substring string (or from 0) to))
- (set-text-properties 0 (length string) nil string)
- string))
- ;; `line-number-at-pos' is available only in Emacs 22.1 or greater
- ;; and XEmacs 21.5.
- (line-number-at-pos
- . ,(lambda (&optional pos)
- "Return (narrowed) buffer line number at position POS.
-If POS is nil, use current buffer location.
-Counting starts at (point-min), so the value refers
-to the contents of the accessible portion of the buffer."
- (let ((opoint (or pos (point))) start)
- (save-excursion
- (goto-char (point-min))
- (setq start (point))
- (goto-char opoint)
- (forward-line 0)
- (1+ (count-lines start (point))))))))))
-
-;; `special-display-p' is an Emacs function, not available in XEmacs.
-(defalias 'mm-special-display-p
- (if (featurep 'emacs)
- 'special-display-p
- (lambda (buffer-name)
- "Returns non-nil if a buffer named BUFFER-NAME gets a special frame."
- (and special-display-function
- (or (and (member buffer-name special-display-buffer-names) t)
- (cdr (assoc buffer-name special-display-buffer-names))
- (catch 'return
- (dolist (elem special-display-regexps)
- (and (stringp elem)
- (string-match elem buffer-name)
- (throw 'return t))
- (and (consp elem)
- (stringp (car elem))
- (string-match (car elem) buffer-name)
- (throw 'return (cdr elem))))))))))
-
-;; `decode-coding-string', `encode-coding-string', `decode-coding-region'
-;; and `encode-coding-region' are available in Emacs and XEmacs built with
-;; the `file-coding' feature, but the XEmacs versions treat nil, that is
-;; given as the `coding-system' argument, as the `binary' coding system.
-(eval-and-compile
- (if (featurep 'xemacs)
- (if (featurep 'file-coding)
- (progn
- (defun mm-decode-coding-string (str coding-system)
- (if coding-system
- (decode-coding-string str coding-system)
- str))
- (defun mm-encode-coding-string (str coding-system)
- (if coding-system
- (encode-coding-string str coding-system)
- str))
- (defun mm-decode-coding-region (start end coding-system)
- (if coding-system
- (decode-coding-region start end coding-system)))
- (defun mm-encode-coding-region (start end coding-system)
- (if coding-system
- (encode-coding-region start end coding-system))))
- (defun mm-decode-coding-string (str coding-system) str)
- (defun mm-encode-coding-string (str coding-system) str)
- (defalias 'mm-decode-coding-region 'ignore)
- (defalias 'mm-encode-coding-region 'ignore))
- (defalias 'mm-decode-coding-string 'decode-coding-string)
- (defalias 'mm-encode-coding-string 'encode-coding-string)
- (defalias 'mm-decode-coding-region 'decode-coding-region)
- (defalias 'mm-encode-coding-region 'encode-coding-region)))
-
-;; `string-to-multibyte' is available only in Emacs.
-(defalias 'mm-string-to-multibyte (if (featurep 'xemacs)
- 'identity
- 'string-to-multibyte))
-
-;; `char-or-char-int-p' is an XEmacs function, not available in Emacs.
-(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))))
+ (string-as-multibyte . identity))))
-;; `ucs-to-char' is a function that Mule-UCS provides.
-(eval-and-compile
- (if (featurep 'xemacs)
- (cond ((and (fboundp 'unicode-to-char) ;; XEmacs 21.5.
- (subrp (symbol-function 'unicode-to-char)))
- (if (featurep 'mule)
- (defalias 'mm-ucs-to-char 'unicode-to-char)
- (defun mm-ucs-to-char (codepoint)
- "Convert Unicode codepoint to character."
- (or (unicode-to-char codepoint) ?#))))
- ((featurep 'mule)
- (defun mm-ucs-to-char (codepoint)
- "Convert Unicode codepoint to character."
- (if (fboundp 'ucs-to-char) ;; Mule-UCS is loaded.
- (progn
- (defalias 'mm-ucs-to-char
- (lambda (codepoint)
- "Convert Unicode codepoint to character."
- (condition-case nil
- (or (ucs-to-char codepoint) ?#)
- (error ?#))))
- (mm-ucs-to-char codepoint))
- (condition-case nil
- (or (int-to-char codepoint) ?#)
- (error ?#)))))
- (t
- (defun mm-ucs-to-char (codepoint)
- "Convert Unicode codepoint to character."
- (condition-case nil
- (or (int-to-char codepoint) ?#)
- (error ?#)))))
- (if (let ((char (make-char 'japanese-jisx0208 36 34)))
- (eq char (decode-char 'ucs char)))
- ;; Emacs 23.
- (defalias 'mm-ucs-to-char 'identity)
- (defun mm-ucs-to-char (codepoint)
- "Convert Unicode codepoint to character."
- (or (decode-char 'ucs codepoint) ?#)))))
-
-;; Fixme: This seems always to be used to read a MIME charset, so it
-;; should be re-named and fixed (in Emacs) to offer completion only on
-;; proper charset names (base coding systems which have a
-;; mime-charset defined). XEmacs doesn't believe in mime-charset;
-;; test with
-;; `(or (coding-system-get 'iso-8859-1 'mime-charset)
-;; (coding-system-get 'iso-8859-1 :mime-charset))'
-;; Actually, there should be an `mm-coding-system-mime-charset'.
-(eval-and-compile
- (defalias 'mm-read-coding-system
- (if (featurep 'emacs) 'read-coding-system
- (cond
- ((fboundp 'read-coding-system)
- (if (and (featurep 'xemacs)
- (<= (string-to-number emacs-version) 21.1))
- (lambda (prompt &optional default-coding-system)
- (read-coding-system prompt))
- 'read-coding-system))
- (t (lambda (prompt &optional default-coding-system)
- "Prompt the user for a coding system."
- (gnus-completing-read
- prompt (mapcar (lambda (s) (symbol-name (car s)))
- mm-mime-mule-charset-alist))))))))
+(defun mm-ucs-to-char (codepoint)
+ "Convert Unicode codepoint to character."
+ (or (decode-char 'ucs codepoint) ?#))
(defvar mm-coding-system-list nil)
(defun mm-get-coding-system-list ()
"Get the coding system list."
(or mm-coding-system-list
- (setq mm-coding-system-list (mm-coding-system-list))))
+ (setq mm-coding-system-list (coding-system-list))))
(defun mm-coding-system-p (cs)
- "Return non-nil if CS is a symbol naming a coding system.
-In XEmacs, also return non-nil if CS is a coding system object.
-If CS is available, return CS itself in Emacs, and return a coding
-system object in XEmacs."
- (if (fboundp 'find-coding-system)
- (and cs (find-coding-system cs))
- (if (fboundp 'coding-system-p)
- (when (coding-system-p cs)
- cs)
- ;; no-MULE XEmacs:
- (car (memq cs (mm-get-coding-system-list))))))
+ "Return CS if CS is a coding system."
+ (and (coding-system-p cs)
+ cs))
(defvar mm-charset-synonym-alist
`(
;; Note: this has to be defined before `mm-charset-to-coding-system'.
(defcustom mm-charset-eval-alist
- (if (featurep 'xemacs)
- nil ;; I don't know what would be useful for XEmacs.
- '(;; Emacs 22 provides autoloads for 1250-1258
- ;; (i.e. `mm-codepage-setup' does nothing).
- (windows-1250 . (mm-codepage-setup 1250 t))
- (windows-1251 . (mm-codepage-setup 1251 t))
- (windows-1253 . (mm-codepage-setup 1253 t))
- (windows-1257 . (mm-codepage-setup 1257 t))))
+ '(
+ ;; Emacs 22 provides autoloads for 1250-1258
+ ;; (i.e. `mm-codepage-setup' does nothing).
+ (windows-1250 . (mm-codepage-setup 1250 t))
+ (windows-1251 . (mm-codepage-setup 1251 t))
+ (windows-1253 . (mm-codepage-setup 1253 t))
+ (windows-1257 . (mm-codepage-setup 1257 t)))
"An alist of (CHARSET . FORM) pairs.
If an article is encoded in an unknown CHARSET, FORM is
evaluated. This allows the loading of additional libraries
(coding-system-get 'mule-utf-8 'safe-charsets))))))
"Alist of MIME-charset/MULE-charsets.")
-(defun mm-enrich-utf-8-by-mule-ucs ()
- "Make the `utf-8' MIME charset usable by the Mule-UCS package.
-This function will run when the `un-define' module is loaded under
-XEmacs, and fill the `utf-8' entry in `mm-mime-mule-charset-alist'
-with Mule charsets. It is completely useless for Emacs."
- (when (boundp 'unicode-basic-translation-charset-order-list)
- (condition-case nil
- (let ((val (delq
- 'ascii
- (copy-sequence
- (symbol-value
- 'unicode-basic-translation-charset-order-list))))
- (elem (assq 'utf-8 mm-mime-mule-charset-alist)))
- (if elem
- (setcdr elem val)
- (setq mm-mime-mule-charset-alist
- (nconc mm-mime-mule-charset-alist
- (list (cons 'utf-8 val))))))
- (error))))
-
;; Correct by construction, but should be unnecessary for Emacs:
-(if (featurep 'xemacs)
- (eval-after-load "un-define" '(mm-enrich-utf-8-by-mule-ucs))
- (when (and (fboundp 'coding-system-list)
- (fboundp 'sort-coding-systems))
- (let ((css (sort-coding-systems (coding-system-list 'base-only)))
- cs mime mule alist)
- (while css
- (setq cs (pop css)
- mime (or (coding-system-get cs :mime-charset); Emacs 23 (unicode)
- (coding-system-get cs 'mime-charset)))
- (when (and mime
- (not (eq t (setq mule
- (coding-system-get cs 'safe-charsets))))
- (not (assq mime alist)))
- (push (cons mime (delq 'ascii mule)) alist)))
- (setq mm-mime-mule-charset-alist (nreverse alist)))))
+(when (and (fboundp 'coding-system-list)
+ (fboundp 'sort-coding-systems))
+ (let ((css (sort-coding-systems (coding-system-list 'base-only)))
+ cs mime mule alist)
+ (while css
+ (setq cs (pop css)
+ mime (or (coding-system-get cs :mime-charset) ; Emacs 23 (unicode)
+ (coding-system-get cs 'mime-charset)))
+ (when (and mime
+ (not (eq t (setq mule
+ (coding-system-get cs 'safe-charsets))))
+ (not (assq mime alist)))
+ (push (cons mime (delq 'ascii mule)) alist)))
+ (setq mm-mime-mule-charset-alist (nreverse alist))))
(defvar mm-hack-charsets '(iso-8859-15 iso-2022-jp-2)
"A list of special charsets.
(pop alist))
out)))
-(eval-and-compile
- (if (featurep 'xemacs)
- (defalias 'mm-enable-multibyte 'ignore)
- (defun mm-enable-multibyte ()
- "Set the multibyte flag of the current buffer.
+(defun mm-enable-multibyte ()
+ "Set the multibyte flag of the current buffer.
Only do this if the default value of `enable-multibyte-characters' is
-non-nil. This is a no-op in XEmacs."
- (set-buffer-multibyte 'to)))
+non-nil."
+ (set-buffer-multibyte 'to))
- (if (featurep 'xemacs)
- (defalias 'mm-disable-multibyte 'ignore)
- (defun mm-disable-multibyte ()
- "Unset the multibyte flag of in the current buffer.
-This is a no-op in XEmacs."
- (set-buffer-multibyte nil))))
+(defun mm-disable-multibyte ()
+ "Unset the multibyte flag of in the current buffer."
+ (set-buffer-multibyte nil))
(defun mm-preferred-coding-system (charset)
;; A typo in some Emacs versions.
If POS is out of range, the value is nil.
If the charset is `composition', return the actual one."
(let ((char (char-after pos)) charset)
- (if (< (mm-char-int char) 128)
+ (if (< char 128)
(setq charset 'ascii)
;; charset-after is fake in some Emacsen.
(setq charset (and (fboundp 'char-charset) (char-charset char)))
;; This is for XEmacs.
(mm-mule-charset-to-mime-charset charset)))
-;; `delete-dups' is not available in XEmacs 21.4.
-(if (fboundp 'delete-dups)
- (defalias 'mm-delete-duplicates 'delete-dups)
- (defun mm-delete-duplicates (list)
- "Destructively remove `equal' duplicates from LIST.
-Store the result in LIST and return it. LIST must be a proper list.
-Of several `equal' occurrences of an element in LIST, the first
-one is kept.
-
-This is a compatibility function for Emacsen without `delete-dups'."
- ;; Code from `subr.el' in Emacs 22:
- (let ((tail list))
- (while tail
- (setcdr tail (delete (car tail) (cdr tail)))
- (setq tail (cdr tail))))
- list))
-
;; Fixme: This is used in places when it should be testing the
-;; default multibyteness. See mm-default-multibyte-p.
-(eval-and-compile
- (if (and (not (featurep 'xemacs))
- (boundp 'enable-multibyte-characters))
- (defun mm-multibyte-p ()
- "Non-nil if multibyte is enabled in the current buffer."
- enable-multibyte-characters)
- (defun mm-multibyte-p () (featurep 'mule))))
-
-(defun mm-default-multibyte-p ()
- "Return non-nil if the session is multibyte.
-This affects whether coding conversion should be attempted generally."
- (if (featurep 'mule)
- (if (boundp 'enable-multibyte-characters)
- (default-value 'enable-multibyte-characters)
- t)))
+;; default multibyteness.
+(defun mm-multibyte-p ()
+ "Non-nil if multibyte is enabled in the current buffer."
+ enable-multibyte-characters)
(defun mm-iso-8859-x-to-15-region (&optional b e)
(if (fboundp 'char-charset)
(length (memq (coding-system-base b) priorities)))
t))))
-(declare-function latin-unity-massage-name "ext:latin-unity")
-(declare-function latin-unity-maybe-remap "ext:latin-unity")
-(declare-function latin-unity-representations-feasible-region "ext:latin-unity")
-(declare-function latin-unity-representations-present-region "ext:latin-unity")
-
-(defvar latin-unity-coding-systems)
-(defvar latin-unity-ucs-list)
-
-(defun mm-xemacs-find-mime-charset-1 (begin end)
- "Determine which MIME charset to use to send region as message.
-This uses the XEmacs-specific latin-unity package to better handle the
-case where identical characters from diverse ISO-8859-? character sets
-can be encoded using a single one of the corresponding coding systems.
-
-It treats `mm-coding-system-priorities' as the list of preferred
-coding systems; a useful example setting for this list in Western
-Europe would be (iso-8859-1 iso-8859-15 utf-8), which would default
-to the very standard Latin 1 coding system, and only move to coding
-systems that are less supported as is necessary to encode the
-characters that exist in the buffer.
-
-Latin Unity doesn't know about those non-ASCII Roman characters that
-are available in various East Asian character sets. As such, its
-behavior if you have a JIS 0212 LATIN SMALL LETTER A WITH ACUTE in a
-buffer and it can otherwise be encoded as Latin 1, won't be ideal.
-But this is very much a corner case, so don't worry about it."
- (let ((systems mm-coding-system-priorities) csets psets curset)
-
- ;; Load the Latin Unity library, if available.
- (when (and (not (featurep 'latin-unity)) (locate-library "latin-unity"))
- (require 'latin-unity))
-
- ;; Now, can we use it?
- (if (featurep 'latin-unity)
- (progn
- (setq csets (latin-unity-representations-feasible-region begin end)
- psets (latin-unity-representations-present-region begin end))
-
- (catch 'done
-
- ;; Pass back the first coding system in the preferred list
- ;; that can encode the whole region.
- (dolist (curset systems)
- (setq curset (latin-unity-massage-name 'buffer-default curset))
-
- ;; If the coding system is a universal coding system, then
- ;; it can certainly encode all the characters in the region.
- (if (memq curset latin-unity-ucs-list)
- (throw 'done (list curset)))
-
- ;; If a coding system isn't universal, and isn't in
- ;; the list that latin unity knows about, we can't
- ;; decide whether to use it here. Leave that until later
- ;; in `mm-find-mime-charset-region' function, whence we
- ;; have been called.
- (unless (memq curset latin-unity-coding-systems)
- (throw 'done nil))
-
- ;; Right, we know about this coding system, and it may
- ;; conceivably be able to encode all the characters in
- ;; the region.
- (if (latin-unity-maybe-remap begin end curset csets psets t)
- (throw 'done (list curset))))
-
- ;; Can't encode using anything from the
- ;; `mm-coding-system-priorities' list.
- ;; Leave `mm-find-mime-charset' to do most of the work.
- nil))
-
- ;; Right, latin unity isn't available; let `mm-find-charset-region'
- ;; take its default action, which equally applies to GNU Emacs.
- nil)))
-
-(defmacro mm-xemacs-find-mime-charset (begin end)
- (when (featurep 'xemacs)
- `(and (featurep 'mule) (mm-xemacs-find-mime-charset-1 ,begin ,end))))
-
-(declare-function mm-delete-duplicates "mm-util" (list))
-
(defun mm-find-mime-charset-region (b e &optional hack-charsets)
"Return the MIME charsets needed to encode the region between B and E.
nil means ASCII, a single-element list represents an appropriate MIME
(setq systems nil
charsets (list cs))))))
charsets))
- ;; If we're XEmacs, and some coding system is appropriate,
- ;; mm-xemacs-find-mime-charset will return an appropriate list.
- ;; Otherwise, we'll get nil, and the next setq will get invoked.
- (setq charsets (mm-xemacs-find-mime-charset b e))
-
- ;; Fixme: won't work for unibyte Emacs 23:
-
;; We're not multibyte, or a single coding system won't cover it.
(setq charsets
- (mm-delete-duplicates
+ (delete-dups
(mapcar 'mm-mime-charset
(delq 'ascii
(mm-find-charset-region b e))))))
(if (and (memq 'iso-2022-jp-2 charsets)
(memq 'iso-2022-jp-2 hack-charsets))
(setq charsets (delq 'iso-2022-jp charsets)))
- ;; Attempt to reduce the number of charsets if utf-8 is available.
- (if (and (featurep 'xemacs)
- (> (length charsets) 1)
- (mm-coding-system-p 'utf-8))
- (let ((mm-coding-system-priorities
- (cons 'utf-8 mm-coding-system-priorities)))
- (setq charsets
- (mm-delete-duplicates
- (mapcar 'mm-mime-charset
- (delq 'ascii
- (mm-find-charset-region b e)))))))
charsets))
(defmacro mm-with-unibyte-buffer (&rest forms)
(defmacro mm-with-unibyte-current-buffer (&rest forms)
"Evaluate FORMS with current buffer temporarily made unibyte.
-Equivalent to `progn' in XEmacs.
Note: We recommend not using this macro any more; there should be
better ways to do a similar thing. The previous version of this macro
evaluating FORMS but it is no longer done. So, some programs assuming
it if any may malfunction."
(declare (obsolete nil "25.1") (indent 0) (debug t))
- (if (featurep 'xemacs)
- `(progn ,@forms)
- (let ((multibyte (make-symbol "multibyte")))
- `(let ((,multibyte enable-multibyte-characters))
+ (let ((multibyte (make-symbol "multibyte")))
+ `(let ((,multibyte enable-multibyte-characters))
+ (when ,multibyte
+ (set-buffer-multibyte nil))
+ (prog1
+ (progn ,@forms)
(when ,multibyte
- (set-buffer-multibyte nil))
- (prog1
- (progn ,@forms)
- (when ,multibyte
- (set-buffer-multibyte t)))))))
+ (set-buffer-multibyte t))))))
(defun mm-find-charset-region (b e)
"Return a list of Emacs charsets in the region B to E."
css)
(setq css (delq cs css)))))
(t
- ;; We are in a unibyte buffer or XEmacs non-mule, so we futz around a bit.
+ ;; We are in a unibyte buffer, so we futz around a bit.
(save-excursion
(save-restriction
(narrow-to-region b e)
inhibit-file-name-handlers)))
(write-region start end filename append visit lockname)))
-;; It is not a MIME function, but some MIME functions use it.
-(if (and (fboundp 'make-temp-file)
- (ignore-errors
- (let ((def (if (fboundp 'compiled-function-arglist) ;; XEmacs
- (eval (list 'compiled-function-arglist
- (symbol-function 'make-temp-file)))
- (require 'help-fns)
- (help-function-arglist 'make-temp-file t))))
- (and (>= (length def) 4)
- (eq (nth 3 def) 'suffix)))))
- (defalias 'mm-make-temp-file 'make-temp-file)
- ;; Stolen (and modified for XEmacs) from Emacs 22.
- (defun mm-make-temp-file (prefix &optional dir-flag suffix)
- "Create a temporary file.
-The returned file name (created by appending some random characters at the end
-of PREFIX, and expanding against `temporary-file-directory' if necessary),
-is guaranteed to point to a newly created empty file.
-You can then use `write-region' to write new data into the file.
-
-If DIR-FLAG is non-nil, create a new empty directory instead of a file.
-
-If SUFFIX is non-nil, add that at the end of the file name."
- (let ((umask (default-file-modes))
- file)
- (unwind-protect
- (progn
- ;; Create temp files with strict access rights. It's easy to
- ;; loosen them later, whereas it's impossible to close the
- ;; time-window of loose permissions otherwise.
- (set-default-file-modes 448)
- (while (condition-case err
- (progn
- (setq file
- (make-temp-name
- (expand-file-name
- prefix
- (if (fboundp 'temp-directory)
- ;; XEmacs
- (temp-directory)
- temporary-file-directory))))
- (if suffix
- (setq file (concat file suffix)))
- (if dir-flag
- (make-directory file)
- (write-region "" nil file nil 'silent nil 'excl))
- nil)
- (file-already-exists t)
- ;; The XEmacs version of `make-directory' issues
- ;; `file-error'.
- (file-error (or (and (featurep 'xemacs)
- (file-exists-p file))
- (signal (car err) (cdr err)))))
- ;; the file was somehow created by someone else between
- ;; `make-temp-name' and `write-region', let's try again.
- nil)
- file)
- ;; Reset the umask.
- (set-default-file-modes umask)))))
+(defalias 'mm-make-temp-file 'make-temp-file)
+(define-obsolete-function-alias 'mm-make-temp-file 'make-temp-file "25.2")
(defvar mm-image-load-path-cache nil)
(let ((cs (mm-detect-coding-region start end)))
cs)))
-(eval-when-compile
- (unless (fboundp 'coding-system-to-mime-charset)
- (defalias 'coding-system-to-mime-charset 'ignore)))
-
(defun mm-coding-system-to-mime-charset (coding-system)
- "Return the MIME charset corresponding to CODING-SYSTEM.
-To make this function work with XEmacs, the APEL package is required."
+ "Return the MIME charset corresponding to CODING-SYSTEM."
(when coding-system
- (or (and (fboundp 'coding-system-get)
- (or (coding-system-get coding-system :mime-charset)
- (coding-system-get coding-system 'mime-charset)))
- (and (featurep 'xemacs)
- (or (and (fboundp 'coding-system-to-mime-charset)
- (not (eq (symbol-function 'coding-system-to-mime-charset)
- 'ignore)))
- (and (condition-case nil
- (require 'mcharset)
- (error nil))
- (fboundp 'coding-system-to-mime-charset)))
- (coding-system-to-mime-charset coding-system)))))
+ (or (coding-system-get coding-system :mime-charset)
+ (coding-system-get coding-system 'mime-charset))))
(defvar jka-compr-acceptable-retval-list)
(declare-function jka-compr-make-temp-name "jka-compr" (&optional local))
(setq filename (file-name-sans-extension filename)))
(goto-char (point-min))
(unwind-protect
- (cond
- ((boundp 'set-auto-coding-function) ;; Emacs
- (if filename
- (or (funcall (symbol-value 'set-auto-coding-function)
- filename (- (point-max) (point-min)))
- (car (find-operation-coding-system 'insert-file-contents
- filename)))
- (let (auto-coding-alist)
- (condition-case nil
- (funcall (symbol-value 'set-auto-coding-function)
- nil (- (point-max) (point-min)))
- (error nil)))))
- ((and (featurep 'xemacs) (featurep 'file-coding)) ;; XEmacs
- (let ((case-fold-search t)
- (end (point-at-eol))
- codesys start)
- (or
- (and (re-search-forward "-\\*-+[\t ]*" end t)
- (progn
- (setq start (match-end 0))
- (re-search-forward "[\t ]*-+\\*-" end t))
- (progn
- (setq end (match-beginning 0))
- (goto-char start)
- (or (looking-at "coding:[\t ]*\\([^\t ;]+\\)")
- (re-search-forward
- "[\t ;]+coding:[\t ]*\\([^\t ;]+\\)"
- end t)))
- (find-coding-system (setq codesys
- (intern (match-string 1))))
- codesys)
- (and (re-search-forward "^[\t ]*;+[\t ]*Local[\t ]+Variables:"
- nil t)
- (progn
- (setq start (match-end 0))
- (re-search-forward "^[\t ]*;+[\t ]*End:" nil t))
- (progn
- (setq end (match-beginning 0))
- (goto-char start)
- (re-search-forward
- "^[\t ]*;+[\t ]*coding:[\t ]*\\([^\t\n\r ]+\\)"
- end t))
- (find-coding-system (setq codesys
- (intern (match-string 1))))
- codesys)
- (and (progn
- (goto-char (point-min))
- (setq case-fold-search nil)
- (re-search-forward "^;;;coding system: "
- ;;(+ (point-min) 3000) t))
- nil t))
- (looking-at "[^\t\n\r ]+")
- (find-coding-system
- (setq codesys (intern (match-string 0))))
- codesys)
- (and filename
- (setq codesys
- (find-file-coding-system-for-read-from-filename
- filename))
- (coding-system-name (coding-system-base codesys)))))))
+ (if filename
+ (or (funcall (symbol-value 'set-auto-coding-function)
+ filename (- (point-max) (point-min)))
+ (car (find-operation-coding-system 'insert-file-contents
+ filename)))
+ (let (auto-coding-alist)
+ (condition-case nil
+ (funcall (symbol-value 'set-auto-coding-function)
+ nil (- (point-max) (point-min)))
+ (error nil))))
(when decomp
(kill-buffer (current-buffer)))))))
(not (eq charset 'ascii)))
;; Assume that buffer's multibyteness is turned off.
;; See `mml2015-pgg-clear-decrypt'.
- (insert (mm-decode-coding-string (prog1
- (buffer-string)
- (erase-buffer)
- (mm-enable-multibyte))
- charset))
+ (insert (decode-coding-string (prog1
+ (buffer-string)
+ (erase-buffer)
+ (mm-enable-multibyte))
+ charset))
(mm-enable-multibyte))
(list (mm-make-handle buf mm-uu-text-plain-type)))
(list (mm-make-handle buf '("application/pgp-encrypted")))))))
((condition-case nil
(let ((coding-system-for-write 'iso-2022-jp)
(coding-system-for-read 'iso-2022-jp)
- (str (mm-decode-coding-string "\
+ (str (decode-coding-string "\
\e$B#D#o#e#s!!#w#3#m!!#s#u#p#p#o#r#t!!#m#1#7#n!)\e(B" 'iso-2022-jp)))
(mm-with-multibyte-buffer
(insert str)
(delete-region (match-beginning 0) (match-end 0))))
(defun mm-inline-wash-with-file (post-func cmd &rest args)
- (let ((file (mm-make-temp-file
+ (let ((file (make-temp-file
(expand-file-name "mm" mm-tmp-directory))))
(let ((coding-system-for-write 'binary))
(write-region (point-min) (point-max) file nil 'silent))
(with-current-buffer (mm-handle-buffer handle)
(buffer-string)))
(coding-system
- (mm-decode-coding-string text coding-system))
+ (decode-coding-string text coding-system))
(charset
(mm-decode-string text charset))
(t
(if (eq 'OpenPGP protocol)
(epg-sign-string context (buffer-string) mode)
(epg-sign-string context
- (mm-replace-in-string (buffer-string)
- "\n" "\r\n") t))
+ (replace-regexp-in-string (buffer-string)
+ "\n" "\r\n")
+ t))
mml-secure-secret-key-id-list nil)
(error
(mml-secure-clear-secret-key-id-list)
(mm-set-handle-multipart-parameter
mm-security-handle 'gnus-info "Corrupted")
(throw 'error handle))
- (setq part (mm-replace-in-string part "\n" "\r\n")
+ (setq part (replace-regexp-in-string part "\n" "\r\n")
context (epg-make-context 'CMS))
(condition-case error
(setq plain (epg-verify-string context (mm-get-part signature) part))
(mm-with-unibyte-buffer
(cond
((cdr (assq 'buffer cont))
- (insert (mm-string-as-unibyte
+ (insert (string-as-unibyte
(with-current-buffer (cdr (assq 'buffer cont))
(buffer-string)))))
((and filename
(let ((contents (cdr (assq 'contents cont))))
(if (if (featurep 'xemacs)
(string-match "[^\000-\377]" contents)
- (mm-multibyte-string-p contents))
+ (multibyte-string-p contents))
(progn
(mm-enable-multibyte)
(insert contents)
'type type
;; icicles redefines read-file-name and returns a
;; string w/ text properties :-/
- 'filename (mm-substring-no-properties file)
+ 'filename (substring-no-properties file)
'disposition (or disposition "attachment")
'description description)
;; When using Mail mode, make sure it does the mime encoding
;; FIXME: Buffer is in article mode, but most tool bar commands won't
;; work. Maybe only keep the following icons: search, print, quit
(goto-char (point-min))))
- (if (and (not (mm-special-display-p (buffer-name mml-preview-buffer)))
+ (if (and (not (special-display-p (buffer-name mml-preview-buffer)))
(boundp 'gnus-buffer-configuration)
(assq 'mml-preview gnus-buffer-configuration))
(let ((gnus-message-buffer (current-buffer)))
(insert "\r"))
(forward-line)
(end-of-line))
- (with-temp-file (setq signature-file (mm-make-temp-file "pgg"))
+ (with-temp-file (setq signature-file (make-temp-file "pgg"))
(mm-insert-part signature))
(if (condition-case err
(prog1
(if (condition-case err
(prog1
(mm-with-unibyte-buffer
- (insert (mm-encode-coding-string text coding-system))
+ (insert (encode-coding-string text coding-system))
(pgg-verify-region (point-min) (point-max) nil t))
(goto-char (point-min))
(while (search-forward "\r\n" nil t)
(defun mml2015-epg-key-image (key-id)
"Return the image of a key, if any"
(with-temp-buffer
- (mm-set-buffer-multibyte nil)
+ (set-buffer-multibyte nil)
(let* ((coding-system-for-write 'binary)
(coding-system-for-read 'binary)
(data (shell-command-to-string
(mm-set-handle-multipart-parameter
mm-security-handle 'gnus-info "Corrupted")
(throw 'error handle))
- (setq part (mm-replace-in-string part "\n" "\r\n")
+ (setq part (replace-regexp-in-string part "\n" "\r\n")
signature (mm-get-part signature)
context (epg-make-context))
(condition-case error
(defun mml2015-epg-clear-verify ()
(let ((inhibit-redisplay t)
(context (epg-make-context))
- (signature (mm-encode-coding-string (buffer-string)
- coding-system-for-write))
+ (signature (encode-coding-string (buffer-string)
+ coding-system-for-write))
plain)
(condition-case error
(setq plain (epg-verify-string context signature))
(mml2015-epg-verify-result-to-string
(epg-context-result-for context 'verify)))
(delete-region (point-min) (point-max))
- (insert (mm-decode-coding-string plain coding-system-for-read)))
+ (insert (decode-coding-string plain coding-system-for-read)))
(mml2015-extract-cleartext-signature))))
(defun mml2015-epg-sign (cont)
(looking-at "JMF"))
(defun nndoc-oe-dbx-type-p ()
- (looking-at (mm-string-to-multibyte "\317\255\022\376")))
+ (looking-at (string-to-multibyte "\317\255\022\376")))
(defun nndoc-read-little-endian ()
(+ (prog1 (char-after) (forward-char 1))
(defun nneething-encode-file-name (file &optional coding-system)
"Encode the name of the FILE in CODING-SYSTEM."
(let ((pos 0) buf)
- (setq file (mm-encode-coding-string
+ (setq file (encode-coding-string
file (or coding-system nnmail-pathname-coding-system)))
(while (string-match "[^-0-9a-zA-Z_:/.]" file pos)
(setq buf (cons (format "%%%02x" (aref file (match-beginning 0)))
(setq buf (cons (string (string-to-number (match-string 1 file) 16))
(cons (substring file pos (match-beginning 0)) buf))
pos (match-end 0)))
- (mm-decode-coding-string
+ (decode-coding-string
(apply (function concat)
(nreverse (cons (substring file pos) buf)))
(or coding-system nnmail-pathname-coding-system))))
(defun nnfolder-group-pathname (group)
"Make file name for GROUP."
(setq group
- (mm-encode-coding-string group nnmail-pathname-coding-system))
+ (encode-coding-string group nnmail-pathname-coding-system))
(let ((dir (file-name-as-directory (expand-file-name nnfolder-directory))))
;; If this file exists, we use it directly.
(if (or nnmail-use-long-file-names
(< beg nnheader-max-head-length))))
;; Finally decode the contents.
(when (mm-coding-system-p nnheader-file-coding-system)
- (mm-decode-coding-region start (point-max)
- nnheader-file-coding-system))))
+ (decode-coding-region start (point-max)
+ nnheader-file-coding-system))))
t))
(defun nnheader-article-p ()
t))
(defsubst nnheader-replace-chars-in-string (string from to)
- (mm-subst-char-in-string from to string))
+ (subst-char-in-string from to string))
(defun nnheader-replace-duplicate-chars-in-string (string from to)
"Replace characters in STRING from FROM to TO."
(if (file-directory-p (concat dir group))
(expand-file-name group dir)
;; If not, we translate dots into slashes.
- (expand-file-name (mm-encode-coding-string
+ (expand-file-name (encode-coding-string
(nnheader-replace-chars-in-string group ?. ?/)
nnheader-pathname-coding-system)
dir))))
`(insert-buffer-substring ,buffer ,start ,end)
`(if enable-multibyte-characters
(insert (with-current-buffer ,buffer
- (mm-string-to-multibyte
+ (string-to-multibyte
,(if (or start end)
`(buffer-substring (or ,start (point-min))
(or ,end (point-max)))
(delete-region (+ (match-beginning 0) 2) (point))
(setq string (buffer-substring (point) (+ (point) size)))
(delete-region (point) (+ (point) size))
- (insert (format "%S" (mm-subst-char-in-string ?\n ?\s string))))
+ (insert (format "%S" (subst-char-in-string ?\n ?\s string))))
(beginning-of-line)
(setq article
(and (re-search-forward "UID \\([0-9]+\\)" (line-end-position)
`(("query" . ,search)
("HITSPERPAGE" . "999")))))
(unless (featurep 'xemacs) (set-buffer-multibyte t))
- (mm-decode-coding-region (point-min) (point-max) 'utf-8)
+ (decode-coding-region (point-min) (point-max) 'utf-8)
(goto-char (point-min))
(forward-line 1)
(while (not (eobp))
(string-to-number (match-string 2 xref)) xscore)
artlist)))))
(forward-line 1)))
- (apply 'vector (nreverse (mm-delete-duplicates artlist)))))
+ (apply 'vector (nreverse (delete-dups artlist)))))
;;; Util Code:
(if (eq (car method) 'nntp)
(while (not (eobp))
(ignore-errors
- (push (mm-string-as-unibyte
+ (push (string-as-unibyte
(gnus-group-full-name
(buffer-substring
(point)
(progn
(skip-chars-forward "^ \t")
- (point))) method))
+ (point)))
+ method))
groups))
(forward-line))
(while (not (eobp))
(ignore-errors
- (push (mm-string-as-unibyte
+ (push (string-as-unibyte
(if (eq (char-after) ?\")
(gnus-group-full-name (read cur) method)
(let ((p (point)) (name ""))
(setq group (symbol-name group)))
(if (and (numberp (setq max (read buffer)))
(numberp (setq min (read buffer))))
- (push (list (mm-string-as-unibyte group) (cons min max))
+ (push (list (string-as-unibyte group) (cons min max))
group-assoc)))
(error nil))
(widen)
5 "Error in `nnmail-split-methods'; using `bogus' mail group: %S" error-info)
(sit-for 1)
'("bogus")))))
- (setq split (mm-delete-duplicates split))
+ (setq split (delete-dups split))
;; The article may be "cross-posted" to `junk'. What
;; to do? Just remove the `junk' spec. Don't really
;; see anything else to do...
(insert (if (mm-multibyte-p)
(mm-string-as-multibyte
(format " %s:%d" (caar group-alist) (cdar group-alist)))
- (mm-string-as-unibyte
+ (string-as-unibyte
(format " %s:%d" (caar group-alist) (cdar group-alist)))))
(setq group-alist (cdr group-alist)))
(insert "\n")))
(file-truename (file-name-as-directory
(expand-file-name nnmh-toplev))))
dir)
- (mm-string-to-multibyte ;Why? Isn't it multibyte already?
- (mm-encode-coding-string
+ (string-to-multibyte ;Why? Isn't it multibyte already?
+ (encode-coding-string
(nnheader-replace-chars-in-string
(substring dir (match-end 0))
?/ ?.)
"Return a decoded group name of GROUP on SERVER-OR-METHOD."
(if nnmail-group-names-not-encoded-p
group
- (mm-decode-coding-string
+ (decode-coding-string
group
(nnml-group-name-charset group server-or-method))))
(defun nnml-encoded-group-name (group &optional server-or-method)
"Return an encoded group name of GROUP on SERVER-OR-METHOD."
- (mm-encode-coding-string
+ (encode-coding-string
group
(nnml-group-name-charset group server-or-method)))
(defun nnrss-decode-group-name (group)
(if (and group (mm-coding-system-p 'utf-8))
- (setq group (mm-decode-coding-string group 'utf-8))
+ (setq group (decode-coding-string group 'utf-8))
group))
(deffoo nnrss-retrieve-headers (articles &optional group server fetch-old)
;; Decode text according to the encoding attribute.
(when (setq cs (nnrss-get-encoding))
(insert (prog1
- (mm-decode-coding-string (buffer-string) cs)
+ (decode-coding-string (buffer-string) cs)
(erase-buffer)
(mm-enable-multibyte))))
(goto-char (point-min))
Export subscriptions to a buffer in OPML Format."
(interactive)
(with-current-buffer (get-buffer-create "*OPML Export*")
- (mm-set-buffer-file-coding-system 'utf-8)
+ (set-buffer-file-coding-system 'utf-8)
(insert "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
"<!-- OPML generated by Emacs Gnus' nnrss.el -->\n"
"<opml version=\"1.1\">\n"
(with-current-buffer ,buffer
(erase-buffer)
(insert (if enable-multibyte-characters
- (mm-string-to-multibyte string)
+ (string-to-multibyte string)
string))
(goto-char (point-min))
nil))))
))))
(setq buffer-file-name nil)
(unless (featurep 'xemacs) (set-buffer-multibyte t))
- (mm-decode-coding-region (point-min) (point-max) 'utf-8)
+ (decode-coding-region (point-min) (point-max) 'utf-8)
t)
(defun nnweb-gmane-identity (url)
;; which already contains non-ASCII characters which would
;; then get doubly-decoded below.
(if coding-system
- (mm-encode-coding-region (point-min) (point-max) coding-system))
+ (encode-coding-region (point-min) (point-max) coding-system))
(goto-char (point-min))
(while (and (skip-chars-forward "^=")
(not (eobp)))
(message "Malformed quoted-printable text")
(forward-char)))))
(if coding-system
- (mm-decode-coding-region (point-min) (point-max) coding-system)))))
+ (decode-coding-region (point-min) (point-max) coding-system)))))
(defun quoted-printable-decode-string (string &optional coding-system)
"Decode the quoted-printable encoded STRING and return the result.
(setq class "\010-\012\014\040-\074\076-\177"))
(save-excursion
(goto-char from)
- (if (re-search-forward (mm-string-to-multibyte "[^\x0-\x7f\x80-\xff]")
+ (if (re-search-forward (string-to-multibyte "[^\x0-\x7f\x80-\xff]")
to t)
(error "Multibyte character in QP encoding region"))
(save-restriction
(not (eobp)))
(insert
(prog1
- ;; To unibyte in case of Emacs 23 (unicode) eight-bit.
- (format "=%02X" (mm-multibyte-char-to-unibyte (char-after)))
+ (format "=%02X" (char-after))
(delete-char 1))))
;; Encode white space at the end of lines.
(goto-char (point-min))
(defun quoted-printable-encode-string (string)
"Encode the STRING as quoted-printable and return the result."
(with-temp-buffer
- (if (mm-multibyte-string-p string)
+ (if (multibyte-string-p string)
(mm-enable-multibyte)
(mm-disable-multibyte))
(insert string)
(match-beginning 1)
(match-end 1)))
(setq firstc (aref str 0))
- (insert (mm-decode-coding-string
+ (insert (decode-coding-string
(rfc1843-decode
(prog1
(substring str 1)
(mm-coding-system-p
(car message-posting-charset)))
;; 8 bit must be decoded.
- (mm-encode-coding-region
+ (encode-coding-region
(point-min) (point-max)
(mm-charset-to-coding-system
(car message-posting-charset))))
(if (boundp 'enable-multibyte-characters)
(default-value 'enable-multibyte-characters))
mail-parse-charset)
- (mm-encode-coding-region (point) (point-max)
- mail-parse-charset)))
+ (encode-coding-region (point) (point-max)
+ mail-parse-charset)))
;; We get this when CC'ing messages to newsgroups with
;; 8-bit names. The group name mail copy just got
;; unconditionally encoded. Previously, it would ask
(if (boundp 'enable-multibyte-characters)
(default-value 'enable-multibyte-characters)))
(featurep 'file-coding))
- (mm-encode-coding-region (point) (point-max) method)))
+ (encode-coding-region (point) (point-max) method)))
;; Hm.
(t)))
(goto-char (point-max))))))))
(if (or debug-on-quit debug-on-error)
(signal (car err) (cdr err))
(error "Invalid data for rfc2047 encoding: %s"
- (mm-replace-in-string orig-text "[ \t\n]+" " "))))))))
+ (replace-regexp-in-string orig-text "[ \t\n]+" " "))))))))
(unless dont-fold
(rfc2047-fold-region b (point)))
(goto-char (point-max))))
((not rfc2047-encode-max-chars)
(concat start
(funcall encoder (if cs
- (mm-encode-coding-string string cs)
+ (encode-coding-string string cs)
string))
"?="))
((>= column rfc2047-encode-max-chars)
(setq next (concat start
(funcall encoder
(if cs
- (mm-encode-coding-string
+ (encode-coding-string
(substring string 0 (1+ index))
cs)
(substring string 0 (1+ index))))
(setq crest (buffer-substring-no-properties (point) b)))
(setq eword (rfc2047-encode-1
(- b (point-at-bol))
- (mm-replace-in-string
+ (replace-regexp-in-string
(buffer-substring-no-properties b e)
"\n\\([ \t]?\\)" "\\1")
cs
(rfc2047-pad-base64 (nth 2 word)))))
((char-equal ?Q (nth 1 word))
(setq text (quoted-printable-decode-string
- (mm-subst-char-in-string
+ (subst-char-in-string
?_ ? (nth 2 word) t)))))
(error
(message "%s" (error-message-string code))
(setq words (concat
(or (and (setq cs (caar rest))
(condition-case code
- (mm-decode-coding-string (cdar rest) cs)
+ (decode-coding-string (cdar rest) cs)
(error
(message "%s" (error-message-string code))
nil)))
mail-parse-charset
(not (eq mail-parse-charset 'us-ascii))
(not (eq mail-parse-charset 'gnus-decoded)))
- (mm-decode-coding-region b e mail-parse-charset))
+ (decode-coding-region b e mail-parse-charset))
(setq b (point)))
(when (and (mm-multibyte-p)
mail-parse-charset
(not (eq mail-parse-charset 'us-ascii))
(not (eq mail-parse-charset 'gnus-decoded)))
- (mm-decode-coding-region b (point-max) mail-parse-charset))))))
+ (decode-coding-region b (point-max) mail-parse-charset))))))
(defun rfc2047-decode-address-region (start end)
"Decode MIME-encoded words in region between START and END.
(when address-mime
(setq string
(with-temp-buffer
- (when (mm-multibyte-string-p string)
+ (when (multibyte-string-p string)
(mm-enable-multibyte))
(insert string)
(rfc2047-strip-backslashes-in-quoted-strings)
;; string is purely ASCII
(eq (detect-coding-string string t) 'undecided))
string
- (mm-decode-coding-string string mail-parse-charset))
- (mm-string-to-multibyte string)))) ;; )
+ (decode-coding-string string mail-parse-charset))
+ (string-to-multibyte string)))) ;; )
(defun rfc2047-decode-address-string (string)
"Decode MIME-encoded STRING and return the result.
(let (mod)
(when (and (string-match "\\\\\"" string)
(not (string-match "\\`\"\\|[^\\]\"" string)))
- (setq string (mm-replace-in-string string "\\\\\"" "\"")
+ (setq string (replace-regexp-in-string string "\\\\\"" "\"")
mod t))
(when (and (string-match "\\\\(" string)
(string-match "\\\\)" string)
(not (string-match "\\`(\\|[^\\][()]" string)))
- (setq string (mm-replace-in-string string "\\\\\\([()]\\)" "\\1")
+ (setq string (replace-regexp-in-string string
+ "\\\\\\([()]\\)" "\\1")
mod t))
(or (and mod
(ignore-errors
;; Decode using the charset, if any.
(if (memq coding-system '(nil ascii))
(buffer-string)
- (mm-decode-coding-string (buffer-string) coding-system)))))
+ (decode-coding-string (buffer-string) coding-system)))))
(defun rfc2231-encode-string (param value)
"Return and PARAM=VALUE string encoded according to RFC2231.
(re-search-forward
"http://\\([^/]+\\)\\(/.*\\) *$" (point-at-eol) t))
(let ((spam-report-gmane-wait
- (zerop (% (mm-line-number-at-pos)
- spam-report-gmane-max-requests))))
+ (zerop (% (line-number-at-pos) spam-report-gmane-max-requests))))
(gnus-message 6 "Reporting %s%s..."
(match-string 1) (match-string 2))
(funcall spam-report-url-ping-function
(defun utf7-latin1-u16-char-converter ()
"Convert latin 1 (ISO-8859.1) characters to 16 bit Unicode.
Characters are converted to raw byte pairs in narrowed buffer."
- (mm-encode-coding-region (point-min) (point-max) 'iso-8859-1)
+ (encode-coding-region (point-min) (point-max) 'iso-8859-1)
(mm-disable-multibyte)
(goto-char (point-min))
(while (not (eobp))
(delete-char 1)
(error "Unable to convert from Unicode"))
(forward-char))
- (mm-decode-coding-region (point-min) (point-max) 'iso-8859-1)
+ (decode-coding-region (point-min) (point-max) 'iso-8859-1)
(mm-enable-multibyte))
;;;###autoload
;; use it as the drafts folder. Then copy the skeleton to a regular
;; temp file, and return the regular temp file.
(let (new
- (temp-folder (mm-make-temp-file
+ (temp-folder (make-temp-file
(concat mh-user-path "draftfolder.") t)))
(mh-exec-cmd "comp" "-nowhatnowproc"
"-draftfolder" (format "+%s"
(file-name-nondirectory temp-folder))
(if (stringp mh-comp-formfile)
(list "-form" mh-comp-formfile)))
- (setq new (mm-make-temp-file "comp."))
+ (setq new (make-temp-file "comp."))
(rename-file (concat temp-folder "/" "1") new t)
(delete-file (concat temp-folder "/" ".mh_sequences"))
(delete-directory temp-folder)
projects / emacs.git / commitdiff