![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fed.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ucb / fed|
Return to fed.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / fed |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)fed.c 4.2 (Berkeley) 8/11/83";
3: #endif
4:
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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.