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

Diff for /mandoc/read.c between version 1.172 and 1.196

version 1.172, 2017/06/07 23:29:48 version 1.196, 2018/07/28 18:34:15
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-2017 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2010-2018 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 24 
Line 24 
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
 #if HAVE_ERR  
 #include <err.h>  
 #endif  
 #include <errno.h>  #include <errno.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <stdarg.h>  #include <stdarg.h>
Line 42 
Line 39 
 #include "mdoc.h"  #include "mdoc.h"
 #include "man.h"  #include "man.h"
 #include "libmandoc.h"  #include "libmandoc.h"
 #include "roff_int.h"  
   
 #define REPARSE_LIMIT   1000  #define REPARSE_LIMIT   1000
   
Line 53  struct mparse {
Line 49  struct mparse {
         const char       *file; /* filename of current input file */          const char       *file; /* filename of current input file */
         struct buf       *primary; /* buffer currently being parsed */          struct buf       *primary; /* buffer currently being parsed */
         struct buf       *secondary; /* preprocessed copy of input */          struct buf       *secondary; /* preprocessed copy of input */
         const char       *defos; /* default operating system */          const char       *os_s; /* default operating system */
         mandocmsg         mmsg; /* warning/error message handler */          mandocmsg         mmsg; /* warning/error message handler */
         enum mandoclevel  file_status; /* status of current parse */          enum mandoclevel  file_status; /* status of current parse */
         enum mandoclevel  wlevel; /* ignore messages below this */          enum mandocerr    mmin; /* ignore messages below this */
         int               options; /* parser options */          int               options; /* parser options */
         int               gzip; /* current input file is gzipped */          int               gzip; /* current input file is gzipped */
         int               filenc; /* encoding of the current file */          int               filenc; /* encoding of the current file */
Line 75  static void   mparse_parse_buffer(struct mparse *, str
Line 71  static void   mparse_parse_buffer(struct mparse *, str
   
 static  const enum mandocerr    mandoclimits[MANDOCLEVEL_MAX] = {  static  const enum mandocerr    mandoclimits[MANDOCLEVEL_MAX] = {
         MANDOCERR_OK,          MANDOCERR_OK,
         MANDOCERR_STYLE,          MANDOCERR_OK,
         MANDOCERR_WARNING,          MANDOCERR_WARNING,
         MANDOCERR_ERROR,          MANDOCERR_ERROR,
         MANDOCERR_UNSUPP,          MANDOCERR_UNSUPP,
Line 86  static const enum mandocerr mandoclimits[MANDOCLEVEL_M
Line 82  static const enum mandocerr mandoclimits[MANDOCLEVEL_M
 static  const char * const      mandocerrs[MANDOCERR_MAX] = {  static  const char * const      mandocerrs[MANDOCERR_MAX] = {
         "ok",          "ok",
   
           "base system convention",
   
           "Mdocdate found",
           "Mdocdate missing",
           "unknown architecture",
           "operating system explicitly specified",
           "RCS id missing",
           "referenced manual not found",
   
         "generic style suggestion",          "generic style suggestion",
   
           "legacy man(7) date format",
           "normalizing date format to",
           "lower case character in document title",
           "duplicate RCS id",
           "possible typo in section name",
           "unterminated quoted argument",
         "useless macro",          "useless macro",
         "consider using OS macro",          "consider using OS macro",
         "errnos out of order",          "errnos out of order",
         "duplicate errno",          "duplicate errno",
         "description line ends with a full stop",          "trailing delimiter",
           "no blank before trailing delimiter",
           "fill mode already enabled, skipping",
           "fill mode already disabled, skipping",
           "verbatim \"--\", maybe consider using \\(em",
           "function name without markup",
           "whitespace at end of input line",
           "bad comment style",
   
         "generic warning",          "generic warning",
   
         /* related to the prologue */          /* related to the prologue */
         "missing manual title, using UNTITLED",          "missing manual title, using UNTITLED",
         "missing manual title, using \"\"",          "missing manual title, using \"\"",
         "lower case character in document title",  
         "missing manual section, using \"\"",          "missing manual section, using \"\"",
         "unknown manual section",          "unknown manual section",
         "missing date, using today's date",          "missing date, using today's date",
         "cannot parse date, using it verbatim",          "cannot parse date, using it verbatim",
           "date in the future, using it anyway",
         "missing Os macro, using \"\"",          "missing Os macro, using \"\"",
         "duplicate prologue macro",  
         "late prologue macro",          "late prologue macro",
         "skipping late title macro",  
         "prologue macros out of order",          "prologue macros out of order",
   
         /* related to document structure */          /* related to document structure */
Line 125  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 141  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "sections out of conventional order",          "sections out of conventional order",
         "duplicate section title",          "duplicate section title",
         "unexpected section",          "unexpected section",
           "cross reference to self",
         "unusual Xr order",          "unusual Xr order",
         "unusual Xr punctuation",          "unusual Xr punctuation",
         "AUTHORS section without An macro",          "AUTHORS section without An macro",
Line 138  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 155  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "blocks badly nested",          "blocks badly nested",
         "nested displays are not portable",          "nested displays are not portable",
         "moving content out of list",          "moving content out of list",
         "fill mode already enabled, skipping",          "first macro on line",
         "fill mode already disabled, skipping",  
         "line scope broken",          "line scope broken",
         "skipping blank line in line scope",          "skipping blank line in line scope",
   
Line 156  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 172  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "missing function name, using \"\"",          "missing function name, using \"\"",
         "empty head in list item",          "empty head in list item",
         "empty list item",          "empty list item",
           "missing argument, using next line",
         "missing font type, using \\fR",          "missing font type, using \\fR",
         "unknown font type, using \\fR",          "unknown font type, using \\fR",
         "nothing follows prefix",          "nothing follows prefix",
Line 167  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 184  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "missing eqn box, using \"\"",          "missing eqn box, using \"\"",
   
         /* related to bad macro arguments */          /* related to bad macro arguments */
         "unterminated quoted argument",  
         "duplicate argument",          "duplicate argument",
         "skipping duplicate argument",          "skipping duplicate argument",
         "skipping duplicate display type",          "skipping duplicate display type",
Line 177  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 193  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "unknown AT&T UNIX version",          "unknown AT&T UNIX version",
         "comma in function argument",          "comma in function argument",
         "parenthesis in function name",          "parenthesis in function name",
           "unknown library name",
         "invalid content in Rs block",          "invalid content in Rs block",
         "invalid Boolean argument",          "invalid Boolean argument",
         "unknown font, skipping request",          "unknown font, skipping request",
Line 185  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 202  static const char * const mandocerrs[MANDOCERR_MAX] = 
         /* related to plain text */          /* related to plain text */
         "blank line in fill mode, using .sp",          "blank line in fill mode, using .sp",
         "tab in filled text",          "tab in filled text",
         "whitespace at end of input line",  
         "new sentence, new line",          "new sentence, new line",
         "bad comment style",  
         "invalid escape sequence",          "invalid escape sequence",
         "undefined string, using \"\"",          "undefined string, using \"\"",
   
Line 213  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 228  static const char * const mandocerrs[MANDOCERR_MAX] = 
   
         /* related to document structure and macros */          /* related to document structure and macros */
         NULL,          NULL,
           "duplicate prologue macro",
           "skipping late title macro",
         "input stack limit exceeded, infinite loop?",          "input stack limit exceeded, infinite loop?",
         "skipping bad character",          "skipping bad character",
         "skipping unknown macro",          "skipping unknown macro",
Line 324  choose_parser(struct mparse *curp)
Line 341  choose_parser(struct mparse *curp)
 static int  static int
 mparse_buf_r(struct mparse *curp, struct buf blk, size_t i, int start)  mparse_buf_r(struct mparse *curp, struct buf blk, size_t i, int start)
 {  {
         const struct tbl_span   *span;  
         struct buf       ln;          struct buf       ln;
         const char      *save_file;          const char      *save_file;
         char            *cp;          char            *cp;
Line 515  rerun:
Line 531  rerun:
                 if (curp->man->macroset == MACROSET_NONE)                  if (curp->man->macroset == MACROSET_NONE)
                         choose_parser(curp);                          choose_parser(curp);
   
                 /*                  if ((curp->man->macroset == MACROSET_MDOC ?
                  * Lastly, push down into the parsers themselves.  
                  * If libroff returns ROFF_TBL, then add it to the  
                  * currently open parse.  Since we only get here if  
                  * there does exist data (see tbl_data.c), we're  
                  * guaranteed that something's been allocated.  
                  * Do the same for ROFF_EQN.  
                  */  
   
                 if (rr == ROFF_TBL)  
                         while ((span = roff_span(curp->roff)) != NULL)  
                                 roff_addtbl(curp->man, span);  
                 else if (rr == ROFF_EQN)  
                         roff_addeqn(curp->man, roff_eqn(curp->roff));  
                 else if ((curp->man->macroset == MACROSET_MDOC ?  
                     mdoc_parseln(curp->man, curp->line, ln.buf, of) :                      mdoc_parseln(curp->man, curp->line, ln.buf, of) :
                     man_parseln(curp->man, curp->line, ln.buf, of)) == 2)                      man_parseln(curp->man, curp->line, ln.buf, of)) == 2)
                                 break;                                  break;
Line 556  read_whole_file(struct mparse *curp, const char *file,
Line 558  read_whole_file(struct mparse *curp, const char *file,
         gzFile           gz;          gzFile           gz;
         size_t           off;          size_t           off;
         ssize_t          ssz;          ssize_t          ssz;
           int              gzerrnum, retval;
   
         if (fstat(fd, &st) == -1)          if (fstat(fd, &st) == -1) {
                 err((int)MANDOCLEVEL_SYSERR, "%s", file);                  mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0,
                       "fstat: %s", strerror(errno));
                   return 0;
           }
   
         /*          /*
          * If we're a regular file, try just reading in the whole entry           * If we're a regular file, try just reading in the whole entry
Line 580  read_whole_file(struct mparse *curp, const char *file,
Line 586  read_whole_file(struct mparse *curp, const char *file,
         }          }
   
         if (curp->gzip) {          if (curp->gzip) {
                 if ((gz = gzdopen(fd, "rb")) == NULL)                  /*
                         err((int)MANDOCLEVEL_SYSERR, "%s", file);                   * Duplicating the file descriptor is required
                    * because we will have to call gzclose(3)
                    * to free memory used internally by zlib,
                    * but that will also close the file descriptor,
                    * which this function must not do.
                    */
                   if ((fd = dup(fd)) == -1) {
                           mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0,
                               "dup: %s", strerror(errno));
                           return 0;
                   }
                   if ((gz = gzdopen(fd, "rb")) == NULL) {
                           mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0,
                               "gzdopen: %s", strerror(errno));
                           close(fd);
                           return 0;
                   }
         } else          } else
                 gz = NULL;                  gz = NULL;
   
Line 592  read_whole_file(struct mparse *curp, const char *file,
Line 614  read_whole_file(struct mparse *curp, const char *file,
   
         *with_mmap = 0;          *with_mmap = 0;
         off = 0;          off = 0;
           retval = 0;
         fb->sz = 0;          fb->sz = 0;
         fb->buf = NULL;          fb->buf = NULL;
         for (;;) {          for (;;) {
Line 608  read_whole_file(struct mparse *curp, const char *file,
Line 631  read_whole_file(struct mparse *curp, const char *file,
                     read(fd, fb->buf + (int)off, fb->sz - off);                      read(fd, fb->buf + (int)off, fb->sz - off);
                 if (ssz == 0) {                  if (ssz == 0) {
                         fb->sz = off;                          fb->sz = off;
                         return 1;                          retval = 1;
                           break;
                 }                  }
                 if (ssz == -1)                  if (ssz == -1) {
                         err((int)MANDOCLEVEL_SYSERR, "%s", file);                          if (curp->gzip)
                                   (void)gzerror(gz, &gzerrnum);
                           mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0, "read: %s",
                               curp->gzip && gzerrnum != Z_ERRNO ?
                               zError(gzerrnum) : strerror(errno));
                           break;
                   }
                 off += (size_t)ssz;                  off += (size_t)ssz;
         }          }
   
         free(fb->buf);          if (curp->gzip && (gzerrnum = gzclose(gz)) != Z_OK)
         fb->buf = NULL;                  mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0, "gzclose: %s",
         return 0;                      gzerrnum == Z_ERRNO ? strerror(errno) :
                       zError(gzerrnum));
           if (retval == 0) {
                   free(fb->buf);
                   fb->buf = NULL;
           }
           return retval;
 }  }
   
 static void  static void
Line 747  mparse_open(struct mparse *curp, const char *file)
Line 783  mparse_open(struct mparse *curp, const char *file)
 }  }
   
 struct mparse *  struct mparse *
 mparse_alloc(int options, enum mandoclevel wlevel, mandocmsg mmsg,  mparse_alloc(int options, enum mandocerr mmin, mandocmsg mmsg,
     const char *defos)      enum mandoc_os os_e, const char *os_s)
 {  {
         struct mparse   *curp;          struct mparse   *curp;
   
         curp = mandoc_calloc(1, sizeof(struct mparse));          curp = mandoc_calloc(1, sizeof(struct mparse));
   
         curp->options = options;          curp->options = options;
         curp->wlevel = wlevel;          curp->mmin = mmin;
         curp->mmsg = mmsg;          curp->mmsg = mmsg;
         curp->defos = defos;          curp->os_s = os_s;
   
         curp->roff = roff_alloc(curp, options);          curp->roff = roff_alloc(curp, options);
         curp->man = roff_man_alloc( curp->roff, curp, curp->defos,          curp->man = roff_man_alloc(curp->roff, curp, curp->os_s,
                 curp->options & MPARSE_QUICK ? 1 : 0);                  curp->options & MPARSE_QUICK ? 1 : 0);
         if (curp->options & MPARSE_MDOC) {          if (curp->options & MPARSE_MDOC) {
                 curp->man->macroset = MACROSET_MDOC;                  curp->man->macroset = MACROSET_MDOC;
Line 772  mparse_alloc(int options, enum mandoclevel wlevel, man
Line 808  mparse_alloc(int options, enum mandoclevel wlevel, man
                         curp->man->manmac = roffhash_alloc(MAN_TH, MAN_MAX);                          curp->man->manmac = roffhash_alloc(MAN_TH, MAN_MAX);
         }          }
         curp->man->first->tok = TOKEN_NONE;          curp->man->first->tok = TOKEN_NONE;
           curp->man->meta.os_e = os_e;
         return curp;          return curp;
 }  }
   
Line 847  mandoc_msg(enum mandocerr er, struct mparse *m,
Line 884  mandoc_msg(enum mandocerr er, struct mparse *m,
 {  {
         enum mandoclevel level;          enum mandoclevel level;
   
           if (er < m->mmin && er != MANDOCERR_FILE)
                   return;
   
         level = MANDOCLEVEL_UNSUPP;          level = MANDOCLEVEL_UNSUPP;
         while (er < mandoclimits[level])          while (er < mandoclimits[level])
                 level--;                  level--;
   
         if (level < m->wlevel && er != MANDOCERR_FILE)  
                 return;  
   
         if (m->mmsg)          if (m->mmsg)
                 (*m->mmsg)(er, level, m->file, ln, col, msg);                  (*m->mmsg)(er, level, m->file, ln, col, msg);
Legend:
Removed from v.1.172  
changed lines
  Added in v.1.196
CVSweb