mdoc.c

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