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

Diff for /mandoc/main.c between version 1.143 and 1.148

version 1.143, 2011/02/06 20:36:36 version 1.148, 2011/03/15 13:24:42
Line 78  enum outt {
Line 78  enum outt {
 };  };
   
 struct  curparse {  struct  curparse {
         const char       *file;         /* Current parse. */          const char       *file;         /* current file-name */
         int               fd;           /* Current parse. */          enum mandoclevel  file_status;  /* error status of current parse */
         int               line;         /* Line number in the file. */          int               fd;           /* current file-descriptor */
         enum mandoclevel  wlevel;       /* Ignore messages below this. */          int               line;         /* line number in the file */
         int               wstop;        /* Stop after a file with a warning. */          enum mandoclevel  wlevel;       /* ignore messages below this */
           int               wstop;        /* stop after a file with a warning */
         enum intt         inttype;      /* which parser to use */          enum intt         inttype;      /* which parser to use */
         struct man       *pman;         /* persistent man parser */          struct man       *pman;         /* persistent man parser */
         struct mdoc      *pmdoc;        /* persistent mdoc parser */          struct mdoc      *pmdoc;        /* persistent mdoc parser */
Line 128  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 129  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "no title in document",          "no title in document",
         "document title should be all caps",          "document title should be all caps",
         "unknown manual section",          "unknown manual section",
         "cannot parse date argument",          "date missing, using today's date",
           "cannot parse date, using it verbatim",
         "prologue macros out of order",          "prologue macros out of order",
         "duplicate prologue macro",          "duplicate prologue macro",
         "macro not allowed in prologue",          "macro not allowed in prologue",
Line 240  static void    version(void) __attribute__((noreturn))
Line 242  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 377  pfile(const char *file, struct curparse *curp)
Line 378  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);
                 file_status = MANDOCLEVEL_SYSERR;                  curp->file_status = MANDOCLEVEL_SYSERR;
                 return(0);                  return(0);
         }          }
   
Line 395  pfile(const char *file, struct curparse *curp)
Line 396  pfile(const char *file, struct curparse *curp)
         if (-1 == close(fd))          if (-1 == close(fd))
                 perror(file);                  perror(file);
   
         return(MANDOCLEVEL_FATAL > file_status ? 1 : 0);          return(MANDOCLEVEL_FATAL > curp->file_status ? 1 : 0);
 }  }
   
   
Line 499  fdesc(struct curparse *curp)
Line 500  fdesc(struct curparse *curp)
   
         curp->mdoc = NULL;          curp->mdoc = NULL;
         curp->man = NULL;          curp->man = NULL;
         file_status = MANDOCLEVEL_OK;          curp->file_status = MANDOCLEVEL_OK;
   
         /* Make sure the mandotory roff parser is initialised. */          /* Make sure the mandotory roff parser is initialised. */
   
Line 512  fdesc(struct curparse *curp)
Line 513  fdesc(struct curparse *curp)
   
         pdesc(curp);          pdesc(curp);
   
         if (MANDOCLEVEL_FATAL <= file_status)          if (MANDOCLEVEL_FATAL <= curp->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);
                 file_status = MANDOCLEVEL_FATAL;                  curp->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 <= file_status);                  assert(MANDOCLEVEL_FATAL <= curp->file_status);
                 goto cleanup;                  goto cleanup;
         }          }
   
         if (curp->man && ! man_endparse(curp->man)) {          if (curp->man && ! man_endparse(curp->man)) {
                 assert(MANDOCLEVEL_FATAL <= file_status);                  assert(MANDOCLEVEL_FATAL <= curp->file_status);
                 goto cleanup;                  goto cleanup;
         }          }
   
Line 543  fdesc(struct curparse *curp)
Line 544  fdesc(struct curparse *curp)
          * the requested level, do not produce output.           * the requested level, do not produce output.
          */           */
   
         if (MANDOCLEVEL_OK != file_status && curp->wstop)          if (MANDOCLEVEL_OK != curp->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 618  fdesc(struct curparse *curp)
Line 619  fdesc(struct curparse *curp)
         assert(curp->roff);          assert(curp->roff);
         roff_reset(curp->roff);          roff_reset(curp->roff);
   
         if (exit_status < file_status)          if (exit_status < curp->file_status)
                 exit_status = file_status;                  exit_status = curp->file_status;
   
         return;          return;
 }  }
Line 638  pdesc(struct curparse *curp)
Line 639  pdesc(struct curparse *curp)
          */           */
   
         if ( ! read_whole_file(curp, &blk, &with_mmap)) {          if ( ! read_whole_file(curp, &blk, &with_mmap)) {
                 file_status = MANDOCLEVEL_SYSERR;                  curp->file_status = MANDOCLEVEL_SYSERR;
                 return;                  return;
         }          }
   
Line 654  pdesc(struct curparse *curp)
Line 655  pdesc(struct curparse *curp)
                 free(blk.buf);                  free(blk.buf);
 }  }
   
   /*
    * Main parse routine for an opened file.  This is called for each
    * opened file and simply loops around the full input file, possibly
    * nesting (i.e., with `so').
    */
 static void  static void
 parsebuf(struct curparse *curp, struct buf blk, int start)  parsebuf(struct curparse *curp, struct buf blk, int start)
 {  {
Line 665  parsebuf(struct curparse *curp, struct buf blk, int st
Line 671  parsebuf(struct curparse *curp, struct buf blk, int st
         int              lnn; /* line number in the real file */          int              lnn; /* line number in the real file */
         unsigned char    c;          unsigned char    c;
   
         /*  
          * Main parse routine for an opened file.  This is called for  
          * each opened file and simply loops around the full input file,  
          * possibly nesting (i.e., with `so').  
          */  
   
         memset(&ln, 0, sizeof(struct buf));          memset(&ln, 0, sizeof(struct buf));
   
         lnn = curp->line;          lnn = curp->line;
Line 815  rerun:
Line 815  rerun:
                         pos = 0;                          pos = 0;
                         continue;                          continue;
                 case (ROFF_ERR):                  case (ROFF_ERR):
                         assert(MANDOCLEVEL_FATAL <= file_status);                          assert(MANDOCLEVEL_FATAL <= curp->file_status);
                         break;                          break;
                 case (ROFF_SO):                  case (ROFF_SO):
                         if (pfile(ln.buf + of, curp)) {                          if (pfile(ln.buf + of, curp)) {
Line 832  rerun:
Line 832  rerun:
                  * call, make sure we don't continue parsing.                   * call, make sure we don't continue parsing.
                  */                   */
   
                 if (MANDOCLEVEL_FATAL <= file_status)                  if (MANDOCLEVEL_FATAL <= curp->file_status)
                         break;                          break;
   
                 /*                  /*
Line 853  rerun:
Line 853  rerun:
                  * currently open parse.  Since we only get here if                   * currently open parse.  Since we only get here if
                  * there does exist data (see tbl_data.c), we're                   * there does exist data (see tbl_data.c), we're
                  * guaranteed that something's been allocated.                   * guaranteed that something's been allocated.
                    * Do the same for ROFF_EQN.
                  */                   */
   
                 if (ROFF_TBL == rr) {                  rc = -1;
                         assert(curp->man || curp->mdoc);  
                   if (ROFF_TBL == rr)
                         while (NULL != (span = roff_span(curp->roff))) {                          while (NULL != (span = roff_span(curp->roff))) {
                                 if (curp->man)                                  rc = curp->man ?
                                         man_addspan(curp->man, span);                                          man_addspan(curp->man, span) :
                                 else  
                                         mdoc_addspan(curp->mdoc, span);                                          mdoc_addspan(curp->mdoc, span);
                                   if (0 == rc)
                                           break;
                         }                          }
                 } else if (ROFF_EQN == rr) {                  else if (ROFF_EQN == rr)
                         assert(curp->man || curp->mdoc);                          rc = curp->mdoc ?
                 } else if (curp->man || curp->mdoc) {                                  mdoc_addeqn(curp->mdoc,
                                           roff_eqn(curp->roff)) :
                                   man_addeqn(curp->man,
                                           roff_eqn(curp->roff));
                   else if (curp->man || curp->mdoc)
                         rc = curp->man ?                          rc = curp->man ?
                                 man_parseln(curp->man,                                  man_parseln(curp->man,
                                         curp->line, ln.buf, of) :                                          curp->line, ln.buf, of) :
                                 mdoc_parseln(curp->mdoc,                                  mdoc_parseln(curp->mdoc,
                                         curp->line, ln.buf, of);                                          curp->line, ln.buf, of);
   
                         if ( ! rc) {                  if (0 == rc) {
                                 assert(MANDOCLEVEL_FATAL <= file_status);                          assert(MANDOCLEVEL_FATAL <= curp->file_status);
                                 break;                          break;
                         }  
                 }                  }
   
                 /* Temporary buffers typically are not full. */                  /* Temporary buffers typically are not full. */
Line 1055  mmsg(enum mandocerr t, void *arg, int ln, int col, con
Line 1061  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 (file_status < level)          if (cp->file_status < level)
                 file_status = level;                  cp->file_status = level;
   
         return(level < MANDOCLEVEL_FATAL);          return(level < MANDOCLEVEL_FATAL);
 }  }
Legend:
Removed from v.1.143  
changed lines
  Added in v.1.148
CVSweb