[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.81 and 1.82

version 1.81, 2014/03/30 19:47:48 version 1.82, 2014/04/20 16:46:04
Line 40  static int   blk_close(MACRO_PROT_ARGS);
Line 40  static int   blk_close(MACRO_PROT_ARGS);
 static  int              blk_exp(MACRO_PROT_ARGS);  static  int              blk_exp(MACRO_PROT_ARGS);
 static  int              blk_imp(MACRO_PROT_ARGS);  static  int              blk_imp(MACRO_PROT_ARGS);
 static  int              in_line_eoln(MACRO_PROT_ARGS);  static  int              in_line_eoln(MACRO_PROT_ARGS);
 static  int              man_args(struct man *, int,  static  int              man_args(struct man *, int,
                                 int *, char *, char **);                                  int *, char *, char **);
   
 static  int              rew_scope(enum man_type,  static  int              rew_scope(enum man_type,
                                 struct man *, enum mant);                                  struct man *, enum mant);
 static  enum rew         rew_dohalt(enum mant, enum man_type,  static  enum rew         rew_dohalt(enum mant, enum man_type,
                                 const struct man_node *);                                  const struct man_node *);
 static  enum rew         rew_block(enum mant, enum man_type,  static  enum rew         rew_block(enum mant, enum man_type,
                                 const struct man_node *);                                  const struct man_node *);
 static  void             rew_warn(struct man *,  static  void             rew_warn(struct man *,
                                 struct man_node *, enum mandocerr);                                  struct man_node *, enum mandocerr);
   
 const   struct man_macro __man_macros[MAN_MAX] = {  const   struct man_macro __man_macros[MAN_MAX] = {
Line 115  rew_warn(struct man *man, struct man_node *n, enum man
Line 115  rew_warn(struct man *man, struct man_node *n, enum man
         man_nmsg(man, n, er);          man_nmsg(man, n, er);
 }  }
   
   
 /*  /*
  * Rewind scope.  If a code "er" != MANDOCERR_MAX has been provided, it   * Rewind scope.  If a code "er" != MANDOCERR_MAX has been provided, it
  * will be used if an explicit block scope is being closed out.   * will be used if an explicit block scope is being closed out.
  */   */
 int  int
 man_unscope(struct man *man, const struct man_node *to,  man_unscope(struct man *man, const struct man_node *to,
                 enum mandocerr er)                  enum mandocerr er)
 {  {
         struct man_node *n;          struct man_node *n;
Line 130  man_unscope(struct man *man, const struct man_node *to
Line 129  man_unscope(struct man *man, const struct man_node *to
   
         man->next = MAN_NEXT_SIBLING;          man->next = MAN_NEXT_SIBLING;
   
         /* LINTED */  
         while (man->last != to) {          while (man->last != to) {
                 /*                  /*
                  * Save the parent here, because we may delete the                   * Save the parent here, because we may delete the
Line 153  man_unscope(struct man *man, const struct man_node *to
Line 151  man_unscope(struct man *man, const struct man_node *to
         return(1);          return(1);
 }  }
   
   
 static enum rew  static enum rew
 rew_block(enum mant ntok, enum man_type type, const struct man_node *n)  rew_block(enum mant ntok, enum man_type type, const struct man_node *n)
 {  {
   
         if (MAN_BLOCK == type && ntok == n->parent->tok &&          if (MAN_BLOCK == type && ntok == n->parent->tok &&
                         MAN_BODY == n->parent->type)              MAN_BODY == n->parent->type)
                 return(REW_REWIND);                  return(REW_REWIND);
         return(ntok == n->tok ? REW_HALT : REW_NOHALT);          return(ntok == n->tok ? REW_HALT : REW_NOHALT);
 }  }
   
   
 /*  /*
  * There are three scope levels: scoped to the root (all), scoped to the   * There are three scope levels: scoped to the root (all), scoped to the
  * section (all less sections), and scoped to subsections (all less   * section (all less sections), and scoped to subsections (all less
  * sections and subsections).   * sections and subsections).
  */   */
 static enum rew  static enum rew
 rew_dohalt(enum mant tok, enum man_type type, const struct man_node *n)  rew_dohalt(enum mant tok, enum man_type type, const struct man_node *n)
 {  {
         enum rew         c;          enum rew         c;
Line 197  rew_dohalt(enum mant tok, enum man_type type, const st
Line 193  rew_dohalt(enum mant tok, enum man_type type, const st
                         return(REW_REWIND);                          return(REW_REWIND);
         }          }
   
         /*          /*
          * Next follow the implicit scope-smashings as defined by man.7:           * Next follow the implicit scope-smashings as defined by man.7:
          * section, sub-section, etc.           * section, sub-section, etc.
          */           */
   
         switch (tok) {          switch (tok) {
         case (MAN_SH):          case MAN_SH:
                 break;                  break;
         case (MAN_SS):          case MAN_SS:
                 /* Rewind to a section, if a block. */                  /* Rewind to a section, if a block. */
                 if (REW_NOHALT != (c = rew_block(MAN_SH, type, n)))                  if (REW_NOHALT != (c = rew_block(MAN_SH, type, n)))
                         return(c);                          return(c);
                 break;                  break;
         case (MAN_RS):          case MAN_RS:
                 /* Preserve empty paragraphs before RS. */                  /* Preserve empty paragraphs before RS. */
                 if (0 == n->nchild && (MAN_P == n->tok ||                  if (0 == n->nchild && (MAN_P == n->tok ||
                     MAN_PP == n->tok || MAN_LP == n->tok))                      MAN_PP == n->tok || MAN_LP == n->tok))
Line 238  rew_dohalt(enum mant tok, enum man_type type, const st
Line 234  rew_dohalt(enum mant tok, enum man_type type, const st
         return(REW_NOHALT);          return(REW_NOHALT);
 }  }
   
   
 /*  /*
  * Rewinding entails ascending the parse tree until a coherent point,   * Rewinding entails ascending the parse tree until a coherent point,
  * for example, the `SH' macro will close out any intervening `SS'   * for example, the `SH' macro will close out any intervening `SS'
Line 250  rew_scope(enum man_type type, struct man *man, enum ma
Line 245  rew_scope(enum man_type type, struct man *man, enum ma
         struct man_node *n;          struct man_node *n;
         enum rew         c;          enum rew         c;
   
         /* LINTED */  
         for (n = man->last; n; n = n->parent) {          for (n = man->last; n; n = n->parent) {
                 /*                  /*
                  * Whether we should stop immediately (REW_HALT), stop                   * Whether we should stop immediately (REW_HALT), stop
                  * and rewind until this point (REW_REWIND), or keep                   * and rewind until this point (REW_REWIND), or keep
                  * rewinding (REW_NOHALT).                   * rewinding (REW_NOHALT).
Line 264  rew_scope(enum man_type type, struct man *man, enum ma
Line 258  rew_scope(enum man_type type, struct man *man, enum ma
                         break;                          break;
         }          }
   
         /*          /*
          * Rewind until the current point.  Warn if we're a roff           * Rewind until the current point.  Warn if we're a roff
          * instruction that's mowing over explicit scopes.           * instruction that's mowing over explicit scopes.
          */           */
Line 277  rew_scope(enum man_type type, struct man *man, enum ma
Line 271  rew_scope(enum man_type type, struct man *man, enum ma
 /*  /*
  * Close out a generic explicit macro.   * Close out a generic explicit macro.
  */   */
 /* ARGSUSED */  
 int  int
 blk_close(MACRO_PROT_ARGS)  blk_close(MACRO_PROT_ARGS)
 {  {
         enum mant                ntok;          enum mant                ntok;
         const struct man_node   *nn;          const struct man_node   *nn;
   
         switch (tok) {          switch (tok) {
         case (MAN_RE):          case MAN_RE:
                 ntok = MAN_RS;                  ntok = MAN_RS;
                 break;                  break;
         case (MAN_UE):          case MAN_UE:
                 ntok = MAN_UR;                  ntok = MAN_UR;
                 break;                  break;
         default:          default:
Line 304  blk_close(MACRO_PROT_ARGS)
Line 297  blk_close(MACRO_PROT_ARGS)
                 man_pmsg(man, line, ppos, MANDOCERR_NOSCOPE);                  man_pmsg(man, line, ppos, MANDOCERR_NOSCOPE);
                 if ( ! rew_scope(MAN_BLOCK, man, MAN_PP))                  if ( ! rew_scope(MAN_BLOCK, man, MAN_PP))
                         return(0);                          return(0);
         } else          } else
                 man_unscope(man, nn, MANDOCERR_MAX);                  man_unscope(man, nn, MANDOCERR_MAX);
   
         return(1);          return(1);
 }  }
   
   
 /* ARGSUSED */  
 int  int
 blk_exp(MACRO_PROT_ARGS)  blk_exp(MACRO_PROT_ARGS)
 {  {
Line 351  blk_exp(MACRO_PROT_ARGS)
Line 342  blk_exp(MACRO_PROT_ARGS)
         return(man_body_alloc(man, line, ppos, tok));          return(man_body_alloc(man, line, ppos, tok));
 }  }
   
   
   
 /*  /*
  * Parse an implicit-block macro.  These contain a MAN_HEAD and a   * Parse an implicit-block macro.  These contain a MAN_HEAD and a
  * MAN_BODY contained within a MAN_BLOCK.  Rules for closing out other   * MAN_BODY contained within a MAN_BLOCK.  Rules for closing out other
  * scopes, such as `SH' closing out an `SS', are defined in the rew   * scopes, such as `SH' closing out an `SS', are defined in the rew
  * routines.   * routines.
  */   */
 /* ARGSUSED */  
 int  int
 blk_imp(MACRO_PROT_ARGS)  blk_imp(MACRO_PROT_ARGS)
 {  {
Line 411  blk_imp(MACRO_PROT_ARGS)
Line 399  blk_imp(MACRO_PROT_ARGS)
         return(man_body_alloc(man, line, ppos, tok));          return(man_body_alloc(man, line, ppos, tok));
 }  }
   
   
 /* ARGSUSED */  
 int  int
 in_line_eoln(MACRO_PROT_ARGS)  in_line_eoln(MACRO_PROT_ARGS)
 {  {
Line 452  in_line_eoln(MACRO_PROT_ARGS)
Line 438  in_line_eoln(MACRO_PROT_ARGS)
                 assert( ! (MAN_NSCOPED & man_macros[tok].flags));                  assert( ! (MAN_NSCOPED & man_macros[tok].flags));
                 man->flags |= MAN_ELINE;                  man->flags |= MAN_ELINE;
                 return(1);                  return(1);
         }          }
   
         /* Set ignorable context, if applicable. */          /* Set ignorable context, if applicable. */
   
Line 463  in_line_eoln(MACRO_PROT_ARGS)
Line 449  in_line_eoln(MACRO_PROT_ARGS)
   
         assert(MAN_ROOT != man->last->type);          assert(MAN_ROOT != man->last->type);
         man->next = MAN_NEXT_SIBLING;          man->next = MAN_NEXT_SIBLING;
   
         /*          /*
          * Rewind our element scope.  Note that when TH is pruned, we'll           * Rewind our element scope.  Note that when TH is pruned, we'll
          * be back at the root, so make sure that we don't clobber as           * be back at the root, so make sure that we don't clobber as
Line 482  in_line_eoln(MACRO_PROT_ARGS)
Line 468  in_line_eoln(MACRO_PROT_ARGS)
         assert(man->last);          assert(man->last);
   
         /*          /*
          * Same here regarding whether we're back at the root.           * Same here regarding whether we're back at the root.
          */           */
   
         if (man->last->type != MAN_ROOT && ! man_valid_post(man))          if (man->last->type != MAN_ROOT && ! man_valid_post(man))
Legend:
Removed from v.1.81  
changed lines
  Added in v.1.82
CVSweb