Add original unix v6

source/s2/mail.c

@@ -0,0 +1,281 @@
+#
+/* mail command usage
+	mail
+		prints your mail
+	mail people
+		sends standard input to people
+ */
+
+#define	SIGINT	2
+
+struct	utmp {
+	char	name[8];
+	char	tty;
+	char	pad1;
+	int	ltime[2];
+	int	pad2;
+};
+
+struct	passwd {
+	char	*pw_name;
+	char	*pw_passwd;
+	int	pw_uid;
+	int	pw_gid;
+	char	*pw_gecos;
+	char	*pw_dir;
+	char	*pw_shell;
+};
+
+char	lettmp[] "/tmp/maxxxxx";
+char	preptmp[] "/tmp/mbxxxxx";
+int	pwfil;
+
+main(argc, argv)
+char **argv;
+{
+	register me;
+	extern fout;
+	register struct passwd *p;
+	register char *cp;
+	static struct utmp ubuf;
+	int uf;
+
+	maketemp();
+	if (argc==1 || argc==2 && argv[1][0]=='-') {
+		printmail(argc, argv);
+		delexit();
+	}
+	signal(SIGINT, delexit);
+	fout = creat(lettmp, 0600);
+	if (((me=ttyn(1))!='x' || (me=ttyn(2))!='x')
+	 && (uf = open("/etc/utmp", 0)) > 0) {
+		while (read(uf, &ubuf, sizeof ubuf) == sizeof ubuf)
+			if (ubuf.tty == me) {
+				ubuf.name[8] = ' ';
+				close(uf);
+				for (cp=ubuf.name; *cp++!=' ';);
+				*--cp = 0;
+				bulkmail(argc, argv, ubuf.name);
+			}
+	}
+	me = getuid() & 0377;
+	setpw();
+	for (;;)
+		if ((p = getpwent()) && p->pw_uid == me)
+			bulkmail(argc, argv, p->pw_name);
+	fout = 1;
+	printf("Who are you?\n");
+	delexit();
+}
+
+printmail(argc, argv)
+char **argv;
+{
+	extern fin, fout;
+	register n, c, f;
+
+	if (fopen(".mail", &fin)>=0 && (c = getchar())) {
+		do {
+			putchar(c);
+		} while (c = getchar());
+		close(fin);
+		c = 'y';
+		if (argc<2) {
+			if (ttyn(0)!='x') {
+				printf("Save?");
+				fin = 0;
+				c = getchar();
+			}
+		} else
+			c = argv[1][1];
+		if (c=='y') {
+			prepend(".mail", "mbox");
+			printf("Saved mail in 'mbox'\n");
+		}
+		close(creat(".mail"));
+	} else
+		printf("No mail.\n");
+}
+
+bulkmail(argc, argv, from)
+char **argv, *from;
+{
+	extern fin, fout;
+	int tbuf[2];
+	register c;
+
+	fin = 0;
+	(&fin)[1] = 0;
+	time(tbuf);
+	printf("From %s %s", from, ctime(tbuf));
+	while (c = getchar())
+		putchar(c);
+	putchar('\n');
+	flush();
+	close(fout);
+	while (--argc > 0)
+		sendto(*++argv);
+	delexit();
+}
+
+sendto(person)
+char *person;
+{
+	static saved;
+	extern fout;
+	extern fin;
+	register struct passwd *p;
+
+	setpw();
+	while (p = getpwent()) {
+		if (equal(p->pw_name, person)) {
+			if (prepend(lettmp, cat(p->pw_dir, "/.mail"))==0)
+				break;
+			return;
+		}
+	}
+	fout = 1;
+	flush();
+	printf("Can't send to %s.\n", person);
+	if (ttyn(0)!='x' && saved==0) {
+		unlink("dead.letter");
+		saved++;
+		printf("Letter saved in 'dead.letter'\n");
+		prepend(lettmp, "dead.letter");
+	}
+}
+
+prepend(from, to)
+char *from, *to;
+{
+	extern int fin, fout;
+
+	fcreat(preptmp, &fout);
+	fopen(from, &fin);
+	while (putchar(getchar()));
+	close(fin);
+	fopen(to, &fin);
+	while (putchar(getchar()));
+	close(fin);
+	flush();
+	close(fout);
+	if (fcreat(to, &fout) < 0) {
+		fout = 1;
+		return(0);
+	}
+	fopen(preptmp, &fin);
+	while(putchar(getchar()));
+	flush();
+	close(fout);
+	close(fin);
+	fout = 1;
+	return(1);
+}
+
+setpw()
+{
+	extern fin;
+
+	if (pwfil == 0) {
+		fopen("/etc/passwd", &fin);
+		pwfil = fin;
+	} else
+		fin = pwfil;
+	(&fin)[1] = 0;
+	seek(fin, 0, 0);
+}
+
+getpwent()
+{
+	register char *p;
+	register c;
+	static struct passwd passwd;
+	static char line[100];
+	extern fin;
+
+	p = line;
+	while((c=getchar()) != '\n') {
+		if(c <= 0)
+			return(0);
+		if(p < line+98)
+			*p++ = c;
+	}
+	*p = 0;
+	p = line;
+	passwd.pw_name = p;
+	p = pwskip(p);
+	passwd.pw_passwd = p;
+	p = pwskip(p);
+	passwd.pw_uid = atoi(p);
+	p = pwskip(p);
+	passwd.pw_gid = atoi(p);
+	p = pwskip(p);
+	passwd.pw_gecos = p;
+	p = pwskip(p);
+	passwd.pw_dir = p;
+	p = pwskip(p);
+	passwd.pw_shell = p;
+	return(&passwd);
+}
+
+pwskip(ap)
+char *ap;
+{
+	register char *p;
+
+	p = ap;
+	while(*p != ':') {
+		if(*p == 0)
+			return(p);
+		p++;
+	}
+	*p++ = 0;
+	return(p);
+}
+
+delexit()
+{
+	unlink(lettmp);
+	unlink(preptmp);
+	exit(0);
+}
+
+maketemp()
+{
+	int i, pid, d;
+
+	pid = getpid();
+	for (i=11; i>=7; --i) {
+		d = (pid&07) + '0';
+		lettmp[i] = d;
+		preptmp[i] = d;
+		pid =>> 3;
+	}
+}
+
+equal(as1, as2)
+{
+	register char *s1, *s2;
+
+	s1 = as1;
+	s2 = as2;
+	while (*s1++ == *s2)
+		if (*s2++ == 0)
+			return(1);
+	return(0);
+}
+
+cat(ap1, ap2)
+char *ap1, *ap2;
+{
+	register char *p1, *p2;
+	static char fn[32];
+
+	p1 = ap1;
+	p2 = fn;
+	while (*p2++ = *p1++);
+	p2--;
+	p1 = ap2;
+	while (*p2++ = *p1++);
+	return(fn);
+}

source/s2/mesg.c

@@ -0,0 +1,49 @@
+/*
+ * mesg -- set current tty to accept or
+ *	forbid write permission.
+ *
+ *	mesg [y] [n]
+ *		y allow messages
+ *		n forbid messages
+ */
+
+int	sbuf[40];
+
+main(argc, argv)
+char *argv[];
+{
+	register char *tty;
+
+	tty = "/dev/ttyx";
+	tty[8] = ttyn(1);
+	if(stat(tty, sbuf) < 0) {
+		write(2, "cannot stat\n", 12);
+		exit(1);
+	}
+	if(argc < 2) {
+		if(sbuf[2] & 02)
+			goto no;
+		goto yes;
+	}
+	if(*argv[1] == 'y')
+		goto yes;
+
+no:
+	if(chmod(tty, 0600) < 0)
+		goto bad;
+	goto was;
+
+yes:
+	if(chmod(tty, 0622) < 0)
+		goto bad;
+
+was:
+	if(sbuf[2] & 02)
+		write(2, "was y\n", 6); else
+		write(2, "was n\n", 6);
+	exit(0);
+
+bad:
+	write(2, "cannot change mode\n", 19);
+	exit(1);
+}

source/s2/mkdir.s

@@ -0,0 +1,91 @@
+/ makdir -- make a directory
+
+	sys	getuid
+	mov	r0,uid
+	mov	sp,r5
+	tst	(r5)+
+
+loop:
+	tst	(r5)+
+	dec	(sp)
+	bgt	1f
+	sys	exit
+1:
+	mov	(r5),r0
+	mov	$buf1,r1
+	mov	$buf2,r2
+	clr	r3
+1:
+	movb	(r0)+,r4
+	beq	2f
+	movb	r4,(r1)+
+	movb	r4,(r2)+
+	cmpb	r4,$'/
+	bne	1b
+	mov	r2,r3
+	br	1b
+2:
+	movb	$'/,(r1)+
+	movb	$'.,(r1)+
+	clrb	(r1)
+	mov	$dot,dir
+	tst	r3
+	beq	1f
+	mov	$buf2,dir
+	clrb	(r3)
+	cmp	r3,$buf2+1
+	beq	1f
+	clrb	-(r3)		/ ???
+1:
+	tstb	uid
+	beq	2f
+	sys	stat; dir:..; stbuf	/ status of parent dir
+	bes	error
+	mov	stbuf+4,r0
+	cmpb	uid,stbuf+7
+	bne	1f
+	ash	$-6,r0
+1:
+	ror	r0
+	ror	r0
+	bcc	error			/ no write permission in parent
+2:
+	mov	(r5),0f
+	sys	makdir; 0:..; 140777; 0
+	bes	error			/ prob already exists
+	mov	(r5),0f
+	sys	chown; 0:..; uid:..
+	mov	(r5),0f
+	sys	link; 0:..; buf1
+	bes	error
+	movb	$'.,(r1)+
+	clrb	(r1)
+	mov	dir,0f
+	sys	link; 0:..; buf1
+	bec	loop
+
+error:
+	mov	(r5),r0
+	mov	r0,0f
+	clr	0f+2
+1:
+	tstb	(r0)+
+	beq	1f
+	inc	0f+2
+	br	1b
+1:
+	mov	$1,r0
+	sys	write; 0:..; ..
+	mov	$1,r0
+	sys	write; ques; 3
+	br	loop
+
+dot:	<.\0>
+ques:	< ?\n>
+	.even
+
+.bss
+buf1:	.=.+100.
+buf2:	.=.+100.
+stbuf:	.=.+40.
+

source/s2/mkfs.c

@@ -0,0 +1,504 @@
+#
+struct
+{
+	char	*s_isize;
+	char	*s_fsize;
+	int	s_nfree;
+	int	s_free[100];
+	int	s_ninode;
+	int	s_inode[100];
+	char	s_flock;
+	char	s_ilock;
+	char	s_fmod;
+	int	s_time[2];
+} filsys;
+
+struct inode
+{
+	int	i_number;
+	int	i_mode;
+	char	i_nlink;
+	char	i_uid;
+	char	i_gid;
+	char	i_size0;
+	char	*i_size1;
+	int	i_addr[8];
+	int	i_time[4];
+};
+
+/* modes */
+#define	IALLOC	0100000
+#define	IFMT	060000
+#define		IFDIR	040000
+#define		IFCHR	020000
+#define		IFBLK	060000
+#define	ILARG	010000
+#define	ISUID	04000
+#define	ISGID	02000
+#define	IREAD	0400
+#define	IWRITE	0200
+#define	IEXEC	0100
+
+int	utime[2];
+int	fin;
+int	fsi;
+int	fso;
+char	*charp;
+int	buf[256];
+char	string[50];
+char	*fsys;
+char	*proto;
+int	f_n	1;
+int	f_m	1;
+
+main(argc, argv)
+char **argv;
+{
+	int f, n;
+
+	/*
+	 * open relevent files
+	 */
+
+	time(utime);
+	if(argc != 3) {
+		printf("arg count\n");
+		exit();
+	}
+	fsys = argv[1];
+	for(n=0; f=fsys[n+1]; n++)
+	if(fsys[n] == 'r') {
+		if(f == 'k') {
+			f_n = 24;
+			f_m = 3;
+		}
+		if(f == 'p') {
+			f_n = 10;
+			f_m = 4;
+		}
+	}
+	proto = argv[2];
+	fso = creat(fsys, 0666);
+	if(fso < 0) {
+		printf("%s: cannot create\n", fsys);
+		exit();
+	}
+	fsi = open(fsys, 0);
+	if(fsi < 0) {
+		printf("%s: cannot open\n", fsys);
+		exit();
+	}
+	fin = open(proto, 0);
+	if(fin < 0) {
+		n = 0;
+		for(f=0; proto[f]; f++) {
+			if(proto[f]<'0' || proto[f]>'9') {
+				printf("%s: cannot open\n", proto);
+				exit();
+			}
+			n = n*10 + proto[f]-'0';
+		}
+		filsys.s_fsize = n;
+		filsys.s_isize = ldiv(0, n, 43+ldiv(0, n, 1000));
+		printf("isize = %d\n", filsys.s_isize);
+		if(f_n != 1)
+			printf("free list %d/%d\n", f_m, f_n);
+		charp = "d--777 0 0 $ ";
+		goto f3;
+	}
+
+	/*
+	 * get name of boot load program
+	 * and read onto block 0
+	 */
+
+	getstr();
+	f = open(string, 0);
+	if(f < 0) {
+		printf("%s: cannot  open init\n", string);
+		goto f2;
+	}
+	read(f, buf, 020);
+	if(buf[0] != 0407) {
+		printf("%s: bad format\n", string);
+		goto f1;
+	}
+	n = buf[1]+buf[2];
+	if(n > 512) {
+		printf("%s: too big\n", string);
+		goto f1;
+	}
+	read(f, buf, n);
+	wtfs(0, buf);
+
+f1:
+	close(f);
+
+	/*
+	 * get total disk size
+	 * and inode block size
+	 */
+
+f2:
+	filsys.s_fsize = getnum();
+	filsys.s_isize = getnum();
+
+f3:
+	if(filsys.s_isize > filsys.s_fsize ||
+	   filsys.s_fsize-filsys.s_isize-2 < filsys.s_isize) {
+		printf("%l/%l: bad ratio\n", filsys.s_fsize, filsys.s_isize);
+		exit();
+	}
+	bflist();
+
+	/*
+	 * initialize files
+	 */
+
+	for(n=0; n<256; n++)
+		buf[n] = 0;
+	for(n=0; n!=filsys.s_isize; n++)
+		wtfs(n+2, buf);
+	cfile(0);
+
+	/*
+	 * write out super block
+	 */
+
+	for(n=0; n<256; n++)
+		buf[n] = 0;
+	filsys.s_time[0] = utime[0];
+	filsys.s_time[1] = utime[1];
+	wtfs(1, &filsys);
+}
+
+cfile(par)
+struct inode *par;
+{
+	struct inode in;
+	int db[256], ib[256];
+	int dbc, ibc;
+	static ino;
+	int i, f, *p1, *p2;
+
+	/*
+	 * get mode, uid and gid
+	 */
+
+	getstr();
+	in.i_mode = IALLOC;
+	in.i_mode =| gmode(string[0], "bcd", IFBLK, IFCHR, IFDIR);
+	in.i_mode =| gmode(string[1], "u", ISUID);
+	in.i_mode =| gmode(string[2], "g", ISGID);
+	for(i=3; i<6; i++) {
+		if(string[i]<'0' || string[i]>'7') {
+			printf("%c/%s: bad digit\n", string[i], string);
+			exit();
+		}
+		in.i_mode =| (string[i]-'0')<<(15-3*i);
+	}
+	in.i_uid = getnum();
+	in.i_gid = getnum();
+
+	/*
+	 * general initialization prior to
+	 * switching on format
+	 */
+
+	ino++;
+	in.i_number = ino;
+	if(ldiv(0, ino, 16) > filsys.s_isize) {
+		printf("too many inodes\n");
+		exit();
+	}
+	in.i_nlink = 1;
+	in.i_size0 = 0;
+	in.i_size1 = 0;
+	for(i=0; i<8; i++)
+		in.i_addr[i] = 0;
+	for(i=0; i<256; i++) {
+		db[i] = 0;
+		ib[i] = 0;
+	}
+	if(par == 0) {
+		par = &in;
+		in.i_nlink--;
+	}
+	dbc = 0;
+	ibc = 0;
+	switch(in.i_mode&IFMT) {
+
+	case 0:
+		/*
+		 * regular file
+		 * contents is a file name
+		 */
+
+		getstr();
+		f = open(string, 0);
+		if(f < 0) {
+			printf("%s: cannot open\n", string);
+			break;
+		}
+		while((i=read(f, db, 512)) > 0) {
+			in.i_size1 =+ i;
+			newblk(&dbc, db, &ibc, ib);
+		}
+		close(f);
+		break;
+
+	case IFBLK:
+	case IFCHR:
+		/*
+		 * special file
+		 * content is maj/min types
+		 */
+
+		in.i_addr[0] = getnum()<<8;
+		in.i_addr[0] =| getnum();
+		break;
+
+	case IFDIR:
+		/*
+		 * directory
+		 * put in extra links
+		 * call recursively until
+		 * name of "$" found
+		 */
+
+		par->i_nlink++;
+		entry(par->i_number, "..", &dbc, db, &ibc, ib);
+		in.i_nlink++;
+		entry(in.i_number, ".", &dbc, db, &ibc, ib);
+		in.i_size1 = 32;
+		for(;;) {
+			getstr();
+			if(string[0]=='$' && string[1]=='\0')
+				break;
+			entry(ino+1, string, &dbc, db, &ibc, ib);
+			in.i_size1 =+ 16;
+			cfile(&in);
+		}
+		break;
+	}
+	if(dbc != 0)
+		newblk(&dbc, db, &ibc, ib);
+	if(ibc > 8) {
+		in.i_mode =| ILARG;
+		dbc = alloc();
+		wtfs(dbc, ib);
+		in.i_addr[0] = dbc;
+	} else
+	for(i=0; i<ibc; i++)
+		in.i_addr[i] = ib[i];
+	in.i_time[0] = in.i_time[2] = utime[0];
+	in.i_time[1] = in.i_time[3] = utime[1];
+	i = in.i_number + 31;
+	dbc = ldiv(0, i, 16);
+	p1 = &buf[lrem(0, i, 16)*16];
+	p2 = &in.i_mode;
+	rdfs(dbc, buf);
+	for(i=0; i<16; i++)
+		*p1++ = *p2++;
+	wtfs(dbc, buf);
+}
+
+gmode(c, s, m0, m1, m2, m3)
+char c, *s;
+{
+	int i;
+
+	for(i=0; s[i]!='\0'; i++)
+		if(c == s[i])
+			return((&m0)[i]);
+	if(c == '-')
+		return(0);
+	printf("%c/%s: bad mode\n", c, string);
+	exit();
+}
+
+getnum()
+{
+	int n, i;
+
+	getstr();
+	n = 0;
+	i = 0;
+	for(i=0; string[i]!='\0'; i++) {
+		if(string[i]<'0' || string[i]>'9') {
+			printf("%s: bad number\n", string);
+			exit();
+		}
+		n = n*10 + string[i] - '0';
+	}
+	return(n);
+}
+
+getstr()
+{
+	int i, c;
+
+loop:
+	switch(c=getch()) {
+
+	case ' ':
+	case '\t':
+	case '\n':
+		goto loop;
+
+	case '\0':
+		printf("EOF\n");
+		exit();
+
+	case ':':
+		while(getch() != '\n');
+		goto loop;
+
+	}
+	i = 0;
+
+	do {
+		string[i++] = c;
+		c = getch();
+	} while(c!=' '&&c!='\t'&&c!='\n'&&c!='\0');
+	string[i] = '\0';
+}
+
+rdfs(bno, bf)
+{
+	int n;
+
+	seek(fsi, bno, 3);
+	n = read(fsi, bf, 512);
+	if(n != 512) {
+		printf("read error: %l\n", bno);
+		exit();
+	}
+}
+
+wtfs(bno, bf)
+{
+	int n;
+
+	seek(fso, bno, 3);
+	n = write(fso, bf, 512);
+	if(n != 512) {
+		printf("write error: %l\n", bno);
+		exit();
+	}
+}
+
+alloc()
+{
+	int bno, i;
+
+	filsys.s_nfree--;
+	bno = filsys.s_free[filsys.s_nfree];
+	filsys.s_free[filsys.s_nfree] = 0;
+	if(bno == 0) {
+		printf("out of free space\n");
+		exit();
+	}
+	if(filsys.s_nfree <= 0) {
+		rdfs(bno, buf);
+		filsys.s_nfree = buf[0];
+		for(i=0; i<100; i++)
+			filsys.s_free[i] = buf[i+1];
+	}
+	return(bno);
+}
+
+free(bno)
+{
+	int i;
+
+	if(filsys.s_nfree >= 100) {
+		buf[0] = filsys.s_nfree;
+		for(i=0; i<100; i++)
+			buf[i+1] = filsys.s_free[i];
+		wtfs(bno, buf);
+		filsys.s_nfree = 0;
+	}
+	filsys.s_free[filsys.s_nfree] = bno;
+	filsys.s_nfree++;
+}
+
+entry(ino, str, adbc, db, aibc, ib)
+char *str;
+int *adbc, *db, *aibc, *ib;
+{
+	char *s;
+	int i;
+
+	db[*adbc] = ino;
+	(*adbc)++;
+	s = &db[*adbc];
+	for(i=0; i<14; i++) {
+		*s++ = *str;
+		if(*str != '\0')
+			str++;
+	}
+	*adbc =+ 7;
+	if(*adbc >= 256)
+		newblk(adbc, db, aibc, ib);
+}
+
+newblk(adbc, db, aibc, ib)
+int *adbc, *db, *aibc, *ib;
+{
+	int bno, i;
+
+	bno = alloc();
+	wtfs(bno, db);
+	for(i=0; i<256; i++)
+		db[i] = 0;
+	*adbc = 0;
+	ib[*aibc] = bno;
+	(*aibc)++;
+	if(*aibc >= 256) {
+		printf("indirect block full\n");
+		exit();
+	}
+}
+
+getch()
+{
+
+	if(charp)
+		return(*charp++);
+	return(getchar());
+}
+
+bflist()
+{
+	char flg[100], adr[100];
+	register i, j;
+	char *low, *high;
+
+	if(f_n > 100)
+		f_n = 100;
+	for(i=0; i<f_n; i++)
+		flg[i] = 0;
+	i = 0;
+	for(j=0; j<f_n; j++) {
+		while(flg[i])
+			i = (i+1)%f_n;
+		adr[j] = i;
+		flg[i]++;
+		i = (i+f_m)%f_n;
+	}
+
+	high = filsys.s_fsize-1;
+	low = filsys.s_isize+2;
+	free(0);
+	for(i=high; lrem(0,i+1,f_n); i--) {
+		if(i < low)
+			break;
+		free(i);
+	}
+	for(; i >= low+f_n; i =- f_n)
+		for(j=0; j<f_n; j++)
+			free(i-adr[j]);
+	for(;i >= low; i--)
+		free(i);
+}

source/s2/mknod.c

@@ -0,0 +1,42 @@
+main(argc, argv)
+int argc;
+char **argv;
+{
+	int m, a, b;
+
+	if(argc != 5) {
+		printf("arg count\n");
+		goto usage;
+	}
+	if(*argv[2] == 'b')
+		m = 0160666; else
+	if(*argv[2] == 'c')
+		m = 0120666; else
+		goto usage;
+	a = number(argv[3]);
+	if(a < 0)
+		goto usage;
+	b = number(argv[4]);
+	if(b < 0)
+		goto usage;
+	if(mknod(argv[1], m, (a<<8)|b) < 0)
+		perror("mknod");
+	exit();
+
+usage:
+	printf("usage: mknod name b/c major minor\n");
+}
+
+number(s)
+char *s;
+{
+	int n, c;
+
+	n = 0;
+	while(c = *s++) {
+		if(c<'0' || c>'9')
+			return(-1);
+		n = n*10 + c-'0';
+	}
+	return(n);
+}

source/s2/mount.c

@@ -0,0 +1,62 @@
+#define	NMOUNT	16
+#define	NAMSIZ	32
+
+struct mtab {
+	char	file[NAMSIZ];
+	char	spec[NAMSIZ];
+} mtab[NMOUNT];
+
+main(argc, argv)
+char **argv;
+{
+	register int ro;
+	register struct mtab *mp;
+	register char *np;
+	int n, mf;
+
+	mf = open("/etc/mtab", 0);
+	read(mf, mtab, NMOUNT*2*NAMSIZ);
+	if (argc==1) {
+		for (mp = mtab; mp < &mtab[NMOUNT]; mp++)
+			if (mp->file[0])
+				printf("%s on %s\n", mp->spec, mp->file);
+		return;
+	}
+	if(argc < 3) {
+		printf("arg count\n");
+		return;
+	}
+	ro = 0;
+	if(argc > 3)
+		ro++;
+	if(mount(argv[1], argv[2], ro) < 0) {
+		perror("mount");
+		return;
+	}
+	np = argv[1];
+	while(*np++)
+		;
+	np--;
+	while(*--np == '/')
+		*np = '\0';
+	while(np > argv[1] && *--np != '/')
+		;
+	if(*np == '/')
+		np++;
+	argv[1] = np;
+	for (mp = mtab; mp < &mtab[NMOUNT]; mp++) {
+		if (mp->file[0] == 0) {
+			for (np = mp->spec; np < &mp->spec[NAMSIZ-1];)
+				if ((*np++ = *argv[1]++) == 0)
+					argv[1]--;
+			for (np = mp->file; np < &mp->file[NAMSIZ-1];)
+				if ((*np++ = *argv[2]++) == 0)
+					argv[2]--;
+			mp = &mtab[NMOUNT];
+			while ((--mp)->file[0] == 0);
+			mf = creat("/etc/mtab", 0644);
+			write(mf, mtab, (mp-mtab+1)*2*NAMSIZ);
+			return;
+		}
+	}
+}

source/s2/mv.c

@@ -0,0 +1,177 @@
+/*
+mv [-d] file1 file2
+
+unlink file2
+link file1 file2
+unlink file1
+*/
+int stbuf[42];
+struct sbuf {
+int dev;
+int inum;
+int imode;
+char nlink;
+char uid;
+char gid;
+char siz0;
+char siz1;
+int addr[8];
+int adate[2];
+int mdate[2];
+};
+char strbuf[70];
+
+main(argc,argv)
+int argc;
+char *argv[];
+{
+char **argp;
+char *argp1, *argp2, *argp3, *argp4;
+char *p, *p1, *p2;
+char place[100];
+int i;
+int status;
+int b;
+argp = argv;
+/*
+	check for correct number
+	of arguments
+*/
+if(argc != 3){
+	write(1,"Usage: mv name1 name2\n",22);
+	exit();
+}
+/*
+	is there anything to do?
+*/
+argp3 = argp[1];
+argp4 = argp[2];
+if(stat(argp[1], stbuf) < 0){
+	write(1,"Source file non-existent\n",25);
+	exit();
+}
+/*
+	yes, there is a source.
+	check whether file or directory
+*/
+if((stbuf[0].imode & 060000) == 040000){
+/*
+	The source is a directory, so
+	we do lots of checking and
+	messing around so as not to get
+	into trouble.  This patch of
+	code contains administrative
+	policies rather than system
+	restrictions.
+*/
+	if(stat(argp[2], stbuf) >= 0){
+		write(1,"Directory target exists.\n",25);
+		exit();
+	}
+	argp1 = argp[1];
+	argp2 = argp[2];
+	while(*argp1 == *argp2){
+		argp1++;
+		if(*argp2++ == 0){
+			write(1,"???\n",4);
+			exit();
+		}
+	}
+	while(*argp1)if(*argp1++ == '/'){
+		write(1,"Directory rename only\n",22);
+		exit();
+	}
+	while(*argp2)if(*argp2++ == '/'){
+		write(1,"Directory rename only\n",22);
+		exit();
+	}
+	if(*--argp1 == '.'){
+		write(1,"values of B will give rise to dom!\n",37);
+		exit();
+	}
+}else{
+/*
+	the source is a file.
+*/
+	setuid(getuid());
+	if(stat(argp4, &stbuf[2]) >= 0){
+		if((stbuf[2].imode & 060000) == 040000){
+			argp2 = strbuf;
+			while(*argp2++ = *argp4++);
+			argp2[-1] = '/';
+			argp4 = argp[1];
+			argp1 = argp[1];
+			while(*argp4)
+				if(*argp4++ == '/')
+					argp1 = argp4;
+			while(*argp2++ = *argp1++);
+			argp4 = strbuf;
+		}
+		if(stat(argp4, &stbuf[2]) >= 0){
+			if((stbuf[0]==stbuf[2]) && (stbuf[1]==stbuf[3])){
+				write(1,"Files are identical.\n",21);
+				exit();
+			}
+			if((getuid()&0377) == stbuf[2].uid)
+				b = 0200; else
+			if((getgid()&0377) == stbuf[2].gid)
+				b = 020; else
+				b = 02;
+			if((stbuf[2].imode & b) == 0) {
+				printf("%s: %o mode ", argp4,
+					stbuf[2].imode & 07777);
+				i = b = getchar();
+				while(b != '\n' && b != '\0')
+					b = getchar();
+				if(i != 'y')
+					exit();
+			}
+			if(unlink(argp4) < 0){
+				write(1,"Cannot remove target file.\n",27);
+				exit();
+			}
+		}
+	}
+}
+if(link(argp3, argp4) < 0){
+	i = fork();
+	if(i == -1){
+		write(1,"Try again.\n",11);
+		exit();
+	}
+	if(i){
+		while(wait(&status) != i);
+	}else{
+		p = place;
+		p1 = p;
+		while(*p++ = *argp3++);
+		p2 = p;
+		while(*p++ = *argp4++);
+		execl("/bin/cp","cp", p1, p2, 0);
+		write(1, "no cp\n", 6);
+		exit(1);
+	}
+	if((status & 0377) != 0){
+		write(1,"?\n", 2);
+		exit();
+	}
+	if(status != 0) exit();
+}
+if(unlink(argp3) < 0){
+	write(1,"Cannot unlink source file.\n",27);
+	exit();
+}
+}
+
+putchar(c)
+{
+	write(1, &c, 1);
+}
+
+getchar()
+{
+	char c;
+
+	if(read(0, &c, 1) != 1) return(0);
+	return(c);
+}

source/s2/ncheck.c

@@ -0,0 +1,299 @@
+#
+
+char	*dargv[]
+{
+	"/dev/rrk2",
+	"/dev/rrp0",
+	0
+};
+
+#define NINODE	16*16
+#include "/usr/sys/ino.h"
+#include "/usr/sys/filsys.h"
+
+struct	filsys	sblock;
+struct	inode	inode[NINODE];
+
+int	sflg;
+int	aflg;
+#define	NI	20
+#define	NDIRS	787
+
+int	ilist[NI] { -1};
+int	fi;
+struct	htab {
+	int	hino;
+	int	hpino;
+	char	hname[14];
+} htab[NDIRS];
+int	nhent	10;
+int	(*pass[])()	{ pass1, pass2, pass3 };
+char	*lasts;
+int	ino;
+int	nerror;
+int	nffil;
+int	fout;
+int	nfiles;
+struct dir {
+	int	ino;
+	char	name[14];
+};
+
+main(argc, argv)
+char **argv;
+{
+	register char **p;
+	register int n, *lp;
+
+	nffil = dup(1);
+	if (argc == 1) {
+		for (p = dargv; *p;)
+			check(*p++);
+		return(nerror);
+	}
+	while (--argc) {
+		argv++;
+		if (**argv=='-') switch ((*argv)[1]) {
+		case 's':
+			sflg++;
+			continue;
+
+		case 'a':
+			aflg++;
+			continue;
+
+		case 'i':
+			lp = ilist;
+			while (lp < &ilist[NI-1] && (n = number(argv[1]))) {
+				*lp++ = n;
+				argv++;
+				argc--;
+			}
+			*lp++ = -1;
+			continue;
+
+		default:
+			printf2("Bad flag\n");
+		}
+		check(*argv);
+	}
+	return(nerror);
+}
+
+check(file)
+char *file;
+{
+	register i, j, pno;
+
+	fi = open(file, 0);
+	if (fi < 0) {
+		printf2("cannot open %s\n", file);
+		return;
+	}
+	printf2("%s:\n", file);
+	sync();
+	bread(1, &sblock, 512);
+	nfiles = sblock.s_isize*16;
+	for (i=0; i<NDIRS; i++)
+		htab[i].hino = 0;
+	fout = nffil;
+	flush();
+	for (pno=0; pno<3; pno++) {
+		ino = 0;
+		for (i=0; ino<nfiles; i =+ NINODE/16) {
+			bread(i+2, inode, sizeof inode);
+			for (j=0; j<NINODE && ino<nfiles; j++) {
+				ino++;
+				(*pass[pno])(&inode[j]);
+			}
+		}
+	}
+	flush();
+	fout = 1;
+}
+
+pass1(ip)
+{
+	if ((ip->i_mode&IALLOC)==0 || (ip->i_mode&IFMT)!=IFDIR)
+		return;
+	lookup(ino, 1);
+}
+
+pass2(ip)
+struct inode *ip;
+{
+	register doff;
+	register struct htab *hp;
+	register struct dir *dp;
+	int i;
+
+	if ((ip->i_mode&IALLOC)==0 || (ip->i_mode&IFMT)!=IFDIR)
+		return;
+	doff = 0;
+	while (dp = dread(ip, doff)) {
+		doff =+ 16;
+		if (dp->ino==0)
+			continue;
+		if ((hp = lookup(dp->ino, 0)) == 0)
+			continue;
+		if (dotname(dp))
+			continue;
+		hp->hpino = ino;
+		for (i=0; i<14; i++)
+			hp->hname[i] = dp->name[i];
+	}
+}
+
+pass3(ip)
+struct inode *ip;
+{
+	register doff;
+	register struct dir *dp;
+	register int *ilp;
+
+	if ((ip->i_mode&IALLOC)==0 || (ip->i_mode&IFMT)!=IFDIR)
+		return;
+	doff = 0;
+	while (dp = dread(ip, doff)) {
+		doff =+ 16;
+		if (dp->ino==0)
+			continue;
+		if (aflg==0 && dotname(dp))
+			continue;
+		for (ilp=ilist; *ilp >= 0; ilp++)
+			if (*ilp == dp->ino)
+				break;
+		if (ilp > ilist && *ilp!=dp->ino)
+			continue;
+		printf("%d	", dp->ino);
+		pname(ino, 0);
+		printf("/%.14s\n", dp->name);
+	}
+}
+
+dotname(adp)
+{
+	register struct dir *dp;
+
+	dp = adp;
+	if (dp->name[0]=='.')
+		if (dp->name[1]==0 || dp->name[1]=='.' && dp->name[2]==0)
+			return(1);
+	return(0);
+}
+
+pname(i, lev)
+{
+	register struct htab *hp;
+
+	if (i==1)
+		return;
+	if ((hp = lookup(i, 0)) == 0) {
+		printf("???");
+		return;
+	}
+	if (lev > 10) {
+		printf("...");
+		return;
+	}
+	pname(hp->hpino, ++lev);
+	printf("/%.14s", hp->hname);
+}
+
+lookup(i, ef)
+{
+	register struct htab *hp;
+
+	for (hp = &htab[i%NDIRS]; hp->hino;) {
+		if (hp->hino==i)
+			return(hp);
+		if (++hp >= &htab[NDIRS])
+			hp = htab;
+	}
+	if (ef==0)
+		return(0);
+	if (++nhent >= NDIRS) {
+		printf2("Out of core-- increase NDIRS\n");
+		flush();
+		exit(1);
+	}
+	hp->hino = i;
+	return(hp);
+}
+
+dread(aip, aoff)
+{
+	register b, off;
+	register struct inode *ip;
+	static ibuf[256];
+	static char buf[512];
+
+	off = aoff;
+	ip = aip;
+	if ((off&0777)==0) {
+		if (off==0177000) {
+			printf2("Monstrous directory %l\n", ino);
+			return(0);
+		}
+		if ((ip->i_mode&ILARG)==0) {
+			if (off>=010000 || (b = ip->i_addr[off>>9])==0)
+				return(0);
+			bread(b, buf, 512);
+		} else {
+			if (off==0) {
+				if (ip->i_addr[0]==0)
+					return(0);
+				bread(ip->i_addr[0], ibuf, 512);
+			}
+			if ((b = ibuf[(off>>9)&0177])==0)
+				return(0);
+			bread(b, buf, 512);
+		}
+	}
+	return(&buf[off&0777]);
+}
+
+bread(bno, buf, cnt)
+{
+
+	seek(fi, bno, 3);
+	if (read(fi, buf, cnt) != cnt) {
+		printf2("read error %d\n", bno);
+		exit();
+	}
+}
+
+bwrite(bno, buf)
+{
+
+	seek(fi, bno, 3);
+	if (write(fi, buf, 512) != 512) {
+		printf2("write error %d\n", bno);
+		exit();
+	}
+}
+
+number(as)
+char *as;
+{
+	register n, c;
+	register char *s;
+
+	s = as;
+	n = 0;
+	while ((c = *s++) >= '0' && c <= '9') {
+		n = n*10+c-'0';
+	}
+	return(n);
+}
+
+printf2(s, a1, a2)
+{
+	extern fout;
+
+	flush();
+	fout = 2;
+	printf(s, a1, a2);
+	fout = nffil;
+	flush();
+}

source/s2/newgrp.c

@@ -0,0 +1,156 @@
+int	gbuf[259];
+int	pbuf[259];
+int	ttyb[3];
+char	name[10];
+char	passwd[10];
+char	space[1000];
+int	peek;
+int	pwdflg;
+
+main(argc, argv)
+char *argv[];
+{
+	register id;
+	register char *p, *q;
+
+	if(argc < 2) {
+		printf("usage: newgrp groupname\n");
+		done();
+	}
+	if(fopen("/etc/group", gbuf) < 0) {
+		printf("cannot open group file\n");
+		done();
+	}
+	do {
+		field(name, gbuf);
+		p = name;
+		q = argv[1];
+		while(*p == *q++)
+			if(*p++ == 0 || p >= name+8)
+				goto l1;
+	} while(skip(gbuf));
+	printf("%s: not a valid group name\n", argv[1]);
+	done();
+
+l1:
+	if(fopen("/etc/passwd", pbuf) < 0) {
+		printf("cannot open password file\n");
+		done();
+	}
+	p = space;
+	id = getuid() & 0377;
+	do {
+		field(p, pbuf);
+		field(name, pbuf);
+		if(value(pbuf) == id) {
+			if(name[0] == 0)
+				pwdflg++;
+			while(*p++) ;
+		}
+	} while(skip(pbuf));
+	*p = 0;
+
+	field(passwd, gbuf);
+	id = value(gbuf);
+	if(id == 1) {
+		pwdflg = 0;
+		goto l2;
+	}
+	do {
+		p = space;
+		field(name, gbuf);
+		while(*p) {
+			q = name;
+			while(*p == *q++) {
+				if(*p++ == 0)
+					goto l2;
+			}
+			while(*p++) ;
+		}
+	} while(peek == ',');
+	goto no;
+
+l2:
+	if(pwdflg && passwd[0]) {
+		printf("password: ");
+		gtty(0, pbuf);
+		pbuf[3] = pbuf[2];
+		pbuf[2] =& ~010;
+		stty(0, pbuf);
+		read(0, gbuf, 512);
+		pbuf[2] = pbuf[3];
+		stty(0, pbuf);
+		printf("\n");
+		p = name;
+		q = gbuf;
+		while(p < name+8) {
+			if(*q == '\n')
+				break;
+			*p++ = *q++;
+		}
+		*p = 0;
+		p = crypt(name);
+		q = passwd;
+		while(q < passwd+8)
+			if(*p++ != *q++)
+				goto no;
+	}
+	if(setgid(id) < 0) {
+		perror("setgid");
+		goto no;
+	}
+	done();
+
+no:
+	printf("Sorry\n");
+	done();
+}
+
+skip(buf)
+{
+
+	while(peek > 0) {
+		if(peek == '\n') {
+			peek = 1;
+			return(1);
+		}
+		peek = getc(buf);
+	}
+	return(0);
+}
+
+field(cp, buf)
+{
+	register c;
+	register char *p, *q;
+
+	p = cp;
+	q = p+8;
+	while((c = getc(buf)) != '\n') {
+		if(c == ',' || c == ':' || c <= 0)
+			break;
+		if(p < q)
+			*p++ = c;
+	}
+	*p = 0;
+	peek = c;
+}
+
+value(buf)
+{
+	register n, c;
+
+	n = 0;
+	while((c = getc(buf)) >= '0' && c <= '9')
+		n = n*10 + c-'0';
+	peek = c;
+	return(n);
+}
+
+done()
+{
+
+	setuid(getuid());
+	execl("/bin/sh", "-", 0);
+	exit();
+}

source/s2/nice.c

@@ -0,0 +1,40 @@
+/* nice */
+int	nicarg	4;
+char	*args[100];
+char	string[10000];
+
+main(argc, argv)
+int argc;
+char *argv[];
+{
+	int i;
+	register char **argp, *strp, *p;
+
+	if(argc > 1 && argv[1][0] == '-') {
+		nicarg = atoi(&argv[1][1]);
+		argc--;
+		argv++;
+	}
+	if(argc < 2) {
+		printf("usage: nice [ -n ] command\n");
+		exit(1);
+	}
+	argc--;
+	argv++;
+	argp = args;
+	strp = string;
+	for (i=0; i<9; i++)
+		*strp++ = "/usr/bin/"[i];
+	for(i=0; i<argc; i++) {
+		*argp++ = strp;
+		p = *argv++;
+		while(*strp++ = *p++);
+	}
+	*argp = 0;
+	nice(nicarg);
+	execv(string+9, args);
+	execv(string+4, args);
+	execv(string, args);
+	printf("%s not found\n", string+9);
+	exit(1);
+}

source/s2/nm.c

@@ -0,0 +1,149 @@
+int	fout;
+int	cflg;
+int	nflg;
+int	uflg;
+int	rflg	1;
+int	gflg;
+int	pflg;
+struct	nl
+{
+	char	name[8];
+	int	typ;
+	int	*val;
+} *nlp;
+int	fi;
+int	buf[8];
+main(argc, argv)
+char **argv;
+{
+	int n, i, j;
+	int compare();
+
+	if (--argc > 0 && *argv[1] == '-') {
+		argv++;
+		while (*++*argv) switch (**argv) {
+		case 'n':
+			nflg++;
+			continue;
+
+		case 'c':
+			cflg++;
+			continue;
+
+		case 'g':
+			gflg++;
+			continue;
+
+		case 'u':
+			uflg++;
+			continue;
+
+		case 'r':
+			rflg = -1;
+			continue;
+
+		case 'p':
+			pflg ++;
+			continue;
+
+		default:
+			continue;
+		}
+		argc--;
+	}
+	if (argc==0)
+		fi = open("a.out", 0); else
+		fi = open(*++argv, 0);
+	if(fi < 0) {
+		printf("cannot open input\n");
+		exit();
+	}
+	read(fi, buf, 020);
+	if(buf[0]!=0407 && buf[0]!=0410 && buf[0]!=0411) {
+		printf("bad format\n");
+		exit();
+	}
+	seek(fi, buf[1], 1);		/* text */
+	seek(fi, buf[2], 1);		/* data */
+	if(buf[7] != 1) {
+		seek(fi, buf[1], 1);
+		seek(fi, buf[2], 1);	/* reloc */
+	}
+	n = ldiv(0, buf[4], 12);
+	if(n == 0) {
+		printf("no name list\n");
+		exit();
+	}
+	nlp = sbrk(12*n);
+	read(fi, nlp, n*12);
+	if (pflg==0)
+		qsort(nlp, n, 12, compare);
+	fout = dup(1);
+	close(1);
+	for(i=0; i<n; i++) {
+		if(gflg && (nlp->typ&040)==0)
+			goto out;
+		if(cflg) {
+			if(nlp->name[0] != '_')
+				goto out;
+			for(j=0; j<7; j++)
+				nlp->name[j] = nlp->name[j+1];
+			nlp->name[7] = '\0';
+		}
+		j = nlp->typ&037;
+		if(j > 4)
+			j = 1;
+		if(j==0 && nlp->val)
+			j = 5;
+		if(uflg && j!=0)
+			goto out;
+		if(!uflg) {
+			if(j==0)
+				printf("      "); else
+				printo(nlp->val);
+			printf("%c ", (nlp->typ&040? "UATDBC":"uatdbc")[j]);
+		}
+		printf("%.8s\n", nlp);
+	out:
+		nlp++;
+	}
+	flush();
+}
+
+compare(p1, p2)
+struct nl *p1, *p2;
+{
+	int a, i;
+
+	a = 0;
+	if(nflg) {
+		if(p1->val > p2->val) {
+			a = 1;
+			goto out;
+		}
+		if(p1->val < p2->val) {
+			a = -1;
+			goto out;
+		}
+	}
+	for(i=0; i<8; i++)
+	if(p1->name[i] != p2->name[i]) {
+		if(p1->name[i] > p2->name[i])
+			a = 1; else
+			a = -1;
+		goto out;
+	}
+out:
+	return(a*rflg);
+}
+
+printo(v)
+{
+	int i;
+
+	printf("%c", v<0?'1':'0');
+	for(i=0; i<5; i++) {
+		printf("%c", ((v>>12)&7)+'0');
+		v =<<3;
+	}
+}

source/s2/nohup.c

@@ -0,0 +1,35 @@
+/* nohup */
+char	*args[100];
+char	string[10000];
+
+main(argc, argv)
+int argc;
+char *argv[];
+{
+	int i;
+	char **argp, *strp, *p;
+
+	if(argc < 2) {
+		printf("arg count\n");
+		exit();
+	}
+	argc--;
+	argv++;
+	argp = args;
+	strp = string;
+	for (i=0; i<9; i++)
+		*strp++ = "/usr/bin/"[i];
+	for(i=0; i<argc; i++) {
+		*argp++ = strp;
+		p = *argv++;
+		while(*strp++ = *p++);
+	}
+	*argp = 0;
+	signal(1, 1);
+	signal(2, 1);
+	signal(3, 1);
+	execv(string+9, args);
+	execv(string+4, args);
+	execv(string, args);
+	printf("%s not found\n", string+9);
+}

source/s2/od.c

@@ -0,0 +1,614 @@
+int	word[16];
+char	gbuf[512];
+int	fi;
+int	conv;
+int	base	010;
+int	basem	01000;
+int	max;
+int	gidx;
+int	gcnt;
+int	eof;
+int	addr[2];
+int	from[2];
+int	key;
+int	flag;
+int	nword	8;
+
+main(argc, argv)
+char **argv;
+{
+	extern fout;
+	int f, k, w, i, a[2];
+	char *p;
+
+	fout = dup(1);
+	argv++;
+	if(argc > 1) {
+		p = *argv;
+		if(*p == '-') {
+			while((i = *p++) != '\0') {
+				switch(i) {
+				case 'o':
+					conv =| 001;
+					f = 6;
+					break;
+				case 'd':
+					conv =| 002;
+					f = 5;
+					break;
+				case 'a':
+					conv =| 004;
+					f = 4;
+					break;
+				case 'h':
+					conv =| 010;
+					f = 4;
+					break;
+				case 'c':
+					conv =| 020;
+					f = 5;
+					break;
+				case 'b':
+					conv =| 040;
+					f = 7;
+					break;
+				}
+				if(f > max)
+					max = f;
+			}
+			argc--;
+			argv++;
+		}
+	}
+	if(!conv) {
+		max = 6;
+		conv = 1;
+	}
+	if(argc > 1)
+	if(**argv != '+') {
+		fi = open(*argv, 0);
+		if(fi < 0) {
+			printf("cannot open %s\n", *argv);
+			goto done;
+		}
+		argv++;
+		argc--;
+	}
+	if(argc > 1)
+		offset(*argv);
+
+loop:
+	f = 1;
+	a[0] = addr[0];
+	a[1] = addr[1];
+	for(i=0; i<nword; i++) {
+		w = getw();
+		if(eof)
+			break;
+		word[i] = w;
+		if(i)
+			f =& w==k; else
+			k = w;
+	}
+	if(i)
+	if(f && !eof) {
+		if(!(flag && k==key)) {
+			dupl();
+			key = k;
+			from[0] = a[0];
+			from[1] = a[1];
+		}
+		flag =+ i;
+	} else {
+		dupl();
+		line(a, word, i);
+	}
+	if(!eof)
+		goto loop;
+	puta(addr);
+	putchar('\n');
+
+done:
+	flush();
+}
+
+dupl()
+{
+
+	if(flag) {
+		flag = 0;
+		line(from, &key, 1);
+	}
+}
+
+puta(a)
+int a[2];
+{
+
+	putn(a[0], base, 4);
+	putn(a[1], base, 3);
+	putchar(' ');
+}
+
+line(a, w, n)
+int w[];
+{
+	int i, f, c;
+
+	f = 1;
+	for(c=1; c; c=+c) {
+		if((c&conv) == 0)
+			continue;
+		if(f) {
+			puta(a);
+			f = 0;
+		} else
+			for(i=0; i<8; i++)
+				putchar(' ');
+		for(i=0; i<n; i++) {
+			putx(w[i], c);
+			putchar(i==n-1? '\n': ' ');
+		}
+	}
+}
+
+putx(n, c)
+{
+
+	switch(c) {
+	case 001:
+		pre(6);
+		putn(n, 8, 6);
+		break;
+	case 002:
+		pre(5);
+		putn(n, 10, 5);
+		break;
+	case 004:
+		pre(4);
+		putop(n);
+		break;
+	case 010:
+		pre(4);
+		putn(n, 16, 4);
+		break;
+	case 020:
+		pre(5);
+		putc(n);
+		putchar(' ');
+		putc(n>>8);
+		break;
+	case 040:
+		pre(7);
+		putn(n&0377, 8, 3);
+		putchar(' ');
+		putn((n>>8)&0377, 8, 3);
+		break;
+	}
+}
+
+getw()
+{
+	int b1, b2;
+
+	b1 = getc();
+	if(b1 == -1) {
+		eof = 1;
+		return(0);
+	}
+	b2 = getc();
+	if(b2 == -1)
+		b2 = 0;
+	return(b1|(b2<<8));
+}
+
+getc()
+{
+
+	if(gidx >= gcnt) {
+		gcnt = read(fi, gbuf, 512);
+		if(gcnt <= 0)
+			return(-1);
+		gidx = 0;
+	}
+	if(++addr[1] >= basem) {
+		addr[0]++;
+		addr[1] = 0;
+	}
+	return(gbuf[gidx++]&0377);
+}
+
+putc(c)
+{
+	c =& 0377;
+	if(c>037 && c<0177 && c!='\\') {
+		putchar(' ');
+		putchar(c);
+		return;
+	}
+	putchar('\\');
+	switch(c) {
+	case '\0':
+		putchar('0');
+		break;
+	case '\n':
+		putchar('n');
+		break;
+	case '\\':
+		putchar('\\');
+		break;
+	case '\t':
+		putchar('t');
+		break;
+	default:
+		putchar('?');
+	}
+}
+
+putn(n, b, c)
+{
+
+	if(!c)
+		return;
+	putn(ldiv(0,n,b),b,c-1);
+	if((n=lrem(0,n,b)) > 9)
+		putchar(n-10+'a'); else
+		putchar(n+'0');
+}
+
+pre(n)
+{
+	int i;
+
+	for(i=n; i<max; i++)
+		putchar(' ');
+}
+
+offset(s)
+char s[];
+{
+	char *p;
+	int a[2], d, i, j, b;
+
+	p = s;
+	while(*p++);
+	i = p-s-1;
+	b = 0;
+	if(i > 0)
+		if(p[-2] == 'b') {
+			i--;
+			b++;
+			p--;
+		}
+	if(i > 0)
+		if(p[-2] == '.') {
+			i--;
+			base = 10;
+			basem = 1000;
+		}
+	a[0] = 0;
+	for(j=0; i-j>3; j++) {
+		d = s[j];
+		if(d>='0' && d<='9')
+			a[0] = a[0]*base + d-'0';
+	}
+	a[1] = 0;
+	for(; i-j>0; j++) {
+		d = s[j];
+		if(d>='0' && d<='9')
+			a[1] = a[1]*base + d-'0';
+	}
+	if(b) {
+		i = a[0]*basem+a[1];
+		a[0] = 0;
+		a[1] = 0;
+		while(i--) {
+			a[1] =+ 512;
+			while(a[1] >= basem) {
+				a[1] =- basem;
+				a[0]++;
+			}
+		}
+	}
+	i = 0;
+	while(a[0] > addr[0]+1) {
+		addr[1] =+ 512;
+		while(addr[1] >= basem) {
+			addr[1] =- basem;
+			addr[0]++;
+		}
+		i++;
+	}
+	seek(fi, i, 3);
+	while(a[0]!=addr[0] || a[1]!=addr[1])
+		if(getc() == -1)
+			break;
+}
+
+putop(n)
+{
+	char *p;
+	int i, c;
+
+	p = getop(n);
+	for(i=0; (c = *p++) != '\0'; i++)
+		putchar(c);
+	for(; i<4; i++)
+		putchar(' ');
+}
+
+getop(n)
+{
+
+	switch(n&0170000)
+	{
+	case 0000000:
+		switch(n&0177000)
+		{
+		case 0004000:
+			return("jsr");
+
+		case 0077000:
+			return("sob");
+		}
+		switch(n&0177400)
+		{
+		case 0000400:
+			return("br");
+
+		case 0001000:
+			return("bne");
+
+		case 0001400:
+			return("beq");
+
+		case 0002000:
+			return("bge");
+
+		case 0002400:
+			return("blt");
+
+		case 0003000:
+			return("bgt");
+
+		case 0003400:
+			return("ble");
+		}
+		switch(n&0177700)
+		{
+		case 0000100:
+			return("jmp");
+
+		case 0000300:
+			return("swab");
+
+		case 0005000:
+			return("clr");
+
+		case 0005100:
+			return("com");
+
+		case 0005200:
+			return("inc");
+
+		case 0005300:
+			return("dec");
+
+		case 0005400:
+			return("neg");
+
+		case 0005500:
+			return("adc");
+
+		case 0005600:
+			return("sbc");
+
+		case 0005700:
+			return("tst");
+
+		case 0006000:
+			return("ror");
+
+		case 0006100:
+			return("rol");
+
+		case 0006200:
+			return("asr");
+
+		case 0006300:
+			return("asl");
+
+		case 0006400:
+			return("mark");
+
+		case 0006500:
+			return("mfpi");
+
+		case 0006600:
+			return("mtpi");
+
+		case 0006700:
+			return("sxt");
+		}
+		switch(n&0177740)
+		{
+		case 0000240:
+			return("flag");
+		}
+		switch(n&0177770)
+		{
+		case 0000200:
+			return("rts");
+
+		case 0000230:
+			return("spl");
+		}
+		switch(n&0177777)
+		{
+		case 0000000:
+			return("halt");
+
+		case 0000001:
+			return("wait");
+
+		case 0000002:
+			return("rti");
+
+		case 0000003:
+			return("bpt");
+
+		case 0000004:
+			return("iot");
+
+		case 0000005:
+			return("rset");
+
+		case 0000006:
+			return("rtt");
+		}
+		break;
+
+	case 0010000:
+		return("mov ");
+
+	case 0020000:
+		return("cmp");
+
+	case 0030000:
+		return("bit");
+
+	case 0040000:
+		return("bic");
+
+	case 0050000:
+		return("bis");
+
+	case 0060000:
+		return("add");
+
+	case 0070000:
+		switch(n&0177000)
+		{
+		case 0070000:
+			return("mul");
+
+		case 0071000:
+			return("div");
+
+		case 0072000:
+			return("ash");
+
+		case 0073000:
+			return("ashc");
+
+		case 0074000:
+			return("xor");
+		}
+		break;
+
+	case 0100000:
+		switch(n&0177400)
+		{
+		case 0100000:
+			return("bpl");
+
+		case 0100400:
+			return("bmi");
+
+		case 0101000:
+			return("bhi");
+
+		case 0101400:
+			return("blos");
+
+		case 0102000:
+			return("bvc");
+
+		case 0102400:
+			return("bvs");
+
+		case 0103000:
+			return("bhis");
+
+		case 0103400:
+			return("blo");
+
+		case 0104000:
+			return("emt");
+
+		case 0104400:
+			return("sys");
+		}
+		switch(n&0177700)
+		{
+		case 0105000:
+			return("clrb");
+
+		case 0105100:
+			return("comb");
+
+		case 0105200:
+			return("incb");
+
+		case 0105300:
+			return("decb");
+
+		case 0105400:
+			return("negb");
+
+		case 0105500:
+			return("adcb");
+
+		case 0105600:
+			return("sbcb");
+
+		case 0105700:
+			return("tstb");
+
+		case 0106000:
+			return("rorb");
+
+		case 0106100:
+			return("rolb");
+
+		case 0106200:
+			return("asrb");
+
+		case 0106300:
+			return("aslb");
+
+		case 0106500:
+			return("mfpd");
+
+		case 0106600:
+			return("mfpd");
+		}
+		break;
+
+	case 0110000:
+		return("movb");
+
+	case 0120000:
+		return("cmpb");
+
+	case 0130000:
+		return("bitb");
+
+	case 0140000:
+		return("bicb");
+
+	case 0150000:
+		return("bisb");
+
+	case 0160000:
+		return("sub");
+
+	case 0170000:
+		switch(n&01777000)
+		{
+		case 0:0;
+		}
+		break;
+	}
+	return("???");
+}

source/s2/opr.c

@@ -0,0 +1,27 @@
+/*
+ *	opr -- off line print dispatcher
+ *		chooses spooling routine appropriate 
+ *		to destination
+ *
+ *	last entry in table isdefault
+ */
+
+char *code[] {
+	"-lp",	"/lib/lpr",	/* line printer */
+	0
+};
+
+main(argc, argv)
+char **argv;
+{
+	int i, j;
+
+	argv[argc] = 0;
+	for(i=0; code[i]; i=+2)
+	if(argc > 1)
+		for(j=0; code[i][j]==argv[1][j]; j++)
+			if(code[i][j] == 0)
+					execv(code[i+1], &argv[1]);
+	execv(code[i-1], argv);
+	write(2, "can't start daemon\n", 19);
+}

source/s2/passwd.c

@@ -0,0 +1,151 @@
+/*
+ * enter a password in the password file
+ * this program should be suid with owner
+ * with an owner with write permission on /etc/passwd
+ */
+char	*tfile	{ "/tmp/ptmp" };
+char	*pfile	{ "/etc/passwd" };
+int	tbuf[259];
+int	pbuf[259];
+
+main(argc, argv)
+char *argv[];
+{
+	register u, c;
+	register char *p;
+
+	if(argc != 3) {
+		write(2, "Usage: passwd user password\n", 28);
+		goto bex;
+	}
+	signal(1, 1);
+	signal(2, 1);
+	signal(3, 1);
+
+	if(stat(tfile, tbuf+20) >= 0) {
+		write(2, "Temporary file busy -- try again\n", 33);
+		goto bex;
+	}
+	tbuf[0] = creat(tfile, 0600);
+	if(tbuf[0] < 0) {
+		write(2, "Cannot create temporary file\n", 29);
+		goto bex;
+	}
+	pbuf[0] = open(pfile, 0);
+	if(pbuf[0] < 0) {
+		write(2, "Cannot open /etc/passwd\n", 24);
+		goto out;
+	}
+	goto l1;
+
+/*
+ * skip to beginning of next line
+ */
+
+skip:
+	while(c != '\n') {
+		if(c < 0)
+			goto ill;
+		c = getc(pbuf);
+		putc(c, tbuf);
+	}
+
+/*
+ * compare user names
+ */
+
+l1:
+	c = getc(pbuf);
+	putc(c, tbuf);
+	if(c < 0) {
+		write(2, "User name not found in password file\n", 37);
+		goto out;
+	}
+	p = argv[1];
+	while(c != ':') {
+		if(*p++ != c)
+			goto skip;
+		c = getc(pbuf);
+		putc(c, tbuf);
+	}
+	if(*p)
+		goto skip;
+/*
+ * skip old password
+ */
+	do {
+		c = getc(pbuf);
+		if(c < 0)
+			goto ill;
+	} while(c != ':');
+
+/*
+ * copy in new password
+ */
+	p = argv[2];
+	for(c=0; c<9; c++)
+		if(*p++ == 0)
+			break;
+	*--p = 0;
+	if(p != argv[2])
+		p = crypt(argv[2]);
+	while(*p)
+		putc(*p++, tbuf);
+	putc(':', tbuf);
+
+/*
+ * validate uid
+ */
+
+	u = 0;
+	do {
+		c = getc(pbuf);
+		putc(c, tbuf);
+		if(c >= '0' && c <= '9')
+			u = u*10 + c-'0';
+		if(c < 0)
+			goto ill;
+	} while(c != ':');
+	c = getuid() & 0377;
+	if(c != 0 && c != u) {
+		write(2, "Permission denied\n", 18);
+		goto out;
+	}
+
+/*
+ * copy out and back
+ */
+
+	for(;;) {
+		c = getc(pbuf);
+		if(c < 0) {
+			fflush(tbuf);
+			close(pbuf[0]);
+			close(tbuf[0]);
+			tbuf[0] = open(tfile, 0);
+			if(tbuf[0] < 0) {
+				write(2, "Urk\n", 4);
+				goto out;
+			}
+			pbuf[0] = creat(pfile, 0644);
+			if(pbuf[0] < 0) {
+				write(2, "Cannot create /etc/passwd\n", 26);
+				goto out;
+			}
+			while((c = read(tbuf[0], tbuf+1, 512)) > 0)
+				write(pbuf[0], tbuf+1, c);
+			unlink(tfile);
+			exit(0);
+		}
+		putc(c, tbuf);
+	}
+
+ill:
+	write(2, "Password file illformed\n", 24);
+
+out:
+	unlink(tfile);
+
+bex:
+	exit(1);
+}

source/s2/pfe.s

@@ -0,0 +1,44 @@
+/ print last floating error
+
+stst	= 170300^tst
+
+	stst	r1
+	cmp	r1,$14
+	blos	1f
+	clr	r1
+1:
+	bic	$1,r1
+	mov	mesg(r1),r1
+1:
+	movb	(r1)+,ch
+	beq	1f
+	mov	$1,r0
+	sys	write; ch; 1
+	br	1b
+1:
+	sys	exit
+
+mesg:
+	1f
+	2f
+	3f
+	4f
+	5f
+	6f
+	7f
+	8f
+
+1:	<No error.\n\0>
+2:	<Floating op code error\n\0>
+3:	<Floating divide check\n\0>
+4:	<Integer conversion error\n\0>
+5:	<Floating overflow\n\0>
+6:	<Floating underflow\n\0>
+7:	<Floating undefined\n\0>
+8:	<Floating maintennace trap\n\0>
+
+	.even
+
+	.bss
+ch:	.=.+2
+

source/s2/pr.c

@@ -0,0 +1,449 @@
+#
+/*
+ *   print file with headings
+ *  2+head+2+page[56]+5
+ */
+
+int	ncol	1;
+char	*header;
+int	col;
+int	icol;
+int	file;
+char	*bufp;
+#define	BUFS	5120
+char	buffer[BUFS];
+#define	FF	014
+int	line;
+char	*colp[72];
+int	nofile;
+char	isclosed[10];
+int	peekc;
+int	fpage;
+int	page;
+int	colw;
+int	nspace;
+int	width	72;
+int	length	66;
+int	plength 61;
+int	margin	10;
+int	ntflg;
+int	mflg;
+int	tabc;
+char	*tty;
+int	mode;
+
+struct inode {
+	int dev;
+	int inum;
+	int flags;
+	char nlink;
+	char uid;
+	char gid;
+	char siz0;
+	int size;
+	int ptr[8];
+	int atime[2];
+	int mtime[2];
+};
+
+main(argc, argv)
+char **argv;
+{
+	int nfdone;
+	int onintr();
+	extern fout;
+
+	tty = "/dev/ttyx";
+	fout = dup(1);
+	close(1);
+	if ((signal(2, 1) & 01) == 0)
+		signal(2, onintr);
+	fixtty();
+	for (nfdone=0; argc>1; argc--) {
+		argv++;
+		if (**argv == '-') {
+			switch (*++*argv) {
+			case 'h':
+				if (argc>=2) {
+					header = *++argv;
+					argc--;
+				}
+				continue;
+
+			case 't':
+				ntflg++;
+				continue;
+
+			case 'l':
+				length = getn(++*argv);
+				continue;
+
+			case 'w':
+				width = getn(++*argv);
+				continue;
+
+			case 's':
+				if (*++*argv)
+					tabc = **argv;
+				else
+					tabc = '\t';
+				continue;
+
+			case 'm':
+				mflg++;
+				continue;
+
+			default:
+				ncol = getn(*argv);
+				continue;
+			}
+		} else if (**argv == '+') {
+			fpage = getn(++*argv);
+		} else {
+			print(*argv, argv);
+			nfdone++;
+			if (mflg)
+				break;
+		}
+	}
+	if (nfdone==0)
+		print(0);
+	flush();
+	onintr();
+}
+
+onintr()
+{
+
+	chmod(tty, mode);
+	exit(0);
+}
+
+fixtty()
+{
+	struct inode sbuf;
+	extern fout;
+
+	tty[8] = ttyn(fout);
+	fstat(fout, &sbuf);
+	mode = sbuf.flags&0777;
+	chmod(tty, 0600);
+}
+
+print(fp, argp)
+char *fp;
+char **argp;
+{
+	struct inode sbuf;
+	register int sncol, sheader;
+	register char *cbuf;
+	extern fout;
+
+	if (ntflg)
+		margin = 0;
+	else
+		margin = 10;
+	if (length <= margin)
+		length = 66;
+	if (width <= 0)
+		width = 72;
+	if (ncol>72 || ncol>width) {
+		write(2, "Very funny.\n", 12);
+		exit();
+	}
+	if (mflg) {
+		mopen(argp);
+		ncol = nofile;
+	}
+	colw = width/ncol;
+	sncol = ncol;
+	sheader = header;
+	plength = length-5;
+	if (ntflg)
+		plength = length;
+	if (--ncol<0)
+		ncol = 0;
+	if (mflg)
+		fp = 0;
+	if (fp) {
+		file = open(fp, 0);
+		if (file<0)
+			return;
+		fstat(file, &sbuf);
+	} else {
+		file = 0;
+		time(sbuf.mtime);
+	}
+	if (header == 0)
+		header = fp;
+	cbuf = ctime(sbuf.mtime);
+	cbuf[16] = '\0';
+	cbuf[24] = '\0';
+	page = 1;
+	icol = 0;
+	colp[ncol] = bufp = buffer;
+	if (mflg==0)
+		nexbuf();
+	while (mflg&&nofile || (!mflg)&&tpgetc(ncol)>0) {
+		if (mflg==0) {
+			colp[ncol]--;
+			if (colp[ncol] < buffer)
+				colp[ncol] = &buffer[BUFS];
+		}
+		line = 0;
+		if (ntflg==0) {
+			puts("\n\n");
+			puts(cbuf+4);
+			puts(" ");
+			puts(cbuf+20);
+			puts("  ");
+			puts(header);
+			puts(" Page ");
+			putd(page);
+			puts("\n\n\n");
+		}
+		putpage();
+		if (ntflg==0)
+			while(line<length)
+				put('\n');
+		page++;
+	}
+	if (file)
+		close(file);
+	ncol = sncol;
+	header = sheader;
+}
+
+mopen(ap)
+char **ap;
+{
+	register char **p, *p1;
+
+	p = ap;
+	while ((p1 = *p++) && p1 != -1) {
+		isclosed[nofile] = fopen(p1, &buffer[2*259*nofile]);
+		if (++nofile>=10) {
+			write(2, "Too many args.\n", 15);
+			exit();
+		}
+	}
+}
+
+putpage()
+{
+	register int lastcol, i, c;
+	int j;
+
+	if (ncol==0) {
+		while (line<plength) {
+			while((c = tpgetc(0)) && c!='\n' && c!=FF)
+				putcp(c);
+			putcp('\n');
+			line++;
+			if (c==FF)
+				break;
+		}
+		return;
+	}
+	colp[0] = colp[ncol];
+	if (mflg==0) for (i=1; i<=ncol; i++) {
+		colp[i] = colp[i-1];
+		for (j = margin; j<length; j++)
+			while((c=tpgetc(i))!='\n')
+				if (c==0)
+					break;
+	}
+	while (line<plength) {
+		lastcol = colw;
+		for (i=0; i<ncol; i++) {
+			while ((c=pgetc(i)) && c!='\n')
+				if (col<lastcol || tabc!=0)
+					put(c);
+			if (c==0 && ntflg)
+				return;
+			if (tabc)
+				put(tabc);
+			else while (col<lastcol)
+				put(' ');
+			lastcol =+ colw;
+		}
+		while ((c = pgetc(ncol)) && c!='\n')
+			put(c);
+		put('\n');
+	}
+}
+
+nexbuf()
+{
+	register int n;
+	register char *rbufp;
+
+	rbufp = bufp;
+	n = &buffer[BUFS] - rbufp;
+	if (n>512)
+		n = 512;
+	if ((n = read(file, rbufp, n)) <= 0)
+		*rbufp = 0376;
+	else {
+		rbufp =+ n;
+		if (rbufp >= &buffer[BUFS])
+			rbufp = buffer;
+		*rbufp = 0375;
+	}
+	bufp = rbufp;
+}
+
+tpgetc(ai)
+{
+	register char **p;
+	register int c, i;
+
+	i = ai;
+	if (mflg) {
+		if ((c = getc(&buffer[2*259*i])) < 0) {
+			if (isclosed[i]==0) {
+				isclosed[i] = 1;
+				if (--nofile <= 0)
+					return(0);
+			}
+			return('\n');
+		}
+		if (c==FF && ncol>0)
+			c = '\n';
+		return(c);
+	}
+loop:
+	c = **(p = &colp[i]) & 0377;
+	if (c == 0375) {
+		nexbuf();
+		c = **p & 0377;
+	}
+	if (c == 0376)
+		return(0);
+	(*p)++;
+	if (*p >= &buffer[BUFS])
+		*p = buffer;
+	if (c==0)
+		goto loop;
+	return(c);
+}
+
+pgetc(i)
+{
+	register int c;
+
+	if (peekc) {
+		c = peekc;
+		peekc = 0;
+	} else
+		c = tpgetc(i);
+	if (tabc)
+		return(c);
+	switch (c) {
+
+	case '\t':
+		icol++;
+		if ((icol&07) != 0)
+			peekc = '\t';
+		return(' ');
+
+	case '\n':
+		icol = 0;
+		break;
+
+	case 010:
+	case 033:
+		icol--;
+		break;
+	}
+	if (c >= ' ')
+		icol++;
+	return(c);
+}
+
+puts(as)
+char *as;
+{
+	register int c;
+	register char *s;
+
+	if ((s=as)==0)
+		return;
+	while (c = *s++)
+		put(c);
+}
+
+putd(an)
+{
+	register int a, n;
+
+	n = an;
+	if (a = n/10)
+		putd(a);
+	put(n%10 + '0');
+}
+
+put(ac)
+{
+	register int ns, c;
+
+	c = ac;
+	if (tabc) {
+		putcp(c);
+		if (c=='\n')
+			line++;
+		return;
+	}
+	switch (c) {
+
+	case ' ':
+		nspace++;
+		col++;
+		return;
+
+	case '\n':
+		col = 0;
+		nspace = 0;
+		line++;
+		break;
+
+	case 010:
+	case 033:
+		if (--col<0)
+			col = 0;
+		if (--nspace<0)
+			nspace = 0;
+
+	}
+	while(nspace) {
+		if (nspace>2 && col > (ns=((col-nspace)|07))) {
+			nspace = col-ns-1;
+			putcp('\t');
+		} else {
+			nspace--;
+			putcp(' ');
+		}
+	}
+	if (c >= ' ')
+		col++;
+	putcp(c);
+}
+
+getn(ap)
+char *ap;
+{
+	register int n, c;
+	register char *p;
+
+	p = ap;
+	n = 0;
+	while ((c = *p++) >= '0' && c <= '9')
+		n = n*10 + c - '0';
+	return(n);
+}
+
+putcp(c)
+{
+	if (page >= fpage)
+		putchar(c);
+}

source/s2/prof.c

@@ -0,0 +1,350 @@
+/*
+ *  Print execution profile
+ */
+
+struct nl {
+	char name[8];
+	int value;
+	float time;
+	int ncall[2];
+};
+
+struct nl nl[600];
+
+struct fnl {
+	char fname[8];
+	int flag;
+	int fvalue;
+};
+
+struct cnt {
+	int	cvalue;
+	int	cncall[2];
+} cbuf[200];
+
+struct inode {
+	int	idev;
+	int inum;
+	int flags;
+	char nlink;
+	char uid;
+	char	gid;
+	char	size0;
+	int size;
+	int ptr[8];
+	int ctime[2];
+	int mtime[2];
+	int fill;
+};
+
+int	ibuf[259];
+int	obuf[259];
+int	buf[17];
+int	i;
+int	j;
+int	highpc;
+int	lowpc;
+int	ccnt;
+int	pcl;
+int	pch;
+int	bufs;
+int	nname;
+double	time;
+double	totime;
+double	maxtime;
+double	scale;
+double	lastx;
+double	lasty;
+struct nl *np;
+struct nl *npe;
+int	aflg;
+int	vflg;
+int	lflg;
+int	symoff;
+int	symsiz;
+int	vf;
+int	etext;
+int	ncount;
+
+main(argc, argv)
+char **argv;
+{
+	char *namfil;
+	int timcmp(), valcmp();
+	int nf, pf, overlap;
+	double fnc, ltod(), lastsx;
+	struct cnt *cp;
+
+	obuf[0] = 1;
+	argv++;
+	namfil = "a.out";
+	while (argc>1) {
+		if (**argv == '-') {
+			if (*++*argv == 'l')
+				lflg++;
+			if (**argv == 'a')
+				aflg = 040;
+			if(**argv == 'v')
+				vflg++;
+		} else
+			namfil = *argv;
+		argc--;
+		argv++;
+	}
+	if ((nf = open(namfil, 0)) < 0) {
+		printf("Can't find %s\n", namfil);
+		done();
+	}
+	read(nf, buf, 020);
+	if (buf[0] != 0407 && buf[0] != 0410 && buf[0] != 0411) { /* a.out magic */
+		printf("Bad format: %s\n", namfil);
+		done();
+	}
+	symsiz = buf[4];
+	symoff = buf[1] + buf[2];
+	if (buf[7] != 1)
+		symoff =<< 1;
+	seek(nf, symoff+020, 0);
+	if ((pf = open("mon.out", 0)) < 0) {
+		printf("No mon.out\n");
+		done();
+	}
+	fstat(pf, buf);
+	read(pf, &lowpc, 2);
+	read(pf, &highpc, 2);
+	read(pf, &ncount, 2);
+	bufs = buf->size/2 - 3*(ncount+1);
+	read(pf, cbuf, ncount*6);
+	lowpc = (lowpc>>1) & 077777;
+	highpc = (highpc>>1) & 077777;
+	npe = nl;
+	initf(nf);
+	for (nname = 0; symsiz > 0; symsiz =- 12) {
+		for(i=0; i<12; i++)
+			buf->fname[i] = getc(ibuf);
+		if ((buf->flag | aflg) != 042)
+			continue;
+		buf->fvalue = (buf->fvalue>>1) & 077777;
+		npe->value = buf->fvalue;
+		for (i=0; i<8; i++)
+			npe->name[i] = buf->fname[i];
+		npe++;
+		nname++;
+	}
+	if (nname == 0) {
+		printf("No symbols: %s\n", namfil);
+		done();
+	}
+	npe->value = 077777;
+	npe++;
+	for (cp = cbuf; cp < &cbuf[ncount]; cp++)
+		for (np = nl; np < npe; np++)
+			if (cp->cvalue-8 == np->value<<1) {
+				np->ncall[0] = cp->cncall[0];
+				np->ncall[1] = cp->cncall[1];
+				break;
+			}
+	qsort(nl, nname, 18, &valcmp);
+	scale = (highpc-lowpc)/(bufs+0.0);
+	initf(pf);
+	for (i=0; (j = getc(ibuf)) != -1; i++) {
+		ccnt.fname[0] = j;
+		ccnt.fname[1] = getc(ibuf);
+		if (ccnt == 0)
+			continue;
+		time = ccnt;
+		if (ccnt<0)
+			time =+ 65536.;
+		totime =+ time;
+		if(time > maxtime)
+			maxtime = time;
+		pcl = lowpc + scale*i - 1;
+		pch = lowpc + scale*(i+1) - 1;
+		for (j=0; j<nname; j++) {
+			if (pch < nl[j].value)
+				break;
+			if (pcl >= nl[j+1].value)
+				continue;
+			overlap=(min(pch,nl[j+1].value)-max(pcl,nl[j].value));
+			nl[j].time =+ overlap*time/scale;
+		}
+	}
+	if (totime==0.0) {
+		printf("No time accumulated\n");
+		done();
+	}
+	if(!vflg)
+		goto print;
+	vf = open("/dev/vt0", 1);
+	if(vf < 0) {
+		printf("Cannot open vt\n");
+		done();
+	}
+	obuf[0] = vf;
+	vtch(1);
+	vtch(1);
+	vtch(3);
+	point(-2048., -2048.);
+	point(-2048., 2048.);
+	vtch(3);
+	point(0., -2048.);
+	point(0., 2048.);
+	for(j=0; j<9; j++) {
+		vtch(3);
+		point(-2048., 2048. - j*512.);
+		point(0., 2048. - j*512.);
+	}
+	lastx = 0.;
+	lasty = 2048.;
+	scale = 4096./(i+2);
+	seek(pf, 6*(ncount+1), 0);
+	initf(pf);
+	lastsx = 0.0;
+	while((j = getc(ibuf)) != -1) {
+		ccnt.fname[0] = j;
+		ccnt.fname[1] = getc(ibuf);
+		time = ccnt;
+		if(ccnt < 0)
+			time =+ 65536.;
+		vtch(3);
+		point(lastsx, lasty);
+		lastsx =- 2000.*time/totime;
+		point(lastsx, lasty-scale);
+		if (ccnt!=0 || lastx!=0.0) {
+			vtch(3);
+			point(lastx, lasty);
+			lastx = -time*2000./maxtime;
+			point(lastx, lasty);
+		}
+		lasty =- scale;
+	}
+	scale = 4096./(highpc-lowpc);
+	lastx = 50.;
+	for(np = nl; np<npe;  np++) {
+		if(np->value < lowpc)
+			continue;
+		if(np->value >= highpc)
+			continue;
+		time = np->time/totime;
+		lasty = 2048. - (np->value - lowpc)*scale;
+		vtch(3);
+		point(0., lasty);
+		point(50., lasty);
+		vtch(3);
+		point(lastx-50., lasty);
+		point(lastx, lasty);
+		vtch(9);
+		point(lastx+10., lasty+60.);
+		vtch(1);
+		vtch(3);
+		for(j=0; j<8; j++)
+			if(np->name[j] != '_')
+			vtch(np->name[j]);
+		vtch(0);
+		lastx =+ 500.;
+		if(lastx > 2000.)
+			lastx = 50.;
+	}
+	done();
+
+print:
+	printf("    name %%time #call  ms/call\n");
+	if (!lflg)
+		qsort(nl, nname, 18, &timcmp);
+	for (np = nl; np<npe-1; np++) {
+		time = np->time/totime;
+		printf("%8.8s%6.1f", np->name, 100*time);
+		fnc = ltod(np->ncall);
+		if (fnc != 0.0) {
+			printf("%6s", locv(np->ncall[0], np->ncall[1]));
+			printf(" %7.2f\n", np->time/(fnc*.06));
+		} else
+			printf("\n");
+	}
+	done();
+}
+
+min(a, b)
+{
+	if (a<b)
+		return(a);
+	return(b);
+}
+
+max(a, b)
+{
+	if (a>b)
+		return(a);
+	return(b);
+}
+
+valcmp(p1, p2)
+struct nl *p1, *p2;
+{
+	return(p1->value - p2->value);
+}
+
+timcmp(p1, p2)
+struct nl *p1, *p2;
+{
+	float d;
+
+	d = p2->time - p1->time;
+	if (d > 0.0)
+		return(1);
+	if (d < 0.0)
+		return(-1);
+	return(0);
+}
+
+vtch(c)
+int c;
+{
+
+	putchar(c&0377);
+}
+
+point(x, y)
+float x, y;
+{
+
+	point1(x);
+	point1(y);
+}
+
+putchar(c)
+{
+
+	putc(c, obuf);
+}
+
+point1(xy)
+float xy;
+{
+	int ixy;
+	struct { char b1; char b2;};
+
+	if(xy > 2047.)
+		xy = 2047.;
+	if(xy < -2048.)
+		xy = -2048.;
+	ixy = xy;
+	vtch(ixy.b1);
+	vtch(ixy.b2);
+}
+
+done()
+{
+
+	fflush(obuf);
+	exit();
+}
+
+initf(f)
+{
+
+	ibuf[0] = f;
+	ibuf[1] = 0;
+	ibuf[2] = 0;
+	ibuf[3] = 0;
+}

source/s2/ps.c

@@ -0,0 +1,292 @@
+#
+
+/*
+ *	ps - process status
+ *	examine and print certain things about processes
+ */
+
+#include "/usr/sys/param.h"
+#include "/usr/sys/proc.h"
+#include "/usr/sys/tty.h"
+#include "/usr/sys/user.h"
+
+struct {
+	char name[8];
+	int  type;
+	char  *value;
+} nl[3];
+
+struct proc proc[NPROC];
+struct tty tty;
+struct user u;
+int	lflg;
+int	kflg;
+int	xflg;
+int	tflg;
+int	aflg;
+int	mem;
+int	swap;
+
+int	stbuf[257];
+int	ndev;
+char	devc[65];
+int	devl[65];
+int	devt[65];
+char	*coref;
+struct ibuf {
+	char	idevmin, idevmaj;
+	int	inum;
+	int	iflags;
+	char	inl;
+	char	iuid;
+	char	igid;
+	char	isize0;
+	int	isize;
+	int	iaddr[8];
+	char	*ictime[2];
+	char	*imtime[2];
+	int	fill;
+};
+int	obuf[259];
+
+
+main(argc, argv)
+char **argv;
+{
+	struct proc *p;
+	int n, b;
+	int i, c, mtty;
+	char *ap;
+	int uid, puid;
+
+	obuf[0] = 1;
+	if (argc>1) {
+		ap = argv[1];
+		while (*ap) switch (*ap++) {
+		case 'a':
+			aflg++;
+			break;
+
+		case 't':
+			tflg++;
+			break;
+
+		case 'x':
+			xflg++;
+			break;
+
+		case 'l':
+			lflg++;
+			break;
+
+		case 'k':
+			kflg++;
+			break;
+
+		}
+	}
+
+	if(chdir("/dev") < 0) {
+		printf("cannot change to /dev\n");
+		done();
+	}
+	setup(&nl[0], "_proc");
+	setup(&nl[1], "_swapdev");
+	nlist(argc>2? argv[2]:"/unix", nl);
+	if (nl[0].type==0) {
+		printf("No namelist\n");
+		return;
+	}
+	coref = "/dev/mem";
+	if(kflg)
+		coref = "/usr/sys/core";
+	if ((mem = open(coref, 0)) < 0) {
+		printf("No mem\n");
+		done();
+	}
+	seek(mem, nl[1].value, 0);
+	read(mem, &nl[1].value, 2);
+	seek(mem, nl[0].value, 0);
+	read(mem, proc, sizeof proc);
+	getdev();
+	mtty = ttyn(0);
+	uid = getuid() & 0377;
+	if(lflg)
+	printf("TTY F S UID   PID PRI ADDR  SZ  WCHAN COMMAND\n"); else
+		printf("TTY  PID COMMAND\n");
+	for (i=0; i<NPROC; i++) {
+		if (proc[i].p_stat==0)
+			continue;
+		if (proc[i].p_ttyp==0) {
+			if (xflg==0)
+				continue;
+			c = '?';
+		} else {
+			for(c=0; c<ndev; c++)
+			if(devt[c] == proc[i].p_ttyp) {
+				c = devc[c];
+				goto out;
+			}
+			seek(mem, proc[i].p_ttyp, 0);
+			read(mem, &tty, sizeof tty);
+			for(c=0; c<ndev; c++)
+			if(devl[c] == tty.t_dev) {
+				devt[c] = proc[i].p_ttyp;
+				c = devc[c];
+				goto out;
+			}
+			c = '?';
+		out:;
+		}
+		puid = proc[i].p_uid & 0377;
+		if (uid != puid && aflg==0)
+			continue;
+		if (lflg || c!=mtty)
+			printf("%c:", c);
+		else
+			printf("  ");
+		if (lflg) {
+			printf("%3o %c%4d", proc[i].p_flag,
+				"0SWRIZT"[proc[i].p_stat], puid);
+		}
+		printf("%6l", proc[i].p_pid);
+		if (lflg) {
+			printf("%4d%5o%4d", proc[i].p_pri, proc[i].p_addr,
+				(proc[i].p_size+7)>>3);
+			if (proc[i].p_wchan)
+				printf("%7o", proc[i].p_wchan); else
+				printf("       ");
+		}
+		if (proc[i].p_stat==5)
+			printf(" <defunct>");
+		else
+			prcom(i);
+		printf("\n");
+	}
+	done();
+}
+
+getdev()
+{
+	register struct { int dir_ino; char dir_n[14]; } *p;
+	register i, c;
+	int f;
+	char dbuf[512];
+	int sbuf[20];
+
+	f = open("/dev");
+	if(f < 0) {
+		printf("cannot open /dev\n");
+		done();
+	}
+	swap = -1;
+	c = 0;
+
+loop:
+	i = read(f, dbuf, 512);
+	if(i <= 0) {
+		close(f);
+		if(swap < 0) {
+			printf("no swap device\n");
+			done();
+		}
+		ndev = c;
+		return;
+	}
+	while(i < 512)
+		dbuf[i++] = 0;
+	for(p = dbuf; p < dbuf+512; p++) {
+		if(p->dir_ino == 0)
+			continue;
+		if(p->dir_n[0] == 't' &&
+		   p->dir_n[1] == 't' &&
+		   p->dir_n[2] == 'y' &&
+		   p->dir_n[4] == 0 &&
+		   p->dir_n[3] != 0) {
+			if(stat(p->dir_n, sbuf) < 0)
+				continue;
+			devc[c] = p->dir_n[3];
+			devl[c] = sbuf->iaddr[0];
+			c++;
+			continue;
+		}
+		if(swap >= 0)
+			continue;
+		if(stat(p->dir_n, sbuf) < 0)
+			continue;
+		if((sbuf->iflags & 060000) != 060000)
+			continue;
+		if(sbuf->iaddr[0] == nl[1].value)
+			swap = open(p->dir_n, 0);
+	}
+	goto loop;
+}
+
+setup(p, s)
+char *p, *s;
+{
+	while (*p++ = *s++);
+}
+
+prcom(i)
+{
+	int baddr, laddr, mf;
+	register int *ip;
+	register char *cp, *cp1;
+	int c, nbad;
+
+	baddr = 0;
+	laddr = 0;
+	if (proc[i].p_flag&SLOAD) {
+		laddr = proc[i].p_addr;
+		mf = mem;
+	} else {
+		baddr = proc[i].p_addr;
+		mf = swap;
+	}
+	laddr =+ proc[i].p_size - 8;
+	baddr =+ laddr>>3;
+	laddr = (laddr&07)<<6;
+	seek(mf, baddr, 3);
+	seek(mf, laddr, 1);
+	if (read(mf, stbuf, 512) != 512)
+		return(0);
+	for (ip = &stbuf[256]; ip > &stbuf[0];) {
+		if (*--ip == -1) {
+			cp = ip+1;
+			if (*cp==0)
+				cp++;
+			nbad = 0;
+			for (cp1 = cp; cp1 < &stbuf[256]; cp1++) {
+				c = *cp1;
+				if (c==0)
+					*cp1 = ' ';
+				else if (c < ' ' || c > 0176) {
+					if (++nbad >= 5) {
+						*cp1++ = ' ';
+						break;
+					}
+					*cp1 = '?';
+				}
+			}
+			while (*--cp1==' ')
+				*cp1 = 0;
+			printf(lflg?" %.16s":" %.64s", cp);
+			return(1);
+		}
+	}
+	return(0);
+}
+
+done()
+{
+
+	fflush(obuf);
+	exit();
+}
+
+putchar(c)
+{
+
+	putc(c, obuf);
+}

source/s2/ptx.c

@@ -0,0 +1,222 @@
+/* permuted title index */
+
+char	*tfil "/tmp/p.tmp";
+char	*sw[] {
+	"a",
+	"an",
+	"and",
+	"as",
+	"for",
+	"is",
+	"of",
+	"on",
+	"or",
+	"the",
+	"to",
+	"up",
+	0};
+char	line[200];
+int	ch;
+int	ptflg;
+int	llen	72;
+
+main(argc, argv)
+int argc;
+char *argv[];
+{
+	extern fin, fout;
+	extern onintr();
+	int f;
+
+	if(argc>1 && *argv[1]=='-') {
+		llen = 100;
+		ptflg++;
+		argc--;
+		argv++;
+	}
+	if(argc<2) {
+		printf("arg count\n");
+		exit();
+	}
+	fin = open(argv[1]);
+	if(fin < 0) {
+		printf("%s: cannot open\n", argv[1]);
+		exit();
+	}
+	f = creat(tfil, 0600);
+	if(f < 0) {
+		printf("cannot create %s\n", tfil);
+		exit();
+	}
+	fout = f;
+	if ((signal(2, 1) & 01) ==0)
+		signal(2, onintr);
+	pass1();
+	flush();
+	close(fin);
+	fin = 0;
+	close(fout);
+	fout = 1;
+	f = fork();
+	if(f < 0) {
+		printf("try again\n");
+		exit();
+	}
+	if(f == 0) {
+		execl("/bin/sort", "sort", "-d", "-o", tfil, tfil, 0);
+		execl("/usr/bin/sort", "sort", "-d", "-o", tfil, tfil, 0);
+		printf("someone moved sort\n");
+		exit();
+	}
+	while(wait() != f);
+	fin = open(tfil, 0);
+	if(fin < 0) {
+		printf("cannot reopen %s\n", tfil);
+		exit();
+	}
+	if (argc>=3)
+		f = creat(argv[2], 0666);
+	else
+		f = dup(1);
+	if(f < 0) {
+		printf("%s: cannot open\n", argv[2]);
+		exit();
+	}
+	fout = f;
+	pass2();
+	flush();
+	onintr();
+}
+
+onintr()
+{
+	unlink(tfil);
+	exit();
+}
+
+pass1()
+{
+	int n, c, i, ll, j, k, cc, ccc;
+
+loop:
+	if ((c=getchar())=='\0')
+		return;
+	n = 0;
+	i = 0;
+	while(c!='\n' && c!='\0') {
+		if(c == '(')
+			c = 0177;
+		if(c==' ' || c=='\t') {
+			i++;
+			c = getchar();
+			continue;
+		}
+		if(i) {
+			i = 0;
+			if(n<=llen) line[n++] = ' ';
+		}
+		if (n<=llen) line[n++] = c;
+		c = getchar();
+	}
+	ll = n;
+	line[n++] = 0;
+	i = -1;
+l1:
+	while((cc=line[++i])==' ');
+	n = i;
+	j = 0;
+	while(sw[j]) {
+		i = n;
+		k = 0;
+		while ((cc=sw[j][k++])==line[i++]);
+		if(cc==0 && ((ccc=line[--i])==' '||ccc==0))
+			goto l1;
+		j++;
+	}
+	i = n;
+	while (c=line[n++]) putchar(c);
+	putchar('~');
+	n = 0;
+	while (n<i) {
+		c = line[n++];
+		if (c!=' ' || n!=i)
+			putchar(c);
+	}
+	putchar('\n');
+	while((c=line[i++])!=0 && c!=' ');
+	--i;
+	if (c) goto l1;
+	goto loop;
+}
+
+pass2()
+{
+	int i, n, c, tilde, llen2, nbfore, nafter;
+
+
+	llen2 = llen/2+6;
+loop:
+	if ((c=getchar())=='\0')
+		return;
+	n = nbfore = nafter = 0;
+	tilde = -1;
+	while(c!='\n' && c!='\0') {
+		if(c == 0177)
+			c = '(';
+		if (n<=llen) line[n] = c;
+		if (c=='~') tilde = n;
+		if (tilde>=0) nafter++; else nbfore++;
+		n++;
+		c = getchar();
+	}
+	if (tilde<0)
+		tilde = n++;
+	nafter--;
+	if (nbfore>llen2) {
+		i = tilde;
+		while (nbfore > llen2)
+			while(line[--i]!=' ' && i>=0) nbfore--;
+		if (i<0) goto l1;
+		line[tilde] = 0200;
+		nafter =+ (tilde-i+2);
+		tilde = i;
+	}
+	if (nafter >= llen-llen2) {
+		i = tilde;
+		while(nafter-- >= llen-llen2)
+			while(line[++i]!=' ' && i<n) nafter--;
+		if (i>=n) goto l1;
+		line[tilde] = 0200;
+		nafter++;
+		tilde = i;
+	}
+l1:
+	if(!ptflg) {
+		for(i=llen-llen2-nafter; i>=8; i =- 8)
+			putchar('\t');
+		while(--i>=0)
+			putchar(' ');
+	} else
+		printf(".xx \"");
+	i = tilde;
+	while (++i<n) p1char(line[i]);
+	if(!ptflg)
+		printf("  "); else
+		printf("\" \"");
+	i = -1;
+	while(++i<tilde) p1char(line[i]);
+	if(ptflg)
+		putchar('"');
+	putchar('\n');
+	goto loop;
+}
+
+p1char(c)
+{
+	if ((c&0377) == 0200) {
+		putchar('.');
+		putchar('.');
+		c = '.';
+	}
+	putchar(c);
+}

source/s2/pwd.c

@@ -0,0 +1,61 @@
+char dot[] ".";
+char dotdot[] "..";
+char root[] "/";
+char name[512];
+int file, off -1;
+struct statb {int devn, inum, i[18];}x;
+struct entry { int jnum; char name[16];}y;
+
+main() {
+	int n;
+
+loop0:
+	stat(dot, &x);
+	if((file = open(dotdot,0)) < 0) prname();
+loop1:
+	if((n = read(file,&y,16)) < 16) prname();
+	if(y.jnum != x.inum)goto loop1;
+	close(file);
+	if(y.jnum == 1) ckroot();
+	cat();
+	chdir(dotdot);
+	goto loop0;
+}
+ckroot() {
+	int i, n;
+
+	if((n = stat(y.name,&x)) < 0) prname();
+	i = x.devn;
+	if((n = chdir(root)) < 0) prname();
+	if((file = open(root,0)) < 0) prname();
+loop:
+	if((n = read(file,&y,16)) < 16) prname();
+	if(y.jnum == 0) goto loop;
+	if((n = stat(y.name,&x)) < 0) prname();
+	if(x.devn != i) goto loop;
+	x.i[0] =& 060000;
+	if(x.i[0] != 040000) goto loop;
+	if(y.name[0]=='.')if(((y.name[1]=='.') && (y.name[2]==0)) ||
+				(y.name[1] == 0)) goto pr;
+	cat();
+pr:
+	write(1,root,1);
+	prname();
+}
+prname() {
+	if(off<0)off=0;
+	name[off] = '\n';
+	write(1,name,off+1);
+	exit();
+}
+cat() {
+	int i, j;
+
+	i = -1;
+	while(y.name[++i] != 0);
+	if((off+i+2) > 511) prname();
+	for(j=off+1; j>=0; --j) name[j+i+1] = name[j];
+	off=i+off+1;
+	name[i] = root[0];
+	for(--i; i>=0; --i) name[i] = y.name[i];
+}

source/s2/quiz.c

@@ -0,0 +1,460 @@
+#define NF 10
+#define NL 200
+#define NC 200
+#define SL 100
+#define NA 10
+
+int tflag;
+int xx[NL];
+char score[NL];
+int rights;
+int wrongs;
+int guesses;
+int buf[259];
+int nl 0;
+int na NA;
+int inc;
+int ptr 0;
+int nc 0;
+char line[150];
+char response[100];
+char *tmp[NF];
+int select[NF];
+
+readline()
+{
+	char *t;
+loop:
+	for(t=line;(*t=getc(buf))!=-1;t++) {
+		nc++;
+		if(*t==' '&&(t==line||t[-1]==' '))
+			t--;
+		if(*t=='\n') {
+			if(t[-1]=='\\')		/*inexact test*/
+				continue;
+			while(t>line&&t[-1]==' ')
+				*--t = '\n';
+			*++t = 0;
+			return(1);
+		}
+		if(t-line>=NC) {
+			printf("Too hard for me\n");
+			do {
+				*line = getc(buf);
+				if(*line==0377)
+					return(0);
+			} while(*line!='\n');
+			goto loop;
+		}
+	}
+	return(0);
+}
+
+char *eu;
+char *ev;
+cmp(u,v)
+{
+	int x;
+	eu = u;
+	ev = v;
+	x = disj(1);
+	if(x!=1)
+		return(x);
+	return(eat(1,0));
+}
+
+disj(s)
+{
+	int t, x;
+	char *u;
+	u = eu;
+	t = 0;
+	for(;;) {
+		x = string(s);
+		if(x>1)
+			return(x);
+		switch(*ev) {
+		case 0:
+		case ']':
+		case '}':
+			return(t|x&s);
+		case '|':
+			ev++;
+			t =| s;
+			s = 0;
+			continue;
+		}
+		if(s) eu = u;
+		if(string(0)>1)
+			return(2);
+		switch(*ev) {
+		case 0:
+		case ']':
+			return(0);
+		case '}':
+			return(1);
+		case '|':
+			ev++;
+			continue;
+		default:
+			return(2);
+		}
+	}
+}
+
+string(s)
+{
+	int x;
+	for(;;) {
+		switch(*ev) {
+		case 0:
+		case '|':
+		case ']':
+		case '}':
+			return(1);
+		case '\\':
+			ev++;
+			if(*ev==0)
+				return(2);
+			if(*ev=='\n') {
+				ev++;
+				continue;
+			}
+		default:
+			if(eat(s,*ev)==1)
+				continue;
+			return(0);
+		case '[':
+			ev++;
+			x = disj(s);
+			if(*ev!=']' || x>1)
+				return(2);
+			ev++;
+			if(s==0)
+				continue;
+			if(x==0)
+				return(0);
+			continue;
+		case '{':
+			ev++;
+			x = disj(s);
+			if(*ev!='}'||x>1)
+				return(2);
+			ev++;
+			continue;
+		}
+	}
+}
+
+eat(s,c)
+char c;
+{
+	if(*ev!=c)
+		return(2);
+	if(s==0) {
+		ev++;
+		return(1);
+	}
+	if(fold(*eu)!=fold(c))
+		return(0);
+	eu++;
+	ev++;
+	return(1);
+}
+
+fold(c)
+char c;
+{
+	if(c<'A'||c>'Z')
+		return(c);
+	return(c|040);
+}
+
+publish(t)
+char *t;
+{
+	ev = t;
+	pub1(1);
+}
+
+pub1(s)
+{
+	for(;;ev++){
+		switch(*ev) {
+		case '|':
+			s = 0;
+			ev;
+			continue;
+		case ']':
+		case '}':
+		case 0:
+			return;
+		case '[':
+		case '{':
+			ev++;
+			pub1(s);
+			ev;
+			continue;
+		case '\\':
+			if(*++ev=='\n')
+				continue;
+		default:
+			if(s)
+				putchar(*ev);
+		}
+	}
+}
+
+segment(u,w)
+char *u, *w[];
+{
+	char *s;
+	int i;
+	char *t;
+	s = u;
+	for(i=0;i<NF;i++) {
+		u = s;
+		t = w[i];
+		while(*s!=':'&&*s!='\n'&&s-u<SL) {
+			if(*s=='\\')  {
+				if(s[1] == '\n') {
+					s =+ 2;
+					continue;
+				}
+				*t++ = *s++;
+			}
+			*t++ = *s++;
+		}
+
+		while(*s!=':'&&*s!='\n')
+			s++;
+		*t = 0;
+		if(*s++=='\n') {
+			return(i+1);
+		}
+	}
+	printf("Too many facts about one thing\n");
+}
+
+perm(u,m,v,n,p)
+int p[];
+char *u[], *v[];
+{
+	int i, j;
+	int x;
+	for(i=0;i<m;i++) {
+		for(j=0;j<n;j++) {
+			x = cmp(u[i],v[j]);
+			if(x>1) badinfo();
+			if(x==0)
+				continue;
+			p[i] = j;
+			goto uloop;
+		}
+		return(0);
+uloop:		;
+	}
+	return(1);
+}
+
+find(u,m)
+char *u[];
+{
+	int n;
+	while(readline()){
+		n = segment(line,tmp);
+		if(perm(u,m,tmp+1,n-1,select))
+			return(1);
+	}
+	return(0);
+}
+
+readindex()
+{
+	xx[0] = nc = 0;
+	while(readline()) {
+		xx[++nl] = nc;
+		if(nl>=NL) {
+			printf("I've forgotten some of it\n");
+			break;
+		}
+	}
+}
+
+talloc()
+{
+	int i;
+	for(i=0;i<NF;i++)
+		tmp[i] = alloc(SL);
+}
+
+main(argc,argv)
+char *argv[];
+{
+	int i;
+	int x;
+	char *info;
+	int tvec[2];
+	char *t;
+	extern done();
+	int count;
+	info = "/usr/lib/quiz/index";
+	time(tvec);
+	inc = tvec[1]&077774|01;
+loop:
+	if(argc>1&&*argv[1]=='-') {
+		switch(argv[1][1]) {
+		case 'i':
+			if(argc>2) 
+				info = argv[2];
+			argc =- 2;
+			argv =+ 2;
+			goto loop;
+		case 't':
+			tflag = 1;
+			argc--;
+			argv++;
+			goto loop;
+		}
+	}
+	if(fopen(info,buf)== -1) {
+		printf("No info\n");
+		exit();
+	}
+	talloc();
+	if(argc<=2)
+		instruct(info);
+	signal(2,done);
+	argv[argc] = 0;
+	if(find(&argv[1],argc-1)==0)
+		dunno();
+	close(buf[0]);
+	if(fopen(tmp[0],buf)== -1) 
+		dunno();
+	readindex();
+	if(!tflag || na>nl)
+		na = nl;
+	for(;;) {
+		i = next();
+		seek(buf[0],xx[i],0);
+		read(buf[0],line,xx[i+1]-xx[i]);
+		segment(line,tmp);
+		if(*tmp[select[0]] == '\0' || *tmp[select[1]] == '\0') {
+			score[i] = 1;
+			continue;
+		}
+		publish(tmp[select[0]]);
+		printf("\n");
+		for(count=0;;count++) {
+			if(query(response)==0) {
+				publish(tmp[select[1]]);
+				printf("\n");
+				if(count==0) wrongs++;
+				score[i] = tflag?-1:1;
+				break;
+			}
+			x = cmp(response,tmp[select[1]]);
+			if(x>1) badinfo();
+			if(x==1) {
+				printf("Right!\n");
+				if(count==0) rights++;
+				if(++score[i]>=1 && na<nl)
+					na++;
+				break;
+			}
+			printf("What?\n");
+			if(count==0) wrongs++;
+			score[i] = tflag?-1:1;
+		}
+		guesses =+ count;
+	}
+}
+
+query(r)
+char *r;
+{
+	char *t;
+	for(t=r;;t++) {
+		if(read(0,t,1)==0)
+			done();
+		if(*t==' '&&(t==r||t[-1]==' '))
+			t--;
+		if(*t=='\n') {
+			while(t>r&&t[-1]==' ')
+				*--t = '\n';
+			break;
+		}
+	}
+	*t = 0;
+	return(t-r);
+}
+
+next()
+{
+	int flag;
+	inc = inc*3125&077777;
+	ptr = (inc>>2)%na;
+	flag = 0;
+	while(score[ptr]>0)
+		if(++ptr>=na) {
+			ptr = 0;
+			if(flag) done();
+			flag = 1;
+		}
+	return(ptr);
+}
+
+done()
+{
+	printf("\nRights %d, wrongs %d, ", rights, wrongs);
+	if(guesses)
+		printf("extra guesses %d, ", guesses);
+	printf("score %d%%\n",100*rights/(rights+wrongs));
+	exit();
+}
+instruct(info)
+{
+	char *t;
+	int i, n;
+	printf("Subjects:\n\n");
+	while(readline()) {
+		printf("-");
+		n = segment(line,tmp);
+		for(i=1;i<n;i++) {
+			printf(" ");
+			publish(tmp[i]);
+		}
+		printf("\n");
+	}
+	printf("\n");
+	if(fopen(info,buf)== -1)
+		abort();
+	readline();
+	segment(line,tmp);
+	printf("For example,\n");
+	printf("    quiz ");
+	publish(tmp[1]);
+	printf(" ");
+	publish(tmp[2]);
+	printf("\nasks you a ");
+	publish(tmp[1]);
+	printf(" and you answer the ");
+	publish(tmp[2]);
+	printf("\n    quiz ");
+	publish(tmp[2]);
+	printf(" ");
+	publish(tmp[1]);
+	printf("\nworks the other way around\n");
+	printf("\nType empty line to get correct answer.\n");
+	exit();
+}
+
+badinfo(){
+	printf("Bad info %s\n",line);
+}
+
+dunno()
+{
+	printf("I don't know about that\n");
+	exit();
+}

source/s2/rc.c

@@ -0,0 +1,379 @@
+/* Ratfor-Fortran command */
+
+extern int fin, fout;
+char	ts[1000];
+char	*tsp	ts;
+char	*av[50];
+char	*rlist[50];
+int	nr	0;
+char	*llist[50];
+int	nl	0;
+int	nxo	0;
+int	bdcount	0;	/* count block data files generated */
+int	rflag;
+int	dflag	0;
+int	vflag	1;
+int	fflag;
+int	cflag;
+char	*complr "/usr/fort/fc1";
+char	*ratfor "/usr/lib/ratfor";
+
+main(argc, argv)
+char *argv[]; {
+	char *t;
+	int i, j, c;
+	int dexit();
+
+	for(i=0; ++i < argc; ) {
+		if(*argv[i] == '-')
+			switch (argv[i][1]) {
+				default:
+					goto passa;
+				case 'd':
+					dflag = 1;
+					break;
+				case 'v':
+					vflag = 0;
+					break;
+				case 'r':
+					rflag = fflag = cflag = 1;
+					break;
+				case 'f':
+					fflag = 1;
+					break;
+				case 'c':
+					cflag = 1;
+					break;
+				case '2':
+					complr = "/usr/fort/fc2";
+					break;
+			}
+		else {
+	   passa:
+			t = argv[i];
+			if( (c=getsuf(t))=='r' )
+				ratcomp(t);
+			else if( c=='f')  {
+				fortcomp(t);
+				llenter(setsuf(copy(t),'o'));
+			}
+			else
+				llenter(copy(t));
+		}
+	}
+	if(rflag)
+		dexit();
+	if ((signal(2, 1) & 01) == 0)
+		signal(2, &dexit);
+	if(dflag)
+		printf("cflag=%d, nl=%d\n", cflag, nl);
+	if (cflag==0 && nl!=0) {
+		i = 0;
+		av[0] = "ld";
+		av[1] = "-x";
+		av[2] = "/lib/fr0.o";
+		j = 3;
+		while(i<nl)
+			av[j++] = llist[i++];
+		av[j++] = "-lf";
+		av[j++] = "/lib/filib.a";
+		av[j++] = "-l";
+		av[j++] = 0;
+		callsys("/bin/ld", av);
+	}
+	dexit();
+}
+
+dexit()
+{
+	int i;
+	cunlink("ratjunk");
+	cunlink("f.tmp1");
+	exit(0);
+}
+
+
+ratcomp(s) char *s; {
+	int i,j,t,nerr,status;
+	nr = 0;
+	if(vflag)
+		printf("%s:\n",s);
+	av[0] = ratfor;
+	av[1] = s;
+	av[2] = 0;
+	if( (t=fork())==0 ){
+		close(1);
+		fout = creat("ratjunk", 0666);
+		execv(ratfor, av);
+		fout = 2;
+		error("can't ratfor\n");
+		exit(1);
+	}
+	while( t!=wait(&status) );
+	if( (t=(status&0377)) != 0 && t!=14 )
+		dexit(1);
+	t = (status>>8) & 0377;
+	if( t )
+		return(++cflag);
+	splitup();
+	nerr=0;
+	for(i=0; i<nr; i++){
+		if( vflag ) printf("   ");
+		if( fortcomp(rlist[i]) )
+			nerr++;
+	}
+	if( nerr )
+		return(1);
+	av[0] = "ld";
+	av[1] = "-r";
+	av[2] = "-x";
+	j = 3;
+	for(i=0; i<nr; i++)
+		av[j++] = rlist[i];
+	av[j] = 0;
+	callsys("/bin/ld", av);
+	t = setsuf(copy(s),'o');
+	if( move("a.out", t) )
+		cflag++;
+	llenter(t);
+	for(i=0; i<nr; i++) {
+		if( nodup(llist,rlist[i]) )
+			cunlink(rlist[i]);
+		if( fflag==0 )
+			cunlink(setsuf(rlist[i],'f'));
+	}
+}
+
+fortcomp(s) char *s; {
+	int t;
+	if( vflag ) printf("%s:\n", s);
+	av[0] = complr;
+	av[1] = s;
+	av[2] = 0;
+	if( callsys(complr, av) )
+		return(++cflag);
+	av[0] = "as";
+	av[1] = "-";
+	av[2] = "f.tmp1";
+	av[3] = 0;
+	callsys("/bin/as", av);
+	t = setsuf(s, 'o');
+	if( move("a.out", t) )
+		return(++cflag);
+	return(0);
+}
+
+getsuf(s)
+char s[];
+{
+	int c;
+	char t, *os;
+
+	c = 0;
+	os = s;
+	while(t = *s++)
+		if (t=='/')
+			c = 0;
+		else
+			c++;
+	s =- 3;
+	if (c<=14 && c>2 && *s++=='.')
+		return(*s);
+	return(0);
+}
+
+setsuf(s, ch)
+char s[];
+{
+	char *os;
+
+	os = s;
+	while(*s++);
+	s[-2] = ch;
+	return(os);
+}
+
+move(s,t) char *s, *t; {
+	cunlink(t);
+	if(link(s, t) || cunlink(s)) {
+		printf("move failed: %s\n", t);
+		return(1);
+	}
+	return(0);
+}
+
+callsys(f, v)
+char f[], *v[]; {
+	int i, t, status;
+
+	if(dflag){
+		for(i=0; v[i]; i++)
+			printf("%s ", v[i]);
+		putchar('\n');
+	}
+	if ((t=fork())==0) {
+		execv(f, v);
+		printf("Can't find %s\n", f);
+		exit(1);
+	} else
+		if (t == -1) {
+			printf("Try again\n");
+			return(1);
+		}
+	while(t!=wait(&status));
+	if ((t=(status&0377)) != 0 && t!=14) {
+		if (t!=2)		/* interrupt */
+			printf("Fatal error in %s\n", f);
+		dexit();
+	}
+	t = (status>>8) & 0377;
+	if(dflag && status != 0)
+		printf("status = %d\n", t);
+	return(t);
+}
+
+copy(s)
+char s[]; {
+	char *otsp;
+
+	otsp = tsp;
+	while(*tsp++ = *s++);
+	return(otsp);
+}
+
+nodup(l, s)
+char **l, s[]; {
+	char *t, *os, c;
+
+	if (getsuf(s) != 'o')
+		return(1);
+	os = s;
+	while(t = *l++) {
+		s = os;
+		while(c = *s++)
+			if (c != *t++)
+				break;
+		if (*t++ == '\0')
+			return(0);
+	}
+	return(1);
+}
+
+llenter(t) char *t; {
+	if (nodup(llist, t)) {
+		llist[nl++] = t;
+		if (getsuf(t)=='o')
+			nxo++;
+	}
+}
+
+cunlink(f)
+char *f;
+{
+	if( dflag )
+		printf("unlink %s\n", f);
+	if (f==0)
+		return(0);
+	return(unlink(f));
+}
+
+splitup(){
+	char in[200], fname[20];
+	int buf[259];
+	int i,fd,c;
+	if( (fin=open("ratjunk", 0)) < 0)
+		error("can't open ratjunk\n");
+	while( gets(in) ){
+		getname(in, fname);
+		savename(fname);
+		if( (fd = fcreat(fname, buf)) < 0)
+			error("can't open %s", fname);
+		puts(in,buf);
+		while( ! endcard(in) ){
+			gets(in);
+			puts(in,buf);
+		}
+		fflush(buf);
+		close(fd);
+	}
+	close(fin);
+}
+
+gets(s) char *s; {
+	int c;
+	while( (*s++=c=getchar()) != '\n' && c != '\0' );
+	*s = '\0';
+	return(c);
+}
+
+puts(s,b) char *s; int *b; {
+	while( *s )
+		putc(*s++, b);
+}
+
+savename(s) char *s; {
+	rlist[nr++] = copy(s);
+}
+
+getname(s,f) char *s,*f; {
+	int i,j,c;
+   loop:
+	while( *s == ' ' || *s == '\t' )
+		s++;
+	if( compar(s,"subroutine") ){ s =+ 10; goto bot; }
+	else if( compar( s,"function") ){ s =+ 8; goto bot; }
+	else if( compar(s,"real") ){ s =+ 4; goto loop; }
+	else if( compar(s,"integer") ){ s =+ 7; goto loop; }
+	else if( compar(s,"logical") ){ s =+ 7; goto loop; }
+	else if( compar(s,"double") ){ s =+ 6; goto loop; }
+	else if( compar(s,"precision") ){ s =+ 9; goto loop; }
+	else if( compar(s,"complex") ){ s =+ 7; goto loop; }
+	else if( compar(s,"block") ){
+		s = "blockdata ";
+		s[9] = (bdcount++) + '0';
+		goto bot;
+	}
+	else {
+		for(i=0; f[i]="MAIN.f"[i]; i++);
+		return;
+	}
+   bot:
+	while( *s == ' ' || *s == '\t' )
+		s++;
+	for(i=0; alphanum(s[i]); i++)
+		f[i] = s[i];
+	f[i++] = '.';
+	f[i++] = 'f';
+	f[i++] = '\0';
+}
+
+compar(s,t) char *s,*t; {
+	while( *t )
+		if( *s++ != *t++ )
+			return(0);
+	return(1);
+}
+
+alphanum(c) int c; {
+	return( (c>='a' && c<='z')
+		|| (c>='A' && c<='Z')
+		|| (c>='0' && c<='9') );
+}
+
+endcard(s) char *s; {
+	if( *s==0 )
+		return(1);
+	while( *s==' ' || *s=='\t' )
+		s++;
+	if( *s!='e' || *(s+1)!='n' || *(s+2)!='d' || *(s+3)!='\n' )
+		return(0);
+	return(1);
+}
+
+error(s1, s2){
+	fout = 1;
+	printf(s1,s2);
+	putchar('\n');
+	flush(1);
+	cflag++;
+}

source/s2/restor.c

@@ -0,0 +1,552 @@
+#
+
+/*
+ * restore from incremental dumps
+ */
+
+char	*dargv[]
+{
+	0,
+	"t",
+	0
+};
+char	*ifile;
+char	*ofile;
+#include "/usr/sys/ino.h"
+#include "/usr/sys/filsys.h"
+
+struct	filsys	sblock;
+int	isize;
+int	*talist;
+int	fi;
+int	buf[256];
+int	dbuf[256];
+int	cbuf[256];
+char	*date[2];
+char	*ddate[2];
+int	fo;
+int	pher;
+char	*tsize	15000;
+int	iflg;
+int	wflg;
+int	cflg;
+char	file[10];
+int	ilist[100];
+
+main(argc, argv)
+char **argv;
+{
+	char *key;
+	register *tap, *p;
+	register struct inode *ip;
+	int i, com, sz, *q, l;
+
+	ifile = "/dev/mt0";
+	if(argc == 1) {
+		argv = dargv;
+		for(argc = 1; dargv[argc]; argc++);
+	}
+
+	argc--;
+	argv++;
+	key = *argv;
+	while(*key)
+	switch(*key++) {
+	default:
+		printf("bad character in key\n");
+		exit();
+
+	case 't':
+	case 'r':
+	case 'x':
+		com = key[-1];
+		continue;
+
+	case 'i':
+		iflg++;
+		continue;
+
+	case '-':
+		continue;
+
+	case 'c':
+		cflg++;
+		continue;
+
+	case 'f':
+		argv++;
+		argc--;
+		ifile = *argv;
+		continue;
+
+	case 'w':
+		wflg++;
+		continue;
+
+	}
+	otape();
+	sread(buf, 0);
+	tap = buf;
+	isize = *tap++;
+	*tap++;		/* fsize */
+	date[0] = *tap++;
+	date[1] = *tap++;
+	ddate[0] = *tap++;
+	ddate[1] = *tap++;
+	tsize = *tap++;
+	i = size(0, isize*32);
+	talist = sbrk(i*512);
+	tap = talist;
+	while(i--) {
+		tread(tap, 0);
+		tap =+ 256;
+	}
+	switch(com) {
+
+case 't':
+	l = 0;
+	com = 0;
+	pdate(ddate);
+	pdate(date);
+	tap = talist;
+	for(i=0; i<isize*16; i++) {
+		sz = *tap++;
+		if(sz == 0 || sz == -1) {
+			if(com == 0)
+				continue;
+			if(i == com) {
+				printf("%l", i);
+				l =+ 5;
+			} else {
+				printf("%l-%l", com, i);
+				l =+ 10;
+			}
+			if(l > 60) {
+				printf("\n");
+				l = 0;
+			} else
+				printf(",");
+			com = 0;
+		} else
+		if(com == 0)
+			com = i+1;
+	}
+	if(com)
+		printf("%l-\n", com);
+	printf("\n");
+	exit();
+
+case 'r':
+	if(argc <= 1) {
+		printf("no filesystem name\n");
+		exit();
+	}
+	ofile = argv[1];
+	fo = open(ofile, 2);
+	if(fo < 0) {
+		printf("can not open %s\n", ofile);
+		exit();
+	}
+	printf("last chance before scribbling on %s\n", ofile);
+	getchar();
+	dread(1, &sblock);
+	tap = talist;
+	for(i=0; i<sblock.s_isize; i++) {
+		if(i >= isize)
+			break;
+		dread(i+2, buf);
+		for(ip = &buf[0]; ip < &buf[256]; ip++) {
+			sz = *tap++;
+			if(sz == 0)
+				continue;
+			dealoc(ip);
+			if(sz == -1) {
+				for(p = ip; p < &ip->i_mtime[2]; )
+					*p++ = 0;
+				continue;
+			}
+			sread(dbuf, 0);
+			q = dbuf;
+			for(p = ip; p < &ip->i_mtime[2]; )
+				*p++ = *q++;
+			restor(ip, sz-1);
+		}
+		dwrite(i+2, buf);
+	}
+	dwrite(1, &sblock);
+	com = 0;
+	for(; i < isize; i++)
+		for(l = 0; l < 16; l++) {
+			sz = *tap++;
+			if(sz != 0 && sz != -1)
+				com++;
+		}
+	if(com)
+		printf("%l files not restored - small ilist\n", com);
+	exit();
+
+case 'x':
+	i = 0;
+	tap = ilist;
+	while(argc > 1) {
+		i++;
+		sz = number(argv[1]);
+		argv++;
+		argc--;
+		if(sz <= 0 || sz >=isize*16) {
+			printf("%l not in range\n", sz);
+			continue;
+		}
+		if(talist[sz-1] == 0) {
+			printf("%l not dumped\n", sz);
+			continue;
+		}
+		if(talist[sz-1] == -1) {
+			printf("%l does not exist\n", sz);
+			continue;
+		}
+		*tap++ = sz;
+	}
+	if(i != 0 && ilist[0] == 0)
+		exit();
+	tap = talist;
+	for(i=1; i<=isize*16; i++) {
+		if(ilist[0] != 0) {
+			for(sz=0; ilist[sz]; sz++)
+				if(ilist[sz] == i)
+					goto yes;
+			sz = *tap++;
+		no:
+			if(sz == -1)
+				sz = 0;
+			while(sz--)
+				tread(dbuf, 1);
+			continue;
+		}
+	yes:
+		sz = *tap++;
+		if(sz == 0 || sz == -1)
+			continue;
+		fo = dwait(i);
+		if(fo < 0)
+			goto no;
+		sz--;
+		sread(buf, 0);
+		ip = buf;
+		while(sz--) {
+			tread(dbuf, 0);
+			com = 512;
+			if(ip->i_size0 == 0 && ip->i_size1 < 512)
+				com = ip->i_size1;
+			write(fo, dbuf, com);
+			if(com > ip->i_size1)
+				ip->i_size0--;
+			ip->i_size1 =- com;
+		}
+		close(fo);
+		chmod(file, ip->i_mode);
+		chown(file, ip->i_uid);
+	}
+	exit();
+
+	}
+}
+
+dealoc(p)
+struct inode *p;
+{
+	register struct inode *ip;
+	register i, j;
+	int k;
+	int xbuf[256], ybuf[256];
+
+	ip = p;
+	if(ip->i_mode & (IFCHR&IFBLK))
+		return;
+	for(i=7; i>=0; i--)
+	if(ip->i_addr[i]) {
+		if(ip->i_mode&ILARG) {
+			dread(ip->i_addr[i], xbuf);
+			for(j=255; j>=0; j--)
+			if(xbuf[j]) {
+				if(i == 7) {
+					dread(xbuf[j], ybuf);
+					for(k=255; k>=0; k--)
+					if(ybuf[k])
+						free(ybuf[k]);
+				}
+				free(xbuf[j]);
+			}
+		}
+		free(ip->i_addr[i]);
+	}
+}
+
+restor(p, sz)
+struct inode *p;
+{
+	register struct inode *ip;
+	register i, j;
+	int xbuf[256];
+
+	ip = p;
+	if(ip->i_mode & (IFCHR&IFBLK))
+		return;
+	for(i=0; i<8; i++)
+		ip->i_addr[i] = 0;
+	if(sz <= 8) {
+		for(i=0; i<sz; i++)
+			ip->i_addr[i] = rcop();
+		ip->i_mode =& ~ILARG;
+		return;
+	}
+	for(i=0; i<256; i++)
+		xbuf[i] = 0;
+	for(j=0; sz >= 256; j++) {
+		if(j <= 7)
+			ip->i_addr[j] = alloc();
+		if(j >= 7)
+			xbuf[j-7] = alloc();
+		for(i=0; i<256; i++)
+			dbuf[i] = rcop();
+		if(j < 7)
+			dwrite(ip->i_addr[j], dbuf); else
+			dwrite(xbuf[j-7], dbuf);
+		sz =- 256;
+	}
+	if(sz) {
+		if(j <= 7)
+			ip->i_addr[j] = alloc();
+		if(j >= 7)
+			xbuf[j-7] = alloc();
+		for(i=0; i<sz; i++)
+			dbuf[i] = rcop();
+		for(; i<256; i++)
+			dbuf[i] = 0;
+		if(j < 7)
+			dwrite(ip->i_addr[j], dbuf); else
+			dwrite(xbuf[j-7], dbuf);
+	}
+	if(j >= 7)
+		dwrite(ip->i_addr[7], xbuf);
+	ip->i_mode =| ILARG;
+}
+
+rcop()
+{
+	register b;
+
+	b = alloc();
+	tread(cbuf, 0);
+	dwrite(b, cbuf);
+	return(b);
+}
+
+pdate(d)
+int *d;
+{
+
+	if(d[0] == 0 && d[1] == 0)
+		printf("the epoch\n"); else
+		printf(ctime(d));
+}
+
+dread(bno, b)
+{
+
+	seek(fo, bno, 3);
+	if(read(fo, b, 512) != 512) {
+		printf("disk read error %l\n", bno);
+		exit();
+	}
+}
+
+dwrite(bno, b)
+{
+
+	seek(fo, bno, 3);
+	if(write(fo, b, 512) != 512) {
+		printf("disk write error %l\n", bno);
+		exit();
+	}
+}
+
+sread(b, flag)
+int *b;
+{
+	register i, s, *p;
+
+	tread(b, flag);
+	if(flag)
+		return;
+	i = 256;
+	s = 0;
+	p = b;
+	while(i--)
+		s =+ *p++;
+	if(s != 031415) {
+		printf("checksum error\n");
+		if(!iflg)
+			exit();
+	}
+}
+
+tread(b, flag)
+int *b;
+{
+	register c;
+	static char *pta, *ata, ctflg;
+
+	if(pta++ >= tsize) {
+		pta = 1;
+		ata = 0;
+		close(fi);
+		otape();
+		ctflg++;
+	}
+	if(flag)
+		return;
+	if(ctflg) {
+		printf("change tapes\n");
+		if(ctflg > 1)
+			printf("skip %d tapes\n", ctflg-1);
+		while((c = getchar()) != '\n')
+			if(c == 0)
+				exit();
+		ctflg = 0;
+	}
+	ata++;
+	if(iflg)
+	for(; pta != ata; ata++)
+		read(fi, b, 512);
+	if(pta != ata) {
+		seek(fi, pta-ata, 4);
+		ata = pta;
+	}
+	if(read(fi, b, 512) != 512) {
+		printf("tape read error %l\n", ata-1);
+		if(!iflg)
+			exit();
+		for(c=0; c<256; c++)
+			b[c] = 0;
+	}
+}
+
+number(s)
+char *s;
+{
+	register n, c;
+
+	n = 0;
+	while(c = *s++) {
+		if(c<'0' || c>'9')
+			continue;
+		n = n*10+c-'0';
+	}
+	return(n);
+}
+
+size(s0, s1)
+{
+	register s;
+	extern ldivr;
+
+	s = ldiv(s0&0377, s1, 512);
+	if(ldivr)
+		s++;
+	return(s);
+}
+
+otape()
+{
+	register char *p;
+
+	fi = open(ifile, 0);
+	if(fi < 0) {
+		printf("can not open %s\n", ifile);
+		exit();
+	}
+	if(!cflg)
+		return;
+	p = ifile;
+	while(*p++)
+		;
+	p[-2]++;
+}
+
+dwait(ino)
+{
+	register i;
+
+	dconv(ino, file);
+loop:
+	if(wflg) {
+		printf("%s ", file);
+		i = getchar();
+		if(i == 'x')
+			exit();
+		if(i == '\n')
+			return(-1);
+		if(i != 'y')
+			goto flush;
+		i = getchar();
+		if(i != '\n') {
+		flush:
+			while((i=getchar()) != '\n')
+				if(i == '\0')
+					exit();
+			goto loop;
+		}
+	}
+	i = creat(file, 0666);
+	return(i);
+}
+
+dconv(n, p)
+char *p;
+{
+	register i;
+
+	if(i = ldiv(0, n, 10))
+		p = dconv(i, p);
+	*p++ = lrem(0, n, 10) + '0';
+	*p = '\0';
+	return(p);
+}
+
+alloc()
+{
+	register b, i;
+
+	i = --sblock.s_nfree;
+	if(i<0 || i>=100) {
+		printf("bad freeblock\n");
+		exit();
+	}
+	b = sblock.s_free[i];
+	if(b == 0) {
+		printf("out of freelist\n");
+		exit();
+	}
+	if(sblock.s_nfree <= 0) {
+		dread(b, cbuf);
+		sblock.s_nfree = cbuf[0];
+		for(i=0; i<100; i++)
+			sblock.s_free[i] = cbuf[i+1];
+	}
+	return(b);
+}
+
+free(in)
+{
+	register i;
+
+	if(sblock.s_nfree >= 100) {
+		cbuf[0] = sblock.s_nfree;
+		for(i=0; i<100; i++)
+			cbuf[i+1] = sblock.s_free[i];
+		sblock.s_nfree = 0;
+		dwrite(in, cbuf);
+	}
+	sblock.s_free[sblock.s_nfree++] = in;
+}

source/s2/rew.s

@@ -0,0 +1,47 @@
+/ rew -- rewind dec/mag tape
+
+	cmp	(sp)+,$2
+	blt	1f
+	tst	(sp)+
+	mov	(sp)+,r0
+	movb	(r0)+,r1
+	cmp	r1,$'m
+	beq	rewm
+	movb	r1,tapx+8
+	tstb	(r0)
+	bne	error
+1:
+	sys	open; tapx; 0
+	br	rew
+
+rewm:
+	movb	(r0)+,r1
+	beq	1f
+	movb	r1,mtx+7
+	tstb	(r0)
+	bne	error
+1:
+	sys	open; mtx; 0
+
+rew:
+	bes	error
+	sys	read; word; 2
+	bes	error
+	sys	exit
+
+error:
+	mov	$1,r0
+	sys	write; 0f; 2
+	sys	exit
+0:
+	<?\n>
+
+tapx:
+	</dev/tap0\0>
+mtx:
+	</dev/mt0\0>
+	.even
+
+.bss
+word:	.=.+2
+

source/s2/rm.c

@@ -0,0 +1,107 @@
+main(argc, argv)
+char *argv[];
+{
+	char *arg;
+	int fflg, rflg;
+
+	fflg = 0;
+	rflg = 0;
+	while(--argc > 0) {
+
+		arg = *++argv;
+		if(arg[0] == '-') {
+			if(arg[1] == 'f') {
+				fflg++;
+				continue;
+			}
+			if(arg[1] == 'r') {
+				rflg++;
+				continue;
+			}
+		}
+
+		rm(arg, fflg, rflg);
+	}
+}
+
+struct stbuf	{
+	int dev;
+	int inum;
+	int mode;
+	char nlink;
+	char uid;
+	char gid;
+	char siz0;
+	char siz1;
+	int addr[8];
+	int adate[2];
+	int mdate[2];
+	};
+
+rm(arg, fflg, rflg)
+char arg[];
+{
+	char *p;
+	int buf[20];
+	int i, b;
+
+	if(stat(arg, buf)) {
+		printf("%s: non existent\n", arg);
+		return;
+	}
+	if((buf->mode & 060000) == 040000)	{
+		if(rflg) {
+			i = fork();
+			if(i == -1) {
+				printf("%s: try again\n", arg);
+				return;
+			}
+			if(i) {
+				while(wait() != i);
+				return;
+			}
+			if(chdir(arg)) {
+				printf("%s: cannot chdir\n", arg);
+				exit();
+			}
+			p = 0;
+			execl("/etc/glob", "glob", "rm", "-r",
+				fflg? "-f": "*", fflg? "*": p, 0);
+			printf("%s: no glob\n", arg);
+			exit();
+		}
+		printf("%s: directory\n", arg);
+		return;
+	}
+
+	if(!fflg) {
+
+		if((getuid()&0377) == buf->uid)
+			b = 0200; else
+			b = 2;
+		if((buf->mode & b) == 0 && ttyn(0) != 'x') {
+			printf("%s: %o mode ", arg, buf->mode);
+			i = b = getchar();
+			i = b;
+			while(b != '\n' && b != '\0')
+				b = getchar();
+			if(i != 'y')
+				return;
+		}
+	}
+	if(unlink(arg))
+		printf("%s: not removed\n", arg);
+}
+
+putchar(c)
+{
+	write(1, &c, 1);
+}
+
+getchar()
+{
+	char c;
+
+	if(read(0, &c, 1) != 1) return(0);
+	return(c);
+}

source/s2/rmdir.s

@@ -0,0 +1,106 @@
+/ rmdir -- unlink directory
+
+	mov	(sp)+,r5
+	tst	(sp)+
+
+loop:
+	dec	r5
+	ble	done
+	mov	(sp)+,r1
+	mov	$name,r2
+	clr	r0
+1:
+	inc	r0
+	movb	(r1)+,(r2)+
+	bne	1b
+	dec	r2
+	dec	r0
+	mov	r0,size
+	cmp	r2,$name
+	beq	error
+	sys	stat; name; stbuf
+	bes	error
+	bic	$!60000,stbuf+4
+	cmp	$40000,stbuf+4
+	bne	error
+	cmpb	-1(r2),$'.
+	bne	1f
+	cmp	r2,$name+1
+	beq	error
+	cmpb	-2(r2),$'/
+	beq	error
+	cmpb	-2(r2),$'.
+	bne	1f
+	cmp	r2,$name+2
+	beq	error
+	cmpb	-3(r2),$'/
+	beq	error
+1:
+	sys	open; name; 0
+	bes	error
+	mov	r0,r1
+1:
+	mov	r1,r0
+	sys	read; stbuf; 16.
+	bes	1f
+	tst	r0
+	beq	1f
+	tst	stbuf
+	beq	1b
+	cmpb	stbuf+2,$'.
+	bne	error1
+	tstb	stbuf+3
+	beq	1b
+	cmpb	stbuf+3,$'.
+	bne	error1
+	tstb	stbuf+4
+	beq	1b
+
+error1:
+	jsr	pc,prname
+	mov	r1,r0
+	sys	close
+	mov	$1,r0
+	sys	write; mes1; emes1-mes1
+	br	loop
+
+1:
+	mov	r1,r0
+	sys	close
+	movb	$'/,(r2)+
+	movb	$'.,(r2)+
+	movb	$'.,(r2)+
+	clrb	(r2)
+	sys	unlink; name
+	clrb	-(r2)
+	sys	unlink; name
+	clrb	-2(r2)
+	sys	unlink; name
+	br	loop
+
+error:
+	jsr	pc,prname
+	mov	$1,r0
+	sys	write; mes2; emes2-mes2
+	br	loop
+
+prname:
+	mov	$1,r0
+	sys	write; name; size:..
+	rts	pc
+
+done:
+	sys	exit
+
+mes1:
+	< -- directory not empty\n>
+emes1:
+mes2:
+	< ?\n>
+emes2:
+	.even
+
+.bss
+name:	.=.+40.
+stbuf:	.=.+40.
+

source/s2/run

@@ -0,0 +1,228 @@
+cc -s -O mail.c
+cmp a.out /bin/mail
+cp a.out /bin/mail
+
+cc -s -O mesg.c
+cmp a.out /usr/bin/mesg
+cp a.out /usr/bin/mesg
+
+as mkdir.s
+strip a.out
+cmp a.out /bin/mkdir
+cp a.out /bin/mkdir
+
+cc -s -O mkfs.c
+cmp a.out /etc/mkfs
+cp a.out /etc/mkfs
+
+cc -s -O mknod.c
+cmp a.out /etc/mknod
+cp a.out /etc/mknod
+
+cc -s -O mount.c
+cmp a.out /etc/mount
+cp a.out /etc/mount
+
+cc -s -O mv.c
+cmp a.out /bin/mv
+cp a.out /bin/mv
+
+cc -s -O ncheck.c
+cmp a.out /bin/ncheck
+cp a.out /bin/ncheck
+
+cc -s -O newgrp.c
+cmp a.out /bin/newgrp
+cp a.out /bin/newgrp
+
+cc -s -O nice.c
+cmp a.out /usr/bin/nice
+cp a.out /usr/bin/nice
+
+cc -s -O nm.c
+cmp a.out /bin/nm
+cp a.out /bin/nm
+
+cc -s -O nohup.c
+cmp a.out /usr/bin/nohup
+cp a.out /usr/bin/nohup
+
+cc -s -O od.c
+cmp a.out /bin/od
+cp a.out /bin/od
+
+cc -s -O opr.c
+cmp a.out /bin/opr
+cp a.out /bin/opr
+
+cc -s -O passwd.c
+cmp a.out /bin/passwd
+cp a.out /bin/passwd
+
+as pfe.s
+strip a.out
+cmp a.out /usr/bin/pfe
+cp a.out /usr/bin/pfe
+
+cc -s -O pr.c
+cmp a.out /bin/pr
+cp a.out /bin/pr
+
+cc -s -f -O prof.c
+cmp a.out /usr/bin/prof
+cp a.out /usr/bin/prof
+
+cc -s -O ps.c
+cmp a.out /bin/ps
+cp a.out /bin/ps
+
+cc -s -O ptx.c
+cmp a.out /usr/bin/ptx
+cp a.out /usr/bin/ptx
+
+cc -s -O pwd.c
+cmp a.out /usr/bin/pwd
+cp a.out /usr/bin/pwd
+
+cc -s -O quiz.c
+cmp a.out /usr/bin/quiz
+cp a.out /usr/bin/quiz
+
+cc -s -O rc.c
+cmp a.out /usr/bin/rc
+cp a.out /usr/bin/rc
+
+cc -s -O restor.c
+cmp a.out /bin/restor
+cp a.out /bin/restor
+
+as rew.s
+strip a.out
+cmp a.out /bin/rew
+cp a.out /bin/rew
+
+cc -s -O rm.c
+cmp a.out /bin/rm
+cp a.out /bin/rm
+
+as rmdir.s
+strip a.out
+cmp a.out /bin/rmdir
+cp a.out /bin/rmdir
+
+cc -s -f -O sa.c
+cmp a.out /usr/bin/sa
+cp a.out /usr/bin/sa
+
+cc -s -n -O sh.c
+cmp a.out /bin/sh
+cp a.out /bin/sh
+
+cc -s -O size.c
+cmp a.out /bin/size
+cp a.out /bin/size
+
+cc -s -O sleep.c
+cmp a.out /usr/bin/sleep
+cp a.out /usr/bin/sleep
+
+cc -s -O sort.c
+cmp a.out /bin/sort
+cp a.out /bin/sort
+
+cc -s -O split.c
+cmp a.out /usr/bin/split
+cp a.out /usr/bin/split
+
+as strip.s
+strip a.out
+cmp a.out /bin/strip
+cp a.out /bin/strip
+
+cc -s -O stty.c
+cmp a.out /bin/stty
+cp a.out /bin/stty
+
+cc -s -O su.c
+cmp a.out /bin/su
+cp a.out /bin/su
+
+as sum.s
+strip a.out
+cmp a.out /bin/sum
+cp a.out /bin/sum
+
+cc -s -O sync.c
+cmp a.out /bin/sync
+cp a.out /bin/sync
+
+cc -s -O tbl.c -lp
+cmp a.out /usr/bin/tbl
+cp a.out /usr/bin/tbl
+
+cc -s -O tee.c
+cmp a.out /usr/bin/tee
+cp a.out /usr/bin/tee
+
+as time.s
+strip a.out
+cmp a.out /bin/time
+cp a.out /bin/time
+
+as tp?.s
+ld a.out -lc -l
+cmp a.out /bin/tp
+cp a.out /bin/tp
+
+cc -s -O tr.c
+cmp a.out /usr/bin/tr
+cp a.out /usr/bin/tr
+
+as tty.s
+ld -s a.out -l
+cmp a.out /bin/tty
+cp a.out /bin/tty
+
+cc -s -f -O typo.c
+cmp a.out /usr/bin/typo
+cp a.out /usr/bin/typo
+
+cc -s -O umount.c
+cmp a.out /etc/umount
+cp a.out /etc/umount
+
+cc -s -O uniq.c
+cmp a.out /bin/uniq
+cp a.out /bin/uniq
+
+cc -s -f -O units.c
+cmp a.out /usr/bin/units
+cp a.out /usr/bin/units
+
+as update.s
+strip a.out
+cmp a.out /etc/update
+cp a.out /etc/update
+
+cc -s -O usort.c
+cmp a.out /usr/bin/usort
+cp a.out /usr/bin/usort
+
+cc -s -O wall.c
+cmp a.out /etc/wall
+cp a.out /etc/wall
+
+cc -s -O wc.c
+cmp a.out /usr/bin/wc
+cp a.out /usr/bin/wc
+
+cc -s -O who.c
+cmp a.out /bin/who
+cp a.out /bin/who
+
+as write.s
+ld -s a.out -l
+cmp a.out /bin/write
+cp a.out /bin/write
+
+rm a.out

source/s2/sa.c

@@ -0,0 +1,470 @@
+#define size 2000
+/* interpret command time accounting */
+
+int	lflg;
+int	cflg;
+int	jflg;
+int	nflg;
+int	aflg;
+int	rflg;
+int	tflg;
+int	vflg;
+int	uflg;
+int	thres	1;
+int	sflg;
+int	bflg;
+int	mflg;
+int	fout;
+
+struct	user {
+	int	ncomm;
+	int	fill;
+	float	fctime;
+} user[256];
+struct tab {
+	char name[8];
+	int count;
+	float realt;
+	float cput;
+	float syst;
+} tab[size];
+
+struct ftab {
+	char	fname[14];
+	char	shf;
+	char	uid;
+	int	fdatet[2];
+	int	frealt[2];
+	int	fcput[2];
+	int	fsyst[2];
+};
+float	treal;
+float	tcpu;
+float	tsys;
+int	junkp -1;
+char	*sname;
+float	ncom;
+
+main(argc, argv)
+char **argv;
+{
+	int i, j, k;
+	extern tcmp(), ncmp(), bcmp();
+	extern float sum();
+	float ft;
+
+	init();
+	if (argc>1)
+	if (argv[1][0]=='-') {
+		argv++;
+		argc--;
+		for(i=1; argv[0][i]; i++)
+		switch(argv[0][i]) {
+
+		case 'b':
+			bflg++;
+			break;
+
+		case 'l':
+			lflg++;
+			break;
+
+		case 'c':
+			cflg++;
+			break;
+
+		case 'j':
+			jflg++;
+			break;
+
+		case 'n':
+			nflg++;
+			break;
+
+		case 'a':
+			aflg++;
+			break;
+
+		case 'r':
+			rflg++;
+			break;
+
+		case 't':
+			tflg++;
+			break;
+
+		case 's':
+			sflg++;
+			aflg++;
+			break;
+
+		case '0':
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+			thres = argv[0][i]-'0';
+			break;
+
+		case 'v':
+			vflg++;
+			break;
+
+		case 'u':
+			uflg++;
+			break;
+
+		case 'm':
+			mflg++;
+			break;
+		}
+	}
+	fout = dup(1);
+	if (argc<2)
+		acct("/usr/adm/sha");
+	else while (--argc)
+		acct(*++argv);
+	if (uflg) {
+		flush();
+		return;
+	}
+
+/*
+ * cleanup pass
+ * put junk together
+ */
+
+	if (vflg)
+		strip();
+	if(!aflg)
+	for (i=0; i<size; i++)
+	if (tab[i].name[0]) {
+		for(j=0; j<8; j++)
+			if(tab[i].name[j] == '?')
+				goto yes;
+		if(tab[i].count != 1)
+			continue;
+	yes:
+		if(junkp == -1)
+			junkp = enter("***other");
+		tab[junkp].count =+ tab[i].count;
+		tab[junkp].realt =+ tab[i].realt;
+		tab[junkp].cput =+ tab[i].cput;
+		tab[junkp].syst =+ tab[i].syst;
+		tab[i].name[0] = 0;
+	}
+	for(i=k=0; i<size; i++)
+	if(tab[i].name[0]) {
+		for(j=0; j<8; j++)
+			tab[k].name[j] = tab[i].name[j];
+		tab[k].count = tab[i].count;
+		tab[k].realt = tab[i].realt;
+		tab[k].cput = tab[i].cput;
+		tab[k].syst = tab[i].syst;
+		k++;
+	}
+	if (sflg) {
+		signal(2, 1);
+		i = creat("/usr/adm/shm", 0666);
+		write(i, user, sizeof(user));
+		close(i);
+		if ((i = creat("/usr/adm/sht", 0666))<0) {
+			printf("Can't save\n");
+			exit();
+		}
+		write(i, tab, k*sizeof(*tab));
+		close(i);
+		if (sname) {
+			if ((i = creat(sname, 0666))<0)
+				printf("Can't truncate\n");
+			close(i);
+		}
+		signal(2, 0);
+	}
+/*
+ * sort and print
+ */
+
+	if (mflg) {
+		printmoney();
+		flush();
+		exit();
+	}
+	qsort(tab, k, 22, nflg? &ncmp: (bflg?&bcmp:&tcmp));
+	printf("%8s", "");
+	column(ncom, treal, tcpu, tsys);
+	for (i=0; i<k; i++)
+	if (tab[i].name[0]) {
+		ft = tab[i].count;
+		printf("%-8.8s", tab[i].name);
+		column(ft, tab[i].realt, tab[i].cput, tab[i].syst);
+	}
+	flush();
+}
+
+printmoney()
+{
+	register i;
+	char buf[128];
+	register char *cp;
+
+	for (i=0; i<256; i++) {
+		if (user[i].ncomm) {
+			if (getpw(i, buf)!=0)
+				printf("%-8d", i);
+			else {
+				cp = buf;
+				while (*cp!=':' &&*cp!='\n' && *cp)
+					cp++;
+				*cp = 0;
+				printf("%-8s", buf);
+			}
+			printf("%5l %7.2f\n",
+			    user[i].ncomm, user[i].fctime/60);
+		}
+	}
+}
+
+column(n, a, b, c)
+double n, a, b, c;
+{
+
+	printf("%6.0f", n);
+	if(cflg) {
+		if(n == ncom)
+			printf("%7s", ""); else
+			printf("%6.2f%%", 100.*n/ncom);
+	}
+	col(n, a, treal);
+	if(lflg) {
+		col(n, b, tcpu);
+		col(n, c, tsys);
+	} else
+		col(n, b+c, tcpu+tsys);
+	if(tflg)
+		printf("%6.1f", a/(b+c));
+	putchar('\n');
+}
+
+col(n, a, m)
+double n, a, m;
+{
+
+	if(jflg)
+		printf("%9.2f", a/(n*60.)); else
+		printf("%9.2f", a/3600.);
+	if(cflg) {
+		if(a == m)
+			printf("%7s", ""); else
+			printf("%6.2f%%", 100.*a/m);
+	}
+}
+
+acct(f)
+char *f;
+{
+	int ff, i, j;
+	float x;
+	struct ftab fbuf;
+	register char *cp;
+	register int c;
+	extern double ltod();
+
+	if (sflg && sname) {
+		printf("Only 1 file with -s\n");
+		exit();
+	}
+	if (sflg)
+		sname = f;
+	if ((ff=open(f, 0))<0) {
+		printf("Can't open %s\n", f);
+		return;
+	}
+	while (read(ff, &fbuf, sizeof(fbuf))==sizeof(fbuf)) {
+		for (cp = fbuf.name; cp < &fbuf.name[8]; cp++) {
+			c = *cp & 0377;
+			if (c && (c < ' ' || c >= 0200))
+				*cp = '?';
+		}
+		if (uflg) {
+			printdate(fbuf.fdatet);
+			printf(" %3d %.8s\n", fbuf.uid, fbuf.name);
+			continue;
+		}
+		if (fbuf.shf==0) {
+			c = fbuf.uid&0377;
+			user[c].ncomm++;
+			user[c].fctime =+ (ltod(fbuf.fcput)+ltod(fbuf.fsyst))/60;
+		}
+		ncom =+ 1.0;
+		i = enter(&fbuf);
+		tab[i].count++;
+		x = ltod(fbuf.frealt);
+		x =* 60.;
+		tab[i].realt =+ x;
+		treal =+ x;
+		x = ltod(fbuf.fcput);
+		tab[i].cput =+ x;
+		tcpu =+ x;
+		x = ltod(fbuf.fsyst);
+		tab[i].syst =+ x;
+		tsys =+ x;
+	}
+	close(ff);
+}
+
+ncmp(p1, p2)
+struct tab *p1, *p2;
+{
+
+	if(p1->count == p2->count)
+		return(tcmp(p1, p2));
+	if(rflg)
+		return(p1->count - p2->count);
+	return(p2->count - p1->count);
+}
+
+bcmp(p1, p2)
+struct tab *p1, *p2;
+{
+	float f1, f2;
+	float sum();
+
+	f1 = sum(p1)/p1->count;
+	f2 = sum(p2)/p2->count;
+	if(f1 < f2) {
+		if(rflg)
+			return(-1);
+		return(1);
+	}
+	if(f1 > f2) {
+		if(rflg)
+			return(1);
+		return(-1);
+	}
+	return(0);
+}
+tcmp(p1, p2)
+struct tab *p1, *p2;
+{
+	extern float sum();
+	float f1, f2;
+
+	f1 = sum(p1);
+	f2 = sum(p2);
+	if(f1 < f2) {
+		if(rflg)
+			return(-1);
+		return(1);
+	}
+	if(f1 > f2) {
+		if(rflg)
+			return(1);
+		return(-1);
+	}
+	return(0);
+}
+
+float sum(p)
+struct tab *p;
+{
+
+	if(p->name[0] == 0)
+		return(0.0);
+	return(
+		p->cput+
+		p->syst);
+}
+
+init()
+{
+	struct tab tbuf;
+	int i, j, f;
+
+	if ((f=open("/usr/adm/sht", 0))<0)
+		goto gshm;
+	while (read(f, &tbuf, sizeof(tbuf)) == sizeof(tbuf)) {
+		i = enter(&tbuf);
+		ncom =+ tbuf.count;
+		tab[i].count = tbuf.count;
+		treal =+ tbuf.realt;
+		tab[i].realt = tbuf.realt;
+		tcpu =+ tbuf.cput;
+		tab[i].cput = tbuf.cput;
+		tsys =+ tbuf.syst;
+		tab[i].syst = tbuf.syst;
+	}
+	close(f);
+ gshm:
+	if ((f=open("/usr/adm/shm", 0)) < 0)
+		return;
+	read(f, user, sizeof(user));
+	close(f);
+}
+
+enter(fbuf)
+struct ftab *fbuf;
+{
+	int i, j;
+
+	i = 0;
+	for (j=0; j<8; j++) {
+		i = i*7 + fbuf->fname[j];
+	}
+	if(i < 0)
+		i = -i;
+	for (i=%size; tab[i].name[0]; i = (i+1)%size) {
+		for (j=0; j<8; j++)
+			if (tab[i].name[j]!=fbuf->fname[j])
+				goto no;
+		goto yes;
+	no:;
+	}
+	for (j=0; j<8; j++)
+		tab[i].name[j] = fbuf->fname[j];
+yes:
+	return(i);
+}
+
+strip()
+{
+	int i, j, k, c;
+
+	j = enter("**junk**");
+	for (i = 0; i<size; i++) {
+		if (tab[i].name[0] && tab[i].count<=thres) {
+			printf("%.8s--", tab[i].name);
+			flush();
+			if ((c=getchar())=='y') {
+				tab[i].name[0] = '\0';
+				tab[j].count =+ tab[i].count;
+				tab[j].realt =+ tab[i].realt;
+				tab[j].cput =+ tab[i].cput;
+				tab[j].syst =+ tab[i].syst;
+			}
+			while (c && c!='\n')
+				c = getchar();
+		}
+	}
+}
+
+printdate(tvec)
+int tvec[2];
+{
+	int *lt;
+	int *localtime();
+
+	lt = localtime(tvec);
+	printf("%3d %c%c%c %d", lt[7], 
+		pair(lt[2]), pair(lt[1]), pair(lt[0]), lt[6]);
+}
+
+pair(n)
+{
+	return(n/10+'0' | (n%10+'0')<<8);
+}

source/s2/sh.c

@@ -0,0 +1,898 @@
+#
+/*
+ */
+
+#define	INTR	2
+#define	QUIT	3
+#define LINSIZ 1000
+#define ARGSIZ 50
+#define TRESIZ 100
+
+#define QUOTE 0200
+#define FAND 1
+#define FCAT 2
+#define FPIN 4
+#define FPOU 8
+#define FPAR 16
+#define FINT 32
+#define FPRS 64
+#define TCOM 1
+#define TPAR 2
+#define TFIL 3
+#define TLST 4
+#define DTYP 0
+#define DLEF 1
+#define DRIT 2
+#define DFLG 3
+#define DSPR 4
+#define DCOM 5
+#define	ENOMEM	12
+#define	ENOEXEC 8
+
+char	*dolp;
+char	pidp[6];
+int	ldivr;
+char	**dolv;
+int	dolc;
+char	*promp;
+char	*linep;
+char	*elinep;
+char	**argp;
+char	**eargp;
+int	*treep;
+int	*treeend;
+char	peekc;
+char	gflg;
+char	error;
+char	acctf;
+char	uid;
+char	setintr;
+char	*arginp;
+int	onelflg;
+
+char	*mesg[] {
+	0,
+	"Hangup",
+	0,
+	"Quit",
+	"Illegal instruction",
+	"Trace/BPT trap",
+	"IOT trap",
+	"EMT trap",
+	"Floating exception",
+	"Killed",
+	"Bus error",
+	"Memory fault",
+	"Bad system call",
+	0,
+	"Sig 14",
+	"Sig 15",
+	"Sig 16",
+	"Sig 17",
+	"Sig 18",
+	"Sig 19",
+};
+
+struct stime {
+	int proct[2];
+	int cputim[2];
+	int systim[2];
+} timeb;
+
+char	line[LINSIZ];
+char	*args[ARGSIZ];
+int	trebuf[TRESIZ];
+
+main(c, av)
+int c;
+char **av;
+{
+	register f;
+	register char *acname, **v;
+
+	for(f=2; f<15; f++)
+		close(f);
+	if((f=dup(1)) != 2)
+		close(f);
+	dolc = getpid();
+	for(f=4; f>=0; f--) {
+		dolc = ldiv(0, dolc, 10);
+		pidp[f] = ldivr+'0';
+	}
+	v = av;
+	acname = "/usr/adm/sha";
+	promp = "% ";
+	if(((uid = getuid())&0377) == 0)
+		promp = "# ";
+	acctf = open(acname, 1);
+	if(c > 1) {
+		promp = 0;
+		if (*v[1]=='-') {
+			**v = '-';
+			if (v[1][1]=='c' && c>2)
+				arginp = v[2];
+			else if (v[1][1]=='t')
+				onelflg = 2;
+		} else {
+			close(0);
+			f = open(v[1], 0);
+			if(f < 0) {
+				prs(v[1]);
+				err(": cannot open");
+			}
+		}
+	}
+	if(**v == '-') {
+		setintr++;
+		signal(QUIT, 1);
+		signal(INTR, 1);
+	}
+	dolv = v+1;
+	dolc = c-1;
+
+loop:
+	if(promp != 0)
+		prs(promp);
+	peekc = getc();
+	main1();
+	goto loop;
+}
+
+main1()
+{
+	register char c, *cp;
+	register *t;
+
+	argp = args;
+	eargp = args+ARGSIZ-5;
+	linep = line;
+	elinep = line+LINSIZ-5;
+	error = 0;
+	gflg = 0;
+	do {
+		cp = linep;
+		word();
+	} while(*cp != '\n');
+	treep = trebuf;
+	treeend = &trebuf[TRESIZ];
+	if(gflg == 0) {
+		if(error == 0) {
+			setexit();
+			if (error)
+				return;
+			t = syntax(args, argp);
+		}
+		if(error != 0)
+			err("syntax error"); else
+			execute(t);
+	}
+}
+
+word()
+{
+	register char c, c1;
+
+	*argp++ = linep;
+
+loop:
+	switch(c = getc()) {
+
+	case ' ':
+	case '\t':
+		goto loop;
+
+	case '\'':
+	case '"':
+		c1 = c;
+		while((c=readc()) != c1) {
+			if(c == '\n') {
+				error++;
+				peekc = c;
+				return;
+			}
+			*linep++ = c|QUOTE;
+		}
+		goto pack;
+
+	case '&':
+	case ';':
+	case '<':
+	case '>':
+	case '(':
+	case ')':
+	case '|':
+	case '^':
+	case '\n':
+		*linep++ = c;
+		*linep++ = '\0';
+		return;
+	}
+
+	peekc = c;
+
+pack:
+	for(;;) {
+		c = getc();
+		if(any(c, " '\"\t;&<>()|^\n")) {
+			peekc = c;
+			if(any(c, "\"'"))
+				goto loop;
+			*linep++ = '\0';
+			return;
+		}
+		*linep++ = c;
+	}
+}
+
+tree(n)
+int n;
+{
+	register *t;
+
+	t = treep;
+	treep =+ n;
+	if (treep>treeend) {
+		prs("Command line overflow\n");
+		error++;
+		reset();
+	}
+	return(t);
+}
+
+getc()
+{
+	register char c;
+
+	if(peekc) {
+		c = peekc;
+		peekc = 0;
+		return(c);
+	}
+	if(argp > eargp) {
+		argp =- 10;
+		while((c=getc()) != '\n');
+		argp =+ 10;
+		err("Too many args");
+		gflg++;
+		return(c);
+	}
+	if(linep > elinep) {
+		linep =- 10;
+		while((c=getc()) != '\n');
+		linep =+ 10;
+		err("Too many characters");
+		gflg++;
+		return(c);
+	}
+getd:
+	if(dolp) {
+		c = *dolp++;
+		if(c != '\0')
+			return(c);
+		dolp = 0;
+	}
+	c = readc();
+	if(c == '\\') {
+		c = readc();
+		if(c == '\n')
+			return(' ');
+		return(c|QUOTE);
+	}
+	if(c == '$') {
+		c = readc();
+		if(c>='0' && c<='9') {
+			if(c-'0' < dolc)
+				dolp = dolv[c-'0'];
+			goto getd;
+		}
+		if(c == '$') {
+			dolp = pidp;
+			goto getd;
+		}
+	}
+	return(c&0177);
+}
+
+readc()
+{
+	char cc;
+	register c;
+
+	if (arginp) {
+		if (arginp == 1)
+			exit();
+		if ((c = *arginp++) == 0) {
+			arginp = 1;
+			c = '\n';
+		}
+		return(c);
+	}
+	if (onelflg==1)
+		exit();
+	if(read(0, &cc, 1) != 1)
+		exit();
+	if (cc=='\n' && onelflg)
+		onelflg--;
+	return(cc);
+}
+
+/*
+ * syntax
+ *	empty
+ *	syn1
+ */
+
+syntax(p1, p2)
+char **p1, **p2;
+{
+
+	while(p1 != p2) {
+		if(any(**p1, ";&\n"))
+			p1++; else
+			return(syn1(p1, p2));
+	}
+	return(0);
+}
+
+/*
+ * syn1
+ *	syn2
+ *	syn2 & syntax
+ *	syn2 ; syntax
+ */
+
+syn1(p1, p2)
+char **p1, **p2;
+{
+	register char **p;
+	register *t, *t1;
+	int l;
+
+	l = 0;
+	for(p=p1; p!=p2; p++)
+	switch(**p) {
+
+	case '(':
+		l++;
+		continue;
+
+	case ')':
+		l--;
+		if(l < 0)
+			error++;
+		continue;
+
+	case '&':
+	case ';':
+	case '\n':
+		if(l == 0) {
+			l = **p;
+			t = tree(4);
+			t[DTYP] = TLST;
+			t[DLEF] = syn2(p1, p);
+			t[DFLG] = 0;
+			if(l == '&') {
+				t1 = t[DLEF];
+				t1[DFLG] =| FAND|FPRS|FINT;
+			}
+			t[DRIT] = syntax(p+1, p2);
+			return(t);
+		}
+	}
+	if(l == 0)
+		return(syn2(p1, p2));
+	error++;
+}
+
+/*
+ * syn2
+ *	syn3
+ *	syn3 | syn2
+ */
+
+syn2(p1, p2)
+char **p1, **p2;
+{
+	register char **p;
+	register int l, *t;
+
+	l = 0;
+	for(p=p1; p!=p2; p++)
+	switch(**p) {
+
+	case '(':
+		l++;
+		continue;
+
+	case ')':
+		l--;
+		continue;
+
+	case '|':
+	case '^':
+		if(l == 0) {
+			t = tree(4);
+			t[DTYP] = TFIL;
+			t[DLEF] = syn3(p1, p);
+			t[DRIT] = syn2(p+1, p2);
+			t[DFLG] = 0;
+			return(t);
+		}
+	}
+	return(syn3(p1, p2));
+}
+
+/*
+ * syn3
+ *	( syn1 ) [ < in  ] [ > out ]
+ *	word word* [ < in ] [ > out ]
+ */
+
+syn3(p1, p2)
+char **p1, **p2;
+{
+	register char **p;
+	char **lp, **rp;
+	register *t;
+	int n, l, i, o, c, flg;
+
+	flg = 0;
+	if(**p2 == ')')
+		flg =| FPAR;
+	lp = 0;
+	rp = 0;
+	i = 0;
+	o = 0;
+	n = 0;
+	l = 0;
+	for(p=p1; p!=p2; p++)
+	switch(c = **p) {
+
+	case '(':
+		if(l == 0) {
+			if(lp != 0)
+				error++;
+			lp = p+1;
+		}
+		l++;
+		continue;
+
+	case ')':
+		l--;
+		if(l == 0)
+			rp = p;
+		continue;
+
+	case '>':
+		p++;
+		if(p!=p2 && **p=='>')
+			flg =| FCAT; else
+			p--;
+
+	case '<':
+		if(l == 0) {
+			p++;
+			if(p == p2) {
+				error++;
+				p--;
+			}
+			if(any(**p, "<>("))
+				error++;
+			if(c == '<') {
+				if(i != 0)
+					error++;
+				i = *p;
+				continue;
+			}
+			if(o != 0)
+				error++;
+			o = *p;
+		}
+		continue;
+
+	default:
+		if(l == 0)
+			p1[n++] = *p;
+	}
+	if(lp != 0) {
+		if(n != 0)
+			error++;
+		t = tree(5);
+		t[DTYP] = TPAR;
+		t[DSPR] = syn1(lp, rp);
+		goto out;
+	}
+	if(n == 0)
+		error++;
+	p1[n++] = 0;
+	t = tree(n+5);
+	t[DTYP] = TCOM;
+	for(l=0; l<n; l++)
+		t[l+DCOM] = p1[l];
+out:
+	t[DFLG] = flg;
+	t[DLEF] = i;
+	t[DRIT] = o;
+	return(t);
+}
+
+scan(at, f)
+int *at;
+int (*f)();
+{
+	register char *p, c;
+	register *t;
+
+	t = at+DCOM;
+	while(p = *t++)
+		while(c = *p)
+			*p++ = (*f)(c);
+}
+
+tglob(c)
+int c;
+{
+
+	if(any(c, "[?*"))
+		gflg = 1;
+	return(c);
+}
+
+trim(c)
+int c;
+{
+
+	return(c&0177);
+}
+
+execute(t, pf1, pf2)
+int *t, *pf1, *pf2;
+{
+	int i, f, pv[2];
+	register *t1;
+	register char *cp1, *cp2;
+	extern errno;
+
+	if(t != 0)
+	switch(t[DTYP]) {
+
+	case TCOM:
+		cp1 = t[DCOM];
+		if(equal(cp1, "chdir")) {
+			if(t[DCOM+1] != 0) {
+				if(chdir(t[DCOM+1]) < 0)
+					err("chdir: bad directory");
+			} else
+				err("chdir: arg count");
+			return;
+		}
+		if(equal(cp1, "shift")) {
+			if(dolc < 1) {
+				prs("shift: no args\n");
+				return;
+			}
+			dolv[1] = dolv[0];
+			dolv++;
+			dolc--;
+			return;
+		}
+		if(equal(cp1, "login")) {
+			if(promp != 0) {
+				close(acctf);
+				execv("/bin/login", t+DCOM);
+			}
+			prs("login: cannot execute\n");
+			return;
+		}
+		if(equal(cp1, "newgrp")) {
+			if(promp != 0) {
+				close(acctf);
+				execv("/bin/newgrp", t+DCOM);
+			}
+			prs("newgrp: cannot execute\n");
+			return;
+		}
+		if(equal(cp1, "wait")) {
+			pwait(-1, 0);
+			return;
+		}
+		if(equal(cp1, ":"))
+			return;
+
+	case TPAR:
+		f = t[DFLG];
+		i = 0;
+		if((f&FPAR) == 0)
+			i = fork();
+		if(i == -1) {
+			err("try again");
+			return;
+		}
+		if(i != 0) {
+			if((f&FPIN) != 0) {
+				close(pf1[0]);
+				close(pf1[1]);
+			}
+			if((f&FPRS) != 0) {
+				prn(i);
+				prs("\n");
+			}
+			if((f&FAND) != 0)
+				return;
+			if((f&FPOU) == 0)
+				pwait(i, t);
+			return;
+		}
+		if(t[DLEF] != 0) {
+			close(0);
+			i = open(t[DLEF], 0);
+			if(i < 0) {
+				prs(t[DLEF]);
+				err(": cannot open");
+				exit();
+			}
+		}
+		if(t[DRIT] != 0) {
+			if((f&FCAT) != 0) {
+				i = open(t[DRIT], 1);
+				if(i >= 0) {
+					seek(i, 0, 2);
+					goto f1;
+				}
+			}
+			i = creat(t[DRIT], 0666);
+			if(i < 0) {
+				prs(t[DRIT]);
+				err(": cannot create");
+				exit();
+			}
+		f1:
+			close(1);
+			dup(i);
+			close(i);
+		}
+		if((f&FPIN) != 0) {
+			close(0);
+			dup(pf1[0]);
+			close(pf1[0]);
+			close(pf1[1]);
+		}
+		if((f&FPOU) != 0) {
+			close(1);
+			dup(pf2[1]);
+			close(pf2[0]);
+			close(pf2[1]);
+		}
+		if((f&FINT)!=0 && t[DLEF]==0 && (f&FPIN)==0) {
+			close(0);
+			open("/dev/null", 0);
+		}
+		if((f&FINT) == 0 && setintr) {
+			signal(INTR, 0);
+			signal(QUIT, 0);
+		}
+		if(t[DTYP] == TPAR) {
+			if(t1 = t[DSPR])
+				t1[DFLG] =| f&FINT;
+			execute(t1);
+			exit();
+		}
+		close(acctf);
+		gflg = 0;
+		scan(t, &tglob);
+		if(gflg) {
+			t[DSPR] = "/etc/glob";
+			execv(t[DSPR], t+DSPR);
+			prs("glob: cannot execute\n");
+			exit();
+		}
+		scan(t, &trim);
+		*linep = 0;
+		texec(t[DCOM], t);
+		cp1 = linep;
+		cp2 = "/usr/bin/";
+		while(*cp1 = *cp2++)
+			cp1++;
+		cp2 = t[DCOM];
+		while(*cp1++ = *cp2++);
+		texec(linep+4, t);
+		texec(linep, t);
+		prs(t[DCOM]);
+		err(": not found");
+		exit();
+
+	case TFIL:
+		f = t[DFLG];
+		pipe(pv);
+		t1 = t[DLEF];
+		t1[DFLG] =| FPOU | (f&(FPIN|FINT|FPRS));
+		execute(t1, pf1, pv);
+		t1 = t[DRIT];
+		t1[DFLG] =| FPIN | (f&(FPOU|FINT|FAND|FPRS));
+		execute(t1, pv, pf2);
+		return;
+
+	case TLST:
+		f = t[DFLG]&FINT;
+		if(t1 = t[DLEF])
+			t1[DFLG] =| f;
+		execute(t1);
+		if(t1 = t[DRIT])
+			t1[DFLG] =| f;
+		execute(t1);
+		return;
+
+	}
+}
+
+texec(f, at)
+int *at;
+{
+	extern errno;
+	register int *t;
+
+	t = at;
+	execv(f, t+DCOM);
+	if (errno==ENOEXEC) {
+		if (*linep)
+			t[DCOM] = linep;
+		t[DSPR] = "/bin/sh";
+		execv(t[DSPR], t+DSPR);
+		prs("No shell!\n");
+		exit();
+	}
+	if (errno==ENOMEM) {
+		prs(t[DCOM]);
+		err(": too large");
+		exit();
+	}
+}
+
+err(s)
+char *s;
+{
+
+	prs(s);
+	prs("\n");
+	if(promp == 0) {
+		seek(0, 0, 2);
+		exit();
+	}
+}
+
+prs(as)
+char *as;
+{
+	register char *s;
+
+	s = as;
+	while(*s)
+		putc(*s++);
+}
+
+putc(c)
+{
+
+	write(2, &c, 1);
+}
+
+prn(n)
+int n;
+{
+	register a;
+
+	if(a=ldiv(0,n,10))
+		prn(a);
+	putc(lrem(0,n,10)+'0');
+}
+
+any(c, as)
+int c;
+char *as;
+{
+	register char *s;
+
+	s = as;
+	while(*s)
+		if(*s++ == c)
+			return(1);
+	return(0);
+}
+
+equal(as1, as2)
+char *as1, *as2;
+{
+	register char *s1, *s2;
+
+	s1 = as1;
+	s2 = as2;
+	while(*s1++ == *s2)
+		if(*s2++ == '\0')
+			return(1);
+	return(0);
+}
+
+pwait(i, t)
+int i, *t;
+{
+	register p, e;
+	int s;
+
+	if(i != 0)
+	for(;;) {
+		times(&timeb);
+		time(timeb.proct);
+		p = wait(&s);
+		if(p == -1)
+			break;
+		e = s&0177;
+		if(mesg[e] != 0) {
+			if(p != i) {
+				prn(p);
+				prs(": ");
+			}
+			prs(mesg[e]);
+			if(s&0200)
+				prs(" -- Core dumped");
+		}
+		if(e != 0)
+			err("");
+		if(i == p) {
+			acct(t);
+			break;
+		} else
+			acct(0);
+	}
+}
+
+acct(t)
+int *t;
+{
+	if(t == 0)
+		enacct("**gok"); else
+	if(*t == TPAR)
+		enacct("()"); else
+	enacct(t[DCOM]);
+}
+
+enacct(as)
+char *as;
+{
+	struct stime timbuf;
+	struct {
+		char cname[14];
+		char shf;
+		char uid;
+		int datet[2];
+		int realt[2];
+		int bcput[2];
+		int bsyst[2];
+	} tbuf;
+	register i;
+	register char *np, *s;
+
+	s = as;
+	times(&timbuf);
+	time(timbuf.proct);
+	lsub(tbuf.realt, timbuf.proct, timeb.proct);
+	lsub(tbuf.bcput, timbuf.cputim, timeb.cputim);
+	lsub(tbuf.bsyst, timbuf.systim, timeb.systim);
+	do {
+		np = s;
+		while (*s != '\0' && *s != '/')
+			s++;
+	} while (*s++ != '\0');
+	for (i=0; i<14; i++) {
+		tbuf.cname[i] = *np;
+		if (*np)
+			np++;
+	}
+	tbuf.datet[0] = timbuf.proct[0];
+	tbuf.datet[1] = timbuf.proct[1];
+	tbuf.uid = uid;
+	tbuf.shf = 0;
+	if (promp==0)
+		tbuf.shf = 1;
+	seek(acctf, 0, 2);
+	write(acctf, &tbuf, sizeof(tbuf));
+}

source/s2/size.c

@@ -0,0 +1,36 @@
+/*
+	size -- determine object size
+
+*/
+
+main(argc, argv)
+char **argv;
+{
+	int buf[010], f, ac, sum;
+
+	ac = argc;
+	if (ac==1) {
+		*argv = "a.out";
+		ac++;
+		--argv;
+	}
+	while(--ac) {
+		++argv;
+		if((f=open(*argv, 0))<0) {
+			printf("%s not found\n", *argv);
+			continue;
+		}
+		read(f, buf, 0020);
+		if(buf[0]!=0411 && buf[0]!=0410 && buf[0]!=0407) {
+			printf("Bad format: %s\n", *argv);
+			close(f);
+			continue;
+		}
+		if (argc>2)
+			printf("%s: ", *argv);
+		printf("%l+%l+%l=", buf[1],buf[2],buf[3]);
+		sum = buf[1]+buf[2]+buf[3];
+		printf("%l (%o)\n", sum, sum);
+		close(f);
+	}
+}

source/s2/sleep.c

@@ -0,0 +1,21 @@
+main(argc, argv)
+char **argv;
+{
+	int c, n;
+	char *s;
+
+	n = 0;
+	if(argc < 2) {
+		printf("arg count\n");
+		exit();
+	}
+	s = argv[1];
+	while(c = *s++) {
+		if(c<'0' || c>'9') {
+			printf("bad character\n");
+			exit();
+		}
+		n = n*10 + c - '0';
+	}
+	sleep(n);
+}

source/s2/sort.c

@@ -0,0 +1,592 @@
+#define	L	512
+#define	N	7
+#define	C	20
+#define	MEM	(16*2048)
+#define NF	10
+
+int	ibuf[259];
+int	obuf[259];
+char	*file;
+char	*filep;
+int	nfiles;
+int	nlines;
+int	ntext;
+int	*lspace;
+char	*tspace;
+int	cmp();
+int	term();
+int 	mflg;
+char	*outfil;
+char	tabchar;
+int 	eargc;
+char	**eargv;
+
+char	fold[128] {
+	0000,0001,0002,0003,0004,0005,0006,0007,
+	0010,0011,0012,0013,0014,0015,0016,0017,
+	0020,0021,0022,0023,0024,0025,0026,0027,
+	0030,0031,0032,0033,0034,0035,0036,0037,
+	0040,0041,0042,0043,0044,0045,0046,0047,
+	0050,0051,0052,0053,0054,0055,0056,0057,
+	0060,0061,0062,0063,0064,0065,0066,0067,
+	0070,0071,0072,0073,0074,0075,0076,0077,
+	0100,0101,0102,0103,0104,0105,0106,0107,
+	0110,0111,0112,0113,0114,0115,0116,0117,
+	0120,0121,0122,0123,0124,0125,0126,0127,
+	0130,0131,0132,0133,0134,0134,0136,0137,
+	0140,0101,0102,0103,0104,0105,0106,0107,
+	0110,0111,0112,0113,0114,0115,0116,0117,
+	0120,0121,0122,0123,0124,0125,0126,0127,
+	0130,0131,0132,0173,0174,0175,0176,0177
+};
+char	nofold[128];
+char	dict[128] {
+	1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,
+	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+	0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+	0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,
+	1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+	0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,
+	1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+	0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1
+};
+char	nodict[128] { 1 };
+
+struct	field {
+	char *code;
+	char *ignore;
+	int nflg;
+	int rflg;
+	int bflg;
+	char *m[2];
+	char *n[2];
+}	fields[NF];
+int proto[9] {
+	&fold,
+	&nodict,
+	0,
+	1,
+	0,
+	0,-1,
+	0,0
+};
+int	nfields;
+int 	error 1;
+
+main(argc, argv)
+char **argv;
+{
+	register a, i;
+	char *arg;
+	register int *p;
+	int *q;
+
+	for(a=0; a<128; a++)
+		nofold[a] = a;
+	nodict[127] = 1;
+	copyproto();
+	eargv = argv;
+	while (--argc > 0) {
+		if(**++argv == '-') for(arg = *argv;;) {
+			switch(*++arg) {
+			case '\0':
+				if(arg[-1] == '-')
+					eargv[eargc++] = "-";
+				break;
+
+			case 'm':
+				mflg++;
+				continue;
+
+			case 'o':
+				if(--argc > 0)
+					outfil = *++argv;
+				continue;
+
+			default:
+				field(++*argv,1);
+				break;
+			}
+			break;
+		} else if (**argv == '+') {
+			if(++nfields>=NF) {
+				mess("Too many keys\n");
+				exit(1);
+			}
+			copyproto();
+			field(++*argv,0);
+		} else
+			eargv[eargc++] = *argv;
+	}
+	q = &fields[0];
+	for(a=1; a<=nfields; a++) {
+		p = &fields[a];
+		for(i=0; i<5; i++)	/*sensitive to sizeof(proto)*/
+			if(p[i] != proto[i])
+				goto next;
+		for(i=0; i<5; i++)
+			p[i] = q[i];
+next:	;
+	}
+	if(eargc == 0)
+		eargv[eargc++] = "-";
+
+	a = MEM;
+	i = lspace = sbrk(0);
+	while(brk(a) == -1)
+		a =- 512;
+	brk(a =- 512);	/* for recursion */
+	a =- i;
+	nlines = ((a-L)>>1) & 077777;
+	nlines =/ 5;
+	ntext = nlines*8;
+	tspace = lspace+nlines;
+	file = "/usr/tmp/stmXaa";
+loop:
+	filep = file;
+	while(*filep != 'X')
+		filep++;
+	for(*filep = 'a';;(*filep)++) {
+		if(stat(file, lspace) < 0) {
+			a = creat(file, 0600);
+			if(a >= 0)
+				break;
+		}
+		if(*filep == 'z') {
+			if(file[1] != 't') {
+				file = "/tmp/stmXaa";
+				goto loop;
+			}
+			mess("Cannot locate temp\n");
+			exit(1);
+		}
+	}
+	close(a);
+	filep++;
+	if ((signal(2, 1) & 01) == 0)
+		signal(2, term);
+	nfiles = eargc;
+	if(!mflg) {
+		ibuf[0] = -1;
+		sort();
+		close(0);
+	}
+	for(a = mflg?0:eargc; a+N < nfiles; a=+N) {
+		newfile();
+		merge(a, a+N);
+	}
+	if(a != nfiles) {
+		oldfile();
+		merge(a, nfiles);
+	}
+	error = 0;
+	term();
+}
+
+sort()
+{
+	register char *cp;
+	register *lp, c;
+	int done;
+	int i;
+	int f;
+
+	done = 0;
+	i = 0;
+	do {
+		cp = tspace;
+		lp = lspace;
+		while(lp < lspace+nlines && cp < tspace+ntext) {
+			*lp++ = cp;
+			while((*cp++ = c = getc(ibuf)) != '\n') {
+				if(c >= 0) continue;
+				cp--;
+				close(ibuf[0]);
+				if(i < eargc) {
+					if((f = setfil(i++)) == 0)
+						ibuf[0] = 0;
+					else if(fopen(f, ibuf) < 0)
+						cant(f);
+				} else
+					break;
+			}
+			if(c < 0) {
+				done++;
+				lp--;
+				break;
+			}
+		}
+		qsort(lspace, lp-lspace, 2, cmp);
+		if(done == 0 || nfiles != eargc)
+			newfile(); else
+			oldfile();
+		while(lp > lspace) {
+			cp = *--lp;
+			do
+				putc(*cp, obuf);
+			while(*cp++ != '\n');
+		}
+		fflush(obuf);
+		close(obuf[0]);
+	} while(done == 0);
+}
+
+struct merg
+{
+	char	l[L];
+	int	b[259];
+};
+
+merge(a, b)
+{
+	register struct merg *p;
+	register char *cp;
+	register i;
+	struct { int *ip;};
+	int f;
+	int j;
+
+	p = lspace;
+	j = 0;
+	for(i=a; i<b; i++) {
+		f = setfil(i);
+		if(f == 0)
+			p->b[0] = dup(0);
+		else if(fopen(f, p->b) < 0)
+			cant(f);
+		ibuf[j] = p;
+		if(!rline(p)) j++;
+		p++;
+	}
+	i = j;
+	qsort(ibuf, i, 2, cmp);
+	if(i > 0) for(;;) {
+		cp = ibuf[i-1];
+		do
+			putc(*cp, obuf);
+		while(*cp++ != '\n');
+		if(rline(ibuf[i-1])) {
+			i--;
+			if(i == 0)
+				break;
+		}
+		cp = &ibuf[i];
+		while (--cp.ip > ibuf && cmp(cp.ip, cp.ip-1) < 0) {
+			p = *cp.ip;
+			*cp.ip = *(cp.ip-1);
+			*(cp.ip-1) = p;
+		}
+	}
+	p = lspace;
+	for(i=a; i<b; i++) {
+		close(p->b[0]);
+		p++;
+		if(i >= eargc)
+			close(creat(setfil(i)));
+	}
+	fflush(obuf);
+	close(obuf[0]);
+}
+
+rline(mp)
+struct merg *mp;
+{
+	register char *cp;
+	register *bp, c;
+
+	bp = mp->b;
+	cp = mp->l;
+	do {
+		c = getc(bp);
+		if(c < 0)
+			return(1);
+		*cp++ = c;
+	} while(c != '\n');
+	return(0);
+}
+
+newfile()
+{
+
+	if(fcreat(setfil(nfiles), obuf) < 0) {
+		mess("Can't create temp\n");
+		term();
+	}
+	nfiles++;
+}
+
+char *
+setfil(i)
+{
+
+	if(i < eargc)
+		if(eargv[i][0] == '-' && eargv[i][1] == '\0')
+			return(0);
+		else
+			return(eargv[i]);
+	i =- eargc;
+	filep[0] = i/26 + 'a';
+	filep[1] = i%26 + 'a';
+	return(file);
+}
+
+oldfile()
+{
+
+	if(outfil) {
+		if(fcreat(outfil, obuf) < 0) {
+			mess("Can't create output\n");
+			term();
+		}
+	} else
+		obuf[0] = 1;
+}
+
+cant(f)
+{
+	mess("Can't open ");
+	mess(f);
+	mess("\n");
+	term();
+}
+
+term()
+{
+	register i;
+
+	if(nfiles == eargc)
+		nfiles++;
+	for(i=eargc; i<nfiles; i++)
+		unlink(setfil(i));
+	exit(error);
+}
+
+cmp(i, j)
+int *i, *j;
+{
+	register char *pa, *pb;
+	char *code, *ignore;
+	int a, b;
+	int k;
+	char *la, *lb;
+	register int sa;
+	int sb;
+	char *ipa, *ipb, *jpa, *jpb;
+	struct field *fp;
+
+	for(k = nfields>0; k<=nfields; k++) {
+		fp = &fields[k];
+		pa = *i;
+		pb = *j;
+		if(k) {
+			la = skip(pa, fp, 1);
+			pa = skip(pa, fp, 0);
+			lb = skip(pb, fp, 1);
+			pb = skip(pb, fp, 0);
+		} else {
+			la = -1;
+			lb = -1;
+		}
+		if(fp->nflg) {
+			while(blank(*pa))
+				pa++;
+			while(blank(*pb))
+				pb++;
+			sa = sb = fp->rflg;
+			if(*pa == '-') {
+				pa++;
+				sa = -sa;
+			}
+			if(*pb == '-') {
+				pb++;
+				sb = -sb;
+			}
+			if(sa != sb)
+				sa = 0;
+			for(ipa = pa; ipa<la&&digit(*ipa); ipa++);
+			for(ipb = pb; ipb<lb&&digit(*ipb); ipb++);
+			jpa = ipa;
+			jpb = ipb;
+			a = 0;
+			if(sa) while(ipa > pa && ipb > pb)
+				if(b = *--ipb - *--ipa)
+					a = b;
+			while(ipa > pa)
+				if(*--ipa != '0')
+					return(sa ? -sa : sb);
+			while(ipb > pb)
+				if(*--ipb != '0')
+					return(sa ? sa : sb);
+			if(a) return(a*sa);
+			if(*(pa=jpa) == '.')
+				pa++;
+			if(*(pb=jpb) == '.')
+				pb++;
+			while(pa<la && digit(*pa))
+				if(pb<lb &&digit(*pb)) {
+					if(a = *pb++ - *pa++)
+						return(sa ? a*sa : sb);
+				} else if(*pa++ != '0')
+					return(sa ? -sa : sb);
+			while(pb<lb && digit(*pb))
+				if(*pb++ != '0')
+					return(sa ? sa : sb);
+			continue;
+		}
+		code = fp->code;
+		ignore = fp->ignore;
+loop: 
+		while(*pa<0 || ignore[*pa])
+			pa++;
+		while(*pb<0 || ignore[*pb])
+			pb++;
+		if(pa>=la || *pa=='\n')
+			if(pb<lb && *pb!='\n')
+				return(fp->rflg);
+			else continue;
+		if(pb>=lb || *pb=='\n')
+			return(-fp->rflg);
+		if((sa = code[*pb++]-code[*pa++]) == 0)
+			goto loop;
+		return(sa*fp->rflg);
+	}
+	pa = *i;
+	pb = *j;
+	while(*pa != '\n') {
+		if(*pa == *pb) {
+			pa++;
+			pb++;
+			continue;
+		}
+		if(*pb == '\n')
+			return(-1);
+		return(*pb - *pa);
+	}
+	return(*pb != '\n');
+}
+
+skip(pp, fp, j)
+struct field *fp;
+char *pp;
+{
+	register i;
+	register char *p;
+
+	p = pp;
+	if( (i=fp->m[j]) < 0)
+		return(-1);
+	while(i-- > 0) {
+		if(tabchar != 0) {
+			while(*p != tabchar)
+				if(*p != '\n')
+					p++;
+				else goto ret;
+			p++;
+		} else {
+			while(blank(*p))
+				p++;
+			while(!blank(*p))
+				if(*p != '\n')
+					p++;
+				else goto ret;
+		}
+	}
+	if(fp->bflg)
+		while(blank(*p))
+			p++;
+	i = fp->n[j];
+	while(i-- > 0) {
+		if(*p != '\n')
+			p++;
+		else goto ret;
+	} 
+ret:
+	return(p);
+}
+
+digit(c)
+{
+
+	return(c <= '9' && c >= '0');
+}
+
+mess(s)
+char *s;
+{
+	while(*s)
+		write(2, s++, 1);
+}
+
+copyproto()
+{
+	register int i, *p, *q;
+
+	p = proto;
+	q = &fields[nfields];
+	for(i=0; i<sizeof(proto)/2; i++)
+		*q++ = *p++;
+}
+
+field(s,k)
+char *s;
+{
+	register struct field *p;
+	p = &fields[nfields];
+	for(; *s!=0; s++) {
+		switch(*s) {
+		case '\0':
+			return;
+
+		case 'a':
+			p->code = nofold;
+			break;
+
+		case 'b':
+			p->bflg++;
+			break;
+
+		case 'd':
+			p->ignore = dict;
+			break;
+
+		case 'n':
+			p->nflg++;
+			break;
+		case 't':
+			tabchar = *++s;
+			if(tabchar == 0) s--;
+			break;
+
+		case 'r':
+			p->rflg = -1;
+			break;
+
+		default:
+			p->m[k] = number(&s);
+			if(*s == '.')
+				s++;
+			p->n[k] = number(&s);
+			s--;
+		}
+	}
+}
+
+number(ppa)
+char **ppa;
+{
+	int n;
+	register char *pa;
+	pa = *ppa;
+	n = 0;
+	while(digit(*pa))
+		n = n*10 + *pa++ - '0';
+	*ppa = pa;
+	return(n);
+}
+
+blank(c)
+{
+	if(c==' ' || c=='\t')
+		return(1);
+	return(0);
+}

source/s2/split.c

@@ -0,0 +1,88 @@
+int	count	1000;
+int	fnumber;
+int	ibuf[259];
+int	obuf[259];
+char	fname[100];
+char	*ifil;
+char	*ofil;
+
+main(argc, argv)
+char *argv[];
+{
+	register i, c, f;
+
+	for(i=1; i<argc; i++)
+	if(argv[i][0] == '-')
+	switch(argv[i][1]) {
+
+	case '\0':
+		ifil = 1;
+		continue;
+
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+		count = number(argv[i]+1);
+		continue;
+
+	} else
+	if(ifil)
+		ofil = argv[i]; else
+		ifil = argv[i];
+	if(ifil != 0 && ifil != 1)
+		if(fopen(ifil, ibuf) < 0) {
+			write(2, "cannot open input\n", 18);
+			exit();
+		}
+	if(ofil == 0)
+		ofil = "x";
+
+loop:
+	f = 1;
+	for(i=0; i<count; i++)
+	do {
+		c = getc(ibuf);
+		if(c < 0) {
+			if(f == 0)
+				fflush(obuf);
+			exit();
+		}
+		if(f) {
+			for(f=0; ofil[f]; f++)
+				fname[f] = ofil[f];
+			fname[f++] = fnumber/26 + 'a';
+			fname[f++] = fnumber%26 + 'a';
+			fname[f] = '\0';
+			fnumber++;
+			if(fcreat(fname, obuf) < 0) {
+				write(2, "Cannot create output\n", 20);
+				exit();
+			}
+			f = 0;
+		}
+		putc(c, obuf);
+	} while(c != '\n');
+	fflush(obuf);
+	close(obuf[0]);
+	goto loop;
+}
+
+number(str)
+char *str;
+{
+	register n;
+	register char *s;
+
+	n = 0;
+	for(s = str; *s; s++)
+		if(*s>='0' && *s<='9')
+			n = n*10 + *s-'0';
+	return(n);
+}

source/s2/strip.s

@@ -0,0 +1,141 @@
+/ strip -- strip relocation and symbols
+
+	mov	(sp)+,argc
+	tst	(sp)+
+	br	loop
+unloop:
+	sys	unlink; s.tmp
+loop:
+	dec	argc
+	bgt	1f
+	sys	exit
+1:
+	mov	(sp)+,r4
+	mov	r4,0f
+	sys	open; 0:..; 0
+	bec	1f
+	jsr	r5,mesg; <open error: \0>; .even
+	br	loop
+1:
+	mov	r0,fi
+	mov	$'a,r1
+1:
+	movb	r1,s.tmp+8
+	sys	stat; s.tmp; buf
+	bec	2f
+	sys	creat; s.tmp; 400
+	bec	1f
+2:
+	inc	r1
+	cmp	r1,$'z
+	blos	1b
+	jsr	r5,mesg; <can't create temp file for \0>; .even
+	sys	exit
+1:
+	mov	r0,fo
+	clr	buf
+	mov	fi,r0
+	sys	read; buf; 512.
+	mov	r0,r3
+	cmp	buf,magic
+	beq	1f
+	cmp	buf,magic1
+	beq	1f
+	cmp	buf,magic2
+	beq	1f
+	jsr	r5,mesg; <improper format: \0>; .even
+	br	unloop
+1:
+	mov	buf+2,r2
+	add	buf+4,r2
+	add	$20,r2
+	clr	r1
+	clr	buf+10
+	mov	$1,buf+16		/ no reloc bits flag
+1:
+	mov	r2,0f
+	sub	r1,0f
+	cmp	0f,r3
+	blos	2f
+	mov	r3,0f
+2:
+	mov	fo,r0
+	sys	write; buf; 0:..
+	add	0b,r1
+	cmp	r1,r2
+	bhis	1f
+	mov	fi,r0
+	sys	read; buf; 512.
+	mov	r0,r3
+	bne	1b
+	jsr	r5,mesg; <unexpected EOF: \0>; .even
+1:
+	mov	fo,r0
+	sys	close
+	mov	fi,r0
+	sys	close
+	mov	r4,0f
+	sys	creat; 0:..; 0		/ same mode as before
+	bec	1f
+	jsr	r5,mesg; <can't rewrite: \0>; .even
+	jmp	unloop
+1:
+	mov	r0,fo
+	sys	open; s.tmp; 0
+	bec	1f
+	jsr	r5,mesg; <can't read temp file for: \0>; .even
+	sys	exit
+1:
+	mov	r0,fi
+1:
+	mov	fi,r0
+	sys	read; buf; 512.
+	mov	r0,0f
+	beq	1f
+	mov	fo,r0
+	sys	write; buf; 0:..
+	br	1b
+1:
+	mov	fi,r0
+	sys	close
+	mov	fo,r0
+	sys	close
+	jmp	unloop
+
+mesg:
+	movb	(r5)+,ch
+	beq	1f
+	mov	$1,r0
+	sys	write; ch; 1
+	br	mesg
+1:
+	inc	r5
+	bic	$1,r5
+	mov	r4,r1
+1:
+	movb	(r1)+,ch
+	beq	1f
+	mov	$1,r0
+	sys	write; ch; 1
+	br	1b
+1:
+	mov	$1,r0
+	sys	write; qnl; 1
+	rts	r5
+
+s.tmp:
+	</tmp/stma\0>
+qnl:
+	<\n>
+	.even
+magic:	407
+magic1:	410
+magic2:	411
+
+.bss
+fi:	.=.+2
+fo:	.=.+2
+argc:	.=.+2
+buf:	.=.+512.
+ch:	.=.+2
+

source/s2/stty.c

@@ -0,0 +1,322 @@
+#
+/*
+ * set teletype modes
+ */
+
+/*
+ * tty flags
+ */
+#define	HUPCL	01
+#define	XTABS	02
+#define	LCASE	04
+#define	ECHO	010
+#define	CRMOD	020
+#define	RAW	040
+#define	ODDP	0100
+#define	EVENP	0200
+#define	ANYP	0300
+
+/*
+ * Delay algorithms
+ */
+#define	CR0	0
+#define	CR1	010000
+#define	CR2	020000
+#define	CR3	030000
+#define	NL0	0
+#define	NL1	000400
+#define	NL2	001000
+#define	NL3	001400
+#define	TAB0	0
+#define	TAB1	002000
+#define	TAB2	004000
+#define	TAB3	006000
+#define	FF0	0
+#define	FF1	040000
+#define	BS0	0
+#define	BS1	0100000
+#define	ALL	0177400
+
+struct
+{
+	char	*string;
+	int	speed;
+} speeds[]
+{
+	"0",	(0<<8)|0,
+	"50",	(1<<8)|1,
+	"75",	(2<<8)|2,
+	"110",	(3<<8)|3,
+	"134",	(4<<8)|4,
+	"134.5",(4<<8)|4,
+	"150",	(5<<8)|5,
+	"200",	(6<<8)|6,
+	"300",	(7<<8)|7,
+	"600",	(8<<8)|8,
+	"1200",	(9<<8)|9,
+	"1800",	(10<<8)|10,
+	"2400",	(11<<8)|11,
+	"4800",	(12<<8)|12,
+	"9600",	(13<<8)|13,
+	"exta",	(14<<8)|14,
+	"extb",	(15<<8)|15,
+	0,
+};
+struct
+{
+	char	*string;
+	int	set;
+	int	reset;
+} modes[]
+{
+	"even",
+	EVENP, 0,
+
+	"-even",
+	0, EVENP,
+
+	"odd",
+	ODDP, 0,
+
+	"-odd",
+	0, ODDP,
+
+	"raw",
+	RAW, 0,
+
+	"-raw",
+	0, RAW,
+
+	"cooked",
+	0, RAW,
+
+	"-nl",
+	CRMOD, 0,
+
+	"nl",
+	0, CRMOD,
+
+	"echo",
+	ECHO, 0,
+
+	"-echo",
+	0, ECHO,
+
+	"LCASE",
+	LCASE, 0,
+
+	"lcase",
+	LCASE, 0,
+
+	"-LCASE",
+	0, LCASE,
+
+	"-lcase",
+	0, LCASE,
+
+	"-tabs",
+	XTABS, 0,
+
+	"tabs",
+	0, XTABS,
+
+	"hup",
+	HUPCL, 0,
+
+	"-hup",
+	0, HUPCL,
+
+	"cr0",
+	CR0, CR3,
+
+	"cr1",
+	CR1, CR3,
+
+	"cr2",
+	CR2, CR3,
+
+	"cr3",
+	CR3, CR3,
+
+	"tab0",
+	TAB0, TAB3,
+
+	"tab1",
+	TAB1, TAB3,
+
+	"tab2",
+	TAB2, TAB3,
+
+	"tab3",
+	TAB3, TAB3,
+
+	"nl0",
+	NL0, NL3,
+
+	"nl1",
+	NL1, NL3,
+
+	"nl2",
+	NL2, NL3,
+
+	"nl3",
+	NL3, NL3,
+
+	"ff0",
+	FF0, FF1,
+
+	"ff1",
+	FF1, FF1,
+
+	"bs0",
+	BS0, BS1,
+
+	"bs1",
+	BS1, BS1,
+
+	"33",
+	CR1, ALL,
+
+	"tty33",
+	CR1, ALL,
+
+	"37",
+	FF1+CR2+TAB1+NL1, ALL,
+
+	"tty37",
+	FF1+CR2+TAB1+NL1, ALL,
+
+	"05",
+	NL2, ALL,
+
+	"vt05",
+	NL2, ALL,
+
+	"tn",
+	CR1, ALL,
+
+	"tn300",
+	CR1, ALL,
+
+	"ti",
+	CR2, ALL,
+
+	"ti700",
+	CR2, ALL,
+
+	"tek",
+	FF1, ALL,
+
+	0,
+	};
+
+char	*arg;
+int	mode[3];
+
+struct { char lobyte, hibyte; };
+
+main(argc, argv)
+char	*argv[];
+{
+	int i;
+
+	gtty(1, mode);
+	if(argc == 1) {
+		prmodes();
+		exit(0);
+	}
+	while(--argc > 0) {
+
+		arg = *++argv;
+		if (eq("ek"))
+			mode[1] = '#@';
+		if (eq("erase")) {
+			mode[1].lobyte = **++argv;
+			argc--;
+		}
+		if (eq("kill")) {
+			mode[1].hibyte = **++argv;
+			argc--;
+		}
+		for(i=0; speeds[i].string; i++)
+			if(eq(speeds[i].string))
+				mode[0] = speeds[i].speed;
+		for(i=0; modes[i].string; i++)
+			if(eq(modes[i].string)) {
+				mode[2] =& ~modes[i].reset;
+				mode[2] =| modes[i].set;
+			}
+		if(arg)
+			printf("unknown mode: %s\n", arg);
+	}
+	stty(1,mode);
+}
+
+eq(string)
+char *string;
+{
+	int i;
+
+	if(!arg)
+		return(0);
+	i = 0;
+loop:
+	if(arg[i] != string[i])
+		return(0);
+	if(arg[i++] != '\0')
+		goto loop;
+	arg = 0;
+	return(1);
+}
+
+prmodes()
+{
+	register m;
+
+	if(mode[0].lobyte != mode[0].hibyte) {
+		prspeed("input speed  ", mode[0].lobyte);
+		prspeed("output speed ", mode[0].hibyte);
+	} else
+		prspeed("speed ", mode[0].lobyte);
+	printf("erase = '%c'; kill = '%c'\n", mode[1].lobyte, mode[1].hibyte);
+	m = mode[2];
+	if(m & 0200) printf("even ");
+	if(m & 0100) printf("odd ");
+	if(m & 040) printf("raw ");
+	if(m & 020) printf("-nl ");
+	if(m & 010) printf("echo ");
+	if(m & 04) printf("lcase ");
+	if(m & 02) printf("-tabs ");
+	if(m & 01) printf("hup ");
+	delay(m>>8, "nl");
+	delay(m>>10, "tab");
+	delay(m>>12, "cr");
+	delay((m>>14)&1, "ff");
+	delay((m>>15)&1, "bs");
+	printf("\n");
+}
+
+delay(m, s)
+char *s;
+{
+
+	if(m =& 3)
+		printf("%s%d ", s, m);
+}
+
+int	speed[]
+{
+	0,50,75,110,134,150,200,300,600,1200,1800,2400,4800,9600,0,0
+};
+
+prspeed(c, s)
+{
+
+	printf("%s%d baud\n", c, speed[s]);
+}
+
+putchar(c)
+{
+
+	write(2, &c, 1);
+}

source/s2/su.c

@@ -0,0 +1,46 @@
+/* su -- become super-user */
+
+char	password[100];
+char	pwbuf[100];
+int	ttybuf[3];
+main()
+{
+	register char *p, *q;
+	extern fin;
+
+	if(getpw(0, pwbuf))
+		goto badpw;
+	(&fin)[1] = 0;
+	p = pwbuf;
+	while(*p != ':')
+		if(*p++ == '\0')
+			goto badpw;
+	if(*++p == ':')
+		goto ok;
+	gtty(0, ttybuf);
+	ttybuf[2] =& ~010;
+	stty(0, ttybuf);
+	printf("password: ");
+	q = password;
+	while((*q = getchar()) != '\n')
+		if(*q++ == '\0')
+			return;
+	*q = '\0';
+	ttybuf[2] =| 010;
+	stty(0, ttybuf);
+	printf("\n");
+	q = crypt(password);
+	while(*q++ == *p++);
+	if(*--q == '\0' && *--p == ':')
+		goto ok;
+	goto error;
+
+badpw:
+	printf("bad password file\n");
+ok:
+	setuid(0);
+	execl("/bin/sh", "-", 0);
+	printf("cannot execute shell\n");
+error:
+	printf("sorry\n");
+}

source/s2/sum.s

@@ -0,0 +1,81 @@
+/ sum -- check sum file
+
+	mov	(sp)+,r3
+	tst	(sp)+
+loop:	dec	r3
+	bgt	1f
+	sys	exit
+1:
+	clr	bcnt
+	mov	(sp)+,0f
+	sys	open; 0:..; 0
+	bec	3f
+	mov	$1,r0
+	sys	write; 1f; 2f-1f
+	br	loop
+1:	<oprd\n>
+2:	.even
+3:	mov	r0,r1
+	clr	r5
+1:
+	mov	r1,r0
+	sys	read; buf; 512.
+	bes	err
+	tst	r0
+	beq	print
+	inc	bcnt
+	mov	$buf,r2
+2:
+	movb	(r2)+,r4
+	add	r4,r5
+	adc	r5
+	sob	r0,2b
+	br	1b
+
+err:
+	mov	$1,r0
+	sys	write; 1f; 2
+
+print:
+	jsr	pc,decml
+	mov	$1,r0
+	sys	write; bl; 1
+	mov	bcnt,r5
+	jsr	pc,decml
+	mov	$1,r0
+	sys	write; nl; 1
+	mov	r1,r0
+	sys	close
+	br	loop
+1:	<? >
+nl:	<\n>
+bl:	< >
+	.even
+
+decml:
+	mov	r0,-(sp)
+	mov	r1,-(sp)
+	mov	r5,r1
+	jsr	pc,1f
+	mov	(sp)+,r1
+	mov	(sp)+,r0
+	rts	pc
+
+1:
+	clr	r0
+	dvd	$10.,r0
+	mov	r1,-(sp)
+	mov	r0,r1
+	beq	1f
+	jsr	pc,1b
+1:
+	mov	(sp)+,ch
+	add	$'0,ch
+	mov	$1,r0
+	sys	write; ch; 1
+	rts	pc
+
+.bss
+ch:	.=.+2
+bcnt:	.=.+2
+buf: .=.+512.

source/s2/sync.c

@@ -0,0 +1,5 @@
+main()
+{
+
+	sync();
+}

source/s2/tbl.c

@@ -0,0 +1,317 @@
+#
+# define ever (;;)
+# define MAXCHS 2000
+main(argc,argv)
+	char *argv[];
+{
+char line[200];
+extern int cin;
+extern char *cspace;
+	cspace = getvec(MAXCHS + 100);
+for ever
+{
+	if (argc>1)
+	{
+	argc--;
+	argv++;
+	if (match(*argv, "-ms"))
+		*argv = "/usr/lib/tmac.s";
+	cin = copen(*argv, 'r');
+	if (cin < 0)
+		{
+		printf(2,"where is input file %s\n",*argv);
+		cexit();
+		}
+	}
+while (gets(line))
+	if (match(line, ".TS"))
+		tableput();
+	else
+		puts(line);
+if (argc <= 1) break;
+}
+cexit();
+}
+# define MAXCOL 35
+# define MAXLIN 220
+# define ONELINE 250
+char *tabentry[MAXLIN][MAXCOL];
+char extra[MAXCHS];
+char *cspace, *cstore;
+char *exstore extra;
+int sep[MAXCOL], dwide[MAXCOL];
+char *instead[MAXLIN];
+int newtab[MAXLIN];
+char *style[MAXCOL];
+tableput()
+{
+/* read input, write output, make tables on the way */
+char st[ONELINE], *format;
+int ilin, nlin, icol, ncol, k, ch, ws, cs, ns;
+int maxchnge, ct;
+printf(".TS\n");
+/* get command line */
+cstore = cspace;
+exstore = extra;
+ncol = 0;
+for (ilin=0; ilin<MAXLIN; ilin++)
+	newtab[ilin]=0;
+gets (st);
+for (k=0; k<ONELINE && st[k] != '\0'; k++)
+	if (!space(st[k]))
+		{
+		style[ncol] = st+k;
+		dwide[ncol] =0;
+		for(; letter(st[k]); k++)
+			{
+			if ((st[k]=='n' || st[k] == 'N') &&
+				!dwide[ncol])
+				{
+				dwide[ncol]=1;
+				sep[ncol++] = 0;
+				style[ncol] = style[ncol-1];
+				dwide [ncol] = 0;
+				}
+			}
+		if (digit(st[k]))
+			sep[ncol] = numb(st+k);
+		else
+			sep[ncol] = 3;
+		ncol++;
+		while (digit(st[k]))
+			st[k++] = '\0';
+		if (st[k] == '\0')
+			break;
+		st[k] = '\0';
+		}
+/* now get input lines */
+for (nlin=0; gets(cstore) && !match(cstore, ".TE"); nlin++)
+	{
+	if (cstore[0] == '.' && letter(cstore[1]))
+		{
+		instead[nlin] = cstore;
+		while (*cstore) cstore++;
+		}
+	else instead[nlin] = 0;
+	for (icol = 0; icol <ncol; icol++)
+		{
+		tabentry[nlin][icol] = cstore;
+		for(; (ch= *cstore) != '\0' && ch != '\t'; cstore++)
+				;
+		*cstore++ = '\0';
+		if (dwide[icol] )
+			if (broken(style[icol],nlin))
+				{
+				tabentry[nlin][icol+1]=maknew(tabentry[nlin][icol]);
+				icol++;
+				if (tabentry[nlin][icol] ==0)
+					newtab[nlin]=newtab[nlin+1]=1;
+				}
+			else
+				tabentry[nlin][++icol] = 0;
+		while (span(style[icol+1],nlin) )
+			tabentry[nlin][++icol] = "";
+		if (ch == '\0') break;
+		}
+	while (++icol <ncol)
+		tabentry[nlin][icol] = "";
+	while (*cstore != '\0')
+		 *cstore++;
+	if (cstore-cspace > MAXCHS)
+		cstore = cspace  = getvec(MAXCHS+100);
+	}
+/* find longest command string */
+for (icol=maxchnge=0; icol<ncol; icol++)
+	if (slen(style[icol]) >maxchnge)
+		maxchnge = slen(style[icol]);
+/* set tab stops */
+printf(".nr 49 0\n");
+for (icol = 0; icol<ncol; icol++)
+	{
+	ct = 1 + (icol>0 ? sep[icol-1] : 0);
+	printf(".nr %2d 0\n", icol+50);
+	for (ilin=0; ilin < nlin; ilin++)
+		{
+		if (icol>0 && dwide[icol-1]>0 && tabentry[ilin][icol]==0)
+			{
+			printf(".nr 48 \\n(%2d+\\w'%s'+%dn\n",
+				icol+48, tabentry[ilin][icol-1], sep[icol-1]);
+			printf(".if \\n(48-\\n(%2d .nr %2d \\n(48\n",
+				icol+50,icol+50);
+			}
+		if ( !span(style[icol],ilin) && /* not part of span */
+		   (dwide[icol] == 0 || tabentry[ilin][icol+1]!= 0)
+				/* not a double item */
+		     && (!span(style[icol+1],ilin) || icol==ncol))
+			{
+			printf(".nr 47 \\n(%2d+\\w'%s'+%dn\n",
+			icol+49,tabentry[ilin][icol], ct);
+			printf(".if \\n(47-\\n(%2d .nr %2d \\n(47\n",
+				icol+50,icol+50);
+			}
+		}
+	/* clean up spanned headings */
+	for(ilin=0; ilin<maxchnge; ilin++)
+		{
+		if( !(span(style[icol],ilin)) &&
+		  (icol ==1 || dwide[icol-1] == 0) &&
+		  span(style[icol+(dwide[icol]?2:1)],ilin))
+			printf(".nr %d \\n(%2d+\\w'%s'+%dn\n",
+			  ilin+30, icol+49, tabentry[ilin][icol], ct);
+		else if (span(style[icol],ilin) &&
+		  (icol+1==ncol || !span(style[icol+1],ilin)))
+			printf(".if \\n(%d-\\n(%d .nr %d \\n(%d\n",
+				30+ilin, icol+50, icol+50, ilin+30);
+		}
+	}
+/* run out table, put field characters in */
+printf (".fc  @\n");
+for (ilin=0; ilin<nlin; ilin++)
+	{
+	if (instead[ilin])
+		{
+		printf("%s\n",instead[ilin]);
+		continue;
+		}
+	/* is a new set of tab stops needed */
+	if (ilin < maxchnge || newtab[ilin])
+		settab(ncol, ilin);
+	for (icol=0; icol<ncol; icol++)
+		{
+		switch ( ylet(style[icol],ilin))
+			{
+			default:
+			case 'L': case 'l':
+				format = "%s@"; break;
+			case 'R': case 'r':
+				format= "@%s"; break;
+			case 'n': case 'N':
+				if (!dwide[icol] || tabentry[ilin][icol+1] != 0)
+					{
+					format=dwide[icol]? "@%s" : "%s@";
+					break;
+					}
+			case 'c': case 'C':
+				format = "@%s@"; break;
+			case 's':  case 'S':
+				format= "";
+				break;
+			}
+		if (! (dwide [icol-1]>0 && tabentry[ilin][icol] == 0 ))
+		printf(format, tabentry[ilin][icol]);
+		if (!span(style[icol+1],ilin))
+			for (k=sep[icol]; k>0; k--)
+				printf(" ");
+		}
+	printf("\n");
+	}
+printf(".fc\n");
+printf(".TE\n");
+}
+match (s1, s2)
+	char *s1, *s2;
+{
+	while (*s1 == *s2)
+		if (*s1++ == '\0')
+			return(1);
+		else
+			*s2++;
+	return(0);
+}
+slen(str)
+	char *str;
+{
+	int k;
+	for (k=0; *str++ != '\0'; k++);
+	return(k);
+}
+space(ch)
+	{
+	switch (ch)
+		{
+		case ' ': case '\t':
+			return(1);
+	}
+	return(0);
+	}
+letter (ch)
+	{
+	if (ch >= 'a' && ch <= 'z')
+		return(1);
+	if (ch >= 'A' && ch <= 'Z')
+		return(1);
+	return(0);
+	}
+numb(str)
+	char *str;
+	{
+	/* convert to integer */
+	int k;
+	for (k=0; *str >= '0' && *str <= '9'; str++)
+		k = k*10 + *str - '0';
+	return(k);
+	}
+broken(str, nlin)
+	{
+	switch(ylet(str,nlin))
+		{
+		case 'n': case 'N':
+			return(1);
+		}
+	return(0);
+	}
+ylet (str, k)
+	char *str;
+{
+	k++;
+	while (*str &&k--)
+		str++;
+	return(*--str);
+}
+span(str, k)
+	{
+	switch(ylet(str,k))
+		{
+		case 's': case 'S':
+			return(1);
+		}
+	return(0);
+	}
+maknew(str)
+	char *str;
+{
+	/* make two numerical fields */
+	int point;
+	char *p, *q;
+	p = str;
+	for (point=0; *str; str++)
+		if (*str=='.')
+			point=1;
+	if (!point && *(str-1)== '$')
+		return(0);
+	for(; str>p; str--)
+		if ( (point && *str == '.') ||
+		    (!point && digit(*(str-1)) ) )
+			break;
+	if (!point && p==str) /* not numerical, don't split */
+		return(0);
+	p= str;
+	q = exstore;
+	while (*exstore++ = *str++);
+	*p = 0;
+	return(q);
+	}
+digit(x)
+	{
+	return(x>= '0' && x<= '9');
+	}
+settab(ncol, ilin)
+{
+	int k, icol;
+	printf(".ta ");
+	for (icol = 0; icol<ncol; icol++)
+	   if ((dwide[icol] == 0 || tabentry[ilin][icol+1] != 0)
+		&& !span(style[icol+1],ilin))
+		printf("\\n(%du ",icol+50);
+	printf("\n");
+}

source/s2/tee.c

@@ -0,0 +1,50 @@
+int open[9] { 1 };
+int n 1;
+int t 0;
+
+char in[512];
+
+char out[512];
+
+main(argc,argv)
+char **argv;
+{
+	int register r,w,p;
+	struct { int x1[2], type, x2[15]; } buf;
+	fstat(1,&buf);
+	t = (buf.type&060000)==020000;
+	while(argc-->1) {
+		open[n++] = creat(argv[1],0666);
+		if(stat(argv[1],&buf)>=0)
+			if((buf.type&060000)==020000)
+				t++;
+		argv++;
+	}
+	r = w = 0;
+	for(;;) {
+		for(p=0;p<512;) {
+			if(r>=w) {
+				if(t>0&&p>0) break;
+				w = read(0,in,512);
+				r = 0;
+				if(w<=0) {
+					stash(p);
+					return;
+				}
+			}
+			out[p++] = in[r++];
+		}
+		stash(p);
+	}
+}
+
+stash(p)
+{
+	int k;
+	int i;
+	int d;
+	d = t ? 10 : p;
+	for(i=0; i<p; i=+d)
+		for(k=0;k<n;k++)
+			write(open[k], out+i, d<p-i?d:p-i);
+}

source/s2/time.s

@@ -0,0 +1,186 @@
+/ time -- prints out system times
+
+times = 43.
+
+	cmp	(sp),$1
+	bgt	1f
+	sys	exit
+1:
+	sys	time
+	mov	r1,ltbuf
+	jsr	pc,execarg
+	sys	time
+	sub	ltbuf,r1
+	sys	times; ltbuf
+	mov	r1,r0
+	mul	$60.,r0
+	mov	r0,ltbuf
+	mov	r1,ltbuf+2
+	jsr	r5,mesg; <\nreal\0>; .even
+	mov	$ltbuf,r2
+	jsr	r5,ptime
+	jsr	r5,mesg; <user\0>; .even
+	jsr	r5,ptime
+	jsr	r5,mesg; <sys \0>; .even
+	jsr	r5,ptime
+	sys	exit
+
+execarg:
+	sys	fork
+		br newproc
+	bec	2f
+	jsr	r5,mesg; <Try again.\n\0>; .even
+	sys	exit
+2:
+	mov	r0,r2
+	sys	signal; 2; 1
+2:
+	sys	wait
+	cmp	r0,r2
+	bne	2b
+	bit	$377,r1
+	beq	1f
+	jsr	r5,mesg; <Command terminated abnormally.\n\0>; .even
+	clr	r0
+	sys	seek; 0; 2
+1:
+	rts	pc
+
+newproc:
+	tst	(sp)+
+	mov	(sp)+,r0
+	tst	(sp)+
+	mov	$ibuf,r1
+	mov	$end,r2
+1:
+	mov	(sp)+,r3
+	mov	r2,(r1)+
+2:
+	movb	(r3)+,(r2)+
+	bne	2b
+	dec	r0
+	cmp	r0,$1
+	bgt	1b
+	clr	(r1)+
+	mov	$end,r1
+	sys	exec; end; ibuf
+	cmp	$8,r0
+	beq	rcom
+	mov	$end-10.,r0
+	mov	$"x/,(r0)+
+	mov	$"us,(r0)+
+	mov	$"r/,(r0)+
+	mov	$"bi,(r0)+
+	mov	$"n/,(r0)+
+	mov	$end-5,r1
+	sys	exec; end-5; ibuf
+	cmp	$8,r0
+	beq	rcom
+	mov	$end-9,r1
+	sys	exec; end-9.; ibuf
+	cmp	$8,r0
+	bne	1f
+rcom:
+	mov	r1,ibuf
+	mov	$shname+5,ibuf-2
+	sys	exec ; shname ; ibuf-2
+1:
+	jsr	r5,mesg; <Command not found.\n\0>; .even
+	clr	r0
+	sys	seek; 0; 2
+	sys	exit
+
+printd:
+	mov	$tbuf+4,r4
+	jsr	r5,tdiv; 10.
+	jsr	r5,tdiv; 10.
+	jsr	r5,tdiv; 10.
+	jsr	r5,tdiv; 10.
+1:
+	cmpb	(r4),$'0
+	bne	1f
+	movb	$' ,(r4)+
+	cmp	r4,$tbuf+3
+	bne	1b
+1:
+	mov	$2,r0
+	sys	write; tbuf; 4
+	rts	pc
+
+ptime:
+	mov	(r2)+,r0
+	mov	(r2)+,r1
+	div	$3600.,r0
+	mov	r0,-(sp)
+	clr	r0
+	div	$60.,r0
+	mov	r1,clicks
+	mov	$tbuf+9.,r4
+	jsr	r5,tdiv; 10.
+	jsr	r5,tdiv; 6.
+	movb	$':,-(r4)
+	mov	(sp)+,r0
+	jsr	r5,tdiv; 10.
+	jsr	r5,tdiv; 6.
+	movb	$':,-(r4)
+	jsr	r5,tdiv; 10.
+	jsr	r5,tdiv; 10.
+	jsr	r5,tdiv; 10.
+1:
+	cmpb	(r4),$'0
+	beq	2f
+	cmpb	(r4),$':
+	bne	1f
+2:
+	movb	$' ,(r4)+
+	cmp	r4,$tbuf+8.
+	bne	1b
+1:
+	mov	$2,r0
+	sys	write; tbuf; 9.
+	jsr	r5,mesg; <.\0>; .even
+	mov	clicks,r1
+	clr	r0
+	div	$6,r0
+	add	$'0,r0
+	mov	r0,ch
+	mov	$2,r0
+	sys	write; ch; 1
+	jsr	r5,mesg; <\n\0>; .even
+	rts	r5
+
+tdiv:
+	mov	r1,-(sp)
+	mov	r0,r1
+	clr	r0
+	div	(r5)+,r0
+	add	$'0,r1
+	movb	r1,-(r4)
+	mov	(sp)+,r1
+	rts	r5
+
+mesg:
+	movb	(r5)+,ch
+	beq	2f
+	mov	$2,r0
+	sys	write; ch; 1
+	br	mesg
+2:
+	inc	r5
+	bic	$1,r5
+	rts	r5
+
+ch:	.=.+1
+.even
+.bss
+
+clicks:	.=.+2
+	.=.+2
+ibuf:	.=.+50.
+tbuf:	.=.+10.
+ltbuf:	.=.+16.
+end:	.=.+1000.
+
+.data
+shname:	</bin/sh\0>
+.even

source/s2/tp1.s

@@ -0,0 +1,267 @@
+/ tap1 -- dec-disk lod/dmp
+
+.globl	_localtime, _end
+namep = 0
+mode = 2
+uid = 4; gid = 5
+size0 = 7
+size1 = 8
+time0 = 10.
+time1 = 12.
+tapea = 14.
+dirsiz = 16.
+mdirent = 496.
+
+	mov	(sp),rnarg
+	mov	(sp)+,narg
+	mov	$cmr,command
+	incb	flu
+	tst	(sp)+
+	cmp	narg,$2
+	bge	1f
+	mov	$2,narg
+	br	3f
+1:
+	mov	(sp)+,r0
+	mov	sp,parg
+1:
+	movb	(r0)+,r1
+	beq	3f
+	mov	$swtab,r2
+2:
+	cmp	r1,(r2)+
+	beq	2f
+	tst	(r2)+
+	bne	2b
+	br	useerr
+2:
+	jsr	pc,*(r2)+
+	br	1b
+3:
+	jsr	pc,optap
+	mov	$_end,r4 / string pointer
+	jsr	pc,setb
+	jmp	*command
+
+optap:
+	tstb	flm
+	bne	2f
+	mov	$578.,tapsiz
+	mov	$192.,ndirent
+	sys	open; tc; 2
+	br	3f
+2:
+	mov	$-1,tapsiz
+	mov	$mdirent,ndirent
+	cmp	command,$cmr
+	beq	2f
+	sys	open; mt; 0
+	br	3f
+2:
+	sys	open; mt; 1
+3:
+	bes	1f
+	mov	r0,fio
+	mov	ndirent,r1
+	ash	$-3,r1
+	mov	r1,ndentd8
+	mov	ndirent,r1
+	mul	$dirsiz,r1
+	add	$dir,r1
+	mov	r1,edir
+	rts	pc
+1:
+	jsr	r5,mesg
+		<Tape open error\n\0>; .even
+	jmp	done
+
+setcom:
+	cmp	command,$cmr
+	bne	useerr
+	mov	(r5)+,command
+	rts	r5
+
+noflag:
+	mov	(r5)+,r0
+	beq	1f
+	tstb	(r0)
+	beq	noflag
+	br	useerr
+1:
+	rts	r5
+
+useerr:
+	jsr	r5,mesg
+		<Bad usage\n\0>; .even
+	jmp	done
+
+swtab:
+	'0; dcof
+	'1; dcof
+	'2; dcof
+	'3; dcof
+	'4; dcof
+	'5; dcof
+	'6; dcof
+	'7; dcof
+	'c; dcc
+	'd; dcd
+	'f; dcf
+	'i; dci
+	'm; dcm
+	'r; dcr
+	't; dct
+	'u; dcu
+	'v; dcv
+	'w; dcw
+	'x; dcx
+	 0; 0
+
+dcof:
+	movb	r1,tcx
+	movb	r1,mtx
+	rts	pc
+
+dcc:
+	incb	flc
+	rts	pc
+
+dcf:
+	incb	flf
+	rts	pc
+
+dcd:
+	jsr	r5,setcom; cmd
+	rts	pc
+
+dci:
+	incb	fli
+	rts	pc
+
+dcm:
+	incb	flm
+	rts	pc
+
+dcu:
+	incb	flu
+	jsr	r5,setcom; cmr
+	rts	pc
+
+dcr:
+	clrb	flu
+	jsr	r5,setcom; cmr
+	rts	pc
+
+dct:
+	jsr	r5,setcom; cmt
+	rts	pc
+
+dcv:
+	incb	flv
+	rts	pc
+
+dcw:
+	incb	flw
+	rts	pc
+
+dcx:
+	jsr	r5,setcom; cmx
+	rts	pc
+
+cmd:
+	jsr	r5,noflag; flm; flc; flf; 0
+	cmp	narg,$2
+	bgt	1f
+	jmp	useerr
+1:
+	jsr	pc,rddir
+	jsr	r5,gettape; delete
+	jsr	pc,wrdir
+	br	check
+
+cmr:
+	jsr	r5,noflag; 0
+	tstb	flc
+	bne	1f
+	tstb	flm
+	bne	1f
+	jsr	pc,rddir
+	br	2f
+1:
+	jsr	pc,clrdir
+2:
+	jsr	pc,getfiles
+	jsr	pc,update
+	br	check
+
+cmt:
+	jsr	r5,noflag; flc; flf; flw; 0
+	jsr	pc,rddir
+	tstb	flv
+	beq	1f
+	jsr	r5,mesg
+	<   mode    uid gid tapa    size   date    time name\n\0>; .even
+1:
+	jsr	r5,gettape; taboc
+	br	check1
+
+cmx:
+	jsr	r5,noflag; flc; flf; 0
+	jsr	pc,rddir
+	jsr	r5,gettape; xtract
+	br	done
+
+check:
+
+check1:
+	jsr	pc,usage
+
+done:
+	jsr	r5,mesg
+		<END\n\0>; .even
+	sys	exit
+
+encode:
+	mov	r2,-(sp)
+	mov	r4,(r1)
+	mov	(r5)+,r2
+1:
+	movb	(r2),(r4)+
+	jsr	pc,setb
+	tstb	(r2)+
+	bne	1b
+	mov	(sp)+,r2
+	rts	r5
+
+decode:
+	mov	r2,-(sp)
+	mov	r1,-(sp)
+	mov	(r1),r1
+	mov	(r5)+,r2
+1:
+	movb	(r1)+,(r2)+
+	bne	1b
+	mov	(sp)+,r1
+	mov	(sp)+,r2
+	rts	r5
+
+setb:
+	mov	r0,-(sp)
+	mov	r4,r0
+	add	$513.,r0
+	cmp	r0,sp
+	bhis	2f
+	bic	$777,r0
+	cmp	r0,0f
+	beq	1f
+	mov	r0,0f
+	sys	break; 0:..
+	bes	2f
+1:
+	mov	(sp)+,r0
+	rts	pc
+
+2:
+	jsr	r5,mesg
+		<Out of core\n\0>; .even
+	jmp	done

source/s2/tp2.s

@@ -0,0 +1,449 @@
+/ tap2 -- dec-tape lod/dmp
+
+pstr:
+	movb	(r1)+,r0
+	beq	1f
+	jsr	pc,putc
+	br	pstr
+1:
+	rts	pc
+
+mesg:
+	movb	(r5)+,r0
+	beq	1f
+	jsr	pc,putc
+	br	mesg
+1:
+	inc	r5
+	bic	$1,r5
+	rts	r5
+
+putc:
+	movb	r0,ch
+	mov	$1,r0
+	sys	write; ch; 1
+	rts	pc
+
+getc:
+	clr	r0
+	sys	read; ch; 1
+	movb	ch,r0
+	rts	pc
+
+clrdir:
+	mov	$dir,r1
+	mov	ndirent,r2
+1:
+	jsr	pc,clrent
+	sob	r2,1b
+	rts	pc
+
+clrent:
+	mov	r1,-(sp)
+	add	$dirsiz,(sp)
+1:
+	clr	(r1)+
+	cmp	r1,(sp)
+	blo	1b
+	tst	(sp)+
+	rts	pc
+
+rddir:
+	clr	sum
+	jsr	pc,clrdir
+	clr	r0
+	jsr	pc,rseek
+	jsr	pc,tread
+	mov	tapeb+510.,r0
+	beq	1f
+	tstb	flm
+	beq	1f
+	mov	r0,ndirent
+1:
+	mov	$dir,r1
+	mov	ndirent,r2
+1:
+	bit	$7,r2
+	bne	2f
+	jsr	pc,tread
+	mov	$tapeb,r3
+2:
+	mov	r1,-(sp)
+	mov	r3,-(sp)
+	mov	$32.,r0
+	clr	-(sp)
+2:
+	add	(r3)+,(sp)
+	sob	r0,2b
+	bis	(sp),sum
+	tst	(sp)+
+	bne	2f
+	mov	(sp),r3
+	tst	(r3)
+	beq	2f
+	mov	r3,0f
+	jsr	pc,9f
+.data
+9:
+	jsr	r5,encode; 0:..
+	rts	pc
+.text
+	add	$32.,r3
+	mov	r1,-(sp)
+	add	$dirsiz,(sp)
+	tst	(r1)+		/ namep
+9:
+	mov	(r3)+,(r1)+
+	cmp	r1,(sp)
+	blo	9b
+	tst	(sp)+
+2:
+	mov	(sp)+,r3
+	add	$64.,r3
+	mov	(sp)+,r1
+	bic	$100000,mode(r1)
+	add	$dirsiz,r1
+	sob	r2,1b
+	tst	sum
+	beq	1f
+	jsr	r5,mesg
+		<Directory checksum\n\0>; .even
+	tstb	fli
+	bne	1f
+	jmp	done
+1:
+	jsr	pc,bitmap
+	rts	pc
+
+wrdir:
+	clr	r0
+	jsr	pc,wseek
+	tstb	flm
+	bne	1f
+	sys	open; tboot; 0
+	bes	3f
+	br	2f
+1:
+	sys	open; mboot; 0
+	bes	3f
+2:
+	mov	r0,r1
+	sys	read; tapeb; 512.
+	mov	r1,r0
+	sys	close
+	mov	ndirent,tapeb+510.
+3:
+	jsr	pc,twrite
+	mov	$dir,r1
+	mov	ndirent,r2
+1:
+	bit	$7,r2
+	bne	2f
+	mov	$256.,r0
+	mov	$tapeb,r3
+3:
+	clr	(r3)+
+	sob	r0,3b
+	mov	$tapeb,r3
+2:
+	mov	r3,-(sp)
+	tst	(r1)
+	beq	2f
+	mov	r3,0f
+	jsr	pc,9f
+.data
+9:
+	jsr	r5,decode; 0:..
+	rts	pc
+.text
+2:
+	add	$32.,r3
+	mov	r1,-(sp)
+	add	$dirsiz,(sp)
+	tst	(r1)+
+9:
+	mov	(r1)+,(r3)+
+	cmp	r1,(sp)
+	blo	9b
+	tst	(sp)+
+	mov	(sp)+,r3
+	clr	-(sp)
+	mov	$31.,r0
+2:
+	sub	(r3)+,(sp)
+	sob	r0,2b
+	mov	(sp)+,(r3)+
+	dec	r2
+	bit	$7,r2
+	bne	1b
+	jsr	pc,twrite
+	tst	r2
+	bne	1b
+	rts	pc
+
+tread:
+	mov	fio,r0
+	sys	read; tapeb; 512.
+	bes	trderr
+	cmp	r0,$512.
+	bne	trderr
+1:
+	inc	rseeka
+	rts	pc
+
+trderr:
+	jsr	r5,mesg
+		<Tape read error\n\0>; .even
+	tstb	fli
+	beq	1f
+	mov	$tapeb,r0
+2:
+	clr	(r0)+
+	cmp	r0,$tapeb+512.
+	blo	2b
+	br	1b
+1:
+	jmp	done
+
+twrite:
+	mov	fio,r0
+	sys	write; tapeb; 512.
+	bes	twrerr
+	cmp	r0,$512.
+	bne	twrerr
+	inc	wseeka
+	rts	pc
+
+twrerr:
+	jsr	r5,mesg
+		<Tape write error\n\0>; .even
+	jmp	done
+
+rseek:
+	mov	r0,rseeka
+	mov	r0,0f
+	mov	fio,r0
+	sys	0; 9f
+.data
+9:
+	sys	seek; 0:..; 3
+.text
+	bes	seekerr
+	rts	pc
+
+wseek:
+	mov	r0,-(sp)
+	sub	wseeka,r0
+	bge	1f
+	neg	r0
+1:
+	cmp	r0,$25.			/ longest write seek
+	ble	1f
+	mov	(sp),0f
+	beq	2f
+	dec	0f
+2:
+	mov	fio,r0
+	sys	0; 9f
+.data
+9:
+	sys	seek; 0:..; 3
+.text
+	mov	fio,r0
+	sys	read; wseeka; 1
+1:
+	mov	(sp),wseeka
+	mov	(sp)+,0f
+	mov	fio,r0
+	sys	0; 9f
+.data
+9:
+	sys	seek; 0:..; 3
+.text
+	bes	seekerr
+	rts	pc
+
+seekerr:
+	jsr	r5,mesg
+<Tape seek error\n\0>; .even
+	jmp	done
+
+verify:
+	movb	(r5)+,0f
+	inc	r5
+	tstb	flw
+	bne	1f
+	tstb	flv
+	beq	2f
+1:
+	jsr	pc,9f
+.data
+9:
+	jsr	r5,mesg
+		0:<x \0>; .even
+	rts	pc
+.text
+	mov	r1,-(sp)
+	mov	$name,r1
+	jsr	pc,pstr
+	mov	(sp)+,r1
+	tstb	flw
+	beq	1f
+	jsr	r5,mesg
+		< \0>
+	jsr	pc,getc
+	cmp	r0,$'x
+	bne	3f
+	jsr	pc,getc
+	jmp	done
+3:
+	cmp	r0,$'\n
+	beq	3f
+	cmp	r0,$'y
+	bne	4f
+	jsr	pc,getc
+	cmp	r0,$'\n
+	beq	2f
+4:
+	jsr	pc,getc
+	cmp	r0,$'\n
+	bne	4b
+	br	1b
+1:
+	jsr	r5,mesg
+		<\n\0>
+2:
+	tst	(r5)+
+3:
+	rts	r5
+
+getfiles:
+	cmp	narg,$2
+	bne	1f
+	mov	$".\0,name
+	jsr	pc,callout
+1:
+	cmp	narg,$2
+	ble	1f
+	dec	narg
+	mov	*parg,r1
+	add	$2,parg
+	mov	$name,r2
+2:
+	movb	(r1)+,(r2)+
+	bne	2b
+	jsr	pc,callout
+	br	1b
+1:
+	rts	pc
+
+expand:
+	sys	open; name; 0
+	bes	fserr
+	mov	r0,-(sp)
+1:
+	mov	(sp),r0
+	sys	read; catlb; 16.
+	bes	fserr
+	tst	r0
+	beq	1f
+	tst	catlb
+	beq	1b
+	mov	$name,r0
+	mov	$catlb+2,r1
+	cmpb	(r1),$'.
+	beq	1b
+2:
+	tstb	(r0)+
+	bne	2b
+	dec	r0
+	mov	r0,-(sp)
+	cmpb	-1(r0),$'/
+	beq	2f
+	movb	$'/,(r0)+
+2:
+	movb	(r1)+,(r0)+
+	bne	2b
+	jsr	pc,callout
+	clrb	*(sp)+
+	br	1b
+1:
+	mov	(sp)+,r0
+	sys	close
+	rts	pc
+
+fserr:
+	mov	$name,r1
+	jsr	pc,pstr
+	jsr	r5,mesg
+		< -- Cannot open file\n\0>; .even
+	jmp	done
+
+callout:
+	sys	stat; name; statb
+	bes	fserr
+	mov	statb+4,r0
+	bic	$!60000,r0
+	beq	1f
+	cmp	r0,$40000
+	beq	expand
+	rts	pc
+1:
+	mov	$dir,r1
+	clr	-(sp)
+1:
+	tst	(r1)
+	bne	3f
+	tst	(sp)
+	bne	2f
+	mov	r1,(sp)
+2:
+	add	$dirsiz,r1
+	cmp	r1,edir
+	blo	1b
+	mov	(sp)+,r1
+	bne	4f
+	jsr	r5,mesg
+		<Directory overflow\n\0>; .even
+	jmp	done
+4:
+	jsr	r5,verify; 'a
+		rts pc
+	jsr	r5,encode; name
+	br	2f
+3:
+	jsr	r5,decode; name1
+	mov	$name,r2
+	mov	$name1,r3
+3:
+	cmpb	(r2)+,(r3)
+	bne	2b
+	tstb	(r3)+
+	bne	3b
+	tst	(sp)+
+	tstb	flu
+	beq	3f
+	cmp	time0(r1),statb+32.
+	blo	3f
+	bhi	1f
+	cmp	time1(r1),statb+34.
+	bhis	1f
+3:
+	jsr	r5,verify; 'r
+		rts pc
+2:
+	mov	statb+4,mode(r1)
+	bis	$100000,mode(r1)
+	movb	statb+7,uid(r1)
+	movb	statb+8,gid(r1)
+	tstb	flf
+	beq	2f
+	clrb	statb+9.
+	clr	statb+10.
+2:
+	movb	statb+9.,size0(r1)
+	mov	statb+10.,size1(r1)
+	mov	statb+32.,time0(r1)
+	mov	statb+34.,time1(r1)
+1:
+	rts	pc

source/s2/tp3.s

@@ -0,0 +1,522 @@
+/ tap3 -- dec-tape lod/dmp
+
+gettape:
+	mov	$dir,r1
+	clr	-(sp)
+1:
+	tst	(r1)
+	beq	2f
+	jsr	r5,decode; name
+	cmp	rnarg,$2
+	ble	4f
+	mov	$name,r2
+	mov	*parg,r3
+3:
+	tstb	(r3)
+	beq	3f
+	cmpb	(r2)+,(r3)+
+	beq	3b
+	br	2f
+3:
+	tstb	(r2)
+	beq	4f
+	cmpb	(r2),$'/
+	bne	2f
+4:
+	mov	r1,-(sp)
+	jsr	pc,*(r5)
+	mov	(sp)+,r1
+	inc	(sp)
+2:
+	add	$dirsiz,r1
+	cmp	r1,edir
+	blo	1b
+	tst	(sp)+
+	bne	2f
+	cmp	rnarg,$2
+	ble	2f
+	mov	*parg,r1
+	jsr	pc,pstr
+	jsr	r5,mesg
+		< not found\n\0>; .even
+2:
+	dec	narg
+	add	$2,parg
+	cmp	narg,$2
+	bgt	gettape
+	tst	(r5)+
+	rts	r5
+
+delete:
+	jsr	r5,verify; 'd
+		rts pc
+	jsr	pc,clrent
+	rts	pc
+
+numb:
+	mov	r1,-(sp)
+	mov	r0,-(sp)
+	clr	r0
+	br	1f
+
+numbx:
+	mov	r1,-(sp)
+	mov	r0,-(sp)
+	movb	size0(r1),r0
+1:
+	mov	$catlb,r2
+1:
+	mov	$"  ,(r2)+
+	cmp	r2,$catlb+12.
+	blo	1b
+	cmp	(r5),$2
+	bne	1f
+	mov	$"00,-2(r2)
+1:
+	mov	(sp)+,r1
+	jsr	pc,numb2
+	mov	(r5)+,r0
+	sub	r0,r2
+	mov	r2,0f
+	mov	r0,0f+2
+	mov	$1,r0
+	sys	0; 9f
+.data
+9:
+	sys	write; 0:..; ..
+.text
+	mov	(sp)+,r1
+	rts	r5
+
+numb1:
+	clr	r0
+numb2:
+	div	$10.,r0
+	mov	r1,-(sp)
+	mov	r0,r1
+	beq	1f
+	jsr	pc,numb1
+1:
+	mov	(sp)+,r0
+	add	$'0,r0
+	movb	r0,(r2)+
+	rts	pc
+
+update:
+	jsr	pc,bitmap
+	mov	$dir,r1
+1:
+	tst	(r1)
+	beq	2f
+	bit	$100000,mode(r1)
+	beq	2f
+	tstb	size0(r1)
+	bne	9f
+	tst	size1(r1)
+	beq	2f
+9:
+	mov	ndentd8,-(sp)
+	inc	(sp)
+	movb	size0(r1),r2
+	mov	size1(r1),r3
+	add	$511.,r3
+	adc	r2
+	ashc	$-9,r2
+	mov	r3,size
+3:
+	mov	(sp),r2
+	mov	size,r3
+4:
+	jsr	pc,bitcalc
+	inc	r2
+	bitb	(sp)+,map(r0)
+	bne	4f
+	sob	r3,4b
+	mov	(sp)+,tapea(r1)
+	jsr	pc,setmap
+	br	2f
+4:
+	inc	(sp)
+	br	3b
+2:
+	add	$dirsiz,r1
+	cmp	r1,edir
+	blo	1b
+	jsr	pc,wrdir
+
+update1:
+	mov	$dir,r1
+	clr	-(sp)
+	mov	$-1,-(sp)
+1:
+	tst	(r1)
+	beq	2f
+	bit	$100000,mode(r1)
+	beq	2f
+	cmp	tapea(r1),(sp)
+	bhis	2f
+	mov	tapea(r1),(sp)
+	mov	r1,2(sp)
+2:
+	add	$dirsiz,r1
+	cmp	r1,edir
+	blo	1b
+	tst	(sp)+
+	mov	(sp)+,r1
+	bne	1f
+	rts	pc
+1:
+	bic	$100000,mode(r1)
+	movb	size0(r1),mss
+	mov	size1(r1),r2
+	bne	4f
+	tst	mss
+	beq	update1
+4:
+	jsr	r5,decode; name
+	mov	tapea(r1),r0
+	jsr	pc,wseek
+	clr	r3
+	sys	open; name; 0
+	bes	phserr
+	mov	r0,r3
+3:
+	tst	mss
+	bne	4f
+	cmp	r2,$512.
+	blo	3f
+4:
+	mov	r3,r0
+	sys	read; tapeb; 512.
+	bes	phserr
+	cmp	r0,$512.
+	bne	phserr
+	jsr	pc,twrite
+	sub	$512.,r2
+	sbc	mss
+	br	3b
+3:
+	mov	r2,0f
+	beq	3f
+	mov	r3,r0
+	sys	0; 9f
+.data
+9:
+	sys	read; tapeb; 0:..
+.text
+	bes	phserr
+	cmp	r0,0b
+	bne	phserr
+	jsr	pc,twrite
+3:
+	mov	r3,r0
+	sys	read; tapeb; 512.
+	bes	phserr
+	tst	r0
+	bne	phserr
+	mov	r3,r0
+	sys	close
+2:
+	jmp	update1
+
+phserr:
+	mov	r1,-(sp)
+	mov	$name,r1
+	jsr	pc,pstr
+	jsr	r5,mesg
+		< -- Phase error\n\0>; .even
+	mov	(sp)+,r1
+	clr	time0(r1) / time
+	beq	2b
+	sys	close
+	br	2b
+
+bitmap:
+	mov	$map,r0
+1:
+	clr	(r0)+
+	cmp	r0,$emap
+	blo	1b
+	mov	$dir,r1
+1:
+	tst	(r1)
+	beq	2f
+	bit	$100000,mode(r1)
+	bne	2f
+	tst	size1(r1)
+	bne	3f
+	tstb	size0(r1)
+	beq	2f
+3:
+	jsr	pc,setmap
+2:
+	add	$dirsiz,r1
+	cmp	r1,edir
+	blo	1b
+	rts	pc
+
+setmap:
+	movb	size0(r1),r2
+	mov	size1(r1),r3
+	add	$511.,r3
+	adc	r2
+	ashc	$-9.,r2
+	mov	tapea(r1),r2
+1:
+	jsr	pc,bitcalc
+	bitb	(sp),map(r0)
+	bne	maperr
+	bisb	(sp)+,map(r0)
+	inc	r2
+	sob	r3,1b
+	rts	pc
+
+bitcalc:
+	mov	(sp),-(sp)
+	cmp	r2,tapsiz
+	bhis	maperr
+	mov	r2,r0
+	bic	$!7,r0
+	mov	r0,-(sp)
+	mov	$1,r0
+	als	(sp)+,r0
+	mov	r0,2(sp)
+	mov	r2,r0
+	ash	$-3,r0
+	bic	$160000,r0
+	rts	pc
+
+maperr:
+	jsr	r5,mesg
+		<Tape overflow\n\0>; .even
+	jmp	done
+
+usage:
+	jsr	pc,bitmap
+	mov	$dir,r2
+1:
+	tst	(r2)
+	beq	2f
+	inc	nentr
+2:
+	add	$dirsiz,r2
+	cmp	r2,edir
+	blo	1b
+	mov	ndentd8,r2
+	inc	r2
+	mov	tapsiz,r3
+	dec	r3
+	sub	ndentd8,r3
+1:
+	jsr	pc,bitcalc
+	bitb	(sp)+,map(r0)
+	beq	2f
+	inc	nused
+	mov	r2,lused
+	br	3f
+2:
+	inc	nfree
+	tstb	flm
+	bne	1f
+3:
+	inc	r2
+	sob	r3,1b
+1:
+	mov	nentr,r0
+	jsr	r5,numb; 4
+	jsr	r5,mesg
+		< entries\n\0>; .even
+	mov	nused,r0
+	jsr	r5,numb; 4
+	jsr	r5,mesg
+		< used\n\0>; .even
+	tstb	flm
+	bne	1f
+	mov	nfree,r0
+	jsr	r5,numb; 4
+	jsr	r5,mesg
+		< free\n\0>; .even
+1:
+	mov	lused,r0
+	jsr	r5,numb; 4
+	jsr	r5,mesg
+		< last\n\0>; .even
+	rts	pc
+
+taboc:
+	tstb	flv
+	beq	4f
+	mov	mode(r1),r0
+	mov	r0,-(sp)
+	ash	$-6,r0
+	bit	$40,r0
+	jsr	pc,pmod
+	mov	(sp),r0
+	ash	$-3,r0
+	bit	$200,r0
+	jsr	pc,pmod
+	mov	(sp)+,r0
+	bit	$1000,r0
+	jsr	pc,pmod
+	clr	r0
+	bisb	uid(r1),r0
+	jsr	r5,numb; 4
+	clr	r0
+	bisb	gid(r1),r0
+	jsr	r5,numb; 4
+	mov	tapea(r1),r0
+	jsr	r5,numb; 5
+	mov	size1(r1),r0
+	jsr	r5,numbx; 9.
+	mov	r1,-(sp)
+	add	$time0,(sp)
+	jsr	pc,_localtime
+	mov	r0,(sp)
+	mov	10.(r0),r0
+	jsr	r5,numb; 3
+	mov	$'/,r0
+	jsr	pc,putc
+	mov	(sp),r0
+	mov	8.(r0),r0
+	inc	r0
+	jsr	r5,numb; 2
+	mov	$'/,r0
+	jsr	pc,putc
+	mov	(sp),r0
+	mov	6(r0),r0
+	jsr	r5,numb; 2
+	mov	(sp),r0
+	mov	4(r0),r0
+	jsr	r5,numb; 3
+	mov	$':,r0
+	jsr	pc,putc
+	mov	(sp)+,r0
+	mov	2(r0),r0
+	jsr	r5,numb; 2
+	mov	$' ,r0
+	jsr	pc,putc
+4:
+	mov	$name,r1
+	jsr	pc,pstr
+	jsr	r5,mesg
+		<\n\0>
+	rts	pc
+
+pmod:
+	beq	1f
+	mov	$'s,-(sp)
+	br	2f
+1:
+	bit	$1,r0
+	beq	1f
+	mov	$'x,-(sp)
+	br	2f
+1:
+	mov	$'-,-(sp)
+2:
+	bit	$2,r0
+	beq	1f
+	mov	$'w,-(sp)
+	br	2f
+1:
+	mov	$'-,-(sp)
+2:
+	bit	$4,r0
+	beq	1f
+	mov	$'r,r0
+	br	2f
+1:
+	mov	$'-,r0
+2:
+	jsr	pc,putc
+	mov	(sp)+,r0
+	jsr	pc,putc
+	mov	(sp)+,r0
+	jsr	pc,putc
+	rts	pc
+
+xtract:
+	movb	size0(r1),mss
+	bne	2f
+	tst	size1(r1)
+	beq	1f
+2:
+	jsr	r5,verify; 'x
+		rts pc
+	mov	size1(r1),r3
+	mov	tapea(r1),r0
+	jsr	pc,rseek
+	sys	unlink; name
+	mov	mode(r1),0f
+	sys	0; 9f
+.data
+9:
+	sys	creat; name; 0:..
+.text
+	bes	crterr
+	mov	r0,r2
+2:
+	tst	mss
+	bne	3f
+	cmp	r3,$512.
+	blo	2f
+3:
+	jsr	pc,tread
+	mov	r2,r0
+	sys	write; tapeb; 512.
+	bes	crterr1
+	cmp	r0,$512.
+	bne	crterr1
+	sub	r0,r3
+	sbc	mss
+	br	2b
+2:
+	mov	r3,0f
+	beq	2f
+	jsr	pc,tread
+	mov	r2,r0
+	sys	0; 9f
+.data
+9:
+	sys	write; tapeb; 0:..
+.text
+	bes	crterr1
+	cmp	r0,0b
+	bne	crterr1
+2:
+	mov	r2,r0
+	sys	close
+	movb	gid(r1),0f+1
+	movb	uid(r1),0f
+	sys	0; 9f
+.data
+9:
+	sys	chown; name; 0:..
+.text
+	mov	time0(r1),r0
+	mov	r1,-(sp)
+	mov	time1(r1),r1
+/	sys	0; 9f
+.data
+9:
+	sys	smdate; name
+.text
+	mov	(sp)+,r1
+1:
+	rts	pc
+
+crterr1:
+	clr	r0
+	mov	r1,-(sp)
+	clr	r1
+/	sys	smdate; name
+	mov	(sp)+,r1
+	mov	r2,r0
+	sys	close
+
+crterr:
+	mov	$name,r1
+	jsr	pc,pstr
+	jsr	r5,mesg
+		< -- create error\n\0>; .even
+	rts	pc

source/s2/tp4.s

@@ -0,0 +1,49 @@
+/ tap4 -- dec-tape lod/dmp
+
+.data
+tc:	</dev/tap>
+tcx:	<x\0>
+mt:	</dev/mt>
+mtx:	<0\0>
+tboot:	</usr/mdec/tboot\0>
+mboot:	</usr/mdec/mboot\0>
+.even
+.bss
+dir:	. = .+[mdirent*dirsiz]
+tapeb:
+map:	.=.+4096.
+emap:
+ch:	.=.+1
+flc:	.=.+1
+flf:	.=.+1
+fli:	.=.+1
+flm:	.=.+1
+flu:	.=.+1
+flv:	.=.+1
+flw:	.=.+1
+.even
+
+command:.=.+2
+sum:	.=.+2
+size:	.=.+2
+nentr:	.=.+2
+nused:	.=.+2
+nfree:	.=.+2
+lused:	.=.+2
+catlb:	.=.+20.
+narg:	.=.+2
+rnarg:	.=.+2
+parg:	.=.+2
+fio:	.=.+2
+mss:	.=.+2
+ndirent:.=.+2
+ndentd8:.=.+2
+edir:	.=.+2
+rseeka:	.=.+2
+wseeka:	.=.+2
+tapsiz:	.=.+2
+name:	.=.+32.
+name1:	.=.+32.
+statb:	.=.+40.
+
+smdate = 30.

source/s2/tr.c

@@ -0,0 +1,144 @@
+int dflag 0;
+int sflag 0;
+int cflag 0;
+int save 0;
+char code[256];
+char squeez[256];
+char vect[256];
+struct string { int last, max, rep; char *p; } string1, string2;
+int inbuf[259];
+
+main(argc,argv)
+char **argv;
+{
+	int i, j;
+	int c, d;
+	char *compl;
+	extern fout;
+
+	string1.last = string2.last = 0;
+	string1.max = string2.max = 0;
+	string1.rep = string2.rep = 0;
+	string1.p = string2.p = "";
+
+	if(--argc>0) {
+		argv++;
+		if(*argv[0]=='-'&&argv[0][1]!=0) {
+			while(*++argv[0])
+				switch(*argv[0]) {
+				case 'c':
+					cflag++;
+					continue;
+				case 'd':
+					dflag++;
+					continue;
+				case 's':
+					sflag++;
+					continue;
+				}
+			argc--;
+			argv++;
+		}
+	}
+	if(argc>0) string1.p = argv[0];
+	if(argc>1) string2.p = argv[1];
+	for(i=0; i<256; i++)
+		code[i] = vect[i] = 0;
+	if(cflag) {
+		while(c = next(&string1))
+			vect[c&0377] = 1;
+		j = 0;
+		for(i=1; i<256; i++)
+			if(vect[i]==0) vect[j++] = i;
+		vect[j] = 0;
+		compl = vect;
+	}
+	for(i=0; i<256; i++)
+		squeez[i] = 0;
+	for(;;){
+		if(cflag) c = *compl++;
+		else c = next(&string1);
+		if(c==0) break;
+		d = next(&string2);
+		if(d==0) d = c;
+		code[c&0377] = d;
+		squeez[d&0377] = 1;
+	}
+	while(d = next(&string2))
+		squeez[d&0377] = 1;
+	squeez[0] = 1;
+	for(i=0;i<256;i++) {
+		if(code[i]==0) code[i] = i;
+		else if(dflag) code[i] = 0;
+	}
+
+	inbuf[0] = 0;
+	fout = dup(1);
+	close(1);
+	while((c=getc(inbuf)) >=0 ) {
+		if(c == 0) continue;
+		if(c = code[c&0377]&0377)
+			if(!sflag || c!=save || !squeez[c&0377])
+				putchar(save = c);
+	}
+	flush();
+}
+
+next(s)
+struct string *s;
+{
+	int a, b, c, n;
+	int base;
+
+	if(--s->rep > 0) return(s->last);
+	if(s->last < s->max) return(++s->last);
+	if(*s->p=='[') {
+		nextc(s);
+		s->last = a = nextc(s);
+		s->max = 0;
+		switch(nextc(s)) {
+		case '-':
+			b = nextc(s);
+			if(b<a || *s->p++!=']')
+				goto error;
+			s->max = b;
+			return(a);
+		case '*':
+			base = (*s->p=='0')?8:10;
+			n = 0;
+			while((c = *s->p)>='0' && c<'0'+base) {
+				n = base*n + c - '0';
+				s->p++;
+			}
+			if(*s->p++!=']') goto error;
+			if(n==0) n = 1000;
+			s->rep = n;
+			return(a);
+		default:
+		error:
+			write(1,"Bad string\n",11);
+			exit();
+		}
+	}
+	return(nextc(s));
+}
+
+nextc(s)
+struct string *s;
+{
+	int c, i, n;
+
+	c = *s->p++;
+	if(c=='\\') {
+		i = n = 0;
+		while(i<3 && (c = *s->p)>='0' && c<='7') {
+			n = n*8 + c - '0';
+			i++;
+			s->p++;
+		}
+		if(i>0) c = n;
+		else c = *s->p++;
+	}
+	if(c==0) *--s->p = 0;
+	return(c&0377);
+}

source/s2/tty.s

@@ -0,0 +1,17 @@
+/ tty -- get tty number
+
+.globl	ttyn
+
+	clr	r0
+	jsr	pc,ttyn
+	movb	r0,nam
+	mov	$1,r0
+	sys	write; name; 5
+	sys	exit
+
+.data
+name:
+	<tty>
+nam:
+	<x\n>
+.even

source/s2/typo.c

@@ -0,0 +1,347 @@
+char number[3];
+int eflg;
+char w2006[100];
+flg 0;
+char realwd[100];
+char *wd {&realwd[1]};
+char *fptr;
+char *ffptr &ffbuf;
+char ffbuf[36];
+int	neng;
+int	npr;
+int table[2];	/*keep these four cards in order*/
+int tab1[26];
+int tab2[730];
+char tab3[19684];
+int logtab[256];
+float inctab[256];
+char nwd[100];
+int tot;
+int wtot;
+char *buf[3];
+file[3];
+ptr[3];
+char *name[3];
+bsp[768];
+
+main(argc,argv) int argc; char *argv[]; {
+	char let,lt;
+	auto arg,t,sw,i,j,salt,er,c;
+	register k,l,m;
+	double junk;
+	int unl();
+	int ii;
+	double log(), exp(), pow();
+
+	nice(-20);
+	inctab[0] = 1;
+	logtab[0] = -10;
+	for(ii=1; ii<256; ii++){
+		inctab[ii] = exp(-ii/30.497);
+		logtab[ii] = log(30.*pow(1.0333,ii+0.) - 30.) + .5;
+		}
+	logtab[1] = -10;
+
+	number[2] = ' ';
+	buf[0] = bsp;
+	buf[1] = bsp + 0400;
+	buf[2] = bsp + 01000;
+	ptr[0] = 0; ptr[1] = 0;
+	ptr[2] = 1;
+	arg = 1;
+	while(argc>1 && argv[arg][0] == '-') {
+		switch(argv[arg][1]) {
+		default:
+			printf("Unrecognizable argument: %c\n",argv[arg][1]);
+				exit();
+		case 0:
+		case 'n':
+				neng++;
+				break;
+		case '1':
+				npr++;
+		}
+		arg++;
+		--argc;
+	}
+	if(!neng) {
+		salt = open("/usr/lib/salt",0);
+		er = read(salt,table,21200);
+			if(er != 21200)err("read salt");
+		close(salt);
+		}
+	if((signal(2,1) & 1) != 1)
+	signal(2,unl);
+	name[0] = "/usr/tmp/ttmpa1";
+	name[1] = "/usr/tmp/ttmpa2";
+	name[2] = "/usr/tmp/ttmpa3";
+	while((file[0] = open(name[0],1)) > 0){
+		close(file[0]);
+		for(j=0; j < 3; j++)name[j][13]++;
+		if(name[0][13] == 'z')err("creat tmp file");
+	}
+	file[0] = creat(name[0],0666);
+	fptr = argv[arg];
+	if(argc == 1) {argc = 2; arg = 0;}
+	while(--argc){
+		if(arg == 0){
+			file[2] = 0;
+		}else{
+			file[2] = open(argv[arg++],0);
+			if(file[2] < 0)err("open input file");
+		}
+		eflg = 1;
+		while((j = wdval(2)) != 0){
+			put(0,nwd,j);
+			k = -1;
+			l = 0;
+			m = 1;
+			if(inctab[table[0]] > (junk=rand()/32768.)) table[0]++;
+			while(m <= j){
+				c = 27*wd[k++] + wd[l++];
+				if(inctab[tab2[c]] > junk) tab2[c]++;
+				c = 27*c + wd[m++];
+				if(inctab[tab3[c]] > junk) tab3[c]++;
+			}
+			c = 27*wd[k] + wd[l];
+			if(inctab[tab2[c]] > junk) tab2[c]++;
+		}
+		if(file[2]) close(file[2]);
+	}
+	flsh(0,0);
+	close(file[0]);
+	sw = fork();
+		if(sw == 0){execl("/usr/bin/usort","usort","-o",name[2],name[0],0);
+			err("sort"); }
+		if(sw == -1)err("fork");
+	er = wait();
+		if(er != sw)err("probs");
+	file[0] = creat(name[0],0666);
+		if(file[0] < 0)err("creat tmp");
+	file[1] = open("/usr/lib/w2006",0);
+		if(file[1] < 0)err("open w2006");
+	ptr[1] = 1;
+	for(k=0;((c = w2006[k] = get(1)) != '\n');k++)
+		if(c == -1) break;
+	file[2] = open(name[2],0);
+	if(file[2] < 0)err("open tmp");
+	ptr[2] = 1;
+
+	while(ptr[2]){
+		l=0;
+		for(k=0;((c = wd[k] = get(2)) != '\n');k++)
+			if(c == -1)goto done;
+		for(i=0; i<=k;i++){
+			if(wd[i] < w2006[l]){
+				put(0,wd,k);
+				break;
+			}
+			if(wd[i] > w2006[l]){
+				for(l=0;((c = w2006[l] = get(1)) != '\n');l++)
+				if(c == -1){
+					put(0,wd,k);
+					for(k=0;((c = wd[k] =get(2))!= -1);k++){
+						put(0,wd,k);
+						k = -1;
+					}
+					goto done;
+				}
+				i = -1;
+				l=0;
+				continue;
+			}
+			l++;
+		}
+	}
+done:
+	close(file[2]); 
+	unlink(name[2]);
+	flsh(0,0);
+	close(file[1]);
+	close(file[0]);
+	ptr[1] = 1;
+	file[1] = open(name[0],0);
+		if(file[1] < 0)err("open tmp ");
+	file[0] = creat(name[1],0666);
+		if(file[0] < 0)err("create tmp");
+	while((j = nwdval(1)) != 0){
+		wtot = 0;
+		flg = 0;
+		k = -1; l = 0; m = 1;
+		while(m <= j){
+			tot = 0;
+			c = wd[k++]*27 + wd[l++];
+			tot =+ (logtab[tab2[c]]+logtab[tab2[wd[k]*27+wd[l]]]);
+			tot =>> 1;
+			c = c*27 + wd[m++];
+			tot =- logtab[tab3[c] & 0377];
+			if(tot > wtot) wtot = tot;
+			}
+		if(wtot < 0) wtot = 0;
+		t = conf(wtot,2,number);
+		put(0,number,2);
+		put(0,nwd,j);
+		}
+	flsh(0,0);
+	close(file[1]);
+	close(file[0]);
+
+	sw = fork();
+		if(sw == 0){execl("/bin/sort","sort","+0nr", "+1","-o",name[1],name[1]
+			,0);
+			err("sort"); }
+		if(sw == -1)err("fork");
+	er = wait();
+		if(er != sw)err("prob");
+
+	sw = fork();
+		if(sw == 0){
+			if(npr) {
+				execl("/bin/cat","cat",name[1],0);
+			} else {
+				i = 0 ;
+				while((c = "Possible typo's in "[i++])!=0)
+					*ffptr++ = c;
+				i = 0;
+				while((c = fptr[i++]) != 0)
+					*ffptr++ = c;
+				*ffptr = 0;
+				execl("/bin/pr","pr","-3", "-h",
+				ffbuf,name[1],0);
+				err("pr");
+		}
+	}
+		if(sw == -1)err("fork");
+	er = wait();
+		if(er != sw)err("prob");
+	unl();
+}
+
+unl() {
+	register j;
+	j = 2;
+	while(j--)unlink(name[j]);
+	exit();
+}
+
+
+err(c) char c[];{
+	register j;
+	printf("cannot %s\n",c);
+	unl();
+}
+
+get(ifile) int ifile;{
+	static char *ibuf[10];
+	if(--ptr[ifile]){
+		return(*ibuf[ifile]++ & 0377);}
+	if(ptr[ifile] = read(file[ifile],buf[ifile],512)){
+		if(ptr[ifile] < 0)goto prob;
+		ibuf[ifile] = buf[ifile];
+		return(*ibuf[ifile]++ & 0377);
+	}
+	ptr[ifile] = 1;
+	return(-1);
+
+prob:
+	ptr[ifile] = 1;
+	printf("read error\n");
+	return(-1);
+}
+
+put(ofile,s,optr) char s[]; {
+	register i;
+
+	while(optr-- >= 0)
+		 buf[ofile][(ptr[ofile] < 512)?ptr[ofile]++:flsh(ofile,1)] = *s++;
+	return;
+}
+
+flsh(ofile,i){
+	register error;
+	error = write(file[ofile],buf[ofile],ptr[ofile]);
+	if(error < 0)goto prob;
+
+	ptr[ofile] = i;
+	return(0);
+prob:
+	printf("write error on t.%d\n",file[ofile]);
+	unl();
+}
+
+wdval(wfile) int wfile; {
+	static let,wflg;
+	register j;
+beg:
+	j = -1;
+	if(wflg == 1){wflg = 0;
+		goto st; }
+	while((let = get(wfile)) != '\n'){
+st:
+		switch(let){
+		case -1:	return(0);
+		case '%':	if(j != -1)break;
+					goto ret;
+		case '-':
+				if((let = get(wfile)) == '\n'){
+					while((let = get(wfile)) == '\n')if(let == -1)return(0);
+					goto st; }
+				else {wflg = 1;
+					goto ret; }
+		case '\'':
+				if(eflg != 1){
+					if(j < 1)goto beg;
+						else break;
+					}
+		case '.':
+				if(eflg == 1){
+					while((let = get(wfile)) != '\n')if(let == -1)return(0);
+					goto beg; }
+				else goto ret;
+		default:
+				eflg = 0;
+				if(let < 'A')goto ret;
+				if(let <= 'Z'){ wd[++j] = let - 0100;
+					nwd[j] = let + ' ';
+					break; }
+				if(let < 'a' || let > 'z')goto ret;
+				wd[++j] = let - 0140;
+				nwd[j] = let;
+			}
+		 eflg = 0;	}
+
+	eflg = 1;
+ret:
+	if(j < 1)goto beg;
+	nwd[++j] = '\n';
+	wd[j] = 0;
+	return(j);
+}
+
+nwdval(wfile) int wfile;{
+	register j;
+	register char c;
+	j = -1;
+	do{
+		if(( c = nwd[++j] = get(wfile)) == -1)return(0);
+		wd[j] = c - 0140;
+	}
+	while(c != '\n');
+	wd[j] = '\0';
+	return(j);
+}
+conf(n,width,cbuf) char cbuf[]; {
+	register i,a;
+
+	i = width;
+	while(i--)cbuf[i] = ' ';
+
+	cbuf[(a = n/10)?conf(a,--width,cbuf):--width] = n%10 + '0';
+
+	return(++width);
+}
+rand(){
+	static gorp;
+	gorp = (gorp + 625) & 077777;
+	return(gorp);
+}

source/s2/umount.c

@@ -0,0 +1,53 @@
+#define	NMOUNT	16
+#define	NAMSIZ	32
+
+struct mtab {
+	char	file[NAMSIZ];
+	char	spec[NAMSIZ];
+} mtab[NMOUNT];
+
+main(argc, argv)
+char **argv;
+{
+	register struct mtab *mp;
+	register char *p1, *p2;
+	int mf;
+
+	sync();
+	mf = open("/etc/mtab", 0);
+	read(mf, mtab, NMOUNT*2*NAMSIZ);
+	if(argc != 2) {
+		printf("arg count\n");
+		return;
+	}
+	if (umount(argv[1]) < 0) {
+		perror("umount");
+		return;
+	}
+	p1 = argv[1];
+	while(*p1++)
+		;
+	p1--;
+	while(*--p1 == '/')
+		*p1 = '\0';
+	while(p1 > argv[1] && *--p1 != '/')
+		;
+	if(*p1 == '/')
+		p1++;
+	argv[1] = p1;
+	for (mp = mtab; mp < &mtab[NMOUNT]; mp++) {
+		p1 = argv[1];
+		p2 = &mp->spec[0];
+		while (*p1++ == *p2)
+			if (*p2++ == 0) {
+				for (p1 = mp->file; p1 < &mp->file[NAMSIZ*2];)
+					*p1++ = 0;
+				mp = &mtab[NMOUNT];
+				while ((--mp)->file[0] == 0);
+				mf = creat("/etc/mtab", 0644);
+				write(mf, mtab, (mp-mtab+1)*2*NAMSIZ);
+				return;
+			}
+	}
+	printf("%s not in mount table\n", argv[1]);
+}

source/s2/uniq.c

@@ -0,0 +1,162 @@
+fields 0;
+letters 0;
+linec;
+mode;
+uniq;
+
+main(argc, argv)
+int argc;
+char *argv[];
+{
+	extern fin, fout;
+	int f;
+	static char b1[1000], b2[1000];
+
+loop:
+	if(argc > 1) {
+		if(*argv[1] == '-') {
+			if(argv[1][1] <= '9')
+				fields = conv(&argv[1][1]);
+			else mode = argv[1][1];
+			argc--;
+			argv++;
+			goto loop;
+		}
+		if(*argv[1] == '+') {
+			letters = conv(&argv[1][1]);
+			argc--;
+			argv++;
+			goto loop;
+		}
+		f = open(argv[1], 0);
+		if(f < 0) {
+			printf("cannot open %s\n", argv[1]);
+			exit();
+		}
+		fin = f;
+	} else
+		fin = dup(0);
+	if(argc > 2) {
+		f = creat(argv[2], 0666);
+		if(f < 0) {
+			printf("cannot create %s\n", argv[2]);
+			exit();
+		}
+		fout = f;
+	} else
+		fout = dup(1);
+	close(0);
+	close(1);
+	gline(b1);
+l1:
+	linec++;
+	if(gline(b2)) {
+		pline(b1);
+		flush();
+		exit();
+	}
+	if(equal(b1, b2)) goto l1;
+	pline(b1);
+	linec = 0;
+l2:
+	linec++;
+	if(gline(b1)) {
+		pline(b2);
+		flush();
+		exit();
+	}
+	if(equal(b1, b2)) goto l2;
+	pline(b2);
+	linec = 0;
+	goto l1;
+}
+
+gline(buf)
+char buf[];
+{
+	int c;
+
+	while((c = getchar()) != '\n') {
+		if(c == '\0')
+			return(1);
+		*buf++ = c;
+	}
+	*buf = 0;
+	return(0);
+}
+
+pline(buf)
+char buf[];
+{
+	int c;
+
+	switch(mode) {
+
+	case 'u':
+		if(uniq) {;
+			uniq = 0;
+			return;
+		}
+		break;
+
+	case 'd':
+		if(uniq) break;
+		return;
+
+	case 'c':
+		printf("%4d ", linec);
+	}
+	uniq = 0;
+	while((c = *buf++) != 0)
+		putchar(c);
+	putchar('\n');
+}
+
+equal(b1, b2)
+char b1[], b2[];
+{
+	int c;
+
+	b1 = skip(b1);
+	b2 = skip(b2);
+	while((c = *b1++) != 0)
+		if(c != *b2++) return(0);
+	if(*b2 != 0)
+		return(0);
+	uniq++;
+	return(1);
+}
+
+char *
+skip(s)
+char *s;
+{
+	int nf, nl;
+
+	nf = nl = 0;
+	while(nf++ < fields) {
+		while(*s==' ' || *s=='\t')
+			s++;
+		while( !(*s==' ' || *s=='\t') ) 
+			if(*s == 0) return(s);
+			else s++;
+	}
+	while(nl++ < letters) 
+			if(*s == 0) return(s);
+			else s++;
+	return(s);
+}
+
+conv(s)
+char *s;
+{
+	int d, n;
+
+	n = 0;
+	for(;;) {
+		d = *s++ - '0';
+		if(0>d || d>9) break;
+		n = n*10 + d;
+	}
+	return(n);
+}

source/s2/units.c

@@ -0,0 +1,456 @@
+#define	NDIM	10
+#define	NTAB	601
+char	*dfile	"/usr/lib/units";
+char	*unames[NDIM];
+double	getflt();
+int	fperr();
+struct unit
+{
+	double	factor;
+	char	dim[NDIM];
+};
+
+struct table
+{
+	double	factor;
+	char	dim[NDIM];
+	char	*name;
+} table[NTAB];
+char	names[NTAB*10];
+struct prefix
+{
+	double	factor;
+	char	*pname;
+} prefix[]
+{
+	1e-18,	"atto",
+	1e-15,	"femto",
+	1e-12,	"pico",
+	1e-9,	"nano",
+	1e-6,	"micro",
+	1e-3,	"milli",
+	1e-2,	"centi",
+	1e-1,	"deci",
+	1e1,	"deka",
+	1e2,	"hecta",
+	1e2,	"hecto",
+	1e3,	"kilo",
+	1e6,	"mega",
+	1e6,	"meg",
+	1e9,	"giga",
+	1e12,	"tera",
+	0.0,	0
+};
+int	ibuf[259];
+int	fperrc;
+int	peekc;
+int	dumpflg;
+
+main(argc, argv)
+char *argv[];
+{
+	register i;
+	register char *file;
+	struct unit u1, u2;
+	double f;
+
+	if(argc>1 && *argv[1]=='-') {
+		argc--;
+		argv++;
+		dumpflg++;
+	}
+	file = dfile;
+	if(argc > 1)
+		file = argv[1];
+	if(fopen(file, ibuf) < 0) {
+		printf("no table\n");
+		exit();
+	}
+	ldfps(07600); /* interrupt on fp errors */
+	signal(8, fperr);
+	init();
+	close(ibuf[0]);
+	ibuf[0] = 0;
+
+loop:
+	fperrc = 0;
+	printf("you have: ");
+	if(convr(&u1))
+		goto loop;
+	if(fperrc)
+		goto fp;
+loop1:
+	printf("you want: ");
+	if(convr(&u2))
+		goto loop1;
+	for(i=0; i<NDIM; i++)
+		if(u1.dim[i] != u2.dim[i])
+			goto conform;
+	f = u1.factor/u2.factor;
+	if(fperrc)
+		goto fp;
+	printf("\t* %e\n", f);
+	printf("\t/ %e\n", 1./f);
+	goto loop;
+
+conform:
+	if(fperrc)
+		goto fp;
+	printf("conformability\n");
+	units(&u1);
+	units(&u2);
+	goto loop;
+
+fp:
+	printf("underflow or overflow\n");
+	goto loop;
+}
+
+units(up)
+struct unit *up;
+{
+	register struct unit *p;
+	register f, i;
+
+	p = up;
+	printf("\t%e ", p->factor);
+	f = 0;
+	for(i=0; i<NDIM; i++)
+		f =| pu(p->dim[i], i, f);
+	if(f&1) {
+		putchar('/');
+		f = 0;
+		for(i=0; i<NDIM; i++)
+			f =| pu(-p->dim[i], i, f);
+	}
+	putchar('\n');
+}
+
+pu(u, i, f)
+{
+
+	if(u > 0) {
+		if(f&2)
+			putchar('-');
+		if(unames[i])
+			printf("%s", unames[i]); else
+			printf("*%c*", i+'a');
+		if(u > 1)
+			putchar(u+'0');
+			return(2);
+	}
+	if(u < 0)
+		return(1);
+	return(0);
+}
+
+convr(up)
+struct unit *up;
+{
+	register struct unit *p;
+	register c;
+	register char *cp;
+	char name[20];
+	int den, err;
+
+	p = up;
+	for(c=0; c<NDIM; c++)
+		p->dim[c] = 0;
+	p->factor = getflt();
+	if(p->factor == 0.)
+		p->factor = 1.0;
+	err = 0;
+	den = 0;
+	cp = name;
+
+loop:
+	switch(c=get()) {
+
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+	case '-':
+	case '/':
+	case ' ':
+	case '\t':
+	case '\n':
+		if(cp != name) {
+			*cp++ = 0;
+			cp = name;
+			err =| lookup(cp, p, den, c);
+		}
+		if(c == '/')
+			den++;
+		if(c == '\n')
+			return(err);
+		goto loop;
+	}
+	*cp++ = c;
+	goto loop;
+}
+
+lookup(name, up, den, c)
+char *name;
+struct unit *up;
+{
+	register struct unit *p;
+	register struct table *q;
+	register i;
+	char *cp1, *cp2;
+	double e;
+
+	p = up;
+	e = 1.0;
+
+loop:
+	q = hash(name);
+	if(q->name) {
+		l1:
+		if(den) {
+			p->factor =/ q->factor*e;
+			for(i=0; i<NDIM; i++)
+				p->dim[i] =- q->dim[i];
+		} else {
+			p->factor =* q->factor*e;
+			for(i=0; i<NDIM; i++)
+				p->dim[i] =+ q->dim[i];
+		}
+		if(c >= '2' && c <= '9') {
+			c--;
+			goto l1;
+		}
+		return(0);
+	}
+	for(i=0; cp1 = prefix[i].pname; i++) {
+		cp2 = name;
+		while(*cp1 == *cp2++)
+			if(*cp1++ == 0) {
+				cp1--;
+				break;
+			}
+		if(*cp1 == 0) {
+			e =* prefix[i].factor;
+			name = cp2-1;
+			goto loop;
+		}
+	}
+	for(cp1 = name; *cp1; cp1++);
+	if(cp1 > name+1 && *--cp1 == 's') {
+		*cp1 = 0;
+		goto loop;
+	}
+	printf("cannot recognize %s\n", name);
+	return(1);
+}
+
+equal(s1, s2)
+char *s1, *s2;
+{
+	register char *c1, *c2;
+
+	c1 = s1;
+	c2 = s2;
+	while(*c1++ == *c2)
+		if(*c2++ == 0)
+			return(1);
+	return(0);
+}
+
+init()
+{
+	register char *cp;
+	register struct table *tp, *lp;
+	int c, i, f, t;
+	char *np;
+
+	cp = names;
+	for(i=0; i<NDIM; i++) {
+		np = cp;
+		*cp++ = '*';
+		*cp++ = i+'a';
+		*cp++ = '*';
+		*cp++ = 0;
+		lp = hash(np);
+		lp->name = np;
+		lp->factor = 1.0;
+		lp->dim[i] = 1;
+	}
+	lp = hash("");
+	lp->name = cp-1;
+	lp->factor = 1.0;
+
+l0:
+	c = get();
+	if(c == 0) {
+		printf("%l units; %l bytes\n\n", i, cp-names);
+		if(dumpflg)
+		for(tp = &table[0]; tp < &table[NTAB]; tp++) {
+			if(tp->name == 0)
+				continue;
+			printf("%s", tp->name);
+			units(tp);
+		}
+		return;
+	}
+	if(c == '/')
+		while(c != '\n')
+			c = get();
+	if(c == '\n')
+		goto l0;
+	np = cp;
+	while(c != ' ' && c != '\t') {
+		*cp++ = c;
+		c = get();
+		if(c == '\n') {
+			*cp++ = 0;
+			tp = hash(np);
+			if(tp->name)
+				goto redef;
+			tp->name = np;
+			tp->factor = lp->factor;
+			for(c=0; c<NDIM; c++)
+				tp->dim[c] = lp->dim[c];
+			i++;
+			goto l0;
+		}
+	}
+	*cp++ = 0;
+	lp = hash(np);
+	if(lp->name)
+		goto redef;
+	convr(lp);
+	lp->name = np;
+	f = 0;
+	i++;
+	if(lp->factor != 1.0)
+		goto l0;
+	for(c=0; c<NDIM; c++) {
+		t = lp->dim[c];
+		if(t>1 || (f>0 && t!=0))
+			goto l0;
+		if(f==0 && t==1) {
+			if(unames[c])
+				goto l0;
+			f = c+1;
+		}
+	}
+	if(f>0)
+		unames[f-1] = np;
+	goto l0;
+
+redef:
+	printf("redefination %s\n", np);
+	goto l0;
+}
+
+double
+getflt()
+{
+	register c, i, dp;
+	double d, e;
+	int f;
+
+	d = 0.;
+	dp = 0;
+	do
+		c = get();
+	while(c == ' ' || c == '\t');
+
+l1:
+	if(c >= '0' && c <= '9') {
+		d = d*10. + c-'0';
+		if(dp)
+			dp++;
+		c = get();
+		goto l1;
+	}
+	if(c == '.') {
+		dp++;
+		c = get();
+		goto l1;
+	}
+	if(dp)
+		dp--;
+	if(c == '+' || c == '-') {
+		f = 0;
+		if(c == '-')
+			f++;
+		i = 0;
+		c = get();
+		while(c >= '0' && c <= '9') {
+			i = i*10 + c-'0';
+			c = get();
+		}
+		if(f)
+			i = -i;
+		dp =- i;
+	}
+	e = 1.;
+	i = dp;
+	if(i < 0)
+		i = -i;
+	while(i--)
+		e =* 10.;
+	if(dp < 0)
+		d =* e; else
+		d =/ e;
+	if(c == '|')
+		return(d/getflt());
+	peekc = c;
+	return(d);
+}
+
+get()
+{
+	register c;
+
+	if(c=peekc) {
+		peekc = 0;
+		return(c);
+	}
+	c = getc(ibuf);
+	if(c <= 0) {
+		if(ibuf[0])
+			return(0);
+		printf("\n");
+		exit();
+	}
+	return(c);
+}
+
+hash(name)
+char *name;
+{
+	register struct table *tp;
+	register char *np;
+	register h;
+
+	h = 0;
+	np = name;
+	while(*np)
+		h = h*57 + *np++ - '0';
+	h = lrem(0, h, NTAB);
+	tp = &table[h];
+l0:
+	if(tp->name == 0)
+		return(tp);
+	if(equal(name, tp->name))
+		return(tp);
+	tp++;
+	if(tp >= &table[NTAB])
+		tp = table;
+	goto l0;
+}
+
+fperr()
+{
+
+	signal(8, fperr);
+	fperrc++;
+}

source/s2/update.s

@@ -0,0 +1,17 @@
+	sys	fork
+		br 1f
+	sys	exit
+1:
+	clr	r0
+	sys	close
+	mov	$1,r0
+	sys	close
+	mov	$2,r0
+	sys	close
+1:
+	sys	sync
+	mov	$30.,r0
+	sys	sleep
+	br	1b
+sleep = 35.
+sync = 36.

source/s2/usort.c

@@ -0,0 +1,649 @@
+#define	L	512
+#define	N	7
+#define	C	20
+#define	MEM	(16*2048)
+#define NF	10
+
+int	ibuf[259];
+int	obuf[259];
+char	*file;
+char	*filep;
+int	nfiles;
+int	nlines;
+int	ntext;
+int	*lspace;
+char	*tspace;
+int	cmp();
+int	term();
+int 	mflg;
+char	*outfil;
+char	tabchar;
+int 	eargc;
+char	**eargv;
+
+char	fold[128] {
+	0000,0001,0002,0003,0004,0005,0006,0007,
+	0010,0011,0012,0013,0014,0015,0016,0017,
+	0020,0021,0022,0023,0024,0025,0026,0027,
+	0030,0031,0032,0033,0034,0035,0036,0037,
+	0040,0041,0042,0043,0044,0045,0046,0047,
+	0050,0051,0052,0053,0054,0055,0056,0057,
+	0060,0061,0062,0063,0064,0065,0066,0067,
+	0070,0071,0072,0073,0074,0075,0076,0077,
+	0100,0101,0102,0103,0104,0105,0106,0107,
+	0110,0111,0112,0113,0114,0115,0116,0117,
+	0120,0121,0122,0123,0124,0125,0126,0127,
+	0130,0131,0132,0133,0134,0134,0136,0137,
+	0140,0101,0102,0103,0104,0105,0106,0107,
+	0110,0111,0112,0113,0114,0115,0116,0117,
+	0120,0121,0122,0123,0124,0125,0126,0127,
+	0130,0131,0132,0173,0174,0175,0176,0177
+};
+char	nofold[128];
+char	dict[128] {
+	1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,
+	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+	0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+	0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,
+	1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+	0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,
+	1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+	0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1
+};
+char	nodict[128] { 1 };
+
+struct	field {
+	char *code;
+	char *ignore;
+	int nflg;
+	int rflg;
+	int bflg;
+	char *m[2];
+	char *n[2];
+}	fields[NF];
+int proto[9] {
+	&fold,
+	&nodict,
+	0,
+	1,
+	0,
+	0,-1,
+	0,0
+};
+int	nfields;
+int 	error 1;
+
+main(argc, argv)
+char **argv;
+{
+	register a, i;
+	char *arg;
+	register int *p;
+	int *q;
+
+	for(a=0; a<128; a++)
+		nofold[a] = a;
+	nodict[127] = 1;
+	copyproto();
+	eargv = argv;
+	while (--argc > 0) {
+		if(**++argv == '-') for(arg = *argv;;) {
+			switch(*++arg) {
+			case '\0':
+				if(arg[-1] == '-')
+					eargv[eargc++] = "-";
+				break;
+
+			case 'm':
+				mflg++;
+				continue;
+
+			case 'o':
+				if(--argc > 0)
+					outfil = *++argv;
+				continue;
+
+			default:
+				field(++*argv,1);
+				break;
+			}
+			break;
+		} else if (**argv == '+') {
+			if(++nfields>=NF) {
+				mess("Too many keys\n");
+				exit(1);
+			}
+			copyproto();
+			field(++*argv,0);
+		} else
+			eargv[eargc++] = *argv;
+	}
+	q = &fields[0];
+	for(a=1; a<=nfields; a++) {
+		p = &fields[a];
+		for(i=0; i<5; i++)	/*sensitive to sizeof(proto)*/
+			if(p[i] != proto[i])
+				goto next;
+		for(i=0; i<5; i++)
+			p[i] = q[i];
+next:	;
+	}
+	if(eargc == 0)
+		eargv[eargc++] = "-";
+
+	a = MEM;
+	i = lspace = sbrk(0);
+	while(brk(a) == -1)
+		a =- 512;
+	brk(a =- 512);	/* for recursion */
+	a =- i;
+	nlines = ((a-L)>>1) & 077777;
+	nlines =/ 5;
+	ntext = nlines*8;
+	tspace = lspace+nlines;
+	file = "/usr/tmp/stmXaa";
+loop:
+	filep = file;
+	while(*filep != 'X')
+		filep++;
+	for(*filep = 'a';;(*filep)++) {
+		if(stat(file, lspace) < 0) {
+			a = creat(file, 0600);
+			if(a >= 0)
+				break;
+		}
+		if(*filep == 'z') {
+			if(file[1] != 't') {
+				file = "/tmp/stmXaa";
+				goto loop;
+			}
+			mess("Cannot locate temp\n");
+			exit(1);
+		}
+	}
+	close(a);
+	filep++;
+	if ((signal(2, 1) & 01) == 0)
+		signal(2, term);
+	nfiles = eargc;
+	if(!mflg) {
+		ibuf[0] = -1;
+		sort();
+		close(0);
+	}
+	for(a = mflg?0:eargc; a+N < nfiles; a=+N) {
+		newfile();
+		merge(a, a+N);
+	}
+	if(a != nfiles) {
+		oldfile();
+		merge(a, nfiles);
+	}
+	error = 0;
+	term();
+}
+
+sort()
+{
+	register char *cp;
+	register *lp, c;
+	int done;
+	int i;
+	int f;
+
+	done = 0;
+	i = 0;
+	do {
+		cp = tspace;
+		lp = lspace;
+		while(lp < lspace+nlines && cp < tspace+ntext) {
+			*lp++ = cp;
+			while((*cp++ = c = getc(ibuf)) != '\n') {
+				if(c >= 0) continue;
+				cp--;
+				close(ibuf[0]);
+				if(i < eargc) {
+					if((f = setfil(i++)) == 0)
+						ibuf[0] = 0;
+					else if(fopen(f, ibuf) < 0)
+						cant(f);
+				} else
+					break;
+			}
+			if(c < 0) {
+				done++;
+				lp--;
+				break;
+			}
+		}
+		qsort(lspace, lp-lspace, 2, cmp);
+		if(done == 0 || nfiles != eargc)
+			newfile(); else
+			oldfile();
+		while(lp > lspace) {
+			cp = *--lp;
+			if(*cp)
+				do
+				putc(*cp, obuf);
+				while(*cp++ != '\n');
+		}
+		fflush(obuf);
+		close(obuf[0]);
+	} while(done == 0);
+}
+
+struct merg
+{
+	char	l[L];
+	int	b[259];
+};
+
+merge(a, b)
+{
+	register struct merg *p;
+	register char *cp;
+	register i;
+	struct { int *ip;};
+	int f;
+	int j;
+	int	k,l,c;
+
+	p = lspace;
+	j = 0;
+	for(i=a; i<b; i++) {
+		f = setfil(i);
+		if(f == 0)
+			p->b[0] = dup(0);
+		else if(fopen(f, p->b) < 0)
+			cant(f);
+		ibuf[j] = p;
+		if(!rline(p)) j++;
+		p++;
+	}
+
+	do {
+		i = j;
+		qsort(ibuf, i, 2, cmp);
+		l = 0;
+		while(i--) {
+			cp = ibuf[i];
+			if(*cp == '\0') {
+				l = 1;
+				if(rline(ibuf[i])) {
+					k = i;
+					while(++k < j)
+						ibuf[k-1] = ibuf[k];
+					j--;
+				}
+			}
+		}
+	} while(l);
+
+	i = j;
+	if(i > 0) for(;;) {
+		cp = ibuf[i-1];
+		if(i == 1 || cmp(&ibuf[i-1], &ibuf[i-2]))
+			do
+				putc(*cp, obuf);
+			while(*cp++ != '\n');
+		if(rline(ibuf[i-1])) {
+			i--;
+			if(i == 0)
+				break;
+		}
+		cp = &ibuf[i];
+		while (--cp.ip > ibuf && cmp(cp.ip, cp.ip-1) < 0) {
+			p = *cp.ip;
+			*cp.ip = *(cp.ip-1);
+			*(cp.ip-1) = p;
+		}
+	}
+	p = lspace;
+	for(i=a; i<b; i++) {
+		close(p->b[0]);
+		p++;
+		if(i >= eargc)
+			close(creat(setfil(i)));
+	}
+	fflush(obuf);
+	close(obuf[0]);
+}
+
+rline(mp)
+struct merg *mp;
+{
+	register char *cp;
+	register *bp, c;
+
+	bp = mp->b;
+	cp = mp->l;
+	do {
+		c = getc(bp);
+		if(c < 0)
+			return(1);
+		*cp++ = c;
+	} while(c != '\n');
+	*cp = '\0';
+	return(0);
+}
+
+newfile()
+{
+
+	if(fcreat(setfil(nfiles), obuf) < 0) {
+		mess("Can't create temp\n");
+		term();
+	}
+	nfiles++;
+}
+
+char *
+setfil(i)
+{
+
+	if(i < eargc)
+		if(eargv[i][0] == '-' && eargv[i][1] == '\0')
+			return(0);
+		else
+			return(eargv[i]);
+	i =- eargc;
+	filep[0] = i/26 + 'a';
+	filep[1] = i%26 + 'a';
+	return(file);
+}
+
+oldfile()
+{
+
+	if(outfil) {
+		if(fcreat(outfil, obuf) < 0) {
+			mess("Can't create output\n");
+			term();
+		}
+	} else
+		obuf[0] = 1;
+}
+
+cant(f)
+{
+	mess("Can't open ");
+	mess(f);
+	mess("\n");
+	term();
+}
+
+term()
+{
+	register i;
+
+	if(nfiles == eargc)
+		nfiles++;
+	for(i=eargc; i<nfiles; i++) {
+		unlink(setfil(i));
+	}
+	exit(error);
+}
+
+cmp(a, b)
+int	*a,*b;
+{
+	register char	*ra, *rb;
+
+	ra = *a - 1;
+	rb = *b - 1;
+
+	while(*++ra == *++rb)
+		if(*ra == '\n')
+			return(0);
+
+	return(*rb - *ra);
+}
+
+
+skip(pp, fp, j)
+struct field *fp;
+char *pp;
+{
+	register i;
+	register char *p;
+
+	p = pp;
+	if( (i=fp->m[j]) < 0)
+		return(-1);
+	while(i-- > 0) {
+		if(tabchar != 0) {
+			while(*p != tabchar)
+				if(*p != '\n')
+					p++;
+				else goto ret;
+			p++;
+		} else {
+			while(blank(*p))
+				p++;
+			while(!blank(*p))
+				if(*p != '\n')
+					p++;
+				else goto ret;
+		}
+	}
+	if(fp->bflg)
+		while(blank(*p))
+			p++;
+	i = fp->n[j];
+	while(i-- > 0) {
+		if(*p != '\n')
+			p++;
+		else goto ret;
+	} 
+ret:
+	return(p);
+}
+
+digit(c)
+{
+
+	return(c <= '9' && c >= '0');
+}
+
+mess(s)
+char *s;
+{
+	while(*s)
+		write(2, s++, 1);
+}
+
+copyproto()
+{
+	register int i, *p, *q;
+
+	p = proto;
+	q = &fields[nfields];
+	for(i=0; i<sizeof(proto)/2; i++)
+		*q++ = *p++;
+}
+
+field(s,k)
+char *s;
+{
+	register struct field *p;
+	p = &fields[nfields];
+	for(; *s!=0; s++) {
+		switch(*s) {
+		case '\0':
+			return;
+
+		case 'a':
+			p->code = nofold;
+			break;
+
+		case 'b':
+			p->bflg++;
+			break;
+
+		case 'd':
+			p->ignore = dict;
+			break;
+
+		case 'n':
+			p->nflg++;
+			break;
+		case 't':
+			tabchar = *++s;
+			if(tabchar == 0) s--;
+			break;
+
+		case 'r':
+			p->rflg = -1;
+			break;
+
+		default:
+			p->m[k] = number(&s);
+			if(*s == '.')
+				s++;
+			p->n[k] = number(&s);
+			s--;
+		}
+	}
+}
+
+number(ppa)
+char **ppa;
+{
+	int n;
+	register char *pa;
+	pa = *ppa;
+	n = 0;
+	while(digit(*pa))
+		n = n*10 + *pa++ - '0';
+	*ppa = pa;
+	return(n);
+}
+
+blank(c)
+{
+	if(c==' ' || c=='\t')
+		return(1);
+	return(0);
+}
+
+int	(*qscmp)();
+int	qses;
+
+qsort(a, n, es, fc)
+char *a;
+int n, es;
+int (*fc)();
+{
+	qscmp = fc;
+	qses = es;
+	qs1(a, a+n*es);
+}
+
+qs1(a, l)
+char *a, *l;
+{
+	register char *i, *j, *es;
+	char **k;
+	char *lp, *hp;
+	int n, c;
+
+
+	es = qses;
+
+start:
+	if((n=l-a) <= es)
+		return;
+
+
+	n = ((n/(2*es))*es) & 077777;
+	hp = lp = a+n;
+	i = a;
+	j = l-es;
+
+
+	for(;;) {
+		if(i < lp) {
+			if((c = (*qscmp)(i, lp)) == 0) {
+				qsexc(i, lp =- es);
+				continue;
+			}
+			if(c < 0) {
+				i =+ es;
+				continue;
+			}
+		}
+
+loop:
+		if(j > hp) {
+			if((c = (*qscmp)(hp, j)) == 0) {
+				qsexc(hp =+ es, j);
+				goto loop;
+			}
+			if(c > 0) {
+				if(i == lp) {
+					qstexc(i, hp =+ es, j);
+					i = lp =+ es;
+					goto loop;
+				}
+				qsexc(i, j);
+				j =- es;
+				i =+ es;
+				continue;
+			}
+			j =- es;
+			goto loop;
+		}
+
+
+		if(i == lp) {
+			for(k=lp+2; k<=hp;) *(*k++)='\0';
+			if(lp-a >= l-hp) {
+				qs1(hp+es, l);
+				l = lp;
+			} else {
+				qs1(a, lp);
+				a = hp+es;
+			}
+			goto start;
+		}
+
+
+		qstexc(j, lp =- es, i);
+		j = hp =- es;
+	}
+}
+
+qsexc(i, j)
+char *i, *j;
+{
+	register char *ri, *rj, c;
+	int n;
+
+	n = qses;
+	ri = i;
+	rj = j;
+	do {
+		c = *ri;
+		*ri++ = *rj;
+		*rj++ = c;
+	} while(--n);
+}
+
+qstexc(i, j, k)
+char *i, *j, *k;
+{
+	register char *ri, *rj, *rk;
+	char	c;
+	int	n;
+
+	n = qses;
+	ri = i;
+	rj = j;
+	rk = k;
+	do {
+		c = *ri;
+		*ri++ = *rk;
+		*rk++ = *rj;
+		*rj++ = c;
+	} while(--n);
+}

source/s2/wall.c

@@ -0,0 +1,68 @@
+char	mesg[3000];
+int	msize;
+struct
+{
+	char	name[8];
+	char	tty[2];
+	int	time[2];
+	int	junk;
+} utmp[50];
+
+main(argc, argv)
+char *argv[];
+{
+	register i, *p;
+	int f;
+
+	f = open("/etc/utmp", 0);
+	if(f < 0) {
+		printf("utmp?\n");
+		exit();
+	}
+	read(f, utmp, sizeof utmp);
+	close(f);
+	f = 0;
+	if(argc >= 2) {
+		f = open(argv[1], 0);
+		if(f < 0) {
+			printf("%s?\n", argv[1]);
+			exit();
+		}
+	}
+	while((i = read(f, &mesg[msize], sizeof mesg - msize)) > 0)
+		msize =+ i;
+	close(f);
+	for(i=0; i<sizeof utmp/sizeof utmp[0]; i++) {
+		p = &utmp[i];
+		if(p->tty[0] == 0)
+			continue;
+		sleep(1);
+		sendmes(p->tty[0]);
+	}
+}
+
+sendmes(tty)
+{
+	register i;
+	register char *s;
+
+	i = fork();
+	if(i == -1) {
+		printf("try again\n");
+		return;
+	}
+	if(i)
+		return;
+	s = "/dev/ttyx";
+	s[8] = tty;
+	i = open(s, 1);
+	if(i < 0) {
+		printf("cannot open tty%c\n", tty);
+		exit();
+	}
+	close(1);
+	dup(i);
+	printf("Broadcast Message ...\n\n");
+	write(1, mesg, msize);
+	exit();
+}

source/s2/wc.c

@@ -0,0 +1,73 @@
+/* wc line and word count */
+
+int	buf[259];
+int wordct[2];
+int twordct[2];
+int linect[2];
+int tlinect[2];
+
+main(argc,argv)
+char **argv;
+{
+	int i, token;
+	register char *p1, *p2;
+	register int c;
+
+	i = 1;
+	do {
+		if(argc<=1) buf[0] = 0;
+		else if(fopen(argv[i],buf)<0) {
+			diag(argv[i]);
+			diag(": cannot open\n");
+			continue;
+		}
+		p1 = 0;
+		p2 = 0;
+		linect[0] = linect[1] = 0;
+		wordct[0] = wordct[1] = 0;
+		token = 0;
+		for(;;) {
+			if(p1 >= p2) {
+				p1 = &buf[1];
+				c = read(buf[0], p1, 512);
+				if(c <= 0)
+					break;
+				p2 = p1+c;
+			}
+			c = 0;
+			c =| *p1++;
+			if(' '<c&&c<0177) {
+				if(!token++) {
+					if(++wordct[1]==0)
+						wordct[0]++;
+				}
+			} else {
+				if(c=='\n') {
+					if(++linect[1]==0)
+						linect[0]++;
+				}
+				else if(c!=' '&&c!='\t')
+					continue;
+				token = 0;
+			}
+		}
+		printf("%7s ",locv(linect[0],linect[1]));
+		printf("%7s ",locv(wordct[0],wordct[1]));
+		printf("%s\n", argc<=1?"":argv[i]);
+		close(buf[0]);
+		ladd(tlinect, tlinect, linect);
+		ladd(twordct, twordct, wordct);
+	} while(++i<argc);
+	if(argc > 2) {
+		printf("%7s ",locv(tlinect[0],tlinect[1]));
+		printf("%7s ",locv(twordct[0],twordct[1]));
+		printf("total\n");
+	}
+}
+
+diag(s)
+char *s;
+{
+	while(*s)
+		write(2,s++,1);
+}

source/s2/who.c

@@ -0,0 +1,68 @@
+/*
+ * who
+ */
+
+int	fout;
+int	buf[256];
+
+main(argc, argv)
+char **argv;
+{
+	char *s, *cbuf;
+	int n, fi, i;
+	int tty;
+	struct {
+		char name[8];
+		char tty;
+		char pad1;
+		int time[2];
+		char pad2[2];
+	} *p;
+
+	s = "/etc/utmp";
+	if(argc == 2)
+		s = argv[1];
+	fi = open(s, 0);
+	if(fi < 0) {
+		write("cannot open wtmp\n", 17);
+		exit();
+	}
+	fout = dup(1);
+	close(1);
+	if (argc==3)
+		tty = ttyn(0);
+
+loop:
+	n = read(fi, buf, 512);
+	if(n == 0) {
+		flush();
+		if (argc==3)
+			write(fout, "Nobody.\n", 8);
+		exit();
+	}
+
+	p = &buf;
+	for(p = &buf; (n =- 16)>=0; p++) {
+		if (argc==3 && tty!=p->tty)
+			continue;
+		if(p->name[0] == '\0' && argc==1)
+			continue;
+		for(i=0; i<8; i++) {
+			if(p->name[i] == '\0')
+				p->name[i] = ' ';
+			putchar(p->name[i]);
+		}
+		for(i=0; i<3; i++)
+			putchar("tty"[i]);
+		putchar(p->tty);
+		cbuf = ctime(p->time);
+		for(i=3; i<16; i++)
+			putchar(cbuf[i]);
+		putchar('\n');
+		if (argc==3) {
+			flush();
+			exit();
+		}
+	}
+	goto loop;
+}

source/s2/write.s

@@ -0,0 +1,204 @@
+/ write -- write to another user
+
+.globl	ttyn
+
+	cmp	(sp)+,$2
+	beq	1f
+	bgt	2f
+	mov	$1,r0
+	sys	write; argm; eargm-argm
+	sys	exit
+2:
+	movb	*4(sp),ltty
+1:
+	tst	(sp)+
+	mov	(sp)+,r5
+	sys	open; utmp; 0
+	bec	1f
+	mov	$1,r0
+	sys	write; film; efilm-film
+	sys	exit
+1:
+	mov	r0,ufil
+1:
+	mov	ufil,r0
+	sys	read; ubuf; 16.
+	tst	r0
+	bne	2f
+	jmp	8f
+2:
+	tstb	ltty
+	beq	2f
+	cmpb	ltty,8.+ubuf
+	bne	1b
+2:
+	mov	$ubuf,r3
+	mov	r5,r4
+	mov	$9.,r2
+2:
+	dec	r2
+	beq	2f
+	cmpb	(r4)+,(r3)+
+	beq	2b
+	tstb	-1(r4)
+	bne	1b
+	cmpb	$' ,-1(r3)
+	bne	1b
+2:
+	movb	8.+ubuf,ttyno
+	sys	open; ttyx; 1
+	bes	3f
+	sys	stat; ttyx; statbuf
+	bes	3f
+	bit	$2,statbuf+4
+	bne	2f
+3:
+	mov	$1,r0
+	sys	write; dnymes; ednymes-dnymes
+	sys	exit
+2:
+	mov	r0,ttyf
+	clr	r0
+	jsr	pc,ttyn
+	mov	r0,r3
+	mov	statbuf,r4
+	mov	ufil,r0
+	sys	seek; 0; 0
+1:
+	mov	ufil,r0
+	sys	read; ubuf; 16.
+	tst	r0
+	beq	unknown
+	cmp	r3,ubuf+8.
+	bne	1b
+	mov	$ubuf,r0
+	mov	$8.,r1
+1:
+	cmpb	$' ,(r0)+
+	beq	1f
+	dec	r1
+	bne	1b
+1:
+	neg	r1
+	add	$8,r1
+	mov	r1,0f
+6:
+	mov	ttyf,r0
+	sys	write; mesg; emesg-mesg
+	mov	ttyf,r0
+	sys	0; 5f
+.data
+5:
+	sys	write; ubuf; 0:2
+.text
+	mov	ttyf,r0
+	sys	write; qnl; 4
+	sys	signal; 2; 9f
+7:
+	clr	r0
+	sys	read; ch; 1
+	tst	r0
+	beq	9f
+	tst	nlflg
+	beq	1f
+	cmp	ch,$'!
+	bne	1f
+	sys	fork
+		br mshproc
+	sys	wait
+	mov	$1,r0
+	sys	write; excl; 2
+	br	7b
+1:
+	clr	nlflg
+	cmp	ch,$'\n
+	bne	1f
+	inc	nlflg
+1:
+	mov	ttyf,r0
+	sys	write; ch; 1
+	br	7b
+8:
+	movb	(r5)+,ch
+	beq	8f
+	mov	$1,r0
+	sys	write; ch; 1
+	br	8b
+8:
+	tstb	ltty
+	beq	8f
+	mov	$1,r0
+	sys	write; ltty-1; 2
+8:
+	mov	$1,r0
+	sys	write; errmsg; eerrmsg-errmsg
+	sys	exit
+9:
+	mov	ttyf,r0
+	sys	write; endmsg; eendmsg-endmsg
+	sys	exit
+
+unknown:
+	mov	$"??,ubuf
+	br	6b
+
+mshproc:
+	sys	exec; msh; mshp
+	sys	exit
+
+.data
+nlflg:
+	1
+.text
+
+mshp:
+	msh
+	minust
+	0
+msh:
+	</bin/sh\0>
+minust:
+	<-t\0>
+argm:
+	<Arg count\n>
+eargm:
+film:
+	<Cannot open utmp\n>
+efilm:
+.data
+	< >		/ is ltty -1
+ltty:
+	.=.+1
+.text
+excl:
+	<!\n>
+qnl:
+	<...\n>
+.data
+ttyx:
+	</dev/ttyx\0>
+ttyno	= .-2
+.text
+utmp:
+	</etc/utmp\0>
+endmsg:
+	<EOT\n>
+eendmsg:
+errmsg:
+	< not logged in.\n>
+eerrmsg:
+mesg:
+	<\nMessage from >
+emesg:
+dnymes:
+	<Permission denied.\n>
+ednymes:
+	.even
+	.bss
+
+ttyf:	.=.+2
+ubuf:	.=.+16.
+statbuf:.=.+40.
+ch:	.=.+2
+ufil:	.=.+2
+signal = 48.