1: /* Copyright (C) 1993, 1994, 1995 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).
5:
6:
7: NOTE: The canonical source of this file is maintained with the GNU C Library.
8: Bugs can be reported to bug-glibc@prep.ai.mit.edu.
9:
10: This program is free software; you can redistribute it and/or modify it
11: under the terms of the GNU General Public License as published by the
12: Free Software Foundation; either version 2, or (at your option) any
13: later version.
14:
15: This program is distributed in the hope that it will be useful,
16: but WITHOUT ANY WARRANTY; without even the implied warranty of
17: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18: GNU General Public License for more details.
19:
20: You should have received a copy of the GNU General Public License
21: along with this program; if not, write to the Free Software
22: Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
23:
24: /* Define this to have a standalone program to test this implementation of
25: mktime. */
26: /* #define DEBUG */
27:
28: #ifdef HAVE_CONFIG_H
29: #include <config.h>
30: #endif
31:
32: #include <sys/types.h> /* Some systems define `time_t' here. */
33: #include <time.h>
34:
35:
36: #ifndef __isleap
37: /* Nonzero if YEAR is a leap year (every 4 years,
38: except every 100th isn't, and every 400th is). */
39: #define __isleap(year) \
40: ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
41: #endif
42:
43: #ifndef __P
44: #if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
45: #define __P(args) args
46: #else
47: #define __P(args) ()
48: #endif /* GCC. */
49: #endif /* Not __P. */
50:
51: /* How many days are in each month. */
52: const unsigned short int __mon_lengths[2][12] =
53: {
54: /* Normal years. */
55: { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
56: /* Leap years. */
57: { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
58: };
59:
60:
61: static int times_through_search; /* This library routine should never
62: hang -- make sure we always return
63: when we're searching for a value */
64:
65:
66: #ifdef DEBUG
67:
68: #include <stdio.h>
69: #include <ctype.h>
70:
71: int debugging_enabled = 0;
72:
73: /* Print the values in a `struct tm'. */
74: static void
75: printtm (it)
76: struct tm *it;
77: {
78: printf ("%02d/%02d/%04d %02d:%02d:%02d (%s) yday:%03d dst:%d gmtoffset:%ld",
79: it->tm_mon + 1,
80: it->tm_mday,
81: it->tm_year + 1900,
82: it->tm_hour,
83: it->tm_min,
84: it->tm_sec,
85: it->tm_zone,
86: it->tm_yday,
87: it->tm_isdst,
88: it->tm_gmtoff);
89: }
90: #endif
91:
92:
93: static time_t
94: dist_tm (t1, t2)
95: struct tm *t1;
96: struct tm *t2;
97: {
98: time_t distance = 0;
99: unsigned long int v1, v2;
100: int diff_flag = 0;
101:
102: v1 = v2 = 0;
103:
104: #define doit(x, secs) \
105: v1 += t1->x * secs; \
106: v2 += t2->x * secs; \
107: if (!diff_flag) \
108: { \
109: if (t1->x < t2->x) \
110: diff_flag = -1; \
111: else if (t1->x > t2->x) \
112: diff_flag = 1; \
113: }
114:
115: doit (tm_year, 31536000); /* Okay, not all years have 365 days. */
116: doit (tm_mon, 2592000); /* Okay, not all months have 30 days. */
117: doit (tm_mday, 86400);
118: doit (tm_hour, 3600);
119: doit (tm_min, 60);
120: doit (tm_sec, 1);
121:
122: #undef doit
123:
124: /* We should also make sure that the sign of DISTANCE is correct -- if
125: DIFF_FLAG is positive, the distance should be positive and vice versa. */
126:
127: distance = (v1 > v2) ? (v1 - v2) : (v2 - v1);
128: if (diff_flag < 0)
129: distance = -distance;
130:
131: if (times_through_search > 20) /* Arbitrary # of calls, but makes sure we
132: never hang if there's a problem with
133: this algorithm. */
134: {
135: distance = diff_flag;
136: }
137:
138: /* We need this DIFF_FLAG business because it is forseeable that the
139: distance may be zero when, in actuality, the two structures are
140: different. This is usually the case when the dates are 366 days apart
141: and one of the years is a leap year. */
142:
143: if (distance == 0 && diff_flag)
144: distance = 86400 * diff_flag;
145:
146: return distance;
147: }
148:
149:
150: /* MKTIME converts the values in a struct tm to a time_t. The values
151: in tm_wday and tm_yday are ignored; other values can be put outside
152: of legal ranges since they will be normalized. This routine takes
153: care of that normalization. */
154:
155: void
156: do_normalization (tmptr)
157: struct tm *tmptr;
158: {
159:
160: #define normalize(foo,x,y,bar); \
161: while (tmptr->foo < x) \
162: { \
163: tmptr->bar--; \
164: tmptr->foo = (y - (x - tmptr->foo) + 1); \
165: } \
166: while (tmptr->foo > y) \
167: { \
168: tmptr->foo = (x + (tmptr->foo - y) - 1); \
169: tmptr->bar++; \
170: }
171:
172: normalize (tm_sec, 0, 59, tm_min);
173: normalize (tm_min, 0, 59, tm_hour);
174: normalize (tm_hour, 0, 23, tm_mday);
175:
176: /* Do the month first, so day range can be found. */
177: normalize (tm_mon, 0, 11, tm_year);
178:
179: /* Since the day range modifies the month, we should be careful how
180: we reference the array of month lengths -- it is possible that
181: the month will go negative, hence the modulo...
182:
183: Also, tm_year is the year - 1900, so we have to 1900 to have it
184: work correctly. */
185:
186: normalize (tm_mday, 1,
187: __mon_lengths[__isleap (tmptr->tm_year + 1900)]
188: [((tmptr->tm_mon < 0)
189: ? (12 + (tmptr->tm_mon % 12))
190: : (tmptr->tm_mon % 12)) ],
191: tm_mon);
192:
193: /* Do the month again, because the day may have pushed it out of range. */
194: normalize (tm_mon, 0, 11, tm_year);
195:
196: /* Do the day again, because the month may have changed the range. */
197: normalize (tm_mday, 1,
198: __mon_lengths[__isleap (tmptr->tm_year + 1900)]
199: [((tmptr->tm_mon < 0)
200: ? (12 + (tmptr->tm_mon % 12))
201: : (tmptr->tm_mon % 12)) ],
202: tm_mon);
203:
204: #ifdef DEBUG
205: if (debugging_enabled)
206: {
207: printf (" After normalizing:\n ");
208: printtm (tmptr);
209: putchar ('\n');
210: }
211: #endif
212:
213: }
214:
215:
216: /* Here's where the work gets done. */
217:
218: #define BAD_STRUCT_TM ((time_t) -1)
219:
220: time_t
221: __mktime_internal (timeptr, producer)
222: struct tm *timeptr;
223: struct tm *(*producer) __P ((const time_t *, struct tm *));
224: {
225: struct tm our_tm; /* our working space */
226: struct tm *me = &our_tm; /* a pointer to the above */
227: time_t result; /* the value we return */
228:
229: *me = *timeptr; /* copy the struct tm that was passed
230: in by the caller */
231:
232:
233: /***************************/
234: /* Normalize the structure */
235: /***************************/
236:
237: /* This routine assumes that the value of TM_ISDST is -1, 0, or 1.
238: If the user didn't pass it in that way, fix it. */
239:
240: if (me->tm_isdst > 0)
241: me->tm_isdst = 1;
242: else if (me->tm_isdst < 0)
243: me->tm_isdst = -1;
244:
245: do_normalization (me);
246:
247: /* Get out of here if it's not possible to represent this struct.
248: If any of the values in the normalized struct tm are negative,
249: our algorithms won't work. Luckily, we only need to check the
250: year at this point; normalization guarantees that all values will
251: be in correct ranges EXCEPT the year. */
252:
253: if (me->tm_year < 0)
254: return BAD_STRUCT_TM;
255:
256: /*************************************************/
257: /* Find the appropriate time_t for the structure */
258: /*************************************************/
259:
260: /* Modified b-search -- make intelligent guesses as to where the
261: time might lie along the timeline, assuming that our target time
262: lies a linear distance (w/o considering time jumps of a
263: particular region).
264:
265: Assume that time does not fluctuate at all along the timeline --
266: e.g., assume that a day will always take 86400 seconds, etc. --
267: and come up with a hypothetical value for the time_t
268: representation of the struct tm TARGET, in relation to the guess
269: variable -- it should be pretty close!
270:
271: After testing this, the maximum number of iterations that I had
272: on any number that I tried was 3! Not bad.
273:
274: The reason this is not a subroutine is that we will modify some
275: fields in the struct tm (yday and mday). I've never felt good
276: about side-effects when writing structured code... */
277:
278: {
279: struct tm *guess_tm;
280: struct tm guess_struct;
281: time_t guess = 0;
282: time_t distance = 0;
283: time_t last_distance = 0;
284:
285: times_through_search = 0;
286:
287: do
288: {
289: guess += distance;
290:
291: times_through_search++;
292:
293: guess_tm = (*producer) (&guess, &guess_struct);
294:
295: #ifdef DEBUG
296: if (debugging_enabled)
297: {
298: printf (" Guessing time_t == %d\n ", (int) guess);
299: printtm (guess_tm);
300: putchar ('\n');
301: }
302: #endif
303:
304: /* How far is our guess from the desired struct tm? */
305: distance = dist_tm (me, guess_tm);
306:
307: /* Handle periods of time where a period of time is skipped.
308: For example, 2:15 3 April 1994 does not exist, because DST
309: is in effect. The distance function will alternately
310: return values of 3600 and -3600, because it doesn't know
311: that the requested time doesn't exist. In these situations
312: (even if the skip is not exactly an hour) the distances
313: returned will be the same, but alternating in sign. We
314: want the later time, so check to see that the distance is
315: oscillating and we've chosen the correct of the two
316: possibilities.
317:
318: Useful: 3 Apr 94 765356300, 30 Oct 94 783496000 */
319:
320: if ((distance == -last_distance) && (distance < last_distance))
321: {
322: /* If the caller specified that the DST flag was off, it's
323: not possible to represent this time. */
324: if (me->tm_isdst == 0)
325: {
326: #ifdef DEBUG
327: printf (" Distance is oscillating -- dst flag nixes struct!\n");
328: #endif
329: return BAD_STRUCT_TM;
330: }
331:
332: #ifdef DEBUG
333: printf (" Distance is oscillating -- chose the later time.\n");
334: #endif
335: distance = 0;
336: }
337:
338: if ((distance == 0) && (me->tm_isdst != -1)
339: && (me->tm_isdst != guess_tm->tm_isdst))
340: {
341: /* If we're in this code, we've got the right time but the
342: wrong daylight savings flag. We need to move away from
343: the time that we have and approach the other time from
344: the other direction. That is, if I've requested the
345: non-DST version of a time and I get the DST version
346: instead, I want to put us forward in time and search
347: backwards to get the other time. I checked all of the
348: configuration files for the tz package -- no entry
349: saves more than two hours, so I think we'll be safe by
350: moving 24 hours in one direction. IF THE AMOUNT OF
351: TIME SAVED IN THE CONFIGURATION FILES CHANGES, THIS
352: VALUE MAY NEED TO BE ADJUSTED. Luckily, we can never
353: have more than one level of overlaps, or this would
354: never work. */
355:
356: #define SKIP_VALUE 86400
357:
358: if (guess_tm->tm_isdst == 0)
359: /* we got the later one, but want the earlier one */
360: distance = -SKIP_VALUE;
361: else
362: distance = SKIP_VALUE;
363:
364: #ifdef DEBUG
365: printf (" Got the right time, wrong DST value -- adjusting\n");
366: #endif
367: }
368:
369: last_distance = distance;
370:
371: } while (distance != 0);
372:
373: /* Check to see that the dst flag matches */
374:
375: if (me->tm_isdst != -1)
376: {
377: if (me->tm_isdst != guess_tm->tm_isdst)
378: {
379: #ifdef DEBUG
380: printf (" DST flag doesn't match! FIXME?\n");
381: #endif
382: return BAD_STRUCT_TM;
383: }
384: }
385:
386: result = guess; /* Success! */
387:
388: /* On successful completion, the values of tm_wday and tm_yday
389: have to be set appropriately. */
390:
391: /* me->tm_yday = guess_tm->tm_yday;
392: me->tm_mday = guess_tm->tm_mday; */
393:
394: *me = *guess_tm;
395: }
396:
397: /* Update the caller's version of the structure */
398:
399: *timeptr = *me;
400:
401: return result;
402: }
403:
404: #if ! HAVE_LOCALTIME_R && ! defined (localtime_r)
405: #ifdef _LIBC
406: #define localtime_r __localtime_r
407: #else
408: /* Approximate localtime_r as best we can in its absence. */
409: #define localtime_r my_localtime_r /* Avoid clash with system localtime_r. */
410: static struct tm *
411: localtime_r (t, tp)
412: const time_t *t;
413: struct tm *tp;
414: {
415: struct tm *l = localtime (t);
416: if (! l)
417: return 0;
418: *tp = *l;
419: return tp;
420: }
421: #endif /* ! _LIBC */
422: #endif /* ! HAVE_LOCALTIME_R && ! defined (localtime_r) */
423:
424: time_t
425: #ifdef DEBUG /* make it work even if the system's
426: libc has it's own mktime routine */
427: my_mktime (timeptr)
428: #else
429: mktime (timeptr)
430: #endif
431: struct tm *timeptr;
432: {
433: return __mktime_internal (timeptr, localtime_r);
434: }
435:
436: #ifdef weak_alias
437: weak_alias (mktime, timelocal)
438: #endif
439:
440: #ifdef DEBUG
441: void
442: main (argc, argv)
443: int argc;
444: char *argv[];
445: {
446: int time;
447: int result_time;
448: struct tm *tmptr;
449:
450: if (argc == 1)
451: {
452: long q;
453:
454: printf ("starting long test...\n");
455:
456: for (q = 10000000; q < 1000000000; q += 599)
457: {
458: struct tm *tm = localtime ((time_t *) &q);
459: if ((q % 10000) == 0) { printf ("%ld\n", q); fflush (stdout); }
460: if (q != my_mktime (tm))
461: { printf ("failed for %ld\n", q); fflush (stdout); }
462: }
463:
464: printf ("test finished\n");
465:
466: exit (0);
467: }
468:
469: if (argc != 2)
470: {
471: printf ("wrong # of args\n");
472: exit (0);
473: }
474:
475: debugging_enabled = 1; /* We want to see the info */
476:
477: ++argv;
478: time = atoi (*argv);
479:
480: tmptr = localtime ((time_t *) &time);
481: printf ("Localtime tells us that a time_t of %d represents\n ", time);
482: printtm (tmptr);
483: putchar ('\n');
484:
485: printf (" Given localtime's return val, mktime returns %d which is\n ",
486: (int) my_mktime (tmptr));
487: printtm (tmptr);
488: putchar ('\n');
489:
490: #if 0
491: tmptr->tm_sec -= 20;
492: tmptr->tm_min -= 20;
493: tmptr->tm_hour -= 20;
494: tmptr->tm_mday -= 20;
495: tmptr->tm_mon -= 20;
496: tmptr->tm_year -= 20;
497: tmptr->tm_gmtoff -= 20000; /* This has no effect! */
498: tmptr->tm_zone = NULL; /* Nor does this! */
499: tmptr->tm_isdst = -1;
500: #endif
501:
502: tmptr->tm_hour += 1;
503: tmptr->tm_isdst = -1;
504:
505: printf ("\n\nchanged ranges: ");
506: printtm (tmptr);
507: putchar ('\n');
508:
509: result_time = my_mktime (tmptr);
510: printf ("\nmktime: %d\n", result_time);
511:
512: tmptr->tm_isdst = 0;
513:
514: printf ("\n\nchanged ranges: ");
515: printtm (tmptr);
516: putchar ('\n');
517:
518: result_time = my_mktime (tmptr);
519: printf ("\nmktime: %d\n", result_time);
520: }
521: #endif /* DEBUG */
522:
523:
524: /*
525: Local Variables:
526: compile-command: "gcc -g mktime.c -o mktime -DDEBUG"
527: End:
528: */
529:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to mktime.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / lrzsz / lib