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

Diff for /mandoc/read.c between version 1.11 and 1.24

version 1.11, 2011/04/04 23:04:38 version 1.24, 2011/10/06 22:29:12
Line 19 
Line 19 
 #include "config.h"  #include "config.h"
 #endif  #endif
   
 #include <sys/stat.h>  #ifdef HAVE_MMAP
 #include <sys/mman.h>  # include <sys/stat.h>
   # include <sys/mman.h>
   #endif
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
Line 57  struct mparse {
Line 59  struct mparse {
         struct man       *man; /* man parser */          struct man       *man; /* man parser */
         struct mdoc      *mdoc; /* mdoc parser */          struct mdoc      *mdoc; /* mdoc parser */
         struct roff      *roff; /* roff parser (!NULL) */          struct roff      *roff; /* roff parser (!NULL) */
         struct regset     regs; /* roff registers */  
         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 */          void             *arg; /* argument to mmsg */
         const char       *file;          const char       *file;
           struct buf       *secondary;
 };  };
   
 static  void      resize_buf(struct buf *, size_t);  static  void      resize_buf(struct buf *, size_t);
Line 142  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 144  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "tab in non-literal context",          "tab in non-literal context",
         "end of line whitespace",          "end of line whitespace",
         "bad comment style",          "bad comment style",
         "unknown escape sequence",          "bad escape sequence",
         "unterminated quoted string",          "unterminated quoted string",
   
           /* related to equations */
           "unexpected literal in equation",
   
         "generic error",          "generic error",
   
           /* related to equations */
           "unexpected equation scope closure",
           "equation scope open on exit",
           "overlapping equation scopes",
           "unexpected end of equation",
           "equation syntax error",
   
         /* related to tables */          /* related to tables */
         "bad table syntax",          "bad table syntax",
         "bad table option",          "bad table option",
Line 235  pset(const char *buf, int pos, struct mparse *curp)
Line 247  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->regs, curp);                          curp->pmdoc = mdoc_alloc(curp->roff, curp);
                 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->regs, curp);                          curp->pman = man_alloc(curp->roff, curp);
                 assert(curp->pman);                  assert(curp->pman);
                 curp->man = curp->pman;                  curp->man = curp->pman;
                 return;                  return;
Line 251  pset(const char *buf, int pos, struct mparse *curp)
Line 263  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->regs, curp);                          curp->pmdoc = mdoc_alloc(curp->roff, curp);
                 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->regs, curp);                  curp->pman = man_alloc(curp->roff, curp);
         assert(curp->pman);          assert(curp->pman);
         curp->man = curp->pman;          curp->man = curp->pman;
 }  }
Line 354  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 366  mparse_buf_r(struct mparse *curp, struct buf blk, int 
                                 continue;                                  continue;
                         }                          }
   
                         if ('"' == blk.buf[i + 1]) {                          if ('"' == blk.buf[i + 1] || '#' == blk.buf[i + 1]) {
                                 i += 2;                                  i += 2;
                                 /* Comment, skip to end of line */                                  /* Comment, skip to end of line */
                                 for (; i < (int)blk.sz; ++i) {                                  for (; i < (int)blk.sz; ++i) {
Line 400  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 412  mparse_buf_r(struct mparse *curp, struct buf blk, int 
   
                 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                  rr = roff_parseln
                         (curp->roff, curp->line,                          (curp->roff, curp->line,
Line 426  rerun:
Line 459  rerun:
                         assert(MANDOCLEVEL_FATAL <= curp->file_status);                          assert(MANDOCLEVEL_FATAL <= curp->file_status);
                         break;                          break;
                 case (ROFF_SO):                  case (ROFF_SO):
                           /*
                            * We remove `so' clauses from our lookaside
                            * buffer because we're going to descend into
                            * the file recursively.
                            */
                           curp->secondary->sz -= pos + 1;
                         mparse_readfd_r(curp, -1, ln.buf + of, 1);                          mparse_readfd_r(curp, -1, ln.buf + of, 1);
                         if (MANDOCLEVEL_FATAL <= curp->file_status)                          if (MANDOCLEVEL_FATAL <= curp->file_status)
                                 break;                                  break;
Line 445  rerun:
Line 484  rerun:
   
                 /*                  /*
                  * If input parsers have not been allocated, do so now.                   * If input parsers have not been allocated, do so now.
                  * We keep these instanced betwen parsers, but set them                   * We keep these instanced between parsers, but set them
                  * locally per parse routine since we can use different                   * locally per parse routine since we can use different
                  * parsers with each one.                   * parsers with each one.
                  */                   */
Line 529  pdesc(struct mparse *curp, const char *file, int fd)
Line 568  pdesc(struct mparse *curp, const char *file, int fd)
   
         mparse_buf_r(curp, blk, 1);          mparse_buf_r(curp, blk, 1);
   
   #ifdef  HAVE_MMAP
         if (with_mmap)          if (with_mmap)
                 munmap(blk.buf, blk.sz);                  munmap(blk.buf, blk.sz);
         else          else
   #endif
                 free(blk.buf);                  free(blk.buf);
 }  }
   
 static int  static int
 read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)  read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)
 {  {
         struct stat      st;  
         size_t           off;          size_t           off;
         ssize_t          ssz;          ssize_t          ssz;
   
   #ifdef  HAVE_MMAP
           struct stat      st;
         if (-1 == fstat(fd, &st)) {          if (-1 == fstat(fd, &st)) {
                 perror(file);                  perror(file);
                 return(0);                  return(0);
Line 566  read_whole_file(const char *file, int fd, struct buf *
Line 608  read_whole_file(const char *file, int fd, struct buf *
                 if (fb->buf != MAP_FAILED)                  if (fb->buf != MAP_FAILED)
                         return(1);                          return(1);
         }          }
   #endif
   
         /*          /*
          * 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
Line 675  mparse_alloc(enum mparset inttype, enum mandoclevel wl
Line 718  mparse_alloc(enum mparset inttype, enum mandoclevel wl
         curp->arg = arg;          curp->arg = arg;
         curp->inttype = inttype;          curp->inttype = inttype;
   
         curp->roff = roff_alloc(&curp->regs, curp);          curp->roff = roff_alloc(curp);
         return(curp);          return(curp);
 }  }
   
Line 683  void
Line 726  void
 mparse_reset(struct mparse *curp)  mparse_reset(struct mparse *curp)
 {  {
   
         memset(&curp->regs, 0, sizeof(struct regset));  
   
         roff_reset(curp->roff);          roff_reset(curp->roff);
   
         if (curp->mdoc)          if (curp->mdoc)
                 mdoc_reset(curp->mdoc);                  mdoc_reset(curp->mdoc);
         if (curp->man)          if (curp->man)
                 man_reset(curp->man);                  man_reset(curp->man);
           if (curp->secondary)
                   curp->secondary->sz = 0;
   
         curp->file_status = MANDOCLEVEL_OK;          curp->file_status = MANDOCLEVEL_OK;
         curp->mdoc = NULL;          curp->mdoc = NULL;
Line 707  mparse_free(struct mparse *curp)
Line 750  mparse_free(struct mparse *curp)
                 man_free(curp->pman);                  man_free(curp->pman);
         if (curp->roff)          if (curp->roff)
                 roff_free(curp->roff);                  roff_free(curp->roff);
           if (curp->secondary)
                   free(curp->secondary->buf);
   
           free(curp->secondary);
         free(curp);          free(curp);
 }  }
   
Line 766  const char *
Line 812  const char *
 mparse_strlevel(enum mandoclevel lvl)  mparse_strlevel(enum mandoclevel lvl)
 {  {
         return(mandoclevels[lvl]);          return(mandoclevels[lvl]);
   }
   
   void
   mparse_keep(struct mparse *p)
   {
   
           assert(NULL == p->secondary);
           p->secondary = mandoc_calloc(1, sizeof(struct 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.11  
changed lines
  Added in v.1.24
CVSweb