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

Diff for /mandoc/main.c between version 1.38 and 1.155

version 1.38, 2009/07/07 09:52:08 version 1.155, 2011/03/20 16:02:05
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>   * 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 above   * purpose with or without fee is hereby granted, provided that the above
Line 14 
Line 15 
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * OR IN CONNECTION WITH THE USE OR 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  
   
 typedef int             (*out_mdoc)(void *, const struct mdoc *);  typedef void            (*out_mdoc)(void *, const struct mdoc *);
 typedef int             (*out_man)(void *, const struct man *);  typedef void            (*out_man)(void *, const struct man *);
 typedef void            (*out_free)(void *);  typedef void            (*out_free)(void *);
   
 struct  buf {  enum    outt {
         char             *buf;          OUTT_ASCII = 0, /* -Tascii */
         size_t            sz;          OUTT_TREE,      /* -Ttree */
           OUTT_HTML,      /* -Thtml */
           OUTT_XHTML,     /* -Txhtml */
           OUTT_LINT,      /* -Tlint */
           OUTT_PS,        /* -Tps */
           OUTT_PDF        /* -Tpdf */
 };  };
   
 enum    intt {  struct  curparse {
         INTT_AUTO,          struct mparse    *mp;
         INTT_MDOC,          const char       *file;         /* current file-name */
         INTT_MAN          enum mandoclevel  wlevel;       /* ignore messages below this */
           int               wstop;        /* stop after a file with a warning */
           enum outt         outtype;      /* which output to use */
           out_mdoc          outmdoc;      /* mdoc output ptr */
           out_man           outman;       /* man output ptr */
           out_free          outfree;      /* free output ptr */
           void             *outdata;      /* data for output */
           char              outopts[BUFSIZ]; /* buf of output opts */
 };  };
   
 enum    outt {  static  const char * const      mandoclevels[MANDOCLEVEL_MAX] = {
         OUTT_ASCII = 0,          "SUCCESS",
         OUTT_TREE,          "RESERVED",
         OUTT_LINT          "WARNING",
           "ERROR",
           "FATAL",
           "BADARG",
           "SYSERR"
 };  };
   
 struct  curparse {  static  const char * const      mandocerrs[MANDOCERR_MAX] = {
         const char       *file;         /* Current parse. */          "ok",
         int               fd;           /* Current parse. */  
         int               wflags;  
 #define WARN_WALL        (1 << 0)       /* All-warnings mask. */  
 #define WARN_WERR        (1 << 2)       /* Warnings->errors. */  
         int               fflags;  
 #define IGN_SCOPE        (1 << 0)       /* Ignore scope errors. */  
 #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_CHARS     (1 << 3)       /* Don't ignore bad chars. */  
         enum intt         inttype;      /* Input parsers... */  
         struct man       *man;  
         struct man       *lastman;  
         struct mdoc      *mdoc;  
         struct mdoc      *lastmdoc;  
         enum outt         outtype;      /* Output devices... */  
         out_mdoc          outmdoc;  
         out_man           outman;  
         out_free          outfree;  
         void             *outdata;  
 };  
   
 extern  void             *ascii_alloc(void);          "generic warning",
 extern  int               tree_mdoc(void *, const struct mdoc *);  
 extern  int               tree_man(void *, const struct man *);  
 extern  int               terminal_mdoc(void *, const struct mdoc *);  
 extern  int               terminal_man(void *, const struct man *);  
 extern  void              terminal_free(void *);  
   
 static  int               foptions(int *, char *);          /* related to the prologue */
 static  int               toptions(enum outt *, char *);          "no title in document",
 static  int               moptions(enum intt *, char *);          "document title should be all caps",
 static  int               woptions(int *, char *);          "unknown manual section",
 static  int               merr(void *, int, int, const char *);          "date missing, using today's date",
 static  int               mwarn(void *, int, int, const char *);          "cannot parse date, using it verbatim",
 static  int               ffile(struct buf *, struct buf *,          "prologue macros out of order",
                                 const char *, struct curparse *);          "duplicate prologue macro",
 static  int               fdesc(struct buf *, struct buf *,          "macro not allowed in prologue",
                                 struct curparse *);          "macro not allowed in body",
 static  int               pset(const char *, int, struct curparse *,  
                                 struct man **, struct mdoc **);  
 static  struct man       *man_init(struct curparse *);  
 static  struct mdoc      *mdoc_init(struct curparse *);  
 __dead  static void       version(void);  
 __dead  static void       usage(void);  
   
 extern  char             *__progname;          /* related to document structure */
           ".so is fragile, better use ln(1)",
           "NAME section must come first",
           "bad NAME section contents",
           "manual name not yet set",
           "sections out of conventional order",
           "duplicate section name",
           "section not in conventional manual section",
   
           /* related to macros and nesting */
           "skipping obsolete macro",
           "skipping paragraph macro",
           "skipping no-space macro",
           "blocks badly nested",
           "child violates parent syntax",
           "nested displays are not portable",
           "already in literal mode",
   
           /* 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  void              evt_close(void *, const char *);
   static  int               evt_open(void *, const char *);
   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;          int              c;
         struct buf       ln, blk;  
         struct curparse  curp;          struct curparse  curp;
           enum mparset     type;
           enum mandoclevel rc;
   
         bzero(&curp, sizeof(struct curparse));          progname = strrchr(argv[0], '/');
           if (progname == NULL)
                   progname = argv[0];
           else
                   ++progname;
   
         curp.inttype = INTT_AUTO;          memset(&curp, 0, sizeof(struct curparse));
   
           type = MPARSE_AUTO;
         curp.outtype = OUTT_ASCII;          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(&curp.fflags, optarg))  
                                 return(EXIT_FAILURE);  
                         break;  
                 case ('m'):                  case ('m'):
                         if ( ! moptions(&curp.inttype, optarg))                          if ( ! moptions(&type, optarg))
                                 return(EXIT_FAILURE);                                  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(&curp.outtype, optarg))                          if ( ! toptions(&curp, optarg))
                                 return(EXIT_FAILURE);                                  return((int)MANDOCLEVEL_BADARG);
                         break;                          break;
                 case ('W'):                  case ('W'):
                         if ( ! woptions(&curp.wflags, optarg))                          if ( ! woptions(&curp, optarg))
                                 return(EXIT_FAILURE);                                  return((int)MANDOCLEVEL_BADARG);
                         break;                          break;
                 case ('V'):                  case ('V'):
                         version();                          version();
Line 150  main(int argc, char *argv[])
Line 243  main(int argc, char *argv[])
                         /* NOTREACHED */                          /* NOTREACHED */
                 }                  }
   
           curp.mp = mparse_alloc(type, evt_open, evt_close, curp.wlevel, mmsg, &curp);
   
         argc -= optind;          argc -= optind;
         argv += optind;          argv += optind;
   
         bzero(&ln, sizeof(struct buf));          rc = MANDOCLEVEL_OK;
         bzero(&blk, sizeof(struct buf));  
   
         rc = 1;          if (NULL == *argv)
                   parse(&curp, STDIN_FILENO, "<stdin>", &rc);
   
         if (NULL == *argv) {          while (*argv) {
                 curp.file = "<stdin>";                  parse(&curp, -1, *argv, &rc);
                 curp.fd = STDIN_FILENO;                  if (MANDOCLEVEL_OK != rc && curp.wstop)
                 if ( ! fdesc(&blk, &ln, &curp))                          break;
                         rc = 0;                  ++argv;
         }          }
   
         while (rc && *argv) {  
                 if ( ! ffile(&blk, &ln, *argv, &curp))  
                         rc = 0;  
                 argv++;  
                 if (*argv && rc) {  
                         if (curp.lastman)  
                                 if ( ! man_reset(curp.lastman))  
                                         rc = 0;  
                         if (curp.lastmdoc)  
                                 if ( ! mdoc_reset(curp.lastmdoc))  
                                         rc = 0;  
                         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.mp)
                 mdoc_free(curp.mdoc);                  mparse_free(curp.mp);
         if (curp.man)  
                 man_free(curp.man);  
   
         return(rc ? EXIT_SUCCESS : EXIT_FAILURE);          return((int)rc);
 }  }
   
   static void
 __dead static void  
 version(void)  version(void)
 {  {
   
         (void)printf("%s %s\n", __progname, VERSION);          printf("%s %s\n", progname, VERSION);
         exit(EXIT_SUCCESS);          exit((int)MANDOCLEVEL_OK);
 }  }
   
   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(EXIT_FAILURE);                          "[-mformat] "
                           "[-Ooption] "
                           "[-Toutput] "
                           "[-Werr] "
                           "[file...]\n",
                           progname);
   
           exit((int)MANDOCLEVEL_BADARG);
 }  }
   
   static int
 static struct man *  evt_open(void *arg, const char *file)
 man_init(struct curparse *curp)  
 {  {
         int              pflags;  
         struct man      *man;  
         struct man_cb    mancb;  
   
         mancb.man_err = merr;          evt_close(arg, file);
         mancb.man_warn = mwarn;          return(1);
   
         /* Defaults from mandoc.1. */  
   
         pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE | MAN_IGN_CHARS;  
   
         if (curp->fflags & NO_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)))  
                 warnx("memory exhausted");  
   
         return(man);  
 }  }
   
   static void
 static struct mdoc *  evt_close(void *arg, const char *file)
 mdoc_init(struct curparse *curp)  
 {  {
         int              pflags;          struct curparse *p;
         struct mdoc     *mdoc;  
         struct mdoc_cb   mdoccb;  
   
         mdoccb.mdoc_err = merr;          p = (struct curparse *)arg;
         mdoccb.mdoc_warn = mwarn;          p->file = file;
   
         /* Defaults from mandoc.1. */  
   
         pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE | MDOC_IGN_CHARS;  
   
         if (curp->fflags & IGN_SCOPE)  
                 pflags |= MDOC_IGN_SCOPE;  
         if (curp->fflags & NO_IGN_ESCAPE)  
                 pflags &= ~MDOC_IGN_ESCAPE;  
         if (curp->fflags & NO_IGN_MACRO)  
                 pflags &= ~MDOC_IGN_MACRO;  
         if (curp->fflags & NO_IGN_CHARS)  
                 pflags &= ~MDOC_IGN_CHARS;  
   
         if (NULL == (mdoc = mdoc_alloc(curp, pflags, &mdoccb)))  
                 warnx("memory exhausted");  
   
         return(mdoc);  
 }  }
   
   static void
 static int  parse(struct curparse *curp, int fd,
 ffile(struct buf *blk, struct buf *ln,                  const char *file, enum mandoclevel *level)
                 const char *file, struct curparse *curp)  
 {  {
         int              c;          enum mandoclevel  rc;
           struct mdoc      *mdoc;
           struct man       *man;
   
         curp->file = file;          /* Begin by parsing the file itself. */
         if (-1 == (curp->fd = open(curp->file, O_RDONLY, 0))) {  
                 warn("%s", curp->file);  
                 return(0);  
         }  
   
         c = fdesc(blk, ln, curp);          assert(file);
           assert(fd >= -1);
   
         if (-1 == close(curp->fd))          rc = mparse_readfd(curp->mp, fd, file);
                 warn("%s", curp->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, struct curparse *curp)  
 {  
         size_t           sz;  
         ssize_t          ssz;  
         struct stat      st;  
         int              j, i, pos, lnn, comment;  
         struct man      *man;  
         struct mdoc     *mdoc;  
   
         sz = BUFSIZ;  
         man = NULL;  
         mdoc = NULL;  
   
         /*          /*
          * Two buffers: ln and buf.  buf is the input buffer optimised           * With -Wstop and warnings or errors of at least the requested
          * here for each file's block size.  ln is a line buffer.  Both           * level, do not produce output.
          * growable, hence passed in by ptr-ptr.  
          */           */
   
         if (-1 == fstat(curp->fd, &st))          if (MANDOCLEVEL_OK != rc && curp->wstop)
                 warn("%s", curp->file);                  goto cleanup;
         else if ((size_t)st.st_blksize > sz)  
                 sz = st.st_blksize;  
   
         if (sz > blk->sz) {          /* If unset, allocate output dev now (if applicable). */
                 blk->buf = realloc(blk->buf, sz);  
                 if (NULL == blk->buf) {  
                         warn("realloc");  
                         return(0);  
                 }  
                 blk->sz = sz;  
         }  
   
         /* Fill buf with file blocksize. */          if ( ! (curp->outman && curp->outmdoc)) {
                   switch (curp->outtype) {
         for (lnn = pos = comment = 0; ; ) {                  case (OUTT_XHTML):
                 if (-1 == (ssz = read(curp->fd, blk->buf, sz))) {                          curp->outdata = xhtml_alloc(curp->outopts);
                         warn("%s", curp->file);  
                         return(0);  
                 } else if (0 == ssz)  
                         break;                          break;
                   case (OUTT_HTML):
                 /* Parse the read block into partial or full lines. */                          curp->outdata = html_alloc(curp->outopts);
                           break;
                 for (i = 0; i < (int)ssz; i++) {                  case (OUTT_ASCII):
                         if (pos >= (int)ln->sz) {                          curp->outdata = ascii_alloc(curp->outopts);
                                 ln->sz += 256; /* Step-size. */                          curp->outfree = ascii_free;
                                 ln->buf = realloc(ln->buf, ln->sz);                          break;
                                 if (NULL == ln->buf) {                  case (OUTT_PDF):
                                         warn("realloc");                          curp->outdata = pdf_alloc(curp->outopts);
                                         return(0);                          curp->outfree = pspdf_free;
                                 }                          break;
                         }                  case (OUTT_PS):
                           curp->outdata = ps_alloc(curp->outopts);
                         if ('\n' != blk->buf[i]) {                          curp->outfree = pspdf_free;
                                 if (comment)                          break;
                                         continue;                  default:
                                 ln->buf[pos++] = blk->buf[i];                          break;
   
                                 /* Handle in-line `\"' comments. */  
   
                                 if (1 == pos || '\"' != ln->buf[pos - 1])  
                                         continue;  
   
                                 for (j = pos - 2; j >= 0; j--)  
                                         if ('\\' != ln->buf[j])  
                                                 break;  
   
                                 if ( ! ((pos - 2 - j) % 2))  
                                         continue;  
   
                                 comment = 1;  
                                 pos -= 2;  
                                 continue;  
                         }  
   
                         /* Handle escaped `\\n' newlines. */  
   
                         if (pos > 0 && 0 == comment &&  
                                         '\\' == ln->buf[pos - 1]) {  
                                 for (j = pos - 1; j >= 0; j--)  
                                         if ('\\' != ln->buf[j])  
                                                 break;  
                                 if ( ! ((pos - j) % 2)) {  
                                         pos--;  
                                         lnn++;  
                                         continue;  
                                 }  
                         }  
   
                         ln->buf[pos] = 0;  
                         lnn++;  
   
                         /* If unset, assign parser in pset(). */  
   
                         if ( ! (man || mdoc) && ! pset(ln->buf,  
                                                 pos, curp, &man, &mdoc))  
                                 return(0);  
   
                         pos = comment = 0;  
   
                         /* Pass down into parsers. */  
   
                         if (man && ! man_parseln(man, lnn, ln->buf))  
                                 return(0);  
                         if (mdoc && ! mdoc_parseln(mdoc, lnn, ln->buf))  
                                 return(0);  
                 }                  }
         }  
   
         /* NOTE a parser may not have been assigned, yet. */  
   
         if ( ! (man || mdoc)) {  
                 warnx("%s: not a manual", curp->file);  
                 return(0);  
         }  
   
         if (mdoc && ! mdoc_endparse(mdoc))  
                 return(0);  
         if (man && ! man_endparse(man))  
                 return(0);  
   
         /* If unset, allocate output dev now (if applicable). */  
   
         if ( ! (curp->outman && curp->outmdoc)) {  
                 switch (curp->outtype) {                  switch (curp->outtype) {
                   case (OUTT_HTML):
                           /* FALLTHROUGH */
                   case (OUTT_XHTML):
                           curp->outman = html_man;
                           curp->outmdoc = html_mdoc;
                           curp->outfree = html_free;
                           break;
                 case (OUTT_TREE):                  case (OUTT_TREE):
                         curp->outman = tree_man;                          curp->outman = tree_man;
                         curp->outmdoc = tree_mdoc;                          curp->outmdoc = tree_mdoc;
                         break;                          break;
                 case (OUTT_LINT):                  case (OUTT_PDF):
                         break;                          /* FALLTHROUGH */
                 default:                  case (OUTT_ASCII):
                         curp->outdata = ascii_alloc();                          /* FALLTHROUGH */
                   case (OUTT_PS):
                         curp->outman = terminal_man;                          curp->outman = terminal_man;
                         curp->outmdoc = terminal_mdoc;                          curp->outmdoc = terminal_mdoc;
                         curp->outfree = terminal_free;  
                         break;                          break;
                   default:
                           break;
                 }                  }
         }          }
   
           mparse_result(curp->mp, &mdoc, &man);
   
         /* Execute the out device, if it exists. */          /* Execute the out device, if it exists. */
   
         if (man && curp->outman)          if (man && curp->outman)
                 if ( ! (*curp->outman)(curp->outdata, man))                  (*curp->outman)(curp->outdata, man);
                         return(0);  
         if (mdoc && curp->outmdoc)          if (mdoc && curp->outmdoc)
                 if ( ! (*curp->outmdoc)(curp->outdata, mdoc))                  (*curp->outmdoc)(curp->outdata, mdoc);
                         return(0);  
   
         return(1);   cleanup:
 }  
   
           mparse_reset(curp->mp);
   
 static int          if (*level < rc)
 pset(const char *buf, int pos, struct curparse *curp,                  *level = rc;
                 struct man **man, struct mdoc **mdoc)  
 {  
         int              i;  
   
         /*  
          * Try to intuit which kind of manual parser should be used.  If  
          * passed in by command-line (-man, -mdoc), then use that  
          * explicitly.  If passed as -mandoc, then try to guess from the  
          * line: either skip dot-lines, use -mdoc when finding `.Dt', or  
          * default to -man, which is more lenient.  
          */  
   
         if (buf[0] == '.') {  
                 for (i = 1; buf[i]; i++)  
                         if (' ' != buf[i] && '\t' != buf[i])  
                                 break;  
                 if (0 == buf[i])  
                         return(1);  
         }  
   
         switch (curp->inttype) {  
         case (INTT_MDOC):  
                 if (NULL == curp->mdoc)  
                         curp->mdoc = mdoc_init(curp);  
                 if (NULL == (*mdoc = curp->mdoc))  
                         return(0);  
                 curp->lastmdoc = *mdoc;  
                 return(1);  
         case (INTT_MAN):  
                 if (NULL == curp->man)  
                         curp->man = man_init(curp);  
                 if (NULL == (*man = curp->man))  
                         return(0);  
                 curp->lastman = *man;  
                 return(1);  
         default:  
                 break;  
         }  
   
         if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {  
                 if (NULL == curp->mdoc)  
                         curp->mdoc = mdoc_init(curp);  
                 if (NULL == (*mdoc = curp->mdoc))  
                         return(0);  
                 curp->lastmdoc = *mdoc;  
                 return(1);  
         }  
   
         if (NULL == curp->man)  
                 curp->man = man_init(curp);  
         if (NULL == (*man = curp->man))  
                 return(0);  
         curp->lastman = *man;  
         return(1);  
 }  }
   
   
 static int  static int
 moptions(enum intt *tflags, char *arg)  moptions(enum mparset *tflags, char *arg)
 {  {
   
         if (0 == strcmp(arg, "doc"))          if (0 == strcmp(arg, "doc"))
                 *tflags = INTT_MDOC;                  *tflags = MPARSE_MDOC;
         else if (0 == strcmp(arg, "andoc"))          else if (0 == strcmp(arg, "andoc"))
                 *tflags = INTT_AUTO;                  *tflags = MPARSE_AUTO;
         else if (0 == strcmp(arg, "an"))          else if (0 == strcmp(arg, "an"))
                 *tflags = INTT_MAN;                  *tflags = MPARSE_MAN;
         else {          else {
                 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);
 }  }
   
   
 static int  static int
 foptions(int *fflags, char *arg)  woptions(struct curparse *curp, char *arg)
 {  {
         char            *v, *o;          char            *v, *o;
         char            *toks[6];          const char      *toks[6];
   
         toks[0] = "ign-scope";          toks[0] = "stop";
         toks[1] = "no-ign-escape";          toks[1] = "all";
         toks[2] = "no-ign-macro";          toks[2] = "warning";
         toks[3] = "no-ign-chars";          toks[3] = "error";
         toks[4] = "strict";          toks[4] = "fatal";
         toks[5] = NULL;          toks[5] = NULL;
   
         while (*arg) {          while (*arg) {
                 o = arg;                  o = arg;
                 switch (getsubopt(&arg, toks, &v)) {                  switch (getsubopt(&arg, UNCONST(toks), &v)) {
                 case (0):                  case (0):
                         *fflags |= IGN_SCOPE;                          curp->wstop = 1;
                         break;                          break;
                 case (1):                  case (1):
                         *fflags |= NO_IGN_ESCAPE;                          /* FALLTHROUGH */
                         break;  
                 case (2):                  case (2):
                         *fflags |= NO_IGN_MACRO;                          curp->wlevel = MANDOCLEVEL_WARNING;
                         break;                          break;
                 case (3):                  case (3):
                         *fflags |= NO_IGN_CHARS;                          curp->wlevel = MANDOCLEVEL_ERROR;
                         break;                          break;
                 case (4):                  case (4):
                         *fflags |= NO_IGN_ESCAPE |                          curp->wlevel = MANDOCLEVEL_FATAL;
                                    NO_IGN_MACRO | NO_IGN_CHARS;  
                         break;                          break;
                 default:                  default:
                         warnx("bad argument: -f%s", o);                          fprintf(stderr, "-W%s: Bad argument\n", o);
                         return(0);                          return(0);
                 }                  }
         }          }
Line 588  foptions(int *fflags, char *arg)
Line 490  foptions(int *fflags, char *arg)
         return(1);          return(1);
 }  }
   
   static void
 static int  mmsg(enum mandocerr t, enum mandoclevel lvl,
 woptions(int *wflags, char *arg)                  const char *file, int line, int col, const char *msg)
 {  {
         char            *v, *o;  
         char            *toks[3];  
   
         toks[0] = "all";          fprintf(stderr, "%s:%d:%d: %s: %s",
         toks[1] = "error";                          file, line, col + 1,
         toks[2] = NULL;                          mandoclevels[lvl], mandocerrs[t]);
   
         while (*arg) {          if (msg)
                 o = arg;                  fprintf(stderr, ": %s", msg);
                 switch (getsubopt(&arg, toks, &v)) {  
                 case (0):  
                         *wflags |= WARN_WALL;  
                         break;  
                 case (1):  
                         *wflags |= WARN_WERR;  
                         break;  
                 default:  
                         warnx("bad argument: -W%s", o);  
                         return(0);  
                 }  
         }  
   
         return(1);          fputc('\n', stderr);
 }  }
   
   
 /* ARGSUSED */  
 static int  
 merr(void *arg, int line, int col, const char *msg)  
 {  
         struct curparse *curp;  
   
         curp = (struct curparse *)arg;  
   
         warnx("%s:%d: error: %s (column %d)",  
                         curp->file, line, msg, col);  
   
         return(0);  
 }  
   
   
 static int  
 mwarn(void *arg, int line, int col, const char *msg)  
 {  
         struct curparse *curp;  
   
         curp = (struct curparse *)arg;  
   
         if ( ! (curp->wflags & WARN_WALL))  
                 return(1);  
   
         warnx("%s:%d: warning: %s (column %d)",  
                         curp->file, line, msg, col);  
   
         if ( ! (curp->wflags & WARN_WERR))  
                 return(1);  
   
         warnx("considering warnings as errors");  
         return(0);  
 }  
   
Legend:
Removed from v.1.38  
changed lines
  Added in v.1.155
CVSweb