![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to deroff.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / usr.bin|
Return to deroff.c CVS log | Up to [CSRG BSD Unix] / 42BSD / usr.bin |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)deroff.c 4.4 (Berkeley) 83/04/29"; ! 3: #endif not lint ! 4: ! 5: #include <stdio.h> ! 6: ! 7: /* ! 8: * Deroff command -- strip troff, eqn, and Tbl sequences from ! 9: * a file. Has two flags argument, -w, to cause output one word per line ! 10: * rather than in the original format. ! 11: * -mm (or -ms) causes the corresponding macro's to be interpreted ! 12: * so that just sentences are output ! 13: * -ml also gets rid of lists. ! 14: * Deroff follows .so and .nx commands, removes contents of macro ! 15: * definitions, equations (both .EQ ... .EN and $...$), ! 16: * Tbl command sequences, and Troff backslash constructions. ! 17: * ! 18: * All input is through the Cget macro; ! 19: * the most recently read character is in c. ! 20: * ! 21: * Modified by Robert Henry to process -me and -man macros. ! 22: */ ! 23: ! 24: #define Cget ( (c=getc(infile)) == EOF ? eof() : ((c==ldelim)&&(filesp==files) ? skeqn() : c) ) ! 25: #define C1get ( (c=getc(infile)) == EOF ? eof() : c) ! 26: ! 27: #ifdef DEBUG ! 28: # define C _C() ! 29: # define C1 _C1() ! 30: #else not DEBUG ! 31: # define C Cget ! 32: # define C1 C1get ! 33: #endif not DEBUG ! 34: ! 35: #define SKIP while(C != '\n') ! 36: #define SKIP_TO_COM SKIP; SKIP; pc=c; while(C != '.' || pc != '\n' || C > 'Z')pc=c ! 37: ! 38: #define YES 1 ! 39: #define NO 0 ! 40: #define MS 0 /* -ms */ ! 41: #define MM 1 /* -mm */ ! 42: #define ME 2 /* -me */ ! 43: #define MA 3 /* -man */ ! 44: ! 45: #ifdef DEBUG ! 46: char *mactab[] = {"-ms", "-mm", "-me", "-ma"}; ! 47: #endif DEBUG ! 48: ! 49: #define ONE 1 ! 50: #define TWO 2 ! 51: ! 52: #define NOCHAR -2 ! 53: #define SPECIAL 0 ! 54: #define APOS 1 ! 55: #define PUNCT 2 ! 56: #define DIGIT 3 ! 57: #define LETTER 4 ! 58: ! 59: int wordflag; ! 60: int msflag; /* processing a source written using a mac package */ ! 61: int mac; /* which package */ ! 62: int disp; ! 63: int parag; ! 64: int inmacro; ! 65: int intable; ! 66: int keepblock; /* keep blocks of text; normally false when msflag */ ! 67: ! 68: char chars[128]; /* SPECIAL, PUNCT, APOS, DIGIT, or LETTER */ ! 69: ! 70: char line[512]; ! 71: char *lp; ! 72: ! 73: int c; ! 74: int pc; ! 75: int ldelim; ! 76: int rdelim; ! 77: ! 78: ! 79: int argc; ! 80: char **argv; ! 81: ! 82: char fname[50]; ! 83: FILE *files[15]; ! 84: FILE **filesp; ! 85: FILE *infile; ! 86: FILE *opn(); ! 87: /* ! 88: * Flags for matching conditions other than ! 89: * the macro name ! 90: */ ! 91: #define NONE 0 ! 92: #define FNEST 1 /* no nested files */ ! 93: #define NOMAC 2 /* no macro */ ! 94: #define MAC 3 /* macro */ ! 95: #define PARAG 4 /* in a paragraph */ ! 96: #define MSF 5 /* msflag is on */ ! 97: #define NBLK 6 /* set if no blocks to be kept */ ! 98: ! 99: /* ! 100: * Return codes from macro minions, determine where to jump, ! 101: * how to repeat/reprocess text ! 102: */ ! 103: #define COMX 1 /* goto comx */ ! 104: #define COM 2 /* goto com */ ! 105: ! 106: main(ac, av) ! 107: int ac; ! 108: char **av; ! 109: { ! 110: register int i; ! 111: int errflg = 0; ! 112: register optchar; ! 113: FILE *opn(); ! 114: int kflag = NO; ! 115: char *p; ! 116: ! 117: wordflag = NO; ! 118: msflag = NO; ! 119: mac = ME; ! 120: disp = NO; ! 121: parag = NO; ! 122: inmacro = NO; ! 123: intable = NO; ! 124: ldelim = NOCHAR; ! 125: rdelim = NOCHAR; ! 126: keepblock = YES; ! 127: ! 128: for(argc = ac - 1, argv = av + 1; ! 129: ( (argc > 0) ! 130: && (argv[0][0] == '-') ! 131: && (argv[0][1] != '\0') ); ! 132: --argc, ++argv ! 133: ){ ! 134: for(p = argv[0]+1; *p; ++p) { ! 135: switch(*p) { ! 136: case 'p': ! 137: parag=YES; ! 138: break; ! 139: case 'k': ! 140: kflag = YES; ! 141: break; ! 142: case 'w': ! 143: wordflag = YES; ! 144: kflag = YES; ! 145: break; ! 146: case 'm': ! 147: msflag = YES; ! 148: keepblock = NO; ! 149: switch(p[1]){ ! 150: case 'm': mac = MM; p++; break; ! 151: case 's': mac = MS; p++; break; ! 152: case 'e': mac = ME; p++; break; ! 153: case 'a': mac = MA; p++; break; ! 154: case 'l': disp = YES; p++; break; ! 155: default: errflg++; break; ! 156: } ! 157: break; ! 158: default: ! 159: errflg++; ! 160: } ! 161: } ! 162: } ! 163: ! 164: if (kflag) ! 165: keepblock = YES; ! 166: if (errflg) ! 167: fatal("usage: deroff [ -w ] [ -k] [ -m (a e m s l) ] [ file ] ... \n", ! 168: (char *) NULL); ! 169: ! 170: #ifdef DEBUG ! 171: printf("msflag = %d, mac = %s, keepblock = %d, disp = %d\n", ! 172: msflag, mactab[mac], keepblock, disp); ! 173: #endif DEBUG ! 174: if (argc == 0){ ! 175: infile = stdin; ! 176: } else { ! 177: infile = opn(argv[0]); ! 178: --argc; ! 179: ++argv; ! 180: } ! 181: ! 182: ! 183: files[0] = infile; ! 184: filesp = &files[0]; ! 185: ! 186: for(i='a'; i<='z' ; ++i) ! 187: chars[i] = LETTER; ! 188: for(i='A'; i<='Z'; ++i) ! 189: chars[i] = LETTER; ! 190: for(i='0'; i<='9'; ++i) ! 191: chars[i] = DIGIT; ! 192: chars['\''] = APOS; ! 193: chars['&'] = APOS; ! 194: chars['.'] = PUNCT; ! 195: chars[','] = PUNCT; ! 196: chars[';'] = PUNCT; ! 197: chars['?'] = PUNCT; ! 198: chars[':'] = PUNCT; ! 199: work(); ! 200: } ! 201: char *calloc(); ! 202: ! 203: skeqn() ! 204: { ! 205: while((c = getc(infile)) != rdelim) ! 206: if(c == EOF) ! 207: c = eof(); ! 208: else if(c == '"') ! 209: while( (c = getc(infile)) != '"') ! 210: if(c == EOF) ! 211: c = eof(); ! 212: else if(c == '\\') ! 213: if((c = getc(infile)) == EOF) ! 214: c = eof(); ! 215: if(msflag)return(c='x'); ! 216: return(c = ' '); ! 217: } ! 218: ! 219: FILE *opn(p) ! 220: register char *p; ! 221: { ! 222: FILE *fd; ! 223: ! 224: if( (fd = fopen(p, "r")) == NULL) { ! 225: fprintf(stderr, "Deroff: "); ! 226: perror(p); ! 227: exit(1); ! 228: } ! 229: ! 230: return(fd); ! 231: } ! 232: ! 233: eof() ! 234: { ! 235: if(infile != stdin) ! 236: fclose(infile); ! 237: if(filesp > files) ! 238: infile = *--filesp; ! 239: else if (argc > 0) { ! 240: infile = opn(argv[0]); ! 241: --argc; ! 242: ++argv; ! 243: } else ! 244: exit(0); ! 245: return(C); ! 246: } ! 247: ! 248: getfname() ! 249: { ! 250: register char *p; ! 251: struct chain { ! 252: struct chain *nextp; ! 253: char *datap; ! 254: } *chainblock; ! 255: register struct chain *q; ! 256: static struct chain *namechain = NULL; ! 257: char *copys(); ! 258: ! 259: while(C == ' ') ; ! 260: ! 261: for(p = fname ; (*p=c)!= '\n' && c!=' ' && c!='\t' && c!='\\' ; ++p) ! 262: C; ! 263: *p = '\0'; ! 264: while(c != '\n') ! 265: C; ! 266: ! 267: /* see if this name has already been used */ ! 268: ! 269: for(q = namechain ; q; q = q->nextp) ! 270: if( ! strcmp(fname, q->datap)) ! 271: { ! 272: fname[0] = '\0'; ! 273: return; ! 274: } ! 275: ! 276: q = (struct chain *) calloc(1, sizeof(*chainblock)); ! 277: q->nextp = namechain; ! 278: q->datap = copys(fname); ! 279: namechain = q; ! 280: } ! 281: ! 282: fatal(s,p) ! 283: char *s, *p; ! 284: { ! 285: fprintf(stderr, "Deroff: "); ! 286: fprintf(stderr, s, p); ! 287: exit(1); ! 288: } ! 289: ! 290: /*ARGSUSED*/ ! 291: textline(str, const) ! 292: char *str; ! 293: int const; ! 294: { ! 295: if (wordflag) { ! 296: msputwords(0); ! 297: return; ! 298: } ! 299: puts(str); ! 300: } ! 301: ! 302: work() ! 303: { ! 304: for( ;; ) ! 305: { ! 306: C; ! 307: #ifdef FULLDEBUG ! 308: printf("Starting work with `%c'\n", c); ! 309: #endif FULLDEBUG ! 310: if(c == '.' || c == '\'') ! 311: comline(); ! 312: else ! 313: regline(textline, TWO); ! 314: } ! 315: } ! 316: ! 317: regline(pfunc, const) ! 318: int (*pfunc)(); ! 319: int const; ! 320: { ! 321: line[0] = c; ! 322: lp = line; ! 323: for( ; ; ) ! 324: { ! 325: if(c == '\\') { ! 326: *lp = ' '; ! 327: backsl(); ! 328: } ! 329: if(c == '\n') ! 330: break; ! 331: if(intable && c=='T') { ! 332: *++lp = C; ! 333: if(c=='{' || c=='}') { ! 334: lp[-1] = ' '; ! 335: *lp = C; ! 336: } ! 337: } else { ! 338: *++lp = C; ! 339: } ! 340: } ! 341: ! 342: *lp = '\0'; ! 343: ! 344: if(line[0] != '\0') ! 345: (*pfunc)(line, const); ! 346: } ! 347: ! 348: macro() ! 349: { ! 350: if(msflag){ ! 351: do { ! 352: SKIP; ! 353: } while(C!='.' || C!='.' || C=='.'); /* look for .. */ ! 354: if(c != '\n')SKIP; ! 355: return; ! 356: } ! 357: SKIP; ! 358: inmacro = YES; ! 359: } ! 360: ! 361: tbl() ! 362: { ! 363: while(C != '.'); ! 364: SKIP; ! 365: intable = YES; ! 366: } ! 367: stbl() ! 368: { ! 369: while(C != '.'); ! 370: SKIP_TO_COM; ! 371: if(c != 'T' || C != 'E'){ ! 372: SKIP; ! 373: pc=c; ! 374: while(C != '.' || pc != '\n' || C != 'T' || C != 'E')pc=c; ! 375: } ! 376: } ! 377: ! 378: eqn() ! 379: { ! 380: register int c1, c2; ! 381: register int dflg; ! 382: char last; ! 383: ! 384: last=0; ! 385: dflg = 1; ! 386: SKIP; ! 387: ! 388: for( ;;) ! 389: { ! 390: if(C1 == '.' || c == '\'') ! 391: { ! 392: while(C1==' ' || c=='\t') ! 393: ; ! 394: if(c=='E' && C1=='N') ! 395: { ! 396: SKIP; ! 397: if(msflag && dflg){ ! 398: putchar('x'); ! 399: putchar(' '); ! 400: if(last){ ! 401: putchar(last); ! 402: putchar('\n'); ! 403: } ! 404: } ! 405: return; ! 406: } ! 407: } ! 408: else if(c == 'd') /* look for delim */ ! 409: { ! 410: if(C1=='e' && C1=='l') ! 411: if( C1=='i' && C1=='m') ! 412: { ! 413: while(C1 == ' '); ! 414: if((c1=c)=='\n' || (c2=C1)=='\n' ! 415: || (c1=='o' && c2=='f' && C1=='f') ) ! 416: { ! 417: ldelim = NOCHAR; ! 418: rdelim = NOCHAR; ! 419: } ! 420: else { ! 421: ldelim = c1; ! 422: rdelim = c2; ! 423: } ! 424: } ! 425: dflg = 0; ! 426: } ! 427: ! 428: if(c != '\n') while(C1 != '\n'){ ! 429: if(chars[c] == PUNCT)last = c; ! 430: else if(c != ' ')last = 0; ! 431: } ! 432: } ! 433: } ! 434: ! 435: backsl() /* skip over a complete backslash construction */ ! 436: { ! 437: int bdelim; ! 438: ! 439: sw: ! 440: switch(C) ! 441: { ! 442: case '"': ! 443: SKIP; ! 444: return; ! 445: case 's': ! 446: if(C == '\\') backsl(); ! 447: else { ! 448: while(C>='0' && c<='9') ; ! 449: ungetc(c,infile); ! 450: c = '0'; ! 451: } ! 452: --lp; ! 453: return; ! 454: ! 455: case 'f': ! 456: case 'n': ! 457: case '*': ! 458: if(C != '(') ! 459: return; ! 460: ! 461: case '(': ! 462: if(msflag){ ! 463: if(C == 'e'){ ! 464: if(C == 'm'){ ! 465: *lp = '-'; ! 466: return; ! 467: } ! 468: } ! 469: else if(c != '\n')C; ! 470: return; ! 471: } ! 472: if(C != '\n') C; ! 473: return; ! 474: ! 475: case '$': ! 476: C; /* discard argument number */ ! 477: return; ! 478: ! 479: case 'b': ! 480: case 'x': ! 481: case 'v': ! 482: case 'h': ! 483: case 'w': ! 484: case 'o': ! 485: case 'l': ! 486: case 'L': ! 487: if( (bdelim=C) == '\n') ! 488: return; ! 489: while(C!='\n' && c!=bdelim) ! 490: if(c == '\\') backsl(); ! 491: return; ! 492: ! 493: case '\\': ! 494: if(inmacro) ! 495: goto sw; ! 496: default: ! 497: return; ! 498: } ! 499: } ! 500: ! 501: char *copys(s) ! 502: register char *s; ! 503: { ! 504: register char *t, *t0; ! 505: ! 506: if( (t0 = t = calloc( (unsigned)(strlen(s)+1), sizeof(*t) ) ) == NULL) ! 507: fatal("Cannot allocate memory", (char *) NULL); ! 508: ! 509: while( *t++ = *s++ ) ! 510: ; ! 511: return(t0); ! 512: } ! 513: ! 514: sce() ! 515: { ! 516: register char *ap; ! 517: register int n, i; ! 518: char a[10]; ! 519: for(ap=a;C != '\n';ap++){ ! 520: *ap = c; ! 521: if(ap == &a[9]){ ! 522: SKIP; ! 523: ap=a; ! 524: break; ! 525: } ! 526: } ! 527: if(ap != a)n = atoi(a); ! 528: else n = 1; ! 529: for(i=0;i<n;){ ! 530: if(C == '.'){ ! 531: if(C == 'c'){ ! 532: if(C == 'e'){ ! 533: while(C == ' '); ! 534: if(c == '0'){ ! 535: SKIP; ! 536: break; ! 537: } ! 538: else SKIP; ! 539: } ! 540: else SKIP; ! 541: } ! 542: else if(c == 'P' || C == 'P'){ ! 543: if(c != '\n')SKIP; ! 544: break; ! 545: } ! 546: else if(c != '\n')SKIP; ! 547: } ! 548: else { ! 549: SKIP; ! 550: i++; ! 551: } ! 552: } ! 553: } ! 554: ! 555: refer(c1) ! 556: { ! 557: register int c2; ! 558: if(c1 != '\n') ! 559: SKIP; ! 560: while(1){ ! 561: if(C != '.') ! 562: SKIP; ! 563: else { ! 564: if(C != ']') ! 565: SKIP; ! 566: else { ! 567: while(C != '\n') ! 568: c2=c; ! 569: if(chars[c2] == PUNCT)putchar(c2); ! 570: return; ! 571: } ! 572: } ! 573: } ! 574: } ! 575: ! 576: inpic() ! 577: { ! 578: register int c1; ! 579: register char *p1; ! 580: SKIP; ! 581: p1 = line; ! 582: c = '\n'; ! 583: while(1){ ! 584: c1 = c; ! 585: if(C == '.' && c1 == '\n'){ ! 586: if(C != 'P'){ ! 587: if(c == '\n')continue; ! 588: else { SKIP; c='\n'; continue;} ! 589: } ! 590: if(C != 'E'){ ! 591: if(c == '\n')continue; ! 592: else { SKIP; c='\n';continue; } ! 593: } ! 594: SKIP; ! 595: return; ! 596: } ! 597: else if(c == '\"'){ ! 598: while(C != '\"'){ ! 599: if(c == '\\'){ ! 600: if(C == '\"')continue; ! 601: ungetc(c,infile); ! 602: backsl(); ! 603: } ! 604: else *p1++ = c; ! 605: } ! 606: *p1++ = ' '; ! 607: } ! 608: else if(c == '\n' && p1 != line){ ! 609: *p1 = '\0'; ! 610: if(wordflag)msputwords(NO); ! 611: else { ! 612: puts(line); ! 613: putchar('\n'); ! 614: } ! 615: p1 = line; ! 616: } ! 617: } ! 618: } ! 619: ! 620: #ifdef DEBUG ! 621: _C1() ! 622: { ! 623: return(C1get); ! 624: } ! 625: _C() ! 626: { ! 627: return(Cget); ! 628: } ! 629: #endif DEBUG ! 630: ! 631: /* ! 632: * Macro processing ! 633: * ! 634: * Macro table definitions ! 635: */ ! 636: #define reg register ! 637: typedef int pacmac; /* compressed macro name */ ! 638: int argconcat = 0; /* concat arguments together (-me only) */ ! 639: ! 640: #define tomac(c1, c2) ((((c1) & 0xFF) << 8) | ((c2) & 0xFF)) ! 641: #define frommac(src, c1, c2) (((c1)=((src)>>8)&0xFF),((c2) =(src)&0xFF)) ! 642: ! 643: struct mactab{ ! 644: int condition; ! 645: pacmac macname; ! 646: int (*func)(); ! 647: }; ! 648: struct mactab troffmactab[]; ! 649: struct mactab ppmactab[]; ! 650: struct mactab msmactab[]; ! 651: struct mactab mmmactab[]; ! 652: struct mactab memactab[]; ! 653: struct mactab manmactab[]; ! 654: /* ! 655: * macro table initialization ! 656: */ ! 657: #define M(cond, c1, c2, func) {cond, tomac(c1, c2), func} ! 658: ! 659: /* ! 660: * Put out a macro line, using ms and mm conventions. ! 661: */ ! 662: msputmac(s, const) ! 663: register char *s; ! 664: int const; ! 665: { ! 666: register char *t; ! 667: register found; ! 668: int last; ! 669: found = 0; ! 670: ! 671: if (wordflag) { ! 672: msputwords(YES); ! 673: return; ! 674: } ! 675: while(*s) ! 676: { ! 677: while(*s==' ' || *s=='\t') ! 678: putchar(*s++); ! 679: for(t = s ; *t!=' ' && *t!='\t' && *t!='\0' ; ++t) ! 680: ; ! 681: if(*s == '\"')s++; ! 682: if(t>s+const && chars[ s[0] ]==LETTER && chars[ s[1] ]==LETTER){ ! 683: while(s < t) ! 684: if(*s == '\"')s++; ! 685: else ! 686: putchar(*s++); ! 687: last = *(t-1); ! 688: found++; ! 689: } ! 690: else if(found && chars[ s[0] ] == PUNCT && s[1] == '\0') ! 691: putchar(*s++); ! 692: else{ ! 693: last = *(t-1); ! 694: s = t; ! 695: } ! 696: } ! 697: putchar('\n'); ! 698: if(msflag && chars[last] == PUNCT){ ! 699: putchar(last); ! 700: putchar('\n'); ! 701: } ! 702: } ! 703: /* ! 704: * put out words (for the -w option) with ms and mm conventions ! 705: */ ! 706: msputwords(macline) ! 707: int macline; /* is this is a macro line */ ! 708: { ! 709: register char *p, *p1; ! 710: int i, nlet; ! 711: ! 712: for(p1 = line ; ;) { ! 713: /* ! 714: * skip initial specials ampersands and apostrophes ! 715: */ ! 716: while( chars[*p1] < DIGIT) ! 717: if(*p1++ == '\0') return; ! 718: nlet = 0; ! 719: for(p = p1 ; (i=chars[*p]) != SPECIAL ; ++p) ! 720: if(i == LETTER) ++nlet; ! 721: ! 722: if ( (macline && nlet > 1) ! 723: || (!macline && nlet > 2 ! 724: && chars[p1[0]] == LETTER ! 725: && chars[p1[1]] == LETTER) ) ! 726: { ! 727: /* ! 728: * delete trailing ampersands and apostrophes ! 729: */ ! 730: while( (p[-1]=='\'') ! 731: || (p[-1]=='&') ! 732: || (chars[p[-1]] == PUNCT) ){ ! 733: --p; ! 734: } ! 735: while(p1 < p) ! 736: putchar(*p1++); ! 737: putchar('\n'); ! 738: } else { ! 739: p1 = p; ! 740: } ! 741: } ! 742: } ! 743: /* ! 744: * put out a macro using the me conventions ! 745: */ ! 746: #define SKIPBLANK(cp) while(*cp == ' ' || *cp == '\t') { cp++; } ! 747: #define SKIPNONBLANK(cp) while(*cp !=' ' && *cp !='\cp' && *cp !='\0') { cp++; } ! 748: ! 749: meputmac(cp, const) ! 750: reg char *cp; ! 751: int const; ! 752: { ! 753: reg char *np; ! 754: int found; ! 755: int argno; ! 756: int last; ! 757: int inquote; ! 758: ! 759: if (wordflag) { ! 760: meputwords(YES); ! 761: return; ! 762: } ! 763: for (argno = 0; *cp; argno++){ ! 764: SKIPBLANK(cp); ! 765: inquote = (*cp == '"'); ! 766: if (inquote) ! 767: cp++; ! 768: for (np = cp; *np; np++){ ! 769: switch(*np){ ! 770: case '\n': ! 771: case '\0': break; ! 772: case '\t': ! 773: case ' ': if (inquote) { ! 774: continue; ! 775: } else { ! 776: goto endarg; ! 777: } ! 778: case '"': if(inquote && np[1] == '"'){ ! 779: strcpy(np, np + 1); ! 780: np++; ! 781: continue; ! 782: } else { ! 783: *np = ' '; /* bye bye " */ ! 784: goto endarg; ! 785: } ! 786: default: continue; ! 787: } ! 788: } ! 789: endarg: ; ! 790: /* ! 791: * cp points at the first char in the arg ! 792: * np points one beyond the last char in the arg ! 793: */ ! 794: if ((argconcat == 0) || (argconcat != argno)) { ! 795: putchar(' '); ! 796: } ! 797: #ifdef FULLDEBUG ! 798: { ! 799: char *p; ! 800: printf("[%d,%d: ", argno, np - cp); ! 801: for (p = cp; p < np; p++) { ! 802: putchar(*p); ! 803: } ! 804: printf("]"); ! 805: } ! 806: #endif FULLDEBUG ! 807: /* ! 808: * Determine if the argument merits being printed ! 809: * ! 810: * const is the cut off point below which something ! 811: * is not a word. ! 812: */ ! 813: if ( ( (np - cp) > const) ! 814: && ( inquote ! 815: || (chars[cp[0]] == LETTER)) ){ ! 816: for (cp = cp; cp < np; cp++){ ! 817: putchar(*cp); ! 818: } ! 819: last = np[-1]; ! 820: found++; ! 821: } else ! 822: if(found && (np - cp == 1) && chars[*cp] == PUNCT){ ! 823: putchar(*cp); ! 824: } else { ! 825: last = np[-1]; ! 826: } ! 827: cp = np; ! 828: } ! 829: if(msflag && chars[last] == PUNCT) ! 830: putchar(last); ! 831: putchar('\n'); ! 832: } ! 833: /* ! 834: * put out words (for the -w option) with ms and mm conventions ! 835: */ ! 836: meputwords(macline) ! 837: int macline; ! 838: { ! 839: msputwords(macline); ! 840: } ! 841: /* ! 842: * ! 843: * Skip over a nested set of macros ! 844: * ! 845: * Possible arguments to noblock are: ! 846: * ! 847: * fi end of unfilled text ! 848: * PE pic ending ! 849: * DE display ending ! 850: * ! 851: * for ms and mm only: ! 852: * KE keep ending ! 853: * ! 854: * NE undocumented match to NS (for mm?) ! 855: * LE mm only: matches RL or *L (for lists) ! 856: * ! 857: * for me: ! 858: * ([lqbzcdf] ! 859: */ ! 860: ! 861: noblock(a1, a2) ! 862: char a1, a2; ! 863: { ! 864: register int c1,c2; ! 865: register int eqnf; ! 866: int lct; ! 867: lct = 0; ! 868: eqnf = 1; ! 869: SKIP; ! 870: while(1){ ! 871: while(C != '.') ! 872: if(c == '\n') ! 873: continue; ! 874: else ! 875: SKIP; ! 876: if((c1=C) == '\n') ! 877: continue; ! 878: if((c2=C) == '\n') ! 879: continue; ! 880: if(c1==a1 && c2 == a2){ ! 881: SKIP; ! 882: if(lct != 0){ ! 883: lct--; ! 884: continue; ! 885: } ! 886: if(eqnf) ! 887: putchar('.'); ! 888: putchar('\n'); ! 889: return; ! 890: } else if(a1 == 'L' && c2 == 'L'){ ! 891: lct++; ! 892: SKIP; ! 893: } ! 894: /* ! 895: * equations (EQ) nested within a display ! 896: */ ! 897: else if(c1 == 'E' && c2 == 'Q'){ ! 898: if ( (mac == ME && a1 == ')') ! 899: || (mac != ME && a1 == 'D') ) { ! 900: eqn(); ! 901: eqnf=0; ! 902: } ! 903: } ! 904: /* ! 905: * turning on filling is done by the paragraphing ! 906: * macros ! 907: */ ! 908: else if(a1 == 'f') { /* .fi */ ! 909: if ( (mac == ME && (c2 == 'h' || c2 == 'p')) ! 910: ||(mac != ME && (c1 == 'P' || c2 == 'P')) ) { ! 911: SKIP; ! 912: return; ! 913: } ! 914: } else { ! 915: SKIP; ! 916: } ! 917: } ! 918: } ! 919: ! 920: EQ() ! 921: { ! 922: eqn(); ! 923: return(0); ! 924: } ! 925: domacro() ! 926: { ! 927: macro(); ! 928: return(0); ! 929: } ! 930: PS() ! 931: { ! 932: if (!msflag) { ! 933: inpic(); ! 934: } else { ! 935: noblock('P', 'E'); ! 936: } ! 937: return(0); ! 938: } ! 939: ! 940: skip() ! 941: { ! 942: SKIP; ! 943: return(0); ! 944: } ! 945: ! 946: intbl() ! 947: { ! 948: if(msflag){ ! 949: stbl(); ! 950: } ! 951: else tbl(); ! 952: return(0); ! 953: } ! 954: ! 955: outtbl(){ intable = NO; } ! 956: ! 957: so() ! 958: { ! 959: getfname(); ! 960: if( fname[0] ) ! 961: infile = *++filesp = opn( fname ); ! 962: return(0); ! 963: } ! 964: nx() ! 965: { ! 966: getfname(); ! 967: if(fname[0] == '\0') exit(0); ! 968: if(infile != stdin) ! 969: fclose(infile); ! 970: infile = *filesp = opn(fname); ! 971: return(0); ! 972: } ! 973: skiptocom(){ SKIP_TO_COM; return(COMX); } ! 974: ! 975: PP(c12) ! 976: pacmac c12; ! 977: { ! 978: int c1, c2; ! 979: ! 980: frommac(c12, c1, c2); ! 981: printf(".%c%c",c1,c2); ! 982: while(C != '\n')putchar(c); ! 983: putchar('\n'); ! 984: return(0); ! 985: } ! 986: AU() ! 987: { ! 988: if(mac==MM) { ! 989: return(0); ! 990: } else { ! 991: SKIP_TO_COM; ! 992: return(COMX); ! 993: } ! 994: } ! 995: ! 996: SH(c12) ! 997: pacmac c12; ! 998: { ! 999: int c1, c2; ! 1000: ! 1001: frommac(c12, c1, c2); ! 1002: ! 1003: if(parag){ ! 1004: printf(".%c%c",c1,c2); ! 1005: while(C != '\n')putchar(c); ! 1006: putchar(c); ! 1007: putchar('!'); ! 1008: while(1){ ! 1009: while(C != '\n')putchar(c); ! 1010: putchar('\n'); ! 1011: if(C == '.') ! 1012: return(COM); ! 1013: putchar('!'); ! 1014: putchar(c); ! 1015: } ! 1016: /*NOTREACHED*/ ! 1017: } else { ! 1018: SKIP_TO_COM; ! 1019: return(COMX); ! 1020: } ! 1021: } ! 1022: ! 1023: UX() ! 1024: { ! 1025: if(wordflag) ! 1026: printf("UNIX\n"); ! 1027: else ! 1028: printf("UNIX "); ! 1029: return(0); ! 1030: } ! 1031: ! 1032: MMHU(c12) ! 1033: pacmac c12; ! 1034: { ! 1035: int c1, c2; ! 1036: ! 1037: frommac(c12, c1, c2); ! 1038: if(parag){ ! 1039: printf(".%c%c",c1,c2); ! 1040: while(C != '\n')putchar(c); ! 1041: putchar('\n'); ! 1042: } else { ! 1043: SKIP; ! 1044: } ! 1045: return(0); ! 1046: } ! 1047: ! 1048: mesnblock(c12) ! 1049: pacmac c12; ! 1050: { ! 1051: int c1, c2; ! 1052: ! 1053: frommac(c12, c1, c2); ! 1054: noblock(')',c2); ! 1055: return(0); ! 1056: } ! 1057: mssnblock(c12) ! 1058: pacmac c12; ! 1059: { ! 1060: int c1, c2; ! 1061: ! 1062: frommac(c12, c1, c2); ! 1063: noblock(c1,'E'); ! 1064: return(0); ! 1065: } ! 1066: nf() ! 1067: { ! 1068: noblock('f','i'); ! 1069: return(0); ! 1070: } ! 1071: ! 1072: ce() ! 1073: { ! 1074: sce(); ! 1075: return(0); ! 1076: } ! 1077: ! 1078: meip(c12) ! 1079: pacmac c12; ! 1080: { ! 1081: if(parag) ! 1082: mepp(c12); ! 1083: else if (wordflag) /* save the tag */ ! 1084: regline(meputmac, ONE); ! 1085: else { ! 1086: SKIP; ! 1087: } ! 1088: return(0); ! 1089: } ! 1090: /* ! 1091: * only called for -me .pp or .sh, when parag is on ! 1092: */ ! 1093: mepp(c12) ! 1094: pacmac c12; ! 1095: { ! 1096: PP(c12); /* eats the line */ ! 1097: return(0); ! 1098: } ! 1099: /* ! 1100: * Start of a section heading; output the section name if doing words ! 1101: */ ! 1102: mesh(c12) ! 1103: pacmac c12; ! 1104: { ! 1105: if (parag) ! 1106: mepp(c12); ! 1107: else if (wordflag) ! 1108: defcomline(c12); ! 1109: else { ! 1110: SKIP; ! 1111: } ! 1112: return(0); ! 1113: } ! 1114: /* ! 1115: * process a font setting ! 1116: */ ! 1117: mefont(c12) ! 1118: pacmac c12; ! 1119: { ! 1120: argconcat = 1; ! 1121: defcomline(c12); ! 1122: argconcat = 0; ! 1123: return(0); ! 1124: } ! 1125: manfont(c12) ! 1126: pacmac c12; ! 1127: { ! 1128: return(mefont(c12)); ! 1129: } ! 1130: manpp(c12) ! 1131: pacmac c12; ! 1132: { ! 1133: return(mepp(c12)); ! 1134: } ! 1135: ! 1136: defcomline(c12) ! 1137: pacmac c12; ! 1138: { ! 1139: int c1, c2; ! 1140: ! 1141: frommac(c12, c1, c2); ! 1142: if(msflag && mac==MM && c2=='L'){ ! 1143: if(disp || c1 == 'R') { ! 1144: noblock('L','E'); ! 1145: } else { ! 1146: SKIP; ! 1147: putchar('.'); ! 1148: } ! 1149: } ! 1150: else if(c1=='.' && c2=='.'){ ! 1151: if(msflag){ ! 1152: SKIP; ! 1153: return; ! 1154: } ! 1155: while(C == '.') ! 1156: /*VOID*/; ! 1157: } ! 1158: ++inmacro; ! 1159: /* ! 1160: * Process the arguments to the macro ! 1161: */ ! 1162: switch(mac){ ! 1163: default: ! 1164: case MM: ! 1165: case MS: ! 1166: if(c1 <= 'Z' && msflag) ! 1167: regline(msputmac, ONE); ! 1168: else ! 1169: regline(msputmac, TWO); ! 1170: break; ! 1171: case ME: ! 1172: regline(meputmac, ONE); ! 1173: break; ! 1174: } ! 1175: --inmacro; ! 1176: } ! 1177: ! 1178: comline() ! 1179: { ! 1180: reg int c1; ! 1181: reg int c2; ! 1182: pacmac c12; ! 1183: reg int mid; ! 1184: int lb, ub; ! 1185: int hit; ! 1186: static int tabsize = 0; ! 1187: static struct mactab *mactab = (struct mactab *)0; ! 1188: reg struct mactab *mp; ! 1189: ! 1190: if (mactab == 0){ ! 1191: buildtab(&mactab, &tabsize); ! 1192: } ! 1193: com: ! 1194: while(C==' ' || c=='\t') ! 1195: ; ! 1196: comx: ! 1197: if( (c1=c) == '\n') ! 1198: return; ! 1199: c2 = C; ! 1200: if(c1=='.' && c2 !='.') ! 1201: inmacro = NO; ! 1202: if(msflag && c1 == '['){ ! 1203: refer(c2); ! 1204: return; ! 1205: } ! 1206: if(parag && mac==MM && c1 == 'P' && c2 == '\n'){ ! 1207: printf(".P\n"); ! 1208: return; ! 1209: } ! 1210: if(c2 == '\n') ! 1211: return; ! 1212: /* ! 1213: * Single letter macro ! 1214: */ ! 1215: if (mac == ME && (c2 == ' ' || c2 == '\t') ) ! 1216: c2 = ' '; ! 1217: c12 = tomac(c1, c2); ! 1218: /* ! 1219: * binary search through the table of macros ! 1220: */ ! 1221: lb = 0; ! 1222: ub = tabsize - 1; ! 1223: while(lb <= ub){ ! 1224: mid = (ub + lb) / 2; ! 1225: mp = &mactab[mid]; ! 1226: if (mp->macname < c12) ! 1227: lb = mid + 1; ! 1228: else if (mp->macname > c12) ! 1229: ub = mid - 1; ! 1230: else { ! 1231: hit = 1; ! 1232: #ifdef FULLDEBUG ! 1233: printf("preliminary hit macro %c%c ", c1, c2); ! 1234: #endif FULLDEBUG ! 1235: switch(mp->condition){ ! 1236: case NONE: hit = YES; break; ! 1237: case FNEST: hit = (filesp == files); break; ! 1238: case NOMAC: hit = !inmacro; break; ! 1239: case MAC: hit = inmacro; break; ! 1240: case PARAG: hit = parag; break; ! 1241: case NBLK: hit = !keepblock; break; ! 1242: default: hit = 0; ! 1243: } ! 1244: if (hit) { ! 1245: #ifdef FULLDEBUG ! 1246: printf("MATCH\n"); ! 1247: #endif FULLDEBUG ! 1248: switch( (*(mp->func))(c12) ) { ! 1249: default: return; ! 1250: case COMX: goto comx; ! 1251: case COM: goto com; ! 1252: } ! 1253: } ! 1254: #ifdef FULLDEBUG ! 1255: printf("FAIL\n"); ! 1256: #endif FULLDEBUG ! 1257: break; ! 1258: } ! 1259: } ! 1260: defcomline(c12); ! 1261: } ! 1262: ! 1263: int macsort(p1, p2) ! 1264: struct mactab *p1, *p2; ! 1265: { ! 1266: return(p1->macname - p2->macname); ! 1267: } ! 1268: ! 1269: int sizetab(mp) ! 1270: reg struct mactab *mp; ! 1271: { ! 1272: reg int i; ! 1273: i = 0; ! 1274: if (mp){ ! 1275: for (; mp->macname; mp++, i++) ! 1276: /*VOID*/ ; ! 1277: } ! 1278: return(i); ! 1279: } ! 1280: ! 1281: struct mactab *macfill(dst, src) ! 1282: reg struct mactab *dst; ! 1283: reg struct mactab *src; ! 1284: { ! 1285: if (src) { ! 1286: while(src->macname){ ! 1287: *dst++ = *src++; ! 1288: } ! 1289: } ! 1290: return(dst); ! 1291: } ! 1292: ! 1293: buildtab(r_back, r_size) ! 1294: struct mactab **r_back; ! 1295: int *r_size; ! 1296: { ! 1297: int size; ! 1298: ! 1299: struct mactab *p, *p1, *p2; ! 1300: struct mactab *back; ! 1301: ! 1302: size = sizetab(troffmactab); ! 1303: size += sizetab(ppmactab); ! 1304: p1 = p2 = (struct mactab *)0; ! 1305: if (msflag){ ! 1306: switch(mac){ ! 1307: case ME: p1 = memactab; break; ! 1308: case MM: p1 = msmactab; ! 1309: p2 = mmmactab; break; ! 1310: ! 1311: case MS: p1 = msmactab; break; ! 1312: case MA: p1 = manmactab; break; ! 1313: default: break; ! 1314: } ! 1315: } ! 1316: size += sizetab(p1); ! 1317: size += sizetab(p2); ! 1318: back = (struct mactab *)calloc(size+2, sizeof(struct mactab)); ! 1319: ! 1320: p = macfill(back, troffmactab); ! 1321: p = macfill(p, ppmactab); ! 1322: p = macfill(p, p1); ! 1323: p = macfill(p, p2); ! 1324: ! 1325: qsort(back, size, sizeof(struct mactab), macsort); ! 1326: *r_size = size; ! 1327: *r_back = back; ! 1328: } ! 1329: ! 1330: /* ! 1331: * troff commands ! 1332: */ ! 1333: struct mactab troffmactab[] = { ! 1334: M(NONE, '\\','"', skip), /* comment */ ! 1335: M(NOMAC, 'd','e', domacro), /* define */ ! 1336: M(NOMAC, 'i','g', domacro), /* ignore till .. */ ! 1337: M(NOMAC, 'a','m', domacro), /* append macro */ ! 1338: M(NBLK, 'n','f', nf), /* filled */ ! 1339: M(NBLK, 'c','e', ce), /* centered */ ! 1340: ! 1341: M(NONE, 's','o', so), /* source a file */ ! 1342: M(NONE, 'n','x', nx), /* go to next file */ ! 1343: ! 1344: M(NONE, 't','m', skip), /* print string on tty */ ! 1345: M(NONE, 'h','w', skip), /* exception hyphen words */ ! 1346: M(NONE, 0,0, 0) ! 1347: }; ! 1348: /* ! 1349: * Preprocessor output ! 1350: */ ! 1351: struct mactab ppmactab[] = { ! 1352: M(FNEST, 'E','Q', EQ), /* equation starting */ ! 1353: M(FNEST, 'T','S', intbl), /* table starting */ ! 1354: M(FNEST, 'T','C', intbl), /* alternative table? */ ! 1355: M(FNEST, 'T','&', intbl), /* table reformatting */ ! 1356: M(NONE, 'T','E', outtbl),/* table ending */ ! 1357: M(NONE, 'P','S', PS), /* picture starting */ ! 1358: M(NONE, 0,0, 0) ! 1359: }; ! 1360: /* ! 1361: * Particular to ms and mm ! 1362: */ ! 1363: struct mactab msmactab[] = { ! 1364: M(NONE, 'T','L', skiptocom), /* title follows */ ! 1365: M(NONE, 'F','S', skiptocom), /* start footnote */ ! 1366: M(NONE, 'O','K', skiptocom), /* Other kws */ ! 1367: ! 1368: M(NONE, 'N','R', skip), /* undocumented */ ! 1369: M(NONE, 'N','D', skip), /* use supplied date */ ! 1370: ! 1371: M(PARAG, 'P','P', PP), /* begin parag */ ! 1372: M(PARAG, 'I','P', PP), /* begin indent parag, tag x */ ! 1373: M(PARAG, 'L','P', PP), /* left blocked parag */ ! 1374: ! 1375: M(NONE, 'A','U', AU), /* author */ ! 1376: M(NONE, 'A','I', AU), /* authors institution */ ! 1377: ! 1378: M(NONE, 'S','H', SH), /* section heading */ ! 1379: M(NONE, 'S','N', SH), /* undocumented */ ! 1380: M(NONE, 'U','X', UX), /* unix */ ! 1381: ! 1382: M(NBLK, 'D','S', mssnblock), /* start display text */ ! 1383: M(NBLK, 'K','S', mssnblock), /* start keep */ ! 1384: M(NBLK, 'K','F', mssnblock), /* start float keep */ ! 1385: M(NONE, 0,0, 0) ! 1386: }; ! 1387: ! 1388: struct mactab mmmactab[] = { ! 1389: M(NONE, 'H',' ', MMHU), /* -mm ? */ ! 1390: M(NONE, 'H','U', MMHU), /* -mm ? */ ! 1391: M(PARAG, 'P',' ', PP), /* paragraph for -mm */ ! 1392: M(NBLK, 'N','S', mssnblock), /* undocumented */ ! 1393: M(NONE, 0,0, 0) ! 1394: }; ! 1395: ! 1396: struct mactab memactab[] = { ! 1397: M(PARAG, 'p','p', mepp), ! 1398: M(PARAG, 'l','p', mepp), ! 1399: M(PARAG, 'n','p', mepp), ! 1400: M(NONE, 'i','p', meip), ! 1401: ! 1402: M(NONE, 's','h', mesh), ! 1403: M(NONE, 'u','h', mesh), ! 1404: ! 1405: M(NBLK, '(','l', mesnblock), ! 1406: M(NBLK, '(','q', mesnblock), ! 1407: M(NBLK, '(','b', mesnblock), ! 1408: M(NBLK, '(','z', mesnblock), ! 1409: M(NBLK, '(','c', mesnblock), ! 1410: ! 1411: M(NBLK, '(','d', mesnblock), ! 1412: M(NBLK, '(','f', mesnblock), ! 1413: M(NBLK, '(','x', mesnblock), ! 1414: ! 1415: M(NONE, 'r',' ', mefont), ! 1416: M(NONE, 'i',' ', mefont), ! 1417: M(NONE, 'b',' ', mefont), ! 1418: M(NONE, 'u',' ', mefont), ! 1419: M(NONE, 'q',' ', mefont), ! 1420: M(NONE, 'r','b', mefont), ! 1421: M(NONE, 'b','i', mefont), ! 1422: M(NONE, 'b','x', mefont), ! 1423: M(NONE, 0,0, 0) ! 1424: }; ! 1425: ! 1426: ! 1427: struct mactab manmactab[] = { ! 1428: M(PARAG, 'B','I', manfont), ! 1429: M(PARAG, 'B','R', manfont), ! 1430: M(PARAG, 'I','B', manfont), ! 1431: M(PARAG, 'I','R', manfont), ! 1432: M(PARAG, 'R','B', manfont), ! 1433: M(PARAG, 'R','I', manfont), ! 1434: ! 1435: M(PARAG, 'P','P', manpp), ! 1436: M(PARAG, 'L','P', manpp), ! 1437: M(PARAG, 'H','P', manpp), ! 1438: M(NONE, 0,0, 0) ! 1439: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.