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

Diff for /mandoc/roff.c between version 1.260 and 1.261

version 1.260, 2015/02/06 16:06:25 version 1.261, 2015/02/17 17:16:52
Line 396  static int   roff_evalcond(struct roff *r, int,
Line 396  static int   roff_evalcond(struct roff *r, int,
 static  int              roff_evalnum(struct roff *, int,  static  int              roff_evalnum(struct roff *, int,
                                 const char *, int *, int *, int);                                  const char *, int *, int *, int);
 static  int              roff_evalpar(struct roff *, int,  static  int              roff_evalpar(struct roff *, int,
                                 const char *, int *, int *);                                  const char *, int *, int *, int);
 static  int              roff_evalstrcond(const char *, int *);  static  int              roff_evalstrcond(const char *, int *);
 static  void             roff_free1(struct roff *);  static  void             roff_free1(struct roff *);
 static  void             roff_freereg(struct roffreg *);  static  void             roff_freereg(struct roffreg *);
 static  void             roff_freestr(struct roffkv *);  static  void             roff_freestr(struct roffkv *);
 static  size_t           roff_getname(struct roff *, char **, int, int);  static  size_t           roff_getname(struct roff *, char **, int, int);
 static  int              roff_getnum(const char *, int *, int *);  static  int              roff_getnum(const char *, int *, int *, int);
 static  int              roff_getop(const char *, int *, char *);  static  int              roff_getop(const char *, int *, char *);
 static  int              roff_getregn(const struct roff *,  static  int              roff_getregn(const struct roff *,
                                 const char *, size_t);                                  const char *, size_t);
Line 441  static enum rofferr  roff_userdef(ROFF_ARGS);
Line 441  static enum rofferr  roff_userdef(ROFF_ARGS);
 #define ASCII_LO         33  #define ASCII_LO         33
 #define HASHWIDTH       (ASCII_HI - ASCII_LO + 1)  #define HASHWIDTH       (ASCII_HI - ASCII_LO + 1)
   
   #define ROFFNUM_SCALE   (1 << 0)  /* Honour scaling in roff_getnum(). */
   #define ROFFNUM_WHITE   (1 << 1)  /* Skip whitespace in roff_evalnum(). */
   
 static  struct roffmac  *hash[HASHWIDTH];  static  struct roffmac  *hash[HASHWIDTH];
   
 static  struct roffmac   roffs[ROFF_MAX] = {  static  struct roffmac   roffs[ROFF_MAX] = {
Line 1050  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1053  roff_res(struct roff *r, struct buf *buf, int ln, int 
                 case 'B':                  case 'B':
                         npos = 0;                          npos = 0;
                         ubuf[0] = arg_complete &&                          ubuf[0] = arg_complete &&
                             roff_evalnum(r, ln, stnam, &npos, NULL, 0) &&                              roff_evalnum(r, ln, stnam, &npos,
                                 NULL, ROFFNUM_SCALE) &&
                             stnam + npos + 1 == cp ? '1' : '0';                              stnam + npos + 1 == cp ? '1' : '0';
                         ubuf[1] = '\0';                          ubuf[1] = '\0';
                         break;                          break;
Line 1628  roff_cond_text(ROFF_ARGS)
Line 1632  roff_cond_text(ROFF_ARGS)
  * Ignore overflows, treat them just like the C language.   * Ignore overflows, treat them just like the C language.
  */   */
 static int  static int
 roff_getnum(const char *v, int *pos, int *res)  roff_getnum(const char *v, int *pos, int *res, int flags)
 {  {
         int      myres, n, p;          int      myres, scaled, n, p;
   
         if (NULL == res)          if (NULL == res)
                 res = &myres;                  res = &myres;
   
         p = *pos;          p = *pos;
         n = v[p] == '-';          n = v[p] == '-';
         if (n)          if (n || v[p] == '+')
                 p++;                  p++;
   
           if (flags & ROFFNUM_WHITE)
                   while (isspace((unsigned char)v[p]))
                           p++;
   
         for (*res = 0; isdigit((unsigned char)v[p]); p++)          for (*res = 0; isdigit((unsigned char)v[p]); p++)
                 *res = 10 * *res + v[p] - '0';                  *res = 10 * *res + v[p] - '0';
         if (p == *pos + n)          if (p == *pos + n)
Line 1652  roff_getnum(const char *v, int *pos, int *res)
Line 1660  roff_getnum(const char *v, int *pos, int *res)
   
         switch (v[p]) {          switch (v[p]) {
         case 'f':          case 'f':
                 *res *= 65536;                  scaled = *res * 65536;
                 break;                  break;
         case 'i':          case 'i':
                 *res *= 240;                  scaled = *res * 240;
                 break;                  break;
         case 'c':          case 'c':
                 *res *= 240;                  scaled = *res * 240 / 2.54;
                 *res /= 2.54;  
                 break;                  break;
         case 'v':          case 'v':
                 /* FALLTROUGH */                  /* FALLTROUGH */
         case 'P':          case 'P':
                 *res *= 40;                  scaled = *res * 40;
                 break;                  break;
         case 'm':          case 'm':
                 /* FALLTROUGH */                  /* FALLTROUGH */
         case 'n':          case 'n':
                 *res *= 24;                  scaled = *res * 24;
                 break;                  break;
         case 'p':          case 'p':
                 *res *= 10;                  scaled = *res * 10 / 3;
                 *res /= 3;  
                 break;                  break;
         case 'u':          case 'u':
                   scaled = *res;
                 break;                  break;
         case 'M':          case 'M':
                 *res *= 6;                  scaled = *res * 6 / 25;
                 *res /= 25;  
                 break;                  break;
         default:          default:
                   scaled = *res;
                 p--;                  p--;
                 break;                  break;
         }          }
           if (flags & ROFFNUM_SCALE)
                   *res = scaled;
   
         *pos = p + 1;          *pos = p + 1;
         return(1);          return(1);
Line 1774  roff_evalcond(struct roff *r, int ln, const char *v, i
Line 1783  roff_evalcond(struct roff *r, int ln, const char *v, i
         }          }
   
         savepos = *pos;          savepos = *pos;
         if (roff_evalnum(r, ln, v, pos, &number, 0))          if (roff_evalnum(r, ln, v, pos, &number, ROFFNUM_SCALE))
                 return((number > 0) == wanttrue);                  return((number > 0) == wanttrue);
         else if (*pos == savepos)          else if (*pos == savepos)
                 return(roff_evalstrcond(v, pos) == wanttrue);                  return(roff_evalstrcond(v, pos) == wanttrue);
Line 1997  roff_getop(const char *v, int *pos, char *res)
Line 2006  roff_getop(const char *v, int *pos, char *res)
  */   */
 static int  static int
 roff_evalpar(struct roff *r, int ln,  roff_evalpar(struct roff *r, int ln,
         const char *v, int *pos, int *res)          const char *v, int *pos, int *res, int flags)
 {  {
   
         if ('(' != v[*pos])          if ('(' != v[*pos])
                 return(roff_getnum(v, pos, res));                  return(roff_getnum(v, pos, res, flags));
   
         (*pos)++;          (*pos)++;
         if ( ! roff_evalnum(r, ln, v, pos, res, 1))          if ( ! roff_evalnum(r, ln, v, pos, res, flags | ROFFNUM_WHITE))
                 return(0);                  return(0);
   
         /*          /*
Line 2027  roff_evalpar(struct roff *r, int ln,
Line 2036  roff_evalpar(struct roff *r, int ln,
  */   */
 static int  static int
 roff_evalnum(struct roff *r, int ln, const char *v,  roff_evalnum(struct roff *r, int ln, const char *v,
         int *pos, int *res, int skipwhite)          int *pos, int *res, int flags)
 {  {
         int              mypos, operand2;          int              mypos, operand2;
         char             operator;          char             operator;
Line 2037  roff_evalnum(struct roff *r, int ln, const char *v,
Line 2046  roff_evalnum(struct roff *r, int ln, const char *v,
                 pos = &mypos;                  pos = &mypos;
         }          }
   
         if (skipwhite)          if (flags & ROFFNUM_WHITE)
                 while (isspace((unsigned char)v[*pos]))                  while (isspace((unsigned char)v[*pos]))
                         (*pos)++;                          (*pos)++;
   
         if ( ! roff_evalpar(r, ln, v, pos, res))          if ( ! roff_evalpar(r, ln, v, pos, res, flags))
                 return(0);                  return(0);
   
         while (1) {          while (1) {
                 if (skipwhite)                  if (flags & ROFFNUM_WHITE)
                         while (isspace((unsigned char)v[*pos]))                          while (isspace((unsigned char)v[*pos]))
                                 (*pos)++;                                  (*pos)++;
   
                 if ( ! roff_getop(v, pos, &operator))                  if ( ! roff_getop(v, pos, &operator))
                         break;                          break;
   
                 if (skipwhite)                  if (flags & ROFFNUM_WHITE)
                         while (isspace((unsigned char)v[*pos]))                          while (isspace((unsigned char)v[*pos]))
                                 (*pos)++;                                  (*pos)++;
   
                 if ( ! roff_evalpar(r, ln, v, pos, &operand2))                  if ( ! roff_evalpar(r, ln, v, pos, &operand2, flags))
                         return(0);                          return(0);
   
                 if (skipwhite)                  if (flags & ROFFNUM_WHITE)
                         while (isspace((unsigned char)v[*pos]))                          while (isspace((unsigned char)v[*pos]))
                                 (*pos)++;                                  (*pos)++;
   
Line 2263  roff_nr(ROFF_ARGS)
Line 2272  roff_nr(ROFF_ARGS)
         if (sign == '+' || sign == '-')          if (sign == '+' || sign == '-')
                 val++;                  val++;
   
         if (roff_evalnum(r, ln, val, NULL, &iv, 0))          if (roff_evalnum(r, ln, val, NULL, &iv, ROFFNUM_SCALE))
                 roff_setreg(r, key, iv, sign);                  roff_setreg(r, key, iv, sign);
   
         return(ROFF_IGN);          return(ROFF_IGN);
Line 2318  roff_rm(ROFF_ARGS)
Line 2327  roff_rm(ROFF_ARGS)
 static enum rofferr  static enum rofferr
 roff_it(ROFF_ARGS)  roff_it(ROFF_ARGS)
 {  {
         char            *cp;  
         size_t           len;  
         int              iv;          int              iv;
   
         /* Parse the number of lines. */          /* Parse the number of lines. */
         cp = buf->buf + pos;  
         len = strcspn(cp, " \t");          if ( ! roff_evalnum(r, ln, buf->buf, &pos, &iv, 0)) {
         cp[len] = '\0';  
         if ((iv = mandoc_strntoi(cp, len, 10)) <= 0) {  
                 mandoc_msg(MANDOCERR_IT_NONUM, r->parse,                  mandoc_msg(MANDOCERR_IT_NONUM, r->parse,
                     ln, ppos, buf->buf + 1);                      ln, ppos, buf->buf + 1);
                 return(ROFF_IGN);                  return(ROFF_IGN);
         }          }
         cp += len + 1;  
   
         /* Arm the input line trap. */          /* Arm the input line trap. */
   
         roffit_lines = iv;          roffit_lines = iv;
         roffit_macro = mandoc_strdup(cp);          roffit_macro = mandoc_strdup(buf->buf + pos);
         return(ROFF_IGN);          return(ROFF_IGN);
 }  }
   

Legend:
Removed from v.1.260  
changed lines
  Added in v.1.261

CVSweb