[unix-history] / usr / src / old / vplot / vplot.c

#ifndef lint
static char sccsid[] = "@(#)vplot.c	4.3 (Berkeley) %G%";
#endif

/*
 *  Reads standard graphics input and produces a plot on the
 *  Varian or Versatec
 */
#include <stdio.h>
#include <signal.h>
#include <vfont.h>

#define LPR "/usr/ucb/lpr"

#define	mapx(x)	((DevRange*((x)-botx)/del)+centx)
#define	mapy(y)	((DevRange*(del-(y)+boty)/del)-centy)
#define SOLID -1
#define DOTTED 014
#define SHORTDASHED 034
#define DOTDASHED 054
#define LONGDASHED 074

char *Sid = "@(#)\t%G%";

int	linmod	= SOLID;
int	done1;
char	chrtab[][16];
char	*obuf;
int	bufsize;
int	lastx;
int	lasty;
int	radius, startx, starty, endx, endy;
double	topx;
double	topy;
double	botx;
double	boty;
int	centx = 0;
int	centy = 0;
double	delx;
double	dely;
double	del;

int	warned = 0;	/* Indicates whether the warning message about
			 * unimplemented routines has been printed */

FILE	*infile;
FILE	*pfp;			/* output file */
char	picture[] = "/usr/tmp/rastAXXXXXX";
int	run = 13;		/* index of 'a' in picture[] */
int	DevRange = 1536;	/* output array size (square) in pixels */
int	DevRange8 = 1536/8;	/* output array size in bytes */
int	BytesPerLine = 264;	/* Bytes per raster line (physical) */
int	lparg = 7;		/* index into lpargs */

char	*lpargs[50] = { "lpr", "-Pvarian", "-v", "-s", "-r", "-J", "vplot" };

/* variables for used to print from font file */
int	fontSet = 0;		/* Has the font file been read */
struct	header header;
struct	dispatch dispatch[256];
char	*bits;
char	*fontFile = "/usr/lib/vfont/R.6";

main(argc, argv)
int argc;
char **argv;
{
	extern int cleanup();
	register char *cp1, *arg;
	register i;
	int again;

	infile = stdin;
	while (argc > 1 && argv[1][0] == '-') {
		argc--;
		arg = *++argv;
		switch (*++arg) {
		case 'W':
			DevRange = 2048;
			DevRange8 = 2048/8;
			BytesPerLine = 880;
			lpargs[1] = "-Pversatec";
			break;
		case 'V':
			DevRange = 1536;
			DevRange8 = 1536/8;
			BytesPerLine = 264;
			lpargs[1] = "-Pvarian";
			break;
		case 'b':
			if (argc-- > 1)
				lpargs[lparg-1] = *++argv;
			break;
		default:
			fprintf(stderr, "vplot: %s option unknown\n", *argv);
			break;
		}
	}
	if (argc > 1) {
		if ((infile = fopen(*++argv, "r")) == NULL) {
			perror(*argv);
			cleanup();
		}
	}

	/* init constants for scaling */
	topx = topy = DevRange;
	botx = boty = 0;
	delx = dely = del = DevRange;
	centx = (DevRange - mapx(topx))/2;
	centy = mapy(topy)/2;
	signal(SIGTERM, cleanup);
	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
		signal(SIGINT, cleanup);
	mktemp(picture);
	if ((obuf = (char *) malloc(bufsize = DevRange * DevRange8)) == NULL) {
		fprintf(stderr, "vplot: ran out of memory\n");
		cleanup();
	}
	do {
		if ((pfp = fopen(picture, "w")) == NULL) {
			fprintf(stderr, "vplot: can't create %s\n", picture);
			cleanup();
		}
		i = strlen(picture) + 1;
		if ((arg = (char *) malloc(i)) == NULL) {
			fprintf(stderr, "ran out of memory\n");
			cleanup();
		}
		strcpy(arg, picture);
		lpargs[lparg++] = arg;
		picture[run]++;
		arg = &obuf[bufsize];
		for (cp1 = obuf; cp1 < arg; )
			*cp1++ = 0;

		again = getpict();

		for (cp1 = obuf; cp1 < arg; cp1 += DevRange8) {
			fwrite(cp1, sizeof(char), DevRange8, pfp);
			fseek(pfp, (long) BytesPerLine - DevRange8, 1);
		}
		fclose(pfp);
	} while (again);
	lpargs[lparg] = 0;
	execv(LPR, lpargs);
	fprintf(stderr, "can't exec %s\n", LPR);
	cleanup();
}

getpict()
{
	register x1, y1;

	for (;;) switch (x1 = getc(infile)) {

	case '\n':
		continue;

	case 's':
		botx = getinteger(infile);
		boty = getinteger(infile);
		topx = getinteger(infile);
		topy = getinteger(infile);
		delx = topx-botx;
		dely = topy-boty;
		if (dely/delx > 1536./2048.)
			del = dely;
		else
			del = delx;
		centx = 0;
		centx = (DevRange - mapx(topx))/2;
		centy = 0;
		centy = mapy(topy) / 2;
		continue;

	case 'b':
		x1 = getc(infile);
		continue;

	case 'l':
		done1 |= 01;
		x1 = mapx(getinteger(infile));
		y1 = mapy(getinteger(infile));
		lastx = mapx(getinteger(infile));
		lasty = mapy(getinteger(infile));
		line(x1, y1, lastx, lasty);
		continue;

	case 'c':
		x1 = mapx(getinteger(infile));
		y1 = mapy(getinteger(infile));
		radius = mapx(getinteger(infile));
		if (!warned) {
			fprintf(stderr,"Circles are Implemented\n");
			warned++;
		}
		circle(x1, y1, radius);
		continue;
		
	case 'a':
		x1 = mapx(getinteger(infile));
		y1 = mapy(getinteger(infile));
		startx = mapx(getinteger(infile));
		starty = mapy(getinteger(infile));
		endx = mapx(getinteger(infile));
		endy = mapy(getinteger(infile));
		if (!warned) {
			fprintf(stderr,"Circles and Arcs are unimplemented\n");
			warned++;
		}
		continue;

	case 'm':
		lastx = mapx(getinteger(infile));
		lasty = mapy(getinteger(infile));
		continue;

	case 't':
		lastx = lastx - 6;
		lasty = lasty + 6;
		done1 |= 01;
		while ((x1 = getc(infile)) != '\n')
			plotch(x1);
		continue;

	case 'e':
		if (done1)
			return(1);
		continue;

	case 'p':
		done1 |= 01;
		lastx = mapx(getinteger(infile));
		lasty = mapy(getinteger(infile));
		point(lastx, lasty);
		point(lastx+1, lasty);
		point(lastx, lasty+1);
		point(lastx+1, lasty+1);
		continue;

	case 'n':
		done1 |= 01;
		x1 = mapx(getinteger(infile));
		y1 = mapy(getinteger(infile));
		line(lastx, lasty, x1, y1);
		lastx = x1;
		lasty = y1;
		continue;

	case 'f':
		getinteger(infile);
		getc(infile);
		switch (getc(infile)) {
		case 't':
			linmod = DOTTED;
			break;
		default:
		case 'i':
			linmod = SOLID;
			break;
		case 'g':
			linmod = LONGDASHED;
			break;
		case 'r':
			linmod = SHORTDASHED;
			break;
		case 'd':
			linmod = DOTDASHED;
			break;
		}
		while ((x1 = getc(infile)) != '\n')
			if (x1 == EOF)
				return(0);
		continue;

	case 'd':
		getinteger(infile);
		getinteger(infile);
		getinteger(infile);
		x1 = getinteger(infile);
		while (--x1 >= 0)
			getinteger(infile);
		continue;

	case 0:		/* ignore null characters */
		continue;

	case 255:
	case EOF:
		return(0);

	default:
		fprintf(stderr, "Input format error %c(%o)\n",x1,x1);
		cleanup();
	}
}

plotch(ch)
char ch;
{
	register int i,j,k;
	register char *ptr,c;
	int nbytes;

	if (!fontSet)
		InitFont();	/* Read font if not already read */

	ptr = bits + dispatch[ch].addr;

	for (i = dispatch[ch].up; i > -dispatch[ch].down; --i) {
		nbytes = (dispatch[ch].right + dispatch[ch].left + 7)/8;
		for (j = 0; j < nbytes; j++) {
			c = *ptr++;
			for (k = 7; k >= 0; k--)
				if ((c >> k) & 1)
					point(lastx+7-k+j*8-dispatch[ch].left, lasty-i);
		}
	}
	if (ch != ' ')
		lastx += dispatch[ch].width;
	else
		lastx += dispatch['a'].width;
}

InitFont()
{
	char *s;
	int fonts;
	int i;

	fontSet = 1;
	/* Get the font file */
	s = fontFile;
	if ((fonts = open(s, 0)) == -1) {
		perror(s);
		fprintf(stderr, "Can't get font file");
		cleanup();
	}
	/* Get the header and check magic number */
	if (read(fonts, &header, sizeof(header)) != sizeof(header)) {
		perror(s);
		fprintf(stderr, "Bad read in font file");
		cleanup();
	}
	if (header.magic != 0436) {
		fprintf(stderr,"Bad magic numer in font file");
		cleanup();
	}
	/* Get dispatches */
	if (read(fonts, dispatch, sizeof(dispatch)) != sizeof(dispatch)) {
		perror(s);
		fprintf(stderr, "Bad read in font file");
		cleanup();
	}
	/* Allocate space for bit map and read in bits */
	bits = (char *) malloc(header.size);
	if (read(fonts, bits, header.size) != header.size) {
		perror(s);
		fprintf(stderr,"Can't read bit map in font file");
		cleanup();
	}
	/* Close font file */
	if (close(fonts) != 0) {
		perror(s);
		fprintf(stderr,"Can't close font file");
		cleanup();
	}
}

line(x0, y0, x1, y1)
register x0, y0;
{
	int dx, dy;
	int xinc, yinc;
	register res1;
	int res2;
	int slope;

	xinc = 1;
	yinc = 1;
	if ((dx = x1-x0) < 0) {
		xinc = -1;
		dx = -dx;
	}
	if ((dy = y1-y0) < 0) {
		yinc = -1;
		dy = -dy;
	}
	slope = xinc*yinc;
	res1 = 0;
	res2 = 0;
	if (dx >= dy) while (x0 != x1) {
		if ((x0+slope*y0) & linmod)
			point(x0, y0);
		if (res1 > res2) {
			res2 += dx - res1;
			res1 = 0;
			y0 += yinc;
		}
		res1 += dy;
		x0 += xinc;
	} else while (y0 != y1) {
		if ((x0+slope*y0) & linmod)
		point(x0, y0);
		if (res1 > res2) {
			res2 += dy - res1;
			res1 = 0;
			x0 += xinc;
		}
		res1 += dx;
		y0 += yinc;
	}
	if ((x1+slope*y1) & linmod)
		point(x1, y1);
}

#define labs(a) (a >= 0 ? a : -a)

circle(x,y,c)
{
	register dx, dy;
	long ep;
	int de;

	dx = 0;
	ep = 0;
	for (dy=c; dy>=dx; dy--) {
		for (;;) {
			point(x+dx, y+dy);
			point(x-dx, y+dy);
			point(x+dx, y-dy);
			point(x-dx, y-dy);
			point(x+dy, y+dx);
			point(x-dy, y+dx);
			point(x+dy, y-dx);
			point(x-dy, y-dx);
			ep += 2*dx + 1;
			de = -2*dy + 1;
			dx++;
			if (labs(ep) >= labs(ep+de)) {
				ep += de;
				break;
			}
		}
	}
}

/*
 * Points should be in the range 0 <= x (or y) <= DevRange.
 * The origin is the top left-hand corner with increasing x towards the
 * right and increasing y going down.
 */
point(x, y)
register int x, y;
{
	register unsigned byte;

	byte = y * DevRange8 + (x >> 3);
	if (byte < bufsize)
		obuf[byte] |= 1 << (7 - (x & 07));
}

cleanup()
{
	while (picture[run] != 'a') {
		unlink(picture);
		picture[run]--;
	}
	exit(1);
}

getinteger(f)
FILE *f;
{
	register int low, high, result;

	low = getc(f);
	high = getc(f);
	result = ((high << 8) | low);
	if (high > 127)
		result |= ~0xffff;
	return(result);
}
Commit	Line	Data
17d1455f SL	1	#ifndef lint
	2	static char sccsid[] = "@(#)vplot.c 4.3 (Berkeley) %G%";
	3	#endif
	4
	5	/*
e853d173 RC	6	* Reads standard graphics input and produces a plot on the
e853d173 RC	7	* Varian or Versatec
fddad162	8	*/
e853d173	9	#include <stdio.h>
fddad162	10	#include <signal.h>
e853d173 RC	11	#include <vfont.h>
	12
	13	#define LPR "/usr/ucb/lpr"
fddad162	14
e853d173 RC	15	#define mapx(x) ((DevRange*((x)-botx)/del)+centx)
e853d173 RC	16	#define mapy(y) ((DevRange*(del-(y)+boty)/del)-centy)
fddad162 RC	17	#define SOLID -1
	18	#define DOTTED 014
	19	#define SHORTDASHED 034
	20	#define DOTDASHED 054
	21	#define LONGDASHED 074
e853d173 RC	22
e853d173 RC	23	char *Sid = "@(#)\t%G%";
fddad162 RC	24
fddad162 RC	25	int linmod = SOLID;
fddad162 RC	26	int done1;
fddad162 RC	27	char chrtab[][16];
265c917a RC	28	char *obuf;
265c917a RC	29	int bufsize;
fddad162 RC	30	int lastx;
fddad162 RC	31	int lasty;
e853d173 RC	32	int radius, startx, starty, endx, endy;
	33	double topx;
	34	double topy;
	35	double botx;
	36	double boty;
	37	int centx = 0;
	38	int centy = 0;
	39	double delx;
	40	double dely;
	41	double del;
	42
	43	int warned = 0; /* Indicates whether the warning message about
	44	* unimplemented routines has been printed */
fddad162	45
e853d173	46	FILE *infile;
265c917a	47	FILE pfp; / output file */
e853d173 RC	48	char picture[] = "/usr/tmp/rastAXXXXXX";
	49	int run = 13; /* index of 'a' in picture[] */
	50	int DevRange = 1536; /* output array size (square) in pixels */
265c917a	51	int DevRange8 = 1536/8; /* output array size in bytes */
e853d173 RC	52	int BytesPerLine = 264; /* Bytes per raster line (physical) */
	53	int lparg = 7; /* index into lpargs */
	54
	55	char *lpargs[50] = { "lpr", "-Pvarian", "-v", "-s", "-r", "-J", "vplot" };
	56
	57	/* variables for used to print from font file */
	58	int fontSet = 0; /* Has the font file been read */
	59	struct header header;
	60	struct dispatch dispatch[256];
	61	char *bits;
	62	char *fontFile = "/usr/lib/vfont/R.6";
fddad162 RC	63
fddad162 RC	64	main(argc, argv)
e853d173	65	int argc;
fddad162 RC	66	char **argv;
fddad162 RC	67	{
e853d173	68	extern int cleanup();
265c917a RC	69	register char cp1, arg;
265c917a RC	70	register i;
e853d173	71	int again;
fddad162	72
e853d173 RC	73	infile = stdin;
	74	while (argc > 1 && argv[1][0] == '-') {
	75	argc--;
	76	arg = *++argv;
	77	switch (*++arg) {
	78	case 'W':
265c917a RC	79	DevRange = 2048;
265c917a RC	80	DevRange8 = 2048/8;
e853d173 RC	81	BytesPerLine = 880;
	82	lpargs[1] = "-Pversatec";
	83	break;
	84	case 'V':
	85	DevRange = 1536;
265c917a	86	DevRange8 = 1536/8;
e853d173 RC	87	BytesPerLine = 264;
	88	lpargs[1] = "-Pvarian";
	89	break;
	90	case 'b':
	91	if (argc-- > 1)
	92	lpargs[lparg-1] = *++argv;
	93	break;
	94	default:
	95	fprintf(stderr, "vplot: %s option unknown\n", *argv);
	96	break;
	97	}
fddad162	98	}
e853d173 RC	99	if (argc > 1) {
	100	if ((infile = fopen(*++argv, "r")) == NULL) {
	101	perror(*argv);
	102	cleanup();
fddad162	103	}
fddad162	104	}
e853d173 RC	105
	106	/* init constants for scaling */
	107	topx = topy = DevRange;
	108	botx = boty = 0;
	109	delx = dely = del = DevRange;
	110	centx = (DevRange - mapx(topx))/2;
	111	centy = mapy(topy)/2;
	112	signal(SIGTERM, cleanup);
	113	if (signal(SIGINT, SIG_IGN) != SIG_IGN)
	114	signal(SIGINT, cleanup);
	115	mktemp(picture);
265c917a RC	116	if ((obuf = (char ) malloc(bufsize = DevRange DevRange8)) == NULL) {
	117	fprintf(stderr, "vplot: ran out of memory\n");
	118	cleanup();
	119	}
e853d173	120	do {
265c917a RC	121	if ((pfp = fopen(picture, "w")) == NULL) {
265c917a RC	122	fprintf(stderr, "vplot: can't create %s\n", picture);
e853d173 RC	123	cleanup();
e853d173 RC	124	}
e853d173	125	i = strlen(picture) + 1;
265c917a	126	if ((arg = (char *) malloc(i)) == NULL) {
e853d173 RC	127	fprintf(stderr, "ran out of memory\n");
	128	cleanup();
	129	}
	130	strcpy(arg, picture);
	131	lpargs[lparg++] = arg;
	132	picture[run]++;
265c917a RC	133	arg = &obuf[bufsize];
	134	for (cp1 = obuf; cp1 < arg; )
	135	*cp1++ = 0;
e853d173 RC	136
	137	again = getpict();
	138
265c917a RC	139	for (cp1 = obuf; cp1 < arg; cp1 += DevRange8) {
	140	fwrite(cp1, sizeof(char), DevRange8, pfp);
	141	fseek(pfp, (long) BytesPerLine - DevRange8, 1);
e853d173	142	}
265c917a	143	fclose(pfp);
e853d173 RC	144	} while (again);
	145	lpargs[lparg] = 0;
	146	execv(LPR, lpargs);
	147	fprintf(stderr, "can't exec %s\n", LPR);
	148	cleanup();
fddad162 RC	149	}
	150
	151	getpict()
	152	{
	153	register x1, y1;
	154
e853d173 RC	155	for (;;) switch (x1 = getc(infile)) {
	156
	157	case '\n':
	158	continue;
fddad162 RC	159
fddad162 RC	160	case 's':
e853d173 RC	161	botx = getinteger(infile);
	162	boty = getinteger(infile);
	163	topx = getinteger(infile);
	164	topy = getinteger(infile);
fddad162 RC	165	delx = topx-botx;
	166	dely = topy-boty;
	167	if (dely/delx > 1536./2048.)
	168	del = dely;
	169	else
e853d173	170	del = delx;
fddad162	171	centx = 0;
e853d173	172	centx = (DevRange - mapx(topx))/2;
fddad162 RC	173	centy = 0;
	174	centy = mapy(topy) / 2;
	175	continue;
	176
e853d173 RC	177	case 'b':
	178	x1 = getc(infile);
	179	continue;
	180
fddad162 RC	181	case 'l':
fddad162 RC	182	done1 \|= 01;
e853d173 RC	183	x1 = mapx(getinteger(infile));
	184	y1 = mapy(getinteger(infile));
	185	lastx = mapx(getinteger(infile));
	186	lasty = mapy(getinteger(infile));
fddad162 RC	187	line(x1, y1, lastx, lasty);
	188	continue;
	189
e853d173 RC	190	case 'c':
	191	x1 = mapx(getinteger(infile));
	192	y1 = mapy(getinteger(infile));
	193	radius = mapx(getinteger(infile));
	194	if (!warned) {
	195	fprintf(stderr,"Circles are Implemented\n");
	196	warned++;
	197	}
	198	circle(x1, y1, radius);
	199	continue;
	200
	201	case 'a':
	202	x1 = mapx(getinteger(infile));
	203	y1 = mapy(getinteger(infile));
	204	startx = mapx(getinteger(infile));
	205	starty = mapy(getinteger(infile));
	206	endx = mapx(getinteger(infile));
	207	endy = mapy(getinteger(infile));
	208	if (!warned) {
	209	fprintf(stderr,"Circles and Arcs are unimplemented\n");
	210	warned++;
	211	}
	212	continue;
	213
fddad162	214	case 'm':
e853d173 RC	215	lastx = mapx(getinteger(infile));
e853d173 RC	216	lasty = mapy(getinteger(infile));
fddad162 RC	217	continue;
	218
	219	case 't':
e853d173 RC	220	lastx = lastx - 6;
e853d173 RC	221	lasty = lasty + 6;
fddad162	222	done1 \|= 01;
e853d173	223	while ((x1 = getc(infile)) != '\n')
fddad162 RC	224	plotch(x1);
	225	continue;
	226
	227	case 'e':
e853d173 RC	228	if (done1)
e853d173 RC	229	return(1);
fddad162 RC	230	continue;
	231
	232	case 'p':
	233	done1 \|= 01;
e853d173 RC	234	lastx = mapx(getinteger(infile));
e853d173 RC	235	lasty = mapy(getinteger(infile));
fddad162 RC	236	point(lastx, lasty);
	237	point(lastx+1, lasty);
	238	point(lastx, lasty+1);
	239	point(lastx+1, lasty+1);
	240	continue;
	241
	242	case 'n':
	243	done1 \|= 01;
e853d173 RC	244	x1 = mapx(getinteger(infile));
e853d173 RC	245	y1 = mapy(getinteger(infile));
fddad162 RC	246	line(lastx, lasty, x1, y1);
	247	lastx = x1;
	248	lasty = y1;
	249	continue;
	250
	251	case 'f':
e853d173 RC	252	getinteger(infile);
	253	getc(infile);
	254	switch (getc(infile)) {
fddad162 RC	255	case 't':
	256	linmod = DOTTED;
	257	break;
	258	default:
	259	case 'i':
	260	linmod = SOLID;
	261	break;
	262	case 'g':
	263	linmod = LONGDASHED;
	264	break;
	265	case 'r':
	266	linmod = SHORTDASHED;
	267	break;
	268	case 'd':
	269	linmod = DOTDASHED;
	270	break;
	271	}
e853d173 RC	272	while ((x1 = getc(infile)) != '\n')
	273	if (x1 == EOF)
	274	return(0);
fddad162 RC	275	continue;
	276
	277	case 'd':
e853d173 RC	278	getinteger(infile);
	279	getinteger(infile);
	280	getinteger(infile);
	281	x1 = getinteger(infile);
fddad162	282	while (--x1 >= 0)
e853d173	283	getinteger(infile);
fddad162 RC	284	continue;
fddad162 RC	285
e853d173 RC	286	case 0: /* ignore null characters */
	287	continue;
	288
	289	case 255:
	290	case EOF:
	291	return(0);
fddad162 RC	292
fddad162 RC	293	default:
e853d173 RC	294	fprintf(stderr, "Input format error %c(%o)\n",x1,x1);
e853d173 RC	295	cleanup();
fddad162 RC	296	}
	297	}
	298
e853d173 RC	299	plotch(ch)
e853d173 RC	300	char ch;
fddad162	301	{
e853d173 RC	302	register int i,j,k;
	303	register char *ptr,c;
	304	int nbytes;
fddad162	305
e853d173 RC	306	if (!fontSet)
	307	InitFont(); /* Read font if not already read */
	308
	309	ptr = bits + dispatch[ch].addr;
	310
	311	for (i = dispatch[ch].up; i > -dispatch[ch].down; --i) {
	312	nbytes = (dispatch[ch].right + dispatch[ch].left + 7)/8;
	313	for (j = 0; j < nbytes; j++) {
	314	c = *ptr++;
	315	for (k = 7; k >= 0; k--)
	316	if ((c >> k) & 1)
	317	point(lastx+7-k+j*8-dispatch[ch].left, lasty-i);
	318	}
fddad162	319	}
e853d173 RC	320	if (ch != ' ')
	321	lastx += dispatch[ch].width;
	322	else
	323	lastx += dispatch['a'].width;
fddad162 RC	324	}
fddad162 RC	325
e853d173	326	InitFont()
fddad162	327	{
e853d173 RC	328	char *s;
	329	int fonts;
	330	int i;
	331
	332	fontSet = 1;
	333	/* Get the font file */
	334	s = fontFile;
	335	if ((fonts = open(s, 0)) == -1) {
	336	perror(s);
	337	fprintf(stderr, "Can't get font file");
	338	cleanup();
fddad162	339	}
e853d173 RC	340	/* Get the header and check magic number */
	341	if (read(fonts, &header, sizeof(header)) != sizeof(header)) {
	342	perror(s);
	343	fprintf(stderr, "Bad read in font file");
	344	cleanup();
	345	}
	346	if (header.magic != 0436) {
	347	fprintf(stderr,"Bad magic numer in font file");
	348	cleanup();
	349	}
	350	/* Get dispatches */
	351	if (read(fonts, dispatch, sizeof(dispatch)) != sizeof(dispatch)) {
	352	perror(s);
	353	fprintf(stderr, "Bad read in font file");
	354	cleanup();
	355	}
	356	/* Allocate space for bit map and read in bits */
	357	bits = (char *) malloc(header.size);
	358	if (read(fonts, bits, header.size) != header.size) {
	359	perror(s);
	360	fprintf(stderr,"Can't read bit map in font file");
	361	cleanup();
	362	}
	363	/* Close font file */
	364	if (close(fonts) != 0) {
	365	perror(s);
	366	fprintf(stderr,"Can't close font file");
	367	cleanup();
fddad162 RC	368	}
	369	}
	370
	371	line(x0, y0, x1, y1)
	372	register x0, y0;
	373	{
	374	int dx, dy;
	375	int xinc, yinc;
	376	register res1;
	377	int res2;
	378	int slope;
	379
	380	xinc = 1;
	381	yinc = 1;
	382	if ((dx = x1-x0) < 0) {
	383	xinc = -1;
	384	dx = -dx;
	385	}
	386	if ((dy = y1-y0) < 0) {
	387	yinc = -1;
	388	dy = -dy;
	389	}
	390	slope = xinc*yinc;
	391	res1 = 0;
	392	res2 = 0;
	393	if (dx >= dy) while (x0 != x1) {
e853d173 RC	394	if ((x0+slope*y0) & linmod)
e853d173 RC	395	point(x0, y0);
fddad162 RC	396	if (res1 > res2) {
	397	res2 += dx - res1;
	398	res1 = 0;
	399	y0 += yinc;
	400	}
	401	res1 += dy;
	402	x0 += xinc;
	403	} else while (y0 != y1) {
e853d173	404	if ((x0+slope*y0) & linmod)
fddad162 RC	405	point(x0, y0);
	406	if (res1 > res2) {
	407	res2 += dy - res1;
	408	res1 = 0;
	409	x0 += xinc;
	410	}
	411	res1 += dx;
	412	y0 += yinc;
	413	}
e853d173	414	if ((x1+slope*y1) & linmod)
fddad162 RC	415	point(x1, y1);
	416	}
	417
e853d173 RC	418	#define labs(a) (a >= 0 ? a : -a)
	419
	420	circle(x,y,c)
	421	{
	422	register dx, dy;
	423	long ep;
	424	int de;
	425
	426	dx = 0;
	427	ep = 0;
	428	for (dy=c; dy>=dx; dy--) {
	429	for (;;) {
	430	point(x+dx, y+dy);
	431	point(x-dx, y+dy);
	432	point(x+dx, y-dy);
	433	point(x-dx, y-dy);
	434	point(x+dy, y+dx);
	435	point(x-dy, y+dx);
	436	point(x+dy, y-dx);
	437	point(x-dy, y-dx);
	438	ep += 2*dx + 1;
	439	de = -2*dy + 1;
	440	dx++;
	441	if (labs(ep) >= labs(ep+de)) {
	442	ep += de;
	443	break;
	444	}
	445	}
	446	}
	447	}
	448
	449	/*
	450	* Points should be in the range 0 <= x (or y) <= DevRange.
	451	* The origin is the top left-hand corner with increasing x towards the
	452	* right and increasing y going down.
	453	*/
fddad162	454	point(x, y)
e853d173	455	register int x, y;
fddad162	456	{
265c917a	457	register unsigned byte;
fddad162	458
265c917a RC	459	byte = y * DevRange8 + (x >> 3);
	460	if (byte < bufsize)
	461	obuf[byte] \|= 1 << (7 - (x & 07));
fddad162 RC	462	}
fddad162 RC	463
e853d173	464	cleanup()
fddad162	465	{
e853d173 RC	466	while (picture[run] != 'a') {
	467	unlink(picture);
	468	picture[run]--;
	469	}
fddad162 RC	470	exit(1);
	471	}
	472
e853d173 RC	473	getinteger(f)
	474	FILE *f;
	475	{
	476	register int low, high, result;
	477
	478	low = getc(f);
	479	high = getc(f);
	480	result = ((high << 8) \| low);
	481	if (high > 127)
	482	result \|= ~0xffff;
	483	return(result);
fddad162	484	}