usr.bin/fmt/fmt.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 #ifndef lint
  35 static char copyright[] =
  36 "@(#) Copyright (c) 1980, 1993\n\
  37         The Regents of the University of California.  All rights reserved.\n";
  38 #endif /* not lint */
  39
  40 #ifndef lint
  41 #if 0
  42 static char sccsid[] = "@(#)fmt.c       8.1 (Berkeley) 7/20/93";
  43 #else
  44 static const char rcsid[] =
  45   "$FreeBSD$";
  46 #endif
  47 #endif /* not lint */
  48
  49 #include <ctype.h>
  50 #include <err.h>
  51 #include <locale.h>
  52 #include <stdio.h>
  53 #include <stdlib.h>
  54 #include <string.h>
  55
  56 /*
  57  * fmt -- format the concatenation of input files or standard input
  58  * onto standard output.  Designed for use with Mail ~|
  59  *
  60  * Syntax : fmt [ goal [ max ] ] [ name ... ]
  61  * Authors: Kurt Shoens (UCB) 12/7/78;
  62  *          Liz Allen (UMCP) 2/24/83 [Addition of goal length concept].
  63  */
  64
  65 /* LIZ@UOM 6/18/85 -- Don't need LENGTH any more.
  66  * #define      LENGTH  72              Max line length in output
  67  */
  68 #define NOSTR   ((char *) 0)    /* Null string pointer for lint */
  69
  70 /* LIZ@UOM 6/18/85 --New variables goal_length and max_length */
  71 #define GOAL_LENGTH 65
  72 #define MAX_LENGTH 75
  73 int     goal_length;            /* Target or goal line length in output */
  74 int     max_length;             /* Max line length in output */
  75 int     pfx;                    /* Current leading blank count */
  76 int     lineno;                 /* Current input line */
  77 int     mark;                   /* Last place we saw a head line */
  78 int     center;
  79
  80 char    *headnames[] = {"To", "Subject", "Cc", 0};
  81
  82 void fmt __P((FILE *));
  83 int ispref __P((char *, char *));
  84 void leadin __P((void));
  85 void oflush __P((void));
  86 void pack __P((char [], int));
  87 void prefix __P((char []));
  88 void setout __P((void));
  89 void split __P((char []));
  90 void tabulate __P((char []));
  91
  92 /*
  93  * Drive the whole formatter by managing input files.  Also,
  94  * cause initialization of the output stuff and flush it out
  95  * at the end.
  96  */
  97
  98 int
  99 main(argc, argv)
 100         int argc;
 101         char **argv;
 102 {
 103         register FILE *fi;
 104         register int errs = 0;
 105         int number;             /* LIZ@UOM 6/18/85 */
 106
 107         (void) setlocale(LC_CTYPE, "");
 108
 109         goal_length = GOAL_LENGTH;
 110         max_length = MAX_LENGTH;
 111         setout();
 112         lineno = 1;
 113         mark = -10;
 114         /*
 115          * LIZ@UOM 6/18/85 -- Check for goal and max length arguments
 116          */
 117         if (argc > 1 && !strcmp(argv[1], "-c")) {
 118                 center++;
 119                 argc--;
 120                 argv++;
 121         }
 122         if (argc > 1 && (1 == (sscanf(argv[1], "%d", &number)))) {
 123                 argv++;
 124                 argc--;
 125                 goal_length = number;
 126                 if (argc > 1 && (1 == (sscanf(argv[1], "%d", &number)))) {
 127                         argv++;
 128                         argc--;
 129                         max_length = number;
 130                 }
 131         }
 132         if (max_length <= goal_length)
 133                 errx(1, "max length must be greater than goal length");
 134         if (argc < 2) {
 135                 fmt(stdin);
 136                 oflush();
 137                 exit(0);
 138         }
 139         while (--argc) {
 140                 if ((fi = fopen(*++argv, "r")) == NULL) {
 141                         perror(*argv);
 142                         errs++;
 143                         continue;
 144                 }
 145                 fmt(fi);
 146                 fclose(fi);
 147         }
 148         oflush();
 149         exit(errs);
 150 }
 151
 152 /*
 153  * Read up characters from the passed input file, forming lines,
 154  * doing ^H processing, expanding tabs, stripping trailing blanks,
 155  * and sending each line down for analysis.
 156  */
 157 void
 158 fmt(fi)
 159         FILE *fi;
 160 {
 161         static char *linebuf = 0, *canonb = 0;
 162         register char *cp, *cp2, cc;
 163         register int c, col;
 164 #define CHUNKSIZE 1024
 165         static int lbufsize = 0, cbufsize = CHUNKSIZE;
 166
 167         canonb = malloc(CHUNKSIZE);
 168         if (canonb == 0)
 169                 abort();
 170
 171         if (center) {
 172                 linebuf = malloc(BUFSIZ);
 173                 while (1) {
 174                         cp = fgets(linebuf, BUFSIZ, fi);
 175                         if (!cp)
 176                                 return;
 177                         while (*cp && isspace(*cp))
 178                                 cp++;
 179                         cp2 = cp + strlen(cp) - 1;
 180                         while (cp2 > cp && isspace(*cp2))
 181                                 cp2--;
 182                         if (cp == cp2)
 183                                 putchar('\n');
 184                         col = cp2 - cp;
 185                         for (c = 0; c < (goal_length-col)/2; c++)
 186                                 putchar(' ');
 187                         while (cp <= cp2)
 188                                 putchar(*cp++);
 189                         putchar('\n');
 190                 }
 191         }
 192         c = getc(fi);
 193         while (c != EOF) {
 194                 /*
 195                  * Collect a line, doing ^H processing.
 196                  * Leave tabs for now.
 197                  */
 198                 cp = linebuf;
 199                 while (c != '\n' && c != EOF) {
 200                         if (cp - linebuf >= lbufsize) {
 201                                 int offset = cp - linebuf;
 202                                 lbufsize += CHUNKSIZE;
 203                                 linebuf = realloc(linebuf, lbufsize);
 204                                 if(linebuf == 0)
 205                                         abort();
 206                                 cp = linebuf + offset;
 207                         }
 208                         if (c == '\b') {
 209                                 if (cp > linebuf)
 210                                         cp--;
 211                                 c = getc(fi);
 212                                 continue;
 213                         }
 214                         if (!isprint(c) && c != '\t') {
 215                                 c = getc(fi);
 216                                 continue;
 217                         }
 218                         *cp++ = c;
 219                         c = getc(fi);
 220                 }
 221
 222                 /*
 223                  * Toss anything remaining on the input line.
 224                  */
 225                 while (c != '\n' && c != EOF)
 226                         c = getc(fi);
 227
 228                 if (cp != NULL) {
 229                         *cp = '\0';
 230                 } else {
 231                         putchar('\n');
 232                         c = getc(fi);
 233                         continue;
 234                 }
 235
 236                 /*
 237                  * Expand tabs on the way to canonb.
 238                  */
 239                 col = 0;
 240                 cp = linebuf;
 241                 cp2 = canonb;
 242                 while ((cc = *cp++)) {
 243                         if (cc != '\t') {
 244                                 col++;
 245                                 if (cp2 - canonb >= cbufsize) {
 246                                         int offset = cp2 - canonb;
 247                                         cbufsize += CHUNKSIZE;
 248                                         canonb = realloc(canonb, cbufsize);
 249                                         if(canonb == 0)
 250                                                 abort();
 251                                         cp2 = canonb + offset;
 252                                 }
 253                                 *cp2++ = cc;
 254                                 continue;
 255                         }
 256                         do {
 257                                 if (cp2 - canonb >= cbufsize) {
 258                                         int offset = cp2 - canonb;
 259                                         cbufsize += CHUNKSIZE;
 260                                         canonb = realloc(canonb, cbufsize);
 261                                         if(canonb == 0)
 262                                                 abort();
 263                                         cp2 = canonb + offset;
 264                                 }
 265                                 *cp2++ = ' ';
 266                                 col++;
 267                         } while ((col & 07) != 0);
 268                 }
 269
 270                 /*
 271                  * Swipe trailing blanks from the line.
 272                  */
 273                 for (cp2--; cp2 >= canonb && *cp2 == ' '; cp2--)
 274                         ;
 275                 *++cp2 = '\0';
 276                 prefix(canonb);
 277                 if (c != EOF)
 278                         c = getc(fi);
 279         }
 280 }
 281
 282 /*
 283  * Take a line devoid of tabs and other garbage and determine its
 284  * blank prefix.  If the indent changes, call for a linebreak.
 285  * If the input line is blank, echo the blank line on the output.
 286  * Finally, if the line minus the prefix is a mail header, try to keep
 287  * it on a line by itself.
 288  */
 289 void
 290 prefix(line)
 291         char line[];
 292 {
 293         register char *cp, **hp;
 294         register int np, h;
 295
 296         if (!*line) {
 297                 oflush();
 298                 putchar('\n');
 299                 return;
 300         }
 301         for (cp = line; *cp == ' '; cp++)
 302                 ;
 303         np = cp - line;
 304
 305         /*
 306          * The following horrible expression attempts to avoid linebreaks
 307          * when the indent changes due to a paragraph.
 308          */
 309         if (np != pfx && (np > pfx || abs(pfx-np) > 8))
 310                 oflush();
 311         if ((h = ishead(cp)))
 312                 oflush(), mark = lineno;
 313         if (lineno - mark < 3 && lineno - mark > 0)
 314                 for (hp = &headnames[0]; *hp != (char *) 0; hp++)
 315                         if (ispref(*hp, cp)) {
 316                                 h = 1;
 317                                 oflush();
 318                                 break;
 319                         }
 320         if (!h && (h = (*cp == '.')))
 321                 oflush();
 322         pfx = np;
 323         if (h)
 324                 pack(cp, strlen(cp));
 325         else    split(cp);
 326         if (h)
 327                 oflush();
 328         lineno++;
 329 }
 330
 331 /*
 332  * Split up the passed line into output "words" which are
 333  * maximal strings of non-blanks with the blank separation
 334  * attached at the end.  Pass these words along to the output
 335  * line packer.
 336  */
 337 void
 338 split(line)
 339         char line[];
 340 {
 341         register char *cp, *cp2;
 342         static char *word=0;
 343         static int wordsize=0;
 344         int wordl;              /* LIZ@UOM 6/18/85 */
 345
 346         {
 347                 int l = strlen(line);
 348                 if (l >= wordsize) {
 349                         if (word)
 350                                 free(word);
 351                         wordsize = (l+66)&~63;
 352                         word = malloc(wordsize);
 353                         if (word == NULL)
 354                                 abort();
 355                 }
 356         }
 357
 358         cp = line;
 359         while (*cp) {
 360                 cp2 = word;
 361                 wordl = 0;      /* LIZ@UOM 6/18/85 */
 362
 363                 /*
 364                  * Collect a 'word,' allowing it to contain escaped white
 365                  * space.
 366                  */
 367                 while (*cp && *cp != ' ') {
 368                         if (*cp == '\\' && isspace(cp[1]))
 369                                 *cp2++ = *cp++;
 370                         *cp2++ = *cp++;
 371                         wordl++;/* LIZ@UOM 6/18/85 */
 372                 }
 373
 374                 /*
 375                  * Guarantee a space at end of line. Two spaces after end of
 376                  * sentence punctuation.
 377                  */
 378                 if (*cp == '\0') {
 379                         *cp2++ = ' ';
 380                         if (cp != line && index(".:!", cp[-1]))
 381                                 *cp2++ = ' ';
 382                 }
 383                 while (*cp == ' ')
 384                         *cp2++ = *cp++;
 385                 *cp2 = '\0';
 386                 /*
 387                  * LIZ@UOM 6/18/85 pack(word);
 388                  */
 389                 pack(word, wordl);
 390         }
 391 }
 392
 393 /*
 394  * Output section.
 395  * Build up line images from the words passed in.  Prefix
 396  * each line with correct number of blanks.  The buffer "outbuf"
 397  * contains the current partial line image, including prefixed blanks.
 398  * "outp" points to the next available space therein.  When outp is NOSTR,
 399  * there ain't nothing in there yet.  At the bottom of this whole mess,
 400  * leading tabs are reinserted.
 401  */
 402 char    *outbuf;                        /* Sandbagged output line image */
 403 char    *outp;                          /* Pointer in above */
 404 int     outbuf_size;                    /* er, size of outbuf */
 405
 406 /*
 407  * Initialize the output section.
 408  */
 409 void
 410 setout()
 411 {
 412         outbuf = malloc(BUFSIZ);
 413         if (outbuf == 0)
 414                 abort();
 415         outbuf_size = BUFSIZ;
 416         outp = NOSTR;
 417 }
 418
 419 /*
 420  * Pack a word onto the output line.  If this is the beginning of
 421  * the line, push on the appropriately-sized string of blanks first.
 422  * If the word won't fit on the current line, flush and begin a new
 423  * line.  If the word is too long to fit all by itself on a line,
 424  * just give it its own and hope for the best.
 425  *
 426  * LIZ@UOM 6/18/85 -- If the new word will fit in at less than the
 427  *      goal length, take it.  If not, then check to see if the line
 428  *      will be over the max length; if so put the word on the next
 429  *      line.  If not, check to see if the line will be closer to the
 430  *      goal length with or without the word and take it or put it on
 431  *      the next line accordingly.
 432  */
 433
 434 /*
 435  * LIZ@UOM 6/18/85 -- pass in the length of the word as well
 436  * pack(word)
 437  *      char word[];
 438  */
 439 void
 440 pack(word,wl)
 441         char word[];
 442         int wl;
 443 {
 444         register char *cp;
 445         register int s, t;
 446
 447         if (((outp==NOSTR) ? wl : outp-outbuf + wl) >= outbuf_size) {
 448                 char *old_outbuf = outbuf;
 449                 outbuf_size *= 2;
 450                 outbuf = realloc(outbuf, outbuf_size);
 451                 if (outbuf == 0)
 452                         abort();
 453                 outp += outbuf-old_outbuf;
 454         }
 455
 456         if (outp == NOSTR)
 457                 leadin();
 458         /*
 459          * LIZ@UOM 6/18/85 -- change condition to check goal_length; s is the
 460          * length of the line before the word is added; t is now the length
 461          * of the line after the word is added
 462          *      t = strlen(word);
 463          *      if (t+s <= LENGTH)
 464          */
 465         s = outp - outbuf;
 466         t = wl + s;
 467         if ((t <= goal_length) ||
 468             ((t <= max_length) && (t - goal_length <= goal_length - s))) {
 469                 /*
 470                  * In like flint!
 471                  */
 472                 for (cp = word; *cp; *outp++ = *cp++);
 473                 return;
 474         }
 475         if (s > pfx) {
 476                 oflush();
 477                 leadin();
 478         }
 479         for (cp = word; *cp; *outp++ = *cp++);
 480 }
 481
 482 /*
 483  * If there is anything on the current output line, send it on
 484  * its way.  Set outp to NOSTR to indicate the absence of the current
 485  * line prefix.
 486  */
 487 void
 488 oflush()
 489 {
 490         if (outp == NOSTR)
 491                 return;
 492         *outp = '\0';
 493         tabulate(outbuf);
 494         outp = NOSTR;
 495 }
 496
 497 /*
 498  * Take the passed line buffer, insert leading tabs where possible, and
 499  * output on standard output (finally).
 500  */
 501 void
 502 tabulate(line)
 503         char line[];
 504 {
 505         register char *cp;
 506         register int b, t;
 507
 508         /*
 509          * Toss trailing blanks in the output line.
 510          */
 511         cp = line + strlen(line) - 1;
 512         while (cp >= line && *cp == ' ')
 513                 cp--;
 514         *++cp = '\0';
 515
 516         /*
 517          * Count the leading blank space and tabulate.
 518          */
 519         for (cp = line; *cp == ' '; cp++)
 520                 ;
 521         b = cp-line;
 522         t = b >> 3;
 523         b &= 07;
 524         if (t > 0)
 525                 do
 526                         putc('\t', stdout);
 527                 while (--t);
 528         if (b > 0)
 529                 do
 530                         putc(' ', stdout);
 531                 while (--b);
 532         while (*cp)
 533                 putc(*cp++, stdout);
 534         putc('\n', stdout);
 535 }
 536
 537 /*
 538  * Initialize the output line with the appropriate number of
 539  * leading blanks.
 540  */
 541 void
 542 leadin()
 543 {
 544         register int b;
 545         register char *cp;
 546
 547         for (b = 0, cp = outbuf; b < pfx; b++)
 548                 *cp++ = ' ';
 549         outp = cp;
 550 }
 551
 552 /*
 553  * Save a string in dynamic space.
 554  * This little goodie is needed for
 555  * a headline detector in head.c
 556  */
 557 char *
 558 savestr(str)
 559         char str[];
 560 {
 561         register char *top;
 562
 563         top = malloc(strlen(str) + 1);
 564         if (top == NOSTR)
 565                 errx(1, "ran out of memory");
 566         strcpy(top, str);
 567         return (top);
 568 }
 569
 570 /*
 571  * Is s1 a prefix of s2??
 572  */
 573 int
 574 ispref(s1, s2)
 575         register char *s1, *s2;
 576 {
 577
 578         while (*s1++ == *s2)
 579                 ;
 580         return (*s1 == '\0');
 581 }