]> git.cameronkatri.com Git - mandoc.git/blob - mdoc_validate.c
git.ckatri.com / mandoc.git / blob
? search:


48e000c7ddb70b0f0e05bbd8497c5a8b2a11b7ad
[mandoc.git] / mdoc_validate.c
1 /* $Id: mdoc_validate.c,v 1.90 2010/05/31 23:40:25 kristaps Exp $ */
2 /*
3 * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@bsd.lv>
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17 #ifdef HAVE_CONFIG_H
18 #include "config.h"
19 #endif
20
21 #include <sys/types.h>
22
23 #include <assert.h>
24 #include <ctype.h>
25 #include <limits.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "mandoc.h"
31 #include "libmdoc.h"
32 #include "libmandoc.h"
33
34 /* FIXME: .Bl -diag can't have non-text children in HEAD. */
35 /* TODO: ignoring Pp (it's superfluous in some invocations). */
36
37 #define PRE_ARGS struct mdoc *mdoc, const struct mdoc_node *n
38 #define POST_ARGS struct mdoc *mdoc
39
40 typedef int (*v_pre)(PRE_ARGS);
41 typedef int (*v_post)(POST_ARGS);
42
43 struct valids {
44 v_pre *pre;
45 v_post *post;
46 };
47
48 static int check_parent(PRE_ARGS, enum mdoct, enum mdoc_type);
49 static int check_stdarg(PRE_ARGS);
50 static int check_text(struct mdoc *, int, int, const char *);
51 static int check_argv(struct mdoc *,
52 const struct mdoc_node *,
53 const struct mdoc_argv *);
54 static int check_args(struct mdoc *,
55 const struct mdoc_node *);
56 static int err_child_lt(struct mdoc *, const char *, int);
57 static int warn_child_lt(struct mdoc *, const char *, int);
58 static int err_child_gt(struct mdoc *, const char *, int);
59 static int warn_child_gt(struct mdoc *, const char *, int);
60 static int err_child_eq(struct mdoc *, const char *, int);
61 static int warn_child_eq(struct mdoc *, const char *, int);
62 static int warn_count(struct mdoc *, const char *,
63 int, const char *, int);
64 static int err_count(struct mdoc *, const char *,
65 int, const char *, int);
66
67 static int berr_ge1(POST_ARGS);
68 static int bwarn_ge1(POST_ARGS);
69 static int ebool(POST_ARGS);
70 static int eerr_eq0(POST_ARGS);
71 static int eerr_eq1(POST_ARGS);
72 static int eerr_ge1(POST_ARGS);
73 static int eerr_le1(POST_ARGS);
74 static int ewarn_ge1(POST_ARGS);
75 static int herr_eq0(POST_ARGS);
76 static int herr_ge1(POST_ARGS);
77 static int hwarn_eq1(POST_ARGS);
78 static int hwarn_eq0(POST_ARGS);
79 static int hwarn_le1(POST_ARGS);
80
81 static int post_an(POST_ARGS);
82 static int post_at(POST_ARGS);
83 static int post_bf(POST_ARGS);
84 static int post_bl(POST_ARGS);
85 static int post_bl_head(POST_ARGS);
86 static int post_dt(POST_ARGS);
87 static int post_it(POST_ARGS);
88 static int post_lb(POST_ARGS);
89 static int post_nm(POST_ARGS);
90 static int post_root(POST_ARGS);
91 static int post_rs(POST_ARGS);
92 static int post_sh(POST_ARGS);
93 static int post_sh_body(POST_ARGS);
94 static int post_sh_head(POST_ARGS);
95 static int post_st(POST_ARGS);
96 static int post_eoln(POST_ARGS);
97 static int post_vt(POST_ARGS);
98 static int pre_an(PRE_ARGS);
99 static int pre_bd(PRE_ARGS);
100 static int pre_bl(PRE_ARGS);
101 static int pre_dd(PRE_ARGS);
102 static int pre_display(PRE_ARGS);
103 static int pre_dt(PRE_ARGS);
104 static int pre_it(PRE_ARGS);
105 static int pre_os(PRE_ARGS);
106 static int pre_rv(PRE_ARGS);
107 static int pre_sh(PRE_ARGS);
108 static int pre_ss(PRE_ARGS);
109
110 static v_post posts_an[] = { post_an, NULL };
111 static v_post posts_at[] = { post_at, NULL };
112 static v_post posts_bd[] = { hwarn_eq0, bwarn_ge1, NULL };
113 static v_post posts_bf[] = { hwarn_le1, post_bf, NULL };
114 static v_post posts_bl[] = { bwarn_ge1, post_bl, NULL };
115 static v_post posts_bool[] = { eerr_eq1, ebool, NULL };
116 static v_post posts_eoln[] = { post_eoln, NULL };
117 static v_post posts_dt[] = { post_dt, NULL };
118 static v_post posts_fo[] = { hwarn_eq1, bwarn_ge1, NULL };
119 static v_post posts_it[] = { post_it, NULL };
120 static v_post posts_lb[] = { eerr_eq1, post_lb, NULL };
121 static v_post posts_nd[] = { berr_ge1, NULL };
122 static v_post posts_nm[] = { post_nm, NULL };
123 static v_post posts_notext[] = { eerr_eq0, NULL };
124 static v_post posts_rs[] = { berr_ge1, herr_eq0, post_rs, NULL };
125 static v_post posts_sh[] = { herr_ge1, bwarn_ge1, post_sh, NULL };
126 static v_post posts_sp[] = { eerr_le1, NULL };
127 static v_post posts_ss[] = { herr_ge1, NULL };
128 static v_post posts_st[] = { eerr_eq1, post_st, NULL };
129 static v_post posts_text[] = { eerr_ge1, NULL };
130 static v_post posts_text1[] = { eerr_eq1, NULL };
131 static v_post posts_vt[] = { post_vt, NULL };
132 static v_post posts_wline[] = { bwarn_ge1, herr_eq0, NULL };
133 static v_post posts_wtext[] = { ewarn_ge1, NULL };
134 static v_pre pres_an[] = { pre_an, NULL };
135 static v_pre pres_bd[] = { pre_display, pre_bd, NULL };
136 static v_pre pres_bl[] = { pre_bl, NULL };
137 static v_pre pres_d1[] = { pre_display, NULL };
138 static v_pre pres_dd[] = { pre_dd, NULL };
139 static v_pre pres_dt[] = { pre_dt, NULL };
140 static v_pre pres_er[] = { NULL, NULL };
141 static v_pre pres_ex[] = { NULL, NULL };
142 static v_pre pres_fd[] = { NULL, NULL };
143 static v_pre pres_it[] = { pre_it, NULL };
144 static v_pre pres_os[] = { pre_os, NULL };
145 static v_pre pres_rv[] = { pre_rv, NULL };
146 static v_pre pres_sh[] = { pre_sh, NULL };
147 static v_pre pres_ss[] = { pre_ss, NULL };
148
149 const struct valids mdoc_valids[MDOC_MAX] = {
150 { NULL, NULL }, /* Ap */
151 { pres_dd, posts_text }, /* Dd */
152 { pres_dt, posts_dt }, /* Dt */
153 { pres_os, NULL }, /* Os */
154 { pres_sh, posts_sh }, /* Sh */
155 { pres_ss, posts_ss }, /* Ss */
156 { NULL, posts_notext }, /* Pp */
157 { pres_d1, posts_wline }, /* D1 */
158 { pres_d1, posts_wline }, /* Dl */
159 { pres_bd, posts_bd }, /* Bd */
160 { NULL, NULL }, /* Ed */
161 { pres_bl, posts_bl }, /* Bl */
162 { NULL, NULL }, /* El */
163 { pres_it, posts_it }, /* It */
164 { NULL, posts_text }, /* Ad */
165 { pres_an, posts_an }, /* An */
166 { NULL, NULL }, /* Ar */
167 { NULL, posts_text }, /* Cd */
168 { NULL, NULL }, /* Cm */
169 { NULL, NULL }, /* Dv */
170 { pres_er, posts_text }, /* Er */
171 { NULL, NULL }, /* Ev */
172 { pres_ex, NULL }, /* Ex */
173 { NULL, NULL }, /* Fa */
174 { pres_fd, posts_wtext }, /* Fd */
175 { NULL, NULL }, /* Fl */
176 { NULL, posts_text }, /* Fn */
177 { NULL, posts_wtext }, /* Ft */
178 { NULL, posts_text }, /* Ic */
179 { NULL, posts_text1 }, /* In */
180 { NULL, NULL }, /* Li */
181 { NULL, posts_nd }, /* Nd */
182 { NULL, posts_nm }, /* Nm */
183 { NULL, posts_wline }, /* Op */
184 { NULL, NULL }, /* Ot */
185 { NULL, NULL }, /* Pa */
186 { pres_rv, NULL }, /* Rv */
187 { NULL, posts_st }, /* St */
188 { NULL, NULL }, /* Va */
189 { NULL, posts_vt }, /* Vt */
190 { NULL, posts_wtext }, /* Xr */
191 { NULL, posts_text }, /* %A */
192 { NULL, posts_text }, /* %B */ /* FIXME: can be used outside Rs/Re. */
193 { NULL, posts_text }, /* %D */ /* FIXME: check date with mandoc_a2time(). */
194 { NULL, posts_text }, /* %I */
195 { NULL, posts_text }, /* %J */
196 { NULL, posts_text }, /* %N */
197 { NULL, posts_text }, /* %O */
198 { NULL, posts_text }, /* %P */
199 { NULL, posts_text }, /* %R */
200 { NULL, posts_text }, /* %T */ /* FIXME: can be used outside Rs/Re. */
201 { NULL, posts_text }, /* %V */
202 { NULL, NULL }, /* Ac */
203 { NULL, NULL }, /* Ao */
204 { NULL, posts_wline }, /* Aq */
205 { NULL, posts_at }, /* At */
206 { NULL, NULL }, /* Bc */
207 { NULL, posts_bf }, /* Bf */
208 { NULL, NULL }, /* Bo */
209 { NULL, posts_wline }, /* Bq */
210 { NULL, NULL }, /* Bsx */
211 { NULL, NULL }, /* Bx */
212 { NULL, posts_bool }, /* Db */
213 { NULL, NULL }, /* Dc */
214 { NULL, NULL }, /* Do */
215 { NULL, posts_wline }, /* Dq */
216 { NULL, NULL }, /* Ec */
217 { NULL, NULL }, /* Ef */
218 { NULL, NULL }, /* Em */
219 { NULL, NULL }, /* Eo */
220 { NULL, NULL }, /* Fx */
221 { NULL, posts_text }, /* Ms */
222 { NULL, posts_notext }, /* No */
223 { NULL, posts_notext }, /* Ns */
224 { NULL, NULL }, /* Nx */
225 { NULL, NULL }, /* Ox */
226 { NULL, NULL }, /* Pc */
227 { NULL, posts_text1 }, /* Pf */
228 { NULL, NULL }, /* Po */
229 { NULL, posts_wline }, /* Pq */
230 { NULL, NULL }, /* Qc */
231 { NULL, posts_wline }, /* Ql */
232 { NULL, NULL }, /* Qo */
233 { NULL, posts_wline }, /* Qq */
234 { NULL, NULL }, /* Re */
235 { NULL, posts_rs }, /* Rs */
236 { NULL, NULL }, /* Sc */
237 { NULL, NULL }, /* So */
238 { NULL, posts_wline }, /* Sq */
239 { NULL, posts_bool }, /* Sm */
240 { NULL, posts_text }, /* Sx */
241 { NULL, posts_text }, /* Sy */
242 { NULL, posts_text }, /* Tn */
243 { NULL, NULL }, /* Ux */
244 { NULL, NULL }, /* Xc */
245 { NULL, NULL }, /* Xo */
246 { NULL, posts_fo }, /* Fo */
247 { NULL, NULL }, /* Fc */
248 { NULL, NULL }, /* Oo */
249 { NULL, NULL }, /* Oc */
250 { NULL, posts_wline }, /* Bk */
251 { NULL, NULL }, /* Ek */
252 { NULL, posts_eoln }, /* Bt */
253 { NULL, NULL }, /* Hf */
254 { NULL, NULL }, /* Fr */
255 { NULL, posts_eoln }, /* Ud */
256 { NULL, posts_lb }, /* Lb */
257 { NULL, posts_notext }, /* Lp */
258 { NULL, posts_text }, /* Lk */
259 { NULL, posts_text }, /* Mt */
260 { NULL, posts_wline }, /* Brq */
261 { NULL, NULL }, /* Bro */
262 { NULL, NULL }, /* Brc */
263 { NULL, posts_text }, /* %C */
264 { NULL, NULL }, /* Es */
265 { NULL, NULL }, /* En */
266 { NULL, NULL }, /* Dx */
267 { NULL, posts_text }, /* %Q */
268 { NULL, posts_notext }, /* br */
269 { NULL, posts_sp }, /* sp */
270 { NULL, posts_text1 }, /* %U */
271 { NULL, NULL }, /* Ta */
272 };
273
274
275 int
276 mdoc_valid_pre(struct mdoc *mdoc, const struct mdoc_node *n)
277 {
278 v_pre *p;
279 int line, pos;
280 const char *tp;
281
282 if (MDOC_TEXT == n->type) {
283 tp = n->string;
284 line = n->line;
285 pos = n->pos;
286 return(check_text(mdoc, line, pos, tp));
287 }
288
289 if ( ! check_args(mdoc, n))
290 return(0);
291 if (NULL == mdoc_valids[n->tok].pre)
292 return(1);
293 for (p = mdoc_valids[n->tok].pre; *p; p++)
294 if ( ! (*p)(mdoc, n))
295 return(0);
296 return(1);
297 }
298
299
300 int
301 mdoc_valid_post(struct mdoc *mdoc)
302 {
303 v_post *p;
304
305 if (MDOC_VALID & mdoc->last->flags)
306 return(1);
307 mdoc->last->flags |= MDOC_VALID;
308
309 if (MDOC_TEXT == mdoc->last->type)
310 return(1);
311 if (MDOC_ROOT == mdoc->last->type)
312 return(post_root(mdoc));
313
314 if (NULL == mdoc_valids[mdoc->last->tok].post)
315 return(1);
316 for (p = mdoc_valids[mdoc->last->tok].post; *p; p++)
317 if ( ! (*p)(mdoc))
318 return(0);
319
320 return(1);
321 }
322
323
324 static inline int
325 warn_count(struct mdoc *m, const char *k,
326 int want, const char *v, int has)
327 {
328
329 return(mdoc_vmsg(m, MANDOCERR_ARGCOUNT,
330 m->last->line, m->last->pos,
331 "%s %s %d (have %d)", v, k, want, has));
332 }
333
334
335 static inline int
336 err_count(struct mdoc *m, const char *k,
337 int want, const char *v, int has)
338 {
339
340 mdoc_vmsg(m, MANDOCERR_SYNTARGCOUNT,
341 m->last->line, m->last->pos,
342 "%s %s %d (have %d)",
343 v, k, want, has);
344 return(0);
345 }
346
347
348 /*
349 * Build these up with macros because they're basically the same check
350 * for different inequalities. Yes, this could be done with functions,
351 * but this is reasonable for now.
352 */
353
354 #define CHECK_CHILD_DEFN(lvl, name, ineq) \
355 static int \
356 lvl##_child_##name(struct mdoc *mdoc, const char *p, int sz) \
357 { \
358 if (mdoc->last->nchild ineq sz) \
359 return(1); \
360 return(lvl##_count(mdoc, #ineq, sz, p, mdoc->last->nchild)); \
361 }
362
363 #define CHECK_BODY_DEFN(name, lvl, func, num) \
364 static int \
365 b##lvl##_##name(POST_ARGS) \
366 { \
367 if (MDOC_BODY != mdoc->last->type) \
368 return(1); \
369 return(func(mdoc, "multi-line arguments", (num))); \
370 }
371
372 #define CHECK_ELEM_DEFN(name, lvl, func, num) \
373 static int \
374 e##lvl##_##name(POST_ARGS) \
375 { \
376 assert(MDOC_ELEM == mdoc->last->type); \
377 return(func(mdoc, "line arguments", (num))); \
378 }
379
380 #define CHECK_HEAD_DEFN(name, lvl, func, num) \
381 static int \
382 h##lvl##_##name(POST_ARGS) \
383 { \
384 if (MDOC_HEAD != mdoc->last->type) \
385 return(1); \
386 return(func(mdoc, "line arguments", (num))); \
387 }
388
389
390 CHECK_CHILD_DEFN(warn, gt, >) /* warn_child_gt() */
391 CHECK_CHILD_DEFN(err, gt, >) /* err_child_gt() */
392 CHECK_CHILD_DEFN(warn, eq, ==) /* warn_child_eq() */
393 CHECK_CHILD_DEFN(err, eq, ==) /* err_child_eq() */
394 CHECK_CHILD_DEFN(err, lt, <) /* err_child_lt() */
395 CHECK_CHILD_DEFN(warn, lt, <) /* warn_child_lt() */
396 CHECK_BODY_DEFN(ge1, warn, warn_child_gt, 0) /* bwarn_ge1() */
397 CHECK_BODY_DEFN(ge1, err, err_child_gt, 0) /* berr_ge1() */
398 CHECK_ELEM_DEFN(ge1, warn, warn_child_gt, 0) /* ewarn_ge1() */
399 CHECK_ELEM_DEFN(eq1, err, err_child_eq, 1) /* eerr_eq1() */
400 CHECK_ELEM_DEFN(le1, err, err_child_lt, 2) /* eerr_le1() */
401 CHECK_ELEM_DEFN(eq0, err, err_child_eq, 0) /* eerr_eq0() */
402 CHECK_ELEM_DEFN(ge1, err, err_child_gt, 0) /* eerr_ge1() */
403 CHECK_HEAD_DEFN(eq0, err, err_child_eq, 0) /* herr_eq0() */
404 CHECK_HEAD_DEFN(le1, warn, warn_child_lt, 2) /* hwarn_le1() */
405 CHECK_HEAD_DEFN(ge1, err, err_child_gt, 0) /* herr_ge1() */
406 CHECK_HEAD_DEFN(eq1, warn, warn_child_eq, 1) /* hwarn_eq1() */
407 CHECK_HEAD_DEFN(eq0, warn, warn_child_eq, 0) /* hwarn_eq0() */
408
409
410 static int
411 check_stdarg(PRE_ARGS)
412 {
413
414 if (n->args && 1 == n->args->argc)
415 if (MDOC_Std == n->args->argv[0].arg)
416 return(1);
417 return(mdoc_nmsg(mdoc, n, MANDOCERR_NOARGV));
418 }
419
420
421 static int
422 check_args(struct mdoc *m, const struct mdoc_node *n)
423 {
424 int i;
425
426 if (NULL == n->args)
427 return(1);
428
429 assert(n->args->argc);
430 for (i = 0; i < (int)n->args->argc; i++)
431 if ( ! check_argv(m, n, &n->args->argv[i]))
432 return(0);
433
434 return(1);
435 }
436
437
438 static int
439 check_argv(struct mdoc *m, const struct mdoc_node *n,
440 const struct mdoc_argv *v)
441 {
442 int i;
443
444 for (i = 0; i < (int)v->sz; i++)
445 if ( ! check_text(m, v->line, v->pos, v->value[i]))
446 return(0);
447
448 if (MDOC_Std == v->arg) {
449 if (v->sz || m->meta.name)
450 return(1);
451 if ( ! mdoc_nmsg(m, n, MANDOCERR_NONAME))
452 return(0);
453 }
454
455 return(1);
456 }
457
458
459 static int
460 check_text(struct mdoc *mdoc, int line, int pos, const char *p)
461 {
462 int c;
463
464 for ( ; *p; p++, pos++) {
465 if ('\t' == *p) {
466 if ( ! (MDOC_LITERAL & mdoc->flags))
467 if ( ! mdoc_pmsg(mdoc, line, pos, MANDOCERR_BADCHAR))
468 return(0);
469 } else if ( ! isprint((u_char)*p) && ASCII_HYPH != *p)
470 if ( ! mdoc_pmsg(mdoc, line, pos, MANDOCERR_BADCHAR))
471 return(0);
472
473 if ('\\' != *p)
474 continue;
475
476 c = mandoc_special(p);
477 if (c) {
478 p += c - 1;
479 pos += c - 1;
480 continue;
481 }
482
483 c = mdoc_pmsg(mdoc, line, pos, MANDOCERR_BADESCAPE);
484 if ( ! (MDOC_IGN_ESCAPE & mdoc->pflags) && ! c)
485 return(c);
486 }
487
488 return(1);
489 }
490
491
492
493
494 static int
495 check_parent(PRE_ARGS, enum mdoct tok, enum mdoc_type t)
496 {
497
498 assert(n->parent);
499 if ((MDOC_ROOT == t || tok == n->parent->tok) &&
500 (t == n->parent->type))
501 return(1);
502
503 mdoc_vmsg(mdoc, MANDOCERR_SYNTCHILD,
504 n->line, n->pos, "want parent %s",
505 MDOC_ROOT == t ? "<root>" :
506 mdoc_macronames[tok]);
507 return(0);
508 }
509
510
511
512 static int
513 pre_display(PRE_ARGS)
514 {
515 struct mdoc_node *node;
516
517 /* Display elements (`Bd', `D1'...) cannot be nested. */
518
519 if (MDOC_BLOCK != n->type)
520 return(1);
521
522 /* LINTED */
523 for (node = mdoc->last->parent; node; node = node->parent)
524 if (MDOC_BLOCK == node->type)
525 if (MDOC_Bd == node->tok)
526 break;
527 if (NULL == node)
528 return(1);
529
530 mdoc_nmsg(mdoc, n, MANDOCERR_NESTEDDISP);
531 return(0);
532 }
533
534
535 static int
536 pre_bl(PRE_ARGS)
537 {
538 int pos, type, width, offset;
539
540 if (MDOC_BLOCK != n->type)
541 return(1);
542 if (NULL == n->args) {
543 mdoc_nmsg(mdoc, n, MANDOCERR_LISTTYPE);
544 return(0);
545 }
546
547 /* Make sure that only one type of list is specified. */
548
549 type = offset = width = -1;
550
551 /* LINTED */
552 for (pos = 0; pos < (int)n->args->argc; pos++)
553 switch (n->args->argv[pos].arg) {
554 case (MDOC_Bullet):
555 /* FALLTHROUGH */
556 case (MDOC_Dash):
557 /* FALLTHROUGH */
558 case (MDOC_Enum):
559 /* FALLTHROUGH */
560 case (MDOC_Hyphen):
561 /* FALLTHROUGH */
562 case (MDOC_Item):
563 /* FALLTHROUGH */
564 case (MDOC_Tag):
565 /* FALLTHROUGH */
566 case (MDOC_Diag):
567 /* FALLTHROUGH */
568 case (MDOC_Hang):
569 /* FALLTHROUGH */
570 case (MDOC_Ohang):
571 /* FALLTHROUGH */
572 case (MDOC_Inset):
573 /* FALLTHROUGH */
574 case (MDOC_Column):
575 if (type < 0) {
576 type = n->args->argv[pos].arg;
577 break;
578 }
579 if (mdoc_nmsg(mdoc, n, MANDOCERR_LISTREP))
580 break;
581 return(0);
582 case (MDOC_Compact):
583 if (type >= 0)
584 break;
585 if (mdoc_nmsg(mdoc, n, MANDOCERR_LISTFIRST))
586 break;
587 return(0);
588 case (MDOC_Width):
589 if (width >= 0)
590 if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_ARGVREP))
591 return(0);
592 if (type < 0 && ! mdoc_nmsg(mdoc, n, MANDOCERR_LISTFIRST))
593 return(0);
594 width = n->args->argv[pos].arg;
595 break;
596 case (MDOC_Offset):
597 if (offset >= 0)
598 if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_ARGVREP))
599 return(0);
600 if (type < 0 && ! mdoc_nmsg(mdoc, n, MANDOCERR_LISTFIRST))
601 return(0);
602 offset = n->args->argv[pos].arg;
603 break;
604 default:
605 break;
606 }
607
608 if (type < 0) {
609 mdoc_nmsg(mdoc, n, MANDOCERR_LISTTYPE);
610 return(0);
611 }
612
613 /*
614 * Validate the width field. Some list types don't need width
615 * types and should be warned about them. Others should have it
616 * and must also be warned.
617 */
618
619 switch (type) {
620 case (MDOC_Tag):
621 if (width < 0 && ! mdoc_nmsg(mdoc, n, MANDOCERR_NOWIDTHARG))
622 return(0);
623 break;
624 case (MDOC_Column):
625 /* FALLTHROUGH */
626 case (MDOC_Diag):
627 /* FALLTHROUGH */
628 case (MDOC_Ohang):
629 /* FALLTHROUGH */
630 case (MDOC_Inset):
631 /* FALLTHROUGH */
632 case (MDOC_Item):
633 if (width >= 0 && ! mdoc_nmsg(mdoc, n, MANDOCERR_WIDTHARG))
634 return(0);
635 break;
636 default:
637 break;
638 }
639
640 return(1);
641 }
642
643
644 static int
645 pre_bd(PRE_ARGS)
646 {
647 int i, type, err;
648
649 if (MDOC_BLOCK != n->type)
650 return(1);
651 if (NULL == n->args) {
652 mdoc_nmsg(mdoc, n, MANDOCERR_DISPTYPE);
653 return(0);
654 }
655
656 /* Make sure that only one type of display is specified. */
657
658 /* LINTED */
659 for (i = 0, err = type = 0; ! err &&
660 i < (int)n->args->argc; i++)
661 switch (n->args->argv[i].arg) {
662 case (MDOC_Centred):
663 /* FALLTHROUGH */
664 case (MDOC_Ragged):
665 /* FALLTHROUGH */
666 case (MDOC_Unfilled):
667 /* FALLTHROUGH */
668 case (MDOC_Filled):
669 /* FALLTHROUGH */
670 case (MDOC_Literal):
671 if (0 == type++)
672 break;
673 if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_DISPREP))
674 return(0);
675 break;
676 default:
677 break;
678 }
679
680 if (type)
681 return(1);
682 mdoc_nmsg(mdoc, n, MANDOCERR_DISPTYPE);
683 return(0);
684 }
685
686
687 static int
688 pre_ss(PRE_ARGS)
689 {
690
691 if (MDOC_BLOCK != n->type)
692 return(1);
693 return(check_parent(mdoc, n, MDOC_Sh, MDOC_BODY));
694 }
695
696
697 static int
698 pre_sh(PRE_ARGS)
699 {
700
701 if (MDOC_BLOCK != n->type)
702 return(1);
703 return(check_parent(mdoc, n, MDOC_MAX, MDOC_ROOT));
704 }
705
706
707 static int
708 pre_it(PRE_ARGS)
709 {
710
711 if (MDOC_BLOCK != n->type)
712 return(1);
713 /*
714 * FIXME: this can probably be lifted if we make the It into
715 * something else on-the-fly?
716 */
717 return(check_parent(mdoc, n, MDOC_Bl, MDOC_BODY));
718 }
719
720
721 static int
722 pre_an(PRE_ARGS)
723 {
724
725 if (NULL == n->args || 1 == n->args->argc)
726 return(1);
727 mdoc_vmsg(mdoc, MANDOCERR_SYNTARGCOUNT,
728 n->line, n->pos,
729 "line arguments == 1 (have %d)",
730 n->args->argc);
731 return(0);
732 }
733
734
735 static int
736 pre_rv(PRE_ARGS)
737 {
738
739 return(check_stdarg(mdoc, n));
740 }
741
742
743 static int
744 post_dt(POST_ARGS)
745 {
746 const struct mdoc_node *nn;
747 const char *p;
748
749 if (NULL != (nn = mdoc->last->child))
750 for (p = nn->string; *p; p++) {
751 if (toupper((u_char)*p) == *p)
752 continue;
753 if ( ! mdoc_nmsg(mdoc, nn, MANDOCERR_UPPERCASE))
754 return(0);
755 break;
756 }
757
758 return(1);
759 }
760
761
762 static int
763 pre_dt(PRE_ARGS)
764 {
765
766 if (0 == mdoc->meta.date || mdoc->meta.os)
767 if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_PROLOGOOO))
768 return(0);
769 if (mdoc->meta.title)
770 if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_PROLOGREP))
771 return(0);
772 return(1);
773 }
774
775
776 static int
777 pre_os(PRE_ARGS)
778 {
779
780 if (NULL == mdoc->meta.title || 0 == mdoc->meta.date)
781 if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_PROLOGOOO))
782 return(0);
783 if (mdoc->meta.os)
784 if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_PROLOGREP))
785 return(0);
786 return(1);
787 }
788
789
790 static int
791 pre_dd(PRE_ARGS)
792 {
793
794 if (mdoc->meta.title || mdoc->meta.os)
795 if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_PROLOGOOO))
796 return(0);
797 if (mdoc->meta.date)
798 if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_PROLOGREP))
799 return(0);
800 return(1);
801 }
802
803
804 static int
805 post_bf(POST_ARGS)
806 {
807 char *p;
808 struct mdoc_node *head;
809
810 if (MDOC_BLOCK != mdoc->last->type)
811 return(1);
812
813 head = mdoc->last->head;
814
815 if (mdoc->last->args && head->child) {
816 /* FIXME: this should provide a default. */
817 mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_SYNTARGVCOUNT);
818 return(0);
819 } else if (mdoc->last->args)
820 return(1);
821
822 if (NULL == head->child || MDOC_TEXT != head->child->type) {
823 /* FIXME: this should provide a default. */
824 mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_SYNTARGVCOUNT);
825 return(0);
826 }
827
828 p = head->child->string;
829
830 if (0 == strcmp(p, "Em"))
831 return(1);
832 else if (0 == strcmp(p, "Li"))
833 return(1);
834 else if (0 == strcmp(p, "Sy"))
835 return(1);
836
837 mdoc_nmsg(mdoc, head, MANDOCERR_FONTTYPE);
838 return(0);
839 }
840
841
842 static int
843 post_lb(POST_ARGS)
844 {
845
846 if (mdoc_a2lib(mdoc->last->child->string))
847 return(1);
848 return(mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADLIB));
849 }
850
851
852 static int
853 post_eoln(POST_ARGS)
854 {
855
856 if (NULL == mdoc->last->child)
857 return(1);
858 return(mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_ARGSLOST));
859 }
860
861
862 static int
863 post_vt(POST_ARGS)
864 {
865 const struct mdoc_node *n;
866
867 /*
868 * The Vt macro comes in both ELEM and BLOCK form, both of which
869 * have different syntaxes (yet more context-sensitive
870 * behaviour). ELEM types must have a child; BLOCK types,
871 * specifically the BODY, should only have TEXT children.
872 */
873
874 if (MDOC_ELEM == mdoc->last->type)
875 return(eerr_ge1(mdoc));
876 if (MDOC_BODY != mdoc->last->type)
877 return(1);
878
879 for (n = mdoc->last->child; n; n = n->next)
880 if (MDOC_TEXT != n->type)
881 if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_CHILD))
882 return(0);
883
884 return(1);
885 }
886
887
888 static int
889 post_nm(POST_ARGS)
890 {
891
892 if (mdoc->last->child)
893 return(1);
894 if (mdoc->meta.name)
895 return(1);
896 return(mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NONAME));
897 }
898
899
900 static int
901 post_at(POST_ARGS)
902 {
903
904 if (NULL == mdoc->last->child)
905 return(1);
906 assert(MDOC_TEXT == mdoc->last->child->type);
907 if (mdoc_a2att(mdoc->last->child->string))
908 return(1);
909 return(mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADATT));
910 }
911
912
913 static int
914 post_an(POST_ARGS)
915 {
916
917 if (mdoc->last->args) {
918 if (NULL == mdoc->last->child)
919 return(1);
920 return(mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_ARGCOUNT));
921 }
922
923 if (mdoc->last->child)
924 return(1);
925 return(mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOARGS));
926 }
927
928
929 static int
930 post_it(POST_ARGS)
931 {
932 int i, cols, rc;
933 enum mdoc_list lt;
934 struct mdoc_node *n, *c;
935 enum mandocerr er;
936
937 if (MDOC_BLOCK != mdoc->last->type)
938 return(1);
939
940 n = mdoc->last->parent->parent;
941 lt = n->data.list;
942
943 if (LIST__NONE == lt) {
944 mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_LISTTYPE);
945 return(0);
946 }
947
948 switch (lt) {
949 case (LIST_tag):
950 if (mdoc->last->head->child)
951 break;
952 /* FIXME: give this a dummy value. */
953 if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOARGS))
954 return(0);
955 break;
956 case (LIST_hang):
957 /* FALLTHROUGH */
958 case (LIST_ohang):
959 /* FALLTHROUGH */
960 case (LIST_inset):
961 /* FALLTHROUGH */
962 case (LIST_diag):
963 if (NULL == mdoc->last->head->child)
964 if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOARGS))
965 return(0);
966 if (NULL == mdoc->last->body->child)
967 if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOBODY))
968 return(0);
969 break;
970 case (LIST_bullet):
971 /* FALLTHROUGH */
972 case (LIST_dash):
973 /* FALLTHROUGH */
974 case (LIST_enum):
975 /* FALLTHROUGH */
976 case (LIST_hyphen):
977 /* FALLTHROUGH */
978 case (LIST_item):
979 if (mdoc->last->head->child)
980 if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_ARGSLOST))
981 return(0);
982 if (NULL == mdoc->last->body->child)
983 if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOBODY))
984 return(0);
985 break;
986 case (LIST_column):
987 cols = -1;
988 for (i = 0; i < (int)n->args->argc; i++)
989 if (MDOC_Column == n->args->argv[i].arg) {
990 cols = (int)n->args->argv[i].sz;
991 break;
992 }
993
994 assert(-1 != cols);
995 assert(NULL == mdoc->last->head->child);
996
997 if (NULL == mdoc->last->body->child)
998 if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NOBODY))
999 return(0);
1000
1001 for (i = 0, c = mdoc->last->child; c; c = c->next)
1002 if (MDOC_BODY == c->type)
1003 i++;
1004
1005 if (i < cols)
1006 er = MANDOCERR_ARGCOUNT;
1007 else if (i == cols || i == cols + 1)
1008 break;
1009 else
1010 er = MANDOCERR_SYNTARGCOUNT;
1011
1012 rc = mdoc_vmsg(mdoc, er,
1013 mdoc->last->line, mdoc->last->pos,
1014 "columns == %d (have %d)", cols, i);
1015 return(rc);
1016 default:
1017 break;
1018 }
1019
1020 return(1);
1021 }
1022
1023
1024 static int
1025 post_bl_head(POST_ARGS)
1026 {
1027 int i;
1028 struct mdoc_node *n;
1029
1030 assert(mdoc->last->parent);
1031 n = mdoc->last->parent;
1032
1033 if (LIST_column == n->data.list) {
1034 for (i = 0; i < (int)n->args->argc; i++)
1035 if (MDOC_Column == n->args->argv[i].arg)
1036 break;
1037 assert(i < (int)n->args->argc);
1038
1039 if (n->args->argv[i].sz && mdoc->last->nchild) {
1040 mdoc_nmsg(mdoc, n, MANDOCERR_COLUMNS);
1041 return(0);
1042 }
1043 return(1);
1044 }
1045
1046 if (0 == (i = mdoc->last->nchild))
1047 return(1);
1048 return(warn_count(mdoc, "==", 0, "line arguments", i));
1049 }
1050
1051
1052 static int
1053 post_bl(POST_ARGS)
1054 {
1055 struct mdoc_node *n;
1056
1057 if (MDOC_HEAD == mdoc->last->type)
1058 return(post_bl_head(mdoc));
1059 if (MDOC_BODY != mdoc->last->type)
1060 return(1);
1061 if (NULL == mdoc->last->child)
1062 return(1);
1063
1064 /*
1065 * We only allow certain children of `Bl'. This is usually on
1066 * `It', but apparently `Sm' occurs here and there, so we let
1067 * that one through, too.
1068 */
1069
1070 /* LINTED */
1071 for (n = mdoc->last->child; n; n = n->next) {
1072 if (MDOC_BLOCK == n->type && MDOC_It == n->tok)
1073 continue;
1074 if (MDOC_Sm == n->tok)
1075 continue;
1076 mdoc_nmsg(mdoc, n, MANDOCERR_SYNTCHILD);
1077 return(0);
1078 }
1079
1080 return(1);
1081 }
1082
1083
1084 static int
1085 ebool(struct mdoc *mdoc)
1086 {
1087 struct mdoc_node *n;
1088
1089 /* LINTED */
1090 for (n = mdoc->last->child; n; n = n->next) {
1091 if (MDOC_TEXT != n->type)
1092 break;
1093 if (0 == strcmp(n->string, "on"))
1094 continue;
1095 if (0 == strcmp(n->string, "off"))
1096 continue;
1097 break;
1098 }
1099
1100 if (NULL == n)
1101 return(1);
1102 return(mdoc_nmsg(mdoc, n, MANDOCERR_BADBOOL));
1103 }
1104
1105
1106 static int
1107 post_root(POST_ARGS)
1108 {
1109
1110 if (NULL == mdoc->first->child)
1111 mdoc_nmsg(mdoc, mdoc->first, MANDOCERR_NODOCBODY);
1112 else if ( ! (MDOC_PBODY & mdoc->flags))
1113 mdoc_nmsg(mdoc, mdoc->first, MANDOCERR_NODOCPROLOG);
1114 else if (MDOC_BLOCK != mdoc->first->child->type)
1115 mdoc_nmsg(mdoc, mdoc->first, MANDOCERR_NODOCBODY);
1116 else if (MDOC_Sh != mdoc->first->child->tok)
1117 mdoc_nmsg(mdoc, mdoc->first, MANDOCERR_NODOCBODY);
1118 else
1119 return(1);
1120
1121 return(0);
1122 }
1123
1124
1125 static int
1126 post_st(POST_ARGS)
1127 {
1128
1129 if (mdoc_a2st(mdoc->last->child->string))
1130 return(1);
1131 return(mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADSTANDARD));
1132 }
1133
1134
1135 static int
1136 post_rs(POST_ARGS)
1137 {
1138 struct mdoc_node *nn;
1139
1140 if (MDOC_BODY != mdoc->last->type)
1141 return(1);
1142
1143 for (nn = mdoc->last->child; nn; nn = nn->next)
1144 switch (nn->tok) {
1145 case(MDOC__U):
1146 /* FALLTHROUGH */
1147 case(MDOC__Q):
1148 /* FALLTHROUGH */
1149 case(MDOC__C):
1150 /* FALLTHROUGH */
1151 case(MDOC__A):
1152 /* FALLTHROUGH */
1153 case(MDOC__B):
1154 /* FALLTHROUGH */
1155 case(MDOC__D):
1156 /* FALLTHROUGH */
1157 case(MDOC__I):
1158 /* FALLTHROUGH */
1159 case(MDOC__J):
1160 /* FALLTHROUGH */
1161 case(MDOC__N):
1162 /* FALLTHROUGH */
1163 case(MDOC__O):
1164 /* FALLTHROUGH */
1165 case(MDOC__P):
1166 /* FALLTHROUGH */
1167 case(MDOC__R):
1168 /* FALLTHROUGH */
1169 case(MDOC__T):
1170 /* FALLTHROUGH */
1171 case(MDOC__V):
1172 break;
1173 default:
1174 mdoc_nmsg(mdoc, nn, MANDOCERR_SYNTCHILD);
1175 return(0);
1176 }
1177
1178 return(1);
1179 }
1180
1181
1182 static int
1183 post_sh(POST_ARGS)
1184 {
1185
1186 if (MDOC_HEAD == mdoc->last->type)
1187 return(post_sh_head(mdoc));
1188 if (MDOC_BODY == mdoc->last->type)
1189 return(post_sh_body(mdoc));
1190
1191 return(1);
1192 }
1193
1194
1195 static int
1196 post_sh_body(POST_ARGS)
1197 {
1198 struct mdoc_node *n;
1199
1200 if (SEC_NAME != mdoc->lastsec)
1201 return(1);
1202
1203 /*
1204 * Warn if the NAME section doesn't contain the `Nm' and `Nd'
1205 * macros (can have multiple `Nm' and one `Nd'). Note that the
1206 * children of the BODY declaration can also be "text".
1207 */
1208
1209 if (NULL == (n = mdoc->last->child))
1210 return(mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADNAMESEC));
1211
1212 for ( ; n && n->next; n = n->next) {
1213 if (MDOC_ELEM == n->type && MDOC_Nm == n->tok)
1214 continue;
1215 if (MDOC_TEXT == n->type)
1216 continue;
1217 if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADNAMESEC))
1218 return(0);
1219 }
1220
1221 assert(n);
1222 if (MDOC_BLOCK == n->type && MDOC_Nd == n->tok)
1223 return(1);
1224 return(mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_BADNAMESEC));
1225 }
1226
1227
1228 static int
1229 post_sh_head(POST_ARGS)
1230 {
1231 char buf[BUFSIZ];
1232 enum mdoc_sec sec;
1233 const struct mdoc_node *n;
1234
1235 /*
1236 * Process a new section. Sections are either "named" or
1237 * "custom"; custom sections are user-defined, while named ones
1238 * usually follow a conventional order and may only appear in
1239 * certain manual sections.
1240 */
1241
1242 buf[0] = '\0';
1243
1244 /*
1245 * FIXME: yes, these can use a dynamic buffer, but I don't do so
1246 * in the interests of simplicity.
1247 */
1248
1249 for (n = mdoc->last->child; n; n = n->next) {
1250 /* XXX - copied from compact(). */
1251 assert(MDOC_TEXT == n->type);
1252
1253 if (strlcat(buf, n->string, BUFSIZ) >= BUFSIZ) {
1254 mdoc_nmsg(mdoc, n, MANDOCERR_MEM);
1255 return(0);
1256 }
1257 if (NULL == n->next)
1258 continue;
1259 if (strlcat(buf, " ", BUFSIZ) >= BUFSIZ) {
1260 mdoc_nmsg(mdoc, n, MANDOCERR_MEM);
1261 return(0);
1262 }
1263 }
1264
1265 sec = mdoc_str2sec(buf);
1266
1267 /*
1268 * Check: NAME should always be first, CUSTOM has no roles,
1269 * non-CUSTOM has a conventional order to be followed.
1270 */
1271
1272 if (SEC_NAME != sec && SEC_NONE == mdoc->lastnamed)
1273 if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_NAMESECFIRST))
1274 return(0);
1275
1276 if (SEC_CUSTOM == sec)
1277 return(1);
1278
1279 if (sec == mdoc->lastnamed)
1280 if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_SECREP))
1281 return(0);
1282
1283 if (sec < mdoc->lastnamed)
1284 if ( ! mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_SECOOO))
1285 return(0);
1286
1287 /*
1288 * Check particular section/manual conventions. LIBRARY can
1289 * only occur in manual section 2, 3, and 9.
1290 */
1291
1292 switch (sec) {
1293 case (SEC_LIBRARY):
1294 assert(mdoc->meta.msec);
1295 if (*mdoc->meta.msec == '2')
1296 break;
1297 if (*mdoc->meta.msec == '3')
1298 break;
1299 if (*mdoc->meta.msec == '9')
1300 break;
1301 return(mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_SECMSEC));
1302 default:
1303 break;
1304 }
1305
1306 return(1);
1307 }
A git conversion mirror of mandoc.bsd.lv