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

Diff for /mandoc/main.c between version 1.153 and 1.154

version 1.153, 2011/03/17 12:08:01 version 1.154, 2011/03/20 11:41:24
Line 19 
Line 19 
 #include "config.h"  #include "config.h"
 #endif  #endif
   
 #include <sys/mman.h>  
 #include <sys/stat.h>  
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  
 #include <fcntl.h>  
 #include <stdio.h>  #include <stdio.h>
 #include <stdint.h>  #include <stdint.h>
 #include <stdlib.h>  #include <stdlib.h>
Line 37 
Line 32 
 #include "man.h"  #include "man.h"
 #include "roff.h"  #include "roff.h"
   
 #ifndef MAP_FILE  
 #define MAP_FILE        0  
 #endif  
   
 #define REPARSE_LIMIT   1000  
   
 /* FIXME: Intel's compiler?  LLVM?  pcc?  */  
   
 #if !defined(__GNUC__) || (__GNUC__ < 2)  #if !defined(__GNUC__) || (__GNUC__ < 2)
 # if !defined(lint)  # if !defined(lint)
 #  define __attribute__(x)  #  define __attribute__(x)
Line 55  typedef void  (*out_mdoc)(void *, const struct mdoc *)
Line 42  typedef void  (*out_mdoc)(void *, const struct mdoc *)
 typedef void            (*out_man)(void *, const struct man *);  typedef void            (*out_man)(void *, const struct man *);
 typedef void            (*out_free)(void *);  typedef void            (*out_free)(void *);
   
 struct  buf {  
         char             *buf;  
         size_t            sz;  
 };  
   
 enum    intt {  
         INTT_AUTO,  
         INTT_MDOC,  
         INTT_MAN  
 };  
   
 enum    outt {  enum    outt {
         OUTT_ASCII = 0,          OUTT_ASCII = 0, /* -Tascii */
         OUTT_TREE,          OUTT_TREE,      /* -Ttree */
         OUTT_HTML,          OUTT_HTML,      /* -Thtml */
         OUTT_XHTML,          OUTT_XHTML,     /* -Txhtml */
         OUTT_LINT,          OUTT_LINT,      /* -Tlint */
         OUTT_PS,          OUTT_PS,        /* -Tps */
         OUTT_PDF          OUTT_PDF        /* -Tpdf */
 };  };
   
 struct  curparse {  struct  curparse {
         enum mandoclevel  exit_status;  /* status of all file parses */          struct mparse    *mp;
         const char       *file;         /* current file-name */          const char       *file;         /* current file-name */
         enum mandoclevel  file_status;  /* error status of current parse */  
         int               fd;           /* current file-descriptor */  
         int               line;         /* line number in the file */  
         enum mandoclevel  wlevel;       /* ignore messages below this */          enum mandoclevel  wlevel;       /* ignore messages below this */
         int               wstop;        /* stop after a file with a warning */          int               wstop;        /* stop after a file with a warning */
         enum intt         inttype;      /* which parser to use */  
         struct man       *pman;         /* persistent man parser */  
         struct mdoc      *pmdoc;        /* persistent mdoc parser */  
         struct man       *man;          /* man parser */  
         struct mdoc      *mdoc;         /* mdoc parser */  
         struct roff      *roff;         /* roff parser (!NULL) */  
         struct regset     regs;         /* roff registers */  
         int               reparse_count; /* finite interpolation stack */  
         enum outt         outtype;      /* which output to use */          enum outt         outtype;      /* which output to use */
         out_mdoc          outmdoc;      /* mdoc output ptr */          out_mdoc          outmdoc;      /* mdoc output ptr */
         out_man           outman;       /* man output ptr */          out_man           outman;       /* man output ptr */
Line 227  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 192  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "static buffer exhausted",          "static buffer exhausted",
 };  };
   
 static  void              parsebuf(struct curparse *, struct buf, int);  static  void              evt_close(void *, const char *);
 static  void              pdesc(struct curparse *);  static  int               evt_open(void *, const char *);
 static  void              fdesc(struct curparse *);  static  int               moptions(enum mparset *, char *);
 static  void              ffile(const char *, struct curparse *);  
 static  int               pfile(const char *, struct curparse *);  
 static  int               moptions(enum intt *, char *);  
 static  void              mmsg(enum mandocerr, void *,  static  void              mmsg(enum mandocerr, void *,
                                 int, int, const char *);                                  int, int, const char *);
 static  void              pset(const char *, int, struct curparse *);  static  void              parse(struct curparse *, int,
                                   const char *, enum mandoclevel *);
 static  int               toptions(struct curparse *, char *);  static  int               toptions(struct curparse *, char *);
 static  void              usage(void) __attribute__((noreturn));  static  void              usage(void) __attribute__((noreturn));
 static  void              version(void) __attribute__((noreturn));  static  void              version(void) __attribute__((noreturn));
Line 248  main(int argc, char *argv[])
Line 211  main(int argc, char *argv[])
 {  {
         int              c;          int              c;
         struct curparse  curp;          struct curparse  curp;
           enum mparset     type;
           enum mandoclevel rc;
   
         progname = strrchr(argv[0], '/');          progname = strrchr(argv[0], '/');
         if (progname == NULL)          if (progname == NULL)
Line 257  main(int argc, char *argv[])
Line 222  main(int argc, char *argv[])
   
         memset(&curp, 0, sizeof(struct curparse));          memset(&curp, 0, sizeof(struct curparse));
   
         curp.inttype = INTT_AUTO;          type = MPARSE_AUTO;
         curp.outtype = OUTT_ASCII;          curp.outtype = OUTT_ASCII;
         curp.wlevel  = MANDOCLEVEL_FATAL;          curp.wlevel  = MANDOCLEVEL_FATAL;
         curp.exit_status = MANDOCLEVEL_OK;  
   
         /* LINTED */          /* LINTED */
         while (-1 != (c = getopt(argc, argv, "m:O:T:VW:")))          while (-1 != (c = getopt(argc, argv, "m:O:T:VW:")))
                 switch (c) {                  switch (c) {
                 case ('m'):                  case ('m'):
                         if ( ! moptions(&curp.inttype, optarg))                          if ( ! moptions(&type, optarg))
                                 return((int)MANDOCLEVEL_BADARG);                                  return((int)MANDOCLEVEL_BADARG);
                         break;                          break;
                 case ('O'):                  case ('O'):
Line 289  main(int argc, char *argv[])
Line 253  main(int argc, char *argv[])
                         /* NOTREACHED */                          /* NOTREACHED */
                 }                  }
   
           curp.mp = mparse_alloc(type, evt_open, evt_close, mmsg, &curp);
   
         argc -= optind;          argc -= optind;
         argv += optind;          argv += optind;
   
         if (NULL == *argv) {          rc = MANDOCLEVEL_OK;
                 curp.file = "<stdin>";  
                 curp.fd = STDIN_FILENO;  
   
                 fdesc(&curp);          if (NULL == *argv)
         }                  parse(&curp, STDIN_FILENO, "<stdin>", &rc);
   
         while (*argv) {          while (*argv) {
                 ffile(*argv, &curp);                  parse(&curp, -1, *argv, &rc);
                 if (MANDOCLEVEL_OK != curp.exit_status && curp.wstop)                  if (MANDOCLEVEL_OK != rc && curp.wstop)
                         break;                          break;
                 ++argv;                  ++argv;
         }          }
   
         if (curp.outfree)          if (curp.outfree)
                 (*curp.outfree)(curp.outdata);                  (*curp.outfree)(curp.outdata);
         if (curp.pmdoc)          if (curp.mp)
                 mdoc_free(curp.pmdoc);                  mparse_free(curp.mp);
         if (curp.pman)  
                 man_free(curp.pman);  
         if (curp.roff)  
                 roff_free(curp.roff);  
   
         return((int)curp.exit_status);          return((int)rc);
 }  }
   
   
 static void  static void
 version(void)  version(void)
 {  {
   
         (void)printf("%s %s\n", progname, VERSION);          printf("%s %s\n", progname, VERSION);
         exit((int)MANDOCLEVEL_OK);          exit((int)MANDOCLEVEL_OK);
 }  }
   
   
 static void  static void
 usage(void)  usage(void)
 {  {
   
         (void)fprintf(stderr, "usage: %s "          fprintf(stderr, "usage: %s "
                         "[-V] "                          "[-V] "
                         "[-foption] "                          "[-foption] "
                         "[-mformat] "                          "[-mformat] "
Line 345  usage(void)
Line 303  usage(void)
         exit((int)MANDOCLEVEL_BADARG);          exit((int)MANDOCLEVEL_BADARG);
 }  }
   
 static void  
 ffile(const char *file, struct curparse *curp)  
 {  
   
         /*  
          * Called once per input file.  Get the file ready for reading,  
          * pass it through to the parser-driver, then close it out.  
          * XXX: don't do anything special as this is only called for  
          * files; stdin goes directly to fdesc().  
          */  
   
         curp->file = file;  
   
         if (-1 == (curp->fd = open(curp->file, O_RDONLY, 0))) {  
                 perror(curp->file);  
                 curp->exit_status = MANDOCLEVEL_SYSERR;  
                 return;  
         }  
   
         fdesc(curp);  
   
         if (-1 == close(curp->fd))  
                 perror(curp->file);  
 }  
   
 static int  static int
 pfile(const char *file, struct curparse *curp)  evt_open(void *arg, const char *file)
 {  {
         const char      *savefile;  
         int              fd, savefd;  
   
         if (-1 == (fd = open(file, O_RDONLY, 0))) {          evt_close(arg, file);
                 perror(file);          return(1);
                 curp->file_status = MANDOCLEVEL_SYSERR;  
                 return(0);  
         }  
   
         savefile = curp->file;  
         savefd = curp->fd;  
   
         curp->file = file;  
         curp->fd = fd;  
   
         pdesc(curp);  
   
         curp->file = savefile;  
         curp->fd = savefd;  
   
         if (-1 == close(fd))  
                 perror(file);  
   
         return(MANDOCLEVEL_FATAL > curp->file_status ? 1 : 0);  
 }  }
   
   
 static void  static void
 resize_buf(struct buf *buf, size_t initial)  evt_close(void *arg, const char *file)
 {  {
           struct curparse *p;
   
         buf->sz = buf->sz > initial/2 ? 2 * buf->sz : initial;          p = (struct curparse *)arg;
         buf->buf = mandoc_realloc(buf->buf, buf->sz);          p->file = file;
 }  }
   
   
 static int  
 read_whole_file(struct curparse *curp, struct buf *fb, int *with_mmap)  
 {  
         struct stat      st;  
         size_t           off;  
         ssize_t          ssz;  
   
         if (-1 == fstat(curp->fd, &st)) {  
                 perror(curp->file);  
                 return(0);  
         }  
   
         /*  
          * If we're a regular file, try just reading in the whole entry  
          * via mmap().  This is faster than reading it into blocks, and  
          * since each file is only a few bytes to begin with, I'm not  
          * concerned that this is going to tank any machines.  
          */  
   
         if (S_ISREG(st.st_mode)) {  
                 if (st.st_size >= (1U << 31)) {  
                         fprintf(stderr, "%s: input too large\n",  
                                         curp->file);  
                         return(0);  
                 }  
                 *with_mmap = 1;  
                 fb->sz = (size_t)st.st_size;  
                 fb->buf = mmap(NULL, fb->sz, PROT_READ,  
                                 MAP_FILE|MAP_SHARED, curp->fd, 0);  
                 if (fb->buf != MAP_FAILED)  
                         return(1);  
         }  
   
         /*  
          * If this isn't a regular file (like, say, stdin), then we must  
          * go the old way and just read things in bit by bit.  
          */  
   
         *with_mmap = 0;  
         off = 0;  
         fb->sz = 0;  
         fb->buf = NULL;  
         for (;;) {  
                 if (off == fb->sz) {  
                         if (fb->sz == (1U << 31)) {  
                                 fprintf(stderr, "%s: input too large\n",  
                                                 curp->file);  
                                 break;  
                         }  
                         resize_buf(fb, 65536);  
                 }  
                 ssz = read(curp->fd, fb->buf + (int)off, fb->sz - off);  
                 if (ssz == 0) {  
                         fb->sz = off;  
                         return(1);  
                 }  
                 if (ssz == -1) {  
                         perror(curp->file);  
                         break;  
                 }  
                 off += (size_t)ssz;  
         }  
   
         free(fb->buf);  
         fb->buf = NULL;  
         return(0);  
 }  
   
   
 static void  static void
 fdesc(struct curparse *curp)  parse(struct curparse *curp, int fd,
                   const char *file, enum mandoclevel *level)
 {  {
           enum mandoclevel  rc;
           struct mdoc      *mdoc;
           struct man       *man;
   
         /*          /* Begin by parsing the file itself. */
          * Called once per file with an opened file descriptor.  All  
          * pre-file-parse operations (whether stdin or a file) should go  
          * here.  
          *  
          * This calls down into the nested parser, which drills down and  
          * fully parses a file and all its dependences (i.e., `so').  It  
          * then runs the cleanup validators and pushes to output.  
          */  
   
         /* Zero the parse type. */          assert(file);
           assert(fd >= -1);
   
         curp->mdoc = NULL;          rc = mparse_readfd(curp->mp, fd, file);
         curp->man = NULL;  
         curp->file_status = MANDOCLEVEL_OK;  
   
         /* Make sure the mandotory roff parser is initialised. */          /* Stop immediately if the parse has failed. */
   
         if (NULL == curp->roff) {          if (MANDOCLEVEL_FATAL <= rc)
                 curp->roff = roff_alloc(&curp->regs, curp, mmsg);  
                 assert(curp->roff);  
         }  
   
         /* Fully parse the file. */  
   
         pdesc(curp);  
   
         if (MANDOCLEVEL_FATAL <= curp->file_status)  
                 goto cleanup;                  goto cleanup;
   
         /* NOTE a parser may not have been assigned, yet. */  
   
         if ( ! (curp->man || curp->mdoc)) {  
                 fprintf(stderr, "%s: Not a manual\n", curp->file);  
                 curp->file_status = MANDOCLEVEL_FATAL;  
                 goto cleanup;  
         }  
   
         /* Clean up the parse routine ASTs. */  
   
         if (curp->mdoc && ! mdoc_endparse(curp->mdoc)) {  
                 assert(MANDOCLEVEL_FATAL <= curp->file_status);  
                 goto cleanup;  
         }  
   
         if (curp->man && ! man_endparse(curp->man)) {  
                 assert(MANDOCLEVEL_FATAL <= curp->file_status);  
                 goto cleanup;  
         }  
   
         assert(curp->roff);  
         roff_endparse(curp->roff);  
   
         /*          /*
          * With -Wstop and warnings or errors of at least           * With -Wstop and warnings or errors of at least the requested
          * the requested level, do not produce output.           * level, do not produce output.
          */           */
   
         if (MANDOCLEVEL_OK != curp->file_status && curp->wstop)          if (MANDOCLEVEL_OK != rc && curp->wstop)
                 goto cleanup;                  goto cleanup;
   
         /* If unset, allocate output dev now (if applicable). */          /* If unset, allocate output dev now (if applicable). */
Line 594  fdesc(struct curparse *curp)
Line 399  fdesc(struct curparse *curp)
                 }                  }
         }          }
   
           mparse_result(curp->mp, &mdoc, &man);
   
         /* Execute the out device, if it exists. */          /* Execute the out device, if it exists. */
   
         if (curp->man && curp->outman)          if (man && curp->outman)
                 (*curp->outman)(curp->outdata, curp->man);                  (*curp->outman)(curp->outdata, man);
         if (curp->mdoc && curp->outmdoc)          if (mdoc && curp->outmdoc)
                 (*curp->outmdoc)(curp->outdata, curp->mdoc);                  (*curp->outmdoc)(curp->outdata, mdoc);
   
  cleanup:   cleanup:
   
         memset(&curp->regs, 0, sizeof(struct regset));          mparse_reset(curp->mp);
   
         /* Reset the current-parse compilers. */          if (*level < rc)
                   *level = rc;
         if (curp->mdoc)  
                 mdoc_reset(curp->mdoc);  
         if (curp->man)  
                 man_reset(curp->man);  
   
         assert(curp->roff);  
         roff_reset(curp->roff);  
   
         if (curp->exit_status < curp->file_status)  
                 curp->exit_status = curp->file_status;  
   
         return;  
 }  }
   
 static void  
 pdesc(struct curparse *curp)  
 {  
         struct buf       blk;  
         int              with_mmap;  
   
         /*  
          * Run for each opened file; may be called more than once for  
          * each full parse sequence if the opened file is nested (i.e.,  
          * from `so').  Simply sucks in the whole file and moves into  
          * the parse phase for the file.  
          */  
   
         if ( ! read_whole_file(curp, &blk, &with_mmap)) {  
                 curp->file_status = MANDOCLEVEL_SYSERR;  
                 return;  
         }  
   
         /* Line number is per-file. */  
   
         curp->line = 1;  
   
         parsebuf(curp, blk, 1);  
   
         if (with_mmap)  
                 munmap(blk.buf, blk.sz);  
         else  
                 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  
 parsebuf(struct curparse *curp, struct buf blk, int start)  
 {  
         const struct tbl_span   *span;  
         struct buf       ln;  
         enum rofferr     rr;  
         int              i, of, rc;  
         int              pos; /* byte number in the ln buffer */  
         int              lnn; /* line number in the real file */  
         unsigned char    c;  
   
         memset(&ln, 0, sizeof(struct buf));  
   
         lnn = curp->line;  
         pos = 0;  
   
         for (i = 0; i < (int)blk.sz; ) {  
                 if (0 == pos && '\0' == blk.buf[i])  
                         break;  
   
                 if (start) {  
                         curp->line = lnn;  
                         curp->reparse_count = 0;  
                 }  
   
                 while (i < (int)blk.sz && (start || '\0' != blk.buf[i])) {  
   
                         /*  
                          * When finding an unescaped newline character,  
                          * leave the character loop to process the line.  
                          * Skip a preceding carriage return, if any.  
                          */  
   
                         if ('\r' == blk.buf[i] && i + 1 < (int)blk.sz &&  
                             '\n' == blk.buf[i + 1])  
                                 ++i;  
                         if ('\n' == blk.buf[i]) {  
                                 ++i;  
                                 ++lnn;  
                                 break;  
                         }  
   
                         /*  
                          * Warn about bogus characters.  If you're using  
                          * non-ASCII encoding, you're screwing your  
                          * readers.  Since I'd rather this not happen,  
                          * I'll be helpful and drop these characters so  
                          * we don't display gibberish.  Note to manual  
                          * writers: use special characters.  
                          */  
   
                         c = (unsigned char) blk.buf[i];  
   
                         if ( ! (isascii(c) &&  
                                         (isgraph(c) || isblank(c)))) {  
                                 mmsg(MANDOCERR_BADCHAR, curp,  
                                     curp->line, pos, "ignoring byte");  
                                 i++;  
                                 continue;  
                         }  
   
                         /* Trailing backslash = a plain char. */  
   
                         if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {  
                                 if (pos >= (int)ln.sz)  
                                         resize_buf(&ln, 256);  
                                 ln.buf[pos++] = blk.buf[i++];  
                                 continue;  
                         }  
   
                         /*  
                          * Found escape and at least one other character.  
                          * When it's a newline character, skip it.  
                          * When there is a carriage return in between,  
                          * skip that one as well.  
                          */  
   
                         if ('\r' == blk.buf[i + 1] && i + 2 < (int)blk.sz &&  
                             '\n' == blk.buf[i + 2])  
                                 ++i;  
                         if ('\n' == blk.buf[i + 1]) {  
                                 i += 2;  
                                 ++lnn;  
                                 continue;  
                         }  
   
                         if ('"' == blk.buf[i + 1]) {  
                                 i += 2;  
                                 /* Comment, skip to end of line */  
                                 for (; i < (int)blk.sz; ++i) {  
                                         if ('\n' == blk.buf[i]) {  
                                                 ++i;  
                                                 ++lnn;  
                                                 break;  
                                         }  
                                 }  
   
                                 /* Backout trailing whitespaces */  
                                 for (; pos > 0; --pos) {  
                                         if (ln.buf[pos - 1] != ' ')  
                                                 break;  
                                         if (pos > 2 && ln.buf[pos - 2] == '\\')  
                                                 break;  
                                 }  
                                 break;  
                         }  
   
                         /* Some other escape sequence, copy & cont. */  
   
                         if (pos + 1 >= (int)ln.sz)  
                                 resize_buf(&ln, 256);  
   
                         ln.buf[pos++] = blk.buf[i++];  
                         ln.buf[pos++] = blk.buf[i++];  
                 }  
   
                 if (pos >= (int)ln.sz)  
                         resize_buf(&ln, 256);  
   
                 ln.buf[pos] = '\0';  
   
                 /*  
                  * A significant amount of complexity is contained by  
                  * the roff preprocessor.  It's line-oriented but can be  
                  * expressed on one line, so we need at times to  
                  * readjust our starting point and re-run it.  The roff  
                  * preprocessor can also readjust the buffers with new  
                  * data, so we pass them in wholesale.  
                  */  
   
                 of = 0;  
   
 rerun:  
                 rr = roff_parseln  
                         (curp->roff, curp->line,  
                          &ln.buf, &ln.sz, of, &of);  
   
                 switch (rr) {  
                 case (ROFF_REPARSE):  
                         if (REPARSE_LIMIT >= ++curp->reparse_count)  
                                 parsebuf(curp, ln, 0);  
                         else  
                                 mmsg(MANDOCERR_ROFFLOOP, curp,  
                                     curp->line, pos, NULL);  
                         pos = 0;  
                         continue;  
                 case (ROFF_APPEND):  
                         pos = (int)strlen(ln.buf);  
                         continue;  
                 case (ROFF_RERUN):  
                         goto rerun;  
                 case (ROFF_IGN):  
                         pos = 0;  
                         continue;  
                 case (ROFF_ERR):  
                         assert(MANDOCLEVEL_FATAL <= curp->file_status);  
                         break;  
                 case (ROFF_SO):  
                         if (pfile(ln.buf + of, curp)) {  
                                 pos = 0;  
                                 continue;  
                         } else  
                                 break;  
                 default:  
                         break;  
                 }  
   
                 /*  
                  * If we encounter errors in the recursive parsebuf()  
                  * call, make sure we don't continue parsing.  
                  */  
   
                 if (MANDOCLEVEL_FATAL <= curp->file_status)  
                         break;  
   
                 /*  
                  * If input parsers have not been allocated, do so now.  
                  * We keep these instanced betwen parsers, but set them  
                  * locally per parse routine since we can use different  
                  * parsers with each one.  
                  */  
   
                 if ( ! (curp->man || curp->mdoc))  
                         pset(ln.buf + of, pos - of, curp);  
   
                 /*  
                  * Lastly, push down into the parsers themselves.  One  
                  * of these will have already been set in the pset()  
                  * routine.  
                  * If libroff returns ROFF_TBL, then add it to the  
                  * currently open parse.  Since we only get here if  
                  * there does exist data (see tbl_data.c), we're  
                  * guaranteed that something's been allocated.  
                  * Do the same for ROFF_EQN.  
                  */  
   
                 rc = -1;  
   
                 if (ROFF_TBL == rr)  
                         while (NULL != (span = roff_span(curp->roff))) {  
                                 rc = curp->man ?  
                                         man_addspan(curp->man, span) :  
                                         mdoc_addspan(curp->mdoc, span);  
                                 if (0 == rc)  
                                         break;  
                         }  
                 else if (ROFF_EQN == rr)  
                         rc = 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 ?  
                                 man_parseln(curp->man,  
                                         curp->line, ln.buf, of) :  
                                 mdoc_parseln(curp->mdoc,  
                                         curp->line, ln.buf, of);  
   
                 if (0 == rc) {  
                         assert(MANDOCLEVEL_FATAL <= curp->file_status);  
                         break;  
                 }  
   
                 /* Temporary buffers typically are not full. */  
   
                 if (0 == start && '\0' == blk.buf[i])  
                         break;  
   
                 /* Start the next input line. */  
   
                 pos = 0;  
         }  
   
         free(ln.buf);  
 }  
   
 static void  
 pset(const char *buf, int pos, struct curparse *curp)  
 {  
         int              i;  
   
         /*  
          * Try to intuit which kind of manual parser should be used.  If  
          * passed in by command-line (-man, -mdoc), then use that  
          * explicitly.  If passed as -mandoc, then try to guess from the  
          * line: either skip dot-lines, use -mdoc when finding `.Dt', or  
          * default to -man, which is more lenient.  
          *  
          * Separate out pmdoc/pman from mdoc/man: the first persists  
          * through all parsers, while the latter is used per-parse.  
          */  
   
         if ('.' == buf[0] || '\'' == buf[0]) {  
                 for (i = 1; buf[i]; i++)  
                         if (' ' != buf[i] && '\t' != buf[i])  
                                 break;  
                 if ('\0' == buf[i])  
                         return;  
         }  
   
         switch (curp->inttype) {  
         case (INTT_MDOC):  
                 if (NULL == curp->pmdoc)  
                         curp->pmdoc = mdoc_alloc  
                                 (&curp->regs, curp, mmsg);  
                 assert(curp->pmdoc);  
                 curp->mdoc = curp->pmdoc;  
                 return;  
         case (INTT_MAN):  
                 if (NULL == curp->pman)  
                         curp->pman = man_alloc  
                                 (&curp->regs, curp, mmsg);  
                 assert(curp->pman);  
                 curp->man = curp->pman;  
                 return;  
         default:  
                 break;  
         }  
   
         if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {  
                 if (NULL == curp->pmdoc)  
                         curp->pmdoc = mdoc_alloc  
                                 (&curp->regs, curp, mmsg);  
                 assert(curp->pmdoc);  
                 curp->mdoc = curp->pmdoc;  
                 return;  
         }  
   
         if (NULL == curp->pman)  
                 curp->pman = man_alloc(&curp->regs, curp, mmsg);  
         assert(curp->pman);  
         curp->man = curp->pman;  
 }  
   
 static int  static int
 moptions(enum intt *tflags, char *arg)  moptions(enum mparset *tflags, char *arg)
 {  {
   
         if (0 == strcmp(arg, "doc"))          if (0 == strcmp(arg, "doc"))
                 *tflags = INTT_MDOC;                  *tflags = MPARSE_MDOC;
         else if (0 == strcmp(arg, "andoc"))          else if (0 == strcmp(arg, "andoc"))
                 *tflags = INTT_AUTO;                  *tflags = MPARSE_AUTO;
         else if (0 == strcmp(arg, "an"))          else if (0 == strcmp(arg, "an"))
                 *tflags = INTT_MAN;                  *tflags = MPARSE_MAN;
         else {          else {
                 fprintf(stderr, "%s: Bad argument\n", arg);                  fprintf(stderr, "%s: Bad argument\n", arg);
                 return(0);                  return(0);
Line 978  toptions(struct curparse *curp, char *arg)
Line 443  toptions(struct curparse *curp, char *arg)
         else if (0 == strcmp(arg, "lint")) {          else if (0 == strcmp(arg, "lint")) {
                 curp->outtype = OUTT_LINT;                  curp->outtype = OUTT_LINT;
                 curp->wlevel  = MANDOCLEVEL_WARNING;                  curp->wlevel  = MANDOCLEVEL_WARNING;
         }          } else if (0 == strcmp(arg, "tree"))
         else if (0 == strcmp(arg, "tree"))  
                 curp->outtype = OUTT_TREE;                  curp->outtype = OUTT_TREE;
         else if (0 == strcmp(arg, "html"))          else if (0 == strcmp(arg, "html"))
                 curp->outtype = OUTT_HTML;                  curp->outtype = OUTT_HTML;
Line 1051  mmsg(enum mandocerr t, void *arg, int ln, int col, con
Line 515  mmsg(enum mandocerr t, void *arg, int ln, int col, con
         if (level < cp->wlevel)          if (level < cp->wlevel)
                 return;                  return;
   
         fprintf(stderr, "%s:%d:%d: %s: %s",          fprintf(stderr, "%s:%d:%d: %s: %s", cp->file, ln, col + 1,
             cp->file, ln, col + 1, mandoclevels[level], mandocerrs[t]);                          mandoclevels[level], mandocerrs[t]);
   
         if (msg)          if (msg)
                 fprintf(stderr, ": %s", msg);                  fprintf(stderr, ": %s", msg);
   
         fputc('\n', stderr);          fputc('\n', stderr);
   
         if (cp->file_status < level)          mparse_setstatus(cp->mp, level);
                 cp->file_status = level;  
 }  }

Legend:
Removed from v.1.153  
changed lines
  Added in v.1.154

CVSweb