[unix-history] / usr / src / old / vpr / vtools / fed / fed.c

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

/*
 *	Font editor for the HP 2648.
 *
 *	Mark Horton, 1/80
 */

#include "fed.h"

main(argc,argv)
int argc;
char **argv;
{

	signal(SIGINT, onintr);
	signal(SIGQUIT, onsig);
	signal(SIGILL, onsig);
	signal(SIGBUS, onsig);
	signal(SIGSEGV, onsig);
	signal(SIGSYS, onsig);

	while (argc > 1 && argv[1][0] == '-') {
		switch(argv[1][1]) {
		case 'T':
			trace = fopen("trace", "w");
			setbuf(trace, tracebuf);
			break;
		case 'i':
		case 'v':
			vidinv();
			break;
		case 'q':
			QUIET = 1;
			break;
		default:
			printf("Bad flag: %s\n", argv[1]);
		}
		argc--; argv++;
	}
	if (argc < 2) {
		fprintf(stderr,"Usage: %s filename\n", argv[0]);
		exit(1);
	}

	if (setjmp(env) == 0) {
		initialize();
		editfont(argv[1]);
	}

	cmdloop();
}

cmdloop()
{
	char cmd;

	setjmp(env);
	for (;;) {
		cmd = inchar();
		if (cmd == ESC)
			cmd = esccmd();
		switch (cmd) {

		/* ^L: redraw munged up screen */
		case '\14':
			redraw();
			break;

		/* b: move cursor to base point of window */
		case 'b':
			cch();
			curs_r = cht[curchar].rcent;
			curs_c = cht[curchar].ccent;
			turnoncurs();
			break;

		/* c: toggle whether cursor is on */
		case 'c':
			if (curcurs)
				turnofcurs();
			else
				turnoncurs();
			break;

		/* d: draw line of current flavor from pen to cursor */
		case 'd':
			cch();
			bufmod();
			drawline(pen_r, pen_c, curs_r, curs_c);
			turnofcurs();
			turnofrb();
			pen_r = curs_r; pen_c = curs_c;
			syncwind(curwind);
			break;

		/* f: fill in the current hole around the cursor */
		case 'f':
			cch();
			bufmod();
			if (trace)
				fprintf(trace, "fillin(%d, %d)\n", curs_r, curs_c);
			if (mat(wind[curwind].val, GLROW, GLCOL, curs_r, curs_c))
				error("Not in a hole");
			fillin(curs_r, curs_c);
			curoff();
			syncwind(curwind);
			break;

		/* g <x>: get glyph "x" as current. */
		case 'g':
			if (fontdes == NULL)
				error("No current font file");
			message("get glyph <char>");
			curchar = inchar();
			sprintf(msgbuf, "get glyph %s", rdchar(curchar));
			message(msgbuf);
			getglyph(curchar);
			break;

		/* h, left arrow: move cursor left */
		case 'h':
			cch();
			if (curs_c <= 0)
				error("Off edge");
			else
				curs_c--;
			turnoncurs();
			break;

		/* j, down arrow: move cursor down */
		case 'j':
			cch();
			if (curs_r >= GLROW-1)
				error("Off edge");
			else
				curs_r++;
			turnoncurs();
			break;

		/* k, up arrow: move cursor up */
		case 'k':
			cch();
			if (curs_r <= 0)
				error("Off edge");
			else
				curs_r--;
			turnoncurs();
			break;

		/* l, right arrow: move cursor down */
		case 'l':
			cch();
			if (curs_c >= GLCOL-1)
				error("Off edge");
			else
				curs_c++;
			turnoncurs();
			break;

		/* m: move the pen to where the cursor is */
		case 'm':
			cch();
			pen_r = curs_r; pen_c = curs_c;
			turnoncurs();
			move(base[curwind].c+curs_c, base[curwind].r+GLROW-1-curs_r);
			turnonrb();
			break;

		/* n <x>: make a new glyph with char x */
		case 'n':
			newglyph();
			break;

		/* p: print a hard copy on the printer of the screen */
		case 'p':
			printg();
			break;

		/* r: toggle rubber band line */
		case 'r':
			if (currb)
				turnofrb();
			else
				turnonrb();
			break;

		/* s <what> <where>: set <what> to <where> */
		case 's':
			setcmd();
			break;

		/* u: undo previous buffer modifying command */
		case 'u':
			cch();
			undo();
			break;

		/* z <n>: set zoom to n. */
		case 'z':
			message("zoom to <level>");
			curzoom = inchar();
			if (curzoom == '\r' || curzoom == '\n')
				curzoom = oldzoom;
			else {
				curzoom -= '0';
				oldzoom = curzoom;
			}
			zoomn(curzoom);
			break;

		/* space: reset zoom to last thing user asked for */
		case ' ':
			zoomn(curzoom = oldzoom);
			break;

		/* A: artificially embolden/italicize <range> by heavy pen size */
		case 'A':
			bufmod();
			artificial();
			break;

		/* B: move base point of window to cursor */
		case 'B':
			cch();
			cht[curchar].rcent = curs_r;
			cht[curchar].ccent = curs_c;
			turnoncurs();
			break;

		/*
		 * C <from> <to>: copy glyph <from> to <to>.
		 * M <from> <to>: move glyph <from> to <to>.
		 */
		case 'C':
		case 'M':
			copymove(cmd);
			break;

		/* D <char1> <char2>: delete range from font */
		case 'D':
			delchar();
			break;

		/* F: display the entire font on the screen. */
		case 'F':
			showfont();
			break;

		/* I: invert the current glyph */
		case 'I':
			cch();
			bufmod();
			invert();
			break;

		/* K: kill (wipe clean) current glyph. */
		case 'K':
			cch();
			bufmod();
			zermat(wind[curwind].val, GLROW, GLCOL);
			syncwind(curwind);
			if (trace)
				fprintf(trace, "kill: curs_r = %d, curs_c = %d\n", curs_r, curs_c);
			break;

		/* P <first> <last> <file>: read partial font */
		case 'P':
			readchars();
			break;

		/* Q: quit the editor, not saving work. */
		case 'Q':
			confirm();
			done();
			exit(0);

		/* T: typeset a line of input text */
		case 'T':
			typein();
			break;

		/* V: toggle video between inverse and normal */
		case 'V':
			togvid();
			break;

		/*
		 * E <file>: edit new font file <file>.
		 * N <file>: write, then edit <file>
		 * R <file>: read <file> on top of buffer.
		 * W <file>: write out on <file> without quitting
		 */
		case 'E':
		case 'N':
		case 'R':
		case 'W':
			fileiocmd(cmd);
			break;

		/* Z: exit, writing out work */
		case 'Z':
			message("Z");
			if (inchar() != 'Z') {
				error("No second Z");
			}
			if (changes)
				writeback();
			done();
			exit(0);

		/*
		 * ".", ">".  Set and clear the bit under the cursor.
		 */
		case '.':
		case '>':
			bufmod();
			setmat(wind[curwind].val, GLROW, GLCOL, curs_r, curs_c, cmd=='.' ? 1 : 0);
			turnofcurs();
			syncwind(curwind);
			break;

		/*
		 * "#": edit the numerical parameters
		 */
		case '#':
			numedit();
			break;

		default:
			sprintf(msgbuf, "No such command as %s", rdchar(cmd));
			message(msgbuf);
		}

	}
}

/*
 * esccmd: a command beginning with an escape.
 * Map it into the corresponding regular command.
 */
char
esccmd()
{
	char cmd;
	char *p;
	char escseqbuf[20];

	cmd = inchar();
	switch(cmd) {
	case 'A':	return ('k');	/* up arrow */
	case 'B':	return ('j');	/* down arrow */
	case 'C':	return ('l');	/* right arrow */
	case 'D':	return ('h');	/* left arrow */
	case 'h':	return ('b');	/* home */
	case '2':	return ('u');	/* clear tab = undo */
	case '1':	return (' ');	/* set tab = rezoom */
	case 'J':	return ('f');	/* clear display = fill area */
	case 'S':	return ('m');	/* roll up = move */
	case 'U':	return ('d');	/* next page = draw */
	case 'T':	return ('.');	/* roll down = set bit */
	case 'V':	return ('>');	/* prev page = clear bit */
	default:
		/*
		 * Eat up rest of (possibly long) escape sequence.
		 * They all end in an upper case letter, with
		 * a few exceptions.
		 */
		p = escseqbuf;
		*p++ = '$';
		*p++ = cmd;
		while (!isupper(cmd) && cmd != 'h' && cmd != '\n')
			*p++ = cmd = inchar();
		*p++ = 0;
		sprintf(msgbuf, "Bad escape sequence: %s\n", escseqbuf);
		error(msgbuf);
	}
}

onsig(signo)
int signo;
{
	char *mes;

	switch(signo) {
		case SIGQUIT:	mes = "quit"; break;
		case SIGILL:	mes = "illegal instruction"; break;
		case SIGBUS:	mes = "bus error"; break;
		case SIGSEGV:	mes = "segmentation violation"; break;
		case SIGSYS:	mes = "bad system call"; break;
		default:	mes = "random signal"; break;
	}
	if (trace) {
		fprintf(trace, "%s: core dumped\n", mes);
		fflush(trace);
	}
	signal(SIGILL, SIG_DFL);
	done();
	printf("fed: %s: core dumped\n", mes);
	fflush(stdout);
	abort();
}

onintr()
{
	signal(SIGINT, onintr);
	error("Interrupted");
	longjmp(env);
}
Commit	Line	Data
524aa063 SL	1	#ifndef lint
	2	static char sccsid[] = "@(#)fed.c 4.2 (Berkeley) %G%";
	3	#endif
	4
f2523db4 RC	5	/*
	6	* Font editor for the HP 2648.
	7	*
	8	* Mark Horton, 1/80
	9	*/
	10
	11	#include "fed.h"
	12
	13	main(argc,argv)
	14	int argc;
	15	char **argv;
	16	{
	17
	18	signal(SIGINT, onintr);
	19	signal(SIGQUIT, onsig);
	20	signal(SIGILL, onsig);
	21	signal(SIGBUS, onsig);
	22	signal(SIGSEGV, onsig);
	23	signal(SIGSYS, onsig);
	24
	25	while (argc > 1 && argv[1][0] == '-') {
	26	switch(argv[1][1]) {
	27	case 'T':
	28	trace = fopen("trace", "w");
	29	setbuf(trace, tracebuf);
	30	break;
	31	case 'i':
	32	case 'v':
	33	vidinv();
	34	break;
	35	case 'q':
	36	QUIET = 1;
	37	break;
	38	default:
	39	printf("Bad flag: %s\n", argv[1]);
	40	}
	41	argc--; argv++;
	42	}
	43	if (argc < 2) {
	44	fprintf(stderr,"Usage: %s filename\n", argv[0]);
	45	exit(1);
	46	}
	47
	48	if (setjmp(env) == 0) {
	49	initialize();
	50	editfont(argv[1]);
	51	}
	52
	53	cmdloop();
	54	}
	55
	56	cmdloop()
	57	{
	58	char cmd;
	59
	60	setjmp(env);
	61	for (;;) {
	62	cmd = inchar();
	63	if (cmd == ESC)
	64	cmd = esccmd();
	65	switch (cmd) {
	66
	67	/* ^L: redraw munged up screen */
	68	case '\14':
69	redraw();
70	break;
71
72	/* b: move cursor to base point of window */
73	case 'b':
74	cch();
75	curs_r = cht[curchar].rcent;
76	curs_c = cht[curchar].ccent;
77	turnoncurs();
78	break;
79
80	/* c: toggle whether cursor is on */
81	case 'c':
82	if (curcurs)
83	turnofcurs();
84	else
85	turnoncurs();
86	break;
87
88	/* d: draw line of current flavor from pen to cursor */
89	case 'd':
90	cch();
91	bufmod();
92	drawline(pen_r, pen_c, curs_r, curs_c);
93	turnofcurs();
94	turnofrb();
95	pen_r = curs_r; pen_c = curs_c;
96	syncwind(curwind);
97	break;
98
99	/* f: fill in the current hole around the cursor */
100	case 'f':
101	cch();
102	bufmod();
103	if (trace)
104	fprintf(trace, "fillin(%d, %d)\n", curs_r, curs_c);
105	if (mat(wind[curwind].val, GLROW, GLCOL, curs_r, curs_c))
106	error("Not in a hole");
107	fillin(curs_r, curs_c);
108	curoff();
109	syncwind(curwind);
110	break;
111
112	/* g <x>: get glyph "x" as current. */
113	case 'g':
114	if (fontdes == NULL)
115	error("No current font file");
116	message("get glyph <char>");
117	curchar = inchar();
118	sprintf(msgbuf, "get glyph %s", rdchar(curchar));
119	message(msgbuf);
120	getglyph(curchar);
121	break;
122
123	/* h, left arrow: move cursor left */
124	case 'h':
125	cch();
126	if (curs_c <= 0)
127	error("Off edge");
128	else
129	curs_c--;
130	turnoncurs();
131	break;
132
133	/* j, down arrow: move cursor down */
134	case 'j':
135	cch();
136	if (curs_r >= GLROW-1)
137	error("Off edge");
138	else
139	curs_r++;
140	turnoncurs();
141	break;
142
143	/* k, up arrow: move cursor up */
144	case 'k':
145	cch();
146	if (curs_r <= 0)
147	error("Off edge");
148	else
149	curs_r--;
150	turnoncurs();
151	break;
152
153	/* l, right arrow: move cursor down */
154	case 'l':
155	cch();
156	if (curs_c >= GLCOL-1)
157	error("Off edge");
158	else
159	curs_c++;
160	turnoncurs();
161	break;
162
163	/* m: move the pen to where the cursor is */
164	case 'm':
165	cch();
166	pen_r = curs_r; pen_c = curs_c;
167	turnoncurs();
168	move(base[curwind].c+curs_c, base[curwind].r+GLROW-1-curs_r);
169	turnonrb();
170	break;
171
172	/* n <x>: make a new glyph with char x */
173	case 'n':
174	newglyph();
175	break;
176
177	/* p: print a hard copy on the printer of the screen */
178	case 'p':
179	printg();
180	break;
181
182	/* r: toggle rubber band line */
183	case 'r':
184	if (currb)
185	turnofrb();
186	else
187	turnonrb();
188	break;
189
190	/* s <what> <where>: set <what> to <where> */
191	case 's':
192	setcmd();
193	break;
194
195	/* u: undo previous buffer modifying command */
196	case 'u':
197	cch();
198	undo();
199	break;
200
201	/* z <n>: set zoom to n. */
202	case 'z':
203	message("zoom to <level>");
204	curzoom = inchar();
205	if (curzoom == '\r' \|\| curzoom == '\n')
206	curzoom = oldzoom;
207	else {
208	curzoom -= '0';
209	oldzoom = curzoom;
210	}
211	zoomn(curzoom);
212	break;
213
214	/* space: reset zoom to last thing user asked for */
215	case ' ':
216	zoomn(curzoom = oldzoom);
217	break;
218
219	/* A: artificially embolden/italicize <range> by heavy pen size */
220	case 'A':
221	bufmod();
222	artificial();
223	break;
224
225	/* B: move base point of window to cursor */
226	case 'B':
227	cch();
228	cht[curchar].rcent = curs_r;
229	cht[curchar].ccent = curs_c;
230	turnoncurs();
231	break;
232
233	/*
234	* C <from> <to>: copy glyph <from> to <to>.
235	* M <from> <to>: move glyph <from> to <to>.
236	*/
237	case 'C':
238	case 'M':
239	copymove(cmd);
240	break;
241
242	/* D <char1> <char2>: delete range from font */
243	case 'D':
244	delchar();
245	break;
246
247	/* F: display the entire font on the screen. */
248	case 'F':
249	showfont();
250	break;
251
252	/* I: invert the current glyph */
253	case 'I':
254	cch();
255	bufmod();
256	invert();
257	break;
258
259	/* K: kill (wipe clean) current glyph. */
260	case 'K':
261	cch();
262	bufmod();
263	zermat(wind[curwind].val, GLROW, GLCOL);
264	syncwind(curwind);
265	if (trace)
266	fprintf(trace, "kill: curs_r = %d, curs_c = %d\n", curs_r, curs_c);
267	break;
268
269	/* P <first> <last> <file>: read partial font */
270	case 'P':
271	readchars();
272	break;
273
274	/* Q: quit the editor, not saving work. */
275	case 'Q':
276	confirm();
277	done();
278	exit(0);
279
280	/* T: typeset a line of input text */
281	case 'T':
282	typein();
283	break;
284
285	/* V: toggle video between inverse and normal */
286	case 'V':
287	togvid();
288	break;
289
290	/*
291	* E <file>: edit new font file <file>.
292	* N <file>: write, then edit <file>
293	* R <file>: read <file> on top of buffer.
294	* W <file>: write out on <file> without quitting
295	*/
296	case 'E':
297	case 'N':
298	case 'R':
299	case 'W':
300	fileiocmd(cmd);
301	break;
302
303	/* Z: exit, writing out work */
304	case 'Z':
305	message("Z");
306	if (inchar() != 'Z') {
307	error("No second Z");
308	}
309	if (changes)
310	writeback();
311	done();
312	exit(0);
313
314	/*
315	* ".", ">". Set and clear the bit under the cursor.
316	*/
317	case '.':
318	case '>':
319	bufmod();
320	setmat(wind[curwind].val, GLROW, GLCOL, curs_r, curs_c, cmd=='.' ? 1 : 0);
321	turnofcurs();
322	syncwind(curwind);
323	break;
324
325	/*
326	* "#": edit the numerical parameters
327	*/
328	case '#':
329	numedit();
330	break;
331
332	default:
333	sprintf(msgbuf, "No such command as %s", rdchar(cmd));
334	message(msgbuf);
335	}
336
337	}
338	}
339
340	/*
341	* esccmd: a command beginning with an escape.
342	* Map it into the corresponding regular command.
343	*/
344	char
345	esccmd()
346	{
347	char cmd;
348	char *p;
349	char escseqbuf[20];
350
351	cmd = inchar();
352	switch(cmd) {
353	case 'A': return ('k'); /* up arrow */
354	case 'B': return ('j'); /* down arrow */
355	case 'C': return ('l'); /* right arrow */
356	case 'D': return ('h'); /* left arrow */
357	case 'h': return ('b'); /* home */
358	case '2': return ('u'); /* clear tab = undo */
359	case '1': return (' '); /* set tab = rezoom */
360	case 'J': return ('f'); /* clear display = fill area */
361	case 'S': return ('m'); /* roll up = move */
362	case 'U': return ('d'); /* next page = draw */
363	case 'T': return ('.'); /* roll down = set bit */
364	case 'V': return ('>'); /* prev page = clear bit */
365	default:
366	/*
367	* Eat up rest of (possibly long) escape sequence.
368	* They all end in an upper case letter, with
369	* a few exceptions.
370	*/
371	p = escseqbuf;
372	*p++ = '$';
373	*p++ = cmd;
374	while (!isupper(cmd) && cmd != 'h' && cmd != '\n')
375	*p++ = cmd = inchar();
376	*p++ = 0;
377	sprintf(msgbuf, "Bad escape sequence: %s\n", escseqbuf);
378	error(msgbuf);
379	}
380	}
381
382	onsig(signo)
383	int signo;
384	{
385	char *mes;
386
387	switch(signo) {
388	case SIGQUIT: mes = "quit"; break;
389	case SIGILL: mes = "illegal instruction"; break;
390	case SIGBUS: mes = "bus error"; break;
391	case SIGSEGV: mes = "segmentation violation"; break;
392	case SIGSYS: mes = "bad system call"; break;
393	default: mes = "random signal"; break;
394	}
395	if (trace) {
396	fprintf(trace, "%s: core dumped\n", mes);
397	fflush(trace);
398	}
399	signal(SIGILL, SIG_DFL);
400	done();
401	printf("fed: %s: core dumped\n", mes);
402	fflush(stdout);
403	abort();
404	}
405
406	onintr()
407	{
408	signal(SIGINT, onintr);
409	error("Interrupted");
410	longjmp(env);
411	}