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

Diff for /mandoc/main.c between version 1.68 and 1.73

version 1.68, 2010/05/15 09:46:31 version 1.73, 2010/05/15 21:53:11
Line 29 
Line 29 
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   
   #include "mandoc.h"
 #include "mdoc.h"  #include "mdoc.h"
 #include "man.h"  #include "man.h"
   #include "roff.h"
 #include "main.h"  #include "main.h"
   
 #define UNCONST(a)      ((void *)(uintptr_t)(const void *)(a))  #define UNCONST(a)      ((void *)(uintptr_t)(const void *)(a))
Line 70  struct curparse {
Line 72  struct curparse {
         const char       *file;         /* Current parse. */          const char       *file;         /* Current parse. */
         int               fd;           /* Current parse. */          int               fd;           /* Current parse. */
         int               wflags;          int               wflags;
           /* FIXME: set by max error */
 #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;
Line 82  struct curparse {
Line 85  struct curparse {
         enum intt         inttype;      /* Input parsers... */          enum intt         inttype;      /* Input parsers... */
         struct man       *man;          struct man       *man;
         struct mdoc      *mdoc;          struct mdoc      *mdoc;
           struct roff      *roff;
         enum outt         outtype;      /* Output devices... */          enum outt         outtype;      /* Output devices... */
         out_mdoc          outmdoc;          out_mdoc          outmdoc;
         out_man           outman;          out_man           outman;
Line 95  static void    ffile(const char *, struct curparse *);
Line 99  static void    ffile(const char *, struct curparse *);
 static  int               foptions(int *, char *);  static  int               foptions(int *, char *);
 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 *);
 static  int               merr(void *, int, int, const char *);  static  struct roff      *roff_init(struct curparse *);
   static  int               merr(void *, int, int, const char *); /* DEPRECATED */
 static  int               moptions(enum intt *, char *);  static  int               moptions(enum intt *, char *);
 static  int               mwarn(void *, int, int, const char *);  static  int               mwarn(void *, int, int, const char *); /* DEPRECATED */
   static  int               mmsg(enum mandocerr, void *,
                                   int, int, const char *);
 static  int               pset(const char *, int, struct curparse *,  static  int               pset(const char *, int, struct curparse *,
                                 struct man **, struct mdoc **);                                  struct man **, struct mdoc **);
 static  int               toptions(struct curparse *, char *);  static  int               toptions(struct curparse *, char *);
Line 177  main(int argc, char *argv[])
Line 184  main(int argc, char *argv[])
   
         if (curp.outfree)          if (curp.outfree)
                 (*curp.outfree)(curp.outdata);                  (*curp.outfree)(curp.outdata);
           if (curp.mdoc)
                   mdoc_free(curp.mdoc);
           if (curp.man)
                   man_free(curp.man);
           if (curp.roff)
                   roff_free(curp.roff);
   
         return((with_warning || with_error) ?          return((with_warning || with_error) ?
                         EXIT_FAILURE :  EXIT_SUCCESS);                          EXIT_FAILURE :  EXIT_SUCCESS);
Line 225  man_init(struct curparse *curp)
Line 238  man_init(struct curparse *curp)
 }  }
   
   
   static struct roff *
   roff_init(struct curparse *curp)
   {
   
           return(roff_alloc(mmsg, curp));
   }
   
   
 static struct mdoc *  static struct mdoc *
 mdoc_init(struct curparse *curp)  mdoc_init(struct curparse *curp)
 {  {
Line 316  read_whole_file(struct curparse *curp, struct buf *fb,
Line 337  read_whole_file(struct curparse *curp, struct buf *fb,
                         return(0);                          return(0);
                 }                  }
                 *with_mmap = 1;                  *with_mmap = 1;
                 fb->sz = st.st_size;                  fb->sz = (size_t)st.st_size;
                 fb->buf = mmap(NULL, fb->sz, PROT_READ,                  fb->buf = mmap(NULL, fb->sz, PROT_READ,
                                 MAP_FILE, curp->fd, 0);                                  MAP_FILE, curp->fd, 0);
                 if (fb->buf != MAP_FAILED)                  if (fb->buf != MAP_FAILED)
Line 342  read_whole_file(struct curparse *curp, struct buf *fb,
Line 363  read_whole_file(struct curparse *curp, struct buf *fb,
                         if (! resize_buf(fb, 65536))                          if (! resize_buf(fb, 65536))
                                 break;                                  break;
                 }                  }
                 ssz = read(curp->fd, fb->buf + off, fb->sz - off);                  ssz = read(curp->fd, fb->buf + (int)off, fb->sz - off);
                 if (ssz == 0) {                  if (ssz == 0) {
                         fb->sz = off;                          fb->sz = off;
                         return(1);                          return(1);
Line 351  read_whole_file(struct curparse *curp, struct buf *fb,
Line 372  read_whole_file(struct curparse *curp, struct buf *fb,
                         perror(curp->file);                          perror(curp->file);
                         break;                          break;
                 }                  }
                 off += ssz;                  off += (size_t)ssz;
         }          }
   
         free(fb->buf);          free(fb->buf);
Line 365  static void
Line 386  static void
 fdesc(struct curparse *curp)  fdesc(struct curparse *curp)
 {  {
         struct buf       ln, blk;          struct buf       ln, blk;
         int              j, i, pos, lnn, comment, with_mmap;          int              i, pos, lnn, lnn_start, with_mmap;
           enum rofferr     re;
         struct man      *man;          struct man      *man;
         struct mdoc     *mdoc;          struct mdoc     *mdoc;
           struct roff     *roff;
   
         man = NULL;          man = NULL;
         mdoc = NULL;          mdoc = NULL;
           roff = NULL;
         memset(&ln, 0, sizeof(struct buf));          memset(&ln, 0, sizeof(struct buf));
   
         /*          /*
          * Two buffers: ln and buf.  buf is the input buffer optimised           * Two buffers: ln and buf.  buf is the input file and may be
          * here for each file's block size.  ln is a line buffer.  Both           * memory mapped.  ln is a line buffer and grows on-demand.
          * growable, hence passed in by ptr-ptr.  
          */           */
   
         if (!read_whole_file(curp, &blk, &with_mmap))          if ( ! read_whole_file(curp, &blk, &with_mmap))
                 return;                  return;
   
         /* Fill buf with file blocksize. */          if (NULL == curp->roff)
                   curp->roff = roff_init(curp);
           if (NULL == (roff = curp->roff))
                   goto bailout;
   
         for (i = lnn = pos = comment = 0; i < (int)blk.sz; ++i) {          for (i = 0, lnn = 1; i < (int)blk.sz;) {
                 if (pos >= (int)ln.sz) {                  pos = 0;
                         if (! resize_buf(&ln, 256))                  lnn_start = lnn;
                                 goto bailout;                  while (i < (int)blk.sz) {
                 }                          if ('\n' == blk.buf[i]) {
                                   ++i;
                 if ('\n' != blk.buf[i]) {                                  ++lnn;
                         if (comment)                                  break;
                           }
                           /* Trailing backslash is like a plain character. */
                           if ('\\' != blk.buf[i] || i + 1 == (int)blk.sz) {
                                   if (pos >= (int)ln.sz)
                                           if (! resize_buf(&ln, 256))
                                                   goto bailout;
                                   ln.buf[pos++] = blk.buf[i++];
                                 continue;                                  continue;
                         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;  
                         for (; pos > 0; --pos) {  
                                 if (ln.buf[pos - 1] != ' ')  
                                         break;  
                                 if (pos > 2 && ln.buf[pos - 2] == '\\')  
                                         break;  
                         }                          }
                         continue;                          /* Found an escape and at least one other character. */
                 }                          if ('\n' == blk.buf[i + 1]) {
                                   /* Escaped newlines are skipped over */
                 /* Handle escaped `\\n' newlines. */                                  i += 2;
                                   ++lnn;
                 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;                                  continue;
                         }                          }
                           if ('"' == blk.buf[i + 1]) {
                                   i += 2;
                                   /* Comment, skip to end of line */
                                   for (; i < (int)blk.sz; ++i) {
                                           if ('\n' == blk.buf[i]) {
                                                   ++i;
                                                   ++lnn;
                                                   break;
                                           }
                                   }
                                   /* Backout trailing whitespaces */
                                   for (; pos > 0; --pos) {
                                           if (ln.buf[pos - 1] != ' ')
                                                   break;
                                           if (pos > 2 && ln.buf[pos - 2] == '\\')
                                                   break;
                                   }
                                   break;
                           }
                           /* Some other escape sequence, copy and continue. */
                           if (pos + 1 >= (int)ln.sz)
                                   if (! resize_buf(&ln, 256))
                                           goto bailout;
   
                           ln.buf[pos++] = blk.buf[i++];
                           ln.buf[pos++] = blk.buf[i++];
                 }                  }
   
                 ln.buf[pos] = 0;                  if (pos >= (int)ln.sz)
                 lnn++;                          if (! resize_buf(&ln, 256))
                                   goto bailout;
                   ln.buf[pos] = '\0';
   
                   re = roff_parseln(roff, lnn_start, &ln.buf, &ln.sz);
                   if (ROFF_IGN == re)
                           continue;
                   else if (ROFF_ERR == re)
                           goto bailout;
   
                 /* If unset, assign parser in pset(). */                  /* If unset, assign parser in pset(). */
   
                 if ( ! (man || mdoc) && ! pset(ln.buf, pos, curp, &man, &mdoc))                  if ( ! (man || mdoc) && ! pset(ln.buf, pos, curp, &man, &mdoc))
                         goto bailout;                          goto bailout;
   
                 pos = comment = 0;  
   
                 /* Pass down into parsers. */                  /* Pass down into parsers. */
   
                 if (man && ! man_parseln(man, lnn, ln.buf))                  if (man && ! man_parseln(man, lnn_start, ln.buf))
                         goto bailout;                          goto bailout;
                 if (mdoc && ! mdoc_parseln(mdoc, lnn, ln.buf))                  if (mdoc && ! mdoc_parseln(mdoc, lnn_start, ln.buf))
                         goto bailout;                          goto bailout;
         }          }
   
Line 460  fdesc(struct curparse *curp)
Line 497  fdesc(struct curparse *curp)
                 goto bailout;                  goto bailout;
         if (man && ! man_endparse(man))          if (man && ! man_endparse(man))
                 goto bailout;                  goto bailout;
           if (roff && ! roff_endparse(roff))
                   goto bailout;
   
         /* If unset, allocate output dev now (if applicable). */          /* If unset, allocate output dev now (if applicable). */
   
Line 484  fdesc(struct curparse *curp)
Line 523  fdesc(struct curparse *curp)
                 case (OUTT_LINT):                  case (OUTT_LINT):
                         break;                          break;
                 default:                  default:
                         curp->outdata = ascii_alloc();                          curp->outdata = ascii_alloc(80);
                         curp->outman = terminal_man;                          curp->outman = terminal_man;
                         curp->outmdoc = terminal_mdoc;                          curp->outmdoc = terminal_mdoc;
                         curp->outfree = terminal_free;                          curp->outfree = terminal_free;
Line 500  fdesc(struct curparse *curp)
Line 539  fdesc(struct curparse *curp)
                 (*curp->outmdoc)(curp->outdata, mdoc);                  (*curp->outmdoc)(curp->outdata, mdoc);
   
  cleanup:   cleanup:
         if (curp->mdoc) {          if (mdoc)
                 mdoc_free(curp->mdoc);                  mdoc_reset(mdoc);
                 curp->mdoc = NULL;          if (man)
         }                  man_reset(man);
         if (curp->man) {          if (roff)
                 man_free(curp->man);                  roff_reset(roff);
                 curp->man = NULL;  
         }  
         if (ln.buf)          if (ln.buf)
                 free(ln.buf);                  free(ln.buf);
         if (with_mmap)          if (with_mmap)
                 munmap(blk.buf, blk.sz);                  munmap(blk.buf, blk.sz);
         else          else
                 free(blk.buf);                  free(blk.buf);
   
         return;          return;
   
  bailout:   bailout:
Line 735  mwarn(void *arg, int line, int col, const char *msg)
Line 773  mwarn(void *arg, int line, int col, const char *msg)
         return(1);          return(1);
 }  }
   
   static  const char * const      mandocerrs[MANDOCERR_MAX] = {
           "ok",
           "multi-line scope open on exit",
           "request for scope closure when no matching scope is open",
           "line arguments will be lost",
           "memory exhausted"
   };
   
   /*
    * XXX: this is experimental code that will eventually become the
    * generic means of covering all warnings and errors!
    */
   /* ARGSUSED */
   static int
   mmsg(enum mandocerr t, void *arg, int ln, int col, const char *msg)
   {
           struct curparse *cp;
   
           cp = (struct curparse *)arg;
   
           fprintf(stderr, "%s:%d:%d: %s", cp->file,
                           ln, col + 1, mandocerrs[t]);
   
           if (msg)
                   fprintf(stderr, ": %s", msg);
   
           fputc('\n', stderr);
           return(1);
   }
Legend:
Removed from v.1.68  
changed lines
  Added in v.1.73
CVSweb