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