Merged in changes from CVS trunk.

Patches applied:

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-213
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-214
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-215
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-216
   Update from CVS

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-217
   Update from CVS


git-archimport-id: lorentey@elte.hu--2004/emacs--multi-tty--0--patch-138

10 files changed, 500 insertions, 37 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 6d48aa0f6d0..c9cf12dc159 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,39 @@
+2004-04-14  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * fileio.c (Fverify_visited_file_modtime, Fvisited_file_modtime):
+        Add hyperlink to Elisp manual to the docstring.
+
+2004-04-14  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * callint.c (fix_command): Use XDCR.
+
+2004-04-14  Nick Roberts  <nick@nick.uklinux.net>
+
+        * window.c (Fget_lru_window): Doc fix.
+
+2004-04-14  Kim F. Storm  <storm@cua.dk>
+
+        * editfns.c (Fformat): Fix allocation size of precision array.
+
+        * dispnew.c (update_window): Only set changed_p if
+        scrolling_window actually did scroll.
+        (scrolling_window): Only return 1 if we actually did scroll.
+
+        * xdisp.c (get_glyph_string_clip_rect): Fix reduction of cursor
+        height to glyph height when cursor row is not fully visible.
+        (make_cursor_line_fully_visible): Add FORCE_P arg to return
+        failure in case row is higher than window.  Callers changed.
+        (try_scrolling): Fix loop in scrolling if last_line_misfit (from Gerd).
+        Try to scroll partially visible, higher-than-window cursor row.
+        (redisplay_window): Always try to scroll partially visible,
+        higher-than-window cursor row - both initially and again with
+        centering_position = 0.
+        Clear desired matrix before retrying with centering_position = 0.
+
+2004-04-13  Joe Buehler  <jbuehler@hekimian.com>
+
+        * sheap.c, unexcw.c: New files.
+
 2004-04-12  Luc Teirlinck  <teirllm@auburn.edu>
 
         * buffer.c (Fmake_indirect_buffer): Throw an error if the intended
@@ -32,6 +68,10 @@
         * buffer.c (fix_start_end_in_overlays): Make overlays
         empty if they are backwards.
 
+2004-04-09  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xfaces.c (face_color_supported_p): Fix compilation without X11.
+
 2004-04-07  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * doc.c (Fsnarf_documentation): Ignore new file name entries.
diff --git a/src/callint.c b/src/callint.c
index 1d7d6f9f89f..50090db8b28 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -209,7 +209,7 @@ fix_command (input, values)
           Lisp_Object intail, valtail;
           for (intail = Fcdr (input), valtail = values;
                CONSP (valtail);
-               intail = Fcdr (intail), valtail = Fcdr (valtail))
+               intail = Fcdr (intail), valtail = XCDR (valtail))
             {
               Lisp_Object elt;
               elt = Fcar (intail);
diff --git a/src/dispnew.c b/src/dispnew.c
index 3b658993811..9a6b0cb65cf 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -4132,9 +4132,11 @@ update_window (w, force_p)
               goto set_cursor;
             }
           else if (rc > 0)
-            /* We've scrolled the display.  */
-            force_p = 1;
-          changed_p = 1;
+            {
+              /* We've scrolled the display.  */
+              force_p = 1;
+              changed_p = 1;
+            }
         }
 
       /* Update the rest of the lines.  */
@@ -5056,8 +5058,8 @@ scrolling_window (w, header_line_p)
   for (i = 0; i < row_entry_idx; ++i)
     row_table[row_entry_pool[i].bucket] = NULL;
 
-  /* Value is non-zero to indicate that we scrolled the display.  */
-  return 1;
+  /* Value is > 0 to indicate that we scrolled the display.  */
+  return nruns;
 }
 
 
@@ -5919,13 +5921,13 @@ marginal_area_string (w, part, x, y, charpos, object, dx, dy, width, height)
          it's the one we were looking for.  */
       if (area == RIGHT_MARGIN_AREA)
         x0 = ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-               ? WINDOW_LEFT_FRINGE_WIDTH (w) 
+               ? WINDOW_LEFT_FRINGE_WIDTH (w)
                : WINDOW_TOTAL_FRINGE_WIDTH (w))
               + window_box_width (w, LEFT_MARGIN_AREA)
               + window_box_width (w, TEXT_AREA));
       else
         x0 = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-              ? WINDOW_LEFT_FRINGE_WIDTH (w) 
+              ? WINDOW_LEFT_FRINGE_WIDTH (w)
               : 0);
 
       glyph = row->glyphs[area];
diff --git a/src/editfns.c b/src/editfns.c
index ce075f2696c..a5c3aea14bc 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -3220,7 +3220,7 @@ usage: (format STRING &rest OBJECTS)  */)
      string itself, will not be used.  Element NARGS, corresponding to
      no argument, *will* be assigned to in the case that a `%' and `.'
      occur after the final format specifier.  */
-  int *precision = (int *) (alloca(nargs * sizeof (int)));
+  int *precision = (int *) (alloca((nargs + 1) * sizeof (int)));
   int longest_format;
   Lisp_Object val;
   int arg_intervals = 0;
@@ -3274,7 +3274,7 @@ usage: (format STRING &rest OBJECTS)  */)
   /* Make room in result for all the non-%-codes in the control string.  */
   total = 5 + CONVERTED_BYTE_SIZE (multibyte, args[0]);
 
-  /* Allocate the info and discarded tables.  */ 
+  /* Allocate the info and discarded tables.  */
   {
     int nbytes = nargs * sizeof *info;
     int i;
diff --git a/src/fileio.c b/src/fileio.c
index 3f17da7033d..c0195558a3c 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -5509,7 +5509,8 @@ e_write (desc, string, start, end, coding)
 DEFUN ("verify-visited-file-modtime", Fverify_visited_file_modtime,
        Sverify_visited_file_modtime, 1, 1, 0,
        doc: /* Return t if last mod time of BUF's visited file matches what BUF records.
-This means that the file has not been changed since it was visited or saved.  */)
+This means that the file has not been changed since it was visited or saved.
+See Info node `(elisp)Modification Time' for more details.  */)
      (buf)
      Lisp_Object buf;
 {
@@ -5565,7 +5566,9 @@ DEFUN ("visited-file-modtime", Fvisited_file_modtime,
        Svisited_file_modtime, 0, 0, 0,
        doc: /* Return the current buffer's recorded visited file modification time.
 The value is a list of the form (HIGH . LOW), like the time values
-that `file-attributes' returns.  */)
+that `file-attributes' returns.  If the current buffer has no recorded
+file modification time, this function returns 0.
+See Info node `(elisp)Modification Time' for more details.  */)
      ()
 {
   return long_to_cons ((unsigned long) current_buffer->modtime);
diff --git a/src/sheap.c b/src/sheap.c
new file mode 100644
index 00000000000..714eb9a710d
--- /dev/null
+++ b/src/sheap.c
@@ -0,0 +1,104 @@
+/* simulate sbrk() with an array in .bss, for unexec() support for Cygwin;
+   complete rewrite of xemacs Cygwin unexec() code
+
+   Copyright (C) 2004
+   Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs; see the file COPYING.  If not, write to
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+#include <config.h>
+#include <stdio.h>
+#include "lisp.h"
+
+#include <unistd.h>
+
+#ifdef HAVE_X_WINDOWS
+#define STATIC_HEAP_SIZE        (7 * 1024 * 1024)
+#else
+#define STATIC_HEAP_SIZE        (7 * 1024 * 1024)
+#endif
+
+int debug_sheap = 0;
+
+#define BLOCKSIZE 4096
+
+char bss_sbrk_buffer[STATIC_HEAP_SIZE];
+char *bss_sbrk_ptr;
+int bss_sbrk_did_unexec;
+
+void *
+bss_sbrk (ptrdiff_t request_size)
+{
+  if (!bss_sbrk_ptr)
+    {
+      bss_sbrk_ptr = bss_sbrk_buffer;
+#ifdef CYGWIN
+      sbrk (BLOCKSIZE);         /* force space for fork to work */
+#endif
+    }
+
+  if (!(int) request_size)
+    {
+      return (bss_sbrk_ptr);
+    }
+  else if (bss_sbrk_ptr + (int) request_size < bss_sbrk_buffer)
+    {
+      printf
+        ("attempt to free too much: avail %d used %d failed request %d\n",
+         STATIC_HEAP_SIZE, bss_sbrk_ptr - bss_sbrk_buffer,
+         (int) request_size);
+      exit (-1);
+      return 0;
+    }
+  else if (bss_sbrk_ptr + (int) request_size >
+           bss_sbrk_buffer + STATIC_HEAP_SIZE)
+    {
+      printf ("static heap exhausted: avail %d used %d failed request %d\n",
+              STATIC_HEAP_SIZE,
+              bss_sbrk_ptr - bss_sbrk_buffer, (int) request_size);
+      exit (-1);
+      return 0;
+    }
+  else if ((int) request_size < 0)
+    {
+      bss_sbrk_ptr += (int) request_size;
+      if (debug_sheap)
+        printf ("freed size %d\n", request_size);
+      return bss_sbrk_ptr;
+    }
+  else
+    {
+      char *ret = bss_sbrk_ptr;
+      if (debug_sheap)
+        printf ("allocated 0x%08x size %d\n", ret, request_size);
+      bss_sbrk_ptr += (int) request_size;
+      return ret;
+    }
+}
+
+void
+report_sheap_usage (int die_if_pure_storage_exceeded)
+{
+  char buf[200];
+  sprintf (buf, "Static heap usage: %d of %d bytes",
+           bss_sbrk_ptr - bss_sbrk_buffer, STATIC_HEAP_SIZE);
+  message ("%s", buf);
+}
+
+/* arch-tag: 1bc386e8-71c2-4da4-b8b5-c1674a9cf926
+   (do not change this comment) */
diff --git a/src/syntax.c b/src/syntax.c
index 30fc94267cd..72f7a5c5209 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -2398,8 +2398,8 @@ scan_lists (from, count, depth, sexpflag)
             case Sstring_fence:
               while (1)
                 {
-                  DEC_BOTH (from, from_byte);
                   if (from == stop) goto lose;
+                  DEC_BOTH (from, from_byte);
                   UPDATE_SYNTAX_TABLE_BACKWARD (from);
                   if (!char_quoted (from, from_byte)
                       && (c = FETCH_CHAR (from_byte),
@@ -2414,19 +2414,13 @@ scan_lists (from, count, depth, sexpflag)
               while (1)
                 {
                   if (from == stop) goto lose;
-                  temp_pos = from_byte;
-                  if (! NILP (current_buffer->enable_multibyte_characters))
-                    DEC_POS (temp_pos);
-                  else
-                    temp_pos--;
-                  UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
-                  if (!char_quoted (from - 1, temp_pos)
-                      && stringterm == (c = FETCH_CHAR (temp_pos))
+                  DEC_BOTH (from, from_byte);
+                  UPDATE_SYNTAX_TABLE_BACKWARD (from);
+                  if (!char_quoted (from, from_byte)
+                      && stringterm == (c = FETCH_CHAR (from_byte))
                       && SYNTAX_WITH_MULTIBYTE_CHECK (c) == Sstring)
                     break;
-                  DEC_BOTH (from, from_byte);
                 }
-              DEC_BOTH (from, from_byte);
               if (!depth && sexpflag) goto done2;
               break;
             default:
diff --git a/src/unexcw.c b/src/unexcw.c
new file mode 100644
index 00000000000..046c8f796ef
--- /dev/null
+++ b/src/unexcw.c
@@ -0,0 +1,307 @@
+/* unexec() support for Cygwin;
+   complete rewrite of xemacs Cygwin unexec() code
+
+   Copyright (C) 2004
+   Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs; see the file COPYING.  If not, write to
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+#include <config.h>
+#include <lisp.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <a.out.h>
+#include <unistd.h>
+#include <assert.h>
+
+#define DOTEXE ".exe"
+
+extern int bss_sbrk_did_unexec;
+
+/* emacs symbols that indicate where bss and data end for emacs internals */
+extern char my_endbss[];
+extern char my_edata[];
+
+/*
+** header for Windows executable files
+*/
+typedef struct
+{
+  FILHDR file_header;
+  PEAOUTHDR file_optional_header;
+  SCNHDR section_header[32];
+} exe_header_t;
+
+int debug_unexcw = 0;
+
+/*
+** Read the header from the executable into memory so we can more easily access it.
+*/
+static exe_header_t *
+read_exe_header (int fd, exe_header_t * exe_header_buffer)
+{
+  int i;
+  int ret;
+
+  assert (fd >= 0);
+  assert (exe_header_buffer != 0);
+
+  ret = lseek (fd, 0L, SEEK_SET);
+  assert (ret != -1);
+
+  ret =
+    read (fd, &exe_header_buffer->file_header,
+          sizeof (exe_header_buffer->file_header));
+  assert (ret == sizeof (exe_header_buffer->file_header));
+
+  assert (exe_header_buffer->file_header.e_magic == 0x5a4d);
+  assert (exe_header_buffer->file_header.nt_signature == 0x4550);
+  assert (exe_header_buffer->file_header.f_magic == 0x014c);
+  assert (exe_header_buffer->file_header.f_nscns > 0);
+  assert (exe_header_buffer->file_header.f_nscns <=
+          sizeof (exe_header_buffer->section_header) /
+          sizeof (exe_header_buffer->section_header[0]));
+  assert (exe_header_buffer->file_header.f_opthdr > 0);
+
+  ret =
+    read (fd, &exe_header_buffer->file_optional_header,
+          sizeof (exe_header_buffer->file_optional_header));
+  assert (ret == sizeof (exe_header_buffer->file_optional_header));
+
+  assert (exe_header_buffer->file_optional_header.magic == 0x010b);
+
+  for (i = 0; i < exe_header_buffer->file_header.f_nscns; ++i)
+    {
+      ret =
+        read (fd, &exe_header_buffer->section_header[i],
+              sizeof (exe_header_buffer->section_header[i]));
+      assert (ret == sizeof (exe_header_buffer->section_header[i]));
+    }
+
+  return (exe_header_buffer);
+}
+
+/*
+** Fix the dumped emacs executable:
+**
+** - copy .data section data of interest from running executable into
+**   output .exe file
+**
+** - convert .bss section into an initialized data section (like
+**   .data) and copy .bss section data of interest from running
+**   executable into output .exe file
+*/
+static void
+fixup_executable (int fd)
+{
+  exe_header_t exe_header_buffer;
+  exe_header_t *exe_header;
+  int i;
+  int ret;
+  int found_data = 0;
+  int found_bss = 0;
+
+  exe_header = read_exe_header (fd, &exe_header_buffer);
+  assert (exe_header != 0);
+
+  assert (exe_header->file_header.f_nscns > 0);
+  for (i = 0; i < exe_header->file_header.f_nscns; ++i)
+    {
+      unsigned long start_address =
+        exe_header->section_header[i].s_vaddr +
+        exe_header->file_optional_header.ImageBase;
+      unsigned long end_address =
+        exe_header->section_header[i].s_vaddr +
+        exe_header->file_optional_header.ImageBase +
+        exe_header->section_header[i].s_paddr;
+      if (debug_unexcw)
+        printf ("%8s start 0x%08x end 0x%08x\n",
+                exe_header->section_header[i].s_name,
+                start_address, end_address);
+      if (my_edata >= (char *) start_address
+          && my_edata < (char *) end_address)
+        {
+          /* data section */
+          ret =
+            lseek (fd, (long) (exe_header->section_header[i].s_scnptr),
+                   SEEK_SET);
+          assert (ret != -1);
+          ret =
+            write (fd, (char *) start_address,
+                   my_edata - (char *) start_address);
+          assert (ret == my_edata - (char *) start_address);
+          ++found_data;
+          if (debug_unexcw)
+            printf ("         .data, mem start 0x%08x mem length %d\n",
+                    start_address, my_edata - (char *) start_address);
+          if (debug_unexcw)
+            printf ("         .data, file start %d file length %d\n",
+                    (int) exe_header->section_header[i].s_scnptr,
+                    (int) exe_header->section_header[i].s_paddr);
+        }
+      else if (my_endbss >= (char *) start_address
+               && my_endbss < (char *) end_address)
+        {
+          /* bss section */
+          ++found_bss;
+          if (exe_header->section_header[i].s_flags & 0x00000080)
+            {
+              /* convert uninitialized data section to initialized data section */
+              struct stat statbuf;
+              ret = fstat (fd, &statbuf);
+              assert (ret != -1);
+
+              exe_header->section_header[i].s_flags &= ~0x00000080;
+              exe_header->section_header[i].s_flags |= 0x00000040;
+
+              exe_header->section_header[i].s_scnptr =
+                (statbuf.st_size +
+                 exe_header->file_optional_header.FileAlignment) /
+                exe_header->file_optional_header.FileAlignment *
+                exe_header->file_optional_header.FileAlignment;
+
+              exe_header->section_header[i].s_size =
+                (exe_header->section_header[i].s_paddr +
+                 exe_header->file_optional_header.FileAlignment) /
+                exe_header->file_optional_header.FileAlignment *
+                exe_header->file_optional_header.FileAlignment;
+
+              ret =
+                lseek (fd,
+                       (long) (exe_header->section_header[i].s_scnptr +
+                               exe_header->section_header[i].s_size - 1),
+                       SEEK_SET);
+              assert (ret != -1);
+              ret = write (fd, "", 1);
+              assert (ret == 1);
+
+              ret =
+                lseek (fd,
+                       (long) ((char *) &exe_header->section_header[i] -
+                               (char *) exe_header), SEEK_SET);
+              assert (ret != -1);
+              ret =
+                write (fd, &exe_header->section_header[i],
+                       sizeof (exe_header->section_header[i]));
+              assert (ret == sizeof (exe_header->section_header[i]));
+              if (debug_unexcw)
+                printf ("         seek to %ld, write %d\n",
+                        (long) ((char *) &exe_header->section_header[i] -
+                                (char *) exe_header),
+                        sizeof (exe_header->section_header[i]));
+            }
+          /* write initialized data section */
+          ret =
+            lseek (fd, (long) (exe_header->section_header[i].s_scnptr),
+                   SEEK_SET);
+          assert (ret != -1);
+          ret =
+            write (fd, (char *) start_address,
+                   my_endbss - (char *) start_address);
+          assert (ret == (my_endbss - (char *) start_address));
+          if (debug_unexcw)
+            printf ("         .bss, mem start 0x%08x mem length %d\n",
+                    start_address, my_endbss - (char *) start_address);
+          if (debug_unexcw)
+            printf ("         .bss, file start %d file length %d\n",
+                    (int) exe_header->section_header[i].s_scnptr,
+                    (int) exe_header->section_header[i].s_paddr);
+        }
+    }
+  assert (found_bss == 1);
+  assert (found_data == 1);
+}
+
+/*
+** Windows likes .exe suffixes on executables.
+*/
+static char *
+add_exe_suffix_if_necessary (const char *name, char *modified)
+{
+  int i = strlen (name);
+  if (i <= (sizeof (DOTEXE) - 1))
+    {
+      sprintf (modified, "%s%s", name, DOTEXE);
+    }
+  else if (!strcasecmp (name + i - (sizeof (DOTEXE) - 1), DOTEXE))
+    {
+      strcpy (modified, name);
+    }
+  else
+    {
+      sprintf (modified, "%s%s", name, DOTEXE);
+    }
+  return (modified);
+}
+
+int
+unexec (char *outfile, char *infile, unsigned start_data, unsigned d1,
+        unsigned d2)
+{
+  char infile_buffer[FILENAME_MAX];
+  char outfile_buffer[FILENAME_MAX];
+  int fd_in;
+  int fd_out;
+  int ret;
+  int ret2;
+
+  if (bss_sbrk_did_unexec)
+    {
+      /* can only dump once */
+      printf ("You can only dump emacs once on this platform.\n");
+      return (1);
+    }
+
+  report_sheap_usage (1);
+
+  infile = add_exe_suffix_if_necessary (infile, infile_buffer);
+  outfile = add_exe_suffix_if_necessary (outfile, outfile_buffer);
+
+  fd_in = open (infile, O_RDONLY | O_BINARY);
+  assert (fd_in >= 0);
+  fd_out = open (outfile, O_RDWR | O_TRUNC | O_CREAT | O_BINARY, 0755);
+  assert (fd_out >= 0);
+  for (;;)
+    {
+      char buffer[4096];
+      ret = read (fd_in, buffer, sizeof (buffer));
+      if (ret == 0)
+        {
+          /* eof */
+          break;
+        }
+      assert (ret > 0);
+      /* data */
+      ret2 = write (fd_out, buffer, ret);
+      assert (ret2 == ret);
+    }
+  ret = close (fd_in);
+  assert (ret == 0);
+
+  bss_sbrk_did_unexec = 1;
+  fixup_executable (fd_out);
+  bss_sbrk_did_unexec = 0;
+
+  ret = close (fd_out);
+  assert (ret == 0);
+
+  return (0);
+}
+
+/* arch-tag: fc44f6c3-ca0a-45e0-a5a2-58b6101b1e65
+   (do not change this comment) */
diff --git a/src/window.c b/src/window.c
index 0192aa4edf6..b6546eee698 100644
--- a/src/window.c
+++ b/src/window.c
@@ -2080,6 +2080,7 @@ check_all_windows ()
 
 DEFUN ("get-lru-window", Fget_lru_window, Sget_lru_window, 0, 1, 0,
        doc: /* Return the window least recently selected or used for display.
+Return a full-width window if possible.
 If optional argument FRAME is `visible', search all visible frames.
 If FRAME is 0, search all visible and iconified frames.
 If FRAME is t, search all frames.
diff --git a/src/xdisp.c b/src/xdisp.c
index 0f5cde82cbd..b2e26d0858a 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -846,7 +846,7 @@ static struct glyph_row *get_overlay_arrow_glyph_row P_ ((struct window *,
                                                           Lisp_Object));
 static void extend_face_to_end_of_line P_ ((struct it *));
 static int append_space P_ ((struct it *, int));
-static int make_cursor_line_fully_visible P_ ((struct window *));
+static int make_cursor_line_fully_visible P_ ((struct window *, int));
 static int try_scrolling P_ ((Lisp_Object, int, EMACS_INT, EMACS_INT, int, int));
 static int try_cursor_movement P_ ((Lisp_Object, struct text_pos, int *));
 static int trailing_whitespace_p P_ ((int));
@@ -1789,8 +1789,9 @@ get_glyph_string_clip_rect (s, nr)
       height = max (FRAME_LINE_HEIGHT (s->f), glyph->ascent + glyph->descent);
       if (height < r.height)
         {
-          r.y = s->ybase + glyph->descent - height;
-          r.height = height;
+          int max_y = r.y + r.height;
+          r.y = min (max_y, s->ybase + glyph->descent - height);
+          r.height = min (max_y - r.y, height);
         }
     }
 
@@ -10729,12 +10730,17 @@ run_window_scroll_functions (window, startp)
    A value of 1 means there is nothing to be done.
    (Either the line is fully visible, or it cannot be made so,
    or we cannot tell.)
+
+   If FORCE_P is non-zero, return 0 even if partial visible cursor row
+   is higher than window.
+
    A value of 0 means the caller should do scrolling
    as if point had gone off the screen.  */
 
 static int
-make_cursor_line_fully_visible (w)
+make_cursor_line_fully_visible (w, force_p)
      struct window *w;
+     int force_p;
 {
   struct glyph_matrix *matrix;
   struct glyph_row *row;
@@ -10752,6 +10758,9 @@ make_cursor_line_fully_visible (w)
   if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (row))
     return 1;
 
+  if (force_p)
+    return 0;
+
   /* If the row the cursor is in is taller than the window's height,
      it's not clear what to do, so do nothing.  */
   window_height = window_box_height (w);
@@ -10848,7 +10857,7 @@ try_scrolling (window, just_this_one_p, scroll_conservatively,
   int amount_to_scroll = 0;
   Lisp_Object aggressive;
   int height;
-  int end_scroll_margin;
+  int extra_scroll_margin_lines = last_line_misfit ? 1 : 0;
 
 #if GLYPH_DEBUG
   debug_method_add (w, "try_scrolling");
@@ -10891,11 +10900,13 @@ try_scrolling (window, just_this_one_p, scroll_conservatively,
   CHARPOS (scroll_margin_pos) = XINT (window_end);
   BYTEPOS (scroll_margin_pos) = CHAR_TO_BYTE (CHARPOS (scroll_margin_pos));
 
-  end_scroll_margin = this_scroll_margin + !!last_line_misfit;
-  if (end_scroll_margin)
+  if (this_scroll_margin || extra_scroll_margin_lines)
     {
       start_display (&it, w, scroll_margin_pos);
-      move_it_vertically (&it, - end_scroll_margin);
+      if (this_scroll_margin)
+        move_it_vertically (&it, - this_scroll_margin);
+      if (extra_scroll_margin_lines)
+        move_it_by_lines (&it, - extra_scroll_margin_lines, 0);
       scroll_margin_pos = it.current.pos;
     }
 
@@ -11030,10 +11041,10 @@ try_scrolling (window, just_this_one_p, scroll_conservatively,
 
       /* If cursor ends up on a partially visible line,
          treat that as being off the bottom of the screen.  */
-      if (! make_cursor_line_fully_visible (w))
+      if (! make_cursor_line_fully_visible (w, extra_scroll_margin_lines <= 1))
         {
           clear_glyph_matrix (w->desired_matrix);
-          last_line_misfit = 1;
+          ++extra_scroll_margin_lines;
           goto too_near_end;
         }
       rc = SCROLLING_SUCCESS;
@@ -11322,7 +11333,7 @@ try_cursor_movement (window, startp, scroll_step)
               else
                 {
                   set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
-                  if (!make_cursor_line_fully_visible (w))
+                  if (!make_cursor_line_fully_visible (w, 0))
                     rc = CURSOR_MOVEMENT_MUST_SCROLL;
                   else
                     rc = CURSOR_MOVEMENT_SUCCESS;
@@ -11655,7 +11666,7 @@ redisplay_window (window, just_this_one_p)
           new_vpos = window_box_height (w) / 2;
         }
 
-      if (!make_cursor_line_fully_visible (w))
+      if (!make_cursor_line_fully_visible (w, 0))
         {
           /* Point does appear, but on a line partly visible at end of window.
              Move it back to a fully-visible line.  */
@@ -11792,7 +11803,7 @@ redisplay_window (window, just_this_one_p)
             /* Forget any recorded base line for line number display.  */
             w->base_line_number = Qnil;
 
-          if (!make_cursor_line_fully_visible (w))
+          if (!make_cursor_line_fully_visible (w, 1))
             {
               clear_glyph_matrix (w->desired_matrix);
               last_line_misfit = 1;
@@ -11952,7 +11963,7 @@ redisplay_window (window, just_this_one_p)
       set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
     }
 
-  if (!make_cursor_line_fully_visible (w))
+  if (!make_cursor_line_fully_visible (w, centering_position > 0))
     {
       /* If vscroll is enabled, disable it and try again.  */
       if (w->vscroll)
@@ -11965,6 +11976,7 @@ redisplay_window (window, just_this_one_p)
       /* If centering point failed to make the whole line visible,
          put point at the top instead.  That has to make the whole line
          visible, if it can be done.  */
+      clear_glyph_matrix (w->desired_matrix);
       centering_position = 0;
       goto point_at_top;
     }