1 /* Convert struct partime into time_t. */
2
3 /* Copyright 1992, 1993, 1994, 1995, 1997 Paul Eggert
4 Distributed under license by the Free Software Foundation, Inc.
5
6 This file is part of RCS.
7
8 RCS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 RCS 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
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with RCS; see the file COPYING.
20 If not, write to the Free Software Foundation,
21 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22
23 Report problems and direct all questions to:
24
25 rcs-bugs@cs.purdue.edu
26
27 */
28
29 #if has_conf_h
30 # include <conf.h>
31 #else
32 # if HAVE_CONFIG_H
33 # include <config.h>
34 # else
35 # ifndef __STDC__
36 # define const
37 # endif
38 # endif
39 /* MIPS RISCOS4.52 defines time_t in <sys/types.h> not <time.h>. */
40 # include <sys/types.h>
41 # if HAVE_LIMITS_H
42 # include <limits.h>
43 # endif
44 # ifndef LONG_MIN
45 # define LONG_MIN (-1-2147483647L)
46 # endif
47 # if STDC_HEADERS
48 # include <stdlib.h>
49 # endif
50 # include <time.h>
51 # ifdef __STDC__
52 # define P(x) x
53 # else
54 # define P(x) ()
55 # endif
56 #endif
57
58 #include <partime.h>
59 #include <maketime.h>
60
61 char const maketId[] =
62 "$Id: maketime.c,v 5.15 1997/06/17 16:54:36 eggert Exp $";
63
64 static int isleap P ((int));
65 static int month_days P ((struct tm const *));
66 static time_t maketime P ((struct partime const *, time_t));
67
68 /* For maximum portability, use only localtime and gmtime.
69 Make no assumptions about the time_t epoch or the range of time_t values.
70 Avoid mktime because it's not universal and because there's no easy,
71 portable way for mktime to yield the inverse of gmtime. */
72
73 #define TM_YEAR_ORIGIN 1900
74
75 static int
isleap(y)76 isleap (y)
77 int y;
78 {
79 return (y & 3) == 0 && (y % 100 != 0 || y % 400 == 0);
80 }
81
82 /* days in year before start of months 0-12 */
83 static int const month_yday[] =
84 {
85 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
86 };
87
88 /* Yield the number of days in TM's month. */
89 static int
month_days(tm)90 month_days (tm)
91 struct tm const *tm;
92 {
93 int m = tm->tm_mon;
94 return (month_yday[m + 1] - month_yday[m]
95 + (m == 1 && isleap (tm->tm_year + TM_YEAR_ORIGIN)));
96 }
97
98 /* Convert UNIXTIME to struct tm form.
99 Use gmtime if available and if !LOCALZONE, localtime otherwise. */
100 struct tm *
time2tm(unixtime,localzone)101 time2tm (unixtime, localzone)
102 time_t unixtime;
103 int localzone;
104 {
105 struct tm *tm;
106 #ifdef TZ_is_unset
107 static char const *TZ;
108 if (!TZ && !(TZ = getenv ("TZ")))
109 TZ_is_unset ("The TZ environment variable is not set; please set it to your timezone");
110 #endif
111 if (localzone || !(tm = gmtime (&unixtime)))
112 tm = localtime (&unixtime);
113 return tm;
114 }
115
116 /* Yield A - B, measured in seconds. */
117 time_t
difftm(a,b)118 difftm (a, b)
119 struct tm const *a;
120 struct tm const *b;
121 {
122 int ay = a->tm_year + (TM_YEAR_ORIGIN - 1);
123 int by = b->tm_year + (TM_YEAR_ORIGIN - 1);
124 int ac = ay / 100 - (ay % 100 < 0);
125 int bc = by / 100 - (by % 100 < 0);
126 int difference_in_day_of_year = a->tm_yday - b->tm_yday;
127 int intervening_leap_days = (((ay >> 2) - (by >> 2))
128 - (ac - bc)
129 + ((ac >> 2) - (bc >> 2)));
130 time_t difference_in_years = ay - by;
131 time_t difference_in_days
132 = (difference_in_years * 365
133 + (intervening_leap_days + difference_in_day_of_year));
134 return (((((difference_in_days * 24
135 + (a->tm_hour - b->tm_hour))
136 * 60)
137 + (a->tm_min - b->tm_min))
138 * 60)
139 + (a->tm_sec - b->tm_sec));
140 }
141
142 /*
143 * Adjust time T by adding SECONDS. SECONDS must be at most 24 hours' worth.
144 * Adjust only T's year, mon, mday, hour, min and sec members;
145 * plus adjust wday if it is defined.
146 */
147 void
adjzone(t,seconds)148 adjzone (t, seconds)
149 register struct tm *t;
150 long seconds;
151 {
152 /*
153 * This code can be off by a second if SECONDS is not a multiple of 60,
154 * if T is local time, and if a leap second happens during this minute.
155 * But this bug has never occurred, and most likely will not ever occur.
156 * Liberia, the last country for which SECONDS % 60 was nonzero,
157 * switched to UTC in May 1972; the first leap second was in June 1972.
158 */
159 int leap_second = t->tm_sec == 60;
160 long sec = seconds + (t->tm_sec - leap_second);
161 if (sec < 0)
162 {
163 if ((t->tm_min -= (59 - sec) / 60) < 0)
164 {
165 if ((t->tm_hour -= (59 - t->tm_min) / 60) < 0)
166 {
167 t->tm_hour += 24;
168 if (TM_DEFINED (t->tm_wday) && --t->tm_wday < 0)
169 t->tm_wday = 6;
170 if (--t->tm_mday <= 0)
171 {
172 if (--t->tm_mon < 0)
173 {
174 --t->tm_year;
175 t->tm_mon = 11;
176 }
177 t->tm_mday = month_days (t);
178 }
179 }
180 t->tm_min += 24 * 60;
181 }
182 sec += 24L * 60 * 60;
183 }
184 else if (60 <= (t->tm_min += sec / 60))
185 if (24 <= (t->tm_hour += t->tm_min / 60))
186 {
187 t->tm_hour -= 24;
188 if (TM_DEFINED (t->tm_wday) && ++t->tm_wday == 7)
189 t->tm_wday = 0;
190 if (month_days (t) < ++t->tm_mday)
191 {
192 if (11 < ++t->tm_mon)
193 {
194 ++t->tm_year;
195 t->tm_mon = 0;
196 }
197 t->tm_mday = 1;
198 }
199 }
200 t->tm_min %= 60;
201 t->tm_sec = (int) (sec % 60) + leap_second;
202 }
203
204 /*
205 * Convert TM to time_t, using localtime if LOCALZONE and gmtime otherwise.
206 * Use only TM's year, mon, mday, hour, min, and sec members.
207 * Ignore TM's old tm_yday and tm_wday, but fill in their correct values.
208 * Yield -1 on failure (e.g. a member out of range).
209 * Posix 1003.1-1990 doesn't allow leap seconds, but some implementations
210 * have them anyway, so allow them if localtime/gmtime does.
211 */
212 time_t
tm2time(tm,localzone)213 tm2time (tm, localzone)
214 struct tm *tm;
215 int localzone;
216 {
217 /* Cache the most recent t,tm pairs; 1 for gmtime, 1 for localtime. */
218 static time_t t_cache[2];
219 static struct tm tm_cache[2];
220
221 time_t d, gt;
222 struct tm const *gtm;
223 /*
224 * The maximum number of iterations should be enough to handle any
225 * combinations of leap seconds, time zone rule changes, and solar time.
226 * 4 is probably enough; we use a bigger number just to be safe.
227 */
228 int remaining_tries = 8;
229
230 /* Avoid subscript errors. */
231 if (12 <= (unsigned) tm->tm_mon)
232 return -1;
233
234 tm->tm_yday = month_yday[tm->tm_mon] + tm->tm_mday
235 - (tm->tm_mon < 2 || !isleap (tm->tm_year + TM_YEAR_ORIGIN));
236
237 /* Make a first guess. */
238 gt = t_cache[localzone];
239 gtm = gt ? &tm_cache[localzone] : time2tm (gt, localzone);
240
241 /* Repeatedly use the error from the guess to improve the guess. */
242 while ((d = difftm (tm, gtm)) != 0)
243 {
244 if (--remaining_tries == 0)
245 return -1;
246 gt += d;
247 gtm = time2tm (gt, localzone);
248 }
249
250 /*
251 * Check that the guess actually matches;
252 * overflow can cause difftm to yield 0 even on differing times,
253 * or tm may have members out of range (e.g. bad leap seconds).
254 */
255 #define TM_DIFFER(a,b) \
256 ( \
257 ((a)->tm_year ^ (b)->tm_year) | \
258 ((a)->tm_mon ^ (b)->tm_mon) | \
259 ((a)->tm_mday ^ (b)->tm_mday) | \
260 ((a)->tm_hour ^ (b)->tm_hour) | \
261 ((a)->tm_min ^ (b)->tm_min) | \
262 ((a)->tm_sec ^ (b)->tm_sec) \
263 )
264 if (TM_DIFFER (tm, gtm))
265 {
266 /*
267 * If gt is a leap second, try gt+1; if it is one greater than
268 * a leap second, try gt-1; otherwise, it doesn't matter.
269 * Leap seconds always fall at month end.
270 */
271 int yd = tm->tm_year - gtm->tm_year;
272 gt += yd + (yd ? 0 : tm->tm_mon - gtm->tm_mon);
273 gtm = time2tm (gt, localzone);
274 if (TM_DIFFER (tm, gtm))
275 return -1;
276 }
277 t_cache[localzone] = gt;
278 tm_cache[localzone] = *gtm;
279
280 tm->tm_wday = gtm->tm_wday;
281 return gt;
282 }
283
284 /*
285 * Check *PT and convert it to time_t.
286 * If it is incompletely specified, use DEFAULT_TIME to fill it out.
287 * Use localtime if PT->zone is the special value TM_LOCAL_ZONE.
288 * Yield -1 on failure.
289 * ISO 8601 day-of-year and week numbers are not yet supported.
290 */
291 static time_t
maketime(pt,default_time)292 maketime (pt, default_time)
293 struct partime const *pt;
294 time_t default_time;
295 {
296 int localzone, wday;
297 struct tm tm;
298 struct tm *tm0 = 0;
299 time_t r;
300
301 tm0 = 0; /* Keep gcc -Wall happy. */
302 localzone = pt->zone == TM_LOCAL_ZONE;
303
304 tm = pt->tm;
305
306 if (TM_DEFINED (pt->ymodulus) || !TM_DEFINED (tm.tm_year))
307 {
308 /* Get tm corresponding to default time. */
309 tm0 = time2tm (default_time, localzone);
310 if (!localzone)
311 adjzone (tm0, pt->zone);
312 }
313
314 if (TM_DEFINED (pt->ymodulus))
315 tm.tm_year +=
316 (tm0->tm_year + TM_YEAR_ORIGIN) / pt->ymodulus * pt->ymodulus;
317 else if (!TM_DEFINED (tm.tm_year))
318 {
319 /* Set default year, month, day from current time. */
320 tm.tm_year = tm0->tm_year + TM_YEAR_ORIGIN;
321 if (!TM_DEFINED (tm.tm_mon))
322 {
323 tm.tm_mon = tm0->tm_mon;
324 if (!TM_DEFINED (tm.tm_mday))
325 tm.tm_mday = tm0->tm_mday;
326 }
327 }
328
329 /* Convert from partime year (Gregorian) to Posix year. */
330 tm.tm_year -= TM_YEAR_ORIGIN;
331
332 /* Set remaining default fields to be their minimum values. */
333 if (!TM_DEFINED (tm.tm_mon))
334 tm.tm_mon = 0;
335 if (!TM_DEFINED (tm.tm_mday))
336 tm.tm_mday = 1;
337 if (!TM_DEFINED (tm.tm_hour))
338 tm.tm_hour = 0;
339 if (!TM_DEFINED (tm.tm_min))
340 tm.tm_min = 0;
341 if (!TM_DEFINED (tm.tm_sec))
342 tm.tm_sec = 0;
343
344 if (!localzone)
345 adjzone (&tm, -pt->zone);
346 wday = tm.tm_wday;
347
348 /* Convert and fill in the rest of the tm. */
349 r = tm2time (&tm, localzone);
350
351 /* Check weekday. */
352 if (r != -1 && TM_DEFINED (wday) && wday != tm.tm_wday)
353 return -1;
354
355 return r;
356 }
357
358 /* Parse a free-format date in SOURCE, yielding a Unix format time. */
359 time_t
str2time(source,default_time,default_zone)360 str2time (source, default_time, default_zone)
361 char const *source;
362 time_t default_time;
363 long default_zone;
364 {
365 struct partime pt;
366
367 if (*partime (source, &pt))
368 return -1;
369 if (pt.zone == TM_UNDEFINED_ZONE)
370 pt.zone = default_zone;
371 return maketime (&pt, default_time);
372 }
373
374 #if TEST
375 #include <stdio.h>
376 int
main(argc,argv)377 main (argc, argv)
378 int argc;
379 char **argv;
380 {
381 time_t default_time = time ((time_t *) 0);
382 long default_zone = argv[1] ? atol (argv[1]) : 0;
383 char buf[1000];
384 while (fgets (buf, sizeof (buf), stdin))
385 {
386 time_t t = str2time (buf, default_time, default_zone);
387 printf ("%s", asctime (gmtime (&t)));
388 }
389 return 0;
390 }
391 #endif
392