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

Diff for /mandoc/main.c between version 1.23 and 1.29

version 1.23, 2009/04/03 12:27:18 version 1.29, 2009/06/16 19:13:28
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   * purpose with or without fee is hereby granted, provided that the above
  * above copyright notice and this permission notice appear in all   * copyright notice and this permission notice appear in all copies.
  * copies.  
  *   *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED   * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  * PERFORMANCE OF THIS SOFTWARE.  
  */   */
 #include <sys/stat.h>  #include <sys/stat.h>
   
Line 73  struct curparse {
Line 71  struct curparse {
 #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 IGN_SCOPE        (1 << 0)       /* Ignore scope errors. */
 #define IGN_ESCAPE       (1 << 1)       /* Ignore bad escapes. */  #define NO_IGN_ESCAPE    (1 << 1)       /* Don't ignore bad escapes. */
 #define IGN_MACRO        (1 << 2)       /* Ignore unknown macros. */  #define NO_IGN_MACRO     (1 << 2)       /* Don't ignore bad macros. */
 #define NO_IGN_MACRO     (1 << 3)  #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 192  main(int argc, char *argv[])
Line 190  main(int argc, char *argv[])
                 free(blk.buf);                  free(blk.buf);
         if (ln.buf)          if (ln.buf)
                 free(ln.buf);                  free(ln.buf);
   
           /* TODO: have a curp_free routine. */
         if (curp.outfree)          if (curp.outfree)
                 (*curp.outfree)(curp.outdata);                  (*curp.outfree)(curp.outdata);
         if (curp.mdoc)          if (curp.mdoc)
Line 233  man_init(struct curparse *curp)
Line 233  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 */          /*
            * Default behaviour is to ignore unknown macros.  This is
            * specified in mandoc.1.
            */
   
           pflags = MAN_IGN_MACRO;
   
           /* Override default behaviour... */
   
         if (curp->fflags & NO_IGN_MACRO)          if (curp->fflags & NO_IGN_MACRO)
                 pflags &= ~MAN_IGN_MACRO;                  pflags &= ~MAN_IGN_MACRO;
   
Line 252  mdoc_init(struct curparse *curp)
Line 259  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;
   
         pflags = 0; /* XXX */          /*
            * Default behaviour is to ignore unknown macros, escape
            * sequences and characters (very liberal).  This is specified
            * in mandoc.1.
            */
   
           pflags = MDOC_IGN_MACRO | MDOC_IGN_ESCAPE | MDOC_IGN_CHARS;
   
           /* Override default behaviour... */
   
         if (curp->fflags & IGN_SCOPE)          if (curp->fflags & IGN_SCOPE)
                 pflags |= MDOC_IGN_SCOPE;                  pflags |= MDOC_IGN_SCOPE;
         if (curp->fflags & IGN_ESCAPE)          if (curp->fflags & NO_IGN_ESCAPE)
                 pflags |= MDOC_IGN_ESCAPE;                  pflags &= ~MDOC_IGN_ESCAPE;
         if (curp->fflags & IGN_MACRO)          if (curp->fflags & NO_IGN_MACRO)
                 pflags |= MDOC_IGN_MACRO;                  pflags &= ~MDOC_IGN_MACRO;
           if (curp->fflags & NO_IGN_CHARS)
                   pflags &= ~MDOC_IGN_CHARS;
   
         if (NULL == (mdoc = mdoc_alloc(curp, pflags, &mdoccb)))          if (NULL == (mdoc = mdoc_alloc(curp, pflags, &mdoccb)))
                 warnx("memory allocated");                  warnx("memory exhausted");
   
         return(mdoc);          return(mdoc);
 }  }
Line 309  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 325  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 339  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 355  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 375  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 412  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;
   
                         if (man && ! man_parseln(man, lnn, ln->buf))                          if (man && ! man_parseln(man, lnn, ln->buf))
                                 return(0);                                  return(0);
Line 400  fdesc(struct buf *blk, struct buf *ln, struct curparse
Line 428  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 440  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 476  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
Line 462  pset(const char *buf, int pos, struct curparse *curp,
Line 486  pset(const char *buf, int pos, struct curparse *curp,
          * 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 548  static int
Line 577  static int
 foptions(int *fflags, char *arg)  foptions(int *fflags, char *arg)
 {  {
         char            *v;          char            *v;
         char            *toks[5];          char            *toks[6];
   
         toks[0] = "ign-scope";          toks[0] = "ign-scope";
         toks[1] = "ign-escape";          toks[1] = "no-ign-escape";
         toks[2] = "ign-macro";          toks[2] = "no-ign-macro";
         toks[3] = "no-ign-macro";          toks[3] = "no-ign-chars";
         toks[4] = NULL;          toks[4] = "strict";
           toks[5] = NULL;
   
         while (*arg)          while (*arg)
                 switch (getsubopt(&arg, toks, &v)) {                  switch (getsubopt(&arg, toks, &v)) {
Line 562  foptions(int *fflags, char *arg)
Line 592  foptions(int *fflags, char *arg)
                         *fflags |= IGN_SCOPE;                          *fflags |= IGN_SCOPE;
                         break;                          break;
                 case (1):                  case (1):
                         *fflags |= IGN_ESCAPE;                          *fflags |= NO_IGN_ESCAPE;
                         break;                          break;
                 case (2):                  case (2):
                         *fflags |= IGN_MACRO;                          *fflags |= NO_IGN_MACRO;
                         break;                          break;
                 case (3):                  case (3):
                         *fflags |= NO_IGN_MACRO;                          *fflags |= NO_IGN_CHARS;
                         break;                          break;
                   case (4):
                           *fflags |= NO_IGN_ESCAPE |
                                      NO_IGN_MACRO | NO_IGN_CHARS;
                           break;
                 default:                  default:
                         warnx("bad argument: -f%s", arg);                          warnx("bad argument: -f%s", arg);
                         return(0);                          return(0);
Line 625  merr(void *arg, int line, int col, const char *msg)
Line 659  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);
   
           /* Always exit on errors... */
         return(0);          return(0);
 }  }
   
Line 661  mdocwarn(void *arg, int line, int col, 
Line 696  mdocwarn(void *arg, int line, int col, 
   
         if ( ! (curp->wflags & WARN_WERR))          if ( ! (curp->wflags & WARN_WERR))
                 return(1);                  return(1);
   
           /*
            * If the -Werror flag is passed in, as in gcc, then all
            * warnings are considered as errors.
            */
   
         warnx("%s: considering warnings as errors",          warnx("%s: considering warnings as errors",
                         __progname);                          __progname);
Line 683  manwarn(void *arg, int line, int col, const char *msg)
Line 723  manwarn(void *arg, int line, int col, const char *msg)
   
         if ( ! (curp->wflags & WARN_WERR))          if ( ! (curp->wflags & WARN_WERR))
                 return(1);                  return(1);
   
           /*
            * If the -Werror flag is passed in, as in gcc, then all
            * warnings are considered as errors.
            */
   
         warnx("%s: considering warnings as errors",          warnx("%s: considering warnings as errors",
                         __progname);                          __progname);
Legend:
Removed from v.1.23  
changed lines
  Added in v.1.29
CVSweb