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

Diff for /mandoc/main.c between version 1.113 and 1.120

version 1.113, 2010/12/01 16:54:25 version 1.120, 2010/12/06 15:31:19
Line 133  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 133  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "bad escape sequence",          "bad escape sequence",
         "unterminated quoted string",          "unterminated quoted string",
         "argument requires the width argument",          "argument requires the width argument",
         "superfluous width argument",  
         "bad date argument",          "bad date argument",
         "bad width argument",          "bad width argument",
         "unknown manual section",          "unknown manual section",
Line 145  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 144  static const char * const mandocerrs[MANDOCERR_MAX] = 
   
         "NAME section must come first",          "NAME section must come first",
         "bad Boolean value",          "bad Boolean value",
           "unknown font",
         "child violates parent syntax",          "child violates parent syntax",
           "displays may not be nested",
         "bad AT&T symbol",          "bad AT&T symbol",
         "bad standard",          "bad standard",
         "list type repeated",          "list type repeated",
Line 169  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 170  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "request scope close w/none open",          "request scope close w/none open",
         "scope already open",          "scope already open",
         "scope open on exit",          "scope open on exit",
           "uname(3) system call failed",
         "macro requires line argument(s)",          "macro requires line argument(s)",
         "macro requires body argument(s)",          "macro requires body argument(s)",
         "macro requires argument(s)",          "macro requires argument(s)",
Line 183  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 185  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "generic fatal error",          "generic fatal error",
   
         "column syntax is inconsistent",          "column syntax is inconsistent",
         "displays may not be nested",  
         "unsupported display type",          "unsupported display type",
         "blocks badly nested",          "blocks badly nested",
         "no such block is open",          "no such block is open",
           "missing end of block",
         "line scope broken, syntax violated",          "line scope broken, syntax violated",
         "argument count wrong, violates syntax",          "argument count wrong, violates syntax",
         "child violates parent syntax",          "child violates parent syntax",
Line 194  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 196  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "NOT IMPLEMENTED: .so with absolute path or \"..\"",          "NOT IMPLEMENTED: .so with absolute path or \"..\"",
         "no document body",          "no document body",
         "no document prologue",          "no document prologue",
         "utsname system call failed",  
         "static buffer exhausted",          "static buffer exhausted",
 };  };
   
Line 213  static void    version(void) __attribute__((noreturn))
Line 214  static void    version(void) __attribute__((noreturn))
 static  int               woptions(struct curparse *, char *);  static  int               woptions(struct curparse *, char *);
   
 static  const char       *progname;  static  const char       *progname;
   static  enum mandoclevel  file_status = MANDOCLEVEL_OK;
 static  enum mandoclevel  exit_status = MANDOCLEVEL_OK;  static  enum mandoclevel  exit_status = MANDOCLEVEL_OK;
   
 int  int
Line 349  pfile(const char *file, struct curparse *curp)
Line 351  pfile(const char *file, struct curparse *curp)
   
         if (-1 == (fd = open(file, O_RDONLY, 0))) {          if (-1 == (fd = open(file, O_RDONLY, 0))) {
                 perror(file);                  perror(file);
                 exit_status = MANDOCLEVEL_SYSERR;                  file_status = MANDOCLEVEL_SYSERR;
                 return(0);                  return(0);
         }          }
   
Line 367  pfile(const char *file, struct curparse *curp)
Line 369  pfile(const char *file, struct curparse *curp)
         if (-1 == close(fd))          if (-1 == close(fd))
                 perror(file);                  perror(file);
   
         return(MANDOCLEVEL_FATAL > exit_status ? 1 : 0);          return(MANDOCLEVEL_FATAL > file_status ? 1 : 0);
 }  }
   
   
Line 471  fdesc(struct curparse *curp)
Line 473  fdesc(struct curparse *curp)
   
         curp->mdoc = NULL;          curp->mdoc = NULL;
         curp->man = NULL;          curp->man = NULL;
           file_status = MANDOCLEVEL_OK;
   
         /* Make sure the mandotory roff parser is initialised. */          /* Make sure the mandotory roff parser is initialised. */
   
Line 483  fdesc(struct curparse *curp)
Line 486  fdesc(struct curparse *curp)
   
         pdesc(curp);          pdesc(curp);
   
         if (MANDOCLEVEL_FATAL <= exit_status)          if (MANDOCLEVEL_FATAL <= file_status)
                 goto cleanup;                  goto cleanup;
   
         /* NOTE a parser may not have been assigned, yet. */          /* NOTE a parser may not have been assigned, yet. */
   
         if ( ! (curp->man || curp->mdoc)) {          if ( ! (curp->man || curp->mdoc)) {
                 fprintf(stderr, "%s: Not a manual\n", curp->file);                  fprintf(stderr, "%s: Not a manual\n", curp->file);
                 exit_status = MANDOCLEVEL_FATAL;                  file_status = MANDOCLEVEL_FATAL;
                 goto cleanup;                  goto cleanup;
         }          }
   
         /* Clean up the parse routine ASTs. */          /* Clean up the parse routine ASTs. */
   
         if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {          if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {
                 assert(MANDOCLEVEL_FATAL <= exit_status);                  assert(MANDOCLEVEL_FATAL <= file_status);
                 goto cleanup;                  goto cleanup;
         }          }
   
         if (curp->man && ! man_endparse(curp->man)) {          if (curp->man && ! man_endparse(curp->man)) {
                 assert(MANDOCLEVEL_FATAL <= exit_status);                  assert(MANDOCLEVEL_FATAL <= file_status);
                 goto cleanup;                  goto cleanup;
         }          }
   
         assert(curp->roff);          assert(curp->roff);
         if ( ! roff_endparse(curp->roff)) {          if ( ! roff_endparse(curp->roff)) {
                 assert(MANDOCLEVEL_FATAL <= exit_status);                  assert(MANDOCLEVEL_FATAL <= file_status);
                 goto cleanup;                  goto cleanup;
         }          }
   
Line 517  fdesc(struct curparse *curp)
Line 520  fdesc(struct curparse *curp)
          * the requested level, do not produce output.           * the requested level, do not produce output.
          */           */
   
         if (MANDOCLEVEL_OK != exit_status && curp->wstop)          if (MANDOCLEVEL_OK != file_status && curp->wstop)
                 goto cleanup;                  goto cleanup;
   
         /* If unset, allocate output dev now (if applicable). */          /* If unset, allocate output dev now (if applicable). */
Line 592  fdesc(struct curparse *curp)
Line 595  fdesc(struct curparse *curp)
         assert(curp->roff);          assert(curp->roff);
         roff_reset(curp->roff);          roff_reset(curp->roff);
   
           if (exit_status < file_status)
                   exit_status = file_status;
   
         return;          return;
 }  }
   
Line 609  pdesc(struct curparse *curp)
Line 615  pdesc(struct curparse *curp)
          */           */
   
         if ( ! read_whole_file(curp, &blk, &with_mmap)) {          if ( ! read_whole_file(curp, &blk, &with_mmap)) {
                 exit_status = MANDOCLEVEL_SYSERR;                  file_status = MANDOCLEVEL_SYSERR;
                 return;                  return;
         }          }
   
Line 629  static void
Line 635  static void
 parsebuf(struct curparse *curp, struct buf blk, int start)  parsebuf(struct curparse *curp, struct buf blk, int start)
 {  {
         struct buf       ln;          struct buf       ln;
           enum rofferr     rr;
         int              i, of, rc;          int              i, of, rc;
         int              pos; /* byte number in the ln buffer */          int              pos; /* byte number in the ln buffer */
         int              lnn; /* line number in the real file */          int              lnn; /* line number in the real file */
Line 743  parsebuf(struct curparse *curp, struct buf blk, int st
Line 750  parsebuf(struct curparse *curp, struct buf blk, int st
                 of = 0;                  of = 0;
   
 rerun:  rerun:
                 rc = roff_parseln                  rr = roff_parseln
                         (curp->roff, curp->line,                          (curp->roff, curp->line,
                          &ln.buf, &ln.sz, of, &of);                           &ln.buf, &ln.sz, of, &of);
   
                 switch (rc) {                  switch (rr) {
                 case (ROFF_REPARSE):                  case (ROFF_REPARSE):
                         parsebuf(curp, ln, 0);                          parsebuf(curp, ln, 0);
                         pos = 0;                          pos = 0;
Line 761  rerun:
Line 768  rerun:
                         pos = 0;                          pos = 0;
                         continue;                          continue;
                 case (ROFF_ERR):                  case (ROFF_ERR):
                         assert(MANDOCLEVEL_FATAL <= exit_status);                          assert(MANDOCLEVEL_FATAL <= file_status);
                         break;                          break;
                 case (ROFF_SO):                  case (ROFF_SO):
                         if (pfile(ln.buf + of, curp)) {                          if (pfile(ln.buf + of, curp)) {
Line 797  rerun:
Line 804  rerun:
                                         curp->line, ln.buf, of);                                          curp->line, ln.buf, of);
   
                         if ( ! rc) {                          if ( ! rc) {
                                 assert(MANDOCLEVEL_FATAL <= exit_status);                                  assert(MANDOCLEVEL_FATAL <= file_status);
                                 break;                                  break;
                         }                          }
                 }                  }
Line 979  mmsg(enum mandocerr t, void *arg, int ln, int col, con
Line 986  mmsg(enum mandocerr t, void *arg, int ln, int col, con
                 fprintf(stderr, ": %s", msg);                  fprintf(stderr, ": %s", msg);
         fputc('\n', stderr);          fputc('\n', stderr);
   
         if (exit_status < level)          if (file_status < level)
                 exit_status = level;                  file_status = level;
   
         return(level < MANDOCLEVEL_FATAL);          return(level < MANDOCLEVEL_FATAL);
 }  }
Legend:
Removed from v.1.113  
changed lines
  Added in v.1.120
CVSweb