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

18 files changed, 289 insertions, 91 deletions

diff --git a/src/Makefile.in b/src/Makefile.in
index 5da2257ba97..40a423d6a1e 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -345,7 +345,7 @@ DUMPING=@DUMPING@
 CHECK_STRUCTS = @CHECK_STRUCTS@
 HAVE_PDUMPER = @HAVE_PDUMPER@
 
-## ARM Macs require that all code have a valid signature.  Since pump
+## ARM Macs require that all code have a valid signature.  Since pdump
 ## invalidates the signature, we must re-sign to fix it.
 DO_CODESIGN=$(patsubst aarch64-apple-darwin%,yes,@configuration@)
 
diff --git a/src/buffer.c b/src/buffer.c
index df302db0e52..565577e75ae 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -5681,10 +5681,10 @@ inserts one or more TAB characters, this variable will affect the
 indentation step as well, even if `indent-tabs-mode' is non-nil.  */);
 
   DEFVAR_PER_BUFFER ("ctl-arrow", &BVAR (current_buffer, ctl_arrow), Qnil,
-                     doc: /* Non-nil means display control chars with uparrow.
-A value of nil means use backslash and octal digits.
-This variable does not apply to characters whose display is specified
-in the current display table (if there is one).  */);
+                     doc: /* Non-nil means display control chars with uparrow `^'.
+A value of nil means use backslash `\\' and octal digits.
+This variable does not apply to characters whose display is specified in
+the current display table (if there is one; see `standard-display-table').  */);
 
   DEFVAR_PER_BUFFER ("enable-multibyte-characters",
                      &BVAR (current_buffer, enable_multibyte_characters),
diff --git a/src/character.c b/src/character.c
index 41abb83a48b..e874cf5e53c 100644
--- a/src/character.c
+++ b/src/character.c
@@ -34,6 +34,7 @@ along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "character.h"
 #include "buffer.h"
+#include "frame.h"
 #include "dispextern.h"
 #include "composite.h"
 #include "disptab.h"
@@ -338,11 +339,18 @@ lisp_string_width (Lisp_Object string, ptrdiff_t from, ptrdiff_t to,
      contains only ascii and eight-bit-graphic, but that's
      intentional.  */
   bool multibyte = SCHARS (string) < SBYTES (string);
-  unsigned char *str = SDATA (string);
   ptrdiff_t i = from, i_byte = from ? string_char_to_byte (string, from) : 0;
   ptrdiff_t from_byte = i_byte;
   ptrdiff_t width = 0;
   struct Lisp_Char_Table *dp = buffer_display_table ();
+#ifdef HAVE_WINDOW_SYSTEM
+  struct frame *f =
+    (FRAMEP (selected_frame) && FRAME_LIVE_P (XFRAME (selected_frame)))
+    ? XFRAME (selected_frame)
+    : NULL;
+  int font_width = -1;
+  Lisp_Object default_font, frame_font;
+#endif
 
   eassert (precision <= 0 || (nchars && nbytes));
 
@@ -361,9 +369,51 @@ lisp_string_width (Lisp_Object string, ptrdiff_t from, ptrdiff_t to,
           chars = end - i;
           bytes = string_char_to_byte (string, end) - i_byte;
         }
+#ifdef HAVE_WINDOW_SYSTEM
+      else if (f && FRAME_WINDOW_P (f)
+               && multibyte
+               && find_automatic_composition (i, -1, &ignore, &end, &val, string)
+               && end > i)
+        {
+          int j;
+          for (j = 0; j < LGSTRING_GLYPH_LEN (val); j++)
+            if (NILP (LGSTRING_GLYPH (val, j)))
+              break;
+
+          int pixelwidth = composition_gstring_width (val, 0, j, NULL);
+
+          /* The below is somewhat expensive, so compute it only once
+             for the entire loop, and only if needed.  */
+          if (font_width < 0)
+            {
+              font_width = FRAME_COLUMN_WIDTH (f);
+              default_font = Fface_font (Qdefault, Qnil, Qnil);
+              frame_font = Fframe_parameter (Qnil, Qfont);
+
+              if (STRINGP (default_font) && STRINGP (frame_font)
+                  && (SCHARS (default_font) != SCHARS (frame_font)
+                      || SBYTES (default_font) != SBYTES (frame_font)
+                      || memcmp (SDATA (default_font), SDATA (frame_font),
+                                 SBYTES (default_font))))
+                {
+                  Lisp_Object font_info = Ffont_info (default_font, Qnil);
+                  if (VECTORP (font_info))
+                    {
+                      font_width = XFIXNUM (AREF (font_info, 11));
+                      if (font_width <= 0)
+                        font_width = XFIXNUM (AREF (font_info, 10));
+                    }
+                }
+            }
+          thiswidth = (double) pixelwidth / font_width + 0.5;
+          chars = end - i;
+          bytes = string_char_to_byte (string, end) - i_byte;
+        }
+#endif  /* HAVE_WINDOW_SYSTEM */
       else
         {
           int c;
+          unsigned char *str = SDATA (string);
 
           if (multibyte)
             {
diff --git a/src/comp.c b/src/comp.c
index c0445050b71..056d0860d8a 100644
--- a/src/comp.c
+++ b/src/comp.c
@@ -4008,15 +4008,16 @@ DEFUN ("comp-el-to-eln-rel-filename", Fcomp_el_to_eln_rel_filename,
 {
   CHECK_STRING (filename);
 
-  /* Use `file-truename' or fall back to `expand-file-name' when the
-     first is not available (bug#44701).
-
-     `file-truename' is not available only for a short phases of the
-     bootstrap before file.el is loaded, given we do not symlink
-     inside the build directory this should work.  */
-  filename = NILP (Ffboundp (intern_c_string ("file-truename")))
-    ? Fexpand_file_name (filename, Qnil)
-    : CALL1I (file-truename, filename);
+  /* Resolve possible symlinks in FILENAME, so that path_hash below
+     always compares equal. (Bug#44701).  */
+  filename = Fexpand_file_name (filename, Qnil);
+  char *file_normalized = realpath (SSDATA (ENCODE_FILE (filename)), NULL);
+  if (file_normalized)
+    {
+      filename = DECODE_FILE (make_unibyte_string (file_normalized,
+                                                   strlen (file_normalized)));
+      xfree (file_normalized);
+    }
 
   if (NILP (Ffile_exists_p (filename)))
     xsignal1 (Qfile_missing, filename);
@@ -4056,7 +4057,8 @@ DEFUN ("comp-el-to-eln-rel-filename", Fcomp_el_to_eln_rel_filename,
       Lisp_Object sys_re =
         concat2 (build_string ("\\`[[:ascii:]]+"),
                  Fregexp_quote (build_string ("/" PATH_REL_LOADSEARCH "/")));
-      Lisp_Object dump_load_search = build_string (PATH_DUMPLOADSEARCH "/");
+      Lisp_Object dump_load_search =
+        Fexpand_file_name (build_string (PATH_DUMPLOADSEARCH "/"), Qnil);
 #ifdef WINDOWSNT
       dump_load_search = Fw32_long_file_name (dump_load_search);
 #endif
diff --git a/src/composite.c b/src/composite.c
index f1c011223b2..17d5914e634 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -953,8 +953,12 @@ char_composable_p (int c)
   Lisp_Object val;
   return (c >= ' '
           && (c == ZERO_WIDTH_NON_JOINER || c == ZERO_WIDTH_JOINER
-              || (val = CHAR_TABLE_REF (Vunicode_category_table, c),
-                  (FIXNUMP (val) && (XFIXNUM (val) <= UNICODE_CATEGORY_Zs)))));
+              /* unicode-category-table may not be available during
+                 dumping.  */
+              || (CHAR_TABLE_P (Vunicode_category_table)
+                  && (val = CHAR_TABLE_REF (Vunicode_category_table, c),
+                      (FIXNUMP (val)
+                       && (XFIXNUM (val) <= UNICODE_CATEGORY_Zs))))));
 }
 
 /* Update cmp_it->stop_pos to the next position after CHARPOS (and
@@ -1475,7 +1479,7 @@ struct position_record
    representing the composition, and return true.  Otherwise, *GSTRING to
    Qnil, and return false.  */
 
-static bool
+bool
 find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit,
                             ptrdiff_t *start, ptrdiff_t *end,
                             Lisp_Object *gstring, Lisp_Object string)
diff --git a/src/composite.h b/src/composite.h
index c5d3c0faabb..75e5f9b9ecb 100644
--- a/src/composite.h
+++ b/src/composite.h
@@ -320,6 +320,10 @@ extern bool composition_gstring_p (Lisp_Object);
 extern int composition_gstring_width (Lisp_Object, ptrdiff_t, ptrdiff_t,
                                       struct font_metrics *);
 
+extern bool find_automatic_composition (ptrdiff_t, ptrdiff_t, ptrdiff_t *,
+                                        ptrdiff_t *, Lisp_Object *,
+                                        Lisp_Object);
+
 extern void composition_compute_stop_pos (struct composition_it *,
                                           ptrdiff_t, ptrdiff_t, ptrdiff_t,
                                           Lisp_Object);
diff --git a/src/conf_post.h b/src/conf_post.h
index 176ab28b21a..8558dc466cc 100644
--- a/src/conf_post.h
+++ b/src/conf_post.h
@@ -99,10 +99,28 @@ typedef bool bool_bf;
 # define ADDRESS_SANITIZER false
 #endif
 
+#ifdef emacs
+/* We include stdlib.h here, because Gnulib's stdlib.h might redirect
+   'free' to its replacement, and we want to avoid that in unexec
+   builds.  Inclduing it here will render its inclusion after config.h
+   a no-op.  */
+# if (defined DARWIN_OS && defined HAVE_UNEXEC) || defined HYBRID_MALLOC
+#  include <stdlib.h>
+# endif
+#endif
+
 #if defined DARWIN_OS && defined emacs && defined HAVE_UNEXEC
+# undef malloc
 # define malloc unexec_malloc
+# undef realloc
 # define realloc unexec_realloc
+# undef free
 # define free unexec_free
+
+extern void *unexec_malloc (size_t);
+extern void *unexec_realloc (void *, size_t);
+extern void unexec_free (void *);
+
 #endif
 
 /* If HYBRID_MALLOC is defined (e.g., on Cygwin), emacs will use
@@ -111,12 +129,23 @@ typedef bool bool_bf;
    accomplish this.  */
 #ifdef HYBRID_MALLOC
 #ifdef emacs
+#undef malloc
 #define malloc hybrid_malloc
+#undef realloc
 #define realloc hybrid_realloc
+#undef aligned_alloc
 #define aligned_alloc hybrid_aligned_alloc
+#undef calloc
 #define calloc hybrid_calloc
+#undef free
 #define free hybrid_free
-#endif
+
+extern void *hybrid_malloc (size_t);
+extern void *hybrid_calloc (size_t, size_t);
+extern void hybrid_free (void *);
+extern void *hybrid_aligned_alloc (size_t, size_t);
+extern void *hybrid_realloc (void *, size_t);
+#endif  /* emacs */
 #endif  /* HYBRID_MALLOC */
 
 /* We have to go this route, rather than the old hpux9 approach of
diff --git a/src/editfns.c b/src/editfns.c
index 04b8e85d9c6..182d3ba6f2b 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -1452,8 +1452,8 @@ DEFUN ("insert-char", Finsert_char, Sinsert_char, 1, 3,
               (prefix-numeric-value current-prefix-arg)\
               t))",
        doc: /* Insert COUNT copies of CHARACTER.
-Interactively, prompt for CHARACTER.  You can specify CHARACTER in one
-of these ways:
+Interactively, prompt for CHARACTER using `read-char-by-name'.
+You can specify CHARACTER in one of these ways:
 
  - As its Unicode character name, e.g. \"LATIN SMALL LETTER A\".
    Completion is available; if you type a substring of the name
diff --git a/src/fileio.c b/src/fileio.c
index 741e297d29c..caf077e2fbf 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -2987,12 +2987,16 @@ file_directory_p (Lisp_Object file)
 DEFUN ("file-accessible-directory-p", Ffile_accessible_directory_p,
        Sfile_accessible_directory_p, 1, 1, 0,
        doc: /* Return t if FILENAME names a directory you can open.
-For the value to be t, FILENAME must specify the name of a directory
-as a file, and the directory must allow you to open files in it.  In
-order to use a directory as a buffer's current directory, this
-predicate must return true.  A directory name spec may be given
-instead; then the value is t if the directory so specified exists and
-really is a readable and searchable directory.  */)
+This means that FILENAME must specify the name of a directory, and the
+directory must allow you to open files in it.  If this isn't the case,
+return nil.
+
+FILENAME can either be a directory name (eg. \"/tmp/foo/\") or the
+file name of a file which is a directory (eg. \"/tmp/foo\", without
+the final slash).
+
+In order to use a directory as a buffer's current directory, this
+predicate must return true.  */)
   (Lisp_Object filename)
 {
   Lisp_Object absname;
diff --git a/src/fns.c b/src/fns.c
index 41429c8863d..40ade578008 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -5892,12 +5892,14 @@ in OBJECT.  */)
 
 DEFUN ("line-number-at-pos", Fline_number_at_pos,
        Sline_number_at_pos, 0, 2, 0,
-       doc: /* Return the line number at POSITION.
-If POSITION is nil, use the current buffer location.
-
-If the buffer is narrowed, the position returned is the position in the
-visible part of the buffer.  If ABSOLUTE is non-nil, count the lines
-from the absolute start of the buffer.  */)
+       doc: /* Return the line number at POSITION in the current buffer.
+If POSITION is nil or omitted, it defaults to point's position in the
+current buffer.
+
+If the buffer is narrowed, the return value by default counts the lines
+from the beginning of the accessible portion of the buffer.  But if the
+second optional argument ABSOLUTE is non-nil, the value counts the lines
+from the absolute start of the buffer, disregarding the narrowing.  */)
   (register Lisp_Object position, Lisp_Object absolute)
 {
   ptrdiff_t pos, start = BEGV_BYTE;
@@ -5915,9 +5917,9 @@ from the absolute start of the buffer.  */)
   if (!NILP (absolute))
     start = BEG_BYTE;
 
-  /* Check that POSITION is n the visible range of the buffer. */
+  /* Check that POSITION is in the accessible range of the buffer. */
   if (pos < BEGV || pos > ZV)
-    args_out_of_range (make_int (start), make_int (ZV));
+    args_out_of_range_3 (make_int (pos), make_int (BEGV), make_int (ZV));
 
   return make_int (count_lines (start, CHAR_TO_BYTE (pos)) + 1);
 }
diff --git a/src/fringe.c b/src/fringe.c
index 0224268c2e6..e67ea9d88fd 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -1797,14 +1797,15 @@ gui_init_fringe (struct redisplay_interface *rif)
   for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++)
     {
       struct fringe_bitmap *fb = &standard_bitmaps[bt];
-      rif->define_fringe_bitmap (bt, fb->bits, fb->height, fb->width);
+      if (!fringe_bitmaps[bt])
+        rif->define_fringe_bitmap (bt, fb->bits, fb->height, fb->width);
     }
 
   /* Set up user-defined fringe bitmaps that might have been defined
      before the frame of this kind was initialized.  This can happen
      if Emacs is started as a daemon and the init files define fringe
      bitmaps.  */
-  for ( ; bt < max_used_fringe_bitmap; bt++)
+  for (bt = NO_FRINGE_BITMAP + 1; bt < max_used_fringe_bitmap; bt++)
     {
       struct fringe_bitmap *fb = fringe_bitmaps[bt];
       if (fb)
diff --git a/src/gmalloc.c b/src/gmalloc.c
index 66008ea69b2..55ae7365d99 100644
--- a/src/gmalloc.c
+++ b/src/gmalloc.c
@@ -1690,16 +1690,6 @@ valloc (size_t size)
 #undef free
 
 #ifdef HYBRID_MALLOC
-/* Declare system malloc and friends.  */
-extern void *malloc (size_t size);
-extern void *realloc (void *ptr, size_t size);
-extern void *calloc (size_t nmemb, size_t size);
-extern void free (void *ptr);
-#ifdef HAVE_ALIGNED_ALLOC
-extern void *aligned_alloc (size_t alignment, size_t size);
-#elif defined HAVE_POSIX_MEMALIGN
-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
@@ -1736,8 +1726,8 @@ hybrid_calloc (size_t nmemb, size_t size)
   return gcalloc (nmemb, size);
 }
 
-void
-hybrid_free (void *ptr)
+static void
+hybrid_free_1 (void *ptr)
 {
   if (allocated_via_gmalloc (ptr))
     gfree (ptr);
@@ -1745,6 +1735,24 @@ hybrid_free (void *ptr)
     free (ptr);
 }
 
+void
+hybrid_free (void *ptr)
+{
+  /* Stolen from Gnulib, to make sure we preserve errno.  */
+#if defined __GNUC__ && !defined __clang__
+  int err[2];
+  err[0] = errno;
+  err[1] = errno;
+  errno = 0;
+  hybrid_free_1 (ptr);
+  errno = err[errno == 0];
+#else
+  int err = errno;
+  hybrid_free_1 (ptr);
+  errno = err;
+#endif
+}
+
 #if defined HAVE_ALIGNED_ALLOC || defined HAVE_POSIX_MEMALIGN
 void *
 hybrid_aligned_alloc (size_t alignment, size_t size)
diff --git a/src/keyboard.c b/src/keyboard.c
index c3fce19d881..b2aabdda325 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -3233,10 +3233,6 @@ help_char_p (Lisp_Object c)
 static void
 record_char (Lisp_Object c)
 {
-  /* quail.el binds this to avoid recording keys twice.  */
-  if (inhibit_record_char)
-    return;
-
   int recorded = 0;
 
   if (CONSP (c) && (EQ (XCAR (c), Qhelp_echo) || EQ (XCAR (c), Qmouse_movement)))
@@ -12351,13 +12347,6 @@ If nil, Emacs crashes immediately in response to fatal signals.  */);
                Vwhile_no_input_ignore_events,
                doc: /* Ignored events from while-no-input.  */);
 
-  DEFVAR_BOOL ("inhibit--record-char",
-               inhibit_record_char,
-               doc: /* If non-nil, don't record input events.
-This inhibits recording input events for the purposes of keyboard
-macros, dribble file, and `recent-keys'.
-Internal use only.  */);
-
   pdumper_do_now_and_after_load (syms_of_keyboard_for_pdumper);
 }
 
@@ -12391,8 +12380,6 @@ syms_of_keyboard_for_pdumper (void)
   /* Create the initial keyboard.  Qt means 'unset'.  */
   eassert (initial_kboard == NULL);
   initial_kboard = allocate_kboard (Qt);
-
-  inhibit_record_char = false;
 }
 
 void
diff --git a/src/lread.c b/src/lread.c
index bca53a9a37a..0b33fd0f254 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -3938,8 +3938,7 @@ string_to_number (char const *string, int base, ptrdiff_t *plen)
   bool signedp = negative | positive;
   cp += signedp;
 
-  enum { INTOVERFLOW = 1, LEAD_INT = 2, DOT_CHAR = 4, TRAIL_INT = 8,
-         E_EXP = 16 };
+  enum { INTOVERFLOW = 1, LEAD_INT = 2, TRAIL_INT = 4, E_EXP = 16 };
   int state = 0;
   int leading_digit = digit_to_number (*cp, base);
   uintmax_t n = leading_digit;
@@ -3959,7 +3958,6 @@ string_to_number (char const *string, int base, ptrdiff_t *plen)
   char const *after_digits = cp;
   if (*cp == '.')
     {
-      state |= DOT_CHAR;
       cp++;
     }
 
@@ -4008,8 +4006,10 @@ string_to_number (char const *string, int base, ptrdiff_t *plen)
             cp = ecp;
         }
 
-      float_syntax = ((state & (DOT_CHAR|TRAIL_INT)) == (DOT_CHAR|TRAIL_INT)
-                      || (state & ~INTOVERFLOW) == (LEAD_INT|E_EXP));
+      /* A float has digits after the dot or an exponent.
+         This excludes numbers like "1." which are lexed as integers. */
+      float_syntax = ((state & TRAIL_INT)
+                      || ((state & LEAD_INT) && (state & E_EXP)));
     }
 
   if (plen)
diff --git a/src/process.c b/src/process.c
index f3f4f09f740..ce71545c117 100644
--- a/src/process.c
+++ b/src/process.c
@@ -5134,6 +5134,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                              Lisp_Object wait_for_cell,
                              struct Lisp_Process *wait_proc, int just_wait_proc)
 {
+  static int last_read_channel = -1;
   int channel, nfds;
   fd_set Available;
   fd_set Writeok;
@@ -5188,6 +5189,8 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
   while (1)
     {
       bool process_skipped = false;
+      bool wrapped;
+      int channel_start;
 
       /* If calling from keyboard input, do not quit
          since we want to return C-g as an input character.
@@ -5726,8 +5729,21 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
             d->func (channel, d->data);
         }
 
-      for (channel = 0; channel <= max_desc; channel++)
+      /* Do round robin if `process-pritoritize-lower-fds' is nil. */
+      channel_start
+        = process_prioritize_lower_fds ? 0 : last_read_channel + 1;
+
+      for (channel = channel_start, wrapped = false;
+           !wrapped || (channel < channel_start && channel <= max_desc);
+           channel++)
         {
+          if (channel > max_desc)
+            {
+              wrapped = true;
+              channel = -1;
+              continue;
+            }
+
           if (FD_ISSET (channel, &Available)
               && ((fd_callback_info[channel].flags & (KEYBOARD_FD | PROCESS_FD))
                   == PROCESS_FD))
@@ -5765,6 +5781,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                      don't try to read from any other processes
                      before doing the select again.  */
                   FD_ZERO (&Available);
+                  last_read_channel = channel;
 
                   if (do_display)
                     redisplay_preserve_echo_area (12);
@@ -8481,6 +8498,16 @@ non-nil value means that the delay is not reset on write.
 The variable takes effect when `start-process' is called.  */);
   Vprocess_adaptive_read_buffering = Qt;
 
+  DEFVAR_BOOL ("process-prioritize-lower-fds", process_prioritize_lower_fds,
+               doc: /* Whether to start checking for subprocess output from first file descriptor.
+Emacs loops through file descriptors to check for output from subprocesses.
+If this variable is nil, the default, then after accepting output from a
+subprocess, Emacs will continue checking the rest of descriptors, starting
+from the one following the descriptor it just read.  If this variable is
+non-nil, Emacs will always restart the loop from the first file descriptor,
+thus favoring processes with lower descriptors.  */);
+  process_prioritize_lower_fds = 0;
+
   DEFVAR_LISP ("interrupt-process-functions", Vinterrupt_process_functions,
                doc: /* List of functions to be called for `interrupt-process'.
 The arguments of the functions are the same as for `interrupt-process'.
diff --git a/src/sysdep.c b/src/sysdep.c
index d940acc4e05..51d8b5eeedc 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -3626,7 +3626,7 @@ system_process_attributes (Lisp_Object pid)
   ttyname = proc.ki_tdev == NODEV ? NULL : devname (proc.ki_tdev, S_IFCHR);
   unblock_input ();
   if (ttyname)
-    attrs = Fcons (Fcons (Qtty, build_string (ttyname)), attrs);
+    attrs = Fcons (Fcons (Qttname, build_string (ttyname)), attrs);
 
   attrs = Fcons (Fcons (Qtpgid,   INT_TO_INTEGER (proc.ki_tpgid)), attrs);
   attrs = Fcons (Fcons (Qminflt,  INT_TO_INTEGER (proc.ki_rusage.ru_minflt)),
@@ -3898,20 +3898,19 @@ system_process_attributes (Lisp_Object pid)
 Lisp_Object
 system_process_attributes (Lisp_Object pid)
 {
-  int proc_id;
+  int proc_id, i;
   struct passwd *pw;
   struct group  *gr;
   char *ttyname;
   struct timeval starttime;
   struct timespec t, now;
-  struct rusage *rusage;
   dev_t tdev;
   uid_t uid;
   gid_t gid;
 
   int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID};
   struct kinfo_proc proc;
-  size_t proclen = sizeof proc;
+  size_t len = sizeof proc;
 
   Lisp_Object attrs = Qnil;
   Lisp_Object decoded_comm;
@@ -3920,7 +3919,7 @@ system_process_attributes (Lisp_Object pid)
   CONS_TO_INTEGER (pid, int, proc_id);
   mib[3] = proc_id;
 
-  if (sysctl (mib, 4, &proc, &proclen, NULL, 0) != 0 || proclen == 0)
+  if (sysctl (mib, 4, &proc, &len, NULL, 0) != 0 || len == 0)
     return attrs;
 
   uid = proc.kp_eproc.e_ucred.cr_uid;
@@ -3957,8 +3956,8 @@ system_process_attributes (Lisp_Object pid)
   decoded_comm = (code_convert_string_norecord
                   (build_unibyte_string (comm),
                    Vlocale_coding_system, 0));
-
   attrs = Fcons (Fcons (Qcomm, decoded_comm), attrs);
+
   {
     char state[2] = {'\0', '\0'};
     switch (proc.kp_proc.p_stat)
@@ -3994,27 +3993,24 @@ system_process_attributes (Lisp_Object pid)
   ttyname = tdev == NODEV ? NULL : devname (tdev, S_IFCHR);
   unblock_input ();
   if (ttyname)
-    attrs = Fcons (Fcons (Qtty, build_string (ttyname)), attrs);
+    attrs = Fcons (Fcons (Qttname, build_string (ttyname)), attrs);
 
   attrs = Fcons (Fcons (Qtpgid, INT_TO_INTEGER (proc.kp_eproc.e_tpgid)),
                  attrs);
 
-  rusage = proc.kp_proc.p_ru;
-  if (rusage)
+  rusage_info_current ri;
+  if (proc_pid_rusage(proc_id, RUSAGE_INFO_CURRENT, (rusage_info_t *) &ri) == 0)
     {
-      attrs = Fcons (Fcons (Qminflt, INT_TO_INTEGER (rusage->ru_minflt)),
-                     attrs);
-      attrs = Fcons (Fcons (Qmajflt, INT_TO_INTEGER (rusage->ru_majflt)),
-                     attrs);
-
-      attrs = Fcons (Fcons (Qutime, make_lisp_timeval (rusage->ru_utime)),
-                     attrs);
-      attrs = Fcons (Fcons (Qstime, make_lisp_timeval (rusage->ru_stime)),
-                     attrs);
-      t = timespec_add (timeval_to_timespec (rusage->ru_utime),
-                        timeval_to_timespec (rusage->ru_stime));
-      attrs = Fcons (Fcons (Qtime, make_lisp_time (t)), attrs);
-    }
+      struct timespec utime = make_timespec (ri.ri_user_time / TIMESPEC_HZ,
+                                             ri.ri_user_time % TIMESPEC_HZ);
+      struct timespec stime = make_timespec (ri.ri_system_time / TIMESPEC_HZ,
+                                             ri.ri_system_time % TIMESPEC_HZ);
+      attrs = Fcons (Fcons (Qutime, make_lisp_time (utime)), attrs);
+      attrs = Fcons (Fcons (Qstime, make_lisp_time (stime)), attrs);
+      attrs = Fcons (Fcons (Qtime, make_lisp_time (timespec_add (utime, stime))), attrs);
+
+      attrs = Fcons (Fcons (Qmajflt, INT_TO_INTEGER (ri.ri_pageins)), attrs);
+  }
 
   starttime = proc.kp_proc.p_starttime;
   attrs = Fcons (Fcons (Qnice,  make_fixnum (proc.kp_proc.p_nice)), attrs);
@@ -4024,6 +4020,50 @@ system_process_attributes (Lisp_Object pid)
   t = timespec_sub (now, timeval_to_timespec (starttime));
   attrs = Fcons (Fcons (Qetime, make_lisp_time (t)), attrs);
 
+  struct proc_taskinfo taskinfo;
+  if (proc_pidinfo (proc_id, PROC_PIDTASKINFO, 0, &taskinfo, sizeof (taskinfo)) > 0)
+    {
+      attrs = Fcons (Fcons (Qvsize, make_fixnum (taskinfo.pti_virtual_size / 1024)), attrs);
+      attrs = Fcons (Fcons (Qrss, make_fixnum (taskinfo.pti_resident_size / 1024)), attrs);
+      attrs = Fcons (Fcons (Qthcount, make_fixnum (taskinfo.pti_threadnum)), attrs);
+    }
+
+#ifdef KERN_PROCARGS2
+  char args[ARG_MAX];
+  mib[1] = KERN_PROCARGS2;
+  mib[2] = proc_id;
+  len = sizeof args;
+
+  if (sysctl (mib, 3, &args, &len, NULL, 0) == 0 && len != 0)
+    {
+      char *start, *end;
+
+      int argc = *(int*)args; /* argc is the first int */
+      start = args + sizeof (int);
+
+      start += strlen (start) + 1; /* skip executable name and any '\0's */
+      while ((start - args < len) && ! *start) start++;
+
+      /* skip argv to find real end */
+      for (i = 0, end = start; i < argc && (end - args) < len; i++)
+        {
+          end += strlen (end) + 1;
+        }
+
+      len = end - start;
+      for (int i = 0; i < len; i++)
+        {
+          if (! start[i] && i < len - 1)
+            start[i] = ' ';
+        }
+
+      AUTO_STRING (comm, start);
+      decoded_comm = code_convert_string_norecord (comm,
+                                                   Vlocale_coding_system, 0);
+      attrs = Fcons (Fcons (Qargs, decoded_comm), attrs);
+    }
+#endif  /* KERN_PROCARGS2 */
+
   return attrs;
 }
 
diff --git a/src/w32.c b/src/w32.c
index 26cc28f877c..968b4bbe489 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -10587,6 +10587,45 @@ w32_my_exename (void)
   return exename;
 }
 
+/* Emulate Posix 'realpath'.  This is needed in
+   comp-el-to-eln-rel-filename.  */
+char *
+realpath (const char *file_name, char *resolved_name)
+{
+  char *tgt = chase_symlinks (file_name);
+  char target[MAX_UTF8_PATH];
+
+  if (tgt == file_name)
+    {
+      /* If FILE_NAME is not a symlink, chase_symlinks returns its
+         argument, possibly not in canonical absolute form.  Make sure
+         we return a canonical file name.  */
+      if (w32_unicode_filenames)
+        {
+          wchar_t file_w[MAX_PATH], tgt_w[MAX_PATH];
+
+          filename_to_utf16 (file_name, file_w);
+          if (GetFullPathNameW (file_w, MAX_PATH, tgt_w, NULL) == 0)
+            return NULL;
+          filename_from_utf16 (tgt_w, target);
+        }
+      else
+        {
+          char file_a[MAX_PATH], tgt_a[MAX_PATH];
+
+          filename_to_ansi (file_name, file_a);
+          if (GetFullPathNameA (file_a, MAX_PATH, tgt_a, NULL) == 0)
+            return NULL;
+          filename_from_ansi (tgt_a, target);
+        }
+      tgt = target;
+    }
+
+  if (resolved_name)
+    return strcpy (resolved_name, tgt);
+  return xstrdup (tgt);
+}
+
 /*
         globals_of_w32 is used to initialize those global variables that
         must always be initialized on startup even when the global variable
diff --git a/src/w32.h b/src/w32.h
index a382dbe791a..ffa145b1484 100644
--- a/src/w32.h
+++ b/src/w32.h
@@ -187,6 +187,7 @@ extern DWORD multiByteToWideCharFlags;
 
 extern char *w32_my_exename (void);
 extern const char *w32_relocate (const char *);
+extern char *realpath (const char *, char *);
 
 extern void init_environment (char **);
 extern void check_windows_init_file (void);