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

Diff for /mandoc/roff.c between version 1.363 and 1.382

version 1.363, 2019/02/06 21:11:43 version 1.382, 2022/04/24 13:38:46
Line 1 
Line 1 
 /*      $Id$ */  /* $Id$ */
 /*  /*
    * Copyright (c) 2010-2015, 2017-2022 Ingo Schwarze <schwarze@openbsd.org>
  * Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2010-2015, 2017-2019 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 14 
Line 14 
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
    *
    * Implementation of the roff(7) parser for mandoc(1).
  */   */
 #include "config.h"  #include "config.h"
   
Line 133  struct roff {
Line 135  struct roff {
         char             escape; /* escape character */          char             escape; /* escape character */
 };  };
   
   /*
    * A macro definition, condition, or ignored block.
    */
 struct  roffnode {  struct  roffnode {
         enum roff_tok    tok; /* type of node */          enum roff_tok    tok; /* type of node */
         struct roffnode *parent; /* up one in stack */          struct roffnode *parent; /* up one in stack */
         int              line; /* parse line */          int              line; /* parse line */
         int              col; /* parse col */          int              col; /* parse col */
         char            *name; /* node name, e.g. macro name */          char            *name; /* node name, e.g. macro name */
         char            *end; /* end-rules: custom token */          char            *end; /* custom end macro of the block */
         int              endspan; /* end-rules: next-line or infty */          int              endspan; /* scope to: 1=eol 2=next line -1=\} */
         int              rule; /* current evaluation rule */          int              rule; /* content is: 1=evaluated 0=skipped */
 };  };
   
 #define ROFF_ARGS        struct roff *r, /* parse ctx */ \  #define ROFF_ARGS        struct roff *r, /* parse ctx */ \
Line 181  static int   roff_als(ROFF_ARGS);
Line 186  static int   roff_als(ROFF_ARGS);
 static  int              roff_block(ROFF_ARGS);  static  int              roff_block(ROFF_ARGS);
 static  int              roff_block_text(ROFF_ARGS);  static  int              roff_block_text(ROFF_ARGS);
 static  int              roff_block_sub(ROFF_ARGS);  static  int              roff_block_sub(ROFF_ARGS);
   static  int              roff_break(ROFF_ARGS);
 static  int              roff_cblock(ROFF_ARGS);  static  int              roff_cblock(ROFF_ARGS);
 static  int              roff_cc(ROFF_ARGS);  static  int              roff_cc(ROFF_ARGS);
 static  int              roff_ccond(struct roff *, int, int);  static  int              roff_ccond(struct roff *, int, int);
 static  int              roff_char(ROFF_ARGS);  static  int              roff_char(ROFF_ARGS);
 static  int              roff_cond(ROFF_ARGS);  static  int              roff_cond(ROFF_ARGS);
   static  int              roff_cond_checkend(ROFF_ARGS);
 static  int              roff_cond_text(ROFF_ARGS);  static  int              roff_cond_text(ROFF_ARGS);
 static  int              roff_cond_sub(ROFF_ARGS);  static  int              roff_cond_sub(ROFF_ARGS);
 static  int              roff_ds(ROFF_ARGS);  static  int              roff_ds(ROFF_ARGS);
 static  int              roff_ec(ROFF_ARGS);  static  int              roff_ec(ROFF_ARGS);
 static  int              roff_eo(ROFF_ARGS);  static  int              roff_eo(ROFF_ARGS);
 static  int              roff_eqndelim(struct roff *, struct buf *, int);  static  int              roff_eqndelim(struct roff *, struct buf *, int);
 static  int              roff_evalcond(struct roff *r, int, char *, int *);  static  int              roff_evalcond(struct roff *, int, char *, 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,
Line 351  const char *__roff_name[MAN_MAX + 1] = {
Line 358  const char *__roff_name[MAN_MAX + 1] = {
         "Lk",           "Mt",           "Brq",          "Bro",          "Lk",           "Mt",           "Brq",          "Bro",
         "Brc",          "%C",           "Es",           "En",          "Brc",          "%C",           "Es",           "En",
         "Dx",           "%Q",           "%U",           "Ta",          "Dx",           "%Q",           "%U",           "Ta",
         NULL,          "Tg",           NULL,
         "TH",           "SH",           "SS",           "TP",          "TH",           "SH",           "SS",           "TP",
         "TQ",          "TQ",
         "LP",           "PP",           "P",            "IP",          "LP",           "PP",           "P",            "IP",
Line 400  static struct roffmac  roffs[TOKEN_NONE] = {
Line 407  static struct roffmac  roffs[TOKEN_NONE] = {
         { roff_unsupp, NULL, NULL, 0 },  /* boxa */          { roff_unsupp, NULL, NULL, 0 },  /* boxa */
         { roff_line_ignore, NULL, NULL, 0 },  /* bp */          { roff_line_ignore, NULL, NULL, 0 },  /* bp */
         { roff_unsupp, NULL, NULL, 0 },  /* BP */          { roff_unsupp, NULL, NULL, 0 },  /* BP */
         { roff_unsupp, NULL, NULL, 0 },  /* break */          { roff_break, NULL, NULL, 0 },  /* break */
         { roff_line_ignore, NULL, NULL, 0 },  /* breakchar */          { roff_line_ignore, NULL, NULL, 0 },  /* breakchar */
         { roff_line_ignore, NULL, NULL, 0 },  /* brnl */          { roff_line_ignore, NULL, NULL, 0 },  /* brnl */
         { roff_noarg, NULL, NULL, 0 },  /* brp */          { roff_noarg, NULL, NULL, 0 },  /* brp */
Line 685  roffhash_find(struct ohash *htab, const char *name, si
Line 692  roffhash_find(struct ohash *htab, const char *name, si
   
 /*  /*
  * Pop the current node off of the stack of roff instructions currently   * Pop the current node off of the stack of roff instructions currently
  * pending.   * pending.  Return 1 if it is a loop or 0 otherwise.
  */   */
 static int  static int
 roffnode_pop(struct roff *r)  roffnode_pop(struct roff *r)
Line 767  void
Line 774  void
 roff_reset(struct roff *r)  roff_reset(struct roff *r)
 {  {
         roff_free1(r);          roff_free1(r);
           r->options |= MPARSE_COMMENT;
         r->format = r->options & (MPARSE_MDOC | MPARSE_MAN);          r->format = r->options & (MPARSE_MDOC | MPARSE_MAN);
         r->control = '\0';          r->control = '\0';
         r->escape = '\\';          r->escape = '\\';
Line 779  roff_reset(struct roff *r)
Line 787  roff_reset(struct roff *r)
 void  void
 roff_free(struct roff *r)  roff_free(struct roff *r)
 {  {
         int              i;          int              i;
   
         roff_free1(r);          roff_free1(r);
         for (i = 0; i < r->mstacksz; i++)          for (i = 0; i < r->mstacksz; i++)
Line 796  roff_alloc(int options)
Line 804  roff_alloc(int options)
   
         r = mandoc_calloc(1, sizeof(struct roff));          r = mandoc_calloc(1, sizeof(struct roff));
         r->reqtab = roffhash_alloc(0, ROFF_RENAMED);          r->reqtab = roffhash_alloc(0, ROFF_RENAMED);
         r->options = options;          r->options = options | MPARSE_COMMENT;
         r->format = options & (MPARSE_MDOC | MPARSE_MAN);          r->format = options & (MPARSE_MDOC | MPARSE_MAN);
         r->mstackpos = -1;          r->mstackpos = -1;
         r->rstackpos = -1;          r->rstackpos = -1;
Line 853  void
Line 861  void
 roff_man_free(struct roff_man *man)  roff_man_free(struct roff_man *man)
 {  {
         roff_man_free1(man);          roff_man_free1(man);
           free(man->os_r);
         free(man);          free(man);
 }  }
   
Line 1096  roff_node_free(struct roff_node *n)
Line 1105  roff_node_free(struct roff_node *n)
                 free(n->norm);                  free(n->norm);
         eqn_box_free(n->eqn);          eqn_box_free(n->eqn);
         free(n->string);          free(n->string);
           free(n->tag);
         free(n);          free(n);
 }  }
   
Line 1109  roff_node_delete(struct roff_man *man, struct roff_nod
Line 1119  roff_node_delete(struct roff_man *man, struct roff_nod
         roff_node_free(n);          roff_node_free(n);
 }  }
   
   int
   roff_node_transparent(struct roff_node *n)
   {
           if (n == NULL)
                   return 0;
           if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT)
                   return 1;
           return roff_tok_transparent(n->tok);
   }
   
   int
   roff_tok_transparent(enum roff_tok tok)
   {
           switch (tok) {
           case ROFF_ft:
           case ROFF_ll:
           case ROFF_mc:
           case ROFF_po:
           case ROFF_ta:
           case MDOC_Db:
           case MDOC_Es:
           case MDOC_Sm:
           case MDOC_Tg:
           case MAN_DT:
           case MAN_UC:
           case MAN_PD:
           case MAN_AT:
                   return 1;
           default:
                   return 0;
           }
   }
   
   struct roff_node *
   roff_node_child(struct roff_node *n)
   {
           for (n = n->child; roff_node_transparent(n); n = n->next)
                   continue;
           return n;
   }
   
   struct roff_node *
   roff_node_prev(struct roff_node *n)
   {
           do {
                   n = n->prev;
           } while (roff_node_transparent(n));
           return n;
   }
   
   struct roff_node *
   roff_node_next(struct roff_node *n)
   {
           do {
                   n = n->next;
           } while (roff_node_transparent(n));
           return n;
   }
   
 void  void
 deroff(char **dest, const struct roff_node *n)  deroff(char **dest, const struct roff_node *n)
 {  {
         char    *cp;          char    *cp;
         size_t   sz;          size_t   sz;
   
         if (n->type != ROFFT_TEXT) {          if (n->string == NULL) {
                 for (n = n->child; n != NULL; n = n->next)                  for (n = n->child; n != NULL; n = n->next)
                         deroff(dest, n);                          deroff(dest, n);
                 return;                  return;
Line 1242  roff_expand(struct roff *r, struct buf *buf, int ln, i
Line 1311  roff_expand(struct roff *r, struct buf *buf, int ln, i
                  * in the syntax tree.                   * in the syntax tree.
                  */                   */
   
                 if (newesc != ASCII_ESC && r->format == 0) {                  if (newesc != ASCII_ESC && r->options & MPARSE_COMMENT) {
                         while (*ep == ' ' || *ep == '\t')                          while (*ep == ' ' || *ep == '\t')
                                 ep--;                                  ep--;
                         ep[1] = '\0';                          ep[1] = '\0';
Line 1332  roff_expand(struct roff *r, struct buf *buf, int ln, i
Line 1401  roff_expand(struct roff *r, struct buf *buf, int ln, i
   
                 term = '\0';                  term = '\0';
                 cp = stesc + 1;                  cp = stesc + 1;
                 if (*cp == 'E')                  while (*cp == 'E')
                         cp++;                          cp++;
                 esct = cp;                  esct = cp;
                 switch (*esct) {                  switch (*esct) {
Line 1586  char *
Line 1655  char *
 roff_getarg(struct roff *r, char **cpp, int ln, int *pos)  roff_getarg(struct roff *r, char **cpp, int ln, int *pos)
 {  {
         struct buf       buf;          struct buf       buf;
         char            *cp, *start;          char            *cp, *start;
         int              newesc, pairs, quoted, white;          int              newesc, pairs, quoted, white;
   
         /* Quoting can only start with a new word. */          /* Quoting can only start with a new word. */
Line 1755  roff_parsetext(struct roff *r, struct buf *buf, int po
Line 1824  roff_parsetext(struct roff *r, struct buf *buf, int po
 }  }
   
 int  int
 roff_parseln(struct roff *r, int ln, struct buf *buf, int *offs)  roff_parseln(struct roff *r, int ln, struct buf *buf, int *offs, size_t len)
 {  {
         enum roff_tok    t;          enum roff_tok    t;
         int              e;          int              e;
Line 1766  roff_parseln(struct roff *r, int ln, struct buf *buf, 
Line 1835  roff_parseln(struct roff *r, int ln, struct buf *buf, 
   
         ppos = pos = *offs;          ppos = pos = *offs;
   
           if (len > 80 && r->tbl == NULL && r->eqn == NULL &&
               (r->man->flags & ROFF_NOFILL) == 0 &&
               strchr(" .\\", buf->buf[pos]) == NULL &&
               buf->buf[pos] != r->control &&
               strcspn(buf->buf, " ") < 80)
                   mandoc_msg(MANDOCERR_TEXT_LONG, ln, (int)len - 1,
                       "%.20s...", buf->buf + pos);
   
         /* Handle in-line equation delimiters. */          /* Handle in-line equation delimiters. */
   
         if (r->tbl == NULL &&          if (r->tbl == NULL &&
Line 1811  roff_parseln(struct roff *r, int ln, struct buf *buf, 
Line 1888  roff_parseln(struct roff *r, int ln, struct buf *buf, 
                 roff_addtbl(r->man, ln, r->tbl);                  roff_addtbl(r->man, ln, r->tbl);
                 return e;                  return e;
         }          }
         if ( ! ctl)          if ( ! ctl) {
                   r->options &= ~MPARSE_COMMENT;
                 return roff_parsetext(r, buf, pos, offs) | e;                  return roff_parsetext(r, buf, pos, offs) | e;
           }
   
         /* Skip empty request lines. */          /* Skip empty request lines. */
   
Line 1835  roff_parseln(struct roff *r, int ln, struct buf *buf, 
Line 1914  roff_parseln(struct roff *r, int ln, struct buf *buf, 
   
         /* No scope is open.  This is a new request or macro. */          /* No scope is open.  This is a new request or macro. */
   
           r->options &= ~MPARSE_COMMENT;
         spos = pos;          spos = pos;
         t = roff_parse(r, buf->buf, &pos, ln, ppos);          t = roff_parse(r, buf->buf, &pos, ln, ppos);
   
Line 1964  roff_parse(struct roff *r, char *buf, int *pos, int ln
Line 2044  roff_parse(struct roff *r, char *buf, int *pos, int ln
   
 /* --- handling of request blocks ----------------------------------------- */  /* --- handling of request blocks ----------------------------------------- */
   
   /*
    * Close a macro definition block or an "ignore" block.
    */
 static int  static int
 roff_cblock(ROFF_ARGS)  roff_cblock(ROFF_ARGS)
 {  {
           int      rr;
   
         /*  
          * A block-close `..' should only be invoked as a child of an  
          * ignore macro, otherwise raise a warning and just ignore it.  
          */  
   
         if (r->last == NULL) {          if (r->last == NULL) {
                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "..");                  mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "..");
                 return ROFF_IGN;                  return ROFF_IGN;
Line 1980  roff_cblock(ROFF_ARGS)
Line 2059  roff_cblock(ROFF_ARGS)
   
         switch (r->last->tok) {          switch (r->last->tok) {
         case ROFF_am:          case ROFF_am:
                 /* ROFF_am1 is remapped to ROFF_am in roff_block(). */  
         case ROFF_ami:          case ROFF_ami:
         case ROFF_de:          case ROFF_de:
                 /* ROFF_de1 is remapped to ROFF_de in roff_block(). */  
         case ROFF_dei:          case ROFF_dei:
         case ROFF_ig:          case ROFF_ig:
                 break;                  break;
           case ROFF_am1:
           case ROFF_de1:
                   /* Remapped in roff_block(). */
                   abort();
         default:          default:
                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "..");                  mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "..");
                 return ROFF_IGN;                  return ROFF_IGN;
         }          }
   
           roffnode_pop(r);
           roffnode_cleanscope(r);
   
           /*
            * If a conditional block with braces is still open,
            * check for "\}" block end markers.
            */
   
           if (r->last != NULL && r->last->endspan < 0) {
                   rr = 1;  /* If arguments follow "\}", warn about them. */
                   roff_cond_checkend(r, tok, buf, ln, ppos, pos, &rr);
           }
   
         if (buf->buf[pos] != '\0')          if (buf->buf[pos] != '\0')
                 mandoc_msg(MANDOCERR_ARG_SKIP, ln, pos,                  mandoc_msg(MANDOCERR_ARG_SKIP, ln, pos,
                     ".. %s", buf->buf + pos);                      ".. %s", buf->buf + pos);
   
         roffnode_pop(r);  
         roffnode_cleanscope(r);  
         return ROFF_IGN;          return ROFF_IGN;
   
 }  }
   
   /*
    * Pop all nodes ending at the end of the current input line.
    * Return the number of loops ended.
    */
 static int  static int
 roffnode_cleanscope(struct roff *r)  roffnode_cleanscope(struct roff *r)
 {  {
         int inloop;          int inloop;
   
         inloop = 0;          inloop = 0;
         while (r->last != NULL) {          while (r->last != NULL && r->last->endspan > 0) {
                 if (--r->last->endspan != 0)                  if (--r->last->endspan != 0)
                         break;                          break;
                 inloop += roffnode_pop(r);                  inloop += roffnode_pop(r);
Line 2016  roffnode_cleanscope(struct roff *r)
Line 2111  roffnode_cleanscope(struct roff *r)
         return inloop;          return inloop;
 }  }
   
   /*
    * Handle the closing "\}" of a conditional block.
    * Apart from generating warnings, this only pops nodes.
    * Return the number of loops ended.
    */
 static int  static int
 roff_ccond(struct roff *r, int ln, int ppos)  roff_ccond(struct roff *r, int ln, int ppos)
 {  {
Line 2232  roff_block_text(ROFF_ARGS)
Line 2332  roff_block_text(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
   /*
    * Check for a closing "\}" and handle it.
    * In this function, the final "int *offs" argument is used for
    * different purposes than elsewhere:
    * Input: *offs == 0: caller wants to discard arguments following \}
    *        *offs == 1: caller wants to preserve text following \}
    * Output: *offs = 0: tell caller to discard input line
    *         *offs = 1: tell caller to use input line
    */
 static int  static int
 roff_cond_sub(ROFF_ARGS)  roff_cond_checkend(ROFF_ARGS)
 {  {
         char            *ep;          char            *ep;
         int              endloop, irc, rr;          int              endloop, irc, rr;
         enum roff_tok    t;  
   
         irc = ROFF_IGN;          irc = ROFF_IGN;
         rr = r->last->rule;          rr = r->last->rule;
Line 2247  roff_cond_sub(ROFF_ARGS)
Line 2355  roff_cond_sub(ROFF_ARGS)
                 irc |= endloop;                  irc |= endloop;
   
         /*          /*
          * If `\}' occurs on a macro line without a preceding macro,           * If "\}" occurs on a macro line without a preceding macro or
          * drop the line completely.           * a text line contains nothing else, drop the line completely.
          */           */
   
         ep = buf->buf + pos;          ep = buf->buf + pos;
         if (ep[0] == '\\' && ep[1] == '}')          if (ep[0] == '\\' && ep[1] == '}' && (ep[2] == '\0' || *offs == 0))
                 rr = 0;                  rr = 0;
   
         /*          /*
          * The closing delimiter `\}' rewinds the conditional scope           * The closing delimiter "\}" rewinds the conditional scope
          * but is otherwise ignored when interpreting the line.           * but is otherwise ignored when interpreting the line.
          */           */
   
         while ((ep = strchr(ep, '\\')) != NULL) {          while ((ep = strchr(ep, '\\')) != NULL) {
                 switch (ep[1]) {                  switch (ep[1]) {
                 case '}':                  case '}':
                         memmove(ep, ep + 2, strlen(ep + 2) + 1);                          if (ep[2] == '\0')
                                   ep[0] = '\0';
                           else if (rr)
                                   ep[1] = '&';
                           else
                                   memmove(ep, ep + 2, strlen(ep + 2) + 1);
                         if (roff_ccond(r, ln, ep - buf->buf))                          if (roff_ccond(r, ln, ep - buf->buf))
                                 irc |= endloop;                                  irc |= endloop;
                         break;                          break;
Line 2275  roff_cond_sub(ROFF_ARGS)
Line 2388  roff_cond_sub(ROFF_ARGS)
                         break;                          break;
                 }                  }
         }          }
           *offs = rr;
         /*  
          * 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);  
         irc |= t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT) ?  
             (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs) :  
             rr ? ROFF_CONT : ROFF_IGN;  
         return irc;          return irc;
 }  }
   
   /*
    * Parse and process a request or macro line in conditional scope.
    */
 static int  static int
 roff_cond_text(ROFF_ARGS)  roff_cond_sub(ROFF_ARGS)
 {  {
         char            *ep;          struct roffnode *bl;
         int              endloop, irc, rr;          int              irc, rr;
           enum roff_tok    t;
   
         irc = ROFF_IGN;          rr = 0;  /* If arguments follow "\}", skip them. */
         rr = r->last->rule;          irc = roff_cond_checkend(r, tok, buf, ln, ppos, pos, &rr);
         endloop = tok != ROFF_while ? ROFF_IGN :          t = roff_parse(r, buf->buf, &pos, ln, ppos);
             rr ? ROFF_LOOPCONT : ROFF_LOOPEXIT;  
         if (roffnode_cleanscope(r))  
                 irc |= endloop;  
   
         /*          /* For now, let high level macros abort .ce mode. */
          * If `\}' occurs on a text line with neither preceding  
          * nor following characters, drop the line completely.  
          */  
   
         ep = buf->buf + pos;          if (roffce_node != NULL &&
         if (strcmp(ep, "\\}") == 0)              (t == TOKEN_NONE || t == ROFF_Dd || t == ROFF_EQ ||
                 rr = 0;               t == ROFF_TH || t == ROFF_TS)) {
                   r->man->last = roffce_node;
                   r->man->next = ROFF_NEXT_SIBLING;
                   roffce_lines = 0;
                   roffce_node = NULL;
           }
   
         /*          /*
          * The closing delimiter `\}' rewinds the conditional scope           * Fully handle known macros when they are structurally
          * but is otherwise ignored when interpreting the line.           * required or when the conditional evaluated to true.
          */           */
   
         while ((ep = strchr(ep, '\\')) != NULL) {          if (t == ROFF_break) {
                 switch (ep[1]) {                  if (irc & ROFF_LOOPMASK)
                 case '}':                          irc = ROFF_IGN | ROFF_LOOPEXIT;
                         memmove(ep, ep + 2, strlen(ep + 2) + 1);                  else if (rr) {
                         if (roff_ccond(r, ln, ep - buf->buf))                          for (bl = r->last; bl != NULL; bl = bl->parent) {
                                 irc |= endloop;                                  bl->rule = 0;
                         break;                                  if (bl->tok == ROFF_while)
                 case '\0':                                          break;
                         ++ep;                          }
                         break;  
                 default:  
                         ep += 2;  
                         break;  
                 }                  }
         }          } else if (t != TOKEN_NONE &&
               (rr || roffs[t].flags & ROFFMAC_STRUCT))
                   irc |= (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
           else
                   irc |= rr ? ROFF_CONT : ROFF_IGN;
           return irc;
   }
   
   /*
    * Parse and process a text line in conditional scope.
    */
   static int
   roff_cond_text(ROFF_ARGS)
   {
           int      irc, rr;
   
           rr = 1;  /* If arguments follow "\}", preserve them. */
           irc = roff_cond_checkend(r, tok, buf, ln, ppos, pos, &rr);
         if (rr)          if (rr)
                 irc |= ROFF_CONT;                  irc |= ROFF_CONT;
         return irc;          return irc;
Line 3482  roff_als(ROFF_ARGS)
Line 3602  roff_als(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
   /*
    * The .break request only makes sense inside conditionals,
    * and that case is already handled in roff_cond_sub().
    */
 static int  static int
   roff_break(ROFF_ARGS)
   {
           mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, pos, "break");
           return ROFF_IGN;
   }
   
   static int
 roff_cc(ROFF_ARGS)  roff_cc(ROFF_ARGS)
 {  {
         const char      *p;          const char      *p;
Line 3537  roff_char(ROFF_ARGS)
Line 3668  roff_char(ROFF_ARGS)
                 case ESCAPE_FONTITALIC:                  case ESCAPE_FONTITALIC:
                 case ESCAPE_FONTBOLD:                  case ESCAPE_FONTBOLD:
                 case ESCAPE_FONTBI:                  case ESCAPE_FONTBI:
                 case ESCAPE_FONTCW:                  case ESCAPE_FONTCR:
                   case ESCAPE_FONTCB:
                   case ESCAPE_FONTCI:
                 case ESCAPE_FONTPREV:                  case ESCAPE_FONTPREV:
                         font++;                          font++;
                         break;                          break;
Line 3737  static int
Line 3870  static int
 roff_shift(ROFF_ARGS)  roff_shift(ROFF_ARGS)
 {  {
         struct mctx     *ctx;          struct mctx     *ctx;
         int              levels, i;          int              argpos, levels, i;
   
           argpos = pos;
         levels = 1;          levels = 1;
         if (buf->buf[pos] != '\0' &&          if (buf->buf[pos] != '\0' &&
             roff_evalnum(r, ln, buf->buf, &pos, &levels, 0) == 0) {              roff_evalnum(r, ln, buf->buf, &pos, &levels, 0) == 0) {
Line 3753  roff_shift(ROFF_ARGS)
Line 3887  roff_shift(ROFF_ARGS)
         ctx = r->mstack + r->mstackpos;          ctx = r->mstack + r->mstackpos;
         if (levels > ctx->argc) {          if (levels > ctx->argc) {
                 mandoc_msg(MANDOCERR_SHIFT,                  mandoc_msg(MANDOCERR_SHIFT,
                     ln, pos, "%d, but max is %d", levels, ctx->argc);                      ln, argpos, "%d, but max is %d", levels, ctx->argc);
                 levels = ctx->argc;                  levels = ctx->argc;
         }          }
           if (levels < 0) {
                   mandoc_msg(MANDOCERR_ARG_NEG, ln, argpos, "shift %d", levels);
                   levels = 0;
           }
         if (levels == 0)          if (levels == 0)
                 return ROFF_IGN;                  return ROFF_IGN;
         for (i = 0; i < levels; i++)          for (i = 0; i < levels; i++)
Line 3804  roff_userdef(ROFF_ARGS)
Line 3942  roff_userdef(ROFF_ARGS)
         char             *arg, *ap, *dst, *src;          char             *arg, *ap, *dst, *src;
         size_t            sz;          size_t            sz;
   
           /* If the macro is empty, ignore it altogether. */
   
           if (*r->current_string == '\0')
                   return ROFF_IGN;
   
         /* Initialize a new macro stack context. */          /* Initialize a new macro stack context. */
   
         if (++r->mstackpos == r->mstacksz) {          if (++r->mstackpos == r->mstacksz) {
Line 3812  roff_userdef(ROFF_ARGS)
Line 3955  roff_userdef(ROFF_ARGS)
                 r->mstacksz += 8;                  r->mstacksz += 8;
         }          }
         ctx = r->mstack + r->mstackpos;          ctx = r->mstack + r->mstackpos;
         ctx->argsz = 0;  
         ctx->argc = 0;          ctx->argc = 0;
         ctx->argv = NULL;  
   
         /*          /*
          * Collect pointers to macro argument strings,           * Collect pointers to macro argument strings,
Line 3851  roff_userdef(ROFF_ARGS)
Line 3992  roff_userdef(ROFF_ARGS)
         buf->sz = strlen(buf->buf) + 1;          buf->sz = strlen(buf->buf) + 1;
         *offs = 0;          *offs = 0;
   
         return buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ?          return buf->buf[buf->sz - 2] == '\n' ?
             ROFF_REPARSE | ROFF_USERCALL : ROFF_IGN | ROFF_APPEND;              ROFF_REPARSE | ROFF_USERCALL : ROFF_IGN | ROFF_APPEND;
 }  }
   
Legend:
Removed from v.1.363  
changed lines
  Added in v.1.382
CVSweb