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

Diff for /mandoc/read.c between version 1.206 and 1.215

version 1.206, 2018/12/14 05:18:03 version 1.215, 2020/03/13 15:32:28
Line 1 
Line 1 
 /*      $Id$ */  /* $Id$ */
 /*  /*
    * Copyright (c) 2010-2019 Ingo Schwarze <schwarze@openbsd.org>
  * 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-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 15 
Line 15 
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * 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.
    *
    * Top-level functions of the mandoc(3) parser:
    * Parser and input encoding selection, decompression,
    * handling of input bytes, characters, lines, and files,
    * handling of roff(7) loops and file inclusion,
    * and steering of the various parsers.
  */   */
 #include "config.h"  #include "config.h"
   
Line 36 
Line 42 
 #include "mandoc_aux.h"  #include "mandoc_aux.h"
 #include "mandoc.h"  #include "mandoc.h"
 #include "roff.h"  #include "roff.h"
   #include "tag.h"
 #include "mdoc.h"  #include "mdoc.h"
 #include "man.h"  #include "man.h"
 #include "mandoc_parse.h"  #include "mandoc_parse.h"
Line 47 
Line 54 
 struct  mparse {  struct  mparse {
         struct roff      *roff; /* roff parser (!NULL) */          struct roff      *roff; /* roff parser (!NULL) */
         struct roff_man  *man; /* man parser */          struct roff_man  *man; /* man parser */
         char             *sodest; /* filename pointed to by .so */  
         struct buf       *primary; /* buffer currently being parsed */          struct buf       *primary; /* buffer currently being parsed */
         struct buf       *secondary; /* copy of top level input */          struct buf       *secondary; /* copy of top level input */
         struct buf       *loop; /* open .while request line */          struct buf       *loop; /* open .while request line */
Line 123  choose_parser(struct mparse *curp)
Line 129  choose_parser(struct mparse *curp)
         }          }
   
         if (format == MPARSE_MDOC) {          if (format == MPARSE_MDOC) {
                 curp->man->macroset = MACROSET_MDOC;                  curp->man->meta.macroset = MACROSET_MDOC;
                 if (curp->man->mdocmac == NULL)                  if (curp->man->mdocmac == NULL)
                         curp->man->mdocmac = roffhash_alloc(MDOC_Dd, MDOC_MAX);                          curp->man->mdocmac = roffhash_alloc(MDOC_Dd, MDOC_MAX);
         } else {          } else {
                 curp->man->macroset = MACROSET_MAN;                  curp->man->meta.macroset = MACROSET_MAN;
                 if (curp->man->manmac == NULL)                  if (curp->man->manmac == NULL)
                         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->meta.first->tok = TOKEN_NONE;
 }  }
   
 /*  /*
Line 158  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 164  mparse_buf_r(struct mparse *curp, struct buf blk, size
         ln.sz = 256;          ln.sz = 256;
         ln.buf = mandoc_malloc(ln.sz);          ln.buf = mandoc_malloc(ln.sz);
         ln.next = NULL;          ln.next = NULL;
         firstln = loop = NULL;          firstln = lastln = loop = NULL;
         lnn = curp->line;          lnn = curp->line;
         pos = 0;          pos = 0;
         inloop = 0;          inloop = 0;
Line 256  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 262  mparse_buf_r(struct mparse *curp, struct buf blk, size
                 /* XXX Ugly hack to mark the end of the input. */                  /* XXX Ugly hack to mark the end of the input. */
   
                 if (i == blk.sz || blk.buf[i] == '\0') {                  if (i == blk.sz || blk.buf[i] == '\0') {
                           if (pos + 2 > ln.sz)
                                   resize_buf(&ln, 256);
                         ln.buf[pos++] = '\n';                          ln.buf[pos++] = '\n';
                         ln.buf[pos] = '\0';                          ln.buf[pos] = '\0';
                 }                  }
Line 334  rerun:
Line 342  rerun:
                 case ROFF_IGN:                  case ROFF_IGN:
                         break;                          break;
                 case ROFF_CONT:                  case ROFF_CONT:
                         if (curp->man->macroset == MACROSET_NONE)                          if (curp->man->meta.macroset == MACROSET_NONE)
                                 choose_parser(curp);                                  choose_parser(curp);
                         if ((curp->man->macroset == MACROSET_MDOC ?                          if ((curp->man->meta.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)                               man_parseln(curp->man, curp->line, ln.buf, of)
                             ) == 2)                              ) == 2)
Line 365  rerun:
Line 373  rerun:
                 case ROFF_SO:                  case ROFF_SO:
                         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->man->meta.sodest =
                                       mandoc_strdup(ln.buf + of);
                                 goto out;                                  goto out;
                         }                          }
                         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);
                                 close(fd);                                  close(fd);
                         } else {                          } else {
                                 mandoc_msg(MANDOCERR_SO_FAIL, curp->line,                                  mandoc_msg(MANDOCERR_SO_FAIL,
                                     pos, ".so %s", ln.buf + of);                                      curp->line, of, ".so %s: %s",
                                       ln.buf + of, strerror(errno));
                                 ln.sz = mandoc_asprintf(&cp,                                  ln.sz = mandoc_asprintf(&cp,
                                     ".sp\nSee the file %s.\n.sp",                                      ".sp\nSee the file %s.\n.sp",
                                     ln.buf + of);                                      ln.buf + of);
Line 428  read_whole_file(struct mparse *curp, int fd, struct bu
Line 438  read_whole_file(struct mparse *curp, int fd, struct bu
         int              gzerrnum, retval;          int              gzerrnum, retval;
   
         if (fstat(fd, &st) == -1) {          if (fstat(fd, &st) == -1) {
                 mandoc_msg(MANDOCERR_FILE, 0, 0,                  mandoc_msg(MANDOCERR_FSTAT, 0, 0, "%s", strerror(errno));
                     "fstat: %s", strerror(errno));                  return -1;
                 return 0;  
         }          }
   
         /*          /*
Line 443  read_whole_file(struct mparse *curp, int fd, struct bu
Line 452  read_whole_file(struct mparse *curp, int fd, struct bu
         if (curp->gzip == 0 && S_ISREG(st.st_mode)) {          if (curp->gzip == 0 && S_ISREG(st.st_mode)) {
                 if (st.st_size > 0x7fffffff) {                  if (st.st_size > 0x7fffffff) {
                         mandoc_msg(MANDOCERR_TOOLARGE, 0, 0, NULL);                          mandoc_msg(MANDOCERR_TOOLARGE, 0, 0, NULL);
                         return 0;                          return -1;
                 }                  }
                 *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, MAP_SHARED, fd, 0);                  fb->buf = mmap(NULL, fb->sz, PROT_READ, MAP_SHARED, fd, 0);
                 if (fb->buf != MAP_FAILED)                  if (fb->buf != MAP_FAILED)
                         return 1;                          return 0;
         }          }
   
         if (curp->gzip) {          if (curp->gzip) {
Line 461  read_whole_file(struct mparse *curp, int fd, struct bu
Line 470  read_whole_file(struct mparse *curp, int fd, struct bu
                  * which this function must not do.                   * which this function must not do.
                  */                   */
                 if ((fd = dup(fd)) == -1) {                  if ((fd = dup(fd)) == -1) {
                         mandoc_msg(MANDOCERR_FILE, 0, 0,                          mandoc_msg(MANDOCERR_DUP, 0, 0,
                             "dup: %s", strerror(errno));                              "%s", strerror(errno));
                         return 0;                          return -1;
                 }                  }
                 if ((gz = gzdopen(fd, "rb")) == NULL) {                  if ((gz = gzdopen(fd, "rb")) == NULL) {
                         mandoc_msg(MANDOCERR_FILE, 0, 0,                          mandoc_msg(MANDOCERR_GZDOPEN, 0, 0,
                             "gzdopen: %s", strerror(errno));                              "%s", strerror(errno));
                         close(fd);                          close(fd);
                         return 0;                          return -1;
                 }                  }
         } else          } else
                 gz = NULL;                  gz = NULL;
Line 481  read_whole_file(struct mparse *curp, int fd, struct bu
Line 490  read_whole_file(struct mparse *curp, int fd, struct bu
   
         *with_mmap = 0;          *with_mmap = 0;
         off = 0;          off = 0;
         retval = 0;          retval = -1;
         fb->sz = 0;          fb->sz = 0;
         fb->buf = NULL;          fb->buf = NULL;
         for (;;) {          for (;;) {
Line 497  read_whole_file(struct mparse *curp, int fd, struct bu
Line 506  read_whole_file(struct mparse *curp, int fd, struct bu
                     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;
                         retval = 1;                          retval = 0;
                         break;                          break;
                 }                  }
                 if (ssz == -1) {                  if (ssz == -1) {
                         if (curp->gzip)                          if (curp->gzip)
                                 (void)gzerror(gz, &gzerrnum);                                  (void)gzerror(gz, &gzerrnum);
                         mandoc_msg(MANDOCERR_FILE, 0, 0, "read: %s",                          mandoc_msg(MANDOCERR_READ, 0, 0, "%s",
                             curp->gzip && gzerrnum != Z_ERRNO ?                              curp->gzip && gzerrnum != Z_ERRNO ?
                             zError(gzerrnum) : strerror(errno));                              zError(gzerrnum) : strerror(errno));
                         break;                          break;
Line 512  read_whole_file(struct mparse *curp, int fd, struct bu
Line 521  read_whole_file(struct mparse *curp, int fd, struct bu
         }          }
   
         if (curp->gzip && (gzerrnum = gzclose(gz)) != Z_OK)          if (curp->gzip && (gzerrnum = gzclose(gz)) != Z_OK)
                 mandoc_msg(MANDOCERR_FILE, 0, 0, "gzclose: %s",                  mandoc_msg(MANDOCERR_GZCLOSE, 0, 0, "%s",
                     gzerrnum == Z_ERRNO ? strerror(errno) :                      gzerrnum == Z_ERRNO ? strerror(errno) :
                     zError(gzerrnum));                      zError(gzerrnum));
         if (retval == 0) {          if (retval == -1) {
                 free(fb->buf);                  free(fb->buf);
                 fb->buf = NULL;                  fb->buf = NULL;
         }          }
Line 525  read_whole_file(struct mparse *curp, int fd, struct bu
Line 534  read_whole_file(struct mparse *curp, int fd, struct bu
 static void  static void
 mparse_end(struct mparse *curp)  mparse_end(struct mparse *curp)
 {  {
         if (curp->man->macroset == MACROSET_NONE)          if (curp->man->meta.macroset == MACROSET_NONE)
                 curp->man->macroset = MACROSET_MAN;                  curp->man->meta.macroset = MACROSET_MAN;
         if (curp->man->macroset == MACROSET_MDOC)          if (curp->man->meta.macroset == MACROSET_MDOC)
                 mdoc_endparse(curp->man);                  mdoc_endparse(curp->man);
         else          else
                 man_endparse(curp->man);                  man_endparse(curp->man);
Line 554  mparse_readfd(struct mparse *curp, int fd, const char 
Line 563  mparse_readfd(struct mparse *curp, int fd, const char 
                 mandoc_msg(MANDOCERR_ROFFLOOP, curp->line, 0, NULL);                  mandoc_msg(MANDOCERR_ROFFLOOP, curp->line, 0, NULL);
                 return;                  return;
         }          }
         if (read_whole_file(curp, fd, &blk, &with_mmap) == 0)          if (read_whole_file(curp, fd, &blk, &with_mmap) == -1)
                 return;                  return;
   
         /*          /*
Line 606  int
Line 615  int
 mparse_open(struct mparse *curp, const char *file)  mparse_open(struct mparse *curp, const char *file)
 {  {
         char             *cp;          char             *cp;
         int               fd;          int               fd, save_errno;
   
         cp = strrchr(file, '.');          cp = strrchr(file, '.');
         curp->gzip = (cp != NULL && ! strcmp(cp + 1, "gz"));          curp->gzip = (cp != NULL && ! strcmp(cp + 1, "gz"));
Line 622  mparse_open(struct mparse *curp, const char *file)
Line 631  mparse_open(struct mparse *curp, const char *file)
          */           */
   
         if ( ! curp->gzip) {          if ( ! curp->gzip) {
                   save_errno = errno;
                 mandoc_asprintf(&cp, "%s.gz", file);                  mandoc_asprintf(&cp, "%s.gz", file);
                 fd = open(cp, O_RDONLY);                  fd = open(cp, O_RDONLY);
                 free(cp);                  free(cp);
                   errno = save_errno;
                 if (fd != -1) {                  if (fd != -1) {
                         curp->gzip = 1;                          curp->gzip = 1;
                         return fd;                          return fd;
Line 633  mparse_open(struct mparse *curp, const char *file)
Line 644  mparse_open(struct mparse *curp, const char *file)
   
         /* Neither worked, give up. */          /* Neither worked, give up. */
   
         mandoc_msg(MANDOCERR_FILE, 0, 0, "%s", strerror(errno));  
         return -1;          return -1;
 }  }
   
Line 647  mparse_alloc(int options, enum mandoc_os os_e, const c
Line 657  mparse_alloc(int options, enum mandoc_os os_e, const c
         curp->options = options;          curp->options = options;
         curp->os_s = os_s;          curp->os_s = os_s;
   
         curp->roff = roff_alloc(curp, options);          curp->roff = roff_alloc(options);
         curp->man = roff_man_alloc(curp->roff, curp, curp->os_s,          curp->man = roff_man_alloc(curp->roff, 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->meta.macroset = MACROSET_MDOC;
                 if (curp->man->mdocmac == NULL)                  if (curp->man->mdocmac == NULL)
                         curp->man->mdocmac = roffhash_alloc(MDOC_Dd, MDOC_MAX);                          curp->man->mdocmac = roffhash_alloc(MDOC_Dd, MDOC_MAX);
         } else if (curp->options & MPARSE_MAN) {          } else if (curp->options & MPARSE_MAN) {
                 curp->man->macroset = MACROSET_MAN;                  curp->man->meta.macroset = MACROSET_MAN;
                 if (curp->man->manmac == NULL)                  if (curp->man->manmac == NULL)
                         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->meta.first->tok = TOKEN_NONE;
         curp->man->meta.os_e = os_e;          curp->man->meta.os_e = os_e;
           tag_alloc();
         return curp;          return curp;
 }  }
   
Line 671  mparse_reset(struct mparse *curp)
Line 682  mparse_reset(struct mparse *curp)
         roff_man_reset(curp->man);          roff_man_reset(curp->man);
         free_buf_list(curp->secondary);          free_buf_list(curp->secondary);
         curp->secondary = NULL;          curp->secondary = NULL;
         free(curp->sodest);  
         curp->sodest = NULL;  
         curp->gzip = 0;          curp->gzip = 0;
 }  }
   
 void  void
 mparse_free(struct mparse *curp)  mparse_free(struct mparse *curp)
 {  {
           tag_free();
         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);
         free_buf_list(curp->secondary);          free_buf_list(curp->secondary);
         free(curp->sodest);  
         free(curp);          free(curp);
 }  }
   
 void  struct roff_meta *
 mparse_result(struct mparse *curp, struct roff_man **man,  mparse_result(struct mparse *curp)
         char **sodest)  
 {  {
           roff_state_reset(curp->man);
         if (sodest && NULL != (*sodest = curp->sodest)) {          if (curp->options & MPARSE_VALIDATE) {
                 *man = NULL;                  if (curp->man->meta.macroset == MACROSET_MDOC)
                 return;                          mdoc_validate(curp->man);
                   else
                           man_validate(curp->man);
         }          }
         if (man)          return &curp->man->meta;
                 *man = curp->man;  
 }  }
   
 void  void
Legend:
Removed from v.1.206  
changed lines
  Added in v.1.215
CVSweb