1 files changed, 91 insertions, 113 deletions

diff --git a/src/sysdep.c b/src/sysdep.c
index 11a6f4a76ce..6439697501e 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -306,7 +306,7 @@ get_child_status (pid_t child, int *status, int options, bool interruptible)
   /* If successful and status is requested, tell wait_reading_process_output
      that it needs to wake up and look around.  */
   if (pid && status && input_available_clear_time)
-    *input_available_clear_time = make_emacs_time (0, 0);
+    *input_available_clear_time = make_timespec (0, 0);
 
   return pid;
 }
@@ -337,16 +337,6 @@ child_status_changed (pid_t child, int *status, int options)
   return get_child_status (child, status, WNOHANG | options, 0);
 }
 
-/*
- *      flush any pending output
- *      (may flush input as well; it does not matter the way we use it)
- */
-
-void
-flush_pending_output (int channel)
-{
-  /* FIXME: maybe this function should be removed */
-}
 
 /*  Set up the terminal at the other end of a pseudo-terminal that
     we will be controlling an inferior through.
@@ -481,10 +471,20 @@ sys_subshell (void)
   pid_t pid;
   int status;
   struct save_signal saved_handlers[5];
-  Lisp_Object dir;
-  unsigned char *volatile str_volatile = 0;
-  unsigned char *str;
-  int len;
+  char *str = SSDATA (encode_current_directory ());
+
+#ifdef DOS_NT
+  pid = 0;
+#else
+  {
+    char *volatile str_volatile = str;
+    pid = vfork ();
+    str = str_volatile;
+  }
+#endif
+
+  if (pid < 0)
+    error ("Can't spawn subshell");
 
   saved_handlers[0].code = SIGINT;
   saved_handlers[1].code = SIGQUIT;
@@ -496,31 +496,8 @@ sys_subshell (void)
   saved_handlers[3].code = 0;
 #endif
 
-  /* Mentioning current_buffer->buffer would mean including buffer.h,
-     which somehow wedges the hp compiler.  So instead...  */
-
-  dir = intern ("default-directory");
-  if (NILP (Fboundp (dir)))
-    goto xyzzy;
-  dir = Fsymbol_value (dir);
-  if (!STRINGP (dir))
-    goto xyzzy;
-
-  dir = expand_and_dir_to_file (Funhandled_file_name_directory (dir), Qnil);
-  str_volatile = str = alloca (SCHARS (dir) + 2);
-  len = SCHARS (dir);
-  memcpy (str, SDATA (dir), len);
-  if (str[len - 1] != '/') str[len++] = '/';
-  str[len] = 0;
- xyzzy:
-
 #ifdef DOS_NT
-  pid = 0;
   save_signal_handlers (saved_handlers);
-#else
-  pid = vfork ();
-  if (pid == -1)
-    error ("Can't spawn subshell");
 #endif
 
   if (pid == 0)
@@ -538,11 +515,10 @@ sys_subshell (void)
         sh = "sh";
 
       /* Use our buffer's default directory for the subshell.  */
-      str = str_volatile;
-      if (str && chdir ((char *) str) != 0)
+      if (chdir (str) != 0)
         {
 #ifndef DOS_NT
-          emacs_perror ((char *) str);
+          emacs_perror (str);
           _exit (EXIT_CANCELED);
 #endif
         }
@@ -556,8 +532,6 @@ sys_subshell (void)
         if (epwd)
           {
             strcpy (old_pwd, epwd);
-            if (str[len - 1] == '/')
-              str[len - 1] = '\0';
             setenv ("PWD", str, 1);
           }
         st = system (sh);
@@ -614,7 +588,7 @@ restore_signal_handlers (struct save_signal *saved_handlers)
 }
 
 #ifdef USABLE_SIGIO
-static int old_fcntl_flags[MAXDESC];
+static int old_fcntl_flags[FD_SETSIZE];
 #endif
 
 void
@@ -843,7 +817,7 @@ emacs_set_tty (int fd, struct emacs_tty *settings, bool flushp)
 
 
 #ifdef F_SETOWN
-static int old_fcntl_owner[MAXDESC];
+static int old_fcntl_owner[FD_SETSIZE];
 #endif /* F_SETOWN */
 
 /* This may also be defined in stdio,
@@ -1196,7 +1170,8 @@ get_tty_size (int fd, int *widthp, int *heightp)
 }
 
 /* Set the logical window size associated with descriptor FD
-   to HEIGHT and WIDTH.  This is used mainly with ptys.  */
+   to HEIGHT and WIDTH.  This is used mainly with ptys.
+   Return a negative value on failure.  */
 
 int
 set_window_size (int fd, int height, int width)
@@ -1208,10 +1183,7 @@ set_window_size (int fd, int height, int width)
   size.ws_row = height;
   size.ws_col = width;
 
-  if (ioctl (fd, TIOCSWINSZ, &size) == -1)
-    return 0; /* error */
-  else
-    return 1;
+  return ioctl (fd, TIOCSWINSZ, &size);
 
 #else
 #ifdef TIOCSSIZE
@@ -1221,10 +1193,7 @@ set_window_size (int fd, int height, int width)
   size.ts_lines = height;
   size.ts_cols = width;
 
-  if (ioctl (fd, TIOCGSIZE, &size) == -1)
-    return 0;
-  else
-    return 1;
+  return ioctl (fd, TIOCGSIZE, &size);
 #else
   return -1;
 #endif /* not SunOS-style */
@@ -2052,8 +2021,8 @@ seed_random (void *seed, ptrdiff_t seed_size)
 void
 init_random (void)
 {
-  EMACS_TIME t = current_emacs_time ();
-  uintmax_t v = getpid () ^ EMACS_SECS (t) ^ EMACS_NSECS (t);
+  struct timespec t = current_timespec ();
+  uintmax_t v = getpid () ^ t.tv_sec ^ t.tv_nsec;
   seed_random (&v, sizeof v);
 }
 
@@ -2388,7 +2357,7 @@ emacs_perror (char const *message)
    Use the least timeval not less than T.
    Return an extremal value if the result would overflow.  */
 struct timeval
-make_timeval (EMACS_TIME t)
+make_timeval (struct timespec t)
 {
   struct timeval tv;
   tv.tv_sec = t.tv_sec;
@@ -2415,7 +2384,7 @@ make_timeval (EMACS_TIME t)
    If FD is nonnegative, then FILE can be NULL.  */
 int
 set_file_times (int fd, const char *filename,
-                EMACS_TIME atime, EMACS_TIME mtime)
+                struct timespec atime, struct timespec mtime)
 {
   struct timespec timespec[2];
   timespec[0] = atime;
@@ -2485,7 +2454,7 @@ serial_configure (struct Lisp_Process *p,
   Lisp_Object childp2 = Qnil;
   Lisp_Object tem = Qnil;
   struct termios attr;
-  int err = -1;
+  int err;
   char summary[4] = "???"; /* This usually becomes "8N1".  */
 
   childp2 = Fcopy_sequence (p->childp);
@@ -2732,7 +2701,7 @@ list_system_processes (void)
 #endif /* !defined (WINDOWSNT) */
 
 #if defined GNU_LINUX && defined HAVE_LONG_LONG_INT
-static EMACS_TIME
+static struct timespec
 time_from_jiffies (unsigned long long tval, long hz)
 {
   unsigned long long s = tval / hz;
@@ -2741,34 +2710,34 @@ time_from_jiffies (unsigned long long tval, long hz)
 
   if (TYPE_MAXIMUM (time_t) < s)
     time_overflow ();
-  if (LONG_MAX - 1 <= ULLONG_MAX / EMACS_TIME_RESOLUTION
-      || frac <= ULLONG_MAX / EMACS_TIME_RESOLUTION)
-    ns = frac * EMACS_TIME_RESOLUTION / hz;
+  if (LONG_MAX - 1 <= ULLONG_MAX / TIMESPEC_RESOLUTION
+      || frac <= ULLONG_MAX / TIMESPEC_RESOLUTION)
+    ns = frac * TIMESPEC_RESOLUTION / hz;
   else
     {
       /* This is reachable only in the unlikely case that HZ * HZ
          exceeds ULLONG_MAX.  It calculates an approximation that is
          guaranteed to be in range.  */
-      long hz_per_ns = (hz / EMACS_TIME_RESOLUTION
-                        + (hz % EMACS_TIME_RESOLUTION != 0));
+      long hz_per_ns = (hz / TIMESPEC_RESOLUTION
+                        + (hz % TIMESPEC_RESOLUTION != 0));
       ns = frac / hz_per_ns;
     }
 
-  return make_emacs_time (s, ns);
+  return make_timespec (s, ns);
 }
 
 static Lisp_Object
 ltime_from_jiffies (unsigned long long tval, long hz)
 {
-  EMACS_TIME t = time_from_jiffies (tval, hz);
+  struct timespec t = time_from_jiffies (tval, hz);
   return make_lisp_time (t);
 }
 
-static EMACS_TIME
+static struct timespec
 get_up_time (void)
 {
   FILE *fup;
-  EMACS_TIME up = make_emacs_time (0, 0);
+  struct timespec up = make_timespec (0, 0);
 
   block_input ();
   fup = emacs_fopen ("/proc/uptime", "r");
@@ -2786,18 +2755,18 @@ get_up_time (void)
           if (TYPE_MAXIMUM (time_t) < upsec)
             {
               upsec = TYPE_MAXIMUM (time_t);
-              upfrac = EMACS_TIME_RESOLUTION - 1;
+              upfrac = TIMESPEC_RESOLUTION - 1;
             }
           else
             {
               int upfraclen = upfrac_end - upfrac_start;
-              for (; upfraclen < LOG10_EMACS_TIME_RESOLUTION; upfraclen++)
+              for (; upfraclen < LOG10_TIMESPEC_RESOLUTION; upfraclen++)
                 upfrac *= 10;
-              for (; LOG10_EMACS_TIME_RESOLUTION < upfraclen; upfraclen--)
+              for (; LOG10_TIMESPEC_RESOLUTION < upfraclen; upfraclen--)
                 upfrac /= 10;
-              upfrac = min (upfrac, EMACS_TIME_RESOLUTION - 1);
+              upfrac = min (upfrac, TIMESPEC_RESOLUTION - 1);
             }
-          up = make_emacs_time (upsec, upfrac);
+          up = make_timespec (upsec, upfrac);
         }
       fclose (fup);
     }
@@ -2852,29 +2821,41 @@ procfs_ttyname (int rdev)
   return build_string (name);
 }
 
-static unsigned long
+static uintmax_t
 procfs_get_total_memory (void)
 {
   FILE *fmem;
-  unsigned long retval = 2 * 1024 * 1024; /* default: 2GB */
+  uintmax_t retval = 2 * 1024 * 1024; /* default: 2 GiB */
+  int c;
 
   block_input ();
   fmem = emacs_fopen ("/proc/meminfo", "r");
 
   if (fmem)
     {
-      unsigned long entry_value;
-      char entry_name[20];      /* the longest I saw is 13+1 */
+      uintmax_t entry_value;
+      bool done;
+
+      do
+        switch (fscanf (fmem, "MemTotal: %"SCNuMAX, &entry_value))
+          {
+          case 1:
+            retval = entry_value;
+            done = 1;
+            break;
+
+          case 0:
+            while ((c = getc (fmem)) != EOF && c != '\n')
+              continue;
+            done = c == EOF;
+            break;
+
+          default:
+            done = 1;
+            break;
+          }
+      while (!done);
 
-      while (!feof (fmem) && !ferror (fmem))
-        {
-          if (fscanf (fmem, "%s %lu kB\n", entry_name, &entry_value) >= 2
-              && strcmp (entry_name, "MemTotal:") == 0)
-            {
-              retval = entry_value;
-              break;
-            }
-        }
       fclose (fmem);
     }
   unblock_input ();
@@ -2906,7 +2887,7 @@ system_process_attributes (Lisp_Object pid)
   unsigned long long u_time, s_time, cutime, cstime, start;
   long priority, niceness, rss;
   unsigned long minflt, majflt, cminflt, cmajflt, vsize;
-  EMACS_TIME tnow, tstart, tboot, telapsed, us_time;
+  struct timespec tnow, tstart, tboot, telapsed, us_time;
   double pcpu, pmem;
   Lisp_Object attrs = Qnil;
   Lisp_Object cmd_str, decoded_cmd;
@@ -3027,20 +3008,19 @@ system_process_attributes (Lisp_Object pid)
           attrs = Fcons (Fcons (Qnice, make_number (niceness)), attrs);
           attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (thcount)),
                          attrs);
-          tnow = current_emacs_time ();
+          tnow = current_timespec ();
           telapsed = get_up_time ();
-          tboot = sub_emacs_time (tnow, telapsed);
+          tboot = timespec_sub (tnow, telapsed);
           tstart = time_from_jiffies (start, clocks_per_sec);
-          tstart = add_emacs_time (tboot, tstart);
+          tstart = timespec_add (tboot, tstart);
           attrs = Fcons (Fcons (Qstart, make_lisp_time (tstart)), attrs);
           attrs = Fcons (Fcons (Qvsize, make_fixnum_or_float (vsize / 1024)),
                          attrs);
           attrs = Fcons (Fcons (Qrss, make_fixnum_or_float (4 * rss)), attrs);
-          telapsed = sub_emacs_time (tnow, tstart);
+          telapsed = timespec_sub (tnow, tstart);
           attrs = Fcons (Fcons (Qetime, make_lisp_time (telapsed)), attrs);
           us_time = time_from_jiffies (u_time + s_time, clocks_per_sec);
-          pcpu = (EMACS_TIME_TO_DOUBLE (us_time)
-                  / EMACS_TIME_TO_DOUBLE (telapsed));
+          pcpu = timespectod (us_time) / timespectod (telapsed);
           if (pcpu > 1.0)
             pcpu = 1.0;
           attrs = Fcons (Fcons (Qpcpu, make_float (100 * pcpu)), attrs);
@@ -3243,13 +3223,11 @@ system_process_attributes (Lisp_Object pid)
                      attrs);
 
       decoded_cmd = (code_convert_string_norecord
-                     (make_unibyte_string (pinfo.pr_fname,
-                                           strlen (pinfo.pr_fname)),
+                     (build_unibyte_string (pinfo.pr_fname),
                       Vlocale_coding_system, 0));
       attrs = Fcons (Fcons (Qcomm, decoded_cmd), attrs);
       decoded_cmd = (code_convert_string_norecord
-                     (make_unibyte_string (pinfo.pr_psargs,
-                                           strlen (pinfo.pr_psargs)),
+                     (build_unibyte_string (pinfo.pr_psargs),
                       Vlocale_coding_system, 0));
       attrs = Fcons (Fcons (Qargs, decoded_cmd), attrs);
     }
@@ -3260,16 +3238,16 @@ system_process_attributes (Lisp_Object pid)
 
 #elif defined __FreeBSD__
 
-static EMACS_TIME
-timeval_to_EMACS_TIME (struct timeval t)
+static struct timespec
+timeval_to_timespec (struct timeval t)
 {
-  return make_emacs_time (t.tv_sec, t.tv_usec * 1000);
+  return make_timespec (t.tv_sec, t.tv_usec * 1000);
 }
 
 static Lisp_Object
 make_lisp_timeval (struct timeval t)
 {
-  return make_lisp_time (timeval_to_EMACS_TIME (t));
+  return make_lisp_time (timeval_to_timespec (t));
 }
 
 Lisp_Object
@@ -3277,14 +3255,14 @@ system_process_attributes (Lisp_Object pid)
 {
   int proc_id;
   int pagesize = getpagesize ();
-  int npages;
+  unsigned long npages;
   int fscale;
   struct passwd *pw;
   struct group  *gr;
   char *ttyname;
   size_t len;
   char args[MAXPATHLEN];
-  EMACS_TIME t, now;
+  struct timespec t, now;
 
   int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID};
   struct kinfo_proc proc;
@@ -3319,9 +3297,9 @@ system_process_attributes (Lisp_Object pid)
   if (gr)
     attrs = Fcons (Fcons (Qgroup, build_string (gr->gr_name)), attrs);
 
-  decoded_comm = code_convert_string_norecord
-    (make_unibyte_string (proc.ki_comm, strlen (proc.ki_comm)),
-     Vlocale_coding_system, 0);
+  decoded_comm = (code_convert_string_norecord
+                  (build_unibyte_string (proc.ki_comm),
+                   Vlocale_coding_system, 0));
 
   attrs = Fcons (Fcons (Qcomm, decoded_comm), attrs);
   {
@@ -3371,8 +3349,8 @@ system_process_attributes (Lisp_Object pid)
                  attrs);
   attrs = Fcons (Fcons (Qstime, make_lisp_timeval (proc.ki_rusage.ru_stime)),
                  attrs);
-  t = add_emacs_time (timeval_to_EMACS_TIME (proc.ki_rusage.ru_utime),
-                      timeval_to_EMACS_TIME (proc.ki_rusage.ru_stime));
+  t = timespec_add (timeval_to_timespec (proc.ki_rusage.ru_utime),
+                    timeval_to_timespec (proc.ki_rusage.ru_stime));
   attrs = Fcons (Fcons (Qtime, make_lisp_time (t)), attrs);
 
   attrs = Fcons (Fcons (Qcutime,
@@ -3381,8 +3359,8 @@ system_process_attributes (Lisp_Object pid)
   attrs = Fcons (Fcons (Qcstime,
                         make_lisp_timeval (proc.ki_rusage_ch.ru_utime)),
                  attrs);
-  t = add_emacs_time (timeval_to_EMACS_TIME (proc.ki_rusage_ch.ru_utime),
-                      timeval_to_EMACS_TIME (proc.ki_rusage_ch.ru_stime));
+  t = timespec_add (timeval_to_timespec (proc.ki_rusage_ch.ru_utime),
+                    timeval_to_timespec (proc.ki_rusage_ch.ru_stime));
   attrs = Fcons (Fcons (Qctime, make_lisp_time (t)), attrs);
 
   attrs = Fcons (Fcons (Qthcount, make_fixnum_or_float (proc.ki_numthreads)),
@@ -3394,8 +3372,8 @@ system_process_attributes (Lisp_Object pid)
   attrs = Fcons (Fcons (Qrss,   make_number (proc.ki_rssize * pagesize >> 10)),
                  attrs);
 
-  now = current_emacs_time ();
-  t = sub_emacs_time (now, timeval_to_EMACS_TIME (proc.ki_start));
+  now = current_timespec ();
+  t = timespec_sub (now, timeval_to_timespec (proc.ki_start));
   attrs = Fcons (Fcons (Qetime, make_lisp_time (t)), attrs);
 
   len = sizeof fscale;