Formerly ../time/mktime.c.~14~
[kopensolaris-gnu/glibc.git] / time / mktime.c
1 /* Copyright (C) 1993 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 DEBUG */    /* Define this to have a standalone shell to test
22                         * this implementation of mktime
23                         */
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
48 /* How many days are in each month.  */
49 const unsigned short int __mon_lengths[2][12] =
50   {
51     /* Normal years.  */
52     { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
53     /* Leap years.  */
54     { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
55   };
56
57
58 static int times_through_search; /* This library routine should never
59                                     hang -- make sure we always return
60                                     when we're searching for a value */
61
62 /* After testing this, the maximum number of iterations that I had on
63    any number that I tried was 3!  Not bad.
64
65    mktime converts a `struct tm' (broken-down local time) into a `time_t';
66    it is the opposite of localtime.  It is possible to put the following
67    values out of range and have mktime compensate: tm_sec, tm_min, tm_hour,
68    tm_mday, tm_year.  The other values in the structure are ignored.  */
69
70 #ifdef DEBUG
71
72 #include <stdio.h>
73 #include <ctype.h>
74
75 int debugging_enabled = 0;
76
77 /* Print the values in a `struct tm'. */
78 static void
79 printtm (it)
80      struct tm *it;
81 {
82   printf ("%d/%d/%d %d:%d:%d (%s) yday:%d f:%d o:%ld",
83           it->tm_mon,
84           it->tm_mday,
85           it->tm_year,
86           it->tm_hour,
87           it->tm_min,
88           it->tm_sec,
89           it->tm_zone,
90           it->tm_yday,
91           it->tm_isdst,
92           it->tm_gmtoff);
93 }
94 #endif
95
96
97 static time_t
98 dist_tm (t1, t2)
99      struct tm *t1;
100      struct tm *t2;
101 {
102   time_t distance = 0;
103   unsigned long int v1, v2;
104   int diff_flag = 0;
105
106   v1 = v2 = 0;
107
108 #define doit(x, secs)                                                         \
109   v1 += t1->x * secs;                                                         \
110   v2 += t2->x * secs;                                                         \
111   if (!diff_flag)                                                             \
112     {                                                                         \
113       if (t1->x < t2->x)                                                      \
114         diff_flag = -1;                                                       \
115       else if (t1->x > t2->x)                                                 \
116         diff_flag = 1;                                                        \
117     }
118   
119   doit (tm_year, 31536000);     /* Okay, not all years have 365 days. */
120   doit (tm_mon, 2592000);       /* Okay, not all months have 30 days. */
121   doit (tm_mday, 86400);
122   doit (tm_hour, 3600);
123   doit (tm_min, 60);
124   doit (tm_sec, 1);
125   
126 #undef doit
127   
128   /* We should also make sure that the sign of DISTANCE is correct --
129    * if DIFF_FLAG is positive, the distance should be positive and
130    * vice versa. */
131   
132   distance = (v1 > v2) ? (v1 - v2) : (v2 - v1);
133   if (diff_flag < 0)
134     distance = -distance;
135
136   if (times_through_search > 20) /* Arbitrary # of calls, but makes
137                                     sure we never hang if there's a
138                                     problem with this algorithm */
139     {
140       distance = diff_flag;
141     }
142
143   /* We need this DIFF_FLAG business because it is forseeable that
144    * the distance may be zero when, in actuality, the two structures
145    * are different.  This is usually the case when the dates are
146    * 366 days apart and one of the years is a leap year. */
147
148   if ((distance == 0) && diff_flag)
149     distance = 86400 * diff_flag;
150
151   return distance;
152 }
153       
154
155 /* Modified b-search -- make intelligent guesses as to where the time
156  * might lie along the timeline, assuming that our target time lies a
157  * linear distance (w/o considering time jumps of a particular region).
158  *
159  * Assume that time does not fluctuate at all along the timeline --
160  * e.g., assume that a day will always take 86400 seconds, etc. -- and
161  * come up with a hypothetical value for the time_t representation of
162  * the struct tm TARGET, in relation to the guess variable -- it should
163  * be pretty close! */
164
165 static time_t
166 search (target)
167      struct tm *target;
168 {
169   struct tm *guess_tm;
170   time_t guess = 0;
171   time_t distance = 0;
172
173   times_through_search = 0;
174
175   do
176     {
177       guess += distance;
178
179       times_through_search++;     
180       
181       guess_tm = localtime (&guess);
182       
183 #ifdef DEBUG
184       if (debugging_enabled)
185         {
186           printf ("guess %d == ", (int) guess);
187           printtm (guess_tm);
188           puts ("");
189         }
190 #endif
191       
192       /* Are we on the money? */
193       distance = dist_tm (target, guess_tm);
194       
195     } while (distance != 0);
196
197   return guess;
198 }
199
200 /* Since this function will call localtime many times (and the user might
201  * be passing their `struct tm *' right from localtime, let's make a copy
202  * for ourselves and run the search on the copy.
203  *
204  * Also, we have to normalize the timeptr because it's possible to call mktime
205  * with values that are out of range for a specific item (like 30th Feb). */
206 time_t
207 mktime (timeptr)
208      struct tm *timeptr;
209 {
210   struct tm private_mktime_struct_tm; /* Yes, users can get a ptr to this. */
211   struct tm *me;
212   time_t result;
213
214   me = &private_mktime_struct_tm;
215   
216   *me = *timeptr;
217
218 #define normalize(foo,x,y,bar); \
219   while (me->foo < x) \
220     { \
221       me->bar--; \
222       me->foo = (y - (x - me->foo)); \
223     } \
224   while (me->foo > y) \
225     { \
226       me->bar++; \
227       me->foo = (x + (me->foo - y)); \
228     }
229   
230   normalize (tm_sec, 0, 59, tm_min);
231   normalize (tm_min, 0, 59, tm_hour);
232   normalize (tm_hour, 0, 23, tm_mday);
233   
234   /* Do the month first, so day range can be found. */
235   normalize (tm_mon, 0, 11, tm_year);
236   normalize (tm_mday, 1,
237              __mon_lengths[__isleap (me->tm_year)][me->tm_mon],
238              tm_mon);
239
240   /* Do the month again, because the day may have pushed it out of range. */
241   normalize (tm_mon, 0, 11, tm_year);
242
243   /* Do the day again, because the month may have changed the range. */
244   normalize (tm_mday, 1,
245              __mon_lengths[__isleap (me->tm_year)][me->tm_mon],
246              tm_mon);
247   
248 #ifdef DEBUG
249   if (debugging_enabled)
250     {
251       printf ("After normalizing: ");
252       printtm (me);
253       puts ("\n");
254     }
255 #endif
256
257   result = search (me);
258
259   *timeptr = *me;
260
261   return result;
262 }
263 \f
264 #ifdef DEBUG
265 void
266 main (argc, argv)
267      int argc;
268      char *argv[];
269 {
270   int time;
271   int result_time;
272   struct tm *tmptr;
273   
274   if (argc == 1)
275     {
276       long q;
277       
278       printf ("starting long test...\n");
279
280       for (q = 10000000; q < 1000000000; q++)
281         {
282           struct tm *tm = localtime (&q);
283           if ((q % 10000) == 0) { printf ("%ld\n", q); fflush (stdout); }
284           if (q != mktime (tm))
285             { printf ("failed for %ld\n", q); fflush (stdout); }
286         }
287       
288       printf ("test finished\n");
289
290       exit (0);
291     }
292   
293   if (argc != 2)
294     {
295       printf ("wrong # of args\n");
296       exit (0);
297     }
298   
299   debugging_enabled = 1;        /* We want to see the info */
300
301   ++argv;
302   time = atoi (*argv);
303   
304   printf ("Time: %d %s\n", time, ctime ((time_t *) &time));
305
306   tmptr = localtime ((time_t *) &time);
307   printf ("localtime returns: ");
308   printtm (tmptr);
309   printf ("\n");
310   printf ("mktime: %d\n\n", (int) mktime (tmptr));
311
312   tmptr->tm_sec -= 20;
313   tmptr->tm_min -= 20;
314   tmptr->tm_hour -= 20;
315   tmptr->tm_mday -= 20;
316   tmptr->tm_mon -= 20;
317   tmptr->tm_year -= 20;
318   tmptr->tm_gmtoff -= 20000;    /* This has no effect! */
319   tmptr->tm_zone = NULL;        /* Nor does this! */
320   tmptr->tm_isdst = -1;
321
322   printf ("changed ranges: ");
323   printtm (tmptr);
324   printf ("\n\n");
325
326   result_time = mktime (tmptr);
327   printf ("\nmktime: %d\n", result_time);
328 }
329 #endif /* DEBUG */