Import macOS userland

adv_cmds-176
basic_cmds-55
bootstrap_cmds-116.100.1
developer_cmds-66
diskdev_cmds-667.40.1
doc_cmds-53.60.1
file_cmds-321.40.3
mail_cmds-35
misc_cmds-34
network_cmds-606.40.1
patch_cmds-17
remote_cmds-63
shell_cmds-216.60.1
system_cmds-880.60.2
text_cmds-106

1 files changed, 330 insertions, 0 deletions

diff --git a/misc_cmds/ncal/calendar.c b/misc_cmds/ncal/calendar.c
new file mode 100644
index 0000000..fca63ee
--- /dev/null
+++ b/misc_cmds/ncal/calendar.c
@@ -0,0 +1,330 @@
+/*-
+ * Copyright (c) 1997 Wolfgang Helbig
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include "calendar.h"
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+/*
+ * For each month tabulate the number of days elapsed in a year before the
+ * month. This assumes the internal date representation, where a year
+ * starts on March 1st. So we don't need a special table for leap years.
+ * But we do need a special table for the year 1582, since 10 days are
+ * deleted in October. This is month1s for the switch from Julian to
+ * Gregorian calendar.
+ */
+static int const month1[] =
+    {0, 31, 61, 92, 122, 153, 184, 214, 245, 275, 306, 337}; 
+   /*  M   A   M   J    J    A    S    O    N    D    J */
+static int const month1s[]=
+    {0, 31, 61, 92, 122, 153, 184, 214, 235, 265, 296, 327}; 
+
+typedef struct date date;
+
+/* The last day of Julian calendar, in internal and ndays representation */
+static int nswitch;	/* The last day of Julian calendar */
+static date jiswitch = {1582, 7, 3};
+
+static date	*date2idt(date *idt, date *dt);
+static date	*idt2date(date *dt, date *idt);
+static int	 ndaysji(date *idt);
+static int	 ndaysgi(date *idt);
+static int	 firstweek(int year);
+
+/*
+ * Compute the Julian date from the number of days elapsed since
+ * March 1st of year zero.
+ */
+date *
+jdate(int ndays, date *dt)
+{
+	date    idt;		/* Internal date representation */
+	int     r;		/* hold the rest of days */
+
+	/*
+	 * Compute the year by starting with an approximation not smaller
+	 * than the answer and using linear search for the greatest
+	 * year which does not begin after ndays.
+	 */
+	idt.y = ndays / 365;
+	idt.m = 0;
+	idt.d = 0;
+	while ((r = ndaysji(&idt)) > ndays)
+		idt.y--;
+	
+	/*
+	 * Set r to the days left in the year and compute the month by
+	 * linear search as the largest month that does not begin after r
+	 * days.
+	 */
+	r = ndays - r;
+	for (idt.m = 11; month1[idt.m] > r; idt.m--)
+		;
+
+	/* Compute the days left in the month */
+	idt.d = r - month1[idt.m];
+
+	/* return external representation of the date */
+	return (idt2date(dt, &idt));
+}
+
+/*
+ * Return the number of days since March 1st of the year zero.
+ * The date is given according to Julian calendar.
+ */
+int
+ndaysj(date *dt)
+{
+	date    idt;		/* Internal date representation */
+
+	if (date2idt(&idt, dt) == NULL)
+		return (-1);
+	else
+		return (ndaysji(&idt));
+}
+
+/*
+ * Same as above, where the Julian date is given in internal notation.
+ * This formula shows the beauty of this notation.
+ */
+static int
+ndaysji(date * idt)
+{
+
+	return (idt->d + month1[idt->m] + idt->y * 365 + idt->y / 4);
+}
+
+/*
+ * Compute the date according to the Gregorian calendar from the number of
+ * days since March 1st, year zero. The date computed will be Julian if it
+ * is older than 1582-10-05. This is the reverse of the function ndaysg().
+ */
+date   *
+gdate(int ndays, date *dt)
+{
+	int const *montht;	/* month-table */
+	date    idt;		/* for internal date representation */
+	int     r;		/* holds the rest of days */
+
+	/*
+	 * Compute the year by starting with an approximation not smaller
+	 * than the answer and search linearly for the greatest year not
+	 * starting after ndays.
+	 */
+	idt.y = ndays / 365;
+	idt.m = 0;
+	idt.d = 0;
+	while ((r = ndaysgi(&idt)) > ndays)
+		idt.y--;
+
+	/*
+	 * Set ndays to the number of days left and compute by linear
+	 * search the greatest month which does not start after ndays. We
+	 * use the table month1 which provides for each month the number
+	 * of days that elapsed in the year before that month. Here the
+	 * year 1582 is special, as 10 days are left out in October to
+	 * resynchronize the calendar with the earth's orbit. October 4th
+	 * 1582 is followed by October 15th 1582. We use the "switch"
+	 * table month1s for this year.
+	 */
+	ndays = ndays - r;
+	if (idt.y == 1582)
+		montht = month1s;
+	else
+		montht = month1;
+
+	for (idt.m = 11; montht[idt.m] > ndays; idt.m--)
+		;
+
+	idt.d = ndays - montht[idt.m]; /* the rest is the day in month */
+
+	/* Advance ten days deleted from October if after switch in Oct 1582 */
+	if (idt.y == jiswitch.y && idt.m == jiswitch.m && jiswitch.d < idt.d)
+		idt.d += 10;
+
+	/* return external representation of found date */
+	return (idt2date(dt, &idt));
+}
+
+/*
+ * Return the number of days since March 1st of the year zero. The date is
+ * assumed Gregorian if younger than 1582-10-04 and Julian otherwise. This
+ * is the reverse of gdate.
+ */
+int
+ndaysg(date *dt)
+{
+	date    idt;		/* Internal date representation */
+
+	if (date2idt(&idt, dt) == NULL)
+		return (-1);
+	return (ndaysgi(&idt));
+}
+
+/*
+ * Same as above, but with the Gregorian date given in internal
+ * representation.
+ */
+static int
+ndaysgi(date *idt)
+{
+	int     nd;		/* Number of days--return value */
+
+	/* Cache nswitch if not already done */
+	if (nswitch == 0)
+		nswitch = ndaysji(&jiswitch);
+
+	/*
+	 * Assume Julian calendar and adapt to Gregorian if necessary, i. e.
+	 * younger than nswitch. Gregori deleted
+	 * the ten days from Oct 5th to Oct 14th 1582.
+	 * Thereafter years which are multiples of 100 and not multiples
+	 * of 400 were not leap years anymore.
+	 * This makes the average length of a year
+	 * 365d +.25d - .01d + .0025d = 365.2425d. But the tropical
+	 * year measures 365.2422d. So in 10000/3 years we are
+	 * again one day ahead of the earth. Sigh :-)
+	 * (d is the average length of a day and tropical year is the
+	 * time from one spring point to the next.)
+	 */
+	if ((nd = ndaysji(idt)) == -1)
+		return (-1);
+	if (idt->y >= 1600)
+		nd = (nd - 10 - (idt->y - 1600) / 100 + (idt->y - 1600) / 400);
+	else if (nd > nswitch)
+		nd -= 10;
+	return (nd);
+}
+
+/*
+ * Compute the week number from the number of days since March 1st year 0.
+ * The weeks are numbered per year starting with 1. If the first
+ * week of a year includes at least four days of that year it is week 1,
+ * otherwise it gets the number of the last week of the previous year.
+ * The variable y will be filled with the year that contains the greater
+ * part of the week.
+ */
+int
+week(int nd, int *y)
+{
+	date    dt;
+	int     fw;		/* 1st day of week 1 of previous, this and
+				 * next year */
+	gdate(nd, &dt);
+	for (*y = dt.y + 1; nd < (fw = firstweek(*y)); (*y)--)
+		;
+	return ((nd - fw) / 7 + 1);
+}
+		
+/* return the first day of week 1 of year y */
+static int
+firstweek(int y)
+{
+	date idt;
+	int nd, wd;
+
+	idt.y = y - 1;   /* internal representation of y-1-1 */
+	idt.m = 10;
+	idt.d = 0;
+
+	nd = ndaysgi(&idt);
+	/*
+	 * If more than 3 days of this week are in the preceding year, the
+	 * next week is week 1 (and the next monday is the answer),
+	 * otherwise this week is week 1 and the last monday is the
+	 * answer.
+	 */
+	if ((wd = weekday(nd)) > 3)
+		return (nd - wd + 7);
+	else
+		return (nd - wd);
+}
+
+/* return the weekday (Mo = 0 .. Su = 6) */
+int
+weekday(int nd)
+{
+	date dmondaygi = {1997, 8, 16}; /* Internal repr. of 1997-11-17 */
+	static int nmonday;             /* ... which is a monday        */ 
+
+	/* Cache the daynumber of one monday */
+	if (nmonday == 0)
+		nmonday = ndaysgi(&dmondaygi);
+
+	/* return (nd - nmonday) modulo 7 which is the weekday */
+	nd = (nd - nmonday) % 7;
+	if (nd < 0)
+		return (nd + 7);
+	else
+		return (nd);
+}
+
+/*
+ * Convert a date to internal date representation: The year starts on
+ * March 1st, month and day numbering start at zero. E. g. March 1st of
+ * year zero is written as y=0, m=0, d=0.
+ */
+static date *
+date2idt(date *idt, date *dt)
+{
+
+	idt->d = dt->d - 1;
+	if (dt->m > 2) {
+		idt->m = dt->m - 3;
+		idt->y = dt->y;
+	} else {
+		idt->m = dt->m + 9;
+		idt->y = dt->y - 1;
+	}
+	if (idt->m < 0 || idt->m > 11 || idt->y < 0)
+		return (NULL);
+	else
+		return idt;
+}
+
+/* Reverse of date2idt */
+static date *
+idt2date(date *dt, date *idt)
+{
+
+	dt->d = idt->d + 1;
+	if (idt->m < 10) {
+		dt->m = idt->m + 3;
+		dt->y = idt->y;
+	} else {
+		dt->m = idt->m - 9;
+		dt->y = idt->y + 1;
+	}
+	if (dt->m < 1)
+		return (NULL);
+	else
+		return (dt);
+}