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

Diff for /mandoc/read.c between version 1.68 and 1.82

version 1.68, 2014/07/07 21:36:20 version 1.82, 2014/09/03 23:21:47
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 65  struct mparse {
Line 65  struct mparse {
         mandocmsg         mmsg; /* warning/error message handler */          mandocmsg         mmsg; /* warning/error message handler */
         const char       *file;          const char       *file;
         struct buf       *secondary;          struct buf       *secondary;
         char             *defos; /* default operating system */          const char       *defos; /* default operating system */
 };  };
   
 static  void      resize_buf(struct buf *, size_t);  static  void      resize_buf(struct buf *, size_t);
Line 93  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 93  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 123  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 126  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 139  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 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 143  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 147  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 184  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 189  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",
           "skipping item outside list",
         "skipping column outside column list",          "skipping column outside column list",
         "skipping end of block that is not open",          "skipping end of block that is not open",
         "inserting missing end of block",          "inserting missing end of block",
Line 191  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 197  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",
         "manual name not yet set",  
         "argument count wrong",          "argument count wrong",
         "unknown standard specifier",  
         "uname(3) system call failed",  
         "request requires a numeric argument",  
         "missing list type, using -item",          "missing list type, using -item",
           "missing manual name, using \"\"",
           "uname(3) system call failed, using UNKNOWN",
           "unknown standard specifier",
           "skipping request without numeric argument",
         "skipping all arguments",          "skipping all arguments",
         "skipping excess arguments",          "skipping excess arguments",
   
         "generic fatal error",          "generic fatal error",
   
         "input too large",          "input too large",
         "not a manual",          "NOT IMPLEMENTED: Bd -file",
         "column syntax is inconsistent",  
         "NOT IMPLEMENTED: .Bd -file",  
         "child violates parent syntax",  
         "argument count wrong, violates syntax",  
         "NOT IMPLEMENTED: .so with absolute path or \"..\"",          "NOT IMPLEMENTED: .so with absolute path or \"..\"",
         ".so request failed",          ".so request failed",
         "no document prologue",  
         "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 263  pset(const char *buf, int pos, struct mparse *curp)
Line 270  pset(const char *buf, int pos, struct mparse *curp)
         }          }
   
         if (MPARSE_MDOC & curp->options) {          if (MPARSE_MDOC & curp->options) {
                 if (NULL == curp->pmdoc)  
                         curp->pmdoc = mdoc_alloc(  
                             curp->roff, curp, curp->defos,  
                             MPARSE_QUICK & curp->options ? 1 : 0);  
                 assert(curp->pmdoc);  
                 curp->mdoc = curp->pmdoc;                  curp->mdoc = curp->pmdoc;
                 return;                  return;
         } else if (MPARSE_MAN & curp->options) {          } else if (MPARSE_MAN & curp->options) {
                 if (NULL == curp->pman)  
                         curp->pman = man_alloc(curp->roff, curp,  
                             MPARSE_QUICK & curp->options ? 1 : 0);  
                 assert(curp->pman);  
                 curp->man = curp->pman;                  curp->man = curp->pman;
                 return;                  return;
         }          }
Line 365  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 363  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 422  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 420  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 600  read_whole_file(struct mparse *curp, const char *file,
Line 598  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 682  mparse_end(struct mparse *curp)
Line 680  mparse_end(struct mparse *curp)
         if (MANDOCLEVEL_FATAL <= curp->file_status)          if (MANDOCLEVEL_FATAL <= curp->file_status)
                 return;                  return;
   
           if (curp->mdoc == NULL &&
               curp->man == NULL &&
               curp->sodest == NULL) {
                   if (curp->options & MPARSE_MDOC)
                           curp->mdoc = curp->pmdoc;
                   else {
                           if (curp->pman == NULL)
                                   curp->pman = man_alloc(curp->roff, curp,
                                       curp->options & MPARSE_QUICK ? 1 : 0);
                           curp->man = curp->pman;
                   }
           }
   
         if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {          if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {
                 assert(MANDOCLEVEL_FATAL <= curp->file_status);                  assert(MANDOCLEVEL_FATAL <= curp->file_status);
                 return;                  return;
Line 692  mparse_end(struct mparse *curp)
Line 703  mparse_end(struct mparse *curp)
                 return;                  return;
         }          }
   
         if ( ! (curp->mdoc || curp->man || curp->sodest)) {  
                 mandoc_msg(MANDOCERR_NOTMANUAL, curp, 0, 0, NULL);  
                 curp->file_status = MANDOCLEVEL_FATAL;  
                 return;  
         }  
   
         roff_endparse(curp->roff);          roff_endparse(curp->roff);
 }  }
   
Line 766  mparse_readfd(struct mparse *curp, int fd, const char 
Line 771  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 779  out:
Line 784  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 *
 mparse_alloc(int options, enum mandoclevel wlevel,  mparse_alloc(int options, enum mandoclevel wlevel,
                 mandocmsg mmsg, char *defos)                  mandocmsg mmsg, const char *defos)
 {  {
         struct mparse   *curp;          struct mparse   *curp;
   
Line 795  mparse_alloc(int options, enum mandoclevel wlevel,
Line 885  mparse_alloc(int options, enum mandoclevel wlevel,
         curp->defos = defos;          curp->defos = defos;
   
         curp->roff = roff_alloc(curp, options);          curp->roff = roff_alloc(curp, options);
           if (curp->options & MPARSE_MDOC)
                   curp->pmdoc = mdoc_alloc(
                       curp->roff, curp, curp->defos,
                       curp->options & MPARSE_QUICK ? 1 : 0);
           if (curp->options & MPARSE_MAN)
                   curp->pman = man_alloc(curp->roff, curp,
                       curp->options & MPARSE_QUICK ? 1 : 0);
   
         return(curp);          return(curp);
 }  }
   
Legend:
Removed from v.1.68  
changed lines
  Added in v.1.82
CVSweb