carl@nrcaero.UUCP (Carl P. Swail) (02/22/85)
: '!/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