Initial Spring 2016 commit.

userland/testbin/factorial/Makefile

@@ -0,0 +1,11 @@
+# Makefile for factorial
+
+TOP=../../..
+.include "$(TOP)/mk/os161.config.mk"
+
+PROG=factorial
+SRCS=factorial.c
+BINDIR=/testbin
+
+.include "$(TOP)/mk/os161.prog.mk"
+

userland/testbin/factorial/factorial.c

@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) 2014
+ *	The President and Fellows of Harvard College.
+ *
+ * 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 UNIVERSITY 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 UNIVERSITY 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 <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <assert.h>
+#include <err.h>
+
+#define _PATH_SELF "/testbin/factorial"
+
+/*
+ * factorial - compute factorials by recursive exec
+ *
+ * External usage: factorial N
+ * (compute N!)
+ *
+ * Internal usage: factoral N M
+ * (compute N! * M)
+ */
+
+////////////////////////////////////////////////////////////
+// arithmetic
+
+/*
+ * We compute using binary-coded decimal integers where
+ * each byte contains the digit characters '0' through '9'.
+ * This is not exactly optimum for computation but it's
+ * perfect for sending numbers through execv.
+ */
+
+#define NUMSIZE 8191
+struct number {
+	char buf[NUMSIZE+1];	/* includes space for a null-terminator */
+	size_t first;		/* first valid digit */
+};
+
+static struct number scratch;
+
+static
+void
+number_init(struct number *n, const char *txt)
+{
+	size_t len, i;
+
+	len = strlen(txt);
+	if (len > NUMSIZE) {
+		warnx("%s", txt);
+		errx(1, "Number too large");
+	}
+	n->first = NUMSIZE - len;
+	strcpy(n->buf + n->first, txt);
+#if 0
+	for (i=0; i<n->first; i++) {
+		n->buf[i] = '0';
+	}
+#endif
+	for (i=n->first; i<NUMSIZE; i++) {
+		if (n->buf[i] < '0' || n->buf[i] > '9') {
+			warnx("%s", txt);
+			errx(1, "Number contained non-digit characters");
+		}
+	}
+	assert(n->buf[NUMSIZE] == 0);
+	while (n->first < NUMSIZE && n->buf[n->first] == '0') {
+		n->first++;
+	}
+}
+
+static
+char *
+number_get(struct number *n)
+{
+	size_t pos;
+
+	pos = n->first;
+	while (pos < NUMSIZE && n->buf[pos] == '0') {
+		pos++;
+	}
+	if (pos == NUMSIZE) {
+		pos--;
+		n->buf[pos] = '0';
+	}
+	return &n->buf[pos];
+}
+
+static
+void
+finishcarry(struct number *r, const struct number *b, size_t pos,
+	    unsigned carry)
+{
+	if (carry > 0 && b->first == 0) {
+		/* if b->first is 0, pos may now be 2^32-1 */
+		errx(1, "Overflow");
+	}
+	while (carry > 0) {
+		if (pos == 0) {
+			errx(1, "Overflow");
+		}
+		r->buf[pos--] = carry % 10 + '0';
+		carry = carry / 10;
+	}
+	r->first = pos + 1;
+}
+
+static
+void
+pluseq(struct number *r, const struct number *b)
+{
+	size_t pos;
+	unsigned an, bn, rn, carry;
+
+	carry = 0;
+	for (pos = NUMSIZE; pos-- > b->first; ) {
+		an = pos < r->first ? 0 : r->buf[pos] - '0';
+		bn = b->buf[pos] - '0';
+		rn = an + bn + carry;
+		r->buf[pos] = rn % 10 + '0';
+		carry = rn / 10;
+	}
+	finishcarry(r, b, pos, carry);
+}
+
+static
+void
+dec(struct number *r)
+{
+	size_t pos;
+
+	for (pos = NUMSIZE; pos-- > r->first; ) {
+		if (r->buf[pos] == '0') {
+			r->buf[pos] = '9';
+		}
+		else {
+			r->buf[pos]--;
+			return;
+		}
+	}
+	/* This should really not happen. */
+	errx(1, "Underflow");
+}
+
+static
+void
+multc(struct number *r, const struct number *a, unsigned bn, size_t offset)
+{
+	size_t pos;
+	unsigned an, rn, carry;
+
+	for (pos = NUMSIZE; pos-- > NUMSIZE - offset; ) {
+		r->buf[pos] = '0';
+	}
+	carry = 0;
+	for (pos = NUMSIZE; pos-- > a->first; ) {
+		an = a->buf[pos] - '0';
+		rn = an * bn + carry;
+		if (pos < offset) {
+			errx(1, "Overflow");
+		}
+		r->buf[pos - offset] = rn % 10 + '0';
+		carry = rn / 10;
+	}
+	if (carry > 0 && pos < offset) {
+		errx(1, "Overflow");
+	}
+	finishcarry(r, a, pos - offset, carry);
+}
+
+static
+void
+mult(struct number *r, const struct number *a, const struct number *b)
+{
+	unsigned offset;
+	size_t apos;
+
+	/* B should normally be the larger number */
+	if (a->first < b->first) {
+		mult(r, b, a);
+		return;
+	}
+
+	number_init(&scratch, "0");
+	offset = 0;
+	for (apos = NUMSIZE; apos-- > a->first; ) {
+		multc(&scratch, b, a->buf[apos] - '0', offset);
+		pluseq(r, &scratch);
+		offset++;
+	}
+}
+
+////////////////////////////////////////////////////////////
+// argv logic
+
+static
+void
+self(const char *arg1, const char *arg2)
+{
+	const char *args[4];
+
+	args[0] = _PATH_SELF;
+	args[1] = arg1;
+	args[2] = arg2;
+	args[3] = NULL;
+	execv(_PATH_SELF, (char **)args);
+	err(1, "execv");
+}
+
+static struct number n1, n2, multbuf;
+
+int
+main(int argc, char *argv[])
+{
+	if (argc == 0) {
+		/* Assume we've just been run from the menu. */
+		self("404", "1");
+	}
+	else if (argc == 2) {
+		self(argv[1], "1");
+	}
+	else if (argc == 3) {
+		if (!strcmp(argv[1], "1") || !strcmp(argv[1], "0")) {
+			printf("%s\n", argv[2]);
+		}
+		else {
+			number_init(&n1, argv[1]);
+			number_init(&n2, argv[2]);
+			number_init(&multbuf, "0");
+			mult(&multbuf, &n1, &n2);
+			dec(&n1);
+			self(number_get(&n1), number_get(&multbuf));
+		}
+	}
+	else {
+		warnx("Usage: factorial N");
+	}
+	return 0;
+}