usr/src/cmd/col/col.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  28 /*        All Rights Reserved   */
  29
  30 /*
  31  *      col - filter reverse carraige motions
  32  *
  33  */
  34
  35
  36 #include <stdio.h>
  37 #include <ctype.h>
  38 #include <locale.h>
  39 #include <limits.h>
  40 #include <stdlib.h>
  41 #include <wctype.h>
  42
  43 #define PL 256
  44 #define ESC '\033'
  45 #define RLF '\013'
  46 #define SI '\017'
  47 #define SO '\016'
  48 #define GREEK 0200
  49 #define LINELN 4096
  50
  51 wchar_t *page[PL];
  52 wchar_t lbuff[LINELN], *line;
  53 wchar_t *lbuffend = lbuff + LINELN - 1;
  54 wchar_t ws_blank[2] = {' ', 0};
  55 char    esc_chars, underline, temp_off, smart;
  56 int     bflag, xflag, fflag, pflag;
  57 int     greeked;
  58 int     half;
  59 int     cp, lp;
  60 int     ll, llh, mustwr;
  61 int     pcp = 0;
  62 char    *pgmname;
  63
  64 #define USAGEMSG        "usage:\tcol [-bfxp]\n"
  65
  66 static void     outc(wchar_t);
  67 static void     store(int);
  68 static void     fetch(int);
  69 static void     emit(wchar_t *, int);
  70 static void     incr(void);
  71 static void     decr(void);
  72 static void     wsinsert(wchar_t *, int);
  73 static void     incr_line(int);
  74 static int      wcscrwidth(wchar_t);
  75
  76 int
  77 main(int argc, char **argv)
  78 {
  79         int     i, n;
  80         int     opt;
  81         int     greek;
  82         int     c;
  83         wchar_t wc;
  84         char    byte;
  85         static char     fbuff[BUFSIZ];
  86
  87         setbuf(stdout, fbuff);
  88         (void) setlocale(LC_ALL, "");
  89 #if !defined(TEXT_DOMAIN)
  90 #define TEXT_DOMAIN "SYS_TEST"
  91 #endif
  92         (void) textdomain(TEXT_DOMAIN);
  93         pgmname = argv[0];
  94
  95         while ((opt = getopt(argc, argv, "bfxp")) != EOF)
  96                 switch (opt) {
  97                 case 'b':
  98                         bflag++;
  99                         break;
 100                 case 'x':
 101                         xflag++;
 102                         break;
 103                 case 'f':
 104                         fflag++;
 105                         break;
 106                 case 'p':
 107                         pflag++;
 108                         break;
 109                 case '?':
 110                 default:
 111                         (void) fprintf(stderr, gettext(USAGEMSG));
 112                         exit(2);
 113                 }
 114
 115         argc -= optind;
 116         if (argc >= 1) {
 117                 (void) fprintf(stderr, gettext(USAGEMSG));
 118                 exit(2);
 119         }
 120
 121         for (ll = 0; ll < PL; ll++)
 122                 page[ll] = 0;
 123
 124         smart = temp_off = underline = esc_chars = '\0';
 125         cp = 0;
 126         ll = 0;
 127         greek = 0;
 128         mustwr = PL;
 129         line = lbuff;
 130
 131         while ((c = getwchar()) != EOF) {
 132                 if (underline && temp_off && c > ' ') {
 133                         outc(ESC);
 134                         if (*line) {
 135                                 incr_line(1);
 136                         }
 137                         *line = 'X';
 138                         incr_line(1);
 139                         *line = temp_off = '\0';
 140                 }
 141                 if (c != '\b')
 142                         if (esc_chars)
 143                                 esc_chars = '\0';
 144                 switch (c) {
 145                 case '\n':
 146                         if (underline && !temp_off) {
 147                                 if (*line)
 148                                         incr_line(1);
 149                                 *line = ESC;
 150                                 incr_line(1);
 151                                 *line = 'Y';
 152                                 incr_line(1);
 153                                 *line = '\0';
 154                                 temp_off = '1';
 155                         }
 156                         incr();
 157                         incr();
 158                         cp = 0;
 159                         continue;
 160
 161                 case '\0':
 162                         continue;
 163
 164                 case ESC:
 165                         c = getwchar();
 166                         switch (c) {
 167                         case '7':       /* reverse full line feed */
 168                                 decr();
 169                                 decr();
 170                                 break;
 171
 172                         case '8':       /* reverse half line feed */
 173                                 if (fflag)
 174                                         decr();
 175                                 else {
 176                                         if (--half < -1) {
 177                                                 decr();
 178                                                 decr();
 179                                                 half += 2;
 180                                         }
 181                                 }
 182                                 break;
 183
 184                         case '9':       /* forward half line feed */
 185                                 if (fflag)
 186                                         incr();
 187                                 else {
 188                                         if (++half > 0) {
 189                                                 incr();
 190                                                 incr();
 191                                                 half -= 2;
 192                                         }
 193                                 }
 194                                 break;
 195
 196                         default:
 197                                 if (pflag)      {       /* pass through esc */
 198                                         outc(ESC);
 199                                         incr_line(1);
 200                                         *line = c;
 201                                         incr_line(1);
 202                                         *line = '\0';
 203                                         esc_chars = 1;
 204                                         if (c == 'X')
 205                                                 underline = 1;
 206                                         if (c == 'Y' && underline)
 207                                                 underline = temp_off = '\0';
 208                                         if (c == ']')
 209                                                 smart = 1;
 210                                         if (c == '[')
 211                                                 smart = '\0';
 212                                         }
 213                                 break;
 214                         }
 215                         continue;
 216
 217                 case SO:
 218                         greek = GREEK;
 219                         greeked++;
 220                         continue;
 221
 222                 case SI:
 223                         greek = 0;
 224                         continue;
 225
 226                 case RLF:
 227                         decr();
 228                         decr();
 229                         continue;
 230
 231                 case '\r':
 232                         cp = 0;
 233                         continue;
 234
 235                 case '\t':
 236                         cp = (cp + 8) & -8;
 237                         continue;
 238
 239                 case '\b':
 240                         if (esc_chars) {
 241                                 *line = '\b';
 242                                 incr_line(1);
 243                                 *line = '\0';
 244                         } else if (cp > 0)
 245                                 cp--;
 246                         continue;
 247
 248                 case ' ':
 249                         cp++;
 250                         continue;
 251
 252                 default:
 253                         if (iswprint(c)) {      /* if printable */
 254                                 if (!greek) {
 255                                         outc((wchar_t)c);
 256                                         cp += wcscrwidth(c);
 257                                 }
 258                                 /*
 259                                  * EUC (apply SO only when there can
 260                                  * be corresponding character in CS1)
 261                                  */
 262                                 else if (iswascii(c)) {
 263                                         byte = (c | greek);
 264                                         n = mbtowc(&wc, &byte, 1);
 265                                         if (!iswcntrl(c) && !iswspace(c) &&
 266                                             n == 1) {
 267                                                 outc(wc);
 268                                                 cp += wcscrwidth(wc);
 269                                         } else {
 270                                                 outc((wchar_t)c);
 271                                                 cp += wcscrwidth(c);
 272                                         }
 273                                 } else {
 274                                         outc((wchar_t)c);
 275                                         cp += wcscrwidth(c);
 276                                 }
 277
 278                                 if ((cp + 1) > LINELN) {
 279                                         (void) fprintf(stderr,
 280                                             gettext("col: Line too long\n"));
 281                                         exit(2);
 282                                 }
 283                         }
 284                         continue;
 285                 }
 286         }
 287
 288         for (i = 0; i < PL; i++)
 289                 if (page[(mustwr+i)%PL] != 0)
 290                         emit(page[(mustwr+i) % PL], mustwr+i-PL);
 291         emit(ws_blank, (llh + 1) & -2);
 292         return (0);
 293 }
 294
 295 static void
 296 outc(wchar_t c)
 297 {
 298         int     n, i;
 299         int     width, widthl, widthc;
 300         wchar_t *p1;
 301         wchar_t c1;
 302         char esc_chars = '\0';
 303         if (lp > cp) {
 304                 line = lbuff;
 305                 lp = 0;
 306         }
 307
 308         while (lp < cp) {
 309                 if (*line != '\b')
 310                         if (esc_chars)
 311                                 esc_chars = '\0';
 312                 switch (*line)  {
 313                 case ESC:
 314                         incr_line(1);
 315                         esc_chars = 1;
 316                         break;
 317                 case '\0':
 318                         *line = ' ';
 319                         lp++;
 320                         break;
 321                 case '\b':
 322                         /* if ( ! esc_chars ) */
 323                         lp--;
 324                         break;
 325                 default:
 326                         lp += wcscrwidth(*line);
 327                 }
 328                 incr_line(1);
 329         }
 330         while (*line == '\b') {
 331                 /*
 332                  * EUC (For a multi-column character, backspace characters
 333                  * are assumed to be used like "__^H^HXX", where "XX"
 334                  * represents a two-column character, and a backspace
 335                  * always goes back by one column.)
 336                  */
 337                 for (n = 0; *line == '\b'; incr_line(1)) {
 338                         n++;
 339                         lp--;
 340                 }
 341                 while (n > 0 && lp < cp) {
 342                         i = *line;
 343                         incr_line(1);
 344                         i = wcscrwidth(i);
 345                         n -= i;
 346                         lp += i;
 347                 }
 348         }
 349         while (*line == ESC)
 350                 incr_line(6);
 351         widthc = wcscrwidth(c);
 352         widthl = wcscrwidth(*line);
 353         if (bflag || (*line == '\0') || *line == ' ') {
 354                 if (*line == '\0' || widthl == widthc) {
 355                         *line = c;
 356                 } else if (widthl > widthc) {
 357                         n = widthl - widthc;
 358                         wsinsert(line, n);
 359                         *line = c;
 360                         incr_line(1);
 361                         for (i = 0; i < n; i++) {
 362                                 *line = ' ';
 363                                 incr_line(1);
 364                         }
 365                         line = lbuff;
 366                         lp = 0;
 367                 } else {
 368                         n = widthc - widthl;
 369                         if (line < lbuffend) {
 370                                 for (p1 = line+1; n > 0 && p1 < lbuffend;
 371                                     n -= wcscrwidth(i)) {
 372                                                 i = *p1++;
 373                                 }
 374                                 *line = c;
 375                                 if (p1 < lbuffend) {
 376                                         (void) wcscpy(line+1, p1);
 377                                 } else {
 378                                         (void) fprintf(stderr,
 379                                             gettext("col: Line too long.\n"));
 380                                         exit(1);
 381                                 }
 382                         } else {
 383                                 (void) fprintf(stderr,
 384                                     gettext("col: Line too long.\n"));
 385                                 exit(1);
 386                         }
 387                 }
 388         } else {
 389                 if (smart && (widthl == 1) && (widthc == 1)) {
 390                         wchar_t c1, c2, c3, c4, c5, c6, c7;
 391                         incr_line(1);
 392                         c1 = *line;
 393                         *line = ESC;
 394                         incr_line(1);
 395                         c2 = *line;
 396                         *line = '[';
 397                         incr_line(1);
 398                         c3 = *line;
 399                         *line = '\b';
 400                         incr_line(1);
 401                         c4 = *line;
 402                         *line = ESC;
 403                         incr_line(1);
 404                         c5 = *line;
 405                         *line = ']';
 406                         incr_line(1);
 407                         c6 = *line;
 408                         *line = c;
 409                         incr_line(1);
 410                         while (c1) {
 411                                 c7 = *line;
 412                                 *line = c1;
 413                                 incr_line(1);
 414                                 c1 = c2;
 415                                 c2 = c3;
 416                                 c3 = c4;
 417                                 c4 = c5;
 418                                 c5 = c6;
 419                                 c6 = c7;
 420                         }
 421                 } else  {
 422                         if ((widthl == 1) && (widthc == 1)) {
 423                                 wchar_t c1, c2, c3;
 424                                 incr_line(1);
 425                                 c1 = *line;
 426                                 *line = '\b';
 427                                 incr_line(1);
 428                                 c2 = *line;
 429                                 *line = c;
 430                                 incr_line(1);
 431                                 while (c1) {
 432                                         c3 = *line;
 433                                         *line = c1;
 434                                         incr_line(1);
 435                                         c1 = c2;
 436                                         c2 = c3;
 437                                 }
 438                         } else {
 439                                 width = (widthc > widthl) ? widthc : widthl;
 440                                 for (i = 0; i < width; i += wcscrwidth(c1)) {
 441                                         c1 = *line;
 442                                         incr_line(1);
 443                                 }
 444                                 wsinsert(line, width + (width - widthc + 1));
 445                                 for (i = 0; i < width; i++) {
 446                                         *line = '\b';
 447                                         incr_line(1);
 448                                 }
 449                                 *line = c;
 450                                 incr_line(1);
 451                                 for (i = widthc; i < width; i++) {
 452                                         *line = ' ';
 453                                         incr_line(1);
 454                                 }
 455                         }
 456                 }
 457                 lp = 0;
 458                 line = lbuff;
 459         }
 460 }
 461
 462 static void
 463 store(int lno)
 464 {
 465         lno %= PL;
 466         if (page[lno] != 0)
 467                 free((char *)page[lno]);
 468         page[lno] = (wchar_t *)malloc((unsigned)(wcslen(lbuff) + 2)
 469             * sizeof (wchar_t));
 470         if (page[lno] == 0) {
 471                 /* fprintf(stderr, "%s: no storage\n", pgmname); */
 472                 exit(2);
 473         }
 474         (void) wcscpy(page[lno], lbuff);
 475 }
 476
 477 static void
 478 fetch(int lno)
 479 {
 480         wchar_t *p;
 481
 482         lno %= PL;
 483         p = lbuff;
 484         while (*p)
 485                 *p++ = '\0';
 486         line = lbuff;
 487         lp = 0;
 488         if (page[lno])
 489                 (void) wcscpy(line, page[lno]);
 490 }
 491
 492 static void
 493 emit(wchar_t *s, int lineno)
 494 {
 495         static int      cline = 0;
 496         int     ncp;
 497         wchar_t *p;
 498         char    cshifted;
 499         char    chr[MB_LEN_MAX + 1];
 500
 501         int     c;
 502         static int      gflag = 0;
 503
 504         if (*s) {
 505                 if (gflag) {
 506                         (void) putchar(SI);
 507                         gflag = 0;
 508                 }
 509                 while (cline < lineno - 1) {
 510                         (void) putchar('\n');
 511                         pcp = 0;
 512                         cline += 2;
 513                 }
 514                 if (cline != lineno) {
 515                         (void) putchar(ESC);
 516                         (void) putchar('9');
 517                         cline++;
 518                 }
 519                 if (pcp)
 520                         (void) putchar('\r');
 521                 pcp = 0;
 522                 p = s;
 523                 while (*p) {
 524                         ncp = pcp;
 525                         while (*p++ == ' ') {
 526                                 if ((++ncp & 7) == 0 && !xflag) {
 527                                         pcp = ncp;
 528                                         (void) putchar('\t');
 529                                 }
 530                         }
 531                         if (!*--p)
 532                                 break;
 533                         while (pcp < ncp) {
 534                                 (void) putchar(' ');
 535                                 pcp++;
 536                         }
 537                         if (greeked) {
 538                                 if (wctomb(chr, *p) == 1) {
 539                                         if (gflag != (*chr & GREEK) &&
 540                                             *p != '\b' &&
 541                                             isascii(*chr ^ (gflag ^ GREEK)) &&
 542                                             !iscntrl(*chr ^ (gflag ^ GREEK)) &&
 543                                             !isspace(*chr ^ (gflag ^ GREEK))) {
 544                                                 if (gflag)
 545                                                         (void) putchar(SI);
 546                                                 else
 547                                                         (void) putchar(SO);
 548                                                 gflag ^= GREEK;
 549                                         }
 550                                 }
 551                         }
 552                         c = *p;
 553                         if (greeked) {
 554                                 if (wctomb(chr, (wchar_t)c) == 1) {
 555                                         cshifted = (*chr ^ GREEK);
 556                                         if (isascii(cshifted) &&
 557                                             !iscntrl(cshifted) &&
 558                                             !isspace(cshifted))
 559                                                 (void) putchar(*chr & ~GREEK);
 560                                 } else
 561                                         (void) putwchar(c);
 562                         } else
 563                                 (void) putwchar(c);
 564                         if (c == '\b') {
 565                                 if (*(p-2) && *(p-2) == ESC) {
 566                                         pcp++;
 567                                 } else
 568                                         pcp--;
 569                         } else {
 570                                 pcp += wcscrwidth(c);
 571                         }
 572                         p++;
 573                 }
 574         }
 575 }
 576
 577 static void
 578 incr(void)
 579 {
 580         store(ll++);
 581         if (ll > llh)
 582                 llh = ll;
 583         if (ll >= mustwr && page[ll%PL]) {
 584                 emit(page[ll%PL], ll - PL);
 585                 mustwr++;
 586                 free((char *)page[ll%PL]);
 587                 page[ll%PL] = 0;
 588         }
 589         fetch(ll);
 590 }
 591
 592 static void
 593 decr(void)
 594 {
 595         if (ll > mustwr - PL) {
 596                 store(ll--);
 597                 fetch(ll);
 598         }
 599 }
 600
 601 static void
 602 wsinsert(wchar_t *s, int n)
 603 {
 604         wchar_t *p1, *p2;
 605
 606
 607         p1 = s + wcslen(s);
 608         p2 = p1 + n;
 609         while (p1 >= s)
 610                 *p2-- = *p1--;
 611 }
 612
 613 /*
 614  * incr_line - increments line pointer and checks for array out of bounds
 615  * amt: assumed to be >= 1
 616  * exit on error to avoid line pointer accessing out of the array
 617  */
 618 static void
 619 incr_line(int amt)
 620 {
 621         if (line < lbuffend - amt + 1) {
 622                 line += amt;
 623         } else {
 624                 (void) fprintf(stderr, gettext("col: Line too long.\n"));
 625                 exit(1);
 626         }
 627 }
 628
 629
 630 static int
 631 wcscrwidth(wchar_t wc)
 632 {
 633         int     nc;
 634
 635         if (wc == 0) {
 636                 /*
 637                  * if wc is a null character, needs to
 638                  * return 1 instead of 0.
 639                  */
 640                 return (1);
 641         }
 642         nc = wcwidth(wc);
 643         if (nc > 0) {
 644                 return (nc);
 645         } else {
 646                 return (0);
 647         }
 648 }