Merge from trunk.

9 files changed, 175 insertions, 91 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 00845a4c188..c2cf656b101 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,6 +1,6 @@
-2011-10-11  Paul Eggert  <eggert@cs.ucla.edu>
+2011-10-12  Paul Eggert  <eggert@cs.ucla.edu>
 
-        Fix integer width and related issues.
+        Fix integer width and related bugs.
         * alloc.c (pure_bytes_used_lisp, pure_bytes_used_non_lisp):
         (allocate_vectorlike, buffer_memory_full, struct sdata, SDATA_SIZE)
         (string_bytes, check_sblock, allocate_string_data):
@@ -784,6 +784,53 @@
         rather than rolling our own approximation.
         (SCROLL_BAR_VEC_SIZE): Remove; not used.
 
+2011-10-12  Eli Zaretskii  <eliz@gnu.org>
+
+        * bidi.c (bidi_level_of_next_char):
+        * xdisp.c (get_visually_first_element): Remove old incorrect
+        comments regarding the Unicode Line Separator character.
+
+        * bidi.c (bidi_init_it): Initialize paragraph_dir to NEUTRAL_DIR.
+
+2011-10-12  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * alloc.c (Fgc_status): Do not access beyond zombies array
+        boundary if nzombies > MAX_ZOMBIES.
+        * alloc.c (dump_zombies): Add missing format specifier.
+
+2011-10-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xdisp.c (set_cursor_from_row): Simplify conditionals,
+        to pacify GCC 4.6.1 x86-64 with -O2 -Wstrict-overflow.
+
+        * lread.c (read_escape): Allow hex escapes as large as ?\xfffffff.
+        Some packages use them to denote characters with modifiers.
+
+2011-10-11  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * lisp.h (GCPRO1_VAR, GCPRO2_VAR, GCPRO3_VAR, GCPRO4_VAR)
+        (GCPRO5_VAR, GCPRO6_VAR, UNGCPRO_VAR): Add whitespace to avoid
+        matching a pp-number.  Rename parameter var to var1.
+
+2011-10-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * minibuf.c (Finternal_complete_buffer): Fix last change (bug#9709).
+
+2011-10-08  Glenn Morris  <rgm@gnu.org>
+
+        * callint.c (Fcall_interactively): Give a more explicit error for the
+        'c' case with a non-character input.  (Bug#8479)
+
+2011-10-08  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (hscroll_window_tree): Support hscroll in right-to-left
+        lines.
+        (set_cursor_from_row): Fix cursor positioning in mixed L2R+R2L
+        lines that are hscrolled on the left.
+
+        * dispnew.c (buffer_posn_from_coords): Account for a possible
+        presence of header-line.  (Bug#4426)
+
 2011-10-07  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * buffer.c (syms_of_buffer) <enable-multibyte-characters>: Don't
diff --git a/src/alloc.c b/src/alloc.c
index ea2fea77e29..ee49a2dfb2e 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -4072,7 +4072,7 @@ DEFUN ("gc-status", Fgc_status, Sgc_status, 0, 0, "",
 {
   Lisp_Object args[8], zombie_list = Qnil;
   EMACS_INT i;
-  for (i = 0; i < nzombies; i++)
+  for (i = 0; i < min (MAX_ZOMBIES, nzombies); i++)
     zombie_list = Fcons (zombies[i], zombie_list);
   args[0] = build_string ("%d GCs, avg live/zombies = %.2f/%.2f (%f%%), max %d/%d\nzombies: %S");
   args[1] = make_number (ngcs);
@@ -4411,7 +4411,7 @@ dump_zombies (void)
 {
   int i;
 
-  fprintf (stderr, "\nZombies kept alive = %"pI":\n", nzombies);
+  fprintf (stderr, "\nZombies kept alive = %"pI"d:\n", nzombies);
   for (i = 0; i < min (MAX_ZOMBIES, nzombies); ++i)
     {
       fprintf (stderr, "  %d = ", i);
diff --git a/src/bidi.c b/src/bidi.c
index a43490f4110..e4965ed59ac 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -808,6 +808,7 @@ bidi_init_it (ptrdiff_t charpos, ptrdiff_t bytepos, int frame_window_p,
   bidi_it->nchars = -1; /* to be computed in bidi_resolve_explicit_1 */
   bidi_it->first_elt = 1;
   bidi_set_paragraph_end (bidi_it);
+  bidi_it->paragraph_dir = NEUTRAL_DIR;
   bidi_it->new_paragraph = 1;
   bidi_it->separator_limit = -1;
   bidi_it->type = NEUTRAL_B;
@@ -2127,7 +2128,7 @@ bidi_level_of_next_char (struct bidi_it *bidi_it)
       do {
         ch = bidi_fetch_char (bpos += clen, cpos += nc, &disp_pos, &dpp, &bs,
                               fwp, &clen, &nc);
-        if (ch == '\n' || ch == BIDI_EOB /* || ch == LINESEP_CHAR */)
+        if (ch == '\n' || ch == BIDI_EOB)
           chtype = NEUTRAL_B;
         else
           chtype = bidi_get_type (ch, NEUTRAL_DIR);
@@ -2177,7 +2178,6 @@ bidi_level_of_next_char (struct bidi_it *bidi_it)
   else if (bidi_it->orig_type == NEUTRAL_B /* L1 */
            || bidi_it->orig_type == NEUTRAL_S
            || bidi_it->ch == '\n' || bidi_it->ch == BIDI_EOB
-           /* || bidi_it->ch == LINESEP_CHAR */
            || (bidi_it->orig_type == NEUTRAL_WS
                && (bidi_it->next_for_ws.type == NEUTRAL_B
                    || bidi_it->next_for_ws.type == NEUTRAL_S)))
diff --git a/src/callint.c b/src/callint.c
index c2a43f0f8f9..5eb824b8c74 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -535,6 +535,8 @@ invoke it.  If KEYS is omitted or nil, the return value of
           message1_nolog ((char *) 0);
           /* Passing args[i] directly stimulates compiler bug */
           teml = args[i];
+          /* See bug#8479.  */
+          if (! CHARACTERP (teml)) error ("Non-character input-event");
           visargs[i] = Fchar_to_string (teml);
           break;
 
diff --git a/src/dispnew.c b/src/dispnew.c
index 32795a5fed9..93a990cff47 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -5260,6 +5260,10 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
   CHARPOS (startp) = min (ZV, max (BEGV, CHARPOS (startp)));
   BYTEPOS (startp) = min (ZV_BYTE, max (BEGV_BYTE, BYTEPOS (startp)));
   start_display (&it, w, startp);
+  /* start_display takes into account the header-line row, but IT's
+     vpos still counts from the glyph row that includes the window's
+     start position.  Adjust for a possible header-line row.  */
+  it.vpos += WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0;
 
   x0 = *x;
 
diff --git a/src/lisp.h b/src/lisp.h
index 2c54c9b41ed..17f1705675e 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2275,105 +2275,105 @@ struct gcpro
 
 #ifndef DEBUG_GCPRO
 
-#define GCPRO1_VAR(var, gcpro) \
- {gcpro##1.next = gcprolist; gcpro##1.var = &var; gcpro##1.nvars = 1; \
+#define GCPRO1_VAR(var1, gcpro) \
+ {gcpro##1 .next = gcprolist; gcpro##1 .var = &var1; gcpro##1 .nvars = 1; \
   gcprolist = &gcpro##1; }
 
 #define GCPRO2_VAR(var1, var2, gcpro) \
- {gcpro##1.next = gcprolist; gcpro##1.var = &var1; gcpro##1.nvars = 1; \
-  gcpro##2.next = &gcpro##1; gcpro##2.var = &var2; gcpro##2.nvars = 1; \
+ {gcpro##1 .next = gcprolist; gcpro##1 .var = &var1; gcpro##1 .nvars = 1; \
+  gcpro##2 .next = &gcpro##1; gcpro##2 .var = &var2; gcpro##2 .nvars = 1; \
   gcprolist = &gcpro##2; }
 
 #define GCPRO3_VAR(var1, var2, var3, gcpro) \
- {gcpro##1.next = gcprolist; gcpro##1.var = &var1; gcpro##1.nvars = 1; \
-  gcpro##2.next = &gcpro##1; gcpro##2.var = &var2; gcpro##2.nvars = 1; \
-  gcpro##3.next = &gcpro##2; gcpro##3.var = &var3; gcpro##3.nvars = 1; \
+ {gcpro##1 .next = gcprolist; gcpro##1 .var = &var1; gcpro##1 .nvars = 1; \
+  gcpro##2 .next = &gcpro##1; gcpro##2 .var = &var2; gcpro##2 .nvars = 1; \
+  gcpro##3 .next = &gcpro##2; gcpro##3 .var = &var3; gcpro##3 .nvars = 1; \
   gcprolist = &gcpro##3; }
 
 #define GCPRO4_VAR(var1, var2, var3, var4, gcpro) \
- {gcpro##1.next = gcprolist; gcpro##1.var = &var1; gcpro##1.nvars = 1; \
-  gcpro##2.next = &gcpro##1; gcpro##2.var = &var2; gcpro##2.nvars = 1; \
-  gcpro##3.next = &gcpro##2; gcpro##3.var = &var3; gcpro##3.nvars = 1; \
-  gcpro##4.next = &gcpro##3; gcpro##4.var = &var4; gcpro##4.nvars = 1; \
+ {gcpro##1 .next = gcprolist; gcpro##1 .var = &var1; gcpro##1 .nvars = 1; \
+  gcpro##2 .next = &gcpro##1; gcpro##2 .var = &var2; gcpro##2 .nvars = 1; \
+  gcpro##3 .next = &gcpro##2; gcpro##3 .var = &var3; gcpro##3 .nvars = 1; \
+  gcpro##4 .next = &gcpro##3; gcpro##4 .var = &var4; gcpro##4 .nvars = 1; \
   gcprolist = &gcpro##4; }
 
 #define GCPRO5_VAR(var1, var2, var3, var4, var5, gcpro) \
- {gcpro##1.next = gcprolist; gcpro##1.var = &var1; gcpro##1.nvars = 1; \
-  gcpro##2.next = &gcpro##1; gcpro##2.var = &var2; gcpro##2.nvars = 1; \
-  gcpro##3.next = &gcpro##2; gcpro##3.var = &var3; gcpro##3.nvars = 1; \
-  gcpro##4.next = &gcpro##3; gcpro##4.var = &var4; gcpro##4.nvars = 1; \
-  gcpro##5.next = &gcpro##4; gcpro##5.var = &var5; gcpro##5.nvars = 1; \
+ {gcpro##1 .next = gcprolist; gcpro##1 .var = &var1; gcpro##1 .nvars = 1; \
+  gcpro##2 .next = &gcpro##1; gcpro##2 .var = &var2; gcpro##2 .nvars = 1; \
+  gcpro##3 .next = &gcpro##2; gcpro##3 .var = &var3; gcpro##3 .nvars = 1; \
+  gcpro##4 .next = &gcpro##3; gcpro##4 .var = &var4; gcpro##4 .nvars = 1; \
+  gcpro##5 .next = &gcpro##4; gcpro##5 .var = &var5; gcpro##5 .nvars = 1; \
   gcprolist = &gcpro##5; }
 
 #define GCPRO6_VAR(var1, var2, var3, var4, var5, var6, gcpro) \
- {gcpro##1.next = gcprolist; gcpro##1.var = &var1; gcpro##1.nvars = 1; \
-  gcpro##2.next = &gcpro##1; gcpro##2.var = &var2; gcpro##2.nvars = 1; \
-  gcpro##3.next = &gcpro##2; gcpro##3.var = &var3; gcpro##3.nvars = 1; \
-  gcpro##4.next = &gcpro##3; gcpro##4.var = &var4; gcpro##4.nvars = 1; \
-  gcpro##5.next = &gcpro##4; gcpro##5.var = &var5; gcpro##5.nvars = 1; \
-  gcpro##6.next = &gcpro##5; gcpro##6.var = &var6; gcpro##6.nvars = 1; \
+ {gcpro##1 .next = gcprolist; gcpro##1 .var = &var1; gcpro##1 .nvars = 1; \
+  gcpro##2 .next = &gcpro##1; gcpro##2 .var = &var2; gcpro##2 .nvars = 1; \
+  gcpro##3 .next = &gcpro##2; gcpro##3 .var = &var3; gcpro##3 .nvars = 1; \
+  gcpro##4 .next = &gcpro##3; gcpro##4 .var = &var4; gcpro##4 .nvars = 1; \
+  gcpro##5 .next = &gcpro##4; gcpro##5 .var = &var5; gcpro##5 .nvars = 1; \
+  gcpro##6 .next = &gcpro##5; gcpro##6 .var = &var6; gcpro##6 .nvars = 1; \
   gcprolist = &gcpro##6; }
 
-#define UNGCPRO_VAR(gcpro) (gcprolist = gcpro##1.next)
+#define UNGCPRO_VAR(gcpro) (gcprolist = gcpro##1 .next)
 
 #else
 
 extern int gcpro_level;
 
-#define GCPRO1_VAR(var, gcpro) \
- {gcpro##1.next = gcprolist; gcpro##1.var = &var; gcpro##1.nvars = 1; \
-  gcpro##1.level = gcpro_level++; \
+#define GCPRO1_VAR(var1, gcpro) \
+ {gcpro##1 .next = gcprolist; gcpro##1 .var = &var1; gcpro##1 .nvars = 1; \
+  gcpro##1 .level = gcpro_level++; \
   gcprolist = &gcpro##1; }
 
 #define GCPRO2_VAR(var1, var2, gcpro) \
- {gcpro##1.next = gcprolist; gcpro##1.var = &var1; gcpro##1.nvars = 1; \
-  gcpro##1.level = gcpro_level; \
-  gcpro##2.next = &gcpro##1; gcpro##2.var = &var2; gcpro##2.nvars = 1; \
-  gcpro##2.level = gcpro_level++; \
+ {gcpro##1 .next = gcprolist; gcpro##1 .var = &var1; gcpro##1 .nvars = 1; \
+  gcpro##1 .level = gcpro_level; \
+  gcpro##2 .next = &gcpro##1; gcpro##2 .var = &var2; gcpro##2 .nvars = 1; \
+  gcpro##2 .level = gcpro_level++; \
   gcprolist = &gcpro##2; }
 
 #define GCPRO3_VAR(var1, var2, var3, gcpro) \
- {gcpro##1.next = gcprolist; gcpro##1.var = &var1; gcpro##1.nvars = 1; \
-  gcpro##1.level = gcpro_level; \
-  gcpro##2.next = &gcpro##1; gcpro##2.var = &var2; gcpro##2.nvars = 1; \
-  gcpro##3.next = &gcpro##2; gcpro##3.var = &var3; gcpro##3.nvars = 1; \
-  gcpro##3.level = gcpro_level++; \
+ {gcpro##1 .next = gcprolist; gcpro##1 .var = &var1; gcpro##1 .nvars = 1; \
+  gcpro##1 .level = gcpro_level; \
+  gcpro##2 .next = &gcpro##1; gcpro##2 .var = &var2; gcpro##2 .nvars = 1; \
+  gcpro##3 .next = &gcpro##2; gcpro##3 .var = &var3; gcpro##3 .nvars = 1; \
+  gcpro##3 .level = gcpro_level++; \
   gcprolist = &gcpro##3; }
 
 #define GCPRO4_VAR(var1, var2, var3, var4, gcpro) \
- {gcpro##1.next = gcprolist; gcpro##1.var = &var1; gcpro##1.nvars = 1; \
-  gcpro##1.level = gcpro_level; \
-  gcpro##2.next = &gcpro##1; gcpro##2.var = &var2; gcpro##2.nvars = 1; \
-  gcpro##3.next = &gcpro##2; gcpro##3.var = &var3; gcpro##3.nvars = 1; \
-  gcpro##4.next = &gcpro##3; gcpro##4.var = &var4; gcpro##4.nvars = 1; \
-  gcpro##4.level = gcpro_level++; \
+ {gcpro##1 .next = gcprolist; gcpro##1 .var = &var1; gcpro##1 .nvars = 1; \
+  gcpro##1 .level = gcpro_level; \
+  gcpro##2 .next = &gcpro##1; gcpro##2 .var = &var2; gcpro##2 .nvars = 1; \
+  gcpro##3 .next = &gcpro##2; gcpro##3 .var = &var3; gcpro##3 .nvars = 1; \
+  gcpro##4 .next = &gcpro##3; gcpro##4 .var = &var4; gcpro##4 .nvars = 1; \
+  gcpro##4 .level = gcpro_level++; \
   gcprolist = &gcpro##4; }
 
 #define GCPRO5_VAR(var1, var2, var3, var4, var5, gcpro) \
- {gcpro##1.next = gcprolist; gcpro##1.var = &var1; gcpro##1.nvars = 1; \
-  gcpro##1.level = gcpro_level; \
-  gcpro##2.next = &gcpro##1; gcpro##2.var = &var2; gcpro##2.nvars = 1; \
-  gcpro##3.next = &gcpro##2; gcpro##3.var = &var3; gcpro##3.nvars = 1; \
-  gcpro##4.next = &gcpro##3; gcpro##4.var = &var4; gcpro##4.nvars = 1; \
-  gcpro##5.next = &gcpro##4; gcpro##5.var = &var5; gcpro##5.nvars = 1; \
-  gcpro##5.level = gcpro_level++; \
+ {gcpro##1 .next = gcprolist; gcpro##1 .var = &var1; gcpro##1 .nvars = 1; \
+  gcpro##1 .level = gcpro_level; \
+  gcpro##2 .next = &gcpro##1; gcpro##2 .var = &var2; gcpro##2 .nvars = 1; \
+  gcpro##3 .next = &gcpro##2; gcpro##3 .var = &var3; gcpro##3 .nvars = 1; \
+  gcpro##4 .next = &gcpro##3; gcpro##4 .var = &var4; gcpro##4 .nvars = 1; \
+  gcpro##5 .next = &gcpro##4; gcpro##5 .var = &var5; gcpro##5 .nvars = 1; \
+  gcpro##5 .level = gcpro_level++; \
   gcprolist = &gcpro##5; }
 
 #define GCPRO6_VAR(var1, var2, var3, var4, var5, var6, gcpro) \
- {gcpro##1.next = gcprolist; gcpro##1.var = &var1; gcpro##1.nvars = 1; \
-  gcpro##1.level = gcpro_level; \
-  gcpro##2.next = &gcpro##1; gcpro##2.var = &var2; gcpro##2.nvars = 1; \
-  gcpro##3.next = &gcpro##2; gcpro##3.var = &var3; gcpro##3.nvars = 1; \
-  gcpro##4.next = &gcpro##3; gcpro##4.var = &var4; gcpro##4.nvars = 1; \
-  gcpro##5.next = &gcpro##4; gcpro##5.var = &var5; gcpro##5.nvars = 1; \
-  gcpro##6.next = &gcpro##5; gcpro##6.var = &var6; gcpro##6.nvars = 1; \
-  gcpro##6.level = gcpro_level++; \
+ {gcpro##1 .next = gcprolist; gcpro##1 .var = &var1; gcpro##1 .nvars = 1; \
+  gcpro##1 .level = gcpro_level; \
+  gcpro##2 .next = &gcpro##1; gcpro##2 .var = &var2; gcpro##2 .nvars = 1; \
+  gcpro##3 .next = &gcpro##2; gcpro##3 .var = &var3; gcpro##3 .nvars = 1; \
+  gcpro##4 .next = &gcpro##3; gcpro##4 .var = &var4; gcpro##4 .nvars = 1; \
+  gcpro##5 .next = &gcpro##4; gcpro##5 .var = &var5; gcpro##5 .nvars = 1; \
+  gcpro##6 .next = &gcpro##5; gcpro##6 .var = &var6; gcpro##6 .nvars = 1; \
+  gcpro##6 .level = gcpro_level++; \
   gcprolist = &gcpro##6; }
 
 #define UNGCPRO_VAR(gcpro) \
- ((--gcpro_level != gcpro##1.level) \
+ ((--gcpro_level != gcpro##1 .level) \
   ? (abort (), 0) \
-  : ((gcprolist = gcpro##1.next), 0))
+  : ((gcprolist = gcpro##1 .next), 0))
 
 #endif /* DEBUG_GCPRO */
 #endif /* GC_MARK_STACK != GC_MAKE_GCPROS_NOOPS */
diff --git a/src/lread.c b/src/lread.c
index 91195a88e63..75d05a2b2f3 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -2215,7 +2215,7 @@ read_escape (Lisp_Object readcharfun, int stringp)
     case 'x':
       /* A hex escape, as in ANSI C.  */
       {
-        int i = 0;
+        unsigned int i = 0;
         int count = 0;
         while (1)
           {
@@ -2239,7 +2239,9 @@ read_escape (Lisp_Object readcharfun, int stringp)
                 UNREAD (c);
                 break;
               }
-            if (MAX_CHAR < i)
+            /* Allow hex escapes as large as ?\xfffffff, because some
+               packages use them to denote characters with modifiers.  */
+            if ((CHAR_META | (CHAR_META - 1)) < i)
               error ("Hex character out of range: \\x%x...", i);
             count += count < 3;
           }
diff --git a/src/minibuf.c b/src/minibuf.c
index 9b905f748bb..0d2bc7234eb 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -1859,9 +1859,10 @@ The arguments STRING and PREDICATE are as in `try-completion',
           /* First, look for a non-internal buffer in `res'.  */
           while (CONSP (bufs) && SREF (XCAR (bufs), 0) == ' ')
             bufs = XCDR (bufs);
-          if (NILP (bufs) && EQ (Flength (res), Flength (Vbuffer_alist)))
-            /* All bufs are internal, so don't trip them out.  */
-            return res;
+          if (NILP (bufs))
+            return (EQ (Flength (res), Flength (Vbuffer_alist))
+                    /* If all bufs are internal don't strip them out.  */
+                    ? res : bufs);
           res = bufs;
           while (CONSP (XCDR (bufs)))
             if (SREF (XCAR (XCDR (bufs)), 0) == ' ')
diff --git a/src/xdisp.c b/src/xdisp.c
index ce240922010..0be1c68780d 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -7154,7 +7154,6 @@ get_visually_first_element (struct it *it)
     }
   else if (it->bidi_it.charpos == bob
            || (!string_p
-               /* FIXME: Should support all Unicode line separators.  */
                && (FETCH_CHAR (it->bidi_it.bytepos - 1) == '\n'
                    || FETCH_CHAR (it->bidi_it.bytepos) == '\n')))
     {
@@ -12072,6 +12071,7 @@ hscroll_window_tree (Lisp_Object window)
             = (desired_cursor_row->enabled_p
                ? desired_cursor_row
                : current_cursor_row);
+          int row_r2l_p = cursor_row->reversed_p;
 
           text_area_width = window_box_width (w, TEXT_AREA);
 
@@ -12079,11 +12079,31 @@ hscroll_window_tree (Lisp_Object window)
           h_margin = hscroll_margin * WINDOW_FRAME_COLUMN_WIDTH (w);
 
           if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode, w->buffer))
-              && ((XFASTINT (w->hscroll)
-                   && w->cursor.x <= h_margin)
-                  || (cursor_row->enabled_p
-                      && cursor_row->truncated_on_right_p
-                      && (w->cursor.x >= text_area_width - h_margin))))
+              /* For left-to-right rows, hscroll when cursor is either
+                 (i) inside the right hscroll margin, or (ii) if it is
+                 inside the left margin and the window is already
+                 hscrolled. */
+              && ((!row_r2l_p
+                   && ((XFASTINT (w->hscroll)
+                        && w->cursor.x <= h_margin)
+                       || (cursor_row->enabled_p
+                           && cursor_row->truncated_on_right_p
+                           && (w->cursor.x >= text_area_width - h_margin))))
+                  /* For right-to-left rows, the logic is similar,
+                     except that rules for scrolling to left and right
+                     are reversed.  E.g., if cursor.x <= h_margin, we
+                     need to hscroll "to the right" unconditionally,
+                     and that will scroll the screen to the left so as
+                     to reveal the next portion of the row.  */
+                  || (row_r2l_p
+                      && ((cursor_row->enabled_p
+                           /* FIXME: It is confusing to set the
+                              truncated_on_right_p flag when R2L rows
+                              are actually truncated on the left. */
+                           && cursor_row->truncated_on_right_p
+                           && w->cursor.x <= h_margin)
+                          || (XFASTINT (w->hscroll)
+                              && (w->cursor.x >= text_area_width - h_margin))))))
             {
               struct it it;
               ptrdiff_t hscroll;
@@ -12118,7 +12138,9 @@ hscroll_window_tree (Lisp_Object window)
                                       ? (text_area_width - 4 * FRAME_COLUMN_WIDTH (it.f))
                                       : (text_area_width / 2))))
                           / FRAME_COLUMN_WIDTH (it.f);
-              else if (w->cursor.x >= text_area_width - h_margin)
+              else if ((!row_r2l_p
+                        && w->cursor.x >= text_area_width - h_margin)
+                       || (row_r2l_p && w->cursor.x <= h_margin))
                 {
                   if (hscroll_relative_p)
                     wanted_x = text_area_width * (1 - hscroll_step_rel)
@@ -13858,21 +13880,7 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
               glyph--;
             }
         }
-      else if (match_with_avoid_cursor
-               /* A truncated row may not include PT among its
-                  character positions.  Setting the cursor inside the
-                  scroll margin will trigger recalculation of hscroll
-                  in hscroll_window_tree.  But if a display string
-                  covers point, defer to the string-handling code
-                  below to figure this out.  */
-               || (!string_seen
-                   && ((row->truncated_on_left_p && pt_old < bpos_min)
-                       || (row->truncated_on_right_p && pt_old > bpos_max)
-                       /* Zero-width characters produce no glyphs.  */
-                       || (!empty_line_p
-                           && (row->reversed_p
-                               ? glyph_after > glyphs_end
-                               : glyph_after < glyphs_end)))))
+      else if (match_with_avoid_cursor)
         {
           cursor = glyph_after;
           x = -1;
@@ -14013,6 +14021,26 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
               && row->continued_p)
             return 0;
         }
+      /* A truncated row may not include PT among its character positions.
+         Setting the cursor inside the scroll margin will trigger
+         recalculation of hscroll in hscroll_window_tree.  But if a
+         display string covers point, defer to the string-handling
+         code below to figure this out.  */
+      else if (row->truncated_on_left_p && pt_old < bpos_min)
+        {
+          cursor = glyph_before;
+          x = -1;
+        }
+      else if ((row->truncated_on_right_p && pt_old > bpos_max)
+               /* Zero-width characters produce no glyphs.  */
+               || (!empty_line_p
+                   && (row->reversed_p
+                       ? glyph_after > glyphs_end
+                       : glyph_after < glyphs_end)))
+        {
+          cursor = glyph_after;
+          x = -1;
+        }
     }
 
  compute_x: