Print this page
Update to 1.12.3.
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/mandoc/man.c
+++ new/usr/src/cmd/mandoc/man.c
1 -/* $Id: man.c,v 1.115 2012/01/03 15:16:24 kristaps Exp $ */
1 +/* $Id: man.c,v 1.121 2013/11/10 22:54:40 schwarze Exp $ */
2 2 /*
3 3 * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
4 4 *
5 5 * Permission to use, copy, modify, and distribute this software for any
6 6 * purpose with or without fee is hereby granted, provided that the above
7 7 * copyright notice and this permission notice appear in all copies.
8 8 *
9 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 16 */
17 17 #ifdef HAVE_CONFIG_H
18 18 #include "config.h"
19 19 #endif
20 20
21 21 #include <sys/types.h>
22 22
23 23 #include <assert.h>
24 24 #include <stdarg.h>
25 25 #include <stdlib.h>
26 26 #include <stdio.h>
27 27 #include <string.h>
28 28
29 29 #include "man.h"
30 30 #include "mandoc.h"
31 31 #include "libman.h"
32 32 #include "libmandoc.h"
|
↓ open down ↓ |
21 lines elided |
↑ open up ↑ |
33 33
34 34 const char *const __man_macronames[MAN_MAX] = {
35 35 "br", "TH", "SH", "SS",
36 36 "TP", "LP", "PP", "P",
37 37 "IP", "HP", "SM", "SB",
38 38 "BI", "IB", "BR", "RB",
39 39 "R", "B", "I", "IR",
40 40 "RI", "na", "sp", "nf",
41 41 "fi", "RE", "RS", "DT",
42 42 "UC", "PD", "AT", "in",
43 - "ft", "OP"
43 + "ft", "OP", "EX", "EE",
44 + "UR", "UE"
44 45 };
45 46
46 47 const char * const *man_macronames = __man_macronames;
47 48
48 49 static struct man_node *man_node_alloc(struct man *, int, int,
49 50 enum man_type, enum mant);
50 51 static int man_node_append(struct man *,
51 52 struct man_node *);
52 53 static void man_node_free(struct man_node *);
53 54 static void man_node_unlink(struct man *,
54 55 struct man_node *);
55 56 static int man_ptext(struct man *, int, char *, int);
56 57 static int man_pmacro(struct man *, int, char *, int);
57 58 static void man_free1(struct man *);
58 59 static void man_alloc1(struct man *);
59 60 static int man_descope(struct man *, int, int);
60 61
61 62
62 63 const struct man_node *
63 -man_node(const struct man *m)
64 +man_node(const struct man *man)
64 65 {
65 66
66 - assert( ! (MAN_HALT & m->flags));
67 - return(m->first);
67 + assert( ! (MAN_HALT & man->flags));
68 + return(man->first);
68 69 }
69 70
70 71
71 72 const struct man_meta *
72 -man_meta(const struct man *m)
73 +man_meta(const struct man *man)
73 74 {
74 75
75 - assert( ! (MAN_HALT & m->flags));
76 - return(&m->meta);
76 + assert( ! (MAN_HALT & man->flags));
77 + return(&man->meta);
77 78 }
78 79
79 80
80 81 void
81 82 man_reset(struct man *man)
82 83 {
83 84
84 85 man_free1(man);
85 86 man_alloc1(man);
86 87 }
87 88
88 89
89 90 void
90 91 man_free(struct man *man)
91 92 {
92 93
93 94 man_free1(man);
94 95 free(man);
95 96 }
96 97
97 98
98 99 struct man *
99 100 man_alloc(struct roff *roff, struct mparse *parse)
100 101 {
101 102 struct man *p;
102 103
103 104 p = mandoc_calloc(1, sizeof(struct man));
104 105
|
↓ open down ↓ |
18 lines elided |
↑ open up ↑ |
105 106 man_hash_init();
106 107 p->parse = parse;
107 108 p->roff = roff;
108 109
109 110 man_alloc1(p);
110 111 return(p);
111 112 }
112 113
113 114
114 115 int
115 -man_endparse(struct man *m)
116 +man_endparse(struct man *man)
116 117 {
117 118
118 - assert( ! (MAN_HALT & m->flags));
119 - if (man_macroend(m))
119 + assert( ! (MAN_HALT & man->flags));
120 + if (man_macroend(man))
120 121 return(1);
121 - m->flags |= MAN_HALT;
122 + man->flags |= MAN_HALT;
122 123 return(0);
123 124 }
124 125
125 126
126 127 int
127 -man_parseln(struct man *m, int ln, char *buf, int offs)
128 +man_parseln(struct man *man, int ln, char *buf, int offs)
128 129 {
129 130
130 - m->flags |= MAN_NEWLINE;
131 + man->flags |= MAN_NEWLINE;
131 132
132 - assert( ! (MAN_HALT & m->flags));
133 + assert( ! (MAN_HALT & man->flags));
133 134
134 - return (mandoc_getcontrol(buf, &offs) ?
135 - man_pmacro(m, ln, buf, offs) :
136 - man_ptext(m, ln, buf, offs));
135 + return (roff_getcontrol(man->roff, buf, &offs) ?
136 + man_pmacro(man, ln, buf, offs) :
137 + man_ptext(man, ln, buf, offs));
137 138 }
138 139
139 140
140 141 static void
141 142 man_free1(struct man *man)
142 143 {
143 144
144 145 if (man->first)
145 146 man_node_delete(man, man->first);
146 147 if (man->meta.title)
147 148 free(man->meta.title);
148 149 if (man->meta.source)
149 150 free(man->meta.source);
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
150 151 if (man->meta.date)
151 152 free(man->meta.date);
152 153 if (man->meta.vol)
153 154 free(man->meta.vol);
154 155 if (man->meta.msec)
155 156 free(man->meta.msec);
156 157 }
157 158
158 159
159 160 static void
160 -man_alloc1(struct man *m)
161 +man_alloc1(struct man *man)
161 162 {
162 163
163 - memset(&m->meta, 0, sizeof(struct man_meta));
164 - m->flags = 0;
165 - m->last = mandoc_calloc(1, sizeof(struct man_node));
166 - m->first = m->last;
167 - m->last->type = MAN_ROOT;
168 - m->last->tok = MAN_MAX;
169 - m->next = MAN_NEXT_CHILD;
164 + memset(&man->meta, 0, sizeof(struct man_meta));
165 + man->flags = 0;
166 + man->last = mandoc_calloc(1, sizeof(struct man_node));
167 + man->first = man->last;
168 + man->last->type = MAN_ROOT;
169 + man->last->tok = MAN_MAX;
170 + man->next = MAN_NEXT_CHILD;
170 171 }
171 172
172 173
173 174 static int
174 175 man_node_append(struct man *man, struct man_node *p)
175 176 {
176 177
177 178 assert(man->last);
178 179 assert(man->first);
179 180 assert(MAN_ROOT != p->type);
180 181
181 182 switch (man->next) {
182 183 case (MAN_NEXT_SIBLING):
183 184 man->last->next = p;
184 185 p->prev = man->last;
185 186 p->parent = man->last->parent;
186 187 break;
187 188 case (MAN_NEXT_CHILD):
188 189 man->last->child = p;
189 190 p->parent = man->last;
190 191 break;
191 192 default:
192 193 abort();
193 194 /* NOTREACHED */
194 195 }
195 196
196 197 assert(p->parent);
197 198 p->parent->nchild++;
198 199
199 200 if ( ! man_valid_pre(man, p))
200 201 return(0);
201 202
202 203 switch (p->type) {
203 204 case (MAN_HEAD):
204 205 assert(MAN_BLOCK == p->parent->type);
205 206 p->parent->head = p;
206 207 break;
207 208 case (MAN_TAIL):
208 209 assert(MAN_BLOCK == p->parent->type);
209 210 p->parent->tail = p;
210 211 break;
211 212 case (MAN_BODY):
212 213 assert(MAN_BLOCK == p->parent->type);
213 214 p->parent->body = p;
214 215 break;
215 216 default:
216 217 break;
217 218 }
218 219
219 220 man->last = p;
220 221
221 222 switch (p->type) {
222 223 case (MAN_TBL):
223 224 /* FALLTHROUGH */
224 225 case (MAN_TEXT):
225 226 if ( ! man_valid_post(man))
226 227 return(0);
|
↓ open down ↓ |
47 lines elided |
↑ open up ↑ |
227 228 break;
228 229 default:
229 230 break;
230 231 }
231 232
232 233 return(1);
233 234 }
234 235
235 236
236 237 static struct man_node *
237 -man_node_alloc(struct man *m, int line, int pos,
238 +man_node_alloc(struct man *man, int line, int pos,
238 239 enum man_type type, enum mant tok)
239 240 {
240 241 struct man_node *p;
241 242
242 243 p = mandoc_calloc(1, sizeof(struct man_node));
243 244 p->line = line;
244 245 p->pos = pos;
245 246 p->type = type;
246 247 p->tok = tok;
247 248
248 - if (MAN_NEWLINE & m->flags)
249 + if (MAN_NEWLINE & man->flags)
249 250 p->flags |= MAN_LINE;
250 - m->flags &= ~MAN_NEWLINE;
251 + man->flags &= ~MAN_NEWLINE;
251 252 return(p);
252 253 }
253 254
254 255
255 256 int
256 -man_elem_alloc(struct man *m, int line, int pos, enum mant tok)
257 +man_elem_alloc(struct man *man, int line, int pos, enum mant tok)
257 258 {
258 259 struct man_node *p;
259 260
260 - p = man_node_alloc(m, line, pos, MAN_ELEM, tok);
261 - if ( ! man_node_append(m, p))
261 + p = man_node_alloc(man, line, pos, MAN_ELEM, tok);
262 + if ( ! man_node_append(man, p))
262 263 return(0);
263 - m->next = MAN_NEXT_CHILD;
264 + man->next = MAN_NEXT_CHILD;
264 265 return(1);
265 266 }
266 267
267 268
268 269 int
269 -man_tail_alloc(struct man *m, int line, int pos, enum mant tok)
270 +man_tail_alloc(struct man *man, int line, int pos, enum mant tok)
270 271 {
271 272 struct man_node *p;
272 273
273 - p = man_node_alloc(m, line, pos, MAN_TAIL, tok);
274 - if ( ! man_node_append(m, p))
274 + p = man_node_alloc(man, line, pos, MAN_TAIL, tok);
275 + if ( ! man_node_append(man, p))
275 276 return(0);
276 - m->next = MAN_NEXT_CHILD;
277 + man->next = MAN_NEXT_CHILD;
277 278 return(1);
278 279 }
279 280
280 281
281 282 int
282 -man_head_alloc(struct man *m, int line, int pos, enum mant tok)
283 +man_head_alloc(struct man *man, int line, int pos, enum mant tok)
283 284 {
284 285 struct man_node *p;
285 286
286 - p = man_node_alloc(m, line, pos, MAN_HEAD, tok);
287 - if ( ! man_node_append(m, p))
287 + p = man_node_alloc(man, line, pos, MAN_HEAD, tok);
288 + if ( ! man_node_append(man, p))
288 289 return(0);
289 - m->next = MAN_NEXT_CHILD;
290 + man->next = MAN_NEXT_CHILD;
290 291 return(1);
291 292 }
292 293
293 294
294 295 int
295 -man_body_alloc(struct man *m, int line, int pos, enum mant tok)
296 +man_body_alloc(struct man *man, int line, int pos, enum mant tok)
296 297 {
297 298 struct man_node *p;
298 299
299 - p = man_node_alloc(m, line, pos, MAN_BODY, tok);
300 - if ( ! man_node_append(m, p))
300 + p = man_node_alloc(man, line, pos, MAN_BODY, tok);
301 + if ( ! man_node_append(man, p))
301 302 return(0);
302 - m->next = MAN_NEXT_CHILD;
303 + man->next = MAN_NEXT_CHILD;
303 304 return(1);
304 305 }
305 306
306 307
307 308 int
308 -man_block_alloc(struct man *m, int line, int pos, enum mant tok)
309 +man_block_alloc(struct man *man, int line, int pos, enum mant tok)
309 310 {
310 311 struct man_node *p;
311 312
312 - p = man_node_alloc(m, line, pos, MAN_BLOCK, tok);
313 - if ( ! man_node_append(m, p))
313 + p = man_node_alloc(man, line, pos, MAN_BLOCK, tok);
314 + if ( ! man_node_append(man, p))
314 315 return(0);
315 - m->next = MAN_NEXT_CHILD;
316 + man->next = MAN_NEXT_CHILD;
316 317 return(1);
317 318 }
318 319
319 320 int
320 -man_word_alloc(struct man *m, int line, int pos, const char *word)
321 +man_word_alloc(struct man *man, int line, int pos, const char *word)
321 322 {
322 323 struct man_node *n;
323 324
324 - n = man_node_alloc(m, line, pos, MAN_TEXT, MAN_MAX);
325 - n->string = roff_strdup(m->roff, word);
325 + n = man_node_alloc(man, line, pos, MAN_TEXT, MAN_MAX);
326 + n->string = roff_strdup(man->roff, word);
326 327
327 - if ( ! man_node_append(m, n))
328 + if ( ! man_node_append(man, n))
328 329 return(0);
329 330
330 - m->next = MAN_NEXT_SIBLING;
331 + man->next = MAN_NEXT_SIBLING;
331 332 return(1);
332 333 }
333 334
334 335
335 336 /*
336 337 * Free all of the resources held by a node. This does NOT unlink a
337 338 * node from its context; for that, see man_node_unlink().
338 339 */
339 340 static void
340 341 man_node_free(struct man_node *p)
341 342 {
342 343
343 344 if (p->string)
344 345 free(p->string);
345 346 free(p);
346 347 }
347 348
348 349
349 350 void
350 -man_node_delete(struct man *m, struct man_node *p)
351 +man_node_delete(struct man *man, struct man_node *p)
351 352 {
352 353
353 354 while (p->child)
354 - man_node_delete(m, p->child);
355 + man_node_delete(man, p->child);
355 356
356 - man_node_unlink(m, p);
357 + man_node_unlink(man, p);
357 358 man_node_free(p);
358 359 }
359 360
360 361 int
361 -man_addeqn(struct man *m, const struct eqn *ep)
362 +man_addeqn(struct man *man, const struct eqn *ep)
362 363 {
363 364 struct man_node *n;
364 365
365 - assert( ! (MAN_HALT & m->flags));
366 + assert( ! (MAN_HALT & man->flags));
366 367
367 - n = man_node_alloc(m, ep->ln, ep->pos, MAN_EQN, MAN_MAX);
368 + n = man_node_alloc(man, ep->ln, ep->pos, MAN_EQN, MAN_MAX);
368 369 n->eqn = ep;
369 370
370 - if ( ! man_node_append(m, n))
371 + if ( ! man_node_append(man, n))
371 372 return(0);
372 373
373 - m->next = MAN_NEXT_SIBLING;
374 - return(man_descope(m, ep->ln, ep->pos));
374 + man->next = MAN_NEXT_SIBLING;
375 + return(man_descope(man, ep->ln, ep->pos));
375 376 }
376 377
377 378 int
378 -man_addspan(struct man *m, const struct tbl_span *sp)
379 +man_addspan(struct man *man, const struct tbl_span *sp)
379 380 {
380 381 struct man_node *n;
381 382
382 - assert( ! (MAN_HALT & m->flags));
383 + assert( ! (MAN_HALT & man->flags));
383 384
384 - n = man_node_alloc(m, sp->line, 0, MAN_TBL, MAN_MAX);
385 + n = man_node_alloc(man, sp->line, 0, MAN_TBL, MAN_MAX);
385 386 n->span = sp;
386 387
387 - if ( ! man_node_append(m, n))
388 + if ( ! man_node_append(man, n))
388 389 return(0);
389 390
390 - m->next = MAN_NEXT_SIBLING;
391 - return(man_descope(m, sp->line, 0));
391 + man->next = MAN_NEXT_SIBLING;
392 + return(man_descope(man, sp->line, 0));
392 393 }
393 394
394 395 static int
395 -man_descope(struct man *m, int line, int offs)
396 +man_descope(struct man *man, int line, int offs)
396 397 {
397 398 /*
398 399 * Co-ordinate what happens with having a next-line scope open:
399 400 * first close out the element scope (if applicable), then close
400 401 * out the block scope (also if applicable).
401 402 */
402 403
403 - if (MAN_ELINE & m->flags) {
404 - m->flags &= ~MAN_ELINE;
405 - if ( ! man_unscope(m, m->last->parent, MANDOCERR_MAX))
404 + if (MAN_ELINE & man->flags) {
405 + man->flags &= ~MAN_ELINE;
406 + if ( ! man_unscope(man, man->last->parent, MANDOCERR_MAX))
406 407 return(0);
407 408 }
408 409
409 - if ( ! (MAN_BLINE & m->flags))
410 + if ( ! (MAN_BLINE & man->flags))
410 411 return(1);
411 - m->flags &= ~MAN_BLINE;
412 + man->flags &= ~MAN_BLINE;
412 413
413 - if ( ! man_unscope(m, m->last->parent, MANDOCERR_MAX))
414 + if ( ! man_unscope(man, man->last->parent, MANDOCERR_MAX))
414 415 return(0);
415 - return(man_body_alloc(m, line, offs, m->last->tok));
416 + return(man_body_alloc(man, line, offs, man->last->tok));
416 417 }
417 418
418 419 static int
419 -man_ptext(struct man *m, int line, char *buf, int offs)
420 +man_ptext(struct man *man, int line, char *buf, int offs)
420 421 {
421 422 int i;
422 423
423 424 /* Literal free-form text whitespace is preserved. */
424 425
425 - if (MAN_LITERAL & m->flags) {
426 - if ( ! man_word_alloc(m, line, offs, buf + offs))
426 + if (MAN_LITERAL & man->flags) {
427 + if ( ! man_word_alloc(man, line, offs, buf + offs))
427 428 return(0);
428 - return(man_descope(m, line, offs));
429 + return(man_descope(man, line, offs));
429 430 }
430 431
431 - /* Pump blank lines directly into the backend. */
432 -
433 432 for (i = offs; ' ' == buf[i]; i++)
434 433 /* Skip leading whitespace. */ ;
435 434
435 + /*
436 + * Blank lines are ignored right after headings
437 + * but add a single vertical space elsewhere.
438 + */
439 +
436 440 if ('\0' == buf[i]) {
437 441 /* Allocate a blank entry. */
438 - if ( ! man_word_alloc(m, line, offs, ""))
439 - return(0);
440 - return(man_descope(m, line, offs));
442 + if (MAN_SH != man->last->tok &&
443 + MAN_SS != man->last->tok) {
444 + if ( ! man_elem_alloc(man, line, offs, MAN_sp))
445 + return(0);
446 + man->next = MAN_NEXT_SIBLING;
447 + }
448 + return(1);
441 449 }
442 450
443 451 /*
444 452 * Warn if the last un-escaped character is whitespace. Then
445 453 * strip away the remaining spaces (tabs stay!).
446 454 */
447 455
448 456 i = (int)strlen(buf);
449 457 assert(i);
450 458
451 459 if (' ' == buf[i - 1] || '\t' == buf[i - 1]) {
452 460 if (i > 1 && '\\' != buf[i - 2])
453 - man_pmsg(m, line, i - 1, MANDOCERR_EOLNSPACE);
461 + man_pmsg(man, line, i - 1, MANDOCERR_EOLNSPACE);
454 462
455 463 for (--i; i && ' ' == buf[i]; i--)
456 464 /* Spin back to non-space. */ ;
457 465
458 466 /* Jump ahead of escaped whitespace. */
459 467 i += '\\' == buf[i] ? 2 : 1;
460 468
461 469 buf[i] = '\0';
462 470 }
463 471
464 - if ( ! man_word_alloc(m, line, offs, buf + offs))
472 + if ( ! man_word_alloc(man, line, offs, buf + offs))
465 473 return(0);
466 474
467 475 /*
468 476 * End-of-sentence check. If the last character is an unescaped
469 477 * EOS character, then flag the node as being the end of a
470 478 * sentence. The front-end will know how to interpret this.
471 479 */
472 480
473 481 assert(i);
474 482 if (mandoc_eos(buf, (size_t)i, 0))
475 - m->last->flags |= MAN_EOS;
483 + man->last->flags |= MAN_EOS;
476 484
477 - return(man_descope(m, line, offs));
485 + return(man_descope(man, line, offs));
478 486 }
479 487
480 488 static int
481 -man_pmacro(struct man *m, int ln, char *buf, int offs)
489 +man_pmacro(struct man *man, int ln, char *buf, int offs)
482 490 {
483 491 int i, ppos;
484 492 enum mant tok;
485 493 char mac[5];
486 494 struct man_node *n;
487 495
488 496 if ('"' == buf[offs]) {
489 - man_pmsg(m, ln, offs, MANDOCERR_BADCOMMENT);
497 + man_pmsg(man, ln, offs, MANDOCERR_BADCOMMENT);
490 498 return(1);
491 499 } else if ('\0' == buf[offs])
492 500 return(1);
493 501
494 502 ppos = offs;
495 503
496 504 /*
497 505 * Copy the first word into a nil-terminated buffer.
498 506 * Stop copying when a tab, space, or eoln is encountered.
499 507 */
500 508
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
501 509 i = 0;
502 510 while (i < 4 && '\0' != buf[offs] &&
503 511 ' ' != buf[offs] && '\t' != buf[offs])
504 512 mac[i++] = buf[offs++];
505 513
506 514 mac[i] = '\0';
507 515
508 516 tok = (i > 0 && i < 4) ? man_hash_find(mac) : MAN_MAX;
509 517
510 518 if (MAN_MAX == tok) {
511 - mandoc_vmsg(MANDOCERR_MACRO, m->parse, ln,
519 + mandoc_vmsg(MANDOCERR_MACRO, man->parse, ln,
512 520 ppos, "%s", buf + ppos - 1);
513 521 return(1);
514 522 }
515 523
516 524 /* The macro is sane. Jump to the next word. */
517 525
518 526 while (buf[offs] && ' ' == buf[offs])
519 527 offs++;
520 528
521 529 /*
522 530 * Trailing whitespace. Note that tabs are allowed to be passed
523 531 * into the parser as "text", so we only warn about spaces here.
524 532 */
525 533
526 534 if ('\0' == buf[offs] && ' ' == buf[offs - 1])
527 - man_pmsg(m, ln, offs - 1, MANDOCERR_EOLNSPACE);
535 + man_pmsg(man, ln, offs - 1, MANDOCERR_EOLNSPACE);
528 536
529 537 /*
530 538 * Remove prior ELINE macro, as it's being clobbered by a new
531 539 * macro. Note that NSCOPED macros do not close out ELINE
532 540 * macros---they don't print text---so we let those slip by.
533 541 */
534 542
535 543 if ( ! (MAN_NSCOPED & man_macros[tok].flags) &&
536 - m->flags & MAN_ELINE) {
537 - n = m->last;
544 + man->flags & MAN_ELINE) {
545 + n = man->last;
538 546 assert(MAN_TEXT != n->type);
539 547
540 548 /* Remove repeated NSCOPED macros causing ELINE. */
541 549
542 550 if (MAN_NSCOPED & man_macros[n->tok].flags)
543 551 n = n->parent;
544 552
545 - mandoc_vmsg(MANDOCERR_LINESCOPE, m->parse, n->line,
553 + mandoc_vmsg(MANDOCERR_LINESCOPE, man->parse, n->line,
546 554 n->pos, "%s breaks %s", man_macronames[tok],
547 555 man_macronames[n->tok]);
548 556
549 - man_node_delete(m, n);
550 - m->flags &= ~MAN_ELINE;
557 + man_node_delete(man, n);
558 + man->flags &= ~MAN_ELINE;
551 559 }
552 560
553 561 /*
554 562 * Remove prior BLINE macro that is being clobbered.
555 563 */
556 - if ((m->flags & MAN_BLINE) &&
564 + if ((man->flags & MAN_BLINE) &&
557 565 (MAN_BSCOPE & man_macros[tok].flags)) {
558 - n = m->last;
566 + n = man->last;
559 567
560 568 /* Might be a text node like 8 in
561 569 * .TP 8
562 570 * .SH foo
563 571 */
564 572 if (MAN_TEXT == n->type)
565 573 n = n->parent;
566 574
567 575 /* Remove element that didn't end BLINE, if any. */
568 576 if ( ! (MAN_BSCOPE & man_macros[n->tok].flags))
569 577 n = n->parent;
570 578
571 579 assert(MAN_HEAD == n->type);
572 580 n = n->parent;
573 581 assert(MAN_BLOCK == n->type);
574 582 assert(MAN_SCOPED & man_macros[n->tok].flags);
575 583
576 - mandoc_vmsg(MANDOCERR_LINESCOPE, m->parse, n->line,
584 + mandoc_vmsg(MANDOCERR_LINESCOPE, man->parse, n->line,
577 585 n->pos, "%s breaks %s", man_macronames[tok],
578 586 man_macronames[n->tok]);
579 587
580 - man_node_delete(m, n);
581 - m->flags &= ~MAN_BLINE;
588 + man_node_delete(man, n);
589 + man->flags &= ~MAN_BLINE;
582 590 }
583 591
584 592 /*
585 593 * Save the fact that we're in the next-line for a block. In
586 594 * this way, embedded roff instructions can "remember" state
587 595 * when they exit.
588 596 */
589 597
590 - if (MAN_BLINE & m->flags)
591 - m->flags |= MAN_BPLINE;
598 + if (MAN_BLINE & man->flags)
599 + man->flags |= MAN_BPLINE;
592 600
593 601 /* Call to handler... */
594 602
595 603 assert(man_macros[tok].fp);
596 - if ( ! (*man_macros[tok].fp)(m, tok, ln, ppos, &offs, buf))
604 + if ( ! (*man_macros[tok].fp)(man, tok, ln, ppos, &offs, buf))
597 605 goto err;
598 606
599 607 /*
600 608 * We weren't in a block-line scope when entering the
601 609 * above-parsed macro, so return.
602 610 */
603 611
604 - if ( ! (MAN_BPLINE & m->flags)) {
605 - m->flags &= ~MAN_ILINE;
612 + if ( ! (MAN_BPLINE & man->flags)) {
613 + man->flags &= ~MAN_ILINE;
606 614 return(1);
607 615 }
608 - m->flags &= ~MAN_BPLINE;
616 + man->flags &= ~MAN_BPLINE;
609 617
610 618 /*
611 619 * If we're in a block scope, then allow this macro to slip by
612 620 * without closing scope around it.
613 621 */
614 622
615 - if (MAN_ILINE & m->flags) {
616 - m->flags &= ~MAN_ILINE;
623 + if (MAN_ILINE & man->flags) {
624 + man->flags &= ~MAN_ILINE;
617 625 return(1);
618 626 }
619 627
620 628 /*
621 629 * If we've opened a new next-line element scope, then return
622 630 * now, as the next line will close out the block scope.
623 631 */
624 632
625 - if (MAN_ELINE & m->flags)
633 + if (MAN_ELINE & man->flags)
626 634 return(1);
627 635
628 636 /* Close out the block scope opened in the prior line. */
629 637
630 - assert(MAN_BLINE & m->flags);
631 - m->flags &= ~MAN_BLINE;
638 + assert(MAN_BLINE & man->flags);
639 + man->flags &= ~MAN_BLINE;
632 640
633 - if ( ! man_unscope(m, m->last->parent, MANDOCERR_MAX))
641 + if ( ! man_unscope(man, man->last->parent, MANDOCERR_MAX))
634 642 return(0);
635 - return(man_body_alloc(m, ln, ppos, m->last->tok));
643 + return(man_body_alloc(man, ln, ppos, man->last->tok));
636 644
637 645 err: /* Error out. */
638 646
639 - m->flags |= MAN_HALT;
647 + man->flags |= MAN_HALT;
640 648 return(0);
641 649 }
642 650
643 651 /*
644 - * Unlink a node from its context. If "m" is provided, the last parse
652 + * Unlink a node from its context. If "man" is provided, the last parse
645 653 * point will also be adjusted accordingly.
646 654 */
647 655 static void
648 -man_node_unlink(struct man *m, struct man_node *n)
656 +man_node_unlink(struct man *man, struct man_node *n)
649 657 {
650 658
651 659 /* Adjust siblings. */
652 660
653 661 if (n->prev)
654 662 n->prev->next = n->next;
655 663 if (n->next)
656 664 n->next->prev = n->prev;
657 665
658 666 /* Adjust parent. */
659 667
660 668 if (n->parent) {
661 669 n->parent->nchild--;
662 670 if (n->parent->child == n)
663 671 n->parent->child = n->prev ? n->prev : n->next;
664 672 }
665 673
666 674 /* Adjust parse point, if applicable. */
667 675
668 - if (m && m->last == n) {
676 + if (man && man->last == n) {
669 677 /*XXX: this can occur when bailing from validation. */
670 678 /*assert(NULL == n->next);*/
671 679 if (n->prev) {
672 - m->last = n->prev;
673 - m->next = MAN_NEXT_SIBLING;
680 + man->last = n->prev;
681 + man->next = MAN_NEXT_SIBLING;
674 682 } else {
675 - m->last = n->parent;
676 - m->next = MAN_NEXT_CHILD;
683 + man->last = n->parent;
684 + man->next = MAN_NEXT_CHILD;
677 685 }
678 686 }
679 687
680 - if (m && m->first == n)
681 - m->first = NULL;
688 + if (man && man->first == n)
689 + man->first = NULL;
682 690 }
683 691
684 692 const struct mparse *
685 -man_mparse(const struct man *m)
693 +man_mparse(const struct man *man)
686 694 {
687 695
688 - assert(m && m->parse);
689 - return(m->parse);
696 + assert(man && man->parse);
697 + return(man->parse);
690 698 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX