/* cal - print a calendar Author: Maritn Minow */

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#define do3months domonth

#define IO_SUCCESS 0 /* Unix definitions */

#define IO_ERROR 1

#define EOS 0

#define ENTRY_SIZE 3 /* 3 bytes per value */

#define DAYS_PER_WEEK 7 /* Sunday, etc. */

#define WEEKS_PER_MONTH 6 /* Max. weeks in a month */

#define MONTHS_PER_LINE 3 /* Three months across */

#define MONTH_SPACE 3 /* Between each month */

char *badarg = {"Bad argument\n"};

char *how = {"Usage: cal [month] year\n"};

/* Calendar() stuffs data into layout[],

* output() copies from layout[] to outline[], (then trims blanks).

*/

char layout[MONTHS_PER_LINE][WEEKS_PER_MONTH][DAYS_PER_WEEK][ENTRY_SIZE];

char outline[(MONTHS_PER_LINE * DAYS_PER_WEEK * ENTRY_SIZE)

+ (MONTHS_PER_LINE * MONTH_SPACE)

+ 1];

char *weekday = " S M Tu W Th F S";

char *monthname[] = {

"???", /* No month 0 */

"Jan", "Feb", "Mar", "Apr", "May", "Jun",

"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"

};

_PROTOTYPE(int main, (int argc, char **argv));

_PROTOTYPE(void doyear, (int year));

_PROTOTYPE(void domonth, (int year, int month));

_PROTOTYPE(void output, (int nmonths));

_PROTOTYPE(void calendar, (int year, int month, int indx));

_PROTOTYPE(void usage, (char *s));

_PROTOTYPE(int date, (int year, int month, int week, int wday));

_PROTOTYPE(void setmonth, (int year, int month));

_PROTOTYPE(int getdate, (int week, int wday));

_PROTOTYPE(static int Jan1, (int year));

int main(argc, argv)

int argc;

char *argv[];

{

register int year;

register int arg1val;

int arg1len;

int arg2val;

if (argc <= 1) {

usage(how);

} else {

arg1val = atoi(argv[1]);

arg1len = strlen(argv[1]);

if (argc == 2) {

/* Only one argument, if small, it's a month. If

* large, it's a year. Note: cal 0082 Year

* 0082 cal 82 Year 0082 */

if (arg1len <= 2 && arg1val <= 12)

do3months(year, arg1val);

else

doyear(arg1val);

} else {

/* Two arguments, allow 1980 12 or 12 1980 */

arg2val = atoi(argv[2]);

if (arg1len > 2)

do3months(arg1val, arg2val);

else

do3months(arg2val, arg1val);

}

}

return(IO_SUCCESS);

}

void doyear(year)

int year;

/* Print the calendar for an entire year. */

{

register int month;

if (year < 1 || year > 9999) usage(badarg);

if (year < 100)

printf("\n\n\n 00%2d\n\n", year);

else

printf("\n\n\n%35d\n\n", year);

for (month = 1; month <= 12; month += MONTHS_PER_LINE) {

printf("%12s%23s%23s\n",

monthname[month],

monthname[month + 1],

monthname[month + 2]);

printf("%s %s %s\n", weekday, weekday, weekday);

calendar(year, month + 0, 0);

calendar(year, month + 1, 1);

calendar(year, month + 2, 2);

output(3);

#if MONTHS_PER_LINE != 3

#error "the above will not work"

#endif

}

printf("\n\n\n");

}

void domonth(year, month)

int year;

int month;

/* Do one specific month -- note: no longer used */

{

if (year < 1 || year > 9999) usage(badarg);

if (month <= 0 || month > 12) usage(badarg);

printf("%9s%5d\n\n%s\n", monthname[month], year, weekday);

calendar(year, month, 0);

output(1);

printf("\n\n");

}

void output(nmonths)

int nmonths; /* Number of months to do */

/* Clean up and output the text. */

{

register int week;

register int month;

register char *outp;

int i;

char tmpbuf[21], *p;

for (week = 0; week < WEEKS_PER_MONTH; week++) {

outp = outline;

for (month = 0; month < nmonths; month++) {

/* The -1 in the following removes the unwanted

* leading blank from the entry for Sunday. */

p = &layout[month][week][0][1];

for (i = 0; i < 20; i++) tmpbuf[i] = *p++;

tmpbuf[20] = 0;

sprintf(outp, "%s ", tmpbuf);

outp += (DAYS_PER_WEEK * ENTRY_SIZE) + MONTH_SPACE - 1;

}

while (outp > outline && outp[-1] == ' ') outp--;

*outp = EOS;

printf("%s\n", outline);

}

}

void calendar(year, month, indx)

int year;

int month;

int indx; /* Which of the three months */

/* Actually build the calendar for this month. */

{

register char *tp;

int week;

register int wday;

register int today;

setmonth(year, month);

for (week = 0; week < WEEKS_PER_MONTH; week++) {

for (wday = 0; wday < DAYS_PER_WEEK; wday++) {

tp = &layout[indx][week][wday][0];

*tp++ = ' ';

today = getdate(week, wday);

if (today <= 0) {

*tp++ = ' ';

*tp++ = ' ';

} else if (today < 10) {

*tp++ = ' ';

*tp = (today + '0');

} else {

*tp++ = (today / 10) + '0';

*tp = (today % 10) + '0';

}

}

}

}

void usage(s)

char *s;

{

/* Fatal parameter error. */

fprintf(stderr, "%s", s);

exit(IO_ERROR);

}

/* Calendar routines, intended for eventual porting to TeX

*

* date(year, month, week, wday)

* Returns the date on this week (0 is first, 5 last possible)

* and day of the week (Sunday == 0)

* Note: January is month 1.

*

* setmonth(year, month)

* Parameters are as above, sets getdate() for this month.

*

* int

* getdate(week, wday)

* Parameters are as above, uses the data set by setmonth()

*/

/* This structure is used to pass data between setmonth() and getdate().

* It needs considerable expansion if the Julian->Gregorian change is

* to be extended to other countries.

*/

static struct {

int this_month; /* month number used in 1752 checking */

int feb; /* Days in February for this month */

int sept; /* Days in September for this month */

int days_in_month; /* Number of days in this month */

int dow_first; /* Day of week of the 1st day in month */

} info;

static int day_month[] = { /* 30 days hath September... */

0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31

};

int date(year, month, week, wday)

int year; /* Calendar date being computed */

int month; /* January == 1 */

int week; /* Week in the month 0..5 inclusive */

int wday; /* Weekday, Sunday == 0 */

/* Return the date of the month that fell on this week and weekday.

* Return zero if it's out of range.

*/

{

setmonth(year, month);

return(getdate(week, wday));

}

void setmonth(year, month)

int year; /* Year to compute */

int month; /* Month, January is month 1 */

/* Setup the parameters needed to compute this month

* (stored in the info structure).

*/

{

register int i;

if (month < 1 || month > 12) {/* Verify caller's parameters */

info.days_in_month = 0; /* Garbage flag */

return;

}

info.this_month = month; /* used in 1752 checking */

info.dow_first = Jan1(year); /* Day of January 1st for now */

info.feb = 29; /* Assume leap year */

info.sept = 30; /* Assume normal year */

/* Determine whether it's an ordinary year, a leap year or the

* magical calendar switch year of 1752. */

switch ((Jan1(year + 1) + 7 - info.dow_first) % 7) {

case 1: /* Not a leap year */

info.feb = 28;

case 2: /* Ordinary leap year */

break;

default: /* The magical moment arrives */

info.sept = 19; /* 19 days hath September */

break;

}

info.days_in_month =

(month == 2) ? info.feb

: (month == 9) ? info.sept

: day_month[month];

for (i = 1; i < month; i++) {

switch (i) { /* Special months? */

case 2: /* February */

info.dow_first += info.feb;

break;

case 9: info.dow_first += info.sept; break;

default:

info.dow_first += day_month[i];

break;

}

}

info.dow_first %= 7; /* Now it's Sunday to Saturday */

}

int getdate(week, wday)

int week;

int wday;

{

register int today;

/* Get a first guess at today's date and make sure it's in range. */

today = (week * 7) + wday - info.dow_first + 1;

if (today <= 0 || today > info.days_in_month)

return(0);

else if (info.sept == 19 && info.this_month == 9

&& today >= 3) /* The magical month? */

return(today + 11); /* If so, some dates changed */

else /* Otherwise, */

return(today); /* Return the date */

}

static int Jan1(year)

int year;

/* Return day of the week for Jan 1 of the specified year. */

{

register int day;

day = year + 4 + ((year + 3) / 4); /* Julian Calendar */

if (year > 1800) { /* If it's recent, do */

day -= ((year - 1701) / 100); /* Clavian correction */

day += ((year - 1601) / 400); /* Gregorian correction */

}

if (year > 1752) /* Adjust for Gregorian */

day += 3; /* calendar */

return(day % 7);

}