Merge remote-tracking branch 'savannah/master' into HEAD

29 files changed, 354 insertions, 145 deletions

diff --git a/src/data.c b/src/data.c
index 85c73b406c4..3f035269de1 100644
--- a/src/data.c
+++ b/src/data.c
@@ -966,6 +966,15 @@ Value, if non-nil, is a list (interactive SPEC).  */)
       if (PVSIZE (fun) > COMPILED_INTERACTIVE)
         return list2 (Qinteractive, AREF (fun, COMPILED_INTERACTIVE));
     }
+#ifdef HAVE_MODULES
+  else if (MODULE_FUNCTIONP (fun))
+    {
+      Lisp_Object form
+        = module_function_interactive_form (XMODULE_FUNCTION (fun));
+      if (! NILP (form))
+        return form;
+    }
+#endif
   else if (AUTOLOADP (fun))
     return Finteractive_form (Fautoload_do_load (fun, cmd, Qnil));
   else if (CONSP (fun))
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 02af244ac38..4c5ab485803 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -129,36 +129,23 @@ static bool xd_in_read_queued_messages = 0;
 #define XD_BASIC_DBUS_TYPE(type)                                        \
   (dbus_type_is_valid (type) && dbus_type_is_basic (type))
 #else
-#ifdef DBUS_TYPE_UNIX_FD
-#define XD_BASIC_DBUS_TYPE(type)                                        \
-  ((type ==  DBUS_TYPE_BYTE)                                            \
-   || (type ==  DBUS_TYPE_BOOLEAN)                                      \
-   || (type ==  DBUS_TYPE_INT16)                                        \
-   || (type ==  DBUS_TYPE_UINT16)                                       \
-   || (type ==  DBUS_TYPE_INT32)                                        \
-   || (type ==  DBUS_TYPE_UINT32)                                       \
-   || (type ==  DBUS_TYPE_INT64)                                        \
-   || (type ==  DBUS_TYPE_UINT64)                                       \
-   || (type ==  DBUS_TYPE_DOUBLE)                                       \
-   || (type ==  DBUS_TYPE_STRING)                                       \
-   || (type ==  DBUS_TYPE_OBJECT_PATH)                                  \
-   || (type ==  DBUS_TYPE_SIGNATURE)                                    \
-   || (type ==  DBUS_TYPE_UNIX_FD))
-#else
 #define XD_BASIC_DBUS_TYPE(type)                                        \
-  ((type ==  DBUS_TYPE_BYTE)                                            \
-   || (type ==  DBUS_TYPE_BOOLEAN)                                      \
-   || (type ==  DBUS_TYPE_INT16)                                        \
-   || (type ==  DBUS_TYPE_UINT16)                                       \
-   || (type ==  DBUS_TYPE_INT32)                                        \
-   || (type ==  DBUS_TYPE_UINT32)                                       \
-   || (type ==  DBUS_TYPE_INT64)                                        \
-   || (type ==  DBUS_TYPE_UINT64)                                       \
-   || (type ==  DBUS_TYPE_DOUBLE)                                       \
-   || (type ==  DBUS_TYPE_STRING)                                       \
-   || (type ==  DBUS_TYPE_OBJECT_PATH)                                  \
-   || (type ==  DBUS_TYPE_SIGNATURE))
+  ((type == DBUS_TYPE_BYTE)                                             \
+   || (type == DBUS_TYPE_BOOLEAN)                                       \
+   || (type == DBUS_TYPE_INT16)                                         \
+   || (type == DBUS_TYPE_UINT16)                                        \
+   || (type == DBUS_TYPE_INT32)                                         \
+   || (type == DBUS_TYPE_UINT32)                                        \
+   || (type == DBUS_TYPE_INT64)                                         \
+   || (type == DBUS_TYPE_UINT64)                                        \
+   || (type == DBUS_TYPE_DOUBLE)                                        \
+   || (type == DBUS_TYPE_STRING)                                        \
+   || (type == DBUS_TYPE_OBJECT_PATH)                                   \
+   || (type == DBUS_TYPE_SIGNATURE)                                     \
+#ifdef DBUS_TYPE_UNIX_FD
+   || (type == DBUS_TYPE_UNIX_FD)                                       \
 #endif
+   )
 #endif
 
 /* This was a macro.  On Solaris 2.11 it was said to compile for
@@ -192,6 +179,33 @@ xd_symbol_to_dbus_type (Lisp_Object object)
      : DBUS_TYPE_INVALID);
 }
 
+/* Determine the Lisp symbol of DBusType.  */
+static Lisp_Object
+xd_dbus_type_to_symbol (int type)
+{
+  return
+    (type == DBUS_TYPE_BYTE) ? QCbyte
+    : (type == DBUS_TYPE_BOOLEAN) ? QCboolean
+    : (type == DBUS_TYPE_INT16) ? QCint16
+    : (type == DBUS_TYPE_UINT16) ? QCuint16
+    : (type == DBUS_TYPE_INT32) ? QCint32
+    : (type == DBUS_TYPE_UINT32) ? QCuint32
+    : (type == DBUS_TYPE_INT64) ? QCint64
+    : (type == DBUS_TYPE_UINT64) ? QCuint64
+    : (type == DBUS_TYPE_DOUBLE) ? QCdouble
+    : (type == DBUS_TYPE_STRING) ? QCstring
+    : (type == DBUS_TYPE_OBJECT_PATH) ? QCobject_path
+    : (type == DBUS_TYPE_SIGNATURE) ? QCsignature
+#ifdef DBUS_TYPE_UNIX_FD
+    : (type == DBUS_TYPE_UNIX_FD) ? QCunix_fd
+#endif
+    : (type == DBUS_TYPE_ARRAY) ? QCarray
+    : (type == DBUS_TYPE_VARIANT) ? QCvariant
+    : (type == DBUS_TYPE_STRUCT) ? QCstruct
+    : (type ==  DBUS_TYPE_DICT_ENTRY) ? QCdict_entry
+    : Qnil;
+}
+
 /* Check whether a Lisp symbol is a predefined D-Bus type symbol.  */
 #define XD_DBUS_TYPE_P(object)                                          \
   (SYMBOLP (object) && ((xd_symbol_to_dbus_type (object) != DBUS_TYPE_INVALID)))
@@ -360,8 +374,8 @@ xd_signature (char *signature, int dtype, int parent_type, Lisp_Object object)
       break;
 
     case DBUS_TYPE_BOOLEAN:
-      if (!EQ (object, Qt) && !NILP (object))
-        wrong_type_argument (intern ("booleanp"), object);
+      /* Any non-nil object will be regarded as `t', so we don't apply
+         further type check.  */
       sprintf (signature, "%c", dtype);
       break;
 
@@ -816,7 +830,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
         dbus_message_iter_get_basic (iter, &val);
         val = val & 0xFF;
         XD_DEBUG_MESSAGE ("%c %u", dtype, val);
-        return make_fixnum (val);
+        return list2 (xd_dbus_type_to_symbol (dtype), make_fixnum (val));
       }
 
     case DBUS_TYPE_BOOLEAN:
@@ -824,7 +838,8 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
         dbus_bool_t val;
         dbus_message_iter_get_basic (iter, &val);
         XD_DEBUG_MESSAGE ("%c %s", dtype, (val == FALSE) ? "false" : "true");
-        return (val == FALSE) ? Qnil : Qt;
+        return list2 (xd_dbus_type_to_symbol (dtype),
+                      (val == FALSE) ? Qnil : Qt);
       }
 
     case DBUS_TYPE_INT16:
@@ -834,7 +849,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
         dbus_message_iter_get_basic (iter, &val);
         pval = val;
         XD_DEBUG_MESSAGE ("%c %d", dtype, pval);
-        return make_fixnum (val);
+        return list2 (xd_dbus_type_to_symbol (dtype), make_fixnum (val));
       }
 
     case DBUS_TYPE_UINT16:
@@ -844,7 +859,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
         dbus_message_iter_get_basic (iter, &val);
         pval = val;
         XD_DEBUG_MESSAGE ("%c %d", dtype, pval);
-        return make_fixnum (val);
+        return list2 (xd_dbus_type_to_symbol (dtype), make_fixnum (val));
       }
 
     case DBUS_TYPE_INT32:
@@ -854,7 +869,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
         dbus_message_iter_get_basic (iter, &val);
         pval = val;
         XD_DEBUG_MESSAGE ("%c %d", dtype, pval);
-        return INT_TO_INTEGER (val);
+        return list2 (xd_dbus_type_to_symbol (dtype), INT_TO_INTEGER (val));
       }
 
     case DBUS_TYPE_UINT32:
@@ -867,7 +882,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
         dbus_message_iter_get_basic (iter, &val);
         pval = val;
         XD_DEBUG_MESSAGE ("%c %u", dtype, pval);
-        return INT_TO_INTEGER (val);
+        return list2 (xd_dbus_type_to_symbol (dtype), INT_TO_INTEGER (val));
       }
 
     case DBUS_TYPE_INT64:
@@ -876,7 +891,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
         dbus_message_iter_get_basic (iter, &val);
         intmax_t pval = val;
         XD_DEBUG_MESSAGE ("%c %"PRIdMAX, dtype, pval);
-        return INT_TO_INTEGER (val);
+        return list2 (xd_dbus_type_to_symbol (dtype), INT_TO_INTEGER (val));
       }
 
     case DBUS_TYPE_UINT64:
@@ -885,7 +900,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
         dbus_message_iter_get_basic (iter, &val);
         uintmax_t pval = val;
         XD_DEBUG_MESSAGE ("%c %"PRIuMAX, dtype, pval);
-        return INT_TO_INTEGER (val);
+        return list2 (xd_dbus_type_to_symbol (dtype), INT_TO_INTEGER (val));
       }
 
     case DBUS_TYPE_DOUBLE:
@@ -893,7 +908,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
         double val;
         dbus_message_iter_get_basic (iter, &val);
         XD_DEBUG_MESSAGE ("%c %f", dtype, val);
-        return make_float (val);
+        return list2 (xd_dbus_type_to_symbol (dtype), make_float (val));
       }
 
     case DBUS_TYPE_STRING:
@@ -903,7 +918,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
         char *val;
         dbus_message_iter_get_basic (iter, &val);
         XD_DEBUG_MESSAGE ("%c %s", dtype, val);
-        return build_string (val);
+        return list2 (xd_dbus_type_to_symbol (dtype), build_string (val));
       }
 
     case DBUS_TYPE_ARRAY:
@@ -923,7 +938,7 @@ xd_retrieve_arg (int dtype, DBusMessageIter *iter)
             dbus_message_iter_next (&subiter);
           }
         XD_DEBUG_MESSAGE ("%c %s", dtype, XD_OBJECT_TO_STRING (result));
-        return Fnreverse (result);
+        return Fcons (xd_dbus_type_to_symbol (dtype), Fnreverse (result));
       }
 
     default:
@@ -1254,6 +1269,10 @@ The following usages are expected:
   (dbus-message-internal
     dbus-message-type-error BUS SERVICE SERIAL ERROR-NAME &rest ARGS)
 
+`dbus-check-arguments': (does not send a message)
+  (dbus-message-internal
+    dbus-message-type-invalid BUS SERVICE &rest ARGS)
+
 usage: (dbus-message-internal &rest REST)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
@@ -1271,7 +1290,7 @@ usage: (dbus-message-internal &rest REST)  */)
   dbus_uint32_t serial = 0;
   unsigned int ui_serial;
   int timeout = -1;
-  ptrdiff_t count;
+  ptrdiff_t count, count0;
   char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
 
   /* Initialize parameters.  */
@@ -1281,7 +1300,7 @@ usage: (dbus-message-internal &rest REST)  */)
   handler = Qnil;
 
   CHECK_FIXNAT (message_type);
-  if (! (DBUS_MESSAGE_TYPE_INVALID < XFIXNAT (message_type)
+  if (! (DBUS_MESSAGE_TYPE_INVALID <= XFIXNAT (message_type)
          && XFIXNAT (message_type) < DBUS_NUM_MESSAGE_TYPES))
     XD_SIGNAL2 (build_string ("Invalid message type"), message_type);
   mtype = XFIXNAT (message_type);
@@ -1296,13 +1315,16 @@ usage: (dbus-message-internal &rest REST)  */)
         handler = args[6];
       count = (mtype == DBUS_MESSAGE_TYPE_METHOD_CALL) ? 7 : 6;
     }
-  else /* DBUS_MESSAGE_TYPE_METHOD_RETURN, DBUS_MESSAGE_TYPE_ERROR  */
+  else if ((mtype == DBUS_MESSAGE_TYPE_METHOD_RETURN)
+           || (mtype == DBUS_MESSAGE_TYPE_ERROR))
     {
       serial = xd_extract_unsigned (args[3], TYPE_MAXIMUM (dbus_uint32_t));
       if (mtype == DBUS_MESSAGE_TYPE_ERROR)
         error_name = args[4];
       count = (mtype == DBUS_MESSAGE_TYPE_ERROR) ? 5 : 4;
     }
+  else /* DBUS_MESSAGE_TYPE_INVALID  */
+    count = 3;
 
   /* Check parameters.  */
   XD_DBUS_VALIDATE_BUS_ADDRESS (bus);
@@ -1352,7 +1374,7 @@ usage: (dbus-message-internal &rest REST)  */)
                         XD_OBJECT_TO_STRING (service),
                         ui_serial);
        break;
-    default: /* DBUS_MESSAGE_TYPE_ERROR  */
+    case DBUS_MESSAGE_TYPE_ERROR:
       ui_serial = serial;
       XD_DEBUG_MESSAGE ("%s %s %s %u %s",
                         XD_MESSAGE_TYPE_TO_STRING (mtype),
@@ -1360,17 +1382,25 @@ usage: (dbus-message-internal &rest REST)  */)
                         XD_OBJECT_TO_STRING (service),
                         ui_serial,
                         XD_OBJECT_TO_STRING (error_name));
+      break;
+    default: /* DBUS_MESSAGE_TYPE_INVALID  */
+      XD_DEBUG_MESSAGE ("%s %s %s",
+                        XD_MESSAGE_TYPE_TO_STRING (mtype),
+                        XD_OBJECT_TO_STRING (bus),
+                        XD_OBJECT_TO_STRING (service));
     }
 
   /* Retrieve bus address.  */
   connection = xd_get_connection_address (bus);
 
-  /* Create the D-Bus message.  */
-  dmessage = dbus_message_new (mtype);
+  /* Create the D-Bus message.  Since DBUS_MESSAGE_TYPE_INVALID is not
+     a valid message type, we mockup it with DBUS_MESSAGE_TYPE_SIGNAL.  */
+  dmessage = dbus_message_new
+    ((mtype == DBUS_MESSAGE_TYPE_INVALID) ? DBUS_MESSAGE_TYPE_SIGNAL : mtype);
   if (dmessage == NULL)
     XD_SIGNAL1 (build_string ("Unable to create a new message"));
 
-  if (STRINGP (service))
+  if ((STRINGP (service)) && (mtype != DBUS_MESSAGE_TYPE_INVALID))
     {
       if (mtype != DBUS_MESSAGE_TYPE_SIGNAL)
         /* Set destination.  */
@@ -1412,7 +1442,8 @@ usage: (dbus-message-internal &rest REST)  */)
         XD_SIGNAL1 (build_string ("Unable to set the message parameter"));
     }
 
-  else /* DBUS_MESSAGE_TYPE_METHOD_RETURN, DBUS_MESSAGE_TYPE_ERROR  */
+  else if ((mtype == DBUS_MESSAGE_TYPE_METHOD_RETURN)
+           || (mtype == DBUS_MESSAGE_TYPE_ERROR))
     {
       if (!dbus_message_set_reply_serial (dmessage, serial))
         XD_SIGNAL1 (build_string ("Unable to create a return message"));
@@ -1434,6 +1465,7 @@ usage: (dbus-message-internal &rest REST)  */)
   dbus_message_iter_init_append (dmessage, &iter);
 
   /* Append parameters to the message.  */
+  count0 = count - 1;
   for (; count < nargs; ++count)
     {
       dtype = XD_OBJECT_TO_DBUS_TYPE (args[count]);
@@ -1441,15 +1473,17 @@ usage: (dbus-message-internal &rest REST)  */)
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[count]);
           XD_DEBUG_VALID_LISP_OBJECT_P (args[count+1]);
-          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", count - 4,
+          XD_DEBUG_MESSAGE ("Parameter%"pD"d: %s Parameter%"pD"d: %s",
+                            count - count0,
                             XD_OBJECT_TO_STRING (args[count]),
+                            count + 1 - count0,
                             XD_OBJECT_TO_STRING (args[count+1]));
           ++count;
         }
       else
         {
           XD_DEBUG_VALID_LISP_OBJECT_P (args[count]);
-          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", count - 4,
+          XD_DEBUG_MESSAGE ("Parameter%"pD"d: %s", count - count0,
                             XD_OBJECT_TO_STRING (args[count]));
         }
 
@@ -1460,7 +1494,10 @@ usage: (dbus-message-internal &rest REST)  */)
       xd_append_arg (dtype, args[count], &iter);
     }
 
-  if (!NILP (handler))
+  if (mtype == DBUS_MESSAGE_TYPE_INVALID)
+    result = Qt;
+
+  else if (!NILP (handler))
     {
       /* Send the message.  The message is just added to the outgoing
          message queue.  */
@@ -1485,7 +1522,8 @@ usage: (dbus-message-internal &rest REST)  */)
       result = Qnil;
     }
 
-  XD_DEBUG_MESSAGE ("Message sent: %s", XD_OBJECT_TO_STRING (result));
+  if (mtype != DBUS_MESSAGE_TYPE_INVALID)
+    XD_DEBUG_MESSAGE ("Message sent: %s", XD_OBJECT_TO_STRING (result));
 
   /* Cleanup.  */
   dbus_message_unref (dmessage);
@@ -1533,7 +1571,7 @@ xd_read_message_1 (DBusConnection *connection, Lisp_Object bus)
     }
 
   /* Read message type, message serial, unique name, object path,
-     interface and member from the message.  */
+     interface, member and error name from the message.  */
   mtype = dbus_message_get_type (dmessage);
   ui_serial = serial =
     ((mtype == DBUS_MESSAGE_TYPE_METHOD_RETURN)
@@ -1544,7 +1582,7 @@ xd_read_message_1 (DBusConnection *connection, Lisp_Object bus)
   path = dbus_message_get_path (dmessage);
   interface = dbus_message_get_interface (dmessage);
   member = dbus_message_get_member (dmessage);
-  error_name =dbus_message_get_error_name (dmessage);
+  error_name = dbus_message_get_error_name (dmessage);
 
   XD_DEBUG_MESSAGE ("Event received: %s %u %s %s %s %s %s %s",
                     XD_MESSAGE_TYPE_TO_STRING (mtype),
@@ -1572,9 +1610,11 @@ xd_read_message_1 (DBusConnection *connection, Lisp_Object bus)
       EVENT_INIT (event);
       event.kind = DBUS_EVENT;
       event.frame_or_window = Qnil;
-      event.arg = Fcons (value,
-                         (mtype == DBUS_MESSAGE_TYPE_ERROR)
-                         ? (Fcons (build_string (error_name), args)) : args);
+      event.arg =
+        Fcons (value,
+               (mtype == DBUS_MESSAGE_TYPE_ERROR)
+               ? Fcons (list2 (QCstring, build_string (error_name)), args)
+               : args);
     }
 
   else /* DBUS_MESSAGE_TYPE_METHOD_CALL, DBUS_MESSAGE_TYPE_SIGNAL.  */
@@ -1828,7 +1868,7 @@ wildcard then.
 
 OBJECT is either the handler to be called when a D-Bus message, which
 matches the key criteria, arrives (TYPE `:method' and `:signal'), or a
-list (ACCESS EMITS-SIGNAL SIGNATURE VALUE) for TYPE `:property'.
+list (ACCESS EMITS-SIGNAL VALUE) for TYPE `:property'.
 
 For entries of type `:signal', there is also a fifth element RULE,
 which keeps the match string the signal is registered with.
diff --git a/src/dispextern.h b/src/dispextern.h
index 956ca96eb61..0d982f79177 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -102,7 +102,7 @@ typedef XImage *Emacs_Pix_Context;
 #endif
 
 #ifdef USE_CAIRO
-/* Mininal version of XImage.  */
+/* Minimal version of XImage.  */
 typedef struct
 {
   int width, height;            /* size of image */
@@ -1744,6 +1744,7 @@ struct face
   bool_bf tty_italic_p : 1;
   bool_bf tty_underline_p : 1;
   bool_bf tty_reverse_p : 1;
+  bool_bf tty_strike_through_p : 1;
 
   /* True means that colors of this face may not be freed because they
      have been copied bitwise from a base face (see
@@ -3290,6 +3291,7 @@ enum tool_bar_item_image
 #define TTY_CAP_BOLD            0x04
 #define TTY_CAP_DIM             0x08
 #define TTY_CAP_ITALIC          0x10
+#define TTY_CAP_STRIKE_THROUGH  0x20
 
 
 /***********************************************************************
diff --git a/src/emacs-module.c b/src/emacs-module.c
index a0bab118019..3581daad112 100644
--- a/src/emacs-module.c
+++ b/src/emacs-module.c
@@ -551,7 +551,7 @@ struct Lisp_Module_Function
   union vectorlike_header header;
 
   /* Fields traced by GC; these must come first.  */
-  Lisp_Object documentation;
+  Lisp_Object documentation, interactive_form;
 
   /* Fields ignored by GC.  */
   ptrdiff_t min_arity, max_arity;
@@ -564,7 +564,7 @@ static struct Lisp_Module_Function *
 allocate_module_function (void)
 {
   return ALLOCATE_PSEUDOVECTOR (struct Lisp_Module_Function,
-                                documentation, PVEC_MODULE_FUNCTION);
+                                interactive_form, PVEC_MODULE_FUNCTION);
 }
 
 #define XSET_MODULE_FUNCTION(var, ptr) \
@@ -630,6 +630,24 @@ module_finalize_function (const struct Lisp_Module_Function *func)
     func->finalizer (func->data);
 }
 
+static void
+module_make_interactive (emacs_env *env, emacs_value function, emacs_value spec)
+{
+  MODULE_FUNCTION_BEGIN ();
+  Lisp_Object lisp_fun = value_to_lisp (function);
+  CHECK_MODULE_FUNCTION (lisp_fun);
+  Lisp_Object lisp_spec = value_to_lisp (spec);
+  /* Normalize (interactive nil) to (interactive). */
+  XMODULE_FUNCTION (lisp_fun)->interactive_form
+    = NILP (lisp_spec) ? list1 (Qinteractive) : list2 (Qinteractive, lisp_spec);
+}
+
+Lisp_Object
+module_function_interactive_form (const struct Lisp_Module_Function *fun)
+{
+  return fun->interactive_form;
+}
+
 static emacs_value
 module_funcall (emacs_env *env, emacs_value func, ptrdiff_t nargs,
                 emacs_value *args)
@@ -1463,6 +1481,7 @@ initialize_environment (emacs_env *env, struct emacs_env_private *priv)
   env->get_function_finalizer = module_get_function_finalizer;
   env->set_function_finalizer = module_set_function_finalizer;
   env->open_channel = module_open_channel;
+  env->make_interactive = module_make_interactive;
   Vmodule_environments = Fcons (make_mint_ptr (env), Vmodule_environments);
   return env;
 }
diff --git a/src/eval.c b/src/eval.c
index 71b7ac8f84e..9e0cec6d9e5 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -2012,6 +2012,15 @@ then strings and vectors are not accepted.  */)
   else if (COMPILEDP (fun))
     return (PVSIZE (fun) > COMPILED_INTERACTIVE ? Qt : if_prop);
 
+#ifdef HAVE_MODULES
+  /* Module functions are interactive if their `interactive_form'
+     field is non-nil. */
+  else if (MODULE_FUNCTIONP (fun))
+    return NILP (module_function_interactive_form (XMODULE_FUNCTION (fun)))
+             ? if_prop
+             : Qt;
+#endif
+
   /* Strings and vectors are keyboard macros.  */
   if (STRINGP (fun) || VECTORP (fun))
     return (NILP (for_call_interactively) ? Qt : Qnil);
diff --git a/src/font.c b/src/font.c
index 2786a772dc3..beaa7be98de 100644
--- a/src/font.c
+++ b/src/font.c
@@ -2810,7 +2810,13 @@ font_list_entities (struct frame *f, Lisp_Object spec)
                 || ! NILP (Vface_ignored_fonts)))
           val = font_delete_unmatched (val, need_filtering ? spec : Qnil, size);
         if (ASIZE (val) > 0)
-          list = Fcons (val, list);
+          {
+            list = Fcons (val, list);
+            /* Querying further backends can be very slow, so we only do
+               it if the user has explicitly requested it (Bug#43177).  */
+            if (query_all_font_backends == false)
+              break;
+          }
       }
 
   list = Fnreverse (list);
@@ -5527,6 +5533,13 @@ Non-nil means don't query fontconfig for color fonts, since they often
 cause Xft crashes.  Only has an effect in Xft builds.  */);
   xft_ignore_color_fonts = true;
 
+  DEFVAR_BOOL ("query-all-font-backends", query_all_font_backends,
+               doc: /*
+If non-nil, attempt to query all available font backends.
+By default Emacs will stop searching for a matching font at the first
+match.  */);
+  query_all_font_backends = false;
+
 #ifdef HAVE_WINDOW_SYSTEM
 #ifdef HAVE_FREETYPE
   syms_of_ftfont ();
diff --git a/src/frame.c b/src/frame.c
index c4dfc35a0c5..3f934504372 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -6106,7 +6106,7 @@ when the mouse is over clickable text.  */);
   Vmouse_highlight = Qt;
 
   DEFVAR_LISP ("make-pointer-invisible", Vmake_pointer_invisible,
-               doc: /* If non-nil, make pointer invisible while typing.
+               doc: /* If non-nil, make mouse pointer invisible while typing.
 The pointer becomes visible again when the mouse is moved.  */);
   Vmake_pointer_invisible = Qt;
 
diff --git a/src/keyboard.c b/src/keyboard.c
index 590d183c4c6..af075a42c76 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -103,7 +103,8 @@ static KBOARD *all_kboards;
 /* True in the single-kboard state, false in the any-kboard state.  */
 static bool single_kboard;
 
-#define NUM_RECENT_KEYS (300)
+/* Minimum allowed size of the recent_keys vector.  */
+#define MIN_NUM_RECENT_KEYS (100)
 
 /* Index for storing next element into recent_keys.  */
 static int recent_keys_index;
@@ -111,7 +112,10 @@ static int recent_keys_index;
 /* Total number of elements stored into recent_keys.  */
 static int total_keys;
 
-/* This vector holds the last NUM_RECENT_KEYS keystrokes.  */
+/* Size of the recent_keys vector.  */
+static int lossage_limit = 3 * MIN_NUM_RECENT_KEYS;
+
+/* This vector holds the last lossage_limit keystrokes.  */
 static Lisp_Object recent_keys;
 
 /* Vector holding the key sequence that invoked the current command.
@@ -1421,10 +1425,10 @@ command_loop_1 (void)
       /* Execute the command.  */
 
       {
-        total_keys += total_keys < NUM_RECENT_KEYS;
+        total_keys += total_keys < lossage_limit;
         ASET (recent_keys, recent_keys_index,
               Fcons (Qnil, cmd));
-        if (++recent_keys_index >= NUM_RECENT_KEYS)
+        if (++recent_keys_index >= lossage_limit)
           recent_keys_index = 0;
       }
       Vthis_command = cmd;
@@ -3248,15 +3252,15 @@ record_char (Lisp_Object c)
       int ix1, ix2, ix3;
 
       if ((ix1 = recent_keys_index - 1) < 0)
-        ix1 = NUM_RECENT_KEYS - 1;
+        ix1 = lossage_limit - 1;
       ev1 = AREF (recent_keys, ix1);
 
       if ((ix2 = ix1 - 1) < 0)
-        ix2 = NUM_RECENT_KEYS - 1;
+        ix2 = lossage_limit - 1;
       ev2 = AREF (recent_keys, ix2);
 
       if ((ix3 = ix2 - 1) < 0)
-        ix3 = NUM_RECENT_KEYS - 1;
+        ix3 = lossage_limit - 1;
       ev3 = AREF (recent_keys, ix3);
 
       if (EQ (XCAR (c), Qhelp_echo))
@@ -3307,12 +3311,12 @@ record_char (Lisp_Object c)
     {
       if (!recorded)
         {
-          total_keys += total_keys < NUM_RECENT_KEYS;
+          total_keys += total_keys < lossage_limit;
           ASET (recent_keys, recent_keys_index,
                 /* Copy the event, in case it gets modified by side-effect
                    by some remapping function (bug#30955).  */
                 CONSP (c) ? Fcopy_sequence (c) : c);
-          if (++recent_keys_index >= NUM_RECENT_KEYS)
+          if (++recent_keys_index >= lossage_limit)
             recent_keys_index = 0;
         }
       else if (recorded < 0)
@@ -3326,10 +3330,10 @@ record_char (Lisp_Object c)
 
           while (recorded++ < 0 && total_keys > 0)
             {
-              if (total_keys < NUM_RECENT_KEYS)
+              if (total_keys < lossage_limit)
                 total_keys--;
               if (--recent_keys_index < 0)
-                recent_keys_index = NUM_RECENT_KEYS - 1;
+                recent_keys_index = lossage_limit - 1;
               ASET (recent_keys, recent_keys_index, Qnil);
             }
         }
@@ -5692,7 +5696,7 @@ make_lispy_event (struct input_event *event)
             ignore_mouse_drag_p = false;
           }
 
-        /* Now we're releasing a button - check the co-ordinates to
+        /* Now we're releasing a button - check the coordinates to
            see if this was a click or a drag.  */
         else if (event->modifiers & up_modifier)
           {
@@ -6640,7 +6644,7 @@ has the same base event type and all the specified modifiers.  */)
 DEFUN ("internal-handle-focus-in", Finternal_handle_focus_in,
        Sinternal_handle_focus_in, 1, 1, 0,
        doc: /* Internally handle focus-in events.
-This function potentially generates an artifical switch-frame event.  */)
+This function potentially generates an artificial switch-frame event.  */)
      (Lisp_Object event)
 {
   Lisp_Object frame;
@@ -10410,6 +10414,64 @@ If CHECK-TIMERS is non-nil, timers that are ready to run will do so.  */)
           ? Qt : Qnil);
 }
 
+/* Reallocate recent_keys copying the recorded keystrokes
+   in the right order.  */
+static void
+update_recent_keys (int new_size, int kept_keys)
+{
+  int osize = ASIZE (recent_keys);
+  eassert (recent_keys_index < osize);
+  eassert (kept_keys <= min (osize, new_size));
+  Lisp_Object v = make_nil_vector (new_size);
+  int i, idx;
+  for (i = 0; i < kept_keys; ++i)
+    {
+      idx = recent_keys_index - kept_keys + i;
+      while (idx < 0)
+        idx += osize;
+      ASET (v, i, AREF (recent_keys, idx));
+    }
+  recent_keys = v;
+  total_keys = kept_keys;
+  recent_keys_index = total_keys % new_size;
+  lossage_limit = new_size;
+
+}
+
+DEFUN ("lossage-size", Flossage_size, Slossage_size, 0, 1,
+       "(list (read-number \"new-size: \" (lossage-size)))",
+       doc: /* Return or set the maximum number of keystrokes to save.
+If called with a non-nil ARG, set the limit to ARG and return it.
+Otherwise, return the current limit.
+
+The saved keystrokes are shown by `view-lossage'.  */)
+  (Lisp_Object arg)
+{
+  if (NILP(arg))
+    return make_fixnum (lossage_limit);
+
+  if (!FIXNATP (arg))
+    user_error ("Value must be a positive integer");
+  int osize = ASIZE (recent_keys);
+  eassert (lossage_limit == osize);
+  int min_size = MIN_NUM_RECENT_KEYS;
+  int new_size = XFIXNAT (arg);
+
+  if (new_size == osize)
+    return make_fixnum (lossage_limit);
+
+  if (new_size < min_size)
+    {
+      AUTO_STRING (fmt, "Value must be >= %d");
+      Fsignal (Quser_error, list1 (CALLN (Fformat, fmt, make_fixnum (min_size))));
+    }
+
+  int kept_keys = new_size > osize ? total_keys : min (new_size, total_keys);
+  update_recent_keys (new_size, kept_keys);
+
+  return make_fixnum (lossage_limit);
+}
+
 DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 1, 0,
        doc: /* Return vector of last few events, not counting those from keyboard macros.
 If INCLUDE-CMDS is non-nil, include the commands that were run,
@@ -10419,21 +10481,21 @@ represented as pseudo-events of the form (nil . COMMAND).  */)
   bool cmds = !NILP (include_cmds);
 
   if (!total_keys
-      || (cmds && total_keys < NUM_RECENT_KEYS))
+      || (cmds && total_keys < lossage_limit))
     return Fvector (total_keys,
                     XVECTOR (recent_keys)->contents);
   else
     {
       Lisp_Object es = Qnil;
-      int i = (total_keys < NUM_RECENT_KEYS
+      int i = (total_keys < lossage_limit
                ? 0 : recent_keys_index);
-      eassert (recent_keys_index < NUM_RECENT_KEYS);
+      eassert (recent_keys_index < lossage_limit);
       do
         {
           Lisp_Object e = AREF (recent_keys, i);
           if (cmds || !CONSP (e) || !NILP (XCAR (e)))
             es = Fcons (e, es);
-          if (++i >= NUM_RECENT_KEYS)
+          if (++i >= lossage_limit)
             i = 0;
         } while (i != recent_keys_index);
       es = Fnreverse (es);
@@ -11686,7 +11748,7 @@ syms_of_keyboard (void)
     staticpro (&modifier_symbols);
   }
 
-  recent_keys = make_nil_vector (NUM_RECENT_KEYS);
+  recent_keys = make_nil_vector (lossage_limit);
   staticpro (&recent_keys);
 
   this_command_keys = make_nil_vector (40);
@@ -11736,6 +11798,7 @@ syms_of_keyboard (void)
   defsubr (&Srecursive_edit);
   defsubr (&Sinternal_track_mouse);
   defsubr (&Sinput_pending_p);
+  defsubr (&Slossage_size);
   defsubr (&Srecent_keys);
   defsubr (&Sthis_command_keys);
   defsubr (&Sthis_command_keys_vector);
diff --git a/src/lisp.h b/src/lisp.h
index bb686845f05..cbc6a666471 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -4224,6 +4224,8 @@ extern Lisp_Object funcall_module (Lisp_Object, ptrdiff_t, Lisp_Object *);
 extern Lisp_Object module_function_arity (const struct Lisp_Module_Function *);
 extern Lisp_Object module_function_documentation
   (struct Lisp_Module_Function const *);
+extern Lisp_Object module_function_interactive_form
+  (const struct Lisp_Module_Function *);
 extern module_funcptr module_function_address
   (struct Lisp_Module_Function const *);
 extern void *module_function_data (const struct Lisp_Module_Function *);
diff --git a/src/lread.c b/src/lread.c
index 3c226e0b50c..d32f5755e98 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -4221,6 +4221,9 @@ intern_sym (Lisp_Object sym, Lisp_Object obarray, Lisp_Object index)
     {
       make_symbol_constant (sym);
       XSYMBOL (sym)->u.s.redirect = SYMBOL_PLAINVAL;
+      /* Mark keywords as special.  This makes (let ((:key 'foo)) ...)
+         in lexically bound elisp signal an error, as documented.  */
+      XSYMBOL (sym)->u.s.declared_special = true;
       SET_SYMBOL_VAL (XSYMBOL (sym), sym);
     }
 
diff --git a/src/module-env-28.h b/src/module-env-28.h
index 5d884c148c4..40b03b92b52 100644
--- a/src/module-env-28.h
+++ b/src/module-env-28.h
@@ -12,3 +12,7 @@
 
   int (*open_channel) (emacs_env *env, emacs_value pipe_process)
     EMACS_ATTRIBUTE_NONNULL (1);
+
+  void (*make_interactive) (emacs_env *env, emacs_value function,
+                            emacs_value spec)
+    EMACS_ATTRIBUTE_NONNULL (1);
diff --git a/src/nsterm.m b/src/nsterm.m
index 26059ab67cd..5e5d09f058b 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -6449,7 +6449,7 @@ not_in_argv (NSString *arg)
   if (nsEvArray == nil)
     nsEvArray = [[NSMutableArray alloc] initWithCapacity: 1];
 
-  [NSCursor setHiddenUntilMouseMoves: YES];
+  [NSCursor setHiddenUntilMouseMoves:! NILP (Vmake_pointer_invisible)];
 
   if (hlinfo->mouse_face_hidden && FIXNUMP (Vmouse_highlight))
     {
@@ -8610,7 +8610,7 @@ not_in_argv (NSString *arg)
       while ( (file = [fenum nextObject]) )
         strings = Fcons ([file lispString], strings);
     }
-  else if ([type isEqualToString: NSURLPboardType])
+  else if ([type isEqualToString: NSPasteboardTypeURL])
     {
       NSURL *url = [NSURL URLFromPasteboard: pb];
       if (url == nil) return NO;
@@ -8619,8 +8619,8 @@ not_in_argv (NSString *arg)
 
       strings = list1 ([[url absoluteString] lispString]);
     }
-  else if ([type isEqualToString: NSStringPboardType]
-           || [type isEqualToString: NSTabularTextPboardType])
+  else if ([type isEqualToString: NSPasteboardTypeString]
+           || [type isEqualToString: NSPasteboardTypeTabularText])
     {
       NSString *data;
 
diff --git a/src/nsxwidget.m b/src/nsxwidget.m
index e81ca7fc0cb..3c6402c03ff 100644
--- a/src/nsxwidget.m
+++ b/src/nsxwidget.m
@@ -33,14 +33,14 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Thoughts on NS Cocoa xwidget and webkit2:
 
    Webkit2 process architecture seems to be very hostile for offscreen
-   rendering techniques, which is used by GTK xwiget implementation;
+   rendering techniques, which is used by GTK xwidget implementation;
    Specifically NSView level view sharing / copying is not working.
 
-   *** So only one view can be associcated with a model. ***
+   *** So only one view can be associated with a model. ***
 
    With this decision, implementation is plain and can expect best out
    of webkit2's rationale.  But process and session structures will
-   diverge from GTK xwiget.  Though, cosmetically similar usages can
+   diverge from GTK xwidget.  Though, cosmetically similar usages can
    be presented and will be preferred, if agreeable.
 
    For other widget types, OSR seems possible, but will not care for a
diff --git a/src/pdumper.c b/src/pdumper.c
index da5e7a17363..0a7e0388f1d 100644
--- a/src/pdumper.c
+++ b/src/pdumper.c
@@ -1834,7 +1834,7 @@ dump_field_lv_or_rawptr (struct dump_context *ctx,
 
   /* Now value is the Lisp_Object to which we want to point whether or
      not the field is a raw pointer (in which case we just synthesized
-     the Lisp_Object outselves) or a Lisp_Object (in which case we
+     the Lisp_Object ourselves) or a Lisp_Object (in which case we
      just copied the thing).  Add a fixup or relocation.  */
 
   intptr_t out_value;
@@ -1925,7 +1925,7 @@ dump_field_fixup_later (struct dump_context *ctx,
   (void) field_relpos (in_start, in_field);
 }
 
-/* Mark an output object field, which is as wide as a poiner, as being
+/* Mark an output object field, which is as wide as a pointer, as being
    fixed up to point to a specific offset in the dump.  */
 static void
 dump_field_ptr_to_dump_offset (struct dump_context *ctx,
diff --git a/src/print.c b/src/print.c
index c5f4bbeef80..1b083f71e08 100644
--- a/src/print.c
+++ b/src/print.c
@@ -1590,27 +1590,34 @@ print_vectorlike (Lisp_Object obj, Lisp_Object printcharfun, bool escapeflag,
 
         /* Print the data here as a plist. */
         ptrdiff_t real_size = HASH_TABLE_SIZE (h);
-        ptrdiff_t size = real_size;
+        ptrdiff_t size = h->count;
 
         /* Don't print more elements than the specified maximum.  */
         if (FIXNATP (Vprint_length) && XFIXNAT (Vprint_length) < size)
           size = XFIXNAT (Vprint_length);
 
         printchar ('(', printcharfun);
-        for (ptrdiff_t i = 0; i < size; i++)
+        ptrdiff_t j = 0;
+        for (ptrdiff_t i = 0; i < real_size; i++)
           {
             Lisp_Object key = HASH_KEY (h, i);
             if (!EQ (key, Qunbound))
               {
-                if (i) printchar (' ', printcharfun);
+                if (j++) printchar (' ', printcharfun);
                 print_object (key, printcharfun, escapeflag);
                 printchar (' ', printcharfun);
                 print_object (HASH_VALUE (h, i), printcharfun, escapeflag);
+                if (j == size)
+                  break;
               }
           }
 
-        if (size < real_size)
-          print_c_string (" ...", printcharfun);
+        if (j < h->count)
+          {
+            if (j)
+              printchar (' ', printcharfun);
+            print_c_string ("...", printcharfun);
+          }
 
         print_c_string ("))", printcharfun);
       }
diff --git a/src/process.c b/src/process.c
index 3aa105ae342..53f4a1d8530 100644
--- a/src/process.c
+++ b/src/process.c
@@ -5413,14 +5413,16 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
           /* If data can be read from the process, do so until exhausted.  */
           if (wait_proc->infd >= 0)
             {
+              unsigned int count = 0;
               XSETPROCESS (proc, wait_proc);
 
               while (true)
                 {
                   int nread = read_process_output (proc, wait_proc->infd);
+                  rarely_quit (++count);
                   if (nread < 0)
                     {
-                      if (errno == EIO || would_block (errno))
+                      if (errno != EINTR)
                         break;
                     }
                   else
diff --git a/src/syntax.c b/src/syntax.c
index 7f0fc341f6e..e6af8a377bb 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -2542,20 +2542,23 @@ between them, return t; otherwise return nil.  */)
               bool fence_found = 0;
               ptrdiff_t ini = from, ini_byte = from_byte;
 
-              while (1)
+              if (from > stop)
                 {
-                  dec_both (&from, &from_byte);
-                  UPDATE_SYNTAX_TABLE_BACKWARD (from);
-                  c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
-                  if (SYNTAX (c) == Scomment_fence
-                      && !char_quoted (from, from_byte))
+                  while (1)
                     {
-                      fence_found = 1;
-                      break;
+                      dec_both (&from, &from_byte);
+                      UPDATE_SYNTAX_TABLE_BACKWARD (from);
+                      c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
+                      if (SYNTAX (c) == Scomment_fence
+                          && !char_quoted (from, from_byte))
+                        {
+                          fence_found = 1;
+                          break;
+                        }
+                      else if (from == stop)
+                        break;
+                      rarely_quit (++quit_count);
                     }
-                  else if (from == stop)
-                    break;
-                  rarely_quit (++quit_count);
                 }
               if (fence_found == 0)
                 {
diff --git a/src/term.c b/src/term.c
index 5cbb092ad17..36776448451 100644
--- a/src/term.c
+++ b/src/term.c
@@ -105,14 +105,14 @@ struct tty_display_info *tty_list;
 
 enum no_color_bit
 {
-  NC_STANDOUT    = 1 << 0,
-  NC_UNDERLINE   = 1 << 1,
-  NC_REVERSE     = 1 << 2,
-  NC_ITALIC      = 1 << 3,
-  NC_DIM         = 1 << 4,
-  NC_BOLD        = 1 << 5,
-  NC_INVIS       = 1 << 6,
-  NC_PROTECT     = 1 << 7
+  NC_STANDOUT            = 1 << 0,
+  NC_UNDERLINE           = 1 << 1,
+  NC_REVERSE             = 1 << 2,
+  NC_ITALIC              = 1 << 3,
+  NC_DIM                 = 1 << 4,
+  NC_BOLD                = 1 << 5,
+  NC_STRIKE_THROUGH      = 1 << 6,
+  NC_PROTECT             = 1 << 7
 };
 
 /* internal state */
@@ -1931,6 +1931,10 @@ turn_on_face (struct frame *f, int face_id)
   if (face->tty_underline_p && MAY_USE_WITH_COLORS_P (tty, NC_UNDERLINE))
     OUTPUT1_IF (tty, tty->TS_enter_underline_mode);
 
+  if (face->tty_strike_through_p
+      && MAY_USE_WITH_COLORS_P (tty, NC_STRIKE_THROUGH))
+    OUTPUT1_IF (tty, tty->TS_enter_strike_through_mode);
+
   if (tty->TN_max_colors > 0)
     {
       const char *ts;
@@ -1971,7 +1975,8 @@ turn_off_face (struct frame *f, int face_id)
       if (face->tty_bold_p
           || face->tty_italic_p
           || face->tty_reverse_p
-          || face->tty_underline_p)
+          || face->tty_underline_p
+          || face->tty_strike_through_p)
         {
           OUTPUT1_IF (tty, tty->TS_exit_attribute_mode);
           if (strcmp (tty->TS_exit_attribute_mode, tty->TS_end_standout_mode) == 0)
@@ -2006,11 +2011,20 @@ tty_capable_p (struct tty_display_info *tty, unsigned int caps)
   if ((caps & (cap)) && (!(TS) || !MAY_USE_WITH_COLORS_P(tty, NC_bit))) \
     return 0;
 
-  TTY_CAPABLE_P_TRY (tty, TTY_CAP_INVERSE,      tty->TS_standout_mode,          NC_REVERSE);
-  TTY_CAPABLE_P_TRY (tty, TTY_CAP_UNDERLINE,    tty->TS_enter_underline_mode,   NC_UNDERLINE);
-  TTY_CAPABLE_P_TRY (tty, TTY_CAP_BOLD,         tty->TS_enter_bold_mode,        NC_BOLD);
-  TTY_CAPABLE_P_TRY (tty, TTY_CAP_DIM,          tty->TS_enter_dim_mode,         NC_DIM);
-  TTY_CAPABLE_P_TRY (tty, TTY_CAP_ITALIC,       tty->TS_enter_italic_mode,      NC_ITALIC);
+  TTY_CAPABLE_P_TRY (tty,
+                     TTY_CAP_INVERSE,     tty->TS_standout_mode, NC_REVERSE);
+  TTY_CAPABLE_P_TRY (tty,
+                     TTY_CAP_UNDERLINE,   tty->TS_enter_underline_mode,
+                     NC_UNDERLINE);
+  TTY_CAPABLE_P_TRY (tty,
+                     TTY_CAP_BOLD,        tty->TS_enter_bold_mode, NC_BOLD);
+  TTY_CAPABLE_P_TRY (tty,
+                     TTY_CAP_DIM,         tty->TS_enter_dim_mode, NC_DIM);
+  TTY_CAPABLE_P_TRY (tty,
+                     TTY_CAP_ITALIC,      tty->TS_enter_italic_mode, NC_ITALIC);
+  TTY_CAPABLE_P_TRY (tty,
+                     TTY_CAP_STRIKE_THROUGH, tty->TS_enter_strike_through_mode,
+                     NC_STRIKE_THROUGH);
 
   /* We can do it!  */
   return 1;
@@ -2402,7 +2416,7 @@ tty_draw_row_with_mouse_face (struct window *w, struct glyph_row *row,
   pos_y = row->y + WINDOW_TOP_EDGE_Y (w);
   pos_x = row->used[LEFT_MARGIN_AREA] + start_hpos + WINDOW_LEFT_EDGE_X (w);
 
-  /* Save current cursor co-ordinates.  */
+  /* Save current cursor coordinates.  */
   save_y = curY (tty);
   save_x = curX (tty);
   cursor_to (f, pos_y, pos_x);
@@ -4124,6 +4138,7 @@ use the Bourne shell command 'TERM=...; export TERM' (C-shell:\n\
   tty->TS_enter_alt_charset_mode = tgetstr ("as", address);
   tty->TS_exit_alt_charset_mode = tgetstr ("ae", address);
   tty->TS_exit_attribute_mode = tgetstr ("me", address);
+  tty->TS_enter_strike_through_mode = tgetstr ("smxx", address);
 
   MultiUp (tty) = tgetstr ("UP", address);
   MultiDown (tty) = tgetstr ("DO", address);
diff --git a/src/termchar.h b/src/termchar.h
index c96b81913b0..c967e7d04f4 100644
--- a/src/termchar.h
+++ b/src/termchar.h
@@ -136,6 +136,8 @@ struct tty_display_info
   const char *TS_enter_reverse_mode; /* "mr" -- enter reverse video mode.  */
   const char *TS_exit_underline_mode; /* "us" -- start underlining.  */
   const char *TS_enter_underline_mode; /* "ue" -- end underlining.  */
+  const char *TS_enter_strike_through_mode; /* "smxx" -- turn on strike-through
+                                               mode.  */
 
   /* "as"/"ae" -- start/end alternate character set.  Not really
      supported, yet.  */
diff --git a/src/terminfo.c b/src/terminfo.c
index 51fd32e9e01..0765996401f 100644
--- a/src/terminfo.c
+++ b/src/terminfo.c
@@ -23,9 +23,12 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 
 /* Define these variables that serve as global parameters to termcap,
    so that we do not need to conditionalize the places in Emacs
-   that set them.  */
+   that set them.  But don't do that for terminfo, as that could
+   cause link errors when using -fno-common.  */
 
+#if !TERMINFO
 char *UP, *BC, PC;
+#endif
 
 /* Interface to curses/terminfo library.
    Turns out that all of the terminfo-level routines look
diff --git a/src/w32fns.c b/src/w32fns.c
index ab864332e78..3134f678f39 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -3640,7 +3640,7 @@ get_wm_chars (HWND aWnd, int *buf, int buflen, int ignore_ctrl, int ctrl,
    non-Emacs window with the same language environment, and using (dead)keys
    there would change the value stored in the kernel, but not this value.  */
 /* A layout may emit deadkey=0.  It looks like this would reset the state
-   of the kernel's finite automaton (equivalent to emiting 0-length string,
+   of the kernel's finite automaton (equivalent to emitting 0-length string,
    which is otherwise impossible in the dead-key map of a layout).
    Be ready to treat the case when this delivers WM_(SYS)DEADCHAR. */
 static int after_deadkey = -1;
@@ -3701,7 +3701,7 @@ deliver_wm_chars (int do_translate, HWND hwnd, UINT msg, UINT wParam,
          of w32_get_key_modifiers ().  */
       wmsg.dwModifiers = w32_kbd_mods_to_emacs (console_modifiers, wParam);
 
-      /* What follows is just heuristics; the correct treatement requires
+      /* What follows is just heuristics; the correct treatment requires
          non-destructive ToUnicode():
            http://search.cpan.org/~ilyaz/UI-KeyboardLayout/lib/UI/KeyboardLayout.pm#Can_an_application_on_Windows_accept_keyboard_events?_Part_IV:_application-specific_modifiers
 
@@ -7001,7 +7001,7 @@ w32_create_tip_frame (struct w32_display_info *dpyinfo, Lisp_Object parms)
      Frame parameters may be changed if .Xdefaults contains
      specifications for the default font.  For example, if there is an
      `Emacs.default.attributeBackground: pink', the `background-color'
-     attribute of the frame get's set, which let's the internal border
+     attribute of the frame gets set, which let's the internal border
      of the tooltip frame appear in pink.  Prevent this.  */
   {
     Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
@@ -7085,7 +7085,7 @@ compute_tip_xy (struct frame *f,
 
       /* If multiple monitor support is available, constrain the tip onto
          the current monitor. This improves the above by allowing negative
-         co-ordinates if monitor positions are such that they are valid, and
+         coordinates if monitor positions are such that they are valid, and
          snaps a tooltip onto a single monitor if we are close to the edge
          where it would otherwise flow onto the other monitor (or into
          nothingness if there is a gap in the overlap).  */
@@ -8079,7 +8079,7 @@ operations:
  \"pastelink\"
            - create a shortcut in DOCUMENT (which must be a directory)
                the file or directory whose name is in the clipboard.
- \"runas\"   - run DOCUMENT, which must be an excutable file, with
+ \"runas\"   - run DOCUMENT, which must be an executable file, with
                elevated privileges (a.k.a. \"as Administrator\").
  \"properties\"
            - open the property sheet dialog for DOCUMENT.
diff --git a/src/w32heap.c b/src/w32heap.c
index ececc73c026..ba3550b6e9b 100644
--- a/src/w32heap.c
+++ b/src/w32heap.c
@@ -884,7 +884,7 @@ setrlimit (rlimit_resource_t rltype, const struct rlimit *rlp)
     {
     case RLIMIT_STACK:
     case RLIMIT_NOFILE:
-      /* We cannot modfy these limits, so we always fail.  */
+      /* We cannot modify these limits, so we always fail.  */
       errno = EPERM;
       break;
     default:
diff --git a/src/w32menu.c b/src/w32menu.c
index e076043f7b7..da2db78a940 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -1485,7 +1485,7 @@ w32_menu_display_help (HWND owner, HMENU menu, UINT item, UINT flags)
              crash Emacs when we try to display those "strings".  It
              is unclear why we get these dwItemData, or what they are:
              sometimes they point to a wchar_t string that is the menu
-             title, sometimes to someting that doesn't look like text
+             title, sometimes to something that doesn't look like text
              at all.  (The problematic data also comes with the 0x0800
              bit set, but this bit is not documented, so we don't want
              to depend on it.)  */
diff --git a/src/w32term.c b/src/w32term.c
index 2669f29b560..e0618e4f52d 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -6877,7 +6877,7 @@ w32_make_frame_visible (struct frame *f)
       /* According to a report in emacs-devel 2008-06-03, SW_SHOWNORMAL
          causes unexpected behavior when unminimizing frames that were
          previously maximized.  But only SW_SHOWNORMAL works properly for
-         frames that were truely hidden (using make-frame-invisible), so
+         frames that were truly hidden (using make-frame-invisible), so
          we need it to avoid Bug#5482.  It seems that iconified is only
          set for minimized windows that are still visible, so use that to
          determine the appropriate flag to pass ShowWindow.  */
diff --git a/src/w32term.h b/src/w32term.h
index 8ba248013c7..694493c6c82 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -476,7 +476,7 @@ struct scroll_bar {
      editing large files, we establish a minimum height by always
      drawing handle bottoms VERTICAL_SCROLL_BAR_MIN_HANDLE pixels below
      where they would be normally; the bottom and top are in a
-     different co-ordinate system.  */
+     different coordinate system.  */
   int start, end;
 
   /* If the scroll bar handle is currently being dragged by the user,
diff --git a/src/xdisp.c b/src/xdisp.c
index 69e5a9e1cf1..ac5307f4acc 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -510,7 +510,7 @@ static Lisp_Object list_of_error;
                || *BYTE_POS_ADDR (IT_BYTEPOS (*it)) == '\t'))))
 
 /* These are the category sets we use.  They are defined by
-   kinsoku.el and chracters.el.  */
+   kinsoku.el and characters.el.  */
 #define NOT_AT_EOL '<'
 #define NOT_AT_BOL '>'
 #define LINE_BREAKABLE '|'
@@ -2230,7 +2230,7 @@ estimate_mode_line_height (struct frame *f, enum face_id face_id)
 }
 
 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
-   co-ordinates in (*X, *Y).  Set *BOUNDS to the rectangle that the
+   coordinates in (*X, *Y).  Set *BOUNDS to the rectangle that the
    glyph at X, Y occupies, if BOUNDS != 0.  If NOCLIP, do
    not force the value into range.  */
 
@@ -3744,7 +3744,7 @@ init_to_row_end (struct it *it, struct window *w, struct glyph_row *row)
         it->continuation_lines_width
           = row->continuation_lines_width + row->pixel_width;
       CHECK_IT (it);
-      /* Initializing IT in the presense of compositions in reordered
+      /* Initializing IT in the presence of compositions in reordered
          rows is tricky: row->end above will generally cause us to
          start at position that is not the first one in the logical
          order, and we might therefore miss the composition earlier in
@@ -25641,8 +25641,10 @@ display_mode_element (struct it *it, int depth, int field_width, int precision,
                     /* Non-ASCII characters in SPEC should cause mode-line
                        element be displayed as a multibyte string.  */
                     ptrdiff_t nbytes = strlen (spec);
-                    if (multibyte_chars_in_text ((const unsigned char *)spec,
-                                                 nbytes) != nbytes)
+                    ptrdiff_t nchars, mb_nbytes;
+                    parse_str_as_multibyte ((const unsigned char *)spec, nbytes,
+                                            &nchars, &mb_nbytes);
+                    if (!(nbytes == nchars || nbytes != mb_nbytes))
                       multibyte = true;
 
                     switch (mode_line_target)
@@ -34831,8 +34833,7 @@ and is used only on frames for which no explicit name has been set
      Oracle Developer Studio 12.6.  */
   Lisp_Object icon_title_name_format
     = pure_list (empty_unibyte_string,
-                 intern_c_string ("invocation-name"),
-                 build_pure_c_string ("@"),
+                 build_pure_c_string ("%b - GNU Emacs at "),
                  intern_c_string ("system-name"));
   Vicon_title_format
     = Vframe_title_format
@@ -35008,8 +35009,10 @@ but does not change the fact they are interpreted as raw bytes.  */);
 
   DEFVAR_LISP ("max-mini-window-height", Vmax_mini_window_height,
     doc: /* Maximum height for resizing mini-windows (the minibuffer and the echo area).
-If a float, it specifies a fraction of the mini-window frame's height.
-If an integer, it specifies a number of lines.  */);
+If a float, it specifies the maximum height in units of the
+mini-window frame's height.
+If an integer, it specifies the maximum height in units of the
+mini-window frame's default font's height.  */);
   Vmax_mini_window_height = make_float (0.25);
 
   DEFVAR_LISP ("resize-mini-windows", Vresize_mini_windows,
diff --git a/src/xfaces.c b/src/xfaces.c
index 06d2f994de6..73a536b19c6 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -5217,7 +5217,6 @@ tty_supports_face_attributes_p (struct frame *f,
       || !UNSPECIFIEDP (attrs[LFACE_HEIGHT_INDEX])
       || !UNSPECIFIEDP (attrs[LFACE_SWIDTH_INDEX])
       || !UNSPECIFIEDP (attrs[LFACE_OVERLINE_INDEX])
-      || !UNSPECIFIEDP (attrs[LFACE_STRIKE_THROUGH_INDEX])
       || !UNSPECIFIEDP (attrs[LFACE_BOX_INDEX]))
     return false;
 
@@ -5282,6 +5281,15 @@ tty_supports_face_attributes_p (struct frame *f,
         test_caps |= TTY_CAP_INVERSE;
     }
 
+  /* strike through */
+  val = attrs[LFACE_STRIKE_THROUGH_INDEX];
+  if (!UNSPECIFIEDP (val))
+    {
+      if (face_attr_equal_p (val, def_attrs[LFACE_STRIKE_THROUGH_INDEX]))
+        return false;           /* same as default */
+      else
+        test_caps |= TTY_CAP_STRIKE_THROUGH;
+    }
 
   /* Color testing.  */
 
@@ -6244,6 +6252,8 @@ realize_tty_face (struct face_cache *cache,
     face->tty_underline_p = true;
   if (!NILP (attrs[LFACE_INVERSE_INDEX]))
     face->tty_reverse_p = true;
+  if (!NILP (attrs[LFACE_STRIKE_THROUGH_INDEX]))
+    face->tty_strike_through_p = true;
 
   /* Map color names to color indices.  */
   map_tty_color (f, face, LFACE_FOREGROUND_INDEX, &face_colors_defaulted);
diff --git a/src/xfns.c b/src/xfns.c
index 78f977bf0aa..46e4bd73a6b 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -6535,7 +6535,7 @@ x_create_tip_frame (struct x_display_info *dpyinfo, Lisp_Object parms)
      Frame parameters may be changed if .Xdefaults contains
      specifications for the default font.  For example, if there is an
      `Emacs.default.attributeBackground: pink', the `background-color'
-     attribute of the frame get's set, which let's the internal border
+     attribute of the frame gets set, which let's the internal border
      of the tooltip frame appear in pink.  Prevent this.  */
   {
     Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
diff --git a/src/xterm.h b/src/xterm.h
index db8d5847814..0f8ba5e82b4 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -890,7 +890,7 @@ struct scroll_bar
      editing large files, we establish a minimum height by always
      drawing handle bottoms VERTICAL_SCROLL_BAR_MIN_HANDLE pixels below
      where they would be normally; the bottom and top are in a
-     different co-ordinate system.  */
+     different coordinate system.  */
   int start, end;
 
   /* If the scroll bar handle is currently being dragged by the user,