Annotation of OpenXM_contrib/gnuplot/time.c, Revision 1.1.1.1
1.1 maekawa 1: #ifndef lint
2: static char *RCSid = "$Id: time.c,v 1.11 1998/04/14 00:16:27 drd Exp $";
3: #endif
4:
5: /* GNUPLOT - time.c */
6:
7: /*[
8: * Copyright 1986 - 1993, 1998 Thomas Williams, Colin Kelley
9: *
10: * Permission to use, copy, and distribute this software and its
11: * documentation for any purpose with or without fee is hereby granted,
12: * provided that the above copyright notice appear in all copies and
13: * that both that copyright notice and this permission notice appear
14: * in supporting documentation.
15: *
16: * Permission to modify the software is granted, but not the right to
17: * distribute the complete modified source code. Modifications are to
18: * be distributed as patches to the released version. Permission to
19: * distribute binaries produced by compiling modified sources is granted,
20: * provided you
21: * 1. distribute the corresponding source modifications from the
22: * released version in the form of a patch file along with the binaries,
23: * 2. add special version identification to distinguish your version
24: * in addition to the base release version number,
25: * 3. provide your name and address as the primary contact for the
26: * support of your modified version, and
27: * 4. retain our contact information in regard to use of the base
28: * software.
29: * Permission to distribute the released version of the source code along
30: * with corresponding source modifications in the form of a patch file is
31: * granted with same provisions 2 through 4 for binary distributions.
32: *
33: * This software is provided "as is" without express or implied warranty
34: * to the extent permitted by applicable law.
35: ]*/
36:
37:
38: /* some systems may not implement time very well ; in particular,
39: * things might break as the year 2000 approaches.
40: * This module either adds a routine gstrptime() to read a formatted time,
41: * augmenting the standard suite of time routines provided by ansi,
42: * or it completely replaces the whole lot with a new set of routines,
43: * which count time relative to the year 2000. Default is to use the
44: * new routines. define USE_SYSTEM_TIME to use the system routines, at your
45: * own risk. One problem in particular is that not all systems allow
46: * the time with integer value 0 to be represented symbolically, which
47: * prevents use of relative times.
48: */
49:
50:
51: #include "plot.h"
52:
53: /* build as a standalone test */
54:
55: #ifdef TEST_TIME
56:
57: # ifdef HAVE_SYS_TIMEB_H
58: # include <sys/timeb.h>
59: #else
60: /* declare struct timeb */
61: extern int ftime(struct timeb *);
62: #endif
63:
64: # define int_error(x,y) fprintf(stderr, "Error: " x "\n")
65: # define int_warn(x,y) fprintf(stderr, "Warn: " x "\n")
66:
67: /* need (only) these from plot.h */
68: # define ZERO_YEAR 2000
69: /* 1st jan, 2000 is a Saturday (cal 1 2000 on unix) */
70: # define JAN_FIRST_WDAY 6
71:
72: /* zero gnuplot (2000) - zero system (1970) */
73: # define SEC_OFFS_SYS 946684800.0
74:
75: /* avg, incl. leap year */
76: # define YEAR_SEC 31557600.0
77:
78: /* YEAR_SEC / 12 */
79: # define MON_SEC 2629800.0
80:
81: # define WEEK_SEC 604800.0
82: # define DAY_SEC 86400.0
83:
84: /*forward decls */
85: extern char *abbrev_month_names[];
86: extern char *full_month_names[];
87: extern char *abbrev_day_names[];
88: extern char *full_day_names[];
89:
90: #else /* TEST_TIME */
91:
92: # include "setshow.h" /* for month names etc */
93:
94: #endif /* TEST_TIME */
95:
96: static char *read_int __PROTO((char *s, int nr, int *d));
97: static int gdysize __PROTO((int yr));
98:
99:
100: static char *
101: read_int(s, nr, d)
102: char *s;
103: int nr, *d;
104: {
105: int result = 0;
106:
107: while (--nr >= 0 && *s >= '0' && *s <= '9')
108: result = result * 10 + (*s++ - '0');
109:
110: *d = result;
111: return (s);
112: }
113:
114:
115:
116: #ifndef USE_SYSTEM_TIME
117:
118: /* a new set of routines to completely replace the ansi ones
119: * Use at your own risk
120: */
121:
122:
123: static int mndday[12] =
124: {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
125:
126: static int xstrftime __PROTO((char *buf, int bufsz, char *fmt, struct tm * tm));
127:
128: /* days in year */
129: static int gdysize(yr)
130: int yr;
131: {
132:
133: if (!(yr % 4)) {
134: if ((!(yr % 100)) && yr % 400)
135: return (365);
136: return (366);
137: }
138: return (365);
139: }
140:
141:
142: /* new strptime() and gmtime() to allow time to be read as 24 hour,
143: * and spaces in the format string. time is converted to seconds from
144: * year 2000.... */
145:
146: char *
147: gstrptime(s, fmt, tm)
148: char *s;
149: char *fmt;
150: struct tm *tm;
151: {
152: int yday, date;
153:
154: date = yday = 0;
155: tm->tm_mday = 1;
156: tm->tm_mon = tm->tm_hour = tm->tm_min = tm->tm_sec = 0;
157: /* make relative times work (user-defined tic step) */
158: tm->tm_year = ZERO_YEAR;
159:
160: /* we do not yet calculate wday or yday, so make them illegal
161: * [but yday will be read by %j]
162: */
163:
164: tm->tm_yday = tm->tm_wday = -1;
165:
166: while (*fmt) {
167: if (*fmt != '%') {
168: if (*fmt == ' ') {
169: /* space in format means zero or more spaces in input */
170: while (*s == ' ')
171: ++s;
172: ++fmt;
173: continue;
174: } else if (*fmt == *s) {
175: ++s;
176: ++fmt;
177: continue;
178: } else
179: break; /* literal match has failed */
180: }
181: /* we are processing a percent escape */
182:
183: switch (*++fmt) {
184: case 'b': /* abbreviated month name */
185: {
186: int m;
187: for (m = 0; m < 12; ++m)
188: if (strnicmp(s, abbrev_month_names[m], strlen(abbrev_month_names[m])) == 0) {
189: s += strlen(abbrev_month_names[m]);
190: goto found_abbrev_mon;
191: }
192: /* get here => not found */
193: int_warn("Bad abbreviated month name", NO_CARET);
194: m = 0;
195: found_abbrev_mon:
196: tm->tm_mon = m;
197: break;
198: }
199:
200: case 'B': /* full month name */
201: {
202: int m;
203: for (m = 0; m < 12; ++m)
204: if (strnicmp(s, full_month_names[m], strlen(full_month_names[m])) == 0) {
205: s += strlen(full_month_names[m]);
206: goto found_full_mon;
207: }
208: /* get here => not found */
209: int_warn("Bad full month name", NO_CARET);
210: m = 0;
211: found_full_mon:
212: tm->tm_mon = m;
213: break;
214: }
215:
216: case 'd': /* read a day of month */
217: s = read_int(s, 2, &tm->tm_mday);
218: date++;
219: break;
220:
221: case 'm': /* month number */
222: s = read_int(s, 2, &tm->tm_mon);
223: date++;
224: --tm->tm_mon;
225: break;
226:
227: case 'y': /* year number */
228: s = read_int(s, 2, &tm->tm_year);
229: date++;
230: tm->tm_year += 1900;
231: break;
232:
233: case 'Y':
234: s = read_int(s, 4, &tm->tm_year);
235: date++;
236: /* tm->tm_year -= 1900; */
237: /* HOE tm->tm_year %= 100; */
238: break;
239:
240: case 'j':
241: s = read_int(s, 3, &tm->tm_yday);
242: tm->tm_yday--;
243: date++;
244: yday++;
245: break;
246:
247: case 'H':
248: s = read_int(s, 2, &tm->tm_hour);
249: break;
250:
251: case 'M':
252: s = read_int(s, 2, &tm->tm_min);
253: break;
254:
255: case 'S':
256: s = read_int(s, 2, &tm->tm_sec);
257: break;
258:
259: default:
260: int_warn("Bad time format in string", NO_CARET);
261: }
262: fmt++;
263: }
264:
265: FPRINTF((stderr, "read date-time : %d/%d/%d:%d:%d:%d\n", tm->tm_mday, tm->tm_mon + 1, tm->tm_year, tm->tm_hour, tm->tm_min, tm->tm_sec));
266:
267: /* now check the date/time entered, normalising if necessary
268: * read_int cannot read a -ve number, but can read %m=0 then decrement
269: * it to -1
270: */
271:
272: #define S (tm->tm_sec)
273: #define M (tm->tm_min)
274: #define H (tm->tm_hour)
275:
276: if (S >= 60) {
277: M += S / 60;
278: S %= 60;
279: }
280: if (M >= 60) {
281: H += M / 60;
282: M %= 60;
283: }
284: if (H >= 24) {
285: if (yday)
286: tm->tm_yday += H / 24;
287: tm->tm_mday += H / 24;
288: H %= 24;
289: }
290: #undef S
291: #undef M
292: #undef H
293:
294: FPRINTF((stderr, "normalised time : %d/%d/%d:%d:%d:%d\n", tm->tm_mday, tm->tm_mon + 1, tm->tm_year, tm->tm_hour, tm->tm_min, tm->tm_sec));
295:
296: if (date) {
297: if (yday) {
298:
299: if (tm->tm_yday < 0)
300: int_error("Illegal day of year", NO_CARET);
301:
302: /* we just set month to jan, day to yday, and let the
303: * normalising code do the work.
304: */
305:
306: tm->tm_mon = 0;
307: /* yday is 0->365, day is 1->31 */
308: tm->tm_mday = tm->tm_yday + 1;
309: }
310: if (tm->tm_mon < 0) {
311: int_error("illegal month", NO_CARET);
312: return (NULL);
313: }
314: if (tm->tm_mday < 1) {
315: int_error("illegal day of month", NO_CARET);
316: return (NULL);
317: }
318: if (tm->tm_mon > 11) {
319: tm->tm_year += tm->tm_mon / 12;
320: tm->tm_mon %= 12;
321: } {
322: int days_in_month;
323: while (tm->tm_mday > (days_in_month = (mndday[tm->tm_mon] + (tm->tm_mon == 1 && (gdysize(tm->tm_year) > 365))))) {
324: if (++tm->tm_mon == 12) {
325: ++tm->tm_year;
326: tm->tm_mon = 0;
327: }
328: tm->tm_mday -= days_in_month;
329: }
330: }
331: }
332: return (s);
333: }
334:
335: int gstrftime(s, bsz, fmt, l_clock)
336: char *s;
337: int bsz;
338: char *fmt;
339: double l_clock;
340: {
341: struct tm tm;
342:
343: ggmtime(&tm, l_clock);
344: #if 0
345: if ((tm.tm_zone = (char *) malloc(strlen(xtm->tm_zone) + 1)))
346: strcpy(tm.tm_zone, xtm->tm_zone);
347: /* printf("zone: %s - %s\n",tm.tm_zone,xtm->tm_zone); */
348: #endif
349:
350: return (xstrftime(s, bsz, fmt, &tm));
351: }
352:
353:
354: /* some shorthands : check that there is space in the output string
355: * Odd-looking defn is dangling-else-safe
356: */
357: #define CHECK_SPACE(n) if ( (l+(n)) <= bsz) ; else return 0
358:
359: /* copy a fixed string, checking that there's room */
360: #define COPY_STRING(z) CHECK_SPACE(strlen(z)) ; strcpy(s, z)
361:
362: /* format a string, using default spec if none given
363: * w and z are width and zero-flag
364: * dw and dz are the defaults for these
365: * In fact, CHECK_SPACE(w) is not a sufficient test, since
366: * sprintf("%2d", 365) outputs three characters
367: */
368:
369: #define FORMAT_STRING(dz, dw, x) \
370: if (w==0) { w=(dw); if (!z) z=(dz); } \
371: CHECK_SPACE(w); \
372: sprintf(s, z ? "%0*d" : "%*d", w, (x) )
373:
374: static int xstrftime(str, bsz, fmt, tm)
375: char *str; /* output buffer */
376: int bsz; /* space available */
377: char *fmt;
378: struct tm *tm;
379: {
380: int l = 0; /* chars written so far */
381:
382: char *s = str;
383:
384: memset(s, '\0', bsz);
385:
386: while (*fmt != '\0') {
387: if (*fmt != '%') {
388: if (l >= bsz)
389: return (0);
390: *s++ = *fmt++;
391: l++;
392: } else {
393:
394: /* set up format modifiers */
395: int w = 0;
396: int z = 0;
397: if (*++fmt == '0') {
398: z = 1;
399: ++fmt;
400: }
401: while (*fmt >= '0' && *fmt <= '9') {
402: w = w * 10 + (*fmt - '0');
403: ++fmt;
404: }
405:
406: switch (*fmt++) {
407: case '%':
408: CHECK_SPACE(1);
409: *s = '%';
410: break;
411:
412: case 'a':
413: COPY_STRING(abbrev_day_names[tm->tm_wday]);
414: break;
415:
416: case 'A':
417: COPY_STRING(full_day_names[tm->tm_wday]);
418: break;
419:
420: case 'b':
421: case 'h':
422: COPY_STRING(abbrev_month_names[tm->tm_mon]);
423: break;
424:
425: case 'B':
426: COPY_STRING(full_month_names[tm->tm_mon]);
427: break;
428:
429:
430: #if 0
431: /* %x not currently supported, so neither is c */
432: case 'c':
433: if (!xstrftime(s, bsz - l, "%x %X", tm))
434: return (0);
435: break;
436: #endif
437:
438: case 'd':
439: FORMAT_STRING(1, 2, tm->tm_mday); /* %02d */
440: break;
441:
442: case 'D':
443: if (!xstrftime(s, bsz - l, "%m/%d/%y", tm))
444: return (0);
445: break;
446:
447: case 'H':
448: FORMAT_STRING(1, 2, tm->tm_hour); /* %02d */
449: break;
450:
451: case 'I':
452: FORMAT_STRING(1, 2, tm->tm_hour % 12); /* %02d */
453: break;
454:
455: case 'j':
456: FORMAT_STRING(1, 3, tm->tm_yday + 1); /* %03d */
457: break;
458:
459: /* not in linux strftime man page. Not really needed now */
460: case 'k':
461: FORMAT_STRING(0, 2, tm->tm_hour); /* %2d */
462: break;
463:
464: case 'l':
465: FORMAT_STRING(0, 2, tm->tm_hour % 12); /* %2d */
466: break;
467:
468: case 'm':
469: FORMAT_STRING(1, 2, tm->tm_mon + 1); /* %02d */
470: break;
471:
472: case 'M':
473: FORMAT_STRING(1, 2, tm->tm_min); /* %02d */
474: break;
475:
476: case 'p':
477: CHECK_SPACE(2);
478: strcpy(s, (tm->tm_hour < 12) ? "am" : "pm");
479: break;
480:
481: case 'r':
482: if (!xstrftime(s, bsz - l, "%I:%M:%S %p", tm))
483: return (0);
484: break;
485:
486: case 'R':
487: if (!xstrftime(s, bsz - l, "%H:%M", tm))
488: return (0);
489: break;
490:
491: case 'S':
492: FORMAT_STRING(1, 2, tm->tm_sec); /* %02d */
493: break;
494:
495: case 'T':
496: if (!xstrftime(s, bsz - l, "%H:%M:%S", tm))
497: return (0);
498: break;
499:
500: case 'W': /* mon 1 day of week */
501: {
502: int week;
503: if (tm->tm_yday <= tm->tm_wday) {
504: week = 1;
505:
506: if ((tm->tm_mday - tm->tm_yday) > 4) {
507: week = 52;
508: }
509: if (tm->tm_yday == tm->tm_wday && tm->tm_wday == 0)
510: week = 52;
511:
512: } else {
513:
514: /* sun prev week */
515: int bw = tm->tm_yday - tm->tm_wday;
516:
517: if (tm->tm_wday > 0)
518: bw += 7; /* sun end of week */
519:
520: week = (int) bw / 7;
521:
522: if ((bw % 7) > 2) /* jan 1 is before friday */
523: week++;
524: }
525: FORMAT_STRING(1, 2, week); /* %02d */
526: break;
527: }
528:
529: case 'U': /* sun 1 day of week */
530: {
531: int week, bw;
532:
533: if (tm->tm_yday <= tm->tm_wday) {
534: week = 1;
535: if ((tm->tm_mday - tm->tm_yday) > 4) {
536: week = 52;
537: }
538: } else {
539: /* sat prev week */
540: bw = tm->tm_yday - tm->tm_wday - 1;
541: if (tm->tm_wday >= 0)
542: bw += 7; /* sat end of week */
543: week = (int) bw / 7;
544: if ((bw % 7) > 1) { /* jan 1 is before friday */
545: week++;
546: }
547: }
548: FORMAT_STRING(1, 2, week); /* %02d */
549: break;
550: }
551:
552: case 'w': /* day of week, sun=0 */
553: FORMAT_STRING(1, 2, tm->tm_wday); /* %02d */
554: break;
555:
556: case 'y':
557: FORMAT_STRING(1, 2, tm->tm_year % 100); /* %02d */
558: break;
559:
560: case 'Y':
561: FORMAT_STRING(1, 4, tm->tm_year); /* %04d */
562: break;
563:
564: #if 0
565: case 'Z':
566: COPY_STRING(tm->tm_zone);
567: break;
568: #endif
569: } /* switch */
570:
571: while (*s != '\0') {
572: s++;
573: l++;
574: }
575: }
576: }
577: return (l);
578: }
579:
580:
581:
582: /* time_t */
583: double gtimegm(tm)
584: struct tm *tm;
585: {
586: register int i;
587: /* returns sec from year ZERO_YEAR, defined in plot.h */
588: double dsec;
589:
590: dsec = 0;
591: if (tm->tm_year < ZERO_YEAR) {
592: for (i = tm->tm_year; i < ZERO_YEAR; i++) {
593: dsec -= (double) gdysize(i);
594: }
595: } else {
596: for (i = ZERO_YEAR; i < tm->tm_year; i++) {
597: dsec += (double) gdysize(i);
598: }
599: }
600: if (tm->tm_mday > 0) {
601: for (i = 0; i < tm->tm_mon; i++) {
602: dsec += (double) mndday[i] + (i == 1 && (gdysize(tm->tm_year) > 365));
603: }
604: dsec += (double) tm->tm_mday - 1;
605: } else {
606: dsec += (double) tm->tm_yday;
607: }
608: dsec *= (double) 24;
609:
610: dsec += tm->tm_hour;
611: dsec *= 60.0;
612: dsec += tm->tm_min;
613: dsec *= 60.0;
614: dsec += tm->tm_sec;
615:
616: FPRINTF((stderr, "broken-down time : %d/%d/%d:%d:%d:%d = %g seconds\n", tm->tm_mday, tm->tm_mon + 1, tm->tm_year, tm->tm_hour, tm->tm_min, tm->tm_sec, dsec));
617:
618: return (dsec);
619: }
620:
621: int ggmtime(tm, l_clock)
622: struct tm *tm;
623: /* time_t l_clock; */
624: double l_clock;
625: {
626: /* l_clock is relative to ZERO_YEAR, jan 1, 00:00:00,defined in plot.h */
627: int i, days;
628:
629: /* dodgy way of doing wday - i hope it works ! */
630:
631: int wday = JAN_FIRST_WDAY; /* eg 6 for 2000 */
632:
633: FPRINTF((stderr, "%g seconds = ", l_clock));
634:
635: tm->tm_year = ZERO_YEAR;
636: tm->tm_mday = tm->tm_yday = tm->tm_mon = tm->tm_hour = tm->tm_min = tm->tm_sec = 0;
637: if (l_clock < 0) {
638: while (l_clock < 0) {
639: int days_in_year = gdysize(--tm->tm_year);
640: l_clock += days_in_year * DAY_SEC; /* 24*3600 */
641: /* adding 371 is noop in modulo 7 arithmetic, but keeps wday +ve */
642: wday += 371 - days_in_year;
643: }
644: } else {
645: for (;;) {
646: int days_in_year = gdysize(tm->tm_year);
647: if (l_clock < days_in_year * DAY_SEC)
648: break;
649: l_clock -= days_in_year * DAY_SEC;
650: tm->tm_year++;
651: /* only interested in result modulo 7, but %7 is expensive */
652: wday += (days_in_year - 364);
653: }
654: }
655: tm->tm_yday = (int) (l_clock / DAY_SEC);
656: l_clock -= tm->tm_yday * DAY_SEC;
657: tm->tm_hour = (int) l_clock / 3600;
658: l_clock -= tm->tm_hour * 3600;
659: tm->tm_min = (int) l_clock / 60;
660: l_clock -= tm->tm_min * 60;
661: tm->tm_sec = (int) l_clock;
662:
663: days = tm->tm_yday;
664:
665: /* wday%7 should be day of week of first day of year */
666: tm->tm_wday = (wday + days) % 7;
667:
668: while (days >= (i = mndday[tm->tm_mon] + (tm->tm_mon == 1 && (gdysize(tm->tm_year) > 365)))) {
669: days -= i;
670: tm->tm_mon++;
671: }
672: tm->tm_mday = days + 1;
673:
674: FPRINTF((stderr, "broken-down time : %d/%d/%d:%d:%d:%d\n", tm->tm_mday, tm->tm_mon + 1, tm->tm_year, tm->tm_hour, tm->tm_min, tm->tm_sec));
675:
676: return (0);
677: }
678:
679:
680:
681:
682: #else /* USE_SYSTEM_TIME */
683:
684: /* define gnu time routines in terms of system time routines */
685:
686: int gstrftime(buf, bufsz, fmt, l_clock)
687: char *buf;
688: int bufsz;
689: char *fmt;
690: double l_clock;
691: {
692: time_t t = (time_t) l_clock;
693: return strftime(buf, bufsz, fmt, gmtime(&t));
694: }
695:
696: double gtimegm(tm)
697: struct tm *tm;
698: {
699: return (double) mktime(tm);
700: }
701:
702: int ggmtime(tm, l_clock)
703: struct tm *tm;
704: double l_clock;
705: {
706: time_t t = (time_t) l_clock;
707: struct tm *m = gmtime(&t);
708: *tm = *m; /* can any non-ansi compilers not do this ? */
709: }
710:
711: #define NOTHING
712: #define LETTER(L, width, field, extra) \
713: case L: s=read_int(s,width,&tm->field); extra; continue
714:
715: /* supplemental routine gstrptime() to read a formatted time */
716:
717: char *
718: gstrptime(s, fmt, tm)
719: char *s;
720: char *fmt;
721: struct tm *tm;
722: {
723: FPRINTF((stderr, "gstrptime(\"%s\", \"%s\")\n", s, fmt));
724:
725: /* linux does not appear to like years before 1902
726: * NT complains if its before 1970
727: * initialise fields to midnight, 1st Jan, 1970 (for relative times)
728: */
729: tm->tm_sec = tm->tm_min = tm->tm_hour = 0;
730: tm->tm_mday = 1;
731: tm->tm_mon = 0;
732: tm->tm_year = 70;
733: /* oops - it goes wrong without this */
734: tm->tm_isdst = 0;
735:
736: for (; *fmt && *s; ++fmt) {
737: if (*fmt != '%') {
738: if (*s != *fmt)
739: return s;
740: ++s;
741: continue;
742: }
743: assert(*fmt == '%');
744:
745: switch (*++fmt) {
746: case 0:
747: /* uh oh - % is last character in format */
748: return s;
749: case '%':
750: /* literal % */
751: if (*s++ != '%')
752: return s - 1;
753: continue;
754:
755: LETTER('d', 2, tm_mday, NOTHING);
756: LETTER('m', 2, tm_mon, NOTHING);
757: LETTER('y', 2, tm_year, NOTHING);
758: LETTER('Y', 4, tm_year, tm->tm_year -= 1900);
759: LETTER('H', 2, tm_hour, NOTHING);
760: LETTER('M', 2, tm_min, NOTHING);
761: LETTER('S', 2, tm_sec, NOTHING);
762:
763: default:
764: int_error("incorrect time format character", NO_CARET);
765: }
766: }
767:
768: FPRINTF((stderr, "Before mktime : %d/%d/%d:%d:%d:%d\n", tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_hour, tm->tm_min, tm->tm_sec));
769: /* mktime range-checks the time */
770:
771: if (mktime(tm) == -1) {
772: FPRINTF((stderr, "mktime() was not happy\n"));
773: int_error("Invalid date/time [mktime() did not like it]", NO_CARET);
774: }
775: FPRINTF((stderr, "After mktime : %d/%d/%d:%d:%d:%d\n", tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_hour, tm->tm_min, tm->tm_sec));
776:
777: return s;
778: }
779:
780:
781: #endif /* USE_SYSTEM_TIME */
782:
783:
784: #ifdef TEST_TIME
785:
786: char *abbrev_month_names[] =
787: {"jan", "feb", "mar", "apr", "may", "jun", "jul",
788: "aug", "sep", "oct", "nov", "dec"};
789: char *full_month_names[] =
790: {"January", "February", "March", "April", "May",
791: "June", "July", "August", "September", "October", "November", "December"};
792:
793: char *abbrev_day_names[] =
794: {"sun", "mon", "tue", "wed", "thu", "fri", "sat"};
795: char *full_day_names[] =
796: {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
797:
798:
799:
800: /* either print current time using supplied format, or read
801: * supplied time using supplied format
802: */
803:
804:
805: int main(argc,argv)
806: int argc;
807: char *argv[];
808: {
809: char output[80];
810:
811: if (argc < 2) {
812: fputs("usage : test 'format' ['time']\n", stderr);
813: exit(EXIT_FAILURE);
814: }
815: if (argc == 2) {
816: struct timeb now;
817: struct tm *tm;
818: ftime(&now);
819: tm = gmtime(&now.time);
820: xstrftime(output, 80, argv[1], tm);
821: puts(output);
822: } else {
823: struct tm tm;
824: gstrptime(argv[2], argv[1], &tm);
825: puts(asctime(&tm));
826: }
827: exit(EXIT_SUCCESS);
828: }
829:
830: #endif /* TEST_TIME */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>