Annotation of mandoc/validate.c, Revision 1.44
1.44 ! kristaps 1: /* $Id: validate.c,v 1.43 2009/01/20 12:51:28 kristaps Exp $ */
1.1 kristaps 2: /*
3: * Copyright (c) 2008 Kristaps Dzonsons <kristaps@kth.se>
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
7: * above copyright notice and this permission notice appear in all
8: * copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
11: * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
12: * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
13: * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
14: * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
15: * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
16: * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17: * PERFORMANCE OF THIS SOFTWARE.
18: */
19: #include <assert.h>
1.8 kristaps 20: #include <stdlib.h>
1.1 kristaps 21:
22: #include "private.h"
23:
1.44 ! kristaps 24: /*
! 25: * Pre- and post-validate macros as they're parsed. Pre-validation
! 26: * occurs when the macro has been detected and its arguments parsed.
! 27: * Post-validation occurs when all child macros have also been parsed.
! 28: * In the ELEMENT case, this is simply the parameters of the macro; in
! 29: * the BLOCK case, this is the HEAD, BODY, TAIL and so on.
! 30: */
! 31:
1.18 kristaps 32: typedef int (*v_pre)(struct mdoc *, struct mdoc_node *);
33: typedef int (*v_post)(struct mdoc *);
1.14 kristaps 34:
1.36 kristaps 35: /* FIXME: some sections should only occur in specific msecs. */
36: /* FIXME: ignoring Pp. */
37: /* FIXME: math symbols. */
1.37 kristaps 38: /* FIXME: valid character-escape checks. */
1.39 kristaps 39: /* FIXME: make sure required sections are included (NAME, ...). */
1.36 kristaps 40:
1.14 kristaps 41: struct valids {
1.24 kristaps 42: v_pre *pre;
1.17 kristaps 43: v_post *post;
1.14 kristaps 44: };
1.1 kristaps 45:
1.37 kristaps 46: /* Utility checks. */
47:
1.33 kristaps 48: static int pre_check_parent(struct mdoc *, struct mdoc_node *,
49: int, enum mdoc_type);
50: static int pre_check_msecs(struct mdoc *, struct mdoc_node *,
51: int, enum mdoc_msec *);
1.36 kristaps 52: static int pre_check_stdarg(struct mdoc *, struct mdoc_node *);
53: static int post_check_children_count(struct mdoc *);
1.40 kristaps 54: static int post_check_children_lt(struct mdoc *, const char *, int);
55: static int post_check_children_gt(struct mdoc *, const char *, int);
56: static int post_check_children_wgt(struct mdoc *, const char *, int);
57: static int post_check_children_eq(struct mdoc *, const char *, int);
58: static int post_check_children_weq(struct mdoc *, const char *, int);
1.11 kristaps 59:
1.37 kristaps 60: /* Specific pre-child-parse routines. */
61:
1.23 kristaps 62: static int pre_display(struct mdoc *, struct mdoc_node *);
1.33 kristaps 63: static int pre_sh(struct mdoc *, struct mdoc_node *);
64: static int pre_ss(struct mdoc *, struct mdoc_node *);
1.24 kristaps 65: static int pre_bd(struct mdoc *, struct mdoc_node *);
66: static int pre_bl(struct mdoc *, struct mdoc_node *);
1.25 kristaps 67: static int pre_it(struct mdoc *, struct mdoc_node *);
1.33 kristaps 68: static int pre_cd(struct mdoc *, struct mdoc_node *);
69: static int pre_er(struct mdoc *, struct mdoc_node *);
70: static int pre_ex(struct mdoc *, struct mdoc_node *);
1.36 kristaps 71: static int pre_rv(struct mdoc *, struct mdoc_node *);
1.35 kristaps 72: static int pre_an(struct mdoc *, struct mdoc_node *);
1.36 kristaps 73: static int pre_st(struct mdoc *, struct mdoc_node *);
1.20 kristaps 74: static int pre_prologue(struct mdoc *, struct mdoc_node *);
75: static int pre_prologue(struct mdoc *, struct mdoc_node *);
76: static int pre_prologue(struct mdoc *, struct mdoc_node *);
1.24 kristaps 77:
1.37 kristaps 78: /* Specific post-child-parse routines. */
79:
80: static int herr_ge1(struct mdoc *);
1.41 kristaps 81: static int herr_le1(struct mdoc *);
1.37 kristaps 82: static int herr_eq0(struct mdoc *);
83: static int eerr_eq0(struct mdoc *);
84: static int eerr_le1(struct mdoc *);
85: static int eerr_le2(struct mdoc *);
86: static int eerr_eq1(struct mdoc *);
87: static int eerr_ge1(struct mdoc *);
88: static int ewarn_eq0(struct mdoc *);
1.39 kristaps 89: static int ewarn_eq1(struct mdoc *);
1.37 kristaps 90: static int bwarn_ge1(struct mdoc *);
91: static int ewarn_ge1(struct mdoc *);
92: static int ebool(struct mdoc *);
1.21 kristaps 93: static int post_sh(struct mdoc *);
1.24 kristaps 94: static int post_bl(struct mdoc *);
1.25 kristaps 95: static int post_it(struct mdoc *);
1.35 kristaps 96: static int post_ex(struct mdoc *);
97: static int post_an(struct mdoc *);
1.36 kristaps 98: static int post_at(struct mdoc *);
99: static int post_xr(struct mdoc *);
1.37 kristaps 100: static int post_nm(struct mdoc *);
1.41 kristaps 101: static int post_bf(struct mdoc *);
1.37 kristaps 102: static int post_root(struct mdoc *);
103:
104: /* Collections of pre-child-parse routines. */
1.17 kristaps 105:
1.24 kristaps 106: static v_pre pres_prologue[] = { pre_prologue, NULL };
107: static v_pre pres_d1[] = { pre_display, NULL };
108: static v_pre pres_bd[] = { pre_display, pre_bd, NULL };
109: static v_pre pres_bl[] = { pre_bl, NULL };
1.25 kristaps 110: static v_pre pres_it[] = { pre_it, NULL };
1.33 kristaps 111: static v_pre pres_ss[] = { pre_ss, NULL };
112: static v_pre pres_sh[] = { pre_sh, NULL };
113: static v_pre pres_cd[] = { pre_cd, NULL };
114: static v_pre pres_er[] = { pre_er, NULL };
115: static v_pre pres_ex[] = { pre_ex, NULL };
1.36 kristaps 116: static v_pre pres_rv[] = { pre_rv, NULL };
1.35 kristaps 117: static v_pre pres_an[] = { pre_an, NULL };
1.36 kristaps 118: static v_pre pres_st[] = { pre_st, NULL };
1.24 kristaps 119:
1.37 kristaps 120: /* Collections of post-child-parse routines. */
121:
122: static v_post posts_bool[] = { eerr_eq1, ebool, NULL };
123: static v_post posts_bd[] = { herr_eq0, bwarn_ge1, NULL };
124: static v_post posts_text[] = { eerr_ge1, NULL };
125: static v_post posts_wtext[] = { ewarn_ge1, NULL };
126: static v_post posts_notext[] = { eerr_eq0, NULL };
1.43 kristaps 127: static v_post posts_wline[] = { bwarn_ge1, herr_eq0, NULL };
1.37 kristaps 128: static v_post posts_sh[] = { herr_ge1, bwarn_ge1, post_sh, NULL };
129: static v_post posts_bl[] = { herr_eq0, bwarn_ge1, post_bl, NULL };
1.25 kristaps 130: static v_post posts_it[] = { post_it, NULL };
1.39 kristaps 131: static v_post posts_in[] = { ewarn_eq1, NULL };
1.37 kristaps 132: static v_post posts_ss[] = { herr_ge1, NULL };
133: static v_post posts_pp[] = { ewarn_eq0, NULL };
134: static v_post posts_ex[] = { eerr_le1, post_ex, NULL };
1.35 kristaps 135: static v_post posts_an[] = { post_an, NULL };
1.37 kristaps 136: static v_post posts_at[] = { post_at, NULL };
137: static v_post posts_xr[] = { eerr_ge1, eerr_le2, post_xr, NULL };
138: static v_post posts_nm[] = { post_nm, NULL };
1.41 kristaps 139: static v_post posts_bf[] = { herr_le1, post_bf, NULL };
1.9 kristaps 140:
1.37 kristaps 141: /* Per-macro pre- and post-child-check routine collections. */
1.12 kristaps 142:
1.9 kristaps 143: const struct valids mdoc_valids[MDOC_MAX] = {
1.17 kristaps 144: { NULL, NULL }, /* \" */
1.26 kristaps 145: { pres_prologue, posts_text }, /* Dd */
1.24 kristaps 146: { pres_prologue, NULL }, /* Dt */
147: { pres_prologue, NULL }, /* Os */
1.26 kristaps 148: /* FIXME: NAME section internal ordering. */
1.33 kristaps 149: { pres_sh, posts_sh }, /* Sh */
150: { pres_ss, posts_ss }, /* Ss */
1.26 kristaps 151: { NULL, posts_pp }, /* Pp */
1.43 kristaps 152: { pres_d1, posts_wline }, /* D1 */
153: { pres_d1, posts_wline }, /* Dl */
1.26 kristaps 154: { pres_bd, posts_bd }, /* Bd */
1.17 kristaps 155: { NULL, NULL }, /* Ed */
1.26 kristaps 156: { pres_bl, posts_bl }, /* Bl */
1.17 kristaps 157: { NULL, NULL }, /* El */
1.25 kristaps 158: { pres_it, posts_it }, /* It */
1.26 kristaps 159: { NULL, posts_text }, /* Ad */
1.35 kristaps 160: { pres_an, posts_an }, /* An */
1.17 kristaps 161: { NULL, NULL }, /* Ar */
1.33 kristaps 162: { pres_cd, posts_text }, /* Cd */
1.17 kristaps 163: { NULL, NULL }, /* Cm */
1.26 kristaps 164: { NULL, posts_text }, /* Dv */
1.33 kristaps 165: { pres_er, posts_text }, /* Er */
1.26 kristaps 166: { NULL, posts_text }, /* Ev */
1.35 kristaps 167: { pres_ex, posts_ex }, /* Ex */
1.26 kristaps 168: { NULL, posts_text }, /* Fa */
1.35 kristaps 169: /* FIXME: only in SYNOPSIS section. */
1.39 kristaps 170: { NULL, posts_wtext }, /* Fd */
1.17 kristaps 171: { NULL, NULL }, /* Fl */
1.26 kristaps 172: { NULL, posts_text }, /* Fn */
1.39 kristaps 173: { NULL, posts_wtext }, /* Ft */
1.26 kristaps 174: { NULL, posts_text }, /* Ic */
1.39 kristaps 175: { NULL, posts_in }, /* In */
1.26 kristaps 176: { NULL, posts_text }, /* Li */
177: { NULL, posts_wtext }, /* Nd */
1.37 kristaps 178: { NULL, posts_nm }, /* Nm */
1.27 kristaps 179: { NULL, posts_wline }, /* Op */
1.17 kristaps 180: { NULL, NULL }, /* Ot */
181: { NULL, NULL }, /* Pa */
1.36 kristaps 182: { pres_rv, posts_notext }, /* Rv */
183: { pres_st, posts_notext }, /* St */
1.26 kristaps 184: { NULL, posts_text }, /* Va */
185: { NULL, posts_text }, /* Vt */
1.36 kristaps 186: { NULL, posts_xr }, /* Xr */
1.26 kristaps 187: { NULL, posts_text }, /* %A */
188: { NULL, posts_text }, /* %B */
189: { NULL, posts_text }, /* %D */
190: { NULL, posts_text }, /* %I */
191: { NULL, posts_text }, /* %J */
192: { NULL, posts_text }, /* %N */
193: { NULL, posts_text }, /* %O */
194: { NULL, posts_text }, /* %P */
195: { NULL, posts_text }, /* %R */
196: { NULL, posts_text }, /* %T */
197: { NULL, posts_text }, /* %V */
1.17 kristaps 198: { NULL, NULL }, /* Ac */
199: { NULL, NULL }, /* Ao */
1.27 kristaps 200: { NULL, posts_wline }, /* Aq */
1.36 kristaps 201: { NULL, posts_at }, /* At */
1.17 kristaps 202: { NULL, NULL }, /* Bc */
1.42 kristaps 203: { NULL, posts_bf }, /* Bf */
1.17 kristaps 204: { NULL, NULL }, /* Bo */
1.27 kristaps 205: { NULL, posts_wline }, /* Bq */
1.17 kristaps 206: { NULL, NULL }, /* Bsx */
207: { NULL, NULL }, /* Bx */
1.34 kristaps 208: { NULL, posts_bool }, /* Db */
1.17 kristaps 209: { NULL, NULL }, /* Dc */
210: { NULL, NULL }, /* Do */
1.27 kristaps 211: { NULL, posts_wline }, /* Dq */
1.17 kristaps 212: { NULL, NULL }, /* Ec */
213: { NULL, NULL }, /* Ef */ /* -symbolic, etc. */
1.26 kristaps 214: { NULL, posts_text }, /* Em */
1.17 kristaps 215: { NULL, NULL }, /* Eo */
216: { NULL, NULL }, /* Fx */
1.36 kristaps 217: { NULL, posts_text }, /* Ms */
1.26 kristaps 218: { NULL, posts_notext }, /* No */
219: { NULL, posts_notext }, /* Ns */
1.17 kristaps 220: { NULL, NULL }, /* Nx */
221: { NULL, NULL }, /* Ox */
222: { NULL, NULL }, /* Pc */
1.35 kristaps 223: { NULL, NULL }, /* Pf */
1.17 kristaps 224: { NULL, NULL }, /* Po */
1.36 kristaps 225: { NULL, posts_wline }, /* Pq */
1.17 kristaps 226: { NULL, NULL }, /* Qc */
1.27 kristaps 227: { NULL, posts_wline }, /* Ql */
1.17 kristaps 228: { NULL, NULL }, /* Qo */
1.27 kristaps 229: { NULL, posts_wline }, /* Qq */
1.17 kristaps 230: { NULL, NULL }, /* Re */
231: { NULL, NULL }, /* Rs */
232: { NULL, NULL }, /* Sc */
233: { NULL, NULL }, /* So */
1.27 kristaps 234: { NULL, posts_wline }, /* Sq */
1.34 kristaps 235: { NULL, posts_bool }, /* Sm */
1.26 kristaps 236: { NULL, posts_text }, /* Sx */
237: { NULL, posts_text }, /* Sy */
238: { NULL, posts_text }, /* Tn */
1.17 kristaps 239: { NULL, NULL }, /* Ux */
240: { NULL, NULL }, /* Xc */
241: { NULL, NULL }, /* Xo */
242: { NULL, NULL }, /* Fo */
243: { NULL, NULL }, /* Fc */
244: { NULL, NULL }, /* Oo */
245: { NULL, NULL }, /* Oc */
246: { NULL, NULL }, /* Bk */
247: { NULL, NULL }, /* Ek */
1.26 kristaps 248: { NULL, posts_notext }, /* Bt */
1.17 kristaps 249: { NULL, NULL }, /* Hf */
250: { NULL, NULL }, /* Fr */
1.26 kristaps 251: { NULL, posts_notext }, /* Ud */
1.9 kristaps 252: };
1.6 kristaps 253:
254:
255: static int
1.36 kristaps 256: post_check_children_count(struct mdoc *mdoc)
257: {
258: struct mdoc_node *n;
259: int i;
260:
261: for (i = 0, n = mdoc->last->child; n; n = n->next, i++)
262: /* Do nothing */ ;
263: return(i);
264: }
265:
266:
267: static int
1.40 kristaps 268: post_check_children_wgt(struct mdoc *mdoc, const char *p, int sz)
1.39 kristaps 269: {
270: int i;
271:
272: if ((i = post_check_children_count(mdoc)) > sz)
273: return(1);
274: return(mdoc_warn(mdoc, WARN_SYNTAX, "macro suggests more "
1.40 kristaps 275: "than %d %s (has %d)", sz, p, i));
1.39 kristaps 276: }
277:
278:
279: static int
1.40 kristaps 280: post_check_children_gt(struct mdoc *mdoc, const char *p, int sz)
1.36 kristaps 281: {
282: int i;
283:
284: if ((i = post_check_children_count(mdoc)) > sz)
285: return(1);
286: return(mdoc_err(mdoc, "macro requires more than %d "
1.40 kristaps 287: "%s (has %d)", sz, p, i));
1.39 kristaps 288: }
289:
290:
291: static int
1.40 kristaps 292: post_check_children_weq(struct mdoc *mdoc, const char *p, int sz)
1.39 kristaps 293: {
294: int i;
295:
296: if ((i = post_check_children_count(mdoc)) == sz)
297: return(1);
298: return(mdoc_warn(mdoc, WARN_SYNTAX, "macro suggests %d "
1.40 kristaps 299: "%s (has %d)", sz, p, i));
1.36 kristaps 300: }
301:
302:
303: static int
1.40 kristaps 304: post_check_children_eq(struct mdoc *mdoc, const char *p, int sz)
1.36 kristaps 305: {
306: int i;
307:
308: if ((i = post_check_children_count(mdoc)) == sz)
309: return(1);
1.40 kristaps 310: return(mdoc_err(mdoc, "macro requires %d %s "
311: "(have %d)", sz, p, i));
1.36 kristaps 312: }
313:
314:
315: static int
1.40 kristaps 316: post_check_children_lt(struct mdoc *mdoc, const char *p, int sz)
1.36 kristaps 317: {
318: int i;
319:
320: if ((i = post_check_children_count(mdoc)) < sz)
321: return(1);
322: return(mdoc_err(mdoc, "macro requires less than %d "
1.40 kristaps 323: "%s (have %d)", sz, p, i));
1.36 kristaps 324: }
325:
326:
327: static int
328: pre_check_stdarg(struct mdoc *mdoc, struct mdoc_node *node)
329: {
330:
331: if (1 == node->data.elem.argc &&
332: MDOC_Std == node->data.elem.argv[0].arg)
333: return(1);
334: return(mdoc_nwarn(mdoc, node, WARN_COMPAT,
335: "macro suggests single `%s' argument",
336: mdoc_argnames[MDOC_Std]));
337: }
338:
339:
340: static int
1.33 kristaps 341: pre_check_msecs(struct mdoc *mdoc, struct mdoc_node *node,
342: int sz, enum mdoc_msec *msecs)
343: {
344: int i;
345:
346: for (i = 0; i < sz; i++)
347: if (msecs[i] == mdoc->meta.msec)
348: return(1);
1.37 kristaps 349: return(mdoc_nwarn(mdoc, node, WARN_COMPAT, "macro not "
350: "appropriate for manual section"));
1.33 kristaps 351: }
352:
353:
354: static int
355: pre_check_parent(struct mdoc *mdoc, struct mdoc_node *node,
356: int tok, enum mdoc_type type)
357: {
358:
1.35 kristaps 359: if (type != node->parent->type)
1.33 kristaps 360: return(mdoc_nerr(mdoc, node, "invalid macro parent class %s, expected %s",
1.35 kristaps 361: mdoc_type2a(node->parent->type),
1.33 kristaps 362: mdoc_type2a(type)));
1.35 kristaps 363: if (MDOC_ROOT != type && tok != node->parent->tok)
1.33 kristaps 364: return(mdoc_nerr(mdoc, node, "invalid macro parent `%s', expected `%s'",
1.35 kristaps 365: mdoc_macronames[node->parent->tok],
1.33 kristaps 366: mdoc_macronames[tok]));
367: return(1);
368: }
369:
370:
371: static int
1.37 kristaps 372: bwarn_ge1(struct mdoc *mdoc)
1.6 kristaps 373: {
374:
1.17 kristaps 375: if (MDOC_BODY != mdoc->last->type)
1.8 kristaps 376: return(1);
1.40 kristaps 377: return(post_check_children_wgt(mdoc, "body children", 0));
1.39 kristaps 378: }
379:
380:
381: static int
382: ewarn_eq1(struct mdoc *mdoc)
383: {
384:
385: assert(MDOC_ELEM == mdoc->last->type);
1.40 kristaps 386: return(post_check_children_weq(mdoc, "parameters", 1));
1.8 kristaps 387: }
1.1 kristaps 388:
389:
1.8 kristaps 390: static int
1.37 kristaps 391: ewarn_eq0(struct mdoc *mdoc)
1.22 kristaps 392: {
393:
394: assert(MDOC_ELEM == mdoc->last->type);
1.40 kristaps 395: return(post_check_children_weq(mdoc, "parameters", 0));
1.22 kristaps 396: }
397:
398:
399: static int
1.37 kristaps 400: ewarn_ge1(struct mdoc *mdoc)
1.26 kristaps 401: {
402:
403: assert(MDOC_ELEM == mdoc->last->type);
1.40 kristaps 404: return(post_check_children_wgt(mdoc, "parameters", 0));
1.26 kristaps 405: }
406:
407:
408: static int
1.37 kristaps 409: eerr_eq1(struct mdoc *mdoc)
1.34 kristaps 410: {
411:
412: assert(MDOC_ELEM == mdoc->last->type);
1.40 kristaps 413: return(post_check_children_eq(mdoc, "parameters", 1));
1.36 kristaps 414: }
415:
416:
417: static int
1.37 kristaps 418: eerr_le2(struct mdoc *mdoc)
1.36 kristaps 419: {
420:
421: assert(MDOC_ELEM == mdoc->last->type);
1.40 kristaps 422: return(post_check_children_lt(mdoc, "parameters", 3));
1.34 kristaps 423: }
424:
425:
426: static int
1.37 kristaps 427: eerr_le1(struct mdoc *mdoc)
1.35 kristaps 428: {
429:
430: assert(MDOC_ELEM == mdoc->last->type);
1.40 kristaps 431: return(post_check_children_lt(mdoc, "parameters", 2));
1.35 kristaps 432: }
433:
434:
435: static int
1.37 kristaps 436: eerr_eq0(struct mdoc *mdoc)
1.26 kristaps 437: {
438:
439: assert(MDOC_ELEM == mdoc->last->type);
1.40 kristaps 440: return(post_check_children_eq(mdoc, "parameters", 0));
1.26 kristaps 441: }
442:
443:
444: static int
1.37 kristaps 445: eerr_ge1(struct mdoc *mdoc)
1.8 kristaps 446: {
1.1 kristaps 447:
1.21 kristaps 448: assert(MDOC_ELEM == mdoc->last->type);
1.40 kristaps 449: return(post_check_children_gt(mdoc, "parameters", 0));
1.1 kristaps 450: }
451:
452:
1.9 kristaps 453: static int
1.37 kristaps 454: herr_eq0(struct mdoc *mdoc)
1.24 kristaps 455: {
456:
457: if (MDOC_HEAD != mdoc->last->type)
458: return(1);
1.40 kristaps 459: return(post_check_children_eq(mdoc, "parameters", 0));
1.24 kristaps 460: }
461:
462:
463: static int
1.41 kristaps 464: herr_le1(struct mdoc *mdoc)
465: {
466: if (MDOC_HEAD != mdoc->last->type)
467: return(1);
468: return(post_check_children_lt(mdoc, "parameters", 2));
469: }
470:
471:
472: static int
1.37 kristaps 473: herr_ge1(struct mdoc *mdoc)
1.14 kristaps 474: {
475:
1.17 kristaps 476: if (MDOC_HEAD != mdoc->last->type)
1.14 kristaps 477: return(1);
1.40 kristaps 478: return(post_check_children_gt(mdoc, "parameters", 0));
1.14 kristaps 479: }
480:
481:
482: static int
1.23 kristaps 483: pre_display(struct mdoc *mdoc, struct mdoc_node *node)
484: {
485: struct mdoc_node *n;
486:
1.24 kristaps 487: if (MDOC_BLOCK != node->type)
488: return(1);
489:
1.32 kristaps 490: assert(mdoc->last);
1.38 kristaps 491: /* LINTED */
1.32 kristaps 492: for (n = mdoc->last->parent; n; n = n->parent)
1.23 kristaps 493: if (MDOC_BLOCK == n->type)
1.25 kristaps 494: if (MDOC_Bd == n->tok)
1.23 kristaps 495: break;
496: if (NULL == n)
497: return(1);
1.31 kristaps 498: return(mdoc_nerr(mdoc, node, "displays may not be nested"));
1.23 kristaps 499: }
500:
501:
502: static int
1.24 kristaps 503: pre_bl(struct mdoc *mdoc, struct mdoc_node *node)
504: {
505: int type, err;
506: struct mdoc_arg *argv;
507: size_t i, argc;
508:
509: if (MDOC_BLOCK != node->type)
510: return(1);
1.25 kristaps 511: assert(MDOC_Bl == node->tok);
1.24 kristaps 512:
513: argv = NULL;
514: argc = node->data.block.argc;
515:
1.38 kristaps 516: /* LINTED */
1.24 kristaps 517: for (i = type = err = 0; i < argc; i++) {
518: argv = &node->data.block.argv[(int)i];
519: assert(argv);
520: switch (argv->arg) {
521: case (MDOC_Bullet):
522: /* FALLTHROUGH */
523: case (MDOC_Dash):
524: /* FALLTHROUGH */
525: case (MDOC_Enum):
526: /* FALLTHROUGH */
527: case (MDOC_Hyphen):
528: /* FALLTHROUGH */
529: case (MDOC_Item):
530: /* FALLTHROUGH */
531: case (MDOC_Tag):
532: /* FALLTHROUGH */
533: case (MDOC_Diag):
534: /* FALLTHROUGH */
535: case (MDOC_Hang):
536: /* FALLTHROUGH */
537: case (MDOC_Ohang):
538: /* FALLTHROUGH */
539: case (MDOC_Inset):
1.26 kristaps 540: /* FALLTHROUGH */
541: case (MDOC_Column):
1.24 kristaps 542: if (type)
543: err++;
544: type++;
545: break;
546: default:
547: break;
548: }
549: }
550: if (0 == type)
1.31 kristaps 551: return(mdoc_err(mdoc, "no list type specified"));
1.24 kristaps 552: if (0 == err)
553: return(1);
554: assert(argv);
555: return(mdoc_perr(mdoc, argv->line,
1.31 kristaps 556: argv->pos, "only one list type possible"));
1.24 kristaps 557: }
558:
559:
560: static int
561: pre_bd(struct mdoc *mdoc, struct mdoc_node *node)
562: {
563: int type, err;
564: struct mdoc_arg *argv;
565: size_t i, argc;
566:
567: if (MDOC_BLOCK != node->type)
568: return(1);
1.25 kristaps 569: assert(MDOC_Bd == node->tok);
1.24 kristaps 570:
571: argv = NULL;
572: argc = node->data.block.argc;
573:
1.38 kristaps 574: /* LINTED */
1.24 kristaps 575: for (err = i = type = 0; 0 == err && i < argc; i++) {
576: argv = &node->data.block.argv[(int)i];
577: assert(argv);
578: switch (argv->arg) {
579: case (MDOC_Ragged):
580: /* FALLTHROUGH */
581: case (MDOC_Unfilled):
582: /* FALLTHROUGH */
1.29 kristaps 583: case (MDOC_Filled):
584: /* FALLTHROUGH */
1.24 kristaps 585: case (MDOC_Literal):
586: /* FALLTHROUGH */
587: case (MDOC_File):
588: if (type)
589: err++;
590: type++;
591: break;
592: default:
593: break;
594: }
595: }
596: if (0 == type)
1.31 kristaps 597: return(mdoc_err(mdoc, "no display type specified"));
1.24 kristaps 598: if (0 == err)
599: return(1);
600: assert(argv);
601: return(mdoc_perr(mdoc, argv->line,
1.31 kristaps 602: argv->pos, "only one display type possible"));
1.24 kristaps 603: }
604:
605:
606: static int
1.33 kristaps 607: pre_ss(struct mdoc *mdoc, struct mdoc_node *node)
608: {
609:
1.35 kristaps 610: if (MDOC_BLOCK != node->type)
1.33 kristaps 611: return(1);
612: return(pre_check_parent(mdoc, node, MDOC_Sh, MDOC_BODY));
613: }
614:
615:
616: static int
617: pre_sh(struct mdoc *mdoc, struct mdoc_node *node)
618: {
619:
1.35 kristaps 620: if (MDOC_BLOCK != node->type)
1.33 kristaps 621: return(1);
622: return(pre_check_parent(mdoc, node, -1, MDOC_ROOT));
623: }
624:
625:
626: static int
1.36 kristaps 627: pre_st(struct mdoc *mdoc, struct mdoc_node *node)
628: {
629:
630: assert(MDOC_ELEM == node->type);
631: assert(MDOC_St == node->tok);
632: if (1 == node->data.elem.argc)
633: return(1);
634: return(mdoc_nerr(mdoc, node, "macro must have one argument"));
635: }
636:
637:
638: static int
1.35 kristaps 639: pre_an(struct mdoc *mdoc, struct mdoc_node *node)
640: {
1.36 kristaps 641:
1.35 kristaps 642: assert(MDOC_ELEM == node->type);
643: assert(MDOC_An == node->tok);
644: if (1 >= node->data.elem.argc)
645: return(1);
646: return(mdoc_nerr(mdoc, node, "macro may only have one argument"));
647: }
648:
649:
650: static int
1.36 kristaps 651: pre_rv(struct mdoc *mdoc, struct mdoc_node *node)
652: {
653: enum mdoc_msec msecs[2];
654:
655: assert(MDOC_ELEM == node->type);
656: assert(MDOC_Rv == node->tok);
657:
658: msecs[0] = MSEC_2;
659: msecs[1] = MSEC_3;
660: if ( ! pre_check_msecs(mdoc, node, 2, msecs))
661: return(0);
662: return(pre_check_stdarg(mdoc, node));
663: }
664:
665:
666: static int
1.33 kristaps 667: pre_ex(struct mdoc *mdoc, struct mdoc_node *node)
668: {
669: enum mdoc_msec msecs[3];
670:
1.35 kristaps 671: assert(MDOC_ELEM == node->type);
1.36 kristaps 672: assert(MDOC_Ex == node->tok);
1.35 kristaps 673:
1.33 kristaps 674: msecs[0] = MSEC_1;
675: msecs[1] = MSEC_6;
676: msecs[2] = MSEC_8;
1.35 kristaps 677: if ( ! pre_check_msecs(mdoc, node, 3, msecs))
678: return(0);
1.36 kristaps 679: return(pre_check_stdarg(mdoc, node));
1.33 kristaps 680: }
681:
682:
683: static int
684: pre_er(struct mdoc *mdoc, struct mdoc_node *node)
685: {
686: enum mdoc_msec msecs[1];
687:
688: msecs[0] = MSEC_2;
689: return(pre_check_msecs(mdoc, node, 1, msecs));
690: }
691:
692:
693: static int
694: pre_cd(struct mdoc *mdoc, struct mdoc_node *node)
695: {
696: enum mdoc_msec msecs[1];
697:
698: msecs[0] = MSEC_4;
699: return(pre_check_msecs(mdoc, node, 1, msecs));
700: }
701:
702:
703: static int
1.25 kristaps 704: pre_it(struct mdoc *mdoc, struct mdoc_node *node)
705: {
706:
1.35 kristaps 707: if (MDOC_BLOCK != node->type)
1.25 kristaps 708: return(1);
1.33 kristaps 709: return(pre_check_parent(mdoc, node, MDOC_Bl, MDOC_BODY));
1.25 kristaps 710: }
711:
712:
713: static int
1.20 kristaps 714: pre_prologue(struct mdoc *mdoc, struct mdoc_node *node)
715: {
716:
717: if (SEC_PROLOGUE != mdoc->sec_lastn)
1.31 kristaps 718: return(mdoc_nerr(mdoc, node, "macro may only be invoked in the prologue"));
1.20 kristaps 719: assert(MDOC_ELEM == node->type);
720:
721: /* Check for ordering. */
722:
1.25 kristaps 723: switch (node->tok) {
1.20 kristaps 724: case (MDOC_Os):
1.36 kristaps 725: if (mdoc->meta.title && mdoc->meta.date)
1.20 kristaps 726: break;
1.31 kristaps 727: return(mdoc_nerr(mdoc, node, "prologue macro out-of-order"));
1.20 kristaps 728: case (MDOC_Dt):
1.36 kristaps 729: if (NULL == mdoc->meta.title && mdoc->meta.date)
1.20 kristaps 730: break;
1.31 kristaps 731: return(mdoc_nerr(mdoc, node, "prologue macro out-of-order"));
1.20 kristaps 732: case (MDOC_Dd):
1.36 kristaps 733: if (NULL == mdoc->meta.title && 0 == mdoc->meta.date)
1.20 kristaps 734: break;
1.31 kristaps 735: return(mdoc_nerr(mdoc, node, "prologue macro out-of-order"));
1.20 kristaps 736: default:
737: abort();
738: /* NOTREACHED */
739: }
740:
741: /* Check for repetition. */
742:
1.25 kristaps 743: switch (node->tok) {
1.20 kristaps 744: case (MDOC_Os):
1.36 kristaps 745: if (NULL == mdoc->meta.os)
1.20 kristaps 746: return(1);
747: break;
748: case (MDOC_Dd):
749: if (0 == mdoc->meta.date)
750: return(1);
751: break;
752: case (MDOC_Dt):
1.36 kristaps 753: if (NULL == mdoc->meta.title)
1.20 kristaps 754: return(1);
755: break;
756: default:
757: abort();
758: /* NOTREACHED */
759: }
760:
1.31 kristaps 761: return(mdoc_nerr(mdoc, node, "prologue macro repeated"));
1.20 kristaps 762: }
763:
764:
1.35 kristaps 765: static int
1.41 kristaps 766: post_bf(struct mdoc *mdoc)
767: {
768: char *p;
769: struct mdoc_node *head;
770:
771: if (MDOC_BLOCK != mdoc->last->type)
772: return(1);
773: assert(MDOC_Bf == mdoc->last->tok);
774: head = mdoc->last->data.block.head;
775: assert(head);
776:
777: if (0 == mdoc->last->data.block.argc) {
778: if (head->child) {
779: assert(MDOC_TEXT == head->child->type);
780: p = head->child->data.text.string;
781: if (xstrcmp(p, "Em"))
782: return(1);
783: else if (xstrcmp(p, "Li"))
784: return(1);
785: else if (xstrcmp(p, "Sm"))
786: return(1);
787: return(mdoc_nerr(mdoc, head->child, "invalid font mode"));
788: }
789: return(mdoc_err(mdoc, "macro expects an argument or parameter"));
790: }
791: if (head->child)
792: return(mdoc_err(mdoc, "macro expects an argument or parameter"));
793: if (1 == mdoc->last->data.block.argc)
794: return(1);
795: return(mdoc_err(mdoc, "macro expects an argument or parameter"));
796: }
797:
798:
799: static int
1.37 kristaps 800: post_nm(struct mdoc *mdoc)
801: {
802:
803: assert(MDOC_ELEM == mdoc->last->type);
804: assert(MDOC_Nm == mdoc->last->tok);
805: if (mdoc->last->child)
806: return(1);
807: if (mdoc->meta.name)
808: return(1);
809: return(mdoc_err(mdoc, "macro `%s' has not been invoked with a name",
810: mdoc_macronames[MDOC_Nm]));
811: }
812:
813:
814: static int
1.36 kristaps 815: post_xr(struct mdoc *mdoc)
816: {
817: struct mdoc_node *n;
818:
819: assert(MDOC_ELEM == mdoc->last->type);
820: assert(MDOC_Xr == mdoc->last->tok);
821: assert(mdoc->last->child);
822: assert(MDOC_TEXT == mdoc->last->child->type);
823:
824: if (NULL == (n = mdoc->last->child->next))
825: return(1);
826: assert(MDOC_TEXT == n->type);
827: if (MSEC_DEFAULT != mdoc_atomsec(n->data.text.string))
828: return(1);
829: return(mdoc_nerr(mdoc, n, "invalid manual section"));
830: }
831:
832:
833: static int
834: post_at(struct mdoc *mdoc)
835: {
836:
837: assert(MDOC_ELEM == mdoc->last->type);
838: assert(MDOC_At == mdoc->last->tok);
1.37 kristaps 839:
840: if (NULL == mdoc->last->child)
841: return(1);
1.36 kristaps 842: assert(MDOC_TEXT == mdoc->last->child->type);
843:
844: if (ATT_DEFAULT != mdoc_atoatt(mdoc->last->child->data.text.string))
845: return(1);
846: return(mdoc_err(mdoc, "macro expects a valid AT&T version symbol"));
847: }
848:
849:
850: static int
1.35 kristaps 851: post_an(struct mdoc *mdoc)
852: {
853:
854: assert(MDOC_ELEM == mdoc->last->type);
855: assert(MDOC_An == mdoc->last->tok);
856:
857: if (0 != mdoc->last->data.elem.argc) {
858: if (NULL == mdoc->last->child)
859: return(1);
860: return(mdoc_err(mdoc, "macro expects either argument or parameters"));
861: }
862:
863: if (mdoc->last->child)
864: return(1);
865: return(mdoc_err(mdoc, "macro expects either argument or parameters"));
866: }
867:
868:
869: static int
870: post_ex(struct mdoc *mdoc)
871: {
872:
873: assert(MDOC_ELEM == mdoc->last->type);
874: assert(MDOC_Ex == mdoc->last->tok);
875:
876: if (0 == mdoc->last->data.elem.argc) {
877: if (mdoc->last->child)
878: return(1);
879: return(mdoc_err(mdoc, "macro expects `%s' or a single child",
880: mdoc_argnames[MDOC_Std]));
881: }
882: if (mdoc->last->child)
883: return(mdoc_err(mdoc, "macro expects `%s' or a single child",
884: mdoc_argnames[MDOC_Std]));
885: if (1 != mdoc->last->data.elem.argc)
886: return(mdoc_err(mdoc, "macro expects `%s' or a single child",
887: mdoc_argnames[MDOC_Std]));
888: if (MDOC_Std != mdoc->last->data.elem.argv[0].arg)
889: return(mdoc_err(mdoc, "macro expects `%s' or a single child",
890: mdoc_argnames[MDOC_Std]));
891: return(1);
892: }
893:
894:
1.25 kristaps 895: /* Warn if `Bl' type-specific syntax isn't reflected in items. */
896: static int
897: post_it(struct mdoc *mdoc)
898: {
899: int type, sv;
900: #define TYPE_NONE (0)
901: #define TYPE_BODY (1)
902: #define TYPE_HEAD (2)
903: size_t i, argc;
904: struct mdoc_node *n;
905:
906: if (MDOC_BLOCK != mdoc->last->type)
907: return(1);
908:
909: assert(MDOC_It == mdoc->last->tok);
910:
911: n = mdoc->last->parent;
912: assert(n);
913: assert(MDOC_Bl == n->tok);
914:
915: n = n->parent;
916: assert(MDOC_BLOCK == n->type);
917: assert(MDOC_Bl == n->tok);
918:
919: argc = n->data.block.argc;
920: type = TYPE_NONE;
1.38 kristaps 921: sv = -1;
1.26 kristaps 922:
923: /* Some types require block-head, some not. */
1.25 kristaps 924:
1.38 kristaps 925: /* LINTED */
1.25 kristaps 926: for (i = 0; TYPE_NONE == type && i < argc; i++)
927: switch (n->data.block.argv[(int)i].arg) {
928: case (MDOC_Tag):
929: /* FALLTHROUGH */
930: case (MDOC_Diag):
931: /* FALLTHROUGH */
932: case (MDOC_Hang):
933: /* FALLTHROUGH */
934: case (MDOC_Ohang):
935: /* FALLTHROUGH */
936: case (MDOC_Inset):
937: type = TYPE_HEAD;
938: sv = n->data.block.argv[(int)i].arg;
939: break;
940: case (MDOC_Bullet):
941: /* FALLTHROUGH */
942: case (MDOC_Dash):
943: /* FALLTHROUGH */
944: case (MDOC_Enum):
945: /* FALLTHROUGH */
946: case (MDOC_Hyphen):
947: /* FALLTHROUGH */
948: case (MDOC_Item):
949: /* FALLTHROUGH */
950: case (MDOC_Column):
951: type = TYPE_BODY;
952: sv = n->data.block.argv[(int)i].arg;
953: break;
954: default:
955: break;
956: }
957:
958: assert(TYPE_NONE != type);
959:
960: if (TYPE_HEAD == type) {
1.33 kristaps 961: n = mdoc->last->data.block.head;
962: assert(n);
963: if (NULL == n->child)
1.31 kristaps 964: if ( ! mdoc_warn(mdoc, WARN_SYNTAX, "macro suggests line parameters"))
1.25 kristaps 965: return(0);
966:
1.33 kristaps 967: n = mdoc->last->data.block.body;
968: assert(n);
969: if (NULL == n->child)
1.31 kristaps 970: if ( ! mdoc_warn(mdoc, WARN_SYNTAX, "macro suggests body children"))
1.25 kristaps 971: return(0);
972:
973: return(1);
974: }
975:
1.33 kristaps 976: assert(TYPE_BODY == type);
977: assert(mdoc->last->data.block.head);
978:
979: n = mdoc->last->data.block.head;
980: assert(n);
981: if (n->child)
982: if ( ! mdoc_warn(mdoc, WARN_SYNTAX, "macro suggests no line parameters"))
1.25 kristaps 983: return(0);
984:
1.33 kristaps 985: n = mdoc->last->data.block.body;
986: assert(n);
987: if (NULL == n->child)
1.31 kristaps 988: if ( ! mdoc_warn(mdoc, WARN_SYNTAX, "macro suggests body children"))
1.25 kristaps 989: return(0);
990:
1.38 kristaps 991: assert(-1 != sv);
1.26 kristaps 992: if (MDOC_Column != sv)
993: return(1);
994:
995: /* Make sure the number of columns is sane. */
996:
1.38 kristaps 997: argc = mdoc->last->parent->parent->data.block.argv->sz;
1.26 kristaps 998: n = mdoc->last->data.block.head->child;
1.25 kristaps 999:
1.26 kristaps 1000: for (i = 0; n; n = n->next)
1001: i++;
1002:
1.38 kristaps 1003: if (i == argc)
1.26 kristaps 1004: return(1);
1.38 kristaps 1005: return(mdoc_err(mdoc, "expected %zu list columns, have %zu", argc, i));
1.25 kristaps 1006: #undef TYPE_NONE
1007: #undef TYPE_BODY
1008: #undef TYPE_HEAD
1009: }
1010:
1011:
1.24 kristaps 1012: static int
1013: post_bl(struct mdoc *mdoc)
1014: {
1015: struct mdoc_node *n;
1016:
1017: if (MDOC_BODY != mdoc->last->type)
1018: return(1);
1.25 kristaps 1019: assert(MDOC_Bl == mdoc->last->tok);
1.24 kristaps 1020:
1.38 kristaps 1021: /* LINTED */
1.24 kristaps 1022: for (n = mdoc->last->child; n; n = n->next) {
1023: if (MDOC_BLOCK == n->type)
1.25 kristaps 1024: if (MDOC_It == n->tok)
1.24 kristaps 1025: continue;
1026: break;
1027: }
1028: if (NULL == n)
1029: return(1);
1.31 kristaps 1030: return(mdoc_nerr(mdoc, n, "invalid child of parent macro `Bl'"));
1.24 kristaps 1031: }
1032:
1033:
1.34 kristaps 1034: static int
1.37 kristaps 1035: ebool(struct mdoc *mdoc)
1.34 kristaps 1036: {
1037: struct mdoc_node *n;
1038:
1039: assert(MDOC_ELEM == mdoc->last->type);
1.38 kristaps 1040: /* LINTED */
1.34 kristaps 1041: for (n = mdoc->last->child; n; n = n->next) {
1042: if (MDOC_TEXT != n->type)
1043: break;
1044: if (xstrcmp(n->data.text.string, "on"))
1045: continue;
1046: if (xstrcmp(n->data.text.string, "off"))
1047: continue;
1048: break;
1049: }
1050: if (NULL == n)
1051: return(1);
1.37 kristaps 1052: return(mdoc_nerr(mdoc, n, "expected boolean value"));
1053: }
1054:
1055:
1056: static int
1057: post_root(struct mdoc *mdoc)
1058: {
1059:
1060: if (NULL == mdoc->last->child)
1061: return(mdoc_err(mdoc, "document has no data"));
1062: if (NULL == mdoc->meta.title)
1.39 kristaps 1063: return(mdoc_err(mdoc, "document has incomplete prologue"));
1.37 kristaps 1064: if (NULL == mdoc->meta.os)
1.39 kristaps 1065: return(mdoc_err(mdoc, "document has incomplete prologue"));
1.37 kristaps 1066: if (0 == mdoc->meta.date)
1.39 kristaps 1067: return(mdoc_err(mdoc, "document has incomplete prologue"));
1.37 kristaps 1068: return(1);
1.34 kristaps 1069: }
1070:
1071:
1.25 kristaps 1072: /* Warn if conventional sections are out of order. */
1.20 kristaps 1073: static int
1.21 kristaps 1074: post_sh(struct mdoc *mdoc)
1.14 kristaps 1075: {
1.36 kristaps 1076: char buf[64];
1.21 kristaps 1077: enum mdoc_sec sec;
1078:
1079: if (MDOC_HEAD != mdoc->last->type)
1080: return(1);
1.25 kristaps 1081: assert(MDOC_Sh == mdoc->last->tok);
1.21 kristaps 1082:
1.36 kristaps 1083: if ( ! xstrlcats(buf, mdoc->last->child, 64))
1084: return(mdoc_err(mdoc, "macro parameters too long"));
1.14 kristaps 1085:
1.36 kristaps 1086: if (SEC_CUSTOM == (sec = mdoc_atosec(buf)))
1.21 kristaps 1087: return(1);
1088: if (sec > mdoc->sec_lastn)
1089: return(1);
1090: if (sec == mdoc->sec_lastn)
1.31 kristaps 1091: return(mdoc_warn(mdoc, WARN_SYNTAX, "section repeated"));
1092: return(mdoc_warn(mdoc, WARN_SYNTAX, "section out of conventional order"));
1.11 kristaps 1093: }
1094:
1095:
1.17 kristaps 1096: int
1.18 kristaps 1097: mdoc_valid_pre(struct mdoc *mdoc, struct mdoc_node *node)
1.11 kristaps 1098: {
1.24 kristaps 1099: v_pre *p;
1.18 kristaps 1100:
1.25 kristaps 1101: if (MDOC_TEXT == node->type)
1.18 kristaps 1102: return(1);
1.25 kristaps 1103: assert(MDOC_ROOT != node->type);
1.11 kristaps 1104:
1.25 kristaps 1105: if (NULL == mdoc_valids[node->tok].pre)
1.11 kristaps 1106: return(1);
1.25 kristaps 1107: for (p = mdoc_valids[node->tok].pre; *p; p++)
1.24 kristaps 1108: if ( ! (*p)(mdoc, node))
1109: return(0);
1110: return(1);
1.11 kristaps 1111: }
1112:
1113:
1.17 kristaps 1114: int
1.18 kristaps 1115: mdoc_valid_post(struct mdoc *mdoc)
1.11 kristaps 1116: {
1.17 kristaps 1117: v_post *p;
1.11 kristaps 1118:
1.39 kristaps 1119: if (MDOC_VALID & mdoc->last->flags)
1120: return(1);
1121: mdoc->last->flags |= MDOC_VALID;
1122:
1.25 kristaps 1123: if (MDOC_TEXT == mdoc->last->type)
1124: return(1);
1.37 kristaps 1125: if (MDOC_ROOT == mdoc->last->type)
1126: return(post_root(mdoc));
1.14 kristaps 1127:
1.25 kristaps 1128: if (NULL == mdoc_valids[mdoc->last->tok].post)
1.9 kristaps 1129: return(1);
1.25 kristaps 1130: for (p = mdoc_valids[mdoc->last->tok].post; *p; p++)
1.18 kristaps 1131: if ( ! (*p)(mdoc))
1.17 kristaps 1132: return(0);
1.11 kristaps 1133:
1.14 kristaps 1134: return(1);
1.11 kristaps 1135: }
1.14 kristaps 1136:
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to validate.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [cvsweb.bsd.lv] / mandoc