upstream

4 files changed, 144 insertions, 24 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 12a45918e87..44a76068313 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,27 @@
+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/dispextern.h b/src/dispextern.h
index 8a1d8e7948e..bdc5008c94c 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -2426,9 +2426,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/emacs.c b/src/emacs.c
index d0e7a748849..bf23643f3f6 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -1999,6 +1999,7 @@ all of which are called before Emacs is actually killed.  */)
 {
   struct gcpro gcpro1;
   Lisp_Object hook;
+  int exit_code;
 
   GCPRO1 (arg);
 
@@ -2023,7 +2024,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))
+    exit_code = EXIT_FAILURE;
+  exit (INTEGERP (arg) ? XINT (arg) : exit_code);
 }
 
 
diff --git a/src/xdisp.c b/src/xdisp.c
index e83ad96b6c8..44255c96468 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -5494,7 +5494,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));
     }
 }
 
@@ -13727,6 +13728,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
@@ -18446,7 +18458,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
@@ -18459,8 +18472,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);
@@ -19230,6 +19311,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
@@ -19242,27 +19324,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)
         {