]>
Commit | Line | Data |
---|---|---|
0afcb29d JM |
1 | /* Dump time zone data in a textual format. */ |
2 | ||
5fb55a68 UD |
3 | /* |
4 | ** This file is in the public domain, so clarified as of | |
5 | ** 2009-05-17 by Arthur David Olson. | |
6 | */ | |
7 | ||
92e4b6a9 | 8 | #include "version.h" |
28f540f4 | 9 | |
670a687d PE |
10 | #ifndef NETBSD_INSPIRED |
11 | # define NETBSD_INSPIRED 1 | |
12 | #endif | |
670a687d | 13 | |
92bd70fb | 14 | #include "private.h" |
0afcb29d JM |
15 | #include <stdio.h> |
16 | ||
17 | #ifndef HAVE_SNPRINTF | |
18 | # define HAVE_SNPRINTF (199901 <= __STDC_VERSION__) | |
19 | #endif | |
670a687d PE |
20 | |
21 | #ifndef HAVE_LOCALTIME_R | |
22 | # define HAVE_LOCALTIME_R 1 | |
23 | #endif | |
24 | ||
25 | #ifndef HAVE_LOCALTIME_RZ | |
26 | # ifdef TM_ZONE | |
27 | # define HAVE_LOCALTIME_RZ (NETBSD_INSPIRED && USE_LTZ) | |
28 | # else | |
29 | # define HAVE_LOCALTIME_RZ 0 | |
30 | # endif | |
31 | #endif | |
32 | ||
33 | #ifndef HAVE_TZSET | |
34 | # define HAVE_TZSET 1 | |
35 | #endif | |
85bff96a | 36 | |
792dcd77 UD |
37 | #ifndef ZDUMP_LO_YEAR |
38 | #define ZDUMP_LO_YEAR (-500) | |
39 | #endif /* !defined ZDUMP_LO_YEAR */ | |
40 | ||
41 | #ifndef ZDUMP_HI_YEAR | |
42 | #define ZDUMP_HI_YEAR 2500 | |
43 | #endif /* !defined ZDUMP_HI_YEAR */ | |
28f540f4 RM |
44 | |
45 | #ifndef MAX_STRING_LENGTH | |
46 | #define MAX_STRING_LENGTH 1024 | |
47 | #endif /* !defined MAX_STRING_LENGTH */ | |
48 | ||
792dcd77 UD |
49 | #define SECSPERNYEAR (SECSPERDAY * DAYSPERNYEAR) |
50 | #define SECSPERLYEAR (SECSPERNYEAR + SECSPERDAY) | |
85bff96a JM |
51 | #define SECSPER400YEARS (SECSPERNYEAR * (intmax_t) (300 + 3) \ |
52 | + SECSPERLYEAR * (intmax_t) (100 - 3)) | |
53 | ||
54 | /* | |
55 | ** True if SECSPER400YEARS is known to be representable as an | |
56 | ** intmax_t. It's OK that SECSPER400YEARS_FITS can in theory be false | |
57 | ** even if SECSPER400YEARS is representable, because when that happens | |
58 | ** the code merely runs a bit more slowly, and this slowness doesn't | |
59 | ** occur on any practical platform. | |
60 | */ | |
61 | enum { SECSPER400YEARS_FITS = SECSPERLYEAR <= INTMAX_MAX / 400 }; | |
792dcd77 | 62 | |
daa6fd88 | 63 | #if HAVE_GETTEXT |
92bd70fb | 64 | #include <locale.h> /* for setlocale */ |
daa6fd88 | 65 | #endif /* HAVE_GETTEXT */ |
92777700 | 66 | |
670a687d PE |
67 | #if ! HAVE_LOCALTIME_RZ |
68 | # undef timezone_t | |
69 | # define timezone_t char ** | |
70 | #endif | |
92777700 | 71 | |
92bd70fb | 72 | #if !HAVE_POSIX_DECLS |
1db5b6f4 UD |
73 | extern int getopt(int argc, char * const argv[], |
74 | const char * options); | |
28f540f4 RM |
75 | extern char * optarg; |
76 | extern int optind; | |
92bd70fb | 77 | #endif |
28f540f4 | 78 | |
85bff96a | 79 | /* The minimum and maximum finite time values. */ |
670a687d | 80 | enum { atime_shift = CHAR_BIT * sizeof (time_t) - 2 }; |
92e4b6a9 | 81 | static time_t const absolute_min_time = |
85bff96a | 82 | ((time_t) -1 < 0 |
670a687d PE |
83 | ? (- ((time_t) ~ (time_t) 0 < 0) |
84 | - (((time_t) 1 << atime_shift) - 1 + ((time_t) 1 << atime_shift))) | |
92e4b6a9 JM |
85 | : 0); |
86 | static time_t const absolute_max_time = | |
85bff96a | 87 | ((time_t) -1 < 0 |
670a687d | 88 | ? (((time_t) 1 << atime_shift) - 1 + ((time_t) 1 << atime_shift)) |
85bff96a | 89 | : -1); |
670a687d | 90 | static int longest; |
792dcd77 | 91 | static char * progname; |
670a687d PE |
92 | static bool warned; |
93 | static bool errout; | |
94 | ||
95 | static char const *abbr(struct tm const *); | |
96 | static intmax_t delta(struct tm *, struct tm *) ATTRIBUTE_PURE; | |
97 | static void dumptime(struct tm const *); | |
98 | static time_t hunt(timezone_t, char *, time_t, time_t); | |
99 | static void show(timezone_t, char *, time_t, bool); | |
92bd70fb JM |
100 | static void showtrans(char const *, struct tm const *, time_t, char const *, |
101 | char const *); | |
670a687d PE |
102 | static const char *tformat(void); |
103 | static time_t yeartot(intmax_t) ATTRIBUTE_PURE; | |
104 | ||
105 | /* Unlike <ctype.h>'s isdigit, this also works if c < 0 | c > UCHAR_MAX. */ | |
106 | #define is_digit(c) ((unsigned)(c) - '0' <= 9) | |
107 | ||
108 | /* Is A an alphabetic character in the C locale? */ | |
109 | static bool | |
110 | is_alpha(char a) | |
111 | { | |
112 | switch (a) { | |
113 | default: | |
114 | return false; | |
115 | case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': | |
116 | case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': | |
117 | case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U': | |
118 | case 'V': case 'W': case 'X': case 'Y': case 'Z': | |
119 | case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': | |
120 | case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': | |
121 | case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u': | |
122 | case 'v': case 'w': case 'x': case 'y': case 'z': | |
123 | return true; | |
124 | } | |
125 | } | |
126 | ||
127 | /* Return A + B, exiting if the result would overflow. */ | |
128 | static size_t | |
129 | sumsize(size_t a, size_t b) | |
130 | { | |
131 | size_t sum = a + b; | |
132 | if (sum < a) { | |
133 | fprintf(stderr, "%s: size overflow\n", progname); | |
134 | exit(EXIT_FAILURE); | |
135 | } | |
136 | return sum; | |
137 | } | |
138 | ||
92bd70fb JM |
139 | /* Return a pointer to a newly allocated buffer of size SIZE, exiting |
140 | on failure. SIZE should be nonzero. */ | |
0afcb29d | 141 | static void * ATTRIBUTE_MALLOC |
92bd70fb JM |
142 | xmalloc(size_t size) |
143 | { | |
144 | void *p = malloc(size); | |
145 | if (!p) { | |
146 | perror(progname); | |
147 | exit(EXIT_FAILURE); | |
148 | } | |
149 | return p; | |
150 | } | |
151 | ||
670a687d PE |
152 | #if ! HAVE_TZSET |
153 | # undef tzset | |
154 | # define tzset zdump_tzset | |
155 | static void tzset(void) { } | |
156 | #endif | |
157 | ||
158 | /* Assume gmtime_r works if localtime_r does. | |
159 | A replacement localtime_r is defined below if needed. */ | |
160 | #if ! HAVE_LOCALTIME_R | |
161 | ||
162 | # undef gmtime_r | |
163 | # define gmtime_r zdump_gmtime_r | |
164 | ||
165 | static struct tm * | |
166 | gmtime_r(time_t *tp, struct tm *tmp) | |
167 | { | |
168 | struct tm *r = gmtime(tp); | |
169 | if (r) { | |
170 | *tmp = *r; | |
171 | r = tmp; | |
172 | } | |
173 | return r; | |
174 | } | |
175 | ||
176 | #endif | |
177 | ||
178 | /* Platforms with TM_ZONE don't need tzname, so they can use the | |
179 | faster localtime_rz or localtime_r if available. */ | |
180 | ||
181 | #if defined TM_ZONE && HAVE_LOCALTIME_RZ | |
182 | # define USE_LOCALTIME_RZ true | |
183 | #else | |
184 | # define USE_LOCALTIME_RZ false | |
185 | #endif | |
792dcd77 | 186 | |
670a687d PE |
187 | #if ! USE_LOCALTIME_RZ |
188 | ||
189 | # if !defined TM_ZONE || ! HAVE_LOCALTIME_R || ! HAVE_TZSET | |
190 | # undef localtime_r | |
191 | # define localtime_r zdump_localtime_r | |
192 | static struct tm * | |
193 | localtime_r(time_t *tp, struct tm *tmp) | |
194 | { | |
195 | struct tm *r = localtime(tp); | |
196 | if (r) { | |
197 | *tmp = *r; | |
198 | r = tmp; | |
199 | } | |
200 | return r; | |
201 | } | |
202 | # endif | |
203 | ||
204 | # undef localtime_rz | |
205 | # define localtime_rz zdump_localtime_rz | |
206 | static struct tm * | |
207 | localtime_rz(timezone_t rz, time_t *tp, struct tm *tmp) | |
208 | { | |
209 | return localtime_r(tp, tmp); | |
210 | } | |
211 | ||
212 | # ifdef TYPECHECK | |
213 | # undef mktime_z | |
214 | # define mktime_z zdump_mktime_z | |
215 | static time_t | |
216 | mktime_z(timezone_t tz, struct tm *tmp) | |
217 | { | |
218 | return mktime(tmp); | |
219 | } | |
220 | # endif | |
221 | ||
222 | # undef tzalloc | |
223 | # undef tzfree | |
224 | # define tzalloc zdump_tzalloc | |
225 | # define tzfree zdump_tzfree | |
226 | ||
227 | static timezone_t | |
228 | tzalloc(char const *val) | |
229 | { | |
230 | static char **fakeenv; | |
231 | char **env = fakeenv; | |
232 | char *env0; | |
233 | if (! env) { | |
234 | char **e = environ; | |
235 | int to; | |
236 | ||
237 | while (*e++) | |
238 | continue; | |
92bd70fb JM |
239 | env = xmalloc(sumsize(sizeof *environ, |
240 | (e - environ) * sizeof *environ)); | |
670a687d PE |
241 | to = 1; |
242 | for (e = environ; (env[to] = *e); e++) | |
243 | to += strncmp(*e, "TZ=", 3) != 0; | |
244 | } | |
92bd70fb | 245 | env0 = xmalloc(sumsize(sizeof "TZ=", strlen(val))); |
670a687d PE |
246 | env[0] = strcat(strcpy(env0, "TZ="), val); |
247 | environ = fakeenv = env; | |
248 | tzset(); | |
249 | return env; | |
250 | } | |
251 | ||
252 | static void | |
253 | tzfree(timezone_t env) | |
254 | { | |
255 | environ = env + 1; | |
256 | free(env[0]); | |
257 | } | |
258 | #endif /* ! USE_LOCALTIME_RZ */ | |
259 | ||
0afcb29d | 260 | /* A UT time zone, and its initializer. */ |
670a687d PE |
261 | static timezone_t gmtz; |
262 | static void | |
263 | gmtzinit(void) | |
264 | { | |
265 | if (USE_LOCALTIME_RZ) { | |
266 | static char const utc[] = "UTC0"; | |
267 | gmtz = tzalloc(utc); | |
268 | if (!gmtz) { | |
269 | perror(utc); | |
270 | exit(EXIT_FAILURE); | |
271 | } | |
272 | } | |
273 | } | |
274 | ||
0afcb29d | 275 | /* Convert *TP to UT, storing the broken-down time into *TMP. |
670a687d PE |
276 | Return TMP if successful, NULL otherwise. This is like gmtime_r(TP, TMP), |
277 | except typically faster if USE_LOCALTIME_RZ. */ | |
278 | static struct tm * | |
279 | my_gmtime_r(time_t *tp, struct tm *tmp) | |
280 | { | |
281 | return USE_LOCALTIME_RZ ? localtime_rz(gmtz, tp, tmp) : gmtime_r(tp, tmp); | |
282 | } | |
792dcd77 UD |
283 | |
284 | #ifndef TYPECHECK | |
670a687d | 285 | # define my_localtime_rz localtime_rz |
792dcd77 | 286 | #else /* !defined TYPECHECK */ |
670a687d | 287 | |
792dcd77 | 288 | static struct tm * |
670a687d | 289 | my_localtime_rz(timezone_t tz, time_t *tp, struct tm *tmp) |
792dcd77 | 290 | { |
670a687d PE |
291 | tmp = localtime_rz(tz, tp, tmp); |
292 | if (tmp) { | |
792dcd77 UD |
293 | struct tm tm; |
294 | register time_t t; | |
295 | ||
296 | tm = *tmp; | |
670a687d | 297 | t = mktime_z(tz, &tm); |
85bff96a | 298 | if (t != *tp) { |
670a687d PE |
299 | fflush(stdout); |
300 | fprintf(stderr, "\n%s: ", progname); | |
301 | fprintf(stderr, tformat(), *tp); | |
302 | fprintf(stderr, " ->"); | |
303 | fprintf(stderr, " year=%d", tmp->tm_year); | |
304 | fprintf(stderr, " mon=%d", tmp->tm_mon); | |
305 | fprintf(stderr, " mday=%d", tmp->tm_mday); | |
306 | fprintf(stderr, " hour=%d", tmp->tm_hour); | |
307 | fprintf(stderr, " min=%d", tmp->tm_min); | |
308 | fprintf(stderr, " sec=%d", tmp->tm_sec); | |
309 | fprintf(stderr, " isdst=%d", tmp->tm_isdst); | |
310 | fprintf(stderr, " -> "); | |
311 | fprintf(stderr, tformat(), t); | |
312 | fprintf(stderr, "\n"); | |
313 | errout = true; | |
792dcd77 UD |
314 | } |
315 | } | |
316 | return tmp; | |
317 | } | |
318 | #endif /* !defined TYPECHECK */ | |
28f540f4 | 319 | |
c872f5cc | 320 | static void |
92e4b6a9 | 321 | abbrok(const char *const abbrp, const char *const zone) |
c872f5cc | 322 | { |
c872f5cc | 323 | register const char * cp; |
92e4b6a9 | 324 | register const char * wp; |
c872f5cc UD |
325 | |
326 | if (warned) | |
327 | return; | |
53751fd5 | 328 | cp = abbrp; |
670a687d | 329 | while (is_alpha(*cp) || is_digit(*cp) || *cp == '-' || *cp == '+') |
c872f5cc | 330 | ++cp; |
670a687d PE |
331 | if (cp - abbrp < 3) |
332 | wp = _("has fewer than 3 characters"); | |
53751fd5 | 333 | else if (cp - abbrp > 6) |
670a687d PE |
334 | wp = _("has more than 6 characters"); |
335 | else if (*cp) | |
336 | wp = _("has characters other than ASCII alphanumerics, '-' or '+'"); | |
337 | else | |
338 | return; | |
339 | fflush(stdout); | |
340 | fprintf(stderr, | |
53751fd5 RM |
341 | _("%s: warning: zone \"%s\" abbreviation \"%s\" %s\n"), |
342 | progname, zone, abbrp, wp); | |
670a687d PE |
343 | warned = errout = true; |
344 | } | |
345 | ||
346 | /* Return a time zone abbreviation. If the abbreviation needs to be | |
347 | saved, use *BUF (of size *BUFALLOC) to save it, and return the | |
348 | abbreviation in the possibly-reallocated *BUF. Otherwise, just | |
349 | return the abbreviation. Get the abbreviation from TMP. | |
350 | Exit on memory allocation failure. */ | |
351 | static char const * | |
352 | saveabbr(char **buf, size_t *bufalloc, struct tm const *tmp) | |
353 | { | |
354 | char const *ab = abbr(tmp); | |
355 | if (HAVE_LOCALTIME_RZ) | |
356 | return ab; | |
357 | else { | |
358 | size_t ablen = strlen(ab); | |
359 | if (*bufalloc <= ablen) { | |
360 | free(*buf); | |
361 | ||
362 | /* Make the new buffer at least twice as long as the old, | |
363 | to avoid O(N**2) behavior on repeated calls. */ | |
364 | *bufalloc = sumsize(*bufalloc, ablen + 1); | |
365 | ||
92bd70fb | 366 | *buf = xmalloc(*bufalloc); |
670a687d PE |
367 | } |
368 | return strcpy(*buf, ab); | |
369 | } | |
370 | } | |
371 | ||
372 | static void | |
373 | close_file(FILE *stream) | |
374 | { | |
375 | char const *e = (ferror(stream) ? _("I/O error") | |
376 | : fclose(stream) != 0 ? strerror(errno) : NULL); | |
377 | if (e) { | |
378 | fprintf(stderr, "%s: %s\n", progname, e); | |
379 | exit(EXIT_FAILURE); | |
380 | } | |
c872f5cc UD |
381 | } |
382 | ||
5fb55a68 | 383 | static void |
92e4b6a9 | 384 | usage(FILE * const stream, const int status) |
5fb55a68 | 385 | { |
670a687d | 386 | fprintf(stream, |
0afcb29d | 387 | _("%s: usage: %s OPTIONS TIMEZONE ...\n" |
92bd70fb JM |
388 | "Options include:\n" |
389 | " -c [L,]U Start at year L (default -500), end before year U (default 2500)\n" | |
390 | " -t [L,]U Start at time L, end before time U (in seconds since 1970)\n" | |
391 | " -i List transitions briefly (format is experimental)\n" \ | |
392 | " -v List transitions verbosely\n" | |
393 | " -V List transitions a bit less verbosely\n" | |
394 | " --help Output this help\n" | |
395 | " --version Output version info\n" | |
85bff96a JM |
396 | "\n" |
397 | "Report bugs to %s.\n"), | |
92bd70fb | 398 | progname, progname, REPORT_BUGS_TO); |
670a687d PE |
399 | if (status == EXIT_SUCCESS) |
400 | close_file(stream); | |
5fb55a68 UD |
401 | exit(status); |
402 | } | |
403 | ||
28f540f4 | 404 | int |
92e4b6a9 | 405 | main(int argc, char *argv[]) |
28f540f4 | 406 | { |
670a687d PE |
407 | /* These are static so that they're initially zero. */ |
408 | static char * abbrev; | |
409 | static size_t abbrevsize; | |
670a687d | 410 | |
6c2f0507 | 411 | register int i; |
670a687d PE |
412 | register bool vflag; |
413 | register bool Vflag; | |
792dcd77 | 414 | register char * cutarg; |
85bff96a | 415 | register char * cuttimes; |
792dcd77 UD |
416 | register time_t cutlotime; |
417 | register time_t cuthitime; | |
28f540f4 | 418 | time_t now; |
92bd70fb | 419 | bool iflag = false; |
28f540f4 | 420 | |
85bff96a JM |
421 | cutlotime = absolute_min_time; |
422 | cuthitime = absolute_max_time; | |
daa6fd88 | 423 | #if HAVE_GETTEXT |
670a687d | 424 | setlocale(LC_ALL, ""); |
92777700 | 425 | #ifdef TZ_DOMAINDIR |
670a687d | 426 | bindtextdomain(TZ_DOMAIN, TZ_DOMAINDIR); |
daa6fd88 | 427 | #endif /* defined TEXTDOMAINDIR */ |
670a687d | 428 | textdomain(TZ_DOMAIN); |
daa6fd88 | 429 | #endif /* HAVE_GETTEXT */ |
28f540f4 | 430 | progname = argv[0]; |
c0df57e1 UD |
431 | for (i = 1; i < argc; ++i) |
432 | if (strcmp(argv[i], "--version") == 0) { | |
670a687d PE |
433 | printf("zdump %s%s\n", PKGVERSION, TZVERSION); |
434 | return EXIT_SUCCESS; | |
5fb55a68 | 435 | } else if (strcmp(argv[i], "--help") == 0) { |
35d76d59 | 436 | usage(stdout, EXIT_SUCCESS); |
c0df57e1 | 437 | } |
670a687d | 438 | vflag = Vflag = false; |
85bff96a JM |
439 | cutarg = cuttimes = NULL; |
440 | for (;;) | |
92bd70fb | 441 | switch (getopt(argc, argv, "c:it:vV")) { |
85bff96a JM |
442 | case 'c': cutarg = optarg; break; |
443 | case 't': cuttimes = optarg; break; | |
92bd70fb | 444 | case 'i': iflag = true; break; |
670a687d PE |
445 | case 'v': vflag = true; break; |
446 | case 'V': Vflag = true; break; | |
85bff96a JM |
447 | case -1: |
448 | if (! (optind == argc - 1 && strcmp(argv[optind], "=") == 0)) | |
449 | goto arg_processing_done; | |
450 | /* Fall through. */ | |
451 | default: | |
452 | usage(stderr, EXIT_FAILURE); | |
453 | } | |
454 | arg_processing_done:; | |
455 | ||
92bd70fb | 456 | if (iflag | vflag | Vflag) { |
85bff96a JM |
457 | intmax_t lo; |
458 | intmax_t hi; | |
459 | char *loend, *hiend; | |
460 | register intmax_t cutloyear = ZDUMP_LO_YEAR; | |
461 | register intmax_t cuthiyear = ZDUMP_HI_YEAR; | |
792dcd77 | 462 | if (cutarg != NULL) { |
85bff96a JM |
463 | lo = strtoimax(cutarg, &loend, 10); |
464 | if (cutarg != loend && !*loend) { | |
465 | hi = lo; | |
466 | cuthiyear = hi; | |
467 | } else if (cutarg != loend && *loend == ',' | |
468 | && (hi = strtoimax(loend + 1, &hiend, 10), | |
469 | loend + 1 != hiend && !*hiend)) { | |
470 | cutloyear = lo; | |
792dcd77 | 471 | cuthiyear = hi; |
792dcd77 | 472 | } else { |
670a687d | 473 | fprintf(stderr, _("%s: wild -c argument %s\n"), |
792dcd77 | 474 | progname, cutarg); |
670a687d | 475 | return EXIT_FAILURE; |
792dcd77 UD |
476 | } |
477 | } | |
85bff96a JM |
478 | if (cutarg != NULL || cuttimes == NULL) { |
479 | cutlotime = yeartot(cutloyear); | |
480 | cuthitime = yeartot(cuthiyear); | |
481 | } | |
482 | if (cuttimes != NULL) { | |
483 | lo = strtoimax(cuttimes, &loend, 10); | |
484 | if (cuttimes != loend && !*loend) { | |
485 | hi = lo; | |
486 | if (hi < cuthitime) { | |
487 | if (hi < absolute_min_time) | |
488 | hi = absolute_min_time; | |
489 | cuthitime = hi; | |
490 | } | |
491 | } else if (cuttimes != loend && *loend == ',' | |
492 | && (hi = strtoimax(loend + 1, &hiend, 10), | |
493 | loend + 1 != hiend && !*hiend)) { | |
494 | if (cutlotime < lo) { | |
495 | if (absolute_max_time < lo) | |
496 | lo = absolute_max_time; | |
497 | cutlotime = lo; | |
498 | } | |
499 | if (hi < cuthitime) { | |
500 | if (hi < absolute_min_time) | |
501 | hi = absolute_min_time; | |
502 | cuthitime = hi; | |
503 | } | |
504 | } else { | |
670a687d | 505 | fprintf(stderr, |
85bff96a JM |
506 | _("%s: wild -t argument %s\n"), |
507 | progname, cuttimes); | |
670a687d | 508 | return EXIT_FAILURE; |
85bff96a JM |
509 | } |
510 | } | |
28f540f4 | 511 | } |
670a687d | 512 | gmtzinit(); |
92bd70fb JM |
513 | INITIALIZE (now); |
514 | if (! (iflag | vflag | Vflag)) | |
515 | now = time(NULL); | |
28f540f4 | 516 | longest = 0; |
670a687d PE |
517 | for (i = optind; i < argc; i++) { |
518 | size_t arglen = strlen(argv[i]); | |
519 | if (longest < arglen) | |
520 | longest = arglen < INT_MAX ? arglen : INT_MAX; | |
28f540f4 | 521 | } |
28f540f4 | 522 | |
670a687d PE |
523 | for (i = optind; i < argc; ++i) { |
524 | timezone_t tz = tzalloc(argv[i]); | |
525 | char const *ab; | |
92bd70fb JM |
526 | time_t t; |
527 | struct tm tm, newtm; | |
528 | bool tm_ok; | |
670a687d PE |
529 | if (!tz) { |
530 | perror(argv[i]); | |
531 | return EXIT_FAILURE; | |
532 | } | |
92bd70fb | 533 | if (! (iflag | vflag | Vflag)) { |
670a687d PE |
534 | show(tz, argv[i], now, false); |
535 | tzfree(tz); | |
28f540f4 | 536 | continue; |
dfe1754a | 537 | } |
670a687d | 538 | warned = false; |
792dcd77 | 539 | t = absolute_min_time; |
92bd70fb | 540 | if (! (iflag | Vflag)) { |
670a687d | 541 | show(tz, argv[i], t, true); |
85bff96a | 542 | t += SECSPERDAY; |
670a687d | 543 | show(tz, argv[i], t, true); |
85bff96a | 544 | } |
792dcd77 UD |
545 | if (t < cutlotime) |
546 | t = cutlotime; | |
0afcb29d | 547 | INITIALIZE (ab); |
92bd70fb JM |
548 | tm_ok = my_localtime_rz(tz, &t, &tm) != NULL; |
549 | if (tm_ok) { | |
670a687d | 550 | ab = saveabbr(&abbrev, &abbrevsize, &tm); |
92bd70fb JM |
551 | if (iflag) { |
552 | showtrans("\nTZ=%f", &tm, t, ab, argv[i]); | |
553 | showtrans("-\t-\t%Q", &tm, t, ab, argv[i]); | |
554 | } | |
555 | } | |
670a687d | 556 | while (t < cuthitime) { |
92bd70fb JM |
557 | time_t newt = ((t < absolute_max_time - SECSPERDAY / 2 |
558 | && t + SECSPERDAY / 2 < cuthitime) | |
559 | ? t + SECSPERDAY / 2 | |
560 | : cuthitime); | |
561 | struct tm *newtmp = localtime_rz(tz, &newt, &newtm); | |
562 | bool newtm_ok = newtmp != NULL; | |
0afcb29d JM |
563 | if (tm_ok != newtm_ok |
564 | || (tm_ok && (delta(&newtm, &tm) != newt - t | |
565 | || newtm.tm_isdst != tm.tm_isdst | |
566 | || strcmp(abbr(&newtm), ab) != 0))) { | |
92bd70fb JM |
567 | newt = hunt(tz, argv[i], t, newt); |
568 | newtmp = localtime_rz(tz, &newt, &newtm); | |
569 | newtm_ok = newtmp != NULL; | |
570 | if (iflag) | |
571 | showtrans("%Y-%m-%d\t%L\t%Q", newtmp, newt, | |
572 | newtm_ok ? abbr(&newtm) : NULL, argv[i]); | |
573 | else { | |
574 | show(tz, argv[i], newt - 1, true); | |
575 | show(tz, argv[i], newt, true); | |
576 | } | |
577 | } | |
578 | t = newt; | |
579 | tm_ok = newtm_ok; | |
580 | if (newtm_ok) { | |
581 | ab = saveabbr(&abbrev, &abbrevsize, &newtm); | |
582 | tm = newtm; | |
583 | } | |
28f540f4 | 584 | } |
92bd70fb | 585 | if (! (iflag | Vflag)) { |
85bff96a JM |
586 | t = absolute_max_time; |
587 | t -= SECSPERDAY; | |
670a687d | 588 | show(tz, argv[i], t, true); |
85bff96a | 589 | t += SECSPERDAY; |
670a687d | 590 | show(tz, argv[i], t, true); |
85bff96a | 591 | } |
670a687d | 592 | tzfree(tz); |
28f540f4 | 593 | } |
670a687d PE |
594 | close_file(stdout); |
595 | if (errout && (ferror(stderr) || fclose(stderr) != 0)) | |
596 | return EXIT_FAILURE; | |
597 | return EXIT_SUCCESS; | |
792dcd77 UD |
598 | } |
599 | ||
792dcd77 | 600 | static time_t |
670a687d | 601 | yeartot(intmax_t y) |
792dcd77 | 602 | { |
85bff96a JM |
603 | register intmax_t myy, seconds, years; |
604 | register time_t t; | |
792dcd77 UD |
605 | |
606 | myy = EPOCH_YEAR; | |
607 | t = 0; | |
85bff96a JM |
608 | while (myy < y) { |
609 | if (SECSPER400YEARS_FITS && 400 <= y - myy) { | |
610 | intmax_t diff400 = (y - myy) / 400; | |
611 | if (INTMAX_MAX / SECSPER400YEARS < diff400) | |
612 | return absolute_max_time; | |
613 | seconds = diff400 * SECSPER400YEARS; | |
614 | years = diff400 * 400; | |
615 | } else { | |
792dcd77 | 616 | seconds = isleap(myy) ? SECSPERLYEAR : SECSPERNYEAR; |
85bff96a JM |
617 | years = 1; |
618 | } | |
619 | myy += years; | |
620 | if (t > absolute_max_time - seconds) | |
621 | return absolute_max_time; | |
622 | t += seconds; | |
623 | } | |
624 | while (y < myy) { | |
625 | if (SECSPER400YEARS_FITS && y + 400 <= myy && myy < 0) { | |
626 | intmax_t diff400 = (myy - y) / 400; | |
627 | if (INTMAX_MAX / SECSPER400YEARS < diff400) | |
628 | return absolute_min_time; | |
629 | seconds = diff400 * SECSPER400YEARS; | |
630 | years = diff400 * 400; | |
792dcd77 | 631 | } else { |
85bff96a JM |
632 | seconds = isleap(myy - 1) ? SECSPERLYEAR : SECSPERNYEAR; |
633 | years = 1; | |
792dcd77 | 634 | } |
85bff96a JM |
635 | myy -= years; |
636 | if (t < absolute_min_time + seconds) | |
637 | return absolute_min_time; | |
638 | t -= seconds; | |
792dcd77 UD |
639 | } |
640 | return t; | |
28f540f4 RM |
641 | } |
642 | ||
643 | static time_t | |
670a687d | 644 | hunt(timezone_t tz, char *name, time_t lot, time_t hit) |
28f540f4 | 645 | { |
670a687d PE |
646 | static char * loab; |
647 | static size_t loabsize; | |
648 | char const * ab; | |
792dcd77 | 649 | time_t t; |
792dcd77 | 650 | struct tm lotm; |
792dcd77 | 651 | struct tm tm; |
92bd70fb JM |
652 | bool lotm_ok = my_localtime_rz(tz, &lot, &lotm) != NULL; |
653 | bool tm_ok; | |
792dcd77 | 654 | |
92bd70fb | 655 | if (lotm_ok) |
670a687d | 656 | ab = saveabbr(&loab, &loabsize, &lotm); |
792dcd77 | 657 | for ( ; ; ) { |
85bff96a | 658 | time_t diff = hit - lot; |
792dcd77 UD |
659 | if (diff < 2) |
660 | break; | |
661 | t = lot; | |
662 | t += diff / 2; | |
28f540f4 RM |
663 | if (t <= lot) |
664 | ++t; | |
665 | else if (t >= hit) | |
666 | --t; | |
92bd70fb JM |
667 | tm_ok = my_localtime_rz(tz, &t, &tm) != NULL; |
668 | if (lotm_ok & tm_ok | |
669 | ? (delta(&tm, &lotm) == t - lot | |
670 | && tm.tm_isdst == lotm.tm_isdst | |
671 | && strcmp(abbr(&tm), ab) == 0) | |
672 | : lotm_ok == tm_ok) { | |
673 | lot = t; | |
674 | if (tm_ok) | |
675 | lotm = tm; | |
28f540f4 RM |
676 | } else hit = t; |
677 | } | |
28f540f4 RM |
678 | return hit; |
679 | } | |
680 | ||
681 | /* | |
0afcb29d | 682 | ** Thanks to Paul Eggert for logic used in delta_nonneg. |
28f540f4 RM |
683 | */ |
684 | ||
85bff96a | 685 | static intmax_t |
0afcb29d | 686 | delta_nonneg(struct tm *newp, struct tm *oldp) |
28f540f4 | 687 | { |
85bff96a JM |
688 | register intmax_t result; |
689 | register int tmy; | |
28f540f4 | 690 | |
28f540f4 RM |
691 | result = 0; |
692 | for (tmy = oldp->tm_year; tmy < newp->tm_year; ++tmy) | |
792dcd77 | 693 | result += DAYSPERNYEAR + isleap_sum(tmy, TM_YEAR_BASE); |
28f540f4 RM |
694 | result += newp->tm_yday - oldp->tm_yday; |
695 | result *= HOURSPERDAY; | |
696 | result += newp->tm_hour - oldp->tm_hour; | |
697 | result *= MINSPERHOUR; | |
698 | result += newp->tm_min - oldp->tm_min; | |
699 | result *= SECSPERMIN; | |
700 | result += newp->tm_sec - oldp->tm_sec; | |
701 | return result; | |
702 | } | |
703 | ||
0afcb29d JM |
704 | static intmax_t |
705 | delta(struct tm *newp, struct tm *oldp) | |
706 | { | |
707 | return (newp->tm_year < oldp->tm_year | |
708 | ? -delta_nonneg(oldp, newp) | |
709 | : delta_nonneg(newp, oldp)); | |
710 | } | |
711 | ||
670a687d PE |
712 | #ifndef TM_GMTOFF |
713 | /* Return A->tm_yday, adjusted to compare it fairly to B->tm_yday. | |
714 | Assume A and B differ by at most one year. */ | |
715 | static int | |
716 | adjusted_yday(struct tm const *a, struct tm const *b) | |
717 | { | |
718 | int yday = a->tm_yday; | |
719 | if (b->tm_year < a->tm_year) | |
720 | yday += 365 + isleap_sum(b->tm_year, TM_YEAR_BASE); | |
721 | return yday; | |
722 | } | |
723 | #endif | |
724 | ||
0afcb29d JM |
725 | /* If A is the broken-down local time and B the broken-down UT for |
726 | the same instant, return A's UT offset in seconds, where positive | |
92bd70fb JM |
727 | offsets are east of Greenwich. On failure, return LONG_MIN. |
728 | ||
729 | If T is nonnull, *T is the timestamp that corresponds to A; call | |
730 | my_gmtime_r and use its result instead of B. Otherwise, B is the | |
731 | possibly nonnull result of an earlier call to my_gmtime_r. */ | |
670a687d | 732 | static long |
92bd70fb | 733 | gmtoff(struct tm const *a, time_t *t, struct tm const *b) |
670a687d PE |
734 | { |
735 | #ifdef TM_GMTOFF | |
736 | return a->TM_GMTOFF; | |
737 | #else | |
92bd70fb JM |
738 | struct tm tm; |
739 | if (t) | |
740 | b = my_gmtime_r(t, &tm); | |
670a687d PE |
741 | if (! b) |
742 | return LONG_MIN; | |
743 | else { | |
744 | int ayday = adjusted_yday(a, b); | |
745 | int byday = adjusted_yday(b, a); | |
746 | int days = ayday - byday; | |
747 | long hours = a->tm_hour - b->tm_hour + 24 * days; | |
748 | long minutes = a->tm_min - b->tm_min + 60 * hours; | |
749 | long seconds = a->tm_sec - b->tm_sec + 60 * minutes; | |
750 | return seconds; | |
751 | } | |
752 | #endif | |
753 | } | |
754 | ||
28f540f4 | 755 | static void |
670a687d | 756 | show(timezone_t tz, char *zone, time_t t, bool v) |
28f540f4 | 757 | { |
792dcd77 | 758 | register struct tm * tmp; |
670a687d PE |
759 | register struct tm * gmtmp; |
760 | struct tm tm, gmtm; | |
28f540f4 | 761 | |
670a687d | 762 | printf("%-*s ", longest, zone); |
daa6fd88 | 763 | if (v) { |
670a687d PE |
764 | gmtmp = my_gmtime_r(&t, &gmtm); |
765 | if (gmtmp == NULL) { | |
766 | printf(tformat(), t); | |
792dcd77 | 767 | } else { |
670a687d PE |
768 | dumptime(gmtmp); |
769 | printf(" UT"); | |
792dcd77 | 770 | } |
670a687d | 771 | printf(" = "); |
daa6fd88 | 772 | } |
670a687d | 773 | tmp = my_localtime_rz(tz, &t, &tm); |
daa6fd88 | 774 | dumptime(tmp); |
792dcd77 UD |
775 | if (tmp != NULL) { |
776 | if (*abbr(tmp) != '\0') | |
670a687d | 777 | printf(" %s", abbr(tmp)); |
792dcd77 | 778 | if (v) { |
92bd70fb | 779 | long off = gmtoff(tmp, NULL, gmtmp); |
670a687d PE |
780 | printf(" isdst=%d", tmp->tm_isdst); |
781 | if (off != LONG_MIN) | |
782 | printf(" gmtoff=%ld", off); | |
792dcd77 | 783 | } |
28f540f4 | 784 | } |
670a687d | 785 | printf("\n"); |
c872f5cc UD |
786 | if (tmp != NULL && *abbr(tmp) != '\0') |
787 | abbrok(abbr(tmp), zone); | |
28f540f4 RM |
788 | } |
789 | ||
0afcb29d JM |
790 | #if HAVE_SNPRINTF |
791 | # define my_snprintf snprintf | |
792 | #else | |
793 | # include <stdarg.h> | |
794 | ||
795 | /* A substitute for snprintf that is good enough for zdump. */ | |
796 | static int ATTRIBUTE_FORMAT((printf, 3, 4)) | |
797 | my_snprintf(char *s, size_t size, char const *format, ...) | |
798 | { | |
799 | int n; | |
800 | va_list args; | |
801 | char const *arg; | |
802 | size_t arglen, slen; | |
803 | char buf[1024]; | |
804 | va_start(args, format); | |
805 | if (strcmp(format, "%s") == 0) { | |
806 | arg = va_arg(args, char const *); | |
807 | arglen = strlen(arg); | |
808 | } else { | |
809 | n = vsprintf(buf, format, args); | |
e740e5b1 JM |
810 | if (n < 0) { |
811 | va_end(args); | |
0afcb29d | 812 | return n; |
e740e5b1 | 813 | } |
0afcb29d JM |
814 | arg = buf; |
815 | arglen = n; | |
816 | } | |
817 | slen = arglen < size ? arglen : size - 1; | |
818 | memcpy(s, arg, slen); | |
819 | s[slen] = '\0'; | |
820 | n = arglen <= INT_MAX ? arglen : -1; | |
821 | va_end(args); | |
822 | return n; | |
823 | } | |
824 | #endif | |
825 | ||
92bd70fb JM |
826 | /* Store into BUF, of size SIZE, a formatted local time taken from *TM. |
827 | Use ISO 8601 format +HH:MM:SS. Omit :SS if SS is zero, and omit | |
828 | :MM too if MM is also zero. | |
829 | ||
830 | Return the length of the resulting string. If the string does not | |
831 | fit, return the length that the string would have been if it had | |
832 | fit; do not overrun the output buffer. */ | |
833 | static int | |
834 | format_local_time(char *buf, size_t size, struct tm const *tm) | |
835 | { | |
836 | int ss = tm->tm_sec, mm = tm->tm_min, hh = tm->tm_hour; | |
837 | return (ss | |
0afcb29d | 838 | ? my_snprintf(buf, size, "%02d:%02d:%02d", hh, mm, ss) |
92bd70fb | 839 | : mm |
0afcb29d JM |
840 | ? my_snprintf(buf, size, "%02d:%02d", hh, mm) |
841 | : my_snprintf(buf, size, "%02d", hh)); | |
92bd70fb JM |
842 | } |
843 | ||
0afcb29d | 844 | /* Store into BUF, of size SIZE, a formatted UT offset for the |
92bd70fb JM |
845 | localtime *TM corresponding to time T. Use ISO 8601 format |
846 | +HHMMSS, or -HHMMSS for timestamps west of Greenwich; use the | |
0afcb29d | 847 | format -00 for unknown UT offsets. If the hour needs more than |
92bd70fb JM |
848 | two digits to represent, extend the length of HH as needed. |
849 | Otherwise, omit SS if SS is zero, and omit MM too if MM is also | |
850 | zero. | |
851 | ||
852 | Return the length of the resulting string, or -1 if the result is | |
853 | not representable as a string. If the string does not fit, return | |
854 | the length that the string would have been if it had fit; do not | |
855 | overrun the output buffer. */ | |
856 | static int | |
857 | format_utc_offset(char *buf, size_t size, struct tm const *tm, time_t t) | |
858 | { | |
859 | long off = gmtoff(tm, &t, NULL); | |
860 | char sign = ((off < 0 | |
861 | || (off == 0 | |
862 | && (*abbr(tm) == '-' || strcmp(abbr(tm), "zzz") == 0))) | |
863 | ? '-' : '+'); | |
864 | long hh; | |
865 | int mm, ss; | |
866 | if (off < 0) | |
867 | { | |
868 | if (off == LONG_MIN) | |
869 | return -1; | |
870 | off = -off; | |
871 | } | |
872 | ss = off % 60; | |
873 | mm = off / 60 % 60; | |
874 | hh = off / 60 / 60; | |
875 | return (ss || 100 <= hh | |
0afcb29d | 876 | ? my_snprintf(buf, size, "%c%02ld%02d%02d", sign, hh, mm, ss) |
92bd70fb | 877 | : mm |
0afcb29d JM |
878 | ? my_snprintf(buf, size, "%c%02ld%02d", sign, hh, mm) |
879 | : my_snprintf(buf, size, "%c%02ld", sign, hh)); | |
92bd70fb JM |
880 | } |
881 | ||
882 | /* Store into BUF (of size SIZE) a quoted string representation of P. | |
883 | If the representation's length is less than SIZE, return the | |
884 | length; the representation is not null terminated. Otherwise | |
885 | return SIZE, to indicate that BUF is too small. */ | |
886 | static size_t | |
887 | format_quoted_string(char *buf, size_t size, char const *p) | |
888 | { | |
889 | char *b = buf; | |
890 | size_t s = size; | |
891 | if (!s) | |
892 | return size; | |
893 | *b++ = '"', s--; | |
894 | for (;;) { | |
895 | char c = *p++; | |
896 | if (s <= 1) | |
897 | return size; | |
898 | switch (c) { | |
899 | default: *b++ = c, s--; continue; | |
900 | case '\0': *b++ = '"', s--; return size - s; | |
901 | case '"': case '\\': break; | |
902 | case ' ': c = 's'; break; | |
903 | case '\f': c = 'f'; break; | |
904 | case '\n': c = 'n'; break; | |
905 | case '\r': c = 'r'; break; | |
906 | case '\t': c = 't'; break; | |
907 | case '\v': c = 'v'; break; | |
908 | } | |
909 | *b++ = '\\', *b++ = c, s -= 2; | |
910 | } | |
911 | } | |
912 | ||
913 | /* Store into BUF (of size SIZE) a timestamp formatted by TIME_FMT. | |
914 | TM is the broken-down time, T the seconds count, AB the time zone | |
915 | abbreviation, and ZONE_NAME the zone name. Return true if | |
916 | successful, false if the output would require more than SIZE bytes. | |
917 | TIME_FMT uses the same format that strftime uses, with these | |
918 | additions: | |
919 | ||
920 | %f zone name | |
921 | %L local time as per format_local_time | |
0afcb29d | 922 | %Q like "U\t%Z\tD" where U is the UT offset as for format_utc_offset |
92bd70fb JM |
923 | and D is the isdst flag; except omit D if it is zero, omit %Z if |
924 | it equals U, quote and escape %Z if it contains nonalphabetics, | |
925 | and omit any trailing tabs. */ | |
926 | ||
927 | static bool | |
928 | istrftime(char *buf, size_t size, char const *time_fmt, | |
929 | struct tm const *tm, time_t t, char const *ab, char const *zone_name) | |
930 | { | |
931 | char *b = buf; | |
932 | size_t s = size; | |
933 | char const *f = time_fmt, *p; | |
934 | ||
935 | for (p = f; ; p++) | |
936 | if (*p == '%' && p[1] == '%') | |
937 | p++; | |
938 | else if (!*p | |
939 | || (*p == '%' | |
940 | && (p[1] == 'f' || p[1] == 'L' || p[1] == 'Q'))) { | |
941 | size_t formatted_len; | |
942 | size_t f_prefix_len = p - f; | |
943 | size_t f_prefix_copy_size = p - f + 2; | |
944 | char fbuf[100]; | |
945 | bool oversized = sizeof fbuf <= f_prefix_copy_size; | |
946 | char *f_prefix_copy = oversized ? xmalloc(f_prefix_copy_size) : fbuf; | |
947 | memcpy(f_prefix_copy, f, f_prefix_len); | |
948 | strcpy(f_prefix_copy + f_prefix_len, "X"); | |
949 | formatted_len = strftime(b, s, f_prefix_copy, tm); | |
950 | if (oversized) | |
951 | free(f_prefix_copy); | |
952 | if (formatted_len == 0) | |
953 | return false; | |
954 | formatted_len--; | |
955 | b += formatted_len, s -= formatted_len; | |
956 | if (!*p++) | |
957 | break; | |
958 | switch (*p) { | |
959 | case 'f': | |
960 | formatted_len = format_quoted_string(b, s, zone_name); | |
961 | break; | |
962 | case 'L': | |
963 | formatted_len = format_local_time(b, s, tm); | |
964 | break; | |
965 | case 'Q': | |
966 | { | |
967 | bool show_abbr; | |
968 | int offlen = format_utc_offset(b, s, tm, t); | |
969 | if (! (0 <= offlen && offlen < s)) | |
970 | return false; | |
971 | show_abbr = strcmp(b, ab) != 0; | |
972 | b += offlen, s -= offlen; | |
973 | if (show_abbr) { | |
974 | char const *abp; | |
975 | size_t len; | |
976 | if (s <= 1) | |
977 | return false; | |
978 | *b++ = '\t', s--; | |
979 | for (abp = ab; is_alpha(*abp); abp++) | |
980 | continue; | |
981 | len = (!*abp && *ab | |
0afcb29d | 982 | ? my_snprintf(b, s, "%s", ab) |
92bd70fb JM |
983 | : format_quoted_string(b, s, ab)); |
984 | if (s <= len) | |
985 | return false; | |
986 | b += len, s -= len; | |
987 | } | |
0afcb29d JM |
988 | formatted_len |
989 | = (tm->tm_isdst | |
990 | ? my_snprintf(b, s, &"\t\t%d"[show_abbr], tm->tm_isdst) | |
991 | : 0); | |
92bd70fb JM |
992 | } |
993 | break; | |
994 | } | |
995 | if (s <= formatted_len) | |
996 | return false; | |
997 | b += formatted_len, s -= formatted_len; | |
998 | f = p + 1; | |
999 | } | |
1000 | *b = '\0'; | |
1001 | return true; | |
1002 | } | |
1003 | ||
1004 | /* Show a time transition. */ | |
1005 | static void | |
1006 | showtrans(char const *time_fmt, struct tm const *tm, time_t t, char const *ab, | |
1007 | char const *zone_name) | |
1008 | { | |
1009 | if (!tm) { | |
1010 | printf(tformat(), t); | |
1011 | putchar('\n'); | |
1012 | } else { | |
1013 | char stackbuf[1000]; | |
1014 | size_t size = sizeof stackbuf; | |
1015 | char *buf = stackbuf; | |
1016 | char *bufalloc = NULL; | |
1017 | while (! istrftime(buf, size, time_fmt, tm, t, ab, zone_name)) { | |
1018 | size = sumsize(size, size); | |
1019 | free(bufalloc); | |
1020 | buf = bufalloc = xmalloc(size); | |
1021 | } | |
1022 | puts(buf); | |
1023 | free(bufalloc); | |
1024 | } | |
1025 | } | |
1026 | ||
670a687d PE |
1027 | static char const * |
1028 | abbr(struct tm const *tmp) | |
28f540f4 | 1029 | { |
670a687d PE |
1030 | #ifdef TM_ZONE |
1031 | return tmp->TM_ZONE; | |
1032 | #else | |
0afcb29d JM |
1033 | # if HAVE_TZNAME |
1034 | if (0 <= tmp->tm_isdst && tzname[0 < tmp->tm_isdst]) | |
1035 | return tzname[0 < tmp->tm_isdst]; | |
1036 | # endif | |
1037 | return ""; | |
670a687d | 1038 | #endif |
28f540f4 | 1039 | } |
daa6fd88 | 1040 | |
792dcd77 UD |
1041 | /* |
1042 | ** The code below can fail on certain theoretical systems; | |
1043 | ** it works on all known real-world systems as of 2004-12-30. | |
1044 | */ | |
1045 | ||
1046 | static const char * | |
1db5b6f4 | 1047 | tformat(void) |
792dcd77 | 1048 | { |
792dcd77 | 1049 | if (0 > (time_t) -1) { /* signed */ |
85bff96a JM |
1050 | if (sizeof (time_t) == sizeof (intmax_t)) |
1051 | return "%"PRIdMAX; | |
792dcd77 UD |
1052 | if (sizeof (time_t) > sizeof (long)) |
1053 | return "%lld"; | |
1054 | if (sizeof (time_t) > sizeof (int)) | |
1055 | return "%ld"; | |
1056 | return "%d"; | |
1057 | } | |
85bff96a JM |
1058 | #ifdef PRIuMAX |
1059 | if (sizeof (time_t) == sizeof (uintmax_t)) | |
1060 | return "%"PRIuMAX; | |
1061 | #endif | |
792dcd77 UD |
1062 | if (sizeof (time_t) > sizeof (unsigned long)) |
1063 | return "%llu"; | |
1064 | if (sizeof (time_t) > sizeof (unsigned int)) | |
1065 | return "%lu"; | |
1066 | return "%u"; | |
1067 | } | |
1068 | ||
daa6fd88 | 1069 | static void |
92e4b6a9 | 1070 | dumptime(register const struct tm *timeptr) |
daa6fd88 | 1071 | { |
0afcb29d | 1072 | static const char wday_name[][4] = { |
daa6fd88 UD |
1073 | "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" |
1074 | }; | |
0afcb29d | 1075 | static const char mon_name[][4] = { |
daa6fd88 UD |
1076 | "Jan", "Feb", "Mar", "Apr", "May", "Jun", |
1077 | "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" | |
1078 | }; | |
1079 | register const char * wn; | |
1080 | register const char * mn; | |
792dcd77 UD |
1081 | register int lead; |
1082 | register int trail; | |
daa6fd88 | 1083 | |
792dcd77 | 1084 | if (timeptr == NULL) { |
670a687d | 1085 | printf("NULL"); |
792dcd77 UD |
1086 | return; |
1087 | } | |
daa6fd88 | 1088 | /* |
670a687d | 1089 | ** The packaged localtime_rz and gmtime_r never put out-of-range |
daa6fd88 UD |
1090 | ** values in tm_wday or tm_mon, but since this code might be compiled |
1091 | ** with other (perhaps experimental) versions, paranoia is in order. | |
1092 | */ | |
1093 | if (timeptr->tm_wday < 0 || timeptr->tm_wday >= | |
1094 | (int) (sizeof wday_name / sizeof wday_name[0])) | |
1095 | wn = "???"; | |
1096 | else wn = wday_name[timeptr->tm_wday]; | |
1097 | if (timeptr->tm_mon < 0 || timeptr->tm_mon >= | |
1098 | (int) (sizeof mon_name / sizeof mon_name[0])) | |
1099 | mn = "???"; | |
1100 | else mn = mon_name[timeptr->tm_mon]; | |
0afcb29d | 1101 | printf("%s %s%3d %.2d:%.2d:%.2d ", |
daa6fd88 UD |
1102 | wn, mn, |
1103 | timeptr->tm_mday, timeptr->tm_hour, | |
792dcd77 UD |
1104 | timeptr->tm_min, timeptr->tm_sec); |
1105 | #define DIVISOR 10 | |
1106 | trail = timeptr->tm_year % DIVISOR + TM_YEAR_BASE % DIVISOR; | |
1107 | lead = timeptr->tm_year / DIVISOR + TM_YEAR_BASE / DIVISOR + | |
1108 | trail / DIVISOR; | |
1109 | trail %= DIVISOR; | |
1110 | if (trail < 0 && lead > 0) { | |
1111 | trail += DIVISOR; | |
1112 | --lead; | |
1113 | } else if (lead < 0 && trail > 0) { | |
1114 | trail -= DIVISOR; | |
1115 | ++lead; | |
1116 | } | |
1117 | if (lead == 0) | |
670a687d PE |
1118 | printf("%d", trail); |
1119 | else printf("%d%d", lead, ((trail < 0) ? -trail : trail)); | |
daa6fd88 | 1120 | } |