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

Diff for /mandoc/roff.c between version 1.359 and 1.368

version 1.359, 2018/12/31 08:18:12 version 1.368, 2019/12/26 19:51:51
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * 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, 2018 Ingo Schwarze <schwarze@openbsd.org>   * 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 133  struct roff {
Line 133  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 184  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);
Line 400  static struct roffmac  roffs[TOKEN_NONE] = {
Line 404  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 689  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 771  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 784  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 801  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 889  roff_node_alloc(struct roff_man *man, int line, int po
Line 894  roff_node_alloc(struct roff_man *man, int line, int po
                 n->flags |= NODE_SYNPRETTY;                  n->flags |= NODE_SYNPRETTY;
         else          else
                 n->flags &= ~NODE_SYNPRETTY;                  n->flags &= ~NODE_SYNPRETTY;
         if (man->flags & ROFF_NOFILL)          if ((man->flags & (ROFF_NOFILL | ROFF_NONOFILL)) == ROFF_NOFILL)
                 n->flags |= NODE_NOFILL;                  n->flags |= NODE_NOFILL;
         else          else
                 n->flags &= ~NODE_NOFILL;                  n->flags &= ~NODE_NOFILL;
Line 1242  roff_expand(struct roff *r, struct buf *buf, int ln, i
Line 1247  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 1586  char *
Line 1591  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 1811  roff_parseln(struct roff *r, int ln, struct buf *buf, 
Line 1816  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 1842  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 2002  roff_cblock(ROFF_ARGS)
Line 2010  roff_cblock(ROFF_ARGS)
   
 }  }
   
   /*
    * 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)
 {  {
Line 2016  roffnode_cleanscope(struct roff *r)
Line 2028  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 2235  roff_block_text(ROFF_ARGS)
Line 2252  roff_block_text(ROFF_ARGS)
 static int  static int
 roff_cond_sub(ROFF_ARGS)  roff_cond_sub(ROFF_ARGS)
 {  {
           struct roffnode *bl;
         char            *ep;          char            *ep;
         int              endloop, irc, rr;          int              endloop, irc, rr;
         enum roff_tok    t;          enum roff_tok    t;
Line 2276  roff_cond_sub(ROFF_ARGS)
Line 2294  roff_cond_sub(ROFF_ARGS)
                 }                  }
         }          }
   
           t = roff_parse(r, buf->buf, &pos, ln, ppos);
   
           /* For now, let high level macros abort .ce mode. */
   
           if (roffce_node != NULL &&
               (t == TOKEN_NONE || t == ROFF_Dd || t == ROFF_EQ ||
                t == ROFF_TH || t == ROFF_TS)) {
                   r->man->last = roffce_node;
                   r->man->next = ROFF_NEXT_SIBLING;
                   roffce_lines = 0;
                   roffce_node = NULL;
           }
   
         /*          /*
          * Fully handle known macros when they are structurally           * Fully handle known macros when they are structurally
          * required or when the conditional evaluated to true.           * required or when the conditional evaluated to true.
          */           */
   
         t = roff_parse(r, buf->buf, &pos, ln, ppos);          if (t == ROFF_break) {
         irc |= t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT) ?                  if (irc & ROFF_LOOPMASK)
             (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs) :                          irc = ROFF_IGN | ROFF_LOOPEXIT;
             rr ? ROFF_CONT : ROFF_IGN;                  else if (rr) {
                           for (bl = r->last; bl != NULL; bl = bl->parent) {
                                   bl->rule = 0;
                                   if (bl->tok == ROFF_while)
                                           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;          return irc;
 }  }
   
Line 2537  roff_evalcond(struct roff *r, int ln, char *v, int *po
Line 2579  roff_evalcond(struct roff *r, int ln, char *v, int *po
                         roff_getstrn(r, name, sz, &deftype);                          roff_getstrn(r, name, sz, &deftype);
                         istrue = !!deftype;                          istrue = !!deftype;
                 }                  }
                 *pos = cp - v;                  *pos = (name + sz) - v;
                 return istrue == wanttrue;                  return istrue == wanttrue;
         default:          default:
                 break;                  break;
Line 2683  roff_ds(ROFF_ARGS)
Line 2725  roff_ds(ROFF_ARGS)
                 return ROFF_IGN;                  return ROFF_IGN;
   
         namesz = roff_getname(r, &string, ln, pos);          namesz = roff_getname(r, &string, ln, pos);
         if (name[namesz] == '\\')          switch (name[namesz]) {
           case '\\':
                 return ROFF_IGN;                  return ROFF_IGN;
           case '\t':
                   string = buf->buf + pos + namesz;
                   break;
           default:
                   break;
           }
   
         /* Read past the initial double-quote, if any. */          /* Read past the initial double-quote, if any. */
         if (*string == '"')          if (*string == '"')
Line 3060  roff_nr(ROFF_ARGS)
Line 3109  roff_nr(ROFF_ARGS)
                 return ROFF_IGN;                  return ROFF_IGN;
   
         keysz = roff_getname(r, &val, ln, pos);          keysz = roff_getname(r, &val, ln, pos);
         if (key[keysz] == '\\')          if (key[keysz] == '\\' || key[keysz] == '\t')
                 return ROFF_IGN;                  return ROFF_IGN;
   
         sign = *val;          sign = *val;
Line 3124  roff_rm(ROFF_ARGS)
Line 3173  roff_rm(ROFF_ARGS)
                 namesz = roff_getname(r, &cp, ln, (int)(cp - buf->buf));                  namesz = roff_getname(r, &cp, ln, (int)(cp - buf->buf));
                 roff_setstrn(&r->strtab, name, namesz, NULL, 0, 0);                  roff_setstrn(&r->strtab, name, namesz, NULL, 0, 0);
                 roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0);                  roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0);
                 if (name[namesz] == '\\')                  if (name[namesz] == '\\' || name[namesz] == '\t')
                         break;                          break;
         }          }
         return ROFF_IGN;          return ROFF_IGN;
Line 3192  roff_Dd(ROFF_ARGS)
Line 3241  roff_Dd(ROFF_ARGS)
 static int  static int
 roff_TE(ROFF_ARGS)  roff_TE(ROFF_ARGS)
 {  {
           r->man->flags &= ~ROFF_NONOFILL;
         if (r->tbl == NULL) {          if (r->tbl == NULL) {
                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "TE");                  mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "TE");
                 return ROFF_IGN;                  return ROFF_IGN;
Line 3336  roff_TS(ROFF_ARGS)
Line 3386  roff_TS(ROFF_ARGS)
                 mandoc_msg(MANDOCERR_BLK_BROKEN, ln, ppos, "TS breaks TS");                  mandoc_msg(MANDOCERR_BLK_BROKEN, ln, ppos, "TS breaks TS");
                 tbl_end(r->tbl, 0);                  tbl_end(r->tbl, 0);
         }          }
           r->man->flags |= ROFF_NONOFILL;
         r->tbl = tbl_alloc(ppos, ln, r->last_tbl);          r->tbl = tbl_alloc(ppos, ln, r->last_tbl);
         if (r->last_tbl == NULL)          if (r->last_tbl == NULL)
                 r->first_tbl = r->tbl;                  r->first_tbl = r->tbl;
Line 3457  roff_als(ROFF_ARGS)
Line 3508  roff_als(ROFF_ARGS)
                 return ROFF_IGN;                  return ROFF_IGN;
   
         newsz = roff_getname(r, &oldn, ln, pos);          newsz = roff_getname(r, &oldn, ln, pos);
         if (newn[newsz] == '\\' || *oldn == '\0')          if (newn[newsz] == '\\' || newn[newsz] == '\t' || *oldn == '\0')
                 return ROFF_IGN;                  return ROFF_IGN;
   
         end = oldn;          end = oldn;
Line 3473  roff_als(ROFF_ARGS)
Line 3524  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 3687  roff_rn(ROFF_ARGS)
Line 3749  roff_rn(ROFF_ARGS)
                 return ROFF_IGN;                  return ROFF_IGN;
   
         oldsz = roff_getname(r, &newn, ln, pos);          oldsz = roff_getname(r, &newn, ln, pos);
         if (oldn[oldsz] == '\\' || *newn == '\0')          if (oldn[oldsz] == '\\' || oldn[oldsz] == '\t' || *newn == '\0')
                 return ROFF_IGN;                  return ROFF_IGN;
   
         end = newn;          end = newn;
Line 3795  roff_userdef(ROFF_ARGS)
Line 3857  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 3842  roff_userdef(ROFF_ARGS)
Line 3909  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;
 }  }
   
Line 3863  roff_renamed(ROFF_ARGS)
Line 3930  roff_renamed(ROFF_ARGS)
         return ROFF_CONT;          return ROFF_CONT;
 }  }
   
   /*
    * Measure the length in bytes of the roff identifier at *cpp
    * and advance the pointer to the next word.
    */
 static size_t  static size_t
 roff_getname(struct roff *r, char **cpp, int ln, int pos)  roff_getname(struct roff *r, char **cpp, int ln, int pos)
 {  {
Line 3870  roff_getname(struct roff *r, char **cpp, int ln, int p
Line 3941  roff_getname(struct roff *r, char **cpp, int ln, int p
         size_t    namesz;          size_t    namesz;
   
         name = *cpp;          name = *cpp;
         if ('\0' == *name)          if (*name == '\0')
                 return 0;                  return 0;
   
         /* Read until end of name and terminate it with NUL. */          /* Advance cp to the byte after the end of the name. */
   
         for (cp = name; 1; cp++) {          for (cp = name; 1; cp++) {
                 if ('\0' == *cp || ' ' == *cp) {                  namesz = cp - name;
                         namesz = cp - name;                  if (*cp == '\0')
                         break;                          break;
                   if (*cp == ' ' || *cp == '\t') {
                           cp++;
                           break;
                 }                  }
                 if ('\\' != *cp)                  if (*cp != '\\')
                         continue;                          continue;
                 namesz = cp - name;                  if (cp[1] == '{' || cp[1] == '}')
                 if ('{' == cp[1] || '}' == cp[1])  
                         break;                          break;
                 cp++;                  if (*++cp == '\\')
                 if ('\\' == *cp)  
                         continue;                          continue;
                 mandoc_msg(MANDOCERR_NAMESC, ln, pos,                  mandoc_msg(MANDOCERR_NAMESC, ln, pos,
                     "%.*s", (int)(cp - name + 1), name);                      "%.*s", (int)(cp - name + 1), name);
Line 3894  roff_getname(struct roff *r, char **cpp, int ln, int p
Line 3967  roff_getname(struct roff *r, char **cpp, int ln, int p
         }          }
   
         /* Read past spaces. */          /* Read past spaces. */
         while (' ' == *cp)  
           while (*cp == ' ')
                 cp++;                  cp++;
   
         *cpp = cp;          *cpp = cp;
Legend:
Removed from v.1.359  
changed lines
  Added in v.1.368
CVSweb