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

Diff for /mandoc/read.c between version 1.20 and 1.34

version 1.20, 2011/07/21 12:30:44 version 1.34, 2012/11/19 22:30:58
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2010, 2011, 2012 Ingo Schwarze <schwarze@openbsd.org>
  *   *
  * 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 28 
Line 28 
 #include <ctype.h>  #include <ctype.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <stdarg.h>  #include <stdarg.h>
   #include <stdint.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
Line 37 
Line 38 
 #include "libmandoc.h"  #include "libmandoc.h"
 #include "mdoc.h"  #include "mdoc.h"
 #include "man.h"  #include "man.h"
   #include "main.h"
   
 #ifndef MAP_FILE  #ifndef MAP_FILE
 #define MAP_FILE        0  #define MAP_FILE        0
Line 63  struct mparse {
Line 65  struct mparse {
         mandocmsg         mmsg; /* warning/error message handler */          mandocmsg         mmsg; /* warning/error message handler */
         void             *arg; /* argument to mmsg */          void             *arg; /* argument to mmsg */
         const char       *file;          const char       *file;
           struct buf       *secondary;
           char             *defos; /* default operating system */
 };  };
   
 static  void      resize_buf(struct buf *, size_t);  static  void      resize_buf(struct buf *, size_t);
 static  void      mparse_buf_r(struct mparse *, struct buf, int);  static  void      mparse_buf_r(struct mparse *, struct buf, int);
 static  void      mparse_readfd_r(struct mparse *, int, const char *, int);  static  void      mparse_readfd_r(struct mparse *, int, const char *, int);
 static  void      pset(const char *, int, struct mparse *);  static  void      pset(const char *, int, struct mparse *);
 static  void      pdesc(struct mparse *, const char *, int);  
 static  int       read_whole_file(const char *, int, struct buf *, int *);  static  int       read_whole_file(const char *, int, struct buf *, int *);
 static  void      mparse_end(struct mparse *);  static  void      mparse_end(struct mparse *);
   
Line 92  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 95  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "no title in document",          "no title in document",
         "document title should be all caps",          "document title should be all caps",
         "unknown manual section",          "unknown manual section",
           "unknown manual volume or arch",
         "date missing, using today's date",          "date missing, using today's date",
         "cannot parse date, using it verbatim",          "cannot parse date, using it verbatim",
         "prologue macros out of order",          "prologue macros out of order",
Line 103  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 107  static const char * const mandocerrs[MANDOCERR_MAX] = 
         ".so is fragile, better use ln(1)",          ".so is fragile, better use ln(1)",
         "NAME section must come first",          "NAME section must come first",
         "bad NAME section contents",          "bad NAME section contents",
         "manual name not yet set",  
         "sections out of conventional order",          "sections out of conventional order",
         "duplicate section name",          "duplicate section name",
         "section not in conventional manual section",          "section not in conventional manual section",
Line 111  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 114  static const char * const mandocerrs[MANDOCERR_MAX] = 
         /* related to macros and nesting */          /* related to macros and nesting */
         "skipping obsolete macro",          "skipping obsolete macro",
         "skipping paragraph macro",          "skipping paragraph macro",
           "moving paragraph macro out of list",
         "skipping no-space macro",          "skipping no-space macro",
         "blocks badly nested",          "blocks badly nested",
         "child violates parent syntax",          "child violates parent syntax",
Line 152  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 156  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "generic error",          "generic error",
   
         /* related to equations */          /* related to equations */
         "bad equation macro syntax",  
         "too many nested equation defines",  
         "unexpected equation scope closure",          "unexpected equation scope closure",
         "equation scope open on exit",          "equation scope open on exit",
           "overlapping equation scopes",
           "unexpected end of equation",
           "equation syntax error",
   
         /* related to tables */          /* related to tables */
         "bad table syntax",          "bad table syntax",
Line 170  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 175  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "input stack limit exceeded, infinite loop?",          "input stack limit exceeded, infinite loop?",
         "skipping bad character",          "skipping bad character",
         "escaped character not allowed in a name",          "escaped character not allowed in a name",
           "manual name not yet set",
         "skipping text before the first section header",          "skipping text before the first section header",
         "skipping unknown macro",          "skipping unknown macro",
         "NOT IMPLEMENTED, please use groff: skipping request",          "NOT IMPLEMENTED, please use groff: skipping request",
         "argument count wrong",          "argument count wrong",
           "skipping column outside column list",
         "skipping end of block that is not open",          "skipping end of block that is not open",
         "missing end of block",          "missing end of block",
         "scope open on exit",          "scope open on exit",
Line 190  static const char * const mandocerrs[MANDOCERR_MAX] = 
Line 197  static const char * const mandocerrs[MANDOCERR_MAX] = 
         "not a manual",          "not a manual",
         "column syntax is inconsistent",          "column syntax is inconsistent",
         "NOT IMPLEMENTED: .Bd -file",          "NOT IMPLEMENTED: .Bd -file",
         "line scope broken, syntax violated",  
         "argument count wrong, violates syntax",          "argument count wrong, violates syntax",
         "child violates parent syntax",          "child violates parent syntax",
         "argument count wrong, violates syntax",          "argument count wrong, violates syntax",
Line 245  pset(const char *buf, int pos, struct mparse *curp)
Line 251  pset(const char *buf, int pos, struct mparse *curp)
         switch (curp->inttype) {          switch (curp->inttype) {
         case (MPARSE_MDOC):          case (MPARSE_MDOC):
                 if (NULL == curp->pmdoc)                  if (NULL == curp->pmdoc)
                         curp->pmdoc = mdoc_alloc(curp->roff, curp);                          curp->pmdoc = mdoc_alloc(curp->roff, curp,
                                           curp->defos);
                 assert(curp->pmdoc);                  assert(curp->pmdoc);
                 curp->mdoc = curp->pmdoc;                  curp->mdoc = curp->pmdoc;
                 return;                  return;
Line 261  pset(const char *buf, int pos, struct mparse *curp)
Line 268  pset(const char *buf, int pos, struct mparse *curp)
   
         if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {          if (pos >= 3 && 0 == memcmp(buf, ".Dd", 3))  {
                 if (NULL == curp->pmdoc)                  if (NULL == curp->pmdoc)
                         curp->pmdoc = mdoc_alloc(curp->roff, curp);                          curp->pmdoc = mdoc_alloc(curp->roff, curp,
                                           curp->defos);
                 assert(curp->pmdoc);                  assert(curp->pmdoc);
                 curp->mdoc = curp->pmdoc;                  curp->mdoc = curp->pmdoc;
                 return;                  return;
Line 324  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 332  mparse_buf_r(struct mparse *curp, struct buf blk, int 
                          * Warn about bogus characters.  If you're using                           * Warn about bogus characters.  If you're using
                          * non-ASCII encoding, you're screwing your                           * non-ASCII encoding, you're screwing your
                          * readers.  Since I'd rather this not happen,                           * readers.  Since I'd rather this not happen,
                          * I'll be helpful and drop these characters so                           * I'll be helpful and replace these characters
                          * we don't display gibberish.  Note to manual                           * with "?", so we don't display gibberish.
                          * writers: use special characters.                           * Note to manual writers: use special characters.
                          */                           */
   
                         c = (unsigned char) blk.buf[i];                          c = (unsigned char) blk.buf[i];
Line 334  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 342  mparse_buf_r(struct mparse *curp, struct buf blk, int 
                         if ( ! (isascii(c) &&                          if ( ! (isascii(c) &&
                                         (isgraph(c) || isblank(c)))) {                                          (isgraph(c) || isblank(c)))) {
                                 mandoc_msg(MANDOCERR_BADCHAR, curp,                                  mandoc_msg(MANDOCERR_BADCHAR, curp,
                                                 curp->line, pos, "ignoring byte");                                                  curp->line, pos, NULL);
                                 i++;                                  i++;
                                   if (pos >= (int)ln.sz)
                                           resize_buf(&ln, 256);
                                   ln.buf[pos++] = '?';
                                 continue;                                  continue;
                         }                          }
   
Line 410  mparse_buf_r(struct mparse *curp, struct buf blk, int 
Line 421  mparse_buf_r(struct mparse *curp, struct buf blk, int 
   
                 of = 0;                  of = 0;
   
                   /*
                    * Maintain a lookaside buffer of all parsed lines.  We
                    * only do this if mparse_keep() has been invoked (the
                    * buffer may be accessed with mparse_getkeep()).
                    */
   
                   if (curp->secondary) {
                           curp->secondary->buf =
                                   mandoc_realloc
                                   (curp->secondary->buf,
                                    curp->secondary->sz + pos + 2);
                           memcpy(curp->secondary->buf +
                                           curp->secondary->sz,
                                           ln.buf, pos);
                           curp->secondary->sz += pos;
                           curp->secondary->buf
                                   [curp->secondary->sz] = '\n';
                           curp->secondary->sz++;
                           curp->secondary->buf
                                   [curp->secondary->sz] = '\0';
                   }
 rerun:  rerun:
                 rr = roff_parseln                  rr = roff_parseln
                         (curp->roff, curp->line,                          (curp->roff, curp->line,
Line 436  rerun:
Line 468  rerun:
                         assert(MANDOCLEVEL_FATAL <= curp->file_status);                          assert(MANDOCLEVEL_FATAL <= curp->file_status);
                         break;                          break;
                 case (ROFF_SO):                  case (ROFF_SO):
                           /*
                            * We remove `so' clauses from our lookaside
                            * buffer because we're going to descend into
                            * the file recursively.
                            */
                           if (curp->secondary)
                                   curp->secondary->sz -= pos + 1;
                         mparse_readfd_r(curp, -1, ln.buf + of, 1);                          mparse_readfd_r(curp, -1, ln.buf + of, 1);
                         if (MANDOCLEVEL_FATAL <= curp->file_status)                          if (MANDOCLEVEL_FATAL <= curp->file_status)
                                 break;                                  break;
Line 515  rerun:
Line 554  rerun:
         free(ln.buf);          free(ln.buf);
 }  }
   
 static void  
 pdesc(struct mparse *curp, const char *file, int fd)  
 {  
         struct buf       blk;  
         int              with_mmap;  
   
         /*  
          * Run for each opened file; may be called more than once for  
          * each full parse sequence if the opened file is nested (i.e.,  
          * from `so').  Simply sucks in the whole file and moves into  
          * the parse phase for the file.  
          */  
   
         if ( ! read_whole_file(file, fd, &blk, &with_mmap)) {  
                 curp->file_status = MANDOCLEVEL_SYSERR;  
                 return;  
         }  
   
         /* Line number is per-file. */  
   
         curp->line = 1;  
   
         mparse_buf_r(curp, blk, 1);  
   
 #ifdef  HAVE_MMAP  
         if (with_mmap)  
                 munmap(blk.buf, blk.sz);  
         else  
 #endif  
                 free(blk.buf);  
 }  
   
 static int  static int
 read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)  read_whole_file(const char *file, int fd, struct buf *fb, int *with_mmap)
 {  {
Line 642  mparse_end(struct mparse *curp)
Line 649  mparse_end(struct mparse *curp)
 }  }
   
 static void  static void
 mparse_readfd_r(struct mparse *curp, int fd, const char *file, int re)  mparse_parse_buffer(struct mparse *curp, struct buf blk, const char *file,
                   int re)
 {  {
         const char      *svfile;          const char      *svfile;
   
           /* Line number is per-file. */
           svfile = curp->file;
           curp->file = file;
           curp->line = 1;
   
           mparse_buf_r(curp, blk, 1);
   
           if (0 == re && MANDOCLEVEL_FATAL > curp->file_status)
                   mparse_end(curp);
   
           curp->file = svfile;
   }
   
   enum mandoclevel
   mparse_readmem(struct mparse *curp, const void *buf, size_t len,
                   const char *file)
   {
           struct buf blk;
   
           blk.buf = UNCONST(buf);
           blk.sz = len;
   
           mparse_parse_buffer(curp, blk, file, 0);
           return(curp->file_status);
   }
   
   static void
   mparse_readfd_r(struct mparse *curp, int fd, const char *file, int re)
   {
           struct buf       blk;
           int              with_mmap;
   
         if (-1 == fd)          if (-1 == fd)
                 if (-1 == (fd = open(file, O_RDONLY, 0))) {                  if (-1 == (fd = open(file, O_RDONLY, 0))) {
                         perror(file);                          perror(file);
                         curp->file_status = MANDOCLEVEL_SYSERR;                          curp->file_status = MANDOCLEVEL_SYSERR;
                         return;                          return;
                 }                  }
           /*
            * Run for each opened file; may be called more than once for
            * each full parse sequence if the opened file is nested (i.e.,
            * from `so').  Simply sucks in the whole file and moves into
            * the parse phase for the file.
            */
   
         svfile = curp->file;          if ( ! read_whole_file(file, fd, &blk, &with_mmap)) {
         curp->file = file;                  curp->file_status = MANDOCLEVEL_SYSERR;
                   return;
           }
   
         pdesc(curp, file, fd);          mparse_parse_buffer(curp, blk, file, re);
   
         if (0 == re && MANDOCLEVEL_FATAL > curp->file_status)  #ifdef  HAVE_MMAP
                 mparse_end(curp);          if (with_mmap)
                   munmap(blk.buf, blk.sz);
           else
   #endif
                   free(blk.buf);
   
         if (STDIN_FILENO != fd && -1 == close(fd))          if (STDIN_FILENO != fd && -1 == close(fd))
                 perror(file);                  perror(file);
   
         curp->file = svfile;  
 }  }
   
 enum mandoclevel  enum mandoclevel
Line 676  mparse_readfd(struct mparse *curp, int fd, const char 
Line 726  mparse_readfd(struct mparse *curp, int fd, const char 
 }  }
   
 struct mparse *  struct mparse *
 mparse_alloc(enum mparset inttype, enum mandoclevel wlevel, mandocmsg mmsg, void *arg)  mparse_alloc(enum mparset inttype, enum mandoclevel wlevel,
                   mandocmsg mmsg, void *arg, char *defos)
 {  {
         struct mparse   *curp;          struct mparse   *curp;
   
Line 688  mparse_alloc(enum mparset inttype, enum mandoclevel wl
Line 739  mparse_alloc(enum mparset inttype, enum mandoclevel wl
         curp->mmsg = mmsg;          curp->mmsg = mmsg;
         curp->arg = arg;          curp->arg = arg;
         curp->inttype = inttype;          curp->inttype = inttype;
           curp->defos = defos;
   
         curp->roff = roff_alloc(curp);          curp->roff = roff_alloc(inttype, curp);
         return(curp);          return(curp);
 }  }
   
Line 703  mparse_reset(struct mparse *curp)
Line 755  mparse_reset(struct mparse *curp)
                 mdoc_reset(curp->mdoc);                  mdoc_reset(curp->mdoc);
         if (curp->man)          if (curp->man)
                 man_reset(curp->man);                  man_reset(curp->man);
           if (curp->secondary)
                   curp->secondary->sz = 0;
   
         curp->file_status = MANDOCLEVEL_OK;          curp->file_status = MANDOCLEVEL_OK;
         curp->mdoc = NULL;          curp->mdoc = NULL;
Line 719  mparse_free(struct mparse *curp)
Line 773  mparse_free(struct mparse *curp)
                 man_free(curp->pman);                  man_free(curp->pman);
         if (curp->roff)          if (curp->roff)
                 roff_free(curp->roff);                  roff_free(curp->roff);
           if (curp->secondary)
                   free(curp->secondary->buf);
   
           free(curp->secondary);
         free(curp);          free(curp);
 }  }
   
Line 778  const char *
Line 835  const char *
 mparse_strlevel(enum mandoclevel lvl)  mparse_strlevel(enum mandoclevel lvl)
 {  {
         return(mandoclevels[lvl]);          return(mandoclevels[lvl]);
   }
   
   void
   mparse_keep(struct mparse *p)
   {
   
           assert(NULL == p->secondary);
           p->secondary = mandoc_calloc(1, sizeof(struct buf));
   }
   
   const char *
   mparse_getkeep(const struct mparse *p)
   {
   
           assert(p->secondary);
           return(p->secondary->sz ? p->secondary->buf : NULL);
 }  }
Legend:
Removed from v.1.20  
changed lines
  Added in v.1.34
CVSweb