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

Diff for /mandoc/read.c between version 1.42 and 1.76

version 1.42, 2014/01/06 00:53:33 version 1.76, 2014/07/31 09:22:21
Line 37 
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"
Line 45 
Line 46 
 #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 53  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 */
         const char       *file;          const char       *file;
         struct buf       *secondary;          struct buf       *secondary;
         char             *defos; /* default operating system */          const char       *defos; /* default operating system */
         int               quick; /* abort the parse early */  
 };  };
   
 static  void      resize_buf(struct buf *, size_t);  static  void      resize_buf(struct buf *, size_t);
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",          "missing .TH macro, using \"unknown 1\"",
         "document title should be all caps",          "lower case character in document title",
         "unknown manual section",          "unknown manual section",
         "unknown manual volume or arch",          "unknown manual volume or arch",
         "date missing, using today's date",          "missing date, using today's date",
         "cannot parse date, using it verbatim",          "cannot parse date, using it verbatim",
         "prologue macros out of order",          "prologue macros out of order",
         "duplicate prologue macro",          "duplicate prologue macro",
         "macro not allowed in prologue",          "incomplete prologue, terminated by",
         "macro not allowed in body",          "skipping prologue macro in body",
   
         /* related to document structure */          /* related to document structure */
         ".so is fragile, better use ln(1)",          ".so is fragile, better use ln(1)",
         "NAME section must come first",          "no document body",
           "content before first section header",
           "first section is not \"NAME\"",
         "bad NAME section contents",          "bad NAME section contents",
         "sections out of conventional order",          "sections out of conventional order",
         "duplicate section name",          "duplicate section title",
         "section header suited to sections 2, 3, and 9 only",          "unexpected section",
   
         /* related to macros and nesting */          /* related to macros and nesting */
         "skipping obsolete macro",          "obsolete macro",
         "skipping paragraph macro",          "skipping paragraph macro",
         "moving paragraph macro out of list",          "moving paragraph macro out of list",
         "skipping no-space macro",          "skipping no-space macro",
         "blocks badly nested",          "blocks badly nested",
         "child violates parent syntax",  
         "nested displays are not portable",          "nested displays are not portable",
         "already in literal mode",          "moving content out of list",
           ".Vt block has child macro",
           "fill mode already enabled, skipping .fi",
           "fill mode already disabled, skipping .nf",
         "line scope broken",          "line scope broken",
   
         /* related to missing macro arguments */          /* related to missing macro arguments */
           "skipping empty request",
           "conditional request controls empty scope",
         "skipping empty macro",          "skipping empty macro",
           "empty argument, using 0n",
         "argument count wrong",          "argument count wrong",
         "missing display type",          "missing display type, using -ragged",
         "list type must come first",          "list type is not the first argument",
         "tag lists require a width argument",          "missing -width in -tag list, using 8n",
         "missing font type",          "missing name for .Ex, using \"\"",
         "skipping end of block that is not open",          "empty head in list item",
           "empty list item",
           "missing font type, using \\fR",
           "unknown font type, using \\fR",
           "missing -std argument, adding it",
   
         /* related to bad macro arguments */          /* related to bad macro arguments */
         "skipping argument",          "unterminated quoted argument",
         "duplicate argument",          "duplicate argument",
         "duplicate display type",          "skipping duplicate argument",
         "duplicate list type",          "skipping duplicate display type",
           "skipping duplicate list type",
           "skipping -width argument",
         "unknown AT&T UNIX version",          "unknown AT&T UNIX version",
         "bad Boolean value",          "invalid content in Rs block",
         "unknown font",          "invalid Boolean argument",
         "unknown standard specifier",          "unknown font, skipping request",
         "bad width argument",  
   
         /* related to plain text */          /* related to plain text */
         "blank line in non-literal context",          "blank line in fill mode, using .sp",
         "tab in non-literal context",          "tab in filled text",
         "end of line whitespace",          "whitespace at end of input line",
         "bad comment style",          "bad comment style",
         "bad escape sequence",          "invalid escape sequence",
         "unterminated quoted string",          "undefined string, using \"\"",
   
         /* related to equations */  
         "unexpected literal in equation",  
   
         "generic error",          "generic error",
   
         /* related to equations */          /* related to equations */
Line 172  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 182  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "data block still open",          "data block still open",
         "ignoring extra data cells",          "ignoring extra data cells",
   
           /* related to document structure and macros */
         "input stack limit exceeded, infinite loop?",          "input stack limit exceeded, infinite loop?",
         "skipping bad character",          "skipping bad character",
         "escaped character not allowed in a name",  
         "manual name not yet set",  
         "skipping text before the first section header",  
         "skipping unknown macro",          "skipping unknown macro",
         "NOT IMPLEMENTED, please use groff: skipping request",          "skipping item outside list",
         "argument count wrong",  
         "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",
         "missing end of block",          "inserting missing end of block",
         "scope open on exit",          "appending missing end of block",
         "uname(3) system call failed",  
         "macro requires line argument(s)",  
         "macro requires body argument(s)",  
         "macro requires argument(s)",  
         "request requires a numeric argument",  
         "missing list type",  
         "line argument(s) will be lost",  
         "body argument(s) will be lost",  
   
           /* related to request and macro arguments */
           "escaped character not allowed in a name",
           "argument count wrong",
           "missing list type, using -item",
           "missing manual name, using \"\"",
           "uname(3) system call failed, using UNKNOWN",
           "unknown standard specifier",
           "skipping request without numeric argument",
           "skipping all arguments",
           "skipping excess arguments",
   
         "generic fatal error",          "generic fatal error",
   
         "input too large",          "input too large",
         "not a manual",  
         "column syntax is inconsistent",  
         "NOT IMPLEMENTED: .Bd -file",          "NOT IMPLEMENTED: .Bd -file",
         "argument count wrong, violates syntax",  
         "child violates parent syntax",  
         "argument count wrong, violates syntax",  
         "NOT IMPLEMENTED: .so with absolute path or \"..\"",          "NOT IMPLEMENTED: .so with absolute path or \"..\"",
         "no document body",          ".so request failed",
         "no document prologue",  
         "static buffer exhausted",          "static buffer exhausted",
   
         /* system errors */          /* system errors */
         "cannot open file",          NULL,
         "cannot stat file",          "cannot stat file",
         "cannot read file",          "cannot read file",
 };  };
Line 223  static const char * const mandoclevels[MANDOCLEVEL_MAX
Line 227  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 255  pset(const char *buf, int pos, struct mparse *curp)
Line 260  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)  
                         curp->pmdoc = mdoc_alloc(curp->roff, curp,  
                                         curp->defos, curp->quick);  
                 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)  
                         curp->pman = man_alloc(curp->roff, curp,  
                                         curp->quick);  
                 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->quick);                              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->quick);                  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 307  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 303  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 345  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 341  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 356  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 352  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 413  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 409  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 428  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 424  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 451  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 447  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 466  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 461  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(curp, -1, ln.buf + of);                          mparse_readfd(curp, -1, ln.buf + of);
                         if (MANDOCLEVEL_FATAL <= curp->file_status)                          if (MANDOCLEVEL_FATAL <= curp->file_status) {
                                   mandoc_vmsg(MANDOCERR_SO_FAIL,
                                       curp, curp->line, pos,
                                       ".so %s", ln.buf + of);
                                 break;                                  break;
                           }
                         pos = 0;                          pos = 0;
                         continue;                          continue;
                 default:                  default:
Line 525  rerun:
Line 529  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 541  rerun:
Line 545  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);
Line 667  mparse_end(struct mparse *curp)
Line 671  mparse_end(struct mparse *curp)
         if (MANDOCLEVEL_FATAL <= curp->file_status)          if (MANDOCLEVEL_FATAL <= curp->file_status)
                 return;                  return;
   
           if (curp->mdoc == NULL &&
               curp->man == NULL &&
               curp->sodest == NULL) {
                   if (curp->options & MPARSE_MDOC)
                           curp->mdoc = curp->pmdoc;
                   else {
                           if (curp->pman == NULL)
                                   curp->pman = man_alloc(curp->roff, curp,
                                       curp->options & MPARSE_QUICK ? 1 : 0);
                           curp->man = curp->pman;
                   }
           }
   
         if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {          if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {
                 assert(MANDOCLEVEL_FATAL <= curp->file_status);                  assert(MANDOCLEVEL_FATAL <= curp->file_status);
                 return;                  return;
Line 677  mparse_end(struct mparse *curp)
Line 694  mparse_end(struct mparse *curp)
                 return;                  return;
         }          }
   
         if ( ! (curp->man || curp->mdoc)) {  
                 mandoc_msg(MANDOCERR_NOTMANUAL, curp, 1, 0, NULL);  
                 curp->file_status = MANDOCLEVEL_FATAL;  
                 return;  
         }  
   
         roff_endparse(curp->roff);          roff_endparse(curp->roff);
 }  }
   
Line 765  out:
Line 776  out:
 }  }
   
 struct mparse *  struct mparse *
 mparse_alloc(enum mparset inttype, enum mandoclevel wlevel,  mparse_alloc(int options, enum mandoclevel wlevel,
                 mandocmsg mmsg, char *defos, int quick)                  mandocmsg mmsg, const char *defos)
 {  {
         struct mparse   *curp;          struct mparse   *curp;
   
Line 774  mparse_alloc(enum mparset inttype, enum mandoclevel wl
Line 785  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->inttype = inttype;  
         curp->defos = defos;          curp->defos = defos;
         curp->quick = quick;  
   
         curp->roff = roff_alloc(inttype, curp);          curp->roff = roff_alloc(curp, options);
           if (curp->options & MPARSE_MDOC)
                   curp->pmdoc = mdoc_alloc(
                       curp->roff, curp, curp->defos,
                       curp->options & MPARSE_QUICK ? 1 : 0);
           if (curp->options & MPARSE_MAN)
                   curp->pman = man_alloc(curp->roff, curp,
                       curp->options & MPARSE_QUICK ? 1 : 0);
   
         return(curp);          return(curp);
 }  }
   
Line 800  mparse_reset(struct mparse *curp)
Line 818  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 816  mparse_free(struct mparse *curp)
Line 837  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 837  mandoc_vmsg(enum mandocerr t, struct mparse *m,
Line 865  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.42  
changed lines
  Added in v.1.76
CVSweb