fixed.

[elisp/flim.git] / eword-decode.el

diff --git a/eword-decode.el b/eword-decode.el
index a8f34b5..4663610 100644 (file)
--- a/eword-decode.el
+++ b/eword-decode.el
@@ -82,7 +82,7 @@ however this behaviour violates RFC2047."
   (concat eword-encoded-word-prefix-regexp
          "\\(" eword-encoded-text-in-phrase-regexp "\\)"
          eword-encoded-word-suffix-regexp))
-(defconst eword-after-encoded-word-in-phrase-regexp "\\([ \t(]\\|$\\)")
+(defconst eword-after-encoded-word-in-phrase-regexp "\\([ \t]\\|$\\)")
 
 (defconst eword-encoded-text-in-comment-regexp "[]!-'*->@-[^-~]+")
 (defconst eword-encoded-word-in-comment-regexp
@@ -369,17 +369,17 @@ default-mime-charset."
 ;;;
 
 (defcustom eword-decode-ignored-field-list
-  '(newsgroups path lines nntp-posting-host received message-id date)
+  '(Newsgroups Path Lines Nntp-Posting-Host Received Message-Id Date)
   "*List of field-names to be ignored when decoding.
 Each field name must be symbol."
   :group 'eword-decode
   :type '(repeat symbol))
 
 (defcustom eword-decode-structured-field-list
-  '(reply-to resent-reply-to from resent-from sender resent-sender
-            to resent-to cc resent-cc bcc resent-bcc dcc
-            mime-version content-type content-transfer-encoding
-            content-disposition)
+  '(Reply-To Resent-Reply-To From Resent-From Sender Resent-Sender
+            To Resent-To Cc Resent-Cc Bcc Resent-Bcc Dcc
+            Mime-Version Content-Type Content-Transfer-Encoding
+            Content-Disposition)
   "*List of field-names to decode as structured field.
 Each field name must be symbol."
   :group 'eword-decode
@@ -407,7 +407,7 @@ If SEPARATOR is not nil, it is used as header separator."
                    p (match-end 0)
                    field-name (buffer-substring beg (1- p))
                    len (string-width field-name)
-                   field-name (intern (downcase field-name))
+                   field-name (intern (capitalize field-name))
                    end (std11-field-end))
              (cond ((memq field-name eword-decode-ignored-field-list)
                     ;; Don't decode
@@ -527,21 +527,18 @@ as a version of Net$cape)."
                  (error "Invalid encoding %s" encoding)
                  )))
               )
-         (if dest
-             (progn
-               (setq dest (decode-coding-string dest cs))
-               (if must-unfold
-                   (mapconcat (function
-                               (lambda (chr)
-                                 (cond
-                                   ((eq chr ?\n) "")
-                                   ((eq chr ?\t) " ")
-                                   (t (char-to-string chr)))
-                                 ))
-                              (std11-unfold-string dest)
-                              "")
-                 dest)
-               ))))))
+         (when dest
+           (setq dest (decode-mime-charset-string dest charset))
+           (if must-unfold
+               (mapconcat (function
+                           (lambda (chr)
+                             (cond ((eq chr ?\n) "")
+                                   ((eq chr ?\t) " ")
+                                   (t (char-to-string chr)))
+                             ))
+                          (std11-unfold-string dest)
+                          "")
+             dest))))))
 
 
 ;;; @ lexical analyze
@@ -578,12 +575,18 @@ be the result."
 (defun eword-analyze-quoted-string (string &optional must-unfold)
   (let ((p (std11-check-enclosure string ?\" ?\")))
     (if p
-       (cons (cons 'quoted-string
-                   (eword-decode-quoted-string
-                     (substring string 0 p)
-                     default-mime-charset))
-             (substring string p))
-      )))
+        (cons (cons 'quoted-string
+                    (if eword-decode-quoted-encoded-word
+                        (std11-wrap-as-quoted-string
+                         (eword-decode-quoted-string
+                          (substring string 1 (1- p))
+                          default-mime-charset))
+                      (std11-wrap-as-quoted-string
+                       (decode-mime-charset-string
+                        (std11-strip-quoted-pair (substring string 1 (1- p)))
+                        default-mime-charset))))
+              (substring string p)))
+    ))
 
 (defun eword-analyze-domain-literal (string &optional must-unfold)
   (std11-analyze-domain-literal string))
@@ -610,12 +613,20 @@ be the result."
 
 (defun eword-analyze-encoded-word (string &optional must-unfold)
   (let ((decoded (eword-decode-first-encoded-words
-                  string
-                  eword-encoded-word-in-phrase-regexp
-                  eword-after-encoded-word-in-phrase-regexp
-                  must-unfold)))
+                  string
+                  eword-encoded-word-in-phrase-regexp
+                  eword-after-encoded-word-in-phrase-regexp
+                  must-unfold)))
     (if decoded
-      (cons (cons 'atom (car decoded)) (cdr decoded)))))
+        (let ((s (car decoded)))
+          (while (or (string-match std11-atom-regexp s)
+                     (string-match std11-spaces-regexp s))
+            (setq s (substring s (match-end 0))))
+          (if (= (length s) 0)
+              (cons (cons 'atom (car decoded)) (cdr decoded))
+            (cons (cons 'quoted-string
+                        (std11-wrap-as-quoted-string (car decoded)))
+                  (cdr decoded)))))))
 
 (defun eword-analyze-atom (string &optional must-unfold)
   (if (let ((enable-multibyte-characters nil))
@@ -633,17 +644,24 @@ be the result."
              ))))
 
 (defun eword-lexical-analyze-internal (string must-unfold)
-  (let (dest ret)
+  (let ((last 'eword-analyze-spaces)
+        dest ret)
     (while (not (string-equal string ""))
       (setq ret
-           (let ((rest eword-lexical-analyzers)
-                 func r)
-             (while (and (setq func (car rest))
-                         (null (setq r (funcall func string must-unfold)))
-                         )
-               (setq rest (cdr rest)))
-             (or r `((error . ,string) . ""))
-             ))
+            (let ((rest eword-lexical-analyzers)
+                  func r)
+              (while (and (setq func (car rest))
+                          (or
+                           (and
+                            (not eword-decode-sticked-encoded-word)
+                            (not (eq last 'eword-analyze-spaces))
+                            (eq func 'eword-analyze-encoded-word))
+                           (null (setq r (funcall func string must-unfold))))
+                          )
+                (setq rest (cdr rest)))
+              (setq last func)
+              (or r `((error . ,string) . ""))
+              ))
       (setq dest (cons (car ret) dest))
       (setq string (cdr ret))
       )