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

Diff for /mandoc/roff.c between version 1.87 and 1.91

version 1.87, 2010/06/09 20:00:38 version 1.91, 2010/06/27 16:36:22
Line 19 
Line 19 
 #endif  #endif
   
 #include <assert.h>  #include <assert.h>
   #include <errno.h>
 #include <ctype.h>  #include <ctype.h>
   #include <limits.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include <stdio.h>  #include <stdio.h>
   
 #include "mandoc.h"  #include "mandoc.h"
   #include "regs.h"
 #include "roff.h"  #include "roff.h"
   
 #define RSTACK_MAX      128  #define RSTACK_MAX      128
Line 32 
Line 35 
 #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_am,          ROFF_am,
         ROFF_ami,          ROFF_ami,
Line 48  enum rofft {
Line 59  enum rofft {
         ROFF_tr,          ROFF_tr,
         ROFF_cblock,          ROFF_cblock,
         ROFF_ccond,          ROFF_ccond,
           ROFF_nr,
         ROFF_MAX          ROFF_MAX
 };  };
   
Line 62  struct roff {
Line 74  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 104  static enum rofferr  roff_cond(ROFF_ARGS);
Line 117  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_line(ROFF_ARGS);
   static  enum rofferr     roff_nr(ROFF_ARGS);
   static  enum roffrule    roff_evalcond(const char *, int *);
   
 /* See roff_hash_find() */  /* See roff_hash_find() */
   
Line 129  static struct roffmac  roffs[ROFF_MAX] = {
Line 144  static struct roffmac  roffs[ROFF_MAX] = {
         { "tr", roff_line, NULL, NULL, 0, NULL },          { "tr", roff_line, 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 },
 };  };
   
 static  void             roff_free1(struct roff *);  static  void             roff_free1(struct roff *);
Line 139  static int   roffnode_push(struct roff *, 
Line 155  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 *, 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 272  roff_free(struct roff *r)
Line 289  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 281  roff_alloc(const mandocmsg msg, void *data)
Line 298  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 291  roff_alloc(const mandocmsg msg, void *data)
Line 309  roff_alloc(const mandocmsg msg, void *data)
   
   
 enum rofferr  enum rofferr
 roff_parseln(struct roff *r, 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 306  roff_parseln(struct roff *r, int ln, 
Line 324  roff_parseln(struct roff *r, int ln, 
         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",
                                   roffs[t].name, &(*bufp)[pos]);
                 return((*roffs[t].text)                  return((*roffs[t].text)
                                 (r, t, bufp, szp, ln, pos, pos, offs));                                  (r, t, bufp, szp,
         } else if ( ! ROFF_CTL((*bufp)[pos]))                                   ln, pos, pos, offs));
           } 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 319  roff_parseln(struct roff *r, int ln, 
Line 343  roff_parseln(struct roff *r, int ln, 
         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, ln, pos, pos, offs));                                  (r, t, bufp, szp,
                                    ln, pos, pos, offs));
         }          }
   
         /*          /*
Line 330  roff_parseln(struct roff *r, int ln, 
Line 357  roff_parseln(struct roff *r, int ln, 
          */           */
   
         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",
                           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, ln, ppos, pos, offs));                          (r, t, bufp, szp,
                            ln, ppos, pos, offs));
 }  }
   
   
Line 391  roff_parse(const char *buf, int *pos)
Line 424  roff_parse(const char *buf, int *pos)
 }  }
   
   
   static int
   roff_parse_nat(const char *buf, unsigned int *res)
   {
           char            *ep;
           long             lval;
   
           errno = 0;
           lval = strtol(buf, &ep, 10);
           if (buf[0] == '\0' || *ep != '\0')
                   return(0);
           if ((errno == ERANGE &&
                           (lval == LONG_MAX || lval == LONG_MIN)) ||
                           (lval > INT_MAX || lval < 0))
                   return(0);
   
           *res = (unsigned int)lval;
           return(1);
   }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static enum rofferr  static enum rofferr
 roff_cblock(ROFF_ARGS)  roff_cblock(ROFF_ARGS)
Line 601  roff_block_sub(ROFF_ARGS)
Line 654  roff_block_sub(ROFF_ARGS)
                 return(ROFF_IGN);                  return(ROFF_IGN);
   
         assert(roffs[t].proc);          assert(roffs[t].proc);
         return((*roffs[t].proc)(r, t, bufp,          return((*roffs[t].proc)(r, t, bufp, szp,
                         szp, ln, ppos, pos, offs));                                  ln, ppos, pos, offs));
 }  }
   
   
Line 651  roff_cond_sub(ROFF_ARGS)
Line 704  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, t, bufp, szp, ln, ppos, pos, offs));                                  ln, ppos, pos, offs));
 }  }
   
   
Line 684  roff_cond_text(ROFF_ARGS)
Line 737  roff_cond_text(ROFF_ARGS)
 }  }
   
   
   static enum roffrule
   roff_evalcond(const char *v, int *pos)
   {
   
           switch (v[*pos]) {
           case ('n'):
                   (*pos)++;
                   return(ROFFRULE_ALLOW);
           case ('e'):
                   /* FALLTHROUGH */
           case ('o'):
                   /* FALLTHROUGH */
           case ('t'):
                   (*pos)++;
                   return(ROFFRULE_DENY);
           default:
                   break;
           }
   
           while (v[*pos] && ' ' != v[*pos])
                   (*pos)++;
           return(ROFFRULE_DENY);
   }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static enum rofferr  static enum rofferr
   roff_line(ROFF_ARGS)
   {
   
           return(ROFF_IGN);
   }
   
   
   /* ARGSUSED */
   static enum rofferr
 roff_cond(ROFF_ARGS)  roff_cond(ROFF_ARGS)
 {  {
         int              cpos;  /* position of the condition */  
         int              sv;          int              sv;
           enum roffrule    rule;
   
         /* Stack overflow! */          /* Stack overflow! */
   
Line 698  roff_cond(ROFF_ARGS)
Line 785  roff_cond(ROFF_ARGS)
                 return(ROFF_ERR);                  return(ROFF_ERR);
         }          }
   
         cpos = pos;          /* First, evaluate the conditional. */
   
         if (ROFF_if == tok || ROFF_ie == tok) {          if (ROFF_el == tok) {
                 /*                  /*
                  * Read ahead past the conditional.  FIXME: this does                   * An `.el' will get the value of the current rstack
                  * not work, as conditionals don't end on whitespace,                   * entry set in prior `ie' calls or defaults to DENY.
                  * but are parsed according to a formal grammar.  It's                   */
                  * good enough for now, however.                  if (r->rstackpos < 0)
                  */                          rule = ROFFRULE_DENY;
                 while ((*bufp)[pos] && ' ' != (*bufp)[pos])                  else
                         pos++;                          rule = r->rstack[r->rstackpos];
         }          } else
                   rule = roff_evalcond(*bufp, &pos);
   
         sv = pos;          sv = pos;
   
         while (' ' == (*bufp)[pos])          while (' ' == (*bufp)[pos])
                 pos++;                  pos++;
   
Line 721  roff_cond(ROFF_ARGS)
Line 810  roff_cond(ROFF_ARGS)
          * really doing anything.  Warn about this.  It's probably           * really doing anything.  Warn about this.  It's probably
          * wrong.           * wrong.
          */           */
   
         if ('\0' == (*bufp)[pos] && sv != pos) {          if ('\0' == (*bufp)[pos] && sv != pos) {
                 if ( ! (*r->msg)(MANDOCERR_NOARGS, r->data, ln, ppos, NULL))                  if ((*r->msg)(MANDOCERR_NOARGS, r->data, ln, ppos, NULL))
                         return(ROFF_ERR);                          return(ROFF_IGN);
                 return(ROFF_IGN);                  return(ROFF_ERR);
         }          }
   
         if ( ! roffnode_push(r, tok, ln, ppos))          if ( ! roffnode_push(r, tok, ln, ppos))
                 return(ROFF_ERR);                  return(ROFF_ERR);
   
         /* XXX: Implement more conditionals. */          r->last->rule = rule;
   
         if (ROFF_if == tok || ROFF_ie == tok)          ROFF_DEBUG("roff: cond: %s -> %s\n", roffs[tok].name,
                 r->last->rule = 'n' == (*bufp)[cpos] ?                          ROFFRULE_ALLOW == rule ?  "allow" : "deny");
                     ROFFRULE_ALLOW : ROFFRULE_DENY;  
         else if (ROFF_el == tok) {  
                 /*  
                  * An `.el' will get the value of the current rstack  
                  * entry set in prior `ie' calls or defaults to DENY.  
                  */  
                 if (r->rstackpos < 0)  
                         r->last->rule = ROFFRULE_DENY;  
                 else  
                         r->last->rule = r->rstack[r->rstackpos];  
         }  
         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 756  roff_cond(ROFF_ARGS)
Line 836  roff_cond(ROFF_ARGS)
                 else                  else
                         r->rstack[r->rstackpos] = ROFFRULE_DENY;                          r->rstack[r->rstackpos] = ROFFRULE_DENY;
         }          }
         if (r->last->parent && ROFFRULE_DENY == r->last->parent->rule)  
           /* If the parent has false as its rule, then so do we. */
   
           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
            * conditional, then we're in a multiline scope.  Else our scope
            * expires on the next line.
            */
   
         r->last->endspan = 1;          r->last->endspan = 1;
   
         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 783  roff_cond(ROFF_ARGS)
Line 879  roff_cond(ROFF_ARGS)
   
 /* ARGSUSED */  /* ARGSUSED */
 static enum rofferr  static enum rofferr
 roff_line(ROFF_ARGS)  roff_nr(ROFF_ARGS)
 {  {
           const char      *key, *val;
           struct reg      *rg;
   
           key = &(*bufp)[pos];
           rg = r->regs->regs;
   
           /* Parse register request. */
           while ((*bufp)[pos] && ' ' != (*bufp)[pos])
                   pos++;
   
           /*
            * Set our nil terminator.  Because this line is going to be
            * ignored anyway, we can munge it as we please.
            */
           if ((*bufp)[pos])
                   (*bufp)[pos++] = '\0';
   
           /* Skip whitespace to register token. */
           while ((*bufp)[pos] && ' ' == (*bufp)[pos])
                   pos++;
   
           val = &(*bufp)[pos];
   
           /* Process register token. */
   
           if (0 == strcmp(key, "nS")) {
                   rg[(int)REG_nS].set = 1;
                   if ( ! roff_parse_nat(val, &rg[(int)REG_nS].v.u))
                           rg[(int)REG_nS].v.u = 0;
   
                   ROFF_DEBUG("roff: register nS: %u\n",
                                   rg[(int)REG_nS].v.u);
           } else
                   ROFF_DEBUG("roff: ignoring register: %s\n", key);
   
         return(ROFF_IGN);          return(ROFF_IGN);
 }  }
Legend:
Removed from v.1.87  
changed lines
  Added in v.1.91
CVSweb