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

Diff for /mandoc/read.c between version 1.35 and 1.49

version 1.35, 2013/05/30 03:52:59 version 1.49, 2014/06/20 17:24:00
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, 2011, 2012, 2013 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2010-2014 Ingo Schwarze <schwarze@openbsd.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
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
Line 26 
Line 27 
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
   #include <errno.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <stdarg.h>  #include <stdarg.h>
 #include <stdint.h>  #include <stdint.h>
Line 35 
Line 37 
 #include <unistd.h>  #include <unistd.h>
   
 #include "mandoc.h"  #include "mandoc.h"
   #include "mandoc_aux.h"
 #include "libmandoc.h"  #include "libmandoc.h"
 #include "mdoc.h"  #include "mdoc.h"
 #include "man.h"  #include "man.h"
 #include "main.h"  #include "main.h"
   
 #ifndef MAP_FILE  
 #define MAP_FILE        0  
 #endif  
   
 #define REPARSE_LIMIT   1000  #define REPARSE_LIMIT   1000
   
 struct  buf {  struct  buf {
         char             *buf; /* binary input buffer */          char             *buf; /* binary input buffer */
         size_t            sz; /* size of binary buffer */          size_t            sz; /* size of binary buffer */
 };  };
   
Line 55  struct mparse {
Line 54  struct mparse {
         enum mandoclevel  file_status; /* status of current parse */          enum mandoclevel  file_status; /* status of current parse */
         enum mandoclevel  wlevel; /* ignore messages below this */          enum mandoclevel  wlevel; /* ignore messages below this */
         int               line; /* line number in the file */          int               line; /* line number in the file */
         enum mparset      inttype; /* which parser to use */          int               options; /* parser options */
         struct man       *pman; /* persistent man parser */          struct man       *pman; /* persistent man parser */
         struct mdoc      *pmdoc; /* persistent mdoc parser */          struct mdoc      *pmdoc; /* persistent mdoc parser */
         struct man       *man; /* man parser */          struct man       *man; /* man parser */
         struct mdoc      *mdoc; /* mdoc parser */          struct mdoc      *mdoc; /* mdoc parser */
         struct roff      *roff; /* roff parser (!NULL) */          struct roff      *roff; /* roff parser (!NULL) */
           char             *sodest; /* filename pointed to by .so */
         int               reparse_count; /* finite interp. stack */          int               reparse_count; /* finite interp. stack */
         mandocmsg         mmsg; /* warning/error message handler */          mandocmsg         mmsg; /* warning/error message handler */
         void             *arg; /* argument to mmsg */          const char       *file;
         const char       *file;  
         struct buf       *secondary;          struct buf       *secondary;
         char             *defos; /* default operating system */          char             *defos; /* default operating system */
 };  };
   
 static  void      resize_buf(struct buf *, size_t);  static  void      resize_buf(struct buf *, size_t);
 static  void      mparse_buf_r(struct mparse *, struct buf, int);  static  void      mparse_buf_r(struct mparse *, struct buf, int);
 static  void      mparse_readfd_r(struct mparse *, int, const char *, int);  
 static  void      pset(const char *, int, struct mparse *);  static  void      pset(const char *, int, struct mparse *);
 static  int       read_whole_file(const char *, int, struct buf *, int *);  static  int       read_whole_file(struct mparse *, const char *, int,
                                   struct buf *, int *);
 static  void      mparse_end(struct mparse *);  static  void      mparse_end(struct mparse *);
   static  void      mparse_parse_buffer(struct mparse *, struct buf,
                           const char *);
   
 static  const enum mandocerr    mandoclimits[MANDOCLEVEL_MAX] = {  static  const enum mandocerr    mandoclimits[MANDOCLEVEL_MAX] = {
         MANDOCERR_OK,          MANDOCERR_OK,
Line 92  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 93  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "generic warning",          "generic warning",
   
         /* related to the prologue */          /* related to the prologue */
         "no title in document",          "no TH macro in document",
         "document title should be all caps",          "document title should be all caps",
         "unknown manual section",          "unknown manual section",
         "unknown manual volume or arch",          "unknown manual volume or arch",
Line 109  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 110  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "bad NAME section contents",          "bad NAME section contents",
         "sections out of conventional order",          "sections out of conventional order",
         "duplicate section name",          "duplicate section name",
         "section not in conventional manual section",          "section header suited to sections 2, 3, and 9 only",
   
         /* related to macros and nesting */          /* related to macros and nesting */
         "skipping obsolete macro",          "skipping obsolete macro",
Line 152  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 153  static const char * const mandocerrs[MANDOCERR_MAX] = 
   
         /* related to equations */          /* related to equations */
         "unexpected literal in equation",          "unexpected literal in equation",
   
         "generic error",          "generic error",
   
         /* related to equations */          /* related to equations */
Line 188  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 189  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "macro requires line argument(s)",          "macro requires line argument(s)",
         "macro requires body argument(s)",          "macro requires body argument(s)",
         "macro requires argument(s)",          "macro requires argument(s)",
           "request requires a numeric argument",
         "missing list type",          "missing list type",
         "line argument(s) will be lost",          "line argument(s) will be lost",
         "body argument(s) will be lost",          "body argument(s) will be lost",
   
         "generic fatal error",          "generic fatal error",
   
           "input too large",
         "not a manual",          "not a manual",
         "column syntax is inconsistent",          "column syntax is inconsistent",
         "NOT IMPLEMENTED: .Bd -file",          "NOT IMPLEMENTED: .Bd -file",
Line 204  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 207  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "no document body",          "no document body",
         "no document prologue",          "no document prologue",
         "static buffer exhausted",          "static buffer exhausted",
   
           /* system errors */
           "cannot open file",
           "cannot stat file",
           "cannot read file",
 };  };
   
 static  const char * const      mandoclevels[MANDOCLEVEL_MAX] = {  static  const char * const      mandoclevels[MANDOCLEVEL_MAX] = {
Line 216  static const char * const mandoclevels[MANDOCLEVEL_MAX
Line 224  static const char * const mandoclevels[MANDOCLEVEL_MAX
         "SYSERR"          "SYSERR"
 };  };
   
   
 static void  static void
 resize_buf(struct buf *buf, size_t initial)  resize_buf(struct buf *buf, size_t initial)
 {  {
Line 248  pset(const char *buf, int pos, struct mparse *curp)
Line 257  pset(const char *buf, int pos, struct mparse *curp)
                         return;                          return;
         }          }
   
         switch (curp->inttype) {          if (MPARSE_MDOC & curp->options) {
         case (MPARSE_MDOC):                  if (NULL == curp->pmdoc)
                 if (NULL == curp->pmdoc)                          curp->pmdoc = mdoc_alloc(
                         curp->pmdoc = mdoc_alloc(curp->roff, curp,                              curp->roff, curp, curp->defos,
                                         curp->defos);                              MPARSE_QUICK & curp->options ? 1 : 0);
                 assert(curp->pmdoc);                  assert(curp->pmdoc);
                 curp->mdoc = curp->pmdoc;                  curp->mdoc = curp->pmdoc;
                 return;                  return;
         case (MPARSE_MAN):          } else if (MPARSE_MAN & curp->options) {
                 if (NULL == curp->pman)                  if (NULL == curp->pman)
                         curp->pman = man_alloc(curp->roff, curp);                          curp->pman = man_alloc(curp->roff, curp,
                               MPARSE_QUICK & curp->options ? 1 : 0);
                 assert(curp->pman);                  assert(curp->pman);
                 curp->man = curp->pman;                  curp->man = curp->pman;
                 return;                  return;
         default:  
                 break;  
         }          }
   
         if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {          if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {
                 if (NULL == curp->pmdoc)                  if (NULL == curp->pmdoc)
                         curp->pmdoc = mdoc_alloc(curp->roff, curp,                          curp->pmdoc = mdoc_alloc(
                                         curp->defos);                              curp->roff, curp, curp->defos,
                               MPARSE_QUICK & curp->options ? 1 : 0);
                 assert(curp->pmdoc);                  assert(curp->pmdoc);
                 curp->mdoc = curp->pmdoc;                  curp->mdoc = curp->pmdoc;
                 return;                  return;
         }          }
   
         if (NULL == curp->pman)          if (NULL == curp->pman)
                 curp->pman = man_alloc(curp->roff, curp);                  curp->pman = man_alloc(curp->roff, curp,
                       MPARSE_QUICK & curp->options ? 1 : 0);
         assert(curp->pman);          assert(curp->pman);
         curp->man = curp->pman;          curp->man = curp->pman;
 }  }
Line 299  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 309  mparse_buf_r(struct mparse *curp, struct buf blk, int 
   
         memset(&ln, 0, sizeof(struct buf));          memset(&ln, 0, sizeof(struct buf));
   
         lnn = curp->line;          lnn = curp->line;
         pos = 0;          pos = 0;
   
         for (i = 0; i < (int)blk.sz; ) {          for (i = 0; i < (int)blk.sz; ) {
                 if (0 == pos && '\0' == blk.buf[i])                  if (0 == pos && '\0' == blk.buf[i])
Line 337  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 347  mparse_buf_r(struct mparse *curp, struct buf blk, int 
                         if (pos + 2 >= (int)ln.sz)                          if (pos + 2 >= (int)ln.sz)
                                 resize_buf(&ln, 256);                                  resize_buf(&ln, 256);
   
                         /*                          /*
                          * Warn about bogus characters.  If you're using                           * Warn about bogus characters.  If you're using
                          * non-ASCII encoding, you're screwing your                           * non-ASCII encoding, you're screwing your
                          * readers.  Since I'd rather this not happen,                           * readers.  Since I'd rather this not happen,
Line 348  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 358  mparse_buf_r(struct mparse *curp, struct buf blk, int 
   
                         c = (unsigned char) blk.buf[i];                          c = (unsigned char) blk.buf[i];
   
                         if ( ! (isascii(c) &&                          if ( ! (isascii(c) &&
                                         (isgraph(c) || isblank(c)))) {                              (isgraph(c) || isblank(c)))) {
                                 mandoc_msg(MANDOCERR_BADCHAR, curp,                                  mandoc_msg(MANDOCERR_BADCHAR, curp,
                                                 curp->line, pos, NULL);                                      curp->line, pos, NULL);
                                 i++;                                  i++;
                                 ln.buf[pos++] = '?';                                  ln.buf[pos++] = '?';
                                 continue;                                  continue;
Line 405  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 415  mparse_buf_r(struct mparse *curp, struct buf blk, int 
   
                         c = (unsigned char) blk.buf[i+1];                          c = (unsigned char) blk.buf[i+1];
   
                         if ( ! (isascii(c) &&                          if ( ! (isascii(c) &&
                                         (isgraph(c) || isblank(c)))) {                              (isgraph(c) || isblank(c)))) {
                                 mandoc_msg(MANDOCERR_BADCHAR, curp,                                  mandoc_msg(MANDOCERR_BADCHAR, curp,
                                                 curp->line, pos, NULL);                                      curp->line, pos, NULL);
                                 i += 2;                                  i += 2;
                                 ln.buf[pos++] = '?';                                  ln.buf[pos++] = '?';
                                 continue;                                  continue;
Line 420  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 430  mparse_buf_r(struct mparse *curp, struct buf blk, int 
                         ln.buf[pos++] = blk.buf[i++];                          ln.buf[pos++] = blk.buf[i++];
                 }                  }
   
                 if (pos >= (int)ln.sz)                  if (pos >= (int)ln.sz)
                         resize_buf(&ln, 256);                          resize_buf(&ln, 256);
   
                 ln.buf[pos] = '\0';                  ln.buf[pos] = '\0';
Line 443  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 453  mparse_buf_r(struct mparse *curp, struct buf blk, int 
                  */                   */
   
                 if (curp->secondary) {                  if (curp->secondary) {
                         curp->secondary->buf =                          curp->secondary->buf = mandoc_realloc(
                                 mandoc_realloc                              curp->secondary->buf,
                                 (curp->secondary->buf,                              curp->secondary->sz + pos + 2);
                                  curp->secondary->sz + pos + 2);                          memcpy(curp->secondary->buf +
                         memcpy(curp->secondary->buf +                              curp->secondary->sz,
                                         curp->secondary->sz,                              ln.buf, pos);
                                         ln.buf, pos);  
                         curp->secondary->sz += pos;                          curp->secondary->sz += pos;
                         curp->secondary->buf                          curp->secondary->buf
                                 [curp->secondary->sz] = '\n';                                  [curp->secondary->sz] = '\n';
Line 458  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 467  mparse_buf_r(struct mparse *curp, struct buf blk, int 
                                 [curp->secondary->sz] = '\0';                                  [curp->secondary->sz] = '\0';
                 }                  }
 rerun:  rerun:
                 rr = roff_parseln                  rr = roff_parseln(curp->roff, curp->line,
                         (curp->roff, curp->line,                      &ln.buf, &ln.sz, of, &of);
                          &ln.buf, &ln.sz, of, &of);  
   
                 switch (rr) {                  switch (rr) {
                 case (ROFF_REPARSE):                  case ROFF_REPARSE:
                         if (REPARSE_LIMIT >= ++curp->reparse_count)                          if (REPARSE_LIMIT >= ++curp->reparse_count)
                                 mparse_buf_r(curp, ln, 0);                                  mparse_buf_r(curp, ln, 0);
                         else                          else
                                 mandoc_msg(MANDOCERR_ROFFLOOP, curp,                                  mandoc_msg(MANDOCERR_ROFFLOOP, curp,
                                         curp->line, pos, NULL);                                      curp->line, pos, NULL);
                         pos = 0;                          pos = 0;
                         continue;                          continue;
                 case (ROFF_APPEND):                  case ROFF_APPEND:
                         pos = (int)strlen(ln.buf);                          pos = (int)strlen(ln.buf);
                         continue;                          continue;
                 case (ROFF_RERUN):                  case ROFF_RERUN:
                         goto rerun;                          goto rerun;
                 case (ROFF_IGN):                  case ROFF_IGN:
                         pos = 0;                          pos = 0;
                         continue;                          continue;
                 case (ROFF_ERR):                  case ROFF_ERR:
                         assert(MANDOCLEVEL_FATAL <= curp->file_status);                          assert(MANDOCLEVEL_FATAL <= curp->file_status);
                         break;                          break;
                 case (ROFF_SO):                  case ROFF_SO:
                           if (0 == (MPARSE_SO & curp->options) &&
                               (i >= (int)blk.sz || '\0' == blk.buf[i])) {
                                   curp->sodest = mandoc_strdup(ln.buf + of);
                                   free(ln.buf);
                                   return;
                           }
                         /*                          /*
                          * We remove `so' clauses from our lookaside                           * We remove `so' clauses from our lookaside
                          * buffer because we're going to descend into                           * buffer because we're going to descend into
                          * the file recursively.                           * the file recursively.
                          */                           */
                         if (curp->secondary)                          if (curp->secondary)
                                 curp->secondary->sz -= pos + 1;                                  curp->secondary->sz -= pos + 1;
                         mparse_readfd_r(curp, -1, ln.buf + of, 1);                          mparse_readfd(curp, -1, ln.buf + of);
                         if (MANDOCLEVEL_FATAL <= curp->file_status)                          if (MANDOCLEVEL_FATAL <= curp->file_status)
                                 break;                                  break;
                         pos = 0;                          pos = 0;
Line 517  rerun:
Line 531  rerun:
                 if ( ! (curp->man || curp->mdoc))                  if ( ! (curp->man || curp->mdoc))
                         pset(ln.buf + of, pos - of, curp);                          pset(ln.buf + of, pos - of, curp);
   
                 /*                  /*
                  * Lastly, push down into the parsers themselves.  One                   * Lastly, push down into the parsers themselves.  One
                  * of these will have already been set in the pset()                   * of these will have already been set in the pset()
                  * routine.                   * routine.
Line 533  rerun:
Line 547  rerun:
                 if (ROFF_TBL == rr)                  if (ROFF_TBL == rr)
                         while (NULL != (span = roff_span(curp->roff))) {                          while (NULL != (span = roff_span(curp->roff))) {
                                 rc = curp->man ?                                  rc = curp->man ?
                                         man_addspan(curp->man, span) :                                      man_addspan(curp->man, span) :
                                         mdoc_addspan(curp->mdoc, span);                                      mdoc_addspan(curp->mdoc, span);
                                 if (0 == rc)                                  if (0 == rc)
                                         break;                                          break;
                         }                          }
                 else if (ROFF_EQN == rr)                  else if (ROFF_EQN == rr)
                         rc = curp->mdoc ?                          rc = curp->mdoc ?
                                 mdoc_addeqn(curp->mdoc,                              mdoc_addeqn(curp->mdoc,
                                         roff_eqn(curp->roff)) :                                  roff_eqn(curp->roff)) :
                                 man_addeqn(curp->man,                              man_addeqn(curp->man,
                                         roff_eqn(curp->roff));                                  roff_eqn(curp->roff));
                 else if (curp->man || curp->mdoc)                  else if (curp->man || curp->mdoc)
                         rc = curp->man ?                          rc = curp->man ?
                                 man_parseln(curp->man,                              man_parseln(curp->man,
                                         curp->line, ln.buf, of) :                                  curp->line, ln.buf, of) :
                                 mdoc_parseln(curp->mdoc,                              mdoc_parseln(curp->mdoc,
                                         curp->line, ln.buf, of);                                  curp->line, ln.buf, of);
   
                 if (0 == rc) {                  if (0 == rc) {
                         assert(MANDOCLEVEL_FATAL <= curp->file_status);                          assert(MANDOCLEVEL_FATAL <= curp->file_status);
                         break;                          break;
                 }                  } else if (2 == rc)
                           break;
   
                 /* Temporary buffers typically are not full. */                  /* Temporary buffers typically are not full. */
   
Line 570  rerun:
Line 585  rerun:
 }  }
   
 static int  static int
 read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)  read_whole_file(struct mparse *curp, const char *file, int fd,
                   struct buf *fb, int *with_mmap)
 {  {
         size_t           off;          size_t           off;
         ssize_t          ssz;          ssize_t          ssz;
Line 578  read_whole_file(const char *file, int fd, struct buf *
Line 594  read_whole_file(const char *file, int fd, struct buf *
 #ifdef  HAVE_MMAP  #ifdef  HAVE_MMAP
         struct stat      st;          struct stat      st;
         if (-1 == fstat(fd, &st)) {          if (-1 == fstat(fd, &st)) {
                 perror(file);                  curp->file_status = MANDOCLEVEL_SYSERR;
                   if (curp->mmsg)
                           (*curp->mmsg)(MANDOCERR_SYSSTAT, curp->file_status,
                               file, 0, 0, strerror(errno));
                 return(0);                  return(0);
         }          }
   
Line 591  read_whole_file(const char *file, int fd, struct buf *
Line 610  read_whole_file(const char *file, int fd, struct buf *
   
         if (S_ISREG(st.st_mode)) {          if (S_ISREG(st.st_mode)) {
                 if (st.st_size >= (1U << 31)) {                  if (st.st_size >= (1U << 31)) {
                         fprintf(stderr, "%s: input too large\n", file);                          curp->file_status = MANDOCLEVEL_FATAL;
                           if (curp->mmsg)
                                   (*curp->mmsg)(MANDOCERR_TOOLARGE,
                                       curp->file_status, file, 0, 0, NULL);
                         return(0);                          return(0);
                 }                  }
                 *with_mmap = 1;                  *with_mmap = 1;
                 fb->sz = (size_t)st.st_size;                  fb->sz = (size_t)st.st_size;
                 fb->buf = mmap(NULL, fb->sz, PROT_READ,                  fb->buf = mmap(NULL, fb->sz, PROT_READ, MAP_SHARED, fd, 0);
                                 MAP_FILE|MAP_SHARED, fd, 0);  
                 if (fb->buf != MAP_FAILED)                  if (fb->buf != MAP_FAILED)
                         return(1);                          return(1);
         }          }
Line 615  read_whole_file(const char *file, int fd, struct buf *
Line 636  read_whole_file(const char *file, int fd, struct buf *
         for (;;) {          for (;;) {
                 if (off == fb->sz) {                  if (off == fb->sz) {
                         if (fb->sz == (1U << 31)) {                          if (fb->sz == (1U << 31)) {
                                 fprintf(stderr, "%s: input too large\n", file);                                  curp->file_status = MANDOCLEVEL_FATAL;
                                   if (curp->mmsg)
                                           (*curp->mmsg)(MANDOCERR_TOOLARGE,
                                               curp->file_status,
                                               file, 0, 0, NULL);
                                 break;                                  break;
                         }                          }
                         resize_buf(fb, 65536);                          resize_buf(fb, 65536);
Line 626  read_whole_file(const char *file, int fd, struct buf *
Line 651  read_whole_file(const char *file, int fd, struct buf *
                         return(1);                          return(1);
                 }                  }
                 if (ssz == -1) {                  if (ssz == -1) {
                         perror(file);                          curp->file_status = MANDOCLEVEL_SYSERR;
                           if (curp->mmsg)
                                   (*curp->mmsg)(MANDOCERR_SYSREAD,
                                       curp->file_status, file, 0, 0,
                                       strerror(errno));
                         break;                          break;
                 }                  }
                 off += (size_t)ssz;                  off += (size_t)ssz;
Line 654  mparse_end(struct mparse *curp)
Line 683  mparse_end(struct mparse *curp)
                 return;                  return;
         }          }
   
         if ( ! (curp->man || curp->mdoc)) {          if ( ! (curp->mdoc || curp->man || curp->sodest)) {
                 mandoc_msg(MANDOCERR_NOTMANUAL, curp, 1, 0, NULL);                  mandoc_msg(MANDOCERR_NOTMANUAL, curp, 1, 0, NULL);
                 curp->file_status = MANDOCLEVEL_FATAL;                  curp->file_status = MANDOCLEVEL_FATAL;
                 return;                  return;
Line 664  mparse_end(struct mparse *curp)
Line 693  mparse_end(struct mparse *curp)
 }  }
   
 static void  static void
 mparse_parse_buffer(struct mparse *curp, struct buf blk, const char *file,  mparse_parse_buffer(struct mparse *curp, struct buf blk, const char *file)
                 int re)  
 {  {
         const char      *svfile;          const char      *svfile;
           static int       recursion_depth;
   
           if (64 < recursion_depth) {
                   mandoc_msg(MANDOCERR_ROFFLOOP, curp, curp->line, 0, NULL);
                   return;
           }
   
         /* Line number is per-file. */          /* Line number is per-file. */
         svfile = curp->file;          svfile = curp->file;
         curp->file = file;          curp->file = file;
         curp->line = 1;          curp->line = 1;
           recursion_depth++;
   
         mparse_buf_r(curp, blk, 1);          mparse_buf_r(curp, blk, 1);
   
         if (0 == re && MANDOCLEVEL_FATAL > curp->file_status)          if (0 == --recursion_depth && MANDOCLEVEL_FATAL > curp->file_status)
                 mparse_end(curp);                  mparse_end(curp);
   
         curp->file = svfile;          curp->file = svfile;
Line 691  mparse_readmem(struct mparse *curp, const void *buf, s
Line 726  mparse_readmem(struct mparse *curp, const void *buf, s
         blk.buf = UNCONST(buf);          blk.buf = UNCONST(buf);
         blk.sz = len;          blk.sz = len;
   
         mparse_parse_buffer(curp, blk, file, 0);          mparse_parse_buffer(curp, blk, file);
         return(curp->file_status);          return(curp->file_status);
 }  }
   
 static void  enum mandoclevel
 mparse_readfd_r(struct mparse *curp, int fd, const char *file, int re)  mparse_readfd(struct mparse *curp, int fd, const char *file)
 {  {
         struct buf       blk;          struct buf       blk;
         int              with_mmap;          int              with_mmap;
   
         if (-1 == fd)          if (-1 == fd && -1 == (fd = open(file, O_RDONLY, 0))) {
                 if (-1 == (fd = open(file, O_RDONLY, 0))) {                  curp->file_status = MANDOCLEVEL_SYSERR;
                         perror(file);                  if (curp->mmsg)
                         curp->file_status = MANDOCLEVEL_SYSERR;                          (*curp->mmsg)(MANDOCERR_SYSOPEN,
                         return;                              curp->file_status,
                 }                              file, 0, 0, strerror(errno));
                   goto out;
           }
   
         /*          /*
          * Run for each opened file; may be called more than once for           * Run for each opened file; may be called more than once for
          * each full parse sequence if the opened file is nested (i.e.,           * each full parse sequence if the opened file is nested (i.e.,
Line 714  mparse_readfd_r(struct mparse *curp, int fd, const cha
Line 752  mparse_readfd_r(struct mparse *curp, int fd, const cha
          * the parse phase for the file.           * the parse phase for the file.
          */           */
   
         if ( ! read_whole_file(file, fd, &blk, &with_mmap)) {          if ( ! read_whole_file(curp, file, fd, &blk, &with_mmap))
                 curp->file_status = MANDOCLEVEL_SYSERR;                  goto out;
                 return;  
         }  
   
         mparse_parse_buffer(curp, blk, file, re);          mparse_parse_buffer(curp, blk, file);
   
 #ifdef  HAVE_MMAP  #ifdef  HAVE_MMAP
         if (with_mmap)          if (with_mmap)
Line 730  mparse_readfd_r(struct mparse *curp, int fd, const cha
Line 766  mparse_readfd_r(struct mparse *curp, int fd, const cha
   
         if (STDIN_FILENO != fd && -1 == close(fd))          if (STDIN_FILENO != fd && -1 == close(fd))
                 perror(file);                  perror(file);
 }  out:
   
 enum mandoclevel  
 mparse_readfd(struct mparse *curp, int fd, const char *file)  
 {  
   
         mparse_readfd_r(curp, fd, file, 0);  
         return(curp->file_status);          return(curp->file_status);
 }  }
   
 struct mparse *  struct mparse *
 mparse_alloc(enum mparset inttype, enum mandoclevel wlevel,  mparse_alloc(int options, enum mandoclevel wlevel,
                 mandocmsg mmsg, void *arg, char *defos)                  mandocmsg mmsg, char *defos)
 {  {
         struct mparse   *curp;          struct mparse   *curp;
   
Line 750  mparse_alloc(enum mparset inttype, enum mandoclevel wl
Line 780  mparse_alloc(enum mparset inttype, enum mandoclevel wl
   
         curp = mandoc_calloc(1, sizeof(struct mparse));          curp = mandoc_calloc(1, sizeof(struct mparse));
   
           curp->options = options;
         curp->wlevel = wlevel;          curp->wlevel = wlevel;
         curp->mmsg = mmsg;          curp->mmsg = mmsg;
         curp->arg = arg;  
         curp->inttype = inttype;  
         curp->defos = defos;          curp->defos = defos;
   
         curp->roff = roff_alloc(inttype, curp);          curp->roff = roff_alloc(curp, options);
         return(curp);          return(curp);
 }  }
   
Line 776  mparse_reset(struct mparse *curp)
Line 805  mparse_reset(struct mparse *curp)
         curp->file_status = MANDOCLEVEL_OK;          curp->file_status = MANDOCLEVEL_OK;
         curp->mdoc = NULL;          curp->mdoc = NULL;
         curp->man = NULL;          curp->man = NULL;
   
           free(curp->sodest);
           curp->sodest = NULL;
 }  }
   
 void  void
Line 792  mparse_free(struct mparse *curp)
Line 824  mparse_free(struct mparse *curp)
                 free(curp->secondary->buf);                  free(curp->secondary->buf);
   
         free(curp->secondary);          free(curp->secondary);
           free(curp->sodest);
         free(curp);          free(curp);
 }  }
   
 void  void
 mparse_result(struct mparse *curp, struct mdoc **mdoc, struct man **man)  mparse_result(struct mparse *curp,
           struct mdoc **mdoc, struct man **man, char **sodest)
 {  {
   
           if (sodest && NULL != (*sodest = curp->sodest)) {
                   *mdoc = NULL;
                   *man = NULL;
                   return;
           }
         if (mdoc)          if (mdoc)
                 *mdoc = curp->mdoc;                  *mdoc = curp->mdoc;
         if (man)          if (man)
Line 813  mandoc_vmsg(enum mandocerr t, struct mparse *m,
Line 852  mandoc_vmsg(enum mandocerr t, struct mparse *m,
         va_list          ap;          va_list          ap;
   
         va_start(ap, fmt);          va_start(ap, fmt);
         vsnprintf(buf, sizeof(buf) - 1, fmt, ap);          (void)vsnprintf(buf, sizeof(buf), fmt, ap);
         va_end(ap);          va_end(ap);
   
         mandoc_msg(t, m, ln, pos, buf);          mandoc_msg(t, m, ln, pos, buf);
 }  }
   
 void  void
 mandoc_msg(enum mandocerr er, struct mparse *m,  mandoc_msg(enum mandocerr er, struct mparse *m,
                 int ln, int col, const char *msg)                  int ln, int col, const char *msg)
 {  {
         enum mandoclevel level;          enum mandoclevel level;
Legend:
Removed from v.1.35  
changed lines
  Added in v.1.49
CVSweb