Merge branch 'master' into cairo

36 files changed, 1304 insertions, 928 deletions

diff --git a/src/ChangeLog b/src/ChangeLog.13
index 78070072438..8057b6e75d6 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog.13
@@ -31,6 +31,12 @@
         (tiff_load): Create cairo image surface if USE_CAIRO.
         (gif_load): Ditto.
 
+2015-04-06  Koichi Arakawa  <arakawa@pp.iij4u.or.jp>  (tiny change)
+
+        * w32proc.c (w32_executable_type): Look for the DLL name in the
+        correct section.  This avoids segfaults with some executables.
+        (Bug#20264)
+
 2015-04-05  Jan Djärv  <jan.h.d@swipnet.se>
 
         * image.c: #undef COLOR_TABLE_SUPPORT when USE_CAIRO.
@@ -40,6 +46,15 @@
 
         * dispextern.h (struct image): add cr_data2 if cairo.
 
+2015-04-04  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xselect.c (x_reply_selection_request)
+        (receive_incremental_selection): Call set_property_change_object
+        inside block_input.
+        (wait_for_property_change): Move set property_change_reply(_object)
+        outside of this function (Bug#16737).
+        (set_property_change_object): New function.
+
 2015-04-03  Jan Djärv  <jan.h.d@swipnet.se>
 
         * image.c (prepare_image_for_display): Don't load if USE_CAIRO.
@@ -160,7 +175,7 @@
         Fix minor ldexp issues
         * floatfns.c (Fldexp): Require 2 args.  Avoid undefined behavior
         if the exponent is out of 'int' range.  Improve documentation.
-        Fixes: bug#20185
+        (Bug#20185)
 
 2015-03-24  Daniel Colascione  <dancol@dancol.org>
 
@@ -251,7 +266,7 @@
 
         Work around x86 glibc backtrace bug
         * sysdep.c (emacs_backtrace): Don't dump core on x86.
-        Fixes: bug#19959
+        (Bug#19959)
 
 2015-03-05  Eli Zaretskii  <eliz@gnu.org>
 
@@ -1300,7 +1315,7 @@
         to unused args.
         * lisp.h (CALLMANY, CALLN): New macros.
         * sound.c (Fplay_sound_internal): Coalesce duplicate code.
-        Fixes: bug#19634
+        (Bug#19634)
 
         Use gnustep-config if available
         * emacs.c [NS_IMPL_GNUSTEP]: Don't include <GNUstepBase/GSConfig.h>.
@@ -1324,7 +1339,7 @@
 
         Don't downcase system diagnostics' first letters
         * fileio.c (report_file_errno): Don't downcase, and simplify.
-        Fixes: bug#19642
+        (Bug#19642)
 
         Isolate NIL_IS_ZERO-assuming code better
         Suggested by Stefan Monnier in:
@@ -1369,7 +1384,7 @@
 
         Correct an old fix for GTK font selection
         * gtkutil.c (xg_get_font): Fix off-by-2 typo.
-        Fixes: bug#3228
+        (Bug#3228)
 
         Fix minor bugs with printing null bytes
         * minibuf.c (read_minibuf_noninteractive):
@@ -2358,7 +2373,7 @@
         * fileio.c (Finsert_file_contents): Compute same_at_end character
         position using the old buffer size, not the new one, since
         restore_window_points wants the old size.
-        Fixes: debbugs:19161
+        (Bug#19161)
 
 2014-12-14  Alan Mackenzie  <acm@muc.de>
 
diff --git a/src/callproc.c b/src/callproc.c
index e1fe8ed95df..12c81439fe4 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -1595,12 +1595,12 @@ init_callproc (void)
 #ifdef HAVE_NS
           const char *path_exec = ns_exec_path ();
 #endif
+          /* Running uninstalled, so default to tem rather than PATH_EXEC.  */
           Vexec_path = decode_env_path ("EMACSPATH",
 #ifdef HAVE_NS
                                         path_exec ? path_exec :
 #endif
-                                        PATH_EXEC, 0);
-          Vexec_path = Fcons (tem, Vexec_path);
+                                        SSDATA (tem), 0);
           Vexec_path = nconc2 (decode_env_path ("PATH", "", 0), Vexec_path);
         }
 
diff --git a/src/ccl.c b/src/ccl.c
index 053544c8274..88307a30aa6 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -1713,7 +1713,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
         case CCL_STAT_INVALID_CMD:
           msglen = sprintf (msg,
                             "\nCCL: Invalid command %x (ccl_code = %x) at %d.",
-                            code & 0x1F, code, this_ic);
+                            code & 0x1Fu, code + 0u, this_ic);
 #ifdef CCL_DEBUG
           {
             int i = ccl_backtrace_idx - 1;
diff --git a/src/character.c b/src/character.c
index ad78f512f43..f51d97125e0 100644
--- a/src/character.c
+++ b/src/character.c
@@ -841,7 +841,7 @@ string_escape_byte8 (Lisp_Object string)
           {
             c = STRING_CHAR_ADVANCE (src);
             c = CHAR_TO_BYTE8 (c);
-            dst += sprintf ((char *) dst, "\\%03o", c);
+            dst += sprintf ((char *) dst, "\\%03o", c + 0u);
           }
         else
           while (len--) *dst++ = *src++;
@@ -851,7 +851,7 @@ string_escape_byte8 (Lisp_Object string)
       {
         c = *src++;
         if (c >= 0x80)
-          dst += sprintf ((char *) dst, "\\%03o", c);
+          dst += sprintf ((char *) dst, "\\%03o", c + 0u);
         else
           *dst++ = c;
       }
@@ -984,8 +984,7 @@ character is not ASCII nor 8-bit character, an error is signaled.  */)
 
 #ifdef emacs
 
-/* Return 'true' if C is an alphabetic character as defined by its
-   Unicode properties.  */
+/* Return true if C is an alphabetic character.  */
 bool
 alphabeticp (int c)
 {
@@ -1008,8 +1007,7 @@ alphabeticp (int c)
           || gen_cat == UNICODE_CATEGORY_Nl);
 }
 
-/* Return 'true' if C is an decimal-number character as defined by its
-   Unicode properties.  */
+/* Return true if C is a decimal-number character.  */
 bool
 decimalnump (int c)
 {
@@ -1022,6 +1020,39 @@ decimalnump (int c)
   return gen_cat == UNICODE_CATEGORY_Nd;
 }
 
+/* Return true if C is a graphic character.  */
+bool
+graphicp (int c)
+{
+  Lisp_Object category = CHAR_TABLE_REF (Vunicode_category_table, c);
+  if (! INTEGERP (category))
+    return false;
+  EMACS_INT gen_cat = XINT (category);
+
+  /* See UTS #18.  */
+  return (!(gen_cat == UNICODE_CATEGORY_Zs /* space separator */
+            || gen_cat == UNICODE_CATEGORY_Zl /* line separator */
+            || gen_cat == UNICODE_CATEGORY_Zp /* paragraph separator */
+            || gen_cat == UNICODE_CATEGORY_Cc /* control */
+            || gen_cat == UNICODE_CATEGORY_Cs /* surrogate */
+            || gen_cat == UNICODE_CATEGORY_Cn)); /* unassigned */
+}
+
+/* Return true if C is a printable character.  */
+bool
+printablep (int c)
+{
+  Lisp_Object category = CHAR_TABLE_REF (Vunicode_category_table, c);
+  if (! INTEGERP (category))
+    return false;
+  EMACS_INT gen_cat = XINT (category);
+
+  /* See UTS #18.  */
+  return (!(gen_cat == UNICODE_CATEGORY_Cc /* control */
+            || gen_cat == UNICODE_CATEGORY_Cs /* surrogate */
+            || gen_cat == UNICODE_CATEGORY_Cn)); /* unassigned */
+}
+
 void
 syms_of_character (void)
 {
diff --git a/src/character.h b/src/character.h
index 7d902952db6..859d717a0ba 100644
--- a/src/character.h
+++ b/src/character.h
@@ -662,6 +662,8 @@ extern Lisp_Object string_escape_byte8 (Lisp_Object);
 
 extern bool alphabeticp (int);
 extern bool decimalnump (int);
+extern bool graphicp (int);
+extern bool printablep (int);
 
 /* Return a translation table of id number ID.  */
 #define GET_TRANSLATION_TABLE(id) \
diff --git a/src/cmds.c b/src/cmds.c
index 270fc39cabc..168ce8355ed 100644
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -213,6 +213,36 @@ to t.  */)
   return Qnil;
 }
 
+static int nonundocount;
+
+static void
+remove_excessive_undo_boundaries (void)
+{
+  bool remove_boundary = true;
+
+  if (!EQ (Vthis_command, KVAR (current_kboard, Vlast_command)))
+    nonundocount = 0;
+
+  if (NILP (Vexecuting_kbd_macro))
+    {
+      if (nonundocount <= 0 || nonundocount >= 20)
+        {
+          remove_boundary = false;
+          nonundocount = 0;
+        }
+      nonundocount++;
+    }
+
+  if (remove_boundary
+      && CONSP (BVAR (current_buffer, undo_list))
+      && NILP (XCAR (BVAR (current_buffer, undo_list)))
+      /* Only remove auto-added boundaries, not boundaries
+         added by explicit calls to undo-boundary.  */
+      && EQ (BVAR (current_buffer, undo_list), last_undo_boundary))
+    /* Remove the undo_boundary that was just pushed.  */
+    bset_undo_list (current_buffer, XCDR (BVAR (current_buffer, undo_list)));
+}
+
 DEFUN ("delete-char", Fdelete_char, Sdelete_char, 1, 2, "p\nP",
        doc: /* Delete the following N characters (previous if N is negative).
 Optional second arg KILLFLAG non-nil means kill instead (save in kill ring).
@@ -227,6 +257,9 @@ because it respects values of `delete-active-region' and `overwrite-mode'.  */)
 
   CHECK_NUMBER (n);
 
+  if (abs (XINT (n)) < 2)
+    remove_excessive_undo_boundaries ();
+
   pos = PT + XINT (n);
   if (NILP (killflag))
     {
@@ -252,8 +285,6 @@ because it respects values of `delete-active-region' and `overwrite-mode'.  */)
   return Qnil;
 }
 
-static int nonundocount;
-
 /* Note that there's code in command_loop_1 which typically avoids
    calling this.  */
 DEFUN ("self-insert-command", Fself_insert_command, Sself_insert_command, 1, 1, "p",
@@ -267,34 +298,13 @@ After insertion, the value of `auto-fill-function' is called if the
 At the end, it runs `post-self-insert-hook'.  */)
   (Lisp_Object n)
 {
-  bool remove_boundary = 1;
   CHECK_NUMBER (n);
 
   if (XFASTINT (n) < 0)
     error ("Negative repetition argument %"pI"d", XFASTINT (n));
 
-  if (!EQ (Vthis_command, KVAR (current_kboard, Vlast_command)))
-    nonundocount = 0;
-
-  if (NILP (Vexecuting_kbd_macro)
-      && !EQ (minibuf_window, selected_window))
-    {
-      if (nonundocount <= 0 || nonundocount >= 20)
-        {
-          remove_boundary = 0;
-          nonundocount = 0;
-        }
-      nonundocount++;
-    }
-
-  if (remove_boundary
-      && CONSP (BVAR (current_buffer, undo_list))
-      && NILP (XCAR (BVAR (current_buffer, undo_list)))
-      /* Only remove auto-added boundaries, not boundaries
-         added be explicit calls to undo-boundary.  */
-      && EQ (BVAR (current_buffer, undo_list), last_undo_boundary))
-    /* Remove the undo_boundary that was just pushed.  */
-    bset_undo_list (current_buffer, XCDR (BVAR (current_buffer, undo_list)));
+  if (XFASTINT (n) < 2)
+    remove_excessive_undo_boundaries ();
 
   /* Barf if the key that invoked this was not a character.  */
   if (!CHARACTERP (last_command_event))
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 54e92cce16e..fa26f9e4168 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -874,7 +874,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
         uprintmax_t pval;
         dbus_message_iter_get_basic (iter, &val);
         pval = val;
-        XD_DEBUG_MESSAGE ("%c %"pMd, dtype, pval);
+        XD_DEBUG_MESSAGE ("%c %"pMu, dtype, pval);
         return make_fixnum_or_float (val);
       }
 
@@ -990,7 +990,7 @@ xd_add_watch (DBusWatch *watch, void *data)
   unsigned int flags = dbus_watch_get_flags (watch);
   int fd = xd_find_watch_fd (watch);
 
-  XD_DEBUG_MESSAGE ("fd %d, write %d, enabled %d",
+  XD_DEBUG_MESSAGE ("fd %d, write %u, enabled %u",
                     fd, flags & DBUS_WATCH_WRITABLE,
                     dbus_watch_get_enabled (watch));
 
diff --git a/src/editfns.c b/src/editfns.c
index 7d3e4620029..dead48c1a62 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -2728,7 +2728,15 @@ DEFUN ("insert-buffer-substring", Finsert_buffer_substring, Sinsert_buffer_subst
        doc: /* Insert before point a substring of the contents of BUFFER.
 BUFFER may be a buffer or a buffer name.
 Arguments START and END are character positions specifying the substring.
-They default to the values of (point-min) and (point-max) in BUFFER.  */)
+They default to the values of (point-min) and (point-max) in BUFFER.
+
+Point and before-insertion markers move forward to end up after the
+inserted text.
+Any other markers at the point of insertion remain before the text.
+
+If the current buffer is multibyte and BUFFER is unibyte, or vice
+versa, strings are converted from unibyte to multibyte or vice versa
+using `string-make-multibyte' or `string-make-unibyte', which see.  */)
   (Lisp_Object buffer, Lisp_Object start, Lisp_Object end)
 {
   register EMACS_INT b, e, temp;
diff --git a/src/eval.c b/src/eval.c
index e828da9288f..490226149ff 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -210,7 +210,7 @@ init_eval_once (void)
   specpdl = specpdl_ptr = pdlvec + 1;
   /* Don't forget to update docs (lispref node "Local Variables").  */
   max_specpdl_size = 1300; /* 1000 is not enough for CEDET's c-by.el.  */
-  max_lisp_eval_depth = 600;
+  max_lisp_eval_depth = 800;
 
   Vrun_hooks = Qnil;
 }
@@ -3305,27 +3305,27 @@ Output stream used is value of `standard-output'.  */)
 
   while (backtrace_p (pdl))
     {
-      write_string (backtrace_debug_on_exit (pdl) ? "* " : "  ", 2);
+      write_string (backtrace_debug_on_exit (pdl) ? "* " : "  ");
       if (backtrace_nargs (pdl) == UNEVALLED)
         {
           Fprin1 (Fcons (backtrace_function (pdl), *backtrace_args (pdl)),
                   Qnil);
-          write_string ("\n", -1);
+          write_string ("\n");
         }
       else
         {
           tem = backtrace_function (pdl);
           Fprin1 (tem, Qnil);   /* This can QUIT.  */
-          write_string ("(", -1);
+          write_string ("(");
           {
             ptrdiff_t i;
             for (i = 0; i < backtrace_nargs (pdl); i++)
               {
-                if (i) write_string (" ", -1);
+                if (i) write_string (" ");
                 Fprin1 (backtrace_args (pdl)[i], Qnil);
               }
           }
-          write_string (")\n", -1);
+          write_string (")\n");
         }
       pdl = backtrace_next (pdl);
     }
diff --git a/src/fileio.c b/src/fileio.c
index d4e12cbe277..796f08d3c58 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -2344,62 +2344,62 @@ This is what happens in interactive use with M-x.  */)
 
 DEFUN ("make-symbolic-link", Fmake_symbolic_link, Smake_symbolic_link, 2, 3,
        "FMake symbolic link to file: \nGMake symbolic link to file %s: \np",
-       doc: /* Make a symbolic link to FILENAME, named LINKNAME.
+       doc: /* Make a symbolic link to TARGET, named LINKNAME.
 Both args must be strings.
 Signals a `file-already-exists' error if a file LINKNAME already exists
 unless optional third argument OK-IF-ALREADY-EXISTS is non-nil.
 A number as third arg means request confirmation if LINKNAME already exists.
 This happens for interactive use with M-x.  */)
-  (Lisp_Object filename, Lisp_Object linkname, Lisp_Object ok_if_already_exists)
+  (Lisp_Object target, Lisp_Object linkname, Lisp_Object ok_if_already_exists)
 {
   Lisp_Object handler;
-  Lisp_Object encoded_filename, encoded_linkname;
+  Lisp_Object encoded_target, encoded_linkname;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
 
-  GCPRO4 (filename, linkname, encoded_filename, encoded_linkname);
-  encoded_filename = encoded_linkname = Qnil;
-  CHECK_STRING (filename);
+  GCPRO4 (target, linkname, encoded_target, encoded_linkname);
+  encoded_target = encoded_linkname = Qnil;
+  CHECK_STRING (target);
   CHECK_STRING (linkname);
   /* If the link target has a ~, we must expand it to get
      a truly valid file name.  Otherwise, do not expand;
      we want to permit links to relative file names.  */
-  if (SREF (filename, 0) == '~')
-    filename = Fexpand_file_name (filename, Qnil);
+  if (SREF (target, 0) == '~')
+    target = Fexpand_file_name (target, Qnil);
 
   if (!NILP (Ffile_directory_p (linkname)))
-    linkname = Fexpand_file_name (Ffile_name_nondirectory (filename), linkname);
+    linkname = Fexpand_file_name (Ffile_name_nondirectory (target), linkname);
   else
     linkname = Fexpand_file_name (linkname, Qnil);
 
   /* If the file name has special constructs in it,
      call the corresponding file handler.  */
-  handler = Ffind_file_name_handler (filename, Qmake_symbolic_link);
+  handler = Ffind_file_name_handler (target, Qmake_symbolic_link);
   if (!NILP (handler))
-    RETURN_UNGCPRO (call4 (handler, Qmake_symbolic_link, filename,
+    RETURN_UNGCPRO (call4 (handler, Qmake_symbolic_link, target,
                            linkname, ok_if_already_exists));
 
   /* If the new link name has special constructs in it,
      call the corresponding file handler.  */
   handler = Ffind_file_name_handler (linkname, Qmake_symbolic_link);
   if (!NILP (handler))
-    RETURN_UNGCPRO (call4 (handler, Qmake_symbolic_link, filename,
+    RETURN_UNGCPRO (call4 (handler, Qmake_symbolic_link, target,
                            linkname, ok_if_already_exists));
 
-  encoded_filename = ENCODE_FILE (filename);
+  encoded_target = ENCODE_FILE (target);
   encoded_linkname = ENCODE_FILE (linkname);
 
   if (NILP (ok_if_already_exists)
       || INTEGERP (ok_if_already_exists))
     barf_or_query_if_file_exists (linkname, false, "make it a link",
                                   INTEGERP (ok_if_already_exists), false);
-  if (symlink (SSDATA (encoded_filename), SSDATA (encoded_linkname)) < 0)
+  if (symlink (SSDATA (encoded_target), SSDATA (encoded_linkname)) < 0)
     {
       /* If we didn't complain already, silently delete existing file.  */
       int symlink_errno;
       if (errno == EEXIST)
         {
           unlink (SSDATA (encoded_linkname));
-          if (symlink (SSDATA (encoded_filename), SSDATA (encoded_linkname))
+          if (symlink (SSDATA (encoded_target), SSDATA (encoded_linkname))
               >= 0)
             {
               UNGCPRO;
@@ -2414,7 +2414,7 @@ This happens for interactive use with M-x.  */)
         }
 
       symlink_errno = errno;
-      report_file_errno ("Making symbolic link", list2 (filename, linkname),
+      report_file_errno ("Making symbolic link", list2 (target, linkname),
                          symlink_errno);
     }
   UNGCPRO;
@@ -4165,7 +4165,7 @@ by calling `format-decode', which see.  */)
       Vdeactivate_mark = old_Vdeactivate_mark;
     }
   else
-    Vdeactivate_mark = Qt;
+    Fset (Qdeactivate_mark, Qt);
 
   emacs_close (fd);
   clear_unwind_protect (fd_index);
diff --git a/src/gnutls.c b/src/gnutls.c
index 35f0eb48bc1..9b8ae2bd1a8 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -1512,7 +1512,7 @@ one trustfile (usually a CA bundle).  */)
           || !NILP (Fmember (QCgnutls_bootprop_trustfiles, verify_error)))
         {
           emacs_gnutls_deinit (proc);
-          error ("Certificate validation failed %s, verification code %d",
+          error ("Certificate validation failed %s, verification code %u",
                  c_hostname, peer_verification);
         }
       else
@@ -1645,6 +1645,16 @@ DEFUN ("gnutls-available-p", Fgnutls_available_p, Sgnutls_available_p, 0, 0, 0,
 void
 syms_of_gnutls (void)
 {
+  DEFSYM (Qlibgnutls_version, "libgnutls-version");
+  Fset (Qlibgnutls_version,
+#ifdef HAVE_GNUTLS
+        make_number (GNUTLS_VERSION_MAJOR * 10000
+                     + GNUTLS_VERSION_MINOR * 100
+                     + GNUTLS_VERSION_PATCH)
+#else
+        make_number (-1)
+#endif
+        );
 #ifdef HAVE_GNUTLS
   gnutls_global_initialized = 0;
 
diff --git a/src/gtkutil.c b/src/gtkutil.c
index c41bb4645a5..d7340ba797e 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -579,9 +579,9 @@ xg_check_special_colors (struct frame *f,
       gtk_style_context_get_background_color (gsty, state, &col);
 
     sprintf (buf, "rgb:%04x/%04x/%04x",
-             (int)(col.red * 65535),
-             (int)(col.green * 65535),
-             (int)(col.blue * 65535));
+             (unsigned) (col.red * 65535),
+             (unsigned) (col.green * 65535),
+             (unsigned) (col.blue * 65535));
     success_p = (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
                               buf, color)
                  != 0);
diff --git a/src/image.c b/src/image.c
index 78de0ba884e..ffbed747590 100644
--- a/src/image.c
+++ b/src/image.c
@@ -5063,7 +5063,8 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
       if (i == 3 && NILP (how))
         {
           char color_name[30];
-          sprintf (color_name, "#%04x%04x%04x", rgb[0], rgb[1], rgb[2]);
+          sprintf (color_name, "#%04x%04x%04x",
+                   rgb[0] + 0u, rgb[1] + 0u, rgb[2] + 0u);
           bg = (
 #ifdef HAVE_NTGUI
                 0x00ffffff & /* Filter out palette info.  */
@@ -5896,6 +5897,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
   /* Find out what file to load.  */
   specified_file = image_spec_value (img->spec, QCfile, NULL);
   specified_data = image_spec_value (img->spec, QCdata, NULL);
+  IF_LINT (Lisp_Object volatile specified_data_volatile = specified_data);
 
   if (NILP (specified_data))
     {
@@ -5992,6 +5994,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
 
   /* Silence a bogus diagnostic; see GCC bug 54561.  */
   IF_LINT (fp = c->fp);
+  IF_LINT (specified_data = specified_data_volatile);
 
   /* Read image info.  */
   if (!NILP (specified_data))
@@ -6658,6 +6661,7 @@ jpeg_load_body (struct frame *f, struct image *img,
   /* Open the JPEG file.  */
   specified_file = image_spec_value (img->spec, QCfile, NULL);
   specified_data = image_spec_value (img->spec, QCdata, NULL);
+  IF_LINT (Lisp_Object volatile specified_data_volatile = specified_data);
 
   if (NILP (specified_data))
     {
@@ -6720,6 +6724,9 @@ jpeg_load_body (struct frame *f, struct image *img,
       return 0;
     }
 
+  /* Silence a bogus diagnostic; see GCC bug 54561.  */
+  IF_LINT (specified_data = specified_data_volatile);
+
   /* Create the JPEG decompression object.  Let it read from fp.
          Read the JPEG image header.  */
   jpeg_CreateDecompress (&mgr->cinfo, JPEG_LIB_VERSION, sizeof *&mgr->cinfo);
diff --git a/src/insdel.c b/src/insdel.c
index 80650be25ae..22c2bcccb82 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -1846,7 +1846,7 @@ prepare_to_modify_buffer_1 (ptrdiff_t start, ptrdiff_t end,
       = call1 (Fsymbol_value (Qregion_extract_function), Qnil);
 
   signal_before_change (start, end, preserve_ptr);
-  Vdeactivate_mark = Qt;
+  Fset (Qdeactivate_mark, Qt);
 }
 
 /* Like above, but called when we know that the buffer text
diff --git a/src/keyboard.c b/src/keyboard.c
index 2d047da5511..bd79f901970 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -2192,7 +2192,7 @@ read_event_from_main_queue (struct timespec *end_time,
   save_getcjmp (save_jump);
   restore_getcjmp (local_getcjmp);
   if (!end_time)
-        timer_start_idle ();
+    timer_start_idle ();
   c = kbd_buffer_get_event (&kb, used_mouse_menu, end_time);
   restore_getcjmp (save_jump);
 
@@ -11492,6 +11492,7 @@ for that character after that prefix key.  */);
                doc: /* Form to evaluate when Emacs starts up.
 Useful to set before you dump a modified Emacs.  */);
   Vtop_level = Qnil;
+  XSYMBOL (Qtop_level)->declared_special = false;
 
   DEFVAR_KBOARD ("keyboard-translate-table", Vkeyboard_translate_table,
                  doc: /* Translate table for local keyboard input, or nil.
diff --git a/src/lisp.h b/src/lisp.h
index b730619726b..55c4c662c06 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3923,7 +3923,7 @@ extern Lisp_Object Vprin1_to_string_buffer;
 extern void debug_print (Lisp_Object) EXTERNALLY_VISIBLE;
 extern void temp_output_buffer_setup (const char *);
 extern int print_level;
-extern void write_string (const char *, int);
+extern void write_string (const char *);
 extern void print_error_message (Lisp_Object, Lisp_Object, const char *,
                                  Lisp_Object);
 extern Lisp_Object internal_with_output_to_temp_buffer
diff --git a/src/lread.c b/src/lread.c
index 050e43e2d08..a84450a4364 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -3024,7 +3024,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
 
                 ch = read_escape (readcharfun, 1);
 
-                /* CH is -1 if \ newline has just been seen.  */
+                /* CH is -1 if \ newline or \ space has just been seen.  */
                 if (ch == -1)
                   {
                     if (p == read_buffer)
@@ -3778,8 +3778,11 @@ intern_1 (const char *str, ptrdiff_t len)
   Lisp_Object obarray = check_obarray (Vobarray);
   Lisp_Object tem = oblookup (obarray, str, len, len);
 
-  return SYMBOLP (tem) ? tem : intern_driver (make_string (str, len),
-                                              obarray, tem);
+  return (SYMBOLP (tem) ? tem
+          /* The above `oblookup' was done on the basis of nchars==nbytes, so
+             the string has to be unibyte.  */
+          : intern_driver (make_unibyte_string (str, len),
+                           obarray, tem));
 }
 
 Lisp_Object
diff --git a/src/print.c b/src/print.c
index 838d03666d4..206466ce68f 100644
--- a/src/print.c
+++ b/src/print.c
@@ -37,6 +37,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "termhooks.h"          /* For struct terminal.  */
 #include "font.h"
 
+#include <c-ctype.h>
 #include <float.h>
 #include <ftoastr.h>
 
@@ -83,12 +84,11 @@ bool print_output_debug_flag EXTERNALLY_VISIBLE = 1;
 
 /* Lisp functions to do output using a stream
    must have the stream in a variable called printcharfun
-   and must start with PRINTPREPARE, end with PRINTFINISH,
-   and use PRINTDECLARE to declare common variables.
-   Use PRINTCHAR to output one character,
+   and must start with PRINTPREPARE, end with PRINTFINISH.
+   Use printchar to output one character,
    or call strout to output a block of characters.  */
 
-#define PRINTDECLARE                                                    \
+#define PRINTPREPARE                                                    \
    struct buffer *old = current_buffer;                                 \
    ptrdiff_t old_point = -1, start_point = -1;                          \
    ptrdiff_t old_point_byte = -1, start_point_byte = -1;                \
@@ -96,10 +96,7 @@ bool print_output_debug_flag EXTERNALLY_VISIBLE = 1;
    bool free_print_buffer = 0;                                          \
    bool multibyte                                                       \
      = !NILP (BVAR (current_buffer, enable_multibyte_characters));      \
-   Lisp_Object original
-
-#define PRINTPREPARE                                                    \
-   original = printcharfun;                                             \
+   Lisp_Object original = printcharfun;                                 \
    if (NILP (printcharfun)) printcharfun = Qt;                          \
    if (BUFFERP (printcharfun))                                          \
      {                                                                  \
@@ -189,8 +186,6 @@ bool print_output_debug_flag EXTERNALLY_VISIBLE = 1;
                                     ? PT_BYTE - start_point_byte : 0)); \
    set_buffer_internal (old);
 
-#define PRINTCHAR(ch) printchar (ch, printcharfun)
-
 /* This is used to restore the saved contents of print_buffer
    when there is a recursive call to print.  */
 
@@ -248,8 +243,7 @@ printchar (unsigned int ch, Lisp_Object fun)
 
 
 /* Output SIZE characters, SIZE_BYTE bytes from string PTR using
-   method PRINTCHARFUN.  If SIZE < 0, use the string length of PTR for
-   both SIZE and SIZE_BYTE.  PRINTCHARFUN nil means output to
+   method PRINTCHARFUN.  PRINTCHARFUN nil means output to
    print_buffer.  PRINTCHARFUN t means output to the echo area or to
    stdout if non-interactive.  If neither nil nor t, call Lisp
    function PRINTCHARFUN for each character printed.  MULTIBYTE
@@ -262,9 +256,6 @@ static void
 strout (const char *ptr, ptrdiff_t size, ptrdiff_t size_byte,
         Lisp_Object printcharfun)
 {
-  if (size < 0)
-    size_byte = size = strlen (ptr);
-
   if (NILP (printcharfun))
     {
       ptrdiff_t incr = size_byte - (print_buffer_size - print_buffer_pos_byte);
@@ -317,7 +308,7 @@ strout (const char *ptr, ptrdiff_t size, ptrdiff_t size_byte,
           while (i < size_byte)
             {
               int ch = ptr[i++];
-              PRINTCHAR (ch);
+              printchar (ch, printcharfun);
             }
         }
       else
@@ -330,7 +321,7 @@ strout (const char *ptr, ptrdiff_t size, ptrdiff_t size_byte,
               int len;
               int ch = STRING_CHAR_AND_LENGTH ((const unsigned char *) ptr + i,
                                                len);
-              PRINTCHAR (ch);
+              printchar (ch, printcharfun);
               i += len;
             }
         }
@@ -407,7 +398,7 @@ print_string (Lisp_Object string, Lisp_Object printcharfun)
       GCPRO1 (string);
       if (size == size_byte)
         for (i = 0; i < size; i++)
-          PRINTCHAR (SREF (string, i));
+          printchar (SREF (string, i), printcharfun);
       else
         for (i = 0; i < size_byte; )
           {
@@ -415,7 +406,7 @@ print_string (Lisp_Object string, Lisp_Object printcharfun)
                corresponding character code before handing it to PRINTCHAR.  */
             int len;
             int ch = STRING_CHAR_AND_LENGTH (SDATA (string) + i, len);
-            PRINTCHAR (ch);
+            printchar (ch, printcharfun);
             i += len;
           }
       UNGCPRO;
@@ -427,46 +418,45 @@ DEFUN ("write-char", Fwrite_char, Swrite_char, 1, 2, 0,
 PRINTCHARFUN defaults to the value of `standard-output' (which see).  */)
   (Lisp_Object character, Lisp_Object printcharfun)
 {
-  PRINTDECLARE;
-
   if (NILP (printcharfun))
     printcharfun = Vstandard_output;
   CHECK_NUMBER (character);
   PRINTPREPARE;
-  PRINTCHAR (XINT (character));
+  printchar (XINT (character), printcharfun);
   PRINTFINISH;
   return character;
 }
 
-/* Used from outside of print.c to print a block of SIZE
-   single-byte chars at DATA on the default output stream.
+/* Print the contents of a unibyte C string STRING using PRINTCHARFUN.
+   The caller should arrange to put this inside PRINTPREPARE and PRINTFINISH.
    Do not use this on the contents of a Lisp string.  */
 
-void
-write_string (const char *data, int size)
+static void
+print_c_string (char const *string, Lisp_Object printcharfun)
 {
-  PRINTDECLARE;
-  Lisp_Object printcharfun;
+  ptrdiff_t len = strlen (string);
+  strout (string, len, len, printcharfun);
+}
 
-  printcharfun = Vstandard_output;
+/* Print unibyte C string at DATA on a specified stream PRINTCHARFUN.
+   Do not use this on the contents of a Lisp string.  */
 
+static void
+write_string_1 (const char *data, Lisp_Object printcharfun)
+{
   PRINTPREPARE;
-  strout (data, size, size, printcharfun);
+  print_c_string (data, printcharfun);
   PRINTFINISH;
 }
 
-/* Used to print a block of SIZE single-byte chars at DATA on a
-   specified stream PRINTCHARFUN.
+/* Used from outside of print.c to print a C unibyte
+   string at DATA on the default output stream.
    Do not use this on the contents of a Lisp string.  */
 
-static void
-write_string_1 (const char *data, int size, Lisp_Object printcharfun)
+void
+write_string (const char *data)
 {
-  PRINTDECLARE;
-
-  PRINTPREPARE;
-  strout (data, size, size, printcharfun);
-  PRINTFINISH;
+  write_string_1 (data, Vstandard_output);
 }
 
 
@@ -515,9 +505,8 @@ beginning of a line.  Value is non-nil if a newline is printed.
 If PRINTCHARFUN is omitted or nil, the value of `standard-output' is used.  */)
   (Lisp_Object printcharfun, Lisp_Object ensure)
 {
-  Lisp_Object val = Qnil;
+  Lisp_Object val;
 
-  PRINTDECLARE;
   if (NILP (printcharfun))
     printcharfun = Vstandard_output;
   PRINTPREPARE;
@@ -529,10 +518,11 @@ If PRINTCHARFUN is omitted or nil, the value of `standard-output' is used.  */)
     signal_error ("Unsupported function argument", printcharfun);
   else if (noninteractive && !NILP (printcharfun))
     val = printchar_stdout_last == 10 ? Qnil : Qt;
-  else if (NILP (Fbolp ()))
-    val = Qt;
+  else
+    val = NILP (Fbolp ()) ? Qt : Qnil;
 
-  if (!NILP (val)) PRINTCHAR ('\n');
+  if (!NILP (val))
+    printchar ('\n', printcharfun);
   PRINTFINISH;
   return val;
 }
@@ -562,8 +552,6 @@ If PRINTCHARFUN is omitted, the value of `standard-output' (which see)
 is used instead.  */)
   (Lisp_Object object, Lisp_Object printcharfun)
 {
-  PRINTDECLARE;
-
   if (NILP (printcharfun))
     printcharfun = Vstandard_output;
   PRINTPREPARE;
@@ -588,32 +576,24 @@ a list, a buffer, a window, a frame, etc.
 A printed representation of an object is text which describes that object.  */)
   (Lisp_Object object, Lisp_Object noescape)
 {
-  Lisp_Object printcharfun;
-  bool prev_abort_on_gc;
-  Lisp_Object save_deactivate_mark;
   ptrdiff_t count = SPECPDL_INDEX ();
-  struct buffer *previous;
 
   specbind (Qinhibit_modification_hooks, Qt);
 
-  {
-    PRINTDECLARE;
-
-    /* Save and restore this--we are altering a buffer
-       but we don't want to deactivate the mark just for that.
-       No need for specbind, since errors deactivate the mark.  */
-    save_deactivate_mark = Vdeactivate_mark;
-    prev_abort_on_gc = abort_on_gc;
-    abort_on_gc = 1;
-
-    printcharfun = Vprin1_to_string_buffer;
-    PRINTPREPARE;
-    print (object, printcharfun, NILP (noescape));
-    /* Make Vprin1_to_string_buffer be the default buffer after PRINTFINISH */
-    PRINTFINISH;
-  }
+  /* Save and restore this: we are altering a buffer
+     but we don't want to deactivate the mark just for that.
+     No need for specbind, since errors deactivate the mark.  */
+  Lisp_Object save_deactivate_mark = Vdeactivate_mark;
+  bool prev_abort_on_gc = abort_on_gc;
+  abort_on_gc = true;
 
-  previous = current_buffer;
+  Lisp_Object printcharfun = Vprin1_to_string_buffer;
+  PRINTPREPARE;
+  print (object, printcharfun, NILP (noescape));
+  /* Make Vprin1_to_string_buffer be the default buffer after PRINTFINISH */
+  PRINTFINISH;
+
+  struct buffer *previous = current_buffer;
   set_buffer_internal (XBUFFER (Vprin1_to_string_buffer));
   object = Fbuffer_string ();
   if (SBYTES (object) == SCHARS (object))
@@ -655,8 +635,6 @@ If PRINTCHARFUN is omitted, the value of `standard-output' (which see)
 is used instead.  */)
   (Lisp_Object object, Lisp_Object printcharfun)
 {
-  PRINTDECLARE;
-
   if (NILP (printcharfun))
     printcharfun = Vstandard_output;
   PRINTPREPARE;
@@ -690,16 +668,15 @@ If PRINTCHARFUN is omitted, the value of `standard-output' (which see)
 is used instead.  */)
   (Lisp_Object object, Lisp_Object printcharfun)
 {
-  PRINTDECLARE;
   struct gcpro gcpro1;
 
   if (NILP (printcharfun))
     printcharfun = Vstandard_output;
   GCPRO1 (object);
   PRINTPREPARE;
-  PRINTCHAR ('\n');
+  printchar ('\n', printcharfun);
   print (object, printcharfun, 1);
-  PRINTCHAR ('\n');
+  printchar ('\n', printcharfun);
   PRINTFINISH;
   UNGCPRO;
   return object;
@@ -817,9 +794,12 @@ safe_debug_print (Lisp_Object arg)
   if (valid > 0)
     debug_print (arg);
   else
-    fprintf (stderr, "#<%s_LISP_OBJECT 0x%08"pI"x>\r\n",
-             !valid ? "INVALID" : "SOME",
-             XLI (arg));
+    {
+      EMACS_UINT n = XLI (arg);
+      fprintf (stderr, "#<%s_LISP_OBJECT 0x%08"pI"x>\r\n",
+               !valid ? "INVALID" : "SOME",
+               n);
+    }
 }
 
 
@@ -869,7 +849,7 @@ print_error_message (Lisp_Object data, Lisp_Object stream, const char *context,
   struct gcpro gcpro1;
 
   if (context != 0)
-    write_string_1 (context, -1, stream);
+    write_string_1 (context, stream);
 
   /* If we know from where the error was signaled, show it in
    *Messages*.  */
@@ -916,7 +896,7 @@ print_error_message (Lisp_Object data, Lisp_Object stream, const char *context,
     const char *sep = ": ";
 
     if (!STRINGP (errmsg))
-      write_string_1 ("peculiar error", -1, stream);
+      write_string_1 ("peculiar error", stream);
     else if (SCHARS (errmsg))
       Fprinc (errmsg, stream);
     else
@@ -927,7 +907,7 @@ print_error_message (Lisp_Object data, Lisp_Object stream, const char *context,
         Lisp_Object obj;
 
         if (sep)
-          write_string_1 (sep, 2, stream);
+          write_string_1 (sep, stream);
         obj = XCAR (tail);
         if (!NILP (file_error)
             || EQ (errname, Qend_of_file) || EQ (errname, Quser_error))
@@ -1409,9 +1389,9 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
           register ptrdiff_t i, i_byte;
           struct gcpro gcpro1;
           ptrdiff_t size_byte;
-          /* 1 means we must ensure that the next character we output
+          /* True means we must ensure that the next character we output
              cannot be taken as part of a hex character escape.  */
-          bool need_nonhex = 0;
+          bool need_nonhex = false;
           bool multibyte = STRING_MULTIBYTE (obj);
 
           GCPRO1 (obj);
@@ -1420,93 +1400,70 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
             obj = print_prune_string_charset (obj);
 
           if (string_intervals (obj))
-            {
-              PRINTCHAR ('#');
-              PRINTCHAR ('(');
-            }
+            print_c_string ("#(", printcharfun);
 
-          PRINTCHAR ('\"');
+          printchar ('\"', printcharfun);
           size_byte = SBYTES (obj);
 
           for (i = 0, i_byte = 0; i_byte < size_byte;)
             {
               /* Here, we must convert each multi-byte form to the
-                 corresponding character code before handing it to PRINTCHAR.  */
+                 corresponding character code before handing it to printchar.  */
               int c;
 
               FETCH_STRING_CHAR_ADVANCE (c, obj, i, i_byte);
 
               QUIT;
 
-              if (c == '\n' && print_escape_newlines)
-                {
-                  PRINTCHAR ('\\');
-                  PRINTCHAR ('n');
-                }
-              else if (c == '\f' && print_escape_newlines)
+              if (multibyte
+                  ? (CHAR_BYTE8_P (c) && (c = CHAR_TO_BYTE8 (c), true))
+                  : (SINGLE_BYTE_CHAR_P (c) && ! ASCII_CHAR_P (c)
+                     && print_escape_nonascii))
                 {
-                  PRINTCHAR ('\\');
-                  PRINTCHAR ('f');
-                }
-              else if (multibyte
-                       && (CHAR_BYTE8_P (c)
-                           || (! ASCII_CHAR_P (c) && print_escape_multibyte)))
-                {
-                  /* When multibyte is disabled,
-                     print multibyte string chars using hex escapes.
-                     For a char code that could be in a unibyte string,
-                     when found in a multibyte string, always use a hex escape
-                     so it reads back as multibyte.  */
-                  char outbuf[50];
-                  int len;
-
-                  if (CHAR_BYTE8_P (c))
-                    len = sprintf (outbuf, "\\%03o", CHAR_TO_BYTE8 (c));
-                  else
-                    {
-                      len = sprintf (outbuf, "\\x%04x", c);
-                      need_nonhex = 1;
-                    }
-                  strout (outbuf, len, len, printcharfun);
-                }
-              else if (! multibyte
-                       && SINGLE_BYTE_CHAR_P (c) && ! ASCII_CHAR_P (c)
-                       && print_escape_nonascii)
-                {
-                  /* When printing in a multibyte buffer
-                     or when explicitly requested,
+                  /* When printing a raw 8-bit byte in a multibyte buffer, or
+                     (when requested) a non-ASCII character in a unibyte buffer,
                      print single-byte non-ASCII string chars
                      using octal escapes.  */
                   char outbuf[5];
-                  int len = sprintf (outbuf, "\\%03o", c);
+                  int len = sprintf (outbuf, "\\%03o", c + 0u);
                   strout (outbuf, len, len, printcharfun);
+                  need_nonhex = false;
+                }
+              else if (multibyte
+                       && ! ASCII_CHAR_P (c) && print_escape_multibyte)
+                {
+                  /* When requested, print multibyte chars using hex escapes.  */
+                  char outbuf[sizeof "\\x" + INT_STRLEN_BOUND (c)];
+                  int len = sprintf (outbuf, "\\x%04x", c + 0u);
+                  strout (outbuf, len, len, printcharfun);
+                  need_nonhex = true;
                 }
               else
                 {
                   /* If we just had a hex escape, and this character
                      could be taken as part of it,
                      output `\ ' to prevent that.  */
-                  if (need_nonhex)
-                    {
-                      need_nonhex = 0;
-                      if ((c >= 'a' && c <= 'f')
-                          || (c >= 'A' && c <= 'F')
-                          || (c >= '0' && c <= '9'))
-                        strout ("\\ ", -1, -1, printcharfun);
-                    }
-
-                  if (c == '\"' || c == '\\')
-                    PRINTCHAR ('\\');
-                  PRINTCHAR (c);
+                  if (need_nonhex && c_isxdigit (c))
+                    print_c_string ("\\ ", printcharfun);
+
+                  if (c == '\n' && print_escape_newlines
+                      ? (c = 'n', true)
+                      : c == '\f' && print_escape_newlines
+                      ? (c = 'f', true)
+                      : c == '\"' || c == '\\')
+                    printchar ('\\', printcharfun);
+
+                  printchar (c, printcharfun);
+                  need_nonhex = false;
                 }
             }
-          PRINTCHAR ('\"');
+          printchar ('\"', printcharfun);
 
           if (string_intervals (obj))
             {
               traverse_intervals (string_intervals (obj),
                                   0, print_interval, printcharfun);
-              PRINTCHAR (')');
+              printchar (')', printcharfun);
             }
 
           UNGCPRO;
@@ -1550,14 +1507,10 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
         size_byte = SBYTES (name);
 
         if (! NILP (Vprint_gensym) && !SYMBOL_INTERNED_P (obj))
-          {
-            PRINTCHAR ('#');
-            PRINTCHAR (':');
-          }
+          print_c_string ("#:", printcharfun);
         else if (size_byte == 0)
           {
-            PRINTCHAR ('#');
-            PRINTCHAR ('#');
+            print_c_string ("##", printcharfun);
             break;
           }
 
@@ -1575,9 +1528,12 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
                     || c == ',' || c == '.' || c == '`'
                     || c == '[' || c == ']' || c == '?' || c <= 040
                     || confusing)
-                  PRINTCHAR ('\\'), confusing = 0;
+                  {
+                    printchar ('\\', printcharfun);
+                    confusing = false;
+                  }
               }
-            PRINTCHAR (c);
+            printchar (c, printcharfun);
           }
       }
       break;
@@ -1586,18 +1542,17 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
       /* If deeper than spec'd depth, print placeholder.  */
       if (INTEGERP (Vprint_level)
           && print_depth > XINT (Vprint_level))
-        strout ("...", -1, -1, printcharfun);
+        print_c_string ("...", printcharfun);
       else if (print_quoted && CONSP (XCDR (obj)) && NILP (XCDR (XCDR (obj)))
                && (EQ (XCAR (obj), Qquote)))
         {
-          PRINTCHAR ('\'');
+          printchar ('\'', printcharfun);
           print_object (XCAR (XCDR (obj)), printcharfun, escapeflag);
         }
       else if (print_quoted && CONSP (XCDR (obj)) && NILP (XCDR (XCDR (obj)))
                && (EQ (XCAR (obj), Qfunction)))
         {
-          PRINTCHAR ('#');
-          PRINTCHAR ('\'');
+          print_c_string ("#'", printcharfun);
           print_object (XCAR (XCDR (obj)), printcharfun, escapeflag);
         }
       else if (print_quoted && CONSP (XCDR (obj)) && NILP (XCDR (XCDR (obj)))
@@ -1622,75 +1577,71 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
         }
       else
         {
-          PRINTCHAR ('(');
+          printchar ('(', printcharfun);
 
-          {
-            printmax_t i, print_length;
-            Lisp_Object halftail = obj;
+          Lisp_Object halftail = obj;
 
-            /* Negative values of print-length are invalid in CL.
-               Treat them like nil, as CMUCL does.  */
-            if (NATNUMP (Vprint_length))
-              print_length = XFASTINT (Vprint_length);
-            else
-              print_length = TYPE_MAXIMUM (printmax_t);
+          /* Negative values of print-length are invalid in CL.
+             Treat them like nil, as CMUCL does.  */
+          printmax_t print_length = (NATNUMP (Vprint_length)
+                                     ? XFASTINT (Vprint_length)
+                                     : TYPE_MAXIMUM (printmax_t));
 
-            i = 0;
-            while (CONSP (obj))
-              {
-                /* Detect circular list.  */
-                if (NILP (Vprint_circle))
-                  {
-                    /* Simple but incomplete way.  */
-                    if (i != 0 && EQ (obj, halftail))
-                      {
-                        int len = sprintf (buf, " . #%"pMd, i / 2);
-                        strout (buf, len, len, printcharfun);
-                        goto end_of_list;
-                      }
-                  }
-                else
-                  {
-                    /* With the print-circle feature.  */
-                    if (i != 0)
-                      {
-                        Lisp_Object num = Fgethash (obj, Vprint_number_table, Qnil);
-                        if (INTEGERP (num))
-                          {
-                            strout (" . ", 3, 3, printcharfun);
-                            print_object (obj, printcharfun, escapeflag);
-                            goto end_of_list;
-                          }
-                      }
-                  }
+          printmax_t i = 0;
+          while (CONSP (obj))
+            {
+              /* Detect circular list.  */
+              if (NILP (Vprint_circle))
+                {
+                  /* Simple but incomplete way.  */
+                  if (i != 0 && EQ (obj, halftail))
+                    {
+                      int len = sprintf (buf, " . #%"pMd, i / 2);
+                      strout (buf, len, len, printcharfun);
+                      goto end_of_list;
+                    }
+                }
+              else
+                {
+                  /* With the print-circle feature.  */
+                  if (i != 0)
+                    {
+                      Lisp_Object num = Fgethash (obj, Vprint_number_table, Qnil);
+                      if (INTEGERP (num))
+                        {
+                          print_c_string (" . ", printcharfun);
+                          print_object (obj, printcharfun, escapeflag);
+                          goto end_of_list;
+                        }
+                    }
+                }
 
-                if (i)
-                  PRINTCHAR (' ');
+              if (i)
+                printchar (' ', printcharfun);
 
-                if (print_length <= i)
-                  {
-                    strout ("...", 3, 3, printcharfun);
-                    goto end_of_list;
-                  }
+              if (print_length <= i)
+                {
+                  print_c_string ("...", printcharfun);
+                  goto end_of_list;
+                }
 
-                i++;
-                print_object (XCAR (obj), printcharfun, escapeflag);
+              i++;
+              print_object (XCAR (obj), printcharfun, escapeflag);
 
-                obj = XCDR (obj);
-                if (!(i & 1))
-                  halftail = XCDR (halftail);
-              }
+              obj = XCDR (obj);
+              if (!(i & 1))
+                halftail = XCDR (halftail);
           }
 
           /* OBJ non-nil here means it's the end of a dotted list.  */
           if (!NILP (obj))
             {
-              strout (" . ", 3, 3, printcharfun);
+              print_c_string (" . ", printcharfun);
               print_object (obj, printcharfun, escapeflag);
             }
 
         end_of_list:
-          PRINTCHAR (')');
+          printchar (')', printcharfun);
         }
       break;
 
@@ -1699,9 +1650,9 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
         {
           if (escapeflag)
             {
-              strout ("#<process ", -1, -1, printcharfun);
+              print_c_string ("#<process ", printcharfun);
               print_string (XPROCESS (obj)->name, printcharfun);
-              PRINTCHAR ('>');
+              printchar ('>', printcharfun);
             }
           else
             print_string (XPROCESS (obj)->name, printcharfun);
@@ -1709,7 +1660,6 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
       else if (BOOL_VECTOR_P (obj))
         {
           ptrdiff_t i;
-          int len;
           unsigned char c;
           struct gcpro gcpro1;
           EMACS_INT size = bool_vector_size (obj);
@@ -1717,11 +1667,8 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
           ptrdiff_t real_size_in_chars = size_in_chars;
           GCPRO1 (obj);
 
-          PRINTCHAR ('#');
-          PRINTCHAR ('&');
-          len = sprintf (buf, "%"pI"d", size);
+          int len = sprintf (buf, "#&%"pI"d\"", size);
           strout (buf, len, len, printcharfun);
-          PRINTCHAR ('\"');
 
           /* Don't print more characters than the specified maximum.
              Negative values of print-length are invalid.  Treat them
@@ -1735,70 +1682,59 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
               QUIT;
               c = bool_vector_uchar_data (obj)[i];
               if (c == '\n' && print_escape_newlines)
-                {
-                  PRINTCHAR ('\\');
-                  PRINTCHAR ('n');
-                }
+                print_c_string ("\\n", printcharfun);
               else if (c == '\f' && print_escape_newlines)
-                {
-                  PRINTCHAR ('\\');
-                  PRINTCHAR ('f');
-                }
+                print_c_string ("\\f", printcharfun);
               else if (c > '\177')
                 {
                   /* Use octal escapes to avoid encoding issues.  */
-                  PRINTCHAR ('\\');
-                  PRINTCHAR ('0' + ((c >> 6) & 3));
-                  PRINTCHAR ('0' + ((c >> 3) & 7));
-                  PRINTCHAR ('0' + (c & 7));
+                  len = sprintf (buf, "\\%o", c);
+                  strout (buf, len, len, printcharfun);
                 }
               else
                 {
                   if (c == '\"' || c == '\\')
-                    PRINTCHAR ('\\');
-                  PRINTCHAR (c);
+                    printchar ('\\', printcharfun);
+                  printchar (c, printcharfun);
                 }
             }
 
           if (size_in_chars < real_size_in_chars)
-            strout (" ...", 4, 4, printcharfun);
-          PRINTCHAR ('\"');
+            print_c_string (" ...", printcharfun);
+          printchar ('\"', printcharfun);
 
           UNGCPRO;
         }
       else if (SUBRP (obj))
         {
-          strout ("#<subr ", -1, -1, printcharfun);
-          strout (XSUBR (obj)->symbol_name, -1, -1, printcharfun);
-          PRINTCHAR ('>');
+          print_c_string ("#<subr ", printcharfun);
+          print_c_string (XSUBR (obj)->symbol_name, printcharfun);
+          printchar ('>', printcharfun);
         }
       else if (WINDOWP (obj))
         {
-          int len;
-          strout ("#<window ", -1, -1, printcharfun);
-          len = sprintf (buf, "%d", XWINDOW (obj)->sequence_number);
+          int len = sprintf (buf, "#<window %"pI"d",
+                             XWINDOW (obj)->sequence_number);
           strout (buf, len, len, printcharfun);
           if (BUFFERP (XWINDOW (obj)->contents))
             {
-              strout (" on ", -1, -1, printcharfun);
+              print_c_string (" on ", printcharfun);
               print_string (BVAR (XBUFFER (XWINDOW (obj)->contents), name),
                             printcharfun);
             }
-          PRINTCHAR ('>');
+          printchar ('>', printcharfun);
         }
       else if (TERMINALP (obj))
         {
-          int len;
           struct terminal *t = XTERMINAL (obj);
-          strout ("#<terminal ", -1, -1, printcharfun);
-          len = sprintf (buf, "%d", t->id);
+          int len = sprintf (buf, "#<terminal %d", t->id);
           strout (buf, len, len, printcharfun);
           if (t->name)
             {
-              strout (" on ", -1, -1, printcharfun);
-              strout (t->name, -1, -1, printcharfun);
+              print_c_string (" on ", printcharfun);
+              print_c_string (t->name, printcharfun);
             }
-          PRINTCHAR ('>');
+          printchar ('>', printcharfun);
         }
       else if (HASH_TABLE_P (obj))
         {
@@ -1808,16 +1744,14 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
           int len;
 #if 0
           void *ptr = h;
-          strout ("#<hash-table", -1, -1, printcharfun);
+          print_c_string ("#<hash-table", printcharfun);
           if (SYMBOLP (h->test))
             {
-              PRINTCHAR (' ');
-              PRINTCHAR ('\'');
-              strout (SDATA (SYMBOL_NAME (h->test)), -1, -1, printcharfun);
-              PRINTCHAR (' ');
-              strout (SDATA (SYMBOL_NAME (h->weak)), -1, -1, printcharfun);
-              PRINTCHAR (' ');
-              len = sprintf (buf, "%"pD"d/%"pD"d", h->count, ASIZE (h->next));
+              print_c_string (" '", printcharfun);
+              print_c_string (SSDATA (SYMBOL_NAME (h->test)), printcharfun);
+              printchar (' ', printcharfun);
+              print_c_string (SSDATA (SYMBOL_NAME (h->weak)), printcharfun);
+              len = sprintf (buf, " %"pD"d/%"pD"d", h->count, ASIZE (h->next));
               strout (buf, len, len, printcharfun);
             }
           len = sprintf (buf, " %p>", ptr);
@@ -1831,29 +1765,29 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
 
           if (!NILP (h->test.name))
             {
-              strout (" test ", -1, -1, printcharfun);
+              print_c_string (" test ", printcharfun);
               print_object (h->test.name, printcharfun, escapeflag);
             }
 
           if (!NILP (h->weak))
             {
-              strout (" weakness ", -1, -1, printcharfun);
+              print_c_string (" weakness ", printcharfun);
               print_object (h->weak, printcharfun, escapeflag);
             }
 
           if (!NILP (h->rehash_size))
             {
-              strout (" rehash-size ", -1, -1, printcharfun);
+              print_c_string (" rehash-size ", printcharfun);
               print_object (h->rehash_size, printcharfun, escapeflag);
             }
 
           if (!NILP (h->rehash_threshold))
             {
-              strout (" rehash-threshold ", -1, -1, printcharfun);
+              print_c_string (" rehash-threshold ", printcharfun);
               print_object (h->rehash_threshold, printcharfun, escapeflag);
             }
 
-          strout (" data ", -1, -1, printcharfun);
+          print_c_string (" data ", printcharfun);
 
           /* Print the data here as a plist. */
           real_size = HASH_TABLE_SIZE (h);
@@ -1864,49 +1798,47 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
               && XFASTINT (Vprint_length) < size)
             size = XFASTINT (Vprint_length);
 
-          PRINTCHAR ('(');
+          printchar ('(', printcharfun);
           for (i = 0; i < size; i++)
             if (!NILP (HASH_HASH (h, i)))
               {
-                if (i) PRINTCHAR (' ');
+                if (i) printchar (' ', printcharfun);
                 print_object (HASH_KEY (h, i), printcharfun, escapeflag);
-                PRINTCHAR (' ');
+                printchar (' ', printcharfun);
                 print_object (HASH_VALUE (h, i), printcharfun, escapeflag);
               }
 
           if (size < real_size)
-            strout (" ...", 4, 4, printcharfun);
+            print_c_string (" ...", printcharfun);
 
-          PRINTCHAR (')');
-          PRINTCHAR (')');
+          print_c_string ("))", printcharfun);
 
         }
       else if (BUFFERP (obj))
         {
           if (!BUFFER_LIVE_P (XBUFFER (obj)))
-            strout ("#<killed buffer>", -1, -1, printcharfun);
+            print_c_string ("#<killed buffer>", printcharfun);
           else if (escapeflag)
             {
-              strout ("#<buffer ", -1, -1, printcharfun);
+              print_c_string ("#<buffer ", printcharfun);
               print_string (BVAR (XBUFFER (obj), name), printcharfun);
-              PRINTCHAR ('>');
+              printchar ('>', printcharfun);
             }
           else
             print_string (BVAR (XBUFFER (obj), name), printcharfun);
         }
       else if (WINDOW_CONFIGURATIONP (obj))
-        {
-          strout ("#<window-configuration>", -1, -1, printcharfun);
-        }
+        print_c_string ("#<window-configuration>", printcharfun);
       else if (FRAMEP (obj))
         {
           int len;
           void *ptr = XFRAME (obj);
           Lisp_Object frame_name = XFRAME (obj)->name;
 
-          strout ((FRAME_LIVE_P (XFRAME (obj))
-                   ? "#<frame " : "#<dead frame "),
-                  -1, -1, printcharfun);
+          print_c_string ((FRAME_LIVE_P (XFRAME (obj))
+                           ? "#<frame "
+                           : "#<dead frame "),
+                          printcharfun);
           if (!STRINGP (frame_name))
             {
               /* A frame could be too young and have no name yet;
@@ -1927,12 +1859,12 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
           if (! FONT_OBJECT_P (obj))
             {
               if (FONT_SPEC_P (obj))
-                strout ("#<font-spec", -1, -1, printcharfun);
+                print_c_string ("#<font-spec", printcharfun);
               else
-                strout ("#<font-entity", -1, -1, printcharfun);
+                print_c_string ("#<font-entity", printcharfun);
               for (i = 0; i < FONT_SPEC_MAX; i++)
                 {
-                  PRINTCHAR (' ');
+                  printchar (' ', printcharfun);
                   if (i < FONT_WEIGHT_INDEX || i > FONT_WIDTH_INDEX)
                     print_object (AREF (obj, i), printcharfun, escapeflag);
                   else
@@ -1942,18 +1874,18 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
             }
           else
             {
-              strout ("#<font-object ", -1, -1, printcharfun);
+              print_c_string ("#<font-object ", printcharfun);
               print_object (AREF (obj, FONT_NAME_INDEX), printcharfun,
                             escapeflag);
             }
-          PRINTCHAR ('>');
+          printchar ('>', printcharfun);
         }
       else
         {
           ptrdiff_t size = ASIZE (obj);
           if (COMPILEDP (obj))
             {
-              PRINTCHAR ('#');
+              printchar ('#', printcharfun);
               size &= PSEUDOVECTOR_SIZE_MASK;
             }
           if (CHAR_TABLE_P (obj) || SUB_CHAR_TABLE_P (obj))
@@ -1967,20 +1899,19 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
                  results in slow redisplay.  */
               if (SUB_CHAR_TABLE_P (obj)
                   && XSUB_CHAR_TABLE (obj)->depth == 3)
-                PRINTCHAR ('\n');
-              PRINTCHAR ('#');
-              PRINTCHAR ('^');
+                printchar ('\n', printcharfun);
+              print_c_string ("#^", printcharfun);
               if (SUB_CHAR_TABLE_P (obj))
-                PRINTCHAR ('^');
+                printchar ('^', printcharfun);
               size &= PSEUDOVECTOR_SIZE_MASK;
             }
           if (size & PSEUDOVECTOR_FLAG)
             goto badtype;
 
-          PRINTCHAR ('[');
+          printchar ('[', printcharfun);
           {
             int i, idx = SUB_CHAR_TABLE_P (obj) ? SUB_CHAR_TABLE_OFFSET : 0;
-            register Lisp_Object tem;
+            Lisp_Object tem;
             ptrdiff_t real_size = size;
 
             /* For a sub char-table, print heading non-Lisp data first.  */
@@ -1998,14 +1929,14 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
 
             for (i = idx; i < size; i++)
               {
-                if (i) PRINTCHAR (' ');
+                if (i) printchar (' ', printcharfun);
                 tem = AREF (obj, i);
                 print_object (tem, printcharfun, escapeflag);
               }
             if (size < real_size)
-              strout (" ...", 4, 4, printcharfun);
+              print_c_string (" ...", printcharfun);
           }
-          PRINTCHAR (']');
+          printchar (']', printcharfun);
         }
       break;
 
@@ -2013,26 +1944,25 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
       switch (XMISCTYPE (obj))
         {
         case Lisp_Misc_Marker:
-          strout ("#<marker ", -1, -1, printcharfun);
+          print_c_string ("#<marker ", printcharfun);
           /* Do you think this is necessary?  */
           if (XMARKER (obj)->insertion_type != 0)
-            strout ("(moves after insertion) ", -1, -1, printcharfun);
+            print_c_string ("(moves after insertion) ", printcharfun);
           if (! XMARKER (obj)->buffer)
-            strout ("in no buffer", -1, -1, printcharfun);
+            print_c_string ("in no buffer", printcharfun);
           else
             {
-              int len = sprintf (buf, "at %"pD"d", marker_position (obj));
+              int len = sprintf (buf, "at %"pD"d in ", marker_position (obj));
               strout (buf, len, len, printcharfun);
-              strout (" in ", -1, -1, printcharfun);
               print_string (BVAR (XMARKER (obj)->buffer, name), printcharfun);
             }
-          PRINTCHAR ('>');
+          printchar ('>', printcharfun);
           break;
 
         case Lisp_Misc_Overlay:
-          strout ("#<overlay ", -1, -1, printcharfun);
+          print_c_string ("#<overlay ", printcharfun);
           if (! XMARKER (OVERLAY_START (obj))->buffer)
-            strout ("in no buffer", -1, -1, printcharfun);
+            print_c_string ("in no buffer", printcharfun);
           else
             {
               int len = sprintf (buf, "from %"pD"d to %"pD"d in ",
@@ -2042,21 +1972,21 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
               print_string (BVAR (XMARKER (OVERLAY_START (obj))->buffer, name),
                             printcharfun);
             }
-          PRINTCHAR ('>');
+          printchar ('>', printcharfun);
           break;
 
         case Lisp_Misc_Finalizer:
-          strout ("#<finalizer", -1, -1, printcharfun);
+          print_c_string ("#<finalizer", printcharfun);
           if (NILP (XFINALIZER (obj)->function))
-            strout (" used", -1, -1, printcharfun);
-          strout (">", -1, -1, printcharfun);
+            print_c_string (" used", printcharfun);
+          printchar ('>', printcharfun);
           break;
 
           /* Remaining cases shouldn't happen in normal usage, but let's
              print them anyway for the benefit of the debugger.  */
 
         case Lisp_Misc_Free:
-          strout ("#<misc free cell>", -1, -1, printcharfun);
+          print_c_string ("#<misc free cell>", printcharfun);
           break;
 
         case Lisp_Misc_Save_Value:
@@ -2064,7 +1994,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
             int i;
             struct Lisp_Save_Value *v = XSAVE_VALUE (obj);
 
-            strout ("#<save-value ", -1, -1, printcharfun);
+            print_c_string ("#<save-value ", printcharfun);
 
             if (v->save_type == SAVE_TYPE_MEMORY)
               {
@@ -2087,17 +2017,15 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
                     Lisp_Object maybe = area[i];
                     int valid = valid_lisp_object_p (maybe);
 
+                    printchar (' ', printcharfun);
                     if (0 < valid)
-                      {
-                        PRINTCHAR (' ');
-                        print_object (maybe, printcharfun, escapeflag);
-                      }
+                      print_object (maybe, printcharfun, escapeflag);
                     else
-                      strout (valid ? " <some>" : " <invalid>",
-                              -1, -1, printcharfun);
+                      print_c_string (valid < 0 ? "<some>" : "<invalid>",
+                                      printcharfun);
                   }
                 if (i == limit && i < amount)
-                  strout (" ...", 4, 4, printcharfun);
+                  print_c_string (" ...", printcharfun);
 
 #else /* not GC_MARK_STACK */
 
@@ -2116,7 +2044,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
                 for (index = 0; index < SAVE_VALUE_SLOTS; index++)
                   {
                     if (index)
-                      PRINTCHAR (' ');
+                      printchar (' ', printcharfun);
 
                     switch (save_type (v, index))
                       {
@@ -2152,7 +2080,7 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
                     strout (buf, i, i, printcharfun);
                   }
               }
-            PRINTCHAR ('>');
+            printchar ('>', printcharfun);
           }
           break;
 
@@ -2167,16 +2095,17 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
         int len;
         /* We're in trouble if this happens!
            Probably should just emacs_abort ().  */
-        strout ("#<EMACS BUG: INVALID DATATYPE ", -1, -1, printcharfun);
+        print_c_string ("#<EMACS BUG: INVALID DATATYPE ", printcharfun);
         if (MISCP (obj))
-          len = sprintf (buf, "(MISC 0x%04x)", (int) XMISCTYPE (obj));
+          len = sprintf (buf, "(MISC 0x%04x)", (unsigned) XMISCTYPE (obj));
         else if (VECTORLIKEP (obj))
-          len = sprintf (buf, "(PVEC 0x%08"pD"x)", ASIZE (obj));
+          len = sprintf (buf, "(PVEC 0x%08zx)", (size_t) ASIZE (obj));
         else
-          len = sprintf (buf, "(0x%02x)", (int) XTYPE (obj));
+          len = sprintf (buf, "(0x%02x)", (unsigned) XTYPE (obj));
         strout (buf, len, len, printcharfun);
-        strout (" Save your buffers immediately and please report this bug>",
-                -1, -1, printcharfun);
+        print_c_string ((" Save your buffers immediately"
+                         " and please report this bug>"),
+                        printcharfun);
       }
     }
 
@@ -2192,12 +2121,12 @@ print_interval (INTERVAL interval, Lisp_Object printcharfun)
 {
   if (NILP (interval->plist))
     return;
-  PRINTCHAR (' ');
+  printchar (' ', printcharfun);
   print_object (make_number (interval->position), printcharfun, 1);
-  PRINTCHAR (' ');
+  printchar (' ', printcharfun);
   print_object (make_number (interval->position + LENGTH (interval)),
                 printcharfun, 1);
-  PRINTCHAR (' ');
+  printchar (' ', printcharfun);
   print_object (interval->plist, printcharfun, 1);
 }
 
diff --git a/src/process.c b/src/process.c
index 2800fa58340..3e04cb76387 100644
--- a/src/process.c
+++ b/src/process.c
@@ -189,6 +189,8 @@ process_socket (int domain, int type, int protocol)
 #define NETCONN1_P(p) (EQ (p->type, Qnetwork))
 #define SERIALCONN_P(p) (EQ (XPROCESS (p)->type, Qserial))
 #define SERIALCONN1_P(p) (EQ (p->type, Qserial))
+#define PIPECONN_P(p) (EQ (XPROCESS (p)->type, Qpipe))
+#define PIPECONN1_P(p) (EQ (p->type, Qpipe))
 
 /* Number of events of change of status of a process.  */
 static EMACS_INT process_tick;
@@ -411,6 +413,11 @@ pset_write_queue (struct Lisp_Process *p, Lisp_Object val)
 {
   p->write_queue = val;
 }
+static void
+pset_stderrproc (struct Lisp_Process *p, Lisp_Object val)
+{
+  p->stderrproc = val;
+}
 
 
 static Lisp_Object
@@ -837,7 +844,7 @@ nil, indicating the current buffer's process.  */)
   p = XPROCESS (process);
 
   p->raw_status_new = 0;
-  if (NETCONN1_P (p) || SERIALCONN1_P (p))
+  if (NETCONN1_P (p) || SERIALCONN1_P (p) || PIPECONN1_P (p))
     {
       pset_status (p, list2 (Qexit, make_number (0)));
       p->tick = ++process_tick;
@@ -903,7 +910,7 @@ nil, indicating the current buffer's process.  */)
   status = p->status;
   if (CONSP (status))
     status = XCAR (status);
-  if (NETCONN1_P (p) || SERIALCONN1_P (p))
+  if (NETCONN1_P (p) || SERIALCONN1_P (p) || PIPECONN1_P (p))
     {
       if (EQ (status, Qexit))
         status = Qclosed;
@@ -987,7 +994,7 @@ Return BUFFER.  */)
     CHECK_BUFFER (buffer);
   p = XPROCESS (process);
   pset_buffer (p, buffer);
-  if (NETCONN1_P (p) || SERIALCONN1_P (p))
+  if (NETCONN1_P (p) || SERIALCONN1_P (p) || PIPECONN1_P (p))
     pset_childp (p, Fplist_put (p->childp, QCbuffer, buffer));
   setup_process_coding_systems (process);
   return buffer;
@@ -1063,7 +1070,7 @@ The string argument is normally a multibyte string, except:
     }
 
   pset_filter (p, filter);
-  if (NETCONN1_P (p) || SERIALCONN1_P (p))
+  if (NETCONN1_P (p) || SERIALCONN1_P (p) || PIPECONN1_P (p))
     pset_childp (p, Fplist_put (p->childp, QCfilter, filter));
   setup_process_coding_systems (process);
   return filter;
@@ -1095,7 +1102,7 @@ It gets two arguments: the process, and a string describing the change.  */)
     sentinel = Qinternal_default_process_sentinel;
 
   pset_sentinel (p, sentinel);
-  if (NETCONN1_P (p) || SERIALCONN1_P (p))
+  if (NETCONN1_P (p) || SERIALCONN1_P (p) || PIPECONN1_P (p))
     pset_childp (p, Fplist_put (p->childp, QCsentinel, sentinel));
   return sentinel;
 }
@@ -1204,7 +1211,8 @@ list of keywords.  */)
                           Fprocess_datagram_address (process));
 #endif
 
-  if ((!NETCONN_P (process) && !SERIALCONN_P (process)) || EQ (key, Qt))
+  if ((!NETCONN_P (process) && !SERIALCONN_P (process) && !PIPECONN_P (process))
+      || EQ (key, Qt))
     return contact;
   if (NILP (key) && NETCONN_P (process))
     return list2 (Fplist_get (contact, QChost),
@@ -1212,6 +1220,11 @@ list of keywords.  */)
   if (NILP (key) && SERIALCONN_P (process))
     return list2 (Fplist_get (contact, QCport),
                   Fplist_get (contact, QCspeed));
+  /* FIXME: Return a meaningful value (e.g., the child end of the pipe)
+     if the pipe process is useful for purposes other than receiving
+     stderr.  */
+  if (NILP (key) && PIPECONN_P (process))
+    return Qt;
   return Fplist_get (contact, key);
 }
 
@@ -1386,10 +1399,15 @@ to use a pty, or nil to use the default specified through
 
 :sentinel SENTINEL -- Install SENTINEL as the process sentinel.
 
+:stderr STDERR -- STDERR is either a buffer or a pipe process attached
+to the standard error of subprocess.  Specifying this implies
+`:connection-type' is set to `pipe'.
+
 usage: (make-process &rest ARGS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
   Lisp_Object buffer, name, command, program, proc, contact, current_dir, tem;
+  Lisp_Object xstderr, stderrproc;
   ptrdiff_t count = SPECPDL_INDEX ();
   struct gcpro gcpro1;
   USE_SAFE_ALLOCA;
@@ -1433,6 +1451,27 @@ usage: (make-process &rest ARGS)  */)
   if (!NILP (program))
     CHECK_STRING (program);
 
+  stderrproc = Qnil;
+  xstderr = Fplist_get (contact, QCstderr);
+  if (PROCESSP (xstderr))
+    {
+      if (!PIPECONN_P (xstderr))
+        error ("Process is not a pipe process");
+      stderrproc = xstderr;
+    }
+  else if (!NILP (xstderr))
+    {
+      struct gcpro gcpro1, gcpro2;
+      CHECK_STRING (program);
+      GCPRO2 (buffer, current_dir);
+      stderrproc = CALLN (Fmake_pipe_process,
+                          QCname,
+                          concat2 (name, build_string (" stderr")),
+                          QCbuffer,
+                          Fget_buffer_create (xstderr));
+      UNGCPRO;
+    }
+
   proc = make_process (name);
   /* If an error occurs and we can't start the process, we want to
      remove it from the process list.  This means that each error
@@ -1444,8 +1483,8 @@ usage: (make-process &rest ARGS)  */)
   pset_plist (XPROCESS (proc), Qnil);
   pset_type (XPROCESS (proc), Qreal);
   pset_buffer (XPROCESS (proc), buffer);
-  pset_sentinel (XPROCESS (proc), Qinternal_default_process_sentinel);
-  pset_filter (XPROCESS (proc), Qinternal_default_process_filter);
+  pset_sentinel (XPROCESS (proc), Fplist_get (contact, QCsentinel));
+  pset_filter (XPROCESS (proc), Fplist_get (contact, QCfilter));
   pset_command (XPROCESS (proc), Fcopy_sequence (command));
 
   if (tem = Fplist_get (contact, QCnoquery), !NILP (tem))
@@ -1463,6 +1502,13 @@ usage: (make-process &rest ARGS)  */)
   else
     report_file_error ("Unknown connection type", tem);
 
+  if (!NILP (stderrproc))
+    {
+      pset_stderrproc (XPROCESS (proc), stderrproc);
+
+      XPROCESS (proc)->pty_flag = false;
+    }
+
 #ifdef HAVE_GNUTLS
   /* AKA GNUTLS_INITSTAGE(proc).  */
   XPROCESS (proc)->gnutls_initstage = GNUTLS_STAGE_EMPTY;
@@ -1708,7 +1754,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
   int inchannel, outchannel;
   pid_t pid;
   int vfork_errno;
-  int forkin, forkout;
+  int forkin, forkout, forkerr = -1;
   bool pty_flag = 0;
   char pty_name[PTY_NAME_SIZE];
   Lisp_Object lisp_pty_name = Qnil;
@@ -1746,6 +1792,17 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
       outchannel = p->open_fd[WRITE_TO_SUBPROCESS];
       inchannel = p->open_fd[READ_FROM_SUBPROCESS];
       forkout = p->open_fd[SUBPROCESS_STDOUT];
+
+      if (!NILP (p->stderrproc))
+        {
+          struct Lisp_Process *pp = XPROCESS (p->stderrproc);
+
+          forkerr = pp->open_fd[SUBPROCESS_STDOUT];
+
+          /* Close unnecessary file descriptors.  */
+          close_process_fd (&pp->open_fd[WRITE_TO_SUBPROCESS]);
+          close_process_fd (&pp->open_fd[SUBPROCESS_STDIN]);
+        }
     }
 
 #ifndef WINDOWSNT
@@ -1792,6 +1849,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
     char **volatile new_argv_volatile = new_argv;
     int volatile forkin_volatile = forkin;
     int volatile forkout_volatile = forkout;
+    int volatile forkerr_volatile = forkerr;
     struct Lisp_Process *p_volatile = p;
 
     pid = vfork ();
@@ -1801,6 +1859,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
     new_argv = new_argv_volatile;
     forkin = forkin_volatile;
     forkout = forkout_volatile;
+    forkerr = forkerr_volatile;
     p = p_volatile;
 
     pty_flag = p->pty_flag;
@@ -1811,6 +1870,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
     {
       int xforkin = forkin;
       int xforkout = forkout;
+      int xforkerr = forkerr;
 
       /* Make the pty be the controlling terminal of the process.  */
 #ifdef HAVE_PTYS
@@ -1910,10 +1970,13 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
 
       if (pty_flag)
         child_setup_tty (xforkout);
+
+      if (xforkerr < 0)
+        xforkerr = xforkout;
 #ifdef WINDOWSNT
-      pid = child_setup (xforkin, xforkout, xforkout, new_argv, 1, current_dir);
+      pid = child_setup (xforkin, xforkout, xforkerr, new_argv, 1, current_dir);
 #else  /* not WINDOWSNT */
-      child_setup (xforkin, xforkout, xforkout, new_argv, 1, current_dir);
+      child_setup (xforkin, xforkout, xforkerr, new_argv, 1, current_dir);
 #endif /* not WINDOWSNT */
     }
 
@@ -1958,6 +2021,11 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
         close_process_fd (&p->open_fd[READ_FROM_EXEC_MONITOR]);
       }
 #endif
+      if (!NILP (p->stderrproc))
+        {
+          struct Lisp_Process *pp = XPROCESS (p->stderrproc);
+          close_process_fd (&pp->open_fd[SUBPROCESS_STDOUT]);
+        }
     }
 }
 
@@ -2016,6 +2084,187 @@ create_pty (Lisp_Object process)
   p->pid = -2;
 }
 
+DEFUN ("make-pipe-process", Fmake_pipe_process, Smake_pipe_process,
+       0, MANY, 0,
+       doc: /* Create and return a bidirectional pipe process.
+
+In Emacs, pipes are represented by process objects, so input and
+output work as for subprocesses, and `delete-process' closes a pipe.
+However, a pipe process has no process id, it cannot be signaled,
+and the status codes are different from normal processes.
+
+Arguments are specified as keyword/argument pairs.  The following
+arguments are defined:
+
+:name NAME -- NAME is the name of the process.  It is modified if necessary to make it unique.
+
+:buffer BUFFER -- BUFFER is the buffer (or buffer-name) to associate
+with the process.  Process output goes at the end of that buffer,
+unless you specify an output stream or filter function to handle the
+output.  If BUFFER is not given, the value of NAME is used.
+
+:coding CODING -- If CODING is a symbol, it specifies the coding
+system used for both reading and writing for this process.  If CODING
+is a cons (DECODING . ENCODING), DECODING is used for reading, and
+ENCODING is used for writing.
+
+:noquery BOOL -- When exiting Emacs, query the user if BOOL is nil and
+the process is running.  If BOOL is not given, query before exiting.
+
+:stop BOOL -- Start process in the `stopped' state if BOOL non-nil.
+In the stopped state, a pipe process does not accept incoming data,
+but you can send outgoing data.  The stopped state is cleared by
+`continue-process' and set by `stop-process'.
+
+:filter FILTER -- Install FILTER as the process filter.
+
+:sentinel SENTINEL -- Install SENTINEL as the process sentinel.
+
+usage:  (make-pipe-process &rest ARGS)  */)
+  (ptrdiff_t nargs, Lisp_Object *args)
+{
+  Lisp_Object proc, contact;
+  struct Lisp_Process *p;
+  struct gcpro gcpro1;
+  Lisp_Object name, buffer;
+  Lisp_Object tem;
+  ptrdiff_t specpdl_count;
+  int inchannel, outchannel;
+
+  if (nargs == 0)
+    return Qnil;
+
+  contact = Flist (nargs, args);
+  GCPRO1 (contact);
+
+  name = Fplist_get (contact, QCname);
+  CHECK_STRING (name);
+  proc = make_process (name);
+  specpdl_count = SPECPDL_INDEX ();
+  record_unwind_protect (remove_process, proc);
+  p = XPROCESS (proc);
+
+  if (emacs_pipe (p->open_fd + SUBPROCESS_STDIN) != 0
+      || emacs_pipe (p->open_fd + READ_FROM_SUBPROCESS) != 0)
+    report_file_error ("Creating pipe", Qnil);
+  outchannel = p->open_fd[WRITE_TO_SUBPROCESS];
+  inchannel = p->open_fd[READ_FROM_SUBPROCESS];
+
+  fcntl (inchannel, F_SETFL, O_NONBLOCK);
+  fcntl (outchannel, F_SETFL, O_NONBLOCK);
+
+#ifdef WINDOWSNT
+  register_aux_fd (inchannel);
+#endif
+
+  /* Record this as an active process, with its channels.  */
+  chan_process[inchannel] = proc;
+  p->infd = inchannel;
+  p->outfd = outchannel;
+
+  if (inchannel > max_process_desc)
+    max_process_desc = inchannel;
+
+  buffer = Fplist_get (contact, QCbuffer);
+  if (NILP (buffer))
+    buffer = name;
+  buffer = Fget_buffer_create (buffer);
+  pset_buffer (p, buffer);
+
+  pset_childp (p, contact);
+  pset_plist (p, Fcopy_sequence (Fplist_get (contact, QCplist)));
+  pset_type (p, Qpipe);
+  pset_sentinel (p, Fplist_get (contact, QCsentinel));
+  pset_filter (p, Fplist_get (contact, QCfilter));
+  pset_log (p, Qnil);
+  if (tem = Fplist_get (contact, QCnoquery), !NILP (tem))
+    p->kill_without_query = 1;
+  if (tem = Fplist_get (contact, QCstop), !NILP (tem))
+    pset_command (p, Qt);
+  eassert (! p->pty_flag);
+
+  if (!EQ (p->command, Qt))
+    {
+      FD_SET (inchannel, &input_wait_mask);
+      FD_SET (inchannel, &non_keyboard_wait_mask);
+    }
+#ifdef ADAPTIVE_READ_BUFFERING
+  p->adaptive_read_buffering
+    = (NILP (Vprocess_adaptive_read_buffering) ? 0
+       : EQ (Vprocess_adaptive_read_buffering, Qt) ? 1 : 2);
+#endif
+
+  /* Make the process marker point into the process buffer (if any).  */
+  if (BUFFERP (buffer))
+    set_marker_both (p->mark, buffer,
+                     BUF_ZV (XBUFFER (buffer)),
+                     BUF_ZV_BYTE (XBUFFER (buffer)));
+
+  {
+    /* Setup coding systems for communicating with the network stream.  */
+
+    /* Qt denotes we have not yet called Ffind_operation_coding_system.  */
+    Lisp_Object coding_systems = Qt;
+    Lisp_Object val;
+
+    tem = Fplist_get (contact, QCcoding);
+    val = Qnil;
+    if (!NILP (tem))
+      {
+        val = tem;
+        if (CONSP (val))
+          val = XCAR (val);
+      }
+    else if (!NILP (Vcoding_system_for_read))
+      val = Vcoding_system_for_read;
+    else if ((!NILP (buffer) && NILP (BVAR (XBUFFER (buffer), enable_multibyte_characters)))
+             || (NILP (buffer) && NILP (BVAR (&buffer_defaults, enable_multibyte_characters))))
+      /* We dare not decode end-of-line format by setting VAL to
+         Qraw_text, because the existing Emacs Lisp libraries
+         assume that they receive bare code including a sequence of
+         CR LF.  */
+      val = Qnil;
+    else
+      {
+        if (CONSP (coding_systems))
+          val = XCAR (coding_systems);
+        else if (CONSP (Vdefault_process_coding_system))
+          val = XCAR (Vdefault_process_coding_system);
+        else
+          val = Qnil;
+      }
+    pset_decode_coding_system (p, val);
+
+    if (!NILP (tem))
+      {
+        val = tem;
+        if (CONSP (val))
+          val = XCDR (val);
+      }
+    else if (!NILP (Vcoding_system_for_write))
+      val = Vcoding_system_for_write;
+    else if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
+      val = Qnil;
+    else
+      {
+        if (CONSP (coding_systems))
+          val = XCDR (coding_systems);
+        else if (CONSP (Vdefault_process_coding_system))
+          val = XCDR (Vdefault_process_coding_system);
+        else
+          val = Qnil;
+      }
+    pset_encode_coding_system (p, val);
+  }
+  /* This may signal an error.  */
+  setup_process_coding_systems (proc);
+
+  specpdl_ptr = specpdl + specpdl_count;
+
+  UNGCPRO;
+  return proc;
+}
+
 
 /* Convert an internal struct sockaddr to a lisp object (vector or string).
    The address family of sa is not included in the result.  */
@@ -4536,37 +4785,41 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
       if (wait_proc && wait_proc->raw_status_new)
         update_status (wait_proc);
       if (wait_proc
-          && wait_proc->infd >= 0
           && ! EQ (wait_proc->status, Qrun)
           && ! EQ (wait_proc->status, Qconnect))
         {
           bool read_some_bytes = false;
 
           clear_waiting_for_input ();
-          XSETPROCESS (proc, wait_proc);
 
-          /* Read data from the process, until we exhaust it.  */
-          while (true)
+          /* If data can be read from the process, do so until exhausted.  */
+          if (wait_proc->infd >= 0)
             {
-              int nread = read_process_output (proc, wait_proc->infd);
-              if (nread < 0)
+              XSETPROCESS (proc, wait_proc);
+
+              while (true)
                 {
-                  if (errno == EIO || errno == EAGAIN)
-                    break;
+                  int nread = read_process_output (proc, wait_proc->infd);
+                  if (nread < 0)
+                    {
+                    if (errno == EIO || errno == EAGAIN)
+                      break;
 #ifdef EWOULDBLOCK
-                  if (errno == EWOULDBLOCK)
-                    break;
+                    if (errno == EWOULDBLOCK)
+                      break;
 #endif
-                }
-              else
-                {
-                  if (got_some_input < nread)
-                    got_some_input = nread;
-                  if (nread == 0)
-                    break;
-                  read_some_bytes = true;
+                    }
+                  else
+                    {
+                      if (got_some_input < nread)
+                        got_some_input = nread;
+                      if (nread == 0)
+                        break;
+                      read_some_bytes = true;
+                    }
                 }
             }
+
           if (read_some_bytes && do_display)
             redisplay_preserve_echo_area (10);
 
@@ -4884,7 +5137,8 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                  available now and a closed pipe.
                  With luck, a closed pipe will be accompanied by
                  subprocess termination and SIGCHLD.  */
-              else if (nread == 0 && !NETCONN_P (proc) && !SERIALCONN_P (proc))
+              else if (nread == 0 && !NETCONN_P (proc) && !SERIALCONN_P (proc)
+                       && !PIPECONN_P (proc))
                 ;
 #endif
 #ifdef HAVE_PTYS
@@ -4916,8 +5170,18 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
 #endif /* HAVE_PTYS */
               /* If we can detect process termination, don't consider the
                  process gone just because its pipe is closed.  */
-              else if (nread == 0 && !NETCONN_P (proc) && !SERIALCONN_P (proc))
+              else if (nread == 0 && !NETCONN_P (proc) && !SERIALCONN_P (proc)
+                       && !PIPECONN_P (proc))
                 ;
+              else if (nread == 0 && PIPECONN_P (proc))
+                {
+                  /* Preserve status of processes already terminated.  */
+                  XPROCESS (proc)->tick = ++process_tick;
+                  deactivate_process (proc);
+                  if (EQ (XPROCESS (proc)->status, Qrun))
+                    pset_status (XPROCESS (proc),
+                                 list2 (Qexit, make_number (0)));
+                }
               else
                 {
                   /* Preserve status of processes already terminated.  */
@@ -5954,7 +6218,8 @@ If PROCESS is a network or serial process, inhibit handling of incoming
 traffic.  */)
   (Lisp_Object process, Lisp_Object current_group)
 {
-  if (PROCESSP (process) && (NETCONN_P (process) || SERIALCONN_P (process)))
+  if (PROCESSP (process) && (NETCONN_P (process) || SERIALCONN_P (process)
+                             || PIPECONN_P (process)))
     {
       struct Lisp_Process *p;
 
@@ -5983,7 +6248,8 @@ If PROCESS is a network or serial process, resume handling of incoming
 traffic.  */)
   (Lisp_Object process, Lisp_Object current_group)
 {
-  if (PROCESSP (process) && (NETCONN_P (process) || SERIALCONN_P (process)))
+  if (PROCESSP (process) && (NETCONN_P (process) || SERIALCONN_P (process)
+                             || PIPECONN_P (process)))
     {
       struct Lisp_Process *p;
 
@@ -7030,7 +7296,7 @@ kill_buffer_processes (Lisp_Object buffer)
   FOR_EACH_PROCESS (tail, proc)
     if (NILP (buffer) || EQ (XPROCESS (proc)->buffer, buffer))
       {
-        if (NETCONN_P (proc) || SERIALCONN_P (proc))
+        if (NETCONN_P (proc) || SERIALCONN_P (proc) || PIPECONN_P (proc))
           Fdelete_process (proc);
         else if (XPROCESS (proc)->infd >= 0)
           process_send_signal (proc, SIGHUP, Qnil, 1);
@@ -7236,40 +7502,6 @@ init_process_emacs (void)
   memset (datagram_address, 0, sizeof datagram_address);
 #endif
 
- {
-   Lisp_Object subfeatures = Qnil;
-   const struct socket_options *sopt;
-
-#define ADD_SUBFEATURE(key, val) \
-  subfeatures = pure_cons (pure_cons (key, pure_cons (val, Qnil)), subfeatures)
-
-#ifdef NON_BLOCKING_CONNECT
-   ADD_SUBFEATURE (QCnowait, Qt);
-#endif
-#ifdef DATAGRAM_SOCKETS
-   ADD_SUBFEATURE (QCtype, Qdatagram);
-#endif
-#ifdef HAVE_SEQPACKET
-   ADD_SUBFEATURE (QCtype, Qseqpacket);
-#endif
-#ifdef HAVE_LOCAL_SOCKETS
-   ADD_SUBFEATURE (QCfamily, Qlocal);
-#endif
-   ADD_SUBFEATURE (QCfamily, Qipv4);
-#ifdef AF_INET6
-   ADD_SUBFEATURE (QCfamily, Qipv6);
-#endif
-#ifdef HAVE_GETSOCKNAME
-   ADD_SUBFEATURE (QCservice, Qt);
-#endif
-   ADD_SUBFEATURE (QCserver, Qt);
-
-   for (sopt = socket_options; sopt->name; sopt++)
-     subfeatures = pure_cons (intern_c_string (sopt->name), subfeatures);
-
-   Fprovide (intern_c_string ("make-network-process"), subfeatures);
- }
-
 #if defined (DARWIN_OS)
   /* PTYs are broken on Darwin < 6, but are sometimes useful for interactive
      processes.  As such, we only change the default value.  */
@@ -7330,6 +7562,7 @@ syms_of_process (void)
   DEFSYM (Qreal, "real");
   DEFSYM (Qnetwork, "network");
   DEFSYM (Qserial, "serial");
+  DEFSYM (Qpipe, "pipe");
   DEFSYM (QCbuffer, ":buffer");
   DEFSYM (QChost, ":host");
   DEFSYM (QCservice, ":service");
@@ -7346,6 +7579,7 @@ syms_of_process (void)
   DEFSYM (QCplist, ":plist");
   DEFSYM (QCcommand, ":command");
   DEFSYM (QCconnection_type, ":connection-type");
+  DEFSYM (QCstderr, ":stderr");
   DEFSYM (Qpty, "pty");
   DEFSYM (Qpipe, "pipe");
 
@@ -7451,6 +7685,7 @@ The variable takes effect when `start-process' is called.  */);
   defsubr (&Sset_process_plist);
   defsubr (&Sprocess_list);
   defsubr (&Smake_process);
+  defsubr (&Smake_pipe_process);
   defsubr (&Sserial_process_configure);
   defsubr (&Smake_serial_process);
   defsubr (&Sset_network_process_option);
@@ -7488,4 +7723,39 @@ The variable takes effect when `start-process' is called.  */);
   defsubr (&Sprocess_inherit_coding_system_flag);
   defsubr (&Slist_system_processes);
   defsubr (&Sprocess_attributes);
+
+ {
+   Lisp_Object subfeatures = Qnil;
+   const struct socket_options *sopt;
+
+#define ADD_SUBFEATURE(key, val) \
+  subfeatures = pure_cons (pure_cons (key, pure_cons (val, Qnil)), subfeatures)
+
+#ifdef NON_BLOCKING_CONNECT
+   ADD_SUBFEATURE (QCnowait, Qt);
+#endif
+#ifdef DATAGRAM_SOCKETS
+   ADD_SUBFEATURE (QCtype, Qdatagram);
+#endif
+#ifdef HAVE_SEQPACKET
+   ADD_SUBFEATURE (QCtype, Qseqpacket);
+#endif
+#ifdef HAVE_LOCAL_SOCKETS
+   ADD_SUBFEATURE (QCfamily, Qlocal);
+#endif
+   ADD_SUBFEATURE (QCfamily, Qipv4);
+#ifdef AF_INET6
+   ADD_SUBFEATURE (QCfamily, Qipv6);
+#endif
+#ifdef HAVE_GETSOCKNAME
+   ADD_SUBFEATURE (QCservice, Qt);
+#endif
+   ADD_SUBFEATURE (QCserver, Qt);
+
+   for (sopt = socket_options; sopt->name; sopt++)
+     subfeatures = pure_cons (intern_c_string (sopt->name), subfeatures);
+
+   Fprovide (intern_c_string ("make-network-process"), subfeatures);
+ }
+
 }
diff --git a/src/process.h b/src/process.h
index 36979dcac9e..e889055dc23 100644
--- a/src/process.h
+++ b/src/process.h
@@ -105,6 +105,9 @@ struct Lisp_Process
     Lisp_Object gnutls_cred_type;
 #endif
 
+    /* Pipe process attached to the standard error of this process.  */
+    Lisp_Object stderrproc;
+
     /* After this point, there are no Lisp_Objects any more.  */
     /* alloc.c assumes that `pid' is the first such non-Lisp slot.  */
 
diff --git a/src/regex.c b/src/regex.c
index 1afc5037594..38c5e350541 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -313,12 +313,12 @@ enum syntaxcode { Swhitespace = 0, Sword = 1, Ssymbol = 2 };
 /* The rest must handle multibyte characters.  */
 
 # define ISGRAPH(c) (SINGLE_BYTE_CHAR_P (c)                             \
-                    ? (c) > ' ' && !((c) >= 0177 && (c) <= 0237)        \
-                    : 1)
+                     ? (c) > ' ' && !((c) >= 0177 && (c) <= 0240)       \
+                     : graphicp (c))
 
 # define ISPRINT(c) (SINGLE_BYTE_CHAR_P (c)                             \
                     ? (c) >= ' ' && !((c) >= 0177 && (c) <= 0237)       \
-                    : 1)
+                     : printablep (c))
 
 # define ISALNUM(c) (IS_REAL_ASCII (c)                  \
                     ? (((c) >= 'a' && (c) <= 'z')       \
@@ -1865,7 +1865,8 @@ struct range_table_work_area
 #define RANGE_TABLE_WORK_ELT(work_area, i) ((work_area).table[i])
 
 /* Bits used to implement the multibyte-part of the various character classes
-   such as [:alnum:] in a charset's range table.  */
+   such as [:alnum:] in a charset's range table.  The code currently assumes
+   that only the low 16 bits are used.  */
 #define BIT_WORD        0x1
 #define BIT_LOWER       0x2
 #define BIT_PUNCT       0x4
@@ -1874,6 +1875,8 @@ struct range_table_work_area
 #define BIT_MULTIBYTE   0x20
 #define BIT_ALPHA       0x40
 #define BIT_ALNUM       0x80
+#define BIT_GRAPH       0x100
+#define BIT_PRINT       0x200
 
 
 /* Set the bit for character C in a list.  */
@@ -2072,7 +2075,7 @@ re_wctype_to_bit (re_wctype_t cc)
 {
   switch (cc)
     {
-    case RECC_NONASCII: case RECC_PRINT: case RECC_GRAPH:
+    case RECC_NONASCII:
     case RECC_MULTIBYTE: return BIT_MULTIBYTE;
     case RECC_ALPHA: return BIT_ALPHA;
     case RECC_ALNUM: return BIT_ALNUM;
@@ -2081,6 +2084,8 @@ re_wctype_to_bit (re_wctype_t cc)
     case RECC_UPPER: return BIT_UPPER;
     case RECC_PUNCT: return BIT_PUNCT;
     case RECC_SPACE: return BIT_SPACE;
+    case RECC_GRAPH: return BIT_GRAPH;
+    case RECC_PRINT: return BIT_PRINT;
     case RECC_ASCII: case RECC_DIGIT: case RECC_XDIGIT: case RECC_CNTRL:
     case RECC_BLANK: case RECC_UNIBYTE: case RECC_ERROR: return 0;
     default:
@@ -5519,7 +5524,9 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const_re_char *string1,
                     | (class_bits & BIT_UPPER && ISUPPER (c))
                     | (class_bits & BIT_WORD  && ISWORD  (c))
                     | (class_bits & BIT_ALPHA && ISALPHA (c))
-                    | (class_bits & BIT_ALNUM && ISALNUM (c)))
+                    | (class_bits & BIT_ALNUM && ISALNUM (c))
+                    | (class_bits & BIT_GRAPH && ISGRAPH (c))
+                    | (class_bits & BIT_PRINT && ISPRINT (c)))
                   not = !not;
                 else
                   CHARSET_LOOKUP_RANGE_TABLE_RAW (not, c, range_table, count);
diff --git a/src/term.c b/src/term.c
index 15d33b4e3ee..d2a9c3d1f30 100644
--- a/src/term.c
+++ b/src/term.c
@@ -1862,9 +1862,11 @@ produce_glyphless_glyph (struct it *it, Lisp_Object acronym)
       else
         {
           eassert (it->glyphless_method == GLYPHLESS_DISPLAY_HEX_CODE);
-          len = (it->c < 0x10000 ? sprintf (buf, "\\u%04X", it->c)
-                 : it->c <= MAX_UNICODE_CHAR ? sprintf (buf, "\\U%06X", it->c)
-                 : sprintf (buf, "\\x%06X", it->c));
+          len = sprintf (buf,
+                         (it->c < 0x10000 ? "\\u%04X"
+                          : it->c <= MAX_UNICODE_CHAR ? "\\U%06X"
+                          : "\\x%06X"),
+                         it->c + 0u);
         }
       str = buf;
     }
diff --git a/src/textprop.c b/src/textprop.c
index 740b96227cf..0a591d0e05f 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -52,8 +52,8 @@ enum property_set_type
   TEXT_PROPERTY_APPEND
 };
 
-/* If o1 is a cons whose cdr is a cons, return non-zero and set o2 to
-   the o1's cdr.  Otherwise, return zero.  This is handy for
+/* If o1 is a cons whose cdr is a cons, return true and set o2 to
+   the o1's cdr.  Otherwise, return false.  This is handy for
    traversing plists.  */
 #define PLIST_ELT_P(o1, o2) (CONSP (o1) && ((o2)=XCDR (o1), CONSP (o2)))
 
@@ -123,13 +123,12 @@ CHECK_STRING_OR_BUFFER (Lisp_Object x)
    Fprevious_property_change which call this function with BEGIN == END.
    Handle this case specially.
 
-   If FORCE is soft (0), it's OK to return NULL.  Otherwise,
+   If FORCE is soft (false), it's OK to return NULL.  Otherwise,
    create an interval tree for OBJECT if one doesn't exist, provided
    the object actually contains text.  In the current design, if there
    is no text, there can be no text properties.  */
 
-#define soft 0
-#define hard 1
+enum { soft = false, hard = true };
 
 INTERVAL
 validate_interval_range (Lisp_Object object, Lisp_Object *begin,
@@ -206,15 +205,17 @@ validate_plist (Lisp_Object list)
 
   if (CONSP (list))
     {
-      bool odd_length = 0;
-      Lisp_Object tail;
-      for (tail = list; CONSP (tail); tail = XCDR (tail))
+      Lisp_Object tail = list;
+      do
         {
-          odd_length ^= 1;
+          tail = XCDR (tail);
+          if (! CONSP (tail))
+            error ("Odd length text property list");
+          tail = XCDR (tail);
           QUIT;
         }
-      if (odd_length)
-        error ("Odd length text property list");
+      while (CONSP (tail));
+
       return list;
     }
 
@@ -233,27 +234,27 @@ interval_has_all_properties (Lisp_Object plist, INTERVAL i)
   for (tail1 = plist; CONSP (tail1); tail1 = Fcdr (XCDR (tail1)))
     {
       Lisp_Object sym1 = XCAR (tail1);
-      bool found = 0;
+      bool found = false;
 
       /* Go through I's plist, looking for sym1 */
       for (tail2 = i->plist; CONSP (tail2); tail2 = Fcdr (XCDR (tail2)))
         if (EQ (sym1, XCAR (tail2)))
           {
             /* Found the same property on both lists.  If the
-               values are unequal, return zero.  */
+               values are unequal, return false.  */
             if (! EQ (Fcar (XCDR (tail1)), Fcar (XCDR (tail2))))
-              return 0;
+              return false;
 
             /* Property has same value on both lists; go to next one.  */
-            found = 1;
+            found = true;
             break;
           }
 
       if (! found)
-        return 0;
+        return false;
     }
 
-  return 1;
+  return true;
 }
 
 /* Return true if the plist of interval I has any of the
@@ -272,13 +273,13 @@ interval_has_some_properties (Lisp_Object plist, INTERVAL i)
       /* Go through i's plist, looking for tail1 */
       for (tail2 = i->plist; CONSP (tail2); tail2 = Fcdr (XCDR (tail2)))
         if (EQ (sym, XCAR (tail2)))
-          return 1;
+          return true;
     }
 
-  return 0;
+  return false;
 }
 
-/* Return nonzero if the plist of interval I has any of the
+/* Return true if the plist of interval I has any of the
    property names in LIST, regardless of their values.  */
 
 static bool
@@ -294,10 +295,10 @@ interval_has_some_properties_list (Lisp_Object list, INTERVAL i)
       /* Go through i's plist, looking for tail1 */
       for (tail2 = i->plist; CONSP (tail2); tail2 = XCDR (XCDR (tail2)))
         if (EQ (sym, XCAR (tail2)))
-          return 1;
+          return true;
     }
 
-  return 0;
+  return false;
 }
 
 /* Changing the plists of individual intervals.  */
@@ -373,7 +374,7 @@ add_properties (Lisp_Object plist, INTERVAL i, Lisp_Object object,
                 enum property_set_type set_type)
 {
   Lisp_Object tail1, tail2, sym1, val1;
-  bool changed = 0;
+  bool changed = false;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
   tail1 = plist;
@@ -387,7 +388,7 @@ add_properties (Lisp_Object plist, INTERVAL i, Lisp_Object object,
   /* Go through each element of PLIST.  */
   for (tail1 = plist; CONSP (tail1); tail1 = Fcdr (XCDR (tail1)))
     {
-      bool found = 0;
+      bool found = false;
       sym1 = XCAR (tail1);
       val1 = Fcar (XCDR (tail1));
 
@@ -401,7 +402,7 @@ add_properties (Lisp_Object plist, INTERVAL i, Lisp_Object object,
 
             this_cdr = XCDR (tail2);
             /* Found the property.  Now check its value.  */
-            found = 1;
+            found = true;
 
             /* The properties have the same value on both lists.
                Continue to the next property.  */
@@ -438,7 +439,7 @@ add_properties (Lisp_Object plist, INTERVAL i, Lisp_Object object,
                   Fsetcar (this_cdr, list2 (Fcar (this_cdr), val1));
               }
             }
-            changed = 1;
+            changed = true;
             break;
           }
 
@@ -451,7 +452,7 @@ add_properties (Lisp_Object plist, INTERVAL i, Lisp_Object object,
                                       sym1, Qnil, object);
             }
           set_interval_plist (i, Fcons (sym1, Fcons (val1, i->plist)));
-          changed = 1;
+          changed = true;
         }
     }
 
@@ -468,23 +469,18 @@ add_properties (Lisp_Object plist, INTERVAL i, Lisp_Object object,
 static bool
 remove_properties (Lisp_Object plist, Lisp_Object list, INTERVAL i, Lisp_Object object)
 {
-  Lisp_Object tail1, tail2, sym, current_plist;
-  bool changed = 0;
+  bool changed = false;
 
   /* True means tail1 is a plist, otherwise it is a list.  */
-  bool use_plist;
+  bool use_plist = ! NILP (plist);
+  Lisp_Object tail1 = use_plist ? plist : list;
 
-  current_plist = i->plist;
-
-  if (! NILP (plist))
-    tail1 = plist, use_plist = 1;
-  else
-    tail1 = list, use_plist = 0;
+  Lisp_Object current_plist = i->plist;
 
   /* Go through each element of LIST or PLIST.  */
   while (CONSP (tail1))
     {
-      sym = XCAR (tail1);
+      Lisp_Object sym = XCAR (tail1);
 
       /* First, remove the symbol if it's at the head of the list */
       while (CONSP (current_plist) && EQ (sym, XCAR (current_plist)))
@@ -495,15 +491,14 @@ remove_properties (Lisp_Object plist, Lisp_Object list, INTERVAL i, Lisp_Object
                                     object);
 
           current_plist = XCDR (XCDR (current_plist));
-          changed = 1;
+          changed = true;
         }
 
       /* Go through I's plist, looking for SYM.  */
-      tail2 = current_plist;
+      Lisp_Object tail2 = current_plist;
       while (! NILP (tail2))
         {
-          register Lisp_Object this;
-          this = XCDR (XCDR (tail2));
+          Lisp_Object this = XCDR (XCDR (tail2));
           if (CONSP (this) && EQ (sym, XCAR (this)))
             {
               if (BUFFERP (object))
@@ -511,7 +506,7 @@ remove_properties (Lisp_Object plist, Lisp_Object list, INTERVAL i, Lisp_Object
                                         sym, XCAR (XCDR (this)), object);
 
               Fsetcdr (XCDR (tail2), XCDR (XCDR (this)));
-              changed = 1;
+              changed = true;
             }
           tail2 = this;
         }
@@ -643,7 +638,7 @@ get_char_property_and_overlay (Lisp_Object position, register Lisp_Object prop,
       set_buffer_temp (XBUFFER (object));
 
       USE_SAFE_ALLOCA;
-      GET_OVERLAYS_AT (XINT (position), overlay_vec, noverlays, NULL, 0);
+      GET_OVERLAYS_AT (XINT (position), overlay_vec, noverlays, NULL, false);
       noverlays = sort_overlays (overlay_vec, noverlays, w);
 
       set_buffer_temp (obuf);
@@ -716,11 +711,12 @@ DEFUN ("next-char-property-change", Fnext_char_property_change,
 This scans characters forward in the current buffer from POSITION till
 it finds a change in some text property, or the beginning or end of an
 overlay, and returns the position of that.
-If none is found up to (point-max), the function returns (point-max).
+If none is found, and LIMIT is nil or omitted, the function
+returns (point-max).
 
-If the optional second argument LIMIT is non-nil, don't search
-past position LIMIT; return LIMIT if nothing is found before LIMIT.
-LIMIT is a no-op if it is greater than (point-max).  */)
+If the optional second argument LIMIT is non-nil, the function doesn't
+search past position LIMIT, and returns LIMIT if nothing is found
+before LIMIT.  LIMIT is a no-op if it is greater than (point-max).  */)
   (Lisp_Object position, Lisp_Object limit)
 {
   Lisp_Object temp;
@@ -741,11 +737,12 @@ DEFUN ("previous-char-property-change", Fprevious_char_property_change,
 Scans characters backward in the current buffer from POSITION till it
 finds a change in some text property, or the beginning or end of an
 overlay, and returns the position of that.
-If none is found since (point-min), the function returns (point-min).
+If none is found, and LIMIT is nil or omitted, the function
+returns (point-min).
 
-If the optional second argument LIMIT is non-nil, don't search
-past position LIMIT; return LIMIT if nothing is found before LIMIT.
-LIMIT is a no-op if it is less than (point-min).  */)
+If the optional second argument LIMIT is non-nil, the function doesn't
+search before position LIMIT, and returns LIMIT if nothing is found
+before LIMIT.  LIMIT is a no-op if it is less than (point-min).  */)
   (Lisp_Object position, Lisp_Object limit)
 {
   Lisp_Object temp;
@@ -770,14 +767,15 @@ If the optional third argument OBJECT is a buffer (or nil, which means
 the current buffer), POSITION is a buffer position (integer or marker).
 If OBJECT is a string, POSITION is a 0-based index into it.
 
-In a string, scan runs to the end of the string.
-In a buffer, it runs to (point-max), and the value cannot exceed that.
+In a string, scan runs to the end of the string, unless LIMIT is non-nil.
+In a buffer, if LIMIT is nil or omitted, it runs to (point-max), and the
+value cannot exceed that.
+If the optional fourth argument LIMIT is non-nil, don't search
+past position LIMIT; return LIMIT if nothing is found before LIMIT.
 
 The property values are compared with `eq'.
 If the property is constant all the way to the end of OBJECT, return the
-last valid position in OBJECT.
-If the optional fourth argument LIMIT is non-nil, don't search
-past position LIMIT; return LIMIT if nothing is found before LIMIT.  */)
+last valid position in OBJECT.  */)
   (Lisp_Object position, Lisp_Object prop, Lisp_Object object, Lisp_Object limit)
 {
   if (STRINGP (object))
@@ -824,7 +822,7 @@ past position LIMIT; return LIMIT if nothing is found before LIMIT.  */)
             XSETFASTINT (position, ZV);
         }
       else
-        while (1)
+        while (true)
           {
             position = Fnext_char_property_change (position, limit);
             if (XFASTINT (position) >= XFASTINT (limit))
@@ -854,14 +852,15 @@ If the optional third argument OBJECT is a buffer (or nil, which means
 the current buffer), POSITION is a buffer position (integer or marker).
 If OBJECT is a string, POSITION is a 0-based index into it.
 
-In a string, scan runs to the start of the string.
-In a buffer, it runs to (point-min), and the value cannot be less than that.
+In a string, scan runs to the start of the string, unless LIMIT is non-nil.
+In a buffer, if LIMIT is nil or omitted, it runs to (point-min), and the
+value cannot be less than that.
+If the optional fourth argument LIMIT is non-nil, don't search back past
+position LIMIT; return LIMIT if nothing is found before reaching LIMIT.
 
 The property values are compared with `eq'.
 If the property is constant all the way to the start of OBJECT, return the
-first valid position in OBJECT.
-If the optional fourth argument LIMIT is non-nil, don't search back past
-position LIMIT; return LIMIT if nothing is found before reaching LIMIT.  */)
+first valid position in OBJECT.  */)
   (Lisp_Object position, Lisp_Object prop, Lisp_Object object, Lisp_Object limit)
 {
   if (STRINGP (object))
@@ -910,7 +909,7 @@ position LIMIT; return LIMIT if nothing is found before reaching LIMIT.  */)
             = Fget_char_property (make_number (XFASTINT (position) - 1),
                                   prop, object);
 
-          while (1)
+          while (true)
             {
               position = Fprevious_char_property_change (position, limit);
 
@@ -945,8 +944,9 @@ a change in some text property, then returns the position of the change.
 If the optional second argument OBJECT is a buffer (or nil, which means
 the current buffer), POSITION is a buffer position (integer or marker).
 If OBJECT is a string, POSITION is a 0-based index into it.
-Return nil if the property is constant all the way to the end of OBJECT.
-If the value is non-nil, it is a position greater than POSITION, never equal.
+Return nil if LIMIT is nil or omitted, and the property is constant all
+the way to the end of OBJECT; if the value is non-nil, it is a position
+greater than POSITION, never equal.
 
 If the optional third argument LIMIT is non-nil, don't search
 past position LIMIT; return LIMIT if nothing is found before LIMIT.  */)
@@ -1010,8 +1010,9 @@ If the optional third argument OBJECT is a buffer (or nil, which means
 the current buffer), POSITION is a buffer position (integer or marker).
 If OBJECT is a string, POSITION is a 0-based index into it.
 The property values are compared with `eq'.
-Return nil if the property is constant all the way to the end of OBJECT.
-If the value is non-nil, it is a position greater than POSITION, never equal.
+Return nil if LIMIT is nil or omitted, and the property is constant all
+the way to the end of OBJECT; if the value is non-nil, it is a position
+greater than POSITION, never equal.
 
 If the optional fourth argument LIMIT is non-nil, don't search
 past position LIMIT; return LIMIT if nothing is found before LIMIT.  */)
@@ -1057,8 +1058,9 @@ a change in some text property, then returns the position of the change.
 If the optional second argument OBJECT is a buffer (or nil, which means
 the current buffer), POSITION is a buffer position (integer or marker).
 If OBJECT is a string, POSITION is a 0-based index into it.
-Return nil if the property is constant all the way to the start of OBJECT.
-If the value is non-nil, it is a position less than POSITION, never equal.
+Return nil if LIMIT is nil or omitted, and the property is constant all
+the way to the start of OBJECT; if the value is non-nil, it is a position
+less than POSITION, never equal.
 
 If the optional third argument LIMIT is non-nil, don't search
 back past position LIMIT; return LIMIT if nothing is found until LIMIT.  */)
@@ -1105,8 +1107,9 @@ If the optional third argument OBJECT is a buffer (or nil, which means
 the current buffer), POSITION is a buffer position (integer or marker).
 If OBJECT is a string, POSITION is a 0-based index into it.
 The property values are compared with `eq'.
-Return nil if the property is constant all the way to the start of OBJECT.
-If the value is non-nil, it is a position less than POSITION, never equal.
+Return nil if LIMIT is nil or omitted, and the property is constant all
+the way to the start of OBJECT; if the value is non-nil, it is a position
+less than POSITION, never equal.
 
 If the optional fourth argument LIMIT is non-nil, don't search
 back past position LIMIT; return LIMIT if nothing is found until LIMIT.  */)
@@ -1156,9 +1159,9 @@ add_text_properties_1 (Lisp_Object start, Lisp_Object end,
                        enum property_set_type set_type) {
   INTERVAL i, unchanged;
   ptrdiff_t s, len;
-  bool modified = 0;
+  bool modified = false;
   struct gcpro gcpro1;
-  bool first_time = 1;
+  bool first_time = true;
 
   properties = validate_plist (properties);
   if (NILP (properties))
@@ -1218,7 +1221,7 @@ add_text_properties_1 (Lisp_Object start, Lisp_Object end,
       if (TOTAL_LENGTH (i) != prev_total_length
           || i->position != prev_pos)
         {
-          first_time = 0;
+          first_time = false;
           goto retry;
         }
     }
@@ -1521,8 +1524,8 @@ Use `set-text-properties' if you want to remove all text properties.  */)
 {
   INTERVAL i, unchanged;
   ptrdiff_t s, len;
-  bool modified = 0;
-  bool first_time = 1;
+  bool modified = false;
+  bool first_time = true;
 
   if (NILP (object))
     XSETBUFFER (object, current_buffer);
@@ -1574,7 +1577,7 @@ Use `set-text-properties' if you want to remove all text properties.  */)
       if (TOTAL_LENGTH (i) != prev_total_length
           || i->position != prev_pos)
         {
-          first_time = 0;
+          first_time = false;
           goto retry;
         }
     }
@@ -1633,7 +1636,7 @@ Return t if any property was actually removed, nil otherwise.  */)
 {
   INTERVAL i, unchanged;
   ptrdiff_t s, len;
-  bool modified = 0;
+  bool modified = false;
   Lisp_Object properties;
   properties = list_of_properties;
 
@@ -1672,11 +1675,11 @@ Return t if any property was actually removed, nil otherwise.  */)
     }
 
   /* We are at the beginning of an interval, with len to scan.
-     The flag `modified' records if changes have been made.
+     The flag MODIFIED records if changes have been made.
      When object is a buffer, we must call modify_text_properties
      before changes are made and signal_after_change when we are done.
-     We call modify_text_properties before calling remove_properties if modified == 0,
-     and we call signal_after_change before returning if modified != 0. */
+     Call modify_text_properties before calling remove_properties if !MODIFIED,
+     and call signal_after_change before returning if MODIFIED. */
   for (;;)
     {
       eassert (i != 0);
@@ -1725,7 +1728,7 @@ Return t if any property was actually removed, nil otherwise.  */)
           if (!modified && BUFFERP (object))
             modify_text_properties (object, start, end);
           remove_properties (Qnil, properties, i, object);
-          modified = 1;
+          modified = true;
         }
       len -= LENGTH (i);
       i = next_interval (i);
@@ -1902,7 +1905,7 @@ copy_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object src,
   Lisp_Object stuff;
   Lisp_Object plist;
   ptrdiff_t s, e, e2, p, len;
-  bool modified = 0;
+  bool modified = false;
   struct gcpro gcpro1, gcpro2;
 
   i = validate_interval_range (src, &start, &end, soft);
@@ -1969,7 +1972,7 @@ copy_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object src,
       res = Fadd_text_properties (Fcar (res), Fcar (Fcdr (res)),
                                   Fcar (Fcdr (Fcdr (res))), dest);
       if (! NILP (res))
-        modified = 1;
+        modified = true;
       stuff = Fcdr (stuff);
     }
 
diff --git a/src/tparam.c b/src/tparam.c
index 538f26c83b6..02047db2095 100644
--- a/src/tparam.c
+++ b/src/tparam.c
@@ -79,14 +79,14 @@ tparam1 (const char *string, char *outstring, int len,
   register int tem;
   int *old_argp = argp;                 /* can move */
   int *fixed_argp = argp;               /* never moves */
-  bool explicit_param_p = 0;            /* set by %p */
+  bool explicit_param_p = false;        /* set by %p */
   ptrdiff_t doleft = 0;
   ptrdiff_t doup = 0;
   ptrdiff_t append_len = 0;
 
   outend = outstring + len;
 
-  while (1)
+  while (true)
     {
       /* If the buffer might be too short, make it bigger.  */
       while (outend - op - append_len <= 5)
@@ -115,7 +115,7 @@ tparam1 (const char *string, char *outstring, int len,
         {
           c = *p++;
           if (explicit_param_p)
-            explicit_param_p = 0;
+            explicit_param_p = false;
           else
             tem = *argp;
           switch (c)
@@ -142,7 +142,7 @@ tparam1 (const char *string, char *outstring, int len,
               break;
             case 'p':           /* %pN means use param N for next subst.  */
               tem = fixed_argp[(*p++) - '1'];
-              explicit_param_p = 1;
+              explicit_param_p = true;
               break;
             case 'C':
               /* For c-100: print quotient of value by 96, if nonzero,
diff --git a/src/undo.c b/src/undo.c
index 948dcf9ec1a..750bc8afff2 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -212,7 +212,7 @@ record_delete (ptrdiff_t beg, Lisp_Object string, bool record_markers)
 void
 record_change (ptrdiff_t beg, ptrdiff_t length)
 {
-  record_delete (beg, make_buffer_string (beg, beg + length, 1), false);
+  record_delete (beg, make_buffer_string (beg, beg + length, true), false);
   record_insert (beg, length);
 }
 
@@ -250,7 +250,7 @@ record_property_change (ptrdiff_t beg, ptrdiff_t length,
 {
   Lisp_Object lbeg, lend, entry;
   struct buffer *obuf = current_buffer, *buf = XBUFFER (buffer);
-  bool boundary = 0;
+  bool boundary = false;
 
   if (EQ (BVAR (buf, undo_list), Qt))
     return;
@@ -260,7 +260,7 @@ record_property_change (ptrdiff_t beg, ptrdiff_t length,
     pending_boundary = Fcons (Qnil, Qnil);
 
   if (buf != last_undo_buffer)
-    boundary = 1;
+    boundary = true;
   last_undo_buffer = buf;
 
   /* Switch temporarily to the buffer that was changed.  */
@@ -519,5 +519,5 @@ so it must make sure not to do a lot of consing.  */);
 
   DEFVAR_BOOL ("undo-inhibit-record-point", undo_inhibit_record_point,
                doc: /* Non-nil means do not record `point' in `buffer-undo-list'.  */);
-  undo_inhibit_record_point = 0;
+  undo_inhibit_record_point = false;
 }
diff --git a/src/w32.c b/src/w32.c
index 6f16704909c..8721ed919fc 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -9473,6 +9473,26 @@ serial_configure (struct Lisp_Process *p, Lisp_Object contact)
   pset_childp (p, childp2);
 }
 
+/* For make-pipe-process */
+void
+register_aux_fd (int infd)
+{
+  child_process *cp;
+
+  cp = new_child ();
+  if (!cp)
+    error ("Could not create child process");
+  cp->fd = infd;
+  cp->status = STATUS_READ_ACKNOWLEDGED;
+
+  if (fd_info[ infd ].cp != NULL)
+    {
+      error ("fd_info[fd = %d] is already in use", infd);
+    }
+  fd_info[ infd ].cp = cp;
+  fd_info[ infd ].hnd = (HANDLE) _get_osfhandle (infd);
+}
+
 #ifdef HAVE_GNUTLS
 
 ssize_t
diff --git a/src/w32.h b/src/w32.h
index 9b3521d077f..e62b93c8e2b 100644
--- a/src/w32.h
+++ b/src/w32.h
@@ -202,6 +202,7 @@ extern int random (void);
 extern int fchmod (int, mode_t);
 extern int sys_rename_replace (char const *, char const *, BOOL);
 extern int pipe2 (int *, int);
+extern void register_aux_fd (int);
 
 extern void set_process_dir (char *);
 extern int sys_spawnve (int, char *, char **, char **);
diff --git a/src/w32fns.c b/src/w32fns.c
index 6abb433fd2f..b9d7bd4d75b 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -29,6 +29,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <fcntl.h>
 #include <unistd.h>
 
+#include <c-ctype.h>
+
 #include "lisp.h"
 #include "w32term.h"
 #include "frame.h"
@@ -7038,7 +7040,28 @@ a ShowWindow flag:
 
 #else  /* !CYGWIN */
 
-  current_dir = ENCODE_FILE (current_dir);
+  const char file_url_str[] = "file:///";
+  const int file_url_len = sizeof (file_url_str) - 1;
+  if (strncmp (SSDATA (document), file_url_str, file_url_len) == 0)
+    {
+      /* Passing "file:///" URLs to ShellExecute causes shlwapi.dll to
+         start a thread in some rare system configurations, for
+         unknown reasons.  That thread is started in the context of
+         the Emacs process, but out of control of our code, and seems
+         to never exit afterwards.  Each such thread reserves 8MB of
+         stack space (because that's the value recorded in the Emacs
+         executable at link time: Emacs needs a large stack).  So a
+         large enough number of invocations of w32-shell-execute can
+         potentially cause the Emacs process to run out of available
+         address space, which is nasty.  To work around this, we
+         convert such URLs to local file names, which seems to prevent
+         those threads from starting.  See bug #20220.  */
+      char *p = SSDATA (document) + file_url_len;
+
+      if (c_isalpha (*p) && p[1] == ':' && IS_DIRECTORY_SEP (p[2]))
+        document = Fsubstring_no_properties (document,
+                                             make_number (file_url_len), Qnil);
+    }
   /* We have a situation here.  If DOCUMENT is a relative file name,
      but its name includes leading directories, i.e. it lives not in
      CURRENT_DIR, but in its subdirectory, then ShellExecute below
@@ -7071,6 +7094,8 @@ a ShowWindow flag:
   else
     document = ENCODE_FILE (document);
   UNGCPRO;
+
+  current_dir = ENCODE_FILE (current_dir);
   if (use_unicode)
     {
       wchar_t document_w[MAX_PATH], current_dir_w[MAX_PATH];
diff --git a/src/w32proc.c b/src/w32proc.c
index 7d982f831e2..1f633d834c2 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -806,7 +806,7 @@ alarm (int seconds)
    etc.
 
    Both these arrays reference each other: there's a member of
-   child_process structure that records the file corresponding
+   child_process structure that records the corresponding file
    descriptor, and there's a member of filedesc structure that holds a
    pointer to the corresponding child_process.
 
@@ -817,13 +817,13 @@ alarm (int seconds)
    thread" that will watch the output of the subprocess/stream and its
    status.  (If no vacant slot can be found, new_child returns a
    failure indication to its caller, and the higher-level Emacs
-   primitive will then fail with EMFILE or EAGAIN.)
+   primitive that called it will then fail with EMFILE or EAGAIN.)
 
    The reader thread started by new_child communicates with the main
    (a.k.a. "Lisp") thread via two event objects and a status, all of
    them recorded by the members of the child_process structure in
    child_procs[].  The event objects serve as semaphores between the
-   reader thread and the 'select' emulation in sys_select, as follows:
+   reader thread and the 'pselect' emulation in sys_select, as follows:
 
      . Initially, the reader thread is waiting for the char_consumed
        event to become signaled by sys_select, which is an indication
@@ -841,8 +841,8 @@ alarm (int seconds)
 
    When the subprocess exits or the network/serial stream is closed,
    the reader thread sets the status accordingly and exits.  It also
-   exits when the main thread sets the ststus to STATUS_READ_ERROR
-   and/or the char_avail and char_consumed event handles are NULL;
+   exits when the main thread sets the status to STATUS_READ_ERROR
+   and/or the char_avail and char_consumed event handles become NULL;
    this is how delete_child, called by Emacs when a subprocess or a
    stream is terminated, terminates the reader thread as part of
    deleting the child_process object.
@@ -863,8 +863,8 @@ alarm (int seconds)
 
    If file descriptor zero (stdin) doesn't have its bit set in the
    'rfds' argument to sys_select, the function always watches for
-   keyboard interrupts, to be able to return when the user presses
-   C-g.
+   keyboard interrupts, to be able to interrupt the wait and return
+   when the user presses C-g.
 
    Having collected the handles to watch, sys_select calls
    WaitForMultipleObjects to wait for any one of them to become
@@ -1613,24 +1613,25 @@ w32_executable_type (char * filename,
 #endif
           if (data_dir)
             {
-              /* Look for cygwin.dll in DLL import list. */
+              /* Look for Cygwin DLL in the DLL import list. */
               IMAGE_DATA_DIRECTORY import_dir =
                 data_dir[IMAGE_DIRECTORY_ENTRY_IMPORT];
-              IMAGE_IMPORT_DESCRIPTOR * imports;
-              IMAGE_SECTION_HEADER * section;
-
-              section = rva_to_section (import_dir.VirtualAddress, nt_header);
-              imports = RVA_TO_PTR (import_dir.VirtualAddress, section,
-                                    executable);
+              IMAGE_IMPORT_DESCRIPTOR * imports =
+                RVA_TO_PTR (import_dir.VirtualAddress,
+                            rva_to_section (import_dir.VirtualAddress,
+                                            nt_header),
+                            executable);
 
               for ( ; imports->Name; imports++)
                 {
+                  IMAGE_SECTION_HEADER * section =
+                    rva_to_section (imports->Name, nt_header);
                   char * dllname = RVA_TO_PTR (imports->Name, section,
                                                executable);
 
-                  /* The exact name of the cygwin dll has changed with
-                     various releases, but hopefully this will be reasonably
-                     future proof.  */
+                  /* The exact name of the Cygwin DLL has changed with
+                     various releases, but hopefully this will be
+                     reasonably future-proof.  */
                   if (strncmp (dllname, "cygwin", 6) == 0)
                     {
                       *is_cygnus_app = TRUE;
diff --git a/src/widget.c b/src/widget.c
index acf559f313b..0986ba61dbf 100644
--- a/src/widget.c
+++ b/src/widget.c
@@ -61,10 +61,7 @@ static void EmacsFrameResize (Widget widget);
 static XtGeometryResult EmacsFrameQueryGeometry (Widget widget, XtWidgetGeometry *request, XtWidgetGeometry *result);
 
 
-#undef XtOffset
-#define XtOffset(p_type,field) \
-        ((Cardinal) (((char *) (&(((p_type)0)->field))) - ((char *)0)))
-#define offset(field) XtOffset (EmacsFrame, emacs_frame.field)
+#define offset(field) offsetof (EmacsFrameRec, emacs_frame.field)
 
 static XtResource resources[] = {
   {XtNgeometry, XtCGeometry, XtRString, sizeof (String),
@@ -271,8 +268,8 @@ set_frame_size (EmacsFrame ew)
    */
 
   /* Hairily merged geometry */
-  unsigned int w = FRAME_COLS (ew->emacs_frame.frame);
-  unsigned int h = FRAME_LINES (ew->emacs_frame.frame);
+  int w = FRAME_COLS (ew->emacs_frame.frame);
+  int h = FRAME_LINES (ew->emacs_frame.frame);
 
   Widget wmshell = get_wm_shell ((Widget) ew);
   /* Each Emacs shell is now independent and top-level.  */
@@ -437,7 +434,7 @@ set_frame_size (EmacsFrame ew)
 static void
 update_wm_hints (EmacsFrame ew)
 {
-  Widget wmshell = get_wm_shell ((Widget)ew);
+  Widget wmshell = get_wm_shell ((Widget) ew);
   int cw;
   int ch;
   Dimension rounded_width;
@@ -480,7 +477,7 @@ update_wm_hints (EmacsFrame ew)
 void
 widget_update_wm_size_hints (Widget widget)
 {
-  EmacsFrame ew = (EmacsFrame)widget;
+  EmacsFrame ew = (EmacsFrame) widget;
   update_wm_hints (ew);
 }
 
@@ -519,7 +516,7 @@ update_from_various_frame_slots (EmacsFrame ew)
 static void
 EmacsFrameInitialize (Widget request, Widget new, ArgList dum1, Cardinal *dum2)
 {
-  EmacsFrame ew = (EmacsFrame)new;
+  EmacsFrame ew = (EmacsFrame) new;
 
   if (!ew->emacs_frame.frame)
     {
@@ -545,7 +542,7 @@ resize_cb (Widget widget,
 static void
 EmacsFrameRealize (Widget widget, XtValueMask *mask, XSetWindowAttributes *attrs)
 {
-  EmacsFrame ew = (EmacsFrame)widget;
+  EmacsFrame ew = (EmacsFrame) widget;
 
   /* This used to contain SubstructureRedirectMask, but this turns out
      to be a problem with XIM on Solaris, and events from that mask
@@ -554,7 +551,7 @@ EmacsFrameRealize (Widget widget, XtValueMask *mask, XSetWindowAttributes *attrs
                        | PropertyChangeMask
                        | SubstructureNotifyMask);
   *mask |= CWEventMask;
-  XtCreateWindow (widget, InputOutput, (Visual *)CopyFromParent, *mask,
+  XtCreateWindow (widget, InputOutput, (Visual *) CopyFromParent, *mask,
                   attrs);
   /* Some ConfigureNotify events does not end up in EmacsFrameResize so
      make sure we get them all.  Seen with xfcwm4 for example.  */
@@ -571,7 +568,7 @@ EmacsFrameDestroy (Widget widget)
 static void
 EmacsFrameResize (Widget widget)
 {
-  EmacsFrame ew = (EmacsFrame)widget;
+  EmacsFrame ew = (EmacsFrame) widget;
   struct frame *f = ew->emacs_frame.frame;
   int width, height;
 
@@ -592,7 +589,7 @@ EmacsFrameResize (Widget widget)
 static XtGeometryResult
 EmacsFrameQueryGeometry (Widget widget, XtWidgetGeometry *request, XtWidgetGeometry *result)
 {
-  EmacsFrame ew = (EmacsFrame)widget;
+  EmacsFrame ew = (EmacsFrame) widget;
 
   int mask = request->request_mode;
   Dimension ok_width, ok_height;
diff --git a/src/window.c b/src/window.c
index d59616d0545..0fcf82d43f4 100644
--- a/src/window.c
+++ b/src/window.c
@@ -45,28 +45,19 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "msdos.h"
 #endif
 
-static int displayed_window_lines (struct window *);
-static int count_windows (struct window *);
-static int get_leaf_windows (struct window *, struct window **, int);
-static void window_scroll (Lisp_Object, EMACS_INT, bool, int);
-static void window_scroll_pixel_based (Lisp_Object, int, bool, int);
-static void window_scroll_line_based (Lisp_Object, int, bool, int);
-static int add_window_to_list (struct window *, void *);
-static Lisp_Object next_window (Lisp_Object, Lisp_Object,
-                                Lisp_Object, int);
-static void decode_next_window_args (Lisp_Object *, Lisp_Object *,
-                                     Lisp_Object *);
+static ptrdiff_t count_windows (struct window *);
+static ptrdiff_t get_leaf_windows (struct window *, struct window **,
+                                   ptrdiff_t);
+static void window_scroll_pixel_based (Lisp_Object, int, bool, bool);
+static void window_scroll_line_based (Lisp_Object, int, bool, bool);
 static void foreach_window (struct frame *,
-                                 int (* fn) (struct window *, void *),
+                            bool (* fn) (struct window *, void *),
                             void *);
-static int foreach_window_1 (struct window *,
-                             int (* fn) (struct window *, void *),
-                             void *);
-static Lisp_Object window_list_1 (Lisp_Object, Lisp_Object, Lisp_Object);
-static int window_resize_check (struct window *, bool);
+static bool foreach_window_1 (struct window *,
+                              bool (* fn) (struct window *, void *),
+                              void *);
+static bool window_resize_check (struct window *, bool);
 static void window_resize_apply (struct window *, bool);
-static void window_resize_apply_total (struct window *, bool);
-static Lisp_Object select_window (Lisp_Object, Lisp_Object, int);
 static void select_window_1 (Lisp_Object, bool);
 
 static struct window *set_window_fringes (struct window *, Lisp_Object,
@@ -74,7 +65,8 @@ static struct window *set_window_fringes (struct window *, Lisp_Object,
 static struct window *set_window_margins (struct window *, Lisp_Object,
                                           Lisp_Object);
 static struct window *set_window_scroll_bars (struct window *, Lisp_Object,
-                                              Lisp_Object, Lisp_Object, Lisp_Object);
+                                              Lisp_Object, Lisp_Object,
+                                              Lisp_Object);
 static void apply_window_adjustment (struct window *);
 
 /* This is the window in which the terminal's cursor should
@@ -102,7 +94,7 @@ Lisp_Object minibuf_window;
 Lisp_Object minibuf_selected_window;
 
 /* Incremented for each window created.  */
-static int sequence_number;
+static EMACS_INT sequence_number;
 
 /* Used by the function window_scroll_pixel_based.  */
 static int window_scroll_pixel_based_preserve_x;
@@ -216,7 +208,7 @@ wset_combination (struct window *w, bool horflag, Lisp_Object val)
     w->horizontal = horflag;
 }
 
-/* Nonzero if leaf window W doesn't reflect the actual state
+/* True if leaf window W doesn't reflect the actual state
    of displayed buffer due to its text or overlays change.  */
 
 bool
@@ -279,7 +271,7 @@ adjust_window_count (struct window *w, int arg)
       b->window_count += arg;
       eassert (b->window_count >= 0);
       /* These should be recalculated by redisplay code.  */
-      w->window_end_valid = 0;
+      w->window_end_valid = false;
       w->base_line_pos = 0;
     }
 }
@@ -460,17 +452,18 @@ selected windows appears and to which many commands apply.  */)
   return selected_window;
 }
 
-int window_select_count;
+EMACS_INT window_select_count;
 
-/* If select_window is called with inhibit_point_swap non-zero it will
+/* If select_window is called with inhibit_point_swap true it will
    not store point of the old selected window's buffer back into that
    window's pointm slot.  This is needed by Fset_window_configuration to
    avoid that the display routine is called with selected_window set to
    Qnil causing a subsequent crash.  */
 static Lisp_Object
-select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
+select_window (Lisp_Object window, Lisp_Object norecord,
+               bool inhibit_point_swap)
 {
-  register struct window *w;
+  struct window *w;
   struct frame *sf;
 
   CHECK_LIVE_WINDOW (window);
@@ -577,9 +570,9 @@ time a window gets selected put it on `buffer-list-update-hook'.
 
 Also note that the main editor command loop sets the current buffer to
 the buffer of the selected window before each command.  */)
-  (register Lisp_Object window, Lisp_Object norecord)
+  (Lisp_Object window, Lisp_Object norecord)
 {
-  return select_window (window, norecord, 0);
+  return select_window (window, norecord, false);
 }
 
 DEFUN ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0,
@@ -930,11 +923,10 @@ window_body_width (struct window *w, bool pixelwise)
                - WINDOW_RIGHT_DIVIDER_WIDTH (w)
                - (WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
                   ? WINDOW_SCROLL_BAR_AREA_WIDTH (w)
-                  : ((!FRAME_WINDOW_P (f)
-                      && !WINDOW_RIGHTMOST_P (w)
-                      && !WINDOW_RIGHT_DIVIDER_WIDTH (w))
-                     /* A vertical bar is either 1 or 0.  */
-                     ? 1 : 0))
+                  : (/* A vertical bar is either 1 or 0.  */
+                     !FRAME_WINDOW_P (f)
+                     && !WINDOW_RIGHTMOST_P (w)
+                     && !WINDOW_RIGHT_DIVIDER_WIDTH (w)))
                 - WINDOW_MARGINS_WIDTH (w)
                 - (FRAME_WINDOW_P (f)
                    ? WINDOW_FRINGES_WIDTH (w)
@@ -961,7 +953,7 @@ visible, that line is not counted.  */)
   (Lisp_Object window, Lisp_Object pixelwise)
 {
   return make_number (window_body_height (decode_live_window (window),
-                                          NILP (pixelwise) ? 0 : 1));
+                                          !NILP (pixelwise)));
 }
 
 DEFUN ("window-body-width", Fwindow_body_width, Swindow_body_width, 0, 2, 0,
@@ -981,7 +973,7 @@ continuation glyph.  */)
   (Lisp_Object window, Lisp_Object pixelwise)
 {
   return make_number (window_body_width (decode_live_window (window),
-                                         NILP (pixelwise) ? 0 : 1));
+                                         !NILP (pixelwise)));
 }
 
 DEFUN ("window-mode-line-height", Fwindow_mode_line_height,
@@ -1062,10 +1054,10 @@ set_window_hscroll (struct window *w, EMACS_INT hscroll)
 
   /* Prevent redisplay shortcuts when changing the hscroll.  */
   if (w->hscroll != new_hscroll)
-    XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
+    XBUFFER (w->contents)->prevent_redisplay_optimizations_p = true;
 
   w->hscroll = new_hscroll;
-  w->suspend_auto_hscroll = 1;
+  w->suspend_auto_hscroll = true;
 
   return make_number (new_hscroll);
 }
@@ -1583,7 +1575,7 @@ If they are in the windows's left or right marginal areas, `left-margin'\n\
    Check if window W contains coordinates *CW->x and *CW->y.  If it
    does, return W in *CW->window, as Lisp_Object, and return in
    *CW->part the part of the window under coordinates *X,*Y.  Return
-   zero from this function to stop iterating over windows.  */
+   false from this function to stop iterating over windows.  */
 
 struct check_window_data
 {
@@ -1592,22 +1584,19 @@ struct check_window_data
   enum window_part *part;
 };
 
-static int
+static bool
 check_window_containing (struct window *w, void *user_data)
 {
   struct check_window_data *cw = user_data;
-  enum window_part found;
-  int continue_p = 1;
-
-  found = coordinates_in_window (w, cw->x, cw->y);
-  if (found != ON_NOTHING)
+  enum window_part found = coordinates_in_window (w, cw->x, cw->y);
+  if (found == ON_NOTHING)
+    return true;
+  else
     {
       *cw->part = found;
       XSETWINDOW (*cw->window, w);
-      continue_p = 0;
+      return false;
     }
-
-  return continue_p;
 }
 
 
@@ -1618,7 +1607,7 @@ check_window_containing (struct window *w, void *user_data)
    set *PART to the id of that element.
 
    If there is no window under X, Y return nil and leave *PART
-   unmodified.  TOOL_BAR_P non-zero means detect tool-bar windows.
+   unmodified.  TOOL_BAR_P means detect tool-bar windows.
 
    This function was previously implemented with a loop cycling over
    windows with Fnext_window, and starting with the frame's selected
@@ -1680,7 +1669,7 @@ column 0.  */)
                                    + FRAME_INTERNAL_BORDER_WIDTH (f)),
                                   (FRAME_PIXEL_Y_FROM_CANON_Y (f, y)
                                    + FRAME_INTERNAL_BORDER_WIDTH (f)),
-                                  0, 0);
+                                  0, false);
 }
 
 DEFUN ("window-point", Fwindow_point, Swindow_point, 0, 1, 0,
@@ -1787,7 +1776,7 @@ if it isn't already recorded.  */)
       if (it.current_y < it.last_visible_y)
         move_it_past_eol (&it);
       value = make_number (IT_CHARPOS (it));
-      bidi_unshelve_cache (itdata, 0);
+      bidi_unshelve_cache (itdata, false);
 
       if (old_buffer)
         set_buffer_internal (old_buffer);
@@ -1845,12 +1834,12 @@ overriding motion of point in order to display at this exact start.  */)
 
   set_marker_restricted (w->start, pos, w->contents);
   /* This is not right, but much easier than doing what is right.  */
-  w->start_at_line_beg = 0;
+  w->start_at_line_beg = false;
   if (NILP (noforce))
-    w->force_start = 1;
-  w->update_mode_line = 1;
+    w->force_start = true;
+  w->update_mode_line = true;
   /* Bug#15957.  */
-  w->window_end_valid = 0;
+  w->window_end_valid = false;
   wset_redisplay (w);
 
   return pos;
@@ -1878,12 +1867,13 @@ POS, ROWH is the visible height of that row, and VPOS is the row number
 \(zero-based).  */)
   (Lisp_Object pos, Lisp_Object window, Lisp_Object partially)
 {
-  register struct window *w;
-  register EMACS_INT posint;
-  register struct buffer *buf;
+  struct window *w;
+  EMACS_INT posint;
+  struct buffer *buf;
   struct text_pos top;
   Lisp_Object in_window = Qnil;
-  int rtop, rbot, rowh, vpos, fully_p = 1;
+  int rtop, rbot, rowh, vpos;
+  bool fully_p = true;
   int x, y;
 
   w = decode_live_window (window);
@@ -1908,9 +1898,12 @@ POS, ROWH is the visible height of that row, and VPOS is the row number
        || (posint >= CHARPOS (top) && posint <= BUF_ZV (buf)))
       && CHARPOS (top) >= BUF_BEGV (buf)
       && CHARPOS (top) <= BUF_ZV (buf)
-      && pos_visible_p (w, posint, &x, &y, &rtop, &rbot, &rowh, &vpos)
-      && (fully_p = !rtop && !rbot, (!NILP (partially) || fully_p)))
-    in_window = Qt;
+      && pos_visible_p (w, posint, &x, &y, &rtop, &rbot, &rowh, &vpos))
+    {
+      fully_p = !rtop && !rbot;
+      if (!NILP (partially) || fully_p)
+        in_window = Qt;
+    }
 
   if (!NILP (in_window) && !NILP (partially))
     {
@@ -2215,7 +2208,7 @@ unshow_buffer (register struct window *w)
 
   eassert (b == XMARKER (w->pointm)->buffer);
 
-#if 0
+#if false
   if (w == XWINDOW (selected_window)
       || ! EQ (buf, XWINDOW (selected_window)->contents))
     /* Do this except when the selected window's buffer
@@ -2254,14 +2247,14 @@ unshow_buffer (register struct window *w)
     bset_last_selected_window (b, Qnil);
 }
 
-/* Put NEW into the window structure in place of OLD.  SETFLAG zero
+/* Put NEW into the window structure in place of OLD.  SETFLAG false
    means change window structure only.  Otherwise store geometry and
    other settings as well.  */
 static void
-replace_window (Lisp_Object old, Lisp_Object new, int setflag)
+replace_window (Lisp_Object old, Lisp_Object new, bool setflag)
 {
-  register Lisp_Object tem;
-  register struct window *o = XWINDOW (old), *n = XWINDOW (new);
+  Lisp_Object tem;
+  struct window *o = XWINDOW (old), *n = XWINDOW (new);
 
   /* If OLD is its frame's root window, then NEW is the new
      root window for that frame.  */
@@ -2291,11 +2284,11 @@ replace_window (Lisp_Object old, Lisp_Object new, int setflag)
       n->phys_cursor_type = NO_CURSOR;
       n->phys_cursor_width = -1;
 #endif
-      n->must_be_updated_p = 0;
-      n->pseudo_window_p = 0;
+      n->must_be_updated_p = false;
+      n->pseudo_window_p = false;
       n->window_end_vpos = 0;
       n->window_end_pos = 0;
-      n->window_end_valid = 0;
+      n->window_end_valid = false;
     }
 
   tem = o->next;
@@ -2380,7 +2373,7 @@ recombine_windows (Lisp_Object window)
             }
 
           /* WINDOW can be deleted now.  */
-          wset_combination (w, 0, Qnil);
+          wset_combination (w, false, Qnil);
         }
     }
 }
@@ -2401,14 +2394,14 @@ delete_deletable_window (Lisp_Object window)
    pointer.  This is a callback function for foreach_window, used in
    the window_list function.  */
 
-static int
+static bool
 add_window_to_list (struct window *w, void *user_data)
 {
   Lisp_Object *list = user_data;
   Lisp_Object window;
   XSETWINDOW (window, w);
   *list = Fcons (window, *list);
-  return 1;
+  return true;
 }
 
 
@@ -2441,7 +2434,7 @@ window_list (void)
 }
 
 
-/* Value is non-zero if WINDOW satisfies the constraints given by
+/* Value is true if WINDOW satisfies the constraints given by
    OWINDOW, MINIBUF and ALL_FRAMES.
 
    MINIBUF      t means WINDOW may be minibuffer windows.
@@ -2463,20 +2456,20 @@ candidate_window_p (Lisp_Object window, Lisp_Object owindow,
 {
   struct window *w = XWINDOW (window);
   struct frame *f = XFRAME (w->frame);
-  bool candidate_p = 1;
+  bool candidate_p = true;
 
   if (!BUFFERP (w->contents))
-    candidate_p = 0;
+    candidate_p = false;
   else if (MINI_WINDOW_P (w)
            && (EQ (minibuf, Qlambda)
                || (WINDOWP (minibuf) && !EQ (minibuf, window))))
     {
       /* If MINIBUF is `lambda' don't consider any mini-windows.
          If it is a window, consider only that one.  */
-      candidate_p = 0;
+      candidate_p = false;
     }
   else if (EQ (all_frames, Qt))
-    candidate_p = 1;
+    candidate_p = true;
   else if (NILP (all_frames))
     {
       eassert (WINDOWP (owindow));
@@ -2556,12 +2549,13 @@ decode_next_window_args (Lisp_Object *window, Lisp_Object *minibuf, Lisp_Object
 
 
 /* Return the next or previous window of WINDOW in cyclic ordering
-   of windows.  NEXT_P non-zero means return the next window.  See the
+   of windows.  NEXT_P means return the next window.  See the
    documentation string of next-window for the meaning of MINIBUF and
    ALL_FRAMES.  */
 
 static Lisp_Object
-next_window (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames, int next_p)
+next_window (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames,
+             bool next_p)
 {
   decode_next_window_args (&window, &minibuf, &all_frames);
 
@@ -2659,7 +2653,7 @@ windows, eventually ending up back at the window you started with.
 `previous-window' traverses the same cycle, in the reverse order.  */)
   (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
 {
-  return next_window (window, minibuf, all_frames, 1);
+  return next_window (window, minibuf, all_frames, true);
 }
 
 
@@ -2699,7 +2693,7 @@ started with.  `next-window' traverses the same cycle, in the
 reverse order.  */)
   (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
 {
-  return next_window (window, minibuf, all_frames, 0);
+  return next_window (window, minibuf, all_frames, false);
 }
 
 
@@ -2797,7 +2791,7 @@ be listed first but no error is signaled.  */)
                 Qnil, look at just the selected frame;
                 Qvisible, look at visible frames;
                 a frame, just look at windows on that frame.
-   If MINI is non-zero, perform the operation on minibuffer windows too.  */
+   If MINI, perform the operation on minibuffer windows too.  */
 
 enum window_loop
 {
@@ -2809,10 +2803,11 @@ enum window_loop
 };
 
 static Lisp_Object
-window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frames)
+window_loop (enum window_loop type, Lisp_Object obj, bool mini,
+             Lisp_Object frames)
 {
   Lisp_Object window, windows, best_window, frame_arg;
-  int frame_best_window_flag = 0;
+  bool frame_best_window_flag = false;
   struct frame *f;
   struct gcpro gcpro1;
 
@@ -2872,7 +2867,7 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
             if (EQ (w->contents, obj)
                 /* Don't find any minibuffer window except the one that
                    is currently in use.  */
-                && (MINI_WINDOW_P (w) ? EQ (window, minibuf_window) : 1))
+                && (!MINI_WINDOW_P (w) || EQ (window, minibuf_window)))
               {
                 if (EQ (window, selected_window))
                   /* Preferably return the selected window.  */
@@ -2883,7 +2878,7 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
                      choose another one if we have one already).  */
                   {
                     best_window = window;
-                    frame_best_window_flag = 1;
+                    frame_best_window_flag = true;
                   }
                 else if (NILP (best_window))
                   best_window = window;
@@ -2900,7 +2895,7 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
                 /* Make WINDOW show the buffer returned by
                    other_buffer_safely, don't run any hooks.  */
                 set_window_buffer
-                  (window, other_buffer_safely (w->contents), 0, 0);
+                  (window, other_buffer_safely (w->contents), false, false);
                 /* If WINDOW is the selected window, make its buffer
                    current.  But do so only if the window shows the
                    current buffer (Bug#6454).  */
@@ -2913,9 +2908,9 @@ window_loop (enum window_loop type, Lisp_Object obj, int mini, Lisp_Object frame
           case REDISPLAY_BUFFER_WINDOWS:
             if (EQ (w->contents, obj))
               {
-                mark_window_display_accurate (window, 0);
-                w->update_mode_line = 1;
-                XBUFFER (obj)->prevent_redisplay_optimizations_p = 1;
+                mark_window_display_accurate (window, false);
+                w->update_mode_line = true;
+                XBUFFER (obj)->prevent_redisplay_optimizations_p = true;
                 update_mode_lines = 27;
                 best_window = window;
               }
@@ -2952,7 +2947,7 @@ extern void check_all_windows (void) EXTERNALLY_VISIBLE;
 void
 check_all_windows (void)
 {
-  window_loop (CHECK_ALL_WINDOWS, Qnil, 1, Qt);
+  window_loop (CHECK_ALL_WINDOWS, Qnil, true, Qt);
 }
 
 DEFUN ("get-buffer-window", Fget_buffer_window, Sget_buffer_window, 0, 2, 0,
@@ -2983,7 +2978,7 @@ selected frame and no others.  */)
     buffer = Fget_buffer (buffer_or_name);
 
   if (BUFFERP (buffer))
-    return window_loop (GET_BUFFER_WINDOW, buffer, 1, all_frames);
+    return window_loop (GET_BUFFER_WINDOW, buffer, true, all_frames);
   else
     return Qnil;
 }
@@ -3040,7 +3035,7 @@ window-start value is reasonable when this function is called.  */)
   struct frame *f;
   Lisp_Object sibling, pwindow, swindow IF_LINT (= Qnil), delta;
   ptrdiff_t startpos IF_LINT (= 0), startbyte IF_LINT (= 0);
-  int top IF_LINT (= 0), new_top, resize_failed;
+  int top IF_LINT (= 0), new_top;
 
   w = decode_valid_window (window);
   XSETWINDOW (window, w);
@@ -3097,7 +3092,7 @@ window-start value is reasonable when this function is called.  */)
          parents and comparing each one with WINDOW.  If it isn't we
          need a new selected window for this frame.  */
       swindow = FRAME_SELECTED_WINDOW (f);
-      while (1)
+      while (true)
         {
           pwindow = swindow;
           while (!NILP (pwindow) && !EQ (window, pwindow))
@@ -3129,7 +3124,7 @@ window-start value is reasonable when this function is called.  */)
       /* We are going to free the glyph matrices of WINDOW, and with
          that we might lose any information about glyph rows that have
          some of their glyphs highlighted in mouse face.  (These rows
-         are marked with a non-zero mouse_face_p flag.)  If WINDOW
+         are marked with a mouse_face_p flag.)  If WINDOW
          indeed has some glyphs highlighted in mouse face, signal to
          frame's up-to-date hook that mouse highlight was overwritten,
          so that it will arrange for redisplaying the highlight.  */
@@ -3140,8 +3135,8 @@ window-start value is reasonable when this function is called.  */)
 
   fset_redisplay (f);
   Vwindow_list = Qnil;
-  FRAME_WINDOW_SIZES_CHANGED (f) = 1;
-  resize_failed = 0;
+  FRAME_WINDOW_SIZES_CHANGED (f) = true;
+  bool resize_failed = false;
 
   if (!WINDOW_LEAF_P (w))
     {
@@ -3150,21 +3145,21 @@ window-start value is reasonable when this function is called.  */)
       w->pixel_top = r->pixel_top;
       w->top_line = r->top_line;
       resize_root_window (window, delta, Qnil, Qnil, Qt);
-      if (window_resize_check (w, 0))
+      if (window_resize_check (w, false))
         {
-          window_resize_apply (w, 0);
+          window_resize_apply (w, false);
           window_pixel_to_total (w->frame, Qnil);
         }
       else
         {
           resize_root_window (window, delta, Qnil, Qt, Qt);
-          if (window_resize_check (w, 0))
+          if (window_resize_check (w, false))
             {
-              window_resize_apply (w, 0);
+              window_resize_apply (w, false);
               window_pixel_to_total (w->frame, Qnil);
             }
           else
-            resize_failed = 1;
+            resize_failed = true;
         }
 
       /* Resize child windows horizontally.  */
@@ -3174,21 +3169,21 @@ window-start value is reasonable when this function is called.  */)
           w->pixel_left = r->pixel_left;
           XSETINT (delta, r->pixel_width - w->pixel_width);
           resize_root_window (window, delta, Qt, Qnil, Qt);
-          if (window_resize_check (w, 1))
+          if (window_resize_check (w, true))
             {
-              window_resize_apply (w, 1);
+              window_resize_apply (w, true);
               window_pixel_to_total (w->frame, Qt);
             }
           else
             {
               resize_root_window (window, delta, Qt, Qt, Qt);
-              if (window_resize_check (w, 1))
+              if (window_resize_check (w, true))
                 {
-                  window_resize_apply (w, 1);
+                  window_resize_apply (w, true);
                   window_pixel_to_total (w->frame, Qt);
                 }
               else
-                resize_failed = 1;
+                resize_failed = true;
             }
         }
 
@@ -3224,10 +3219,10 @@ window-start value is reasonable when this function is called.  */)
   if (WINDOWP (r->contents))
     {
       delete_all_child_windows (r->contents);
-      wset_combination (r, 0, Qnil);
+      wset_combination (r, false, Qnil);
     }
 
-  replace_window (root, window, 1);
+  replace_window (root, window, true);
 
   /* This must become SWINDOW anyway .......  */
   if (BUFFERP (w->contents) && !resize_failed)
@@ -3251,12 +3246,12 @@ window-start value is reasonable when this function is called.  */)
           pos = *vmotion (startpos, startbyte, -top, w);
 
           set_marker_both (w->start, w->contents, pos.bufpos, pos.bytepos);
-          w->window_end_valid = 0;
+          w->window_end_valid = false;
           w->start_at_line_beg = (pos.bytepos == BEGV_BYTE
                                     || FETCH_BYTE (pos.bytepos - 1) == '\n');
           /* We need to do this, so that the window-scroll-functions
              get called.  */
-          w->optional_new_start = 1;
+          w->optional_new_start = true;
 
           set_buffer_internal (obuf);
         }
@@ -3291,7 +3286,7 @@ replace_buffer_in_windows_safely (Lisp_Object buffer)
          considers frames on the current keyboard.  So loop manually over
          frames, and handle each one.  */
       FOR_EACH_FRAME (tail, frame)
-        window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY, buffer, 1, frame);
+        window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY, buffer, true, frame);
     }
 }
 
@@ -3391,9 +3386,9 @@ If WINDOW is omitted or nil, it defaults to the selected window.  */)
   return Qnil;
 }
 
-/* Make WINDOW display BUFFER.  RUN_HOOKS_P non-zero means it's allowed
+/* Make WINDOW display BUFFER.  RUN_HOOKS_P means it's allowed
    to run hooks.  See make_frame for a case where it's not allowed.
-   KEEP_MARGINS_P non-zero means that the current margins, fringes, and
+   KEEP_MARGINS_P means that the current margins, fringes, and
    scroll-bar settings of the window are not reset from the buffer's
    local settings.  */
 
@@ -3435,15 +3430,15 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer,
          doc-view-mode since it resets the image's position whenever we
          resize the frame.  */
       w->hscroll = w->min_hscroll = w->hscroll_whole = 0;
-      w->suspend_auto_hscroll = 0;
+      w->suspend_auto_hscroll = false;
       w->vscroll = 0;
       set_marker_both (w->pointm, buffer, BUF_PT (b), BUF_PT_BYTE (b));
       set_marker_both (w->old_pointm, buffer, BUF_PT (b), BUF_PT_BYTE (b));
       set_marker_restricted (w->start,
                              make_number (b->last_window_start),
                              buffer);
-      w->start_at_line_beg = 0;
-      w->force_start = 0;
+      w->start_at_line_beg = false;
+      w->force_start = false;
     }
   /* Maybe we could move this into the `if' but it's not obviously safe and
      I doubt it's worth the trouble.  */
@@ -3534,7 +3529,7 @@ This function runs `window-scroll-functions' before running
       unshow_buffer (w);
     }
 
-  set_window_buffer (window, buffer, 1, !NILP (keep_margins));
+  set_window_buffer (window, buffer, true, !NILP (keep_margins));
 
   return Qnil;
 }
@@ -3563,10 +3558,10 @@ displaying that buffer.  */)
   if (WINDOWP (object))
     {
       struct window *w = XWINDOW (object);
-      mark_window_display_accurate (object, 0);
-      w->update_mode_line = 1;
+      mark_window_display_accurate (object, false);
+      w->update_mode_line = true;
       if (BUFFERP (w->contents))
-        XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
+        XBUFFER (w->contents)->prevent_redisplay_optimizations_p = true;
       update_mode_lines = 29;
       return Qt;
     }
@@ -3578,7 +3573,7 @@ displaying that buffer.  */)
     {
       /* If buffer is live and shown in at least one window, find
          all windows showing this buffer and force update of them.  */
-      object = window_loop (REDISPLAY_BUFFER_WINDOWS, object, 0, Qvisible);
+      object = window_loop (REDISPLAY_BUFFER_WINDOWS, object, false, Qvisible);
       return NILP (object) ? Qnil : Qt;
     }
 
@@ -3614,7 +3609,7 @@ temp_output_buffer_show (register Lisp_Object buf)
       Vminibuf_scroll_window = window;
       w = XWINDOW (window);
       w->hscroll = w->min_hscroll = w->hscroll_whole = 0;
-      w->suspend_auto_hscroll = 0;
+      w->suspend_auto_hscroll = false;
       set_marker_restricted_both (w->start, buf, BEG, BEG);
       set_marker_restricted_both (w->pointm, buf, BEG, BEG);
       set_marker_restricted_both (w->old_pointm, buf, BEG, BEG);
@@ -3651,7 +3646,7 @@ allocate_window (void)
 }
 
 /* Make new window, have it replace WINDOW in window-tree, and make
-   WINDOW its only vertical child (HORFLAG 1 means make WINDOW its only
+   WINDOW its only vertical child (HORFLAG means make WINDOW its only
    horizontal child).   */
 static void
 make_parent_window (Lisp_Object window, bool horflag)
@@ -3670,7 +3665,7 @@ make_parent_window (Lisp_Object window, bool horflag)
 
   p->sequence_number = ++sequence_number;
 
-  replace_window (window, parent, 1);
+  replace_window (window, parent, true);
 
   wset_next (o, Qnil);
   wset_prev (o, Qnil);
@@ -3799,14 +3794,14 @@ Note: This function does not operate on any child windows of WINDOW.  */)
   return size;
 }
 
-/* Return 1 if setting w->pixel_height (w->pixel_width if HORFLAG is
-   non-zero) to w->new_pixel would result in correct heights (widths)
+/* Return true if setting w->pixel_height (w->pixel_width if HORFLAG)
+   to w->new_pixel would result in correct heights (widths)
    for window W and recursively all child windows of W.
 
    Note: This function does not check any of `window-fixed-size-p',
    `window-min-height' or `window-min-width'.  It does check that window
    sizes do not drop below one line (two columns). */
-static int
+static bool
 window_resize_check (struct window *w, bool horflag)
 {
   struct frame *f = XFRAME (w->frame);
@@ -3823,12 +3818,12 @@ window_resize_check (struct window *w, bool horflag)
             {
               if (XINT (c->new_pixel) != XINT (w->new_pixel)
                   || !window_resize_check (c, horflag))
-                return 0;
+                return false;
 
               c = NILP (c->next) ? 0 : XWINDOW (c->next);
             }
 
-          return 1;
+          return true;
         }
       else
         /* The sum of the heights of the child windows of W must equal
@@ -3839,11 +3834,11 @@ window_resize_check (struct window *w, bool horflag)
           while (c)
             {
               if (!window_resize_check (c, horflag))
-                return 0;
+                return false;
 
               remaining_pixels -= XINT (c->new_pixel);
               if (remaining_pixels < 0)
-                return 0;
+                return false;
               c = NILP (c->next) ? 0 : XWINDOW (c->next);
             }
 
@@ -3863,11 +3858,11 @@ window_resize_check (struct window *w, bool horflag)
           while (c)
             {
               if (!window_resize_check (c, horflag))
-                return 0;
+                return false;
 
               remaining_pixels -= XINT (c->new_pixel);
               if (remaining_pixels < 0)
-                return 0;
+                return false;
               c = NILP (c->next) ? 0 : XWINDOW (c->next);
             }
 
@@ -3880,12 +3875,12 @@ window_resize_check (struct window *w, bool horflag)
             {
               if (XINT (c->new_pixel) != XINT (w->new_pixel)
                   || !window_resize_check (c, horflag))
-                return 0;
+                return false;
 
               c = NILP (c->next) ? 0 : XWINDOW (c->next);
             }
 
-          return 1;
+          return true;
         }
     }
   else
@@ -3898,7 +3893,7 @@ window_resize_check (struct window *w, bool horflag)
 }
 
 
-/* Set w->pixel_height (w->pixel_width if HORFLAG is non-zero) to
+/* Set w->pixel_height (w->pixel_width if HORFLAG) to
    w->new_pixel for window W and recursively all child windows of W.
    Also calculate and assign the new vertical (horizontal) pixel start
    positions of each of these windows.
@@ -3984,11 +3979,11 @@ window_resize_apply (struct window *w, bool horflag)
     }
   else
     /* Bug#15957.  */
-    w->window_end_valid = 0;
+    w->window_end_valid = false;
 }
 
 
-/* Set w->total_lines (w->total_cols if HORFLAG is non-zero) to
+/* Set w->total_lines (w->total_cols if HORFLAG) to
    w->new_total for window W and recursively all child windows of W.
    Also calculate and assign the new vertical (horizontal) start
    positions of each of these windows.  */
@@ -4083,7 +4078,7 @@ be applied on the Elisp level.  */)
   window_resize_apply (r, horflag);
 
   fset_redisplay (f);
-  FRAME_WINDOW_SIZES_CHANGED (f) = 1;
+  FRAME_WINDOW_SIZES_CHANGED (f) = true;
 
   adjust_frame_glyphs (f);
   unblock_input ();
@@ -4133,8 +4128,8 @@ values.  */)
 
 
 /* Resize frame F's windows when number of lines of F is set to SIZE.
-   HORFLAG 1 means resize windows when number of columns of F is set to
-   SIZE.  PIXELWISE 1 means to interpret SIZE as pixels.  */
+   HORFLAG means resize windows when number of columns of F is set to
+   SIZE.  PIXELWISE means to interpret SIZE as pixels.  */
 void
 resize_frame_windows (struct frame *f, int size, bool horflag, bool pixelwise)
 {
@@ -4168,12 +4163,9 @@ resize_frame_windows (struct frame *f, int size, bool horflag, bool pixelwise)
     }
   else
     {
-      new_size = max (horflag
-                      ? size
-                      : (size
-                         - ((FRAME_HAS_MINIBUF_P (f)
-                             && !FRAME_MINIBUF_ONLY_P (f))
-                            ? 1 : 0)),
+      new_size = max (size - (!horflag
+                              && FRAME_HAS_MINIBUF_P (f)
+                              && !FRAME_MINIBUF_ONLY_P (f)),
                       1);
       new_pixel_size = new_size * unit;
     }
@@ -4224,7 +4216,7 @@ resize_frame_windows (struct frame *f, int size, bool horflag, bool pixelwise)
             {
               window_resize_apply (r, horflag);
               window_pixel_to_total (r->frame, horflag ? Qt : Qnil);
-#if 0 /* Let's try without safe sizes and/or killing other windows.  */
+#if false /* Let's try without safe sizes and/or killing other windows.  */
             }
           else
             {
@@ -4254,7 +4246,7 @@ resize_frame_windows (struct frame *f, int size, bool horflag, bool pixelwise)
                       XWINDOW (root)->pixel_height = new_pixel_size;
                     }
                 }
-#endif /* 0 */
+#endif /* false */
             }
         }
     }
@@ -4284,7 +4276,7 @@ resize_frame_windows (struct frame *f, int size, bool horflag, bool pixelwise)
 DEFUN ("split-window-internal", Fsplit_window_internal, Ssplit_window_internal, 4, 4, 0,
        doc: /* Split window OLD.
 Second argument PIXEL-SIZE specifies the number of pixels of the
-new window.  In any case TOTAL-SIZE must be a positive integer.
+new window.  It must be a positive integer.
 
 Third argument SIDE nil (or `below') specifies that the new window shall
 be located below WINDOW.  SIDE `above' means the new window shall be
@@ -4311,14 +4303,12 @@ set correctly.  See the code of `split-window' for how this is done.  */)
      provided OLD is a leaf window, or to the frame's selected window.
      NEW (*n) is the new window created with some parameters taken from
      REFERENCE (*r).  */
-  register Lisp_Object new, frame, reference;
-  register struct window *o, *p, *n, *r, *c;
+  Lisp_Object new, frame, reference;
+  struct window *o, *p, *n, *r, *c;
   struct frame *f;
   bool horflag
-    /* HORFLAG is 1 when we split side-by-side, 0 otherwise.  */
+    /* HORFLAG is true when we split side-by-side, false otherwise.  */
     = EQ (side, Qt) || EQ (side, Qleft) || EQ (side, Qright);
-  int combination_limit = 0, sum = 0;
-  int total_size;
 
   CHECK_WINDOW (old);
   o = XWINDOW (old);
@@ -4326,20 +4316,20 @@ set correctly.  See the code of `split-window' for how this is done.  */)
   f = XFRAME (frame);
 
   CHECK_NUMBER (pixel_size);
-  total_size
+  EMACS_INT total_size
     = XINT (pixel_size) / (horflag
                            ? FRAME_COLUMN_WIDTH (f)
                            : FRAME_LINE_HEIGHT (f));
 
-  /* Set combination_limit to 1 if we have to make a new parent window.
+  /* Set combination_limit if we have to make a new parent window.
      We do that if either `window-combination-limit' is t, or OLD has no
      parent, or OLD is ortho-combined.  */
-  combination_limit =
-    EQ (Vwindow_combination_limit, Qt)
-    || NILP (o->parent)
-    || (horflag
-        ? WINDOW_VERTICAL_COMBINATION_P (XWINDOW (o->parent))
-        : WINDOW_HORIZONTAL_COMBINATION_P (XWINDOW (o->parent)));
+  bool combination_limit
+    = (EQ (Vwindow_combination_limit, Qt)
+       || NILP (o->parent)
+       || (horflag
+           ? WINDOW_VERTICAL_COMBINATION_P (XWINDOW (o->parent))
+           : WINDOW_HORIZONTAL_COMBINATION_P (XWINDOW (o->parent))));
 
   /* We need a live reference window to initialize some parameters.  */
   if (WINDOW_LIVE_P (old))
@@ -4405,7 +4395,7 @@ set correctly.  See the code of `split-window' for how this is done.  */)
     p = XWINDOW (o->parent);
 
   fset_redisplay (f);
-  FRAME_WINDOW_SIZES_CHANGED (f) = 1;
+  FRAME_WINDOW_SIZES_CHANGED (f) = true;
   new = make_window ();
   n = XWINDOW (new);
   wset_frame (n, frame);
@@ -4430,7 +4420,7 @@ set correctly.  See the code of `split-window' for how this is done.  */)
       wset_next (o, new);
     }
 
-  n->window_end_valid = 0;
+  n->window_end_valid = false;
   n->last_cursor_vpos = 0;
 
   /* Get special geometry settings from reference window.  */
@@ -4463,6 +4453,7 @@ set correctly.  See the code of `split-window' for how this is done.  */)
   /* Iso-coordinates and sizes are assigned by window_resize_apply,
      get them ready here.  */
   wset_new_pixel (n, pixel_size);
+  EMACS_INT sum = 0;
   c = XWINDOW (p->contents);
   while (c)
     {
@@ -4481,7 +4472,7 @@ set correctly.  See the code of `split-window' for how this is done.  */)
   adjust_frame_glyphs (f);
   /* Set buffer of NEW to buffer of reference window.  Don't run
      any hooks.  */
-  set_window_buffer (new, r->contents, 0, 1);
+  set_window_buffer (new, r->contents, false, true);
   unblock_input ();
 
   /* Maybe we should run the scroll functions in Elisp (which already
@@ -4498,12 +4489,12 @@ DEFUN ("delete-window-internal", Fdelete_window_internal, Sdelete_window_interna
        doc: /* Remove WINDOW from its frame.
 WINDOW defaults to the selected window.  Return nil.
 Signal an error when WINDOW is the only window on its frame.  */)
-     (register Lisp_Object window)
+     (Lisp_Object window)
 {
-  register Lisp_Object parent, sibling, frame, root;
+  Lisp_Object parent, sibling, frame, root;
   struct window *w, *p, *s, *r;
   struct frame *f;
-  bool horflag, before_sibling = 0;
+  bool horflag, before_sibling = false;
 
   w = decode_any_window (window);
   XSETWINDOW (window, w);
@@ -4533,9 +4524,9 @@ Signal an error when WINDOW is the only window on its frame.  */)
   if (NILP (w->prev))
     /* Get SIBLING below (on the right of) WINDOW.  */
     {
-      /* before_sibling 1 means WINDOW is the first child of its
+      /* before_sibling means WINDOW is the first child of its
          parent and thus before the sibling.  */
-      before_sibling = 1;
+      before_sibling = true;
       sibling = w->next;
       s = XWINDOW (sibling);
       wset_prev (s, Qnil);
@@ -4572,7 +4563,7 @@ Signal an error when WINDOW is the only window on its frame.  */)
 
       fset_redisplay (f);
       Vwindow_list = Qnil;
-      FRAME_WINDOW_SIZES_CHANGED (f) = 1;
+      FRAME_WINDOW_SIZES_CHANGED (f) = true;
 
       wset_next (w, Qnil);  /* Don't delete w->next too.  */
       free_window_matrices (w);
@@ -4580,7 +4571,7 @@ Signal an error when WINDOW is the only window on its frame.  */)
       if (WINDOWP (w->contents))
         {
           delete_all_child_windows (w->contents);
-          wset_combination (w, 0, Qnil);
+          wset_combination (w, false, Qnil);
         }
       else
         {
@@ -4596,13 +4587,13 @@ Signal an error when WINDOW is the only window on its frame.  */)
              PARENT.  */
         {
           /* Put SIBLING into PARENT's place.  */
-          replace_window (parent, sibling, 0);
+          replace_window (parent, sibling, false);
           /* Have SIBLING inherit the following three slot values from
              PARENT (the combination_limit slot is not inherited).  */
           wset_normal_cols (s, p->normal_cols);
           wset_normal_lines (s, p->normal_lines);
           /* Mark PARENT as deleted.  */
-          wset_combination (p, 0, Qnil);
+          wset_combination (p, false, Qnil);
           /* Try to merge SIBLING into its new parent.  */
           recombine_windows (sibling);
         }
@@ -4687,10 +4678,10 @@ grow_mini_window (struct window *w, int delta, bool pixelwise)
       r = XWINDOW (root);
       height = call3 (Qwindow_resize_root_window_vertically,
                       root, make_number (- delta), pixelwise ? Qt : Qnil);
-      if (INTEGERP (height) && window_resize_check (r, 0))
+      if (INTEGERP (height) && window_resize_check (r, false))
         {
           block_input ();
-          window_resize_apply (r, 0);
+          window_resize_apply (r, false);
 
           if (pixelwise)
             {
@@ -4742,10 +4733,10 @@ shrink_mini_window (struct window *w, bool pixelwise)
       delta = call3 (Qwindow_resize_root_window_vertically,
                      root, make_number (height - unit),
                      pixelwise ? Qt : Qnil);
-      if (INTEGERP (delta) && window_resize_check (r, 0))
+      if (INTEGERP (delta) && window_resize_check (r, false))
         {
           block_input ();
-          window_resize_apply (r, 0);
+          window_resize_apply (r, false);
 
           /* Shrink the mini-window.  */
           w->top_line = r->top_line + r->total_lines;
@@ -4784,12 +4775,12 @@ DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal, Sresize_mini
 
   r = XWINDOW (FRAME_ROOT_WINDOW (f));
   height = r->pixel_height + w->pixel_height;
-  if (window_resize_check (r, 0)
+  if (window_resize_check (r, false)
       && XINT (w->new_pixel) > 0
       && height == XINT (r->new_pixel) + XINT (w->new_pixel))
     {
       block_input ();
-      window_resize_apply (r, 0);
+      window_resize_apply (r, false);
 
       w->pixel_height = XFASTINT (w->new_pixel);
       w->total_lines = w->pixel_height / FRAME_LINE_HEIGHT (f);
@@ -4797,7 +4788,7 @@ DEFUN ("resize-mini-window-internal", Fresize_mini_window_internal, Sresize_mini
       w->top_line = r->top_line + r->total_lines;
 
       fset_redisplay (f);
-      FRAME_WINDOW_SIZES_CHANGED (f) = 1;
+      FRAME_WINDOW_SIZES_CHANGED (f) = true;
       adjust_frame_glyphs (f);
       unblock_input ();
       return Qt;
@@ -4819,7 +4810,7 @@ mark_window_cursors_off (struct window *w)
       if (WINDOWP (w->contents))
         mark_window_cursors_off (XWINDOW (w->contents));
       else
-        w->phys_cursor_on_p = 0;
+        w->phys_cursor_on_p = false;
 
       w = NILP (w->next) ? 0 : XWINDOW (w->next);
     }
@@ -4854,19 +4845,19 @@ window_internal_height (struct window *w)
                            Window Scrolling
  ***********************************************************************/
 
-/* Scroll contents of window WINDOW up.  If WHOLE is non-zero, scroll
+/* Scroll contents of window WINDOW up.  If WHOLE, scroll
    N screen-fulls, which is defined as the height of the window minus
    next_screen_context_lines.  If WHOLE is zero, scroll up N lines
-   instead.  Negative values of N mean scroll down.  NOERROR non-zero
+   instead.  Negative values of N mean scroll down.  NOERROR
    means don't signal an error if we try to move over BEGV or ZV,
    respectively.  */
 
 static void
-window_scroll (Lisp_Object window, EMACS_INT n, bool whole, int noerror)
+window_scroll (Lisp_Object window, EMACS_INT n, bool whole, bool noerror)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
 
-  immediate_quit = 1;
+  immediate_quit = true;
   n = clip_to_bounds (INT_MIN, n, INT_MAX);
 
   wset_redisplay (XWINDOW (window));
@@ -4884,8 +4875,8 @@ window_scroll (Lisp_Object window, EMACS_INT n, bool whole, int noerror)
   unbind_to (count, Qnil);
 
   /* Bug#15957.  */
-  XWINDOW (window)->window_end_valid = 0;
-  immediate_quit = 0;
+  XWINDOW (window)->window_end_valid = false;
+  immediate_quit = false;
 }
 
 
@@ -4894,14 +4885,14 @@ window_scroll (Lisp_Object window, EMACS_INT n, bool whole, int noerror)
    descriptions.  */
 
 static void
-window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
+window_scroll_pixel_based (Lisp_Object window, int n, bool whole, bool noerror)
 {
   struct it it;
   struct window *w = XWINDOW (window);
   struct text_pos start;
   int this_scroll_margin;
   /* True if we fiddled the window vscroll field without really scrolling.  */
-  int vscrolled = 0;
+  bool vscrolled = false;
   int x, y, rtop, rbot, rowh, vpos;
   void *itdata = NULL;
   int window_total_lines;
@@ -4944,7 +4935,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
         }
 
       start = it.current.pos;
-      bidi_unshelve_cache (itdata, 0);
+      bidi_unshelve_cache (itdata, false);
     }
   else if (auto_window_vscroll_p)
     {
@@ -4997,11 +4988,11 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
                     spos = min (XINT (Fline_end_position (Qnil)) + 1, ZV);
                   set_marker_restricted (w->start, make_number (spos),
                                          w->contents);
-                  w->start_at_line_beg = 1;
-                  w->update_mode_line = 1;
+                  w->start_at_line_beg = true;
+                  w->update_mode_line = true;
                   /* Set force_start so that redisplay_window will run the
                      window-scroll-functions.  */
-                  w->force_start = 1;
+                  w->force_start = true;
                   return;
                 }
             }
@@ -5095,7 +5086,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
             }
           else
             {
-              bidi_unshelve_cache (itdata, 0);
+              bidi_unshelve_cache (itdata, false);
               if (noerror)
                 return;
               else if (n < 0)   /* could happen with empty buffers */
@@ -5112,7 +5103,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
             w->vscroll = 0;
           else
             {
-              bidi_unshelve_cache (itdata, 0);
+              bidi_unshelve_cache (itdata, false);
               if (noerror)
                 return;
               else
@@ -5122,10 +5113,10 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
 
       /* If control gets here, then we vscrolled.  */
 
-      XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
+      XBUFFER (w->contents)->prevent_redisplay_optimizations_p = true;
 
       /* Don't try to change the window start below.  */
-      vscrolled = 1;
+      vscrolled = true;
     }
 
   if (! vscrolled)
@@ -5146,10 +5137,10 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
                                   IT_BYTEPOS (it));
       bytepos = marker_byte_position (w->start);
       w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
-      w->update_mode_line = 1;
+      w->update_mode_line = true;
       /* Set force_start so that redisplay_window will run the
          window-scroll-functions.  */
-      w->force_start = 1;
+      w->force_start = true;
     }
 
   /* The rest of this function uses current_y in a nonstandard way,
@@ -5182,8 +5173,8 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
              This is necessary because we set it.current_y to 0, above.  */
           move_it_to (&it, -1,
                       window_scroll_pixel_based_preserve_x,
-                      window_scroll_pixel_based_preserve_y
-                      - (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0 ),
+                      (window_scroll_pixel_based_preserve_y
+                       - WINDOW_WANTS_HEADER_LINE_P (w)),
                       -1, MOVE_TO_Y | MOVE_TO_X);
           SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
         }
@@ -5202,7 +5193,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
   else if (n < 0)
     {
       ptrdiff_t charpos, bytepos;
-      int partial_p;
+      bool partial_p;
 
       /* Save our position, for the
          window_scroll_pixel_based_preserve_y case.  */
@@ -5238,12 +5229,12 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
             {
               charpos = IT_CHARPOS (it);
               bytepos = IT_BYTEPOS (it);
-              bidi_unshelve_cache (it_data, 1);
+              bidi_unshelve_cache (it_data, true);
             }
           else
             {
               it = it2;
-              bidi_unshelve_cache (it_data, 0);
+              bidi_unshelve_cache (it_data, false);
             }
         }
 
@@ -5287,7 +5278,7 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
             SET_PT_BOTH (charpos, bytepos);
         }
     }
-  bidi_unshelve_cache (itdata, 0);
+  bidi_unshelve_cache (itdata, false);
 
   if (adjust_old_pointm)
     Fset_marker (w->old_pointm,
@@ -5302,9 +5293,9 @@ window_scroll_pixel_based (Lisp_Object window, int n, bool whole, int noerror)
    See the comment of window_scroll for parameter descriptions.  */
 
 static void
-window_scroll_line_based (Lisp_Object window, int n, bool whole, int noerror)
+window_scroll_line_based (Lisp_Object window, int n, bool whole, bool noerror)
 {
-  register struct window *w = XWINDOW (window);
+  struct window *w = XWINDOW (window);
   /* Fvertical_motion enters redisplay, which can trigger
      fontification, which in turn can modify buffer text (e.g., if the
      fontification functions replace escape sequences with faces, as
@@ -5334,7 +5325,7 @@ window_scroll_line_based (Lisp_Object window, int n, bool whole, int noerror)
           || NILP (Fget (KVAR (current_kboard, Vlast_command), Qscroll_command)))
         {
           struct position posit
-            = *compute_motion (startpos, startbyte, 0, 0, 0,
+            = *compute_motion (startpos, startbyte, 0, 0, false,
                                PT, ht, 0, -1, w->hscroll, 0, w);
 
           window_scroll_preserve_vpos = posit.vpos;
@@ -5380,10 +5371,10 @@ window_scroll_line_based (Lisp_Object window, int n, bool whole, int noerror)
 
       set_marker_restricted_both (w->start, w->contents, pos, pos_byte);
       w->start_at_line_beg = !NILP (bolp);
-      w->update_mode_line = 1;
+      w->update_mode_line = true;
       /* Set force_start so that redisplay_window will run
          the window-scroll-functions.  */
-      w->force_start = 1;
+      w->force_start = true;
 
       if (!NILP (Vscroll_preserve_screen_position)
           && (whole || !EQ (Vscroll_preserve_screen_position, Qt)))
@@ -5485,13 +5476,13 @@ scroll_command (Lisp_Object n, int direction)
     }
 
   if (NILP (n))
-    window_scroll (selected_window, direction, 1, 0);
+    window_scroll (selected_window, direction, true, false);
   else if (EQ (n, Qminus))
-    window_scroll (selected_window, -direction, 1, 0);
+    window_scroll (selected_window, -direction, true, false);
   else
     {
       n = Fprefix_numeric_value (n);
-      window_scroll (selected_window, XINT (n) * direction, 0, 0);
+      window_scroll (selected_window, XINT (n) * direction, false, false);
     }
 
   unbind_to (count, Qnil);
@@ -5599,15 +5590,15 @@ specifies the window to scroll.  This takes precedence over
   SET_PT_BOTH (marker_position (w->old_pointm), marker_byte_position (w->old_pointm));
 
   if (NILP (arg))
-    window_scroll (window, 1, 1, 1);
+    window_scroll (window, 1, true, true);
   else if (EQ (arg, Qminus))
-    window_scroll (window, -1, 1, 1);
+    window_scroll (window, -1, true, true);
   else
     {
       if (CONSP (arg))
         arg = XCAR (arg);
       CHECK_NUMBER (arg);
-      window_scroll (window, XINT (arg), 0, 1);
+      window_scroll (window, XINT (arg), false, true);
     }
 
   set_marker_both (w->pointm, Qnil, PT, PT_BYTE);
@@ -5637,7 +5628,7 @@ by this function.  This happens in an interactive call.  */)
   if (!NILP (set_minimum))
     w->min_hscroll = w->hscroll;
 
-  w->suspend_auto_hscroll = 1;
+  w->suspend_auto_hscroll = true;
 
   return result;
 }
@@ -5662,7 +5653,7 @@ by this function.  This happens in an interactive call.  */)
   if (!NILP (set_minimum))
     w->min_hscroll = w->hscroll;
 
-  w->suspend_auto_hscroll = 1;
+  w->suspend_auto_hscroll = true;
 
   return result;
 }
@@ -5710,7 +5701,7 @@ displayed_window_lines (struct window *w)
   start_display (&it, w, start);
   move_it_vertically (&it, height);
   bottom_y = line_bottom_y (&it);
-  bidi_unshelve_cache (itdata, 0);
+  bidi_unshelve_cache (itdata, false);
 
   /* rms: On a non-window display,
      the value of it.vpos at the bottom of the screen
@@ -5754,7 +5745,7 @@ and redisplay normally--don't erase and redraw the frame.  */)
 {
   struct window *w = XWINDOW (selected_window);
   struct buffer *buf = XBUFFER (w->contents);
-  bool center_p = 0;
+  bool center_p = false;
   ptrdiff_t charpos, bytepos;
   EMACS_INT iarg IF_LINT (= 0);
   int this_scroll_margin;
@@ -5783,10 +5774,10 @@ and redisplay normally--don't erase and redraw the frame.  */)
           SET_FRAME_GARBAGED (WINDOW_XFRAME (w));
         }
 
-      center_p = 1;
+      center_p = true;
     }
   else if (CONSP (arg)) /* Just C-u.  */
-    center_p = 1;
+    center_p = true;
   else
     {
       arg = Fprefix_numeric_value (arg);
@@ -5799,10 +5790,9 @@ and redisplay normally--don't erase and redraw the frame.  */)
   this_scroll_margin
     = max (0, min (scroll_margin, w->total_lines / 4));
 
-  /* Handle centering on a graphical frame specially.  Such frames can
-     have variable-height lines and centering point on the basis of
-     line counts would lead to strange effects.  */
-  if (FRAME_WINDOW_P (XFRAME (w->frame)))
+  /* Don't use redisplay code for initial frames, as the necessary
+     data structures might not be set up yet then.  */
+  if (!FRAME_INITIAL_P (XFRAME (w->frame)))
     {
       if (center_p)
         {
@@ -5815,7 +5805,7 @@ and redisplay normally--don't erase and redraw the frame.  */)
           move_it_vertically_backward (&it, window_box_height (w) / 2);
           charpos = IT_CHARPOS (it);
           bytepos = IT_BYTEPOS (it);
-          bidi_unshelve_cache (itdata, 0);
+          bidi_unshelve_cache (itdata, false);
         }
       else if (iarg < 0)
         {
@@ -5824,9 +5814,11 @@ and redisplay normally--don't erase and redraw the frame.  */)
           ptrdiff_t nlines = min (PTRDIFF_MAX, -iarg);
           int extra_line_spacing;
           int h = window_box_height (w);
+          int ht = window_internal_height (w);
           void *itdata = bidi_shelve_cache ();
 
-          iarg = - max (-iarg, this_scroll_margin);
+          nlines = clip_to_bounds (this_scroll_margin + 1, nlines,
+                                   ht - this_scroll_margin);
 
           SET_TEXT_POS (pt, PT, PT_BYTE);
           start_display (&it, w, pt);
@@ -5863,7 +5855,7 @@ and redisplay normally--don't erase and redraw the frame.  */)
             }
           if (h <= 0)
             {
-              bidi_unshelve_cache (itdata, 0);
+              bidi_unshelve_cache (itdata, false);
               return Qnil;
             }
 
@@ -5886,17 +5878,37 @@ and redisplay normally--don't erase and redraw the frame.  */)
           charpos = IT_CHARPOS (it);
           bytepos = IT_BYTEPOS (it);
 
-          bidi_unshelve_cache (itdata, 0);
+          bidi_unshelve_cache (itdata, false);
         }
       else
         {
-          struct position pos;
+          struct it it;
+          struct text_pos pt;
+          ptrdiff_t nlines = min (PTRDIFF_MAX, iarg);
+          int ht = window_internal_height (w);
+          void *itdata = bidi_shelve_cache ();
+
+          nlines = clip_to_bounds (this_scroll_margin, nlines,
+                                   ht - this_scroll_margin - 1);
+
+          SET_TEXT_POS (pt, PT, PT_BYTE);
+          start_display (&it, w, pt);
 
-          iarg = max (iarg, this_scroll_margin);
+          /* Move to the beginning of screen line containing PT.  */
+          move_it_by_lines (&it, 0);
 
-          pos = *vmotion (PT, PT_BYTE, -iarg, w);
-          charpos = pos.bufpos;
-          bytepos = pos.bytepos;
+          /* Move back to find the point which is ARG screen lines above PT.  */
+          if (nlines > 0)
+            {
+              it.current_y = 0;
+              it.vpos = 0;
+              move_it_by_lines (&it, -nlines);
+            }
+
+          charpos = IT_CHARPOS (it);
+          bytepos = IT_BYTEPOS (it);
+
+          bidi_unshelve_cache (itdata, false);
         }
     }
   else
@@ -5920,9 +5932,9 @@ and redisplay normally--don't erase and redraw the frame.  */)
 
   /* Set the new window start.  */
   set_marker_both (w->start, w->contents, charpos, bytepos);
-  w->window_end_valid = 0;
+  w->window_end_valid = false;
 
-  w->optional_new_start = 1;
+  w->optional_new_start = true;
 
   w->start_at_line_beg = (bytepos == BEGV_BYTE
                           || FETCH_BYTE (bytepos - 1) == '\n');
@@ -5986,7 +5998,7 @@ zero means top of window, negative means relative to bottom of window.  */)
   struct window *w = XWINDOW (selected_window);
   int lines, start;
   Lisp_Object window;
-#if 0
+#if false
   int this_scroll_margin;
 #endif
 
@@ -6003,14 +6015,14 @@ zero means top of window, negative means relative to bottom of window.  */)
       Fvertical_motion (make_number (- (height / 2)), window, Qnil);
       set_marker_both (w->start, w->contents, PT, PT_BYTE);
       w->start_at_line_beg = !NILP (Fbolp ());
-      w->force_start = 1;
+      w->force_start = true;
     }
   else
     Fgoto_char (w->start);
 
   lines = displayed_window_lines (w);
 
-#if 0
+#if false
   this_scroll_margin = max (0, min (scroll_margin, lines / 4));
 #endif
 
@@ -6023,11 +6035,11 @@ zero means top of window, negative means relative to bottom of window.  */)
       if (iarg < 0)
         iarg = iarg + lines;
 
-#if 0  /* This code would prevent move-to-window-line from moving point
-          to a place inside the scroll margins (which would cause the
-          next redisplay to scroll).  I wrote this code, but then concluded
-          it is probably better not to install it.  However, it is here
-          inside #if 0 so as not to lose it.  -- rms.  */
+#if false /* This code would prevent move-to-window-line from moving point
+             to a place inside the scroll margins (which would cause the
+             next redisplay to scroll).  I wrote this code, but then concluded
+             it is probably better not to install it.  However, it is here
+             inside #if false so as not to lose it.  -- rms.  */
 
       /* Don't let it get into the margin at either top or bottom.  */
       iarg = max (iarg, this_scroll_margin);
@@ -6193,14 +6205,12 @@ the return value is nil.  Otherwise the value is t.  */)
     {
       Lisp_Object window;
       Lisp_Object dead_windows = Qnil;
-      register Lisp_Object tem, par, pers;
-      register struct window *w;
-      register struct saved_window *p;
+      Lisp_Object tem, par, pers;
+      struct window *w;
+      struct saved_window *p;
       struct window *root_window;
       struct window **leaf_windows;
-      int n_leaf_windows;
-      ptrdiff_t k;
-      int i, n;
+      ptrdiff_t i, k, n_leaf_windows;
 
       /* Don't do this within the main loop below: This may call Lisp
          code and is thus potentially unsafe while input is blocked.  */
@@ -6238,14 +6248,14 @@ the return value is nil.  Otherwise the value is t.  */)
         }
 
       fset_redisplay (f);
-      FRAME_WINDOW_SIZES_CHANGED (f) = 1;
+      FRAME_WINDOW_SIZES_CHANGED (f) = true;
 
       /* Problem: Freeing all matrices and later allocating them again
          is a serious redisplay flickering problem.  What we would
          really like to do is to free only those matrices not reused
          below.  */
       root_window = XWINDOW (FRAME_ROOT_WINDOW (f));
-      int nwindows = count_windows (root_window);
+      ptrdiff_t nwindows = count_windows (root_window);
       SAFE_NALLOCA (leaf_windows, 1, nwindows);
       n_leaf_windows = get_leaf_windows (root_window, leaf_windows, 0);
 
@@ -6369,7 +6379,7 @@ the return value is nil.  Otherwise the value is t.  */)
                   (w->old_pointm, w->contents,
                    BUF_PT (XBUFFER (w->contents)),
                    BUF_PT_BYTE (XBUFFER (w->contents)));
-              w->start_at_line_beg = 1;
+              w->start_at_line_beg = true;
             }
           else if (!NILP (w->start))
             /* Leaf window has no live buffer, get one.  */
@@ -6384,7 +6394,7 @@ the return value is nil.  Otherwise the value is t.  */)
               set_marker_restricted_both (w->start, w->contents, 0, 0);
               set_marker_restricted_both (w->pointm, w->contents, 0, 0);
               set_marker_restricted_both (w->old_pointm, w->contents, 0, 0);
-              w->start_at_line_beg = 1;
+              w->start_at_line_beg = true;
               if (!NILP (w->dedicated))
                 /* Record this window as dead.  */
                 dead_windows = Fcons (window, dead_windows);
@@ -6408,7 +6418,7 @@ the return value is nil.  Otherwise the value is t.  */)
 
          Do not record the buffer here.  We do that in a separate call
          to select_window below.  See also Bug#16207.  */
-      select_window (data->current_window, Qt, 1);
+      select_window (data->current_window, Qt, true);
       BVAR (XBUFFER (XWINDOW (selected_window)->contents),
             last_selected_window)
         = selected_window;
@@ -6419,18 +6429,14 @@ the return value is nil.  Otherwise the value is t.  */)
         Fredirect_frame_focus (frame, data->focus_frame);
 
       /* Now, free glyph matrices in windows that were not reused.  */
-      for (i = n = 0; i < n_leaf_windows; ++i)
-        {
-          if (NILP (leaf_windows[i]->contents))
-            free_window_matrices (leaf_windows[i]);
-          else if (EQ (leaf_windows[i]->contents, new_current_buffer))
-            ++n;
-        }
+      for (i = 0; i < n_leaf_windows; i++)
+        if (NILP (leaf_windows[i]->contents))
+          free_window_matrices (leaf_windows[i]);
 
       /* Allow x_set_window_size again and apply frame size changes if
          needed.  */
       f->can_x_set_window_size = true;
-      adjust_frame_size (f, -1, -1, 1, 0, Qset_window_configuration);
+      adjust_frame_size (f, -1, -1, 1, false, Qset_window_configuration);
 
       adjust_frame_glyphs (f);
       unblock_input ();
@@ -6445,7 +6451,7 @@ the return value is nil.  Otherwise the value is t.  */)
 
       /* Record the selected window's buffer here.  The window should
          already be the selected one from the call above.  */
-      select_window (data->current_window, Qnil, 0);
+      select_window (data->current_window, Qnil, false);
 
       /* Fselect_window will have made f the selected frame, so we
          reselect the proper frame here.  Fhandle_switch_frame will change the
@@ -6500,7 +6506,7 @@ delete_all_child_windows (Lisp_Object window)
   if (WINDOWP (w->contents))
     {
       delete_all_child_windows (w->contents);
-      wset_combination (w, 0, Qnil);
+      wset_combination (w, false, Qnil);
     }
   else if (BUFFERP (w->contents))
     {
@@ -6518,10 +6524,10 @@ delete_all_child_windows (Lisp_Object window)
   Vwindow_list = Qnil;
 }
 
-static int
-count_windows (register struct window *window)
+static ptrdiff_t
+count_windows (struct window *window)
 {
-  register int count = 1;
+  ptrdiff_t count = 1;
   if (!NILP (window->next))
     count += count_windows (XWINDOW (window->next));
   if (WINDOWP (window->contents))
@@ -6532,8 +6538,8 @@ count_windows (register struct window *window)
 
 /* Fill vector FLAT with leaf windows under W, starting at index I.
    Value is last index + 1.  */
-static int
-get_leaf_windows (struct window *w, struct window **flat, int i)
+static ptrdiff_t
+get_leaf_windows (struct window *w, struct window **flat, ptrdiff_t i)
 {
   while (w)
     {
@@ -6587,12 +6593,12 @@ get_phys_cursor_glyph (struct window *w)
 }
 
 
-static int
-save_window_save (Lisp_Object window, struct Lisp_Vector *vector, int i)
+static ptrdiff_t
+save_window_save (Lisp_Object window, struct Lisp_Vector *vector, ptrdiff_t i)
 {
-  register struct saved_window *p;
-  register struct window *w;
-  register Lisp_Object tem, pers, par;
+  struct saved_window *p;
+  struct window *w;
+  Lisp_Object tem, pers, par;
 
   for (; !NILP (window); window = w->next)
     {
@@ -6730,10 +6736,9 @@ redirection (see `redirect-frame-focus').  The variable
 saved by this function.  */)
   (Lisp_Object frame)
 {
-  register Lisp_Object tem;
-  register int n_windows;
-  register struct save_window_data *data;
-  register int i;
+  Lisp_Object tem;
+  ptrdiff_t i, n_windows;
+  struct save_window_data *data;
   struct frame *f = decode_live_frame (frame);
 
   n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f)));
@@ -6772,7 +6777,7 @@ apply_window_adjustment (struct window *w)
 {
   eassert (w);
   clear_glyph_matrix (w->current_matrix);
-  w->window_end_valid = 0;
+  w->window_end_valid = false;
   windows_or_buffers_changed = 30;
   wset_redisplay (w);
   adjust_frame_glyphs (XFRAME (WINDOW_FRAME (w)));
@@ -6783,17 +6788,22 @@ apply_window_adjustment (struct window *w)
                             Marginal Areas
  ***********************************************************************/
 
+static int
+extract_dimension (Lisp_Object dimension)
+{
+  if (NILP (dimension))
+    return -1;
+  CHECK_RANGED_INTEGER (dimension, 0, INT_MAX);
+  return XINT (dimension);
+}
+
 static struct window *
 set_window_margins (struct window *w, Lisp_Object left_width,
                     Lisp_Object right_width)
 {
-  int left, right;
   int unit = WINDOW_FRAME_COLUMN_WIDTH (w);
-
-  left = (NILP (left_width) ? 0
-          : (CHECK_NATNUM (left_width), XINT (left_width)));
-  right = (NILP (right_width) ? 0
-           : (CHECK_NATNUM (right_width), XINT (right_width)));
+  int left = NILP (left_width) ? 0 : extract_dimension (left_width);
+  int right = NILP (right_width) ? 0 : extract_dimension (right_width);
 
   if (w->left_margin_cols != left || w->right_margin_cols != right)
     {
@@ -6862,12 +6872,9 @@ static struct window *
 set_window_fringes (struct window *w, Lisp_Object left_width,
                     Lisp_Object right_width, Lisp_Object outside_margins)
 {
-  int left, right, outside = !NILP (outside_margins);
-
-  left = (NILP (left_width) ? -1
-          : (CHECK_NATNUM (left_width), XINT (left_width)));
-  right = (NILP (right_width) ? -1
-           : (CHECK_NATNUM (right_width), XINT (right_width)));
+  bool outside = !NILP (outside_margins);
+  int left = extract_dimension (left_width);
+  int right = extract_dimension (right_width);
 
   /* Do nothing on a tty or if nothing to actually change.  */
   if (FRAME_WINDOW_P (WINDOW_XFRAME (w))
@@ -6947,8 +6954,8 @@ set_window_scroll_bars (struct window *w, Lisp_Object width,
                         Lisp_Object vertical_type, Lisp_Object height,
                         Lisp_Object horizontal_type)
 {
-  int iwidth = (NILP (width) ? -1 : (CHECK_NATNUM (width), XINT (width)));
-  bool changed = 0;
+  int iwidth = extract_dimension (width);
+  bool changed = false;
 
   if (iwidth == 0)
     vertical_type = Qnil;
@@ -6971,13 +6978,13 @@ set_window_scroll_bars (struct window *w, Lisp_Object width,
         {
           w->scroll_bar_width = iwidth;
           wset_vertical_scroll_bar_type (w, vertical_type);
-          changed = 1;
+          changed = true;
         }
     }
 
 #if USE_HORIZONTAL_SCROLL_BARS
   {
-    int iheight = (NILP (height) ? -1 : (CHECK_NATNUM (height), XINT (height)));
+    int iheight = extract_dimension (height);
 
     if (MINI_WINDOW_P (w) || iheight == 0)
       horizontal_type = Qnil;
@@ -6999,7 +7006,7 @@ set_window_scroll_bars (struct window *w, Lisp_Object width,
           {
             w->scroll_bar_height = iheight;
             wset_horizontal_scroll_bar_type (w, horizontal_type);
-            changed = 1;
+            changed = true;
           }
       }
   }
@@ -7122,7 +7129,7 @@ If PIXELS-P is non-nil, the return value is VSCROLL.  */)
             adjust_frame_glyphs (f);
 
           /* Prevent redisplay shortcuts.  */
-          XBUFFER (w->contents)->prevent_redisplay_optimizations_p = 1;
+          XBUFFER (w->contents)->prevent_redisplay_optimizations_p = true;
         }
     }
 
@@ -7135,7 +7142,7 @@ If PIXELS-P is non-nil, the return value is VSCROLL.  */)
    additional argument USER_DATA.  Stops when FN returns 0.  */
 
 static void
-foreach_window (struct frame *f, int (*fn) (struct window *, void *),
+foreach_window (struct frame *f, bool (*fn) (struct window *, void *),
                 void *user_data)
 {
   /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil.  */
@@ -7147,14 +7154,15 @@ foreach_window (struct frame *f, int (*fn) (struct window *, void *),
 /* Helper function for foreach_window.  Call FN for all leaf windows
    reachable from W.  FN is called with the first argument being a
    pointer to the leaf window, and with additional argument USER_DATA.
-   Stop when FN returns 0.  Value is 0 if stopped by FN.  */
+   Stop when FN returns false.  Value is false if stopped by FN.  */
 
-static int
-foreach_window_1 (struct window *w, int (*fn) (struct window *, void *), void *user_data)
+static bool
+foreach_window_1 (struct window *w, bool (*fn) (struct window *, void *),
+                  void *user_data)
 {
-  int cont;
+  bool cont;
 
-  for (cont = 1; w && cont;)
+  for (cont = true; w && cont;)
     {
       if (WINDOWP (w->contents))
         cont = foreach_window_1 (XWINDOW (w->contents), fn, user_data);
@@ -7171,7 +7179,7 @@ foreach_window_1 (struct window *w, int (*fn) (struct window *, void *), void *u
                             Initialization
  ***********************************************************************/
 
-/* Return 1 if window configurations CONFIGURATION1 and CONFIGURATION2
+/* Return true if window configurations CONFIGURATION1 and CONFIGURATION2
    describe the same state of affairs.  This is used by Fequal.
 
    IGNORE_POSITIONS means ignore non-matching scroll positions
@@ -7210,7 +7218,7 @@ compare_window_configurations (Lisp_Object configuration1,
       || !EQ (d1->focus_frame, d2->focus_frame)
       /* Verify that the two configurations have the same number of windows.  */
       || sws1->header.size != sws2->header.size)
-    return 0;
+    return false;
 
   for (i = 0; i < sws1->header.size; i++)
     {
@@ -7254,10 +7262,10 @@ compare_window_configurations (Lisp_Object configuration1,
           || !EQ (sw1->scroll_bar_height, sw2->scroll_bar_height)
           || !EQ (sw1->vertical_scroll_bar_type, sw2->vertical_scroll_bar_type)
           || !EQ (sw1->horizontal_scroll_bar_type, sw2->horizontal_scroll_bar_type))
-        return 0;
+        return false;
     }
 
-  return 1;
+  return true;
 }
 
 DEFUN ("compare-window-configurations", Fcompare_window_configurations,
@@ -7267,7 +7275,7 @@ This function ignores details such as the values of point
 and scrolling positions.  */)
   (Lisp_Object x, Lisp_Object y)
 {
-  if (compare_window_configurations (x, y, 1))
+  if (compare_window_configurations (x, y, true))
     return Qt;
   return Qnil;
 }
diff --git a/src/window.h b/src/window.h
index 2ec28ab4e56..eaff57eaedf 100644
--- a/src/window.h
+++ b/src/window.h
@@ -195,10 +195,10 @@ struct window
     Lisp_Object next_buffers;
 
     /* Number saying how recently window was selected.  */
-    int use_time;
+    EMACS_INT use_time;
 
     /* Unique number of window assigned when it was created.  */
-    int sequence_number;
+    EMACS_INT sequence_number;
 
     /* The upper left corner pixel coordinates of this window, as
        integers relative to upper left corner of frame = 0, 0.  */
@@ -256,7 +256,7 @@ struct window
 
     /* Scaling factor for the glyph_matrix size calculation in this window.
        Used if window contains many small images or uses proportional fonts,
-       as the normal  may yield a matrix which is too small.  */
+       as the normal may yield a matrix which is too small.  */
     int nrows_scale_factor, ncols_scale_factor;
 
     /* Intended cursor position.   This is a position within the
@@ -323,7 +323,7 @@ struct window
     /* True if this window is a minibuffer window.  */
     bool_bf mini : 1;
 
-    /* Meaningful only if contents is a window, non-zero if this
+    /* Meaningful only if contents is a window, true if this
        internal window is used in horizontal combination.  */
     bool_bf horizontal : 1;
 
@@ -921,7 +921,7 @@ wset_next_buffers (struct window *w, Lisp_Object val)
    : 0)
 
 #define WINDOW_MODE_LINE_LINES(W)       \
-  (!! WINDOW_WANTS_MODELINE_P (W))
+  WINDOW_WANTS_MODELINE_P (W)
 
 /* Height in pixels, and in lines, of the header line.
    Zero if W doesn't have a header line.  */
@@ -931,7 +931,7 @@ wset_next_buffers (struct window *w, Lisp_Object val)
    : 0)
 
 #define WINDOW_HEADER_LINE_LINES(W)     \
-  (!! WINDOW_WANTS_HEADER_LINE_P (W))
+  WINDOW_WANTS_HEADER_LINE_P (W)
 
 /* Pixel height of window W without mode line, bottom scroll bar and
    bottom divider.  */
@@ -990,7 +990,7 @@ extern Lisp_Object selected_window;
    recently used window.  Its only users are Fselect_window,
    init_window_once, and make_frame.  */
 
-extern int window_select_count;
+extern EMACS_INT window_select_count;
 
 /* The minibuffer window of the selected frame.
    Note that you cannot test for minibufferness of an arbitrary window
@@ -1015,7 +1015,7 @@ extern int window_relative_x_coord (struct window *, enum window_part, int);
 
 void run_window_configuration_change_hook (struct frame *f);
 
-/* Make WINDOW display BUFFER.  RUN_HOOKS_P non-zero means it's allowed
+/* Make WINDOW display BUFFER.  RUN_HOOKS_P means it's allowed
    to run hooks.  See make_frame for a case where it's not allowed.  */
 
 void set_window_buffer (Lisp_Object window, Lisp_Object buffer,
@@ -1067,7 +1067,7 @@ extern void redisplay_other_windows (void);
 
 struct glyph *get_phys_cursor_glyph (struct window *w);
 
-/* Value is non-zero if WINDOW is a valid window.  */
+/* True if WINDOW is a valid window.  */
 #define WINDOW_VALID_P(WINDOW)                                  \
   (WINDOWP (WINDOW) && !NILP (XWINDOW (WINDOW)->contents))      \
 
@@ -1076,7 +1076,7 @@ struct glyph *get_phys_cursor_glyph (struct window *w);
 #define CHECK_VALID_WINDOW(WINDOW)                              \
   CHECK_TYPE (WINDOW_VALID_P (WINDOW), Qwindow_valid_p, WINDOW)
 
-/* Value is non-zero if WINDOW is a live window.  */
+/* True if WINDOW is a live window.  */
 #define WINDOW_LIVE_P(WINDOW)                                   \
   (WINDOWP (WINDOW) && BUFFERP (XWINDOW (WINDOW)->contents))
 
diff --git a/src/xdisp.c b/src/xdisp.c
index a17f5a9c34f..5a27adc2b18 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -6971,7 +6971,7 @@ get_next_display_element (struct it *it)
                 if (CHAR_BYTE8_P (c))
                   /* Display \200 instead of \17777600.  */
                   c = CHAR_TO_BYTE8 (c);
-                len = sprintf (str, "%03o", c);
+                len = sprintf (str, "%03o", c + 0u);
 
                 XSETINT (it->ctl_chars[0], escape_glyph);
                 for (i = 0; i < len; i++)
@@ -10053,8 +10053,8 @@ message3 (Lisp_Object m)
       message_dolog (buffer, nbytes, true, multibyte);
       SAFE_FREE ();
     }
-  message3_nolog (m);
-
+  if (! inhibit_message)
+    message3_nolog (m);
   UNGCPRO;
 }
 
@@ -26233,7 +26233,7 @@ produce_glyphless_glyph (struct it *it, bool for_no_font, Lisp_Object acronym)
       else
         {
           eassert (it->glyphless_method == GLYPHLESS_DISPLAY_HEX_CODE);
-          sprintf (buf, "%0*X", it->c < 0x10000 ? 4 : 6, it->c);
+          sprintf (buf, "%0*X", it->c < 0x10000 ? 4 : 6, it->c + 0u);
           str = buf;
         }
       for (len = 0; str[len] && ASCII_CHAR_P (str[len]) && len < 6; len++)
@@ -30430,6 +30430,11 @@ syms_of_xdisp (void)
 
   DEFSYM (Qredisplay_internal, "redisplay_internal (C function)");
 
+  DEFVAR_BOOL("inhibit-message", inhibit_message,
+              doc:  /* Non-nil means calls to `message' are not displayed.
+They are still logged to the *Messages* buffer.  */);
+  inhibit_message = 0;
+
   message_dolog_marker1 = Fmake_marker ();
   staticpro (&message_dolog_marker1);
   message_dolog_marker2 = Fmake_marker ();
diff --git a/src/xfaces.c b/src/xfaces.c
index b2697220bce..d198c4be1a9 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -1822,7 +1822,7 @@ resolve_face_name (Lisp_Object face_name, bool signal_p)
   Lisp_Object tortoise, hare;
 
   if (STRINGP (face_name))
-    face_name = intern (SSDATA (face_name));
+    face_name = Fintern (face_name, Qnil);
 
   if (NILP (face_name) || !SYMBOLP (face_name))
     return face_name;
diff --git a/src/xselect.c b/src/xselect.c
index 027192dfea2..1570c4fef9c 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -531,6 +531,16 @@ static struct prop_location *property_change_reply_object;
 
 static struct prop_location *property_change_wait_list;
 
+static void
+set_property_change_object (struct prop_location *location)
+{
+  /* Input must be blocked so we don't get the event before we set these.  */
+  if (! input_blocked_p ())
+    emacs_abort ();
+  XSETCAR (property_change_reply, Qnil);
+  property_change_reply_object = location;
+}
+
 
 /* Send the reply to a selection request event EVENT.  */
 
@@ -633,6 +643,11 @@ x_reply_selection_request (struct input_event *event,
       {
         int format_bytes = cs->format / 8;
         bool had_errors_p = x_had_errors_p (display);
+
+        /* Must set this inside block_input ().  unblock_input may read
+           events and setting property_change_reply in
+           wait_for_property_change is then too late.  */
+        set_property_change_object (cs->wait_object);
         unblock_input ();
 
         bytes_remaining = cs->size;
@@ -673,6 +688,8 @@ x_reply_selection_request (struct input_event *event,
                              : format_bytes);
             XFlush (display);
             had_errors_p = x_had_errors_p (display);
+            // See comment above about property_change_reply.
+            set_property_change_object (cs->wait_object);
             unblock_input ();
 
             if (had_errors_p) break;
@@ -1059,14 +1076,11 @@ wait_for_property_change (struct prop_location *location)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
 
-  if (property_change_reply_object)
-    emacs_abort ();
-
   /* Make sure to do unexpect_property_change if we quit or err.  */
   record_unwind_protect_ptr (wait_for_property_change_unwind, location);
 
-  XSETCAR (property_change_reply, Qnil);
-  property_change_reply_object = location;
+  /* See comment in x_reply_selection_request about setting
+     property_change_reply.  Do not do it here.  */
 
   /* If the event we are waiting for arrives beyond here, it will set
      property_change_reply, because property_change_reply_object says so.  */
@@ -1381,6 +1395,8 @@ receive_incremental_selection (struct x_display_info *dpyinfo,
   wait_object = expect_property_change (display, window, property,
                                         PropertyNewValue);
   XFlush (display);
+  // See comment in x_reply_selection_request about property_change_reply.
+  set_property_change_object (wait_object);
   unblock_input ();
 
   while (true)
@@ -1419,6 +1435,8 @@ receive_incremental_selection (struct x_display_info *dpyinfo,
       XDeleteProperty (display, window, property);
       wait_object = expect_property_change (display, window, property,
                                             PropertyNewValue);
+      // See comment in x_reply_selection_request about property_change_reply.
+      set_property_change_object (wait_object);
       XFlush (display);
       unblock_input ();
 
diff --git a/src/xterm.c b/src/xterm.c
index 6e7ef366d5f..3d3e0a70cfa 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -1955,7 +1955,7 @@ x_draw_glyphless_glyph_string_foreground (struct glyph_string *s)
         {
           sprintf (buf, "%0*X",
                    glyph->u.glyphless.ch < 0x10000 ? 4 : 6,
-                   glyph->u.glyphless.ch);
+                   glyph->u.glyphless.ch + 0u);
           str = buf;
         }
 
@@ -2048,9 +2048,9 @@ x_alloc_lighter_color_for_widget (Widget widget, Display *display, Colormap cmap
 
 static XtConvertArgRec cvt_string_to_pixel_args[] =
   {
-    {XtWidgetBaseOffset, (XtPointer) XtOffset (Widget, core.screen),
+    {XtWidgetBaseOffset, (XtPointer) offsetof (WidgetRec, core.screen),
      sizeof (Screen *)},
-    {XtWidgetBaseOffset, (XtPointer) XtOffset (Widget, core.colormap),
+    {XtWidgetBaseOffset, (XtPointer) offsetof (WidgetRec, core.colormap),
      sizeof (Colormap)}
   };