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

Diff for /mandoc/man_macro.c between version 1.133 and 1.146

version 1.133, 2018/08/26 16:21:24 version 1.146, 2022/04/13 14:45:50
Line 1 
Line 1 
 /*      $Id$ */  /* $Id$ */
 /*  /*
    * Copyright (c) 2012-2015,2017-2020,2022 Ingo Schwarze <schwarze@openbsd.org>
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2012-2015, 2017, 2018 Ingo Schwarze <schwarze@openbsd.org>  
  * Copyright (c) 2013 Franco Fichtner <franco@lastsummer.de>   * Copyright (c) 2013 Franco Fichtner <franco@lastsummer.de>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
Line 22 
Line 22 
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
   #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   
Line 62  static const struct man_macro man_macros[MAN_MAX - MAN
Line 63  static const struct man_macro man_macros[MAN_MAX - MAN
         { in_line_eoln, MAN_NSCOPED | MAN_ESCOPED | MAN_JOIN }, /* I */          { in_line_eoln, MAN_NSCOPED | MAN_ESCOPED | MAN_JOIN }, /* I */
         { in_line_eoln, 0 }, /* IR */          { in_line_eoln, 0 }, /* IR */
         { in_line_eoln, 0 }, /* RI */          { in_line_eoln, 0 }, /* RI */
         { in_line_eoln, MAN_NSCOPED }, /* nf */  
         { in_line_eoln, MAN_NSCOPED }, /* fi */  
         { blk_close, MAN_XSCOPE }, /* RE */          { blk_close, MAN_XSCOPE }, /* RE */
         { blk_exp, MAN_XSCOPE }, /* RS */          { blk_exp, MAN_XSCOPE }, /* RS */
         { in_line_eoln, 0 }, /* DT */          { in_line_eoln, 0 }, /* DT */
Line 105  man_unscope(struct roff_man *man, const struct roff_no
Line 104  man_unscope(struct roff_man *man, const struct roff_no
                         if (man->flags & (MAN_BLINE | MAN_ELINE) &&                          if (man->flags & (MAN_BLINE | MAN_ELINE) &&
                             man_macro(n->tok)->flags &                              man_macro(n->tok)->flags &
                              (MAN_BSCOPED | MAN_NSCOPED)) {                               (MAN_BSCOPED | MAN_NSCOPED)) {
                                 mandoc_vmsg(MANDOCERR_BLK_LINE,                                  mandoc_msg(MANDOCERR_BLK_LINE,
                                     man->parse, n->line, n->pos,                                      n->line, n->pos,
                                     "EOF breaks %s", roff_name[n->tok]);                                      "EOF breaks %s", roff_name[n->tok]);
                                 if (man->flags & MAN_ELINE)                                  if (man->flags & MAN_ELINE) {
                                         man->flags &= ~MAN_ELINE;                                          if (n->parent->type == ROFFT_ROOT ||
                                 else {                                              (man_macro(n->parent->tok)->flags &
                                               MAN_ESCOPED) == 0)
                                                   man->flags &= ~MAN_ELINE;
                                   } else {
                                         assert(n->type == ROFFT_HEAD);                                          assert(n->type == ROFFT_HEAD);
                                         n = n->parent;                                          n = n->parent;
                                         man->flags &= ~MAN_BLINE;                                          man->flags &= ~MAN_BLINE;
Line 123  man_unscope(struct roff_man *man, const struct roff_no
Line 125  man_unscope(struct roff_man *man, const struct roff_no
                         if (n->type == ROFFT_BLOCK &&                          if (n->type == ROFFT_BLOCK &&
                             man_macro(n->tok)->fp == blk_exp)                              man_macro(n->tok)->fp == blk_exp)
                                 mandoc_msg(MANDOCERR_BLK_NOEND,                                  mandoc_msg(MANDOCERR_BLK_NOEND,
                                     man->parse, n->line, n->pos,                                      n->line, n->pos, "%s",
                                     roff_name[n->tok]);                                      roff_name[n->tok]);
                 }                  }
   
Line 201  blk_close(MACRO_PROT_ARGS)
Line 203  blk_close(MACRO_PROT_ARGS)
 {  {
         enum roff_tok            ctok, ntok;          enum roff_tok            ctok, ntok;
         const struct roff_node  *nn;          const struct roff_node  *nn;
         char                    *p;          char                    *p, *ep;
         int                      cline, cpos, nrew, target;          int                      cline, cpos, la, nrew, target;
   
         nrew = 1;          nrew = 1;
         switch (tok) {          switch (tok) {
         case MAN_RE:          case MAN_RE:
                 ntok = MAN_RS;                  ntok = MAN_RS;
                   la = *pos;
                 if ( ! man_args(man, line, pos, buf, &p))                  if ( ! man_args(man, line, pos, buf, &p))
                         break;                          break;
                 for (nn = man->last->parent; nn; nn = nn->parent)                  for (nn = man->last->parent; nn; nn = nn->parent)
                         if (nn->tok == ntok && nn->type == ROFFT_BLOCK)                          if (nn->tok == ntok && nn->type == ROFFT_BLOCK)
                                 nrew++;                                  nrew++;
                 target = strtol(p, &p, 10);                  target = strtol(p, &ep, 10);
                 if (*p != '\0')                  if (*ep != '\0')
                         mandoc_vmsg(MANDOCERR_ARG_EXCESS, man->parse,                          mandoc_msg(MANDOCERR_ARG_EXCESS, line,
                             line, p - buf, "RE ... %s", p);                              la + (buf[la] == '"') + (int)(ep - p),
                               "RE ... %s", ep);
                   free(p);
                 if (target == 0)                  if (target == 0)
                         target = 1;                          target = 1;
                 nrew -= target;                  nrew -= target;
                 if (nrew < 1) {                  if (nrew < 1) {
                         mandoc_vmsg(MANDOCERR_RE_NOTOPEN, man->parse,                          mandoc_msg(MANDOCERR_RE_NOTOPEN,
                             line, ppos, "RE %d", target);                              line, ppos, "RE %d", target);
                         return;                          return;
                 }                  }
Line 244  blk_close(MACRO_PROT_ARGS)
Line 249  blk_close(MACRO_PROT_ARGS)
                         break;                          break;
   
         if (nn == NULL) {          if (nn == NULL) {
                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, man->parse,                  mandoc_msg(MANDOCERR_BLK_NOTOPEN,
                     line, ppos, roff_name[tok]);                      line, ppos, "%s", roff_name[tok]);
                 rew_scope(man, MAN_PP);                  rew_scope(man, MAN_PP);
                 if (tok == MAN_RE) {                  if (tok == MAN_RE) {
                         roff_elem_alloc(man, line, ppos, ROFF_br);                          roff_elem_alloc(man, line, ppos, ROFF_br);
Line 295  blk_exp(MACRO_PROT_ARGS)
Line 300  blk_exp(MACRO_PROT_ARGS)
         char            *p;          char            *p;
         int              la;          int              la;
   
         if (tok == MAN_RS)          if (tok == MAN_RS) {
                 rew_scope(man, tok);                  rew_scope(man, tok);
                   man->flags |= ROFF_NONOFILL;
           }
         roff_block_alloc(man, line, ppos, tok);          roff_block_alloc(man, line, ppos, tok);
         head = roff_head_alloc(man, line, ppos, tok);          head = roff_head_alloc(man, line, ppos, tok);
   
Line 311  blk_exp(MACRO_PROT_ARGS)
Line 318  blk_exp(MACRO_PROT_ARGS)
                                 roff_setreg(man->roff, "an-margin",                                  roff_setreg(man->roff, "an-margin",
                                     head->aux, '+');                                      head->aux, '+');
                 }                  }
                   free(p);
         }          }
   
         if (buf[*pos] != '\0')          if (buf[*pos] != '\0')
                 mandoc_vmsg(MANDOCERR_ARG_EXCESS, man->parse, line,                  mandoc_msg(MANDOCERR_ARG_EXCESS, line, *pos,
                     *pos, "%s ... %s", roff_name[tok], buf + *pos);                      "%s ... %s", roff_name[tok], buf + *pos);
   
         man_unscope(man, head);          man_unscope(man, head);
         roff_body_alloc(man, line, ppos, tok);          roff_body_alloc(man, line, ppos, tok);
           man->flags &= ~ROFF_NONOFILL;
 }  }
   
 /*  /*
Line 335  blk_imp(MACRO_PROT_ARGS)
Line 344  blk_imp(MACRO_PROT_ARGS)
         struct roff_node *n;          struct roff_node *n;
   
         rew_scope(man, tok);          rew_scope(man, tok);
         n = roff_block_alloc(man, line, ppos, tok);          man->flags |= ROFF_NONOFILL;
         if (n->tok == MAN_SH || n->tok == MAN_SS)          if (tok == MAN_SH || tok == MAN_SS)
                 man->flags &= ~MAN_LITERAL;                  man->flags &= ~ROFF_NOFILL;
           roff_block_alloc(man, line, ppos, tok);
         n = roff_head_alloc(man, line, ppos, tok);          n = roff_head_alloc(man, line, ppos, tok);
   
         /* Add line arguments. */          /* Add line arguments. */
Line 347  blk_imp(MACRO_PROT_ARGS)
Line 357  blk_imp(MACRO_PROT_ARGS)
                 if ( ! man_args(man, line, pos, buf, &p))                  if ( ! man_args(man, line, pos, buf, &p))
                         break;                          break;
                 roff_word_alloc(man, line, la, p);                  roff_word_alloc(man, line, la, p);
                   free(p);
         }          }
   
         /*          /*
Line 365  blk_imp(MACRO_PROT_ARGS)
Line 376  blk_imp(MACRO_PROT_ARGS)
   
         man_unscope(man, n);          man_unscope(man, n);
         roff_body_alloc(man, line, ppos, tok);          roff_body_alloc(man, line, ppos, tok);
           man->flags &= ~ROFF_NONOFILL;
 }  }
   
 void  void
Line 377  in_line_eoln(MACRO_PROT_ARGS)
Line 389  in_line_eoln(MACRO_PROT_ARGS)
         roff_elem_alloc(man, line, ppos, tok);          roff_elem_alloc(man, line, ppos, tok);
         n = man->last;          n = man->last;
   
           if (tok == MAN_EX)
                   man->flags |= ROFF_NOFILL;
           else if (tok == MAN_EE)
                   man->flags &= ~ROFF_NOFILL;
   
         for (;;) {          for (;;) {
                 if (buf[*pos] != '\0' && (tok == MAN_fi || tok == MAN_nf)) {  
                         mandoc_vmsg(MANDOCERR_ARG_SKIP,  
                             man->parse, line, *pos, "%s %s",  
                             roff_name[tok], buf + *pos);  
                         break;  
                 }  
                 if (buf[*pos] != '\0' && man->last != n && tok == MAN_PD) {                  if (buf[*pos] != '\0' && man->last != n && tok == MAN_PD) {
                         mandoc_vmsg(MANDOCERR_ARG_EXCESS,                          mandoc_msg(MANDOCERR_ARG_EXCESS, line, *pos,
                             man->parse, line, *pos, "%s ... %s",                              "%s ... %s", roff_name[tok], buf + *pos);
                             roff_name[tok], buf + *pos);  
                         break;                          break;
                 }                  }
                 la = *pos;                  la = *pos;
Line 398  in_line_eoln(MACRO_PROT_ARGS)
Line 408  in_line_eoln(MACRO_PROT_ARGS)
                         roff_word_append(man, p);                          roff_word_append(man, p);
                 else                  else
                         roff_word_alloc(man, line, la, p);                          roff_word_alloc(man, line, la, p);
                   free(p);
         }          }
   
         /*          /*
Line 426  in_line_eoln(MACRO_PROT_ARGS)
Line 437  in_line_eoln(MACRO_PROT_ARGS)
         /* Rewind our element scope. */          /* Rewind our element scope. */
   
         for ( ; man->last; man->last = man->last->parent) {          for ( ; man->last; man->last = man->last->parent) {
                 man_state(man, man->last);                  man->last->flags |= NODE_VALID;
                 if (man->last == n)                  if (man->last == n)
                         break;                          break;
         }          }
Line 440  in_line_eoln(MACRO_PROT_ARGS)
Line 451  in_line_eoln(MACRO_PROT_ARGS)
 void  void
 man_endparse(struct roff_man *man)  man_endparse(struct roff_man *man)
 {  {
           man_unscope(man, man->meta.first);
         man_unscope(man, man->first);  
         man->flags &= ~MAN_LITERAL;  
 }  }
   
 static int  static int
Line 457  man_args(struct roff_man *man, int line, int *pos, cha
Line 466  man_args(struct roff_man *man, int line, int *pos, cha
         if ('\0' == *start)          if ('\0' == *start)
                 return 0;                  return 0;
   
         *v = mandoc_getarg(man->parse, v, line, pos);          *v = roff_getarg(man->roff, v, line, pos);
         return 1;          return 1;
 }  }
Legend:
Removed from v.1.133  
changed lines
  Added in v.1.146
CVSweb