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

Diff for /mandoc/roff.c between version 1.353 and 1.356

version 1.353, 2018/12/18 22:00:02 version 1.356, 2018/12/30 00:49:56
Line 38 
Line 38 
 #include "tbl_parse.h"  #include "tbl_parse.h"
 #include "eqn_parse.h"  #include "eqn_parse.h"
   
   /*
    * ASCII_ESC is used to signal from roff_getarg() to roff_expand()
    * that an escape sequence resulted from copy-in processing and
    * needs to be checked or interpolated.  As it is used nowhere
    * else, it is defined here rather than in a header file.
    */
   #define ASCII_ESC       27
   
 /* Maximum number of string expansions per line, to break infinite loops. */  /* Maximum number of string expansions per line, to break infinite loops. */
 #define EXPAND_LIMIT    1000  #define EXPAND_LIMIT    1000
   
Line 191  static int   roff_evalnum(struct roff *, int,
Line 199  static int   roff_evalnum(struct roff *, int,
 static  int              roff_evalpar(struct roff *, int,  static  int              roff_evalpar(struct roff *, int,
                                 const char *, int *, int *, int);                                  const char *, int *, int *, int);
 static  int              roff_evalstrcond(const char *, int *);  static  int              roff_evalstrcond(const char *, int *);
   static  int              roff_expand(struct roff *, struct buf *,
                                   int, int, char);
 static  void             roff_free1(struct roff *);  static  void             roff_free1(struct roff *);
 static  void             roff_freereg(struct roffreg *);  static  void             roff_freereg(struct roffreg *);
 static  void             roff_freestr(struct roffkv *);  static  void             roff_freestr(struct roffkv *);
Line 219  static enum roff_tok  roff_parse(struct roff *, char *
Line 229  static enum roff_tok  roff_parse(struct roff *, char *
 static  int              roff_parsetext(struct roff *, struct buf *,  static  int              roff_parsetext(struct roff *, struct buf *,
                                 int, int *);                                  int, int *);
 static  int              roff_renamed(ROFF_ARGS);  static  int              roff_renamed(ROFF_ARGS);
 static  int              roff_res(struct roff *, struct buf *, int, int);  
 static  int              roff_return(ROFF_ARGS);  static  int              roff_return(ROFF_ARGS);
 static  int              roff_rm(ROFF_ARGS);  static  int              roff_rm(ROFF_ARGS);
 static  int              roff_rn(ROFF_ARGS);  static  int              roff_rn(ROFF_ARGS);
Line 798  roff_alloc(int options)
Line 807  roff_alloc(int options)
 static void  static void
 roff_man_free1(struct roff_man *man)  roff_man_free1(struct roff_man *man)
 {  {
           if (man->meta.first != NULL)
         if (man->first != NULL)                  roff_node_delete(man, man->meta.first);
                 roff_node_delete(man, man->first);  
         free(man->meta.msec);          free(man->meta.msec);
         free(man->meta.vol);          free(man->meta.vol);
         free(man->meta.os);          free(man->meta.os);
Line 808  roff_man_free1(struct roff_man *man)
Line 816  roff_man_free1(struct roff_man *man)
         free(man->meta.title);          free(man->meta.title);
         free(man->meta.name);          free(man->meta.name);
         free(man->meta.date);          free(man->meta.date);
           free(man->meta.sodest);
 }  }
   
 static void  static void
 roff_man_alloc1(struct roff_man *man)  roff_man_alloc1(struct roff_man *man)
 {  {
   
         memset(&man->meta, 0, sizeof(man->meta));          memset(&man->meta, 0, sizeof(man->meta));
         man->first = mandoc_calloc(1, sizeof(*man->first));          man->meta.first = mandoc_calloc(1, sizeof(*man->meta.first));
         man->first->type = ROFFT_ROOT;          man->meta.first->type = ROFFT_ROOT;
         man->last = man->first;          man->last = man->meta.first;
         man->last_es = NULL;          man->last_es = NULL;
         man->flags = 0;          man->flags = 0;
         man->macroset = MACROSET_NONE;          man->meta.macroset = MACROSET_NONE;
         man->lastsec = man->lastnamed = SEC_NONE;          man->lastsec = man->lastnamed = SEC_NONE;
         man->next = ROFF_NEXT_CHILD;          man->next = ROFF_NEXT_CHILD;
 }  }
Line 828  roff_man_alloc1(struct roff_man *man)
Line 836  roff_man_alloc1(struct roff_man *man)
 void  void
 roff_man_reset(struct roff_man *man)  roff_man_reset(struct roff_man *man)
 {  {
   
         roff_man_free1(man);          roff_man_free1(man);
         roff_man_alloc1(man);          roff_man_alloc1(man);
 }  }
Line 836  roff_man_reset(struct roff_man *man)
Line 843  roff_man_reset(struct roff_man *man)
 void  void
 roff_man_free(struct roff_man *man)  roff_man_free(struct roff_man *man)
 {  {
   
         roff_man_free1(man);          roff_man_free1(man);
         free(man);          free(man);
 }  }
Line 1011  roff_addtbl(struct roff_man *man, int line, struct tbl
Line 1017  roff_addtbl(struct roff_man *man, int line, struct tbl
         struct roff_node        *n;          struct roff_node        *n;
         struct tbl_span         *span;          struct tbl_span         *span;
   
         if (man->macroset == MACROSET_MAN)          if (man->meta.macroset == MACROSET_MAN)
                 man_breakscope(man, ROFF_TS);                  man_breakscope(man, ROFF_TS);
         while ((span = tbl_span(tbl)) != NULL) {          while ((span = tbl_span(tbl)) != NULL) {
                 n = roff_node_alloc(man, line, 0, ROFFT_TBL, TOKEN_NONE);                  n = roff_node_alloc(man, line, 0, ROFFT_TBL, TOKEN_NONE);
Line 1055  roff_node_unlink(struct roff_man *man, struct roff_nod
Line 1061  roff_node_unlink(struct roff_man *man, struct roff_nod
                         man->next = ROFF_NEXT_SIBLING;                          man->next = ROFF_NEXT_SIBLING;
                 }                  }
         }          }
         if (man->first == n)          if (man->meta.first == n)
                 man->first = NULL;                  man->meta.first = NULL;
 }  }
   
 void  void
Line 1142  deroff(char **dest, const struct roff_node *n)
Line 1148  deroff(char **dest, const struct roff_node *n)
 /* --- main functions of the roff parser ---------------------------------- */  /* --- main functions of the roff parser ---------------------------------- */
   
 /*  /*
  * In the current line, expand escape sequences that tend to get   * In the current line, expand escape sequences that produce parsable
  * used in numerical expressions and conditional requests.   * input text.  Also check the syntax of the remaining escape sequences,
  * Also check the syntax of the remaining escape sequences.   * which typically produce output glyphs or change formatter state.
  */   */
 static int  static int
 roff_res(struct roff *r, struct buf *buf, int ln, int pos)  roff_expand(struct roff *r, struct buf *buf, int ln, int pos, char newesc)
 {  {
         struct mctx     *ctx;   /* current macro call context */          struct mctx     *ctx;   /* current macro call context */
         char             ubuf[24]; /* buffer to print the number */          char             ubuf[24]; /* buffer to print the number */
Line 1181  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1187  roff_res(struct roff *r, struct buf *buf, int ln, int 
         done = 0;          done = 0;
         start = buf->buf + pos;          start = buf->buf + pos;
         for (stesc = buf->buf + pos; *stesc != '\0'; stesc++) {          for (stesc = buf->buf + pos; *stesc != '\0'; stesc++) {
                 if (stesc[0] != r->escape || stesc[1] == '\0')                  if (stesc[0] != newesc || stesc[1] == '\0')
                         continue;                          continue;
                 stesc++;                  stesc++;
                 if (*stesc != '"' && *stesc != '#')                  if (*stesc != '"' && *stesc != '#')
Line 1223  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1229  roff_res(struct roff *r, struct buf *buf, int ln, int 
                  * in the syntax tree.                   * in the syntax tree.
                  */                   */
   
                 if (r->format == 0) {                  if (newesc != ASCII_ESC && r->format == 0) {
                         while (*ep == ' ' || *ep == '\t')                          while (*ep == ' ' || *ep == '\t')
                                 ep--;                                  ep--;
                         ep[1] = '\0';                          ep[1] = '\0';
Line 1264  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1270  roff_res(struct roff *r, struct buf *buf, int ln, int 
   
         expand_count = 0;          expand_count = 0;
         while (stesc >= start) {          while (stesc >= start) {
                   if (*stesc != newesc) {
   
                 /* Search backwards for the next backslash. */                          /*
                            * If we have a non-standard escape character,
                            * escape literal backslashes because all
                            * processing in subsequent functions uses
                            * the standard escaping rules.
                            */
   
                 if (*stesc != r->escape) {                          if (newesc != ASCII_ESC && *stesc == '\\') {
                         if (*stesc == '\\') {  
                                 *stesc = '\0';                                  *stesc = '\0';
                                 buf->sz = mandoc_asprintf(&nbuf, "%s\\e%s",                                  buf->sz = mandoc_asprintf(&nbuf, "%s\\e%s",
                                     buf->buf, stesc + 1) + 1;                                      buf->buf, stesc + 1) + 1;
Line 1277  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1288  roff_res(struct roff *r, struct buf *buf, int ln, int 
                                 free(buf->buf);                                  free(buf->buf);
                                 buf->buf = nbuf;                                  buf->buf = nbuf;
                         }                          }
   
                           /* Search backwards for the next escape. */
   
                         stesc--;                          stesc--;
                         continue;                          continue;
                 }                  }
Line 1556  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1570  roff_res(struct roff *r, struct buf *buf, int ln, int 
  * or to the NUL byte terminating the argument line.   * or to the NUL byte terminating the argument line.
  */   */
 char *  char *
 mandoc_getarg(char **cpp, int ln, int *pos)  roff_getarg(struct roff *r, char **cpp, int ln, int *pos)
 {  {
         char     *start, *cp;          struct buf       buf;
         int       quoted, pairs, white;          char            *cp, *start;
           int              newesc, pairs, quoted, white;
   
         /* Quoting can only start with a new word. */          /* Quoting can only start with a new word. */
         start = *cpp;          start = *cpp;
Line 1569  mandoc_getarg(char **cpp, int ln, int *pos)
Line 1584  mandoc_getarg(char **cpp, int ln, int *pos)
                 start++;                  start++;
         }          }
   
         pairs = 0;          newesc = pairs = white = 0;
         white = 0;  
         for (cp = start; '\0' != *cp; cp++) {          for (cp = start; '\0' != *cp; cp++) {
   
                 /*                  /*
Line 1588  mandoc_getarg(char **cpp, int ln, int *pos)
Line 1602  mandoc_getarg(char **cpp, int ln, int *pos)
                         switch (cp[1]) {                          switch (cp[1]) {
                         case 'a':                          case 'a':
                         case 't':                          case 't':
                                 cp[0] = '\t';                                  cp[-pairs] = '\t';
                                 /* FALLTHROUGH */                                  pairs++;
                                   cp++;
                                   break;
                         case '\\':                          case '\\':
                                   newesc = 1;
                                   cp[-pairs] = ASCII_ESC;
                                 pairs++;                                  pairs++;
                                 cp++;                                  cp++;
                                 break;                                  break;
Line 1639  mandoc_getarg(char **cpp, int ln, int *pos)
Line 1657  mandoc_getarg(char **cpp, int ln, int *pos)
         if ('\0' == *cp && (white || ' ' == cp[-1]))          if ('\0' == *cp && (white || ' ' == cp[-1]))
                 mandoc_msg(MANDOCERR_SPACE_EOL, ln, *pos, NULL);                  mandoc_msg(MANDOCERR_SPACE_EOL, ln, *pos, NULL);
   
         return start;          start = mandoc_strdup(start);
           if (newesc == 0)
                   return start;
   
           buf.buf = start;
           buf.sz = strlen(start) + 1;
           buf.next = NULL;
           if (roff_expand(r, &buf, ln, 0, ASCII_ESC) & ROFF_IGN) {
                   free(buf.buf);
                   buf.buf = mandoc_strdup("");
           }
           return buf.buf;
 }  }
   
   
Line 1737  roff_parseln(struct roff *r, int ln, struct buf *buf, 
Line 1766  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_expand(r, buf, ln, pos, r->escape);
         if ((e & ROFF_MASK) == ROFF_IGN)          if ((e & ROFF_MASK) == ROFF_IGN)
                 return e;                  return e;
         assert(e == ROFF_CONT);          assert(e == ROFF_CONT);
Line 3249  roff_EQ(ROFF_ARGS)
Line 3278  roff_EQ(ROFF_ARGS)
 {  {
         struct roff_node        *n;          struct roff_node        *n;
   
         if (r->man->macroset == MACROSET_MAN)          if (r->man->meta.macroset == MACROSET_MAN)
                 man_breakscope(r->man, ROFF_EQ);                  man_breakscope(r->man, ROFF_EQ);
         n = roff_node_alloc(r->man, ln, ppos, ROFFT_EQN, TOKEN_NONE);          n = roff_node_alloc(r->man, ln, ppos, ROFFT_EQN, TOKEN_NONE);
         if (ln > r->man->last->line)          if (ln > r->man->last->line)
Line 3771  roff_userdef(ROFF_ARGS)
Line 3800  roff_userdef(ROFF_ARGS)
                         ctx->argv = mandoc_reallocarray(ctx->argv,                          ctx->argv = mandoc_reallocarray(ctx->argv,
                             ctx->argsz, sizeof(*ctx->argv));                              ctx->argsz, sizeof(*ctx->argv));
                 }                  }
                 arg = mandoc_getarg(&src, ln, &pos);                  arg = roff_getarg(r, &src, ln, &pos);
                 sz = 1;  /* For the terminating NUL. */                  sz = 1;  /* For the terminating NUL. */
                 for (ap = arg; *ap != '\0'; ap++)                  for (ap = arg; *ap != '\0'; ap++)
                         sz += *ap == '"' ? 4 : 1;                          sz += *ap == '"' ? 4 : 1;
Line 3784  roff_userdef(ROFF_ARGS)
Line 3813  roff_userdef(ROFF_ARGS)
                                 *dst++ = *ap;                                  *dst++ = *ap;
                 }                  }
                 *dst = '\0';                  *dst = '\0';
                   free(arg);
         }          }
   
         /* Replace the macro invocation by the macro definition. */          /* Replace the macro invocation by the macro definition. */
Line 3988  roff_getstrn(struct roff *r, const char *name, size_t 
Line 4018  roff_getstrn(struct roff *r, const char *name, size_t 
                         break;                          break;
                 }                  }
         }          }
         if (r->man->macroset != MACROSET_MAN) {          if (r->man->meta.macroset != MACROSET_MAN) {
                 for (tok = MDOC_Dd; tok < MDOC_MAX; tok++) {                  for (tok = MDOC_Dd; tok < MDOC_MAX; tok++) {
                         if (strncmp(name, roff_name[tok], len) != 0 ||                          if (strncmp(name, roff_name[tok], len) != 0 ||
                             roff_name[tok][len] != '\0')                              roff_name[tok][len] != '\0')
Line 4002  roff_getstrn(struct roff *r, const char *name, size_t 
Line 4032  roff_getstrn(struct roff *r, const char *name, size_t 
                         }                          }
                 }                  }
         }          }
         if (r->man->macroset != MACROSET_MDOC) {          if (r->man->meta.macroset != MACROSET_MDOC) {
                 for (tok = MAN_TH; tok < MAN_MAX; tok++) {                  for (tok = MAN_TH; tok < MAN_MAX; tok++) {
                         if (strncmp(name, roff_name[tok], len) != 0 ||                          if (strncmp(name, roff_name[tok], len) != 0 ||
                             roff_name[tok][len] != '\0')                              roff_name[tok][len] != '\0')
Line 4133  roff_strdup(const struct roff *r, const char *p)
Line 4163  roff_strdup(const struct roff *r, const char *p)
                 /*                  /*
                  * We bail out on bad escapes.                   * We bail out on bad escapes.
                  * No need to warn: we already did so when                   * No need to warn: we already did so when
                  * roff_res() was called.                   * roff_expand() was called.
                  */                   */
                 sz = (int)(p - pp);                  sz = (int)(p - pp);
                 res = mandoc_realloc(res, ssz + sz + 1);                  res = mandoc_realloc(res, ssz + sz + 1);
Legend:
Removed from v.1.353  
changed lines
  Added in v.1.356
CVSweb