6 * Manipulate character strings representing dates.
10 * #include <parsedate.h>
13 * struct parseddate *pd;
15 * pd = parsedate (date);
17 * compute_unixtime (pd);
19 * break_down_unixtime (pd);
21 * date = mail_date_string (pd);
23 * date = uucp_date_string (pd);
27 * The returned value from "parsedate", "mail_date_string", or
28 * "uucp_date_string" points to static data whose contents are
29 * overwritten by the next call to the same routine.
31 * "compute_unixtime" is implicitly called by "parsedate".
35 * struct parseddate *parsedate (date) char *date;
36 * Parse a character string representing a date and time into
37 * individual values in a "struct parseddate" data structure.
39 * compute_unixtime (pd) struct parseddate *pd;
40 * Given a mostly filled-in "struct parseddate", compute the day
41 * of the week and the internal UNIX representation of the date.
43 * break_down_unixtime (pd) struct parseddate *pd;
44 * Compute the date and time corresponding to the "unixtime" and
45 * "zone" values in a "struct parseddate".
47 * char *mail_date_string (pd) struct parseddate *pd;
48 * Generate a character string representing a date and time in
49 * the RFC822 (ARPANET mail standard) format.
51 * char *uucp_date_string (pd) struct parseddate *pd;
52 * Generate a character string representing a date and time in
53 * the UUCP mail format.
61 #include "parsedate.h"
63 static char *RCSID = "$Id: parsedate.c,v 1.2 2002-09-28 06:58:45 arjen Exp $";
67 compute_unixtime (register struct parseddate *pd);
69 /* Number of seconds in various time intervals. */
70 #define SEC_PER_MIN 60
71 #define SEC_PER_HOUR (60*SEC_PER_MIN)
72 #define SEC_PER_DAY (24*SEC_PER_HOUR)
73 #define SEC_PER_YEAR (365*SEC_PER_DAY)
75 /* Number of days in each month. */
76 static int monthsize[] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
78 /* Three-letter abbreviations of month and day names. */
79 static char monthname[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
80 static char dayname[] = "SunMonTueWedThuFriSat";
82 /* struct parseddate *parsedate (date) char *date;
83 * Analyze a character string representing a date and time. The
84 * returned value points to a data structure with the desired
85 * information. (NOTE: The returned value points to static data
86 * whose contents are overwritten by each call.)
88 struct parseddate * parsedate (char *date)
90 register int year_save;
91 extern struct parseddate yyans;
94 /* Initialize the returned-value structure. */
105 yyans.c_weekday = -1;
108 /* Parse the argument string. */
111 if (yyparse () != 0 && yyans.error == NULL)
112 yyans.error = yyinbuf;
114 /* Validate the day of the month, compute/validate the day of the
115 * week, and compute the internal UNIX form of the time. See if
116 * "compute_unixtime" found fault with the year or the day of the
117 * month. (Note that we have to remember the original "year" value
118 * because it might legitimately have been -1 to begin with.)
120 year_save = yyans.year; compute_unixtime (&yyans);
121 if (yyans.error == NULL
122 && (yyans.year != year_save
123 || (yyans.month > 0 && yyans.day < 0)
124 || (yyans.month < 0 && yyans.day > 0)))
125 yyans.error = yyinbuf;
130 /* compute_unixtime (pd) struct parseddate *pd;
131 * Given a mostly filled-in "struct parseddate", compute the day of
132 * the week and the internal UNIX representation of the date.
134 * A year before 1600 will be rejected and replaced with -1. A
135 * date from 1600 on which falls outside the range representable in
136 * internal UNIX form will still have the correct day of the week
139 * The day of the week is always computed on the assumption that the
140 * Gregorian calendar is in use. Days of the week for dates in the
141 * far future may turn out to be incorrect if any changes are made
142 * to the calendar between now and then.
144 compute_unixtime (register struct parseddate *pd)
146 register int weekday, n, l, a;
148 /* Validate the year. */
149 if (pd->year >= 0 && pd->year < 1600) pd->year = -1;
151 /* Validate the day of the month. Also calculate the number of days
152 * in February (even if this is not February, we will need the num-
153 * ber of days in February later on when computing the UNIX time).
156 { if (pd->year < 0) monthsize[2] = 29;
157 else if (pd->year % 4 != 0) monthsize[2] = 28;
158 else if (pd->year % 100 != 0) monthsize[2] = 29;
159 else if (pd->year % 400 != 0) monthsize[2] = 28;
160 else monthsize[2] = 29;
161 if (pd->day <= 0 || pd->day > monthsize[pd->month])
165 /* Compute the day of the week. The next several lines constitute a
166 * perpetual-calendar formula. Note, of course, that the "claimed"
167 * day of the week (pd->c_weekday) is ignored here.
169 if (pd->year > 0 && pd->month > 0 && pd->day > 0)
170 { if (pd->month >= 3) n = pd->year / 100,
172 else n = (pd->year-1) / 100,
173 l = (pd->year-1) % 100;
174 a = (26 * ((pd->month+9)%12 + 1) - 2) / 10;
175 weekday = (a+(l>>2)+(n>>2)+l-(n+n)+pd->day);
176 while (weekday < 0) weekday += 7;
177 pd->weekday = weekday % 7;
180 /* Figure out the internal UNIX form of the date. */
181 if (pd->year >= 1969 && pd->year <= 2038
182 && pd->month > 0 && pd->day > 0
183 && pd->hour >= 0 && pd->minute >= 0
184 && pd->zone != -1 && pd->zone > -1440 && pd->zone < 1440)
186 SEC_PER_YEAR * (pd->year - 1970)
187 + SEC_PER_DAY * ((pd->year - 1969) / 4)
188 /* month is taken care of later */
189 + SEC_PER_DAY * (pd->day - 1)
190 + SEC_PER_HOUR * pd->hour
191 + SEC_PER_MIN * pd->minute
192 /* seconds are taken care of later */
193 - SEC_PER_MIN * pd->zone;
195 pd->unixtime += pd->second;
196 for (n = pd->month - 1; n > 0; n--)
197 pd->unixtime += SEC_PER_DAY * monthsize[n];
198 if (pd->unixtime < 0) pd->unixtime = -1;
200 else pd->unixtime = -1;
203 /* break_down_unixtime (pd) struct parseddate *pd;
204 * Given the "unixtime" and "zone" fields of a "struct parseddate",
205 * compute the values of the "year", "month", "day", "hour", "min-
206 * ute", "second", and "weekday" fields. The "dst" and "error"
207 * fields of the structure are not used or modified.
209 break_down_unixtime (pd)
210 register struct parseddate *pd;
211 { register unsigned long timevalue;
214 /* Validate the "unixtime" and "zone" fields. */
216 || pd->zone == -1 || pd->zone <= -1440 || pd->zone >= 1440)
217 { /* Sorry, can't do it. */
218 pd->year = -1; pd->month = -1; pd->day = -1;
219 pd->hour = -1; pd->minute = -1; pd->second = -1;
224 /* Even though "pd->unixtime" must be non-negative, and thus cannot
225 * indicate a time earlier than 1970, a negative "pd->zone" could
226 * cause the local date to be Wednesday, 31 December 1969. Such a
227 * date requires special handling.
229 * A local date earlier than 31 December 1969 is impossible because
230 * "pd->zone" must represent a time-zone shift of less than a day.
232 if (pd->zone < 0 && pd->unixtime + SEC_PER_MIN * pd->zone < 0)
233 { pd->year = 1969; pd->month = 12; pd->day = 31;
234 pd->weekday = 3; /* Wednesday */
235 timevalue = pd->unixtime + SEC_PER_MIN * pd->zone + SEC_PER_DAY;
236 /* Note: 0 <= timevalue < SEC_PER_DAY */
237 pd->hour = timevalue / SEC_PER_HOUR;
238 pd->minute = (timevalue % SEC_PER_HOUR) / SEC_PER_MIN;
239 pd->second = timevalue % SEC_PER_MIN;
243 /* Handle the general case (local time is 1970 or later). */
244 timevalue = pd->unixtime + SEC_PER_MIN * pd->zone;
246 /* day of the week (1 January 1970 was a Thursday) . . . */
247 pd->weekday = (timevalue/SEC_PER_DAY + 4 /* Thursday */) % 7;
249 /* year (note that the only possible century year here is 2000,
250 * a leap year -- hence no special tests for century years are
253 for (m = 1970; ; m++)
254 { n = (m%4==0) ? SEC_PER_YEAR+SEC_PER_DAY : SEC_PER_YEAR;
255 if (n > timevalue) break;
259 monthsize[2] = (m%4==0) ? 29 : 28;
263 { n = SEC_PER_DAY * monthsize[m];
264 if (n > timevalue) break;
269 /* day, hour, minute, and second . . . */
270 pd->day = (timevalue / SEC_PER_DAY) + 1;
271 pd->hour = (timevalue % SEC_PER_DAY) / SEC_PER_HOUR;
272 pd->minute = (timevalue % SEC_PER_HOUR) / SEC_PER_MIN;
273 pd->second = timevalue % SEC_PER_MIN;
276 /* char *mail_date_string (pd) struct parseddate *pd;
277 * Generate a character string representing a date and time in the
278 * RFC822 (ARPANET mail standard) format. A value of NULL is re-
279 * turned if "pd" does not contain all necessary data fields.
280 * (NOTE: The returned value points to static data whose contents
281 * are overwritten by each call.)
284 mail_date_string (pd)
285 register struct parseddate *pd;
287 static char answer[50];
289 /* Check the day of the month and compute the day of the week. */
290 compute_unixtime (pd);
292 /* Make sure all required fields are present. */
293 if (pd->year < 0 || pd->month < 0 || pd->day < 0
294 || pd->hour < 0 || pd->minute < 0
295 || pd->zone == -1 || pd->zone <= -1440 || pd->zone >= 1440)
296 return NULL; /* impossible to generate string */
298 /* Generate the answer string. */
300 "%.3s, %d %.3s %d %02d:%02d",
301 dayname + 3*pd->weekday,
302 pd->day, monthname + 3*(pd->month-1),
303 (pd->year >= 1960 && pd->year <= 1999)
304 ? pd->year - 1900 : pd->year,
305 pd->hour, pd->minute);
306 c = answer + strlen (answer);
307 if (pd->second >= 0) sprintf (c, ":%02d", pd->second), c += 3;
310 { /* NOTE: Only zone abbreviations in RFC822 are used here. */
311 case 0: strcpy (c, pd->dst ? "+0000" : "GMT"); break;
312 case -240: strcpy (c, pd->dst ? "EDT" : "-0400"); break;
313 case -300: strcpy (c, pd->dst ? "CDT" : "EST"); break;
314 case -360: strcpy (c, pd->dst ? "MDT" : "CST"); break;
315 case -420: strcpy (c, pd->dst ? "PDT" : "MST"); break;
316 case -480: strcpy (c, pd->dst ? "-0800" : "PST"); break;
319 sprintf (c, "+%02d%02d", pd->zone/60, pd->zone%60);
320 else sprintf (c, "-%02d%02d", -pd->zone/60, -pd->zone%60);
326 /* char *uucp_date_string (pd) struct parseddate *pd;
327 * Generate a character string representing a date and time in the
328 * UUCP mail format. A value of NULL is returned if "pd" does not
329 * contain all necessary data fields. (NOTE: The returned value
330 * points to static data whose contents are overwritten by each
334 uucp_date_string (pd)
335 register struct parseddate *pd;
337 static char answer[50];
339 /* Check the day of the month and compute the day of the week. */
340 compute_unixtime (pd);
342 /* Make sure all required fields are present. */
343 if (pd->year < 0 || pd->month < 0 || pd->day < 0
344 || pd->hour < 0 || pd->minute < 0
345 || pd->zone == -1 || pd->zone <= -1440 || pd->zone >= 1440)
346 return NULL; /* impossible to generate string */
348 /* Generate the answer string. */
350 "%.3s %.3s %d %02d:%02d",
351 dayname + 3*pd->weekday,
352 monthname + 3*(pd->month-1), pd->day,
353 pd->hour, pd->minute);
354 c = answer + strlen (answer);
355 if (pd->second >= 0) sprintf (c, ":%02d", pd->second), c += 3;
357 { /* NOTE: Only zone abbreviations in RFC822 are used here. */
358 case 0: strcpy (c, pd->dst ? "+0000" : "-GMT"); break;
359 case -240: strcpy (c, pd->dst ? "-EDT" : "-0400"); break;
360 case -300: strcpy (c, pd->dst ? "-CDT" : "-EST"); break;
361 case -360: strcpy (c, pd->dst ? "-MDT" : "-CST"); break;
362 case -420: strcpy (c, pd->dst ? "-PDT" : "-MST"); break;
363 case -480: strcpy (c, pd->dst ? "-0800" : "-PST"); break;
366 sprintf (c, "+%02d%02d", pd->zone/60, pd->zone%60);
367 else sprintf (c, "-%02d%02d", -pd->zone/60, -pd->zone%60);
369 c = answer + strlen (answer);
370 sprintf (c, " %d", pd->year);