Thread View: pe.cust.sources
1 messages
1 total messages
Started by Carl P. Swail
Thu, 21 Feb 1985 19:07
nroff source of driver paper - part 2 of 2
Author: Carl P. Swail
Date: Thu, 21 Feb 1985 19:07
Date: Thu, 21 Feb 1985 19:07
1925 lines
44918 bytes
44918 bytes
: '!/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
Thread Navigation
This is a paginated view of messages in the thread with full content displayed inline.
Messages are displayed in chronological order, with the original post highlighted in green.
Use pagination controls to navigate through all messages in large threads.
Back to All Threads