Remove __P macros from src/usr.bin and src/usr.sbin.
[dragonfly.git] / usr.bin / checknr / checknr.c
1 /*
2  * Copyright (c) 1980, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by the University of
16  *      California, Berkeley and its contributors.
17  * 4. Neither the name of the University nor the names of its contributors
18  *    may be used to endorse or promote products derived from this software
19  *    without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31  * SUCH DAMAGE.
32  *
33  * @(#) Copyright (c) 1980, 1993 The Regents of the University of California.  All rights reserved.
34  * @(#)checknr.c        8.1 (Berkeley) 6/6/93
35  *
36  * $DragonFly: src/usr.bin/checknr/checknr.c,v 1.4 2003/11/03 19:31:28 eirikn Exp $
37  */
38
39 /*
40  * checknr: check an nroff/troff input file for matching macro calls.
41  * we also attempt to match size and font changes, but only the embedded
42  * kind.  These must end in \s0 and \fP resp.  Maybe more sophistication
43  * later but for now think of these restrictions as contributions to
44  * structured typesetting.
45  */
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include <ctype.h>
50
51 #define MAXSTK  100     /* Stack size */
52 #define MAXBR   100     /* Max number of bracket pairs known */
53 #define MAXCMDS 500     /* Max number of commands known */
54
55 void addcmd(char *);
56 void addmac(char *);
57 int binsrch(char *);
58 void checkknown(char *);
59 void chkcmd(char *, char *);
60 void complain(int);
61 int eq(char *, char *);
62 void nomatch(char *);
63 void pe(int);
64 void process(FILE *);
65 void prop(int);
66 static void usage(void);
67
68 /*
69  * The stack on which we remember what we've seen so far.
70  */
71 struct stkstr {
72         int opno;       /* number of opening bracket */
73         int pl;         /* '+', '-', ' ' for \s, 1 for \f, 0 for .ft */
74         int parm;       /* parm to size, font, etc */
75         int lno;        /* line number the thing came in in */
76 } stk[MAXSTK];
77 int stktop;
78
79 /*
80  * The kinds of opening and closing brackets.
81  */
82 struct brstr {
83         char *opbr;
84         char *clbr;
85 } br[MAXBR] = {
86         /* A few bare bones troff commands */
87 #define SZ      0
88         {"sz",  "sz"},  /* also \s */
89 #define FT      1
90         {"ft",  "ft"},  /* also \f */
91         /* the -mm package */
92         {"AL",  "LE"},
93         {"AS",  "AE"},
94         {"BL",  "LE"},
95         {"BS",  "BE"},
96         {"DF",  "DE"},
97         {"DL",  "LE"},
98         {"DS",  "DE"},
99         {"FS",  "FE"},
100         {"ML",  "LE"},
101         {"NS",  "NE"},
102         {"RL",  "LE"},
103         {"VL",  "LE"},
104         /* the -ms package */
105         {"AB",  "AE"},
106         {"BD",  "DE"},
107         {"CD",  "DE"},
108         {"DS",  "DE"},
109         {"FS",  "FE"},
110         {"ID",  "DE"},
111         {"KF",  "KE"},
112         {"KS",  "KE"},
113         {"LD",  "DE"},
114         {"LG",  "NL"},
115         {"QS",  "QE"},
116         {"RS",  "RE"},
117         {"SM",  "NL"},
118         {"XA",  "XE"},
119         {"XS",  "XE"},
120         /* The -me package */
121         {"(b",  ")b"},
122         {"(c",  ")c"},
123         {"(d",  ")d"},
124         {"(f",  ")f"},
125         {"(l",  ")l"},
126         {"(q",  ")q"},
127         {"(x",  ")x"},
128         {"(z",  ")z"},
129         /* Things needed by preprocessors */
130         {"EQ",  "EN"},
131         {"TS",  "TE"},
132         /* Refer */
133         {"[",   "]"},
134         {0,     0}
135 };
136
137 /*
138  * All commands known to nroff, plus macro packages.
139  * Used so we can complain about unrecognized commands.
140  */
141 char *knowncmds[MAXCMDS] = {
142 "$c", "$f", "$h", "$p", "$s", "(b", "(c", "(d", "(f", "(l", "(q", "(t",
143 "(x", "(z", ")b", ")c", ")d", ")f", ")l", ")q", ")t", ")x", ")z", "++",
144 "+c", "1C", "1c", "2C", "2c", "@(", "@)", "@C", "@D", "@F", "@I", "@M",
145 "@c", "@e", "@f", "@h", "@m", "@n", "@o", "@p", "@r", "@t", "@z", "AB",
146 "AE", "AF", "AI", "AL", "AM", "AS", "AT", "AU", "AX", "B",  "B1", "B2",
147 "BD", "BE", "BG", "BL", "BS", "BT", "BX", "C1", "C2", "CD", "CM", "CT",
148 "D",  "DA", "DE", "DF", "DL", "DS", "DT", "EC", "EF", "EG", "EH", "EM",
149 "EN", "EQ", "EX", "FA", "FD", "FE", "FG", "FJ", "FK", "FL", "FN", "FO",
150 "FQ", "FS", "FV", "FX", "H",  "HC", "HD", "HM", "HO", "HU", "I",  "ID",
151 "IE", "IH", "IM", "IP", "IX", "IZ", "KD", "KE", "KF", "KQ", "KS", "LB",
152 "LC", "LD", "LE", "LG", "LI", "LP", "MC", "ME", "MF", "MH", "ML", "MR",
153 "MT", "ND", "NE", "NH", "NL", "NP", "NS", "OF", "OH", "OK", "OP", "P",
154 "P1", "PF", "PH", "PP", "PT", "PX", "PY", "QE", "QP", "QS", "R",  "RA",
155 "RC", "RE", "RL", "RP", "RQ", "RS", "RT", "S",  "S0", "S2", "S3", "SA",
156 "SG", "SH", "SK", "SM", "SP", "SY", "T&", "TA", "TB", "TC", "TD", "TE",
157 "TH", "TL", "TM", "TP", "TQ", "TR", "TS", "TX", "UL", "US", "UX", "VL",
158 "WC", "WH", "XA", "XD", "XE", "XF", "XK", "XP", "XS", "[",  "[-", "[0",
159 "[1", "[2", "[3", "[4", "[5", "[<", "[>", "[]", "]",  "]-", "]<", "]>",
160 "][", "ab", "ac", "ad", "af", "am", "ar", "as", "b",  "ba", "bc", "bd",
161 "bi", "bl", "bp", "br", "bx", "c.", "c2", "cc", "ce", "cf", "ch", "cs",
162 "ct", "cu", "da", "de", "di", "dl", "dn", "ds", "dt", "dw", "dy", "ec",
163 "ef", "eh", "el", "em", "eo", "ep", "ev", "ex", "fc", "fi", "fl", "fo",
164 "fp", "ft", "fz", "hc", "he", "hl", "hp", "ht", "hw", "hx", "hy", "i",
165 "ie", "if", "ig", "in", "ip", "it", "ix", "lc", "lg", "li", "ll", "ln",
166 "lo", "lp", "ls", "lt", "m1", "m2", "m3", "m4", "mc", "mk", "mo", "n1",
167 "n2", "na", "ne", "nf", "nh", "nl", "nm", "nn", "np", "nr", "ns", "nx",
168 "of", "oh", "os", "pa", "pc", "pi", "pl", "pm", "pn", "po", "pp", "ps",
169 "q",  "r",  "rb", "rd", "re", "rm", "rn", "ro", "rr", "rs", "rt", "sb",
170 "sc", "sh", "sk", "so", "sp", "ss", "st", "sv", "sz", "ta", "tc", "th",
171 "ti", "tl", "tm", "tp", "tr", "u",  "uf", "uh", "ul", "vs", "wh", "xp",
172 "yr", 0
173 };
174
175 int     lineno;         /* current line number in input file */
176 char    line[256];      /* the current line */
177 char    *cfilename;     /* name of current file */
178 int     nfiles;         /* number of files to process */
179 int     fflag;          /* -f: ignore \f */
180 int     sflag;          /* -s: ignore \s */
181 int     ncmds;          /* size of knowncmds */
182 int     slot;           /* slot in knowncmds found by binsrch */
183
184 int
185 main(int argc, char **argv)
186 {
187         FILE *f;
188         int i;
189         char *cp;
190         char b1[4];
191
192         /* Figure out how many known commands there are */
193         while (knowncmds[ncmds])
194                 ncmds++;
195         while (argc > 1 && argv[1][0] == '-') {
196                 switch(argv[1][1]) {
197
198                 /* -a: add pairs of macros */
199                 case 'a':
200                         i = strlen(argv[1]) - 2;
201                         if (i % 6 != 0)
202                                 usage();
203                         /* look for empty macro slots */
204                         for (i=0; br[i].opbr; i++)
205                                 ;
206                         for (cp=argv[1]+3; cp[-1]; cp += 6) {
207                                 br[i].opbr = malloc(3);
208                                 strncpy(br[i].opbr, cp, 2);
209                                 br[i].clbr = malloc(3);
210                                 strncpy(br[i].clbr, cp+3, 2);
211                                 addmac(br[i].opbr);     /* knows pairs are also known cmds */
212                                 addmac(br[i].clbr);
213                                 i++;
214                         }
215                         break;
216
217                 /* -c: add known commands */
218                 case 'c':
219                         i = strlen(argv[1]) - 2;
220                         if (i % 3 != 0)
221                                 usage();
222                         for (cp=argv[1]+3; cp[-1]; cp += 3) {
223                                 if (cp[2] && cp[2] != '.')
224                                         usage();
225                                 strncpy(b1, cp, 2);
226                                 b1[2] = '\0';
227                                 addmac(b1);
228                         }
229                         break;
230
231                 /* -f: ignore font changes */
232                 case 'f':
233                         fflag = 1;
234                         break;
235
236                 /* -s: ignore size changes */
237                 case 's':
238                         sflag = 1;
239                         break;
240                 default:
241                         usage();
242                 }
243                 argc--; argv++;
244         }
245
246         nfiles = argc - 1;
247
248         if (nfiles > 0) {
249                 for (i=1; i<argc; i++) {
250                         cfilename = argv[i];
251                         f = fopen(cfilename, "r");
252                         if (f == NULL)
253                                 perror(cfilename);
254                         else
255                                 process(f);
256                 }
257         } else {
258                 cfilename = "stdin";
259                 process(stdin);
260         }
261         exit(0);
262 }
263
264 static void
265 usage(void)
266 {
267         fprintf(stderr,
268         "usage: checknr [-a.xx.yy.xx.yy...] [-c.xx.xx.xx...] [-s] [-f] file\n");
269         exit(1);
270 }
271
272 void
273 process(FILE *f)
274 {
275         register int i, n;
276         char mac[5];    /* The current macro or nroff command */
277         int pl;
278
279         stktop = -1;
280         for (lineno = 1; fgets(line, sizeof line, f); lineno++) {
281                 if (line[0] == '.') {
282                         /*
283                          * find and isolate the macro/command name.
284                          */
285                         strncpy(mac, line+1, 4);
286                         if (isspace(mac[0])) {
287                                 pe(lineno);
288                                 printf("Empty command\n");
289                         } else if (isspace(mac[1])) {
290                                 mac[1] = 0;
291                         } else if (isspace(mac[2])) {
292                                 mac[2] = 0;
293                         } else if (mac[0] != '\\' || mac[1] != '\"') {
294                                 pe(lineno);
295                                 printf("Command too long\n");
296                         }
297
298                         /*
299                          * Is it a known command?
300                          */
301                         checkknown(mac);
302
303                         /*
304                          * Should we add it?
305                          */
306                         if (eq(mac, "de"))
307                                 addcmd(line);
308
309                         chkcmd(line, mac);
310                 }
311
312                 /*
313                  * At this point we process the line looking
314                  * for \s and \f.
315                  */
316                 for (i=0; line[i]; i++)
317                         if (line[i]=='\\' && (i==0 || line[i-1]!='\\')) {
318                                 if (!sflag && line[++i]=='s') {
319                                         pl = line[++i];
320                                         if (isdigit(pl)) {
321                                                 n = pl - '0';
322                                                 pl = ' ';
323                                         } else
324                                                 n = 0;
325                                         while (isdigit(line[++i]))
326                                                 n = 10 * n + line[i] - '0';
327                                         i--;
328                                         if (n == 0) {
329                                                 if (stk[stktop].opno == SZ) {
330                                                         stktop--;
331                                                 } else {
332                                                         pe(lineno);
333                                                         printf("unmatched \\s0\n");
334                                                 }
335                                         } else {
336                                                 stk[++stktop].opno = SZ;
337                                                 stk[stktop].pl = pl;
338                                                 stk[stktop].parm = n;
339                                                 stk[stktop].lno = lineno;
340                                         }
341                                 } else if (!fflag && line[i]=='f') {
342                                         n = line[++i];
343                                         if (n == 'P') {
344                                                 if (stk[stktop].opno == FT) {
345                                                         stktop--;
346                                                 } else {
347                                                         pe(lineno);
348                                                         printf("unmatched \\fP\n");
349                                                 }
350                                         } else {
351                                                 stk[++stktop].opno = FT;
352                                                 stk[stktop].pl = 1;
353                                                 stk[stktop].parm = n;
354                                                 stk[stktop].lno = lineno;
355                                         }
356                                 }
357                         }
358         }
359         /*
360          * We've hit the end and look at all this stuff that hasn't been
361          * matched yet!  Complain, complain.
362          */
363         for (i=stktop; i>=0; i--) {
364                 complain(i);
365         }
366 }
367
368 void
369 complain(int i)
370 {
371         pe(stk[i].lno);
372         printf("Unmatched ");
373         prop(i);
374         printf("\n");
375 }
376
377 void
378 prop(int i)
379 {
380         if (stk[i].pl == 0)
381                 printf(".%s", br[stk[i].opno].opbr);
382         else switch(stk[i].opno) {
383         case SZ:
384                 printf("\\s%c%d", stk[i].pl, stk[i].parm);
385                 break;
386         case FT:
387                 printf("\\f%c", stk[i].parm);
388                 break;
389         default:
390                 printf("Bug: stk[%d].opno = %d = .%s, .%s",
391                         i, stk[i].opno, br[stk[i].opno].opbr, br[stk[i].opno].clbr);
392         }
393 }
394
395 void
396 chkcmd(char *line, char *mac)
397 {
398         register int i;
399
400         /*
401          * Check to see if it matches top of stack.
402          */
403         if (stktop >= 0 && eq(mac, br[stk[stktop].opno].clbr))
404                 stktop--;       /* OK. Pop & forget */
405         else {
406                 /* No. Maybe it's an opener */
407                 for (i=0; br[i].opbr; i++) {
408                         if (eq(mac, br[i].opbr)) {
409                                 /* Found. Push it. */
410                                 stktop++;
411                                 stk[stktop].opno = i;
412                                 stk[stktop].pl = 0;
413                                 stk[stktop].parm = 0;
414                                 stk[stktop].lno = lineno;
415                                 break;
416                         }
417                         /*
418                          * Maybe it's an unmatched closer.
419                          * NOTE: this depends on the fact
420                          * that none of the closers can be
421                          * openers too.
422                          */
423                         if (eq(mac, br[i].clbr)) {
424                                 nomatch(mac);
425                                 break;
426                         }
427                 }
428         }
429 }
430
431 void
432 nomatch(char *mac)
433 {
434         register int i, j;
435
436         /*
437          * Look for a match further down on stack
438          * If we find one, it suggests that the stuff in
439          * between is supposed to match itself.
440          */
441         for (j=stktop; j>=0; j--)
442                 if (eq(mac,br[stk[j].opno].clbr)) {
443                         /* Found.  Make a good diagnostic. */
444                         if (j == stktop-2) {
445                                 /*
446                                  * Check for special case \fx..\fR and don't
447                                  * complain.
448                                  */
449                                 if (stk[j+1].opno==FT && stk[j+1].parm!='R'
450                                  && stk[j+2].opno==FT && stk[j+2].parm=='R') {
451                                         stktop = j -1;
452                                         return;
453                                 }
454                                 /*
455                                  * We have two unmatched frobs.  Chances are
456                                  * they were intended to match, so we mention
457                                  * them together.
458                                  */
459                                 pe(stk[j+1].lno);
460                                 prop(j+1);
461                                 printf(" does not match %d: ", stk[j+2].lno);
462                                 prop(j+2);
463                                 printf("\n");
464                         } else for (i=j+1; i <= stktop; i++) {
465                                 complain(i);
466                         }
467                         stktop = j-1;
468                         return;
469                 }
470         /* Didn't find one.  Throw this away. */
471         pe(lineno);
472         printf("Unmatched .%s\n", mac);
473 }
474
475 /* eq: are two strings equal? */
476 int
477 eq(char *s1, char *s2)
478 {
479         return (strcmp(s1, s2) == 0);
480 }
481
482 /* print the first part of an error message, given the line number */
483 void
484 pe(int lineno)
485 {
486         if (nfiles > 1)
487                 printf("%s: ", cfilename);
488         printf("%d: ", lineno);
489 }
490
491 void
492 checkknown(char *mac)
493 {
494
495         if (eq(mac, "."))
496                 return;
497         if (binsrch(mac) >= 0)
498                 return;
499         if (mac[0] == '\\' && mac[1] == '"')    /* comments */
500                 return;
501
502         pe(lineno);
503         printf("Unknown command: .%s\n", mac);
504 }
505
506 /*
507  * We have a .de xx line in "line".  Add xx to the list of known commands.
508  */
509 void
510 addcmd(char *line)
511 {
512         char *mac;
513
514         /* grab the macro being defined */
515         mac = line+4;
516         while (isspace(*mac))
517                 mac++;
518         if (*mac == 0) {
519                 pe(lineno);
520                 printf("illegal define: %s\n", line);
521                 return;
522         }
523         mac[2] = 0;
524         if (isspace(mac[1]) || mac[1] == '\\')
525                 mac[1] = 0;
526         if (ncmds >= MAXCMDS) {
527                 printf("Only %d known commands allowed\n", MAXCMDS);
528                 exit(1);
529         }
530         addmac(mac);
531 }
532
533 /*
534  * Add mac to the list.  We should really have some kind of tree
535  * structure here but this is a quick-and-dirty job and I just don't
536  * have time to mess with it.  (I wonder if this will come back to haunt
537  * me someday?)  Anyway, I claim that .de is fairly rare in user
538  * nroff programs, and the register loop below is pretty fast.
539  */
540 void
541 addmac(char *mac)
542 {
543         register char **src, **dest, **loc;
544
545         if (binsrch(mac) >= 0){ /* it's OK to redefine something */
546 #ifdef DEBUG
547                 printf("binsrch(%s) -> already in table\n", mac);
548 #endif DEBUG
549                 return;
550         }
551         /* binsrch sets slot as a side effect */
552 #ifdef DEBUG
553 printf("binsrch(%s) -> %d\n", mac, slot);
554 #endif
555         loc = &knowncmds[slot];
556         src = &knowncmds[ncmds-1];
557         dest = src+1;
558         while (dest > loc)
559                 *dest-- = *src--;
560         *loc = malloc(3);
561         strcpy(*loc, mac);
562         ncmds++;
563 #ifdef DEBUG
564 printf("after: %s %s %s %s %s, %d cmds\n", knowncmds[slot-2], knowncmds[slot-1], knowncmds[slot], knowncmds[slot+1], knowncmds[slot+2], ncmds);
565 #endif
566 }
567
568 /*
569  * Do a binary search in knowncmds for mac.
570  * If found, return the index.  If not, return -1.
571  */
572 int
573 binsrch(char *mac)
574 {
575         register char *p;       /* pointer to current cmd in list */
576         register int d;         /* difference if any */
577         register int mid;       /* mid point in binary search */
578         register int top, bot;  /* boundaries of bin search, inclusive */
579
580         top = ncmds-1;
581         bot = 0;
582         while (top >= bot) {
583                 mid = (top+bot)/2;
584                 p = knowncmds[mid];
585                 d = p[0] - mac[0];
586                 if (d == 0)
587                         d = p[1] - mac[1];
588                 if (d == 0)
589                         return mid;
590                 if (d < 0)
591                         bot = mid + 1;
592                 else
593                         top = mid - 1;
594         }
595         slot = bot;     /* place it would have gone */
596         return -1;
597 }