[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.121

version 1.108, 2015/01/14 22:02:50 version 1.121, 2015/02/04 16:38:56
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 110  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 110  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "content before first section header",          "content before first section header",
         "first section is not \"NAME\"",          "first section is not \"NAME\"",
         "bad NAME section contents",          "bad NAME section contents",
           "missing description line, using \"\"",
         "sections out of conventional order",          "sections out of conventional order",
         "duplicate section title",          "duplicate section title",
         "unexpected section",          "unexpected section",
Line 171  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 172  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "invalid escape sequence",          "invalid escape sequence",
         "undefined string, using \"\"",          "undefined string, using \"\"",
   
           /* related to tables */
           "tbl line starts with span",
           "tbl column starts with span",
           "skipping vertical bar in tbl layout",
   
         "generic error",          "generic error",
   
         /* related to equations */  
         "unexpected equation scope closure",  
         "equation scope open on exit",  
         "overlapping equation scopes",  
         "unexpected end of equation",  
   
         /* related to tables */          /* related to tables */
         "bad table syntax",          "non-alphabetic character in tbl options",
         "bad table option",          "skipping unknown tbl option",
         "bad table layout",          "missing tbl option argument",
         "no table layout cells specified",          "wrong tbl option argument size",
         "no table data cells specified",          "empty tbl layout",
         "ignore data in cell",          "invalid character in tbl layout",
         "data block still open",          "unmatched parenthesis in tbl layout",
         "ignoring extra data cells",          "tbl without any data cells",
         "ignoring macro in table",          "ignoring data in spanned tbl cell",
           "ignoring extra tbl data cells",
           "data block open at end of tbl",
   
         /* 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",
           "fewer RS blocks open, skipping",
         "inserting missing end of block",          "inserting missing end of block",
         "appending missing end of block",          "appending missing end of block",
   
Line 210  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 214  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 control character",
         ".so request failed",          "unsupported roff request",
           "eqn delim option in tbl",
           "unsupported tbl layout modifier",
           "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 234  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 314  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 364  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 376  mparse_buf_r(struct mparse *curp, struct buf blk, size
                         if (c & 0x80) {                          if (c & 0x80) {
                                 if ( ! (curp->filenc && preconv_encode(                                  if ( ! (curp->filenc && preconv_encode(
                                     &blk, &i, &ln, &pos, &curp->filenc))) {                                      &blk, &i, &ln, &pos, &curp->filenc))) {
                                         mandoc_vmsg(MANDOCERR_BADCHAR,                                          mandoc_vmsg(MANDOCERR_CHAR_BAD, curp,
                                             curp, curp->line, pos,                                              curp->line, pos, "0x%x", c);
                                             "0x%x", c);  
                                         ln.buf[pos++] = '?';                                          ln.buf[pos++] = '?';
                                         i++;                                          i++;
                                 }                                  }
Line 378  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 389  mparse_buf_r(struct mparse *curp, struct buf blk, size
                          */                           */
   
                         if (c == 0x7f || (c < 0x20 && c != 0x09)) {                          if (c == 0x7f || (c < 0x20 && c != 0x09)) {
                                 mandoc_vmsg(MANDOCERR_BADCHAR, curp,                                  mandoc_vmsg(c == 0x00 || c == 0x04 ||
                                     curp->line, pos, "0x%x", c);                                      c > 0x0a ? MANDOCERR_CHAR_BAD :
                                       MANDOCERR_CHAR_UNSUPP,
                                       curp, curp->line, pos, "0x%x", c);
                                 i++;                                  i++;
                                 ln.buf[pos++] = '?';                                  ln.buf[pos++] = '?';
                                 continue;                                  continue;
Line 435  mparse_buf_r(struct mparse *curp, struct buf blk, size
Line 448  mparse_buf_r(struct mparse *curp, struct buf blk, size
   
                         if ( ! (isascii(c) &&                          if ( ! (isascii(c) &&
                             (isgraph(c) || isblank(c)))) {                              (isgraph(c) || isblank(c)))) {
                                 mandoc_vmsg(MANDOCERR_BADCHAR, curp,                                  mandoc_vmsg(MANDOCERR_CHAR_BAD, curp,
                                     curp->line, pos, "0x%x", c);                                      curp->line, pos, "0x%x", c);
                                 i += 2;                                  i += 2;
                                 ln.buf[pos++] = '?';                                  ln.buf[pos++] = '?';
Line 504  rerun:
Line 517  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 531  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 558  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 628  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 651  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 678  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 691  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 731  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 752  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 761  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 780  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 878  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 974  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.121
CVSweb