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

Diff for /mandoc/roff.c between version 1.95 and 1.117

version 1.95, 2010/07/21 09:15:48 version 1.117, 2011/01/01 16:18:39
Line 7 
Line 7 
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.   * copyright notice and this permission notice appear in all copies.
  *   *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF   * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
Line 29 
Line 29 
   
 #include "mandoc.h"  #include "mandoc.h"
 #include "roff.h"  #include "roff.h"
   #include "libroff.h"
 #include "libmandoc.h"  #include "libmandoc.h"
   
 #define RSTACK_MAX      128  #define RSTACK_MAX      128
Line 36 
Line 37 
 #define ROFF_CTL(c) \  #define ROFF_CTL(c) \
         ('.' == (c) || '\'' == (c))          ('.' == (c) || '\'' == (c))
   
 #if 1  
 #define ROFF_DEBUG(fmt, args...) \  
         do { /* Nothing. */ } while (/*CONSTCOND*/ 0)  
 #else  
 #define ROFF_DEBUG(fmt, args...) \  
         do { fprintf(stderr, fmt , ##args); } while (/*CONSTCOND*/ 0)  
 #endif  
   
 enum    rofft {  enum    rofft {
           ROFF_ad,
         ROFF_am,          ROFF_am,
         ROFF_ami,          ROFF_ami,
         ROFF_am1,          ROFF_am1,
Line 53  enum rofft {
Line 47  enum rofft {
         ROFF_de1,          ROFF_de1,
         ROFF_ds,          ROFF_ds,
         ROFF_el,          ROFF_el,
           ROFF_hy,
         ROFF_ie,          ROFF_ie,
         ROFF_if,          ROFF_if,
         ROFF_ig,          ROFF_ig,
           ROFF_ne,
           ROFF_nh,
           ROFF_nr,
         ROFF_rm,          ROFF_rm,
           ROFF_so,
         ROFF_tr,          ROFF_tr,
           ROFF_TS,
           ROFF_TE,
           ROFF_T_,
         ROFF_cblock,          ROFF_cblock,
         ROFF_ccond,          ROFF_ccond, /* FIXME: remove this. */
         ROFF_nr,          ROFF_USERDEF,
         ROFF_MAX          ROFF_MAX
 };  };
   
Line 69  enum roffrule {
Line 71  enum roffrule {
         ROFFRULE_DENY          ROFFRULE_DENY
 };  };
   
   
 struct  roffstr {  struct  roffstr {
         char            *name; /* key of symbol */          char            *name; /* key of symbol */
         char            *string; /* current value */          char            *string; /* current value */
Line 83  struct roff {
Line 84  struct roff {
         enum roffrule    rstack[RSTACK_MAX]; /* stack of !`ie' rules */          enum roffrule    rstack[RSTACK_MAX]; /* stack of !`ie' rules */
         int              rstackpos; /* position in rstack */          int              rstackpos; /* position in rstack */
         struct regset   *regs; /* read/writable registers */          struct regset   *regs; /* read/writable registers */
         struct roffstr  *first_string;          struct roffstr  *first_string; /* user-defined strings & macros */
           const char      *current_string; /* value of last called user macro */
           struct tbl      *first_tbl; /* first table parsed */
           struct tbl      *last_tbl; /* last table parsed */
           struct tbl      *tbl; /* current table being parsed */
 };  };
   
 struct  roffnode {  struct  roffnode {
Line 91  struct roffnode {
Line 96  struct roffnode {
         struct roffnode *parent; /* up one in stack */          struct roffnode *parent; /* up one in stack */
         int              line; /* parse line */          int              line; /* parse line */
         int              col; /* parse col */          int              col; /* parse col */
           char            *name; /* node name, e.g. macro name */
         char            *end; /* end-rules: custom token */          char            *end; /* end-rules: custom token */
         int              endspan; /* end-rules: next-line or infty */          int              endspan; /* end-rules: next-line or infty */
         enum roffrule    rule; /* current evaluation rule */          enum roffrule    rule; /* current evaluation rule */
Line 130  static enum roffrule  roff_evalcond(const char *, int 
Line 136  static enum roffrule  roff_evalcond(const char *, int 
 static  void             roff_freestr(struct roff *);  static  void             roff_freestr(struct roff *);
 static  const char      *roff_getstrn(const struct roff *,  static  const char      *roff_getstrn(const struct roff *,
                                 const char *, size_t);                                  const char *, size_t);
 static  enum rofferr     roff_line(ROFF_ARGS);  static  enum rofferr     roff_line_ignore(ROFF_ARGS);
   static  enum rofferr     roff_line_error(ROFF_ARGS);
 static  enum rofferr     roff_nr(ROFF_ARGS);  static  enum rofferr     roff_nr(ROFF_ARGS);
 static  int              roff_res(struct roff *,  static  int              roff_res(struct roff *,
                                 char **, size_t *, int);                                  char **, size_t *, int);
 static  void             roff_setstr(struct roff *,  static  void             roff_setstr(struct roff *,
                                 const char *, const char *);                                  const char *, const char *, int);
   static  enum rofferr     roff_so(ROFF_ARGS);
   static  enum rofferr     roff_TE(ROFF_ARGS);
   static  enum rofferr     roff_TS(ROFF_ARGS);
   static  enum rofferr     roff_T_(ROFF_ARGS);
   static  enum rofferr     roff_userdef(ROFF_ARGS);
   
 /* See roff_hash_find() */  /* See roff_hash_find() */
   
Line 146  static void   roff_setstr(struct roff *,
Line 158  static void   roff_setstr(struct roff *,
 static  struct roffmac  *hash[HASHWIDTH];  static  struct roffmac  *hash[HASHWIDTH];
   
 static  struct roffmac   roffs[ROFF_MAX] = {  static  struct roffmac   roffs[ROFF_MAX] = {
           { "ad", roff_line_ignore, NULL, NULL, 0, NULL },
         { "am", roff_block, roff_block_text, roff_block_sub, 0, NULL },          { "am", roff_block, roff_block_text, roff_block_sub, 0, NULL },
         { "ami", roff_block, roff_block_text, roff_block_sub, 0, NULL },          { "ami", roff_block, roff_block_text, roff_block_sub, 0, NULL },
         { "am1", roff_block, roff_block_text, roff_block_sub, 0, NULL },          { "am1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
Line 154  static struct roffmac  roffs[ROFF_MAX] = {
Line 167  static struct roffmac  roffs[ROFF_MAX] = {
         { "de1", roff_block, roff_block_text, roff_block_sub, 0, NULL },          { "de1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
         { "ds", roff_ds, NULL, NULL, 0, NULL },          { "ds", roff_ds, NULL, NULL, 0, NULL },
         { "el", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },          { "el", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
           { "hy", roff_line_ignore, NULL, NULL, 0, NULL },
         { "ie", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },          { "ie", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
         { "if", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },          { "if", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
         { "ig", roff_block, roff_block_text, roff_block_sub, 0, NULL },          { "ig", roff_block, roff_block_text, roff_block_sub, 0, NULL },
         { "rm", roff_line, NULL, NULL, 0, NULL },          { "ne", roff_line_ignore, NULL, NULL, 0, NULL },
         { "tr", roff_line, NULL, NULL, 0, NULL },          { "nh", roff_line_ignore, NULL, NULL, 0, NULL },
           { "nr", roff_nr, NULL, NULL, 0, NULL },
           { "rm", roff_line_error, NULL, NULL, 0, NULL },
           { "so", roff_so, NULL, NULL, 0, NULL },
           { "tr", roff_line_ignore, NULL, NULL, 0, NULL },
           { "TS", roff_TS, NULL, NULL, 0, NULL },
           { "TE", roff_TE, NULL, NULL, 0, NULL },
           { "T&", roff_T_, NULL, NULL, 0, NULL },
         { ".", roff_cblock, NULL, NULL, 0, NULL },          { ".", roff_cblock, NULL, NULL, 0, NULL },
         { "\\}", roff_ccond, NULL, NULL, 0, NULL },          { "\\}", roff_ccond, NULL, NULL, 0, NULL },
         { "nr", roff_nr, NULL, NULL, 0, NULL },          { NULL, roff_userdef, NULL, NULL, 0, NULL },
 };  };
   
 static  void             roff_free1(struct roff *);  static  void             roff_free1(struct roff *);
 static  enum rofft       roff_hash_find(const char *);  static  enum rofft       roff_hash_find(const char *, size_t);
 static  void             roff_hash_init(void);  static  void             roff_hash_init(void);
 static  void             roffnode_cleanscope(struct roff *);  static  void             roffnode_cleanscope(struct roff *);
 static  int              roffnode_push(struct roff *,  static  void             roffnode_push(struct roff *, enum rofft,
                                 enum rofft, int, int);                                  const char *, int, int);
 static  void             roffnode_pop(struct roff *);  static  void             roffnode_pop(struct roff *);
 static  enum rofft       roff_parse(const char *, int *);  static  enum rofft       roff_parse(struct roff *, const char *, int *);
 static  int              roff_parse_nat(const char *, unsigned int *);  static  int              roff_parse_nat(const char *, unsigned int *);
   
 /* See roff_hash_find() */  /* See roff_hash_find() */
Line 183  roff_hash_init(void)
Line 204  roff_hash_init(void)
         struct roffmac   *n;          struct roffmac   *n;
         int               buc, i;          int               buc, i;
   
         for (i = 0; i < (int)ROFF_MAX; i++) {          for (i = 0; i < (int)ROFF_USERDEF; i++) {
                 assert(roffs[i].name[0] >= ASCII_LO);                  assert(roffs[i].name[0] >= ASCII_LO);
                 assert(roffs[i].name[0] <= ASCII_HI);                  assert(roffs[i].name[0] <= ASCII_HI);
   
Line 204  roff_hash_init(void)
Line 225  roff_hash_init(void)
  * the nil-terminated string name could be found.   * the nil-terminated string name could be found.
  */   */
 static enum rofft  static enum rofft
 roff_hash_find(const char *p)  roff_hash_find(const char *p, size_t s)
 {  {
         int              buc;          int              buc;
         struct roffmac  *n;          struct roffmac  *n;
Line 224  roff_hash_find(const char *p)
Line 245  roff_hash_find(const char *p)
         if (NULL == (n = hash[buc]))          if (NULL == (n = hash[buc]))
                 return(ROFF_MAX);                  return(ROFF_MAX);
         for ( ; n; n = n->next)          for ( ; n; n = n->next)
                 if (0 == strcmp(n->name, p))                  if (0 == strncmp(n->name, p, s) && '\0' == n->name[(int)s])
                         return((enum rofft)(n - roffs));                          return((enum rofft)(n - roffs));
   
         return(ROFF_MAX);          return(ROFF_MAX);
Line 248  roffnode_pop(struct roff *r)
Line 269  roffnode_pop(struct roff *r)
                         r->rstackpos--;                          r->rstackpos--;
   
         r->last = r->last->parent;          r->last = r->last->parent;
         if (p->end)          free(p->name);
                 free(p->end);          free(p->end);
         free(p);          free(p);
 }  }
   
Line 258  roffnode_pop(struct roff *r)
Line 279  roffnode_pop(struct roff *r)
  * Push a roff node onto the instruction stack.  This must later be   * Push a roff node onto the instruction stack.  This must later be
  * removed with roffnode_pop().   * removed with roffnode_pop().
  */   */
 static int  static void
 roffnode_push(struct roff *r, enum rofft tok, int line, int col)  roffnode_push(struct roff *r, enum rofft tok, const char *name,
                   int line, int col)
 {  {
         struct roffnode *p;          struct roffnode *p;
   
         if (NULL == (p = calloc(1, sizeof(struct roffnode)))) {          p = mandoc_calloc(1, sizeof(struct roffnode));
                 (*r->msg)(MANDOCERR_MEM, r->data, line, col, NULL);  
                 return(0);  
         }  
   
         p->tok = tok;          p->tok = tok;
           if (name)
                   p->name = mandoc_strdup(name);
         p->parent = r->last;          p->parent = r->last;
         p->line = line;          p->line = line;
         p->col = col;          p->col = col;
         p->rule = p->parent ? p->parent->rule : ROFFRULE_DENY;          p->rule = p->parent ? p->parent->rule : ROFFRULE_DENY;
   
         r->last = p;          r->last = p;
         return(1);  
 }  }
   
   
 static void  static void
 roff_free1(struct roff *r)  roff_free1(struct roff *r)
 {  {
           struct tbl      *t;
   
           while (r->first_tbl) {
                   t = r->first_tbl;
                   r->first_tbl = t->next;
                   tbl_free(t);
           }
   
           r->first_tbl = r->last_tbl = r->tbl = NULL;
   
         while (r->last)          while (r->last)
                 roffnode_pop(r);                  roffnode_pop(r);
   
         roff_freestr(r);          roff_freestr(r);
 }  }
   
Line 307  roff_free(struct roff *r)
Line 336  roff_free(struct roff *r)
   
   
 struct roff *  struct roff *
 roff_alloc(struct regset *regs, const mandocmsg msg, void *data)  roff_alloc(struct regset *regs, void *data, const mandocmsg msg)
 {  {
         struct roff     *r;          struct roff     *r;
   
         if (NULL == (r = calloc(1, sizeof(struct roff)))) {          r = mandoc_calloc(1, sizeof(struct roff));
                 (*msg)(MANDOCERR_MEM, data, 0, 0, NULL);  
                 return(0);  
         }  
   
         r->regs = regs;          r->regs = regs;
         r->msg = msg;          r->msg = msg;
         r->data = data;          r->data = data;
Line 334  roff_alloc(struct regset *regs, const mandocmsg msg, v
Line 359  roff_alloc(struct regset *regs, const mandocmsg msg, v
 static int  static int
 roff_res(struct roff *r, char **bufp, size_t *szp, int pos)  roff_res(struct roff *r, char **bufp, size_t *szp, int pos)
 {  {
         const char      *cp, *cpp, *st, *res;          const char      *stesc; /* start of an escape sequence ('\\') */
           const char      *stnam; /* start of the name, after "[(*" */
           const char      *cp;    /* end of the name, e.g. before ']' */
           const char      *res;   /* the string to be substituted */
         int              i, maxl;          int              i, maxl;
         size_t           nsz;          size_t           nsz;
         char            *n;          char            *n;
   
         /* LINTED */          /* Search for a leading backslash and save a pointer to it. */
         for (cp = &(*bufp)[pos]; (cpp = strstr(cp, "\\*")); cp++) {  
                 cp = cpp + 2;          cp = *bufp + pos;
           while (NULL != (cp = strchr(cp, '\\'))) {
                   stesc = cp++;
   
                   /*
                    * The second character must be an asterisk.
                    * If it isn't, skip it anyway:  It is escaped,
                    * so it can't start another escape sequence.
                    */
   
                   if ('\0' == *cp)
                           return(1);
                   if ('*' != *cp++)
                           continue;
   
                   /*
                    * The third character decides the length
                    * of the name of the string.
                    * Save a pointer to the name.
                    */
   
                 switch (*cp) {                  switch (*cp) {
                   case ('\0'):
                           return(1);
                 case ('('):                  case ('('):
                         cp++;                          cp++;
                         maxl = 2;                          maxl = 2;
Line 355  roff_res(struct roff *r, char **bufp, size_t *szp, int
Line 405  roff_res(struct roff *r, char **bufp, size_t *szp, int
                         maxl = 1;                          maxl = 1;
                         break;                          break;
                 }                  }
                   stnam = cp;
   
                 st = cp;                  /* Advance to the end of the name. */
   
                 for (i = 0; 0 == maxl || i < maxl; i++, cp++) {                  for (i = 0; 0 == maxl || i < maxl; i++, cp++) {
                         if ('\0' == *cp)                          if ('\0' == *cp)
Line 365  roff_res(struct roff *r, char **bufp, size_t *szp, int
Line 416  roff_res(struct roff *r, char **bufp, size_t *szp, int
                                 break;                                  break;
                 }                  }
   
                 res = roff_getstrn(r, st, (size_t)i);                  /*
                    * Retrieve the replacement string; if it is
                    * undefined, resume searching for escapes.
                    */
   
                   res = roff_getstrn(r, stnam, (size_t)i);
   
                 if (NULL == res) {                  if (NULL == res) {
                         cp -= maxl ? 1 : 0;                          cp -= maxl ? 1 : 0;
                         continue;                          continue;
                 }                  }
   
                 ROFF_DEBUG("roff: splicing reserved: [%.*s]\n", i, st);                  /* Replace the escape sequence by the string. */
   
                 nsz = *szp + strlen(res) + 1;                  nsz = *szp + strlen(res) + 1;
                 n = mandoc_malloc(nsz);                  n = mandoc_malloc(nsz);
   
                 *n = '\0';                  strlcpy(n, *bufp, (size_t)(stesc - *bufp + 1));
   
                 strlcat(n, *bufp, (size_t)(cpp - *bufp + 1));  
                 strlcat(n, res, nsz);                  strlcat(n, res, nsz);
                 strlcat(n, cp + (maxl ? 0 : 1), nsz);                  strlcat(n, cp + (maxl ? 0 : 1), nsz);
   
Line 399  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 453  roff_parseln(struct roff *r, int ln, char **bufp, 
                 size_t *szp, int pos, int *offs)                  size_t *szp, int pos, int *offs)
 {  {
         enum rofft       t;          enum rofft       t;
           enum rofferr     e;
         int              ppos;          int              ppos;
   
         /*          /*
Line 407  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 462  roff_parseln(struct roff *r, int ln, char **bufp, 
          */           */
   
         if (r->first_string && ! roff_res(r, bufp, szp, pos))          if (r->first_string && ! roff_res(r, bufp, szp, pos))
                 return(ROFF_RERUN);                  return(ROFF_REPARSE);
   
         /*          /*
          * First, if a scope is open and we're not a macro, pass the           * First, if a scope is open and we're not a macro, pass the
Line 418  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 473  roff_parseln(struct roff *r, int ln, char **bufp, 
         if (r->last && ! ROFF_CTL((*bufp)[pos])) {          if (r->last && ! ROFF_CTL((*bufp)[pos])) {
                 t = r->last->tok;                  t = r->last->tok;
                 assert(roffs[t].text);                  assert(roffs[t].text);
                 ROFF_DEBUG("roff: intercept scoped text: %s, [%s]\n",                  e = (*roffs[t].text)
                                 roffs[t].name, &(*bufp)[pos]);                          (r, t, bufp, szp, ln, pos, pos, offs);
                 return((*roffs[t].text)                  assert(ROFF_IGN == e || ROFF_CONT == e);
                                 (r, t, bufp, szp,                  if (ROFF_CONT == e && r->tbl)
                                  ln, pos, pos, offs));                          return(tbl_read(r->tbl, ln, *bufp, *offs));
         } else if ( ! ROFF_CTL((*bufp)[pos]))                  return(e);
           } else if ( ! ROFF_CTL((*bufp)[pos])) {
                   if (r->tbl)
                           return(tbl_read(r->tbl, ln, *bufp, *offs));
                 return(ROFF_CONT);                  return(ROFF_CONT);
           }
   
         /*          /*
          * If a scope is open, go to the child handler for that macro,           * If a scope is open, go to the child handler for that macro,
Line 434  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 493  roff_parseln(struct roff *r, int ln, char **bufp, 
         if (r->last) {          if (r->last) {
                 t = r->last->tok;                  t = r->last->tok;
                 assert(roffs[t].sub);                  assert(roffs[t].sub);
                 ROFF_DEBUG("roff: intercept scoped context: %s\n",  
                                 roffs[t].name);  
                 return((*roffs[t].sub)                  return((*roffs[t].sub)
                                 (r, t, bufp, szp,                                  (r, t, bufp, szp,
                                  ln, pos, pos, offs));                                   ln, pos, pos, offs));
Line 448  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 505  roff_parseln(struct roff *r, int ln, char **bufp, 
          */           */
   
         ppos = pos;          ppos = pos;
         if (ROFF_MAX == (t = roff_parse(*bufp, &pos)))          if (ROFF_MAX == (t = roff_parse(r, *bufp, &pos)))
                 return(ROFF_CONT);                  return(ROFF_CONT);
   
         ROFF_DEBUG("roff: intercept new-scope: %s, [%s]\n",  
                         roffs[t].name, &(*bufp)[pos]);  
         assert(roffs[t].proc);          assert(roffs[t].proc);
         return((*roffs[t].proc)          return((*roffs[t].proc)
                         (r, t, bufp, szp,                          (r, t, bufp, szp,
Line 460  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 515  roff_parseln(struct roff *r, int ln, char **bufp, 
 }  }
   
   
 int  void
 roff_endparse(struct roff *r)  roff_endparse(struct roff *r)
 {  {
   
         if (NULL == r->last)          if (r->last)
                 return(1);                  (*r->msg)(MANDOCERR_SCOPEEXIT, r->data,
         return((*r->msg)(MANDOCERR_SCOPEEXIT, r->data, r->last->line,                                  r->last->line, r->last->col, NULL);
                                 r->last->col, NULL));  
           if (r->tbl) {
                   (*r->msg)(MANDOCERR_SCOPEEXIT, r->data,
                                   r->tbl->line, r->tbl->pos, NULL);
                   tbl_end(r->tbl);
                   r->tbl = NULL;
           }
 }  }
   
   
Line 476  roff_endparse(struct roff *r)
Line 537  roff_endparse(struct roff *r)
  * form of ".foo xxx" in the usual way.   * form of ".foo xxx" in the usual way.
  */   */
 static enum rofft  static enum rofft
 roff_parse(const char *buf, int *pos)  roff_parse(struct roff *r, const char *buf, int *pos)
 {  {
         int              j;          const char      *mac;
         char             mac[5];          size_t           maclen;
         enum rofft       t;          enum rofft       t;
   
         assert(ROFF_CTL(buf[*pos]));          assert(ROFF_CTL(buf[*pos]));
         (*pos)++;          (*pos)++;
   
         while (buf[*pos] && (' ' == buf[*pos] || '\t' == buf[*pos]))          while (' ' == buf[*pos] || '\t' == buf[*pos])
                 (*pos)++;                  (*pos)++;
   
         if ('\0' == buf[*pos])          if ('\0' == buf[*pos])
                 return(ROFF_MAX);                  return(ROFF_MAX);
   
         for (j = 0; j < 4; j++, (*pos)++)          mac = buf + *pos;
                 if ('\0' == (mac[j] = buf[*pos]))          maclen = strcspn(mac, " \\\t\0");
                         break;  
                 else if (' ' == buf[*pos] || (j && '\\' == buf[*pos]))  
                         break;  
   
         if (j == 4 || j < 1)          t = (r->current_string = roff_getstrn(r, mac, maclen))
                 return(ROFF_MAX);              ? ROFF_USERDEF : roff_hash_find(mac, maclen);
   
         mac[j] = '\0';          *pos += maclen;
   
         if (ROFF_MAX == (t = roff_hash_find(mac)))  
                 return(t);  
   
         while (buf[*pos] && ' ' == buf[*pos])          while (buf[*pos] && ' ' == buf[*pos])
                 (*pos)++;                  (*pos)++;
   
Line 543  roff_cblock(ROFF_ARGS)
Line 597  roff_cblock(ROFF_ARGS)
          */           */
   
         if (NULL == r->last) {          if (NULL == r->last) {
                 if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))                  (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL);
                         return(ROFF_ERR);  
                 return(ROFF_IGN);                  return(ROFF_IGN);
         }          }
   
Line 556  roff_cblock(ROFF_ARGS)
Line 609  roff_cblock(ROFF_ARGS)
         case (ROFF_am1):          case (ROFF_am1):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (ROFF_de):          case (ROFF_de):
                   /* ROFF_de1 is remapped to ROFF_de in roff_block(). */
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (ROFF_dei):          case (ROFF_dei):
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case (ROFF_de1):  
                 /* FALLTHROUGH */  
         case (ROFF_ig):          case (ROFF_ig):
                 break;                  break;
         default:          default:
                 if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))                  (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL);
                         return(ROFF_ERR);  
                 return(ROFF_IGN);                  return(ROFF_IGN);
         }          }
   
         if ((*bufp)[pos])          if ((*bufp)[pos])
                 if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL))                  (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL);
                         return(ROFF_ERR);  
   
         roffnode_pop(r);          roffnode_pop(r);
         roffnode_cleanscope(r);          roffnode_cleanscope(r);
Line 598  roff_ccond(ROFF_ARGS)
Line 648  roff_ccond(ROFF_ARGS)
 {  {
   
         if (NULL == r->last) {          if (NULL == r->last) {
                 if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))                  (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL);
                         return(ROFF_ERR);  
                 return(ROFF_IGN);                  return(ROFF_IGN);
         }          }
   
Line 611  roff_ccond(ROFF_ARGS)
Line 660  roff_ccond(ROFF_ARGS)
         case (ROFF_if):          case (ROFF_if):
                 break;                  break;
         default:          default:
                 if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))                  (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL);
                         return(ROFF_ERR);  
                 return(ROFF_IGN);                  return(ROFF_IGN);
         }          }
   
         if (r->last->endspan > -1) {          if (r->last->endspan > -1) {
                 if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL))                  (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL);
                         return(ROFF_ERR);  
                 return(ROFF_IGN);                  return(ROFF_IGN);
         }          }
   
         if ((*bufp)[pos])          if ((*bufp)[pos])
                 if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL))                  (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL);
                         return(ROFF_ERR);  
   
         roffnode_pop(r);          roffnode_pop(r);
         roffnode_cleanscope(r);          roffnode_cleanscope(r);
Line 638  roff_block(ROFF_ARGS)
Line 684  roff_block(ROFF_ARGS)
 {  {
         int             sv;          int             sv;
         size_t          sz;          size_t          sz;
           char            *name;
   
         if (ROFF_ig != tok && '\0' == (*bufp)[pos]) {          name = NULL;
                 if ( ! (*r->msg)(MANDOCERR_NOARGS, r->data, ln, ppos, NULL))  
                         return(ROFF_ERR);          if (ROFF_ig != tok) {
                 return(ROFF_IGN);                  if ('\0' == (*bufp)[pos]) {
         } else if (ROFF_ig != tok) {                          (*r->msg)(MANDOCERR_NOARGS, r->data, ln, ppos, NULL);
                           return(ROFF_IGN);
                   }
   
                   /*
                    * Re-write `de1', since we don't really care about
                    * groff's strange compatibility mode, into `de'.
                    */
   
                   if (ROFF_de1 == tok)
                           tok = ROFF_de;
                   if (ROFF_de == tok)
                           name = *bufp + pos;
                   else
                           (*r->msg)(MANDOCERR_REQUEST, r->data, ln, ppos,
                               roffs[tok].name);
   
                 while ((*bufp)[pos] && ' ' != (*bufp)[pos])                  while ((*bufp)[pos] && ' ' != (*bufp)[pos])
                         pos++;                          pos++;
   
                 while (' ' == (*bufp)[pos])                  while (' ' == (*bufp)[pos])
                         pos++;                          (*bufp)[pos++] = '\0';
         }          }
   
         if ( ! roffnode_push(r, tok, ln, ppos))          roffnode_push(r, tok, name, ln, ppos);
                 return(ROFF_ERR);  
   
           /*
            * At the beginning of a `de' macro, clear the existing string
            * with the same name, if there is one.  New content will be
            * added from roff_block_text() in multiline mode.
            */
   
           if (ROFF_de == tok)
                   roff_setstr(r, name, "", 0);
   
         if ('\0' == (*bufp)[pos])          if ('\0' == (*bufp)[pos])
                 return(ROFF_IGN);                  return(ROFF_IGN);
   
           /* If present, process the custom end-of-line marker. */
   
         sv = pos;          sv = pos;
         while ((*bufp)[pos] && ' ' != (*bufp)[pos] &&          while ((*bufp)[pos] &&
                           ' ' != (*bufp)[pos] &&
                         '\t' != (*bufp)[pos])                          '\t' != (*bufp)[pos])
                 pos++;                  pos++;
   
Line 673  roff_block(ROFF_ARGS)
Line 748  roff_block(ROFF_ARGS)
         if (1 == sz && '.' == (*bufp)[sv])          if (1 == sz && '.' == (*bufp)[sv])
                 return(ROFF_IGN);                  return(ROFF_IGN);
   
         r->last->end = malloc(sz + 1);          r->last->end = mandoc_malloc(sz + 1);
   
         if (NULL == r->last->end) {  
                 (*r->msg)(MANDOCERR_MEM, r->data, ln, pos, NULL);  
                 return(ROFF_ERR);  
         }  
   
         memcpy(r->last->end, *bufp + sv, sz);          memcpy(r->last->end, *bufp + sv, sz);
         r->last->end[(int)sz] = '\0';          r->last->end[(int)sz] = '\0';
   
         if ((*bufp)[pos])          if ((*bufp)[pos])
                 if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL))                  (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL);
                         return(ROFF_ERR);  
   
         return(ROFF_IGN);          return(ROFF_IGN);
 }  }
Line 723  roff_block_sub(ROFF_ARGS)
Line 792  roff_block_sub(ROFF_ARGS)
                         roffnode_pop(r);                          roffnode_pop(r);
                         roffnode_cleanscope(r);                          roffnode_cleanscope(r);
   
                         if (ROFF_MAX != roff_parse(*bufp, &pos))                          if (ROFF_MAX != roff_parse(r, *bufp, &pos))
                                 return(ROFF_RERUN);                                  return(ROFF_RERUN);
                         return(ROFF_IGN);                          return(ROFF_IGN);
                 }                  }
Line 735  roff_block_sub(ROFF_ARGS)
Line 804  roff_block_sub(ROFF_ARGS)
          */           */
   
         ppos = pos;          ppos = pos;
         t = roff_parse(*bufp, &pos);          t = roff_parse(r, *bufp, &pos);
   
         /* If we're not a comment-end, then throw it away. */          /*
         if (ROFF_cblock != t)           * Macros other than block-end are only significant
            * in `de' blocks; elsewhere, simply throw them away.
            */
           if (ROFF_cblock != t) {
                   if (ROFF_de == tok)
                           roff_setstr(r, r->last->name, *bufp + ppos, 1);
                 return(ROFF_IGN);                  return(ROFF_IGN);
           }
   
         assert(roffs[t].proc);          assert(roffs[t].proc);
         return((*roffs[t].proc)(r, t, bufp, szp,          return((*roffs[t].proc)(r, t, bufp, szp,
Line 752  static enum rofferr
Line 827  static enum rofferr
 roff_block_text(ROFF_ARGS)  roff_block_text(ROFF_ARGS)
 {  {
   
           if (ROFF_de == tok)
                   roff_setstr(r, r->last->name, *bufp + pos, 1);
   
         return(ROFF_IGN);          return(ROFF_IGN);
 }  }
   
Line 762  roff_cond_sub(ROFF_ARGS)
Line 840  roff_cond_sub(ROFF_ARGS)
 {  {
         enum rofft       t;          enum rofft       t;
         enum roffrule    rr;          enum roffrule    rr;
         struct roffnode *l;  
   
         ppos = pos;          ppos = pos;
         rr = r->last->rule;          rr = r->last->rule;
Line 772  roff_cond_sub(ROFF_ARGS)
Line 849  roff_cond_sub(ROFF_ARGS)
          * continue.           * continue.
          */           */
   
         l = r->last;  
         roffnode_cleanscope(r);          roffnode_cleanscope(r);
   
         if (l != r->last)          if (ROFF_MAX == (t = roff_parse(r, *bufp, &pos))) {
                   if ('\\' == (*bufp)[pos] && '}' == (*bufp)[pos + 1])
                           return(roff_ccond
                                   (r, ROFF_ccond, bufp, szp,
                                    ln, pos, pos + 2, offs));
                 return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);                  return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);
           }
   
         if (ROFF_MAX == (t = roff_parse(*bufp, &pos)))  
                 return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);  
   
         /*          /*
          * A denied conditional must evaluate its children if and only           * A denied conditional must evaluate its children if and only
          * if they're either structurally required (such as loops and           * if they're either structurally required (such as loops and
Line 811  roff_cond_text(ROFF_ARGS)
Line 889  roff_cond_text(ROFF_ARGS)
          * scope permits us to do so.           * scope permits us to do so.
          */           */
   
           /* FIXME: use roff_ccond? */
   
         st = &(*bufp)[pos];          st = &(*bufp)[pos];
         if (NULL == (ep = strstr(st, "\\}"))) {          if (NULL == (ep = strstr(st, "\\}"))) {
                 roffnode_cleanscope(r);                  roffnode_cleanscope(r);
Line 849  roff_evalcond(const char *v, int *pos)
Line 929  roff_evalcond(const char *v, int *pos)
         return(ROFFRULE_DENY);          return(ROFFRULE_DENY);
 }  }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static enum rofferr  static enum rofferr
 roff_line(ROFF_ARGS)  roff_line_ignore(ROFF_ARGS)
 {  {
   
         return(ROFF_IGN);          return(ROFF_IGN);
 }  }
   
   /* ARGSUSED */
   static enum rofferr
   roff_line_error(ROFF_ARGS)
   {
   
           (*r->msg)(MANDOCERR_REQUEST, r->data, ln, ppos, roffs[tok].name);
           return(ROFF_IGN);
   }
   
 /* ARGSUSED */  /* ARGSUSED */
 static enum rofferr  static enum rofferr
 roff_cond(ROFF_ARGS)  roff_cond(ROFF_ARGS)
Line 900  roff_cond(ROFF_ARGS)
Line 987  roff_cond(ROFF_ARGS)
          */           */
   
         if ('\0' == (*bufp)[pos] && sv != pos) {          if ('\0' == (*bufp)[pos] && sv != pos) {
                 if ((*r->msg)(MANDOCERR_NOARGS, r->data, ln, ppos, NULL))                  (*r->msg)(MANDOCERR_NOARGS, r->data, ln, ppos, NULL);
                         return(ROFF_IGN);                  return(ROFF_IGN);
                 return(ROFF_ERR);  
         }          }
   
         if ( ! roffnode_push(r, tok, ln, ppos))          roffnode_push(r, tok, NULL, ln, ppos);
                 return(ROFF_ERR);  
   
         r->last->rule = rule;          r->last->rule = rule;
   
         ROFF_DEBUG("roff: cond: %s -> %s\n", roffs[tok].name,  
                         ROFFRULE_ALLOW == rule ?  "allow" : "deny");  
   
         if (ROFF_ie == tok) {          if (ROFF_ie == tok) {
                 /*                  /*
                  * An if-else will put the NEGATION of the current                   * An if-else will put the NEGATION of the current
Line 927  roff_cond(ROFF_ARGS)
Line 1009  roff_cond(ROFF_ARGS)
   
         /* If the parent has false as its rule, then so do we. */          /* If the parent has false as its rule, then so do we. */
   
         if (r->last->parent && ROFFRULE_DENY == r->last->parent->rule) {          if (r->last->parent && ROFFRULE_DENY == r->last->parent->rule)
                 r->last->rule = ROFFRULE_DENY;                  r->last->rule = ROFFRULE_DENY;
                 ROFF_DEBUG("roff: cond override: %s -> deny\n",  
                                 roffs[tok].name);  
         }  
   
         /*          /*
          * Determine scope.  If we're invoked with "\{" trailing the           * Determine scope.  If we're invoked with "\{" trailing the
Line 944  roff_cond(ROFF_ARGS)
Line 1023  roff_cond(ROFF_ARGS)
         if ('\\' == (*bufp)[pos] && '{' == (*bufp)[pos + 1]) {          if ('\\' == (*bufp)[pos] && '{' == (*bufp)[pos + 1]) {
                 r->last->endspan = -1;                  r->last->endspan = -1;
                 pos += 2;                  pos += 2;
                 ROFF_DEBUG("roff: cond-scope: %s, multi-line\n",          }
                                 roffs[tok].name);  
         } else  
                 ROFF_DEBUG("roff: cond-scope: %s, one-line\n",  
                                 roffs[tok].name);  
   
         /*          /*
          * If there are no arguments on the line, the next-line scope is           * If there are no arguments on the line, the next-line scope is
Line 969  roff_cond(ROFF_ARGS)
Line 1044  roff_cond(ROFF_ARGS)
 static enum rofferr  static enum rofferr
 roff_ds(ROFF_ARGS)  roff_ds(ROFF_ARGS)
 {  {
         char *name, *string, *end;          char            *name, *string;
   
           /*
            * A symbol is named by the first word following the macro
            * invocation up to a space.  Its value is anything after the
            * name's trailing whitespace and optional double-quote.  Thus,
            *
            *  [.ds foo "bar  "     ]
            *
            * will have `bar  "     ' as its value.
            */
   
         name = *bufp + pos;          name = *bufp + pos;
         if ('\0' == *name)          if ('\0' == *name)
                 return(ROFF_IGN);                  return(ROFF_IGN);
   
         string = name;          string = name;
           /* Read until end of name. */
         while (*string && ' ' != *string)          while (*string && ' ' != *string)
                 string++;                  string++;
   
           /* Nil-terminate name. */
         if (*string)          if (*string)
                 *(string++) = NULL;                  *(string++) = '\0';
         if (*string && '"' == *string)  
                 string++;          /* Read past spaces. */
         while (*string && ' ' == *string)          while (*string && ' ' == *string)
                 string++;                  string++;
         end = string;  
         while (*end)  
                 end++;  
         if (string < end) {  
                 end--;  
                 if (*end == '"')  
                         *end = '\0';  
         }  
   
         roff_setstr(r, name, string);          /* Read passed initial double-quote. */
           if (*string && '"' == *string)
                   string++;
   
           /* The rest is the value. */
           roff_setstr(r, name, string, 0);
         return(ROFF_IGN);          return(ROFF_IGN);
 }  }
   
Line 1031  roff_nr(ROFF_ARGS)
Line 1116  roff_nr(ROFF_ARGS)
                 rg[(int)REG_nS].set = 1;                  rg[(int)REG_nS].set = 1;
                 if ( ! roff_parse_nat(val, &rg[(int)REG_nS].v.u))                  if ( ! roff_parse_nat(val, &rg[(int)REG_nS].v.u))
                         rg[(int)REG_nS].v.u = 0;                          rg[(int)REG_nS].v.u = 0;
           }
   
                 ROFF_DEBUG("roff: register nS: %u\n",          return(ROFF_IGN);
                                 rg[(int)REG_nS].v.u);  }
         } else  
                 ROFF_DEBUG("roff: ignoring register: %s\n", key);  
   
   /* ARGSUSED */
   static enum rofferr
   roff_TE(ROFF_ARGS)
   {
   
           if (NULL == r->tbl)
                   (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL);
           else
                   tbl_end(r->tbl);
   
           r->tbl = NULL;
         return(ROFF_IGN);          return(ROFF_IGN);
 }  }
   
   /* ARGSUSED */
   static enum rofferr
   roff_T_(ROFF_ARGS)
   {
   
           if (NULL == r->tbl)
                   (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL);
           else
                   tbl_restart(ppos, ln, r->tbl);
   
           return(ROFF_IGN);
   }
   
   /* ARGSUSED */
   static enum rofferr
   roff_TS(ROFF_ARGS)
   {
           struct tbl      *t;
   
           if (r->tbl) {
                   (*r->msg)(MANDOCERR_SCOPEBROKEN, r->data, ln, ppos, NULL);
                   tbl_end(r->tbl);
           }
   
           t = tbl_alloc(ppos, ln, r->data, r->msg);
   
           if (r->last_tbl)
                   r->last_tbl->next = t;
           else
                   r->first_tbl = r->last_tbl = t;
   
           r->tbl = r->last_tbl = t;
           return(ROFF_IGN);
   }
   
   /* ARGSUSED */
   static enum rofferr
   roff_so(ROFF_ARGS)
   {
           char *name;
   
           (*r->msg)(MANDOCERR_SO, r->data, ln, ppos, NULL);
   
           /*
            * Handle `so'.  Be EXTREMELY careful, as we shouldn't be
            * opening anything that's not in our cwd or anything beneath
            * it.  Thus, explicitly disallow traversing up the file-system
            * or using absolute paths.
            */
   
           name = *bufp + pos;
           if ('/' == *name || strstr(name, "../") || strstr(name, "/..")) {
                   (*r->msg)(MANDOCERR_SOPATH, r->data, ln, pos, NULL);
                   return(ROFF_ERR);
           }
   
           *offs = pos;
           return(ROFF_SO);
   }
   
   /* ARGSUSED */
   static enum rofferr
   roff_userdef(ROFF_ARGS)
   {
           const char       *arg[9];
           char             *cp, *n1, *n2;
           int               i, quoted, pairs;
   
           /*
            * Collect pointers to macro argument strings
            * and null-terminate them.
            */
           cp = *bufp + pos;
           for (i = 0; i < 9; i++) {
                   /* Quoting can only start with a new word. */
                   if ('"' == *cp) {
                           quoted = 1;
                           cp++;
                   } else
                           quoted = 0;
                   arg[i] = cp;
                   for (pairs = 0; '\0' != *cp; cp++) {
                           /* Unquoted arguments end at blanks. */
                           if (0 == quoted) {
                                   if (' ' == *cp)
                                           break;
                                   continue;
                           }
                           /* After pairs of quotes, move left. */
                           if (pairs)
                                   cp[-pairs] = cp[0];
                           /* Pairs of quotes do not end words, ... */
                           if ('"' == cp[0] && '"' == cp[1]) {
                                   pairs++;
                                   cp++;
                                   continue;
                           }
                           /* ... but solitary quotes do. */
                           if ('"' != *cp)
                                   continue;
                           if (pairs)
                                   cp[-pairs] = '\0';
                           *cp = ' ';
                           break;
                   }
                   /* Last argument; the remaining ones are empty strings. */
                   if ('\0' == *cp)
                           continue;
                   /* Null-terminate argument and move to the next one. */
                   *cp++ = '\0';
                   while (' ' == *cp)
                           cp++;
           }
   
           /*
            * Expand macro arguments.
            */
           *szp = 0;
           n1 = cp = mandoc_strdup(r->current_string);
           while (NULL != (cp = strstr(cp, "\\$"))) {
                   i = cp[2] - '1';
                   if (0 > i || 8 < i) {
                           /* Not an argument invocation. */
                           cp += 2;
                           continue;
                   }
   
                   *szp = strlen(n1) - 3 + strlen(arg[i]) + 1;
                   n2 = mandoc_malloc(*szp);
   
                   strlcpy(n2, n1, (size_t)(cp - n1 + 1));
                   strlcat(n2, arg[i], *szp);
                   strlcat(n2, cp + 3, *szp);
   
                   cp = n2 + (cp - n1);
                   free(n1);
                   n1 = n2;
           }
   
           /*
            * Replace the macro invocation
            * by the expanded macro.
            */
           free(*bufp);
           *bufp = n1;
           if (0 == *szp)
                   *szp = strlen(*bufp) + 1;
   
           return(*szp > 1 && '\n' == (*bufp)[(int)*szp - 2] ?
              ROFF_REPARSE : ROFF_APPEND);
   }
   
   /*
    * Store *string into the user-defined string called *name.
    * In multiline mode, append to an existing entry and append '\n';
    * else replace the existing entry, if there is one.
    * To clear an existing entry, call with (*r, *name, NULL, 0).
    */
 static void  static void
 roff_setstr(struct roff *r, const char *name, const char *string)  roff_setstr(struct roff *r, const char *name, const char *string,
           int multiline)
 {  {
         struct roffstr   *n;          struct roffstr   *n;
         char             *namecopy;          char             *c;
           size_t            oldch, newch;
   
           /* Search for an existing string with the same name. */
         n = r->first_string;          n = r->first_string;
         while (n && strcmp(name, n->name))          while (n && strcmp(name, n->name))
                 n = n->next;                  n = n->next;
   
         if (NULL == n) {          if (NULL == n) {
                 namecopy = mandoc_strdup(name);                  /* Create a new string table entry. */
                 n = mandoc_malloc(sizeof(struct roffstr));                  n = mandoc_malloc(sizeof(struct roffstr));
                 n->name = namecopy;                  n->name = mandoc_strdup(name);
                   n->string = NULL;
                 n->next = r->first_string;                  n->next = r->first_string;
                 r->first_string = n;                  r->first_string = n;
         } else          } else if (0 == multiline) {
                   /* In multiline mode, append; else replace. */
                 free(n->string);                  free(n->string);
                   n->string = NULL;
           }
   
         n->string = string ? strdup(string) : NULL;          if (NULL == string)
                   return;
   
           /*
            * One additional byte for the '\n' in multiline mode,
            * and one for the terminating '\0'.
            */
           newch = strlen(string) + (multiline ? 2 : 1);
           if (NULL == n->string) {
                   n->string = mandoc_malloc(newch);
                   *n->string = '\0';
                   oldch = 0;
           } else {
                   oldch = strlen(n->string);
                   n->string = mandoc_realloc(n->string, oldch + newch);
           }
   
           /* Skip existing content in the destination buffer. */
           c = n->string + oldch;
   
           /* Append new content to the destination buffer. */
           while (*string) {
                   /*
                    * Rudimentary roff copy mode:
                    * Handle escaped backslashes.
                    */
                   if ('\\' == *string && '\\' == *(string + 1))
                           string++;
                   *c++ = *string++;
           }
   
           /* Append terminating bytes. */
           if (multiline)
                   *c++ = '\n';
           *c = '\0';
 }  }
   
   
Line 1070  roff_getstrn(const struct roff *r, const char *name, s
Line 1363  roff_getstrn(const struct roff *r, const char *name, s
         const struct roffstr *n;          const struct roffstr *n;
   
         n = r->first_string;          n = r->first_string;
         while (n && (strncmp(name, n->name, len) || '\0' != n->name[len]))          while (n && (strncmp(name, n->name, len) || '\0' != n->name[(int)len]))
                 n = n->next;                  n = n->next;
   
         return(n ? n->string : NULL);          return(n ? n->string : NULL);
Line 1090  roff_freestr(struct roff *r)
Line 1383  roff_freestr(struct roff *r)
         }          }
   
         r->first_string = NULL;          r->first_string = NULL;
   }
   
   const struct tbl_span *
   roff_span(const struct roff *r)
   {
   
           return(r->tbl ? tbl_span(r->tbl) : NULL);
 }  }
Legend:
Removed from v.1.95  
changed lines
  Added in v.1.117
CVSweb