-
[kopensolaris-gnu/glibc.git] / time / mktime.c
1 /* Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
2    Contributed by Paul Eggert (eggert@twinsun.com).
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 1 */
24
25 #ifdef HAVE_CONFIG_H
26 #include <config.h>
27 #endif
28
29 /* Assume that leap seconds are possible, unless told otherwise.
30    If the host has a `zic' command with a `-L leapsecondfilename' option,
31    then it supports leap seconds; otherwise it probably doesn't.  */
32 #ifndef LEAP_SECONDS_POSSIBLE
33 #define LEAP_SECONDS_POSSIBLE 1
34 #endif
35
36 #include <sys/types.h>          /* Some systems define `time_t' here.  */
37 #include <time.h>
38
39 #if __STDC__ || __GNU_LIBRARY__ || STDC_HEADERS
40 #include <limits.h>
41 #endif
42
43 #if DEBUG
44 #include <stdio.h>
45 #if __STDC__ || __GNU_LIBRARY__ || STDC_HEADERS
46 #include <stdlib.h>
47 #endif
48 /* Make it work even if the system's libc has its own mktime routine.  */
49 #define mktime my_mktime
50 #endif /* DEBUG */
51
52 #ifndef __P
53 #if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
54 #define __P(args) args
55 #else
56 #define __P(args) ()
57 #endif  /* GCC.  */
58 #endif  /* Not __P.  */
59
60 #ifndef CHAR_BIT
61 #define CHAR_BIT 8
62 #endif
63
64 #ifndef INT_MIN
65 #define INT_MIN (~0 << (sizeof (int) * CHAR_BIT - 1))
66 #endif
67 #ifndef INT_MAX
68 #define INT_MAX (~0 - INT_MIN)
69 #endif
70
71 #ifndef TIME_T_MIN
72 #define TIME_T_MIN (0 < (time_t) -1 ? (time_t) 0 \
73                     : ~ (time_t) 0 << (sizeof (time_t) * CHAR_BIT - 1))
74 #endif
75 #ifndef TIME_T_MAX
76 #define TIME_T_MAX (~ (time_t) 0 - TIME_T_MIN)
77 #endif
78
79 #define TM_YEAR_BASE 1900
80 #define EPOCH_YEAR 1970
81
82 #ifndef __isleap
83 /* Nonzero if YEAR is a leap year (every 4 years,
84    except every 100th isn't, and every 400th is).  */
85 #define __isleap(year)  \
86   ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
87 #endif
88
89 /* How many days come before each month (0-12).  */
90 const unsigned short int __mon_yday[2][13] =
91   {
92     /* Normal years.  */
93     { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
94     /* Leap years.  */
95     { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
96   };
97
98 static time_t ydhms_tm_diff __P ((int, int, int, int, int, const struct tm *));
99 time_t __mktime_internal __P ((struct tm *,
100                                struct tm *(*) (const time_t *, struct tm *),
101                                time_t *));
102
103
104 #if ! HAVE_LOCALTIME_R && ! defined (localtime_r)
105 #ifdef _LIBC
106 #define localtime_r __localtime_r
107 #else
108 /* Approximate localtime_r as best we can in its absence.  */
109 #define localtime_r my_localtime_r
110 static struct tm *localtime_r __P ((const time_t *, struct tm *));
111 static struct tm *
112 localtime_r (t, tp)
113      const time_t *t;
114      struct tm *tp;
115 {
116   struct tm *l = localtime (t);
117   if (! l)
118     return 0;
119   *tp = *l;
120   return tp;
121 }
122 #endif /* ! _LIBC */
123 #endif /* ! HAVE_LOCALTIME_R && ! defined (localtime_r) */
124
125
126 /* Yield the difference between (YEAR-YDAY HOUR:MIN:SEC) and (*TP),
127    measured in seconds, ignoring leap seconds.
128    YEAR uses the same numbering as TM->tm_year.
129    All values are in range, except possibly YEAR.
130    If overflow occurs, yield the low order bits of the correct answer.  */
131 static time_t
132 ydhms_tm_diff (year, yday, hour, min, sec, tp)
133      int year, yday, hour, min, sec;
134      const struct tm *tp;
135 {
136   time_t ay = year + (time_t) (TM_YEAR_BASE - 1);
137   time_t by = tp->tm_year + (time_t) (TM_YEAR_BASE - 1);
138   time_t intervening_leap_days =
139     (ay/4 - by/4) - (ay/100 - by/100) + (ay/400 - by/400);
140   time_t years = ay - by;
141   time_t days = (365 * years + intervening_leap_days
142                  + (yday - tp->tm_yday));
143   return (60 * (60 * (24 * days + (hour - tp->tm_hour))
144                 + (min - tp->tm_min))
145           + (sec - tp->tm_sec));
146 }
147
148
149 /* Convert *TP to a time_t value.  */
150 time_t
151 mktime (tp)
152      struct tm *tp;
153 {
154   static time_t localtime_offset;
155   return __mktime_internal (tp, localtime_r, &localtime_offset);
156 }
157
158 /* Convert *TP to a time_t value, inverting
159    the monotonic and mostly-unit-linear conversion function CONVERT.
160    Use *OFFSET to keep track of a guess at the offset of the result,
161    compared to what the result would be for UTC without leap seconds.
162    If *OFFSET's guess is correct, only one CONVERT call is needed.  */
163 time_t
164 __mktime_internal (tp, convert, offset)
165      struct tm *tp;
166      struct tm *(*convert) __P ((const time_t *, struct tm *));
167      time_t *offset;
168 {
169   time_t t, dt, t0;
170   struct tm tm;
171
172   /* The maximum number of probes (calls to CONVERT) should be enough
173      to handle any combinations of time zone rule changes, solar time,
174      and leap seconds.  Posix.1 prohibits leap seconds, but some hosts
175      have them anyway.  */
176   int remaining_probes = 4;
177
178   /* Time requested.  Copy it in case CONVERT modifies *TP; this can
179      occur if TP is localtime's returned value and CONVERT is localtime.  */
180   int sec = tp->tm_sec;
181   int min = tp->tm_min;
182   int hour = tp->tm_hour;
183   int mday = tp->tm_mday;
184   int mon = tp->tm_mon;
185   int year_requested = tp->tm_year;
186   int isdst = tp->tm_isdst;
187
188   /* Ensure that mon is in range, and set year accordingly.  */
189   int mon_remainder = mon % 12;
190   int negative_mon_remainder = mon_remainder < 0;
191   int mon_years = mon / 12 - negative_mon_remainder;
192   int year = year_requested + mon_years;
193
194   /* The other values need not be in range:
195      the remaining code handles minor overflows correctly,
196      assuming int and time_t arithmetic wraps around.
197      Major overflows are caught at the end.  */
198
199   /* Calculate day of year from year, month, and day of month.
200      The result need not be in range.  */
201   int yday = ((__mon_yday[__isleap (year + TM_YEAR_BASE)]
202                [mon_remainder + 12 * negative_mon_remainder])
203               + mday - 1);
204
205 #if LEAP_SECONDS_POSSIBLE
206   /* Handle out-of-range seconds specially,
207      since ydhms_tm_diff assumes every minute has 60 seconds.  */
208   int sec_requested = sec;
209   if (sec < 0)
210     sec = 0;
211   if (59 < sec)
212     sec = 59;
213 #endif
214
215   /* Invert CONVERT by probing.  First assume the same offset as last time.
216      Then repeatedly use the error to improve the guess.  */
217
218   tm.tm_year = EPOCH_YEAR - TM_YEAR_BASE;
219   tm.tm_yday = tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
220   t0 = ydhms_tm_diff (year, yday, hour, min, sec, &tm);
221
222   for (t = t0 + *offset;
223        (dt = ydhms_tm_diff (year, yday, hour, min, sec, (*convert) (&t, &tm)));
224        t += dt)
225     if (--remaining_probes == 0)
226       return -1;
227
228   /* Check whether tm.tm_isdst has the requested value, if any.  */
229   if (0 <= isdst && 0 <= tm.tm_isdst)
230     {
231       int dst_diff = (isdst != 0) - (tm.tm_isdst != 0);
232       if (dst_diff)
233         {
234           /* Move two hours in the direction indicated by the disagreement,
235              probe some more, and switch to a new time if found.
236              The largest known fallback due to daylight savings is two hours:
237              once, in Newfoundland, 1988-10-30 02:00 -> 00:00.  */
238           time_t ot = t - 2 * 60 * 60 * dst_diff;
239           while (--remaining_probes != 0)
240             {
241               struct tm otm;
242               if (! (dt = ydhms_tm_diff (year, yday, hour, min, sec,
243                                          (*convert) (&ot, &otm))))
244                 {
245                   t = ot;
246                   tm = otm;
247                   break;
248                 }
249               if ((ot += dt) == t)
250                 break;  /* Avoid a redundant probe.  */
251             }
252         }
253     }
254
255   *offset = t - t0;
256
257 #if LEAP_SECONDS_POSSIBLE
258   if (sec_requested != tm.tm_sec)
259     {
260       /* Adjust time to reflect the tm_sec requested, not the normalized value.
261          Also, repair any damage from a false match due to a leap second.  */
262       t += sec_requested - sec + (sec == 0 && tm.tm_sec == 60);
263       (*convert) (&t, &tm);
264     }
265 #endif
266
267   if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)
268     {
269       /* time_t isn't large enough to rule out overflows in ydhms_tm_diff,
270          so check for major overflows.  A gross check suffices,
271          since if t has overflowed, it is off by a multiple of
272          TIME_T_MAX - TIME_T_MIN + 1.  So ignore any component of
273          the difference that is bounded by a small value.  */
274
275       double dyear = (double) year_requested + mon_years - tm.tm_year;
276       double dday = 366 * dyear + mday;
277       double dsec = 60 * (60 * (24 * dday + hour) + min) + sec_requested;
278
279       if (TIME_T_MAX / 3 - TIME_T_MIN / 3 < (dsec < 0 ? - dsec : dsec))
280         return -1;
281     }
282
283   *tp = tm;
284   return t;
285 }
286
287 #ifdef weak_alias
288 weak_alias (mktime, timelocal)
289 #endif
290 \f
291 #if DEBUG
292
293 static int
294 not_equal_tm (a, b)
295      struct tm *a;
296      struct tm *b;
297 {
298   return ((a->tm_sec ^ b->tm_sec)
299           | (a->tm_min ^ b->tm_min)
300           | (a->tm_hour ^ b->tm_hour)
301           | (a->tm_mday ^ b->tm_mday)
302           | (a->tm_mon ^ b->tm_mon)
303           | (a->tm_year ^ b->tm_year)
304           | (a->tm_mday ^ b->tm_mday)
305           | (a->tm_yday ^ b->tm_yday)
306           | (a->tm_isdst ^ b->tm_isdst));
307 }
308
309 static void
310 print_tm (tp)
311      struct tm *tp;
312 {
313   printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
314           tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
315           tp->tm_hour, tp->tm_min, tp->tm_sec,
316           tp->tm_yday, tp->tm_wday, tp->tm_isdst);
317 }
318
319 static int
320 check_result (tk, tmk, tl, tml)
321      time_t tk;
322      struct tm tmk;
323      time_t tl;
324      struct tm tml;
325 {
326   if (tk != tl || not_equal_tm (&tmk, &tml))
327     {
328       printf ("mktime (");
329       print_tm (&tmk);
330       printf (")\nyields (");
331       print_tm (&tml);
332       printf (") == %ld, should be %ld\n", (long) tl, (long) tk);
333       return 1;
334     }
335
336   return 0;
337 }
338
339 int
340 main (argc, argv)
341      int argc;
342      char **argv;
343 {
344   int status = 0;
345   struct tm tm, tmk, tml;
346   time_t tk, tl;
347   char trailer;
348
349   if ((argc == 3 || argc == 4)
350       && (sscanf (argv[1], "%d-%d-%d%c",
351                   &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer)
352           == 3)
353       && (sscanf (argv[2], "%d:%d:%d%c",
354                   &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer)
355           == 3))
356     {
357       tm.tm_year -= TM_YEAR_BASE;
358       tm.tm_mon--;
359       tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]);
360       tmk = tm;
361       tl = mktime (&tmk);
362       tml = *localtime (&tl);
363       printf ("mktime returns %ld == ", (long) tl);
364       print_tm (&tmk);
365       printf ("\n");
366       status = check_result (tl, tmk, tl, tml);
367     }
368   else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0))
369     {
370       time_t from = atol (argv[1]);
371       time_t by = atol (argv[2]);
372       time_t to = atol (argv[3]);
373
374       if (argc == 4)
375         for (tl = from; tl <= to; tl += by)
376           {
377             tml = *localtime (&tl);
378             tmk = tml;
379             tk = mktime (&tmk);
380             status |= check_result (tk, tmk, tl, tml);
381           }
382       else
383         for (tl = from; tl <= to; tl += by)
384           {
385             /* Null benchmark.  */
386             tml = *localtime (&tl);
387             tmk = tml;
388             tk = tl;
389             status |= check_result (tk, tmk, tl, tml);
390           }
391     }
392   else
393     printf ("Usage:\
394 \t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
395 \t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
396 \t%s FROM BY TO - # Do not test those values (for benchmark).\n",
397             argv[0], argv[0], argv[0]);
398
399   return status;
400 }
401
402 #endif /* DEBUG */
403 \f
404 /*
405 Local Variables:
406 compile-command: "gcc -DDEBUG=1 -Wall -O -g mktime.c -o mktime"
407 End:
408 */