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

version 1.113, 2010/12/01 16:54:25 version 1.118, 2010/12/05 15:55:01
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 146  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 145  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "NAME section must come first",          "NAME section must come first",
         "bad Boolean value",          "bad Boolean value",
         "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 169  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 184  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",
Line 194  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 194  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 212  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 349  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 367  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 471  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 484  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 518  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 593  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 613  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 633  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 748  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 766  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 802  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 984  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.118
CVSweb