[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.272 and 1.295

version 1.272, 2015/02/06 01:07:22 version 1.295, 2015/10/12 00:08:16
Line 8 
Line 8 
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.   * copyright notice and this permission notice appear in all copies.
  *   *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF   * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
Line 31 
Line 31 
 #include <string.h>  #include <string.h>
 #include <time.h>  #include <time.h>
   
 #include "mdoc.h"  
 #include "mandoc.h"  
 #include "mandoc_aux.h"  #include "mandoc_aux.h"
 #include "libmdoc.h"  #include "mandoc.h"
   #include "roff.h"
   #include "mdoc.h"
 #include "libmandoc.h"  #include "libmandoc.h"
   #include "roff_int.h"
   #include "libmdoc.h"
   
 /* FIXME: .Bl -diag can't have non-text children in HEAD. */  /* FIXME: .Bl -diag can't have non-text children in HEAD. */
   
 #define PRE_ARGS  struct mdoc *mdoc, struct mdoc_node *n  #define PRE_ARGS  struct roff_man *mdoc, struct roff_node *n
 #define POST_ARGS struct mdoc *mdoc  #define POST_ARGS struct roff_man *mdoc
   
 enum    check_ineq {  enum    check_ineq {
         CHECK_LT,          CHECK_LT,
Line 56  struct valids {
Line 58  struct valids {
         v_post   post;          v_post   post;
 };  };
   
 static  void     check_count(struct mdoc *, enum mdoc_type,  static  void     check_text(struct roff_man *, int, int, char *);
                         enum check_ineq, int);  static  void     check_argv(struct roff_man *,
 static  void     check_text(struct mdoc *, int, int, char *);                          struct roff_node *, struct mdoc_argv *);
 static  void     check_argv(struct mdoc *,  static  void     check_args(struct roff_man *, struct roff_node *);
                         struct mdoc_node *, struct mdoc_argv *);  static  int      child_an(const struct roff_node *);
 static  void     check_args(struct mdoc *, struct mdoc_node *);  static  enum roff_sec   a2sec(const char *);
 static  int      child_an(const struct mdoc_node *);  static  size_t          macro2len(int);
 static  enum mdoc_sec   a2sec(const char *);  
 static  size_t          macro2len(enum mdoct);  
 static  void     rewrite_macro2len(char **);  static  void     rewrite_macro2len(char **);
   
 static  void     bwarn_ge1(POST_ARGS);  
 static  void     ewarn_eq1(POST_ARGS);  
 static  void     ewarn_ge1(POST_ARGS);  
   
 static  void     post_an(POST_ARGS);  static  void     post_an(POST_ARGS);
 static  void     post_at(POST_ARGS);  static  void     post_at(POST_ARGS);
 static  void     post_bf(POST_ARGS);  static  void     post_bf(POST_ARGS);
Line 93  static void  post_fn(POST_ARGS);
Line 89  static void  post_fn(POST_ARGS);
 static  void     post_fname(POST_ARGS);  static  void     post_fname(POST_ARGS);
 static  void     post_fo(POST_ARGS);  static  void     post_fo(POST_ARGS);
 static  void     post_hyph(POST_ARGS);  static  void     post_hyph(POST_ARGS);
 static  void     post_hyphtext(POST_ARGS);  
 static  void     post_ignpar(POST_ARGS);  static  void     post_ignpar(POST_ARGS);
 static  void     post_it(POST_ARGS);  static  void     post_it(POST_ARGS);
 static  void     post_lb(POST_ARGS);  static  void     post_lb(POST_ARGS);
Line 112  static void  post_sh_see_also(POST_ARGS);
Line 107  static void  post_sh_see_also(POST_ARGS);
 static  void     post_sh_authors(POST_ARGS);  static  void     post_sh_authors(POST_ARGS);
 static  void     post_sm(POST_ARGS);  static  void     post_sm(POST_ARGS);
 static  void     post_st(POST_ARGS);  static  void     post_st(POST_ARGS);
 static  void     post_vt(POST_ARGS);  
   
 static  void     pre_an(PRE_ARGS);  static  void     pre_an(PRE_ARGS);
 static  void     pre_bd(PRE_ARGS);  static  void     pre_bd(PRE_ARGS);
Line 151  static const struct valids mdoc_valids[MDOC_MAX] = {
Line 145  static const struct valids mdoc_valids[MDOC_MAX] = {
         { NULL, NULL },                         /* Ev */          { NULL, NULL },                         /* Ev */
         { pre_std, post_ex },                   /* Ex */          { pre_std, post_ex },                   /* Ex */
         { NULL, post_fa },                      /* Fa */          { NULL, post_fa },                      /* Fa */
         { NULL, ewarn_ge1 },                    /* Fd */          { NULL, NULL },                         /* Fd */
         { NULL, NULL },                         /* Fl */          { NULL, NULL },                         /* Fl */
         { NULL, post_fn },                      /* Fn */          { NULL, post_fn },                      /* Fn */
         { NULL, NULL },                         /* Ft */          { NULL, NULL },                         /* Ft */
Line 166  static const struct valids mdoc_valids[MDOC_MAX] = {
Line 160  static const struct valids mdoc_valids[MDOC_MAX] = {
         { pre_std, NULL },                      /* Rv */          { pre_std, NULL },                      /* Rv */
         { NULL, post_st },                      /* St */          { NULL, post_st },                      /* St */
         { NULL, NULL },                         /* Va */          { NULL, NULL },                         /* Va */
         { NULL, post_vt },                      /* Vt */          { NULL, NULL },                         /* Vt */
         { NULL, NULL },                         /* Xr */          { NULL, NULL },                         /* Xr */
         { NULL, ewarn_ge1 },                    /* %A */          { NULL, NULL },                         /* %A */
         { NULL, post_hyphtext },                /* %B */ /* FIXME: can be used outside Rs/Re. */          { NULL, post_hyph },                    /* %B */ /* FIXME: can be used outside Rs/Re. */
         { NULL, ewarn_ge1 },                    /* %D */          { NULL, NULL },                         /* %D */
         { NULL, ewarn_ge1 },                    /* %I */          { NULL, NULL },                         /* %I */
         { NULL, ewarn_ge1 },                    /* %J */          { NULL, NULL },                         /* %J */
         { NULL, post_hyphtext },                /* %N */          { NULL, post_hyph },                    /* %N */
         { NULL, post_hyphtext },                /* %O */          { NULL, post_hyph },                    /* %O */
         { NULL, ewarn_ge1 },                    /* %P */          { NULL, NULL },                         /* %P */
         { NULL, post_hyphtext },                /* %R */          { NULL, post_hyph },                    /* %R */
         { NULL, post_hyphtext },                /* %T */ /* FIXME: can be used outside Rs/Re. */          { NULL, post_hyph },                    /* %T */ /* FIXME: can be used outside Rs/Re. */
         { NULL, ewarn_ge1 },                    /* %V */          { NULL, NULL },                         /* %V */
         { NULL, NULL },                         /* Ac */          { NULL, NULL },                         /* Ac */
         { NULL, NULL },                         /* Ao */          { NULL, NULL },                         /* Ao */
         { NULL, NULL },                         /* Aq */          { NULL, NULL },                         /* Aq */
Line 240  static const struct valids mdoc_valids[MDOC_MAX] = {
Line 234  static const struct valids mdoc_valids[MDOC_MAX] = {
         { NULL, NULL },                         /* Brq */          { NULL, NULL },                         /* Brq */
         { NULL, NULL },                         /* Bro */          { NULL, NULL },                         /* Bro */
         { NULL, NULL },                         /* Brc */          { NULL, NULL },                         /* Brc */
         { NULL, ewarn_ge1 },                    /* %C */          { NULL, NULL },                         /* %C */
         { pre_obsolete, post_es },              /* Es */          { pre_obsolete, post_es },              /* Es */
         { pre_obsolete, post_en },              /* En */          { pre_obsolete, post_en },              /* En */
         { NULL, NULL },                         /* Dx */          { NULL, NULL },                         /* Dx */
         { NULL, ewarn_ge1 },                    /* %Q */          { NULL, NULL },                         /* %Q */
         { NULL, post_par },                     /* br */          { NULL, post_par },                     /* br */
         { NULL, post_par },                     /* sp */          { NULL, post_par },                     /* sp */
         { NULL, ewarn_eq1 },                    /* %U */          { NULL, NULL },                         /* %U */
         { NULL, NULL },                         /* Ta */          { NULL, NULL },                         /* Ta */
         { NULL, NULL },                         /* ll */          { NULL, NULL },                         /* ll */
 };  };
   
 #define RSORD_MAX 14 /* Number of `Rs' blocks. */  #define RSORD_MAX 14 /* Number of `Rs' blocks. */
   
 static  const enum mdoct rsord[RSORD_MAX] = {  static  const int rsord[RSORD_MAX] = {
         MDOC__A,          MDOC__A,
         MDOC__T,          MDOC__T,
         MDOC__B,          MDOC__B,
Line 299  static const char * const secnames[SEC__MAX] = {
Line 293  static const char * const secnames[SEC__MAX] = {
   
   
 void  void
 mdoc_valid_pre(struct mdoc *mdoc, struct mdoc_node *n)  mdoc_valid_pre(struct roff_man *mdoc, struct roff_node *n)
 {  {
         v_pre    p;          v_pre    p;
   
         switch (n->type) {          switch (n->type) {
         case MDOC_TEXT:          case ROFFT_TEXT:
                 check_text(mdoc, n->line, n->pos, n->string);                  if (n->sec != SEC_SYNOPSIS || n->parent->tok != MDOC_Fd)
                 /* FALLTHROUGH */                          check_text(mdoc, n->line, n->pos, n->string);
         case MDOC_TBL:  
                 /* FALLTHROUGH */  
         case MDOC_EQN:  
                 /* FALLTHROUGH */  
         case MDOC_ROOT:  
                 return;                  return;
           case ROFFT_TBL:
           case ROFFT_EQN:
           case ROFFT_ROOT:
                   return;
         default:          default:
                 break;                  break;
         }          }
Line 324  mdoc_valid_pre(struct mdoc *mdoc, struct mdoc_node *n)
Line 317  mdoc_valid_pre(struct mdoc *mdoc, struct mdoc_node *n)
 }  }
   
 void  void
 mdoc_valid_post(struct mdoc *mdoc)  mdoc_valid_post(struct roff_man *mdoc)
 {  {
         struct mdoc_node *n;          struct roff_node *n;
         v_post p;          v_post p;
   
         n = mdoc->last;          n = mdoc->last;
         if (n->flags & MDOC_VALID)          if (n->flags & MDOC_VALID)
                 return;                  return;
         n->flags |= MDOC_VALID;          n->flags |= MDOC_VALID | MDOC_ENDED;
   
         switch (n->type) {          switch (n->type) {
         case MDOC_TEXT:          case ROFFT_TEXT:
                 /* FALLTHROUGH */          case ROFFT_EQN:
         case MDOC_EQN:          case ROFFT_TBL:
                 /* FALLTHROUGH */  
         case MDOC_TBL:  
                 break;                  break;
         case MDOC_ROOT:          case ROFFT_ROOT:
                 post_root(mdoc);                  post_root(mdoc);
                 break;                  break;
         default:          default:
Line 367  mdoc_valid_post(struct mdoc *mdoc)
Line 358  mdoc_valid_post(struct mdoc *mdoc)
 }  }
   
 static void  static void
 check_count(struct mdoc *mdoc, enum mdoc_type type,  check_args(struct roff_man *mdoc, struct roff_node *n)
         enum check_ineq ineq, int val)  
 {  {
         const char      *p;  
   
         if (mdoc->last->type != type)  
                 return;  
   
         switch (ineq) {  
         case CHECK_LT:  
                 p = "less than ";  
                 if (mdoc->last->nchild < val)  
                         return;  
                 break;  
         case CHECK_GT:  
                 p = "more than ";  
                 if (mdoc->last->nchild > val)  
                         return;  
                 break;  
         case CHECK_EQ:  
                 p = "";  
                 if (val == mdoc->last->nchild)  
                         return;  
                 break;  
         default:  
                 abort();  
                 /* NOTREACHED */  
         }  
   
         mandoc_vmsg(MANDOCERR_ARGCWARN, mdoc->parse, mdoc->last->line,  
             mdoc->last->pos, "want %s%d children (have %d)",  
             p, val, mdoc->last->nchild);  
 }  
   
 static void  
 bwarn_ge1(POST_ARGS)  
 {  
         check_count(mdoc, MDOC_BODY, CHECK_GT, 0);  
 }  
   
 static void  
 ewarn_eq1(POST_ARGS)  
 {  
         check_count(mdoc, MDOC_ELEM, CHECK_EQ, 1);  
 }  
   
 static void  
 ewarn_ge1(POST_ARGS)  
 {  
         check_count(mdoc, MDOC_ELEM, CHECK_GT, 0);  
 }  
   
 static void  
 check_args(struct mdoc *mdoc, struct mdoc_node *n)  
 {  
         int              i;          int              i;
   
         if (NULL == n->args)          if (NULL == n->args)
Line 433  check_args(struct mdoc *mdoc, struct mdoc_node *n)
Line 371  check_args(struct mdoc *mdoc, struct mdoc_node *n)
 }  }
   
 static void  static void
 check_argv(struct mdoc *mdoc, struct mdoc_node *n, struct mdoc_argv *v)  check_argv(struct roff_man *mdoc, struct roff_node *n, struct mdoc_argv *v)
 {  {
         int              i;          int              i;
   
Line 442  check_argv(struct mdoc *mdoc, struct mdoc_node *n, str
Line 380  check_argv(struct mdoc *mdoc, struct mdoc_node *n, str
 }  }
   
 static void  static void
 check_text(struct mdoc *mdoc, int ln, int pos, char *p)  check_text(struct roff_man *mdoc, int ln, int pos, char *p)
 {  {
         char            *cp;          char            *cp;
   
Line 457  check_text(struct mdoc *mdoc, int ln, int pos, char *p
Line 395  check_text(struct mdoc *mdoc, int ln, int pos, char *p
 static void  static void
 pre_display(PRE_ARGS)  pre_display(PRE_ARGS)
 {  {
         struct mdoc_node *node;          struct roff_node *node;
   
         if (MDOC_BLOCK != n->type)          if (n->type != ROFFT_BLOCK)
                 return;                  return;
   
         for (node = mdoc->last->parent; node; node = node->parent)          for (node = mdoc->last->parent; node; node = node->parent)
                 if (MDOC_BLOCK == node->type)                  if (node->type == ROFFT_BLOCK)
                         if (MDOC_Bd == node->tok)                          if (MDOC_Bd == node->tok)
                                 break;                                  break;
   
Line 476  pre_display(PRE_ARGS)
Line 414  pre_display(PRE_ARGS)
 static void  static void
 pre_bl(PRE_ARGS)  pre_bl(PRE_ARGS)
 {  {
         struct mdoc_node *np;  
         struct mdoc_argv *argv, *wa;          struct mdoc_argv *argv, *wa;
         int               i;          int               i;
         enum mdocargt     mdoclt;          enum mdocargt     mdoclt;
         enum mdoc_list    lt;          enum mdoc_list    lt;
   
         if (MDOC_BLOCK != n->type) {          if (n->type != ROFFT_BLOCK)
                 if (ENDBODY_NOT != n->end) {  
                         assert(n->pending);  
                         np = n->pending->parent;  
                 } else  
                         np = n->parent;  
   
                 assert(np);  
                 assert(MDOC_BLOCK == np->type);  
                 assert(MDOC_Bl == np->tok);  
                 return;                  return;
         }  
   
         /*          /*
          * First figure out which kind of list to use: bind ourselves to           * First figure out which kind of list to use: bind ourselves to
Line 635  pre_bl(PRE_ARGS)
Line 562  pre_bl(PRE_ARGS)
                             n->line, n->pos, "Bl -tag");                              n->line, n->pos, "Bl -tag");
                 break;                  break;
         case LIST_column:          case LIST_column:
                 /* FALLTHROUGH */  
         case LIST_diag:          case LIST_diag:
                 /* FALLTHROUGH */  
         case LIST_ohang:          case LIST_ohang:
                 /* FALLTHROUGH */  
         case LIST_inset:          case LIST_inset:
                 /* FALLTHROUGH */  
         case LIST_item:          case LIST_item:
                 if (n->norm->Bl.width)                  if (n->norm->Bl.width)
                         mandoc_vmsg(MANDOCERR_BL_SKIPW, mdoc->parse,                          mandoc_vmsg(MANDOCERR_BL_SKIPW, mdoc->parse,
Line 649  pre_bl(PRE_ARGS)
Line 572  pre_bl(PRE_ARGS)
                             mdoc_argnames[mdoclt]);                              mdoc_argnames[mdoclt]);
                 break;                  break;
         case LIST_bullet:          case LIST_bullet:
                 /* FALLTHROUGH */  
         case LIST_dash:          case LIST_dash:
                 /* FALLTHROUGH */  
         case LIST_hyphen:          case LIST_hyphen:
                 if (NULL == n->norm->Bl.width)                  if (NULL == n->norm->Bl.width)
                         n->norm->Bl.width = "2n";                          n->norm->Bl.width = "2n";
Line 669  pre_bl(PRE_ARGS)
Line 590  pre_bl(PRE_ARGS)
 static void  static void
 pre_bd(PRE_ARGS)  pre_bd(PRE_ARGS)
 {  {
         struct mdoc_node *np;  
         struct mdoc_argv *argv;          struct mdoc_argv *argv;
         int               i;          int               i;
         enum mdoc_disp    dt;          enum mdoc_disp    dt;
   
         pre_literal(mdoc, n);          pre_literal(mdoc, n);
   
         if (MDOC_BLOCK != n->type) {          if (n->type != ROFFT_BLOCK)
                 if (ENDBODY_NOT != n->end) {  
                         assert(n->pending);  
                         np = n->pending->parent;  
                 } else  
                         np = n->parent;  
   
                 assert(np);  
                 assert(MDOC_BLOCK == np->type);  
                 assert(MDOC_Bd == np->tok);  
                 return;                  return;
         }  
   
         for (i = 0; n->args && i < (int)n->args->argc; i++) {          for (i = 0; n->args && i < (int)n->args->argc; i++) {
                 argv = n->args->argv + i;                  argv = n->args->argv + i;
Line 737  pre_bd(PRE_ARGS)
Line 647  pre_bd(PRE_ARGS)
                         break;                          break;
                 default:                  default:
                         abort();                          abort();
                         /* NOTREACHED */  
                 }                  }
                 if (DISP__NONE == dt)                  if (DISP__NONE == dt)
                         continue;                          continue;
Line 799  static void
Line 708  static void
 pre_obsolete(PRE_ARGS)  pre_obsolete(PRE_ARGS)
 {  {
   
         if (MDOC_ELEM == n->type || MDOC_BLOCK == n->type)          if (n->type == ROFFT_ELEM || n->type == ROFFT_BLOCK)
                 mandoc_msg(MANDOCERR_MACRO_OBS, mdoc->parse,                  mandoc_msg(MANDOCERR_MACRO_OBS, mdoc->parse,
                     n->line, n->pos, mdoc_macronames[n->tok]);                      n->line, n->pos, mdoc_macronames[n->tok]);
 }  }
Line 849  pre_dd(PRE_ARGS)
Line 758  pre_dd(PRE_ARGS)
 static void  static void
 post_bf(POST_ARGS)  post_bf(POST_ARGS)
 {  {
         struct mdoc_node *np, *nch;          struct roff_node *np, *nch;
         enum mdocargt     arg;          enum mdocargt     arg;
   
         /*          /*
Line 857  post_bf(POST_ARGS)
Line 766  post_bf(POST_ARGS)
          * element, which contains the goods.           * element, which contains the goods.
          */           */
   
         if (MDOC_HEAD != mdoc->last->type) {          np = mdoc->last;
                 if (ENDBODY_NOT != mdoc->last->end) {          if (np->type != ROFFT_HEAD)
                         assert(mdoc->last->pending);  
                         np = mdoc->last->pending->parent->head;  
                 } else if (MDOC_BLOCK != mdoc->last->type) {  
                         np = mdoc->last->parent->head;  
                 } else  
                         np = mdoc->last->head;  
   
                 assert(np);  
                 assert(MDOC_HEAD == np->type);  
                 assert(MDOC_Bf == np->tok);  
                 return;                  return;
         }  
   
         np = mdoc->last;          assert(np->parent->type == ROFFT_BLOCK);
         assert(MDOC_BLOCK == np->parent->type);  
         assert(MDOC_Bf == np->parent->tok);          assert(MDOC_Bf == np->parent->tok);
   
         /* Check the number of arguments. */          /* Check the number of arguments. */
Line 923  post_bf(POST_ARGS)
Line 820  post_bf(POST_ARGS)
 static void  static void
 post_lb(POST_ARGS)  post_lb(POST_ARGS)
 {  {
         struct mdoc_node        *n;          struct roff_node        *n;
         const char              *stdlibname;          const char              *stdlibname;
         char                    *libname;          char                    *libname;
   
         check_count(mdoc, MDOC_ELEM, CHECK_EQ, 1);  
         n = mdoc->last->child;          n = mdoc->last->child;
         assert(MDOC_TEXT == n->type);          assert(n->type == ROFFT_TEXT);
   
         if (NULL == (stdlibname = mdoc_a2lib(n->string)))          if (NULL == (stdlibname = mdoc_a2lib(n->string)))
                 mandoc_asprintf(&libname,                  mandoc_asprintf(&libname,
                     "library \\(lq%s\\(rq", n->string);                      "library \\(Lq%s\\(Rq", n->string);
         else          else
                 libname = mandoc_strdup(stdlibname);                  libname = mandoc_strdup(stdlibname);
   
Line 944  post_lb(POST_ARGS)
Line 840  post_lb(POST_ARGS)
 static void  static void
 post_eoln(POST_ARGS)  post_eoln(POST_ARGS)
 {  {
         const struct mdoc_node *n;          const struct roff_node *n;
   
         n = mdoc->last;          n = mdoc->last;
         if (n->child)          if (n->child)
Line 957  post_eoln(POST_ARGS)
Line 853  post_eoln(POST_ARGS)
 static void  static void
 post_fname(POST_ARGS)  post_fname(POST_ARGS)
 {  {
         const struct mdoc_node  *n;          const struct roff_node  *n;
         const char              *cp;          const char              *cp;
         size_t                   pos;          size_t                   pos;
   
Line 980  post_fn(POST_ARGS)
Line 876  post_fn(POST_ARGS)
 static void  static void
 post_fo(POST_ARGS)  post_fo(POST_ARGS)
 {  {
           const struct roff_node  *n;
   
         check_count(mdoc, MDOC_HEAD, CHECK_EQ, 1);          n = mdoc->last;
         bwarn_ge1(mdoc);  
         if (mdoc->last->type == MDOC_HEAD && mdoc->last->nchild)          if (n->type != ROFFT_HEAD)
                 post_fname(mdoc);                  return;
   
           if (n->child == NULL) {
                   mandoc_msg(MANDOCERR_FO_NOHEAD, mdoc->parse,
                       n->line, n->pos, "Fo");
                   return;
           }
           if (n->child != n->last) {
                   mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
                       n->child->next->line, n->child->next->pos,
                       "Fo ... %s", n->child->next->string);
                   while (n->child != n->last)
                           roff_node_delete(mdoc, n->last);
           }
   
           post_fname(mdoc);
 }  }
   
 static void  static void
 post_fa(POST_ARGS)  post_fa(POST_ARGS)
 {  {
         const struct mdoc_node *n;          const struct roff_node *n;
         const char *cp;          const char *cp;
   
         for (n = mdoc->last->child; n != NULL; n = n->next) {          for (n = mdoc->last->child; n != NULL; n = n->next) {
Line 1009  post_fa(POST_ARGS)
Line 921  post_fa(POST_ARGS)
 }  }
   
 static void  static void
 post_vt(POST_ARGS)  
 {  
         const struct mdoc_node *n;  
   
         /*  
          * The Vt macro comes in both ELEM and BLOCK form, both of which  
          * have different syntaxes (yet more context-sensitive  
          * behaviour).  ELEM types must have a child, which is already  
          * guaranteed by the in_line parsing routine; BLOCK types,  
          * specifically the BODY, should only have TEXT children.  
          */  
   
         if (MDOC_BODY != mdoc->last->type)  
                 return;  
   
         for (n = mdoc->last->child; n; n = n->next)  
                 if (MDOC_TEXT != n->type)  
                         mandoc_msg(MANDOCERR_VT_CHILD, mdoc->parse,  
                             n->line, n->pos, mdoc_macronames[n->tok]);  
 }  
   
 static void  
 post_nm(POST_ARGS)  post_nm(POST_ARGS)
 {  {
         struct mdoc_node        *n;          struct roff_node        *n;
   
         n = mdoc->last;          n = mdoc->last;
   
Line 1045  post_nm(POST_ARGS)
Line 935  post_nm(POST_ARGS)
         if (NULL != mdoc->meta.name)          if (NULL != mdoc->meta.name)
                 return;                  return;
   
         mdoc_deroff(&mdoc->meta.name, n);          deroff(&mdoc->meta.name, n);
   
         if (NULL == mdoc->meta.name)          if (NULL == mdoc->meta.name)
                 mandoc_msg(MANDOCERR_NM_NONAME, mdoc->parse,                  mandoc_msg(MANDOCERR_NM_NONAME, mdoc->parse,
Line 1055  post_nm(POST_ARGS)
Line 945  post_nm(POST_ARGS)
 static void  static void
 post_nd(POST_ARGS)  post_nd(POST_ARGS)
 {  {
         struct mdoc_node        *n;          struct roff_node        *n;
   
         n = mdoc->last;          n = mdoc->last;
   
         if (n->type != MDOC_BODY)          if (n->type != ROFFT_BODY)
                 return;                  return;
   
         if (n->child == NULL)          if (n->child == NULL)
Line 1072  post_nd(POST_ARGS)
Line 962  post_nd(POST_ARGS)
 static void  static void
 post_d1(POST_ARGS)  post_d1(POST_ARGS)
 {  {
           struct roff_node        *n;
   
         bwarn_ge1(mdoc);          n = mdoc->last;
   
           if (n->type != ROFFT_BODY)
                   return;
   
           if (n->child == NULL)
                   mandoc_msg(MANDOCERR_BLK_EMPTY, mdoc->parse,
                       n->line, n->pos, "D1");
   
         post_hyph(mdoc);          post_hyph(mdoc);
 }  }
   
 static void  static void
 post_literal(POST_ARGS)  post_literal(POST_ARGS)
 {  {
           struct roff_node        *n;
   
         bwarn_ge1(mdoc);          n = mdoc->last;
   
         /*          if (n->type != ROFFT_BODY)
          * The `Dl' (note "el" not "one") and `Bd' macros unset the                  return;
          * MDOC_LITERAL flag as they leave.  Note that `Bd' only sets  
          * this in literal mode, but it doesn't hurt to just switch it  
          * off in general since displays can't be nested.  
          */  
   
         if (MDOC_BODY == mdoc->last->type)          if (n->child == NULL)
                 mdoc->flags &= ~MDOC_LITERAL;                  mandoc_msg(MANDOCERR_BLK_EMPTY, mdoc->parse,
                       n->line, n->pos, mdoc_macronames[n->tok]);
   
           if (n->tok == MDOC_Bd &&
               n->norm->Bd.type != DISP_literal &&
               n->norm->Bd.type != DISP_unfilled)
                   return;
   
           mdoc->flags &= ~MDOC_LITERAL;
 }  }
   
 static void  static void
 post_defaults(POST_ARGS)  post_defaults(POST_ARGS)
 {  {
         struct mdoc_node *nn;          struct roff_node *nn;
   
         /*          /*
          * The `Ar' defaults to "file ..." if no value is provided as an           * The `Ar' defaults to "file ..." if no value is provided as an
Line 1109  post_defaults(POST_ARGS)
Line 1013  post_defaults(POST_ARGS)
                 return;                  return;
   
         nn = mdoc->last;          nn = mdoc->last;
         mdoc->next = MDOC_NEXT_CHILD;          mdoc->next = ROFF_NEXT_CHILD;
   
         switch (nn->tok) {          switch (nn->tok) {
         case MDOC_Ar:          case MDOC_Ar:
                 mdoc_word_alloc(mdoc, nn->line, nn->pos, "file");                  roff_word_alloc(mdoc, nn->line, nn->pos, "file");
                 mdoc_word_alloc(mdoc, nn->line, nn->pos, "...");                  roff_word_alloc(mdoc, nn->line, nn->pos, "...");
                 break;                  break;
         case MDOC_Pa:          case MDOC_Pa:
                 /* FALLTHROUGH */  
         case MDOC_Mt:          case MDOC_Mt:
                 mdoc_word_alloc(mdoc, nn->line, nn->pos, "~");                  roff_word_alloc(mdoc, nn->line, nn->pos, "~");
                 break;                  break;
         default:          default:
                 abort();                  abort();
                 /* NOTREACHED */  
         }          }
         mdoc->last = nn;          mdoc->last = nn;
 }  }
Line 1131  post_defaults(POST_ARGS)
Line 1033  post_defaults(POST_ARGS)
 static void  static void
 post_at(POST_ARGS)  post_at(POST_ARGS)
 {  {
         struct mdoc_node        *n;          struct roff_node        *n;
         const char              *std_att;          const char              *std_att;
         char                    *att;          char                    *att;
   
         n = mdoc->last;          n = mdoc->last;
         if (n->child == NULL) {          if (n->child == NULL) {
                 mdoc->next = MDOC_NEXT_CHILD;                  mdoc->next = ROFF_NEXT_CHILD;
                 mdoc_word_alloc(mdoc, n->line, n->pos, "AT&T UNIX");                  roff_word_alloc(mdoc, n->line, n->pos, "AT&T UNIX");
                 mdoc->last = n;                  mdoc->last = n;
                 return;                  return;
         }          }
Line 1150  post_at(POST_ARGS)
Line 1052  post_at(POST_ARGS)
          */           */
   
         n = n->child;          n = n->child;
         assert(MDOC_TEXT == n->type);          assert(n->type == ROFFT_TEXT);
         if (NULL == (std_att = mdoc_a2att(n->string))) {          if (NULL == (std_att = mdoc_a2att(n->string))) {
                 mandoc_vmsg(MANDOCERR_AT_BAD, mdoc->parse,                  mandoc_vmsg(MANDOCERR_AT_BAD, mdoc->parse,
                     n->line, n->pos, "At %s", n->string);                      n->line, n->pos, "At %s", n->string);
Line 1165  post_at(POST_ARGS)
Line 1067  post_at(POST_ARGS)
 static void  static void
 post_an(POST_ARGS)  post_an(POST_ARGS)
 {  {
         struct mdoc_node *np, *nch;          struct roff_node *np, *nch;
   
         np = mdoc->last;          np = mdoc->last;
         nch = np->child;          nch = np->child;
Line 1182  static void
Line 1084  static void
 post_en(POST_ARGS)  post_en(POST_ARGS)
 {  {
   
         if (MDOC_BLOCK == mdoc->last->type)          if (mdoc->last->type == ROFFT_BLOCK)
                 mdoc->last->norm->Es = mdoc->last_es;                  mdoc->last->norm->Es = mdoc->last_es;
 }  }
   
Line 1196  post_es(POST_ARGS)
Line 1098  post_es(POST_ARGS)
 static void  static void
 post_it(POST_ARGS)  post_it(POST_ARGS)
 {  {
           struct roff_node *nbl, *nit, *nch;
         int               i, cols;          int               i, cols;
         enum mdoc_list    lt;          enum mdoc_list    lt;
         struct mdoc_node *nbl, *nit, *nch;  
   
         nit = mdoc->last;          nit = mdoc->last;
         if (nit->type != MDOC_BLOCK)          if (nit->type != ROFFT_BLOCK)
                 return;                  return;
   
         nbl = nit->parent->parent;          nbl = nit->parent->parent;
Line 1209  post_it(POST_ARGS)
Line 1111  post_it(POST_ARGS)
   
         switch (lt) {          switch (lt) {
         case LIST_tag:          case LIST_tag:
                 /* FALLTHROUGH */  
         case LIST_hang:          case LIST_hang:
                 /* FALLTHROUGH */  
         case LIST_ohang:          case LIST_ohang:
                 /* FALLTHROUGH */  
         case LIST_inset:          case LIST_inset:
                 /* FALLTHROUGH */  
         case LIST_diag:          case LIST_diag:
                 if (nit->head->child == NULL)                  if (nit->head->child == NULL)
                         mandoc_vmsg(MANDOCERR_IT_NOHEAD,                          mandoc_vmsg(MANDOCERR_IT_NOHEAD,
Line 1224  post_it(POST_ARGS)
Line 1122  post_it(POST_ARGS)
                             mdoc_argnames[nbl->args->argv[0].arg]);                              mdoc_argnames[nbl->args->argv[0].arg]);
                 break;                  break;
         case LIST_bullet:          case LIST_bullet:
                 /* FALLTHROUGH */  
         case LIST_dash:          case LIST_dash:
                 /* FALLTHROUGH */  
         case LIST_enum:          case LIST_enum:
                 /* FALLTHROUGH */  
         case LIST_hyphen:          case LIST_hyphen:
                 if (nit->body == NULL || nit->body->child == NULL)                  if (nit->body == NULL || nit->body->child == NULL)
                         mandoc_vmsg(MANDOCERR_IT_NOBODY,                          mandoc_vmsg(MANDOCERR_IT_NOBODY,
Line 1248  post_it(POST_ARGS)
Line 1143  post_it(POST_ARGS)
                 assert(nit->head->child == NULL);                  assert(nit->head->child == NULL);
   
                 for (i = 0, nch = nit->child; nch; nch = nch->next)                  for (i = 0, nch = nit->child; nch; nch = nch->next)
                         if (nch->type == MDOC_BODY)                          if (nch->type == ROFFT_BODY)
                                 i++;                                  i++;
   
                 if (i < cols || i > cols + 1)                  if (i < cols || i > cols + 1)
                         mandoc_vmsg(MANDOCERR_ARGCOUNT,                          mandoc_vmsg(MANDOCERR_BL_COL,
                             mdoc->parse, nit->line, nit->pos,                              mdoc->parse, nit->line, nit->pos,
                             "columns == %d (have %d)", cols, i);                              "%d columns, %d cells", cols, i);
                 break;                  break;
         default:          default:
                 abort();                  abort();
Line 1264  post_it(POST_ARGS)
Line 1159  post_it(POST_ARGS)
 static void  static void
 post_bl_block(POST_ARGS)  post_bl_block(POST_ARGS)
 {  {
         struct mdoc_node *n, *ni, *nc;          struct roff_node *n, *ni, *nc;
   
         /*          /*
          * These are fairly complicated, so we've broken them into two           * These are fairly complicated, so we've broken them into two
Line 1289  post_bl_block(POST_ARGS)
Line 1184  post_bl_block(POST_ARGS)
                 while (NULL != nc) {                  while (NULL != nc) {
                         switch (nc->tok) {                          switch (nc->tok) {
                         case MDOC_Pp:                          case MDOC_Pp:
                                 /* FALLTHROUGH */  
                         case MDOC_Lp:                          case MDOC_Lp:
                                 /* FALLTHROUGH */  
                         case MDOC_br:                          case MDOC_br:
                                 break;                                  break;
                         default:                          default:
Line 1309  post_bl_block(POST_ARGS)
Line 1202  post_bl_block(POST_ARGS)
                                     mdoc->parse, nc->line, nc->pos,                                      mdoc->parse, nc->line, nc->pos,
                                     "%s before It",                                      "%s before It",
                                     mdoc_macronames[nc->tok]);                                      mdoc_macronames[nc->tok]);
                                 mdoc_node_delete(mdoc, nc);                                  roff_node_delete(mdoc, nc);
                         } else                          } else
                                 break;                                  break;
                         nc = ni->body->last;                          nc = ni->body->last;
Line 1325  void
Line 1218  void
 rewrite_macro2len(char **arg)  rewrite_macro2len(char **arg)
 {  {
         size_t            width;          size_t            width;
         enum mdoct        tok;          int               tok;
   
         if (*arg == NULL)          if (*arg == NULL)
                 return;                  return;
         else if ( ! strcmp(*arg, "Ds"))          else if ( ! strcmp(*arg, "Ds"))
                 width = 6;                  width = 6;
         else if ((tok = mdoc_hash_find(*arg)) == MDOC_MAX)          else if ((tok = mdoc_hash_find(*arg)) == TOKEN_NONE)
                 return;                  return;
         else          else
                 width = macro2len(tok);                  width = macro2len(tok);
Line 1343  rewrite_macro2len(char **arg)
Line 1236  rewrite_macro2len(char **arg)
 static void  static void
 post_bl_block_tag(POST_ARGS)  post_bl_block_tag(POST_ARGS)
 {  {
         struct mdoc_node *n, *nn;          struct roff_node *n, *nn;
         size_t            sz, ssz;          size_t            sz, ssz;
         int               i;          int               i;
         char              buf[24];          char              buf[24];
Line 1362  post_bl_block_tag(POST_ARGS)
Line 1255  post_bl_block_tag(POST_ARGS)
                 if (MDOC_It != nn->tok)                  if (MDOC_It != nn->tok)
                         continue;                          continue;
   
                 assert(MDOC_BLOCK == nn->type);                  assert(nn->type == ROFFT_BLOCK);
                 nn = nn->head->child;                  nn = nn->head->child;
   
                 if (nn == NULL)                  if (nn == NULL)
                         break;                          break;
   
                 if (MDOC_TEXT == nn->type) {                  if (nn->type == ROFFT_TEXT) {
                         sz = strlen(nn->string) + 1;                          sz = strlen(nn->string) + 1;
                         break;                          break;
                 }                  }
Line 1408  post_bl_block_tag(POST_ARGS)
Line 1301  post_bl_block_tag(POST_ARGS)
 static void  static void
 post_bl_head(POST_ARGS)  post_bl_head(POST_ARGS)
 {  {
         struct mdoc_node *nbl, *nh, *nch, *nnext;          struct roff_node *nbl, *nh, *nch, *nnext;
         struct mdoc_argv *argv;          struct mdoc_argv *argv;
         int               i, j;          int               i, j;
   
Line 1420  post_bl_head(POST_ARGS)
Line 1313  post_bl_head(POST_ARGS)
                 mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,                  mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
                     nch->line, nch->pos, "Bl ... %s", nch->string);                      nch->line, nch->pos, "Bl ... %s", nch->string);
                 while (nch != NULL) {                  while (nch != NULL) {
                         mdoc_node_delete(mdoc, nch);                          roff_node_delete(mdoc, nch);
                         nch = nh->child;                          nch = nh->child;
                 }                  }
                 return;                  return;
Line 1461  post_bl_head(POST_ARGS)
Line 1354  post_bl_head(POST_ARGS)
                 argv->value[i++] = nch->string;                  argv->value[i++] = nch->string;
                 nch->string = NULL;                  nch->string = NULL;
                 nnext = nch->next;                  nnext = nch->next;
                 mdoc_node_delete(NULL, nch);                  roff_node_delete(NULL, nch);
         }          }
         nh->nchild = 0;          nh->nchild = 0;
         nh->child = NULL;          nh->child = NULL;
Line 1470  post_bl_head(POST_ARGS)
Line 1363  post_bl_head(POST_ARGS)
 static void  static void
 post_bl(POST_ARGS)  post_bl(POST_ARGS)
 {  {
         struct mdoc_node        *nparent, *nprev; /* of the Bl block */          struct roff_node        *nparent, *nprev; /* of the Bl block */
         struct mdoc_node        *nblock, *nbody;  /* of the Bl */          struct roff_node        *nblock, *nbody;  /* of the Bl */
         struct mdoc_node        *nchild, *nnext;  /* of the Bl body */          struct roff_node        *nchild, *nnext;  /* of the Bl body */
   
         nbody = mdoc->last;          nbody = mdoc->last;
         switch (nbody->type) {          switch (nbody->type) {
         case MDOC_BLOCK:          case ROFFT_BLOCK:
                 post_bl_block(mdoc);                  post_bl_block(mdoc);
                 return;                  return;
         case MDOC_HEAD:          case ROFFT_HEAD:
                 post_bl_head(mdoc);                  post_bl_head(mdoc);
                 return;                  return;
         case MDOC_BODY:          case ROFFT_BODY:
                 break;                  break;
         default:          default:
                 return;                  return;
         }          }
   
         bwarn_ge1(mdoc);  
   
         nchild = nbody->child;          nchild = nbody->child;
         while (NULL != nchild) {          if (nchild == NULL) {
                   mandoc_msg(MANDOCERR_BLK_EMPTY, mdoc->parse,
                       nbody->line, nbody->pos, "Bl");
                   return;
           }
           while (nchild != NULL) {
                 if (nchild->tok == MDOC_It ||                  if (nchild->tok == MDOC_It ||
                     (nchild->tok == MDOC_Sm &&                      (nchild->tok == MDOC_Sm &&
                      nchild->next != NULL &&                       nchild->next != NULL &&
Line 1550  post_bl(POST_ARGS)
Line 1446  post_bl(POST_ARGS)
 static void  static void
 post_bk(POST_ARGS)  post_bk(POST_ARGS)
 {  {
         struct mdoc_node        *n;          struct roff_node        *n;
   
         n = mdoc->last;          n = mdoc->last;
   
         if (n->type == MDOC_BLOCK && n->body->child == NULL) {          if (n->type == ROFFT_BLOCK && n->body->child == NULL) {
                 mandoc_msg(MANDOCERR_MACRO_EMPTY,                  mandoc_msg(MANDOCERR_BLK_EMPTY,
                     mdoc->parse, n->line, n->pos, "Bk");                      mdoc->parse, n->line, n->pos, "Bk");
                 mdoc_node_delete(mdoc, n);                  roff_node_delete(mdoc, n);
         }          }
 }  }
   
 static void  static void
 post_sm(struct mdoc *mdoc)  post_sm(struct roff_man *mdoc)
 {  {
         struct mdoc_node        *nch;          struct roff_node        *nch;
   
         nch = mdoc->last->child;          nch = mdoc->last->child;
   
Line 1573  post_sm(struct mdoc *mdoc)
Line 1469  post_sm(struct mdoc *mdoc)
                 return;                  return;
         }          }
   
         assert(nch->type == MDOC_TEXT);          assert(nch->type == ROFFT_TEXT);
   
         if ( ! strcmp(nch->string, "on")) {          if ( ! strcmp(nch->string, "on")) {
                 mdoc->flags &= ~MDOC_SMOFF;                  mdoc->flags &= ~MDOC_SMOFF;
Line 1594  post_sm(struct mdoc *mdoc)
Line 1490  post_sm(struct mdoc *mdoc)
 static void  static void
 post_root(POST_ARGS)  post_root(POST_ARGS)
 {  {
         struct mdoc_node *n;          struct roff_node *n;
   
         /* Add missing prologue data. */          /* Add missing prologue data. */
   
Line 1621  post_root(POST_ARGS)
Line 1517  post_root(POST_ARGS)
         /* Check that we begin with a proper `Sh'. */          /* Check that we begin with a proper `Sh'. */
   
         n = mdoc->first->child;          n = mdoc->first->child;
         while (n != NULL && mdoc_macros[n->tok].flags & MDOC_PROLOGUE)          while (n != NULL && n->tok != TOKEN_NONE &&
               mdoc_macros[n->tok].flags & MDOC_PROLOGUE)
                 n = n->next;                  n = n->next;
   
         if (n == NULL)          if (n == NULL)
Line 1634  post_root(POST_ARGS)
Line 1531  post_root(POST_ARGS)
 static void  static void
 post_st(POST_ARGS)  post_st(POST_ARGS)
 {  {
         struct mdoc_node         *n, *nch;          struct roff_node         *n, *nch;
         const char               *p;          const char               *p;
   
         n = mdoc->last;          n = mdoc->last;
         nch = n->child;          nch = n->child;
   
         assert(MDOC_TEXT == nch->type);          assert(nch->type == ROFFT_TEXT);
   
         if (NULL == (p = mdoc_a2st(nch->string))) {          if (NULL == (p = mdoc_a2st(nch->string))) {
                 mandoc_vmsg(MANDOCERR_ST_BAD, mdoc->parse,                  mandoc_vmsg(MANDOCERR_ST_BAD, mdoc->parse,
                     nch->line, nch->pos, "St %s", nch->string);                      nch->line, nch->pos, "St %s", nch->string);
                 mdoc_node_delete(mdoc, n);                  roff_node_delete(mdoc, n);
         } else {          } else {
                 free(nch->string);                  free(nch->string);
                 nch->string = mandoc_strdup(p);                  nch->string = mandoc_strdup(p);
Line 1655  post_st(POST_ARGS)
Line 1552  post_st(POST_ARGS)
 static void  static void
 post_rs(POST_ARGS)  post_rs(POST_ARGS)
 {  {
         struct mdoc_node *np, *nch, *next, *prev;          struct roff_node *np, *nch, *next, *prev;
         int               i, j;          int               i, j;
   
         np = mdoc->last;          np = mdoc->last;
   
         if (np->type != MDOC_BODY)          if (np->type != ROFFT_BODY)
                 return;                  return;
   
         if (np->child == NULL) {          if (np->child == NULL) {
Line 1692  post_rs(POST_ARGS)
Line 1589  post_rs(POST_ARGS)
   
                 /*                  /*
                  * Remove this child from the chain.  This somewhat                   * Remove this child from the chain.  This somewhat
                  * repeats mdoc_node_unlink(), but since we're                   * repeats roff_node_unlink(), but since we're
                  * just re-ordering, there's no need for the                   * just re-ordering, there's no need for the
                  * full unlink process.                   * full unlink process.
                  */                   */
Line 1749  post_rs(POST_ARGS)
Line 1646  post_rs(POST_ARGS)
 static void  static void
 post_hyph(POST_ARGS)  post_hyph(POST_ARGS)
 {  {
         struct mdoc_node        *n, *nch;          struct roff_node        *nch;
         char                    *cp;          char                    *cp;
   
         n = mdoc->last;          for (nch = mdoc->last->child; nch != NULL; nch = nch->next) {
         switch (n->type) {                  if (nch->type != ROFFT_TEXT)
         case MDOC_HEAD:  
                 if (MDOC_Sh == n->tok || MDOC_Ss == n->tok)  
                         break;  
                 return;  
         case MDOC_BODY:  
                 if (MDOC_D1 == n->tok || MDOC_Nd == n->tok)  
                         break;  
                 return;  
         case MDOC_ELEM:  
                 break;  
         default:  
                 return;  
         }  
   
         for (nch = n->child; nch; nch = nch->next) {  
                 if (MDOC_TEXT != nch->type)  
                         continue;                          continue;
                 cp = nch->string;                  cp = nch->string;
                 if ('\0' == *cp)                  if (*cp == '\0')
                         continue;                          continue;
                 while ('\0' != *(++cp))                  while (*(++cp) != '\0')
                         if ('-' == *cp &&                          if (*cp == '-' &&
                             isalpha((unsigned char)cp[-1]) &&                              isalpha((unsigned char)cp[-1]) &&
                             isalpha((unsigned char)cp[1]))                              isalpha((unsigned char)cp[1]))
                                 *cp = ASCII_HYPH;                                  *cp = ASCII_HYPH;
Line 1783  post_hyph(POST_ARGS)
Line 1664  post_hyph(POST_ARGS)
 }  }
   
 static void  static void
 post_hyphtext(POST_ARGS)  
 {  
   
         ewarn_ge1(mdoc);  
         post_hyph(mdoc);  
 }  
   
 static void  
 post_ns(POST_ARGS)  post_ns(POST_ARGS)
 {  {
   
Line 1806  post_sh(POST_ARGS)
Line 1679  post_sh(POST_ARGS)
         post_ignpar(mdoc);          post_ignpar(mdoc);
   
         switch (mdoc->last->type) {          switch (mdoc->last->type) {
         case MDOC_HEAD:          case ROFFT_HEAD:
                 post_sh_head(mdoc);                  post_sh_head(mdoc);
                 break;                  break;
         case MDOC_BODY:          case ROFFT_BODY:
                 switch (mdoc->lastsec)  {                  switch (mdoc->lastsec)  {
                 case SEC_NAME:                  case SEC_NAME:
                         post_sh_name(mdoc);                          post_sh_name(mdoc);
Line 1832  post_sh(POST_ARGS)
Line 1705  post_sh(POST_ARGS)
 static void  static void
 post_sh_name(POST_ARGS)  post_sh_name(POST_ARGS)
 {  {
         struct mdoc_node *n;          struct roff_node *n;
           int hasnm, hasnd;
   
         /*          hasnm = hasnd = 0;
          * Warn if the NAME section doesn't contain the `Nm' and `Nd'  
          * macros (can have multiple `Nm' and one `Nd').  Note that the  
          * children of the BODY declaration can also be "text".  
          */  
   
         if (NULL == (n = mdoc->last->child)) {          for (n = mdoc->last->child; n != NULL; n = n->next) {
                 mandoc_msg(MANDOCERR_NAMESEC_BAD, mdoc->parse,                  switch (n->tok) {
                     mdoc->last->line, mdoc->last->pos, "empty");                  case MDOC_Nm:
                 return;                          hasnm = 1;
                           break;
                   case MDOC_Nd:
                           hasnd = 1;
                           if (n->next != NULL)
                                   mandoc_msg(MANDOCERR_NAMESEC_ND,
                                       mdoc->parse, n->line, n->pos, NULL);
                           break;
                   case TOKEN_NONE:
                           if (hasnm)
                                   break;
                           /* FALLTHROUGH */
                   default:
                           mandoc_msg(MANDOCERR_NAMESEC_BAD, mdoc->parse,
                               n->line, n->pos, mdoc_macronames[n->tok]);
                           break;
                   }
         }          }
   
         for ( ; n && n->next; n = n->next) {          if ( ! hasnm)
                 if (MDOC_ELEM == n->type && MDOC_Nm == n->tok)                  mandoc_msg(MANDOCERR_NAMESEC_NONM, mdoc->parse,
                         continue;                      mdoc->last->line, mdoc->last->pos, NULL);
                 if (MDOC_TEXT == n->type)          if ( ! hasnd)
                         continue;                  mandoc_msg(MANDOCERR_NAMESEC_NOND, mdoc->parse,
                 mandoc_msg(MANDOCERR_NAMESEC_BAD, mdoc->parse,                      mdoc->last->line, mdoc->last->pos, NULL);
                     n->line, n->pos, mdoc_macronames[n->tok]);  
         }  
   
         assert(n);  
         if (MDOC_BLOCK == n->type && MDOC_Nd == n->tok)  
                 return;  
   
         mandoc_msg(MANDOCERR_NAMESEC_BAD, mdoc->parse,  
             n->line, n->pos, mdoc_macronames[n->tok]);  
 }  }
   
 static void  static void
 post_sh_see_also(POST_ARGS)  post_sh_see_also(POST_ARGS)
 {  {
         const struct mdoc_node  *n;          const struct roff_node  *n;
         const char              *name, *sec;          const char              *name, *sec;
         const char              *lastname, *lastsec, *lastpunct;          const char              *lastname, *lastsec, *lastpunct;
         int                      cmp;          int                      cmp;
   
Line 1911  post_sh_see_also(POST_ARGS)
Line 1788  post_sh_see_also(POST_ARGS)
                         lastpunct = "none";                          lastpunct = "none";
                         continue;                          continue;
                 }                  }
                 if (n->type != MDOC_TEXT)                  if (n->type != ROFFT_TEXT)
                         break;                          break;
                 for (name = n->string; *name != '\0'; name++)                  for (name = n->string; *name != '\0'; name++)
                         if (isalpha((const unsigned char)*name))                          if (isalpha((const unsigned char)*name))
Line 1926  post_sh_see_also(POST_ARGS)
Line 1803  post_sh_see_also(POST_ARGS)
 }  }
   
 static int  static int
 child_an(const struct mdoc_node *n)  child_an(const struct roff_node *n)
 {  {
   
         for (n = n->child; n != NULL; n = n->next)          for (n = n->child; n != NULL; n = n->next)
                 if ((n->tok == MDOC_An && n->nchild) || child_an(n))                  if ((n->tok == MDOC_An && n->nchild) || child_an(n))
                         return(1);                          return 1;
         return(0);          return 0;
 }  }
   
 static void  static void
Line 1947  post_sh_authors(POST_ARGS)
Line 1824  post_sh_authors(POST_ARGS)
 static void  static void
 post_sh_head(POST_ARGS)  post_sh_head(POST_ARGS)
 {  {
         struct mdoc_node *n;          struct roff_node *n;
         const char      *goodsec;          const char      *goodsec;
         char            *secname;          char            *secname;
         enum mdoc_sec    sec;          enum roff_sec    sec;
   
         /*          /*
          * Process a new section.  Sections are either "named" or           * Process a new section.  Sections are either "named" or
Line 1961  post_sh_head(POST_ARGS)
Line 1838  post_sh_head(POST_ARGS)
   
         secname = NULL;          secname = NULL;
         sec = SEC_CUSTOM;          sec = SEC_CUSTOM;
         mdoc_deroff(&secname, mdoc->last);          deroff(&secname, mdoc->last);
         sec = NULL == secname ? SEC_CUSTOM : a2sec(secname);          sec = NULL == secname ? SEC_CUSTOM : a2sec(secname);
   
         /* The NAME should be first. */          /* The NAME should be first. */
Line 2040  post_sh_head(POST_ARGS)
Line 1917  post_sh_head(POST_ARGS)
                 goodsec = "2, 3, 4, 9";                  goodsec = "2, 3, 4, 9";
                 /* FALLTHROUGH */                  /* FALLTHROUGH */
         case SEC_RETURN_VALUES:          case SEC_RETURN_VALUES:
                 /* FALLTHROUGH */  
         case SEC_LIBRARY:          case SEC_LIBRARY:
                 if (*mdoc->meta.msec == '2')                  if (*mdoc->meta.msec == '2')
                         break;                          break;
Line 2067  post_sh_head(POST_ARGS)
Line 1943  post_sh_head(POST_ARGS)
 static void  static void
 post_ignpar(POST_ARGS)  post_ignpar(POST_ARGS)
 {  {
         struct mdoc_node *np;          struct roff_node *np;
   
         post_hyph(mdoc);          switch (mdoc->last->type) {
           case ROFFT_HEAD:
         if (MDOC_BODY != mdoc->last->type)                  post_hyph(mdoc);
                 return;                  return;
           case ROFFT_BODY:
                   break;
           default:
                   return;
           }
   
         if (NULL != (np = mdoc->last->child))          if (NULL != (np = mdoc->last->child))
                 if (MDOC_Pp == np->tok || MDOC_Lp == np->tok) {                  if (MDOC_Pp == np->tok || MDOC_Lp == np->tok) {
Line 2080  post_ignpar(POST_ARGS)
Line 1961  post_ignpar(POST_ARGS)
                             mdoc->parse, np->line, np->pos,                              mdoc->parse, np->line, np->pos,
                             "%s after %s", mdoc_macronames[np->tok],                              "%s after %s", mdoc_macronames[np->tok],
                             mdoc_macronames[mdoc->last->tok]);                              mdoc_macronames[mdoc->last->tok]);
                         mdoc_node_delete(mdoc, np);                          roff_node_delete(mdoc, np);
                 }                  }
   
         if (NULL != (np = mdoc->last->last))          if (NULL != (np = mdoc->last->last))
Line 2089  post_ignpar(POST_ARGS)
Line 1970  post_ignpar(POST_ARGS)
                             np->line, np->pos, "%s at the end of %s",                              np->line, np->pos, "%s at the end of %s",
                             mdoc_macronames[np->tok],                              mdoc_macronames[np->tok],
                             mdoc_macronames[mdoc->last->tok]);                              mdoc_macronames[mdoc->last->tok]);
                         mdoc_node_delete(mdoc, np);                          roff_node_delete(mdoc, np);
                 }                  }
 }  }
   
Line 2099  pre_par(PRE_ARGS)
Line 1980  pre_par(PRE_ARGS)
   
         if (NULL == mdoc->last)          if (NULL == mdoc->last)
                 return;                  return;
         if (MDOC_ELEM != n->type && MDOC_BLOCK != n->type)          if (n->type != ROFFT_ELEM && n->type != ROFFT_BLOCK)
                 return;                  return;
   
         /*          /*
Line 2122  pre_par(PRE_ARGS)
Line 2003  pre_par(PRE_ARGS)
             mdoc->last->line, mdoc->last->pos,              mdoc->last->line, mdoc->last->pos,
             "%s before %s", mdoc_macronames[mdoc->last->tok],              "%s before %s", mdoc_macronames[mdoc->last->tok],
             mdoc_macronames[n->tok]);              mdoc_macronames[n->tok]);
         mdoc_node_delete(mdoc, mdoc->last);          roff_node_delete(mdoc, mdoc->last);
 }  }
   
 static void  static void
 post_par(POST_ARGS)  post_par(POST_ARGS)
 {  {
         struct mdoc_node *np;          struct roff_node *np;
   
         np = mdoc->last;          np = mdoc->last;
   
Line 2155  post_par(POST_ARGS)
Line 2036  post_par(POST_ARGS)
             mdoc->last->line, mdoc->last->pos,              mdoc->last->line, mdoc->last->pos,
             "%s after %s", mdoc_macronames[mdoc->last->tok],              "%s after %s", mdoc_macronames[mdoc->last->tok],
             mdoc_macronames[np->tok]);              mdoc_macronames[np->tok]);
         mdoc_node_delete(mdoc, mdoc->last);          roff_node_delete(mdoc, mdoc->last);
 }  }
   
 static void  static void
Line 2164  pre_literal(PRE_ARGS)
Line 2045  pre_literal(PRE_ARGS)
   
         pre_display(mdoc, n);          pre_display(mdoc, n);
   
         if (MDOC_BODY != n->type)          if (n->type != ROFFT_BODY)
                 return;                  return;
   
         /*          /*
Line 2184  pre_literal(PRE_ARGS)
Line 2065  pre_literal(PRE_ARGS)
                 break;                  break;
         default:          default:
                 abort();                  abort();
                 /* NOTREACHED */  
         }          }
 }  }
   
 static void  static void
 post_dd(POST_ARGS)  post_dd(POST_ARGS)
 {  {
         struct mdoc_node *n;          struct roff_node *n;
         char             *datestr;          char             *datestr;
   
         if (mdoc->meta.date)          if (mdoc->meta.date)
Line 2205  post_dd(POST_ARGS)
Line 2085  post_dd(POST_ARGS)
         }          }
   
         datestr = NULL;          datestr = NULL;
         mdoc_deroff(&datestr, n);          deroff(&datestr, n);
         if (mdoc->quick)          if (mdoc->quick)
                 mdoc->meta.date = datestr;                  mdoc->meta.date = datestr;
         else {          else {
Line 2214  post_dd(POST_ARGS)
Line 2094  post_dd(POST_ARGS)
                 free(datestr);                  free(datestr);
         }          }
 out:  out:
         mdoc_node_delete(mdoc, n);          roff_node_delete(mdoc, n);
 }  }
   
 static void  static void
 post_dt(POST_ARGS)  post_dt(POST_ARGS)
 {  {
         struct mdoc_node *nn, *n;          struct roff_node *nn, *n;
         const char       *cp;          const char       *cp;
         char             *p;          char             *p;
   
Line 2236  post_dt(POST_ARGS)
Line 2116  post_dt(POST_ARGS)
         mdoc->meta.vol = NULL;          mdoc->meta.vol = NULL;
         mdoc->meta.arch = NULL;          mdoc->meta.arch = NULL;
   
         /* First check that all characters are uppercase. */          /* Mandatory first argument: title. */
   
         if (NULL != (nn = n->child))          nn = n->child;
                 for (p = nn->string; *p; p++) {          if (nn == NULL || *nn->string == '\0') {
                         if (toupper((unsigned char)*p) == *p)  
                                 continue;  
                         mandoc_vmsg(MANDOCERR_TITLE_CASE,  
                             mdoc->parse, nn->line,  
                             nn->pos + (p - nn->string),  
                             "Dt %s", nn->string);  
                         break;  
                 }  
   
         /* No argument: msec and arch remain NULL. */  
   
         if (NULL == (nn = n->child)) {  
                 mandoc_msg(MANDOCERR_DT_NOTITLE,                  mandoc_msg(MANDOCERR_DT_NOTITLE,
                     mdoc->parse, n->line, n->pos, "Dt");                      mdoc->parse, n->line, n->pos, "Dt");
                 mdoc->meta.title = mandoc_strdup("UNTITLED");                  mdoc->meta.title = mandoc_strdup("UNTITLED");
                 mdoc->meta.vol = mandoc_strdup("LOCAL");          } else {
                 goto out;                  mdoc->meta.title = mandoc_strdup(nn->string);
   
                   /* Check that all characters are uppercase. */
   
                   for (p = nn->string; *p != '\0'; p++)
                           if (islower((unsigned char)*p)) {
                                   mandoc_vmsg(MANDOCERR_TITLE_CASE,
                                       mdoc->parse, nn->line,
                                       nn->pos + (p - nn->string),
                                       "Dt %s", nn->string);
                                   break;
                           }
         }          }
   
         /* One argument: msec and arch remain NULL. */          /* Mandatory second argument: section. */
   
         mdoc->meta.title = mandoc_strdup(          if (nn != NULL)
             '\0' == nn->string[0] ? "UNTITLED" : nn->string);                  nn = nn->next;
   
         if (NULL == (nn = nn->next)) {          if (nn == NULL) {
                 mandoc_vmsg(MANDOCERR_MSEC_MISSING,                  mandoc_vmsg(MANDOCERR_MSEC_MISSING,
                     mdoc->parse, n->line, n->pos,                      mdoc->parse, n->line, n->pos,
                     "Dt %s", mdoc->meta.title);                      "Dt %s", mdoc->meta.title);
                 mdoc->meta.vol = mandoc_strdup("LOCAL");                  mdoc->meta.vol = mandoc_strdup("LOCAL");
                 goto out;                  goto out;  /* msec and arch remain NULL. */
         }          }
   
         /* Handles: `.Dt TITLE SEC'          mdoc->meta.msec = mandoc_strdup(nn->string);
          * title = TITLE,  
          * volume = SEC is msec ? format(msec) : SEC,  
          * msec = SEC is msec ? atoi(msec) : 0,  
          * arch = NULL  
          */  
   
           /* Infer volume title from section number. */
   
         cp = mandoc_a2msec(nn->string);          cp = mandoc_a2msec(nn->string);
         if (cp) {          if (cp == NULL) {
                 mdoc->meta.vol = mandoc_strdup(cp);  
                 mdoc->meta.msec = mandoc_strdup(nn->string);  
         } else {  
                 mandoc_vmsg(MANDOCERR_MSEC_BAD, mdoc->parse,                  mandoc_vmsg(MANDOCERR_MSEC_BAD, mdoc->parse,
                     nn->line, nn->pos, "Dt ... %s", nn->string);                      nn->line, nn->pos, "Dt ... %s", nn->string);
                 mdoc->meta.vol = mandoc_strdup(nn->string);                  mdoc->meta.vol = mandoc_strdup(nn->string);
                 mdoc->meta.msec = mandoc_strdup(nn->string);          } else
         }                  mdoc->meta.vol = mandoc_strdup(cp);
   
         /* Handle an optional architecture */          /* Optional third argument: architecture. */
   
         if ((nn = nn->next) != NULL) {          if ((nn = nn->next) == NULL)
                 for (p = nn->string; *p; p++)                  goto out;
                         *p = tolower((unsigned char)*p);  
                 mdoc->meta.arch = mandoc_strdup(nn->string);  
         }  
   
         /* Ignore any subsequent parameters... */          for (p = nn->string; *p != '\0'; p++)
         /* FIXME: warn about subsequent parameters. */                  *p = tolower((unsigned char)*p);
           mdoc->meta.arch = mandoc_strdup(nn->string);
   
           /* Ignore fourth and later arguments. */
   
           if ((nn = nn->next) != NULL)
                   mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
                       nn->line, nn->pos, "Dt ... %s", nn->string);
   
 out:  out:
         mdoc_node_delete(mdoc, n);          roff_node_delete(mdoc, n);
 }  }
   
 static void  static void
 post_bx(POST_ARGS)  post_bx(POST_ARGS)
 {  {
         struct mdoc_node        *n;          struct roff_node        *n;
   
         /*          /*
          * Make `Bx's second argument always start with an uppercase           * Make `Bx's second argument always start with an uppercase
Line 2327  post_os(POST_ARGS)
Line 2205  post_os(POST_ARGS)
         struct utsname    utsname;          struct utsname    utsname;
         static char      *defbuf;          static char      *defbuf;
 #endif  #endif
         struct mdoc_node *n;          struct roff_node *n;
   
         n = mdoc->last;          n = mdoc->last;
   
Line 2342  post_os(POST_ARGS)
Line 2220  post_os(POST_ARGS)
   
         free(mdoc->meta.os);          free(mdoc->meta.os);
         mdoc->meta.os = NULL;          mdoc->meta.os = NULL;
         mdoc_deroff(&mdoc->meta.os, n);          deroff(&mdoc->meta.os, n);
         if (mdoc->meta.os)          if (mdoc->meta.os)
                 goto out;                  goto out;
   
Line 2367  post_os(POST_ARGS)
Line 2245  post_os(POST_ARGS)
 #endif /*!OSNAME*/  #endif /*!OSNAME*/
   
 out:  out:
         mdoc_node_delete(mdoc, n);          roff_node_delete(mdoc, n);
 }  }
   
 /*  /*
Line 2377  out:
Line 2255  out:
 static void  static void
 post_ex(POST_ARGS)  post_ex(POST_ARGS)
 {  {
         struct mdoc_node *n;          struct roff_node *n;
   
         n = mdoc->last;          n = mdoc->last;
   
Line 2390  post_ex(POST_ARGS)
Line 2268  post_ex(POST_ARGS)
                 return;                  return;
         }          }
   
         mdoc->next = MDOC_NEXT_CHILD;          mdoc->next = ROFF_NEXT_CHILD;
         mdoc_word_alloc(mdoc, n->line, n->pos, mdoc->meta.name);          roff_word_alloc(mdoc, n->line, n->pos, mdoc->meta.name);
         mdoc->last = n;          mdoc->last = n;
 }  }
   
 static enum mdoc_sec  static enum roff_sec
 a2sec(const char *p)  a2sec(const char *p)
 {  {
         int              i;          int              i;
   
         for (i = 0; i < (int)SEC__MAX; i++)          for (i = 0; i < (int)SEC__MAX; i++)
                 if (secnames[i] && 0 == strcmp(p, secnames[i]))                  if (secnames[i] && 0 == strcmp(p, secnames[i]))
                         return((enum mdoc_sec)i);                          return (enum roff_sec)i;
   
         return(SEC_CUSTOM);          return SEC_CUSTOM;
 }  }
   
 static size_t  static size_t
 macro2len(enum mdoct macro)  macro2len(int macro)
 {  {
   
         switch (macro) {          switch (macro) {
         case MDOC_Ad:          case MDOC_Ad:
                 return(12);                  return 12;
         case MDOC_Ao:          case MDOC_Ao:
                 return(12);                  return 12;
         case MDOC_An:          case MDOC_An:
                 return(12);                  return 12;
         case MDOC_Aq:          case MDOC_Aq:
                 return(12);                  return 12;
         case MDOC_Ar:          case MDOC_Ar:
                 return(12);                  return 12;
         case MDOC_Bo:          case MDOC_Bo:
                 return(12);                  return 12;
         case MDOC_Bq:          case MDOC_Bq:
                 return(12);                  return 12;
         case MDOC_Cd:          case MDOC_Cd:
                 return(12);                  return 12;
         case MDOC_Cm:          case MDOC_Cm:
                 return(10);                  return 10;
         case MDOC_Do:          case MDOC_Do:
                 return(10);                  return 10;
         case MDOC_Dq:          case MDOC_Dq:
                 return(12);                  return 12;
         case MDOC_Dv:          case MDOC_Dv:
                 return(12);                  return 12;
         case MDOC_Eo:          case MDOC_Eo:
                 return(12);                  return 12;
         case MDOC_Em:          case MDOC_Em:
                 return(10);                  return 10;
         case MDOC_Er:          case MDOC_Er:
                 return(17);                  return 17;
         case MDOC_Ev:          case MDOC_Ev:
                 return(15);                  return 15;
         case MDOC_Fa:          case MDOC_Fa:
                 return(12);                  return 12;
         case MDOC_Fl:          case MDOC_Fl:
                 return(10);                  return 10;
         case MDOC_Fo:          case MDOC_Fo:
                 return(16);                  return 16;
         case MDOC_Fn:          case MDOC_Fn:
                 return(16);                  return 16;
         case MDOC_Ic:          case MDOC_Ic:
                 return(10);                  return 10;
         case MDOC_Li:          case MDOC_Li:
                 return(16);                  return 16;
         case MDOC_Ms:          case MDOC_Ms:
                 return(6);                  return 6;
         case MDOC_Nm:          case MDOC_Nm:
                 return(10);                  return 10;
         case MDOC_No:          case MDOC_No:
                 return(12);                  return 12;
         case MDOC_Oo:          case MDOC_Oo:
                 return(10);                  return 10;
         case MDOC_Op:          case MDOC_Op:
                 return(14);                  return 14;
         case MDOC_Pa:          case MDOC_Pa:
                 return(32);                  return 32;
         case MDOC_Pf:          case MDOC_Pf:
                 return(12);                  return 12;
         case MDOC_Po:          case MDOC_Po:
                 return(12);                  return 12;
         case MDOC_Pq:          case MDOC_Pq:
                 return(12);                  return 12;
         case MDOC_Ql:          case MDOC_Ql:
                 return(16);                  return 16;
         case MDOC_Qo:          case MDOC_Qo:
                 return(12);                  return 12;
         case MDOC_So:          case MDOC_So:
                 return(12);                  return 12;
         case MDOC_Sq:          case MDOC_Sq:
                 return(12);                  return 12;
         case MDOC_Sy:          case MDOC_Sy:
                 return(6);                  return 6;
         case MDOC_Sx:          case MDOC_Sx:
                 return(16);                  return 16;
         case MDOC_Tn:          case MDOC_Tn:
                 return(10);                  return 10;
         case MDOC_Va:          case MDOC_Va:
                 return(12);                  return 12;
         case MDOC_Vt:          case MDOC_Vt:
                 return(12);                  return 12;
         case MDOC_Xr:          case MDOC_Xr:
                 return(10);                  return 10;
         default:          default:
                 break;                  break;
         };          };
         return(0);          return 0;
 }  }
Legend:
Removed from v.1.272  
changed lines
  Added in v.1.295
CVSweb