![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ul.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ucb|
Return to ul.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)ul.c 4.5 (Berkeley) 8/11/83";
3: #endif
4:
5: #include <stdio.h>
6:
7: #define IESC '\033'
8: #define SO '\016'
9: #define SI '\017'
10: #define HFWD '9'
11: #define HREV '8'
12: #define FREV '7'
13: #define MAXBUF 512
14:
15: #define NORMAL 000
16: #define ALTSET 001 /* Reverse */
17: #define SUPERSC 002 /* Dim */
18: #define SUBSC 004 /* Dim | Ul */
19: #define UNDERL 010 /* Ul */
20: #define BOLD 020 /* Bold */
21:
22: int must_use_uc, must_overstrike;
23: char *CURS_UP, *CURS_RIGHT, *CURS_LEFT,
24: *ENTER_STANDOUT, *EXIT_STANDOUT, *ENTER_UNDERLINE, *EXIT_UNDERLINE,
25: *ENTER_DIM, *ENTER_BOLD, *ENTER_REVERSE, *UNDER_CHAR, *EXIT_ATTRIBUTES;
26:
27: struct CHAR {
28: char c_mode;
29: char c_char;
30: } ;
31:
32: char buf[BUFSIZ];
33:
34: struct CHAR obuf[MAXBUF];
35: int col, maxcol;
36: int mode;
37: int halfpos;
38: int upln;
39: int iflag;
40:
41: main(argc, argv)
42: int argc;
43: char **argv;
44: {
45: int c;
46: char *cp, *termtype;
47: FILE *f;
48: char termcap[1024];
49: char *getenv();
50: extern int optind;
51: extern char *optarg;
52:
53: termtype = getenv("TERM");
54: if (termtype == NULL || (argv[0][0] == 'c' && !isatty(1)))
55: termtype = "lpr";
56: while ((c=getopt(argc, argv, "it:T:")) != EOF)
57: switch(c) {
58:
59: case 't':
60: case 'T': /* for nroff compatibility */
61: termtype = optarg;
62: break;
63: case 'i':
64: iflag = 1;
65: break;
66:
67: default:
68: fprintf(stderr,
69: "Usage: %s [ -i ] [ -tTerm ] file...\n",
70: argv[0]);
71: exit(1);
72: }
73:
74: switch(tgetent(termcap, termtype)) {
75:
76: case 1:
77: break;
78:
79: default:
80: fprintf(stderr,"trouble reading termcap");
81: /* fall through to ... */
82:
83: case 0:
84: /* No such terminal type - assume dumb */
85: strcpy(termcap, "dumb:os:col#80:cr=^M:sf=^J:am:");
86: break;
87: }
88: initcap();
89: if ( (tgetflag("os") && ENTER_BOLD==NULL ) ||
90: (tgetflag("ul") && ENTER_UNDERLINE==NULL && UNDER_CHAR==NULL))
91: must_overstrike = 1;
92: setbuf(stdout, buf);
93: initbuf();
94: if (optind == argc)
95: filter(stdin);
96: else for (; optind<argc; optind++) {
97: f = fopen(argv[optind],"r");
98: if (f == NULL) {
99: perror(argv[optind]);
100: exit(1);
101: } else
102: filter(f);
103: }
104: exit(0);
105: }
106:
107: filter(f)
108: FILE *f;
109: {
110: register c;
111:
112: while((c = getc(f)) != EOF) switch(c) {
113:
114: case '\b':
115: if (col > 0)
116: col--;
117: continue;
118:
119: case '\t':
120: col = (col+8) & ~07;
121: if (col > maxcol)
122: maxcol = col;
123: continue;
124:
125: case '\r':
126: col = 0;
127: continue;
128:
129: case SO:
130: mode |= ALTSET;
131: continue;
132:
133: case SI:
134: mode &= ~ALTSET;
135: continue;
136:
137: case IESC:
138: switch (c = getc(f)) {
139:
140: case HREV:
141: if (halfpos == 0) {
142: mode |= SUPERSC;
143: halfpos--;
144: } else if (halfpos > 0) {
145: mode &= ~SUBSC;
146: halfpos--;
147: } else {
148: halfpos = 0;
149: reverse();
150: }
151: continue;
152:
153: case HFWD:
154: if (halfpos == 0) {
155: mode |= SUBSC;
156: halfpos++;
157: } else if (halfpos < 0) {
158: mode &= ~SUPERSC;
159: halfpos++;
160: } else {
161: halfpos = 0;
162: fwd();
163: }
164: continue;
165:
166: case FREV:
167: reverse();
168: continue;
169:
170: default:
171: fprintf(stderr,
172: "Unknown escape sequence in input: %o, %o\n",
173: IESC, c);
174: exit(1);
175: }
176: continue;
177:
178: case '_':
179: if (obuf[col].c_char)
180: obuf[col].c_mode |= UNDERL | mode;
181: else
182: obuf[col].c_char = '_';
183: case ' ':
184: col++;
185: if (col > maxcol)
186: maxcol = col;
187: continue;
188:
189: case '\n':
190: flushln();
191: continue;
192:
193: default:
194: if (c < ' ') /* non printing */
195: continue;
196: if (obuf[col].c_char == '\0') {
197: obuf[col].c_char = c;
198: obuf[col].c_mode = mode;
199: } else if (obuf[col].c_char == '_') {
200: obuf[col].c_char = c;
201: obuf[col].c_mode |= UNDERL|mode;
202: } else if (obuf[col].c_char == c)
203: obuf[col].c_mode |= BOLD|mode;
204: else {
205: obuf[col].c_mode = c;
206: obuf[col].c_mode = mode;
207: }
208: col++;
209: if (col > maxcol)
210: maxcol = col;
211: continue;
212: }
213: if (maxcol)
214: flushln();
215: }
216:
217: flushln()
218: {
219: register lastmode;
220: register i;
221: int hadmodes = 0;
222:
223: lastmode = NORMAL;
224: for (i=0; i<maxcol; i++) {
225: if (obuf[i].c_mode != lastmode) {
226: hadmodes++;
227: setmode(obuf[i].c_mode);
228: lastmode = obuf[i].c_mode;
229: }
230: if (obuf[i].c_char == '\0') {
231: if (upln) {
232: puts(CURS_RIGHT);
233: } else
234: outc(' ');
235: } else
236: outc(obuf[i].c_char);
237: }
238: if (lastmode != NORMAL) {
239: setmode(0);
240: }
241: if (must_overstrike && hadmodes)
242: overstrike();
243: putchar('\n');
244: if (iflag && hadmodes)
245: iattr();
246: fflush(stdout);
247: if (upln)
248: upln--;
249: initbuf();
250: }
251:
252: /*
253: * For terminals that can overstrike, overstrike underlines and bolds.
254: * We don't do anything with halfline ups and downs, or Greek.
255: */
256: overstrike()
257: {
258: register int i;
259: char lbuf[256];
260: register char *cp = lbuf;
261: int hadbold=0;
262:
263: /* Set up overstrike buffer */
264: for (i=0; i<maxcol; i++)
265: switch (obuf[i].c_mode) {
266: case NORMAL:
267: default:
268: *cp++ = ' ';
269: break;
270: case UNDERL:
271: *cp++ = '_';
272: break;
273: case BOLD:
274: *cp++ = obuf[i].c_char;
275: hadbold=1;
276: break;
277: }
278: putchar('\r');
279: for (*cp=' '; *cp==' '; cp--)
280: *cp = 0;
281: for (cp=lbuf; *cp; cp++)
282: putchar(*cp);
283: if (hadbold) {
284: putchar('\r');
285: for (cp=lbuf; *cp; cp++)
286: putchar(*cp=='_' ? ' ' : *cp);
287: putchar('\r');
288: for (cp=lbuf; *cp; cp++)
289: putchar(*cp=='_' ? ' ' : *cp);
290: }
291: }
292:
293: iattr()
294: {
295: register int i;
296: char lbuf[256];
297: register char *cp = lbuf;
298:
299: for (i=0; i<maxcol; i++)
300: switch (obuf[i].c_mode) {
301: case NORMAL: *cp++ = ' '; break;
302: case ALTSET: *cp++ = 'g'; break;
303: case SUPERSC: *cp++ = '^'; break;
304: case SUBSC: *cp++ = 'v'; break;
305: case UNDERL: *cp++ = '_'; break;
306: case BOLD: *cp++ = '!'; break;
307: default: *cp++ = 'X'; break;
308: }
309: for (*cp=' '; *cp==' '; cp--)
310: *cp = 0;
311: for (cp=lbuf; *cp; cp++)
312: putchar(*cp);
313: putchar('\n');
314: }
315:
316: initbuf()
317: {
318: register i;
319:
320: for (i=0; i<MAXBUF; i++) {
321: obuf[i].c_char = '\0';
322: obuf[i].c_mode = NORMAL;
323: }
324: col = 0;
325: maxcol = 0;
326: mode &= ALTSET;
327: }
328:
329: fwd()
330: {
331: register oldcol, oldmax;
332:
333: oldcol = col;
334: oldmax = maxcol;
335: flushln();
336: col = oldcol;
337: maxcol = oldmax;
338: }
339:
340: reverse()
341: {
342: upln++;
343: fwd();
344: puts(CURS_UP);
345: puts(CURS_UP);
346: upln++;
347: }
348:
349: initcap()
350: {
351: static char tcapbuf[512];
352: char *termtype;
353: char *bp = tcapbuf;
354: char *getenv(), *tgetstr();
355:
356: /* This nonsense attempts to work with both old and new termcap */
357: CURS_UP = tgetstr("up", &bp);
358: CURS_RIGHT = tgetstr("ri", &bp);
359: if (CURS_RIGHT == NULL)
360: CURS_RIGHT = tgetstr("nd", &bp);
361: CURS_LEFT = tgetstr("le", &bp);
362: if (CURS_LEFT == NULL)
363: CURS_LEFT = tgetstr("bc", &bp);
364: if (CURS_LEFT == NULL && tgetflag("bs"))
365: CURS_LEFT = "\b";
366:
367: ENTER_STANDOUT = tgetstr("so", &bp);
368: EXIT_STANDOUT = tgetstr("se", &bp);
369: ENTER_UNDERLINE = tgetstr("us", &bp);
370: EXIT_UNDERLINE = tgetstr("ue", &bp);
371: ENTER_DIM = tgetstr("mh", &bp);
372: ENTER_BOLD = tgetstr("md", &bp);
373: ENTER_REVERSE = tgetstr("mr", &bp);
374: EXIT_ATTRIBUTES = tgetstr("me", &bp);
375:
376: if (!ENTER_BOLD && ENTER_REVERSE)
377: ENTER_BOLD = ENTER_REVERSE;
378: if (!ENTER_BOLD && ENTER_STANDOUT)
379: ENTER_BOLD = ENTER_STANDOUT;
380: if (!ENTER_UNDERLINE && ENTER_STANDOUT) {
381: ENTER_UNDERLINE = ENTER_STANDOUT;
382: EXIT_UNDERLINE = EXIT_STANDOUT;
383: }
384: if (!ENTER_DIM && ENTER_STANDOUT)
385: ENTER_DIM = ENTER_STANDOUT;
386: if (!ENTER_REVERSE && ENTER_STANDOUT)
387: ENTER_REVERSE = ENTER_STANDOUT;
388: if (!EXIT_ATTRIBUTES && EXIT_STANDOUT)
389: EXIT_ATTRIBUTES = EXIT_STANDOUT;
390:
391: /*
392: * Note that we use REVERSE for the alternate character set,
393: * not the as/ae capabilities. This is because we are modelling
394: * the model 37 teletype (since that's what nroff outputs) and
395: * the typical as/ae is more of a graphics set, not the greek
396: * letters the 37 has.
397: */
398:
399: #ifdef notdef
400: printf("so %s se %s us %s ue %s me %s\n",
401: ENTER_STANDOUT, EXIT_STANDOUT, ENTER_UNDERLINE,
402: EXIT_UNDERLINE, EXIT_ATTRIBUTES);
403: #endif
404: UNDER_CHAR = tgetstr("uc", &bp);
405: must_use_uc = (UNDER_CHAR && !ENTER_UNDERLINE);
406: }
407:
408: outchar(c)
409: char c;
410: {
411: putchar(c&0177);
412: }
413:
414: puts(str)
415: char *str;
416: {
417: if (str)
418: tputs(str, 1, outchar);
419: }
420:
421: static curmode = 0;
422: outc(c)
423: char c;
424: {
425: putchar(c);
426: if (must_use_uc && (curmode&UNDERL)) {
427: puts(CURS_LEFT);
428: puts(UNDER_CHAR);
429: }
430: }
431:
432: setmode(newmode)
433: int newmode;
434: {
435: if (!iflag)
436: {
437: if (curmode != NORMAL && newmode != NORMAL)
438: setmode(NORMAL);
439: switch (newmode) {
440: case NORMAL:
441: switch(curmode) {
442: case NORMAL:
443: break;
444: case UNDERL:
445: puts(EXIT_UNDERLINE);
446: break;
447: default:
448: /* This includes standout */
449: puts(EXIT_ATTRIBUTES);
450: break;
451: }
452: break;
453: case ALTSET:
454: puts(ENTER_REVERSE);
455: break;
456: case SUPERSC:
457: /*
458: * This only works on a few terminals.
459: * It should be fixed.
460: */
461: puts(ENTER_UNDERLINE);
462: puts(ENTER_DIM);
463: break;
464: case SUBSC:
465: puts(ENTER_DIM);
466: break;
467: case UNDERL:
468: puts(ENTER_UNDERLINE);
469: break;
470: case BOLD:
471: puts(ENTER_BOLD);
472: break;
473: default:
474: /*
475: * We should have some provision here for multiple modes
476: * on at once. This will have to come later.
477: */
478: puts(ENTER_STANDOUT);
479: break;
480: }
481: }
482: curmode = newmode;
483: }
484: /* @(#)getopt.c 3.2 */
485: #define ERR(s, c) if(opterr){\
486: fputs(argv[0], stderr);\
487: fputs(s, stderr);\
488: fputc(c, stderr);\
489: fputc('\n', stderr);}
490:
491: int opterr = 1;
492: int optind = 1;
493: char *optarg;
494: char *index();
495:
496: int
497: getopt (argc, argv, opts)
498: char **argv, *opts;
499: {
500: static int sp = 1;
501: char c;
502: char *cp;
503:
504: if (sp == 1)
505: if (optind >= argc ||
506: argv[optind][0] != '-' || argv[optind][1] == '\0')
507: return EOF;
508: else if (strcmp(argv[optind], "--") == NULL) {
509: optind++;
510: return EOF;
511: }
512: else if (strcmp(argv[optind], "-?") == NULL) {
513: optind++;
514: return '?';
515: }
516: c = argv[optind][sp];
517: if (c == ':' || (cp=index(opts, c)) == NULL) {
518: ERR (": illegal option -- ", c);
519: if (argv[optind][++sp] == '\0') {
520: optind++;
521: sp = 1;
522: }
523: return '?';
524: }
525: if (*++cp == ':') {
526: if (argv[optind][2] != '\0')
527: optarg = &argv[optind++][sp+1];
528: else if (++optind >= argc) {
529: ERR (": option requires an argument -- ", c);
530: sp = 1;
531: return '?';
532: } else
533: optarg = argv[optind++];
534: sp = 1;
535: }
536: else if (argv[optind][++sp] == '\0') {
537: sp = 1;
538: optind++;
539: }
540: return c;
541: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.