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

Diff for /mandoc/main.c between version 1.54 and 1.63

version 1.54, 2009/10/31 06:17:19 version 1.63, 2010/05/14 13:54:15
Line 14 
Line 14 
  * 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.
  */   */
   #ifdef HAVE_CONFIG_H
   #include "config.h"
   #endif
   
 #include <sys/stat.h>  #include <sys/stat.h>
   
 #include <assert.h>  #include <assert.h>
Line 30 
Line 34 
   
 #define UNCONST(a)      ((void *)(uintptr_t)(const void *)(a))  #define UNCONST(a)      ((void *)(uintptr_t)(const void *)(a))
   
 /* Account for FreeBSD and Linux in our declarations. */  /* FIXME: Intel's compiler?  LLVM?  pcc?  */
   
 #ifdef __linux__  #if !defined(__GNUC__) || (__GNUC__ < 2)
 extern  int               getsubopt(char **, char * const *, char **);  # if !defined(lint)
 extern  size_t            strlcat(char *, const char *, size_t);  #  define __attribute__(x)
 # ifndef __dead  
 #  define __dead __attribute__((__noreturn__))  
 # endif  # endif
 #elif defined(__dead2)  #endif /* !defined(__GNUC__) || (__GNUC__ < 2) */
 # ifndef __dead  
 #  define __dead __dead2  
 # endif  
 #endif  
   
 typedef void            (*out_mdoc)(void *, const struct mdoc *);  typedef void            (*out_mdoc)(void *, const struct mdoc *);
 typedef void            (*out_man)(void *, const struct man *);  typedef void            (*out_man)(void *, const struct man *);
Line 63  enum outt {
Line 61  enum outt {
         OUTT_ASCII = 0,          OUTT_ASCII = 0,
         OUTT_TREE,          OUTT_TREE,
         OUTT_HTML,          OUTT_HTML,
           OUTT_XHTML,
         OUTT_LINT          OUTT_LINT
 };  };
   
Line 73  struct curparse {
Line 72  struct curparse {
 #define WARN_WALL        (1 << 0)       /* All-warnings mask. */  #define WARN_WALL        (1 << 0)       /* All-warnings mask. */
 #define WARN_WERR        (1 << 2)       /* Warnings->errors. */  #define WARN_WERR        (1 << 2)       /* Warnings->errors. */
         int               fflags;          int               fflags;
 #define IGN_SCOPE        (1 << 0)       /* Ignore scope errors. */  #define FL_IGN_SCOPE     (1 << 0)       /* Ignore scope errors. */
 #define NO_IGN_ESCAPE    (1 << 1)       /* Don't ignore bad escapes. */  #define FL_NIGN_ESCAPE   (1 << 1)       /* Don't ignore bad escapes. */
 #define NO_IGN_MACRO     (1 << 2)       /* Don't ignore bad macros. */  #define FL_NIGN_MACRO    (1 << 2)       /* Don't ignore bad macros. */
 #define NO_IGN_CHARS     (1 << 3)       /* Don't ignore bad chars. */  #define FL_IGN_ERRORS    (1 << 4)       /* Ignore failed parse. */
 #define IGN_ERRORS       (1 << 4)       /* Ignore failed parse. */  
         enum intt         inttype;      /* Input parsers... */          enum intt         inttype;      /* Input parsers... */
         struct man       *man;          struct man       *man;
         struct man       *lastman;          struct man       *lastman;
Line 91  struct curparse {
Line 89  struct curparse {
         char              outopts[BUFSIZ];          char              outopts[BUFSIZ];
 };  };
   
   #define FL_STRICT         FL_NIGN_ESCAPE | \
                             FL_NIGN_MACRO
   
 static  int               foptions(int *, char *);  static  int               foptions(int *, char *);
 static  int               toptions(enum outt *, char *);  static  int               toptions(struct curparse *, char *);
 static  int               moptions(enum intt *, char *);  static  int               moptions(enum intt *, char *);
 static  int               woptions(int *, char *);  static  int               woptions(int *, char *);
 static  int               merr(void *, int, int, const char *);  static  int               merr(void *, int, int, const char *);
Line 105  static int    pset(const char *, int, struct curparse 
Line 106  static int    pset(const char *, int, struct curparse 
                                 struct man **, struct mdoc **);                                  struct man **, struct mdoc **);
 static  struct man       *man_init(struct curparse *);  static  struct man       *man_init(struct curparse *);
 static  struct mdoc      *mdoc_init(struct curparse *);  static  struct mdoc      *mdoc_init(struct curparse *);
 __dead  static void       version(void);  static  void              version(void) __attribute__((noreturn));
 __dead  static void       usage(void);  static  void              usage(void) __attribute__((noreturn));
   
 static  const char       *progname;  static  const char       *progname;
   
Line 145  main(int argc, char *argv[])
Line 146  main(int argc, char *argv[])
                         (void)strlcat(curp.outopts, ",", BUFSIZ);                          (void)strlcat(curp.outopts, ",", BUFSIZ);
                         break;                          break;
                 case ('T'):                  case ('T'):
                         if ( ! toptions(&curp.outtype, optarg))                          if ( ! toptions(&curp, optarg))
                                 return(EXIT_FAILURE);                                  return(EXIT_FAILURE);
                         break;                          break;
                 case ('W'):                  case ('W'):
Line 173  main(int argc, char *argv[])
Line 174  main(int argc, char *argv[])
                 curp.fd = STDIN_FILENO;                  curp.fd = STDIN_FILENO;
   
                 c = fdesc(&blk, &ln, &curp);                  c = fdesc(&blk, &ln, &curp);
                 if ( ! (IGN_ERRORS & curp.fflags))                  if ( ! (FL_IGN_ERRORS & curp.fflags))
                         rc = 1 == c ? 1 : 0;                          rc = 1 == c ? 1 : 0;
                 else                  else
                         rc = -1 == c ? 0 : 1;                          rc = -1 == c ? 0 : 1;
Line 181  main(int argc, char *argv[])
Line 182  main(int argc, char *argv[])
   
         while (rc && *argv) {          while (rc && *argv) {
                 c = ffile(&blk, &ln, *argv, &curp);                  c = ffile(&blk, &ln, *argv, &curp);
                 if ( ! (IGN_ERRORS & curp.fflags))                  if ( ! (FL_IGN_ERRORS & curp.fflags))
                         rc = 1 == c ? 1 : 0;                          rc = 1 == c ? 1 : 0;
                 else                  else
                         rc = -1 == c ? 0 : 1;                          rc = -1 == c ? 0 : 1;
Line 212  main(int argc, char *argv[])
Line 213  main(int argc, char *argv[])
 }  }
   
   
 __dead static void  static void
 version(void)  version(void)
 {  {
   
Line 221  version(void)
Line 222  version(void)
 }  }
   
   
 __dead static void  static void
 usage(void)  usage(void)
 {  {
   
         (void)fprintf(stderr, "usage: %s [-V] [-foption...] "          (void)fprintf(stderr, "usage: %s [-V] [-foption] "
                         "[-mformat] [-Ooption] [-Toutput] "                          "[-mformat] [-Ooption] [-Toutput] "
                         "[-Werr...]\n", progname);                          "[-Werr] [file...]\n", progname);
         exit(EXIT_FAILURE);          exit(EXIT_FAILURE);
 }  }
   
Line 243  man_init(struct curparse *curp)
Line 244  man_init(struct curparse *curp)
   
         /* Defaults from mandoc.1. */          /* Defaults from mandoc.1. */
   
         pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE | MAN_IGN_CHARS;          pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE;
   
         if (curp->fflags & NO_IGN_MACRO)          if (curp->fflags & FL_NIGN_MACRO)
                 pflags &= ~MAN_IGN_MACRO;                  pflags &= ~MAN_IGN_MACRO;
         if (curp->fflags & NO_IGN_CHARS)          if (curp->fflags & FL_NIGN_ESCAPE)
                 pflags &= ~MAN_IGN_CHARS;  
         if (curp->fflags & NO_IGN_ESCAPE)  
                 pflags &= ~MAN_IGN_ESCAPE;                  pflags &= ~MAN_IGN_ESCAPE;
   
         return(man_alloc(curp, pflags, &mancb));          return(man_alloc(curp, pflags, &mancb));
Line 267  mdoc_init(struct curparse *curp)
Line 266  mdoc_init(struct curparse *curp)
   
         /* Defaults from mandoc.1. */          /* Defaults from mandoc.1. */
   
         pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE | MDOC_IGN_CHARS;          pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE;
   
         if (curp->fflags & IGN_SCOPE)          if (curp->fflags & FL_IGN_SCOPE)
                 pflags |= MDOC_IGN_SCOPE;                  pflags |= MDOC_IGN_SCOPE;
         if (curp->fflags & NO_IGN_ESCAPE)          if (curp->fflags & FL_NIGN_ESCAPE)
                 pflags &= ~MDOC_IGN_ESCAPE;                  pflags &= ~MDOC_IGN_ESCAPE;
         if (curp->fflags & NO_IGN_MACRO)          if (curp->fflags & FL_NIGN_MACRO)
                 pflags &= ~MDOC_IGN_MACRO;                  pflags &= ~MDOC_IGN_MACRO;
         if (curp->fflags & NO_IGN_CHARS)  
                 pflags &= ~MDOC_IGN_CHARS;  
   
         return(mdoc_alloc(curp, pflags, &mdoccb));          return(mdoc_alloc(curp, pflags, &mdoccb));
 }  }
Line 377  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 374  fdesc(struct buf *blk, struct buf *ln, struct curparse
   
                                 comment = 1;                                  comment = 1;
                                 pos -= 2;                                  pos -= 2;
                                   for (; pos > 0; --pos) {
                                           if (ln->buf[pos - 1] != ' ')
                                                   break;
                                           if (pos > 2 && ln->buf[pos - 2] == '\\')
                                                   break;
                                   }
                                 continue;                                  continue;
                         }                          }
   
Line 430  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 433  fdesc(struct buf *blk, struct buf *ln, struct curparse
   
         if ( ! (curp->outman && curp->outmdoc)) {          if ( ! (curp->outman && curp->outmdoc)) {
                 switch (curp->outtype) {                  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):                  case (OUTT_HTML):
                         curp->outdata = html_alloc(curp->outopts);                          curp->outdata = html_alloc(curp->outopts);
                         curp->outman = html_man;                          curp->outman = html_man;
Line 532  moptions(enum intt *tflags, char *arg)
Line 541  moptions(enum intt *tflags, char *arg)
         else if (0 == strcmp(arg, "an"))          else if (0 == strcmp(arg, "an"))
                 *tflags = INTT_MAN;                  *tflags = INTT_MAN;
         else {          else {
                 fprintf(stderr, "%s: Bad argument", arg);                  fprintf(stderr, "%s: Bad argument\n", arg);
                 return(0);                  return(0);
         }          }
   
Line 541  moptions(enum intt *tflags, char *arg)
Line 550  moptions(enum intt *tflags, char *arg)
   
   
 static int  static int
 toptions(enum outt *tflags, char *arg)  toptions(struct curparse *curp, char *arg)
 {  {
   
         if (0 == strcmp(arg, "ascii"))          if (0 == strcmp(arg, "ascii"))
                 *tflags = OUTT_ASCII;                  curp->outtype = OUTT_ASCII;
         else if (0 == strcmp(arg, "lint"))          else if (0 == strcmp(arg, "lint")) {
                 *tflags = OUTT_LINT;                  curp->outtype = OUTT_LINT;
                   curp->wflags |= WARN_WALL;
                   curp->fflags |= FL_STRICT;
           }
         else if (0 == strcmp(arg, "tree"))          else if (0 == strcmp(arg, "tree"))
                 *tflags = OUTT_TREE;                  curp->outtype = OUTT_TREE;
         else if (0 == strcmp(arg, "html"))          else if (0 == strcmp(arg, "html"))
                 *tflags = OUTT_HTML;                  curp->outtype = OUTT_HTML;
           else if (0 == strcmp(arg, "xhtml"))
                   curp->outtype = OUTT_XHTML;
         else {          else {
                 fprintf(stderr, "%s: Bad argument", arg);                  fprintf(stderr, "%s: Bad argument\n", arg);
                 return(0);                  return(0);
         }          }
   
Line 570  foptions(int *fflags, char *arg)
Line 584  foptions(int *fflags, char *arg)
         toks[0] = "ign-scope";          toks[0] = "ign-scope";
         toks[1] = "no-ign-escape";          toks[1] = "no-ign-escape";
         toks[2] = "no-ign-macro";          toks[2] = "no-ign-macro";
         toks[3] = "no-ign-chars";          toks[3] = "ign-errors";
         toks[4] = "ign-errors";          toks[4] = "strict";
         toks[5] = "strict";          toks[5] = "ign-escape";
         toks[6] = "ign-escape";          toks[6] = NULL;
         toks[7] = NULL;  
   
         while (*arg) {          while (*arg) {
                 o = arg;                  o = arg;
                 switch (getsubopt(&arg, UNCONST(toks), &v)) {                  switch (getsubopt(&arg, UNCONST(toks), &v)) {
                 case (0):                  case (0):
                         *fflags |= IGN_SCOPE;                          *fflags |= FL_IGN_SCOPE;
                         break;                          break;
                 case (1):                  case (1):
                         *fflags |= NO_IGN_ESCAPE;                          *fflags |= FL_NIGN_ESCAPE;
                         break;                          break;
                 case (2):                  case (2):
                         *fflags |= NO_IGN_MACRO;                          *fflags |= FL_NIGN_MACRO;
                         break;                          break;
                 case (3):                  case (3):
                         *fflags |= NO_IGN_CHARS;                          *fflags |= FL_IGN_ERRORS;
                         break;                          break;
                 case (4):                  case (4):
                         *fflags |= IGN_ERRORS;                          *fflags |= FL_STRICT;
                         break;                          break;
                 case (5):                  case (5):
                         *fflags |= NO_IGN_ESCAPE |                          *fflags &= ~FL_NIGN_ESCAPE;
                                    NO_IGN_MACRO | NO_IGN_CHARS;  
                         break;                          break;
                 case (6):  
                         *fflags &= ~NO_IGN_ESCAPE;  
                         break;  
                 default:                  default:
                         fprintf(stderr, "%s: Bad argument", o);                          fprintf(stderr, "%s: Bad argument\n", o);
                         return(0);                          return(0);
                 }                  }
         }          }
Line 631  woptions(int *wflags, char *arg)
Line 640  woptions(int *wflags, char *arg)
                         *wflags |= WARN_WERR;                          *wflags |= WARN_WERR;
                         break;                          break;
                 default:                  default:
                         fprintf(stderr, "%s: Bad argument", o);                          fprintf(stderr, "%s: Bad argument\n", o);
                         return(0);                          return(0);
                 }                  }
         }          }
Legend:
Removed from v.1.54  
changed lines
  Added in v.1.63
CVSweb