1 ;;; eword-decode.el --- RFC 2047 based encoded-word decoder for GNU Emacs
3 ;; Copyright (C) 1995,1996,1997,1998 Free Software Foundation, Inc.
5 ;; Author: ENAMI Tsugutomo <enami@sys.ptg.sony.co.jp>
6 ;; MORIOKA Tomohiko <morioka@jaist.ac.jp>
7 ;; Tanaka Akira <akr@jaist.ac.jp>
8 ;; Maintainer: Tanaka Akira <akr@jaist.ac.jp>
10 ;; Original: 1992/07/20 ENAMI Tsugutomo's `mime.el'.
11 ;; Renamed: 1993/06/03 to tiny-mime.el
12 ;; Renamed: 1995/10/03 from tiny-mime.el (split off encoder)
13 ;; Renamed: 1997/02/22 from tm-ew-d.el
14 ;; Keywords: encoded-word, MIME, multilingual, header, mail, news
16 ;; This file is part of FLAM (Faithful Library About MIME).
18 ;; This program is free software; you can redistribute it and/or
19 ;; modify it under the terms of the GNU General Public License as
20 ;; published by the Free Software Foundation; either version 2, or (at
21 ;; your option) any later version.
23 ;; This program is distributed in the hope that it will be useful, but
24 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
25 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 ;; General Public License for more details.
28 ;; You should have received a copy of the GNU General Public License
29 ;; along with GNU Emacs; see the file COPYING. If not, write to the
30 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
31 ;; Boston, MA 02111-1307, USA.
35 (require 'std11-parse)
39 (defgroup eword-decode nil
40 "Encoded-word decoding"
47 (defcustom eword-decode-sticked-encoded-word nil
48 "*If non-nil, decode encoded-words sticked on atoms,
49 other encoded-words, etc.
50 however this behaviour violates RFC2047."
54 (defcustom eword-decode-quoted-encoded-word nil
55 "*If non-nil, decode encoded-words in quoted-string
56 however this behaviour violates RFC2047."
61 ;;; @ MIME encoded-word definition
64 (defconst eword-encoded-word-prefix-regexp
65 (concat (regexp-quote "=?")
66 "\\(" mime-charset-regexp "\\)"
70 (defconst eword-encoded-word-suffix-regexp
73 (defconst eword-encoded-text-in-unstructured-regexp "[!->@-~]+")
74 (defconst eword-encoded-word-in-unstructured-regexp
75 (concat eword-encoded-word-prefix-regexp
76 "\\(" eword-encoded-text-in-unstructured-regexp "\\)"
77 eword-encoded-word-suffix-regexp))
78 (defconst eword-after-encoded-word-in-unstructured-regexp "\\([ \t]\\|$\\)")
80 (defconst eword-encoded-text-in-phrase-regexp "[-A-Za-z0-9!*+/=_]+")
81 (defconst eword-encoded-word-in-phrase-regexp
82 (concat eword-encoded-word-prefix-regexp
83 "\\(" eword-encoded-text-in-phrase-regexp "\\)"
84 eword-encoded-word-suffix-regexp))
85 (defconst eword-after-encoded-word-in-phrase-regexp "\\([ \t(]\\|$\\)")
87 (defconst eword-encoded-text-in-comment-regexp "[]!-'*->@-[^-~]+")
88 (defconst eword-encoded-word-in-comment-regexp
89 (concat eword-encoded-word-prefix-regexp
90 "\\(" eword-encoded-text-in-comment-regexp "\\)"
91 eword-encoded-word-suffix-regexp))
92 (defconst eword-after-encoded-word-in-comment-regexp "\\([ \t()\\\\]\\|$\\)")
94 (defconst eword-encoded-text-in-quoted-string-regexp "[]!#->@-[^-~]+")
95 (defconst eword-encoded-word-in-quoted-string-regexp
96 (concat eword-encoded-word-prefix-regexp
97 "\\(" eword-encoded-text-in-quoted-string-regexp "\\)"
98 eword-encoded-word-suffix-regexp))
99 (defconst eword-after-encoded-word-in-quoted-string-regexp "\\([ \t\"\\\\]\\|$\\)")
102 (defconst eword-encoded-text-regexp eword-encoded-text-in-unstructured-regexp)
103 (defconst eword-encoded-word-regexp eword-encoded-word-in-unstructured-regexp)
109 (defconst base64-token-regexp "[A-Za-z0-9+/]")
110 (defconst base64-token-padding-regexp "[A-Za-z0-9+/=]")
112 (defconst eword-B-encoded-text-regexp
121 base64-token-padding-regexp
122 base64-token-padding-regexp
125 ;; (defconst eword-B-encoding-and-encoded-text-regexp
126 ;; (concat "\\(B\\)\\?" eword-B-encoded-text-regexp))
129 ;;; @@ Quoted-Printable
132 (defconst quoted-printable-hex-chars "0123456789ABCDEF")
133 (defconst quoted-printable-octet-regexp
134 (concat "=[" quoted-printable-hex-chars
135 "][" quoted-printable-hex-chars "]"))
137 (defconst eword-Q-encoded-text-regexp
138 (concat "\\([^=?]\\|" quoted-printable-octet-regexp "\\)+"))
139 ;; (defconst eword-Q-encoding-and-encoded-text-regexp
140 ;; (concat "\\(Q\\)\\?" eword-Q-encoded-text-regexp))
143 ;;; @ internal utilities
146 (defun eword-decode-first-encoded-words (string
149 &optional must-unfold)
150 "Decode MIME encoded-words in beginning of STRING.
152 EWORD-REGEXP is the regexp that matches a encoded-word.
154 eword-encoded-word-in-unstructured-regexp,
155 eword-encoded-text-in-phrase-regexp,
156 eword-encoded-word-in-comment-regexp or
157 eword-encoded-word-in-quoted-string-regexp.
159 AFTER-REGEXP is the regexp that matches a after encoded-word.
161 eword-after-encoded-word-in-unstructured-regexp,
162 eword-after-encoded-text-in-phrase-regexp,
163 eword-after-encoded-word-in-comment-regexp or
164 eword-after-encoded-word-in-quoted-string-regexp.
166 If beginning of STRING matches EWORD-REGEXP with AFTER-REGEXP,
167 returns a cons cell of decoded string(sequence of characters) and
168 the rest(sequence of octets).
170 If beginning of STRING does not matches EWORD-REGEXP and AFTER-REGEXP,
173 If an encoded-word is broken or your emacs implementation can not
174 decode the charset included in it, it is returned in decoded part
175 as encoded-word form.
177 If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
178 if there are in decoded encoded-words (generated by bad manner MUA
179 such as a version of Net$cape)."
180 (if eword-decode-sticked-encoded-word (setq after-regexp ""))
181 (let* ((between-ewords-regexp
182 (if eword-decode-sticked-encoded-word
185 (between-ewords-eword-after-regexp
186 (concat "\\`\\(" between-ewords-regexp "\\)"
187 "\\(" eword-regexp "\\)"
190 (concat "\\`\\(" eword-regexp "\\)" after-regexp))
191 (src string) ; sequence of octets.
192 (dst "")) ; sequence of characters.
193 (if (string-match eword-after-regexp src)
196 (ew (substring src 0 q))
197 (dw (eword-decode-encoded-word ew must-unfold)))
198 (setq dst (concat dst dw)
199 src (substring src q))
200 (if (not (string= ew dw))
204 (string-match between-ewords-eword-after-regexp src)
206 (setq p (match-end 1)
208 ew (substring src p q)
209 dw (eword-decode-encoded-word ew must-unfold))
212 (setq dst (concat dst (substring src 0 q))
213 src (substring src q))
216 (setq dst (concat dst dw)
217 src (substring src q)))))
221 (defun eword-decode-entire-string (string
226 delimiters ; list of chars.
229 (if (and code-conversion
230 (not (mime-charset-to-coding-system code-conversion)))
231 (setq code-conversion default-mime-charset))
232 (let ((equal-safe-regexp (concat "\\`=?" safe-regexp))
237 (while (< 0 (length src))
238 (let ((ch (aref src 0))
241 (eword-decode-first-encoded-words src
242 eword-regexp after-regexp must-unfold))))
243 (if (and (not (string= buf ""))
244 (or decoded (memq ch delimiters)))
245 (setq dst (concat dst
246 (std11-wrap-as-quoted-pairs
247 (decode-mime-charset-string buf code-conversion)
252 (setq dst (concat dst
253 (std11-wrap-as-quoted-pairs
257 ((memq ch delimiters)
258 (setq dst (concat dst (list ch))
259 src (substring src 1)
262 (setq buf (concat buf (list (aref src 1)))
263 src (substring src 2)
265 ((string-match "\\`[ \t\n]+" src)
266 (setq buf (concat buf (substring src 0 (match-end 0)))
267 src (substring src (match-end 0))
269 ((and (string-match equal-safe-regexp src)
271 (setq buf (concat buf (substring src 0 (match-end 0)))
272 src (substring src (match-end 0))
273 ew-enable eword-decode-sticked-encoded-word))
274 (t (error "something wrong")))))
275 (if (not (string= buf ""))
276 (setq dst (concat dst
277 (std11-wrap-as-quoted-pairs
278 (decode-mime-charset-string buf code-conversion)
286 (defun eword-decode-unstructured (string code-conversion &optional must-unfold)
287 (eword-decode-entire-string
289 eword-encoded-word-in-unstructured-regexp
290 eword-after-encoded-word-in-unstructured-regexp
297 (defun eword-decode-comment (string code-conversion &optional must-unfold)
298 (eword-decode-entire-string
300 eword-encoded-word-in-comment-regexp
301 eword-after-encoded-word-in-comment-regexp
308 (defun eword-decode-quoted-string (string code-conversion &optional must-unfold)
309 (eword-decode-entire-string
311 eword-encoded-word-in-quoted-string-regexp
312 eword-after-encoded-word-in-quoted-string-regexp
319 (defun eword-decode-string (string &optional must-unfold code-conversion)
320 "Decode MIME encoded-words in STRING.
322 STRING is unfolded before decoding.
324 If an encoded-word is broken or your emacs implementation can not
325 decode the charset included in it, it is not decoded.
327 If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
328 if there are in decoded encoded-words (generated by bad manner MUA
329 such as a version of Net$cape).
331 If CODE-CONVERSION is nil, it decodes only encoded-words. If it is
332 mime-charset, it decodes non-ASCII bit patterns as the mime-charset.
333 Otherwise it decodes non-ASCII bit patterns as the
334 default-mime-charset."
335 (eword-decode-unstructured
337 (std11-unfold-string string)
344 (defun eword-decode-region (start end &optional unfolding must-unfold
346 "Decode MIME encoded-words in region between START and END.
348 If UNFOLDING is not nil, it unfolds before decoding.
350 If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
351 if there are in decoded encoded-words (generated by bad manner MUA
352 such as a version of Net$cape).
354 If CODE-CONVERSION is nil, it decodes only encoded-words. If it is
355 mime-charset, it decodes non-ASCII bit patterns as the mime-charset.
356 Otherwise it decodes non-ASCII bit patterns as the
357 default-mime-charset."
361 (narrow-to-region start end)
363 (eword-decode-unfold)
365 (let ((str (eword-decode-unstructured
367 (buffer-substring (point-min) (point-max))
369 (delete-region (point-min) (point-max))
373 ;;; @ for message header
376 (defcustom eword-decode-ignored-field-list
377 '(newsgroups path lines nntp-posting-host received message-id date)
378 "*List of field-names to be ignored when decoding.
379 Each field name must be symbol."
381 :type '(repeat symbol))
383 (defcustom eword-decode-structured-field-list
384 '(reply-to resent-reply-to from resent-from sender resent-sender
385 to resent-to cc resent-cc bcc resent-bcc dcc
386 mime-version content-type content-transfer-encoding
388 "*List of field-names to decode as structured field.
389 Each field name must be symbol."
391 :type '(repeat symbol))
393 (defun eword-decode-header (&optional code-conversion separator)
394 "Decode MIME encoded-words in header fields.
395 If CODE-CONVERSION is nil, it decodes only encoded-words. If it is
396 mime-charset, it decodes non-ASCII bit patterns as the mime-charset.
397 Otherwise it decodes non-ASCII bit patterns as the
398 default-mime-charset.
399 If SEPARATOR is not nil, it is used as header separator."
401 (if (and code-conversion
402 (not (mime-charset-to-coding-system code-conversion)))
403 (setq code-conversion default-mime-charset))
406 (std11-narrow-to-header separator)
408 (let (beg p end field-name len)
409 (goto-char (point-min))
410 (while (re-search-forward std11-field-head-regexp nil t)
411 (setq beg (match-beginning 0)
413 field-name (buffer-substring beg (1- p))
414 len (string-width field-name)
415 field-name (intern (downcase field-name))
416 end (std11-field-end))
417 (cond ((memq field-name eword-decode-ignored-field-list)
420 ((memq field-name eword-decode-structured-field-list)
421 ;; Decode as structured field
422 (let ((body (buffer-substring p end)))
423 (delete-region p end)
424 (insert (eword-decode-and-fold-structured-field
428 ;; Decode as unstructured field
430 (narrow-to-region beg (1+ end))
432 (eword-decode-region beg (point-max) 'unfold nil
434 (goto-char (point-max))
436 (eword-decode-region (point-min) (point-max) t nil nil)
439 (defun eword-decode-unfold ()
440 (goto-char (point-min))
442 (while (re-search-forward std11-field-head-regexp nil t)
443 (setq beg (match-beginning 0)
444 end (std11-field-end))
445 (setq field (buffer-substring beg end))
446 (if (string-match eword-encoded-word-regexp field)
448 (narrow-to-region (goto-char beg) end)
449 (while (re-search-forward "\n\\([ \t]\\)" nil t)
450 (replace-match (match-string 1))
452 (goto-char (point-max))
457 ;;; @ encoded-word decoder
460 (defvar eword-warning-face nil "Face used for invalid encoded-word.")
462 (defun eword-decode-encoded-word (word &optional must-unfold)
463 "Decode WORD if it is an encoded-word.
465 If your emacs implementation can not decode the charset of WORD, it
466 returns WORD. Similarly the encoded-word is broken, it returns WORD.
468 If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
469 if there are in decoded encoded-word (generated by bad manner MUA such
470 as a version of Net$cape)."
471 (or (if (string-match eword-encoded-word-regexp word)
473 (substring word (match-beginning 1) (match-end 1))
477 (substring word (match-beginning 2) (match-end 2))
480 (substring word (match-beginning 3) (match-end 3))
483 (eword-decode-encoded-text charset encoding text must-unfold)
486 (add-text-properties 0 (length word)
487 (and eword-warning-face
488 (list 'face eword-warning-face))
495 ;;; @ encoded-text decoder
498 (defun eword-decode-encoded-text (charset encoding string
499 &optional must-unfold)
500 "Decode STRING as an encoded-text.
502 If your emacs implementation can not decode CHARSET, it returns nil.
504 If ENCODING is not \"B\" or \"Q\", it occurs error.
505 So you should write error-handling code if you don't want break by errors.
507 If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
508 if there are in decoded encoded-text (generated by bad manner MUA such
509 as a version of Net$cape)."
510 (let ((cs (mime-charset-to-coding-system charset)))
514 ((string-equal "B" encoding)
515 (if (and (string-match eword-B-encoded-text-regexp string)
516 (string-equal string (match-string 0 string)))
517 (base64-decode-string string)
518 (error "Invalid encoded-text %s" string)))
519 ((string-equal "Q" encoding)
520 (if (and (string-match eword-Q-encoded-text-regexp string)
521 (string-equal string (match-string 0 string)))
522 (q-encoding-decode-string string)
523 (error "Invalid encoded-text %s" string)))
525 (error "Invalid encoding %s" encoding)
530 (setq dest (decode-coding-string dest cs))
537 (t (char-to-string chr)))
539 (std11-unfold-string dest)
545 ;;; @ lexical analyze
548 (defvar eword-lexical-analyze-cache nil)
549 (defvar eword-lexical-analyze-cache-max 299
550 "*Max position of eword-lexical-analyze-cache.
551 It is max size of eword-lexical-analyze-cache - 1.")
553 (defcustom eword-lexical-analyzers
554 '(eword-analyze-quoted-string
555 eword-analyze-domain-literal
556 eword-analyze-comment
558 eword-analyze-special
559 eword-analyze-encoded-word
561 "*List of functions to return result of lexical analyze.
562 Each function must have two arguments: STRING and MUST-UNFOLD.
563 STRING is the target string to be analyzed.
564 If MUST-UNFOLD is not nil, each function must unfold and eliminate
565 bare-CR and bare-LF from the result even if they are included in
566 content of the encoded-word.
567 Each function must return nil if it can not analyze STRING as its
570 Previous function is preferred to next function. If a function
571 returns nil, next function is used. Otherwise the return value will
574 :type '(repeat function))
576 (defun eword-analyze-quoted-string (string &optional must-unfold)
577 (let ((p (std11-check-enclosure string ?\" ?\")))
579 (cons (cons 'quoted-string
580 (eword-decode-quoted-string
581 (substring string 0 p)
582 default-mime-charset))
583 (substring string p))
586 (defun eword-analyze-domain-literal (string &optional must-unfold)
587 (std11-analyze-domain-literal string))
589 (defun eword-analyze-comment (string &optional must-unfold)
590 (let ((len (length string)))
591 (if (and (< 0 len) (eq (aref string 0) ?\())
593 (while (and p (< p len) (eq (aref string p) ?\())
594 (setq p (std11-check-enclosure string ?\( ?\) t p)))
597 (eword-decode-comment
598 (substring string 0 p)
599 default-mime-charset))
600 (substring string p)))
603 (defun eword-analyze-spaces (string &optional must-unfold)
604 (std11-analyze-spaces string))
606 (defun eword-analyze-special (string &optional must-unfold)
607 (std11-analyze-special string))
609 (defun eword-analyze-encoded-word (string &optional must-unfold)
610 (let ((decoded (eword-decode-first-encoded-words
612 eword-encoded-word-in-phrase-regexp
613 eword-after-encoded-word-in-phrase-regexp
616 (cons (cons 'atom (car decoded)) (cdr decoded)))))
618 (defun eword-analyze-atom (string &optional must-unfold)
619 (if (let ((enable-multibyte-characters nil))
620 (string-match std11-atom-regexp string))
621 (let ((end (match-end 0)))
622 (if (and eword-decode-sticked-encoded-word
623 (string-match eword-encoded-word-in-phrase-regexp
624 (substring string 0 end))
625 (< 0 (match-beginning 0)))
626 (setq end (match-beginning 0)))
627 (cons (cons 'atom (decode-mime-charset-string
628 (substring string 0 end)
629 default-mime-charset))
630 (substring string end)
633 (defun eword-lexical-analyze-internal (string must-unfold)
635 (while (not (string-equal string ""))
637 (let ((rest eword-lexical-analyzers)
639 (while (and (setq func (car rest))
640 (null (setq r (funcall func string must-unfold)))
642 (setq rest (cdr rest)))
643 (or r `((error . ,string) . ""))
645 (setq dest (cons (car ret) dest))
646 (setq string (cdr ret))
651 (defun eword-lexical-analyze (string &optional must-unfold)
652 "Return lexical analyzed list corresponding STRING.
653 It is like std11-lexical-analyze, but it decodes non us-ascii
654 characters encoded as encoded-words or invalid \"raw\" format.
655 \"Raw\" non us-ascii characters are regarded as variable
656 `default-mime-charset'."
657 (let* ((str (copy-sequence string))
658 (key (cons str (cons default-mime-charset must-unfold)))
660 (set-text-properties 0 (length str) nil str)
661 (if (setq ret (assoc key eword-lexical-analyze-cache))
663 (setq ret (eword-lexical-analyze-internal str must-unfold))
664 (setq eword-lexical-analyze-cache
666 (last eword-lexical-analyze-cache
667 eword-lexical-analyze-cache-max)))
670 (defun eword-decode-token (token)
673 (defun eword-decode-and-fold-structured-field
674 (string start-column &optional max-column must-unfold)
675 "Decode and fold (fill) STRING as structured field body.
676 It decodes non us-ascii characters in FULL-NAME encoded as
677 encoded-words or invalid \"raw\" string. \"Raw\" non us-ascii
678 characters are regarded as variable `default-mime-charset'.
680 If an encoded-word is broken or your emacs implementation can not
681 decode the charset included in it, it is not decoded.
683 If MAX-COLUMN is omitted, `fill-column' is used.
685 If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
686 if there are in decoded encoded-words (generated by bad manner MUA
687 such as a version of Net$cape)."
689 (setq max-column fill-column))
690 (let ((c start-column)
691 (tokens (eword-lexical-analyze string must-unfold))
694 (while (and (setq token (car tokens))
695 (setq tokens (cdr tokens)))
696 (let* ((type (car token)))
697 (if (eq type 'spaces)
698 (let* ((next-token (car tokens))
699 (next-str (eword-decode-token next-token))
700 (next-len (string-width next-str))
701 (next-c (+ c next-len 1)))
702 (if (< next-c max-column)
703 (setq result (concat result " " next-str)
705 (setq result (concat result "\n " next-str)
707 (setq tokens (cdr tokens))
709 (let* ((str (eword-decode-token token)))
710 (setq result (concat result str)
711 c (+ c (string-width str)))
714 (concat result (eword-decode-token token))
717 (defun eword-decode-and-unfold-structured-field (string)
718 "Decode and unfold STRING as structured field body.
719 It decodes non us-ascii characters in FULL-NAME encoded as
720 encoded-words or invalid \"raw\" string. \"Raw\" non us-ascii
721 characters are regarded as variable `default-mime-charset'.
723 If an encoded-word is broken or your emacs implementation can not
724 decode the charset included in it, it is not decoded."
725 (let ((tokens (eword-lexical-analyze string 'must-unfold))
728 (let* ((token (car tokens))
730 (setq tokens (cdr tokens))
732 (if (eq type 'spaces)
734 (concat result (eword-decode-token token))
738 (defun eword-decode-structured-field-body (string &optional must-unfold
739 start-column max-column)
740 "Decode non us-ascii characters in STRING as structured field body.
741 STRING is unfolded before decoding.
743 It decodes non us-ascii characters in FULL-NAME encoded as
744 encoded-words or invalid \"raw\" string. \"Raw\" non us-ascii
745 characters are regarded as variable `default-mime-charset'.
747 If an encoded-word is broken or your emacs implementation can not
748 decode the charset included in it, it is not decoded.
750 If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
751 if there are in decoded encoded-words (generated by bad manner MUA
752 such as a version of Net$cape)."
754 ;; fold with max-column
755 (eword-decode-and-fold-structured-field
756 string start-column max-column must-unfold)
758 (mapconcat (function eword-decode-token)
759 (eword-lexical-analyze string must-unfold)
763 (defun eword-decode-unstructured-field-body (string &optional must-unfold)
764 "Decode non us-ascii characters in STRING as unstructured field body.
765 STRING is unfolded before decoding.
767 It decodes non us-ascii characters in FULL-NAME encoded as
768 encoded-words or invalid \"raw\" string. \"Raw\" non us-ascii
769 characters are regarded as variable `default-mime-charset'.
771 If an encoded-word is broken or your emacs implementation can not
772 decode the charset included in it, it is not decoded.
774 If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
775 if there are in decoded encoded-words (generated by bad manner MUA
776 such as a version of Net$cape)."
777 (eword-decode-string string must-unfold default-mime-charset))
779 (defun eword-extract-address-components (string)
780 "Extract full name and canonical address from STRING.
781 Returns a list of the form (FULL-NAME CANONICAL-ADDRESS).
782 If no name can be extracted, FULL-NAME will be nil.
783 It decodes non us-ascii characters in FULL-NAME encoded as
784 encoded-words or invalid \"raw\" string. \"Raw\" non us-ascii
785 characters are regarded as variable `default-mime-charset'."
786 (let* ((structure (car (std11-parse-address
787 (eword-lexical-analyze
788 (std11-unfold-string string) 'must-unfold))))
789 (phrase (std11-full-name-string structure))
790 (address (std11-address-string structure))
792 (list phrase address)
799 (provide 'eword-decode)
801 ;;; eword-decode.el ends here