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

Diff for /mandoc/main.c between version 1.29 and 1.39

version 1.29, 2009/06/16 19:13:28 version 1.39, 2009/07/24 14:00:59
Line 65  struct curparse {
Line 65  struct curparse {
         const char       *file;         /* Current parse. */          const char       *file;         /* Current parse. */
         int               fd;           /* Current parse. */          int               fd;           /* Current parse. */
         int               wflags;          int               wflags;
 #define WARN_WALL         0x03          /* All-warnings mask. */  #define WARN_WALL        (1 << 0)       /* All-warnings mask. */
 #define WARN_WCOMPAT     (1 << 0)       /* Compatibility warnings. */  
 #define WARN_WSYNTAX     (1 << 1)       /* Syntax warnings. */  
 #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 IGN_SCOPE        (1 << 0)       /* Ignore scope errors. */
 #define NO_IGN_ESCAPE    (1 << 1)       /* Don't ignore bad escapes. */  #define NO_IGN_ESCAPE    (1 << 1)       /* Don't ignore bad escapes. */
 #define NO_IGN_MACRO     (1 << 2)       /* Don't ignore bad macros. */  #define NO_IGN_MACRO     (1 << 2)       /* Don't ignore bad macros. */
 #define NO_IGN_CHARS     (1 << 3)       /* Don't ignore bad chars. */  #define NO_IGN_CHARS     (1 << 3)       /* Don't ignore bad chars. */
   #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 man       *lastman;
Line 98  static int    toptions(enum outt *, char *);
Line 97  static int    toptions(enum outt *, 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               manwarn(void *, int, int, const char *);  static  int               mwarn(void *, int, int, const char *);
 static  int               mdocwarn(void *, int, int,  
                                 enum mdoc_warn, const char *);  
 static  int               fstdin(struct buf *, struct buf *,  
                                 struct curparse *);  
 static  int               ffile(struct buf *, struct buf *,  static  int               ffile(struct buf *, struct buf *,
                                 const char *, struct curparse *);                                  const char *, struct curparse *);
 static  int               fdesc(struct buf *, struct buf *,  static  int               fdesc(struct buf *, struct buf *,
Line 134  main(int argc, char *argv[])
Line 129  main(int argc, char *argv[])
                 switch (c) {                  switch (c) {
                 case ('f'):                  case ('f'):
                         if ( ! foptions(&curp.fflags, optarg))                          if ( ! foptions(&curp.fflags, optarg))
                                 return(0);                                  return(EXIT_FAILURE);
                         break;                          break;
                 case ('m'):                  case ('m'):
                         if ( ! moptions(&curp.inttype, optarg))                          if ( ! moptions(&curp.inttype, optarg))
                                 return(0);                                  return(EXIT_FAILURE);
                         break;                          break;
                 case ('T'):                  case ('T'):
                         if ( ! toptions(&curp.outtype, optarg))                          if ( ! toptions(&curp.outtype, optarg))
                                 return(0);                                  return(EXIT_FAILURE);
                         break;                          break;
                 case ('W'):                  case ('W'):
                         if ( ! woptions(&curp.wflags, optarg))                          if ( ! woptions(&curp.wflags, optarg))
                                 return(0);                                  return(EXIT_FAILURE);
                         break;                          break;
                 case ('V'):                  case ('V'):
                         version();                          version();
Line 159  main(int argc, char *argv[])
Line 154  main(int argc, char *argv[])
         argc -= optind;          argc -= optind;
         argv += optind;          argv += optind;
   
         /* Configure buffers. */  
   
         bzero(&ln, sizeof(struct buf));          bzero(&ln, sizeof(struct buf));
         bzero(&blk, sizeof(struct buf));          bzero(&blk, sizeof(struct buf));
   
         rc = 1;          rc = 1;
   
         if (NULL == *argv)          if (NULL == *argv) {
                 if ( ! fstdin(&blk, &ln, &curp))                  curp.file = "<stdin>";
                         rc = 0;                  curp.fd = STDIN_FILENO;
   
                   c = fdesc(&blk, &ln, &curp);
                   if ( ! (IGN_ERRORS & curp.fflags))
                           rc = 1 == c ? 1 : 0;
                   else
                           rc = -1 == c ? 0 : 1;
           }
   
         while (rc && *argv) {          while (rc && *argv) {
                 if ( ! ffile(&blk, &ln, *argv, &curp))                  c = ffile(&blk, &ln, *argv, &curp);
                         rc = 0;                  if ( ! (IGN_ERRORS & curp.fflags))
                           rc = 1 == c ? 1 : 0;
                   else
                           rc = -1 == c ? 0 : 1;
   
                 argv++;                  argv++;
                 if (*argv && rc) {                  if (*argv && rc) {
                         if (curp.lastman)                          if (curp.lastman)
Line 190  main(int argc, char *argv[])
Line 194  main(int argc, char *argv[])
                 free(blk.buf);                  free(blk.buf);
         if (ln.buf)          if (ln.buf)
                 free(ln.buf);                  free(ln.buf);
   
         /* TODO: have a curp_free routine. */  
         if (curp.outfree)          if (curp.outfree)
                 (*curp.outfree)(curp.outdata);                  (*curp.outfree)(curp.outdata);
         if (curp.mdoc)          if (curp.mdoc)
Line 231  man_init(struct curparse *curp)
Line 233  man_init(struct curparse *curp)
         struct man_cb    mancb;          struct man_cb    mancb;
   
         mancb.man_err = merr;          mancb.man_err = merr;
         mancb.man_warn = manwarn;          mancb.man_warn = mwarn;
   
         /*          /* Defaults from mandoc.1. */
          * Default behaviour is to ignore unknown macros.  This is  
          * specified in mandoc.1.  
          */  
   
         pflags = MAN_IGN_MACRO;          pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE | MAN_IGN_CHARS;
   
         /* Override default behaviour... */  
   
         if (curp->fflags & NO_IGN_MACRO)          if (curp->fflags & NO_IGN_MACRO)
                 pflags &= ~MAN_IGN_MACRO;                  pflags &= ~MAN_IGN_MACRO;
           if (curp->fflags & NO_IGN_CHARS)
                   pflags &= ~MAN_IGN_CHARS;
           if (curp->fflags & NO_IGN_ESCAPE)
                   pflags &= ~MAN_IGN_ESCAPE;
   
         if (NULL == (man = man_alloc(curp, pflags, &mancb)))          if (NULL == (man = man_alloc(curp, pflags, &mancb)))
                 warnx("memory exhausted");                  warnx("memory exhausted");
Line 260  mdoc_init(struct curparse *curp)
Line 261  mdoc_init(struct curparse *curp)
         struct mdoc_cb   mdoccb;          struct mdoc_cb   mdoccb;
   
         mdoccb.mdoc_err = merr;          mdoccb.mdoc_err = merr;
         mdoccb.mdoc_warn = mdocwarn;          mdoccb.mdoc_warn = mwarn;
   
         /*          /* Defaults from mandoc.1. */
          * Default behaviour is to ignore unknown macros, escape  
          * sequences and characters (very liberal).  This is specified  
          * in mandoc.1.  
          */  
   
         pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE | MDOC_IGN_CHARS;          pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE | MDOC_IGN_CHARS;
   
         /* Override default behaviour... */  
   
         if (curp->fflags & IGN_SCOPE)          if (curp->fflags & IGN_SCOPE)
                 pflags |= MDOC_IGN_SCOPE;                  pflags |= MDOC_IGN_SCOPE;
         if (curp->fflags & NO_IGN_ESCAPE)          if (curp->fflags & NO_IGN_ESCAPE)
Line 289  mdoc_init(struct curparse *curp)
Line 284  mdoc_init(struct curparse *curp)
   
   
 static int  static int
 fstdin(struct buf *blk, struct buf *ln, struct curparse *curp)  
 {  
   
         curp->file = "<stdin>";  
         curp->fd = STDIN_FILENO;  
         return(fdesc(blk, ln, curp));  
 }  
   
   
 static int  
 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)
 {  {
Line 307  ffile(struct buf *blk, struct buf *ln, 
Line 292  ffile(struct buf *blk, struct buf *ln, 
         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))) {
                 warn("%s", curp->file);                  warn("%s", curp->file);
                 return(0);                  return(-1);
         }          }
   
         c = fdesc(blk, ln, curp);          c = fdesc(blk, ln, curp);
Line 340  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 325  fdesc(struct buf *blk, struct buf *ln, struct curparse
          */           */
   
         if (-1 == fstat(curp->fd, &st))          if (-1 == fstat(curp->fd, &st))
                 warnx("%s", curp->file);                  warn("%s", curp->file);
         else if ((size_t)st.st_blksize > sz)          else if ((size_t)st.st_blksize > sz)
                 sz = st.st_blksize;                  sz = st.st_blksize;
   
Line 348  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 333  fdesc(struct buf *blk, struct buf *ln, struct curparse
                 blk->buf = realloc(blk->buf, sz);                  blk->buf = realloc(blk->buf, sz);
                 if (NULL == blk->buf) {                  if (NULL == blk->buf) {
                         warn("realloc");                          warn("realloc");
                         return(0);                          return(-1);
                 }                  }
                 blk->sz = sz;                  blk->sz = sz;
         }          }
Line 358  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 343  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))) {
                         warn("%s", curp->file);                          warn("%s", curp->file);
                         return(0);                          return(-1);
                 } else if (0 == ssz)                  } else if (0 == ssz)
                         break;                          break;
   
Line 370  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 355  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) {
                                         warn("realloc");                                          warn("realloc");
                                         return(0);                                          return(-1);
                                 }                                  }
                         }                          }
   
Line 417  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 402  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(0);                                  return(-1);
   
                         pos = comment = 0;                          pos = comment = 0;
   
                           /* Pass down into parsers. */
   
                         if (man && ! man_parseln(man, lnn, ln->buf))                          if (man && ! man_parseln(man, lnn, ln->buf))
                                 return(0);                                  return(0);
                         if (mdoc && ! mdoc_parseln(mdoc, lnn, ln->buf))                          if (mdoc && ! mdoc_parseln(mdoc, lnn, ln->buf))
Line 463  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 450  fdesc(struct buf *blk, struct buf *ln, struct curparse
   
         if (man && curp->outman)          if (man && curp->outman)
                 if ( ! (*curp->outman)(curp->outdata, man))                  if ( ! (*curp->outman)(curp->outdata, man))
                         return(0);                          return(-1);
         if (mdoc && curp->outmdoc)          if (mdoc && curp->outmdoc)
                 if ( ! (*curp->outmdoc)(curp->outdata, mdoc))                  if ( ! (*curp->outmdoc)(curp->outdata, mdoc))
                         return(0);                          return(-1);
   
         return(1);          return(1);
 }  }
Line 482  pset(const char *buf, int pos, struct curparse *curp,
Line 469  pset(const char *buf, int pos, struct curparse *curp,
          * Try to intuit which kind of manual parser should be used.  If           * Try to intuit which kind of manual parser should be used.  If
          * passed in by command-line (-man, -mdoc), then use that           * passed in by command-line (-man, -mdoc), then use that
          * explicitly.  If passed as -mandoc, then try to guess from the           * explicitly.  If passed as -mandoc, then try to guess from the
          * line: either skip comments, use -mdoc when finding `.Dt', or           * line: either skip dot-lines, use -mdoc when finding `.Dt', or
          * default to -man, which is more lenient.           * default to -man, which is more lenient.
          */           */
   
Line 569  toptions(enum outt *tflags, char *arg)
Line 556  toptions(enum outt *tflags, char *arg)
 }  }
   
   
 /*  
  * Parse out the options for [-fopt...] setting compiler options.  These  
  * can be comma-delimited or called again.  
  */  
 static int  static int
 foptions(int *fflags, char *arg)  foptions(int *fflags, char *arg)
 {  {
         char            *v;          char            *v, *o;
         char            *toks[6];          char            *toks[7];
   
         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] = "no-ign-chars";
         toks[4] = "strict";          toks[4] = "ign-errors";
         toks[5] = NULL;          toks[5] = "strict";
           toks[6] = NULL;
   
         while (*arg)          while (*arg) {
                   o = arg;
                 switch (getsubopt(&arg, toks, &v)) {                  switch (getsubopt(&arg, toks, &v)) {
                 case (0):                  case (0):
                         *fflags |= IGN_SCOPE;                          *fflags |= IGN_SCOPE;
Line 601  foptions(int *fflags, char *arg)
Line 586  foptions(int *fflags, char *arg)
                         *fflags |= NO_IGN_CHARS;                          *fflags |= NO_IGN_CHARS;
                         break;                          break;
                 case (4):                  case (4):
                           *fflags |= IGN_ERRORS;
                           break;
                   case (5):
                         *fflags |= NO_IGN_ESCAPE |                          *fflags |= NO_IGN_ESCAPE |
                                    NO_IGN_MACRO | NO_IGN_CHARS;                                     NO_IGN_MACRO | NO_IGN_CHARS;
                         break;                          break;
                 default:                  default:
                         warnx("bad argument: -f%s", arg);                          warnx("bad argument: -f%s", o);
                         return(0);                          return(0);
                 }                  }
           }
   
         return(1);          return(1);
 }  }
   
   
 /*  
  * Parse out the options for [-Werr...], which sets warning modes.  
  * These can be comma-delimited or called again.  
  */  
 static int  static int
 woptions(int *wflags, char *arg)  woptions(int *wflags, char *arg)
 {  {
         char            *v;          char            *v, *o;
         char            *toks[5];          char            *toks[3];
   
         toks[0] = "all";          toks[0] = "all";
         toks[1] = "compat";          toks[1] = "error";
         toks[2] = "syntax";          toks[2] = NULL;
         toks[3] = "error";  
         toks[4] = NULL;  
   
         while (*arg)          while (*arg) {
                   o = arg;
                 switch (getsubopt(&arg, toks, &v)) {                  switch (getsubopt(&arg, toks, &v)) {
                 case (0):                  case (0):
                         *wflags |= WARN_WALL;                          *wflags |= WARN_WALL;
                         break;                          break;
                 case (1):                  case (1):
                         *wflags |= WARN_WCOMPAT;  
                         break;  
                 case (2):  
                         *wflags |= WARN_WSYNTAX;  
                         break;  
                 case (3):  
                         *wflags |= WARN_WERR;                          *wflags |= WARN_WERR;
                         break;                          break;
                 default:                  default:
                         warnx("bad argument: -W%s", arg);                          warnx("bad argument: -W%s", o);
                         return(0);                          return(0);
                 }                  }
           }
   
         return(1);          return(1);
 }  }
Line 659  merr(void *arg, int line, int col, const char *msg)
Line 638  merr(void *arg, int line, int col, const char *msg)
         struct curparse *curp;          struct curparse *curp;
   
         curp = (struct curparse *)arg;          curp = (struct curparse *)arg;
   
         warnx("%s:%d: error: %s (column %d)",          warnx("%s:%d: error: %s (column %d)",
                         curp->file, line, msg, col);                          curp->file, line, msg, col);
   
         /* Always exit on errors... */  
         return(0);          return(0);
 }  }
   
   
 static int  static int
 mdocwarn(void *arg, int line, int col,  mwarn(void *arg, int line, int col, const char *msg)
                 enum mdoc_warn type, const char *msg)  
 {  {
         struct curparse *curp;          struct curparse *curp;
         char            *wtype;  
   
         curp = (struct curparse *)arg;          curp = (struct curparse *)arg;
         wtype = NULL;  
   
         switch (type) {          if ( ! (curp->wflags & WARN_WALL))
         case (WARN_COMPAT):  
                 wtype = "compat";  
                 if (curp->wflags & WARN_WCOMPAT)  
                         break;  
                 return(1);                  return(1);
         case (WARN_SYNTAX):  
                 wtype = "syntax";  
                 if (curp->wflags & WARN_WSYNTAX)  
                         break;  
                 return(1);  
         }  
   
         assert(wtype);          warnx("%s:%d: warning: %s (column %d)",
         warnx("%s:%d: %s warning: %s (column %d)",                          curp->file, line, msg, col);
                         curp->file, line, wtype, msg, col);  
   
         if ( ! (curp->wflags & WARN_WERR))          if ( ! (curp->wflags & WARN_WERR))
                 return(1);                  return(1);
   
         /*          warnx("considering warnings as errors");
          * If the -Werror flag is passed in, as in gcc, then all  
          * warnings are considered as errors.  
          */  
   
         warnx("%s: considering warnings as errors",  
                         __progname);  
         return(0);          return(0);
 }  }
   
   
 static int  
 manwarn(void *arg, int line, int col, const char *msg)  
 {  
         struct curparse *curp;  
   
         curp = (struct curparse *)arg;  
   
         if ( ! (curp->wflags & WARN_WSYNTAX))  
                 return(1);  
   
         warnx("%s:%d: syntax warning: %s (column %d)",  
                         curp->file, line, msg, col);  
   
         if ( ! (curp->wflags & WARN_WERR))  
                 return(1);  
   
         /*  
          * If the -Werror flag is passed in, as in gcc, then all  
          * warnings are considered as errors.  
          */  
   
         warnx("%s: considering warnings as errors",  
                         __progname);  
         return(0);  
 }  
Legend:
Removed from v.1.29  
changed lines
  Added in v.1.39
CVSweb