Merge from trunk.

11 files changed, 307 insertions, 50 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index b72de32ffc3..10f6e326891 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,4 +1,4 @@
-2011-07-19  Paul Eggert  <eggert@cs.ucla.edu>
+2011-07-28  Paul Eggert  <eggert@cs.ucla.edu>
 
         Integer signedness and overflow and related fixes.  (Bug#9079)
 
@@ -197,6 +197,101 @@
         Use EMACS_INT, not EMACS_UINT, for sizes.  The code works equally
         well either way, and we prefer signed to unsigned.
 
+2011-07-27  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * gnutls.c (emacs_gnutls_read): Don't message anything if the peer
+        closes the connection while we're reading (bug#9182).
+
+2011-07-25  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsmenu.m (ns_popup_dialog): Add an "ok" button if no buttons
+        are specified (Bug#9168).
+
+2011-07-25  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * bidi.c (bidi_dump_cached_states): Fix printf format mismatch.
+        Found by GCC static checking and --with-wide-int on a 32-bit host.
+
+2011-07-25  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (compute_display_string_pos): Fix logic of caching
+        previous display string position.  Initialize cached_prev_pos to
+        -1.  Fixes slow-down at the beginning of a buffer.
+
+2011-07-24  Eli Zaretskii  <eliz@gnu.org>
+
+        * xfaces.c (check_lface_attrs) [HAVE_WINDOW_SYSTEM]: Allow `nil'
+        for attrs[LFACE_FONTSET_INDEX].
+
+2011-07-23  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xml.c (parse_region): Remove unused local
+        that was recently introduced.
+
+2011-07-23  Eli Zaretskii  <eliz@gnu.org>
+
+        * xfns.c (unwind_create_frame) [GLYPH_DEBUG]: Adapt to changes in
+        2008-02-22T17:42:09Z!monnier@iro.umontreal.ca.
+
+        * xdisp.c (move_it_in_display_line_to): Record the best matching
+        position for TO_CHARPOS while scanning the line, and restore it on
+        exit if none of the characters scanned was an exact match.  Fixes
+        vertical-motion and pos-visible-in-window-p under bidi redisplay
+        when exact match is impossible due to invisible text, and the
+        lines are truncated.
+
+2011-07-23  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (initFrameFromEmacs): Set NSTitledWindowMask in styleMask
+        for OSX >= 10.7.
+
+2011-07-22  Eli Zaretskii  <eliz@gnu.org>
+
+        Fix a significant slow-down of cursor motion with C-n, C-p,
+        C-f/C-b, and C-v/M-v that couldn't keep up with keyboard
+        auto-repeat under bidi redisplay in fontified buffers.
+        * xdisp.c (compute_stop_pos_backwards): New function.
+        (next_element_from_buffer): Call compute_stop_pos_backwards to
+        find a suitable prev_stop when we find ourselves before
+        base_level_stop.
+        (reseat): Don't look for prev_stop, as that could mean a very long
+        run.
+        <cached_disp_pos, cached_disp_buffer, cached_disp_modiff>
+        <cached_disp_overlay_modiff>: Cache for last found display string
+        position.
+        (compute_display_string_pos): Return the cached position if asked
+        about the same buffer in the same area of character positions, and
+        the buffer wasn't changed since the time the display string
+        position was cached.
+
+2011-07-22  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (rows_from_pos_range): Don't ignore glyphs whose object
+        is an integer, which is important for empty lines.  (Bug#9149)
+
+2011-07-22  Chong Yidong  <cyd@stupidchicken.com>
+
+        * frame.c (Fmodify_frame_parameters): In tty case, update the
+        default face if necessary (Bug#4238).
+
+2011-07-21  Chong Yidong  <cyd@stupidchicken.com>
+
+        * editfns.c (Fstring_to_char): No need to explain what a character
+        is in the docstring (Bug#6576).
+
+2011-07-20  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * xml.c (parse_region): Make sure we always return a tree.
+
+2011-07-20  HAMANO Kiyoto  <khiker.mail@gmail.com>
+
+        * xml.c (parse_region): If a document contains only comments,
+        return that, too.
+
+2011-07-20  Lars Magne Ingebrigtsen  <larsi@gnus.org>
+
+        * xml.c (make_dom): Return comments, too.
+
 2011-07-19  Paul Eggert  <eggert@cs.ucla.edu>
 
         Port to OpenBSD.
diff --git a/src/bidi.c b/src/bidi.c
index 697ebb92856..a6af9e36e15 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -2319,7 +2319,7 @@ bidi_dump_cached_states (void)
       fprintf (stderr, "The cache is empty.\n");
       return;
     }
-  fprintf (stderr, "Total of  %"pD"d state%s in cache:\n",
+  fprintf (stderr, "Total of  %"pI"d state%s in cache:\n",
            bidi_cache_idx, bidi_cache_idx == 1 ? "" : "s");
 
   for (i = bidi_cache[bidi_cache_idx - 1].charpos; i > 0; i /= 10)
diff --git a/src/editfns.c b/src/editfns.c
index 18fefa5e3b5..577263c5aea 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -194,12 +194,7 @@ DEFUN ("byte-to-string", Fbyte_to_string, Sbyte_to_string, 1, 1, 0,
 }
 
 DEFUN ("string-to-char", Fstring_to_char, Sstring_to_char, 1, 1, 0,
-       doc: /* Return the first character in STRING.
-A multibyte character is handled correctly.
-The value returned is a Unicode codepoint if it is below #x110000 (in
-hex).  Codepoints beyond that are Emacs extensions of Unicode.  In
-particular, eight-bit characters are returned as codepoints in the
-range #x3FFF80 through #x3FFFFF, inclusive.  */)
+       doc: /* Return the first character in STRING.  */)
   (register Lisp_Object string)
 {
   register Lisp_Object val;
diff --git a/src/frame.c b/src/frame.c
index 635996ca424..19ce78dfd9c 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -2437,11 +2437,9 @@ use is not recommended.  Explicitly check for a frame-parameter instead.  */)
           val = values[i];
           store_frame_param (f, prop, val);
 
-          /* Changing the background color might change the background
-             mode, so that we have to load new defface specs.
-             Call frame-set-background-mode to do that.  */
-          if (EQ (prop, Qbackground_color))
-            call1 (Qframe_set_background_mode, frame);
+          if (EQ (prop, Qforeground_color)
+              || EQ (prop, Qbackground_color))
+            update_face_from_frame_parameter (f, prop, val);
         }
     }
   return Qnil;
diff --git a/src/gnutls.c b/src/gnutls.c
index 3175f55041d..fc651d2c7e4 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -382,6 +382,9 @@ emacs_gnutls_read (struct Lisp_Process *proc, char *buf, EMACS_INT nbyte)
   rtnval = fn_gnutls_record_recv (state, buf, nbyte);
   if (rtnval >= 0)
     return rtnval;
+  else if (rtnval == GNUTLS_E_UNEXPECTED_PACKET_LENGTH)
+    /* The peer closed the connection. */
+    return 0;
   else if (emacs_gnutls_handle_error (state, rtnval) == 0)
     /* non-fatal error */
     return -1;
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 6a9ee7dd4f5..6931b7a3c01 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -1340,7 +1340,7 @@ Lisp_Object
 ns_popup_dialog (Lisp_Object position, Lisp_Object contents, Lisp_Object header)
 {
   id dialog;
-  Lisp_Object window, tem;
+  Lisp_Object window, tem, title;
   struct frame *f;
   NSPoint p;
   BOOL isQ;
@@ -1389,6 +1389,14 @@ ns_popup_dialog (Lisp_Object position, Lisp_Object contents, Lisp_Object header)
   p.x = (int)f->left_pos + ((int)FRAME_COLUMN_WIDTH (f) * f->text_cols)/2;
   p.y = (int)f->top_pos + (FRAME_LINE_HEIGHT (f) * f->text_lines)/2;
 
+  title = Fcar (contents);
+  CHECK_STRING (title);
+
+  if (NILP (Fcar (Fcdr (contents))))
+    /* No buttons specified, add an "Ok" button so users can pop down
+       the dialog.  */
+    contents = Fcons (title, Fcons (Fcons (build_string ("Ok"), Qt), Qnil));
+
   BLOCK_INPUT;
   dialog = [[EmacsDialogPanel alloc] initFromContents: contents
                                            isQuestion: isQ];
diff --git a/src/nsterm.m b/src/nsterm.m
index 546247ab74a..e45dc1a902d 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -5304,6 +5304,9 @@ ns_term_shutdown (int sig)
   win = [[EmacsWindow alloc]
             initWithContentRect: r
                       styleMask: (NSResizableWindowMask |
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
+                                  NSTitledWindowMask |
+#endif
                                   NSMiniaturizableWindowMask |
                                   NSClosableWindowMask)
                         backing: NSBackingStoreBuffered
diff --git a/src/xdisp.c b/src/xdisp.c
index 137cbec497c..8f352561719 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -3134,6 +3134,14 @@ next_overlay_change (EMACS_INT pos)
   return endpos;
 }
 
+/* Record one cached display string position found recently by
+   compute_display_string_pos.  */
+static EMACS_INT cached_disp_pos;
+static EMACS_INT cached_prev_pos = -1;
+static struct buffer *cached_disp_buffer;
+static int cached_disp_modiff;
+static int cached_disp_overlay_modiff;
+
 /* Return the character position of a display string at or after
    position specified by POSITION.  If no display string exists at or
    after POSITION, return ZV.  A display string is either an overlay
@@ -3155,6 +3163,7 @@ compute_display_string_pos (struct text_pos *position,
   EMACS_INT begb = string_p ? 0 : BEGV;
   EMACS_INT bufpos, charpos = CHARPOS (*position);
   struct text_pos tpos;
+  struct buffer *b;
 
   if (charpos >= eob
       /* We don't support display properties whose values are strings
@@ -3164,6 +3173,37 @@ compute_display_string_pos (struct text_pos *position,
       || (string->s && !STRINGP (object)))
     return eob;
 
+  /* Check the cached values.  */
+  if (!STRINGP (object))
+    {
+      if (NILP (object))
+        b = current_buffer;
+      else
+        b = XBUFFER (object);
+      if (b == cached_disp_buffer
+          && BUF_MODIFF (b) == cached_disp_modiff
+          && BUF_OVERLAY_MODIFF (b) == cached_disp_overlay_modiff)
+        {
+          if (cached_prev_pos >= 0
+              && cached_prev_pos < charpos && charpos <= cached_disp_pos)
+            return cached_disp_pos;
+          /* Handle overstepping either end of the known interval.  */
+          if (charpos > cached_disp_pos)
+            cached_prev_pos = cached_disp_pos;
+          else  /* charpos <= cached_prev_pos */
+            cached_prev_pos = max (charpos - 1, 0);
+        }
+
+      /* Record new values in the cache.  */
+      if (b != cached_disp_buffer)
+        {
+          cached_disp_buffer = b;
+          cached_prev_pos = max (charpos - 1, 0);
+        }
+      cached_disp_modiff = BUF_MODIFF (b);
+      cached_disp_overlay_modiff = BUF_OVERLAY_MODIFF (b);
+    }
+
   /* If the character at CHARPOS is where the display string begins,
      return CHARPOS.  */
   pos = make_number (charpos);
@@ -3179,7 +3219,11 @@ compute_display_string_pos (struct text_pos *position,
                   spec))
       && handle_display_spec (NULL, spec, object, Qnil, &tpos, bufpos,
                               frame_window_p))
-    return charpos;
+    {
+      if (!STRINGP (object))
+        cached_disp_pos = charpos;
+      return charpos;
+    }
 
   /* Look forward for the first character with a `display' property
      that will replace the underlying text when displayed.  */
@@ -3199,6 +3243,8 @@ compute_display_string_pos (struct text_pos *position,
            || !handle_display_spec (NULL, spec, object, Qnil, &tpos, bufpos,
                                     frame_window_p));
 
+  if (!STRINGP (object))
+    cached_disp_pos = CHARPOS (tpos);
   return CHARPOS (tpos);
 }
 
@@ -5731,17 +5777,19 @@ reseat (struct it *it, struct text_pos pos, int force_p)
         {
           /* For bidi iteration, we need to prime prev_stop and
              base_level_stop with our best estimations.  */
-          if (CHARPOS (pos) < it->prev_stop)
-            {
-              handle_stop_backwards (it, BEGV);
-              if (CHARPOS (pos) < it->base_level_stop)
-                it->base_level_stop = 0;
-            }
-          else if (CHARPOS (pos) > it->stop_charpos
-                   && it->stop_charpos >= BEGV)
-            handle_stop_backwards (it, it->stop_charpos);
-          else  /* force_p */
-            handle_stop (it);
+          /* Implementation note: Of course, POS is not necessarily a
+             stop position, so assigning prev_pos to it is a lie; we
+             should have called compute_stop_backwards.  However, if
+             the current buffer does not include any R2L characters,
+             that call would be a waste of cycles, because the
+             iterator will never move back, and thus never cross this
+             "fake" stop position.  So we delay that backward search
+             until the time we really need it, in next_element_from_buffer.  */
+          if (CHARPOS (pos) != it->prev_stop)
+            it->prev_stop = CHARPOS (pos);
+          if (CHARPOS (pos) < it->base_level_stop)
+            it->base_level_stop = 0; /* meaning it's unknown */
+          handle_stop (it);
         }
       else
         {
@@ -7008,10 +7056,10 @@ next_element_from_string (struct it *it)
                   embedding level, so test for that explicitly.  */
                && !BIDI_AT_BASE_LEVEL (it->bidi_it))
         {
-          /* If we lost track of base_level_stop, we have no better place
-             for handle_stop_backwards to start from than BEGV.  This
-             happens, e.g., when we were reseated to the previous
-             screenful of text by vertical-motion.  */
+          /* If we lost track of base_level_stop, we have no better
+             place for handle_stop_backwards to start from than string
+             beginning.  This happens, e.g., when we were reseated to
+             the previous screenful of text by vertical-motion.  */
           if (it->base_level_stop <= 0
               || IT_STRING_CHARPOS (*it) < it->base_level_stop)
             it->base_level_stop = 0;
@@ -7199,6 +7247,50 @@ next_element_from_stretch (struct it *it)
   return 1;
 }
 
+/* Scan backwards from IT's current position until we find a stop
+   position, or until BEGV.  This is called when we find ourself
+   before both the last known prev_stop and base_level_stop while
+   reordering bidirectional text.  */
+
+static void
+compute_stop_pos_backwards (struct it *it)
+{
+  const int SCAN_BACK_LIMIT = 1000;
+  struct text_pos pos;
+  struct display_pos save_current = it->current;
+  struct text_pos save_position = it->position;
+  EMACS_INT charpos = IT_CHARPOS (*it);
+  EMACS_INT where_we_are = charpos;
+  EMACS_INT save_stop_pos = it->stop_charpos;
+  EMACS_INT save_end_pos = it->end_charpos;
+
+  xassert (NILP (it->string) && !it->s);
+  xassert (it->bidi_p);
+  it->bidi_p = 0;
+  do
+    {
+      it->end_charpos = min (charpos + 1, ZV);
+      charpos = max (charpos - SCAN_BACK_LIMIT, BEGV);
+      SET_TEXT_POS (pos, charpos, BYTE_TO_CHAR (charpos));
+      reseat_1 (it, pos, 0);
+      compute_stop_pos (it);
+      /* We must advance forward, right?  */
+      if (it->stop_charpos <= charpos)
+        abort ();
+    }
+  while (charpos > BEGV && it->stop_charpos >= it->end_charpos);
+
+  if (it->stop_charpos <= where_we_are)
+    it->prev_stop = it->stop_charpos;
+  else
+    it->prev_stop = BEGV;
+  it->bidi_p = 1;
+  it->current = save_current;
+  it->position = save_position;
+  it->stop_charpos = save_stop_pos;
+  it->end_charpos = save_end_pos;
+}
+
 /* Scan forward from CHARPOS in the current buffer/string, until we
    find a stop position > current IT's position.  Then handle the stop
    position before that.  This is called when we bump into a stop
@@ -7218,6 +7310,7 @@ handle_stop_backwards (struct it *it, EMACS_INT charpos)
   EMACS_INT next_stop;
 
   /* Scan in strict logical order.  */
+  xassert (it->bidi_p);
   it->bidi_p = 0;
   do
     {
@@ -7237,11 +7330,11 @@ handle_stop_backwards (struct it *it, EMACS_INT charpos)
     }
   while (charpos <= where_we_are);
 
-  next_stop = it->stop_charpos;
-  it->stop_charpos = it->prev_stop;
   it->bidi_p = 1;
   it->current = save_current;
   it->position = save_position;
+  next_stop = it->stop_charpos;
+  it->stop_charpos = it->prev_stop;
   handle_stop (it);
   it->stop_charpos = next_stop;
 }
@@ -7338,14 +7431,19 @@ next_element_from_buffer (struct it *it)
               embedding level, so test for that explicitly.  */
            && !BIDI_AT_BASE_LEVEL (it->bidi_it))
     {
-      /* If we lost track of base_level_stop, we have no better place
-         for handle_stop_backwards to start from than BEGV.  This
-         happens, e.g., when we were reseated to the previous
-         screenful of text by vertical-motion.  */
       if (it->base_level_stop <= 0
           || IT_CHARPOS (*it) < it->base_level_stop)
-        it->base_level_stop = BEGV;
-      handle_stop_backwards (it, it->base_level_stop);
+        {
+          /* If we lost track of base_level_stop, we need to find
+             prev_stop by looking backwards.  This happens, e.g., when
+             we were reseated to the previous screenful of text by
+             vertical-motion.  */
+          it->base_level_stop = BEGV;
+          compute_stop_pos_backwards (it);
+          handle_stop_backwards (it, it->prev_stop);
+        }
+      else
+        handle_stop_backwards (it, it->base_level_stop);
       return GET_NEXT_DISPLAY_ELEMENT (it);
     }
   else
@@ -7547,8 +7645,9 @@ move_it_in_display_line_to (struct it *it,
 {
   enum move_it_result result = MOVE_UNDEFINED;
   struct glyph_row *saved_glyph_row;
-  struct it wrap_it, atpos_it, atx_it;
+  struct it wrap_it, atpos_it, atx_it, ppos_it;
   void *wrap_data = NULL, *atpos_data = NULL, *atx_data = NULL;
+  void *ppos_data = NULL;
   int may_wrap = 0;
   enum it_method prev_method = it->method;
   EMACS_INT prev_pos = IT_CHARPOS (*it);
@@ -7567,6 +7666,19 @@ move_it_in_display_line_to (struct it *it,
   atpos_it.sp = -1;
   atx_it.sp = -1;
 
+  /* Use ppos_it under bidi reordering to save a copy of IT for the
+     position > CHARPOS that is the closest to CHARPOS.  We restore
+     that position in IT when we have scanned the entire display line
+     without finding a match for CHARPOS and all the character
+     positions are greater than CHARPOS.  */
+  if (it->bidi_p)
+    {
+      SAVE_IT (ppos_it, *it, ppos_data);
+      SET_TEXT_POS (ppos_it.current.pos, ZV, ZV_BYTE);
+      if ((op & MOVE_TO_POS) && IT_CHARPOS (*it) >= to_charpos)
+        SAVE_IT (ppos_it, *it, ppos_data);
+    }
+
 #define BUFFER_POS_REACHED_P()                                  \
   ((op & MOVE_TO_POS) != 0                                      \
    && BUFFERP (it->object)                                      \
@@ -7692,6 +7804,11 @@ move_it_in_display_line_to (struct it *it,
           if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
             SET_TEXT_POS (this_line_min_pos,
                           IT_CHARPOS (*it), IT_BYTEPOS (*it));
+          if (it->bidi_p
+              && (op & MOVE_TO_POS)
+              && IT_CHARPOS (*it) > to_charpos
+              && IT_CHARPOS (*it) < IT_CHARPOS (ppos_it))
+            SAVE_IT (ppos_it, *it, ppos_data);
           continue;
         }
 
@@ -7902,7 +8019,11 @@ move_it_in_display_line_to (struct it *it,
           if ((op & MOVE_TO_POS) != 0
               && !saw_smaller_pos
               && IT_CHARPOS (*it) > to_charpos)
-            result = MOVE_POS_MATCH_OR_ZV;
+            {
+              result = MOVE_POS_MATCH_OR_ZV;
+              if (it->bidi_p && IT_CHARPOS (ppos_it) < ZV)
+                RESTORE_IT (it, &ppos_it, ppos_data);
+            }
           else
             result = MOVE_NEWLINE_OR_CR;
           break;
@@ -7918,6 +8039,11 @@ move_it_in_display_line_to (struct it *it,
         SET_TEXT_POS (this_line_min_pos, IT_CHARPOS (*it), IT_BYTEPOS (*it));
       if (IT_CHARPOS (*it) < to_charpos)
         saw_smaller_pos = 1;
+      if (it->bidi_p
+          && (op & MOVE_TO_POS)
+          && IT_CHARPOS (*it) >= to_charpos
+          && IT_CHARPOS (*it) < IT_CHARPOS (ppos_it))
+        SAVE_IT (ppos_it, *it, ppos_data);
 
       /* Stop if lines are truncated and IT's current x-position is
          past the right edge of the window now.  */
@@ -7927,7 +8053,9 @@ move_it_in_display_line_to (struct it *it,
           if (!FRAME_WINDOW_P (it->f)
               || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
             {
-              if (!get_next_display_element (it)
+              int at_eob_p = 0;
+
+              if ((at_eob_p = !get_next_display_element (it))
                   || BUFFER_POS_REACHED_P ()
                   /* If we are past TO_CHARPOS, but never saw any
                      character positions smaller than TO_CHARPOS,
@@ -7938,6 +8066,8 @@ move_it_in_display_line_to (struct it *it,
                       && IT_CHARPOS (*it) > to_charpos))
                 {
                   result = MOVE_POS_MATCH_OR_ZV;
+                  if (it->bidi_p && !at_eob_p && IT_CHARPOS (ppos_it) < ZV)
+                    RESTORE_IT (it, &ppos_it, ppos_data);
                   break;
                 }
               if (ITERATOR_AT_END_OF_LINE_P (it))
@@ -7951,6 +8081,8 @@ move_it_in_display_line_to (struct it *it,
                    && IT_CHARPOS (*it) > to_charpos)
             {
               result = MOVE_POS_MATCH_OR_ZV;
+              if (it->bidi_p && IT_CHARPOS (ppos_it) < ZV)
+                RESTORE_IT (it, &ppos_it, ppos_data);
               break;
             }
           result = MOVE_LINE_TRUNCATED;
@@ -7976,6 +8108,8 @@ move_it_in_display_line_to (struct it *it,
     xfree (atx_data);
   if (wrap_data)
     xfree (wrap_data);
+  if (ppos_data)
+    xfree (ppos_data);
 
   /* Restore the iterator settings altered at the beginning of this
      function.  */
@@ -23126,7 +23260,7 @@ produce_glyphless_glyph (struct it *it, int for_no_font, Lisp_Object acronym)
   base_width = font->average_width;
 
   /* Get a face ID for the glyph by utilizing a cache (the same way as
-     doen for `escape-glyph' in get_next_display_element).  */
+     done for `escape-glyph' in get_next_display_element).  */
   if (it->f == last_glyphless_glyph_frame
       && it->face_id == last_glyphless_glyph_face_id)
     {
@@ -25029,7 +25163,7 @@ rows_from_pos_range (struct window *w,
 
           while (g < e)
             {
-              if (BUFFERP (g->object)
+              if ((BUFFERP (g->object) || INTEGERP (g->object))
                   && start_charpos <= g->charpos && g->charpos < end_charpos)
                 *start = row;
               g++;
@@ -25079,7 +25213,7 @@ rows_from_pos_range (struct window *w,
 
           while (g < e)
             {
-              if (BUFFERP (g->object)
+              if ((BUFFERP (g->object) || INTEGERP (g->object))
                   && start_charpos <= g->charpos && g->charpos < end_charpos)
                 break;
               g++;
diff --git a/src/xfaces.c b/src/xfaces.c
index e0dc2883f33..52b125b42e6 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -1920,7 +1920,8 @@ check_lface_attrs (Lisp_Object *attrs)
            || IGNORE_DEFFACE_P (attrs[LFACE_FONT_INDEX])
            || FONTP (attrs[LFACE_FONT_INDEX]));
   xassert (UNSPECIFIEDP (attrs[LFACE_FONTSET_INDEX])
-           || STRINGP (attrs[LFACE_FONTSET_INDEX]));
+           || STRINGP (attrs[LFACE_FONTSET_INDEX])
+           || NILP (attrs[LFACE_FONTSET_INDEX]));
 #endif
 }
 
diff --git a/src/xfns.c b/src/xfns.c
index 0d1e4a1bb5e..eec19b9d275 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -2933,7 +2933,7 @@ unwind_create_frame (Lisp_Object frame)
 #if GLYPH_DEBUG
       /* Check that reference counts are indeed correct.  */
       xassert (dpyinfo->reference_count == dpyinfo_refcount);
-      xassert (dpyinfo->image_cache->refcount == image_cache_refcount);
+      xassert (dpyinfo->terminal->image_cache->refcount == image_cache_refcount);
 #endif
       return Qt;
     }
diff --git a/src/xml.c b/src/xml.c
index 63041c96b24..55352baae3a 100644
--- a/src/xml.c
+++ b/src/xml.c
@@ -71,6 +71,14 @@ make_dom (xmlNode *node)
       else
         return Qnil;
     }
+  else if (node->type == XML_COMMENT_NODE)
+    {
+      if (node->content)
+        return list3 (intern ("comment"), Qnil,
+                      build_string ((char *) node->content));
+      else
+        return Qnil;
+    }
   else
     return Qnil;
 }
@@ -79,7 +87,6 @@ static Lisp_Object
 parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, int htmlp)
 {
   xmlDoc *doc;
-  xmlNode *node;
   Lisp_Object result = Qnil;
   const char *burl = "";
   EMACS_INT bytes;
@@ -117,9 +124,22 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, int html
 
   if (doc != NULL)
     {
-      node = xmlDocGetRootElement (doc);
-      if (node != NULL)
-        result = make_dom (node);
+      xmlNode *n = doc->children->next;
+      Lisp_Object r = Qnil;
+
+      while (n) {
+        if (!NILP (r))
+          result = Fcons (r, result);
+        r = make_dom (n);
+        n = n->next;
+      }
+
+      if (NILP (result))
+        result = r;
+      else
+        result = Fcons (intern ("top"),
+                        Fcons (Qnil, Fnreverse (Fcons (r, result))));
+
       xmlFreeDoc (doc);
       xmlCleanupParser ();
     }