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

Diff for /mandoc/main.c between version 1.59 and 1.65

version 1.59, 2010/01/29 14:39:38 version 1.65, 2010/05/15 04:46:10
Line 72  struct curparse {
Line 72  struct curparse {
 #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 IGN_SCOPE        (1 << 0)       /* Ignore scope errors. */  #define FL_IGN_SCOPE     (1 << 0)       /* Ignore scope errors. */
 #define NO_IGN_ESCAPE    (1 << 1)       /* Don't ignore bad escapes. */  #define FL_NIGN_ESCAPE   (1 << 1)       /* Don't ignore bad escapes. */
 #define NO_IGN_MACRO     (1 << 2)       /* Don't ignore bad macros. */  #define FL_NIGN_MACRO    (1 << 2)       /* Don't ignore bad macros. */
 #define NO_IGN_CHARS     (1 << 3)       /* Don't ignore bad chars. */  #define FL_IGN_ERRORS    (1 << 4)       /* Ignore failed parse. */
 #define IGN_ERRORS       (1 << 4)       /* Ignore failed parse. */  
         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;  
         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 87  struct curparse {
         char              outopts[BUFSIZ];          char              outopts[BUFSIZ];
 };  };
   
   #define FL_STRICT         FL_NIGN_ESCAPE | \
                             FL_NIGN_MACRO
   
 static  int               foptions(int *, char *);  static  int               foptions(int *, char *);
 static  int               toptions(enum outt *, char *);  static  int               toptions(struct curparse *, char *);
 static  int               moptions(enum intt *, char *);  static  int               moptions(enum intt *, char *);
 static  int               woptions(int *, char *);  static  int               woptions(int *, char *);
 static  int               merr(void *, int, int, const char *);  static  int               merr(void *, int, int, const char *);
 static  int               mwarn(void *, int, int, const char *);  static  int               mwarn(void *, int, int, const char *);
 static  int               ffile(struct buf *, struct buf *,  static  void              ffile(struct buf *, struct buf *,
                                 const char *, struct curparse *);                                  const char *, struct curparse *);
 static  int               fdesc(struct buf *, struct buf *,  static  void              fdesc(struct buf *, struct buf *,
                                 struct curparse *);                                  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 **);
Line 108  static void    version(void) __attribute__((noreturn))
Line 108  static void    version(void) __attribute__((noreturn))
 static  void              usage(void) __attribute__((noreturn));  static  void              usage(void) __attribute__((noreturn));
   
 static  const char       *progname;  static  const char       *progname;
   static  int               with_error, with_warning;
   
   
 int  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         int              c, rc;          int              c;
         struct buf       ln, blk;          struct buf       ln, blk;
         struct curparse  curp;          struct curparse  curp;
   
Line 144  main(int argc, char *argv[])
Line 144  main(int argc, char *argv[])
                         (void)strlcat(curp.outopts, ",", BUFSIZ);                          (void)strlcat(curp.outopts, ",", BUFSIZ);
                         break;                          break;
                 case ('T'):                  case ('T'):
                         if ( ! toptions(&curp.outtype, optarg))                          if ( ! toptions(&curp, optarg))
                                 return(EXIT_FAILURE);                                  return(EXIT_FAILURE);
                         break;                          break;
                 case ('W'):                  case ('W'):
Line 165  main(int argc, char *argv[])
Line 165  main(int argc, char *argv[])
         memset(&ln, 0, sizeof(struct buf));          memset(&ln, 0, sizeof(struct buf));
         memset(&blk, 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(&blk, &ln, &curp);
                 if ( ! (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(&blk, &ln, *argv, &curp);
                 if ( ! (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)          if (blk.buf)
Line 202  main(int argc, char *argv[])
Line 186  main(int argc, char *argv[])
                 free(ln.buf);                  free(ln.buf);
         if (curp.outfree)          if (curp.outfree)
                 (*curp.outfree)(curp.outdata);                  (*curp.outfree)(curp.outdata);
         if (curp.mdoc)  
                 mdoc_free(curp.mdoc);  
         if (curp.man)  
                 man_free(curp.man);  
   
         return(rc ? EXIT_SUCCESS : EXIT_FAILURE);          return((with_warning || with_error) ? EXIT_FAILURE :  EXIT_SUCCESS );
 }  }
   
   
Line 224  static void
Line 204  static void
 usage(void)  usage(void)
 {  {
   
         (void)fprintf(stderr, "usage: %s [-V] [-foption...] "          (void)fprintf(stderr, "usage: %s [-V] [-foption] "
                         "[-mformat] [-Ooption] [-Toutput] "                          "[-mformat] [-Ooption] [-Toutput] "
                         "[-Werr...]\n", progname);                          "[-Werr] [file...]\n", progname);
         exit(EXIT_FAILURE);          exit(EXIT_FAILURE);
 }  }
   
Line 242  man_init(struct curparse *curp)
Line 222  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 & NO_IGN_MACRO)          if (curp->fflags & FL_NIGN_MACRO)
                 pflags &= ~MAN_IGN_MACRO;                  pflags &= ~MAN_IGN_MACRO;
         if (curp->fflags & NO_IGN_CHARS)          if (curp->fflags & FL_NIGN_ESCAPE)
                 pflags &= ~MAN_IGN_CHARS;  
         if (curp->fflags & NO_IGN_ESCAPE)  
                 pflags &= ~MAN_IGN_ESCAPE;                  pflags &= ~MAN_IGN_ESCAPE;
   
         return(man_alloc(curp, pflags, &mancb));          return(man_alloc(curp, pflags, &mancb));
Line 266  mdoc_init(struct curparse *curp)
Line 244  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 & IGN_SCOPE)          if (curp->fflags & FL_IGN_SCOPE)
                 pflags |= MDOC_IGN_SCOPE;                  pflags |= MDOC_IGN_SCOPE;
         if (curp->fflags & NO_IGN_ESCAPE)          if (curp->fflags & FL_NIGN_ESCAPE)
                 pflags &= ~MDOC_IGN_ESCAPE;                  pflags &= ~MDOC_IGN_ESCAPE;
         if (curp->fflags & NO_IGN_MACRO)          if (curp->fflags & FL_NIGN_MACRO)
                 pflags &= ~MDOC_IGN_MACRO;                  pflags &= ~MDOC_IGN_MACRO;
         if (curp->fflags & NO_IGN_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(struct buf *blk, struct buf *ln,
                 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(blk, ln, curp);
   
         if (-1 == close(curp->fd))          if (-1 == close(curp->fd))
                 perror(curp->file);                  perror(curp->file);
   
         return(c);  
 }  }
   
   
 static int  static void
 fdesc(struct buf *blk, struct buf *ln, struct curparse *curp)  fdesc(struct buf *blk, struct buf *ln, struct curparse *curp)
 {  {
         size_t           sz;          size_t           sz;
Line 322  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 296  fdesc(struct buf *blk, struct buf *ln, struct curparse
          * growable, hence passed in by ptr-ptr.           * growable, hence passed in by ptr-ptr.
          */           */
   
         if (-1 == fstat(curp->fd, &st))          if (-1 == fstat(curp->fd, &st)) {
                 perror(curp->file);                  perror(curp->file);
         else if ((size_t)st.st_blksize > sz)                  with_error = 1;
                   return;
           }
           if ((size_t)st.st_blksize > sz)
                 sz = st.st_blksize;                  sz = st.st_blksize;
   
         if (sz > blk->sz) {          if (sz > blk->sz) {
                 blk->buf = realloc(blk->buf, sz);                  void *buf = realloc(blk->buf, sz);
                 if (NULL == blk->buf) {  
                   if (NULL == buf) {
                         perror(NULL);                          perror(NULL);
                         exit(EXIT_FAILURE);                          with_error = 1;
                           return;
                 }                  }
                   blk->buf = buf;
                 blk->sz = sz;                  blk->sz = sz;
         }          }
   
Line 341  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 321  fdesc(struct buf *blk, struct buf *ln, struct curparse
         for (lnn = pos = comment = 0; ; ) {          for (lnn = pos = comment = 0; ; ) {
                 if (-1 == (ssz = read(curp->fd, blk->buf, sz))) {                  if (-1 == (ssz = read(curp->fd, blk->buf, sz))) {
                         perror(curp->file);                          perror(curp->file);
                         return(-1);                          goto bailout;
                 } else if (0 == ssz)                  } else if (0 == ssz)
                         break;                          break;
   
Line 353  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 333  fdesc(struct buf *blk, struct buf *ln, struct curparse
                                 ln->buf = realloc(ln->buf, ln->sz);                                  ln->buf = realloc(ln->buf, ln->sz);
                                 if (NULL == ln->buf) {                                  if (NULL == ln->buf) {
                                         perror(NULL);                                          perror(NULL);
                                         return(EXIT_FAILURE);                                          goto bailout;
                                 }                                  }
                         }                          }
   
Line 376  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 356  fdesc(struct buf *blk, struct buf *ln, struct curparse
   
                                 comment = 1;                                  comment = 1;
                                 pos -= 2;                                  pos -= 2;
                                   for (; pos > 0; --pos) {
                                           if (ln->buf[pos - 1] != ' ')
                                                   break;
                                           if (pos > 2 && ln->buf[pos - 2] == '\\')
                                                   break;
                                   }
                                 continue;                                  continue;
                         }                          }
   
Line 400  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 386  fdesc(struct buf *blk, struct buf *ln, struct curparse
   
                         if ( ! (man || mdoc) && ! pset(ln->buf,                          if ( ! (man || mdoc) && ! pset(ln->buf,
                                                 pos, curp, &man, &mdoc))                                                  pos, curp, &man, &mdoc))
                                 return(-1);                                  goto bailout;
   
                         pos = comment = 0;                          pos = comment = 0;
   
                         /* Pass down into parsers. */                          /* Pass down into parsers. */
   
                         if (man && ! man_parseln(man, lnn, ln->buf))                          if (man && ! man_parseln(man, lnn, ln->buf))
                                 return(0);                                  goto bailout;
                         if (mdoc && ! mdoc_parseln(mdoc, lnn, ln->buf))                          if (mdoc && ! mdoc_parseln(mdoc, lnn, ln->buf))
                                 return(0);                                  goto bailout;
                 }                  }
         }          }
   
Line 417  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 403  fdesc(struct buf *blk, struct buf *ln, struct curparse
   
         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;
         }          }
   
         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 unset, allocate output dev now (if applicable). */          /* If unset, allocate output dev now (if applicable). */
   
Line 463  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 449  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 (curp->mdoc) {
                   mdoc_free(curp->mdoc);
                   curp->mdoc = NULL;
           }
           if (curp->man) {
                   man_free(curp->man);
                   curp->man = NULL;
           }
           return;
   
    bailout:
           with_error = 1;
           goto cleanup;
 }  }
   
   
Line 495  pset(const char *buf, int pos, struct curparse *curp,
Line 494  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 513  pset(const char *buf, int pos, struct curparse *curp,
Line 510  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 521  pset(const char *buf, int pos, struct curparse *curp,
Line 517  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 546  moptions(enum intt *tflags, char *arg)
Line 541  moptions(enum intt *tflags, char *arg)
   
   
 static int  static int
 toptions(enum outt *tflags, char *arg)  toptions(struct curparse *curp, char *arg)
 {  {
   
         if (0 == strcmp(arg, "ascii"))          if (0 == strcmp(arg, "ascii"))
                 *tflags = OUTT_ASCII;                  curp->outtype = OUTT_ASCII;
         else if (0 == strcmp(arg, "lint"))          else if (0 == strcmp(arg, "lint")) {
                 *tflags = OUTT_LINT;                  curp->outtype = OUTT_LINT;
                   curp->wflags |= WARN_WALL;
                   curp->fflags |= FL_STRICT;
           }
         else if (0 == strcmp(arg, "tree"))          else if (0 == strcmp(arg, "tree"))
                 *tflags = OUTT_TREE;                  curp->outtype = OUTT_TREE;
         else if (0 == strcmp(arg, "html"))          else if (0 == strcmp(arg, "html"))
                 *tflags = OUTT_HTML;                  curp->outtype = OUTT_HTML;
         else if (0 == strcmp(arg, "xhtml"))          else if (0 == strcmp(arg, "xhtml"))
                 *tflags = OUTT_XHTML;                  curp->outtype = OUTT_XHTML;
         else {          else {
                 fprintf(stderr, "%s: Bad argument\n", arg);                  fprintf(stderr, "%s: Bad argument\n", arg);
                 return(0);                  return(0);
Line 577  foptions(int *fflags, char *arg)
Line 575  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;
                 switch (getsubopt(&arg, UNCONST(toks), &v)) {                  switch (getsubopt(&arg, UNCONST(toks), &v)) {
                 case (0):                  case (0):
                         *fflags |= IGN_SCOPE;                          *fflags |= FL_IGN_SCOPE;
                         break;                          break;
                 case (1):                  case (1):
                         *fflags |= NO_IGN_ESCAPE;                          *fflags |= FL_NIGN_ESCAPE;
                         break;                          break;
                 case (2):                  case (2):
                         *fflags |= NO_IGN_MACRO;                          *fflags |= FL_NIGN_MACRO;
                         break;                          break;
                 case (3):                  case (3):
                         *fflags |= NO_IGN_CHARS;                          *fflags |= FL_IGN_ERRORS;
                         break;                          break;
                 case (4):                  case (4):
                         *fflags |= IGN_ERRORS;                          *fflags |= FL_STRICT;
                         break;                          break;
                 case (5):                  case (5):
                         *fflags |= NO_IGN_ESCAPE |                          *fflags &= ~FL_NIGN_ESCAPE;
                                    NO_IGN_MACRO | NO_IGN_CHARS;  
                         break;                          break;
                 case (6):  
                         *fflags &= ~NO_IGN_ESCAPE;  
                         break;  
                 default:                  default:
                         fprintf(stderr, "%s: Bad argument\n", o);                          fprintf(stderr, "%s: Bad argument\n", o);
                         return(0);                          return(0);
Line 658  merr(void *arg, int line, int col, const char *msg)
Line 651  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 675  mwarn(void *arg, int line, int col, const char *msg)
Line 670  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);
 }  }
   
Legend:
Removed from v.1.59  
changed lines
  Added in v.1.65
CVSweb