Revision: miles@gnu.org--gnu-2005/emacs--unicode--0--patch-68

Merge from emacs--cvs-trunk--0

Patches applied:

 * emacs--cvs-trunk--0  (patch 459-473)

   - Update from CVS
   - Merge from gnus--rel--5.10

 * gnus--rel--5.10  (patch 86-87)

   - Update from CVS

diff --cc configure
Simple merge

diff --cc configure.in
Simple merge

diff --cc etc/NEWS
Simple merge

diff --cc etc/PROBLEMS
Simple merge

diff --cc etc/ps-prin1.ps
Simple merge

diff --cc leim/Makefile.in
Simple merge

diff --cc leim/quail/cyrillic.el
Simple merge

diff --cc leim/quail/indian.el
Simple merge

diff --cc leim/quail/latin-alt.el
Simple merge

diff --cc leim/quail/latin-post.el
Simple merge

diff --cc leim/quail/latin-pre.el
Simple merge

diff --cc leim/quail/pypunct-b5.el
Simple merge

diff --cc leim/quail/symbol-ksc.el
Simple merge

diff --cc leim/quail/thai.el
Simple merge

diff --cc leim/quail/tibetan.el
Simple merge

diff --cc leim/quail/uni-input.el
Simple merge

diff --cc leim/quail/welsh.el
Simple merge

diff --cc lisp/ChangeLog
Simple merge

diff --cc lisp/Makefile.in
Simple merge

diff --cc lisp/arc-mode.el
index ac2869a,b049f8e..2cf578a
--- 1/lisp/arc-mode.el
--- 2/lisp/arc-mode.el
+++ b/lisp/arc-mode.el
@@@ -737,7 -707,8 +730,7 @@@ is visible (and the real data of the bu
  Optional argument SHUT-UP, if non-nil, means don't print messages
  when parsing the archive."
    (widen)
-   (let (buffer-read-only)
 -  (set-buffer-multibyte nil)
+   (let ((inhibit-read-only t))
      (or shut-up
        (message "Parsing archive file..."))
      (buffer-disable-undo (current-buffer))
@@@ -965,10 -927,8 +950,9 @@@ using `make-temp-file', and the generat
            (setq default-directory arcdir)
            (make-local-variable 'archive-superior-buffer)
            (setq archive-superior-buffer archive-buffer)
-           (make-local-variable 'local-write-file-hooks)
-           (add-hook 'local-write-file-hooks 'archive-write-file-member)
+           (add-hook 'write-file-functions 'archive-write-file-member nil t)
            (setq archive-subfile-mode descr)
 +        (setq archive-file-name-coding-system file-name-coding)
          (if (and
               (null
                (let (;; We may have to encode file name arguement for
@@@ -1340,9 -1292,10 +1317,9 @@@ as a relative change like \"g+rw\" as f
        (descr (archive-get-descr)))
      (if (fboundp func)
          (progn
-         (funcall func (buffer-file-name)
+         (funcall func
 -                 (if enable-multibyte-characters
 -                     (encode-coding-string newname file-name-coding-system)
 -                   newname)
 +                 (encode-coding-string newname
 +                                       archive-file-name-coding-system)
                   descr)
          (archive-resummarize))
        (error "Renaming is not supported for this archive type"))))
@@@ -1446,30 -1400,27 +1423,26 @@@ This doesn't recover lost files, it jus
               (ucsize  (archive-l-e (+ p 11) 4))       ;size of an uncompressed file.
             (time1   (archive-l-e (+ p 15) 2)) ;date/time (MSDOS format in level 0, 1 headers
             (time2   (archive-l-e (+ p 17) 2)) ;and UNIX format in level 2 header.)
 -           (hdrlvl  (char-after (+ p 20))) ;header level
 +           (hdrlvl  (byte-after (+ p 20))) ;header level
             thsize             ;total header size (base + extensions)
-            fnlen efnname fiddle ifnname width p2 creator
+            fnlen efnname fiddle ifnname width p2
             neh        ;beginning of next extension header (level 1 and 2)
             mode modestr uid gid text dir prname
             gname uname modtime moddate)
        (if (= hdrlvl 3) (error "can't handle lzh level 3 header type"))
        (when (or (= hdrlvl 0) (= hdrlvl 1))
 -        (setq fnlen   (char-after (+ p 21))) ;filename length
 +        (setq fnlen   (byte-after (+ p 21))) ;filename length
          (setq efnname (let ((str (buffer-substring (+ p 22) (+ p 22 fnlen)))) ;filename from offset 22
 -                      (if file-name-coding-system
 -                          (decode-coding-string str file-name-coding-system)
 -                        (string-as-multibyte str))))
 +                      (decode-coding-string
 +                       str archive-file-name-coding-system)))
          (setq p2      (+ p 22 fnlen))) ;
        (if (= hdrlvl 1)
-           (progn              ;specific to level 1 header
-             (setq creator (if (>= (- hsize fnlen) 24) (byte-after (+ p2 2)) 0))
-             (setq neh (+ p2 3)))
+             (setq neh (+ p2 3))         ;specific to level 1 header
          (if (= hdrlvl 2)
-             (progn            ;specific to level 2 header
-               (setq creator (byte-after (+ p 23)) )
-               (setq neh (+ p 24)))))
+               (setq neh (+ p 24))))     ;specific to level 2 header
        (if neh         ;if level 1 or 2 we expect extension headers to follow
            (let* ((ehsize (archive-l-e neh 2)) ;size of the extension header
 -                 (etype (char-after (+ neh 2)))) ;extension type
 +                 (etype (byte-after (+ neh 2)))) ;extension type
              (while (not (= ehsize 0))
                  (cond
                 ((= etype 1)   ;file name
@@@ -1585,46 -1537,46 +1558,44 @@@
    (save-restriction
      (save-excursion
        (widen)
 -      (set-buffer-multibyte nil)
        (let* ((p        (+ archive-proper-file-start (aref descr 4)))
 -           (oldhsize (char-after p))
 -           (oldfnlen (char-after (+ p 21)))
 +           (oldhsize (byte-after p))
 +           (oldfnlen (byte-after (+ p 21)))
             (newfnlen (length newname))
             (newhsize (+ oldhsize newfnlen (- oldfnlen)))
-            buffer-read-only)
+            (inhibit-read-only t))
        (if (> newhsize 255)
            (error "The file name is too long"))
        (goto-char (+ p 21))
        (delete-char (1+ oldfnlen))
 -      (insert newfnlen newname)
 +      (insert-unibyte newfnlen newname)
        (goto-char p)
        (delete-char 2)
 -      (insert newhsize (archive-lzh-resum p newhsize))))))
 +      (insert-unibyte newhsize (archive-lzh-resum p newhsize))))))
  
  (defun archive-lzh-ogm (newval files errtxt ofs)
-   (save-restriction
-     (save-excursion
+   (save-excursion
+     (save-restriction
        (widen)
-       (while files
-       (let* ((fil (car files))
-              (p (+ archive-proper-file-start (aref fil 4)))
 -      (set-buffer-multibyte nil)
+       (dolist (fil files)
+       (let* ((p (+ archive-proper-file-start (aref fil 4)))
 -             (hsize   (char-after p))
 -             (fnlen   (char-after (+ p 21)))
 +             (hsize   (byte-after p))
 +             (fnlen   (byte-after (+ p 21)))
               (p2      (+ p 22 fnlen))
 -             (creator (if (>= (- hsize fnlen) 24) (char-after (+ p2 2)) 0))
 +             (creator (if (>= (- hsize fnlen) 24) (byte-after (+ p2 2)) 0))
-              buffer-read-only)
+              (inhibit-read-only t))
          (if (= creator ?U)
              (progn
                (or (numberp newval)
                    (setq newval (funcall newval (archive-l-e (+ p2 ofs) 2))))
                (goto-char (+ p2 ofs))
                (delete-char 2)
 -              (insert (logand newval 255) (lsh newval -8))
 +              (insert-unibyte (logand newval 255) (lsh newval -8))
                (goto-char (1+ p))
                (delete-char 1)
 -              (insert (archive-lzh-resum (1+ p) hsize)))
 +              (insert-unibyte (archive-lzh-resum (1+ p) hsize)))
            (message "Member %s does not have %s field"
-                    (aref fil 1) errtxt)))
-       (setq files (cdr files))))))
+                    (aref fil 1) errtxt)))))))
  
  (defun archive-lzh-chown-entry (newuid files)
    (archive-lzh-ogm newuid files "an uid" 10))
@@@ -1649,8 -1601,8 +1620,8 @@@
          files
        visual)
      (while (string= "PK\001\002" (buffer-substring p (+ p 4)))
 -      (let* ((creator (char-after (+ p 5)))
 +      (let* ((creator (byte-after (+ p 5)))
-            (method  (archive-l-e (+ p 10) 2))
+            ;; (method  (archive-l-e (+ p 10) 2))
               (modtime (archive-l-e (+ p 12) 2))
               (moddate (archive-l-e (+ p 14) 2))
               (ucsize  (archive-l-e (+ p 24) 4))
@@@ -1726,24 -1679,24 +1697,23 @@@
    (save-restriction
      (save-excursion
        (widen)
-       (while files
-       (let* ((fil (car files))
-              (p (+ archive-proper-file-start (car (aref fil 4))))
 -      (set-buffer-multibyte nil)
+       (dolist (fil files)
+       (let* ((p (+ archive-proper-file-start (car (aref fil 4))))
 -             (creator (char-after (+ p 5)))
 +             (creator (byte-after (+ p 5)))
               (oldmode (aref fil 3))
               (newval  (archive-calc-mode oldmode newmode t))
-              buffer-read-only)
+              (inhibit-read-only t))
          (cond ((memq creator '(2 3)) ; Unix + VMS
                 (goto-char (+ p 40))
                 (delete-char 2)
 -               (insert (logand newval 255) (lsh newval -8)))
 +               (insert-unibyte (logand newval 255) (lsh newval -8)))
                ((memq creator '(0 5 6 7 10 11 15)) ; Dos etc.
                 (goto-char (+ p 38))
 -               (insert (logior (logand (char-after (point)) 254)
 -                               (logand (logxor 1 (lsh newval -7)) 1)))
 +               (insert-unibyte (logior (logand (byte-after (point)) 254)
 +                                       (logand (logxor 1 (lsh newval -7)) 1)))
                 (delete-char 1))
                (t (message "Don't know how to change mode for this member"))))
-       (setq files (cdr files))))))
+         ))))
  ;; -------------------------------------------------------------------------
  ;; Section: Zoo Archives
  

diff --cc lisp/bindings.el
Simple merge

diff --cc lisp/case-table.el
Simple merge

diff --cc lisp/composite.el
Simple merge

diff --cc lisp/cus-start.el
Simple merge

diff --cc lisp/descr-text.el
Simple merge

diff --cc lisp/desktop.el
Simple merge

diff --cc lisp/disp-table.el
Simple merge

diff --cc lisp/edmacro.el
Simple merge

diff --cc lisp/emacs-lisp/byte-opt.el
Simple merge

diff --cc lisp/emacs-lisp/bytecomp.el
Simple merge

diff --cc lisp/emacs-lisp/cl-macs.el
Simple merge

diff --cc lisp/emacs-lisp/copyright.el
Simple merge

diff --cc lisp/emacs-lisp/generic.el
Simple merge

diff --cc lisp/emacs-lisp/regexp-opt.el
Simple merge

diff --cc lisp/emulation/keypad.el
Simple merge

diff --cc lisp/eshell/esh-mode.el
Simple merge

diff --cc lisp/eshell/esh-opt.el
Simple merge

diff --cc lisp/faces.el
Simple merge

diff --cc lisp/font-lock.el
Simple merge

diff --cc lisp/format.el
Simple merge

diff --cc lisp/gnus/gnus-start.el
Simple merge

diff --cc lisp/gnus/message.el
Simple merge

diff --cc lisp/gnus/mm-bodies.el
Simple merge

diff --cc lisp/gnus/mm-util.el
Simple merge

diff --cc lisp/gnus/mml.el
Simple merge

diff --cc lisp/gnus/qp.el
Simple merge

diff --cc lisp/gnus/rfc2047.el
Simple merge

diff --cc lisp/gnus/rfc2104.el
Simple merge

diff --cc lisp/gnus/utf7.el
Simple merge

diff --cc lisp/international/ccl.el
Simple merge

diff --cc lisp/international/characters.el
Simple merge

diff --cc lisp/international/codepage.el
Simple merge

diff --cc lisp/international/encoded-kb.el
Simple merge

diff --cc lisp/international/fontset.el
Simple merge

diff --cc lisp/international/ja-dic-cnv.el
Simple merge

diff --cc lisp/international/ja-dic-utl.el
Simple merge

diff --cc lisp/international/mule-cmds.el
index 4174bcd,bb69dbd..b84fb38
--- 1/lisp/international/mule-cmds.el
--- 2/lisp/international/mule-cmds.el
+++ b/lisp/international/mule-cmds.el
@@@ -324,9 -321,9 +324,11 @@@ This sets the following coding systems
    o coding system of a newly created buffer
    o default coding system for subprocess I/O
  This also sets the following values:
--  o default value used as `file-name-coding-system' for converting file names.
++  o default value used as `file-name-coding-system' for converting file names
++      if CODING-SYSTEM is ASCII-compatible.
    o default value for the command `set-terminal-coding-system' (not on MSDOS)
--  o default value for the command `set-keyboard-coding-system'."
++  o default value for the command `set-keyboard-coding-system'
++      if CODING-SYSTEM is ASCII-compatible.."
    (check-coding-system coding-system)
    (setq-default buffer-file-coding-system coding-system)
    (if (fboundp 'ucs-set-table-for-input)

diff --cc lisp/international/mule-conf.el
Simple merge

diff --cc lisp/international/mule-diag.el
Simple merge

diff --cc lisp/international/mule-util.el
Simple merge

diff --cc lisp/international/mule.el
Simple merge

diff --cc lisp/international/quail.el
Simple merge

diff --cc lisp/international/swedish.el
Simple merge

diff --cc lisp/international/titdic-cnv.el
Simple merge

diff --cc lisp/isearch.el
Simple merge

diff --cc lisp/language/china-util.el
Simple merge

diff --cc lisp/language/chinese.el
Simple merge

diff --cc lisp/language/cyril-util.el
Simple merge

diff --cc lisp/language/cyrillic.el
Simple merge

diff --cc lisp/language/czech.el
Simple merge

diff --cc lisp/language/devan-util.el
Simple merge

diff --cc lisp/language/devanagari.el
Simple merge

diff --cc lisp/language/english.el
Simple merge

diff --cc lisp/language/ethio-util.el
Simple merge

diff --cc lisp/language/ethiopic.el
Simple merge

diff --cc lisp/language/european.el
Simple merge

diff --cc lisp/language/georgian.el
Simple merge

diff --cc lisp/language/greek.el
Simple merge

diff --cc lisp/language/hebrew.el
Simple merge

diff --cc lisp/language/ind-util.el
Simple merge

diff --cc lisp/language/indian.el
Simple merge

diff --cc lisp/language/japanese.el
Simple merge

diff --cc lisp/language/kannada.el
Simple merge

diff --cc lisp/language/knd-util.el
Simple merge

diff --cc lisp/language/korean.el
Simple merge

diff --cc lisp/language/lao-util.el
Simple merge

diff --cc lisp/language/lao.el
Simple merge

diff --cc lisp/language/malayalam.el
Simple merge

diff --cc lisp/language/mlm-util.el
Simple merge

diff --cc lisp/language/romanian.el
Simple merge

diff --cc lisp/language/slovak.el
Simple merge

diff --cc lisp/language/tamil.el
Simple merge

diff --cc lisp/language/thai-util.el
Simple merge

diff --cc lisp/language/thai.el
Simple merge

diff --cc lisp/language/tibet-util.el
Simple merge

diff --cc lisp/language/tibetan.el
Simple merge

diff --cc lisp/language/tml-util.el
Simple merge

diff --cc lisp/language/utf-8-lang.el
Simple merge

diff --cc lisp/language/viet-util.el
Simple merge

diff --cc lisp/language/vietnamese.el
Simple merge

diff --cc lisp/loadup.el
Simple merge

diff --cc lisp/mail/rmail.el
Simple merge

diff --cc lisp/mail/sendmail.el
Simple merge

diff --cc lisp/makefile.w32-in
Simple merge

diff --cc lisp/progmodes/perl-mode.el
Simple merge

diff --cc lisp/progmodes/sh-script.el
Simple merge

diff --cc lisp/ps-bdf.el
Simple merge

diff --cc lisp/ps-mule.el
Simple merge

diff --cc lisp/ps-print.el
Simple merge

diff --cc lisp/ruler-mode.el
Simple merge

diff --cc lisp/simple.el
Simple merge

diff --cc lisp/startup.el
Simple merge

diff --cc lisp/subr.el
Simple merge

diff --cc lisp/tar-mode.el
Simple merge

diff --cc lisp/term.el
Simple merge

diff --cc lisp/term/mac-win.el
Simple merge

diff --cc lisp/term/w32-win.el
Simple merge

diff --cc lisp/term/x-win.el
Simple merge

diff --cc lisp/textmodes/ispell.el
Simple merge

diff --cc lisp/textmodes/sgml-mode.el
Simple merge

diff --cc lisp/textmodes/tex-mode.el
Simple merge

diff --cc lisp/time-stamp.el
Simple merge

diff --cc lisp/version.el
Simple merge

diff --cc lisp/w32-fns.el
Simple merge

diff --cc lisp/wid-edit.el
Simple merge

diff --cc src/.gdbinit
Simple merge

diff --cc src/ChangeLog
Simple merge

diff --cc src/Makefile.in
Simple merge

diff --cc src/abbrev.c
Simple merge

diff --cc src/alloc.c
Simple merge

diff --cc src/buffer.c
Simple merge

diff --cc src/buffer.h
Simple merge

diff --cc src/bytecode.c
Simple merge

diff --cc src/callproc.c
Simple merge

diff --cc src/casefiddle.c
Simple merge

diff --cc src/casetab.c
Simple merge

diff --cc src/category.c
Simple merge

diff --cc src/category.h
Simple merge

diff --cc src/ccl.c
Simple merge

diff --cc src/ccl.h
Simple merge

diff --cc src/charset.c
index e7b0800,e7b6897..bf4dfc5
--- 1/src/charset.c
--- 2/src/charset.c
+++ b/src/charset.c
@@@ -20,355 -17,238 +20,355 @@@ GNU General Public License for more det
  
  You should have received a copy of the GNU General Public License
  along with GNU Emacs; see the file COPYING.  If not, write to
- the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.  */
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.  */
  
 -/* At first, see the document in `charset.h' to understand the code in
 -   this file.  */
 -
 -#ifdef emacs
  #include <config.h>
 -#endif
  
  #include <stdio.h>
 -
 -#ifdef emacs
 -
 +#include <unistd.h>
 +#include <ctype.h>
  #include <sys/types.h>
  #include "lisp.h"
 -#include "buffer.h"
 +#include "character.h"
  #include "charset.h"
 -#include "composite.h"
  #include "coding.h"
  #include "disptab.h"
 +#include "buffer.h"
  
 -#else  /* not emacs */
 +/*** GENERAL NOTES on CODED CHARACTER SETS (CHARSETS) ***
  
 -#include "mulelib.h"
 +  A coded character set ("charset" hereafter) is a meaningful
 +  collection (i.e. language, culture, functionality, etc.) of
 +  characters.  Emacs handles multiple charsets at once.  In Emacs Lisp
 +  code, a charset is represented by a symbol.  In C code, a charset is
 +  represented by its ID number or by a pointer to a struct charset.
  
 -#endif /* emacs */
 +  The actual information about each charset is stored in two places.
 +  Lispy information is stored in the hash table Vcharset_hash_table as
 +  a vector (charset attributes).  The other information is stored in
 +  charset_table as a struct charset.
  
 -Lisp_Object Qcharset, Qascii, Qeight_bit_control, Qeight_bit_graphic;
 -Lisp_Object Qunknown;
 +*/
  
 -/* Declaration of special leading-codes.  */
 -EMACS_INT leading_code_private_11; /* for private DIMENSION1 of 1-column */
 -EMACS_INT leading_code_private_12; /* for private DIMENSION1 of 2-column */
 -EMACS_INT leading_code_private_21; /* for private DIMENSION2 of 1-column */
 -EMACS_INT leading_code_private_22; /* for private DIMENSION2 of 2-column */
 +/* List of all charsets.  This variable is used only from Emacs
 +   Lisp.  */
 +Lisp_Object Vcharset_list;
  
 -/* Declaration of special charsets.  The values are set by
 -   Fsetup_special_charsets.  */
 -int charset_latin_iso8859_1;  /* ISO8859-1 (Latin-1) */
 -int charset_jisx0208_1978;    /* JISX0208.1978 (Japanese Kanji old set) */
 -int charset_jisx0208;         /* JISX0208.1983 (Japanese Kanji) */
 -int charset_katakana_jisx0201;        /* JISX0201.Kana (Japanese Katakana) */
 -int charset_latin_jisx0201;   /* JISX0201.Roman (Japanese Roman) */
 -int charset_big5_1;           /* Big5 Level 1 (Chinese Traditional) */
 -int charset_big5_2;           /* Big5 Level 2 (Chinese Traditional) */
 +/* Hash table that contains attributes of each charset.  Keys are
 +   charset symbols, and values are vectors of charset attributes.  */
 +Lisp_Object Vcharset_hash_table;
  
 -Lisp_Object Qcharset_table;
 +/* Table of struct charset.  */
 +struct charset *charset_table;
  
 -/* A char-table containing information of each character set.  */
 -Lisp_Object Vcharset_table;
 +static int charset_table_size;
 +static int charset_table_used;
  
 -/* A vector of charset symbol indexed by charset-id.  This is used
 -   only for returning charset symbol from C functions.  */
 -Lisp_Object Vcharset_symbol_table;
 +Lisp_Object Qcharsetp;
  
 -/* A list of charset symbols ever defined.  */
 -Lisp_Object Vcharset_list;
 +/* Special charset symbols.  */
 +Lisp_Object Qascii;
 +Lisp_Object Qeight_bit;
 +Lisp_Object Qiso_8859_1;
 +Lisp_Object Qunicode;
  
 -/* Vector of translation table ever defined.
 -   ID of a translation table is used to index this vector.  */
 -Lisp_Object Vtranslation_table_vector;
 +/* The corresponding charsets.  */
 +int charset_ascii;
 +int charset_eight_bit;
 +int charset_iso_8859_1;
 +int charset_unicode;
  
 -/* A char-table for characters which may invoke auto-filling.  */
 -Lisp_Object Vauto_fill_chars;
 +/* The other special charsets.  */
 +int charset_jisx0201_roman;
 +int charset_jisx0208_1978;
 +int charset_jisx0208;
  
 -Lisp_Object Qauto_fill_chars;
 +/* Value of charset attribute `charset-iso-plane'.  */
 +Lisp_Object Qgl, Qgr;
  
 -/* Tables used by macros BYTES_BY_CHAR_HEAD and WIDTH_BY_CHAR_HEAD.  */
 -int bytes_by_char_head[256];
 -int width_by_char_head[256];
 +/* Charset of unibyte characters.  */
 +int charset_unibyte;
  
 -/* Mapping table from ISO2022's charset (specified by DIMENSION,
 -   CHARS, and FINAL-CHAR) to Emacs' charset.  */
 -int iso_charset_table[2][2][128];
 +/* List of charsets ordered by the priority.  */
 +Lisp_Object Vcharset_ordered_list;
 +
 +/* Incremented everytime we change Vcharset_ordered_list.  This is
 +   unsigned short so that it fits in Lisp_Int and never matches
 +   -1.  */
 +unsigned short charset_ordered_list_tick;
  
 -/* Variables used locally in the macro FETCH_MULTIBYTE_CHAR.  */
 -unsigned char *_fetch_multibyte_char_p;
 -int _fetch_multibyte_char_len;
 +/* List of iso-2022 charsets.  */
 +Lisp_Object Viso_2022_charset_list;
  
 -/* Offset to add to a non-ASCII value when inserting it.  */
 -EMACS_INT nonascii_insert_offset;
 +/* List of emacs-mule charsets.  */
 +Lisp_Object Vemacs_mule_charset_list;
  
 -/* Translation table for converting non-ASCII unibyte characters
 -   to multibyte codes, or nil.  */
 -Lisp_Object Vnonascii_translation_table;
 +struct charset *emacs_mule_charset[256];
 +
 +/* Mapping table from ISO2022's charset (specified by DIMENSION,
 +   CHARS, and FINAL-CHAR) to Emacs' charset.  */
 +int iso_charset_table[ISO_MAX_DIMENSION][ISO_MAX_CHARS][ISO_MAX_FINAL];
 +
 +Lisp_Object Vcharset_map_path;
 +
 +Lisp_Object Vchar_unified_charset_table;
 +
 +/* Defined in chartab.c */
 +extern void
 +map_char_table_for_charset P_ ((void (*c_function) (Lisp_Object, Lisp_Object),
 +                              Lisp_Object function, Lisp_Object table,
 +                              Lisp_Object arg, struct charset *charset,
 +                              unsigned from, unsigned to));
 +
 +#define CODE_POINT_TO_INDEX(charset, code)                            \
 +  ((charset)->code_linear_p                                           \
 +   ? (code) - (charset)->min_code                                     \
 +   : (((charset)->code_space_mask[(code) >> 24] & 0x8)                        \
 +      && ((charset)->code_space_mask[((code) >> 16) & 0xFF] & 0x4)    \
 +      && ((charset)->code_space_mask[((code) >> 8) & 0xFF] & 0x2)     \
 +      && ((charset)->code_space_mask[(code) & 0xFF] & 0x1))           \
 +   ? (((((code) >> 24) - (charset)->code_space[12])                   \
 +       * (charset)->code_space[11])                                   \
 +      + (((((code) >> 16) & 0xFF) - (charset)->code_space[8])         \
 +       * (charset)->code_space[7])                                    \
 +      + (((((code) >> 8) & 0xFF) - (charset)->code_space[4])          \
 +       * (charset)->code_space[3])                                    \
 +      + (((code) & 0xFF) - (charset)->code_space[0])                  \
 +      - ((charset)->char_index_offset))                                       \
 +   : -1)
 +
 +
 +/* Convert the character index IDX to code-point CODE for CHARSET.
 +   It is assumed that IDX is in a valid range.  */
 +
 +#define INDEX_TO_CODE_POINT(charset, idx)                                  \
 +  ((charset)->code_linear_p                                                \
 +   ? (idx) + (charset)->min_code                                           \
 +   : (idx += (charset)->char_index_offset,                                 \
 +      (((charset)->code_space[0] + (idx) % (charset)->code_space[2])       \
 +       | (((charset)->code_space[4]                                        \
 +         + ((idx) / (charset)->code_space[3] % (charset)->code_space[6]))  \
 +        << 8)                                                              \
 +       | (((charset)->code_space[8]                                        \
 +         + ((idx) / (charset)->code_space[7] % (charset)->code_space[10])) \
 +        << 16)                                                             \
 +       | (((charset)->code_space[12] + ((idx) / (charset)->code_space[11]))  \
 +        << 24))))
  
 -/* List of all possible generic characters.  */
 -Lisp_Object Vgeneric_character_list;
  
  \f
 -void
 -invalid_character (c)
 -     int c;
 -{
 -  error ("Invalid character: 0%o, %d, 0x%x", c, c, c);
 -}
  
 -/* Parse string STR of length LENGTH and fetch information of a
 -   character at STR.  Set BYTES to the byte length the character
 -   occupies, CHARSET, C1, C2 to proper values of the character. */
 -
 -#define SPLIT_MULTIBYTE_SEQ(str, length, bytes, charset, c1, c2)           \
 -  do {                                                                             \
 -    (c1) = *(str);                                                         \
 -    (bytes) = BYTES_BY_CHAR_HEAD (c1);                                             \
 -    if ((bytes) == 1)                                                      \
 -      (charset) = ASCII_BYTE_P (c1) ? CHARSET_ASCII : CHARSET_8_BIT_GRAPHIC; \
 -    else if ((bytes) == 2)                                                 \
 -      {                                                                            \
 -      if ((c1) == LEADING_CODE_8_BIT_CONTROL)                              \
 -        (charset) = CHARSET_8_BIT_CONTROL, (c1) = (str)[1] - 0x20;         \
 -      else                                                                 \
 -        (charset) = (c1), (c1) = (str)[1] & 0x7F;                          \
 -      }                                                                            \
 -    else if ((bytes) == 3)                                                 \
 -      {                                                                            \
 -      if ((c1) < LEADING_CODE_PRIVATE_11)                                  \
 -        (charset) = (c1), (c1) = (str)[1] & 0x7F, (c2) = (str)[2] & 0x7F;  \
 -      else                                                                 \
 -        (charset) = (str)[1], (c1) = (str)[2] & 0x7F;                      \
 -      }                                                                            \
 -    else                                                                   \
 -      (charset) = (str)[1], (c1) = (str)[2] & 0x7F, (c2) = (str)[3] & 0x7F;  \
 -  } while (0)
 -
 -/* 1 if CHARSET, C1, and C2 compose a valid character, else 0.
 -   Note that this intentionally allows invalid components, such
 -   as 0xA0 0xA0, because there exist many files that contain
 -   such invalid byte sequences, especially in EUC-GB. */
 -#define CHAR_COMPONENTS_VALID_P(charset, c1, c2)      \
 -  ((charset) == CHARSET_ASCII                         \
 -   ? ((c1) >= 0 && (c1) <= 0x7F)                      \
 -   : ((charset) == CHARSET_8_BIT_CONTROL              \
 -      ? ((c1) >= 0x80 && (c1) <= 0x9F)                        \
 -      : ((charset) == CHARSET_8_BIT_GRAPHIC           \
 -       ? ((c1) >= 0x80 && (c1) <= 0xFF)               \
 -       : (CHARSET_DIMENSION (charset) == 1            \
 -          ? ((c1) >= 0x20 && (c1) <= 0x7F)            \
 -          : ((c1) >= 0x20 && (c1) <= 0x7F             \
 -             && (c2) >= 0x20 && (c2) <= 0x7F)))))
 -
 -/* Store multi-byte form of the character C in STR.  The caller should
 -   allocate at least 4-byte area at STR in advance.  Returns the
 -   length of the multi-byte form.  If C is an invalid character code,
 -   return -1.  */
 +/* Set to 1 to warn that a charset map is loaded and thus a buffer
 +   text and a string data may be relocated.  */
 +int charset_map_loaded;
  
 -int
 -char_to_string_1 (c, str)
 -     int c;
 -     unsigned char *str;
 +struct charset_map_entries
 +{
 +  struct {
 +    unsigned from, to;
 +    int c;
 +  } entry[0x10000];
 +  struct charset_map_entries *next;
 +};
 +
 +/* Load the mapping information for CHARSET from ENTRIES.
 +
 +   If CONTROL_FLAG is 0, setup CHARSET->min_char and CHARSET->max_char.
 +
 +   If CONTROL_FLAG is 1, setup CHARSET->min_char, CHARSET->max_char,
 +   CHARSET->decoder, and CHARSET->encoder.
 +
 +   If CONTROL_FLAG is 2, setup CHARSET->deunifier and
 +   Vchar_unify_table.  If Vchar_unified_charset_table is non-nil,
 +   setup it too.  */
 +
 +static void
 +load_charset_map (charset, entries, n_entries, control_flag)
 +  struct charset *charset;
 +  struct charset_map_entries *entries;
 +  int n_entries;
 +  int control_flag;
  {
 -  unsigned char *p = str;
 +  Lisp_Object vec, table;
 +  unsigned max_code = CHARSET_MAX_CODE (charset);
 +  int ascii_compatible_p = charset->ascii_compatible_p;
 +  int min_char, max_char, nonascii_min_char;
 +  int i;
 +  unsigned char *fast_map = charset->fast_map;
 +
 +  if (n_entries <= 0)
 +    return;
  
 -  if (c & CHAR_MODIFIER_MASK) /* This includes the case C is negative.  */
 +  if (control_flag > 0)
      {
 -      /* Multibyte character can't have a modifier bit.  */
 -      if (! SINGLE_BYTE_CHAR_P ((c & ~CHAR_MODIFIER_MASK)))
 -      return -1;
 +      int n = CODE_POINT_TO_INDEX (charset, max_code) + 1;
  
 -      /* For Meta, Shift, and Control modifiers, we need special care.  */
 -      if (c & CHAR_META)
 +      table = Fmake_char_table (Qnil, Qnil);
 +      if (control_flag == 1)
 +      vec = Fmake_vector (make_number (n), make_number (-1));
 +      else if (! CHAR_TABLE_P (Vchar_unify_table))
 +      Vchar_unify_table = Fmake_char_table (Qnil, Qnil);
 +
 +      charset_map_loaded = 1;
 +    }
 +
 +  min_char = max_char = entries->entry[0].c;
 +  nonascii_min_char = MAX_CHAR;
 +  for (i = 0; i < n_entries; i++)
 +    {
 +      unsigned from, to;
 +      int from_index, to_index;
 +      int from_c, to_c;
 +      int idx = i % 0x10000;
 +
 +      if (i > 0 && idx == 0)
 +      entries = entries->next;
 +      from = entries->entry[idx].from;
 +      to = entries->entry[idx].to;
 +      from_c = entries->entry[idx].c;
 +      from_index = CODE_POINT_TO_INDEX (charset, from);
 +      if (from == to)
        {
 -        /* Move the meta bit to the right place for a string.  */
 -        c = (c & ~CHAR_META) | 0x80;
 +        to_index = from_index;
 +        to_c = from_c;
        }
 -      if (c & CHAR_SHIFT)
 +      else
        {
 -        /* Shift modifier is valid only with [A-Za-z].  */
 -        if ((c & 0377) >= 'A' && (c & 0377) <= 'Z')
 -          c &= ~CHAR_SHIFT;
 -        else if ((c & 0377) >= 'a' && (c & 0377) <= 'z')
 -          c = (c & ~CHAR_SHIFT) - ('a' - 'A');
 +        to_index = CODE_POINT_TO_INDEX (charset, to);
 +        to_c = from_c + (to_index - from_index);
        }
 -      if (c & CHAR_CTL)
 +      if (from_index < 0 || to_index < 0)
 +      continue;
 +
 +      if (control_flag < 2)
        {
 -        /* Simulate the code in lread.c.  */
 -        /* Allow `\C- ' and `\C-?'.  */
 -        if (c == (CHAR_CTL | ' '))
 -          c = 0;
 -        else if (c == (CHAR_CTL | '?'))
 -          c = 127;
 -        /* ASCII control chars are made from letters (both cases),
 -           as well as the non-letters within 0100...0137.  */
 -        else if ((c & 0137) >= 0101 && (c & 0137) <= 0132)
 -          c &= (037 | (~0177 & ~CHAR_CTL));
 -        else if ((c & 0177) >= 0100 && (c & 0177) <= 0137)
 -          c &= (037 | (~0177 & ~CHAR_CTL));
 +        int c;
 +
 +        if (to_c > max_char)
 +          max_char = to_c;
 +        else if (from_c < min_char)
 +          min_char = from_c;
 +        if (ascii_compatible_p)
 +          {
 +            if (! ASCII_BYTE_P (from_c))
 +              {
 +                if (from_c < nonascii_min_char)
 +                  nonascii_min_char = from_c;
 +              }
 +            else if (! ASCII_BYTE_P (to_c))
 +              {
 +                nonascii_min_char = 0x80;
 +              }
 +          }
 +
 +        for (c = from_c; c <= to_c; c++)
 +          CHARSET_FAST_MAP_SET (c, fast_map);
 +
 +        if (control_flag == 1)
 +          {
 +            unsigned code = from;
 +
 +            if (CHARSET_COMPACT_CODES_P (charset))
 +              while (1)
 +                {
 +                  ASET (vec, from_index, make_number (from_c));
 +                  if (NILP (CHAR_TABLE_REF (table, from_c)))
 +                    CHAR_TABLE_SET (table, from_c, make_number (code));
 +                  if (from_index == to_index)
 +                    break;
 +                  from_index++, from_c++;
 +                  code = INDEX_TO_CODE_POINT (charset, from_index);
 +                }
 +            else
 +              for (; from_index <= to_index; from_index++, from_c++)
 +                {
 +                  ASET (vec, from_index, make_number (from_c));
 +                  if (NILP (CHAR_TABLE_REF (table, from_c)))
 +                    CHAR_TABLE_SET (table, from_c, make_number (from_index));
 +                }
 +          }
        }
 +      else
 +      {
 +        unsigned code = from;
  
 -      /* If C still has any modifier bits, just ignore it.  */
 -      c &= ~CHAR_MODIFIER_MASK;
 +        while (1)
 +          {
 +            int c1 = DECODE_CHAR (charset, code);
 +
 +            if (c1 >= 0)
 +              {
 +                CHAR_TABLE_SET (table, from_c, make_number (c1));
 +                CHAR_TABLE_SET (Vchar_unify_table, c1, make_number (from_c));
 +                if (CHAR_TABLE_P (Vchar_unified_charset_table))
 +                  CHAR_TABLE_SET (Vchar_unified_charset_table, c1,
 +                                  CHARSET_NAME (charset));
 +              }
 +            if (from_index == to_index)
 +              break;
 +            from_index++, from_c++;
 +            code = INDEX_TO_CODE_POINT (charset, from_index);
 +          }
 +      }
      }
  
 -  if (SINGLE_BYTE_CHAR_P (c))
 +  if (control_flag < 2)
      {
 -      if (ASCII_BYTE_P (c) || c >= 0xA0)
 -      *p++ = c;
 -      else
 +      CHARSET_MIN_CHAR (charset) = (ascii_compatible_p
 +                                  ? nonascii_min_char : min_char);
 +      CHARSET_MAX_CHAR (charset) = max_char;
 +      if (control_flag == 1)
        {
 -        *p++ = LEADING_CODE_8_BIT_CONTROL;
 -        *p++ = c + 0x20;
 +        CHARSET_DECODER (charset) = vec;
 +        CHARSET_ENCODER (charset) = table;
        }
      }
 -  else if (CHAR_VALID_P (c, 0))
 -    {
 -      int charset, c1, c2;
 +  else
 +    CHARSET_DEUNIFIER (charset) = table;
 +}
  
 -      SPLIT_CHAR (c, charset, c1, c2);
  
 -      if (charset >= LEADING_CODE_EXT_11)
 -      *p++ = (charset < LEADING_CODE_EXT_12
 -              ? LEADING_CODE_PRIVATE_11
 -              : (charset < LEADING_CODE_EXT_21
 -                 ? LEADING_CODE_PRIVATE_12
 -                 : (charset < LEADING_CODE_EXT_22
 -                    ? LEADING_CODE_PRIVATE_21
 -                    : LEADING_CODE_PRIVATE_22)));
 -      *p++ = charset;
 -      if ((c1 > 0 && c1 < 32) || (c2 > 0 && c2 < 32))
 -      return -1;
 -      if (c1)
 +/* Read a hexadecimal number (preceded by "0x") from the file FP while
 +   paying attention to comment charcter '#'.  */
 +
 +static INLINE unsigned
 +read_hex (fp, eof)
 +     FILE *fp;
 +     int *eof;
 +{
 +  int c;
 +  unsigned n;
 +
 +  while ((c = getc (fp)) != EOF)
 +    {
 +      if (c == '#')
        {
 -        *p++ = c1 | 0x80;
 -        if (c2 > 0)
 -          *p++ = c2 | 0x80;
 +        while ((c = getc (fp)) != EOF && c != '\n');
 +      }
 +      else if (c == '0')
 +      {
 +        if ((c = getc (fp)) == EOF || c == 'x')
 +          break;
        }
      }
 +  if (c == EOF)
 +    {
 +      *eof = 1;
 +      return 0;
 +    }
 +  *eof = 0;
 +  n = 0;
 +  if (c == 'x')
 +    while ((c = getc (fp)) != EOF && isxdigit (c))
 +      n = ((n << 4)
 +         | (c <= '9' ? c - '0' : c <= 'F' ? c - 'A' + 10 : c - 'a' + 10));
    else
 -    return -1;
 -
 -  return (p - str);
 +    while ((c = getc (fp)) != EOF && isdigit (c))
 +      n = (n * 10) + c - '0';
 +  if (c != EOF)
 +    ungetc (c, fp);
 +  return n;
  }
  
  

diff --cc src/charset.h
Simple merge

diff --cc src/cmds.c
Simple merge

diff --cc src/coding.c
Simple merge

diff --cc src/coding.h
Simple merge

diff --cc src/composite.c
Simple merge

diff --cc src/composite.h
Simple merge

diff --cc src/data.c
Simple merge

diff --cc src/dired.c
Simple merge

diff --cc src/dispextern.h
Simple merge

diff --cc src/dispnew.c
Simple merge

diff --cc src/disptab.h
Simple merge

diff --cc src/doc.c
Simple merge

diff --cc src/doprnt.c
Simple merge

diff --cc src/dosfns.c
Simple merge

diff --cc src/editfns.c
Simple merge

diff --cc src/emacs.c
Simple merge

diff --cc src/fileio.c
Simple merge

diff --cc src/filelock.c
Simple merge

diff --cc src/fns.c
Simple merge

diff --cc src/fontset.c
Simple merge

diff --cc src/fontset.h
Simple merge

diff --cc src/frame.c
Simple merge

diff --cc src/frame.h
Simple merge

diff --cc src/fringe.c
Simple merge

diff --cc src/indent.c
Simple merge

diff --cc src/insdel.c
Simple merge

diff --cc src/intervals.c
Simple merge

diff --cc src/intervals.h
Simple merge

diff --cc src/keyboard.c
Simple merge

diff --cc src/keymap.c
Simple merge

diff --cc src/lisp.h
Simple merge

diff --cc src/lread.c
Simple merge

diff --cc src/macfns.c
Simple merge

diff --cc src/macterm.c
index 16d8452,59aafc3..53028f9
--- 1/src/macterm.c
--- 2/src/macterm.c
+++ b/src/macterm.c
@@@ -1724,10 -1727,11 +1730,11 @@@ mac_encode_char (c, char2b, font_info, 
        /* It's a program.  */
        struct ccl_program *ccl = font_info->font_encoder;
  
+       check_ccl_update (ccl);
        if (CHARSET_DIMENSION (charset) == 1)
        {
 -        ccl->reg[0] = charset;
 -        ccl->reg[1] = char2b->byte2;
 +        ccl->reg[0] = CHARSET_ID (charset);
 +        ccl->reg[1] = XCHAR2B_BYTE2 (char2b);
          ccl->reg[2] = -1;
        }
        else
@@@ -6350,10 -6337,9 +6359,10 @@@ x_font_name_to_mac_font_name (xf, mf, m
        coding.dst_multibyte = 1;
        coding.mode |= CODING_MODE_LAST_BLOCK;
        encode_coding (&coding, mf_decoded, mf,
-                    strlen (mf_decoded), sizeof (Str32) - 1);
+                    strlen (mf_decoded), sizeof (Str255) - 1);
        mf[coding.produced] = '\0';
      }
 +#endif
  }
  
  

diff --cc src/makefile.w32-in
Simple merge

diff --cc src/marker.c
Simple merge

diff --cc src/minibuf.c
Simple merge

diff --cc src/msdos.c
Simple merge

diff --cc src/print.c
Simple merge

diff --cc src/process.c
Simple merge

diff --cc src/regex.c
Simple merge

diff --cc src/regex.h
Simple merge

diff --cc src/search.c
Simple merge

diff --cc src/syntax.c
Simple merge

diff --cc src/syntax.h
Simple merge

diff --cc src/term.c
Simple merge

diff --cc src/w16select.c
Simple merge

diff --cc src/w32bdf.c
Simple merge

diff --cc src/w32console.c
Simple merge

diff --cc src/w32fns.c
Simple merge

diff --cc src/w32select.c
Simple merge

diff --cc src/w32term.c
index 0bb5607,b6cc61d..543b588
--- 1/src/w32term.c
--- 2/src/w32term.c
+++ b/src/w32term.c
@@@ -6615,15 -6472,15 +6640,17 @@@ w32_initialize (
    /* Dynamically link to optional system components. */
    {
      HANDLE user_lib = LoadLibrary ("user32.dll");
 +    HANDLE gdi_lib = LoadLibrary ("gdi32.dll");
+     UINT smoothing_type;
+     BOOL smoothing_enabled;
  
 -#define LOAD_PROC(fn) pfn##fn = (void *) GetProcAddress (user_lib, #fn)
 +#define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
  
      /* New proportional scroll bar functions. */
 -    LOAD_PROC (SetScrollInfo);
 -    LOAD_PROC (GetScrollInfo);
 -
 +    LOAD_PROC (user_lib, SetScrollInfo);
 +    LOAD_PROC (user_lib, GetScrollInfo);
 +    LOAD_PROC (gdi_lib, GetFontUnicodeRanges);
 +    
  #undef LOAD_PROC
  
      FreeLibrary (user_lib);

diff --cc src/w32term.h
Simple merge

diff --cc src/window.c
Simple merge

diff --cc src/xdisp.c
Simple merge

diff --cc src/xfaces.c
Simple merge

diff --cc src/xfns.c
Simple merge

diff --cc src/xmenu.c
Simple merge

diff --cc src/xterm.c
Simple merge

diff --cc src/xterm.h
Simple merge