usr.bin/deroff/deroff.c

   1 /*      $NetBSD: deroff.c,v 1.6 2009/04/11 13:01:27 lukem Exp $ */
   2
   3 /* taken from: OpenBSD: deroff.c,v 1.6 2004/06/02 14:58:46 tom Exp */
   4
   5 /*-
   6  * Copyright (c) 1988, 1993
   7  *      The Regents of the University of California.  All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. 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  * Copyright (C) Caldera International Inc.  2001-2002.
  35  * All rights reserved.
  36  *
  37  * Redistribution and use in source and binary forms, with or without
  38  * modification, are permitted provided that the following conditions
  39  * are met:
  40  * 1. Redistributions of source code and documentation must retain the above
  41  *    copyright notice, this list of conditions and the following disclaimer.
  42  * 2. Redistributions in binary form must reproduce the above copyright
  43  *    notice, this list of conditions and the following disclaimer in the
  44  *    documentation and/or other materials provided with the distribution.
  45  * 3. All advertising materials mentioning features or use of this software
  46  *    must display the following acknowledgement:
  47  *      This product includes software developed or owned by Caldera
  48  *      International, Inc.
  49  * 4. Neither the name of Caldera International, Inc. nor the names of other
  50  *    contributors may be used to endorse or promote products derived from
  51  *    this software without specific prior written permission.
  52  *
  53  * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
  54  * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
  55  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  56  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  57  * IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE FOR ANY DIRECT,
  58  * INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  59  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  60  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  61  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  62  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  63  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  64  * POSSIBILITY OF SUCH DAMAGE.
  65  */
  66
  67 #ifndef lint
  68 static const char copyright[] =
  69 "@(#) Copyright (c) 1988, 1993\n\
  70         The Regents of the University of California.  All rights reserved.\n";
  71 #endif /* not lint */
  72
  73 #ifndef lint
  74 #if 0
  75 static const char sccsid[] = "@(#)deroff.c      8.1 (Berkeley) 6/6/93";
  76 #else
  77 static const char rcsid[] = "$NetBSD: deroff.c,v 1.6 2009/04/11 13:01:27 lukem Exp $";
  78 #endif
  79 #endif /* not lint */
  80
  81 #include <sys/cdefs.h>
  82 #include <err.h>
  83 #include <limits.h>
  84 #include <stddef.h>
  85 #include <stdio.h>
  86 #include <stdlib.h>
  87 #include <string.h>
  88 #include <unistd.h>
  89
  90 /*
  91  *      Deroff command -- strip troff, eqn, and Tbl sequences from
  92  *      a file.  Has two flags argument, -w, to cause output one word per line
  93  *      rather than in the original format.
  94  *      -mm (or -ms) causes the corresponding macro's to be interpreted
  95  *      so that just sentences are output
  96  *      -ml  also gets rid of lists.
  97  *      Deroff follows .so and .nx commands, removes contents of macro
  98  *      definitions, equations (both .EQ ... .EN and $...$),
  99  *      Tbl command sequences, and Troff backslash constructions.
 100  *
 101  *      All input is through the Cget macro;
 102  *      the most recently read character is in c.
 103  *
 104  *      Modified by Robert Henry to process -me and -man macros.
 105  */
 106
 107 #define Cget ( (c=getc(infile)) == EOF ? eof() : ((c==ldelim)&&(filesp==files) ? skeqn() : c) )
 108 #define C1get ( (c=getc(infile)) == EOF ? eof() :  c)
 109
 110 #ifdef DEBUG
 111 #  define C     _C()
 112 #  define C1    _C1()
 113 #else /* not DEBUG */
 114 #  define C     Cget
 115 #  define C1    C1get
 116 #endif /* not DEBUG */
 117
 118 #define SKIP while (C != '\n')
 119 #define SKIP_TO_COM SKIP; SKIP; pc=c; while (C != '.' || pc != '\n' || C > 'Z')pc=c
 120
 121 #define YES 1
 122 #define NO 0
 123 #define MS 0    /* -ms */
 124 #define MM 1    /* -mm */
 125 #define ME 2    /* -me */
 126 #define MA 3    /* -man */
 127
 128 #ifdef DEBUG
 129 char *mactab[] = { "-ms", "-mm", "-me", "-ma" };
 130 #endif /* DEBUG */
 131
 132 #define ONE 1
 133 #define TWO 2
 134
 135 #define NOCHAR -2
 136 #define SPECIAL 0
 137 #define APOS 1
 138 #define PUNCT 2
 139 #define DIGIT 3
 140 #define LETTER 4
 141
 142 #define MAXFILES 20
 143
 144 static int      iflag;
 145 static int      wordflag;
 146 static int      msflag;  /* processing a source written using a mac package */
 147 static int      mac;            /* which package */
 148 static int      disp;
 149 static int      parag;
 150 static int      inmacro;
 151 static int      intable;
 152 static int      keepblock; /* keep blocks of text; normally false when msflag */
 153
 154 static char chars[128];  /* SPECIAL, PUNCT, APOS, DIGIT, or LETTER */
 155
 156 static char line[LINE_MAX];
 157 static char *lp;
 158
 159 static int c;
 160 static int pc;
 161 static int ldelim;
 162 static int rdelim;
 163
 164 static char fname[PATH_MAX];
 165 static FILE *files[MAXFILES];
 166 static FILE **filesp;
 167 static FILE *infile;
 168
 169 static int argc;
 170 static char **argv;
 171
 172 /*
 173  *      Macro processing
 174  *
 175  *      Macro table definitions
 176  */
 177 typedef int pacmac;             /* compressed macro name */
 178 static int      argconcat = 0;  /* concat arguments together (-me only) */
 179
 180 #define tomac(c1, c2)           ((((c1) & 0xFF) << 8) | ((c2) & 0xFF))
 181 #define frommac(src, c1, c2)    (((c1)=((src)>>8)&0xFF),((c2) =(src)&0xFF))
 182
 183 struct mactab {
 184         int     condition;
 185         pacmac  macname;
 186         int     (*func)(pacmac);
 187 };
 188
 189 static const struct     mactab  troffmactab[];
 190 static const struct     mactab  ppmactab[];
 191 static const struct     mactab  msmactab[];
 192 static const struct     mactab  mmmactab[];
 193 static const struct     mactab  memactab[];
 194 static const struct     mactab  manmactab[];
 195
 196 /*
 197  *      Macro table initialization
 198  */
 199 #define M(cond, c1, c2, func) {cond, tomac(c1, c2), func}
 200
 201 /*
 202  *      Flags for matching conditions other than
 203  *      the macro name
 204  */
 205 #define NONE            0
 206 #define FNEST           1               /* no nested files */
 207 #define NOMAC           2               /* no macro */
 208 #define MAC             3               /* macro */
 209 #define PARAG           4               /* in a paragraph */
 210 #define MSF             5               /* msflag is on */
 211 #define NBLK            6               /* set if no blocks to be kept */
 212
 213 /*
 214  *      Return codes from macro minions, determine where to jump,
 215  *      how to repeat/reprocess text
 216  */
 217 #define COMX            1               /* goto comx */
 218 #define COM             2               /* goto com */
 219
 220 static int       skeqn(void);
 221 static int       eof(void);
 222 #ifdef DEBUG
 223 static int       _C1(void);
 224 static int       _C(void);
 225 #endif
 226 static int       EQ(pacmac);
 227 static int       domacro(pacmac);
 228 static int       PS(pacmac);
 229 static int       skip(pacmac);
 230 static int       intbl(pacmac);
 231 static int       outtbl(pacmac);
 232 static int       so(pacmac);
 233 static int       nx(pacmac);
 234 static int       skiptocom(pacmac);
 235 static int       PP(pacmac);
 236 static int       AU(pacmac);
 237 static int       SH(pacmac);
 238 static int       UX(pacmac);
 239 static int       MMHU(pacmac);
 240 static int       mesnblock(pacmac);
 241 static int       mssnblock(pacmac);
 242 static int       nf(pacmac);
 243 static int       ce(pacmac);
 244 static int       meip(pacmac);
 245 static int       mepp(pacmac);
 246 static int       mesh(pacmac);
 247 static int       mefont(pacmac);
 248 static int       manfont(pacmac);
 249 static int       manpp(pacmac);
 250 static int       macsort(const void *, const void *);
 251 static int       sizetab(const struct mactab *);
 252 static void      getfname(void);
 253 static void      textline(char *, int);
 254 static void      work(void);
 255 static void      regline(void (*)(char *, int), int);
 256 static void      macro(void);
 257 static void      tbl(void);
 258 static void      stbl(void);
 259 static void      eqn(void);
 260 static void      backsl(void);
 261 static void      sce(void);
 262 static void      refer(int);
 263 static void      inpic(void);
 264 static void      msputmac(char *, int);
 265 static void      msputwords(int);
 266 static void      meputmac(char *, int);
 267 static void      meputwords(int);
 268 static void      noblock(char, char);
 269 static void      defcomline(pacmac);
 270 static void      comline(void);
 271 static void      buildtab(const struct mactab **, int *);
 272 static FILE     *opn(char *);
 273 static struct mactab *macfill(struct mactab *, const struct mactab *);
 274 static void usage(void) __dead;
 275
 276 int
 277 main(int ac, char **av)
 278 {
 279         int     i, ch;
 280         int     errflg = 0;
 281         int     kflag = NO;
 282
 283         iflag = NO;
 284         wordflag = NO;
 285         msflag = NO;
 286         mac = ME;
 287         disp = NO;
 288         parag = NO;
 289         inmacro = NO;
 290         intable = NO;
 291         ldelim  = NOCHAR;
 292         rdelim  = NOCHAR;
 293         keepblock = YES;
 294
 295         while ((ch = getopt(ac, av, "ikpwm:")) != -1) {
 296                 switch (ch) {
 297                 case 'i':
 298                         iflag = YES;
 299                         break;
 300                 case 'k':
 301                         kflag = YES;
 302                         break;
 303                 case 'm':
 304                         msflag = YES;
 305                         keepblock = NO;
 306                         switch (optarg[0]) {
 307                         case 'm':
 308                                 mac = MM;
 309                                 break;
 310                         case 's':
 311                                 mac = MS;
 312                                 break;
 313                         case 'e':
 314                                 mac = ME;
 315                                 break;
 316                         case 'a':
 317                                 mac = MA;
 318                                 break;
 319                         case 'l':
 320                                 disp = YES;
 321                                 break;
 322                         default:
 323                                 errflg++;
 324                                 break;
 325                         }
 326                         if (errflg == 0 && optarg[1] != '\0')
 327                                 errflg++;
 328                         break;
 329                 case 'p':
 330                         parag = YES;
 331                         break;
 332                 case 'w':
 333                         wordflag = YES;
 334                         kflag = YES;
 335                         break;
 336                 default:
 337                         errflg++;
 338                 }
 339         }
 340         argc = ac - optind;
 341         argv = av + optind;
 342
 343         if (kflag)
 344                 keepblock = YES;
 345         if (errflg)
 346                 usage();
 347
 348 #ifdef DEBUG
 349         printf("msflag = %d, mac = %s, keepblock = %d, disp = %d\n",
 350                 msflag, mactab[mac], keepblock, disp);
 351 #endif /* DEBUG */
 352         if (argc == 0) {
 353                 infile = stdin;
 354         } else {
 355                 infile = opn(argv[0]);
 356                 --argc;
 357                 ++argv;
 358         }
 359         files[0] = infile;
 360         filesp = &files[0];
 361
 362         for (i = 'a'; i <= 'z' ; ++i)
 363                 chars[i] = LETTER;
 364         for (i = 'A'; i <= 'Z'; ++i)
 365                 chars[i] = LETTER;
 366         for (i = '0'; i <= '9'; ++i)
 367                 chars[i] = DIGIT;
 368         chars['\''] = APOS;
 369         chars['&'] = APOS;
 370         chars['.'] = PUNCT;
 371         chars[','] = PUNCT;
 372         chars[';'] = PUNCT;
 373         chars['?'] = PUNCT;
 374         chars[':'] = PUNCT;
 375         work();
 376         return 0;
 377 }
 378
 379 static int
 380 skeqn(void)
 381 {
 382
 383         while ((c = getc(infile)) != rdelim) {
 384                 if (c == EOF)
 385                         c = eof();
 386                 else if (c == '"') {
 387                         while ((c = getc(infile)) != '"') {
 388                                 if (c == EOF ||
 389                                     (c == '\\' && (c = getc(infile)) == EOF))
 390                                         c = eof();
 391                         }
 392                 }
 393         }
 394         if (msflag)
 395                 return c == 'x';
 396         return c == ' ';
 397 }
 398
 399 static FILE *
 400 opn(char *p)
 401 {
 402         FILE *fd;
 403
 404         if ((fd = fopen(p, "r")) == NULL)
 405                 err(1, "fopen %s", p);
 406
 407         return fd;
 408 }
 409
 410 static int
 411 eof(void)
 412 {
 413
 414         if (infile != stdin)
 415                 fclose(infile);
 416         if (filesp > files)
 417                 infile = *--filesp;
 418         else if (argc > 0) {
 419                 infile = opn(argv[0]);
 420                 --argc;
 421                 ++argv;
 422         } else
 423                 exit(0);
 424         return C;
 425 }
 426
 427 static void
 428 getfname(void)
 429 {
 430         char *p;
 431         struct chain {
 432                 struct chain *nextp;
 433                 char *datap;
 434         } *q;
 435         static struct chain *namechain= NULL;
 436
 437         while (C == ' ')
 438                 ;       /* nothing */
 439
 440         for (p = fname ; p - fname < (ptrdiff_t)sizeof(fname) &&
 441             (*p = c) != '\n' &&
 442             c != ' ' && c != '\t' && c != '\\'; ++p)
 443                 C;
 444         *p = '\0';
 445         while (c != '\n')
 446                 C;
 447
 448         /* see if this name has already been used */
 449         for (q = namechain ; q; q = q->nextp)
 450                 if (strcmp(fname, q->datap) == 0) {
 451                         fname[0] = '\0';
 452                         return;
 453                 }
 454
 455         q = (struct chain *) malloc(sizeof(struct chain));
 456         if (q == NULL)
 457                 err(1, NULL);
 458         q->nextp = namechain;
 459         q->datap = strdup(fname);
 460         if (q->datap == NULL)
 461                 err(1, NULL);
 462         namechain = q;
 463 }
 464
 465 /*ARGSUSED*/
 466 static void
 467 textline(char *str, int constant)
 468 {
 469
 470         if (wordflag) {
 471                 msputwords(0);
 472                 return;
 473         }
 474         puts(str);
 475 }
 476
 477 void
 478 work(void)
 479 {
 480
 481         for (;;) {
 482                 C;
 483 #ifdef FULLDEBUG
 484                 printf("Starting work with `%c'\n", c);
 485 #endif /* FULLDEBUG */
 486                 if (c == '.' || c == '\'')
 487                         comline();
 488                 else
 489                         regline(textline, TWO);
 490         }
 491 }
 492
 493 static void
 494 regline(void (*pfunc)(char *, int), int constant)
 495 {
 496
 497         line[0] = c;
 498         lp = line;
 499         while (lp - line < (ptrdiff_t)sizeof(line)) {
 500                 if (c == '\\') {
 501                         *lp = ' ';
 502                         backsl();
 503                 }
 504                 if (c == '\n')
 505                         break;
 506                 if (intable && c == 'T') {
 507                         *++lp = C;
 508                         if (c == '{' || c == '}') {
 509                                 lp[-1] = ' ';
 510                                 *lp = C;
 511                         }
 512                 } else {
 513                         *++lp = C;
 514                 }
 515         }
 516         *lp = '\0';
 517
 518         if (line[0] != '\0')
 519                 (*pfunc)(line, constant);
 520 }
 521
 522 static void
 523 macro(void)
 524 {
 525
 526         if (msflag) {
 527                 do {
 528                         SKIP;
 529                 } while (C!='.' || C!='.' || C=='.');   /* look for  .. */
 530                 if (c != '\n')
 531                         SKIP;
 532                 return;
 533         }
 534         SKIP;
 535         inmacro = YES;
 536 }
 537
 538 static void
 539 tbl(void)
 540 {
 541
 542         while (C != '.')
 543                 ;       /* nothing */
 544         SKIP;
 545         intable = YES;
 546 }
 547
 548 static void
 549 stbl(void)
 550 {
 551
 552         while (C != '.')
 553                 ;       /* nothing */
 554         SKIP_TO_COM;
 555         if (c != 'T' || C != 'E') {
 556                 SKIP;
 557                 pc = c;
 558                 while (C != '.' || pc != '\n' || C != 'T' || C != 'E')
 559                         pc = c;
 560         }
 561 }
 562
 563 static void
 564 eqn(void)
 565 {
 566         int c1, c2;
 567         int dflg;
 568         char last;
 569
 570         last=0;
 571         dflg = 1;
 572         SKIP;
 573
 574         for (;;) {
 575                 if (C1 == '.'  || c == '\'') {
 576                         while (C1 == ' ' || c == '\t')
 577                                 ;
 578                         if (c == 'E' && C1 == 'N') {
 579                                 SKIP;
 580                                 if (msflag && dflg) {
 581                                         putchar('x');
 582                                         putchar(' ');
 583                                         if (last) {
 584                                                 putchar(last);
 585                                                 putchar('\n');
 586                                         }
 587                                 }
 588                                 return;
 589                         }
 590                 } else if (c == 'd') {
 591                         /* look for delim */
 592                         if (C1 == 'e' && C1 == 'l')
 593                                 if (C1 == 'i' && C1 == 'm') {
 594                                         while (C1 == ' ')
 595                                                 ;       /* nothing */
 596
 597                                         if ((c1 = c) == '\n' ||
 598                                             (c2 = C1) == '\n' ||
 599                                             (c1 == 'o' && c2 == 'f' && C1=='f')) {
 600                                                 ldelim = NOCHAR;
 601                                                 rdelim = NOCHAR;
 602                                         } else {
 603                                                 ldelim = c1;
 604                                                 rdelim = c2;
 605                                         }
 606                                 }
 607                         dflg = 0;
 608                 }
 609
 610                 if (c != '\n')
 611                         while (C1 != '\n') {
 612                                 if (chars[c] == PUNCT)
 613                                         last = c;
 614                                 else if (c != ' ')
 615                                         last = 0;
 616                         }
 617         }
 618 }
 619
 620 /* skip over a complete backslash construction */
 621 static void
 622 backsl(void)
 623 {
 624         int bdelim;
 625
 626 sw:
 627         switch (C) {
 628         case '"':
 629                 SKIP;
 630                 return;
 631
 632         case 's':
 633                 if (C == '\\')
 634                         backsl();
 635                 else {
 636                         while (C >= '0' && c <= '9')
 637                                 ;       /* nothing */
 638                         ungetc(c, infile);
 639                         c = '0';
 640                 }
 641                 --lp;
 642                 return;
 643
 644         case 'f':
 645         case 'n':
 646         case '*':
 647                 if (C != '(')
 648                         return;
 649
 650         case '(':
 651                 if (msflag) {
 652                         if (C == 'e') {
 653                                 if (C == 'm') {
 654                                         *lp = '-';
 655                                         return;
 656                                 }
 657                         }
 658                         else if (c != '\n')
 659                                 C;
 660                         return;
 661                 }
 662                 if (C != '\n')
 663                         C;
 664                 return;
 665
 666         case '$':
 667                 C;      /* discard argument number */
 668                 return;
 669
 670         case 'b':
 671         case 'x':
 672         case 'v':
 673         case 'h':
 674         case 'w':
 675         case 'o':
 676         case 'l':
 677         case 'L':
 678                 if ((bdelim = C) == '\n')
 679                         return;
 680                 while (C != '\n' && c != bdelim)
 681                         if (c == '\\')
 682                                 backsl();
 683                 return;
 684
 685         case '\\':
 686                 if (inmacro)
 687                         goto sw;
 688
 689         default:
 690                 return;
 691         }
 692 }
 693
 694 static void
 695 sce(void)
 696 {
 697         char *ap;
 698         int n, i;
 699         char a[10];
 700
 701         for (ap = a; C != '\n'; ap++) {
 702                 *ap = c;
 703                 if (ap == &a[9]) {
 704                         SKIP;
 705                         ap = a;
 706                         break;
 707                 }
 708         }
 709         if (ap != a)
 710                 n = atoi(a);
 711         else
 712                 n = 1;
 713         for (i = 0; i < n;) {
 714                 if (C == '.') {
 715                         if (C == 'c') {
 716                                 if (C == 'e') {
 717                                         while (C == ' ')
 718                                                 ;       /* nothing */
 719                                         if (c == '0') {
 720                                                 SKIP;
 721                                                 break;
 722                                         } else
 723                                                 SKIP;
 724                                 }
 725                                 else
 726                                         SKIP;
 727                         } else if (c == 'P' || C == 'P') {
 728                                 if (c != '\n')
 729                                         SKIP;
 730                                 break;
 731                         } else if (c != '\n')
 732                                 SKIP;
 733                 } else {
 734                         SKIP;
 735                         i++;
 736                 }
 737         }
 738 }
 739
 740 static void
 741 refer(int c1)
 742 {
 743         int c2;
 744
 745         if (c1 != '\n')
 746                 SKIP;
 747
 748         for (c2 = -1;;) {
 749                 if (C != '.')
 750                         SKIP;
 751                 else {
 752                         if (C != ']')
 753                                 SKIP;
 754                         else {
 755                                 while (C != '\n')
 756                                         c2 = c;
 757                                 if (c2 != -1 && chars[c2] == PUNCT)
 758                                         putchar(c2);
 759                                 return;
 760                         }
 761                 }
 762         }
 763 }
 764
 765 static void
 766 inpic(void)
 767 {
 768         int c1;
 769         char *p1;
 770
 771         SKIP;
 772         p1 = line;
 773         c = '\n';
 774         for (;;) {
 775                 c1 = c;
 776                 if (C == '.' && c1 == '\n') {
 777                         if (C != 'P') {
 778                                 if (c == '\n')
 779                                         continue;
 780                                 else {
 781                                         SKIP;
 782                                         c = '\n';
 783                                         continue;
 784                                 }
 785                         }
 786                         if (C != 'E') {
 787                                 if (c == '\n')
 788                                         continue;
 789                                 else {
 790                                         SKIP;
 791                                         c = '\n';
 792                                         continue;
 793                                 }
 794                         }
 795                         SKIP;
 796                         return;
 797                 }
 798                 else if (c == '\"') {
 799                         while (C != '\"') {
 800                                 if (c == '\\') {
 801                                         if (C == '\"')
 802                                                 continue;
 803                                         ungetc(c, infile);
 804                                         backsl();
 805                                 } else
 806                                         *p1++ = c;
 807                         }
 808                         *p1++ = ' ';
 809                 }
 810                 else if (c == '\n' && p1 != line) {
 811                         *p1 = '\0';
 812                         if (wordflag)
 813                                 msputwords(NO);
 814                         else {
 815                                 puts(line);
 816                                 putchar('\n');
 817                         }
 818                         p1 = line;
 819                 }
 820         }
 821 }
 822
 823 #ifdef DEBUG
 824 static int
 825 _C1(void)
 826 {
 827
 828         return C1get;
 829 }
 830
 831 static int
 832 _C(void)
 833 {
 834
 835         return Cget;
 836 }
 837 #endif /* DEBUG */
 838
 839 /*
 840  *      Put out a macro line, using ms and mm conventions.
 841  */
 842 static void
 843 msputmac(char *s, int constant)
 844 {
 845         char *t;
 846         int found;
 847         int last;
 848
 849         last = 0;
 850         found = 0;
 851         if (wordflag) {
 852                 msputwords(YES);
 853                 return;
 854         }
 855         while (*s) {
 856                 while (*s == ' ' || *s == '\t')
 857                         putchar(*s++);
 858                 for (t = s ; *t != ' ' && *t != '\t' && *t != '\0' ; ++t)
 859                         ;       /* nothing */
 860                 if (*s == '\"')
 861                         s++;
 862                 if (t > s + constant && chars[(unsigned char)s[0]] == LETTER &&
 863                     chars[(unsigned char)s[1]] == LETTER) {
 864                         while (s < t)
 865                                 if (*s == '\"')
 866                                         s++;
 867                                 else
 868                                         putchar(*s++);
 869                         last = *(t-1);
 870                         found++;
 871                 } else if (found && chars[(unsigned char)s[0]] == PUNCT &&
 872                     s[1] == '\0') {
 873                         putchar(*s++);
 874                 } else {
 875                         last = *(t - 1);
 876                         s = t;
 877                 }
 878         }
 879         putchar('\n');
 880         if (msflag && chars[last] == PUNCT) {
 881                 putchar(last);
 882                 putchar('\n');
 883         }
 884 }
 885
 886 /*
 887  *      put out words (for the -w option) with ms and mm conventions
 888  */
 889 static void
 890 msputwords(int macline)
 891 {
 892         char *p, *p1;
 893         int i, nlet;
 894
 895         for (p1 = line;;) {
 896                 /*
 897                  *      skip initial specials ampersands and apostrophes
 898                  */
 899                 while (chars[(unsigned char)*p1] < DIGIT)
 900                         if (*p1++ == '\0')
 901                                 return;
 902                 nlet = 0;
 903                 for (p = p1 ; (i = chars[(unsigned char)*p]) != SPECIAL ; ++p)
 904                         if (i == LETTER)
 905                                 ++nlet;
 906
 907                 if (nlet > 1 && chars[(unsigned char)p1[0]] == LETTER) {
 908                         /*
 909                          *      delete trailing ampersands and apostrophes
 910                          */
 911                         while ((i = chars[(unsigned char)p[-1]]) == PUNCT ||
 912                             i == APOS )
 913                                 --p;
 914                         while (p1 < p)
 915                                 putchar(*p1++);
 916                         putchar('\n');
 917                 } else {
 918                         p1 = p;
 919                 }
 920         }
 921 }
 922
 923 /*
 924  *      put out a macro using the me conventions
 925  */
 926 #define SKIPBLANK(cp)   while (*cp == ' ' || *cp == '\t') { cp++; }
 927 #define SKIPNONBLANK(cp) while (*cp !=' ' && *cp !='\cp' && *cp !='\0') { cp++; }
 928
 929 static void
 930 meputmac(char *cp, int constant)
 931 {
 932         char    *np;
 933         int     found;
 934         int     argno;
 935         int     last;
 936         int     inquote;
 937
 938         last = 0;
 939         found = 0;
 940         if (wordflag) {
 941                 meputwords(YES);
 942                 return;
 943         }
 944         for (argno = 0; *cp; argno++) {
 945                 SKIPBLANK(cp);
 946                 inquote = (*cp == '"');
 947                 if (inquote)
 948                         cp++;
 949                 for (np = cp; *np; np++) {
 950                         switch (*np) {
 951                         case '\n':
 952                         case '\0':
 953                                 break;
 954
 955                         case '\t':
 956                         case ' ':
 957                                 if (inquote)
 958                                         continue;
 959                                 else
 960                                         goto endarg;
 961
 962                         case '"':
 963                                 if (inquote && np[1] == '"') {
 964                                         memmove(np, np + 1, strlen(np));
 965                                         np++;
 966                                         continue;
 967                                 } else {
 968                                         *np = ' ';      /* bye bye " */
 969                                         goto endarg;
 970                                 }
 971
 972                         default:
 973                                 continue;
 974                         }
 975                 }
 976                 endarg: ;
 977                 /*
 978                  *      cp points at the first char in the arg
 979                  *      np points one beyond the last char in the arg
 980                  */
 981                 if ((argconcat == 0) || (argconcat != argno))
 982                         putchar(' ');
 983 #ifdef FULLDEBUG
 984                 {
 985                         char    *p;
 986                         printf("[%d,%d: ", argno, np - cp);
 987                         for (p = cp; p < np; p++) {
 988                                 putchar(*p);
 989                         }
 990                         printf("]");
 991                 }
 992 #endif /* FULLDEBUG */
 993                 /*
 994                  *      Determine if the argument merits being printed
 995                  *
 996                  *      constant is the cut off point below which something
 997                  *      is not a word.
 998                  */
 999                 if (((np - cp) > constant) &&
1000                     (inquote || (chars[(unsigned char)cp[0]] == LETTER))) {
1001                         for (cp = cp; cp < np; cp++)
1002                                 putchar(*cp);
1003                         last = np[-1];
1004                         found++;
1005                 } else if (found && (np - cp == 1) &&
1006                     chars[(unsigned char)*cp] == PUNCT) {
1007                         putchar(*cp);
1008                 } else {
1009                         last = np[-1];
1010                 }
1011                 cp = np;
1012         }
1013         if (msflag && chars[last] == PUNCT)
1014                 putchar(last);
1015         putchar('\n');
1016 }
1017
1018 /*
1019  *      put out words (for the -w option) with ms and mm conventions
1020  */
1021 static void
1022 meputwords(int macline)
1023 {
1024
1025         msputwords(macline);
1026 }
1027
1028 /*
1029  *
1030  *      Skip over a nested set of macros
1031  *
1032  *      Possible arguments to noblock are:
1033  *
1034  *      fi      end of unfilled text
1035  *      PE      pic ending
1036  *      DE      display ending
1037  *
1038  *      for ms and mm only:
1039  *              KE      keep ending
1040  *
1041  *              NE      undocumented match to NS (for mm?)
1042  *              LE      mm only: matches RL or *L (for lists)
1043  *
1044  *      for me:
1045  *              ([lqbzcdf]
1046  */
1047 static void
1048 noblock(char a1, char a2)
1049 {
1050         int c1,c2;
1051         int eqnf;
1052         int lct;
1053
1054         lct = 0;
1055         eqnf = 1;
1056         SKIP;
1057         for (;;) {
1058                 while (C != '.')
1059                         if (c == '\n')
1060                                 continue;
1061                         else
1062                                 SKIP;
1063                 if ((c1 = C) == '\n')
1064                         continue;
1065                 if ((c2 = C) == '\n')
1066                         continue;
1067                 if (c1 == a1 && c2 == a2) {
1068                         SKIP;
1069                         if (lct != 0) {
1070                                 lct--;
1071                                 continue;
1072                         }
1073                         if (eqnf)
1074                                 putchar('.');
1075                         putchar('\n');
1076                         return;
1077                 } else if (a1 == 'L' && c2 == 'L') {
1078                         lct++;
1079                         SKIP;
1080                 }
1081                 /*
1082                  *      equations (EQ) nested within a display
1083                  */
1084                 else if (c1 == 'E' && c2 == 'Q') {
1085                         if ((mac == ME && a1 == ')')
1086                             || (mac != ME && a1 == 'D')) {
1087                                 eqn();
1088                                 eqnf=0;
1089                         }
1090                 }
1091                 /*
1092                  *      turning on filling is done by the paragraphing
1093                  *      macros
1094                  */
1095                 else if (a1 == 'f') {   /* .fi */
1096                         if  ((mac == ME && (c2 == 'h' || c2 == 'p'))
1097                             || (mac != ME && (c1 == 'P' || c2 == 'P'))) {
1098                                 SKIP;
1099                                 return;
1100                         }
1101                 } else {
1102                         SKIP;
1103                 }
1104         }
1105 }
1106
1107 static int
1108 /*ARGSUSED*/
1109 EQ(pacmac unused)
1110 {
1111
1112         eqn();
1113         return 0;
1114 }
1115
1116 static int
1117 /*ARGSUSED*/
1118 domacro(pacmac unused)
1119 {
1120
1121         macro();
1122         return 0;
1123 }
1124
1125 static int
1126 /*ARGSUSED*/
1127 PS(pacmac unused)
1128 {
1129
1130         for (C; c == ' ' || c == '\t'; C)
1131                 ;       /* nothing */
1132
1133         if (c == '<') {         /* ".PS < file" -- don't expect a .PE */
1134                 SKIP;
1135                 return 0;
1136         }
1137         if (!msflag)
1138                 inpic();
1139         else
1140                 noblock('P', 'E');
1141         return 0;
1142 }
1143
1144 static int
1145 /*ARGSUSED*/
1146 skip(pacmac unused)
1147 {
1148
1149         SKIP;
1150         return 0;
1151 }
1152
1153 static int
1154 /*ARGSUSED*/
1155 intbl(pacmac unused)
1156 {
1157
1158         if (msflag)
1159                 stbl();
1160         else
1161                 tbl();
1162         return 0;
1163 }
1164
1165 static int
1166 /*ARGSUSED*/
1167 outtbl(pacmac unused)
1168 {
1169
1170         intable = NO;
1171         return 0;
1172 }
1173
1174 int
1175 /*ARGSUSED*/
1176 so(pacmac unused)
1177 {
1178
1179         if (!iflag) {
1180                 getfname();
1181                 if (fname[0]) {
1182                         if (++filesp - &files[0] > MAXFILES)
1183                                 err(1, "too many nested files (max %d)",
1184                                     MAXFILES);
1185                         infile = *filesp = opn(fname);
1186                 }
1187         }
1188         return 0;
1189 }
1190
1191 static int
1192 /*ARGSUSED*/
1193 nx(pacmac unused)
1194 {
1195
1196         if (!iflag) {
1197                 getfname();
1198                 if (fname[0] == '\0')
1199                         exit(0);
1200                 if (infile != stdin)
1201                         fclose(infile);
1202                 infile = *filesp = opn(fname);
1203         }
1204         return 0;
1205 }
1206
1207 static int
1208 /*ARGSUSED*/
1209 skiptocom(pacmac unused)
1210 {
1211
1212         SKIP_TO_COM;
1213         return COMX;
1214 }
1215
1216 static int
1217 PP(pacmac c12)
1218 {
1219         int c1, c2;
1220
1221         frommac(c12, c1, c2);
1222         printf(".%c%c", c1, c2);
1223         while (C != '\n')
1224                 putchar(c);
1225         putchar('\n');
1226         return 0;
1227 }
1228
1229 static int
1230 /*ARGSUSED*/
1231 AU(pacmac unused)
1232 {
1233
1234         if (mac == MM)
1235                 return 0;
1236         SKIP_TO_COM;
1237         return COMX;
1238 }
1239
1240 static int
1241 SH(pacmac c12)
1242 {
1243         int c1, c2;
1244
1245         frommac(c12, c1, c2);
1246
1247         if (parag) {
1248                 printf(".%c%c", c1, c2);
1249                 while (C != '\n')
1250                         putchar(c);
1251                 putchar(c);
1252                 putchar('!');
1253                 for (;;) {
1254                         while (C != '\n')
1255                                 putchar(c);
1256                         putchar('\n');
1257                         if (C == '.')
1258                                 return COM;
1259                         putchar('!');
1260                         putchar(c);
1261                 }
1262                 /*NOTREACHED*/
1263         } else {
1264                 SKIP_TO_COM;
1265                 return COMX;
1266         }
1267 }
1268
1269 static int
1270 /*ARGSUSED*/
1271 UX(pacmac unused)
1272 {
1273
1274         if (wordflag)
1275                 printf("UNIX\n");
1276         else
1277                 printf("UNIX ");
1278         return 0;
1279 }
1280
1281 static int
1282 MMHU(pacmac c12)
1283 {
1284         int c1, c2;
1285
1286         frommac(c12, c1, c2);
1287         if (parag) {
1288                 printf(".%c%c", c1, c2);
1289                 while (C != '\n')
1290                         putchar(c);
1291                 putchar('\n');
1292         } else {
1293                 SKIP;
1294         }
1295         return 0;
1296 }
1297
1298 static int
1299 mesnblock(pacmac c12)
1300 {
1301         int c1, c2;
1302
1303         frommac(c12, c1, c2);
1304         noblock(')', c2);
1305         return 0;
1306 }
1307
1308 static int
1309 mssnblock(pacmac c12)
1310 {
1311         int c1, c2;
1312
1313         frommac(c12, c1, c2);
1314         noblock(c1, 'E');
1315         return 0;
1316 }
1317
1318 static int
1319 /*ARGUSED*/
1320 nf(pacmac unused)
1321 {
1322
1323         noblock('f', 'i');
1324         return 0;
1325 }
1326
1327 static int
1328 /*ARGUSED*/
1329 ce(pacmac unused)
1330 {
1331
1332         sce();
1333         return 0;
1334 }
1335
1336 static int
1337 meip(pacmac c12)
1338 {
1339
1340         if (parag)
1341                 mepp(c12);
1342         else if (wordflag)      /* save the tag */
1343                 regline(meputmac, ONE);
1344         else
1345                 SKIP;
1346         return 0;
1347 }
1348
1349 /*
1350  *      only called for -me .pp or .sh, when parag is on
1351  */
1352 static int
1353 mepp(pacmac c12)
1354 {
1355
1356         PP(c12);                /* eats the line */
1357         return 0;
1358 }
1359
1360 /*
1361  *      Start of a section heading; output the section name if doing words
1362  */
1363 static int
1364 mesh(pacmac c12)
1365 {
1366
1367         if (parag)
1368                 mepp(c12);
1369         else if (wordflag)
1370                 defcomline(c12);
1371         else
1372                 SKIP;
1373         return 0;
1374 }
1375
1376 /*
1377  *      process a font setting
1378  */
1379 static int
1380 mefont(pacmac c12)
1381 {
1382
1383         argconcat = 1;
1384         defcomline(c12);
1385         argconcat = 0;
1386         return 0;
1387 }
1388
1389 static int
1390 manfont(pacmac c12)
1391 {
1392
1393         return mefont(c12);
1394 }
1395
1396 static int
1397 manpp(pacmac c12)
1398 {
1399
1400         return mepp(c12);
1401 }
1402
1403 static void
1404 defcomline(pacmac c12)
1405 {
1406         int c1, c2;
1407
1408         frommac(c12, c1, c2);
1409         if (msflag && mac == MM && c2 == 'L') {
1410                 if (disp || c1 == 'R') {
1411                         noblock('L', 'E');
1412                 } else {
1413                         SKIP;
1414                         putchar('.');
1415                 }
1416         }
1417         else if (c1 == '.' && c2 == '.') {
1418                 if (msflag) {
1419                         SKIP;
1420                         return;
1421                 }
1422                 while (C == '.')
1423                         /*VOID*/;
1424         }
1425         ++inmacro;
1426         /*
1427          *      Process the arguments to the macro
1428          */
1429         switch (mac) {
1430         default:
1431         case MM:
1432         case MS:
1433                 if (c1 <= 'Z' && msflag)
1434                         regline(msputmac, ONE);
1435                 else
1436                         regline(msputmac, TWO);
1437                 break;
1438         case ME:
1439                 regline(meputmac, ONE);
1440                 break;
1441         }
1442         --inmacro;
1443 }
1444
1445 static void
1446 comline(void)
1447 {
1448         int     c1;
1449         int     c2;
1450         pacmac  c12;
1451         int     mid;
1452         int     lb, ub;
1453         int     hit;
1454         static  int     tabsize = 0;
1455         static  const struct mactab     *mactab = NULL;
1456         const struct mactab     *mp;
1457
1458         if (mactab == 0)
1459                  buildtab(&mactab, &tabsize);
1460 com:
1461         while (C == ' ' || c == '\t')
1462                 ;
1463 comx:
1464         if ((c1 = c) == '\n')
1465                 return;
1466         c2 = C;
1467         if (c1 == '.' && c2 != '.')
1468                 inmacro = NO;
1469         if (msflag && c1 == '[') {
1470                 refer(c2);
1471                 return;
1472         }
1473         if (parag && mac==MM && c1 == 'P' && c2 == '\n') {
1474                 printf(".P\n");
1475                 return;
1476         }
1477         if (c2 == '\n')
1478                 return;
1479         /*
1480          *      Single letter macro
1481          */
1482         if (mac == ME && (c2 == ' ' || c2 == '\t') )
1483                 c2 = ' ';
1484         c12 = tomac(c1, c2);
1485         /*
1486          *      binary search through the table of macros
1487          */
1488         lb = 0;
1489         ub = tabsize - 1;
1490         while (lb <= ub) {
1491                 mid = (ub + lb) / 2;
1492                 mp = &mactab[mid];
1493                 if (mp->macname < c12)
1494                         lb = mid + 1;
1495                 else if (mp->macname > c12)
1496                         ub = mid - 1;
1497                 else {
1498                         hit = 1;
1499 #ifdef FULLDEBUG
1500                         printf("preliminary hit macro %c%c ", c1, c2);
1501 #endif /* FULLDEBUG */
1502                         switch (mp->condition) {
1503                         case NONE:
1504                                 hit = YES;
1505                                 break;
1506                         case FNEST:
1507                                 hit = (filesp == files);
1508                                 break;
1509                         case NOMAC:
1510                                 hit = !inmacro;
1511                                 break;
1512                         case MAC:
1513                                 hit = inmacro;
1514                                 break;
1515                         case PARAG:
1516                                 hit = parag;
1517                                 break;
1518                         case NBLK:
1519                                 hit = !keepblock;
1520                                 break;
1521                         default:
1522                                 hit = 0;
1523                         }
1524
1525                         if (hit) {
1526 #ifdef FULLDEBUG
1527                                 printf("MATCH\n");
1528 #endif /* FULLDEBUG */
1529                                 switch ((*(mp->func))(c12)) {
1530                                 default:
1531                                         return;
1532                                 case COMX:
1533                                         goto comx;
1534                                 case COM:
1535                                         goto com;
1536                                 }
1537                         }
1538 #ifdef FULLDEBUG
1539                         printf("FAIL\n");
1540 #endif /* FULLDEBUG */
1541                         break;
1542                 }
1543         }
1544         defcomline(c12);
1545 }
1546
1547 static int
1548 macsort(const void *p1, const void *p2)
1549 {
1550         const struct mactab *t1 = p1;
1551         const struct mactab *t2 = p2;
1552
1553         return t1->macname - t2->macname;
1554 }
1555
1556 static int
1557 sizetab(const struct mactab *mp)
1558 {
1559         int i;
1560
1561         i = 0;
1562         if (mp) {
1563                 for (; mp->macname; mp++, i++)
1564                         /*VOID*/ ;
1565         }
1566         return i;
1567 }
1568
1569 static struct mactab *
1570 macfill(struct mactab *dst, const struct mactab *src)
1571 {
1572
1573         if (src) {
1574                 while (src->macname)
1575                         *dst++ = *src++;
1576         }
1577         return dst;
1578 }
1579
1580 static void
1581 usage(void)
1582 {
1583         extern char *__progname;
1584
1585         fprintf(stderr, "usage: %s [-ikpw ] [ -m a | e | l | m | s] [file ...]\n", __progname);
1586         exit(1);
1587 }
1588
1589 static void
1590 buildtab(const struct mactab **r_back, int *r_size)
1591 {
1592         size_t  size;
1593         const struct    mactab  *p1, *p2;
1594         struct  mactab  *back, *p;
1595
1596         size = sizetab(troffmactab) + sizetab(ppmactab);
1597         p1 = p2 = NULL;
1598         if (msflag) {
1599                 switch (mac) {
1600                 case ME:
1601                         p1 = memactab;
1602                         break;
1603                 case MM:
1604                         p1 = msmactab;
1605                         p2 = mmmactab;
1606                         break;
1607                 case MS:
1608                         p1 = msmactab;
1609                         break;
1610                 case MA:
1611                         p1 = manmactab;
1612                         break;
1613                 default:
1614                         break;
1615                 }
1616         }
1617         size += sizetab(p1);
1618         size += sizetab(p2);
1619         back = calloc(size + 2, sizeof(struct mactab));
1620         if (back == NULL)
1621                 err(1, NULL);
1622
1623         p = macfill(back, troffmactab);
1624         p = macfill(p, ppmactab);
1625         p = macfill(p, p1);
1626         p = macfill(p, p2);
1627
1628         qsort(back, size, sizeof(struct mactab), macsort);
1629         *r_size = size;
1630         *r_back = back;
1631 }
1632
1633 /*
1634  *      troff commands
1635  */
1636 static const struct mactab      troffmactab[] = {
1637         M(NONE,         '\\','"',       skip),  /* comment */
1638         M(NOMAC,        'd','e',        domacro),       /* define */
1639         M(NOMAC,        'i','g',        domacro),       /* ignore till .. */
1640         M(NOMAC,        'a','m',        domacro),       /* append macro */
1641         M(NBLK,         'n','f',        nf),    /* filled */
1642         M(NBLK,         'c','e',        ce),    /* centered */
1643
1644         M(NONE,         's','o',        so),    /* source a file */
1645         M(NONE,         'n','x',        nx),    /* go to next file */
1646
1647         M(NONE,         't','m',        skip),  /* print string on tty */
1648         M(NONE,         'h','w',        skip),  /* exception hyphen words */
1649         M(NONE,         0,0,            0)
1650 };
1651
1652 /*
1653  *      Preprocessor output
1654  */
1655 static const struct mactab      ppmactab[] = {
1656         M(FNEST,        'E','Q',        EQ),    /* equation starting */
1657         M(FNEST,        'T','S',        intbl), /* table starting */
1658         M(FNEST,        'T','C',        intbl), /* alternative table? */
1659         M(FNEST,        'T','&',        intbl), /* table reformatting */
1660         M(NONE,         'T','E',        outtbl),/* table ending */
1661         M(NONE,         'P','S',        PS),    /* picture starting */
1662         M(NONE,         0,0,            0)
1663 };
1664
1665 /*
1666  *      Particular to ms and mm
1667  */
1668 static const struct mactab      msmactab[] = {
1669         M(NONE,         'T','L',        skiptocom),     /* title follows */
1670         M(NONE,         'F','S',        skiptocom),     /* start footnote */
1671         M(NONE,         'O','K',        skiptocom),     /* Other kws */
1672
1673         M(NONE,         'N','R',        skip),  /* undocumented */
1674         M(NONE,         'N','D',        skip),  /* use supplied date */
1675
1676         M(PARAG,        'P','P',        PP),    /* begin parag */
1677         M(PARAG,        'I','P',        PP),    /* begin indent parag, tag x */
1678         M(PARAG,        'L','P',        PP),    /* left blocked parag */
1679
1680         M(NONE,         'A','U',        AU),    /* author */
1681         M(NONE,         'A','I',        AU),    /* authors institution */
1682
1683         M(NONE,         'S','H',        SH),    /* section heading */
1684         M(NONE,         'S','N',        SH),    /* undocumented */
1685         M(NONE,         'U','X',        UX),    /* unix */
1686
1687         M(NBLK,         'D','S',        mssnblock),     /* start display text */
1688         M(NBLK,         'K','S',        mssnblock),     /* start keep */
1689         M(NBLK,         'K','F',        mssnblock),     /* start float keep */
1690         M(NONE,         0,0,            0)
1691 };
1692
1693 static const struct mactab      mmmactab[] = {
1694         M(NONE,         'H',' ',        MMHU),  /* -mm ? */
1695         M(NONE,         'H','U',        MMHU),  /* -mm ? */
1696         M(PARAG,        'P',' ',        PP),    /* paragraph for -mm */
1697         M(NBLK,         'N','S',        mssnblock),     /* undocumented */
1698         M(NONE,         0,0,            0)
1699 };
1700
1701 static const struct mactab      memactab[] = {
1702         M(PARAG,        'p','p',        mepp),
1703         M(PARAG,        'l','p',        mepp),
1704         M(PARAG,        'n','p',        mepp),
1705         M(NONE,         'i','p',        meip),
1706
1707         M(NONE,         's','h',        mesh),
1708         M(NONE,         'u','h',        mesh),
1709
1710         M(NBLK,         '(','l',        mesnblock),
1711         M(NBLK,         '(','q',        mesnblock),
1712         M(NBLK,         '(','b',        mesnblock),
1713         M(NBLK,         '(','z',        mesnblock),
1714         M(NBLK,         '(','c',        mesnblock),
1715
1716         M(NBLK,         '(','d',        mesnblock),
1717         M(NBLK,         '(','f',        mesnblock),
1718         M(NBLK,         '(','x',        mesnblock),
1719
1720         M(NONE,         'r',' ',        mefont),
1721         M(NONE,         'i',' ',        mefont),
1722         M(NONE,         'b',' ',        mefont),
1723         M(NONE,         'u',' ',        mefont),
1724         M(NONE,         'q',' ',        mefont),
1725         M(NONE,         'r','b',        mefont),
1726         M(NONE,         'b','i',        mefont),
1727         M(NONE,         'b','x',        mefont),
1728         M(NONE,         0,0,            0)
1729 };
1730
1731 static const struct mactab      manmactab[] = {
1732         M(PARAG,        'B','I',        manfont),
1733         M(PARAG,        'B','R',        manfont),
1734         M(PARAG,        'I','B',        manfont),
1735         M(PARAG,        'I','R',        manfont),
1736         M(PARAG,        'R','B',        manfont),
1737         M(PARAG,        'R','I',        manfont),
1738
1739         M(PARAG,        'P','P',        manpp),
1740         M(PARAG,        'L','P',        manpp),
1741         M(PARAG,        'H','P',        manpp),
1742         M(NONE,         0,0,            0)
1743 };