3 files changed, 235 insertions, 231 deletions

diff --git a/lisp/international/iso-cvt.el b/lisp/international/iso-cvt.el
index b0dffc40f50..d7baabb29c8 100644
--- a/lisp/international/iso-cvt.el
+++ b/lisp/international/iso-cvt.el
@@ -1,7 +1,8 @@
 ;;; iso-cvt.el --- translate ISO 8859-1 from/to various encodings -*- coding: iso-latin-1 -*-
 ;; This file was formerly called gm-lingo.el.
 
-;; Copyright (C) 1993, 1994, 1995, 1996, 1998, 2000 Free Software Foundation, Inc.
+;; Copyright (C) 1993, 1994, 1995, 1996, 1998, 2000, 2003, 2004
+;;           Free Software Foundation, Inc.
 
 ;; Author: Michael Gschwind <mike@vlsivie.tuwien.ac.at>
 ;; Keywords: tex, iso, latin, i18n
@@ -828,69 +829,67 @@ Optional arg BUFFER is ignored (for use in `format-alist')."
 
 ;;;###autoload
 (defun iso-cvt-define-menu ()
-  "Add submenus to the Files menu, to convert to and from various formats."
+  "Add submenus to the File menu, to convert to and from various formats."
   (interactive)
 
-  (define-key menu-bar-files-menu [load-as-separator] '("--"))
-
-  (define-key menu-bar-files-menu [load-as] '("Load As..."  . load-as))
-  (defvar load-as-menu-map (make-sparse-keymap "Load As..."))
-  (fset 'load-as load-as-menu-map)
-
-  ;;(define-key menu-bar-files-menu [insert-as] '("Insert As..."  . insert-as))
-  (defvar insert-as-menu-map (make-sparse-keymap "Insert As..."))
-  (fset 'insert-as insert-as-menu-map)
-
-  (define-key menu-bar-files-menu [write-as] '("Write As..."  . write-as))
-  (defvar write-as-menu-map (make-sparse-keymap "Write As..."))
-  (fset 'write-as write-as-menu-map)
-
-  (define-key menu-bar-files-menu [translate-separator] '("--"))
-
-  (define-key menu-bar-files-menu [translate-to] '("Translate to..."  . translate-to))
-  (defvar translate-to-menu-map (make-sparse-keymap "Translate to..."))
-  (fset 'translate-to translate-to-menu-map)
-
-  (define-key menu-bar-files-menu [translate-from] '("Translate from..."  . translate-from))
-  (defvar translate-from-menu-map (make-sparse-keymap "Translate from..."))
-  (fset 'translate-from translate-from-menu-map)
-
-  (let ((file-types (reverse format-alist))
-        name
-        str-name)
-    (while file-types
-      (setq name (car (car file-types))
-            str-name (car (cdr (car file-types)))
-            file-types (cdr file-types))
-      (if (stringp str-name)
-          (progn
-            (define-key load-as-menu-map (vector name)
-              (cons str-name
-                    `(lambda (file)
-                       (interactive (format "FFind file (as %s): " ,name))
-                       (format-find-file file ',name))))
-            (define-key insert-as-menu-map (vector name)
-              (cons str-name
-                    `(lambda (file)
-                       (interactive (format "FInsert file (as %s): " ,name))
-                       (format-insert-file file ',name))))
-            (define-key write-as-menu-map (vector name)
-              (cons str-name
-                    `(lambda (file)
-                       (interactive (format "FWrite file (as %s): " ,name))
-                          (format-write-file file ',name))))
-            (define-key translate-to-menu-map (vector name)
-              (cons str-name
-                    `(lambda ()
-                       (interactive)
-                          (format-encode-buffer ',name))))
-            (define-key translate-from-menu-map (vector name)
-              (cons str-name
-                    `(lambda ()
-                       (interactive)
-                       (format-decode-buffer ',name)))))))))
+  (let ((load-as-menu-map (make-sparse-keymap "Load As..."))
+        (insert-as-menu-map (make-sparse-keymap "Insert As..."))
+        (write-as-menu-map (make-sparse-keymap "Write As..."))
+        (translate-to-menu-map (make-sparse-keymap "Translate to..."))
+        (translate-from-menu-map (make-sparse-keymap "Translate from..."))
+        (menu menu-bar-file-menu))
+        
+    (define-key menu [load-as-separator] '("--"))
+
+    (define-key menu [load-as] '("Load As..." . iso-cvt-load-as))
+    (fset 'iso-cvt-load-as load-as-menu-map)
+
+    ;;(define-key menu [insert-as] '("Insert As..." . iso-cvt-insert-as))
+    (fset 'iso-cvt-insert-as insert-as-menu-map)
+
+    (define-key menu [write-as] '("Write As..." . iso-cvt-write-as))
+    (fset 'iso-cvt-write-as write-as-menu-map)
+
+    (define-key menu [translate-separator] '("--"))
+
+    (define-key menu [translate-to] '("Translate to..." . iso-cvt-translate-to))
+    (fset 'iso-cvt-translate-to translate-to-menu-map)
+
+    (define-key menu [translate-from] '("Translate from..." . iso-cvt-translate-from))
+    (fset 'iso-cvt-translate-from translate-from-menu-map)
+
+    (dolist (file-type (reverse format-alist))
+      (let ((name (car file-type))
+            (str-name (cadr file-type)))
+        (if (stringp str-name)
+            (progn
+              (define-key load-as-menu-map (vector name)
+                (cons str-name
+                      `(lambda (file)
+                         (interactive ,(format "FFind file (as %s): " name))
+                         (format-find-file file ',name))))
+              (define-key insert-as-menu-map (vector name)
+                (cons str-name
+                      `(lambda (file)
+                         (interactive (format "FInsert file (as %s): " ,name))
+                         (format-insert-file file ',name))))
+              (define-key write-as-menu-map (vector name)
+                (cons str-name
+                      `(lambda (file)
+                         (interactive (format "FWrite file (as %s): " ,name))
+                         (format-write-file file ',name))))
+              (define-key translate-to-menu-map (vector name)
+                (cons str-name
+                      `(lambda ()
+                         (interactive)
+                         (format-encode-buffer ',name))))
+              (define-key translate-from-menu-map (vector name)
+                (cons str-name
+                      `(lambda ()
+                         (interactive)
+                         (format-decode-buffer ',name))))))))))
 
 (provide 'iso-cvt)
 
-;;; arch-tag: 64ae843f-ed0e-43e1-ba50-ffd581b90840
+;; arch-tag: 64ae843f-ed0e-43e1-ba50-ffd581b90840
 ;;; iso-cvt.el ends here
diff --git a/lisp/international/mule-cmds.el b/lisp/international/mule-cmds.el
index 510a3c9358d..404ee5529f8 100644
--- a/lisp/international/mule-cmds.el
+++ b/lisp/international/mule-cmds.el
@@ -1,7 +1,8 @@
 ;;; mule-cmds.el --- commands for mulitilingual environment -*-coding: iso-2022-7bit -*-
+
+;; Copyright (C) 2000, 2001, 2002, 2003, 2004  Free Software Foundation, Inc.
 ;; Copyright (C) 1995, 2003 Electrotechnical Laboratory, JAPAN.
 ;; Licensed to the Free Software Foundation.
-;; Copyright (C) 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
 
 ;; Keywords: mule, multilingual
 
@@ -625,6 +626,175 @@ The meaning is the same as the argument ACCEPT-DEFAULT-P of the
 function `select-safe-coding-system' (which see).  This variable
 overrides that argument.")
 
+(defun select-safe-coding-system-interactively (from to codings unsafe
+                                                &optional rejected default)
+  "Select interactively a coding system for the region FROM ... TO.
+FROM can be a string, as in `write-region'.
+CODINGS is the list of base coding systems known to be safe for this region,
+  typically obtained with `find-coding-systems-region'.
+UNSAFE is a list of coding systems known to be unsafe for this region.
+REJECTED is a list of coding systems which were safe but for some reason
+  were not recommended in the particular context.
+DEFAULT is the coding system to use by default in the query."
+  ;; At first, if some defaults are unsafe, record at most 11
+  ;; problematic characters and their positions for them by turning
+  ;;    (CODING ...)
+  ;; into
+  ;;    ((CODING (POS . CHAR) (POS . CHAR) ...) ...)
+  (if unsafe
+      (setq unsafe
+            (mapcar #'(lambda (coding)
+                        (cons coding
+                              (if (stringp from)
+                                  (mapcar #'(lambda (pos)
+                                              (cons pos (aref from pos)))
+                                          (unencodable-char-position
+                                           0 (length from) coding
+                                           11 from))
+                                (mapcar #'(lambda (pos)
+                                            (cons pos (char-after pos)))
+                                        (unencodable-char-position
+                                         from to coding 11)))))
+                    unsafe)))
+
+  ;; Change each safe coding system to the corresponding
+  ;; mime-charset name if it is also a coding system.  Such a name
+  ;; is more friendly to users.
+  (let ((l codings)
+        mime-charset)
+    (while l
+      (setq mime-charset (coding-system-get (car l) 'mime-charset))
+      (if (and mime-charset (coding-system-p mime-charset))
+          (setcar l mime-charset))
+      (setq l (cdr l))))
+
+  ;; Don't offer variations with locking shift, which you
+  ;; basically never want.
+  (let (l)
+    (dolist (elt codings (setq codings (nreverse l)))
+      (unless (or (eq 'coding-category-iso-7-else
+                      (coding-system-category elt))
+                  (eq 'coding-category-iso-8-else
+                      (coding-system-category elt)))
+        (push elt l))))
+
+  ;; Remove raw-text, emacs-mule and no-conversion unless nothing
+  ;; else is available.
+  (setq codings
+        (or (delq 'raw-text
+                  (delq 'emacs-mule
+                        (delq 'no-conversion codings)))
+            '(raw-text emacs-mule no-conversion)))
+
+  (let ((window-configuration (current-window-configuration))
+        (bufname (buffer-name))
+        coding-system)
+    (save-excursion
+      ;; If some defaults are unsafe, make sure the offending
+      ;; buffer is displayed.
+      (when (and unsafe (not (stringp from)))
+        (pop-to-buffer bufname)
+        (goto-char (apply 'min (mapcar #'(lambda (x) (car (cadr x)))
+                                       unsafe))))
+      ;; Then ask users to select one from CODINGS while showing
+      ;; the reason why none of the defaults are not used.
+      (with-output-to-temp-buffer "*Warning*"
+        (with-current-buffer standard-output
+          (if (and (null rejected) (null unsafe))
+              (insert "No default coding systems to try for "
+                      (if (stringp from)
+                          (format "string \"%s\"." from)
+                        (format "buffer `%s'." bufname)))
+            (insert
+             "These default coding systems were tried to encode"
+             (if (stringp from)
+                 (concat " \"" (if (> (length from) 10)
+                                   (concat (substring from 0 10) "...\"")
+                                 (concat from "\"")))
+               (format " text\nin the buffer `%s'" bufname))
+             ":\n")
+            (let ((pos (point))
+                  (fill-prefix "  "))
+              (dolist (x (append rejected unsafe))
+                (princ "  ") (princ (car x)))
+              (insert "\n")
+              (fill-region-as-paragraph pos (point)))
+            (when rejected
+              (insert "These safely encodes the target text,
+but it is not recommended for encoding text in this context,
+e.g., for sending an email message.\n ")
+              (dolist (x rejected)
+                (princ " ") (princ x))
+              (insert "\n"))
+            (when unsafe
+              (insert (if rejected "And the others"
+                        "However, each of them")
+                      " encountered these problematic characters:\n")
+              (dolist (coding unsafe)
+                (insert (format "  %s:" (car coding)))
+                (let ((i 0)
+                      (func1
+                       #'(lambda (bufname pos)
+                           (when (buffer-live-p (get-buffer bufname))
+                             (pop-to-buffer bufname)
+                             (goto-char pos))))
+                      (func2
+                       #'(lambda (bufname pos coding)
+                           (when (buffer-live-p (get-buffer bufname))
+                             (pop-to-buffer bufname)
+                             (if (< (point) pos)
+                                 (goto-char pos)
+                               (forward-char 1)
+                               (search-unencodable-char coding)
+                               (forward-char -1))))))
+                  (dolist (elt (cdr coding))
+                    (insert " ")
+                    (if (stringp from)
+                        (insert (if (< i 10) (cdr elt) "..."))
+                      (if (< i 10)
+                          (insert-text-button
+                           (cdr elt)
+                           :type 'help-xref
+                           'help-echo
+                           "mouse-2, RET: jump to this character"
+                           'help-function func1
+                           'help-args (list bufname (car elt)))
+                        (insert-text-button
+                         "..."
+                         :type 'help-xref
+                         'help-echo
+                         "mouse-2, RET: next unencodable character"
+                         'help-function func2
+                         'help-args (list bufname (car elt)
+                                          (car coding)))))
+                    (setq i (1+ i))))
+                (insert "\n"))
+              (insert "\
+The first problematic character is at point in the displayed buffer,\n"
+                      (substitute-command-keys "\
+and \\[universal-argument] \\[what-cursor-position] will give information about it.\n"))))
+          (insert "\nSelect \
+one of the following safe coding systems, or edit the buffer:\n")
+          (let ((pos (point))
+                (fill-prefix "  "))
+            (dolist (x codings)
+              (princ "  ") (princ x))
+            (insert "\n")
+            (fill-region-as-paragraph pos (point)))
+          (insert "Or specify any other coding system
+at the risk of losing the problematic characters.\n")))
+
+      ;; Read a coding system.
+      (setq coding-system
+            (read-coding-system
+             (format "Select coding system (default %s): " default)
+             default))
+      (setq last-coding-system-specified coding-system))
+
+    (kill-buffer "*Warning*")
+    (set-window-configuration window-configuration)
+    coding-system))
+
 (defun select-safe-coding-system (from to &optional default-coding-system
                                        accept-default-p file)
   "Ask a user to select a safe coding system from candidates.
@@ -721,7 +891,6 @@ and TO is ignored."
 
   (let ((codings (find-coding-systems-region from to))
         (coding-system nil)
-        (bufname (buffer-name))
         safe rejected unsafe)
     (if (eq (car codings) 'undecided)
         ;; Any coding system is ok.
@@ -739,172 +908,8 @@ and TO is ignored."
 
     ;; If all the defaults failed, ask a user.
     (when (not coding-system)
-      ;; At first, if some defaults are unsafe, record at most 11
-      ;; problematic characters and their positions for them by turning
-      ;;        (CODING ...)
-      ;; into
-      ;;        ((CODING (POS . CHAR) (POS . CHAR) ...) ...)
-      (if unsafe
-          (if (stringp from)
-              (setq unsafe
-                    (mapcar #'(lambda (coding)
-                                (cons coding
-                                      (mapcar #'(lambda (pos)
-                                                  (cons pos (aref from pos)))
-                                              (unencodable-char-position
-                                               0 (length from) coding
-                                               11 from))))
-                            unsafe))
-            (setq unsafe
-                  (mapcar #'(lambda (coding)
-                              (cons coding
-                                    (mapcar #'(lambda (pos)
-                                                (cons pos (char-after pos)))
-                                            (unencodable-char-position
-                                             from to coding 11))))
-                          unsafe))))
-
-      ;; Change each safe coding system to the corresponding
-      ;; mime-charset name if it is also a coding system.  Such a name
-      ;; is more friendly to users.
-      (let ((l codings)
-            mime-charset)
-        (while l
-          (setq mime-charset (coding-system-get (car l) 'mime-charset))
-          (if (and mime-charset (coding-system-p mime-charset))
-              (setcar l mime-charset))
-          (setq l (cdr l))))
-
-      ;; Don't offer variations with locking shift, which you
-      ;; basically never want.
-      (let (l)
-        (dolist (elt codings (setq codings (nreverse l)))
-          (unless (or (eq 'coding-category-iso-7-else
-                          (coding-system-category elt))
-                      (eq 'coding-category-iso-8-else
-                          (coding-system-category elt)))
-            (push elt l))))
-
-      ;; Remove raw-text, emacs-mule and no-conversion unless nothing
-      ;; else is available.
-      (setq codings
-            (or (delq 'raw-text
-                      (delq 'emacs-mule
-                            (delq 'no-conversion codings)))
-                '(raw-text emacs-mule no-conversion)))
-
-      (let ((window-configuration (current-window-configuration)))
-        (save-excursion
-          ;; If some defaults are unsafe, make sure the offending
-          ;; buffer is displayed.
-          (when (and unsafe (not (stringp from)))
-            (pop-to-buffer bufname)
-            (goto-char (apply 'min (mapcar #'(lambda (x) (car (cadr x)))
-                                           unsafe))))
-          ;; Then ask users to select one from CODINGS while showing
-          ;; the reason why none of the defaults are not used.
-          (with-output-to-temp-buffer "*Warning*"
-            (save-excursion
-              (set-buffer standard-output)
-              (if (not default-coding-system)
-                  (insert "No default coding systems to try for "
-                          (if (stringp from)
-                              (format "string \"%s\"." from)
-                            (format "buffer `%s'." bufname)))
-                (insert
-                 "These default coding systems were tried to encode"
-                 (if (stringp from)
-                     (concat " \"" (if (> (length from) 10)
-                                       (concat (substring from 0 10) "...\"")
-                                     (concat from "\"")))
-                   (format " text\nin the buffer `%s'" bufname))
-                 ":\n")
-                (let ((pos (point))
-                      (fill-prefix "  "))
-                  (mapc #'(lambda (x) (princ "  ") (princ (car x)))
-                        default-coding-system)
-                  (insert "\n")
-                  (fill-region-as-paragraph pos (point)))
-                (when rejected
-                  (insert "These safely encodes the target text,
-but it is not recommended for encoding text in this context,
-e.g., for sending an email message.\n ")
-                  (mapc #'(lambda (x) (princ " ") (princ x)) rejected)
-                  (insert "\n"))
-                (when unsafe
-                  (insert (if rejected "And the others"
-                            "However, each of them")
-                          " encountered these problematic characters:\n")
-                  (mapc
-                   #'(lambda (coding)
-                       (insert (format "  %s:" (car coding)))
-                       (let ((i 0)
-                             (func1
-                              #'(lambda (bufname pos)
-                                  (when (buffer-live-p (get-buffer bufname))
-                                    (pop-to-buffer bufname)
-                                    (goto-char pos))))
-                             (func2
-                              #'(lambda (bufname pos coding)
-                                  (when (buffer-live-p (get-buffer bufname))
-                                    (pop-to-buffer bufname)
-                                    (if (< (point) pos)
-                                        (goto-char pos)
-                                      (forward-char 1)
-                                      (search-unencodable-char coding)
-                                      (forward-char -1))))))
-                         (dolist (elt (cdr coding))
-                           (insert " ")
-                           (if (stringp from)
-                               (insert (if (< i 10) (cdr elt) "..."))
-                             (if (< i 10)
-                                 (insert-text-button
-                                  (cdr elt)
-                                  :type 'help-xref
-                                  'help-echo
-                                  "mouse-2, RET: jump to this character"
-                                  'help-function func1
-                                  'help-args (list bufname (car elt)))
-                               (insert-text-button
-                                "..."
-                                :type 'help-xref
-                                'help-echo
-                                "mouse-2, RET: next unencodable character"
-                                'help-function func2
-                                'help-args (list bufname (car elt)
-                                                 (car coding)))))
-                           (setq i (1+ i))))
-                       (insert "\n"))
-                   unsafe)
-                  (insert "\
-The first problematic character is at point in the displayed buffer,\n"
-                          (substitute-command-keys "\
-and \\[universal-argument] \\[what-cursor-position] will give information about it.\n"))))
-              (insert (if safe
-                          "\nSelect the above, or "
-                        "\nSelect ")
-                      "\
-one of the following safe coding systems, or edit the buffer:\n")
-              (let ((pos (point))
-                    (fill-prefix "  "))
-                (mapcar (function (lambda (x) (princ "  ") (princ x)))
-                        codings)
-                (insert "\n")
-                (fill-region-as-paragraph pos (point)))
-              (insert "Or specify any other coding system
-at the risk of losing the problematic characters.\n")))
-
-          ;; Read a coding system.
-          (setq default-coding-system (or (car safe) (car codings)))
-          (setq coding-system
-                (read-coding-system
-                 (format "Select coding system (default %s): "
-                         default-coding-system)
-                 default-coding-system))
-          (setq last-coding-system-specified coding-system))
-
-        (kill-buffer "*Warning*")
-        (set-window-configuration window-configuration)))
+      (setq coding-system (select-safe-coding-system-interactively
+                           from to codings unsafe rejected (car codings))))
 
     (if (vectorp (coding-system-eol-type coding-system))
         (let ((eol (coding-system-eol-type buffer-file-coding-system)))
@@ -2627,5 +2632,5 @@ If CODING-SYSTEM can't safely encode CHAR, return nil."
       (substring enc2 0 i2))))
 
 
-;;; arch-tag: b382c432-4b36-460e-bf4c-05efd0bb18dc
+;; arch-tag: b382c432-4b36-460e-bf4c-05efd0bb18dc
 ;;; mule-cmds.el ends here
diff --git a/lisp/international/mule.el b/lisp/international/mule.el
index f5294fea92f..9136a257ee1 100644
--- a/lisp/international/mule.el
+++ b/lisp/international/mule.el
@@ -2126,7 +2126,7 @@ This function is intended to be added to `auto-coding-functions'."
                   (save-excursion
                     (forward-line 10)
                     (point))))
-  (when (and (search-forward "<html>" size t)
+  (when (and (search-forward "<html" size t)
              (re-search-forward "<meta\\s-+http-equiv=\"content-type\"\\s-+content=\"text/\\sw+;\\s-*charset=\\(.+?\\)\"" size t))
       (let* ((match (match-string 1))
              (sym (intern (downcase match))))