merge trun

12 files changed, 314 insertions, 133 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index a5f76b22def..e3371796bfb 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -3,6 +3,76 @@
         * font.c (Ffont_at): If WINDOW is specified and it is not
         displaying the current buffer, signal an error.
 
+2012-10-29  Daniel Colascione  <dancol@dancol.org>
+
+        * cygw32.h, cygw32.c (Qutf_16le, from_unicode, to_unicode): In
+        preparation for fixing bug#12739, move these functions from
+        here...
+
+        * coding.h, coding.c: ... to here, and compile them only when
+        WINDOWSNT or CYGWIN.  Moving these functions out of cygw32 proper
+        lets us write cygw32-agnostic code for the HAVE_NTGUI case.
+
+2012-10-28  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32proc.c (TIMER_TICKS_PER_SEC): New macro.
+        (timer_loop, getitimer, setitimer): Use it instead of
+        CLOCKS_PER_SEC, which is no longer pertinent, since we don't use
+        'clock'.
+        (w32_get_timer_time): Use 10*TIMER_TICKS_PER_SEC instead of a
+        literal 10000.
+
+2012-10-28  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (NO_APPDEFINED_DATA): New define.
+        (last_appdefined_event_data): New variable
+        (last_appdefined_event): Remove.
+        (ns_select): Initialize t from last_appdefined_event_data instead
+        of [last_appdefined_event data1].
+        (sendEvent:): Save [theEvent data1] to last_appdefined_event_data,
+        remove last_appdefined_event (Bug#12698).
+
+2012-10-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * frame.c (x_set_font): Catch internal error.
+
+2012-10-27  Eli Zaretskii  <eliz@gnu.org>
+
+        Avoid overflow in w32 implementation of interval timers.
+        When possible, for ITIMER_PROF count only times the main thread
+        actually executes.
+        * w32proc.c <struct itimer_data>: 'expire' and 'reload' are now
+        'volatile ULONGLONG' types.  All the other data which was
+        previously clock_t is now ULONGLONG.  'terminate' is 'volatile int'.
+        (GetThreadTimes_Proc): New typedef.
+        (w32_get_timer_time): New function, returns a suitable time value
+        for the timer.
+        (timer_loop): Enter critical section when accessing ULONGLONG
+        values of the itimer_data struct, as these accesses are no longer
+        atomic.  Call 'w32_get_timer_time' instead of 'clock'.
+        Remove unused variable.
+        (init_timers): Initialize s_pfn_Get_Thread_Times.
+        (start_timer_thread): Don't assign itimer->caller_thread here.
+        (getitimer): Assign itimer->caller_thread here.
+        (setitimer): Always call getitimer to get the value of ticks_now.
+        (sys_spawnve): Avoid compiler warning about format mismatch.
+
+2012-10-26  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32fns.c (w32_wnd_proc) <WM_MOUSEMOVE>: Don't enable tracking of
+        mouse movement events if the menu bar is active.  This avoids
+        producing a busy "hour-glass" cursor by Windows if the mouse
+        pointer is positioned over a tooltip shown for some menu item.
+
+2012-10-25  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Don't assume process IDs fit in int.
+        * emacs.c (shut_down_emacs) [!DOS_NT]:
+        * sysdep.c (sys_suspend) [SIGTSTP && !MSDOS]:
+        * term.c (dissociate_if_controlling_tty) [!DOS_NT]:
+        Use pid_t, not int, to store process IDs, as 'int'
+        is not wide enough on a few platforms (e.g., AIX and IRIX).
+
 2012-10-23  Kenichi Handa  <handa@gnu.org>
 
         The following change is to make face-font-rescale-alist work
@@ -60,8 +130,8 @@
 
 2012-10-19  Eli Zaretskii  <eliz@gnu.org>
 
-        * puresize.h (BASE_PURESIZE): Bump the base value to 1700000.  See
-        http://lists.gnu.org/archive/html/emacs-devel/2012-10/msg00593.html
+        * puresize.h (BASE_PURESIZE): Bump the base value to 1700000.
+        See http://lists.gnu.org/archive/html/emacs-devel/2012-10/msg00593.html
         for the reasons.
 
         * alloc.c (NSTATICS): Decrease to 0x800.
@@ -680,8 +750,8 @@
         (ns_clear_frame_area): Remove resize handle code.
 
         * nsfns.m (ns_in_resize): Remove.
-        (x_set_icon_name, ns_set_name, ns_set_name_as_filename): Remove
-        ns_in_resize check.
+        (x_set_icon_name, ns_set_name, ns_set_name_as_filename):
+        Remove ns_in_resize check.
 
 2012-10-07  Paul Eggert  <eggert@cs.ucla.edu>
 
diff --git a/src/coding.c b/src/coding.c
index 7628a9fbf2e..56202e4861d 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -343,6 +343,10 @@ Lisp_Object Qcoding_system_p, Qcoding_system_error;
 Lisp_Object Qemacs_mule, Qraw_text;
 Lisp_Object Qutf_8_emacs;
 
+#if defined (WINDOWSNT) || defined (CYGWIN)
+static Lisp_Object Qutf_16le;
+#endif
+
 /* Coding-systems are handed between Emacs Lisp programs and C internal
    routines by the following three variables.  */
 /* Coding system to be used to encode text for terminal display when
@@ -7971,6 +7975,40 @@ preferred_coding_system (void)
   return CODING_ID_NAME (id);
 }
 
+#if defined (WINDOWSNT) || defined (CYGWIN)
+
+Lisp_Object
+from_unicode (Lisp_Object str)
+{
+  CHECK_STRING (str);
+  if (!STRING_MULTIBYTE (str) &&
+      SBYTES (str) & 1)
+    {
+      str = Fsubstring (str, make_number (0), make_number (-1));
+    }
+
+  return code_convert_string_norecord (str, Qutf_16le, 0);
+}
+
+wchar_t *
+to_unicode (Lisp_Object str, Lisp_Object *buf)
+{
+  *buf = code_convert_string_norecord (str, Qutf_16le, 1);
+  /* We need to make a another copy (in addition to the one made by
+     code_convert_string_norecord) to ensure that the final string is
+     _doubly_ zero terminated --- that is, that the string is
+     terminated by two zero bytes and one utf-16le null character.
+     Because strings are already terminated with a single zero byte,
+     we just add one additional zero. */
+  str = make_uninit_string (SBYTES (*buf) + 1);
+  memcpy (SDATA (str), SDATA (*buf), SBYTES (*buf));
+  SDATA (str) [SBYTES (*buf)] = '\0';
+  *buf = str;
+  return WCSDATA (*buf);
+}
+
+#endif /* WINDOWSNT || CYGWIN */
+
 
 #ifdef emacs
 /*** 8. Emacs Lisp library functions ***/
@@ -10284,6 +10322,11 @@ syms_of_coding (void)
   DEFSYM (Qutf_8, "utf-8");
   DEFSYM (Qutf_8_emacs, "utf-8-emacs");
 
+#if defined (WINDOWSNT) || defined (CYGWIN)
+  /* No, not utf-16-le: that one has a BOM.  */
+  DEFSYM (Qutf_16le, "utf-16le");
+#endif
+
   DEFSYM (Qutf_16, "utf-16");
   DEFSYM (Qbig, "big");
   DEFSYM (Qlittle, "little");
diff --git a/src/coding.h b/src/coding.h
index 989552bf667..192be58f083 100644
--- a/src/coding.h
+++ b/src/coding.h
@@ -701,6 +701,28 @@ extern void encode_coding_object (struct coding_system *,
                                   Lisp_Object, ptrdiff_t, ptrdiff_t,
                                   ptrdiff_t, ptrdiff_t, Lisp_Object);
 
+#if defined (WINDOWSNT) || defined (CYGWIN)
+
+/* These functions use Lisp string objects to store the UTF-16LE
+   strings that modern versions of Windows expect.  These strings are
+   not particularly useful to Lisp, and all Lisp strings should be
+   native Emacs multibyte.  */
+
+/* Access the wide-character string stored in a Lisp string object.  */
+#define WCSDATA(x) ((wchar_t *) SDATA (x))
+
+/* Convert the multi-byte string in STR to UTF-16LE encoded unibyte
+   string, and store it in *BUF.  BUF may safely point to STR on entry.  */
+extern wchar_t *to_unicode (Lisp_Object str, Lisp_Object *buf);
+
+/* Convert STR, a UTF-16LE encoded string embedded in a unibyte string
+   object, to a multi-byte Emacs string and return it.  This function
+   calls code_convert_string_norecord internally and has all its
+   failure modes.  STR itself is not modified.  */
+extern Lisp_Object from_unicode (Lisp_Object str);
+
+#endif /* WINDOWSNT || CYGWIN */
+
 /* Macros for backward compatibility.  */
 
 #define decode_coding_region(coding, from, to)          \
diff --git a/src/cygw32.c b/src/cygw32.c
index 8f63461da2a..54f2076a891 100644
--- a/src/cygw32.c
+++ b/src/cygw32.c
@@ -22,7 +22,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "buffer.h"
 #include <unistd.h>
 #include <fcntl.h>
-static Lisp_Object Qutf_16le;
 
 static Lisp_Object
 fchdir_unwind (Lisp_Object dir_fd)
@@ -107,36 +106,6 @@ conv_filename_from_w32_unicode (const wchar_t* in, int absolute_p)
   return unbind_to (count, DECODE_FILE (converted));
 }
 
-Lisp_Object
-from_unicode (Lisp_Object str)
-{
-  CHECK_STRING (str);
-  if (!STRING_MULTIBYTE (str) &&
-      SBYTES (str) & 1)
-    {
-      str = Fsubstring (str, make_number (0), make_number (-1));
-    }
-
-  return code_convert_string_norecord (str, Qutf_16le, 0);
-}
-
-wchar_t *
-to_unicode (Lisp_Object str, Lisp_Object *buf)
-{
-  *buf = code_convert_string_norecord (str, Qutf_16le, 1);
-  /* We need to make a another copy (in addition to the one made by
-     code_convert_string_norecord) to ensure that the final string is
-     _doubly_ zero terminated --- that is, that the string is
-     terminated by two zero bytes and one utf-16le null character.
-     Because strings are already terminated with a single zero byte,
-     we just add one additional zero. */
-  str = make_uninit_string (SBYTES (*buf) + 1);
-  memcpy (SDATA (str), SDATA (*buf), SBYTES (*buf));
-  SDATA (str) [SBYTES (*buf)] = '\0';
-  *buf = str;
-  return WCSDATA (*buf);
-}
-
 DEFUN ("cygwin-convert-path-to-windows",
        Fcygwin_convert_path_to_windows, Scygwin_convert_path_to_windows,
        1, 2, 0,
@@ -162,8 +131,6 @@ DEFUN ("cygwin-convert-path-from-windows",
 void
 syms_of_cygw32 (void)
 {
-  /* No, not utf-16-le: that one has a BOM.  */
-  DEFSYM (Qutf_16le, "utf-16le");
   defsubr (&Scygwin_convert_path_from_windows);
   defsubr (&Scygwin_convert_path_to_windows);
 }
diff --git a/src/cygw32.h b/src/cygw32.h
index 78e77a9a141..51571913fd1 100644
--- a/src/cygw32.h
+++ b/src/cygw32.h
@@ -33,20 +33,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "coding.h"
 
-/* *** Character conversion *** */
-
-/* Access the wide-character string stored in a Lisp string object.  */
-#define WCSDATA(x) ((wchar_t *) SDATA (x))
-
-/* Convert the multi-byte string in STR to UTF-16LE encoded unibyte
-   string, and store it in *BUF.  BUF may safely point to STR on entry.  */
-extern wchar_t *to_unicode (Lisp_Object str, Lisp_Object *buf);
-
-/* Convert STR, a UTF-16LE encoded string embedded in a unibyte string
-   object, to a multi-byte Emacs string, and return it.  */
-extern Lisp_Object from_unicode (Lisp_Object str);
-
-/* *** Misc *** */
 extern void syms_of_cygw32 (void);
 extern char * w32_strerror (int error_no);
 
diff --git a/src/emacs.c b/src/emacs.c
index 0a2a60bee0c..7f3228641ae 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -1903,8 +1903,8 @@ shut_down_emacs (int sig, Lisp_Object stuff)
   /* If we are controlling the terminal, reset terminal modes.  */
 #ifndef DOS_NT
   {
-    int pgrp = EMACS_GETPGRP (0);
-    int tpgrp = tcgetpgrp (0);
+    pid_t pgrp = EMACS_GETPGRP (0);
+    pid_t tpgrp = tcgetpgrp (0);
     if ((tpgrp != -1) && tpgrp == pgrp)
       {
         reset_all_sys_modes ();
diff --git a/src/frame.c b/src/frame.c
index 6478ad1e06f..17a99000c9b 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -3242,6 +3242,9 @@ x_set_font (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
           Lisp_Object ascii_font = fontset_ascii (fontset);
           Lisp_Object spec = font_spec_from_name (ascii_font);
 
+          if (NILP (spec))
+            signal_error ("Invalid font name", ascii_font);
+
           if (! font_match_p (spec, font_object))
             fontset = -1;
         }
diff --git a/src/nsterm.m b/src/nsterm.m
index a4eaad47ac1..9b2e544c75b 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -190,7 +190,8 @@ static BOOL ns_menu_bar_is_hidden = NO;
 
 /* event loop */
 static BOOL send_appdefined = YES;
-static NSEvent *last_appdefined_event = 0;
+#define NO_APPDEFINED_DATA (-8)
+static int last_appdefined_event_data = NO_APPDEFINED_DATA;
 static NSTimer *timed_entry = 0;
 static NSTimer *scroll_repeat_entry = nil;
 static fd_set select_readfds, select_writefds;
@@ -3436,8 +3437,7 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
    -------------------------------------------------------------------------- */
 {
   int result;
-  NSEvent *ev;
-  int k, nr = 0;
+  int t, k, nr = 0;
   struct input_event event;
   char c;
 
@@ -3521,16 +3521,11 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
     }
   unblock_input ();
 
-  ev = last_appdefined_event;
+  t = last_appdefined_event_data;
 
-  if (ev)
+  if (t != NO_APPDEFINED_DATA)
     {
-      int t;
-      if ([ev type] != NSApplicationDefined)
-        emacs_abort ();
-
-      t = [ev data1];
-      last_appdefined_event = 0;
+      last_appdefined_event_data = NO_APPDEFINED_DATA;
 
       if (t == -2)
         {
@@ -4307,7 +4302,7 @@ ns_term_shutdown (int sig)
          modal loop. Just defer it until later. */
       if ([NSApp modalWindow] == nil)
         {
-          last_appdefined_event = theEvent;
+          last_appdefined_event_data = [theEvent data1];
           [self stop: self];
         }
       else
diff --git a/src/sysdep.c b/src/sysdep.c
index 35beeaa7202..c7174e91612 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -452,7 +452,7 @@ sys_suspend (void)
 #if defined (SIGTSTP) && !defined (MSDOS)
 
   {
-    int pgrp = EMACS_GETPGRP (0);
+    pid_t pgrp = EMACS_GETPGRP (0);
     EMACS_KILLPG (pgrp, SIGTSTP);
   }
 
diff --git a/src/term.c b/src/term.c
index f7c87b7608d..74b02b0af27 100644
--- a/src/term.c
+++ b/src/term.c
@@ -2919,7 +2919,7 @@ static void
 dissociate_if_controlling_tty (int fd)
 {
 #ifndef DOS_NT
-  int pgid = tcgetpgrp (fd); /* If tcgetpgrp succeeds, fd is the ctty. */
+  pid_t pgid = tcgetpgrp (fd); /* If tcgetpgrp succeeds, fd is the ctty. */
   if (pgid != -1)
     {
 #if defined (USG5)
diff --git a/src/w32fns.c b/src/w32fns.c
index 28e8ea02e05..aa120d59ce5 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -3331,7 +3331,19 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
          versions, there is no way of telling when the mouse leaves the
          frame, so we just have to put up with help-echo and mouse
          highlighting remaining while the frame is not active.  */
-      if (track_mouse_event_fn && !track_mouse_window)
+      if (track_mouse_event_fn && !track_mouse_window
+          /* If the menu bar is active, turning on tracking of mouse
+             movement events might send these events to the tooltip
+             frame, if the user happens to move the mouse pointer over
+             the tooltip.  But since we don't process events for
+             tooltip frames, this causes Windows to present a
+             hourglass cursor, which is ugly and unexpected.  So don't
+             enable tracking mouse events in this case; they will be
+             restarted when the menu pops down.  (Confusingly, the
+             menubar_active member of f->output_data.w32, tested
+             above, is only set when a menu was popped up _not_ from
+             the frame's menu bar, but via x-popup-menu.)  */
+          && !menubar_in_use)
         {
           TRACKMOUSEEVENT tme;
           tme.cbSize = sizeof (tme);
diff --git a/src/w32proc.c b/src/w32proc.c
index 57b3860cb76..d45d9879a24 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -244,28 +244,92 @@ setpgrp (int pid, int gid)
    the thread calls the appropriate signal handler when the timer
    expires, after stopping the thread which installed the timer.  */
 
-/* FIXME: clock_t counts overflow after 49 days, need to handle the
-   wrap-around.  */
 struct itimer_data {
-  clock_t expire;
-  clock_t reload;
-  int terminate;
+  volatile ULONGLONG expire;
+  volatile ULONGLONG reload;
+  volatile int terminate;
   int type;
   HANDLE caller_thread;
   HANDLE timer_thread;
 };
 
-static clock_t ticks_now;
+static ULONGLONG ticks_now;
 static struct itimer_data real_itimer, prof_itimer;
-static clock_t clocks_min;
+static ULONGLONG clocks_min;
 /* If non-zero, itimers are disabled.  Used during shutdown, when we
    delete the critical sections used by the timer threads.  */
 static int disable_itimers;
 
 static CRITICAL_SECTION crit_real, crit_prof;
 
-#define MAX_SINGLE_SLEEP 30
+/* GetThreadTimes is not available on Windows 9X and possibly also on 2K.  */
+typedef BOOL (WINAPI *GetThreadTimes_Proc) (
+  HANDLE hThread,
+  LPFILETIME lpCreationTime,
+  LPFILETIME lpExitTime,
+  LPFILETIME lpKernelTime,
+  LPFILETIME lpUserTime);
+
+static GetThreadTimes_Proc s_pfn_Get_Thread_Times;
+
+#define MAX_SINGLE_SLEEP    30
+#define TIMER_TICKS_PER_SEC 1000
+
+/* Return a suitable time value, in 1-ms units, for THREAD, a handle
+   to a thread.  If THREAD is NULL or an invalid handle, return the
+   current wall-clock time since January 1, 1601 (UTC).  Otherwise,
+   return the sum of kernel and user times used by THREAD since it was
+   created, plus its creation time.  */
+static ULONGLONG
+w32_get_timer_time (HANDLE thread)
+{
+  ULONGLONG retval;
+  int use_system_time = 1;
+  /* The functions below return times in 100-ns units.  */
+  const int tscale = 10 * TIMER_TICKS_PER_SEC;
+
+  if (thread && thread != INVALID_HANDLE_VALUE
+      && s_pfn_Get_Thread_Times != NULL)
+    {
+      FILETIME creation_ftime, exit_ftime, kernel_ftime, user_ftime;
+      ULARGE_INTEGER temp_creation, temp_kernel, temp_user;
+
+      if (s_pfn_Get_Thread_Times (thread, &creation_ftime, &exit_ftime,
+                                  &kernel_ftime, &user_ftime))
+        {
+          use_system_time = 0;
+          temp_creation.LowPart = creation_ftime.dwLowDateTime;
+          temp_creation.HighPart = creation_ftime.dwHighDateTime;
+          temp_kernel.LowPart = kernel_ftime.dwLowDateTime;
+          temp_kernel.HighPart = kernel_ftime.dwHighDateTime;
+          temp_user.LowPart = user_ftime.dwLowDateTime;
+          temp_user.HighPart = user_ftime.dwHighDateTime;
+          retval =
+            temp_creation.QuadPart / tscale + temp_kernel.QuadPart / tscale
+            + temp_user.QuadPart / tscale;
+        }
+      else
+        DebPrint (("GetThreadTimes failed with error code %lu\n",
+                   GetLastError ()));
+    }
+
+  if (use_system_time)
+    {
+      FILETIME current_ftime;
+      ULARGE_INTEGER temp;
+
+      GetSystemTimeAsFileTime (&current_ftime);
+
+      temp.LowPart = current_ftime.dwLowDateTime;
+      temp.HighPart = current_ftime.dwHighDateTime;
+
+      retval = temp.QuadPart / tscale;
+    }
 
+  return retval;
+}
+
+/* Thread function for a timer thread.  */
 static DWORD WINAPI
 timer_loop (LPVOID arg)
 {
@@ -273,14 +337,14 @@ timer_loop (LPVOID arg)
   int which = itimer->type;
   int sig = (which == ITIMER_REAL) ? SIGALRM : SIGPROF;
   CRITICAL_SECTION *crit = (which == ITIMER_REAL) ? &crit_real : &crit_prof;
-  const DWORD max_sleep = MAX_SINGLE_SLEEP * 1000 / CLOCKS_PER_SEC;
-  int new_count = 0;
+  const DWORD max_sleep = MAX_SINGLE_SLEEP * 1000 / TIMER_TICKS_PER_SEC;
+  HANDLE hth = (which == ITIMER_REAL) ? NULL : itimer->caller_thread;
 
   while (1)
     {
       DWORD sleep_time;
       signal_handler handler;
-      clock_t now, expire, reload;
+      ULONGLONG now, expire, reload;
 
       /* Load new values if requested by setitimer.  */
       EnterCriticalSection (crit);
@@ -290,15 +354,14 @@ timer_loop (LPVOID arg)
       if (itimer->terminate)
         return 0;
 
-      if (itimer->expire == 0)
+      if (expire == 0)
         {
           /* We are idle.  */
           Sleep (max_sleep);
           continue;
         }
 
-      expire = itimer->expire;
-      if (expire > (now = clock ()))
+      if (expire > (now = w32_get_timer_time (hth)))
         sleep_time = expire - now;
       else
         sleep_time = 0;
@@ -309,24 +372,30 @@ timer_loop (LPVOID arg)
           if (itimer->terminate)
             return 0;
           Sleep (max_sleep);
+          EnterCriticalSection (crit);
           expire = itimer->expire;
-          sleep_time = (expire > (now = clock ())) ? expire - now : 0;
+          LeaveCriticalSection (crit);
+          sleep_time =
+            (expire > (now = w32_get_timer_time (hth))) ? expire - now : 0;
         }
       if (itimer->terminate)
         return 0;
       if (sleep_time > 0)
         {
-          Sleep (sleep_time * 1000 / CLOCKS_PER_SEC);
+          Sleep (sleep_time * 1000 / TIMER_TICKS_PER_SEC);
           /* Always sleep past the expiration time, to make sure we
              never call the handler _before_ the expiration time,
              always slightly after it.  Sleep(5) makes sure we don't
-             hog the CPU by calling 'clock' with high frequency, and
-             also let other threads work.  */
-          while (clock () < expire)
+             hog the CPU by calling 'w32_get_timer_time' with high
+             frequency, and also let other threads work.  */
+          while (w32_get_timer_time (hth) < expire)
             Sleep (5);
         }
 
-      if (itimer->expire == 0)
+      EnterCriticalSection (crit);
+      expire = itimer->expire;
+      LeaveCriticalSection (crit);
+      if (expire == 0)
         continue;
 
       /* Time's up.  */
@@ -353,19 +422,21 @@ timer_loop (LPVOID arg)
           ResumeThread (itimer->caller_thread);
         }
 
-      if (itimer->expire == 0)
-        continue;
-
       /* Update expiration time and loop.  */
       EnterCriticalSection (crit);
       expire = itimer->expire;
+      if (expire == 0)
+        {
+          LeaveCriticalSection (crit);
+          continue;
+        }
       reload = itimer->reload;
       if (reload > 0)
         {
-          now = clock ();
+          now = w32_get_timer_time (hth);
           if (expire <= now)
             {
-              clock_t lag = now - expire;
+              ULONGLONG lag = now - expire;
 
               /* If we missed some opportunities (presumably while
                  sleeping or while the signal handler ran), skip
@@ -448,6 +519,15 @@ term_timers (void)
 void
 init_timers (void)
 {
+  /* GetThreadTimes is not avaiulable on all versions of Windows, so
+     need to probe for its availability dynamically, and call it
+     through a pointer.  */
+  s_pfn_Get_Thread_Times = NULL; /* in case dumped Emacs comes with a value */
+  if (os_subtype != OS_9X)
+    s_pfn_Get_Thread_Times =
+      (GetThreadTimes_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
+                                           "GetThreadTimes");
+
   /* Make sure we start with zeroed out itimer structures, since
      dumping may have left there traces of threads long dead.  */
   memset (&real_itimer, 0, sizeof real_itimer);
@@ -473,14 +553,6 @@ start_timer_thread (int which)
     return 0;
 
   /* Start a new thread.  */
-  if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
-                        GetCurrentProcess (), &itimer->caller_thread, 0,
-                        FALSE, DUPLICATE_SAME_ACCESS))
-    {
-      errno = ESRCH;
-      return -1;
-    }
-
   itimer->terminate = 0;
   itimer->type = which;
   /* Request that no more than 64KB of stack be reserved for this
@@ -512,17 +584,16 @@ start_timer_thread (int which)
 int
 getitimer (int which, struct itimerval *value)
 {
-  volatile clock_t *t_expire;
-  volatile clock_t *t_reload;
-  clock_t expire, reload;
+  volatile ULONGLONG *t_expire;
+  volatile ULONGLONG *t_reload;
+  ULONGLONG expire, reload;
   __int64 usecs;
   CRITICAL_SECTION *crit;
+  struct itimer_data *itimer;
 
   if (disable_itimers)
     return -1;
 
-  ticks_now = clock ();
-
   if (!value)
     {
       errno = EFAULT;
@@ -535,8 +606,22 @@ getitimer (int which, struct itimerval *value)
       return -1;
     }
 
-  t_expire = (which == ITIMER_REAL) ? &real_itimer.expire: &prof_itimer.expire;
-  t_reload = (which == ITIMER_REAL) ? &real_itimer.reload: &prof_itimer.reload;
+  itimer = (which == ITIMER_REAL) ? &real_itimer : &prof_itimer;
+
+  if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
+                        GetCurrentProcess (), &itimer->caller_thread, 0,
+                        FALSE, DUPLICATE_SAME_ACCESS))
+    {
+      errno = ESRCH;
+      return -1;
+    }
+
+  ticks_now = w32_get_timer_time ((which == ITIMER_REAL)
+                                  ? NULL
+                                  : itimer->caller_thread);
+
+  t_expire = &itimer->expire;
+  t_reload = &itimer->reload;
   crit = (which == ITIMER_REAL) ? &crit_real : &crit_prof;
 
   EnterCriticalSection (crit);
@@ -547,11 +632,13 @@ getitimer (int which, struct itimerval *value)
   if (expire)
     expire -= ticks_now;
 
-  value->it_value.tv_sec    = expire / CLOCKS_PER_SEC;
-  usecs = (expire % CLOCKS_PER_SEC) * (__int64)1000000 / CLOCKS_PER_SEC;
+  value->it_value.tv_sec    = expire / TIMER_TICKS_PER_SEC;
+  usecs =
+    (expire % TIMER_TICKS_PER_SEC) * (__int64)1000000 / TIMER_TICKS_PER_SEC;
   value->it_value.tv_usec   = usecs;
-  value->it_interval.tv_sec = reload / CLOCKS_PER_SEC;
-  usecs = (reload % CLOCKS_PER_SEC) * (__int64)1000000 / CLOCKS_PER_SEC;
+  value->it_interval.tv_sec = reload / TIMER_TICKS_PER_SEC;
+  usecs =
+    (reload % TIMER_TICKS_PER_SEC) * (__int64)1000000 / TIMER_TICKS_PER_SEC;
   value->it_interval.tv_usec= usecs;
 
   return 0;
@@ -560,10 +647,11 @@ getitimer (int which, struct itimerval *value)
 int
 setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
 {
-  volatile clock_t *t_expire, *t_reload;
-  clock_t expire, reload, expire_old, reload_old;
+  volatile ULONGLONG *t_expire, *t_reload;
+  ULONGLONG expire, reload, expire_old, reload_old;
   __int64 usecs;
   CRITICAL_SECTION *crit;
+  struct itimerval tem, *ptem;
 
   if (disable_itimers)
     return -1;
@@ -573,26 +661,21 @@ setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
      time we are called, measure the clock tick resolution.  */
   if (!clocks_min)
     {
-      clock_t t1, t2;
+      ULONGLONG t1, t2;
 
-      for (t1 = clock (); (t2 = clock ()) == t1; )
+      for (t1 = w32_get_timer_time (NULL);
+           (t2 = w32_get_timer_time (NULL)) == t1; )
         ;
       clocks_min = t2 - t1;
     }
 
   if (ovalue)
-    {
-      if (getitimer (which, ovalue)) /* also sets ticks_now */
-        return -1;                   /* errno already set */
-    }
+    ptem = ovalue;
   else
-    ticks_now = clock ();
+    ptem = &tem;
 
-  if (which != ITIMER_REAL && which != ITIMER_PROF)
-    {
-      errno = EINVAL;
-      return -1;
-    }
+  if (getitimer (which, ptem)) /* also sets ticks_now */
+    return -1;                 /* errno already set */
 
   t_expire =
     (which == ITIMER_REAL) ? &real_itimer.expire : &prof_itimer.expire;
@@ -612,26 +695,26 @@ setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
       return 0;
     }
 
-  reload = value->it_interval.tv_sec * CLOCKS_PER_SEC;
+  reload = value->it_interval.tv_sec * TIMER_TICKS_PER_SEC;
 
   usecs = value->it_interval.tv_usec;
   if (value->it_interval.tv_sec == 0
-      && usecs && usecs * CLOCKS_PER_SEC < clocks_min * 1000000)
+      && usecs && usecs * TIMER_TICKS_PER_SEC < clocks_min * 1000000)
     reload = clocks_min;
   else
     {
-      usecs *= CLOCKS_PER_SEC;
+      usecs *= TIMER_TICKS_PER_SEC;
       reload += usecs / 1000000;
     }
 
-  expire = value->it_value.tv_sec * CLOCKS_PER_SEC;
+  expire = value->it_value.tv_sec * TIMER_TICKS_PER_SEC;
   usecs = value->it_value.tv_usec;
   if (value->it_value.tv_sec == 0
-      && usecs * CLOCKS_PER_SEC < clocks_min * 1000000)
+      && usecs * TIMER_TICKS_PER_SEC < clocks_min * 1000000)
     expire = clocks_min;
   else
     {
-      usecs *= CLOCKS_PER_SEC;
+      usecs *= TIMER_TICKS_PER_SEC;
       expire += usecs / 1000000;
     }
 
@@ -1577,7 +1660,7 @@ sys_spawnve (int mode, char *cmdname, char **argv, char **envp)
       numenv++;
     }
   /* extra env vars... */
-  sprintf (ppid_env_var_buffer, "EM_PARENT_PROCESS_ID=%d",
+  sprintf (ppid_env_var_buffer, "EM_PARENT_PROCESS_ID=%lu",
            GetCurrentProcessId ());
   arglen += strlen (ppid_env_var_buffer) + 1;
   numenv++;