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

Diff for /mandoc/man_validate.c between version 1.136 and 1.139

version 1.136, 2018/08/16 23:43:37 version 1.139, 2018/12/04 02:53:51
Line 40 
Line 40 
   
 typedef void    (*v_check)(CHKARGS);  typedef void    (*v_check)(CHKARGS);
   
   static  void      check_abort(CHKARGS);
 static  void      check_par(CHKARGS);  static  void      check_par(CHKARGS);
 static  void      check_part(CHKARGS);  static  void      check_part(CHKARGS);
 static  void      check_root(CHKARGS);  static  void      check_root(CHKARGS);
Line 48  static void   check_text(CHKARGS);
Line 49  static void   check_text(CHKARGS);
 static  void      post_AT(CHKARGS);  static  void      post_AT(CHKARGS);
 static  void      post_IP(CHKARGS);  static  void      post_IP(CHKARGS);
 static  void      post_OP(CHKARGS);  static  void      post_OP(CHKARGS);
   static  void      post_SH(CHKARGS);
 static  void      post_TH(CHKARGS);  static  void      post_TH(CHKARGS);
 static  void      post_UC(CHKARGS);  static  void      post_UC(CHKARGS);
 static  void      post_UR(CHKARGS);  static  void      post_UR(CHKARGS);
 static  void      post_in(CHKARGS);  static  void      post_in(CHKARGS);
 static  void      post_vs(CHKARGS);  
   
 static  const v_check man_valids[MAN_MAX - MAN_TH] = {  static  const v_check man_valids[MAN_MAX - MAN_TH] = {
         post_TH,    /* TH */          post_TH,    /* TH */
         NULL,       /* SH */          post_SH,    /* SH */
         NULL,       /* SS */          post_SH,    /* SS */
         NULL,       /* TP */          NULL,       /* TP */
         NULL,       /* TQ */          NULL,       /* TQ */
         check_par,  /* LP */          check_abort,/* LP */
         check_par,  /* PP */          check_par,  /* PP */
         check_par,  /* P */          check_abort,/* P */
         post_IP,    /* IP */          post_IP,    /* IP */
         NULL,       /* HP */          NULL,       /* HP */
         NULL,       /* SM */          NULL,       /* SM */
Line 85  static const v_check man_valids[MAN_MAX - MAN_TH] = {
Line 86  static const v_check man_valids[MAN_MAX - MAN_TH] = {
         NULL,       /* PD */          NULL,       /* PD */
         post_AT,    /* AT */          post_AT,    /* AT */
         post_in,    /* in */          post_in,    /* in */
           NULL,       /* SY */
           NULL,       /* YS */
         post_OP,    /* OP */          post_OP,    /* OP */
         NULL,       /* EX */          NULL,       /* EX */
         NULL,       /* EE */          NULL,       /* EE */
Line 95  static const v_check man_valids[MAN_MAX - MAN_TH] = {
Line 98  static const v_check man_valids[MAN_MAX - MAN_TH] = {
 };  };
   
   
   /* Validate the subtree rooted at man->last. */
 void  void
 man_node_validate(struct roff_man *man)  man_node_validate(struct roff_man *man)
 {  {
         struct roff_node *n;          struct roff_node *n;
         const v_check    *cp;          const v_check    *cp;
   
           /*
            * Translate obsolete macros such that later code
            * does not need to look for them.
            */
   
         n = man->last;          n = man->last;
           switch (n->tok) {
           case MAN_LP:
           case MAN_P:
                   n->tok = MAN_PP;
                   break;
           default:
                   break;
           }
   
           /*
            * Iterate over all children, recursing into each one
            * in turn, depth-first.
            */
   
         man->last = man->last->child;          man->last = man->last->child;
         while (man->last != NULL) {          while (man->last != NULL) {
                 man_node_validate(man);                  man_node_validate(man);
Line 111  man_node_validate(struct roff_man *man)
Line 134  man_node_validate(struct roff_man *man)
                         man->last = man->last->next;                          man->last = man->last->next;
         }          }
   
           /* Finally validate the macro itself. */
   
         man->last = n;          man->last = n;
         man->next = ROFF_NEXT_SIBLING;          man->next = ROFF_NEXT_SIBLING;
         switch (n->type) {          switch (n->type) {
Line 126  man_node_validate(struct roff_man *man)
Line 151  man_node_validate(struct roff_man *man)
                 break;                  break;
         default:          default:
                 if (n->tok < ROFF_MAX) {                  if (n->tok < ROFF_MAX) {
                         switch (n->tok) {                          roff_validate(man);
                         case ROFF_br:  
                         case ROFF_sp:  
                                 post_vs(man, n);  
                                 break;  
                         default:  
                                 roff_validate(man);  
                                 break;  
                         }  
                         break;                          break;
                 }                  }
                 assert(n->tok >= MAN_TH && n->tok < MAN_MAX);                  assert(n->tok >= MAN_TH && n->tok < MAN_MAX);
Line 181  check_root(CHKARGS)
Line 198  check_root(CHKARGS)
 }  }
   
 static void  static void
   check_abort(CHKARGS)
   {
           abort();
   }
   
   static void
 check_text(CHKARGS)  check_text(CHKARGS)
 {  {
         char            *cp, *p;          char            *cp, *p;
Line 209  post_OP(CHKARGS)
Line 232  post_OP(CHKARGS)
 }  }
   
 static void  static void
   post_SH(CHKARGS)
   {
           struct roff_node        *nc;
   
           if (n->type != ROFFT_BODY || (nc = n->child) == NULL)
                   return;
   
           if (nc->tok == MAN_PP && nc->body->child != NULL) {
                   while (nc->body->last != NULL) {
                           man->next = ROFF_NEXT_CHILD;
                           roff_node_relink(man, nc->body->last);
                           man->last = n;
                   }
           }
   
           if (nc->tok == MAN_PP || nc->tok == ROFF_sp || nc->tok == ROFF_br) {
                   mandoc_vmsg(MANDOCERR_PAR_SKIP, man->parse,
                       nc->line, nc->pos, "%s after %s",
                       roff_name[nc->tok], roff_name[n->tok]);
                   roff_node_delete(man, nc);
           }
   
           /*
            * Trailing PP is empty, so it is deleted by check_par().
            * Trailing sp is significant.
            */
   
           if ((nc = n->last) != NULL && nc->tok == ROFF_br) {
                   mandoc_vmsg(MANDOCERR_PAR_SKIP, man->parse,
                       nc->line, nc->pos, "%s at the end of %s",
                       roff_name[nc->tok], roff_name[n->tok]);
                   roff_node_delete(man, nc);
           }
   }
   
   static void
 post_UR(CHKARGS)  post_UR(CHKARGS)
 {  {
         if (n->type == ROFFT_HEAD && n->child == NULL)          if (n->type == ROFFT_HEAD && n->child == NULL)
Line 236  check_par(CHKARGS)
Line 295  check_par(CHKARGS)
                         roff_node_delete(man, n);                          roff_node_delete(man, n);
                 break;                  break;
         case ROFFT_BODY:          case ROFFT_BODY:
                   if (n->child != NULL &&
                       (n->child->tok == ROFF_sp || n->child->tok == ROFF_br)) {
                           mandoc_vmsg(MANDOCERR_PAR_SKIP,
                               man->parse, n->child->line, n->child->pos,
                               "%s after %s", roff_name[n->child->tok],
                               roff_name[n->tok]);
                           roff_node_delete(man, n->child);
                   }
                 if (n->child == NULL)                  if (n->child == NULL)
                         mandoc_vmsg(MANDOCERR_PAR_SKIP,                          mandoc_vmsg(MANDOCERR_PAR_SKIP,
                             man->parse, n->line, n->pos,                              man->parse, n->line, n->pos,
Line 462  post_in(CHKARGS)
Line 529  post_in(CHKARGS)
         mandoc_asprintf(&s, "+%s", n->child->string);          mandoc_asprintf(&s, "+%s", n->child->string);
         free(n->child->string);          free(n->child->string);
         n->child->string = s;          n->child->string = s;
 }  
   
 static void  
 post_vs(CHKARGS)  
 {  
   
         if (NULL != n->prev)  
                 return;  
   
         switch (n->parent->tok) {  
         case MAN_SH:  
         case MAN_SS:  
         case MAN_PP:  
         case MAN_LP:  
         case MAN_P:  
                 mandoc_vmsg(MANDOCERR_PAR_SKIP, man->parse, n->line, n->pos,  
                     "%s after %s", roff_name[n->tok],  
                     roff_name[n->parent->tok]);  
                 /* FALLTHROUGH */  
         case TOKEN_NONE:  
                 /*  
                  * Don't warn about this because it occurs in pod2man  
                  * and would cause considerable (unfixable) warnage.  
                  */  
                 roff_node_delete(man, n);  
                 break;  
         default:  
                 break;  
         }  
 }  }
Legend:
Removed from v.1.136  
changed lines
  Added in v.1.139
CVSweb