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

Diff for /mandoc/main.c between version 1.61 and 1.76

version 1.61, 2010/04/12 19:27:22 version 1.76, 2010/05/16 10:59:36
Line 18 
Line 18 
 #include "config.h"  #include "config.h"
 #endif  #endif
   
   #include <sys/mman.h>
 #include <sys/stat.h>  #include <sys/stat.h>
   
 #include <assert.h>  #include <assert.h>
Line 28 
Line 29 
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   
   #include "mandoc.h"
 #include "mdoc.h"  #include "mdoc.h"
 #include "man.h"  #include "man.h"
   #include "roff.h"
 #include "main.h"  #include "main.h"
   
 #define UNCONST(a)      ((void *)(uintptr_t)(const void *)(a))  #define UNCONST(a)      ((void *)(uintptr_t)(const void *)(a))
Line 69  struct curparse {
Line 72  struct curparse {
         const char       *file;         /* Current parse. */          const char       *file;         /* Current parse. */
         int               fd;           /* Current parse. */          int               fd;           /* Current parse. */
         int               wflags;          int               wflags;
           /* FIXME: set by max error */
 #define WARN_WALL        (1 << 0)       /* All-warnings mask. */  #define WARN_WALL        (1 << 0)       /* All-warnings mask. */
 #define WARN_WERR        (1 << 2)       /* Warnings->errors. */  #define WARN_WERR        (1 << 2)       /* Warnings->errors. */
         int               fflags;          int               fflags;
 #define FL_IGN_SCOPE     (1 << 0)       /* Ignore scope errors. */  #define FL_IGN_SCOPE     (1 << 0)       /* Ignore scope errors. */
 #define FL_NIGN_ESCAPE   (1 << 1)       /* Don't ignore bad escapes. */  #define FL_NIGN_ESCAPE   (1 << 1)       /* Don't ignore bad escapes. */
 #define FL_NIGN_MACRO    (1 << 2)       /* Don't ignore bad macros. */  #define FL_NIGN_MACRO    (1 << 2)       /* Don't ignore bad macros. */
 #define FL_NIGN_CHARS    (1 << 3)       /* Don't ignore bad chars. */  
 #define FL_IGN_ERRORS    (1 << 4)       /* Ignore failed parse. */  #define FL_IGN_ERRORS    (1 << 4)       /* Ignore failed parse. */
   #define FL_STRICT         FL_NIGN_ESCAPE | \
                             FL_NIGN_MACRO
         enum intt         inttype;      /* Input parsers... */          enum intt         inttype;      /* Input parsers... */
         struct man       *man;          struct man       *man;
         struct man       *lastman;  
         struct mdoc      *mdoc;          struct mdoc      *mdoc;
         struct mdoc      *lastmdoc;          struct roff      *roff;
         enum outt         outtype;      /* Output devices... */          enum outt         outtype;      /* Output devices... */
         out_mdoc          outmdoc;          out_mdoc          outmdoc;
         out_man           outman;          out_man           outman;
Line 90  struct curparse {
Line 94  struct curparse {
         char              outopts[BUFSIZ];          char              outopts[BUFSIZ];
 };  };
   
 #define FL_STRICT         FL_NIGN_ESCAPE | \  static  void              fdesc(struct curparse *);
                           FL_NIGN_MACRO | \  static  void              ffile(const char *, struct curparse *);
                           FL_NIGN_CHARS  
   
 static  int               foptions(int *, char *);  static  int               foptions(int *, char *);
 static  int               toptions(struct curparse *, char *);  static  struct man       *man_init(struct curparse *);
   static  struct mdoc      *mdoc_init(struct curparse *);
   static  struct roff      *roff_init(struct curparse *);
   static  int               merr(void *, int, int, const char *); /* DEPRECATED */
 static  int               moptions(enum intt *, char *);  static  int               moptions(enum intt *, char *);
 static  int               woptions(int *, char *);  static  int               mwarn(void *, int, int, const char *); /* DEPRECATED */
 static  int               merr(void *, int, int, const char *);  static  int               mmsg(enum mandocerr, void *,
 static  int               mwarn(void *, int, int, const char *);                                  int, int, const char *);
 static  int               ffile(struct buf *, struct buf *,  
                                 const char *, struct curparse *);  
 static  int               fdesc(struct buf *, struct buf *,  
                                 struct curparse *);  
 static  int               pset(const char *, int, struct curparse *,  static  int               pset(const char *, int, struct curparse *,
                                 struct man **, struct mdoc **);                                  struct man **, struct mdoc **);
 static  struct man       *man_init(struct curparse *);  static  int               toptions(struct curparse *, char *);
 static  struct mdoc      *mdoc_init(struct curparse *);  
 static  void              version(void) __attribute__((noreturn));  
 static  void              usage(void) __attribute__((noreturn));  static  void              usage(void) __attribute__((noreturn));
   static  void              version(void) __attribute__((noreturn));
   static  int               woptions(int *, char *);
   
 static  const char       *progname;  static  const char       *progname;
   static  int               with_error;
   static  int               with_warning;
   
   
 int  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         int              c, rc;          int              c;
         struct buf       ln, blk;  
         struct curparse  curp;          struct curparse  curp;
   
         progname = strrchr(argv[0], '/');          progname = strrchr(argv[0], '/');
Line 166  main(int argc, char *argv[])
Line 167  main(int argc, char *argv[])
         argc -= optind;          argc -= optind;
         argv += optind;          argv += optind;
   
         memset(&ln, 0, sizeof(struct buf));  
         memset(&blk, 0, sizeof(struct buf));  
   
         rc = 1;  
   
         if (NULL == *argv) {          if (NULL == *argv) {
                 curp.file = "<stdin>";                  curp.file = "<stdin>";
                 curp.fd = STDIN_FILENO;                  curp.fd = STDIN_FILENO;
   
                 c = fdesc(&blk, &ln, &curp);                  fdesc(&curp);
                 if ( ! (FL_IGN_ERRORS & curp.fflags))  
                         rc = 1 == c ? 1 : 0;  
                 else  
                         rc = -1 == c ? 0 : 1;  
         }          }
   
         while (rc && *argv) {          while (*argv) {
                 c = ffile(&blk, &ln, *argv, &curp);                  ffile(*argv, &curp);
                 if ( ! (FL_IGN_ERRORS & curp.fflags))  
                         rc = 1 == c ? 1 : 0;  
                 else  
                         rc = -1 == c ? 0 : 1;  
   
                 argv++;                  if (with_error && !(curp.fflags & FL_IGN_ERRORS))
                 if (*argv && rc) {                          break;
                         if (curp.lastman)                  ++argv;
                                 man_reset(curp.lastman);  
                         if (curp.lastmdoc)  
                                 mdoc_reset(curp.lastmdoc);  
                         curp.lastman = NULL;  
                         curp.lastmdoc = NULL;  
                 }  
         }          }
   
         if (blk.buf)  
                 free(blk.buf);  
         if (ln.buf)  
                 free(ln.buf);  
         if (curp.outfree)          if (curp.outfree)
                 (*curp.outfree)(curp.outdata);                  (*curp.outfree)(curp.outdata);
         if (curp.mdoc)          if (curp.mdoc)
                 mdoc_free(curp.mdoc);                  mdoc_free(curp.mdoc);
         if (curp.man)          if (curp.man)
                 man_free(curp.man);                  man_free(curp.man);
           if (curp.roff)
                   roff_free(curp.roff);
   
         return(rc ? EXIT_SUCCESS : EXIT_FAILURE);          return((with_warning || with_error) ?
                           EXIT_FAILURE :  EXIT_SUCCESS);
 }  }
   
   
Line 246  man_init(struct curparse *curp)
Line 227  man_init(struct curparse *curp)
   
         /* Defaults from mandoc.1. */          /* Defaults from mandoc.1. */
   
         pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE | MAN_IGN_CHARS;          pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE;
   
         if (curp->fflags & FL_NIGN_MACRO)          if (curp->fflags & FL_NIGN_MACRO)
                 pflags &= ~MAN_IGN_MACRO;                  pflags &= ~MAN_IGN_MACRO;
         if (curp->fflags & FL_NIGN_CHARS)  
                 pflags &= ~MAN_IGN_CHARS;  
         if (curp->fflags & FL_NIGN_ESCAPE)          if (curp->fflags & FL_NIGN_ESCAPE)
                 pflags &= ~MAN_IGN_ESCAPE;                  pflags &= ~MAN_IGN_ESCAPE;
   
Line 259  man_init(struct curparse *curp)
Line 238  man_init(struct curparse *curp)
 }  }
   
   
   static struct roff *
   roff_init(struct curparse *curp)
   {
   
           return(roff_alloc(mmsg, curp));
   }
   
   
 static struct mdoc *  static struct mdoc *
 mdoc_init(struct curparse *curp)  mdoc_init(struct curparse *curp)
 {  {
Line 270  mdoc_init(struct curparse *curp)
Line 257  mdoc_init(struct curparse *curp)
   
         /* Defaults from mandoc.1. */          /* Defaults from mandoc.1. */
   
         pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE | MDOC_IGN_CHARS;          pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE;
   
         if (curp->fflags & FL_IGN_SCOPE)          if (curp->fflags & FL_IGN_SCOPE)
                 pflags |= MDOC_IGN_SCOPE;                  pflags |= MDOC_IGN_SCOPE;
Line 278  mdoc_init(struct curparse *curp)
Line 265  mdoc_init(struct curparse *curp)
                 pflags &= ~MDOC_IGN_ESCAPE;                  pflags &= ~MDOC_IGN_ESCAPE;
         if (curp->fflags & FL_NIGN_MACRO)          if (curp->fflags & FL_NIGN_MACRO)
                 pflags &= ~MDOC_IGN_MACRO;                  pflags &= ~MDOC_IGN_MACRO;
         if (curp->fflags & FL_NIGN_CHARS)  
                 pflags &= ~MDOC_IGN_CHARS;  
   
         return(mdoc_alloc(curp, pflags, &mdoccb));          return(mdoc_alloc(curp, pflags, &mdoccb));
 }  }
   
   
 static int  static void
 ffile(struct buf *blk, struct buf *ln,  ffile(const char *file, struct curparse *curp)
                 const char *file, struct curparse *curp)  
 {  {
         int              c;  
   
         curp->file = file;          curp->file = file;
         if (-1 == (curp->fd = open(curp->file, O_RDONLY, 0))) {          if (-1 == (curp->fd = open(curp->file, O_RDONLY, 0))) {
                 perror(curp->file);                  perror(curp->file);
                 return(-1);                  with_error = 1;
                   return;
         }          }
   
         c = fdesc(blk, ln, curp);          fdesc(curp);
   
         if (-1 == close(curp->fd))          if (-1 == close(curp->fd))
                 perror(curp->file);                  perror(curp->file);
   }
   
         return(c);  
   static int
   resize_buf(struct buf *buf, size_t initial)
   {
           void *tmp;
           size_t sz;
   
           if (buf->sz == 0)
                   sz = initial;
           else
                   sz = 2 * buf->sz;
           tmp = realloc(buf->buf, sz);
           if (NULL == tmp) {
                   perror(NULL);
                   return(0);
           }
           buf->buf = tmp;
           buf->sz = sz;
           return(1);
 }  }
   
   
 static int  static int
 fdesc(struct buf *blk, struct buf *ln, struct curparse *curp)  read_whole_file(struct curparse *curp, struct buf *fb, int *with_mmap)
 {  {
         size_t           sz;  
         ssize_t          ssz;  
         struct stat      st;          struct stat      st;
         int              j, i, pos, lnn, comment;          size_t           off;
         struct man      *man;          ssize_t          ssz;
         struct mdoc     *mdoc;  
   
         sz = BUFSIZ;          if (-1 == fstat(curp->fd, &st)) {
         man = NULL;                  perror(curp->file);
         mdoc = NULL;                  with_error = 1;
                   return(0);
           }
   
         /*          /*
          * Two buffers: ln and buf.  buf is the input buffer optimised           * If we're a regular file, try just reading in the whole entry
          * here for each file's block size.  ln is a line buffer.  Both           * via mmap().  This is faster than reading it into blocks, and
          * growable, hence passed in by ptr-ptr.           * since each file is only a few bytes to begin with, I'm not
            * concerned that this is going to tank any machines.
          */           */
   
         if (-1 == fstat(curp->fd, &st))          if (S_ISREG(st.st_mode)) {
                 perror(curp->file);                  if (st.st_size >= (1U << 31)) {
         else if ((size_t)st.st_blksize > sz)                          fprintf(stderr, "%s: input too large\n",
                 sz = st.st_blksize;                                          curp->file);
                           with_error = 1;
         if (sz > blk->sz) {                          return(0);
                 blk->buf = realloc(blk->buf, sz);  
                 if (NULL == blk->buf) {  
                         perror(NULL);  
                         exit(EXIT_FAILURE);  
                 }                  }
                 blk->sz = sz;                  *with_mmap = 1;
                   fb->sz = (size_t)st.st_size;
                   fb->buf = mmap(NULL, fb->sz, PROT_READ,
                                   MAP_FILE, curp->fd, 0);
                   if (fb->buf != MAP_FAILED)
                           return(1);
         }          }
   
         /* Fill buf with file blocksize. */          /*
            * 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.
            */
   
         for (lnn = pos = comment = 0; ; ) {          *with_mmap = 0;
                 if (-1 == (ssz = read(curp->fd, blk->buf, sz))) {          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;
                           }
                           if (! resize_buf(fb, 65536))
                                   break;
                   }
                   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);                          perror(curp->file);
                         return(-1);  
                 } else if (0 == ssz)  
                         break;                          break;
                   }
                   off += (size_t)ssz;
           }
   
                 /* Parse the read block into partial or full lines. */          free(fb->buf);
           fb->buf = NULL;
           with_error = 1;
           return(0);
   }
   
                 for (i = 0; i < (int)ssz; i++) {  
                         if (pos >= (int)ln->sz) {  
                                 ln->sz += 256; /* Step-size. */  
                                 ln->buf = realloc(ln->buf, ln->sz);  
                                 if (NULL == ln->buf) {  
                                         perror(NULL);  
                                         return(EXIT_FAILURE);  
                                 }  
                         }  
   
                         if ('\n' != blk->buf[i]) {  static void
                                 if (comment)  fdesc(struct curparse *curp)
                                         continue;  {
                                 ln->buf[pos++] = blk->buf[i];          struct buf       ln, blk;
           int              i, pos, lnn, lnn_start, with_mmap, of;
           enum rofferr     re;
           struct man      *man;
           struct mdoc     *mdoc;
           struct roff     *roff;
   
                                 /* Handle in-line `\"' comments. */          man = NULL;
           mdoc = NULL;
           roff = NULL;
           memset(&ln, 0, sizeof(struct buf));
   
                                 if (1 == pos || '\"' != ln->buf[pos - 1])          /*
                                         continue;           * Two buffers: ln and buf.  buf is the input file and may be
            * memory mapped.  ln is a line buffer and grows on-demand.
            */
   
                                 for (j = pos - 2; j >= 0; j--)          if ( ! read_whole_file(curp, &blk, &with_mmap))
                                         if ('\\' != ln->buf[j])                  return;
                                                 break;  
   
                                 if ( ! ((pos - 2 - j) % 2))          if (NULL == curp->roff)
                                         continue;                  curp->roff = roff_init(curp);
           if (NULL == (roff = curp->roff))
                   goto bailout;
   
                                 comment = 1;          for (i = 0, lnn = 1; i < (int)blk.sz;) {
                                 pos -= 2;                  pos = 0;
                   lnn_start = lnn;
                   while (i < (int)blk.sz) {
                           if ('\n' == blk.buf[i]) {
                                   ++i;
                                   ++lnn;
                                   break;
                           }
                           /* Trailing backslash is like a plain character. */
                           if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {
                                   if (pos >= (int)ln.sz)
                                           if (! resize_buf(&ln, 256))
                                                   goto bailout;
                                   ln.buf[pos++] = blk.buf[i++];
                                   continue;
                           }
                           /* Found an escape and at least one other character. */
                           if ('\n' == blk.buf[i + 1]) {
                                   /* Escaped newlines are skipped over */
                                   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) {                                  for (; pos > 0; --pos) {
                                         if (ln->buf[pos] != ' ')                                          if (ln.buf[pos - 1] != ' ')
                                                 break;                                                  break;
                                         if (ln->buf[pos - 1] == '\\')                                          if (pos > 2 && ln.buf[pos - 2] == '\\')
                                                 break;                                                  break;
                                 }                                  }
                                 continue;                                  break;
                         }                          }
                           /* Some other escape sequence, copy and continue. */
                           if (pos + 1 >= (int)ln.sz)
                                   if (! resize_buf(&ln, 256))
                                           goto bailout;
   
                         /* Handle escaped `\\n' newlines. */                          ln.buf[pos++] = blk.buf[i++];
                           ln.buf[pos++] = blk.buf[i++];
                   }
   
                         if (pos > 0 && 0 == comment &&                  if (pos >= (int)ln.sz)
                                         '\\' == ln->buf[pos - 1]) {                          if (! resize_buf(&ln, 256))
                                 for (j = pos - 1; j >= 0; j--)                                  goto bailout;
                                         if ('\\' != ln->buf[j])                  ln.buf[pos] = '\0';
                                                 break;  
                                 if ( ! ((pos - j) % 2)) {  
                                         pos--;  
                                         lnn++;  
                                         continue;  
                                 }  
                         }  
   
                         ln->buf[pos] = 0;                  /*
                         lnn++;                   * 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.
                    */
   
                         /* If unset, assign parser in pset(). */                  of = 0;
                   do {
                           re = roff_parseln(roff, lnn_start,
                                           &ln.buf, &ln.sz, of, &of);
                   } while (ROFF_RERUN == re);
   
                         if ( ! (man || mdoc) && ! pset(ln->buf,                  if (ROFF_IGN == re)
                                                 pos, curp, &man, &mdoc))                          continue;
                                 return(-1);                  else if (ROFF_ERR == re)
                           goto bailout;
   
                         pos = comment = 0;                  /*
                    * 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.
                    */
   
                         /* Pass down into parsers. */                  if ( ! (man || mdoc))
                           if ( ! pset(ln.buf + of, pos - of, curp, &man, &mdoc))
                                   goto bailout;
   
                         if (man && ! man_parseln(man, lnn, ln->buf))                  /* Lastly, push down into the parsers themselves. */
                                 return(0);  
                         if (mdoc && ! mdoc_parseln(mdoc, lnn, ln->buf))                  if (man && ! man_parseln(man, lnn_start, ln.buf, of))
                                 return(0);                          goto bailout;
                 }                  if (mdoc && ! mdoc_parseln(mdoc, lnn_start, ln.buf, of))
                           goto bailout;
         }          }
   
         /* NOTE a parser may not have been assigned, yet. */          /* NOTE a parser may not have been assigned, yet. */
   
         if ( ! (man || mdoc)) {          if ( ! (man || mdoc)) {
                 fprintf(stderr, "%s: Not a manual\n", curp->file);                  fprintf(stderr, "%s: Not a manual\n", curp->file);
                 return(0);                  goto bailout;
         }          }
   
           /* Clean up the parse routine ASTs. */
   
         if (mdoc && ! mdoc_endparse(mdoc))          if (mdoc && ! mdoc_endparse(mdoc))
                 return(0);                  goto bailout;
         if (man && ! man_endparse(man))          if (man && ! man_endparse(man))
                 return(0);                  goto bailout;
           if (roff && ! roff_endparse(roff))
                   goto bailout;
   
         /* If unset, allocate output dev now (if applicable). */          /* If unset, allocate output dev now (if applicable). */
   
Line 458  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 545  fdesc(struct buf *blk, struct buf *ln, struct curparse
                 case (OUTT_LINT):                  case (OUTT_LINT):
                         break;                          break;
                 default:                  default:
                         curp->outdata = ascii_alloc();                          curp->outdata = ascii_alloc(80);
                         curp->outman = terminal_man;                          curp->outman = terminal_man;
                         curp->outmdoc = terminal_mdoc;                          curp->outmdoc = terminal_mdoc;
                         curp->outfree = terminal_free;                          curp->outfree = terminal_free;
Line 473  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 560  fdesc(struct buf *blk, struct buf *ln, struct curparse
         if (mdoc && curp->outmdoc)          if (mdoc && curp->outmdoc)
                 (*curp->outmdoc)(curp->outdata, mdoc);                  (*curp->outmdoc)(curp->outdata, mdoc);
   
         return(1);   cleanup:
           if (mdoc)
                   mdoc_reset(mdoc);
           if (man)
                   man_reset(man);
           if (roff)
                   roff_reset(roff);
           if (ln.buf)
                   free(ln.buf);
           if (with_mmap)
                   munmap(blk.buf, blk.sz);
           else
                   free(blk.buf);
   
           return;
   
    bailout:
           with_error = 1;
           goto cleanup;
 }  }
   
   
Line 491  pset(const char *buf, int pos, struct curparse *curp,
Line 596  pset(const char *buf, int pos, struct curparse *curp,
          * default to -man, which is more lenient.           * default to -man, which is more lenient.
          */           */
   
         if (buf[0] == '.') {          if ('.' == buf[0] || '\'' == buf[0]) {
                 for (i = 1; buf[i]; i++)                  for (i = 1; buf[i]; i++)
                         if (' ' != buf[i] && '\t' != buf[i])                          if (' ' != buf[i] && '\t' != buf[i])
                                 break;                                  break;
Line 505  pset(const char *buf, int pos, struct curparse *curp,
Line 610  pset(const char *buf, int pos, struct curparse *curp,
                         curp->mdoc = mdoc_init(curp);                          curp->mdoc = mdoc_init(curp);
                 if (NULL == (*mdoc = curp->mdoc))                  if (NULL == (*mdoc = curp->mdoc))
                         return(0);                          return(0);
                 curp->lastmdoc = *mdoc;  
                 return(1);                  return(1);
         case (INTT_MAN):          case (INTT_MAN):
                 if (NULL == curp->man)                  if (NULL == curp->man)
                         curp->man = man_init(curp);                          curp->man = man_init(curp);
                 if (NULL == (*man = curp->man))                  if (NULL == (*man = curp->man))
                         return(0);                          return(0);
                 curp->lastman = *man;  
                 return(1);                  return(1);
         default:          default:
                 break;                  break;
Line 523  pset(const char *buf, int pos, struct curparse *curp,
Line 626  pset(const char *buf, int pos, struct curparse *curp,
                         curp->mdoc = mdoc_init(curp);                          curp->mdoc = mdoc_init(curp);
                 if (NULL == (*mdoc = curp->mdoc))                  if (NULL == (*mdoc = curp->mdoc))
                         return(0);                          return(0);
                 curp->lastmdoc = *mdoc;  
                 return(1);                  return(1);
         }          }
   
Line 531  pset(const char *buf, int pos, struct curparse *curp,
Line 633  pset(const char *buf, int pos, struct curparse *curp,
                 curp->man = man_init(curp);                  curp->man = man_init(curp);
         if (NULL == (*man = curp->man))          if (NULL == (*man = curp->man))
                 return(0);                  return(0);
         curp->lastman = *man;  
         return(1);          return(1);
 }  }
   
Line 590  foptions(int *fflags, char *arg)
Line 691  foptions(int *fflags, char *arg)
         toks[0] = "ign-scope";          toks[0] = "ign-scope";
         toks[1] = "no-ign-escape";          toks[1] = "no-ign-escape";
         toks[2] = "no-ign-macro";          toks[2] = "no-ign-macro";
         toks[3] = "no-ign-chars";          toks[3] = "ign-errors";
         toks[4] = "ign-errors";          toks[4] = "strict";
         toks[5] = "strict";          toks[5] = "ign-escape";
         toks[6] = "ign-escape";          toks[6] = NULL;
         toks[7] = NULL;  
   
         while (*arg) {          while (*arg) {
                 o = arg;                  o = arg;
Line 609  foptions(int *fflags, char *arg)
Line 709  foptions(int *fflags, char *arg)
                         *fflags |= FL_NIGN_MACRO;                          *fflags |= FL_NIGN_MACRO;
                         break;                          break;
                 case (3):                  case (3):
                         *fflags |= FL_NIGN_CHARS;  
                         break;  
                 case (4):  
                         *fflags |= FL_IGN_ERRORS;                          *fflags |= FL_IGN_ERRORS;
                         break;                          break;
                 case (5):                  case (4):
                         *fflags |= FL_STRICT;                          *fflags |= FL_STRICT;
                         break;                          break;
                 case (6):                  case (5):
                         *fflags &= ~FL_NIGN_ESCAPE;                          *fflags &= ~FL_NIGN_ESCAPE;
                         break;                          break;
                 default:                  default:
Line 670  merr(void *arg, int line, int col, const char *msg)
Line 767  merr(void *arg, int line, int col, const char *msg)
         (void)fprintf(stderr, "%s:%d:%d: error: %s\n",          (void)fprintf(stderr, "%s:%d:%d: error: %s\n",
                         curp->file, line, col + 1, msg);                          curp->file, line, col + 1, msg);
   
           with_error = 1;
   
         return(0);          return(0);
 }  }
   
Line 687  mwarn(void *arg, int line, int col, const char *msg)
Line 786  mwarn(void *arg, int line, int col, const char *msg)
         (void)fprintf(stderr, "%s:%d:%d: warning: %s\n",          (void)fprintf(stderr, "%s:%d:%d: warning: %s\n",
                         curp->file, line, col + 1, msg);                          curp->file, line, col + 1, msg);
   
         if ( ! (curp->wflags & WARN_WERR))          with_warning = 1;
                 return(1);          if (curp->wflags & WARN_WERR) {
                   with_error = 1;
         return(0);                  return(0);
           }
   
           return(1);
 }  }
   
   static  const char * const      mandocerrs[MANDOCERR_MAX] = {
           "ok",
           "multi-line scope open on exit",
           "request for scope closure when no matching scope is open",
           "line arguments will be lost",
           "memory exhausted"
   };
   
   /*
    * XXX: this is experimental code that will eventually become the
    * generic means of covering all warnings and errors!
    */
   /* ARGSUSED */
   static int
   mmsg(enum mandocerr t, void *arg, int ln, int col, const char *msg)
   {
   #if 0
           struct curparse *cp;
   
           cp = (struct curparse *)arg;
   
           fprintf(stderr, "%s:%d:%d: %s", cp->file,
                           ln, col + 1, mandocerrs[t]);
   
           if (msg)
                   fprintf(stderr, ": %s", msg);
   
           fputc('\n', stderr);
   #endif
           return(1);
   }

Legend:
Removed from v.1.61  
changed lines
  Added in v.1.76

CVSweb