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

Diff for /mandoc/read.c between version 1.108 and 1.113

version 1.108, 2015/01/14 22:02:50 version 1.113, 2015/01/22 19:26:50
Line 80  static const enum mandocerr mandoclimits[MANDOCLEVEL_M
Line 80  static const enum mandocerr mandoclimits[MANDOCLEVEL_M
         MANDOCERR_WARNING,          MANDOCERR_WARNING,
         MANDOCERR_WARNING,          MANDOCERR_WARNING,
         MANDOCERR_ERROR,          MANDOCERR_ERROR,
         MANDOCERR_FATAL,          MANDOCERR_UNSUPP,
         MANDOCERR_MAX,          MANDOCERR_MAX,
         MANDOCERR_MAX          MANDOCERR_MAX
 };  };
Line 180  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 180  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "unexpected end of equation",          "unexpected end of equation",
   
         /* related to tables */          /* related to tables */
         "bad table syntax",  
         "bad table option",  
         "bad table layout",  
         "no table layout cells specified",          "no table layout cells specified",
         "no table data cells specified",          "no table data cells specified",
         "ignore data in cell",          "ignore data in cell",
         "data block still open",          "data block still open",
         "ignoring extra data cells",          "ignoring extra data cells",
         "ignoring macro in table",  
   
         /* related to document structure and macros */          /* related to document structure and macros */
         NULL,          NULL,
         "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 insecure request",
         "skipping item outside list",          "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",
Line 210  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 207  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "uname(3) system call failed, using UNKNOWN",          "uname(3) system call failed, using UNKNOWN",
         "unknown standard specifier",          "unknown standard specifier",
         "skipping request without numeric argument",          "skipping request without numeric argument",
           "NOT IMPLEMENTED: .so with absolute path or \"..\"",
           ".so request failed",
         "skipping all arguments",          "skipping all arguments",
         "skipping excess arguments",          "skipping excess arguments",
         "divide by zero",          "divide by zero",
   
         "generic fatal error",          "unsupported feature",
   
         "input too large",          "input too large",
         "NOT IMPLEMENTED: .so with absolute path or \"..\"",          "unsupported roff request",
         ".so request failed",          "unsupported table syntax",
           "unsupported table option",
           "unsupported table layout",
           "ignoring macro in table",
 };  };
   
 static  const char * const      mandoclevels[MANDOCLEVEL_MAX] = {  static  const char * const      mandoclevels[MANDOCLEVEL_MAX] = {
Line 226  static const char * const mandoclevels[MANDOCLEVEL_MAX
Line 227  static const char * const mandoclevels[MANDOCLEVEL_MAX
         "RESERVED",          "RESERVED",
         "WARNING",          "WARNING",
         "ERROR",          "ERROR",
         "FATAL",          "UNSUPP",
         "BADARG",          "BADARG",
         "SYSERR"          "SYSERR"
 };  };
Line 306  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 307  mparse_buf_r(struct mparse *curp, struct buf blk, size
 {  {
         const struct tbl_span   *span;          const struct tbl_span   *span;
         struct buf       ln;          struct buf       ln;
           const char      *save_file;
           char            *cp;
         size_t           pos; /* byte number in the ln buffer */          size_t           pos; /* byte number in the ln buffer */
         enum rofferr     rr;          enum rofferr     rr;
         int              of;          int              of;
         int              lnn; /* line number in the real file */          int              lnn; /* line number in the real file */
           int              fd;
           pid_t            save_child;
         unsigned char    c;          unsigned char    c;
   
         memset(&ln, 0, sizeof(ln));          memset(&ln, 0, sizeof(ln));
Line 504  rerun:
Line 509  rerun:
                 case ROFF_IGN:                  case ROFF_IGN:
                         pos = 0;                          pos = 0;
                         continue;                          continue;
                 case ROFF_ERR:  
                         assert(MANDOCLEVEL_FATAL <= curp->file_status);  
                         break;  
                 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')) {
Line 521  rerun:
Line 523  rerun:
                          */                           */
                         if (curp->secondary)                          if (curp->secondary)
                                 curp->secondary->sz -= pos + 1;                                  curp->secondary->sz -= pos + 1;
                         mparse_readfd(curp, -1, ln.buf + of);                          save_file = curp->file;
                         if (MANDOCLEVEL_FATAL <= curp->file_status) {                          save_child = curp->child;
                           if (mparse_open(curp, &fd, ln.buf + of) ==
                               MANDOCLEVEL_OK) {
                                   mparse_readfd(curp, fd, ln.buf + of);
                                   curp->file = save_file;
                           } else {
                                   curp->file = save_file;
                                 mandoc_vmsg(MANDOCERR_SO_FAIL,                                  mandoc_vmsg(MANDOCERR_SO_FAIL,
                                     curp, curp->line, pos,                                      curp, curp->line, pos,
                                     ".so %s", ln.buf + of);                                      ".so %s", ln.buf + of);
                                 break;                                  ln.sz = mandoc_asprintf(&cp,
                                       ".sp\nSee the file %s.\n.sp",
                                       ln.buf + of);
                                   free(ln.buf);
                                   ln.buf = cp;
                                   of = 0;
                                   mparse_buf_r(curp, ln, of, 0);
                         }                          }
                           curp->child = save_child;
                         pos = 0;                          pos = 0;
                         continue;                          continue;
                 default:                  default:
Line 535  rerun:
Line 550  rerun:
                 }                  }
   
                 /*                  /*
                  * If we encounter errors in the recursive parse, make  
                  * sure we don't continue parsing.  
                  */  
   
                 if (MANDOCLEVEL_FATAL <= curp->file_status)  
                         break;  
   
                 /*  
                  * If input parsers have not been allocated, do so now.                   * If input parsers have not been allocated, do so now.
                  * We keep these instanced between 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
Line 613  read_whole_file(struct mparse *curp, const char *file,
Line 620  read_whole_file(struct mparse *curp, const char *file,
   
         if (S_ISREG(st.st_mode)) {          if (S_ISREG(st.st_mode)) {
                 if (st.st_size >= (1U << 31)) {                  if (st.st_size >= (1U << 31)) {
                         curp->file_status = MANDOCLEVEL_FATAL;                          mandoc_msg(MANDOCERR_TOOLARGE, curp, 0, 0, NULL);
                         if (curp->mmsg)  
                                 (*curp->mmsg)(MANDOCERR_TOOLARGE,  
                                     curp->file_status, file, 0, 0, NULL);  
                         return(0);                          return(0);
                 }                  }
                 *with_mmap = 1;                  *with_mmap = 1;
Line 639  read_whole_file(struct mparse *curp, const char *file,
Line 643  read_whole_file(struct mparse *curp, const char *file,
         for (;;) {          for (;;) {
                 if (off == fb->sz) {                  if (off == fb->sz) {
                         if (fb->sz == (1U << 31)) {                          if (fb->sz == (1U << 31)) {
                                 curp->file_status = MANDOCLEVEL_FATAL;                                  mandoc_msg(MANDOCERR_TOOLARGE, curp,
                                 if (curp->mmsg)                                      0, 0, NULL);
                                         (*curp->mmsg)(MANDOCERR_TOOLARGE,  
                                             curp->file_status,  
                                             file, 0, 0, NULL);  
                                 break;                                  break;
                         }                          }
                         resize_buf(fb, 65536);                          resize_buf(fb, 65536);
Line 669  static void
Line 670  static void
 mparse_end(struct mparse *curp)  mparse_end(struct mparse *curp)
 {  {
   
         if (MANDOCLEVEL_FATAL <= curp->file_status)  
                 return;  
   
         if (curp->mdoc == NULL &&          if (curp->mdoc == NULL &&
             curp->man == NULL &&              curp->man == NULL &&
             curp->sodest == NULL) {              curp->sodest == NULL) {
Line 685  mparse_end(struct mparse *curp)
Line 683  mparse_end(struct mparse *curp)
                         curp->man = curp->pman;                          curp->man = curp->pman;
                 }                  }
         }          }
           if (curp->mdoc)
         if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {                  mdoc_endparse(curp->mdoc);
                 assert(MANDOCLEVEL_FATAL <= curp->file_status);          if (curp->man)
                 return;                  man_endparse(curp->man);
         }  
   
         if (curp->man && ! man_endparse(curp->man)) {  
                 assert(MANDOCLEVEL_FATAL <= curp->file_status);  
                 return;  
         }  
   
         roff_endparse(curp->roff);          roff_endparse(curp->roff);
 }  }
   
Line 732  mparse_parse_buffer(struct mparse *curp, struct buf bl
Line 723  mparse_parse_buffer(struct mparse *curp, struct buf bl
   
         mparse_buf_r(curp, blk, offset, 1);          mparse_buf_r(curp, blk, offset, 1);
   
         if (0 == --recursion_depth && MANDOCLEVEL_FATAL > curp->file_status)          if (--recursion_depth == 0)
                 mparse_end(curp);                  mparse_end(curp);
   
         curp->primary = svprimary;          curp->primary = svprimary;
Line 753  mparse_readmem(struct mparse *curp, void *buf, size_t 
Line 744  mparse_readmem(struct mparse *curp, void *buf, size_t 
 }  }
   
 /*  /*
  * If a file descriptor is given, use it and assume it points  
  * to the named file.  Otherwise, open the named file.  
  * Read the whole file into memory and call the parsers.   * Read the whole file into memory and call the parsers.
  * Called recursively when an .so request is encountered.   * Called recursively when an .so request is encountered.
  */   */
Line 764  mparse_readfd(struct mparse *curp, int fd, const char 
Line 753  mparse_readfd(struct mparse *curp, int fd, const char 
         struct buf       blk;          struct buf       blk;
         int              with_mmap;          int              with_mmap;
         int              save_filenc;          int              save_filenc;
         pid_t            save_child;  
   
         save_child = curp->child;  
         if (fd != -1)  
                 curp->child = 0;  
         else if (mparse_open(curp, &fd, file) != MANDOCLEVEL_OK)  
                 goto out;  
   
         if (read_whole_file(curp, file, fd, &blk, &with_mmap)) {          if (read_whole_file(curp, file, fd, &blk, &with_mmap)) {
                 save_filenc = curp->filenc;                  save_filenc = curp->filenc;
                 curp->filenc = curp->options &                  curp->filenc = curp->options &
Line 790  mparse_readfd(struct mparse *curp, int fd, const char 
Line 772  mparse_readfd(struct mparse *curp, int fd, const char 
                 perror(file);                  perror(file);
   
         mparse_wait(curp);          mparse_wait(curp);
 out:  
         curp->child = save_child;  
         return(curp->file_status);          return(curp->file_status);
 }  }
   
Line 890  mparse_alloc(int options, enum mandoclevel wlevel, man
Line 870  mparse_alloc(int options, enum mandoclevel wlevel, man
 {  {
         struct mparse   *curp;          struct mparse   *curp;
   
         assert(wlevel <= MANDOCLEVEL_FATAL);  
   
         curp = mandoc_calloc(1, sizeof(struct mparse));          curp = mandoc_calloc(1, sizeof(struct mparse));
   
         curp->options = options;          curp->options = options;
Line 988  mandoc_msg(enum mandocerr er, struct mparse *m,
Line 966  mandoc_msg(enum mandocerr er, struct mparse *m,
 {  {
         enum mandoclevel level;          enum mandoclevel level;
   
         level = MANDOCLEVEL_FATAL;          level = MANDOCLEVEL_UNSUPP;
         while (er < mandoclimits[level])          while (er < mandoclimits[level])
                 level--;                  level--;
   
Legend:
Removed from v.1.108  
changed lines
  Added in v.1.113
CVSweb