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

Diff for /mandoc/read.c between version 1.136 and 1.141

version 1.136, 2015/04/18 17:01:58 version 1.141, 2015/09/14 15:36:14
Line 23 
Line 23 
 #include <sys/mman.h>  #include <sys/mman.h>
 #include <sys/stat.h>  #include <sys/stat.h>
 #endif  #endif
 #include <sys/wait.h>  
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
 #include <errno.h>  #include <errno.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <signal.h>  
 #include <stdarg.h>  #include <stdarg.h>
 #include <stdint.h>  #include <stdint.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   #include <zlib.h>
   
 #include "mandoc_aux.h"  #include "mandoc_aux.h"
 #include "mandoc.h"  #include "mandoc.h"
Line 43 
Line 42 
 #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 59  struct mparse {
Line 59  struct mparse {
         enum mandoclevel  file_status; /* status of current parse */          enum mandoclevel  file_status; /* status of current parse */
         enum mandoclevel  wlevel; /* ignore messages below this */          enum mandoclevel  wlevel; /* ignore messages below this */
         int               options; /* parser options */          int               options; /* parser options */
           int               gzip; /* current input file is gzipped */
         int               filenc; /* encoding of the current file */          int               filenc; /* encoding of the current file */
         int               reparse_count; /* finite interp. stack */          int               reparse_count; /* finite interp. stack */
         int               line; /* line number in the file */          int               line; /* line number in the file */
         pid_t             child; /* the gunzip(1) process */  
 };  };
   
 static  void      choose_parser(struct mparse *);  static  void      choose_parser(struct mparse *);
Line 129  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 129  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",
         ".Vt block has child macro",  
         "fill mode already enabled, skipping",          "fill mode already enabled, skipping",
         "fill mode already disabled, skipping",          "fill mode already disabled, skipping",
         "line scope broken",          "line scope broken",
Line 289  choose_parser(struct mparse *curp)
Line 288  choose_parser(struct mparse *curp)
                 }                  }
         }          }
   
         if (format == MPARSE_MDOC) {          if (curp->man == NULL) {
                 if (curp->man == NULL)                  curp->man = roff_man_alloc(curp->roff, curp, curp->defos,
                         curp->man = mdoc_alloc(                      curp->options & MPARSE_QUICK ? 1 : 0);
                             curp->roff, curp, curp->defos,                  curp->man->macroset = MACROSET_MAN;
                             MPARSE_QUICK & curp->options ? 1 : 0);                  curp->man->first->tok = TOKEN_NONE;
                 else  
                         curp->man->macroset = MACROSET_MDOC;  
                 mdoc_hash_init();  
                 return;  
         }          }
   
         /* Fall back to man(7) as a last resort. */          if (format == MPARSE_MDOC) {
                   mdoc_hash_init();
         if (curp->man == NULL)                  curp->man->macroset = MACROSET_MDOC;
                 curp->man = man_alloc(                  curp->man->first->tok = TOKEN_NONE;
                     curp->roff, curp, curp->defos,          } else {
                     MPARSE_QUICK & curp->options ? 1 : 0);                  man_hash_init();
         else  
                 curp->man->macroset = MACROSET_MAN;                  curp->man->macroset = MACROSET_MAN;
         man_hash_init();                  curp->man->first->tok = TOKEN_NONE;
           }
 }  }
   
 /*  /*
Line 330  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 325  mparse_buf_r(struct mparse *curp, struct buf blk, size
         int              of;          int              of;
         int              lnn; /* line number in the real file */          int              lnn; /* line number in the real file */
         int              fd;          int              fd;
         pid_t            save_child;  
         unsigned char    c;          unsigned char    c;
   
         memset(&ln, 0, sizeof(ln));          memset(&ln, 0, sizeof(ln));
Line 542  rerun:
Line 536  rerun:
                         if (curp->secondary)                          if (curp->secondary)
                                 curp->secondary->sz -= pos + 1;                                  curp->secondary->sz -= pos + 1;
                         save_file = curp->file;                          save_file = curp->file;
                         save_child = curp->child;  
                         if (mparse_open(curp, &fd, ln.buf + of) ==                          if (mparse_open(curp, &fd, ln.buf + of) ==
                             MANDOCLEVEL_OK) {                              MANDOCLEVEL_OK) {
                                 mparse_readfd(curp, fd, ln.buf + of);                                  mparse_readfd(curp, fd, ln.buf + of);
Line 560  rerun:
Line 553  rerun:
                                 of = 0;                                  of = 0;
                                 mparse_buf_r(curp, ln, of, 0);                                  mparse_buf_r(curp, ln, of, 0);
                         }                          }
                         curp->child = save_child;  
                         pos = 0;                          pos = 0;
                         continue;                          continue;
                 default:                  default:
Line 587  rerun:
Line 579  rerun:
                  * Do the same for ROFF_EQN.                   * Do the same for ROFF_EQN.
                  */                   */
   
                 if (rr == ROFF_TBL) {                  if (rr == ROFF_TBL)
                         while ((span = roff_span(curp->roff)) != NULL)                          while ((span = roff_span(curp->roff)) != NULL)
                                 if (curp->man->macroset == MACROSET_MDOC)                                  roff_addtbl(curp->man, span);
                                         mdoc_addspan(curp->man, span);                  else if (rr == ROFF_EQN)
                                 else                          roff_addeqn(curp->man, roff_eqn(curp->roff));
                                         man_addspan(curp->man, span);                  else if ((curp->man->macroset == MACROSET_MDOC ?
                 } else if (rr == ROFF_EQN) {  
                         if (curp->man->macroset == MACROSET_MDOC)  
                                 mdoc_addeqn(curp->man, roff_eqn(curp->roff));  
                         else  
                                 man_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 620  static int
Line 606  static int
 read_whole_file(struct mparse *curp, const char *file, int fd,  read_whole_file(struct mparse *curp, const char *file, int fd,
                 struct buf *fb, int *with_mmap)                  struct buf *fb, int *with_mmap)
 {  {
           gzFile           gz;
         size_t           off;          size_t           off;
         ssize_t          ssz;          ssize_t          ssz;
   
Line 637  read_whole_file(struct mparse *curp, const char *file,
Line 624  read_whole_file(struct mparse *curp, const char *file,
          * concerned that this is going to tank any machines.           * concerned that this is going to tank any machines.
          */           */
   
         if (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, curp, 0, 0, NULL);                          mandoc_msg(MANDOCERR_TOOLARGE, curp, 0, 0, NULL);
                         return(0);                          return(0);
Line 650  read_whole_file(struct mparse *curp, const char *file,
Line 637  read_whole_file(struct mparse *curp, const char *file,
         }          }
 #endif  #endif
   
           if (curp->gzip) {
                   if ((gz = gzdopen(fd, "rb")) == NULL) {
                           perror(file);
                           exit((int)MANDOCLEVEL_SYSERR);
                   }
           } else
                   gz = NULL;
   
         /*          /*
          * If this isn't a regular file (like, say, stdin), then we must           * If this isn't a regular file (like, say, stdin), then we must
          * go the old way and just read things in bit by bit.           * go the old way and just read things in bit by bit.
Line 668  read_whole_file(struct mparse *curp, const char *file,
Line 663  read_whole_file(struct mparse *curp, const char *file,
                         }                          }
                         resize_buf(fb, 65536);                          resize_buf(fb, 65536);
                 }                  }
                 ssz = read(fd, fb->buf + (int)off, fb->sz - off);                  ssz = curp->gzip ?
                       gzread(gz, 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);                          return(1);
Line 690  mparse_end(struct mparse *curp)
Line 687  mparse_end(struct mparse *curp)
 {  {
   
         if (curp->man == NULL && curp->sodest == NULL)          if (curp->man == NULL && curp->sodest == NULL)
                 curp->man = man_alloc(curp->roff, curp, curp->defos,                  curp->man = roff_man_alloc(curp->roff, curp, curp->defos,
                     curp->options & MPARSE_QUICK ? 1 : 0);                      curp->options & MPARSE_QUICK ? 1 : 0);
         if (curp->man->macroset == MACROSET_NONE)          if (curp->man->macroset == MACROSET_NONE)
                 curp->man->macroset = MACROSET_MAN;                  curp->man->macroset = MACROSET_MAN;
Line 782  mparse_readfd(struct mparse *curp, int fd, const char 
Line 779  mparse_readfd(struct mparse *curp, int fd, const char 
         if (fd != STDIN_FILENO && close(fd) == -1)          if (fd != STDIN_FILENO && close(fd) == -1)
                 perror(file);                  perror(file);
   
         mparse_wait(curp);  
         return(curp->file_status);          return(curp->file_status);
 }  }
   
 enum mandoclevel  enum mandoclevel
 mparse_open(struct mparse *curp, int *fd, const char *file)  mparse_open(struct mparse *curp, int *fd, const char *file)
 {  {
         int               pfd[2];  
         int               save_errno;  
         char             *cp;          char             *cp;
   
         curp->file = file;          curp->file = file;
           cp = strrchr(file, '.');
           curp->gzip = (cp != NULL && ! strcmp(cp + 1, "gz"));
   
         /* Unless zipped, try to just open the file. */          /* First try to use the filename as it is. */
   
         if ((cp = strrchr(file, '.')) == NULL ||          if ((*fd = open(file, O_RDONLY)) != -1)
             strcmp(cp + 1, "gz")) {                  return(MANDOCLEVEL_OK);
                 curp->child = 0;  
                 if ((*fd = open(file, O_RDONLY)) != -1)  
                         return(MANDOCLEVEL_OK);  
   
                 /* Open failed; try to append ".gz". */          /*
            * If that doesn't work and the filename doesn't
            * already  end in .gz, try appending .gz.
            */
   
           if ( ! curp->gzip) {
                 mandoc_asprintf(&cp, "%s.gz", file);                  mandoc_asprintf(&cp, "%s.gz", file);
                 file = cp;                  *fd = open(file, O_RDONLY);
         } else  
                 cp = NULL;  
   
         /* Before forking, make sure the file can be read. */  
   
         save_errno = errno;  
         if (access(file, R_OK) == -1) {  
                 if (cp != NULL)  
                         errno = save_errno;  
                 free(cp);                  free(cp);
                 *fd = -1;                  if (*fd != -1) {
                 curp->child = 0;                          curp->gzip = 1;
                 mandoc_msg(MANDOCERR_FILE, curp, 0, 0, strerror(errno));                          return(MANDOCLEVEL_OK);
                 return(MANDOCLEVEL_ERROR);  
         }  
   
         /* Run gunzip(1). */  
   
         if (pipe(pfd) == -1) {  
                 perror("pipe");  
                 exit((int)MANDOCLEVEL_SYSERR);  
         }  
   
         switch (curp->child = fork()) {  
         case -1:  
                 perror("fork");  
                 exit((int)MANDOCLEVEL_SYSERR);  
         case 0:  
                 close(pfd[0]);  
                 if (dup2(pfd[1], STDOUT_FILENO) == -1) {  
                         perror("dup");  
                         exit((int)MANDOCLEVEL_SYSERR);  
                 }                  }
                 signal(SIGPIPE, SIG_DFL);  
                 execlp("gunzip", "gunzip", "-c", file, NULL);  
                 perror("exec");  
                 exit((int)MANDOCLEVEL_SYSERR);  
         default:  
                 close(pfd[1]);  
                 *fd = pfd[0];  
                 return(MANDOCLEVEL_OK);  
         }          }
 }  
   
 enum mandoclevel          /* Neither worked, give up. */
 mparse_wait(struct mparse *curp)  
 {  
         int       status;  
   
         if (curp->child == 0)          mandoc_msg(MANDOCERR_FILE, curp, 0, 0, strerror(errno));
                 return(MANDOCLEVEL_OK);          return(MANDOCLEVEL_ERROR);
   
         if (waitpid(curp->child, &status, 0) == -1) {  
                 perror("wait");  
                 exit((int)MANDOCLEVEL_SYSERR);  
         }  
         curp->child = 0;  
         if (WIFSIGNALED(status)) {  
                 mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0,  
                     "gunzip died from signal %d", WTERMSIG(status));  
                 return(MANDOCLEVEL_ERROR);  
         }  
         if (WEXITSTATUS(status)) {  
                 mandoc_vmsg(MANDOCERR_FILE, curp, 0, 0,  
                     "gunzip failed with code %d", WEXITSTATUS(status));  
                 return(MANDOCLEVEL_ERROR);  
         }  
         return(MANDOCLEVEL_OK);  
 }  }
   
 struct mparse *  struct mparse *
Line 892  mparse_alloc(int options, enum mandoclevel wlevel, man
Line 832  mparse_alloc(int options, enum mandoclevel wlevel, man
   
         curp->mchars = mchars;          curp->mchars = mchars;
         curp->roff = roff_alloc(curp, curp->mchars, options);          curp->roff = roff_alloc(curp, curp->mchars, options);
           curp->man = roff_man_alloc( curp->roff, curp, curp->defos,
                   curp->options & MPARSE_QUICK ? 1 : 0);
         if (curp->options & MPARSE_MDOC) {          if (curp->options & MPARSE_MDOC) {
                 curp->man = mdoc_alloc(  
                     curp->roff, curp, curp->defos,  
                     curp->options & MPARSE_QUICK ? 1 : 0);  
                 mdoc_hash_init();                  mdoc_hash_init();
         }                  curp->man->macroset = MACROSET_MDOC;
         if (curp->options & MPARSE_MAN) {          } else if (curp->options & MPARSE_MAN) {
                 curp->man = man_alloc(  
                     curp->roff, curp, curp->defos,  
                     curp->options & MPARSE_QUICK ? 1 : 0);  
                 man_hash_init();                  man_hash_init();
                   curp->man->macroset = MACROSET_MAN;
         }          }
           curp->man->first->tok = TOKEN_NONE;
         return(curp);          return(curp);
 }  }
   
Line 914  mparse_reset(struct mparse *curp)
Line 851  mparse_reset(struct mparse *curp)
   
         roff_reset(curp->roff);          roff_reset(curp->roff);
   
         if (curp->man != NULL) {          if (curp->man != NULL)
                 if (curp->man->macroset == MACROSET_MDOC)                  roff_man_reset(curp->man);
                         mdoc_reset(curp->man);  
                 else  
                         man_reset(curp->man);  
                 curp->man->macroset = MACROSET_NONE;  
         }  
         if (curp->secondary)          if (curp->secondary)
                 curp->secondary->sz = 0;                  curp->secondary->sz = 0;
   
Line 934  void
Line 866  void
 mparse_free(struct mparse *curp)  mparse_free(struct mparse *curp)
 {  {
   
         if (curp->man->macroset == MACROSET_MDOC)          roff_man_free(curp->man);
                 mdoc_free(curp->man);  
         if (curp->man->macroset == MACROSET_MAN)  
                 man_free(curp->man);  
         if (curp->roff)          if (curp->roff)
                 roff_free(curp->roff);                  roff_free(curp->roff);
         if (curp->secondary)          if (curp->secondary)
Legend:
Removed from v.1.136  
changed lines
  Added in v.1.141
CVSweb