Allow `Bd' to accept (warn about then ignore) in-line arguments.

[mandoc.git] / main.c

diff --git a/main.c b/main.c
index 9a52d80737aec0a5e1055c95bfe95bc78d48a9fd..795c6493236ef28b8aa28a9dd6ba2be15d150632 100644 (file)
--- a/main.c
+++ b/main.c
@@ -1,4 +1,4 @@
-/*     $Id: main.c,v 1.41 2009/07/28 10:15:12 kristaps Exp $ */
+/*     $Id: main.c,v 1.60 2010/03/22 20:43:00 kristaps Exp $ */

 /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *
 /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *


@@ -14,34 +14,36 @@
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */

+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+

 #include <sys/stat.h>
 
 #include <assert.h>
 #include <sys/stat.h>
 
 #include <assert.h>

-#include <err.h>

 #include <fcntl.h>
 #include <stdio.h>
 #include <fcntl.h>
 #include <stdio.h>

+#include <stdint.h>

 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "mdoc.h"
 #include "man.h"
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "mdoc.h"
 #include "man.h"

+#include "main.h"

 
 

-/* Account for FreeBSD and Linux in our declarations. */
+#define        UNCONST(a)      ((void *)(uintptr_t)(const void *)(a))

 
 

-#ifdef __linux__
-extern int               getsubopt(char **, char * const *, char **);
-# ifndef __dead
-#  define __dead __attribute__((__noreturn__))
-# endif
-#elif defined(__dead2)
-# ifndef __dead
-#  define __dead __dead2
+/* FIXME: Intel's compiler?  LLVM?  pcc?  */
+
+#if !defined(__GNUC__) || (__GNUC__ < 2)
+# if !defined(lint)
+#  define __attribute__(x)

 # endif
 # endif

-#endif
+#endif /* !defined(__GNUC__) || (__GNUC__ < 2) */

 
 

-typedef        int             (*out_mdoc)(void *, const struct mdoc *);
-typedef        int             (*out_man)(void *, const struct man *);
+typedef        void            (*out_mdoc)(void *, const struct mdoc *);
+typedef        void            (*out_man)(void *, const struct man *);

 typedef        void            (*out_free)(void *);
 
 struct buf {
 typedef        void            (*out_free)(void *);
 
 struct buf {


@@ -58,6 +60,8 @@ enum  intt {
 enum   outt {
        OUTT_ASCII = 0,
        OUTT_TREE,
 enum   outt {
        OUTT_ASCII = 0,
        OUTT_TREE,

+       OUTT_HTML,
+       OUTT_XHTML,

        OUTT_LINT
 };
 
        OUTT_LINT
 };
 


@@ -68,11 +72,11 @@ struct      curparse {
 #define        WARN_WALL        (1 << 0)       /* All-warnings mask. */
 #define        WARN_WERR        (1 << 2)       /* Warnings->errors. */
        int               fflags;
 #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. */
-#define        IGN_ERRORS       (1 << 4)       /* Ignore failed parse. */
+#define        FL_IGN_SCOPE     (1 << 0)       /* Ignore scope errors. */
+#define        FL_NIGN_ESCAPE   (1 << 1)       /* Don't ignore bad escapes. */
+#define        FL_NIGN_MACRO    (1 << 2)       /* Don't ignore bad macros. */
+#define        FL_NIGN_CHARS    (1 << 3)       /* Don't ignore bad chars. */
+#define        FL_IGN_ERRORS    (1 << 4)       /* Ignore failed parse. */

        enum intt         inttype;      /* Input parsers... */
        struct man       *man;
        struct man       *lastman;
        enum intt         inttype;      /* Input parsers... */
        struct man       *man;
        struct man       *lastman;


@@ -83,17 +87,15 @@ struct      curparse {
        out_man           outman;
        out_free          outfree;
        void             *outdata;
        out_man           outman;
        out_free          outfree;
        void             *outdata;

+       char              outopts[BUFSIZ];

 };
 
 };
 

-extern void             *ascii_alloc(void);
-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 *);
+#define        FL_STRICT         FL_NIGN_ESCAPE | \
+                         FL_NIGN_MACRO | \
+                         FL_NIGN_CHARS

 
 static int               foptions(int *, char *);
 
 static int               foptions(int *, char *);

-static int               toptions(enum outt *, char *);
+static int               toptions(struct curparse *, char *);

 static int               moptions(enum intt *, char *);
 static int               woptions(int *, char *);
 static int               merr(void *, int, int, const char *);
 static int               moptions(enum intt *, char *);
 static int               woptions(int *, char *);
 static int               merr(void *, int, int, const char *);


@@ -106,10 +108,10 @@ 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 *);
                                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);
+static void              version(void) __attribute__((noreturn));
+static void              usage(void) __attribute__((noreturn));

 
 

-extern char             *__progname;
+static const char       *progname;

 
 
 int
 
 
 int


@@ -119,13 +121,19 @@ main(int argc, char *argv[])
        struct buf       ln, blk;
        struct curparse  curp;
 
        struct buf       ln, blk;
        struct curparse  curp;
 

-       bzero(&curp, sizeof(struct curparse));
+       progname = strrchr(argv[0], '/');
+       if (progname == NULL)
+               progname = argv[0];
+       else
+               ++progname;
+
+       memset(&curp, 0, sizeof(struct curparse));

 
        curp.inttype = INTT_AUTO;
        curp.outtype = OUTT_ASCII;
 
        /* LINTED */
 
        curp.inttype = INTT_AUTO;
        curp.outtype = OUTT_ASCII;
 
        /* LINTED */

-       while (-1 != (c = getopt(argc, argv, "f:m:VW:T:")))
+       while (-1 != (c = getopt(argc, argv, "f:m:O:T:VW:")))

                switch (c) {
                case ('f'):
                        if ( ! foptions(&curp.fflags, optarg))
                switch (c) {
                case ('f'):
                        if ( ! foptions(&curp.fflags, optarg))


@@ -135,8 +143,12 @@ main(int argc, char *argv[])
                        if ( ! moptions(&curp.inttype, optarg))
                                return(EXIT_FAILURE);
                        break;
                        if ( ! moptions(&curp.inttype, optarg))
                                return(EXIT_FAILURE);
                        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);
                        break;
                case ('W'):
                                return(EXIT_FAILURE);
                        break;
                case ('W'):


@@ -154,8 +166,8 @@ main(int argc, char *argv[])
        argc -= optind;
        argv += optind;
 
        argc -= optind;
        argv += optind;
 

-       bzero(&ln, sizeof(struct buf));
-       bzero(&blk, sizeof(struct buf));
+       memset(&ln, 0, sizeof(struct buf));
+       memset(&blk, 0, sizeof(struct buf));

 
        rc = 1;
 
 
        rc = 1;
 


@@ -164,7 +176,7 @@ main(int argc, char *argv[])
                curp.fd = STDIN_FILENO;
 
                c = fdesc(&blk, &ln, &curp);
                curp.fd = STDIN_FILENO;
 
                c = fdesc(&blk, &ln, &curp);

-               if ( ! (IGN_ERRORS & curp.fflags)) 
+               if ( ! (FL_IGN_ERRORS & curp.fflags)) 

                        rc = 1 == c ? 1 : 0;
                else
                        rc = -1 == c ? 0 : 1;
                        rc = 1 == c ? 1 : 0;
                else
                        rc = -1 == c ? 0 : 1;


@@ -172,7 +184,7 @@ main(int argc, char *argv[])
 
        while (rc && *argv) {
                c = ffile(&blk, &ln, *argv, &curp);
 
        while (rc && *argv) {
                c = ffile(&blk, &ln, *argv, &curp);

-               if ( ! (IGN_ERRORS & curp.fflags)) 
+               if ( ! (FL_IGN_ERRORS & curp.fflags)) 

                        rc = 1 == c ? 1 : 0;
                else
                        rc = -1 == c ? 0 : 1;
                        rc = 1 == c ? 1 : 0;
                else
                        rc = -1 == c ? 0 : 1;


@@ -180,11 +192,9 @@ main(int argc, char *argv[])
                argv++;
                if (*argv && rc) {
                        if (curp.lastman)
                argv++;
                if (*argv && rc) {
                        if (curp.lastman)

-                               if ( ! man_reset(curp.lastman))
-                                       rc = 0;
+                               man_reset(curp.lastman);

                        if (curp.lastmdoc)
                        if (curp.lastmdoc)

-                               if ( ! mdoc_reset(curp.lastmdoc))
-                                       rc = 0;
+                               mdoc_reset(curp.lastmdoc);

                        curp.lastman = NULL;
                        curp.lastmdoc = NULL;
                }
                        curp.lastman = NULL;
                        curp.lastmdoc = NULL;
                }


@@ -205,22 +215,22 @@ main(int argc, char *argv[])
 }
 
 
 }
 
 

-__dead static void
+static void

 version(void)
 {
 
 version(void)
 {
 

-       (void)printf("%s %s\n", __progname, VERSION);
+       (void)printf("%s %s\n", progname, VERSION);

        exit(EXIT_SUCCESS);
 }
 
 
        exit(EXIT_SUCCESS);
 }
 
 

-__dead static void
+static void

 usage(void)
 {
 
        (void)fprintf(stderr, "usage: %s [-V] [-foption...] "
 usage(void)
 {
 
        (void)fprintf(stderr, "usage: %s [-V] [-foption...] "

-                       "[-mformat] [-Toutput] [-Werr...]\n", 
-                       __progname);
+                       "[-mformat] [-Ooption] [-Toutput] "
+                       "[-Werr...]\n", progname);

        exit(EXIT_FAILURE);
 }
 
        exit(EXIT_FAILURE);
 }
 


@@ -229,7 +239,6 @@ static struct man *
 man_init(struct curparse *curp)
 {
        int              pflags;
 man_init(struct curparse *curp)
 {
        int              pflags;

-       struct man      *man;

        struct man_cb    mancb;
 
        mancb.man_err = merr;
        struct man_cb    mancb;
 
        mancb.man_err = merr;


@@ -239,17 +248,14 @@ man_init(struct curparse *curp)
 
        pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE | MAN_IGN_CHARS;
 
 
        pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE | MAN_IGN_CHARS;
 

-       if (curp->fflags & NO_IGN_MACRO)
+       if (curp->fflags & FL_NIGN_MACRO)

                pflags &= ~MAN_IGN_MACRO;
                pflags &= ~MAN_IGN_MACRO;

-       if (curp->fflags & NO_IGN_CHARS)
+       if (curp->fflags & FL_NIGN_CHARS)

                pflags &= ~MAN_IGN_CHARS;
                pflags &= ~MAN_IGN_CHARS;

-       if (curp->fflags & NO_IGN_ESCAPE)
+       if (curp->fflags & FL_NIGN_ESCAPE)

                pflags &= ~MAN_IGN_ESCAPE;
 
                pflags &= ~MAN_IGN_ESCAPE;
 

-       if (NULL == (man = man_alloc(curp, pflags, &mancb)))
-               warnx("memory exhausted");
-
-       return(man);
+       return(man_alloc(curp, pflags, &mancb));

 }
 
 
 }
 
 


@@ -257,7 +263,6 @@ static struct mdoc *
 mdoc_init(struct curparse *curp)
 {
        int              pflags;
 mdoc_init(struct curparse *curp)
 {
        int              pflags;

-       struct mdoc     *mdoc;

        struct mdoc_cb   mdoccb;
 
        mdoccb.mdoc_err = merr;
        struct mdoc_cb   mdoccb;
 
        mdoccb.mdoc_err = merr;


@@ -267,19 +272,16 @@ mdoc_init(struct curparse *curp)
 
        pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE | MDOC_IGN_CHARS;
 
 
        pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE | MDOC_IGN_CHARS;
 

-       if (curp->fflags & IGN_SCOPE)
+       if (curp->fflags & FL_IGN_SCOPE)

                pflags |= MDOC_IGN_SCOPE;
                pflags |= MDOC_IGN_SCOPE;

-       if (curp->fflags & NO_IGN_ESCAPE)
+       if (curp->fflags & FL_NIGN_ESCAPE)

                pflags &= ~MDOC_IGN_ESCAPE;
                pflags &= ~MDOC_IGN_ESCAPE;

-       if (curp->fflags & NO_IGN_MACRO)
+       if (curp->fflags & FL_NIGN_MACRO)

                pflags &= ~MDOC_IGN_MACRO;
                pflags &= ~MDOC_IGN_MACRO;

-       if (curp->fflags & NO_IGN_CHARS)
+       if (curp->fflags & FL_NIGN_CHARS)

                pflags &= ~MDOC_IGN_CHARS;
 
                pflags &= ~MDOC_IGN_CHARS;
 

-       if (NULL == (mdoc = mdoc_alloc(curp, pflags, &mdoccb)))
-               warnx("memory exhausted");
-
-       return(mdoc);
+       return(mdoc_alloc(curp, pflags, &mdoccb));

 }
 
 
 }
 
 


@@ -291,14 +293,14 @@ ffile(struct buf *blk, struct buf *ln,
 
        curp->file = file;
        if (-1 == (curp->fd = open(curp->file, O_RDONLY, 0))) {
 
        curp->file = file;
        if (-1 == (curp->fd = open(curp->file, O_RDONLY, 0))) {

-               warn("%s", curp->file);
+               perror(curp->file);

                return(-1);
        }
 
        c = fdesc(blk, ln, curp);
 
        if (-1 == close(curp->fd))
                return(-1);
        }
 
        c = fdesc(blk, ln, curp);
 
        if (-1 == close(curp->fd))

-               warn("%s", curp->file);
+               perror(curp->file);

 
        return(c);
 }
 
        return(c);
 }


@@ -325,15 +327,15 @@ fdesc(struct buf *blk, struct buf *ln, struct curparse *curp)
         */
 
        if (-1 == fstat(curp->fd, &st))
         */
 
        if (-1 == fstat(curp->fd, &st))

-               warn("%s", curp->file);
+               perror(curp->file);

        else if ((size_t)st.st_blksize > sz)
                sz = st.st_blksize;
 
        if (sz > blk->sz) {
                blk->buf = realloc(blk->buf, sz);
                if (NULL == blk->buf) {
        else if ((size_t)st.st_blksize > sz)
                sz = st.st_blksize;
 
        if (sz > blk->sz) {
                blk->buf = realloc(blk->buf, sz);
                if (NULL == blk->buf) {

-                       warn("realloc");
-                       return(-1);
+                       perror(NULL);
+                       exit(EXIT_FAILURE);

                }
                blk->sz = sz;
        }
                }
                blk->sz = sz;
        }


@@ -342,7 +344,7 @@ fdesc(struct buf *blk, struct buf *ln, struct curparse *curp)
 
        for (lnn = pos = comment = 0; ; ) {
                if (-1 == (ssz = read(curp->fd, blk->buf, sz))) {
 
        for (lnn = pos = comment = 0; ; ) {
                if (-1 == (ssz = read(curp->fd, blk->buf, sz))) {

-                       warn("%s", curp->file);
+                       perror(curp->file);

                        return(-1);
                } else if (0 == ssz) 
                        break;
                        return(-1);
                } else if (0 == ssz) 
                        break;


@@ -354,8 +356,8 @@ fdesc(struct buf *blk, struct buf *ln, struct curparse *curp)
                                ln->sz += 256; /* Step-size. */
                                ln->buf = realloc(ln->buf, ln->sz);
                                if (NULL == ln->buf) {
                                ln->sz += 256; /* Step-size. */
                                ln->buf = realloc(ln->buf, ln->sz);
                                if (NULL == ln->buf) {

-                                       warn("realloc");
-                                       return(-1);
+                                       perror(NULL);
+                                       return(EXIT_FAILURE);

                                }
                        }
 
                                }
                        }
 


@@ -418,8 +420,7 @@ fdesc(struct buf *blk, struct buf *ln, struct curparse *curp)
        /* NOTE a parser may not have been assigned, yet. */
 
        if ( ! (man || mdoc)) {
        /* NOTE a parser may not have been assigned, yet. */
 
        if ( ! (man || mdoc)) {

-               (void)fprintf(stderr, "%s: not a manual\n", 
-                               curp->file);
+               fprintf(stderr, "%s: Not a manual\n", curp->file);

                return(0);
        }
 
                return(0);
        }
 


@@ -432,6 +433,18 @@ fdesc(struct buf *blk, struct buf *ln, struct curparse *curp)
 
        if ( ! (curp->outman && curp->outmdoc)) {
                switch (curp->outtype) {
 
        if ( ! (curp->outman && curp->outmdoc)) {
                switch (curp->outtype) {

+               case (OUTT_XHTML):
+                       curp->outdata = xhtml_alloc(curp->outopts);
+                       curp->outman = html_man;
+                       curp->outmdoc = html_mdoc;
+                       curp->outfree = html_free;
+                       break;
+               case (OUTT_HTML):
+                       curp->outdata = html_alloc(curp->outopts);
+                       curp->outman = html_man;
+                       curp->outmdoc = html_mdoc;
+                       curp->outfree = html_free;
+                       break;

                case (OUTT_TREE):
                        curp->outman = tree_man;
                        curp->outmdoc = tree_mdoc;
                case (OUTT_TREE):
                        curp->outman = tree_man;
                        curp->outmdoc = tree_mdoc;


@@ -450,11 +463,9 @@ fdesc(struct buf *blk, struct buf *ln, struct curparse *curp)
        /* Execute the out device, if it exists. */
 
        if (man && curp->outman)
        /* Execute the out device, if it exists. */
 
        if (man && curp->outman)

-               if ( ! (*curp->outman)(curp->outdata, man))
-                       return(-1);
+               (*curp->outman)(curp->outdata, man);

        if (mdoc && curp->outmdoc)
        if (mdoc && curp->outmdoc)

-               if ( ! (*curp->outmdoc)(curp->outdata, mdoc))
-                       return(-1);
+               (*curp->outmdoc)(curp->outdata, mdoc);

 
        return(1);
 }
 
        return(1);
 }


@@ -530,7 +541,7 @@ moptions(enum intt *tflags, char *arg)
        else if (0 == strcmp(arg, "an"))
                *tflags = INTT_MAN;
        else {
        else if (0 == strcmp(arg, "an"))
                *tflags = INTT_MAN;
        else {

-               warnx("bad argument: -m%s", arg);
+               fprintf(stderr, "%s: Bad argument\n", arg);

                return(0);
        }
 
                return(0);
        }
 


@@ -539,17 +550,24 @@ moptions(enum intt *tflags, char *arg)
 
 
 static int
 
 
 static int

-toptions(enum outt *tflags, char *arg)
+toptions(struct curparse *curp, char *arg)

 {
 
        if (0 == strcmp(arg, "ascii"))
 {
 
        if (0 == strcmp(arg, "ascii"))

-               *tflags = OUTT_ASCII;
-       else if (0 == strcmp(arg, "lint"))
-               *tflags = OUTT_LINT;
+               curp->outtype = OUTT_ASCII;
+       else if (0 == strcmp(arg, "lint")) {
+               curp->outtype = OUTT_LINT;
+               curp->wflags |= WARN_WALL;
+               curp->fflags |= FL_STRICT;
+       }

        else if (0 == strcmp(arg, "tree"))
        else if (0 == strcmp(arg, "tree"))

-               *tflags = OUTT_TREE;
+               curp->outtype = OUTT_TREE;
+       else if (0 == strcmp(arg, "html"))
+               curp->outtype = OUTT_HTML;
+       else if (0 == strcmp(arg, "xhtml"))
+               curp->outtype = OUTT_XHTML;

        else {
        else {

-               warnx("bad argument: -T%s", arg);
+               fprintf(stderr, "%s: Bad argument\n", arg);

                return(0);
        }
 
                return(0);
        }
 


@@ -561,7 +579,7 @@ static int
 foptions(int *fflags, char *arg)
 {
        char            *v, *o;
 foptions(int *fflags, char *arg)
 {
        char            *v, *o;

-       char            *toks[7];
+       const char      *toks[8];

 
        toks[0] = "ign-scope";
        toks[1] = "no-ign-escape";
 
        toks[0] = "ign-scope";
        toks[1] = "no-ign-escape";


@@ -569,32 +587,35 @@ foptions(int *fflags, char *arg)
        toks[3] = "no-ign-chars";
        toks[4] = "ign-errors";
        toks[5] = "strict";
        toks[3] = "no-ign-chars";
        toks[4] = "ign-errors";
        toks[5] = "strict";

-       toks[6] = NULL;
+       toks[6] = "ign-escape";
+       toks[7] = NULL;

 
        while (*arg) {
                o = arg;
 
        while (*arg) {
                o = arg;

-               switch (getsubopt(&arg, toks, &v)) {
+               switch (getsubopt(&arg, UNCONST(toks), &v)) {

                case (0):
                case (0):

-                       *fflags |= IGN_SCOPE;
+                       *fflags |= FL_IGN_SCOPE;

                        break;
                case (1):
                        break;
                case (1):

-                       *fflags |= NO_IGN_ESCAPE;
+                       *fflags |= FL_NIGN_ESCAPE;

                        break;
                case (2):
                        break;
                case (2):

-                       *fflags |= NO_IGN_MACRO;
+                       *fflags |= FL_NIGN_MACRO;

                        break;
                case (3):
                        break;
                case (3):

-                       *fflags |= NO_IGN_CHARS;
+                       *fflags |= FL_NIGN_CHARS;

                        break;
                case (4):
                        break;
                case (4):

-                       *fflags |= IGN_ERRORS;
+                       *fflags |= FL_IGN_ERRORS;

                        break;
                case (5):
                        break;
                case (5):

-                       *fflags |= NO_IGN_ESCAPE | 
-                                  NO_IGN_MACRO | NO_IGN_CHARS;
+                       *fflags |= FL_STRICT;
+                       break;
+               case (6):
+                       *fflags &= ~FL_NIGN_ESCAPE;

                        break;
                default:
                        break;
                default:

-                       warnx("bad argument: -f%s", o);
+                       fprintf(stderr, "%s: Bad argument\n", o);

                        return(0);
                }
        }
                        return(0);
                }
        }


@@ -607,7 +628,7 @@ static int
 woptions(int *wflags, char *arg)
 {
        char            *v, *o;
 woptions(int *wflags, char *arg)
 {
        char            *v, *o;

-       char            *toks[3]; 
+       const char      *toks[3]; 

 
        toks[0] = "all";
        toks[1] = "error";
 
        toks[0] = "all";
        toks[1] = "error";


@@ -615,7 +636,7 @@ woptions(int *wflags, char *arg)
 
        while (*arg) {
                o = arg;
 
        while (*arg) {
                o = arg;

-               switch (getsubopt(&arg, toks, &v)) {
+               switch (getsubopt(&arg, UNCONST(toks), &v)) {

                case (0):
                        *wflags |= WARN_WALL;
                        break;
                case (0):
                        *wflags |= WARN_WALL;
                        break;


@@ -623,7 +644,7 @@ woptions(int *wflags, char *arg)
                        *wflags |= WARN_WERR;
                        break;
                default:
                        *wflags |= WARN_WERR;
                        break;
                default:

-                       warnx("bad argument: -W%s", o);
+                       fprintf(stderr, "%s: Bad argument\n", o);

                        return(0);
                }
        }
                        return(0);
                }
        }