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

Diff for /mandoc/roff.c between version 1.315 and 1.319

version 1.315, 2017/06/18 17:36:03 version 1.319, 2017/07/08 14:51:04
Line 98  struct roff {
Line 98  struct roff {
         struct tbl_node *first_tbl; /* first table parsed */          struct tbl_node *first_tbl; /* first table parsed */
         struct tbl_node *last_tbl; /* last table parsed */          struct tbl_node *last_tbl; /* last table parsed */
         struct tbl_node *tbl; /* current table being parsed */          struct tbl_node *tbl; /* current table being parsed */
         struct eqn_node *last_eqn; /* last equation parsed */          struct eqn_node *last_eqn; /* equation parser */
         struct eqn_node *first_eqn; /* first equation parsed */          struct eqn_node *eqn; /* active equation parser */
         struct eqn_node *eqn; /* current equation being parsed */  
         int              eqn_inline; /* current equation is inline */          int              eqn_inline; /* current equation is inline */
         int              options; /* parse options */          int              options; /* parse options */
         int              rstacksz; /* current size limit of rstack */          int              rstacksz; /* current size limit of rstack */
Line 330  const char *__roff_name[MAN_MAX + 1] = {
Line 329  const char *__roff_name[MAN_MAX + 1] = {
         "RE",           "RS",           "DT",           "UC",          "RE",           "RS",           "DT",           "UC",
         "PD",           "AT",           "in",          "PD",           "AT",           "in",
         "OP",           "EX",           "EE",           "UR",          "OP",           "EX",           "EE",           "UR",
         "UE",           NULL          "UE",           "MT",           "ME",           NULL
 };  };
 const   char *const *roff_name = __roff_name;  const   char *const *roff_name = __roff_name;
   
Line 695  static void
Line 694  static void
 roff_free1(struct roff *r)  roff_free1(struct roff *r)
 {  {
         struct tbl_node *tbl;          struct tbl_node *tbl;
         struct eqn_node *e;  
         int              i;          int              i;
   
         while (NULL != (tbl = r->first_tbl)) {          while (NULL != (tbl = r->first_tbl)) {
Line 704  roff_free1(struct roff *r)
Line 702  roff_free1(struct roff *r)
         }          }
         r->first_tbl = r->last_tbl = r->tbl = NULL;          r->first_tbl = r->last_tbl = r->tbl = NULL;
   
         while (NULL != (e = r->first_eqn)) {          if (r->last_eqn != NULL)
                 r->first_eqn = e->next;                  eqn_free(r->last_eqn);
                 eqn_free(e);          r->last_eqn = r->eqn = NULL;
         }  
         r->first_eqn = r->last_eqn = r->eqn = NULL;  
   
         while (r->last)          while (r->last)
                 roffnode_pop(r);                  roffnode_pop(r);
Line 819  roff_man_free(struct roff_man *man)
Line 815  roff_man_free(struct roff_man *man)
   
 struct roff_man *  struct roff_man *
 roff_man_alloc(struct roff *roff, struct mparse *parse,  roff_man_alloc(struct roff *roff, struct mparse *parse,
         const char *defos, int quick)          const char *os_s, int quick)
 {  {
         struct roff_man *man;          struct roff_man *man;
   
         man = mandoc_calloc(1, sizeof(*man));          man = mandoc_calloc(1, sizeof(*man));
         man->parse = parse;          man->parse = parse;
         man->roff = roff;          man->roff = roff;
         man->defos = defos;          man->os_s = os_s;
         man->quick = quick;          man->quick = quick;
         roff_man_alloc1(man);          roff_man_alloc1(man);
         roff->man = man;          roff->man = man;
Line 984  roff_body_alloc(struct roff_man *man, int line, int po
Line 980  roff_body_alloc(struct roff_man *man, int line, int po
 }  }
   
 void  void
 roff_addeqn(struct roff_man *man, const struct eqn *eqn)  
 {  
         struct roff_node        *n;  
   
         n = roff_node_alloc(man, eqn->ln, eqn->pos, ROFFT_EQN, TOKEN_NONE);  
         n->eqn = eqn;  
         if (eqn->ln > man->last->line)  
                 n->flags |= NODE_LINE;  
         roff_node_append(man, n);  
         man->next = ROFF_NEXT_SIBLING;  
 }  
   
 void  
 roff_addtbl(struct roff_man *man, const struct tbl_span *tbl)  roff_addtbl(struct roff_man *man, const struct tbl_span *tbl)
 {  {
         struct roff_node        *n;          struct roff_node        *n;
Line 1055  roff_node_free(struct roff_node *n)
Line 1038  roff_node_free(struct roff_node *n)
                 mdoc_argv_free(n->args);                  mdoc_argv_free(n->args);
         if (n->type == ROFFT_BLOCK || n->type == ROFFT_ELEM)          if (n->type == ROFFT_BLOCK || n->type == ROFFT_ELEM)
                 free(n->norm);                  free(n->norm);
           if (n->eqn != NULL)
                   eqn_box_free(n->eqn);
         free(n->string);          free(n->string);
         free(n);          free(n);
 }  }
Line 1138  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1123  roff_res(struct roff *r, struct buf *buf, int ln, int 
         size_t           maxl;  /* expected length of the escape name */          size_t           maxl;  /* expected length of the escape name */
         size_t           naml;  /* actual length of the escape name */          size_t           naml;  /* actual length of the escape name */
         enum mandoc_esc  esc;   /* type of the escape sequence */          enum mandoc_esc  esc;   /* type of the escape sequence */
         enum mdoc_os     os_e;  /* kind of RCS id seen */          enum mandoc_os   os_e;  /* kind of RCS id seen */
         int              inaml; /* length returned from mandoc_escape() */          int              inaml; /* length returned from mandoc_escape() */
         int              expand_count;  /* to avoid infinite loops */          int              expand_count;  /* to avoid infinite loops */
         int              npos;  /* position in numeric expression */          int              npos;  /* position in numeric expression */
Line 1161  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1146  roff_res(struct roff *r, struct buf *buf, int ln, int 
                 /* Comment found, look for RCS id. */                  /* Comment found, look for RCS id. */
   
                 if ((cp = strstr(stesc, "$" "OpenBSD")) != NULL) {                  if ((cp = strstr(stesc, "$" "OpenBSD")) != NULL) {
                         os_e = MDOC_OS_OPENBSD;                          os_e = MANDOC_OS_OPENBSD;
                         cp += 8;                          cp += 8;
                 } else if ((cp = strstr(stesc, "$" "NetBSD")) != NULL) {                  } else if ((cp = strstr(stesc, "$" "NetBSD")) != NULL) {
                         os_e = MDOC_OS_NETBSD;                          os_e = MANDOC_OS_NETBSD;
                         cp += 7;                          cp += 7;
                 }                  }
                 if (cp != NULL &&                  if (cp != NULL &&
Line 1512  roff_parseln(struct roff *r, int ln, struct buf *buf, 
Line 1497  roff_parseln(struct roff *r, int ln, struct buf *buf, 
                         return e;                          return e;
                 assert(e == ROFF_CONT);                  assert(e == ROFF_CONT);
         }          }
         if (r->eqn != NULL)          if (r->eqn != NULL && strncmp(buf->buf + ppos, ".EN", 3)) {
                 return eqn_read(&r->eqn, ln, buf->buf, ppos, offs);                  eqn_read(r->eqn, buf->buf + ppos);
                   return ROFF_IGN;
           }
         if (r->tbl != NULL && ( ! ctl || buf->buf[pos] == '\0'))          if (r->tbl != NULL && ( ! ctl || buf->buf[pos] == '\0'))
                 return tbl_read(r->tbl, ln, buf->buf, ppos);                  return tbl_read(r->tbl, ln, buf->buf, ppos);
         if ( ! ctl)          if ( ! ctl)
Line 1593  roff_endparse(struct roff *r)
Line 1580  roff_endparse(struct roff *r)
   
         if (r->eqn) {          if (r->eqn) {
                 mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,                  mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
                     r->eqn->eqn.ln, r->eqn->eqn.pos, "EQ");                      r->eqn->node->line, r->eqn->node->pos, "EQ");
                 eqn_end(&r->eqn);                  eqn_parse(r->eqn);
                   r->eqn = NULL;
         }          }
   
         if (r->tbl) {          if (r->tbl) {
Line 1926  roff_cond_sub(ROFF_ARGS)
Line 1914  roff_cond_sub(ROFF_ARGS)
   
         rr = r->last->rule;          rr = r->last->rule;
         roffnode_cleanscope(r);          roffnode_cleanscope(r);
         t = roff_parse(r, buf->buf, &pos, ln, ppos);  
   
         /*          /*
          * Fully handle known macros when they are structurally  
          * required or when the conditional evaluated to true.  
          */  
   
         if (t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT))  
                 return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);  
   
         /*  
          * If `\}' occurs on a macro line without a preceding macro,           * If `\}' occurs on a macro line without a preceding macro,
          * drop the line completely.           * drop the line completely.
          */           */
Line 1948  roff_cond_sub(ROFF_ARGS)
Line 1927  roff_cond_sub(ROFF_ARGS)
         /* Always check for the closing delimiter `\}'. */          /* Always check for the closing delimiter `\}'. */
   
         while ((ep = strchr(ep, '\\')) != NULL) {          while ((ep = strchr(ep, '\\')) != NULL) {
                 if (*(++ep) == '}') {                  switch (ep[1]) {
                         *ep = '&';                  case '}':
                         roff_ccond(r, ln, ep - buf->buf - 1);                          memmove(ep, ep + 2, strlen(ep + 2) + 1);
                 }                          roff_ccond(r, ln, ep - buf->buf);
                 if (*ep != '\0')                          break;
                   case '\0':
                         ++ep;                          ++ep;
                           break;
                   default:
                           ep += 2;
                           break;
                   }
         }          }
         return rr ? ROFF_CONT : ROFF_IGN;  
           /*
            * Fully handle known macros when they are structurally
            * required or when the conditional evaluated to true.
            */
   
           t = roff_parse(r, buf->buf, &pos, ln, ppos);
           return t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT)
               ? (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs) : rr
               ? ROFF_CONT : ROFF_IGN;
 }  }
   
 static enum rofferr  static enum rofferr
Line 2871  roff_eqndelim(struct roff *r, struct buf *buf, int pos
Line 2865  roff_eqndelim(struct roff *r, struct buf *buf, int pos
 static enum rofferr  static enum rofferr
 roff_EQ(ROFF_ARGS)  roff_EQ(ROFF_ARGS)
 {  {
         struct eqn_node *e;          struct roff_node        *n;
   
           n = roff_node_alloc(r->man, ln, ppos, ROFFT_EQN, TOKEN_NONE);
           if (ln > r->man->last->line)
                   n->flags |= NODE_LINE;
           n->eqn = mandoc_calloc(1, sizeof(*n->eqn));
           n->eqn->expectargs = UINT_MAX;
           roff_node_append(r->man, n);
           r->man->next = ROFF_NEXT_SIBLING;
   
         assert(r->eqn == NULL);          assert(r->eqn == NULL);
         e = eqn_alloc(ppos, ln, r->parse);          if (r->last_eqn == NULL)
                   r->last_eqn = eqn_alloc(r->parse);
           else
                   eqn_reset(r->last_eqn);
           r->eqn = r->last_eqn;
           r->eqn->node = n;
   
         if (r->last_eqn) {  
                 r->last_eqn->next = e;  
                 e->delim = r->last_eqn->delim;  
                 e->odelim = r->last_eqn->odelim;  
                 e->cdelim = r->last_eqn->cdelim;  
         } else  
                 r->first_eqn = r->last_eqn = e;  
   
         r->eqn = r->last_eqn = e;  
   
         if (buf->buf[pos] != '\0')          if (buf->buf[pos] != '\0')
                 mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,                  mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
                     ".EQ %s", buf->buf + pos);                      ".EQ %s", buf->buf + pos);
Line 2896  roff_EQ(ROFF_ARGS)
Line 2893  roff_EQ(ROFF_ARGS)
 static enum rofferr  static enum rofferr
 roff_EN(ROFF_ARGS)  roff_EN(ROFF_ARGS)
 {  {
           if (r->eqn != NULL) {
         mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN");                  eqn_parse(r->eqn);
                   r->eqn = NULL;
           } else
                   mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN");
           if (buf->buf[pos] != '\0')
                   mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
                       "EN %s", buf->buf + pos);
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
Line 3602  roff_span(const struct roff *r)
Line 3605  roff_span(const struct roff *r)
 {  {
   
         return r->tbl ? tbl_span(r->tbl) : NULL;          return r->tbl ? tbl_span(r->tbl) : NULL;
 }  
   
 const struct eqn *  
 roff_eqn(const struct roff *r)  
 {  
   
         return r->last_eqn ? &r->last_eqn->eqn : NULL;  
 }  }
   
 /*  /*
Legend:
Removed from v.1.315  
changed lines
  Added in v.1.319
CVSweb