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

Diff for /mandoc/mdoc_validate.c between version 1.118 and 1.122

version 1.118, 2010/09/27 11:25:03 version 1.122, 2010/11/29 12:22:28
Line 36 
Line 36 
 #define PRE_ARGS  struct mdoc *mdoc, struct mdoc_node *n  #define PRE_ARGS  struct mdoc *mdoc, struct mdoc_node *n
 #define POST_ARGS struct mdoc *mdoc  #define POST_ARGS struct mdoc *mdoc
   
   enum    check_ineq {
           CHECK_LT,
           CHECK_GT,
           CHECK_EQ
   };
   
   enum    check_lvl {
           CHECK_WARN,
           CHECK_ERROR,
           CHECK_FATAL
   };
   
 typedef int     (*v_pre)(PRE_ARGS);  typedef int     (*v_pre)(PRE_ARGS);
 typedef int     (*v_post)(POST_ARGS);  typedef int     (*v_post)(POST_ARGS);
   
Line 44  struct valids {
Line 56  struct valids {
         v_post  *post;          v_post  *post;
 };  };
   
   static  int      check_count(struct mdoc *, enum mdoc_type,
                           enum check_lvl, enum check_ineq, int);
 static  int      check_parent(PRE_ARGS, enum mdoct, enum mdoc_type);  static  int      check_parent(PRE_ARGS, enum mdoct, enum mdoc_type);
 static  int      check_stdarg(PRE_ARGS);  static  int      check_stdarg(PRE_ARGS);
 static  int      check_text(struct mdoc *, int, int, char *);  static  int      check_text(struct mdoc *, int, int, char *);
 static  int      check_argv(struct mdoc *,  static  int      check_argv(struct mdoc *,
                         struct mdoc_node *, struct mdoc_argv *);                          struct mdoc_node *, struct mdoc_argv *);
 static  int      check_args(struct mdoc *, struct mdoc_node *);  static  int      check_args(struct mdoc *, struct mdoc_node *);
 static  int      err_child_lt(struct mdoc *, const char *, int);  
 static  int      warn_child_lt(struct mdoc *, const char *, int);  
 static  int      err_child_gt(struct mdoc *, const char *, int);  
 static  int      warn_child_gt(struct mdoc *, const char *, int);  
 static  int      err_child_eq(struct mdoc *, const char *, int);  
 static  int      warn_child_eq(struct mdoc *, const char *, int);  
 static  int      warn_count(struct mdoc *, const char *,  
                         int, const char *, int);  
 static  int      err_count(struct mdoc *, const char *,  
                         int, const char *, int);  
   
   static  int      ebool(POST_ARGS);
 static  int      berr_ge1(POST_ARGS);  static  int      berr_ge1(POST_ARGS);
 static  int      bwarn_ge1(POST_ARGS);  static  int      bwarn_ge1(POST_ARGS);
 static  int      ebool(POST_ARGS);  static  int      eerr_eq0(POST_ARGS);
 static  int      eerr_eq1(POST_ARGS);  static  int      eerr_eq1(POST_ARGS);
 static  int      eerr_ge1(POST_ARGS);  static  int      eerr_ge1(POST_ARGS);
 static  int      eerr_le1(POST_ARGS);  static  int      eerr_le1(POST_ARGS);
Line 71  static int  ewarn_eq0(POST_ARGS);
Line 76  static int  ewarn_eq0(POST_ARGS);
 static  int      ewarn_ge1(POST_ARGS);  static  int      ewarn_ge1(POST_ARGS);
 static  int      herr_eq0(POST_ARGS);  static  int      herr_eq0(POST_ARGS);
 static  int      herr_ge1(POST_ARGS);  static  int      herr_ge1(POST_ARGS);
 static  int      hwarn_eq1(POST_ARGS);  
 static  int      hwarn_eq0(POST_ARGS);  static  int      hwarn_eq0(POST_ARGS);
   static  int      hwarn_eq1(POST_ARGS);
 static  int      hwarn_le1(POST_ARGS);  static  int      hwarn_le1(POST_ARGS);
   
 static  int      post_an(POST_ARGS);  static  int      post_an(POST_ARGS);
Line 265  const struct valids mdoc_valids[MDOC_MAX] = {
Line 270  const struct valids mdoc_valids[MDOC_MAX] = {
         { NULL, NULL },                         /* Dx */          { NULL, NULL },                         /* Dx */
         { NULL, posts_text },                   /* %Q */          { NULL, posts_text },                   /* %Q */
         { NULL, posts_notext },                 /* br */          { NULL, posts_notext },                 /* br */
         { NULL, posts_sp },                     /* sp */          { pres_pp, posts_sp },                  /* sp */
         { NULL, posts_text1 },                  /* %U */          { NULL, posts_text1 },                  /* %U */
         { NULL, NULL },                         /* Ta */          { NULL, NULL },                         /* Ta */
 };  };
   
   #define RSORD_MAX 14 /* Number of `Rs' blocks. */
   
   static  const enum mdoct rsord[RSORD_MAX] = {
           MDOC__A,
           MDOC__T,
           MDOC__B,
           MDOC__I,
           MDOC__J,
           MDOC__R,
           MDOC__N,
           MDOC__V,
           MDOC__P,
           MDOC__Q,
           MDOC__D,
           MDOC__O,
           MDOC__C,
           MDOC__U
   };
   
   
 int  int
 mdoc_valid_pre(struct mdoc *mdoc, struct mdoc_node *n)  mdoc_valid_pre(struct mdoc *mdoc, struct mdoc_node *n)
 {  {
Line 319  mdoc_valid_post(struct mdoc *mdoc)
Line 343  mdoc_valid_post(struct mdoc *mdoc)
         return(1);          return(1);
 }  }
   
   static int
   check_count(struct mdoc *m, enum mdoc_type type,
                   enum check_lvl lvl, enum check_ineq ineq, int val)
   {
           const char      *p;
   
 static inline int          if (m->last->type != type)
 warn_count(struct mdoc *m, const char *k,                  return(1);
                 int want, const char *v, int has)  
           switch (ineq) {
           case (CHECK_LT):
                   p = "less than ";
                   if (m->last->nchild < val)
                           return(1);
                   break;
           case (CHECK_GT):
                   p = "greater than ";
                   if (m->last->nchild > val)
                           return(1);
                   break;
           case (CHECK_EQ):
                   p = "";
                   if (val == m->last->nchild)
                           return(1);
                   break;
           }
   
           if (CHECK_WARN == lvl) {
                   return(mdoc_vmsg(m, MANDOCERR_ARGCOUNT,
                                   m->last->line, m->last->pos,
                                   "want %s%d children (have %d)",
                                   p, val, m->last->nchild));
           }
   
           return(mdoc_vmsg(m, MANDOCERR_ARGCOUNT,
                           m->last->line, m->last->pos,
                           "require %s%d children (have %d)",
                           p, val, m->last->nchild));
   }
   
   static int
   berr_ge1(POST_ARGS)
 {  {
   
         return(mdoc_vmsg(m, MANDOCERR_ARGCOUNT,          return(check_count(mdoc, MDOC_BODY, CHECK_FATAL, CHECK_GT, 0));
                                 m->last->line, m->last->pos,  
                                 "%s %s %d (have %d)", v, k, want, has));  
 }  }
   
   static int
   bwarn_ge1(POST_ARGS)
   {
           return(check_count(mdoc, MDOC_BODY, CHECK_WARN, CHECK_GT, 0));
   }
   
 static inline int  static int
 err_count(struct mdoc *m, const char *k,  eerr_eq0(POST_ARGS)
                 int want, const char *v, int has)  
 {  {
           return(check_count(mdoc, MDOC_ELEM, CHECK_FATAL, CHECK_EQ, 0));
   }
   
         mdoc_vmsg(m, MANDOCERR_SYNTARGCOUNT,  static int
                         m->last->line, m->last->pos,  eerr_eq1(POST_ARGS)
                         "%s %s %d (have %d)",  {
                         v, k, want, has);          return(check_count(mdoc, MDOC_ELEM, CHECK_FATAL, CHECK_EQ, 1));
         return(0);  
 }  }
   
   static int
   eerr_ge1(POST_ARGS)
   {
           return(check_count(mdoc, MDOC_ELEM, CHECK_FATAL, CHECK_GT, 0));
   }
   
 /*  static int
  * Build these up with macros because they're basically the same check  eerr_le1(POST_ARGS)
  * for different inequalities.  Yes, this could be done with functions,  {
  * but this is reasonable for now.          return(check_count(mdoc, MDOC_ELEM, CHECK_FATAL, CHECK_LT, 2));
  */  }
   
 #define CHECK_CHILD_DEFN(lvl, name, ineq)                       \  static int
 static int                                                      \  ewarn_eq0(POST_ARGS)
 lvl##_child_##name(struct mdoc *mdoc, const char *p, int sz)    \  {
 {                                                               \          return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_EQ, 0));
         if (mdoc->last->nchild ineq sz)                         \  
                 return(1);                                      \  
         return(lvl##_count(mdoc, #ineq, sz, p, mdoc->last->nchild)); \  
 }  }
   
 #define CHECK_BODY_DEFN(name, lvl, func, num)                   \  static int
 static int                                                      \  ewarn_ge1(POST_ARGS)
 b##lvl##_##name(POST_ARGS)                                      \  {
 {                                                               \          return(check_count(mdoc, MDOC_ELEM, CHECK_WARN, CHECK_GT, 0));
         if (MDOC_BODY != mdoc->last->type)                      \  
                 return(1);                                      \  
         return(func(mdoc, "multi-line arguments", (num)));      \  
 }  }
   
 #define CHECK_ELEM_DEFN(name, lvl, func, num)                   \  static int
 static int                                                      \  herr_eq0(POST_ARGS)
 e##lvl##_##name(POST_ARGS)                                      \  {
 {                                                               \          return(check_count(mdoc, MDOC_HEAD, CHECK_FATAL, CHECK_EQ, 0));
         assert(MDOC_ELEM == mdoc->last->type);                  \  
         return(func(mdoc, "line arguments", (num)));            \  
 }  }
   
 #define CHECK_HEAD_DEFN(name, lvl, func, num)                   \  static int
 static int                                                      \  herr_ge1(POST_ARGS)
 h##lvl##_##name(POST_ARGS)                                      \  {
 {                                                               \          return(check_count(mdoc, MDOC_HEAD, CHECK_FATAL, CHECK_GT, 0));
         if (MDOC_HEAD != mdoc->last->type)                      \  
                 return(1);                                      \  
         return(func(mdoc, "line arguments", (num)));            \  
 }  }
   
   static int
   hwarn_eq0(POST_ARGS)
   {
           return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_EQ, 0));
   }
   
 CHECK_CHILD_DEFN(warn, gt, >)                   /* warn_child_gt() */  static int
 CHECK_CHILD_DEFN(err, gt, >)                    /* err_child_gt() */  hwarn_eq1(POST_ARGS)
 CHECK_CHILD_DEFN(warn, eq, ==)                  /* warn_child_eq() */  {
 CHECK_CHILD_DEFN(err, eq, ==)                   /* err_child_eq() */          return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_EQ, 1));
 CHECK_CHILD_DEFN(err, lt, <)                    /* err_child_lt() */  }
 CHECK_CHILD_DEFN(warn, lt, <)                   /* warn_child_lt() */  
 CHECK_BODY_DEFN(ge1, warn, warn_child_gt, 0)    /* bwarn_ge1() */  
 CHECK_BODY_DEFN(ge1, err, err_child_gt, 0)      /* berr_ge1() */  
 CHECK_ELEM_DEFN(eq0, warn, warn_child_eq, 0)    /* ewarn_eq0() */  
 CHECK_ELEM_DEFN(ge1, warn, warn_child_gt, 0)    /* ewarn_ge1() */  
 CHECK_ELEM_DEFN(eq1, err, err_child_eq, 1)      /* eerr_eq1() */  
 CHECK_ELEM_DEFN(le1, err, err_child_lt, 2)      /* eerr_le1() */  
 CHECK_ELEM_DEFN(ge1, err, err_child_gt, 0)      /* eerr_ge1() */  
 CHECK_HEAD_DEFN(eq0, err, err_child_eq, 0)      /* herr_eq0() */  
 CHECK_HEAD_DEFN(le1, warn, warn_child_lt, 2)    /* hwarn_le1() */  
 CHECK_HEAD_DEFN(ge1, err, err_child_gt, 0)      /* herr_ge1() */  
 CHECK_HEAD_DEFN(eq1, warn, warn_child_eq, 1)    /* hwarn_eq1() */  
 CHECK_HEAD_DEFN(eq0, warn, warn_child_eq, 0)    /* hwarn_eq0() */  
   
   static int
   hwarn_le1(POST_ARGS)
   {
           return(check_count(mdoc, MDOC_HEAD, CHECK_WARN, CHECK_LT, 2));
   }
   
   
 static int  static int
 check_stdarg(PRE_ARGS)  check_stdarg(PRE_ARGS)
 {  {
Line 855  pre_it(PRE_ARGS)
Line 912  pre_it(PRE_ARGS)
 static int  static int
 pre_an(PRE_ARGS)  pre_an(PRE_ARGS)
 {  {
           int              i;
   
         if (NULL == n->args)          if (NULL == n->args)
                 return(1);                  return(1);
         if (n->args->argc > 1)  
                 if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_ARGCOUNT))          for (i = 1; i < (int)n->args->argc; i++)
                   if ( ! mdoc_pmsg(mdoc, n->args->argv[i].line,
                           n->args->argv[i].pos, MANDOCERR_IGNARGV))
                         return(0);                          return(0);
   
         if (MDOC_Split == n->args->argv[0].arg)          if (MDOC_Split == n->args->argv[0].arg)
Line 1094  post_an(POST_ARGS)
Line 1154  post_an(POST_ARGS)
   
         np = mdoc->last;          np = mdoc->last;
         if (AUTH__NONE != np->data.An.auth && np->child)          if (AUTH__NONE != np->data.An.auth && np->child)
                 return(mdoc_nmsg(mdoc, np, MANDOCERR_ARGCOUNT));                  return(eerr_eq0(mdoc));
           /*
            * FIXME: make this ewarn and make sure that the front-ends
            * don't print the arguments.
            */
         if (AUTH__NONE != np->data.An.auth || np->child)          if (AUTH__NONE != np->data.An.auth || np->child)
                 return(1);                  return(1);
         return(mdoc_nmsg(mdoc, np, MANDOCERR_NOARGS));          return(mdoc_nmsg(mdoc, np, MANDOCERR_NOARGS));
Line 1191  post_it(POST_ARGS)
Line 1255  post_it(POST_ARGS)
 static int  static int
 post_bl_head(POST_ARGS)  post_bl_head(POST_ARGS)
 {  {
         int               i;  
         struct mdoc_node *n;          struct mdoc_node *n;
   
         assert(mdoc->last->parent);          assert(mdoc->last->parent);
Line 1205  post_bl_head(POST_ARGS) 
Line 1268  post_bl_head(POST_ARGS) 
                 return(1);                  return(1);
         }          }
   
         if (0 == (i = mdoc->last->nchild))          /* FIXME: should be ERROR class. */
                 return(1);          return(hwarn_eq0(mdoc));
         return(warn_count(mdoc, "==", 0, "line arguments", i));  
 }  }
   
   
Line 1297  post_st(POST_ARGS)
Line 1359  post_st(POST_ARGS)
 static int  static int
 post_rs(POST_ARGS)  post_rs(POST_ARGS)
 {  {
         struct mdoc_node        *nn;          struct mdoc_node *nn, *next, *prev;
           int               i, j;
   
         if (MDOC_BODY != mdoc->last->type)          if (MDOC_BODY != mdoc->last->type)
                 return(1);                  return(1);
   
         for (nn = mdoc->last->child; nn; nn = nn->next)          /*
                 switch (nn->tok) {           * Make sure only certain types of nodes are allowed within the
                 case(MDOC__U):           * the `Rs' body.  Delete offending nodes and raise a warning.
                         /* FALLTHROUGH */           * Do this before re-ordering for the sake of clarity.
                 case(MDOC__Q):           */
                         /* FALLTHROUGH */  
                 case(MDOC__C):          next = NULL;
                         /* FALLTHROUGH */          for (nn = mdoc->last->child; nn; nn = next) {
                 case(MDOC__A):                  for (i = 0; i < RSORD_MAX; i++)
                         /* FALLTHROUGH */                          if (nn->tok == rsord[i])
                 case(MDOC__B):                                  break;
                         /* FALLTHROUGH */  
                 case(MDOC__D):                  if (i < RSORD_MAX) {
                         /* FALLTHROUGH */                          next = nn->next;
                 case(MDOC__I):                          continue;
                         /* FALLTHROUGH */  
                 case(MDOC__J):  
                         /* FALLTHROUGH */  
                 case(MDOC__N):  
                         /* FALLTHROUGH */  
                 case(MDOC__O):  
                         /* FALLTHROUGH */  
                 case(MDOC__P):  
                         /* FALLTHROUGH */  
                 case(MDOC__R):  
                         /* FALLTHROUGH */  
                 case(MDOC__T):  
                         /* FALLTHROUGH */  
                 case(MDOC__V):  
                         break;  
                 default:  
                         mdoc_nmsg(mdoc, nn, MANDOCERR_SYNTCHILD);  
                         return(0);  
                 }                  }
   
                   next = nn->next;
                   mdoc_nmsg(mdoc, nn, MANDOCERR_CHILD);
                   mdoc_node_delete(mdoc, nn);
           }
   
           /*
            * The full `Rs' block needs special handling to order the
            * sub-elements according to `rsord'.  Pick through each element
            * and correctly order it.  This is a insertion sort.
            */
   
           next = NULL;
           for (nn = mdoc->last->child->next; nn; nn = next) {
                   /* Determine order of `nn'. */
                   for (i = 0; i < RSORD_MAX; i++)
                           if (rsord[i] == nn->tok)
                                   break;
   
                   /*
                    * Remove `nn' from the chain.  This somewhat
                    * repeats mdoc_node_unlink(), but since we're
                    * just re-ordering, there's no need for the
                    * full unlink process.
                    */
   
                   if (NULL != (next = nn->next))
                           next->prev = nn->prev;
   
                   if (NULL != (prev = nn->prev))
                           prev->next = nn->next;
   
                   nn->prev = nn->next = NULL;
   
                   /*
                    * Scan back until we reach a node that's
                    * ordered before `nn'.
                    */
   
                   for ( ; prev ; prev = prev->prev) {
                           /* Determine order of `prev'. */
                           for (j = 0; j < RSORD_MAX; j++)
                                   if (rsord[j] == prev->tok)
                                           break;
   
                           if (j <= i)
                                   break;
                   }
   
                   /*
                    * Set `nn' back into its correct place in front
                    * of the `prev' node.
                    */
   
                   nn->prev = prev;
   
                   if (prev) {
                           if (prev->next)
                                   prev->next->prev = nn;
                           nn->next = prev->next;
                           prev->next = nn;
                   } else {
                           mdoc->last->child->prev = nn;
                           nn->next = mdoc->last->child;
                           mdoc->last->child = nn;
                   }
           }
   
         return(1);          return(1);
 }  }
Legend:
Removed from v.1.118  
changed lines
  Added in v.1.122
CVSweb