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

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

version 1.326, 2018/04/09 22:27:04 version 1.339, 2018/08/23 14:29:39
Line 73  struct roffkv {
Line 73  struct roffkv {
 struct  roffreg {  struct  roffreg {
         struct roffstr   key;          struct roffstr   key;
         int              val;          int              val;
           int              step;
         struct roffreg  *next;          struct roffreg  *next;
 };  };
   
Line 84  struct roffreq {
Line 85  struct roffreq {
         char             name[];          char             name[];
 };  };
   
   /*
    * A macro processing context.
    * More than one is needed when macro calls are nested.
    */
   struct  mctx {
           char            **argv;
           int              argc;
           int              argsz;
   };
   
 struct  roff {  struct  roff {
         struct mparse   *parse; /* parse point */          struct mparse   *parse; /* parse point */
         struct roff_man *man; /* mdoc or man parser */          struct roff_man *man; /* mdoc or man parser */
         struct roffnode *last; /* leaf of stack */          struct roffnode *last; /* leaf of stack */
           struct mctx     *mstack; /* stack of macro contexts */
         int             *rstack; /* stack of inverted `ie' values */          int             *rstack; /* stack of inverted `ie' values */
         struct ohash    *reqtab; /* request lookup table */          struct ohash    *reqtab; /* request lookup table */
         struct roffreg  *regtab; /* number registers */          struct roffreg  *regtab; /* number registers */
Line 103  struct roff {
Line 115  struct roff {
         struct eqn_node *eqn; /* active equation parser */          struct eqn_node *eqn; /* active equation parser */
         int              eqn_inline; /* current equation is inline */          int              eqn_inline; /* current equation is inline */
         int              options; /* parse options */          int              options; /* parse options */
           int              mstacksz; /* current size of mstack */
           int              mstackpos; /* position in mstack */
         int              rstacksz; /* current size limit of rstack */          int              rstacksz; /* current size limit of rstack */
         int              rstackpos; /* position in rstack */          int              rstackpos; /* position in rstack */
         int              format; /* current file in mdoc or man format */          int              format; /* current file in mdoc or man format */
         int              argc; /* number of args of the last macro */  
         char             control; /* control character */          char             control; /* control character */
         char             escape; /* escape character */          char             escape; /* escape character */
 };  };
Line 182  static void   roff_freestr(struct roffkv *);
Line 195  static void   roff_freestr(struct roffkv *);
 static  size_t           roff_getname(struct roff *, char **, int, int);  static  size_t           roff_getname(struct roff *, char **, int, int);
 static  int              roff_getnum(const char *, int *, int *, int);  static  int              roff_getnum(const char *, int *, int *, int);
 static  int              roff_getop(const char *, int *, char *);  static  int              roff_getop(const char *, int *, char *);
 static  int              roff_getregn(struct roff *, const char *, size_t);  static  int              roff_getregn(struct roff *,
                                   const char *, size_t, char);
 static  int              roff_getregro(const struct roff *,  static  int              roff_getregro(const struct roff *,
                                 const char *name);                                  const char *name);
 static  const char      *roff_getstrn(struct roff *,  static  const char      *roff_getstrn(struct roff *,
Line 195  static enum rofferr  roff_line_ignore(ROFF_ARGS);
Line 209  static enum rofferr  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  enum rofferr     roff_manyarg(ROFF_ARGS);
   static  enum rofferr     roff_nop(ROFF_ARGS);
 static  enum rofferr     roff_nr(ROFF_ARGS);  static  enum rofferr     roff_nr(ROFF_ARGS);
 static  enum rofferr     roff_onearg(ROFF_ARGS);  static  enum rofferr     roff_onearg(ROFF_ARGS);
 static  enum roff_tok    roff_parse(struct roff *, char *, int *,  static  enum roff_tok    roff_parse(struct roff *, char *, int *,
Line 203  static enum rofferr  roff_parsetext(struct roff *, str
Line 218  static enum rofferr  roff_parsetext(struct roff *, str
                                 int, int *);                                  int, int *);
 static  enum rofferr     roff_renamed(ROFF_ARGS);  static  enum rofferr     roff_renamed(ROFF_ARGS);
 static  enum rofferr     roff_res(struct roff *, struct buf *, int, int);  static  enum rofferr     roff_res(struct roff *, struct buf *, int, int);
   static  enum rofferr     roff_return(ROFF_ARGS);
 static  enum rofferr     roff_rm(ROFF_ARGS);  static  enum rofferr     roff_rm(ROFF_ARGS);
 static  enum rofferr     roff_rn(ROFF_ARGS);  static  enum rofferr     roff_rn(ROFF_ARGS);
 static  enum rofferr     roff_rr(ROFF_ARGS);  static  enum rofferr     roff_rr(ROFF_ARGS);
 static  void             roff_setregn(struct roff *, const char *,  static  void             roff_setregn(struct roff *, const char *,
                                 size_t, int, char);                                  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  enum rofferr     roff_so(ROFF_ARGS);  static  enum rofferr     roff_so(ROFF_ARGS);
 static  enum rofferr     roff_tr(ROFF_ARGS);  static  enum rofferr     roff_tr(ROFF_ARGS);
 static  enum rofferr     roff_Dd(ROFF_ARGS);  static  enum rofferr     roff_Dd(ROFF_ARGS);
Line 324  const char *__roff_name[MAN_MAX + 1] = {
Line 341  const char *__roff_name[MAN_MAX + 1] = {
         "Dx",           "%Q",           "%U",           "Ta",          "Dx",           "%Q",           "%U",           "Ta",
         NULL,          NULL,
         "TH",           "SH",           "SS",           "TP",          "TH",           "SH",           "SS",           "TP",
           "TQ",
         "LP",           "PP",           "P",            "IP",          "LP",           "PP",           "P",            "IP",
         "HP",           "SM",           "SB",           "BI",          "HP",           "SM",           "SB",           "BI",
         "IB",           "BR",           "RB",           "R",          "IB",           "BR",           "RB",           "R",
Line 331  const char *__roff_name[MAN_MAX + 1] = {
Line 349  const char *__roff_name[MAN_MAX + 1] = {
         "nf",           "fi",          "nf",           "fi",
         "RE",           "RS",           "DT",           "UC",          "RE",           "RS",           "DT",           "UC",
         "PD",           "AT",           "in",          "PD",           "AT",           "in",
         "OP",           "EX",           "EE",           "UR",          "SY",           "YS",           "OP",
           "EX",           "EE",           "UR",
         "UE",           "MT",           "ME",           NULL          "UE",           "MT",           "ME",           NULL
 };  };
 const   char *const *roff_name = __roff_name;  const   char *const *roff_name = __roff_name;
Line 488  static struct roffmac  roffs[TOKEN_NONE] = {
Line 507  static struct roffmac  roffs[TOKEN_NONE] = {
         { roff_line_ignore, NULL, NULL, 0 },  /* nhychar */          { roff_line_ignore, NULL, NULL, 0 },  /* nhychar */
         { roff_unsupp, NULL, NULL, 0 },  /* nm */          { roff_unsupp, NULL, NULL, 0 },  /* nm */
         { roff_unsupp, NULL, NULL, 0 },  /* nn */          { roff_unsupp, NULL, NULL, 0 },  /* nn */
         { roff_unsupp, NULL, NULL, 0 },  /* nop */          { roff_nop, NULL, NULL, 0 },  /* nop */
         { roff_nr, NULL, NULL, 0 },  /* nr */          { roff_nr, NULL, NULL, 0 },  /* nr */
         { roff_unsupp, NULL, NULL, 0 },  /* nrf */          { roff_unsupp, NULL, NULL, 0 },  /* nrf */
         { roff_line_ignore, NULL, NULL, 0 },  /* nroff */          { roff_line_ignore, NULL, NULL, 0 },  /* nroff */
Line 517  static struct roffmac  roffs[TOKEN_NONE] = {
Line 536  static struct roffmac  roffs[TOKEN_NONE] = {
         { roff_unsupp, NULL, NULL, 0 },  /* rchar */          { roff_unsupp, NULL, NULL, 0 },  /* rchar */
         { roff_line_ignore, NULL, NULL, 0 },  /* rd */          { roff_line_ignore, NULL, NULL, 0 },  /* rd */
         { roff_line_ignore, NULL, NULL, 0 },  /* recursionlimit */          { roff_line_ignore, NULL, NULL, 0 },  /* recursionlimit */
         { roff_unsupp, NULL, NULL, 0 },  /* return */          { roff_return, NULL, NULL, 0 },  /* return */
         { roff_unsupp, NULL, NULL, 0 },  /* rfschar */          { roff_unsupp, NULL, NULL, 0 },  /* rfschar */
         { roff_line_ignore, NULL, NULL, 0 },  /* rhang */          { roff_line_ignore, NULL, NULL, 0 },  /* rhang */
         { roff_rm, NULL, NULL, 0 },  /* rm */          { roff_rm, NULL, NULL, 0 },  /* rm */
Line 529  static struct roffmac  roffs[TOKEN_NONE] = {
Line 548  static struct roffmac  roffs[TOKEN_NONE] = {
         { roff_unsupp, NULL, NULL, 0 },  /* schar */          { roff_unsupp, NULL, NULL, 0 },  /* schar */
         { roff_line_ignore, NULL, NULL, 0 },  /* sentchar */          { roff_line_ignore, NULL, NULL, 0 },  /* sentchar */
         { roff_line_ignore, NULL, NULL, 0 },  /* shc */          { roff_line_ignore, NULL, NULL, 0 },  /* shc */
         { roff_unsupp, NULL, NULL, 0 },  /* shift */          { roff_shift, NULL, NULL, 0 },  /* shift */
         { roff_line_ignore, NULL, NULL, 0 },  /* sizes */          { roff_line_ignore, NULL, NULL, 0 },  /* sizes */
         { roff_so, NULL, NULL, 0 },  /* so */          { roff_so, NULL, NULL, 0 },  /* so */
         { roff_line_ignore, NULL, NULL, 0 },  /* spacewidth */          { roff_line_ignore, NULL, NULL, 0 },  /* spacewidth */
Line 709  roff_free1(struct roff *r)
Line 728  roff_free1(struct roff *r)
                 eqn_free(r->last_eqn);                  eqn_free(r->last_eqn);
         r->last_eqn = r->eqn = NULL;          r->last_eqn = r->eqn = NULL;
   
           while (r->mstackpos >= 0)
                   roff_userret(r);
   
         while (r->last)          while (r->last)
                 roffnode_pop(r);                  roffnode_pop(r);
   
Line 748  roff_reset(struct roff *r)
Line 770  roff_reset(struct roff *r)
 void  void
 roff_free(struct roff *r)  roff_free(struct roff *r)
 {  {
           int              i;
   
         roff_free1(r);          roff_free1(r);
           for (i = 0; i < r->mstacksz; i++)
                   free(r->mstack[i].argv);
           free(r->mstack);
         roffhash_free(r->reqtab);          roffhash_free(r->reqtab);
         free(r);          free(r);
 }  }
Line 760  roff_alloc(struct mparse *parse, int options)
Line 787  roff_alloc(struct mparse *parse, int options)
   
         r = mandoc_calloc(1, sizeof(struct roff));          r = mandoc_calloc(1, sizeof(struct roff));
         r->parse = parse;          r->parse = parse;
         r->reqtab = roffhash_alloc(0, ROFF_USERDEF);          r->reqtab = roffhash_alloc(0, ROFF_RENAMED);
         r->options = options;          r->options = options;
         r->format = options & (MPARSE_MDOC | MPARSE_MAN);          r->format = options & (MPARSE_MDOC | MPARSE_MAN);
           r->mstackpos = -1;
         r->rstackpos = -1;          r->rstackpos = -1;
         r->escape = '\\';          r->escape = '\\';
         return r;          return r;
Line 1119  deroff(char **dest, const struct roff_node *n)
Line 1147  deroff(char **dest, const struct roff_node *n)
 static enum rofferr  static enum rofferr
 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 */
         char             ubuf[24]; /* buffer to print the number */          char             ubuf[24]; /* buffer to print the number */
           struct roff_node *n;    /* used for header comments */
         const char      *start; /* start of the string to process */          const char      *start; /* start of the string to process */
         char            *stesc; /* start of an escape sequence ('\\') */          char            *stesc; /* start of an escape sequence ('\\') */
           char            *ep;    /* end of comment string */
         const char      *stnam; /* start of the name, after "[(*" */          const char      *stnam; /* start of the name, after "[(*" */
         const char      *cp;    /* end of the name, e.g. before ']' */          const char      *cp;    /* end of the name, e.g. before ']' */
         const char      *res;   /* the string to be substituted */          const char      *res;   /* the string to be substituted */
         char            *nbuf;  /* new buffer to copy buf->buf to */          char            *nbuf;  /* new buffer to copy buf->buf to */
         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 */
           size_t           asz;   /* length of the replacement */
           size_t           rsz;   /* length of the rest of the string */
         enum mandoc_esc  esc;   /* type of the escape sequence */          enum mandoc_esc  esc;   /* type of the escape sequence */
         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 */
         int              arg_complete; /* argument not interrupted by eol */          int              arg_complete; /* argument not interrupted by eol */
           int              quote_args; /* true for \\$@, false for \\$* */
         int              done;  /* no more input available */          int              done;  /* no more input available */
         int              deftype; /* type of definition to paste */          int              deftype; /* type of definition to paste */
         int              rcsid; /* kind of RCS id seen */          int              rcsid; /* kind of RCS id seen */
           char             sign;  /* increment number register */
         char             term;  /* character terminating the escape */          char             term;  /* character terminating the escape */
   
         /* Search forward for comments. */          /* Search forward for comments. */
Line 1170  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1205  roff_res(struct roff *r, struct buf *buf, int ln, int 
   
                 /* Handle trailing whitespace. */                  /* Handle trailing whitespace. */
   
                 cp = strchr(stesc--, '\0') - 1;                  ep = strchr(stesc--, '\0') - 1;
                 if (*cp == '\n') {                  if (*ep == '\n') {
                         done = 1;                          done = 1;
                         cp--;                          ep--;
                 }                  }
                 if (*cp == ' ' || *cp == '\t')                  if (*ep == ' ' || *ep == '\t')
                         mandoc_msg(MANDOCERR_SPACE_EOL, r->parse,                          mandoc_msg(MANDOCERR_SPACE_EOL, r->parse,
                             ln, cp - buf->buf, NULL);                              ln, ep - buf->buf, NULL);
                 while (stesc > start && stesc[-1] == ' ')  
                   /*
                    * Save comments preceding the title macro
                    * in the syntax tree.
                    */
   
                   if (r->format == 0) {
                           while (*ep == ' ' || *ep == '\t')
                                   ep--;
                           ep[1] = '\0';
                           n = roff_node_alloc(r->man,
                               ln, stesc + 1 - buf->buf,
                               ROFFT_COMMENT, TOKEN_NONE);
                           n->string = mandoc_strdup(stesc + 2);
                           roff_node_append(r->man, n);
                           n->flags |= NODE_VALID | NODE_ENDED;
                           r->man->next = ROFF_NEXT_SIBLING;
                   }
   
                   /* Line continuation with comment. */
   
                   if (stesc[1] == '#') {
                           *stesc = '\0';
                           return ROFF_APPEND;
                   }
   
                   /* Discard normal comments. */
   
                   while (stesc > start && stesc[-1] == ' ' &&
                       (stesc == start + 1 || stesc[-2] != '\\'))
                         stesc--;                          stesc--;
                 *stesc = '\0';                  *stesc = '\0';
                 break;                  break;
Line 1239  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1303  roff_res(struct roff *r, struct buf *buf, int ln, int 
                 cp = stesc + 1;                  cp = stesc + 1;
                 switch (*cp) {                  switch (*cp) {
                 case '*':                  case '*':
                   case '$':
                         res = NULL;                          res = NULL;
                         break;                          break;
                 case 'B':                  case 'B':
Line 1246  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1311  roff_res(struct roff *r, struct buf *buf, int ln, int 
                         term = cp[1];                          term = cp[1];
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
                 case 'n':                  case 'n':
                           sign = cp[1];
                           if (sign == '+' || sign == '-')
                                   cp++;
                         res = ubuf;                          res = ubuf;
                         break;                          break;
                 default:                  default:
Line 1337  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1405  roff_res(struct roff *r, struct buf *buf, int ln, int 
                         if (arg_complete) {                          if (arg_complete) {
                                 deftype = ROFFDEF_USER | ROFFDEF_PRE;                                  deftype = ROFFDEF_USER | ROFFDEF_PRE;
                                 res = roff_getstrn(r, stnam, naml, &deftype);                                  res = roff_getstrn(r, stnam, naml, &deftype);
   
                                   /*
                                    * If not overriden, let \*(.T
                                    * through to the formatters.
                                    */
   
                                   if (res == NULL && naml == 2 &&
                                       stnam[0] == '.' && stnam[1] == 'T') {
                                           roff_setstrn(&r->strtab,
                                               ".T", 2, NULL, 0, 0);
                                           stesc--;
                                           continue;
                                   }
                         }                          }
                         break;                          break;
                   case '$':
                           if (r->mstackpos < 0) {
                                   mandoc_vmsg(MANDOCERR_ARG_UNDEF,
                                       r->parse, ln, (int)(stesc - buf->buf),
                                       "%.3s", stesc);
                                   break;
                           }
                           ctx = r->mstack + r->mstackpos;
                           npos = stesc[2] - '1';
                           if (npos >= 0 && npos <= 8) {
                                   res = npos < ctx->argc ?
                                       ctx->argv[npos] : "";
                                   break;
                           }
                           if (stesc[2] == '*')
                                   quote_args = 0;
                           else if (stesc[2] == '@')
                                   quote_args = 1;
                           else {
                                   mandoc_vmsg(MANDOCERR_ARG_NONUM,
                                       r->parse, ln, (int)(stesc - buf->buf),
                                       "%.3s", stesc);
                                   break;
                           }
                           asz = 0;
                           for (npos = 0; npos < ctx->argc; npos++) {
                                   if (npos)
                                           asz++;  /* blank */
                                   if (quote_args)
                                           asz += 2;  /* quotes */
                                   asz += strlen(ctx->argv[npos]);
                           }
                           if (asz != 3) {
                                   rsz = buf->sz - (stesc - buf->buf) - 3;
                                   if (asz < 3)
                                           memmove(stesc + asz, stesc + 3, rsz);
                                   buf->sz += asz - 3;
                                   nbuf = mandoc_realloc(buf->buf, buf->sz);
                                   start = nbuf + pos;
                                   stesc = nbuf + (stesc - buf->buf);
                                   buf->buf = nbuf;
                                   if (asz > 3)
                                           memmove(stesc + asz, stesc + 3, rsz);
                           }
                           for (npos = 0; npos < ctx->argc; npos++) {
                                   if (npos)
                                           *stesc++ = ' ';
                                   if (quote_args)
                                           *stesc++ = '"';
                                   cp = ctx->argv[npos];
                                   while (*cp != '\0')
                                           *stesc++ = *cp++;
                                   if (quote_args)
                                           *stesc++ = '"';
                           }
                           continue;
                 case 'B':                  case 'B':
                         npos = 0;                          npos = 0;
                         ubuf[0] = arg_complete &&                          ubuf[0] = arg_complete &&
Line 1350  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1487  roff_res(struct roff *r, struct buf *buf, int ln, int 
                 case 'n':                  case 'n':
                         if (arg_complete)                          if (arg_complete)
                                 (void)snprintf(ubuf, sizeof(ubuf), "%d",                                  (void)snprintf(ubuf, sizeof(ubuf), "%d",
                                     roff_getregn(r, stnam, naml));                                      roff_getregn(r, stnam, naml, sign));
                         else                          else
                                 ubuf[0] = '\0';                                  ubuf[0] = '\0';
                         break;                          break;
Line 1362  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1499  roff_res(struct roff *r, struct buf *buf, int ln, int 
                 }                  }
   
                 if (res == NULL) {                  if (res == NULL) {
                         mandoc_vmsg(MANDOCERR_STR_UNDEF,                          if (stesc[1] == '*')
                             r->parse, ln, (int)(stesc - buf->buf),                                  mandoc_vmsg(MANDOCERR_STR_UNDEF,
                             "%.*s", (int)naml, stnam);                                      r->parse, ln, (int)(stesc - buf->buf),
                                       "%.*s", (int)naml, stnam);
                         res = "";                          res = "";
                 } else if (buf->sz + strlen(res) > SHRT_MAX) {                  } else if (buf->sz + strlen(res) > SHRT_MAX) {
                         mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,                          mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,
Line 1582  roff_parseln(struct roff *r, int ln, struct buf *buf, 
Line 1720  roff_parseln(struct roff *r, int ln, struct buf *buf, 
         return (*roffs[t].proc)(r, t, buf, ln, spos, pos, offs);          return (*roffs[t].proc)(r, t, buf, ln, spos, pos, offs);
 }  }
   
   /*
    * Internal interface function to tell the roff parser that execution
    * of the current macro ended.  This is required because macro
    * definitions usually do not end with a .return request.
    */
 void  void
   roff_userret(struct roff *r)
   {
           struct mctx     *ctx;
           int              i;
   
           assert(r->mstackpos >= 0);
           ctx = r->mstack + r->mstackpos;
           for (i = 0; i < ctx->argc; i++)
                   free(ctx->argv[i]);
           ctx->argc = 0;
           r->mstackpos--;
   }
   
   void
 roff_endparse(struct roff *r)  roff_endparse(struct roff *r)
 {  {
         if (r->last != NULL)          if (r->last != NULL)
Line 2115  out:
Line 2272  out:
 static int  static int
 roff_evalcond(struct roff *r, int ln, char *v, int *pos)  roff_evalcond(struct roff *r, int ln, char *v, int *pos)
 {  {
         char    *cp, *name;          const char      *start, *end;
         size_t   sz;          char            *cp, *name;
         int      deftype, number, savepos, istrue, wanttrue;          size_t           sz;
           int              deftype, len, number, savepos, istrue, wanttrue;
   
         if ('!' == v[*pos]) {          if ('!' == v[*pos]) {
                 wanttrue = 0;                  wanttrue = 0;
Line 2132  roff_evalcond(struct roff *r, int ln, char *v, int *po
Line 2290  roff_evalcond(struct roff *r, int ln, char *v, int *po
         case 'o':          case 'o':
                 (*pos)++;                  (*pos)++;
                 return wanttrue;                  return wanttrue;
         case 'c':  
         case 'e':          case 'e':
         case 't':          case 't':
         case 'v':          case 'v':
                 (*pos)++;                  (*pos)++;
                 return !wanttrue;                  return !wanttrue;
           case 'c':
                   do {
                           (*pos)++;
                   } while (v[*pos] == ' ');
   
                   /*
                    * Quirk for groff compatibility:
                    * The horizontal tab is neither available nor unavailable.
                    */
   
                   if (v[*pos] == '\t') {
                           (*pos)++;
                           return 0;
                   }
   
                   /* Printable ASCII characters are available. */
   
                   if (v[*pos] != '\\') {
                           (*pos)++;
                           return wanttrue;
                   }
   
                   end = v + ++*pos;
                   switch (mandoc_escape(&end, &start, &len)) {
                   case ESCAPE_SPECIAL:
                           istrue = mchars_spec2cp(start, len) != -1;
                           break;
                   case ESCAPE_UNICODE:
                           istrue = 1;
                           break;
                   case ESCAPE_NUMBERED:
                           istrue = mchars_num2char(start, len) != -1;
                           break;
                   default:
                           istrue = !wanttrue;
                           break;
                   }
                   *pos = end - v;
                   return istrue == wanttrue;
         case 'd':          case 'd':
         case 'r':          case 'r':
                 cp = v + *pos + 1;                  cp = v + *pos + 1;
Line 2522  roff_evalnum(struct roff *r, int ln, const char *v,
Line 2718  roff_evalnum(struct roff *r, int ln, const char *v,
 void  void
 roff_setreg(struct roff *r, const char *name, int val, char sign)  roff_setreg(struct roff *r, const char *name, int val, char sign)
 {  {
         roff_setregn(r, name, strlen(name), val, sign);          roff_setregn(r, name, strlen(name), val, sign, INT_MIN);
 }  }
   
 static void  static void
 roff_setregn(struct roff *r, const char *name, size_t len,  roff_setregn(struct roff *r, const char *name, size_t len,
     int val, char sign)      int val, char sign, int step)
 {  {
         struct roffreg  *reg;          struct roffreg  *reg;
   
Line 2544  roff_setregn(struct roff *r, const char *name, size_t 
Line 2740  roff_setregn(struct roff *r, const char *name, size_t 
                 reg->key.p = mandoc_strndup(name, len);                  reg->key.p = mandoc_strndup(name, len);
                 reg->key.sz = len;                  reg->key.sz = len;
                 reg->val = 0;                  reg->val = 0;
                   reg->step = 0;
                 reg->next = r->regtab;                  reg->next = r->regtab;
                 r->regtab = reg;                  r->regtab = reg;
         }          }
Line 2554  roff_setregn(struct roff *r, const char *name, size_t 
Line 2751  roff_setregn(struct roff *r, const char *name, size_t 
                 reg->val -= val;                  reg->val -= val;
         else          else
                 reg->val = val;                  reg->val = val;
           if (step != INT_MIN)
                   reg->step = step;
 }  }
   
 /*  /*
Line 2568  roff_getregro(const struct roff *r, const char *name)
Line 2767  roff_getregro(const struct roff *r, const char *name)
   
         switch (*name) {          switch (*name) {
         case '$':  /* Number of arguments of the last macro evaluated. */          case '$':  /* Number of arguments of the last macro evaluated. */
                 return r->argc;                  return r->mstackpos < 0 ? 0 : r->mstack[r->mstackpos].argc;
         case 'A':  /* ASCII approximation mode is always off. */          case 'A':  /* ASCII approximation mode is always off. */
                 return 0;                  return 0;
         case 'g':  /* Groff compatibility mode is always on. */          case 'g':  /* Groff compatibility mode is always on. */
Line 2589  roff_getregro(const struct roff *r, const char *name)
Line 2788  roff_getregro(const struct roff *r, const char *name)
 int  int
 roff_getreg(struct roff *r, const char *name)  roff_getreg(struct roff *r, const char *name)
 {  {
         return roff_getregn(r, name, strlen(name));          return roff_getregn(r, name, strlen(name), '\0');
 }  }
   
 static int  static int
 roff_getregn(struct roff *r, const char *name, size_t len)  roff_getregn(struct roff *r, const char *name, size_t len, char sign)
 {  {
         struct roffreg  *reg;          struct roffreg  *reg;
         int              val;          int              val;
Line 2604  roff_getregn(struct roff *r, const char *name, size_t 
Line 2803  roff_getregn(struct roff *r, const char *name, size_t 
                         return val;                          return val;
         }          }
   
         for (reg = r->regtab; reg; reg = reg->next)          for (reg = r->regtab; reg; reg = reg->next) {
                 if (len == reg->key.sz &&                  if (len == reg->key.sz &&
                     0 == strncmp(name, reg->key.p, len))                      0 == strncmp(name, reg->key.p, len)) {
                           switch (sign) {
                           case '+':
                                   reg->val += reg->step;
                                   break;
                           case '-':
                                   reg->val -= reg->step;
                                   break;
                           default:
                                   break;
                           }
                         return reg->val;                          return reg->val;
                   }
           }
   
         roff_setregn(r, name, len, 0, '\0');          roff_setregn(r, name, len, 0, '\0', INT_MIN);
         return 0;          return 0;
 }  }
   
Line 2649  roff_freereg(struct roffreg *reg)
Line 2860  roff_freereg(struct roffreg *reg)
 static enum rofferr  static enum rofferr
 roff_nr(ROFF_ARGS)  roff_nr(ROFF_ARGS)
 {  {
         char            *key, *val;          char            *key, *val, *step;
         size_t           keysz;          size_t           keysz;
         int              iv;          int              iv, is, len;
         char             sign;          char             sign;
   
         key = val = buf->buf + pos;          key = val = buf->buf + pos;
Line 2666  roff_nr(ROFF_ARGS)
Line 2877  roff_nr(ROFF_ARGS)
         if (sign == '+' || sign == '-')          if (sign == '+' || sign == '-')
                 val++;                  val++;
   
         if (roff_evalnum(r, ln, val, NULL, &iv, ROFFNUM_SCALE))          len = 0;
                 roff_setregn(r, key, keysz, iv, sign);          if (roff_evalnum(r, ln, val, &len, &iv, ROFFNUM_SCALE) == 0)
                   return ROFF_IGN;
   
           step = val + len;
           while (isspace((unsigned char)*step))
                   step++;
           if (roff_evalnum(r, ln, step, NULL, &is, 0) == 0)
                   is = INT_MIN;
   
           roff_setregn(r, key, keysz, iv, sign, is);
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
Line 2793  roff_TE(ROFF_ARGS)
Line 3012  roff_TE(ROFF_ARGS)
                 free(buf->buf);                  free(buf->buf);
                 buf->buf = mandoc_strdup(".sp");                  buf->buf = mandoc_strdup(".sp");
                 buf->sz = 4;                  buf->sz = 4;
                   *offs = 0;
                 return ROFF_REPARSE;                  return ROFF_REPARSE;
         }          }
         r->tbl = NULL;          r->tbl = NULL;
Line 3041  roff_als(ROFF_ARGS)
Line 3261  roff_als(ROFF_ARGS)
         if (oldsz == 0)          if (oldsz == 0)
                 return ROFF_IGN;                  return ROFF_IGN;
   
         valsz = mandoc_asprintf(&value, ".%.*s \\$*\\\"\n",          valsz = mandoc_asprintf(&value, ".%.*s \\$@\\\"\n",
             (int)oldsz, oldn);              (int)oldsz, oldn);
         roff_setstrn(&r->strtab, newn, newsz, value, valsz, 0);          roff_setstrn(&r->strtab, newn, newsz, value, valsz, 0);
         roff_setstrn(&r->rentab, newn, newsz, NULL, 0, 0);          roff_setstrn(&r->rentab, newn, newsz, NULL, 0, 0);
Line 3108  roff_eo(ROFF_ARGS)
Line 3328  roff_eo(ROFF_ARGS)
 }  }
   
 static enum rofferr  static enum rofferr
   roff_nop(ROFF_ARGS)
   {
           while (buf->buf[pos] == ' ')
                   pos++;
           *offs = pos;
           return ROFF_RERUN;
   }
   
   static enum rofferr
 roff_tr(ROFF_ARGS)  roff_tr(ROFF_ARGS)
 {  {
         const char      *p, *first, *second;          const char      *p, *first, *second;
Line 3169  roff_tr(ROFF_ARGS)
Line 3398  roff_tr(ROFF_ARGS)
         return ROFF_IGN;          return ROFF_IGN;
 }  }
   
   /*
    * Implementation of the .return request.
    * There is no need to call roff_userret() from here.
    * The read module will call that after rewinding the reader stack
    * to the place from where the current macro was called.
    */
 static enum rofferr  static enum rofferr
   roff_return(ROFF_ARGS)
   {
           if (r->mstackpos >= 0)
                   return ROFF_USERRET;
   
           mandoc_msg(MANDOCERR_REQ_NOMAC, r->parse, ln, ppos, "return");
           return ROFF_IGN;
   }
   
   static enum rofferr
 roff_rn(ROFF_ARGS)  roff_rn(ROFF_ARGS)
 {  {
         const char      *value;          const char      *value;
Line 3220  roff_rn(ROFF_ARGS)
Line 3465  roff_rn(ROFF_ARGS)
 }  }
   
 static enum rofferr  static enum rofferr
   roff_shift(ROFF_ARGS)
   {
           struct mctx     *ctx;
           int              levels, i;
   
           levels = 1;
           if (buf->buf[pos] != '\0' &&
               roff_evalnum(r, ln, buf->buf, &pos, &levels, 0) == 0) {
                   mandoc_vmsg(MANDOCERR_CE_NONUM, r->parse,
                       ln, pos, "shift %s", buf->buf + pos);
                   levels = 1;
           }
           if (r->mstackpos < 0) {
                   mandoc_msg(MANDOCERR_REQ_NOMAC, r->parse, ln, ppos, "shift");
                   return ROFF_IGN;
           }
           ctx = r->mstack + r->mstackpos;
           if (levels > ctx->argc) {
                   mandoc_vmsg(MANDOCERR_SHIFT, r->parse,
                       ln, pos, "%d, but max is %d", levels, ctx->argc);
                   levels = ctx->argc;
           }
           if (levels == 0)
                   return ROFF_IGN;
           for (i = 0; i < levels; i++)
                   free(ctx->argv[i]);
           ctx->argc -= levels;
           for (i = 0; i < ctx->argc; i++)
                   ctx->argv[i] = ctx->argv[i + levels];
           return ROFF_IGN;
   }
   
   static enum rofferr
 roff_so(ROFF_ARGS)  roff_so(ROFF_ARGS)
 {  {
         char *name, *cp;          char *name, *cp;
Line 3254  roff_so(ROFF_ARGS)
Line 3532  roff_so(ROFF_ARGS)
 static enum rofferr  static enum rofferr
 roff_userdef(ROFF_ARGS)  roff_userdef(ROFF_ARGS)
 {  {
         const char       *arg[16], *ap;          struct mctx      *ctx;
         char             *cp, *n1, *n2;          char             *arg, *ap, *dst, *src;
         int               expand_count, i, ib, ie;          size_t            sz;
         size_t            asz, rsz;  
   
         /*          /* Initialize a new macro stack context. */
          * Collect pointers to macro argument strings  
          * and NUL-terminate them.  
          */  
   
         r->argc = 0;          if (++r->mstackpos == r->mstacksz) {
         cp = buf->buf + pos;                  r->mstack = mandoc_recallocarray(r->mstack,
         for (i = 0; i < 16; i++) {                      r->mstacksz, r->mstacksz + 8, sizeof(*r->mstack));
                 if (*cp == '\0')                  r->mstacksz += 8;
                         arg[i] = "";  
                 else {  
                         arg[i] = mandoc_getarg(r->parse, &cp, ln, &pos);  
                         r->argc = i + 1;  
                 }  
         }          }
           ctx = r->mstack + r->mstackpos;
           ctx->argsz = 0;
           ctx->argc = 0;
           ctx->argv = NULL;
   
         /*          /*
          * Expand macro arguments.           * Collect pointers to macro argument strings,
            * NUL-terminating them and escaping quotes.
          */           */
   
         buf->sz = strlen(r->current_string) + 1;          src = buf->buf + pos;
         n1 = n2 = cp = mandoc_malloc(buf->sz);          while (*src != '\0') {
         memcpy(n1, r->current_string, buf->sz);                  if (ctx->argc == ctx->argsz) {
         expand_count = 0;                          ctx->argsz += 8;
         while (*cp != '\0') {                          ctx->argv = mandoc_reallocarray(ctx->argv,
                               ctx->argsz, sizeof(*ctx->argv));
                 /* Scan ahead for the next argument invocation. */  
   
                 if (*cp++ != '\\')  
                         continue;  
                 if (*cp++ != '$')  
                         continue;  
                 if (*cp == '*') {  /* \\$* inserts all arguments */  
                         ib = 0;  
                         ie = r->argc - 1;  
                 } else {  /* \\$1 .. \\$9 insert one argument */  
                         ib = ie = *cp - '1';  
                         if (ib < 0 || ib > 8)  
                                 continue;  
                 }                  }
                 cp -= 2;                  arg = mandoc_getarg(r->parse, &src, ln, &pos);
                   sz = 1;  /* For the terminating NUL. */
                 /*                  for (ap = arg; *ap != '\0'; ap++)
                  * Prevent infinite recursion.                          sz += *ap == '"' ? 4 : 1;
                  */                  ctx->argv[ctx->argc++] = dst = mandoc_malloc(sz);
                   for (ap = arg; *ap != '\0'; ap++) {
                 if (cp >= n2)                          if (*ap == '"') {
                         expand_count = 1;                                  memcpy(dst, "\\(dq", 4);
                 else if (++expand_count > EXPAND_LIMIT) {                                  dst += 4;
                         mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,                          } else
                             ln, (int)(cp - n1), NULL);                                  *dst++ = *ap;
                         free(buf->buf);  
                         buf->buf = n1;  
                         return ROFF_IGN;  
                 }                  }
                   *dst = '\0';
                 /*  
                  * Determine the size of the expanded argument,  
                  * taking escaping of quotes into account.  
                  */  
   
                 asz = ie > ib ? ie - ib : 0;  /* for blanks */  
                 for (i = ib; i <= ie; i++) {  
                         for (ap = arg[i]; *ap != '\0'; ap++) {  
                                 asz++;  
                                 if (*ap == '"')  
                                         asz += 3;  
                         }  
                 }  
                 if (asz != 3) {  
   
                         /*  
                          * Determine the size of the rest of the  
                          * unexpanded macro, including the NUL.  
                          */  
   
                         rsz = buf->sz - (cp - n1) - 3;  
   
                         /*  
                          * When shrinking, move before  
                          * releasing the storage.  
                          */  
   
                         if (asz < 3)  
                                 memmove(cp + asz, cp + 3, rsz);  
   
                         /*  
                          * Resize the storage for the macro  
                          * and readjust the parse pointer.  
                          */  
   
                         buf->sz += asz - 3;  
                         n2 = mandoc_realloc(n1, buf->sz);  
                         cp = n2 + (cp - n1);  
                         n1 = n2;  
   
                         /*  
                          * When growing, make room  
                          * for the expanded argument.  
                          */  
   
                         if (asz > 3)  
                                 memmove(cp + asz, cp + 3, rsz);  
                 }  
   
                 /* Copy the expanded argument, escaping quotes. */  
   
                 n2 = cp;  
                 for (i = ib; i <= ie; i++) {  
                         for (ap = arg[i]; *ap != '\0'; ap++) {  
                                 if (*ap == '"') {  
                                         memcpy(n2, "\\(dq", 4);  
                                         n2 += 4;  
                                 } else  
                                         *n2++ = *ap;  
                         }  
                         if (i < ie)  
                                 *n2++ = ' ';  
                 }  
         }          }
   
         /*          /* Replace the macro invocation by the macro definition. */
          * Replace the macro invocation  
          * by the expanded macro.  
          */  
   
         free(buf->buf);          free(buf->buf);
         buf->buf = n1;          buf->buf = mandoc_strdup(r->current_string);
           buf->sz = strlen(buf->buf) + 1;
         *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_REPARSE : ROFF_APPEND;             ROFF_USERCALL : ROFF_APPEND;
 }  }
   
 /*  /*
Line 3406  roff_renamed(ROFF_ARGS)
Line 3599  roff_renamed(ROFF_ARGS)
             buf->buf[pos] == '\0' ? "" : " ", buf->buf + pos) + 1;              buf->buf[pos] == '\0' ? "" : " ", buf->buf + pos) + 1;
         free(buf->buf);          free(buf->buf);
         buf->buf = nbuf;          buf->buf = nbuf;
           *offs = 0;
         return ROFF_CONT;          return ROFF_CONT;
 }  }
   
Legend:
Removed from v.1.326  
changed lines
  Added in v.1.339
CVSweb