[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.119 and 1.120

version 1.119, 2010/09/27 23:03:44 version 1.120, 2010/10/11 13:24:33
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 319  mdoc_valid_post(struct mdoc *mdoc)
Line 324  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 862  pre_an(PRE_ARGS)
Line 900  pre_an(PRE_ARGS)
                 if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_ARGCOUNT))                  if ( ! mdoc_nmsg(mdoc, n, MANDOCERR_ARGCOUNT))
                         return(0);                          return(0);
   
           /* FIXME: this should use a different error message. */
   
         if (MDOC_Split == n->args->argv[0].arg)          if (MDOC_Split == n->args->argv[0].arg)
                 n->data.An.auth = AUTH_split;                  n->data.An.auth = AUTH_split;
         else if (MDOC_Nosplit == n->args->argv[0].arg)          else if (MDOC_Nosplit == n->args->argv[0].arg)
Line 1094  post_an(POST_ARGS)
Line 1134  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 1235  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 1248  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));  
 }  }
   
   
Legend:
Removed from v.1.119  
changed lines
  Added in v.1.120
CVSweb