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

version 1.113, 2010/07/21 09:08:26 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_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);
   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 100  static int  pre_display(PRE_ARGS);
Line 105  static int  pre_display(PRE_ARGS);
 static  int      pre_dt(PRE_ARGS);  static  int      pre_dt(PRE_ARGS);
 static  int      pre_it(PRE_ARGS);  static  int      pre_it(PRE_ARGS);
 static  int      pre_os(PRE_ARGS);  static  int      pre_os(PRE_ARGS);
   static  int      pre_pp(PRE_ARGS);
 static  int      pre_rv(PRE_ARGS);  static  int      pre_rv(PRE_ARGS);
 static  int      pre_sh(PRE_ARGS);  static  int      pre_sh(PRE_ARGS);
 static  int      pre_ss(PRE_ARGS);  static  int      pre_ss(PRE_ARGS);
Line 117  static v_post  posts_it[] = { post_it, NULL };
Line 123  static v_post  posts_it[] = { post_it, NULL };
 static  v_post   posts_lb[] = { eerr_eq1, post_lb, NULL };  static  v_post   posts_lb[] = { eerr_eq1, post_lb, NULL };
 static  v_post   posts_nd[] = { berr_ge1, NULL };  static  v_post   posts_nd[] = { berr_ge1, NULL };
 static  v_post   posts_nm[] = { post_nm, NULL };  static  v_post   posts_nm[] = { post_nm, NULL };
 static  v_post   posts_notext[] = { eerr_eq0, NULL };  static  v_post   posts_notext[] = { ewarn_eq0, NULL };
 static  v_post   posts_rs[] = { berr_ge1, herr_eq0, post_rs, NULL };  static  v_post   posts_rs[] = { berr_ge1, herr_eq0, post_rs, NULL };
 static  v_post   posts_sh[] = { herr_ge1, bwarn_ge1, post_sh, NULL };  static  v_post   posts_sh[] = { herr_ge1, bwarn_ge1, post_sh, NULL };
 static  v_post   posts_sp[] = { eerr_le1, NULL };  static  v_post   posts_sp[] = { eerr_le1, NULL };
Line 129  static v_post  posts_vt[] = { post_vt, NULL };
Line 135  static v_post  posts_vt[] = { post_vt, NULL };
 static  v_post   posts_wline[] = { bwarn_ge1, herr_eq0, NULL };  static  v_post   posts_wline[] = { bwarn_ge1, herr_eq0, NULL };
 static  v_post   posts_wtext[] = { ewarn_ge1, NULL };  static  v_post   posts_wtext[] = { ewarn_ge1, NULL };
 static  v_pre    pres_an[] = { pre_an, NULL };  static  v_pre    pres_an[] = { pre_an, NULL };
 static  v_pre    pres_bd[] = { pre_display, pre_bd, NULL };  static  v_pre    pres_bd[] = { pre_display, pre_bd, pre_pp, NULL };
 static  v_pre    pres_bl[] = { pre_bl, NULL };  static  v_pre    pres_bl[] = { pre_bl, pre_pp, NULL };
 static  v_pre    pres_d1[] = { pre_display, NULL };  static  v_pre    pres_d1[] = { pre_display, NULL };
 static  v_pre    pres_dd[] = { pre_dd, NULL };  static  v_pre    pres_dd[] = { pre_dd, NULL };
 static  v_pre    pres_dt[] = { pre_dt, NULL };  static  v_pre    pres_dt[] = { pre_dt, NULL };
Line 139  static v_pre  pres_ex[] = { NULL, NULL };
Line 145  static v_pre  pres_ex[] = { NULL, NULL };
 static  v_pre    pres_fd[] = { NULL, NULL };  static  v_pre    pres_fd[] = { NULL, NULL };
 static  v_pre    pres_it[] = { pre_it, NULL };  static  v_pre    pres_it[] = { pre_it, NULL };
 static  v_pre    pres_os[] = { pre_os, NULL };  static  v_pre    pres_os[] = { pre_os, NULL };
   static  v_pre    pres_pp[] = { pre_pp, NULL };
 static  v_pre    pres_rv[] = { pre_rv, NULL };  static  v_pre    pres_rv[] = { pre_rv, NULL };
 static  v_pre    pres_sh[] = { pre_sh, NULL };  static  v_pre    pres_sh[] = { pre_sh, NULL };
 static  v_pre    pres_ss[] = { pre_ss, NULL };  static  v_pre    pres_ss[] = { pre_ss, NULL };
   
 const   struct valids mdoc_valids[MDOC_MAX] = {  const   struct valids mdoc_valids[MDOC_MAX] = {
         { NULL, NULL },                         /* Ap */          { NULL, NULL },                         /* Ap */
         { pres_dd, posts_text },                /* Dd */          { pres_dd, posts_wtext },               /* Dd */
         { pres_dt, posts_dt },                  /* Dt */          { pres_dt, posts_dt },                  /* Dt */
         { pres_os, NULL },                      /* Os */          { pres_os, NULL },                      /* Os */
         { pres_sh, posts_sh },                  /* Sh */          { pres_sh, posts_sh },                  /* Sh */
         { pres_ss, posts_ss },                  /* Ss */          { pres_ss, posts_ss },                  /* Ss */
         { NULL, posts_notext },                 /* Pp */          { pres_pp, posts_notext },              /* Pp */
         { pres_d1, posts_wline },               /* D1 */          { pres_d1, posts_wline },               /* D1 */
         { pres_d1, posts_wline },               /* Dl */          { pres_d1, posts_wline },               /* Dl */
         { pres_bd, posts_bd_bk },               /* Bd */          { pres_bd, posts_bd_bk },               /* Bd */
Line 263  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 */
 };  };
Line 317  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(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(eq0, err, err_child_eq, 0)      /* eerr_eq0() */  
 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 481  check_text(struct mdoc *m, int ln, int pos, char *p)
Line 521  check_text(struct mdoc *m, int ln, int pos, char *p)
                 if (c) {                  if (c) {
                         p += c - 1;                          p += c - 1;
                         pos += c - 1;                          pos += c - 1;
                         continue;                  } else
                 }                          mdoc_pmsg(m, ln, pos, MANDOCERR_BADESCAPE);
   
                 c = mdoc_pmsg(m, ln, pos, MANDOCERR_BADESCAPE);  
                 if ( ! (MDOC_IGN_ESCAPE & m->pflags) && ! c)  
                         return(c);  
         }          }
   
         return(1);          return(1);
Line 864  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 1096  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 1193  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 1207  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));  
 }  }
   
   
Line 1467  post_sh_head(POST_ARGS)
Line 1507  post_sh_head(POST_ARGS)
                 break;                  break;
         }          }
   
           return(1);
   }
   
   
   static int
   pre_pp(PRE_ARGS)
   {
   
           if (NULL == mdoc->last)
                   return(1);
   
           /* Don't allow prior `Lp' or `Pp'. */
   
           if (MDOC_Pp != mdoc->last->tok && MDOC_Lp != mdoc->last->tok)
                   return(1);
   
           if (MDOC_Bl == n->tok && n->data.Bl->comp)
                   return(1);
           if (MDOC_Bd == n->tok && n->data.Bd->comp)
                   return(1);
   
           mdoc_nmsg(mdoc, mdoc->last, MANDOCERR_IGNPAR);
           mdoc_node_delete(mdoc, mdoc->last);
         return(1);          return(1);
 }  }
Legend:
Removed from v.1.113  
changed lines
  Added in v.1.120
CVSweb