[svn] Remove K&R support.

[wget] / src / ptimer.c

diff --git a/src/ptimer.c b/src/ptimer.c
index d63e69e27821b11432aa1285fd00ebfbb3a390fc..695019e9389079c497484486b3d8cda294532dea 100644 (file)
--- a/src/ptimer.c
+++ b/src/ptimer.c
@@ -39,9 +39,10 @@ so, delete this exception statement from your version.  */
      ptimer_destroy -- destroy the timer.
      ptimer_granularity -- returns the approximate granularity of the timers.
 
-   Timers operate in milliseconds, but return floating point values
-   that can be more precise.  For example, to measure the time it
-   takes to run a loop, you can use something like:
+   Timers measure time in milliseconds, but the timings they return
+   are floating point numbers, so they can carry as much precision as
+   the underlying system timer supports.  For example, to measure the
+   time it takes to run a loop, you can use something like:
 
      ptimer *tmr = ptimer_new ();
      while (...)
@@ -53,25 +54,24 @@ so, delete this exception statement from your version.  */
 
 #include <stdio.h>
 #include <stdlib.h>
-#ifdef HAVE_STRING_H
-# include <string.h>
-#else  /* not HAVE_STRING_H */
-# include <strings.h>
-#endif /* not HAVE_STRING_H */
-#include <sys/types.h>
+#include <string.h>
 #include <errno.h>
 #ifdef HAVE_UNISTD_H
 # include <unistd.h>
 #endif
 #include <assert.h>
+#include <time.h>
+
+/* Cygwin currently (as of 2005-04-08, Cygwin 1.5.14) lacks clock_getres,
+   but still defines _POSIX_TIMERS!  Because of that we simply use the
+   Windows timers under Cygwin.  */
+#ifdef __CYGWIN__
+# include <windows.h>
+#endif
 
 #include "wget.h"
 #include "ptimer.h"
 
-#ifndef errno
-extern int errno;
-#endif
-
 /* Depending on the OS and availability of gettimeofday(), one and
    only one of PTIMER_POSIX, PTIMER_GETTIMEOFDAY, PTIMER_WINDOWS, or
    PTIMER_TIME will be defined.  */
@@ -81,10 +81,10 @@ extern int errno;
 #undef PTIMER_TIME
 #undef PTIMER_WINDOWS
 
-#ifdef WINDOWS
+#if defined(WINDOWS) || defined(__CYGWIN__)
 # define PTIMER_WINDOWS                /* use Windows timers */
 #else
-# if _POSIX_TIMERS > 0
+# if _POSIX_TIMERS - 0 > 0
 #  define PTIMER_POSIX         /* use POSIX timers (clock_gettime) */
 # else
 #  ifdef HAVE_GETTIMEOFDAY
@@ -131,7 +131,7 @@ posix_init (void)
     int id;
     int sysconf_name;
   } clocks[] = {
-#if defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0
+#if defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK - 0 >= 0
     { CLOCK_MONOTONIC, _SC_MONOTONIC_CLOCK },
 #endif
 #ifdef CLOCK_HIGHRES
@@ -338,9 +338,6 @@ windows_resolution (void)
 /* The code below this point is independent of timer implementation. */
 
 struct ptimer {
-  /* Whether the start time has been set. */
-  int initialized;
-
   /* The starting point in time which, subtracted from the current
      time, yields elapsed time. */
   ptimer_system_time start;
@@ -360,7 +357,7 @@ struct ptimer {
 struct ptimer *
 ptimer_new (void)
 {
-  struct ptimer *wt = xnew0 (struct ptimer);
+  struct ptimer *pt = xnew0 (struct ptimer);
 #ifdef IMPL_init
   static int init_done;
   if (!init_done)
@@ -369,31 +366,30 @@ ptimer_new (void)
       IMPL_init ();
     }
 #endif
-  ptimer_reset (wt);
-  return wt;
+  ptimer_reset (pt);
+  return pt;
 }
 
 /* Free the resources associated with the timer.  Its further use is
    prohibited.  */
 
 void
-ptimer_destroy (struct ptimer *wt)
+ptimer_destroy (struct ptimer *pt)
 {
-  xfree (wt);
+  xfree (pt);
 }
 
-/* Reset timer WT.  This establishes the starting point from which
+/* Reset timer PT.  This establishes the starting point from which
    ptimer_read() will return the number of elapsed milliseconds.
    It is allowed to reset a previously used timer.  */
 
 void
-ptimer_reset (struct ptimer *wt)
+ptimer_reset (struct ptimer *pt)
 {
   /* Set the start time to the current time. */
-  IMPL_measure (&wt->start);
-  wt->elapsed_last = 0;
-  wt->elapsed_pre_start = 0;
-  wt->initialized = 1;
+  IMPL_measure (&pt->start);
+  pt->elapsed_last = 0;
+  pt->elapsed_pre_start = 0;
 }
 
 /* Measure the elapsed time since timer creation/reset and return it
@@ -408,24 +404,22 @@ ptimer_reset (struct ptimer *wt)
    ignored.  */
 
 double
-ptimer_measure (struct ptimer *wt)
+ptimer_measure (struct ptimer *pt)
 {
   ptimer_system_time now;
   double elapsed;
 
-  assert (wt->initialized != 0);
-
   IMPL_measure (&now);
-  elapsed = wt->elapsed_pre_start + IMPL_diff (&now, &wt->start);
+  elapsed = pt->elapsed_pre_start + IMPL_diff (&now, &pt->start);
 
   /* Ideally we'd just return the difference between NOW and
-     wt->start.  However, the system timer can be set back, and we
+     pt->start.  However, the system timer can be set back, and we
      could return a value smaller than when we were last called, even
      a negative value.  Both of these would confuse the callers, which
      expect us to return monotonically nondecreasing values.
 
      Therefore: if ELAPSED is smaller than its previous known value,
-     we reset wt->start to the current time and effectively start
+     we reset pt->start to the current time and effectively start
      measuring from this point.  But since we don't want the elapsed
      value to start from zero, we set elapsed_pre_start to the last
      elapsed time and increment all future calculations by that
@@ -434,14 +428,14 @@ ptimer_measure (struct ptimer *wt)
      This cannot happen with Windows and POSIX monotonic/highres
      timers, but the check is not expensive.  */
 
-  if (elapsed < wt->elapsed_last)
+  if (elapsed < pt->elapsed_last)
     {
-      wt->start = now;
-      wt->elapsed_pre_start = wt->elapsed_last;
-      elapsed = wt->elapsed_last;
+      pt->start = now;
+      pt->elapsed_pre_start = pt->elapsed_last;
+      elapsed = pt->elapsed_last;
     }
 
-  wt->elapsed_last = elapsed;
+  pt->elapsed_last = elapsed;
   return elapsed;
 }
 
@@ -449,9 +443,9 @@ ptimer_measure (struct ptimer *wt)
    ptimer_reset and the last call to ptimer_update.  */
 
 double
-ptimer_read (const struct ptimer *wt)
+ptimer_read (const struct ptimer *pt)
 {
-  return wt->elapsed_last;
+  return pt->elapsed_last;
 }
 
 /* Return the assessed resolution of the timer implementation, in