mdoc.c

   1 /*      $Id: mdoc.c,v 1.120 2010/04/05 08:59:46 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_free1(struct mdoc *);
 145 static  void              mdoc_alloc1(struct mdoc *);
 146 static  struct mdoc_node *node_alloc(struct mdoc *, int, int,
 147                                 enum mdoct, enum mdoc_type);
 148 static  int               node_append(struct mdoc *,
 149                                 struct mdoc_node *);
 150 static  int               parsetext(struct mdoc *, int, char *);
 151 static  int               parsemacro(struct mdoc *, int, char *);
 152 static  int               macrowarn(struct mdoc *, int, const char *);
 153 static  int               pstring(struct mdoc *, int, int,
 154                                 const char *, size_t);
 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, enum mdoct tok,
 346                 int ln, int pp, int *pos, char *buf)
 347 {
 348
 349         assert(tok < MDOC_MAX);
 350         /*
 351          * If we're in the prologue, deny "body" macros.  Similarly, if
 352          * we're in the body, deny prologue calls.
 353          */
 354         if (MDOC_PROLOGUE & mdoc_macros[tok].flags &&
 355                         MDOC_PBODY & m->flags) {
 356                 if ( ! mdoc_pwarn(m, ln, pp, EBODYPROL))
 357                         return(0);
 358                 /*
 359                  * FIXME: do this in mdoc_action.c.
 360                  */
 361                 if (NULL == m->meta.title)
 362                         m->meta.title = mandoc_strdup("unknown");
 363                 if (NULL == m->meta.vol)
 364                         m->meta.vol = mandoc_strdup("local");
 365                 if (NULL == m->meta.os)
 366                         m->meta.os = mandoc_strdup("local");
 367                 if (0 == m->meta.date)
 368                         m->meta.date = time(NULL);
 369                 m->flags |= MDOC_PBODY;
 370         }
 371         if ( ! (MDOC_PROLOGUE & mdoc_macros[tok].flags) &&
 372                         ! (MDOC_PBODY & m->flags))
 373                 return(mdoc_perr(m, ln, pp, EBODYPROL));
 374
 375         return((*mdoc_macros[tok].fp)(m, tok, ln, pp, pos, buf));
 376 }
 377
 378
 379 static int
 380 node_append(struct mdoc *mdoc, struct mdoc_node *p)
 381 {
 382
 383         assert(mdoc->last);
 384         assert(mdoc->first);
 385         assert(MDOC_ROOT != p->type);
 386
 387         switch (mdoc->next) {
 388         case (MDOC_NEXT_SIBLING):
 389                 mdoc->last->next = p;
 390                 p->prev = mdoc->last;
 391                 p->parent = mdoc->last->parent;
 392                 break;
 393         case (MDOC_NEXT_CHILD):
 394                 mdoc->last->child = p;
 395                 p->parent = mdoc->last;
 396                 break;
 397         default:
 398                 abort();
 399                 /* NOTREACHED */
 400         }
 401
 402         p->parent->nchild++;
 403
 404         if ( ! mdoc_valid_pre(mdoc, p))
 405                 return(0);
 406         if ( ! mdoc_action_pre(mdoc, p))
 407                 return(0);
 408
 409         switch (p->type) {
 410         case (MDOC_HEAD):
 411                 assert(MDOC_BLOCK == p->parent->type);
 412                 p->parent->head = p;
 413                 break;
 414         case (MDOC_TAIL):
 415                 assert(MDOC_BLOCK == p->parent->type);
 416                 p->parent->tail = p;
 417                 break;
 418         case (MDOC_BODY):
 419                 assert(MDOC_BLOCK == p->parent->type);
 420                 p->parent->body = p;
 421                 break;
 422         default:
 423                 break;
 424         }
 425
 426         mdoc->last = p;
 427
 428         switch (p->type) {
 429         case (MDOC_TEXT):
 430                 if ( ! mdoc_valid_post(mdoc))
 431                         return(0);
 432                 if ( ! mdoc_action_post(mdoc))
 433                         return(0);
 434                 break;
 435         default:
 436                 break;
 437         }
 438
 439         return(1);
 440 }
 441
 442
 443 static struct mdoc_node *
 444 node_alloc(struct mdoc *m, int line, int pos,
 445                 enum mdoct tok, enum mdoc_type type)
 446 {
 447         struct mdoc_node *p;
 448
 449         p = mandoc_calloc(1, sizeof(struct mdoc_node));
 450         p->sec = m->lastsec;
 451         p->line = line;
 452         p->pos = pos;
 453         p->tok = tok;
 454         p->type = type;
 455
 456         return(p);
 457 }
 458
 459
 460 int
 461 mdoc_tail_alloc(struct mdoc *m, int line, int pos, enum mdoct tok)
 462 {
 463         struct mdoc_node *p;
 464
 465         p = node_alloc(m, line, pos, tok, MDOC_TAIL);
 466         if ( ! node_append(m, p))
 467                 return(0);
 468         m->next = MDOC_NEXT_CHILD;
 469         return(1);
 470 }
 471
 472
 473 int
 474 mdoc_head_alloc(struct mdoc *m, int line, int pos, enum mdoct tok)
 475 {
 476         struct mdoc_node *p;
 477
 478         assert(m->first);
 479         assert(m->last);
 480
 481         p = node_alloc(m, line, pos, tok, MDOC_HEAD);
 482         if ( ! node_append(m, p))
 483                 return(0);
 484         m->next = MDOC_NEXT_CHILD;
 485         return(1);
 486 }
 487
 488
 489 int
 490 mdoc_body_alloc(struct mdoc *m, int line, int pos, enum mdoct tok)
 491 {
 492         struct mdoc_node *p;
 493
 494         p = node_alloc(m, line, pos, tok, MDOC_BODY);
 495         if ( ! node_append(m, p))
 496                 return(0);
 497         m->next = MDOC_NEXT_CHILD;
 498         return(1);
 499 }
 500
 501
 502 int
 503 mdoc_block_alloc(struct mdoc *m, int line, int pos,
 504                 enum mdoct tok, struct mdoc_arg *args)
 505 {
 506         struct mdoc_node *p;
 507
 508         p = node_alloc(m, line, pos, tok, MDOC_BLOCK);
 509         p->args = args;
 510         if (p->args)
 511                 (args->refcnt)++;
 512         if ( ! node_append(m, p))
 513                 return(0);
 514         m->next = MDOC_NEXT_CHILD;
 515         return(1);
 516 }
 517
 518
 519 int
 520 mdoc_elem_alloc(struct mdoc *m, int line, int pos,
 521                 enum mdoct tok, struct mdoc_arg *args)
 522 {
 523         struct mdoc_node *p;
 524
 525         p = node_alloc(m, line, pos, tok, MDOC_ELEM);
 526         p->args = args;
 527         if (p->args)
 528                 (args->refcnt)++;
 529         if ( ! node_append(m, p))
 530                 return(0);
 531         m->next = MDOC_NEXT_CHILD;
 532         return(1);
 533 }
 534
 535
 536 static int
 537 pstring(struct mdoc *m, int line, int pos, const char *p, size_t len)
 538 {
 539         struct mdoc_node *n;
 540         size_t            sv;
 541
 542         n = node_alloc(m, line, pos, -1, MDOC_TEXT);
 543         n->string = mandoc_malloc(len + 1);
 544         sv = strlcpy(n->string, p, len + 1);
 545
 546         /* Prohibit truncation. */
 547         assert(sv < len + 1);
 548
 549         if ( ! node_append(m, n))
 550                 return(0);
 551         m->next = MDOC_NEXT_SIBLING;
 552         return(1);
 553 }
 554
 555
 556 int
 557 mdoc_word_alloc(struct mdoc *m, int line, int pos, const char *p)
 558 {
 559
 560         return(pstring(m, line, pos, p, strlen(p)));
 561 }
 562
 563
 564 void
 565 mdoc_node_free(struct mdoc_node *p)
 566 {
 567
 568         if (p->parent)
 569                 p->parent->nchild--;
 570         if (p->string)
 571                 free(p->string);
 572         if (p->args)
 573                 mdoc_argv_free(p->args);
 574         free(p);
 575 }
 576
 577
 578 void
 579 mdoc_node_freelist(struct mdoc_node *p)
 580 {
 581
 582         if (p->child)
 583                 mdoc_node_freelist(p->child);
 584         if (p->next)
 585                 mdoc_node_freelist(p->next);
 586
 587         assert(0 == p->nchild);
 588         mdoc_node_free(p);
 589 }
 590
 591
 592 /*
 593  * Parse free-form text, that is, a line that does not begin with the
 594  * control character.
 595  */
 596 static int
 597 parsetext(struct mdoc *m, int line, char *buf)
 598 {
 599         int              i, j;
 600         char             sv;
 601
 602         if (SEC_NONE == m->lastnamed)
 603                 return(mdoc_perr(m, line, 0, ETEXTPROL));
 604
 605         /*
 606          * If in literal mode, then pass the buffer directly to the
 607          * back-end, as it should be preserved as a single term.
 608          */
 609
 610         if (MDOC_LITERAL & m->flags)
 611                 return(mdoc_word_alloc(m, line, 0, buf));
 612
 613         /* Disallow blank/white-space lines in non-literal mode. */
 614
 615         for (i = 0; ' ' == buf[i]; i++)
 616                 /* Skip leading whitespace. */ ;
 617
 618         if ('\0' == buf[i]) {
 619                 if ( ! mdoc_pwarn(m, line, 0, ENOBLANK))
 620                         return(0);
 621                 /*
 622                  * Assume that a `Pp' should be inserted in the case of
 623                  * a blank line.  Technically, blank lines aren't
 624                  * allowed, but enough manuals assume this behaviour
 625                  * that we want to work around it.
 626                  */
 627                 if ( ! mdoc_elem_alloc(m, line, 0, MDOC_Pp, NULL))
 628                         return(0);
 629         }
 630
 631         /*
 632          * Break apart a free-form line into tokens.  Spaces are
 633          * stripped out of the input.
 634          */
 635
 636         for (j = i; buf[i]; i++) {
 637                 if (' ' != buf[i])
 638                         continue;
 639
 640                 /* Escaped whitespace. */
 641                 if (i && ' ' == buf[i] && '\\' == buf[i - 1])
 642                         continue;
 643
 644                 sv = buf[i];
 645                 buf[i++] = '\0';
 646
 647                 if ( ! pstring(m, line, j, &buf[j], (size_t)(i - j)))
 648                         return(0);
 649
 650                 /* Trailing whitespace?  Check at overwritten byte. */
 651
 652                 if (' ' == sv && '\0' == buf[i])
 653                         if ( ! mdoc_pwarn(m, line, i - 1, ETAILWS))
 654                                 return(0);
 655
 656                 for ( ; ' ' == buf[i]; i++)
 657                         /* Skip trailing whitespace. */ ;
 658
 659                 j = i;
 660
 661                 /* Trailing whitespace? */
 662
 663                 if (' ' == buf[i - 1] && '\0' == buf[i])
 664                         if ( ! mdoc_pwarn(m, line, i - 1, ETAILWS))
 665                                 return(0);
 666
 667                 if ('\0' == buf[i])
 668                         break;
 669         }
 670
 671         if (j != i && ! pstring(m, line, j, &buf[j], (size_t)(i - j)))
 672                 return(0);
 673
 674         m->next = MDOC_NEXT_SIBLING;
 675         return(1);
 676 }
 677
 678
 679
 680 static int
 681 macrowarn(struct mdoc *m, int ln, const char *buf)
 682 {
 683         if ( ! (MDOC_IGN_MACRO & m->pflags))
 684                 return(mdoc_verr(m, ln, 0,
 685                                 "unknown macro: %s%s",
 686                                 buf, strlen(buf) > 3 ? "..." : ""));
 687         return(mdoc_vwarn(m, ln, 0, "unknown macro: %s%s",
 688                                 buf, strlen(buf) > 3 ? "..." : ""));
 689 }
 690
 691
 692 /*
 693  * Parse a macro line, that is, a line beginning with the control
 694  * character.
 695  */
 696 int
 697 parsemacro(struct mdoc *m, int ln, char *buf)
 698 {
 699         int               i, j, c;
 700         char              mac[5];
 701
 702         /* Empty lines are ignored. */
 703
 704         if ('\0' == buf[1])
 705                 return(1);
 706
 707         i = 1;
 708
 709         /* Accept whitespace after the initial control char. */
 710
 711         if (' ' == buf[i]) {
 712                 i++;
 713                 while (buf[i] && ' ' == buf[i])
 714                         i++;
 715                 if ('\0' == buf[i])
 716                         return(1);
 717         }
 718
 719         /* Copy the first word into a nil-terminated buffer. */
 720
 721         for (j = 0; j < 4; j++, i++) {
 722                 if ('\0' == (mac[j] = buf[i]))
 723                         break;
 724                 else if (' ' == buf[i])
 725                         break;
 726
 727                 /* Check for invalid characters. */
 728
 729                 if (isgraph((u_char)buf[i]))
 730                         continue;
 731                 return(mdoc_perr(m, ln, i, EPRINT));
 732         }
 733
 734         mac[j] = 0;
 735
 736         if (j == 4 || j < 2) {
 737                 if ( ! macrowarn(m, ln, mac))
 738                         goto err;
 739                 return(1);
 740         }
 741
 742         if (MDOC_MAX == (c = mdoc_hash_find(mac))) {
 743                 if ( ! macrowarn(m, ln, mac))
 744                         goto err;
 745                 return(1);
 746         }
 747
 748         /* The macro is sane.  Jump to the next word. */
 749
 750         while (buf[i] && ' ' == buf[i])
 751                 i++;
 752
 753         /* Trailing whitespace? */
 754
 755         if ('\0' == buf[i] && ' ' == buf[i - 1])
 756                 if ( ! mdoc_pwarn(m, ln, i - 1, ETAILWS))
 757                         goto err;
 758
 759         /*
 760          * Begin recursive parse sequence.  Since we're at the start of
 761          * the line, we don't need to do callable/parseable checks.
 762          */
 763         if ( ! mdoc_macro(m, c, ln, 1, &i, buf))
 764                 goto err;
 765
 766         return(1);
 767
 768 err:    /* Error out. */
 769
 770         m->flags |= MDOC_HALT;
 771         return(0);
 772 }
 773
 774