![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd|
Return to hp.c CVS log | Up to [Research Unix] / researchv10no / cmd |
1.1 root 1: /*
2: * hp [-e] [-m]
3: * convert nroff TTY37 output to right form for HP2640x terminals.
4: * -e indicates enhanced terminal with underline, etc.
5: * -m requests minimization of output by removing multiple newlines
6: */
7:
8: char hpvers[] = "@(#)hp.c 1.6";
9:
10: #include <stdio.h>
11: #include <signal.h>
12: #include <sys/types.h>
13: #include <sys/stat.h>
14: #include <sgtty.h>
15: #define ESC 033 /* escape */
16: #define HFWD '9'
17: #define HREV '8'
18: #define FREV '7'
19: #define SO 016 /* shift out - enter greek */
20: #define SI 017 /* shift in */
21: #define LF '\n'
22: #define CR 015
23: #define NFLAG 0200 /* hi-bit flag for non-showing chars */
24: #define NMASK 0177
25: #define AMP 046 /* & */
26: #define DEE 0144 /* d */
27: #define BFSIZ 4096 /* size of output buffer */
28: /* (bigger because of tbl weirds */
29: /* and nroff idiosyncracies */
30:
31: /* puty adds control char to output, marked by hi-bit */
32: #define puty(c) putx(c|NFLAG)
33: #define flg(x) ((char)(x|NFLAG)) /* set hi-bit of x */
34: int nlcnt, /* accumulated newline count */
35: frevcnt, /* accumulated reverse line-feeds */
36: halfpos, /* half-line position: -1 = above, +1 = below */
37: restrict = 1, /* 0==> full terminal, 1==> no display enhancements */
38: minimiz; /* 0==> normal, 1==> remove extra newlines */
39: char *ttydev;
40: int svstmode; /* for mesg restore */
41: int restore();
42: char *ttyname();
43: int svsgflgs;
44: struct sgttyb sgb;
45: int retcode = 2; /* return code */
46: char peekbuf[2];
47: char *peekstr = peekbuf; /* lookahead ptr */
48:
49: char outbf[BFSIZ]; /* output assembly buffer */
50: char *bfnext = outbf, /* addr of next empty byte */
51: *bflast = &outbf[BFSIZ-1]; /* addr of last usable byte */
52:
53: /* normal display enhancement strings */
54: char *enunder = "\033&dD", /* underline */
55: *ennorml = "\033&d@", /* normal output */
56: *ensuper = "\033&dH", /* superscript (half) */
57: *ensubsc = "\033&dL", /* subscript (half, underlined */
58: *enrestr = "\033&dB"; /* restricted (inverse only) */
59:
60: int restore();
61: main(argc, argv)
62: char **argv;
63: {
64: register c;
65: scanarg(argc,argv);
66: if (((int)signal(SIGINT, SIG_IGN) & 01) == 0)
67: signal(SIGINT, restore);
68: if (gtty(1, &sgb) == 0)
69: fixtty();
70: setbuf(stdin, calloc(BUFSIZ,1));
71: while((c = getchal()) != EOF) {
72: if (nlcnt && c != LF) flushnl();
73: if (frevcnt && c != ESC) flushrv();
74: if (c == LF) {
75: if (++nlcnt == 1) flushln();
76: continue;
77: }
78: if (c == ESC)
79: escape();
80: else if (c == SO)
81: special();
82: else if (c == '\b')
83: backsp();
84: else if (c == '_') { /* C nroff */
85: if ((c = getchal()) == '\b') {
86: undersc();
87: } else {
88: putx('_');
89: peekbuf[0] = c;
90: peekstr = peekbuf;
91: }
92: }
93: else
94: putx(c);
95: }
96: flusher();
97: retcode = 0;
98: restore();
99: }
100:
101: getchal()
102: {
103: if (*peekstr)
104: return(*peekstr++);
105: return(getchar());
106: }
107:
108: /* scanarg: scan arguments and set flags; ignore unknown args */
109: scanarg(argc,argv)
110: int argc; char **argv;
111: {
112: register char *p;
113: while ( --argc > 0) {
114: p = *++argv;
115: if (*p == '-') {
116: ++p;
117: if (*p == 'e') restrict = 0;
118: else if (*p == 'm') minimiz = 1;
119: }
120: }
121: if (restrict)
122: enunder = ensuper = ensubsc = enrestr;
123: }
124:
125: /* fixtty: get tty status and save; remove delay and CR-LF mapping */
126: fixtty()
127: {
128: struct stat sb;
129:
130: svsgflgs = sgb.sg_flags;
131: sgb.sg_flags &= ~(ALLDELAY|CRMOD);
132: stty(1, &sgb); /* stty nl nl0 cr0 tab0 ff0 */
133: fstat(1, &sb);
134: svstmode = sb.st_mode;
135: ttydev = ttyname(1);
136: if (ttydev && *ttydev)
137: chmod(ttydev, 0600); /* mesg n */
138: }
139:
140: /* flusher: flush accumulated newlines, reverse line feeds, buffer */
141: flusher()
142: {
143: flushln();
144: if (nlcnt) flushnl();
145: if (frevcnt) flushrv();
146: fflush(stdout);
147: }
148:
149: /* flushrv: flush accumulated reverse line feeds */
150: flushrv()
151: {
152: while (frevcnt--)
153: putstr("\033T");
154: putstr(ennorml);
155: frevcnt = 0;
156: }
157:
158: /* flushnl: flush accumulated newlines (count in nlcnt) */
159: flushnl()
160: {
161: if (minimiz != 0 && nlcnt > 2) nlcnt = 2;
162: putchar(CR);
163: while (nlcnt--)
164: putchar(LF);
165: nlcnt = 0;
166: }
167:
168: putstr(p)
169: char *p;
170: {
171: register char *pp;
172: pp = p;
173: while (*pp) puty(*pp++);
174: }
175:
176: restore(){
177: if (isatty(1)) {
178: sgb.sg_flags = svsgflgs;
179: stty(1, &sgb);
180: if (ttydev && *ttydev)
181: chmod(ttydev, svstmode);
182: }
183: exit(retcode);
184: }
185:
186: char tab[] = {
187: 'A','A', /* alpha */
188: 'B','B', /* beta */
189: 'D','W', /* delta */
190: 'W','V', /* DELTA */
191: 'S','E', /* epsilon */
192: 'N','H', /* eta */
193: '\\','Q', /* gamma */
194: 'G','+', /* GAMMA */
195: 'o','<', /* infinity - not in M37 */
196: '^','\'', /* integral */
197: 'L','G', /* lambda */
198: 'E',';', /* LAMBDA */
199: 'M','M', /* mu */
200: '[','$', /* nabla (del) */
201: '_','\\', /* not */
202: '@','N', /* nu */
203: 'C','L', /* omega */
204: 'Z',':', /* OMEGA */
205: ']','F', /* partial */
206: 'U','D', /* phi */
207: 'F','.', /* PHI */
208: 'V','C', /* psi */
209: 'H',',', /* PSI */
210: 'J','P', /* pi */
211: 'P','*', /* PI */
212: 'K','O', /* rho */
213: 'Y','S', /* sigma */
214: 'R','?', /* SIGMA */
215: 'I','T', /* tau */
216: 'T','R', /* theta */
217: 'O','J', /* THETA */
218: 'X','U', /* xi */
219: 'Q','Z', /* zeta */
220: 'v','Y',
221: 0
222: };
223:
224: char spec1[] = {LF,SO,0};
225: special(){
226: register int c;
227: register char *p;
228: puty(SO);
229: while ((c = getchal()) != EOF) {
230: if (c == SI) {
231: puty(c);
232: return;
233: }
234: if (c == LF) {
235: peekstr = spec1;
236: return;
237: }
238: for (p = tab; *p != 0; p += 2)
239: if (c == *p) {
240: c = *++p;
241: break;
242: }
243: putx(c);
244: }
245: }
246:
247: /* escape: handle escape sequences */
248: escape()
249: {
250: register int c;
251: c = getchal();
252: if (frevcnt && c != FREV) flushrv();
253: switch (c) {
254: case FREV:
255: frevcnt++;
256: break;
257: case HREV:
258: if (halfpos == 0) {
259: putstr(ensuper);
260: halfpos--;
261: }
262: else if (halfpos > 0) {
263: putstr(ennorml);
264: halfpos--;
265: }
266: else {
267: putstr("\033T"); /* roll back 1 */
268: putstr(ennorml);
269: halfpos = 0;
270: }
271: break;
272: case HFWD:
273: if (halfpos == 0) {
274: putstr(ensubsc);
275: halfpos++;
276: }
277: else if (halfpos < 0) {
278: putstr(ennorml);
279: halfpos++;
280: }
281: else {
282: putstr("\033S"); /* roll up 1, i.e., LF w/o CR */
283: putstr(ennorml);
284: halfpos = 0;
285: }
286: break;
287: case '&':
288: putstr("\033&");
289: puty(c = getchal());
290: if (c == 'd') puty(getchal());
291: break;
292: case ')':
293: putstr("\033)");
294: puty(getchal());
295: break;
296: default:
297: puty(ESC);
298: puty(getchal());
299: break;
300: }
301: }
302:
303: char peeku[3];
304: /* backsp: handle backspacing */
305: /* sequences are handled such that : ( \b is backspace ) */
306: /* a\b_ -> a in inverse video */
307: /* _\ba -> a in inverse video */
308: /* c\bd -> c in inverse video */
309: /* if a control char (ESC) precedes or follows '\b' */
310: /* then an actual backspace movement is performed */
311: backsp()
312: {
313: register char *bftmp;
314: register int c;
315: char *bfhi;
316: int i, j, ncnt, bscnt;
317: char *p, *p1;
318: p = bfnext-2;
319: p1 = bfnext-4;
320: /* check if last char put in buffer was escape sequence */
321: /* if so, put backspace control sequence in buffer */
322: /* check against "\033&d" */
323: if ((*p == flg(ESC)) ||
324: (*p1++ == flg(ESC) && *p1++==flg(AMP) && *p1==flg(DEE))) {
325: putstr("\033D");
326: while((c=getchal())=='\b') putstr("\033D");
327: /* put last char back */
328: peeku[0] = c;
329: peeku[1] = '\0';
330: peekstr = peeku;
331: return;
332: }
333: bscnt = 1;
334: c = getchal();
335: /* count backspaces */
336: while (c == '\b') {
337: bscnt++;
338: c = getchal();
339: }
340: /* read in chars until bscnt have been read */
341: /* or until an ESC is read */
342: ncnt = 0;
343: if (c!=ESC) {
344: for (ncnt=0; (ncnt<bscnt && c!=ESC); ncnt++)
345: c = getchal();
346: /* since there were normal chars with backsp */
347: /* insert inverse video chars in buffer */
348: bftmp = bfhi = bfnext + 4;
349: for (i=0; i<bscnt;)
350: if (((*--bftmp = *--bfnext) & NFLAG) == 0) i++;
351: putstr(enunder);
352: bfnext = bfhi;
353: }
354: /* if number of bcksp is not = to number normal chars */
355: /* then some bcksp chars will be inserted as actual */
356: /* bcksp movement and not inverse video for another char */
357: j = bscnt - ncnt;
358: if (j == 0) putstr(ennorml);
359: else {
360: /* move chars over and insert normal char seq */
361: if (ncnt > 0) {
362: bftmp = bfhi = bfnext + 4;
363: for (i=0; i<j;)
364: if (((*--bftmp = *--bfnext) & NFLAG) == 0) i++;
365: putstr(ennorml);
366: bfnext = bfhi;
367: }
368: /* insert backspace movement chars */
369: while (j--) putstr("\033D");
370: }
371: /* put last char read back */
372: peeku[0] = c;
373: peeku[1] = '\0';
374: peekstr = peeku;
375: }
376: /* undersc: handle C nroff's (_ BS char)+ sequences
377: * assumes _ BS already found
378: * if char is a control char, put char back and break.
379: */
380: undersc()
381: {
382: register char c;
383:
384: putstr(enunder);
385: while (1) {
386: if ((c=getchal())==ESC) {
387: peeku[0] = c; peeku[1] = '\0';
388: peekstr = peeku;
389: break;
390: }
391: else
392: putx(c);
393: if ((c = getchal()) != '_') {
394: peeku[0] = c; peeku[1] = '\0';
395: peekstr = peeku;
396: break;
397: }
398: if ((c = getchal()) != '\b') {
399: peeku[0] = '_'; peeku[1] = c;
400: peekstr = peeku;
401: break;
402: }
403: }
404: putstr(ennorml);
405: }
406:
407: /* flushln: flush out accumulated line */
408: flushln()
409: {
410: register char c, *p;
411: putx('\0');
412: p = outbf;
413: while (c = (*p++ & NMASK)) putchar(c);
414: bfnext = outbf;
415: }
416:
417: /* putx: add normal (printing) char to output */
418: putx(c)
419: char c;
420: {
421: if (bfnext <= bflast)
422: *bfnext++ = c;
423: else die("line too long\n");
424: }
425:
426: die(mesg)
427: char *mesg;
428: {
429: register char *p;
430: char *c = "hp: ";
431:
432: write(2, c, 4);
433: p = mesg;
434: while (*p)
435: write(2, p++, 1);
436: restore();
437: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.