*** empty log message ***
[findutils.git] / lib / mktime.c
blobd441d8d8c410d0620898ed39e083315b5cd5d94c
1 /* Copyright (C) 1993, 1994 Free Software Foundation, Inc.
2 Contributed by Noel Cragg (noel@cs.oberlin.edu), with fixes by
3 Michael E. Calwas (calwas@ttd.teradyne.com) and
4 Wade Hampton (tasi029@tmn.com).
6 This file is part of the GNU C Library.
8 The GNU C Library is free software; you can redistribute it and/or
9 modify it under the terms of the GNU Library General Public License as
10 published by the Free Software Foundation; either version 2 of the
11 License, or (at your option) any later version.
13 The GNU C Library is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Library General Public License for more details.
18 You should have received a copy of the GNU Library General Public
19 License along with the GNU C Library; see the file COPYING.LIB. If
20 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
21 Cambridge, MA 02139, USA. */
23 /* Define this to have a standalone program to test this implementation of
24 mktime. */
25 /* #define DEBUG */
27 #ifdef HAVE_CONFIG_H
28 #include <config.h>
29 #endif
31 #include <sys/types.h> /* Some systems define `time_t' here. */
32 #include <time.h>
35 #ifndef __isleap
36 /* Nonzero if YEAR is a leap year (every 4 years,
37 except every 100th isn't, and every 400th is). */
38 #define __isleap(year) \
39 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
40 #endif
42 #ifndef __P
43 #if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
44 #define __P(args) args
45 #else
46 #define __P(args) ()
47 #endif /* GCC. */
48 #endif /* Not __P. */
50 /* How many days are in each month. */
51 const unsigned short int __mon_lengths[2][12] =
53 /* Normal years. */
54 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
55 /* Leap years. */
56 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
60 static int times_through_search; /* This library routine should never
61 hang -- make sure we always return
62 when we're searching for a value */
65 #ifdef DEBUG
67 #include <stdio.h>
68 #include <ctype.h>
70 int debugging_enabled = 0;
72 /* Print the values in a `struct tm'. */
73 static void
74 printtm (it)
75 struct tm *it;
77 printf ("%02d/%02d/%04d %02d:%02d:%02d (%s) yday:%03d dst:%d gmtoffset:%ld",
78 it->tm_mon + 1,
79 it->tm_mday,
80 it->tm_year + 1900,
81 it->tm_hour,
82 it->tm_min,
83 it->tm_sec,
84 it->tm_zone,
85 it->tm_yday,
86 it->tm_isdst,
87 it->tm_gmtoff);
89 #endif
92 static time_t
93 dist_tm (t1, t2)
94 struct tm *t1;
95 struct tm *t2;
97 time_t distance = 0;
98 unsigned long int v1, v2;
99 int diff_flag = 0;
101 v1 = v2 = 0;
103 #define doit(x, secs) \
104 v1 += t1->x * secs; \
105 v2 += t2->x * secs; \
106 if (!diff_flag) \
108 if (t1->x < t2->x) \
109 diff_flag = -1; \
110 else if (t1->x > t2->x) \
111 diff_flag = 1; \
114 doit (tm_year, 31536000); /* Okay, not all years have 365 days. */
115 doit (tm_mon, 2592000); /* Okay, not all months have 30 days. */
116 doit (tm_mday, 86400);
117 doit (tm_hour, 3600);
118 doit (tm_min, 60);
119 doit (tm_sec, 1);
121 #undef doit
123 /* We should also make sure that the sign of DISTANCE is correct -- if
124 DIFF_FLAG is positive, the distance should be positive and vice versa. */
126 distance = (v1 > v2) ? (v1 - v2) : (v2 - v1);
127 if (diff_flag < 0)
128 distance = -distance;
130 if (times_through_search > 20) /* Arbitrary # of calls, but makes sure we
131 never hang if there's a problem with
132 this algorithm. */
134 distance = diff_flag;
137 /* We need this DIFF_FLAG business because it is forseeable that the
138 distance may be zero when, in actuality, the two structures are
139 different. This is usually the case when the dates are 366 days apart
140 and one of the years is a leap year. */
142 if (distance == 0 && diff_flag)
143 distance = 86400 * diff_flag;
145 return distance;
149 /* MKTIME converts the values in a struct tm to a time_t. The values
150 in tm_wday and tm_yday are ignored; other values can be put outside
151 of legal ranges since they will be normalized. This routine takes
152 care of that normalization. */
154 void
155 do_normalization (tmptr)
156 struct tm *tmptr;
159 #define normalize(foo,x,y,bar); \
160 while (tmptr->foo < x) \
162 tmptr->bar--; \
163 tmptr->foo = (y - (x - tmptr->foo) + 1); \
165 while (tmptr->foo > y) \
167 tmptr->foo = (x + (tmptr->foo - y) - 1); \
168 tmptr->bar++; \
171 normalize (tm_sec, 0, 59, tm_min);
172 normalize (tm_min, 0, 59, tm_hour);
173 normalize (tm_hour, 0, 23, tm_mday);
175 /* Do the month first, so day range can be found. */
176 normalize (tm_mon, 0, 11, tm_year);
178 /* Since the day range modifies the month, we should be careful how
179 we reference the array of month lengths -- it is possible that
180 the month will go negative, hence the modulo...
182 Also, tm_year is the year - 1900, so we have to 1900 to have it
183 work correctly. */
185 normalize (tm_mday, 1,
186 __mon_lengths[__isleap (tmptr->tm_year + 1900)]
187 [((tmptr->tm_mon < 0)
188 ? (12 + (tmptr->tm_mon % 12))
189 : (tmptr->tm_mon % 12)) ],
190 tm_mon);
192 /* Do the month again, because the day may have pushed it out of range. */
193 normalize (tm_mon, 0, 11, tm_year);
195 /* Do the day again, because the month may have changed the range. */
196 normalize (tm_mday, 1,
197 __mon_lengths[__isleap (tmptr->tm_year + 1900)]
198 [((tmptr->tm_mon < 0)
199 ? (12 + (tmptr->tm_mon % 12))
200 : (tmptr->tm_mon % 12)) ],
201 tm_mon);
203 #ifdef DEBUG
204 if (debugging_enabled)
206 printf (" After normalizing:\n ");
207 printtm (tmptr);
208 putchar ('\n');
210 #endif
215 /* Here's where the work gets done. */
217 #define BAD_STRUCT_TM ((time_t) -1)
219 time_t
220 _mktime_internal (timeptr, producer)
221 struct tm *timeptr;
222 struct tm *(*producer) __P ((const time_t *));
224 struct tm our_tm; /* our working space */
225 struct tm *me = &our_tm; /* a pointer to the above */
226 time_t result; /* the value we return */
228 *me = *timeptr; /* copy the struct tm that was passed
229 in by the caller */
232 /***************************/
233 /* Normalize the structure */
234 /***************************/
236 /* This routine assumes that the value of TM_ISDST is -1, 0, or 1.
237 If the user didn't pass it in that way, fix it. */
239 if (me->tm_isdst > 0)
240 me->tm_isdst = 1;
241 else if (me->tm_isdst < 0)
242 me->tm_isdst = -1;
244 do_normalization (me);
246 /* Get out of here if it's not possible to represent this struct.
247 If any of the values in the normalized struct tm are negative,
248 our algorithms won't work. Luckily, we only need to check the
249 year at this point; normalization guarantees that all values will
250 be in correct ranges EXCEPT the year. */
252 if (me->tm_year < 0)
253 return BAD_STRUCT_TM;
255 /*************************************************/
256 /* Find the appropriate time_t for the structure */
257 /*************************************************/
259 /* Modified b-search -- make intelligent guesses as to where the
260 time might lie along the timeline, assuming that our target time
261 lies a linear distance (w/o considering time jumps of a
262 particular region).
264 Assume that time does not fluctuate at all along the timeline --
265 e.g., assume that a day will always take 86400 seconds, etc. --
266 and come up with a hypothetical value for the time_t
267 representation of the struct tm TARGET, in relation to the guess
268 variable -- it should be pretty close!
270 After testing this, the maximum number of iterations that I had
271 on any number that I tried was 3! Not bad.
273 The reason this is not a subroutine is that we will modify some
274 fields in the struct tm (yday and mday). I've never felt good
275 about side-effects when writing structured code... */
278 struct tm *guess_tm;
279 time_t guess = 0;
280 time_t distance = 0;
281 time_t last_distance = 0;
283 times_through_search = 0;
287 guess += distance;
289 times_through_search++;
291 guess_tm = (*producer) (&guess);
293 #ifdef DEBUG
294 if (debugging_enabled)
296 printf (" Guessing time_t == %d\n ", (int) guess);
297 printtm (guess_tm);
298 putchar ('\n');
300 #endif
302 /* How far is our guess from the desired struct tm? */
303 distance = dist_tm (me, guess_tm);
305 /* Handle periods of time where a period of time is skipped.
306 For example, 2:15 3 April 1994 does not exist, because DST
307 is in effect. The distance function will alternately
308 return values of 3600 and -3600, because it doesn't know
309 that the requested time doesn't exist. In these situations
310 (even if the skip is not exactly an hour) the distances
311 returned will be the same, but alternating in sign. We
312 want the later time, so check to see that the distance is
313 oscillating and we've chosen the correct of the two
314 possibilities.
316 Useful: 3 Apr 94 765356300, 30 Oct 94 783496000 */
318 if ((distance == -last_distance) && (distance < last_distance))
320 /* If the caller specified that the DST flag was off, it's
321 not possible to represent this time. */
322 if (me->tm_isdst == 0)
324 #ifdef DEBUG
325 printf (" Distance is oscillating -- dst flag nixes struct!\n");
326 #endif
327 return BAD_STRUCT_TM;
330 #ifdef DEBUG
331 printf (" Distance is oscillating -- chose the later time.\n");
332 #endif
333 distance = 0;
336 if ((distance == 0) && (me->tm_isdst != -1)
337 && (me->tm_isdst != guess_tm->tm_isdst))
339 /* If we're in this code, we've got the right time but the
340 wrong daylight savings flag. We need to move away from
341 the time that we have and approach the other time from
342 the other direction. That is, if I've requested the
343 non-DST version of a time and I get the DST version
344 instead, I want to put us forward in time and search
345 backwards to get the other time. I checked all of the
346 configuration files for the tz package -- no entry
347 saves more than two hours, so I think we'll be safe by
348 moving 24 hours in one direction. IF THE AMOUNT OF
349 TIME SAVED IN THE CONFIGURATION FILES CHANGES, THIS
350 VALUE MAY NEED TO BE ADJUSTED. Luckily, we can never
351 have more than one level of overlaps, or this would
352 never work. */
354 #define SKIP_VALUE 86400
356 if (guess_tm->tm_isdst == 0)
357 /* we got the later one, but want the earlier one */
358 distance = -SKIP_VALUE;
359 else
360 distance = SKIP_VALUE;
362 #ifdef DEBUG
363 printf (" Got the right time, wrong DST value -- adjusting\n");
364 #endif
367 last_distance = distance;
369 } while (distance != 0);
371 /* Check to see that the dst flag matches */
373 if (me->tm_isdst != -1)
375 if (me->tm_isdst != guess_tm->tm_isdst)
377 #ifdef DEBUG
378 printf (" DST flag doesn't match! FIXME?\n");
379 #endif
380 return BAD_STRUCT_TM;
384 result = guess; /* Success! */
386 /* On successful completion, the values of tm_wday and tm_yday
387 have to be set appropriately. */
389 /* me->tm_yday = guess_tm->tm_yday;
390 me->tm_mday = guess_tm->tm_mday; */
392 *me = *guess_tm;
395 /* Update the caller's version of the structure */
397 *timeptr = *me;
399 return result;
402 time_t
403 #ifdef DEBUG /* make it work even if the system's
404 libc has it's own mktime routine */
405 my_mktime (timeptr)
406 #else
407 mktime (timeptr)
408 #endif
409 struct tm *timeptr;
411 return _mktime_internal (timeptr, localtime);
414 #ifdef DEBUG
415 void
416 main (argc, argv)
417 int argc;
418 char *argv[];
420 int time;
421 int result_time;
422 struct tm *tmptr;
424 if (argc == 1)
426 long q;
428 printf ("starting long test...\n");
430 for (q = 10000000; q < 1000000000; q += 599)
432 struct tm *tm = localtime ((time_t *) &q);
433 if ((q % 10000) == 0) { printf ("%ld\n", q); fflush (stdout); }
434 if (q != my_mktime (tm))
435 { printf ("failed for %ld\n", q); fflush (stdout); }
438 printf ("test finished\n");
440 exit (0);
443 if (argc != 2)
445 printf ("wrong # of args\n");
446 exit (0);
449 debugging_enabled = 1; /* We want to see the info */
451 ++argv;
452 time = atoi (*argv);
454 tmptr = localtime ((time_t *) &time);
455 printf ("Localtime tells us that a time_t of %d represents\n ", time);
456 printtm (tmptr);
457 putchar ('\n');
459 printf (" Given localtime's return val, mktime returns %d which is\n ",
460 (int) my_mktime (tmptr));
461 printtm (tmptr);
462 putchar ('\n');
464 #if 0
465 tmptr->tm_sec -= 20;
466 tmptr->tm_min -= 20;
467 tmptr->tm_hour -= 20;
468 tmptr->tm_mday -= 20;
469 tmptr->tm_mon -= 20;
470 tmptr->tm_year -= 20;
471 tmptr->tm_gmtoff -= 20000; /* This has no effect! */
472 tmptr->tm_zone = NULL; /* Nor does this! */
473 tmptr->tm_isdst = -1;
474 #endif
476 tmptr->tm_hour += 1;
477 tmptr->tm_isdst = -1;
479 printf ("\n\nchanged ranges: ");
480 printtm (tmptr);
481 putchar ('\n');
483 result_time = my_mktime (tmptr);
484 printf ("\nmktime: %d\n", result_time);
486 tmptr->tm_isdst = 0;
488 printf ("\n\nchanged ranges: ");
489 printtm (tmptr);
490 putchar ('\n');
492 result_time = my_mktime (tmptr);
493 printf ("\nmktime: %d\n", result_time);
495 #endif /* DEBUG */
499 Local Variables:
500 compile-command: "gcc -g mktime.c -o mktime -DDEBUG"
501 End: