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

Diff for /mandoc/read.c between version 1.191 and 1.198

version 1.191, 2017/07/08 17:52:50 version 1.198, 2018/08/23 19:33:27
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 51  struct mparse {
Line 48  struct mparse {
         char             *sodest; /* filename pointed to by .so */          char             *sodest; /* filename pointed to by .so */
         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; /* copy of top level input */
         const char       *os_s; /* 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 */
Line 64  struct mparse {
Line 61  struct mparse {
 };  };
   
 static  void      choose_parser(struct mparse *);  static  void      choose_parser(struct mparse *);
   static  void      free_buf_list(struct buf *);
 static  void      resize_buf(struct buf *, size_t);  static  void      resize_buf(struct buf *, size_t);
 static  int       mparse_buf_r(struct mparse *, struct buf, size_t, int);  static  enum rofferr mparse_buf_r(struct mparse *, struct buf, size_t, int);
 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 97  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 95  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "generic style suggestion",          "generic style suggestion",
   
         "legacy man(7) date format",          "legacy man(7) date format",
           "normalizing date format to",
         "lower case character in document title",          "lower case character in document title",
         "duplicate RCS id",          "duplicate RCS id",
         "typo in section name",          "possible typo in section name",
         "unterminated quoted argument",          "unterminated quoted argument",
         "useless macro",          "useless macro",
         "consider using OS macro",          "consider using OS macro",
Line 109  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 108  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "no blank before trailing delimiter",          "no blank before trailing delimiter",
         "fill mode already enabled, skipping",          "fill mode already enabled, skipping",
         "fill mode already disabled, skipping",          "fill mode already disabled, skipping",
           "verbatim \"--\", maybe consider using \\(em",
         "function name without markup",          "function name without markup",
         "whitespace at end of input line",          "whitespace at end of input line",
         "bad comment style",          "bad comment style",
Line 234  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 234  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",
         "skipping unknown macro",          "skipping unknown macro",
           "ignoring request outside macro",
         "skipping insecure request",          "skipping insecure request",
         "skipping item outside list",          "skipping item outside list",
         "skipping column outside column list",          "skipping column outside column list",
Line 244  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 245  static const char * const mandocerrs[MANDOCERR_MAX] = 
   
         /* related to request and macro arguments */          /* related to request and macro arguments */
         "escaped character not allowed in a name",          "escaped character not allowed in a name",
           "using macro argument outside macro",
           "argument number is not numeric",
         "NOT IMPLEMENTED: Bd -file",          "NOT IMPLEMENTED: Bd -file",
         "skipping display without arguments",          "skipping display without arguments",
         "missing list type, using -item",          "missing list type, using -item",
Line 252  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 255  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "uname(3) system call failed, using UNKNOWN",          "uname(3) system call failed, using UNKNOWN",
         "unknown standard specifier",          "unknown standard specifier",
         "skipping request without numeric argument",          "skipping request without numeric argument",
           "excessive shift",
         "NOT IMPLEMENTED: .so with absolute path or \"..\"",          "NOT IMPLEMENTED: .so with absolute path or \"..\"",
         ".so request failed",          ".so request failed",
         "skipping all arguments",          "skipping all arguments",
Line 287  resize_buf(struct buf *buf, size_t initial)
Line 291  resize_buf(struct buf *buf, size_t initial)
 }  }
   
 static void  static void
   free_buf_list(struct buf *buf)
   {
           struct buf *tmp;
   
           while (buf != NULL) {
                   tmp = buf;
                   buf = tmp->next;
                   free(tmp->buf);
                   free(tmp);
           }
   }
   
   static void
 choose_parser(struct mparse *curp)  choose_parser(struct mparse *curp)
 {  {
         char            *cp, *ep;          char            *cp, *ep;
Line 339  choose_parser(struct mparse *curp)
Line 356  choose_parser(struct mparse *curp)
  * macros, inline equations, and input line traps)   * macros, inline equations, and input line traps)
  * and indirectly (for .so file inclusion).   * and indirectly (for .so file inclusion).
  */   */
 static int  static enum rofferr
 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)
 {  {
         struct buf       ln;          struct buf       ln;
           struct buf      *firstln, *lastln, *thisln;
         const char      *save_file;          const char      *save_file;
         char            *cp;          char            *cp;
         size_t           pos; /* byte number in the ln buffer */          size_t           pos; /* byte number in the ln buffer */
         enum rofferr     rr;          enum rofferr     line_result, result;
         int              of;          int              of;
         int              lnn; /* line number in the real file */          int              lnn; /* line number in the real file */
         int              fd;          int              fd;
         unsigned char    c;          unsigned char    c;
   
         memset(&ln, 0, sizeof(ln));          ln.sz = 256;
           ln.buf = mandoc_malloc(ln.sz);
           ln.next = NULL;
           firstln = NULL;
         lnn = curp->line;          lnn = curp->line;
         pos = 0;          pos = 0;
           result = ROFF_CONT;
   
         while (i < blk.sz) {          while (i < blk.sz) {
                 if (0 == pos && '\0' == blk.buf[i])                  if (0 == pos && '\0' == blk.buf[i])
Line 390  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 411  mparse_buf_r(struct mparse *curp, struct buf blk, size
   
                         /*                          /*
                          * Make sure we have space for the worst                           * Make sure we have space for the worst
                          * case of 11 bytes: "\\[u10ffff]\0"                           * case of 12 bytes: "\\[u10ffff]\n\0"
                          */                           */
   
                         if (pos + 11 > ln.sz)                          if (pos + 12 > ln.sz)
                                 resize_buf(&ln, 256);                                  resize_buf(&ln, 256);
   
                         /*                          /*
Line 429  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 450  mparse_buf_r(struct mparse *curp, struct buf blk, size
   
                         ln.buf[pos++] = blk.buf[i++];                          ln.buf[pos++] = blk.buf[i++];
                 }                  }
                   ln.buf[pos] = '\0';
   
                 if (pos + 1 >= ln.sz)                  /*
                         resize_buf(&ln, 256);                   * Maintain a lookaside buffer of all lines.
                    * parsed from this input source.
                    */
   
                 if (i == blk.sz || blk.buf[i] == '\0')                  thisln = mandoc_malloc(sizeof(*thisln));
                   thisln->buf = mandoc_strdup(ln.buf);
                   thisln->sz = strlen(ln.buf) + 1;
                   thisln->next = NULL;
                   if (firstln == NULL) {
                           firstln = lastln = thisln;
                           if (curp->secondary == NULL)
                                   curp->secondary = firstln;
                   } else {
                           lastln->next = thisln;
                           lastln = thisln;
                   }
   
                   /* XXX Ugly hack to mark the end of the input. */
   
                   if (i == blk.sz || blk.buf[i] == '\0') {
                         ln.buf[pos++] = '\n';                          ln.buf[pos++] = '\n';
                 ln.buf[pos] = '\0';                          ln.buf[pos] = '\0';
                   }
   
                 /*                  /*
                  * A significant amount of complexity is contained by                   * A significant amount of complexity is contained by
Line 447  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 487  mparse_buf_r(struct mparse *curp, struct buf blk, size
                  */                   */
   
                 of = 0;                  of = 0;
   
                 /*  
                  * Maintain a lookaside buffer of all parsed lines.  We  
                  * only do this if mparse_keep() has been invoked (the  
                  * buffer may be accessed with mparse_getkeep()).  
                  */  
   
                 if (curp->secondary) {  
                         curp->secondary->buf = mandoc_realloc(  
                             curp->secondary->buf,  
                             curp->secondary->sz + pos + 2);  
                         memcpy(curp->secondary->buf +  
                             curp->secondary->sz,  
                             ln.buf, pos);  
                         curp->secondary->sz += pos;  
                         curp->secondary->buf  
                                 [curp->secondary->sz] = '\n';  
                         curp->secondary->sz++;  
                         curp->secondary->buf  
                                 [curp->secondary->sz] = '\0';  
                 }  
 rerun:  rerun:
                 rr = roff_parseln(curp->roff, curp->line, &ln, &of);                  line_result = roff_parseln(curp->roff, curp->line, &ln, &of);
   
                 switch (rr) {                  switch (line_result) {
                 case ROFF_REPARSE:                  case ROFF_REPARSE:
                         if (++curp->reparse_count > REPARSE_LIMIT)                  case ROFF_USERCALL:
                           if (++curp->reparse_count > REPARSE_LIMIT) {
                                   result = ROFF_IGN;
                                 mandoc_msg(MANDOCERR_ROFFLOOP, curp,                                  mandoc_msg(MANDOCERR_ROFFLOOP, curp,
                                     curp->line, pos, NULL);                                      curp->line, pos, NULL);
                         else if (mparse_buf_r(curp, ln, of, 0) == 1 ||                          } else {
                             start == 1) {                                  result = mparse_buf_r(curp, ln, of, 0);
                                   if (line_result == ROFF_USERCALL) {
                                           if (result == ROFF_USERRET)
                                                   result = ROFF_CONT;
                                           roff_userret(curp->roff);
                                   }
                                   if (start || result == ROFF_CONT) {
                                           pos = 0;
                                           continue;
                                   }
                           }
                           goto out;
                   case ROFF_USERRET:
                           if (start) {
                                 pos = 0;                                  pos = 0;
                                 continue;                                  continue;
                         }                          }
                         free(ln.buf);                          result = ROFF_USERRET;
                         return 0;                          goto out;
                 case ROFF_APPEND:                  case ROFF_APPEND:
                         pos = strlen(ln.buf);                          pos = strlen(ln.buf);
                         continue;                          continue;
Line 495  rerun:
Line 529  rerun:
                         if ( ! (curp->options & MPARSE_SO) &&                          if ( ! (curp->options & MPARSE_SO) &&
                             (i >= blk.sz || blk.buf[i] == '\0')) {                              (i >= blk.sz || blk.buf[i] == '\0')) {
                                 curp->sodest = mandoc_strdup(ln.buf + of);                                  curp->sodest = mandoc_strdup(ln.buf + of);
                                 free(ln.buf);                                  goto out;
                                 return 1;  
                         }                          }
                         /*  
                          * We remove `so' clauses from our lookaside  
                          * buffer because we're going to descend into  
                          * the file recursively.  
                          */  
                         if (curp->secondary)  
                                 curp->secondary->sz -= pos + 1;  
                         save_file = curp->file;                          save_file = curp->file;
                         if ((fd = mparse_open(curp, ln.buf + of)) != -1) {                          if ((fd = mparse_open(curp, ln.buf + of)) != -1) {
                                 mparse_readfd(curp, fd, ln.buf + of);                                  mparse_readfd(curp, fd, ln.buf + of);
Line 546  rerun:
Line 572  rerun:
   
                 pos = 0;                  pos = 0;
         }          }
   out:
         free(ln.buf);          free(ln.buf);
         return 1;          if (firstln != curp->secondary)
                   free_buf_list(firstln);
           return result;
 }  }
   
 static int  static int
Line 559  read_whole_file(struct mparse *curp, const char *file,
Line 587  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 583  read_whole_file(struct mparse *curp, const char *file,
Line 615  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 595  read_whole_file(struct mparse *curp, const char *file,
Line 643  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 611  read_whole_file(struct mparse *curp, const char *file,
Line 660  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 784  mparse_reset(struct mparse *curp)
Line 846  mparse_reset(struct mparse *curp)
 {  {
         roff_reset(curp->roff);          roff_reset(curp->roff);
         roff_man_reset(curp->man);          roff_man_reset(curp->man);
           free_buf_list(curp->secondary);
           curp->secondary = NULL;
   
         free(curp->sodest);          free(curp->sodest);
         curp->sodest = NULL;          curp->sodest = NULL;
   
         if (curp->secondary)  
                 curp->secondary->sz = 0;  
   
         curp->file_status = MANDOCLEVEL_OK;          curp->file_status = MANDOCLEVEL_OK;
         curp->gzip = 0;          curp->gzip = 0;
 }  }
Line 798  mparse_reset(struct mparse *curp)
Line 859  mparse_reset(struct mparse *curp)
 void  void
 mparse_free(struct mparse *curp)  mparse_free(struct mparse *curp)
 {  {
   
         roffhash_free(curp->man->mdocmac);          roffhash_free(curp->man->mdocmac);
         roffhash_free(curp->man->manmac);          roffhash_free(curp->man->manmac);
         roff_man_free(curp->man);          roff_man_free(curp->man);
         roff_free(curp->roff);          roff_free(curp->roff);
         if (curp->secondary)          free_buf_list(curp->secondary);
                 free(curp->secondary->buf);  
   
         free(curp->secondary);  
         free(curp->sodest);          free(curp->sodest);
         free(curp);          free(curp);
 }  }
Line 879  mparse_strlevel(enum mandoclevel lvl)
Line 936  mparse_strlevel(enum mandoclevel lvl)
 }  }
   
 void  void
 mparse_keep(struct mparse *p)  mparse_copy(const struct mparse *p)
 {  {
           struct buf      *buf;
   
         assert(NULL == p->secondary);          for (buf = p->secondary; buf != NULL; buf = buf->next)
         p->secondary = mandoc_calloc(1, sizeof(struct buf));                  puts(buf->buf);
 }  
   
 const char *  
 mparse_getkeep(const struct mparse *p)  
 {  
   
         assert(p->secondary);  
         return p->secondary->sz ? p->secondary->buf : NULL;  
 }  }
Legend:
Removed from v.1.191  
changed lines
  Added in v.1.198
CVSweb