merge trunk

12 files changed, 533 insertions, 175 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 12a45918e87..3282654ab06 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,88 @@
+2011-09-25  Michael Albinus  <michael.albinus@gmx.de>
+
+        * dbusbind.c (Fdbus_register_signal): When service is not
+        registered, use nil in Vdbus_registered_objects_table.  (Bug#9581)
+
+2011-09-25  Glenn Morris  <rgm@gnu.org>
+
+        * buffer.c (truncate-lines): Doc fix.
+
+2011-09-24  Chong Yidong  <cyd@stupidchicken.com>
+
+        * window.c (Fwindow_prev_buffers, Fset_window_prev_buffers)
+        (Fset_window_next_buffers): Doc fix.
+
+2011-09-24  Glenn Morris  <rgm@gnu.org>
+
+        * minibuf.c (read_minibuf): Disable line truncation.  (Bug#5715)
+
+2011-09-24  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix minor problems found by static checking.
+        * xdisp.c (string_from_display_spec): Don't assume vecsize fits in int.
+        * indent.c (Fvertical_motion): Fix == vs = typo.
+
+2011-09-24  Eli Zaretskii  <eliz@gnu.org>
+
+        * dispnew.c (syms_of_display) <redisplay-dont-pause>: Default
+        value is now t.  Doc fix.
+
+        * indent.c (Fvertical_motion): Compute and apply the overshoot
+        logic when moving up, not only when moving down.  Fix the
+        confusing name and values of the it_overshoot_expected variable;
+        logic changes accordingly.  (Bug#9254) (Bug#9549)
+
+        * xdisp.c (pos_visible_p): Produce correct pixel coordinates when
+        CHARPOS is covered by a display string which includes newlines.
+        (move_it_vertically_backward): Avoid inflooping when START_CHARPOS
+        is covered by a display string with embedded newlines.
+
+2011-09-24  Michael Albinus  <michael.albinus@gmx.de>
+
+        * dbusbind.c (Fdbus_register_signal): Add match rule to
+        Vdbus_registered_objects_table.  (Bug#9581)
+        (Fdbus_register_method, Vdbus_registered_objects_table): Fix
+        docstring.
+
+2011-09-24  Jim Meyering  <meyering@redhat.com>
+
+        do not ignore write error for any output size
+        The previous change was incomplete.
+        While it makes emacs --batch detect the vast majority of stdout
+        write failures, errors were still ignored whenever the output size is
+        k * (BUFSIZ+1) - 4.  E.g., on a system with BUFSIZ of 4096,
+          $ emacs --batch --eval '(print (format "%4093d" 0))' > /dev/full \
+              && echo FAIL: ignored write error
+          FAIL: ignored write error
+          $ emacs --batch --eval '(print (format "%20481d" 0))' > /dev/full \
+              && echo FAIL: ignored write error
+          FAIL: ignored write error
+        * emacs.c (Fkill_emacs): Also test ferror.  (Bug#9574)
+
+2011-09-23  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * emacs.c (Fkill_emacs): In noninteractive mode exit
+        non-successfully if a write error occurred on stdout.  (Bug#9574)
+
+2011-09-21  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (pop_it): Allow it->object that is a cons cell to pass
+        the xassert test.
+
+        * dispextern.h (struct it): Update the comment documenting what
+        can it->OBJECT be.
+
+2011-09-20  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (set_cursor_from_row): If the row ends in a newline from
+        a display string, extend search for cursor position to end of row.
+        (find_row_edges): If the row ends in a newline from a display
+        string, increment its MATRIX_ROW_END_CHARPOS by one.  (Bug#9549)
+        Handle the case of a display string with multiple newlines.
+        (Fcurrent_bidi_paragraph_direction): Fix search for previous
+        non-empty line.  Fixes confusing cursor motion with arrow keys at
+        the beginning of a line that starts with whitespace.
+
 2011-09-19  Lars Magne Ingebrigtsen  <larsi@gnus.org>
 
         * lread.c (Fread_from_string): Document what FINAL-STRING-INDEX is
diff --git a/src/ChangeLog.11 b/src/ChangeLog.11
index 6f462e32534..b64736459c8 100644
--- a/src/ChangeLog.11
+++ b/src/ChangeLog.11
@@ -2927,7 +2927,7 @@
         * nsimage.m (EmacsImage-setXBMColor:): Correct previous patch:
         don't change the method signature, change the return.
 
-2010-11-04  Ismail Donmez  <ismail@namtrac.org>  (tiny change)
+2010-11-04  İsmail Dönmez  <ismail@namtrac.org>  (tiny change)
 
         * nsfont.m (nsfont_draw)
         * nsimage.m (EmacsImage-setXBMColor:)
diff --git a/src/bidi.c b/src/bidi.c
index 3efdc1590df..599c00449b5 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -222,7 +222,7 @@ bidi_mirror_char (int c)
 static inline void
 bidi_set_sor_type (struct bidi_it *bidi_it, int level_before, int level_after)
 {
-  int higher_level = level_before > level_after ? level_before : level_after;
+  int higher_level = (level_before > level_after ? level_before : level_after);
 
   /* The prev_was_pdf gork is required for when we have several PDFs
      in a row.  In that case, we want to compute the sor type for the
@@ -233,18 +233,18 @@ bidi_set_sor_type (struct bidi_it *bidi_it, int level_before, int level_after)
      level to which we descend after processing all the PDFs.  */
   if (!bidi_it->prev_was_pdf || level_before < level_after)
     /* FIXME: should the default sor direction be user selectable?  */
-    bidi_it->sor = (higher_level & 1) != 0 ? R2L : L2R;
+    bidi_it->sor = ((higher_level & 1) != 0 ? R2L : L2R);
   if (level_before > level_after)
     bidi_it->prev_was_pdf = 1;
 
   bidi_it->prev.type = UNKNOWN_BT;
-  bidi_it->last_strong.type = bidi_it->last_strong.type_after_w1 =
-    bidi_it->last_strong.orig_type = UNKNOWN_BT;
-  bidi_it->prev_for_neutral.type = bidi_it->sor == R2L ? STRONG_R : STRONG_L;
+  bidi_it->last_strong.type = bidi_it->last_strong.type_after_w1
+    = bidi_it->last_strong.orig_type = UNKNOWN_BT;
+  bidi_it->prev_for_neutral.type = (bidi_it->sor == R2L ? STRONG_R : STRONG_L);
   bidi_it->prev_for_neutral.charpos = bidi_it->charpos;
   bidi_it->prev_for_neutral.bytepos = bidi_it->bytepos;
-  bidi_it->next_for_neutral.type = bidi_it->next_for_neutral.type_after_w1 =
-    bidi_it->next_for_neutral.orig_type = UNKNOWN_BT;
+  bidi_it->next_for_neutral.type = bidi_it->next_for_neutral.type_after_w1
+    = bidi_it->next_for_neutral.orig_type = UNKNOWN_BT;
   bidi_it->ignore_bn_limit = -1; /* meaning it's unknown */
 }
 
@@ -325,10 +325,10 @@ static int bidi_cache_sp;
 /* Size of header used by bidi_shelve_cache.  */
 enum
   {
-    bidi_shelve_header_size =
-      (sizeof (bidi_cache_idx) + sizeof (bidi_cache_start_stack)
-       + sizeof (bidi_cache_sp) + sizeof (bidi_cache_start)
-       + sizeof (bidi_cache_last_idx))
+    bidi_shelve_header_size
+      = (sizeof (bidi_cache_idx) + sizeof (bidi_cache_start_stack)
+         + sizeof (bidi_cache_sp) + sizeof (bidi_cache_start)
+         + sizeof (bidi_cache_last_idx))
   };
 
 /* Reset the cache state to the empty state.  We only reset the part
@@ -353,8 +353,8 @@ bidi_cache_shrink (void)
 {
   if (bidi_cache_size > BIDI_CACHE_CHUNK)
     {
-      bidi_cache =
-        (struct bidi_it *) xrealloc (bidi_cache, BIDI_CACHE_CHUNK * elsz);
+      bidi_cache
+        = (struct bidi_it *) xrealloc (bidi_cache, BIDI_CACHE_CHUNK * elsz);
       bidi_cache_size = BIDI_CACHE_CHUNK;
     }
   bidi_cache_reset ();
@@ -490,17 +490,17 @@ bidi_cache_ensure_space (ptrdiff_t idx)
     {
       /* The bidi cache cannot be larger than the largest Lisp string
          or buffer.  */
-      ptrdiff_t string_or_buffer_bound =
-        max (BUF_BYTES_MAX, STRING_BYTES_BOUND);
+      ptrdiff_t string_or_buffer_bound
+        = max (BUF_BYTES_MAX, STRING_BYTES_BOUND);
 
       /* Also, it cannot be larger than what C can represent.  */
-      ptrdiff_t c_bound =
-        (min (PTRDIFF_MAX, SIZE_MAX) - bidi_shelve_header_size) / elsz;
+      ptrdiff_t c_bound
+        = (min (PTRDIFF_MAX, SIZE_MAX) - bidi_shelve_header_size) / elsz;
 
-      bidi_cache =
-        xpalloc (bidi_cache, &bidi_cache_size,
-                 max (BIDI_CACHE_CHUNK, idx - bidi_cache_size + 1),
-                 min (string_or_buffer_bound, c_bound), elsz);
+      bidi_cache
+        = xpalloc (bidi_cache, &bidi_cache_size,
+                   max (BIDI_CACHE_CHUNK, idx - bidi_cache_size + 1),
+                   min (string_or_buffer_bound, c_bound), elsz);
     }
 }
 
@@ -708,8 +708,8 @@ bidi_unshelve_cache (void *databuf, int just_free)
           ptrdiff_t idx;
 
           memcpy (&idx, p, sizeof (bidi_cache_idx));
-          bidi_cache_total_alloc -=
-            bidi_shelve_header_size + idx * sizeof (struct bidi_it);
+          bidi_cache_total_alloc
+            -= bidi_shelve_header_size + idx * sizeof (struct bidi_it);
         }
       else
         {
@@ -737,8 +737,9 @@ bidi_unshelve_cache (void *databuf, int just_free)
                   + sizeof (bidi_cache_start_stack) + sizeof (bidi_cache_sp)
                   + sizeof (bidi_cache_start),
                   sizeof (bidi_cache_last_idx));
-          bidi_cache_total_alloc -=
-            bidi_shelve_header_size + bidi_cache_idx * sizeof (struct bidi_it);
+          bidi_cache_total_alloc
+            -= (bidi_shelve_header_size
+                + bidi_cache_idx * sizeof (struct bidi_it));
         }
 
       xfree (p);
@@ -813,18 +814,18 @@ bidi_init_it (EMACS_INT charpos, EMACS_INT bytepos, int frame_window_p,
   bidi_it->type_after_w1 = NEUTRAL_B;
   bidi_it->orig_type = NEUTRAL_B;
   bidi_it->prev_was_pdf = 0;
-  bidi_it->prev.type = bidi_it->prev.type_after_w1 =
-    bidi_it->prev.orig_type = UNKNOWN_BT;
-  bidi_it->last_strong.type = bidi_it->last_strong.type_after_w1 =
-    bidi_it->last_strong.orig_type = UNKNOWN_BT;
+  bidi_it->prev.type = bidi_it->prev.type_after_w1
+    = bidi_it->prev.orig_type = UNKNOWN_BT;
+  bidi_it->last_strong.type = bidi_it->last_strong.type_after_w1
+    = bidi_it->last_strong.orig_type = UNKNOWN_BT;
   bidi_it->next_for_neutral.charpos = -1;
-  bidi_it->next_for_neutral.type =
-    bidi_it->next_for_neutral.type_after_w1 =
-    bidi_it->next_for_neutral.orig_type = UNKNOWN_BT;
+  bidi_it->next_for_neutral.type
+    = bidi_it->next_for_neutral.type_after_w1
+    = bidi_it->next_for_neutral.orig_type = UNKNOWN_BT;
   bidi_it->prev_for_neutral.charpos = -1;
-  bidi_it->prev_for_neutral.type =
-    bidi_it->prev_for_neutral.type_after_w1 =
-    bidi_it->prev_for_neutral.orig_type = UNKNOWN_BT;
+  bidi_it->prev_for_neutral.type
+    = bidi_it->prev_for_neutral.type_after_w1
+    = bidi_it->prev_for_neutral.orig_type = UNKNOWN_BT;
   bidi_it->sor = L2R;    /* FIXME: should it be user-selectable? */
   bidi_it->disp_pos = -1;       /* invalid/unknown */
   bidi_it->disp_prop = 0;
@@ -848,7 +849,7 @@ bidi_line_init (struct bidi_it *bidi_it)
   bidi_it->next_en_pos = -1;
   bidi_it->next_for_ws.type = UNKNOWN_BT;
   bidi_set_sor_type (bidi_it,
-                     bidi_it->paragraph_dir == R2L ? 1 : 0,
+                     (bidi_it->paragraph_dir == R2L ? 1 : 0),
                      bidi_it->level_stack[0].level); /* X10 */
 
   bidi_cache_reset ();
@@ -925,8 +926,8 @@ bidi_fetch_char (EMACS_INT bytepos, EMACS_INT charpos, EMACS_INT *disp_pos,
                  int frame_window_p, EMACS_INT *ch_len, EMACS_INT *nchars)
 {
   int ch;
-  EMACS_INT endpos =
-    (string->s || STRINGP (string->lstring)) ? string->schars : ZV;
+  EMACS_INT endpos
+    = (string->s || STRINGP (string->lstring)) ? string->schars : ZV;
   struct text_pos pos;
 
   /* If we got past the last known position of display string, compute
@@ -1173,8 +1174,9 @@ bidi_paragraph_init (bidi_dir_t dir, struct bidi_it *bidi_it, int no_default_p)
          we are potentially in a new paragraph that doesn't yet
          exist.  */
       pos = bidi_it->charpos;
-      s = STRINGP (bidi_it->string.lstring) ?
-        SDATA (bidi_it->string.lstring) : bidi_it->string.s;
+      s = (STRINGP (bidi_it->string.lstring)
+           ? SDATA (bidi_it->string.lstring)
+           : bidi_it->string.s);
       if (bytepos > begbyte
           && bidi_char_at_pos (bytepos, s, bidi_it->string.unibyte) == '\n')
         {
@@ -1324,9 +1326,10 @@ bidi_resolve_explicit_1 (struct bidi_it *bidi_it)
       bidi_it->first_elt = 0;
       if (string_p)
         {
-          const unsigned char *p =
-            STRINGP (bidi_it->string.lstring)
-            ? SDATA (bidi_it->string.lstring) : bidi_it->string.s;
+          const unsigned char *p
+            = (STRINGP (bidi_it->string.lstring)
+               ? SDATA (bidi_it->string.lstring)
+               : bidi_it->string.s);
 
           if (bidi_it->charpos < 0)
             bidi_it->charpos = 0;
@@ -1509,8 +1512,10 @@ bidi_resolve_explicit (struct bidi_it *bidi_it)
   int prev_level = bidi_it->level_stack[bidi_it->stack_idx].level;
   int new_level  = bidi_resolve_explicit_1 (bidi_it);
   EMACS_INT eob = bidi_it->string.s ? bidi_it->string.schars : ZV;
-  const unsigned char *s = STRINGP (bidi_it->string.lstring)
-    ? SDATA (bidi_it->string.lstring) : bidi_it->string.s;
+  const unsigned char *s
+    = (STRINGP (bidi_it->string.lstring)
+       ? SDATA (bidi_it->string.lstring)
+       : bidi_it->string.s);
 
   if (prev_level < new_level
       && bidi_it->type == WEAK_BN
@@ -1594,9 +1599,9 @@ bidi_resolve_weak (struct bidi_it *bidi_it)
   int next_char;
   bidi_type_t type_of_next;
   struct bidi_it saved_it;
-  EMACS_INT eob =
-    (STRINGP (bidi_it->string.lstring) || bidi_it->string.s)
-    ? bidi_it->string.schars : ZV;
+  EMACS_INT eob
+    = ((STRINGP (bidi_it->string.lstring) || bidi_it->string.s)
+       ? bidi_it->string.schars : ZV);
 
   type = bidi_it->type;
   override = bidi_it->level_stack[bidi_it->stack_idx].override;
@@ -1663,15 +1668,15 @@ bidi_resolve_weak (struct bidi_it *bidi_it)
                         && bidi_it->prev.orig_type == WEAK_EN)
                        || bidi_it->prev.type_after_w1 == WEAK_AN)))
         {
-          const unsigned char *s =
-            STRINGP (bidi_it->string.lstring)
-            ? SDATA (bidi_it->string.lstring) : bidi_it->string.s;
-
-          next_char =
-            bidi_it->charpos + bidi_it->nchars >= eob
-            ? BIDI_EOB
-            : bidi_char_at_pos (bidi_it->bytepos + bidi_it->ch_len, s,
-                                bidi_it->string.unibyte);
+          const unsigned char *s
+            = (STRINGP (bidi_it->string.lstring)
+               ? SDATA (bidi_it->string.lstring)
+               : bidi_it->string.s);
+
+          next_char = (bidi_it->charpos + bidi_it->nchars >= eob
+                       ? BIDI_EOB
+                       : bidi_char_at_pos (bidi_it->bytepos + bidi_it->ch_len,
+                                           s, bidi_it->string.unibyte));
           type_of_next = bidi_get_type (next_char, override);
 
           if (type_of_next == WEAK_BN
@@ -1720,17 +1725,17 @@ bidi_resolve_weak (struct bidi_it *bidi_it)
           else                  /* W5: ET/BN with EN after it.  */
             {
               EMACS_INT en_pos = bidi_it->charpos + bidi_it->nchars;
-              const unsigned char *s =
-                STRINGP (bidi_it->string.lstring)
-                ? SDATA (bidi_it->string.lstring) : bidi_it->string.s;
+              const unsigned char *s = (STRINGP (bidi_it->string.lstring)
+                                        ? SDATA (bidi_it->string.lstring)
+                                        : bidi_it->string.s);
 
               if (bidi_it->nchars <= 0)
                 abort ();
-              next_char =
-                bidi_it->charpos + bidi_it->nchars >= eob
-                ? BIDI_EOB
-                : bidi_char_at_pos (bidi_it->bytepos + bidi_it->ch_len, s,
-                                    bidi_it->string.unibyte);
+              next_char
+                = (bidi_it->charpos + bidi_it->nchars >= eob
+                   ? BIDI_EOB
+                   : bidi_char_at_pos (bidi_it->bytepos + bidi_it->ch_len, s,
+                                       bidi_it->string.unibyte));
               type_of_next = bidi_get_type (next_char, override);
 
               if (type_of_next == WEAK_ET
@@ -1875,8 +1880,8 @@ bidi_resolve_neutral (struct bidi_it *bidi_it)
                          && bidi_get_category (type) != NEUTRAL)
                      /* This is all per level run, so stop when we
                         reach the end of this level run.  */
-                     || bidi_it->level_stack[bidi_it->stack_idx].level !=
-                     current_level));
+                     || (bidi_it->level_stack[bidi_it->stack_idx].level
+                         != current_level)));
 
           bidi_remember_char (&saved_it.next_for_neutral, bidi_it);
 
@@ -1971,9 +1976,9 @@ bidi_level_of_next_char (struct bidi_it *bidi_it)
 
   if (bidi_it->scan_dir == 1)
     {
-      EMACS_INT eob =
-        (bidi_it->string.s || STRINGP (bidi_it->string.lstring))
-        ? bidi_it->string.schars : ZV;
+      EMACS_INT eob
+        = ((bidi_it->string.s || STRINGP (bidi_it->string.lstring))
+           ? bidi_it->string.schars : ZV);
 
       /* There's no sense in trying to advance if we hit end of text.  */
       if (bidi_it->charpos >= eob)
@@ -2018,9 +2023,8 @@ bidi_level_of_next_char (struct bidi_it *bidi_it)
      UNKNOWN_BT.  */
   if (bidi_cache_idx > bidi_cache_start && !bidi_it->first_elt)
     {
-      int bob =
-        (bidi_it->string.s || STRINGP (bidi_it->string.lstring)) ? 0 : 1;
-
+      int bob = ((bidi_it->string.s || STRINGP (bidi_it->string.lstring))
+                 ? 0 : 1);
       if (bidi_it->scan_dir > 0)
         {
           if (bidi_it->nchars <= 0)
@@ -2345,9 +2349,9 @@ bidi_move_to_visually_next (struct bidi_it *bidi_it)
         bidi_it->separator_limit = bidi_it->string.schars;
       else if (bidi_it->bytepos < ZV_BYTE)
         {
-          EMACS_INT sep_len =
-            bidi_at_paragraph_end (bidi_it->charpos + bidi_it->nchars,
-                                   bidi_it->bytepos + bidi_it->ch_len);
+          EMACS_INT sep_len
+            = bidi_at_paragraph_end (bidi_it->charpos + bidi_it->nchars,
+                                     bidi_it->bytepos + bidi_it->ch_len);
           if (bidi_it->nchars <= 0)
             abort ();
           if (sep_len >= 0)
@@ -2355,8 +2359,8 @@ bidi_move_to_visually_next (struct bidi_it *bidi_it)
               bidi_it->new_paragraph = 1;
               /* Record the buffer position of the last character of the
                  paragraph separator.  */
-              bidi_it->separator_limit =
-                bidi_it->charpos + bidi_it->nchars + sep_len;
+              bidi_it->separator_limit
+                = bidi_it->charpos + bidi_it->nchars + sep_len;
             }
         }
     }
diff --git a/src/buffer.c b/src/buffer.c
index 37d2975c8c7..dffdeb536fc 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -5493,7 +5493,9 @@ Instead, give each line of text just one screen line.
 
 Note that this is overridden by the variable
 `truncate-partial-width-windows' if that variable is non-nil
-and this buffer is not full-frame width.  */);
+and this buffer is not full-frame width.
+
+Minibuffers set this variable to nil.  */);
 
   DEFVAR_PER_BUFFER ("word-wrap", &BVAR (current_buffer, word_wrap), Qnil,
                      doc: /* *Non-nil means to use word-wrapping for continuation lines.
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 227d4e647e9..52e08d8ee2a 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -2071,13 +2071,7 @@ usage: (dbus-register-signal BUS SERVICE PATH INTERFACE SIGNAL HANDLER &rest ARG
       && (SBYTES (service) > 0)
       && (strcmp (SSDATA (service), DBUS_SERVICE_DBUS) != 0)
       && (strncmp (SSDATA (service), ":", 1) != 0))
-    {
-      uname = call2 (intern ("dbus-get-name-owner"), bus, service);
-      /* When there is no unique name, we mark it with an empty
-         string.  */
-      if (NILP (uname))
-        uname = empty_unibyte_string;
-    }
+    uname = call2 (intern ("dbus-get-name-owner"), bus, service);
   else
     uname = service;
 
@@ -2145,7 +2139,7 @@ usage: (dbus-register-signal BUS SERVICE PATH INTERFACE SIGNAL HANDLER &rest ARG
 
   /* Create a hash table entry.  */
   key = list3 (bus, interface, signal);
-  key1 = list4 (uname, service, path, handler);
+  key1 = list5 (uname, service, path, handler, build_string (rule));
   value = Fgethash (key, Vdbus_registered_objects_table, Qnil);
 
   if (NILP (Fmember (key1, value)))
@@ -2177,7 +2171,7 @@ When DONT-REGISTER-SERVICE is non-nil, the known name SERVICE is not
 registered.  This means that other D-Bus clients have no way of
 noticing the newly registered method.  When interfaces are constructed
 incrementally by adding single methods or properties at a time,
-DONT-REGISTER-SERVICE can be use to prevent other clients from
+DONT-REGISTER-SERVICE can be used to prevent other clients from
 discovering the still incomplete interface.*/)
   (Lisp_Object bus, Lisp_Object service, Lisp_Object path,
    Lisp_Object interface, Lisp_Object method, Lisp_Object handler,
@@ -2319,6 +2313,9 @@ be called when a D-Bus message, which matches the key criteria,
 arrives (methods and signals), or a cons cell containing the value of
 the property.
 
+For signals, there is also a fifth element RULE, which keeps the match
+string the signal is registered with.
+
 In the second case, the key in the hash table is the list (BUS
 SERIAL).  BUS is either a Lisp symbol, `:system' or `:session', or a
 string denoting the bus address.  SERIAL is the serial number of the
diff --git a/src/dispextern.h b/src/dispextern.h
index 65284121588..3c157371ef3 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -2398,9 +2398,19 @@ struct it
   Lisp_Object font_height;
 
   /* Object and position where the current display element came from.
-     Object can be a Lisp string in case the current display element
-     comes from an overlay string, or it is buffer.  It may also be nil
-     during mode-line update.  Position is a position in object.  */
+     Object is normally the buffer which is being rendered, but it can
+     also be a Lisp string in case the current display element comes
+     from an overlay string or from a display string (before- or
+     after-string).  It may also be nil when a C string is being
+     rendered, e.g., during mode-line or header-line update.  It can
+     also be a cons cell of the form `(space ...)', when we produce a
+     stretch glyph from a `display' specification.  Finally, it can be
+     a zero-valued Lisp integer, but only temporarily, when we are
+     producing special glyphs for display purposes, like truncation
+     and continuation glyphs, or blanks that extend each line to the
+     edge of the window on a TTY.
+
+     Position is the current iterator position in object.  */
   Lisp_Object object;
   struct text_pos position;
 
diff --git a/src/dispnew.c b/src/dispnew.c
index 958420d3081..51b17fc0f11 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -6494,8 +6494,8 @@ See `buffer-display-table' for more information.  */);
   Vstandard_display_table = Qnil;
 
   DEFVAR_BOOL ("redisplay-dont-pause", redisplay_dont_pause,
-               doc: /* *Non-nil means update isn't paused when input is detected.  */);
-  redisplay_dont_pause = 0;
+               doc: /* *Non-nil means display update isn't paused when input is detected.  */);
+  redisplay_dont_pause = 1;
 
 #if PERIODIC_PREEMPTION_CHECKING
   DEFVAR_LISP ("redisplay-preemption-period", Vredisplay_preemption_period,
diff --git a/src/emacs.c b/src/emacs.c
index 321e7919c93..073156bb0c9 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -1993,6 +1993,7 @@ all of which are called before Emacs is actually killed.  */)
 {
   struct gcpro gcpro1;
   Lisp_Object hook;
+  int exit_code;
 
   GCPRO1 (arg);
 
@@ -2017,7 +2018,10 @@ all of which are called before Emacs is actually killed.  */)
   if (STRINGP (Vauto_save_list_file_name))
     unlink (SSDATA (Vauto_save_list_file_name));
 
-  exit (INTEGERP (arg) ? XINT (arg) : EXIT_SUCCESS);
+  exit_code = EXIT_SUCCESS;
+  if (noninteractive && (fflush (stdout) || ferror (stdout)))
+    exit_code = EXIT_FAILURE;
+  exit (INTEGERP (arg) ? XINT (arg) : exit_code);
 }
 
 
diff --git a/src/indent.c b/src/indent.c
index e00d2152577..a70b7971b96 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -2019,7 +2019,8 @@ whether or not it is currently displayed in some window.  */)
   else
     {
       EMACS_INT it_start;
-      int first_x, it_overshoot_expected IF_LINT (= 0);
+      int first_x, it_overshoot_count = 0;
+      int overshoot_handled = 0;
 
       itdata = bidi_shelve_cache ();
       SET_TEXT_POS (pt, PT, PT_BYTE);
@@ -2028,22 +2029,23 @@ whether or not it is currently displayed in some window.  */)
       it_start = IT_CHARPOS (it);
 
       /* See comments below for why we calculate this.  */
-      if (XINT (lines) > 0)
+      if (it.cmp_it.id >= 0)
+        it_overshoot_count = 0;
+      else if (it.method == GET_FROM_STRING)
         {
-          if (it.cmp_it.id >= 0)
-            it_overshoot_expected = 1;
-          else if (it.method == GET_FROM_STRING)
+          const char *s = SSDATA (it.string);
+          const char *e = s + SBYTES (it.string);
+          while (s < e)
             {
-              const char *s = SSDATA (it.string);
-              const char *e = s + SBYTES (it.string);
-              while (s < e && *s != '\n')
-                ++s;
-              it_overshoot_expected = (s == e) ? -1 : 0;
+              if (*s++ == '\n')
+                it_overshoot_count++;
             }
-          else
-            it_overshoot_expected = (it.method == GET_FROM_IMAGE
-                                     || it.method == GET_FROM_STRETCH);
+          if (!it_overshoot_count)
+            it_overshoot_count = -1;
         }
+      else
+        it_overshoot_count =
+          !(it.method == GET_FROM_IMAGE || it.method == GET_FROM_STRETCH);
 
       /* Scan from the start of the line containing PT.  If we don't
          do this, we start moving with IT->current_x == 0, while PT is
@@ -2057,6 +2059,25 @@ whether or not it is currently displayed in some window.  */)
            tell, and it causes Bug#2694 .  -- cyd */
         move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
 
+      /* IT may move too far if truncate-lines is on and PT lies
+         beyond the right margin.  IT may also move too far if the
+         starting point is on a Lisp string that has embedded
+         newlines.  In these cases, backtrack.  */
+      if (IT_CHARPOS (it) > it_start)
+        {
+          /* We need to backtrack also if the Lisp string contains no
+             newlines, but there is a newline right after it.  In this
+             case, IT overshoots if there is an after-string just
+             before the newline.  */
+          if (it_overshoot_count < 0
+              && it.method == GET_FROM_BUFFER
+              && it.c == '\n')
+            it_overshoot_count = 1;
+          if (it_overshoot_count > 0)
+            move_it_by_lines (&it, -it_overshoot_count);
+
+          overshoot_handled = 1;
+        }
       if (XINT (lines) <= 0)
         {
           it.vpos = 0;
@@ -2065,47 +2086,31 @@ whether or not it is currently displayed in some window.  */)
           if (XINT (lines) == 0 || IT_CHARPOS (it) > 0)
             move_it_by_lines (&it, max (INT_MIN, XINT (lines)));
         }
+      else if (overshoot_handled)
+        {
+          it.vpos = 0;
+          move_it_by_lines (&it, min (INT_MAX, XINT (lines)));
+        }
       else
         {
-          if (IT_CHARPOS (it) > it_start)
-            {
-              /* IT may move too far if truncate-lines is on and PT
-                 lies beyond the right margin.  In that case,
-                 backtrack unless the starting point is on an image,
-                 stretch glyph, composition, or Lisp string.  */
-              if (!it_overshoot_expected
-                  /* Also, backtrack if the Lisp string contains no
-                     newline, but there is a newline right after it.
-                     In this case, IT overshoots if there is an
-                     after-string just before the newline.  */
-                  || (it_overshoot_expected < 0
-                      && it.method == GET_FROM_BUFFER
-                      && it.c == '\n'))
-                move_it_by_lines (&it, -1);
-              it.vpos = 0;
-              move_it_by_lines (&it, min (INT_MAX, XINT (lines)));
-            }
-          else
+          /* Otherwise, we are at the first row occupied by PT, which
+             might span multiple screen lines (e.g., if it's on a
+             multi-line display string).  We want to start from the
+             last line that it occupies.  */
+          if (it_start < ZV)
             {
-              /* Otherwise, we are at the first row occupied by PT,
-                 which might span multiple screen lines (e.g., if it's
-                 on a multi-line display string).  We want to start
-                 from the last line that it occupies.  */
-              if (it_start < ZV)
-                {
-                  while (IT_CHARPOS (it) <= it_start)
-                    {
-                      it.vpos = 0;
-                      move_it_by_lines (&it, 1);
-                    }
-                  if (XINT (lines) > 1)
-                    move_it_by_lines (&it, min (INT_MAX, XINT (lines) - 1));
-                }
-              else
+              while (IT_CHARPOS (it) <= it_start)
                 {
                   it.vpos = 0;
-                  move_it_by_lines (&it, min (INT_MAX, XINT (lines)));
+                  move_it_by_lines (&it, 1);
                 }
+              if (XINT (lines) > 1)
+                move_it_by_lines (&it, min (INT_MAX, XINT (lines) - 1));
+            }
+          else
+            {
+              it.vpos = 0;
+              move_it_by_lines (&it, min (INT_MAX, XINT (lines)));
             }
         }
 
diff --git a/src/minibuf.c b/src/minibuf.c
index d3f43b06254..341d544ef51 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -559,6 +559,10 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
   minibuffer = get_minibuffer (minibuf_level);
   Fset_buffer (minibuffer);
 
+  /* Defeat (setq-default truncate-lines t), since truncated lines do
+     not work correctly in minibuffers.  (Bug#5715, etc)  */
+  BVAR (current_buffer, truncate_lines) = Qnil;
+
   /* If appropriate, copy enable-multibyte-characters into the minibuffer.  */
   if (inherit_input_method)
     BVAR (current_buffer, enable_multibyte_characters) = enable_multibyte;
diff --git a/src/window.c b/src/window.c
index 39210b91616..ba06779846a 100644
--- a/src/window.c
+++ b/src/window.c
@@ -1665,8 +1665,9 @@ DEFUN ("window-prev-buffers", Fwindow_prev_buffers, Swindow_prev_buffers,
        doc:  /* Return buffers previously shown in WINDOW.
 WINDOW must be a live window and defaults to the selected one.
 
-The return value is either nil or a list of <buffer, window-start,
-window-point> triples where buffer was previously shown in WINDOW.  */)
+The return value is a list of elements (BUFFER WINDOW-START POS),
+where BUFFER is a buffer, WINDOW-START is the start position of the
+window for that buffer, and POS is a window-specific point value.  */)
   (Lisp_Object window)
 {
   return decode_window (window)->prev_buffers;
@@ -1675,11 +1676,11 @@ window-point> triples where buffer was previously shown in WINDOW.  */)
 DEFUN ("set-window-prev-buffers", Fset_window_prev_buffers,
        Sset_window_prev_buffers, 2, 2, 0,
        doc: /* Set WINDOW's previous buffers to PREV-BUFFERS.
-WINDOW must be a live window and defaults to the selected one.  Return
-PREV-BUFFERS.
+WINDOW must be a live window and defaults to the selected one.
 
-PREV-BUFFERS should be either nil or a list of <buffer, window-start,
-window-point> triples where buffer was previously shown in WINDOW.  */)
+PREV-BUFFERS should be a list of elements (BUFFER WINDOW-START POS),
+where BUFFER is a buffer, WINDOW-START is the start position of the
+window for that buffer, and POS is a window-specific point value.  */)
      (Lisp_Object window, Lisp_Object prev_buffers)
 {
   return decode_window (window)->prev_buffers = prev_buffers;
@@ -1697,11 +1698,8 @@ WINDOW must be a live window and defaults to the selected one.  */)
 DEFUN ("set-window-next-buffers", Fset_window_next_buffers,
        Sset_window_next_buffers, 2, 2, 0,
        doc: /* Set WINDOW's next buffers to NEXT-BUFFERS.
-WINDOW must be a live window and defaults to the selected one.  Return
-NEXT-BUFFERS.
-
-NEXT-BUFFERS should be either nil or a list of buffers that have been
-recently re-shown in WINDOW.  */)
+WINDOW must be a live window and defaults to the selected one.
+NEXT-BUFFERS should be a list of buffers.  */)
      (Lisp_Object window, Lisp_Object next_buffers)
 {
   return decode_window (window)->next_buffers = next_buffers;
diff --git a/src/xdisp.c b/src/xdisp.c
index d58eea538f5..a556236835c 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -1210,6 +1210,34 @@ line_bottom_y (struct it *it)
   return line_top_y + line_height;
 }
 
+/* Subroutine of pos_visible_p below.  Extracts a display string, if
+   any, from the display spec given as its argument.  */
+static Lisp_Object
+string_from_display_spec (Lisp_Object spec)
+{
+  if (CONSP (spec))
+    {
+      while (CONSP (spec))
+        {
+          if (STRINGP (XCAR (spec)))
+            return XCAR (spec);
+          spec = XCDR (spec);
+        }
+    }
+  else if (VECTORP (spec))
+    {
+      ptrdiff_t i;
+
+      for (i = 0; i < ASIZE (spec); i++)
+        {
+          if (STRINGP (AREF (spec, i)))
+            return AREF (spec, i);
+        }
+      return Qnil;
+    }
+
+  return spec;
+}
 
 /* Return 1 if position CHARPOS is visible in window W.
    CHARPOS < 0 means return info about WINDOW_END position.
@@ -1304,6 +1332,136 @@ pos_visible_p (struct window *w, EMACS_INT charpos, int *x, int *y,
                     }
                 }
             }
+          else if (IT_CHARPOS (it) != charpos)
+            {
+              Lisp_Object cpos = make_number (charpos);
+              Lisp_Object spec = Fget_char_property (cpos, Qdisplay, Qnil);
+              Lisp_Object string = string_from_display_spec (spec);
+              int newline_in_string = 0;
+
+              if (STRINGP (string))
+                {
+                  const char *s = SSDATA (string);
+                  const char *e = s + SBYTES (string);
+                  while (s < e)
+                    {
+                      if (*s++ == '\n')
+                        {
+                          newline_in_string = 1;
+                          break;
+                        }
+                    }
+                }
+              /* The tricky code below is needed because there's a
+                 discrepancy between move_it_to and how we set cursor
+                 when the display line ends in a newline from a
+                 display string.  move_it_to will stop _after_ such
+                 display strings, whereas set_cursor_from_row
+                 conspires with cursor_row_p to place the cursor on
+                 the first glyph produced from the display string.  */
+
+              /* We have overshoot PT because it is covered by a
+                 display property whose value is a string.  If the
+                 string includes embedded newlines, we are also in the
+                 wrong display line.  Backtrack to the correct line,
+                 where the display string begins.  */
+              if (newline_in_string)
+                {
+                  Lisp_Object startpos, endpos;
+                  EMACS_INT start, end;
+                  struct it it3;
+
+                  /* Find the first and the last buffer positions
+                     covered by the display string.  */
+                  endpos =
+                    Fnext_single_char_property_change (cpos, Qdisplay,
+                                                       Qnil, Qnil);
+                  startpos =
+                    Fprevious_single_char_property_change (endpos, Qdisplay,
+                                                           Qnil, Qnil);
+                  start = XFASTINT (startpos);
+                  end = XFASTINT (endpos);
+                  /* Move to the last buffer position before the
+                     display property.  */
+                  start_display (&it3, w, top);
+                  move_it_to (&it3, start - 1, -1, -1, -1, MOVE_TO_POS);
+                  /* Move forward one more line if the position before
+                     the display string is a newline or if it is the
+                     rightmost character on a line that is
+                     continued or word-wrapped.  */
+                  if (it3.method == GET_FROM_BUFFER
+                      && it3.c == '\n')
+                    move_it_by_lines (&it3, 1);
+                  else if (move_it_in_display_line_to (&it3, -1,
+                                                       it3.current_x
+                                                       + it3.pixel_width,
+                                                       MOVE_TO_X)
+                           == MOVE_LINE_CONTINUED)
+                    {
+                      move_it_by_lines (&it3, 1);
+                      /* When we are under word-wrap, the #$@%!
+                         move_it_by_lines moves 2 lines, so we need to
+                         fix that up.  */
+                      if (it3.line_wrap == WORD_WRAP)
+                        move_it_by_lines (&it3, -1);
+                    }
+
+                  /* Record the vertical coordinate of the display
+                     line where we wound up.  */
+                  top_y = it3.current_y;
+                  if (it3.bidi_p)
+                    {
+                      /* When characters are reordered for display,
+                         the character displayed to the left of the
+                         display string could be _after_ the display
+                         property in the logical order.  Use the
+                         smallest vertical position of these two.  */
+                      start_display (&it3, w, top);
+                      move_it_to (&it3, end + 1, -1, -1, -1, MOVE_TO_POS);
+                      if (it3.current_y < top_y)
+                        top_y = it3.current_y;
+                    }
+                  /* Move from the top of the window to the beginning
+                     of the display line where the display string
+                     begins.  */
+                  start_display (&it3, w, top);
+                  move_it_to (&it3, -1, 0, top_y, -1, MOVE_TO_X | MOVE_TO_Y);
+                  /* Finally, advance the iterator until we hit the
+                     first display element whose character position is
+                     CHARPOS, or until the first newline from the
+                     display string, which signals the end of the
+                     display line.  */
+                  while (get_next_display_element (&it3))
+                    {
+                      PRODUCE_GLYPHS (&it3);
+                      if (IT_CHARPOS (it3) == charpos
+                          || ITERATOR_AT_END_OF_LINE_P (&it3))
+                        break;
+                      set_iterator_to_next (&it3, 0);
+                    }
+                  top_x = it3.current_x - it3.pixel_width;
+                  /* Normally, we would exit the above loop because we
+                     found the display element whose character
+                     position is CHARPOS.  For the contingency that we
+                     didn't, and stopped at the first newline from the
+                     display string, move back over the glyphs
+                     prfoduced from the string, until we find the
+                     rightmost glyph not from the string.  */
+                  if (IT_CHARPOS (it3) != charpos && EQ (it3.object, string))
+                    {
+                      struct glyph *g = it3.glyph_row->glyphs[TEXT_AREA]
+                                        + it3.glyph_row->used[TEXT_AREA];
+
+                      while (EQ ((g - 1)->object, string))
+                        {
+                          --g;
+                          top_x -= g->pixel_width;
+                        }
+                      xassert (g < it3.glyph_row->glyphs[TEXT_AREA]
+                                    + it3.glyph_row->used[TEXT_AREA]);
+                    }
+                }
+            }
 
           *x = top_x;
           *y = max (top_y + max (0, it.max_ascent - it.ascent), window_top_y);
@@ -5459,7 +5617,8 @@ pop_it (struct it *it)
                 && IT_BYTEPOS (*it) == it->bidi_it.bytepos)
                || (STRINGP (it->object)
                    && IT_STRING_CHARPOS (*it) == it->bidi_it.charpos
-                   && IT_STRING_BYTEPOS (*it) == it->bidi_it.bytepos));
+                   && IT_STRING_BYTEPOS (*it) == it->bidi_it.bytepos)
+               || (CONSP (it->object) && it->method == GET_FROM_STRETCH));
     }
 }
 
@@ -8520,7 +8679,16 @@ move_it_vertically_backward (struct it *it, int dy)
       move_it_to (&it2, start_pos, -1, -1, it2.vpos + 1,
                   MOVE_TO_POS | MOVE_TO_VPOS);
     }
-  while (!IT_POS_VALID_AFTER_MOVE_P (&it2));
+  while (!(IT_POS_VALID_AFTER_MOVE_P (&it2)
+           /* If we are in a display string which starts at START_POS,
+              and that display string includes a newline, and we are
+              right after that newline (i.e. at the beginning of a
+              display line), exit the loop, because otherwise we will
+              infloop, since move_it_to will see that it is already at
+              START_POS and will not move.  */
+           || (it2.method == GET_FROM_STRING
+               && IT_CHARPOS (it2) == start_pos
+               && SREF (it2.string, IT_STRING_BYTEPOS (it2) - 1) == '\n')));
   xassert (IT_CHARPOS (*it) >= BEGV);
   SAVE_IT (it3, it2, it3data);
 
@@ -13666,6 +13834,17 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
 
           x = -1;
 
+          /* If the row ends in a newline from a display string,
+             reordering could have moved the glyphs belonging to the
+             string out of the [GLYPH_BEFORE..GLYPH_AFTER] range.  So
+             in this case we extend the search to the last glyph in
+             the row that was not inserted by redisplay.  */
+          if (row->ends_in_newline_from_string_p)
+            {
+              glyph_after = end;
+              pos_after = MATRIX_ROW_END_CHARPOS (row) + delta;
+            }
+
           /* GLYPH_BEFORE and GLYPH_AFTER are the glyphs that
              correspond to POS_BEFORE and POS_AFTER, respectively.  We
              need START and STOP in the order that corresponds to the
@@ -18341,7 +18520,8 @@ find_row_edges (struct it *it, struct glyph_row *row,
      Line ends in a newline from buffer       eol_pos + 1
      Line is continued from buffer            max_pos + 1
      Line is truncated on right               it->current.pos
-     Line ends in a newline from string       max_pos
+     Line ends in a newline from string       max_pos + 1(*)
+      (*) + 1 only when line ends in a forward scan
      Line is continued from string            max_pos
      Line is continued from display vector    max_pos
      Line is entirely from a string           min_pos == max_pos
@@ -18354,8 +18534,76 @@ find_row_edges (struct it *it, struct glyph_row *row,
     row->maxpos = it->current.pos;
   else if (row->used[TEXT_AREA])
     {
-      if (row->ends_in_newline_from_string_p)
-        SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
+      int seen_this_string = 0;
+      struct glyph_row *r1 = row - 1;
+
+      /* Did we see the same display string on the previous row?  */
+      if (STRINGP (it->object)
+          /* this is not the first row */
+          && row > it->w->desired_matrix->rows
+          /* previous row is not the header line */
+          && !r1->mode_line_p
+          /* previous row also ends in a newline from a string */
+          && r1->ends_in_newline_from_string_p)
+        {
+          struct glyph *start, *end;
+
+          /* Search for the last glyph of the previous row that came
+             from buffer or string.  Depending on whether the row is
+             L2R or R2L, we need to process it front to back or the
+             other way round.  */
+          if (!r1->reversed_p)
+            {
+              start = r1->glyphs[TEXT_AREA];
+              end = start + r1->used[TEXT_AREA];
+              /* Glyphs inserted by redisplay have an integer (zero)
+                 as their object.  */
+              while (end > start
+                     && INTEGERP ((end - 1)->object)
+                     && (end - 1)->charpos <= 0)
+                --end;
+              if (end > start)
+                {
+                  if (EQ ((end - 1)->object, it->object))
+                    seen_this_string = 1;
+                }
+              else
+                abort ();
+            }
+          else
+            {
+              end = r1->glyphs[TEXT_AREA] - 1;
+              start = end + r1->used[TEXT_AREA];
+              while (end < start
+                     && INTEGERP ((end + 1)->object)
+                     && (end + 1)->charpos <= 0)
+                ++end;
+              if (end < start)
+                {
+                  if (EQ ((end + 1)->object, it->object))
+                    seen_this_string = 1;
+                }
+              else
+                abort ();
+            }
+        }
+      /* Take note of each display string that covers a newline only
+         once, the first time we see it.  This is for when a display
+         string includes more than one newline in it.  */
+      if (row->ends_in_newline_from_string_p && !seen_this_string)
+        {
+          /* If we were scanning the buffer forward when we displayed
+             the string, we want to account for at least one buffer
+             position that belongs to this row (position covered by
+             the display string), so that cursor positioning will
+             consider this row as a candidate when point is at the end
+             of the visual line represented by this row.  This is not
+             required when scanning back, because max_pos will already
+             have a much larger value.  */
+          if (CHARPOS (row->end.pos) > max_pos)
+            INC_BOTH (max_pos, max_bpos);
+          SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
+        }
       else if (CHARPOS (it->eol_pos) > 0)
         SET_TEXT_POS (row->maxpos,
                       CHARPOS (it->eol_pos) + 1, BYTEPOS (it->eol_pos) + 1);
@@ -19125,6 +19373,7 @@ See also `bidi-paragraph-direction'.  */)
       EMACS_INT pos = BUF_PT (buf);
       EMACS_INT bytepos = BUF_PT_BYTE (buf);
       int c;
+      void *itb_data = bidi_shelve_cache ();
 
       set_buffer_temp (buf);
       /* bidi_paragraph_init finds the base direction of the paragraph
@@ -19137,27 +19386,27 @@ See also `bidi-paragraph-direction'.  */)
           pos--;
           bytepos = CHAR_TO_BYTE (pos);
         }
-      while ((c = FETCH_BYTE (bytepos)) == '\n'
-             || c == ' ' || c == '\t' || c == '\f')
+      if (fast_looking_at (build_string ("[\f\t ]*\n"),
+                           pos, bytepos, ZV, ZV_BYTE, Qnil) > 0)
         {
-          if (bytepos <= BEGV_BYTE)
-            break;
-          bytepos--;
-          pos--;
+          while ((c = FETCH_BYTE (bytepos)) == '\n'
+                 || c == ' ' || c == '\t' || c == '\f')
+            {
+              if (bytepos <= BEGV_BYTE)
+                break;
+              bytepos--;
+              pos--;
+            }
+          while (!CHAR_HEAD_P (FETCH_BYTE (bytepos)))
+            bytepos--;
         }
-      while (!CHAR_HEAD_P (FETCH_BYTE (bytepos)))
-        bytepos--;
-      itb.charpos = pos;
-      itb.bytepos = bytepos;
-      itb.nchars = -1;
+      bidi_init_it (pos, bytepos, FRAME_WINDOW_P (SELECTED_FRAME ()), &itb);
       itb.string.s = NULL;
       itb.string.lstring = Qnil;
-      itb.frame_window_p = FRAME_WINDOW_P (SELECTED_FRAME ()); /* guesswork */
-      itb.first_elt = 1;
-      itb.separator_limit = -1;
-      itb.paragraph_dir = NEUTRAL_DIR;
-
+      itb.string.bufpos = 0;
+      itb.string.unibyte = 0;
       bidi_paragraph_init (NEUTRAL_DIR, &itb, 1);
+      bidi_unshelve_cache (itb_data, 0);
       set_buffer_temp (old);
       switch (itb.paragraph_dir)
         {