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

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

version 1.197, 2018/08/23 14:29:38 version 1.198, 2018/08/23 19:33:27
Line 48  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 61  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  enum rofferr 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,
Line 290  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 346  static enum rofferr
Line 360  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     line_result, sub_result;          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 393  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 432  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 450  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:
                 line_result = roff_parseln(curp->roff, curp->line, &ln, &of);                  line_result = roff_parseln(curp->roff, curp->line, &ln, &of);
   
Line 478  rerun:
Line 494  rerun:
                 case ROFF_REPARSE:                  case ROFF_REPARSE:
                 case ROFF_USERCALL:                  case ROFF_USERCALL:
                         if (++curp->reparse_count > REPARSE_LIMIT) {                          if (++curp->reparse_count > REPARSE_LIMIT) {
                                 sub_result = ROFF_IGN;                                  result = ROFF_IGN;
                                 mandoc_msg(MANDOCERR_ROFFLOOP, curp,                                  mandoc_msg(MANDOCERR_ROFFLOOP, curp,
                                     curp->line, pos, NULL);                                      curp->line, pos, NULL);
                         } else {                          } else {
                                 sub_result = mparse_buf_r(curp, ln, of, 0);                                  result = mparse_buf_r(curp, ln, of, 0);
                                 if (line_result == ROFF_USERCALL) {                                  if (line_result == ROFF_USERCALL) {
                                         if (sub_result == ROFF_USERRET)                                          if (result == ROFF_USERRET)
                                                 sub_result = ROFF_CONT;                                                  result = ROFF_CONT;
                                         roff_userret(curp->roff);                                          roff_userret(curp->roff);
                                 }                                  }
                                 if (start || sub_result == ROFF_CONT) {                                  if (start || result == ROFF_CONT) {
                                         pos = 0;                                          pos = 0;
                                         continue;                                          continue;
                                 }                                  }
                         }                          }
                         free(ln.buf);                          goto out;
                         return sub_result;  
                 case ROFF_USERRET:                  case ROFF_USERRET:
                         if (start) {                          if (start) {
                                 pos = 0;                                  pos = 0;
                                 continue;                                  continue;
                         }                          }
                         free(ln.buf);                          result = ROFF_USERRET;
                         return ROFF_USERRET;                          goto out;
                 case ROFF_APPEND:                  case ROFF_APPEND:
                         pos = strlen(ln.buf);                          pos = strlen(ln.buf);
                         continue;                          continue;
Line 514  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 ROFF_CONT;  
                         }                          }
                         /*  
                          * 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 565  rerun:
Line 572  rerun:
   
                 pos = 0;                  pos = 0;
         }          }
   out:
         free(ln.buf);          free(ln.buf);
         return ROFF_CONT;          if (firstln != curp->secondary)
                   free_buf_list(firstln);
           return result;
 }  }
   
 static int  static int
Line 837  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 851  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 932  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.197  
changed lines
  Added in v.1.198

CVSweb