🚀 go-pugleaf

: '!/bin/sh     '
: 'This is a shell archive, meaning:            '
: '1. Remove everything above the #!/bin/sh line.       '
: '2. Save the resulting text in a file.                '
: '3. Execute the file with /bin/sh (not csh) to create the files:      '
: '      Makefile       '
: '      bold.c         '
: '      c.c            '
: '      c.c1           '
: '      c.c10          '
: '      c.c11          '
: '      c.c12          '
: '      c.c2           '
: '      c.c20          '
: '      c.c21          '
: '      c.c22          '
: '      c.c23          '
: '      c.c3           '
: '      c.c30          '
: '      c.c31          '
: '      c.c4           '
: '      dk.c           '
: '      dk.c1          '
: '      dk.c2          '
: '      dk.c3          '
: '      dk.c4          '
: '      dk.c5          '
: '      dk.c6          '
: '      dk.c7          '
: '      dk.c8          '
: '      dk.c99         '
: '      pr.c           '
: '      pr.c1          '
: '      pr.c2          '
: '      pr.c3          '
: '      pr.c4          '
: '      pr.c5          '
: '      pr.c6          '
: '      pr.c7          '
: '      pr.c8          '
: '      pr.c9          '
: '      prog.c         '
: '      tabbold.c      '
: '      dk.h           '
: '      pr.h           '
: 'This archive created: Tue Jan 29 10:07:35 1985       '
export PATH; PATH=/bin:$PATH
echo shar: extracting "'Makefile'" '(428 characters)'
if test -f 'Makefile'
then
	echo shar: over-writing existing file "'Makefile'"
fi
cat << \SHAR_EOF > 'Makefile'
#	driver paper
#	ats 10/84

page = 1-
spool = cat >/dev/tty1

all:	d

d:
	soelim d.ms \
	| prog \
	| nroff -Tbold -rL70 -o$(page) -ms - \
	| bs \
	| $(spool)

bold:	bold.c
	cc -o $@ $?
prog:	prog.c
	cc -o $@ $?
tabbold:	/usr/lib/term/tabbold
/usr/lib/term/tabbold:	tabbold.c
	cc -c $?
	strip tabbold.o
	cp tabbold.o $@
	rm tabbold.o

driver:
	cc -c -m -DKERNEL c.c dk.c pr.c
nodes:
	/etc/mknod pr0 c 25 0
	/etc/mknod pr1 c 25 1
SHAR_EOF
if test 428 -ne "`wc -c 'Makefile'`"
then
	echo shar: error transmitting "'Makefile'" '(should have been 428 characters)'
fi
echo shar: extracting "'bold.c'" '(1292 characters)'
if test -f 'bold.c'
then
	echo shar: over-writing existing file "'bold.c'"
fi
cat << \SHAR_EOF > 'bold.c'
/*
 *	bold -- convert text between SO and SI to boldface
 *	ats 10/84
 */

#include <stdio.h>

#define	USAGE	fputs("usage: bold [-#] [file]...\n", stderr), exit(1)

#define	NORMAL	1		/* states */
#define	BOLD	2

#define	SO	016		/* shift-out to boldface */
#define	SI	017		/* shift-in to normal */

main(argc, argv)
	int argc;
	char ** argv;
{	int repeat = 2;

	while (--argc && **++argv == '-')
		switch (*++*argv) {
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			repeat = **argv - '0';
			continue;
		default:
			USAGE;
		}

	if (argc)
		do
			if (freopen(*argv, "r", stdin))
				bold(repeat);
			else
				perror(*argv), exit(1);
		while (++argv, --argc);
	else
		bold(repeat);
}

bold(repeat)
	register int repeat;
{	register int ch, state = NORMAL;
	register int i;

	while ((ch = getchar()) != EOF)
	{	switch (state) {
		case NORMAL:
			switch (ch) {
			case SO:
				state = BOLD;
			case SI:
				continue;
			}
			break;
		case BOLD:
			switch (ch) {
			case SI:
				state = NORMAL;
			case SO:
				continue;
			default:
				for (i = 0; i < repeat; ++ i)
				{	putchar(ch);
					putchar('\b');
				}
			case ' ':
			case '\n':
			case '\t':
			case '\f':
			case '\b':
			case '\r':
				break;
			}
		}
		putchar(ch);
	}
}
SHAR_EOF
if test 1292 -ne "`wc -c 'bold.c'`"
then
	echo shar: error transmitting "'bold.c'" '(should have been 1292 characters)'
fi
echo shar: extracting "'c.c'" '(7345 characters)'
if test -f 'c.c'
then
	echo shar: over-writing existing file "'c.c'"
fi
cat << \SHAR_EOF > 'c.c'
/* from "standard input" */

#include "sys/local.h"
#include "sys/param.h"
#include "sys/systm.h"
#include "sys/buf.h"
#include "sys/tty.h"
#include "sys/conf.h"
#include "sys/proc.h"
#include "sys/text.h"
#include "sys/file.h"
#include "sys/inode.h"
#include "sys/acct.h"
#include "sys/dskmap.h"
#include "sys/ccb.h"

int   nodev(), nulldev();
int	mtopen(), mtclose(), mtstrategy();
struct buf      mtab;
int	msmstrategy();
struct buf      msmtab;

#include "c.c3"
#include "c.c4"
#include "c.c1"

struct bdevsw bdevsw[] = {
	nodev, nodev, nodev, 0, 0,	/* dsk = 0 */
	mtopen, mtclose, mtstrategy, &mtab, BD_NORMAL,	/* mt = 1 */
	nulldev, nulldev, msmstrategy, &msmtab, BD_NORMAL,	/* msm = 2 */
	nodev, nodev, nodev, 0, 0,	/* d40 = 3 */
	nodev, nodev, nodev, 0, 0,	/* mta = 4 */
	nodev, nodev, nodev, 0, 0,	/* mtb = 5 */
	nodev, nodev, nodev, 0, 0,	/* ud1 = 6 */
	nodev, nodev, nodev, 0, 0,	/* mm = 7 */
#include "c.c2"
	0
};

int	vduopen(), vduclose(), vduread(), vduwrite(), vduioctl(), vdustop();
struct tty      vdu[10];
int	mmread(), mmwrite();
int	syopen(), syread(), sywrite(), sysioctl();
int	mtopen(), mtclose(), mtread(), mtwrite(), mtioctl();
int	lpopen(), lpclose(), lpwrite(), lpioctl();
int	msmread(), msmwrite();

#include "c.c10"

struct cdevsw cdevsw[] = {
	vduopen, vduclose, vduread, vduwrite, vduioctl, vdustop, vdu,	/* vdu = 0 */
	nulldev, nulldev, mmread, mmwrite, nodev, nulldev, 0,	/* mem = 1 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* dsk = 2 */
	syopen, nulldev, syread, sywrite, sysioctl, nulldev, 0,	/* tty = 3 */
	mtopen, mtclose, mtread, mtwrite, mtioctl, nulldev, 0,	/* mt = 4 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* cli = 5 */
	lpopen, lpclose, nodev, lpwrite, lpioctl, nulldev, 0,	/* lp = 6 */
	nulldev, nulldev, msmread, msmwrite, nodev, nulldev, 0,	/* msm = 7 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* dsa = 8 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* mx = 9 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* d40 = 10 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* mta = 11 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* mtb = 12 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* ud1 = 13 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* sin = 14 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* meg = 15 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* ptc = 16 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* pts = 17 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* up = 18 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* uu = 19 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* ud = 20 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* li = 21 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* dio = 22 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* lpa = 23 */
	nodev, nodev, nodev, nodev, nodev, nodev, 0,	/* lpb = 24 */
#include "c.c11"
	0
};

int	ttyopen(), ttread(), ttwrite(), ttyinput(), ttyrend(), ttstart();

struct linesw linesw[] = {
	ttyopen, nulldev, ttread, ttwrite, nodev,
		ttyinput, ttyrend, nulldev, ttstart, nulldev,	/* tty = 0 */
	0
};

int  nldisp = 1;
int	mpxchan();
int	(*ldmpx)() = mpxchan;
dev_t	rootdev = makedev(2, 0);
dev_t	swapdev = makedev(2, 7);
dev_t	pipedev = makedev(2, 1);
dev_t	consdev = makedev(0, 0);
daddr_t	swplo	= 25104;
int	nswap	= 10000;
caddr_t	memtop	= 4194304;
caddr_t	totmem	= 4194304;

int	mtdump();
int	(*dumpsw)() = mtdump;

int	timezone = 300;
int	daylight = 1;
struct	buf	bfreelist;
struct	acct	acctbuf;
struct	inode	*acctp;
char	serialnum[32] = "3210/8413987";
char	license[32] = "ed7-033-wb-16 pr";
short	nvdu = 8;
short	vduaddr[] = {
	0x010, 0x012, 0x020, 0x022, 0x024, 0x026, 0x028, 0x02A,
};
struct ccb *vduccb = &ccb[0];
short	vdudios[] = {
	0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000, 0x000,
};
char	vdurate[][4] = {
	B150, B600, B4800, B9600,
	B300, B1200, B7200, B19200,
	B150, B600, B4800, B9600,
	B150, B600, B4800, B9600,
	B150, B600, B4800, B9600,
	B150, B600, B4800, B9600,
	B150, B600, B4800, B9600,
	B150, B600, B4800, B9600,
};
short	nmt = 1;
short	mtaddr[] = {
	0x0C5,
};
short	mtselch[] = {
	0x0F0,
};
short	lpaddr[] = {
	0x062,
};
short	nmsm = 2;
short	msmaddr[] = {
	0x0FC, 0x0FC,
};
short	msmcntl[] = {
	0x0FB, 0x0FB,
};
short	msmselch[] = {
	0x0F0, 0x0F0,
};
char	msmtype[] = {
	5, 2,
};
char	msmspindle[] = {
	1, 1,
};
char	msmmap[] = {
	1, 0,
};
int	msmlayout[][16] = {
{
	       0,	   25000,
	       0,	       0,
	       0,	       0,
	       0,	       0,
	       0,	       0,
	       0,	       0,
	       0,	       0,
	       0,	   26304,
},

{
	       0,	   25000,
	   35104,	   17504,
	   52608,	   26304,
	   78912,	   26304,
	  105216,	   26304,
	       0,	       0,
	       0,	       0,
	       0,	  131520,
},

};
short	clockaddr[] = {
	0x06C,
};
int	mmmap[] = {
	       0,	       0,
	       0,	       0,
	       0,	       0,
	       0,	       0,
	       0,	       0,
	       0,	       0,
	       0,	       0,
	       0,	       0,
};

short	diosaddr[] = {
	
};

struct	locklist locklist[NFLOCKS];

char	devmap[] = {
 /*   0 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  10 */  0,  0,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
#include "c.c20"
 /*  30 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  40 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  50 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  60 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  70 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  80 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  90 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  A0 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
#include "c.c30"
 /*  D0 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  E0 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  F0 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,
};

char	devint[] = {
 /*   0 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  10 */  8, 12,  8, 12,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
#include "c.c21"
 /*  30 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  40 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  50 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  60 */  0,  0, 20,  0,  0,  0,  0,  0,  0,  0,  0,  0, 32,  0,  0,  0,
 /*  70 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  80 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  90 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  A0 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
#include "c.c31"
 /*  D0 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  E0 */  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 /*  F0 */  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 28, 24,  0,  0,  0,
};
int	spurint(), selchint(), vdurint(), vduxint(), mtintr(), lpint();
int	msmintr(), msmcintr(), clock();

#include "c.c22"
int	(*handler[])() = {
	spurint,
	selchint,
	vdurint,
	vduxint,
	mtintr,
	lpint,
	msmintr,
	msmcintr,
	clock,
#include "c.c23"
};

#include "c.c12"

SHAR_EOF
if test 7345 -ne "`wc -c 'c.c'`"
then
	echo shar: error transmitting "'c.c'" '(should have been 7345 characters)'
fi
echo shar: extracting "'c.c1'" '(42 characters)'
if test -f 'c.c1'
then
	echo shar: over-writing existing file "'c.c1'"
fi
cat << \SHAR_EOF > 'c.c1'
int	dkstrategy();		/* transfer routine */
SHAR_EOF
if test 42 -ne "`wc -c 'c.c1'`"
then
	echo shar: error transmitting "'c.c1'" '(should have been 42 characters)'
fi
echo shar: extracting "'c.c10'" '(243 characters)'
if test -f 'c.c10'
then
	echo shar: over-writing existing file "'c.c10'"
fi
cat << \SHAR_EOF > 'c.c10'
int	propen(),	/* connect routine */
	prwrite(),	/* output transfer routine */
	prclose(),	/* disconnect routine */
	prioctl();	/* control routine */

int	dkread(),	/* raw input transfer routine */
	dkwrite();	/* raw output transfer routine */
SHAR_EOF
if test 243 -ne "`wc -c 'c.c10'`"
then
	echo shar: error transmitting "'c.c10'" '(should have been 243 characters)'
fi
echo shar: extracting "'c.c11'" '(189 characters)'
if test -f 'c.c11'
then
	echo shar: over-writing existing file "'c.c11'"
fi
cat << \SHAR_EOF > 'c.c11'
propen, prclose, nodev,  prwrite, prioctl, nulldev,0,/*pr:25*/
nulldev, nulldev, dkread, dkwrite, nodev, nulldev,0,/*dk0:26*/
nulldev, nulldev, dkread, dkwrite, nodev, nulldev,0,/*dk1:27*/
SHAR_EOF
if test 189 -ne "`wc -c 'c.c11'`"
then
	echo shar: error transmitting "'c.c11'" '(should have been 189 characters)'
fi
echo shar: extracting "'c.c12'" '(218 characters)'
if test -f 'c.c12'
then
	echo shar: over-writing existing file "'c.c12'"
fi
cat << \SHAR_EOF > 'c.c12'
#include "pr.h"

struct prparm prparm[] = {	/* printers */
	{ 0x2D, 0xEE },	/* pr0: hi clk, 7bit, 2stop, even */
	{ 0x2F, 0xEE },	/* pr0: hi clk, 7bit, 2stop, even */
	};

int prnum = sizeof prparm / sizeof prparm[0];
SHAR_EOF
if test 218 -ne "`wc -c 'c.c12'`"
then
	echo shar: error transmitting "'c.c12'" '(should have been 218 characters)'
fi
echo shar: extracting "'c.c2'" '(154 characters)'
if test -f 'c.c2'
then
	echo shar: over-writing existing file "'c.c2'"
fi
cat << \SHAR_EOF > 'c.c2'
nulldev, nulldev, dkstrategy, & dkparm[0].dk_tab,
	BD_NORMAL,			/* dk0: 8 */
nulldev, nulldev, dkstrategy, & dkparm[1].dk_tab,
	BD_NORMAL,			/* dk1: 9 */
SHAR_EOF
if test 154 -ne "`wc -c 'c.c2'`"
then
	echo shar: error transmitting "'c.c2'" '(should have been 154 characters)'
fi
echo shar: extracting "'c.c20'" '(79 characters)'
if test -f 'c.c20'
then
	echo shar: over-writing existing file "'c.c20'"
fi
cat << \SHAR_EOF > 'c.c20'
 /*  20 */  2,  2,  3,  3,  4,  4,  5,  5,
	    6,  6,  7,  7,  0,  0,  0,  1,
SHAR_EOF
if test 79 -ne "`wc -c 'c.c20'`"
then
	echo shar: error transmitting "'c.c20'" '(should have been 79 characters)'
fi
echo shar: extracting "'c.c21'" '(79 characters)'
if test -f 'c.c21'
then
	echo shar: over-writing existing file "'c.c21'"
fi
cat << \SHAR_EOF > 'c.c21'
 /*  20 */  8, 12,  8, 12,  8, 12,  8, 12,
	    8, 12,  8, 12,  0, 44,  0, 44,
SHAR_EOF
if test 79 -ne "`wc -c 'c.c21'`"
then
	echo shar: error transmitting "'c.c21'" '(should have been 79 characters)'
fi
echo shar: extracting "'c.c22'" '(113 characters)'
if test -f 'c.c22'
then
	echo shar: over-writing existing file "'c.c22'"
fi
cat << \SHAR_EOF > 'c.c22'
int	dkint();	/* drive interrupt */
int	dkcint();	/* controller interrupt */
int	print();	/* printer interrupt */
SHAR_EOF
if test 113 -ne "`wc -c 'c.c22'`"
then
	echo shar: error transmitting "'c.c22'" '(should have been 113 characters)'
fi
echo shar: extracting "'c.c23'" '(42 characters)'
if test -f 'c.c23'
then
	echo shar: over-writing existing file "'c.c23'"
fi
cat << \SHAR_EOF > 'c.c23'
	dkint,		/* offset 36 */
	dkcint,
	print,
SHAR_EOF
if test 42 -ne "`wc -c 'c.c23'`"
then
	echo shar: error transmitting "'c.c23'" '(should have been 42 characters)'
fi
echo shar: extracting "'c.c3'" '(389 characters)'
if test -f 'c.c3'
then
	echo shar: over-writing existing file "'c.c3'"
fi
cat << \SHAR_EOF > 'c.c3'
#include "dk.h"

int	dkseek(),	/* start transfer cycle */
	dkscint();	/* SELCH has completed */

struct dkparm dkparm[] = {	/* controllers */
	{			/* first */
		2,		/* two drives */
		{ 0xC6, 0xC7 },
		0xB6, 0xF0,
		{ dkseek, dkscint }
	},
	{			/* second */
		2,		/* two drives */
		{ 0xC8, 0xC9 },
		0xB8, 0xF0,
		{ dkseek, dkscint }
	}
	};

int dknum = sizeof dkparm / sizeof dkparm[0];
SHAR_EOF
if test 389 -ne "`wc -c 'c.c3'`"
then
	echo shar: error transmitting "'c.c3'" '(should have been 389 characters)'
fi
echo shar: extracting "'c.c30'" '(158 characters)'
if test -f 'c.c30'
then
	echo shar: over-writing existing file "'c.c30'"
fi
cat << \SHAR_EOF > 'c.c30'
 /*  B0 */  0,  0,  0,  0,  0,  0,  0,  0,
	   32,  0,  0,  0,  0,  0,  0,  0,
 /*  C0 */  0,  0,  0,  0,  0,  0,  0,  4,
	   32, 36,  0,  0,  0,  0,  0,  0,
SHAR_EOF
if test 158 -ne "`wc -c 'c.c30'`"
then
	echo shar: error transmitting "'c.c30'" '(should have been 158 characters)'
fi
echo shar: extracting "'c.c31'" '(158 characters)'
if test -f 'c.c31'
then
	echo shar: over-writing existing file "'c.c31'"
fi
cat << \SHAR_EOF > 'c.c31'
 /*  B0 */  0,  0,  0,  0,  0,  0, 40,  0,
	   40,  0,  0,  0,  0,  0,  0,  0,
 /*  C0 */  0,  0,  0,  0,  0, 16, 36, 36,
	   36, 36,  0,  0,  0,  0,  0,  0,
SHAR_EOF
if test 158 -ne "`wc -c 'c.c31'`"
then
	echo shar: error transmitting "'c.c31'" '(should have been 158 characters)'
fi
echo shar: extracting "'c.c4'" '(204 characters)'
if test -f 'c.c4'
then
	echo shar: over-writing existing file "'c.c4'"
fi
cat << \SHAR_EOF > 'c.c4'
struct dkmap dkmap[] = {	/* slice definition */
	       0,	9792,	/* (minor&3) == 0 */
	       0,	3264,	/*              1 */
	    3264,	6528,	/*              2 */
	    6528,	3264,	/*              3 */
	};
SHAR_EOF
if test 204 -ne "`wc -c 'c.c4'`"
then
	echo shar: error transmitting "'c.c4'" '(should have been 204 characters)'
fi
echo shar: extracting "'dk.c'" '(154 characters)'
if test -f 'dk.c'
then
	echo shar: over-writing existing file "'dk.c'"
fi
cat << \SHAR_EOF > 'dk.c'
#include "dk.c1"
#include "dk.c2"
#include "dk.c3"
#include "dk.c4"
#include "dk.c5"
#include "dk.c6"
#include "dk.c7"
#include "dk.c8"
#include "dk.c99"
SHAR_EOF
if test 154 -ne "`wc -c 'dk.c'`"
then
	echo shar: error transmitting "'dk.c'" '(should have been 154 characters)'
fi
echo shar: extracting "'dk.c1'" '(438 characters)'
if test -f 'dk.c1'
then
	echo shar: over-writing existing file "'dk.c1'"
fi
cat << \SHAR_EOF > 'dk.c1'
/*
 *	dk -- primitive disk driver skeleton
 *	ats 10/84
 */

#include <sys/local.h>
#include <sys/param.h>
#include <sys/buf.h>
#include <sys/conf.h>
#include "dk.h"		/* dk driver header */

/*
 *	tunable parameters
 */

#define	NERR	5	/* maximum number of retries */

/*
 *	staging sequence (in dk->dk_tab.b_active)
 */

#define	WSEEK	1	/* waiting to complete SEEK */
#define	WIO	2	/* waiting to complete i/o */

/*
 *	hardware bits
 */
SHAR_EOF
if test 438 -ne "`wc -c 'dk.c1'`"
then
	echo shar: error transmitting "'dk.c1'" '(should have been 438 characters)'
fi
echo shar: extracting "'dk.c2'" '(205 characters)'
if test -f 'dk.c2'
then
	echo shar: over-writing existing file "'dk.c2'"
fi
cat << \SHAR_EOF > 'dk.c2'
/*
 *	start
 *		get the SELCH
 *		through its queue, dkseek is called
 */

static start(dk)
	register struct dkparm * dk;
{
	if (dk->dk_tab.b_actf)
		selchreq(dk->dk_selch, & dk->dk_queue,
			(int) dk);
}
SHAR_EOF
if test 205 -ne "`wc -c 'dk.c2'`"
then
	echo shar: error transmitting "'dk.c2'" '(should have been 205 characters)'
fi
echo shar: extracting "'dk.c3'" '(453 characters)'
if test -f 'dk.c3'
then
	echo shar: over-writing existing file "'dk.c3'"
fi
cat << \SHAR_EOF > 'dk.c3'
/*
 *	error
 *		report, retry, get upset
 */

static error(dk, stat, addr)
	register struct dkparm * dk;
	register int stat;
	register int addr;
{	register struct buf * bp = dk->dk_tab.b_actf;

	deverror(bp, stat, addr);
	if (++ dk->dk_tab.b_errcnt <= NERR)
		dkseek(dk);
	else
	{	dk->dk_tab.b_errcnt = 0;
		dk->dk_tab.b_active = 0;
		dk->dk_tab.b_actf = bp->av_forw;
		bp->b_flags |= B_ERROR;
		iodone(bp);
		selchfree(dk->dk_selch);
		start(dk);
	}
}
SHAR_EOF
if test 453 -ne "`wc -c 'dk.c3'`"
then
	echo shar: error transmitting "'dk.c3'" '(should have been 453 characters)'
fi
echo shar: extracting "'dk.c4'" '(931 characters)'
if test -f 'dk.c4'
then
	echo shar: over-writing existing file "'dk.c4'"
fi
cat << \SHAR_EOF > 'dk.c4'
/*
 *	strategy
 *		queue request
 */

dkstrategy(bp)
	register struct buf * bp;
{	register int cntrl = minor(bp->b_dev) >> 5 & 7;
	register struct dkparm * dk = dkparm + cntrl;
	register int drive = minor(bp->b_dev) >> 2 & 7;
	register int slice = minor(bp->b_dev) & 3;

#ifdef	ASSERT
	if (sizeof(int) < sizeof(struct dkparm *))
		panic("bad dk cast");
#endif	ASSERT
	if (cntrl >= dknum
	    || drive >= dkparm[cntrl].dk_n)
	{	bp->b_flags |= B_ERROR;
		bp->b_resid = bp->b_bcount;
		iodone(bp);
	}
	else if (bp->b_blkno + (bp->b_bcount >> 9)
			> dkmap[slice].dk_size)
	{	if ((bp->b_flags&(B_PHYS|B_READ))
				!= (B_PHYS|B_READ))
			bp->b_flags |= B_ERROR;
		bp->b_resid = bp->b_bcount;
		iodone(bp);
	}
	else
	{	bp->av_forw = 0;
		spl5();
			if (dk->dk_tab.b_actf)
				dk->dk_tab.b_actl->av_forw =
					bp;
			else
				dk->dk_tab.b_actf = bp;
			dk->dk_tab.b_actl = bp;
			if (! dk->dk_tab.b_active)
				start(dk);
		spl0();
	}
}
SHAR_EOF
if test 931 -ne "`wc -c 'dk.c4'`"
then
	echo shar: error transmitting "'dk.c4'" '(should have been 931 characters)'
fi
echo shar: extracting "'dk.c5'" '(450 characters)'
if test -f 'dk.c5'
then
	echo shar: over-writing existing file "'dk.c5'"
fi
cat << \SHAR_EOF > 'dk.c5'
/*
 *	dkseek
 *		called from the SELCH queue
 *		map logical block number
 *		start seek
 */

dkseek(dk)
	register struct dkparm * dk;
{	register struct buf * bp;

	if (! (bp = dk->dk_tab.b_actf))
	{	selchfree(dk->dk_tab.dk_selch);
		return;
	}
	dk->dk_tab.b_active = WSEEK;
	/*
	 *	map bp->b_blkno
	 *	(512-byte logical block number in slice)
	 *	as directed by dkmap[minor(bp->b_dev) & 3]
	 *	start seeking
	 *	must come back with interrupt
	 */
}
SHAR_EOF
if test 450 -ne "`wc -c 'dk.c5'`"
then
	echo shar: error transmitting "'dk.c5'" '(should have been 450 characters)'
fi
echo shar: extracting "'dk.c6'" '(710 characters)'
if test -f 'dk.c6'
then
	echo shar: over-writing existing file "'dk.c6'"
fi
cat << \SHAR_EOF > 'dk.c6'
/*
 *	drive interrupt
 *		happens once seek is done
 *		check status
 *		map blkno as directed by slice map
 *		start read/write
 */

dkint(dev, stat)
	register int dev;
	register int stat;
{	register struct dkparm * dk = dkparm + (dev >> 5 & 7);
	register struct buf * bp;

	if (! (bp = dk->dk_tab.b_actf)
	    || dk->dk_tab.b_active != WSEEK)
		return;
	dk->dk_tab.b_active = WIO;
	/*
	 *	if something went wrong...
	 */
	{	error(dk, stat, dk->dk_tab.dk_addr[dev & 3]);
		return;
	}
	if (bp->b_flags & B_READ)
	{
	/*
	 *	setup drive and SELCH commands
	 *	to read
	 */
	}
	else
	{
	/*
	 *	to write
	 */
	}
	/*
	 *	map the logical block number,
	 *	get SELCH and drive going for i/o
	 *	must interrupt
	 */
}
SHAR_EOF
if test 710 -ne "`wc -c 'dk.c6'`"
then
	echo shar: error transmitting "'dk.c6'" '(should have been 710 characters)'
fi
echo shar: extracting "'dk.c7'" '(256 characters)'
if test -f 'dk.c7'
then
	echo shar: over-writing existing file "'dk.c7'"
fi
cat << \SHAR_EOF > 'dk.c7'
/*
 *	selch interrupt
 *		happens once SELCH completes,
 *		called from SELCH queue
 *		usually controller interrupt follows
 */

dkscint(dev, stat, dk)
	register int dev;
	register int stat;
	register struct dkparm * dk;
{
	/*
	 *	stop the SELCH??
	 */
}
SHAR_EOF
if test 256 -ne "`wc -c 'dk.c7'`"
then
	echo shar: error transmitting "'dk.c7'" '(should have been 256 characters)'
fi
echo shar: extracting "'dk.c8'" '(690 characters)'
if test -f 'dk.c8'
then
	echo shar: over-writing existing file "'dk.c8'"
fi
cat << \SHAR_EOF > 'dk.c8'
/*
 *	controller interrupt
 *		happens once i/o is done
 *		check status
 *		recycle
 */

dkcint(dev, stat)
	register int dev;
	register int stat;
{	register struct dkparm * dk = dkparm + (dev>>5 & 7);
	register struct buf * bp;

	if (! (bp = dk->dk_tab.b_actf)
	    || dk->dk_tab.b_active != WIO)
		return;
	/*
	 *	if something went wrong...
	 */
	{	error(dk, stat, dk->dk_cntrl);
		return;
	}
	/*
	 *	if (cylinder overflow)
	 *	{	may need to recycle to dkseek() to
	 *		take care of the next track/cylinder
	 *		return;
	 *	}
	 */
	bp->b_resid = 0;
	dk->dk_tab.b_errcnt = 0;
	dk->dk_tab.b_active = 0;
	dk->dk_tab.b_actf = bp->av_forw;
	iodone(bp);
	selchfree(dk->dk_selch);
	start(dk);
}
SHAR_EOF
if test 690 -ne "`wc -c 'dk.c8'`"
then
	echo shar: error transmitting "'dk.c8'" '(should have been 690 characters)'
fi
echo shar: extracting "'dk.c99'" '(170 characters)'
if test -f 'dk.c99'
then
	echo shar: over-writing existing file "'dk.c99'"
fi
cat << \SHAR_EOF > 'dk.c99'
static struct buf rdkbuf;

dkread(dev)
	int dev;
{
	physio(dkstrategy, & rdkbuf, dev, B_READ);
}

dkwrite(dev)
	int dev;
{
	physio(dkstrategy, & rdkbuf, dev, B_WRITE);
}
SHAR_EOF
if test 170 -ne "`wc -c 'dk.c99'`"
then
	echo shar: error transmitting "'dk.c99'" '(should have been 170 characters)'
fi
echo shar: extracting "'pr.c'" '(153 characters)'
if test -f 'pr.c'
then
	echo shar: over-writing existing file "'pr.c'"
fi
cat << \SHAR_EOF > 'pr.c'
#include "pr.c1"
#include "pr.c2"
#include "pr.c3"
#include "pr.c4"
#include "pr.c5"
#include "pr.c6"
#include "pr.c7"
#include "pr.c8"
#include "pr.c9"
SHAR_EOF
if test 153 -ne "`wc -c 'pr.c'`"
then
	echo shar: error transmitting "'pr.c'" '(should have been 153 characters)'
fi
echo shar: extracting "'pr.c1'" '(497 characters)'
if test -f 'pr.c1'
then
	echo shar: over-writing existing file "'pr.c1'"
fi
cat << \SHAR_EOF > 'pr.c1'
/*
 *	pr -- very primitive PASLA output driver
 *	ats 10/84
 */

#include <sys/local.h>
#include <sys/param.h>
#include <sys/dir.h>
#include <sys/user.h>
#include <sys/tty.h>
#include "pr.h"		/* pr driver header */

/*
 *	tunable parameters
 */

#define	PRI	75	/* wakeup priority */
#define	LOW	70	/* low water mark in queue */
#define	HIGH	150	/* high water mark */

/*
 *	hardware bits
 */

#define	ENA	0x40	/* enable interrupts */
#define	WRT	0x02	/* write */
#define	CMD1	0x01	/* command 1 */
SHAR_EOF
if test 497 -ne "`wc -c 'pr.c1'`"
then
	echo shar: error transmitting "'pr.c1'" '(should have been 497 characters)'
fi
echo shar: extracting "'pr.c2'" '(194 characters)'
if test -f 'pr.c2'
then
	echo shar: over-writing existing file "'pr.c2'"
fi
cat << \SHAR_EOF > 'pr.c2'
/*
 *	setup
 *		transmit (new) CMD2 to PASLA
 *		(re)enable interrupts
 */

static setup(pr)
	register struct prparm * pr;
{
	oc(pr->pr_addr, pr->pr_cmd2);
	oc(pr->pr_addr, ENA | WRT | CMD1);
}
SHAR_EOF
if test 194 -ne "`wc -c 'pr.c2'`"
then
	echo shar: error transmitting "'pr.c2'" '(should have been 194 characters)'
fi
echo shar: extracting "'pr.c3'" '(204 characters)'
if test -f 'pr.c3'
then
	echo shar: over-writing existing file "'pr.c3'"
fi
cat << \SHAR_EOF > 'pr.c3'
/*
 *	start
 *		dequeue and emit
 */

static start(pr)
	register struct prparm * pr;
{	register int i;

	while ((i = ss(pr->pr_addr)) == 0
	       && (i = getc(&pr->pr_que)) >= 0)
		wd(pr->pr_addr, i);
}
SHAR_EOF
if test 204 -ne "`wc -c 'pr.c3'`"
then
	echo shar: error transmitting "'pr.c3'" '(should have been 204 characters)'
fi
echo shar: extracting "'pr.c4'" '(265 characters)'
if test -f 'pr.c4'
then
	echo shar: over-writing existing file "'pr.c4'"
fi
cat << \SHAR_EOF > 'pr.c4'
/*
 *	queue
 *		queue character
 */

static queue(pr, ch)
	register struct prparm * pr;
	register int ch;
{
	spl4();
		while(pr->pr_que.c_cc >= HIGH)
		{	pr->pr_sleep = 1;
			sleep(pr, PRI);
			pr->pr_sleep = 0;
		}
		putc(ch, &pr->pr_que);
		start(pr);
	spl0();
}
SHAR_EOF
if test 265 -ne "`wc -c 'pr.c4'`"
then
	echo shar: error transmitting "'pr.c4'" '(should have been 265 characters)'
fi
echo shar: extracting "'pr.c5'" '(310 characters)'
if test -f 'pr.c5'
then
	echo shar: over-writing existing file "'pr.c5'"
fi
cat << \SHAR_EOF > 'pr.c5'
/*
 *	open
 *		ensure exclusive access
 *		enable interrupts
 */

propen(dev, flag)
	register int dev;
	register int flag;
{	register struct prparm * pr = prparm + minor(dev);

	if (minor(dev) >= prnum)
		u.u_error = ENXIO;
	else if (pr->pr_open)
		u.u_error = EIO;
	else
	{	pr->pr_open = 1;
		setup(pr);
	}
}
SHAR_EOF
if test 310 -ne "`wc -c 'pr.c5'`"
then
	echo shar: error transmitting "'pr.c5'" '(should have been 310 characters)'
fi
echo shar: extracting "'pr.c6'" '(178 characters)'
if test -f 'pr.c6'
then
	echo shar: over-writing existing file "'pr.c6'"
fi
cat << \SHAR_EOF > 'pr.c6'
/*
 *	close
 *		release exclusive access
 */

prclose(dev, flag)
	register int dev;
	register int flag;
{	register struct prparm * pr = prparm + minor(dev);

	pr->pr_open = 0;
}
SHAR_EOF
if test 178 -ne "`wc -c 'pr.c6'`"
then
	echo shar: error transmitting "'pr.c6'" '(should have been 178 characters)'
fi
echo shar: extracting "'pr.c7'" '(488 characters)'
if test -f 'pr.c7'
then
	echo shar: over-writing existing file "'pr.c7'"
fi
cat << \SHAR_EOF > 'pr.c7'
/*
 *	write
 *		queue/sleep cycle
 */

prwrite(dev)
	register int dev;
{	register struct prparm * pr = prparm + minor(dev);
	register int ch;
	static int col = 0;

	while ((ch = cpass()) >= 0)
		switch (ch) {
		case '\n':
			queue(pr, '\r'), col = 0;
			queue(pr, ch);
			break;
		case '\t':
			do
				queue(pr, ' ');
			while (++ col & 7);
			break;
		case '\b':
			if (col)
				queue(pr, ch), -- col;
			break;
		default:
			if (ch >= ' ' && ch <= '~')
				queue(pr, ch), ++ col;
		}
}
SHAR_EOF
if test 488 -ne "`wc -c 'pr.c7'`"
then
	echo shar: error transmitting "'pr.c7'" '(should have been 488 characters)'
fi
echo shar: extracting "'pr.c8'" '(209 characters)'
if test -f 'pr.c8'
then
	echo shar: over-writing existing file "'pr.c8'"
fi
cat << \SHAR_EOF > 'pr.c8'
/*
 *	interrupt
 */

print(dev, stat)
	register int dev;
	register int stat;
{	register struct prparm * pr = prparm + minor(dev);

	start(pr);
	if (pr->pr_que.c_cc <= LOW
	    && pr->pr_sleep)
		wakeup(pr);
}
SHAR_EOF
if test 209 -ne "`wc -c 'pr.c8'`"
then
	echo shar: error transmitting "'pr.c8'" '(should have been 209 characters)'
fi
echo shar: extracting "'pr.c9'" '(628 characters)'
if test -f 'pr.c9'
then
	echo shar: over-writing existing file "'pr.c9'"
fi
cat << \SHAR_EOF > 'pr.c9'
/*
 *	control
 *		(version 7 system call only)
 */

prioctl(dev, cmd, addr, flag)
	register int dev;
	register int cmd;
	register caddr_t addr;
	register int flag;
{	register struct prparm * pr = prparm + minor(dev);
	struct ttiocb iocb;	/* parameter buffer */

        switch (cmd) {
	case TIOCSETP:
	case TIOCSETN:
		if (copyin(addr, (caddr_t) & iocb,
			sizeof iocb))
			u.u_error = EFAULT;
		else
			pr->pr_cmd2 = iocb.ioc_flags;
		setup(pr);
		break;
	case TIOCGETP:
		iocb.ioc_flags = pr->pr_cmd2;
		if (copyout((caddr_t) & iocb, addr,
			sizeof iocb))
			u.u_error = EFAULT;
		break;
	default:
		u.u_error = EINVAL;
	}
}
SHAR_EOF
if test 628 -ne "`wc -c 'pr.c9'`"
then
	echo shar: error transmitting "'pr.c9'" '(should have been 628 characters)'
fi
echo shar: extracting "'prog.c'" '(4411 characters)'
if test -f 'prog.c'
then
	echo shar: over-writing existing file "'prog.c'"
fi
cat << \SHAR_EOF > 'prog.c'
/*
 *	prog -- filter programming examples
 *	rev (UNIX the book) ats 12/83
 *	rev (Software I) ats 4/84
 *	rev (Compiler Construction) ats 9/84
 *	rev (Driver paper) ats 10/84
 */

/*
 *	Principles of Operation
 *
 *	lines are passed through; between ON and OFF they are processed:
 *	a lazy output routine corrects certain multi-character sequences.
 *
 *	output is tuned for nroff -mb, or (-a) for nroff -mba.
 */

#include <stdio.h>
#include <ctype.h>

char usage[] = "usage: prog [-a] [-c] [file...]\n";
int acomp = 0;			/* if set: acomp version */
int cflag = 0;			/* if set: 'on' */
char * filename;
int lineno;

#define	TOOLONG	fprintf(stderr, "%d (%s) too long\n", lineno, filename)
#define	USAGE	fputs(usage, stderr), exit(1)

#define	MLEN	62				/* width in examples */
#define	TMASK	7				/* defines tabstop */

#define	EMPTY	acomp? "\\(bsz": ".sp"		/* empty line */
#define	SPACE	acomp? "\\(bsL": " "		/* space */
/*#define	DOUBLE	acomp? "\\(bs": "\\*"	/* prefix for ++, etc. */
#define	DOT	acomp? "\\&.": "\\&."		/* . at begin of line */
#define	BEG	acomp? "\\(bsp": ""		/* begin line */
#define	END	acomp? "\\(bsP": ""		/* end line */

main(argc, argv)
	register int argc;
	register char ** argv;
{
	while (--argc && **++argv == '-')
		while (*++*argv)
			switch (**argv) {
			case 'a':
				acomp = 1;
				break;
			case 'c':
				cflag = 1;
				break;
			default:
				USAGE;
			}
	if (argc == 0)
		filename = "-", doprog();
	else
		do
			if (freopen(*argv, "r", stdin) == NULL)
				perror(*argv);
			else
				filename = *argv, doprog();
		while (++argv, --argc);
}

char * on(s)			/* returns OFF text or NULL */
	register char * s;	/* can be ON text */
{	register char ** p;
	static char * on [] ={
		".Be",
		".Gr",
		".DS",
		0
		};
	static char * off[] ={
		".Eb",
		".Eg",
		".DE",
		};

	for (p = on; *p; ++p)
		if (strncmp(*p, s, strlen(*p)) == 0)
			return off[p-on];
	return (char *) 0;
}

doprog()			/* process a file */
{	register char * off = (char *) 0;
	register int len;
	static char buf[BUFSIZ];

	for (lineno = 1; fgets(buf, sizeof buf, stdin); ++ lineno)
	switch ((int) off) {
				/* pass through regular text */
	case 0:
				/* unless -c was set */
		if (! cflag)
		{	fputs(buf, stdout);
			off = on(buf);
			continue;
		}
				/* process program examples */
	default:
				/* if [on] has been seen */
		if (cflag || strncmp(off, buf, strlen(off)))
				/* if -c or if not [off] */
		{	if (buf[0] == '.')
				/* . at begin of line merits attention */
				switch(buf[1]) {
					/* it may be part of an example */
				case ' ':
				case '\t':
				case '\n':
				case '.':
				case 0:
					fputs(DOT, stdout);
					line(buf+1);
					puts(END);
					continue;
				default:
					/* or it is a macro call */
					fputs(buf, stdout);
					continue;
				}
			switch (len = strlen(buf)) {
			case 1:
				/* turn blank line into macro call */
				puts(EMPTY);
				continue;
			default:
				/* process nonempty program line */
				fputs(BEG, stdout);
				line(buf);
				puts(END);
				continue;
			}
		}
				/* if not -c or if [off] */
		fputs(buf, stdout);
		off = on(buf);
	}
				/* shouldn't be [on] at end of file */
	if (off)		/* cannot be set under -c */
		fprintf(stderr, "prog: expecting %s\n", off), exit(1);
}

line(s)			/* process rest of a line */
	register char * s;
{	register char ch;
	register int col = 0;

	while (ch = *s++) switch (ch) {
	default:
		if (col == MLEN)
			TOOLONG;
		out(ch), ++col;
		continue;
	case '\t':
		fout();
		do
		{	if (col == MLEN)
				TOOLONG;
			out(' '), ++col;
		} while (col & TMASK);
		continue;
	case 0:
	case '\n':
		fout();
		return;
	}
}

/*
 *	special character expansion
 */

int prev = EOF;
int escaping = 0;

out(ch)
	register char ch;
{
	switch (escaping) {
	case 2:
	case 1:
		-- escaping;
		putchar(ch);
		return;
	case -1:
		putchar(ch);
		escaping = ch == '('? 2: 0;
		return;
	}

	switch (prev) {
	case EOF:
		return prev = ch;
	case '\\':
		putchar(prev);
		switch(ch) {
		default:
			putchar('e');
		case 'e':
			return prev = ch;
		case '*':
			escaping = -1;
			putchar(ch);
			return prev = EOF;
		}
	case ' ':
		fputs(SPACE, stdout);
		return prev = ch;
#ifdef	DOUBLE
	case '+':
	case '-':
	case '<':
	case '>':
	case '=':
		if (prev == ch)
		{	fputs(DOUBLE, stdout);
			putchar(ch);
			prev = EOF;
			return ch;
		}
#endif
	default:
		putchar(prev);
		return prev = ch;
	}
}

fout()
{
	out(0);
	prev = EOF;
	escaping = 0;
}
SHAR_EOF
if test 4411 -ne "`wc -c 'prog.c'`"
then
	echo shar: error transmitting "'prog.c'" '(should have been 4411 characters)'
fi
echo shar: extracting "'tabbold.c'" '(5270 characters)'
if test -f 'tabbold.c'
then
	echo shar: over-writing existing file "'tabbold.c'"
fi
cat << \SHAR_EOF > 'tabbold.c'
/*
 *	nroff table for 'bold' lineprinter
 *	ats 10/84
 */

#define INCH 240

struct {
	int bset;
	int breset;
	int Hor;
	int Vert;
	int Newline;
	int Char;
	int Em;
	int Halfline;
	int Adj;
	char *twinit;
	char *twrest;
	char *twnl;
	char *hlr;
	char *hlf;
	char *flr;
	char *bdon;
	char *bdoff;
	char *ploton;
	char *plotoff;
	char *up;
	char *down;
	char *right;
	char *left;
	char *codetab[256-32];
	int zzz;
	} t {
/*bset*/	0,
/*breset*/	0,
/*Hor*/		INCH/10,
/*Vert*/	INCH/6,
/*Newline*/	INCH/6,
/*Char*/	INCH/10,
/*Em*/		INCH/10,
/*Halfline*/	INCH/6,
/*Adj*/		INCH/10,
/*twinit*/	"",
/*twrest*/	"",
/*twnl*/	"\n",
/*hlr*/		"",
/*hlf*/		"",
/*flr*/		"",
/*bdon*/	"\16",
/*bdoff*/	"\17",
/*ploton*/	"",
/*plotoff*/	"",
/*up*/		"",
/*down*/	"",
/*right*/	"",
/*left*/	"",

"\001 ",	/*space*/
"\001!",	/*!*/
"\001\"",	/*"*/
"\001#",	/*#*/
"\001$",	/*$*/
"\001%",	/*%*/
"\001&",	/*&*/
"\001'",	/*' close*/
"\001(",	/*(*/
"\001)",	/*)*/
"\001*",	/***/
"\001+",	/*+*/
"\001,",	/*,*/
"\001-",	/*- hyphen*/
"\001.",	/*.*/
"\001/",	/*/*/
"\2010",	/*0*/
"\2011",	/*1*/
"\2012",	/*2*/
"\2013",	/*3*/
"\2014",	/*4*/
"\2015",	/*5*/
"\2016",	/*6*/
"\2017",	/*7*/
"\2018",	/*8*/
"\2019",	/*9*/
"\001:",	/*:*/
"\001;",	/*;*/
"\001<",	/*<*/
"\001=",	/*=*/
"\001>",	/*>*/
"\001?",	/*?*/
"\001@",	/*@*/
"\201A",	/*A*/
"\201B",	/*B*/
"\201C",	/*C*/
"\201D",	/*D*/
"\201E",	/*E*/
"\201F",	/*F*/
"\201G",	/*G*/
"\201H",	/*H*/
"\201I",	/*I*/
"\201J",	/*J*/
"\201K",	/*K*/
"\201L",	/*L*/
"\201M",	/*M*/
"\201N",	/*N*/
"\201O",	/*O*/
"\201P",	/*P*/
"\201Q",	/*Q*/
"\201R",	/*R*/
"\201S",	/*S*/
"\201T",	/*T*/
"\201U",	/*U*/
"\201V",	/*V*/
"\201W",	/*W*/
"\201X",	/*X*/
"\201Y",	/*Y*/
"\201Z",	/*Z*/
"\001[",	/*[*/
"\001\\",	/*\*/
"\001]",	/*]*/
"\001^",	/*^*/
"\001_",	/*_ dash*/
"\001`",	/*` open*/
"\201a",	/*a*/
"\201b",	/*b*/
"\201c",	/*c*/
"\201d",	/*d*/
"\201e",	/*e*/
"\201f",	/*f*/
"\201g",	/*g*/
"\201h",	/*h*/
"\201i",	/*i*/
"\201j",	/*j*/
"\201k",	/*k*/
"\201l",	/*l*/
"\201m",	/*m*/
"\201n",	/*n*/
"\201o",	/*o*/
"\201p",	/*p*/
"\201q",	/*q*/
"\201r",	/*r*/
"\201s",	/*s*/
"\201t",	/*t*/
"\201u",	/*u*/
"\201v",	/*v*/
"\201w",	/*w*/
"\201x",	/*x*/
"\201y",	/*y*/
"\201z",	/*z*/
"\001{",	/*{*/
"\001|",	/*|*/
"\001}",	/*}*/
"\001~",	/*~*/

"\000\0",	/*narrow sp*/
"\001-",	/*hyphen*/
"\001o\b+",	/*bullet*/
"\002[]",	/*square*/
"\002--",	/*3/4 em*/
"\001_",	/*rule*/
"\0031/4",	/*1/4*/
"\0031/2",	/*1/2*/
"\0033/4",	/*3/4*/
"\001-",	/*minus*/
"\202fi",	/*fi*/
"\202fl",	/*fl*/
"\202ff",	/*ff*/
"\203ffi",	/*ffi*/
"\203ffl",	/*ffl*/
"\001o",	/*degree*/
"\001-\b|",	/*dagger*/
"\001(\b)",	/*section*/
"\001'",	/*foot mark*/
"\001'",	/*acute accent*/
"\001`",	/*grave accent*/
"\001_",	/*underrule*/
"\001/",	/*slash (longer)*/
"\000\0",	/*half narrow space*/
"\001 ",	/*unpaddable space*/

"\005alpha",	/* alpha */
"\001p\b3",	/* beta */
"\005gamma",	/* gamma */
"\005delta",	/* delta */
"\007epsilon",	/* epsilon */
"\004zeta",	/* zeta */
"\003eta",	/* eta */
"\005theta",	/* theta */
"\004iota",	/* iota */
"\005kappa",	/* kappa */
"\006lambda",	/* lambda */
"\002mu",	/* mu */
"\002nu",	/* nu */
"\002xi",	/* xi */
"\007omicron",	/* omicron */
"\002pi",	/* pi */
"\003rho",	/* rho */
"\005sigma",	/* sigma */
"\003tau",	/* tau */
"\007upsilon",	/* upsilon */
"\003phi",	/* phi */
"\003chi",	/* chi */
"\003psi",	/* psi */
"\005omega",	/* omega */
"\005Gamma",	/* Gamma */
"\005Delta",	/* Delta */
"\005Theta",	/* Theta */
"\005Lambda",	/* Lambda */
"\002Xi",	/* Xi */
"\002Pi",	/* Pi */
"\005Sigma",	/* Sigma */
"\000\0",	/* \0 */
"\007Upsilon",	/* Upsilon */
"\003Phi",	/* Phi */
"\003Psi",	/* Psi */
"\005Omega",	/* Omega */

"\002\\/",	/*square root*/
"\005sigma",	/*terminal sigma*/
"\001~",	/*root en*/
"\001>\b_",	/*>=*/
"\001<\b_",	/*<=*/
"\001=\b_",	/*identically equal*/
"\001-",	/*equation minus*/	/* \(mi Minus */
"\001~\b=",	/*approx =*/
"\001~",	/*approximates*/
"\001=\b|",	/*not equal*/
"\002--\b>",	/*right arrow*/
"\002<\b--",	/*left arrow*/
"\001^\b|",	/*up arrow*/
"\001v\b|",	/*down arrow*/
"\001=",	/*equation equal*/
"\001*",	/*multiply*/
"\001/",	/*divide*/
"\001+\b_",	/*plus-minus*/
"\001U",	/*cup (union)*/
"\001()",	/*cap (intersection)*/
"\001C",	/*subset of*/
"\001)",	/*superset of*/
"\001C\b_",	/*improper subset*/
"\001)\b_",	/*improper superset*/
"\008infinity",	/*infinity*/
"\003del",	/*partial derivative*/
"\004grad",	/*gradient*/
"\001~",	/*not*/
"\008integral",	/*integral sign*/
"\001~",	/*proportional to*/
"\001O\b/",	/*empty set*/
"\001C\b-",	/*member of*/
"\001+",	/*equation plus*/
"\003(r)",	/*registered*/
"\003(c)",	/*copyright*/
"\001|",	/*box rule */
"\001c\b/",	/*cent sign*/
"\001|\b-\b_",	/*dbl dagger*/
"\002rh",	/*right hand*/
"\002lh",	/*left hand*/
"\001*",	/*math * */
"\006(Bell)",	/*bell system sign*/	/* acomp escape */
"\001|",	/*or (was star)*/
"\001O",	/*circle*/
"\001{",	/*left top (of big curly)*/
"\001{",	/*left bottom*/
"\001}",	/*right top*/
"\001}",	/*right bot*/
"\001{",	/*left center of big curly bracket*/
"\001}",	/*right center of big curly bracket*/
"\001|",	/*bold vertical*/
"\001[",	/*left ceiling (left top of big sq bract)*/
"\001[",	/*left floor (left bot of big sq bract)*/
"\001]",	/* right ceiling (right top of big sq bracket */
"\\001]",	/* right floor (right bot of big sq bracket */
};
SHAR_EOF
if test 5270 -ne "`wc -c 'tabbold.c'`"
then
	echo shar: error transmitting "'tabbold.c'" '(should have been 5270 characters)'
fi
echo shar: extracting "'dk.h'" '(654 characters)'
if test -f 'dk.h'
then
	echo shar: over-writing existing file "'dk.h'"
fi
cat << \SHAR_EOF > 'dk.h'
/*
 *	dk -- primitive disk driver skeleton -- header
 *	ats 10/84
 */

#include <sys/selch.h>		/* SELCH header */

extern struct dkparm {		/* parameters for dk */
	char dk_n;		/* number of drives */
	char dk_addr[4];	/* addresses of drives */
	char dk_cntrl;		/* ... of controller */
	char dk_selch;		/* ... of selch */
	struct selchq dk_queue;	/* to enqueue on selch */
	struct buf dk_tab;	/* for bdevsw */
	} dkparm[];		/* one per controller */

extern int dknum;		/* number of controllers */

extern struct dkmap {		/* logical map for dk */
	int dk_base;		/* origin of slice */
	int dk_size;		/* length in blocks */
	} dkmap[];		/* one map for all */
SHAR_EOF
if test 654 -ne "`wc -c 'dk.h'`"
then
	echo shar: error transmitting "'dk.h'" '(should have been 654 characters)'
fi
echo shar: extracting "'pr.h'" '(416 characters)'
if test -f 'pr.h'
then
	echo shar: over-writing existing file "'pr.h'"
fi
cat << \SHAR_EOF > 'pr.h'
/*
 *	pr -- very primitive PASLA output driver -- header
 *	ats 10/84
 */

extern struct prparm {		/* parameters for pr */
	char pr_addr;		/* device address */
	char pr_cmd2;		/* PASLA CMD2 */
	struct clist pr_que;	/* output queue */
	unsigned pr_open : 1;	/* set while opened */
	unsigned pr_sleep : 1;	/* set while asleep */
	} prparm[];		/* one element per printer */

extern int prnum;		/* number of printers */
SHAR_EOF
if test 416 -ne "`wc -c 'pr.h'`"
then
	echo shar: error transmitting "'pr.h'" '(should have been 416 characters)'
fi
: '     End of shell archive    '
exit 0
-- 

Carl Swail      Mail: National Research Council of Canada
		      Building U-66, Montreal Road
		      Ottawa, Ontario, Canada K1A 0R6
		Phone: (613) 998-3408
USENET:
{pesnta,lsuc}!nrcaero!carl
{cornell,uw-beaver}!utcsrgv!dciem!nrcaero!carl
{allegra,decvax,duke,floyd,ihnp4,linus}!utzoo!dciem!nrcaero!carl