Print this page
5051 import mdocml-1.12.3
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
Approved by: TBD
   1 /*      $Id: read.c,v 1.28 2012/02/16 20:51:31 joerg Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21 
  22 #ifdef HAVE_MMAP
  23 # include <sys/stat.h>
  24 # include <sys/mman.h>
  25 #endif
  26 
  27 #include <assert.h>
  28 #include <ctype.h>
  29 #include <fcntl.h>
  30 #include <stdarg.h>
  31 #include <stdint.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <unistd.h>
  36 
  37 #include "mandoc.h"
  38 #include "libmandoc.h"
  39 #include "mdoc.h"
  40 #include "man.h"
  41 #include "main.h"
  42 
  43 #ifndef MAP_FILE
  44 #define MAP_FILE        0
  45 #endif
  46 
  47 #define REPARSE_LIMIT   1000
  48 
  49 struct  buf {
  50         char             *buf; /* binary input buffer */
  51         size_t            sz; /* size of binary buffer */
  52 };
  53 
  54 struct  mparse {
  55         enum mandoclevel  file_status; /* status of current parse */
  56         enum mandoclevel  wlevel; /* ignore messages below this */
  57         int               line; /* line number in the file */
  58         enum mparset      inttype; /* which parser to use */
  59         struct man       *pman; /* persistent man parser */
  60         struct mdoc      *pmdoc; /* persistent mdoc parser */
  61         struct man       *man; /* man parser */
  62         struct mdoc      *mdoc; /* mdoc parser */
  63         struct roff      *roff; /* roff parser (!NULL) */
  64         int               reparse_count; /* finite interp. stack */
  65         mandocmsg         mmsg; /* warning/error message handler */
  66         void             *arg; /* argument to mmsg */
  67         const char       *file; 
  68         struct buf       *secondary;

  69 };
  70 
  71 static  void      resize_buf(struct buf *, size_t);
  72 static  void      mparse_buf_r(struct mparse *, struct buf, int);
  73 static  void      mparse_readfd_r(struct mparse *, int, const char *, int);
  74 static  void      pset(const char *, int, struct mparse *);
  75 static  int       read_whole_file(const char *, int, struct buf *, int *);
  76 static  void      mparse_end(struct mparse *);


  77 
  78 static  const enum mandocerr    mandoclimits[MANDOCLEVEL_MAX] = {
  79         MANDOCERR_OK,
  80         MANDOCERR_WARNING,
  81         MANDOCERR_WARNING,
  82         MANDOCERR_ERROR,
  83         MANDOCERR_FATAL,
  84         MANDOCERR_MAX,
  85         MANDOCERR_MAX
  86 };
  87 
  88 static  const char * const      mandocerrs[MANDOCERR_MAX] = {
  89         "ok",
  90 
  91         "generic warning",
  92 
  93         /* related to the prologue */
  94         "no title in document",
  95         "document title should be all caps",
  96         "unknown manual section",

  97         "date missing, using today's date",
  98         "cannot parse date, using it verbatim",
  99         "prologue macros out of order",
 100         "duplicate prologue macro",
 101         "macro not allowed in prologue",
 102         "macro not allowed in body",
 103 
 104         /* related to document structure */
 105         ".so is fragile, better use ln(1)",
 106         "NAME section must come first",
 107         "bad NAME section contents",
 108         "manual name not yet set",
 109         "sections out of conventional order",
 110         "duplicate section name",
 111         "section not in conventional manual section",
 112 
 113         /* related to macros and nesting */
 114         "skipping obsolete macro",
 115         "skipping paragraph macro",

 116         "skipping no-space macro",
 117         "blocks badly nested",
 118         "child violates parent syntax",
 119         "nested displays are not portable",
 120         "already in literal mode",
 121         "line scope broken",
 122 
 123         /* related to missing macro arguments */
 124         "skipping empty macro",
 125         "argument count wrong",
 126         "missing display type",
 127         "list type must come first",
 128         "tag lists require a width argument",
 129         "missing font type",
 130         "skipping end of block that is not open",
 131 
 132         /* related to bad macro arguments */
 133         "skipping argument",
 134         "duplicate argument",
 135         "duplicate display type",


 156         /* related to equations */
 157         "unexpected equation scope closure",
 158         "equation scope open on exit",
 159         "overlapping equation scopes",
 160         "unexpected end of equation",
 161         "equation syntax error",
 162 
 163         /* related to tables */
 164         "bad table syntax",
 165         "bad table option",
 166         "bad table layout",
 167         "no table layout cells specified",
 168         "no table data cells specified",
 169         "ignore data in cell",
 170         "data block still open",
 171         "ignoring extra data cells",
 172 
 173         "input stack limit exceeded, infinite loop?",
 174         "skipping bad character",
 175         "escaped character not allowed in a name",

 176         "skipping text before the first section header",
 177         "skipping unknown macro",
 178         "NOT IMPLEMENTED, please use groff: skipping request",
 179         "argument count wrong",

 180         "skipping end of block that is not open",
 181         "missing end of block",
 182         "scope open on exit",
 183         "uname(3) system call failed",
 184         "macro requires line argument(s)",
 185         "macro requires body argument(s)",
 186         "macro requires argument(s)",

 187         "missing list type",
 188         "line argument(s) will be lost",
 189         "body argument(s) will be lost",
 190 
 191         "generic fatal error",
 192 
 193         "not a manual",
 194         "column syntax is inconsistent",
 195         "NOT IMPLEMENTED: .Bd -file",
 196         "argument count wrong, violates syntax",
 197         "child violates parent syntax",
 198         "argument count wrong, violates syntax",
 199         "NOT IMPLEMENTED: .so with absolute path or \"..\"",
 200         "no document body",
 201         "no document prologue",
 202         "static buffer exhausted",
 203 };
 204 
 205 static  const char * const      mandoclevels[MANDOCLEVEL_MAX] = {
 206         "SUCCESS",


 230          * passed in by command-line (-man, -mdoc), then use that
 231          * explicitly.  If passed as -mandoc, then try to guess from the
 232          * line: either skip dot-lines, use -mdoc when finding `.Dt', or
 233          * default to -man, which is more lenient.
 234          *
 235          * Separate out pmdoc/pman from mdoc/man: the first persists
 236          * through all parsers, while the latter is used per-parse.
 237          */
 238 
 239         if ('.' == buf[0] || '\'' == buf[0]) {
 240                 for (i = 1; buf[i]; i++)
 241                         if (' ' != buf[i] && '\t' != buf[i])
 242                                 break;
 243                 if ('\0' == buf[i])
 244                         return;
 245         }
 246 
 247         switch (curp->inttype) {
 248         case (MPARSE_MDOC):
 249                 if (NULL == curp->pmdoc) 
 250                         curp->pmdoc = mdoc_alloc(curp->roff, curp);

 251                 assert(curp->pmdoc);
 252                 curp->mdoc = curp->pmdoc;
 253                 return;
 254         case (MPARSE_MAN):
 255                 if (NULL == curp->pman) 
 256                         curp->pman = man_alloc(curp->roff, curp);
 257                 assert(curp->pman);
 258                 curp->man = curp->pman;
 259                 return;
 260         default:
 261                 break;
 262         }
 263 
 264         if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {
 265                 if (NULL == curp->pmdoc) 
 266                         curp->pmdoc = mdoc_alloc(curp->roff, curp);

 267                 assert(curp->pmdoc);
 268                 curp->mdoc = curp->pmdoc;
 269                 return;
 270         } 
 271 
 272         if (NULL == curp->pman) 
 273                 curp->pman = man_alloc(curp->roff, curp);
 274         assert(curp->pman);
 275         curp->man = curp->pman;
 276 }
 277 
 278 /*
 279  * Main parse routine for an opened file.  This is called for each
 280  * opened file and simply loops around the full input file, possibly
 281  * nesting (i.e., with `so').
 282  */
 283 static void
 284 mparse_buf_r(struct mparse *curp, struct buf blk, int start)
 285 {
 286         const struct tbl_span   *span;


 306                 }
 307 
 308                 while (i < (int)blk.sz && (start || '\0' != blk.buf[i])) {
 309 
 310                         /*
 311                          * When finding an unescaped newline character,
 312                          * leave the character loop to process the line.
 313                          * Skip a preceding carriage return, if any.
 314                          */
 315 
 316                         if ('\r' == blk.buf[i] && i + 1 < (int)blk.sz &&
 317                             '\n' == blk.buf[i + 1])
 318                                 ++i;
 319                         if ('\n' == blk.buf[i]) {
 320                                 ++i;
 321                                 ++lnn;
 322                                 break;
 323                         }
 324 
 325                         /* 









 326                          * Warn about bogus characters.  If you're using
 327                          * non-ASCII encoding, you're screwing your
 328                          * readers.  Since I'd rather this not happen,
 329                          * I'll be helpful and replace these characters
 330                          * with "?", so we don't display gibberish.
 331                          * Note to manual writers: use special characters.
 332                          */
 333 
 334                         c = (unsigned char) blk.buf[i];
 335 
 336                         if ( ! (isascii(c) && 
 337                                         (isgraph(c) || isblank(c)))) {
 338                                 mandoc_msg(MANDOCERR_BADCHAR, curp,
 339                                                 curp->line, pos, NULL);
 340                                 i++;
 341                                 if (pos >= (int)ln.sz)
 342                                         resize_buf(&ln, 256);
 343                                 ln.buf[pos++] = '?';
 344                                 continue;
 345                         }
 346 
 347                         /* Trailing backslash = a plain char. */
 348 
 349                         if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {
 350                                 if (pos >= (int)ln.sz)
 351                                         resize_buf(&ln, 256);
 352                                 ln.buf[pos++] = blk.buf[i++];
 353                                 continue;
 354                         }
 355 
 356                         /*
 357                          * Found escape and at least one other character.
 358                          * When it's a newline character, skip it.
 359                          * When there is a carriage return in between,
 360                          * skip that one as well.
 361                          */
 362 
 363                         if ('\r' == blk.buf[i + 1] && i + 2 < (int)blk.sz &&
 364                             '\n' == blk.buf[i + 2])
 365                                 ++i;
 366                         if ('\n' == blk.buf[i + 1]) {
 367                                 i += 2;
 368                                 ++lnn;
 369                                 continue;
 370                         }
 371 


 373                                 i += 2;
 374                                 /* Comment, skip to end of line */
 375                                 for (; i < (int)blk.sz; ++i) {
 376                                         if ('\n' == blk.buf[i]) {
 377                                                 ++i;
 378                                                 ++lnn;
 379                                                 break;
 380                                         }
 381                                 }
 382 
 383                                 /* Backout trailing whitespaces */
 384                                 for (; pos > 0; --pos) {
 385                                         if (ln.buf[pos - 1] != ' ')
 386                                                 break;
 387                                         if (pos > 2 && ln.buf[pos - 2] == '\\')
 388                                                 break;
 389                                 }
 390                                 break;
 391                         }
 392 
 393                         /* Some other escape sequence, copy & cont. */
 394 
 395                         if (pos + 1 >= (int)ln.sz)
 396                                 resize_buf(&ln, 256);
 397 











 398                         ln.buf[pos++] = blk.buf[i++];
 399                         ln.buf[pos++] = blk.buf[i++];
 400                 }
 401 
 402                 if (pos >= (int)ln.sz)
 403                         resize_buf(&ln, 256);
 404 
 405                 ln.buf[pos] = '\0';
 406 
 407                 /*
 408                  * A significant amount of complexity is contained by
 409                  * the roff preprocessor.  It's line-oriented but can be
 410                  * expressed on one line, so we need at times to
 411                  * readjust our starting point and re-run it.  The roff
 412                  * preprocessor can also readjust the buffers with new
 413                  * data, so we pass them in wholesale.
 414                  */
 415 
 416                 of = 0;
 417 


 452                         continue;
 453                 case (ROFF_APPEND):
 454                         pos = (int)strlen(ln.buf);
 455                         continue;
 456                 case (ROFF_RERUN):
 457                         goto rerun;
 458                 case (ROFF_IGN):
 459                         pos = 0;
 460                         continue;
 461                 case (ROFF_ERR):
 462                         assert(MANDOCLEVEL_FATAL <= curp->file_status);
 463                         break;
 464                 case (ROFF_SO):
 465                         /*
 466                          * We remove `so' clauses from our lookaside
 467                          * buffer because we're going to descend into
 468                          * the file recursively.
 469                          */
 470                         if (curp->secondary) 
 471                                 curp->secondary->sz -= pos + 1;
 472                         mparse_readfd_r(curp, -1, ln.buf + of, 1);
 473                         if (MANDOCLEVEL_FATAL <= curp->file_status)
 474                                 break;
 475                         pos = 0;
 476                         continue;
 477                 default:
 478                         break;
 479                 }
 480 
 481                 /*
 482                  * If we encounter errors in the recursive parse, make
 483                  * sure we don't continue parsing.
 484                  */
 485 
 486                 if (MANDOCLEVEL_FATAL <= curp->file_status)
 487                         break;
 488 
 489                 /*
 490                  * If input parsers have not been allocated, do so now.
 491                  * We keep these instanced between parsers, but set them
 492                  * locally per parse routine since we can use different


 558         struct stat      st;
 559         if (-1 == fstat(fd, &st)) {
 560                 perror(file);
 561                 return(0);
 562         }
 563 
 564         /*
 565          * If we're a regular file, try just reading in the whole entry
 566          * via mmap().  This is faster than reading it into blocks, and
 567          * since each file is only a few bytes to begin with, I'm not
 568          * concerned that this is going to tank any machines.
 569          */
 570 
 571         if (S_ISREG(st.st_mode)) {
 572                 if (st.st_size >= (1U << 31)) {
 573                         fprintf(stderr, "%s: input too large\n", file);
 574                         return(0);
 575                 }
 576                 *with_mmap = 1;
 577                 fb->sz = (size_t)st.st_size;
 578                 fb->buf = mmap(NULL, fb->sz, PROT_READ, 
 579                                 MAP_FILE|MAP_SHARED, fd, 0);
 580                 if (fb->buf != MAP_FAILED)
 581                         return(1);
 582         }
 583 #endif
 584 
 585         /*
 586          * If this isn't a regular file (like, say, stdin), then we must
 587          * go the old way and just read things in bit by bit.
 588          */
 589 
 590         *with_mmap = 0;
 591         off = 0;
 592         fb->sz = 0;
 593         fb->buf = NULL;
 594         for (;;) {
 595                 if (off == fb->sz) {
 596                         if (fb->sz == (1U << 31)) {
 597                                 fprintf(stderr, "%s: input too large\n", file);
 598                                 break;
 599                         }


 626         if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {
 627                 assert(MANDOCLEVEL_FATAL <= curp->file_status);
 628                 return;
 629         }
 630 
 631         if (curp->man && ! man_endparse(curp->man)) {
 632                 assert(MANDOCLEVEL_FATAL <= curp->file_status);
 633                 return;
 634         }
 635 
 636         if ( ! (curp->man || curp->mdoc)) {
 637                 mandoc_msg(MANDOCERR_NOTMANUAL, curp, 1, 0, NULL);
 638                 curp->file_status = MANDOCLEVEL_FATAL;
 639                 return;
 640         }
 641 
 642         roff_endparse(curp->roff);
 643 }
 644 
 645 static void
 646 mparse_parse_buffer(struct mparse *curp, struct buf blk, const char *file,
 647                 int re)
 648 {
 649         const char      *svfile;

 650 





 651         /* Line number is per-file. */
 652         svfile = curp->file;
 653         curp->file = file;
 654         curp->line = 1;

 655 
 656         mparse_buf_r(curp, blk, 1);
 657 
 658         if (0 == re && MANDOCLEVEL_FATAL > curp->file_status)
 659                 mparse_end(curp);
 660 
 661         curp->file = svfile;
 662 }
 663 
 664 enum mandoclevel
 665 mparse_readmem(struct mparse *curp, const void *buf, size_t len,
 666                 const char *file)
 667 {
 668         struct buf blk;
 669 
 670         blk.buf = UNCONST(buf);
 671         blk.sz = len;
 672 
 673         mparse_parse_buffer(curp, blk, file, 0);
 674         return(curp->file_status);
 675 }
 676 
 677 static void
 678 mparse_readfd_r(struct mparse *curp, int fd, const char *file, int re)
 679 {
 680         struct buf       blk;
 681         int              with_mmap;
 682 
 683         if (-1 == fd)
 684                 if (-1 == (fd = open(file, O_RDONLY, 0))) {
 685                         perror(file);
 686                         curp->file_status = MANDOCLEVEL_SYSERR;
 687                         return;
 688                 }
 689         /*
 690          * Run for each opened file; may be called more than once for
 691          * each full parse sequence if the opened file is nested (i.e.,
 692          * from `so').  Simply sucks in the whole file and moves into
 693          * the parse phase for the file.
 694          */
 695 
 696         if ( ! read_whole_file(file, fd, &blk, &with_mmap)) {
 697                 curp->file_status = MANDOCLEVEL_SYSERR;
 698                 return;
 699         }
 700 
 701         mparse_parse_buffer(curp, blk, file, re);
 702 
 703 #ifdef  HAVE_MMAP
 704         if (with_mmap)
 705                 munmap(blk.buf, blk.sz);
 706         else
 707 #endif
 708                 free(blk.buf);
 709 
 710         if (STDIN_FILENO != fd && -1 == close(fd))
 711                 perror(file);
 712 }
 713 
 714 enum mandoclevel
 715 mparse_readfd(struct mparse *curp, int fd, const char *file)
 716 {
 717 
 718         mparse_readfd_r(curp, fd, file, 0);
 719         return(curp->file_status);
 720 }
 721 
 722 struct mparse *
 723 mparse_alloc(enum mparset inttype, enum mandoclevel wlevel, mandocmsg mmsg, void *arg)

 724 {
 725         struct mparse   *curp;
 726 
 727         assert(wlevel <= MANDOCLEVEL_FATAL);
 728 
 729         curp = mandoc_calloc(1, sizeof(struct mparse));
 730 
 731         curp->wlevel = wlevel;
 732         curp->mmsg = mmsg;
 733         curp->arg = arg;
 734         curp->inttype = inttype;

 735 
 736         curp->roff = roff_alloc(curp);
 737         return(curp);
 738 }
 739 
 740 void
 741 mparse_reset(struct mparse *curp)
 742 {
 743 
 744         roff_reset(curp->roff);
 745 
 746         if (curp->mdoc)
 747                 mdoc_reset(curp->mdoc);
 748         if (curp->man)
 749                 man_reset(curp->man);
 750         if (curp->secondary)
 751                 curp->secondary->sz = 0;
 752 
 753         curp->file_status = MANDOCLEVEL_OK;
 754         curp->mdoc = NULL;
 755         curp->man = NULL;
 756 }


   1 /*      $Id: read.c,v 1.39 2013/09/16 00:25:07 schwarze Exp $ */
   2 /*
   3  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
   4  * Copyright (c) 2010, 2011, 2012, 2013 Ingo Schwarze <schwarze@openbsd.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21 
  22 #ifdef HAVE_MMAP
  23 # include <sys/stat.h>
  24 # include <sys/mman.h>
  25 #endif
  26 
  27 #include <assert.h>
  28 #include <ctype.h>
  29 #include <fcntl.h>
  30 #include <stdarg.h>
  31 #include <stdint.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <unistd.h>
  36 
  37 #include "mandoc.h"
  38 #include "libmandoc.h"
  39 #include "mdoc.h"
  40 #include "man.h"
  41 #include "main.h"
  42 




  43 #define REPARSE_LIMIT   1000
  44 
  45 struct  buf {
  46         char             *buf; /* binary input buffer */
  47         size_t            sz; /* size of binary buffer */
  48 };
  49 
  50 struct  mparse {
  51         enum mandoclevel  file_status; /* status of current parse */
  52         enum mandoclevel  wlevel; /* ignore messages below this */
  53         int               line; /* line number in the file */
  54         enum mparset      inttype; /* which parser to use */
  55         struct man       *pman; /* persistent man parser */
  56         struct mdoc      *pmdoc; /* persistent mdoc parser */
  57         struct man       *man; /* man parser */
  58         struct mdoc      *mdoc; /* mdoc parser */
  59         struct roff      *roff; /* roff parser (!NULL) */
  60         int               reparse_count; /* finite interp. stack */
  61         mandocmsg         mmsg; /* warning/error message handler */
  62         void             *arg; /* argument to mmsg */
  63         const char       *file; 
  64         struct buf       *secondary;
  65         char             *defos; /* default operating system */
  66 };
  67 
  68 static  void      resize_buf(struct buf *, size_t);
  69 static  void      mparse_buf_r(struct mparse *, struct buf, int);

  70 static  void      pset(const char *, int, struct mparse *);
  71 static  int       read_whole_file(const char *, int, struct buf *, int *);
  72 static  void      mparse_end(struct mparse *);
  73 static  void      mparse_parse_buffer(struct mparse *, struct buf,
  74                         const char *);
  75 
  76 static  const enum mandocerr    mandoclimits[MANDOCLEVEL_MAX] = {
  77         MANDOCERR_OK,
  78         MANDOCERR_WARNING,
  79         MANDOCERR_WARNING,
  80         MANDOCERR_ERROR,
  81         MANDOCERR_FATAL,
  82         MANDOCERR_MAX,
  83         MANDOCERR_MAX
  84 };
  85 
  86 static  const char * const      mandocerrs[MANDOCERR_MAX] = {
  87         "ok",
  88 
  89         "generic warning",
  90 
  91         /* related to the prologue */
  92         "no title in document",
  93         "document title should be all caps",
  94         "unknown manual section",
  95         "unknown manual volume or arch",
  96         "date missing, using today's date",
  97         "cannot parse date, using it verbatim",
  98         "prologue macros out of order",
  99         "duplicate prologue macro",
 100         "macro not allowed in prologue",
 101         "macro not allowed in body",
 102 
 103         /* related to document structure */
 104         ".so is fragile, better use ln(1)",
 105         "NAME section must come first",
 106         "bad NAME section contents",

 107         "sections out of conventional order",
 108         "duplicate section name",
 109         "section header suited to sections 2, 3, and 9 only",
 110 
 111         /* related to macros and nesting */
 112         "skipping obsolete macro",
 113         "skipping paragraph macro",
 114         "moving paragraph macro out of list",
 115         "skipping no-space macro",
 116         "blocks badly nested",
 117         "child violates parent syntax",
 118         "nested displays are not portable",
 119         "already in literal mode",
 120         "line scope broken",
 121 
 122         /* related to missing macro arguments */
 123         "skipping empty macro",
 124         "argument count wrong",
 125         "missing display type",
 126         "list type must come first",
 127         "tag lists require a width argument",
 128         "missing font type",
 129         "skipping end of block that is not open",
 130 
 131         /* related to bad macro arguments */
 132         "skipping argument",
 133         "duplicate argument",
 134         "duplicate display type",


 155         /* related to equations */
 156         "unexpected equation scope closure",
 157         "equation scope open on exit",
 158         "overlapping equation scopes",
 159         "unexpected end of equation",
 160         "equation syntax error",
 161 
 162         /* related to tables */
 163         "bad table syntax",
 164         "bad table option",
 165         "bad table layout",
 166         "no table layout cells specified",
 167         "no table data cells specified",
 168         "ignore data in cell",
 169         "data block still open",
 170         "ignoring extra data cells",
 171 
 172         "input stack limit exceeded, infinite loop?",
 173         "skipping bad character",
 174         "escaped character not allowed in a name",
 175         "manual name not yet set",
 176         "skipping text before the first section header",
 177         "skipping unknown macro",
 178         "NOT IMPLEMENTED, please use groff: skipping request",
 179         "argument count wrong",
 180         "skipping column outside column list",
 181         "skipping end of block that is not open",
 182         "missing end of block",
 183         "scope open on exit",
 184         "uname(3) system call failed",
 185         "macro requires line argument(s)",
 186         "macro requires body argument(s)",
 187         "macro requires argument(s)",
 188         "request requires a numeric argument",
 189         "missing list type",
 190         "line argument(s) will be lost",
 191         "body argument(s) will be lost",
 192 
 193         "generic fatal error",
 194 
 195         "not a manual",
 196         "column syntax is inconsistent",
 197         "NOT IMPLEMENTED: .Bd -file",
 198         "argument count wrong, violates syntax",
 199         "child violates parent syntax",
 200         "argument count wrong, violates syntax",
 201         "NOT IMPLEMENTED: .so with absolute path or \"..\"",
 202         "no document body",
 203         "no document prologue",
 204         "static buffer exhausted",
 205 };
 206 
 207 static  const char * const      mandoclevels[MANDOCLEVEL_MAX] = {
 208         "SUCCESS",


 232          * passed in by command-line (-man, -mdoc), then use that
 233          * explicitly.  If passed as -mandoc, then try to guess from the
 234          * line: either skip dot-lines, use -mdoc when finding `.Dt', or
 235          * default to -man, which is more lenient.
 236          *
 237          * Separate out pmdoc/pman from mdoc/man: the first persists
 238          * through all parsers, while the latter is used per-parse.
 239          */
 240 
 241         if ('.' == buf[0] || '\'' == buf[0]) {
 242                 for (i = 1; buf[i]; i++)
 243                         if (' ' != buf[i] && '\t' != buf[i])
 244                                 break;
 245                 if ('\0' == buf[i])
 246                         return;
 247         }
 248 
 249         switch (curp->inttype) {
 250         case (MPARSE_MDOC):
 251                 if (NULL == curp->pmdoc) 
 252                         curp->pmdoc = mdoc_alloc(curp->roff, curp,
 253                                         curp->defos);
 254                 assert(curp->pmdoc);
 255                 curp->mdoc = curp->pmdoc;
 256                 return;
 257         case (MPARSE_MAN):
 258                 if (NULL == curp->pman) 
 259                         curp->pman = man_alloc(curp->roff, curp);
 260                 assert(curp->pman);
 261                 curp->man = curp->pman;
 262                 return;
 263         default:
 264                 break;
 265         }
 266 
 267         if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {
 268                 if (NULL == curp->pmdoc) 
 269                         curp->pmdoc = mdoc_alloc(curp->roff, curp,
 270                                         curp->defos);
 271                 assert(curp->pmdoc);
 272                 curp->mdoc = curp->pmdoc;
 273                 return;
 274         } 
 275 
 276         if (NULL == curp->pman) 
 277                 curp->pman = man_alloc(curp->roff, curp);
 278         assert(curp->pman);
 279         curp->man = curp->pman;
 280 }
 281 
 282 /*
 283  * Main parse routine for an opened file.  This is called for each
 284  * opened file and simply loops around the full input file, possibly
 285  * nesting (i.e., with `so').
 286  */
 287 static void
 288 mparse_buf_r(struct mparse *curp, struct buf blk, int start)
 289 {
 290         const struct tbl_span   *span;


 310                 }
 311 
 312                 while (i < (int)blk.sz && (start || '\0' != blk.buf[i])) {
 313 
 314                         /*
 315                          * When finding an unescaped newline character,
 316                          * leave the character loop to process the line.
 317                          * Skip a preceding carriage return, if any.
 318                          */
 319 
 320                         if ('\r' == blk.buf[i] && i + 1 < (int)blk.sz &&
 321                             '\n' == blk.buf[i + 1])
 322                                 ++i;
 323                         if ('\n' == blk.buf[i]) {
 324                                 ++i;
 325                                 ++lnn;
 326                                 break;
 327                         }
 328 
 329                         /*
 330                          * Make sure we have space for at least
 331                          * one backslash and one other character
 332                          * and the trailing NUL byte.
 333                          */
 334 
 335                         if (pos + 2 >= (int)ln.sz)
 336                                 resize_buf(&ln, 256);
 337 
 338                         /* 
 339                          * Warn about bogus characters.  If you're using
 340                          * non-ASCII encoding, you're screwing your
 341                          * readers.  Since I'd rather this not happen,
 342                          * I'll be helpful and replace these characters
 343                          * with "?", so we don't display gibberish.
 344                          * Note to manual writers: use special characters.
 345                          */
 346 
 347                         c = (unsigned char) blk.buf[i];
 348 
 349                         if ( ! (isascii(c) && 
 350                                         (isgraph(c) || isblank(c)))) {
 351                                 mandoc_msg(MANDOCERR_BADCHAR, curp,
 352                                                 curp->line, pos, NULL);
 353                                 i++;


 354                                 ln.buf[pos++] = '?';
 355                                 continue;
 356                         }
 357 
 358                         /* Trailing backslash = a plain char. */
 359 
 360                         if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {


 361                                 ln.buf[pos++] = blk.buf[i++];
 362                                 continue;
 363                         }
 364 
 365                         /*
 366                          * Found escape and at least one other character.
 367                          * When it's a newline character, skip it.
 368                          * When there is a carriage return in between,
 369                          * skip that one as well.
 370                          */
 371 
 372                         if ('\r' == blk.buf[i + 1] && i + 2 < (int)blk.sz &&
 373                             '\n' == blk.buf[i + 2])
 374                                 ++i;
 375                         if ('\n' == blk.buf[i + 1]) {
 376                                 i += 2;
 377                                 ++lnn;
 378                                 continue;
 379                         }
 380 


 382                                 i += 2;
 383                                 /* Comment, skip to end of line */
 384                                 for (; i < (int)blk.sz; ++i) {
 385                                         if ('\n' == blk.buf[i]) {
 386                                                 ++i;
 387                                                 ++lnn;
 388                                                 break;
 389                                         }
 390                                 }
 391 
 392                                 /* Backout trailing whitespaces */
 393                                 for (; pos > 0; --pos) {
 394                                         if (ln.buf[pos - 1] != ' ')
 395                                                 break;
 396                                         if (pos > 2 && ln.buf[pos - 2] == '\\')
 397                                                 break;
 398                                 }
 399                                 break;
 400                         }
 401 
 402                         /* Catch escaped bogus characters. */
 403 
 404                         c = (unsigned char) blk.buf[i+1];

 405 
 406                         if ( ! (isascii(c) && 
 407                                         (isgraph(c) || isblank(c)))) {
 408                                 mandoc_msg(MANDOCERR_BADCHAR, curp,
 409                                                 curp->line, pos, NULL);
 410                                 i += 2;
 411                                 ln.buf[pos++] = '?';
 412                                 continue;
 413                         }
 414 
 415                         /* Some other escape sequence, copy & cont. */
 416 
 417                         ln.buf[pos++] = blk.buf[i++];
 418                         ln.buf[pos++] = blk.buf[i++];
 419                 }
 420 
 421                 if (pos >= (int)ln.sz)
 422                         resize_buf(&ln, 256);
 423 
 424                 ln.buf[pos] = '\0';
 425 
 426                 /*
 427                  * A significant amount of complexity is contained by
 428                  * the roff preprocessor.  It's line-oriented but can be
 429                  * expressed on one line, so we need at times to
 430                  * readjust our starting point and re-run it.  The roff
 431                  * preprocessor can also readjust the buffers with new
 432                  * data, so we pass them in wholesale.
 433                  */
 434 
 435                 of = 0;
 436 


 471                         continue;
 472                 case (ROFF_APPEND):
 473                         pos = (int)strlen(ln.buf);
 474                         continue;
 475                 case (ROFF_RERUN):
 476                         goto rerun;
 477                 case (ROFF_IGN):
 478                         pos = 0;
 479                         continue;
 480                 case (ROFF_ERR):
 481                         assert(MANDOCLEVEL_FATAL <= curp->file_status);
 482                         break;
 483                 case (ROFF_SO):
 484                         /*
 485                          * We remove `so' clauses from our lookaside
 486                          * buffer because we're going to descend into
 487                          * the file recursively.
 488                          */
 489                         if (curp->secondary) 
 490                                 curp->secondary->sz -= pos + 1;
 491                         mparse_readfd(curp, -1, ln.buf + of);
 492                         if (MANDOCLEVEL_FATAL <= curp->file_status)
 493                                 break;
 494                         pos = 0;
 495                         continue;
 496                 default:
 497                         break;
 498                 }
 499 
 500                 /*
 501                  * If we encounter errors in the recursive parse, make
 502                  * sure we don't continue parsing.
 503                  */
 504 
 505                 if (MANDOCLEVEL_FATAL <= curp->file_status)
 506                         break;
 507 
 508                 /*
 509                  * If input parsers have not been allocated, do so now.
 510                  * We keep these instanced between parsers, but set them
 511                  * locally per parse routine since we can use different


 577         struct stat      st;
 578         if (-1 == fstat(fd, &st)) {
 579                 perror(file);
 580                 return(0);
 581         }
 582 
 583         /*
 584          * If we're a regular file, try just reading in the whole entry
 585          * via mmap().  This is faster than reading it into blocks, and
 586          * since each file is only a few bytes to begin with, I'm not
 587          * concerned that this is going to tank any machines.
 588          */
 589 
 590         if (S_ISREG(st.st_mode)) {
 591                 if (st.st_size >= (1U << 31)) {
 592                         fprintf(stderr, "%s: input too large\n", file);
 593                         return(0);
 594                 }
 595                 *with_mmap = 1;
 596                 fb->sz = (size_t)st.st_size;
 597                 fb->buf = mmap(NULL, fb->sz, PROT_READ, MAP_SHARED, fd, 0);

 598                 if (fb->buf != MAP_FAILED)
 599                         return(1);
 600         }
 601 #endif
 602 
 603         /*
 604          * If this isn't a regular file (like, say, stdin), then we must
 605          * go the old way and just read things in bit by bit.
 606          */
 607 
 608         *with_mmap = 0;
 609         off = 0;
 610         fb->sz = 0;
 611         fb->buf = NULL;
 612         for (;;) {
 613                 if (off == fb->sz) {
 614                         if (fb->sz == (1U << 31)) {
 615                                 fprintf(stderr, "%s: input too large\n", file);
 616                                 break;
 617                         }


 644         if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {
 645                 assert(MANDOCLEVEL_FATAL <= curp->file_status);
 646                 return;
 647         }
 648 
 649         if (curp->man && ! man_endparse(curp->man)) {
 650                 assert(MANDOCLEVEL_FATAL <= curp->file_status);
 651                 return;
 652         }
 653 
 654         if ( ! (curp->man || curp->mdoc)) {
 655                 mandoc_msg(MANDOCERR_NOTMANUAL, curp, 1, 0, NULL);
 656                 curp->file_status = MANDOCLEVEL_FATAL;
 657                 return;
 658         }
 659 
 660         roff_endparse(curp->roff);
 661 }
 662 
 663 static void
 664 mparse_parse_buffer(struct mparse *curp, struct buf blk, const char *file)

 665 {
 666         const char      *svfile;
 667         static int       recursion_depth;
 668 
 669         if (64 < recursion_depth) {
 670                 mandoc_msg(MANDOCERR_ROFFLOOP, curp, curp->line, 0, NULL);
 671                 return;
 672         }
 673 
 674         /* Line number is per-file. */
 675         svfile = curp->file;
 676         curp->file = file;
 677         curp->line = 1;
 678         recursion_depth++;
 679 
 680         mparse_buf_r(curp, blk, 1);
 681 
 682         if (0 == --recursion_depth && MANDOCLEVEL_FATAL > curp->file_status)
 683                 mparse_end(curp);
 684 
 685         curp->file = svfile;
 686 }
 687 
 688 enum mandoclevel
 689 mparse_readmem(struct mparse *curp, const void *buf, size_t len,
 690                 const char *file)
 691 {
 692         struct buf blk;
 693 
 694         blk.buf = UNCONST(buf);
 695         blk.sz = len;
 696 
 697         mparse_parse_buffer(curp, blk, file);
 698         return(curp->file_status);
 699 }
 700 
 701 enum mandoclevel
 702 mparse_readfd(struct mparse *curp, int fd, const char *file)
 703 {
 704         struct buf       blk;
 705         int              with_mmap;
 706 
 707         if (-1 == fd)
 708                 if (-1 == (fd = open(file, O_RDONLY, 0))) {
 709                         perror(file);
 710                         curp->file_status = MANDOCLEVEL_SYSERR;
 711                         goto out;
 712                 }
 713         /*
 714          * Run for each opened file; may be called more than once for
 715          * each full parse sequence if the opened file is nested (i.e.,
 716          * from `so').  Simply sucks in the whole file and moves into
 717          * the parse phase for the file.
 718          */
 719 
 720         if ( ! read_whole_file(file, fd, &blk, &with_mmap)) {
 721                 curp->file_status = MANDOCLEVEL_SYSERR;
 722                 goto out;
 723         }
 724 
 725         mparse_parse_buffer(curp, blk, file);
 726 
 727 #ifdef  HAVE_MMAP
 728         if (with_mmap)
 729                 munmap(blk.buf, blk.sz);
 730         else
 731 #endif
 732                 free(blk.buf);
 733 
 734         if (STDIN_FILENO != fd && -1 == close(fd))
 735                 perror(file);
 736 out:






 737         return(curp->file_status);
 738 }
 739 
 740 struct mparse *
 741 mparse_alloc(enum mparset inttype, enum mandoclevel wlevel,
 742                 mandocmsg mmsg, void *arg, char *defos)
 743 {
 744         struct mparse   *curp;
 745 
 746         assert(wlevel <= MANDOCLEVEL_FATAL);
 747 
 748         curp = mandoc_calloc(1, sizeof(struct mparse));
 749 
 750         curp->wlevel = wlevel;
 751         curp->mmsg = mmsg;
 752         curp->arg = arg;
 753         curp->inttype = inttype;
 754         curp->defos = defos;
 755 
 756         curp->roff = roff_alloc(inttype, curp);
 757         return(curp);
 758 }
 759 
 760 void
 761 mparse_reset(struct mparse *curp)
 762 {
 763 
 764         roff_reset(curp->roff);
 765 
 766         if (curp->mdoc)
 767                 mdoc_reset(curp->mdoc);
 768         if (curp->man)
 769                 man_reset(curp->man);
 770         if (curp->secondary)
 771                 curp->secondary->sz = 0;
 772 
 773         curp->file_status = MANDOCLEVEL_OK;
 774         curp->mdoc = NULL;
 775         curp->man = NULL;
 776 }