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

Diff for /mandoc/main.c between version 1.25 and 1.33

version 1.25, 2009/04/12 19:45:26 version 1.33, 2009/07/04 09:01:55
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@openbsd.org>   * Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se>
  *   *
  * 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 74  struct curparse {
Line 74  struct curparse {
 #define NO_IGN_ESCAPE    (1 << 1)       /* Don't ignore bad escapes. */  #define NO_IGN_ESCAPE    (1 << 1)       /* Don't ignore bad escapes. */
 #define NO_IGN_MACRO     (1 << 2)       /* Don't ignore bad macros. */  #define NO_IGN_MACRO     (1 << 2)       /* Don't ignore bad macros. */
 #define NO_IGN_CHARS     (1 << 3)       /* Don't ignore bad chars. */  #define NO_IGN_CHARS     (1 << 3)       /* Don't ignore bad chars. */
         enum intt         inttype;      /* Input parsers. */          enum intt         inttype;      /* Input parsers... */
         struct man       *man;          struct man       *man;
         struct man       *lastman;          struct man       *lastman;
         struct mdoc      *mdoc;          struct mdoc      *mdoc;
         struct mdoc      *lastmdoc;          struct mdoc      *lastmdoc;
         enum outt         outtype;      /* Output devices. */          enum outt         outtype;      /* Output devices... */
         out_mdoc          outmdoc;          out_mdoc          outmdoc;
         out_man           outman;          out_man           outman;
         out_free          outfree;          out_free          outfree;
Line 101  static int    merr(void *, int, int, const char *);
Line 101  static int    merr(void *, int, int, const char *);
 static  int               manwarn(void *, int, int, const char *);  static  int               manwarn(void *, int, int, const char *);
 static  int               mdocwarn(void *, int, int,  static  int               mdocwarn(void *, int, int,
                                 enum mdoc_warn, const char *);                                  enum mdoc_warn, const char *);
 static  int               fstdin(struct buf *, struct buf *,  
                                 struct curparse *);  
 static  int               ffile(struct buf *, struct buf *,  static  int               ffile(struct buf *, struct buf *,
                                 const char *, struct curparse *);                                  const char *, struct curparse *);
 static  int               fdesc(struct buf *, struct buf *,  static  int               fdesc(struct buf *, struct buf *,
Line 134  main(int argc, char *argv[])
Line 132  main(int argc, char *argv[])
                 switch (c) {                  switch (c) {
                 case ('f'):                  case ('f'):
                         if ( ! foptions(&curp.fflags, optarg))                          if ( ! foptions(&curp.fflags, optarg))
                                 return(0);                                  return(EXIT_FAILURE);
                         break;                          break;
                 case ('m'):                  case ('m'):
                         if ( ! moptions(&curp.inttype, optarg))                          if ( ! moptions(&curp.inttype, optarg))
                                 return(0);                                  return(EXIT_FAILURE);
                         break;                          break;
                 case ('T'):                  case ('T'):
                         if ( ! toptions(&curp.outtype, optarg))                          if ( ! toptions(&curp.outtype, optarg))
                                 return(0);                                  return(EXIT_FAILURE);
                         break;                          break;
                 case ('W'):                  case ('W'):
                         if ( ! woptions(&curp.wflags, optarg))                          if ( ! woptions(&curp.wflags, optarg))
                                 return(0);                                  return(EXIT_FAILURE);
                         break;                          break;
                 case ('V'):                  case ('V'):
                         version();                          version();
Line 159  main(int argc, char *argv[])
Line 157  main(int argc, char *argv[])
         argc -= optind;          argc -= optind;
         argv += optind;          argv += optind;
   
         /* Configure buffers. */  
   
         bzero(&ln, sizeof(struct buf));          bzero(&ln, sizeof(struct buf));
         bzero(&blk, sizeof(struct buf));          bzero(&blk, sizeof(struct buf));
   
         rc = 1;          rc = 1;
   
         if (NULL == *argv)          if (NULL == *argv) {
                 if ( ! fstdin(&blk, &ln, &curp))                  curp.file = "<stdin>";
                   curp.fd = STDIN_FILENO;
                   if ( ! fdesc(&blk, &ln, &curp))
                         rc = 0;                          rc = 0;
           }
   
         while (rc && *argv) {          while (rc && *argv) {
                 if ( ! ffile(&blk, &ln, *argv, &curp))                  if ( ! ffile(&blk, &ln, *argv, &curp))
Line 231  man_init(struct curparse *curp)
Line 230  man_init(struct curparse *curp)
         mancb.man_err = merr;          mancb.man_err = merr;
         mancb.man_warn = manwarn;          mancb.man_warn = manwarn;
   
         pflags = MAN_IGN_MACRO; /* XXX */          /* Defaults from mandoc.1. */
   
           pflags = MAN_IGN_MACRO | MAN_IGN_ESCAPE | MAN_IGN_CHARS;
   
         if (curp->fflags & NO_IGN_MACRO)          if (curp->fflags & NO_IGN_MACRO)
                 pflags &= ~MAN_IGN_MACRO;                  pflags &= ~MAN_IGN_MACRO;
           if (curp->fflags & NO_IGN_CHARS)
                   pflags &= ~MAN_IGN_CHARS;
           if (curp->fflags & NO_IGN_ESCAPE)
                   pflags &= ~MAN_IGN_ESCAPE;
   
         if (NULL == (man = man_alloc(curp, pflags, &mancb)))          if (NULL == (man = man_alloc(curp, pflags, &mancb)))
                 warnx("memory exhausted");                  warnx("memory exhausted");
Line 250  mdoc_init(struct curparse *curp)
Line 255  mdoc_init(struct curparse *curp)
         struct mdoc     *mdoc;          struct mdoc     *mdoc;
         struct mdoc_cb   mdoccb;          struct mdoc_cb   mdoccb;
   
         mdoccb.mdoc_msg = NULL;  
         mdoccb.mdoc_err = merr;          mdoccb.mdoc_err = merr;
         mdoccb.mdoc_warn = mdocwarn;          mdoccb.mdoc_warn = mdocwarn;
   
           /* Defaults from mandoc.1. */
   
         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 & IGN_SCOPE)
Line 273  mdoc_init(struct curparse *curp)
Line 279  mdoc_init(struct curparse *curp)
   
   
 static int  static int
 fstdin(struct buf *blk, struct buf *ln, struct curparse *curp)  
 {  
   
         curp->file = "<stdin>";  
         curp->fd = STDIN_FILENO;  
         return(fdesc(blk, ln, curp));  
 }  
   
   
 static int  
 ffile(struct buf *blk, struct buf *ln,  ffile(struct buf *blk, struct buf *ln,
                 const char *file, struct curparse *curp)                  const char *file, struct curparse *curp)
 {  {
Line 309  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 305  fdesc(struct buf *blk, struct buf *ln, struct curparse
         size_t           sz;          size_t           sz;
         ssize_t          ssz;          ssize_t          ssz;
         struct stat      st;          struct stat      st;
         int              j, i, pos, lnn;          int              j, i, pos, lnn, comment;
         struct man      *man;          struct man      *man;
         struct mdoc     *mdoc;          struct mdoc     *mdoc;
   
Line 324  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 320  fdesc(struct buf *blk, struct buf *ln, struct curparse
          */           */
   
         if (-1 == fstat(curp->fd, &st))          if (-1 == fstat(curp->fd, &st))
                 warnx("%s", curp->file);                  warn("%s", curp->file);
         else if ((size_t)st.st_blksize > sz)          else if ((size_t)st.st_blksize > sz)
                 sz = st.st_blksize;                  sz = st.st_blksize;
   
Line 339  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 335  fdesc(struct buf *blk, struct buf *ln, struct curparse
   
         /* Fill buf with file blocksize. */          /* Fill buf with file blocksize. */
   
         for (lnn = 0, pos = 0; ; ) {          for (lnn = pos = comment = 0; ; ) {
                 if (-1 == (ssz = read(curp->fd, blk->buf, sz))) {                  if (-1 == (ssz = read(curp->fd, blk->buf, sz))) {
                         warn("%s", curp->file);                          warn("%s", curp->file);
                         return(0);                          return(0);
Line 359  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 355  fdesc(struct buf *blk, struct buf *ln, struct curparse
                         }                          }
   
                         if ('\n' != blk->buf[i]) {                          if ('\n' != blk->buf[i]) {
                                   if (comment)
                                           continue;
                                 ln->buf[pos++] = blk->buf[i];                                  ln->buf[pos++] = blk->buf[i];
   
                                   /* 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;                                  continue;
                         }                          }
   
                         /* Check for CPP-escaped newline.  */                          /* Handle escaped `\\n' newlines. */
   
                         if (pos > 0 && '\\' == ln->buf[pos - 1]) {                          if (pos > 0 && 0 == comment &&
                                           '\\' == ln->buf[pos - 1]) {
                                 for (j = pos - 1; j >= 0; j--)                                  for (j = pos - 1; j >= 0; j--)
                                         if ('\\' != ln->buf[j])                                          if ('\\' != ln->buf[j])
                                                 break;                                                  break;
   
                                 if ( ! ((pos - j) % 2)) {                                  if ( ! ((pos - j) % 2)) {
                                         pos--;                                          pos--;
                                         lnn++;                                          lnn++;
Line 379  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 392  fdesc(struct buf *blk, struct buf *ln, struct curparse
   
                         ln->buf[pos] = 0;                          ln->buf[pos] = 0;
                         lnn++;                          lnn++;
   
                         /*  
                          * If no manual parser has been assigned, then  
                          * try to assign one in pset(), which may do  
                          * nothing at all.  After this, parse the manual  
                          * line accordingly.  
                          */  
   
                           /* If unset, assign parser in pset(). */
   
                         if ( ! (man || mdoc) && ! pset(ln->buf,                          if ( ! (man || mdoc) && ! pset(ln->buf,
                                                 pos, curp, &man, &mdoc))                                                  pos, curp, &man, &mdoc))
                                 return(0);                                  return(0);
   
                         pos = 0;                          pos = comment = 0;
   
                           /* Pass down into parsers. */
   
                         if (man && ! man_parseln(man, lnn, ln->buf))                          if (man && ! man_parseln(man, lnn, ln->buf))
                                 return(0);                                  return(0);
                         if (mdoc && ! mdoc_parseln(mdoc, lnn, ln->buf))                          if (mdoc && ! mdoc_parseln(mdoc, lnn, ln->buf))
Line 400  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 410  fdesc(struct buf *blk, struct buf *ln, struct curparse
                 }                  }
         }          }
   
         /* Note that a parser may not have been assigned, yet. */          /* NOTE a parser may not have been assigned, yet. */
   
         if ( ! (man || mdoc)) {          if ( ! (man || mdoc)) {
                 warnx("%s: not a manual", curp->file);                  warnx("%s: not a manual", curp->file);
Line 412  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 422  fdesc(struct buf *blk, struct buf *ln, struct curparse
         if (man && ! man_endparse(man))          if (man && ! man_endparse(man))
                 return(0);                  return(0);
   
         /*          /* If unset, allocate output dev now (if applicable). */
          * If an output device hasn't been allocated, see if we should  
          * do so now.  Note that not all outtypes have functions, so  
          * this switch statement may be superfluous, but it's  
          * low-overhead enough not to matter very much.  
          */  
   
         if ( ! (curp->outman && curp->outmdoc)) {          if ( ! (curp->outman && curp->outmdoc)) {
                 switch (curp->outtype) {                  switch (curp->outtype) {
Line 453  static int
Line 458  static int
 pset(const char *buf, int pos, struct curparse *curp,  pset(const char *buf, int pos, struct curparse *curp,
                 struct man **man, struct mdoc **mdoc)                  struct man **man, struct mdoc **mdoc)
 {  {
           int              i;
   
         /*          /*
          * Try to intuit which kind of manual parser should be used.  If           * Try to intuit which kind of manual parser should be used.  If
          * passed in by command-line (-man, -mdoc), then use that           * passed in by command-line (-man, -mdoc), then use that
          * explicitly.  If passed as -mandoc, then try to guess from the           * explicitly.  If passed as -mandoc, then try to guess from the
          * line: either skip comments, use -mdoc when finding `.Dt', or           * line: either skip dot-lines, use -mdoc when finding `.Dt', or
          * default to -man, which is more lenient.           * default to -man, which is more lenient.
          */           */
   
         if (pos >= 3 && 0 == memcmp(buf, ".\\\"", 3))          if (buf[0] == '.') {
                 return(1);                  for (i = 1; buf[i]; i++)
                           if (' ' != buf[i] && '\t' != buf[i])
                                   break;
                   if (0 == buf[i])
                           return(1);
           }
   
         switch (curp->inttype) {          switch (curp->inttype) {
         case (INTT_MDOC):          case (INTT_MDOC):
Line 540  toptions(enum outt *tflags, char *arg)
Line 551  toptions(enum outt *tflags, char *arg)
 }  }
   
   
 /*  
  * Parse out the options for [-fopt...] setting compiler options.  These  
  * can be comma-delimited or called again.  
  */  
 static int  static int
 foptions(int *fflags, char *arg)  foptions(int *fflags, char *arg)
 {  {
Line 576  foptions(int *fflags, char *arg)
Line 583  foptions(int *fflags, char *arg)
                                    NO_IGN_MACRO | NO_IGN_CHARS;                                     NO_IGN_MACRO | NO_IGN_CHARS;
                         break;                          break;
                 default:                  default:
                         warnx("bad argument: -f%s", arg);                          warnx("bad argument: -f%s", suboptarg);
                         return(0);                          return(0);
                 }                  }
   
Line 584  foptions(int *fflags, char *arg)
Line 591  foptions(int *fflags, char *arg)
 }  }
   
   
 /*  
  * Parse out the options for [-Werr...], which sets warning modes.  
  * These can be comma-delimited or called again.  
  */  
 static int  static int
 woptions(int *wflags, char *arg)  woptions(int *wflags, char *arg)
 {  {
Line 615  woptions(int *wflags, char *arg)
Line 618  woptions(int *wflags, char *arg)
                         *wflags |= WARN_WERR;                          *wflags |= WARN_WERR;
                         break;                          break;
                 default:                  default:
                         warnx("bad argument: -W%s", arg);                          warnx("bad argument: -W%s", suboptarg);
                         return(0);                          return(0);
                 }                  }
   
Line 630  merr(void *arg, int line, int col, const char *msg)
Line 633  merr(void *arg, int line, int col, const char *msg)
         struct curparse *curp;          struct curparse *curp;
   
         curp = (struct curparse *)arg;          curp = (struct curparse *)arg;
   
         warnx("%s:%d: error: %s (column %d)",          warnx("%s:%d: error: %s (column %d)",
                         curp->file, line, msg, col);                          curp->file, line, msg, col);
   
         return(0);          return(0);
 }  }
   
Line 666  mdocwarn(void *arg, int line, int col, 
Line 669  mdocwarn(void *arg, int line, int col, 
   
         if ( ! (curp->wflags & WARN_WERR))          if ( ! (curp->wflags & WARN_WERR))
                 return(1);                  return(1);
   
         warnx("%s: considering warnings as errors",          warnx("considering warnings as errors");
                         __progname);  
         return(0);          return(0);
 }  }
   
Line 689  manwarn(void *arg, int line, int col, const char *msg)
Line 691  manwarn(void *arg, int line, int col, const char *msg)
         if ( ! (curp->wflags & WARN_WERR))          if ( ! (curp->wflags & WARN_WERR))
                 return(1);                  return(1);
   
         warnx("%s: considering warnings as errors",          warnx("considering warnings as errors");
                         __progname);  
         return(0);          return(0);
 }  }
Legend:
Removed from v.1.25  
changed lines
  Added in v.1.33
CVSweb