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

Diff for /mandoc/Attic/mdocterm.c between version 1.48 and 1.49

version 1.48, 2009/03/17 13:35:46 version 1.49, 2009/03/19 11:49:00
Line 17 
Line 17 
  * PERFORMANCE OF THIS SOFTWARE.   * PERFORMANCE OF THIS SOFTWARE.
  */   */
 #include <sys/types.h>  #include <sys/types.h>
   #include <sys/stat.h>
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  
 #include <err.h>  #include <err.h>
   #include <fcntl.h>
 #include <getopt.h>  #include <getopt.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
   
 #include "mmain.h"  
 #include "term.h"  #include "term.h"
   
 struct  nroffopt {  #define WARN_WALL         0x03          /* All-warnings mask. */
         int               fl_h;  #define WARN_WCOMPAT     (1 << 0)       /* Compatibility warnings. */
         int               fl_i;  #define WARN_WSYNTAX     (1 << 1)       /* Syntax warnings. */
         char             *arg_m;  #define WARN_WERR        (1 << 2)       /* Warnings->errors. */
         char             *arg_n;  
         char             *arg_o;  enum    termt {
         char             *arg_r;          TERMT_ASCII,
         char             *arg_T;          TERMT_LINT,
         struct termp     *termp; /* Ephemeral. */          TERMT_TREE
 };  };
   
 __dead void               punt(struct nroffopt *, char *);  extern  char             *__progname;
 static  int               option(void *, int, char *);  
 static  int               optsopt(struct termp *, char *);  __dead  static void       version(void);
 static  void              body(struct termp *,  __dead  static void       usage(void);
                                 struct termpair *,  #if 0
   __dead  static void       punt(struct cmdargs *, char **);
   #endif
   static  int               foptions(int *, char *);
   static  int               toptions(enum termt *, char *);
   static  int               woptions(int *, char *);
   static  int               merr(void *, int, int, const char *);
   static  int               mwarn(void *, int, int,
                                   enum mdoc_warn, const char *);
   static  void              body(struct termp *, struct termpair *,
                                 const struct mdoc_meta *,                                  const struct mdoc_meta *,
                                 const struct mdoc_node *);                                  const struct mdoc_node *);
 static  void              header(struct termp *,  static  void              header(struct termp *,
                                 const struct mdoc_meta *);                                  const struct mdoc_meta *);
 static  void              footer(struct termp *,  static  void              footer(struct termp *,
                                 const struct mdoc_meta *);                                  const struct mdoc_meta *);
   static  int               file(char **, size_t *, char **, size_t *,
 static  void              pword(struct termp *, const char *, size_t);                                  const char *, struct mdoc *);
 static  void              pescape(struct termp *, const char *,  static  int               fdesc(char **, size_t *, char **, size_t *,
                                 size_t *, size_t);                                  const char *, int, struct mdoc *);
   static  void              pword(struct termp *, const char *, int);
   static  void              pescape(struct termp *,
                                   const char *, int *, int);
 static  void              nescape(struct termp *,  static  void              nescape(struct termp *,
                                 const char *, size_t);                                  const char *, size_t);
 static  void              chara(struct termp *, char);  static  void              chara(struct termp *, char);
Line 63  static void    stringa(struct termp *, 
Line 75  static void    stringa(struct termp *, 
                                 const char *, size_t);                                  const char *, size_t);
 static  void              sanity(const struct mdoc_node *);  static  void              sanity(const struct mdoc_node *);
   
   
 int  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         struct mmain      *p;          struct termp     termp;
         const struct mdoc *mdoc;          int              c, fflags, wflags;
         struct nroffopt    nroff;          struct mdoc_cb   cb;
         struct termp       termp;          struct mdoc     *mdoc;
         int                c;          char            *buf, *line;
         char              *in;          size_t           bufsz, linesz;
           enum termt       termt;
   
         (void)memset(&termp, 0, sizeof(struct termp));          bzero(&termp, sizeof(struct termp));
         (void)memset(&nroff, 0, sizeof(struct nroffopt));          bzero(&cb, sizeof(struct mdoc_cb));
   
         termp.maxrmargin = termp.rmargin = 78; /* FIXME */          termt = TERMT_ASCII;
         termp.maxcols = 1024; /* FIXME */          fflags = wflags = 0;
         termp.flags = TERMP_NOSPACE;  
         termp.symtab = ascii2htab();  
   
         nroff.termp = &termp;          /* LINTED */
           while (-1 != (c = getopt(argc, argv, "f:VW:T:")))
                   switch (c) {
                   case ('f'):
                           if ( ! foptions(&fflags, optarg))
                                   return(0);
                           break;
                   case ('T'):
                           if ( ! toptions(&termt, optarg))
                                   return(0);
                           break;
                   case ('W'):
                           if ( ! woptions(&wflags, optarg))
                                   return(0);
                           break;
                   case ('V'):
                           version();
                           /* NOTREACHED */
                   default:
                           usage();
                           /* NOTREACHED */
                   }
   
         p = mmain_alloc();          argc -= optind;
           argv += optind;
   
         c = mmain_getopt(p, argc, argv, "[-Ooption...]",          termp.maxrmargin = 78;                  /* FIXME */
                         "[infile]", "him:n:o:r:T:O:", &nroff, option);  
   
         /* FIXME: this needs to accept multiple outputs. */          cb.mdoc_err = merr;
         argv += c;          cb.mdoc_warn = mwarn;
         if ((argc -= c) > 0)  
                 in = *argv++;  
         else  
                 in = "-";  
   
         mmain_prepare(p, in);          /* Line and block buffers persist between parses. */
   
         if (NULL == (mdoc = mmain_process(p))) {          buf = line = NULL;
                 if (TERMP_NOPUNT & termp.iflags)          bufsz = linesz = 0;
                         mmain_exit(p, 1);  
                 mmain_free(p);          /* Overall mdoc persists between parses. */
                 punt(&nroff, in);  
                 /* NOTREACHED */          mdoc = mdoc_alloc(&wflags, fflags, &cb);
   
           while (*argv) {
                   if ( ! file(&line, &linesz, &buf, &bufsz, *argv, mdoc))
                           break;
   
                   switch (termt) {
                   case (TERMT_ASCII):
                           if (NULL == termp.symtab)
                                   termp.symtab = ascii2htab();
                           header(&termp, mdoc_meta(mdoc));
                           body(&termp, NULL, mdoc_meta(mdoc),
                                           mdoc_node(mdoc));
                           footer(&termp, mdoc_meta(mdoc));
                           break;
                   default:
                           break;
                   }
   
                   mdoc_reset(mdoc);
                   argv++;
         }          }
   
         if (NULL == (termp.buf = malloc(termp.maxcols)))          if (buf)
                 err(1, "malloc");                  free(buf);
           if (line)
                   free(line);
           if (termp.buf)
                   free(termp.buf);
           if (termp.symtab)
                   asciifree(termp.symtab);
   
         header(&termp, mdoc_meta(mdoc));          mdoc_free(mdoc);
         body(&termp, NULL, mdoc_meta(mdoc), mdoc_node(mdoc));  
         footer(&termp, mdoc_meta(mdoc));  
   
         free(termp.buf);          return(0);
         asciifree(termp.symtab);  }
   
         mmain_exit(p, 0);  
   __dead static void
   version(void)
   {
   
           (void)printf("%s %s\n", __progname, VERSION);
           exit(0);
         /* NOTREACHED */          /* NOTREACHED */
 }  }
   
   
   __dead static void
   usage(void)
   {
   
           (void)fprintf(stderr, "usage: %s\n", __progname);
           exit(1);
           /* NOTREACHED */
   }
   
   
 static int  static int
 optsopt(struct termp *p, char *arg)  file(char **ln, size_t *lnsz, char **buf, size_t *bufsz,
                   const char *file, struct mdoc *mdoc)
 {  {
           int              fd, c;
   
           if (-1 == (fd = open(file, O_RDONLY, 0))) {
                   warn("%s", file);
                   return(0);
           }
   
           c = fdesc(ln, lnsz, buf, bufsz, file, fd, mdoc);
   
           if (-1 == close(fd))
                   warn("%s", file);
   
           return(c);
   }
   
   
   static int
   fdesc(char **lnp, size_t *lnsz, char **bufp, size_t *bufsz,
                   const char *f, int fd, struct mdoc *mdoc)
   {
           size_t           sz;
           ssize_t          ssz;
           struct stat      st;
           int              j, i, pos, lnn;
           char            *ln, *buf;
   
           buf = *bufp;
           ln = *lnp;
   
           /*
            * Two buffers: ln and buf.  buf is the input buffer, optimised
            * for each file's block size.  ln is a line buffer.  Both
            * growable, hence passed in by ptr-ptr.
            */
   
           if (-1 == fstat(fd, &st)) {
                   warnx("%s", f);
                   sz = BUFSIZ;
           } else
                   sz = (unsigned)BUFSIZ > st.st_blksize ?
                           (size_t)BUFSIZ : st.st_blksize;
   
           if (sz > *bufsz) {
                   if (NULL == (buf = realloc(buf, sz)))
                           err(1, "realloc");
                   *bufp = buf;
                   *bufsz = sz;
           }
   
           /*
            * Fill buf with file blocksize and parse newlines into ln.
            */
   
           for (lnn = 1, pos = 0; ; ) {
                   if (-1 == (ssz = read(fd, buf, sz))) {
                           warn("%s", f);
                           return(0);
                   } else if (0 == ssz)
                           break;
   
                   for (i = 0; i < (int)ssz; i++) {
                           if (pos >= (int)*lnsz) {
                                   *lnsz += 256; /* Step-size. */
                                   ln = realloc(ln, *lnsz);
                                   if (NULL == ln)
                                           err(1, "realloc");
                                   *lnp = ln;
                           }
   
                           if ('\n' != buf[i]) {
                                   ln[pos++] = buf[i];
                                   continue;
                           }
   
                           /* Check for CPP-escaped newline.  */
   
                           if (pos > 0 && '\\' == ln[pos - 1]) {
                                   for (j = pos - 1; j >= 0; j--)
                                           if ('\\' != ln[j])
                                                   break;
   
                                   if ( ! ((pos - j) % 2)) {
                                           pos--;
                                           lnn++;
                                           continue;
                                   }
                           }
   
                           ln[pos] = 0;
                           if ( ! mdoc_parseln(mdoc, lnn, ln))
                                   return(0);
                           lnn++;
                           pos = 0;
                   }
           }
   
           return(mdoc_endparse(mdoc));
   }
   
   
   static int
   toptions(enum termt *tflags, char *arg)
   {
   
           if (0 == strcmp(arg, "ascii"))
                   *tflags = TERMT_ASCII;
           else if (0 == strcmp(arg, "lint"))
                   *tflags = TERMT_LINT;
           else if (0 == strcmp(arg, "tree"))
                   *tflags = TERMT_TREE;
           else {
                   warnx("bad argument: -T%s", arg);
                   return(0);
           }
   
           return(1);
   }
   
   
   /*
    * Parse out the options for [-fopt...] setting compiler options.  These
    * can be comma-delimited or called again.
    */
   static int
   foptions(int *fflags, char *arg)
   {
         char            *v;          char            *v;
         char            *toks[] = { "nopunt", NULL };          char            *toks[] = { "ign-scope", "ign-escape",
                                       "ign-macro", NULL };
   
         while (*arg)          while (*arg)
                 switch (getsubopt(&arg, toks, &v)) {                  switch (getsubopt(&arg, toks, &v)) {
                 case (0):                  case (0):
                         p->iflags |= TERMP_NOPUNT;                          *fflags |= MDOC_IGN_SCOPE;
                         break;                          break;
                   case (1):
                           *fflags |= MDOC_IGN_ESCAPE;
                           break;
                   case (2):
                           *fflags |= MDOC_IGN_MACRO;
                           break;
                 default:                  default:
                         warnx("unknown -O argument");                          warnx("bad argument: -f%s", arg);
                         return(0);                          return(0);
                 }                  }
   
Line 140  optsopt(struct termp *p, char *arg)
Line 343  optsopt(struct termp *p, char *arg)
 }  }
   
   
   /*
    * Parse out the options for [-Werr...], which sets warning modes.
    * These can be comma-delimited or called again.  XXX - should this be
    * using -w like troff?
    */
 static int  static int
 option(void *ptr, int c, char *arg)  woptions(int *wflags, char *arg)
 {  {
         struct termp    *termp;          char            *v;
         struct nroffopt *nroff;          char            *toks[] = { "all", "compat",
                           "syntax", "error", NULL };
   
         nroff = (struct nroffopt *)ptr;          while (*arg)
         termp = nroff->termp;                  switch (getsubopt(&arg, toks, &v)) {
                   case (0):
                           *wflags |= WARN_WALL;
                           break;
                   case (1):
                           *wflags |= WARN_WCOMPAT;
                           break;
                   case (2):
                           *wflags |= WARN_WSYNTAX;
                           break;
                   case (3):
                           *wflags |= WARN_WERR;
                           break;
                   default:
                           warnx("bad argument: -W%s", arg);
                           return(0);
                   }
   
         switch (c) {  
         case ('h'):  
                 nroff->fl_h = 1;  
                 break;  
         case ('i'):  
                 nroff->fl_i = 1;  
                 break;  
         case ('m'):  
                 nroff->arg_m = arg;  
                 break;  
         case ('n'):  
                 nroff->arg_n = arg;  
                 break;  
         case ('o'):  
                 nroff->arg_o = arg;  
                 break;  
         case ('r'):  
                 nroff->arg_r = arg;  
                 break;  
         case ('T'):  
                 nroff->arg_T = arg;  
                 break;  
         case ('O'):  
                 return(optsopt(termp, arg));  
         default:  
                 break;  
         }  
   
         return(1);          return(1);
 }  }
   
Line 201  option(void *ptr, int c, char *arg)
Line 398  option(void *ptr, int c, char *arg)
  *    columns.  In short: don't print a newline and instead pad to the   *    columns.  In short: don't print a newline and instead pad to the
  *    right margin.  Used in conjunction with TERMP_NOLPAD.   *    right margin.  Used in conjunction with TERMP_NOLPAD.
  *   *
    *  - TERMP_NONOBREAK: don't newline when TERMP_NOBREAK is specified.
    *
  *  In-line line breaking:   *  In-line line breaking:
  *   *
  *  If TERMP_NOBREAK is specified and the line overruns the right   *  If TERMP_NOBREAK is specified and the line overruns the right
Line 216  option(void *ptr, int c, char *arg)
Line 415  option(void *ptr, int c, char *arg)
 void  void
 flushln(struct termp *p)  flushln(struct termp *p)
 {  {
         size_t           i, j, vsz, vis, maxvis, mmax, bp;          int              i, j;
           size_t           vsz, vis, maxvis, mmax, bp;
   
         /*          /*
          * First, establish the maximum columns of "visible" content.           * First, establish the maximum columns of "visible" content.
Line 239  flushln(struct termp *p)
Line 439  flushln(struct termp *p)
   
         if ( ! (p->flags & TERMP_NOLPAD))          if ( ! (p->flags & TERMP_NOLPAD))
                 /* LINTED */                  /* LINTED */
                 for (j = 0; j < p->offset; j++)                  for (j = 0; j < (int)p->offset; j++)
                         putchar(' ');                          putchar(' ');
   
         for (i = 0; i < p->col; i++) {          for (i = 0; i < (int)p->col; i++) {
                 /*                  /*
                  * Count up visible word characters.  Control sequences                   * Count up visible word characters.  Control sequences
                  * (starting with the CSI) aren't counted.  A space                   * (starting with the CSI) aren't counted.  A space
Line 251  flushln(struct termp *p)
Line 451  flushln(struct termp *p)
                  */                   */
   
                 /* LINTED */                  /* LINTED */
                 for (j = i, vsz = 0; j < p->col; j++) {                  for (j = i, vsz = 0; j < (int)p->col; j++) {
                         if (' ' == p->buf[j])                          if (' ' == p->buf[j])
                                 break;                                  break;
                         else if (8 == p->buf[j])                          else if (8 == p->buf[j])
Line 271  flushln(struct termp *p)
Line 471  flushln(struct termp *p)
                 if ( ! (TERMP_NOBREAK & p->flags)) {                  if ( ! (TERMP_NOBREAK & p->flags)) {
                         if (vis && vis + vsz > bp) {                          if (vis && vis + vsz > bp) {
                                 putchar('\n');                                  putchar('\n');
                                 for (j = 0; j < p->offset; j++)                                  for (j = 0; j < (int)p->offset; j++)
                                         putchar(' ');                                          putchar(' ');
                                 vis = 0;                                  vis = 0;
                         } else if (vis + vsz > bp)                          } else if (vis + vsz > bp)
Line 282  flushln(struct termp *p)
Line 482  flushln(struct termp *p)
                 } else {                  } else {
                         if (vis && vis + vsz > bp) {                          if (vis && vis + vsz > bp) {
                                 putchar('\n');                                  putchar('\n');
                                 for (j = 0; j < p->rmargin; j++)                                  for (j = 0; j < (int)p->rmargin; j++)
                                         putchar(' ');                                          putchar(' ');
                                 vis = p->rmargin - p->offset;                                  vis = p->rmargin - p->offset;
                         } else if (vis + vsz > bp)                          } else if (vis + vsz > bp)
Line 297  flushln(struct termp *p)
Line 497  flushln(struct termp *p)
                  * our breakpoint.                   * our breakpoint.
                  */                   */
   
                 for ( ; i < p->col; i++) {                  for ( ; i < (int)p->col; i++) {
                         if (' ' == p->buf[i])                          if (' ' == p->buf[i])
                                 break;                                  break;
                         putchar(p->buf[i]);                          putchar(p->buf[i]);
                 }                  }
                 vis += vsz;                  vis += vsz;
                 if (i < p->col && vis <= bp) {                  if (i < (int)p->col && vis <= bp) {
                         putchar(' ');                          putchar(' ');
                         vis++;                          vis++;
                 }                  }
Line 317  flushln(struct termp *p)
Line 517  flushln(struct termp *p)
         if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) {          if ((TERMP_NOBREAK & p->flags) && vis >= maxvis) {
                 if ( ! (TERMP_NONOBREAK & p->flags)) {                  if ( ! (TERMP_NONOBREAK & p->flags)) {
                         putchar('\n');                          putchar('\n');
                         for (i = 0; i < p->rmargin; i++)                          for (i = 0; i < (int)p->rmargin; i++)
                                 putchar(' ');                                  putchar(' ');
                 }                  }
                 p->col = 0;                  p->col = 0;
Line 383  vspace(struct termp *p)
Line 583  vspace(struct termp *p)
 void  void
 word(struct termp *p, const char *word)  word(struct termp *p, const char *word)
 {  {
         size_t           i, j, len;          int              i, j, len;
   
         if (p->flags & TERMP_LITERAL) {          if (p->flags & TERMP_LITERAL) {
                 pword(p, word, strlen(word));                  pword(p, word, (int)strlen(word));
                 return;                  return;
         }          }
   
         if (0 == (len = strlen(word)))          if (0 == (len = (int)strlen(word)))
                 errx(1, "blank line not in literal context");                  errx(1, "blank line not in literal context");
   
         if (mdoc_isdelim(word)) {          if (mdoc_isdelim(word)) {
Line 537  footer(struct termp *p, const struct mdoc_meta *meta)
Line 737  footer(struct termp *p, const struct mdoc_meta *meta)
 static void  static void
 header(struct termp *p, const struct mdoc_meta *meta)  header(struct termp *p, const struct mdoc_meta *meta)
 {  {
         char            *buf, *title, *bufp;          char            *buf, *title;
   
         p->rmargin = p->maxrmargin;          p->rmargin = p->maxrmargin;
         p->offset = 0;          p->offset = 0;
Line 572  header(struct termp *p, const struct mdoc_meta *meta)
Line 772  header(struct termp *p, const struct mdoc_meta *meta)
         (void)snprintf(title, p->rmargin, "%s(%d)",          (void)snprintf(title, p->rmargin, "%s(%d)",
                         meta->title, meta->msec);                          meta->title, meta->msec);
   
         for (bufp = title; *bufp; bufp++)  
                 *bufp = toupper((u_char)*bufp);  
   
         p->offset = 0;          p->offset = 0;
         p->rmargin = (p->maxrmargin - strlen(buf)) / 2;          p->rmargin = (p->maxrmargin - strlen(buf)) / 2;
         p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;          p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
Line 617  nescape(struct termp *p, const char *word, size_t len)
Line 814  nescape(struct termp *p, const char *word, size_t len)
         const char      *rhs;          const char      *rhs;
         size_t           sz;          size_t           sz;
   
         if (NULL == (rhs = a2ascii(p->symtab, word, len, &sz))) {          if (NULL == (rhs = a2ascii(p->symtab, word, len, &sz)))
                 warnx("unsupported %zu-byte escape sequence", len);  
                 return;                  return;
         }  
   
         stringa(p, rhs, sz);          stringa(p, rhs, sz);
 }  }
   
Line 632  nescape(struct termp *p, const char *word, size_t len)
Line 826  nescape(struct termp *p, const char *word, size_t len)
  * the escape sequence (we assert upon badly-formed escape sequences).   * the escape sequence (we assert upon badly-formed escape sequences).
  */   */
 static void  static void
 pescape(struct termp *p, const char *word, size_t *i, size_t len)  pescape(struct termp *p, const char *word, int *i, int len)
 {  {
         size_t           j;          int              j;
   
         if (++(*i) >= len) {          if (++(*i) >= len)
                 warnx("ignoring bad escape sequence");  
                 return;                  return;
         }  
   
         if ('(' == word[*i]) {          if ('(' == word[*i]) {
                 (*i)++;                  (*i)++;
                 if (*i + 1 >= len) {                  if (*i + 1 >= len)
                         warnx("ignoring bad escape sequence");  
                         return;                          return;
                 }  
                 nescape(p, &word[*i], 2);                  nescape(p, &word[*i], 2);
                 (*i)++;                  (*i)++;
                 return;                  return;
   
         } else if ('*' == word[*i]) {          } else if ('*' == word[*i]) {
                 (*i)++;                  (*i)++;
                 if (*i >= len) {                  if (*i >= len)
                         warnx("ignoring bad escape sequence");  
                         return;                          return;
                 }  
                 switch (word[*i]) {                  switch (word[*i]) {
                 case ('('):                  case ('('):
                         (*i)++;                          (*i)++;
                         if (*i + 1 >= len) {                          if (*i + 1 >= len)
                                 warnx("ignoring bad escape sequence");  
                                 return;                                  return;
                         }  
                         nescape(p, &word[*i], 2);                          nescape(p, &word[*i], 2);
                         (*i)++;                          (*i)++;
                         return;                          return;
Line 683  pescape(struct termp *p, const char *word, size_t *i, 
Line 872  pescape(struct termp *p, const char *word, size_t *i, 
         for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++)          for (j = 0; word[*i] && ']' != word[*i]; (*i)++, j++)
                 /* Loop... */ ;                  /* Loop... */ ;
   
         if (0 == word[*i]) {          if (0 == word[*i])
                 warnx("ignoring bad escape sequence");  
                 return;                  return;
         }  
         nescape(p, &word[*i - j], j);          nescape(p, &word[*i - j], (size_t)j);
 }  }
   
   
Line 697  pescape(struct termp *p, const char *word, size_t *i, 
Line 885  pescape(struct termp *p, const char *word, size_t *i, 
  * handles word styling.   * handles word styling.
  */   */
 static void  static void
 pword(struct termp *p, const char *word, size_t len)  pword(struct termp *p, const char *word, int len)
 {  {
         size_t           i;          int              i;
   
         if ( ! (TERMP_NOSPACE & p->flags) &&          if ( ! (TERMP_NOSPACE & p->flags) &&
                         ! (TERMP_LITERAL & p->flags))                          ! (TERMP_LITERAL & p->flags))
Line 748  stringa(struct termp *p, const char *c, size_t sz)
Line 936  stringa(struct termp *p, const char *c, size_t sz)
         if (0 == sz)          if (0 == sz)
                 return;                  return;
   
         s = sz > p->maxcols * 2 ? sz : p->maxcols * 2;  
   
         assert(c);          assert(c);
         if (p->col + sz >= p->maxcols) {          if (p->col + sz >= p->maxcols) {
                   if (0 == p->maxcols)
                           p->maxcols = 256;
                   s = sz > p->maxcols * 2 ? sz : p->maxcols * 2;
                 p->buf = realloc(p->buf, s);                  p->buf = realloc(p->buf, s);
                 if (NULL == p->buf)                  if (NULL == p->buf)
                         err(1, "realloc");                          err(1, "realloc");
                 p->maxcols = s;                  p->maxcols = s;
         }          }
   
         (void)memcpy(&p->buf[p->col], c, sz);          (void)memcpy(&p->buf[(int)p->col], c, sz);
         p->col += sz;          p->col += sz;
 }  }
   
Line 771  stringa(struct termp *p, const char *c, size_t sz)
Line 960  stringa(struct termp *p, const char *c, size_t sz)
 static void  static void
 chara(struct termp *p, char c)  chara(struct termp *p, char c)
 {  {
           size_t           s;
   
         if (p->col + 1 >= p->maxcols) {          if (p->col + 1 >= p->maxcols) {
                 p->buf = realloc(p->buf, p->maxcols * 2);                  if (0 == p->maxcols)
                           p->maxcols = 256;
                   s = p->maxcols * 2;
                   p->buf = realloc(p->buf, s);
                 if (NULL == p->buf)                  if (NULL == p->buf)
                         err(1, "malloc");                          err(1, "realloc");
                 p->maxcols *= 2;                  p->maxcols = s;
         }          }
         p->buf[(p->col)++] = c;          p->buf[(int)(p->col)++] = c;
 }  }
   
   
Line 892  sanity(const struct mdoc_node *n)
Line 1085  sanity(const struct mdoc_node *n)
 }  }
   
   
 __dead void  static int
 punt(struct nroffopt *nroff, char *in)  merr(void *arg, int line, int col, const char *msg)
 {  {
         char            *args[32];  
         char             arg0[32], argm[32];  
         int              i;  
   
         warnx("punting to nroff!");          warnx("error: %s (line %d, column %d)", msg, line, col);
           return(0);
   }
   
         i = 0;  
   
         (void)strlcpy(arg0, "nroff", 32);  static int
         args[i++] = arg0;  mwarn(void *arg, int line, int col,
                   enum mdoc_warn type, const char *msg)
   {
           int              flags;
           char            *wtype;
   
         if (nroff->fl_h)          flags = *(int *)arg;
                 args[i++] = "-h";          wtype = NULL;
         if (nroff->fl_i)  
                 args[i++] = "-i";  
   
         if (nroff->arg_m) {          switch (type) {
                 (void)strlcpy(argm, "-m", 32);          case (WARN_COMPAT):
                 (void)strlcat(argm, nroff->arg_m, 32);                  wtype = "compat";
                 args[i++] = argm;                  if (flags & WARN_WCOMPAT)
         } else                          break;
                 args[i++] = "-mandoc";                  return(1);
           case (WARN_SYNTAX):
                   wtype = "syntax";
                   if (flags & WARN_WSYNTAX)
                           break;
                   return(1);
           }
   
         args[i++] = in;          assert(wtype);
         args[i++] = (char *)NULL;          warnx("%s warning: %s (line %d, column %d)",
                           wtype, msg, line, col);
   
         (void)execvp("nroff", args);          if ( ! (flags & WARN_WERR))
         errx(1, "exec");                  return(1);
         /* NOTREACHED */  
           warnx("%s: considering warnings as errors",
                           __progname);
           return(0);
 }  }
   
   
Legend:
Removed from v.1.48  
changed lines
  Added in v.1.49
CVSweb