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

Diff for /mandoc/roff.c between version 1.231 and 1.235

version 1.231, 2014/10/16 01:28:38 version 1.235, 2014/10/25 14:35:37
Line 186  static enum rofferr  roff_cond_sub(ROFF_ARGS);
Line 186  static enum rofferr  roff_cond_sub(ROFF_ARGS);
 static  enum rofferr     roff_ds(ROFF_ARGS);  static  enum rofferr     roff_ds(ROFF_ARGS);
 static  enum rofferr     roff_eqndelim(struct roff *,  static  enum rofferr     roff_eqndelim(struct roff *,
                                 char **, size_t *, int);                                  char **, size_t *, int);
 static  int              roff_evalcond(const char *, int *);  static  int              roff_evalcond(struct roff *r, int,
 static  int              roff_evalnum(const char *, int *, int *, int);                                  const char *, int *);
 static  int              roff_evalpar(const char *, int *, int *);  static  int              roff_evalnum(struct roff *, int,
                                   const char *, int *, int *, int);
   static  int              roff_evalpar(struct roff *, int,
                                   const char *, 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 *);
Line 204  static const char *roff_getstrn(const struct roff *,
Line 207  static const char *roff_getstrn(const struct roff *,
 static  enum rofferr     roff_it(ROFF_ARGS);  static  enum rofferr     roff_it(ROFF_ARGS);
 static  enum rofferr     roff_line_ignore(ROFF_ARGS);  static  enum rofferr     roff_line_ignore(ROFF_ARGS);
 static  enum rofferr     roff_nr(ROFF_ARGS);  static  enum rofferr     roff_nr(ROFF_ARGS);
 static  void             roff_openeqn(struct roff *, const char *,  
                                 int, int, const char *);  
 static  enum rofft       roff_parse(struct roff *, char *, int *,  static  enum rofft       roff_parse(struct roff *, char *, int *,
                                 int, int);                                  int, int);
 static  enum rofferr     roff_parsetext(char **, size_t *, int, int *);  static  enum rofferr     roff_parsetext(char **, size_t *, int, int *);
Line 622  roff_res(struct roff *r, char **bufp, size_t *szp, int
Line 623  roff_res(struct roff *r, char **bufp, size_t *szp, int
                 case 'B':                  case 'B':
                         npos = 0;                          npos = 0;
                         ubuf[0] = arg_complete &&                          ubuf[0] = arg_complete &&
                             roff_evalnum(stnam, &npos, NULL, 0) &&                              roff_evalnum(r, ln, stnam, &npos, NULL, 0) &&
                             stnam + npos + 1 == cp ? '1' : '0';                              stnam + npos + 1 == cp ? '1' : '0';
                         ubuf[1] = '\0';                          ubuf[1] = '\0';
                         break;                          break;
Line 1240  out:
Line 1241  out:
  * or string condition.   * or string condition.
  */   */
 static int  static int
 roff_evalcond(const char *v, int *pos)  roff_evalcond(struct roff *r, int ln, const char *v, int *pos)
 {  {
         int      wanttrue, number;          int      wanttrue, number;
   
Line 1271  roff_evalcond(const char *v, int *pos)
Line 1272  roff_evalcond(const char *v, int *pos)
                 break;                  break;
         }          }
   
         if (roff_evalnum(v, pos, &number, 0))          if (roff_evalnum(r, ln, v, pos, &number, 0))
                 return((number > 0) == wanttrue);                  return((number > 0) == wanttrue);
         else          else
                 return(roff_evalstrcond(v, pos) == wanttrue);                  return(roff_evalstrcond(v, pos) == wanttrue);
Line 1300  roff_cond(ROFF_ARGS)
Line 1301  roff_cond(ROFF_ARGS)
   
         r->last->rule = ROFF_el == tok ?          r->last->rule = ROFF_el == tok ?
             (r->rstackpos < 0 ? 0 : r->rstack[r->rstackpos--]) :              (r->rstackpos < 0 ? 0 : r->rstack[r->rstackpos--]) :
             roff_evalcond(*bufp, &pos);              roff_evalcond(r, ln, *bufp, &pos);
   
         /*          /*
          * An if-else will put the NEGATION of the current evaluated           * An if-else will put the NEGATION of the current evaluated
Line 1466  roff_getop(const char *v, int *pos, char *res)
Line 1467  roff_getop(const char *v, int *pos, char *res)
  * or a single signed integer number.   * or a single signed integer number.
  */   */
 static int  static int
 roff_evalpar(const char *v, int *pos, int *res)  roff_evalpar(struct roff *r, int ln,
           const char *v, int *pos, int *res)
 {  {
   
         if ('(' != v[*pos])          if ('(' != v[*pos])
                 return(roff_getnum(v, pos, res));                  return(roff_getnum(v, pos, res));
   
         (*pos)++;          (*pos)++;
         if ( ! roff_evalnum(v, pos, res, 1))          if ( ! roff_evalnum(r, ln, v, pos, res, 1))
                 return(0);                  return(0);
   
         /*          /*
Line 1495  roff_evalpar(const char *v, int *pos, int *res)
Line 1497  roff_evalpar(const char *v, int *pos, int *res)
  * Proceed left to right, there is no concept of precedence.   * Proceed left to right, there is no concept of precedence.
  */   */
 static int  static int
 roff_evalnum(const char *v, int *pos, int *res, int skipwhite)  roff_evalnum(struct roff *r, int ln, const char *v,
           int *pos, int *res, int skipwhite)
 {  {
         int              mypos, operand2;          int              mypos, operand2;
         char             operator;          char             operator;
Line 1509  roff_evalnum(const char *v, int *pos, int *res, int sk
Line 1512  roff_evalnum(const char *v, int *pos, int *res, int sk
                 while (isspace((unsigned char)v[*pos]))                  while (isspace((unsigned char)v[*pos]))
                         (*pos)++;                          (*pos)++;
   
         if ( ! roff_evalpar(v, pos, res))          if ( ! roff_evalpar(r, ln, v, pos, res))
                 return(0);                  return(0);
   
         while (1) {          while (1) {
Line 1524  roff_evalnum(const char *v, int *pos, int *res, int sk
Line 1527  roff_evalnum(const char *v, int *pos, int *res, int sk
                         while (isspace((unsigned char)v[*pos]))                          while (isspace((unsigned char)v[*pos]))
                                 (*pos)++;                                  (*pos)++;
   
                 if ( ! roff_evalpar(v, pos, &operand2))                  if ( ! roff_evalpar(r, ln, v, pos, &operand2))
                         return(0);                          return(0);
   
                 if (skipwhite)                  if (skipwhite)
Line 1545  roff_evalnum(const char *v, int *pos, int *res, int sk
Line 1548  roff_evalnum(const char *v, int *pos, int *res, int sk
                         *res *= operand2;                          *res *= operand2;
                         break;                          break;
                 case '/':                  case '/':
                           if (0 == operand2) {
                                   mandoc_msg(MANDOCERR_DIVZERO,
                                           r->parse, ln, *pos, v);
                                   *res = 0;
                                   break;
                           }
                         *res /= operand2;                          *res /= operand2;
                         break;                          break;
                 case '%':                  case '%':
Line 1719  roff_nr(ROFF_ARGS)
Line 1728  roff_nr(ROFF_ARGS)
         if ('+' == sign || '-' == sign)          if ('+' == sign || '-' == sign)
                 val++;                  val++;
   
         if (roff_evalnum(val, NULL, &iv, 0))          if (roff_evalnum(r, ln, val, NULL, &iv, 0))
                 roff_setreg(r, key, iv, sign);                  roff_setreg(r, key, iv, sign);
   
         return(ROFF_IGN);          return(ROFF_IGN);
Line 1857  roff_T_(ROFF_ARGS)
Line 1866  roff_T_(ROFF_ARGS)
 static enum rofferr  static enum rofferr
 roff_eqndelim(struct roff *r, char **bufp, size_t *szp, int pos)  roff_eqndelim(struct roff *r, char **bufp, size_t *szp, int pos)
 {  {
         char    *cp1, *cp2;          char            *cp1, *cp2;
           const char      *bef_pr, *bef_nl, *mac, *aft_nl, *aft_pr;
   
         /*          /*
          * Outside equations, look for an opening delimiter.           * Outside equations, look for an opening delimiter.
Line 1872  roff_eqndelim(struct roff *r, char **bufp, size_t *szp
Line 1882  roff_eqndelim(struct roff *r, char **bufp, size_t *szp
         if (cp2 == NULL)          if (cp2 == NULL)
                 return(ROFF_CONT);                  return(ROFF_CONT);
   
         /* Found a delimiter; get rid of surrounding blanks. */          *cp2++ = '\0';
           bef_pr = bef_nl = aft_nl = aft_pr = "";
   
         cp1 = cp2++;          /* Handle preceding text, protecting whitespace. */
         while (cp2[0] == ' ')  
                 cp2++;  
         while (cp1[-1] == ' ')  
                 cp1--;  
         *cp1 = '\0';  
   
         /* Replace the delimiter with an equation macro. */          if (**bufp != '\0') {
                   if (r->eqn == NULL)
                           bef_pr = "\\&";
                   bef_nl = "\n";
           }
   
         *szp = mandoc_asprintf(&cp1, "%s\n.E%s%s", *bufp,          /*
             r->eqn == NULL ? "Q\n" : "N\n\\&", cp2) + 1;           * Prepare replacing the delimiter with an equation macro
            * and drop leading white space from the equation.
            */
   
           if (r->eqn == NULL) {
                   while (*cp2 == ' ')
                           cp2++;
                   mac = ".EQ";
           } else
                   mac = ".EN";
   
           /* Handle following text, protecting whitespace. */
   
           if (*cp2 != '\0') {
                   aft_nl = "\n";
                   if (r->eqn != NULL)
                           aft_pr = "\\&";
           }
   
           /* Do the actual replacement. */
   
           *szp = mandoc_asprintf(&cp1, "%s%s%s%s%s%s%s", *bufp,
               bef_pr, bef_nl, mac, aft_nl, aft_pr, cp2) + 1;
         free(*bufp);          free(*bufp);
         *bufp = cp1;          *bufp = cp1;
   
Line 1894  roff_eqndelim(struct roff *r, char **bufp, size_t *szp
Line 1926  roff_eqndelim(struct roff *r, char **bufp, size_t *szp
         return(ROFF_REPARSE);          return(ROFF_REPARSE);
 }  }
   
 static void  static enum rofferr
 roff_openeqn(struct roff *r, const char *name, int line,  roff_EQ(ROFF_ARGS)
                 int offs, const char *buf)  
 {  {
         struct eqn_node *e;          struct eqn_node *e;
         int              poff;  
   
         assert(NULL == r->eqn);          assert(NULL == r->eqn);
         e = eqn_alloc(name, offs, line, r->parse);          e = eqn_alloc(ppos, ln, r->parse);
   
         if (r->last_eqn) {          if (r->last_eqn) {
                 r->last_eqn->next = e;                  r->last_eqn->next = e;
Line 1914  roff_openeqn(struct roff *r, const char *name, int lin
Line 1944  roff_openeqn(struct roff *r, const char *name, int lin
   
         r->eqn = r->last_eqn = e;          r->eqn = r->last_eqn = e;
   
         if (buf) {          if ((*bufp)[pos])
                 poff = 0;                  mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
                 eqn_read(&r->eqn, line, buf, offs, &poff);                      ".EQ %s", *bufp + pos);
         }  
 }  
   
 static enum rofferr  
 roff_EQ(ROFF_ARGS)  
 {  
   
         roff_openeqn(r, *bufp + pos, ln, ppos, NULL);  
         return(ROFF_IGN);          return(ROFF_IGN);
 }  }
   
Legend:
Removed from v.1.231  
changed lines
  Added in v.1.235
CVSweb