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