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

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

version 1.93, 2010/07/04 22:04:04 version 1.94, 2010/07/07 15:04:54
Line 28 
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 69  enum roffrule {
Line 69  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 76  struct roff {
Line 83  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 109  struct roffmac {
Line 117  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 124  static enum rofferr  roff_cond(ROFF_ARGS);
Line 126  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_ds(ROFF_ARGS);
   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(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  int              roff_res(struct roff *, int,
                                   char **, size_t *, int, int *);
   static  void             roff_setstr(struct roff *,
                                   const char *, const char *);
   
 /* See roff_hash_find() */  /* See roff_hash_find() */
   
Line 276  roff_free1(struct roff *r)
Line 285  roff_free1(struct roff *r)
   
         while (r->last)          while (r->last)
                 roffnode_pop(r);                  roffnode_pop(r);
         roff_freestr();          roff_freestr(r);
 }  }
   
   
Line 317  roff_alloc(struct regset *regs, const mandocmsg msg, v
Line 326  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, int ln, char **bufp,
                   size_t *szp, int pos, int *offs)
   {
           const char      *cp, *cpp, *st, *res;
           int              i, maxl;
           size_t           nsz;
           char            *n;
   
           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 325  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 402  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, ln, bufp, szp, pos, offs))
                   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 338  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 423  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 366  roff_parseln(struct roff *r, int ln, char **bufp, 
Line 448  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 914  roff_ds(ROFF_ARGS)
Line 993  roff_ds(ROFF_ARGS)
                         *end = '\0';                          *end = '\0';
         }          }
   
         roff_setstr(name, string);          roff_setstr(r, name, string);
         return(ROFF_IGN);          return(ROFF_IGN);
 }  }
   
Line 962  roff_nr(ROFF_ARGS)
Line 1041  roff_nr(ROFF_ARGS)
 }  }
   
   
 char *  static void
 roff_setstr(const char *name, const char *string)  roff_setstr(struct roff *r, const char *name, const char *string)
 {  {
         struct roffstr   *n;          struct roffstr   *n;
         char             *namecopy;          char             *namecopy;
   
         n = 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 (n) {  
                 free(n->string);          if (NULL == n) {
         } else {                  namecopy = mandoc_strdup(name);
                 if (NULL == (namecopy = strdup(name)))                  n = mandoc_malloc(sizeof(struct roffstr));
                         return(NULL);  
                 if (NULL == (n = malloc(sizeof(struct roffstr)))) {  
                         free(n);  
                         return(NULL);  
                 }  
                 n->name = namecopy;                  n->name = namecopy;
                 n->next = first_string;                  n->next = r->first_string;
                 first_string = n;                  r->first_string = n;
         }          } else
         if (string)                  free(n->string);
                 n->string = strdup(string);  
         else  
                 n->string = NULL;  
         return(n->string);  
 }  
   
 char *          n->string = string ? strdup(string) : NULL;
 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)  static const char *
   roff_getstrn(const struct roff *r, const char *name, size_t len)
 {  {
         struct roffstr   *n;          const struct roffstr *n;
   
         n = 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[len]))
                 n = n->next;                  n = n->next;
         if (n)  
                 return(n->string);          return(n ? n->string : NULL);
         else  
                 return(NULL);  
 }  }
   
 void  
 roff_freestr(void)  static void
   roff_freestr(struct roff *r)
 {  {
         struct roffstr   *n, *nn;          struct roffstr   *n, *nn;
   
         for (n = first_string; n; n = nn) {          for (n = r->first_string; n; n = nn) {
                 free(n->name);                  free(n->name);
                 free(n->string);                  free(n->string);
                 nn = n->next;                  nn = n->next;
                 free(n);                  free(n);
         }          }
         first_string = NULL;  
           r->first_string = NULL;
 }  }

Legend:
Removed from v.1.93  
changed lines
  Added in v.1.94

CVSweb