]> git.ipfire.org Git - thirdparty/util-linux.git/blob - text-utils/ul.c
su: use lib/pty-session.c code for --pty
[thirdparty/util-linux.git] / text-utils / ul.c
1 /*
2 * Copyright (c) 1980, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34 /*
35 * modified by Kars de Jong <jongk@cs.utwente.nl>
36 * to use terminfo instead of termcap.
37 * 1999-02-22 Arkadiusz Miƛkiewicz <misiek@pld.ORG.PL>
38 * added Native Language Support
39 * 1999-09-19 Bruno Haible <haible@clisp.cons.org>
40 * modified to work correctly in multi-byte locales
41 */
42
43 #include <stdio.h>
44 #include <unistd.h> /* for getopt(), isatty() */
45 #include <string.h> /* for memset(), strcpy() */
46 #include <stdlib.h> /* for getenv() */
47 #include <limits.h> /* for INT_MAX */
48 #include <signal.h> /* for signal() */
49 #include <errno.h>
50 #include <getopt.h>
51
52 #if defined(HAVE_NCURSESW_TERM_H)
53 # include <ncursesw/term.h>
54 #elif defined(HAVE_NCURSES_TERM_H)
55 # include <ncurses/term.h>
56 #elif defined(HAVE_TERM_H)
57 # include <term.h>
58 #endif
59
60 #include "nls.h"
61 #include "xalloc.h"
62 #include "widechar.h"
63 #include "c.h"
64 #include "closestream.h"
65
66 #ifdef HAVE_WIDECHAR
67 /* Output an ASCII character as a wide character */
68 static int put1wc(int c)
69 {
70 if (putwchar(c) == WEOF)
71 return EOF;
72 else
73 return c;
74 }
75 #define putwp(s) tputs(s, STDOUT_FILENO, put1wc)
76 #else
77 #define putwp(s) putp(s)
78 #endif
79
80 static int handle_escape(FILE * f);
81 static void filter(FILE *f);
82 static void flushln(void);
83 static void overstrike(void);
84 static void iattr(void);
85 static void initbuf(void);
86 static void fwd(void);
87 static void reverse(void);
88 static void initinfo(void);
89 static void outc(wint_t c, int width);
90 static void xsetmode(int newmode);
91 static void setcol(int newcol);
92 static void needcol(int col);
93 static void sig_handler(int signo);
94 static void print_out(char *line);
95
96 #define IESC '\033'
97 #define SO '\016'
98 #define SI '\017'
99 #define HFWD '9'
100 #define HREV '8'
101 #define FREV '7'
102
103 #define NORMAL 000
104 #define ALTSET 001 /* Reverse */
105 #define SUPERSC 002 /* Dim */
106 #define SUBSC 004 /* Dim | Ul */
107 #define UNDERL 010 /* Ul */
108 #define BOLD 020 /* Bold */
109
110 static int must_use_uc, must_overstrike;
111 static char *CURS_UP,
112 *CURS_RIGHT,
113 *CURS_LEFT,
114 *ENTER_STANDOUT,
115 *EXIT_STANDOUT,
116 *ENTER_UNDERLINE,
117 *EXIT_UNDERLINE,
118 *ENTER_DIM,
119 *ENTER_BOLD,
120 *ENTER_REVERSE,
121 *UNDER_CHAR,
122 *EXIT_ATTRIBUTES;
123
124 struct CHAR {
125 char c_mode;
126 wchar_t c_char;
127 int c_width;
128 };
129
130 static struct CHAR *obuf;
131 static int obuflen;
132 static int col, maxcol;
133 static int mode;
134 static int halfpos;
135 static int upln;
136 static int iflag;
137
138 static void __attribute__((__noreturn__)) usage(void)
139 {
140 FILE *out = stdout;
141 fputs(USAGE_HEADER, out);
142 fprintf(out, _(" %s [options] [<file> ...]\n"), program_invocation_short_name);
143
144 fputs(USAGE_SEPARATOR, out);
145 fputs(_("Do underlining.\n"), out);
146
147 fputs(USAGE_OPTIONS, out);
148 fputs(_(" -t, -T, --terminal TERMINAL override the TERM environment variable\n"), out);
149 fputs(_(" -i, --indicated underlining is indicated via a separate line\n"), out);
150 fputs(USAGE_SEPARATOR, out);
151 printf(USAGE_HELP_OPTIONS(30));
152
153 printf(USAGE_MAN_TAIL("ul(1)"));
154
155 exit(EXIT_SUCCESS);
156 }
157
158 int main(int argc, char **argv)
159 {
160 int c, ret, tflag = 0;
161 char *termtype;
162 FILE *f;
163
164 static const struct option longopts[] = {
165 { "terminal", required_argument, NULL, 't' },
166 { "indicated", no_argument, NULL, 'i' },
167 { "version", no_argument, NULL, 'V' },
168 { "help", no_argument, NULL, 'h' },
169 { NULL, 0, NULL, 0 }
170 };
171
172 setlocale(LC_ALL, "");
173 bindtextdomain(PACKAGE, LOCALEDIR);
174 textdomain(PACKAGE);
175 close_stdout_atexit();
176
177 signal(SIGINT, sig_handler);
178 signal(SIGTERM, sig_handler);
179
180 termtype = getenv("TERM");
181
182 while ((c = getopt_long(argc, argv, "it:T:Vh", longopts, NULL)) != -1)
183 switch (c) {
184
185 case 't':
186 case 'T':
187 /* for nroff compatibility */
188 termtype = optarg;
189 tflag = 1;
190 break;
191 case 'i':
192 iflag = 1;
193 break;
194
195 case 'V':
196 print_version(EXIT_SUCCESS);
197 case 'h':
198 usage();
199 default:
200 errtryhelp(EXIT_FAILURE);
201 }
202 setupterm(termtype, STDOUT_FILENO, &ret);
203 switch (ret) {
204
205 case 1:
206 break;
207
208 default:
209 warnx(_("trouble reading terminfo"));
210 /* fallthrough */
211
212 case 0:
213 if (tflag)
214 warnx(_("terminal `%s' is not known, defaulting to `dumb'"),
215 termtype);
216 setupterm("dumb", STDOUT_FILENO, (int *)0);
217 break;
218 }
219 initinfo();
220 if ((tigetflag("os") && ENTER_BOLD==NULL ) ||
221 (tigetflag("ul") && ENTER_UNDERLINE==NULL && UNDER_CHAR==NULL))
222 must_overstrike = 1;
223 initbuf();
224 if (optind == argc)
225 filter(stdin);
226 else
227 for (; optind < argc; optind++) {
228 f = fopen(argv[optind],"r");
229 if (!f)
230 err(EXIT_FAILURE, _("cannot open %s"),
231 argv[optind]);
232 filter(f);
233 fclose(f);
234 }
235 free(obuf);
236 return EXIT_SUCCESS;
237 }
238
239 static int handle_escape(FILE * f)
240 {
241 wint_t c;
242
243 switch (c = getwc(f)) {
244 case HREV:
245 if (halfpos == 0) {
246 mode |= SUPERSC;
247 halfpos--;
248 } else if (halfpos > 0) {
249 mode &= ~SUBSC;
250 halfpos--;
251 } else {
252 halfpos = 0;
253 reverse();
254 }
255 return 0;
256 case HFWD:
257 if (halfpos == 0) {
258 mode |= SUBSC;
259 halfpos++;
260 } else if (halfpos < 0) {
261 mode &= ~SUPERSC;
262 halfpos++;
263 } else {
264 halfpos = 0;
265 fwd();
266 }
267 return 0;
268 case FREV:
269 reverse();
270 return 0;
271 default:
272 /* unknown escape */
273 ungetwc(c, f);
274 return 1;
275 }
276 }
277
278 static void filter(FILE *f)
279 {
280 wint_t c;
281 int i, w;
282
283 while ((c = getwc(f)) != WEOF) {
284 switch (c) {
285 case '\b':
286 setcol(col - 1);
287 continue;
288 case '\t':
289 setcol((col + 8) & ~07);
290 continue;
291 case '\r':
292 setcol(0);
293 continue;
294 case SO:
295 mode |= ALTSET;
296 continue;
297 case SI:
298 mode &= ~ALTSET;
299 continue;
300 case IESC:
301 if (handle_escape(f)) {
302 c = getwc(f);
303 errx(EXIT_FAILURE,
304 _("unknown escape sequence in input: %o, %o"), IESC, c);
305 }
306 continue;
307 case '_':
308 if (obuf[col].c_char || obuf[col].c_width < 0) {
309 while (col > 0 && obuf[col].c_width < 0)
310 col--;
311 w = obuf[col].c_width;
312 for (i = 0; i < w; i++)
313 obuf[col++].c_mode |= UNDERL | mode;
314 setcol(col);
315 continue;
316 }
317 obuf[col].c_char = '_';
318 obuf[col].c_width = 1;
319 /* fallthrough */
320 case ' ':
321 setcol(col + 1);
322 continue;
323 case '\n':
324 flushln();
325 continue;
326 case '\f':
327 flushln();
328 putwchar('\f');
329 continue;
330 default:
331 if (!iswprint(c))
332 /* non printable */
333 continue;
334 w = wcwidth(c);
335 needcol(col + w);
336 if (obuf[col].c_char == '\0') {
337 obuf[col].c_char = c;
338 for (i = 0; i < w; i++)
339 obuf[col + i].c_mode = mode;
340 obuf[col].c_width = w;
341 for (i = 1; i < w; i++)
342 obuf[col + i].c_width = -1;
343 } else if (obuf[col].c_char == '_') {
344 obuf[col].c_char = c;
345 for (i = 0; i < w; i++)
346 obuf[col + i].c_mode |= UNDERL | mode;
347 obuf[col].c_width = w;
348 for (i = 1; i < w; i++)
349 obuf[col + i].c_width = -1;
350 } else if ((wint_t) obuf[col].c_char == c) {
351 for (i = 0; i < w; i++)
352 obuf[col + i].c_mode |= BOLD | mode;
353 } else {
354 w = obuf[col].c_width;
355 for (i = 0; i < w; i++)
356 obuf[col + i].c_mode = mode;
357 }
358 setcol(col + w);
359 continue;
360 }
361 }
362 if (maxcol)
363 flushln();
364 }
365
366 static void flushln(void)
367 {
368 int lastmode;
369 int i;
370 int hadmodes = 0;
371
372 lastmode = NORMAL;
373 for (i = 0; i < maxcol; i++) {
374 if (obuf[i].c_mode != lastmode) {
375 hadmodes++;
376 xsetmode(obuf[i].c_mode);
377 lastmode = obuf[i].c_mode;
378 }
379 if (obuf[i].c_char == '\0') {
380 if (upln) {
381 print_out(CURS_RIGHT);
382 } else
383 outc(' ', 1);
384 } else
385 outc(obuf[i].c_char, obuf[i].c_width);
386 if (obuf[i].c_width > 1)
387 i += obuf[i].c_width - 1;
388 }
389 if (lastmode != NORMAL) {
390 xsetmode(0);
391 }
392 if (must_overstrike && hadmodes)
393 overstrike();
394 putwchar('\n');
395 if (iflag && hadmodes)
396 iattr();
397 fflush(stdout);
398 if (upln)
399 upln--;
400 initbuf();
401 }
402
403 /*
404 * For terminals that can overstrike, overstrike underlines and bolds.
405 * We don't do anything with halfline ups and downs, or Greek.
406 */
407 static void overstrike(void)
408 {
409 register int i;
410 register wchar_t *lbuf = xcalloc(maxcol + 1, sizeof(wchar_t));
411 register wchar_t *cp = lbuf;
412 int hadbold=0;
413
414 /* Set up overstrike buffer */
415 for (i = 0; i < maxcol; i++)
416 switch (obuf[i].c_mode) {
417 case NORMAL:
418 default:
419 *cp++ = ' ';
420 break;
421 case UNDERL:
422 *cp++ = '_';
423 break;
424 case BOLD:
425 *cp++ = obuf[i].c_char;
426 if (obuf[i].c_width > 1)
427 i += obuf[i].c_width - 1;
428 hadbold=1;
429 break;
430 }
431 putwchar('\r');
432 for (*cp = ' '; *cp == ' '; cp--)
433 *cp = 0;
434 fputws(lbuf, stdout);
435 if (hadbold) {
436 putwchar('\r');
437 for (cp = lbuf; *cp; cp++)
438 putwchar(*cp == '_' ? ' ' : *cp);
439 putwchar('\r');
440 for (cp = lbuf; *cp; cp++)
441 putwchar(*cp == '_' ? ' ' : *cp);
442 }
443 free(lbuf);
444 }
445
446 static void iattr(void)
447 {
448 register int i;
449 register wchar_t *lbuf = xcalloc(maxcol + 1, sizeof(wchar_t));
450 register wchar_t *cp = lbuf;
451
452 for (i = 0; i < maxcol; i++)
453 switch (obuf[i].c_mode) {
454 case NORMAL: *cp++ = ' '; break;
455 case ALTSET: *cp++ = 'g'; break;
456 case SUPERSC: *cp++ = '^'; break;
457 case SUBSC: *cp++ = 'v'; break;
458 case UNDERL: *cp++ = '_'; break;
459 case BOLD: *cp++ = '!'; break;
460 default: *cp++ = 'X'; break;
461 }
462 for (*cp = ' '; *cp == ' '; cp--)
463 *cp = 0;
464 fputws(lbuf, stdout);
465 putwchar('\n');
466 free(lbuf);
467 }
468
469 static void initbuf(void)
470 {
471 if (obuf == NULL) {
472 /* First time. */
473 obuflen = BUFSIZ;
474 obuf = xcalloc(obuflen, sizeof(struct CHAR));
475 } else
476 /* assumes NORMAL == 0 */
477 memset(obuf, 0, sizeof(struct CHAR) * maxcol);
478
479 setcol(0);
480 maxcol = 0;
481 mode &= ALTSET;
482 }
483
484 static void fwd(void)
485 {
486 int oldcol, oldmax;
487
488 oldcol = col;
489 oldmax = maxcol;
490 flushln();
491 setcol(oldcol);
492 maxcol = oldmax;
493 }
494
495 static void reverse(void)
496 {
497 upln++;
498 fwd();
499 print_out(CURS_UP);
500 print_out(CURS_UP);
501 upln++;
502 }
503
504 static void initinfo(void)
505 {
506 CURS_UP = tigetstr("cuu1");
507 CURS_RIGHT = tigetstr("cuf1");
508 CURS_LEFT = tigetstr("cub1");
509 if (CURS_LEFT == NULL)
510 CURS_LEFT = "\b";
511
512 ENTER_STANDOUT = tigetstr("smso");
513 EXIT_STANDOUT = tigetstr("rmso");
514 ENTER_UNDERLINE = tigetstr("smul");
515 EXIT_UNDERLINE = tigetstr("rmul");
516 ENTER_DIM = tigetstr("dim");
517 ENTER_BOLD = tigetstr("bold");
518 ENTER_REVERSE = tigetstr("rev");
519 EXIT_ATTRIBUTES = tigetstr("sgr0");
520
521 if (!ENTER_BOLD && ENTER_REVERSE)
522 ENTER_BOLD = ENTER_REVERSE;
523 if (!ENTER_BOLD && ENTER_STANDOUT)
524 ENTER_BOLD = ENTER_STANDOUT;
525 if (!ENTER_UNDERLINE && ENTER_STANDOUT) {
526 ENTER_UNDERLINE = ENTER_STANDOUT;
527 EXIT_UNDERLINE = EXIT_STANDOUT;
528 }
529 if (!ENTER_DIM && ENTER_STANDOUT)
530 ENTER_DIM = ENTER_STANDOUT;
531 if (!ENTER_REVERSE && ENTER_STANDOUT)
532 ENTER_REVERSE = ENTER_STANDOUT;
533 if (!EXIT_ATTRIBUTES && EXIT_STANDOUT)
534 EXIT_ATTRIBUTES = EXIT_STANDOUT;
535
536 /*
537 * Note that we use REVERSE for the alternate character set,
538 * not the as/ae capabilities. This is because we are modeling
539 * the model 37 teletype (since that's what nroff outputs) and
540 * the typical as/ae is more of a graphics set, not the greek
541 * letters the 37 has.
542 */
543
544 UNDER_CHAR = tigetstr("uc");
545 must_use_uc = (UNDER_CHAR && !ENTER_UNDERLINE);
546 }
547
548 static int curmode = 0;
549
550 static void outc(wint_t c, int width) {
551 int i;
552
553 putwchar(c);
554 if (must_use_uc && (curmode&UNDERL)) {
555 for (i = 0; i < width; i++)
556 print_out(CURS_LEFT);
557 for (i = 0; i < width; i++)
558 print_out(UNDER_CHAR);
559 }
560 }
561
562 static void xsetmode(int newmode)
563 {
564 if (!iflag) {
565 if (curmode != NORMAL && newmode != NORMAL)
566 xsetmode(NORMAL);
567 switch (newmode) {
568 case NORMAL:
569 switch (curmode) {
570 case NORMAL:
571 break;
572 case UNDERL:
573 print_out(EXIT_UNDERLINE);
574 break;
575 default:
576 /* This includes standout */
577 print_out(EXIT_ATTRIBUTES);
578 break;
579 }
580 break;
581 case ALTSET:
582 print_out(ENTER_REVERSE);
583 break;
584 case SUPERSC:
585 /*
586 * This only works on a few terminals.
587 * It should be fixed.
588 */
589 print_out(ENTER_UNDERLINE);
590 print_out(ENTER_DIM);
591 break;
592 case SUBSC:
593 print_out(ENTER_DIM);
594 break;
595 case UNDERL:
596 print_out(ENTER_UNDERLINE);
597 break;
598 case BOLD:
599 print_out(ENTER_BOLD);
600 break;
601 default:
602 /*
603 * We should have some provision here for multiple modes
604 * on at once. This will have to come later.
605 */
606 print_out(ENTER_STANDOUT);
607 break;
608 }
609 }
610 curmode = newmode;
611 }
612
613 static void setcol(int newcol) {
614 col = newcol;
615
616 if (col < 0)
617 col = 0;
618 else if (col > maxcol)
619 needcol(col);
620 }
621
622 static void needcol(int acol) {
623 maxcol = acol;
624
625 /* If col >= obuflen, expand obuf until obuflen > col. */
626 while (acol >= obuflen) {
627 /* Paranoid check for obuflen == INT_MAX. */
628 if (obuflen == INT_MAX)
629 errx(EXIT_FAILURE, _("Input line too long."));
630
631 /* Similar paranoia: double only up to INT_MAX. */
632 if (obuflen < (INT_MAX / 2))
633 obuflen *= 2;
634 else
635 obuflen = INT_MAX;
636
637 /* Now we can try to expand obuf. */
638 obuf = xrealloc(obuf, sizeof(struct CHAR) * obuflen);
639 }
640 }
641
642 static void sig_handler(int signo __attribute__ ((__unused__)))
643 {
644 _exit(EXIT_SUCCESS);
645 }
646
647 static void print_out(char *line)
648 {
649 if (line == NULL)
650 return;
651
652 putwp(line);
653 }