| 1 | /* $Id: mdoc.c,v 1.113 2009/10/30 05:58:38 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 <sys/types.h> |
| 18 | |
| 19 | #include <assert.h> |
| 20 | #include <ctype.h> |
| 21 | #include <stdarg.h> |
| 22 | #include <stdio.h> |
| 23 | #include <stdlib.h> |
| 24 | #include <string.h> |
| 25 | |
| 26 | #include "libmdoc.h" |
| 27 | #include "libmandoc.h" |
| 28 | |
| 29 | const char *const __mdoc_merrnames[MERRMAX] = { |
| 30 | "trailing whitespace", /* ETAILWS */ |
| 31 | "unexpected quoted parameter", /* EQUOTPARM */ |
| 32 | "unterminated quoted parameter", /* EQUOTTERM */ |
| 33 | "argument parameter suggested", /* EARGVAL */ |
| 34 | "macro disallowed in prologue", /* EBODYPROL */ |
| 35 | "macro disallowed in body", /* EPROLBODY */ |
| 36 | "text disallowed in prologue", /* ETEXTPROL */ |
| 37 | "blank line disallowed", /* ENOBLANK */ |
| 38 | "text parameter too long", /* ETOOLONG */ |
| 39 | "invalid escape sequence", /* EESCAPE */ |
| 40 | "invalid character", /* EPRINT */ |
| 41 | "document has no body", /* ENODAT */ |
| 42 | "document has no prologue", /* ENOPROLOGUE */ |
| 43 | "expected line arguments", /* ELINE */ |
| 44 | "invalid AT&T argument", /* EATT */ |
| 45 | "default name not yet set", /* ENAME */ |
| 46 | "missing list type", /* ELISTTYPE */ |
| 47 | "missing display type", /* EDISPTYPE */ |
| 48 | "too many display types", /* EMULTIDISP */ |
| 49 | "too many list types", /* EMULTILIST */ |
| 50 | "NAME section must be first", /* ESECNAME */ |
| 51 | "badly-formed NAME section", /* ENAMESECINC */ |
| 52 | "argument repeated", /* EARGREP */ |
| 53 | "expected boolean parameter", /* EBOOL */ |
| 54 | "inconsistent column syntax", /* ECOLMIS */ |
| 55 | "nested display invalid", /* ENESTDISP */ |
| 56 | "width argument missing", /* EMISSWIDTH */ |
| 57 | "invalid section for this manual section", /* EWRONGMSEC */ |
| 58 | "section out of conventional order", /* ESECOOO */ |
| 59 | "section repeated", /* ESECREP */ |
| 60 | "invalid standard argument", /* EBADSTAND */ |
| 61 | "multi-line arguments discouraged", /* ENOMULTILINE */ |
| 62 | "multi-line arguments suggested", /* EMULTILINE */ |
| 63 | "line arguments discouraged", /* ENOLINE */ |
| 64 | "prologue macro out of conventional order", /* EPROLOOO */ |
| 65 | "prologue macro repeated", /* EPROLREP */ |
| 66 | "invalid manual section", /* EBADMSEC */ |
| 67 | "invalid section", /* EBADSEC */ |
| 68 | "invalid font mode", /* EFONT */ |
| 69 | "invalid date syntax", /* EBADDATE */ |
| 70 | "invalid number format", /* ENUMFMT */ |
| 71 | "superfluous width argument", /* ENOWIDTH */ |
| 72 | "system: utsname error", /* EUTSNAME */ |
| 73 | "obsolete macro", /* EOBS */ |
| 74 | "end-of-line scope violation", /* EIMPBRK */ |
| 75 | "empty macro ignored", /* EIGNE */ |
| 76 | "unclosed explicit scope", /* EOPEN */ |
| 77 | "unterminated quoted phrase", /* EQUOTPHR */ |
| 78 | "closure macro without prior context", /* ENOCTX */ |
| 79 | "no description found for library", /* ELIB */ |
| 80 | "bad child for parent context", /* EBADCHILD */ |
| 81 | "list arguments preceding type", /* ENOTYPE */ |
| 82 | }; |
| 83 | |
| 84 | const char *const __mdoc_macronames[MDOC_MAX] = { |
| 85 | "Ap", "Dd", "Dt", "Os", |
| 86 | "Sh", "Ss", "Pp", "D1", |
| 87 | "Dl", "Bd", "Ed", "Bl", |
| 88 | "El", "It", "Ad", "An", |
| 89 | "Ar", "Cd", "Cm", "Dv", |
| 90 | "Er", "Ev", "Ex", "Fa", |
| 91 | "Fd", "Fl", "Fn", "Ft", |
| 92 | "Ic", "In", "Li", "Nd", |
| 93 | "Nm", "Op", "Ot", "Pa", |
| 94 | "Rv", "St", "Va", "Vt", |
| 95 | /* LINTED */ |
| 96 | "Xr", "\%A", "\%B", "\%D", |
| 97 | /* LINTED */ |
| 98 | "\%I", "\%J", "\%N", "\%O", |
| 99 | /* LINTED */ |
| 100 | "\%P", "\%R", "\%T", "\%V", |
| 101 | "Ac", "Ao", "Aq", "At", |
| 102 | "Bc", "Bf", "Bo", "Bq", |
| 103 | "Bsx", "Bx", "Db", "Dc", |
| 104 | "Do", "Dq", "Ec", "Ef", |
| 105 | "Em", "Eo", "Fx", "Ms", |
| 106 | "No", "Ns", "Nx", "Ox", |
| 107 | "Pc", "Pf", "Po", "Pq", |
| 108 | "Qc", "Ql", "Qo", "Qq", |
| 109 | "Re", "Rs", "Sc", "So", |
| 110 | "Sq", "Sm", "Sx", "Sy", |
| 111 | "Tn", "Ux", "Xc", "Xo", |
| 112 | "Fo", "Fc", "Oo", "Oc", |
| 113 | "Bk", "Ek", "Bt", "Hf", |
| 114 | "Fr", "Ud", "Lb", "Lp", |
| 115 | "Lk", "Mt", "Brq", "Bro", |
| 116 | /* LINTED */ |
| 117 | "Brc", "\%C", "Es", "En", |
| 118 | /* LINTED */ |
| 119 | "Dx", "\%Q", "br", "sp", |
| 120 | /* LINTED */ |
| 121 | "\%U" |
| 122 | }; |
| 123 | |
| 124 | const char *const __mdoc_argnames[MDOC_ARG_MAX] = { |
| 125 | "split", "nosplit", "ragged", |
| 126 | "unfilled", "literal", "file", |
| 127 | "offset", "bullet", "dash", |
| 128 | "hyphen", "item", "enum", |
| 129 | "tag", "diag", "hang", |
| 130 | "ohang", "inset", "column", |
| 131 | "width", "compact", "std", |
| 132 | "filled", "words", "emphasis", |
| 133 | "symbolic", "nested", "centered" |
| 134 | }; |
| 135 | |
| 136 | const char * const *mdoc_macronames = __mdoc_macronames; |
| 137 | const char * const *mdoc_argnames = __mdoc_argnames; |
| 138 | |
| 139 | static void mdoc_free1(struct mdoc *); |
| 140 | static void mdoc_alloc1(struct mdoc *); |
| 141 | static struct mdoc_node *node_alloc(struct mdoc *, int, int, |
| 142 | int, enum mdoc_type); |
| 143 | static int node_append(struct mdoc *, |
| 144 | struct mdoc_node *); |
| 145 | static int parsetext(struct mdoc *, int, char *); |
| 146 | static int parsemacro(struct mdoc *, int, char *); |
| 147 | static int macrowarn(struct mdoc *, int, const char *); |
| 148 | static int pstring(struct mdoc *, int, int, |
| 149 | const char *, size_t); |
| 150 | |
| 151 | #ifdef __linux__ |
| 152 | extern size_t strlcpy(char *, const char *, size_t); |
| 153 | #endif |
| 154 | |
| 155 | |
| 156 | const struct mdoc_node * |
| 157 | mdoc_node(const struct mdoc *m) |
| 158 | { |
| 159 | |
| 160 | return(MDOC_HALT & m->flags ? NULL : m->first); |
| 161 | } |
| 162 | |
| 163 | |
| 164 | const struct mdoc_meta * |
| 165 | mdoc_meta(const struct mdoc *m) |
| 166 | { |
| 167 | |
| 168 | return(MDOC_HALT & m->flags ? NULL : &m->meta); |
| 169 | } |
| 170 | |
| 171 | |
| 172 | /* |
| 173 | * Frees volatile resources (parse tree, meta-data, fields). |
| 174 | */ |
| 175 | static void |
| 176 | mdoc_free1(struct mdoc *mdoc) |
| 177 | { |
| 178 | |
| 179 | if (mdoc->first) |
| 180 | mdoc_node_freelist(mdoc->first); |
| 181 | if (mdoc->meta.title) |
| 182 | free(mdoc->meta.title); |
| 183 | if (mdoc->meta.os) |
| 184 | free(mdoc->meta.os); |
| 185 | if (mdoc->meta.name) |
| 186 | free(mdoc->meta.name); |
| 187 | if (mdoc->meta.arch) |
| 188 | free(mdoc->meta.arch); |
| 189 | if (mdoc->meta.vol) |
| 190 | free(mdoc->meta.vol); |
| 191 | } |
| 192 | |
| 193 | |
| 194 | /* |
| 195 | * Allocate all volatile resources (parse tree, meta-data, fields). |
| 196 | */ |
| 197 | static void |
| 198 | mdoc_alloc1(struct mdoc *mdoc) |
| 199 | { |
| 200 | |
| 201 | memset(&mdoc->meta, 0, sizeof(struct mdoc_meta)); |
| 202 | mdoc->flags = 0; |
| 203 | mdoc->lastnamed = mdoc->lastsec = SEC_NONE; |
| 204 | mdoc->last = mandoc_calloc(1, sizeof(struct mdoc_node)); |
| 205 | mdoc->first = mdoc->last; |
| 206 | mdoc->last->type = MDOC_ROOT; |
| 207 | mdoc->next = MDOC_NEXT_CHILD; |
| 208 | } |
| 209 | |
| 210 | |
| 211 | /* |
| 212 | * Free up volatile resources (see mdoc_free1()) then re-initialises the |
| 213 | * data with mdoc_alloc1(). After invocation, parse data has been reset |
| 214 | * and the parser is ready for re-invocation on a new tree; however, |
| 215 | * cross-parse non-volatile data is kept intact. |
| 216 | */ |
| 217 | void |
| 218 | mdoc_reset(struct mdoc *mdoc) |
| 219 | { |
| 220 | |
| 221 | mdoc_free1(mdoc); |
| 222 | mdoc_alloc1(mdoc); |
| 223 | } |
| 224 | |
| 225 | |
| 226 | /* |
| 227 | * Completely free up all volatile and non-volatile parse resources. |
| 228 | * After invocation, the pointer is no longer usable. |
| 229 | */ |
| 230 | void |
| 231 | mdoc_free(struct mdoc *mdoc) |
| 232 | { |
| 233 | |
| 234 | mdoc_free1(mdoc); |
| 235 | free(mdoc); |
| 236 | } |
| 237 | |
| 238 | |
| 239 | /* |
| 240 | * Allocate volatile and non-volatile parse resources. |
| 241 | */ |
| 242 | struct mdoc * |
| 243 | mdoc_alloc(void *data, int pflags, const struct mdoc_cb *cb) |
| 244 | { |
| 245 | struct mdoc *p; |
| 246 | |
| 247 | p = mandoc_calloc(1, sizeof(struct mdoc)); |
| 248 | |
| 249 | if (cb) |
| 250 | memcpy(&p->cb, cb, sizeof(struct mdoc_cb)); |
| 251 | |
| 252 | p->data = data; |
| 253 | p->pflags = pflags; |
| 254 | |
| 255 | mdoc_hash_init(); |
| 256 | mdoc_alloc1(p); |
| 257 | return(p); |
| 258 | } |
| 259 | |
| 260 | |
| 261 | /* |
| 262 | * Climb back up the parse tree, validating open scopes. Mostly calls |
| 263 | * through to macro_end() in macro.c. |
| 264 | */ |
| 265 | int |
| 266 | mdoc_endparse(struct mdoc *m) |
| 267 | { |
| 268 | |
| 269 | if (MDOC_HALT & m->flags) |
| 270 | return(0); |
| 271 | else if (mdoc_macroend(m)) |
| 272 | return(1); |
| 273 | m->flags |= MDOC_HALT; |
| 274 | return(0); |
| 275 | } |
| 276 | |
| 277 | |
| 278 | /* |
| 279 | * Main parse routine. Parses a single line -- really just hands off to |
| 280 | * the macro (parsemacro()) or text parser (parsetext()). |
| 281 | */ |
| 282 | int |
| 283 | mdoc_parseln(struct mdoc *m, int ln, char *buf) |
| 284 | { |
| 285 | |
| 286 | if (MDOC_HALT & m->flags) |
| 287 | return(0); |
| 288 | |
| 289 | return('.' == *buf ? parsemacro(m, ln, buf) : |
| 290 | parsetext(m, ln, buf)); |
| 291 | } |
| 292 | |
| 293 | |
| 294 | int |
| 295 | mdoc_verr(struct mdoc *mdoc, int ln, int pos, |
| 296 | const char *fmt, ...) |
| 297 | { |
| 298 | char buf[256]; |
| 299 | va_list ap; |
| 300 | |
| 301 | if (NULL == mdoc->cb.mdoc_err) |
| 302 | return(0); |
| 303 | |
| 304 | va_start(ap, fmt); |
| 305 | (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap); |
| 306 | va_end(ap); |
| 307 | |
| 308 | return((*mdoc->cb.mdoc_err)(mdoc->data, ln, pos, buf)); |
| 309 | } |
| 310 | |
| 311 | |
| 312 | int |
| 313 | mdoc_vwarn(struct mdoc *mdoc, int ln, int pos, const char *fmt, ...) |
| 314 | { |
| 315 | char buf[256]; |
| 316 | va_list ap; |
| 317 | |
| 318 | if (NULL == mdoc->cb.mdoc_warn) |
| 319 | return(0); |
| 320 | |
| 321 | va_start(ap, fmt); |
| 322 | (void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap); |
| 323 | va_end(ap); |
| 324 | |
| 325 | return((*mdoc->cb.mdoc_warn)(mdoc->data, ln, pos, buf)); |
| 326 | } |
| 327 | |
| 328 | |
| 329 | int |
| 330 | mdoc_err(struct mdoc *m, int line, int pos, int iserr, enum merr type) |
| 331 | { |
| 332 | const char *p; |
| 333 | |
| 334 | p = __mdoc_merrnames[(int)type]; |
| 335 | assert(p); |
| 336 | |
| 337 | if (iserr) |
| 338 | return(mdoc_verr(m, line, pos, p)); |
| 339 | |
| 340 | return(mdoc_vwarn(m, line, pos, p)); |
| 341 | } |
| 342 | |
| 343 | |
| 344 | int |
| 345 | mdoc_macro(struct mdoc *m, int tok, |
| 346 | int ln, int pp, int *pos, char *buf) |
| 347 | { |
| 348 | /* |
| 349 | * If we're in the prologue, deny "body" macros. Similarly, if |
| 350 | * we're in the body, deny prologue calls. |
| 351 | */ |
| 352 | if (MDOC_PROLOGUE & mdoc_macros[tok].flags && |
| 353 | MDOC_PBODY & m->flags) |
| 354 | return(mdoc_perr(m, ln, pp, EPROLBODY)); |
| 355 | if ( ! (MDOC_PROLOGUE & mdoc_macros[tok].flags) && |
| 356 | ! (MDOC_PBODY & m->flags)) |
| 357 | return(mdoc_perr(m, ln, pp, EBODYPROL)); |
| 358 | |
| 359 | return((*mdoc_macros[tok].fp)(m, tok, ln, pp, pos, buf)); |
| 360 | } |
| 361 | |
| 362 | |
| 363 | static int |
| 364 | node_append(struct mdoc *mdoc, struct mdoc_node *p) |
| 365 | { |
| 366 | |
| 367 | assert(mdoc->last); |
| 368 | assert(mdoc->first); |
| 369 | assert(MDOC_ROOT != p->type); |
| 370 | |
| 371 | switch (mdoc->next) { |
| 372 | case (MDOC_NEXT_SIBLING): |
| 373 | mdoc->last->next = p; |
| 374 | p->prev = mdoc->last; |
| 375 | p->parent = mdoc->last->parent; |
| 376 | break; |
| 377 | case (MDOC_NEXT_CHILD): |
| 378 | mdoc->last->child = p; |
| 379 | p->parent = mdoc->last; |
| 380 | break; |
| 381 | default: |
| 382 | abort(); |
| 383 | /* NOTREACHED */ |
| 384 | } |
| 385 | |
| 386 | p->parent->nchild++; |
| 387 | |
| 388 | if ( ! mdoc_valid_pre(mdoc, p)) |
| 389 | return(0); |
| 390 | if ( ! mdoc_action_pre(mdoc, p)) |
| 391 | return(0); |
| 392 | |
| 393 | switch (p->type) { |
| 394 | case (MDOC_HEAD): |
| 395 | assert(MDOC_BLOCK == p->parent->type); |
| 396 | p->parent->head = p; |
| 397 | break; |
| 398 | case (MDOC_TAIL): |
| 399 | assert(MDOC_BLOCK == p->parent->type); |
| 400 | p->parent->tail = p; |
| 401 | break; |
| 402 | case (MDOC_BODY): |
| 403 | assert(MDOC_BLOCK == p->parent->type); |
| 404 | p->parent->body = p; |
| 405 | break; |
| 406 | default: |
| 407 | break; |
| 408 | } |
| 409 | |
| 410 | mdoc->last = p; |
| 411 | |
| 412 | switch (p->type) { |
| 413 | case (MDOC_TEXT): |
| 414 | if ( ! mdoc_valid_post(mdoc)) |
| 415 | return(0); |
| 416 | if ( ! mdoc_action_post(mdoc)) |
| 417 | return(0); |
| 418 | break; |
| 419 | default: |
| 420 | break; |
| 421 | } |
| 422 | |
| 423 | return(1); |
| 424 | } |
| 425 | |
| 426 | |
| 427 | static struct mdoc_node * |
| 428 | node_alloc(struct mdoc *m, int line, |
| 429 | int pos, int tok, enum mdoc_type type) |
| 430 | { |
| 431 | struct mdoc_node *p; |
| 432 | |
| 433 | p = mandoc_calloc(1, sizeof(struct mdoc_node)); |
| 434 | p->sec = m->lastsec; |
| 435 | p->line = line; |
| 436 | p->pos = pos; |
| 437 | p->tok = tok; |
| 438 | if (MDOC_TEXT != (p->type = type)) |
| 439 | assert(p->tok >= 0); |
| 440 | |
| 441 | return(p); |
| 442 | } |
| 443 | |
| 444 | |
| 445 | int |
| 446 | mdoc_tail_alloc(struct mdoc *m, int line, int pos, int tok) |
| 447 | { |
| 448 | struct mdoc_node *p; |
| 449 | |
| 450 | p = node_alloc(m, line, pos, tok, MDOC_TAIL); |
| 451 | if ( ! node_append(m, p)) |
| 452 | return(0); |
| 453 | m->next = MDOC_NEXT_CHILD; |
| 454 | return(1); |
| 455 | } |
| 456 | |
| 457 | |
| 458 | int |
| 459 | mdoc_head_alloc(struct mdoc *m, int line, int pos, int tok) |
| 460 | { |
| 461 | struct mdoc_node *p; |
| 462 | |
| 463 | assert(m->first); |
| 464 | assert(m->last); |
| 465 | |
| 466 | p = node_alloc(m, line, pos, tok, MDOC_HEAD); |
| 467 | if ( ! node_append(m, p)) |
| 468 | return(0); |
| 469 | m->next = MDOC_NEXT_CHILD; |
| 470 | return(1); |
| 471 | } |
| 472 | |
| 473 | |
| 474 | int |
| 475 | mdoc_body_alloc(struct mdoc *m, int line, int pos, int tok) |
| 476 | { |
| 477 | struct mdoc_node *p; |
| 478 | |
| 479 | p = node_alloc(m, line, pos, tok, MDOC_BODY); |
| 480 | if ( ! node_append(m, p)) |
| 481 | return(0); |
| 482 | m->next = MDOC_NEXT_CHILD; |
| 483 | return(1); |
| 484 | } |
| 485 | |
| 486 | |
| 487 | int |
| 488 | mdoc_block_alloc(struct mdoc *m, int line, int pos, |
| 489 | int tok, struct mdoc_arg *args) |
| 490 | { |
| 491 | struct mdoc_node *p; |
| 492 | |
| 493 | p = node_alloc(m, line, pos, tok, MDOC_BLOCK); |
| 494 | p->args = args; |
| 495 | if (p->args) |
| 496 | (args->refcnt)++; |
| 497 | if ( ! node_append(m, p)) |
| 498 | return(0); |
| 499 | m->next = MDOC_NEXT_CHILD; |
| 500 | return(1); |
| 501 | } |
| 502 | |
| 503 | |
| 504 | int |
| 505 | mdoc_elem_alloc(struct mdoc *m, int line, int pos, |
| 506 | int tok, struct mdoc_arg *args) |
| 507 | { |
| 508 | struct mdoc_node *p; |
| 509 | |
| 510 | p = node_alloc(m, line, pos, tok, MDOC_ELEM); |
| 511 | p->args = args; |
| 512 | if (p->args) |
| 513 | (args->refcnt)++; |
| 514 | if ( ! node_append(m, p)) |
| 515 | return(0); |
| 516 | m->next = MDOC_NEXT_CHILD; |
| 517 | return(1); |
| 518 | } |
| 519 | |
| 520 | |
| 521 | static int |
| 522 | pstring(struct mdoc *m, int line, int pos, const char *p, size_t len) |
| 523 | { |
| 524 | struct mdoc_node *n; |
| 525 | size_t sv; |
| 526 | |
| 527 | n = node_alloc(m, line, pos, -1, MDOC_TEXT); |
| 528 | n->string = mandoc_malloc(len + 1); |
| 529 | sv = strlcpy(n->string, p, len + 1); |
| 530 | |
| 531 | /* Prohibit truncation. */ |
| 532 | assert(sv < len + 1); |
| 533 | |
| 534 | if ( ! node_append(m, n)) |
| 535 | return(0); |
| 536 | m->next = MDOC_NEXT_SIBLING; |
| 537 | return(1); |
| 538 | } |
| 539 | |
| 540 | |
| 541 | int |
| 542 | mdoc_word_alloc(struct mdoc *m, int line, int pos, const char *p) |
| 543 | { |
| 544 | |
| 545 | return(pstring(m, line, pos, p, strlen(p))); |
| 546 | } |
| 547 | |
| 548 | |
| 549 | void |
| 550 | mdoc_node_free(struct mdoc_node *p) |
| 551 | { |
| 552 | |
| 553 | if (p->parent) |
| 554 | p->parent->nchild--; |
| 555 | if (p->string) |
| 556 | free(p->string); |
| 557 | if (p->args) |
| 558 | mdoc_argv_free(p->args); |
| 559 | free(p); |
| 560 | } |
| 561 | |
| 562 | |
| 563 | void |
| 564 | mdoc_node_freelist(struct mdoc_node *p) |
| 565 | { |
| 566 | |
| 567 | if (p->child) |
| 568 | mdoc_node_freelist(p->child); |
| 569 | if (p->next) |
| 570 | mdoc_node_freelist(p->next); |
| 571 | |
| 572 | assert(0 == p->nchild); |
| 573 | mdoc_node_free(p); |
| 574 | } |
| 575 | |
| 576 | |
| 577 | /* |
| 578 | * Parse free-form text, that is, a line that does not begin with the |
| 579 | * control character. |
| 580 | */ |
| 581 | static int |
| 582 | parsetext(struct mdoc *m, int line, char *buf) |
| 583 | { |
| 584 | int i, j; |
| 585 | |
| 586 | if (SEC_NONE == m->lastnamed) |
| 587 | return(mdoc_perr(m, line, 0, ETEXTPROL)); |
| 588 | |
| 589 | /* |
| 590 | * If in literal mode, then pass the buffer directly to the |
| 591 | * back-end, as it should be preserved as a single term. |
| 592 | */ |
| 593 | |
| 594 | if (MDOC_LITERAL & m->flags) |
| 595 | return(mdoc_word_alloc(m, line, 0, buf)); |
| 596 | |
| 597 | /* Disallow blank/white-space lines in non-literal mode. */ |
| 598 | |
| 599 | for (i = 0; ' ' == buf[i]; i++) |
| 600 | /* Skip leading whitespace. */ ; |
| 601 | if (0 == buf[i]) |
| 602 | return(mdoc_perr(m, line, 0, ENOBLANK)); |
| 603 | |
| 604 | /* |
| 605 | * Break apart a free-form line into tokens. Spaces are |
| 606 | * stripped out of the input. |
| 607 | */ |
| 608 | |
| 609 | for (j = i; buf[i]; i++) { |
| 610 | if (' ' != buf[i]) |
| 611 | continue; |
| 612 | |
| 613 | /* Escaped whitespace. */ |
| 614 | if (i && ' ' == buf[i] && '\\' == buf[i - 1]) |
| 615 | continue; |
| 616 | |
| 617 | buf[i++] = 0; |
| 618 | if ( ! pstring(m, line, j, &buf[j], (size_t)(i - j))) |
| 619 | return(0); |
| 620 | |
| 621 | for ( ; ' ' == buf[i]; i++) |
| 622 | /* Skip trailing whitespace. */ ; |
| 623 | |
| 624 | j = i; |
| 625 | if (0 == buf[i]) |
| 626 | break; |
| 627 | } |
| 628 | |
| 629 | if (j != i && ! pstring(m, line, j, &buf[j], (size_t)(i - j))) |
| 630 | return(0); |
| 631 | |
| 632 | m->next = MDOC_NEXT_SIBLING; |
| 633 | return(1); |
| 634 | } |
| 635 | |
| 636 | |
| 637 | |
| 638 | static int |
| 639 | macrowarn(struct mdoc *m, int ln, const char *buf) |
| 640 | { |
| 641 | if ( ! (MDOC_IGN_MACRO & m->pflags)) |
| 642 | return(mdoc_verr(m, ln, 0, |
| 643 | "unknown macro: %s%s", |
| 644 | buf, strlen(buf) > 3 ? "..." : "")); |
| 645 | return(mdoc_vwarn(m, ln, 0, "unknown macro: %s%s", |
| 646 | buf, strlen(buf) > 3 ? "..." : "")); |
| 647 | } |
| 648 | |
| 649 | |
| 650 | /* |
| 651 | * Parse a macro line, that is, a line beginning with the control |
| 652 | * character. |
| 653 | */ |
| 654 | int |
| 655 | parsemacro(struct mdoc *m, int ln, char *buf) |
| 656 | { |
| 657 | int i, j, c; |
| 658 | char mac[5]; |
| 659 | |
| 660 | /* Empty lines are ignored. */ |
| 661 | |
| 662 | if (0 == buf[1]) |
| 663 | return(1); |
| 664 | |
| 665 | i = 1; |
| 666 | |
| 667 | /* Accept whitespace after the initial control char. */ |
| 668 | |
| 669 | if (' ' == buf[i]) { |
| 670 | i++; |
| 671 | while (buf[i] && ' ' == buf[i]) |
| 672 | i++; |
| 673 | if (0 == buf[i]) |
| 674 | return(1); |
| 675 | } |
| 676 | |
| 677 | /* Copy the first word into a nil-terminated buffer. */ |
| 678 | |
| 679 | for (j = 0; j < 4; j++, i++) { |
| 680 | if (0 == (mac[j] = buf[i])) |
| 681 | break; |
| 682 | else if (' ' == buf[i]) |
| 683 | break; |
| 684 | |
| 685 | /* Check for invalid characters. */ |
| 686 | |
| 687 | if (isgraph((u_char)buf[i])) |
| 688 | continue; |
| 689 | return(mdoc_perr(m, ln, i, EPRINT)); |
| 690 | } |
| 691 | |
| 692 | mac[j] = 0; |
| 693 | |
| 694 | if (j == 4 || j < 2) { |
| 695 | if ( ! macrowarn(m, ln, mac)) |
| 696 | goto err; |
| 697 | return(1); |
| 698 | } |
| 699 | |
| 700 | if (MDOC_MAX == (c = mdoc_hash_find(mac))) { |
| 701 | if ( ! macrowarn(m, ln, mac)) |
| 702 | goto err; |
| 703 | return(1); |
| 704 | } |
| 705 | |
| 706 | /* The macro is sane. Jump to the next word. */ |
| 707 | |
| 708 | while (buf[i] && ' ' == buf[i]) |
| 709 | i++; |
| 710 | |
| 711 | /* |
| 712 | * Begin recursive parse sequence. Since we're at the start of |
| 713 | * the line, we don't need to do callable/parseable checks. |
| 714 | */ |
| 715 | if ( ! mdoc_macro(m, c, ln, 1, &i, buf)) |
| 716 | goto err; |
| 717 | |
| 718 | return(1); |
| 719 | |
| 720 | err: /* Error out. */ |
| 721 | |
| 722 | m->flags |= MDOC_HALT; |
| 723 | return(0); |
| 724 | } |