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

Diff for /mandoc/roff.c between version 1.89 and 1.93

version 1.89, 2010/06/26 15:22:19 version 1.93, 2010/07/04 22:04:04
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 74  struct roff {
Line 75  struct roff {
         void            *data; /* privdata for messages */          void            *data; /* privdata for messages */
         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  roffnode {  struct  roffnode {
Line 87  struct roffnode {
Line 89  struct roffnode {
 };  };
   
 #define ROFF_ARGS        struct roff *r, /* parse ctx */ \  #define ROFF_ARGS        struct roff *r, /* parse ctx */ \
                          struct regset *regs, /* registers */ \  
                          enum rofft tok, /* tok of macro */ \                           enum rofft tok, /* tok of macro */ \
                          char **bufp, /* input buffer */ \                           char **bufp, /* input buffer */ \
                          size_t *szp, /* size of input buffer */ \                           size_t *szp, /* size of input buffer */ \
Line 108  struct roffmac {
Line 109  struct roffmac {
         struct roffmac  *next;          struct roffmac  *next;
 };  };
   
   struct roffstr {
           char            *name;
           char            *string;
           struct roffstr  *next;
   } *first_string;
   
 static  enum rofferr     roff_block(ROFF_ARGS);  static  enum rofferr     roff_block(ROFF_ARGS);
 static  enum rofferr     roff_block_text(ROFF_ARGS);  static  enum rofferr     roff_block_text(ROFF_ARGS);
 static  enum rofferr     roff_block_sub(ROFF_ARGS);  static  enum rofferr     roff_block_sub(ROFF_ARGS);
Line 116  static enum rofferr  roff_ccond(ROFF_ARGS);
Line 123  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_ds(ROFF_ARGS);
 static  enum rofferr     roff_line(ROFF_ARGS);  static  enum rofferr     roff_line(ROFF_ARGS);
 static  enum rofferr     roff_nr(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 *);
Line 135  static struct roffmac  roffs[ROFF_MAX] = {
Line 143  static struct roffmac  roffs[ROFF_MAX] = {
         { "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 },
         { "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 },
Line 155  static int   roffnode_push(struct roff *, 
Line 163  static int   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 268  roff_free1(struct roff *r)
Line 276  roff_free1(struct roff *r)
   
         while (r->last)          while (r->last)
                 roffnode_pop(r);                  roffnode_pop(r);
           roff_freestr();
 }  }
   
   
Line 289  roff_free(struct roff *r)
Line 298  roff_free(struct roff *r)
   
   
 struct roff *  struct roff *
 roff_alloc(const mandocmsg msg, void *data)  roff_alloc(struct regset *regs, const mandocmsg msg, void *data)
 {  {
         struct roff     *r;          struct roff     *r;
   
Line 298  roff_alloc(const mandocmsg msg, void *data)
Line 307  roff_alloc(const mandocmsg msg, void *data)
                 return(0);                  return(0);
         }          }
   
           r->regs = regs;
         r->msg = msg;          r->msg = msg;
         r->data = data;          r->data = data;
         r->rstackpos = -1;          r->rstackpos = -1;
Line 308  roff_alloc(const mandocmsg msg, void *data)
Line 318  roff_alloc(const mandocmsg msg, void *data)
   
   
 enum rofferr  enum rofferr
 roff_parseln(struct roff *r, struct regset *regs, int ln,  roff_parseln(struct roff *r, int ln, char **bufp,
                 char **bufp, size_t *szp, int pos, int *offs)                  size_t *szp, int pos, int *offs)
 {  {
         enum rofft       t;          enum rofft       t;
         int              ppos;          int              ppos;
Line 326  roff_parseln(struct roff *r, struct regset *regs, int 
Line 336  roff_parseln(struct roff *r, struct regset *regs, int 
                 ROFF_DEBUG("roff: intercept scoped text: %s, [%s]\n",                  ROFF_DEBUG("roff: intercept scoped text: %s, [%s]\n",
                                 roffs[t].name, &(*bufp)[pos]);                                  roffs[t].name, &(*bufp)[pos]);
                 return((*roffs[t].text)                  return((*roffs[t].text)
                                 (r, regs, t, bufp,                                  (r, t, bufp, szp,
                                  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",                  ROFF_DEBUG("roff: pass non-scoped text: [%s]\n",
                                 &(*bufp)[pos]);                                  &(*bufp)[pos]);
Line 345  roff_parseln(struct roff *r, struct regset *regs, int 
Line 355  roff_parseln(struct roff *r, struct regset *regs, int 
                 ROFF_DEBUG("roff: intercept scoped context: %s\n",                  ROFF_DEBUG("roff: intercept scoped context: %s\n",
                                 roffs[t].name);                                  roffs[t].name);
                 return((*roffs[t].sub)                  return((*roffs[t].sub)
                                 (r, regs, t, bufp,                                  (r, t, bufp, szp,
                                  szp, ln, pos, pos, offs));                                   ln, pos, pos, offs));
         }          }
   
         /*          /*
Line 366  roff_parseln(struct roff *r, struct regset *regs, int 
Line 376  roff_parseln(struct roff *r, struct regset *regs, int 
                         roffs[t].name, &(*bufp)[pos]);                          roffs[t].name, &(*bufp)[pos]);
         assert(roffs[t].proc);          assert(roffs[t].proc);
         return((*roffs[t].proc)          return((*roffs[t].proc)
                         (r, regs, t, bufp,                          (r, t, bufp, szp,
                          szp, ln, ppos, pos, offs));                           ln, ppos, pos, offs));
 }  }
   
   
Line 424  roff_parse(const char *buf, int *pos)
Line 434  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 435  roff_parse_nat(const char *buf, int *res)
Line 445  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 653  roff_block_sub(ROFF_ARGS)
Line 663  roff_block_sub(ROFF_ARGS)
                 return(ROFF_IGN);                  return(ROFF_IGN);
   
         assert(roffs[t].proc);          assert(roffs[t].proc);
         return((*roffs[t].proc)(r, regs, t, bufp,          return((*roffs[t].proc)(r, t, bufp, szp,
                         szp, ln, ppos, pos, offs));                                  ln, ppos, pos, offs));
 }  }
   
   
Line 703  roff_cond_sub(ROFF_ARGS)
Line 713  roff_cond_sub(ROFF_ARGS)
                                 return(ROFF_IGN);                                  return(ROFF_IGN);
   
         assert(roffs[t].proc);          assert(roffs[t].proc);
         return((*roffs[t].proc)          return((*roffs[t].proc)(r, t, bufp, szp,
                         (r, regs, t, bufp, szp, ln, ppos, pos, offs));                                  ln, ppos, pos, offs));
 }  }
   
   
Line 878  roff_cond(ROFF_ARGS)
Line 888  roff_cond(ROFF_ARGS)
   
 /* ARGSUSED */  /* ARGSUSED */
 static enum rofferr  static enum rofferr
   roff_ds(ROFF_ARGS)
   {
           char *name, *string, *end;
   
           name = *bufp + pos;
           if ('\0' == *name)
                   return(ROFF_IGN);
   
           string = name;
           while (*string && ' ' != *string)
                   string++;
           if (*string)
                   *(string++) = NULL;
           if (*string && '"' == *string)
                   string++;
           while (*string && ' ' == *string)
                   string++;
           end = string;
           while (*end)
                   end++;
           if (string < end) {
                   end--;
                   if (*end == '"')
                           *end = '\0';
           }
   
           roff_setstr(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 904  roff_nr(ROFF_ARGS)
Line 949  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, &regs->regs[(int)REG_nS].i))                  rg[(int)REG_nS].set = 1;
                         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",
                                 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);
   }
   
   
   char *
   roff_setstr(const char *name, const char *string)
   {
           struct roffstr   *n;
           char             *namecopy;
   
           n = first_string;
           while (n && strcmp(name, n->name))
                   n = n->next;
           if (n) {
                   free(n->string);
           } else {
                   if (NULL == (namecopy = strdup(name)))
                           return(NULL);
                   if (NULL == (n = malloc(sizeof(struct roffstr)))) {
                           free(n);
                           return(NULL);
                   }
                   n->name = namecopy;
                   n->next = first_string;
                   first_string = n;
           }
           if (string)
                   n->string = strdup(string);
           else
                   n->string = NULL;
           return(n->string);
   }
   
   char *
   roff_getstr(const char *name)
   {
           struct roffstr   *n;
   
           n = first_string;
           while (n && strcmp(name, n->name))
                   n = n->next;
           if (n)
                   return(n->string);
           else
                   return(NULL);
   }
   
   char *
   roff_getstrn(const char *name, size_t len)
   {
           struct roffstr   *n;
   
           n = first_string;
           while (n && (strncmp(name, n->name, len) || '\0' != n->name[len]))
                   n = n->next;
           if (n)
                   return(n->string);
           else
                   return(NULL);
   }
   
   void
   roff_freestr(void)
   {
           struct roffstr   *n, *nn;
   
           for (n = first_string; n; n = nn) {
                   free(n->name);
                   free(n->string);
                   nn = n->next;
                   free(n);
           }
           first_string = NULL;
 }  }
Legend:
Removed from v.1.89  
changed lines
  Added in v.1.93
CVSweb