]> git.cameronkatri.com Git - mandoc.git/blob - mdoc_macro.c
git.ckatri.com / mandoc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix in mandoc.1 and mandoc_char.7 syntax (submitted Joerg Sonnenberger).
[mandoc.git] / mdoc_macro.c
1 /* $Id: mdoc_macro.c,v 1.36 2009/09/20 17:24:57 kristaps Exp $ */
2 /*
3 * Copyright (c) 2008, 2009 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 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 #include <assert.h>
18 #include <ctype.h>
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <string.h>
22
23 #include "libmdoc.h"
24
25 #define REWIND_REWIND (1 << 0)
26 #define REWIND_NOHALT (1 << 1)
27 #define REWIND_HALT (1 << 2)
28
29 static int obsolete(MACRO_PROT_ARGS);
30 static int blk_part_exp(MACRO_PROT_ARGS);
31 static int in_line_eoln(MACRO_PROT_ARGS);
32 static int in_line_argn(MACRO_PROT_ARGS);
33 static int in_line(MACRO_PROT_ARGS);
34 static int blk_full(MACRO_PROT_ARGS);
35 static int blk_exp_close(MACRO_PROT_ARGS);
36 static int blk_part_imp(MACRO_PROT_ARGS);
37
38 static int phrase(struct mdoc *, int, int, char *);
39 static int rew_dohalt(int, enum mdoc_type,
40 const struct mdoc_node *);
41 static int rew_alt(int);
42 static int rew_dobreak(int, const struct mdoc_node *);
43 static int rew_elem(struct mdoc *, int);
44 static int rew_sub(enum mdoc_type, struct mdoc *,
45 int, int, int);
46 static int rew_last(struct mdoc *,
47 const struct mdoc_node *);
48 static int append_delims(struct mdoc *, int, int *, char *);
49 static int lookup(int, const char *);
50 static int lookup_raw(const char *);
51 static int swarn(struct mdoc *, enum mdoc_type, int, int,
52 const struct mdoc_node *);
53
54 /* Central table of library: who gets parsed how. */
55
56 const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
57 { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Ap */
58 { in_line_eoln, MDOC_PROLOGUE }, /* Dd */
59 { in_line_eoln, MDOC_PROLOGUE }, /* Dt */
60 { in_line_eoln, MDOC_PROLOGUE }, /* Os */
61 { blk_full, 0 }, /* Sh */
62 { blk_full, 0 }, /* Ss */
63 { in_line_eoln, 0 }, /* Pp */
64 { blk_part_imp, MDOC_PARSED }, /* D1 */
65 { blk_part_imp, MDOC_PARSED }, /* Dl */
66 { blk_full, MDOC_EXPLICIT }, /* Bd */
67 { blk_exp_close, MDOC_EXPLICIT }, /* Ed */
68 { blk_full, MDOC_EXPLICIT }, /* Bl */
69 { blk_exp_close, MDOC_EXPLICIT }, /* El */
70 { blk_full, MDOC_PARSED }, /* It */
71 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ad */
72 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* An */
73 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ar */
74 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Cd */
75 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Cm */
76 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Dv */
77 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Er */
78 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ev */
79 { in_line_eoln, 0 }, /* Ex */
80 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Fa */
81 { in_line_eoln, 0 }, /* Fd */
82 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Fl */
83 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Fn */
84 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ft */
85 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ic */
86 { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* In */
87 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Li */
88 { blk_full, 0 }, /* Nd */
89 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Nm */
90 { blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Op */
91 { obsolete, 0 }, /* Ot */
92 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Pa */
93 { in_line_eoln, 0 }, /* Rv */
94 { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* St */
95 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Va */
96 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Vt */
97 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Xr */
98 { in_line_eoln, 0 }, /* %A */
99 { in_line_eoln, 0 }, /* %B */
100 { in_line_eoln, 0 }, /* %D */
101 { in_line_eoln, 0 }, /* %I */
102 { in_line_eoln, 0 }, /* %J */
103 { in_line_eoln, 0 }, /* %N */
104 { in_line_eoln, 0 }, /* %O */
105 { in_line_eoln, 0 }, /* %P */
106 { in_line_eoln, 0 }, /* %R */
107 { in_line_eoln, 0 }, /* %T */
108 { in_line_eoln, 0 }, /* %V */
109 { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Ac */
110 { blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Ao */
111 { blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Aq */
112 { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* At */
113 { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Bc */
114 { blk_full, MDOC_EXPLICIT }, /* Bf */
115 { blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Bo */
116 { blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Bq */
117 { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Bsx */
118 { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Bx */
119 { in_line_eoln, 0 }, /* Db */
120 { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Dc */
121 { blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Do */
122 { blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Dq */
123 { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Ec */
124 { blk_exp_close, MDOC_EXPLICIT }, /* Ef */
125 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Em */
126 { blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Eo */
127 { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Fx */
128 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ms */
129 { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* No */
130 { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Ns */
131 { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Nx */
132 { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Ox */
133 { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Pc */
134 { in_line_argn, MDOC_PARSED | MDOC_IGNDELIM }, /* Pf */
135 { blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Po */
136 { blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Pq */
137 { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Qc */
138 { blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Ql */
139 { blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Qo */
140 { blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Qq */
141 { blk_exp_close, MDOC_EXPLICIT }, /* Re */
142 { blk_full, MDOC_EXPLICIT }, /* Rs */
143 { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Sc */
144 { blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* So */
145 { blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Sq */
146 { in_line_eoln, 0 }, /* Sm */
147 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Sx */
148 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Sy */
149 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Tn */
150 { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Ux */
151 { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Xc */
152 { blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Xo */
153 { blk_full, MDOC_EXPLICIT | MDOC_CALLABLE }, /* Fo */
154 { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Fc */
155 { blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Oo */
156 { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Oc */
157 { blk_full, MDOC_EXPLICIT }, /* Bk */
158 { blk_exp_close, MDOC_EXPLICIT }, /* Ek */
159 { in_line_eoln, 0 }, /* Bt */
160 { in_line_eoln, 0 }, /* Hf */
161 { obsolete, 0 }, /* Fr */
162 { in_line_eoln, 0 }, /* Ud */
163 { in_line_eoln, 0 }, /* Lb */
164 { in_line_eoln, 0 }, /* Lp */
165 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Lk */
166 { in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Mt */
167 { blk_part_imp, MDOC_CALLABLE | MDOC_PARSED }, /* Brq */
168 { blk_part_exp, MDOC_CALLABLE | MDOC_PARSED | MDOC_EXPLICIT }, /* Bro */
169 { blk_exp_close, MDOC_EXPLICIT | MDOC_CALLABLE | MDOC_PARSED }, /* Brc */
170 { in_line_eoln, 0 }, /* %C */
171 { obsolete, 0 }, /* Es */
172 { obsolete, 0 }, /* En */
173 { in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Dx */
174 { in_line_eoln, 0 }, /* %Q */
175 { in_line_eoln, 0 }, /* br */
176 { in_line_eoln, 0 }, /* sp */
177 };
178
179 const struct mdoc_macro * const mdoc_macros = __mdoc_macros;
180
181
182 static int
183 swarn(struct mdoc *mdoc, enum mdoc_type type,
184 int line, int pos, const struct mdoc_node *p)
185 {
186 const char *n, *t, *tt;
187
188 n = t = "<root>";
189 tt = "block";
190
191 switch (type) {
192 case (MDOC_BODY):
193 tt = "multi-line";
194 break;
195 case (MDOC_HEAD):
196 tt = "line";
197 break;
198 default:
199 break;
200 }
201
202 switch (p->type) {
203 case (MDOC_BLOCK):
204 n = mdoc_macronames[p->tok];
205 t = "block";
206 break;
207 case (MDOC_BODY):
208 n = mdoc_macronames[p->tok];
209 t = "multi-line";
210 break;
211 case (MDOC_HEAD):
212 n = mdoc_macronames[p->tok];
213 t = "line";
214 break;
215 default:
216 break;
217 }
218
219 if ( ! (MDOC_IGN_SCOPE & mdoc->pflags))
220 return(mdoc_verr(mdoc, line, pos,
221 "%s scope breaks %s scope of %s",
222 tt, t, n));
223 return(mdoc_vwarn(mdoc, line, pos,
224 "%s scope breaks %s scope of %s",
225 tt, t, n));
226 }
227
228
229 /*
230 * This is called at the end of parsing. It must traverse up the tree,
231 * closing out open [implicit] scopes. Obviously, open explicit scopes
232 * are errors.
233 */
234 int
235 mdoc_macroend(struct mdoc *m)
236 {
237 struct mdoc_node *n;
238
239 /* Scan for open explicit scopes. */
240
241 n = MDOC_VALID & m->last->flags ? m->last->parent : m->last;
242
243 for ( ; n; n = n->parent) {
244 if (MDOC_BLOCK != n->type)
245 continue;
246 if ( ! (MDOC_EXPLICIT & mdoc_macros[n->tok].flags))
247 continue;
248 return(mdoc_nerr(m, n, EOPEN));
249 }
250
251 /* Rewind to the first. */
252
253 return(rew_last(m, m->first));
254 }
255
256
257 /*
258 * Look up a macro from within a subsequent context.
259 */
260 static int
261 lookup(int from, const char *p)
262 {
263 /* FIXME: make -diag lists be un-PARSED. */
264
265 if ( ! (MDOC_PARSED & mdoc_macros[from].flags))
266 return(MDOC_MAX);
267 return(lookup_raw(p));
268 }
269
270
271 /*
272 * Lookup a macro following the initial line macro.
273 */
274 static int
275 lookup_raw(const char *p)
276 {
277 int res;
278
279 if (MDOC_MAX == (res = mdoc_hash_find(p)))
280 return(MDOC_MAX);
281 if (MDOC_CALLABLE & mdoc_macros[res].flags)
282 return(res);
283 return(MDOC_MAX);
284 }
285
286
287 static int
288 rew_last(struct mdoc *mdoc, const struct mdoc_node *to)
289 {
290
291 assert(to);
292 mdoc->next = MDOC_NEXT_SIBLING;
293
294 /* LINTED */
295 while (mdoc->last != to) {
296 if ( ! mdoc_valid_post(mdoc))
297 return(0);
298 if ( ! mdoc_action_post(mdoc))
299 return(0);
300 mdoc->last = mdoc->last->parent;
301 assert(mdoc->last);
302 }
303
304 if ( ! mdoc_valid_post(mdoc))
305 return(0);
306 return(mdoc_action_post(mdoc));
307 }
308
309
310 /*
311 * Return the opening macro of a closing one, e.g., `Ec' has `Eo' as its
312 * matching pair.
313 */
314 static int
315 rew_alt(int tok)
316 {
317 switch (tok) {
318 case (MDOC_Ac):
319 return(MDOC_Ao);
320 case (MDOC_Bc):
321 return(MDOC_Bo);
322 case (MDOC_Brc):
323 return(MDOC_Bro);
324 case (MDOC_Dc):
325 return(MDOC_Do);
326 case (MDOC_Ec):
327 return(MDOC_Eo);
328 case (MDOC_Ed):
329 return(MDOC_Bd);
330 case (MDOC_Ef):
331 return(MDOC_Bf);
332 case (MDOC_Ek):
333 return(MDOC_Bk);
334 case (MDOC_El):
335 return(MDOC_Bl);
336 case (MDOC_Fc):
337 return(MDOC_Fo);
338 case (MDOC_Oc):
339 return(MDOC_Oo);
340 case (MDOC_Pc):
341 return(MDOC_Po);
342 case (MDOC_Qc):
343 return(MDOC_Qo);
344 case (MDOC_Re):
345 return(MDOC_Rs);
346 case (MDOC_Sc):
347 return(MDOC_So);
348 case (MDOC_Xc):
349 return(MDOC_Xo);
350 default:
351 break;
352 }
353 abort();
354 /* NOTREACHED */
355 }
356
357
358 /*
359 * Rewind rules. This indicates whether to stop rewinding
360 * (REWIND_HALT) without touching our current scope, stop rewinding and
361 * close our current scope (REWIND_REWIND), or continue (REWIND_NOHALT).
362 * The scope-closing and so on occurs in the various rew_* routines.
363 */
364 static int
365 rew_dohalt(int tok, enum mdoc_type type, const struct mdoc_node *p)
366 {
367
368 if (MDOC_ROOT == p->type)
369 return(REWIND_HALT);
370 if (MDOC_VALID & p->flags)
371 return(REWIND_NOHALT);
372
373 switch (tok) {
374 case (MDOC_Aq):
375 /* FALLTHROUGH */
376 case (MDOC_Bq):
377 /* FALLTHROUGH */
378 case (MDOC_Brq):
379 /* FALLTHROUGH */
380 case (MDOC_D1):
381 /* FALLTHROUGH */
382 case (MDOC_Dl):
383 /* FALLTHROUGH */
384 case (MDOC_Dq):
385 /* FALLTHROUGH */
386 case (MDOC_Op):
387 /* FALLTHROUGH */
388 case (MDOC_Pq):
389 /* FALLTHROUGH */
390 case (MDOC_Ql):
391 /* FALLTHROUGH */
392 case (MDOC_Qq):
393 /* FALLTHROUGH */
394 case (MDOC_Sq):
395 assert(MDOC_TAIL != type);
396 if (type == p->type && tok == p->tok)
397 return(REWIND_REWIND);
398 break;
399 case (MDOC_It):
400 assert(MDOC_TAIL != type);
401 if (type == p->type && tok == p->tok)
402 return(REWIND_REWIND);
403 if (MDOC_BODY == p->type && MDOC_Bl == p->tok)
404 return(REWIND_HALT);
405 break;
406 case (MDOC_Sh):
407 if (type == p->type && tok == p->tok)
408 return(REWIND_REWIND);
409 break;
410 case (MDOC_Nd):
411 /* FALLTHROUGH */
412 case (MDOC_Ss):
413 assert(MDOC_TAIL != type);
414 if (type == p->type && tok == p->tok)
415 return(REWIND_REWIND);
416 if (MDOC_BODY == p->type && MDOC_Sh == p->tok)
417 return(REWIND_HALT);
418 break;
419 case (MDOC_Ao):
420 /* FALLTHROUGH */
421 case (MDOC_Bd):
422 /* FALLTHROUGH */
423 case (MDOC_Bf):
424 /* FALLTHROUGH */
425 case (MDOC_Bk):
426 /* FALLTHROUGH */
427 case (MDOC_Bl):
428 /* FALLTHROUGH */
429 case (MDOC_Bo):
430 /* FALLTHROUGH */
431 case (MDOC_Bro):
432 /* FALLTHROUGH */
433 case (MDOC_Do):
434 /* FALLTHROUGH */
435 case (MDOC_Eo):
436 /* FALLTHROUGH */
437 case (MDOC_Fo):
438 /* FALLTHROUGH */
439 case (MDOC_Oo):
440 /* FALLTHROUGH */
441 case (MDOC_Po):
442 /* FALLTHROUGH */
443 case (MDOC_Qo):
444 /* FALLTHROUGH */
445 case (MDOC_Rs):
446 /* FALLTHROUGH */
447 case (MDOC_So):
448 /* FALLTHROUGH */
449 case (MDOC_Xo):
450 if (type == p->type && tok == p->tok)
451 return(REWIND_REWIND);
452 break;
453 /* Multi-line explicit scope close. */
454 case (MDOC_Ac):
455 /* FALLTHROUGH */
456 case (MDOC_Bc):
457 /* FALLTHROUGH */
458 case (MDOC_Brc):
459 /* FALLTHROUGH */
460 case (MDOC_Dc):
461 /* FALLTHROUGH */
462 case (MDOC_Ec):
463 /* FALLTHROUGH */
464 case (MDOC_Ed):
465 /* FALLTHROUGH */
466 case (MDOC_Ek):
467 /* FALLTHROUGH */
468 case (MDOC_El):
469 /* FALLTHROUGH */
470 case (MDOC_Fc):
471 /* FALLTHROUGH */
472 case (MDOC_Ef):
473 /* FALLTHROUGH */
474 case (MDOC_Oc):
475 /* FALLTHROUGH */
476 case (MDOC_Pc):
477 /* FALLTHROUGH */
478 case (MDOC_Qc):
479 /* FALLTHROUGH */
480 case (MDOC_Re):
481 /* FALLTHROUGH */
482 case (MDOC_Sc):
483 /* FALLTHROUGH */
484 case (MDOC_Xc):
485 if (type == p->type && rew_alt(tok) == p->tok)
486 return(REWIND_REWIND);
487 break;
488 default:
489 abort();
490 /* NOTREACHED */
491 }
492
493 return(REWIND_NOHALT);
494 }
495
496
497 /*
498 * See if we can break an encountered scope (the rew_dohalt has returned
499 * REWIND_NOHALT).
500 */
501 static int
502 rew_dobreak(int tok, const struct mdoc_node *p)
503 {
504
505 assert(MDOC_ROOT != p->type);
506 if (MDOC_ELEM == p->type)
507 return(1);
508 if (MDOC_TEXT == p->type)
509 return(1);
510 if (MDOC_VALID & p->flags)
511 return(1);
512
513 switch (tok) {
514 case (MDOC_It):
515 return(MDOC_It == p->tok);
516 case (MDOC_Nd):
517 return(MDOC_Nd == p->tok);
518 case (MDOC_Ss):
519 return(MDOC_Ss == p->tok);
520 case (MDOC_Sh):
521 if (MDOC_Nd == p->tok)
522 return(1);
523 if (MDOC_Ss == p->tok)
524 return(1);
525 return(MDOC_Sh == p->tok);
526 case (MDOC_El):
527 if (MDOC_It == p->tok)
528 return(1);
529 break;
530 case (MDOC_Oc):
531 /* XXX - experimental! */
532 if (MDOC_Op == p->tok)
533 return(1);
534 break;
535 default:
536 break;
537 }
538
539 if (MDOC_EXPLICIT & mdoc_macros[tok].flags)
540 return(p->tok == rew_alt(tok));
541 else if (MDOC_BLOCK == p->type)
542 return(1);
543
544 return(tok == p->tok);
545 }
546
547
548 static int
549 rew_elem(struct mdoc *mdoc, int tok)
550 {
551 struct mdoc_node *n;
552
553 n = mdoc->last;
554 if (MDOC_ELEM != n->type)
555 n = n->parent;
556 assert(MDOC_ELEM == n->type);
557 assert(tok == n->tok);
558
559 return(rew_last(mdoc, n));
560 }
561
562
563 static int
564 rew_sub(enum mdoc_type t, struct mdoc *m,
565 int tok, int line, int ppos)
566 {
567 struct mdoc_node *n;
568 int c;
569
570 /* LINTED */
571 for (n = m->last; n; n = n->parent) {
572 c = rew_dohalt(tok, t, n);
573 if (REWIND_HALT == c) {
574 if (MDOC_BLOCK != t)
575 return(1);
576 if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags))
577 return(1);
578 return(mdoc_perr(m, line, ppos, ENOCTX));
579 }
580 if (REWIND_REWIND == c)
581 break;
582 else if (rew_dobreak(tok, n))
583 continue;
584 if ( ! swarn(m, t, line, ppos, n))
585 return(0);
586 }
587
588 assert(n);
589 return(rew_last(m, n));
590 }
591
592
593 static int
594 append_delims(struct mdoc *mdoc, int line, int *pos, char *buf)
595 {
596 int c, lastarg;
597 char *p;
598
599 if (0 == buf[*pos])
600 return(1);
601
602 for (;;) {
603 lastarg = *pos;
604 c = mdoc_zargs(mdoc, line, pos, buf, ARGS_NOWARN, &p);
605 assert(ARGS_PHRASE != c);
606
607 if (ARGS_ERROR == c)
608 return(0);
609 else if (ARGS_EOLN == c)
610 break;
611 assert(mdoc_isdelim(p));
612 if ( ! mdoc_word_alloc(mdoc, line, lastarg, p))
613 return(0);
614 }
615
616 return(1);
617 }
618
619
620 /*
621 * Close out block partial/full explicit.
622 */
623 static int
624 blk_exp_close(MACRO_PROT_ARGS)
625 {
626 int j, c, lastarg, maxargs, flushed;
627 char *p;
628
629 switch (tok) {
630 case (MDOC_Ec):
631 maxargs = 1;
632 break;
633 default:
634 maxargs = 0;
635 break;
636 }
637
638 if ( ! (MDOC_CALLABLE & mdoc_macros[tok].flags)) {
639 if (buf[*pos])
640 if ( ! mdoc_pwarn(m, line, ppos, ENOLINE))
641 return(0);
642
643 if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))
644 return(0);
645 return(rew_sub(MDOC_BLOCK, m, tok, line, ppos));
646 }
647
648 if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))
649 return(0);
650
651 if (maxargs > 0)
652 if ( ! mdoc_tail_alloc(m, line, ppos, rew_alt(tok)))
653 return(0);
654
655 for (flushed = j = 0; ; j++) {
656 lastarg = *pos;
657
658 if (j == maxargs && ! flushed) {
659 if ( ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
660 return(0);
661 flushed = 1;
662 }
663
664 c = mdoc_args(m, line, pos, buf, tok, &p);
665
666 if (ARGS_ERROR == c)
667 return(0);
668 if (ARGS_PUNCT == c)
669 break;
670 if (ARGS_EOLN == c)
671 break;
672
673 if (MDOC_MAX != (c = lookup(tok, p))) {
674 if ( ! flushed) {
675 if ( ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
676 return(0);
677 flushed = 1;
678 }
679 if ( ! mdoc_macro(m, c, line, lastarg, pos, buf))
680 return(0);
681 break;
682 }
683
684 if ( ! mdoc_word_alloc(m, line, lastarg, p))
685 return(0);
686 }
687
688 if ( ! flushed && ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
689 return(0);
690
691 if (ppos > 1)
692 return(1);
693 return(append_delims(m, line, pos, buf));
694 }
695
696
697 static int
698 in_line(MACRO_PROT_ARGS)
699 {
700 int la, lastpunct, c, w, cnt, d, nc;
701 struct mdoc_arg *arg;
702 char *p;
703
704 /*
705 * Whether we allow ignored elements (those without content,
706 * usually because of reserved words) to squeak by.
707 */
708 switch (tok) {
709 case (MDOC_An):
710 /* FALLTHROUGH */
711 case (MDOC_Ar):
712 /* FALLTHROUGH */
713 case (MDOC_Fl):
714 /* FALLTHROUGH */
715 case (MDOC_Lk):
716 /* FALLTHROUGH */
717 case (MDOC_Nm):
718 /* FALLTHROUGH */
719 case (MDOC_Pa):
720 nc = 1;
721 break;
722 default:
723 nc = 0;
724 break;
725 }
726
727 for (arg = NULL;; ) {
728 la = *pos;
729 c = mdoc_argv(m, line, tok, &arg, pos, buf);
730
731 if (ARGV_WORD == c) {
732 *pos = la;
733 break;
734 }
735 if (ARGV_EOLN == c)
736 break;
737 if (ARGV_ARG == c)
738 continue;
739
740 mdoc_argv_free(arg);
741 return(0);
742 }
743
744 for (cnt = 0, lastpunct = 1;; ) {
745 la = *pos;
746 w = mdoc_args(m, line, pos, buf, tok, &p);
747
748 if (ARGS_ERROR == w)
749 return(0);
750 if (ARGS_EOLN == w)
751 break;
752 if (ARGS_PUNCT == w)
753 break;
754
755 /* Quoted words shouldn't be looked-up. */
756
757 c = ARGS_QWORD == w ? MDOC_MAX : lookup(tok, p);
758
759 /*
760 * In this case, we've located a submacro and must
761 * execute it. Close out scope, if open. If no
762 * elements have been generated, either create one (nc)
763 * or raise a warning.
764 */
765
766 if (MDOC_MAX != c) {
767 if (0 == lastpunct && ! rew_elem(m, tok))
768 return(0);
769 if (nc && 0 == cnt) {
770 if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
771 return(0);
772 if ( ! rew_last(m, m->last))
773 return(0);
774 } else if ( ! nc && 0 == cnt) {
775 mdoc_argv_free(arg);
776 if ( ! mdoc_pwarn(m, line, ppos, EIGNE))
777 return(0);
778 }
779 c = mdoc_macro(m, c, line, la, pos, buf);
780 if (0 == c)
781 return(0);
782 if (ppos > 1)
783 return(1);
784 return(append_delims(m, line, pos, buf));
785 }
786
787 /*
788 * Non-quote-enclosed punctuation. Set up our scope, if
789 * a word; rewind the scope, if a delimiter; then append
790 * the word.
791 */
792
793 d = mdoc_isdelim(p);
794
795 if (ARGS_QWORD != w && d) {
796 if (0 == lastpunct && ! rew_elem(m, tok))
797 return(0);
798 lastpunct = 1;
799 } else if (lastpunct) {
800 if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
801 return(0);
802 lastpunct = 0;
803 }
804
805 if ( ! d)
806 cnt++;
807 if ( ! mdoc_word_alloc(m, line, la, p))
808 return(0);
809 }
810
811 if (0 == lastpunct && ! rew_elem(m, tok))
812 return(0);
813
814 /*
815 * If no elements have been collected and we're allowed to have
816 * empties (nc), open a scope and close it out. Otherwise,
817 * raise a warning.
818 *
819 */
820 if (nc && 0 == cnt) {
821 if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
822 return(0);
823 if ( ! rew_last(m, m->last))
824 return(0);
825 } else if ( ! nc && 0 == cnt) {
826 mdoc_argv_free(arg);
827 if ( ! mdoc_pwarn(m, line, ppos, EIGNE))
828 return(0);
829 }
830
831 if (ppos > 1)
832 return(1);
833 return(append_delims(m, line, pos, buf));
834 }
835
836
837 static int
838 blk_full(MACRO_PROT_ARGS)
839 {
840 int c, lastarg, reopen, dohead;
841 struct mdoc_arg *arg;
842 char *p;
843
844 /*
845 * Whether to process a block-head section. If this is
846 * non-zero, then a head will be opened for all line arguments.
847 * If not, then the head will always be empty and only a body
848 * will be opened, which will stay open at the eoln.
849 */
850
851 switch (tok) {
852 case (MDOC_Nd):
853 dohead = 0;
854 break;
855 default:
856 dohead = 1;
857 break;
858 }
859
860 if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags)) {
861 if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))
862 return(0);
863 if ( ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))
864 return(0);
865 }
866
867 for (arg = NULL;; ) {
868 lastarg = *pos;
869 c = mdoc_argv(m, line, tok, &arg, pos, buf);
870
871 if (ARGV_WORD == c) {
872 *pos = lastarg;
873 break;
874 }
875
876 if (ARGV_EOLN == c)
877 break;
878 if (ARGV_ARG == c)
879 continue;
880
881 mdoc_argv_free(arg);
882 return(0);
883 }
884
885 if ( ! mdoc_block_alloc(m, line, ppos, tok, arg))
886 return(0);
887
888 if (0 == buf[*pos]) {
889 if ( ! mdoc_head_alloc(m, line, ppos, tok))
890 return(0);
891 if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
892 return(0);
893 if ( ! mdoc_body_alloc(m, line, ppos, tok))
894 return(0);
895 return(1);
896 }
897
898 if ( ! mdoc_head_alloc(m, line, ppos, tok))
899 return(0);
900
901 /* Immediately close out head and enter body, if applicable. */
902
903 if (0 == dohead) {
904 if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
905 return(0);
906 if ( ! mdoc_body_alloc(m, line, ppos, tok))
907 return(0);
908 }
909
910 for (reopen = 0;; ) {
911 lastarg = *pos;
912 c = mdoc_args(m, line, pos, buf, tok, &p);
913
914 if (ARGS_ERROR == c)
915 return(0);
916 if (ARGS_EOLN == c)
917 break;
918 if (ARGS_PHRASE == c) {
919 assert(dohead);
920 if (reopen && ! mdoc_head_alloc(m, line, ppos, tok))
921 return(0);
922 /*
923 * Phrases are self-contained macro phrases used
924 * in the columnar output of a macro. They need
925 * special handling.
926 */
927 if ( ! phrase(m, line, lastarg, buf))
928 return(0);
929 if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
930 return(0);
931
932 reopen = 1;
933 continue;
934 }
935
936 if (MDOC_MAX == (c = lookup(tok, p))) {
937 if ( ! mdoc_word_alloc(m, line, lastarg, p))
938 return(0);
939 continue;
940 }
941
942 if ( ! mdoc_macro(m, c, line, lastarg, pos, buf))
943 return(0);
944 break;
945 }
946
947 if (1 == ppos && ! append_delims(m, line, pos, buf))
948 return(0);
949
950 /* If the body's already open, then just return. */
951 if (0 == dohead)
952 return(1);
953
954 if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
955 return(0);
956 if ( ! mdoc_body_alloc(m, line, ppos, tok))
957 return(0);
958
959 return(1);
960 }
961
962
963 static int
964 blk_part_imp(MACRO_PROT_ARGS)
965 {
966 int la, c;
967 char *p;
968 struct mdoc_node *blk, *body, *n;
969
970 /* If applicable, close out prior scopes. */
971
972 if ( ! mdoc_block_alloc(m, line, ppos, tok, NULL))
973 return(0);
974 /* Saved for later close-out. */
975 blk = m->last;
976 if ( ! mdoc_head_alloc(m, line, ppos, tok))
977 return(0);
978 if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
979 return(0);
980 if ( ! mdoc_body_alloc(m, line, ppos, tok))
981 return(0);
982 /* Saved for later close-out. */
983 body = m->last;
984
985 /* Body argument processing. */
986
987 for (;;) {
988 la = *pos;
989 c = mdoc_args(m, line, pos, buf, tok, &p);
990 assert(ARGS_PHRASE != c);
991
992 if (ARGS_ERROR == c)
993 return(0);
994 if (ARGS_PUNCT == c)
995 break;
996 if (ARGS_EOLN == c)
997 break;
998
999 if (MDOC_MAX == (c = lookup(tok, p))) {
1000 if ( ! mdoc_word_alloc(m, line, la, p))
1001 return(0);
1002 continue;
1003 }
1004
1005 if ( ! mdoc_macro(m, c, line, la, pos, buf))
1006 return(0);
1007 break;
1008 }
1009
1010 /*
1011 * If we can't rewind to our body, then our scope has already
1012 * been closed by another macro (like `Oc' closing `Op'). This
1013 * is ugly behaviour nodding its head to OpenBSD's overwhelming
1014 * crufty use of `Op' breakage--XXX, deprecate in time.
1015 */
1016 for (n = m->last; n; n = n->parent)
1017 if (body == n)
1018 break;
1019 if (NULL == n && ! mdoc_nwarn(m, body, EIMPBRK))
1020 return(0);
1021 if (n && ! rew_last(m, body))
1022 return(0);
1023
1024 /* Standard appending of delimiters. */
1025
1026 if (1 == ppos && ! append_delims(m, line, pos, buf))
1027 return(0);
1028
1029 /* Rewind scope, if applicable. */
1030
1031 if (n && ! rew_last(m, blk))
1032 return(0);
1033
1034 return(1);
1035 }
1036
1037
1038 static int
1039 blk_part_exp(MACRO_PROT_ARGS)
1040 {
1041 int la, flushed, j, c, maxargs;
1042 char *p;
1043
1044 /* Number of head arguments. Only `Eo' has these, */
1045
1046 switch (tok) {
1047 case (MDOC_Eo):
1048 maxargs = 1;
1049 break;
1050 default:
1051 maxargs = 0;
1052 break;
1053 }
1054
1055 /* Begin the block scope. */
1056
1057 if ( ! mdoc_block_alloc(m, line, ppos, tok, NULL))
1058 return(0);
1059
1060 /*
1061 * If no head arguments, open and then close out a head, noting
1062 * that we've flushed our terms. `flushed' means that we've
1063 * flushed out the head and the body is open.
1064 */
1065
1066 if (0 == maxargs) {
1067 if ( ! mdoc_head_alloc(m, line, ppos, tok))
1068 return(0);
1069 if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
1070 return(0);
1071 if ( ! mdoc_body_alloc(m, line, ppos, tok))
1072 return(0);
1073 flushed = 1;
1074 } else {
1075 if ( ! mdoc_head_alloc(m, line, ppos, tok))
1076 return(0);
1077 flushed = 0;
1078 }
1079
1080 /* Process the head/head+body line arguments. */
1081
1082 for (j = 0; ; j++) {
1083 la = *pos;
1084 if (j == maxargs && ! flushed) {
1085 if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
1086 return(0);
1087 flushed = 1;
1088 if ( ! mdoc_body_alloc(m, line, ppos, tok))
1089 return(0);
1090 }
1091
1092 c = mdoc_args(m, line, pos, buf, tok, &p);
1093 assert(ARGS_PHRASE != c);
1094
1095 if (ARGS_ERROR == c)
1096 return(0);
1097 if (ARGS_PUNCT == c)
1098 break;
1099 if (ARGS_EOLN == c)
1100 break;
1101
1102 if (MDOC_MAX != (c = lookup(tok, p))) {
1103 if ( ! flushed) {
1104 if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
1105 return(0);
1106 flushed = 1;
1107 if ( ! mdoc_body_alloc(m, line, ppos, tok))
1108 return(0);
1109 }
1110 if ( ! mdoc_macro(m, c, line, la, pos, buf))
1111 return(0);
1112 break;
1113 }
1114
1115 if ( ! flushed && mdoc_isdelim(p)) {
1116 if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
1117 return(0);
1118 flushed = 1;
1119 if ( ! mdoc_body_alloc(m, line, ppos, tok))
1120 return(0);
1121 }
1122
1123 if ( ! mdoc_word_alloc(m, line, la, p))
1124 return(0);
1125 }
1126
1127 /* Close the head and open the body, if applicable. */
1128
1129 if ( ! flushed) {
1130 if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))
1131 return(0);
1132 if ( ! mdoc_body_alloc(m, line, ppos, tok))
1133 return(0);
1134 }
1135
1136 /* Standard appending of delimiters. */
1137
1138 if (ppos > 1)
1139 return(1);
1140 return(append_delims(m, line, pos, buf));
1141 }
1142
1143
1144 static int
1145 in_line_argn(MACRO_PROT_ARGS)
1146 {
1147 int la, flushed, j, c, maxargs;
1148 struct mdoc_arg *arg;
1149 char *p;
1150
1151 /* Fixed maximum arguments per macro, if applicable. */
1152
1153 switch (tok) {
1154 case (MDOC_Ap):
1155 /* FALLTHROUGH */
1156 case (MDOC_No):
1157 /* FALLTHROUGH */
1158 case (MDOC_Ns):
1159 /* FALLTHROUGH */
1160 case (MDOC_Ux):
1161 maxargs = 0;
1162 break;
1163 default:
1164 maxargs = 1;
1165 break;
1166 }
1167
1168 /* Macro argument processing. */
1169
1170 for (arg = NULL;; ) {
1171 la = *pos;
1172 c = mdoc_argv(m, line, tok, &arg, pos, buf);
1173
1174 if (ARGV_WORD == c) {
1175 *pos = la;
1176 break;
1177 }
1178
1179 if (ARGV_EOLN == c)
1180 break;
1181 if (ARGV_ARG == c)
1182 continue;
1183
1184 mdoc_argv_free(arg);
1185 return(0);
1186 }
1187
1188 /* Open the element scope. */
1189
1190 if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
1191 return(0);
1192
1193 /* Process element arguments. */
1194
1195 for (flushed = j = 0; ; j++) {
1196 la = *pos;
1197
1198 if (j == maxargs && ! flushed) {
1199 if ( ! rew_elem(m, tok))
1200 return(0);
1201 flushed = 1;
1202 }
1203
1204 c = mdoc_args(m, line, pos, buf, tok, &p);
1205
1206 if (ARGS_ERROR == c)
1207 return(0);
1208 if (ARGS_PUNCT == c)
1209 break;
1210 if (ARGS_EOLN == c)
1211 break;
1212
1213 if (MDOC_MAX != (c = lookup(tok, p))) {
1214 if ( ! flushed && ! rew_elem(m, tok))
1215 return(0);
1216 flushed = 1;
1217 if ( ! mdoc_macro(m, c, line, la, pos, buf))
1218 return(0);
1219 break;
1220 }
1221
1222 if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) &&
1223 ! flushed && mdoc_isdelim(p)) {
1224 if ( ! rew_elem(m, tok))
1225 return(0);
1226 flushed = 1;
1227 }
1228
1229 if ( ! mdoc_word_alloc(m, line, la, p))
1230 return(0);
1231 }
1232
1233 /* Close out and append delimiters. */
1234
1235 if ( ! flushed && ! rew_elem(m, tok))
1236 return(0);
1237
1238 if (ppos > 1)
1239 return(1);
1240 return(append_delims(m, line, pos, buf));
1241 }
1242
1243
1244 static int
1245 in_line_eoln(MACRO_PROT_ARGS)
1246 {
1247 int c, w, la;
1248 struct mdoc_arg *arg;
1249 char *p;
1250
1251 assert( ! (MDOC_PARSED & mdoc_macros[tok].flags));
1252
1253 /* Parse macro arguments. */
1254
1255 for (arg = NULL; ; ) {
1256 la = *pos;
1257 c = mdoc_argv(m, line, tok, &arg, pos, buf);
1258
1259 if (ARGV_WORD == c) {
1260 *pos = la;
1261 break;
1262 }
1263 if (ARGV_EOLN == c)
1264 break;
1265 if (ARGV_ARG == c)
1266 continue;
1267
1268 mdoc_argv_free(arg);
1269 return(0);
1270 }
1271
1272 /* Open element scope. */
1273
1274 if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))
1275 return(0);
1276
1277 /* Parse argument terms. */
1278
1279 for (;;) {
1280 la = *pos;
1281 w = mdoc_args(m, line, pos, buf, tok, &p);
1282
1283 if (ARGS_ERROR == w)
1284 return(0);
1285 if (ARGS_EOLN == w)
1286 break;
1287
1288 c = ARGS_QWORD == w ? MDOC_MAX : lookup(tok, p);
1289
1290 if (MDOC_MAX != c) {
1291 if ( ! rew_elem(m, tok))
1292 return(0);
1293 return(mdoc_macro(m, c, line, la, pos, buf));
1294 }
1295
1296 if ( ! mdoc_word_alloc(m, line, la, p))
1297 return(0);
1298 }
1299
1300 /* Close out (no delimiters). */
1301
1302 return(rew_elem(m, tok));
1303 }
1304
1305
1306 /* ARGSUSED */
1307 static int
1308 obsolete(MACRO_PROT_ARGS)
1309 {
1310
1311 return(mdoc_pwarn(m, line, ppos, EOBS));
1312 }
1313
1314
1315 /*
1316 * Phrases occur within `Bl -column' entries, separated by `Ta' or tabs.
1317 * They're unusual because they're basically free-form text until a
1318 * macro is encountered.
1319 */
1320 static int
1321 phrase(struct mdoc *m, int line, int ppos, char *buf)
1322 {
1323 int c, w, la, pos;
1324 char *p;
1325
1326 for (pos = ppos; ; ) {
1327 la = pos;
1328
1329 /* Note: no calling context! */
1330 w = mdoc_zargs(m, line, &pos, buf, 0, &p);
1331
1332 if (ARGS_ERROR == w)
1333 return(0);
1334 if (ARGS_EOLN == w)
1335 break;
1336
1337 c = ARGS_QWORD == w ? MDOC_MAX : lookup_raw(p);
1338
1339 if (MDOC_MAX != c) {
1340 if ( ! mdoc_macro(m, c, line, la, &pos, buf))
1341 return(0);
1342 return(append_delims(m, line, &pos, buf));
1343 }
1344
1345 if ( ! mdoc_word_alloc(m, line, la, p))
1346 return(0);
1347 }
1348
1349 return(1);
1350 }
1351
1352
A git conversion mirror of mandoc.bsd.lv