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

Diff for /mandoc/read.c between version 1.28 and 1.41

version 1.28, 2012/02/16 20:51:31 version 1.41, 2014/01/05 20:26:36
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 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2010-2014 Ingo Schwarze <schwarze@openbsd.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 26 
   
 #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 40 
Line 41 
 #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 {
Line 63  struct mparse {
Line 60  struct mparse {
         struct roff      *roff; /* roff parser (!NULL) */          struct roff      *roff; /* roff parser (!NULL) */
         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 */
           int               quick; /* abort the parse early */
 };  };
   
 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 94  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 94  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "no title in document",          "no title 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",
         "date missing, using today's date",          "date missing, 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",
Line 105  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 106  static const char * const mandocerrs[MANDOCERR_MAX] = 
         ".so is fragile, better use ln(1)",          ".so is fragile, better use ln(1)",
         "NAME section must come first",          "NAME section must come first",
         "bad NAME section contents",          "bad NAME section contents",
         "manual name not yet set",  
         "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",
         "skipping paragraph macro",          "skipping paragraph macro",
           "moving paragraph macro out of list",
         "skipping no-space macro",          "skipping no-space macro",
         "blocks badly nested",          "blocks badly nested",
         "child violates parent syntax",          "child violates parent syntax",
Line 173  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 174  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "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",          "escaped character not allowed in a name",
           "manual name not yet set",
         "skipping text before the first section header",          "skipping text before the first section header",
         "skipping unknown macro",          "skipping unknown macro",
         "NOT IMPLEMENTED, please use groff: skipping request",          "NOT IMPLEMENTED, please use groff: skipping request",
         "argument count wrong",          "argument count wrong",
           "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",          "missing end of block",
         "scope open on exit",          "scope open on exit",
Line 184  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 187  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 200  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 205  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 247  pset(const char *buf, int pos, struct mparse *curp)
Line 257  pset(const char *buf, int pos, struct mparse *curp)
         switch (curp->inttype) {          switch (curp->inttype) {
         case (MPARSE_MDOC):          case (MPARSE_MDOC):
                 if (NULL == curp->pmdoc)                  if (NULL == curp->pmdoc)
                         curp->pmdoc = mdoc_alloc(curp->roff, curp);                          curp->pmdoc = mdoc_alloc(curp->roff, curp,
                                           curp->defos, curp->quick);
                 assert(curp->pmdoc);                  assert(curp->pmdoc);
                 curp->mdoc = curp->pmdoc;                  curp->mdoc = curp->pmdoc;
                 return;                  return;
         case (MPARSE_MAN):          case (MPARSE_MAN):
                 if (NULL == curp->pman)                  if (NULL == curp->pman)
                         curp->pman = man_alloc(curp->roff, curp);                          curp->pman = man_alloc(curp->roff, curp,
                                           curp->quick);
                 assert(curp->pman);                  assert(curp->pman);
                 curp->man = curp->pman;                  curp->man = curp->pman;
                 return;                  return;
Line 263  pset(const char *buf, int pos, struct mparse *curp)
Line 275  pset(const char *buf, int pos, struct mparse *curp)
   
         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->roff, curp,
                                           curp->defos, curp->quick);
                 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, curp->quick);
         assert(curp->pman);          assert(curp->pman);
         curp->man = curp->pman;          curp->man = curp->pman;
 }  }
Line 322  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 335  mparse_buf_r(struct mparse *curp, struct buf blk, int 
                                 break;                                  break;
                         }                          }
   
                           /*
                            * Make sure we have space for at least
                            * one backslash and one other character
                            * and the trailing NUL byte.
                            */
   
                           if (pos + 2 >= (int)ln.sz)
                                   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
Line 338  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 360  mparse_buf_r(struct mparse *curp, struct buf blk, int 
                                 mandoc_msg(MANDOCERR_BADCHAR, curp,                                  mandoc_msg(MANDOCERR_BADCHAR, curp,
                                                 curp->line, pos, NULL);                                                  curp->line, pos, NULL);
                                 i++;                                  i++;
                                 if (pos >= (int)ln.sz)  
                                         resize_buf(&ln, 256);  
                                 ln.buf[pos++] = '?';                                  ln.buf[pos++] = '?';
                                 continue;                                  continue;
                         }                          }
Line 347  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 367  mparse_buf_r(struct mparse *curp, struct buf blk, int 
                         /* Trailing backslash = a plain char. */                          /* Trailing backslash = a plain char. */
   
                         if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {                          if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {
                                 if (pos >= (int)ln.sz)  
                                         resize_buf(&ln, 256);  
                                 ln.buf[pos++] = blk.buf[i++];                                  ln.buf[pos++] = blk.buf[i++];
                                 continue;                                  continue;
                         }                          }
Line 390  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 408  mparse_buf_r(struct mparse *curp, struct buf blk, int 
                                 break;                                  break;
                         }                          }
   
                         /* Some other escape sequence, copy & cont. */                          /* Catch escaped bogus characters. */
   
                         if (pos + 1 >= (int)ln.sz)                          c = (unsigned char) blk.buf[i+1];
                                 resize_buf(&ln, 256);  
   
                           if ( ! (isascii(c) &&
                                           (isgraph(c) || isblank(c)))) {
                                   mandoc_msg(MANDOCERR_BADCHAR, curp,
                                                   curp->line, pos, NULL);
                                   i += 2;
                                   ln.buf[pos++] = '?';
                                   continue;
                           }
   
                           /* Some other escape sequence, copy & cont. */
   
                         ln.buf[pos++] = blk.buf[i++];                          ln.buf[pos++] = blk.buf[i++];
                         ln.buf[pos++] = blk.buf[i++];                          ln.buf[pos++] = blk.buf[i++];
                 }                  }
Line 469  rerun:
Line 497  rerun:
                          */                           */
                         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 533  rerun:
Line 561  rerun:
                 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 549  rerun:
Line 578  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 557  read_whole_file(const char *file, int fd, struct buf *
Line 587  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 570  read_whole_file(const char *file, int fd, struct buf *
Line 603  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 594  read_whole_file(const char *file, int fd, struct buf *
Line 629  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 605  read_whole_file(const char *file, int fd, struct buf *
Line 644  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 643  mparse_end(struct mparse *curp)
Line 686  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 670  mparse_readmem(struct mparse *curp, const void *buf, s
Line 719  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 693  mparse_readfd_r(struct mparse *curp, int fd, const cha
Line 745  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 709  mparse_readfd_r(struct mparse *curp, int fd, const cha
Line 759  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, mandocmsg mmsg, void *arg)  mparse_alloc(enum mparset inttype, enum mandoclevel wlevel,
                   mandocmsg mmsg, char *defos, int quick)
 {  {
         struct mparse   *curp;          struct mparse   *curp;
   
Line 730  mparse_alloc(enum mparset inttype, enum mandoclevel wl
Line 775  mparse_alloc(enum mparset inttype, enum mandoclevel wl
   
         curp->wlevel = wlevel;          curp->wlevel = wlevel;
         curp->mmsg = mmsg;          curp->mmsg = mmsg;
         curp->arg = arg;  
         curp->inttype = inttype;          curp->inttype = inttype;
           curp->defos = defos;
           curp->quick = quick;
   
         curp->roff = roff_alloc(curp);          curp->roff = roff_alloc(inttype, curp);
         return(curp);          return(curp);
 }  }
   
Legend:
Removed from v.1.28  
changed lines
  Added in v.1.41
CVSweb