| 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 | /* For maximum portability, use only localtime and gmtime.
|
|---|
| 30 | Make no assumptions about the time_t epoch or the range of time_t values.
|
|---|
| 31 | Avoid mktime because it's not universal and because there's no easy,
|
|---|
| 32 | portable way for mktime to yield the inverse of gmtime. */
|
|---|
| 33 |
|
|---|
| 34 | #if has_conf_h
|
|---|
| 35 | # include <conf.h>
|
|---|
| 36 | #else
|
|---|
| 37 | # if HAVE_CONFIG_H
|
|---|
| 38 | # include <config.h>
|
|---|
| 39 | # else
|
|---|
| 40 | # ifndef __STDC__
|
|---|
| 41 | # define const
|
|---|
| 42 | # endif
|
|---|
| 43 | # endif
|
|---|
| 44 | /* MIPS RISCOS4.52 defines time_t in <sys/types.h> not <time.h>. */
|
|---|
| 45 | # include <sys/types.h>
|
|---|
| 46 | # if HAVE_LIMITS_H
|
|---|
| 47 | # include <limits.h>
|
|---|
| 48 | # endif
|
|---|
| 49 | # ifndef LONG_MIN
|
|---|
| 50 | # define LONG_MIN (-1-2147483647L)
|
|---|
| 51 | # endif
|
|---|
| 52 | # if STDC_HEADERS
|
|---|
| 53 | # include <stdlib.h>
|
|---|
| 54 | # endif
|
|---|
| 55 | # include <time.h>
|
|---|
| 56 | # ifdef __STDC__
|
|---|
| 57 | # define P(x) x
|
|---|
| 58 | # else
|
|---|
| 59 | # define P(x) ()
|
|---|
| 60 | # endif
|
|---|
| 61 | #endif
|
|---|
| 62 |
|
|---|
| 63 | #include <partime.h>
|
|---|
| 64 | #include <maketime.h>
|
|---|
| 65 |
|
|---|
| 66 | char const maket_id[] =
|
|---|
| 67 | "$Id: maketime.c,v 5.17 1999/08/29 11:12:37 eggert Exp $";
|
|---|
| 68 |
|
|---|
| 69 | static int isleap P ((int));
|
|---|
| 70 | static int month_days P ((struct tm const *));
|
|---|
| 71 | static time_t maketime P ((struct partime const *, time_t));
|
|---|
| 72 |
|
|---|
| 73 | /* Suppose A1 + B1 = SUM1, using 2's complement arithmetic ignoring overflow.
|
|---|
| 74 | Suppose A, B and SUM have the same respective signs as A1, B1, and SUM1.
|
|---|
| 75 | Then this yields nonzero if overflow occurred during the addition.
|
|---|
| 76 | Overflow occurs if A and B have the same sign, but A and SUM differ in sign.
|
|---|
| 77 | Use `^' to test whether signs differ, and `< 0' to isolate the sign. */
|
|---|
| 78 | #define overflow_sum_sign(a, b, sum) ((~((a) ^ (b)) & ((a) ^ (sum))) < 0)
|
|---|
| 79 |
|
|---|
| 80 | /* Quotient and remainder when dividing A by B,
|
|---|
| 81 | truncating towards minus infinity, where B is positive. */
|
|---|
| 82 | #define DIV(a, b) ((a) / (b) - ((a) % (b) < 0))
|
|---|
| 83 | #define MOD(a, b) ((a) % (b) + (b) * ((a) % (b) < 0))
|
|---|
| 84 |
|
|---|
| 85 | /* Number of days in 400 consecutive Gregorian years. */
|
|---|
| 86 | #define Y400_DAYS (365 * 400L + 100 - 4 + 1)
|
|---|
| 87 |
|
|---|
| 88 | /* Number of years to add to tm_year to get Gregorian year. */
|
|---|
| 89 | #define TM_YEAR_ORIGIN 1900
|
|---|
| 90 |
|
|---|
| 91 | static int
|
|---|
| 92 | isleap (y)
|
|---|
| 93 | int y;
|
|---|
| 94 | {
|
|---|
| 95 | return (y & 3) == 0 && (y % 100 != 0 || y % 400 == 0);
|
|---|
| 96 | }
|
|---|
| 97 |
|
|---|
| 98 | /* days in year before start of months 0-12 */
|
|---|
| 99 | static int const month_yday[] =
|
|---|
| 100 | {
|
|---|
| 101 | 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
|
|---|
| 102 | };
|
|---|
| 103 |
|
|---|
| 104 | /* Yield the number of days in TM's month. */
|
|---|
| 105 | static int
|
|---|
| 106 | month_days (tm)
|
|---|
| 107 | struct tm const *tm;
|
|---|
| 108 | {
|
|---|
| 109 | int m = tm->tm_mon;
|
|---|
| 110 | return (month_yday[m + 1] - month_yday[m]
|
|---|
| 111 | + (m == 1 && isleap (tm->tm_year + TM_YEAR_ORIGIN)));
|
|---|
| 112 | }
|
|---|
| 113 |
|
|---|
| 114 | /* Convert UNIXTIME to struct tm form.
|
|---|
| 115 | Use gmtime if available and if !LOCALZONE, localtime otherwise. */
|
|---|
| 116 | struct tm *
|
|---|
| 117 | time2tm (unixtime, localzone)
|
|---|
| 118 | time_t unixtime;
|
|---|
| 119 | int localzone;
|
|---|
| 120 | {
|
|---|
| 121 | struct tm *tm;
|
|---|
| 122 | #ifdef TZ_is_unset
|
|---|
| 123 | static char const *TZ;
|
|---|
| 124 | if (!TZ && !(TZ = getenv ("TZ")))
|
|---|
| 125 | TZ_is_unset ("The TZ environment variable is not set; please set it to your timezone");
|
|---|
| 126 | #endif
|
|---|
| 127 | if (localzone || !(tm = gmtime (&unixtime)))
|
|---|
| 128 | tm = localtime (&unixtime);
|
|---|
| 129 | return tm;
|
|---|
| 130 | }
|
|---|
| 131 |
|
|---|
| 132 | /* Yield A - B, measured in seconds. */
|
|---|
| 133 | time_t
|
|---|
| 134 | difftm (a, b)
|
|---|
| 135 | struct tm const *a;
|
|---|
| 136 | struct tm const *b;
|
|---|
| 137 | {
|
|---|
| 138 | int ay = a->tm_year + (TM_YEAR_ORIGIN - 1);
|
|---|
| 139 | int by = b->tm_year + (TM_YEAR_ORIGIN - 1);
|
|---|
| 140 | int ac = DIV (ay, 100);
|
|---|
| 141 | int bc = DIV (by, 100);
|
|---|
| 142 | int difference_in_day_of_year = a->tm_yday - b->tm_yday;
|
|---|
| 143 | int intervening_leap_days = (((ay >> 2) - (by >> 2))
|
|---|
| 144 | - (ac - bc)
|
|---|
| 145 | + ((ac >> 2) - (bc >> 2)));
|
|---|
| 146 | time_t difference_in_years = ay - by;
|
|---|
| 147 | time_t difference_in_days
|
|---|
| 148 | = (difference_in_years * 365
|
|---|
| 149 | + (intervening_leap_days + difference_in_day_of_year));
|
|---|
| 150 | return (((((difference_in_days * 24
|
|---|
| 151 | + (a->tm_hour - b->tm_hour))
|
|---|
| 152 | * 60)
|
|---|
| 153 | + (a->tm_min - b->tm_min))
|
|---|
| 154 | * 60)
|
|---|
| 155 | + (a->tm_sec - b->tm_sec));
|
|---|
| 156 | }
|
|---|
| 157 |
|
|---|
| 158 | /* Adjust time T by adding SECONDS.
|
|---|
| 159 | The absolute value of SECONDS cannot exceed 59 * INT_MAX,
|
|---|
| 160 | and also cannot exceed one month's worth of seconds;
|
|---|
| 161 | this is enough to handle any POSIX or real-life daylight-saving offset.
|
|---|
| 162 | Adjust only T's year, mon, mday, hour, min and sec members;
|
|---|
| 163 | plus adjust wday if it is defined. */
|
|---|
| 164 | void
|
|---|
| 165 | adjzone (t, seconds)
|
|---|
| 166 | register struct tm *t;
|
|---|
| 167 | long seconds;
|
|---|
| 168 | {
|
|---|
| 169 | int days = 0;
|
|---|
| 170 |
|
|---|
| 171 | /* This code can be off by a second if SECONDS is not a multiple of 60,
|
|---|
| 172 | if T is local time, and if a leap second happens during this minute.
|
|---|
| 173 | But this bug has never occurred, and most likely will not ever occur.
|
|---|
| 174 | Liberia, the last country for which SECONDS % 60 was nonzero,
|
|---|
| 175 | switched to UTC in May 1972; the first leap second was in June 1972. */
|
|---|
| 176 | int leap_second = t->tm_sec == 60;
|
|---|
| 177 | long sec = seconds + (t->tm_sec - leap_second);
|
|---|
| 178 | if (sec < 0)
|
|---|
| 179 | {
|
|---|
| 180 | if ((t->tm_min -= (59 - sec) / 60) < 0
|
|---|
| 181 | && (t->tm_hour -= (59 - t->tm_min) / 60) < 0)
|
|---|
| 182 | {
|
|---|
| 183 | days = - ((23 - t->tm_hour) / 24);
|
|---|
| 184 | if ((t->tm_mday += days) <= 0)
|
|---|
| 185 | {
|
|---|
| 186 | if (--t->tm_mon < 0)
|
|---|
| 187 | {
|
|---|
| 188 | --t->tm_year;
|
|---|
| 189 | t->tm_mon = 11;
|
|---|
| 190 | }
|
|---|
| 191 | t->tm_mday += month_days (t);
|
|---|
| 192 | }
|
|---|
| 193 | }
|
|---|
| 194 | }
|
|---|
| 195 | else
|
|---|
| 196 | {
|
|---|
| 197 | if (60 <= (t->tm_min += sec / 60)
|
|---|
| 198 | && (24 <= (t->tm_hour += t->tm_min / 60)))
|
|---|
| 199 | {
|
|---|
| 200 | days = t->tm_hour / 24;
|
|---|
| 201 | if (month_days (t) < (t->tm_mday += days))
|
|---|
| 202 | {
|
|---|
| 203 | if (11 < ++t->tm_mon)
|
|---|
| 204 | {
|
|---|
| 205 | ++t->tm_year;
|
|---|
| 206 | t->tm_mon = 0;
|
|---|
| 207 | }
|
|---|
| 208 | t->tm_mday = 1;
|
|---|
| 209 | }
|
|---|
| 210 | }
|
|---|
| 211 | }
|
|---|
| 212 | if (TM_DEFINED (t->tm_wday))
|
|---|
| 213 | t->tm_wday = MOD (t->tm_wday + days, 7);
|
|---|
| 214 | t->tm_hour = MOD (t->tm_hour, 24);
|
|---|
| 215 | t->tm_min = MOD (t->tm_min, 60);
|
|---|
| 216 | t->tm_sec = (int) MOD (sec, 60) + leap_second;
|
|---|
| 217 | }
|
|---|
| 218 |
|
|---|
| 219 | /* Convert TM to time_t, using localtime if LOCALZONE and gmtime otherwise.
|
|---|
| 220 | Use only TM's year, mon, mday, hour, min, and sec members.
|
|---|
| 221 | Ignore TM's old tm_yday and tm_wday, but fill in their correct values.
|
|---|
| 222 | Yield -1 on failure (e.g. a member out of range).
|
|---|
| 223 | POSIX 1003.1 doesn't allow leap seconds, but some implementations
|
|---|
| 224 | have them anyway, so allow them if localtime/gmtime does. */
|
|---|
| 225 | time_t
|
|---|
| 226 | tm2time (tm, localzone)
|
|---|
| 227 | struct tm *tm;
|
|---|
| 228 | int localzone;
|
|---|
| 229 | {
|
|---|
| 230 | /* Cache the most recent t,tm pairs; 1 for gmtime, 1 for localtime. */
|
|---|
| 231 | static time_t t_cache[2];
|
|---|
| 232 | static struct tm tm_cache[2];
|
|---|
| 233 |
|
|---|
| 234 | time_t d, gt;
|
|---|
| 235 | struct tm const *gtm;
|
|---|
| 236 | /* The maximum number of iterations should be enough to handle any
|
|---|
| 237 | combinations of leap seconds, time zone rule changes, and solar time.
|
|---|
| 238 | 4 is probably enough; we use a bigger number just to be safe. */
|
|---|
| 239 | int remaining_tries = 8;
|
|---|
| 240 |
|
|---|
| 241 | /* Avoid subscript errors. */
|
|---|
| 242 | if (12 <= (unsigned) tm->tm_mon)
|
|---|
| 243 | return -1;
|
|---|
| 244 |
|
|---|
| 245 | tm->tm_yday = month_yday[tm->tm_mon] + tm->tm_mday
|
|---|
| 246 | - (tm->tm_mon < 2 || !isleap (tm->tm_year + TM_YEAR_ORIGIN));
|
|---|
| 247 |
|
|---|
| 248 | /* Make a first guess. */
|
|---|
| 249 | gt = t_cache[localzone];
|
|---|
| 250 | gtm = gt ? &tm_cache[localzone] : time2tm (gt, localzone);
|
|---|
| 251 |
|
|---|
| 252 | /* Repeatedly use the error from the guess to improve the guess. */
|
|---|
| 253 | while ((d = difftm (tm, gtm)) != 0)
|
|---|
| 254 | {
|
|---|
| 255 | if (--remaining_tries == 0)
|
|---|
| 256 | return -1;
|
|---|
| 257 | gt += d;
|
|---|
| 258 | gtm = time2tm (gt, localzone);
|
|---|
| 259 | }
|
|---|
| 260 |
|
|---|
| 261 | /* Check that the guess actually matches;
|
|---|
| 262 | overflow can cause difftm to yield 0 even on differing times,
|
|---|
| 263 | or tm may have members out of range (e.g. bad leap seconds). */
|
|---|
| 264 | #define TM_DIFFER(a,b) \
|
|---|
| 265 | ( \
|
|---|
| 266 | ((a)->tm_year ^ (b)->tm_year) | \
|
|---|
| 267 | ((a)->tm_mon ^ (b)->tm_mon) | \
|
|---|
| 268 | ((a)->tm_mday ^ (b)->tm_mday) | \
|
|---|
| 269 | ((a)->tm_hour ^ (b)->tm_hour) | \
|
|---|
| 270 | ((a)->tm_min ^ (b)->tm_min) | \
|
|---|
| 271 | ((a)->tm_sec ^ (b)->tm_sec) \
|
|---|
| 272 | )
|
|---|
| 273 | if (TM_DIFFER (tm, gtm))
|
|---|
| 274 | {
|
|---|
| 275 | /* If gt is a leap second, try gt+1; if it is one greater than
|
|---|
| 276 | a leap second, try gt-1; otherwise, it doesn't matter.
|
|---|
| 277 | Leap seconds always fall at month end. */
|
|---|
| 278 | int yd = tm->tm_year - gtm->tm_year;
|
|---|
| 279 | gt += yd + (yd ? 0 : tm->tm_mon - gtm->tm_mon);
|
|---|
| 280 | gtm = time2tm (gt, localzone);
|
|---|
| 281 | if (TM_DIFFER (tm, gtm))
|
|---|
| 282 | return -1;
|
|---|
| 283 | }
|
|---|
| 284 | t_cache[localzone] = gt;
|
|---|
| 285 | tm_cache[localzone] = *gtm;
|
|---|
| 286 |
|
|---|
| 287 | tm->tm_wday = gtm->tm_wday;
|
|---|
| 288 | return gt;
|
|---|
| 289 | }
|
|---|
| 290 |
|
|---|
| 291 | /* Check *PT and convert it to time_t.
|
|---|
| 292 | If it is incompletely specified, use DEFAULT_TIME to fill it out.
|
|---|
| 293 | Use localtime if PT->zone is the special value TM_LOCAL_ZONE.
|
|---|
| 294 | Yield -1 on failure.
|
|---|
| 295 | ISO 8601 day-of-year and week numbers are not yet supported. */
|
|---|
| 296 | static time_t
|
|---|
| 297 | maketime (pt, default_time)
|
|---|
| 298 | struct partime const *pt;
|
|---|
| 299 | time_t default_time;
|
|---|
| 300 | {
|
|---|
| 301 | int localzone, wday, year;
|
|---|
| 302 | struct tm tm;
|
|---|
| 303 | struct tm *tm0 = 0;
|
|---|
| 304 | time_t r;
|
|---|
| 305 | int use_ordinal_day;
|
|---|
| 306 |
|
|---|
| 307 | tm0 = 0; /* Keep gcc -Wall happy. */
|
|---|
| 308 | localzone = pt->zone == TM_LOCAL_ZONE;
|
|---|
| 309 |
|
|---|
| 310 | tm = pt->tm;
|
|---|
| 311 | year = tm.tm_year;
|
|---|
| 312 | wday = tm.tm_wday;
|
|---|
| 313 | use_ordinal_day = (!TM_DEFINED (tm.tm_mday)
|
|---|
| 314 | && TM_DEFINED (wday) && TM_DEFINED (pt->wday_ordinal));
|
|---|
| 315 |
|
|---|
| 316 | if (use_ordinal_day || TM_DEFINED (pt->ymodulus) || !TM_DEFINED (year))
|
|---|
| 317 | {
|
|---|
| 318 | /* Get tm corresponding to default time. */
|
|---|
| 319 | tm0 = time2tm (default_time, localzone);
|
|---|
| 320 | if (!localzone)
|
|---|
| 321 | adjzone (tm0, pt->zone);
|
|---|
| 322 | }
|
|---|
| 323 |
|
|---|
| 324 | if (use_ordinal_day)
|
|---|
| 325 | tm.tm_mday = (tm0->tm_mday
|
|---|
| 326 | + ((wday - tm0->tm_wday + 7) % 7
|
|---|
| 327 | + 7 * (pt->wday_ordinal - (pt->wday_ordinal != 0))));
|
|---|
| 328 |
|
|---|
| 329 | if (TM_DEFINED (pt->ymodulus))
|
|---|
| 330 | {
|
|---|
| 331 | /* Yield a year closest to the default that has the given modulus. */
|
|---|
| 332 | int year0 = tm0->tm_year + TM_YEAR_ORIGIN;
|
|---|
| 333 | int y0 = MOD (year0, pt->ymodulus);
|
|---|
| 334 | int d = 2 * (year - y0);
|
|---|
| 335 | year += (((year0 - y0) / pt->ymodulus
|
|---|
| 336 | + (pt->ymodulus < d ? -1 : d < -pt->ymodulus))
|
|---|
| 337 | * pt->ymodulus);
|
|---|
| 338 | }
|
|---|
| 339 | else if (!TM_DEFINED (year))
|
|---|
| 340 | {
|
|---|
| 341 | /* Set default year, month, day from current time. */
|
|---|
| 342 | year = tm0->tm_year + TM_YEAR_ORIGIN;
|
|---|
| 343 | if (!TM_DEFINED (tm.tm_mon))
|
|---|
| 344 | {
|
|---|
| 345 | tm.tm_mon = tm0->tm_mon;
|
|---|
| 346 | if (!TM_DEFINED (tm.tm_mday))
|
|---|
| 347 | tm.tm_mday = tm0->tm_mday;
|
|---|
| 348 | }
|
|---|
| 349 | }
|
|---|
| 350 |
|
|---|
| 351 | /* Set remaining default fields to be their minimum values. */
|
|---|
| 352 | if (!TM_DEFINED (tm.tm_mon))
|
|---|
| 353 | tm.tm_mon = 0;
|
|---|
| 354 | if (!TM_DEFINED (tm.tm_mday))
|
|---|
| 355 | tm.tm_mday = 1;
|
|---|
| 356 | if (!TM_DEFINED (tm.tm_hour))
|
|---|
| 357 | tm.tm_hour = 0;
|
|---|
| 358 | if (!TM_DEFINED (tm.tm_min))
|
|---|
| 359 | tm.tm_min = 0;
|
|---|
| 360 | if (!TM_DEFINED (tm.tm_sec))
|
|---|
| 361 | tm.tm_sec = 0;
|
|---|
| 362 |
|
|---|
| 363 | tm.tm_year = year - TM_YEAR_ORIGIN;
|
|---|
| 364 | if ((year < tm.tm_year) != (TM_YEAR_ORIGIN < 0))
|
|---|
| 365 | return -1;
|
|---|
| 366 |
|
|---|
| 367 | if (!localzone)
|
|---|
| 368 | {
|
|---|
| 369 | adjzone (&tm, -pt->zone);
|
|---|
| 370 | wday = tm.tm_wday;
|
|---|
| 371 | }
|
|---|
| 372 |
|
|---|
| 373 | /* Convert and fill in the rest of the tm. */
|
|---|
| 374 | r = tm2time (&tm, localzone);
|
|---|
| 375 | if (r == -1)
|
|---|
| 376 | return r;
|
|---|
| 377 |
|
|---|
| 378 | /* Check weekday. */
|
|---|
| 379 | if (TM_DEFINED (wday) && wday != tm.tm_wday)
|
|---|
| 380 | return -1;
|
|---|
| 381 |
|
|---|
| 382 | /* Add relative time, except for seconds.
|
|---|
| 383 | We handle seconds separately, at the end,
|
|---|
| 384 | so that leap seconds are handled properly. */
|
|---|
| 385 | if (pt->tmr.tm_year | pt->tmr.tm_mon | pt->tmr.tm_mday
|
|---|
| 386 | | pt->tmr.tm_hour | pt->tmr.tm_min)
|
|---|
| 387 | {
|
|---|
| 388 | int years = tm.tm_year + pt->tmr.tm_year;
|
|---|
| 389 | int mons = tm.tm_mon + pt->tmr.tm_mon;
|
|---|
| 390 | int mdays = tm.tm_mday + pt->tmr.tm_mday;
|
|---|
| 391 | int hours = tm.tm_hour + pt->tmr.tm_hour;
|
|---|
| 392 | int mins = tm.tm_min + pt->tmr.tm_min;
|
|---|
| 393 |
|
|---|
| 394 | int carried_hours = DIV (mins, 60);
|
|---|
| 395 | int hours1 = hours + carried_hours;
|
|---|
| 396 | int carried_days = DIV (hours1, 24);
|
|---|
| 397 | int mdays1 = mdays + carried_days;
|
|---|
| 398 |
|
|---|
| 399 | int mon0 = MOD (mons, 12);
|
|---|
| 400 | int carried_years0 = DIV (mons, 12);
|
|---|
| 401 | int year0 = years + carried_years0;
|
|---|
| 402 | int yday0 = (month_yday[mon0]
|
|---|
| 403 | - (mon0 < 2 || !isleap (year0 + TM_YEAR_ORIGIN)));
|
|---|
| 404 |
|
|---|
| 405 | int yday1 = yday0 + mdays1;
|
|---|
| 406 | int carried_years1 = DIV (yday1, Y400_DAYS) * 400;
|
|---|
| 407 | int year1 = year0 + carried_years1;
|
|---|
| 408 | int yday2 = MOD (yday1, Y400_DAYS);
|
|---|
| 409 | int leap;
|
|---|
| 410 |
|
|---|
| 411 | if (overflow_sum_sign (tm.tm_year, pt->tmr.tm_year, years)
|
|---|
| 412 | | overflow_sum_sign (tm.tm_mon, pt->tmr.tm_mon, mons)
|
|---|
| 413 | | overflow_sum_sign (tm.tm_mday, pt->tmr.tm_mday, mdays)
|
|---|
| 414 | | overflow_sum_sign (tm.tm_hour, pt->tmr.tm_hour, hours)
|
|---|
| 415 | | overflow_sum_sign (tm.tm_min, pt->tmr.tm_min, mins)
|
|---|
| 416 | | overflow_sum_sign (hours, carried_hours, hours1)
|
|---|
| 417 | | overflow_sum_sign (mdays, carried_days, mdays1)
|
|---|
| 418 | | overflow_sum_sign (years, carried_years0, year0)
|
|---|
| 419 | | overflow_sum_sign (yday0, mdays1, yday1)
|
|---|
| 420 | | overflow_sum_sign (year0, carried_years1, year1))
|
|---|
| 421 | return -1;
|
|---|
| 422 |
|
|---|
| 423 | for (;;)
|
|---|
| 424 | {
|
|---|
| 425 | int days_per_year = 365 + (leap = isleap (year1 + TM_YEAR_ORIGIN));
|
|---|
| 426 | if (yday2 < days_per_year)
|
|---|
| 427 | break;
|
|---|
| 428 | yday2 -= days_per_year;
|
|---|
| 429 | year1++;
|
|---|
| 430 | }
|
|---|
| 431 |
|
|---|
| 432 | tm.tm_year = year1;
|
|---|
| 433 |
|
|---|
| 434 | {
|
|---|
| 435 | int mon;
|
|---|
| 436 | for (mon = 11;
|
|---|
| 437 | (tm.tm_mday = (yday2 - month_yday[mon] + (mon < 2 || !leap))) <= 0;
|
|---|
| 438 | mon--)
|
|---|
| 439 | continue;
|
|---|
| 440 | tm.tm_mon = mon;
|
|---|
| 441 | }
|
|---|
| 442 |
|
|---|
| 443 | tm.tm_hour = MOD (hours1, 24);
|
|---|
| 444 | tm.tm_min = MOD (mins, 60);
|
|---|
| 445 |
|
|---|
| 446 | r = tm2time (&tm, localzone);
|
|---|
| 447 | if (r == -1)
|
|---|
| 448 | return r;
|
|---|
| 449 | }
|
|---|
| 450 |
|
|---|
| 451 | /* Add the seconds' part of relative time. */
|
|---|
| 452 | {
|
|---|
| 453 | time_t rs = r + pt->tmr.tm_sec;
|
|---|
| 454 | if ((pt->tmr.tm_sec < 0) != (rs < r))
|
|---|
| 455 | return -1;
|
|---|
| 456 | return rs;
|
|---|
| 457 | }
|
|---|
| 458 | }
|
|---|
| 459 |
|
|---|
| 460 | /* Parse a free-format date in *SOURCE, yielding a Unix format time.
|
|---|
| 461 | Update *SOURCE to point to the first character after the date.
|
|---|
| 462 | If *SOURCE is missing some information, take defaults from
|
|---|
| 463 | DEFAULT_TIME and DEFAULT_ZONE. *SOURCE may even be the empty
|
|---|
| 464 | string or an immediately invalid string, in which case the default
|
|---|
| 465 | time and zone is used.
|
|---|
| 466 | Return (time_t) -1 if the time is invalid or cannot be represented. */
|
|---|
| 467 | time_t
|
|---|
| 468 | str2time (source, default_time, default_zone)
|
|---|
| 469 | char const **source;
|
|---|
| 470 | time_t default_time;
|
|---|
| 471 | long default_zone;
|
|---|
| 472 | {
|
|---|
| 473 | struct partime pt;
|
|---|
| 474 |
|
|---|
| 475 | *source = partime (*source, &pt);
|
|---|
| 476 | if (pt.zone == TM_UNDEFINED_ZONE)
|
|---|
| 477 | pt.zone = default_zone;
|
|---|
| 478 | return maketime (&pt, default_time);
|
|---|
| 479 | }
|
|---|
| 480 |
|
|---|
| 481 | #ifdef TEST
|
|---|
| 482 | #include <stdio.h>
|
|---|
| 483 | int
|
|---|
| 484 | main (argc, argv)
|
|---|
| 485 | int argc;
|
|---|
| 486 | char **argv;
|
|---|
| 487 | {
|
|---|
| 488 | time_t default_time = time ((time_t *) 0);
|
|---|
| 489 | long default_zone = argv[1] ? atol (argv[1]) : TM_LOCAL_ZONE;
|
|---|
| 490 | char buf[1000];
|
|---|
| 491 | while (fgets (buf, sizeof (buf), stdin))
|
|---|
| 492 | {
|
|---|
| 493 | char const *p = buf;
|
|---|
| 494 | time_t t = str2time (&p, default_time, default_zone);
|
|---|
| 495 | printf ("`%.*s' -> %s",
|
|---|
| 496 | (int) (p - buf - (p[0] == '\0' && p[-1] == '\n')), buf,
|
|---|
| 497 | asctime ((argv[1] ? gmtime : localtime) (&t)));
|
|---|
| 498 | }
|
|---|
| 499 | return 0;
|
|---|
| 500 | }
|
|---|
| 501 | #endif
|
|---|
