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

Diff for /mandoc/read.c between version 1.74 and 1.86

version 1.74, 2014/07/30 23:38:52 version 1.86, 2014/09/07 23:25:01
Line 16 
Line 16 
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */   */
 #ifdef HAVE_CONFIG_H  
 #include "config.h"  #include "config.h"
 #endif  
   
 #ifdef HAVE_MMAP  #include <sys/types.h>
 # include <sys/stat.h>  #if HAVE_MMAP
 # include <sys/mman.h>  #include <sys/mman.h>
   #include <sys/stat.h>
 #endif  #endif
   #include <sys/wait.h>
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
Line 51  struct buf {
Line 51  struct buf {
 };  };
   
 struct  mparse {  struct  mparse {
         enum mandoclevel  file_status; /* status of current parse */  
         enum mandoclevel  wlevel; /* ignore messages below this */  
         int               line; /* line number in the file */  
         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 */          char             *sodest; /* filename pointed to by .so */
         int               reparse_count; /* finite interp. stack */          const char       *file; /* filename of current input file */
         mandocmsg         mmsg; /* warning/error message handler */          struct buf       *primary; /* buffer currently being parsed */
         const char       *file;          struct buf       *secondary; /* preprocessed copy of input */
         struct buf       *secondary;  
         const char       *defos; /* default operating system */          const char       *defos; /* default operating system */
           mandocmsg         mmsg; /* warning/error message handler */
           enum mandoclevel  file_status; /* status of current parse */
           enum mandoclevel  wlevel; /* ignore messages below this */
           int               options; /* parser options */
           int               reparse_count; /* finite interp. stack */
           int               line; /* line number in the file */
 };  };
   
   static  void      choose_parser(struct mparse *);
 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      pset(const char *, int, struct mparse *);  
 static  int       read_whole_file(struct mparse *, const char *, int,  static  int       read_whole_file(struct mparse *, const char *, int,
                                 struct buf *, int *);                                  struct buf *, int *);
 static  void      mparse_end(struct mparse *);  static  void      mparse_end(struct mparse *);
Line 93  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 94  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "generic warning",          "generic warning",
   
         /* related to the prologue */          /* related to the prologue */
         "missing .TH macro, using \"unknown 1\"",          "missing manual title, using UNTITLED",
           "missing manual title, using \"\"",
         "lower case character in document title",          "lower case character in document title",
           "missing manual section, using \"\"",
         "unknown manual section",          "unknown manual section",
         "unknown manual volume or arch",          "unknown manual volume or arch",
         "missing date, 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",          "missing Os macro, using \"\"",
         "duplicate prologue macro",          "duplicate prologue macro",
         "incomplete prologue, terminated by",          "late prologue macro",
         "skipping prologue macro in body",          "skipping late title macro",
           "prologue macros out of order",
   
         /* related to document structure */          /* related to document structure */
         ".so is fragile, better use ln(1)",          ".so is fragile, better use ln(1)",
Line 113  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 117  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",
           "AUTHORS section without An macro",
   
         /* related to macros and nesting */          /* related to macros and nesting */
         "obsolete macro",          "obsolete macro",
Line 123  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 128  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "nested displays are not portable",          "nested displays are not portable",
         "moving content out of list",          "moving content out of list",
         ".Vt block has child macro",          ".Vt block has child macro",
         "fill mode already enabled, skipping .fi",          "fill mode already enabled, skipping",
         "fill mode already disabled, skipping .nf",          "fill mode already disabled, skipping",
         "line scope broken",          "line scope broken",
   
         /* related to missing macro arguments */          /* related to missing macro arguments */
Line 136  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 141  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "missing display type, using -ragged",          "missing display type, using -ragged",
         "list type is not the first argument",          "list type is not the first argument",
         "missing -width in -tag list, using 8n",          "missing -width in -tag list, using 8n",
         "missing name for .Ex, using \"\"",          "missing utility name, using \"\"",
         "empty head in list item",          "empty head in list item",
         "empty list item",          "empty list item",
         "missing font type, using \\fR",          "missing font type, using \\fR",
Line 144  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 149  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "missing -std argument, adding it",          "missing -std argument, adding it",
   
         /* related to bad macro arguments */          /* related to bad macro arguments */
         "skipping argument",  
         "unterminated quoted argument",          "unterminated quoted argument",
         "duplicate argument",          "duplicate argument",
           "skipping duplicate argument",
         "skipping duplicate display type",          "skipping duplicate display type",
         "skipping duplicate list type",          "skipping duplicate list type",
           "skipping -width argument",
         "unknown AT&T UNIX version",          "unknown AT&T UNIX version",
         "invalid content in Rs block",          "invalid content in Rs block",
         "invalid Boolean argument",          "invalid Boolean argument",
Line 205  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 211  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "generic fatal error",          "generic fatal error",
   
         "input too large",          "input too large",
         "column syntax is inconsistent",          "NOT IMPLEMENTED: Bd -file",
         "NOT IMPLEMENTED: .Bd -file",  
         "NOT IMPLEMENTED: .so with absolute path or \"..\"",          "NOT IMPLEMENTED: .so with absolute path or \"..\"",
         ".so request failed",          ".so request failed",
         "static buffer exhausted",  
   
         /* system errors */          /* system errors */
           "cannot dup file descriptor",
           "cannot exec",
           "gunzip failed with code",
           "cannot fork",
         NULL,          NULL,
         "cannot stat file",          "cannot open pipe",
         "cannot read file",          "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 237  resize_buf(struct buf *buf, size_t initial)
Line 248  resize_buf(struct buf *buf, size_t initial)
 }  }
   
 static void  static void
 pset(const char *buf, int pos, struct mparse *curp)  choose_parser(struct mparse *curp)
 {  {
         int              i;          char            *cp, *ep;
           int              format;
   
         /*          /*
          * Try to intuit which kind of manual parser should be used.  If           * If neither command line arguments -mdoc or -man select
          * passed in by command-line (-man, -mdoc), then use that           * a parser nor the roff parser found a .Dd or .TH macro
          * explicitly.  If passed as -mandoc, then try to guess from the           * yet, look ahead in the main input buffer.
          * line: either skip dot-lines, use -mdoc when finding `.Dt', or  
          * default to -man, which is more lenient.  
          *  
          * Separate out pmdoc/pman from mdoc/man: the first persists  
          * through all parsers, while the latter is used per-parse.  
          */           */
   
         if ('.' == buf[0] || '\'' == buf[0]) {          if ((format = roff_getformat(curp->roff)) == 0) {
                 for (i = 1; buf[i]; i++)                  cp = curp->primary->buf;
                         if (' ' != buf[i] && '\t' != buf[i])                  ep = cp + curp->primary->sz;
                   while (cp < ep) {
                           if (*cp == '.' || *cp == '\'') {
                                   cp++;
                                   if (cp[0] == 'D' && cp[1] == 'd') {
                                           format = MPARSE_MDOC;
                                           break;
                                   }
                                   if (cp[0] == 'T' && cp[1] == 'H') {
                                           format = MPARSE_MAN;
                                           break;
                                   }
                           }
                           cp = memchr(cp, '\n', ep - cp);
                           if (cp == NULL)
                                 break;                                  break;
                 if ('\0' == buf[i])                          cp++;
                         return;                  }
         }          }
   
         if (MPARSE_MDOC & curp->options) {          if (format == MPARSE_MDOC) {
                 curp->mdoc = curp->pmdoc;  
                 return;  
         } else if (MPARSE_MAN & curp->options) {  
                 curp->man = curp->pman;  
                 return;  
         }  
   
         if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {  
                 if (NULL == curp->pmdoc)                  if (NULL == curp->pmdoc)
                         curp->pmdoc = mdoc_alloc(                          curp->pmdoc = mdoc_alloc(
                             curp->roff, curp, curp->defos,                              curp->roff, curp, curp->defos,
Line 278  pset(const char *buf, int pos, struct mparse *curp)
Line 291  pset(const char *buf, int pos, struct mparse *curp)
                 return;                  return;
         }          }
   
           /* 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,
                     MPARSE_QUICK & curp->options ? 1 : 0);                      MPARSE_QUICK & curp->options ? 1 : 0);
Line 354  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 369  mparse_buf_r(struct mparse *curp, struct buf blk, int 
   
                         if ( ! (isascii(c) &&                          if ( ! (isascii(c) &&
                             (isgraph(c) || isblank(c)))) {                              (isgraph(c) || isblank(c)))) {
                                 mandoc_msg(MANDOCERR_BADCHAR, curp,                                  mandoc_vmsg(MANDOCERR_BADCHAR, curp,
                                     curp->line, pos, NULL);                                      curp->line, pos, "0x%x", c);
                                 i++;                                  i++;
                                 ln.buf[pos++] = '?';                                  ln.buf[pos++] = '?';
                                 continue;                                  continue;
Line 411  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 426  mparse_buf_r(struct mparse *curp, struct buf blk, int 
   
                         if ( ! (isascii(c) &&                          if ( ! (isascii(c) &&
                             (isgraph(c) || isblank(c)))) {                              (isgraph(c) || isblank(c)))) {
                                 mandoc_msg(MANDOCERR_BADCHAR, curp,                                  mandoc_vmsg(MANDOCERR_BADCHAR, curp,
                                     curp->line, pos, NULL);                                      curp->line, pos, "0x%x", c);
                                 i += 2;                                  i += 2;
                                 ln.buf[pos++] = '?';                                  ln.buf[pos++] = '?';
                                 continue;                                  continue;
Line 527  rerun:
Line 542  rerun:
                  */                   */
   
                 if ( ! (curp->man || curp->mdoc))                  if ( ! (curp->man || curp->mdoc))
                         pset(ln.buf + of, pos - of, curp);                          choose_parser(curp);
   
                 /*                  /*
                  * Lastly, push down into the parsers themselves.  One                   * Lastly, push down into the parsers themselves.
                  * of these will have already been set in the pset()  
                  * routine.  
                  * If libroff returns ROFF_TBL, then add it to the                   * If libroff returns ROFF_TBL, then add it to the
                  * currently open parse.  Since we only get here if                   * currently open parse.  Since we only get here if
                  * there does exist data (see tbl_data.c), we're                   * there does exist data (see tbl_data.c), we're
Line 589  read_whole_file(struct mparse *curp, const char *file,
Line 602  read_whole_file(struct mparse *curp, const char *file,
         size_t           off;          size_t           off;
         ssize_t          ssz;          ssize_t          ssz;
   
 #ifdef  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;                  curp->file_status = MANDOCLEVEL_SYSERR;
Line 700  mparse_end(struct mparse *curp)
Line 713  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)
 {  {
           struct buf      *svprimary;
         const char      *svfile;          const char      *svfile;
         static int       recursion_depth;          static int       recursion_depth;
   
Line 711  mparse_parse_buffer(struct mparse *curp, struct buf bl
Line 725  mparse_parse_buffer(struct mparse *curp, struct buf bl
         /* Line number is per-file. */          /* Line number is per-file. */
         svfile = curp->file;          svfile = curp->file;
         curp->file = file;          curp->file = file;
           svprimary = curp->primary;
           curp->primary = &blk;
         curp->line = 1;          curp->line = 1;
         recursion_depth++;          recursion_depth++;
   
Line 719  mparse_parse_buffer(struct mparse *curp, struct buf bl
Line 735  mparse_parse_buffer(struct mparse *curp, struct buf bl
         if (0 == --recursion_depth && MANDOCLEVEL_FATAL > curp->file_status)          if (0 == --recursion_depth && MANDOCLEVEL_FATAL > curp->file_status)
                 mparse_end(curp);                  mparse_end(curp);
   
           curp->primary = svprimary;
         curp->file = svfile;          curp->file = svfile;
 }  }
   
Line 762  mparse_readfd(struct mparse *curp, int fd, const char 
Line 779  mparse_readfd(struct mparse *curp, int fd, const char 
   
         mparse_parse_buffer(curp, blk, file);          mparse_parse_buffer(curp, blk, file);
   
 #ifdef  HAVE_MMAP  #if HAVE_MMAP
         if (with_mmap)          if (with_mmap)
                 munmap(blk.buf, blk.sz);                  munmap(blk.buf, blk.sz);
         else          else
Line 773  mparse_readfd(struct mparse *curp, int fd, const char 
Line 790  mparse_readfd(struct mparse *curp, int fd, const char 
                 perror(file);                  perror(file);
 out:  out:
         return(curp->file_status);          return(curp->file_status);
   }
   
   enum mandoclevel
   mparse_open(struct mparse *curp, int *fd, const char *file,
           pid_t *child_pid)
   {
           int               pfd[2];
           char             *cp;
           enum mandocerr    err;
   
           pfd[1] = -1;
           curp->file = file;
           if ((cp = strrchr(file, '.')) == NULL ||
               strcmp(cp + 1, "gz")) {
                   *child_pid = 0;
                   if ((*fd = open(file, O_RDONLY)) == -1) {
                           err = MANDOCERR_SYSOPEN;
                           goto out;
                   }
                   return(MANDOCLEVEL_OK);
           }
   
           if (pipe(pfd) == -1) {
                   err = MANDOCERR_SYSPIPE;
                   goto out;
           }
   
           switch (*child_pid = fork()) {
           case -1:
                   err = MANDOCERR_SYSFORK;
                   close(pfd[0]);
                   close(pfd[1]);
                   pfd[1] = -1;
                   break;
           case 0:
                   close(pfd[0]);
                   if (dup2(pfd[1], STDOUT_FILENO) == -1) {
                           err = MANDOCERR_SYSDUP;
                           break;
                   }
                   execlp("gunzip", "gunzip", "-c", file, NULL);
                   err = MANDOCERR_SYSEXEC;
                   break;
           default:
                   close(pfd[1]);
                   *fd = pfd[0];
                   return(MANDOCLEVEL_OK);
           }
   
   out:
           *fd = -1;
           *child_pid = 0;
           curp->file_status = MANDOCLEVEL_SYSERR;
           if (curp->mmsg)
                   (*curp->mmsg)(err, curp->file_status, file,
                       0, 0, strerror(errno));
           if (pfd[1] != -1)
                   exit(1);
           return(curp->file_status);
   }
   
   enum mandoclevel
   mparse_wait(struct mparse *curp, pid_t child_pid)
   {
           int       status;
   
           if (waitpid(child_pid, &status, 0) == -1) {
                   mandoc_msg(MANDOCERR_SYSWAIT, curp, 0, 0,
                       strerror(errno));
                   curp->file_status = MANDOCLEVEL_SYSERR;
                   return(curp->file_status);
           }
           if (WIFSIGNALED(status)) {
                   mandoc_vmsg(MANDOCERR_SYSSIG, curp, 0, 0,
                       "%d", WTERMSIG(status));
                   curp->file_status = MANDOCLEVEL_SYSERR;
                   return(curp->file_status);
           }
           if (WEXITSTATUS(status)) {
                   mandoc_vmsg(MANDOCERR_SYSEXIT, curp, 0, 0,
                       "%d", WEXITSTATUS(status));
                   curp->file_status = MANDOCLEVEL_SYSERR;
                   return(curp->file_status);
           }
           return(MANDOCLEVEL_OK);
 }  }
   
 struct mparse *  struct mparse *
Legend:
Removed from v.1.74  
changed lines
  Added in v.1.86
CVSweb