[BACK]Return to roff.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / mandoc

Diff for /src/usr.bin/mandoc/roff.c between version 1.7 and 1.8

version 1.7, 2010/07/03 15:59:05 version 1.8, 2010/07/13 01:09:13
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 60 
Line 61 
         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 67 
Line 75 
         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 100 
Line 109 
         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 115 
Line 118 
 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 267 
Line 277 
   
         while (r->last)          while (r->last)
                 roffnode_pop(r);                  roffnode_pop(r);
         roff_freestr();          roff_freestr(r);
 }  }
   
   
Line 308 
Line 318 
 }  }
   
   
   /*
    * 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;
                   }
   
                   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 
Line 392 
         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 325 
Line 409 
                 t = r->last->tok;                  t = r->last->tok;
                 assert(roffs[t].text);                  assert(roffs[t].text);
                 return((*roffs[t].text)                  return((*roffs[t].text)
                                 (r, t, bufp, szp, ln, pos, pos, offs));                                  (r, t, bufp, szp,
                                    ln, pos, pos, offs));
         } else if ( ! ROFF_CTL((*bufp)[pos]))          } else if ( ! ROFF_CTL((*bufp)[pos]))
                 return(ROFF_CONT);                  return(ROFF_CONT);
   
Line 338 
Line 423 
                 t = r->last->tok;                  t = r->last->tok;
                 assert(roffs[t].sub);                  assert(roffs[t].sub);
                 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 353 
Line 439 
   
         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 880 
Line 967 
                         *end = '\0';                          *end = '\0';
         }          }
   
         roff_setstr(name, string);          roff_setstr(r, name, string);
         return(ROFF_IGN);          return(ROFF_IGN);
 }  }
   
Line 924 
Line 1011 
 }  }
   
   
 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.7  
changed lines
  Added in v.1.8