(display_text_line): Introduce new local variable

rev_dir_bit to display right to left characters (not yet used).

(message): Use FRAME_MESSAGE_BUF_SIZE().
(redisplay_internal): Add canceling code for continuation at
wide-column.
(display_text_line): Don't just decrement left_edge->bufpos,
it may be multi-byte character, use DEC_POS instead.

(try_window): Change the way of calculation of tab
offset.  We now use val.tab_offset to maintain tab offset.
Removed local variable tab_offset.
(try_window_id): Likewise.

(pos_tab_offset): Return COL (Modulo is no longer valid).
Add the line to set tab_offset member.
Use pos.tab_offset.

(redisplay_window): Specify big negative number for TOHPOS
of compute_motion().
(try_window_id): Likewise.

(tri_window_id): Specify "1 << (BITS_PER_SHORT - 1)" to
express "Don't care".

Include charset.h, coding.h, and process.h.
(display_text_line): Handle multibyte characters.
(display_mode_line): Pay attention to wide-column characters.
(decode_mode_spec_coding): New function.
(decode_mode_spec): Handle %-constructs `%z' and `%Z' to print
coding system mnemonics.
(display_string): Handle multibyte characters.

1 files changed, 393 insertions, 86 deletions

diff --git a/src/xdisp.c b/src/xdisp.c
index e0de4f96e05..e96cf8494cc 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -29,6 +29,7 @@ Boston, MA 02111-1307, USA.  */
 #include "termchar.h"
 #include "dispextern.h"
 #include "buffer.h"
+#include "charset.h"
 #include "indent.h"
 #include "commands.h"
 #include "macros.h"
@@ -36,6 +37,8 @@ Boston, MA 02111-1307, USA.  */
 #include "termhooks.h"
 #include "intervals.h"
 #include "keyboard.h"
+#include "coding.h"
+#include "process.h"
 
 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
 extern void set_frame_menubar ();
@@ -548,10 +551,10 @@ message (m, a1, a2, a3)
               a[2] = a3;
 
               len = doprnt (FRAME_MESSAGE_BUF (f),
-                            (int) FRAME_WIDTH (f), m, (char *)0, 3, a);
+                            FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, 3, a);
 #else
               len = doprnt (FRAME_MESSAGE_BUF (f),
-                            (int) FRAME_WIDTH (f), m, (char *)0, 3, &a1);
+                            FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, 3, &a1);
 #endif /* NO_ARG_ARRAY */
 
               message2 (FRAME_MESSAGE_BUF (f), len);
@@ -987,15 +990,44 @@ redisplay_internal (preserve_echo_area)
               && end_unchanged >= tlendpos
               && Z - GPT >= tlendpos)))
     {
-      if (tlbufpos > BEGV && FETCH_CHAR (tlbufpos - 1) != '\n'
+      if (tlbufpos > BEGV && FETCH_BYTE (tlbufpos - 1) != '\n'
           && (tlbufpos == ZV
-              || FETCH_CHAR (tlbufpos) == '\n'))
+              || FETCH_BYTE (tlbufpos) == '\n'))
         /* Former continuation line has disappeared by becoming empty */
         goto cancel;
       else if (XFASTINT (w->last_modified) < MODIFF
                || XFASTINT (w->last_overlay_modified) < OVERLAY_MODIFF
                || MINI_WINDOW_P (w))
         {
+          /* We have to handle the case of continuation around a
+             wide-column character (See the comment in indent.c around
+             line 885).
+
+             For instance, in the following case:
+
+             --------  Insert  --------
+             K_A_N_\\   `a'    K_A_N_a\         `X_' are wide-column chars.
+             J_I_       ==>    J_I_             `^^' are cursors.
+             ^^                ^^
+             --------          --------
+
+             As we have to redraw the line above, we should goto cancel.  */
+
+          struct position val;
+          int prevline;
+
+          prevline = find_next_newline (tlbufpos, -1);
+          val = *compute_motion (prevline, 0,
+                                 XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0,
+                                 0,
+                                 tlbufpos,
+                                 1 << (BITS_PER_SHORT - 1),
+                                 1 << (BITS_PER_SHORT - 1),
+                                 window_internal_width (w) - 1,
+                                 XINT (w->hscroll), 0, w);
+          if (val.hpos != this_line_start_hpos)
+            goto cancel;
+
           cursor_vpos = -1;
           overlay_arrow_seen = 0;
           zv_strings_seen = 0;
@@ -1604,7 +1636,10 @@ redisplay_window (window, just_this_one, preserve_echo_area)
                                ? minibuf_prompt_width : 0)
                               + (hscroll ? 1 - hscroll : 0)),
                              0,
-                             PT, height, 0,
+                             PT, height, 
+                             /* BUG FIX: See the comment of
+                                Fpos_visible_in_window_p (window.c).  */
+                             - (1 << (BITS_PER_SHORT - 1)),
                              width, hscroll, pos_tab_offset (w, startp), w);
       /* If PT does fit on the screen, we will use this start pos,
          so do so by setting force_start.  */
@@ -1711,8 +1746,12 @@ redisplay_window (window, just_this_one, preserve_echo_area)
       int this_scroll_margin = scroll_margin;
 
       pos = *compute_motion (startp, 0, (hscroll ? 1 - hscroll : 0), 0,
-                            PT, height, 0, width, hscroll,
-                            pos_tab_offset (w, startp), w);
+                             PT, height,
+                             /* BUG FIX: See the comment of
+                                Fpos_visible_in_window_p (window.c).  */
+                             - (1 << (BITS_PER_SHORT - 1)),
+                             width, hscroll,
+                             pos_tab_offset (w, startp), w);
 
       /* Don't use a scroll margin that is negative or too large.  */
       if (this_scroll_margin < 0)
@@ -1750,7 +1789,7 @@ redisplay_window (window, just_this_one, preserve_echo_area)
      but no longer is, find a new starting point.  */
   else if (!NILP (w->start_at_line_beg)
            && !(startp <= BEGV
-                || FETCH_CHAR (startp - 1) == '\n'))
+                || FETCH_BYTE (startp - 1) == '\n'))
     {
       goto recenter;
     }
@@ -1957,7 +1996,7 @@ recenter:
 
   startp = marker_position (w->start);
   w->start_at_line_beg
-    = (startp == BEGV || FETCH_CHAR (startp - 1) == '\n') ? Qt : Qnil;
+    = (startp == BEGV || FETCH_BYTE (startp - 1) == '\n') ? Qt : Qnil;
 
 done:
   if ((update_mode_line
@@ -2043,7 +2082,6 @@ try_window (window, pos)
   register int height = window_internal_height (w);
   register int vpos = XFASTINT (w->top);
   register int last_text_vpos = vpos;
-  int tab_offset = pos_tab_offset (w, pos);
   FRAME_PTR f = XFRAME (w->frame);
   int width = window_internal_width (w) - 1;
   struct position val;
@@ -2059,13 +2097,18 @@ try_window (window, pos)
   zv_strings_seen = 0;
   val.hpos = XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0;
   val.ovstring_chars_done = 0;
+  val.tab_offset = pos_tab_offset (w, pos);
 
   while (--height >= 0)
     {
-      val = *display_text_line (w, pos, vpos, val.hpos, tab_offset,
+      val = *display_text_line (w, pos, vpos, val.hpos, val.tab_offset,
                                 val.ovstring_chars_done);
+      /* The following code is omitted because we maintain tab_offset
+         in VAL.  */
+#if 0
       tab_offset += width;
       if (val.vpos) tab_offset = 0;
+#endif  /* 0 */
       vpos++;
       if (pos != val.bufpos)
         {
@@ -2079,7 +2122,7 @@ try_window (window, pos)
           last_text_vpos
             /* Next line, unless prev line ended in end of buffer with no cr */
             = vpos - (val.vpos
-                      && (FETCH_CHAR (val.bufpos - 1) != '\n' || invis));
+                      && (FETCH_BYTE (val.bufpos - 1) != '\n' || invis));
         }
       pos = val.bufpos;
     }
@@ -2133,7 +2176,7 @@ try_window_id (window)
   struct position val, bp, ep, xp, pp;
   int scroll_amount = 0;
   int delta;
-  int tab_offset, epto, old_tick;
+  int epto, old_tick;
 
   if (GPT - BEG < beg_unchanged)
     beg_unchanged = GPT - BEG;
@@ -2145,7 +2188,10 @@ try_window_id (window)
 
   /* Find position before which nothing is changed.  */
   bp = *compute_motion (start, 0, lmargin, 0,
-                        min (ZV, beg_unchanged + BEG), height, 0,
+                        min (ZV, beg_unchanged + BEG), height,
+                        /* BUG FIX: See the comment of
+                           Fpos_visible_in_window_p() (window.c).  */
+                        - (1 << (BITS_PER_SHORT - 1)),
                         width, hscroll, pos_tab_offset (w, start), w);
   if (bp.vpos >= height)
     {
@@ -2156,7 +2202,10 @@ try_window_id (window)
              But we need to update window_end_pos to account for
              any change in buffer size.  */
           bp = *compute_motion (start, 0, lmargin, 0,
-                                ZV, height, 0,
+                                ZV, height,
+                                /* BUG FIX: See the comment of
+                                   Fpos_visible_in_window_p() (window.c).  */
+                                - (1 << (BITS_PER_SHORT - 1)),
                                 width, hscroll, pos_tab_offset (w, start), w);
           XSETFASTINT (w->window_end_vpos, height);
           XSETFASTINT (w->window_end_pos, Z - bp.bufpos);
@@ -2188,12 +2237,14 @@ try_window_id (window)
       --vpos;
       pos = bp.bufpos;
     }
+  val.tab_offset = bp.tab_offset; /* Update tab offset.  */
 
   if (bp.contin && bp.hpos != lmargin)
     {
       val.hpos = bp.prevhpos - width + lmargin;
+      val.tab_offset = bp.tab_offset + bp.prevhpos - width;
       did_motion = 1;
-      pos--;
+      DEC_POS (pos);
     }
 
   bp.vpos = vpos;
@@ -2207,7 +2258,9 @@ try_window_id (window)
   /* Compute the cursor position after that newline.  */
   ep = *compute_motion (pos, vpos, val.hpos, did_motion, tem,
                         height, - (1 << (BITS_PER_SHORT - 1)),
-                        width, hscroll, pos_tab_offset (w, bp.bufpos), w);
+                        width, hscroll,
+                        /* We have tab offset in VAL, use it.  */
+                        val.tab_offset, w); 
 
   /* If changes reach past the text available on the frame,
      just display rest of frame.  */
@@ -2223,7 +2276,7 @@ try_window_id (window)
      newline before it, so the following line must be redrawn. */
   if (stop_vpos == ep.vpos
       && (ep.bufpos == BEGV
-          || FETCH_CHAR (ep.bufpos - 1) != '\n'
+          || FETCH_BYTE (ep.bufpos - 1) != '\n'
           || ep.bufpos == Z - end_unchanged))
     stop_vpos = ep.vpos + 1;
 
@@ -2236,17 +2289,20 @@ try_window_id (window)
   if (stop_vpos < height)
     {
       /* Now determine how far up or down the rest of the window has moved */
-      epto = pos_tab_offset (w, ep.bufpos);
       xp = *compute_motion (ep.bufpos, ep.vpos, ep.hpos, 1,
                             Z - XFASTINT (w->window_end_pos),
-                            10000, 0, width, hscroll, epto, w);
+                            /* Don't care for VPOS... */
+                            1 << (BITS_PER_SHORT - 1),
+                            /* ... nor HPOS.  */
+                            1 << (BITS_PER_SHORT - 1),
+                            width, hscroll, ep.tab_offset, w);
       scroll_amount = xp.vpos - XFASTINT (w->window_end_vpos);
 
       /* Is everything on frame below the changes whitespace?
          If so, no scrolling is really necessary.  */
       for (i = ep.bufpos; i < xp.bufpos; i++)
         {
-          tem = FETCH_CHAR (i);
+          tem = FETCH_BYTE (i);
           if (tem != ' ' && tem != '\n' && tem != '\t')
             break;
         }
@@ -2263,14 +2319,17 @@ try_window_id (window)
             {
               pp = *compute_motion (ep.bufpos, ep.vpos, ep.hpos, 1,
                                     PT, height, - (1 << (BITS_PER_SHORT - 1)),
-                                    width, hscroll, epto, w);
+                                    width, hscroll,
+                                    /* We have tab offset in EP, use it.  */
+                                    ep.tab_offset, w);
             }
           else
             {
               pp = *compute_motion (xp.bufpos, xp.vpos, xp.hpos, 1,
                                     PT, height, - (1 << (BITS_PER_SHORT - 1)),
                                     width, hscroll,
-                                    pos_tab_offset (w, xp.bufpos), w);
+                                    /* We have tab offset in XP, use it. */
+                                    xp.tab_offset, w);
             }
           if (pp.bufpos < PT || pp.vpos == height)
             return 0;
@@ -2373,27 +2432,35 @@ try_window_id (window)
 
   /* Redisplay the lines where the text was changed */
   last_text_vpos = vpos;
+  /* The following code is omitted because we maintain tab offset in
+     val.tab_offset.  */
+#if 0
   tab_offset = pos_tab_offset (w, pos);
   /* If we are starting display in mid-character, correct tab_offset
      to account for passing the line that that character really starts in.  */
   if (val.hpos < lmargin)
     tab_offset += width;
+#endif /* 0 */
   old_tick = MODIFF;
   while (vpos < stop_vpos)
     {
-      val = *display_text_line (w, pos, top + vpos++, val.hpos, tab_offset,
+      val = *display_text_line (w, pos, top + vpos++, val.hpos, val.tab_offset,
                                 val.ovstring_chars_done);
       /* If display_text_line ran a hook and changed some text,
          redisplay all the way to bottom of buffer
          So that we show the changes.  */
       if (old_tick != MODIFF)
         stop_vpos = height;
+      /* The following code is omitted because we maintain tab offset
+         in val.tab_offset.  */
+#if 0
       tab_offset += width;
       if (val.vpos) tab_offset = 0;
+#endif
       if (pos != val.bufpos)
         last_text_vpos
           /* Next line, unless prev line ended in end of buffer with no cr */
-            = vpos - (val.vpos && FETCH_CHAR (val.bufpos - 1) != '\n');
+            = vpos - (val.vpos && FETCH_BYTE (val.bufpos - 1) != '\n');
       pos = val.bufpos;
     }
 
@@ -2420,28 +2487,37 @@ try_window_id (window)
       FRAME_SCROLL_BOTTOM_VPOS (f) = xp.vpos;
       vpos = xp.vpos;
       pos = xp.bufpos;
-      val.hpos = lmargin;
+      val.hpos = xp.hpos;
+      val.tab_offset = xp.tab_offset;
       if (pos == ZV)
         vpos = height + scroll_amount;
       else if (xp.contin && xp.hpos != lmargin)
         {
           val.hpos = xp.prevhpos - width + lmargin;
-          pos--;
+          val.tab_offset = xp.tab_offset + bp.prevhpos - width;
+          DEC_POS (pos);
         }
 
       blank_end_of_window = 1;
+      /* The following code is omitted because we maintain tab offset
+         in val.tab_offset.  */
+#if 0
       tab_offset = pos_tab_offset (w, pos);
       /* If we are starting display in mid-character, correct tab_offset
          to account for passing the line that that character starts in.  */
       if (val.hpos < lmargin)
         tab_offset += width;
-
+#endif
       while (vpos < height)
         {
-          val = *display_text_line (w, pos, top + vpos++, val.hpos, tab_offset,
-                                    val.ovstring_chars_done);
+          val = *display_text_line (w, pos, top + vpos++, val.hpos,
+                                    val.tab_offset, val.ovstring_chars_done);
+          /* The following code is omitted because we maintain tab
+             offset in val.tab_offset.  */
+#if 0
           tab_offset += width;
           if (val.vpos) tab_offset = 0;
+#endif /* 0 */
           pos = val.bufpos;
         }
 
@@ -2478,7 +2554,11 @@ try_window_id (window)
   if (cursor_vpos < 0)
     {
     findpoint:
-      val = *compute_motion (start, 0, lmargin, 0, PT, 10000, 10000,
+      val = *compute_motion (start, 0, lmargin, 0, PT, 
+                             /* Don't care for VPOS...  */
+                             1 << (BITS_PER_SHORT - 1),
+                             /* ... nor HPOS.  */
+                             1 << (BITS_PER_SHORT - 1),
                              width, hscroll, pos_tab_offset (w, start), w);
       /* Admit failure if point is off frame now */
       if (val.vpos >= height)
@@ -2677,6 +2757,15 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
   GLYPH continuer = (dp == 0 || !INTEGERP (DISP_CONTINUE_GLYPH (dp))
                      ? '\\' : XINT (DISP_CONTINUE_GLYPH (dp)));
 
+  /* If 1, we must handle multibyte characters.  */
+  int multibyte = !NILP (current_buffer->enable_multibyte_characters);
+  /* Length of multibyte form of each character.  */
+  int len;
+  /* Glyphs generated should be set this bit mask if text must be
+     displayed from right to left.  */
+  GLYPH rev_dir_bit = (NILP (current_buffer->direction_reversed)
+                       ? 0 : GLYPH_MASK_REV_DIR);
+
   /* The next buffer location at which the face should change, due
      to overlays or text property changes.  */
   int next_face_change;
@@ -2760,7 +2849,8 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
       if (left_edge->vpos > vpos
           || left_edge->hpos > 0)
         {
-          pos = left_edge->bufpos - 1;
+          pos = left_edge->bufpos;
+          DEC_POS (pos);        /* MULE: It may be a multi-byte character */
           hpos = left_edge->prevhpos;
         }
       else
@@ -2820,13 +2910,32 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
                       ovstr += ovstr_done;
                       ovlen -= ovstr_done;
 
-                      /* Start outputting.  */
-                      for (; ovlen; ovlen--, ovstr++)
+                      while (ovlen > 0)
                         {
-                          if (p1 >= leftmargin && p1 < endp)
-                            *p1 = MAKE_GLYPH (f, *ovstr, current_face);
-                          p1++;
-                          ovstr_done++;
+                          int charset, cols;
+                          GLYPH g;
+
+                          if (multibyte)
+                            {
+                              c = STRING_CHAR_AND_LENGTH (ovstr, ovlen, len);
+                              ovstr += len, ovlen -= len, ovstr_done += len;
+                              charset = CHAR_CHARSET (c);
+                              cols = (charset == CHARSET_COMPOSITION
+                                      ? cmpchar_table[COMPOSITE_CHAR_ID (c)]->width
+                                      : CHARSET_WIDTH (charset));
+                            }
+                          else
+                            {
+                              c = *ovstr++, ovlen--, ovstr_done++;
+                              cols = 1;
+                            }
+                          g = MAKE_GLYPH (f, c, current_face) | rev_dir_bit;
+                          while (cols-- > 0)
+                            {
+                              if (p1 >= leftmargin && p1 < endp)
+                                *p1 = g, g |= GLYPH_MASK_PADDING;
+                              p1++;
+                            }
                         }
                       /* If we did all the overlay strings
                          and we have room for text, clear ovstr_done
@@ -2852,7 +2961,12 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
               /* This is just an estimate to give reasonable
                  performance; nothing should go wrong if it is too small.  */
               if (XFASTINT (limit) > pos + 50)
-                XSETFASTINT (limit, pos + 50);
+                {
+                  int limitpos = pos + 50;
+                  if (limitpos < Z)
+                    INC_POS (limitpos); /* Adjust to character boundary.  */
+                  XSETFASTINT (limit, limitpos);
+                }
               limit = Fnext_single_property_change (position, Qinvisible,
                                                     Fcurrent_buffer (), limit);
 #endif
@@ -2933,9 +3047,15 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
              loop, to see what face we should start with.  */
           if (pos >= next_face_change
               && (FRAME_WINDOW_P (f) || FRAME_MSDOS_P (f)))
-            current_face = compute_char_face (f, w, pos,
-                                              region_beg, region_end,
-                                              &next_face_change, pos + 50, 0);
+            {
+              int limit = pos + 50;
+
+              if (limit < Z && !CHAR_HEAD_P (POS_ADDR (limit)))
+                INC_POS (limit); /* Adjust to character boundary.  */
+              current_face = compute_char_face (f, w, pos,
+                                                region_beg, region_end,
+                                                &next_face_change, limit, 0);
+            }
 #endif
 
           /* Compute the next place we need to stop
@@ -2958,7 +3078,7 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
           if (pos < GPT && GPT < pause)
             pause = GPT;
 
-          p = &FETCH_CHAR (pos);
+          p = POS_ADDR (pos);
         }
 
       if (p1 >= endp)
@@ -2966,19 +3086,23 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
 
       p1prev = p1;
 
-      c = *p++;
+      if (multibyte)
+        /* PAUSE is surely at character boundary.  */
+        c = STRING_CHAR_AND_LENGTH (p, pause - pos, len), p += len;
+      else
+        c = *p++, len = 1;
       /* Let a display table override all standard display methods.  */
       if (dp != 0 && VECTORP (DISP_CHAR_VECTOR (dp, c)))
         {
           p1 = copy_part_of_rope (f, p1, leftmargin,
                                   XVECTOR (DISP_CHAR_VECTOR (dp, c))->contents,
                                   XVECTOR (DISP_CHAR_VECTOR (dp, c))->size,
-                                  current_face);
+                                  current_face, rev_dir_bit);
         }
       else if (c >= 040 && c < 0177)
         {
           if (p1 >= leftmargin)
-            *p1 = MAKE_GLYPH (f, c, current_face);
+            *p1 = MAKE_GLYPH (f, c, current_face) | rev_dir_bit;
           p1++;
         }
       else if (c == '\n')
@@ -2993,7 +3117,7 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
             {
               invis = 1;
               pos = find_next_newline (pos + 1, 1);
-              if (FETCH_CHAR (pos - 1) == '\n')
+              if (FETCH_BYTE (pos - 1) == '\n')
                 pos--;
             }
           if (invis && selective_rlen > 0 && p1 >= leftmargin)
@@ -3002,7 +3126,7 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
               if (p1 - leftmargin > width)
                 p1 = endp;
               copy_part_of_rope (f, p1prev, p1prev, invis_vector_contents,
-                                 (p1 - p1prev), current_face);
+                                 (p1 - p1prev), current_face, rev_dir_bit);
             }
 #ifdef HAVE_FACES
           /* Draw the face of the newline character as extending all the 
@@ -3012,7 +3136,7 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
               if (p1 < leftmargin)
                 p1 = leftmargin;
               while (p1 < endp)
-                *p1++ = FAST_MAKE_GLYPH (' ', current_face);
+                *p1++ = FAST_MAKE_GLYPH (' ', current_face) | rev_dir_bit;
             }
 #endif
 
@@ -3041,7 +3165,7 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
           do
             {
               if (p1 >= leftmargin && p1 < endp)
-                *p1 = MAKE_GLYPH (f, ' ', current_face);
+                *p1 = MAKE_GLYPH (f, ' ', current_face) | rev_dir_bit;
               p1++;
             }
           while ((p1 - leftmargin + taboffset + hscroll - (hscroll > 0))
@@ -3050,7 +3174,7 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
       else if (c == Ctl ('M') && selective == -1)
         {
           pos = find_next_newline (pos, 1);
-          if (FETCH_CHAR (pos - 1) == '\n')
+          if (FETCH_BYTE (pos - 1) == '\n')
             pos--;
           if (selective_rlen > 0)
             {
@@ -3058,7 +3182,7 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
               if (p1 - leftmargin > width)
                 p1 = endp;
               copy_part_of_rope (f, p1prev, p1prev, invis_vector_contents,
-                                 (p1 - p1prev), current_face);
+                                 (p1 - p1prev), current_face, rev_dir_bit);
             }
 #ifdef HAVE_FACES
           /* Draw the face of the newline character as extending all the 
@@ -3068,7 +3192,7 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
               if (p1 < leftmargin)
                 p1 = leftmargin;
               while (p1 < endp)
-                *p1++ = FAST_MAKE_GLYPH (' ', current_face);
+                *p1++ = FAST_MAKE_GLYPH (' ', current_face) | rev_dir_bit;
             }
 #endif
 
@@ -3094,34 +3218,54 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
       else if (c < 0200 && ctl_arrow)
         {
           if (p1 >= leftmargin)
-            *p1 = fix_glyph (f, (dp && INTEGERP (DISP_CTRL_GLYPH (dp))
-                                 ? XINT (DISP_CTRL_GLYPH (dp)) : '^'),
-                             current_face);
+            *p1 = (fix_glyph (f, (dp && INTEGERP (DISP_CTRL_GLYPH (dp))
+                                  ? XINT (DISP_CTRL_GLYPH (dp)) : '^'),
+                              current_face)
+                   | rev_dir_bit);
           p1++;
           if (p1 >= leftmargin && p1 < endp)
-            *p1 = MAKE_GLYPH (f, c ^ 0100, current_face);
+            *p1 = MAKE_GLYPH (f, c ^ 0100, current_face) | rev_dir_bit;
           p1++;
         }
-      else
+      else if (len == 1)
         {
+          /* C is not a multibyte character.  */
           if (p1 >= leftmargin)
-            *p1 = fix_glyph (f, (dp && INTEGERP (DISP_ESCAPE_GLYPH (dp))
-                                 ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\'),
-                             current_face);
+            *p1 = (fix_glyph (f, (dp && INTEGERP (DISP_ESCAPE_GLYPH (dp))
+                                  ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\'),
+                              current_face)
+                   | rev_dir_bit);
           p1++;
           if (p1 >= leftmargin && p1 < endp)
-            *p1 = MAKE_GLYPH (f, (c >> 6) + '0', current_face);
+            *p1 = MAKE_GLYPH (f, (c >> 6) + '0', current_face) | rev_dir_bit;
           p1++;
           if (p1 >= leftmargin && p1 < endp)
-            *p1 = MAKE_GLYPH (f, (7 & (c >> 3)) + '0', current_face);
+            *p1 = (MAKE_GLYPH (f, (7 & (c >> 3)) + '0', current_face)
+                   | rev_dir_bit);
           p1++;
           if (p1 >= leftmargin && p1 < endp)
-            *p1 = MAKE_GLYPH (f, (7 & c) + '0', current_face);
+            *p1 = MAKE_GLYPH (f, (7 & c) + '0', current_face) | rev_dir_bit;
           p1++;
         }
+      else
+        {
+          /* C is a multibyte character.  */
+          int charset = CHAR_CHARSET (c);
+          int columns = (charset == CHARSET_COMPOSITION
+                         ? cmpchar_table[COMPOSITE_CHAR_ID (c)]->width
+                         : CHARSET_WIDTH (charset));
+          GLYPH g = MAKE_GLYPH (f, c, current_face) | rev_dir_bit;
+
+          while (columns--)
+            {
+              if (p1 >= leftmargin && p1 < endp)
+                *p1 = g, g |= GLYPH_MASK_PADDING;
+              p1++;
+            }
+        }
 
       prevpos = pos;
-      pos++;
+      pos += len;
 
       /* Update charstarts for the character just output.  */
 
@@ -3174,10 +3318,37 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
          This occurs when the minibuffer prompt takes up the whole line.  */
       if (p1prev)
         {
-          /* Start the next line with that same character */
-          pos--;
-          /* but at negative hpos, to skip the columns output on this line.  */
-          val.hpos += p1prev - endp;
+          /* Start the next line with that same character whose
+             character code is C and the length of multi-byte form is
+             LEN.  */
+          pos = prevpos;
+
+          if (len == 1)
+            /* C is not a multi-byte character.  We can break it and
+               start from the middle column in the next line.  So,
+               adjust VAL.HPOS to skip the columns output on this
+               line.  */
+            val.hpos += p1prev - endp;
+          else
+            {
+              /* C is a multibyte character.  Since we can't broke it
+                 in the middle, the whole character should be driven
+                 into the next line.  */
+              /* As the result, the actual columns occupied by the
+                 text on this line is less than WIDTH.  VAL.TAB_OFFSET
+                 must be adjusted.  */
+              taboffset = taboffset + (p1prev - endp);
+              /* Let's fill unused columns with TRUNCATOR or CONTINUER.  */
+              {
+                GLYPH g = fix_glyph (f, truncate ? truncator : continuer, 0);
+                while (p1prev < endp)
+                  *p1prev++ = g;
+              }
+              /* If POINT is at POS, cursor should not on this line.  */
+              lastpos = pos;
+              if (PT == pos)
+                cursor_vpos = -1;
+            }
         }
 
       /* Keep in this line everything up to the continuation column.  */
@@ -3191,10 +3362,11 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
 
   if (pos < ZV)
     {
-      if (FETCH_CHAR (pos) == '\n')
+      if (FETCH_BYTE (pos) == '\n')
         {
           /* If stopped due to a newline, start next line after it */
           pos++;
+          val.tab_offset = 0;
           /* Check again for hidden lines, in case the newline occurred exactly
              at the right margin.  */
           while (pos < ZV && selective > 0
@@ -3216,16 +3388,20 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
                      && indented_beyond_p (pos, selective));
               val.hpos = XINT (w->hscroll) ? 1 - XINT (w->hscroll) : 0;
 
-              lastpos = pos - (FETCH_CHAR (pos - 1) == '\n');
+              lastpos = pos - (FETCH_BYTE (pos - 1) == '\n');
+              val.tab_offset = 0;
             }
           else
             {
               *p1++ = fix_glyph (f, continuer, 0);
               val.vpos = 0;
               lastpos--;
+              val.tab_offset = taboffset + width;
             }
         }
     }
+  else
+    val.tab_offset = 0;
 
   /* If point is at eol or in invisible text at eol,
      record its frame location now.  */
@@ -3273,9 +3449,16 @@ display_text_line (w, start, vpos, hpos, taboffset, ovstr_done)
   /* If hscroll and line not empty, insert truncation-at-left marker */
   if (hscroll && lastpos != start)
     {
-      *leftmargin = fix_glyph (f, truncator, 0);
+      GLYPH g = fix_glyph (f, truncator, 0);
+      *leftmargin = g;
       if (p1 <= leftmargin)
         p1 = leftmargin + 1;
+      else                      /* MULE: it may be a wide-column character */
+        {
+          p1prev = leftmargin + 1;
+          while (p1prev < p1 && *p1prev & GLYPH_MASK_PADDING)
+            *p1prev++ = g;
+        }
     }
 
   if (!WINDOW_RIGHTMOST_P (w))
@@ -3454,9 +3637,13 @@ display_mode_line (w)
     {
       /* For a partial width window, explicitly set face of each glyph. */
       int i;
+      unsigned int padding;
       GLYPH *ptr = FRAME_DESIRED_GLYPHS (f)->glyphs[vpos];
       for (i = left; i < right; ++i)
-        ptr[i] = FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (ptr[i]), 1);
+        {
+          padding = ptr[i] & GLYPH_MASK_PADDING;
+          ptr[i] = FAST_MAKE_GLYPH (FAST_GLYPH_CHAR (ptr[i]), 1) | padding;
+        }
     }
 #endif
 
@@ -3730,6 +3917,46 @@ pint2str (buf, width, d)
   }
 }
 
+/* Set a mnemonic character for CODING_SYSTEM (Lisp symbol) in BUF.
+   If EOL_FLAG is 1, set also a mnemonic character for end-of-line
+   type of CODING_SYSTEM.  Return updated pointer into BUF.  */
+
+static char *
+decode_mode_spec_coding (coding_system, buf, eol_flag)
+     Lisp_Object coding_system;
+     register char *buf;
+     int eol_flag;
+{
+  register Lisp_Object val = coding_system;
+
+  if (NILP (val))               /* Not yet decided.  */
+    {
+      *buf++ = '-';
+      if (eol_flag) *buf++ = eol_mnemonic_undecided;
+    }
+  else
+    {
+      while (!NILP (val) && SYMBOLP (val))
+        val = Fget (val, Qcoding_system);
+      *buf++ = XFASTINT (XVECTOR (val)->contents[1]);
+      if (eol_flag)
+        {
+          val = Fget (coding_system, Qeol_type);
+
+          if (NILP (val))       /* Not yet decided.  */
+            *buf++ = eol_mnemonic_undecided;
+          else if (VECTORP (val)) /* Not yet decided.  */
+            *buf++ = eol_mnemonic_undecided;
+          else                  /* INTEGERP (val) -- 1:LF, 2:CRLF, 3:CR */
+            *buf++ = (XFASTINT (val) == 1
+                      ? eol_mnemonic_unix
+                      : (XFASTINT (val) == 2
+                         ? eol_mnemonic_dos : eol_mnemonic_mac));
+        }
+    }
+  return buf;
+}
+
 /* Return a string for the output of a mode line %-spec for window W,
    generated by character C.  SPEC_WIDTH is the field width when
    padding to the left (%c, %l).  The value returned from this
@@ -4052,6 +4279,36 @@ decode_mode_spec (w, c, spec_width, maxwidth)
 #else
       return "T";
 #endif
+
+    case 'z':
+      /* coding-system (not including end-of-line format) */
+    case 'Z':
+      /* coding-system (including end-of-line type) */
+      {
+        int eol_flag = (c == 'Z');
+        char *p;
+
+        p = decode_mode_spec_coding
+          (find_symbol_value (Qbuffer_file_coding_system),
+           decode_mode_spec_buf, eol_flag);
+        if (FRAME_TERMCAP_P (f))
+          {
+            p = decode_mode_spec_coding (keyboard_coding.symbol, p, eol_flag);
+            p = decode_mode_spec_coding (terminal_coding.symbol, p, eol_flag);
+          }
+#ifdef subprocesses
+        obj = Fget_buffer_process (Fcurrent_buffer ());
+        if (PROCESSP (obj))
+          {
+            p = decode_mode_spec_coding (XPROCESS (obj)->decode_coding_system,
+                                         p, eol_flag);
+            p = decode_mode_spec_coding (XPROCESS (obj)->encode_coding_system,
+                                         p, eol_flag);
+          }
+#endif /* subprocesses */
+        *p = 0;
+        return decode_mode_spec_buf;
+      }
     }
 
   if (STRINGP (obj))
@@ -4104,8 +4361,8 @@ display_scan_buffer (start, count, shortage)
       {
         ceiling =  BUFFER_CEILING_OF (start);
         ceiling = min (limit, ceiling);
-        ceiling_addr = &FETCH_CHAR (ceiling) + 1;
-        base = (cursor = &FETCH_CHAR (start));
+        ceiling_addr = POS_ADDR (ceiling) + 1;
+        base = (cursor = POS_ADDR (start));
         while (1)
           {
             while (*cursor != '\n' && *cursor != 015 && ++cursor != ceiling_addr)
@@ -4133,8 +4390,8 @@ display_scan_buffer (start, count, shortage)
         {                       /* we WILL scan under start */
           ceiling =  BUFFER_FLOOR_OF (start);
           ceiling = max (limit, ceiling);
-          ceiling_addr = &FETCH_CHAR (ceiling) - 1;
-          base = (cursor = &FETCH_CHAR (start));
+          ceiling_addr = POS_ADDR (ceiling) - 1;
+          base = (cursor = POS_ADDR (start));
           cursor++;
           while (1)
             {
@@ -4235,6 +4492,8 @@ display_string (w, vpos, string, length, hpos, truncate,
   struct frame_glyphs *desired_glyphs = FRAME_DESIRED_GLYPHS (f);
   GLYPH *p1start = desired_glyphs->glyphs[vpos] + hpos;
   int window_width = XFASTINT (w->width);
+  /* If 1, we must display multibyte characters.  */
+  int multibyte = !NILP (XBUFFER (w->buffer)->enable_multibyte_characters);
 
   /* Use the standard display table, not the window's display table.
      We don't want the mode line in rot13.  */
@@ -4278,20 +4537,25 @@ display_string (w, vpos, string, length, hpos, truncate,
   if (maxcol >= 0 && mincol > maxcol)
     mincol = maxcol;
 
+  if (length < 0)
+    /* We need this value for multibyte characters.  */
+    length = strlen (string);
+
   /* We set truncated to 1 if we get stopped by trying to pass END
      (that is, trying to pass MAXCOL.)  */
   truncated = 0;
   while (1)
     {
-      if (length == 0)
-        break;
-      c = *string++;
-      /* Specified length.  */
-      if (length >= 0)
-        length--;
-      /* Unspecified length (null-terminated string).  */
-      else if (c == 0)
+      int len;
+
+      if (length <= 0)
         break;
+      if (multibyte)
+        c = STRING_CHAR_AND_LENGTH (string, length, len);
+      else
+        c = *string, len = 1;
+
+      string += len, length -= len;
 
       if (p1 >= end)
         {
@@ -4333,8 +4597,9 @@ display_string (w, vpos, string, length, hpos, truncate,
             *p1 = c ^ 0100;
           p1++;
         }
-      else
+      else if (len == 1)
         {
+          /* C is a control character or a binary byte data.  */
           if (p1 >= start)
             *p1 = fix_glyph (f, (dp && INTEGERP (DISP_ESCAPE_GLYPH (dp))
                                  ? XINT (DISP_ESCAPE_GLYPH (dp)) : '\\'),
@@ -4350,6 +4615,48 @@ display_string (w, vpos, string, length, hpos, truncate,
             *p1 = (7 & c) + '0';
           p1++;
         }
+      else
+        {
+          /* C is a multibyte character.  */      
+          int charset = CHAR_CHARSET (c);
+          int columns = (charset == CHARSET_COMPOSITION
+                         ? cmpchar_table[COMPOSITE_CHAR_ID (c)]->width
+                         : CHARSET_WIDTH (charset));
+
+          if (p1 < start)
+            {
+              /* Since we can't show the left part of C, fill all
+                 columns with spaces.  */
+              columns -= start - p1;
+              p1 = start;
+              while (columns--)
+                {
+                  if (p1 < end)
+                    *p1 = SPACEGLYPH;
+                  p1++;
+                }
+            }
+          else if (p1 + columns > end)
+            {
+              /* Since we can't show the right part of C, fill all
+                 columns with TRUNCATE if TRUNCATE is specified.  */
+              if (truncate)
+                {
+                  while (p1 < end)
+                    *p1++ = fix_glyph (f, truncate, 0);
+                  /* And tell the line is truncated.  */
+                  truncated = 1;
+                }
+              break;
+            }
+          else
+            {
+              /* We can show the whole glyph of C.  */
+              *p1++ = c;
+              while (--columns)
+                *p1++ = c | GLYPH_MASK_PADDING;
+            }
+        }
     }
 
   if (truncated)