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

Diff for /mandoc/roff.c between version 1.277 and 1.286

version 1.277, 2015/10/06 18:32:20 version 1.286, 2017/01/10 14:09:07
Line 33 
Line 33 
 #include "roff_int.h"  #include "roff_int.h"
 #include "libroff.h"  #include "libroff.h"
   
 /* Maximum number of nested if-else conditionals. */  
 #define RSTACK_MAX      128  
   
 /* 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 316  struct roffreg {
Line 313  struct roffreg {
   
 struct  roff {  struct  roff {
         struct mparse   *parse; /* parse point */          struct mparse   *parse; /* parse point */
         const struct mchars *mchars; /* character table */  
         struct roffnode *last; /* leaf of stack */          struct roffnode *last; /* leaf of stack */
         int             *rstack; /* stack of inverted `ie' values */          int             *rstack; /* stack of inverted `ie' values */
         struct roffreg  *regtab; /* number registers */          struct roffreg  *regtab; /* number registers */
Line 901  roff_free(struct roff *r)
Line 897  roff_free(struct roff *r)
 }  }
   
 struct roff *  struct roff *
 roff_alloc(struct mparse *parse, const struct mchars *mchars, int options)  roff_alloc(struct mparse *parse, int options)
 {  {
         struct roff     *r;          struct roff     *r;
   
         r = mandoc_calloc(1, sizeof(struct roff));          r = mandoc_calloc(1, sizeof(struct roff));
         r->parse = parse;          r->parse = parse;
         r->mchars = mchars;  
         r->options = options;          r->options = options;
         r->format = options & (MPARSE_MDOC | MPARSE_MAN);          r->format = options & (MPARSE_MDOC | MPARSE_MAN);
         r->rstackpos = -1;          r->rstackpos = -1;
Line 996  roff_node_alloc(struct roff_man *man, int line, int po
Line 991  roff_node_alloc(struct roff_man *man, int line, int po
         n->sec = man->lastsec;          n->sec = man->lastsec;
   
         if (man->flags & MDOC_SYNOPSIS)          if (man->flags & MDOC_SYNOPSIS)
                 n->flags |= MDOC_SYNPRETTY;                  n->flags |= NODE_SYNPRETTY;
         else          else
                 n->flags &= ~MDOC_SYNPRETTY;                  n->flags &= ~NODE_SYNPRETTY;
         if (man->flags & MDOC_NEWLINE)          if (man->flags & MDOC_NEWLINE)
                 n->flags |= MDOC_LINE;                  n->flags |= NODE_LINE;
         man->flags &= ~MDOC_NEWLINE;          man->flags &= ~MDOC_NEWLINE;
   
         return n;          return n;
Line 1012  roff_node_append(struct roff_man *man, struct roff_nod
Line 1007  roff_node_append(struct roff_man *man, struct roff_nod
   
         switch (man->next) {          switch (man->next) {
         case ROFF_NEXT_SIBLING:          case ROFF_NEXT_SIBLING:
                   if (man->last->next != NULL) {
                           n->next = man->last->next;
                           man->last->next->prev = n;
                   } else
                           man->last->parent->last = n;
                 man->last->next = n;                  man->last->next = n;
                 n->prev = man->last;                  n->prev = man->last;
                 n->parent = man->last->parent;                  n->parent = man->last->parent;
Line 1019  roff_node_append(struct roff_man *man, struct roff_nod
Line 1019  roff_node_append(struct roff_man *man, struct roff_nod
         case ROFF_NEXT_CHILD:          case ROFF_NEXT_CHILD:
                 man->last->child = n;                  man->last->child = n;
                 n->parent = man->last;                  n->parent = man->last;
                   n->parent->last = n;
                 break;                  break;
         default:          default:
                 abort();                  abort();
         }          }
         n->parent->nchild++;          man->last = n;
         n->parent->last = n;  
   
         /*  
          * Copy over the normalised-data pointer of our parent.  Not  
          * everybody has one, but copying a null pointer is fine.  
          */  
   
         switch (n->type) {          switch (n->type) {
         case ROFFT_BODY:  
                 if (n->end != ENDBODY_NOT)  
                         break;  
                 /* FALLTHROUGH */  
         case ROFFT_TAIL:  
                 /* FALLTHROUGH */  
         case ROFFT_HEAD:          case ROFFT_HEAD:
                 n->norm = n->parent->norm;  
                 break;  
         default:  
                 break;  
         }  
   
         if (man->macroset == MACROSET_MDOC)  
                 mdoc_valid_pre(man, n);  
   
         switch (n->type) {  
         case ROFFT_HEAD:  
                 assert(n->parent->type == ROFFT_BLOCK);  
                 n->parent->head = n;                  n->parent->head = n;
                 break;                  break;
         case ROFFT_BODY:          case ROFFT_BODY:
                 if (n->end)                  if (n->end != ENDBODY_NOT)
                         break;                          return;
                 assert(n->parent->type == ROFFT_BLOCK);  
                 n->parent->body = n;                  n->parent->body = n;
                 break;                  break;
         case ROFFT_TAIL:          case ROFFT_TAIL:
                 assert(n->parent->type == ROFFT_BLOCK);  
                 n->parent->tail = n;                  n->parent->tail = n;
                 break;                  break;
         default:          default:
                 break;                  return;
         }          }
         man->last = n;  
           /*
            * Copy over the normalised-data pointer of our parent.  Not
            * everybody has one, but copying a null pointer is fine.
            */
   
           n->norm = n->parent->norm;
           assert(n->parent->type == ROFFT_BLOCK);
 }  }
   
 void  void
Line 1077  roff_word_alloc(struct roff_man *man, int line, int po
Line 1059  roff_word_alloc(struct roff_man *man, int line, int po
         n = roff_node_alloc(man, line, pos, ROFFT_TEXT, TOKEN_NONE);          n = roff_node_alloc(man, line, pos, ROFFT_TEXT, TOKEN_NONE);
         n->string = roff_strdup(man->roff, word);          n->string = roff_strdup(man->roff, word);
         roff_node_append(man, n);          roff_node_append(man, n);
         if (man->macroset == MACROSET_MDOC)          n->flags |= NODE_VALID | NODE_ENDED;
                 mdoc_valid_post(man);  
         else  
                 man_valid_post(man);  
         man->next = ROFF_NEXT_SIBLING;          man->next = ROFF_NEXT_SIBLING;
 }  }
   
Line 1150  roff_addeqn(struct roff_man *man, const struct eqn *eq
Line 1129  roff_addeqn(struct roff_man *man, const struct eqn *eq
         n = roff_node_alloc(man, eqn->ln, eqn->pos, ROFFT_EQN, TOKEN_NONE);          n = roff_node_alloc(man, eqn->ln, eqn->pos, ROFFT_EQN, TOKEN_NONE);
         n->eqn = eqn;          n->eqn = eqn;
         if (eqn->ln > man->last->line)          if (eqn->ln > man->last->line)
                 n->flags |= MDOC_LINE;                  n->flags |= NODE_LINE;
         roff_node_append(man, n);          roff_node_append(man, n);
         man->next = ROFF_NEXT_SIBLING;          man->next = ROFF_NEXT_SIBLING;
 }  }
Line 1165  roff_addtbl(struct roff_man *man, const struct tbl_spa
Line 1144  roff_addtbl(struct roff_man *man, const struct tbl_spa
         n = roff_node_alloc(man, tbl->line, 0, ROFFT_TBL, TOKEN_NONE);          n = roff_node_alloc(man, tbl->line, 0, ROFFT_TBL, TOKEN_NONE);
         n->span = tbl;          n->span = tbl;
         roff_node_append(man, n);          roff_node_append(man, n);
         if (man->macroset == MACROSET_MDOC)          n->flags |= NODE_VALID | NODE_ENDED;
                 mdoc_valid_post(man);  
         else  
                 man_valid_post(man);  
         man->next = ROFF_NEXT_SIBLING;          man->next = ROFF_NEXT_SIBLING;
 }  }
   
Line 1186  roff_node_unlink(struct roff_man *man, struct roff_nod
Line 1162  roff_node_unlink(struct roff_man *man, struct roff_nod
         /* Adjust parent. */          /* Adjust parent. */
   
         if (n->parent != NULL) {          if (n->parent != NULL) {
                 n->parent->nchild--;  
                 if (n->parent->child == n)                  if (n->parent->child == n)
                         n->parent->child = n->next;                          n->parent->child = n->next;
                 if (n->parent->last == n)                  if (n->parent->last == n)
Line 1228  roff_node_delete(struct roff_man *man, struct roff_nod
Line 1203  roff_node_delete(struct roff_man *man, struct roff_nod
   
         while (n->child != NULL)          while (n->child != NULL)
                 roff_node_delete(man, n->child);                  roff_node_delete(man, n->child);
         assert(n->nchild == 0);  
         roff_node_unlink(man, n);          roff_node_unlink(man, n);
         roff_node_free(n);          roff_node_free(n);
 }  }
Line 1335  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1309  roff_res(struct roff *r, struct buf *buf, int ln, int 
                         res = NULL;                          res = NULL;
                         break;                          break;
                 case 'B':                  case 'B':
                         /* FALLTHROUGH */  
                 case 'w':                  case 'w':
                         term = cp[1];                          term = cp[1];
                         /* FALLTHROUGH */                          /* FALLTHROUGH */
Line 1346  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1319  roff_res(struct roff *r, struct buf *buf, int ln, int 
                         esc = mandoc_escape(&cp, &stnam, &inaml);                          esc = mandoc_escape(&cp, &stnam, &inaml);
                         if (esc == ESCAPE_ERROR ||                          if (esc == ESCAPE_ERROR ||
                             (esc == ESCAPE_SPECIAL &&                              (esc == ESCAPE_SPECIAL &&
                              mchars_spec2cp(r->mchars, stnam, inaml) < 0))                               mchars_spec2cp(stnam, inaml) < 0))
                                 mandoc_vmsg(MANDOCERR_ESC_BAD,                                  mandoc_vmsg(MANDOCERR_ESC_BAD,
                                     r->parse, ln, (int)(stesc - buf->buf),                                      r->parse, ln, (int)(stesc - buf->buf),
                                     "%.*s", (int)(cp - stesc), stesc);                                      "%.*s", (int)(cp - stesc), stesc);
Line 1410  roff_res(struct roff *r, struct buf *buf, int ln, int 
Line 1383  roff_res(struct roff *r, struct buf *buf, int ln, int 
                         }                          }
                         switch (mandoc_escape(&cp, NULL, NULL)) {                          switch (mandoc_escape(&cp, NULL, NULL)) {
                         case ESCAPE_SPECIAL:                          case ESCAPE_SPECIAL:
                                 /* FALLTHROUGH */  
                         case ESCAPE_UNICODE:                          case ESCAPE_UNICODE:
                                 /* FALLTHROUGH */  
                         case ESCAPE_NUMBERED:                          case ESCAPE_NUMBERED:
                                 /* FALLTHROUGH */  
                         case ESCAPE_OVERSTRIKE:                          case ESCAPE_OVERSTRIKE:
                                 naml++;                                  naml++;
                                 break;                                  break;
Line 1721  roff_cblock(ROFF_ARGS)
Line 1691  roff_cblock(ROFF_ARGS)
         switch (r->last->tok) {          switch (r->last->tok) {
         case ROFF_am:          case ROFF_am:
                 /* ROFF_am1 is remapped to ROFF_am in roff_block(). */                  /* ROFF_am1 is remapped to ROFF_am in roff_block(). */
                 /* FALLTHROUGH */  
         case ROFF_ami:          case ROFF_ami:
                 /* FALLTHROUGH */  
         case ROFF_de:          case ROFF_de:
                 /* ROFF_de1 is remapped to ROFF_de in roff_block(). */                  /* ROFF_de1 is remapped to ROFF_de in roff_block(). */
                 /* FALLTHROUGH */  
         case ROFF_dei:          case ROFF_dei:
                 /* FALLTHROUGH */  
         case ROFF_ig:          case ROFF_ig:
                 break;                  break;
         default:          default:
Line 1770  roff_ccond(struct roff *r, int ln, int ppos)
Line 1736  roff_ccond(struct roff *r, int ln, int ppos)
   
         switch (r->last->tok) {          switch (r->last->tok) {
         case ROFF_el:          case ROFF_el:
                 /* FALLTHROUGH */  
         case ROFF_ie:          case ROFF_ie:
                 /* FALLTHROUGH */  
         case ROFF_if:          case ROFF_if:
                 break;                  break;
         default:          default:
Line 2059  roff_getnum(const char *v, int *pos, int *res, int fla
Line 2023  roff_getnum(const char *v, int *pos, int *res, int fla
                 scaled = *res * 240 / 2.54;                  scaled = *res * 240 / 2.54;
                 break;                  break;
         case 'v':          case 'v':
                 /* FALLTHROUGH */  
         case 'P':          case 'P':
                 scaled = *res * 40;                  scaled = *res * 40;
                 break;                  break;
         case 'm':          case 'm':
                 /* FALLTHROUGH */  
         case 'n':          case 'n':
                 scaled = *res * 24;                  scaled = *res * 24;
                 break;                  break;
Line 2153  roff_evalcond(struct roff *r, int ln, char *v, int *po
Line 2115  roff_evalcond(struct roff *r, int ln, char *v, int *po
         case '\0':          case '\0':
                 return 0;                  return 0;
         case 'n':          case 'n':
                 /* FALLTHROUGH */  
         case 'o':          case 'o':
                 (*pos)++;                  (*pos)++;
                 return wanttrue;                  return wanttrue;
         case 'c':          case 'c':
                 /* FALLTHROUGH */  
         case 'd':          case 'd':
                 /* FALLTHROUGH */  
         case 'e':          case 'e':
                 /* FALLTHROUGH */  
         case 't':          case 't':
                 /* FALLTHROUGH */  
         case 'v':          case 'v':
                 (*pos)++;                  (*pos)++;
                 return !wanttrue;                  return !wanttrue;
Line 2340  roff_getop(const char *v, int *pos, char *res)
Line 2297  roff_getop(const char *v, int *pos, char *res)
   
         switch (*res) {          switch (*res) {
         case '+':          case '+':
                 /* FALLTHROUGH */  
         case '-':          case '-':
                 /* FALLTHROUGH */  
         case '*':          case '*':
                 /* FALLTHROUGH */  
         case '/':          case '/':
                 /* FALLTHROUGH */  
         case '%':          case '%':
                 /* FALLTHROUGH */  
         case '&':          case '&':
                 /* FALLTHROUGH */  
         case ':':          case ':':
                 break;                  break;
         case '<':          case '<':
Legend:
Removed from v.1.277  
changed lines
  Added in v.1.286
CVSweb