Merge from emacs-24; up to 2014-07-02T00:57:53Z!juri@jurta.org

5 files changed, 96 insertions, 21 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index e79cef6a8a4..d08b3780242 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,20 @@
+2014-08-28  Eli Zaretskii  <eliz@gnu.org>
+
+        * conf_post.h (_GL_EXECINFO_INLINE) [MSDOS]: Don't define.
+
+        * indent.c (Fvertical_motion): Fix vertical motion up through a
+        display property after a newline.  (Bug#18276)
+
+        * xdisp.c (display_line): Don't assume that the call to
+        reseat_at_next_visible_line_start ends up at a character
+        immediately following the newline on the previous line.  Avoids
+        setting the ends_at_zv_p flag on screen lines that are not at or
+        beyond ZV, which causes infloop in redisplay.  For the details, see
+        http://lists.gnu.org/archive/html/emacs-devel/2014-08/msg00368.html.
+
+        * dispnew.c (buffer_posn_from_coords): Fix mirroring of X
+        coordinate for hscrolled R2L screen lines.  (Bug#18277)
+
 2014-08-28  Paul Eggert  <eggert@cs.ucla.edu>
 
         * sysdep.c (LC_COLLATE, LC_COLLATE_MASK): Give individual defaults
diff --git a/src/conf_post.h b/src/conf_post.h
index a995acfd915..c8e3672b228 100644
--- a/src/conf_post.h
+++ b/src/conf_post.h
@@ -123,13 +123,6 @@ You lose; /* Emacs for DOS must be compiled with DJGPP */
    so we could reuse it in readlinkat; see msdos.c.  */
 #define opendir sys_opendir
 
-/* The "portable" definition of _GL_INLINE on config.h does not work
-   with DJGPP GCC 3.4.4: it causes unresolved externals in sysdep.c,
-   although lib/execinfo.h is included and the inline functions there
-   are visible.  */
-#if __GNUC__ < 4
-# define _GL_EXECINFO_INLINE inline
-#endif
 /* End of gnulib-related stuff.  */
 
 #define emacs_raise(sig) msdos_fatal_signal (sig)
diff --git a/src/dispnew.c b/src/dispnew.c
index b587852fc6e..43ffca7c181 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -5143,9 +5143,8 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
   move_it_to (&it, -1, 0, *y, -1, MOVE_TO_X | MOVE_TO_Y);
 
   /* TO_X is the pixel position that the iterator will compute for the
-     glyph at *X.  We add it.first_visible_x because iterator
-     positions include the hscroll.  */
-  to_x = x0 + it.first_visible_x;
+     glyph at *X.  */
+  to_x = x0;
   if (it.bidi_it.paragraph_dir == R2L)
     /* For lines in an R2L paragraph, we need to mirror TO_X wrt the
        text area.  This is because the iterator, even in R2L
@@ -5159,6 +5158,10 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
        it should be mirrored into zero pixel position.)  */
     to_x = window_box_width (w, TEXT_AREA) - to_x - 1;
 
+  /* We need to add it.first_visible_x because iterator positions
+     include the hscroll. */
+  to_x += it.first_visible_x;
+
   /* Now move horizontally in the row to the glyph under *X.  Second
      argument is ZV to prevent move_it_in_display_line from matching
      based on buffer positions.  */
diff --git a/src/indent.c b/src/indent.c
index 79af42c5f7e..e6b267a3891 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -2004,6 +2004,8 @@ whether or not it is currently displayed in some window.  */)
       int first_x;
       bool overshoot_handled = 0;
       bool disp_string_at_start_p = 0;
+      ptrdiff_t nlines = XINT (lines);
+      int vpos_init = 0;
 
       itdata = bidi_shelve_cache ();
       SET_TEXT_POS (pt, PT, PT_BYTE);
@@ -2093,18 +2095,31 @@ whether or not it is currently displayed in some window.  */)
 
           overshoot_handled = 1;
         }
-      if (XINT (lines) <= 0)
+      else if (IT_CHARPOS (it) == PT - 1
+               && FETCH_BYTE (PT - 1) == '\n'
+               && nlines < 0)
         {
-          it.vpos = 0;
+          /* The position we started from was covered by a display
+             property, so we moved to position before the string, and
+             backed up one line, because the character at PT - 1 is a
+             newline.  So we need one less line to go up.  */
+          nlines++;
+          /* But we still need to record that one line, in order to
+             return the correct value to the caller.  */
+          vpos_init = -1;
+        }
+      if (nlines <= 0)
+        {
+          it.vpos = vpos_init;
           /* Do this even if LINES is 0, so that we move back to the
              beginning of the current line as we ought.  */
-          if (XINT (lines) == 0 || IT_CHARPOS (it) > 0)
-            move_it_by_lines (&it, max (PTRDIFF_MIN, XINT (lines)));
+          if (nlines == 0 || IT_CHARPOS (it) > 0)
+            move_it_by_lines (&it, max (PTRDIFF_MIN, nlines));
         }
       else if (overshoot_handled)
         {
           it.vpos = 0;
-          move_it_by_lines (&it, min (PTRDIFF_MAX, XINT (lines)));
+          move_it_by_lines (&it, min (PTRDIFF_MAX, nlines));
         }
       else
         {
@@ -2119,13 +2134,13 @@ whether or not it is currently displayed in some window.  */)
                   it.vpos = 0;
                   move_it_by_lines (&it, 1);
                 }
-              if (XINT (lines) > 1)
-                move_it_by_lines (&it, min (PTRDIFF_MAX, XINT (lines) - 1));
+              if (nlines > 1)
+                move_it_by_lines (&it, min (PTRDIFF_MAX, nlines - 1));
             }
           else
             {
               it.vpos = 0;
-              move_it_by_lines (&it, min (PTRDIFF_MAX, XINT (lines)));
+              move_it_by_lines (&it, min (PTRDIFF_MAX, nlines));
             }
         }
 
diff --git a/src/xdisp.c b/src/xdisp.c
index 39e70717143..1f2c5a02d6c 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -3413,6 +3413,48 @@ handle_stop (struct it *it)
   if (it->selective_display_ellipsis_p)
     it->saved_face_id = it->face_id;
 
+  /* Here's the description of the semantics of, and the logic behind,
+     the various HANDLED_* statuses:
+
+     HANDLED_NORMALLY means the handler did its job, and the loop
+     should proceed to calling the next handler in order.
+
+     HANDLED_RECOMPUTE_PROPS means the handler caused a significant
+     change in the properties and overlays at current position, so the
+     loop should be restarted, to re-invoke the handlers that were
+     already called.  This happens when fontification-functions were
+     called by handle_fontified_prop, and actually fontified
+     something.  Another case where HANDLED_RECOMPUTE_PROPS is
+     returned is when we discover overlay strings that need to be
+     displayed right away.  The loop below will continue for as long
+     as the status is HANDLED_RECOMPUTE_PROPS.
+
+     HANDLED_RETURN means return immediately to the caller, to
+     continue iteration without calling any further handlers.  This is
+     used when we need to act on some property right away, for example
+     when we need to display the ellipsis or a replacing display
+     property, such as display string or image.
+
+     HANDLED_OVERLAY_STRING_CONSUMED means an overlay string was just
+     consumed, and the handler switched to the next overlay string.
+     This signals the loop below to refrain from looking for more
+     overlays before all the overlay strings of the current overlay
+     are processed.
+
+     Some of the handlers called by the loop push the iterator state
+     onto the stack (see 'push_it'), and arrange for the iteration to
+     continue with another object, such as an image, a display string,
+     or an overlay string.  In most such cases, it->stop_charpos is
+     set to the first character of the string, so that when the
+     iteration resumes, this function will immediately be called
+     again, to examine the properties at the beginning of the string.
+
+     When a display or overlay string is exhausted, the iterator state
+     is popped (see 'pop_it'), and iteration continues with the
+     previous object.  Again, in many such cases this function is
+     called again to find the next position where properties might
+     change.  */
+
   do
     {
       handled = HANDLED_NORMALLY;
@@ -20621,10 +20663,15 @@ display_line (struct it *it)
           row->truncated_on_right_p = 1;
           it->continuation_lines_width = 0;
           reseat_at_next_visible_line_start (it, 0);
-          if (IT_BYTEPOS (*it) <= BEG_BYTE)
-            row->ends_at_zv_p = true;
+          /* We insist below that IT's position be at ZV because in
+             bidi-reordered lines the character at visible line start
+             might not be the character that follows the newline in
+             the logical order.  */
+          if (IT_BYTEPOS (*it) > BEG_BYTE)
+            row->ends_at_zv_p =
+              IT_BYTEPOS (*it) >= ZV_BYTE && FETCH_BYTE (ZV_BYTE - 1) != '\n';
           else
-            row->ends_at_zv_p = FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n';
+            row->ends_at_zv_p = false;
           break;
         }
     }