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