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 * 4. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * @(#) Copyright (c) 1980, 1993 The Regents of the University of California. All rights reserved. 30 * @(#)ul.c 8.1 (Berkeley) 6/6/93 31 * $FreeBSD: src/usr.bin/ul/ul.c,v 1.6.2.1 2000/08/23 08:49:49 kris Exp $ 32 * $DragonFly: src/usr.bin/ul/ul.c,v 1.4 2005/01/05 02:40:23 cpressey Exp $ 33 */ 34 35 #include <err.h> 36 #include <stdio.h> 37 #include <stdlib.h> 38 #include <string.h> 39 #include <termcap.h> 40 #include <unistd.h> 41 42 #define IESC '\033' 43 #define SO '\016' 44 #define SI '\017' 45 #define HFWD '9' 46 #define HREV '8' 47 #define FREV '7' 48 #define MAXBUF 512 49 50 #define NORMAL 000 51 #define ALTSET 001 /* Reverse */ 52 #define SUPERSC 002 /* Dim */ 53 #define SUBSC 004 /* Dim | Ul */ 54 #define UNDERL 010 /* Ul */ 55 #define BOLD 020 /* Bold */ 56 57 int must_use_uc, must_overstrike; 58 const char *CURS_UP, *CURS_RIGHT, *CURS_LEFT, 59 *ENTER_STANDOUT, *EXIT_STANDOUT, *ENTER_UNDERLINE, *EXIT_UNDERLINE, 60 *ENTER_DIM, *ENTER_BOLD, *ENTER_REVERSE, *UNDER_CHAR, *EXIT_ATTRIBUTES; 61 62 struct CHAR { 63 char c_mode; 64 char c_char; 65 } ; 66 67 struct CHAR obuf[MAXBUF]; 68 int col, maxcol; 69 int mode; 70 int halfpos; 71 int upln; 72 int iflag; 73 74 static void usage(void); 75 void setnewmode(int); 76 void initcap(void); 77 void reverse(void); 78 int outchar(int); 79 void fwd(void); 80 void initbuf(void); 81 void iattr(void); 82 void overstrike(void); 83 void flushln(void); 84 void filter(FILE *); 85 void outc(int); 86 87 #define PRINT(s) if (s == NULL) /* void */; else tputs(s, 1, outchar) 88 89 int 90 main(int argc, char **argv) 91 { 92 int c; 93 const char *termtype; 94 FILE *f; 95 char termcap[1024]; 96 97 termtype = getenv("TERM"); 98 if (termtype == NULL || (argv[0][0] == 'c' && !isatty(1))) 99 termtype = "lpr"; 100 while ((c=getopt(argc, argv, "it:T:")) != -1) 101 switch(c) { 102 103 case 't': 104 case 'T': /* for nroff compatibility */ 105 termtype = optarg; 106 break; 107 case 'i': 108 iflag = 1; 109 break; 110 default: 111 usage(); 112 } 113 114 switch(tgetent(termcap, termtype)) { 115 116 case 1: 117 break; 118 119 default: 120 warnx("trouble reading termcap"); 121 /* fall through to ... */ 122 123 case 0: 124 /* No such terminal type - assume dumb */ 125 (void)strcpy(termcap, "dumb:os:col#80:cr=^M:sf=^J:am:"); 126 break; 127 } 128 initcap(); 129 if ( (tgetflag("os") && ENTER_BOLD==NULL ) || 130 (tgetflag("ul") && ENTER_UNDERLINE==NULL && UNDER_CHAR==NULL)) 131 must_overstrike = 1; 132 initbuf(); 133 if (optind == argc) 134 filter(stdin); 135 else for (; optind<argc; optind++) { 136 f = fopen(argv[optind],"r"); 137 if (f == NULL) 138 err(1, "%s", argv[optind]); 139 else 140 filter(f); 141 } 142 exit(0); 143 } 144 145 static void 146 usage(void) 147 { 148 fprintf(stderr, "usage: ul [-i] [-t terminal] file...\n"); 149 exit(1); 150 } 151 152 void 153 filter(FILE *f) 154 { 155 int c; 156 157 while ((c = getc(f)) != EOF && col < MAXBUF) switch(c) { 158 159 case '\b': 160 if (col > 0) 161 col--; 162 continue; 163 164 case '\t': 165 col = (col+8) & ~07; 166 if (col > maxcol) 167 maxcol = col; 168 continue; 169 170 case '\r': 171 col = 0; 172 continue; 173 174 case SO: 175 mode |= ALTSET; 176 continue; 177 178 case SI: 179 mode &= ~ALTSET; 180 continue; 181 182 case IESC: 183 switch (c = getc(f)) { 184 185 case HREV: 186 if (halfpos == 0) { 187 mode |= SUPERSC; 188 halfpos--; 189 } else if (halfpos > 0) { 190 mode &= ~SUBSC; 191 halfpos--; 192 } else { 193 halfpos = 0; 194 reverse(); 195 } 196 continue; 197 198 case HFWD: 199 if (halfpos == 0) { 200 mode |= SUBSC; 201 halfpos++; 202 } else if (halfpos < 0) { 203 mode &= ~SUPERSC; 204 halfpos++; 205 } else { 206 halfpos = 0; 207 fwd(); 208 } 209 continue; 210 211 case FREV: 212 reverse(); 213 continue; 214 215 default: 216 errx(1, "unknown escape sequence in input: %o, %o", IESC, c); 217 } 218 continue; 219 220 case '_': 221 if (obuf[col].c_char) 222 obuf[col].c_mode |= UNDERL | mode; 223 else 224 obuf[col].c_char = '_'; 225 case ' ': 226 col++; 227 if (col > maxcol) 228 maxcol = col; 229 continue; 230 231 case '\n': 232 flushln(); 233 continue; 234 235 case '\f': 236 flushln(); 237 putchar('\f'); 238 continue; 239 240 default: 241 if (c < ' ') /* non printing */ 242 continue; 243 if (obuf[col].c_char == '\0') { 244 obuf[col].c_char = c; 245 obuf[col].c_mode = mode; 246 } else if (obuf[col].c_char == '_') { 247 obuf[col].c_char = c; 248 obuf[col].c_mode |= UNDERL|mode; 249 } else if (obuf[col].c_char == c) 250 obuf[col].c_mode |= BOLD|mode; 251 else 252 obuf[col].c_mode = mode; 253 col++; 254 if (col > maxcol) 255 maxcol = col; 256 continue; 257 } 258 if (maxcol) 259 flushln(); 260 } 261 262 void 263 flushln(void) 264 { 265 int lastmode; 266 int i; 267 int hadmodes = 0; 268 269 lastmode = NORMAL; 270 for (i=0; i<maxcol; i++) { 271 if (obuf[i].c_mode != lastmode) { 272 hadmodes++; 273 setnewmode(obuf[i].c_mode); 274 lastmode = obuf[i].c_mode; 275 } 276 if (obuf[i].c_char == '\0') { 277 if (upln) 278 PRINT(CURS_RIGHT); 279 else 280 outc(' '); 281 } else 282 outc(obuf[i].c_char); 283 } 284 if (lastmode != NORMAL) { 285 setnewmode(0); 286 } 287 if (must_overstrike && hadmodes) 288 overstrike(); 289 putchar('\n'); 290 if (iflag && hadmodes) 291 iattr(); 292 (void)fflush(stdout); 293 if (upln) 294 upln--; 295 initbuf(); 296 } 297 298 /* 299 * For terminals that can overstrike, overstrike underlines and bolds. 300 * We don't do anything with halfline ups and downs, or Greek. 301 */ 302 void 303 overstrike(void) 304 { 305 int i; 306 char lbuf[256]; 307 char *cp = lbuf; 308 int hadbold=0; 309 310 /* Set up overstrike buffer */ 311 for (i=0; i<maxcol; i++) 312 switch (obuf[i].c_mode) { 313 case NORMAL: 314 default: 315 *cp++ = ' '; 316 break; 317 case UNDERL: 318 *cp++ = '_'; 319 break; 320 case BOLD: 321 *cp++ = obuf[i].c_char; 322 hadbold=1; 323 break; 324 } 325 putchar('\r'); 326 for (*cp=' '; *cp==' '; cp--) 327 *cp = 0; 328 for (cp=lbuf; *cp; cp++) 329 putchar(*cp); 330 if (hadbold) { 331 putchar('\r'); 332 for (cp=lbuf; *cp; cp++) 333 putchar(*cp=='_' ? ' ' : *cp); 334 putchar('\r'); 335 for (cp=lbuf; *cp; cp++) 336 putchar(*cp=='_' ? ' ' : *cp); 337 } 338 } 339 340 void 341 iattr(void) 342 { 343 int i; 344 char lbuf[256]; 345 char *cp = lbuf; 346 347 for (i=0; i<maxcol; i++) 348 switch (obuf[i].c_mode) { 349 case NORMAL: *cp++ = ' '; break; 350 case ALTSET: *cp++ = 'g'; break; 351 case SUPERSC: *cp++ = '^'; break; 352 case SUBSC: *cp++ = 'v'; break; 353 case UNDERL: *cp++ = '_'; break; 354 case BOLD: *cp++ = '!'; break; 355 default: *cp++ = 'X'; break; 356 } 357 for (*cp=' '; *cp==' '; cp--) 358 *cp = 0; 359 for (cp=lbuf; *cp; cp++) 360 putchar(*cp); 361 putchar('\n'); 362 } 363 364 void 365 initbuf(void) 366 { 367 368 bzero((char *)obuf, sizeof (obuf)); /* depends on NORMAL == 0 */ 369 col = 0; 370 maxcol = 0; 371 mode &= ALTSET; 372 } 373 374 void 375 fwd(void) 376 { 377 int oldcol, oldmax; 378 379 oldcol = col; 380 oldmax = maxcol; 381 flushln(); 382 col = oldcol; 383 maxcol = oldmax; 384 } 385 386 void 387 reverse(void) 388 { 389 upln++; 390 fwd(); 391 PRINT(CURS_UP); 392 PRINT(CURS_UP); 393 upln++; 394 } 395 396 void 397 initcap(void) 398 { 399 static char tcapbuf[512]; 400 char *bp = tcapbuf; 401 402 /* This nonsense attempts to work with both old and new termcap */ 403 CURS_UP = tgetstr("up", &bp); 404 CURS_RIGHT = tgetstr("ri", &bp); 405 if (CURS_RIGHT == NULL) 406 CURS_RIGHT = tgetstr("nd", &bp); 407 CURS_LEFT = tgetstr("le", &bp); 408 if (CURS_LEFT == NULL) 409 CURS_LEFT = tgetstr("bc", &bp); 410 if (CURS_LEFT == NULL && tgetflag("bs")) 411 CURS_LEFT = "\b"; 412 413 ENTER_STANDOUT = tgetstr("so", &bp); 414 EXIT_STANDOUT = tgetstr("se", &bp); 415 ENTER_UNDERLINE = tgetstr("us", &bp); 416 EXIT_UNDERLINE = tgetstr("ue", &bp); 417 ENTER_DIM = tgetstr("mh", &bp); 418 ENTER_BOLD = tgetstr("md", &bp); 419 ENTER_REVERSE = tgetstr("mr", &bp); 420 EXIT_ATTRIBUTES = tgetstr("me", &bp); 421 422 if (!ENTER_BOLD && ENTER_REVERSE) 423 ENTER_BOLD = ENTER_REVERSE; 424 if (!ENTER_BOLD && ENTER_STANDOUT) 425 ENTER_BOLD = ENTER_STANDOUT; 426 if (!ENTER_UNDERLINE && ENTER_STANDOUT) { 427 ENTER_UNDERLINE = ENTER_STANDOUT; 428 EXIT_UNDERLINE = EXIT_STANDOUT; 429 } 430 if (!ENTER_DIM && ENTER_STANDOUT) 431 ENTER_DIM = ENTER_STANDOUT; 432 if (!ENTER_REVERSE && ENTER_STANDOUT) 433 ENTER_REVERSE = ENTER_STANDOUT; 434 if (!EXIT_ATTRIBUTES && EXIT_STANDOUT) 435 EXIT_ATTRIBUTES = EXIT_STANDOUT; 436 437 /* 438 * Note that we use REVERSE for the alternate character set, 439 * not the as/ae capabilities. This is because we are modelling 440 * the model 37 teletype (since that's what nroff outputs) and 441 * the typical as/ae is more of a graphics set, not the greek 442 * letters the 37 has. 443 */ 444 445 UNDER_CHAR = tgetstr("uc", &bp); 446 must_use_uc = (UNDER_CHAR && !ENTER_UNDERLINE); 447 } 448 449 int 450 outchar(int c) 451 { 452 return(putchar(c & 0177)); 453 } 454 455 static int curmode = 0; 456 457 void 458 outc(int c) 459 { 460 putchar(c); 461 if (must_use_uc && (curmode&UNDERL)) { 462 PRINT(CURS_LEFT); 463 PRINT(UNDER_CHAR); 464 } 465 } 466 467 void 468 setnewmode(int newmode) 469 { 470 if (!iflag) { 471 if (curmode != NORMAL && newmode != NORMAL) 472 setnewmode(NORMAL); 473 switch (newmode) { 474 case NORMAL: 475 switch(curmode) { 476 case NORMAL: 477 break; 478 case UNDERL: 479 PRINT(EXIT_UNDERLINE); 480 break; 481 default: 482 /* This includes standout */ 483 PRINT(EXIT_ATTRIBUTES); 484 break; 485 } 486 break; 487 case ALTSET: 488 PRINT(ENTER_REVERSE); 489 break; 490 case SUPERSC: 491 /* 492 * This only works on a few terminals. 493 * It should be fixed. 494 */ 495 PRINT(ENTER_UNDERLINE); 496 PRINT(ENTER_DIM); 497 break; 498 case SUBSC: 499 PRINT(ENTER_DIM); 500 break; 501 case UNDERL: 502 PRINT(ENTER_UNDERLINE); 503 break; 504 case BOLD: 505 PRINT(ENTER_BOLD); 506 break; 507 default: 508 /* 509 * We should have some provision here for multiple modes 510 * on at once. This will have to come later. 511 */ 512 PRINT(ENTER_STANDOUT); 513 break; 514 } 515 } 516 curmode = newmode; 517 } 518