![[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] / 43BSDTahoe / usr.bin|
Return to deroff.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)deroff.c 4.7 (Berkeley) 88/04/24";
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, constant)
292: char *str;
293: int constant;
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, constant)
318: int (*pfunc)();
319: int constant;
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, constant);
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, constant)
663: register char *s;
664: int constant;
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+constant && 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 (nlet > 1 && chars[p1[0]] == LETTER) {
723: /*
724: * delete trailing ampersands and apostrophes
725: */
726: while( (i=chars[p[-1]]) == PUNCT || i == APOS )
727: --p;
728: while(p1 < p)
729: putchar(*p1++);
730: putchar('\n');
731: } else {
732: p1 = p;
733: }
734: }
735: }
736: /*
737: * put out a macro using the me conventions
738: */
739: #define SKIPBLANK(cp) while(*cp == ' ' || *cp == '\t') { cp++; }
740: #define SKIPNONBLANK(cp) while(*cp !=' ' && *cp !='\cp' && *cp !='\0') { cp++; }
741:
742: meputmac(cp, constant)
743: reg char *cp;
744: int constant;
745: {
746: reg char *np;
747: int found;
748: int argno;
749: int last;
750: int inquote;
751:
752: if (wordflag) {
753: meputwords(YES);
754: return;
755: }
756: for (argno = 0; *cp; argno++){
757: SKIPBLANK(cp);
758: inquote = (*cp == '"');
759: if (inquote)
760: cp++;
761: for (np = cp; *np; np++){
762: switch(*np){
763: case '\n':
764: case '\0': break;
765: case '\t':
766: case ' ': if (inquote) {
767: continue;
768: } else {
769: goto endarg;
770: }
771: case '"': if(inquote && np[1] == '"'){
772: strcpy(np, np + 1);
773: np++;
774: continue;
775: } else {
776: *np = ' '; /* bye bye " */
777: goto endarg;
778: }
779: default: continue;
780: }
781: }
782: endarg: ;
783: /*
784: * cp points at the first char in the arg
785: * np points one beyond the last char in the arg
786: */
787: if ((argconcat == 0) || (argconcat != argno)) {
788: putchar(' ');
789: }
790: #ifdef FULLDEBUG
791: {
792: char *p;
793: printf("[%d,%d: ", argno, np - cp);
794: for (p = cp; p < np; p++) {
795: putchar(*p);
796: }
797: printf("]");
798: }
799: #endif FULLDEBUG
800: /*
801: * Determine if the argument merits being printed
802: *
803: * constant is the cut off point below which something
804: * is not a word.
805: */
806: if ( ( (np - cp) > constant)
807: && ( inquote
808: || (chars[cp[0]] == LETTER)) ){
809: for (cp = cp; cp < np; cp++){
810: putchar(*cp);
811: }
812: last = np[-1];
813: found++;
814: } else
815: if(found && (np - cp == 1) && chars[*cp] == PUNCT){
816: putchar(*cp);
817: } else {
818: last = np[-1];
819: }
820: cp = np;
821: }
822: if(msflag && chars[last] == PUNCT)
823: putchar(last);
824: putchar('\n');
825: }
826: /*
827: * put out words (for the -w option) with ms and mm conventions
828: */
829: meputwords(macline)
830: int macline;
831: {
832: msputwords(macline);
833: }
834: /*
835: *
836: * Skip over a nested set of macros
837: *
838: * Possible arguments to noblock are:
839: *
840: * fi end of unfilled text
841: * PE pic ending
842: * DE display ending
843: *
844: * for ms and mm only:
845: * KE keep ending
846: *
847: * NE undocumented match to NS (for mm?)
848: * LE mm only: matches RL or *L (for lists)
849: *
850: * for me:
851: * ([lqbzcdf]
852: */
853:
854: noblock(a1, a2)
855: char a1, a2;
856: {
857: register int c1,c2;
858: register int eqnf;
859: int lct;
860: lct = 0;
861: eqnf = 1;
862: SKIP;
863: while(1){
864: while(C != '.')
865: if(c == '\n')
866: continue;
867: else
868: SKIP;
869: if((c1=C) == '\n')
870: continue;
871: if((c2=C) == '\n')
872: continue;
873: if(c1==a1 && c2 == a2){
874: SKIP;
875: if(lct != 0){
876: lct--;
877: continue;
878: }
879: if(eqnf)
880: putchar('.');
881: putchar('\n');
882: return;
883: } else if(a1 == 'L' && c2 == 'L'){
884: lct++;
885: SKIP;
886: }
887: /*
888: * equations (EQ) nested within a display
889: */
890: else if(c1 == 'E' && c2 == 'Q'){
891: if ( (mac == ME && a1 == ')')
892: || (mac != ME && a1 == 'D') ) {
893: eqn();
894: eqnf=0;
895: }
896: }
897: /*
898: * turning on filling is done by the paragraphing
899: * macros
900: */
901: else if(a1 == 'f') { /* .fi */
902: if ( (mac == ME && (c2 == 'h' || c2 == 'p'))
903: ||(mac != ME && (c1 == 'P' || c2 == 'P')) ) {
904: SKIP;
905: return;
906: }
907: } else {
908: SKIP;
909: }
910: }
911: }
912:
913: EQ()
914: {
915: eqn();
916: return(0);
917: }
918: domacro()
919: {
920: macro();
921: return(0);
922: }
923: PS()
924: {
925: for (C; c == ' ' || c == '\t'; C);
926: if (c == '<') { /* ".PS < file" -- don't expect a .PE */
927: SKIP;
928: return(0);
929: }
930: if (!msflag) {
931: inpic();
932: } else {
933: noblock('P', 'E');
934: }
935: return(0);
936: }
937:
938: skip()
939: {
940: SKIP;
941: return(0);
942: }
943:
944: intbl()
945: {
946: if(msflag){
947: stbl();
948: }
949: else tbl();
950: return(0);
951: }
952:
953: outtbl(){ intable = NO; }
954:
955: so()
956: {
957: getfname();
958: if( fname[0] )
959: infile = *++filesp = opn( fname );
960: return(0);
961: }
962: nx()
963: {
964: getfname();
965: if(fname[0] == '\0') exit(0);
966: if(infile != stdin)
967: fclose(infile);
968: infile = *filesp = opn(fname);
969: return(0);
970: }
971: skiptocom(){ SKIP_TO_COM; return(COMX); }
972:
973: PP(c12)
974: pacmac c12;
975: {
976: int c1, c2;
977:
978: frommac(c12, c1, c2);
979: printf(".%c%c",c1,c2);
980: while(C != '\n')putchar(c);
981: putchar('\n');
982: return(0);
983: }
984: AU()
985: {
986: if(mac==MM) {
987: return(0);
988: } else {
989: SKIP_TO_COM;
990: return(COMX);
991: }
992: }
993:
994: SH(c12)
995: pacmac c12;
996: {
997: int c1, c2;
998:
999: frommac(c12, c1, c2);
1000:
1001: if(parag){
1002: printf(".%c%c",c1,c2);
1003: while(C != '\n')putchar(c);
1004: putchar(c);
1005: putchar('!');
1006: while(1){
1007: while(C != '\n')putchar(c);
1008: putchar('\n');
1009: if(C == '.')
1010: return(COM);
1011: putchar('!');
1012: putchar(c);
1013: }
1014: /*NOTREACHED*/
1015: } else {
1016: SKIP_TO_COM;
1017: return(COMX);
1018: }
1019: }
1020:
1021: UX()
1022: {
1023: if(wordflag)
1024: printf("UNIX\n");
1025: else
1026: printf("UNIX ");
1027: return(0);
1028: }
1029:
1030: MMHU(c12)
1031: pacmac c12;
1032: {
1033: int c1, c2;
1034:
1035: frommac(c12, c1, c2);
1036: if(parag){
1037: printf(".%c%c",c1,c2);
1038: while(C != '\n')putchar(c);
1039: putchar('\n');
1040: } else {
1041: SKIP;
1042: }
1043: return(0);
1044: }
1045:
1046: mesnblock(c12)
1047: pacmac c12;
1048: {
1049: int c1, c2;
1050:
1051: frommac(c12, c1, c2);
1052: noblock(')',c2);
1053: return(0);
1054: }
1055: mssnblock(c12)
1056: pacmac c12;
1057: {
1058: int c1, c2;
1059:
1060: frommac(c12, c1, c2);
1061: noblock(c1,'E');
1062: return(0);
1063: }
1064: nf()
1065: {
1066: noblock('f','i');
1067: return(0);
1068: }
1069:
1070: ce()
1071: {
1072: sce();
1073: return(0);
1074: }
1075:
1076: meip(c12)
1077: pacmac c12;
1078: {
1079: if(parag)
1080: mepp(c12);
1081: else if (wordflag) /* save the tag */
1082: regline(meputmac, ONE);
1083: else {
1084: SKIP;
1085: }
1086: return(0);
1087: }
1088: /*
1089: * only called for -me .pp or .sh, when parag is on
1090: */
1091: mepp(c12)
1092: pacmac c12;
1093: {
1094: PP(c12); /* eats the line */
1095: return(0);
1096: }
1097: /*
1098: * Start of a section heading; output the section name if doing words
1099: */
1100: mesh(c12)
1101: pacmac c12;
1102: {
1103: if (parag)
1104: mepp(c12);
1105: else if (wordflag)
1106: defcomline(c12);
1107: else {
1108: SKIP;
1109: }
1110: return(0);
1111: }
1112: /*
1113: * process a font setting
1114: */
1115: mefont(c12)
1116: pacmac c12;
1117: {
1118: argconcat = 1;
1119: defcomline(c12);
1120: argconcat = 0;
1121: return(0);
1122: }
1123: manfont(c12)
1124: pacmac c12;
1125: {
1126: return(mefont(c12));
1127: }
1128: manpp(c12)
1129: pacmac c12;
1130: {
1131: return(mepp(c12));
1132: }
1133:
1134: defcomline(c12)
1135: pacmac c12;
1136: {
1137: int c1, c2;
1138:
1139: frommac(c12, c1, c2);
1140: if(msflag && mac==MM && c2=='L'){
1141: if(disp || c1 == 'R') {
1142: noblock('L','E');
1143: } else {
1144: SKIP;
1145: putchar('.');
1146: }
1147: }
1148: else if(c1=='.' && c2=='.'){
1149: if(msflag){
1150: SKIP;
1151: return;
1152: }
1153: while(C == '.')
1154: /*VOID*/;
1155: }
1156: ++inmacro;
1157: /*
1158: * Process the arguments to the macro
1159: */
1160: switch(mac){
1161: default:
1162: case MM:
1163: case MS:
1164: if(c1 <= 'Z' && msflag)
1165: regline(msputmac, ONE);
1166: else
1167: regline(msputmac, TWO);
1168: break;
1169: case ME:
1170: regline(meputmac, ONE);
1171: break;
1172: }
1173: --inmacro;
1174: }
1175:
1176: comline()
1177: {
1178: reg int c1;
1179: reg int c2;
1180: pacmac c12;
1181: reg int mid;
1182: int lb, ub;
1183: int hit;
1184: static int tabsize = 0;
1185: static struct mactab *mactab = (struct mactab *)0;
1186: reg struct mactab *mp;
1187:
1188: if (mactab == 0){
1189: buildtab(&mactab, &tabsize);
1190: }
1191: com:
1192: while(C==' ' || c=='\t')
1193: ;
1194: comx:
1195: if( (c1=c) == '\n')
1196: return;
1197: c2 = C;
1198: if(c1=='.' && c2 !='.')
1199: inmacro = NO;
1200: if(msflag && c1 == '['){
1201: refer(c2);
1202: return;
1203: }
1204: if(parag && mac==MM && c1 == 'P' && c2 == '\n'){
1205: printf(".P\n");
1206: return;
1207: }
1208: if(c2 == '\n')
1209: return;
1210: /*
1211: * Single letter macro
1212: */
1213: if (mac == ME && (c2 == ' ' || c2 == '\t') )
1214: c2 = ' ';
1215: c12 = tomac(c1, c2);
1216: /*
1217: * binary search through the table of macros
1218: */
1219: lb = 0;
1220: ub = tabsize - 1;
1221: while(lb <= ub){
1222: mid = (ub + lb) / 2;
1223: mp = &mactab[mid];
1224: if (mp->macname < c12)
1225: lb = mid + 1;
1226: else if (mp->macname > c12)
1227: ub = mid - 1;
1228: else {
1229: hit = 1;
1230: #ifdef FULLDEBUG
1231: printf("preliminary hit macro %c%c ", c1, c2);
1232: #endif FULLDEBUG
1233: switch(mp->condition){
1234: case NONE: hit = YES; break;
1235: case FNEST: hit = (filesp == files); break;
1236: case NOMAC: hit = !inmacro; break;
1237: case MAC: hit = inmacro; break;
1238: case PARAG: hit = parag; break;
1239: case NBLK: hit = !keepblock; break;
1240: default: hit = 0;
1241: }
1242: if (hit) {
1243: #ifdef FULLDEBUG
1244: printf("MATCH\n");
1245: #endif FULLDEBUG
1246: switch( (*(mp->func))(c12) ) {
1247: default: return;
1248: case COMX: goto comx;
1249: case COM: goto com;
1250: }
1251: }
1252: #ifdef FULLDEBUG
1253: printf("FAIL\n");
1254: #endif FULLDEBUG
1255: break;
1256: }
1257: }
1258: defcomline(c12);
1259: }
1260:
1261: int macsort(p1, p2)
1262: struct mactab *p1, *p2;
1263: {
1264: return(p1->macname - p2->macname);
1265: }
1266:
1267: int sizetab(mp)
1268: reg struct mactab *mp;
1269: {
1270: reg int i;
1271: i = 0;
1272: if (mp){
1273: for (; mp->macname; mp++, i++)
1274: /*VOID*/ ;
1275: }
1276: return(i);
1277: }
1278:
1279: struct mactab *macfill(dst, src)
1280: reg struct mactab *dst;
1281: reg struct mactab *src;
1282: {
1283: if (src) {
1284: while(src->macname){
1285: *dst++ = *src++;
1286: }
1287: }
1288: return(dst);
1289: }
1290:
1291: buildtab(r_back, r_size)
1292: struct mactab **r_back;
1293: int *r_size;
1294: {
1295: int size;
1296:
1297: struct mactab *p, *p1, *p2;
1298: struct mactab *back;
1299:
1300: size = sizetab(troffmactab);
1301: size += sizetab(ppmactab);
1302: p1 = p2 = (struct mactab *)0;
1303: if (msflag){
1304: switch(mac){
1305: case ME: p1 = memactab; break;
1306: case MM: p1 = msmactab;
1307: p2 = mmmactab; break;
1308:
1309: case MS: p1 = msmactab; break;
1310: case MA: p1 = manmactab; break;
1311: default: break;
1312: }
1313: }
1314: size += sizetab(p1);
1315: size += sizetab(p2);
1316: back = (struct mactab *)calloc(size+2, sizeof(struct mactab));
1317:
1318: p = macfill(back, troffmactab);
1319: p = macfill(p, ppmactab);
1320: p = macfill(p, p1);
1321: p = macfill(p, p2);
1322:
1323: qsort(back, size, sizeof(struct mactab), macsort);
1324: *r_size = size;
1325: *r_back = back;
1326: }
1327:
1328: /*
1329: * troff commands
1330: */
1331: struct mactab troffmactab[] = {
1332: M(NONE, '\\','"', skip), /* comment */
1333: M(NOMAC, 'd','e', domacro), /* define */
1334: M(NOMAC, 'i','g', domacro), /* ignore till .. */
1335: M(NOMAC, 'a','m', domacro), /* append macro */
1336: M(NBLK, 'n','f', nf), /* filled */
1337: M(NBLK, 'c','e', ce), /* centered */
1338:
1339: M(NONE, 's','o', so), /* source a file */
1340: M(NONE, 'n','x', nx), /* go to next file */
1341:
1342: M(NONE, 't','m', skip), /* print string on tty */
1343: M(NONE, 'h','w', skip), /* exception hyphen words */
1344: M(NONE, 0,0, 0)
1345: };
1346: /*
1347: * Preprocessor output
1348: */
1349: struct mactab ppmactab[] = {
1350: M(FNEST, 'E','Q', EQ), /* equation starting */
1351: M(FNEST, 'T','S', intbl), /* table starting */
1352: M(FNEST, 'T','C', intbl), /* alternative table? */
1353: M(FNEST, 'T','&', intbl), /* table reformatting */
1354: M(NONE, 'T','E', outtbl),/* table ending */
1355: M(NONE, 'P','S', PS), /* picture starting */
1356: M(NONE, 0,0, 0)
1357: };
1358: /*
1359: * Particular to ms and mm
1360: */
1361: struct mactab msmactab[] = {
1362: M(NONE, 'T','L', skiptocom), /* title follows */
1363: M(NONE, 'F','S', skiptocom), /* start footnote */
1364: M(NONE, 'O','K', skiptocom), /* Other kws */
1365:
1366: M(NONE, 'N','R', skip), /* undocumented */
1367: M(NONE, 'N','D', skip), /* use supplied date */
1368:
1369: M(PARAG, 'P','P', PP), /* begin parag */
1370: M(PARAG, 'I','P', PP), /* begin indent parag, tag x */
1371: M(PARAG, 'L','P', PP), /* left blocked parag */
1372:
1373: M(NONE, 'A','U', AU), /* author */
1374: M(NONE, 'A','I', AU), /* authors institution */
1375:
1376: M(NONE, 'S','H', SH), /* section heading */
1377: M(NONE, 'S','N', SH), /* undocumented */
1378: M(NONE, 'U','X', UX), /* unix */
1379:
1380: M(NBLK, 'D','S', mssnblock), /* start display text */
1381: M(NBLK, 'K','S', mssnblock), /* start keep */
1382: M(NBLK, 'K','F', mssnblock), /* start float keep */
1383: M(NONE, 0,0, 0)
1384: };
1385:
1386: struct mactab mmmactab[] = {
1387: M(NONE, 'H',' ', MMHU), /* -mm ? */
1388: M(NONE, 'H','U', MMHU), /* -mm ? */
1389: M(PARAG, 'P',' ', PP), /* paragraph for -mm */
1390: M(NBLK, 'N','S', mssnblock), /* undocumented */
1391: M(NONE, 0,0, 0)
1392: };
1393:
1394: struct mactab memactab[] = {
1395: M(PARAG, 'p','p', mepp),
1396: M(PARAG, 'l','p', mepp),
1397: M(PARAG, 'n','p', mepp),
1398: M(NONE, 'i','p', meip),
1399:
1400: M(NONE, 's','h', mesh),
1401: M(NONE, 'u','h', mesh),
1402:
1403: M(NBLK, '(','l', mesnblock),
1404: M(NBLK, '(','q', mesnblock),
1405: M(NBLK, '(','b', mesnblock),
1406: M(NBLK, '(','z', mesnblock),
1407: M(NBLK, '(','c', mesnblock),
1408:
1409: M(NBLK, '(','d', mesnblock),
1410: M(NBLK, '(','f', mesnblock),
1411: M(NBLK, '(','x', mesnblock),
1412:
1413: M(NONE, 'r',' ', mefont),
1414: M(NONE, 'i',' ', mefont),
1415: M(NONE, 'b',' ', mefont),
1416: M(NONE, 'u',' ', mefont),
1417: M(NONE, 'q',' ', mefont),
1418: M(NONE, 'r','b', mefont),
1419: M(NONE, 'b','i', mefont),
1420: M(NONE, 'b','x', mefont),
1421: M(NONE, 0,0, 0)
1422: };
1423:
1424:
1425: struct mactab manmactab[] = {
1426: M(PARAG, 'B','I', manfont),
1427: M(PARAG, 'B','R', manfont),
1428: M(PARAG, 'I','B', manfont),
1429: M(PARAG, 'I','R', manfont),
1430: M(PARAG, 'R','B', manfont),
1431: M(PARAG, 'R','I', manfont),
1432:
1433: M(PARAG, 'P','P', manpp),
1434: M(PARAG, 'L','P', manpp),
1435: M(PARAG, 'H','P', manpp),
1436: M(NONE, 0,0, 0)
1437: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.