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

Diff for /mandoc/roff.c between version 1.108 and 1.109

version 1.108, 2010/12/21 01:46:44 version 1.109, 2010/12/28 10:51:03
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_ad,
         ROFF_am,          ROFF_am,
Line 64  enum rofft {
Line 57  enum rofft {
         ROFF_rm,          ROFF_rm,
         ROFF_so,          ROFF_so,
         ROFF_tr,          ROFF_tr,
           ROFF_TS,
           ROFF_TE,
         ROFF_cblock,          ROFF_cblock,
         ROFF_ccond, /* FIXME: remove this. */          ROFF_ccond, /* FIXME: remove this. */
         ROFF_USERDEF,          ROFF_USERDEF,
Line 75  enum roffrule {
Line 70  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 91  struct roff {
Line 85  struct roff {
         struct regset   *regs; /* read/writable registers */          struct regset   *regs; /* read/writable registers */
         struct roffstr  *first_string; /* user-defined strings & macros */          struct roffstr  *first_string; /* user-defined strings & macros */
         const char      *current_string; /* value of last called user macro */          const char      *current_string; /* value of last called user macro */
           struct tbl      *tbl;
 };  };
   
 struct  roffnode {  struct  roffnode {
Line 146  static int   roff_res(struct roff *, 
Line 141  static int   roff_res(struct roff *, 
 static  void             roff_setstr(struct roff *,  static  void             roff_setstr(struct roff *,
                                 const char *, const char *, int);                                  const char *, const char *, int);
 static  enum rofferr     roff_so(ROFF_ARGS);  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_userdef(ROFF_ARGS);  static  enum rofferr     roff_userdef(ROFF_ARGS);
   
 /* See roff_hash_find() */  /* See roff_hash_find() */
Line 176  static struct roffmac  roffs[ROFF_MAX] = {
Line 173  static struct roffmac  roffs[ROFF_MAX] = {
         { "rm", roff_line_error, NULL, NULL, 0, NULL },          { "rm", roff_line_error, NULL, NULL, 0, NULL },
         { "so", roff_so, NULL, NULL, 0, NULL },          { "so", roff_so, NULL, NULL, 0, NULL },
         { "tr", roff_line_ignore, 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 },
         { ".", roff_cblock, NULL, NULL, 0, NULL },          { ".", roff_cblock, NULL, NULL, 0, NULL },
         { "\\}", roff_ccond, NULL, NULL, 0, NULL },          { "\\}", roff_ccond, NULL, NULL, 0, NULL },
         { NULL, roff_userdef, NULL, NULL, 0, NULL },          { NULL, roff_userdef, NULL, NULL, 0, NULL },
Line 264  roffnode_pop(struct roff *r)
Line 263  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;
         free(p->name);          free(p->name);
         free(p->end);          free(p->end);
Line 299  static void
Line 297  static void
 roff_free1(struct roff *r)  roff_free1(struct roff *r)
 {  {
   
           if (r->tbl) {
                   tbl_free(r->tbl);
                   r->tbl = NULL;
           }
   
         while (r->last)          while (r->last)
                 roffnode_pop(r);                  roffnode_pop(r);
   
         roff_freestr(r);          roff_freestr(r);
 }  }
   
Line 417  roff_res(struct roff *r, char **bufp, size_t *szp, int
Line 421  roff_res(struct roff *r, char **bufp, size_t *szp, int
   
                 /* Replace the escape sequence by the string. */                  /* Replace the escape sequence by the string. */
   
                 ROFF_DEBUG("roff: splicing reserved: [%.*s]\n", i, st);  
   
                 nsz = *szp + strlen(res) + 1;                  nsz = *szp + strlen(res) + 1;
                 n = mandoc_malloc(nsz);                  n = mandoc_malloc(nsz);
   
Line 442  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 444  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 461  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 464  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 477  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 484  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, [%s]\n",  
                                 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 494  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 499  roff_parseln(struct roff *r, int ln, char **bufp, 
         if (ROFF_MAX == (t = roff_parse(r, *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",  
                         ROFF_USERDEF == t ? r->current_string : 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 509  int
Line 510  int
 roff_endparse(struct roff *r)  roff_endparse(struct roff *r)
 {  {
   
         if (NULL == r->last)          if (r->last || r->tbl)
                 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));          return(1);
 }  }
   
   
Line 581  roff_cblock(ROFF_ARGS)
Line 582  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 601  roff_cblock(ROFF_ARGS)
Line 601  roff_cblock(ROFF_ARGS)
         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 635  roff_ccond(ROFF_ARGS)
Line 633  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 648  roff_ccond(ROFF_ARGS)
Line 645  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 986  roff_cond(ROFF_ARGS)
Line 980  roff_cond(ROFF_ARGS)
   
         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 1003  roff_cond(ROFF_ARGS)
Line 994  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 1020  roff_cond(ROFF_ARGS)
Line 1008  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 1117  roff_nr(ROFF_ARGS)
Line 1101  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);  }
   
   /* ARGSUSED */
   static enum rofferr
   roff_TE(ROFF_ARGS)
   {
   
           if (NULL == r->tbl)
                   (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL);
           else
                   tbl_free(r->tbl);
   
           r->tbl = NULL;
           return(ROFF_IGN);
   }
   
   /* ARGSUSED */
   static enum rofferr
   roff_TS(ROFF_ARGS)
   {
   
           if (r->tbl) {
                   (*r->msg)(MANDOCERR_SCOPEBROKEN, r->data, ln, ppos, NULL);
                   tbl_reset(r->tbl);
         } else          } else
                 ROFF_DEBUG("roff: ignoring register: %s\n", key);                  r->tbl = tbl_alloc();
   
         return(ROFF_IGN);          return(ROFF_IGN);
 }  }
Legend:
Removed from v.1.108  
changed lines
  Added in v.1.109
CVSweb