Merge branch 'master' of git.sv.gnu.org:/srv/git/emacs

91 files changed, 8186 insertions, 2992 deletions

diff --git a/src/.gdbinit b/src/.gdbinit
index 6d7476d5a72..b5a974bb38d 100644
--- a/src/.gdbinit
+++ b/src/.gdbinit
@@ -1264,3 +1264,99 @@ commands
   end
   continue
 end
+
+
+# Put the Python code at the end of .gdbinit so that if GDB does not
+# support Python, GDB will do all the above initializations before
+# reporting an error.
+
+python
+
+# Omit pretty-printing in older (pre-7.3) GDBs that lack it.
+if hasattr(gdb, 'printing'):
+
+  class Emacs_Pretty_Printers (gdb.printing.RegexpCollectionPrettyPrinter):
+    """A collection of pretty-printers.  This is like GDB's
+       RegexpCollectionPrettyPrinter except when printing Lisp_Object."""
+    def __call__ (self, val):
+      """Look up the pretty-printer for the provided value."""
+      type = val.type.unqualified ()
+      typename = type.tag or type.name
+      basic_type = gdb.types.get_basic_type (type)
+      basic_typename = basic_type.tag or basic_type.name
+      for printer in self.subprinters:
+        if (printer.enabled
+            and ((printer.regexp == '^Lisp_Object$'
+                  and typename == 'Lisp_Object')
+                 or (basic_typename
+                     and printer.compiled_re.search (basic_typename)))):
+          return printer.gen_printer (val)
+      return None
+
+  class Lisp_Object_Printer:
+    "A printer for Lisp_Object values."
+    def __init__ (self, val):
+      self.val = val
+
+    def to_string (self):
+      "Yield a string that can be fed back into GDB."
+
+      # This implementation should work regardless of C compiler, and
+      # it should not attempt to run any code in the inferior.
+      EMACS_INT_WIDTH = int(gdb.lookup_symbol("EMACS_INT_WIDTH")[0].value())
+      USE_LSB_TAG = int(gdb.lookup_symbol("USE_LSB_TAG")[0].value())
+      GCTYPEBITS = 3
+      VALBITS = EMACS_INT_WIDTH - GCTYPEBITS
+      Lisp_Int0 = 2
+      Lisp_Int1 = 6 if USE_LSB_TAG else 3
+
+      # Unpack the Lisp value from its containing structure, if necessary.
+      val = self.val
+      basic_type = gdb.types.get_basic_type (val.type)
+      if (basic_type.code == gdb.TYPE_CODE_STRUCT
+          and gdb.types.has_field (basic_type, "i")):
+        val = val["i"]
+
+      # For nil, yield "XIL(0)", which is easier to read than "XIL(0x0)".
+      if not val:
+        return "XIL(0)"
+
+      # Extract the integer representation of the value and its Lisp type.
+      ival = int(val)
+      itype = ival >> (0 if USE_LSB_TAG else VALBITS)
+      itype = itype & ((1 << GCTYPEBITS) - 1)
+
+      # For a Lisp integer N, yield "make_number(N)".
+      if itype == Lisp_Int0 or itype == Lisp_Int1:
+        if USE_LSB_TAG:
+          ival = ival >> (GCTYPEBITS - 1)
+        elif (ival >> VALBITS) & 1:
+          ival = ival | (-1 << VALBITS)
+        else:
+          ival = ival & ((1 << VALBITS) - 1)
+        return "make_number(%d)" % ival
+
+      # For non-integers other than nil yield "XIL(N)", where N is a C integer.
+      # This helps humans distinguish Lisp_Object values from ordinary
+      # integers even when Lisp_Object is an integer.
+      # Perhaps some day the pretty-printing could be fancier.
+      # Prefer the unsigned representation to negative values, converting
+      # by hand as val.cast(gdb.lookup_type("EMACS_UINT") does not work in
+      # GDB 7.12.1; see <http://patchwork.sourceware.org/patch/11557/>.
+      if ival < 0:
+        ival = ival + (1 << EMACS_INT_WIDTH)
+      return "XIL(0x%x)" % ival
+
+  def build_pretty_printer ():
+    pp = Emacs_Pretty_Printers ("Emacs")
+    pp.add_printer ('Lisp_Object', '^Lisp_Object$', Lisp_Object_Printer)
+    return pp
+
+  gdb.printing.register_pretty_printer (gdb.current_objfile (),
+                                        build_pretty_printer (), True)
+end
+
+# GDB mishandles indentation with leading tabs when feeding it to Python.
+# Local Variables:
+# indent-tabs-mode: nil
+# End:
diff --git a/src/ChangeLog.13 b/src/ChangeLog.13
index 3a58c0cc754..66f062d3d3f 100644
--- a/src/ChangeLog.13
+++ b/src/ChangeLog.13
@@ -17504,7 +17504,7 @@
         * casetab.c (init_casetab_once): Don't abuse the ascii eqv table for
         the upcase table.
 
-2013-03-27  rzl24ozi  <rzl24ozi@gmail.com>  (tiny changes)
+2013-03-27  rzl24ozi  <rzl24ozi@gmail.com>  (tiny change)
 
         * image.c [WINDOWSNT]: Fix calls to DEF_IMGLIB_FN for SVG function.
 
diff --git a/src/Makefile.in b/src/Makefile.in
index 5a3d0bd0445..57969d5fc58 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -48,7 +48,6 @@ lispsource = $(top_srcdir)/lisp
 lib = ../lib
 libsrc = ../lib-src
 etc = ../etc
-leimdir = ${lispsource}/leim
 oldXMenudir = ../oldXMenu
 lwlibdir = ../lwlib
 
@@ -347,16 +346,6 @@ am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
 am__v_at_0 = @
 am__v_at_1 =
 
-AUTO_DEPEND = @AUTO_DEPEND@
-DEPDIR = deps
-ifeq ($(AUTO_DEPEND),yes)
-  DEPFLAGS = -MMD -MF $(DEPDIR)/$*.d -MP
-  -include $(ALLOBJS:%.o=$(DEPDIR)/%.d)
-else
-  DEPFLAGS =
-  include $(srcdir)/deps.mk
-endif
-
 # Flags that might be in WARN_CFLAGS but are not valid for Objective C.
 NON_OBJC_CFLAGS = -Wignored-attributes -Wignored-qualifiers -Wopenmp-simd
 
@@ -445,6 +434,16 @@ otherobj= $(TERMCAP_OBJ) $(PRE_ALLOC_OBJ) $(GMALLOC_OBJ) $(RALLOC_OBJ) \
 FIRSTFILE_OBJ=@FIRSTFILE_OBJ@
 ALLOBJS = $(FIRSTFILE_OBJ) $(VMLIMIT_OBJ) $(obj) $(otherobj)
 
+AUTO_DEPEND = @AUTO_DEPEND@
+DEPDIR = deps
+ifeq ($(AUTO_DEPEND),yes)
+  DEPFLAGS = -MMD -MF $(DEPDIR)/$*.d -MP
+  -include $(ALLOBJS:%.o=$(DEPDIR)/%.d)
+else
+  DEPFLAGS =
+  include $(srcdir)/deps.mk
+endif
+
 all: emacs$(EXEEXT) $(OTHER_FILES)
 .PHONY: all
 
@@ -494,9 +493,6 @@ LIBES = $(LIBS) $(W32_LIBS) $(LIBS_GNUSTEP) $(LIBX_BASE) $(LIBIMAGE) \
    $(LIBGNUTLS_LIBS) $(LIB_PTHREAD) $(GETADDRINFO_A_LIBS) \
    $(NOTIFY_LIBS) $(LIB_MATH) $(LIBZ) $(LIBMODULES) $(LIBSYSTEMD_LIBS)
 
-$(leimdir)/leim-list.el: bootstrap-emacs$(EXEEXT)
-        $(MAKE) -C ../leim leim-list.el EMACS="$(bootstrap_exe)"
-
 ## FORCE it so that admin/unidata can decide whether these files
 ## are up-to-date.  Although since charprop depends on bootstrap-emacs,
 ## and emacs (which recreates bootstrap-emacs) depends on charprop,
@@ -507,12 +503,8 @@ $(srcdir)/macuvs.h $(lispsource)/international/charprop.el: \
 
 ## We require charprop.el to exist before ucs-normalize.el is
 ## byte-compiled, because ucs-normalize.el needs to load 2 uni-*.el files.
-$(lispsource)/international/ucs-normalize.elc: | \
-  $(lispsource)/international/charprop.el
-
-## ns-win.el loads ucs-normalize, so it also needs the above-mentioned
-## 2 uni-*.el files to exist.
-$(lispsource)/term/ns-win.elc: | \
+## And ns-win requires ucs-normalize.
+$(lispsource)/international/ucs-normalize.elc $(lispsource)/term/ns-win.elc: | \
   $(lispsource)/international/charprop.el
 
 lispintdir = ${lispsource}/international
@@ -535,7 +527,7 @@ ${lispintdir}/characters.elc: ${charscript:.el=.elc}
 ## since not all pieces are used on all platforms.  But DOC depends
 ## on all of $lisp, and emacs depends on DOC, so it is ok to use $lisp here.
 emacs$(EXEEXT): temacs$(EXEEXT) \
-                lisp.mk $(etc)/DOC $(lisp) $(leimdir)/leim-list.el \
+                lisp.mk $(etc)/DOC $(lisp) \
                 $(lispsource)/international/charprop.el ${charsets}
 ifeq ($(CANNOT_DUMP),yes)
         ln -f temacs$(EXEEXT) $@
@@ -647,13 +639,13 @@ mostlyclean:
         rm -f globals.h gl-stamp
         rm -f *.res *.tmp
 clean: mostlyclean
-        rm -f emacs-*.*.*$(EXEEXT) emacs$(EXEEXT) $(DEPDIR)/*
+        rm -f emacs-*.*.*[0-9]$(EXEEXT) emacs$(EXEEXT) $(DEPDIR)/*
 
 ## bootstrap-clean is used to clean up just before a bootstrap.
 ## It should remove all files generated during a compilation/bootstrap,
 ## but not things like config.status or TAGS.
 bootstrap-clean: clean
-        rm -f epaths.h config.h config.stamp
+        rm -f emacs-module.h epaths.h config.h config.stamp
         if test -f ./.gdbinit; then \
           mv ./.gdbinit ./.gdbinit.save; \
           if test -f "$(srcdir)/.gdbinit"; then rm -f ./.gdbinit.save; \
diff --git a/src/alloc.c b/src/alloc.c
index ae3e1519c04..ac3de83b2b6 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -75,14 +75,20 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 static bool valgrind_p;
 #endif
 
-/* GC_CHECK_MARKED_OBJECTS means do sanity checks on allocated objects.  */
+/* GC_CHECK_MARKED_OBJECTS means do sanity checks on allocated objects.
+   We turn that on by default when ENABLE_CHECKING is defined;
+   define GC_CHECK_MARKED_OBJECTS to zero to disable.  */
+
+#if defined ENABLE_CHECKING && !defined GC_CHECK_MARKED_OBJECTS
+# define GC_CHECK_MARKED_OBJECTS 1
+#endif
 
 /* GC_MALLOC_CHECK defined means perform validity checks of malloc'd
    memory.  Can do this only if using gmalloc.c and if not checking
    marked objects.  */
 
 #if (defined SYSTEM_MALLOC || defined DOUG_LEA_MALLOC \
-     || defined HYBRID_MALLOC || defined GC_CHECK_MARKED_OBJECTS)
+     || defined HYBRID_MALLOC || GC_CHECK_MARKED_OBJECTS)
 #undef GC_MALLOC_CHECK
 #endif
 
@@ -3371,7 +3377,7 @@ allocate_pseudovector (int memlen, int lisplen,
   eassert (0 <= tag && tag <= PVEC_FONT);
   eassert (0 <= lisplen && lisplen <= zerolen && zerolen <= memlen);
   eassert (memlen - lisplen <= (1 << PSEUDOVECTOR_REST_BITS) - 1);
-  eassert (lisplen <= (1 << PSEUDOVECTOR_SIZE_BITS) - 1);
+  eassert (lisplen <= PSEUDOVECTOR_SIZE_MASK);
 
   /* Only the first LISPLEN slots will be traced normally by the GC.  */
   memclear (v->contents, zerolen * word_size);
@@ -3392,6 +3398,54 @@ allocate_buffer (void)
   return b;
 }
 
+
+/* Allocate a record with COUNT slots.  COUNT must be positive, and
+   includes the type slot.  */
+
+static struct Lisp_Vector *
+allocate_record (EMACS_INT count)
+{
+  if (count > PSEUDOVECTOR_SIZE_MASK)
+    error ("Attempt to allocate a record of %"pI"d slots; max is %d",
+           count, PSEUDOVECTOR_SIZE_MASK);
+  struct Lisp_Vector *p = allocate_vectorlike (count);
+  p->header.size = count;
+  XSETPVECTYPE (p, PVEC_RECORD);
+  return p;
+}
+
+
+DEFUN ("make-record", Fmake_record, Smake_record, 3, 3, 0,
+       doc: /* Create a new record.
+TYPE is its type as returned by `type-of'; it should be either a
+symbol or a type descriptor.  SLOTS is the number of non-type slots,
+each initialized to INIT.  */)
+  (Lisp_Object type, Lisp_Object slots, Lisp_Object init)
+{
+  CHECK_NATNUM (slots);
+  EMACS_INT size = XFASTINT (slots) + 1;
+  struct Lisp_Vector *p = allocate_record (size);
+  p->contents[0] = type;
+  for (ptrdiff_t i = 1; i < size; i++)
+    p->contents[i] = init;
+  return make_lisp_ptr (p, Lisp_Vectorlike);
+}
+
+
+DEFUN ("record", Frecord, Srecord, 1, MANY, 0,
+       doc: /* Create a new record.
+TYPE is its type as returned by `type-of'; it should be either a
+symbol or a type descriptor.  SLOTS is used to initialize the record
+slots with shallow copies of the arguments.
+usage: (record TYPE &rest SLOTS) */)
+  (ptrdiff_t nargs, Lisp_Object *args)
+{
+  struct Lisp_Vector *p = allocate_record (nargs);
+  memcpy (p->contents, args, nargs * sizeof *args);
+  return make_lisp_ptr (p, Lisp_Vectorlike);
+}
+
+
 DEFUN ("make-vector", Fmake_vector, Smake_vector, 2, 2, 0,
        doc: /* Return a newly created vector of length LENGTH, with each element being INIT.
 See also the function `vector'.  */)
@@ -3888,7 +3942,6 @@ make_user_ptr (void (*finalizer) (void *), void *p)
   uptr->p = p;
   return obj;
 }
-
 #endif
 
 static void
@@ -5532,7 +5585,7 @@ purecopy (Lisp_Object obj)
       struct Lisp_Hash_Table *h = purecopy_hash_table (table);
       XSET_HASH_TABLE (obj, h);
     }
-  else if (COMPILEDP (obj) || VECTORP (obj))
+  else if (COMPILEDP (obj) || VECTORP (obj) || RECORDP (obj))
     {
       struct Lisp_Vector *objp = XVECTOR (obj);
       ptrdiff_t nbytes = vector_nbytes (objp);
@@ -5889,6 +5942,10 @@ garbage_collect_1 (void *end)
   mark_fringe_data ();
 #endif
 
+#ifdef HAVE_MODULES
+  mark_modules ();
+#endif
+
   /* Everything is now marked, except for the data in font caches,
      undo lists, and finalizers.  The first two are compacted by
      removing an items which aren't reachable otherwise.  */
@@ -6295,7 +6352,7 @@ mark_object (Lisp_Object arg)
 {
   register Lisp_Object obj;
   void *po;
-#ifdef GC_CHECK_MARKED_OBJECTS
+#if GC_CHECK_MARKED_OBJECTS
   struct mem_node *m;
 #endif
   ptrdiff_t cdr_count = 0;
@@ -6314,7 +6371,7 @@ mark_object (Lisp_Object arg)
   /* Perform some sanity checks on the objects marked here.  Abort if
      we encounter an object we know is bogus.  This increases GC time
      by ~80%.  */
-#ifdef GC_CHECK_MARKED_OBJECTS
+#if GC_CHECK_MARKED_OBJECTS
 
   /* Check that the object pointed to by PO is known to be a Lisp
      structure allocated from the heap.  */
@@ -6383,7 +6440,7 @@ mark_object (Lisp_Object arg)
         if (VECTOR_MARKED_P (ptr))
           break;
 
-#ifdef GC_CHECK_MARKED_OBJECTS
+#if GC_CHECK_MARKED_OBJECTS
         m = mem_find (po);
         if (m == MEM_NIL && !SUBRP (obj) && !main_thread_p (po))
           emacs_abort ();
@@ -6400,7 +6457,7 @@ mark_object (Lisp_Object arg)
         switch (pvectype)
           {
           case PVEC_BUFFER:
-#ifdef GC_CHECK_MARKED_OBJECTS
+#if GC_CHECK_MARKED_OBJECTS
             {
               struct buffer *b;
               FOR_EACH_BUFFER (b)
@@ -7107,7 +7164,7 @@ We divide the value by 1024 to make sure it fits in a Lisp integer.  */)
 {
   Lisp_Object end;
 
-#if defined HAVE_NS || !HAVE_SBRK
+#if defined HAVE_NS || defined __APPLE__ || !HAVE_SBRK
   /* Avoid warning.  sbrk has no relation to memory allocated anyway.  */
   XSETINT (end, 0);
 #else
@@ -7461,10 +7518,12 @@ The time is in seconds as a floating point value.  */);
   defsubr (&Scons);
   defsubr (&Slist);
   defsubr (&Svector);
+  defsubr (&Srecord);
   defsubr (&Sbool_vector);
   defsubr (&Smake_byte_code);
   defsubr (&Smake_list);
   defsubr (&Smake_vector);
+  defsubr (&Smake_record);
   defsubr (&Smake_string);
   defsubr (&Smake_bool_vector);
   defsubr (&Smake_symbol);
diff --git a/src/bidi.c b/src/bidi.c
index b75ad933626..e34da778ba0 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -565,9 +565,7 @@ bidi_copy_it (struct bidi_it *to, struct bidi_it *from)
    RTL characters in the offending line of text.  */
 /* Do we need to allow customization of this limit?  */
 #define BIDI_CACHE_MAX_ELTS_PER_SLOT 50000
-#if BIDI_CACHE_CHUNK >= BIDI_CACHE_MAX_ELTS_PER_SLOT
-# error BIDI_CACHE_CHUNK must be less than BIDI_CACHE_MAX_ELTS_PER_SLOT
-#endif
+verify (BIDI_CACHE_CHUNK < BIDI_CACHE_MAX_ELTS_PER_SLOT);
 static ptrdiff_t bidi_cache_max_elts = BIDI_CACHE_MAX_ELTS_PER_SLOT;
 static struct bidi_it *bidi_cache;
 static ptrdiff_t bidi_cache_size = 0;
@@ -2092,7 +2090,7 @@ bidi_resolve_explicit (struct bidi_it *bidi_it)
           type = RLI;
           bidi_it->orig_type = type;
         }
-      /* FALLTHROUGH */
+      FALLTHROUGH;
     case RLI:   /* X5a */
       if (override == NEUTRAL_DIR)
         bidi_it->type_after_wn = type;
@@ -2468,9 +2466,11 @@ typedef struct bpa_stack_entry {
   unsigned flags : 2;
 } bpa_stack_entry;
 
-/* With MAX_ALLOCA of 16KB, this should allow at least 1K slots in the
+/* Allow for the two struct bidi_it objects too, since they can be big.
+   With MAX_ALLOCA of 16 KiB, this should allow at least 900 slots in the
    BPA stack, which should be more than enough for actual bidi text.  */
-#define MAX_BPA_STACK ((int)max (MAX_ALLOCA / sizeof (bpa_stack_entry), 1))
+enum { MAX_BPA_STACK = max (1, ((MAX_ALLOCA - 2 * sizeof (struct bidi_it))
+                                / sizeof (bpa_stack_entry))) };
 
 /* UAX#9 says to match opening brackets with the matching closing
    brackets or their canonical equivalents.  As of Unicode 8.0, there
@@ -2517,7 +2517,7 @@ typedef struct bpa_stack_entry {
 #define PUSH_BPA_STACK                                                  \
   do {                                                                  \
     int ch;                                                             \
-    if (bpa_sp < MAX_BPA_STACK - 1)                                     \
+    if (bpa_sp < MAX_BPA_STACK - 1 && bidi_cache_last_idx <= INT_MAX)   \
       {                                                                 \
         bpa_sp++;                                                       \
         ch = CANONICAL_EQU (bidi_it->ch);                               \
@@ -2563,7 +2563,7 @@ bidi_find_bracket_pairs (struct bidi_it *bidi_it)
       ptrdiff_t pairing_pos;
       int idx_at_entry = bidi_cache_idx;
 
-      eassert (MAX_BPA_STACK >= 100);
+      verify (MAX_BPA_STACK >= 100);
       bidi_copy_it (&saved_it, bidi_it);
       /* bidi_cache_iterator_state refuses to cache on backward scans,
          and bidi_cache_fetch_state doesn't bring scan_dir from the
diff --git a/src/buffer.c b/src/buffer.c
index ff4a500c8b7..80dbd3318dc 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -5486,8 +5486,11 @@ A string is printed verbatim in the mode line except for %-constructs:
         For a modified read-only buffer, %* gives % and %+ gives *.
   %s -- print process status.   %l -- print the current line number.
   %c -- print the current column number (this makes editing slower).
+        Columns are numbered starting from the left margin, and the
+        leftmost column is displayed as zero.
         To make the column number update correctly in all cases,
         `column-number-mode' must be non-nil.
+  %C -- Like %c, but the leftmost column is displayed as one.
   %i -- print the size of the buffer.
   %I -- like %i, but use k, M, G, etc., to abbreviate.
   %p -- print percent of buffer above top of window, or Top, Bot or All.
@@ -5629,7 +5632,9 @@ visual lines rather than logical lines.  See the documentation of
   DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer, directory),
                      Qstringp,
                      doc: /* Name of default directory of current buffer.
-To interactively change the default directory, use command `cd'.  */);
+It should be a directory name (as opposed to a directory file-name).
+On GNU and Unix systems, directory names end in a slash `/'.
+To interactively change the default directory, use command `cd'. */);
 
   DEFVAR_PER_BUFFER ("auto-fill-function", &BVAR (current_buffer, auto_fill_function),
                      Qnil,
diff --git a/src/buffer.h b/src/buffer.h
index a2bdc4e7294..be270fe4823 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -412,6 +412,15 @@ extern void enlarge_buffer_text (struct buffer *, ptrdiff_t);
    ? BUF_FETCH_MULTIBYTE_CHAR ((buf), (pos))    \
    : BUF_FETCH_BYTE ((buf), (pos)))
 
+/* Return character at byte position POS in buffer BUF.  If BUF is
+   unibyte and the character is not ASCII, make the returning
+   character multibyte.  */
+
+#define BUF_FETCH_CHAR_AS_MULTIBYTE(buf, pos)           \
+  (! NILP (BVAR ((buf), enable_multibyte_characters))   \
+   ? BUF_FETCH_MULTIBYTE_CHAR ((buf), (pos))            \
+   : UNIBYTE_TO_CHAR (BUF_FETCH_BYTE ((buf), (pos))))
+
 /* Return the byte at byte position N in buffer BUF.   */
 
 #define BUF_FETCH_BYTE(buf, n) \
diff --git a/src/callint.c b/src/callint.c
index d96454883cf..96436116c8b 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -690,6 +690,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
         case 'N':     /* Prefix arg as number, else number from minibuffer.  */
           if (!NILP (prefix_arg))
             goto have_prefix_arg;
+          FALLTHROUGH;
         case 'n':               /* Read number from minibuffer.  */
           args[i] = call1 (Qread_number, callint_message);
           /* Passing args[i] directly stimulates compiler bug.  */
diff --git a/src/callproc.c b/src/callproc.c
index 05048576ce9..4cec02be7ef 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -52,6 +52,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "syswait.h"
 #include "blockinput.h"
 #include "frame.h"
+#include "systty.h"
+#include "keyboard.h"
 
 #ifdef MSDOS
 #include "msdos.h"
@@ -200,10 +202,11 @@ call_process_cleanup (Lisp_Object buffer)
       message1 ("Waiting for process to die...(type C-g again to kill it instantly)");
 
       /* This will quit on C-g.  */
-      wait_for_termination (synch_process_pid, 0, 1);
-
+      bool wait_ok = wait_for_termination (synch_process_pid, NULL, true);
       synch_process_pid = 0;
-      message1 ("Waiting for process to die...done");
+      message1 (wait_ok
+                ? "Waiting for process to die...done"
+                : "Waiting for process to die...internal error");
     }
 #endif  /* !MSDOS */
 }
@@ -240,6 +243,10 @@ Otherwise it waits for PROGRAM to terminate
 and returns a numeric exit status or a signal description string.
 If you quit, the process is killed with SIGINT, or SIGKILL if you quit again.
 
+The process runs in `default-directory' if that is local (as
+determined by `unhandled-file-name-directory'), or "~" otherwise.  If
+you want to run a process in a remote directory use `process-file'.
+
 usage: (call-process PROGRAM &optional INFILE DESTINATION DISPLAY &rest ARGS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
@@ -624,9 +631,28 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
 
   if (pid == 0)
     {
+#ifdef DARWIN_OS
+      /* Work around a macOS bug, where SIGCHLD is apparently
+         delivered to a vforked child instead of to its parent.  See:
+         http://lists.gnu.org/archive/html/emacs-devel/2017-05/msg00342.html
+      */
+      signal (SIGCHLD, SIG_DFL);
+#endif
+
       unblock_child_signal (&oldset);
 
+#ifdef DARWIN_OS
+      /* Darwin doesn't let us run setsid after a vfork, so use
+         TIOCNOTTY when necessary. */
+      int j = emacs_open (DEV_TTY, O_RDWR, 0);
+      if (j >= 0)
+        {
+          ioctl (j, TIOCNOTTY, 0);
+          emacs_close (j);
+        }
+#else
       setsid ();
+#endif
 
       /* Emacs ignores SIGPIPE, but the child should not.  */
       signal (SIGPIPE, SIG_DFL);
@@ -849,9 +875,10 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
                make_number (total_read));
     }
 
+  bool wait_ok = true;
 #ifndef MSDOS
   /* Wait for it to terminate, unless it already has.  */
-  wait_for_termination (pid, &status, fd0 < 0);
+  wait_ok = wait_for_termination (pid, &status, fd0 < 0);
 #endif
 
   /* Don't kill any children that the subprocess may have left behind
@@ -861,6 +888,9 @@ call_process (ptrdiff_t nargs, Lisp_Object *args, int filefd,
   SAFE_FREE ();
   unbind_to (count, Qnil);
 
+  if (!wait_ok)
+    return build_unibyte_string ("internal error");
+
   if (WIFSIGNALED (status))
     {
       const char *signame;
diff --git a/src/casefiddle.c b/src/casefiddle.c
index 11d59444916..443d62b6259 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -1,3 +1,4 @@
+/* -*- coding: utf-8 -*- */
 /* GNU Emacs case conversion functions.
 
 Copyright (C) 1985, 1994, 1997-1999, 2001-2017 Free Software Foundation,
@@ -30,116 +31,312 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "keymap.h"
 
 enum case_action {CASE_UP, CASE_DOWN, CASE_CAPITALIZE, CASE_CAPITALIZE_UP};
-
-static Lisp_Object
-casify_object (enum case_action flag, Lisp_Object obj)
+
+/* State for casing individual characters.  */
+struct casing_context
+{
+  /* A char-table with title-case character mappings or nil.  Non-nil implies
+     flag is CASE_CAPITALIZE or CASE_CAPITALIZE_UP.  */
+  Lisp_Object titlecase_char_table;
+
+  /* The unconditional special-casing Unicode property char tables for upper
+     casing, lower casing and title casing respectively.  */
+  Lisp_Object specialcase_char_tables[3];
+
+  /* User-requested action.  */
+  enum case_action flag;
+
+  /* If true, the function operates on a buffer as opposed to a string
+     or character.  When run on a buffer, syntax_prefix_flag_p is
+     taken into account when determining whether the context is within
+     a word.  */
+  bool inbuffer;
+
+  /* Whether the context is within a word.  */
+  bool inword;
+};
+
+/* Initialize CTX structure for casing characters.  */
+static void
+prepare_casing_context (struct casing_context *ctx,
+                        enum case_action flag, bool inbuffer)
 {
-  int c, c1;
-  bool inword = flag == CASE_DOWN;
+  ctx->flag = flag;
+  ctx->inbuffer = inbuffer;
+  ctx->inword = false;
+  ctx->titlecase_char_table
+    = (flag < CASE_CAPITALIZE ? Qnil
+       : uniprop_table (Qtitlecase));
+  ctx->specialcase_char_tables[CASE_UP]
+    = (flag == CASE_DOWN ? Qnil
+       : uniprop_table (Qspecial_uppercase));
+  ctx->specialcase_char_tables[CASE_DOWN]
+    = (flag == CASE_UP ? Qnil
+       : uniprop_table (Qspecial_lowercase));
+  ctx->specialcase_char_tables[CASE_CAPITALIZE]
+    = (flag < CASE_CAPITALIZE ? Qnil
+       : uniprop_table (Qspecial_titlecase));
 
   /* If the case table is flagged as modified, rescan it.  */
   if (NILP (XCHAR_TABLE (BVAR (current_buffer, downcase_table))->extras[1]))
     Fset_case_table (BVAR (current_buffer, downcase_table));
 
-  if (NATNUMP (obj))
+  if (inbuffer && flag >= CASE_CAPITALIZE)
+    SETUP_BUFFER_SYNTAX_TABLE ();       /* For syntax_prefix_flag_p.  */
+}
+
+struct casing_str_buf
+{
+  unsigned char data[max (6, MAX_MULTIBYTE_LENGTH)];
+  unsigned char len_chars;
+  unsigned char len_bytes;
+};
+
+/* Based on CTX, case character CH.  If BUF is NULL, return cased character.
+   Otherwise, if BUF is non-NULL, save result in it and return whether the
+   character has been changed.
+
+   Since meaning of return value depends on arguments, it’s more convenient to
+   use case_single_character or case_character instead.  */
+static int
+case_character_impl (struct casing_str_buf *buf,
+                     struct casing_context *ctx, int ch)
+{
+  enum case_action flag;
+  Lisp_Object prop;
+  int cased;
+
+  /* Update inword state */
+  bool was_inword = ctx->inword;
+  ctx->inword = SYNTAX (ch) == Sword &&
+    (!ctx->inbuffer || was_inword || !syntax_prefix_flag_p (ch));
+
+  /* Normalize flag so its one of CASE_UP, CASE_DOWN or CASE_CAPITALIZE.  */
+  if (ctx->flag == CASE_CAPITALIZE)
+    flag = ctx->flag - was_inword;
+  else if (ctx->flag != CASE_CAPITALIZE_UP)
+    flag = ctx->flag;
+  else if (!was_inword)
+    flag = CASE_CAPITALIZE;
+  else
     {
-      int flagbits = (CHAR_ALT | CHAR_SUPER | CHAR_HYPER
-                      | CHAR_SHIFT | CHAR_CTL | CHAR_META);
-      int flags = XINT (obj) & flagbits;
-      bool multibyte = ! NILP (BVAR (current_buffer,
-                                     enable_multibyte_characters));
-
-      /* If the character has higher bits set
-         above the flags, return it unchanged.
-         It is not a real character.  */
-      if (UNSIGNED_CMP (XFASTINT (obj), >, flagbits))
-        return obj;
-
-      c1 = XFASTINT (obj) & ~flagbits;
-      /* FIXME: Even if enable-multibyte-characters is nil, we may
-         manipulate multibyte chars.  This means we have a bug for latin-1
-         chars since when we receive an int 128-255 we can't tell whether
-         it's an eight-bit byte or a latin-1 char.  */
-      if (c1 >= 256)
-        multibyte = 1;
-      if (! multibyte)
-        MAKE_CHAR_MULTIBYTE (c1);
-      c = flag == CASE_DOWN ? downcase (c1) : upcase (c1);
-      if (c != c1)
-        {
-          if (! multibyte)
-            MAKE_CHAR_UNIBYTE (c);
-          XSETFASTINT (obj, c | flags);
-        }
-      return obj;
+      cased = ch;
+      goto done;
     }
 
-  if (!STRINGP (obj))
-    wrong_type_argument (Qchar_or_string_p, obj);
-  else if (!STRING_MULTIBYTE (obj))
+  /* Look through the special casing entries.  */
+  if (buf && !NILP (ctx->specialcase_char_tables[flag]))
     {
-      ptrdiff_t i;
-      ptrdiff_t size = SCHARS (obj);
-
-      obj = Fcopy_sequence (obj);
-      for (i = 0; i < size; i++)
-        {
-          c = SREF (obj, i);
-          MAKE_CHAR_MULTIBYTE (c);
-          c1 = c;
-          if (inword && flag != CASE_CAPITALIZE_UP)
-            c = downcase (c);
-          else if (!uppercasep (c)
-                   && (!inword || flag != CASE_CAPITALIZE_UP))
-            c = upcase (c1);
-          if ((int) flag >= (int) CASE_CAPITALIZE)
-            inword = (SYNTAX (c) == Sword);
-          if (c != c1)
+      prop = CHAR_TABLE_REF (ctx->specialcase_char_tables[flag], ch);
+      if (STRINGP (prop))
+        {
+          struct Lisp_String *str = XSTRING (prop);
+          if (STRING_BYTES (str) <= sizeof buf->data)
             {
-              MAKE_CHAR_UNIBYTE (c);
-              /* If the char can't be converted to a valid byte, just don't
-                 change it.  */
-              if (c >= 0 && c < 256)
-                SSET (obj, i, c);
+              buf->len_chars = str->size;
+              buf->len_bytes = STRING_BYTES (str);
+              memcpy (buf->data, str->data, buf->len_bytes);
+              return 1;
             }
-        }
-      return obj;
+        }
     }
+
+  /* Handle simple, one-to-one case.  */
+  if (flag == CASE_DOWN)
+    cased = downcase (ch);
   else
     {
-      ptrdiff_t i, i_byte, size = SCHARS (obj);
-      int len;
-      USE_SAFE_ALLOCA;
-      ptrdiff_t o_size;
-      if (INT_MULTIPLY_WRAPV (size, MAX_MULTIBYTE_LENGTH, &o_size))
-        o_size = PTRDIFF_MAX;
-      unsigned char *dst = SAFE_ALLOCA (o_size);
-      unsigned char *o = dst;
-
-      for (i = i_byte = 0; i < size; i++, i_byte += len)
+      bool cased_is_set = false;
+      if (!NILP (ctx->titlecase_char_table))
         {
-          if (o_size - MAX_MULTIBYTE_LENGTH < o - dst)
-            string_overflow ();
-          c = STRING_CHAR_AND_LENGTH (SDATA (obj) + i_byte, len);
-          if (inword && flag != CASE_CAPITALIZE_UP)
-            c = downcase (c);
-          else if (!inword || flag != CASE_CAPITALIZE_UP)
-            c = upcase (c);
-          if ((int) flag >= (int) CASE_CAPITALIZE)
-            inword = (SYNTAX (c) == Sword);
-          o += CHAR_STRING (c, o);
+          prop = CHAR_TABLE_REF (ctx->titlecase_char_table, ch);
+          if (CHARACTERP (prop))
+            {
+              cased = XFASTINT (prop);
+              cased_is_set = true;
+            }
         }
-      eassert (o - dst <= o_size);
-      obj = make_multibyte_string ((char *) dst, size, o - dst);
-      SAFE_FREE ();
-      return obj;
+      if (!cased_is_set)
+        cased = upcase (ch);
     }
+
+  /* And we’re done.  */
+ done:
+  if (!buf)
+    return cased;
+  buf->len_chars = 1;
+  buf->len_bytes = CHAR_STRING (cased, buf->data);
+  return cased != ch;
+}
+
+/* In Greek, lower case sigma has two forms: one when used in the middle and one
+   when used at the end of a word.  Below is to help handle those cases when
+   casing.
+
+   The rule does not conflict with any other casing rules so while it is
+   a conditional one, it is independent of language.  */
+
+enum { GREEK_CAPITAL_LETTER_SIGMA = 0x03A3 }; /* Σ */
+enum { GREEK_SMALL_LETTER_FINAL_SIGMA = 0x03C2 }; /* ς */
+
+/* Based on CTX, case character CH accordingly.  Update CTX as necessary.
+   Return cased character.
+
+   Special casing rules (such as upcase(fi) = FI) are not handled.  For
+   characters whose casing results in multiple code points, the character is
+   returned unchanged.  */
+static inline int
+case_single_character (struct casing_context *ctx, int ch)
+{
+  return case_character_impl (NULL, ctx, ch);
+}
+
+/* Save in BUF result of casing character CH.  Return whether casing changed the
+   character.
+
+   If not-NULL, NEXT points to the next character in the cased string.  If NULL,
+   it is assumed current character is the last one being cased.  This is used to
+   apply some rules which depend on proceeding state.
+
+   This is like case_single_character but also handles one-to-many casing
+   rules.  */
+static bool
+case_character (struct casing_str_buf *buf, struct casing_context *ctx,
+                int ch, const unsigned char *next)
+{
+  bool was_inword = ctx->inword;
+  bool changed = case_character_impl (buf, ctx, ch);
+
+  /* If we have just down-cased a capital sigma and the next character no longer
+     has a word syntax (i.e. current character is end of word), use final
+     sigma.  */
+  if (was_inword && ch == GREEK_CAPITAL_LETTER_SIGMA && changed
+      && (!next || SYNTAX (STRING_CHAR (next)) != Sword))
+    {
+      buf->len_bytes = CHAR_STRING (GREEK_SMALL_LETTER_FINAL_SIGMA, buf->data);
+      buf->len_chars = 1;
+    }
+
+  return changed;
+}
+
+static Lisp_Object
+do_casify_natnum (struct casing_context *ctx, Lisp_Object obj)
+{
+  int flagbits = (CHAR_ALT | CHAR_SUPER | CHAR_HYPER
+                  | CHAR_SHIFT | CHAR_CTL | CHAR_META);
+  int ch = XFASTINT (obj);
+
+  /* If the character has higher bits set above the flags, return it unchanged.
+     It is not a real character.  */
+  if (UNSIGNED_CMP (ch, >, flagbits))
+    return obj;
+
+  int flags = ch & flagbits;
+  ch = ch & ~flagbits;
+
+  /* FIXME: Even if enable-multibyte-characters is nil, we may manipulate
+     multibyte chars.  This means we have a bug for latin-1 chars since when we
+     receive an int 128-255 we can't tell whether it's an eight-bit byte or
+     a latin-1 char.  */
+  bool multibyte = (ch >= 256
+                    || !NILP (BVAR (current_buffer,
+                                    enable_multibyte_characters)));
+  if (! multibyte)
+    MAKE_CHAR_MULTIBYTE (ch);
+  int cased = case_single_character (ctx, ch);
+  if (cased == ch)
+    return obj;
+
+  if (! multibyte)
+    MAKE_CHAR_UNIBYTE (cased);
+  return make_natnum (cased | flags);
+}
+
+static Lisp_Object
+do_casify_multibyte_string (struct casing_context *ctx, Lisp_Object obj)
+{
+  /* Verify that ‘data’ is the first member of struct casing_str_buf
+     so that when casting char * to struct casing_str_buf *, the
+     representation of the character is at the beginning of the
+     buffer.  This is why we don’t need a separate struct
+     casing_str_buf object, and can write directly to the destination.  */
+  verify (offsetof (struct casing_str_buf, data) == 0);
+
+  ptrdiff_t size = SCHARS (obj), n;
+  USE_SAFE_ALLOCA;
+  if (INT_MULTIPLY_WRAPV (size, MAX_MULTIBYTE_LENGTH, &n)
+      || INT_ADD_WRAPV (n, sizeof (struct casing_str_buf), &n))
+    n = PTRDIFF_MAX;
+  unsigned char *dst = SAFE_ALLOCA (n);
+  unsigned char *dst_end = dst + n;
+  unsigned char *o = dst;
+
+  const unsigned char *src = SDATA (obj);
+
+  for (n = 0; size; --size)
+    {
+      if (dst_end - o < sizeof (struct casing_str_buf))
+        string_overflow ();
+      int ch = STRING_CHAR_ADVANCE (src);
+      case_character ((struct casing_str_buf *) o, ctx, ch,
+                      size > 1 ? src : NULL);
+      n += ((struct casing_str_buf *) o)->len_chars;
+      o += ((struct casing_str_buf *) o)->len_bytes;
+    }
+  eassert (o <= dst_end);
+  obj = make_multibyte_string ((char *) dst, n, o - dst);
+  SAFE_FREE ();
+  return obj;
+}
+
+static Lisp_Object
+do_casify_unibyte_string (struct casing_context *ctx, Lisp_Object obj)
+{
+  ptrdiff_t i, size = SCHARS (obj);
+  int ch, cased;
+
+  obj = Fcopy_sequence (obj);
+  for (i = 0; i < size; i++)
+    {
+      ch = SREF (obj, i);
+      MAKE_CHAR_MULTIBYTE (ch);
+      cased = case_single_character (ctx, ch);
+      if (ch == cased)
+        continue;
+      MAKE_CHAR_UNIBYTE (cased);
+      /* If the char can't be converted to a valid byte, just don't
+         change it.  */
+      if (cased >= 0 && cased < 256)
+        SSET (obj, i, cased);
+    }
+  return obj;
+}
+
+static Lisp_Object
+casify_object (enum case_action flag, Lisp_Object obj)
+{
+  struct casing_context ctx;
+  prepare_casing_context (&ctx, flag, false);
+
+  if (NATNUMP (obj))
+    return do_casify_natnum (&ctx, obj);
+  else if (!STRINGP (obj))
+    wrong_type_argument (Qchar_or_string_p, obj);
+  else if (!SCHARS (obj))
+    return obj;
+  else if (STRING_MULTIBYTE (obj))
+    return do_casify_multibyte_string (&ctx, obj);
+  else
+    return do_casify_unibyte_string (&ctx, obj);
 }
 
 DEFUN ("upcase", Fupcase, Supcase, 1, 1, 0,
        doc: /* Convert argument to upper case and return that.
 The argument may be a character or string.  The result has the same type.
-The argument object is not altered--the value is a copy.
+The argument object is not altered--the value is a copy.  If argument
+is a character, characters which map to multiple code points when
+cased, e.g. fi, are returned unchanged.
 See also `capitalize', `downcase' and `upcase-initials'.  */)
   (Lisp_Object obj)
 {
@@ -157,10 +354,12 @@ The argument object is not altered--the value is a copy.  */)
 
 DEFUN ("capitalize", Fcapitalize, Scapitalize, 1, 1, 0,
        doc: /* Convert argument to capitalized form and return that.
-This means that each word's first character is upper case
-and the rest is lower case.
+This means that each word's first character is converted to either
+title case or upper case, and the rest to lower case.
 The argument may be a character or string.  The result has the same type.
-The argument object is not altered--the value is a copy.  */)
+The argument object is not altered--the value is a copy.  If argument
+is a character, characters which map to multiple code points when
+cased, e.g. fi, are returned unchanged.  */)
   (Lisp_Object obj)
 {
   return casify_object (CASE_CAPITALIZE, obj);
@@ -170,122 +369,151 @@ The argument object is not altered--the value is a copy.  */)
 
 DEFUN ("upcase-initials", Fupcase_initials, Supcase_initials, 1, 1, 0,
        doc: /* Convert the initial of each word in the argument to upper case.
-Do not change the other letters of each word.
+This means that each word's first character is converted to either
+title case or upper case, and the rest are left unchanged.
 The argument may be a character or string.  The result has the same type.
-The argument object is not altered--the value is a copy.  */)
+The argument object is not altered--the value is a copy.  If argument
+is a character, characters which map to multiple code points when
+cased, e.g. fi, are returned unchanged.  */)
   (Lisp_Object obj)
 {
   return casify_object (CASE_CAPITALIZE_UP, obj);
 }
 
-/* flag is CASE_UP, CASE_DOWN or CASE_CAPITALIZE or CASE_CAPITALIZE_UP.
-   b and e specify range of buffer to operate on. */
+/* Based on CTX, case region in a unibyte buffer from *STARTP to *ENDP.
 
-static void
-casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e)
+   Save first and last positions that has changed in *STARTP and *ENDP
+   respectively.  If no characters were changed, save -1 to *STARTP and leave
+   *ENDP unspecified.
+
+   Always return 0.  This is so that interface of this function is the same as
+   do_casify_multibyte_region.  */
+static ptrdiff_t
+do_casify_unibyte_region (struct casing_context *ctx,
+                          ptrdiff_t *startp, ptrdiff_t *endp)
 {
-  int c;
-  bool inword = flag == CASE_DOWN;
-  bool multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
-  ptrdiff_t start, end;
-  ptrdiff_t start_byte;
+  ptrdiff_t first = -1, last = -1;  /* Position of first and last changes.  */
+  ptrdiff_t end = *endp;
 
-  /* Position of first and last changes.  */
-  ptrdiff_t first = -1, last;
+  for (ptrdiff_t pos = *startp; pos < end; ++pos)
+    {
+      int ch = FETCH_BYTE (pos);
+      MAKE_CHAR_MULTIBYTE (ch);
 
-  ptrdiff_t opoint = PT;
-  ptrdiff_t opoint_byte = PT_BYTE;
+      int cased = case_single_character (ctx, ch);
+      if (cased == ch)
+        continue;
 
-  if (EQ (b, e))
-    /* Not modifying because nothing marked */
-    return;
+      last = pos + 1;
+      if (first < 0)
+        first = pos;
 
-  /* If the case table is flagged as modified, rescan it.  */
-  if (NILP (XCHAR_TABLE (BVAR (current_buffer, downcase_table))->extras[1]))
-    Fset_case_table (BVAR (current_buffer, downcase_table));
+      MAKE_CHAR_UNIBYTE (cased);
+      FETCH_BYTE (pos) = cased;
+    }
 
-  validate_region (&b, &e);
-  start = XFASTINT (b);
-  end = XFASTINT (e);
-  modify_text (start, end);
-  record_change (start, end - start);
-  start_byte = CHAR_TO_BYTE (start);
+  *startp = first;
+  *endp = last;
+  return 0;
+}
 
-  SETUP_BUFFER_SYNTAX_TABLE (); /* For syntax_prefix_flag_p.  */
+/* Based on CTX, case region in a multibyte buffer from *STARTP to *ENDP.
 
-  while (start < end)
-    {
-      int c2, len;
+   Return number of added characters (may be negative if more characters were
+   deleted then inserted), save first and last positions that has changed in
+   *STARTP and *ENDP respectively.  If no characters were changed, return 0,
+   save -1 to *STARTP and leave *ENDP unspecified.  */
+static ptrdiff_t
+do_casify_multibyte_region (struct casing_context *ctx,
+                            ptrdiff_t *startp, ptrdiff_t *endp)
+{
+  ptrdiff_t first = -1, last = -1;  /* Position of first and last changes.  */
+  ptrdiff_t pos = *startp, pos_byte = CHAR_TO_BYTE (pos), size = *endp - pos;
+  ptrdiff_t opoint = PT, added = 0;
 
-      if (multibyte)
+  for (; size; --size)
+    {
+      int len;
+      int ch = STRING_CHAR_AND_LENGTH (BYTE_POS_ADDR (pos_byte), len);
+      struct casing_str_buf buf;
+      if (!case_character (&buf, ctx, ch,
+                           size > 1 ? BYTE_POS_ADDR (pos_byte + len) : NULL))
         {
-          c = FETCH_MULTIBYTE_CHAR (start_byte);
-          len = CHAR_BYTES (c);
+          pos_byte += len;
+          ++pos;
+          continue;
         }
+
+      last = pos + buf.len_chars;
+      if (first < 0)
+        first = pos;
+
+      if (buf.len_chars == 1 && buf.len_bytes == len)
+        memcpy (BYTE_POS_ADDR (pos_byte), buf.data, len);
       else
         {
-          c = FETCH_BYTE (start_byte);
-          MAKE_CHAR_MULTIBYTE (c);
-          len = 1;
+          /* Replace one character with the other(s), keeping text
+             properties the same.  */
+          replace_range_2 (pos, pos_byte, pos + 1, pos_byte + len,
+                           (const char *) buf.data, buf.len_chars,
+                           buf.len_bytes,
+                           0);
+          added += (ptrdiff_t) buf.len_chars - 1;
+          if (opoint > pos)
+            opoint += (ptrdiff_t) buf.len_chars - 1;
         }
-      c2 = c;
-      if (inword && flag != CASE_CAPITALIZE_UP)
-        c = downcase (c);
-      else if (!inword || flag != CASE_CAPITALIZE_UP)
-        c = upcase (c);
-      if ((int) flag >= (int) CASE_CAPITALIZE)
-        inword = ((SYNTAX (c) == Sword)
-                  && (inword || !syntax_prefix_flag_p (c)));
-      if (c != c2)
-        {
-          last = start;
-          if (first < 0)
-            first = start;
 
-          if (! multibyte)
-            {
-              MAKE_CHAR_UNIBYTE (c);
-              FETCH_BYTE (start_byte) = c;
-            }
-          else if (ASCII_CHAR_P (c2) && ASCII_CHAR_P (c))
-            FETCH_BYTE (start_byte) = c;
-          else
-            {
-              int tolen = CHAR_BYTES (c);
-              int j;
-              unsigned char str[MAX_MULTIBYTE_LENGTH];
-
-              CHAR_STRING (c, str);
-              if (len == tolen)
-                {
-                  /* Length is unchanged.  */
-                  for (j = 0; j < len; ++j)
-                    FETCH_BYTE (start_byte + j) = str[j];
-                }
-              else
-                {
-                  /* Replace one character with the other,
-                     keeping text properties the same.  */
-                  replace_range_2 (start, start_byte,
-                                   start + 1, start_byte + len,
-                                   (char *) str, 1, tolen,
-                                   0);
-                  len = tolen;
-                }
-            }
-        }
-      start++;
-      start_byte += len;
+      pos_byte += buf.len_bytes;
+      pos += buf.len_chars;
     }
 
   if (PT != opoint)
-    TEMP_SET_PT_BOTH (opoint, opoint_byte);
+    TEMP_SET_PT_BOTH (opoint, CHAR_TO_BYTE (opoint));
 
-  if (first >= 0)
+  *startp = first;
+  *endp = last;
+  return added;
+}
+
+/* flag is CASE_UP, CASE_DOWN or CASE_CAPITALIZE or CASE_CAPITALIZE_UP.  b and
+   e specify range of buffer to operate on.  Return character position of the
+   end of the region after changes.  */
+static ptrdiff_t
+casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e)
+{
+  ptrdiff_t added;
+  struct casing_context ctx;
+
+  validate_region (&b, &e);
+  ptrdiff_t start = XFASTINT (b);
+  ptrdiff_t end = XFASTINT (e);
+  if (start == end)
+    /* Not modifying because nothing marked.  */
+    return end;
+  modify_text (start, end);
+  prepare_casing_context (&ctx, flag, true);
+
+  ptrdiff_t orig_end = end;
+  record_delete (start, make_buffer_string (start, end, true), false);
+  if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
     {
-      signal_after_change (first, last + 1 - first, last + 1 - first);
-      update_compositions (first, last + 1, CHECK_ALL);
+      record_insert (start, end - start);
+      added = do_casify_unibyte_region (&ctx, &start, &end);
     }
+  else
+    {
+      ptrdiff_t len = end - start, ostart = start;
+      added = do_casify_multibyte_region (&ctx, &start, &end);
+      record_insert (ostart, len + added);
+    }
+
+  if (start >= 0)
+    {
+      signal_after_change (start, end - start - added, end - start);
+      update_compositions (start, end, CHECK_ALL);
+    }
+
+  return orig_end + added;
 }
 
 DEFUN ("upcase-region", Fupcase_region, Supcase_region, 2, 3,
@@ -345,8 +573,8 @@ point and the mark is operated on.  */)
 
 DEFUN ("capitalize-region", Fcapitalize_region, Scapitalize_region, 2, 2, "r",
        doc: /* Convert the region to capitalized form.
-Capitalized form means each word's first character is upper case
-and the rest of it is lower case.
+This means that each word's first character is converted to either
+title case or upper case, and the rest to lower case.
 In programs, give two arguments, the starting and ending
 character positions to operate on.  */)
   (Lisp_Object beg, Lisp_Object end)
@@ -360,7 +588,8 @@ character positions to operate on.  */)
 DEFUN ("upcase-initials-region", Fupcase_initials_region,
        Supcase_initials_region, 2, 2, "r",
        doc: /* Upcase the initial of each word in the region.
-Subsequent letters of each word are not changed.
+This means that each word's first character is converted to either
+title case or upper case, and the rest are left unchanged.
 In programs, give two arguments, the starting and ending
 character positions to operate on.  */)
   (Lisp_Object beg, Lisp_Object end)
@@ -376,9 +605,7 @@ casify_word (enum case_action flag, Lisp_Object arg)
   ptrdiff_t farend = scan_words (PT, XINT (arg));
   if (!farend)
     farend = XINT (arg) <= 0 ? BEGV : ZV;
-  ptrdiff_t newpoint = max (PT, farend);
-  casify_region (flag, make_number (PT), make_number (farend));
-  SET_PT (newpoint);
+  SET_PT (casify_region (flag, make_number (PT), make_number (farend)));
   return Qnil;
 }
 
@@ -426,6 +653,11 @@ void
 syms_of_casefiddle (void)
 {
   DEFSYM (Qidentity, "identity");
+  DEFSYM (Qtitlecase, "titlecase");
+  DEFSYM (Qspecial_uppercase, "special-uppercase");
+  DEFSYM (Qspecial_lowercase, "special-lowercase");
+  DEFSYM (Qspecial_titlecase, "special-titlecase");
+
   defsubr (&Supcase);
   defsubr (&Sdowncase);
   defsubr (&Scapitalize);
diff --git a/src/ccl.c b/src/ccl.c
index 90bd2f46794..b2caf413f7a 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -1000,7 +1000,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
 
         case CCL_ReadBranch:    /* CCCCCCCCCCCCCCCCCCCCrrrXXXXX */
           CCL_READ_CHAR (reg[rrr]);
-          /* fall through ... */
+          FALLTHROUGH;
         case CCL_Branch:        /* CCCCCCCCCCCCCCCCCCCCrrrXXXXX */
         {
           int ioff = 0 <= reg[rrr] && reg[rrr] < field1 ? reg[rrr] : field1;
@@ -1174,6 +1174,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
 
         case CCL_ReadJumpCondExprConst: /* A--D--D--R--E--S--S-rrrXXXXX */
           CCL_READ_CHAR (reg[rrr]);
+          FALLTHROUGH;
         case CCL_JumpCondExprConst: /* A--D--D--R--E--S--S-rrrXXXXX */
           i = reg[rrr];
           jump_address = ic + ADDR;
@@ -1184,6 +1185,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
 
         case CCL_ReadJumpCondExprReg: /* A--D--D--R--E--S--S-rrrXXXXX */
           CCL_READ_CHAR (reg[rrr]);
+          FALLTHROUGH;
         case CCL_JumpCondExprReg:
           i = reg[rrr];
           jump_address = ic + ADDR;
diff --git a/src/charset.c b/src/charset.c
index f0b41400843..d0840f7d2a9 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -29,7 +29,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <config.h>
 
 #include <errno.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <limits.h>
@@ -40,6 +39,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "charset.h"
 #include "coding.h"
 #include "buffer.h"
+#include "sysstdio.h"
 
 /*** GENERAL NOTES on CODED CHARACTER SETS (CHARSETS) ***
 
@@ -416,15 +416,15 @@ read_hex (FILE *fp, bool *eof, bool *overflow)
   int c;
   unsigned n;
 
-  while ((c = getc (fp)) != EOF)
+  while ((c = getc_unlocked (fp)) != EOF)
     {
       if (c == '#')
         {
-          while ((c = getc (fp)) != EOF && c != '\n');
+          while ((c = getc_unlocked (fp)) != EOF && c != '\n');
         }
       else if (c == '0')
         {
-          if ((c = getc (fp)) == EOF || c == 'x')
+          if ((c = getc_unlocked (fp)) == EOF || c == 'x')
             break;
         }
     }
@@ -434,7 +434,7 @@ read_hex (FILE *fp, bool *eof, bool *overflow)
       return 0;
     }
   n = 0;
-  while (c_isxdigit (c = getc (fp)))
+  while (c_isxdigit (c = getc_unlocked (fp)))
     {
       if (INT_LEFT_SHIFT_OVERFLOW (n, 4))
         *overflow = 1;
@@ -508,7 +508,7 @@ load_charset_map_from_file (struct charset *charset, Lisp_Object mapfile,
       from = read_hex (fp, &eof, &overflow);
       if (eof)
         break;
-      if (getc (fp) == '-')
+      if (getc_unlocked (fp) == '-')
         to = read_hex (fp, &eof, &overflow);
       else
         to = from;
diff --git a/src/chartab.c b/src/chartab.c
index fa5a8e41164..8392c0c07dc 100644
--- a/src/chartab.c
+++ b/src/chartab.c
@@ -185,7 +185,7 @@ Lisp_Object
 copy_char_table (Lisp_Object table)
 {
   Lisp_Object copy;
-  int size = XCHAR_TABLE (table)->header.size & PSEUDOVECTOR_SIZE_MASK;
+  int size = PVSIZE (table);
   int i;
 
   copy = Fmake_vector (make_number (size), Qnil);
diff --git a/src/cm.c b/src/cm.c
index efa50b0f58d..9a90f37445c 100644
--- a/src/cm.c
+++ b/src/cm.c
@@ -19,10 +19,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
 #include <config.h>
-#include <stdio.h>
 
 #include "lisp.h"
 #include "cm.h"
+#include "sysstdio.h"
 #include "termchar.h"
 #include "tparam.h"
 
@@ -45,8 +45,8 @@ int
 cmputc (int c)
 {
   if (current_tty->termscript)
-    putc (c & 0177, current_tty->termscript);
-  putc (c & 0177, current_tty->output);
+    putc_unlocked (c & 0177, current_tty->termscript);
+  putc_unlocked (c & 0177, current_tty->output);
   return c;
 }
 
@@ -117,11 +117,11 @@ cmcheckmagic (struct tty_display_info *tty)
       if (!MagicWrap (tty) || curY (tty) >= FrameRows (tty) - 1)
         emacs_abort ();
       if (tty->termscript)
-        putc ('\r', tty->termscript);
-      putc ('\r', tty->output);
+        putc_unlocked ('\r', tty->termscript);
+      putc_unlocked ('\r', tty->output);
       if (tty->termscript)
-        putc ('\n', tty->termscript);
-      putc ('\n', tty->output);
+        putc_unlocked ('\n', tty->termscript);
+      putc_unlocked ('\n', tty->output);
       curX (tty) = 0;
       curY (tty)++;
     }
diff --git a/src/coding.c b/src/coding.c
index e341a71f576..5682fc015ad 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -1449,7 +1449,7 @@ decode_coding_utf_8 (struct coding_system *coding)
 }
 
 
-static bool
+bool
 encode_coding_utf_8 (struct coding_system *coding)
 {
   bool multibytep = coding->dst_multibyte;
@@ -3611,7 +3611,7 @@ decode_coding_iso_2022 (struct coding_system *coding)
               || CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS)
             goto invalid_code;
           /* This is a graphic character, we fall down ... */
-
+          FALLTHROUGH;
         case ISO_graphic_plane_1:
           if (charset_id_1 < 0)
             goto invalid_code;
@@ -3646,6 +3646,7 @@ decode_coding_iso_2022 (struct coding_system *coding)
         case ISO_single_shift_2_7:
           if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SEVEN_BITS))
             goto invalid_code;
+          FALLTHROUGH;
         case ISO_single_shift_2:
           if (! (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_SINGLE_SHIFT))
             goto invalid_code;
@@ -3797,6 +3798,7 @@ decode_coding_iso_2022 (struct coding_system *coding)
                 {
                 case ']':       /* end of the current direction */
                   coding->mode &= ~CODING_MODE_DIRECTION;
+                  break;
 
                 case '0':       /* end of the current direction */
                 case '1':       /* start of left-to-right direction */
diff --git a/src/coding.h b/src/coding.h
index 7a1dd682b29..8ed851d99ff 100644
--- a/src/coding.h
+++ b/src/coding.h
@@ -96,39 +96,6 @@ enum define_coding_undecided_arg_index
 extern Lisp_Object Vcoding_system_hash_table;
 
 
-/* Enumeration of coding system type.  */
-
-enum coding_system_type
-  {
-    coding_type_charset,
-    coding_type_utf_8,
-    coding_type_utf_16,
-    coding_type_iso_2022,
-    coding_type_emacs_mule,
-    coding_type_sjis,
-    coding_type_ccl,
-    coding_type_raw_text,
-    coding_type_undecided,
-    coding_type_max
-  };
-
-
-/* Enumeration of end-of-line format type.  */
-
-enum end_of_line_type
-  {
-    eol_lf,             /* Line-feed only, same as Emacs' internal
-                           format.  */
-    eol_crlf,           /* Sequence of carriage-return and
-                           line-feed.  */
-    eol_cr,             /* Carriage-return only.  */
-    eol_any,            /* Accept any of above.  Produce line-feed
-                           only.  */
-    eol_undecided,      /* This value is used to denote that the
-                           eol-type is not yet undecided.  */
-    eol_type_max
-  };
-
 /* Enumeration of index to an attribute vector of a coding system.  */
 
 enum coding_attr_index
@@ -697,6 +664,7 @@ struct coding_system
 
 /* Extern declarations.  */
 extern Lisp_Object code_conversion_save (bool, bool);
+extern bool encode_coding_utf_8 (struct coding_system *);
 extern void setup_coding_system (Lisp_Object, struct coding_system *);
 extern Lisp_Object coding_charset_list (struct coding_system *);
 extern Lisp_Object coding_system_charset_list (Lisp_Object);
diff --git a/src/composite.c b/src/composite.c
index b673c53ac83..05a296329a6 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -867,7 +867,6 @@ autocmp_chars (Lisp_Object rule, ptrdiff_t charpos, ptrdiff_t bytepos,
                Lisp_Object string)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
-  struct frame *f = XFRAME (win->frame);
   Lisp_Object pos = make_number (charpos);
   ptrdiff_t to;
   ptrdiff_t pt = PT, pt_byte = PT_BYTE;
@@ -893,6 +892,7 @@ autocmp_chars (Lisp_Object rule, ptrdiff_t charpos, ptrdiff_t bytepos,
   to = limit = charpos + len;
   font_object = win->frame;
 #ifdef HAVE_WINDOW_SYSTEM
+  struct frame *f = XFRAME (font_object);
   if (FRAME_WINDOW_P (f))
     {
       font_object = font_range (charpos, bytepos, &to, win, face, string);
diff --git a/src/conf_post.h b/src/conf_post.h
index e146b9bbe8a..e1d6a9397d3 100644
--- a/src/conf_post.h
+++ b/src/conf_post.h
@@ -57,7 +57,9 @@ typedef bool bool_bf;
 #endif
 
 /* Simulate __has_attribute on compilers that lack it.  It is used only
-   on arguments like alloc_size that are handled in this simulation.  */
+   on arguments like alloc_size that are handled in this simulation.
+   __has_attribute should be used only in #if expressions, as Oracle
+   Studio 12.5's __has_attribute does not work in plain code.  */
 #ifndef __has_attribute
 # define __has_attribute(a) __has_attribute_##a
 # define __has_attribute_alloc_size GNUC_PREREQ (4, 3, 0)
@@ -94,17 +96,11 @@ typedef bool bool_bf;
 #endif
 
 #ifdef DARWIN_OS
-#ifdef emacs
+#if defined emacs && !defined CANNOT_DUMP
 #define malloc unexec_malloc
 #define realloc unexec_realloc
 #define free unexec_free
 #endif
-/* The following solves the problem that Emacs hangs when evaluating
-   (make-comint "test0" "/nodir/nofile" nil "") when /nodir/nofile
-   does not exist.  Also, setsid is not allowed in the vfork child's
-   context as of Darwin 9/Mac OS X 10.5.  */
-#undef HAVE_WORKING_VFORK
-#define vfork fork
 #endif  /* DARWIN_OS */
 
 /* If HYBRID_MALLOC is defined (e.g., on Cygwin), emacs will use
@@ -250,6 +246,12 @@ extern int emacs_setenv_TZ (char const *);
 # define ATTRIBUTE_FORMAT(spec) /* empty */
 #endif
 
+#if GNUC_PREREQ (7, 0, 0)
+# define FALLTHROUGH __attribute__ ((__fallthrough__))
+#else
+# define FALLTHROUGH ((void) 0)
+#endif
+
 #if GNUC_PREREQ (4, 4, 0) && defined __GLIBC_MINOR__
 # define PRINTF_ARCHETYPE __gnu_printf__
 #elif GNUC_PREREQ (4, 4, 0) && defined __MINGW32__
@@ -263,6 +265,20 @@ extern int emacs_setenv_TZ (char const *);
 #define ATTRIBUTE_CONST _GL_ATTRIBUTE_CONST
 #define ATTRIBUTE_UNUSED _GL_UNUSED
 
+#if GNUC_PREREQ (3, 3, 0) && !defined __ICC
+# define ATTRIBUTE_MAY_ALIAS __attribute__ ((__may_alias__))
+#else
+# define ATTRIBUTE_MAY_ALIAS
+#endif
+
+/* Declare NAME to be a pointer to an object of type TYPE, initialized
+   to the address ADDR, which may be of a different type.  Accesses
+   via NAME may alias with other accesses with the traditional
+   behavior, even if options like gcc -fstrict-aliasing are used.  */
+
+#define DECLARE_POINTER_ALIAS(name, type, addr) \
+  type ATTRIBUTE_MAY_ALIAS *name = (type *) (addr)
+
 #if 3 <= __GNUC__
 # define ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
 #else
@@ -302,6 +318,12 @@ extern int emacs_setenv_TZ (char const *);
 # define ATTRIBUTE_NO_SANITIZE_ADDRESS
 #endif
 
+/* gcc -fsanitize=address does not work with vfork in Fedora 25 x86-64.
+   For now, assume that this problem occurs on all platforms.  */
+#if ADDRESS_SANITIZER && !defined vfork
+# define vfork fork
+#endif
+
 /* Some versions of GNU/Linux define noinline in their headers.  */
 #ifdef noinline
 #undef noinline
diff --git a/src/data.c b/src/data.c
index ae8dd9721c2..559844b03fd 100644
--- a/src/data.c
+++ b/src/data.c
@@ -228,8 +228,6 @@ for example, (type-of 1) returns `integer'.  */)
           return Qmarker;
         case Lisp_Misc_Overlay:
           return Qoverlay;
-        case Lisp_Misc_Float:
-          return Qfloat;
         case Lisp_Misc_Finalizer:
           return Qfinalizer;
 #ifdef HAVE_MODULES
@@ -267,6 +265,17 @@ for example, (type-of 1) returns `integer'.  */)
         case PVEC_MUTEX: return Qmutex;
         case PVEC_CONDVAR: return Qcondition_variable;
         case PVEC_TERMINAL: return Qterminal;
+        case PVEC_RECORD:
+          {
+            Lisp_Object t = AREF (object, 0);
+            if (RECORDP (t) && 1 < PVSIZE (t))
+              /* Return the type name field of the class!  */
+              return AREF (t, 1);
+            else
+              return t;
+          }
+        case PVEC_MODULE_FUNCTION:
+          return Qmodule_function;
         /* "Impossible" cases.  */
         case PVEC_XWIDGET:
         case PVEC_OTHER:
@@ -359,6 +368,15 @@ DEFUN ("vectorp", Fvectorp, Svectorp, 1, 1, 0,
   return Qnil;
 }
 
+DEFUN ("recordp", Frecordp, Srecordp, 1, 1, 0,
+       doc: /* Return t if OBJECT is a record.  */)
+  (Lisp_Object object)
+{
+  if (RECORDP (object))
+    return Qt;
+  return Qnil;
+}
+
 DEFUN ("stringp", Fstringp, Sstringp, 1, 1, 0,
        doc: /* Return t if OBJECT is a string.  */
        attributes: const)
@@ -474,6 +492,14 @@ DEFUN ("byte-code-function-p", Fbyte_code_function_p, Sbyte_code_function_p,
   return Qnil;
 }
 
+DEFUN ("module-function-p", Fmodule_function_p, Smodule_function_p, 1, 1, NULL,
+       doc: /* Return t if OBJECT is a function loaded from a dynamic module.  */
+       attributes: const)
+  (Lisp_Object object)
+{
+  return MODULE_FUNCTIONP (object) ? Qt : Qnil;
+}
+
 DEFUN ("char-or-string-p", Fchar_or_string_p, Schar_or_string_p, 1, 1, 0,
        doc: /* Return t if OBJECT is a character or a string.  */
        attributes: const)
@@ -672,12 +698,10 @@ global value outside of any lexical scope.  */)
   return (EQ (valcontents, Qunbound) ? Qnil : Qt);
 }
 
-/* FIXME: It has been previously suggested to make this function an
-   alias for symbol-function, but upon discussion at Bug#23957,
-   there is a risk breaking backward compatibility, as some users of
-   fboundp may expect `t' in particular, rather than any true
-   value.  An alias is still welcome so long as the compatibility
-   issues are addressed.  */
+/* It has been previously suggested to make this function an alias for
+   symbol-function, but upon discussion at Bug#23957, there is a risk
+   breaking backward compatibility, as some users of fboundp may
+   expect `t' in particular, rather than any true value.  */
 DEFUN ("fboundp", Ffboundp, Sfboundp, 1, 1, 0,
        doc: /* Return t if SYMBOL's function definition is not void.  */)
   (register Lisp_Object symbol)
@@ -884,7 +908,7 @@ Value, if non-nil, is a list (interactive SPEC).  */)
     }
   else if (COMPILEDP (fun))
     {
-      if ((ASIZE (fun) & PSEUDOVECTOR_SIZE_MASK) > COMPILED_INTERACTIVE)
+      if (PVSIZE (fun) > COMPILED_INTERACTIVE)
         return list2 (Qinteractive, AREF (fun, COMPILED_INTERACTIVE));
     }
   else if (AUTOLOADP (fun))
@@ -2133,7 +2157,7 @@ If the current binding is global (the default), the value is nil.  */)
         else if (!BUFFER_OBJFWDP (valcontents))
           return Qnil;
       }
-      /* FALLTHROUGH */
+      FALLTHROUGH;
     case SYMBOL_LOCALIZED:
       /* For a local variable, record both the symbol and which
          buffer's or frame's value we are saving.  */
@@ -2248,8 +2272,8 @@ function chain of symbols.  */)
 /* Extract and set vector and string elements.  */
 
 DEFUN ("aref", Faref, Saref, 2, 2, 0,
-       doc: /* Return the element of ARRAY at index IDX.
-ARRAY may be a vector, a string, a char-table, a bool-vector,
+       doc: /* Return the element of ARG at index IDX.
+ARG may be a vector, a string, a char-table, a bool-vector, a record,
 or a byte-code object.  IDX starts at 0.  */)
   (register Lisp_Object array, Lisp_Object idx)
 {
@@ -2287,8 +2311,8 @@ or a byte-code object.  IDX starts at 0.  */)
       ptrdiff_t size = 0;
       if (VECTORP (array))
         size = ASIZE (array);
-      else if (COMPILEDP (array))
-        size = ASIZE (array) & PSEUDOVECTOR_SIZE_MASK;
+      else if (COMPILEDP (array) || RECORDP (array))
+        size = PVSIZE (array);
       else
         wrong_type_argument (Qarrayp, array);
 
@@ -2308,7 +2332,8 @@ bool-vector.  IDX starts at 0.  */)
 
   CHECK_NUMBER (idx);
   idxval = XINT (idx);
-  CHECK_ARRAY (array, Qarrayp);
+  if (! RECORDP (array))
+    CHECK_ARRAY (array, Qarrayp);
 
   if (VECTORP (array))
     {
@@ -2328,7 +2353,13 @@ bool-vector.  IDX starts at 0.  */)
       CHECK_CHARACTER (idx);
       CHAR_TABLE_SET (array, idxval, newelt);
     }
-  else
+  else if (RECORDP (array))
+    {
+      if (idxval < 0 || idxval >= PVSIZE (array))
+        args_out_of_range (array, idx);
+      ASET (array, idxval, newelt);
+    }
+  else /* STRINGP */
     {
       int c;
 
@@ -3039,9 +3070,12 @@ usage: (logxor &rest INTS-OR-MARKERS)  */)
 }
 
 static Lisp_Object
-ash_lsh_impl (register Lisp_Object value, Lisp_Object count, bool lsh)
+ash_lsh_impl (Lisp_Object value, Lisp_Object count, bool lsh)
 {
-  register Lisp_Object val;
+  /* This code assumes that signed right shifts are arithmetic.  */
+  verify ((EMACS_INT) -1 >> 1 == -1);
+
+  Lisp_Object val;
 
   CHECK_NUMBER (value);
   CHECK_NUMBER (count);
@@ -3049,12 +3083,12 @@ ash_lsh_impl (register Lisp_Object value, Lisp_Object count, bool lsh)
   if (XINT (count) >= EMACS_INT_WIDTH)
     XSETINT (val, 0);
   else if (XINT (count) > 0)
-    XSETINT (val, XUINT (value) << XFASTINT (count));
+    XSETINT (val, XUINT (value) << XINT (count));
   else if (XINT (count) <= -EMACS_INT_WIDTH)
     XSETINT (val, lsh ? 0 : XINT (value) < 0 ? -1 : 0);
   else
-    XSETINT (val, lsh ? XUINT (value) >> -XINT (count) : \
-                        XINT (value) >> -XINT (count));
+    XSETINT (val, (lsh ? XUINT (value) >> -XINT (count)
+                   : XINT (value) >> -XINT (count)));
   return val;
 }
 
@@ -3563,7 +3597,6 @@ syms_of_data (void)
 
   DEFSYM (Qquote, "quote");
   DEFSYM (Qlambda, "lambda");
-  DEFSYM (Qsubr, "subr");
   DEFSYM (Qerror_conditions, "error-conditions");
   DEFSYM (Qerror_message, "error-message");
   DEFSYM (Qtop_level, "top-level");
@@ -3604,6 +3637,7 @@ syms_of_data (void)
   DEFSYM (Qsequencep, "sequencep");
   DEFSYM (Qbufferp, "bufferp");
   DEFSYM (Qvectorp, "vectorp");
+  DEFSYM (Qrecordp, "recordp");
   DEFSYM (Qbool_vector_p, "bool-vector-p");
   DEFSYM (Qchar_or_string_p, "char-or-string-p");
   DEFSYM (Qmarkerp, "markerp");
@@ -3704,28 +3738,31 @@ syms_of_data (void)
   DEFSYM (Qoverlay, "overlay");
   DEFSYM (Qfinalizer, "finalizer");
 #ifdef HAVE_MODULES
+  DEFSYM (Qmodule_function, "module-function");
   DEFSYM (Quser_ptr, "user-ptr");
 #endif
   DEFSYM (Qfloat, "float");
   DEFSYM (Qwindow_configuration, "window-configuration");
   DEFSYM (Qprocess, "process");
   DEFSYM (Qwindow, "window");
+  DEFSYM (Qsubr, "subr");
   DEFSYM (Qcompiled_function, "compiled-function");
   DEFSYM (Qbuffer, "buffer");
   DEFSYM (Qframe, "frame");
   DEFSYM (Qvector, "vector");
+  DEFSYM (Qrecord, "record");
   DEFSYM (Qchar_table, "char-table");
   DEFSYM (Qbool_vector, "bool-vector");
   DEFSYM (Qhash_table, "hash-table");
   DEFSYM (Qthread, "thread");
   DEFSYM (Qmutex, "mutex");
   DEFSYM (Qcondition_variable, "condition-variable");
-
-  DEFSYM (Qdefun, "defun");
-
   DEFSYM (Qfont_spec, "font-spec");
   DEFSYM (Qfont_entity, "font-entity");
   DEFSYM (Qfont_object, "font-object");
+  DEFSYM (Qterminal, "terminal");
+
+  DEFSYM (Qdefun, "defun");
 
   DEFSYM (Qinteractive_form, "interactive-form");
   DEFSYM (Qdefalias_fset_function, "defalias-fset-function");
@@ -3750,6 +3787,7 @@ syms_of_data (void)
   defsubr (&Sstringp);
   defsubr (&Smultibyte_string_p);
   defsubr (&Svectorp);
+  defsubr (&Srecordp);
   defsubr (&Schar_table_p);
   defsubr (&Svector_or_char_table_p);
   defsubr (&Sbool_vector_p);
@@ -3759,6 +3797,7 @@ syms_of_data (void)
   defsubr (&Smarkerp);
   defsubr (&Ssubrp);
   defsubr (&Sbyte_code_function_p);
+  defsubr (&Smodule_function_p);
   defsubr (&Schar_or_string_p);
   defsubr (&Sthreadp);
   defsubr (&Smutexp);
diff --git a/src/dispextern.h b/src/dispextern.h
index 679820d5063..8644ce26d13 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -1106,7 +1106,7 @@ struct glyph_row *matrix_row (struct glyph_matrix *, int);
 #define MATRIX_BOTTOM_TEXT_ROW(MATRIX, W)               \
      ((MATRIX)->rows                                    \
       + (MATRIX)->nrows                                 \
-      - (WINDOW_WANTS_MODELINE_P ((W)) ? 1 : 0))
+      - (window_wants_mode_line ((W)) ? 1 : 0))
 
 /* Non-zero if the face of the last glyph in ROW's text area has
    to be drawn to the end of the text area.  */
@@ -1469,40 +1469,6 @@ struct glyph_string
 #define DESIRED_HEADER_LINE_HEIGHT(W) \
      MATRIX_HEADER_LINE_HEIGHT ((W)->desired_matrix)
 
-/* PXW: The height checks below serve to show at least one text line
-   instead of a mode- and/or header line when a window gets very small.
-   But (1) the check fails when the mode- or header-line is taller than
-   the associated frame's line height and (2) we don't care much about
-   text visibility anyway when shrinking a frame containing a toolbar.
-
-   So maybe these checks should be removed and any clipping left to the
-   window manager.  */
-
-/* Value is true if window W wants a mode line and is large enough
-   to accommodate it.  */
-#define WINDOW_WANTS_MODELINE_P(W)                                      \
-  (BUFFERP ((W)->contents)                                              \
-   ? (!MINI_WINDOW_P (W)                                                \
-      && !(W)->pseudo_window_p                                          \
-      && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (W)))             \
-      && !NILP (BVAR (XBUFFER ((W)->contents), mode_line_format))       \
-      && WINDOW_PIXEL_HEIGHT (W) > WINDOW_FRAME_LINE_HEIGHT (W))        \
-   : false)
-
-/* Value is true if window W wants a header line and is large enough
-   to accommodate it.  */
-#define WINDOW_WANTS_HEADER_LINE_P(W)                                   \
-     (BUFFERP ((W)->contents)                                           \
-      ? (!MINI_WINDOW_P (W)                                             \
-         && !(W)->pseudo_window_p                                       \
-         && FRAME_WANTS_MODELINE_P (XFRAME (WINDOW_FRAME (W)))          \
-         && !NILP (BVAR (XBUFFER ((W)->contents), header_line_format))  \
-         && (WINDOW_PIXEL_HEIGHT (W)                                    \
-             > (WINDOW_WANTS_MODELINE_P (W)                             \
-                ? (2 * WINDOW_FRAME_LINE_HEIGHT (W))                    \
-                : WINDOW_FRAME_LINE_HEIGHT (W))))                       \
-      : false)
-
 /* Return proper value to be used as baseline offset of font that has
    ASCENT and DESCENT to draw characters by the font at the vertical
    center of the line of frame F.
@@ -1784,6 +1750,7 @@ enum face_id
   WINDOW_DIVIDER_FACE_ID,
   WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID,
   WINDOW_DIVIDER_LAST_PIXEL_FACE_ID,
+  INTERNAL_BORDER_FACE_ID,
   BASIC_FACE_ID_SENTINEL
 };
 
diff --git a/src/dispnew.c b/src/dispnew.c
index 27c69bde831..93ef6a55a2e 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -377,7 +377,7 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y
     {
       window_box (w, ANY_AREA, 0, 0, &window_width, &window_height);
 
-      header_line_p = WINDOW_WANTS_HEADER_LINE_P (w);
+      header_line_p = window_wants_header_line (w);
       header_line_changed_p = header_line_p != matrix->header_line_p;
     }
   matrix->header_line_p = header_line_p;
@@ -446,7 +446,7 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y
 
           if (w == NULL
               || (row == matrix->rows + dim.height - 1
-                  && WINDOW_WANTS_MODELINE_P (w))
+                  && window_wants_mode_line (w))
               || (row == matrix->rows && matrix->header_line_p))
             {
               row->glyphs[TEXT_AREA]
@@ -491,7 +491,7 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y
 
               /* The mode line, if displayed, never has marginal areas.  */
               if ((row == matrix->rows + dim.height - 1
-                   && !(w && WINDOW_WANTS_MODELINE_P (w)))
+                   && !(w && window_wants_mode_line (w)))
                   || (row == matrix->rows && matrix->header_line_p))
                 {
                   row->glyphs[TEXT_AREA]
@@ -570,7 +570,7 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y
              the mode line, if any, since otherwise it will remain
              disabled in the current matrix, and expose events won't
              redraw it.  */
-          if (WINDOW_WANTS_MODELINE_P (w))
+          if (window_wants_mode_line (w))
             w->update_mode_line = 1;
         }
       else if (matrix == w->desired_matrix)
@@ -3126,9 +3126,9 @@ update_frame (struct frame *f, bool force_p, bool inhibit_hairy_id_p)
       if (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
         {
           if (FRAME_TTY (f)->termscript)
-            fflush (FRAME_TTY (f)->termscript);
+            fflush_unlocked (FRAME_TTY (f)->termscript);
           if (FRAME_TERMCAP_P (f))
-            fflush (FRAME_TTY (f)->output);
+            fflush_unlocked (FRAME_TTY (f)->output);
         }
 
       /* Check window matrices for lost pointers.  */
@@ -3181,8 +3181,8 @@ update_frame_with_menu (struct frame *f, int row, int col)
   update_end (f);
 
   if (FRAME_TTY (f)->termscript)
-    fflush (FRAME_TTY (f)->termscript);
-  fflush (FRAME_TTY (f)->output);
+    fflush_unlocked (FRAME_TTY (f)->termscript);
+  fflush_unlocked (FRAME_TTY (f)->output);
   /* Check window matrices for lost pointers.  */
 #if GLYPH_DEBUG
 #if 0
@@ -4531,7 +4531,7 @@ update_frame_1 (struct frame *f, bool force_p, bool inhibit_id_p,
                   ptrdiff_t outq = __fpending (display_output);
                   if (outq > 900
                       || (outq > 20 && ((i - 1) % preempt_count == 0)))
-                    fflush (display_output);
+                    fflush_unlocked (display_output);
                 }
             }
 
@@ -5188,7 +5188,7 @@ buffer_posn_from_coords (struct window *w, int *x, int *y, struct display_pos *p
      start position, i.e. it excludes the header-line row, but
      MATRIX_ROW includes the header-line row.  Adjust for a possible
      header-line row.  */
-  it_vpos = it.vpos + WINDOW_WANTS_HEADER_LINE_P (w);
+  it_vpos = it.vpos + window_wants_header_line (w);
   if (it_vpos < w->current_matrix->nrows
       && (row = MATRIX_ROW (w->current_matrix, it_vpos),
           row->enabled_p))
@@ -5615,13 +5615,13 @@ when TERMINAL is nil.  */)
 
       if (tty->termscript)
         {
-          fwrite (SDATA (string), 1, SBYTES (string), tty->termscript);
-          fflush (tty->termscript);
+          fwrite_unlocked (SDATA (string), 1, SBYTES (string), tty->termscript);
+          fflush_unlocked (tty->termscript);
         }
       out = tty->output;
     }
-  fwrite (SDATA (string), 1, SBYTES (string), out);
-  fflush (out);
+  fwrite_unlocked (SDATA (string), 1, SBYTES (string), out);
+  fflush_unlocked (out);
   unblock_input ();
   return Qnil;
 }
@@ -5636,7 +5636,7 @@ terminate any keyboard macro currently executing.  */)
   if (!NILP (arg))
     {
       if (noninteractive)
-        putchar (07);
+        putchar_unlocked (07);
       else
         ring_bell (XFRAME (selected_frame));
     }
@@ -5650,7 +5650,7 @@ void
 bitch_at_user (void)
 {
   if (noninteractive)
-    putchar (07);
+    putchar_unlocked (07);
   else if (!INTERACTIVE)  /* Stop executing a keyboard macro.  */
     {
       const char *msg
diff --git a/src/doc.c b/src/doc.c
index 1e7e3fcf6a6..345e18b9186 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -340,9 +340,11 @@ string is passed through `substitute-command-keys'.  */)
     fun = XCDR (fun);
   if (SUBRP (fun))
     doc = make_number (XSUBR (fun)->doc);
+  else if (MODULE_FUNCTIONP (fun))
+    doc = XMODULE_FUNCTION (fun)->documentation;
   else if (COMPILEDP (fun))
     {
-      if ((ASIZE (fun) & PSEUDOVECTOR_SIZE_MASK) <= COMPILED_DOC_STRING)
+      if (PVSIZE (fun) <= COMPILED_DOC_STRING)
         return Qnil;
       else
         {
@@ -500,7 +502,7 @@ store_function_docstring (Lisp_Object obj, EMACS_INT offset)
     {
       /* This bytecode object must have a slot for the
          docstring, since we've found a docstring for it.  */
-      if ((ASIZE (fun) & PSEUDOVECTOR_SIZE_MASK) > COMPILED_DOC_STRING)
+      if (PVSIZE (fun) > COMPILED_DOC_STRING)
         ASET (fun, COMPILED_DOC_STRING, make_number (offset));
       else
         {
diff --git a/src/doprnt.c b/src/doprnt.c
index 09051adc053..418601acb02 100644
--- a/src/doprnt.c
+++ b/src/doprnt.c
@@ -352,6 +352,7 @@ doprnt (char *buffer, ptrdiff_t bufsize, const char *format,
 
             case 'S':
               string[-1] = 's';
+              FALLTHROUGH;
             case 's':
               if (fmtcpy[1] != 's')
                 minlen = atoi (&fmtcpy[1]);
@@ -437,7 +438,9 @@ doprnt (char *buffer, ptrdiff_t bufsize, const char *format,
               }
 
             case '%':
-              fmt--;    /* Drop thru and this % will be treated as normal */
+              /* Treat this '%' as normal.  */
+              fmt0 = fmt - 1;
+              break;
             }
         }
 
diff --git a/src/dynlib.c b/src/dynlib.c
index 95619236d43..47ba5e3d91b 100644
--- a/src/dynlib.c
+++ b/src/dynlib.c
@@ -28,6 +28,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "dynlib.h"
 
+#include <stddef.h>
+
 #ifdef WINDOWSNT
 
 /* MS-Windows systems.  */
@@ -120,15 +122,13 @@ dynlib_sym (dynlib_handle_ptr h, const char *sym)
   return (void *)sym_addr;
 }
 
-bool
+void
 dynlib_addr (void *addr, const char **fname, const char **symname)
 {
   static char dll_filename[MAX_UTF8_PATH];
-  static char addr_str[22];
   static GetModuleHandleExA_Proc s_pfn_Get_Module_HandleExA = NULL;
   char *dll_fn = NULL;
   HMODULE hm_kernel32 = NULL;
-  bool result = false;
   HMODULE hm_dll = NULL;
   wchar_t mfn_w[MAX_PATH];
   char mfn_a[MAX_PATH];
@@ -206,23 +206,19 @@ dynlib_addr (void *addr, const char **fname, const char **symname)
             dynlib_last_err = GetLastError ();
         }
       if (dll_fn)
-        {
-          dostounix_filename (dll_fn);
-          /* We cannot easily produce the function name, since
-             typically all of the module functions will be unexported,
-             and probably even static, which means the symbols can be
-             obtained only if we link against libbfd (and the DLL can
-             be stripped anyway).  So we just show the address and the
-             file name; they can use that with addr2line or GDB to
-             recover the symbolic name.  */
-          sprintf (addr_str, "at 0x%x", (DWORD_PTR)addr);
-          *symname = addr_str;
-          result = true;
-        }
+        dostounix_filename (dll_fn);
     }
 
   *fname = dll_fn;
-  return result;
+
+  /* We cannot easily produce the function name, since typically all
+     of the module functions will be unexported, and probably even
+     static, which means the symbols can be obtained only if we link
+     against libbfd (and the DLL can be stripped anyway).  So we just
+     show the address and the file name (see print_vectorlike in
+     print.c); they can use that with addr2line or GDB to recover the
+     symbolic name.  */
+  *symname = NULL;
 }
 
 const char *
@@ -283,19 +279,19 @@ dynlib_sym (dynlib_handle_ptr h, const char *sym)
   return dlsym (h, sym);
 }
 
-bool
+void
 dynlib_addr (void *ptr, const char **path, const char **sym)
 {
+  *path = NULL;
+  *sym = NULL;
 #ifdef HAVE_DLADDR
   Dl_info info;
   if (dladdr (ptr, &info) && info.dli_fname && info.dli_sname)
     {
       *path = info.dli_fname;
       *sym = info.dli_sname;
-      return true;
     }
 #endif
-  return false;
 }
 
 const char *
diff --git a/src/dynlib.h b/src/dynlib.h
index 5ccec11bc79..1d53b8e5b2f 100644
--- a/src/dynlib.h
+++ b/src/dynlib.h
@@ -24,11 +24,17 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 typedef void *dynlib_handle_ptr;
 dynlib_handle_ptr dynlib_open (const char *path);
-void *dynlib_sym (dynlib_handle_ptr h, const char *sym);
-typedef struct dynlib_function_ptr_nonce *(*dynlib_function_ptr) (void);
-dynlib_function_ptr dynlib_func (dynlib_handle_ptr h, const char *sym);
-bool dynlib_addr (void *ptr, const char **path, const char **sym);
-const char *dynlib_error (void);
 int dynlib_close (dynlib_handle_ptr h);
+const char *dynlib_error (void);
+
+ATTRIBUTE_MAY_ALIAS void *dynlib_sym (dynlib_handle_ptr h, const char *sym);
+
+typedef struct dynlib_function_ptr_nonce *(ATTRIBUTE_MAY_ALIAS *dynlib_function_ptr) (void);
+dynlib_function_ptr dynlib_func (dynlib_handle_ptr h, const char *sym);
+
+/* Sets *FILE to the file name from which PTR was loaded, and *SYM to
+   its symbol name.  If the file or symbol name could not be
+   determined, set the corresponding argument to NULL.  */
+void dynlib_addr (void *ptr, const char **file, const char **sym);
 
 #endif /* DYNLIB_H */
diff --git a/src/editfns.c b/src/editfns.c
index 2dafd8e7b1b..da99c055b54 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -48,6 +48,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <float.h>
 #include <limits.h>
 
+#include <c-ctype.h>
 #include <intprops.h>
 #include <stdlib.h>
 #include <strftime.h>
@@ -81,10 +82,8 @@ static Lisp_Object styled_format (ptrdiff_t, Lisp_Object *, bool);
 
 enum { tzeqlen = sizeof "TZ=" - 1 };
 
-/* Time zones equivalent to current local time, to wall clock time,
-   and to UTC, respectively.  */
+/* Time zones equivalent to current local time and to UTC, respectively.  */
 static timezone_t local_tz;
-static timezone_t wall_clock_tz;
 static timezone_t const utc_tz = 0;
 
 /* The cached value of Vsystem_name.  This is used only to compare it
@@ -226,7 +225,7 @@ tzlookup (Lisp_Object zone, bool settz)
 void
 init_editfns (bool dumping)
 {
-#if !defined CANNOT_DUMP && defined HAVE_TZSET
+#if !defined CANNOT_DUMP
   /* A valid but unlikely setting for the TZ environment variable.
      It is OK (though a bit slower) if the user chooses this value.  */
   static char dump_tz_string[] = "TZ=UtC0";
@@ -245,17 +244,15 @@ init_editfns (bool dumping)
      and skip the rest of this function.  */
   if (dumping)
     {
-# ifdef HAVE_TZSET
       xputenv (dump_tz_string);
       tzset ();
-# endif
       return;
     }
 #endif
 
   char *tz = getenv ("TZ");
 
-#if !defined CANNOT_DUMP && defined HAVE_TZSET
+#if !defined CANNOT_DUMP
   /* If the execution TZ happens to be the same as the dump TZ,
      change it to some other value and then change it back,
      to force the underlying implementation to reload the TZ info.
@@ -271,7 +268,6 @@ init_editfns (bool dumping)
 
   /* Set the time zone rule now, so that the call to putenv is done
      before multiple threads are active.  */
-  wall_clock_tz = xtzalloc (0);
   tzlookup (tz ? build_string (tz) : Qwall, true);
 
   pw = getpwuid (getuid ());
@@ -1597,10 +1593,10 @@ time_arith (Lisp_Object a, Lisp_Object b,
     {
     default:
       val = Fcons (make_number (t.ps), val);
-      /* Fall through.  */
+      FALLTHROUGH;
     case 3:
       val = Fcons (make_number (t.us), val);
-      /* Fall through.  */
+      FALLTHROUGH;
     case 2:
       val = Fcons (make_number (t.lo), val);
       val = Fcons (make_number (t.hi), val);
@@ -2144,7 +2140,7 @@ the epoch.  The obsolete form (HIGH . LOW) is also still accepted.
 The optional ZONE is omitted or nil for Emacs local time, t for
 Universal Time, `wall' for system wall clock time, or a string as in
 the TZ environment variable.  It can also be a list (as from
-`current-time-zone') or an integer (as from `decode-time') applied
+`current-time-zone') or an integer (the UTC offset in seconds) applied
 without consideration for daylight saving time.
 
 The list has the following nine members: SEC is an integer between 0
@@ -3109,6 +3105,207 @@ determines whether case is significant or ignored.  */)
   /* Same length too => they are equal.  */
   return make_number (0);
 }
+
+
+/* Set up necessary definitions for diffseq.h; see comments in
+   diffseq.h for explanation.  */
+
+#undef ELEMENT
+#undef EQUAL
+
+#define XVECREF_YVECREF_EQUAL(ctx, xoff, yoff)  \
+  buffer_chars_equal ((ctx), (xoff), (yoff))
+
+#define OFFSET ptrdiff_t
+
+#define EXTRA_CONTEXT_FIELDS                    \
+  /* Buffers to compare.  */                    \
+  struct buffer *buffer_a;                      \
+  struct buffer *buffer_b;                      \
+  /* Bit vectors recording for each character whether it was deleted
+     or inserted.  */                           \
+  unsigned char *deletions;                     \
+  unsigned char *insertions;
+
+#define NOTE_DELETE(ctx, xoff) set_bit ((ctx)->deletions, (xoff))
+#define NOTE_INSERT(ctx, yoff) set_bit ((ctx)->insertions, (yoff))
+
+struct context;
+static void set_bit (unsigned char *, OFFSET);
+static bool bit_is_set (const unsigned char *, OFFSET);
+static bool buffer_chars_equal (struct context *, OFFSET, OFFSET);
+
+#include "minmax.h"
+#include "diffseq.h"
+
+DEFUN ("replace-buffer-contents", Freplace_buffer_contents,
+       Sreplace_buffer_contents, 1, 1, "bSource buffer: ",
+       doc: /* Replace accessible portion of current buffer with that of SOURCE.
+SOURCE can be a buffer or a string that names a buffer.
+Interactively, prompt for SOURCE.
+As far as possible the replacement is non-destructive, i.e. existing
+buffer contents, markers, properties, and overlays in the current
+buffer stay intact.  */)
+  (Lisp_Object source)
+{
+  struct buffer *a = current_buffer;
+  Lisp_Object source_buffer = Fget_buffer (source);
+  if (NILP (source_buffer))
+    nsberror (source);
+  struct buffer *b = XBUFFER (source_buffer);
+  if (! BUFFER_LIVE_P (b))
+    error ("Selecting deleted buffer");
+  if (a == b)
+    error ("Cannot replace a buffer with itself");
+
+  ptrdiff_t min_a = BEGV;
+  ptrdiff_t min_b = BUF_BEGV (b);
+  ptrdiff_t size_a = ZV - min_a;
+  ptrdiff_t size_b = BUF_ZV (b) - min_b;
+  eassume (size_a >= 0);
+  eassume (size_b >= 0);
+  bool a_empty = size_a == 0;
+  bool b_empty = size_b == 0;
+
+  /* Handle trivial cases where at least one accessible portion is
+     empty.  */
+
+  if (a_empty && b_empty)
+    return Qnil;
+
+  if (a_empty)
+    return Finsert_buffer_substring (source, Qnil, Qnil);
+
+  if (b_empty)
+    {
+      del_range_both (BEGV, BEGV_BYTE, ZV, ZV_BYTE, true);
+      return Qnil;
+    }
+
+  /* FIXME: It is not documented how to initialize the contents of the
+     context structure.  This code cargo-cults from the existing
+     caller in src/analyze.c of GNU Diffutils, which appears to
+     work.  */
+
+  ptrdiff_t diags = size_a + size_b + 3;
+  ptrdiff_t *buffer;
+  USE_SAFE_ALLOCA;
+  SAFE_NALLOCA (buffer, 2, diags);
+  /* Micro-optimization: Casting to size_t generates much better
+     code.  */
+  ptrdiff_t del_bytes = (size_t) size_a / CHAR_BIT + 1;
+  ptrdiff_t ins_bytes = (size_t) size_b / CHAR_BIT + 1;
+  struct context ctx = {
+    .buffer_a = a,
+    .buffer_b = b,
+    .deletions = SAFE_ALLOCA (del_bytes),
+    .insertions = SAFE_ALLOCA (ins_bytes),
+    .fdiag = buffer + size_b + 1,
+    .bdiag = buffer + diags + size_b + 1,
+    /* FIXME: Find a good number for .too_expensive.  */
+    .too_expensive = 1000000,
+  };
+  memclear (ctx.deletions, del_bytes);
+  memclear (ctx.insertions, ins_bytes);
+  /* compareseq requires indices to be zero-based.  We add BEGV back
+     later.  */
+  bool early_abort = compareseq (0, size_a, 0, size_b, false, &ctx);
+  /* Since we didn’t define EARLY_ABORT, we should never abort
+     early.  */
+  eassert (! early_abort);
+  SAFE_FREE ();
+
+  Fundo_boundary ();
+  ptrdiff_t count = SPECPDL_INDEX ();
+  record_unwind_protect (save_excursion_restore, save_excursion_save ());
+
+  ptrdiff_t i = size_a;
+  ptrdiff_t j = size_b;
+  /* Walk backwards through the lists of changes.  This was also
+     cargo-culted from src/analyze.c in GNU Diffutils.  Because we
+     walk backwards, we don’t have to keep the positions in sync.  */
+  while (i >= 0 || j >= 0)
+    {
+      /* Check whether there is a change (insertion or deletion)
+         before the current position.  */
+      if ((i > 0 && bit_is_set (ctx.deletions, i - 1)) ||
+          (j > 0 && bit_is_set (ctx.insertions, j - 1)))
+        {
+          ptrdiff_t end_a = min_a + i;
+          ptrdiff_t end_b = min_b + j;
+          /* Find the beginning of the current change run.  */
+          while (i > 0 && bit_is_set (ctx.deletions, i - 1))
+            --i;
+          while (j > 0 && bit_is_set (ctx.insertions, j - 1))
+            --j;
+          ptrdiff_t beg_a = min_a + i;
+          ptrdiff_t beg_b = min_b + j;
+          eassert (beg_a >= BEGV);
+          eassert (beg_b >= BUF_BEGV (b));
+          eassert (beg_a <= end_a);
+          eassert (beg_b <= end_b);
+          eassert (end_a <= ZV);
+          eassert (end_b <= BUF_ZV (b));
+          eassert (beg_a < end_a || beg_b < end_b);
+          if (beg_a < end_a)
+            del_range (beg_a, end_a);
+          if (beg_b < end_b)
+            {
+              SET_PT (beg_a);
+              Finsert_buffer_substring (source, make_natnum (beg_b),
+                                        make_natnum (end_b));
+            }
+        }
+      --i;
+      --j;
+    }
+
+  return unbind_to (count, Qnil);
+}
+
+static void
+set_bit (unsigned char *a, ptrdiff_t i)
+{
+  eassert (i >= 0);
+  /* Micro-optimization: Casting to size_t generates much better
+     code.  */
+  size_t j = i;
+  a[j / CHAR_BIT] |= (1 << (j % CHAR_BIT));
+}
+
+static bool
+bit_is_set (const unsigned char *a, ptrdiff_t i)
+{
+  eassert (i >= 0);
+  /* Micro-optimization: Casting to size_t generates much better
+     code.  */
+  size_t j = i;
+  return a[j / CHAR_BIT] & (1 << (j % CHAR_BIT));
+}
+
+/* Return true if the characters at position POS_A of buffer
+   CTX->buffer_a and at position POS_B of buffer CTX->buffer_b are
+   equal.  POS_A and POS_B are zero-based.  Text properties are
+   ignored.  */
+
+static bool
+buffer_chars_equal (struct context *ctx,
+                    ptrdiff_t pos_a, ptrdiff_t pos_b)
+{
+  eassert (pos_a >= 0);
+  pos_a += BUF_BEGV (ctx->buffer_a);
+  eassert (pos_a >= BUF_BEGV (ctx->buffer_a));
+  eassert (pos_a < BUF_ZV (ctx->buffer_a));
+
+  eassert (pos_b >= 0);
+  pos_b += BUF_BEGV (ctx->buffer_b);
+  eassert (pos_b >= BUF_BEGV (ctx->buffer_b));
+  eassert (pos_b < BUF_ZV (ctx->buffer_b));
+
+  return BUF_FETCH_CHAR_AS_MULTIBYTE (ctx->buffer_a, pos_a)
+    == BUF_FETCH_CHAR_AS_MULTIBYTE (ctx->buffer_b, pos_b);
+}
+
 
 static void
 subst_char_in_region_unwind (Lisp_Object arg)
@@ -3739,11 +3936,10 @@ In batch mode, the message is printed to the standard error stream,
 followed by a newline.
 
 The first argument is a format control string, and the rest are data
-to be formatted under control of the string.  See `format-message' for
-details.
-
-Note: (message "%s" VALUE) displays the string VALUE without
-interpreting format characters like `%', `\\=`', and `\\=''.
+to be formatted under control of the string.  Percent sign (%), grave
+accent (\\=`) and apostrophe (\\=') are special in the format; see
+`format-message' for details.  To display STRING without special
+treatment, use (message "%s" STRING).
 
 If the first argument is nil or the empty string, the function clears
 any existing message; this lets the minibuffer contents show.  See
@@ -3856,13 +4052,30 @@ usage: (propertize STRING &rest PROPERTIES)  */)
   return string;
 }
 
+/* Convert the prefix of STR from ASCII decimal digits to a number.
+   Set *STR_END to the address of the first non-digit.  Return the
+   number, or PTRDIFF_MAX on overflow.  Return 0 if there is no number.
+   This is like strtol for ptrdiff_t and base 10 and C locale,
+   except without negative numbers or errno.  */
+
+static ptrdiff_t
+str2num (char *str, char **str_end)
+{
+  ptrdiff_t n = 0;
+  for (; c_isdigit (*str); str++)
+    if (INT_MULTIPLY_WRAPV (n, 10, &n) || INT_ADD_WRAPV (n, *str - '0', &n))
+      n = PTRDIFF_MAX;
+  *str_end = str;
+  return n;
+}
+
 DEFUN ("format", Fformat, Sformat, 1, MANY, 0,
        doc: /* Format a string out of a format-string and arguments.
 The first argument is a format control string.
 The other arguments are substituted into it to make the result, a string.
 
 The format control string may contain %-sequences meaning to substitute
-the next available argument:
+the next available argument, or the argument explicitly specified:
 
 %s means print a string argument.  Actually, prints any object, with `princ'.
 %d means print as signed number in decimal.
@@ -3879,13 +4092,19 @@ the next available argument:
 The argument used for %d, %o, %x, %e, %f, %g or %c must be a number.
 Use %% to put a single % into the output.
 
-A %-sequence may contain optional flag, width, and precision
-specifiers, as follows:
+A %-sequence other than %% may contain optional field number, flag,
+width, and precision specifiers, as follows:
+
+  %<field><flags><width><precision>character
 
-  %<flags><width><precision>character
+where field is [0-9]+ followed by a literal dollar "$", flags is
+[+ #-0]+, width is [0-9]+, and precision is a literal period "."
+followed by [0-9]+.
 
-where flags is [+ #-0]+, width is [0-9]+, and precision is a literal
-period "." followed by [0-9]+
+If a %-sequence is numbered with a field with positive value N, the
+Nth argument is substituted instead of the next one.  A format can
+contain either numbered or unnumbered %-sequences but not both, except
+that %% can be mixed with numbered %-sequences.
 
 The + flag character inserts a + before any positive number, while a
 space inserts a space before any positive number; these flags only
@@ -3960,38 +4179,42 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
   bool maybe_combine_byte;
   bool arg_intervals = false;
   USE_SAFE_ALLOCA;
+  sa_avail -= sizeof initial_buffer;
 
-  /* Each element records, for one argument,
-     the start and end bytepos in the output string,
-     whether the argument has been converted to string (e.g., due to "%S"),
-     and whether the argument is a string with intervals.  */
+  /* Information recorded for each format spec.  */
   struct info
   {
+    /* The corresponding argument, converted to string if conversion
+       was needed.  */
+    Lisp_Object argument;
+
+    /* The start and end bytepos in the output string.  */
     ptrdiff_t start, end;
-    bool_bf converted_to_string : 1;
+
+    /* Whether the argument is a string with intervals.  */
     bool_bf intervals : 1;
   } *info;
 
   CHECK_STRING (args[0]);
   char *format_start = SSDATA (args[0]);
+  bool multibyte_format = STRING_MULTIBYTE (args[0]);
   ptrdiff_t formatlen = SBYTES (args[0]);
 
+  /* Upper bound on number of format specs.  Each uses at least 2 chars.  */
+  ptrdiff_t nspec_bound = SCHARS (args[0]) >> 1;
+
   /* Allocate the info and discarded tables.  */
   ptrdiff_t alloca_size;
-  if (INT_MULTIPLY_WRAPV (nargs, sizeof *info, &alloca_size)
-      || INT_ADD_WRAPV (sizeof *info, alloca_size, &alloca_size)
+  if (INT_MULTIPLY_WRAPV (nspec_bound, sizeof *info, &alloca_size)
       || INT_ADD_WRAPV (formatlen, alloca_size, &alloca_size)
       || SIZE_MAX < alloca_size)
     memory_full (SIZE_MAX);
-  /* info[0] is unused.  Unused elements have -1 for start.  */
   info = SAFE_ALLOCA (alloca_size);
-  memset (info, 0, alloca_size);
-  for (ptrdiff_t i = 0; i < nargs + 1; i++)
-    info[i].start = -1;
   /* discarded[I] is 1 if byte I of the format
      string was not copied into the output.
      It is 2 if byte I was not the first byte of its character.  */
-  char *discarded = (char *) &info[nargs + 1];
+  char *discarded = (char *) &info[nspec_bound];
+  memset (discarded, 0, formatlen);
 
   /* Try to determine whether the result should be multibyte.
      This is not always right; sometimes the result needs to be multibyte
@@ -3999,8 +4222,6 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
      or because a grave accent or apostrophe is requoted,
      and in that case, we won't know it here.  */
 
-  /* True if the format is multibyte.  */
-  bool multibyte_format = STRING_MULTIBYTE (args[0]);
   /* True if the output should be a multibyte string,
      which is true if any of the inputs is one.  */
   bool multibyte = multibyte_format;
@@ -4010,13 +4231,19 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
 
   int quoting_style = message ? text_quoting_style () : -1;
 
+  ptrdiff_t ispec;
+  ptrdiff_t nspec = 0;
+
   /* If we start out planning a unibyte result,
      then discover it has to be multibyte, we jump back to retry.  */
  retry:
 
   p = buf;
   nchars = 0;
+
+  /* N is the argument index, ISPEC is the specification index.  */
   n = 0;
+  ispec = 0;
 
   /* Scan the format and store result in BUF.  */
   format = format_start;
@@ -4025,8 +4252,10 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
 
   while (format != end)
     {
-      /* The values of N and FORMAT when the loop body is entered.  */
+      /* The values of N, ISPEC, and FORMAT when the loop body is
+         entered.  */
       ptrdiff_t n0 = n;
+      ptrdiff_t ispec0 = ispec;
       char *format0 = format;
       char const *convsrc = format;
       unsigned char format_char = *format++;
@@ -4038,14 +4267,18 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
         {
           /* General format specifications look like
 
-             '%' [flags] [field-width] [precision] format
+             '%' [field-number] [flags] [field-width] [precision] format
 
              where
 
+             field-number ::= [0-9]+ '$'
              flags ::= [-+0# ]+
              field-width ::= [0-9]+
              precision ::= '.' [0-9]*
 
+             If present, a field-number specifies the argument number
+             to substitute.  Otherwise, the next argument is taken.
+
              If a field-width is specified, it specifies to which width
              the output should be padded with blanks, if the output
              string is shorter than field-width.
@@ -4054,6 +4287,18 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
              digits to print after the '.' for floats, or the max.
              number of chars to print from a string.  */
 
+          ptrdiff_t num;
+          char *num_end;
+          if (c_isdigit (*format))
+            {
+              num = str2num (format, &num_end);
+              if (*num_end == '$')
+                {
+                  n = num - 1;
+                  format = num_end + 1;
+                }
+            }
+
           bool minus_flag = false;
           bool  plus_flag = false;
           bool space_flag = false;
@@ -4074,19 +4319,18 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
             }
 
           /* Ignore flags when sprintf ignores them.  */
-          space_flag &= ~ plus_flag;
-          zero_flag &= ~ minus_flag;
+          space_flag &= ! plus_flag;
+          zero_flag &= ! minus_flag;
 
-          char *num_end;
-          uintmax_t raw_field_width = strtoumax (format, &num_end, 10);
-          if (max_bufsize <= raw_field_width)
+          num = str2num (format, &num_end);
+          if (max_bufsize <= num)
             string_overflow ();
-          ptrdiff_t field_width = raw_field_width;
+          ptrdiff_t field_width = num;
 
           bool precision_given = *num_end == '.';
-          uintmax_t precision = (precision_given
-                                 ? strtoumax (num_end + 1, &num_end, 10)
-                                 : UINTMAX_MAX);
+          ptrdiff_t precision = (precision_given
+                                 ? str2num (num_end + 1, &num_end)
+                                 : PTRDIFF_MAX);
           format = num_end;
 
           if (format == end)
@@ -4102,20 +4346,28 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
           if (! (n < nargs))
             error ("Not enough arguments for format string");
 
+          struct info *spec = &info[ispec++];
+          if (nspec < ispec)
+            {
+              spec->argument = args[n];
+              spec->intervals = false;
+              nspec = ispec;
+            }
+          Lisp_Object arg = spec->argument;
+
           /* For 'S', prin1 the argument, and then treat like 's'.
              For 's', princ any argument that is not a string or
              symbol.  But don't do this conversion twice, which might
              happen after retrying.  */
           if ((conversion == 'S'
                || (conversion == 's'
-                   && ! STRINGP (args[n]) && ! SYMBOLP (args[n]))))
+                   && ! STRINGP (arg) && ! SYMBOLP (arg))))
             {
-              if (! info[n].converted_to_string)
+              if (EQ (arg, args[n]))
                 {
                   Lisp_Object noescape = conversion == 'S' ? Qnil : Qt;
-                  args[n] = Fprin1_to_string (args[n], noescape);
-                  info[n].converted_to_string = true;
-                  if (STRING_MULTIBYTE (args[n]) && ! multibyte)
+                  spec->argument = arg = Fprin1_to_string (arg, noescape);
+                  if (STRING_MULTIBYTE (arg) && ! multibyte)
                     {
                       multibyte = true;
                       goto retry;
@@ -4125,26 +4377,25 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
             }
           else if (conversion == 'c')
             {
-              if (INTEGERP (args[n]) && ! ASCII_CHAR_P (XINT (args[n])))
+              if (INTEGERP (arg) && ! ASCII_CHAR_P (XINT (arg)))
                 {
                   if (!multibyte)
                     {
                       multibyte = true;
                       goto retry;
                     }
-                  args[n] = Fchar_to_string (args[n]);
-                  info[n].converted_to_string = true;
+                  spec->argument = arg = Fchar_to_string (arg);
                 }
 
-              if (info[n].converted_to_string)
+              if (!EQ (arg, args[n]))
                 conversion = 's';
               zero_flag = false;
             }
 
-          if (SYMBOLP (args[n]))
+          if (SYMBOLP (arg))
             {
-              args[n] = SYMBOL_NAME (args[n]);
-              if (STRING_MULTIBYTE (args[n]) && ! multibyte)
+              spec->argument = arg = SYMBOL_NAME (arg);
+              if (STRING_MULTIBYTE (arg) && ! multibyte)
                 {
                   multibyte = true;
                   goto retry;
@@ -4159,7 +4410,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
               /* handle case (precision[n] >= 0) */
 
               ptrdiff_t prec = -1;
-              if (precision_given && precision <= TYPE_MAXIMUM (ptrdiff_t))
+              if (precision_given)
                 prec = precision;
 
               /* lisp_string_width ignores a precision of 0, but GNU
@@ -4175,11 +4426,11 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
               else
                 {
                   ptrdiff_t nch, nby;
-                  width = lisp_string_width (args[n], prec, &nch, &nby);
+                  width = lisp_string_width (arg, prec, &nch, &nby);
                   if (prec < 0)
                     {
-                      nchars_string = SCHARS (args[n]);
-                      nbytes = SBYTES (args[n]);
+                      nchars_string = SCHARS (arg);
+                      nbytes = SBYTES (arg);
                     }
                   else
                     {
@@ -4189,8 +4440,8 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                 }
 
               convbytes = nbytes;
-              if (convbytes && multibyte && ! STRING_MULTIBYTE (args[n]))
-                convbytes = count_size_as_multibyte (SDATA (args[n]), nbytes);
+              if (convbytes && multibyte && ! STRING_MULTIBYTE (arg))
+                convbytes = count_size_as_multibyte (SDATA (arg), nbytes);
 
               ptrdiff_t padding
                 = width < field_width ? field_width - width : 0;
@@ -4206,18 +4457,18 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                       p += padding;
                       nchars += padding;
                     }
-                  info[n].start = nchars;
+                  spec->start = nchars;
 
                   if (p > buf
                       && multibyte
                       && !ASCII_CHAR_P (*((unsigned char *) p - 1))
-                      && STRING_MULTIBYTE (args[n])
-                      && !CHAR_HEAD_P (SREF (args[n], 0)))
+                      && STRING_MULTIBYTE (arg)
+                      && !CHAR_HEAD_P (SREF (arg, 0)))
                     maybe_combine_byte = true;
 
-                  p += copy_text (SDATA (args[n]), (unsigned char *) p,
+                  p += copy_text (SDATA (arg), (unsigned char *) p,
                                   nbytes,
-                                  STRING_MULTIBYTE (args[n]), multibyte);
+                                  STRING_MULTIBYTE (arg), multibyte);
 
                   nchars += nchars_string;
 
@@ -4227,12 +4478,12 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                       p += padding;
                       nchars += padding;
                     }
-                  info[n].end = nchars;
+                  spec->end = nchars;
 
                   /* If this argument has text properties, record where
                      in the result string it appears.  */
-                  if (string_intervals (args[n]))
-                    info[n].intervals = arg_intervals = true;
+                  if (string_intervals (arg))
+                    spec->intervals = arg_intervals = true;
 
                   continue;
                 }
@@ -4243,8 +4494,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                       || conversion == 'X'))
             error ("Invalid format operation %%%c",
                    STRING_CHAR ((unsigned char *) format - 1));
-          else if (! (INTEGERP (args[n])
-                      || (FLOATP (args[n]) && conversion != 'c')))
+          else if (! (INTEGERP (arg) || (FLOATP (arg) && conversion != 'c')))
             error ("Format specifier doesn't match argument type");
           else
             {
@@ -4306,14 +4556,14 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                     if (INT_AS_LDBL)
                       {
                         *f = 'L';
-                        f += INTEGERP (args[n]);
+                        f += INTEGERP (arg);
                       }
                   }
                 else if (conversion != 'c')
                   {
                     memcpy (f, pMd, pMlen);
                     f += pMlen;
-                    zero_flag &= ~ precision_given;
+                    zero_flag &= ! precision_given;
                   }
                 *f++ = conversion;
                 *f = '\0';
@@ -4338,22 +4588,22 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
               ptrdiff_t sprintf_bytes;
               if (float_conversion)
                 {
-                  if (INT_AS_LDBL && INTEGERP (args[n]))
+                  if (INT_AS_LDBL && INTEGERP (arg))
                     {
                       /* Although long double may have a rounding error if
                          DIG_BITS_LBOUND * LDBL_MANT_DIG < FIXNUM_BITS - 1,
                          it is more accurate than plain 'double'.  */
-                      long double x = XINT (args[n]);
+                      long double x = XINT (arg);
                       sprintf_bytes = sprintf (sprintf_buf, convspec, prec, x);
                     }
                   else
                     sprintf_bytes = sprintf (sprintf_buf, convspec, prec,
-                                             XFLOATINT (args[n]));
+                                             XFLOATINT (arg));
                 }
               else if (conversion == 'c')
                 {
                   /* Don't use sprintf here, as it might mishandle prec.  */
-                  sprintf_buf[0] = XINT (args[n]);
+                  sprintf_buf[0] = XINT (arg);
                   sprintf_bytes = prec != 0;
                 }
               else if (conversion == 'd' || conversion == 'i')
@@ -4362,11 +4612,11 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                      instead so it also works for values outside
                      the integer range.  */
                   printmax_t x;
-                  if (INTEGERP (args[n]))
-                    x = XINT (args[n]);
+                  if (INTEGERP (arg))
+                    x = XINT (arg);
                   else
                     {
-                      double d = XFLOAT_DATA (args[n]);
+                      double d = XFLOAT_DATA (arg);
                       if (d < 0)
                         {
                           x = TYPE_MINIMUM (printmax_t);
@@ -4386,11 +4636,11 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                 {
                   /* Don't sign-extend for octal or hex printing.  */
                   uprintmax_t x;
-                  if (INTEGERP (args[n]))
-                    x = XUINT (args[n]);
+                  if (INTEGERP (arg))
+                    x = XUINT (arg);
                   else
                     {
-                      double d = XFLOAT_DATA (args[n]);
+                      double d = XFLOAT_DATA (arg);
                       if (d < 0)
                         x = 0;
                       else
@@ -4407,8 +4657,9 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                  padding and excess precision.  Deal with excess precision
                  first.  This happens only when the format specifies
                  ridiculously large precision.  */
-              uintmax_t excess_precision = precision - prec;
-              uintmax_t leading_zeros = 0, trailing_zeros = 0;
+              ptrdiff_t excess_precision
+                = precision_given ? precision - prec : 0;
+              ptrdiff_t leading_zeros = 0, trailing_zeros = 0;
               if (excess_precision)
                 {
                   if (float_conversion)
@@ -4434,7 +4685,9 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
 
               /* Compute the total bytes needed for this item, including
                  excess precision and padding.  */
-              uintmax_t numwidth = sprintf_bytes + excess_precision;
+              ptrdiff_t numwidth;
+              if (INT_ADD_WRAPV (sprintf_bytes, excess_precision, &numwidth))
+                numwidth = PTRDIFF_MAX;
               ptrdiff_t padding
                 = numwidth < field_width ? field_width - numwidth : 0;
               if (max_bufsize - sprintf_bytes <= excess_precision
@@ -4468,7 +4721,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                         exponent_bytes = src + sprintf_bytes - e;
                     }
 
-                  info[n].start = nchars;
+                  spec->start = nchars;
                   if (! minus_flag)
                     {
                       memset (p, ' ', padding);
@@ -4499,7 +4752,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                       p += padding;
                       nchars += padding;
                     }
-                  info[n].end = nchars;
+                  spec->end = nchars;
 
                   continue;
                 }
@@ -4585,6 +4838,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
       p = buf + used;
       format = format0;
       n = n0;
+      ispec = ispec0;
     }
 
   if (bufsize < p - buf)
@@ -4607,7 +4861,7 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
       if (CONSP (props))
         {
           ptrdiff_t bytepos = 0, position = 0, translated = 0;
-          ptrdiff_t argn = 1;
+          ptrdiff_t fieldn = 0;
 
           /* Adjust the bounds of each text property
              to the proper start and end in the output string.  */
@@ -4637,10 +4891,10 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                   else if (discarded[bytepos] == 1)
                     {
                       position++;
-                      if (translated == info[argn].start)
+                      if (translated == info[fieldn].start)
                         {
-                          translated += info[argn].end - info[argn].start;
-                          argn++;
+                          translated += info[fieldn].end - info[fieldn].start;
+                          fieldn++;
                         }
                     }
                 }
@@ -4657,10 +4911,10 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
                   else if (discarded[bytepos] == 1)
                     {
                       position++;
-                      if (translated == info[argn].start)
+                      if (translated == info[fieldn].start)
                         {
-                          translated += info[argn].end - info[argn].start;
-                          argn++;
+                          translated += info[fieldn].end - info[fieldn].start;
+                          fieldn++;
                         }
                     }
                 }
@@ -4673,12 +4927,13 @@ styled_format (ptrdiff_t nargs, Lisp_Object *args, bool message)
 
       /* Add text properties from arguments.  */
       if (arg_intervals)
-        for (ptrdiff_t i = 1; i < nargs; i++)
+        for (ptrdiff_t i = 0; i < nspec; i++)
           if (info[i].intervals)
             {
-              len = make_number (SCHARS (args[i]));
+              len = make_number (SCHARS (info[i].argument));
               Lisp_Object new_len = make_number (info[i].end - info[i].start);
-              props = text_property_list (args[i], make_number (0), len, Qnil);
+              props = text_property_list (info[i].argument,
+                                          make_number (0), len, Qnil);
               props = extend_property_ranges (props, len, new_len);
               /* If successive arguments have properties, be sure that
                  the value of `composition' property be the copy.  */
@@ -5262,6 +5517,7 @@ functions if all the text being accessed has this property.  */);
 
   defsubr (&Sinsert_buffer_substring);
   defsubr (&Scompare_buffer_substrings);
+  defsubr (&Sreplace_buffer_contents);
   defsubr (&Ssubst_char_in_region);
   defsubr (&Stranslate_region_internal);
   defsubr (&Sdelete_region);
diff --git a/src/emacs-module.c b/src/emacs-module.c
index 1b445dcc3b2..7b1a402eeff 100644
--- a/src/emacs-module.c
+++ b/src/emacs-module.c
@@ -21,6 +21,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "emacs-module.h"
 
+#include <stdarg.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -28,20 +29,27 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "dynlib.h"
 #include "coding.h"
+#include "keyboard.h"
 #include "syssignal.h"
+#include "thread.h"
 
 #include <intprops.h>
 #include <verify.h>
 
+/* We use different strategies for allocating the user-visible objects
+   (struct emacs_runtime, emacs_env, emacs_value), depending on
+   whether the user supplied the -module-assertions flag.  If
+   assertions are disabled, all objects are allocated from the stack.
+   If assertions are enabled, all objects are allocated from the free
+   store, and objects are never freed; this guarantees that they all
+   have different addresses.  We use that for checking which objects
+   are live.  Without unique addresses, we might consider some dead
+   objects live because their addresses would have been reused in the
+   meantime.  */
+
 
 /* Feature tests.  */
 
-#if __has_attribute (cleanup)
-enum { module_has_cleanup = true };
-#else
-enum { module_has_cleanup = false };
-#endif
-
 #ifdef WINDOWSNT
 #include <windows.h>
 #include "w32term.h"
@@ -62,10 +70,6 @@ enum
 /* Function prototype for the module init function.  */
 typedef int (*emacs_init_function) (struct emacs_runtime *);
 
-/* Function prototype for the module Lisp functions.  */
-typedef emacs_value (*emacs_subr) (emacs_env *, ptrdiff_t,
-                                   emacs_value [], void *);
-
 /* Function prototype for module user-pointer finalizers.  These
    should not throw C++ exceptions, so emacs-module.h declares the
    corresponding interfaces with EMACS_NOEXCEPT.  There is only C code
@@ -86,35 +90,44 @@ struct emacs_env_private
      storage is always available for them, even in an out-of-memory
      situation.  */
   Lisp_Object non_local_exit_symbol, non_local_exit_data;
+
+  /* List of values allocated from this environment.  The code uses
+     this only if the user gave the -module-assertions command-line
+     option.  */
+  Lisp_Object values;
 };
 
 /* The private parts of an `emacs_runtime' object contain the initial
    environment.  */
 struct emacs_runtime_private
 {
-  /* FIXME: Ideally, we would just define "struct emacs_runtime_private"
-     as a synonym of "emacs_env", but I don't know how to do that in C.  */
-  emacs_env pub;
+  emacs_env *env;
 };
 
 
 /* Forward declarations.  */
 
-struct module_fun_env;
-
-static Lisp_Object module_format_fun_env (const struct module_fun_env *);
 static Lisp_Object value_to_lisp (emacs_value);
-static emacs_value lisp_to_value (Lisp_Object);
+static emacs_value lisp_to_value (emacs_env *, Lisp_Object);
 static enum emacs_funcall_exit module_non_local_exit_check (emacs_env *);
-static void check_main_thread (void);
-static void finalize_environment (struct emacs_env_private *);
-static void initialize_environment (emacs_env *, struct emacs_env_private *priv);
+static void module_assert_thread (void);
+static void module_assert_runtime (struct emacs_runtime *);
+static void module_assert_env (emacs_env *);
+static _Noreturn void module_abort (const char *format, ...)
+  ATTRIBUTE_FORMAT_PRINTF(1, 2);
+static emacs_env *initialize_environment (emacs_env *,
+                                          struct emacs_env_private *);
+static void finalize_environment (emacs_env *);
+static void finalize_environment_unwind (void *);
+static void finalize_runtime_unwind (void *);
 static void module_handle_signal (emacs_env *, Lisp_Object);
 static void module_handle_throw (emacs_env *, Lisp_Object);
-static void module_non_local_exit_signal_1 (emacs_env *, Lisp_Object, Lisp_Object);
-static void module_non_local_exit_throw_1 (emacs_env *, Lisp_Object, Lisp_Object);
+static void module_non_local_exit_signal_1 (emacs_env *,
+                                            Lisp_Object, Lisp_Object);
+static void module_non_local_exit_throw_1 (emacs_env *,
+                                           Lisp_Object, Lisp_Object);
 static void module_out_of_memory (emacs_env *);
-static void module_reset_handlerlist (const int *);
+static void module_reset_handlerlist (struct handler **);
 
 /* We used to return NULL when emacs_value was a different type from
    Lisp_Object, but nowadays we just use Qnil instead.  Although they
@@ -122,6 +135,10 @@ static void module_reset_handlerlist (const int *);
    code should not assume this.  */
 verify (NIL_IS_ZERO);
 static emacs_value const module_nil = 0;
+
+static bool module_assertions = false;
+static emacs_env *global_env;
+static struct emacs_env_private global_env_private;
 
 /* Convenience macros for non-local exit handling.  */
 
@@ -153,6 +170,10 @@ static emacs_value const module_nil = 0;
                    internal_handler_##handlertype,                             \
                    internal_cleanup_##handlertype)
 
+#if !__has_attribute (cleanup)
+ #error "__attribute__ ((cleanup)) not supported by this compiler; try GCC"
+#endif
+
 /* It is very important that pushing the handler doesn't itself raise
    a signal.  Install the cleanup only after the handler has been
    pushed.  Use __attribute__ ((cleanup)) to avoid
@@ -165,17 +186,17 @@ static emacs_value const module_nil = 0;
 
 /* TODO: Make backtraces work if this macros is used.  */
 
-#define MODULE_SETJMP_1(handlertype, handlerfunc, retval, c, dummy)     \
+#define MODULE_SETJMP_1(handlertype, handlerfunc, retval, c0, c)        \
   if (module_non_local_exit_check (env) != emacs_funcall_exit_return)   \
     return retval;                                                      \
-  struct handler *c = push_handler_nosignal (Qt, handlertype);          \
-  if (!c)                                                               \
+  struct handler *c0 = push_handler_nosignal (Qt, handlertype);         \
+  if (!c0)                                                              \
     {                                                                   \
       module_out_of_memory (env);                                       \
       return retval;                                                    \
     }                                                                   \
-  verify (module_has_cleanup);                                          \
-  int dummy __attribute__ ((cleanup (module_reset_handlerlist)));       \
+  struct handler *c __attribute__ ((cleanup (module_reset_handlerlist))) \
+    = c0;                                                               \
   if (sys_setjmp (c->jmp))                                              \
     {                                                                   \
       (handlerfunc) (env, c->val);                                      \
@@ -184,29 +205,13 @@ static emacs_value const module_nil = 0;
   do { } while (false)
 
 
-/* Function environments.  */
-
-/* A function environment is an auxiliary structure used by
-   `module_make_function' to store information about a module
-   function.  It is stored in a save pointer and retrieved by
-   `internal--module-call'.  Its members correspond to the arguments
-   given to `module_make_function'.  */
-
-struct module_fun_env
-{
-  ptrdiff_t min_arity, max_arity;
-  emacs_subr subr;
-  void *data;
-};
-
-
 /* Implementation of runtime and environment functions.
 
    These should abide by the following rules:
 
    1. The first argument should always be a pointer to emacs_env.
 
-   2. Each function should first call check_main_thread.  Note that
+   2. Each function should first call check_thread.  Note that
       this function is a no-op unless Emacs was built with
       --enable-checking.
 
@@ -233,14 +238,25 @@ struct module_fun_env
       instead of reporting the error back to Lisp, and also because
       'eassert' is compiled to nothing in the release version.  */
 
+/* Use MODULE_FUNCTION_BEGIN_NO_CATCH to implement steps 2 and 3 for
+   environment functions that are known to never exit non-locally.  On
+   error it will return its argument, which can be a sentinel
+   value.  */
+
+#define MODULE_FUNCTION_BEGIN_NO_CATCH(error_retval)                    \
+  do {                                                                  \
+    module_assert_thread ();                                            \
+    module_assert_env (env);                                            \
+    if (module_non_local_exit_check (env) != emacs_funcall_exit_return) \
+      return error_retval;                                              \
+  } while (false)
+
 /* Use MODULE_FUNCTION_BEGIN to implement steps 2 through 4 for most
    environment functions.  On error it will return its argument, which
-   should be a sentinel value.  */
+   can be a sentinel value.  */
 
-#define MODULE_FUNCTION_BEGIN(error_retval)                             \
-  check_main_thread ();                                                 \
-  if (module_non_local_exit_check (env) != emacs_funcall_exit_return)   \
-    return error_retval;                                                \
+#define MODULE_FUNCTION_BEGIN(error_retval)      \
+  MODULE_FUNCTION_BEGIN_NO_CATCH (error_retval); \
   MODULE_HANDLE_NONLOCAL_EXIT (error_retval)
 
 static void
@@ -256,8 +272,9 @@ CHECK_USER_PTR (Lisp_Object obj)
 static emacs_env *
 module_get_environment (struct emacs_runtime *ert)
 {
-  check_main_thread ();
-  return &ert->private_members->pub;
+  module_assert_thread ();
+  module_assert_runtime (ert);
+  return ert->private_members->env;
 }
 
 /* To make global refs (GC-protected global values) keep a hash that
@@ -286,7 +303,7 @@ module_make_global_ref (emacs_env *env, emacs_value ref)
       hash_put (h, new_obj, make_natnum (1), hashcode);
     }
 
-  return lisp_to_value (new_obj);
+  return lisp_to_value (module_assertions ? global_env : env, new_obj);
 }
 
 static void
@@ -313,32 +330,59 @@ module_free_global_ref (emacs_env *env, emacs_value ref)
       else
         hash_remove_from_table (h, value);
     }
+
+  if (module_assertions)
+    {
+      Lisp_Object globals = global_env_private.values;
+      Lisp_Object prev = Qnil;
+      ptrdiff_t count = 0;
+      for (Lisp_Object tail = global_env_private.values; CONSP (tail);
+           tail = XCDR (tail))
+        {
+          emacs_value global = XSAVE_POINTER (XCAR (globals), 0);
+          if (global == ref)
+            {
+              if (NILP (prev))
+                global_env_private.values = XCDR (globals);
+              else
+                XSETCDR (prev, XCDR (globals));
+              return;
+            }
+          ++count;
+          prev = globals;
+        }
+      module_abort ("Global value was not found in list of %"pD"d globals",
+                    count);
+    }
 }
 
 static enum emacs_funcall_exit
 module_non_local_exit_check (emacs_env *env)
 {
-  check_main_thread ();
+  module_assert_thread ();
+  module_assert_env (env);
   return env->private_members->pending_non_local_exit;
 }
 
 static void
 module_non_local_exit_clear (emacs_env *env)
 {
-  check_main_thread ();
+  module_assert_thread ();
+  module_assert_env (env);
   env->private_members->pending_non_local_exit = emacs_funcall_exit_return;
 }
 
 static enum emacs_funcall_exit
 module_non_local_exit_get (emacs_env *env, emacs_value *sym, emacs_value *data)
 {
-  check_main_thread ();
+  module_assert_thread ();
+  module_assert_env (env);
   struct emacs_env_private *p = env->private_members;
   if (p->pending_non_local_exit != emacs_funcall_exit_return)
     {
       /* FIXME: lisp_to_value can exit non-locally.  */
-      *sym = lisp_to_value (p->non_local_exit_symbol);
-      *data = lisp_to_value (p->non_local_exit_data);
+      *sym = lisp_to_value (env, p->non_local_exit_symbol);
+      *data = lisp_to_value (env, p->non_local_exit_data);
     }
   return p->pending_non_local_exit;
 }
@@ -347,7 +391,8 @@ module_non_local_exit_get (emacs_env *env, emacs_value *sym, emacs_value *data)
 static void
 module_non_local_exit_signal (emacs_env *env, emacs_value sym, emacs_value data)
 {
-  check_main_thread ();
+  module_assert_thread ();
+  module_assert_env (env);
   if (module_non_local_exit_check (env) == emacs_funcall_exit_return)
     module_non_local_exit_signal_1 (env, value_to_lisp (sym),
                                     value_to_lisp (data));
@@ -356,18 +401,25 @@ module_non_local_exit_signal (emacs_env *env, emacs_value sym, emacs_value data)
 static void
 module_non_local_exit_throw (emacs_env *env, emacs_value tag, emacs_value value)
 {
-  check_main_thread ();
+  module_assert_thread ();
+  module_assert_env (env);
   if (module_non_local_exit_check (env) == emacs_funcall_exit_return)
     module_non_local_exit_throw_1 (env, value_to_lisp (tag),
                                    value_to_lisp (value));
 }
 
-/* A module function is lambda function that calls
-   `internal--module-call', passing the function pointer of the module
-   function along with the module emacs_env pointer as arguments.
+static struct Lisp_Module_Function *
+allocate_module_function (void)
+{
+  return ALLOCATE_PSEUDOVECTOR (struct Lisp_Module_Function,
+                                min_arity, PVEC_MODULE_FUNCTION);
+}
 
-        (function (lambda (&rest arglist)
-                    (internal--module-call envobj arglist)))  */
+#define XSET_MODULE_FUNCTION(var, ptr) \
+  XSETPSEUDOVECTOR (var, ptr, PVEC_MODULE_FUNCTION)
+
+/* A module function is a pseudovector of subtype
+   PVEC_MODULE_FUNCTION; see lisp.h for the definition.  */
 
 static emacs_value
 module_make_function (emacs_env *env, ptrdiff_t min_arity, ptrdiff_t max_arity,
@@ -378,35 +430,29 @@ module_make_function (emacs_env *env, ptrdiff_t min_arity, ptrdiff_t max_arity,
 
   if (! (0 <= min_arity
          && (max_arity < 0
-             ? max_arity == emacs_variadic_function
-             : min_arity <= max_arity)))
+             ? (min_arity <= MOST_POSITIVE_FIXNUM
+                && max_arity == emacs_variadic_function)
+             : min_arity <= max_arity && max_arity <= MOST_POSITIVE_FIXNUM)))
     xsignal2 (Qinvalid_arity, make_number (min_arity), make_number (max_arity));
 
-  /* FIXME: This should be freed when envobj is GC'd.  */
-  struct module_fun_env *envptr = xmalloc (sizeof *envptr);
-  envptr->min_arity = min_arity;
-  envptr->max_arity = max_arity;
-  envptr->subr = subr;
-  envptr->data = data;
+  struct Lisp_Module_Function *function = allocate_module_function ();
+  function->min_arity = min_arity;
+  function->max_arity = max_arity;
+  function->subr = subr;
+  function->data = data;
 
-  Lisp_Object envobj = make_save_ptr (envptr);
-  Lisp_Object doc = Qnil;
   if (documentation)
     {
       AUTO_STRING (unibyte_doc, documentation);
-      doc = code_convert_string_norecord (unibyte_doc, Qutf_8, false);
+      function->documentation =
+        code_convert_string_norecord (unibyte_doc, Qutf_8, false);
     }
 
-  /* FIXME: Use a bytecompiled object, or even better a subr.  */
-  Lisp_Object ret = list4 (Qlambda,
-                           list2 (Qand_rest, Qargs),
-                           doc,
-                           list4 (Qapply,
-                                  list2 (Qfunction, Qinternal__module_call),
-                                  envobj,
-                                  Qargs));
+  Lisp_Object result;
+  XSET_MODULE_FUNCTION (result, function);
+  eassert (MODULE_FUNCTIONP (result));
 
-  return lisp_to_value (ret);
+  return lisp_to_value (env, result);
 }
 
 static emacs_value
@@ -426,7 +472,7 @@ module_funcall (emacs_env *env, emacs_value fun, ptrdiff_t nargs,
   newargs[0] = value_to_lisp (fun);
   for (ptrdiff_t i = 0; i < nargs; i++)
     newargs[1 + i] = value_to_lisp (args[i]);
-  emacs_value result = lisp_to_value (Ffuncall (nargs1, newargs));
+  emacs_value result = lisp_to_value (env, Ffuncall (nargs1, newargs));
   SAFE_FREE ();
   return result;
 }
@@ -435,31 +481,27 @@ static emacs_value
 module_intern (emacs_env *env, const char *name)
 {
   MODULE_FUNCTION_BEGIN (module_nil);
-  return lisp_to_value (intern (name));
+  return lisp_to_value (env, intern (name));
 }
 
 static emacs_value
 module_type_of (emacs_env *env, emacs_value value)
 {
   MODULE_FUNCTION_BEGIN (module_nil);
-  return lisp_to_value (Ftype_of (value_to_lisp (value)));
+  return lisp_to_value (env, Ftype_of (value_to_lisp (value)));
 }
 
 static bool
 module_is_not_nil (emacs_env *env, emacs_value value)
 {
-  check_main_thread ();
-  if (module_non_local_exit_check (env) != emacs_funcall_exit_return)
-    return false;
+  MODULE_FUNCTION_BEGIN_NO_CATCH (false);
   return ! NILP (value_to_lisp (value));
 }
 
 static bool
 module_eq (emacs_env *env, emacs_value a, emacs_value b)
 {
-  check_main_thread ();
-  if (module_non_local_exit_check (env) != emacs_funcall_exit_return)
-    return false;
+  MODULE_FUNCTION_BEGIN_NO_CATCH (false);
   return EQ (value_to_lisp (a), value_to_lisp (b));
 }
 
@@ -478,7 +520,7 @@ module_make_integer (emacs_env *env, intmax_t n)
   MODULE_FUNCTION_BEGIN (module_nil);
   if (FIXNUM_OVERFLOW_P (n))
     xsignal0 (Qoverflow_error);
-  return lisp_to_value (make_number (n));
+  return lisp_to_value (env, make_number (n));
 }
 
 static double
@@ -494,7 +536,7 @@ static emacs_value
 module_make_float (emacs_env *env, double d)
 {
   MODULE_FUNCTION_BEGIN (module_nil);
-  return lisp_to_value (make_float (d));
+  return lisp_to_value (env, make_float (d));
 }
 
 static bool
@@ -509,16 +551,12 @@ module_copy_string_contents (emacs_env *env, emacs_value value, char *buffer,
   ptrdiff_t raw_size = SBYTES (lisp_str_utf8);
   ptrdiff_t required_buf_size = raw_size + 1;
 
-  eassert (length != NULL);
-
   if (buffer == NULL)
     {
       *length = required_buf_size;
       return true;
     }
 
-  eassert (*length >= 0);
-
   if (*length < required_buf_size)
     {
       *length = required_buf_size;
@@ -535,15 +573,20 @@ static emacs_value
 module_make_string (emacs_env *env, const char *str, ptrdiff_t length)
 {
   MODULE_FUNCTION_BEGIN (module_nil);
+  if (! (0 <= length && length <= STRING_BYTES_BOUND))
+    xsignal0 (Qoverflow_error);
+  /* FIXME: AUTO_STRING_WITH_LEN requires STR to be null-terminated,
+     but we shouldn’t require that.  */
   AUTO_STRING_WITH_LEN (lstr, str, length);
-  return lisp_to_value (code_convert_string_norecord (lstr, Qutf_8, false));
+  return lisp_to_value (env,
+                        code_convert_string_norecord (lstr, Qutf_8, false));
 }
 
 static emacs_value
 module_make_user_ptr (emacs_env *env, emacs_finalizer_function fin, void *ptr)
 {
   MODULE_FUNCTION_BEGIN (module_nil);
-  return lisp_to_value (make_user_ptr (fin, ptr));
+  return lisp_to_value (env, make_user_ptr (fin, ptr));
 }
 
 static void *
@@ -558,7 +601,6 @@ module_get_user_ptr (emacs_env *env, emacs_value uptr)
 static void
 module_set_user_ptr (emacs_env *env, emacs_value uptr, void *ptr)
 {
-  /* FIXME: This function should return bool because it can fail.  */
   MODULE_FUNCTION_BEGIN ();
   Lisp_Object lisp = value_to_lisp (uptr);
   CHECK_USER_PTR (lisp);
@@ -578,7 +620,6 @@ static void
 module_set_user_finalizer (emacs_env *env, emacs_value uptr,
                            emacs_finalizer_function fin)
 {
-  /* FIXME: This function should return bool because it can fail.  */
   MODULE_FUNCTION_BEGIN ();
   Lisp_Object lisp = value_to_lisp (uptr);
   CHECK_USER_PTR (lisp);
@@ -597,7 +638,6 @@ check_vec_index (Lisp_Object lvec, ptrdiff_t i)
 static void
 module_vec_set (emacs_env *env, emacs_value vec, ptrdiff_t i, emacs_value val)
 {
-  /* FIXME: This function should return bool because it can fail.  */
   MODULE_FUNCTION_BEGIN ();
   Lisp_Object lvec = value_to_lisp (vec);
   check_vec_index (lvec, i);
@@ -610,22 +650,46 @@ module_vec_get (emacs_env *env, emacs_value vec, ptrdiff_t i)
   MODULE_FUNCTION_BEGIN (module_nil);
   Lisp_Object lvec = value_to_lisp (vec);
   check_vec_index (lvec, i);
-  return lisp_to_value (AREF (lvec, i));
+  return lisp_to_value (env, AREF (lvec, i));
 }
 
 static ptrdiff_t
 module_vec_size (emacs_env *env, emacs_value vec)
 {
-  /* FIXME: Return a sentinel value (e.g., -1) on error.  */
   MODULE_FUNCTION_BEGIN (0);
   Lisp_Object lvec = value_to_lisp (vec);
   CHECK_VECTOR (lvec);
   return ASIZE (lvec);
 }
 
+/* This function should return true if and only if maybe_quit would do
+   anything.  */
+static bool
+module_should_quit (emacs_env *env)
+{
+  MODULE_FUNCTION_BEGIN_NO_CATCH (false);
+  return (! NILP (Vquit_flag) && NILP (Vinhibit_quit)) || pending_signals;
+}
+
 
 /* Subroutines.  */
 
+static void
+module_signal_or_throw (struct emacs_env_private *env)
+{
+  switch (env->pending_non_local_exit)
+    {
+    case emacs_funcall_exit_return:
+      return;
+    case emacs_funcall_exit_signal:
+      xsignal (env->non_local_exit_symbol, env->non_local_exit_data);
+    case emacs_funcall_exit_throw:
+      Fthrow (env->non_local_exit_symbol, env->non_local_exit_data);
+    default:
+      eassume (false);
+    }
+}
+
 DEFUN ("module-load", Fmodule_load, Smodule_load, 1, 1, 0,
        doc: /* Load module FILE.  */)
   (Lisp_Object file)
@@ -637,122 +701,161 @@ DEFUN ("module-load", Fmodule_load, Smodule_load, 1, 1, 0,
   CHECK_STRING (file);
   handle = dynlib_open (SSDATA (file));
   if (!handle)
-    error ("Cannot load file %s: %s", SDATA (file), dynlib_error ());
+    xsignal2 (Qmodule_open_failed, file, build_string (dynlib_error ()));
 
   gpl_sym = dynlib_sym (handle, "plugin_is_GPL_compatible");
   if (!gpl_sym)
-    error ("Module %s is not GPL compatible", SDATA (file));
+    xsignal1 (Qmodule_not_gpl_compatible, file);
 
   module_init = (emacs_init_function) dynlib_func (handle, "emacs_module_init");
   if (!module_init)
-    error ("Module %s does not have an init function.", SDATA (file));
-
-  struct emacs_runtime_private rt; /* Includes the public emacs_env.  */
-  struct emacs_env_private priv;
-  initialize_environment (&rt.pub, &priv);
-  struct emacs_runtime pub =
-    {
-      .size = sizeof pub,
-      .private_members = &rt,
-      .get_environment = module_get_environment
-    };
-  int r = module_init (&pub);
-  finalize_environment (&priv);
+    xsignal1 (Qmissing_module_init_function, file);
+
+  struct emacs_runtime rt_pub;
+  struct emacs_runtime_private rt_priv;
+  emacs_env env_pub;
+  struct emacs_env_private env_priv;
+  rt_priv.env = initialize_environment (&env_pub, &env_priv);
+
+  /* If we should use module assertions, reallocate the runtime object
+     from the free store, but never free it.  That way the addresses
+     for two different runtime objects are guaranteed to be distinct,
+     which we can use for checking the liveness of runtime
+     pointers.  */
+  struct emacs_runtime *rt = module_assertions ? xmalloc (sizeof *rt) : &rt_pub;
+  rt->size = sizeof *rt;
+  rt->private_members = &rt_priv;
+  rt->get_environment = module_get_environment;
+
+  Vmodule_runtimes = Fcons (make_save_ptr (rt), Vmodule_runtimes);
+  ptrdiff_t count = SPECPDL_INDEX ();
+  record_unwind_protect_ptr (finalize_runtime_unwind, rt);
+
+  int r = module_init (rt);
+
+  /* Process the quit flag first, so that quitting doesn't get
+     overridden by other non-local exits.  */
+  maybe_quit ();
 
   if (r != 0)
     {
       if (FIXNUM_OVERFLOW_P (r))
         xsignal0 (Qoverflow_error);
-      xsignal2 (Qmodule_load_failed, file, make_number (r));
+      xsignal2 (Qmodule_init_failed, file, make_number (r));
     }
 
-  return Qt;
+  module_signal_or_throw (&env_priv);
+  return unbind_to (count, Qt);
 }
 
-DEFUN ("internal--module-call", Finternal_module_call, Sinternal_module_call, 1, MANY, 0,
-       doc: /* Internal function to call a module function.
-ENVOBJ is a save pointer to a module_fun_env structure.
-ARGLIST is a list of arguments passed to SUBRPTR.
-usage: (module-call ENVOBJ &rest ARGLIST)   */)
-  (ptrdiff_t nargs, Lisp_Object *arglist)
+Lisp_Object
+funcall_module (Lisp_Object function, ptrdiff_t nargs, Lisp_Object *arglist)
 {
-  Lisp_Object envobj = arglist[0];
-  /* FIXME: Rather than use a save_value, we should create a new object type.
-     Making save_value visible to Lisp is wrong.  */
-  CHECK_TYPE (SAVE_VALUEP (envobj), Qsave_value_p, envobj);
-  struct Lisp_Save_Value *save_value = XSAVE_VALUE (envobj);
-  CHECK_TYPE (save_type (save_value, 0) == SAVE_POINTER, Qsave_pointer_p, envobj);
-  /* FIXME: We have no reason to believe that XSAVE_POINTER (envobj, 0)
-     is a module_fun_env pointer.  If some other part of Emacs also
-     exports save_value objects to Elisp, than we may be getting here this
-     other kind of save_value which will likely hold something completely
-     different in this field.  */
-  struct module_fun_env *envptr = XSAVE_POINTER (envobj, 0);
-  EMACS_INT len = nargs - 1;
-  eassume (0 <= envptr->min_arity);
-  if (! (envptr->min_arity <= len
-         && len <= (envptr->max_arity < 0 ? PTRDIFF_MAX : envptr->max_arity)))
-    xsignal2 (Qwrong_number_of_arguments, module_format_fun_env (envptr),
-              make_number (len));
+  const struct Lisp_Module_Function *func = XMODULE_FUNCTION (function);
+  eassume (0 <= func->min_arity);
+  if (! (func->min_arity <= nargs
+         && (func->max_arity < 0 || nargs <= func->max_arity)))
+    xsignal2 (Qwrong_number_of_arguments, function, make_number (nargs));
 
   emacs_env pub;
   struct emacs_env_private priv;
-  initialize_environment (&pub, &priv);
+  emacs_env *env = initialize_environment (&pub, &priv);
+  ptrdiff_t count = SPECPDL_INDEX ();
+  record_unwind_protect_ptr (finalize_environment_unwind, env);
 
   USE_SAFE_ALLOCA;
-  emacs_value *args;
-  if (plain_values)
-    args = (emacs_value *) arglist + 1;
+  ATTRIBUTE_MAY_ALIAS emacs_value *args;
+  if (plain_values && ! module_assertions)
+    /* FIXME: The cast below is incorrect because the argument array
+       is not declared as const, so module functions can modify it.
+       Either declare it as const, or remove this branch.  */
+    args = (emacs_value *) arglist;
   else
     {
-      args = SAFE_ALLOCA (len * sizeof *args);
-      for (ptrdiff_t i = 0; i < len; i++)
-        args[i] = lisp_to_value (arglist[i + 1]);
+      args = SAFE_ALLOCA (nargs * sizeof *args);
+      for (ptrdiff_t i = 0; i < nargs; i++)
+        args[i] = lisp_to_value (env, arglist[i]);
     }
 
-  emacs_value ret = envptr->subr (&pub, len, args, envptr->data);
+  emacs_value ret = func->subr (env, nargs, args, func->data);
   SAFE_FREE ();
 
-  eassert (&priv == pub.private_members);
+  eassert (&priv == env->private_members);
 
-  switch (priv.pending_non_local_exit)
-    {
-    case emacs_funcall_exit_return:
-      finalize_environment (&priv);
-      return value_to_lisp (ret);
-    case emacs_funcall_exit_signal:
-      {
-        Lisp_Object symbol = priv.non_local_exit_symbol;
-        Lisp_Object data = priv.non_local_exit_data;
-        finalize_environment (&priv);
-        xsignal (symbol, data);
-      }
-    case emacs_funcall_exit_throw:
-      {
-        Lisp_Object tag = priv.non_local_exit_symbol;
-        Lisp_Object value = priv.non_local_exit_data;
-        finalize_environment (&priv);
-        Fthrow (tag, value);
-      }
-    default:
-      eassume (false);
-    }
+  /* Process the quit flag first, so that quitting doesn't get
+     overridden by other non-local exits.  */
+  maybe_quit ();
+
+  module_signal_or_throw (&priv);
+  return unbind_to (count, value_to_lisp (ret));
+}
+
+Lisp_Object
+module_function_arity (const struct Lisp_Module_Function *const function)
+{
+  ptrdiff_t minargs = function->min_arity;
+  ptrdiff_t maxargs = function->max_arity;
+  return Fcons (make_number (minargs),
+                maxargs == MANY ? Qmany : make_number (maxargs));
 }
 
 
 /* Helper functions.  */
 
-static void
-check_main_thread (void)
+static bool
+in_current_thread (void)
 {
+  if (current_thread == NULL)
+    return false;
 #ifdef HAVE_PTHREAD
-  eassert (pthread_equal (pthread_self (), main_thread_id));
+  return pthread_equal (pthread_self (), current_thread->thread_id);
 #elif defined WINDOWSNT
-  eassert (GetCurrentThreadId () == dwMainThreadId);
+  return GetCurrentThreadId () == current_thread->thread_id;
 #endif
 }
 
 static void
+module_assert_thread (void)
+{
+  if (! module_assertions || in_current_thread ())
+    return;
+  module_abort ("Module function called from outside the current Lisp thread");
+}
+
+static void
+module_assert_runtime (struct emacs_runtime *ert)
+{
+  if (! module_assertions)
+    return;
+  ptrdiff_t count = 0;
+  for (Lisp_Object tail = Vmodule_runtimes; CONSP (tail); tail = XCDR (tail))
+    {
+      if (XSAVE_POINTER (XCAR (tail), 0) == ert)
+        return;
+      ++count;
+    }
+  module_abort ("Runtime pointer not found in list of %"pD"d runtimes",
+                count);
+}
+
+static void
+module_assert_env (emacs_env *env)
+{
+  if (! module_assertions)
+    return;
+  ptrdiff_t count = 0;
+  for (Lisp_Object tail = Vmodule_environments; CONSP (tail);
+       tail = XCDR (tail))
+    {
+      if (XSAVE_POINTER (XCAR (tail), 0) == env)
+        return;
+      ++count;
+    }
+  module_abort ("Environment pointer not found in list of %"pD"d environments",
+                count);
+}
+
+static void
 module_non_local_exit_signal_1 (emacs_env *env, Lisp_Object sym,
                                 Lisp_Object data)
 {
@@ -791,6 +894,14 @@ module_out_of_memory (emacs_env *env)
 
 /* Value conversion.  */
 
+/* We represent Lisp objects differently depending on whether the user
+   gave -module-assertions.  If assertions are disabled, emacs_value
+   objects are Lisp_Objects cast to emacs_value.  If assertions are
+   enabled, emacs_value objects are pointers to Lisp_Object objects
+   allocated from the free store; they are never freed, which ensures
+   that their addresses are unique and can be used for liveness
+   checking.  */
+
 /* Unique Lisp_Object used to mark those emacs_values which are really
    just containers holding a Lisp_Object that does not fit as an emacs_value,
    either because it is an integer out of range, or is not properly aligned.
@@ -837,6 +948,33 @@ value_to_lisp_bits (emacs_value v)
 static Lisp_Object
 value_to_lisp (emacs_value v)
 {
+  if (module_assertions)
+    {
+      /* Check the liveness of the value by iterating over all live
+         environments.  */
+      void *vptr = v;
+      ATTRIBUTE_MAY_ALIAS Lisp_Object *optr = vptr;
+      ptrdiff_t num_environments = 0;
+      ptrdiff_t num_values = 0;
+      for (Lisp_Object environments = Vmodule_environments;
+           CONSP (environments); environments = XCDR (environments))
+        {
+          emacs_env *env = XSAVE_POINTER (XCAR (environments), 0);
+          for (Lisp_Object values = env->private_members->values;
+               CONSP (values); values = XCDR (values))
+            {
+              Lisp_Object *p = XSAVE_POINTER (XCAR (values), 0);
+              if (p == optr)
+                return *p;
+              ++num_values;
+            }
+          ++num_environments;
+        }
+      module_abort (("Emacs value not found in %"pD"d values "
+                     "of %"pD"d environments"),
+                    num_values, num_environments);
+    }
+
   Lisp_Object o = value_to_lisp_bits (v);
   if (! plain_values && CONSP (o) && EQ (XCDR (o), ltv_mark))
     o = XCAR (o);
@@ -865,8 +1003,23 @@ enum { HAVE_STRUCT_ATTRIBUTE_ALIGNED = 0 };
 /* Convert O to an emacs_value.  Allocate storage if needed; this can
    signal if memory is exhausted.  Must be an injective function.  */
 static emacs_value
-lisp_to_value (Lisp_Object o)
+lisp_to_value (emacs_env *env, Lisp_Object o)
 {
+  if (module_assertions)
+    {
+      /* Add the new value to the list of values allocated from this
+         environment.  The value is actually a pointer to the
+         Lisp_Object cast to emacs_value.  We make a copy of the
+         object on the free store to guarantee unique addresses.  */
+      ATTRIBUTE_MAY_ALIAS Lisp_Object *optr = xmalloc (sizeof o);
+      *optr = o;
+      void *vptr = optr;
+      ATTRIBUTE_MAY_ALIAS emacs_value ret = vptr;
+      struct emacs_env_private *priv = env->private_members;
+      priv->values = Fcons (make_save_ptr (ret), priv->values);
+      return ret;
+    }
+
   emacs_value v = lisp_to_value_bits (o);
 
   if (! EQ (o, value_to_lisp_bits (v)))
@@ -897,11 +1050,20 @@ lisp_to_value (Lisp_Object o)
 
 /* Environment lifetime management.  */
 
-/* Must be called before the environment can be used.  */
-static void
+/* Must be called before the environment can be used.  Returns another
+   pointer that callers should use instead of the ENV argument.  If
+   module assertions are disabled, the return value is ENV.  If module
+   assertions are enabled, the return value points to a heap-allocated
+   object.  That object is never freed to guarantee unique
+   addresses.  */
+static emacs_env *
 initialize_environment (emacs_env *env, struct emacs_env_private *priv)
 {
+  if (module_assertions)
+      env = xmalloc (sizeof *env);
+
   priv->pending_non_local_exit = emacs_funcall_exit_return;
+  priv->values = priv->non_local_exit_symbol = priv->non_local_exit_data = Qnil;
   env->size = sizeof *env;
   env->private_members = priv;
   env->make_global_ref = module_make_global_ref;
@@ -931,15 +1093,50 @@ initialize_environment (emacs_env *env, struct emacs_env_private *priv)
   env->vec_set = module_vec_set;
   env->vec_get = module_vec_get;
   env->vec_size = module_vec_size;
+  env->should_quit = module_should_quit;
   Vmodule_environments = Fcons (make_save_ptr (env), Vmodule_environments);
+  return env;
 }
 
 /* Must be called before the lifetime of the environment object
    ends.  */
 static void
-finalize_environment (struct emacs_env_private *env)
+finalize_environment (emacs_env *env)
 {
+  eassert (XSAVE_POINTER (XCAR (Vmodule_environments), 0) == env);
   Vmodule_environments = XCDR (Vmodule_environments);
+  if (module_assertions)
+    /* There is always at least the global environment.  */
+    eassert (CONSP (Vmodule_environments));
+}
+
+static void
+finalize_environment_unwind (void *env)
+{
+  finalize_environment (env);
+}
+
+static void
+finalize_runtime_unwind (void* raw_ert)
+{
+  struct emacs_runtime *ert = raw_ert;
+  eassert (XSAVE_POINTER (XCAR (Vmodule_runtimes), 0) == ert);
+  Vmodule_runtimes = XCDR (Vmodule_runtimes);
+  finalize_environment (ert->private_members->env);
+}
+
+void
+mark_modules (void)
+{
+  for (Lisp_Object tail = Vmodule_environments; CONSP (tail);
+       tail = XCDR (tail))
+    {
+      emacs_env *env = XSAVE_POINTER (XCAR (tail), 0);
+      struct emacs_env_private *priv = env->private_members;
+      mark_object (priv->non_local_exit_symbol);
+      mark_object (priv->non_local_exit_data);
+      mark_object (priv->values);
+    }
 }
 
 
@@ -948,10 +1145,12 @@ finalize_environment (struct emacs_env_private *env)
 /* Must be called after setting up a handler immediately before
    returning from the function.  See the comments in lisp.h and the
    code in eval.c for details.  The macros below arrange for this
-   function to be called automatically.  DUMMY is ignored.  */
+   function to be called automatically.  PHANDLERLIST points to a word
+   containing the handler list, for sanity checking.  */
 static void
-module_reset_handlerlist (const int *dummy)
+module_reset_handlerlist (struct handler **phandlerlist)
 {
+  eassert (handlerlist == *phandlerlist);
   handlerlist = handlerlist->next;
 }
 
@@ -972,30 +1171,33 @@ module_handle_throw (emacs_env *env, Lisp_Object tag_val)
 }
 
 
-/* Function environments.  */
+/* Support for assertions.  */
+void
+init_module_assertions (bool enable)
+{
+  module_assertions = enable;
+  if (enable)
+    {
+      /* We use a hidden environment for storing the globals.  This
+         environment is never freed.  */
+      emacs_env env;
+      global_env = initialize_environment (&env, &global_env_private);
+      eassert (global_env != &env);
+    }
+}
 
-/* Return a string object that contains a user-friendly
-   representation of the function environment.  */
-static Lisp_Object
-module_format_fun_env (const struct module_fun_env *env)
+static _Noreturn void
+ATTRIBUTE_FORMAT_PRINTF(1, 2)
+module_abort (const char *format, ...)
 {
-  /* Try to print a function name if possible.  */
-  const char *path, *sym;
-  static char const noaddr_format[] = "#<module function at %p>";
-  char buffer[sizeof noaddr_format + INT_STRLEN_BOUND (intptr_t) + 256];
-  char *buf = buffer;
-  ptrdiff_t bufsize = sizeof buffer;
-  ptrdiff_t size
-    = (dynlib_addr (env->subr, &path, &sym)
-       ? exprintf (&buf, &bufsize, buffer, -1,
-                   "#<module function %s from %s>", sym, path)
-       : sprintf (buffer, noaddr_format, env->subr));
-  AUTO_STRING_WITH_LEN (unibyte_result, buffer, size);
-  Lisp_Object result = code_convert_string_norecord (unibyte_result,
-                                                     Qutf_8, false);
-  if (buf != buffer)
-    xfree (buf);
-  return result;
+  fputs ("Emacs module assertion: ", stderr);
+  va_list args;
+  va_start (args, format);
+  vfprintf (stderr, format, args);
+  va_end (args);
+  putc ('\n', stderr);
+  fflush (NULL);
+  emacs_abort ();
 }
 
 
@@ -1018,6 +1220,14 @@ syms_of_module (void)
                        Qnil, false);
   Funintern (Qmodule_refs_hash, Qnil);
 
+  DEFSYM (Qmodule_runtimes, "module-runtimes");
+  DEFVAR_LISP ("module-runtimes", Vmodule_runtimes,
+               doc: /* List of active module runtimes.  */);
+  Vmodule_runtimes = Qnil;
+  /* Unintern `module-runtimes' because it is only used
+     internally.  */
+  Funintern (Qmodule_runtimes, Qnil);
+
   DEFSYM (Qmodule_environments, "module-environments");
   DEFVAR_LISP ("module-environments", Vmodule_environments,
                doc: /* List of active module environments.  */);
@@ -1032,11 +1242,34 @@ syms_of_module (void)
   Fput (Qmodule_load_failed, Qerror_message,
         build_pure_c_string ("Module load failed"));
 
-  DEFSYM (Qinvalid_module_call, "invalid-module-call");
-  Fput (Qinvalid_module_call, Qerror_conditions,
-        listn (CONSTYPE_PURE, 2, Qinvalid_module_call, Qerror));
-  Fput (Qinvalid_module_call, Qerror_message,
-        build_pure_c_string ("Invalid module call"));
+  DEFSYM (Qmodule_open_failed, "module-open-failed");
+  Fput (Qmodule_open_failed, Qerror_conditions,
+        listn (CONSTYPE_PURE, 3,
+               Qmodule_open_failed, Qmodule_load_failed, Qerror));
+  Fput (Qmodule_open_failed, Qerror_message,
+        build_pure_c_string ("Module could not be opened"));
+
+  DEFSYM (Qmodule_not_gpl_compatible, "module-not-gpl-compatible");
+  Fput (Qmodule_not_gpl_compatible, Qerror_conditions,
+        listn (CONSTYPE_PURE, 3,
+               Qmodule_not_gpl_compatible, Qmodule_load_failed, Qerror));
+  Fput (Qmodule_not_gpl_compatible, Qerror_message,
+        build_pure_c_string ("Module is not GPL compatible"));
+
+  DEFSYM (Qmissing_module_init_function, "missing-module-init-function");
+  Fput (Qmissing_module_init_function, Qerror_conditions,
+        listn (CONSTYPE_PURE, 3,
+               Qmissing_module_init_function, Qmodule_load_failed, Qerror));
+  Fput (Qmissing_module_init_function, Qerror_message,
+        build_pure_c_string ("Module does not export an "
+                             "initialization function"));
+
+  DEFSYM (Qmodule_init_failed, "module-init-failed");
+  Fput (Qmodule_init_failed, Qerror_conditions,
+        listn (CONSTYPE_PURE, 3,
+               Qmodule_init_failed, Qmodule_load_failed, Qerror));
+  Fput (Qmodule_init_failed, Qerror_message,
+        build_pure_c_string ("Module initialization failed"));
 
   DEFSYM (Qinvalid_arity, "invalid-arity");
   Fput (Qinvalid_arity, Qerror_conditions,
@@ -1048,11 +1281,7 @@ syms_of_module (void)
      code or modules should not access it.  */
   Funintern (Qmodule_refs_hash, Qnil);
 
-  DEFSYM (Qsave_value_p, "save-value-p");
-  DEFSYM (Qsave_pointer_p, "save-pointer-p");
+  DEFSYM (Qmodule_function_p, "module-function-p");
 
   defsubr (&Smodule_load);
-
-  DEFSYM (Qinternal__module_call, "internal--module-call");
-  defsubr (&Sinternal_module_call);
 }
diff --git a/src/emacs-module.h b/src/emacs-module.h
deleted file mode 100644
index d9eeeabec3f..00000000000
--- a/src/emacs-module.h
+++ /dev/null
@@ -1,197 +0,0 @@
-/* emacs-module.h - GNU Emacs module API.
-
-Copyright (C) 2015-2017 Free Software Foundation, Inc.
-
-This file is part of GNU Emacs.
-
-GNU Emacs is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or (at
-your option) any later version.
-
-GNU Emacs is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
-
-#ifndef EMACS_MODULE_H
-#define EMACS_MODULE_H
-
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-
-#if defined __cplusplus && __cplusplus >= 201103L
-# define EMACS_NOEXCEPT noexcept
-#else
-# define EMACS_NOEXCEPT
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Current environment.  */
-typedef struct emacs_env_25 emacs_env;
-
-/* Opaque pointer representing an Emacs Lisp value.
-   BEWARE: Do not assume NULL is a valid value!  */
-typedef struct emacs_value_tag *emacs_value;
-
-enum { emacs_variadic_function = -2 };
-
-/* Struct passed to a module init function (emacs_module_init).  */
-struct emacs_runtime
-{
-  /* Structure size (for version checking).  */
-  ptrdiff_t size;
-
-  /* Private data; users should not touch this.  */
-  struct emacs_runtime_private *private_members;
-
-  /* Return an environment pointer.  */
-  emacs_env *(*get_environment) (struct emacs_runtime *ert);
-};
-
-
-/* Possible Emacs function call outcomes.  */
-enum emacs_funcall_exit
-{
-  /* Function has returned normally.  */
-  emacs_funcall_exit_return = 0,
-
-  /* Function has signaled an error using `signal'.  */
-  emacs_funcall_exit_signal = 1,
-
-  /* Function has exit using `throw'.  */
-  emacs_funcall_exit_throw = 2,
-};
-
-struct emacs_env_25
-{
-  /* Structure size (for version checking).  */
-  ptrdiff_t size;
-
-  /* Private data; users should not touch this.  */
-  struct emacs_env_private *private_members;
-
-  /* Memory management.  */
-
-  emacs_value (*make_global_ref) (emacs_env *env,
-                                  emacs_value any_reference);
-
-  void (*free_global_ref) (emacs_env *env,
-                           emacs_value global_reference);
-
-  /* Non-local exit handling.  */
-
-  enum emacs_funcall_exit (*non_local_exit_check) (emacs_env *env);
-
-  void (*non_local_exit_clear) (emacs_env *env);
-
-  enum emacs_funcall_exit (*non_local_exit_get)
-    (emacs_env *env,
-     emacs_value *non_local_exit_symbol_out,
-     emacs_value *non_local_exit_data_out);
-
-  void (*non_local_exit_signal) (emacs_env *env,
-                                 emacs_value non_local_exit_symbol,
-                                 emacs_value non_local_exit_data);
-
-  void (*non_local_exit_throw) (emacs_env *env,
-                                emacs_value tag,
-                                emacs_value value);
-
-  /* Function registration.  */
-
-  emacs_value (*make_function) (emacs_env *env,
-                                ptrdiff_t min_arity,
-                                ptrdiff_t max_arity,
-                                emacs_value (*function) (emacs_env *env,
-                                                         ptrdiff_t nargs,
-                                                         emacs_value args[],
-                                                         void *)
-                                  EMACS_NOEXCEPT,
-                                const char *documentation,
-                                void *data);
-
-  emacs_value (*funcall) (emacs_env *env,
-                          emacs_value function,
-                          ptrdiff_t nargs,
-                          emacs_value args[]);
-
-  emacs_value (*intern) (emacs_env *env,
-                         const char *symbol_name);
-
-  /* Type conversion.  */
-
-  emacs_value (*type_of) (emacs_env *env,
-                          emacs_value value);
-
-  bool (*is_not_nil) (emacs_env *env, emacs_value value);
-
-  bool (*eq) (emacs_env *env, emacs_value a, emacs_value b);
-
-  intmax_t (*extract_integer) (emacs_env *env, emacs_value value);
-
-  emacs_value (*make_integer) (emacs_env *env, intmax_t value);
-
-  double (*extract_float) (emacs_env *env, emacs_value value);
-
-  emacs_value (*make_float) (emacs_env *env, double value);
-
-  /* Copy the content of the Lisp string VALUE to BUFFER as an utf8
-     null-terminated string.
-
-     SIZE must point to the total size of the buffer.  If BUFFER is
-     NULL or if SIZE is not big enough, write the required buffer size
-     to SIZE and return false.
-
-     Note that SIZE must include the last null byte (e.g. "abc" needs
-     a buffer of size 4).
-
-     Return true if the string was successfully copied.  */
-
-  bool (*copy_string_contents) (emacs_env *env,
-                                emacs_value value,
-                                char *buffer,
-                                ptrdiff_t *size_inout);
-
-  /* Create a Lisp string from a utf8 encoded string.  */
-  emacs_value (*make_string) (emacs_env *env,
-                              const char *contents, ptrdiff_t length);
-
-  /* Embedded pointer type.  */
-  emacs_value (*make_user_ptr) (emacs_env *env,
-                                void (*fin) (void *) EMACS_NOEXCEPT,
-                                void *ptr);
-
-  void *(*get_user_ptr) (emacs_env *env, emacs_value uptr);
-  void (*set_user_ptr) (emacs_env *env, emacs_value uptr, void *ptr);
-
-  void (*(*get_user_finalizer) (emacs_env *env, emacs_value uptr))
-    (void *) EMACS_NOEXCEPT;
-  void (*set_user_finalizer) (emacs_env *env,
-                              emacs_value uptr,
-                              void (*fin) (void *) EMACS_NOEXCEPT);
-
-  /* Vector functions.  */
-  emacs_value (*vec_get) (emacs_env *env, emacs_value vec, ptrdiff_t i);
-
-  void (*vec_set) (emacs_env *env, emacs_value vec, ptrdiff_t i,
-                   emacs_value val);
-
-  ptrdiff_t (*vec_size) (emacs_env *env, emacs_value vec);
-};
-
-/* Every module should define a function as follows.  */
-extern int emacs_module_init (struct emacs_runtime *ert);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* EMACS_MODULE_H */
diff --git a/src/emacs-module.h.in b/src/emacs-module.h.in
new file mode 100644
index 00000000000..40b6448d27e
--- /dev/null
+++ b/src/emacs-module.h.in
@@ -0,0 +1,107 @@
+/* emacs-module.h - GNU Emacs module API.
+
+Copyright (C) 2015-2017 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or (at
+your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef EMACS_MODULE_H
+#define EMACS_MODULE_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
+
+#if defined __cplusplus && __cplusplus >= 201103L
+# define EMACS_NOEXCEPT noexcept
+#else
+# define EMACS_NOEXCEPT
+#endif
+
+#ifdef __has_attribute
+#if __has_attribute(__nonnull__)
+# define EMACS_ATTRIBUTE_NONNULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
+#endif
+#endif
+#ifndef EMACS_ATTRIBUTE_NONNULL
+# define EMACS_ATTRIBUTE_NONNULL(...)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Current environment.  */
+typedef struct emacs_env_26 emacs_env;
+
+/* Opaque pointer representing an Emacs Lisp value.
+   BEWARE: Do not assume NULL is a valid value!  */
+typedef struct emacs_value_tag *emacs_value;
+
+enum { emacs_variadic_function = -2 };
+
+/* Struct passed to a module init function (emacs_module_init).  */
+struct emacs_runtime
+{
+  /* Structure size (for version checking).  */
+  ptrdiff_t size;
+
+  /* Private data; users should not touch this.  */
+  struct emacs_runtime_private *private_members;
+
+  /* Return an environment pointer.  */
+  emacs_env *(*get_environment) (struct emacs_runtime *ert)
+    EMACS_ATTRIBUTE_NONNULL(1);
+};
+
+
+/* Possible Emacs function call outcomes.  */
+enum emacs_funcall_exit
+{
+  /* Function has returned normally.  */
+  emacs_funcall_exit_return = 0,
+
+  /* Function has signaled an error using `signal'.  */
+  emacs_funcall_exit_signal = 1,
+
+  /* Function has exit using `throw'.  */
+  emacs_funcall_exit_throw = 2
+};
+
+struct emacs_env_25
+{
+@module_env_snippet_25@
+};
+
+struct emacs_env_26
+{
+@module_env_snippet_25@
+
+@module_env_snippet_26@
+};
+
+/* Every module should define a function as follows.  */
+extern int emacs_module_init (struct emacs_runtime *ert)
+  EMACS_NOEXCEPT
+  EMACS_ATTRIBUTE_NONNULL(1);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EMACS_MODULE_H */
diff --git a/src/emacs.c b/src/emacs.c
index 1868961090d..0fec7167588 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -23,7 +23,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <errno.h>
 #include <fcntl.h>
-#include <stdio.h>
 #include <stdlib.h>
 
 #include <sys/file.h>
@@ -33,6 +32,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #define MAIN_PROGRAM
 #include "lisp.h"
+#include "sysstdio.h"
 
 #ifdef WINDOWSNT
 #include <fcntl.h>
@@ -137,10 +137,6 @@ static
 bool might_dump;
 #endif
 
-#ifdef DARWIN_OS
-extern void unexec_init_emacs_zone (void);
-#endif
-
 /* If true, Emacs should not attempt to use a window-specific code,
    but instead should use the virtual terminal under which it was started.  */
 bool inhibit_window_system;
@@ -223,11 +219,16 @@ Initialization options:\n\
     "\
 --batch                     do not do interactive display; implies -q\n\
 --chdir DIR                 change to directory DIR\n\
---daemon, --old-daemon[=NAME] start a (named) server in the background\n\
---new-daemon[=NAME]         start a (named) server in the foreground\n\
+--daemon, --bg-daemon[=NAME] start a (named) server in the background\n\
+--fg-daemon[=NAME]          start a (named) server in the foreground\n\
 --debug-init                enable Emacs Lisp debugger for init file\n\
 --display, -d DISPLAY       use X server DISPLAY\n\
 ",
+#ifdef HAVE_MODULES
+    "\
+--module-assertions         assert behavior of dynamic modules\n\
+",
+#endif
     "\
 --no-build-details          do not add build details such as time stamps\n\
 --no-desktop                do not load a saved desktop\n\
@@ -467,6 +468,9 @@ init_cmdargs (int argc, char **argv, int skip_args, char *original_pwd)
 
   if (!NILP (Vinvocation_directory))
     {
+      if (NILP (Vpurify_flag) && !NILP (Ffboundp (Qfile_truename)))
+        Vinvocation_directory = call1 (Qfile_truename, Vinvocation_directory);
+
       dir = Vinvocation_directory;
 #ifdef WINDOWSNT
       /* If we are running from the build directory, set DIR to the
@@ -657,8 +661,11 @@ close_output_streams (void)
       _exit (EXIT_FAILURE);
     }
 
-   if (close_stream (stderr) != 0)
-     _exit (EXIT_FAILURE);
+  /* Do not close stderr if addresses are being sanitized, as the
+     sanitizer might report to stderr after this function is
+     invoked.  */
+  if (!ADDRESS_SANITIZER && close_stream (stderr) != 0)
+    _exit (EXIT_FAILURE);
 }
 
 /* ARGSUSED */
@@ -683,8 +690,12 @@ main (int argc, char **argv)
   /* Record (approximately) where the stack begins.  */
   stack_bottom = &stack_bottom_variable;
 
+#ifndef CANNOT_DUMP
   dumping = !initialized && (strcmp (argv[argc - 1], "dump") == 0
                              || strcmp (argv[argc - 1], "bootstrap") == 0);
+#else
+  dumping = false;
+#endif
 
   /* True if address randomization interferes with memory allocation.  */
 # ifdef __PPC64__
@@ -742,7 +753,7 @@ main (int argc, char **argv)
 #endif
 
 /* If using unexmacosx.c (set by s/darwin.h), we must do this. */
-#ifdef DARWIN_OS
+#if defined DARWIN_OS && !defined CANNOT_DUMP
   if (!initialized)
     unexec_init_emacs_zone ();
 #endif
@@ -874,7 +885,7 @@ main (int argc, char **argv)
     }
 #endif /* HAVE_SETRLIMIT and RLIMIT_STACK and not CYGWIN */
 
-  clearerr (stdin);
+  clearerr_unlocked (stdin);
 
   emacs_backtrace (-1);
 
@@ -972,7 +983,7 @@ main (int argc, char **argv)
       int i;
       printf ("Usage: %s [OPTION-OR-FILENAME]...\n", argv[0]);
       for (i = 0; i < ARRAYELTS (usage_message); i++)
-        fputs (usage_message[i], stdout);
+        fputs_unlocked (usage_message[i], stdout);
       exit (0);
     }
 
@@ -988,15 +999,15 @@ main (int argc, char **argv)
 
   int sockfd = -1;
 
-  if (argmatch (argv, argc, "-new-daemon", "--new-daemon", 10, NULL, &skip_args)
-      || argmatch (argv, argc, "-new-daemon", "--new-daemon", 10, &dname_arg, &skip_args))
+  if (argmatch (argv, argc, "-fg-daemon", "--fg-daemon", 10, NULL, &skip_args)
+      || argmatch (argv, argc, "-fg-daemon", "--fg-daemon", 10, &dname_arg, &skip_args))
     {
       daemon_type = 1;           /* foreground */
     }
   else if (argmatch (argv, argc, "-daemon", "--daemon", 5, NULL, &skip_args)
       || argmatch (argv, argc, "-daemon", "--daemon", 5, &dname_arg, &skip_args)
-      || argmatch (argv, argc, "-old-daemon", "--old-daemon", 10, NULL, &skip_args)
-      || argmatch (argv, argc, "-old-daemon", "--old-daemon", 10, &dname_arg, &skip_args))
+      || argmatch (argv, argc, "-bg-daemon", "--bg-daemon", 10, NULL, &skip_args)
+      || argmatch (argv, argc, "-bg-daemon", "--bg-daemon", 10, &dname_arg, &skip_args))
     {
       daemon_type = 2;          /* background */
     }
@@ -1111,7 +1122,7 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
                 char fdStr[80];
                 int fdStrlen =
                   snprintf (fdStr, sizeof fdStr,
-                            "--old-daemon=\n%d,%d\n%s", daemon_pipe[0],
+                            "--bg-daemon=\n%d,%d\n%s", daemon_pipe[0],
                             daemon_pipe[1], dname_arg ? dname_arg : "");
 
                 if (! (0 <= fdStrlen && fdStrlen < sizeof fdStr))
@@ -1257,6 +1268,18 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
   build_details = ! argmatch (argv, argc, "-no-build-details",
                               "--no-build-details", 7, NULL, &skip_args);
 
+#ifdef HAVE_MODULES
+  bool module_assertions
+    = argmatch (argv, argc, "-module-assertions", "--module-assertions", 15,
+                NULL, &skip_args);
+  if (dumping && module_assertions)
+    {
+      fputs ("Module assertions are not supported during dumping\n", stderr);
+      exit (1);
+    }
+  init_module_assertions (module_assertions);
+#endif
+
 #ifdef HAVE_NS
   ns_pool = ns_alloc_autorelease_pool ();
 #ifdef NS_IMPL_GNUSTEP
@@ -1708,12 +1731,15 @@ static const struct standard_args standard_args[] =
   { "-batch", "--batch", 100, 0 },
   { "-script", "--script", 100, 1 },
   { "-daemon", "--daemon", 99, 0 },
-  { "-old-daemon", "--old-daemon", 99, 0 },
-  { "-new-daemon", "--new-daemon", 99, 0 },
+  { "-bg-daemon", "--bg-daemon", 99, 0 },
+  { "-fg-daemon", "--fg-daemon", 99, 0 },
   { "-help", "--help", 90, 0 },
   { "-nl", "--no-loadup", 70, 0 },
   { "-nsl", "--no-site-lisp", 65, 0 },
   { "-no-build-details", "--no-build-details", 63, 0 },
+#ifdef HAVE_MODULES
+  { "-module-assertions", "--module-assertions", 62, 0 },
+#endif
   /* -d must come last before the options handled in startup.el.  */
   { "-d", "--display", 60, 1 },
   { "-display", 0, 60, 1 },
@@ -2171,7 +2197,7 @@ You must run Emacs in batch mode in order to dump it.  */)
   }
 #endif
 
-  fflush (stdout);
+  fflush_unlocked (stdout);
   /* Tell malloc where start of impure now is.  */
   /* Also arrange for warnings when nearly out of space.  */
 #if !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
diff --git a/src/eval.c b/src/eval.c
index 16d1cf810ea..8f293c9d300 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1225,18 +1225,17 @@ usage: (condition-case VAR BODYFORM &rest HANDLERS)  */)
    rather than passed in a list.  Used by Fbyte_code.  */
 
 Lisp_Object
-internal_lisp_condition_case (volatile Lisp_Object var, Lisp_Object bodyform,
+internal_lisp_condition_case (Lisp_Object var, Lisp_Object bodyform,
                               Lisp_Object handlers)
 {
-  Lisp_Object val;
   struct handler *oldhandlerlist = handlerlist;
-  int clausenb = 0;
+  ptrdiff_t clausenb = 0;
 
   CHECK_SYMBOL (var);
 
-  for (val = handlers; CONSP (val); val = XCDR (val))
+  for (Lisp_Object tail = handlers; CONSP (tail); tail = XCDR (tail))
     {
-      Lisp_Object tem = XCAR (val);
+      Lisp_Object tem = XCAR (tail);
       clausenb++;
       if (! (NILP (tem)
              || (CONSP (tem)
@@ -1246,55 +1245,58 @@ internal_lisp_condition_case (volatile Lisp_Object var, Lisp_Object bodyform,
                SDATA (Fprin1_to_string (tem, Qt)));
     }
 
-  { /* The first clause is the one that should be checked first, so it should
-       be added to handlerlist last.  So we build in `clauses' a table that
-       contains `handlers' but in reverse order.  SAFE_ALLOCA won't work
-       here due to the setjmp, so impose a MAX_ALLOCA limit.  */
-    if (MAX_ALLOCA / word_size < clausenb)
-      memory_full (SIZE_MAX);
-    Lisp_Object *clauses = alloca (clausenb * sizeof *clauses);
-    Lisp_Object *volatile clauses_volatile = clauses;
-    int i = clausenb;
-    for (val = handlers; CONSP (val); val = XCDR (val))
-      clauses[--i] = XCAR (val);
-    for (i = 0; i < clausenb; i++)
-      {
-        Lisp_Object clause = clauses[i];
-        Lisp_Object condition = CONSP (clause) ? XCAR (clause) : Qnil;
-        if (!CONSP (condition))
-          condition = Fcons (condition, Qnil);
-        struct handler *c = push_handler (condition, CONDITION_CASE);
-        if (sys_setjmp (c->jmp))
-          {
-            ptrdiff_t count = SPECPDL_INDEX ();
-            Lisp_Object val = handlerlist->val;
-            Lisp_Object *chosen_clause = clauses_volatile;
-            for (c = handlerlist->next; c != oldhandlerlist; c = c->next)
-              chosen_clause++;
-            handlerlist = oldhandlerlist;
-            if (!NILP (var))
-              {
-                if (!NILP (Vinternal_interpreter_environment))
-                  specbind (Qinternal_interpreter_environment,
-                            Fcons (Fcons (var, val),
-                                   Vinternal_interpreter_environment));
-                else
-                  specbind (var, val);
-              }
-            val = Fprogn (XCDR (*chosen_clause));
-            /* Note that this just undoes the binding of var; whoever
-               longjumped to us unwound the stack to c.pdlcount before
-               throwing.  */
-            if (!NILP (var))
-              unbind_to (count, Qnil);
-            return val;
-          }
-      }
-  }
+  /* The first clause is the one that should be checked first, so it
+     should be added to handlerlist last.  So build in CLAUSES a table
+     that contains HANDLERS but in reverse order.  CLAUSES is pointer
+     to volatile to avoid issues with setjmp and local storage.
+     SAFE_ALLOCA won't work here due to the setjmp, so impose a
+     MAX_ALLOCA limit.  */
+  if (MAX_ALLOCA / word_size < clausenb)
+    memory_full (SIZE_MAX);
+  Lisp_Object volatile *clauses = alloca (clausenb * sizeof *clauses);
+  clauses += clausenb;
+  for (Lisp_Object tail = handlers; CONSP (tail); tail = XCDR (tail))
+    *--clauses = XCAR (tail);
+  for (ptrdiff_t i = 0; i < clausenb; i++)
+    {
+      Lisp_Object clause = clauses[i];
+      Lisp_Object condition = CONSP (clause) ? XCAR (clause) : Qnil;
+      if (!CONSP (condition))
+        condition = list1 (condition);
+      struct handler *c = push_handler (condition, CONDITION_CASE);
+      if (sys_setjmp (c->jmp))
+        {
+          Lisp_Object val = handlerlist->val;
+          Lisp_Object volatile *chosen_clause = clauses;
+          for (struct handler *h = handlerlist->next; h != oldhandlerlist;
+               h = h->next)
+            chosen_clause++;
+          Lisp_Object handler_body = XCDR (*chosen_clause);
+          handlerlist = oldhandlerlist;
+
+          if (NILP (var))
+            return Fprogn (handler_body);
+
+          Lisp_Object handler_var = var;
+          if (!NILP (Vinternal_interpreter_environment))
+            {
+              val = Fcons (Fcons (var, val),
+                           Vinternal_interpreter_environment);
+              handler_var = Qinternal_interpreter_environment;
+            }
 
-  val = eval_sub (bodyform);
+          /* Bind HANDLER_VAR to VAL while evaluating HANDLER_BODY.
+             The unbind_to undoes just this binding; whoever longjumped
+             to us unwound the stack to C->pdlcount before throwing.  */
+          ptrdiff_t count = SPECPDL_INDEX ();
+          specbind (handler_var, val);
+          return unbind_to (count, Fprogn (handler_body));
+        }
+    }
+
+  Lisp_Object result = eval_sub (bodyform);
   handlerlist = oldhandlerlist;
-  return val;
+  return result;
 }
 
 /* Call the function BFUN with no arguments, catching errors within it
@@ -1472,7 +1474,10 @@ process_quit_flag (void)
    If quit-flag is set to `kill-emacs' the SIGINT handler has received
    a request to exit Emacs when it is safe to do.
 
-   When not quitting, process any pending signals.  */
+   When not quitting, process any pending signals.
+
+   If you change this function, also adapt module_should_quit in
+   emacs-module.c.  */
 
 void
 maybe_quit (void)
@@ -1881,8 +1886,7 @@ then strings and vectors are not accepted.  */)
      have an element whose index is COMPILED_INTERACTIVE, which is
      where the interactive spec is stored.  */
   else if (COMPILEDP (fun))
-    return ((ASIZE (fun) & PSEUDOVECTOR_SIZE_MASK) > COMPILED_INTERACTIVE
-            ? Qt : if_prop);
+    return (PVSIZE (fun) > COMPILED_INTERACTIVE ? Qt : if_prop);
 
   /* Strings and vectors are keyboard macros.  */
   if (STRINGP (fun) || VECTORP (fun))
@@ -2260,7 +2264,7 @@ eval_sub (Lisp_Object form)
             }
         }
     }
-  else if (COMPILEDP (fun))
+  else if (COMPILEDP (fun) || MODULE_FUNCTIONP (fun))
     return apply_lambda (fun, original_args, count);
   else
     {
@@ -2686,7 +2690,7 @@ FUNCTIONP (Lisp_Object object)
 
   if (SUBRP (object))
     return XSUBR (object)->max_args != UNEVALLED;
-  else if (COMPILEDP (object))
+  else if (COMPILEDP (object) || MODULE_FUNCTIONP (object))
     return true;
   else if (CONSP (object))
     {
@@ -2741,7 +2745,7 @@ usage: (funcall FUNCTION &rest ARGUMENTS)  */)
 
   if (SUBRP (fun))
     val = funcall_subr (XSUBR (fun), numargs, args + 1);
-  else if (COMPILEDP (fun))
+  else if (COMPILEDP (fun) || MODULE_FUNCTIONP (fun))
     val = funcall_lambda (fun, numargs, args + 1);
   else
     {
@@ -2891,7 +2895,8 @@ apply_lambda (Lisp_Object fun, Lisp_Object args, ptrdiff_t count)
 
 /* Apply a Lisp function FUN to the NARGS evaluated arguments in ARG_VECTOR
    and return the result of evaluation.
-   FUN must be either a lambda-expression or a compiled-code object.  */
+   FUN must be either a lambda-expression, a compiled-code object,
+   or a module function.  */
 
 static Lisp_Object
 funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
@@ -2922,7 +2927,7 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
     }
   else if (COMPILEDP (fun))
     {
-      ptrdiff_t size = ASIZE (fun) & PSEUDOVECTOR_SIZE_MASK;
+      ptrdiff_t size = PVSIZE (fun);
       if (size <= COMPILED_STACK_DEPTH)
         xsignal1 (Qinvalid_function, fun);
       syms_left = AREF (fun, COMPILED_ARGLIST);
@@ -2948,6 +2953,10 @@ funcall_lambda (Lisp_Object fun, ptrdiff_t nargs,
         }
       lexenv = Qnil;
     }
+#ifdef HAVE_MODULES
+  else if (MODULE_FUNCTIONP (fun))
+    return funcall_module (fun, nargs, arg_vector);
+#endif
   else
     emacs_abort ();
 
@@ -3059,6 +3068,10 @@ function with `&rest' args, or `unevalled' for a special form.  */)
     result = Fsubr_arity (function);
   else if (COMPILEDP (function))
     result = lambda_arity (function);
+#ifdef HAVE_MODULES
+  else if (MODULE_FUNCTIONP (function))
+    result = module_function_arity (XMODULE_FUNCTION (function));
+#endif
   else
     {
       if (NILP (function))
@@ -3103,7 +3116,7 @@ lambda_arity (Lisp_Object fun)
     }
   else if (COMPILEDP (fun))
     {
-      ptrdiff_t size = ASIZE (fun) & PSEUDOVECTOR_SIZE_MASK;
+      ptrdiff_t size = PVSIZE (fun);
       if (size <= COMPILED_STACK_DEPTH)
         xsignal1 (Qinvalid_function, fun);
       syms_left = AREF (fun, COMPILED_ARGLIST);
@@ -3148,7 +3161,7 @@ DEFUN ("fetch-bytecode", Ffetch_bytecode, Sfetch_bytecode,
 
   if (COMPILEDP (object))
     {
-      ptrdiff_t size = ASIZE (object) & PSEUDOVECTOR_SIZE_MASK;
+      ptrdiff_t size = PVSIZE (object);
       if (size <= COMPILED_STACK_DEPTH)
         xsignal1 (Qinvalid_function, object);
       if (CONSP (AREF (object, COMPILED_BYTECODE)))
@@ -3211,7 +3224,7 @@ do_specbind (struct Lisp_Symbol *sym, union specbinding *bind,
           set_default_internal (specpdl_symbol (bind), value, bindflag);
           return;
         }
-      /* FALLTHROUGH */
+      FALLTHROUGH;
     case SYMBOL_LOCALIZED:
       set_internal (specpdl_symbol (bind), value, Qnil, bindflag);
       break;
@@ -3389,12 +3402,10 @@ do_one_unbind (union specbinding *this_binding, bool unwinding,
                             Qnil, bindflag);
             break;
           }
-        else
-          { /* FALLTHROUGH!!
-               NOTE: we only ever come here if make_local_foo was used for
-               the first time on this var within this let.  */
-          }
       }
+      /* Come here only if make_local_foo was used for the first time
+         on this var within this let.  */
+      FALLTHROUGH;
     case SPECPDL_LET_DEFAULT:
       set_default_internal (specpdl_symbol (this_binding),
                             specpdl_old_value (this_binding),
@@ -3602,8 +3613,12 @@ returns nil.  */)
 
   while (backtrace_p (pdl))
     {
+      ptrdiff_t i = pdl - specpdl;
       backtrace_frame_apply (function, pdl);
-      pdl = backtrace_next (pdl);
+      /* Beware! PDL is no longer valid here because FUNCTION might
+         have caused grow_specpdl to reallocate pdlvec.  We must use
+         the saved index, cf. Bug#27258.  */
+      pdl = backtrace_next (&specpdl[i]);
     }
 
   return Qnil;
@@ -3675,12 +3690,10 @@ backtrace_eval_unrewind (int distance)
                 SET_SYMBOL_VAL (XSYMBOL (sym), old_value);
                 break;
               }
-            else
-              { /* FALLTHROUGH!!
-                   NOTE: we only ever come here if make_local_foo was used for
-                   the first time on this var within this let.  */
-              }
           }
+          /* Come here only if make_local_foo was used for the first
+             time on this var within this let.  */
+          FALLTHROUGH;
         case SPECPDL_LET_DEFAULT:
           {
             Lisp_Object sym = specpdl_symbol (tmp);
@@ -3836,7 +3849,7 @@ mark_specpdl (union specbinding *first, union specbinding *ptr)
         case SPECPDL_LET_DEFAULT:
         case SPECPDL_LET_LOCAL:
           mark_object (specpdl_where (pdl));
-          /* Fall through.  */
+          FALLTHROUGH;
         case SPECPDL_LET:
           mark_object (specpdl_symbol (pdl));
           mark_object (specpdl_old_value (pdl));
diff --git a/src/fileio.c b/src/fileio.c
index acbf76e0d81..a57d50b24e0 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -2256,61 +2256,21 @@ static bool
 file_name_case_insensitive_p (const char *filename)
 {
   /* Use pathconf with _PC_CASE_INSENSITIVE or _PC_CASE_SENSITIVE if
-     those flags are available.  As of this writing (2016-11-14),
+     those flags are available.  As of this writing (2017-05-20),
      Cygwin is the only platform known to support the former (starting
-     with Cygwin-2.6.1), and Mac OS X is the only platform known to
-     support the latter.
-
-     There have been reports that pathconf with _PC_CASE_SENSITIVE
-     does not work reliably on Mac OS X.  If you have a problem,
-     please recompile Emacs with -D DARWIN_OS_CASE_SENSITIVE_FIXME=1 or
-     -D DARWIN_OS_CASE_SENSITIVE_FIXME=2, and file a bug report saying
-     whether this fixed your problem.  */
+     with Cygwin-2.6.1), and macOS is the only platform known to
+     support the latter.  */
 
 #ifdef _PC_CASE_INSENSITIVE
   int res = pathconf (filename, _PC_CASE_INSENSITIVE);
   if (res >= 0)
     return res > 0;
-#elif defined _PC_CASE_SENSITIVE && !defined DARWIN_OS_CASE_SENSITIVE_FIXME
+#elif defined _PC_CASE_SENSITIVE
   int res = pathconf (filename, _PC_CASE_SENSITIVE);
   if (res >= 0)
     return res == 0;
 #endif
 
-#ifdef DARWIN_OS
-# ifndef DARWIN_OS_CASE_SENSITIVE_FIXME
-  int DARWIN_OS_CASE_SENSITIVE_FIXME = 0;
-# endif
-
-  if (DARWIN_OS_CASE_SENSITIVE_FIXME == 1)
-    {
-      /* This is based on developer.apple.com's getattrlist man page.  */
-      struct attrlist alist = {.volattr = ATTR_VOL_CAPABILITIES};
-      vol_capabilities_attr_t vcaps;
-      if (getattrlist (filename, &alist, &vcaps, sizeof vcaps, 0) == 0)
-        {
-          if (vcaps.valid[VOL_CAPABILITIES_FORMAT] & VOL_CAP_FMT_CASE_SENSITIVE)
-            return ! (vcaps.capabilities[VOL_CAPABILITIES_FORMAT]
-                      & VOL_CAP_FMT_CASE_SENSITIVE);
-        }
-    }
-  else if (DARWIN_OS_CASE_SENSITIVE_FIXME == 2)
-    {
-      /* The following is based on
-         http://lists.apple.com/archives/darwin-dev/2007/Apr/msg00010.html.  */
-      struct attrlist alist;
-      unsigned char buffer[sizeof (vol_capabilities_attr_t) + sizeof (size_t)];
-
-      memset (&alist, 0, sizeof (alist));
-      alist.volattr = ATTR_VOL_CAPABILITIES;
-      if (getattrlist (filename, &alist, buffer, sizeof (buffer), 0)
-          || !(alist.volattr & ATTR_VOL_CAPABILITIES))
-        return 0;
-      vol_capabilities_attr_t *vcaps = buffer;
-      return !(vcaps->capabilities[0] & VOL_CAP_FMT_CASE_SENSITIVE);
-    }
-#endif  /* DARWIN_OS */
-
 #if defined CYGWIN || defined DOS_NT
   return true;
 #else
@@ -3346,11 +3306,7 @@ otherwise, if FILE2 does not exist, the answer is t.  */)
           ? Qt : Qnil);
 }
 
-#ifndef READ_BUF_SIZE
-#define READ_BUF_SIZE (64 << 10)
-#endif
-/* Some buffer offsets are stored in 'int' variables.  */
-verify (READ_BUF_SIZE <= INT_MAX);
+enum { READ_BUF_SIZE = MAX_ALLOCA };
 
 /* This function is called after Lisp functions to decide a coding
    system are called, or when they cause an error.  Before they are
@@ -5687,14 +5643,12 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
           {
             block_input ();
             if (!NILP (BVAR (b, filename)))
-              {
-                fwrite (SDATA (BVAR (b, filename)), 1,
-                        SBYTES (BVAR (b, filename)), stream);
-              }
-            putc ('\n', stream);
-            fwrite (SDATA (BVAR (b, auto_save_file_name)), 1,
-                    SBYTES (BVAR (b, auto_save_file_name)), stream);
-            putc ('\n', stream);
+              fwrite_unlocked (SDATA (BVAR (b, filename)), 1,
+                               SBYTES (BVAR (b, filename)), stream);
+            putc_unlocked ('\n', stream);
+            fwrite_unlocked (SDATA (BVAR (b, auto_save_file_name)), 1,
+                             SBYTES (BVAR (b, auto_save_file_name)), stream);
+            putc_unlocked ('\n', stream);
             unblock_input ();
           }
 
@@ -5885,7 +5839,7 @@ effect except for flushing STREAM's data.  */)
 
   binmode = NILP (mode) ? O_TEXT : O_BINARY;
   if (fp != stdin)
-    fflush (fp);
+    fflush_unlocked (fp);
 
   return (set_binary_mode (fileno (fp), binmode) == O_BINARY) ? Qt : Qnil;
 }
diff --git a/src/filelock.c b/src/filelock.c
index 67e8dbd34ed..bfa1d63d833 100644
--- a/src/filelock.c
+++ b/src/filelock.c
@@ -569,7 +569,7 @@ current_lock_owner (lock_info_type *owner, char *lfname)
       if (! (boot[0] == '\200' && boot[1] == '\242'))
         return -1;
       boot += 2;
-      /* Fall through.  */
+      FALLTHROUGH;
     case ':':
       if (! c_isdigit (boot[0]))
         return -1;
diff --git a/src/fns.c b/src/fns.c
index de7fc1b47fc..6610d2a6d0e 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -106,8 +106,8 @@ To get the number of bytes, use `string-bytes'.  */)
     XSETFASTINT (val, MAX_CHAR);
   else if (BOOL_VECTOR_P (sequence))
     XSETFASTINT (val, bool_vector_size (sequence));
-  else if (COMPILEDP (sequence))
-    XSETFASTINT (val, ASIZE (sequence) & PSEUDOVECTOR_SIZE_MASK);
+  else if (COMPILEDP (sequence) || RECORDP (sequence))
+    XSETFASTINT (val, PVSIZE (sequence));
   else if (CONSP (sequence))
     {
       intptr_t i = 0;
@@ -475,13 +475,18 @@ usage: (vconcat &rest SEQUENCES)   */)
 
 
 DEFUN ("copy-sequence", Fcopy_sequence, Scopy_sequence, 1, 1, 0,
-       doc: /* Return a copy of a list, vector, string or char-table.
-The elements of a list or vector are not copied; they are shared
-with the original.  */)
+       doc: /* Return a copy of a list, vector, string, char-table or record.
+The elements of a list, vector or record are not copied; they are
+shared with the original.  */)
   (Lisp_Object arg)
 {
   if (NILP (arg)) return arg;
 
+  if (RECORDP (arg))
+    {
+      return Frecord (PVSIZE (arg), XVECTOR (arg)->contents);
+    }
+
   if (CHAR_TABLE_P (arg))
     {
       return copy_char_table (arg);
@@ -2792,8 +2797,17 @@ suppressed.  */)
 
       tem = Fmemq (feature, Vfeatures);
       if (NILP (tem))
-        error ("Required feature `%s' was not provided",
-               SDATA (SYMBOL_NAME (feature)));
+        {
+          unsigned char *tem2 = SDATA (SYMBOL_NAME (feature));
+          Lisp_Object tem3 = Fcar (Fcar (Vload_history));
+
+          if (NILP (tem3))
+            error ("Required feature `%s' was not provided", tem2);
+          else
+            /* Cf autoload-do-load.  */
+            error ("Loading file %s failed to provide feature `%s'",
+                   SDATA (tem3), tem2);
+        }
 
       /* Once loading finishes, don't undo it.  */
       Vautoload_queue = Qt;
@@ -4275,7 +4289,7 @@ sxhash_list (Lisp_Object list, int depth)
 }
 
 
-/* Return a hash for vector VECTOR.  DEPTH is the current depth in
+/* Return a hash for (pseudo)vector VECTOR.  DEPTH is the current depth in
    the Lisp structure.  */
 
 static EMACS_UINT
@@ -4284,7 +4298,7 @@ sxhash_vector (Lisp_Object vec, int depth)
   EMACS_UINT hash = ASIZE (vec);
   int i, n;
 
-  n = min (SXHASH_MAX_LEN, ASIZE (vec));
+  n = min (SXHASH_MAX_LEN, hash & PSEUDOVECTOR_FLAG ? PVSIZE (vec) : hash);
   for (i = 0; i < n; ++i)
     {
       EMACS_UINT hash2 = sxhash (AREF (vec, i), depth + 1);
@@ -4339,11 +4353,11 @@ sxhash (Lisp_Object obj, int depth)
 
       /* This can be everything from a vector to an overlay.  */
     case Lisp_Vectorlike:
-      if (VECTORP (obj))
+      if (VECTORP (obj) || RECORDP (obj))
         /* According to the CL HyperSpec, two arrays are equal only if
            they are `eq', except for strings and bit-vectors.  In
            Emacs, this works differently.  We have to compare element
-           by element.  */
+           by element.  Same for records.  */
         hash = sxhash_vector (obj, depth);
       else if (BOOL_VECTOR_P (obj))
         hash = sxhash_bool_vector (obj);
diff --git a/src/font.c b/src/font.c
index a929509752c..5a3f271ef85 100644
--- a/src/font.c
+++ b/src/font.c
@@ -306,18 +306,20 @@ font_pixel_size (struct frame *f, Lisp_Object spec)
     return XINT (size);
   if (NILP (size))
     return 0;
-  eassert (FLOATP (size));
-  point_size = XFLOAT_DATA (size);
-  val = AREF (spec, FONT_DPI_INDEX);
-  if (INTEGERP (val))
-    dpi = XINT (val);
-  else
-    dpi = FRAME_RES_Y (f);
-  pixel_size = POINT_TO_PIXEL (point_size, dpi);
-  return pixel_size;
-#else
-  return 1;
+  if (FRAME_WINDOW_P (f))
+    {
+      eassert (FLOATP (size));
+      point_size = XFLOAT_DATA (size);
+      val = AREF (spec, FONT_DPI_INDEX);
+      if (INTEGERP (val))
+        dpi = XINT (val);
+      else
+        dpi = FRAME_RES_Y (f);
+      pixel_size = POINT_TO_PIXEL (point_size, dpi);
+      return pixel_size;
+    }
 #endif
+  return 1;
 }
 
 
@@ -2777,21 +2779,27 @@ font_list_entities (struct frame *f, Lisp_Object spec)
           val = XCDR (val);
         else
           {
-            val = driver_list->driver->list (f, scratch_font_spec);
-            if (!NILP (val))
-              {
-                Lisp_Object copy = copy_font_spec (scratch_font_spec);
+            Lisp_Object copy;
 
-                val = Fvconcat (1, &val);
-                ASET (copy, FONT_TYPE_INDEX, driver_list->driver->type);
-                XSETCDR (cache, Fcons (Fcons (copy, val), XCDR (cache)));
-              }
+            val = driver_list->driver->list (f, scratch_font_spec);
+            /* We put zero_vector in the font-cache to indicate that
+               no fonts matching SPEC were found on the system.
+               Failure to have this indication in the font cache can
+               cause severe performance degradation in some rare
+               cases, see bug#21028.  */
+            if (NILP (val))
+              val = zero_vector;
+            else
+              val = Fvconcat (1, &val);
+            copy = copy_font_spec (scratch_font_spec);
+            ASET (copy, FONT_TYPE_INDEX, driver_list->driver->type);
+            XSETCDR (cache, Fcons (Fcons (copy, val), XCDR (cache)));
           }
-        if (VECTORP (val) && ASIZE (val) > 0
+        if (ASIZE (val) > 0
             && (need_filtering
                 || ! NILP (Vface_ignored_fonts)))
           val = font_delete_unmatched (val, need_filtering ? spec : Qnil, size);
-        if (VECTORP (val) && ASIZE (val) > 0)
+        if (ASIZE (val) > 0)
           list = Fcons (val, list);
       }
 
diff --git a/src/font.h b/src/font.h
index a469b20e4f4..53e3fc21a3d 100644
--- a/src/font.h
+++ b/src/font.h
@@ -424,7 +424,7 @@ FONTP (Lisp_Object x)
 INLINE bool
 FONT_SPEC_P (Lisp_Object x)
 {
-  return FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_SPEC_MAX;
+  return FONTP (x) && PVSIZE (x) == FONT_SPEC_MAX;
 }
 
 /* Like FONT_SPEC_P, but can be used in the garbage collector.  */
@@ -438,7 +438,7 @@ GC_FONT_SPEC_P (Lisp_Object x)
 INLINE bool
 FONT_ENTITY_P (Lisp_Object x)
 {
-  return FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_ENTITY_MAX;
+  return FONTP (x) && PVSIZE (x) == FONT_ENTITY_MAX;
 }
 
 /* Like FONT_ENTITY_P, but can be used in the garbage collector.  */
@@ -452,7 +452,7 @@ GC_FONT_ENTITY_P (Lisp_Object x)
 INLINE bool
 FONT_OBJECT_P (Lisp_Object x)
 {
-  return FONTP (x) && (ASIZE (x) & PSEUDOVECTOR_SIZE_MASK) == FONT_OBJECT_MAX;
+  return FONTP (x) && PVSIZE (x) == FONT_OBJECT_MAX;
 }
 
 /* Like FONT_OBJECT_P, but can be used in the garbage collector.  */
diff --git a/src/frame.c b/src/frame.c
index 162b2038fd8..1e5e4bbdb48 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -324,55 +324,222 @@ DEFUN ("frame-windows-min-size", Fframe_windows_min_size,
   return make_number (0);
 }
 
+/**
+ * frame_windows_min_size:
+ *
+ * Return the minimum number of lines (columns if HORIZONTAL is non-nil)
+ * of FRAME.  If PIXELWISE is non-nil, return the minimum inner height
+ * (width) of FRAME in pixels.
+ *
+ * This value is calculated by the function `frame-windows-min-size' in
+ * window.el unless the `min-height' (`min-width' if HORIZONTAL is
+ * non-nil) parameter of FRAME is non-nil thus explicitly specifying the
+ * value to be returned.  In that latter case IGNORE is ignored.
+ *
+ * If `frame-windows-min-size' is called, it will make sure that the
+ * return value accommodates all windows of FRAME respecting the values
+ * of `window-min-height' (`window-min-width' if HORIZONTAL is non-nil).
+ * With IGNORE non-nil the values of these variables are ignored.
+ *
+ * In either case, never return a value less than 1.
+ */
 static int
 frame_windows_min_size (Lisp_Object frame, Lisp_Object horizontal,
                         Lisp_Object ignore, Lisp_Object pixelwise)
 {
-  return XINT (call4 (Qframe_windows_min_size, frame, horizontal,
+  struct frame *f = XFRAME (frame);
+  Lisp_Object par_size;
+
+  if ((!NILP (horizontal)
+       && NUMBERP (par_size = get_frame_param (f, Qmin_width)))
+      || (NILP (horizontal)
+          && NUMBERP (par_size = get_frame_param (f, Qmin_height))))
+    {
+      int min_size = XINT (par_size);
+
+      /* Don't allow phantom frames.  */
+      if (min_size < 1)
+        min_size = 1;
+
+      return (NILP (pixelwise)
+              ? min_size
+              : min_size * (NILP (horizontal)
+                            ? FRAME_LINE_HEIGHT (f)
+                            : FRAME_COLUMN_WIDTH (f)));
+    }
+  else
+    return XINT (call4 (Qframe_windows_min_size, frame, horizontal,
                       ignore, pixelwise));
 }
 
 
-/* Make sure windows sizes of frame F are OK.  new_width and new_height
-   are in pixels.  A value of -1 means no change is requested for that
-   size (but the frame may still have to be resized to accommodate
-   windows with their minimum sizes).  This can either issue a request
-   to resize the frame externally (via x_set_window_size), to resize the
-   frame internally (via resize_frame_windows) or do nothing at all.
+#ifdef HAVE_WINDOW_SYSTEM
+/**
+ * keep_ratio:
+ *
+ * Preserve ratios of frame F which usually happens after its parent
+ * frame P got resized.  OLD_WIDTH, OLD_HEIGHT specifies the old native
+ * size of F's parent, NEW_WIDTH and NEW_HEIGHT its new size.
+ *
+ * Adjust F's width if F's 'keep_ratio' parameter is non-nil and, if
+ * it is a cons, its car is not 'height-only'.  Adjust F's height if F's
+ * 'keep_ratio' parameter is non-nil and, if it is a cons, its car
+ * is not 'width-only'.
+ *
+ * Adjust F's left position if F's 'keep_ratio' parameter is non-nil
+ * and, if its is a cons, its cdr is non-nil and not 'top-only'.  Adjust
+ * F's top position if F's 'keep_ratio' parameter is non-nil and, if
+ * its is a cons, its cdr is non-nil and not 'left-only'.
+ *
+ * Note that when positional adjustment is requested but the size of F
+ * should remain unaltered in the corresponding direction, this routine
+ * tries to constrain F to its parent frame - something which usually
+ * happens when the parent frame shrinks.  This means, however, that
+ * when the parent frame is re-enlarged later, the child's original
+ * position will not get restored to its pre-shrinking value.
+ *
+ * This routine is currently useful for child frames only.  It might be
+ * eventually useful when moving non-child frames between monitors with
+ * different resolutions.
+ */
+static void
+keep_ratio (struct frame *f, struct frame *p, int old_width, int old_height,
+            int new_width, int new_height)
+{
+  Lisp_Object keep_ratio = get_frame_param (f, Qkeep_ratio);
 
-   The argument INHIBIT can assume the following values:
 
-   0 means to unconditionally call x_set_window_size even if sizes
-     apparently do not change.  Fx_create_frame uses this to pass the
-     initial size to the window manager.
+  if (!NILP (keep_ratio))
+    {
+      double width_factor = (double)new_width / (double)old_width;
+      double height_factor = (double)new_height / (double)old_height;
+      int pixel_width, pixel_height, pos_x, pos_y;
 
-   1 means to call x_set_window_size if the outer frame size really
-     changes.  Fset_frame_size, Fset_frame_height, ... use this.
+      if (!CONSP (keep_ratio) || !NILP (Fcdr (keep_ratio)))
+        {
+          if (CONSP (keep_ratio) && EQ (Fcdr (keep_ratio), Qtop_only))
+            pos_x = f->left_pos;
+          else
+            {
+              pos_x = (int)(f->left_pos * width_factor + 0.5);
 
-   2 means to call x_set_window_size provided frame_inhibit_resize
-     allows it.  The menu and tool bar code use this ("3" won't work
-     here in general because menu and tool bar are often not counted in
-     the frame's text height).
+              if (CONSP (keep_ratio)
+                  && (NILP (Fcar (keep_ratio))
+                      || EQ (Fcar (keep_ratio), Qheight_only))
+                  && p->pixel_width - f->pixel_width < pos_x)
+                {
+                  int p_f_width = p->pixel_width - f->pixel_width;
 
-   3 means call x_set_window_size if window minimum sizes must be
-     preserved or frame_inhibit_resize allows it.  x_set_left_fringe,
-     x_set_scroll_bar_width, x_new_font ... use (or should use) this.
+                  if (p_f_width <= 0)
+                    pos_x = 0;
+                  else
+                    pos_x = (int)(p_f_width * width_factor * 0.5 + 0.5);
+                }
 
-   4 means call x_set_window_size only if window minimum sizes must be
-     preserved.  x_set_right_divider_width, x_set_border_width and the
-     code responsible for wrapping the tool bar use this.
+              f->left_pos = pos_x;
+            }
 
-   5 means to never call x_set_window_size.  change_frame_size uses
-     this.
+          if (CONSP (keep_ratio) && EQ (Fcdr (keep_ratio), Qleft_only))
+            pos_y = f->top_pos;
+          else
+            {
+              pos_y = (int)(f->top_pos * height_factor + 0.5);
+
+              if (CONSP (keep_ratio)
+                  && (NILP (Fcar (keep_ratio))
+                      || EQ (Fcar (keep_ratio), Qwidth_only))
+                  && p->pixel_height - f->pixel_height < pos_y)
+                /* When positional adjustment was requested and the
+                   width of F should remain unaltered, try to constrain
+                   F to its parent.  This means that when the parent
+                   frame is enlarged later the child's original position
+                   won't get restored.  */
+                {
+                  int p_f_height = p->pixel_height - f->pixel_height;
+
+                  if (p_f_height <= 0)
+                    pos_y = 0;
+                  else
+                    pos_y = (int)(p_f_height * height_factor * 0.5 + 0.5);
+                }
+
+              f->top_pos = pos_y;
+            }
+
+          x_set_offset (f, pos_x, pos_y, -1);
+        }
+
+      if (!CONSP (keep_ratio) || !NILP (Fcar (keep_ratio)))
+        {
+          if (CONSP (keep_ratio) && EQ (Fcar (keep_ratio), Qheight_only))
+            pixel_width = -1;
+          else
+            {
+              pixel_width = (int)(f->pixel_width * width_factor + 0.5);
+              pixel_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, pixel_width);
+            }
+
+          if (CONSP (keep_ratio) && EQ (Fcar (keep_ratio), Qwidth_only))
+            pixel_height = -1;
+          else
+            {
+              pixel_height = (int)(f->pixel_height * height_factor + 0.5);
+              pixel_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, pixel_height);
+            }
+
+          adjust_frame_size (f, pixel_width, pixel_height, 1, 0,
+                             Qkeep_ratio);
+        }
+    }
+}
+#endif
 
-   Note that even when x_set_window_size is not called, individual
-   windows may have to be resized (via `window--sanitize-window-sizes')
-   in order to support minimum size constraints.
 
-   PRETEND is as for change_frame_size.  PARAMETER, if non-nil, is the
-   symbol of the parameter changed (like `menu-bar-lines', `font', ...).
-   This is passed on to frame_inhibit_resize to let the latter decide on
-   a case-by-case basis whether the frame may be resized externally.  */
+/**
+ * adjust_frame_size:
+ *
+ * Adjust size of frame F.  NEW_WIDTH and NEW_HEIGHT specify the new
+ * text size of F in pixels.  A value of -1 means no change is requested
+ * for that direction (but the frame may still have to be resized to
+ * accommodate windows with their minimum sizes).  This can either issue
+ * a request to resize the frame externally (via x_set_window_size), to
+ * resize the frame internally (via resize_frame_windows) or do nothing
+ * at all.
+ *
+ * The argument INHIBIT can assume the following values:
+ *
+ * 0 means to unconditionally call x_set_window_size even if sizes
+ *   apparently do not change.  Fx_create_frame uses this to pass the
+ *   initial size to the window manager.
+ *
+ * 1 means to call x_set_window_size if the native frame size really
+ *   changes.  Fset_frame_size, Fset_frame_height, ... use this.
+ *
+ * 2 means to call x_set_window_size provided frame_inhibit_resize
+ *   allows it.  The menu and tool bar code use this ("3" won't work
+ *   here in general because menu and tool bar are often not counted in
+ *   the frame's text height).
+ *
+ * 3 means call x_set_window_size if window minimum sizes must be
+ *   preserved or frame_inhibit_resize allows it.  x_set_left_fringe,
+ *   x_set_scroll_bar_width, x_new_font ... use (or should use) this.
+ *
+ * 4 means call x_set_window_size only if window minimum sizes must be
+ *   preserved.  x_set_right_divider_width, x_set_border_width and the
+ *   code responsible for wrapping the tool bar use this.
+ *
+ * 5 means to never call x_set_window_size.  change_frame_size uses
+ *   this.
+ *
+ * Note that even when x_set_window_size is not called, individual
+ * windows may have to be resized (via `window--sanitize-window-sizes')
+ * in order to support minimum size constraints.
+ *
+ * PRETEND is as for change_frame_size.  PARAMETER, if non-nil, is the
+ * symbol of the parameter changed (like `menu-bar-lines', `font', ...).
+ * This is passed on to frame_inhibit_resize to let the latter decide on
+ * a case-by-case basis whether the frame may be resized externally.
+ */
 void
 adjust_frame_size (struct frame *f, int new_width, int new_height, int inhibit,
                    bool pretend, Lisp_Object parameter)
@@ -596,6 +763,18 @@ adjust_frame_size (struct frame *f, int new_width, int new_height, int inhibit,
                   || new_pixel_height != old_pixel_height);
 
   unblock_input ();
+
+#ifdef HAVE_WINDOW_SYSTEM
+  {
+    /* Adjust size of F's child frames.  */
+    Lisp_Object frames, frame1;
+
+    FOR_EACH_FRAME (frames, frame1)
+      if (FRAME_PARENT_FRAME (XFRAME (frame1)) == f)
+        keep_ratio (XFRAME (frame1), f, old_pixel_width, old_pixel_height,
+                    new_pixel_width, new_pixel_height);
+  }
+#endif
 }
 
 /* Allocate basically initialized frame.  */
@@ -643,6 +822,15 @@ make_frame (bool mini_p)
   f->vertical_scroll_bar_type = vertical_scroll_bar_none;
   f->horizontal_scroll_bars = false;
   f->want_fullscreen = FULLSCREEN_NONE;
+  f->undecorated = false;
+  f->no_special_glyphs = false;
+#ifndef HAVE_NTGUI
+  f->override_redirect = false;
+#endif
+  f->skip_taskbar = false;
+  f->no_focus_on_map = false;
+  f->no_accept_focus = false;
+  f->z_group = z_group_none;
 #if ! defined (USE_GTK) && ! defined (HAVE_NS)
   f->last_tool_bar_item = -1;
 #endif
@@ -1107,7 +1295,7 @@ affects all frames on the same terminal device.  */)
 Lisp_Object
 do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object norecord)
 {
-  struct frame *sf = SELECTED_FRAME ();
+  struct frame *sf = SELECTED_FRAME (), *f;
 
   /* If FRAME is a switch-frame event, extract the frame we should
      switch to.  */
@@ -1120,10 +1308,10 @@ do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object nor
      a switch-frame event to arrive after a frame is no longer live,
      especially when deleting the initial frame during startup.  */
   CHECK_FRAME (frame);
-  if (! FRAME_LIVE_P (XFRAME (frame)))
+  f = XFRAME (frame);
+  if (!FRAME_LIVE_P (f))
     return Qnil;
-
-  if (sf == XFRAME (frame))
+  else if (f == sf)
     return frame;
 
   /* If a frame's focus has been redirected toward the currently
@@ -1156,11 +1344,11 @@ do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object nor
 #else /* ! 0 */
   /* Instead, apply it only to the frame we're pointing to.  */
 #ifdef HAVE_WINDOW_SYSTEM
-  if (track && FRAME_WINDOW_P (XFRAME (frame)))
+  if (track && FRAME_WINDOW_P (f))
     {
       Lisp_Object focus, xfocus;
 
-      xfocus = x_get_focus_frame (XFRAME (frame));
+      xfocus = x_get_focus_frame (f);
       if (FRAMEP (xfocus))
         {
           focus = FRAME_FOCUS_FRAME (XFRAME (xfocus));
@@ -1168,8 +1356,7 @@ do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object nor
               /* Redirect frame focus also when FRAME has its minibuffer
                  window on the selected frame (see Bug#24500).  */
               || (NILP (focus)
-                  && EQ (FRAME_MINIBUF_WINDOW (XFRAME (frame)),
-                         sf->selected_window)))
+                  && EQ (FRAME_MINIBUF_WINDOW (f), sf->selected_window)))
             Fredirect_frame_focus (xfocus, frame);
         }
     }
@@ -1179,9 +1366,8 @@ do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object nor
   if (!for_deletion && FRAME_HAS_MINIBUF_P (sf))
     resize_mini_window (XWINDOW (FRAME_MINIBUF_WINDOW (sf)), 1);
 
-  if (FRAME_TERMCAP_P (XFRAME (frame)) || FRAME_MSDOS_P (XFRAME (frame)))
+  if (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
     {
-      struct frame *f = XFRAME (frame);
       struct tty_display_info *tty = FRAME_TTY (f);
       Lisp_Object top_frame = tty->top_frame;
 
@@ -1209,7 +1395,7 @@ do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object nor
   if (! FRAME_MINIBUF_ONLY_P (XFRAME (selected_frame)))
     last_nonminibuf_frame = XFRAME (selected_frame);
 
-  Fselect_window (XFRAME (frame)->selected_window, norecord);
+  Fselect_window (f->selected_window, norecord);
 
   /* We want to make sure that the next event generates a frame-switch
      event to the appropriate frame.  This seems kludgy to me, but
@@ -1217,7 +1403,10 @@ do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object nor
      (select-window (frame-root-window (new-frame))) doesn't end up
      with your typing being interpreted in the new frame instead of
      the one you're actually typing in.  */
-  internal_last_event_frame = Qnil;
+#ifdef HAVE_WINDOW_SYSTEM
+  if (!frame_ancestor_p (f, sf))
+#endif
+    internal_last_event_frame = Qnil;
 
   return frame;
 }
@@ -1253,12 +1442,15 @@ If EVENT is frame object, handle it as if it were a switch-frame event
 to that frame.  */)
   (Lisp_Object event)
 {
+  Lisp_Object value;
+
   /* Preserve prefix arg that the command loop just cleared.  */
   kset_prefix_arg (current_kboard, Vcurrent_prefix_arg);
   run_hook (Qmouse_leave_buffer_hook);
   /* `switch-frame' implies a focus in.  */
+  value = do_switch_frame (event, 0, 0, Qnil);
   call1 (intern ("handle-focus-in"), event);
-  return do_switch_frame (event, 0, 0, Qnil);
+  return value;
 }
 
 DEFUN ("selected-frame", Fselected_frame, Sselected_frame, 0, 0, 0,
@@ -1282,6 +1474,72 @@ DEFUN ("frame-list", Fframe_list, Sframe_list,
   return frames;
 }
 
+DEFUN ("frame-parent", Fframe_parent, Sframe_parent,
+       0, 1, 0,
+       doc: /* Return the parent frame of FRAME.
+The parent frame of FRAME is the Emacs frame whose window-system window
+is the parent window of FRAME's window-system window.  When such a frame
+exists, FRAME is considered a child frame of that frame.
+
+Return nil if FRAME has no parent frame.  This means that FRAME's
+window-system window is either a "top-level" window (a window whose
+parent window is the window-system's root window) or an embedded window
+\(a window whose parent window is owned by some other application).  */)
+     (Lisp_Object frame)
+{
+  struct frame *f = decode_live_frame (frame);
+  struct frame *p = FRAME_PARENT_FRAME (f);
+  Lisp_Object parent;
+
+  /* Can't return f->parent_frame directly since it might not be defined
+     for this platform.  */
+  if (p)
+    {
+      XSETFRAME (parent, p);
+
+      return parent;
+    }
+  else
+    return Qnil;
+}
+
+#ifdef HAVE_WINDOW_SYSTEM
+bool
+frame_ancestor_p (struct frame *af, struct frame *df)
+{
+  struct frame *pf = FRAME_PARENT_FRAME (df);
+
+  while (pf)
+    {
+      if (pf == af)
+        return true;
+      else
+        pf = FRAME_PARENT_FRAME (pf);
+    }
+
+  return false;
+}
+#endif
+
+DEFUN ("frame-ancestor-p", Fframe_ancestor_p, Sframe_ancestor_p,
+       2, 2, 0,
+       doc: /* Return non-nil if ANCESTOR is an ancestor of DESCENDANT.
+ANCESTOR is an ancestor of DESCENDANT when it is either DESCENDANT's
+parent frame or it is an ancestor of DESCENDANT's parent frame.  Both,
+ANCESTOR and DESCENDANT must be live frames and default to the selected
+frame.  */)
+     (Lisp_Object ancestor, Lisp_Object descendant)
+{
+#ifdef HAVE_WINDOW_SYSTEM
+  struct frame *af = decode_live_frame (ancestor);
+  struct frame *df = decode_live_frame (descendant);
+
+  return frame_ancestor_p (af, df) ? Qt : Qnil;
+#else
+  return Qnil;
+#endif
+  }
+
 /* Return CANDIDATE if it can be used as 'other-than-FRAME' frame on the
    same tty (for tty frames) or among frames which uses FRAME's keyboard.
    If MINIBUF is nil, do not consider minibuffer-only candidate.
@@ -1302,7 +1560,9 @@ candidate_frame (Lisp_Object candidate, Lisp_Object frame, Lisp_Object minibuf)
       || (FRAME_TERMCAP_P (c) && FRAME_TERMCAP_P (f)
           && FRAME_TTY (c) == FRAME_TTY (f)))
     {
-      if (NILP (minibuf))
+      if (!NILP (get_frame_param (c, Qno_other_frame)))
+        return Qnil;
+      else if (NILP (minibuf))
         {
           if (!FRAME_MINIBUF_ONLY_P (c))
             return candidate;
@@ -1339,9 +1599,6 @@ next_frame (Lisp_Object frame, Lisp_Object minibuf)
   Lisp_Object f, tail;
   int passed = 0;
 
-  /* There must always be at least one frame in Vframe_list.  */
-  eassert (CONSP (Vframe_list));
-
   while (passed < 2)
     FOR_EACH_FRAME (tail, f)
       {
@@ -1364,9 +1621,6 @@ prev_frame (Lisp_Object frame, Lisp_Object minibuf)
 {
   Lisp_Object f, tail, prev = Qnil;
 
-  /* There must always be at least one frame in Vframe_list.  */
-  eassert (CONSP (Vframe_list));
-
   FOR_EACH_FRAME (tail, f)
     {
       if (EQ (frame, f) && !NILP (prev))
@@ -1440,35 +1694,63 @@ DEFUN ("last-nonminibuffer-frame", Flast_nonminibuf_frame,
   return frame;
 }
 
-/* Return 1 if it is ok to delete frame F;
-   0 if all frames aside from F are invisible.
-   (Exception: if F is the terminal frame, and we are using X, return 1.)  */
-
-static int
-other_visible_frames (struct frame *f)
+/**
+ * other_frames:
+ *
+ * Return true if there exists at least one visible or iconified frame
+ * but F.  Return false otherwise.
+ *
+ * INVISIBLE true means we are called from make_frame_invisible where
+ * such a frame must be visible or iconified.  INVISIBLE nil means we
+ * are called from delete_frame.  In that case FORCE true means that the
+ * visibility status of such a frame can be ignored.
+ *
+ * If F is the terminal frame and we are using X, return true if at
+ * least one X frame exists.
+ */
+static bool
+other_frames (struct frame *f, bool invisible, bool force)
 {
-  Lisp_Object frames, this;
+  Lisp_Object frames, frame, frame1;
+  struct frame *f1;
+  Lisp_Object minibuffer_window = FRAME_MINIBUF_WINDOW (f);
 
-  FOR_EACH_FRAME (frames, this)
-    {
-      if (f == XFRAME (this))
-        continue;
+  XSETFRAME (frame, f);
+  if (WINDOWP (minibuffer_window)
+      && !EQ (frame, WINDOW_FRAME (XWINDOW (minibuffer_window))))
+    minibuffer_window = Qnil;
 
-      /* Verify that we can still talk to the frame's X window,
-         and note any recent change in visibility.  */
+  FOR_EACH_FRAME (frames, frame1)
+    {
+      f1 = XFRAME (frame1);
+      if (f != f1)
+        {
+          /* Verify that we can still talk to the frame's X window, and
+             note any recent change in visibility.  */
 #ifdef HAVE_X_WINDOWS
-      if (FRAME_WINDOW_P (XFRAME (this)))
-        x_sync (XFRAME (this));
+          if (FRAME_WINDOW_P (f1))
+            x_sync (f1);
 #endif
-
-      if (FRAME_VISIBLE_P (XFRAME (this))
-          || FRAME_ICONIFIED_P (XFRAME (this))
-          /* Allow deleting the terminal frame when at least one X
-             frame exists.  */
-          || (FRAME_WINDOW_P (XFRAME (this)) && !FRAME_WINDOW_P (f)))
-        return 1;
+          if (NILP (Fframe_parameter (frame1, Qtooltip))
+              /* Tooltips and child frames count neither for
+                 invisibility nor for deletions.  */
+              && !FRAME_PARENT_FRAME (f1)
+              /* Frames with a non-nil `delete-before' parameter don't
+                 count for deletions.  */
+              && (invisible || NILP (get_frame_param (f1, Qdelete_before)))
+              /* For invisibility and normal deletions, at least one
+                 visible or iconified frame must remain (Bug#26682).  */
+              && (FRAME_VISIBLE_P (f1) || FRAME_ICONIFIED_P (f1)
+                  || (!invisible
+                      && (force
+                          /* Allow deleting the terminal frame when at
+                             least one X frame exists.  */
+                          || (FRAME_WINDOW_P (f1) && !FRAME_WINDOW_P (f))))))
+            return true;
+        }
     }
-  return 0;
+
+  return false;
 }
 
 /* Make sure that minibuf_window doesn't refer to FRAME's minibuffer
@@ -1517,53 +1799,65 @@ check_minibuf_window (Lisp_Object frame, int select)
 }
 
 
-/* Delete FRAME.  When FORCE equals Qnoelisp, delete FRAME
-  unconditionally.  x_connection_closed and delete_terminal use
-  this.  Any other value of FORCE implements the semantics
-  described for Fdelete_frame.  */
+/**
+ * delete_frame:
+ *
+ * Delete FRAME.  When FORCE equals Qnoelisp, delete FRAME
+ * unconditionally.  x_connection_closed and delete_terminal use this.
+ * Any other value of FORCE implements the semantics described for
+ * Fdelete_frame.  */
 Lisp_Object
 delete_frame (Lisp_Object frame, Lisp_Object force)
 {
   struct frame *f = decode_any_frame (frame);
   struct frame *sf;
   struct kboard *kb;
-
+  Lisp_Object frames, frame1;
   int minibuffer_selected, is_tooltip_frame;
+  bool nochild = !FRAME_PARENT_FRAME (f);
 
-  if (! FRAME_LIVE_P (f))
+  if (!FRAME_LIVE_P (f))
     return Qnil;
-
-  if (NILP (force) && !other_visible_frames (f))
-    error ("Attempt to delete the sole visible or iconified frame");
-
-  /* x_connection_closed must have set FORCE to `noelisp' in order
-     to delete the last frame, if it is gone.  */
-  if (NILP (XCDR (Vframe_list)) && !EQ (force, Qnoelisp))
-    error ("Attempt to delete the only frame");
+  else if (!EQ (force, Qnoelisp) && !other_frames (f, false, !NILP (force)))
+    {
+      if (NILP (force))
+        error ("Attempt to delete the sole visible or iconified frame");
+      else
+        error ("Attempt to delete the only frame");
+    }
 
   XSETFRAME (frame, f);
 
+  /* Softly delete all frames with this frame as their parent frame or
+     as their `delete-before' frame parameter value.  */
+  FOR_EACH_FRAME (frames, frame1)
+    if (FRAME_PARENT_FRAME (XFRAME (frame1)) == f
+        /* Process `delete-before' parameter iff FRAME is not a child
+           frame.  This avoids that we enter an infinite chain of mixed
+           dependencies.  */
+        || (nochild
+            && EQ (get_frame_param (XFRAME (frame1), Qdelete_before), frame)))
+      delete_frame (frame1, Qnil);
+
   /* Does this frame have a minibuffer, and is it the surrogate
      minibuffer for any other frame?  */
   if (FRAME_HAS_MINIBUF_P (f))
     {
-      Lisp_Object frames, this;
-
-      FOR_EACH_FRAME (frames, this)
+      FOR_EACH_FRAME (frames, frame1)
         {
           Lisp_Object fminiw;
 
-          if (EQ (this, frame))
+          if (EQ (frame1, frame))
             continue;
 
-          fminiw = FRAME_MINIBUF_WINDOW (XFRAME (this));
+          fminiw = FRAME_MINIBUF_WINDOW (XFRAME (frame1));
 
           if (WINDOWP (fminiw) && EQ (frame, WINDOW_FRAME (XWINDOW (fminiw))))
             {
               /* If we MUST delete this frame, delete the other first.
                  But do this only if FORCE equals `noelisp'.  */
               if (EQ (force, Qnoelisp))
-                delete_frame (this, Qnoelisp);
+                delete_frame (frame1, Qnoelisp);
               else
                 error ("Attempt to delete a surrogate minibuffer frame");
             }
@@ -1592,20 +1886,26 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
       safe_call2 (Qrun_hook_with_args, Qdelete_frame_functions, frame);
     }
 
-  /* The hook may sometimes (indirectly) cause the frame to be deleted.  */
-  if (! FRAME_LIVE_P (f))
+  /* delete_frame_functions may have deleted any frame, including this
+     one.  */
+  if (!FRAME_LIVE_P (f))
     return Qnil;
+  else if (!EQ (force, Qnoelisp) && !other_frames (f, false, !NILP (force)))
+    {
+      if (NILP (force))
+        error ("Attempt to delete the sole visible or iconified frame");
+      else
+        error ("Attempt to delete the only frame");
+    }
 
   /* At this point, we are committed to deleting the frame.
      There is no more chance for errors to prevent it.  */
-
   minibuffer_selected = EQ (minibuf_window, selected_window);
   sf = SELECTED_FRAME ();
   /* Don't let the frame remain selected.  */
   if (f == sf)
     {
       Lisp_Object tail;
-      Lisp_Object frame1 = Qnil;
 
       /* Look for another visible frame on the same terminal.
          Do not call next_frame here because it may loop forever.
@@ -1709,8 +2009,6 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
      promise that the terminal of the frame must be valid until we
      have called the window-system-dependent frame destruction
      routine.  */
-
-
   {
     struct terminal *terminal;
     block_input ();
@@ -1747,16 +2045,15 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
      another one.  */
   if (f == last_nonminibuf_frame)
     {
-      Lisp_Object frames, this;
-
       last_nonminibuf_frame = 0;
 
-      FOR_EACH_FRAME (frames, this)
+      FOR_EACH_FRAME (frames, frame1)
         {
-          f = XFRAME (this);
-          if (!FRAME_MINIBUF_ONLY_P (f))
+          struct frame *f1 = XFRAME (frame1);
+
+          if (!FRAME_MINIBUF_ONLY_P (f1))
             {
-              last_nonminibuf_frame = f;
+              last_nonminibuf_frame = f1;
               break;
             }
         }
@@ -1766,13 +2063,12 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
      single-kboard state if we're in it for this kboard.  */
   if (kb != NULL)
     {
-      Lisp_Object frames, this;
       /* Some frame we found on the same kboard, or nil if there are none.  */
       Lisp_Object frame_on_same_kboard = Qnil;
 
-      FOR_EACH_FRAME (frames, this)
-        if (kb == FRAME_KBOARD (XFRAME (this)))
-          frame_on_same_kboard = this;
+      FOR_EACH_FRAME (frames, frame1)
+        if (kb == FRAME_KBOARD (XFRAME (frame1)))
+          frame_on_same_kboard = frame1;
 
       if (NILP (frame_on_same_kboard))
         not_single_kboard_state (kb);
@@ -1784,29 +2080,27 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
      frames with other windows.  */
   if (kb != NULL && EQ (frame, KVAR (kb, Vdefault_minibuffer_frame)))
     {
-      Lisp_Object frames, this;
-
       /* The last frame we saw with a minibuffer, minibuffer-only or not.  */
       Lisp_Object frame_with_minibuf = Qnil;
       /* Some frame we found on the same kboard, or nil if there are none.  */
       Lisp_Object frame_on_same_kboard = Qnil;
 
-      FOR_EACH_FRAME (frames, this)
+      FOR_EACH_FRAME (frames, frame1)
         {
-          struct frame *f1 = XFRAME (this);
+          struct frame *f1 = XFRAME (frame1);
 
           /* Consider only frames on the same kboard
              and only those with minibuffers.  */
           if (kb == FRAME_KBOARD (f1)
               && FRAME_HAS_MINIBUF_P (f1))
             {
-              frame_with_minibuf = this;
+              frame_with_minibuf = frame1;
               if (FRAME_MINIBUF_ONLY_P (f1))
                 break;
             }
 
           if (kb == FRAME_KBOARD (f1))
-            frame_on_same_kboard = this;
+            frame_on_same_kboard = frame1;
         }
 
       if (!NILP (frame_on_same_kboard))
@@ -1850,8 +2144,101 @@ The functions are run with one argument, the frame to be deleted.  */)
 {
   return delete_frame (frame, !NILP (force) ? Qt : Qnil);
 }
-
 
+#ifdef HAVE_WINDOW_SYSTEM
+/**
+ * frame_internal_border_part:
+ *
+ * Return part of internal border the coordinates X and Y relative to
+ * frame F are on.  Return nil if the coordinates are not on the
+ * internal border of F.
+ *
+ * Return one of INTERNAL_BORDER_LEFT_EDGE, INTERNAL_BORDER_TOP_EDGE,
+ * INTERNAL_BORDER_RIGHT_EDGE or INTERNAL_BORDER_BOTTOM_EDGE when the
+ * mouse cursor is on the corresponding border with an offset of at
+ * least one canonical character height from that border's edges.
+ *
+ * If no border part could be found this way, return one of
+ * INTERNAL_BORDER_TOP_LEFT_CORNER, INTERNAL_BORDER_TOP_RIGHT_CORNER,
+ * INTERNAL_BORDER_BOTTOM_LEFT_CORNER or
+ * INTERNAL_BORDER_BOTTOM_RIGHT_CORNER to indicate that the mouse is in
+ * one of the corresponding corners.  This means that for very small
+ * frames an `edge' return value is preferred.
+ */
+enum internal_border_part
+frame_internal_border_part (struct frame *f, int x, int y)
+{
+  int border = FRAME_INTERNAL_BORDER_WIDTH (f);
+  int offset = FRAME_LINE_HEIGHT (f);
+  int width = FRAME_PIXEL_WIDTH (f);
+  int height = FRAME_PIXEL_HEIGHT (f);
+  enum internal_border_part part = INTERNAL_BORDER_NONE;
+
+  if (offset < border)
+    /* For very wide borders make offset at least as large as
+       border.  */
+    offset = border;
+
+  if (offset < x && x < width - offset)
+    /* Top or bottom border.  */
+    {
+      if (0 <= y && y <= border)
+        part = INTERNAL_BORDER_TOP_EDGE;
+      else if (height - border <= y && y <= height)
+        part = INTERNAL_BORDER_BOTTOM_EDGE;
+    }
+  else if (offset < y && y < height - offset)
+    /* Left or right border.  */
+    {
+      if (0 <= x && x <= border)
+        part = INTERNAL_BORDER_LEFT_EDGE;
+      else if (width - border <= x && x <= width)
+        part = INTERNAL_BORDER_RIGHT_EDGE;
+    }
+  else
+    {
+      /* An edge.  */
+      int half_width = width / 2;
+      int half_height = height / 2;
+
+      if (0 <= x && x <= border)
+        {
+          /* A left edge.  */
+          if (0 <= y && y <= half_height)
+             part = INTERNAL_BORDER_TOP_LEFT_CORNER;
+          else if (half_height < y && y <= height)
+             part = INTERNAL_BORDER_BOTTOM_LEFT_CORNER;
+        }
+      else if (width - border <= x && x <= width)
+        {
+          /* A right edge.  */
+          if (0 <= y && y <= half_height)
+             part = INTERNAL_BORDER_TOP_RIGHT_CORNER;
+          else if (half_height < y && y <= height)
+             part = INTERNAL_BORDER_BOTTOM_RIGHT_CORNER;
+        }
+      else if (0 <= y && y <= border)
+        {
+          /* A top edge.  */
+          if (0 <= x && x <= half_width)
+             part = INTERNAL_BORDER_TOP_LEFT_CORNER;
+          else if (half_width < x && x <= width)
+            part = INTERNAL_BORDER_TOP_RIGHT_CORNER;
+        }
+      else if (height - border <= y && y <= height)
+        {
+          /* A bottom edge.  */
+          if (0 <= x && x <= half_width)
+             part = INTERNAL_BORDER_BOTTOM_LEFT_CORNER;
+          else if (half_width < x && x <= width)
+            part = INTERNAL_BORDER_BOTTOM_RIGHT_CORNER;
+        }
+    }
+
+  return part;
+}
+#endif
+
 /* Return mouse position in character cell units.  */
 
 DEFUN ("mouse-position", Fmouse_position, Smouse_position, 0, 0, 0,
@@ -2119,7 +2506,7 @@ displayed in the terminal.  */)
 {
   struct frame *f = decode_live_frame (frame);
 
-  if (NILP (force) && !other_visible_frames (f))
+  if (NILP (force) && !other_frames (f, true, false))
     error ("Attempt to make invisible the sole visible or iconified frame");
 
   /* Don't allow minibuf_window to remain on an invisible frame.  */
@@ -2292,14 +2679,16 @@ See `redirect-frame-focus'.  */)
   return FRAME_FOCUS_FRAME (decode_live_frame (frame));
 }
 
-DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
+DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 2, 0,
        doc: /* Set the input focus to FRAME.
-FRAME nil means use the selected frame.
+FRAME nil means use the selected frame.  Optional argument NOACTIVATE
+means do not activate FRAME.
+
 If there is no window system support, this function does nothing.  */)
-  (Lisp_Object frame)
+     (Lisp_Object frame, Lisp_Object noactivate)
 {
 #ifdef HAVE_WINDOW_SYSTEM
-  x_focus_frame (decode_window_system_frame (frame));
+  x_focus_frame (decode_window_system_frame (frame), !NILP (noactivate));
 #endif
   return Qnil;
 }
@@ -2454,9 +2843,39 @@ store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
         }
     }
 
+  /* Check each parent-frame and delete-before parameter for a
+     circular dependency.  Do not check between parameters, so you can
+     still create circular dependencies with different properties, for
+     example a chain of frames F1->F2->...Fn such that F1 is an ancestor
+     frame of Fn and thus cannot be deleted before Fn and a second chain
+     Fn->Fn-1->...F1 such that Fn cannot be deleted before F1.  */
+  else if (EQ (prop, Qparent_frame) || EQ (prop, Qdelete_before))
+    {
+      Lisp_Object oldval = Fcdr (Fassq (prop, f->param_alist));
+
+      if (!EQ (oldval, val) && !NILP (val))
+        {
+          Lisp_Object frame;
+          Lisp_Object frame1 = val;
+
+          if (!FRAMEP (frame1) || !FRAME_LIVE_P (XFRAME (frame1)))
+            error ("Invalid `%s' frame parameter",
+                   SSDATA (SYMBOL_NAME (prop)));
+
+          XSETFRAME (frame, f);
+
+          while (FRAMEP (frame1) && FRAME_LIVE_P (XFRAME (frame1)))
+            if (EQ (frame1, frame))
+              error ("Circular specification of `%s' frame parameter",
+                     SSDATA (SYMBOL_NAME (prop)));
+            else
+              frame1 = get_frame_param (XFRAME (frame1), prop);
+        }
+    }
+
   /* The buffer-list parameters are stored in a special place and not
      in the alist.  All buffers must be live.  */
-  if (EQ (prop, Qbuffer_list))
+  else if (EQ (prop, Qbuffer_list))
     {
       Lisp_Object list = Qnil;
       for (; CONSP (val); val = XCDR (val))
@@ -2465,7 +2884,7 @@ store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
       fset_buffer_list (f, Fnreverse (list));
       return;
     }
-  if (EQ (prop, Qburied_buffer_list))
+  else if (EQ (prop, Qburied_buffer_list))
     {
       Lisp_Object list = Qnil;
       for (; CONSP (val); val = XCDR (val))
@@ -2776,49 +3195,47 @@ For a terminal screen, the value is always 1.  */)
     return make_number (1);
 }
 
-DEFUN ("frame-pixel-height", Fframe_pixel_height,
-       Sframe_pixel_height, 0, 1, 0,
-       doc: /* Return a FRAME's height in pixels.
-If FRAME is omitted or nil, the selected frame is used.  The exact value
-of the result depends on the window-system and toolkit in use:
-
-In the Gtk+ version of Emacs, it includes only any window (including
-the minibuffer or echo area), mode line, and header line.  It does not
-include the tool bar or menu bar.
-
-With other graphical versions, it also includes the tool bar and the
-menu bar.
-
-For a text terminal, it includes the menu bar.  In this case, the
-result is really in characters rather than pixels (i.e., is identical
-to `frame-height'). */)
+DEFUN ("frame-native-width", Fframe_native_width,
+       Sframe_native_width, 0, 1, 0,
+       doc: /* Return FRAME's native width in pixels.
+For a terminal frame, the result really gives the width in characters.
+If FRAME is omitted or nil, the selected frame is used.  */)
   (Lisp_Object frame)
 {
   struct frame *f = decode_any_frame (frame);
 
 #ifdef HAVE_WINDOW_SYSTEM
   if (FRAME_WINDOW_P (f))
-    return make_number (FRAME_PIXEL_HEIGHT (f));
+    return make_number (FRAME_PIXEL_WIDTH (f));
   else
 #endif
-    return make_number (FRAME_TOTAL_LINES (f));
+    return make_number (FRAME_TOTAL_COLS (f));
 }
 
-DEFUN ("frame-pixel-width", Fframe_pixel_width,
-       Sframe_pixel_width, 0, 1, 0,
-       doc: /* Return FRAME's width in pixels.
-For a terminal frame, the result really gives the width in characters.
-If FRAME is omitted or nil, the selected frame is used.  */)
+DEFUN ("frame-native-height", Fframe_native_height,
+       Sframe_native_height, 0, 1, 0,
+       doc: /* Return FRAME's native height in pixels.
+If FRAME is omitted or nil, the selected frame is used.  The exact value
+of the result depends on the window-system and toolkit in use:
+
+In the Gtk+ and NS versions, it includes only any window (including the
+minibuffer or echo area), mode line, and header line.  It does not
+include the tool bar or menu bar.  With other graphical versions, it may
+also include the tool bar and the menu bar.
+
+For a text terminal, it includes the menu bar.  In this case, the
+result is really in characters rather than pixels (i.e., is identical
+to `frame-height'). */)
   (Lisp_Object frame)
 {
   struct frame *f = decode_any_frame (frame);
 
 #ifdef HAVE_WINDOW_SYSTEM
   if (FRAME_WINDOW_P (f))
-    return make_number (FRAME_PIXEL_WIDTH (f));
+    return make_number (FRAME_PIXEL_HEIGHT (f));
   else
 #endif
-    return make_number (FRAME_TOTAL_COLS (f));
+    return make_number (FRAME_TOTAL_LINES (f));
 }
 
 DEFUN ("tool-bar-pixel-width", Ftool_bar_pixel_width,
@@ -2901,8 +3318,8 @@ DEFUN ("frame-fringe-width", Ffringe_width, Sfringe_width, 0, 1, 0,
   return make_number (FRAME_TOTAL_FRINGE_WIDTH (decode_any_frame (frame)));
 }
 
-DEFUN ("frame-border-width", Fborder_width, Sborder_width, 0, 1, 0,
-       doc: /* Return border width of FRAME in pixels.  */)
+DEFUN ("frame-internal-border-width", Fframe_internal_border_width, Sframe_internal_border_width, 0, 1, 0,
+       doc: /* Return width of FRAME's internal border in pixels.  */)
   (Lisp_Object frame)
 {
   return make_number (FRAME_INTERNAL_BORDER_WIDTH (decode_any_frame (frame)));
@@ -3038,7 +3455,6 @@ bottom edge of FRAME's display.  */)
 
   return Qt;
 }
-
 
 /***********************************************************************
                                 Frame Parameters
@@ -3096,10 +3512,200 @@ static const struct frame_parm_table frame_parms[] =
   {"sticky",                    SYMBOL_INDEX (Qsticky)},
   {"tool-bar-position",         SYMBOL_INDEX (Qtool_bar_position)},
   {"inhibit-double-buffering",  SYMBOL_INDEX (Qinhibit_double_buffering)},
+  {"undecorated",               SYMBOL_INDEX (Qundecorated)},
+  {"parent-frame",              SYMBOL_INDEX (Qparent_frame)},
+  {"skip-taskbar",              SYMBOL_INDEX (Qskip_taskbar)},
+  {"no-focus-on-map",           SYMBOL_INDEX (Qno_focus_on_map)},
+  {"no-accept-focus",           SYMBOL_INDEX (Qno_accept_focus)},
+  {"z-group",                   SYMBOL_INDEX (Qz_group)},
+  {"override-redirect",         SYMBOL_INDEX (Qoverride_redirect)},
+  {"no-special-glyphs",         SYMBOL_INDEX (Qno_special_glyphs)},
 };
 
 #ifdef HAVE_WINDOW_SYSTEM
 
+/* Enumeration type for switch in frame_float.  */
+enum frame_float_type
+{
+ FRAME_FLOAT_WIDTH,
+ FRAME_FLOAT_HEIGHT,
+ FRAME_FLOAT_LEFT,
+ FRAME_FLOAT_TOP
+};
+
+/**
+ * frame_float:
+ *
+ * Process the value VAL of the float type frame parameter 'width',
+ * 'height', 'left', or 'top' specified via a frame_float_type
+ * enumeration type WHAT for frame F.  Such parameters relate the outer
+ * size or position of F to the size of the F's display or parent frame
+ * which have to be both available in some way.
+ *
+ * The return value is a size or position value in pixels.  VAL must be
+ * in the range 0.0 to 1.0 where a width/height of 0.0 means to return 0
+ * and 1.0 means to return the full width/height of the display/parent.
+ * For positions, 0.0 means position in the left/top corner of the
+ * display/parent while 1.0 means to position at the right/bottom corner
+ * of the display/parent frame.
+ *
+ * Set PARENT_DONE and OUTER_DONE to avoid recalculation of the outer
+ * size or parent or display attributes when more float parameters are
+ * calculated in a row: -1 means not processed yet, 0 means processing
+ * failed, 1 means processing succeeded.
+ *
+ * Return DEFAULT_VALUE when processing fails for whatever reason with
+ * one exception: When calculating F's outer edges fails (probably
+ * because F has not been created yet) return the difference between F's
+ * native and text size.
+ */
+static int
+frame_float (struct frame *f, Lisp_Object val, enum frame_float_type what,
+             int *parent_done, int *outer_done, int default_value)
+{
+  double d_val = XFLOAT_DATA (val);
+
+  if (d_val < 0.0 || d_val > 1.0)
+    /* Invalid VAL.  */
+    return default_value;
+  else
+    {
+      static unsigned parent_width, parent_height;
+      static int parent_left, parent_top;
+      static unsigned outer_minus_text_width, outer_minus_text_height;
+      struct frame *p = FRAME_PARENT_FRAME (f);
+
+      if (*parent_done == 1)
+        ;
+      else if (p)
+        {
+          parent_width = FRAME_PIXEL_WIDTH (p);
+          parent_height = FRAME_PIXEL_HEIGHT (p);
+          *parent_done = 1;
+        }
+      else
+        {
+          if (*parent_done == 0)
+            /* No workarea available.  */
+            return default_value;
+          else if (*parent_done == -1)
+            {
+              Lisp_Object monitor_attributes;
+              Lisp_Object workarea;
+              Lisp_Object frame;
+
+              XSETFRAME (frame, f);
+              monitor_attributes = Fcar (call1 (Qdisplay_monitor_attributes_list, frame));
+              if (NILP (monitor_attributes))
+                {
+                  /* No monitor attributes available.  */
+                  *parent_done = 0;
+
+                  return default_value;
+                }
+
+              workarea = Fcdr (Fassq (Qworkarea, monitor_attributes));
+              if (NILP (workarea))
+                {
+                  /* No workarea available.  */
+                  *parent_done = 0;
+
+                  return default_value;
+                }
+
+              /* Workarea available.  */
+              parent_left = XINT (Fnth (make_number (0), workarea));
+              parent_top = XINT (Fnth (make_number (1), workarea));
+              parent_width = XINT (Fnth (make_number (2), workarea));
+              parent_height = XINT (Fnth (make_number (3), workarea));
+              *parent_done = 1;
+            }
+        }
+
+      if (*outer_done == 1)
+        ;
+      else if (FRAME_UNDECORATED (f))
+        {
+          outer_minus_text_width
+            = FRAME_PIXEL_WIDTH (f) - FRAME_TEXT_WIDTH (f);
+          outer_minus_text_height
+            = FRAME_PIXEL_HEIGHT (f) - FRAME_TEXT_HEIGHT (f);
+          *outer_done = 1;
+        }
+      else if (*outer_done == 0)
+        /* No outer size available.  */
+        return default_value;
+      else if (*outer_done == -1)
+        {
+          Lisp_Object frame, outer_edges;
+
+          XSETFRAME (frame, f);
+          outer_edges = call2 (Qframe_edges, frame, Qouter_edges);
+
+          if (!NILP (outer_edges))
+            {
+              outer_minus_text_width
+                = (XINT (Fnth (make_number (2), outer_edges))
+                   - XINT (Fnth (make_number (0), outer_edges))
+                   - FRAME_TEXT_WIDTH (f));
+              outer_minus_text_height
+                = (XINT (Fnth (make_number (3), outer_edges))
+                   - XINT (Fnth (make_number (1), outer_edges))
+                   - FRAME_TEXT_HEIGHT (f));
+            }
+          else
+            {
+              /* If we can't get any outer edges, proceed as if the frame
+                 were undecorated.  */
+              outer_minus_text_width
+                = FRAME_PIXEL_WIDTH (f) - FRAME_TEXT_WIDTH (f);
+              outer_minus_text_height
+                = FRAME_PIXEL_HEIGHT (f) - FRAME_TEXT_HEIGHT (f);
+            }
+
+          *outer_done = 1;
+        }
+
+      switch (what)
+        {
+        case FRAME_FLOAT_WIDTH:
+          return parent_width * d_val - outer_minus_text_width;
+
+        case FRAME_FLOAT_HEIGHT:
+          return parent_height * d_val - outer_minus_text_height;
+
+        case FRAME_FLOAT_LEFT:
+          {
+            int rest_width = (parent_width
+                              - FRAME_TEXT_WIDTH (f)
+                              - outer_minus_text_width);
+
+            if (p)
+              return (rest_width <= 0 ? 0 : d_val * rest_width);
+            else
+              return (rest_width <= 0
+                      ? parent_left
+                      : parent_left + d_val * rest_width);
+          }
+        case FRAME_FLOAT_TOP:
+          {
+            int rest_height = (parent_height
+                               - FRAME_TEXT_HEIGHT (f)
+                               - outer_minus_text_height);
+
+            if (p)
+              return (rest_height <= 0 ? 0 : d_val * rest_height);
+            else
+              return (rest_height <= 0
+                      ? parent_top
+                      : parent_top + d_val * rest_height);
+          }
+        default:
+          emacs_abort ();
+        }
+    }
+}
+
 /* Change the parameters of frame F as specified by ALIST.
    If a parameter is not specially recognized, do nothing special;
    otherwise call the `x_set_...' function for that parameter.
@@ -3109,7 +3715,8 @@ static const struct frame_parm_table frame_parms[] =
 void
 x_set_frame_parameters (struct frame *f, Lisp_Object alist)
 {
-  Lisp_Object tail;
+  Lisp_Object tail, frame;
+
 
   /* If both of these parameters are present, it's more efficient to
      set them both at once.  So we wait until we've looked at the
@@ -3134,7 +3741,9 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
 #ifdef HAVE_X_WINDOWS
   bool icon_left_no_change = 0, icon_top_no_change = 0;
 #endif
+  int parent_done = -1, outer_done = -1;
 
+  XSETFRAME (frame, f);
   for (size = 0, tail = alist; CONSP (tail); tail = XCDR (tail))
     size++;
   CHECK_LIST_END (tail, alist);
@@ -3195,6 +3804,9 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
           else if (CONSP (val) && EQ (XCAR (val), Qtext_pixels)
                    && RANGED_INTEGERP (0, XCDR (val), INT_MAX))
             width = XFASTINT (XCDR (val));
+          else if (FLOATP (val))
+            width = frame_float (f, val, FRAME_FLOAT_WIDTH, &parent_done,
+                                 &outer_done, -1);
         }
       else if (EQ (prop, Qheight))
         {
@@ -3203,6 +3815,9 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
           else if (CONSP (val) && EQ (XCAR (val), Qtext_pixels)
                    && RANGED_INTEGERP (0, XCDR (val), INT_MAX))
             height = XFASTINT (XCDR (val));
+          else if (FLOATP (val))
+            height = frame_float (f, val, FRAME_FLOAT_HEIGHT, &parent_done,
+                                 &outer_done, -1);
         }
       else if (EQ (prop, Qtop))
         top = val;
@@ -3279,105 +3894,100 @@ x_set_frame_parameters (struct frame *f, Lisp_Object alist)
      Don't set these parameters unless they actually differ from the
      window's current parameters; the window may not actually exist
      yet.  */
-  {
-    Lisp_Object frame;
-
-    XSETFRAME (frame, f);
-
-    if ((width != -1 && width != FRAME_TEXT_WIDTH (f))
-        || (height != -1 && height != FRAME_TEXT_HEIGHT (f)))
-      /* We could consider checking f->after_make_frame here, but I
-         don't have the faintest idea why the following is needed at
-         all.  With the old setting it can get a Heisenbug when
-         EmacsFrameResize intermittently provokes a delayed
-         change_frame_size in the middle of adjust_frame_size.  */
-      /**       || (f->can_x_set_window_size && (f->new_height || f->new_width))) **/
-      adjust_frame_size (f, width, height, 1, 0, Qx_set_frame_parameters);
-
-    if ((!NILP (left) || !NILP (top))
-        && ! (left_no_change && top_no_change)
-        && ! (NUMBERP (left) && XINT (left) == f->left_pos
-              && NUMBERP (top) && XINT (top) == f->top_pos))
-      {
-        int leftpos = 0;
-        int toppos = 0;
+  if ((width != -1 && width != FRAME_TEXT_WIDTH (f))
+      || (height != -1 && height != FRAME_TEXT_HEIGHT (f)))
+    /* We could consider checking f->after_make_frame here, but I
+       don't have the faintest idea why the following is needed at
+       all.  With the old setting it can get a Heisenbug when
+       EmacsFrameResize intermittently provokes a delayed
+       change_frame_size in the middle of adjust_frame_size.  */
+    /**         || (f->can_x_set_window_size && (f->new_height || f->new_width))) **/
+    adjust_frame_size (f, width, height, 1, 0, Qx_set_frame_parameters);
+
+  if ((!NILP (left) || !NILP (top))
+      && ! (left_no_change && top_no_change)
+      && ! (NUMBERP (left) && XINT (left) == f->left_pos
+            && NUMBERP (top) && XINT (top) == f->top_pos))
+    {
+      int leftpos = 0;
+      int toppos = 0;
 
-        /* Record the signs.  */
-        f->size_hint_flags &= ~ (XNegative | YNegative);
-        if (EQ (left, Qminus))
-          f->size_hint_flags |= XNegative;
-        else if (TYPE_RANGED_INTEGERP (int, left))
-          {
-            leftpos = XINT (left);
-            if (leftpos < 0)
-              f->size_hint_flags |= XNegative;
-          }
-        else if (CONSP (left) && EQ (XCAR (left), Qminus)
-                 && CONSP (XCDR (left))
-                 && RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (left)), INT_MAX))
-          {
-            leftpos = - XINT (XCAR (XCDR (left)));
+      /* Record the signs.  */
+      f->size_hint_flags &= ~ (XNegative | YNegative);
+      if (EQ (left, Qminus))
+        f->size_hint_flags |= XNegative;
+      else if (TYPE_RANGED_INTEGERP (int, left))
+        {
+          leftpos = XINT (left);
+          if (leftpos < 0)
             f->size_hint_flags |= XNegative;
-          }
-        else if (CONSP (left) && EQ (XCAR (left), Qplus)
-                 && CONSP (XCDR (left))
-                 && TYPE_RANGED_INTEGERP (int, XCAR (XCDR (left))))
-          {
-            leftpos = XINT (XCAR (XCDR (left)));
-          }
+        }
+      else if (CONSP (left) && EQ (XCAR (left), Qminus)
+               && CONSP (XCDR (left))
+               && RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (left)), INT_MAX))
+        {
+          leftpos = - XINT (XCAR (XCDR (left)));
+          f->size_hint_flags |= XNegative;
+        }
+      else if (CONSP (left) && EQ (XCAR (left), Qplus)
+               && CONSP (XCDR (left))
+               && TYPE_RANGED_INTEGERP (int, XCAR (XCDR (left))))
+        leftpos = XINT (XCAR (XCDR (left)));
+      else if (FLOATP (left))
+        leftpos = frame_float (f, left, FRAME_FLOAT_LEFT, &parent_done,
+                               &outer_done, 0);
 
-        if (EQ (top, Qminus))
-          f->size_hint_flags |= YNegative;
-        else if (TYPE_RANGED_INTEGERP (int, top))
-          {
-            toppos = XINT (top);
-            if (toppos < 0)
-              f->size_hint_flags |= YNegative;
-          }
-        else if (CONSP (top) && EQ (XCAR (top), Qminus)
-                 && CONSP (XCDR (top))
-                 && RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (top)), INT_MAX))
-          {
-            toppos = - XINT (XCAR (XCDR (top)));
+      if (EQ (top, Qminus))
+        f->size_hint_flags |= YNegative;
+      else if (TYPE_RANGED_INTEGERP (int, top))
+        {
+          toppos = XINT (top);
+          if (toppos < 0)
             f->size_hint_flags |= YNegative;
-          }
-        else if (CONSP (top) && EQ (XCAR (top), Qplus)
-                 && CONSP (XCDR (top))
-                 && TYPE_RANGED_INTEGERP (int, XCAR (XCDR (top))))
-          {
-            toppos = XINT (XCAR (XCDR (top)));
-          }
-
+        }
+      else if (CONSP (top) && EQ (XCAR (top), Qminus)
+               && CONSP (XCDR (top))
+               && RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (top)), INT_MAX))
+        {
+          toppos = - XINT (XCAR (XCDR (top)));
+          f->size_hint_flags |= YNegative;
+        }
+      else if (CONSP (top) && EQ (XCAR (top), Qplus)
+               && CONSP (XCDR (top))
+               && TYPE_RANGED_INTEGERP (int, XCAR (XCDR (top))))
+        toppos = XINT (XCAR (XCDR (top)));
+      else if (FLOATP (top))
+        toppos = frame_float (f, top, FRAME_FLOAT_TOP, &parent_done,
+                              &outer_done, 0);
 
-        /* Store the numeric value of the position.  */
-        f->top_pos = toppos;
-        f->left_pos = leftpos;
+      /* Store the numeric value of the position.  */
+      f->top_pos = toppos;
+      f->left_pos = leftpos;
 
-        f->win_gravity = NorthWestGravity;
+      f->win_gravity = NorthWestGravity;
 
-        /* Actually set that position, and convert to absolute.  */
-        x_set_offset (f, leftpos, toppos, -1);
-      }
+      /* Actually set that position, and convert to absolute.  */
+      x_set_offset (f, leftpos, toppos, -1);
+    }
 
-    if (fullscreen_change)
-      {
-        Lisp_Object old_value = get_frame_param (f, Qfullscreen);
+  if (fullscreen_change)
+    {
+      Lisp_Object old_value = get_frame_param (f, Qfullscreen);
 
-        frame_size_history_add
-          (f, Qx_set_fullscreen, 0, 0, list2 (old_value, fullscreen));
+      frame_size_history_add
+        (f, Qx_set_fullscreen, 0, 0, list2 (old_value, fullscreen));
 
-        store_frame_param (f, Qfullscreen, fullscreen);
-        if (!EQ (fullscreen, old_value))
-          x_set_fullscreen (f, fullscreen, old_value);
-      }
+      store_frame_param (f, Qfullscreen, fullscreen);
+      if (!EQ (fullscreen, old_value))
+        x_set_fullscreen (f, fullscreen, old_value);
+    }
 
 
 #ifdef HAVE_X_WINDOWS
-    if ((!NILP (icon_left) || !NILP (icon_top))
-        && ! (icon_left_no_change && icon_top_no_change))
-      x_wm_set_icon_position (f, XINT (icon_left), XINT (icon_top));
+  if ((!NILP (icon_left) || !NILP (icon_top))
+      && ! (icon_left_no_change && icon_top_no_change))
+    x_wm_set_icon_position (f, XINT (icon_left), XINT (icon_top));
 #endif /* HAVE_X_WINDOWS */
-  }
 
   SAFE_FREE ();
 }
@@ -3797,7 +4407,6 @@ x_set_right_divider_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
       adjust_frame_glyphs (f);
       SET_FRAME_GARBAGED (f);
     }
-
 }
 
 void
@@ -4011,6 +4620,22 @@ x_set_alpha (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
   return;
 }
 
+
+/**
+ * x_set_no_special_glyphs:
+ *
+ * Set frame F's `no-special-glyphs' parameter which, if non-nil,
+ * suppresses the display of truncation and continuation glyphs
+ * outside fringes.
+ */
+void
+x_set_no_special_glyphs (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  if (!EQ (new_value, old_value))
+    FRAME_NO_SPECIAL_GLYPHS (f) = !NILP (new_value);
+}
+
+
 #ifndef HAVE_NS
 
 /* Non-zero if mouse is grabbed on DPYINFO
@@ -4566,6 +5191,7 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
   Lisp_Object height, width, user_size, top, left, user_position;
   long window_prompting = 0;
   Display_Info *dpyinfo = FRAME_DISPLAY_INFO (f);
+  int parent_done = -1, outer_done = -1;
 
   /* Default values if we fall through.
      Actually, if that happens we should get
@@ -4630,6 +5256,21 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
               f->inhibit_horizontal_resize = true;
               *x_width = XINT (XCDR (width));
             }
+          else if (FLOATP (width))
+            {
+              double d_width = XFLOAT_DATA (width);
+
+              if (d_width < 0.0 || d_width > 1.0)
+                xsignal1 (Qargs_out_of_range, width);
+              else
+                {
+                  int new_width = frame_float (f, width, FRAME_FLOAT_WIDTH,
+                                               &parent_done, &outer_done, -1);
+
+                  if (new_width > -1)
+                    SET_FRAME_WIDTH (f, new_width);
+                }
+            }
           else
             {
               CHECK_NUMBER (width);
@@ -4652,6 +5293,21 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
               f->inhibit_vertical_resize = true;
               *x_height = XINT (XCDR (height));
             }
+          else if (FLOATP (height))
+            {
+              double d_height = XFLOAT_DATA (height);
+
+              if (d_height < 0.0 || d_height > 1.0)
+                xsignal1 (Qargs_out_of_range, height);
+              else
+                {
+                  int new_height = frame_float (f, height, FRAME_FLOAT_HEIGHT,
+                                                &parent_done, &outer_done, -1);
+
+                  if (new_height > -1)
+                    SET_FRAME_HEIGHT (f, new_height);
+                }
+            }
           else
             {
               CHECK_NUMBER (height);
@@ -4692,6 +5348,9 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
         {
           f->top_pos = XINT (XCAR (XCDR (top)));
         }
+      else if (FLOATP (top))
+        f->top_pos = frame_float (f, top, FRAME_FLOAT_TOP, &parent_done,
+                                  &outer_done, 0);
       else if (EQ (top, Qunbound))
         f->top_pos = 0;
       else
@@ -4720,6 +5379,9 @@ x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p, int *x
         {
           f->left_pos = XINT (XCAR (XCDR (left)));
         }
+      else if (FLOATP (left))
+        f->left_pos = frame_float (f, left, FRAME_FLOAT_LEFT, &parent_done,
+                                   &outer_done, 0);
       else if (EQ (left, Qunbound))
         f->left_pos = 0;
       else
@@ -4878,11 +5540,21 @@ syms_of_frame (void)
   DEFSYM (Qframep, "framep");
   DEFSYM (Qframe_live_p, "frame-live-p");
   DEFSYM (Qframe_windows_min_size, "frame-windows-min-size");
+  DEFSYM (Qdisplay_monitor_attributes_list, "display-monitor-attributes-list");
   DEFSYM (Qwindow__pixel_to_total, "window--pixel-to-total");
   DEFSYM (Qexplicit_name, "explicit-name");
   DEFSYM (Qheight, "height");
   DEFSYM (Qicon, "icon");
   DEFSYM (Qminibuffer, "minibuffer");
+  DEFSYM (Qundecorated, "undecorated");
+  DEFSYM (Qno_special_glyphs, "no-special-glyphs");
+  DEFSYM (Qparent_frame, "parent-frame");
+  DEFSYM (Qskip_taskbar, "skip-taskbar");
+  DEFSYM (Qno_focus_on_map, "no-focus-on-map");
+  DEFSYM (Qno_accept_focus, "no-accept-focus");
+  DEFSYM (Qz_group, "z-group");
+  DEFSYM (Qoverride_redirect, "override-redirect");
+  DEFSYM (Qdelete_before, "delete-before");
   DEFSYM (Qmodeline, "modeline");
   DEFSYM (Qonly, "only");
   DEFSYM (Qnone, "none");
@@ -4923,13 +5595,12 @@ syms_of_frame (void)
   DEFSYM (Qx_resource_name, "x-resource-name");
   DEFSYM (Qx_frame_parameter, "x-frame-parameter");
 
-  DEFSYM (Qterminal, "terminal");
-
   DEFSYM (Qworkarea, "workarea");
   DEFSYM (Qmm_size, "mm-size");
   DEFSYM (Qframes, "frames");
   DEFSYM (Qsource, "source");
 
+  DEFSYM (Qframe_edges, "frame-edges");
   DEFSYM (Qouter_edges, "outer-edges");
   DEFSYM (Qouter_position, "outer-position");
   DEFSYM (Qouter_size, "outer-size");
@@ -4981,6 +5652,7 @@ syms_of_frame (void)
   DEFSYM (Qauto_raise, "auto-raise");
   DEFSYM (Qborder_color, "border-color");
   DEFSYM (Qborder_width, "border-width");
+  DEFSYM (Qouter_border_width, "outer-border-width");
   DEFSYM (Qbottom_divider_width, "bottom-divider-width");
   DEFSYM (Qcursor_color, "cursor-color");
   DEFSYM (Qcursor_type, "cursor-type");
@@ -5014,6 +5686,17 @@ syms_of_frame (void)
   DEFSYM (Qvisibility, "visibility");
   DEFSYM (Qwait_for_wm, "wait-for-wm");
   DEFSYM (Qinhibit_double_buffering, "inhibit-double-buffering");
+  DEFSYM (Qno_other_frame, "no-other-frame");
+  DEFSYM (Qbelow, "below");
+  DEFSYM (Qabove_suspended, "above-suspended");
+  DEFSYM (Qmin_width, "min-width");
+  DEFSYM (Qmin_height, "min-height");
+  DEFSYM (Qmouse_wheel_frame, "mouse-wheel-frame");
+  DEFSYM (Qkeep_ratio, "keep-ratio");
+  DEFSYM (Qwidth_only, "width-only");
+  DEFSYM (Qheight_only, "height-only");
+  DEFSYM (Qleft_only, "left-only");
+  DEFSYM (Qtop_only, "top-only");
 
   {
     int i;
@@ -5123,13 +5806,19 @@ The pointer becomes visible again when the mouse is moved.  */);
   Vmake_pointer_invisible = Qt;
 
   DEFVAR_LISP ("focus-in-hook", Vfocus_in_hook,
-               doc: /* Normal hook run when a frame gains input focus.  */);
+               doc: /* Normal hook run when a frame gains input focus.
+The frame gaining focus is selected at the time this hook is run.  */);
   Vfocus_in_hook = Qnil;
 
   DEFVAR_LISP ("focus-out-hook", Vfocus_out_hook,
-               doc: /* Normal hook run when a frame loses input focus.  */);
+               doc: /* Normal hook run when all frames lost input focus.  */);
   Vfocus_out_hook = Qnil;
 
+  DEFVAR_LISP ("move-frame-functions", Vmove_frame_functions,
+               doc: /* Functions run after a frame was moved.
+The functions are run with one arg, the frame that moved.  */);
+  Vmove_frame_functions = Qnil;
+
   DEFVAR_LISP ("delete-frame-functions", Vdelete_frame_functions,
                doc: /* Functions run before deleting a frame.
 The functions are run with one arg, the frame to be deleted.
@@ -5176,12 +5865,51 @@ displayed.
 
 This variable is local to the current terminal and cannot be buffer-local.  */);
 
-  DEFVAR_BOOL ("focus-follows-mouse", focus_follows_mouse,
+  DEFVAR_LISP ("focus-follows-mouse", focus_follows_mouse,
                doc: /* Non-nil if window system changes focus when you move the mouse.
 You should set this variable to tell Emacs how your window manager
 handles focus, since there is no way in general for Emacs to find out
-automatically.  See also `mouse-autoselect-window'.  */);
-  focus_follows_mouse = 0;
+automatically.
+
+There are three meaningful values:
+
+- The default nil should be used when your window manager follows a
+  "click-to-focus" policy where you have to click the mouse inside of a
+  frame in order for that frame to get focus.
+
+- The value t should be used when your window manager has the focus
+  automatically follow the position of the mouse pointer but a window
+  that gains focus is not raised automatically.
+
+- The value `auto-raise' should be used when your window manager has the
+  focus automatically follow the position of the mouse pointer and a
+  window that gains focus is raised automatically.
+
+If this option is non-nil, Emacs moves the mouse pointer to the frame
+selected by `select-frame-set-input-focus'.  This function is used by a
+number of commands like, for example, `other-frame' and `pop-to-buffer'.
+If this option is nil and your focus follows mouse window manager does
+not autonomously move the mouse pointer to the newly selected frame, the
+previously selected window manager window might get reselected instead
+immediately.
+
+The distinction between the values t and `auto-raise' is not needed for
+"normal" frames because the window manager takes care of raising them.
+Setting this to `auto-raise' will, however, override the standard
+behavior of a window manager that does not automatically raise the frame
+that gets focus.  Setting this to `auto-raise' is also necessary to
+automatically raise child frames which are usually left alone by the
+window manager.
+
+Note that this option does not distinguish "sloppy" focus (where the
+frame that previously had focus retains focus as long as the mouse
+pointer does not move into another window manager window) from "strict"
+focus (where a frame immediately loses focus when it's left by the mouse
+pointer).
+
+In order to extend a "focus follows mouse" policy to individual Emacs
+windows, customize the variable `mouse-autoselect-window'.  */);
+  focus_follows_mouse = Qnil;
 
   DEFVAR_BOOL ("frame-resize-pixelwise", frame_resize_pixelwise,
                doc: /* Non-nil means resize frames pixelwise.
@@ -5283,6 +6011,8 @@ Gtk+ tooltips are not used) and on Windows.  */);
   defsubr (&Sselect_frame);
   defsubr (&Sselected_frame);
   defsubr (&Sframe_list);
+  defsubr (&Sframe_parent);
+  defsubr (&Sframe_ancestor_p);
   defsubr (&Snext_frame);
   defsubr (&Sprevious_frame);
   defsubr (&Slast_nonminibuf_frame);
@@ -5311,8 +6041,8 @@ Gtk+ tooltips are not used) and on Windows.  */);
   defsubr (&Smodify_frame_parameters);
   defsubr (&Sframe_char_height);
   defsubr (&Sframe_char_width);
-  defsubr (&Sframe_pixel_height);
-  defsubr (&Sframe_pixel_width);
+  defsubr (&Sframe_native_height);
+  defsubr (&Sframe_native_width);
   defsubr (&Sframe_text_cols);
   defsubr (&Sframe_text_lines);
   defsubr (&Sframe_total_cols);
@@ -5322,7 +6052,7 @@ Gtk+ tooltips are not used) and on Windows.  */);
   defsubr (&Sscroll_bar_width);
   defsubr (&Sscroll_bar_height);
   defsubr (&Sfringe_width);
-  defsubr (&Sborder_width);
+  defsubr (&Sframe_internal_border_width);
   defsubr (&Sright_divider_width);
   defsubr (&Sbottom_divider_width);
   defsubr (&Stool_bar_pixel_width);
diff --git a/src/frame.h b/src/frame.h
index 5f18901a17c..154dc9a3bb4 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -45,6 +45,26 @@ enum fullscreen_type
 #endif
 };
 
+enum z_group
+{
+  z_group_none,
+  z_group_above,
+  z_group_below,
+  z_group_above_suspended,
+};
+
+enum internal_border_part
+  {
+   INTERNAL_BORDER_NONE,
+   INTERNAL_BORDER_LEFT_EDGE,
+   INTERNAL_BORDER_TOP_LEFT_CORNER,
+   INTERNAL_BORDER_TOP_EDGE,
+   INTERNAL_BORDER_TOP_RIGHT_CORNER,
+   INTERNAL_BORDER_RIGHT_EDGE,
+   INTERNAL_BORDER_BOTTOM_RIGHT_CORNER,
+   INTERNAL_BORDER_BOTTOM_EDGE,
+   INTERNAL_BORDER_BOTTOM_LEFT_CORNER,
+  };
 #endif /* HAVE_WINDOW_SYSTEM */
 
 /* The structure representing a frame.  */
@@ -68,6 +88,11 @@ struct frame
      Usually it is nil.  */
   Lisp_Object title;
 
+#if defined (HAVE_WINDOW_SYSTEM)
+  /* This frame's parent frame, if it has one.  */
+  Lisp_Object parent_frame;
+#endif /* HAVE_WINDOW_SYSTEM */
+
   /* The frame which should receive keystrokes that occur in this
      frame, or nil if they should go to the frame itself.  This is
      usually nil, but if the frame is minibufferless, we can use this
@@ -320,6 +345,34 @@ struct frame
   bool_bf horizontal_scroll_bars : 1;
 #endif /* HAVE_WINDOW_SYSTEM */
 
+#if defined (HAVE_WINDOW_SYSTEM)
+  /* True if this is an undecorated frame.  */
+  bool_bf undecorated : 1;
+
+#ifndef HAVE_NTGUI
+  /* True if this is an override_redirect frame.  */
+  bool_bf override_redirect : 1;
+#endif
+
+  /* Nonzero if this frame's icon should not appear on its display's taskbar.  */
+  bool_bf skip_taskbar : 1;
+
+  /* Nonzero if this frame's window F's X window does not want to
+     receive input focus when it is mapped.  */
+  bool_bf no_focus_on_map : 1;
+
+  /* Nonzero if this frame's window does not want to receive input focus
+     via mouse clicks or by moving the mouse into it.  */
+  bool_bf no_accept_focus : 1;
+
+  /* The z-group this frame's window belongs to. */
+  ENUM_BF (z_group) z_group : 2;
+
+  /* Non-zero if display of truncation and continuation glyphs outside
+     the fringes is suppressed.  */
+  bool_bf no_special_glyphs : 1;
+#endif /* HAVE_WINDOW_SYSTEM */
+
   /* Whether new_height and new_width shall be interpreted
      in pixels.  */
   bool_bf new_pixelwise : 1;
@@ -534,6 +587,13 @@ fset_face_alist (struct frame *f, Lisp_Object val)
 {
   f->face_alist = val;
 }
+#if defined (HAVE_WINDOW_SYSTEM)
+INLINE void
+fset_parent_frame (struct frame *f, Lisp_Object val)
+{
+  f->parent_frame = val;
+}
+#endif
 INLINE void
 fset_focus_frame (struct frame *f, Lisp_Object val)
 {
@@ -781,7 +841,7 @@ default_pixels_per_inch_y (void)
 #ifdef USE_GTK
 #define FRAME_TOOL_BAR_POSITION(f) (f)->tool_bar_position
 #else
-#define FRAME_TOOL_BAR_POSITION(f) ((void) f, Qtop)
+#define FRAME_TOOL_BAR_POSITION(f) ((void) (f), Qtop)
 #endif
 
 /* Number of lines of frame F used for the tool-bar.  */
@@ -854,7 +914,6 @@ default_pixels_per_inch_y (void)
 #define FRAME_FOCUS_FRAME(f) f->focus_frame
 
 #ifdef HAVE_WINDOW_SYSTEM
-
 /* This frame slot says whether scroll bars are currently enabled for frame F,
    and which side they are on.  */
 #define FRAME_VERTICAL_SCROLL_BAR_TYPE(f) ((f)->vertical_scroll_bar_type)
@@ -864,15 +923,48 @@ default_pixels_per_inch_y (void)
   ((f)->vertical_scroll_bar_type == vertical_scroll_bar_left)
 #define FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT(f) \
   ((f)->vertical_scroll_bar_type == vertical_scroll_bar_right)
-
 #else /* not HAVE_WINDOW_SYSTEM */
-
 /* If there is no window system, there are no scroll bars.  */
-#define FRAME_VERTICAL_SCROLL_BAR_TYPE(f) ((void) f, vertical_scroll_bar_none)
-#define FRAME_HAS_VERTICAL_SCROLL_BARS(f) ((void) f, 0)
-#define FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT(f) ((void) f, 0)
-#define FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT(f) ((void) f, 0)
+#define FRAME_VERTICAL_SCROLL_BAR_TYPE(f) \
+  ((void) (f), vertical_scroll_bar_none)
+#define FRAME_HAS_VERTICAL_SCROLL_BARS(f) ((void) (f), 0)
+#define FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT(f) ((void) (f), 0)
+#define FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT(f) ((void) (f), 0)
+#endif /* HAVE_WINDOW_SYSTEM */
 
+#if defined (HAVE_WINDOW_SYSTEM)
+#define FRAME_UNDECORATED(f) ((f)->undecorated)
+#ifdef HAVE_NTGUI
+#define FRAME_OVERRIDE_REDIRECT(f) ((void) (f), 0)
+#else
+#define FRAME_OVERRIDE_REDIRECT(f) ((f)->override_redirect)
+#endif
+#define FRAME_PARENT_FRAME(f)                   \
+  (NILP ((f)->parent_frame)                     \
+   ? NULL                                       \
+   : XFRAME ((f)->parent_frame))
+#define FRAME_SKIP_TASKBAR(f) ((f)->skip_taskbar)
+#define FRAME_NO_FOCUS_ON_MAP(f) ((f)->no_focus_on_map)
+#define FRAME_NO_ACCEPT_FOCUS(f) ((f)->no_accept_focus)
+#define FRAME_NO_SPECIAL_GLYPHS(f) ((f)->no_special_glyphs)
+#define FRAME_Z_GROUP(f) ((f)->z_group)
+#define FRAME_Z_GROUP_NONE(f) ((f)->z_group == z_group_none)
+#define FRAME_Z_GROUP_ABOVE(f) ((f)->z_group == z_group_above)
+#define FRAME_Z_GROUP_ABOVE_SUSPENDED(f)        \
+  ((f)->z_group == z_group_above_suspended)
+#define FRAME_Z_GROUP_BELOW(f) ((f)->z_group == z_group_below)
+#else /* not HAVE_WINDOW_SYSTEM */
+#define FRAME_UNDECORATED(f) ((void) (f), 0)
+#define FRAME_OVERRIDE_REDIRECT(f) ((void) (f), 0)
+#define FRAME_PARENT_FRAME(f) ((void) (f), NULL)
+#define FRAME_SKIP_TASKBAR(f) ((void) (f), 0)
+#define FRAME_NO_FOCUS_ON_MAP(f) ((void) (f), 0)
+#define FRAME_NO_ACCEPT_FOCUS(f) ((void) (f), 0)
+#define FRAME_NO_SPECIAL_GLYPHS(f) ((void) (f), 0)
+#define FRAME_Z_GROUP(f) ((void) (f), z_group_none)
+#define FRAME_Z_GROUP_NONE(f) ((void) (f), true)
+#define FRAME_Z_GROUP_ABOVE(f) ((void) (f), false)
+#define FRAME_Z_GROUP_BELOW(f) ((void) (f), false)
 #endif /* HAVE_WINDOW_SYSTEM */
 
 /* Whether horizontal scroll bars are currently enabled for frame F.  */
@@ -880,7 +972,7 @@ default_pixels_per_inch_y (void)
 #define FRAME_HAS_HORIZONTAL_SCROLL_BARS(f) \
   ((f)->horizontal_scroll_bars)
 #else
-#define FRAME_HAS_HORIZONTAL_SCROLL_BARS(f) ((void) f, 0)
+#define FRAME_HAS_HORIZONTAL_SCROLL_BARS(f) ((void) (f), 0)
 #endif
 
 /* Width that a scroll bar in frame F should have, if there is one.
@@ -1039,16 +1131,18 @@ default_pixels_per_inch_y (void)
 /* FOR_EACH_FRAME (LIST_VAR, FRAME_VAR) followed by a statement is a
    `for' loop which iterates over the elements of Vframe_list.  The
    loop will set FRAME_VAR, a Lisp_Object, to each frame in
-   Vframe_list in succession and execute the statement.  LIST_VAR
+   Vframe_list in succession and execute the statement.  Vframe_list
+   should be nonempty, so the body is executed at least once.  LIST_VAR
    should be a Lisp_Object too; it is used to iterate through the
-   Vframe_list.
+   Vframe_list.  Note that this macro walks over child frames and
+   the tooltip frame as well.
 
    This macro is a holdover from a time when multiple frames weren't always
    supported.  An alternate definition of the macro would expand to
    something which executes the statement once.  */
 
 #define FOR_EACH_FRAME(list_var, frame_var)     \
-  for ((list_var) = Vframe_list;                \
+  for ((list_var) = (eassume (CONSP (Vframe_list)), Vframe_list); \
        (CONSP (list_var)                        \
         && (frame_var = XCAR (list_var), true)); \
        list_var = XCDR (list_var))
@@ -1214,19 +1308,20 @@ FRAME_TOTAL_FRINGE_WIDTH (struct frame *f)
   return FRAME_LEFT_FRINGE_WIDTH (f) + FRAME_RIGHT_FRINGE_WIDTH (f);
 }
 
-/* Pixel-width of internal border lines */
+/* Pixel-width of internal border lines.  */
 INLINE int
 FRAME_INTERNAL_BORDER_WIDTH (struct frame *f)
 {
   return frame_dimension (f->internal_border_width);
 }
 
-/* Pixel-size of window border lines */
+/* Pixel-size of window divider lines.  */
 INLINE int
 FRAME_RIGHT_DIVIDER_WIDTH (struct frame *f)
 {
   return frame_dimension (f->right_divider_width);
 }
+
 INLINE int
 FRAME_BOTTOM_DIVIDER_WIDTH (struct frame *f)
 {
@@ -1424,6 +1519,7 @@ extern void x_set_scroll_bar_height (struct frame *, Lisp_Object, Lisp_Object);
 extern long x_figure_window_size (struct frame *, Lisp_Object, bool, int *, int *);
 
 extern void x_set_alpha (struct frame *, Lisp_Object, Lisp_Object);
+extern void x_set_no_special_glyphs (struct frame *, Lisp_Object, Lisp_Object);
 
 extern void validate_x_resource_name (void);
 
@@ -1446,6 +1542,8 @@ extern void x_activate_menubar (struct frame *);
 extern void x_real_positions (struct frame *, int *, int *);
 extern void free_frame_menubar (struct frame *);
 extern void x_free_frame_resources (struct frame *);
+extern bool frame_ancestor_p (struct frame *af, struct frame *df);
+extern enum internal_border_part frame_internal_border_part (struct frame *f, int x, int y);
 
 #if defined HAVE_X_WINDOWS
 extern void x_wm_set_icon_position (struct frame *, int, int);
@@ -1456,7 +1554,7 @@ extern void x_sync (struct frame *);
 #endif /* HAVE_X_WINDOWS */
 
 extern void x_query_colors (struct frame *f, XColor *, int);
-extern void x_focus_frame (struct frame *);
+extern void x_focus_frame (struct frame *, bool);
 
 #ifndef HAVE_NS
 
diff --git a/src/ftfont.c b/src/ftfont.c
index 6cabddda370..5600bde646d 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -1546,7 +1546,8 @@ ftfont_get_metrics (MFLTFont *font, MFLTGlyphString *gstring,
           {
             FT_Glyph_Metrics *m;
 
-            if (FT_Load_Glyph (ft_face, g->g.code, FT_LOAD_DEFAULT) != 0)
+            if (FT_Load_Glyph (ft_face, g->g.code, FT_LOAD_DEFAULT) != 0
+                && FT_Load_Glyph (ft_face, g->g.code, FT_LOAD_NO_HINTING) != 0)
               emacs_abort ();
             m = &ft_face->glyph->metrics;
             if (flt_font_ft->matrix)
diff --git a/src/gmalloc.c b/src/gmalloc.c
index 49f1fafccc0..baaff58050f 100644
--- a/src/gmalloc.c
+++ b/src/gmalloc.c
@@ -77,11 +77,6 @@ extern void *(*__morecore) (ptrdiff_t);
 #ifdef HYBRID_MALLOC
 # include "sheap.h"
 # define DUMPED bss_sbrk_did_unexec
-static bool
-ALLOCATED_BEFORE_DUMPING (char *p)
-{
-  return bss_sbrk_buffer <= p && p < bss_sbrk_buffer + STATIC_HEAP_SIZE;
-}
 #endif
 
 #ifdef  __cplusplus
@@ -133,8 +128,13 @@ typedef union
     /* Heap information for a busy block.  */
     struct
       {
-        /* Zero for a large (multiblock) object, or positive giving the
-           logarithm to the base two of the fragment size.  */
+        /* Zero for a block that is not one of ours (typically,
+           allocated by system malloc), positive for the log base 2 of
+           the fragment size of a fragmented block, -1 for the first
+           block of a multiblock object, and unspecified for later
+           blocks of that object.  Type-0 blocks can be present
+           because the system malloc can be invoked by library
+           functions in an undumped Emacs.  */
         int type;
         union
           {
@@ -144,8 +144,7 @@ typedef union
                 size_t first; /* First free fragment of the block.  */
               } frag;
             /* For a large object, in its first block, this has the number
-               of blocks in the object.  In the other blocks, this has a
-               negative number which says how far back the first block is.  */
+               of blocks in the object.  */
             ptrdiff_t size;
           } info;
       } busy;
@@ -166,7 +165,7 @@ extern char *_heapbase;
 extern malloc_info *_heapinfo;
 
 /* Address to block number and vice versa.  */
-#define BLOCK(A)        (((char *) (A) - _heapbase) / BLOCKSIZE + 1)
+#define BLOCK(A)        ((size_t) ((char *) (A) - _heapbase) / BLOCKSIZE + 1)
 #define ADDRESS(B)      ((void *) (((B) - 1) * BLOCKSIZE + _heapbase))
 
 /* Current search index for the heap table.  */
@@ -491,11 +490,8 @@ register_heapinfo (void)
   ++_chunks_used;
 
   /* Describe the heapinfo block itself in the heapinfo.  */
-  _heapinfo[block].busy.type = 0;
+  _heapinfo[block].busy.type = -1;
   _heapinfo[block].busy.info.size = blocks;
-  /* Leave back-pointers for malloc_find_address.  */
-  while (--blocks > 0)
-    _heapinfo[block + blocks].busy.info.size = -blocks;
 }
 
 #ifdef USE_PTHREAD
@@ -608,7 +604,7 @@ morecore_nolock (size_t size)
   PROTECT_MALLOC_STATE (0);
 
   /* Check if we need to grow the info table.  */
-  if ((size_t) BLOCK ((char *) result + size) > heapsize)
+  if (heapsize < BLOCK ((char *) result + size))
     {
       /* Calculate the new _heapinfo table size.  We do not account for the
          added blocks in the table itself, as we hope to place them in
@@ -617,7 +613,7 @@ morecore_nolock (size_t size)
       newsize = heapsize;
       do
         newsize *= 2;
-      while ((size_t) BLOCK ((char *) result + size) > newsize);
+      while (newsize < BLOCK ((char *) result + size));
 
       /* We must not reuse existing core for the new info table when called
          from realloc in the case of growing a large block, because the
@@ -665,8 +661,7 @@ morecore_nolock (size_t size)
 
           /* Is it big enough to record status for its own space?
              If so, we win.  */
-          if ((size_t) BLOCK ((char *) newinfo
-                              + newsize * sizeof (malloc_info))
+          if (BLOCK ((char *) newinfo + newsize * sizeof (malloc_info))
               < newsize)
             break;
 
@@ -883,17 +878,11 @@ _malloc_internal_nolock (size_t size)
           --_chunks_free;
         }
 
-      _heapinfo[block].busy.type = 0;
+      _heapinfo[block].busy.type = -1;
       _heapinfo[block].busy.info.size = blocks;
       ++_chunks_used;
       _bytes_used += blocks * BLOCKSIZE;
       _bytes_free -= blocks * BLOCKSIZE;
-
-      /* Mark all the blocks of the object just allocated except for the
-         first with a negative number so you can find the first block by
-         adding that adjustment.  */
-      while (--blocks > 0)
-        _heapinfo[block + blocks].busy.info.size = -blocks;
     }
 
   PROTECT_MALLOC_STATE (1);
@@ -1026,7 +1015,7 @@ _free_internal_nolock (void *ptr)
   type = _heapinfo[block].busy.type;
   switch (type)
     {
-    case 0:
+    case -1:
       /* Get as many statistics as early as we can.  */
       --_chunks_used;
       _bytes_used -= _heapinfo[block].busy.info.size * BLOCKSIZE;
@@ -1187,7 +1176,7 @@ _free_internal_nolock (void *ptr)
           prev->prev->next = next;
           if (next != NULL)
             next->prev = prev->prev;
-          _heapinfo[block].busy.type = 0;
+          _heapinfo[block].busy.type = -1;
           _heapinfo[block].busy.info.size = 1;
 
           /* Keep the statistics accurate.  */
@@ -1326,7 +1315,7 @@ _realloc_internal_nolock (void *ptr, size_t size)
   type = _heapinfo[block].busy.type;
   switch (type)
     {
-    case 0:
+    case -1:
       /* Maybe reallocate a large block to a small fragment.  */
       if (size <= BLOCKSIZE / 2)
         {
@@ -1346,7 +1335,7 @@ _realloc_internal_nolock (void *ptr, size_t size)
         {
           /* The new size is smaller; return
              excess memory to the free list. */
-          _heapinfo[block + blocks].busy.type = 0;
+          _heapinfo[block + blocks].busy.type = -1;
           _heapinfo[block + blocks].busy.info.size
             = _heapinfo[block].busy.info.size - blocks;
           _heapinfo[block].busy.info.size = blocks;
@@ -1721,6 +1710,20 @@ extern void *aligned_alloc (size_t alignment, size_t size);
 extern int posix_memalign (void **memptr, size_t alignment, size_t size);
 #endif
 
+/* Assuming PTR was allocated via the hybrid malloc, return true if
+   PTR was allocated via gmalloc, not the system malloc.  Also, return
+   true if _heaplimit is zero; this can happen temporarily when
+   gmalloc calls itself for internal use, and in that case PTR is
+   already known to be allocated via gmalloc.  */
+
+static bool
+allocated_via_gmalloc (void *ptr)
+{
+  size_t block = BLOCK (ptr);
+  size_t blockmax = _heaplimit - 1;
+  return block <= blockmax && _heapinfo[block].busy.type != 0;
+}
+
 /* See the comments near the beginning of this file for explanations
    of the following functions. */
 
@@ -1743,13 +1746,10 @@ hybrid_calloc (size_t nmemb, size_t size)
 void
 hybrid_free (void *ptr)
 {
-  if (!DUMPED)
+  if (allocated_via_gmalloc (ptr))
     gfree (ptr);
-  else if (!ALLOCATED_BEFORE_DUMPING (ptr))
+  else
     free (ptr);
-  /* Otherwise the dumped emacs is trying to free something allocated
-     before dumping; do nothing.  */
-  return;
 }
 
 #if defined HAVE_ALIGNED_ALLOC || defined HAVE_POSIX_MEMALIGN
@@ -1775,19 +1775,20 @@ hybrid_realloc (void *ptr, size_t size)
   int type;
   size_t block, oldsize;
 
+  if (!ptr)
+    return hybrid_malloc (size);
+  if (!allocated_via_gmalloc (ptr))
+    return realloc (ptr, size);
   if (!DUMPED)
     return grealloc (ptr, size);
-  if (!ALLOCATED_BEFORE_DUMPING (ptr))
-    return realloc (ptr, size);
 
   /* The dumped emacs is trying to realloc storage allocated before
-   dumping.  We just malloc new space and copy the data.  */
-  if (size == 0 || ptr == NULL)
-    return malloc (size);
-  block = ((char *) ptr - _heapbase) / BLOCKSIZE + 1;
+     dumping via gmalloc.  Allocate new space and copy the data.  Do
+     not bother with gfree (ptr), as that would just waste time.  */
+  block = BLOCK (ptr);
   type = _heapinfo[block].busy.type;
   oldsize =
-    type == 0 ? _heapinfo[block].busy.info.size * BLOCKSIZE
+    type < 0 ? _heapinfo[block].busy.info.size * BLOCKSIZE
     : (size_t) 1 << type;
   result = malloc (size);
   if (result)
diff --git a/src/gnutls.c b/src/gnutls.c
index 28ab10de05c..2078ad88f28 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -605,6 +605,7 @@ emacs_gnutls_handle_error (gnutls_session_t session, int err)
                        max_log_level,
                        "retry:",
                        str);
+          FALLTHROUGH;
         default:
           GNUTLS_LOG2 (1,
                        max_log_level,
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 63f01436413..2d4abefa969 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -554,10 +554,11 @@ xg_check_special_colors (struct frame *f,
     else
       gtk_style_context_get_background_color (gsty, state, &col);
 
-    sprintf (buf, "rgb:%04x/%04x/%04x",
-             (unsigned) (col.red * 65535),
-             (unsigned) (col.green * 65535),
-             (unsigned) (col.blue * 65535));
+    unsigned short
+      r = col.red * 65535,
+      g = col.green * 65535,
+      b = col.blue * 65535;
+    sprintf (buf, "rgb:%04x/%04x/%04x", r, g, b);
     success_p = x_parse_color (f, buf, color) != 0;
 #else
     GtkStyle *gsty = gtk_widget_get_style (FRAME_GTK_WIDGET (f));
@@ -835,30 +836,6 @@ xg_set_geometry (struct frame *f)
     }
 }
 
-/* Clear under internal border if any.  As we use a mix of Gtk+ and X calls
-   and use a GtkFixed widget, this doesn't happen automatically.  */
-
-void
-xg_clear_under_internal_border (struct frame *f)
-{
-  if (FRAME_INTERNAL_BORDER_WIDTH (f) > 0)
-    {
-      x_clear_area (f, 0, 0,
-                    FRAME_PIXEL_WIDTH (f), FRAME_INTERNAL_BORDER_WIDTH (f));
-
-      x_clear_area (f, 0, 0,
-                    FRAME_INTERNAL_BORDER_WIDTH (f), FRAME_PIXEL_HEIGHT (f));
-
-      x_clear_area (f, 0,
-                    FRAME_PIXEL_HEIGHT (f) - FRAME_INTERNAL_BORDER_WIDTH (f),
-                    FRAME_PIXEL_WIDTH (f), FRAME_INTERNAL_BORDER_WIDTH (f));
-
-      x_clear_area (f,
-                    FRAME_PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f),
-                    0, FRAME_INTERNAL_BORDER_WIDTH (f), FRAME_PIXEL_HEIGHT (f));
-    }
-}
-
 static int
 xg_get_gdk_scale (void)
 {
@@ -905,7 +882,7 @@ xg_frame_resized (struct frame *f, int pixelwidth, int pixelheight)
       || pixelwidth != FRAME_PIXEL_WIDTH (f)
       || pixelheight != FRAME_PIXEL_HEIGHT (f))
     {
-      xg_clear_under_internal_border (f);
+      x_clear_under_internal_border (f);
       change_frame_size (f, width, height, 0, 1, 0, 1);
       SET_FRAME_GARBAGED (f);
       cancel_mouse_face (f);
@@ -933,7 +910,7 @@ xg_frame_set_char_size (struct frame *f, int width, int height)
                        &gwidth, &gheight);
 
   /* Do this before resize, as we don't know yet if we will be resized.  */
-  xg_clear_under_internal_border (f);
+  x_clear_under_internal_border (f);
 
   if (FRAME_VISIBLE_P (f))
     {
@@ -1200,7 +1177,14 @@ xg_create_frame_widgets (struct frame *f)
   else if (! NILP (f->name))
     title = SSDATA (ENCODE_UTF_8 (f->name));
 
-  if (title) gtk_window_set_title (GTK_WINDOW (wtop), title);
+  if (title)
+    gtk_window_set_title (GTK_WINDOW (wtop), title);
+
+  if (FRAME_UNDECORATED (f))
+    {
+      gtk_window_set_decorated (GTK_WINDOW (wtop), FALSE);
+      store_frame_param (f, Qundecorated, Qt);
+    }
 
   FRAME_GTK_OUTER_WIDGET (f) = wtop;
   FRAME_GTK_WIDGET (f) = wfixed;
@@ -1275,6 +1259,14 @@ xg_create_frame_widgets (struct frame *f)
   gtk_window_set_resizable (GTK_WINDOW (wtop), TRUE);
 #endif
 
+  if (FRAME_OVERRIDE_REDIRECT (f))
+    {
+      GdkWindow *gwin = gtk_widget_get_window (wtop);
+
+      if (gwin)
+        gdk_window_set_override_redirect (gwin, TRUE);
+    }
+
 #ifdef USE_GTK_TOOLTIP
   /* Steal a tool tip window we can move ourselves.  */
   f->output_data.x->ttip_widget = 0;
@@ -1356,7 +1348,9 @@ x_wm_set_size_hint (struct frame *f, long int flags, bool user_position)
   /* Don't set size hints during initialization; that apparently leads
      to a race condition.  See the thread at
      http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html  */
-  if (NILP (Vafter_init_time) || !FRAME_GTK_OUTER_WIDGET (f))
+  if (NILP (Vafter_init_time)
+      || !FRAME_GTK_OUTER_WIDGET (f)
+      || FRAME_PARENT_FRAME (f))
     return;
 
   XSETFRAME (frame, f);
@@ -1489,6 +1483,102 @@ xg_set_background_color (struct frame *f, unsigned long bg)
     }
 }
 
+/* Change the frame's decoration (title bar + resize borders).  This
+   might not work with all window managers.  */
+void
+xg_set_undecorated (struct frame *f, Lisp_Object undecorated)
+{
+  if (FRAME_GTK_WIDGET (f))
+    {
+      block_input ();
+      gtk_window_set_decorated (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
+                                NILP (undecorated) ? TRUE : FALSE);
+      unblock_input ();
+    }
+}
+
+
+/* Restack F1 below F2, above if ABOVE_FLAG is true.  This might not
+   work with all window managers.  */
+void
+xg_frame_restack (struct frame *f1, struct frame *f2, bool above_flag)
+{
+#if GTK_CHECK_VERSION (2, 18, 0)
+  block_input ();
+  if (FRAME_GTK_OUTER_WIDGET (f1) && FRAME_GTK_OUTER_WIDGET (f2))
+    {
+      GdkWindow *gwin1 = gtk_widget_get_window (FRAME_GTK_OUTER_WIDGET (f1));
+      GdkWindow *gwin2 = gtk_widget_get_window (FRAME_GTK_OUTER_WIDGET (f2));
+      Lisp_Object frame1, frame2;
+
+      XSETFRAME (frame1, f1);
+      XSETFRAME (frame2, f2);
+
+      gdk_window_restack (gwin1, gwin2, above_flag);
+      x_sync (f1);
+    }
+  unblock_input ();
+#endif
+}
+
+
+/* Don't show frame in taskbar, don't ALT-TAB to it.  */
+void
+xg_set_skip_taskbar (struct frame *f, Lisp_Object skip_taskbar)
+{
+  block_input ();
+  if (FRAME_GTK_WIDGET (f))
+    gdk_window_set_skip_taskbar_hint
+      (gtk_widget_get_window (FRAME_GTK_OUTER_WIDGET (f)),
+       NILP (skip_taskbar) ? FALSE : TRUE);
+  unblock_input ();
+}
+
+
+/* Don't give frame focus.  */
+void
+xg_set_no_focus_on_map (struct frame *f, Lisp_Object no_focus_on_map)
+{
+  block_input ();
+  if (FRAME_GTK_WIDGET (f))
+    {
+      GtkWindow *gwin = GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f));
+      gboolean g_no_focus_on_map = NILP (no_focus_on_map) ? TRUE : FALSE;
+
+      gtk_window_set_focus_on_map (gwin, g_no_focus_on_map);
+    }
+  unblock_input ();
+}
+
+
+void
+xg_set_no_accept_focus (struct frame *f, Lisp_Object no_accept_focus)
+{
+  block_input ();
+  if (FRAME_GTK_WIDGET (f))
+    {
+      GtkWindow *gwin = GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f));
+      gboolean g_no_accept_focus = NILP (no_accept_focus) ? TRUE : FALSE;
+
+      gtk_window_set_accept_focus (gwin, g_no_accept_focus);
+    }
+  unblock_input ();
+}
+
+void
+xg_set_override_redirect (struct frame *f, Lisp_Object override_redirect)
+{
+  block_input ();
+
+  if (FRAME_GTK_OUTER_WIDGET (f))
+    {
+      GdkWindow *gwin = gtk_widget_get_window (FRAME_GTK_OUTER_WIDGET (f));
+
+      gdk_window_set_override_redirect (gwin, NILP (override_redirect) ? FALSE : TRUE);
+    }
+
+  unblock_input ();
+}
 
 /* Set the frame icon to ICON_PIXMAP/MASK.  This must be done with GTK
    functions so GTK does not overwrite the icon.  */
@@ -3787,7 +3877,8 @@ xg_update_scrollbar_pos (struct frame *f,
       /* Move and resize to new values.  */
       gtk_fixed_move (GTK_FIXED (wfixed), wparent, left, top);
       gtk_widget_style_get (wscroll, "min-slider-length", &msl, NULL);
-      if (msl > height)
+      bool hidden = height < msl;
+      if (hidden)
         {
           /* No room.  Hide scroll bar as some themes output a warning if
              the height is less than the min size.  */
@@ -3807,6 +3898,15 @@ xg_update_scrollbar_pos (struct frame *f,
           x_clear_area (f, oldx, oldy, oldw, oldh);
         }
 
+      if (!hidden)
+        {
+          GtkWidget *scrollbar = xg_get_widget_from_map (scrollbar_id);
+          GtkWidget *webox = gtk_widget_get_parent (scrollbar);
+
+          /* Don't obscure any child frames.  */
+          XLowerWindow (FRAME_X_DISPLAY (f), GTK_WIDGET_TO_X_WIN (webox));
+        }
+
       /* GTK does not redraw until the main loop is entered again, but
          if there are no X events pending we will not enter it.  So we sync
          here to get some events.  */
@@ -3872,6 +3972,15 @@ xg_update_horizontal_scrollbar_pos (struct frame *f,
          if there are no X events pending we will not enter it.  So we sync
          here to get some events.  */
 
+      {
+        GtkWidget *scrollbar =
+          xg_get_widget_from_map (scrollbar_id);
+        GtkWidget *webox = gtk_widget_get_parent (scrollbar);
+
+        /* Don't obscure any child frames.  */
+        XLowerWindow (FRAME_X_DISPLAY (f), GTK_WIDGET_TO_X_WIN (webox));
+      }
+
       x_sync (f);
       SET_FRAME_GARBAGED (f);
       cancel_mouse_face (f);
@@ -4230,7 +4339,7 @@ xg_tool_bar_callback (GtkWidget *w, gpointer client_data)
 
   /* Return focus to the frame after we have clicked on a detached
      tool bar button. */
-  x_focus_frame (f);
+  x_focus_frame (f, false);
 }
 
 static GtkWidget *
diff --git a/src/gtkutil.h b/src/gtkutil.h
index d67a7bc4328..0abcb06bc71 100644
--- a/src/gtkutil.h
+++ b/src/gtkutil.h
@@ -150,7 +150,6 @@ extern void update_frame_tool_bar (struct frame *f);
 extern void free_frame_tool_bar (struct frame *f);
 extern void xg_change_toolbar_position (struct frame *f, Lisp_Object pos);
 
-extern void xg_clear_under_internal_border (struct frame *f);
 extern void xg_frame_resized (struct frame *f,
                               int pixelwidth,
                               int pixelheight);
@@ -172,6 +171,13 @@ extern void xg_set_frame_icon (struct frame *f,
                                Pixmap icon_pixmap,
                                Pixmap icon_mask);
 
+extern void xg_set_undecorated (struct frame *f, Lisp_Object undecorated);
+extern void xg_frame_restack (struct frame *f1, struct frame *f2, bool above);
+extern void xg_set_skip_taskbar (struct frame *f, Lisp_Object skip_taskbar);
+extern void xg_set_no_focus_on_map (struct frame *f, Lisp_Object no_focus_on_map);
+extern void xg_set_no_accept_focus (struct frame *f, Lisp_Object no_accept_focus);
+extern void xg_set_override_redirect (struct frame *f, Lisp_Object override_redirect);
+
 extern bool xg_prepare_tooltip (struct frame *f,
                                 Lisp_Object string,
                                 int *width,
diff --git a/src/image.c b/src/image.c
index 3ebf469e8b3..07c4769e9e3 100644
--- a/src/image.c
+++ b/src/image.c
@@ -20,7 +20,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <config.h>
 
 #include <fcntl.h>
-#include <stdio.h>
 #include <unistd.h>
 
 /* Include this before including <setjmp.h> to work around bugs with
@@ -41,6 +40,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "buffer.h"
 #include "dispextern.h"
 #include "blockinput.h"
+#include "sysstdio.h"
 #include "systime.h"
 #include <epaths.h>
 #include "coding.h"
@@ -1269,8 +1269,7 @@ image_background_transparent (struct image *img, struct frame *f, XImagePtr_or_D
   return img->background_transparent;
 }
 
-#if defined (HAVE_PNG) || defined (HAVE_NS) \
-  || defined (HAVE_IMAGEMAGICK) || defined (HAVE_RSVG)
+#if defined (HAVE_PNG) || defined (HAVE_IMAGEMAGICK) || defined (HAVE_RSVG)
 
 /* Store F's background color into *BGCOLOR.  */
 static void
@@ -1284,7 +1283,7 @@ x_query_frame_background_color (struct frame *f, XColor *bgcolor)
 #endif
 }
 
-#endif /* HAVE_PNG || HAVE_NS || HAVE_IMAGEMAGICK || HAVE_RSVG */
+#endif /* HAVE_PNG || HAVE_IMAGEMAGICK || HAVE_RSVG */
 
 /***********************************************************************
                   Helper functions for X image types
@@ -2042,10 +2041,20 @@ x_create_x_image_and_pixmap (struct frame *f, int width, int height, int depth,
       (*ximg)->info.bmiColors[0].rgbGreen = 0;
       (*ximg)->info.bmiColors[0].rgbRed = 0;
       (*ximg)->info.bmiColors[0].rgbReserved = 0;
+      /* bmiColors is a variable-length array declared by w32api
+         headers as bmiColors[1], which triggers a warning under
+         -Warray-bounds; shut that up.  */
+#     if GNUC_PREREQ (4, 4, 0)
+#      pragma GCC push_options
+#      pragma GCC diagnostic ignored "-Warray-bounds"
+#     endif
       (*ximg)->info.bmiColors[1].rgbBlue = 255;
       (*ximg)->info.bmiColors[1].rgbGreen = 255;
       (*ximg)->info.bmiColors[1].rgbRed = 255;
       (*ximg)->info.bmiColors[1].rgbReserved = 0;
+#     if GNUC_PREREQ (4, 4, 0)
+#      pragma GCC pop_options
+#     endif
     }
 
   hdc = get_frame_dc (f);
@@ -2352,7 +2361,7 @@ slurp_file (int fd, ptrdiff_t *size)
              This can happen if the file grows as we read it.  */
           ptrdiff_t buflen = st.st_size;
           buf = xmalloc (buflen + 1);
-          if (fread (buf, 1, buflen + 1, fp) == buflen)
+          if (fread_unlocked (buf, 1, buflen + 1, fp) == buflen)
             *size = buflen;
           else
             {
@@ -5881,7 +5890,7 @@ png_read_from_file (png_structp png_ptr, png_bytep data, png_size_t length)
 {
   FILE *fp = png_get_io_ptr (png_ptr);
 
-  if (fread (data, 1, length, fp) < length)
+  if (fread_unlocked (data, 1, length, fp) < length)
     png_error (png_ptr, "Read error");
 }
 
@@ -5950,7 +5959,7 @@ png_load_body (struct frame *f, struct image *img, struct png_load_context *c)
         }
 
       /* Check PNG signature.  */
-      if (fread (sig, 1, sizeof sig, fp) != sizeof sig
+      if (fread_unlocked (sig, 1, sizeof sig, fp) != sizeof sig
           || png_sig_cmp (sig, 0, sizeof sig))
         {
           fclose (fp);
@@ -6589,7 +6598,8 @@ our_stdio_fill_input_buffer (j_decompress_ptr cinfo)
     {
       ptrdiff_t bytes;
 
-      bytes = fread (src->buffer, 1, JPEG_STDIO_BUFFER_SIZE, src->file);
+      bytes = fread_unlocked (src->buffer, 1, JPEG_STDIO_BUFFER_SIZE,
+                              src->file);
       if (bytes > 0)
         src->mgr.bytes_in_buffer = bytes;
       else
diff --git a/src/indent.c b/src/indent.c
index f630ebb847c..adecc3622a8 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -925,6 +925,7 @@ position_indentation (ptrdiff_t pos_byte)
         case 0240:
           if (! NILP (BVAR (current_buffer, enable_multibyte_characters)))
             return column;
+          FALLTHROUGH;
         case ' ':
           column++;
           break;
diff --git a/src/inotify.c b/src/inotify.c
index 290701349ef..3d5d3d2621f 100644
--- a/src/inotify.c
+++ b/src/inotify.c
@@ -41,7 +41,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifndef IN_ONLYDIR
 # define IN_ONLYDIR 0
 #endif
-#define INOTIFY_DEFAULT_MASK (IN_ALL_EVENTS | IN_EXCL_UNLINK)
 
 /* File handle for inotify.  */
 static int inotifyfd = -1;
@@ -58,7 +57,6 @@ static int inotifyfd = -1;
    IN_EXCL_UNLINK
    IN_MASK_ADD
    IN_ONESHOT
-   IN_ONLYDIR
 
    Each element of this list is of the form (DESCRIPTOR . WATCHES)
    where no two DESCRIPTOR values are the same.  DESCRIPTOR represents
@@ -145,6 +143,8 @@ symbol_to_inotifymask (Lisp_Object symb)
 
   else if (EQ (symb, Qdont_follow))
     return IN_DONT_FOLLOW;
+  else if (EQ (symb, Qonlydir))
+    return IN_ONLYDIR;
 
   else if (EQ (symb, Qt) || EQ (symb, Qall_events))
     return IN_ALL_EVENTS;
@@ -198,16 +198,15 @@ inotifyevent_to_event (Lisp_Object watch, struct inotify_event const *ev)
 }
 
 /* Add a new watch to watch-descriptor WD watching FILENAME and using
-   CALLBACK.  Returns a cons (DESCRIPTOR . ID) uniquely identifying the
-   new watch.  */
+   IMASK and CALLBACK.  Return a cons (DESCRIPTOR . ID) uniquely
+   identifying the new watch.  */
 static Lisp_Object
 add_watch (int wd, Lisp_Object filename,
-           Lisp_Object aspect, Lisp_Object callback)
+           uint32_t imask, Lisp_Object callback)
 {
   Lisp_Object descriptor = INTEGER_TO_CONS (wd);
   Lisp_Object tail = assoc_no_quit (descriptor, watch_list);
   Lisp_Object watch, watch_id;
-  uint32_t imask = aspect_to_inotifymask (aspect);
   Lisp_Object mask = INTEGER_TO_CONS (imask);
 
   EMACS_INT id = 0;
@@ -381,9 +380,11 @@ all-events or t
 move
 close
 
-The following symbols can also be added to a list of aspects:
+ASPECT can also contain the following symbols, which control whether
+the watch descriptor will be created:
 
 dont-follow
+onlydir
 
 Watching a directory is not recursive.  CALLBACK is passed a single argument
 EVENT which contains an event structure of the format
@@ -409,22 +410,18 @@ See inotify(7) and inotify_add_watch(2) for further information.  The
 inotify fd is managed internally and there is no corresponding
 inotify_init.  Use `inotify-rm-watch' to remove a watch.
 
-Also note, that the following inotify bit-masks can not be used, due
-to the fact that descriptors are shared across different callers.
+The following inotify bit-masks cannot be used because descriptors are
+shared across different callers.
 
 IN_EXCL_UNLINK
 IN_MASK_ADD
-IN_ONESHOT
-IN_ONLYDIR  */)
+IN_ONESHOT  */)
      (Lisp_Object filename, Lisp_Object aspect, Lisp_Object callback)
 {
   Lisp_Object encoded_file_name;
-  bool dont_follow = (CONSP (aspect)
-                      ? ! NILP (Fmemq (Qdont_follow, aspect))
-                      : EQ (Qdont_follow, aspect));
   int wd = -1;
-  uint32_t mask = (INOTIFY_DEFAULT_MASK
-                   | (dont_follow ? IN_DONT_FOLLOW : 0));
+  uint32_t imask = aspect_to_inotifymask (aspect);
+  uint32_t mask = imask | IN_MASK_ADD | IN_EXCL_UNLINK;
 
   CHECK_STRING (filename);
 
@@ -442,7 +439,7 @@ IN_ONLYDIR  */)
   if (wd < 0)
     report_file_notify_error ("Could not add watch for file", filename);
 
-  return add_watch (wd, filename, aspect, callback);
+  return add_watch (wd, filename, imask, callback);
 }
 
 static bool
@@ -534,6 +531,7 @@ syms_of_inotify (void)
   DEFSYM (Qclose, "close");             /* IN_CLOSE */
 
   DEFSYM (Qdont_follow, "dont-follow"); /* IN_DONT_FOLLOW */
+  DEFSYM (Qonlydir, "onlydir");         /* IN_ONLYDIR */
 
   DEFSYM (Qignored, "ignored");         /* IN_IGNORED */
   DEFSYM (Qisdir, "isdir");             /* IN_ISDIR */
diff --git a/src/intervals.h b/src/intervals.h
index db91b3f21a0..a0da6f37801 100644
--- a/src/intervals.h
+++ b/src/intervals.h
@@ -85,10 +85,10 @@ struct interval
 #define LEAF_INTERVAL_P(i) ((i)->left == NULL && (i)->right == NULL)
 
 /* True if this interval has no parent and is therefore the root.  */
-#define ROOT_INTERVAL_P(i) (NULL_PARENT (i))
+#define ROOT_INTERVAL_P(i) NULL_PARENT (i)
 
 /* True if this interval is the only interval in the interval tree.  */
-#define ONLY_INTERVAL_P(i) (ROOT_INTERVAL_P ((i)) && LEAF_INTERVAL_P ((i)))
+#define ONLY_INTERVAL_P(i) (ROOT_INTERVAL_P (i) && LEAF_INTERVAL_P (i))
 
 /* True if this interval has both left and right children.  */
 #define BOTH_KIDS_P(i) ((i)->left != NULL && (i)->right != NULL)
@@ -98,13 +98,13 @@ struct interval
 #define TOTAL_LENGTH(i) ((i) == NULL ? 0 : (i)->total_length)
 
 /* The size of text represented by this interval alone.  */
-#define LENGTH(i) ((i) == NULL ? 0 : (TOTAL_LENGTH ((i))                \
-                                      - TOTAL_LENGTH ((i)->right)       \
-                                      - TOTAL_LENGTH ((i)->left)))
+#define LENGTH(i) ((i)->total_length                    \
+                   - TOTAL_LENGTH ((i)->right)          \
+                   - TOTAL_LENGTH ((i)->left))
 
 /* The position of the character just past the end of I.  Note that
    the position cache i->position must be valid for this to work.  */
-#define INTERVAL_LAST_POS(i) ((i)->position + LENGTH ((i)))
+#define INTERVAL_LAST_POS(i) ((i)->position + LENGTH (i))
 
 /* The total size of the left subtree of this interval.  */
 #define LEFT_TOTAL_LENGTH(i) ((i)->left ? (i)->left->total_length : 0)
diff --git a/src/keyboard.c b/src/keyboard.c
index 2e0a813bb08..9e90899c569 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -39,6 +39,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "intervals.h"
 #include "keymap.h"
 #include "blockinput.h"
+#include "sysstdio.h"
 #include "systime.h"
 #include "atimer.h"
 #include "process.h"
@@ -634,7 +635,8 @@ echo_length (void)
 static void
 echo_truncate (ptrdiff_t nchars)
 {
-  if (STRINGP (KVAR (current_kboard, echo_string)))
+  Lisp_Object es = KVAR (current_kboard, echo_string);
+  if (STRINGP (es) && SCHARS (es) > nchars)
     kset_echo_string (current_kboard,
                       Fsubstring (KVAR (current_kboard, echo_string),
                                   make_number (0), make_number (nchars)));
@@ -3289,7 +3291,7 @@ record_char (Lisp_Object c)
       if (INTEGERP (c))
         {
           if (XUINT (c) < 0x100)
-            putc (XUINT (c), dribble);
+            putc_unlocked (XUINT (c), dribble);
           else
             fprintf (dribble, " 0x%"pI"x", XUINT (c));
         }
@@ -3302,15 +3304,15 @@ record_char (Lisp_Object c)
 
           if (SYMBOLP (dribblee))
             {
-              putc ('<', dribble);
-              fwrite (SDATA (SYMBOL_NAME (dribblee)), sizeof (char),
-                      SBYTES (SYMBOL_NAME (dribblee)),
-                      dribble);
-              putc ('>', dribble);
+              putc_unlocked ('<', dribble);
+              fwrite_unlocked (SDATA (SYMBOL_NAME (dribblee)), sizeof (char),
+                               SBYTES (SYMBOL_NAME (dribblee)),
+                               dribble);
+              putc_unlocked ('>', dribble);
             }
         }
 
-      fflush (dribble);
+      fflush_unlocked (dribble);
       unblock_input ();
     }
 }
@@ -3768,7 +3770,7 @@ kbd_buffer_get_event (KBOARD **kbp,
          detaching from the terminal.  */
       || (IS_DAEMON && DAEMON_RUNNING))
     {
-      int c = getchar ();
+      int c = getchar_unlocked ();
       XSETINT (obj, c);
       *kbp = current_kboard;
       return obj;
@@ -4056,6 +4058,14 @@ kbd_buffer_get_event (KBOARD **kbp,
           kbd_fetch_ptr = event + 1;
         }
 #endif
+#if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (HAVE_NS)
+      else if (event->kind == MOVE_FRAME_EVENT)
+        {
+          /* Make an event (move-frame (FRAME)).  */
+          obj = list2 (Qmove_frame, list1 (event->ie.frame_or_window));
+          kbd_fetch_ptr = event + 1;
+        }
+#endif
 #ifdef HAVE_XWIDGETS
       else if (event->kind == XWIDGET_EVENT)
         {
@@ -4068,6 +4078,11 @@ kbd_buffer_get_event (KBOARD **kbp,
           obj = make_lispy_event (&event->ie);
           kbd_fetch_ptr = event + 1;
         }
+      else if (event->kind == SELECT_WINDOW_EVENT)
+        {
+          obj = list2 (Qselect_window, list1 (event->ie.frame_or_window));
+          kbd_fetch_ptr = event + 1;
+        }
       else
         {
           /* If this event is on a different frame, return a switch-frame this
@@ -5112,6 +5127,17 @@ static short const scroll_bar_parts[] = {
   SYMBOL_INDEX (Qrightmost), SYMBOL_INDEX (Qend_scroll), SYMBOL_INDEX (Qratio)
 };
 
+/* An array of symbol indexes of internal border parts, indexed by an enum
+   internal_border_part value.  Note that Qnil corresponds to
+   internal_border_part_none and should not appear in Lisp events.  */
+static short const internal_border_parts[] = {
+  SYMBOL_INDEX (Qnil), SYMBOL_INDEX (Qleft_edge),
+  SYMBOL_INDEX (Qtop_left_corner), SYMBOL_INDEX (Qtop_edge),
+  SYMBOL_INDEX (Qtop_right_corner), SYMBOL_INDEX (Qright_edge),
+  SYMBOL_INDEX (Qbottom_right_corner), SYMBOL_INDEX (Qbottom_edge),
+  SYMBOL_INDEX (Qbottom_left_corner)
+};
+
 /* A vector, indexed by button number, giving the down-going location
    of currently depressed buttons, both scroll bar and non-scroll bar.
 
@@ -5149,15 +5175,15 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
   Lisp_Object extra_info = Qnil;
   /* Coordinate pixel positions to return.  */
   int xret = 0, yret = 0;
-  /* The window under frame pixel coordinates (x,y)  */
-  Lisp_Object window = f
+  /* The window or frame under frame pixel coordinates (x,y)  */
+  Lisp_Object window_or_frame = f
     ? window_from_coordinates (f, XINT (x), XINT (y), &part, 0)
     : Qnil;
 
-  if (WINDOWP (window))
+  if (WINDOWP (window_or_frame))
     {
       /* It's a click in window WINDOW at frame coordinates (X,Y)  */
-      struct window *w = XWINDOW (window);
+      struct window *w = XWINDOW (window_or_frame);
       Lisp_Object string_info = Qnil;
       ptrdiff_t textpos = 0;
       int col = -1, row = -1;
@@ -5346,17 +5372,31 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
                                                make_number (row)),
                                         extra_info)));
     }
-  else if (f != 0)
+
+#ifdef HAVE_WINDOW_SYSTEM
+  else if (f)
     {
       /* Return mouse pixel coordinates here.  */
-      XSETFRAME (window, f);
+      XSETFRAME (window_or_frame, f);
       xret = XINT (x);
       yret = XINT (y);
+
+      if (FRAME_LIVE_P (f)
+          && FRAME_INTERNAL_BORDER_WIDTH (f) > 0
+          && !NILP (get_frame_param (f, Qdrag_internal_border)))
+        {
+          enum internal_border_part part
+            = frame_internal_border_part (f, xret, yret);
+
+          posn = builtin_lisp_symbol (internal_border_parts[part]);
+        }
     }
+#endif
+
   else
-    window = Qnil;
+    window_or_frame = Qnil;
 
-  return Fcons (window,
+  return Fcons (window_or_frame,
                 Fcons (posn,
                        Fcons (Fcons (make_number (xret),
                                      make_number (yret)),
@@ -10363,7 +10403,7 @@ handle_interrupt (bool in_signal_handler)
           sigemptyset (&blocked);
           sigaddset (&blocked, SIGINT);
           pthread_sigmask (SIG_BLOCK, &blocked, 0);
-          fflush (stdout);
+          fflush_unlocked (stdout);
         }
 
       reset_all_sys_modes ();
@@ -10977,6 +11017,7 @@ static const struct event_head head_table[] = {
 
   {SYMBOL_INDEX (Qfocus_in),            SYMBOL_INDEX (Qfocus_in)},
   {SYMBOL_INDEX (Qfocus_out),           SYMBOL_INDEX (Qfocus_out)},
+  {SYMBOL_INDEX (Qmove_frame),          SYMBOL_INDEX (Qmove_frame)},
   {SYMBOL_INDEX (Qdelete_frame),        SYMBOL_INDEX (Qdelete_frame)},
   {SYMBOL_INDEX (Qiconify_frame),       SYMBOL_INDEX (Qiconify_frame)},
   {SYMBOL_INDEX (Qmake_frame_visible),  SYMBOL_INDEX (Qmake_frame_visible)},
@@ -11143,12 +11184,24 @@ syms_of_keyboard (void)
   Fset (Qinput_method_exit_on_first_char, Qnil);
   Fset (Qinput_method_use_echo_area, Qnil);
 
+  /* Symbols for dragging internal borders.  */
+  DEFSYM (Qdrag_internal_border, "drag-internal-border");
+  DEFSYM (Qleft_edge, "left-edge");
+  DEFSYM (Qtop_left_corner, "top-left-corner");
+  DEFSYM (Qtop_edge, "top-edge");
+  DEFSYM (Qtop_right_corner, "top-right-corner");
+  DEFSYM (Qright_edge, "right-edge");
+  DEFSYM (Qbottom_right_corner, "bottom-right-corner");
+  DEFSYM (Qbottom_edge, "bottom-edge");
+  DEFSYM (Qbottom_left_corner, "bottom-left-corner");
+
   /* Symbols to head events.  */
   DEFSYM (Qmouse_movement, "mouse-movement");
   DEFSYM (Qscroll_bar_movement, "scroll-bar-movement");
   DEFSYM (Qswitch_frame, "switch-frame");
   DEFSYM (Qfocus_in, "focus-in");
   DEFSYM (Qfocus_out, "focus-out");
+  DEFSYM (Qmove_frame, "move-frame");
   DEFSYM (Qdelete_frame, "delete-frame");
   DEFSYM (Qiconify_frame, "iconify-frame");
   DEFSYM (Qmake_frame_visible, "make-frame-visible");
@@ -11895,6 +11948,8 @@ keys_of_keyboard (void)
                             "handle-focus-in");
   initial_define_lispy_key (Vspecial_event_map, "focus-out",
                             "handle-focus-out");
+  initial_define_lispy_key (Vspecial_event_map, "move-frame",
+                            "handle-move-frame");
 }
 
 /* Mark the pointers in the kboard objects.
diff --git a/src/kqueue.c b/src/kqueue.c
index 8e6b1e149f7..a8eb4cb797c 100644
--- a/src/kqueue.c
+++ b/src/kqueue.c
@@ -42,7 +42,7 @@ static Lisp_Object watch_list;
 
 /* Generate a list from the directory_files_internal output.
    Items are (INODE FILE-NAME LAST-MOD LAST-STATUS-MOD SIZE).  */
-Lisp_Object
+static Lisp_Object
 kqueue_directory_listing (Lisp_Object directory_files)
 {
   Lisp_Object dl, result = Qnil;
diff --git a/src/lisp.h b/src/lisp.h
index 3125bd2a5dd..ff8dde2b825 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -466,9 +466,6 @@ enum Lisp_Misc_Type
 #ifdef HAVE_MODULES
     Lisp_Misc_User_Ptr,
 #endif
-    /* Currently floats are not a misc type,
-       but let's define this in case we want to change that.  */
-    Lisp_Misc_Float,
     /* This is not a type code.  It is for range checking.  */
     Lisp_Misc_Limit
   };
@@ -545,7 +542,7 @@ enum Lisp_Fwd_Type
 
 #ifdef CHECK_LISP_OBJECT_TYPE
 
-typedef struct { EMACS_INT i; } Lisp_Object;
+typedef struct Lisp_Object { EMACS_INT i; } Lisp_Object;
 
 #define LISP_INITIALLY(i) {i}
 
@@ -884,11 +881,13 @@ enum pvec_type
   PVEC_THREAD,
   PVEC_MUTEX,
   PVEC_CONDVAR,
+  PVEC_MODULE_FUNCTION,
 
   /* These should be last, check internal_equal to see why.  */
   PVEC_COMPILED,
   PVEC_CHAR_TABLE,
   PVEC_SUB_CHAR_TABLE,
+  PVEC_RECORD,
   PVEC_FONT /* Should be last because it's used for range checking.  */
 };
 
@@ -1344,7 +1343,9 @@ SSET (Lisp_Object string, ptrdiff_t index, unsigned char new)
 INLINE ptrdiff_t
 SCHARS (Lisp_Object string)
 {
-  return XSTRING (string)->size;
+  ptrdiff_t nchars = XSTRING (string)->size;
+  eassume (0 <= nchars);
+  return nchars;
 }
 
 #ifdef GC_CHECK_STRING_BYTES
@@ -1354,10 +1355,12 @@ INLINE ptrdiff_t
 STRING_BYTES (struct Lisp_String *s)
 {
 #ifdef GC_CHECK_STRING_BYTES
-  return string_bytes (s);
+  ptrdiff_t nbytes = string_bytes (s);
 #else
-  return s->size_byte < 0 ? s->size : s->size_byte;
+  ptrdiff_t nbytes = s->size_byte < 0 ? s->size : s->size_byte;
 #endif
+  eassume (0 <= nbytes);
+  return nbytes;
 }
 
 INLINE ptrdiff_t
@@ -1368,6 +1371,11 @@ SBYTES (Lisp_Object string)
 INLINE void
 STRING_SET_CHARS (Lisp_Object string, ptrdiff_t newsize)
 {
+  /* This function cannot change the size of data allocated for the
+     string when it was created.  */
+  eassert (STRING_MULTIBYTE (string)
+           ? 0 <= newsize && newsize <= SBYTES (string)
+           : newsize == SCHARS (string));
   XSTRING (string)->size = newsize;
 }
 
@@ -1400,6 +1408,12 @@ ASIZE (Lisp_Object array)
   return size;
 }
 
+INLINE ptrdiff_t
+PVSIZE (Lisp_Object pv)
+{
+  return ASIZE (pv) & PSEUDOVECTOR_SIZE_MASK;
+}
+
 INLINE bool
 VECTORP (Lisp_Object x)
 {
@@ -1412,6 +1426,7 @@ CHECK_VECTOR (Lisp_Object x)
   CHECK_TYPE (VECTORP (x), Qvectorp, x);
 }
 
+
 /* A pseudovector is like a vector, but has other non-Lisp components.  */
 
 INLINE enum pvec_type
@@ -2732,6 +2747,18 @@ FRAMEP (Lisp_Object a)
   return PSEUDOVECTORP (a, PVEC_FRAME);
 }
 
+INLINE bool
+RECORDP (Lisp_Object a)
+{
+  return PSEUDOVECTORP (a, PVEC_RECORD);
+}
+
+INLINE void
+CHECK_RECORD (Lisp_Object x)
+{
+  CHECK_TYPE (RECORDP (x), Qrecordp, x);
+}
+
 /* Test for image (image . spec)  */
 INLINE bool
 IMAGEP (Lisp_Object x)
@@ -3861,11 +3888,62 @@ extern void get_backtrace (Lisp_Object array);
 Lisp_Object backtrace_top_function (void);
 extern bool let_shadows_buffer_binding_p (struct Lisp_Symbol *symbol);
 
+/* Defined in unexmacosx.c.  */
+#if defined DARWIN_OS && !defined CANNOT_DUMP
+extern void unexec_init_emacs_zone (void);
+extern void *unexec_malloc (size_t);
+extern void *unexec_realloc (void *, size_t);
+extern void unexec_free (void *);
+#endif
+
+#include "emacs-module.h"
+
+/* Function prototype for the module Lisp functions.  */
+typedef emacs_value (*emacs_subr) (emacs_env *, ptrdiff_t,
+                                   emacs_value [], void *);
+
+/* Module function.  */
+
+/* A function environment is an auxiliary structure returned by
+   `module_make_function' to store information about a module
+   function.  It is stored in a pseudovector.  Its members correspond
+   to the arguments given to `module_make_function'.  */
+
+struct Lisp_Module_Function
+{
+  struct vectorlike_header header;
+
+  /* Fields traced by GC; these must come first.  */
+  Lisp_Object documentation;
+
+  /* Fields ignored by GC.  */
+  ptrdiff_t min_arity, max_arity;
+  emacs_subr subr;
+  void *data;
+};
+
+INLINE bool
+MODULE_FUNCTIONP (Lisp_Object o)
+{
+  return PSEUDOVECTORP (o, PVEC_MODULE_FUNCTION);
+}
+
+INLINE struct Lisp_Module_Function *
+XMODULE_FUNCTION (Lisp_Object o)
+{
+  eassert (MODULE_FUNCTIONP (o));
+  return XUNTAG (o, Lisp_Vectorlike);
+}
+
 #ifdef HAVE_MODULES
 /* Defined in alloc.c.  */
 extern Lisp_Object make_user_ptr (void (*finalizer) (void *), void *p);
 
 /* Defined in emacs-module.c.  */
+extern Lisp_Object funcall_module (Lisp_Object, ptrdiff_t, Lisp_Object *);
+extern Lisp_Object module_function_arity (const struct Lisp_Module_Function *);
+extern void mark_modules (void);
+extern void init_module_assertions (bool);
 extern void syms_of_module (void);
 #endif
 
@@ -4077,7 +4155,7 @@ extern bool no_site_lisp;
 extern bool build_details;
 
 #ifndef WINDOWSNT
-/* 0 not a daemon, 1 new-style (foreground), 2 old-style (background).  */
+/* 0 not a daemon, 1 foreground daemon, 2 background daemon.  */
 extern int daemon_type;
 #define IS_DAEMON (daemon_type != 0)
 #define DAEMON_RUNNING (daemon_type >= 0)
diff --git a/src/lread.c b/src/lread.c
index 5c6a7f97f52..182f96223a5 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -72,11 +72,36 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define file_tell ftell
 #endif
 
-/* The association list of objects read with the #n=object form.
-   Each member of the list has the form (n . object), and is used to
-   look up the object for the corresponding #n# construct.
-   It must be set to nil before all top-level calls to read0.  */
-static Lisp_Object read_objects;
+/* The objects or placeholders read with the #n=object form.
+
+   A hash table maps a number to either a placeholder (while the
+   object is still being parsed, in case it's referenced within its
+   own definition) or to the completed object.  With small integers
+   for keys, it's effectively little more than a vector, but it'll
+   manage any needed resizing for us.
+
+   The variable must be reset to an empty hash table before all
+   top-level calls to read0.  In between calls, it may be an empty
+   hash table left unused from the previous call (to reduce
+   allocations), or nil.  */
+static Lisp_Object read_objects_map;
+
+/* The recursive objects read with the #n=object form.
+
+   Objects that might have circular references are stored here, so
+   that recursive substitution knows not to keep processing them
+   multiple times.
+
+   Only objects that are completely processed, including substituting
+   references to themselves (but not necessarily replacing
+   placeholders for other objects still being read), are stored.
+
+   A hash table is used for efficient lookups of keys.  We don't care
+   what the value slots hold.  The variable must be set to an empty
+   hash table before all top-level calls to read0.  In between calls,
+   it may be an empty hash table left unused from the previous call
+   (to reduce allocations), or nil.  */
+static Lisp_Object read_objects_completed;
 
 /* File for get_file_char to read from.  Use by load.  */
 static FILE *instream;
@@ -445,16 +470,15 @@ readbyte_from_file (int c, Lisp_Object readcharfun)
     }
 
   block_input ();
-  c = getc (instream);
 
   /* Interrupted reads have been observed while reading over the network.  */
-  while (c == EOF && ferror (instream) && errno == EINTR)
+  while ((c = getc_unlocked (instream)) == EOF && errno == EINTR
+         && ferror_unlocked (instream))
     {
       unblock_input ();
       maybe_quit ();
       block_input ();
-      clearerr (instream);
-      c = getc (instream);
+      clearerr_unlocked (instream);
     }
 
   unblock_input ();
@@ -757,7 +781,7 @@ DEFUN ("get-file-char", Fget_file_char, Sget_file_char, 0, 0, 0,
 {
   register Lisp_Object val;
   block_input ();
-  XSETINT (val, getc (instream));
+  XSETINT (val, getc_unlocked (instream));
   unblock_input ();
   return val;
 }
@@ -948,13 +972,30 @@ load_error_handler (Lisp_Object data)
 static void
 load_warn_old_style_backquotes (Lisp_Object file)
 {
-  if (!NILP (Vold_style_backquotes))
+  if (!NILP (Vlread_old_style_backquotes))
     {
       AUTO_STRING (format, "Loading `%s': old-style backquotes detected!");
       CALLN (Fmessage, format, file);
     }
 }
 
+static void
+load_warn_unescaped_character_literals (Lisp_Object file)
+{
+  if (NILP (Vlread_unescaped_character_literals)) return;
+  CHECK_CONS (Vlread_unescaped_character_literals);
+  Lisp_Object format =
+    build_string ("Loading `%s': unescaped character literals %s detected!");
+  Lisp_Object separator = build_string (", ");
+  Lisp_Object inner_format = build_string ("`?%c'");
+  CALLN (Fmessage,
+         format, file,
+         Fmapconcat (list3 (Qlambda, list1 (Qchar),
+                            list3 (Qformat, inner_format, Qchar)),
+                     Fsort (Vlread_unescaped_character_literals, Qlss),
+                     separator));
+}
+
 DEFUN ("get-load-suffixes", Fget_load_suffixes, Sget_load_suffixes, 0, 0, 0,
        doc: /* Return the suffixes that `load' should try if a suffix is \
 required.
@@ -1199,9 +1240,14 @@ Return t if the file exists and loads successfully.  */)
   version = -1;
 
   /* Check for the presence of old-style quotes and warn about them.  */
-  specbind (Qold_style_backquotes, Qnil);
+  specbind (Qlread_old_style_backquotes, Qnil);
   record_unwind_protect (load_warn_old_style_backquotes, file);
 
+  /* Check for the presence of unescaped character literals and warn
+     about them. */
+  specbind (Qlread_unescaped_character_literals, Qnil);
+  record_unwind_protect (load_warn_unescaped_character_literals, file);
+
   int is_elc;
   if ((is_elc = suffix_p (found, ".elc")) != 0
       /* version = 1 means the file is empty, in which case we can
@@ -1865,7 +1911,7 @@ readevalloop (Lisp_Object readcharfun,
       /* On the first cycle, we can easily test here
          whether we are reading the whole buffer.  */
       if (b && first_sexp)
-        whole_buffer = (PT == BEG && ZV == Z);
+        whole_buffer = (BUF_PT (b) == BUF_BEG (b) && BUF_ZV (b) == BUF_Z (b));
 
       instream = stream;
     read_next:
@@ -1886,6 +1932,18 @@ readevalloop (Lisp_Object readcharfun,
           || c == NO_BREAK_SPACE)
         goto read_next;
 
+      if (! HASH_TABLE_P (read_objects_map)
+          || XHASH_TABLE (read_objects_map)->count)
+        read_objects_map
+          = make_hash_table (hashtest_eq, DEFAULT_HASH_SIZE,
+                             DEFAULT_REHASH_SIZE, DEFAULT_REHASH_THRESHOLD,
+                             Qnil, false);
+      if (! HASH_TABLE_P (read_objects_completed)
+          || XHASH_TABLE (read_objects_completed)->count)
+        read_objects_completed
+          = make_hash_table (hashtest_eq, DEFAULT_HASH_SIZE,
+                             DEFAULT_REHASH_SIZE, DEFAULT_REHASH_THRESHOLD,
+                             Qnil, false);
       if (!NILP (Vpurify_flag) && c == '(')
         {
           val = read_list (0, readcharfun);
@@ -1893,7 +1951,6 @@ readevalloop (Lisp_Object readcharfun,
       else
         {
           UNREAD (c);
-          read_objects = Qnil;
           if (!NILP (readfun))
             {
               val = call1 (readfun, readcharfun);
@@ -1913,6 +1970,13 @@ readevalloop (Lisp_Object readcharfun,
           else
             val = read_internal_start (readcharfun, Qnil, Qnil);
         }
+      /* Empty hashes can be reused; otherwise, reset on next call.  */
+      if (HASH_TABLE_P (read_objects_map)
+          && XHASH_TABLE (read_objects_map)->count > 0)
+        read_objects_map = Qnil;
+      if (HASH_TABLE_P (read_objects_completed)
+          && XHASH_TABLE (read_objects_completed)->count > 0)
+        read_objects_completed = Qnil;
 
       if (!NILP (start) && continue_reading_p)
         start = Fpoint_marker ();
@@ -1988,6 +2052,7 @@ This function preserves the position of point.  */)
   record_unwind_protect (save_excursion_restore, save_excursion_save ());
   BUF_TEMP_SET_PT (XBUFFER (buf), BUF_BEGV (XBUFFER (buf)));
   specbind (Qlexical_binding, lisp_file_lexically_bound_p (buf) ? Qt : Qnil);
+  BUF_TEMP_SET_PT (XBUFFER (buf), BUF_BEGV (XBUFFER (buf)));
   readevalloop (buf, 0, filename,
                 !NILP (printflag), unibyte, Qnil, Qnil, Qnil);
   unbind_to (count, Qnil);
@@ -2083,7 +2148,18 @@ read_internal_start (Lisp_Object stream, Lisp_Object start, Lisp_Object end)
 
   readchar_count = 0;
   new_backquote_flag = 0;
-  read_objects = Qnil;
+  /* We can get called from readevalloop which may have set these
+     already.  */
+  if (! HASH_TABLE_P (read_objects_map)
+      || XHASH_TABLE (read_objects_map)->count)
+    read_objects_map
+      = make_hash_table (hashtest_eq, DEFAULT_HASH_SIZE, DEFAULT_REHASH_SIZE,
+                         DEFAULT_REHASH_THRESHOLD, Qnil, false);
+  if (! HASH_TABLE_P (read_objects_completed)
+      || XHASH_TABLE (read_objects_completed)->count)
+    read_objects_completed
+      = make_hash_table (hashtest_eq, DEFAULT_HASH_SIZE, DEFAULT_REHASH_SIZE,
+                         DEFAULT_REHASH_THRESHOLD, Qnil, false);
   if (EQ (Vread_with_symbol_positions, Qt)
       || EQ (Vread_with_symbol_positions, stream))
     Vread_symbol_positions_list = Qnil;
@@ -2111,6 +2187,13 @@ read_internal_start (Lisp_Object stream, Lisp_Object start, Lisp_Object end)
   if (EQ (Vread_with_symbol_positions, Qt)
       || EQ (Vread_with_symbol_positions, stream))
     Vread_symbol_positions_list = Fnreverse (Vread_symbol_positions_list);
+  /* Empty hashes can be reused; otherwise, reset on next call.  */
+  if (HASH_TABLE_P (read_objects_map)
+      && XHASH_TABLE (read_objects_map)->count > 0)
+    read_objects_map = Qnil;
+  if (HASH_TABLE_P (read_objects_completed)
+      && XHASH_TABLE (read_objects_completed)->count > 0)
+    read_objects_completed = Qnil;
   return retval;
 }
 
@@ -2286,6 +2369,7 @@ read_escape (Lisp_Object readcharfun, bool stringp)
       c = READCHAR;
       if (c != '-')
         error ("Invalid escape character syntax");
+      FALLTHROUGH;
     case '^':
       c = READCHAR;
       if (c == '\\')
@@ -2376,6 +2460,7 @@ read_escape (Lisp_Object readcharfun, bool stringp)
     case 'U':
       /* Post-Unicode-2.0: Up to eight hex chars.  */
       unicode_hex_count = 8;
+      FALLTHROUGH;
     case 'u':
 
       /* A Unicode escape.  We only permit them in strings and characters,
@@ -2603,8 +2688,18 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
               int param_count = 0;
 
               if (!EQ (head, Qhash_table))
-                error ("Invalid extended read marker at head of #s list "
-                       "(only hash-table allowed)");
+                {
+                  ptrdiff_t size = XINT (Flength (tmp));
+                  Lisp_Object record = Fmake_record (CAR_SAFE (tmp),
+                                                     make_number (size - 1),
+                                                     Qnil);
+                  for (int i = 1; i < size; i++)
+                    {
+                      tmp = Fcdr (tmp);
+                      ASET (record, i, Fcar (tmp));
+                    }
+                  return record;
+                }
 
               tmp = CDR_SAFE (tmp);
 
@@ -2866,7 +2961,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
               /* Copy that many characters into saved_doc_string.  */
               block_input ();
               for (i = 0; i < nskip && c >= 0; i++)
-                saved_doc_string[i] = c = getc (instream);
+                saved_doc_string[i] = c = getc_unlocked (instream);
               unblock_input ();
 
               saved_doc_string_length = i;
@@ -2939,7 +3034,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
                       /* Note: We used to use AUTO_CONS to allocate
                          placeholder, but that is a bad idea, since it
                          will place a stack-allocated cons cell into
-                         the list in read_objects, which is a
+                         the list in read_objects_map, which is a
                          staticpro'd global variable, and thus each of
                          its elements is marked during each GC.  A
                          stack-allocated object will become garbled
@@ -2948,27 +3043,62 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
                          different purposes, which will cause crashes
                          in GC.  */
                       Lisp_Object placeholder = Fcons (Qnil, Qnil);
-                      Lisp_Object cell = Fcons (make_number (n), placeholder);
-                      read_objects = Fcons (cell, read_objects);
+                      struct Lisp_Hash_Table *h
+                        = XHASH_TABLE (read_objects_map);
+                      EMACS_UINT hash;
+                      Lisp_Object number = make_number (n);
+
+                      ptrdiff_t i = hash_lookup (h, number, &hash);
+                      if (i >= 0)
+                        /* Not normal, but input could be malformed.  */
+                        set_hash_value_slot (h, i, placeholder);
+                      else
+                        hash_put (h, number, placeholder, hash);
 
                       /* Read the object itself.  */
                       tem = read0 (readcharfun);
 
+                      /* If it can be recursive, remember it for
+                         future substitutions.  */
+                      if (! SYMBOLP (tem)
+                          && ! NUMBERP (tem)
+                          && ! (STRINGP (tem) && !string_intervals (tem)))
+                        {
+                          struct Lisp_Hash_Table *h2
+                            = XHASH_TABLE (read_objects_completed);
+                          i = hash_lookup (h2, tem, &hash);
+                          eassert (i < 0);
+                          hash_put (h2, tem, Qnil, hash);
+                        }
+
                       /* Now put it everywhere the placeholder was...  */
-                      Fsubstitute_object_in_subtree (tem, placeholder);
+                      if (CONSP (tem))
+                        {
+                          Fsetcar (placeholder, XCAR (tem));
+                          Fsetcdr (placeholder, XCDR (tem));
+                          return placeholder;
+                        }
+                      else
+                        {
+                          Fsubstitute_object_in_subtree (tem, placeholder);
 
-                      /* ...and #n# will use the real value from now on.  */
-                      Fsetcdr (cell, tem);
+                          /* ...and #n# will use the real value from now on.  */
+                          i = hash_lookup (h, number, &hash);
+                          eassert (i >= 0);
+                          set_hash_value_slot (h, i, tem);
 
-                      return tem;
+                          return tem;
+                        }
                     }
 
                   /* #n# returns a previously read object.  */
                   if (c == '#')
                     {
-                      tem = Fassq (make_number (n), read_objects);
-                      if (CONSP (tem))
-                        return XCDR (tem);
+                      struct Lisp_Hash_Table *h
+                        = XHASH_TABLE (read_objects_map);
+                      ptrdiff_t i = hash_lookup (h, make_number (n), NULL);
+                      if (i >= 0)
+                        return HASH_VALUE (h, i);
                     }
                 }
             }
@@ -3007,7 +3137,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
            "(\`" anyway).  */
         if (!new_backquote_flag && first_in_list && next_char == ' ')
           {
-            Vold_style_backquotes = Qt;
+            Vlread_old_style_backquotes = Qt;
             goto default_label;
           }
         else
@@ -3061,7 +3191,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
           }
         else
           {
-            Vold_style_backquotes = Qt;
+            Vlread_old_style_backquotes = Qt;
             goto default_label;
           }
       }
@@ -3082,6 +3212,16 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
         if (c == ' ' || c == '\t')
           return make_number (c);
 
+        if (c == '(' || c == ')' || c == '[' || c == ']'
+            || c == '"' || c == ';')
+          {
+            CHECK_LIST (Vlread_unescaped_character_literals);
+            Lisp_Object char_obj = make_natnum (c);
+            if (NILP (Fmemq (char_obj, Vlread_unescaped_character_literals)))
+              Vlread_unescaped_character_literals =
+                Fcons (char_obj, Vlread_unescaped_character_literals);
+          }
+
         if (c == '\\')
           c = read_escape (readcharfun, 0);
         modifiers = c & CHAR_MODIFIER_MASK;
@@ -3235,11 +3375,11 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
             *pch = c;
             return Qnil;
           }
-
-        /* Otherwise, we fall through!  Note that the atom-reading loop
-           below will now loop at least once, assuring that we will not
-           try to UNREAD two characters in a row.  */
       }
+      /* The atom-reading loop below will now loop at least once,
+         assuring that we will not try to UNREAD two characters in a
+         row.  */
+      FALLTHROUGH;
     default:
     default_label:
       if (c <= 040) goto retry;
@@ -3297,25 +3437,51 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
             if (! NILP (result))
               return unbind_to (count, result);
           }
+        {
+          Lisp_Object result;
+          ptrdiff_t nbytes = p - read_buffer;
+          ptrdiff_t nchars
+            = (multibyte
+               ? multibyte_chars_in_text ((unsigned char *) read_buffer,
+                                          nbytes)
+               : nbytes);
+
+          if (uninterned_symbol)
+            {
+              Lisp_Object name
+                = ((! NILP (Vpurify_flag)
+                    ? make_pure_string : make_specified_string)
+                   (read_buffer, nchars, nbytes, multibyte));
+              result = Fmake_symbol (name);
+            }
+          else
+            {
+              /* Don't create the string object for the name unless
+                 we're going to retain it in a new symbol.
 
-        ptrdiff_t nbytes = p - read_buffer;
-        ptrdiff_t nchars
-          = (multibyte
-             ? multibyte_chars_in_text ((unsigned char *) read_buffer,
-                                        nbytes)
-             : nbytes);
-        Lisp_Object name = ((uninterned_symbol && ! NILP (Vpurify_flag)
-                             ? make_pure_string : make_specified_string)
-                            (read_buffer, nchars, nbytes, multibyte));
-        Lisp_Object result = (uninterned_symbol ? Fmake_symbol (name)
-                              : Fintern (name, Qnil));
-
-        if (EQ (Vread_with_symbol_positions, Qt)
-            || EQ (Vread_with_symbol_positions, readcharfun))
-          Vread_symbol_positions_list
-            = Fcons (Fcons (result, make_number (start_position)),
-                     Vread_symbol_positions_list);
-        return unbind_to (count, result);
+                 Like intern_1 but supports multibyte names.  */
+              Lisp_Object obarray = check_obarray (Vobarray);
+              Lisp_Object tem = oblookup (obarray, read_buffer,
+                                          nchars, nbytes);
+
+              if (SYMBOLP (tem))
+                result = tem;
+              else
+                {
+                  Lisp_Object name
+                    = make_specified_string (read_buffer, nchars, nbytes,
+                                             multibyte);
+                  result = intern_driver (name, obarray, tem);
+                }
+            }
+
+          if (EQ (Vread_with_symbol_positions, Qt)
+              || EQ (Vread_with_symbol_positions, readcharfun))
+            Vread_symbol_positions_list
+              = Fcons (Fcons (result, make_number (start_position)),
+                       Vread_symbol_positions_list);
+          return unbind_to (count, result);
+        }
       }
     }
 }
@@ -3369,6 +3535,13 @@ substitute_object_recurse (Lisp_Object object, Lisp_Object placeholder, Lisp_Obj
   if (EQ (placeholder, subtree))
     return object;
 
+  /* For common object types that can't contain other objects, don't
+     bother looking them up; we're done.  */
+  if (SYMBOLP (subtree)
+      || (STRINGP (subtree) && !string_intervals (subtree))
+      || NUMBERP (subtree))
+    return subtree;
+
   /* If we've been to this node before, don't explore it again.  */
   if (!EQ (Qnil, Fmemq (subtree, seen_list)))
     return subtree;
@@ -3376,8 +3549,8 @@ substitute_object_recurse (Lisp_Object object, Lisp_Object placeholder, Lisp_Obj
   /* If this node can be the entry point to a cycle, remember that
      we've seen it.  It can only be such an entry point if it was made
      by #n=, which means that we can find it as a value in
-     read_objects.  */
-  if (!EQ (Qnil, Frassq (subtree, read_objects)))
+     read_objects_completed.  */
+  if (hash_lookup (XHASH_TABLE (read_objects_completed), subtree, NULL) >= 0)
     seen_list = Fcons (subtree, seen_list);
 
   /* Recurse according to subtree's type.
@@ -3390,8 +3563,9 @@ substitute_object_recurse (Lisp_Object object, Lisp_Object placeholder, Lisp_Obj
         if (BOOL_VECTOR_P (subtree))
           return subtree;               /* No sub-objects anyway.  */
         else if (CHAR_TABLE_P (subtree) || SUB_CHAR_TABLE_P (subtree)
-                 || COMPILEDP (subtree) || HASH_TABLE_P (subtree))
-          length = ASIZE (subtree) & PSEUDOVECTOR_SIZE_MASK;
+                 || COMPILEDP (subtree) || HASH_TABLE_P (subtree)
+                 || RECORDP (subtree))
+          length = PVSIZE (subtree);
         else if (VECTORP (subtree))
           length = ASIZE (subtree);
         else
@@ -3449,25 +3623,18 @@ substitute_in_interval (INTERVAL interval, Lisp_Object arg)
 }
 
 
-#define LEAD_INT 1
-#define DOT_CHAR 2
-#define TRAIL_INT 4
-#define E_EXP 16
-
-
-/* Convert STRING to a number, assuming base BASE.  Return a fixnum if CP has
-   integer syntax and fits in a fixnum, else return the nearest float if CP has
-   either floating point or integer syntax and BASE is 10, else return nil.  If
-   IGNORE_TRAILING, consider just the longest prefix of CP that has
-   valid floating point syntax.  Signal an overflow if BASE is not 10 and the
-   number has integer syntax but does not fit.  */
+/* Convert STRING to a number, assuming base BASE.  Return a fixnum if
+   STRING has integer syntax and fits in a fixnum, else return the
+   nearest float if STRING has either floating point or integer syntax
+   and BASE is 10, else return nil.  If IGNORE_TRAILING, consider just
+   the longest prefix of STRING that has valid floating point syntax.
+   Signal an overflow if BASE is not 10 and the number has integer
+   syntax but does not fit.  */
 
 Lisp_Object
 string_to_number (char const *string, int base, bool ignore_trailing)
 {
-  int state;
   char const *cp = string;
-  int leading_digit;
   bool float_syntax = 0;
   double value = 0;
 
@@ -3479,15 +3646,23 @@ string_to_number (char const *string, int base, bool ignore_trailing)
   bool signedp = negative || *cp == '+';
   cp += signedp;
 
-  state = 0;
-
-  leading_digit = digit_to_number (*cp, base);
+  enum { INTOVERFLOW = 1, LEAD_INT = 2, DOT_CHAR = 4, TRAIL_INT = 8,
+         E_EXP = 16 };
+  int state = 0;
+  int leading_digit = digit_to_number (*cp, base);
+  uintmax_t n = leading_digit;
   if (leading_digit >= 0)
     {
       state |= LEAD_INT;
-      do
-        ++cp;
-      while (digit_to_number (*cp, base) >= 0);
+      for (int digit; 0 <= (digit = digit_to_number (*++cp, base)); )
+        {
+          if (INT_MULTIPLY_OVERFLOW (n, base))
+            state |= INTOVERFLOW;
+          n *= base;
+          if (INT_ADD_OVERFLOW (n, digit))
+            state |= INTOVERFLOW;
+          n += digit;
+        }
     }
   if (*cp == '.')
     {
@@ -3537,32 +3712,22 @@ string_to_number (char const *string, int base, bool ignore_trailing)
         }
 
       float_syntax = ((state & (DOT_CHAR|TRAIL_INT)) == (DOT_CHAR|TRAIL_INT)
-                      || state == (LEAD_INT|E_EXP));
+                      || (state & ~INTOVERFLOW) == (LEAD_INT|E_EXP));
     }
 
   /* Return nil if the number uses invalid syntax.  If IGNORE_TRAILING, accept
      any prefix that matches.  Otherwise, the entire string must match.  */
   if (! (ignore_trailing
          ? ((state & LEAD_INT) != 0 || float_syntax)
-         : (!*cp && ((state & ~DOT_CHAR) == LEAD_INT || float_syntax))))
+         : (!*cp && ((state & ~(INTOVERFLOW | DOT_CHAR)) == LEAD_INT
+                     || float_syntax))))
     return Qnil;
 
   /* If the number uses integer and not float syntax, and is in C-language
      range, use its value, preferably as a fixnum.  */
   if (leading_digit >= 0 && ! float_syntax)
     {
-      uintmax_t n;
-
-      /* Fast special case for single-digit integers.  This also avoids a
-         glitch when BASE is 16 and IGNORE_TRAILING, because in that
-         case some versions of strtoumax accept numbers like "0x1" that Emacs
-         does not allow.  */
-      if (digit_to_number (string[signedp + 1], base) < 0)
-        return make_number (negative ? -leading_digit : leading_digit);
-
-      errno = 0;
-      n = strtoumax (string + signedp, NULL, base);
-      if (errno == ERANGE)
+      if (state & INTOVERFLOW)
         {
           /* Unfortunately there's no simple and accurate way to convert
              non-base-10 numbers that are out of C-language range.  */
@@ -4436,6 +4601,9 @@ load_path_default (void)
 void
 init_lread (void)
 {
+  if (NILP (Vpurify_flag) && !NILP (Ffboundp (Qfile_truename)))
+    Vsource_directory = call1 (Qfile_truename, Vsource_directory);
+
   /* First, set Vload_path.  */
 
   /* Ignore EMACSLOADPATH when dumping.  */
@@ -4690,11 +4858,12 @@ The remaining ENTRIES in the alist element describe the functions and
 variables defined in that file, the features provided, and the
 features required.  Each entry has the form `(provide . FEATURE)',
 `(require . FEATURE)', `(defun . FUNCTION)', `(autoload . SYMBOL)',
-`(defface . SYMBOL)', or `(t . SYMBOL)'.  Entries like `(t . SYMBOL)'
-may precede a `(defun . FUNCTION)' entry, and means that SYMBOL was an
-autoload before this file redefined it as a function.  In addition,
-entries may also be single symbols, which means that SYMBOL was
-defined by `defvar' or `defconst'.
+`(defface . SYMBOL)', `(define-type . SYMBOL)',
+`(cl-defmethod METHOD SPECIALIZERS)', or `(t . SYMBOL)'.
+Entries like `(t . SYMBOL)' may precede a `(defun . FUNCTION)' entry,
+and means that SYMBOL was an autoload before this file redefined it
+as a function.  In addition, entries may also be single symbols,
+which means that symbol was defined by `defvar' or `defconst'.
 
 During preloading, the file name recorded is relative to the main Lisp
 directory.  These file names are converted to absolute at startup.  */);
@@ -4799,10 +4968,23 @@ variables, this must be set in the first line of a file.  */);
                doc: /* List of buffers being read from by calls to `eval-buffer' and `eval-region'.  */);
   Veval_buffer_list = Qnil;
 
-  DEFVAR_LISP ("old-style-backquotes", Vold_style_backquotes,
-               doc: /* Set to non-nil when `read' encounters an old-style backquote.  */);
-  Vold_style_backquotes = Qnil;
-  DEFSYM (Qold_style_backquotes, "old-style-backquotes");
+  DEFVAR_LISP ("lread--old-style-backquotes", Vlread_old_style_backquotes,
+               doc: /* Set to non-nil when `read' encounters an old-style backquote.
+For internal use only.  */);
+  Vlread_old_style_backquotes = Qnil;
+  DEFSYM (Qlread_old_style_backquotes, "lread--old-style-backquotes");
+
+  DEFVAR_LISP ("lread--unescaped-character-literals",
+               Vlread_unescaped_character_literals,
+               doc: /* List of deprecated unescaped character literals encountered by `read'.
+For internal use only.  */);
+  Vlread_unescaped_character_literals = Qnil;
+  DEFSYM (Qlread_unescaped_character_literals,
+          "lread--unescaped-character-literals");
+
+  DEFSYM (Qlss, "<");
+  DEFSYM (Qchar, "char");
+  DEFSYM (Qformat, "format");
 
   DEFVAR_BOOL ("load-prefer-newer", load_prefer_newer,
                doc: /* Non-nil means `load' prefers the newest version of a file.
@@ -4844,8 +5026,10 @@ that are loaded before your customizations are read!  */);
   DEFSYM (Qdir_ok, "dir-ok");
   DEFSYM (Qdo_after_load_evaluation, "do-after-load-evaluation");
 
-  staticpro (&read_objects);
-  read_objects = Qnil;
+  staticpro (&read_objects_map);
+  read_objects_map = Qnil;
+  staticpro (&read_objects_completed);
+  read_objects_completed = Qnil;
   staticpro (&seen_list);
   seen_list = Qnil;
 
diff --git a/src/macfont.m b/src/macfont.m
index f356842db18..4d310e47aec 100644
--- a/src/macfont.m
+++ b/src/macfont.m
@@ -206,7 +206,7 @@ mac_screen_font_get_advance_width_for_glyph (ScreenFontRef font, CGGlyph glyph)
 
 #if !USE_CT_GLYPH_INFO
 static CGGlyph
-mac_font_get_glyph_for_cid (CTFontRef font, CTCharacterCollection collection,
+mac_font_get_glyph_for_cid (CTFontRef font, NSCharacterCollection collection,
                             CGFontIndex cid)
 {
   CGGlyph result = kCGFontIndexInvalid;
@@ -284,7 +284,6 @@ mac_screen_font_get_metrics (ScreenFontRef font, CGFloat *ascent,
 
   [textStorage setFont:nsFont];
   [textContainer setLineFragmentPadding:0];
-  [layoutManager setUsesScreenFonts:YES];
 
   [layoutManager addTextContainer:textContainer];
   [textContainer release];
@@ -318,8 +317,7 @@ mac_screen_font_get_metrics (ScreenFontRef font, CGFloat *ascent,
 
 static CFIndex
 mac_font_shape_1 (NSFont *font, NSString *string,
-                  struct mac_glyph_layout *glyph_layouts, CFIndex glyph_len,
-                  BOOL screen_font_p)
+                  struct mac_glyph_layout *glyph_layouts, CFIndex glyph_len)
 {
   NSUInteger i;
   CFIndex result = 0;
@@ -339,7 +337,6 @@ mac_font_shape_1 (NSFont *font, NSString *string,
                                           initWithString:@" "] autorelease])];
   [textStorage setFont:font];
   [textContainer setLineFragmentPadding:0];
-  [layoutManager setUsesScreenFonts:screen_font_p];
 
   [layoutManager addTextContainer:textContainer];
   [textContainer release];
@@ -413,8 +410,9 @@ mac_font_shape_1 (NSFont *font, NSString *string,
       /* For now we assume the direction is not changed within the
          string.  */
       [layoutManager getGlyphsInRange:(NSMakeRange (glyphIndex, 1))
-                               glyphs:NULL characterIndexes:NULL
-                    glyphInscriptions:NULL elasticBits:NULL
+                               glyphs:NULL
+                           properties:NULL
+                     characterIndexes:NULL
                            bidiLevels:&bidiLevel];
       if (bidiLevel & 1)
         permutation = xmalloc (sizeof (NSUInteger) * used);
@@ -587,7 +585,7 @@ mac_screen_font_shape (ScreenFontRef font, CFStringRef string,
 {
   return mac_font_shape_1 ([(NSFont *)font printerFont],
                            (NSString *) string,
-                           glyph_layouts, glyph_len, YES);
+                           glyph_layouts, glyph_len);
 }
 
 static CGColorRef
@@ -1321,8 +1319,8 @@ struct macfont_cache
     /* Character collection specifying the destination of the mapping
        provided by `table' above.  If `table' is obtained from the UVS
        subtable in the font cmap table, then the value of this member
-       should be kCTCharacterCollectionIdentityMapping.  */
-    CTCharacterCollection collection;
+       should be NSIdentityMappingCharacterCollection.  */
+    NSCharacterCollection collection;
   } uvs;
 };
 
@@ -1333,8 +1331,8 @@ static CFCharacterSetRef macfont_get_cf_charset (struct font *);
 static CFCharacterSetRef macfont_get_cf_charset_for_name (CFStringRef);
 static CGGlyph macfont_get_glyph_for_character (struct font *, UTF32Char);
 static CGGlyph macfont_get_glyph_for_cid (struct font *font,
-                                          CTCharacterCollection, CGFontIndex);
-static CFDataRef macfont_get_uvs_table (struct font *, CTCharacterCollection *);
+                                          NSCharacterCollection, CGFontIndex);
+static CFDataRef macfont_get_uvs_table (struct font *, NSCharacterCollection *);
 
 static struct macfont_cache *
 macfont_lookup_cache (CFStringRef key)
@@ -1582,7 +1580,7 @@ macfont_get_glyph_for_character (struct font *font, UTF32Char c)
 }
 
 static CGGlyph
-macfont_get_glyph_for_cid (struct font *font, CTCharacterCollection collection,
+macfont_get_glyph_for_cid (struct font *font, NSCharacterCollection collection,
                            CGFontIndex cid)
 {
   struct macfont_info *macfont_info = (struct macfont_info *) font;
@@ -1593,7 +1591,7 @@ macfont_get_glyph_for_cid (struct font *font, CTCharacterCollection collection,
 }
 
 static CFDataRef
-macfont_get_uvs_table (struct font *font, CTCharacterCollection *collection)
+macfont_get_uvs_table (struct font *font, NSCharacterCollection *collection)
 {
   struct macfont_info *macfont_info = (struct macfont_info *) font;
   CTFontRef macfont = macfont_info->macfont;
@@ -1603,12 +1601,12 @@ macfont_get_uvs_table (struct font *font, CTCharacterCollection *collection)
   if (cache->uvs.table == NULL)
     {
       CFDataRef uvs_table = mac_font_copy_uvs_table (macfont);
-      CTCharacterCollection uvs_collection =
-        kCTCharacterCollectionIdentityMapping;
+      NSCharacterCollection uvs_collection =
+        NSIdentityMappingCharacterCollection;
 
       if (uvs_table == NULL
           && mac_font_get_glyph_for_cid (macfont,
-                                         kCTCharacterCollectionAdobeJapan1,
+                                         NSAdobeJapan1CharacterCollection,
                                          6480) != kCGFontIndexInvalid)
         {
           /* If the glyph for U+4E55 is accessible via its CID 6480,
@@ -1625,7 +1623,7 @@ macfont_get_uvs_table (struct font *font, CTCharacterCollection *collection)
           if (mac_uvs_table_adobe_japan1)
             {
               uvs_table = CFRetain (mac_uvs_table_adobe_japan1);
-              uvs_collection = kCTCharacterCollectionAdobeJapan1;
+              uvs_collection = NSAdobeJapan1CharacterCollection;
             }
         }
       if (uvs_table == NULL)
@@ -2538,8 +2536,7 @@ macfont_open (struct frame * f, Lisp_Object entity, int pixel_size)
   int size;
   CTFontRef macfont;
   CTFontSymbolicTraits sym_traits;
-  char name[256];
-  int len, i, total_width;
+  int i, total_width;
   CGGlyph glyph;
   CGFloat ascent, descent, leading;
 
@@ -3348,7 +3345,7 @@ static int
 macfont_variation_glyphs (struct font *font, int c, unsigned variations[256])
 {
   CFDataRef uvs_table;
-  CTCharacterCollection uvs_collection;
+  NSCharacterCollection uvs_collection;
   int i, n = 0;
 
   block_input ();
@@ -3368,7 +3365,7 @@ macfont_variation_glyphs (struct font *font, int c, unsigned variations[256])
         {
           CGGlyph glyph = glyphs[i];
 
-          if (uvs_collection != kCTCharacterCollectionIdentityMapping
+          if (uvs_collection != NSIdentityMappingCharacterCollection
               && glyph != kCGFontIndexInvalid)
             glyph = macfont_get_glyph_for_cid (font, uvs_collection, glyph);
           if (glyph == kCGFontIndexInvalid)
diff --git a/src/minibuf.c b/src/minibuf.c
index 1bbe276776e..d4128ce01c1 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -20,7 +20,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include <config.h>
 #include <errno.h>
-#include <stdio.h>
 
 #include <binary-io.h>
 
@@ -31,6 +30,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "frame.h"
 #include "window.h"
 #include "keymap.h"
+#include "sysstdio.h"
 #include "systty.h"
 
 /* List of buffers for use as minibuffers.
@@ -209,15 +209,15 @@ read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial,
       suppress_echo_on_tty (STDIN_FILENO);
     }
 
-  fwrite (SDATA (prompt), 1, SBYTES (prompt), stdout);
-  fflush (stdout);
+  fwrite_unlocked (SDATA (prompt), 1, SBYTES (prompt), stdout);
+  fflush_unlocked (stdout);
 
   val = Qnil;
   size = 100;
   len = 0;
   line = xmalloc (size);
 
-  while ((c = getchar ()) != '\n' && c != '\r')
+  while ((c = getchar_unlocked ()) != '\n' && c != '\r')
     {
       if (c == EOF)
         {
@@ -874,6 +874,30 @@ read_minibuf_unwind (void)
   if (minibuf_level == 0)
     resize_mini_window (XWINDOW (window), 0);
 
+  /* Deal with frames that should be removed when exiting the
+     minibuffer.  */
+  {
+    Lisp_Object frames, frame1, val;
+    struct frame *f1;
+
+    FOR_EACH_FRAME (frames, frame1)
+      {
+        f1 = XFRAME (frame1);
+
+        if ((FRAME_PARENT_FRAME (f1)
+             || !NILP (get_frame_param (f1, Qdelete_before)))
+            && !NILP (val = (get_frame_param (f1, Qminibuffer_exit))))
+          {
+            if (EQ (val, Qiconify_frame))
+              Ficonify_frame (frame1);
+            else if (EQ (val, Qdelete_frame))
+              Fdelete_frame (frame1, Qnil);
+            else
+              Fmake_frame_invisible (frame1, Qnil);
+          }
+      }
+  }
+
   /* In case the previous minibuffer displayed in this miniwindow is
      dead, we may keep displaying this buffer (tho it's inactive), so reset it,
      to make sure we don't leave around bindings and stuff which only
@@ -1930,6 +1954,8 @@ syms_of_minibuf (void)
   DEFSYM (Qactivate_input_method, "activate-input-method");
   DEFSYM (Qcase_fold_search, "case-fold-search");
   DEFSYM (Qmetadata, "metadata");
+  /* A frame parameter.  */
+  DEFSYM (Qminibuffer_exit, "minibuffer-exit");
 
   DEFVAR_LISP ("read-expression-history", Vread_expression_history,
                doc: /* A history list for arguments that are Lisp expressions to evaluate.
diff --git a/src/module-env-25.h b/src/module-env-25.h
new file mode 100644
index 00000000000..675010b995b
--- /dev/null
+++ b/src/module-env-25.h
@@ -0,0 +1,140 @@
+  /* Structure size (for version checking).  */
+  ptrdiff_t size;
+
+  /* Private data; users should not touch this.  */
+  struct emacs_env_private *private_members;
+
+  /* Memory management.  */
+
+  emacs_value (*make_global_ref) (emacs_env *env,
+                                  emacs_value any_reference)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  void (*free_global_ref) (emacs_env *env,
+                           emacs_value global_reference)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  /* Non-local exit handling.  */
+
+  enum emacs_funcall_exit (*non_local_exit_check) (emacs_env *env)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  void (*non_local_exit_clear) (emacs_env *env)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  enum emacs_funcall_exit (*non_local_exit_get)
+    (emacs_env *env,
+     emacs_value *non_local_exit_symbol_out,
+     emacs_value *non_local_exit_data_out)
+    EMACS_ATTRIBUTE_NONNULL(1, 2, 3);
+
+  void (*non_local_exit_signal) (emacs_env *env,
+                                 emacs_value non_local_exit_symbol,
+                                 emacs_value non_local_exit_data)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  void (*non_local_exit_throw) (emacs_env *env,
+                                emacs_value tag,
+                                emacs_value value)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  /* Function registration.  */
+
+  emacs_value (*make_function) (emacs_env *env,
+                                ptrdiff_t min_arity,
+                                ptrdiff_t max_arity,
+                                emacs_value (*function) (emacs_env *env,
+                                                         ptrdiff_t nargs,
+                                                         emacs_value args[],
+                                                         void *)
+                                  EMACS_NOEXCEPT
+                                  EMACS_ATTRIBUTE_NONNULL(1),
+                                const char *documentation,
+                                void *data)
+    EMACS_ATTRIBUTE_NONNULL(1, 4);
+
+  emacs_value (*funcall) (emacs_env *env,
+                          emacs_value function,
+                          ptrdiff_t nargs,
+                          emacs_value args[])
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  emacs_value (*intern) (emacs_env *env,
+                         const char *symbol_name)
+    EMACS_ATTRIBUTE_NONNULL(1, 2);
+
+  /* Type conversion.  */
+
+  emacs_value (*type_of) (emacs_env *env,
+                          emacs_value value)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  bool (*is_not_nil) (emacs_env *env, emacs_value value)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  bool (*eq) (emacs_env *env, emacs_value a, emacs_value b)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  intmax_t (*extract_integer) (emacs_env *env, emacs_value value)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  emacs_value (*make_integer) (emacs_env *env, intmax_t value)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  double (*extract_float) (emacs_env *env, emacs_value value)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  emacs_value (*make_float) (emacs_env *env, double value)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  /* Copy the content of the Lisp string VALUE to BUFFER as an utf8
+     null-terminated string.
+
+     SIZE must point to the total size of the buffer.  If BUFFER is
+     NULL or if SIZE is not big enough, write the required buffer size
+     to SIZE and return true.
+
+     Note that SIZE must include the last null byte (e.g. "abc" needs
+     a buffer of size 4).
+
+     Return true if the string was successfully copied.  */
+
+  bool (*copy_string_contents) (emacs_env *env,
+                                emacs_value value,
+                                char *buffer,
+                                ptrdiff_t *size_inout)
+    EMACS_ATTRIBUTE_NONNULL(1, 4);
+
+  /* Create a Lisp string from a utf8 encoded string.  */
+  emacs_value (*make_string) (emacs_env *env,
+                              const char *contents, ptrdiff_t length)
+    EMACS_ATTRIBUTE_NONNULL(1, 2);
+
+  /* Embedded pointer type.  */
+  emacs_value (*make_user_ptr) (emacs_env *env,
+                                void (*fin) (void *) EMACS_NOEXCEPT,
+                                void *ptr)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  void *(*get_user_ptr) (emacs_env *env, emacs_value uptr)
+    EMACS_ATTRIBUTE_NONNULL(1);
+  void (*set_user_ptr) (emacs_env *env, emacs_value uptr, void *ptr)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  void (*(*get_user_finalizer) (emacs_env *env, emacs_value uptr))
+    (void *) EMACS_NOEXCEPT EMACS_ATTRIBUTE_NONNULL(1);
+  void (*set_user_finalizer) (emacs_env *env,
+                              emacs_value uptr,
+                              void (*fin) (void *) EMACS_NOEXCEPT)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  /* Vector functions.  */
+  emacs_value (*vec_get) (emacs_env *env, emacs_value vec, ptrdiff_t i)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  void (*vec_set) (emacs_env *env, emacs_value vec, ptrdiff_t i,
+                   emacs_value val)
+    EMACS_ATTRIBUTE_NONNULL(1);
+
+  ptrdiff_t (*vec_size) (emacs_env *env, emacs_value vec)
+    EMACS_ATTRIBUTE_NONNULL(1);
diff --git a/src/module-env-26.h b/src/module-env-26.h
new file mode 100644
index 00000000000..1ab12d45c84
--- /dev/null
+++ b/src/module-env-26.h
@@ -0,0 +1,3 @@
+  /* Returns whether a quit is pending.  */
+  bool (*should_quit) (emacs_env *env)
+    EMACS_ATTRIBUTE_NONNULL(1);
diff --git a/src/nsfns.m b/src/nsfns.m
index 9e904c68382..68eba8b6a2e 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -175,6 +175,7 @@ ns_directory_from_panel (NSSavePanel *panel)
 #endif
 }
 
+#ifndef NS_IMPL_COCOA
 static Lisp_Object
 interpret_services_menu (NSMenu *menu, Lisp_Object prefix, Lisp_Object old)
 /* --------------------------------------------------------------------------
@@ -223,7 +224,7 @@ interpret_services_menu (NSMenu *menu, Lisp_Object prefix, Lisp_Object old)
     }
   return old;
 }
-
+#endif
 
 
 /* ==========================================================================
@@ -972,6 +973,18 @@ frame_parm_handler ns_frame_parm_handlers[] =
   0, /* x_set_sticky */
   0, /* x_set_tool_bar_position */
   0, /* x_set_inhibit_double_buffering */
+#ifdef NS_IMPL_COCOA
+  x_set_undecorated,
+#else
+  0, /*x_set_undecorated */
+#endif
+  x_set_parent_frame,
+  0, /* x_set_skip_taskbar */
+  x_set_no_focus_on_map,
+  x_set_no_accept_focus,
+  x_set_z_group, /* x_set_z_group */
+  0, /* x_set_override_redirect */
+  x_set_no_special_glyphs,
 };
 
 
@@ -1080,7 +1093,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
   ptrdiff_t count = specpdl_ptr - specpdl;
   Lisp_Object display;
   struct ns_display_info *dpyinfo = NULL;
-  Lisp_Object parent;
+  Lisp_Object parent, parent_frame;
   struct kboard *kb;
   static int desc_ctr = 1;
   int x_width = 0, x_height = 0;
@@ -1244,14 +1257,45 @@ This function is an internal primitive--use `make-frame' instead.  */)
                        "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
   x_default_parameter (f, parms, Qright_fringe, Qnil,
                        "rightFringe", "RightFringe", RES_TYPE_NUMBER);
+  x_default_parameter (f, parms, Qno_special_glyphs, Qnil,
+                       NULL, NULL, RES_TYPE_BOOLEAN);
 
   init_frame_faces (f);
 
   /* Read comment about this code in corresponding place in xfns.c.  */
+  tem = x_get_arg (dpyinfo, parms, Qmin_width, NULL, NULL, RES_TYPE_NUMBER);
+  if (NUMBERP (tem))
+    store_frame_param (f, Qmin_width, tem);
+  tem = x_get_arg (dpyinfo, parms, Qmin_height, NULL, NULL, RES_TYPE_NUMBER);
+  if (NUMBERP (tem))
+    store_frame_param (f, Qmin_height, tem);
   adjust_frame_size (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
                      FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 5, 1,
                      Qx_create_frame_1);
 
+  tem = x_get_arg (dpyinfo, parms, Qundecorated, NULL, NULL, RES_TYPE_BOOLEAN);
+  FRAME_UNDECORATED (f) = !NILP (tem) && !EQ (tem, Qunbound);
+  store_frame_param (f, Qundecorated, FRAME_UNDECORATED (f) ? Qt : Qnil);
+
+  parent_frame = x_get_arg (dpyinfo, parms, Qparent_frame, NULL, NULL,
+                            RES_TYPE_SYMBOL);
+  /* Accept parent-frame iff parent-id was not specified.  */
+  if (!NILP (parent)
+      || EQ (parent_frame, Qunbound)
+      || NILP (parent_frame)
+      || !FRAMEP (parent_frame)
+      || !FRAME_LIVE_P (XFRAME (parent_frame)))
+    parent_frame = Qnil;
+
+  fset_parent_frame (f, parent_frame);
+  store_frame_param (f, Qparent_frame, parent_frame);
+
+  x_default_parameter (f, parms, Qz_group, Qnil, NULL, NULL, RES_TYPE_SYMBOL);
+  x_default_parameter (f, parms, Qno_focus_on_map, Qnil,
+                       NULL, NULL, RES_TYPE_BOOLEAN);
+  x_default_parameter (f, parms, Qno_accept_focus, Qnil,
+                       NULL, NULL, RES_TYPE_BOOLEAN);
+
   /* The resources controlling the menu-bar and tool-bar are
      processed specially at startup, and reflected in the mode
      variables; ignore them here.  */
@@ -1284,6 +1328,15 @@ This function is an internal primitive--use `make-frame' instead.  */)
   f->output_data.ns->hourglass_cursor = [NSCursor disappearingItemCursor];
   f->output_data.ns->horizontal_drag_cursor = [NSCursor resizeLeftRightCursor];
   f->output_data.ns->vertical_drag_cursor = [NSCursor resizeUpDownCursor];
+  f->output_data.ns->left_edge_cursor = [NSCursor resizeLeftRightCursor];
+  f->output_data.ns->top_left_corner_cursor = [NSCursor arrowCursor];
+  f->output_data.ns->top_edge_cursor = [NSCursor resizeUpDownCursor];
+  f->output_data.ns->top_right_corner_cursor = [NSCursor arrowCursor];
+  f->output_data.ns->right_edge_cursor = [NSCursor resizeLeftRightCursor];
+  f->output_data.ns->bottom_right_corner_cursor = [NSCursor arrowCursor];
+  f->output_data.ns->bottom_edge_cursor = [NSCursor resizeUpDownCursor];
+  f->output_data.ns->bottom_left_corner_cursor = [NSCursor arrowCursor];
+
   FRAME_DISPLAY_INFO (f)->vertical_scroll_bar_cursor
      = [NSCursor arrowCursor];
   FRAME_DISPLAY_INFO (f)->horizontal_scroll_bar_cursor
@@ -1378,7 +1431,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
 }
 
 void
-x_focus_frame (struct frame *f)
+x_focus_frame (struct frame *f, bool noactivate)
 {
   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
 
@@ -1392,6 +1445,86 @@ x_focus_frame (struct frame *f)
     }
 }
 
+static BOOL
+ns_window_is_ancestor (NSWindow *win, NSWindow *candidate)
+/* Test whether CANDIDATE is an ancestor window of WIN. */
+{
+  if (candidate == NULL)
+    return NO;
+  else if (win == candidate)
+    return YES;
+  else
+    return ns_window_is_ancestor(win, [candidate parentWindow]);
+}
+
+DEFUN ("ns-frame-list-z-order", Fns_frame_list_z_order,
+       Sns_frame_list_z_order, 0, 1, 0,
+       doc: /* Return list of Emacs' frames, in Z (stacking) order.
+The optional argument TERMINAL specifies which display to ask about.
+TERMINAL should be either a frame or a display name (a string).  If
+omitted or nil, that stands for the selected frame's display.  Return
+nil if TERMINAL contains no Emacs frame.
+
+As a special case, if TERMINAL is non-nil and specifies a live frame,
+return the child frames of that frame in Z (stacking) order.
+
+Frames are listed from topmost (first) to bottommost (last).  */)
+  (Lisp_Object terminal)
+{
+  Lisp_Object frames = Qnil;
+  NSWindow *parent = nil;
+
+  if (FRAMEP (terminal) && FRAME_LIVE_P (XFRAME (terminal)))
+    parent = [FRAME_NS_VIEW (XFRAME (terminal)) window];
+  else if (!NILP (terminal))
+    return Qnil;
+
+  for (NSWindow *win in [[NSApp orderedWindows] reverseObjectEnumerator])
+    {
+      Lisp_Object frame;
+
+      /* Check against [win parentWindow] so that it doesn't match itself. */
+      if (parent == nil || ns_window_is_ancestor (parent, [win parentWindow]))
+        {
+          XSETFRAME (frame, ((EmacsView *)[win delegate])->emacsframe);
+          frames = Fcons(frame, frames);
+        }
+    }
+
+  return frames;
+}
+
+DEFUN ("ns-frame-restack", Fns_frame_restack, Sns_frame_restack, 2, 3, 0,
+       doc: /* Restack FRAME1 below FRAME2.
+This means that if both frames are visible and the display areas of
+these frames overlap, FRAME2 (partially) obscures FRAME1.  If optional
+third argument ABOVE is non-nil, restack FRAME1 above FRAME2.  This
+means that if both frames are visible and the display areas of these
+frames overlap, FRAME1 (partially) obscures FRAME2.
+
+Some window managers may refuse to restack windows.  */)
+     (Lisp_Object frame1, Lisp_Object frame2, Lisp_Object above)
+{
+  struct frame *f1 = decode_live_frame (frame1);
+  struct frame *f2 = decode_live_frame (frame2);
+
+  if (FRAME_NS_VIEW (f1) && FRAME_NS_VIEW (f2))
+    {
+      NSWindow *window = [FRAME_NS_VIEW (f1) window];
+      NSInteger window2 = [[FRAME_NS_VIEW (f2) window] windowNumber];
+      NSWindowOrderingMode flag = NILP (above) ? NSWindowBelow : NSWindowAbove;
+
+      [window orderWindow: flag
+               relativeTo: window2];
+
+      return Qt;
+    }
+  else
+    {
+      error ("Cannot restack frames");
+      return Qnil;
+    }
+}
 
 DEFUN ("ns-popup-font-panel", Fns_popup_font_panel, Sns_popup_font_panel,
        0, 1, "",
@@ -1989,9 +2122,6 @@ DEFUN ("ns-list-services", Fns_list_services, Sns_list_services, 0, 0, 0,
 #else
   Lisp_Object ret = Qnil;
   NSMenu *svcs;
-#ifdef NS_IMPL_COCOA
-  id delegate;
-#endif
 
   check_window_system (NULL);
   svcs = [[NSMenu alloc] initWithTitle: @"Services"];
@@ -1999,33 +2129,7 @@ DEFUN ("ns-list-services", Fns_list_services, Sns_list_services, 0, 0, 0,
   [NSApp registerServicesMenuSendTypes: ns_send_types
                            returnTypes: ns_return_types];
 
-/* On Tiger, services menu updating was made lazier (waits for user to
-   actually click on the menu), so we have to force things along: */
-#ifdef NS_IMPL_COCOA
-  delegate = [svcs delegate];
-  if (delegate != nil)
-    {
-      if ([delegate respondsToSelector: @selector (menuNeedsUpdate:)])
-        [delegate menuNeedsUpdate: svcs];
-      if ([delegate respondsToSelector:
-                       @selector (menu:updateItem:atIndex:shouldCancel:)])
-        {
-          int i, len = [delegate numberOfItemsInMenu: svcs];
-          for (i =0; i<len; i++)
-            [svcs addItemWithTitle: @"" action: NULL keyEquivalent: @""];
-          for (i =0; i<len; i++)
-            if (![delegate menu: svcs
-                     updateItem: (NSMenuItem *)[svcs itemAtIndex: i]
-                        atIndex: i shouldCancel: NO])
-              break;
-        }
-    }
-#endif
-
   [svcs setAutoenablesItems: NO];
-#ifdef NS_IMPL_COCOA
-  [svcs update]; /* on macOS, converts from '/' structure */
-#endif
 
   ret = interpret_services_menu (svcs, Qnil, ret);
   return ret;
@@ -2639,9 +2743,8 @@ compute_tip_xy (struct frame *f,
                 int *root_y)
 {
   Lisp_Object left, top, right, bottom;
-  EmacsView *view = FRAME_NS_VIEW (f);
-  struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
   NSPoint pt;
+  NSScreen *screen;
 
   /* Start with user-specified or mouse position.  */
   left = Fcdr (Fassq (Qleft, parms));
@@ -2651,22 +2754,7 @@ compute_tip_xy (struct frame *f,
 
   if ((!INTEGERP (left) && !INTEGERP (right))
       || (!INTEGERP (top) && !INTEGERP (bottom)))
-    {
-      pt.x = dpyinfo->last_mouse_motion_x;
-      pt.y = dpyinfo->last_mouse_motion_y;
-      /* Convert to screen coordinates */
-      pt = [view convertPoint: pt toView: nil];
-#if !defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
-      pt = [[view window] convertBaseToScreen: pt];
-#else
-      {
-        NSRect r = NSMakeRect (pt.x, pt.y, 0, 0);
-        r = [[view window] convertRectToScreen: r];
-        pt.x = r.origin.x;
-        pt.y = r.origin.y;
-      }
-#endif
-    }
+    pt = [NSEvent mouseLocation];
   else
     {
       /* Absolute coordinates.  */
@@ -2676,13 +2764,28 @@ compute_tip_xy (struct frame *f,
               - height);
     }
 
+  /* Find the screen that pt is on. */
+  for (screen in [NSScreen screens])
+    if (pt.x >= screen.frame.origin.x
+        && pt.x < screen.frame.origin.x + screen.frame.size.width
+        && pt.y >= screen.frame.origin.y
+        && pt.y < screen.frame.origin.y + screen.frame.size.height)
+      break;
+
+  /* We could use this instead of the if above:
+
+         if (CGRectContainsPoint ([screen frame], pt))
+
+     which would be neater, but it causes problems building on old
+     versions of macOS and in GNUstep. */
+
   /* Ensure in bounds.  (Note, screen origin = lower left.) */
   if (INTEGERP (left) || INTEGERP (right))
     *root_x = pt.x;
-  else if (pt.x + XINT (dx) <= 0)
-    *root_x = 0; /* Can happen for negative dx */
+  else if (pt.x + XINT (dx) <= screen.frame.origin.x)
+    *root_x = screen.frame.origin.x; /* Can happen for negative dx */
   else if (pt.x + XINT (dx) + width
-           <= x_display_pixel_width (FRAME_DISPLAY_INFO (f)))
+           <= screen.frame.origin.x + screen.frame.size.width)
     /* It fits to the right of the pointer.  */
     *root_x = pt.x + XINT (dx);
   else if (width + XINT (dx) <= pt.x)
@@ -2690,20 +2793,20 @@ compute_tip_xy (struct frame *f,
     *root_x = pt.x - width - XINT (dx);
   else
     /* Put it left justified on the screen -- it ought to fit that way.  */
-    *root_x = 0;
+    *root_x = screen.frame.origin.x;
 
   if (INTEGERP (top) || INTEGERP (bottom))
     *root_y = pt.y;
-  else if (pt.y - XINT (dy) - height >= 0)
+  else if (pt.y - XINT (dy) - height >= screen.frame.origin.y)
     /* It fits below the pointer.  */
     *root_y = pt.y - height - XINT (dy);
   else if (pt.y + XINT (dy) + height
-           <= x_display_pixel_height (FRAME_DISPLAY_INFO (f)))
+           <= screen.frame.origin.y + screen.frame.size.height)
     /* It fits above the pointer */
       *root_y = pt.y + XINT (dy);
   else
     /* Put it on the top.  */
-    *root_y = x_display_pixel_height (FRAME_DISPLAY_INFO (f)) - height;
+    *root_y = screen.frame.origin.y + screen.frame.size.height - height;
 }
 
 
@@ -2935,6 +3038,48 @@ menu bar or tool bar of FRAME.  */)
                                  : Qnative_edges));
 }
 
+DEFUN ("ns-set-mouse-absolute-pixel-position",
+       Fns_set_mouse_absolute_pixel_position,
+       Sns_set_mouse_absolute_pixel_position, 2, 2, 0,
+       doc: /* Move mouse pointer to absolute pixel position (X, Y).
+The coordinates X and Y are interpreted in pixels relative to a position
+\(0, 0) of the selected frame's display.  */)
+       (Lisp_Object x, Lisp_Object y)
+{
+#ifdef NS_IMPL_COCOA
+  /* GNUstep doesn't support CGWarpMouseCursorPosition, so none of
+     this will work. */
+  struct frame *f = SELECTED_FRAME ();
+  EmacsView *view = FRAME_NS_VIEW (f);
+  NSScreen *screen = [[view window] screen];
+  NSRect screen_frame = [screen frame];
+  int mouse_x, mouse_y;
+
+  NSScreen *primary_screen = [[NSScreen screens] objectAtIndex:0];
+  NSRect primary_screen_frame = [primary_screen frame];
+  CGFloat primary_screen_height = primary_screen_frame.size.height;
+
+  if (FRAME_INITIAL_P (f) || !FRAME_NS_P (f))
+    return Qnil;
+
+  CHECK_TYPE_RANGED_INTEGER (int, x);
+  CHECK_TYPE_RANGED_INTEGER (int, y);
+
+  mouse_x = screen_frame.origin.x + XINT (x);
+
+  if (screen == primary_screen)
+    mouse_y = screen_frame.origin.y + XINT (y);
+  else
+    mouse_y = (primary_screen_height - screen_frame.size.height
+               - screen_frame.origin.y) + XINT (y);
+
+  CGPoint mouse_pos = CGPointMake(mouse_x, mouse_y);
+  CGWarpMouseCursorPosition (mouse_pos);
+#endif /* NS_IMPL_COCOA */
+
+  return Qnil;
+}
+
 /* ==========================================================================
 
     Class implementations
@@ -3121,6 +3266,9 @@ be used as the image of the icon representing the frame.  */);
   defsubr (&Sns_display_monitor_attributes_list);
   defsubr (&Sns_frame_geometry);
   defsubr (&Sns_frame_edges);
+  defsubr (&Sns_frame_list_z_order);
+  defsubr (&Sns_frame_restack);
+  defsubr (&Sns_set_mouse_absolute_pixel_position);
   defsubr (&Sx_display_mm_width);
   defsubr (&Sx_display_mm_height);
   defsubr (&Sx_display_screens);
diff --git a/src/nsimage.m b/src/nsimage.m
index cc8abf76094..fb2322afc30 100644
--- a/src/nsimage.m
+++ b/src/nsimage.m
@@ -152,7 +152,7 @@ ns_set_alpha (void *img, int x, int y, unsigned char a)
 
 @implementation EmacsImage
 
-+ allocInitFromFile: (Lisp_Object)file
++ (instancetype)allocInitFromFile: (Lisp_Object)file
 {
   NSImageRep *imgRep;
   Lisp_Object found;
@@ -197,7 +197,7 @@ ns_set_alpha (void *img, int x, int y, unsigned char a)
 
 /* Create image from monochrome bitmap. If both FG and BG are 0
    (black), set the background to white and make it transparent. */
-- initFromXBM: (unsigned char *)bits width: (int)w height: (int)h
+- (instancetype)initFromXBM: (unsigned char *)bits width: (int)w height: (int)h
            fg: (unsigned long)fg bg: (unsigned long)bg
 {
   unsigned char *planes[5];
@@ -269,7 +269,7 @@ ns_set_alpha (void *img, int x, int y, unsigned char a)
 }
 
 /* Set color for a bitmap image.  */
-- setXBMColor: (NSColor *)color
+- (instancetype)setXBMColor: (NSColor *)color
 {
   NSSize s = [self size];
   unsigned char *planes[5];
@@ -302,14 +302,14 @@ ns_set_alpha (void *img, int x, int y, unsigned char a)
           planes[1][i] = gg;
           planes[2][i] = bb;
         }
-    xbm_fg = ((rr << 16) & 0xff) + ((gg << 8) & 0xff) + (bb & 0xff);
+    xbm_fg = ((rr << 16) & 0xff0000) + ((gg << 8) & 0xff00) + (bb & 0xff);
   }
 
   return self;
 }
 
 
-- initForXPMWithDepth: (int)depth width: (int)width height: (int)height
+- (instancetype)initForXPMWithDepth: (int)depth width: (int)width height: (int)height
 {
   NSSize s = {width, height};
   int i;
@@ -386,7 +386,7 @@ ns_set_alpha (void *img, int x, int y, unsigned char a)
 
 - (void) setPixelAtX: (int)x Y: (int)y toRed: (unsigned char)r
                green: (unsigned char)g blue: (unsigned char)b
-               alpha:(unsigned char)a;
+               alpha:(unsigned char)a
 {
   if (bmRep == nil)
     return;
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 59ea3855ed1..37a1a62d6d3 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -493,7 +493,7 @@ x_activate_menubar (struct frame *f)
 @implementation EmacsMenu
 
 /* override designated initializer */
-- initWithTitle: (NSString *)title
+- (instancetype)initWithTitle: (NSString *)title
 {
   frame = 0;
   if ((self = [super initWithTitle: title]))
@@ -503,7 +503,7 @@ x_activate_menubar (struct frame *f)
 
 
 /* used for top-level */
-- initWithTitle: (NSString *)title frame: (struct frame *)f
+- (instancetype)initWithTitle: (NSString *)title frame: (struct frame *)f
 {
   [self initWithTitle: title];
   frame = f;
@@ -750,7 +750,7 @@ x_activate_menubar (struct frame *f)
                          modifierFlags: 0
                              timestamp: [e timestamp]
                           windowNumber: [[view window] windowNumber]
-                               context: [e context]
+                               context: nil
                            eventNumber: 0/*[e eventNumber] */
                             clickCount: 1
                               pressure: 0];
@@ -995,8 +995,6 @@ free_frame_tool_bar (struct frame *f)
   block_input ();
   view->wait_for_tool_bar = NO;
 
-  FRAME_TOOLBAR_HEIGHT (f) = 0;
-
   /* Note: This trigger an animation, which calls windowDidResize
      repeatedly. */
   f->output_data.ns->in_animation = 1;
@@ -1014,7 +1012,6 @@ update_frame_tool_bar (struct frame *f)
 {
   int i, k = 0;
   EmacsView *view = FRAME_NS_VIEW (f);
-  NSWindow *window = [view window];
   EmacsToolbar *toolbar = [view toolbar];
   int oldh;
 
@@ -1129,12 +1126,6 @@ update_frame_tool_bar (struct frame *f)
     }
 #endif
 
-  FRAME_TOOLBAR_HEIGHT (f) =
-    NSHeight ([window frameRectForContentRect: NSMakeRect (0, 0, 0, 0)])
-    - FRAME_NS_TITLEBAR_HEIGHT (f);
-  if (FRAME_TOOLBAR_HEIGHT (f) < 0) // happens if frame is fullscreen.
-    FRAME_TOOLBAR_HEIGHT (f) = 0;
-
   if (oldh != FRAME_TOOLBAR_HEIGHT (f))
     [view updateFrameSize:YES];
   if (view->wait_for_tool_bar && FRAME_TOOLBAR_HEIGHT (f) > 0)
@@ -1155,7 +1146,7 @@ update_frame_tool_bar (struct frame *f)
 
 @implementation EmacsToolbar
 
-- initForView: (EmacsView *)view withIdentifier: (NSString *)identifier
+- (instancetype)initForView: (EmacsView *)view withIdentifier: (NSString *)identifier
 {
   NSTRACE ("[EmacsToolbar initForView: withIdentifier:]");
 
@@ -1311,7 +1302,7 @@ update_frame_tool_bar (struct frame *f)
    display. */
 @implementation EmacsTooltip
 
-- init
+- (instancetype)init
 {
   NSColor *col = [NSColor colorWithCalibratedRed: 1.0 green: 1.0
                                             blue: 0.792 alpha: 0.95];
@@ -1502,7 +1493,7 @@ ns_popup_dialog (struct frame *f, Lisp_Object header, Lisp_Object contents)
 #define TEXTHEIGHT      20.0
 #define MINCELLWIDTH    90.0
 
-- initWithContentRect: (NSRect)contentRect styleMask: (NSUInteger)aStyle
+- (instancetype)initWithContentRect: (NSRect)contentRect styleMask: (NSWindowStyleMask)aStyle
               backing: (NSBackingStoreType)backingType defer: (BOOL)flag
 {
   NSSize spacing = {SPACER, SPACER};
@@ -1526,7 +1517,7 @@ ns_popup_dialog (struct frame *f, Lisp_Object header, Lisp_Object contents)
   [img autorelease];
   [imgView autorelease];
 
-  aStyle = NSWindowStyleMaskTitled|NSWindowStyleMaskClosable|NSUtilityWindowMask;
+  aStyle = NSWindowStyleMaskTitled|NSWindowStyleMaskClosable|NSWindowStyleMaskUtilityWindow;
   flag = YES;
   rows = 0;
   cols = 1;
@@ -1706,7 +1697,7 @@ ns_popup_dialog (struct frame *f, Lisp_Object header, Lisp_Object contents)
 }
 
 
-- initFromContents: (Lisp_Object)contents isQuestion: (BOOL)isQ
+- (instancetype)initFromContents: (Lisp_Object)contents isQuestion: (BOOL)isQ
 {
   Lisp_Object head;
   [super init];
diff --git a/src/nsterm.h b/src/nsterm.h
index 53d9344cc78..0f1b36db7b2 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -356,6 +356,12 @@ char const * nstrace_fullscreen_type_name (int);
 #endif
 
 
+/* If the compiler doesn't support instancetype, map it to id. */
+#ifndef NATIVE_OBJC_INSTANCETYPE
+typedef id instancetype;
+#endif
+
+
 /* ==========================================================================
 
    NSColor, EmacsColor category.
@@ -430,7 +436,7 @@ char const * nstrace_fullscreen_type_name (int);
    NSString *workingText;
    BOOL processingCompose;
    int fs_state, fs_before_fs, next_maximized;
-   int tibar_height, tobar_height, bwidth;
+   int bwidth;
    int maximized_width, maximized_height;
    NSWindow *nonfs_window;
    BOOL fs_is_native;
@@ -444,16 +450,17 @@ char const * nstrace_fullscreen_type_name (int);
    }
 
 /* AppKit-side interface */
-- menuDown: (id)sender;
-- toolbarClicked: (id)item;
-- toggleToolbar: (id)sender;
+- (instancetype)menuDown: (id)sender;
+- (instancetype)toolbarClicked: (id)item;
+- (instancetype)toggleToolbar: (id)sender;
 - (void)keyDown: (NSEvent *)theEvent;
 - (void)mouseDown: (NSEvent *)theEvent;
 - (void)mouseUp: (NSEvent *)theEvent;
-- setMiniwindowImage: (BOOL)setMini;
+- (instancetype)setMiniwindowImage: (BOOL)setMini;
 
 /* Emacs-side interface */
-- initFrameFromEmacs: (struct frame *) f;
+- (instancetype) initFrameFromEmacs: (struct frame *) f;
+- (void) createToolbar: (struct frame *)f;
 - (void) setRows: (int) r andColumns: (int) c;
 - (void) setWindowClosing: (BOOL)closing;
 - (EmacsToolbar *) toolbar;
@@ -512,7 +519,7 @@ char const * nstrace_fullscreen_type_name (int);
   unsigned long keyEquivModMask;
 }
 
-- initWithTitle: (NSString *)title frame: (struct frame *)f;
+- (instancetype)initWithTitle: (NSString *)title frame: (struct frame *)f;
 - (void)setFrame: (struct frame *)f;
 - (void)menuNeedsUpdate: (NSMenu *)menu; /* (delegate method) */
 - (NSString *)parseKeyEquiv: (const char *)key;
@@ -546,7 +553,7 @@ char const * nstrace_fullscreen_type_name (int);
      NSArray *prevIdentifiers;
      unsigned long enablement, prevEnablement;
    }
-- initForView: (EmacsView *)view withIdentifier: (NSString *)identifier;
+- (instancetype) initForView: (EmacsView *)view withIdentifier: (NSString *)identifier;
 - (void) clearActive;
 - (void) clearAll;
 - (BOOL) changed;
@@ -581,7 +588,7 @@ char const * nstrace_fullscreen_type_name (int);
    Lisp_Object dialog_return;
    Lisp_Object *button_values;
    }
-- initFromContents: (Lisp_Object)menu isQuestion: (BOOL)isQ;
+- (instancetype)initFromContents: (Lisp_Object)menu isQuestion: (BOOL)isQ;
 - (void)process_dialog: (Lisp_Object)list;
 - (void)addButton: (char *)str value: (int)tag row: (int)row;
 - (void)addString: (char *)str row: (int)row;
@@ -600,7 +607,7 @@ char const * nstrace_fullscreen_type_name (int);
     NSTextField *textField;
     NSTimer *timer;
   }
-- init;
+- (instancetype) init;
 - (void) setText: (char *)text;
 - (void) showAtX: (int)x Y: (int)y for: (int)seconds;
 - (void) hide;
@@ -648,12 +655,12 @@ char const * nstrace_fullscreen_type_name (int);
   NSColor *stippleMask;
   unsigned long xbm_fg;
 }
-+ allocInitFromFile: (Lisp_Object)file;
++ (instancetype)allocInitFromFile: (Lisp_Object)file;
 - (void)dealloc;
-- initFromXBM: (unsigned char *)bits width: (int)w height: (int)h
+- (instancetype)initFromXBM: (unsigned char *)bits width: (int)w height: (int)h
                   fg: (unsigned long)fg bg: (unsigned long)bg;
-- setXBMColor: (NSColor *)color;
-- initForXPMWithDepth: (int)depth width: (int)width height: (int)height;
+- (instancetype)setXBMColor: (NSColor *)color;
+- (instancetype)initForXPMWithDepth: (int)depth width: (int)width height: (int)height;
 - (void)setPixmapData;
 - (unsigned long)getPixelAtX: (int)x Y: (int)y;
 - (void)setPixelAtX: (int)x Y: (int)y toRed: (unsigned char)r
@@ -692,16 +699,16 @@ char const * nstrace_fullscreen_type_name (int);
    int em_whole;
    }
 
-- initFrame: (NSRect )r window: (Lisp_Object)win;
+- (instancetype) initFrame: (NSRect )r window: (Lisp_Object)win;
 - (void)setFrame: (NSRect)r;
 
-- setPosition: (int) position portion: (int) portion whole: (int) whole;
+- (instancetype) setPosition: (int) position portion: (int) portion whole: (int) whole;
 - (int) checkSamePosition: (int)position portion: (int)portion
                     whole: (int)whole;
 - (void) sendScrollEventAtLoc: (float)loc fromEvent: (NSEvent *)e;
-- repeatScroll: (NSTimer *)sender;
-- condemn;
-- reprieve;
+- (instancetype)repeatScroll: (NSTimer *)sender;
+- (instancetype)condemn;
+- (instancetype)reprieve;
 - (bool)judge;
 + (CGFloat)scrollerWidth;
 @end
@@ -724,7 +731,7 @@ char const * nstrace_fullscreen_type_name (int);
   unsigned long maxChar, maxGlyph;
   long i, len;
 }
-- initWithCapacity: (unsigned long) c;
+- (instancetype)initWithCapacity: (unsigned long) c;
 - (void) setString: (NSString *)str font: (NSFont *)font;
 @end
 #endif  /* NS_IMPL_COCOA */
@@ -950,6 +957,14 @@ struct ns_output
   Cursor hourglass_cursor;
   Cursor horizontal_drag_cursor;
   Cursor vertical_drag_cursor;
+  Cursor left_edge_cursor;
+  Cursor top_left_corner_cursor;
+  Cursor top_edge_cursor;
+  Cursor top_right_corner_cursor;
+  Cursor right_edge_cursor;
+  Cursor bottom_right_corner_cursor;
+  Cursor bottom_edge_cursor;
+  Cursor bottom_left_corner_cursor;
 
   /* NS-specific */
   Cursor current_pointer;
@@ -1012,8 +1027,6 @@ struct x_output
 
 #define NS_FACE_FOREGROUND(f) ((f)->foreground)
 #define NS_FACE_BACKGROUND(f) ((f)->background)
-#define FRAME_NS_TITLEBAR_HEIGHT(f) ((f)->output_data.ns->titlebar_height)
-#define FRAME_TOOLBAR_HEIGHT(f) ((f)->output_data.ns->toolbar_height)
 
 #define FRAME_DEFAULT_FACE(f) FACE_FROM_ID_OR_NULL (f, DEFAULT_FACE_ID)
 
@@ -1029,6 +1042,25 @@ struct x_output
 #define XNS_SCROLL_BAR(vec) XSAVE_POINTER (vec, 0)
 #endif
 
+/* Compute pixel height of the frame's titlebar. */
+#define FRAME_NS_TITLEBAR_HEIGHT(f)                                     \
+  (NSHeight([FRAME_NS_VIEW (f) frame]) == 0 ?                           \
+   0                                                                    \
+   : (int)(NSHeight([FRAME_NS_VIEW (f) window].frame)                   \
+           - NSHeight([NSWindow contentRectForFrameRect:                \
+                       [[FRAME_NS_VIEW (f) window] frame]               \
+                       styleMask:[[FRAME_NS_VIEW (f) window] styleMask]])))
+
+/* Compute pixel height of the toolbar. */
+#define FRAME_TOOLBAR_HEIGHT(f)                                         \
+  (([[FRAME_NS_VIEW (f) window] toolbar] == nil                         \
+    || ! [[FRAME_NS_VIEW (f) window] toolbar].isVisible) ?              \
+   0                                                                    \
+   : (int)(NSHeight([NSWindow contentRectForFrameRect:                  \
+                     [[FRAME_NS_VIEW (f) window] frame]                 \
+                     styleMask:[[FRAME_NS_VIEW (f) window] styleMask]]) \
+           - NSHeight([[[FRAME_NS_VIEW (f) window] contentView] frame])))
+
 /* Compute pixel size for vertical scroll bars */
 #define NS_SCROLL_BAR_WIDTH(f)                                          \
   (FRAME_HAS_VERTICAL_SCROLL_BARS (f)                                   \
@@ -1059,12 +1091,17 @@ struct x_output
    (FRAME_SCROLL_BAR_LINES (f) * FRAME_LINE_HEIGHT (f)  \
     - NS_SCROLL_BAR_HEIGHT (f)) : 0)
 
-/* XXX: fix for GNUstep inconsistent accounting for titlebar */
-#ifdef NS_IMPL_GNUSTEP
-#define NS_TOP_POS(f) ((f)->top_pos + 18)
-#else
-#define NS_TOP_POS(f) ((f)->top_pos)
-#endif
+/* Calculate system coordinates of the left and top of the parent
+   window or, if there is no parent window, the screen. */
+#define NS_PARENT_WINDOW_LEFT_POS(f)                                    \
+  (FRAME_PARENT_FRAME (f) != NULL                                       \
+   ? [[FRAME_NS_VIEW (f) window] parentWindow].frame.origin.x : 0)
+#define NS_PARENT_WINDOW_TOP_POS(f)                                     \
+  (FRAME_PARENT_FRAME (f) != NULL                                       \
+   ? ([[FRAME_NS_VIEW (f) window] parentWindow].frame.origin.y          \
+      + [[FRAME_NS_VIEW (f) window] parentWindow].frame.size.height     \
+      - FRAME_NS_TITLEBAR_HEIGHT (FRAME_PARENT_FRAME (f)))              \
+   : [[[NSScreen screens] objectAtIndex: 0] frame].size.height)
 
 #define FRAME_NS_FONT_TABLE(f) (FRAME_DISPLAY_INFO (f)->font_table)
 
@@ -1185,9 +1222,22 @@ extern int x_display_pixel_width (struct ns_display_info *);
 /* This in nsterm.m */
 extern float ns_antialias_threshold;
 extern void x_destroy_window (struct frame *f);
+extern void x_set_undecorated (struct frame *f, Lisp_Object new_value,
+                               Lisp_Object old_value);
+extern void x_set_parent_frame (struct frame *f, Lisp_Object new_value,
+                                Lisp_Object old_value);
+extern void x_set_no_focus_on_map (struct frame *f, Lisp_Object new_value,
+                                   Lisp_Object old_value);
+extern void x_set_no_accept_focus (struct frame *f, Lisp_Object new_value,
+                                   Lisp_Object old_value);
+extern void x_set_z_group (struct frame *f, Lisp_Object new_value,
+                           Lisp_Object old_value);
 extern int ns_select (int nfds, fd_set *readfds, fd_set *writefds,
-                      fd_set *exceptfds, struct timespec const *timeout,
-                      sigset_t const *sigmask);
+                      fd_set *exceptfds, struct timespec *timeout,
+                      sigset_t *sigmask);
+#ifdef HAVE_PTHREAD
+extern void ns_run_loop_break (void);
+#endif
 extern unsigned long ns_get_rgb_color (struct frame *f,
                                        float r, float g, float b, float a);
 
@@ -1259,8 +1309,14 @@ extern char gnustep_base_version[];  /* version tracking */
 #define NSWindowStyleMaskMiniaturizable    NSMiniaturizableWindowMask
 #define NSWindowStyleMaskResizable         NSResizableWindowMask
 #define NSWindowStyleMaskTitled            NSTitledWindowMask
+#define NSWindowStyleMaskUtilityWindow     NSUtilityWindowMask
 #define NSAlertStyleCritical               NSCriticalAlertStyle
 #define NSControlSizeRegular               NSRegularControlSize
+
+/* And adds NSWindowStyleMask. */
+#ifdef __OBJC__
+typedef NSUInteger NSWindowStyleMask;
+#endif
 #endif
 
 #endif  /* HAVE_NS */
diff --git a/src/nsterm.m b/src/nsterm.m
index b03ad526212..bf83550b3d7 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -411,6 +411,23 @@ static CGPoint menu_mouse_point;
       ns_send_appdefined (-1);                                          \
     }
 
+
+/* GNUstep always shows decorations if the window is resizable,
+   miniaturizable or closable, but Cocoa does strange things in native
+   fullscreen mode if you don't have at least resizable enabled.
+
+   These flags will be OR'd or XOR'd with the NSWindow's styleMask
+   property depending on what we're doing. */
+#ifdef NS_IMPL_COCOA
+#define FRAME_DECORATED_FLAGS NSWindowStyleMaskTitled
+#else
+#define FRAME_DECORATED_FLAGS (NSWindowStyleMaskTitled              \
+                               | NSWindowStyleMaskResizable         \
+                               | NSWindowStyleMaskMiniaturizable    \
+                               | NSWindowStyleMaskClosable)
+#endif
+#define FRAME_UNDECORATED_FLAGS NSWindowStyleMaskBorderless
+
 /* TODO: get rid of need for these forward declarations */
 static void ns_condemn_scroll_bars (struct frame *f);
 static void ns_judge_scroll_bars (struct frame *f);
@@ -1300,7 +1317,7 @@ ns_clip_to_row (struct window *w, struct glyph_row *row,
 
 @implementation EmacsBell
 
-- (id)init;
+- (id)init
 {
   NSTRACE ("[EmacsBell init]");
   if ((self = [super init]))
@@ -1446,9 +1463,9 @@ hide_bell (void)
 
 
 static void
-ns_raise_frame (struct frame *f)
+ns_raise_frame (struct frame *f, BOOL make_key)
 /* --------------------------------------------------------------------------
-     Bring window to foreground and make it active
+     Bring window to foreground and if make_key is YES, give it focus.
    -------------------------------------------------------------------------- */
 {
   NSView *view;
@@ -1457,7 +1474,12 @@ ns_raise_frame (struct frame *f)
   view = FRAME_NS_VIEW (f);
   block_input ();
   if (FRAME_VISIBLE_P (f))
-    [[view window] makeKeyAndOrderFront: NSApp];
+    {
+      if (make_key)
+        [[view window] makeKeyAndOrderFront: NSApp];
+      else
+        [[view window] orderFront: NSApp];
+    }
   unblock_input ();
 }
 
@@ -1487,7 +1509,7 @@ ns_frame_raise_lower (struct frame *f, bool raise)
   NSTRACE ("ns_frame_raise_lower");
 
   if (raise)
-    ns_raise_frame (f);
+    ns_raise_frame (f, YES);
   else
     ns_lower_frame (f);
 }
@@ -1550,7 +1572,7 @@ x_make_frame_visible (struct frame *f)
       EmacsView *view = (EmacsView *)FRAME_NS_VIEW (f);
 
       SET_FRAME_VISIBLE (f, 1);
-      ns_raise_frame (f);
+      ns_raise_frame (f, ! FRAME_NO_FOCUS_ON_MAP (f));
 
       /* Making a new frame from a fullscreen frame will make the new frame
          fullscreen also.  So skip handleFS as this will print an error.  */
@@ -1668,6 +1690,17 @@ x_destroy_window (struct frame *f)
    -------------------------------------------------------------------------- */
 {
   NSTRACE ("x_destroy_window");
+
+  /* If this frame has a parent window, detach it as not doing so can
+     cause a crash in GNUStep. */
+  if (FRAME_PARENT_FRAME (f) != NULL)
+    {
+      NSWindow *child = [FRAME_NS_VIEW (f) window];
+      NSWindow *parent = [FRAME_NS_VIEW (FRAME_PARENT_FRAME (f)) window];
+
+      [parent removeChildWindow: child];
+    }
+
   check_window_system (f);
   x_free_frame_resources (f);
   ns_window_num--;
@@ -1706,14 +1739,18 @@ x_set_offset (struct frame *f, int xoff, int yoff, int change_grav)
            - FRAME_TOOLBAR_HEIGHT (f))
         : f->top_pos;
 #ifdef NS_IMPL_GNUSTEP
-      if (f->left_pos < 100)
-        f->left_pos = 100;  /* don't overlap menu */
+      if (FRAME_PARENT_FRAME (f) == NULL)
+        {
+          if (f->left_pos < 100)
+            f->left_pos = 100;  /* don't overlap menu */
+        }
 #endif
       /* Constrain the setFrameTopLeftPoint so we don't move behind the
          menu bar.  */
-      NSPoint pt = NSMakePoint (SCREENMAXBOUND (f->left_pos),
-                                SCREENMAXBOUND ([fscreen frame].size.height
-                                                - NS_TOP_POS (f)));
+      NSPoint pt = NSMakePoint (SCREENMAXBOUND (f->left_pos
+                                                + NS_PARENT_WINDOW_LEFT_POS (f)),
+                                SCREENMAXBOUND (NS_PARENT_WINDOW_TOP_POS (f)
+                                                - f->top_pos));
       NSTRACE_POINT ("setFrameTopLeftPoint", pt);
       [[view window] setFrameTopLeftPoint: pt];
       f->size_hint_flags &= ~(XNegative|YNegative);
@@ -1738,7 +1775,6 @@ x_set_window_size (struct frame *f,
   EmacsView *view = FRAME_NS_VIEW (f);
   NSWindow *window = [view window];
   NSRect wr = [window frame];
-  int tb = FRAME_EXTERNAL_TOOL_BAR (f);
   int pixelwidth, pixelheight;
   int orig_height = wr.size.height;
 
@@ -1764,25 +1800,6 @@ x_set_window_size (struct frame *f,
       pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height);
     }
 
-  /* If we have a toolbar, take its height into account. */
-  if (tb && ! [view isFullscreen])
-    {
-    /* NOTE: previously this would generate wrong result if toolbar not
-             yet displayed and fixing toolbar_height=32 helped, but
-             now (200903) seems no longer needed */
-    FRAME_TOOLBAR_HEIGHT (f) =
-      NSHeight ([window frameRectForContentRect: NSMakeRect (0, 0, 0, 0)])
-        - FRAME_NS_TITLEBAR_HEIGHT (f);
-#if 0
-      /* Only breaks things here, removed by martin 2015-09-30.  */
-#ifdef NS_IMPL_GNUSTEP
-      FRAME_TOOLBAR_HEIGHT (f) -= 3;
-#endif
-#endif
-    }
-  else
-    FRAME_TOOLBAR_HEIGHT (f) = 0;
-
   wr.size.width = pixelwidth + f->border_width;
   wr.size.height = pixelheight;
   if (! [view isFullscreen])
@@ -1811,6 +1828,184 @@ x_set_window_size (struct frame *f,
   unblock_input ();
 }
 
+#ifdef NS_IMPL_COCOA
+void
+x_set_undecorated (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+/* --------------------------------------------------------------------------
+     Set frame F's `undecorated' parameter.  If non-nil, F's window-system
+     window is drawn without decorations, title, minimize/maximize boxes
+     and external borders.  This usually means that the window cannot be
+     dragged, resized, iconified, maximized or deleted with the mouse.  If
+     nil, draw the frame with all the elements listed above unless these
+     have been suspended via window manager settings.
+
+     GNUStep cannot change an existing window's style.
+   -------------------------------------------------------------------------- */
+{
+  EmacsView *view = (EmacsView *)FRAME_NS_VIEW (f);
+  NSWindow *window = [view window];
+
+  NSTRACE ("x_set_undecorated");
+
+  if (!EQ (new_value, old_value))
+    {
+      block_input ();
+
+      if (NILP (new_value))
+        {
+          FRAME_UNDECORATED (f) = false;
+          [window setStyleMask: ((window.styleMask | FRAME_DECORATED_FLAGS)
+                                  ^ FRAME_UNDECORATED_FLAGS)];
+
+          [view createToolbar: f];
+        }
+      else
+        {
+          [window setToolbar: nil];
+          /* Do I need to release the toolbar here? */
+
+          FRAME_UNDECORATED (f) = true;
+          [window setStyleMask: ((window.styleMask | FRAME_UNDECORATED_FLAGS)
+                                 ^ FRAME_DECORATED_FLAGS)];
+        }
+
+      /* At this point it seems we don't have an active NSResponder,
+         so some key presses (TAB) are swallowed by the system. */
+      [window makeFirstResponder: view];
+
+      [view updateFrameSize: NO];
+      unblock_input ();
+    }
+}
+#endif /* NS_IMPL_COCOA */
+
+void
+x_set_parent_frame (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+/* --------------------------------------------------------------------------
+     Set frame F's `parent-frame' parameter.  If non-nil, make F a child
+     frame of the frame specified by that parameter.  Technically, this
+     makes F's window-system window a child window of the parent frame's
+     window-system window.  If nil, make F's window-system window a
+     top-level window--a child of its display's root window.
+
+     A child frame's `left' and `top' parameters specify positions
+     relative to the top-left corner of its parent frame's native
+     rectangle.  On macOS moving a parent frame moves all its child
+     frames too, keeping their position relative to the parent
+     unaltered.  When a parent frame is iconified or made invisible, its
+     child frames are made invisible.  When a parent frame is deleted,
+     its child frames are deleted too.
+
+     Whether a child frame has a tool bar may be window-system or window
+     manager dependent.  It's advisable to disable it via the frame
+     parameter settings.
+
+     Some window managers may not honor this parameter.
+   -------------------------------------------------------------------------- */
+{
+  struct frame *p = NULL;
+  NSWindow *parent, *child;
+
+  NSTRACE ("x_set_parent_frame");
+
+  if (!NILP (new_value)
+      && (!FRAMEP (new_value)
+          || !FRAME_LIVE_P (p = XFRAME (new_value))
+          || !FRAME_X_P (p)))
+    {
+      store_frame_param (f, Qparent_frame, old_value);
+      error ("Invalid specification of `parent-frame'");
+    }
+
+  if (p != FRAME_PARENT_FRAME (f))
+    {
+      parent = [FRAME_NS_VIEW (p) window];
+      child = [FRAME_NS_VIEW (f) window];
+
+      block_input ();
+      [parent addChildWindow: child
+                     ordered: NSWindowAbove];
+      unblock_input ();
+
+      fset_parent_frame (f, new_value);
+    }
+}
+
+void
+x_set_no_focus_on_map (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+/* Set frame F's `no-focus-on-map' parameter which, if non-nil, means
+ * that F's window-system window does not want to receive input focus
+ * when it is mapped.  (A frame's window is mapped when the frame is
+ * displayed for the first time and when the frame changes its state
+ * from `iconified' or `invisible' to `visible'.)
+ *
+ * Some window managers may not honor this parameter. */
+{
+  NSTRACE ("x_set_no_focus_on_map");
+
+  if (!EQ (new_value, old_value))
+    {
+      FRAME_NO_FOCUS_ON_MAP (f) = !NILP (new_value);
+    }
+}
+
+void
+x_set_no_accept_focus (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+/*  Set frame F's `no-accept-focus' parameter which, if non-nil, hints
+ * that F's window-system window does not want to receive input focus
+ * via mouse clicks or by moving the mouse into it.
+ *
+ * If non-nil, this may have the unwanted side-effect that a user cannot
+ * scroll a non-selected frame with the mouse.
+ *
+ * Some window managers may not honor this parameter. */
+{
+  NSTRACE ("x_set_no_accept_focus");
+
+  if (!EQ (new_value, old_value))
+    FRAME_NO_ACCEPT_FOCUS (f) = !NILP (new_value);
+}
+
+void
+x_set_z_group (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+/* Set frame F's `z-group' parameter.  If `above', F's window-system
+   window is displayed above all windows that do not have the `above'
+   property set.  If nil, F's window is shown below all windows that
+   have the `above' property set and above all windows that have the
+   `below' property set.  If `below', F's window is displayed below
+   all windows that do.
+
+   Some window managers may not honor this parameter. */
+{
+  EmacsView *view = (EmacsView *)FRAME_NS_VIEW (f);
+  NSWindow *window = [view window];
+
+  NSTRACE ("x_set_z_group");
+
+  if (NILP (new_value))
+    {
+      window.level = NSNormalWindowLevel;
+      FRAME_Z_GROUP (f) = z_group_none;
+    }
+  else if (EQ (new_value, Qabove))
+    {
+      window.level = NSNormalWindowLevel + 1;
+      FRAME_Z_GROUP (f) = z_group_above;
+    }
+  else if (EQ (new_value, Qabove_suspended))
+    {
+      /* Not sure what level this should be. */
+      window.level = NSNormalWindowLevel + 1;
+      FRAME_Z_GROUP (f) = z_group_above_suspended;
+    }
+  else if (EQ (new_value, Qbelow))
+    {
+      window.level = NSNormalWindowLevel - 1;
+      FRAME_Z_GROUP (f) = z_group_below;
+    }
+  else
+    error ("Invalid z-group specification");
+}
 
 static void
 ns_fullscreen_hook (struct frame *f)
@@ -2149,14 +2344,14 @@ frame_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y)
    -------------------------------------------------------------------------- */
 {
   NSTRACE ("frame_set_mouse_pixel_position");
-  ns_raise_frame (f);
-#if 0
-  /* FIXME: this does not work, and what about GNUstep? */
+
+  /* FIXME: what about GNUstep? */
 #ifdef NS_IMPL_COCOA
-  [FRAME_NS_VIEW (f) lockFocus];
-  PSsetmouse ((float)pix_x, (float)pix_y);
-  [FRAME_NS_VIEW (f) unlockFocus];
-#endif
+  CGPoint mouse_pos =
+    CGPointMake(f->left_pos + pix_x,
+                f->top_pos + pix_y +
+                FRAME_NS_TITLEBAR_HEIGHT(f) + FRAME_TOOLBAR_HEIGHT(f));
+  CGWarpMouseCursorPosition (mouse_pos);
 #endif
 }
 
@@ -3873,7 +4068,7 @@ ns_send_appdefined (int value)
       app->nextappdefined = value;
       [app performSelectorOnMainThread:@selector (sendFromMainThread:)
                             withObject:nil
-                         waitUntilDone:YES];
+                         waitUntilDone:NO];
       return;
     }
 
@@ -4075,7 +4270,6 @@ ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
         }
       else
         {
-          ptrdiff_t specpdl_count = SPECPDL_INDEX ();
           /* Run and wait for events.  We must always send one NX_APPDEFINED event
              to ourself, otherwise [NXApp run] will never exit.  */
           send_appdefined = YES;
@@ -4090,6 +4284,8 @@ ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
       q_event_ptr = NULL;
       unblock_input ();
     }
+  else
+    return -1;
 
   return nevents;
 }
@@ -4097,8 +4293,8 @@ ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
 
 int
 ns_select (int nfds, fd_set *readfds, fd_set *writefds,
-           fd_set *exceptfds, struct timespec const *timeout,
-           sigset_t const *sigmask)
+           fd_set *exceptfds, struct timespec *timeout,
+           sigset_t *sigmask)
 /* --------------------------------------------------------------------------
      Replacement for select, checking for events
    -------------------------------------------------------------------------- */
@@ -4131,7 +4327,13 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
   if (NSApp == nil
       || ![NSThread isMainThread]
       || (timeout && timeout->tv_sec == 0 && timeout->tv_nsec == 0))
-    return pselect (nfds, readfds, writefds, exceptfds, timeout, sigmask);
+    return thread_select(pselect, nfds, readfds, writefds,
+                         exceptfds, timeout, sigmask);
+  else
+    {
+      struct timespec t = {0, 0};
+      thread_select(pselect, 0, NULL, NULL, NULL, &t, sigmask);
+    }
 
   [outerpool release];
   outerpool = [[NSAutoreleasePool alloc] init];
@@ -4234,6 +4436,18 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
   return result;
 }
 
+#ifdef HAVE_PTHREAD
+void
+ns_run_loop_break ()
+/* Break out of the NS run loop in ns_select or ns_read_socket. */
+{
+  NSTRACE_WHEN (NSTRACE_GROUP_EVENTS, "ns_run_loop_break");
+
+  /* If we don't have a GUI, don't send the event. */
+  if (NSApp != NULL)
+    ns_send_appdefined(-1);
+}
+#endif
 
 
 /* ==========================================================================
@@ -6288,7 +6502,7 @@ not_in_argv (NSString *arg)
       if (WINDOWP (window)
           && !EQ (window, last_mouse_window)
           && !EQ (window, selected_window)
-          && (focus_follows_mouse
+          && (!NILP (focus_follows_mouse)
               || (EQ (XWINDOW (window)->frame,
                       XWINDOW (selected_window)->frame))))
         {
@@ -6357,7 +6571,7 @@ not_in_argv (NSString *arg)
   return NO;
 }
 
-- (void) updateFrameSize: (BOOL) delay;
+- (void) updateFrameSize: (BOOL) delay
 {
   NSWindow *window = [self window];
   NSRect wr = [window frame];
@@ -6387,7 +6601,10 @@ not_in_argv (NSString *arg)
 
   if (wait_for_tool_bar)
     {
-      if (FRAME_TOOLBAR_HEIGHT (emacsframe) == 0)
+      /* The toolbar height is always 0 in fullscreen, so don't wait
+         for it to become available. */
+      if (FRAME_TOOLBAR_HEIGHT (emacsframe) == 0
+          && ! [self isFullscreen])
         {
           NSTRACE_MSG ("Waiting for toolbar");
           return;
@@ -6399,7 +6616,8 @@ not_in_argv (NSString *arg)
   newh = (int)wr.size.height - extra;
 
   NSTRACE_SIZE ("New size", NSMakeSize (neww, newh));
-  NSTRACE_MSG ("tool_bar_height: %d", emacsframe->tool_bar_height);
+  NSTRACE_MSG ("FRAME_TOOLBAR_HEIGHT: %d", FRAME_TOOLBAR_HEIGHT (emacsframe));
+  NSTRACE_MSG ("FRAME_NS_TITLEBAR_HEIGHT: %d", FRAME_NS_TITLEBAR_HEIGHT (emacsframe));
 
   cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe, neww);
   rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (emacsframe, newh);
@@ -6424,9 +6642,11 @@ not_in_argv (NSString *arg)
       SET_FRAME_GARBAGED (emacsframe);
       cancel_mouse_face (emacsframe);
 
-      wr = NSMakeRect (0, 0, neww, newh);
+      /* The next two lines appear to be setting the frame to the same
+         size as it already is.  Why are they there? */
+      // wr = NSMakeRect (0, 0, neww, newh);
 
-      [view setFrame: wr];
+      // [view setFrame: wr];
 
       // to do: consider using [NSNotificationCenter postNotificationName:].
       [self windowDidMove: // Update top/left.
@@ -6489,7 +6709,8 @@ not_in_argv (NSString *arg)
             old_title = 0;
           }
       }
-    else if (fs_state == FULLSCREEN_NONE && ! maximizing_resize)
+    else if (fs_state == FULLSCREEN_NONE && ! maximizing_resize
+             && [[self window] title] != NULL)
       {
         char *size_title;
         NSWindow *window = [self window];
@@ -6671,7 +6892,7 @@ not_in_argv (NSString *arg)
 }
 
 
-- (void)setFrame:(NSRect)frameRect;
+- (void)setFrame:(NSRect)frameRect
 {
   NSTRACE ("[EmacsView setFrame:" NSTRACE_FMT_RECT "]",
            NSTRACE_ARG_RECT (frameRect));
@@ -6692,7 +6913,35 @@ not_in_argv (NSString *arg)
 }
 
 
-- initFrameFromEmacs: (struct frame *)f
+- (void)createToolbar: (struct frame *)f
+{
+  EmacsView *view = (EmacsView *)FRAME_NS_VIEW (f);
+  NSWindow *window = [view window];
+
+  toolbar = [[EmacsToolbar alloc] initForView: self withIdentifier:
+                   [NSString stringWithFormat: @"Emacs Frame %d",
+                             ns_window_num]];
+  [toolbar setVisible: NO];
+  [window setToolbar: toolbar];
+
+  /* Don't set frame garbaged until tool bar is up to date?
+     This avoids an extra clear and redraw (flicker) at frame creation.  */
+  if (FRAME_EXTERNAL_TOOL_BAR (f)) wait_for_tool_bar = YES;
+  else wait_for_tool_bar = NO;
+
+
+#ifdef NS_IMPL_COCOA
+  {
+    NSButton *toggleButton;
+    toggleButton = [window standardWindowButton: NSWindowToolbarButton];
+    [toggleButton setTarget: self];
+    [toggleButton setAction: @selector (toggleToolbar: )];
+  }
+#endif
+}
+
+
+- (instancetype) initFrameFromEmacs: (struct frame *)f
 {
   NSRect r, wr;
   Lisp_Object tem;
@@ -6731,12 +6980,15 @@ not_in_argv (NSString *arg)
 
   win = [[EmacsWindow alloc]
             initWithContentRect: r
-                      styleMask: (NSWindowStyleMaskResizable |
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
-                                  NSWindowStyleMaskTitled |
+                      styleMask: (FRAME_UNDECORATED (f)
+                                  ? FRAME_UNDECORATED_FLAGS
+                                  : FRAME_DECORATED_FLAGS
+#ifdef NS_IMPL_COCOA
+                                  | NSWindowStyleMaskResizable
+                                  | NSWindowStyleMaskMiniaturizable
+                                  | NSWindowStyleMaskClosable
 #endif
-                                  NSWindowStyleMaskMiniaturizable |
-                                  NSWindowStyleMaskClosable)
+                                  )
                         backing: NSBackingStoreBuffered
                           defer: YES];
 
@@ -6746,7 +6998,6 @@ not_in_argv (NSString *arg)
 
   wr = [win frame];
   bwidth = f->border_width = wr.size.width - r.size.width;
-  tibar_height = FRAME_NS_TITLEBAR_HEIGHT (f) = wr.size.height - r.size.height;
 
   [win setAcceptsMouseMovedEvents: YES];
   [win setDelegate: self];
@@ -6766,42 +7017,36 @@ not_in_argv (NSString *arg)
   [win setTitle: name];
 
   /* toolbar support */
-  toolbar = [[EmacsToolbar alloc] initForView: self withIdentifier:
-                         [NSString stringWithFormat: @"Emacs Frame %d",
-                                   ns_window_num]];
-  [win setToolbar: toolbar];
-  [toolbar setVisible: NO];
-
-  /* Don't set frame garbaged until tool bar is up to date?
-     This avoids an extra clear and redraw (flicker) at frame creation.  */
-  if (FRAME_EXTERNAL_TOOL_BAR (f)) wait_for_tool_bar = YES;
-  else wait_for_tool_bar = NO;
-
-
-#ifdef NS_IMPL_COCOA
-  {
-    NSButton *toggleButton;
-  toggleButton = [win standardWindowButton: NSWindowToolbarButton];
-  [toggleButton setTarget: self];
-  [toggleButton setAction: @selector (toggleToolbar: )];
-  }
-#endif
-  FRAME_TOOLBAR_HEIGHT (f) = 0;
+  if (! FRAME_UNDECORATED (f))
+    [self createToolbar: f];
 
   tem = f->icon_name;
   if (!NILP (tem))
     [win setMiniwindowTitle:
            [NSString stringWithUTF8String: SSDATA (tem)]];
 
+  if (FRAME_PARENT_FRAME (f) != NULL)
+    {
+      NSWindow *parent = [FRAME_NS_VIEW (FRAME_PARENT_FRAME (f)) window];
+      [parent addChildWindow: win
+                     ordered: NSWindowAbove];
+    }
+
+  if (FRAME_Z_GROUP (f) != z_group_none)
+      win.level = NSNormalWindowLevel
+        + (FRAME_Z_GROUP_BELOW (f) ? -1 : 1);
+
   {
     NSScreen *screen = [win screen];
 
     if (screen != 0)
       {
         NSPoint pt = NSMakePoint
-          (IN_BOUND (-SCREENMAX, f->left_pos, SCREENMAX),
+          (IN_BOUND (-SCREENMAX, f->left_pos
+                     + NS_PARENT_WINDOW_LEFT_POS (f), SCREENMAX),
            IN_BOUND (-SCREENMAX,
-                     [screen frame].size.height - NS_TOP_POS (f), SCREENMAX));
+                     NS_PARENT_WINDOW_TOP_POS (f) - f->top_pos,
+                     SCREENMAX));
 
         [win setFrameTopLeftPoint: pt];
 
@@ -6823,7 +7068,15 @@ not_in_argv (NSString *arg)
   [self allocateGState];
 #endif
   [NSApp registerServicesMenuSendTypes: ns_send_types
-                           returnTypes: nil];
+                           returnTypes: [NSArray array]];
+
+  /* macOS Sierra automatically enables tabbed windows.  We can't
+     allow this to be enabled until it's available on a Free system.
+     Currently it only happens by accident and is buggy anyway. */
+#if defined (NS_IMPL_COCOA) && \
+  MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_12
+  [win setTabbingMode: NSWindowTabbingModeDisallowed];
+#endif
 
   ns_window_num++;
   return self;
@@ -6843,9 +7096,15 @@ not_in_argv (NSString *arg)
     return;
   if (screen != nil)
     {
-      emacsframe->left_pos = r.origin.x;
+      emacsframe->left_pos = r.origin.x - NS_PARENT_WINDOW_LEFT_POS (emacsframe);
       emacsframe->top_pos =
-        [screen frame].size.height - (r.origin.y + r.size.height);
+        NS_PARENT_WINDOW_TOP_POS (emacsframe) - (r.origin.y + r.size.height);
+
+      if (emacs_event)
+        {
+          emacs_event->kind = MOVE_FRAME_EVENT;
+          EV_TRAILER ((id)nil);
+        }
     }
 }
 
@@ -7262,9 +7521,6 @@ not_in_argv (NSString *arg)
         [fw setOpaque: NO];
 
       f->border_width = 0;
-      FRAME_NS_TITLEBAR_HEIGHT (f) = 0;
-      tobar_height = FRAME_TOOLBAR_HEIGHT (f);
-      FRAME_TOOLBAR_HEIGHT (f) = 0;
 
       nonfs_window = w;
 
@@ -7298,9 +7554,6 @@ not_in_argv (NSString *arg)
         [w setOpaque: NO];
 
       f->border_width = bwidth;
-      FRAME_NS_TITLEBAR_HEIGHT (f) = tibar_height;
-      if (FRAME_EXTERNAL_TOOL_BAR (f))
-        FRAME_TOOLBAR_HEIGHT (f) = tobar_height;
 
       // to do: consider using [NSNotificationCenter postNotificationName:] to send notifications.
 
@@ -7418,7 +7671,7 @@ not_in_argv (NSString *arg)
 }
 
 
-- menuDown: sender
+- (instancetype)menuDown: sender
 {
   NSTRACE ("[EmacsView menuDown:]");
   if (context_menu_value == -1)
@@ -7443,7 +7696,7 @@ not_in_argv (NSString *arg)
 
 
 /* this gets called on toolbar button click */
-- toolbarClicked: (id)item
+- (instancetype)toolbarClicked: (id)item
 {
   NSEvent *theEvent;
   int idx = [item tag] * TOOL_BAR_ITEM_NSLOTS;
@@ -7469,7 +7722,7 @@ not_in_argv (NSString *arg)
 }
 
 
-- toggleToolbar: (id)sender
+- (instancetype)toggleToolbar: (id)sender
 {
   NSTRACE ("[EmacsView toggleToolbar:]");
 
@@ -7697,7 +7950,7 @@ not_in_argv (NSString *arg)
    (gives a miniaturized version of the window); currently we use the latter for
    frames whose active buffer doesn't correspond to any file
    (e.g., '*scratch*') */
-- setMiniwindowImage: (BOOL) setMini
+- (instancetype)setMiniwindowImage: (BOOL) setMini
 {
   id image = [[self window] miniwindowImage];
   NSTRACE ("[EmacsView setMiniwindowImage:%d]", setMini);
@@ -7832,7 +8085,40 @@ not_in_argv (NSString *arg)
       NSTRACE_RETURN_RECT (frameRect);
       return frameRect;
     }
-#endif
+  else
+#endif /* MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_9 */
+    // Check that the proposed frameRect is visible in at least one
+    // screen.  If it is not, ask the system to reposition it (only
+    // for non-child windows).
+
+    if (!FRAME_PARENT_FRAME (((EmacsView *)[self delegate])->emacsframe))
+    {
+      NSArray *screens = [NSScreen screens];
+      NSUInteger nr_screens = [screens count];
+
+      int i;
+      BOOL frame_on_screen = NO;
+
+      for (i = 0; i < nr_screens; ++i)
+        {
+          NSScreen *s = [screens objectAtIndex: i];
+          NSRect scrRect = [s frame];
+
+          if (NSIntersectsRect(frameRect, scrRect))
+            {
+              frame_on_screen = YES;
+              break;
+            }
+        }
+
+      if (!frame_on_screen)
+        {
+          NSTRACE_MSG ("Frame outside screens; constraining");
+          frameRect = [super constrainFrameRect:frameRect toScreen:screen];
+          NSTRACE_RETURN_RECT (frameRect);
+          return frameRect;
+        }
+    }
 #endif
 
   return constrain_frame_rect(frameRect,
@@ -7966,6 +8252,11 @@ not_in_argv (NSString *arg)
 
   [super setFrameTopLeftPoint:point];
 }
+
+- (BOOL)canBecomeKeyWindow
+{
+  return !FRAME_NO_ACCEPT_FOCUS (((EmacsView *)[self delegate])->emacsframe);
+}
 @end /* EmacsWindow */
 
 
@@ -8011,7 +8302,7 @@ not_in_argv (NSString *arg)
   return r;
 }
 
-- initFrame: (NSRect )r window: (Lisp_Object)nwin
+- (instancetype)initFrame: (NSRect )r window: (Lisp_Object)nwin
 {
   NSTRACE ("[EmacsScroller initFrame: window:]");
 
@@ -8095,7 +8386,7 @@ not_in_argv (NSString *arg)
 }
 
 
-- condemn
+- (instancetype)condemn
 {
   NSTRACE ("[EmacsScroller condemn]");
   condemned =YES;
@@ -8103,7 +8394,7 @@ not_in_argv (NSString *arg)
 }
 
 
-- reprieve
+- (instancetype)reprieve
 {
   NSTRACE ("[EmacsScroller reprieve]");
   condemned =NO;
@@ -8158,7 +8449,7 @@ not_in_argv (NSString *arg)
 }
 
 
-- setPosition: (int)position portion: (int)portion whole: (int)whole
+- (instancetype)setPosition: (int)position portion: (int)portion whole: (int)whole
 {
   NSTRACE ("[EmacsScroller setPosition:portion:whole:]");
 
@@ -8237,7 +8528,7 @@ not_in_argv (NSString *arg)
 
 
 /* called manually thru timer to implement repeated button action w/hold-down */
-- repeatScroll: (NSTimer *)scrollEntry
+- (instancetype)repeatScroll: (NSTimer *)scrollEntry
 {
   NSEvent *e = [[self window] currentEvent];
   NSPoint p =  [[self window] mouseLocationOutsideOfEventStream];
@@ -8297,7 +8588,7 @@ not_in_argv (NSString *arg)
     case NSScrollerKnobSlot:  /* GNUstep-only */
       last_hit_part = scroll_bar_move_ratio; break;
     default:  /* NSScrollerNoPart? */
-      fprintf (stderr, "EmacsScoller-mouseDown: unexpected part %ld\n",
+      fprintf (stderr, "EmacsScroller-mouseDown: unexpected part %ld\n",
                (long) part);
       return;
     }
@@ -8356,7 +8647,7 @@ not_in_argv (NSString *arg)
                                  modifierFlags: [e modifierFlags]
                                      timestamp: [e timestamp]
                                   windowNumber: [e windowNumber]
-                                       context: [e context]
+                                       context: nil
                                    eventNumber: [e eventNumber]
                                     clickCount: [e clickCount]
                                       pressure: [e pressure]];
diff --git a/src/print.c b/src/print.c
index e857761bd46..50c75d7712c 100644
--- a/src/print.c
+++ b/src/print.c
@@ -33,6 +33,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "intervals.h"
 #include "blockinput.h"
 #include "xwidget.h"
+#include "dynlib.h"
 
 #include <c-ctype.h>
 #include <float.h>
@@ -227,7 +228,7 @@ printchar_to_stream (unsigned int ch, FILE *stream)
     {
       if (ASCII_CHAR_P (ch))
         {
-          putc (ch, stream);
+          putc_unlocked (ch, stream);
 #ifdef WINDOWSNT
           /* Send the output to a debugger (nothing happens if there
              isn't one).  */
@@ -245,7 +246,7 @@ printchar_to_stream (unsigned int ch, FILE *stream)
           if (encode_p)
             encoded_ch = code_convert_string_norecord (encoded_ch,
                                                        coding_system, true);
-          fwrite (SSDATA (encoded_ch), 1, SBYTES (encoded_ch), stream);
+          fwrite_unlocked (SSDATA (encoded_ch), 1, SBYTES (encoded_ch), stream);
 #ifdef WINDOWSNT
           if (print_output_debug_flag && stream == stderr)
             OutputDebugString (SSDATA (encoded_ch));
@@ -297,7 +298,7 @@ printchar (unsigned int ch, Lisp_Object fun)
           if (DISP_TABLE_P (Vstandard_display_table))
             printchar_to_stream (ch, stdout);
           else
-            fwrite (str, 1, len, stdout);
+            fwrite_unlocked (str, 1, len, stdout);
           noninteractive_need_newline = 1;
         }
       else
@@ -349,7 +350,7 @@ strout (const char *ptr, ptrdiff_t size, ptrdiff_t size_byte,
             }
         }
       else
-        fwrite (ptr, 1, size_byte, stdout);
+        fwrite_unlocked (ptr, 1, size_byte, stdout);
 
       noninteractive_need_newline = 1;
     }
@@ -800,7 +801,7 @@ append to existing target file.  */)
         report_file_error ("Cannot open debugging output stream", file);
     }
 
-  fflush (stderr);
+  fflush_unlocked (stderr);
   if (dup2 (fd, STDERR_FILENO) < 0)
     report_file_error ("dup2", file);
   if (fd != stderr_dup)
@@ -1135,7 +1136,8 @@ print (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
    || (VECTORLIKEP (obj)                                   \
        && (VECTORP (obj) || COMPILEDP (obj)                \
            || CHAR_TABLE_P (obj) || SUB_CHAR_TABLE_P (obj) \
-           || HASH_TABLE_P (obj) || FONTP (obj)))          \
+           || HASH_TABLE_P (obj) || FONTP (obj)            \
+           || RECORDP (obj)))                              \
    || (! NILP (Vprint_gensym)                              \
        && SYMBOLP (obj)                                    \
        && !SYMBOL_INTERNED_P (obj)))
@@ -1345,6 +1347,401 @@ print_prune_string_charset (Lisp_Object string)
   return string;
 }
 
+static bool
+print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
+                  char *buf)
+{
+  switch (PSEUDOVECTOR_TYPE (XVECTOR (obj)))
+    {
+    case PVEC_PROCESS:
+      if (escapeflag)
+        {
+          print_c_string ("#<process ", printcharfun);
+          print_string (XPROCESS (obj)->name, printcharfun);
+          printchar ('>', printcharfun);
+        }
+      else
+        print_string (XPROCESS (obj)->name, printcharfun);
+      break;
+
+    case PVEC_BOOL_VECTOR:
+      {
+        EMACS_INT size = bool_vector_size (obj);
+        ptrdiff_t size_in_chars = bool_vector_bytes (size);
+        ptrdiff_t real_size_in_chars = size_in_chars;
+
+        int len = sprintf (buf, "#&%"pI"d\"", size);
+        strout (buf, len, len, printcharfun);
+
+        /* Don't print more characters than the specified maximum.
+           Negative values of print-length are invalid.  Treat them
+           like a print-length of nil.  */
+        if (NATNUMP (Vprint_length)
+            && XFASTINT (Vprint_length) < size_in_chars)
+          size_in_chars = XFASTINT (Vprint_length);
+
+        for (ptrdiff_t i = 0; i < size_in_chars; i++)
+          {
+            maybe_quit ();
+            unsigned char c = bool_vector_uchar_data (obj)[i];
+            if (c == '\n' && print_escape_newlines)
+              print_c_string ("\\n", printcharfun);
+            else if (c == '\f' && print_escape_newlines)
+              print_c_string ("\\f", printcharfun);
+            else if (c > '\177')
+              {
+                /* Use octal escapes to avoid encoding issues.  */
+                int len = sprintf (buf, "\\%o", c);
+                strout (buf, len, len, printcharfun);
+              }
+            else
+              {
+                if (c == '\"' || c == '\\')
+                  printchar ('\\', printcharfun);
+                printchar (c, printcharfun);
+              }
+          }
+
+        if (size_in_chars < real_size_in_chars)
+          print_c_string (" ...", printcharfun);
+        printchar ('\"', printcharfun);
+      }
+      break;
+
+    case PVEC_SUBR:
+      print_c_string ("#<subr ", printcharfun);
+      print_c_string (XSUBR (obj)->symbol_name, printcharfun);
+      printchar ('>', printcharfun);
+      break;
+
+    case PVEC_XWIDGET: case PVEC_XWIDGET_VIEW:
+      print_c_string ("#<xwidget ", printcharfun);
+      printchar ('>', printcharfun);
+      break;
+
+    case PVEC_WINDOW:
+      {
+        int len = sprintf (buf, "#<window %"pI"d",
+                           XWINDOW (obj)->sequence_number);
+        strout (buf, len, len, printcharfun);
+        if (BUFFERP (XWINDOW (obj)->contents))
+          {
+            print_c_string (" on ", printcharfun);
+            print_string (BVAR (XBUFFER (XWINDOW (obj)->contents), name),
+                          printcharfun);
+          }
+        printchar ('>', printcharfun);
+      }
+      break;
+
+    case PVEC_TERMINAL:
+      {
+        struct terminal *t = XTERMINAL (obj);
+        int len = sprintf (buf, "#<terminal %d", t->id);
+        strout (buf, len, len, printcharfun);
+        if (t->name)
+          {
+            print_c_string (" on ", printcharfun);
+            print_c_string (t->name, printcharfun);
+          }
+        printchar ('>', printcharfun);
+      }
+      break;
+
+    case PVEC_HASH_TABLE:
+      {
+        struct Lisp_Hash_Table *h = XHASH_TABLE (obj);
+        /* Implement a readable output, e.g.:
+          #s(hash-table size 2 test equal data (k1 v1 k2 v2)) */
+        /* Always print the size.  */
+        int len = sprintf (buf, "#s(hash-table size %"pD"d", ASIZE (h->next));
+        strout (buf, len, len, printcharfun);
+
+        if (!NILP (h->test.name))
+          {
+            print_c_string (" test ", printcharfun);
+            print_object (h->test.name, printcharfun, escapeflag);
+          }
+
+        if (!NILP (h->weak))
+          {
+            print_c_string (" weakness ", printcharfun);
+            print_object (h->weak, printcharfun, escapeflag);
+          }
+
+        print_c_string (" rehash-size ", printcharfun);
+        print_object (Fhash_table_rehash_size (obj),
+                      printcharfun, escapeflag);
+
+        print_c_string (" rehash-threshold ", printcharfun);
+        print_object (Fhash_table_rehash_threshold (obj),
+                      printcharfun, escapeflag);
+
+        if (h->pure)
+          {
+            print_c_string (" purecopy ", printcharfun);
+            print_object (h->pure ? Qt : Qnil, printcharfun, escapeflag);
+          }
+
+        print_c_string (" data ", printcharfun);
+
+        /* Print the data here as a plist. */
+        ptrdiff_t real_size = HASH_TABLE_SIZE (h);
+        ptrdiff_t size = real_size;
+
+        /* Don't print more elements than the specified maximum.  */
+        if (NATNUMP (Vprint_length) && XFASTINT (Vprint_length) < size)
+          size = XFASTINT (Vprint_length);
+
+        printchar ('(', printcharfun);
+        for (ptrdiff_t i = 0; i < size; i++)
+          if (!NILP (HASH_HASH (h, i)))
+            {
+              if (i) printchar (' ', printcharfun);
+              print_object (HASH_KEY (h, i), printcharfun, escapeflag);
+              printchar (' ', printcharfun);
+              print_object (HASH_VALUE (h, i), printcharfun, escapeflag);
+            }
+
+        if (size < real_size)
+          print_c_string (" ...", printcharfun);
+
+        print_c_string ("))", printcharfun);
+      }
+      break;
+
+    case PVEC_BUFFER:
+      if (!BUFFER_LIVE_P (XBUFFER (obj)))
+        print_c_string ("#<killed buffer>", printcharfun);
+      else if (escapeflag)
+        {
+          print_c_string ("#<buffer ", printcharfun);
+          print_string (BVAR (XBUFFER (obj), name), printcharfun);
+          printchar ('>', printcharfun);
+        }
+      else
+        print_string (BVAR (XBUFFER (obj), name), printcharfun);
+      break;
+
+    case PVEC_WINDOW_CONFIGURATION:
+      print_c_string ("#<window-configuration>", printcharfun);
+      break;
+
+    case PVEC_FRAME:
+      {
+        void *ptr = XFRAME (obj);
+        Lisp_Object frame_name = XFRAME (obj)->name;
+
+        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;
+               don't crash.  */
+            if (SYMBOLP (frame_name))
+              frame_name = Fsymbol_name (frame_name);
+            else        /* can't happen: name should be either nil or string */
+              frame_name = build_string ("*INVALID*FRAME*NAME*");
+          }
+        print_string (frame_name, printcharfun);
+        int len = sprintf (buf, " %p>", ptr);
+        strout (buf, len, len, printcharfun);
+      }
+      break;
+
+    case PVEC_FONT:
+      {
+        if (! FONT_OBJECT_P (obj))
+          {
+            if (FONT_SPEC_P (obj))
+              print_c_string ("#<font-spec", printcharfun);
+            else
+              print_c_string ("#<font-entity", printcharfun);
+            for (int i = 0; i < FONT_SPEC_MAX; i++)
+              {
+                printchar (' ', printcharfun);
+                if (i < FONT_WEIGHT_INDEX || i > FONT_WIDTH_INDEX)
+                  print_object (AREF (obj, i), printcharfun, escapeflag);
+                else
+                  print_object (font_style_symbolic (obj, i, 0),
+                                printcharfun, escapeflag);
+              }
+          }
+        else
+          {
+            print_c_string ("#<font-object ", printcharfun);
+            print_object (AREF (obj, FONT_NAME_INDEX), printcharfun,
+                          escapeflag);
+          }
+        printchar ('>', printcharfun);
+      }
+      break;
+
+    case PVEC_THREAD:
+      print_c_string ("#<thread ", printcharfun);
+      if (STRINGP (XTHREAD (obj)->name))
+        print_string (XTHREAD (obj)->name, printcharfun);
+      else
+        {
+          int len = sprintf (buf, "%p", XTHREAD (obj));
+          strout (buf, len, len, printcharfun);
+        }
+      printchar ('>', printcharfun);
+      break;
+
+    case PVEC_MUTEX:
+      print_c_string ("#<mutex ", printcharfun);
+      if (STRINGP (XMUTEX (obj)->name))
+        print_string (XMUTEX (obj)->name, printcharfun);
+      else
+        {
+          int len = sprintf (buf, "%p", XMUTEX (obj));
+          strout (buf, len, len, printcharfun);
+        }
+      printchar ('>', printcharfun);
+      break;
+
+    case PVEC_CONDVAR:
+      print_c_string ("#<condvar ", printcharfun);
+      if (STRINGP (XCONDVAR (obj)->name))
+        print_string (XCONDVAR (obj)->name, printcharfun);
+      else
+        {
+          int len = sprintf (buf, "%p", XCONDVAR (obj));
+          strout (buf, len, len, printcharfun);
+        }
+      printchar ('>', printcharfun);
+      break;
+
+    case PVEC_RECORD:
+      {
+        ptrdiff_t size = PVSIZE (obj);
+
+        /* Don't print more elements than the specified maximum.  */
+        ptrdiff_t n
+          = (NATNUMP (Vprint_length) && XFASTINT (Vprint_length) < size
+             ? XFASTINT (Vprint_length) : size);
+
+        print_c_string ("#s(", printcharfun);
+        for (ptrdiff_t i = 0; i < n; i ++)
+          {
+            if (i) printchar (' ', printcharfun);
+            print_object (AREF (obj, i), printcharfun, escapeflag);
+          }
+        if (n < size)
+          print_c_string (" ...", printcharfun);
+        printchar (')', printcharfun);
+      }
+      break;
+
+    case PVEC_SUB_CHAR_TABLE:
+    case PVEC_COMPILED:
+    case PVEC_CHAR_TABLE:
+    case PVEC_NORMAL_VECTOR:
+      {
+        ptrdiff_t size = ASIZE (obj);
+        if (COMPILEDP (obj))
+          {
+            printchar ('#', printcharfun);
+            size &= PSEUDOVECTOR_SIZE_MASK;
+          }
+        if (CHAR_TABLE_P (obj) || SUB_CHAR_TABLE_P (obj))
+          {
+            /* Print a char-table as if it were a vector,
+               lumping the parent and default slots in with the
+               character slots.  But add #^ as a prefix.  */
+
+            /* Make each lowest sub_char_table start a new line.
+               Otherwise we'll make a line extremely long, which
+               results in slow redisplay.  */
+            if (SUB_CHAR_TABLE_P (obj)
+                && XSUB_CHAR_TABLE (obj)->depth == 3)
+              printchar ('\n', printcharfun);
+            print_c_string ("#^", printcharfun);
+            if (SUB_CHAR_TABLE_P (obj))
+              printchar ('^', printcharfun);
+            size &= PSEUDOVECTOR_SIZE_MASK;
+          }
+        if (size & PSEUDOVECTOR_FLAG)
+          return false;
+
+        printchar ('[', printcharfun);
+
+        int idx = SUB_CHAR_TABLE_P (obj) ? SUB_CHAR_TABLE_OFFSET : 0;
+        Lisp_Object tem;
+        ptrdiff_t real_size = size;
+
+        /* For a sub char-table, print heading non-Lisp data first.  */
+        if (SUB_CHAR_TABLE_P (obj))
+          {
+            int i = sprintf (buf, "%d %d", XSUB_CHAR_TABLE (obj)->depth,
+                             XSUB_CHAR_TABLE (obj)->min_char);
+            strout (buf, i, i, printcharfun);
+          }
+
+        /* Don't print more elements than the specified maximum.  */
+        if (NATNUMP (Vprint_length)
+            && XFASTINT (Vprint_length) < size)
+          size = XFASTINT (Vprint_length);
+
+        for (int i = idx; i < size; i++)
+          {
+            if (i) printchar (' ', printcharfun);
+            tem = AREF (obj, i);
+            print_object (tem, printcharfun, escapeflag);
+          }
+        if (size < real_size)
+          print_c_string (" ...", printcharfun);
+        printchar (']', printcharfun);
+      }
+      break;
+
+#ifdef HAVE_MODULES
+    case PVEC_MODULE_FUNCTION:
+      {
+        print_c_string ("#<module function ", printcharfun);
+        void *ptr = XMODULE_FUNCTION (obj)->subr;
+        const char *file = NULL;
+        const char *symbol = NULL;
+        dynlib_addr (ptr, &file, &symbol);
+
+        if (symbol == NULL)
+          {
+            print_c_string ("at ", printcharfun);
+            enum { pointer_bufsize = sizeof ptr * 16 / CHAR_BIT + 2 + 1 };
+            char buffer[pointer_bufsize];
+            int needed = snprintf (buffer, sizeof buffer, "%p", ptr);
+            const char p0x[] = "0x";
+            eassert (needed <= sizeof buffer);
+            /* ANSI C doesn't guarantee that %p produces a string that
+               begins with a "0x".  */
+            if (c_strncasecmp (buffer, p0x, sizeof (p0x) - 1) != 0)
+              print_c_string (p0x, printcharfun);
+            print_c_string (buffer, printcharfun);
+          }
+        else
+          print_c_string (symbol, printcharfun);
+
+        if (file != NULL)
+          {
+            print_c_string (" from ", printcharfun);
+            print_c_string (file, printcharfun);
+          }
+
+        printchar ('>', printcharfun);
+      }
+      break;
+#endif
+
+    default:
+      emacs_abort ();
+    }
+
+  return true;
+}
+
 static void
 print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
 {
@@ -1473,21 +1870,36 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
                 }
               else
                 {
+                  bool still_need_nonhex = false;
                   /* If we just had a hex escape, and this character
                      could be taken as part of it,
                      output `\ ' to prevent that.  */
-                  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;
+                  if (c_isxdigit (c))
+                    {
+                      if (need_nonhex)
+                        print_c_string ("\\ ", printcharfun);
+                      printchar (c, printcharfun);
+                    }
+                  else if (c == '\n' && print_escape_newlines
+                           ? (c = 'n', true)
+                           : c == '\f' && print_escape_newlines
+                           ? (c = 'f', true)
+                           : c == '\0' && print_escape_control_characters
+                           ? (c = '0', still_need_nonhex = true)
+                           : c == '\"' || c == '\\')
+                    {
+                      printchar ('\\', printcharfun);
+                      printchar (c, printcharfun);
+                    }
+                  else if (print_escape_control_characters && c_iscntrl (c))
+                    {
+                      char outbuf[1 + 3 + 1];
+                      int len = sprintf (outbuf, "\\%03o", c + 0u);
+                      strout (outbuf, len, len, printcharfun);
+                    }
+                  else
+                    printchar (c, printcharfun);
+                  need_nonhex = still_need_nonhex;
                 }
             }
           printchar ('\"', printcharfun);
@@ -1677,359 +2089,8 @@ print_object (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag)
       break;
 
     case Lisp_Vectorlike:
-      switch (PSEUDOVECTOR_TYPE (XVECTOR (obj))) {
-      case PVEC_PROCESS:
-        {
-          if (escapeflag)
-            {
-              print_c_string ("#<process ", printcharfun);
-              print_string (XPROCESS (obj)->name, printcharfun);
-              printchar ('>', printcharfun);
-            }
-          else
-            print_string (XPROCESS (obj)->name, printcharfun);
-        }
-        break;
-
-      case PVEC_BOOL_VECTOR:
-        {
-          ptrdiff_t i;
-          unsigned char c;
-          EMACS_INT size = bool_vector_size (obj);
-          ptrdiff_t size_in_chars = bool_vector_bytes (size);
-          ptrdiff_t real_size_in_chars = size_in_chars;
-
-          int len = sprintf (buf, "#&%"pI"d\"", size);
-          strout (buf, len, len, printcharfun);
-
-          /* Don't print more characters than the specified maximum.
-             Negative values of print-length are invalid.  Treat them
-             like a print-length of nil.  */
-          if (NATNUMP (Vprint_length)
-              && XFASTINT (Vprint_length) < size_in_chars)
-            size_in_chars = XFASTINT (Vprint_length);
-
-          for (i = 0; i < size_in_chars; i++)
-            {
-              maybe_quit ();
-              c = bool_vector_uchar_data (obj)[i];
-              if (c == '\n' && print_escape_newlines)
-                print_c_string ("\\n", printcharfun);
-              else if (c == '\f' && print_escape_newlines)
-                print_c_string ("\\f", printcharfun);
-              else if (c > '\177')
-                {
-                  /* Use octal escapes to avoid encoding issues.  */
-                  len = sprintf (buf, "\\%o", c);
-                  strout (buf, len, len, printcharfun);
-                }
-              else
-                {
-                  if (c == '\"' || c == '\\')
-                    printchar ('\\', printcharfun);
-                  printchar (c, printcharfun);
-                }
-            }
-
-          if (size_in_chars < real_size_in_chars)
-            print_c_string (" ...", printcharfun);
-          printchar ('\"', printcharfun);
-        }
-        break;
-
-      case PVEC_SUBR:
-        {
-          print_c_string ("#<subr ", printcharfun);
-          print_c_string (XSUBR (obj)->symbol_name, printcharfun);
-          printchar ('>', printcharfun);
-        }
-        break;
-
-      case PVEC_XWIDGET: case PVEC_XWIDGET_VIEW:
-        {
-          print_c_string ("#<xwidget ", printcharfun);
-          printchar ('>', printcharfun);
-        }
-        break;
-
-      case PVEC_WINDOW:
-        {
-          int len = sprintf (buf, "#<window %"pI"d",
-                             XWINDOW (obj)->sequence_number);
-          strout (buf, len, len, printcharfun);
-          if (BUFFERP (XWINDOW (obj)->contents))
-            {
-              print_c_string (" on ", printcharfun);
-              print_string (BVAR (XBUFFER (XWINDOW (obj)->contents), name),
-                            printcharfun);
-            }
-          printchar ('>', printcharfun);
-        }
-        break;
-
-      case PVEC_TERMINAL:
-        {
-          struct terminal *t = XTERMINAL (obj);
-          int len = sprintf (buf, "#<terminal %d", t->id);
-          strout (buf, len, len, printcharfun);
-          if (t->name)
-            {
-              print_c_string (" on ", printcharfun);
-              print_c_string (t->name, printcharfun);
-            }
-          printchar ('>', printcharfun);
-        }
-        break;
-
-      case PVEC_HASH_TABLE:
-        {
-          struct Lisp_Hash_Table *h = XHASH_TABLE (obj);
-          ptrdiff_t i;
-          ptrdiff_t real_size, size;
-          int len;
-          /* Implement a readable output, e.g.:
-            #s(hash-table size 2 test equal data (k1 v1 k2 v2)) */
-          /* Always print the size.  */
-          len = sprintf (buf, "#s(hash-table size %"pD"d", ASIZE (h->next));
-          strout (buf, len, len, printcharfun);
-
-          if (!NILP (h->test.name))
-            {
-              print_c_string (" test ", printcharfun);
-              print_object (h->test.name, printcharfun, escapeflag);
-            }
-
-          if (!NILP (h->weak))
-            {
-              print_c_string (" weakness ", printcharfun);
-              print_object (h->weak, printcharfun, escapeflag);
-            }
-
-          print_c_string (" rehash-size ", printcharfun);
-          print_object (Fhash_table_rehash_size (obj),
-                        printcharfun, escapeflag);
-
-          print_c_string (" rehash-threshold ", printcharfun);
-          print_object (Fhash_table_rehash_threshold (obj),
-                        printcharfun, escapeflag);
-
-          if (h->pure)
-            {
-              print_c_string (" purecopy ", printcharfun);
-              print_object (h->pure ? Qt : Qnil, printcharfun, escapeflag);
-            }
-
-          print_c_string (" data ", printcharfun);
-
-          /* Print the data here as a plist. */
-          real_size = HASH_TABLE_SIZE (h);
-          size = real_size;
-
-          /* Don't print more elements than the specified maximum.  */
-          if (NATNUMP (Vprint_length)
-              && XFASTINT (Vprint_length) < size)
-            size = XFASTINT (Vprint_length);
-
-          printchar ('(', printcharfun);
-          for (i = 0; i < size; i++)
-            if (!NILP (HASH_HASH (h, i)))
-              {
-                if (i) printchar (' ', printcharfun);
-                print_object (HASH_KEY (h, i), printcharfun, escapeflag);
-                printchar (' ', printcharfun);
-                print_object (HASH_VALUE (h, i), printcharfun, escapeflag);
-              }
-
-          if (size < real_size)
-            print_c_string (" ...", printcharfun);
-
-          print_c_string ("))", printcharfun);
-        }
-        break;
-
-      case PVEC_BUFFER:
-        {
-          if (!BUFFER_LIVE_P (XBUFFER (obj)))
-            print_c_string ("#<killed buffer>", printcharfun);
-          else if (escapeflag)
-            {
-              print_c_string ("#<buffer ", printcharfun);
-              print_string (BVAR (XBUFFER (obj), name), printcharfun);
-              printchar ('>', printcharfun);
-            }
-          else
-            print_string (BVAR (XBUFFER (obj), name), printcharfun);
-        }
-        break;
-
-      case PVEC_WINDOW_CONFIGURATION:
-        print_c_string ("#<window-configuration>", printcharfun);
-        break;
-
-      case PVEC_FRAME: ;
-        {
-          int len;
-          void *ptr = XFRAME (obj);
-          Lisp_Object frame_name = XFRAME (obj)->name;
-
-          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;
-                 don't crash.  */
-              if (SYMBOLP (frame_name))
-                frame_name = Fsymbol_name (frame_name);
-              else      /* can't happen: name should be either nil or string */
-                frame_name = build_string ("*INVALID*FRAME*NAME*");
-            }
-          print_string (frame_name, printcharfun);
-          len = sprintf (buf, " %p>", ptr);
-          strout (buf, len, len, printcharfun);
-        }
-        break;
-
-      case PVEC_FONT:
-        {
-          int i;
-
-          if (! FONT_OBJECT_P (obj))
-            {
-              if (FONT_SPEC_P (obj))
-                print_c_string ("#<font-spec", printcharfun);
-              else
-                print_c_string ("#<font-entity", printcharfun);
-              for (i = 0; i < FONT_SPEC_MAX; i++)
-                {
-                  printchar (' ', printcharfun);
-                  if (i < FONT_WEIGHT_INDEX || i > FONT_WIDTH_INDEX)
-                    print_object (AREF (obj, i), printcharfun, escapeflag);
-                  else
-                    print_object (font_style_symbolic (obj, i, 0),
-                                  printcharfun, escapeflag);
-                }
-            }
-          else
-            {
-              print_c_string ("#<font-object ", printcharfun);
-              print_object (AREF (obj, FONT_NAME_INDEX), printcharfun,
-                            escapeflag);
-            }
-          printchar ('>', printcharfun);
-        }
-        break;
-
-      case PVEC_THREAD:
-        {
-          print_c_string ("#<thread ", printcharfun);
-          if (STRINGP (XTHREAD (obj)->name))
-            print_string (XTHREAD (obj)->name, printcharfun);
-          else
-            {
-              int len = sprintf (buf, "%p", XTHREAD (obj));
-              strout (buf, len, len, printcharfun);
-            }
-          printchar ('>', printcharfun);
-        }
-        break;
-
-      case PVEC_MUTEX:
-        {
-          print_c_string ("#<mutex ", printcharfun);
-          if (STRINGP (XMUTEX (obj)->name))
-            print_string (XMUTEX (obj)->name, printcharfun);
-          else
-            {
-              int len = sprintf (buf, "%p", XMUTEX (obj));
-              strout (buf, len, len, printcharfun);
-            }
-          printchar ('>', printcharfun);
-        }
-        break;
-
-      case PVEC_CONDVAR:
-        {
-          print_c_string ("#<condvar ", printcharfun);
-          if (STRINGP (XCONDVAR (obj)->name))
-            print_string (XCONDVAR (obj)->name, printcharfun);
-          else
-            {
-              int len = sprintf (buf, "%p", XCONDVAR (obj));
-              strout (buf, len, len, printcharfun);
-            }
-          printchar ('>', printcharfun);
-        }
-        break;
-
-      case PVEC_SUB_CHAR_TABLE:
-      case PVEC_COMPILED:
-      case PVEC_CHAR_TABLE:
-      case PVEC_NORMAL_VECTOR: ;
-        {
-          ptrdiff_t size = ASIZE (obj);
-          if (COMPILEDP (obj))
-            {
-              printchar ('#', printcharfun);
-              size &= PSEUDOVECTOR_SIZE_MASK;
-            }
-          if (CHAR_TABLE_P (obj) || SUB_CHAR_TABLE_P (obj))
-            {
-              /* We print a char-table as if it were a vector,
-                 lumping the parent and default slots in with the
-                 character slots.  But we add #^ as a prefix.  */
-
-              /* Make each lowest sub_char_table start a new line.
-                 Otherwise we'll make a line extremely long, which
-                 results in slow redisplay.  */
-              if (SUB_CHAR_TABLE_P (obj)
-                  && XSUB_CHAR_TABLE (obj)->depth == 3)
-                printchar ('\n', printcharfun);
-              print_c_string ("#^", printcharfun);
-              if (SUB_CHAR_TABLE_P (obj))
-                printchar ('^', printcharfun);
-              size &= PSEUDOVECTOR_SIZE_MASK;
-            }
-          if (size & PSEUDOVECTOR_FLAG)
-            goto badtype;
-
-          printchar ('[', printcharfun);
-          {
-            int i, idx = SUB_CHAR_TABLE_P (obj) ? SUB_CHAR_TABLE_OFFSET : 0;
-            Lisp_Object tem;
-            ptrdiff_t real_size = size;
-
-            /* For a sub char-table, print heading non-Lisp data first.  */
-            if (SUB_CHAR_TABLE_P (obj))
-              {
-                i = sprintf (buf, "%d %d", XSUB_CHAR_TABLE (obj)->depth,
-                             XSUB_CHAR_TABLE (obj)->min_char);
-                strout (buf, i, i, printcharfun);
-              }
-
-            /* Don't print more elements than the specified maximum.  */
-            if (NATNUMP (Vprint_length)
-                && XFASTINT (Vprint_length) < size)
-              size = XFASTINT (Vprint_length);
-
-            for (i = idx; i < size; i++)
-              {
-                if (i) printchar (' ', printcharfun);
-                tem = AREF (obj, i);
-                print_object (tem, printcharfun, escapeflag);
-              }
-            if (size < real_size)
-              print_c_string (" ...", printcharfun);
-          }
-          printchar (']', printcharfun);
-        }
-        break;
-
-        case PVEC_OTHER:
-        case PVEC_FREE:
-          emacs_abort ();
-        }
+      if (! print_vectorlike (obj, printcharfun, escapeflag, buf))
+        goto badtype;
       break;
 
     case Lisp_Misc:
@@ -2283,6 +2344,11 @@ A value of nil means no limit.  See also `eval-expression-print-level'.  */);
 Also print formfeeds as `\\f'.  */);
   print_escape_newlines = 0;
 
+  DEFVAR_BOOL ("print-escape-control-characters", print_escape_control_characters,
+               doc: /* Non-nil means print control characters in strings as `\\OOO'.
+\(OOO is the octal representation of the character code.)*/);
+  print_escape_control_characters = 0;
+
   DEFVAR_BOOL ("print-escape-nonascii", print_escape_nonascii,
                doc: /* Non-nil means print unibyte non-ASCII chars in strings as \\OOO.
 \(OOO is the octal representation of the character code.)
@@ -2372,6 +2438,7 @@ priorities.  */);
   DEFSYM (Qprint_escape_newlines, "print-escape-newlines");
   DEFSYM (Qprint_escape_multibyte, "print-escape-multibyte");
   DEFSYM (Qprint_escape_nonascii, "print-escape-nonascii");
+  DEFSYM (Qprint_escape_control_characters, "print-escape-control-characters");
 
   print_prune_charset_plist = Qnil;
   staticpro (&print_prune_charset_plist);
diff --git a/src/process.c b/src/process.c
index 2f2e5c1b251..abd017bb907 100644
--- a/src/process.c
+++ b/src/process.c
@@ -2049,7 +2049,21 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
   int volatile forkerr_volatile = forkerr;
   struct Lisp_Process *p_volatile = p;
 
+#ifdef DARWIN_OS
+  /* Darwin doesn't let us run setsid after a vfork, so use fork when
+     necessary.  Also, reset SIGCHLD handling after a vfork, as
+     apparently macOS can mistakenly deliver SIGCHLD to the child.  */
+  if (pty_flag)
+    pid = fork ();
+  else
+    {
+      pid = vfork ();
+      if (pid == 0)
+        signal (SIGCHLD, SIG_DFL);
+    }
+#else
   pid = vfork ();
+#endif
 
   current_dir = current_dir_volatile;
   lisp_pty_name = lisp_pty_name_volatile;
@@ -2467,7 +2481,7 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, ptrdiff_t len)
     {
     case AF_INET:
       {
-        struct sockaddr_in *sin = (struct sockaddr_in *) sa;
+        DECLARE_POINTER_ALIAS (sin, struct sockaddr_in, sa);
         len = sizeof (sin->sin_addr) + 1;
         address = Fmake_vector (make_number (len), Qnil);
         p = XVECTOR (address);
@@ -2478,8 +2492,8 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, ptrdiff_t len)
 #ifdef AF_INET6
     case AF_INET6:
       {
-        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa;
-        uint16_t *ip6 = (uint16_t *) &sin6->sin6_addr;
+        DECLARE_POINTER_ALIAS (sin6, struct sockaddr_in6, sa);
+        DECLARE_POINTER_ALIAS (ip6, uint16_t, &sin6->sin6_addr);
         len = sizeof (sin6->sin6_addr) / 2 + 1;
         address = Fmake_vector (make_number (len), Qnil);
         p = XVECTOR (address);
@@ -2492,7 +2506,7 @@ conv_sockaddr_to_lisp (struct sockaddr *sa, ptrdiff_t len)
 #ifdef HAVE_LOCAL_SOCKETS
     case AF_LOCAL:
       {
-        struct sockaddr_un *sockun = (struct sockaddr_un *) sa;
+        DECLARE_POINTER_ALIAS (sockun, struct sockaddr_un, sa);
         ptrdiff_t name_length = len - offsetof (struct sockaddr_un, sun_path);
         /* If the first byte is NUL, the name is a Linux abstract
            socket name, and the name can contain embedded NULs.  If
@@ -2603,7 +2617,7 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
       p = XVECTOR (address);
       if (family == AF_INET)
         {
-          struct sockaddr_in *sin = (struct sockaddr_in *) sa;
+          DECLARE_POINTER_ALIAS (sin, struct sockaddr_in, sa);
           len = sizeof (sin->sin_addr) + 1;
           hostport = XINT (p->contents[--len]);
           sin->sin_port = htons (hostport);
@@ -2613,8 +2627,8 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
 #ifdef AF_INET6
       else if (family == AF_INET6)
         {
-          struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa;
-          uint16_t *ip6 = (uint16_t *)&sin6->sin6_addr;
+          DECLARE_POINTER_ALIAS (sin6, struct sockaddr_in6, sa);
+          DECLARE_POINTER_ALIAS (ip6, uint16_t, &sin6->sin6_addr);
           len = sizeof (sin6->sin6_addr) / 2 + 1;
           hostport = XINT (p->contents[--len]);
           sin6->sin6_port = htons (hostport);
@@ -2636,7 +2650,7 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
 #ifdef HAVE_LOCAL_SOCKETS
       if (family == AF_LOCAL)
         {
-          struct sockaddr_un *sockun = (struct sockaddr_un *) sa;
+          DECLARE_POINTER_ALIAS (sockun, struct sockaddr_un, sa);
           cp = SDATA (address);
           for (i = 0; i < sizeof (sockun->sun_path) && *cp; i++)
             sockun->sun_path[i] = *cp++;
@@ -3409,18 +3423,33 @@ connect_network_socket (Lisp_Object proc, Lisp_Object addrinfos,
             report_file_error ("Cannot bind server socket", Qnil);
 
 #ifdef HAVE_GETSOCKNAME
-          if (p->port == 0)
+          if (p->port == 0
+#ifdef HAVE_LOCAL_SOCKETS
+              && family != AF_LOCAL
+#endif
+              )
             {
               struct sockaddr_in sa1;
               socklen_t len1 = sizeof (sa1);
-              if (getsockname (s, (struct sockaddr *)&sa1, &len1) == 0)
+#ifdef AF_INET6
+              /* The code below assumes the port is at the same offset
+                 and of the same width in both IPv4 and IPv6
+                 structures, but the standards don't guarantee that,
+                 so verify it here.  */
+              struct sockaddr_in6 sa6;
+              verify ((offsetof (struct sockaddr_in, sin_port)
+                       == offsetof (struct sockaddr_in6, sin6_port))
+                      && sizeof (sa1.sin_port) == sizeof (sa6.sin6_port));
+#endif
+              DECLARE_POINTER_ALIAS (psa1, struct sockaddr, &sa1);
+              if (getsockname (s, psa1, &len1) == 0)
                 {
-                  Lisp_Object service;
-                  service = make_number (ntohs (sa1.sin_port));
+                  Lisp_Object service = make_number (ntohs (sa1.sin_port));
                   contact = Fplist_put (contact, QCservice, service);
                   /* Save the port number so that we can stash it in
                      the process object later.  */
-                  ((struct sockaddr_in *)sa)->sin_port = sa1.sin_port;
+                  DECLARE_POINTER_ALIAS (psa, struct sockaddr_in, sa);
+                  psa->sin_port = sa1.sin_port;
                 }
             }
 #endif
@@ -3526,11 +3555,12 @@ connect_network_socket (Lisp_Object proc, Lisp_Object addrinfos,
 #ifdef HAVE_GETSOCKNAME
       if (!p->is_server)
         {
-          struct sockaddr_in sa1;
+          struct sockaddr_storage sa1;
           socklen_t len1 = sizeof (sa1);
-          if (getsockname (s, (struct sockaddr *)&sa1, &len1) == 0)
+          DECLARE_POINTER_ALIAS (psa1, struct sockaddr, &sa1);
+          if (getsockname (s, psa1, &len1) == 0)
             contact = Fplist_put (contact, QClocal,
-                                  conv_sockaddr_to_lisp ((struct sockaddr *)&sa1, len1));
+                                  conv_sockaddr_to_lisp (psa1, len1));
         }
 #endif
     }
@@ -4379,7 +4409,7 @@ network_interface_info (Lisp_Object ifname)
 
       for (it = ifap; it != NULL; it = it->ifa_next)
         {
-          struct sockaddr_dl *sdl = (struct sockaddr_dl *) it->ifa_addr;
+          DECLARE_POINTER_ALIAS (sdl, struct sockaddr_dl, it->ifa_addr);
           unsigned char linkaddr[6];
           int n;
 
@@ -4563,8 +4593,16 @@ is nil, from any process) before the timeout expired.  */)
       /* Can't wait for a process that is dedicated to a different
          thread.  */
       if (!EQ (proc->thread, Qnil) && !EQ (proc->thread, Fcurrent_thread ()))
-        error ("Attempt to accept output from process %s locked to thread %s",
-               SDATA (proc->name), SDATA (XTHREAD (proc->thread)->name));
+        {
+          Lisp_Object proc_thread_name = XTHREAD (proc->thread)->name;
+
+          if (STRINGP (proc_thread_name))
+            error ("Attempt to accept output from process %s locked to thread %s",
+                   SDATA (proc->name), SDATA (proc_thread_name));
+          else
+            error ("Attempt to accept output from process %s locked to thread %p",
+                   SDATA (proc->name), XTHREAD (proc->thread));
+        }
     }
   else
     just_this_one = Qnil;
@@ -4626,7 +4664,7 @@ static EMACS_INT connect_counter = 0;
 static void
 server_accept_connection (Lisp_Object server, int channel)
 {
-  Lisp_Object proc, caller, name, buffer;
+  Lisp_Object buffer;
   Lisp_Object contact, host, service;
   struct Lisp_Process *ps = XPROCESS (server);
   struct Lisp_Process *p;
@@ -4668,49 +4706,43 @@ server_accept_connection (Lisp_Object server, int channel)
      information for this process.  */
   host = Qt;
   service = Qnil;
+  Lisp_Object args[11];
+  int nargs = 0;
+  AUTO_STRING (procname_format_in, "%s <%d.%d.%d.%d:%d>");
+  AUTO_STRING (procname_format_in6, "%s <[%x:%x:%x:%x:%x:%x:%x:%x]:%d>");
+  AUTO_STRING (procname_format_default, "%s <%d>");
   switch (saddr.sa.sa_family)
     {
     case AF_INET:
       {
+        args[nargs++] = procname_format_in;
+        nargs++;
         unsigned char *ip = (unsigned char *)&saddr.in.sin_addr.s_addr;
-
-        AUTO_STRING (ipv4_format, "%d.%d.%d.%d");
-        host = CALLN (Fformat, ipv4_format,
-                      make_number (ip[0]), make_number (ip[1]),
-                      make_number (ip[2]), make_number (ip[3]));
         service = make_number (ntohs (saddr.in.sin_port));
-        AUTO_STRING (caller_format, " <%s:%d>");
-        caller = CALLN (Fformat, caller_format, host, service);
+        for (int i = 0; i < 4; i++)
+          args[nargs++] = make_number (ip[i]);
+        args[nargs++] = service;
       }
       break;
 
 #ifdef AF_INET6
     case AF_INET6:
       {
-        Lisp_Object args[9];
-        uint16_t *ip6 = (uint16_t *)&saddr.in6.sin6_addr;
-        int i;
-
-        AUTO_STRING (ipv6_format, "%x:%x:%x:%x:%x:%x:%x:%x");
-        args[0] = ipv6_format;
-        for (i = 0; i < 8; i++)
-          args[i + 1] = make_number (ntohs (ip6[i]));
-        host = CALLMANY (Fformat, args);
+        args[nargs++] = procname_format_in6;
+        nargs++;
+        DECLARE_POINTER_ALIAS (ip6, uint16_t, &saddr.in6.sin6_addr);
         service = make_number (ntohs (saddr.in.sin_port));
-        AUTO_STRING (caller_format, " <[%s]:%d>");
-        caller = CALLN (Fformat, caller_format, host, service);
+        for (int i = 0; i < 8; i++)
+          args[nargs++] = make_number (ip6[i]);
+        args[nargs++] = service;
       }
       break;
 #endif
 
-#ifdef HAVE_LOCAL_SOCKETS
-    case AF_LOCAL:
-#endif
     default:
-      caller = Fnumber_to_string (make_number (connect_counter));
-      AUTO_STRING (space_less_than, " <");
-      AUTO_STRING (greater_than, ">");
-      caller = concat3 (space_less_than, caller, greater_than);
+      args[nargs++] = procname_format_default;
+      nargs++;
+      args[nargs++] = make_number (connect_counter);
       break;
     }
 
@@ -4731,16 +4763,17 @@ server_accept_connection (Lisp_Object server, int channel)
         buffer = ps->name;
       if (!NILP (buffer))
         {
-          buffer = concat2 (buffer, caller);
-          buffer = Fget_buffer_create (buffer);
+          args[1] = buffer;
+          buffer = Fget_buffer_create (Fformat (nargs, args));
         }
     }
 
   /* Generate a unique name for the new server process.  Combine the
      server process name with the caller identification.  */
 
-  name = concat2 (ps->name, caller);
-  proc = make_process (name);
+  args[1] = ps->name;
+  Lisp_Object name = Fformat (nargs, args);
+  Lisp_Object proc = make_process (name);
 
   chan_process[s] = proc;
 
@@ -5338,14 +5371,13 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
           nfds = xg_select (max_desc + 1,
                             &Available, (check_write ? &Writeok : 0),
                             NULL, &timeout, NULL);
+#elif defined HAVE_NS
+          /* And NS builds call thread_select in ns_select. */
+          nfds = ns_select (max_desc + 1,
+                            &Available, (check_write ? &Writeok : 0),
+                            NULL, &timeout, NULL);
 #else  /* !HAVE_GLIB */
-          nfds = thread_select (
-# ifdef HAVE_NS
-                                ns_select
-# else
-                                pselect
-# endif
-                                , max_desc + 1,
+          nfds = thread_select (pselect, max_desc + 1,
                                 &Available,
                                 (check_write ? &Writeok : 0),
                                 NULL, &timeout, NULL);
diff --git a/src/regex.c b/src/regex.c
index 8e38a920cdb..240a91f2ba8 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -2636,8 +2636,9 @@ regex_compile (const_re_char *pattern, size_t size,
           if ((syntax & RE_BK_PLUS_QM)
               || (syntax & RE_LIMITED_OPS))
             goto normal_char;
-        handle_plus:
+          FALLTHROUGH;
         case '*':
+        handle_plus:
           /* If there is no previous pattern...  */
           if (!laststart)
             {
@@ -3086,6 +3087,7 @@ regex_compile (const_re_char *pattern, size_t size,
                                    with non-0. */
                                 if (regnum == 0)
                                   FREE_STACK_RETURN (REG_BADPAT);
+                                FALLTHROUGH;
                               case '1': case '2': case '3': case '4':
                               case '5': case '6': case '7': case '8': case '9':
                                 regnum = 10*regnum + (c - '0'); break;
@@ -3905,8 +3907,7 @@ analyze_first (const_re_char *p, const_re_char *pend, char *fastmap,
                  j < (1 << BYTEWIDTH); j++)
               fastmap[j] = 1;
           }
-
-          /* Fallthrough */
+          FALLTHROUGH;
         case charset:
           if (!fastmap) break;
           not = (re_opcode_t) *(p - 1) == charset_not;
@@ -6182,8 +6183,7 @@ re_match_2_internal (struct re_pattern_buffer *bufp, const_re_char *string1,
             case on_failure_jump_nastyloop:
               assert ((re_opcode_t)pat[-2] == no_op);
               PUSH_FAILURE_POINT (pat - 2, str);
-              /* Fallthrough */
-
+              FALLTHROUGH;
             case on_failure_jump_loop:
             case on_failure_jump:
             case succeed_n:
diff --git a/src/search.c b/src/search.c
index 33cb02aa7af..19e789dfa87 100644
--- a/src/search.c
+++ b/src/search.c
@@ -1804,6 +1804,7 @@ boyer_moore (EMACS_INT n, unsigned char *base_pat,
     {
       /* Setup translate_prev_byte1/2/3/4 from CHAR_BASE.  Only a
          byte following them are the target of translation.  */
+      eassume (0x80 <= char_base && char_base <= MAX_CHAR);
       unsigned char str[MAX_MULTIBYTE_LENGTH];
       int cblen = CHAR_STRING (char_base, str);
 
@@ -2228,26 +2229,12 @@ See also the functions `match-beginning', `match-end' and `replace-match'.  */)
 
 DEFUN ("re-search-backward", Fre_search_backward, Sre_search_backward, 1, 4,
        "sRE search backward: ",
-       doc: /* Search backward from point for match for regular expression REGEXP.
-Set point to the beginning of the occurrence found, and return point.
-An optional second argument bounds the search; it is a buffer position.
-  The match found must not begin before that position.  A value of nil
-  means search to the beginning of the accessible portion of the buffer.
-Optional third argument, if t, means if fail just return nil (no error).
-  If not nil and not t, position at limit of search and return nil.
-Optional fourth argument COUNT, if a positive number, means to search
-  for COUNT successive occurrences.  If COUNT is negative, search
-  forward, instead of backward, for -COUNT occurrences.  A value of
-  nil means the same as 1.
-With COUNT positive, the match found is the COUNTth to last one (or
-  last, if COUNT is 1 or nil) in the buffer located entirely before
-  the origin of the search; correspondingly with COUNT negative.
-
-Search case-sensitivity is determined by the value of the variable
-`case-fold-search', which see.
+       doc: /* Search backward from point for regular expression REGEXP.
+This function is almost identical to `re-search-forward', except that
+by default it searches backward instead of forward, and the sign of
+COUNT also indicates exactly the opposite searching direction.
 
-See also the functions `match-beginning', `match-end', `match-string',
-and `replace-match'.  */)
+See `re-search-forward' for details.  */)
   (Lisp_Object regexp, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
 {
   return search_command (regexp, bound, noerror, count, -1, 1, 0);
@@ -2257,18 +2244,22 @@ DEFUN ("re-search-forward", Fre_search_forward, Sre_search_forward, 1, 4,
        "sRE search: ",
        doc: /* Search forward from point for regular expression REGEXP.
 Set point to the end of the occurrence found, and return point.
-An optional second argument bounds the search; it is a buffer position.
-  The match found must not end after that position.  A value of nil
-  means search to the end of the accessible portion of the buffer.
-Optional third argument, if t, means if fail just return nil (no error).
-  If not nil and not t, move to limit of search and return nil.
-Optional fourth argument COUNT, if a positive number, means to search
-  for COUNT successive occurrences.  If COUNT is negative, search
-  backward, instead of forward, for -COUNT occurrences.  A value of
-  nil means the same as 1.
-With COUNT positive, the match found is the COUNTth one (or first,
-  if COUNT is 1 or nil) in the buffer located entirely after the
-  origin of the search; correspondingly with COUNT negative.
+The optional second argument BOUND is a buffer position that bounds
+  the search.  The match found must not end after that position.  A
+  value of nil means search to the end of the accessible portion of
+  the buffer.
+The optional third argument NOERROR indicates how errors are handled
+  when the search fails.  If it is nil or omitted, emit an error; if
+  it is t, simply return nil and do nothing; if it is neither nil nor
+  t, move to the limit of search and return nil.
+The optional fourth argument COUNT is a number that indicates the
+  search direction and the number of occurrences to search for.  If it
+  is positive, search forward for COUNT successive occurrences; if it
+  is negative, search backward, instead of forward, for -COUNT
+  occurrences.  A value of nil means the same as 1.
+With COUNT positive/negative, the match found is the COUNTth/-COUNTth
+  one in the buffer located entirely after/before the origin of the
+  search.
 
 Search case-sensitivity is determined by the value of the variable
 `case-fold-search', which see.
@@ -2640,7 +2631,7 @@ since only regular expressions have distinguished subexpressions.  */)
           const unsigned char *add_stuff = NULL;
           ptrdiff_t add_len = 0;
           ptrdiff_t idx = -1;
-          ptrdiff_t begbyte;
+          ptrdiff_t begbyte UNINIT;
 
           if (str_multibyte)
             {
@@ -3389,6 +3380,10 @@ syms_of_search (void)
   /* Error condition used for failing searches.  */
   DEFSYM (Qsearch_failed, "search-failed");
 
+  /* Error condition used for failing searches started by user, i.e.,
+     where failure should not invoke the debugger.  */
+  DEFSYM (Quser_search_failed, "user-search-failed");
+
   /* Error condition signaled when regexp compile_pattern fails.  */
   DEFSYM (Qinvalid_regexp, "invalid-regexp");
 
@@ -3397,6 +3392,12 @@ syms_of_search (void)
   Fput (Qsearch_failed, Qerror_message,
         build_pure_c_string ("Search failed"));
 
+  Fput (Quser_search_failed, Qerror_conditions,
+        listn (CONSTYPE_PURE, 4,
+               Quser_search_failed, Quser_error, Qsearch_failed, Qerror));
+  Fput (Quser_search_failed, Qerror_message,
+        build_pure_c_string ("Search failed"));
+
   Fput (Qinvalid_regexp, Qerror_conditions,
         listn (CONSTYPE_PURE, 2, Qinvalid_regexp, Qerror));
   Fput (Qinvalid_regexp, Qerror_message,
diff --git a/src/syntax.c b/src/syntax.c
index 7aa43e6e5c7..dcaca22f0e2 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -810,6 +810,7 @@ back_comment (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop,
         case Sstring_fence:
         case Scomment_fence:
           c = (code == Sstring_fence ? ST_STRING_STYLE : ST_COMMENT_STYLE);
+          FALLTHROUGH;
         case Sstring:
           /* Track parity of quotes.  */
           if (string_style == -1)
@@ -2690,6 +2691,7 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
                 goto lose;
               INC_BOTH (from, from_byte);
               /* Treat following character as a word constituent.  */
+              FALLTHROUGH;
             case Sword:
             case Ssymbol:
               if (depth || !sexpflag) break;
@@ -2721,7 +2723,7 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
 
             case Scomment_fence:
               comstyle = ST_COMMENT_STYLE;
-              /* FALLTHROUGH */
+              FALLTHROUGH;
             case Scomment:
               if (!parse_sexp_ignore_comments) break;
               UPDATE_SYNTAX_TABLE_FORWARD (from);
@@ -2753,7 +2755,7 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
                   goto close1;
                 }
               mathexit = 1;
-
+              FALLTHROUGH;
             case Sopen:
               if (!++depth) goto done;
               break;
@@ -2909,7 +2911,7 @@ scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
                   goto open2;
                 }
               mathexit = 1;
-
+              FALLTHROUGH;
             case Sclose:
               if (!++depth) goto done2;
               break;
diff --git a/src/sysdep.c b/src/sysdep.c
index 91b2a5cb943..b52236769e0 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -368,8 +368,8 @@ init_baud_rate (int fd)
    Use waitpid-style OPTIONS when waiting.
    If INTERRUPTIBLE, this function is interruptible by a signal.
 
-   Return CHILD if successful, 0 if no status is available;
-   the latter is possible only when options & NOHANG.  */
+   Return CHILD if successful, 0 if no status is available, and a
+   negative value (setting errno) if waitpid is buggy.  */
 static pid_t
 get_child_status (pid_t child, int *status, int options, bool interruptible)
 {
@@ -392,13 +392,14 @@ get_child_status (pid_t child, int *status, int options, bool interruptible)
       pid = waitpid (child, status, options);
       if (0 <= pid)
         break;
-
-      /* Check that CHILD is a child process that has not been reaped,
-         and that STATUS and OPTIONS are valid.  Otherwise abort,
-         as continuing after this internal error could cause Emacs to
-         become confused and kill innocent-victim processes.  */
       if (errno != EINTR)
-        emacs_abort ();
+        {
+          /* Most likely, waitpid is buggy and the operating system
+             lost track of the child somehow.  Return -1 and let the
+             caller try to figure things out.  Possibly the bug could
+             cause Emacs to kill the wrong process.  Oh well.  */
+          return pid;
+        }
     }
 
   /* If successful and status is requested, tell wait_reading_process_output
@@ -413,11 +414,13 @@ get_child_status (pid_t child, int *status, int options, bool interruptible)
    CHILD must be a child process that has not been reaped.
    If STATUS is non-null, store the waitpid-style exit status into *STATUS
    and tell wait_reading_process_output that it needs to look around.
-   If INTERRUPTIBLE, this function is interruptible by a signal.  */
-void
+   If INTERRUPTIBLE, this function is interruptible by a signal.
+   Return true if successful, false (setting errno) if CHILD cannot be
+   waited for because waitpid is buggy.  */
+bool
 wait_for_termination (pid_t child, int *status, bool interruptible)
 {
-  get_child_status (child, status, 0, interruptible);
+  return 0 <= get_child_status (child, status, 0, interruptible);
 }
 
 /* Report whether the subprocess with process id CHILD has changed status.
@@ -1405,7 +1408,7 @@ reset_sys_modes (struct tty_display_info *tty_out)
 {
   if (noninteractive)
     {
-      fflush (stdout);
+      fflush_unlocked (stdout);
       return;
     }
   if (!tty_out->term_initted)
@@ -1425,17 +1428,14 @@ reset_sys_modes (struct tty_display_info *tty_out)
     }
   else
     {                   /* have to do it the hard way */
-      int i;
       tty_turn_off_insert (tty_out);
 
-      for (i = cursorX (tty_out); i < FrameCols (tty_out) - 1; i++)
-        {
-          fputc (' ', tty_out->output);
-        }
+      for (int i = cursorX (tty_out); i < FrameCols (tty_out) - 1; i++)
+        fputc_unlocked (' ', tty_out->output);
     }
 
   cmgoto (tty_out, FrameRows (tty_out) - 1, 0);
-  fflush (tty_out->output);
+  fflush_unlocked (tty_out->output);
 
   if (tty_out->terminal->reset_terminal_modes_hook)
     tty_out->terminal->reset_terminal_modes_hook (tty_out->terminal);
@@ -3076,7 +3076,7 @@ procfs_ttyname (int rdev)
       char minor[25];   /* 2 32-bit numbers + dash */
       char *endp;
 
-      for (; !feof (fdev) && !ferror (fdev); name[0] = 0)
+      for (; !feof_unlocked (fdev) && !ferror_unlocked (fdev); name[0] = 0)
         {
           if (fscanf (fdev, "%*s %s %u %s %*s\n", name, &major, minor) >= 3
               && major == MAJOR (rdev))
@@ -3126,7 +3126,7 @@ procfs_get_total_memory (void)
             break;
 
           case 0:
-            while ((c = getc (fmem)) != EOF && c != '\n')
+            while ((c = getc_unlocked (fmem)) != EOF && c != '\n')
               continue;
             done = c == EOF;
             break;
@@ -3707,14 +3707,9 @@ Lisp_Object
 system_process_attributes (Lisp_Object pid)
 {
   int proc_id;
-  int pagesize = getpagesize ();
-  unsigned long npages;
-  int fscale;
   struct passwd *pw;
   struct group  *gr;
   char *ttyname;
-  size_t len;
-  char args[MAXPATHLEN];
   struct timeval starttime;
   struct timespec t, now;
   struct rusage *rusage;
diff --git a/src/sysstdio.h b/src/sysstdio.h
index 45ee33f5580..7fbcefcdad9 100644
--- a/src/sysstdio.h
+++ b/src/sysstdio.h
@@ -33,4 +33,45 @@ extern FILE *emacs_fopen (char const *, char const *);
 # define FOPEN_TEXT ""
 #endif
 
+/* These are compatible with unlocked-io.h, if both files are included.  */
+#if !HAVE_DECL_CLEARERR_UNLOCKED
+# define clearerr_unlocked(x) clearerr (x)
+#endif
+#if !HAVE_DECL_FEOF_UNLOCKED
+# define feof_unlocked(x) feof (x)
+#endif
+#if !HAVE_DECL_FERROR_UNLOCKED
+# define ferror_unlocked(x) ferror (x)
+#endif
+#if !HAVE_DECL_FFLUSH_UNLOCKED
+# define fflush_unlocked(x) fflush (x)
+#endif
+#if !HAVE_DECL_FGETS_UNLOCKED
+# define fgets_unlocked(x,y,z) fgets (x,y,z)
+#endif
+#if !HAVE_DECL_FPUTC_UNLOCKED
+# define fputc_unlocked(x,y) fputc (x,y)
+#endif
+#if !HAVE_DECL_FPUTS_UNLOCKED
+# define fputs_unlocked(x,y) fputs (x,y)
+#endif
+#if !HAVE_DECL_FREAD_UNLOCKED
+# define fread_unlocked(w,x,y,z) fread (w,x,y,z)
+#endif
+#if !HAVE_DECL_FWRITE_UNLOCKED
+# define fwrite_unlocked(w,x,y,z) fwrite (w,x,y,z)
+#endif
+#if !HAVE_DECL_GETC_UNLOCKED
+# define getc_unlocked(x) getc (x)
+#endif
+#if !HAVE_DECL_GETCHAR_UNLOCKED
+# define getchar_unlocked() getchar ()
+#endif
+#if !HAVE_DECL_PUTC_UNLOCKED
+# define putc_unlocked(x,y) putc (x,y)
+#endif
+#if !HAVE_DECL_PUTCHAR_UNLOCKED
+# define putchar_unlocked(x) putchar (x)
+#endif
+
 #endif /* EMACS_SYSSTDIO_H */
diff --git a/src/systhread.c b/src/systhread.c
index a84060c18f0..aee12a9b482 100644
--- a/src/systhread.c
+++ b/src/systhread.c
@@ -20,6 +20,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <setjmp.h>
 #include "lisp.h"
 
+#ifdef HAVE_NS
+#include "nsterm.h"
+#endif
+
 #ifndef THREADS_ENABLED
 
 void
@@ -130,6 +134,13 @@ void
 sys_cond_broadcast (sys_cond_t *cond)
 {
   pthread_cond_broadcast (cond);
+#ifdef HAVE_NS
+  /* Send an app defined event to break out of the NS run loop.
+     It seems that if ns_select is running the NS run loop, this
+     broadcast has no effect until the loop is done, breaking a couple
+     of tests in thread-tests.el. */
+  ns_run_loop_break ();
+#endif
 }
 
 void
diff --git a/src/syswait.h b/src/syswait.h
index 846a975b241..055562ae48b 100644
--- a/src/syswait.h
+++ b/src/syswait.h
@@ -56,7 +56,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 
 /* Defined in sysdep.c.  */
-extern void wait_for_termination (pid_t, int *, bool);
+extern bool wait_for_termination (pid_t, int *, bool);
 extern pid_t child_status_changed (pid_t, int *, int);
 
 #endif /* EMACS_SYSWAIT_H */
diff --git a/src/term.c b/src/term.c
index 8770aff8a92..3d7f4ada0b9 100644
--- a/src/term.c
+++ b/src/term.c
@@ -22,7 +22,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <config.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <stdio.h>
 #include <stdlib.h>
 #include <sys/file.h>
 #include <sys/time.h>
@@ -45,6 +44,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "keymap.h"
 #include "blockinput.h"
 #include "syssignal.h"
+#include "sysstdio.h"
 #ifdef MSDOS
 #include "msdos.h"
 static int been_here = -1;
@@ -146,7 +146,7 @@ tty_ring_bell (struct frame *f)
       OUTPUT (tty, (tty->TS_visible_bell && visible_bell
                     ? tty->TS_visible_bell
                     : tty->TS_bell));
-      fflush (tty->output);
+      fflush_unlocked (tty->output);
     }
 }
 
@@ -167,9 +167,10 @@ tty_send_additional_strings (struct terminal *terminal, Lisp_Object sym)
       Lisp_Object string = XCAR (extra_codes);
       if (STRINGP (string))
         {
-          fwrite (SDATA (string), 1, SBYTES (string), tty->output);
+          fwrite_unlocked (SDATA (string), 1, SBYTES (string), tty->output);
           if (tty->termscript)
-            fwrite (SDATA (string), 1, SBYTES (string), tty->termscript);
+            fwrite_unlocked (SDATA (string), 1, SBYTES (string),
+                             tty->termscript);
         }
     }
 }
@@ -197,7 +198,7 @@ tty_set_terminal_modes (struct terminal *terminal)
       OUTPUT_IF (tty, tty->TS_keypad_mode);
       losecursor (tty);
       tty_send_additional_strings (terminal, Qtty_mode_set_strings);
-      fflush (tty->output);
+      fflush_unlocked (tty->output);
     }
 }
 
@@ -220,7 +221,7 @@ tty_reset_terminal_modes (struct terminal *terminal)
       /* Output raw CR so kernel can track the cursor hpos.  */
       current_tty = tty;
       cmputc ('\r');
-      fflush (tty->output);
+      fflush_unlocked (tty->output);
     }
 }
 
@@ -235,7 +236,7 @@ tty_update_end (struct frame *f)
     tty_show_cursor (tty);
   tty_turn_off_insert (tty);
   tty_background_highlight (tty);
-  fflush (tty->output);
+  fflush_unlocked (tty->output);
 }
 
 /* The implementation of set_terminal_window for termcap frames. */
@@ -497,8 +498,8 @@ tty_clear_end_of_line (struct frame *f, int first_unused_hpos)
       for (i = curX (tty); i < first_unused_hpos; i++)
         {
           if (tty->termscript)
-            fputc (' ', tty->termscript);
-          fputc (' ', tty->output);
+            fputc_unlocked (' ', tty->termscript);
+          fputc_unlocked (' ', tty->output);
         }
       cmplus (tty, first_unused_hpos - curX (tty));
     }
@@ -771,11 +772,11 @@ tty_write_glyphs (struct frame *f, struct glyph *string, int len)
       if (coding->produced > 0)
         {
           block_input ();
-          fwrite (conversion_buffer, 1, coding->produced, tty->output);
-          if (ferror (tty->output))
-            clearerr (tty->output);
+          fwrite_unlocked (conversion_buffer, 1, coding->produced, tty->output);
+          clearerr_unlocked (tty->output);
           if (tty->termscript)
-            fwrite (conversion_buffer, 1, coding->produced, tty->termscript);
+            fwrite_unlocked (conversion_buffer, 1, coding->produced,
+                             tty->termscript);
           unblock_input ();
         }
       string += n;
@@ -832,11 +833,11 @@ tty_write_glyphs_with_face (register struct frame *f, register struct glyph *str
   if (coding->produced > 0)
     {
       block_input ();
-      fwrite (conversion_buffer, 1, coding->produced, tty->output);
-      if (ferror (tty->output))
-        clearerr (tty->output);
+      fwrite_unlocked (conversion_buffer, 1, coding->produced, tty->output);
+      clearerr_unlocked (tty->output);
       if (tty->termscript)
-        fwrite (conversion_buffer, 1, coding->produced, tty->termscript);
+        fwrite_unlocked (conversion_buffer, 1, coding->produced,
+                         tty->termscript);
       unblock_input ();
     }
 
@@ -918,11 +919,11 @@ tty_insert_glyphs (struct frame *f, struct glyph *start, int len)
       if (coding->produced > 0)
         {
           block_input ();
-          fwrite (conversion_buffer, 1, coding->produced, tty->output);
-          if (ferror (tty->output))
-            clearerr (tty->output);
+          fwrite_unlocked (conversion_buffer, 1, coding->produced, tty->output);
+          clearerr_unlocked (tty->output);
           if (tty->termscript)
-            fwrite (conversion_buffer, 1, coding->produced, tty->termscript);
+            fwrite_unlocked (conversion_buffer, 1, coding->produced,
+                             tty->termscript);
           unblock_input ();
         }
 
@@ -3327,7 +3328,7 @@ tty_menu_activate (tty_menu *menu, int *pane, int *selidx,
          which calls tty_show_cursor.  Re-hide it, so it doesn't show
          through the menus.  */
       tty_hide_cursor (tty);
-      fflush (tty->output);
+      fflush_unlocked (tty->output);
     }
 
   sf->mouse_moved = 0;
@@ -3335,7 +3336,7 @@ tty_menu_activate (tty_menu *menu, int *pane, int *selidx,
   while (statecount--)
     free_saved_screen (state[statecount].screen_behind);
   tty_show_cursor (tty);        /* Turn cursor back on.  */
-  fflush (tty->output);
+  fflush_unlocked (tty->output);
 
 /* Clean up any mouse events that are waiting inside Emacs event queue.
      These events are likely to be generated before the menu was even
diff --git a/src/termhooks.h b/src/termhooks.h
index 3b1b4959b1d..14ec397346a 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -202,6 +202,9 @@ enum event_kind
 
   FOCUS_OUT_EVENT,
 
+  /* Generated when a frame is moved.  */
+  MOVE_FRAME_EVENT,
+
   /* Generated when mouse moves over window not currently selected.  */
   SELECT_WINDOW_EVENT,
 
diff --git a/src/terminal.c b/src/terminal.c
index 0b1cbe7b791..367f2ac7192 100644
--- a/src/terminal.c
+++ b/src/terminal.c
@@ -575,7 +575,10 @@ Lisp_Object
 terminal_glyph_code (struct terminal *t, int ch)
 {
 #if HAVE_STRUCT_UNIPAIR_UNICODE
-  if (t->type == output_termcap)
+  /* Heuristically assume that a terminal supporting glyph codes is in
+     UTF-8 mode if and only if its coding system is UTF-8 (Bug#26396).  */
+  if (t->type == output_termcap
+      && t->terminal_coding->encoder == encode_coding_utf_8)
     {
       /* As a hack, recompute the table when CH is the maximum
          character.  */
diff --git a/src/thread.c b/src/thread.c
index 9ea7e121a82..e3787971a53 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -664,7 +664,7 @@ DEFUN ("thread-yield", Fthread_yield, Sthread_yield, 0, 0, 0,
 static Lisp_Object
 invoke_thread_function (void)
 {
-  int count = SPECPDL_INDEX ();
+  ptrdiff_t count = SPECPDL_INDEX ();
 
   Ffuncall (1, &current_thread->function);
   return unbind_to (count, Qnil);
diff --git a/src/unexelf.c b/src/unexelf.c
index 7fad64fab17..5129784ade2 100644
--- a/src/unexelf.c
+++ b/src/unexelf.c
@@ -576,7 +576,17 @@ unexec (const char *new_name, const char *old_name)
     }
 
   /* This loop seeks out relocation sections for the data section, so
-     that it can undo relocations performed by the runtime loader.  */
+     that it can undo relocations performed by the runtime loader.
+
+     The following approach does not work on x86 platforms that use
+     the GNU Gold linker, which can generate .rel.dyn relocation
+     sections containing R_386_32 entries that the following code does
+     not grok.  Emacs works around this problem by avoiding C
+     constructs that generate such entries, which is horrible hack.
+
+     FIXME: Presumably more problems like this will crop up as linkers
+     get fancier.  We really need to stop assuming that Emacs can grok
+     arbitrary linker output.  See Bug#27248.  */
   for (n = new_file_h->e_shnum; 0 < --n; )
     {
       ElfW (Shdr) *rel_shdr = &NEW_SECTION_H (n);
diff --git a/src/unexmacosx.c b/src/unexmacosx.c
index 97dcb435d37..3b1efa3ca30 100644
--- a/src/unexmacosx.c
+++ b/src/unexmacosx.c
@@ -346,31 +346,6 @@ print_region_list (void)
     print_region (r->address, r->size, r->protection, r->max_protection);
 }
 
-static void
-print_regions (void)
-{
-  task_t target_task = mach_task_self ();
-  vm_address_t address = (vm_address_t) 0;
-  vm_size_t size;
-  struct vm_region_basic_info info;
-  mach_msg_type_number_t info_count = VM_REGION_BASIC_INFO_COUNT;
-  mach_port_t object_name;
-
-  printf ("   address     size prot maxp\n");
-
-  while (vm_region (target_task, &address, &size, VM_REGION_BASIC_INFO,
-                    (vm_region_info_t) &info, &info_count, &object_name)
-         == KERN_SUCCESS && info_count == VM_REGION_BASIC_INFO_COUNT)
-    {
-      print_region (address, size, info.protection, info.max_protection);
-
-      if (object_name != MACH_PORT_NULL)
-        mach_port_deallocate (target_task, object_name);
-
-      address += size;
-    }
-}
-
 /* Build the list of regions that need to be dumped.  Regions with
    addresses above VM_DATA_TOP are omitted.  Adjacent regions with
    identical protection are merged.  Note that non-writable regions
diff --git a/src/w32.c b/src/w32.c
index f35ad67d829..fa3cbe183fb 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -2978,31 +2978,6 @@ emacs_root_dir (void)
   return root_dir;
 }
 
-#include <sys/timeb.h>
-
-/* Emulate gettimeofday (Ulrich Leodolter, 1/11/95).  */
-int
-gettimeofday (struct timeval *__restrict tv, struct timezone *__restrict tz)
-{
-  struct _timeb tb;
-  _ftime (&tb);
-
-  tv->tv_sec = tb.time;
-  tv->tv_usec = tb.millitm * 1000L;
-  /* Implementation note: _ftime sometimes doesn't update the dstflag
-     according to the new timezone when the system timezone is
-     changed.  We could fix that by using GetSystemTime and
-     GetTimeZoneInformation, but that doesn't seem necessary, since
-     Emacs always calls gettimeofday with the 2nd argument NULL (see
-     current_emacs_time).  */
-  if (tz)
-    {
-      tz->tz_minuteswest = tb.timezone; /* minutes west of Greenwich  */
-      tz->tz_dsttime = tb.dstflag;      /* type of dst correction  */
-    }
-  return 0;
-}
-
 /* Emulate fdutimens.  */
 
 /* Set the access and modification time stamps of FD (a.k.a. FILE) to be
diff --git a/src/w32fns.c b/src/w32fns.c
index dd16d74439f..b0842b5ee6c 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -256,6 +256,10 @@ static unsigned int sound_type = 0xFFFFFFFF;
 # define WTS_SESSION_LOCK      0x7
 #endif
 
+#ifndef WS_EX_NOACTIVATE
+#define WS_EX_NOACTIVATE 0x08000000L
+#endif
+
 /* Keyboard hook state data.  */
 static struct
 {
@@ -367,17 +371,20 @@ void x_set_title (struct frame *, Lisp_Object, Lisp_Object);
 void
 x_real_positions (struct frame *f, int *xptr, int *yptr)
 {
-  POINT pt;
   RECT rect;
 
   /* Get the bounds of the WM window.  */
   GetWindowRect (FRAME_W32_WINDOW (f), &rect);
 
-  pt.x = 0;
-  pt.y = 0;
+  if (FRAME_PARENT_FRAME (f))
+    {
+      /* For a child window we have to get its coordinates wrt its
+         parent.  */
+      HWND parent_hwnd = FRAME_W32_WINDOW (FRAME_PARENT_FRAME (f));
 
-  /* Convert (0, 0) in the client area to screen co-ordinates.  */
-  ClientToScreen (FRAME_W32_WINDOW (f), &pt);
+      if (parent_hwnd)
+        MapWindowPoints (HWND_DESKTOP, parent_hwnd, (LPPOINT) &rect, 2);
+    }
 
   *xptr = rect.left;
   *yptr = rect.top;
@@ -1627,7 +1634,13 @@ x_set_icon_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 #endif
 }
 
-static void
+/**
+ * x_clear_under_internal_border:
+ *
+ * Clear area of frame F's internal border.  If the internal border face
+ * of F has been specified (is not null), fill the area with that face.
+ */
+void
 x_clear_under_internal_border (struct frame *f)
 {
   int border = FRAME_INTERNAL_BORDER_WIDTH (f);
@@ -1638,18 +1651,38 @@ x_clear_under_internal_border (struct frame *f)
       HDC hdc = get_frame_dc (f);
       int width = FRAME_PIXEL_WIDTH (f);
       int height = FRAME_PIXEL_HEIGHT (f);
+      struct face *face = FACE_FROM_ID_OR_NULL (f, INTERNAL_BORDER_FACE_ID);
 
       block_input ();
-      w32_clear_area (f, hdc, 0, FRAME_TOP_MARGIN_HEIGHT (f), width, border);
-      w32_clear_area (f, hdc, 0, 0, border, height);
-      w32_clear_area (f, hdc, width - border, 0, border, height);
-      w32_clear_area (f, hdc, 0, height - border, width, border);
+      if (face)
+        {
+          /* Fill border with internal border face.  */
+          unsigned long color = face->background;
+
+          w32_fill_area (f, hdc, color, 0, FRAME_TOP_MARGIN_HEIGHT (f), width, border);
+          w32_fill_area (f, hdc, color, 0, 0, border, height);
+          w32_fill_area (f, hdc, color, width - border, 0, border, height);
+          w32_fill_area (f, hdc, color, 0, height - border, width, border);
+        }
+      else
+        {
+          w32_clear_area (f, hdc, 0, FRAME_TOP_MARGIN_HEIGHT (f), width, border);
+          w32_clear_area (f, hdc, 0, 0, border, height);
+          w32_clear_area (f, hdc, width - border, 0, border, height);
+          w32_clear_area (f, hdc, 0, height - border, width, border);
+        }
       release_frame_dc (f, hdc);
       unblock_input ();
     }
 }
 
 
+/**
+ * x_set_internal_border_width:
+ *
+ * Set width of frame F's internal border to ARG pixels.  ARG < 0 is
+ * treated like ARG = 0.
+ */
 void
 x_set_internal_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
 {
@@ -1673,44 +1706,59 @@ x_set_internal_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldva
 }
 
 
+/**
+ * x_set_menu_bar_lines:
+ *
+ * Set number of lines of frame F's menu bar to VALUE.  An integer
+ * greater zero specifies 1 line and turns the menu bar on if it was off
+ * before.  Any other value specifies 0 lines and turns the menu bar off
+ * if it was on before.
+ */
 void
 x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
 {
-  int nlines;
-
   /* Right now, menu bars don't work properly in minibuf-only frames;
      most of the commands try to apply themselves to the minibuffer
-     frame itself, and get an error because you can't switch buffers
-     in or split the minibuffer window.  */
-  if (FRAME_MINIBUF_ONLY_P (f))
-    return;
+     frame itself, and get an error because you can't switch buffers in
+     or split the minibuffer window.  Child frames don't like menu bars
+     either.  */
+  if (!FRAME_MINIBUF_ONLY_P (f) && !FRAME_PARENT_FRAME (f))
+    {
+      boolean old = FRAME_EXTERNAL_MENU_BAR (f);
+      boolean new = (INTEGERP (value) && XINT (value) > 0) ? true : false;
 
-  if (INTEGERP (value))
-    nlines = XINT (value);
-  else
-    nlines = 0;
+      FRAME_MENU_BAR_LINES (f) = 0;
+      FRAME_MENU_BAR_HEIGHT (f) = 0;
 
-  FRAME_MENU_BAR_LINES (f) = 0;
-  FRAME_MENU_BAR_HEIGHT (f) = 0;
-  if (nlines)
-    FRAME_EXTERNAL_MENU_BAR (f) = 1;
-  else
-    {
-      if (FRAME_EXTERNAL_MENU_BAR (f) == 1)
-        free_frame_menubar (f);
-      FRAME_EXTERNAL_MENU_BAR (f) = 0;
+      if (old != new)
+        {
+          FRAME_EXTERNAL_MENU_BAR (f) = new;
 
-      /* Adjust the frame size so that the client (text) dimensions
-         remain the same.  This depends on FRAME_EXTERNAL_MENU_BAR being
-         set correctly.  Note that we resize twice: The first time upon
-         a request from the window manager who wants to keep the height
-         of the outer rectangle (including decorations) unchanged, and a
-         second time because we want to keep the height of the inner
-         rectangle (without the decorations unchanged).  */
-      adjust_frame_size (f, -1, -1, 2, true, Qmenu_bar_lines);
+          if (!old)
+            /* Make menu bar when there was none.  Emacs 25 waited until
+               the next redisplay for this to take effect.  */
+            set_frame_menubar (f, false, true);
+          else
+            {
+              /* Remove menu bar.  */
+              free_frame_menubar (f);
+
+              /* Adjust the frame size so that the client (text) dimensions
+                 remain the same.  Note that we resize twice: The first time
+                 upon a request from the window manager who wants to keep
+                 the height of the outer rectangle (including decorations)
+                 unchanged, and a second time because we want to keep the
+                 height of the inner rectangle (without the decorations
+                 unchanged).  */
+              adjust_frame_size (f, -1, -1, 2, false, Qmenu_bar_lines);
+            }
 
-      /* Not sure whether this is needed.  */
-      x_clear_under_internal_border (f);
+          if (FRAME_W32_WINDOW (f))
+            x_clear_under_internal_border (f);
+
+          /* Don't store anything but 1 or 0 in the parameter.  */
+          store_frame_param (f, Qmenu_bar_lines, make_number (new ? 1 : 0));
+        }
     }
 }
 
@@ -1793,7 +1841,7 @@ x_change_tool_bar_height (struct frame *f, int height)
      here.  */
   adjust_frame_glyphs (f);
   SET_FRAME_GARBAGED (f);
-  if (FRAME_X_WINDOW (f))
+  if (FRAME_W32_WINDOW (f))
     x_clear_under_internal_border (f);
 }
 
@@ -1955,6 +2003,233 @@ x_set_scroll_bar_default_height (struct frame *f)
   FRAME_CONFIG_SCROLL_BAR_LINES (f)
     = (FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) + unit - 1) / unit;
 }
+
+/**
+ * x_set_undecorated:
+ *
+ * Set frame F's `undecorated' parameter.  If non-nil, F's window-system
+ * window is drawn without decorations, title, minimize/maximize boxes
+ * and external borders.  This usually means that the window cannot be
+ * dragged, resized, iconified, maximized or deleted with the mouse.  If
+ * nil, draw the frame with all the elements listed above unless these
+ * have been suspended via window manager settings.
+ *
+ * Some window managers may not honor this parameter.
+ */
+static void
+x_set_undecorated (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  HWND hwnd = FRAME_W32_WINDOW (f);
+  DWORD dwStyle = GetWindowLong (hwnd, GWL_STYLE);
+  Lisp_Object border_width = Fcdr (Fassq (Qborder_width, f->param_alist));
+
+  block_input ();
+  if (!NILP (new_value) && !FRAME_UNDECORATED (f))
+    {
+      dwStyle = ((dwStyle & ~WS_THICKFRAME & ~WS_CAPTION)
+                 | ((NUMBERP (border_width) && (XINT (border_width) > 0))
+                    ? WS_BORDER : false));
+      SetWindowLong (hwnd, GWL_STYLE, dwStyle);
+      SetWindowPos (hwnd, HWND_TOP, 0, 0, 0, 0,
+                    SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE
+                    | SWP_FRAMECHANGED);
+      FRAME_UNDECORATED (f) = true;
+    }
+  else if (NILP (new_value) && FRAME_UNDECORATED (f))
+    {
+      SetWindowLong (hwnd, GWL_STYLE, dwStyle | WS_THICKFRAME | WS_CAPTION
+                     | WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_SYSMENU);
+      SetWindowPos (hwnd, HWND_TOP, 0, 0, 0, 0,
+                    SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE
+                    | SWP_FRAMECHANGED);
+      FRAME_UNDECORATED (f) = false;
+    }
+  unblock_input ();
+}
+
+/**
+ * x_set_parent_frame:
+ *
+ * Set frame F's `parent-frame' parameter.  If non-nil, make F a child
+ * frame of the frame specified by that parameter.  Technically, this
+ * makes F's window-system window a child window of the parent frame's
+ * window-system window.  If nil, make F's window-system window a
+ * top-level window--a child of its display's root window.
+ *
+ * A child frame is clipped at the native edges of its parent frame.
+ * Its `left' and `top' parameters specify positions relative to the
+ * top-left corner of its parent frame's native rectangle.  Usually,
+ * moving a parent frame moves all its child frames too, keeping their
+ * position relative to the parent unaltered.  When a parent frame is
+ * iconified or made invisible, its child frames are made invisible.
+ * When a parent frame is deleted, its child frames are deleted too.
+ *
+ * A visible child frame always appears on top of its parent frame thus
+ * obscuring parts of it.  When a frame has more than one child frame,
+ * their stacking order is specified just as that of non-child frames
+ * relative to their display.
+ *
+ * Whether a child frame has a menu or tool bar may be window-system or
+ * window manager dependent.  It's advisable to disable both via the
+ * frame parameter settings.
+ *
+ * Some window managers may not honor this parameter.
+ */
+static void
+x_set_parent_frame (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  struct frame *p = NULL;
+
+  if (!NILP (new_value)
+      && (!FRAMEP (new_value)
+          || !FRAME_LIVE_P (p = XFRAME (new_value))
+          || !FRAME_W32_P (p)))
+    {
+      store_frame_param (f, Qparent_frame, old_value);
+      error ("Invalid specification of `parent-frame'");
+    }
+
+  if (p != FRAME_PARENT_FRAME (f))
+    {
+      HWND hwnd = FRAME_W32_WINDOW (f);
+      HWND hwnd_parent = p ? FRAME_W32_WINDOW (p) : NULL;
+      HWND hwnd_value;
+
+      block_input ();
+      hwnd_value = SetParent (hwnd, hwnd_parent);
+      unblock_input ();
+
+      if (hwnd_value)
+        fset_parent_frame (f, new_value);
+      else
+        {
+          store_frame_param (f, Qparent_frame, old_value);
+          error ("Reparenting frame failed");
+        }
+    }
+}
+
+/**
+ * x_set_skip_taskbar:
+ *
+ * Set frame F's `skip-taskbar' parameter.  If non-nil, this should
+ * remove F's icon from the taskbar associated with the display of F's
+ * window-system window and inhibit switching to F's window via
+ * <Alt>-<TAB>.  On Windows iconifying F will "roll in" its window at
+ * the bottom of the desktop.  If nil, lift these restrictions.
+ *
+ * Some window managers may not honor this parameter.
+ */
+static void
+x_set_skip_taskbar (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  if (!EQ (new_value, old_value))
+    {
+      HWND hwnd = FRAME_W32_WINDOW (f);
+      DWORD exStyle = GetWindowLong (hwnd, GWL_EXSTYLE);
+
+      block_input ();
+      /* Temporarily hide the window while changing its WS_EX_NOACTIVATE
+         setting.  */
+      ShowWindow (hwnd, SW_HIDE);
+      if (!NILP (new_value))
+        SetWindowLong (hwnd, GWL_EXSTYLE, exStyle | WS_EX_NOACTIVATE);
+      else
+        SetWindowLong (hwnd, GWL_EXSTYLE, exStyle & ~WS_EX_NOACTIVATE);
+      ShowWindow (hwnd, SW_SHOWNOACTIVATE);
+      unblock_input ();
+
+      FRAME_SKIP_TASKBAR (f) = !NILP (new_value);
+    }
+}
+
+/**
+ * x_set_no_focus_on_map:
+ *
+ * Set frame F's `no-focus-on-map' parameter which, if non-nil, means
+ * that F's window-system window does not want to receive input focus
+ * when it is mapped.  (A frame's window is mapped when the frame is
+ * displayed for the first time and when the frame changes its state
+ * from `iconified' or `invisible' to `visible'.)
+ *
+ * Some window managers may not honor this parameter.
+ */
+static void
+x_set_no_focus_on_map (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  if (!EQ (new_value, old_value))
+    FRAME_NO_FOCUS_ON_MAP (f) = !NILP (new_value);
+}
+
+/**
+ * x_set_no_accept_focus:
+ *
+ * Set frame F's `no-accept-focus' parameter which, if non-nil, hints
+ * that F's window-system window does not want to receive input focus
+ * via mouse clicks or by moving the mouse into it.
+ *
+ * If non-nil, this may have the unwanted side-effect that a user cannot
+ * scroll a non-selected frame with the mouse.
+ *
+ * Some window managers may not honor this parameter.
+ */
+static void
+x_set_no_accept_focus (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  if (!EQ (new_value, old_value))
+    FRAME_NO_ACCEPT_FOCUS (f) = !NILP (new_value);
+}
+
+/**
+ * x_set_z_group:
+ *
+ * Set frame F's `z-group' parameter.  If `above', F's window-system
+ * window is displayed above all windows that do not have the `above'
+ * property set.  If nil, F's window is shown below all windows that
+ * have the `above' property set and above all windows that have the
+ * `below' property set.  If `below', F's window is displayed below all
+ * windows that do not have the `below' property set.
+ *
+ * Some window managers may not honor this parameter.  The value `below'
+ * is not supported on Windows.
+ */
+static void
+x_set_z_group (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  HWND hwnd = FRAME_W32_WINDOW (f);
+
+  if (NILP (new_value))
+    {
+      block_input ();
+      SetWindowPos (hwnd, HWND_NOTOPMOST, 0, 0, 0, 0,
+                    SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE
+                    | SWP_NOOWNERZORDER);
+      unblock_input ();
+      FRAME_Z_GROUP (f) = z_group_none;
+    }
+  else if (EQ (new_value, Qabove))
+    {
+      block_input ();
+      SetWindowPos (hwnd, HWND_TOPMOST, 0, 0, 0, 0,
+                    SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE
+                    | SWP_NOOWNERZORDER);
+      unblock_input ();
+      FRAME_Z_GROUP (f) = z_group_above;
+    }
+  else if (EQ (new_value, Qabove_suspended))
+    {
+      block_input ();
+      SetWindowPos (hwnd, HWND_NOTOPMOST, 0, 0, 0, 0,
+                    SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE
+                    | SWP_NOOWNERZORDER);
+      unblock_input ();
+      FRAME_Z_GROUP (f) = z_group_above_suspended;
+    }
+  else if (EQ (new_value, Qbelow))
+    error ("Value `below' for z-group is not supported on Windows");
+  else
+    error ("Invalid z-group specification");
+}
 
 /* Subroutines for creating a frame.  */
 
@@ -2013,7 +2288,12 @@ w32_init_class (HINSTANCE hinst)
 static HWND
 w32_createvscrollbar (struct frame *f, struct scroll_bar * bar)
 {
-  return CreateWindow ("SCROLLBAR", "", SBS_VERT | WS_CHILD | WS_VISIBLE,
+  return CreateWindow ("SCROLLBAR", "",
+                       /* Clip siblings so we don't draw over child
+                          frames.  Apparently this is not always
+                          sufficient so we also try to make bar windows
+                          bottommost.  */
+                       SBS_VERT | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS,
                        /* Position and size of scroll bar.  */
                        bar->left, bar->top, bar->width, bar->height,
                        FRAME_W32_WINDOW (f), NULL, hinst, NULL);
@@ -2022,7 +2302,12 @@ w32_createvscrollbar (struct frame *f, struct scroll_bar * bar)
 static HWND
 w32_createhscrollbar (struct frame *f, struct scroll_bar * bar)
 {
-  return CreateWindow ("SCROLLBAR", "", SBS_HORZ | WS_CHILD | WS_VISIBLE,
+  return CreateWindow ("SCROLLBAR", "",
+                       /* Clip siblings so we don't draw over child
+                          frames.  Apparently this is not always
+                          sufficient so we also try to make bar windows
+                          bottommost.  */
+                       SBS_HORZ | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS,
                        /* Position and size of scroll bar.  */
                        bar->left, bar->top, bar->width, bar->height,
                        FRAME_W32_WINDOW (f), NULL, hinst, NULL);
@@ -2031,20 +2316,52 @@ w32_createhscrollbar (struct frame *f, struct scroll_bar * bar)
 static void
 w32_createwindow (struct frame *f, int *coords)
 {
-  HWND hwnd;
+  HWND hwnd = NULL, parent_hwnd = NULL;
   RECT rect;
-  int top;
-  int left;
+  int top, left;
+  Lisp_Object border_width = Fcdr (Fassq (Qborder_width, f->param_alist));
+
+  if (FRAME_PARENT_FRAME (f) && FRAME_W32_P (FRAME_PARENT_FRAME (f)))
+    {
+      parent_hwnd = FRAME_W32_WINDOW (FRAME_PARENT_FRAME (f));
+      f->output_data.w32->dwStyle = WS_CHILD | WS_CLIPSIBLINGS;
+
+      if (FRAME_UNDECORATED (f))
+        {
+          /* If we want a thin border, specify it here.  */
+          if (NUMBERP (border_width) && (XINT (border_width) > 0))
+            f->output_data.w32->dwStyle |= WS_BORDER;
+        }
+      else
+        /* To decorate a child frame, list all needed elements.  */
+        f->output_data.w32->dwStyle |= (WS_THICKFRAME | WS_CAPTION
+                                        | WS_MAXIMIZEBOX | WS_MINIMIZEBOX
+                                        | WS_SYSMENU);
+    }
+  else if (FRAME_UNDECORATED (f))
+    {
+      /* All attempts to start with ~WS_OVERLAPPEDWINDOW or overlapped
+         with all other style elements negated failed here.  */
+      f->output_data.w32->dwStyle = WS_POPUP;
+
+      /* If we want a thin border, specify it here.  */
+      if (NUMBERP (border_width) && (XINT (border_width) > 0))
+        f->output_data.w32->dwStyle |= WS_BORDER;
+    }
+  else
+    f->output_data.w32->dwStyle = WS_OVERLAPPEDWINDOW;
+
+  /* Always clip children.  */
+  f->output_data.w32->dwStyle |= WS_CLIPCHILDREN;
 
   rect.left = rect.top = 0;
   rect.right = FRAME_PIXEL_WIDTH (f);
   rect.bottom = FRAME_PIXEL_HEIGHT (f);
 
   AdjustWindowRect (&rect, f->output_data.w32->dwStyle,
-                    FRAME_EXTERNAL_MENU_BAR (f));
+                    FRAME_EXTERNAL_MENU_BAR (f) && !parent_hwnd);
 
   /* Do first time app init */
-
   w32_init_class (hinst);
 
   if (f->size_hint_flags & USPosition || f->size_hint_flags & PPosition)
@@ -2059,18 +2376,16 @@ w32_createwindow (struct frame *f, int *coords)
     }
 
   FRAME_W32_WINDOW (f) = hwnd
-    = CreateWindow (EMACS_CLASS,
-                    f->namebuf,
-                    f->output_data.w32->dwStyle | WS_CLIPCHILDREN,
-                    left, top,
-                    rect.right - rect.left, rect.bottom - rect.top,
-                    NULL,
-                    NULL,
-                    hinst,
-                    NULL);
+    = CreateWindow (EMACS_CLASS, f->namebuf, f->output_data.w32->dwStyle,
+                    left, top, rect.right - rect.left, rect.bottom - rect.top,
+                    parent_hwnd, NULL, hinst, NULL);
 
   if (hwnd)
     {
+      if (FRAME_SKIP_TASKBAR (f))
+        SetWindowLong (hwnd, GWL_EXSTYLE,
+                       GetWindowLong (hwnd, GWL_EXSTYLE) | WS_EX_NOACTIVATE);
+
       SetWindowLong (hwnd, WND_FONTWIDTH_INDEX, FRAME_COLUMN_WIDTH (f));
       SetWindowLong (hwnd, WND_LINEHEIGHT_INDEX, FRAME_LINE_HEIGHT (f));
       SetWindowLong (hwnd, WND_BORDER_INDEX, FRAME_INTERNAL_BORDER_WIDTH (f));
@@ -2086,6 +2401,12 @@ w32_createwindow (struct frame *f, int *coords)
 
       /* Update frame positions. */
       GetWindowRect (hwnd, &rect);
+
+      if (parent_hwnd)
+        /* For a child window we have to get its coordinates wrt its
+           parent.  */
+        MapWindowPoints (HWND_DESKTOP, parent_hwnd, (LPPOINT) &rect, 2);
+
       f->left_pos = rect.left;
       f->top_pos = rect.top;
     }
@@ -4381,6 +4702,22 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
           }
       }
 
+      if (f && (msg == WM_LBUTTONDOWN || msg == WM_RBUTTONDOWN
+                || msg == WM_MBUTTONDOWN ||msg == WM_XBUTTONDOWN)
+          && !FRAME_NO_ACCEPT_FOCUS (f))
+        /* When clicking into a child frame or when clicking into a
+           parent frame with the child frame selected and
+           `no-accept-focus' is not set, select the clicked frame.  */
+        {
+          struct frame *p = FRAME_PARENT_FRAME (XFRAME (selected_frame));
+
+          if (FRAME_PARENT_FRAME (f) || f == p)
+            {
+              SetFocus (hwnd);
+              SetWindowPos (hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
+            }
+        }
+
       wmsg.dwModifiers = w32_get_modifiers ();
       my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
       signal_user_input ();
@@ -4486,6 +4823,10 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
       if (w32_pass_multimedia_buttons_to_system)
         goto dflt;
       /* Otherwise, pass to lisp, the same way we do with mousehwheel.  */
+
+      /* FIXME!!!  This is never reached so what's the purpose?  If the
+         non-zero return remark below is right we're doing it wrong all
+         the time.  */
     case WM_MOUSEHWHEEL:
       wmsg.dwModifiers = w32_get_modifiers ();
       my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
@@ -4712,19 +5053,34 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
         }
       return 0;
 
-#if 0
+    case WM_MOUSEACTIVATE:
+      /* WM_MOUSEACTIVATE is the only way on Windows to implement the
+         `no-accept-focus' frame parameter.  This means that one can't
+         use the mouse to scroll a window on a non-selected frame.  */
+
       /* Still not right - can't distinguish between clicks in the
          client area of the frame from clicks forwarded from the scroll
          bars - may have to hook WM_NCHITTEST to remember the mouse
-         position and then check if it is in the client area ourselves.  */
-    case WM_MOUSEACTIVATE:
+         position and then check if it is in the client area
+         ourselves.  */
+
       /* Discard the mouse click that activates a frame, allowing the
          user to click anywhere without changing point (or worse!).
          Don't eat mouse clicks on scrollbars though!!  */
-      if (LOWORD (lParam) == HTCLIENT )
-        return MA_ACTIVATEANDEAT;
+
+      if ((f = x_window_to_frame (dpyinfo, hwnd))
+          && FRAME_NO_ACCEPT_FOCUS (f)
+          /* Ignore child frames, they don't accept focus anyway.  */
+          && !FRAME_PARENT_FRAME (f))
+        {
+          Lisp_Object frame;
+
+          XSETFRAME (frame, f);
+          if (!EQ (selected_frame, frame))
+            /* Don't discard the message, GTK doesn't either.  */
+            return MA_NOACTIVATE; /* ANDEAT; */
+        }
       goto dflt;
-#endif
 
     case WM_MOUSELEAVE:
       /* No longer tracking mouse.  */
@@ -4903,6 +5259,10 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
           AttachThreadInput (GetCurrentThreadId (),
                              foreground_thread, FALSE);
 
+        /* SetFocus to give/remove focus to/from a child window.  */
+        if (msg == WM_EMACS_SETFOREGROUND)
+          SetFocus ((HWND) wParam);
+
         return retval;
       }
 
@@ -5134,7 +5494,8 @@ w32_window (struct frame *f, long window_prompting, bool minibuffer_only)
 
   unblock_input ();
 
-  if (!minibuffer_only && FRAME_EXTERNAL_MENU_BAR (f))
+  if (!minibuffer_only && FRAME_EXTERNAL_MENU_BAR (f)
+      && !FRAME_PARENT_FRAME (f))
     initialize_frame_menubar (f);
 
   if (FRAME_W32_WINDOW (f) == 0)
@@ -5322,7 +5683,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
   ptrdiff_t count = SPECPDL_INDEX ();
   Lisp_Object display;
   struct w32_display_info *dpyinfo = NULL;
-  Lisp_Object parent;
+  Lisp_Object parent, parent_frame;
   struct kboard *kb;
   int x_width = 0, x_height = 0;
 
@@ -5359,10 +5720,11 @@ This function is an internal primitive--use `make-frame' instead.  */)
     Vx_resource_name = name;
 
   /* See if parent window is specified.  */
-  parent = x_get_arg (dpyinfo, parameters, Qparent_id, NULL, NULL, RES_TYPE_NUMBER);
+  parent = x_get_arg (dpyinfo, parameters, Qparent_id, NULL, NULL,
+                      RES_TYPE_NUMBER);
   if (EQ (parent, Qunbound))
     parent = Qnil;
-  if (! NILP (parent))
+  else if (!NILP (parent))
     CHECK_NUMBER (parent);
 
   /* make_frame_without_minibuffer can run Lisp code and garbage collect.  */
@@ -5385,6 +5747,31 @@ This function is an internal primitive--use `make-frame' instead.  */)
 
   XSETFRAME (frame, f);
 
+  parent_frame = x_get_arg (dpyinfo, parameters, Qparent_frame, NULL, NULL,
+                            RES_TYPE_SYMBOL);
+  /* Apply `parent-frame' parameter only when no `parent-id' was
+     specified.  */
+  if (!NILP (parent_frame)
+      && (!NILP (parent)
+          || !FRAMEP (parent_frame)
+          || !FRAME_LIVE_P (XFRAME (parent_frame))
+          || !FRAME_W32_P (XFRAME (parent_frame))))
+    parent_frame = Qnil;
+
+  fset_parent_frame (f, parent_frame);
+  store_frame_param (f, Qparent_frame, parent_frame);
+
+  tem = x_get_arg (dpyinfo, parameters, Qundecorated, NULL, NULL,
+                   RES_TYPE_BOOLEAN);
+  FRAME_UNDECORATED (f) = !NILP (tem) && !EQ (tem, Qunbound);
+  store_frame_param (f, Qundecorated, FRAME_UNDECORATED (f) ? Qt : Qnil);
+
+  tem = x_get_arg (dpyinfo, parameters, Qskip_taskbar, NULL, NULL,
+                   RES_TYPE_BOOLEAN);
+  FRAME_SKIP_TASKBAR (f) = !NILP (tem) && !EQ (tem, Qunbound);
+  store_frame_param (f, Qskip_taskbar,
+                     (NILP (tem) || EQ (tem, Qunbound)) ? Qnil : Qt);
+
   /* By default, make scrollbars the system standard width and height. */
   FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = GetSystemMetrics (SM_CXVSCROLL);
   FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) = GetSystemMetrics (SM_CXHSCROLL);
@@ -5412,7 +5799,9 @@ This function is an internal primitive--use `make-frame' instead.  */)
   dpyinfo_refcount = dpyinfo->reference_count;
 #endif /* GLYPH_DEBUG */
 
-  /* Specify the parent under which to make this window.  */
+  /* Specify the parent under which to make this window - this seems to
+     have no effect on Windows because parent_desc is explicitly reset
+     below.  */
   if (!NILP (parent))
     {
       /* Cast to UINT_PTR shuts up compiler warnings about cast to
@@ -5496,23 +5885,44 @@ This function is an internal primitive--use `make-frame' instead.  */)
                        "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
   x_default_parameter (f, parameters, Qright_fringe, Qnil,
                        "rightFringe", "RightFringe", RES_TYPE_NUMBER);
-  /* Process alpha here (Bug#16619).  */
-  x_default_parameter (f, parameters, Qalpha, Qnil,
-                       "alpha", "Alpha", RES_TYPE_NUMBER);
+  x_default_parameter (f, parameters, Qno_focus_on_map, Qnil,
+                       NULL, NULL, RES_TYPE_BOOLEAN);
+  x_default_parameter (f, parameters, Qno_accept_focus, Qnil,
+                       NULL, NULL, RES_TYPE_BOOLEAN);
+  x_default_parameter (f, parameters, Qno_special_glyphs, Qnil,
+                       NULL, NULL, RES_TYPE_BOOLEAN);
+
+  /* Process alpha here (Bug#16619).  On XP this fails with child
+     frames.  For `no-focus-on-map' frames delay processing of alpha
+     until the frame becomes visible.  */
+  if (!FRAME_NO_FOCUS_ON_MAP (f))
+    x_default_parameter (f, parameters, Qalpha, Qnil,
+                         "alpha", "Alpha", RES_TYPE_NUMBER);
 
   /* Init faces first since we need the frame's column width/line
      height in various occasions.  */
   init_frame_faces (f);
 
-  /* The following call of change_frame_size is needed since otherwise
+  /* We have to call adjust_frame_size here since otherwise
      x_set_tool_bar_lines will already work with the character sizes
-     installed by init_frame_faces while the frame's pixel size is
-     still calculated from a character size of 1 and we subsequently
-     hit the (height >= 0) assertion in window_box_height.
+     installed by init_frame_faces while the frame's pixel size is still
+     calculated from a character size of 1 and we subsequently hit the
+     (height >= 0) assertion in window_box_height.
 
      The non-pixelwise code apparently worked around this because it
      had one frame line vs one toolbar line which left us with a zero
-     root window height which was obviously wrong as well ...  */
+     root window height which was obviously wrong as well ...
+
+     Also process `min-width' and `min-height' parameters right here
+     because `frame-windows-min-size' needs them.  */
+  tem = x_get_arg (dpyinfo, parameters, Qmin_width, NULL, NULL,
+                   RES_TYPE_NUMBER);
+  if (NUMBERP (tem))
+    store_frame_param (f, Qmin_width, tem);
+  tem = x_get_arg (dpyinfo, parameters, Qmin_height, NULL, NULL,
+                   RES_TYPE_NUMBER);
+  if (NUMBERP (tem))
+    store_frame_param (f, Qmin_height, tem);
   adjust_frame_size (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
                      FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 5, true,
                      Qx_create_frame_1);
@@ -5520,10 +5930,17 @@ This function is an internal primitive--use `make-frame' instead.  */)
   /* The X resources controlling the menu-bar and tool-bar are
      processed specially at startup, and reflected in the mode
      variables; ignore them here.  */
-  x_default_parameter (f, parameters, Qmenu_bar_lines,
-                       NILP (Vmenu_bar_mode)
-                       ? make_number (0) : make_number (1),
-                       NULL, NULL, RES_TYPE_NUMBER);
+  if (NILP (parent_frame))
+    {
+      x_default_parameter (f, parameters, Qmenu_bar_lines,
+                           NILP (Vmenu_bar_mode)
+                           ? make_number (0) : make_number (1),
+                           NULL, NULL, RES_TYPE_NUMBER);
+    }
+  else
+    /* No menu bar for child frames.  */
+    store_frame_param (f, Qmenu_bar_lines, make_number (0));
+
   x_default_parameter (f, parameters, Qtool_bar_lines,
                        NILP (Vtool_bar_mode)
                        ? make_number (0) : make_number (1),
@@ -5534,9 +5951,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
   x_default_parameter (f, parameters, Qtitle, Qnil,
                        "title", "Title", RES_TYPE_STRING);
 
-  f->output_data.w32->dwStyle = WS_OVERLAPPEDWINDOW;
   f->output_data.w32->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
-
   f->output_data.w32->text_cursor = w32_load_cursor (IDC_IBEAM);
   f->output_data.w32->nontext_cursor = w32_load_cursor (IDC_ARROW);
   f->output_data.w32->modeline_cursor = w32_load_cursor (IDC_ARROW);
@@ -5544,6 +5959,14 @@ This function is an internal primitive--use `make-frame' instead.  */)
   f->output_data.w32->hourglass_cursor = w32_load_cursor (IDC_WAIT);
   f->output_data.w32->horizontal_drag_cursor = w32_load_cursor (IDC_SIZEWE);
   f->output_data.w32->vertical_drag_cursor = w32_load_cursor (IDC_SIZENS);
+  f->output_data.w32->left_edge_cursor = w32_load_cursor (IDC_SIZEWE);
+  f->output_data.w32->top_left_corner_cursor = w32_load_cursor (IDC_SIZENWSE);
+  f->output_data.w32->top_edge_cursor = w32_load_cursor (IDC_SIZENS);
+  f->output_data.w32->top_right_corner_cursor = w32_load_cursor (IDC_SIZENESW);
+  f->output_data.w32->right_edge_cursor = w32_load_cursor (IDC_SIZEWE);
+  f->output_data.w32->bottom_right_corner_cursor = w32_load_cursor (IDC_SIZENWSE);
+  f->output_data.w32->bottom_edge_cursor = w32_load_cursor (IDC_SIZENS);
+  f->output_data.w32->bottom_left_corner_cursor = w32_load_cursor (IDC_SIZENESW);
 
   f->output_data.w32->current_cursor = f->output_data.w32->nontext_cursor;
 
@@ -5601,29 +6024,36 @@ This function is an internal primitive--use `make-frame' instead.  */)
      adjust_frame_size call.  */
   x_default_parameter (f, parameters, Qfullscreen, Qnil,
                        "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
+  x_default_parameter (f, parameters, Qz_group, Qnil,
+                       NULL, NULL, RES_TYPE_SYMBOL);
 
   /* Make the window appear on the frame and enable display, unless
      the caller says not to.  However, with explicit parent, Emacs
      cannot control visibility, so don't try.  */
-  if (! f->output_data.w32->explicit_parent)
+  if (!f->output_data.w32->explicit_parent)
     {
-      Lisp_Object visibility;
-
-      visibility = x_get_arg (dpyinfo, parameters, Qvisibility, 0, 0, RES_TYPE_SYMBOL);
-      if (EQ (visibility, Qunbound))
-        visibility = Qt;
+      Lisp_Object visibility
+        = x_get_arg (dpyinfo, parameters, Qvisibility, 0, 0, RES_TYPE_SYMBOL);
 
       if (EQ (visibility, Qicon))
         x_iconify_frame (f);
-      else if (! NILP (visibility))
-        x_make_frame_visible (f);
       else
         {
-          /* Must have been Qnil.  */
-          ;
+          if (EQ (visibility, Qunbound))
+            visibility = Qt;
+
+          if (!NILP (visibility))
+            x_make_frame_visible (f);
         }
+
+      store_frame_param (f, Qvisibility, visibility);
     }
 
+  /* For `no-focus-on-map' frames set alpha here.  */
+  if (FRAME_NO_FOCUS_ON_MAP (f))
+    x_default_parameter (f, parameters, Qalpha, Qnil,
+                         "alpha", "Alpha", RES_TYPE_NUMBER);
+
   /* Initialize `default-minibuffer-frame' in case this is the first
      frame on this terminal.  */
   if (FRAME_HAS_MINIBUF_P (f)
@@ -6572,8 +7002,6 @@ x_create_tip_frame (struct w32_display_info *dpyinfo, Lisp_Object parms)
   dpyinfo_refcount = dpyinfo->reference_count;
 #endif /* GLYPH_DEBUG */
   FRAME_KBOARD (f) = kb;
-  f->output_data.w32->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
-  f->output_data.w32->explicit_parent = false;
 
   /* Set the name; the functions to which we pass f expect the name to
      be set.  */
@@ -6631,6 +7059,8 @@ x_create_tip_frame (struct w32_display_info *dpyinfo, Lisp_Object parms)
                        "cursorColor", "Foreground", RES_TYPE_STRING);
   x_default_parameter (f, parms, Qborder_color, build_string ("black"),
                        "borderColor", "BorderColor", RES_TYPE_STRING);
+  x_default_parameter (f, parms, Qno_special_glyphs, Qt,
+                       NULL, NULL, RES_TYPE_BOOLEAN);
 
   /* Init faces before x_default_parameter is called for the
      scroll-bar-width parameter because otherwise we end up in
@@ -6639,6 +7069,7 @@ x_create_tip_frame (struct w32_display_info *dpyinfo, Lisp_Object parms)
 
   f->output_data.w32->dwStyle = WS_BORDER | WS_POPUP | WS_DISABLED;
   f->output_data.w32->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
+  f->output_data.w32->explicit_parent = false;
 
   x_figure_window_size (f, parms, true, &x_width, &x_height);
 
@@ -6740,7 +7171,7 @@ compute_tip_xy (struct frame *f,
                 int width, int height, int *root_x, int *root_y)
 {
   Lisp_Object left, top, right, bottom;
-  int min_x, min_y, max_x, max_y;
+  int min_x = 0, min_y, max_x = 0, max_y;
 
   /* User-specified position?  */
   left = Fcdr (Fassq (Qleft, parms));
@@ -7282,6 +7713,23 @@ file_dialog_callback (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
   return 0;
 }
 
+void
+w32_dialog_in_progress (Lisp_Object in_progress)
+{
+  Lisp_Object frames, frame;
+
+  /* Don't let frames in `above' z-group obscure popups.  */
+  FOR_EACH_FRAME (frames, frame)
+    {
+      struct frame *f = XFRAME (frame);
+
+      if (!NILP (in_progress) && FRAME_Z_GROUP_ABOVE (f))
+        x_set_z_group (f, Qabove_suspended, Qabove);
+      else if (NILP (in_progress) && FRAME_Z_GROUP_ABOVE_SUSPENDED (f))
+        x_set_z_group (f, Qabove, Qabove_suspended);
+    }
+}
+
 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
        doc: /* Read file name, prompting with PROMPT in directory DIR.
 Use a file selection dialog.  Select DEFAULT-FILENAME in the dialog's file
@@ -7341,7 +7789,7 @@ value of DIR as in previous invocations; this is standard Windows behavior.  */)
   OPENFILENAMEA * file_details_a = &new_file_details_a.details;
   int use_unicode = w32_unicode_filenames;
   wchar_t *prompt_w;
-  char *prompt_a;
+  char *prompt_a UNINIT;
   int len;
   char fname_ret[MAX_UTF8_PATH];
 #endif /* NTGUI_UNICODE */
@@ -7513,8 +7961,12 @@ value of DIR as in previous invocations; this is standard Windows behavior.  */)
 
     {
       int count = SPECPDL_INDEX ();
+
+      w32_dialog_in_progress (Qt);
+
       /* Prevent redisplay.  */
       specbind (Qinhibit_redisplay, Qt);
+      record_unwind_protect (w32_dialog_in_progress, Qnil);
       block_input ();
       if (use_unicode)
         {
@@ -8065,8 +8517,8 @@ w32_parse_and_hook_hot_key (Lisp_Object key, int hook)
 {
   /* Copied from Fdefine_key and store_in_keymap.  */
   register Lisp_Object c;
-  int vk_code;
-  int lisp_modifiers;
+  int vk_code = 0;
+  int lisp_modifiers = 0;
   int w32_modifiers;
   Lisp_Object res = Qnil;
   char* vkname;
@@ -8510,33 +8962,47 @@ menu bar or tool bar of FRAME.  */)
   if (EQ (type, Qouter_edges))
     {
       RECT rectangle;
+      BOOL success = false;
 
       block_input ();
       /* Outer frame rectangle, including outer borders and title bar. */
-      GetWindowRect (FRAME_W32_WINDOW (f), &rectangle);
+      success = GetWindowRect (FRAME_W32_WINDOW (f), &rectangle);
       unblock_input ();
 
-      return list4 (make_number (rectangle.left),
-                    make_number (rectangle.top),
-                    make_number (rectangle.right),
-                    make_number (rectangle.bottom));
+      if (success)
+        return list4 (make_number (rectangle.left),
+                      make_number (rectangle.top),
+                      make_number (rectangle.right),
+                      make_number (rectangle.bottom));
+      else
+        return Qnil;
     }
   else
     {
       RECT rectangle;
       POINT pt;
       int left, top, right, bottom;
+      BOOL success;
 
       block_input ();
       /* Inner frame rectangle, excluding borders and title bar.  */
-      GetClientRect (FRAME_W32_WINDOW (f), &rectangle);
+      success = GetClientRect (FRAME_W32_WINDOW (f), &rectangle);
       /* Get top-left corner of native rectangle in screen
          coordinates.  */
+      if (!success)
+        {
+          unblock_input ();
+          return Qnil;
+        }
+
       pt.x = 0;
       pt.y = 0;
-      ClientToScreen (FRAME_W32_WINDOW (f), &pt);
+      success = ClientToScreen (FRAME_W32_WINDOW (f), &pt);
       unblock_input ();
 
+      if (!success)
+        return Qnil;
+
       left = pt.x;
       top = pt.y;
       right = left + rectangle.right;
@@ -8559,6 +9025,136 @@ menu bar or tool bar of FRAME.  */)
     }
 }
 
+/**
+ * w32_frame_list_z_order:
+ *
+ * Recursively add list of all frames on the display specified via
+ * DPYINFO and whose window-system window's parent is specified by
+ * WINDOW to FRAMES and return FRAMES.
+ */
+static Lisp_Object
+w32_frame_list_z_order (struct w32_display_info *dpyinfo, HWND window)
+{
+  Lisp_Object frame, frames = Qnil;
+
+  while (window)
+    {
+      struct frame *f = x_window_to_frame (dpyinfo, window);
+
+      if (f)
+        {
+          XSETFRAME (frame, f);
+          frames = Fcons (frame, frames);
+        }
+
+      block_input ();
+      window = GetNextWindow (window, GW_HWNDNEXT);
+      unblock_input ();
+    }
+
+  return Fnreverse (frames);
+}
+
+DEFUN ("w32-frame-list-z-order", Fw32_frame_list_z_order,
+       Sw32_frame_list_z_order, 0, 1, 0,
+       doc: /* Return list of Emacs' frames, in Z (stacking) order.
+The optional argument DISPLAY specifies which display to ask about.
+DISPLAY should be either a frame or a display name (a string).  If
+omitted or nil, that stands for the selected frame's display.
+
+As a special case, if DISPLAY is non-nil and specifies a live frame,
+return the child frames of that frame in Z (stacking) order.
+
+Frames are listed from topmost (first) to bottommost (last).  */)
+  (Lisp_Object display)
+{
+  struct w32_display_info *dpyinfo = check_x_display_info (display);
+  HWND window;
+
+  block_input ();
+  if (FRAMEP (display) && FRAME_LIVE_P (XFRAME (display)))
+    window = GetWindow (FRAME_W32_WINDOW (XFRAME (display)), GW_CHILD);
+  else
+    window = GetTopWindow (NULL);
+  unblock_input ();
+
+  return w32_frame_list_z_order (dpyinfo, window);
+}
+
+/**
+ * w32_frame_restack:
+ *
+ * Restack frame F1 below frame F2, above if ABOVE_FLAG is non-nil.  In
+ * practice this is a two-step action: The first step removes F1's
+ * window-system window from the display.  The second step reinserts
+ * F1's window below (above if ABOVE_FLAG is true) that of F2.
+ */
+static void
+w32_frame_restack (struct frame *f1, struct frame *f2, bool above_flag)
+{
+  HWND hwnd1 = FRAME_W32_WINDOW (f1);
+  HWND hwnd2 = FRAME_W32_WINDOW (f2);
+
+  block_input ();
+  if (above_flag)
+    /* Put F1 above F2 in the z-order.  */
+    {
+      if (GetNextWindow (hwnd1, GW_HWNDNEXT) != hwnd2)
+        {
+          /* Make sure F1 is below F2 first because we must not
+             change the relative position of F2 wrt any other
+             window but F1.  */
+          if (GetNextWindow (hwnd2, GW_HWNDNEXT) != hwnd1)
+            SetWindowPos (hwnd1, hwnd2, 0, 0, 0, 0,
+                          SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE
+                          | SWP_FRAMECHANGED);
+          /* Now put F1 above F2.  */
+          SetWindowPos (hwnd2, hwnd1, 0, 0, 0, 0,
+                        SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE
+                        | SWP_FRAMECHANGED);
+        }
+    }
+  else if (GetNextWindow (hwnd2, GW_HWNDNEXT) != hwnd1)
+    /* Put F1 below F2 in the z-order.  */
+    SetWindowPos (hwnd1, hwnd2, 0, 0, 0, 0,
+                  SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE
+                  | SWP_FRAMECHANGED);
+  unblock_input ();
+}
+
+DEFUN ("w32-frame-restack", Fw32_frame_restack, Sw32_frame_restack, 2, 3, 0,
+       doc: /* Restack FRAME1 below FRAME2.
+This means that if both frames are visible and the display areas of
+these frames overlap, FRAME2 (partially) obscures FRAME1.  If optional
+third argument ABOVE is non-nil, restack FRAME1 above FRAME2.  This
+means that if both frames are visible and the display areas of these
+frames overlap, FRAME1 (partially) obscures FRAME2.
+
+This may be thought of as an atomic action performed in two steps: The
+first step removes FRAME1's window-system window from the display.  The
+second step reinserts FRAME1's window below (above if ABOVE is true)
+that of FRAME2.  Hence the position of FRAME2 in its display's Z
+\(stacking) order relative to all other frames excluding FRAME1 remains
+unaltered.
+
+Some window managers may refuse to restack windows.  */)
+     (Lisp_Object frame1, Lisp_Object frame2, Lisp_Object above)
+{
+  struct frame *f1 = decode_live_frame (frame1);
+  struct frame *f2 = decode_live_frame (frame2);
+
+  if (FRAME_W32_P (f1) && FRAME_W32_P (f2))
+    {
+      w32_frame_restack (f1, f2, !NILP (above));
+      return Qt;
+    }
+  else
+    {
+      error ("Cannot restack frames");
+      return Qnil;
+    }
+}
+
 DEFUN ("w32-mouse-absolute-pixel-position", Fw32_mouse_absolute_pixel_position,
        Sw32_mouse_absolute_pixel_position, 0, 0, 0,
        doc: /* Return absolute position of mouse cursor in pixels.
@@ -9753,6 +10349,14 @@ frame_parm_handler w32_frame_parm_handlers[] =
   0, /* x_set_sticky */
   0, /* x_set_tool_bar_position */
   0, /* x_set_inhibit_double_buffering */
+  x_set_undecorated,
+  x_set_parent_frame,
+  x_set_skip_taskbar,
+  x_set_no_focus_on_map,
+  x_set_no_accept_focus,
+  x_set_z_group,
+  0, /* x_set_override_redirect */
+  x_set_no_special_glyphs,
 };
 
 void
@@ -10132,6 +10736,8 @@ tip frame.  */);
   defsubr (&Sx_display_list);
   defsubr (&Sw32_frame_geometry);
   defsubr (&Sw32_frame_edges);
+  defsubr (&Sw32_frame_list_z_order);
+  defsubr (&Sw32_frame_restack);
   defsubr (&Sw32_mouse_absolute_pixel_position);
   defsubr (&Sw32_set_mouse_absolute_pixel_position);
   defsubr (&Sx_synchronize);
diff --git a/src/w32font.c b/src/w32font.c
index 37df1bc43c0..67d2f6d666d 100644
--- a/src/w32font.c
+++ b/src/w32font.c
@@ -436,7 +436,7 @@ w32font_text_extents (struct font *font, unsigned *code,
   int i;
   HFONT old_font = NULL;
   HDC dc = NULL;
-  struct frame * f;
+  struct frame * f UNINIT;
   int total_width = 0;
   WORD *wcode;
   SIZE size;
@@ -2553,11 +2553,22 @@ in the font selection dialog. */)
   SelectObject (hdc, oldobj);
   ReleaseDC (FRAME_W32_WINDOW (f), hdc);
 
-  if (!ChooseFont (&cf)
-      || logfont_to_fcname (&lf, cf.iPointSize, buf, 100) < 0)
-    return Qnil;
+  {
+    int count = SPECPDL_INDEX ();
+    Lisp_Object value = Qnil;
+
+    w32_dialog_in_progress (Qt);
+    specbind (Qinhibit_redisplay, Qt);
+    record_unwind_protect (w32_dialog_in_progress, Qnil);
+
+    if (ChooseFont (&cf)
+        && logfont_to_fcname (&lf, cf.iPointSize, buf, 100) >= 0)
+      value = DECODE_SYSTEM (build_string (buf));
 
-  return DECODE_SYSTEM (build_string (buf));
+    unbind_to (count, Qnil);
+
+    return value;
+  }
 }
 
 static const char *const w32font_booleans [] = {
diff --git a/src/w32menu.c b/src/w32menu.c
index 7dae9de2966..de5c4b46b54 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -267,7 +267,7 @@ set_frame_menubar (struct frame *f, bool first_time, bool deep_p)
   HMENU menubar_widget = f->output_data.w32->menubar_widget;
   Lisp_Object items;
   widget_value *wv, *first_wv, *prev_wv = 0;
-  int i, last_i;
+  int i, last_i = 0;
   int *submenu_start, *submenu_end;
   int *submenu_top_level_items, *submenu_n_panes;
 
diff --git a/src/w32term.c b/src/w32term.c
index 81666f5bc47..c37805cb6ca 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -782,9 +782,23 @@ x_after_update_window_line (struct window *w, struct glyph_row *desired_row)
       block_input ();
       {
         HDC hdc = get_frame_dc (f);
-        w32_clear_area (f, hdc, 0, y, width, height);
-        w32_clear_area (f, hdc, FRAME_PIXEL_WIDTH (f) - width,
-                        y, width, height);
+        struct face *face = FACE_FROM_ID_OR_NULL (f, INTERNAL_BORDER_FACE_ID);
+
+        if (face)
+          {
+            /* Fill border with internal border face.  */
+            unsigned long color = face->background;
+
+            w32_fill_area (f, hdc, color, 0, y, width, height);
+            w32_fill_area (f, hdc, color, FRAME_PIXEL_WIDTH (f) - width,
+                           y, width, height);
+          }
+        else
+          {
+            w32_clear_area (f, hdc, 0, y, width, height);
+            w32_clear_area (f, hdc, FRAME_PIXEL_WIDTH (f) - width,
+                            y, width, height);
+          }
         release_frame_dc (f, hdc);
       }
       unblock_input ();
@@ -940,6 +954,10 @@ x_set_cursor_gc (struct glyph_string *s)
   if (s->font == FRAME_FONT (s->f)
       && s->face->background == FRAME_BACKGROUND_PIXEL (s->f)
       && s->face->foreground == FRAME_FOREGROUND_PIXEL (s->f)
+      /* Sometimes we are not called for each change in the default
+         face's background color (e.g., bug#26851), so the additional
+         test in the next line gives us a chance to resync.  */
+      && s->f->output_data.w32->cursor_gc->foreground == s->face->background
       && !s->cmp)
     s->gc = s->f->output_data.w32->cursor_gc;
   else
@@ -2440,7 +2458,7 @@ x_draw_glyph_string (struct glyph_string *s)
                     thickness = font->underline_thickness;
                   else
                     thickness = 1;
-                  if (x_underline_at_descent_line)
+                  if (x_underline_at_descent_line || !font)
                     position = (s->height - thickness) - (s->ybase - s->y);
                   else
                     {
@@ -2453,9 +2471,9 @@ x_draw_glyph_string (struct glyph_string *s)
                          ROUND (x) = floor (x + 0.5)  */
 
                       if (x_use_underline_position_properties
-                          && font && font->underline_position >= 0)
+                          && font->underline_position >= 0)
                         position = font->underline_position;
-                      else if (font)
+                      else
                         position = (font->descent + 1) / 2;
                     }
                   position = max (position, underline_minimum_offset);
@@ -3095,7 +3113,8 @@ construct_mouse_wheel (struct input_event *result, W32Msg *msg, struct frame *f)
      coordinates, so cast to short to interpret them correctly.  */
   p.x = (short) LOWORD (msg->msg.lParam);
   p.y = (short) HIWORD (msg->msg.lParam);
-  ScreenToClient (msg->msg.hwnd, &p);
+  /* For the case that F's w32 window is not msg->msg.hwnd.  */
+  ScreenToClient (FRAME_W32_WINDOW (f), &p);
   XSETINT (result->x, p.x);
   XSETINT (result->y, p.y);
   XSETFRAME (result->frame_or_window, f);
@@ -3412,7 +3431,6 @@ w32_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
                     enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y,
                     Time *time)
 {
-  struct frame *f1;
   struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (*fp);
 
   block_input ();
@@ -3429,8 +3447,8 @@ w32_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
   else
     {
       POINT pt;
-
       Lisp_Object frame, tail;
+      struct frame *f1 = NULL;
 
       /* Clear the mouse-moved flag for every frame on this display.  */
       FOR_EACH_FRAME (tail, frame)
@@ -3446,8 +3464,31 @@ w32_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
         /* If mouse was grabbed on a frame, give coords for that
            frame even if the mouse is now outside it.  Otherwise
            check for window under mouse on one of our frames.  */
-        f1 = (x_mouse_grabbed (dpyinfo) ? dpyinfo->last_mouse_frame
-              : x_any_window_to_frame (dpyinfo, WindowFromPoint (pt)));
+        if (x_mouse_grabbed (dpyinfo))
+          f1 = dpyinfo->last_mouse_frame;
+        else
+          {
+            HWND wfp = WindowFromPoint (pt);
+
+            if (wfp)
+              {
+                f1 = x_any_window_to_frame (dpyinfo, wfp);
+                if (f1)
+                  {
+                    HWND cwfp = ChildWindowFromPoint (wfp, pt);
+
+                    if (cwfp)
+                      {
+                        struct frame *f2 = x_any_window_to_frame (dpyinfo, cwfp);
+
+                        /* If a child window was found, make sure that its
+                           frame is a child frame (Bug#26615, maybe).  */
+                        if (f2 && FRAME_PARENT_FRAME (f2))
+                          f1 = f2;
+                      }
+                  }
+              }
+          }
 
         /* If not, is it one of our scroll bars?  */
         if (! f1)
@@ -3893,11 +3934,15 @@ w32_set_vertical_scroll_bar (struct window *w,
                  for them on the frame, we have to clear "under" them.  */
               w32_clear_area (f, hdc, left, top, width, height);
               release_frame_dc (f, hdc);
+              x_clear_under_internal_border (f);
             }
           /* Make sure scroll bar is "visible" before moving, to ensure the
              area of the parent window now exposed will be refreshed.  */
           my_show_window (f, hwnd, SW_HIDE);
-          MoveWindow (hwnd, left, top, width, max (height, 1), TRUE);
+/**           MoveWindow (hwnd, left, top, width, max (height, 1), TRUE); **/
+          /* Try to not draw over child frames.  */
+          SetWindowPos (hwnd, HWND_BOTTOM, left, top, width, max (height, 1),
+                        SWP_FRAMECHANGED);
 
           si.cbSize = sizeof (si);
           si.fMask = SIF_RANGE;
@@ -3991,11 +4036,15 @@ w32_set_horizontal_scroll_bar (struct window *w,
                  for them on the frame, we have to clear "under" them.  */
               w32_clear_area (f, hdc, clear_left, top, clear_width, height);
               release_frame_dc (f, hdc);
+              x_clear_under_internal_border (f);
             }
           /* Make sure scroll bar is "visible" before moving, to ensure the
              area of the parent window now exposed will be refreshed.  */
           my_show_window (f, hwnd, SW_HIDE);
-          MoveWindow (hwnd, left, top, width, max (height, 1), TRUE);
+/**           MoveWindow (hwnd, left, top, width, max (height, 1), TRUE); **/
+          /* Try to not draw over child frames.  */
+          SetWindowPos (hwnd, HWND_BOTTOM, left, top, max (width, 1), height,
+                        SWP_FRAMECHANGED);
 
           /* +++ SetScrollInfo +++ */
           si.cbSize = sizeof (si);
@@ -4532,6 +4581,7 @@ x_scroll_bar_clear (struct frame *f)
         GetClientRect (window, &rect);
         select_palette (f, hdc);
         w32_clear_rect (f, hdc, &rect);
+        x_clear_under_internal_border (f);
         deselect_palette (f, hdc);
 
         ReleaseDC (window, hdc);
@@ -4649,7 +4699,7 @@ w32_read_socket (struct terminal *terminal,
                      in that case expose_frame will do nothing, and if
                      the various redisplay flags happen to be unset,
                      we are left with a blank frame.  */
-                  if (!FRAME_GARBAGED_P (f))
+                  if (!FRAME_GARBAGED_P (f) || FRAME_PARENT_FRAME (f))
                     {
                       HDC hdc = get_frame_dc (f);
 
@@ -4661,6 +4711,7 @@ w32_read_socket (struct terminal *terminal,
                                 msg.rect.top,
                                 msg.rect.right - msg.rect.left,
                                 msg.rect.bottom - msg.rect.top);
+                  x_clear_under_internal_border (f);
                 }
             }
           break;
@@ -4835,8 +4886,15 @@ w32_read_socket (struct terminal *terminal,
 
           if (f)
             {
-              /* Generate SELECT_WINDOW_EVENTs when needed.  */
-              if (!NILP (Vmouse_autoselect_window))
+              /* Maybe generate SELECT_WINDOW_EVENTs for
+                 `mouse-autoselect-window'.  */
+              if (!NILP (Vmouse_autoselect_window)
+                  && (f == XFRAME (selected_frame)
+                      /* Switch to f from another frame iff
+                         focus_follows_mouse is set and f accepts
+                         focus.  */
+                      || (!NILP (focus_follows_mouse)
+                          && !FRAME_NO_ACCEPT_FOCUS (f))))
                 {
                   static Lisp_Object last_mouse_window;
                   Lisp_Object window = window_from_coordinates
@@ -4848,20 +4906,16 @@ w32_read_socket (struct terminal *terminal,
                      only when it is active.  */
                   if (WINDOWP (window)
                       && !EQ (window, last_mouse_window)
-                      && !EQ (window, selected_window)
-                      /* For click-to-focus window managers
-                         create event iff we don't leave the
-                         selected frame.  */
-                      && (focus_follows_mouse
-                          || (EQ (XWINDOW (window)->frame,
-                                  XWINDOW (selected_window)->frame))))
+                      && !EQ (window, selected_window))
                     {
                       inev.kind = SELECT_WINDOW_EVENT;
                       inev.frame_or_window = window;
                     }
+
                   /* Remember the last window where we saw the mouse.  */
                   last_mouse_window = window;
                 }
+
               if (!note_mouse_movement (f, &msg.msg))
                 help_echo_string = previous_help_echo_string;
             }
@@ -4927,7 +4981,10 @@ w32_read_socket (struct terminal *terminal,
 
                 if (tool_bar_p
                     || (dpyinfo->w32_focus_frame
-                        && f != dpyinfo->w32_focus_frame))
+                        && f != dpyinfo->w32_focus_frame
+                        /* This does not help when the click happens in
+                           a grand-parent frame.  */
+                        && !frame_ancestor_p (f, dpyinfo->w32_focus_frame)))
                   inev.kind = NO_EVENT;
               }
 
@@ -4964,21 +5021,40 @@ w32_read_socket (struct terminal *terminal,
 
             if (f)
               {
-
                 if (!dpyinfo->w32_focus_frame
                     || f == dpyinfo->w32_focus_frame)
+                  /* Emit an Emacs wheel-up/down event.  */
                   {
-                    /* Emit an Emacs wheel-up/down event.  */
                     construct_mouse_wheel (&inev, &msg, f);
+
+                    /* Ignore any mouse motion that happened before this
+                       event; any subsequent mouse-movement Emacs events
+                       should reflect only motion after the ButtonPress.  */
+                    f->mouse_moved = false;
+                    f->last_tool_bar_item = -1;
+                    dpyinfo->last_mouse_frame = f;
                   }
-                /* Ignore any mouse motion that happened before this
-                   event; any subsequent mouse-movement Emacs events
-                   should reflect only motion after the
-                   ButtonPress.  */
-                f->mouse_moved = false;
-                f->last_tool_bar_item = -1;
+                else if (FRAME_NO_ACCEPT_FOCUS (f)
+                         && !x_mouse_grabbed (dpyinfo))
+                  {
+                    Lisp_Object frame1 = get_frame_param (f, Qmouse_wheel_frame);
+                    struct frame *f1 = FRAMEP (frame1) ? XFRAME (frame1) : NULL;
+
+                    if (f1 && FRAME_LIVE_P (f1) && FRAME_W32_P (f1))
+                      {
+                        construct_mouse_wheel (&inev, &msg, f1);
+                        f1->mouse_moved = false;
+                        f1->last_tool_bar_item = -1;
+                        dpyinfo->last_mouse_frame = f1;
+                      }
+                    else
+                      dpyinfo->last_mouse_frame = f;
+                  }
+                else
+                  dpyinfo->last_mouse_frame = f;
               }
-            dpyinfo->last_mouse_frame = f;
+            else
+              dpyinfo->last_mouse_frame = f;
           }
           break;
 
@@ -5010,6 +5086,51 @@ w32_read_socket (struct terminal *terminal,
           }
 
         case WM_WINDOWPOSCHANGED:
+          f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
+
+          if (f)
+            {
+              RECT rect;
+              int /* rows, columns, */ width, height, text_width, text_height;
+
+              if (GetClientRect (msg.msg.hwnd, &rect)
+                  /* GetClientRect evidently returns (0, 0, 0, 0) if
+                     called on a minimized frame.  Such "dimensions"
+                     aren't useful anyway.  */
+                  && !(rect.bottom == 0
+                       && rect.top == 0
+                       && rect.left == 0
+                       && rect.right == 0))
+                {
+                  height = rect.bottom - rect.top;
+                  width = rect.right - rect.left;
+                  text_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, width);
+                  text_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, height);
+                  /* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
+                  /* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
+
+                  /* TODO: Clip size to the screen dimensions.  */
+
+                  /* Even if the number of character rows and columns
+                     has not changed, the font size may have changed,
+                     so we need to check the pixel dimensions as well.  */
+
+                  if (width != FRAME_PIXEL_WIDTH (f)
+                      || height != FRAME_PIXEL_HEIGHT (f)
+                      || text_width != FRAME_TEXT_WIDTH (f)
+                      || text_height != FRAME_TEXT_HEIGHT (f))
+                    {
+                      change_frame_size (f, text_width, text_height, 0, 1, 0, 1);
+                      SET_FRAME_GARBAGED (f);
+                      cancel_mouse_face (f);
+                      f->win_gravity = NorthWestGravity;
+                    }
+                }
+            }
+
+          check_visibility = 1;
+          break;
+
         case WM_ACTIVATE:
         case WM_ACTIVATEAPP:
           f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
@@ -5031,14 +5152,19 @@ w32_read_socket (struct terminal *terminal,
                   w32fullscreen_hook (f);
                 }
             }
+
           check_visibility = 1;
           break;
 
         case WM_MOVE:
           f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
 
-          if (f && !FRAME_ICONIFIED_P (f))
-            x_real_positions (f, &f->left_pos, &f->top_pos);
+          if (f && FRAME_VISIBLE_P (f) && !FRAME_ICONIFIED_P(f))
+            {
+              x_real_positions (f, &f->left_pos, &f->top_pos);
+              inev.kind = MOVE_FRAME_EVENT;
+              XSETFRAME (inev.frame_or_window, f);
+            }
 
           check_visibility = 1;
           break;
@@ -5067,6 +5193,10 @@ w32_read_socket (struct terminal *terminal,
             }
 #endif
 
+          f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
+          if (f)
+            x_clear_under_internal_border (f);
+
           check_visibility = 1;
           break;
 
@@ -5965,7 +6095,9 @@ x_calc_absolute_position (struct frame *f)
      are computed correctly (Bug#21173).  */
   int display_left = 0;
   int display_top = 0;
-  if (flags & (XNegative | YNegative))
+  struct frame *p = FRAME_PARENT_FRAME (f);
+
+  if (!p && flags & (XNegative | YNegative))
     {
       Lisp_Object list;
 
@@ -5991,20 +6123,42 @@ x_calc_absolute_position (struct frame *f)
     }
 
   /* Treat negative positions as relative to the rightmost bottommost
-     position that fits on the screen.  */
+     position that fits on the screen or parent frame.
+
+     I see no need for subtracting 1 from the border widths - is there
+     any on the remaining platforms?  Here these subtractions did put
+     the last pixel line/column of a frame off-display when, for
+     example, a (set-frame-parameter nil 'left '(- 0)) specification was
+     used - martin 20017-05-05. */
   if (flags & XNegative)
-    f->left_pos = (x_display_pixel_width (FRAME_DISPLAY_INFO (f))
-                   + display_left
-                   - FRAME_PIXEL_WIDTH (f)
-                   + f->left_pos
-                   - (left_right_borders_width - 1));
+    {
+      if (p)
+        f->left_pos = (FRAME_PIXEL_WIDTH (p)
+                       - FRAME_PIXEL_WIDTH (f)
+                       + f->left_pos
+                       - left_right_borders_width);
+      else
+        f->left_pos = (x_display_pixel_width (FRAME_DISPLAY_INFO (f))
+                       + display_left
+                       - FRAME_PIXEL_WIDTH (f)
+                       + f->left_pos
+                       - left_right_borders_width);
+    }
 
   if (flags & YNegative)
-    f->top_pos = (x_display_pixel_height (FRAME_DISPLAY_INFO (f))
-                  + display_top
-                  - FRAME_PIXEL_HEIGHT (f)
-                  + f->top_pos
-                  - (top_bottom_borders_height - 1));
+    {
+      if (p)
+        f->top_pos = (FRAME_PIXEL_HEIGHT (p)
+                      - FRAME_PIXEL_HEIGHT (f)
+                      + f->top_pos
+                      - top_bottom_borders_height);
+      else
+        f->top_pos = (x_display_pixel_height (FRAME_DISPLAY_INFO (f))
+                      + display_top
+                      - FRAME_PIXEL_HEIGHT (f)
+                      + f->top_pos
+                      - top_bottom_borders_height);
+    }
 
   /* The left_pos and top_pos are now relative to the top and left
      screen edges, so the flags should correspond.  */
@@ -6042,11 +6196,16 @@ x_set_offset (struct frame *f, register int xoff, register int yoff,
   modified_left = f->left_pos;
   modified_top = f->top_pos;
 
-  my_set_window_pos (FRAME_W32_WINDOW (f),
-                     NULL,
-                     modified_left, modified_top,
-                     0, 0,
-                     SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
+  if (!FRAME_PARENT_FRAME (f))
+    my_set_window_pos (FRAME_W32_WINDOW (f), NULL,
+                       modified_left, modified_top,
+                       0, 0,
+                       SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
+  else
+    my_set_window_pos (FRAME_W32_WINDOW (f), HWND_TOP,
+                       modified_left, modified_top,
+                       0, 0,
+                       SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
   unblock_input ();
 }
 
@@ -6168,10 +6327,7 @@ x_set_window_size (struct frame *f, bool change_gravity,
 
   /* Get the height of the menu bar here.  It's used below to detect
      whether the menu bar is wrapped.  It's also used to specify the
-     third argument for AdjustWindowRect.  FRAME_EXTERNAL_MENU_BAR which
-     has been used before for that reason is unreliable because it only
-     specifies whether we _want_ a menu bar for this frame and not
-     whether this frame _has_ a menu bar.  See bug#22105.  */
+     third argument for AdjustWindowRect.  See bug#22105.  */
   info.cbSize = sizeof (info);
   info.rcBar.top = info.rcBar.bottom = 0;
   GetMenuBarInfo (FRAME_W32_WINDOW (f), 0xFFFFFFFD, 0, &info);
@@ -6250,11 +6406,18 @@ x_set_window_size (struct frame *f, bool change_gravity,
                 Fcons (make_number (rect.right - rect.left),
                        make_number (rect.bottom - rect.top))));
 
-      my_set_window_pos (FRAME_W32_WINDOW (f), NULL,
-                         0, 0,
-                         rect.right - rect.left,
-                         rect.bottom - rect.top,
-                         SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
+      if (!FRAME_PARENT_FRAME (f))
+        my_set_window_pos (FRAME_W32_WINDOW (f), NULL,
+                           0, 0,
+                           rect.right - rect.left,
+                           rect.bottom - rect.top,
+                           SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
+      else
+        my_set_window_pos (FRAME_W32_WINDOW (f), HWND_TOP,
+                           0, 0,
+                           rect.right - rect.left,
+                           rect.bottom - rect.top,
+                           SWP_NOMOVE | SWP_NOACTIVATE);
 
       change_frame_size (f,
                          ((pixelwidth == 0)
@@ -6311,10 +6474,14 @@ frame_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y)
 }
 
 
-/* focus shifting, raising and lowering.  */
+/* Focus shifting, raising and lowering.  */
+
+/* The NOACTIVATE argument has no effect on Windows.  According to the
+   Windows API: An application cannot activate an inactive window
+   without also bringing it to the top of the Z order.  */
 
 void
-x_focus_frame (struct frame *f)
+x_focus_frame (struct frame *f, bool noactivate)
 {
 #if 0
   struct w32_display_info *dpyinfo = &one_w32_display_info;
@@ -6443,18 +6610,21 @@ x_make_frame_visible (struct frame *f)
       if (! FRAME_ICONIFIED_P (f)
           && ! f->output_data.w32->asked_for_visible)
         {
-          RECT workarea_rect;
-          RECT window_rect;
-
-          /* Adjust vertical window position in order to avoid being
-             covered by a taskbar placed at the bottom of the desktop. */
-          SystemParametersInfo (SPI_GETWORKAREA, 0, &workarea_rect, 0);
-          GetWindowRect (FRAME_W32_WINDOW (f), &window_rect);
-          if (window_rect.bottom > workarea_rect.bottom
-              && window_rect.top > workarea_rect.top)
-            f->top_pos = max (window_rect.top
-                              - window_rect.bottom + workarea_rect.bottom,
-                              workarea_rect.top);
+          if (!FRAME_PARENT_FRAME (f))
+            {
+              RECT workarea_rect;
+              RECT window_rect;
+
+              /* Adjust vertical window position in order to avoid being
+                 covered by a taskbar placed at the bottom of the desktop. */
+              SystemParametersInfo (SPI_GETWORKAREA, 0, &workarea_rect, 0);
+              GetWindowRect (FRAME_W32_WINDOW (f), &window_rect);
+              if (window_rect.bottom > workarea_rect.bottom
+                  && window_rect.top > workarea_rect.top)
+                f->top_pos = max (window_rect.top
+                                  - window_rect.bottom + workarea_rect.bottom,
+                                  workarea_rect.top);
+            }
 
           x_set_offset (f, f->left_pos, f->top_pos, 0);
         }
@@ -6469,7 +6639,11 @@ x_make_frame_visible (struct frame *f)
          set for minimized windows that are still visible, so use that to
          determine the appropriate flag to pass ShowWindow.  */
       my_show_window (f, FRAME_W32_WINDOW (f),
-                      FRAME_ICONIFIED_P (f) ? SW_RESTORE : SW_SHOWNORMAL);
+                      FRAME_ICONIFIED_P (f)
+                      ? SW_RESTORE
+                      : FRAME_NO_FOCUS_ON_MAP (f)
+                      ? SW_SHOWNOACTIVATE
+                      : SW_SHOWNORMAL);
     }
 
   /* Synchronize to ensure Emacs knows the frame is visible
diff --git a/src/w32term.h b/src/w32term.h
index 990d3794b22..9956682c5cd 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -246,6 +246,7 @@ extern void x_set_internal_border_width (struct frame *f,
                                          Lisp_Object value,
                                          Lisp_Object oldval);
 extern void initialize_frame_menubar (struct frame *);
+extern void w32_dialog_in_progress (Lisp_Object in_progress);
 
 /* w32inevt.c */
 extern int w32_kbd_patch_key (KEY_EVENT_RECORD *event, int cpId);
@@ -344,6 +345,14 @@ struct w32_output
   Cursor hourglass_cursor;
   Cursor horizontal_drag_cursor;
   Cursor vertical_drag_cursor;
+  Cursor left_edge_cursor;
+  Cursor top_left_corner_cursor;
+  Cursor top_edge_cursor;
+  Cursor top_right_corner_cursor;
+  Cursor right_edge_cursor;
+  Cursor bottom_right_corner_cursor;
+  Cursor bottom_edge_cursor;
+  Cursor bottom_left_corner_cursor;
 
   /* Non-zero means hourglass cursor is currently displayed.  */
   unsigned hourglass_p : 1;
@@ -706,7 +715,7 @@ extern BOOL parse_button (int, int, int *, int *);
 
 extern void w32_sys_ring_bell (struct frame *f);
 extern void x_delete_display (struct w32_display_info *dpyinfo);
-
+extern void x_clear_under_internal_border (struct frame *f);
 extern void x_query_color (struct frame *, XColor *);
 
 #define FILE_NOTIFICATIONS_SIZE 16384
diff --git a/src/widget.c b/src/widget.c
index d7ec7028517..585039d58c6 100644
--- a/src/widget.c
+++ b/src/widget.c
@@ -108,7 +108,7 @@ emacsFrameTranslations [] = "\
 
 static EmacsFrameClassRec emacsFrameClassRec = {
     { /* core fields */
-    /* superclass               */      &widgetClassRec,
+    /* superclass               */      0, /* filled in by emacsFrameClass */
     /* class_name               */      (char *) "EmacsFrame",
     /* widget_size              */      sizeof (EmacsFrameRec),
     /* class_initialize         */      0,
@@ -146,7 +146,16 @@ static EmacsFrameClassRec emacsFrameClassRec = {
     }
 };
 
-WidgetClass emacsFrameClass = (WidgetClass) &emacsFrameClassRec;
+WidgetClass
+emacsFrameClass (void)
+{
+  /* Set the superclass here rather than relying on static
+     initialization, to work around an unexelf.c bug on x86 platforms
+     that use the GNU Gold linker (Bug#27248).  */
+  emacsFrameClassRec.core_class.superclass = &widgetClassRec;
+
+  return (WidgetClass) &emacsFrameClassRec;
+}
 
 static void
 get_default_char_pixel_size (EmacsFrame ew, int *pixel_width, int *pixel_height)
diff --git a/src/widget.h b/src/widget.h
index 2c5fb61df2f..97dd6ab61de 100644
--- a/src/widget.h
+++ b/src/widget.h
@@ -90,7 +90,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 typedef struct _EmacsFrameRec *EmacsFrame;
 typedef struct _EmacsFrameClassRec *EmacsFrameClass;
 
-extern WidgetClass emacsFrameClass;
+extern WidgetClass emacsFrameClass (void);
 
 extern struct _DisplayContext *display_context;
 
diff --git a/src/window.c b/src/window.c
index 95690443f8e..4816bd69909 100644
--- a/src/window.c
+++ b/src/window.c
@@ -492,7 +492,7 @@ select_window (Lisp_Object window, Lisp_Object norecord,
        record_buffer before returning here.  */
     goto record_and_return;
 
-  if (NILP (norecord))
+  if (NILP (norecord) || EQ (norecord, Qmark_for_redisplay))
     { /* Mark the window for redisplay since the selected-window has
          a different mode-line.  */
       wset_redisplay (XWINDOW (selected_window));
@@ -571,7 +571,8 @@ Return WINDOW.
 
 Optional second arg NORECORD non-nil means do not put this buffer at the
 front of the buffer list and do not make this window the most recently
-selected one.
+selected one.  Also, do not mark WINDOW for redisplay unless NORECORD
+equals the special symbol `mark-for-redisplay'.
 
 Run `buffer-list-update-hook' unless NORECORD is non-nil.  Note that
 applications and internal routines often select a window temporarily for
@@ -1207,13 +1208,13 @@ coordinates_in_window (register struct window *w, int x, int y)
                      - WINDOW_BOTTOM_DIVIDER_WIDTH (w))))
     return ON_HORIZONTAL_SCROLL_BAR;
   /* On the mode or header line?   */
-  else if ((WINDOW_WANTS_MODELINE_P (w)
+  else if ((window_wants_mode_line (w)
             && y >= (bottom_y
                      - CURRENT_MODE_LINE_HEIGHT (w)
                      - WINDOW_BOTTOM_DIVIDER_WIDTH (w))
             && y <= bottom_y - WINDOW_BOTTOM_DIVIDER_WIDTH (w)
             && (part = ON_MODE_LINE))
-           || (WINDOW_WANTS_HEADER_LINE_P (w)
+           || (window_wants_header_line (w)
                && y < top_y + CURRENT_HEADER_LINE_HEIGHT (w)
                && (part = ON_HEADER_LINE)))
     {
@@ -1850,7 +1851,7 @@ Return nil if window display is not up-to-date.  In that case, use
 
   if (EQ (line, Qheader_line))
     {
-      if (!WINDOW_WANTS_HEADER_LINE_P (w))
+      if (!window_wants_header_line (w))
         return Qnil;
       row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
       return row->enabled_p ? list4i (row->height, 0, 0, 0) : Qnil;
@@ -1897,6 +1898,129 @@ Return nil if window display is not up-to-date.  In that case, use
   return list4i (row->height + min (0, row->y) - crop, i, row->y, crop);
 }
 
+DEFUN ("window-lines-pixel-dimensions", Fwindow_lines_pixel_dimensions, Swindow_lines_pixel_dimensions, 0, 6, 0,
+       doc: /* Return pixel dimensions of WINDOW's lines.
+The return value is a list of the x- and y-coordinates of the lower
+right corner of the last character of each line.  Return nil if the
+current glyph matrix of WINDOW is not up-to-date.
+
+Optional argument WINDOW specifies the window whose lines' dimensions
+shall be returned.  Nil or omitted means to return the dimensions for
+the selected window.
+
+FIRST, if non-nil, specifies the index of the first line whose
+dimensions shall be returned.  If FIRST is nil and BODY is non-nil,
+start with the first text line of WINDOW.  Otherwise, start with the
+first line of WINDOW.
+
+LAST, if non-nil, specifies the last line whose dimensions shall be
+returned.  If LAST is nil and BODY is non-nil, the last line is the last
+line of the body (text area) of WINDOW.  Otherwise, last is the last
+line of WINDOW.
+
+INVERSE, if nil, means that the y-pixel value returned for a specific
+line specifies the distance in pixels from the left edge (body edge if
+BODY is non-nil) of WINDOW to the right edge of the last glyph of that
+line.  INVERSE non-nil means that the y-pixel value returned for a
+specific line specifies the distance in pixels from the right edge of
+the last glyph of that line to the right edge (body edge if BODY is
+non-nil) of WINDOW.
+
+LEFT non-nil means to return the x- and y-coordinates of the lower left
+corner of the leftmost character on each line.  This is the value that
+should be used for buffers that mostly display text from right to left.
+
+If LEFT is non-nil and INVERSE is nil, this means that the y-pixel value
+returned for a specific line specifies the distance in pixels from the
+left edge of the last (leftmost) glyph of that line to the right edge
+(body edge if BODY is non-nil) of WINDOW.  If LEFT and INVERSE are both
+non-nil, the y-pixel value returned for a specific line specifies the
+distance in pixels from the left edge (body edge if BODY is non-nil) of
+WINDOW to the left edge of the last (leftmost) glyph of that line.
+
+Normally, the value of this function is not available while Emacs is
+busy, for example, when processing a command.  It should be retrievable
+though when run from an idle timer with a delay of zero seconds.  */)
+  (Lisp_Object window, Lisp_Object first, Lisp_Object last, Lisp_Object body, Lisp_Object inverse, Lisp_Object left)
+{
+  struct window *w = decode_live_window (window);
+  struct buffer *b;
+  struct glyph_row *row, *end_row;
+  int max_y = NILP (body) ? WINDOW_PIXEL_HEIGHT (w) : window_text_bottom_y (w);
+  Lisp_Object rows = Qnil;
+  int window_width = NILP (body) ? w->pixel_width : window_body_width (w, true);
+  int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
+  int subtract = NILP (body) ? 0 : header_line_height;
+  bool invert = !NILP (inverse);
+  bool left_flag = !NILP (left);
+
+  if (noninteractive || w->pseudo_window_p)
+    return Qnil;
+
+  CHECK_BUFFER (w->contents);
+  b = XBUFFER (w->contents);
+
+  /* Fail if current matrix is not up-to-date.  */
+  if (!w->window_end_valid
+      || windows_or_buffers_changed
+      || b->clip_changed
+      || b->prevent_redisplay_optimizations_p
+      || window_outdated (w))
+    return Qnil;
+
+  if (NILP (first))
+    row = (NILP (body)
+           ? MATRIX_ROW (w->current_matrix, 0)
+           : MATRIX_FIRST_TEXT_ROW (w->current_matrix));
+  else if (NUMBERP (first))
+    {
+      CHECK_RANGED_INTEGER (first, 0, w->current_matrix->nrows);
+      row = MATRIX_ROW (w->current_matrix, XINT (first));
+    }
+  else
+    error ("Invalid specification of first line");
+
+  if (NILP (last))
+
+    end_row = (NILP (body)
+               ? MATRIX_ROW (w->current_matrix, w->current_matrix->nrows)
+               : MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w));
+  else if (NUMBERP (last))
+    {
+      CHECK_RANGED_INTEGER (last, 0, w->current_matrix->nrows);
+      end_row = MATRIX_ROW (w->current_matrix, XINT (last));
+    }
+  else
+    error ("Invalid specification of last line");
+
+  while (row <= end_row && row->enabled_p
+         && row->y + row->height < max_y)
+    {
+
+      if (left_flag)
+        {
+          struct glyph *glyph = row->glyphs[TEXT_AREA];
+
+          rows = Fcons (Fcons (make_number
+                               (invert
+                                ? glyph->pixel_width
+                                : window_width - glyph->pixel_width),
+                               make_number (row->y + row->height - subtract)),
+                        rows);
+        }
+      else
+        rows = Fcons (Fcons (make_number
+                             (invert
+                              ? window_width - row->pixel_width
+                              : row->pixel_width),
+                             make_number (row->y + row->height - subtract)),
+                      rows);
+      row++;
+    }
+
+  return Fnreverse (rows);
+}
+
 DEFUN ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p,
        0, 1, 0,
        doc: /* Return non-nil when WINDOW is dedicated to its buffer.
@@ -2002,16 +2126,24 @@ return value is a list of elements of the form (PARAMETER . VALUE).  */)
   return Fcopy_alist (decode_valid_window (window)->window_parameters);
 }
 
+Lisp_Object
+window_parameter (struct window *w, Lisp_Object parameter)
+{
+  Lisp_Object result = Fassq (parameter, w->window_parameters);
+
+  return CDR_SAFE (result);
+}
+
+
 DEFUN ("window-parameter", Fwindow_parameter, Swindow_parameter,
        2, 2, 0,
        doc:  /* Return WINDOW's value for PARAMETER.
 WINDOW can be any window and defaults to the selected one.  */)
   (Lisp_Object window, Lisp_Object parameter)
 {
-  Lisp_Object result;
+  struct window *w = decode_any_window (window);
 
-  result = Fassq (parameter, decode_any_window (window)->window_parameters);
-  return CDR_SAFE (result);
+  return window_parameter (w, parameter);
 }
 
 DEFUN ("set-window-parameter", Fset_window_parameter,
@@ -3314,6 +3446,9 @@ run_window_size_change_functions (Lisp_Object frame)
   Lisp_Object functions = Vwindow_size_change_functions;
 
   if (FRAME_WINDOW_CONFIGURATION_CHANGED (f)
+      /* Here we implicitly exclude the possibility that the height of
+         FRAME and its minibuffer window both change leaving the height
+         of FRAME's root window alone.  */
       || window_size_changed (r))
     {
       while (CONSP (functions))
@@ -3324,6 +3459,12 @@ run_window_size_change_functions (Lisp_Object frame)
         }
 
       window_set_before_size_change_sizes (r);
+
+      if (FRAME_HAS_MINIBUF_P (f) && !FRAME_MINIBUF_ONLY_P (f))
+        /* Record size of FRAME's minibuffer window too.  */
+        window_set_before_size_change_sizes
+          (XWINDOW (FRAME_MINIBUF_WINDOW (f)));
+
       FRAME_WINDOW_CONFIGURATION_CHANGED (f) = false;
     }
 }
@@ -3332,7 +3473,7 @@ run_window_size_change_functions (Lisp_Object frame)
 /* 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 means that the current margins, fringes, and
-   scroll-bar settings of the window are not reset from the buffer's
+   scroll bar settings of the window are not reset from the buffer's
    local settings.  */
 
 void
@@ -4730,6 +4871,69 @@ mark_window_cursors_off (struct window *w)
 }
 
 
+/**
+ * window_wants_mode_line:
+ *
+ * Return 1 if window W wants a mode line and is high enough to
+ * accomodate it, 0 otherwise.
+ *
+ * W wants a mode line if it's a leaf window and neither a minibuffer
+ * nor a pseudo window.  Moreover, its 'window-mode-line-format'
+ * parameter must not be 'none' and either that parameter or W's
+ * buffer's 'mode-line-format' value must be non-nil.  Finally, W must
+ * be higher than its frame's canonical character height.
+ */
+bool
+window_wants_mode_line (struct window *w)
+{
+  Lisp_Object window_mode_line_format =
+    window_parameter (w, Qmode_line_format);
+
+  return ((WINDOW_LEAF_P (w)
+           && !MINI_WINDOW_P (w)
+           && !WINDOW_PSEUDO_P (w)
+           && !EQ (window_mode_line_format, Qnone)
+           && (!NILP (window_mode_line_format)
+               || !NILP (BVAR (XBUFFER (WINDOW_BUFFER (w)), mode_line_format)))
+           && WINDOW_PIXEL_HEIGHT (w) > WINDOW_FRAME_LINE_HEIGHT (w))
+          ? 1
+          : 0);
+}
+
+
+/**
+ * window_wants_header_line:
+ *
+ * Return 1 if window W wants a header line and is high enough to
+ * accomodate it, 0 otherwise.
+ *
+ * W wants a header line if it's a leaf window and neither a minibuffer
+ * nor a pseudo window.  Moreover, its 'window-mode-line-format'
+ * parameter must not be 'none' and either that parameter or W's
+ * buffer's 'mode-line-format' value must be non-nil.  Finally, W must
+ * be higher than its frame's canonical character height and be able to
+ * accomodate a mode line too if necessary (the mode line prevails).
+ */
+bool
+window_wants_header_line (struct window *w)
+{
+  Lisp_Object window_header_line_format =
+    window_parameter (w, Qheader_line_format);
+
+  return ((WINDOW_LEAF_P (w)
+           && !MINI_WINDOW_P (w)
+           && !WINDOW_PSEUDO_P (w)
+           && !EQ (window_header_line_format, Qnone)
+           && (!NILP (window_header_line_format)
+               || !NILP (BVAR (XBUFFER (WINDOW_BUFFER (w)), header_line_format)))
+           && (WINDOW_PIXEL_HEIGHT (w)
+               > (window_wants_mode_line (w)
+                  ? 2 * WINDOW_FRAME_LINE_HEIGHT (w)
+                  : WINDOW_FRAME_LINE_HEIGHT (w))))
+          ? 1
+          : 0);
+}
+
 /* Return number of lines of text (not counting mode lines) in W.  */
 
 int
@@ -4743,10 +4947,10 @@ window_internal_height (struct window *w)
           || WINDOWP (w->contents)
           || !NILP (w->next)
           || !NILP (w->prev)
-          || WINDOW_WANTS_MODELINE_P (w))
+          || window_wants_mode_line (w))
         --ht;
 
-      if (WINDOW_WANTS_HEADER_LINE_P (w))
+      if (window_wants_header_line (w))
         --ht;
     }
 
@@ -7035,16 +7239,18 @@ DEFUN ("set-window-scroll-bars", Fset_window_scroll_bars,
 WINDOW must be a live window and defaults to the selected one.
 
 Second parameter WIDTH specifies the pixel width for the vertical scroll
-bar.  If WIDTH is nil, use the scroll-bar width of WINDOW's frame.
+bar.  If WIDTH is nil, use the scroll bar width of WINDOW's frame.
 Third parameter VERTICAL-TYPE specifies the type of the vertical scroll
-bar: left, right, or nil.  If VERTICAL-TYPE is t, this means use the
-frame's scroll-bar type.
+bar: left, right, nil or t where nil means to not display a vertical
+scroll bar on WINDOW and t means to use WINDOW frame's vertical scroll
+bar type.
 
 Fourth parameter HEIGHT specifies the pixel height for the horizontal
-scroll bar.  If HEIGHT is nil, use the scroll-bar height of WINDOW's
+scroll bar.  If HEIGHT is nil, use the scroll bar height of WINDOW's
 frame.  Fifth parameter HORIZONTAL-TYPE specifies the type of the
-horizontal scroll bar: nil, bottom, or t.  If HORIZONTAL-TYPE is t, this
-means to use the frame's horizontal scroll-bar type.
+horizontal scroll bar: bottom, nil, or t where nil means to not display
+a horizontal scroll bar on WINDOW and t means to use WINDOW frame's
+horizontal scroll bar type.
 
 Return t if scroll bars were actually changed and nil otherwise.  */)
   (Lisp_Object window, Lisp_Object width, Lisp_Object vertical_type,
@@ -7341,6 +7547,9 @@ syms_of_window (void)
   DEFSYM (Qclone_of, "clone-of");
   DEFSYM (Qfloor, "floor");
   DEFSYM (Qceiling, "ceiling");
+  DEFSYM (Qmark_for_redisplay, "mark-for-redisplay");
+  DEFSYM (Qmode_line_format, "mode-line-format");
+  DEFSYM (Qheader_line_format, "header-line-format");
 
   staticpro (&Vwindow_list);
 
@@ -7457,9 +7666,14 @@ nil means splitting a window will create a new parent window only if the
     `window-height' or `window-width' entry in the alist used by
     `display-buffer'.  Otherwise, this value is handled like nil.
 
+`temp-buffer-resize' means that splitting a window for displaying a
+    temporary buffer via `with-temp-buffer-window' makes a new parent
+    window only if `temp-buffer-resize-mode' is enabled.  Otherwise,
+    this value is handled like nil.
+
 `temp-buffer' means that splitting a window for displaying a temporary
-    buffer always makes a new parent window.  Otherwise, this value is
-    handled like nil.
+    buffer via `with-temp-buffer-window' always makes a new parent
+    window.  Otherwise, this value is handled like nil.
 
 `display-buffer' means that splitting a window for displaying a buffer
     always makes a new parent window.  Since temporary buffers are
@@ -7472,7 +7686,8 @@ t means that splitting a window always creates a new parent window.  If
     tree and every window but the frame's root window has exactly one
     sibling.
 
-Other values are reserved for future use.  */);
+The default value is `window-size'.  Other values are reserved for
+future use.  */);
   Vwindow_combination_limit = Qwindow_size;
 
   DEFVAR_LISP ("window-persistent-parameters", Vwindow_persistent_parameters,
@@ -7584,6 +7799,7 @@ displayed after a scrolling operation to be somewhat inaccurate.  */);
   defsubr (&Sset_window_point);
   defsubr (&Sset_window_start);
   defsubr (&Swindow_dedicated_p);
+  defsubr (&Swindow_lines_pixel_dimensions);
   defsubr (&Sset_window_dedicated_p);
   defsubr (&Swindow_display_table);
   defsubr (&Sset_window_display_table);
diff --git a/src/window.h b/src/window.h
index acb8a5cabfa..e9040f816df 100644
--- a/src/window.h
+++ b/src/window.h
@@ -328,8 +328,9 @@ struct window
     /* True if this window is a minibuffer window.  */
     bool_bf mini : 1;
 
-    /* Meaningful only if contents is a window, true if this
-       internal window is used in horizontal combination.  */
+    /* Meaningful for internal windows only: true if this window is a
+       horizontal combination, false if it is a vertical
+       combination.  */
     bool_bf horizontal : 1;
 
     /* True means must regenerate mode line of this window.  */
@@ -481,15 +482,14 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 /* True if W is a minibuffer window.  */
 #define MINI_WINDOW_P(W) ((W)->mini)
 
-/* 1 if W is a non-only minibuffer window.  */
-/* The first check is redundant and the second overly complicated. */
-#define MINI_NON_ONLY_WINDOW_P(W)                               \
-  (MINI_WINDOW_P (W)                                            \
-   && (EQ (W->prev, FRAME_ROOT_WINDOW (WINDOW_XFRAME (W)))))
+/* True if W is a minibuffer window on a frame that contains at least
+   one other window.  */
+#define MINI_NON_ONLY_WINDOW_P(W)        \
+  (MINI_WINDOW_P (W) && !NILP ((W)->prev))
 
-/* 1 if W is a minibuffer-only window.  */
-#define MINI_ONLY_WINDOW_P(W)                   \
-  (MINI_WINDOW_P (W) && NILP (W->prev))
+/* True if W is a minibuffer window that is alone on its frame.  */
+#define MINI_ONLY_WINDOW_P(W)            \
+  (MINI_WINDOW_P (W) && NILP ((W)->prev))
 
 /* General window layout:
 
@@ -518,29 +518,34 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 
 /* A handy macro.  */
 
-/* Non-nil if W is leaf (carry the buffer).  */
-
+/* Non-nil if window W is leaf window (has a buffer).  */
 #define WINDOW_LEAF_P(W) \
   (BUFFERP ((W)->contents))
 
-/* Non-nil if W is internal.  */
+/* Non-nil if window W is internal (is a parent window).  */
 #define WINDOW_INTERNAL_P(W) \
   (WINDOWP ((W)->contents))
 
-/* True if W is a member of horizontal combination.  */
+/* True if window W is a horizontal combination of windows.  */
 #define WINDOW_HORIZONTAL_COMBINATION_P(W) \
   (WINDOW_INTERNAL_P (W) && (W)->horizontal)
 
-/* True if W is a member of vertical combination.  */
+/* True if window W is a vertical combination of windows.  */
 #define WINDOW_VERTICAL_COMBINATION_P(W) \
   (WINDOW_INTERNAL_P (W) && !(W)->horizontal)
 
-/* WINDOW's XFRAME.  */
+/* Window W's XFRAME.  */
 #define WINDOW_XFRAME(W) (XFRAME (WINDOW_FRAME ((W))))
 
-/* Whether WINDOW is a pseudo window.  */
+/* Whether window W is a pseudo window.  */
 #define WINDOW_PSEUDO_P(W) ((W)->pseudo_window_p)
 
+/* Window W's buffer.  */
+#define WINDOW_BUFFER(W)                        \
+  (WINDOW_LEAF_P(W)                             \
+   ? (W)->contents                              \
+   : Qnil)                                      \
+
 /* Return the canonical column width of the frame of window W.  */
 #define WINDOW_FRAME_COLUMN_WIDTH(W) \
   (FRAME_COLUMN_WIDTH (WINDOW_XFRAME ((W))))
@@ -549,24 +554,24 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 #define WINDOW_FRAME_LINE_HEIGHT(W) \
   (FRAME_LINE_HEIGHT (WINDOW_XFRAME ((W))))
 
-/* Return the pixel width of window W.
-   This includes scroll bars and fringes.  */
+/* Return the pixel width of window W.  This includes dividers, scroll
+   bars, fringes and margins, if any.  */
 #define WINDOW_PIXEL_WIDTH(W) (W)->pixel_width
 
-/* Return the pixel height of window W.
-   This includes header and mode lines, if any.  */
+/* Return the pixel height of window W.  This includes dividers, scroll
+   bars, header and mode lines, if any.  */
 #define WINDOW_PIXEL_HEIGHT(W) (W)->pixel_height
 
-/* Return the width of window W in canonical column units.
-   This includes scroll bars and fringes.
-   This value is adjusted such that the sum of the widths of all child
+/* Return the width of window W in canonical column units.  This
+   includes dividers, scroll bars, fringes and margins, if any.  The
+   value is adjusted such that the sum of the widths of all child
    windows equals the width of their parent window.  */
 #define WINDOW_TOTAL_COLS(W) (W)->total_cols
 
-/* Return the height of window W in canonical line units.
-   This includes header and mode lines, if any.
-   This value is adjusted such that the sum of the heights of all child
-   windows equals the height of their parent window.  */
+/* Return the height of window W in canonical line units.  This includes
+   dividers, scroll bars, header and mode lines, if any.  The value is
+   adjusted such that the sum of the heights of all child windows equals
+   the height of their parent window.  */
 #define WINDOW_TOTAL_LINES(W) (W)->total_lines
 
 /* The smallest acceptable dimensions for a window.  Anything smaller
@@ -581,31 +586,63 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 #define MIN_SAFE_WINDOW_PIXEL_HEIGHT(W) \
   (WINDOW_FRAME_LINE_HEIGHT (W))
 
+/* True if window W has no other windows to its left on its frame.  */
+#define WINDOW_LEFTMOST_P(W)                    \
+  (WINDOW_LEFT_PIXEL_EDGE (W) == 0)
+
+/* True if window W has no other windows above it on its frame.  */
+#define WINDOW_TOPMOST_P(W)                     \
+  (WINDOW_TOP_PIXEL_EDGE (W) == 0)
+
+/* True if window W has no other windows to its right on its frame.  */
+#define WINDOW_RIGHTMOST_P(W)                                   \
+  (WINDOW_RIGHT_PIXEL_EDGE (W)                                  \
+   == (WINDOW_RIGHT_PIXEL_EDGE                                  \
+       (XWINDOW (FRAME_ROOT_WINDOW (WINDOW_XFRAME (W))))))      \
+
+/* True if window W has no other windows below it on its frame (the
+   minibuffer window is not counted in this respect unless W itself is a
+   minibuffer window).  */
+#define WINDOW_BOTTOMMOST_P(W)                                  \
+  (WINDOW_BOTTOM_PIXEL_EDGE (W)                                 \
+   == (WINDOW_BOTTOM_PIXEL_EDGE                                 \
+       (XWINDOW (FRAME_ROOT_WINDOW (WINDOW_XFRAME (W))))))      \
+
+/* True if window W takes up the full width of its frame.  */
+#define WINDOW_FULL_WIDTH_P(W)                                  \
+  (WINDOW_PIXEL_WIDTH (W)                                       \
+   == (WINDOW_PIXEL_WIDTH                                       \
+       (XWINDOW (FRAME_ROOT_WINDOW (WINDOW_XFRAME (W))))))      \
+
 /* Width of right divider of window W.  */
 #define WINDOW_RIGHT_DIVIDER_WIDTH(W)                           \
-  ((WINDOW_RIGHTMOST_P (W) || MINI_WINDOW_P (W))                \
-   ? 0                                                          \
-   : FRAME_RIGHT_DIVIDER_WIDTH (WINDOW_XFRAME (W)))
+  (WINDOW_RIGHTMOST_P (W)                                       \
+   ? 0 : FRAME_RIGHT_DIVIDER_WIDTH (WINDOW_XFRAME (W)))
+
+/* Width of bottom divider of window W.  */
+#define WINDOW_BOTTOM_DIVIDER_WIDTH(W)                                  \
+  (((WINDOW_BOTTOMMOST_P (W)                                            \
+     && NILP ((XWINDOW (FRAME_ROOT_WINDOW                               \
+                        (WINDOW_XFRAME (W))))->next))                   \
+    || EQ ((W)->prev, FRAME_ROOT_WINDOW (WINDOW_XFRAME (W)))            \
+    || (W)->pseudo_window_p)                                            \
+   ? 0 : FRAME_BOTTOM_DIVIDER_WIDTH (WINDOW_XFRAME (W)))
 
 /* Return the canonical frame column at which window W starts.
    This includes a left-hand scroll bar, if any.  */
-
 #define WINDOW_LEFT_EDGE_COL(W) (W)->left_col
 
 /* Return the canonical frame column before which window W ends.
    This includes a right-hand scroll bar, if any.  */
-
 #define WINDOW_RIGHT_EDGE_COL(W) \
   (WINDOW_LEFT_EDGE_COL (W) + WINDOW_TOTAL_COLS (W))
 
 /* Return the canonical frame line at which window W starts.
    This includes a header line, if any.  */
-
 #define WINDOW_TOP_EDGE_LINE(W) (W)->top_line
 
 /* Return the canonical frame line before which window W ends.
    This includes a mode line, if any.  */
-
 #define WINDOW_BOTTOM_EDGE_LINE(W) \
   (WINDOW_TOP_EDGE_LINE (W) + WINDOW_TOTAL_LINES (W))
 
@@ -629,20 +666,17 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 
 /* Return the frame x-position at which window W starts.
    This includes a left-hand scroll bar, if any.  */
-
 #define WINDOW_LEFT_EDGE_X(W) \
   (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \
    + WINDOW_LEFT_PIXEL_EDGE (W))
 
 /* Return the frame x- position before which window W ends.
    This includes a right-hand scroll bar, if any.  */
-
 #define WINDOW_RIGHT_EDGE_X(W) \
   (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \
    + WINDOW_RIGHT_PIXEL_EDGE (W))
 
 /* True if W is a menu bar window.  */
-
 #if defined (HAVE_X_WINDOWS) && ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
 #define WINDOW_MENU_BAR_P(W) \
   (WINDOWP (WINDOW_XFRAME (W)->menu_bar_window) \
@@ -661,72 +695,24 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 #define WINDOW_TOOL_BAR_P(W) false
 #endif
 
-/* Return the frame y-position at which window W starts.
-   This includes a header line, if any.
-
-   PXW: With a menu or tool bar this is not symmetric to the _X values
-   since it _does_ include the internal border width.  */
+/* Return the frame y-position at which window W starts.  */
 #define WINDOW_TOP_EDGE_Y(W) \
   (((WINDOW_MENU_BAR_P (W) || WINDOW_TOOL_BAR_P (W)) \
     ? 0 : FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W))) \
    + WINDOW_TOP_PIXEL_EDGE (W))
 
-/* Return the frame y-position before which window W ends.
-   This includes a mode line, if any.  */
+/* Return the frame y-position before which window W ends.  */
 #define WINDOW_BOTTOM_EDGE_Y(W)                            \
   (((WINDOW_MENU_BAR_P (W) || WINDOW_TOOL_BAR_P (W))       \
     ? 0 : FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W))) \
    + WINDOW_BOTTOM_PIXEL_EDGE (W))
 
-/* True if window W takes up the full width of its frame.  */
-#define WINDOW_FULL_WIDTH_P(W)                                  \
-  (WINDOW_PIXEL_WIDTH (W)                                       \
-   == (WINDOW_PIXEL_WIDTH                                       \
-       (XWINDOW (FRAME_ROOT_WINDOW (WINDOW_XFRAME (W))))))      \
-
-/* True if window W's has no other windows to its left in its frame.  */
-
-#define WINDOW_LEFTMOST_P(W) \
-  (WINDOW_LEFT_PIXEL_EDGE (W) == 0)
-
-/* True if window W's has no other windows above in its frame.  */
-#define WINDOW_TOPMOST_P(W) \
-  (WINDOW_TOP_PIXEL_EDGE (W) == 0)
-
-/* True if window W's has no other windows to its right in its frame.  */
-#define WINDOW_RIGHTMOST_P(W)                                   \
-  (WINDOW_RIGHT_PIXEL_EDGE (W)                                  \
-   == (WINDOW_RIGHT_PIXEL_EDGE                                  \
-       (XWINDOW (FRAME_ROOT_WINDOW (WINDOW_XFRAME (W))))))      \
-
-/* True if window W's has no other windows below it in its frame
-   (the minibuffer window is not counted in this respect).  */
-#define WINDOW_BOTTOMMOST_P(W)                                  \
-  (WINDOW_BOTTOM_PIXEL_EDGE (W)                                 \
-   == (WINDOW_BOTTOM_PIXEL_EDGE                                 \
-       (XWINDOW (FRAME_ROOT_WINDOW (WINDOW_XFRAME (W))))))      \
-
-/* Return the frame column at which the text (or left fringe) in
-   window W starts.  This is different from the `LEFT_EDGE' because it
-   does not include a left-hand scroll bar if any.  */
-#define WINDOW_BOX_LEFT_EDGE_COL(W) \
-  (WINDOW_LEFT_EDGE_COL (W) \
-   + WINDOW_LEFT_SCROLL_BAR_COLS (W))
-
-/* Return the pixel value where the text (or left fringe) in
-   window W starts.  This is different from the `LEFT_EDGE' because it
-   does not include a left-hand scroll bar if any.  */
+/* Return the pixel value where the text (or left fringe) in window W
+   starts.  */
 #define WINDOW_BOX_LEFT_PIXEL_EDGE(W)           \
   (WINDOW_LEFT_PIXEL_EDGE (W)                   \
    + WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (W))
 
-/* Return the window column before which the text in window W ends.
-   This is different from WINDOW_RIGHT_EDGE_COL because it does not
-   include a scroll bar or window-separating line on the right edge.  */
-#define WINDOW_BOX_RIGHT_EDGE_COL(W) \
-  (WINDOW_RIGHT_EDGE_COL (W) \
-   - WINDOW_RIGHT_SCROLL_BAR_COLS (W))
-
 /* Return the pixel value before which the text in window W ends.  This
    is different from the `RIGHT_EDGE' because it does not include a
    right-hand scroll bar or window-separating line on the right
@@ -736,16 +722,16 @@ wset_next_buffers (struct window *w, Lisp_Object val)
    - WINDOW_RIGHT_DIVIDER_WIDTH (W)             \
    - WINDOW_RIGHT_SCROLL_BAR_AREA_WIDTH (W))
 
-/* Return the frame position at which the text (or left fringe) in
-   window W starts.  This is different from the `LEFT_EDGE' because it
-   does not include a left-hand scroll bar if any.  */
+/* Return the frame x-position at which the text (or left fringe) in
+   window W starts.  This does not include a left-hand scroll bar if
+   any.  */
 #define WINDOW_BOX_LEFT_EDGE_X(W)                  \
   (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \
    + WINDOW_BOX_LEFT_PIXEL_EDGE (W))
 
-/* Return the window column before which the text in window W ends.
-   This is different from WINDOW_RIGHT_EDGE_COL because it does not
-   include a scroll bar or window-separating line on the right edge.  */
+/* Return the frame x-position before which the text in window W ends.
+   This does not include a scroll bar, divider or window-separating line
+   on the right edge.  */
 #define WINDOW_BOX_RIGHT_EDGE_X(W)                 \
   (FRAME_INTERNAL_BORDER_WIDTH (WINDOW_XFRAME (W)) \
    + WINDOW_BOX_RIGHT_PIXEL_EDGE (W))
@@ -899,16 +885,6 @@ wset_next_buffers (struct window *w, Lisp_Object val)
    ? WINDOW_BOX_RIGHT_EDGE_X (W)                \
    : WINDOW_LEFT_EDGE_X (W))
 
-/* Width of bottom divider of window W.  */
-#define WINDOW_BOTTOM_DIVIDER_WIDTH(W)                                  \
-  (((WINDOW_BOTTOMMOST_P (W)                                            \
-     && NILP ((XWINDOW (FRAME_ROOT_WINDOW                               \
-                        (WINDOW_XFRAME (W))))->next))                   \
-    || EQ ((W)->prev, FRAME_ROOT_WINDOW (WINDOW_XFRAME (W)))            \
-    || (W)->pseudo_window_p)                                            \
-   ? 0                                                                  \
-   : FRAME_BOTTOM_DIVIDER_WIDTH (WINDOW_XFRAME (W)))
-
 /* Height that a scroll bar in window W should have, if there is one.
    Measured in pixels.  If scroll bars are turned off, this is still
    nonzero.  */
@@ -942,22 +918,22 @@ wset_next_buffers (struct window *w, Lisp_Object val)
 /* Height in pixels of the mode line.
    May be zero if W doesn't have a mode line.  */
 #define WINDOW_MODE_LINE_HEIGHT(W)      \
-  (WINDOW_WANTS_MODELINE_P ((W))        \
+  (window_wants_mode_line ((W))         \
    ? CURRENT_MODE_LINE_HEIGHT (W)       \
    : 0)
 
 #define WINDOW_MODE_LINE_LINES(W)       \
-  WINDOW_WANTS_MODELINE_P (W)
+  window_wants_mode_line (W)
 
 /* Height in pixels of the header line.
    Zero if W doesn't have a header line.  */
 #define WINDOW_HEADER_LINE_HEIGHT(W)    \
-  (WINDOW_WANTS_HEADER_LINE_P (W)       \
+  (window_wants_header_line (W)         \
    ? CURRENT_HEADER_LINE_HEIGHT (W)     \
    : 0)
 
 #define WINDOW_HEADER_LINE_LINES(W)     \
-  WINDOW_WANTS_HEADER_LINE_P (W)
+  window_wants_header_line (W)
 
 /* Pixel height of window W without mode line, bottom scroll bar and
    bottom divider.  */
@@ -1114,10 +1090,13 @@ struct glyph *get_phys_cursor_glyph (struct window *w);
 extern Lisp_Object Vwindow_list;
 
 extern Lisp_Object window_list (void);
+extern Lisp_Object window_parameter (struct window *, Lisp_Object parameter);
 extern struct window *decode_live_window (Lisp_Object);
 extern struct window *decode_any_window (Lisp_Object);
 extern bool compare_window_configurations (Lisp_Object, Lisp_Object, bool);
 extern void mark_window_cursors_off (struct window *);
+extern bool window_wants_mode_line (struct window *);
+extern bool window_wants_header_line (struct window *);
 extern int window_internal_height (struct window *);
 extern int window_body_width (struct window *w, bool);
 enum margin_unit { MARGIN_IN_LINES, MARGIN_IN_PIXELS };
@@ -1133,7 +1112,6 @@ extern void init_window_once (void);
 extern void init_window (void);
 extern void syms_of_window (void);
 extern void keys_of_window (void);
-
 /* Move cursor to row/column position VPOS/HPOS, pixel coordinates
    Y/X. HPOS/VPOS are window-relative row and column numbers and X/Y
    are window-relative pixel positions.  This is always done during
diff --git a/src/xdisp.c b/src/xdisp.c
index af086d17eb8..8bc5d81f448 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -476,7 +476,7 @@ int windows_or_buffers_changed;
    used to track down the cause for this full-redisplay).
 
    Since the frame title uses the same %-constructs as the mode line
-   (except %c and %l), if this variable is non-zero, we also consider
+   (except %c, %C, and %l), if this variable is non-zero, we also consider
    redisplaying the title of each frame, see x_consider_frame_title.
 
    The `redisplay' bits are the same as those used for
@@ -832,7 +832,7 @@ static bool cursor_row_fully_visible_p (struct window *, bool, bool);
 static bool update_menu_bar (struct frame *, bool, bool);
 static bool try_window_reusing_current_matrix (struct window *);
 static int try_window_id (struct window *);
-static bool display_line (struct it *);
+static bool display_line (struct it *, int);
 static int display_mode_lines (struct window *);
 static int display_mode_line (struct window *, enum face_id, Lisp_Object);
 static int display_mode_element (struct it *, int, int, int, Lisp_Object,
@@ -921,7 +921,7 @@ window_text_bottom_y (struct window *w)
 
   height -= WINDOW_BOTTOM_DIVIDER_WIDTH (w);
 
-  if (WINDOW_WANTS_MODELINE_P (w))
+  if (window_wants_mode_line (w))
     height -= CURRENT_MODE_LINE_HEIGHT (w);
 
   height -= WINDOW_SCROLL_BAR_AREA_HEIGHT (w);
@@ -978,7 +978,7 @@ window_box_height (struct window *w)
      the appropriate glyph row has its `mode_line_p' flag set,
      and if it doesn't, uses estimate_mode_line_height instead.  */
 
-  if (WINDOW_WANTS_MODELINE_P (w))
+  if (window_wants_mode_line (w))
     {
       struct glyph_row *ml_row
         = (w->current_matrix && w->current_matrix->rows
@@ -990,7 +990,7 @@ window_box_height (struct window *w)
         height -= estimate_mode_line_height (f, CURRENT_MODE_LINE_FACE_ID (w));
     }
 
-  if (WINDOW_WANTS_HEADER_LINE_P (w))
+  if (window_wants_header_line (w))
     {
       struct glyph_row *hl_row
         = (w->current_matrix && w->current_matrix->rows
@@ -1102,7 +1102,7 @@ window_box (struct window *w, enum glyph_row_area area, int *box_x,
   if (box_y)
     {
       *box_y = WINDOW_TOP_EDGE_Y (w);
-      if (WINDOW_WANTS_HEADER_LINE_P (w))
+      if (window_wants_header_line (w))
         *box_y += CURRENT_HEADER_LINE_HEIGHT (w);
     }
 }
@@ -1322,15 +1322,29 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
     return visible_p;
 
   /* Compute exact mode line heights.  */
-  if (WINDOW_WANTS_MODELINE_P (w))
-    w->mode_line_height
-      = display_mode_line (w, CURRENT_MODE_LINE_FACE_ID (w),
-                           BVAR (current_buffer, mode_line_format));
+  if (window_wants_mode_line (w))
+    {
+      Lisp_Object window_mode_line_format
+        = window_parameter (w, Qmode_line_format);
+
+      w->mode_line_height
+        = display_mode_line (w, CURRENT_MODE_LINE_FACE_ID (w),
+                             NILP (window_mode_line_format)
+                             ? BVAR (current_buffer, mode_line_format)
+                             : window_mode_line_format);
+    }
 
-  if (WINDOW_WANTS_HEADER_LINE_P (w))
-    w->header_line_height
-      = display_mode_line (w, HEADER_LINE_FACE_ID,
-                           BVAR (current_buffer, header_line_format));
+  if (window_wants_header_line (w))
+    {
+      Lisp_Object window_header_line_format
+        = window_parameter (w, Qheader_line_format);
+
+      w->header_line_height
+        = display_mode_line (w, HEADER_LINE_FACE_ID,
+                             NILP (window_header_line_format)
+                             ? BVAR (current_buffer, header_line_format)
+                             : window_header_line_format);
+    }
 
   start_display (&it, w, top);
   move_it_to (&it, charpos, -1, it.last_visible_y - 1, -1,
@@ -2513,6 +2527,14 @@ adjust_window_ends (struct window *w, struct glyph_row *row, bool current)
     = MATRIX_ROW_VPOS (row, current ? w->current_matrix : w->desired_matrix);
 }
 
+static bool
+hscrolling_current_line_p (struct window *w)
+{
+  return (!w->suspend_auto_hscroll
+          && EQ (Fbuffer_local_value (Qauto_hscroll_mode, w->contents),
+                 Qcurrent_line));
+}
+
 /***********************************************************************
                         Lisp form evaluation
  ***********************************************************************/
@@ -2834,13 +2856,12 @@ init_iterator (struct it *it, struct window *w,
 
   /* Get dimensions of truncation and continuation glyphs.  These are
      displayed as fringe bitmaps under X, but we need them for such
-     frames when the fringes are turned off.  But leave the dimensions
-     zero for tooltip frames, as these glyphs look ugly there and also
-     sabotage calculations of tooltip dimensions in x-show-tip.  */
+     frames when the fringes are turned off.  The no_special_glyphs slot
+     of the iterator's frame, when set, suppresses their display - by
+     default for tooltip frames and when set via the 'no-special-glyphs'
+     frame parameter.  */
 #ifdef HAVE_WINDOW_SYSTEM
-  if (!(FRAME_WINDOW_P (it->f)
-        && FRAMEP (tip_frame)
-        && it->f == XFRAME (tip_frame)))
+  if (!(FRAME_WINDOW_P (it->f) && it->f->no_special_glyphs))
 #endif
     {
       if (it->line_wrap == TRUNCATE)
@@ -2882,8 +2903,22 @@ init_iterator (struct it *it, struct window *w,
     }
   else
     {
-      it->first_visible_x
-        = window_hscroll_limited (it->w, it->f) * FRAME_COLUMN_WIDTH (it->f);
+      /* When hscrolling only the current line, don't apply the
+         hscroll here, it will be applied by display_line when it gets
+         to laying out the line showing point.  However, if the
+         window's min_hscroll is positive, the user specified a lower
+         bound for automatic hscrolling, so they expect the
+         non-current lines to obey that hscroll amount.  */
+      if (hscrolling_current_line_p (w))
+        {
+          if (w->min_hscroll > 0)
+            it->first_visible_x = w->min_hscroll * FRAME_COLUMN_WIDTH (it->f);
+          else
+            it->first_visible_x = 0;
+        }
+      else
+        it->first_visible_x =
+          window_hscroll_limited (w, it->f) * FRAME_COLUMN_WIDTH (it->f);
       it->last_visible_x = (it->first_visible_x
                             + window_box_width (w, TEXT_AREA));
 
@@ -2898,7 +2933,7 @@ init_iterator (struct it *it, struct window *w,
             it->last_visible_x -= it->continuation_pixel_width;
         }
 
-      it->header_line_p = WINDOW_WANTS_HEADER_LINE_P (w);
+      it->header_line_p = window_wants_header_line (w);
       it->current_y = WINDOW_HEADER_LINE_HEIGHT (w) + w->vscroll;
     }
 
@@ -2997,7 +3032,7 @@ void
 start_display (struct it *it, struct window *w, struct text_pos pos)
 {
   struct glyph_row *row;
-  bool first_vpos = WINDOW_WANTS_HEADER_LINE_P (w);
+  bool first_vpos = window_wants_header_line (w);
 
   row = w->desired_matrix->rows + first_vpos;
   init_iterator (it, w, CHARPOS (pos), BYTEPOS (pos), row, DEFAULT_FACE_ID);
@@ -4318,7 +4353,8 @@ handle_invisible_prop (struct it *it)
                       bidi_move_to_visually_next (&it->bidi_it);
                     }
                   while (oldpos <= it->bidi_it.charpos
-                         && it->bidi_it.charpos < endpos);
+                         && it->bidi_it.charpos < endpos
+                         && it->bidi_it.charpos < it->bidi_it.string.schars);
 
                   IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
                   IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
@@ -7032,7 +7068,7 @@ get_next_display_element (struct it *it)
              translated too.
 
              Non-printable characters and raw-byte characters are also
-             translated to octal form.  */
+             translated to octal or hexadecimal form.  */
           if (((c < ' ' || c == 127) /* ASCII control chars.  */
                ? (it->area != TEXT_AREA
                   /* In mode line, treat \n, \t like other crl chars.  */
@@ -7139,9 +7175,12 @@ get_next_display_element (struct it *it)
                 int len, i;
 
                 if (CHAR_BYTE8_P (c))
-                  /* Display \200 instead of \17777600.  */
+                  /* Display \200 or \x80 instead of \17777600.  */
                   c = CHAR_TO_BYTE8 (c);
-                len = sprintf (str, "%03o", c + 0u);
+                const char *format_string = display_raw_bytes_as_hex
+                                            ? "x%02x"
+                                            : "%03o";
+                len = sprintf (str, format_string, c + 0u);
 
                 XSETINT (it->ctl_chars[0], escape_glyph);
                 for (i = 0; i < len; i++)
@@ -7729,9 +7768,8 @@ next_element_from_display_vector (struct it *it)
 
   /* KFS: This code used to check ip->dpvec[0] instead of the current element.
      That seemed totally bogus - so I changed it...  */
-  gc = it->dpvec[it->current.dpvec_index];
-
-  if (GLYPH_CODE_P (gc))
+  if (it->dpend - it->dpvec > 0 /* empty dpvec[] is invalid */
+      && (gc = it->dpvec[it->current.dpvec_index], GLYPH_CODE_P (gc)))
     {
       struct face *this_face, *prev_face, *next_face;
 
@@ -10529,9 +10567,12 @@ message_with_string (const char *m, Lisp_Object string, bool log)
 /* Dump an informative message to the minibuf.  If M is 0, clear out
    any existing message, and let the mini-buffer text show through.
 
-   The message must be safe ASCII and the format must not contain ` or
-   '.  If your message and format do not fit into this category,
-   convert your arguments to Lisp objects and use Fmessage instead.  */
+   The message must be safe ASCII (because when Emacs is
+   non-interactive the message is sent straight to stderr without
+   encoding first) and the format must not contain ` or ' (because
+   this function does not account for `text-quoting-style').  If your
+   message and format do not fit into this category, convert your
+   arguments to Lisp objects and use Fmessage instead.  */
 
 static void ATTRIBUTE_FORMAT_PRINTF (1, 0)
 vmessage (const char *m, va_list ap)
@@ -10589,6 +10630,7 @@ vmessage (const char *m, va_list ap)
     }
 }
 
+/* See vmessage for restrictions on the text of the message.  */
 void
 message (const char *m, ...)
 {
@@ -11379,6 +11421,11 @@ clear_garbaged_frames (void)
                 redraw_frame (f);
               else
                 clear_current_matrices (f);
+
+#if defined (HAVE_WINDOW_SYSTEM) && !defined (HAVE_NS)
+              x_clear_under_internal_border (f);
+#endif /* HAVE_WINDOW_SYSTEM && !HAVE_NS */
+
               fset_redisplay (f);
               f->garbaged = false;
               f->resized_p = false;
@@ -11441,7 +11488,14 @@ echo_area_display (bool update_frame_p)
              been called, so that mode lines above the echo area are
              garbaged.  This looks odd, so we prevent it here.  */
           if (!display_completed)
-            n = redisplay_mode_lines (FRAME_ROOT_WINDOW (f), false);
+            {
+              n = redisplay_mode_lines (FRAME_ROOT_WINDOW (f), false);
+
+#if defined (HAVE_WINDOW_SYSTEM) && !defined (HAVE_NS)
+              x_clear_under_internal_border (f);
+#endif /* HAVE_WINDOW_SYSTEM && !HAVE_NS */
+
+            }
 
           if (window_height_changed_p
               /* Don't do this if Emacs is shutting down.  Redisplay
@@ -11513,7 +11567,7 @@ window_buffer_changed (struct window *w)
   return (BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)) != w->last_had_star;
 }
 
-/* True if W has %c in its mode line and mode line should be updated.  */
+/* True if W has %c or %C in its mode line and mode line should be updated.  */
 
 static bool
 mode_line_update_needed (struct window *w)
@@ -11767,6 +11821,7 @@ x_consider_frame_title (Lisp_Object frame)
               && FRAME_KBOARD (tf) == FRAME_KBOARD (f)
               && !FRAME_MINIBUF_ONLY_P (tf)
               && !EQ (other_frame, tip_frame)
+              && !FRAME_PARENT_FRAME (tf)
               && (FRAME_VISIBLE_P (tf) || FRAME_ICONIFIED_P (tf)))
             break;
         }
@@ -11883,6 +11938,7 @@ prepare_menu_bars (void)
             continue;
 
           if (!EQ (frame, tooltip_frame)
+              && !FRAME_PARENT_FRAME (f)
               && (FRAME_ICONIFIED_P (f)
                   || FRAME_VISIBLE_P (f) == 1
                   /* Exclude TTY frames that are obscured because they
@@ -11929,6 +11985,10 @@ prepare_menu_bars (void)
             continue;
 
           run_window_size_change_functions (frame);
+
+          if (FRAME_PARENT_FRAME (f))
+            continue;
+
           menu_bar_hooks_run = update_menu_bar (f, false, menu_bar_hooks_run);
 #ifdef HAVE_WINDOW_SYSTEM
           update_tool_bar (f, false);
@@ -13008,6 +13068,7 @@ hscroll_window_tree (Lisp_Object window)
                 cursor_row = bottom_row - 1;
             }
           bool row_r2l_p = cursor_row->reversed_p;
+          bool hscl = hscrolling_current_line_p (w);
 
           text_area_width = window_box_width (w, TEXT_AREA);
 
@@ -13058,7 +13119,15 @@ hscroll_window_tree (Lisp_Object window)
                            && cursor_row->truncated_on_right_p
                            && w->cursor.x <= h_margin)
                           || (w->hscroll
-                              && (w->cursor.x >= text_area_width - h_margin))))))
+                              && (w->cursor.x >= text_area_width - h_margin))))
+                  /* This last condition is needed when moving
+                     vertically from an hscrolled line to a short line
+                     that doesn't need to be hscrolled.  If we omit
+                     this condition, the line from which we move will
+                     remain hscrolled.  */
+                  || (hscl
+                      && w->hscroll != w->min_hscroll
+                      && !cursor_row->truncated_on_left_p)))
             {
               struct it it;
               ptrdiff_t hscroll;
@@ -13078,6 +13147,9 @@ hscroll_window_tree (Lisp_Object window)
               /* Move iterator to pt starting at cursor_row->start in
                  a line with infinite width.  */
               init_to_row_start (&it, w, cursor_row);
+              if (hscl)
+                it.first_visible_x = window_hscroll_limited (w, it.f)
+                                     * FRAME_COLUMN_WIDTH (it.f);
               it.last_visible_x = INFINITY;
               move_it_in_display_line_to (&it, pt, -1, MOVE_TO_POS);
               /* If the line ends in an overlay string with a newline,
@@ -13089,6 +13161,9 @@ hscroll_window_tree (Lisp_Object window)
               if (it.method == GET_FROM_STRING && pt > 1)
                 {
                   init_to_row_start (&it, w, cursor_row);
+                  if (hscl)
+                    it.first_visible_x = (window_hscroll_limited (w, it.f)
+                                          * FRAME_COLUMN_WIDTH (it.f));
                   move_it_in_display_line_to (&it, pt - 1, -1, MOVE_TO_POS);
                 }
               current_buffer = saved_current_buffer;
@@ -13130,7 +13205,12 @@ hscroll_window_tree (Lisp_Object window)
               /* Don't prevent redisplay optimizations if hscroll
                  hasn't changed, as it will unnecessarily slow down
                  redisplay.  */
-              if (w->hscroll != hscroll)
+              if (w->hscroll != hscroll
+                  /* When hscrolling only the current line, we need to
+                     report hscroll even if its value is equal to the
+                     previous one, because the new line might need a
+                     different value.  */
+                  || (hscl && w->last_cursor_vpos != w->cursor.vpos))
                 {
                   struct buffer *b = XBUFFER (w->contents);
                   b->prevent_redisplay_optimizations_p = true;
@@ -13596,6 +13676,14 @@ redisplay_internal (void)
   enum { MAX_HSCROLL_RETRIES = 16 };
   int hscroll_retries = 0;
 
+  /* Limit the number of retries for when frame(s) become garbaged as
+     result of redisplaying them.  Some packages set various redisplay
+     hooks, such as window-scroll-functions, to run Lisp that always
+     calls APIs which cause the frame's garbaged flag to become set,
+     so we loop indefinitely.  */
+  enum {MAX_GARBAGED_FRAME_RETRIES = 2 };
+  int garbaged_frame_retries = 0;
+
   /* True means redisplay has to consider all windows on all
      frames.  False, only selected_window is considered.  */
   bool consider_all_windows_p;
@@ -13898,7 +13986,7 @@ redisplay_internal (void)
           it.vpos = this_line_vpos;
           it.current_y = this_line_y;
           it.glyph_row = MATRIX_ROW (w->desired_matrix, this_line_vpos);
-          display_line (&it);
+          display_line (&it, -1);
 
           /* If line contains point, is not continued,
              and ends at same distance from eob as before, we win.  */
@@ -14142,9 +14230,14 @@ redisplay_internal (void)
                      garbage.  We have to start over.  These cases
                      should be rare, so going all the way back to the
                      top of redisplay should be good enough.  */
-                  if (FRAME_GARBAGED_P (f))
+                  if (FRAME_GARBAGED_P (f)
+                      && garbaged_frame_retries++ < MAX_GARBAGED_FRAME_RETRIES)
                     goto retry;
 
+#if defined (HAVE_WINDOW_SYSTEM) && !defined (HAVE_NS)
+                  x_clear_under_internal_border (f);
+#endif /* HAVE_WINDOW_SYSTEM && !HAVE_NS */
+
                   /* Prevent various kinds of signals during display
                      update.  stdio is not robust about handling
                      signals, which can cause an apparent I/O error.  */
@@ -15718,7 +15811,7 @@ compute_window_start_on_continuation_line (struct window *w)
 
       /* Find the start of the continued line.  This should be fast
          because find_newline is fast (newline cache).  */
-      row = w->desired_matrix->rows + WINDOW_WANTS_HEADER_LINE_P (w);
+      row = w->desired_matrix->rows + window_wants_header_line (w);
       init_iterator (&it, w, CHARPOS (start_pos), BYTEPOS (start_pos),
                      row, DEFAULT_FACE_ID);
       reseat_at_previous_visible_line_start (&it);
@@ -15868,7 +15961,7 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp,
       this_scroll_margin = window_scroll_margin (w, MARGIN_IN_PIXELS);
 
       top_scroll_margin = this_scroll_margin;
-      if (WINDOW_WANTS_HEADER_LINE_P (w))
+      if (window_wants_header_line (w))
         top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
 
       /* Start with the row the cursor was displayed during the last
@@ -16404,7 +16497,8 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
     = (w->window_end_valid
        && !current_buffer->clip_changed
        && !current_buffer->prevent_redisplay_optimizations_p
-       && !window_outdated (w));
+       && !window_outdated (w)
+       && !hscrolling_current_line_p (w));
 
   /* Run the window-text-change-functions
      if it is possible that the text on the screen has changed
@@ -16650,7 +16744,7 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
              margin, even though this part handles windows that didn't
              scroll at all.  */
           int pixel_margin = margin * frame_line_height;
-          bool header_line = WINDOW_WANTS_HEADER_LINE_P (w);
+          bool header_line = window_wants_header_line (w);
 
           /* Note: We add an extra FRAME_LINE_HEIGHT, because the loop
              below, which finds the row to move point to, advances by
@@ -17217,15 +17311,15 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
        || (w->column_number_displayed != -1
            && (w->column_number_displayed != current_column ())))
       /* This means that the window has a mode line.  */
-      && (WINDOW_WANTS_MODELINE_P (w)
-          || WINDOW_WANTS_HEADER_LINE_P (w)))
+      && (window_wants_mode_line (w)
+          || window_wants_header_line (w)))
     {
 
       display_mode_lines (w);
 
       /* If mode line height has changed, arrange for a thorough
          immediate redisplay using the correct mode line height.  */
-      if (WINDOW_WANTS_MODELINE_P (w)
+      if (window_wants_mode_line (w)
           && CURRENT_MODE_LINE_HEIGHT (w) != DESIRED_MODE_LINE_HEIGHT (w))
         {
           f->fonts_changed = true;
@@ -17236,7 +17330,7 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
 
       /* If header line height has changed, arrange for a thorough
          immediate redisplay using the correct header line height.  */
-      if (WINDOW_WANTS_HEADER_LINE_P (w)
+      if (window_wants_header_line (w)
           && CURRENT_HEADER_LINE_HEIGHT (w) != DESIRED_HEADER_LINE_HEIGHT (w))
         {
           f->fonts_changed = true;
@@ -17381,6 +17475,7 @@ try_window (Lisp_Object window, struct text_pos pos, int flags)
   struct it it;
   struct glyph_row *last_text_row = NULL;
   struct frame *f = XFRAME (w->frame);
+  int cursor_vpos = w->cursor.vpos;
 
   /* Make POS the new window start.  */
   set_marker_both (w->start, Qnil, CHARPOS (pos), BYTEPOS (pos));
@@ -17396,7 +17491,7 @@ try_window (Lisp_Object window, struct text_pos pos, int flags)
   /* Display all lines of W.  */
   while (it.current_y < it.last_visible_y)
     {
-      if (display_line (&it))
+      if (display_line (&it, cursor_vpos))
         last_text_row = it.glyph_row - 1;
       if (f->fonts_changed && !(flags & TRY_WINDOW_IGNORE_FONTS_CHANGE))
         return 0;
@@ -17500,7 +17595,7 @@ try_window_reusing_current_matrix (struct window *w)
     return false;
 
   /* If top-line visibility has changed, give up.  */
-  if (WINDOW_WANTS_HEADER_LINE_P (w)
+  if (window_wants_header_line (w)
       != MATRIX_HEADER_LINE_ROW (w->current_matrix)->mode_line_p)
     return false;
 
@@ -17572,7 +17667,7 @@ try_window_reusing_current_matrix (struct window *w)
             break;
 
           it.glyph_row->reversed_p = false;
-          if (display_line (&it))
+          if (display_line (&it, -1))
             last_text_row = it.glyph_row - 1;
 
         }
@@ -17751,7 +17846,7 @@ try_window_reusing_current_matrix (struct window *w)
         w->cursor.vpos = -1;
       last_text_row = NULL;
       while (it.current_y < it.last_visible_y && !f->fonts_changed)
-        if (display_line (&it))
+        if (display_line (&it, w->cursor.vpos))
           last_text_row = it.glyph_row - 1;
 
       /* If point is in a reused row, adjust y and vpos of the cursor
@@ -18607,7 +18702,7 @@ try_window_id (struct window *w)
          && (first_unchanged_at_end_row == NULL
              || IT_CHARPOS (it) < stop_pos))
     {
-      if (display_line (&it))
+      if (display_line (&it, -1))
         last_text_row = it.glyph_row - 1;
     }
 
@@ -18735,7 +18830,7 @@ try_window_id (struct window *w)
             = MATRIX_ROW_VPOS (first_unchanged_at_end_row, w->current_matrix);
           int from = WINDOW_TOP_EDGE_LINE (w) + from_vpos;
           int end = (WINDOW_TOP_EDGE_LINE (w)
-                     + WINDOW_WANTS_HEADER_LINE_P (w)
+                     + window_wants_header_line (w)
                      + window_internal_height (w));
 
 #if defined (HAVE_GPM) || defined (MSDOS)
@@ -18873,7 +18968,7 @@ try_window_id (struct window *w)
              displayed invalid in the current matrix by setting their
              enabled_p flag to false.  */
           SET_MATRIX_ROW_ENABLED_P (w->current_matrix, it.vpos, false);
-          if (display_line (&it))
+          if (display_line (&it, w->cursor.vpos))
             last_text_row_at_end = it.glyph_row - 1;
         }
     }
@@ -18913,7 +19008,7 @@ try_window_id (struct window *w)
     {
       /* Displayed to end of window, but no line containing text was
          displayed.  Lines were deleted at the end of the window.  */
-      bool first_vpos = WINDOW_WANTS_HEADER_LINE_P (w);
+      bool first_vpos = window_wants_header_line (w);
       int vpos = w->window_end_vpos;
       struct glyph_row *current_row = current_matrix->rows + vpos;
       struct glyph_row *desired_row = desired_matrix->rows + vpos;
@@ -20591,10 +20686,11 @@ find_row_edges (struct it *it, struct glyph_row *row,
    IT->w from text at the current position of IT.  See dispextern.h
    for an overview of struct it.  Value is true if
    IT->glyph_row displays text, as opposed to a line displaying ZV
-   only.  */
+   only.  CURSOR_VPOS is the window-relative vertical position of
+   the glyph row displaying the cursor, or -1 if unknown.  */
 
 static bool
-display_line (struct it *it)
+display_line (struct it *it, int cursor_vpos)
 {
   struct glyph_row *row = it->glyph_row;
   Lisp_Object overlay_arrow_string;
@@ -20612,6 +20708,13 @@ display_line (struct it *it)
   ptrdiff_t min_pos = ZV + 1, max_pos = 0;
   ptrdiff_t min_bpos UNINIT, max_bpos UNINIT;
   bool pending_handle_line_prefix = false;
+  int header_line = window_wants_header_line (it->w);
+  bool hscroll_this_line = (cursor_vpos >= 0
+                            && it->vpos == cursor_vpos - header_line
+                            && hscrolling_current_line_p (it->w));
+  int first_visible_x = it->first_visible_x;
+  int last_visible_x = it->last_visible_x;
+  int x_incr = 0;
 
   /* We always start displaying at hpos zero even if hscrolled.  */
   eassert (it->hpos == 0 && it->current_x == 0);
@@ -20641,19 +20744,32 @@ display_line (struct it *it)
      recenter_overlay_lists but the first will be pretty cheap.  */
   recenter_overlay_lists (current_buffer, IT_CHARPOS (*it));
 
+  /* If we are going to display the cursor's line, account for the
+     hscroll of that line.  We subtract the window's min_hscroll,
+     because that was already accounted for in init_iterator.  */
+  if (hscroll_this_line)
+    x_incr =
+      (window_hscroll_limited (it->w, it->f) - it->w->min_hscroll)
+      * FRAME_COLUMN_WIDTH (it->f);
+
   /* Move over display elements that are not visible because we are
-     hscrolled.  This may stop at an x-position < IT->first_visible_x
+     hscrolled.  This may stop at an x-position < first_visible_x
      if the first glyph is partially visible or if we hit a line end.  */
-  if (it->current_x < it->first_visible_x)
+  if (it->current_x < it->first_visible_x + x_incr)
     {
       enum move_it_result move_result;
 
       this_line_min_pos = row->start.pos;
+      if (hscroll_this_line)
+        {
+          it->first_visible_x += x_incr;
+          it->last_visible_x  += x_incr;
+        }
       move_result = move_it_in_display_line_to (it, ZV, it->first_visible_x,
                                                 MOVE_TO_POS | MOVE_TO_X);
       /* If we are under a large hscroll, move_it_in_display_line_to
          could hit the end of the line without reaching
-         it->first_visible_x.  Pretend that we did reach it.  This is
+         first_visible_x.  Pretend that we did reach it.  This is
          especially important on a TTY, where we will call
          extend_face_to_end_of_line, which needs to know how many
          blank glyphs to produce.  */
@@ -21430,6 +21546,13 @@ display_line (struct it *it)
      row to be used.  */
   it->current_x = it->hpos = 0;
   it->current_y += row->height;
+  /* Restore the first and last visible X if we adjusted them for
+     current-line hscrolling.  */
+  if (hscroll_this_line)
+    {
+      it->first_visible_x = first_visible_x;
+      it->last_visible_x  = last_visible_x;
+    }
   SET_TEXT_POS (it->eol_pos, 0, 0);
   ++it->vpos;
   ++it->glyph_row;
@@ -22538,20 +22661,30 @@ display_mode_lines (struct window *w)
   line_number_displayed = false;
   w->column_number_displayed = -1;
 
-  if (WINDOW_WANTS_MODELINE_P (w))
+  if (window_wants_mode_line (w))
     {
+      Lisp_Object window_mode_line_format
+        = window_parameter (w, Qmode_line_format);
+
       struct window *sel_w = XWINDOW (old_selected_window);
 
       /* Select mode line face based on the real selected window.  */
       display_mode_line (w, CURRENT_MODE_LINE_FACE_ID_3 (sel_w, sel_w, w),
-                         BVAR (current_buffer, mode_line_format));
+                         NILP (window_mode_line_format)
+                         ? BVAR (current_buffer, mode_line_format)
+                         : window_mode_line_format);
       ++n;
     }
 
-  if (WINDOW_WANTS_HEADER_LINE_P (w))
+  if (window_wants_header_line (w))
     {
+      Lisp_Object window_header_line_format
+        = window_parameter (w, Qheader_line_format);
+
       display_mode_line (w, HEADER_LINE_FACE_ID,
-                         BVAR (current_buffer, header_line_format));
+                         NILP (window_header_line_format)
+                         ? BVAR (current_buffer, header_line_format)
+                         : window_header_line_format);
       ++n;
     }
 
@@ -23663,7 +23796,8 @@ decode_mode_spec (struct window *w, register int c, int field_width,
       break;
 
     case 'c':
-      /* %c and %l are ignored in `frame-title-format'.
+    case 'C':
+      /* %c, %C, and %l are ignored in `frame-title-format'.
          (In redisplay_internal, the frame title is drawn _before_ the
          windows are updated, so the stuff which depends on actual
          window contents (such as %l) may fail to render properly, or
@@ -23673,8 +23807,9 @@ decode_mode_spec (struct window *w, register int c, int field_width,
       else
         {
           ptrdiff_t col = current_column ();
+          int disp_col = (c == 'C') ? col + 1 : col;
           w->column_number_displayed = col;
-          pint2str (decode_mode_spec_buf, width, col);
+          pint2str (decode_mode_spec_buf, width, disp_col);
           return decode_mode_spec_buf;
         }
 
@@ -23722,7 +23857,7 @@ decode_mode_spec (struct window *w, register int c, int field_width,
         ptrdiff_t topline, nlines, height;
         ptrdiff_t junk;
 
-        /* %c and %l are ignored in `frame-title-format'.  */
+        /* %c, %C, and %l are ignored in `frame-title-format'.  */
         if (mode_line_target == MODE_LINE_TITLE)
           return "";
 
@@ -23841,6 +23976,27 @@ decode_mode_spec (struct window *w, register int c, int field_width,
         return " Narrow";
       break;
 
+      /* Display the "degree of travel" of the window through the buffer.  */
+    case 'o':
+      {
+        ptrdiff_t toppos = marker_position (w->start);
+        ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
+        ptrdiff_t begv = BUF_BEGV (b);
+        ptrdiff_t zv = BUF_ZV (b);
+
+        if (zv <= botpos)
+          return toppos <= begv ? "All" : "Bottom";
+        else if (toppos <= begv)
+          return "Top";
+        else
+          {
+          sprintf (decode_mode_spec_buf, "%2d%%",
+                   percent99 (toppos - begv, (toppos - begv) + (zv - botpos)));
+          return decode_mode_spec_buf;
+          }
+      }
+
+      /* Display percentage of buffer above the top of the screen.  */
     case 'p':
       {
         ptrdiff_t pos = marker_position (w->start);
@@ -23878,6 +24034,30 @@ decode_mode_spec (struct window *w, register int c, int field_width,
           }
       }
 
+      /* Display percentage offsets of top and bottom of the window,
+         using "All" (but not "Top" or "Bottom") where appropriate.  */
+    case 'q':
+      {
+        ptrdiff_t toppos = marker_position (w->start);
+        ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
+        ptrdiff_t begv = BUF_BEGV (b);
+        ptrdiff_t zv = BUF_ZV (b);
+        int top_perc, bot_perc;
+
+        if ((toppos <= begv) && (zv <= botpos))
+          return "All   ";
+
+        top_perc = toppos <= begv ? 0 : percent99 (toppos - begv, zv - begv);
+        bot_perc = zv <= botpos ? 100 : percent99 (botpos - begv, zv - begv);
+
+        if (top_perc == bot_perc)
+          sprintf (decode_mode_spec_buf, "%d%%", top_perc);
+        else
+          sprintf (decode_mode_spec_buf, "%d-%d%%", top_perc, bot_perc);
+
+        return decode_mode_spec_buf;
+      }
+
     case 's':
       /* status of process */
       obj = Fget_buffer_process (Fcurrent_buffer ());
@@ -25394,6 +25574,20 @@ set_glyph_string_background_width (struct glyph_string *s, int start, int last_x
 }
 
 
+/* Return glyph string that shares background with glyph string S and
+   whose `background_width' member has been set.  */
+
+static struct glyph_string *
+glyph_string_containing_background_width (struct glyph_string *s)
+{
+  if (s->cmp)
+    while (s->cmp_from)
+      s = s->prev;
+
+  return s;
+}
+
+
 /* Compute overhangs and x-positions for glyph string S and its
    predecessors, or successors.  X is the starting x-position for S.
    BACKWARD_P means process predecessors.  */
@@ -25407,7 +25601,8 @@ compute_overhangs_and_x (struct glyph_string *s, int x, bool backward_p)
         {
           if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
             FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
-          x -= s->width;
+          if (!s->cmp || s->cmp_to == s->cmp->glyph_len)
+            x -= s->width;
           s->x = x;
           s = s->prev;
         }
@@ -25419,7 +25614,8 @@ compute_overhangs_and_x (struct glyph_string *s, int x, bool backward_p)
           if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
             FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
           s->x = x;
-          x += s->width;
+          if (!s->cmp || s->cmp_to == s->cmp->glyph_len)
+            x += s->width;
           s = s->next;
         }
     }
@@ -25751,7 +25947,10 @@ draw_glyphs (struct window *w, int x, struct glyph_row *row,
   USE_SAFE_ALLOCA;
   BUILD_GLYPH_STRINGS (i, end, head, tail, hl, x, last_x);
   if (tail)
-    x_reached = tail->x + tail->background_width;
+    {
+      s = glyph_string_containing_background_width (tail);
+      x_reached = s->x + s->background_width;
+    }
   else
     x_reached = x;
 
@@ -25906,6 +26105,9 @@ draw_glyphs (struct window *w, int x, struct glyph_row *row,
           compute_overhangs_and_x (h, tail->x + tail->width, false);
           append_glyph_string_lists (&head, &tail, h, t);
         }
+      tail = glyph_string_containing_background_width (tail);
+      if (clip_tail)
+        clip_tail = glyph_string_containing_background_width (clip_tail);
       if (clip_head || clip_tail)
         for (s = head; s; s = s->next)
           {
@@ -28613,7 +28815,6 @@ display_and_set_cursor (struct window *w, bool on,
      be in the midst of changing its size, and x and y may be off the
      window.  */
   if (! FRAME_VISIBLE_P (f)
-      || FRAME_GARBAGED_P (f)
       || vpos >= w->current_matrix->nrows
       || hpos >= w->current_matrix->matrix_w)
     return;
@@ -28631,6 +28832,26 @@ display_and_set_cursor (struct window *w, bool on,
       return;
     }
 
+  /* A frame might be marked garbaged even though its cursor position
+     is correct, and will not change upon subsequent redisplay.  This
+     happens in some rare situations, like toggling the sort order in
+     Dired windows.  We've already established that VPOS is valid, so
+     it shouldn't do any harm to record the cursor position, as we are
+     going to return without acting on it anyway.  Otherwise, expose
+     events might come in and call update_window_cursor, which will
+     blindly use outdated values in w->phys_cursor.  */
+  if (FRAME_GARBAGED_P (f))
+    {
+      if (on)
+        {
+          w->phys_cursor.x = x;
+          w->phys_cursor.y = glyph_row->y;
+          w->phys_cursor.hpos = hpos;
+          w->phys_cursor.vpos = vpos;
+        }
+      return;
+    }
+
   glyph = NULL;
   if (0 <= hpos && hpos < glyph_row->used[TEXT_AREA])
     glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
@@ -30243,13 +30464,67 @@ note_mouse_highlight (struct frame *f, int x, int y)
           && part != ON_HEADER_LINE))
     clear_mouse_face (hlinfo);
 
+  /* Reset help_echo_string. It will get recomputed below.  */
+  help_echo_string = Qnil;
+
+#ifdef HAVE_WINDOW_SYSTEM
+  /* If the cursor is on the internal border of FRAME and FRAME's
+     internal border is draggable, provide some visual feedback.  */
+  if (FRAME_INTERNAL_BORDER_WIDTH (f) > 0
+      && !NILP (get_frame_param (f, Qdrag_internal_border)))
+    {
+      enum internal_border_part part = frame_internal_border_part (f, x, y);
+
+      switch (part)
+        {
+        case INTERNAL_BORDER_NONE:
+          if (cursor != FRAME_X_OUTPUT (f)->nontext_cursor)
+            /* Reset cursor.  */
+            cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
+          break;
+        case INTERNAL_BORDER_LEFT_EDGE:
+          cursor = FRAME_X_OUTPUT (f)->left_edge_cursor;
+          break;
+        case INTERNAL_BORDER_TOP_LEFT_CORNER:
+          cursor = FRAME_X_OUTPUT (f)->top_left_corner_cursor;
+          break;
+        case INTERNAL_BORDER_TOP_EDGE:
+          cursor = FRAME_X_OUTPUT (f)->top_edge_cursor;
+          break;
+        case INTERNAL_BORDER_TOP_RIGHT_CORNER:
+          cursor = FRAME_X_OUTPUT (f)->top_right_corner_cursor;
+          break;
+        case INTERNAL_BORDER_RIGHT_EDGE:
+          cursor = FRAME_X_OUTPUT (f)->right_edge_cursor;
+          break;
+        case INTERNAL_BORDER_BOTTOM_RIGHT_CORNER:
+          cursor = FRAME_X_OUTPUT (f)->bottom_right_corner_cursor;
+          break;
+        case INTERNAL_BORDER_BOTTOM_EDGE:
+          cursor = FRAME_X_OUTPUT (f)->bottom_edge_cursor;
+          break;
+        case INTERNAL_BORDER_BOTTOM_LEFT_CORNER:
+          cursor = FRAME_X_OUTPUT (f)->bottom_left_corner_cursor;
+          break;
+        default:
+          /* This should not happen.  */
+          if (cursor != FRAME_X_OUTPUT (f)->nontext_cursor)
+            cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
+        }
+
+      if (cursor != FRAME_X_OUTPUT (f)->nontext_cursor)
+        {
+          /* Do we really want a help echo here?  */
+          help_echo_string = build_string ("drag-mouse-1: resize frame");
+          goto set_cursor;
+        }
+    }
+#endif /* HAVE_WINDOW_SYSTEM */
+
   /* Not on a window -> return.  */
   if (!WINDOWP (window))
     return;
 
-  /* Reset help_echo_string. It will get recomputed below.  */
-  help_echo_string = Qnil;
-
   /* Convert to window-relative pixel coordinates.  */
   w = XWINDOW (window);
   frame_to_window_pixel_xy (w, &x, &y);
@@ -30287,11 +30562,13 @@ note_mouse_highlight (struct frame *f, int x, int y)
     {
       cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
       help_echo_string = build_string ("drag-mouse-1: resize");
+      goto set_cursor;
     }
   else if (part == ON_RIGHT_DIVIDER)
     {
       cursor = FRAME_X_OUTPUT (f)->horizontal_drag_cursor;
       help_echo_string = build_string ("drag-mouse-1: resize");
+      goto set_cursor;
     }
   else if (part == ON_BOTTOM_DIVIDER)
     if (! WINDOW_BOTTOMMOST_P (w)
@@ -30300,6 +30577,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
       {
         cursor = FRAME_X_OUTPUT (f)->vertical_drag_cursor;
         help_echo_string = build_string ("drag-mouse-1: resize");
+        goto set_cursor;
       }
     else
       cursor = FRAME_X_OUTPUT (f)->nontext_cursor;
@@ -30994,8 +31272,15 @@ x_draw_right_divider (struct window *w)
       int x0 = WINDOW_RIGHT_EDGE_X (w) - WINDOW_RIGHT_DIVIDER_WIDTH (w);
       int x1 = WINDOW_RIGHT_EDGE_X (w);
       int y0 = WINDOW_TOP_EDGE_Y (w);
-      /* The bottom divider prevails.  */
-      int y1 = WINDOW_BOTTOM_EDGE_Y (w) - WINDOW_BOTTOM_DIVIDER_WIDTH (w);
+      int y1 = WINDOW_BOTTOM_EDGE_Y (w);
+
+      /* If W is horizontally combined and has a right sibling, don't
+         draw over any bottom divider.  */
+      if (WINDOW_BOTTOM_DIVIDER_WIDTH (w)
+          && !NILP (w->parent)
+          && WINDOW_HORIZONTAL_COMBINATION_P (XWINDOW (w->parent))
+          && !NILP (w->next))
+        y1 -= WINDOW_BOTTOM_DIVIDER_WIDTH (w);
 
       FRAME_RIF (f)->draw_window_divider (w, x0, x1, y0, y1);
     }
@@ -31014,8 +31299,22 @@ x_draw_bottom_divider (struct window *w)
       int x1 = WINDOW_RIGHT_EDGE_X (w);
       int y0 = WINDOW_BOTTOM_EDGE_Y (w) - WINDOW_BOTTOM_DIVIDER_WIDTH (w);
       int y1 = WINDOW_BOTTOM_EDGE_Y (w);
+      struct window *p = !NILP (w->parent) ? XWINDOW (w->parent) : false;
 
-      FRAME_RIF (f)->draw_window_divider (w, x0, x1, y0, y1);
+      /* If W is vertically combined and has a sibling below, don't draw
+         over any right divider.  */
+      if (WINDOW_RIGHT_DIVIDER_WIDTH (w)
+          && p
+          && ((WINDOW_VERTICAL_COMBINATION_P (p)
+               && !NILP (w->next))
+              || (WINDOW_HORIZONTAL_COMBINATION_P (p)
+                  && NILP (w->next)
+                  && !NILP (p->parent)
+                  && WINDOW_VERTICAL_COMBINATION_P (XWINDOW (p->parent))
+                  && !NILP (XWINDOW (p->parent)->next))))
+        x1 -= WINDOW_RIGHT_DIVIDER_WIDTH (w);
+
+        FRAME_RIF (f)->draw_window_divider (w, x0, x1, y0, y1);
     }
 }
 
@@ -31130,7 +31429,7 @@ expose_window (struct window *w, XRectangle *fr)
         }
 
       /* Display the mode line if there is one.  */
-      if (WINDOW_WANTS_MODELINE_P (w)
+      if (window_wants_mode_line (w)
           && (row = MATRIX_MODE_LINE_ROW (w->current_matrix),
               row->enabled_p)
           && row->y < r_bottom)
@@ -31676,7 +31975,7 @@ This variable is not guaranteed to be accurate except while processing
 \(Assuming the window manager supports this feature.)
 
 This variable has the same structure as `mode-line-format', except that
-the %c and %l constructs are ignored.  It is used only on frames for
+the %c, %C, and %l constructs are ignored.  It is used only on frames for
 which no explicit name has been set (see `modify-frame-parameters').  */);
 
   DEFVAR_LISP ("icon-title-format", Vicon_title_format,
@@ -31855,12 +32154,15 @@ If a frame's ON-STATE has no entry in this list,
 the frame's other specifications determine how to blink the cursor off.  */);
   Vblink_cursor_alist = Qnil;
 
-  DEFVAR_BOOL ("auto-hscroll-mode", automatic_hscrolling_p,
+  DEFVAR_LISP ("auto-hscroll-mode", automatic_hscrolling,
     doc: /* Allow or disallow automatic horizontal scrolling of windows.
-If non-nil, windows are automatically scrolled horizontally to make
-point visible.  */);
-  automatic_hscrolling_p = true;
+The value `current-line' means the line displaying point in each window
+is automatically scrolled horizontally to make point visible.
+Any other non-nil value means all the lines in a window are automatically
+scrolled horizontally to make point visible.  */);
+  automatic_hscrolling = Qt;
   DEFSYM (Qauto_hscroll_mode, "auto-hscroll-mode");
+  DEFSYM (Qcurrent_line, "current-line");
 
   DEFVAR_INT ("hscroll-margin", hscroll_margin,
     doc: /* How many columns away from the window edge point is allowed to get
@@ -32051,6 +32353,13 @@ display table takes effect; in this case, Emacs does not consult
   /* Initialize to t, since we need to disable reordering until
      loadup.el successfully loads charprop.el.  */
   redisplay__inhibit_bidi = true;
+
+  DEFVAR_BOOL ("display-raw-bytes-as-hex", display_raw_bytes_as_hex,
+    doc: /* Non-nil means display raw bytes in hexadecimal format.
+The default is to use octal format (\200) whereas hexadecimal (\x80)
+may be more familiar to users.  */);
+  display_raw_bytes_as_hex = false;
+
 }
 
 
diff --git a/src/xfaces.c b/src/xfaces.c
index 7fcaef4e41a..86bb9b0b496 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -4474,6 +4474,10 @@ lookup_basic_face (struct frame *f, int face_id)
     case CURSOR_FACE_ID:                name = Qcursor;                 break;
     case MOUSE_FACE_ID:                 name = Qmouse;                  break;
     case MENU_FACE_ID:                  name = Qmenu;                   break;
+    case WINDOW_DIVIDER_FACE_ID:        name = Qwindow_divider;         break;
+    case WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID:    name = Qwindow_divider_first_pixel;     break;
+    case WINDOW_DIVIDER_LAST_PIXEL_FACE_ID:     name = Qwindow_divider_last_pixel;      break;
+    case INTERNAL_BORDER_FACE_ID:       name = Qinternal_border;        break;
 
     default:
       emacs_abort (); /* the caller is supposed to pass us a basic face id */
@@ -5168,6 +5172,7 @@ realize_basic_faces (struct frame *f)
                           WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID);
       realize_named_face (f, Qwindow_divider_last_pixel,
                           WINDOW_DIVIDER_LAST_PIXEL_FACE_ID);
+      realize_named_face (f, Qinternal_border, INTERNAL_BORDER_FACE_ID);
 
       /* Reflect changes in the `menu' face in menu bars.  */
       if (FRAME_FACE_CACHE (f)->menu_face_changed_p)
@@ -6227,7 +6232,7 @@ where R,G,B are numbers between 0 and 255 and name is an arbitrary string.  */)
       int red, green, blue;
       int num;
 
-      while (fgets (buf, sizeof (buf), fp) != NULL) {
+      while (fgets_unlocked (buf, sizeof (buf), fp) != NULL) {
         if (sscanf (buf, "%d %d %d %n", &red, &green, &blue, &num) == 3)
           {
 #ifdef HAVE_NTGUI
@@ -6420,11 +6425,12 @@ syms_of_xfaces (void)
   DEFSYM (Qmouse, "mouse");
   DEFSYM (Qmode_line_inactive, "mode-line-inactive");
   DEFSYM (Qvertical_border, "vertical-border");
-
-  /* TTY color-related functions (defined in tty-colors.el).  */
   DEFSYM (Qwindow_divider, "window-divider");
   DEFSYM (Qwindow_divider_first_pixel, "window-divider-first-pixel");
   DEFSYM (Qwindow_divider_last_pixel, "window-divider-last-pixel");
+  DEFSYM (Qinternal_border, "internal-border");
+
+  /* TTY color-related functions (defined in tty-colors.el).  */
   DEFSYM (Qtty_color_desc, "tty-color-desc");
   DEFSYM (Qtty_color_standard_values, "tty-color-standard-values");
   DEFSYM (Qtty_color_by_index, "tty-color-by-index");
diff --git a/src/xfns.c b/src/xfns.c
index d3e0839d8ac..d8bf9747191 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -90,6 +90,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <Xm/FileSB.h>
 #include <Xm/List.h>
 #include <Xm/TextF.h>
+#include <Xm/MwmUtil.h>
 #endif
 
 #ifdef USE_LUCID
@@ -117,6 +118,35 @@ static ptrdiff_t image_cache_refcount;
 static int dpyinfo_refcount;
 #endif
 
+#ifndef USE_MOTIF
+#ifndef USE_GTK
+/** #define MWM_HINTS_FUNCTIONS     (1L << 0) **/
+#define MWM_HINTS_DECORATIONS   (1L << 1)
+/** #define MWM_HINTS_INPUT_MODE    (1L << 2) **/
+/** #define MWM_HINTS_STATUS        (1L << 3) **/
+
+#define MWM_DECOR_ALL           (1L << 0)
+/** #define MWM_DECOR_BORDER        (1L << 1) **/
+/** #define MWM_DECOR_RESIZEH       (1L << 2) **/
+/** #define MWM_DECOR_TITLE         (1L << 3) **/
+/** #define MWM_DECOR_MENU          (1L << 4) **/
+/** #define MWM_DECOR_MINIMIZE      (1L << 5) **/
+/** #define MWM_DECOR_MAXIMIZE      (1L << 6) **/
+
+/** #define _XA_MOTIF_WM_HINTS "_MOTIF_WM_HINTS" **/
+
+typedef struct {
+    unsigned long flags;
+    unsigned long functions;
+    unsigned long decorations;
+    long input_mode;
+    unsigned long status;
+} PropMotifWmHints;
+
+#define PROP_MOTIF_WM_HINTS_ELEMENTS 5
+#endif /* NOT USE_GTK */
+#endif /* NOT USE_MOTIF */
+
 static struct x_display_info *x_display_info_for_name (Lisp_Object);
 static void set_up_x_back_buffer (struct frame *f);
 
@@ -185,7 +215,9 @@ x_real_pos_and_offsets (struct frame *f,
   int win_x = 0, win_y = 0, outer_x = 0, outer_y = 0;
   int real_x = 0, real_y = 0;
   bool had_errors = false;
-  Window win = f->output_data.x->parent_desc;
+  Window win = (FRAME_PARENT_FRAME (f)
+                ? FRAME_X_WINDOW (FRAME_PARENT_FRAME (f))
+                : f->output_data.x->parent_desc);
   struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
   long max_len = 400;
   Atom target_type = XA_CARDINAL;
@@ -323,7 +355,8 @@ x_real_pos_and_offsets (struct frame *f,
         outer_geom_cookie = xcb_get_geometry (xcb_conn,
                                               FRAME_OUTER_WINDOW (f));
 
-      if (dpyinfo->root_window == f->output_data.x->parent_desc)
+      if ((dpyinfo->root_window == f->output_data.x->parent_desc)
+          && !FRAME_PARENT_FRAME (f))
         /* Try _NET_FRAME_EXTENTS if our parent is the root window.  */
         prop_cookie = xcb_get_property (xcb_conn, 0, win,
                                         dpyinfo->Xatom_net_frame_extents,
@@ -437,7 +470,8 @@ x_real_pos_and_offsets (struct frame *f,
 #endif
     }
 
-  if (dpyinfo->root_window == f->output_data.x->parent_desc)
+  if ((dpyinfo->root_window == f->output_data.x->parent_desc)
+      && !FRAME_PARENT_FRAME (f))
     {
       /* Try _NET_FRAME_EXTENTS if our parent is the root window.  */
 #ifdef USE_XCB
@@ -735,6 +769,204 @@ x_set_inhibit_double_buffering (struct frame *f,
   unblock_input ();
 }
 
+/**
+ * x_set_undecorated:
+ *
+ * Set frame F's `undecorated' parameter.  If non-nil, F's window-system
+ * window is drawn without decorations, title, minimize/maximize boxes
+ * and external borders.  This usually means that the window cannot be
+ * dragged, resized, iconified, maximized or deleted with the mouse.  If
+ * nil, draw the frame with all the elements listed above unless these
+ * have been suspended via window manager settings.
+ *
+ * Some window managers may not honor this parameter.
+ */
+static void
+x_set_undecorated (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  if (!EQ (new_value, old_value))
+    {
+      FRAME_UNDECORATED (f) = NILP (new_value) ? false : true;
+#ifdef USE_GTK
+      xg_set_undecorated (f, new_value);
+#else
+      Display *dpy = FRAME_X_DISPLAY (f);
+      PropMotifWmHints hints;
+      Atom prop = XInternAtom (dpy, "_MOTIF_WM_HINTS", False);
+
+      memset (&hints, 0, sizeof(hints));
+      hints.flags = MWM_HINTS_DECORATIONS;
+      hints.decorations = NILP (new_value) ? MWM_DECOR_ALL : 0;
+
+      block_input ();
+      /* For some reason the third and fourth arguments in the following
+         call must be identical: In the corresponding XGetWindowProperty
+         call in getMotifHints, xfwm has the third and seventh args both
+         display_info->atoms[MOTIF_WM_HINTS].  Obviously, YMMV.   */
+      XChangeProperty (dpy, FRAME_OUTER_WINDOW (f), prop, prop, 32,
+                       PropModeReplace, (unsigned char *) &hints,
+                       PROP_MOTIF_WM_HINTS_ELEMENTS);
+      unblock_input ();
+
+#endif /* USE_GTK */
+    }
+}
+
+/**
+ * x_set_parent_frame:
+ *
+ * Set frame F's `parent-frame' parameter.  If non-nil, make F a child
+ * frame of the frame specified by that parameter.  Technically, this
+ * makes F's window-system window a child window of the parent frame's
+ * window-system window.  If nil, make F's window-system window a
+ * top-level window--a child of its display's root window.
+ *
+ * A child frame is clipped at the native edges of its parent frame.
+ * Its `left' and `top' parameters specify positions relative to the
+ * top-left corner of its parent frame's native rectangle.  Usually,
+ * moving a parent frame moves all its child frames too, keeping their
+ * position relative to the parent unaltered.  When a parent frame is
+ * iconified or made invisible, its child frames are made invisible.
+ * When a parent frame is deleted, its child frames are deleted too.
+ *
+ * A visible child frame always appears on top of its parent frame thus
+ * obscuring parts of it.  When a frame has more than one child frame,
+ * their stacking order is specified just as that of non-child frames
+ * relative to their display.
+ *
+ * Whether a child frame has a menu or tool bar may be window-system or
+ * window manager dependent.  It's advisable to disable both via the
+ * frame parameter settings.
+ *
+ * Some window managers may not honor this parameter.
+ */
+static void
+x_set_parent_frame (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  struct frame *p = NULL;
+
+  if (!NILP (new_value)
+      && (!FRAMEP (new_value)
+          || !FRAME_LIVE_P (p = XFRAME (new_value))
+          || !FRAME_X_P (p)))
+    {
+      store_frame_param (f, Qparent_frame, old_value);
+      error ("Invalid specification of `parent-frame'");
+    }
+
+  if (p != FRAME_PARENT_FRAME (f))
+    {
+      block_input ();
+      XReparentWindow
+        (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
+         p ? FRAME_X_WINDOW (p) : DefaultRootWindow (FRAME_X_DISPLAY (f)),
+         f->left_pos, f->top_pos);
+      unblock_input ();
+
+      fset_parent_frame (f, new_value);
+    }
+}
+
+/**
+ * x_set_no_focus_on_map:
+ *
+ * Set frame F's `no-focus-on-map' parameter which, if non-nil, means
+ * that F's window-system window does not want to receive input focus
+ * when it is mapped.  (A frame's window is mapped when the frame is
+ * displayed for the first time and when the frame changes its state
+ * from `iconified' or `invisible' to `visible'.)
+ *
+ * Some window managers may not honor this parameter.
+ */
+static void
+x_set_no_focus_on_map (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  if (!EQ (new_value, old_value))
+    {
+#ifdef USE_GTK
+      xg_set_no_focus_on_map (f, new_value);
+#else /* not USE_GTK */
+      Display *dpy = FRAME_X_DISPLAY (f);
+      Atom prop = XInternAtom (dpy, "_NET_WM_USER_TIME", False);
+      Time timestamp = NILP (new_value) ? CurrentTime : 0;
+
+      XChangeProperty (dpy, FRAME_OUTER_WINDOW (f), prop,
+                       XA_CARDINAL, 32, PropModeReplace,
+                       (unsigned char *) &timestamp, 1);
+#endif /* USE_GTK */
+      FRAME_NO_FOCUS_ON_MAP (f) = !NILP (new_value);
+    }
+}
+
+/**
+ * x_set_no_accept_focus:
+ *
+ * Set frame F's `no-accept-focus' parameter which, if non-nil, hints
+ * that F's window-system window does not want to receive input focus
+ * via mouse clicks or by moving the mouse into it.
+ *
+ * If non-nil, this may have the unwanted side-effect that a user cannot
+ * scroll a non-selected frame with the mouse.
+ *
+ * Some window managers may not honor this parameter.
+ */
+static void
+x_set_no_accept_focus (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  if (!EQ (new_value, old_value))
+    {
+#ifdef USE_GTK
+      xg_set_no_accept_focus (f, new_value);
+#else /* not USE_GTK */
+#ifdef USE_X_TOOLKIT
+      Arg al[1];
+
+      XtSetArg (al[0], XtNinput, NILP (new_value) ? True : False);
+      XtSetValues (f->output_data.x->widget, al, 1);
+#else /* not USE_X_TOOLKIT */
+      Window window = FRAME_X_WINDOW (f);
+
+      f->output_data.x->wm_hints.input = NILP (new_value) ? True : False;
+      XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
+#endif /* USE_X_TOOLKIT */
+#endif /* USE_GTK */
+      FRAME_NO_ACCEPT_FOCUS (f) = !NILP (new_value);
+    }
+}
+
+/**
+ * x_set_override_redirect:
+ *
+ * Set frame F's `override_redirect' parameter which, if non-nil, hints
+ * that the window manager doesn't want to deal with F.  Usually, such
+ * frames have no decorations and always appear on top of all frames.
+ *
+ * Some window managers may not honor this parameter.
+ */
+static void
+x_set_override_redirect (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  if (!EQ (new_value, old_value))
+    {
+      /* Here (xfwm) override_redirect can be changed for invisible
+         frames only.  */
+      x_make_frame_invisible (f);
+
+#ifdef USE_GTK
+      xg_set_override_redirect (f, new_value);
+#else /* not USE_GTK */
+      XSetWindowAttributes attributes;
+
+      attributes.override_redirect = NILP (new_value) ? False : True;
+      XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
+                               CWOverrideRedirect, &attributes);
+#endif
+      x_make_frame_visible (f);
+      FRAME_OVERRIDE_REDIRECT (f) = !NILP (new_value);
+    }
+}
+
+
 #ifdef USE_GTK
 
 /* Set icon from FILE for frame F.  By using GTK functions the icon
@@ -888,6 +1120,14 @@ enum mouse_cursor {
   mouse_cursor_hand,
   mouse_cursor_horizontal_drag,
   mouse_cursor_vertical_drag,
+  mouse_cursor_left_edge,
+  mouse_cursor_top_left_corner,
+  mouse_cursor_top_edge,
+  mouse_cursor_top_right_corner,
+  mouse_cursor_right_edge,
+  mouse_cursor_bottom_right_corner,
+  mouse_cursor_bottom_edge,
+  mouse_cursor_bottom_left_corner,
   mouse_cursor_max
 };
 
@@ -907,13 +1147,21 @@ struct mouse_cursor_types {
 
 /* This array must stay in sync with enum mouse_cursor above!  */
 static const struct mouse_cursor_types mouse_cursor_types[] = {
-  { "text",      &Vx_pointer_shape,                XC_xterm             },
-  { "nontext",   &Vx_nontext_pointer_shape,        XC_left_ptr          },
-  { "hourglass", &Vx_hourglass_pointer_shape,      XC_watch             },
-  { "modeline",  &Vx_mode_pointer_shape,           XC_xterm             },
-  { NULL,        &Vx_sensitive_text_pointer_shape, XC_hand2             },
-  { NULL,        &Vx_window_horizontal_drag_shape, XC_sb_h_double_arrow },
-  { NULL,        &Vx_window_vertical_drag_shape,   XC_sb_v_double_arrow },
+  { "text",      &Vx_pointer_shape,                    XC_xterm               },
+  { "nontext",   &Vx_nontext_pointer_shape,            XC_left_ptr            },
+  { "hourglass", &Vx_hourglass_pointer_shape,          XC_watch               },
+  { "modeline",  &Vx_mode_pointer_shape,               XC_xterm               },
+  { NULL,        &Vx_sensitive_text_pointer_shape,     XC_hand2               },
+  { NULL,        &Vx_window_horizontal_drag_shape,     XC_sb_h_double_arrow   },
+  { NULL,        &Vx_window_vertical_drag_shape,       XC_sb_v_double_arrow   },
+  { NULL,        &Vx_window_left_edge_shape,           XC_left_side           },
+  { NULL,        &Vx_window_top_left_corner_shape,     XC_top_left_corner     },
+  { NULL,        &Vx_window_top_edge_shape,            XC_top_side            },
+  { NULL,        &Vx_window_top_right_corner_shape,    XC_top_right_corner    },
+  { NULL,        &Vx_window_right_edge_shape,          XC_right_side          },
+  { NULL,        &Vx_window_bottom_right_corner_shape, XC_bottom_right_corner },
+  { NULL,        &Vx_window_bottom_edge_shape,         XC_bottom_side         },
+  { NULL,        &Vx_window_bottom_left_corner_shape,  XC_bottom_left_corner  },
 };
 
 struct mouse_cursor_data {
@@ -1064,6 +1312,14 @@ x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
   INSTALL_CURSOR (hand_cursor, hand);
   INSTALL_CURSOR (horizontal_drag_cursor, horizontal_drag);
   INSTALL_CURSOR (vertical_drag_cursor, vertical_drag);
+  INSTALL_CURSOR (left_edge_cursor, left_edge);
+  INSTALL_CURSOR (top_left_corner_cursor, top_left_corner);
+  INSTALL_CURSOR (top_edge_cursor, top_edge);
+  INSTALL_CURSOR (top_right_corner_cursor, top_right_corner);
+  INSTALL_CURSOR (right_edge_cursor, right_edge);
+  INSTALL_CURSOR (bottom_right_corner_cursor, bottom_right_corner);
+  INSTALL_CURSOR (bottom_edge_cursor, bottom_edge);
+  INSTALL_CURSOR (bottom_left_corner_cursor, bottom_left_corner);
 
 #undef INSTALL_CURSOR
 
@@ -1272,7 +1528,7 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
      most of the commands try to apply themselves to the minibuffer
      frame itself, and get an error because you can't switch buffers
      in or split the minibuffer window.  */
-  if (FRAME_MINIBUF_ONLY_P (f))
+  if (FRAME_MINIBUF_ONLY_P (f) || FRAME_PARENT_FRAME (f))
     return;
 
   if (TYPE_RANGED_INTEGERP (int, value))
@@ -1471,15 +1727,10 @@ x_set_internal_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldva
         widget_store_internal_border (FRAME_X_OUTPUT (f)->edit_widget);
 #endif
 
-      if (FRAME_X_WINDOW (f) != 0)
+      if (FRAME_X_WINDOW (f))
         {
           adjust_frame_size (f, -1, -1, 3, false, Qinternal_border_width);
-
-#ifdef USE_GTK
-          xg_clear_under_internal_border (f);
-#else
           x_clear_under_internal_border (f);
-#endif
         }
     }
 
@@ -2648,7 +2899,7 @@ x_window (struct frame *f, long window_prompting)
   XtSetArg (al[ac], XtNdepth, FRAME_DISPLAY_INFO (f)->n_planes); ac++;
   XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
   XtSetArg (al[ac], XtNborderWidth, 0); ac++;
-  frame_widget = XtCreateWidget (f->namebuf, emacsFrameClass, pane_widget,
+  frame_widget = XtCreateWidget (f->namebuf, emacsFrameClass (), pane_widget,
                                  al, ac);
 
   f->output_data.x->edit_widget = frame_widget;
@@ -2693,7 +2944,7 @@ x_window (struct frame *f, long window_prompting)
        and specify it.
        Note that we do not specify here whether the position
        is a user-specified or program-specified one.
-       We pass that information later, in x_wm_set_size_hints.  */
+       We pass that information later, in x_wm_set_size_hint.  */
     {
       int left = f->left_pos;
       bool xneg = (window_prompting & XNegative) != 0;
@@ -2783,7 +3034,8 @@ x_window (struct frame *f, long window_prompting)
     }
 #endif /* HAVE_X_I18N */
 
-  attribute_mask = CWEventMask;
+  attributes.override_redirect = FRAME_OVERRIDE_REDIRECT (f);
+  attribute_mask = CWEventMask | CWOverrideRedirect;
   XChangeWindowAttributes (XtDisplay (shell_widget), XtWindow (shell_widget),
                            attribute_mask, &attributes);
 
@@ -2803,6 +3055,25 @@ x_window (struct frame *f, long window_prompting)
     x_set_name (f, name, explicit);
   }
 
+  if (FRAME_UNDECORATED (f))
+    {
+      Display *dpy = FRAME_X_DISPLAY (f);
+      PropMotifWmHints hints;
+      Atom prop = XInternAtom (dpy, "_MOTIF_WM_HINTS", False);
+
+      memset (&hints, 0, sizeof(hints));
+      hints.flags = MWM_HINTS_DECORATIONS;
+      hints.decorations = 0;
+
+      /* For some reason the third and fourth arguments in the following
+         call must be identical: In the corresponding XGetWindowProperty
+         call in getMotifHints, xfwm has the third and seventh args both
+         display_info->atoms[MOTIF_WM_HINTS].  Obviously, YMMV.   */
+      XChangeProperty (dpy, FRAME_OUTER_WINDOW (f), prop, prop, 32,
+                       PropModeReplace, (unsigned char *) &hints,
+                       PROP_MOTIF_WM_HINTS_ELEMENTS);
+    }
+
   XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
                  f->output_data.x->current_cursor
                  = f->output_data.x->text_cursor);
@@ -2870,8 +3141,9 @@ x_window (struct frame *f)
   attributes.save_under = True;
   attributes.event_mask = STANDARD_EVENT_SET;
   attributes.colormap = FRAME_X_COLORMAP (f);
+  attributes.override_redirect = FRAME_OVERRIDE_REDIRECT (f);
   attribute_mask = (CWBackPixel | CWBorderPixel | CWBitGravity | CWEventMask
-                    | CWColormap);
+                    | CWOverrideRedirect | CWColormap);
 
   block_input ();
   FRAME_X_WINDOW (f)
@@ -2943,6 +3215,26 @@ x_window (struct frame *f)
     x_set_name (f, name, explicit);
   }
 
+  if (FRAME_UNDECORATED (f))
+    {
+      Display *dpy = FRAME_X_DISPLAY (f);
+      PropMotifWmHints hints;
+      Atom prop = XInternAtom (dpy, "_MOTIF_WM_HINTS", False);
+
+      memset (&hints, 0, sizeof(hints));
+      hints.flags = MWM_HINTS_DECORATIONS;
+      hints.decorations = 0;
+
+      /* For some reason the third and fourth arguments in the following
+         call must be identical: In the corresponding XGetWindowProperty
+         call in getMotifHints, xfwm has the third and seventh args both
+         display_info->atoms[MOTIF_WM_HINTS].  Obviously, YMMV.   */
+      XChangeProperty (dpy, FRAME_OUTER_WINDOW (f), prop, prop, 32,
+                       PropModeReplace, (unsigned char *) &hints,
+                       PROP_MOTIF_WM_HINTS_ELEMENTS);
+    }
+
+
   XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
                  f->output_data.x->current_cursor
                  = f->output_data.x->text_cursor);
@@ -3285,11 +3577,12 @@ This function is an internal primitive--use `make-frame' instead.  */)
   Lisp_Object frame, tem;
   Lisp_Object name;
   bool minibuffer_only = false;
+  bool undecorated = false, override_redirect = false;
   long window_prompting = 0;
   ptrdiff_t count = SPECPDL_INDEX ();
   Lisp_Object display;
   struct x_display_info *dpyinfo = NULL;
-  Lisp_Object parent;
+  Lisp_Object parent, parent_frame;
   struct kboard *kb;
   int x_width = 0, x_height = 0;
 
@@ -3341,6 +3634,36 @@ This function is an internal primitive--use `make-frame' instead.  */)
   else
     f = make_frame (true);
 
+  parent_frame = x_get_arg (dpyinfo, parms, Qparent_frame, NULL, NULL,
+                            RES_TYPE_SYMBOL);
+  /* Accept parent-frame iff parent-id was not specified.  */
+  if (!NILP (parent)
+      || EQ (parent_frame, Qunbound)
+      || NILP (parent_frame)
+      || !FRAMEP (parent_frame)
+      || !FRAME_LIVE_P (XFRAME (parent_frame))
+      || !FRAME_X_P (XFRAME (parent_frame)))
+    parent_frame = Qnil;
+
+  fset_parent_frame (f, parent_frame);
+  store_frame_param (f, Qparent_frame, parent_frame);
+
+  if (!NILP (tem = (x_get_arg (dpyinfo, parms, Qundecorated, NULL, NULL,
+                               RES_TYPE_BOOLEAN)))
+      && !(EQ (tem, Qunbound)))
+    undecorated = true;
+
+  FRAME_UNDECORATED (f) = undecorated;
+  store_frame_param (f, Qundecorated, undecorated ? Qt : Qnil);
+
+  if (!NILP (tem = (x_get_arg (dpyinfo, parms, Qoverride_redirect, NULL, NULL,
+                               RES_TYPE_BOOLEAN)))
+      && !(EQ (tem, Qunbound)))
+    override_redirect = true;
+
+  FRAME_OVERRIDE_REDIRECT (f) = override_redirect;
+  store_frame_param (f, Qoverride_redirect, override_redirect ? Qt : Qnil);
+
   XSETFRAME (frame, f);
 
   f->terminal = dpyinfo->terminal;
@@ -3515,6 +3838,8 @@ This function is an internal primitive--use `make-frame' instead.  */)
                        "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
   x_default_parameter (f, parms, Qright_fringe, Qnil,
                        "rightFringe", "RightFringe", RES_TYPE_NUMBER);
+  x_default_parameter (f, parms, Qno_special_glyphs, Qnil,
+                       NULL, NULL, RES_TYPE_BOOLEAN);
 
   x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_foreground,
                                         "scrollBarForeground",
@@ -3528,15 +3853,24 @@ This function is an internal primitive--use `make-frame' instead.  */)
      init_iterator with a null face cache, which should not happen.  */
   init_frame_faces (f);
 
-  /* The following call of change_frame_size is needed since otherwise
+  /* We have to call adjust_frame_size here since otherwise
      x_set_tool_bar_lines will already work with the character sizes
-     installed by init_frame_faces while the frame's pixel size is
-     still calculated from a character size of 1 and we subsequently
-     hit the (height >= 0) assertion in window_box_height.
+     installed by init_frame_faces while the frame's pixel size is still
+     calculated from a character size of 1 and we subsequently hit the
+     (height >= 0) assertion in window_box_height.
 
      The non-pixelwise code apparently worked around this because it
      had one frame line vs one toolbar line which left us with a zero
-     root window height which was obviously wrong as well ...  */
+     root window height which was obviously wrong as well ...
+
+     Also process `min-width' and `min-height' parameters right here
+     because `frame-windows-min-size' needs them.  */
+  tem = x_get_arg (dpyinfo, parms, Qmin_width, NULL, NULL, RES_TYPE_NUMBER);
+  if (NUMBERP (tem))
+    store_frame_param (f, Qmin_width, tem);
+  tem = x_get_arg (dpyinfo, parms, Qmin_height, NULL, NULL, RES_TYPE_NUMBER);
+  if (NUMBERP (tem))
+    store_frame_param (f, Qmin_height, tem);
   adjust_frame_size (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
                      FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 5, true,
                      Qx_create_frame_1);
@@ -3611,6 +3945,21 @@ This function is an internal primitive--use `make-frame' instead.  */)
   x_default_parameter (f, parms, Qalpha, Qnil,
                        "alpha", "Alpha", RES_TYPE_NUMBER);
 
+  if (!NILP (parent_frame))
+    {
+      struct frame *p = XFRAME (parent_frame);
+
+      block_input ();
+      XReparentWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
+                       FRAME_X_WINDOW (p), f->left_pos, f->top_pos);
+      unblock_input ();
+    }
+
+  x_default_parameter (f, parms, Qno_focus_on_map, Qnil,
+                       NULL, NULL, RES_TYPE_BOOLEAN);
+  x_default_parameter (f, parms, Qno_accept_focus, Qnil,
+                       NULL, NULL, RES_TYPE_BOOLEAN);
+
 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
   /* Create the menu bar.  */
   if (!minibuffer_only && FRAME_EXTERNAL_MENU_BAR (f))
@@ -3656,23 +4005,23 @@ This function is an internal primitive--use `make-frame' instead.  */)
   /* Make the window appear on the frame and enable display, unless
      the caller says not to.  However, with explicit parent, Emacs
      cannot control visibility, so don't try.  */
-  if (! f->output_data.x->explicit_parent)
+  if (!f->output_data.x->explicit_parent)
     {
-      Lisp_Object visibility;
-
-      visibility = x_get_arg (dpyinfo, parms, Qvisibility, 0, 0,
-                              RES_TYPE_SYMBOL);
-      if (EQ (visibility, Qunbound))
-        visibility = Qt;
+      Lisp_Object visibility
+        = x_get_arg (dpyinfo, parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL);
 
       if (EQ (visibility, Qicon))
         x_iconify_frame (f);
-      else if (! NILP (visibility))
-        x_make_frame_visible (f);
       else
         {
-          /* Must have been Qnil.  */
+          if (EQ (visibility, Qunbound))
+            visibility = Qt;
+
+          if (!NILP (visibility))
+            x_make_frame_visible (f);
         }
+
+      store_frame_param (f, Qvisibility, visibility);
     }
 
   block_input ();
@@ -3685,14 +4034,21 @@ This function is an internal primitive--use `make-frame' instead.  */)
   if (dpyinfo->client_leader_window != 0)
     {
       XChangeProperty (FRAME_X_DISPLAY (f),
-                       FRAME_OUTER_WINDOW (f),
-                       dpyinfo->Xatom_wm_client_leader,
-                       XA_WINDOW, 32, PropModeReplace,
-                       (unsigned char *) &dpyinfo->client_leader_window, 1);
+                       FRAME_OUTER_WINDOW (f),
+                       dpyinfo->Xatom_wm_client_leader,
+                       XA_WINDOW, 32, PropModeReplace,
+                       (unsigned char *) &dpyinfo->client_leader_window, 1);
     }
 
   unblock_input ();
 
+  /* Works iff frame has been already mapped.  */
+  x_default_parameter (f, parms, Qskip_taskbar, Qnil,
+                       NULL, NULL, RES_TYPE_BOOLEAN);
+  /* The `z-group' parameter works only for visible frames.  */
+  x_default_parameter (f, parms, Qz_group, Qnil,
+                       NULL, NULL, RES_TYPE_SYMBOL);
+
   /* Initialize `default-minibuffer-frame' in case this is the first
      frame on this terminal.  */
   if (FRAME_HAS_MINIBUF_P (f)
@@ -3710,7 +4066,7 @@ This function is an internal primitive--use `make-frame' instead.  */)
      and similar functions.  */
   Vwindow_list = Qnil;
 
-  return unbind_to (count, frame);
+ return unbind_to (count, frame);
 }
 
 
@@ -3741,7 +4097,7 @@ x_get_focus_frame (struct frame *frame)
    following a user-command.  */
 
 void
-x_focus_frame (struct frame *f)
+x_focus_frame (struct frame *f, bool noactivate)
 {
   Display *dpy = FRAME_X_DISPLAY (f);
 
@@ -3759,7 +4115,8 @@ x_focus_frame (struct frame *f)
     {
       XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
                       RevertToParent, CurrentTime);
-      x_ewmh_activate_frame (f);
+      if (!noactivate)
+        x_ewmh_activate_frame (f);
     }
 
   x_uncatch_errors ();
@@ -4644,9 +5001,9 @@ frame_geometry (Lisp_Object frame, Lisp_Object attribute)
   struct frame *f = decode_live_frame (frame);
   /**   XWindowAttributes atts; **/
   Window rootw;
-  unsigned int ign, native_width, native_height;
-  int xy_ign, xptr, yptr;
-  int left_off, right_off, top_off, bottom_off;
+  unsigned int ign, native_width, native_height, x_border_width = 0;
+  int x_native = 0, y_native = 0, xptr = 0, yptr = 0;
+  int left_off = 0, right_off = 0, top_off = 0, bottom_off = 0;
   int outer_left, outer_top, outer_right, outer_bottom;
   int native_left, native_top, native_right, native_bottom;
   int inner_left, inner_top, inner_right, inner_bottom;
@@ -4660,25 +5017,51 @@ frame_geometry (Lisp_Object frame, Lisp_Object attribute)
 
   block_input ();
   XGetGeometry (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
-                &rootw, &xy_ign, &xy_ign, &native_width, &native_height,
-                &ign, &ign);
+                &rootw, &x_native, &y_native, &native_width, &native_height,
+                &x_border_width, &ign);
   /**   XGetWindowAttributes (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &atts); **/
-  x_real_pos_and_offsets (f, &left_off, &right_off, &top_off, &bottom_off,
-                          NULL, NULL, &xptr, &yptr, NULL);
+  if (!FRAME_PARENT_FRAME (f))
+    x_real_pos_and_offsets (f, &left_off, &right_off, &top_off, &bottom_off,
+                            NULL, NULL, &xptr, &yptr, NULL);
   unblock_input ();
 
   /**   native_width = atts.width; **/
   /**   native_height = atts.height; **/
 
-  outer_left = xptr;
-  outer_top = yptr;
-  outer_right = outer_left + left_off + native_width + right_off;
-  outer_bottom = outer_top + top_off + native_height + bottom_off;
+  if (FRAME_PARENT_FRAME (f))
+    {
+      Lisp_Object parent, edges;
 
-  native_left = outer_left + left_off;
-  native_top = outer_top + top_off;
-  native_right = native_left + native_width;
-  native_bottom = native_top + native_height;
+      XSETFRAME (parent, FRAME_PARENT_FRAME (f));
+      edges = Fx_frame_edges (parent, Qnative_edges);
+      if (!NILP (edges))
+        {
+          x_native += XINT (Fnth (make_number (0), edges));
+          y_native += XINT (Fnth (make_number (1), edges));
+        }
+
+      outer_left = x_native;
+      outer_top = y_native;
+      outer_right = outer_left + native_width + 2 * x_border_width;
+      outer_bottom = outer_top + native_height + 2 * x_border_width;
+
+      native_left = x_native + x_border_width;
+      native_top = y_native + x_border_width;
+      native_right = native_left + native_width;
+      native_bottom = native_top + native_height;
+    }
+  else
+    {
+      outer_left = xptr;
+      outer_top = yptr;
+      outer_right = outer_left + left_off + native_width + right_off;
+      outer_bottom = outer_top + top_off + native_height + bottom_off;
+
+      native_left = outer_left + left_off;
+      native_top = outer_top + top_off;
+      native_right = native_left + native_width;
+      native_bottom = native_top + native_height;
+    }
 
   internal_border_width = FRAME_INTERNAL_BORDER_WIDTH (f);
   inner_left = native_left + internal_border_width;
@@ -4749,7 +5132,7 @@ frame_geometry (Lisp_Object frame, Lisp_Object attribute)
                   make_number (inner_right), make_number (inner_bottom));
   else
     return
-      listn (CONSTYPE_HEAP, 10,
+      listn (CONSTYPE_HEAP, 11,
              Fcons (Qouter_position,
                     Fcons (make_number (outer_left),
                            make_number (outer_top))),
@@ -4760,6 +5143,7 @@ frame_geometry (Lisp_Object frame, Lisp_Object attribute)
              Fcons (Qexternal_border_size,
                     Fcons (make_number (right_off),
                            make_number (bottom_off))),
+             Fcons (Qouter_border_width, make_number (x_border_width)),
              /* Approximate.  */
              Fcons (Qtitle_bar_size,
                     Fcons (make_number (0),
@@ -4788,7 +5172,8 @@ and width values are in pixels.
 
 `outer-size' is a cons of the outer width and height of FRAME.  The
   outer size includes the title bar and the external borders as well as
-  any menu and/or tool bar of frame.
+  any menu and/or tool bar of frame.  For a child frame the value
+  includes FRAME's X borders, if any.
 
 `external-border-size' is a cons of the horizontal and vertical width of
   FRAME's external borders as supplied by the window manager.
@@ -4815,7 +5200,11 @@ and width values are in pixels.
   FRAME.
 
 `internal-border-width' is the width of the internal border of
-  FRAME.  */)
+  FRAME.
+
+`outer-border-width' is the width of the X border of FRAME.  The X
+  border is usually only shown for frames without window manager
+  decorations like child and tooltip frames.  */)
   (Lisp_Object frame)
 {
   return frame_geometry (frame, Qnil);
@@ -4845,6 +5234,139 @@ menu bar or tool bar of FRAME.  */)
                                  : Qnative_edges));
 }
 
+/**
+ * x_frame_list_z_order:
+ *
+ * Recursively add list of all frames on the display specified via
+ * DPYINFO and whose window-system window's parent is specified by
+ * WINDOW to FRAMES and return FRAMES.
+ */
+static Lisp_Object
+x_frame_list_z_order (Display* dpy, Window window)
+{
+  Window root, parent, *children;
+  unsigned int nchildren;
+  int i;
+  Lisp_Object frames = Qnil;
+
+  block_input ();
+  if (XQueryTree (dpy, window, &root, &parent, &children, &nchildren))
+    {
+      unblock_input ();
+      for (i = 0; i < nchildren; i++)
+        {
+          Lisp_Object frame, tail;
+
+          FOR_EACH_FRAME (tail, frame)
+            /* With a reparenting window manager the parent_desc field
+               usually specifies the topmost windows of our frames.
+               Otherwise FRAME_OUTER_WINDOW should do.  */
+            if (XFRAME (frame)->output_data.x->parent_desc == children[i]
+                || FRAME_OUTER_WINDOW (XFRAME (frame)) == children[i])
+              frames = Fcons (frame, frames);
+        }
+
+      if (children) XFree ((char *)children);
+    }
+  else
+    unblock_input ();
+
+  return frames;
+}
+
+
+DEFUN ("x-frame-list-z-order", Fx_frame_list_z_order,
+       Sx_frame_list_z_order, 0, 1, 0,
+       doc: /* Return list of Emacs' frames, in Z (stacking) order.
+The optional argument TERMINAL specifies which display to ask about.
+TERMINAL should be either a frame or a display name (a string).  If
+omitted or nil, that stands for the selected frame's display.  Return
+nil if TERMINAL contains no Emacs frame.
+
+As a special case, if TERMINAL is non-nil and specifies a live frame,
+return the child frames of that frame in Z (stacking) order.
+
+Frames are listed from topmost (first) to bottommost (last).  */)
+  (Lisp_Object terminal)
+{
+  struct x_display_info *dpyinfo = check_x_display_info (terminal);
+  Display *dpy = dpyinfo->display;
+  Window window;
+
+  if (FRAMEP (terminal) && FRAME_LIVE_P (XFRAME (terminal)))
+    window = FRAME_X_WINDOW (XFRAME (terminal));
+  else
+    window = dpyinfo->root_window;
+
+  return x_frame_list_z_order (dpy, window);
+}
+
+/**
+ * x_frame_restack:
+ *
+ * Restack frame F1 below frame F2, above if ABOVE_FLAG is non-nil.  In
+ * practice this is a two-step action: The first step removes F1's
+ * window-system window from the display.  The second step reinserts
+ * F1's window below (above if ABOVE_FLAG is true) that of F2.
+ */
+static void
+x_frame_restack (struct frame *f1, struct frame *f2, bool above_flag)
+{
+#if defined (USE_GTK) && GTK_CHECK_VERSION (2, 18, 0)
+  block_input ();
+  xg_frame_restack (f1, f2, above_flag);
+  unblock_input ();
+#else
+  Display *dpy = FRAME_X_DISPLAY (f1);
+  Window window1 = FRAME_OUTER_WINDOW (f1);
+  XWindowChanges wc;
+  unsigned long mask = (CWSibling | CWStackMode);
+
+  wc.sibling = FRAME_OUTER_WINDOW (f2);
+  wc.stack_mode = above_flag ? Above : Below;
+  block_input ();
+  /* Configure the window manager window (a normal XConfigureWindow
+     won't cut it).  This should also work for child frames.  */
+  XReconfigureWMWindow (dpy, window1, FRAME_X_SCREEN_NUMBER (f1), mask, &wc);
+  unblock_input ();
+#endif /* USE_GTK */
+}
+
+
+DEFUN ("x-frame-restack", Fx_frame_restack, Sx_frame_restack, 2, 3, 0,
+       doc: /* Restack FRAME1 below FRAME2.
+This means that if both frames are visible and the display areas of
+these frames overlap, FRAME2 (partially) obscures FRAME1.  If optional
+third argument ABOVE is non-nil, restack FRAME1 above FRAME2.  This
+means that if both frames are visible and the display areas of these
+frames overlap, FRAME1 (partially) obscures FRAME2.
+
+This may be thought of as an atomic action performed in two steps: The
+first step removes FRAME1's window-step window from the display.  The
+second step reinserts FRAME1's window below (above if ABOVE is true)
+that of FRAME2.  Hence the position of FRAME2 in its display's Z
+\(stacking) order relative to all other frames excluding FRAME1 remains
+unaltered.
+
+Some window managers may refuse to restack windows.  */)
+     (Lisp_Object frame1, Lisp_Object frame2, Lisp_Object above)
+{
+  struct frame *f1 = decode_live_frame (frame1);
+  struct frame *f2 = decode_live_frame (frame2);
+
+  if (FRAME_OUTER_WINDOW (f1) && FRAME_OUTER_WINDOW (f2))
+    {
+      x_frame_restack (f1, f2, !NILP (above));
+      return Qt;
+    }
+  else
+    {
+      error ("Cannot restack frames");
+      return Qnil;
+    }
+}
+
+
 DEFUN ("x-mouse-absolute-pixel-position", Fx_mouse_absolute_pixel_position,
        Sx_mouse_absolute_pixel_position, 0, 0, 0,
        doc: /* Return absolute position of mouse cursor in pixels.
@@ -5700,6 +6222,8 @@ x_create_tip_frame (struct x_display_info *dpyinfo, Lisp_Object parms)
                        "cursorColor", "Foreground", RES_TYPE_STRING);
   x_default_parameter (f, parms, Qborder_color, build_string ("black"),
                        "borderColor", "BorderColor", RES_TYPE_STRING);
+  x_default_parameter (f, parms, Qno_special_glyphs, Qnil,
+                       NULL, NULL, RES_TYPE_BOOLEAN);
 
   /* Init faces before x_default_parameter is called for the
      scroll-bar-width parameter because otherwise we end up in
@@ -6585,6 +7109,8 @@ value of DIR as in previous invocations; this is standard Windows behavior.  */)
 
   if (popup_activated ())
     error ("Trying to use a menu from within a menu-entry");
+  else
+    x_menu_set_in_use (true);
 
   CHECK_STRING (prompt);
   CHECK_STRING (dir);
@@ -6641,6 +7167,8 @@ nil, it defaults to the selected frame. */)
 
   if (popup_activated ())
     error ("Trying to use a menu from within a menu-entry");
+  else
+    x_menu_set_in_use (true);
 
   /* Prevent redisplay.  */
   specbind (Qinhibit_redisplay, Qt);
@@ -6979,6 +7507,14 @@ frame_parm_handler x_frame_parm_handlers[] =
   x_set_sticky,
   x_set_tool_bar_position,
   x_set_inhibit_double_buffering,
+  x_set_undecorated,
+  x_set_parent_frame,
+  x_set_skip_taskbar,
+  x_set_no_focus_on_map,
+  x_set_no_accept_focus,
+  x_set_z_group,
+  x_set_override_redirect,
+  x_set_no_special_glyphs,
 };
 
 void
@@ -7057,6 +7593,62 @@ This variable takes effect when you create a new frame
 or when you set the mouse color.  */);
   Vx_window_vertical_drag_shape = Qnil;
 
+  DEFVAR_LISP ("x-window-left-edge-cursor",
+               Vx_window_left_edge_shape,
+  doc: /* Pointer shape indicating a left x-window edge can be dragged.
+This variable takes effect when you create a new frame
+or when you set the mouse color.  */);
+  Vx_window_left_edge_shape = Qnil;
+
+  DEFVAR_LISP ("x-window-top-left-corner-cursor",
+               Vx_window_top_left_corner_shape,
+  doc: /* Pointer shape indicating a top left x-window corner can be dragged.
+This variable takes effect when you create a new frame
+or when you set the mouse color.  */);
+  Vx_window_top_left_corner_shape = Qnil;
+
+  DEFVAR_LISP ("x-window-top-edge-cursor",
+               Vx_window_top_edge_shape,
+  doc: /* Pointer shape indicating a top x-window edge can be dragged.
+This variable takes effect when you create a new frame
+or when you set the mouse color.  */);
+  Vx_window_top_edge_shape = Qnil;
+
+  DEFVAR_LISP ("x-window-top-right-corner-cursor",
+               Vx_window_top_right_corner_shape,
+  doc: /* Pointer shape indicating a top right x-window corner can be dragged.
+This variable takes effect when you create a new frame
+or when you set the mouse color.  */);
+  Vx_window_top_right_corner_shape = Qnil;
+
+  DEFVAR_LISP ("x-window-right-edge-cursor",
+               Vx_window_right_edge_shape,
+  doc: /* Pointer shape indicating a right x-window edge can be dragged.
+This variable takes effect when you create a new frame
+or when you set the mouse color.  */);
+  Vx_window_right_edge_shape = Qnil;
+
+  DEFVAR_LISP ("x-window-bottom-right-corner-cursor",
+               Vx_window_bottom_right_corner_shape,
+  doc: /* Pointer shape indicating a bottom right x-window corner can be dragged.
+This variable takes effect when you create a new frame
+or when you set the mouse color.  */);
+  Vx_window_bottom_right_corner_shape = Qnil;
+
+  DEFVAR_LISP ("x-window-bottom-edge-cursor",
+               Vx_window_bottom_edge_shape,
+  doc: /* Pointer shape indicating a bottom x-window edge can be dragged.
+This variable takes effect when you create a new frame
+or when you set the mouse color.  */);
+  Vx_window_bottom_edge_shape = Qnil;
+
+  DEFVAR_LISP ("x-window-bottom-left-corner-cursor",
+               Vx_window_bottom_left_corner_shape,
+  doc: /* Pointer shape indicating a bottom left x-window corner can be dragged.
+This variable takes effect when you create a new frame
+or when you set the mouse color.  */);
+  Vx_window_bottom_left_corner_shape = Qnil;
+
   DEFVAR_LISP ("x-cursor-fore-pixel", Vx_cursor_fore_pixel,
     doc: /* A string indicating the foreground color of the cursor box.  */);
   Vx_cursor_fore_pixel = Qnil;
@@ -7183,6 +7775,8 @@ When using Gtk+ tooltips, the tooltip face is not used.  */);
   defsubr (&Sx_display_monitor_attributes_list);
   defsubr (&Sx_frame_geometry);
   defsubr (&Sx_frame_edges);
+  defsubr (&Sx_frame_list_z_order);
+  defsubr (&Sx_frame_restack);
   defsubr (&Sx_mouse_absolute_pixel_position);
   defsubr (&Sx_set_mouse_absolute_pixel_position);
   defsubr (&Sx_wm_set_size_hint);
diff --git a/src/xmenu.c b/src/xmenu.c
index 249cd6903fa..6c8a0c506cc 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -140,14 +140,26 @@ menubar_id_to_frame (LWLIB_ID id)
 void
 x_menu_set_in_use (bool in_use)
 {
+  Lisp_Object frames, frame;
+
   menu_items_inuse = in_use ? Qt : Qnil;
   popup_activated_flag = in_use;
 #ifdef USE_X_TOOLKIT
   if (popup_activated_flag)
     x_activate_timeout_atimer ();
 #endif
-}
 
+  /* Don't let frames in `above' z-group obscure popups.  */
+  FOR_EACH_FRAME (frames, frame)
+    {
+      struct frame *f = XFRAME (frame);
+
+      if (in_use && FRAME_Z_GROUP_ABOVE (f))
+        x_set_z_group (f, Qabove_suspended, Qabove);
+      else if (!in_use && FRAME_Z_GROUP_ABOVE_SUSPENDED (f))
+        x_set_z_group (f, Qabove, Qabove_suspended);
+    }
+}
 #endif
 
 /* Wait for an X event to arrive or for a timer to expire.  */
@@ -1148,9 +1160,37 @@ menu_position_func (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer
 {
   struct next_popup_x_y *data = user_data;
   GtkRequisition req;
-  struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (data->f);
-  int disp_width = x_display_pixel_width (dpyinfo);
-  int disp_height = x_display_pixel_height (dpyinfo);
+  int max_x = -1;
+  int max_y = -1;
+
+  Lisp_Object frame, workarea;
+
+  XSETFRAME (frame, data->f);
+
+  /* TODO: Get the monitor workarea directly without calculating other
+     items in x-display-monitor-attributes-list. */
+  workarea = call3 (Qframe_monitor_workarea,
+                    Qnil,
+                    make_number (data->x),
+                    make_number (data->y));
+
+  if (CONSP (workarea))
+    {
+      int min_x, min_y;
+
+      min_x = XINT (XCAR (workarea));
+      min_y = XINT (Fnth (make_number (1), workarea));
+      max_x = min_x + XINT (Fnth (make_number (2), workarea));
+      max_y = min_y + XINT (Fnth (make_number (3), workarea));
+    }
+
+  if (max_x < 0 || max_y < 0)
+    {
+      struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (data->f);
+
+      max_x = x_display_pixel_width (dpyinfo);
+      max_y = x_display_pixel_height (dpyinfo);
+    }
 
   *x = data->x;
   *y = data->y;
@@ -1158,10 +1198,10 @@ menu_position_func (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer
   /* Check if there is room for the menu.  If not, adjust x/y so that
      the menu is fully visible.  */
   gtk_widget_get_preferred_size (GTK_WIDGET (menu), NULL, &req);
-  if (data->x + req.width > disp_width)
-    *x -= data->x + req.width - disp_width;
-  if (data->y + req.height > disp_height)
-    *y -= data->y + req.height - disp_height;
+  if (data->x + req.width > max_x)
+    *x -= data->x + req.width - max_x;
+  if (data->y + req.height > max_y)
+    *y -= data->y + req.height - max_y;
 }
 
 static void
@@ -2349,6 +2389,10 @@ syms_of_xmenu (void)
   DEFSYM (Qdebug_on_next_call, "debug-on-next-call");
   defsubr (&Smenu_or_popup_active_p);
 
+#ifdef USE_GTK
+  DEFSYM (Qframe_monitor_workarea, "frame-monitor-workarea");
+#endif
+
 #if defined (USE_GTK) || defined (USE_X_TOOLKIT)
   defsubr (&Sx_menu_bar_open_internal);
   Ffset (intern_c_string ("accelerate-menu"),
diff --git a/src/xterm.c b/src/xterm.c
index 4f9eff6c5e6..a214cd81031 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -569,7 +569,7 @@ x_cr_export_frames (Lisp_Object frames, cairo_surface_type_t surface_type)
   int width, height;
   void (*surface_set_size_func) (cairo_surface_t *, double, double) = NULL;
   Lisp_Object acc = Qnil;
-  int count = SPECPDL_INDEX ();
+  ptrdiff_t count = SPECPDL_INDEX ();
 
   specbind (Qredisplay_dont_pause, Qt);
   redisplay_preserve_echo_area (31);
@@ -945,11 +945,14 @@ x_set_frame_alpha (struct frame *f)
      Do this unconditionally as this function is called on reparent when
      alpha has not changed on the frame.  */
 
-  parent = x_find_topmost_parent (f);
-  if (parent != None)
-    XChangeProperty (dpy, parent, dpyinfo->Xatom_net_wm_window_opacity,
-                     XA_CARDINAL, 32, PropModeReplace,
-                     (unsigned char *) &opac, 1);
+  if (!FRAME_PARENT_FRAME (f))
+    {
+      parent = x_find_topmost_parent (f);
+      if (parent != None)
+        XChangeProperty (dpy, parent, dpyinfo->Xatom_net_wm_window_opacity,
+                         XA_CARDINAL, 32, PropModeReplace,
+                         (unsigned char *) &opac, 1);
+    }
 
   /* return unless necessary */
   {
@@ -1292,8 +1295,12 @@ XTbuffer_flipping_unblocked_hook (struct frame *f)
     show_back_buffer (f);
 }
 
-/* Clear under internal border if any (GTK has its own version). */
-#ifndef USE_GTK
+/**
+ * x_clear_under_internal_border:
+ *
+ * Clear area of frame F's internal border.  If the internal border face
+ * of F has been specified (is not null), fill the area with that face.
+ */
 void
 x_clear_under_internal_border (struct frame *f)
 {
@@ -1302,17 +1309,39 @@ x_clear_under_internal_border (struct frame *f)
       int border = FRAME_INTERNAL_BORDER_WIDTH (f);
       int width = FRAME_PIXEL_WIDTH (f);
       int height = FRAME_PIXEL_HEIGHT (f);
+#ifdef USE_GTK
+      int margin = 0;
+#else
       int margin = FRAME_TOP_MARGIN_HEIGHT (f);
+#endif
+      struct face *face = FACE_FROM_ID_OR_NULL (f, INTERNAL_BORDER_FACE_ID);
 
       block_input ();
-      x_clear_area (f, 0, 0, border, height);
-      x_clear_area (f, 0, margin, width, border);
-      x_clear_area (f, width - border, 0, border, height);
-      x_clear_area (f, 0, height - border, width, border);
+
+      if (face)
+        {
+          unsigned long color = face->background;
+          Display *display = FRAME_X_DISPLAY (f);
+          GC gc = f->output_data.x->normal_gc;
+
+          XSetForeground (display, gc, color);
+          x_fill_rectangle (f, gc, 0, margin, width, border);
+          x_fill_rectangle (f, gc, 0, 0, border, height);
+          x_fill_rectangle (f, gc, width - border, 0, border, height);
+          x_fill_rectangle (f, gc, 0, height - border, width, border);
+          XSetForeground (display, gc, FRAME_FOREGROUND_PIXEL (f));
+        }
+      else
+        {
+          x_clear_area (f, 0, 0, border, height);
+          x_clear_area (f, 0, margin, width, border);
+          x_clear_area (f, width - border, 0, border, height);
+          x_clear_area (f, 0, height - border, width, border);
+        }
+
       unblock_input ();
     }
 }
-#endif
 
 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
    arrow bitmaps, or clear the fringes if no bitmaps are required
@@ -1348,10 +1377,25 @@ x_after_update_window_line (struct window *w, struct glyph_row *desired_row)
             height > 0))
       {
         int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
+        struct face *face = FACE_FROM_ID_OR_NULL (f, INTERNAL_BORDER_FACE_ID);
 
         block_input ();
-        x_clear_area (f, 0, y, width, height);
-        x_clear_area (f, FRAME_PIXEL_WIDTH (f) - width, y, width, height);
+        if (face)
+          {
+            unsigned long color = face->background;
+            Display *display = FRAME_X_DISPLAY (f);
+
+            XSetForeground (display, f->output_data.x->normal_gc, color);
+            x_fill_rectangle (f, f->output_data.x->normal_gc,
+                              0, y, width, height);
+            x_fill_rectangle (f, f->output_data.x->normal_gc,
+                              FRAME_PIXEL_WIDTH (f) - width, y, width, height);
+          }
+        else
+          {
+            x_clear_area (f, 0, y, width, height);
+            x_clear_area (f, FRAME_PIXEL_WIDTH (f) - width, y, width, height);
+          }
         unblock_input ();
       }
   }
@@ -1961,9 +2005,9 @@ x_draw_glyphless_glyph_string_foreground (struct glyph_string *s)
         }
       else if (glyph->u.glyphless.method == GLYPHLESS_DISPLAY_HEX_CODE)
         {
-          sprintf (buf, "%0*X",
-                   glyph->u.glyphless.ch < 0x10000 ? 4 : 6,
-                   glyph->u.glyphless.ch + 0u);
+          unsigned int ch = glyph->u.glyphless.ch;
+          eassume (ch <= MAX_CHAR);
+          sprintf (buf, "%0*X", ch < 0x10000 ? 4 : 6, ch);
           str = buf;
         }
 
@@ -3846,11 +3890,11 @@ x_clear_area (struct frame *f, int x, int y, int width, int height)
   cairo_fill (cr);
   x_end_cr_clip (f);
 #else
-    if (FRAME_X_DOUBLE_BUFFERED_P (f))
-      XFillRectangle (FRAME_X_DISPLAY (f),
-                      FRAME_X_DRAWABLE (f),
-                      f->output_data.x->reverse_gc,
-                      x, y, width, height);
+  if (FRAME_X_DOUBLE_BUFFERED_P (f))
+    XFillRectangle (FRAME_X_DISPLAY (f),
+                    FRAME_X_DRAWABLE (f),
+                    f->output_data.x->reverse_gc,
+                    x, y, width, height);
   else
     x_clear_area1 (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
                    x, y, width, height, False);
@@ -4964,6 +5008,9 @@ XTmouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
          containing the pointer.  */
       {
         Window win, child;
+#ifdef USE_GTK
+        Window first_win = 0;
+#endif
         int win_x, win_y;
         int parent_x = 0, parent_y = 0;
 
@@ -5010,20 +5057,37 @@ XTmouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
                                        &child);
 
                 if (child == None || child == win)
-                  break;
+                  {
+#ifdef USE_GTK
+                    /* On GTK we have not inspected WIN yet.  If it has
+                       a frame and that frame has a parent, use it.  */
+                    struct frame *f = x_window_to_frame (dpyinfo, win);
+
+                    if (f && FRAME_PARENT_FRAME (f))
+                      first_win = win;
+#endif
+                    break;
+                  }
 #ifdef USE_GTK
                 /* We don't wan't to know the innermost window.  We
                    want the edit window.  For non-Gtk+ the innermost
                    window is the edit window.  For Gtk+ it might not
                    be.  It might be the tool bar for example.  */
                 if (x_window_to_frame (dpyinfo, win))
-                  break;
+                  /* But don't hurry.  We might find a child frame
+                     beneath.  */
+                  first_win = win;
 #endif
                 win = child;
                 parent_x = win_x;
                 parent_y = win_y;
               }
 
+#ifdef USE_GTK
+            if (first_win)
+              win = first_win;
+#endif
+
             /* Now we know that:
                win is the innermost window containing the pointer
                (XTC says it has no child containing the pointer),
@@ -5284,20 +5348,22 @@ xt_horizontal_action_hook (Widget widget, XtPointer client_data, String action_n
       x_send_scroll_bar_event (window_being_scrolled,
                                scroll_bar_end_scroll, 0, 0, true);
       w = XWINDOW (window_being_scrolled);
-      bar = XSCROLL_BAR (w->horizontal_scroll_bar);
-
-      if (bar->dragging != -1)
+      if (!NILP (w->horizontal_scroll_bar))
         {
-          bar->dragging = -1;
-          /* The thumb size is incorrect while dragging: fix it.  */
-          set_horizontal_scroll_bar (w);
-        }
-      window_being_scrolled = Qnil;
+          bar = XSCROLL_BAR (w->horizontal_scroll_bar);
+          if (bar->dragging != -1)
+            {
+              bar->dragging = -1;
+              /* The thumb size is incorrect while dragging: fix it.  */
+              set_horizontal_scroll_bar (w);
+            }
+          window_being_scrolled = Qnil;
 #if defined (USE_LUCID)
-      bar->last_seen_part = scroll_bar_nowhere;
+          bar->last_seen_part = scroll_bar_nowhere;
 #endif
-      /* Xt timeouts no longer needed.  */
-      toolkit_scroll_bar_interaction = false;
+          /* Xt timeouts no longer needed.  */
+          toolkit_scroll_bar_interaction = false;
+        }
     }
 }
 #endif /* not USE_GTK */
@@ -6496,10 +6562,14 @@ x_scroll_bar_create (struct window *w, int top, int left,
     Widget scroll_bar = SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar);
     XtConfigureWidget (scroll_bar, left, top, width, max (height, 1), 0);
     XtMapWidget (scroll_bar);
+    /* Don't obscure any child frames.  */
+    XLowerWindow (FRAME_X_DISPLAY (f), bar->x_window);
 #endif /* not USE_GTK */
     }
 #else /* not USE_TOOLKIT_SCROLL_BARS */
-  XMapRaised (FRAME_X_DISPLAY (f), bar->x_window);
+  XMapWindow (FRAME_X_DISPLAY (f), bar->x_window);
+  /* Don't obscure any child frames.  */
+  XLowerWindow (FRAME_X_DISPLAY (f), bar->x_window);
 #endif /* not USE_TOOLKIT_SCROLL_BARS */
 
   unblock_input ();
@@ -7067,10 +7137,10 @@ x_scroll_bar_expose (struct scroll_bar *bar, const XEvent *event)
                   /* x, y, width, height */
                   0, 0, bar->width - 1, bar->height - 1);
 
-   /* Restore the foreground color of the GC if we changed it above.  */
-   if (f->output_data.x->scroll_bar_foreground_pixel != -1)
-     XSetForeground (FRAME_X_DISPLAY (f), gc,
-                     FRAME_FOREGROUND_PIXEL (f));
+  /* Restore the foreground color of the GC if we changed it above.  */
+  if (f->output_data.x->scroll_bar_foreground_pixel != -1)
+    XSetForeground (FRAME_X_DISPLAY (f), gc,
+                    FRAME_FOREGROUND_PIXEL (f));
 
    unblock_input ();
 
@@ -7839,8 +7909,21 @@ handle_one_xevent (struct x_display_info *dpyinfo,
       f = x_top_window_to_frame (dpyinfo, event->xreparent.window);
       if (f)
         {
-          f->output_data.x->parent_desc = event->xreparent.parent;
-          x_real_positions (f, &f->left_pos, &f->top_pos);
+          /* Maybe we shouldn't set this for child frames ??  */
+          f->output_data.x->parent_desc = event->xreparent.parent;
+          if (!FRAME_PARENT_FRAME (f))
+            x_real_positions (f, &f->left_pos, &f->top_pos);
+          else
+            {
+              Window root;
+              unsigned int dummy_uint;
+
+              block_input ();
+              XGetGeometry (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
+                            &root, &f->left_pos, &f->top_pos,
+                            &dummy_uint, &dummy_uint, &dummy_uint, &dummy_uint);
+              unblock_input ();
+            }
 
           /* Perhaps reparented due to a WM restart.  Reset this.  */
           FRAME_DISPLAY_INFO (f)->wm_type = X_WMTYPE_UNKNOWN;
@@ -7880,6 +7963,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                 event->xexpose.x, event->xexpose.y,
                 event->xexpose.width, event->xexpose.height,
                 0);
+              x_clear_under_internal_border (f);
 #endif
             }
 
@@ -7895,6 +7979,9 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 #endif
               expose_frame (f, event->xexpose.x, event->xexpose.y,
                             event->xexpose.width, event->xexpose.height);
+#ifdef USE_GTK
+              x_clear_under_internal_border (f);
+#endif
             }
 
           if (!FRAME_GARBAGED_P (f))
@@ -7943,7 +8030,10 @@ handle_one_xevent (struct x_display_info *dpyinfo,
                         event->xgraphicsexpose.y,
                         event->xgraphicsexpose.width,
                         event->xgraphicsexpose.height);
-          show_back_buffer (f);
+#ifdef USE_GTK
+          x_clear_under_internal_border (f);
+#endif
+          show_back_buffer (f);
         }
 #ifdef USE_X_TOOLKIT
       else
@@ -8000,7 +8090,26 @@ handle_one_xevent (struct x_display_info *dpyinfo,
           /* Check if fullscreen was specified before we where mapped the
              first time, i.e. from the command line.  */
           if (!f->output_data.x->has_been_visible)
-            x_check_fullscreen (f);
+            {
+
+              x_check_fullscreen (f);
+#ifndef USE_GTK
+              /* For systems that cannot synthesize `skip_taskbar' for
+                 unmapped windows do the following.  */
+              if (FRAME_SKIP_TASKBAR (f))
+                x_set_skip_taskbar (f, Qt, Qnil);
+#endif /* Not USE_GTK */
+            }
+
+          if (!iconified)
+            {
+              /* The `z-group' is reset every time a frame becomes
+                 invisible.  Handle this here.  */
+              if (FRAME_Z_GROUP (f) == z_group_above)
+                x_set_z_group (f, Qabove, Qnil);
+              else if (FRAME_Z_GROUP (f) == z_group_below)
+                x_set_z_group (f, Qbelow, Qnil);
+            }
 
           SET_FRAME_VISIBLE (f, 1);
           SET_FRAME_ICONIFIED (f, false);
@@ -8444,34 +8553,46 @@ handle_one_xevent (struct x_display_info *dpyinfo,
 #endif
         if (f)
           {
-
-            /* Generate SELECT_WINDOW_EVENTs when needed.
-               Don't let popup menus influence things (bug#1261).  */
-            if (!NILP (Vmouse_autoselect_window) && !popup_activated ())
+            /* Maybe generate a SELECT_WINDOW_EVENT for
+               `mouse-autoselect-window' but don't let popup menus
+               interfere with this (Bug#1261).  */
+            if (!NILP (Vmouse_autoselect_window)
+                && !popup_activated ()
+                /* Don't switch if we're currently in the minibuffer.
+                   This tries to work around problems where the
+                   minibuffer gets unselected unexpectedly, and where
+                   you then have to move your mouse all the way down to
+                   the minibuffer to select it.  */
+                && !MINI_WINDOW_P (XWINDOW (selected_window))
+                /* With `focus-follows-mouse' non-nil create an event
+                   also when the target window is on another frame.  */
+                && (f == XFRAME (selected_frame)
+                    || !NILP (focus_follows_mouse)))
               {
                 static Lisp_Object last_mouse_window;
                 Lisp_Object window = window_from_coordinates
                   (f, event->xmotion.x, event->xmotion.y, 0, false);
 
-                /* Window will be selected only when it is not selected now and
-                   last mouse movement event was not in it.  Minibuffer window
-                   will be selected only when it is active.  */
+                /* A window will be autoselected only when it is not
+                   selected now and the last mouse movement event was
+                   not in it.  The remainder of the code is a bit vague
+                   wrt what a "window" is.  For immediate autoselection,
+                   the window is usually the entire window but for GTK
+                   where the scroll bars don't count.  For delayed
+                   autoselection the window is usually the window's text
+                   area including the margins.  */
                 if (WINDOWP (window)
                     && !EQ (window, last_mouse_window)
-                    && !EQ (window, selected_window)
-                    /* For click-to-focus window managers
-                       create event iff we don't leave the
-                       selected frame.  */
-                    && (focus_follows_mouse
-                        || (EQ (XWINDOW (window)->frame,
-                                XWINDOW (selected_window)->frame))))
+                    && !EQ (window, selected_window))
                   {
                     inev.ie.kind = SELECT_WINDOW_EVENT;
                     inev.ie.frame_or_window = window;
                   }
+
                 /* Remember the last window where we saw the mouse.  */
                 last_mouse_window = window;
               }
+
             if (!note_mouse_movement (f, &event->xmotion))
               help_echo_string = previous_help_echo_string;
           }
@@ -8614,7 +8735,34 @@ handle_one_xevent (struct x_display_info *dpyinfo,
           if (FRAME_GTK_OUTER_WIDGET (f)
               && gtk_widget_get_mapped (FRAME_GTK_OUTER_WIDGET (f)))
 #endif
-            x_real_positions (f, &f->left_pos, &f->top_pos);
+            {
+              int old_left = f->left_pos;
+              int old_top = f->top_pos;
+              Lisp_Object frame = Qnil;
+
+              XSETFRAME (frame, f);
+
+              if (!FRAME_PARENT_FRAME (f))
+                x_real_positions (f, &f->left_pos, &f->top_pos);
+              else
+                {
+                  Window root;
+                  unsigned int dummy_uint;
+
+                  block_input ();
+                  XGetGeometry (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
+                                &root, &f->left_pos, &f->top_pos,
+                                &dummy_uint, &dummy_uint, &dummy_uint, &dummy_uint);
+                  unblock_input ();
+                }
+
+              if (old_left != f->left_pos || old_top != f->top_pos)
+                {
+                  inev.ie.kind = MOVE_FRAME_EVENT;
+                  XSETFRAME (inev.ie.frame_or_window, f);
+                }
+            }
+
 
 #ifdef HAVE_X_I18N
           if (FRAME_XIC (f) && (FRAME_XIC_STYLE (f) & XIMStatusArea))
@@ -8635,8 +8783,35 @@ handle_one_xevent (struct x_display_info *dpyinfo,
         dpyinfo->last_mouse_glyph_frame = NULL;
         x_display_set_last_user_time (dpyinfo, event->xbutton.time);
 
-        f = (x_mouse_grabbed (dpyinfo) ? dpyinfo->last_mouse_frame
-             : x_window_to_frame (dpyinfo, event->xbutton.window));
+        if (x_mouse_grabbed (dpyinfo))
+          f = dpyinfo->last_mouse_frame;
+        else
+          {
+            f = x_window_to_frame (dpyinfo, event->xbutton.window);
+
+            if (f && event->xbutton.type == ButtonPress
+                && !popup_activated ()
+                && !x_window_to_scroll_bar (event->xbutton.display,
+                                            event->xbutton.window, 2)
+                && !FRAME_NO_ACCEPT_FOCUS (f))
+              {
+                /* When clicking into a child frame or when clicking
+                   into a parent frame with the child frame selected and
+                   `no-accept-focus' is not set, select the clicked
+                   frame.  */
+                struct frame *hf = dpyinfo->x_highlight_frame;
+
+                if (FRAME_PARENT_FRAME (f) || (hf && frame_ancestor_p (f, hf)))
+                  {
+                    block_input ();
+                    XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
+                                    RevertToParent, CurrentTime);
+                    if (FRAME_PARENT_FRAME (f))
+                      XRaiseWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f));
+                    unblock_input ();
+                  }
+              }
+          }
 
 #ifdef USE_GTK
         if (f && xg_event_is_for_scrollbar (f, event))
@@ -8774,7 +8949,7 @@ handle_one_xevent (struct x_display_info *dpyinfo,
         {
         case MappingModifier:
           x_find_modifier_meanings (dpyinfo);
-          /* This is meant to fall through.  */
+          FALLTHROUGH;
         case MappingKeyboard:
           XRefreshKeyboardMapping ((XMappingEvent *) &event->xmapping);
         }
@@ -9992,6 +10167,7 @@ static void
 x_calc_absolute_position (struct frame *f)
 {
   int flags = f->size_hint_flags;
+  struct frame *p = FRAME_PARENT_FRAME (f);
 
   /* We have nothing to do if the current position
      is already for the top-left corner.  */
@@ -10000,32 +10176,72 @@ x_calc_absolute_position (struct frame *f)
 
   /* Treat negative positions as relative to the leftmost bottommost
      position that fits on the screen.  */
-  if (flags & XNegative)
-    f->left_pos = x_display_pixel_width (FRAME_DISPLAY_INFO (f))
-      - FRAME_PIXEL_WIDTH (f) + f->left_pos;
+  if ((flags & XNegative) && (f->left_pos <= 0))
+    {
+      int width = FRAME_PIXEL_WIDTH (f);
 
-  {
-    int height = FRAME_PIXEL_HEIGHT (f);
+      /* A frame that has been visible at least once should have outer
+         edges.  */
+      if (f->output_data.x->has_been_visible && !p)
+        {
+          Lisp_Object frame;
+          Lisp_Object edges = Qnil;
+
+          XSETFRAME (frame, f);
+          edges = Fx_frame_edges (frame, Qouter_edges);
+          if (!NILP (edges))
+            width = (XINT (Fnth (make_number (2), edges))
+                     - XINT (Fnth (make_number (0), edges)));
+        }
+
+      if (p)
+        f->left_pos = (FRAME_PIXEL_WIDTH (p) - width - 2 * f->border_width
+                       + f->left_pos);
+      else
+        f->left_pos = (x_display_pixel_width (FRAME_DISPLAY_INFO (f))
+                       - width + f->left_pos);
+
+    }
+
+  if ((flags & YNegative) && (f->top_pos <= 0))
+    {
+      int height = FRAME_PIXEL_HEIGHT (f);
 
 #if defined USE_X_TOOLKIT && defined USE_MOTIF
-    /* Something is fishy here.  When using Motif, starting Emacs with
-       `-g -0-0', the frame appears too low by a few pixels.
+      /* Something is fishy here.  When using Motif, starting Emacs with
+         `-g -0-0', the frame appears too low by a few pixels.
 
-       This seems to be so because initially, while Emacs is starting,
-       the column widget's height and the frame's pixel height are
-       different.  The column widget's height is the right one.  In
-       later invocations, when Emacs is up, the frame's pixel height
-       is right, though.
+         This seems to be so because initially, while Emacs is starting,
+         the column widget's height and the frame's pixel height are
+         different.  The column widget's height is the right one.  In
+         later invocations, when Emacs is up, the frame's pixel height
+         is right, though.
 
-       It's not obvious where the initial small difference comes from.
-       2000-12-01, gerd.  */
+         It's not obvious where the initial small difference comes from.
+         2000-12-01, gerd.  */
 
-    XtVaGetValues (f->output_data.x->column_widget, XtNheight, &height, NULL);
+      XtVaGetValues (f->output_data.x->column_widget, XtNheight, &height, NULL);
 #endif
 
-    if (flags & YNegative)
-      f->top_pos = x_display_pixel_height (FRAME_DISPLAY_INFO (f))
-        - height + f->top_pos;
+      if (f->output_data.x->has_been_visible && !p)
+        {
+          Lisp_Object frame;
+          Lisp_Object edges = Qnil;
+
+          XSETFRAME (frame, f);
+          if (NILP (edges))
+            edges = Fx_frame_edges (frame, Qouter_edges);
+          if (!NILP (edges))
+            height = (XINT (Fnth (make_number (3), edges))
+                      - XINT (Fnth (make_number (1), edges)));
+        }
+
+      if (p)
+        f->top_pos = (FRAME_PIXEL_HEIGHT (p) - height - 2 * f->border_width
+                       + f->top_pos);
+      else
+        f->top_pos = (x_display_pixel_height (FRAME_DISPLAY_INFO (f))
+                      - height + f->top_pos);
   }
 
   /* The left_pos and top_pos
@@ -10088,8 +10304,13 @@ x_set_offset (struct frame *f, register int xoff, register int yoff, int change_
       modified_top += FRAME_X_OUTPUT (f)->move_offset_top;
     }
 
+#ifdef USE_GTK
+  gtk_window_move (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
+                   modified_left, modified_top);
+#else
   XMoveWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
-               modified_left, modified_top);
+               modified_left, modified_top);
+#endif
 
   x_sync_with_move (f, f->left_pos, f->top_pos,
                     FRAME_DISPLAY_INFO (f)->wm_type == X_WMTYPE_UNKNOWN);
@@ -10105,6 +10326,7 @@ x_set_offset (struct frame *f, register int xoff, register int yoff, int change_
      need to compute the top/left offset adjustment for this frame.  */
 
   if (change_gravity != 0
+      && !FRAME_PARENT_FRAME (f)
       && (FRAME_DISPLAY_INFO (f)->wm_type == X_WMTYPE_UNKNOWN
           || (FRAME_DISPLAY_INFO (f)->wm_type == X_WMTYPE_A
               && (FRAME_X_OUTPUT (f)->move_offset_left == 0
@@ -10235,6 +10457,92 @@ x_set_sticky (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
                 dpyinfo->Xatom_net_wm_state_sticky, None);
 }
 
+/**
+ * x_set_skip_taskbar:
+ *
+ * Set frame F's `skip-taskbar' parameter.  If non-nil, this should
+ * remove F's icon from the taskbar associated with the display of F's
+ * window-system window and inhibit switching to F's window via
+ * <Alt>-<TAB>.  If nil, lift these restrictions.
+ *
+ * Some window managers may not honor this parameter.
+ */
+void
+x_set_skip_taskbar (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  if (!EQ (new_value, old_value))
+    {
+#ifdef USE_GTK
+      xg_set_skip_taskbar (f, new_value);
+#else
+      Lisp_Object frame;
+      struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
+
+      XSETFRAME (frame, f);
+      set_wm_state (frame, !NILP (new_value),
+                    dpyinfo->Xatom_net_wm_state_skip_taskbar, None);
+#endif /* USE_GTK */
+      FRAME_SKIP_TASKBAR (f) = !NILP (new_value);
+    }
+}
+
+/**
+ * x_set_z_group:
+ *
+ * Set frame F's `z-group' parameter.  If `above', F's window-system
+ * window is displayed above all windows that do not have the `above'
+ * property set.  If nil, F's window is shown below all windows that
+ * have the `above' property set and above all windows that have the
+ * `below' property set.  If `below', F's window is displayed below all
+ * windows that do not have the `below' property set.
+ *
+ * Some window managers may not honor this parameter.
+ */
+void
+x_set_z_group (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
+{
+  /* We don't care about old_value.  The window manager might have
+     reset the value without telling us.  */
+  Lisp_Object frame;
+  struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
+
+  XSETFRAME (frame, f);
+
+  if (NILP (new_value))
+    {
+      set_wm_state (frame, false,
+                    dpyinfo->Xatom_net_wm_state_above, None);
+      set_wm_state (frame, false,
+                    dpyinfo->Xatom_net_wm_state_below, None);
+      FRAME_Z_GROUP (f) = z_group_none;
+    }
+  else if (EQ (new_value, Qabove))
+    {
+      set_wm_state (frame, true,
+                    dpyinfo->Xatom_net_wm_state_above, None);
+      set_wm_state (frame, false,
+                    dpyinfo->Xatom_net_wm_state_below, None);
+      FRAME_Z_GROUP (f) = z_group_above;
+    }
+  else if (EQ (new_value, Qbelow))
+    {
+      set_wm_state (frame, false,
+                    dpyinfo->Xatom_net_wm_state_above, None);
+      set_wm_state (frame, true,
+                    dpyinfo->Xatom_net_wm_state_below, None);
+      FRAME_Z_GROUP (f) = z_group_below;
+    }
+  else if (EQ (new_value, Qabove_suspended))
+    {
+      set_wm_state (frame, false,
+                    dpyinfo->Xatom_net_wm_state_above, None);
+      FRAME_Z_GROUP (f) = z_group_above_suspended;
+    }
+  else
+    error ("Invalid z-group specification");
+}
+
+
 /* Return the current _NET_WM_STATE.
    SIZE_STATE is set to one of the FULLSCREEN_* values.
    Set *STICKY to the sticky state.
@@ -10738,7 +11046,8 @@ x_set_window_size_1 (struct frame *f, bool change_gravity,
   int old_height = FRAME_PIXEL_HEIGHT (f);
   Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
 
-  if (change_gravity) f->win_gravity = NorthWestGravity;
+  if (change_gravity)
+    f->win_gravity = NorthWestGravity;
   x_wm_set_size_hint (f, 0, false);
 
   /* When the frame is fullheight and we only want to change the width
@@ -11027,6 +11336,26 @@ xembed_send_message (struct frame *f, Time t, enum xembed_message msg,
 void
 x_make_frame_visible (struct frame *f)
 {
+  if (FRAME_PARENT_FRAME (f))
+    {
+      if (!FRAME_VISIBLE_P (f))
+        {
+          block_input ();
+#ifdef USE_GTK
+          gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f));
+          XMoveWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
+                       f->left_pos, f->top_pos);
+#else
+          XMapRaised (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f));
+#endif
+          unblock_input ();
+
+          SET_FRAME_VISIBLE (f, true);
+          SET_FRAME_ICONIFIED (f, false);
+        }
+      return;
+    }
+
   block_input ();
 
   x_set_bitmap_icon (f);
@@ -11095,9 +11424,10 @@ x_make_frame_visible (struct frame *f)
        because the window manager may choose the position
        and we don't want to override it.  */
 
-    if (! FRAME_VISIBLE_P (f)
-        && ! FRAME_ICONIFIED_P (f)
-        && ! FRAME_X_EMBEDDED_P (f)
+    if (!FRAME_VISIBLE_P (f)
+        && !FRAME_ICONIFIED_P (f)
+        && !FRAME_X_EMBEDDED_P (f)
+        && !FRAME_PARENT_FRAME (f)
         && f->win_gravity == NorthWestGravity
         && previously_visible)
       {
@@ -11160,15 +11490,15 @@ x_make_frame_invisible (struct frame *f)
     xembed_set_info (f, 0);
   else
 #endif
-  {
 
-  if (! XWithdrawWindow (FRAME_X_DISPLAY (f), window,
-                         DefaultScreen (FRAME_X_DISPLAY (f))))
-    {
-      unblock_input ();
-      error ("Can't notify window manager of window withdrawal");
-    }
-  }
+    if (! XWithdrawWindow (FRAME_X_DISPLAY (f), window,
+                           DefaultScreen (FRAME_X_DISPLAY (f))))
+      {
+        unblock_input ();
+        error ("Can't notify window manager of window withdrawal");
+      }
+
+  x_sync (f);
 
   /* We can't distinguish this from iconification
      just by the event that we get from the server.
@@ -11178,8 +11508,6 @@ x_make_frame_invisible (struct frame *f)
   SET_FRAME_VISIBLE (f, 0);
   SET_FRAME_ICONIFIED (f, false);
 
-  x_sync (f);
-
   unblock_input ();
 }
 
@@ -11429,6 +11757,22 @@ x_free_frame_resources (struct frame *f)
         XFreeCursor (FRAME_X_DISPLAY (f), f->output_data.x->horizontal_drag_cursor);
       if (f->output_data.x->vertical_drag_cursor != 0)
         XFreeCursor (FRAME_X_DISPLAY (f), f->output_data.x->vertical_drag_cursor);
+      if (f->output_data.x->left_edge_cursor != 0)
+        XFreeCursor (FRAME_X_DISPLAY (f), f->output_data.x->left_edge_cursor);
+      if (f->output_data.x->top_left_corner_cursor != 0)
+        XFreeCursor (FRAME_X_DISPLAY (f), f->output_data.x->top_left_corner_cursor);
+      if (f->output_data.x->top_edge_cursor != 0)
+        XFreeCursor (FRAME_X_DISPLAY (f), f->output_data.x->top_edge_cursor);
+      if (f->output_data.x->top_right_corner_cursor != 0)
+        XFreeCursor (FRAME_X_DISPLAY (f), f->output_data.x->top_right_corner_cursor);
+      if (f->output_data.x->right_edge_cursor != 0)
+        XFreeCursor (FRAME_X_DISPLAY (f), f->output_data.x->right_edge_cursor);
+      if (f->output_data.x->bottom_right_corner_cursor != 0)
+        XFreeCursor (FRAME_X_DISPLAY (f), f->output_data.x->bottom_right_corner_cursor);
+      if (f->output_data.x->bottom_edge_cursor != 0)
+        XFreeCursor (FRAME_X_DISPLAY (f), f->output_data.x->bottom_edge_cursor);
+      if (f->output_data.x->bottom_left_corner_cursor != 0)
+        XFreeCursor (FRAME_X_DISPLAY (f), f->output_data.x->bottom_left_corner_cursor);
 
       XFlush (FRAME_X_DISPLAY (f));
     }
@@ -12335,6 +12679,9 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
       ATOM_REFS_INIT ("SM_CLIENT_ID", Xatom_SM_CLIENT_ID)
       ATOM_REFS_INIT ("_XSETTINGS_SETTINGS", Xatom_xsettings_prop)
       ATOM_REFS_INIT ("MANAGER", Xatom_xsettings_mgr)
+      ATOM_REFS_INIT ("_NET_WM_STATE_SKIP_TASKBAR", Xatom_net_wm_state_skip_taskbar)
+      ATOM_REFS_INIT ("_NET_WM_STATE_ABOVE", Xatom_net_wm_state_above)
+      ATOM_REFS_INIT ("_NET_WM_STATE_BELOW", Xatom_net_wm_state_below)
     };
 
     int i;
@@ -12923,8 +13270,8 @@ transition between the various maximization states.  */);
 
   DEFVAR_BOOL ("x-gtk-use-window-move", x_gtk_use_window_move,
     doc: /* Non-nil means rely on gtk_window_move to set frame positions.
-If this variable is t, the GTK build uses the function gtk_window_move
-to set or store frame positions and disables some time consuming frame
-position adjustments.  */);
-  x_gtk_use_window_move = false;
+If this variable is t (the default), the GTK build uses the function
+gtk_window_move to set or store frame positions and disables some time
+consuming frame position adjustments.  */);
+  x_gtk_use_window_move = true;
 }
diff --git a/src/xterm.h b/src/xterm.h
index 32c879bcdca..803feda99f3 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -447,9 +447,9 @@ struct x_display_info
   /* Atoms dealing with EWMH (i.e. _NET_...) */
   Atom Xatom_net_wm_state, Xatom_net_wm_state_fullscreen,
     Xatom_net_wm_state_maximized_horz, Xatom_net_wm_state_maximized_vert,
-    Xatom_net_wm_state_sticky, Xatom_net_wm_state_hidden,
-    Xatom_net_frame_extents,
-    Xatom_net_current_desktop, Xatom_net_workarea;
+    Xatom_net_wm_state_sticky, Xatom_net_wm_state_above, Xatom_net_wm_state_below,
+    Xatom_net_wm_state_hidden, Xatom_net_wm_state_skip_taskbar,
+    Xatom_net_frame_extents, Xatom_net_current_desktop, Xatom_net_workarea;
 
   /* XSettings atoms and windows.  */
   Atom Xatom_xsettings_sel, Xatom_xsettings_prop, Xatom_xsettings_mgr;
@@ -637,6 +637,14 @@ struct x_output
   Cursor horizontal_drag_cursor;
   Cursor vertical_drag_cursor;
   Cursor current_cursor;
+  Cursor left_edge_cursor;
+  Cursor top_left_corner_cursor;
+  Cursor top_edge_cursor;
+  Cursor top_right_corner_cursor;
+  Cursor right_edge_cursor;
+  Cursor bottom_right_corner_cursor;
+  Cursor bottom_edge_cursor;
+  Cursor bottom_left_corner_cursor;
 
   /* Window whose cursor is hourglass_cursor.  This window is temporarily
      mapped to display an hourglass cursor.  */
@@ -1168,6 +1176,8 @@ x_mutable_colormap (Visual *visual)
 }
 
 extern void x_set_sticky (struct frame *, Lisp_Object, Lisp_Object);
+extern void x_set_skip_taskbar (struct frame *, Lisp_Object, Lisp_Object);
+extern void x_set_z_group (struct frame *, Lisp_Object, Lisp_Object);
 extern bool x_wm_supports (struct frame *, Atom);
 extern void x_wait_for_event (struct frame *, int);
 extern void x_clear_under_internal_border (struct frame *f);