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

Diff for /mandoc/main.c between version 1.17 and 1.156

version 1.17, 2009/03/26 16:23:22 version 1.156, 2011/03/20 16:05:21
Line 1 
Line 1 
 /* $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org>   * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
    * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the   * purpose with or without fee is hereby granted, provided that the above
  * above copyright notice and this permission notice appear in all   * copyright notice and this permission notice appear in all copies.
  * copies.  
  *   *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED   * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  * PERFORMANCE OF THIS SOFTWARE.  
  */   */
 #include <sys/stat.h>  #ifdef HAVE_CONFIG_H
   #include "config.h"
   #endif
   
 #include <assert.h>  #include <assert.h>
 #include <err.h>  
 #include <fcntl.h>  
 #include <stdio.h>  #include <stdio.h>
   #include <stdint.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   
   #include "mandoc.h"
   #include "main.h"
 #include "mdoc.h"  #include "mdoc.h"
 #include "man.h"  #include "man.h"
   #include "roff.h"
   
 /* Account for FreeBSD and Linux in our declarations. */  #if !defined(__GNUC__) || (__GNUC__ < 2)
   # if !defined(lint)
 #ifdef __linux__  #  define __attribute__(x)
 extern  int               getsubopt(char **, char * const *, char **);  
 # ifndef __dead  
 #  define __dead __attribute__((__noreturn__))  
 # endif  # endif
 #elif defined(__dead2)  #endif /* !defined(__GNUC__) || (__GNUC__ < 2) */
 # ifndef __dead  
 #  define __dead __dead2  
 # endif  
 #endif  
   
 struct  buf {  typedef void            (*out_mdoc)(void *, const struct mdoc *);
         char             *buf;  typedef void            (*out_man)(void *, const struct man *);
         size_t            sz;  typedef void            (*out_free)(void *);
   
   enum    outt {
           OUTT_ASCII = 0, /* -Tascii */
           OUTT_TREE,      /* -Ttree */
           OUTT_HTML,      /* -Thtml */
           OUTT_XHTML,     /* -Txhtml */
           OUTT_LINT,      /* -Tlint */
           OUTT_PS,        /* -Tps */
           OUTT_PDF        /* -Tpdf */
 };  };
   
 struct  curparse {  struct  curparse {
         const char       *file;          struct mparse    *mp;
         int               wflags;          enum mandoclevel  wlevel;       /* ignore messages below this */
 #define WARN_WALL         0x03          /* All-warnings mask. */          int               wstop;        /* stop after a file with a warning */
 #define WARN_WCOMPAT     (1 << 0)       /* Compatibility warnings. */          enum outt         outtype;      /* which output to use */
 #define WARN_WSYNTAX     (1 << 1)       /* Syntax warnings. */          out_mdoc          outmdoc;      /* mdoc output ptr */
 #define WARN_WERR        (1 << 2)       /* Warnings->errors. */          out_man           outman;       /* man output ptr */
           out_free          outfree;      /* free output ptr */
           void             *outdata;      /* data for output */
           char              outopts[BUFSIZ]; /* buf of output opts */
 };  };
   
 #define IGN_SCOPE        (1 << 0)       /* Ignore scope errors. */  static  const char * const      mandoclevels[MANDOCLEVEL_MAX] = {
 #define IGN_ESCAPE       (1 << 1)       /* Ignore bad escapes. */          "SUCCESS",
 #define IGN_MACRO        (1 << 2)       /* Ignore unknown macros. */          "RESERVED",
           "WARNING",
 enum    intt {          "ERROR",
         INTT_MDOC = 0,          "FATAL",
         INTT_MAN          "BADARG",
           "SYSERR"
 };  };
   
 enum    outt {  static  const char * const      mandocerrs[MANDOCERR_MAX] = {
         OUTT_ASCII = 0,          "ok",
         OUTT_TREE,  
         OUTT_LINT  
 };  
   
 typedef int             (*out_run)(void *, const struct man *,          "generic warning",
                                 const struct mdoc *);  
 typedef void            (*out_free)(void *);  
   
 extern  char             *__progname;          /* related to the prologue */
           "no title in document",
           "document title should be all caps",
           "unknown manual section",
           "date missing, using today's date",
           "cannot parse date, using it verbatim",
           "prologue macros out of order",
           "duplicate prologue macro",
           "macro not allowed in prologue",
           "macro not allowed in body",
   
 extern  void             *ascii_alloc(void);          /* related to document structure */
 extern  int               terminal_run(void *, const struct man *,          ".so is fragile, better use ln(1)",
                                 const struct mdoc *);          "NAME section must come first",
 extern  int               tree_run(void *, const struct man *,          "bad NAME section contents",
                                 const struct mdoc *);          "manual name not yet set",
 extern  void              terminal_free(void *);          "sections out of conventional order",
           "duplicate section name",
           "section not in conventional manual section",
   
 static  int               foptions(int *, char *);          /* related to macros and nesting */
 static  int               toptions(enum outt *, char *);          "skipping obsolete macro",
 static  int               moptions(enum intt *, char *);          "skipping paragraph macro",
 static  int               woptions(int *, char *);          "skipping no-space macro",
 static  int               merr(void *, int, int, const char *);          "blocks badly nested",
 static  int               manwarn(void *, int, int, const char *);          "child violates parent syntax",
 static  int               mdocwarn(void *, int, int,          "nested displays are not portable",
                                 enum mdoc_warn, const char *);          "already in literal mode",
 static  int               file(struct buf *, struct buf *,  
                                 const char *,  
                                 struct man *, struct mdoc *);  
 static  int               fdesc(struct buf *, struct buf *,  
                                 const char *, int,  
                                 struct man *, struct mdoc *);  
 __dead  static void       version(void);  
 __dead  static void       usage(void);  
   
           /* related to missing macro arguments */
           "skipping empty macro",
           "argument count wrong",
           "missing display type",
           "list type must come first",
           "tag lists require a width argument",
           "missing font type",
           "skipping end of block that is not open",
   
           /* related to bad macro arguments */
           "skipping argument",
           "duplicate argument",
           "duplicate display type",
           "duplicate list type",
           "unknown AT&T UNIX version",
           "bad Boolean value",
           "unknown font",
           "unknown standard specifier",
           "bad width argument",
   
           /* related to plain text */
           "blank line in non-literal context",
           "tab in non-literal context",
           "end of line whitespace",
           "bad comment style",
           "unknown escape sequence",
           "unterminated quoted string",
   
           "generic error",
   
           /* related to tables */
           "bad table syntax",
           "bad table option",
           "bad table layout",
           "no table layout cells specified",
           "no table data cells specified",
           "ignore data in cell",
           "data block still open",
           "ignoring extra data cells",
   
           "input stack limit exceeded, infinite loop?",
           "skipping bad character",
           "escaped character not allowed in a name",
           "skipping text before the first section header",
           "skipping unknown macro",
           "NOT IMPLEMENTED, please use groff: skipping request",
           "line scope broken",
           "argument count wrong",
           "skipping end of block that is not open",
           "missing end of block",
           "scope open on exit",
           "uname(3) system call failed",
           "macro requires line argument(s)",
           "macro requires body argument(s)",
           "macro requires argument(s)",
           "missing list type",
           "line argument(s) will be lost",
           "body argument(s) will be lost",
   
           "generic fatal error",
   
           "column syntax is inconsistent",
           "NOT IMPLEMENTED: .Bd -file",
           "line scope broken, syntax violated",
           "argument count wrong, violates syntax",
           "child violates parent syntax",
           "argument count wrong, violates syntax",
           "NOT IMPLEMENTED: .so with absolute path or \"..\"",
           "no document body",
           "no document prologue",
           "static buffer exhausted",
   };
   
   static  int               moptions(enum mparset *, char *);
   static  void              mmsg(enum mandocerr, enum mandoclevel,
                                   const char *, int, int, const char *);
   static  void              parse(struct curparse *, int,
                                   const char *, enum mandoclevel *);
   static  int               toptions(struct curparse *, char *);
   static  void              usage(void) __attribute__((noreturn));
   static  void              version(void) __attribute__((noreturn));
   static  int               woptions(struct curparse *, char *);
   
   static  const char       *progname;
   
 int  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         int              c, rc, fflags, pflags;          int              c;
         struct mdoc_cb   mdoccb;  
         struct man_cb    mancb;  
         struct man      *man;  
         struct mdoc     *mdoc;  
         void            *outdata;  
         enum outt        outtype;  
         enum intt        inttype;  
         struct buf       ln, blk;  
         out_run          outrun;  
         out_free         outfree;  
         struct curparse  curp;          struct curparse  curp;
           enum mparset     type;
           enum mandoclevel rc;
   
         fflags = 0;          progname = strrchr(argv[0], '/');
         outtype = OUTT_ASCII;          if (progname == NULL)
         inttype = INTT_MDOC;                  progname = argv[0];
           else
                   ++progname;
   
         bzero(&curp, sizeof(struct curparse));          memset(&curp, 0, sizeof(struct curparse));
   
           type = MPARSE_AUTO;
           curp.outtype = OUTT_ASCII;
           curp.wlevel  = MANDOCLEVEL_FATAL;
   
         /* LINTED */          /* LINTED */
         while (-1 != (c = getopt(argc, argv, "f:m:VW:T:")))          while (-1 != (c = getopt(argc, argv, "m:O:T:VW:")))
                 switch (c) {                  switch (c) {
                 case ('f'):  
                         if ( ! foptions(&fflags, optarg))  
                                 return(0);  
                         break;  
                 case ('m'):                  case ('m'):
                         if ( ! moptions(&inttype, optarg))                          if ( ! moptions(&type, optarg))
                                 return(0);                                  return((int)MANDOCLEVEL_BADARG);
                         break;                          break;
                   case ('O'):
                           (void)strlcat(curp.outopts, optarg, BUFSIZ);
                           (void)strlcat(curp.outopts, ",", BUFSIZ);
                           break;
                 case ('T'):                  case ('T'):
                         if ( ! toptions(&outtype, optarg))                          if ( ! toptions(&curp, optarg))
                                 return(0);                                  return((int)MANDOCLEVEL_BADARG);
                         break;                          break;
                 case ('W'):                  case ('W'):
                         if ( ! woptions(&curp.wflags, optarg))                          if ( ! woptions(&curp, optarg))
                                 return(0);                                  return((int)MANDOCLEVEL_BADARG);
                         break;                          break;
                 case ('V'):                  case ('V'):
                         version();                          version();
Line 151  main(int argc, char *argv[])
Line 240  main(int argc, char *argv[])
                         /* NOTREACHED */                          /* NOTREACHED */
                 }                  }
   
           curp.mp = mparse_alloc(type, curp.wlevel, mmsg, &curp);
   
         argc -= optind;          argc -= optind;
         argv += optind;          argv += optind;
   
         /*          rc = MANDOCLEVEL_OK;
          * Allocate the appropriate front-end.  Note that utf8, latin1  
          * (both not yet implemented) and ascii all resolve to the  
          * terminal front-end with different encodings (see terminal.c).  
          * Not all frontends have cleanup or alloc routines.  
          */  
   
         switch (outtype) {          if (NULL == *argv)
         case (OUTT_TREE):                  parse(&curp, STDIN_FILENO, "<stdin>", &rc);
                 outdata = NULL;  
                 outrun = tree_run;  
                 outfree = NULL;  
                 break;  
         case (OUTT_LINT):  
                 outdata = NULL;  
                 outrun = NULL;  
                 outfree = NULL;  
                 break;  
         default:  
                 outdata = ascii_alloc();  
                 outrun = terminal_run;  
                 outfree = terminal_free;  
                 break;  
         }  
   
         /*          while (*argv) {
          * All callbacks route into here, where we print them onto the                  parse(&curp, -1, *argv, &rc);
          * screen.  XXX - for now, no path for debugging messages.                  if (MANDOCLEVEL_OK != rc && curp.wstop)
          */                          break;
                   ++argv;
         mdoccb.mdoc_msg = NULL;  
         mdoccb.mdoc_err = merr;  
         mdoccb.mdoc_warn = mdocwarn;  
   
         mancb.man_err = merr;  
         mancb.man_warn = manwarn;  
   
         /* Configure buffers. */  
   
         bzero(&ln, sizeof(struct buf));  
         bzero(&blk, sizeof(struct buf));  
   
         man = NULL;  
         mdoc = NULL;  
         pflags = 0;  
   
         /*  
          * Allocate the parser.  There are two kinds of parser: libman  
          * and libmdoc.  We must separately copy over the flags that  
          * we'll use internally.  
          */  
   
         switch (inttype) {  
         case (INTT_MAN):  
                 if (fflags & IGN_MACRO)  
                         pflags |= MAN_IGN_MACRO;  
                 man = man_alloc(&curp, pflags, &mancb);  
                 break;  
         default:  
                 if (fflags & IGN_SCOPE)  
                         pflags |= MDOC_IGN_SCOPE;  
                 if (fflags & IGN_ESCAPE)  
                         pflags |= MDOC_IGN_ESCAPE;  
                 if (fflags & IGN_MACRO)  
                         pflags |= MDOC_IGN_MACRO;  
                 mdoc = mdoc_alloc(&curp, pflags, &mdoccb);  
                 break;  
         }          }
   
         /*          if (curp.outfree)
          * Main loop around available files.                  (*curp.outfree)(curp.outdata);
          */          if (curp.mp)
                   mparse_free(curp.mp);
   
         if (NULL == *argv) {          return((int)rc);
                 curp.file = "<stdin>";  
                 rc = 0;  
                 c = fdesc(&blk, &ln, "stdin", STDIN_FILENO, man, mdoc);  
   
                 if (c && NULL == outrun)  
                         rc = 1;  
                 else if (c && outrun && (*outrun)(outdata, man, mdoc))  
                         rc = 1;  
         } else {  
                 while (*argv) {  
                         curp.file = *argv;  
                         c = file(&blk, &ln, *argv, man, mdoc);  
                         if ( ! c)  
                                 break;  
                         if (outrun && ! (*outrun)(outdata, man, mdoc))  
                                 break;  
                         if (man)  
                                 man_reset(man);  
                         if (mdoc)  
                                 mdoc_reset(mdoc);  
                         argv++;  
                 }  
                 rc = NULL == *argv;  
         }  
   
         if (blk.buf)  
                 free(blk.buf);  
         if (ln.buf)  
                 free(ln.buf);  
         if (outfree)  
                 (*outfree)(outdata);  
         if (mdoc)  
                 mdoc_free(mdoc);  
         if (man)  
                 man_free(man);  
   
         return(rc ? EXIT_SUCCESS : EXIT_FAILURE);  
 }  }
   
   static void
 __dead static void  
 version(void)  version(void)
 {  {
   
         (void)printf("%s %s\n", __progname, VERSION);          printf("%s %s\n", progname, VERSION);
         exit(0);          exit((int)MANDOCLEVEL_OK);
         /* NOTREACHED */  
 }  }
   
   static void
 __dead static void  
 usage(void)  usage(void)
 {  {
   
         (void)fprintf(stderr, "usage: %s [-V] [-foption...] "          fprintf(stderr, "usage: %s "
                         "[-mformat] [-Toutput] [-Werr...]\n",                          "[-V] "
                         __progname);                          "[-foption] "
         exit(1);                          "[-mformat] "
         /* NOTREACHED */                          "[-Ooption] "
                           "[-Toutput] "
                           "[-Werr] "
                           "[file...]\n",
                           progname);
   
           exit((int)MANDOCLEVEL_BADARG);
 }  }
   
   static void
 static int  parse(struct curparse *curp, int fd,
 file(struct buf *blk, struct buf *ln, const char *file,                  const char *file, enum mandoclevel *level)
                 struct man *man, struct mdoc *mdoc)  
 {  {
         int              fd, c;          enum mandoclevel  rc;
           struct mdoc      *mdoc;
           struct man       *man;
   
         if (-1 == (fd = open(file, O_RDONLY, 0))) {          /* Begin by parsing the file itself. */
                 warn("%s", file);  
                 return(0);  
         }  
   
         c = fdesc(blk, ln, file, fd, man, mdoc);          assert(file);
           assert(fd >= -1);
   
         if (-1 == close(fd))          rc = mparse_readfd(curp->mp, fd, file);
                 warn("%s", file);  
   
         return(c);          /* Stop immediately if the parse has failed. */
 }  
   
           if (MANDOCLEVEL_FATAL <= rc)
                   goto cleanup;
   
 static int  
 fdesc(struct buf *blk, struct buf *ln,  
                 const char *f, int fd,  
                 struct man *man, struct mdoc *mdoc)  
 {  
         size_t           sz;  
         ssize_t          ssz;  
         struct stat      st;  
         int              j, i, pos, lnn;  
   
         assert( ! (man && mdoc));  
   
         /*          /*
          * Two buffers: ln and buf.  buf is the input buffer, optimised           * With -Wstop and warnings or errors of at least the requested
          * for each file's block size.  ln is a line buffer.  Both           * level, do not produce output.
          * growable, hence passed in by ptr-ptr.  
          */           */
   
         sz = BUFSIZ;          if (MANDOCLEVEL_OK != rc && curp->wstop)
                   goto cleanup;
   
         if (-1 == fstat(fd, &st))          /* If unset, allocate output dev now (if applicable). */
                 warnx("%s", f);  
         else if ((size_t)st.st_blksize > sz)  
                 sz = st.st_blksize;  
   
         if (sz > blk->sz) {          if ( ! (curp->outman && curp->outmdoc)) {
                 blk->buf = realloc(blk->buf, sz);                  switch (curp->outtype) {
                 if (NULL == blk->buf)                  case (OUTT_XHTML):
                         err(1, "realloc");                          curp->outdata = xhtml_alloc(curp->outopts);
                 blk->sz = sz;                          break;
         }                  case (OUTT_HTML):
                           curp->outdata = html_alloc(curp->outopts);
                           break;
                   case (OUTT_ASCII):
                           curp->outdata = ascii_alloc(curp->outopts);
                           curp->outfree = ascii_free;
                           break;
                   case (OUTT_PDF):
                           curp->outdata = pdf_alloc(curp->outopts);
                           curp->outfree = pspdf_free;
                           break;
                   case (OUTT_PS):
                           curp->outdata = ps_alloc(curp->outopts);
                           curp->outfree = pspdf_free;
                           break;
                   default:
                           break;
                   }
   
         /*                  switch (curp->outtype) {
          * Fill buf with file blocksize and parse newlines into ln.                  case (OUTT_HTML):
          */                          /* FALLTHROUGH */
                   case (OUTT_XHTML):
         for (lnn = 1, pos = 0; ; ) {                          curp->outman = html_man;
                 if (-1 == (ssz = read(fd, blk->buf, sz))) {                          curp->outmdoc = html_mdoc;
                         warn("%s", f);                          curp->outfree = html_free;
                         return(0);  
                 } else if (0 == ssz)  
                         break;                          break;
                   case (OUTT_TREE):
                           curp->outman = tree_man;
                           curp->outmdoc = tree_mdoc;
                           break;
                   case (OUTT_PDF):
                           /* FALLTHROUGH */
                   case (OUTT_ASCII):
                           /* FALLTHROUGH */
                   case (OUTT_PS):
                           curp->outman = terminal_man;
                           curp->outmdoc = terminal_mdoc;
                           break;
                   default:
                           break;
                   }
           }
   
                 for (i = 0; i < (int)ssz; i++) {          mparse_result(curp->mp, &mdoc, &man);
                         if (pos >= (int)ln->sz) {  
                                 ln->sz += 256; /* Step-size. */  
                                 ln->buf = realloc(ln->buf, ln->sz);  
                                 if (NULL == ln->buf)  
                                         err(1, "realloc");  
                         }  
   
                         if ('\n' != blk->buf[i]) {          /* Execute the out device, if it exists. */
                                 ln->buf[pos++] = blk->buf[i];  
                                 continue;  
                         }  
   
                         /* Check for CPP-escaped newline.  */          if (man && curp->outman)
                   (*curp->outman)(curp->outdata, man);
           if (mdoc && curp->outmdoc)
                   (*curp->outmdoc)(curp->outdata, mdoc);
   
                         if (pos > 0 && '\\' == ln->buf[pos - 1]) {   cleanup:
                                 for (j = pos - 1; j >= 0; j--)  
                                         if ('\\' != ln->buf[j])  
                                                 break;  
   
                                 if ( ! ((pos - j) % 2)) {          mparse_reset(curp->mp);
                                         pos--;  
                                         lnn++;  
                                         continue;  
                                 }  
                         }  
   
                         ln->buf[pos] = 0;          if (*level < rc)
                         if (mdoc && ! mdoc_parseln(mdoc, lnn, ln->buf))                  *level = rc;
                                 return(0);  
                         if (man && ! man_parseln(man, lnn, ln->buf))  
                                 return(0);  
                         lnn++;  
                         pos = 0;  
                 }  
         }  
   
         if (mdoc)  
                return(mdoc_endparse(mdoc));  
   
         return(man_endparse(man));  
 }  }
   
   
 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"))
                   *tflags = MPARSE_AUTO;
         else if (0 == strcmp(arg, "an"))          else if (0 == strcmp(arg, "an"))
                 *tflags = INTT_MAN;                  *tflags = MPARSE_MAN;
         else {          else {
                 warnx("bad argument: -m%s", arg);                  fprintf(stderr, "%s: Bad argument\n", arg);
                 return(0);                  return(0);
         }          }
   
         return(1);          return(1);
 }  }
   
   
 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;
         else if (0 == strcmp(arg, "tree"))                  curp->wlevel  = MANDOCLEVEL_WARNING;
                 *tflags = OUTT_TREE;          } else if (0 == strcmp(arg, "tree"))
                   curp->outtype = OUTT_TREE;
           else if (0 == strcmp(arg, "html"))
                   curp->outtype = OUTT_HTML;
           else if (0 == strcmp(arg, "xhtml"))
                   curp->outtype = OUTT_XHTML;
           else if (0 == strcmp(arg, "ps"))
                   curp->outtype = OUTT_PS;
           else if (0 == strcmp(arg, "pdf"))
                   curp->outtype = OUTT_PDF;
         else {          else {
                 warnx("bad argument: -T%s", arg);                  fprintf(stderr, "%s: Bad argument\n", arg);
                 return(0);                  return(0);
         }          }
   
         return(1);          return(1);
 }  }
   
   
 /*  
  * 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)  woptions(struct curparse *curp, char *arg)
 {  {
         char            *v;          char            *v, *o;
         char            *toks[4];          const char      *toks[6];
   
         toks[0] = "ign-scope";          toks[0] = "stop";
         toks[1] = "ign-escape";          toks[1] = "all";
         toks[2] = "ign-macro";          toks[2] = "warning";
         toks[3] = NULL;  
   
         while (*arg)  
                 switch (getsubopt(&arg, toks, &v)) {  
                 case (0):  
                         *fflags |= IGN_SCOPE;  
                         break;  
                 case (1):  
                         *fflags |= IGN_ESCAPE;  
                         break;  
                 case (2):  
                         *fflags |= IGN_MACRO;  
                         break;  
                 default:  
                         warnx("bad argument: -f%s", arg);  
                         return(0);  
                 }  
   
         return(1);  
 }  
   
   
 /*  
  * Parse out the options for [-Werr...], which sets warning modes.  
  * These can be comma-delimited or called again.  
  */  
 static int  
 woptions(int *wflags, char *arg)  
 {  
         char            *v;  
         char            *toks[5];  
   
         toks[0] = "all";  
         toks[1] = "compat";  
         toks[2] = "syntax";  
         toks[3] = "error";          toks[3] = "error";
         toks[4] = NULL;          toks[4] = "fatal";
           toks[5] = NULL;
   
         while (*arg)          while (*arg) {
                 switch (getsubopt(&arg, toks, &v)) {                  o = arg;
                   switch (getsubopt(&arg, UNCONST(toks), &v)) {
                 case (0):                  case (0):
                         *wflags |= WARN_WALL;                          curp->wstop = 1;
                         break;                          break;
                 case (1):                  case (1):
                         *wflags |= WARN_WCOMPAT;                          /* FALLTHROUGH */
                         break;  
                 case (2):                  case (2):
                         *wflags |= WARN_WSYNTAX;                          curp->wlevel = MANDOCLEVEL_WARNING;
                         break;                          break;
                 case (3):                  case (3):
                         *wflags |= WARN_WERR;                          curp->wlevel = MANDOCLEVEL_ERROR;
                         break;                          break;
                   case (4):
                           curp->wlevel = MANDOCLEVEL_FATAL;
                           break;
                 default:                  default:
                         warnx("bad argument: -W%s", arg);                          fprintf(stderr, "-W%s: Bad argument\n", o);
                         return(0);                          return(0);
                 }                  }
           }
   
         return(1);          return(1);
 }  }
   
   static void
 /* ARGSUSED */  mmsg(enum mandocerr t, enum mandoclevel lvl,
 static int                  const char *file, int line, int col, const char *msg)
 merr(void *arg, int line, int col, const char *msg)  
 {  {
         struct curparse *curp;  
   
         curp = (struct curparse *)arg;          fprintf(stderr, "%s:%d:%d: %s: %s",
                           file, line, col + 1,
                           mandoclevels[lvl], mandocerrs[t]);
   
         warnx("%s:%d: error: %s (column %d)",          if (msg)
                         curp->file, line, msg, col);                  fprintf(stderr, ": %s", msg);
         return(0);  
 }  
   
           fputc('\n', stderr);
 static int  
 mdocwarn(void *arg, int line, int col,  
                 enum mdoc_warn type, const char *msg)  
 {  
         struct curparse *curp;  
         char            *wtype;  
   
         curp = (struct curparse *)arg;  
         wtype = NULL;  
   
         switch (type) {  
         case (WARN_COMPAT):  
                 wtype = "compat";  
                 if (curp->wflags & WARN_WCOMPAT)  
                         break;  
                 return(1);  
         case (WARN_SYNTAX):  
                 wtype = "syntax";  
                 if (curp->wflags & WARN_WSYNTAX)  
                         break;  
                 return(1);  
         }  
   
         assert(wtype);  
         warnx("%s:%d: %s warning: %s (column %d)",  
                         curp->file, line, wtype, msg, col);  
   
         if ( ! (curp->wflags & WARN_WERR))  
                 return(1);  
   
         warnx("%s: considering warnings as errors",  
                         __progname);  
         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);  
   
         warnx("%s: considering warnings as errors",  
                         __progname);  
         return(0);  
 }  }
Legend:
Removed from v.1.17  
changed lines
  Added in v.1.156
CVSweb