lib/mktime.c

   1 /* Copyright (C) 1993, 1994 Free Software Foundation, Inc.
   2    Contributed by Noel Cragg (noel@cs.oberlin.edu).
   3
   4 This file is part of the GNU C Library.
   5
   6 The GNU C Library is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU Library General Public License as
   8 published by the Free Software Foundation; either version 2 of the
   9 License, or (at your option) any later version.
  10
  11 The GNU C Library is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 Library General Public License for more details.
  15
  16 You should have received a copy of the GNU Library General Public
  17 License along with the GNU C Library; see the file COPYING.LIB.  If
  18 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  19 Cambridge, MA 02139, USA.  */
  20
  21 /* Define this to have a standalone program to test this implementation of
  22    mktime.  */
  23 /* #define DEBUG */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #if defined (CONFIG_BROKETS)
  27 /* We use <config.h> instead of "config.h" so that a compilation
  28    using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h
  29    (which it would do because it found this file in $srcdir).  */
  30 #include <config.h>
  31 #else
  32 #include "config.h"
  33 #endif
  34 #endif
  35
  36 #include <sys/types.h>          /* Some systems define `time_t' here.  */
  37 #include <time.h>
  38
  39
  40 #ifndef __isleap
  41 /* Nonzero if YEAR is a leap year (every 4 years,
  42    except every 100th isn't, and every 400th is).  */
  43 #define __isleap(year)  \
  44   ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
  45 #endif
  46
  47 #ifndef __P
  48 #if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
  49 #define __P(args) args
  50 #else
  51 #define __P(args) ()
  52 #endif  /* GCC.  */
  53 #endif  /* Not __P.  */
  54
  55 /* How many days are in each month.  */
  56 const unsigned short int __mon_lengths[2][12] =
  57   {
  58     /* Normal years.  */
  59     { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
  60     /* Leap years.  */
  61     { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
  62   };
  63
  64
  65 static int times_through_search; /* This library routine should never
  66                                     hang -- make sure we always return
  67                                     when we're searching for a value */
  68
  69 /* After testing this, the maximum number of iterations that I had on
  70    any number that I tried was 3!  Not bad.
  71
  72    mktime converts a `struct tm' (broken-down local time) into a `time_t';
  73    it is the opposite of localtime.  It is possible to put the following
  74    values out of range and have mktime compensate: tm_sec, tm_min, tm_hour,
  75    tm_mday, tm_year.  The other values in the structure are ignored.  */
  76
  77 #ifdef DEBUG
  78
  79 #include <stdio.h>
  80 #include <ctype.h>
  81
  82 int debugging_enabled = 0;
  83
  84 /* Print the values in a `struct tm'. */
  85 static void
  86 printtm (it)
  87      struct tm *it;
  88 {
  89   printf ("%d/%d/%d %d:%d:%d (%s) yday:%d f:%d o:%ld",
  90           it->tm_mon,
  91           it->tm_mday,
  92           it->tm_year,
  93           it->tm_hour,
  94           it->tm_min,
  95           it->tm_sec,
  96           it->tm_zone,
  97           it->tm_yday,
  98           it->tm_isdst,
  99           it->tm_gmtoff);
 100 }
 101 #endif
 102
 103
 104 static time_t
 105 dist_tm (t1, t2)
 106      struct tm *t1;
 107      struct tm *t2;
 108 {
 109   time_t distance = 0;
 110   unsigned long int v1, v2;
 111   int diff_flag = 0;
 112
 113   v1 = v2 = 0;
 114
 115 #define doit(x, secs)                                                         \
 116   v1 += t1->x * secs;                                                         \
 117   v2 += t2->x * secs;                                                         \
 118   if (!diff_flag)                                                             \
 119     {                                                                         \
 120       if (t1->x < t2->x)                                                      \
 121         diff_flag = -1;                                                       \
 122       else if (t1->x > t2->x)                                                 \
 123         diff_flag = 1;                                                        \
 124     }
 125
 126   doit (tm_year, 31536000);     /* Okay, not all years have 365 days. */
 127   doit (tm_mon, 2592000);       /* Okay, not all months have 30 days. */
 128   doit (tm_mday, 86400);
 129   doit (tm_hour, 3600);
 130   doit (tm_min, 60);
 131   doit (tm_sec, 1);
 132
 133 #undef doit
 134
 135   /* We should also make sure that the sign of DISTANCE is correct -- if
 136      DIFF_FLAG is positive, the distance should be positive and vice versa. */
 137
 138   distance = (v1 > v2) ? (v1 - v2) : (v2 - v1);
 139   if (diff_flag < 0)
 140     distance = -distance;
 141
 142   if (times_through_search > 20) /* Arbitrary # of calls, but makes sure we
 143                                     never hang if there's a problem with
 144                                     this algorithm.  */
 145     {
 146       distance = diff_flag;
 147     }
 148
 149   /* We need this DIFF_FLAG business because it is forseeable that the
 150      distance may be zero when, in actuality, the two structures are
 151      different.  This is usually the case when the dates are 366 days apart
 152      and one of the years is a leap year.  */
 153
 154   if (distance == 0 && diff_flag)
 155     distance = 86400 * diff_flag;
 156
 157   return distance;
 158 }
 159
 160
 161 /* Modified b-search -- make intelligent guesses as to where the time might
 162    lie along the timeline, assuming that our target time lies a linear
 163    distance (w/o considering time jumps of a particular region).
 164
 165    Assume that time does not fluctuate at all along the timeline -- e.g.,
 166    assume that a day will always take 86400 seconds, etc. -- and come up
 167    with a hypothetical value for the time_t representation of the struct tm
 168    TARGET, in relation to the guess variable -- it should be pretty close! */
 169
 170 static time_t
 171 search (target, producer)
 172      struct tm *target;
 173      struct tm *(*producer) __P ((const time_t *));
 174 {
 175   struct tm *guess_tm;
 176   time_t guess = 0;
 177   time_t distance = 0;
 178
 179   times_through_search = 0;
 180
 181   do
 182     {
 183       guess += distance;
 184
 185       times_through_search++;
 186
 187       guess_tm = (*producer) (&guess);
 188
 189 #ifdef DEBUG
 190       if (debugging_enabled)
 191         {
 192           printf ("guess %d == ", (int) guess);
 193           printtm (guess_tm);
 194           puts ("");
 195         }
 196 #endif
 197
 198       /* Are we on the money? */
 199       distance = dist_tm (target, guess_tm);
 200
 201     } while (distance != 0);
 202
 203   return guess;
 204 }
 205
 206 /* Since this function will call localtime many times (and the user might
 207    be passing their `struct tm *' right from localtime, let's make a copy
 208    for ourselves and run the search on the copy.
 209
 210    Also, we have to normalize *TIMEPTR because it's possible to call mktime
 211    with values that are out of range for a specific item (like Feb 30th). */
 212 time_t
 213 _mktime_internal (timeptr, producer)
 214      struct tm *timeptr;
 215      struct tm *(*producer) __P ((const time_t *));
 216 {
 217   struct tm private_mktime_struct_tm; /* Yes, users can get a ptr to this. */
 218   struct tm *me;
 219   time_t result;
 220
 221   me = &private_mktime_struct_tm;
 222
 223   *me = *timeptr;
 224
 225 #define normalize(foo,x,y,bar); \
 226   while (me->foo < x) \
 227     { \
 228       me->bar--; \
 229       me->foo = (y - (x - me->foo)); \
 230     } \
 231   while (me->foo > y) \
 232     { \
 233       me->bar++; \
 234       me->foo = (x + (me->foo - y)); \
 235     }
 236
 237   normalize (tm_sec, 0, 59, tm_min);
 238   normalize (tm_min, 0, 59, tm_hour);
 239   normalize (tm_hour, 0, 23, tm_mday);
 240
 241   /* Do the month first, so day range can be found. */
 242   normalize (tm_mon, 0, 11, tm_year);
 243   normalize (tm_mday, 1,
 244              __mon_lengths[__isleap (me->tm_year)][me->tm_mon],
 245              tm_mon);
 246
 247   /* Do the month again, because the day may have pushed it out of range. */
 248   normalize (tm_mon, 0, 11, tm_year);
 249
 250   /* Do the day again, because the month may have changed the range. */
 251   normalize (tm_mday, 1,
 252              __mon_lengths[__isleap (me->tm_year)][me->tm_mon],
 253              tm_mon);
 254
 255 #ifdef DEBUG
 256   if (debugging_enabled)
 257     {
 258       printf ("After normalizing: ");
 259       printtm (me);
 260       puts ("\n");
 261     }
 262 #endif
 263
 264   result = search (me, producer);
 265
 266   *timeptr = *me;
 267
 268   return result;
 269 }
 270
 271 time_t
 272 mktime (timeptr)
 273      struct tm *timeptr;
 274 {
 275   return _mktime_internal (timeptr, localtime);
 276 }
 277 \f
 278 #ifdef DEBUG
 279 void
 280 main (argc, argv)
 281      int argc;
 282      char *argv[];
 283 {
 284   int time;
 285   int result_time;
 286   struct tm *tmptr;
 287
 288   if (argc == 1)
 289     {
 290       long q;
 291
 292       printf ("starting long test...\n");
 293
 294       for (q = 10000000; q < 1000000000; q++)
 295         {
 296           struct tm *tm = localtime (&q);
 297           if ((q % 10000) == 0) { printf ("%ld\n", q); fflush (stdout); }
 298           if (q != mktime (tm))
 299             { printf ("failed for %ld\n", q); fflush (stdout); }
 300         }
 301
 302       printf ("test finished\n");
 303
 304       exit (0);
 305     }
 306
 307   if (argc != 2)
 308     {
 309       printf ("wrong # of args\n");
 310       exit (0);
 311     }
 312
 313   debugging_enabled = 1;        /* We want to see the info */
 314
 315   ++argv;
 316   time = atoi (*argv);
 317
 318   printf ("Time: %d %s\n", time, ctime ((time_t *) &time));
 319
 320   tmptr = localtime ((time_t *) &time);
 321   printf ("localtime returns: ");
 322   printtm (tmptr);
 323   printf ("\n");
 324   printf ("mktime: %d\n\n", (int) mktime (tmptr));
 325
 326   tmptr->tm_sec -= 20;
 327   tmptr->tm_min -= 20;
 328   tmptr->tm_hour -= 20;
 329   tmptr->tm_mday -= 20;
 330   tmptr->tm_mon -= 20;
 331   tmptr->tm_year -= 20;
 332   tmptr->tm_gmtoff -= 20000;    /* This has no effect! */
 333   tmptr->tm_zone = NULL;        /* Nor does this! */
 334   tmptr->tm_isdst = -1;
 335
 336   printf ("changed ranges: ");
 337   printtm (tmptr);
 338   printf ("\n\n");
 339
 340   result_time = mktime (tmptr);
 341   printf ("\nmktime: %d\n", result_time);
 342 }
 343 #endif /* DEBUG */