/* $NetBSD: cal.c,v 1.26 2010/02/03 15:34:45 roy Exp $ */ /* * Copyright (c) 1989, 1993, 1994 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Kim Letkeman. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #ifndef lint __COPYRIGHT("@(#) Copyright (c) 1989, 1993, 1994\ The Regents of the University of California. All rights reserved."); #endif /* not lint */ #ifndef lint #if 0 static char sccsid[] = "@(#)cal.c 8.4 (Berkeley) 4/2/94"; #else __RCSID("$NetBSD: cal.c,v 1.26 2010/02/03 15:34:45 roy Exp $"); #endif #endif /* not lint */ #include #include #include #include #include #include #include #include #include #include #include #include #define SATURDAY 6 /* 1 Jan 1 was a Saturday */ #define FIRST_MISSING_DAY reform->first_missing_day #define NUMBER_MISSING_DAYS reform->missing_days #define MAXDAYS 42 /* max slots in a month array */ #define SPACE -1 /* used in day array */ static int days_in_month[2][13] = { {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, }; int empty[MAXDAYS] = { SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, SPACE, }; int shift_days[2][4][MAXDAYS + 1]; const char *month_names[12] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December", }; const char *day_headings = " S M Tu W Th F S"; const char *j_day_headings = " S M Tu W Th F S"; /* leap years according to the julian calendar */ #define j_leap_year(y, m, d) \ (((m) > 2) && \ !((y) % 4)) /* leap years according to the gregorian calendar */ #define g_leap_year(y, m, d) \ (((m) > 2) && \ ((!((y) % 4) && ((y) % 100)) || \ !((y) % 400))) /* leap year -- account for gregorian reformation at some point */ #define leap_year(yr) \ ((yr) <= reform->year ? j_leap_year((yr), 3, 1) : \ g_leap_year((yr), 3, 1)) /* number of julian leap days that have passed by a given date */ #define j_leap_days(y, m, d) \ ((((y) - 1) / 4) + j_leap_year(y, m, d)) /* number of gregorian leap days that have passed by a given date */ #define g_leap_days(y, m, d) \ ((((y) - 1) / 4) - (((y) - 1) / 100) + (((y) - 1) / 400) + \ g_leap_year(y, m, d)) /* * Subtracting the gregorian leap day count (for a given date) from * the julian leap day count (for the same date) describes the number * of days from the date before the shift to the next date that * appears in the calendar. Since we want to know the number of * *missing* days, not the number of days that the shift spans, we * subtract 2. * * Alternately... * * There's a reason they call the Dark ages the Dark Ages. Part of it * is that we don't have that many records of that period of time. * One of the reasons for this is that a lot of the Dark Ages never * actually took place. At some point in the first millenium A.D., a * ruler of some power decided that he wanted the number of the year * to be different than what it was, so he changed it to coincide * nicely with some event (a birthday or anniversary, perhaps a * wedding, or maybe a centennial for a largish city). One of the * side effects of this upon the Gregorian reform is that two Julian * leap years (leap days celebrated during centennial years that are * not quatro-centennial years) were skipped. */ #define GREGORIAN_MAGIC 2 /* number of centuries since the reform, not inclusive */ #define centuries_since_reform(yr) \ ((yr) > reform->year ? ((yr) / 100) - (reform->year / 100) : 0) /* number of centuries since the reform whose modulo of 400 is 0 */ #define quad_centuries_since_reform(yr) \ ((yr) > reform->year ? ((yr) / 400) - (reform->year / 400) : 0) /* number of leap years between year 1 and this year, not inclusive */ #define leap_years_since_year_1(yr) \ ((yr) / 4 - centuries_since_reform(yr) + quad_centuries_since_reform(yr)) struct reform { const char *country; int ambiguity, year, month, date; long first_missing_day; int missing_days; /* * That's 2 for standard/julian display, 4 for months possibly * affected by the Gregorian shift, and MAXDAYS + 1 for the * days that get displayed, plus a crib slot. */ } *reform, reforms[] = { { "DEFAULT", 0, 1752, 9, 3, 0, 0 }, { "Italy", 1, 1582, 10, 5, 0, 0 }, { "Spain", 1, 1582, 10, 5, 0, 0 }, { "Portugal", 1, 1582, 10, 5, 0, 0 }, { "Poland", 1, 1582, 10, 5, 0, 0 }, { "France", 2, 1582, 12, 10, 0, 0 }, { "Luxembourg", 2, 1582, 12, 22, 0, 0 }, { "Netherlands", 2, 1582, 12, 22, 0, 0 }, { "Bavaria", 0, 1583, 10, 6, 0, 0 }, { "Austria", 2, 1584, 1, 7, 0, 0 }, { "Switzerland", 2, 1584, 1, 12, 0, 0 }, { "Hungary", 0, 1587, 10, 22, 0, 0 }, { "Germany", 0, 1700, 2, 19, 0, 0 }, { "Norway", 0, 1700, 2, 19, 0, 0 }, { "Denmark", 0, 1700, 2, 19, 0, 0 }, { "Great Britain", 0, 1752, 9, 3, 0, 0 }, { "England", 0, 1752, 9, 3, 0, 0 }, { "America", 0, 1752, 9, 3, 0, 0 }, { "Sweden", 0, 1753, 2, 18, 0, 0 }, { "Finland", 0, 1753, 2, 18, 0, 0 }, { "Japan", 0, 1872, 12, 20, 0, 0 }, { "China", 0, 1911, 11, 7, 0, 0 }, { "Bulgaria", 0, 1916, 4, 1, 0, 0 }, { "U.S.S.R.", 0, 1918, 2, 1, 0, 0 }, { "Serbia", 0, 1919, 1, 19, 0, 0 }, { "Romania", 0, 1919, 1, 19, 0, 0 }, { "Greece", 0, 1924, 3, 10, 0, 0 }, { "Turkey", 0, 1925, 12, 19, 0, 0 }, { "Egypt", 0, 1928, 9, 18, 0, 0 }, { NULL, 0, 0, 0, 0, 0, 0 }, }; int julian; int dow; int hilite; const char *md, *me; void init_hilite(void); int getnum(const char *); void gregorian_reform(const char *); void reform_day_array(int, int, int *, int *, int *,int *,int *,int *); int ascii_day(char *, int); void center(const char *, int, int); void day_array(int, int, int *); int day_in_week(int, int, int); int day_in_year(int, int, int); void monthrange(int, int, int, int, int); int main(int, char **); void trim_trailing_spaces(char *); void usage(void); int main(int argc, char **argv) { struct tm *local_time; time_t now; int ch, yflag; long month, year; int before, after, use_reform; int yearly = 0; char *when, *eoi; before = after = 0; use_reform = yflag = year = 0; when = NULL; while ((ch = getopt(argc, argv, "A:B:d:hjR:ry3")) != -1) { switch (ch) { case 'A': after = getnum(optarg); if (after < 0) errx(1, "Argument to -A must be positive"); break; case 'B': before = getnum(optarg); if (before < 0) errx(1, "Argument to -B must be positive"); break; case 'd': dow = getnum(optarg); if (dow < 0 || dow > 6) errx(1, "illegal day of week value: use 0-6"); break; case 'h': init_hilite(); break; case 'j': julian = 1; break; case 'R': when = optarg; break; case 'r': use_reform = 1; break; case 'y': yflag = 1; break; case '3': before = after = 1; break; case '?': default: usage(); /* NOTREACHED */ } } argc -= optind; argv += optind; if (when != NULL) gregorian_reform(when); if (reform == NULL) gregorian_reform("DEFAULT"); month = 0; switch (argc) { case 2: month = strtol(*argv++, &eoi, 10); if (month < 1 || month > 12 || *eoi != '\0') errx(1, "illegal month value: use 1-12"); year = strtol(*argv, &eoi, 10); if (year < 1 || year > 9999 || *eoi != '\0') errx(1, "illegal year value: use 1-9999"); break; case 1: year = strtol(*argv, &eoi, 10); if (year < 1 || year > 9999 || (*eoi != '\0' && *eoi != '/' && *eoi != '-')) errx(1, "illegal year value: use 1-9999"); if (*eoi != '\0') { month = strtol(eoi + 1, &eoi, 10); if (month < 1 || month > 12 || *eoi != '\0') errx(1, "illegal month value: use 1-12"); } break; case 0: (void)time(&now); local_time = localtime(&now); if (use_reform) year = reform->year; else year = local_time->tm_year + TM_YEAR_BASE; if (!yflag) { if (use_reform) month = reform->month; else month = local_time->tm_mon + 1; } break; default: usage(); } if (!month) { /* yearly */ month = 1; before = 0; after = 11; yearly = 1; } monthrange(month, year, before, after, yearly); exit(0); } #define DAY_LEN 3 /* 3 spaces per day */ #define J_DAY_LEN 4 /* 4 spaces per day */ #define WEEK_LEN 20 /* 7 * 3 - one space at the end */ #define J_WEEK_LEN 27 /* 7 * 4 - one space at the end */ #define HEAD_SEP 2 /* spaces between day headings */ #define J_HEAD_SEP 2 #define MONTH_PER_ROW 3 /* how many monthes in a row */ #define J_MONTH_PER_ROW 2 void monthrange(int month, int year, int before, int after, int yearly) { int startmonth, startyear; int endmonth, endyear; int i, row; int days[3][MAXDAYS]; char lineout[256]; int inayear; int newyear; int day_len, week_len, head_sep; int month_per_row; int skip, r_off, w_off; if (julian) { day_len = J_DAY_LEN; week_len = J_WEEK_LEN; head_sep = J_HEAD_SEP; month_per_row = J_MONTH_PER_ROW; } else { day_len = DAY_LEN; week_len = WEEK_LEN; head_sep = HEAD_SEP; month_per_row = MONTH_PER_ROW; } month--; startyear = year - (before + 12 - 1 - month) / 12; startmonth = 12 - 1 - ((before + 12 - 1 - month) % 12); endyear = year + (month + after) / 12; endmonth = (month + after) % 12; if (startyear < 0 || endyear > 9999) { errx(1, "year should be in 1-9999\n"); } year = startyear; month = startmonth; inayear = newyear = (year != endyear || yearly); if (inayear) { skip = month % month_per_row; month -= skip; } else { skip = 0; } do { if (newyear) { (void)snprintf(lineout, sizeof(lineout), "%d", year); center(lineout, week_len * month_per_row + head_sep * (month_per_row - 1), 0); (void)printf("\n\n"); newyear = 0; } for (i = 0; i < skip; i++) center("", week_len, head_sep); for (; i < month_per_row; i++) { int sep; if (year == endyear && month + i > endmonth) break; sep = (i == month_per_row - 1) ? 0 : head_sep; day_array(month + i + 1, year, days[i]); if (inayear) { center(month_names[month + i], week_len, sep); } else { snprintf(lineout, sizeof(lineout), "%s %d", month_names[month + i], year); center(lineout, week_len, sep); } } printf("\n"); for (i = 0; i < skip; i++) center("", week_len, head_sep); for (; i < month_per_row; i++) { int sep; if (year == endyear && month + i > endmonth) break; sep = (i == month_per_row - 1) ? 0 : head_sep; if (dow) { printf("%s ", (julian) ? j_day_headings + 4 * dow : day_headings + 3 * dow); printf("%.*s", dow * (julian ? 4 : 3) - 1, (julian) ? j_day_headings : day_headings); } else printf("%s", (julian) ? j_day_headings : day_headings); printf("%*s", sep, ""); } printf("\n"); for (row = 0; row < 6; row++) { char *p = NULL; memset(lineout, ' ', sizeof(lineout)); for (i = 0; i < skip; i++) { /* nothing */ } w_off = 0; for (; i < month_per_row; i++) { int col, *dp; if (year == endyear && month + i > endmonth) break; p = lineout + i * (week_len + 2) + w_off; dp = &days[i][row * 7]; for (col = 0; col < 7; col++, p += day_len + r_off) { r_off = ascii_day(p, *dp++); w_off += r_off; } } *p = '\0'; trim_trailing_spaces(lineout); (void)printf("%s\n", lineout); } skip = 0; month += month_per_row; if (month >= 12) { month -= 12; year++; newyear = 1; } } while (year < endyear || (year == endyear && month <= endmonth)); } /* * day_array -- * Fill in an array of 42 integers with a calendar. Assume for a moment * that you took the (maximum) 6 rows in a calendar and stretched them * out end to end. You would have 42 numbers or spaces. This routine * builds that array for any month from Jan. 1 through Dec. 9999. */ void day_array(int month, int year, int *days) { int day, dw, dm; time_t t; struct tm *tm; t = time(NULL); tm = localtime(&t); tm->tm_year += TM_YEAR_BASE; tm->tm_mon++; tm->tm_yday++; /* jan 1 is 1 for us, not 0 */ for (dm = month + year * 12, dw = 0; dw < 4; dw++) { if (dm == shift_days[julian][dw][MAXDAYS]) { memmove(days, shift_days[julian][dw], MAXDAYS * sizeof(int)); return; } } memmove(days, empty, MAXDAYS * sizeof(int)); dm = days_in_month[leap_year(year)][month]; dw = day_in_week(1, month, year); day = julian ? day_in_year(1, month, year) : 1; while (dm--) { if (hilite && year == tm->tm_year && (julian ? (day == tm->tm_yday) : (month == tm->tm_mon && day == tm->tm_mday))) days[dw++] = SPACE - day++; else days[dw++] = day++; } } /* * day_in_year -- * return the 1 based day number within the year */ int day_in_year(int day, int month, int year) { int i, leap; leap = leap_year(year); for (i = 1; i < month; i++) day += days_in_month[leap][i]; return (day); } /* * day_in_week * return the 0 based day number for any date from 1 Jan. 1 to * 31 Dec. 9999. Returns the day of the week of the first * missing day for any given Gregorian shift. */ int day_in_week(int day, int month, int year) { long temp; temp = (long)(year - 1) * 365 + leap_years_since_year_1(year - 1) + day_in_year(day, month, year); if (temp < FIRST_MISSING_DAY) return ((temp - dow + 6 + SATURDAY) % 7); if (temp >= (FIRST_MISSING_DAY + NUMBER_MISSING_DAYS)) return (((temp - dow + 6 + SATURDAY) - NUMBER_MISSING_DAYS) % 7); return ((FIRST_MISSING_DAY - dow + 6 + SATURDAY) % 7); } int ascii_day(char *p, int day) { int display, val, rc; char *b; static const char *aday[] = { "", " 1", " 2", " 3", " 4", " 5", " 6", " 7", " 8", " 9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", }; if (day == SPACE) { memset(p, ' ', julian ? J_DAY_LEN : DAY_LEN); return (0); } if (day < SPACE) { b = p; day = SPACE - day; } else b = NULL; if (julian) { if ((val = day / 100) != 0) { day %= 100; *p++ = val + '0'; display = 1; } else { *p++ = ' '; display = 0; } val = day / 10; if (val || display) *p++ = val + '0'; else *p++ = ' '; *p++ = day % 10 + '0'; } else { *p++ = aday[day][0]; *p++ = aday[day][1]; } rc = 0; if (b != NULL) { const char *t; char h[64]; int l; l = p - b; memcpy(h, b, l); p = b; if (md != NULL) { for (t = md; *t; rc++) *p++ = *t++; memcpy(p, h, l); p += l; for (t = me; *t; rc++) *p++ = *t++; } else { for (t = &h[0]; l--; t++) { *p++ = *t; rc++; *p++ = '\b'; rc++; *p++ = *t; } } } *p = ' '; return (rc); } void trim_trailing_spaces(char *s) { char *p; for (p = s; *p; ++p) continue; while (p > s && isspace((unsigned char)*--p)) continue; if (p > s) ++p; *p = '\0'; } void center(const char *str, int len, int separate) { len -= strlen(str); (void)printf("%*s%s%*s", len / 2, "", str, len / 2 + len % 2, ""); if (separate) (void)printf("%*s", separate, ""); } /* * gregorian_reform -- * Given a description of date on which the Gregorian Reform was * applied. The argument can be any of the "country" names * listed in the reforms array (case insensitive) or a date of * the form YYYY/MM/DD. The date and month can be omitted if * doing so would not select more than one different built-in * reform point. */ void gregorian_reform(const char *p) { int year, month, date; int i, days, diw, diy; char c; i = sscanf(p, "%d%*[/,-]%d%*[/,-]%d%c", &year, &month, &date, &c); switch (i) { case 4: /* * If the character was sscanf()ed, then there's more * stuff than we need. */ errx(1, "date specifier %s invalid", p); case 0: /* * Not a form we can sscanf(), so void these, and we * can try matching "country" names later. */ year = month = date = -1; break; case 1: month = 0; /*FALLTHROUGH*/ case 2: date = 0; /*FALLTHROUGH*/ case 3: /* * At last, some sanity checking on the values we were * given. */ if (year < 1 || year > 9999) errx(1, "%d: illegal year value: use 1-9999", year); if (i > 1 && (month < 1 || month > 12)) errx(1, "%d: illegal month value: use 1-12", month); if ((i == 3 && date < 1) || date < 0 || date > days_in_month[1][month]) /* * What about someone specifying a leap day in * a non-leap year? Well...that's a tricky * one. We can't yet *say* whether the year * in question is a leap year. What if the * date given was, for example, 1700/2/29? is * that a valid leap day? * * So...we punt, and hope that saying 29 in * the case of February isn't too bad an idea. */ errx(1, "%d: illegal date value: use 1-%d", date, days_in_month[1][month]); break; } /* * A complete date was specified, so use the other pope. */ if (date > 0) { static struct reform Goestheveezl; reform = &Goestheveezl; reform->country = "Bompzidaize"; reform->year = year; reform->month = month; reform->date = date; } /* * No date information was specified, so let's try to match on * country name. */ else if (year == -1) { for (reform = &reforms[0]; reform->year; reform++) { if (strcasecmp(p, reform->country) == 0) break; } } /* * We have *some* date information, but not a complete date. * Let's see if we have enough to pick a single entry from the * list that's not ambiguous. */ else { for (reform = &reforms[0]; reform->year; reform++) { if ((year == 0 || year == reform->year) && (month == 0 || month == reform->month) && (date == 0 || month == reform->date)) break; } if (i <= reform->ambiguity) errx(1, "%s: ambiguous short reform date specification", p); } /* * Oops...we reached the end of the list. */ if (reform->year == 0) errx(1, "reform name %s invalid", p); /* * */ reform->missing_days = j_leap_days(reform->year, reform->month, reform->date) - g_leap_days(reform->year, reform->month, reform->date) - GREGORIAN_MAGIC; reform->first_missing_day = (reform->year - 1) * 365 + day_in_year(reform->date, reform->month, reform->year) + date + j_leap_days(reform->year, reform->month, reform->date); /* * Once we know the day of the week of the first missing day, * skip back to the first of the month's day of the week. */ diw = day_in_week(reform->date, reform->month, reform->year); diw = (diw + 8 - (reform->date % 7)) % 7; diy = day_in_year(1, reform->month, reform->year); /* * We might need all four of these (if you switch from Julian * to Gregorian at some point after 9900, you get a gap of 73 * days, and that can affect four months), and it doesn't hurt * all that much to precompute them, so there. */ date = 1; days = 0; for (i = 0; i < 4; i++) reform_day_array(reform->month + i, reform->year, &days, &date, &diw, &diy, shift_days[0][i], shift_days[1][i]); } /* * reform_day_array -- * Pre-calculates the given month's calendar (in both "standard" * and "julian day" representations) with respect for days * skipped during a reform period. */ void reform_day_array(int month, int year, int *done, int *date, int *diw, int *diy, int *scal, int *jcal) { int mdays; /* * If the reform was in the month of october or later, then * the month number from the caller could "overflow". */ if (month > 12) { month -= 12; year++; } /* * Erase months, and set crib number. The crib number is used * later to determine if the month to be displayed is here or * should be built on the fly with the generic routine */ memmove(scal, empty, MAXDAYS * sizeof(int)); scal[MAXDAYS] = month + year * 12; memmove(jcal, empty, MAXDAYS * sizeof(int)); jcal[MAXDAYS] = month + year * 12; /* * It doesn't matter what the actual month is when figuring * out if this is a leap year or not, just so long as February * gets the right number of days in it. */ mdays = days_in_month[g_leap_year(year, 3, 1)][month]; /* * Bounce back to the first "row" in the day array, and fill * in any days that actually occur. */ for (*diw %= 7; (*date - *done) <= mdays; (*date)++, (*diy)++) { /* * "date" doesn't get reset by the caller across calls * to this routine, so we can actually tell that we're * looking at April the 41st. Much easier than trying * to calculate the absolute julian day for a given * date and then checking that. */ if (*date < reform->date || *date >= reform->date + reform->missing_days) { scal[*diw] = *date - *done; jcal[*diw] = *diy; (*diw)++; } } *done += mdays; } int getnum(const char *p) { unsigned long result; char *ep; errno = 0; result = strtoul(p, &ep, 10); if (p[0] == '\0' || *ep != '\0') goto error; if (errno == ERANGE && result == ULONG_MAX) goto error; if (result > INT_MAX) goto error; return (int)result; error: errx(1, "bad number: %s", p); /*NOTREACHED*/ } void init_hilite(void) { const char *term; int errret; hilite++; if (!isatty(fileno(stdout))) return; term = getenv("TERM"); if (term == NULL) term = "dumb"; if (setupterm(term, fileno(stdout), &errret) != 0 && errret != 1) return; if (hilite > 1) md = enter_reverse_mode; else md = enter_bold_mode; me = exit_attribute_mode; if (me == NULL || md == NULL) md = me = NULL; } void usage(void) { (void)fprintf(stderr, "usage: cal [-3hjry] [-A after] [-B before] [-d day-of-week] " "[-R reform-spec]\n [[month] year]\n"); exit(1); }