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

Diff for /mandoc/roff.c between version 1.339 and 1.340

version 1.339, 2018/08/23 14:29:39 version 1.340, 2018/08/24 23:12:33
Line 143  struct roffnode {
Line 143  struct roffnode {
                          int pos, /* current pos in buffer */ \                           int pos, /* current pos in buffer */ \
                          int *offs /* reset offset of buffer data */                           int *offs /* reset offset of buffer data */
   
 typedef enum rofferr (*roffproc)(ROFF_ARGS);  typedef int (*roffproc)(ROFF_ARGS);
   
 struct  roffmac {  struct  roffmac {
         roffproc         proc; /* process new macro */          roffproc         proc; /* process new macro */
Line 163  struct predef {
Line 163  struct predef {
   
 /* --- function prototypes ------------------------------------------------ */  /* --- function prototypes ------------------------------------------------ */
   
 static  void             roffnode_cleanscope(struct roff *);  static  int              roffnode_cleanscope(struct roff *);
 static  void             roffnode_pop(struct roff *);  static  int              roffnode_pop(struct roff *);
 static  void             roffnode_push(struct roff *, enum roff_tok,  static  void             roffnode_push(struct roff *, enum roff_tok,
                                 const char *, int, int);                                  const char *, int, int);
 static  void             roff_addtbl(struct roff_man *, struct tbl_node *);  static  void             roff_addtbl(struct roff_man *, struct tbl_node *);
 static  enum rofferr     roff_als(ROFF_ARGS);  static  int              roff_als(ROFF_ARGS);
 static  enum rofferr     roff_block(ROFF_ARGS);  static  int              roff_block(ROFF_ARGS);
 static  enum rofferr     roff_block_text(ROFF_ARGS);  static  int              roff_block_text(ROFF_ARGS);
 static  enum rofferr     roff_block_sub(ROFF_ARGS);  static  int              roff_block_sub(ROFF_ARGS);
 static  enum rofferr     roff_br(ROFF_ARGS);  static  int              roff_br(ROFF_ARGS);
 static  enum rofferr     roff_cblock(ROFF_ARGS);  static  int              roff_cblock(ROFF_ARGS);
 static  enum rofferr     roff_cc(ROFF_ARGS);  static  int              roff_cc(ROFF_ARGS);
 static  void             roff_ccond(struct roff *, int, int);  static  int              roff_ccond(struct roff *, int, int);
 static  enum rofferr     roff_cond(ROFF_ARGS);  static  int              roff_cond(ROFF_ARGS);
 static  enum rofferr     roff_cond_text(ROFF_ARGS);  static  int              roff_cond_text(ROFF_ARGS);
 static  enum rofferr     roff_cond_sub(ROFF_ARGS);  static  int              roff_cond_sub(ROFF_ARGS);
 static  enum rofferr     roff_ds(ROFF_ARGS);  static  int              roff_ds(ROFF_ARGS);
 static  enum rofferr     roff_ec(ROFF_ARGS);  static  int              roff_ec(ROFF_ARGS);
 static  enum rofferr     roff_eo(ROFF_ARGS);  static  int              roff_eo(ROFF_ARGS);
 static  enum rofferr     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 *r, 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);
Line 203  static const char *roff_getstrn(struct roff *,
Line 203  static const char *roff_getstrn(struct roff *,
                                 const char *, size_t, int *);                                  const char *, size_t, int *);
 static  int              roff_hasregn(const struct roff *,  static  int              roff_hasregn(const struct roff *,
                                 const char *, size_t);                                  const char *, size_t);
 static  enum rofferr     roff_insec(ROFF_ARGS);  static  int              roff_insec(ROFF_ARGS);
 static  enum rofferr     roff_it(ROFF_ARGS);  static  int              roff_it(ROFF_ARGS);
 static  enum rofferr     roff_line_ignore(ROFF_ARGS);  static  int              roff_line_ignore(ROFF_ARGS);
 static  void             roff_man_alloc1(struct roff_man *);  static  void             roff_man_alloc1(struct roff_man *);
 static  void             roff_man_free1(struct roff_man *);  static  void             roff_man_free1(struct roff_man *);
 static  enum rofferr     roff_manyarg(ROFF_ARGS);  static  int              roff_manyarg(ROFF_ARGS);
 static  enum rofferr     roff_nop(ROFF_ARGS);  static  int              roff_nop(ROFF_ARGS);
 static  enum rofferr     roff_nr(ROFF_ARGS);  static  int              roff_nr(ROFF_ARGS);
 static  enum rofferr     roff_onearg(ROFF_ARGS);  static  int              roff_onearg(ROFF_ARGS);
 static  enum roff_tok    roff_parse(struct roff *, char *, int *,  static  enum roff_tok    roff_parse(struct roff *, char *, int *,
                                 int, int);                                  int, int);
 static  enum rofferr     roff_parsetext(struct roff *, struct buf *,  static  int              roff_parsetext(struct roff *, struct buf *,
                                 int, int *);                                  int, int *);
 static  enum rofferr     roff_renamed(ROFF_ARGS);  static  int              roff_renamed(ROFF_ARGS);
 static  enum rofferr     roff_res(struct roff *, struct buf *, int, int);  static  int              roff_res(struct roff *, struct buf *, int, int);
 static  enum rofferr     roff_return(ROFF_ARGS);  static  int              roff_return(ROFF_ARGS);
 static  enum rofferr     roff_rm(ROFF_ARGS);  static  int              roff_rm(ROFF_ARGS);
 static  enum rofferr     roff_rn(ROFF_ARGS);  static  int              roff_rn(ROFF_ARGS);
 static  enum rofferr     roff_rr(ROFF_ARGS);  static  int              roff_rr(ROFF_ARGS);
 static  void             roff_setregn(struct roff *, const char *,  static  void             roff_setregn(struct roff *, const char *,
                                 size_t, int, char, int);                                  size_t, int, char, int);
 static  void             roff_setstr(struct roff *,  static  void             roff_setstr(struct roff *,
                                 const char *, const char *, int);                                  const char *, const char *, int);
 static  void             roff_setstrn(struct roffkv **, const char *,  static  void             roff_setstrn(struct roffkv **, const char *,
                                 size_t, const char *, size_t, int);                                  size_t, const char *, size_t, int);
 static  enum rofferr     roff_shift(ROFF_ARGS);  static  int              roff_shift(ROFF_ARGS);
 static  enum rofferr     roff_so(ROFF_ARGS);  static  int              roff_so(ROFF_ARGS);
 static  enum rofferr     roff_tr(ROFF_ARGS);  static  int              roff_tr(ROFF_ARGS);
 static  enum rofferr     roff_Dd(ROFF_ARGS);  static  int              roff_Dd(ROFF_ARGS);
 static  enum rofferr     roff_TE(ROFF_ARGS);  static  int              roff_TE(ROFF_ARGS);
 static  enum rofferr     roff_TS(ROFF_ARGS);  static  int              roff_TS(ROFF_ARGS);
 static  enum rofferr     roff_EQ(ROFF_ARGS);  static  int              roff_EQ(ROFF_ARGS);
 static  enum rofferr     roff_EN(ROFF_ARGS);  static  int              roff_EN(ROFF_ARGS);
 static  enum rofferr     roff_T_(ROFF_ARGS);  static  int              roff_T_(ROFF_ARGS);
 static  enum rofferr     roff_unsupp(ROFF_ARGS);  static  int              roff_unsupp(ROFF_ARGS);
 static  enum rofferr     roff_userdef(ROFF_ARGS);  static  int              roff_userdef(ROFF_ARGS);
   
 /* --- constant data ------------------------------------------------------ */  /* --- constant data ------------------------------------------------------ */
   
Line 590  static struct roffmac  roffs[TOKEN_NONE] = {
Line 590  static struct roffmac  roffs[TOKEN_NONE] = {
         { roff_line_ignore, NULL, NULL, 0 },  /* watchlength */          { roff_line_ignore, NULL, NULL, 0 },  /* watchlength */
         { roff_line_ignore, NULL, NULL, 0 },  /* watchn */          { roff_line_ignore, NULL, NULL, 0 },  /* watchn */
         { roff_unsupp, NULL, NULL, 0 },  /* wh */          { roff_unsupp, NULL, NULL, 0 },  /* wh */
         { roff_unsupp, NULL, NULL, 0 },  /* while */          { roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT }, /*while*/
         { roff_insec, NULL, NULL, 0 },  /* write */          { roff_insec, NULL, NULL, 0 },  /* write */
         { roff_insec, NULL, NULL, 0 },  /* writec */          { roff_insec, NULL, NULL, 0 },  /* writec */
         { roff_insec, NULL, NULL, 0 },  /* writem */          { roff_insec, NULL, NULL, 0 },  /* writem */
Line 674  roffhash_find(struct ohash *htab, const char *name, si
Line 674  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.
  */   */
 static void  static int
 roffnode_pop(struct roff *r)  roffnode_pop(struct roff *r)
 {  {
         struct roffnode *p;          struct roffnode *p;
           int              inloop;
   
         assert(r->last);  
         p = r->last;          p = r->last;
           inloop = p->tok == ROFF_while;
         r->last = r->last->parent;          r->last = p->parent;
         free(p->name);          free(p->name);
         free(p->end);          free(p->end);
         free(p);          free(p);
           return inloop;
 }  }
   
 /*  /*
Line 1144  deroff(char **dest, const struct roff_node *n)
Line 1145  deroff(char **dest, const struct roff_node *n)
  * used in numerical expressions and conditional requests.   * used in numerical expressions and conditional requests.
  * Also check the syntax of the remaining escape sequences.   * Also check the syntax of the remaining escape sequences.
  */   */
 static enum rofferr  static int
 roff_res(struct roff *r, struct buf *buf, int ln, int pos)  roff_res(struct roff *r, struct buf *buf, int ln, int pos)
 {  {
         struct mctx     *ctx;   /* current macro call context */          struct mctx     *ctx;   /* current macro call context */
Line 1236  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1237  roff_res(struct roff *r, struct buf *buf, int ln, int 
   
                 if (stesc[1] == '#') {                  if (stesc[1] == '#') {
                         *stesc = '\0';                          *stesc = '\0';
                         return ROFF_APPEND;                          return ROFF_IGN | ROFF_APPEND;
                 }                  }
   
                 /* Discard normal comments. */                  /* Discard normal comments. */
Line 1294  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1295  roff_res(struct roff *r, struct buf *buf, int ln, int 
                         if (done)                          if (done)
                                 continue;                                  continue;
                         else                          else
                                 return ROFF_APPEND;                                  return ROFF_IGN | ROFF_APPEND;
                 }                  }
   
                 /* Decide whether to expand or to check only. */                  /* Decide whether to expand or to check only. */
Line 1529  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1530  roff_res(struct roff *r, struct buf *buf, int ln, int 
 /*  /*
  * Process text streams.   * Process text streams.
  */   */
 static enum rofferr  static int
 roff_parsetext(struct roff *r, struct buf *buf, int pos, int *offs)  roff_parsetext(struct roff *r, struct buf *buf, int pos, int *offs)
 {  {
         size_t           sz;          size_t           sz;
Line 1595  roff_parsetext(struct roff *r, struct buf *buf, int po
Line 1596  roff_parsetext(struct roff *r, struct buf *buf, int po
         return ROFF_CONT;          return ROFF_CONT;
 }  }
   
 enum rofferr  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)
 {  {
         enum roff_tok    t;          enum roff_tok    t;
         enum rofferr     e;          int              e;
         int              pos;   /* parse point */          int              pos;   /* parse point */
         int              spos;  /* saved parse point for messages */          int              spos;  /* saved parse point for messages */
         int              ppos;  /* original offset in buf->buf */          int              ppos;  /* original offset in buf->buf */
Line 1621  roff_parseln(struct roff *r, int ln, struct buf *buf, 
Line 1622  roff_parseln(struct roff *r, int ln, struct buf *buf, 
         /* Expand some escape sequences. */          /* Expand some escape sequences. */
   
         e = roff_res(r, buf, ln, pos);          e = roff_res(r, buf, ln, pos);
         if (e == ROFF_IGN || e == ROFF_APPEND)          if ((e & ROFF_MASK) == ROFF_IGN)
                 return e;                  return e;
         assert(e == ROFF_CONT);          assert(e == ROFF_CONT);
   
Line 1638  roff_parseln(struct roff *r, int ln, struct buf *buf, 
Line 1639  roff_parseln(struct roff *r, int ln, struct buf *buf, 
         if (r->last != NULL && ! ctl) {          if (r->last != NULL && ! ctl) {
                 t = r->last->tok;                  t = r->last->tok;
                 e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs);                  e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs);
                 if (e == ROFF_IGN)                  if ((e & ROFF_MASK) == ROFF_IGN)
                         return e;                          return e;
                 assert(e == ROFF_CONT);                  e &= ~ROFF_MASK;
         }          } else
                   e = ROFF_IGN;
         if (r->eqn != NULL && strncmp(buf->buf + ppos, ".EN", 3)) {          if (r->eqn != NULL && strncmp(buf->buf + ppos, ".EN", 3)) {
                 eqn_read(r->eqn, buf->buf + ppos);                  eqn_read(r->eqn, buf->buf + ppos);
                 return ROFF_IGN;                  return e;
         }          }
         if (r->tbl != NULL && (ctl == 0 || buf->buf[pos] == '\0')) {          if (r->tbl != NULL && (ctl == 0 || buf->buf[pos] == '\0')) {
                 tbl_read(r->tbl, ln, buf->buf, ppos);                  tbl_read(r->tbl, ln, buf->buf, ppos);
                 roff_addtbl(r->man, r->tbl);                  roff_addtbl(r->man, r->tbl);
                 return ROFF_IGN;                  return e;
         }          }
         if ( ! ctl)          if ( ! ctl)
                 return roff_parsetext(r, buf, pos, offs);                  return roff_parsetext(r, buf, pos, offs) | e;
   
         /* Skip empty request lines. */          /* Skip empty request lines. */
   
Line 1808  roff_parse(struct roff *r, char *buf, int *pos, int ln
Line 1810  roff_parse(struct roff *r, char *buf, int *pos, int ln
   
 /* --- handling of request blocks ----------------------------------------- */  /* --- handling of request blocks ----------------------------------------- */
   
 static enum rofferr  static int
 roff_cblock(ROFF_ARGS)  roff_cblock(ROFF_ARGS)
 {  {
   
Line 1848  roff_cblock(ROFF_ARGS)
Line 1850  roff_cblock(ROFF_ARGS)
   
 }  }
   
 static void  static int
 roffnode_cleanscope(struct roff *r)  roffnode_cleanscope(struct roff *r)
 {  {
           int inloop;
   
         while (r->last) {          inloop = 0;
           while (r->last != NULL) {
                 if (--r->last->endspan != 0)                  if (--r->last->endspan != 0)
                         break;                          break;
                 roffnode_pop(r);                  inloop += roffnode_pop(r);
         }          }
           return inloop;
 }  }
   
 static void  static int
 roff_ccond(struct roff *r, int ln, int ppos)  roff_ccond(struct roff *r, int ln, int ppos)
 {  {
   
         if (NULL == r->last) {          if (NULL == r->last) {
                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,                  mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
                     ln, ppos, "\\}");                      ln, ppos, "\\}");
                 return;                  return 0;
         }          }
   
         switch (r->last->tok) {          switch (r->last->tok) {
         case ROFF_el:          case ROFF_el:
         case ROFF_ie:          case ROFF_ie:
         case ROFF_if:          case ROFF_if:
           case ROFF_while:
                 break;                  break;
         default:          default:
                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,                  mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
                     ln, ppos, "\\}");                      ln, ppos, "\\}");
                 return;                  return 0;
         }          }
   
         if (r->last->endspan > -1) {          if (r->last->endspan > -1) {
                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,                  mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
                     ln, ppos, "\\}");                      ln, ppos, "\\}");
                 return;                  return 0;
         }          }
   
         roffnode_pop(r);          return roffnode_pop(r) + roffnode_cleanscope(r);
         roffnode_cleanscope(r);  
         return;  
 }  }
   
 static enum rofferr  static int
 roff_block(ROFF_ARGS)  roff_block(ROFF_ARGS)
 {  {
         const char      *name, *value;          const char      *name, *value;
Line 2016  roff_block(ROFF_ARGS)
Line 2019  roff_block(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_block_sub(ROFF_ARGS)  roff_block_sub(ROFF_ARGS)
 {  {
         enum roff_tok   t;          enum roff_tok   t;
Line 2070  roff_block_sub(ROFF_ARGS)
Line 2073  roff_block_sub(ROFF_ARGS)
         return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);          return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
 }  }
   
 static enum rofferr  static int
 roff_block_text(ROFF_ARGS)  roff_block_text(ROFF_ARGS)
 {  {
   
Line 2080  roff_block_text(ROFF_ARGS)
Line 2083  roff_block_text(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_cond_sub(ROFF_ARGS)  roff_cond_sub(ROFF_ARGS)
 {  {
         enum roff_tok    t;  
         char            *ep;          char            *ep;
         int              rr;          int              endloop, irc, rr;
           enum roff_tok    t;
   
           irc = ROFF_IGN;
         rr = r->last->rule;          rr = r->last->rule;
         roffnode_cleanscope(r);          endloop = tok != ROFF_while ? ROFF_IGN :
               rr ? ROFF_LOOPCONT : ROFF_LOOPEXIT;
           if (roffnode_cleanscope(r))
                   irc |= endloop;
   
         /*          /*
          * If `\}' occurs on a macro line without a preceding macro,           * If `\}' occurs on a macro line without a preceding macro,
Line 2105  roff_cond_sub(ROFF_ARGS)
Line 2112  roff_cond_sub(ROFF_ARGS)
                 switch (ep[1]) {                  switch (ep[1]) {
                 case '}':                  case '}':
                         memmove(ep, ep + 2, strlen(ep + 2) + 1);                          memmove(ep, ep + 2, strlen(ep + 2) + 1);
                         roff_ccond(r, ln, ep - buf->buf);                          if (roff_ccond(r, ln, ep - buf->buf))
                                   irc |= endloop;
                         break;                          break;
                 case '\0':                  case '\0':
                         ++ep;                          ++ep;
Line 2122  roff_cond_sub(ROFF_ARGS)
Line 2130  roff_cond_sub(ROFF_ARGS)
          */           */
   
         t = roff_parse(r, buf->buf, &pos, ln, ppos);          t = roff_parse(r, buf->buf, &pos, ln, ppos);
         return t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT)          irc |= t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT) ?
             ? (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs) : rr              (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs) :
             ? ROFF_CONT : ROFF_IGN;              rr ? ROFF_CONT : ROFF_IGN;
           return irc;
 }  }
   
 static enum rofferr  static int
 roff_cond_text(ROFF_ARGS)  roff_cond_text(ROFF_ARGS)
 {  {
         char            *ep;          char            *ep;
         int              rr;          int              endloop, irc, rr;
   
           irc = ROFF_IGN;
         rr = r->last->rule;          rr = r->last->rule;
         roffnode_cleanscope(r);          endloop = tok != ROFF_while ? ROFF_IGN :
               rr ? ROFF_LOOPCONT : ROFF_LOOPEXIT;
           if (roffnode_cleanscope(r))
                   irc |= endloop;
   
         ep = buf->buf + pos;          ep = buf->buf + pos;
         while ((ep = strchr(ep, '\\')) != NULL) {          while ((ep = strchr(ep, '\\')) != NULL) {
                 if (*(++ep) == '}') {                  if (*(++ep) == '}') {
                         *ep = '&';                          *ep = '&';
                         roff_ccond(r, ln, ep - buf->buf - 1);                          if (roff_ccond(r, ln, ep - buf->buf - 1))
                                   irc |= endloop;
                 }                  }
                 if (*ep != '\0')                  if (*ep != '\0')
                         ++ep;                          ++ep;
         }          }
         return rr ? ROFF_CONT : ROFF_IGN;          if (rr)
                   irc |= ROFF_CONT;
           return irc;
 }  }
   
 /* --- handling of numeric and conditional expressions -------------------- */  /* --- handling of numeric and conditional expressions -------------------- */
Line 2365  roff_evalcond(struct roff *r, int ln, char *v, int *po
Line 2381  roff_evalcond(struct roff *r, int ln, char *v, int *po
                 return 0;                  return 0;
 }  }
   
 static enum rofferr  static int
 roff_line_ignore(ROFF_ARGS)  roff_line_ignore(ROFF_ARGS)
 {  {
   
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_insec(ROFF_ARGS)  roff_insec(ROFF_ARGS)
 {  {
   
Line 2381  roff_insec(ROFF_ARGS)
Line 2397  roff_insec(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_unsupp(ROFF_ARGS)  roff_unsupp(ROFF_ARGS)
 {  {
   
Line 2390  roff_unsupp(ROFF_ARGS)
Line 2406  roff_unsupp(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_cond(ROFF_ARGS)  roff_cond(ROFF_ARGS)
 {  {
           int      irc;
   
         roffnode_push(r, tok, NULL, ln, ppos);          roffnode_push(r, tok, NULL, ln, ppos);
   
Line 2431  roff_cond(ROFF_ARGS)
Line 2448  roff_cond(ROFF_ARGS)
          * Determine scope.           * Determine scope.
          * If there is nothing on the line after the conditional,           * If there is nothing on the line after the conditional,
          * not even whitespace, use next-line scope.           * not even whitespace, use next-line scope.
            * Except that .while does not support next-line scope.
          */           */
   
         if (buf->buf[pos] == '\0') {          if (buf->buf[pos] == '\0' && tok != ROFF_while) {
                 r->last->endspan = 2;                  r->last->endspan = 2;
                 goto out;                  goto out;
         }          }
Line 2465  roff_cond(ROFF_ARGS)
Line 2483  roff_cond(ROFF_ARGS)
   
 out:  out:
         *offs = pos;          *offs = pos;
         return ROFF_RERUN;          irc = ROFF_RERUN;
           if (tok == ROFF_while)
                   irc |= ROFF_WHILE;
           return irc;
 }  }
   
 static enum rofferr  static int
 roff_ds(ROFF_ARGS)  roff_ds(ROFF_ARGS)
 {  {
         char            *string;          char            *string;
Line 2857  roff_freereg(struct roffreg *reg)
Line 2878  roff_freereg(struct roffreg *reg)
         }          }
 }  }
   
 static enum rofferr  static int
 roff_nr(ROFF_ARGS)  roff_nr(ROFF_ARGS)
 {  {
         char            *key, *val, *step;          char            *key, *val, *step;
Line 2891  roff_nr(ROFF_ARGS)
Line 2912  roff_nr(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_rr(ROFF_ARGS)  roff_rr(ROFF_ARGS)
 {  {
         struct roffreg  *reg, **prev;          struct roffreg  *reg, **prev;
Line 2921  roff_rr(ROFF_ARGS)
Line 2942  roff_rr(ROFF_ARGS)
   
 /* --- handler functions for roff requests -------------------------------- */  /* --- handler functions for roff requests -------------------------------- */
   
 static enum rofferr  static int
 roff_rm(ROFF_ARGS)  roff_rm(ROFF_ARGS)
 {  {
         const char       *name;          const char       *name;
Line 2940  roff_rm(ROFF_ARGS)
Line 2961  roff_rm(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_it(ROFF_ARGS)  roff_it(ROFF_ARGS)
 {  {
         int              iv;          int              iv;
Line 2969  roff_it(ROFF_ARGS)
Line 2990  roff_it(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_Dd(ROFF_ARGS)  roff_Dd(ROFF_ARGS)
 {  {
         int              mask;          int              mask;
Line 2999  roff_Dd(ROFF_ARGS)
Line 3020  roff_Dd(ROFF_ARGS)
         return ROFF_CONT;          return ROFF_CONT;
 }  }
   
 static enum rofferr  static int
 roff_TE(ROFF_ARGS)  roff_TE(ROFF_ARGS)
 {  {
         if (r->tbl == NULL) {          if (r->tbl == NULL) {
Line 3019  roff_TE(ROFF_ARGS)
Line 3040  roff_TE(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_T_(ROFF_ARGS)  roff_T_(ROFF_ARGS)
 {  {
   
Line 3035  roff_T_(ROFF_ARGS)
Line 3056  roff_T_(ROFF_ARGS)
 /*  /*
  * Handle in-line equation delimiters.   * Handle in-line equation delimiters.
  */   */
 static enum rofferr  static int
 roff_eqndelim(struct roff *r, struct buf *buf, int pos)  roff_eqndelim(struct roff *r, struct buf *buf, int pos)
 {  {
         char            *cp1, *cp2;          char            *cp1, *cp2;
Line 3098  roff_eqndelim(struct roff *r, struct buf *buf, int pos
Line 3119  roff_eqndelim(struct roff *r, struct buf *buf, int pos
         return ROFF_REPARSE;          return ROFF_REPARSE;
 }  }
   
 static enum rofferr  static int
 roff_EQ(ROFF_ARGS)  roff_EQ(ROFF_ARGS)
 {  {
         struct roff_node        *n;          struct roff_node        *n;
Line 3128  roff_EQ(ROFF_ARGS)
Line 3149  roff_EQ(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_EN(ROFF_ARGS)  roff_EN(ROFF_ARGS)
 {  {
         if (r->eqn != NULL) {          if (r->eqn != NULL) {
Line 3142  roff_EN(ROFF_ARGS)
Line 3163  roff_EN(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_TS(ROFF_ARGS)  roff_TS(ROFF_ARGS)
 {  {
         if (r->tbl != NULL) {          if (r->tbl != NULL) {
Line 3159  roff_TS(ROFF_ARGS)
Line 3180  roff_TS(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_onearg(ROFF_ARGS)  roff_onearg(ROFF_ARGS)
 {  {
         struct roff_node        *n;          struct roff_node        *n;
Line 3219  roff_onearg(ROFF_ARGS)
Line 3240  roff_onearg(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_manyarg(ROFF_ARGS)  roff_manyarg(ROFF_ARGS)
 {  {
         struct roff_node        *n;          struct roff_node        *n;
Line 3242  roff_manyarg(ROFF_ARGS)
Line 3263  roff_manyarg(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_als(ROFF_ARGS)  roff_als(ROFF_ARGS)
 {  {
         char            *oldn, *newn, *end, *value;          char            *oldn, *newn, *end, *value;
Line 3269  roff_als(ROFF_ARGS)
Line 3290  roff_als(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_br(ROFF_ARGS)  roff_br(ROFF_ARGS)
 {  {
         if (r->man->flags & (MAN_BLINE | MAN_ELINE))          if (r->man->flags & (MAN_BLINE | MAN_ELINE))
Line 3283  roff_br(ROFF_ARGS)
Line 3304  roff_br(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_cc(ROFF_ARGS)  roff_cc(ROFF_ARGS)
 {  {
         const char      *p;          const char      *p;
Line 3300  roff_cc(ROFF_ARGS)
Line 3321  roff_cc(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_ec(ROFF_ARGS)  roff_ec(ROFF_ARGS)
 {  {
         const char      *p;          const char      *p;
Line 3317  roff_ec(ROFF_ARGS)
Line 3338  roff_ec(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_eo(ROFF_ARGS)  roff_eo(ROFF_ARGS)
 {  {
         r->escape = '\0';          r->escape = '\0';
Line 3327  roff_eo(ROFF_ARGS)
Line 3348  roff_eo(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_nop(ROFF_ARGS)  roff_nop(ROFF_ARGS)
 {  {
         while (buf->buf[pos] == ' ')          while (buf->buf[pos] == ' ')
Line 3336  roff_nop(ROFF_ARGS)
Line 3357  roff_nop(ROFF_ARGS)
         return ROFF_RERUN;          return ROFF_RERUN;
 }  }
   
 static enum rofferr  static int
 roff_tr(ROFF_ARGS)  roff_tr(ROFF_ARGS)
 {  {
         const char      *p, *first, *second;          const char      *p, *first, *second;
Line 3404  roff_tr(ROFF_ARGS)
Line 3425  roff_tr(ROFF_ARGS)
  * The read module will call that after rewinding the reader stack   * The read module will call that after rewinding the reader stack
  * to the place from where the current macro was called.   * to the place from where the current macro was called.
  */   */
 static enum rofferr  static int
 roff_return(ROFF_ARGS)  roff_return(ROFF_ARGS)
 {  {
         if (r->mstackpos >= 0)          if (r->mstackpos >= 0)
                 return ROFF_USERRET;                  return ROFF_IGN | ROFF_USERRET;
   
         mandoc_msg(MANDOCERR_REQ_NOMAC, r->parse, ln, ppos, "return");          mandoc_msg(MANDOCERR_REQ_NOMAC, r->parse, ln, ppos, "return");
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_rn(ROFF_ARGS)  roff_rn(ROFF_ARGS)
 {  {
         const char      *value;          const char      *value;
Line 3464  roff_rn(ROFF_ARGS)
Line 3485  roff_rn(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_shift(ROFF_ARGS)  roff_shift(ROFF_ARGS)
 {  {
         struct mctx     *ctx;          struct mctx     *ctx;
Line 3497  roff_shift(ROFF_ARGS)
Line 3518  roff_shift(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
 static enum rofferr  static int
 roff_so(ROFF_ARGS)  roff_so(ROFF_ARGS)
 {  {
         char *name, *cp;          char *name, *cp;
Line 3529  roff_so(ROFF_ARGS)
Line 3550  roff_so(ROFF_ARGS)
   
 /* --- user defined strings and macros ------------------------------------ */  /* --- user defined strings and macros ------------------------------------ */
   
 static enum rofferr  static int
 roff_userdef(ROFF_ARGS)  roff_userdef(ROFF_ARGS)
 {  {
         struct mctx      *ctx;          struct mctx      *ctx;
Line 3583  roff_userdef(ROFF_ARGS)
Line 3604  roff_userdef(ROFF_ARGS)
         *offs = 0;          *offs = 0;
   
         return buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ?          return buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ?
            ROFF_USERCALL : ROFF_APPEND;              ROFF_REPARSE | ROFF_USERCALL : ROFF_IGN | ROFF_APPEND;
 }  }
   
 /*  /*
  * Calling a high-level macro that was renamed with .rn.   * Calling a high-level macro that was renamed with .rn.
  * r->current_string has already been set up by roff_parse().   * r->current_string has already been set up by roff_parse().
  */   */
 static enum rofferr  static int
 roff_renamed(ROFF_ARGS)  roff_renamed(ROFF_ARGS)
 {  {
         char    *nbuf;          char    *nbuf;
Legend:
Removed from v.1.339  
changed lines
  Added in v.1.340
CVSweb