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

Diff for /mandoc/roff.c between version 1.90 and 1.103

version 1.90, 2010/06/27 15:52:41 version 1.103, 2010/12/01 10:21:25
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2010 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2010 Kristaps Dzonsons <kristaps@bsd.lv>
    * Copyright (c) 2010 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 27 
Line 28 
 #include <stdio.h>  #include <stdio.h>
   
 #include "mandoc.h"  #include "mandoc.h"
 #include "regs.h"  
 #include "roff.h"  #include "roff.h"
   #include "libmandoc.h"
   
 #define RSTACK_MAX      128  #define RSTACK_MAX      128
   
Line 44 
Line 45 
 #endif  #endif
   
 enum    rofft {  enum    rofft {
           ROFF_ad,
         ROFF_am,          ROFF_am,
         ROFF_ami,          ROFF_ami,
         ROFF_am1,          ROFF_am1,
Line 52  enum rofft {
Line 54  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_rm,          ROFF_rm,
         ROFF_tr,          ROFF_tr,
         ROFF_cblock,          ROFF_cblock,
         ROFF_ccond,          ROFF_ccond, /* FIXME: remove this. */
         ROFF_nr,          ROFF_nr,
         ROFF_MAX          ROFF_MAX
 };  };
Line 68  enum roffrule {
Line 73  enum roffrule {
         ROFFRULE_DENY          ROFFRULE_DENY
 };  };
   
   
   struct  roffstr {
           char            *name; /* key of symbol */
           char            *string; /* current value */
           struct roffstr  *next; /* next in list */
   };
   
 struct  roff {  struct  roff {
         struct roffnode *last; /* leaf of stack */          struct roffnode *last; /* leaf of stack */
         mandocmsg        msg; /* err/warn/fatal messages */          mandocmsg        msg; /* err/warn/fatal messages */
Line 75  struct roff {
Line 87  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  roffnode {  struct  roffnode {
Line 116  static enum rofferr  roff_ccond(ROFF_ARGS);
Line 129  static enum rofferr  roff_ccond(ROFF_ARGS);
 static  enum rofferr     roff_cond(ROFF_ARGS);  static  enum rofferr     roff_cond(ROFF_ARGS);
 static  enum rofferr     roff_cond_text(ROFF_ARGS);  static  enum rofferr     roff_cond_text(ROFF_ARGS);
 static  enum rofferr     roff_cond_sub(ROFF_ARGS);  static  enum rofferr     roff_cond_sub(ROFF_ARGS);
 static  enum rofferr     roff_line(ROFF_ARGS);  static  enum rofferr     roff_ds(ROFF_ARGS);
 static  enum rofferr     roff_nr(ROFF_ARGS);  
 static  enum roffrule    roff_evalcond(const char *, int *);  static  enum roffrule    roff_evalcond(const char *, int *);
   static  void             roff_freestr(struct roff *);
   static  const char      *roff_getstrn(const struct roff *,
                                   const char *, size_t);
   static  enum rofferr     roff_line_ignore(ROFF_ARGS);
   static  enum rofferr     roff_nr(ROFF_ARGS);
   static  int              roff_res(struct roff *,
                                   char **, size_t *, int);
   static  void             roff_setstr(struct roff *,
                                   const char *, const char *);
   static  char            *roff_strdup(const char *);
   
 /* See roff_hash_find() */  /* See roff_hash_find() */
   
Line 129  static enum roffrule  roff_evalcond(const char *, int 
Line 151  static enum roffrule  roff_evalcond(const char *, int 
 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 },
         { "de", roff_block, roff_block_text, roff_block_sub, 0, NULL },          { "de", roff_block, roff_block_text, roff_block_sub, 0, NULL },
         { "dei", roff_block, roff_block_text, roff_block_sub, 0, NULL },          { "dei", roff_block, roff_block_text, roff_block_sub, 0, NULL },
         { "de1", roff_block, roff_block_text, roff_block_sub, 0, NULL },          { "de1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
         { "ds", roff_line, 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 },
           { "rm", roff_line_ignore, NULL, NULL, 0, NULL },
           { "tr", roff_line_ignore, 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 },          { "nr", roff_nr, NULL, NULL, 0, NULL },
Line 151  static void   roff_free1(struct roff *);
Line 177  static void   roff_free1(struct roff *);
 static  enum rofft       roff_hash_find(const char *);  static  enum rofft       roff_hash_find(const char *);
 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, int, int);                                  enum rofft, 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(const char *, int *);
 static  int              roff_parse_nat(const char *, int *);  static  int              roff_parse_nat(const char *, unsigned int *);
   
 /* See roff_hash_find() */  /* See roff_hash_find() */
 #define ROFF_HASH(p)    (p[0] - ASCII_LO)  #define ROFF_HASH(p)    (p[0] - ASCII_LO)
Line 230  roffnode_pop(struct roff *r)
Line 256  roffnode_pop(struct roff *r)
                 if (r->rstackpos > -1)                  if (r->rstackpos > -1)
                         r->rstackpos--;                          r->rstackpos--;
   
           ROFF_DEBUG("roff: popping scope\n");
         r->last = r->last->parent;          r->last = r->last->parent;
         if (p->end)          if (p->end)
                 free(p->end);                  free(p->end);
Line 241  roffnode_pop(struct roff *r)
Line 268  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, 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;
         p->parent = r->last;          p->parent = r->last;
         p->line = line;          p->line = line;
Line 258  roffnode_push(struct roff *r, enum rofft tok, int line
Line 281  roffnode_push(struct roff *r, enum rofft tok, int line
         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);  
 }  }
   
   
Line 268  roff_free1(struct roff *r)
Line 290  roff_free1(struct roff *r)
   
         while (r->last)          while (r->last)
                 roffnode_pop(r);                  roffnode_pop(r);
           roff_freestr(r);
 }  }
   
   
Line 289  roff_free(struct roff *r)
Line 312  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 308  roff_alloc(struct regset *regs, const mandocmsg msg, v
Line 327  roff_alloc(struct regset *regs, const mandocmsg msg, v
 }  }
   
   
   /*
    * Pre-filter each and every line for reserved words (one beginning with
    * `\*', e.g., `\*(ab').  These must be handled before the actual line
    * is processed.
    */
   static int
   roff_res(struct roff *r, char **bufp, size_t *szp, int pos)
   {
           const char      *cp, *cpp, *st, *res;
           int              i, maxl;
           size_t           nsz;
           char            *n;
   
           /* LINTED */
           for (cp = &(*bufp)[pos]; (cpp = strstr(cp, "\\*")); cp++) {
                   cp = cpp + 2;
                   switch (*cp) {
                   case ('('):
                           cp++;
                           maxl = 2;
                           break;
                   case ('['):
                           cp++;
                           maxl = 0;
                           break;
                   default:
                           maxl = 1;
                           break;
                   }
   
                   st = cp;
   
                   for (i = 0; 0 == maxl || i < maxl; i++, cp++) {
                           if ('\0' == *cp)
                                   return(1); /* Error. */
                           if (0 == maxl && ']' == *cp)
                                   break;
                   }
   
                   res = roff_getstrn(r, st, (size_t)i);
   
                   if (NULL == res) {
                           cp -= maxl ? 1 : 0;
                           continue;
                   }
   
                   ROFF_DEBUG("roff: splicing reserved: [%.*s]\n", i, st);
   
                   nsz = *szp + strlen(res) + 1;
                   n = mandoc_malloc(nsz);
   
                   *n = '\0';
   
                   strlcat(n, *bufp, (size_t)(cpp - *bufp + 1));
                   strlcat(n, res, nsz);
                   strlcat(n, cp + (maxl ? 0 : 1), nsz);
   
                   free(*bufp);
   
                   *bufp = n;
                   *szp = nsz;
                   return(0);
           }
   
           return(1);
   }
   
   
 enum rofferr  enum rofferr
 roff_parseln(struct roff *r, int ln, char **bufp,  roff_parseln(struct roff *r, int ln, char **bufp,
                 size_t *szp, int pos, int *offs)                  size_t *szp, int pos, int *offs)
Line 316  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 403  roff_parseln(struct roff *r, int ln, char **bufp, 
         int              ppos;          int              ppos;
   
         /*          /*
            * Run the reserved-word filter only if we have some reserved
            * words to fill in.
            */
   
           if (r->first_string && ! roff_res(r, bufp, szp, pos))
                   return(ROFF_RERUN);
   
           /*
          * 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
          * text through the macro's filter.  If a scope isn't open and           * text through the macro's filter.  If a scope isn't open and
          * we're not a macro, just let it through.           * we're not a macro, just let it through.
Line 329  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 424  roff_parseln(struct roff *r, int ln, char **bufp, 
                 return((*roffs[t].text)                  return((*roffs[t].text)
                                 (r, t, bufp, szp,                                  (r, t, bufp, szp,
                                  ln, pos, pos, offs));                                   ln, pos, pos, offs));
         } else if ( ! ROFF_CTL((*bufp)[pos])) {          } else if ( ! ROFF_CTL((*bufp)[pos]))
                 ROFF_DEBUG("roff: pass non-scoped text: [%s]\n",  
                                 &(*bufp)[pos]);  
                 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 343  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 435  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",                  ROFF_DEBUG("roff: intercept scoped context: %s, [%s]\n",
                                 roffs[t].name);                                  roffs[t].name, &(*bufp)[pos]);
                 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 357  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 449  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(*bufp, &pos)))
                 ROFF_DEBUG("roff: pass non-scoped non-macro: [%s]\n",  
                                 &(*bufp)[pos]);  
                 return(ROFF_CONT);                  return(ROFF_CONT);
         }  
   
         ROFF_DEBUG("roff: intercept new-scope: %s, [%s]\n",          ROFF_DEBUG("roff: intercept new-scope: %s, [%s]\n",
                         roffs[t].name, &(*bufp)[pos]);                          roffs[t].name, &(*bufp)[pos]);
Line 425  roff_parse(const char *buf, int *pos)
Line 514  roff_parse(const char *buf, int *pos)
   
   
 static int  static int
 roff_parse_nat(const char *buf, int *res)  roff_parse_nat(const char *buf, unsigned int *res)
 {  {
         char            *ep;          char            *ep;
         long             lval;          long             lval;
Line 436  roff_parse_nat(const char *buf, int *res)
Line 525  roff_parse_nat(const char *buf, int *res)
                 return(0);                  return(0);
         if ((errno == ERANGE &&          if ((errno == ERANGE &&
                         (lval == LONG_MAX || lval == LONG_MIN)) ||                          (lval == LONG_MAX || lval == LONG_MIN)) ||
                         (lval > INT_MAX || lval <= 0))                          (lval > INT_MAX || lval < 0))
                 return(0);                  return(0);
   
         *res = (int)lval;          *res = (unsigned int)lval;
         return(1);          return(1);
 }  }
   
Line 562  roff_block(ROFF_ARGS)
Line 651  roff_block(ROFF_ARGS)
                         pos++;                          pos++;
         }          }
   
         if ( ! roffnode_push(r, tok, ln, ppos))          roffnode_push(r, tok, ln, ppos);
                 return(ROFF_ERR);  
   
         if ('\0' == (*bufp)[pos])          if ('\0' == (*bufp)[pos])
                 return(ROFF_IGN);                  return(ROFF_IGN);
Line 585  roff_block(ROFF_ARGS)
Line 673  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';
   
Line 674  roff_cond_sub(ROFF_ARGS)
Line 757  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 684  roff_cond_sub(ROFF_ARGS)
Line 766  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(*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 723  roff_cond_text(ROFF_ARGS)
Line 806  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 764  roff_evalcond(const char *v, int *pos)
Line 849  roff_evalcond(const char *v, int *pos)
   
 /* ARGSUSED */  /* ARGSUSED */
 static enum rofferr  static enum rofferr
 roff_line(ROFF_ARGS)  roff_line_ignore(ROFF_ARGS)
 {  {
   
         return(ROFF_IGN);          return(ROFF_IGN);
Line 817  roff_cond(ROFF_ARGS)
Line 902  roff_cond(ROFF_ARGS)
                 return(ROFF_ERR);                  return(ROFF_ERR);
         }          }
   
         if ( ! roffnode_push(r, tok, ln, ppos))          roffnode_push(r, tok, ln, ppos);
                 return(ROFF_ERR);  
   
         r->last->rule = rule;          r->last->rule = rule;
   
Line 879  roff_cond(ROFF_ARGS)
Line 963  roff_cond(ROFF_ARGS)
   
 /* ARGSUSED */  /* ARGSUSED */
 static enum rofferr  static enum rofferr
   roff_ds(ROFF_ARGS)
   {
           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;
           if ('\0' == *name)
                   return(ROFF_IGN);
   
           string = name;
           /* Read until end of name. */
           while (*string && ' ' != *string)
                   string++;
   
           /* Nil-terminate name. */
           if (*string)
                   *(string++) = '\0';
   
           /* Read past spaces. */
           while (*string && ' ' == *string)
                   string++;
   
           /* Read passed initial double-quote. */
           if (*string && '"' == *string)
                   string++;
   
           /* The rest is the value. */
           roff_setstr(r, name, string);
           return(ROFF_IGN);
   }
   
   
   /* ARGSUSED */
   static enum rofferr
 roff_nr(ROFF_ARGS)  roff_nr(ROFF_ARGS)
 {  {
         const char      *key, *val;          const char      *key, *val;
           struct reg      *rg;
   
         key = &(*bufp)[pos];          key = &(*bufp)[pos];
           rg = r->regs->regs;
   
         /* Parse register request. */          /* Parse register request. */
         while ((*bufp)[pos] && ' ' != (*bufp)[pos])          while ((*bufp)[pos] && ' ' != (*bufp)[pos])
Line 905  roff_nr(ROFF_ARGS)
Line 1034  roff_nr(ROFF_ARGS)
         /* Process register token. */          /* Process register token. */
   
         if (0 == strcmp(key, "nS")) {          if (0 == strcmp(key, "nS")) {
                 if ( ! roff_parse_nat(val, &r->regs->regs[(int)REG_nS].i))                  rg[(int)REG_nS].set = 1;
                         r->regs->regs[(int)REG_nS].i = 0;                  if ( ! roff_parse_nat(val, &rg[(int)REG_nS].v.u))
                           rg[(int)REG_nS].v.u = 0;
   
                 ROFF_DEBUG("roff: register nS: %d\n",                  ROFF_DEBUG("roff: register nS: %u\n",
                                 r->regs->regs[(int)REG_nS].i);                                  rg[(int)REG_nS].v.u);
         } else          } else
                 ROFF_DEBUG("roff: ignoring register: %s\n", key);                  ROFF_DEBUG("roff: ignoring register: %s\n", key);
   
         return(ROFF_IGN);          return(ROFF_IGN);
   }
   
   
   static char *
   roff_strdup(const char *name)
   {
           char            *namecopy, *sv;
   
           /*
            * This isn't a nice simple mandoc_strdup() because we must
            * handle roff's stupid double-escape rule.
            */
           sv = namecopy = mandoc_malloc(strlen(name) + 1);
           while (*name) {
                   if ('\\' == *name && '\\' == *(name + 1))
                           name++;
                   *namecopy++ = *name++;
           }
   
           *namecopy = '\0';
           return(sv);
   }
   
   
   static void
   roff_setstr(struct roff *r, const char *name, const char *string)
   {
           struct roffstr   *n;
           char             *namecopy;
   
           n = r->first_string;
           while (n && strcmp(name, n->name))
                   n = n->next;
   
           if (NULL == n) {
                   namecopy = mandoc_strdup(name);
                   n = mandoc_malloc(sizeof(struct roffstr));
                   n->name = namecopy;
                   n->next = r->first_string;
                   r->first_string = n;
           } else
                   free(n->string);
   
           /* Don't use mandoc_strdup: clean out double-escapes. */
           n->string = string ? roff_strdup(string) : NULL;
           ROFF_DEBUG("roff: new symbol: [%s] = [%s]\n", name, n->string);
   }
   
   
   static const char *
   roff_getstrn(const struct roff *r, const char *name, size_t len)
   {
           const struct roffstr *n;
   
           n = r->first_string;
           while (n && (strncmp(name, n->name, len) || '\0' != n->name[(int)len]))
                   n = n->next;
   
           return(n ? n->string : NULL);
   }
   
   
   static void
   roff_freestr(struct roff *r)
   {
           struct roffstr   *n, *nn;
   
           for (n = r->first_string; n; n = nn) {
                   free(n->name);
                   free(n->string);
                   nn = n->next;
                   free(n);
           }
   
           r->first_string = NULL;
 }  }
Legend:
Removed from v.1.90  
changed lines
  Added in v.1.103
CVSweb