[BACK]Return to read.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/read.c between version 1.102 and 1.117

version 1.102, 2014/11/30 02:36:38 version 1.117, 2015/01/26 13:03:48
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2010-2014 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2010-2015 Ingo Schwarze <schwarze@openbsd.org>
  * Copyright (c) 2010, 2012 Joerg Sonnenberger <joerg@netbsd.org>   * Copyright (c) 2010, 2012 Joerg Sonnenberger <joerg@netbsd.org>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
Line 41 
Line 41 
 #include "libmandoc.h"  #include "libmandoc.h"
 #include "mdoc.h"  #include "mdoc.h"
 #include "man.h"  #include "man.h"
 #include "main.h"  
   
 #define REPARSE_LIMIT   1000  #define REPARSE_LIMIT   1000
   
Line 81  static const enum mandocerr mandoclimits[MANDOCLEVEL_M
Line 80  static const enum mandocerr mandoclimits[MANDOCLEVEL_M
         MANDOCERR_WARNING,          MANDOCERR_WARNING,
         MANDOCERR_WARNING,          MANDOCERR_WARNING,
         MANDOCERR_ERROR,          MANDOCERR_ERROR,
         MANDOCERR_FATAL,          MANDOCERR_UNSUPP,
         MANDOCERR_MAX,          MANDOCERR_MAX,
         MANDOCERR_MAX          MANDOCERR_MAX
 };  };
Line 146  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 145  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "empty list item",          "empty list item",
         "missing font type, using \\fR",          "missing font type, using \\fR",
         "unknown font type, using \\fR",          "unknown font type, using \\fR",
           "nothing follows prefix",
         "missing -std argument, adding it",          "missing -std argument, adding it",
         "missing eqn box, using \"\"",          "missing eqn box, using \"\"",
   
Line 180  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 180  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "unexpected end of equation",          "unexpected end of equation",
   
         /* related to tables */          /* related to tables */
         "bad table syntax",          "non-alphabetic character in tbl options",
         "bad table option",          "skipping unknown tbl option",
         "bad table layout",          "missing tbl option argument",
           "wrong tbl option argument size",
         "no table layout cells specified",          "no table layout cells specified",
         "no table data cells specified",          "no table data cells specified",
         "ignore data in cell",          "ignore data in cell",
Line 190  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 191  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "ignoring extra data cells",          "ignoring extra data cells",
   
         /* related to document structure and macros */          /* related to document structure and macros */
           NULL,
         "input stack limit exceeded, infinite loop?",          "input stack limit exceeded, infinite loop?",
         "skipping bad character",          "skipping bad character",
         "skipping unknown macro",          "skipping unknown macro",
           "skipping insecure request",
         "skipping item outside list",          "skipping item outside list",
         "skipping column outside column list",          "skipping column outside column list",
         "skipping end of block that is not open",          "skipping end of block that is not open",
           "fewer RS blocks open, skipping",
         "inserting missing end of block",          "inserting missing end of block",
         "appending missing end of block",          "appending missing end of block",
   
Line 208  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 212  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "uname(3) system call failed, using UNKNOWN",          "uname(3) system call failed, using UNKNOWN",
         "unknown standard specifier",          "unknown standard specifier",
         "skipping request without numeric argument",          "skipping request without numeric argument",
           "NOT IMPLEMENTED: .so with absolute path or \"..\"",
           ".so request failed",
         "skipping all arguments",          "skipping all arguments",
         "skipping excess arguments",          "skipping excess arguments",
         "divide by zero",          "divide by zero",
   
         "generic fatal error",          "unsupported feature",
   
         "input too large",          "input too large",
         "NOT IMPLEMENTED: .so with absolute path or \"..\"",          "unsupported control character",
         ".so request failed",          "unsupported roff request",
           "unsupported table layout",
         /* system errors */          "ignoring macro in table",
         "cannot dup file descriptor",          "eqn in tbl",
         "cannot exec",  
         "gunzip failed with code",  
         "cannot fork",  
         NULL,  
         "cannot open pipe",  
         "cannot read file",  
         "gunzip died from signal",  
         "cannot stat file",  
         "wait failed",  
 };  };
   
 static  const char * const      mandoclevels[MANDOCLEVEL_MAX] = {  static  const char * const      mandoclevels[MANDOCLEVEL_MAX] = {
Line 236  static const char * const mandoclevels[MANDOCLEVEL_MAX
Line 232  static const char * const mandoclevels[MANDOCLEVEL_MAX
         "RESERVED",          "RESERVED",
         "WARNING",          "WARNING",
         "ERROR",          "ERROR",
         "FATAL",          "UNSUPP",
         "BADARG",          "BADARG",
         "SYSERR"          "SYSERR"
 };  };
Line 297  choose_parser(struct mparse *curp)
Line 293  choose_parser(struct mparse *curp)
         /* Fall back to man(7) as a last resort. */          /* Fall back to man(7) as a last resort. */
   
         if (NULL == curp->pman)          if (NULL == curp->pman)
                 curp->pman = man_alloc(curp->roff, curp,                  curp->pman = man_alloc(
                       curp->roff, curp, curp->defos,
                     MPARSE_QUICK & curp->options ? 1 : 0);                      MPARSE_QUICK & curp->options ? 1 : 0);
         assert(curp->pman);          assert(curp->pman);
         curp->man = curp->pman;          curp->man = curp->pman;
Line 315  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 312  mparse_buf_r(struct mparse *curp, struct buf blk, size
 {  {
         const struct tbl_span   *span;          const struct tbl_span   *span;
         struct buf       ln;          struct buf       ln;
           const char      *save_file;
           char            *cp;
         size_t           pos; /* byte number in the ln buffer */          size_t           pos; /* byte number in the ln buffer */
         enum rofferr     rr;          enum rofferr     rr;
         int              of;          int              of;
         int              lnn; /* line number in the real file */          int              lnn; /* line number in the real file */
           int              fd;
           pid_t            save_child;
         unsigned char    c;          unsigned char    c;
   
         memset(&ln, 0, sizeof(ln));          memset(&ln, 0, sizeof(ln));
Line 373  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 374  mparse_buf_r(struct mparse *curp, struct buf blk, size
                         if (c & 0x80) {                          if (c & 0x80) {
                                 if ( ! (curp->filenc && preconv_encode(                                  if ( ! (curp->filenc && preconv_encode(
                                     &blk, &i, &ln, &pos, &curp->filenc))) {                                      &blk, &i, &ln, &pos, &curp->filenc))) {
                                         mandoc_vmsg(MANDOCERR_BADCHAR,                                          mandoc_vmsg(MANDOCERR_CHAR_BAD, curp,
                                             curp, curp->line, pos,                                              curp->line, pos, "0x%x", c);
                                             "0x%x", c);  
                                         ln.buf[pos++] = '?';                                          ln.buf[pos++] = '?';
                                         i++;                                          i++;
                                 }                                  }
Line 387  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 387  mparse_buf_r(struct mparse *curp, struct buf blk, size
                          */                           */
   
                         if (c == 0x7f || (c < 0x20 && c != 0x09)) {                          if (c == 0x7f || (c < 0x20 && c != 0x09)) {
                                 mandoc_vmsg(MANDOCERR_BADCHAR, curp,                                  mandoc_vmsg(c == 0x00 || c == 0x04 ||
                                     curp->line, pos, "0x%x", c);                                      c > 0x0a ? MANDOCERR_CHAR_BAD :
                                       MANDOCERR_CHAR_UNSUPP,
                                       curp, curp->line, pos, "0x%x", c);
                                 i++;                                  i++;
                                 ln.buf[pos++] = '?';                                  ln.buf[pos++] = '?';
                                 continue;                                  continue;
Line 444  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 446  mparse_buf_r(struct mparse *curp, struct buf blk, size
   
                         if ( ! (isascii(c) &&                          if ( ! (isascii(c) &&
                             (isgraph(c) || isblank(c)))) {                              (isgraph(c) || isblank(c)))) {
                                 mandoc_vmsg(MANDOCERR_BADCHAR, curp,                                  mandoc_vmsg(MANDOCERR_CHAR_BAD, curp,
                                     curp->line, pos, "0x%x", c);                                      curp->line, pos, "0x%x", c);
                                 i += 2;                                  i += 2;
                                 ln.buf[pos++] = '?';                                  ln.buf[pos++] = '?';
Line 513  rerun:
Line 515  rerun:
                 case ROFF_IGN:                  case ROFF_IGN:
                         pos = 0;                          pos = 0;
                         continue;                          continue;
                 case ROFF_ERR:  
                         assert(MANDOCLEVEL_FATAL <= curp->file_status);  
                         break;  
                 case ROFF_SO:                  case ROFF_SO:
                         if ( ! (curp->options & MPARSE_SO) &&                          if ( ! (curp->options & MPARSE_SO) &&
                             (i >= blk.sz || blk.buf[i] == '\0')) {                              (i >= blk.sz || blk.buf[i] == '\0')) {
Line 530  rerun:
Line 529  rerun:
                          */                           */
                         if (curp->secondary)                          if (curp->secondary)
                                 curp->secondary->sz -= pos + 1;                                  curp->secondary->sz -= pos + 1;
                         mparse_readfd(curp, -1, ln.buf + of);                          save_file = curp->file;
                         if (MANDOCLEVEL_FATAL <= curp->file_status) {                          save_child = curp->child;
                           if (mparse_open(curp, &fd, ln.buf + of) ==
                               MANDOCLEVEL_OK) {
                                   mparse_readfd(curp, fd, ln.buf + of);
                                   curp->file = save_file;
                           } else {
                                   curp->file = save_file;
                                 mandoc_vmsg(MANDOCERR_SO_FAIL,                                  mandoc_vmsg(MANDOCERR_SO_FAIL,
                                     curp, curp->line, pos,                                      curp, curp->line, pos,
                                     ".so %s", ln.buf + of);                                      ".so %s", ln.buf + of);
                                 break;                                  ln.sz = mandoc_asprintf(&cp,
                                       ".sp\nSee the file %s.\n.sp",
                                       ln.buf + of);
                                   free(ln.buf);
                                   ln.buf = cp;
                                   of = 0;
                                   mparse_buf_r(curp, ln, of, 0);
                         }                          }
                           curp->child = save_child;
                         pos = 0;                          pos = 0;
                         continue;                          continue;
                 default:                  default:
Line 544  rerun:
Line 556  rerun:
                 }                  }
   
                 /*                  /*
                  * If we encounter errors in the recursive parse, make  
                  * sure we don't continue parsing.  
                  */  
   
                 if (MANDOCLEVEL_FATAL <= curp->file_status)  
                         break;  
   
                 /*  
                  * If input parsers have not been allocated, do so now.                   * If input parsers have not been allocated, do so now.
                  * We keep these instanced between parsers, but set them                   * We keep these instanced between parsers, but set them
                  * locally per parse routine since we can use different                   * locally per parse routine since we can use different
Line 609  read_whole_file(struct mparse *curp, const char *file,
Line 613  read_whole_file(struct mparse *curp, const char *file,
 #if HAVE_MMAP  #if HAVE_MMAP
         struct stat      st;          struct stat      st;
         if (-1 == fstat(fd, &st)) {          if (-1 == fstat(fd, &st)) {
                 curp->file_status = MANDOCLEVEL_SYSERR;                  perror(file);
                 if (curp->mmsg)                  exit((int)MANDOCLEVEL_SYSERR);
                         (*curp->mmsg)(MANDOCERR_SYSSTAT, curp->file_status,  
                             file, 0, 0, strerror(errno));  
                 return(0);  
         }          }
   
         /*          /*
Line 625  read_whole_file(struct mparse *curp, const char *file,
Line 626  read_whole_file(struct mparse *curp, const char *file,
   
         if (S_ISREG(st.st_mode)) {          if (S_ISREG(st.st_mode)) {
                 if (st.st_size >= (1U << 31)) {                  if (st.st_size >= (1U << 31)) {
                         curp->file_status = MANDOCLEVEL_FATAL;                          mandoc_msg(MANDOCERR_TOOLARGE, curp, 0, 0, NULL);
                         if (curp->mmsg)  
                                 (*curp->mmsg)(MANDOCERR_TOOLARGE,  
                                     curp->file_status, file, 0, 0, NULL);  
                         return(0);                          return(0);
                 }                  }
                 *with_mmap = 1;                  *with_mmap = 1;
Line 651  read_whole_file(struct mparse *curp, const char *file,
Line 649  read_whole_file(struct mparse *curp, const char *file,
         for (;;) {          for (;;) {
                 if (off == fb->sz) {                  if (off == fb->sz) {
                         if (fb->sz == (1U << 31)) {                          if (fb->sz == (1U << 31)) {
                                 curp->file_status = MANDOCLEVEL_FATAL;                                  mandoc_msg(MANDOCERR_TOOLARGE, curp,
                                 if (curp->mmsg)                                      0, 0, NULL);
                                         (*curp->mmsg)(MANDOCERR_TOOLARGE,  
                                             curp->file_status,  
                                             file, 0, 0, NULL);  
                                 break;                                  break;
                         }                          }
                         resize_buf(fb, 65536);                          resize_buf(fb, 65536);
Line 666  read_whole_file(struct mparse *curp, const char *file,
Line 661  read_whole_file(struct mparse *curp, const char *file,
                         return(1);                          return(1);
                 }                  }
                 if (ssz == -1) {                  if (ssz == -1) {
                         curp->file_status = MANDOCLEVEL_SYSERR;                          perror(file);
                         if (curp->mmsg)                          exit((int)MANDOCLEVEL_SYSERR);
                                 (*curp->mmsg)(MANDOCERR_SYSREAD,  
                                     curp->file_status, file, 0, 0,  
                                     strerror(errno));  
                         break;  
                 }                  }
                 off += (size_t)ssz;                  off += (size_t)ssz;
         }          }
Line 685  static void
Line 676  static void
 mparse_end(struct mparse *curp)  mparse_end(struct mparse *curp)
 {  {
   
         if (MANDOCLEVEL_FATAL <= curp->file_status)  
                 return;  
   
         if (curp->mdoc == NULL &&          if (curp->mdoc == NULL &&
             curp->man == NULL &&              curp->man == NULL &&
             curp->sodest == NULL) {              curp->sodest == NULL) {
Line 695  mparse_end(struct mparse *curp)
Line 683  mparse_end(struct mparse *curp)
                         curp->mdoc = curp->pmdoc;                          curp->mdoc = curp->pmdoc;
                 else {                  else {
                         if (curp->pman == NULL)                          if (curp->pman == NULL)
                                 curp->pman = man_alloc(curp->roff, curp,                                  curp->pman = man_alloc(
                                       curp->roff, curp, curp->defos,
                                     curp->options & MPARSE_QUICK ? 1 : 0);                                      curp->options & MPARSE_QUICK ? 1 : 0);
                         curp->man = curp->pman;                          curp->man = curp->pman;
                 }                  }
         }          }
           if (curp->mdoc)
         if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {                  mdoc_endparse(curp->mdoc);
                 assert(MANDOCLEVEL_FATAL <= curp->file_status);          if (curp->man)
                 return;                  man_endparse(curp->man);
         }  
   
         if (curp->man && ! man_endparse(curp->man)) {  
                 assert(MANDOCLEVEL_FATAL <= curp->file_status);  
                 return;  
         }  
   
         roff_endparse(curp->roff);          roff_endparse(curp->roff);
 }  }
   
Line 747  mparse_parse_buffer(struct mparse *curp, struct buf bl
Line 729  mparse_parse_buffer(struct mparse *curp, struct buf bl
   
         mparse_buf_r(curp, blk, offset, 1);          mparse_buf_r(curp, blk, offset, 1);
   
         if (0 == --recursion_depth && MANDOCLEVEL_FATAL > curp->file_status)          if (--recursion_depth == 0)
                 mparse_end(curp);                  mparse_end(curp);
   
         curp->primary = svprimary;          curp->primary = svprimary;
Line 755  mparse_parse_buffer(struct mparse *curp, struct buf bl
Line 737  mparse_parse_buffer(struct mparse *curp, struct buf bl
 }  }
   
 enum mandoclevel  enum mandoclevel
 mparse_readmem(struct mparse *curp, const void *buf, size_t len,  mparse_readmem(struct mparse *curp, void *buf, size_t len,
                 const char *file)                  const char *file)
 {  {
         struct buf blk;          struct buf blk;
   
         blk.buf = UNCONST(buf);          blk.buf = buf;
         blk.sz = len;          blk.sz = len;
   
         mparse_parse_buffer(curp, blk, file);          mparse_parse_buffer(curp, blk, file);
Line 768  mparse_readmem(struct mparse *curp, const void *buf, s
Line 750  mparse_readmem(struct mparse *curp, const void *buf, s
 }  }
   
 /*  /*
  * If a file descriptor is given, use it and assume it points  
  * to the named file.  Otherwise, open the named file.  
  * Read the whole file into memory and call the parsers.   * Read the whole file into memory and call the parsers.
  * Called recursively when an .so request is encountered.   * Called recursively when an .so request is encountered.
  */   */
Line 779  mparse_readfd(struct mparse *curp, int fd, const char 
Line 759  mparse_readfd(struct mparse *curp, int fd, const char 
         struct buf       blk;          struct buf       blk;
         int              with_mmap;          int              with_mmap;
         int              save_filenc;          int              save_filenc;
         pid_t            save_child;  
   
         save_child = curp->child;  
         if (fd != -1)  
                 curp->child = 0;  
         else if (mparse_open(curp, &fd, file) >= MANDOCLEVEL_SYSERR)  
                 goto out;  
   
         if (read_whole_file(curp, file, fd, &blk, &with_mmap)) {          if (read_whole_file(curp, file, fd, &blk, &with_mmap)) {
                 save_filenc = curp->filenc;                  save_filenc = curp->filenc;
                 curp->filenc = curp->options &                  curp->filenc = curp->options &
Line 805  mparse_readfd(struct mparse *curp, int fd, const char 
Line 778  mparse_readfd(struct mparse *curp, int fd, const char 
                 perror(file);                  perror(file);
   
         mparse_wait(curp);          mparse_wait(curp);
 out:  
         curp->child = save_child;  
         return(curp->file_status);          return(curp->file_status);
 }  }
   
Line 816  mparse_open(struct mparse *curp, int *fd, const char *
Line 787  mparse_open(struct mparse *curp, int *fd, const char *
         int               pfd[2];          int               pfd[2];
         int               save_errno;          int               save_errno;
         char             *cp;          char             *cp;
         enum mandocerr    err;  
   
         pfd[1] = -1;  
         curp->file = file;          curp->file = file;
   
         /* Unless zipped, try to just open the file. */          /* Unless zipped, try to just open the file. */
Line 842  mparse_open(struct mparse *curp, int *fd, const char *
Line 811  mparse_open(struct mparse *curp, int *fd, const char *
         if (access(file, R_OK) == -1) {          if (access(file, R_OK) == -1) {
                 if (cp != NULL)                  if (cp != NULL)
                         errno = save_errno;                          errno = save_errno;
                 err = MANDOCERR_SYSOPEN;                  free(cp);
                 goto out;                  *fd = -1;
                   curp->child = 0;
                   mandoc_msg(MANDOCERR_FILE, curp, 0, 0, strerror(errno));
                   return(MANDOCLEVEL_ERROR);
         }          }
   
         /* Run gunzip(1). */          /* Run gunzip(1). */
   
         if (pipe(pfd) == -1) {          if (pipe(pfd) == -1) {
                 err = MANDOCERR_SYSPIPE;                  perror("pipe");
                 goto out;                  exit((int)MANDOCLEVEL_SYSERR);
         }          }
   
         switch (curp->child = fork()) {          switch (curp->child = fork()) {
         case -1:          case -1:
                 err = MANDOCERR_SYSFORK;                  perror("fork");
                 close(pfd[0]);                  exit((int)MANDOCLEVEL_SYSERR);
                 close(pfd[1]);  
                 pfd[1] = -1;  
                 break;  
         case 0:          case 0:
                 close(pfd[0]);                  close(pfd[0]);
                 if (dup2(pfd[1], STDOUT_FILENO) == -1) {                  if (dup2(pfd[1], STDOUT_FILENO) == -1) {
                         err = MANDOCERR_SYSDUP;                          perror("dup");
                         break;                          exit((int)MANDOCLEVEL_SYSERR);
                 }                  }
                 execlp("gunzip", "gunzip", "-c", file, NULL);                  execlp("gunzip", "gunzip", "-c", file, NULL);
                 err = MANDOCERR_SYSEXEC;                  perror("exec");
                 break;                  exit((int)MANDOCLEVEL_SYSERR);
         default:          default:
                 close(pfd[1]);                  close(pfd[1]);
                 *fd = pfd[0];                  *fd = pfd[0];
                 return(MANDOCLEVEL_OK);                  return(MANDOCLEVEL_OK);
         }          }
   
 out:  
         free(cp);  
         *fd = -1;  
         curp->child = 0;  
         curp->file_status = MANDOCLEVEL_SYSERR;  
         if (curp->mmsg)  
                 (*curp->mmsg)(err, curp->file_status, curp->file,  
                     0, 0, strerror(errno));  
         if (pfd[1] != -1)  
                 exit(1);  
         return(curp->file_status);  
 }  }
   
 enum mandoclevel  enum mandoclevel
Line 897  mparse_wait(struct mparse *curp)
Line 854  mparse_wait(struct mparse *curp)
                 return(MANDOCLEVEL_OK);                  return(MANDOCLEVEL_OK);
   
         if (waitpid(curp->child, &status, 0) == -1) {          if (waitpid(curp->child, &status, 0) == -1) {
                 mandoc_msg(MANDOCERR_SYSWAIT, curp, 0, 0,                  perror("wait");
                     strerror(errno));                  exit((int)MANDOCLEVEL_SYSERR);
                 curp->file_status = MANDOCLEVEL_SYSERR;  
                 return(curp->file_status);  
         }          }
         if (WIFSIGNALED(status)) {          if (WIFSIGNALED(status)) {
                 mandoc_vmsg(MANDOCERR_SYSSIG, curp, 0, 0,                  mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0,
                     "%d", WTERMSIG(status));                      "gunzip died from signal %d", WTERMSIG(status));
                 curp->file_status = MANDOCLEVEL_SYSERR;                  return(MANDOCLEVEL_ERROR);
                 return(curp->file_status);  
         }          }
         if (WEXITSTATUS(status)) {          if (WEXITSTATUS(status)) {
                 mandoc_vmsg(MANDOCERR_SYSEXIT, curp, 0, 0,                  mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0,
                     "%d", WEXITSTATUS(status));                      "gunzip failed with code %d", WEXITSTATUS(status));
                 curp->file_status = MANDOCLEVEL_SYSERR;                  return(MANDOCLEVEL_ERROR);
                 return(curp->file_status);  
         }          }
         return(MANDOCLEVEL_OK);          return(MANDOCLEVEL_OK);
 }  }
Line 923  mparse_alloc(int options, enum mandoclevel wlevel, man
Line 876  mparse_alloc(int options, enum mandoclevel wlevel, man
 {  {
         struct mparse   *curp;          struct mparse   *curp;
   
         assert(wlevel <= MANDOCLEVEL_FATAL);  
   
         curp = mandoc_calloc(1, sizeof(struct mparse));          curp = mandoc_calloc(1, sizeof(struct mparse));
   
         curp->options = options;          curp->options = options;
Line 939  mparse_alloc(int options, enum mandoclevel wlevel, man
Line 890  mparse_alloc(int options, enum mandoclevel wlevel, man
                     curp->roff, curp, curp->defos,                      curp->roff, curp, curp->defos,
                     curp->options & MPARSE_QUICK ? 1 : 0);                      curp->options & MPARSE_QUICK ? 1 : 0);
         if (curp->options & MPARSE_MAN)          if (curp->options & MPARSE_MAN)
                 curp->pman = man_alloc(curp->roff, curp,                  curp->pman = man_alloc(
                       curp->roff, curp, curp->defos,
                     curp->options & MPARSE_QUICK ? 1 : 0);                      curp->options & MPARSE_QUICK ? 1 : 0);
   
         return(curp);          return(curp);
Line 1020  mandoc_msg(enum mandocerr er, struct mparse *m,
Line 972  mandoc_msg(enum mandocerr er, struct mparse *m,
 {  {
         enum mandoclevel level;          enum mandoclevel level;
   
         level = MANDOCLEVEL_FATAL;          level = MANDOCLEVEL_UNSUPP;
         while (er < mandoclimits[level])          while (er < mandoclimits[level])
                 level--;                  level--;
   
         if (level < m->wlevel)          if (level < m->wlevel && er != MANDOCERR_FILE)
                 return;                  return;
   
         if (m->mmsg)          if (m->mmsg)
Legend:
Removed from v.1.102  
changed lines
  Added in v.1.117
CVSweb