[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.288 and 1.297

version 1.288, 2015/04/19 14:00:20 version 1.297, 2015/10/19 20:04:10
Line 107  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 161  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, NULL },                         /* %A */          { NULL, NULL },                         /* %A */
         { NULL, post_hyph },                    /* %B */ /* FIXME: can be used outside Rs/Re. */          { NULL, post_hyph },                    /* %B */ /* FIXME: can be used outside Rs/Re. */
Line 302  mdoc_valid_pre(struct roff_man *mdoc, struct roff_node
Line 301  mdoc_valid_pre(struct roff_man *mdoc, struct roff_node
         case ROFFT_TEXT:          case ROFFT_TEXT:
                 if (n->sec != SEC_SYNOPSIS || n->parent->tok != MDOC_Fd)                  if (n->sec != SEC_SYNOPSIS || n->parent->tok != MDOC_Fd)
                         check_text(mdoc, n->line, n->pos, n->string);                          check_text(mdoc, n->line, n->pos, n->string);
                 /* FALLTHROUGH */                  return;
         case ROFFT_TBL:          case ROFFT_TBL:
                 /* FALLTHROUGH */  
         case ROFFT_EQN:          case ROFFT_EQN:
                 /* FALLTHROUGH */  
         case ROFFT_ROOT:          case ROFFT_ROOT:
                 return;                  return;
         default:          default:
Line 332  mdoc_valid_post(struct roff_man *mdoc)
Line 329  mdoc_valid_post(struct roff_man *mdoc)
   
         switch (n->type) {          switch (n->type) {
         case ROFFT_TEXT:          case ROFFT_TEXT:
                 /* FALLTHROUGH */  
         case ROFFT_EQN:          case ROFFT_EQN:
                 /* FALLTHROUGH */  
         case ROFFT_TBL:          case ROFFT_TBL:
                 break;                  break;
         case ROFFT_ROOT:          case ROFFT_ROOT:
Line 567  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 581  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 658  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 771  static void
Line 759  static void
 post_bf(POST_ARGS)  post_bf(POST_ARGS)
 {  {
         struct roff_node *np, *nch;          struct roff_node *np, *nch;
         enum mdocargt     arg;  
   
         /*          /*
          * Unlike other data pointers, these are "housed" by the HEAD           * Unlike other data pointers, these are "housed" by the HEAD
Line 783  post_bf(POST_ARGS)
Line 770  post_bf(POST_ARGS)
                 return;                  return;
   
         assert(np->parent->type == ROFFT_BLOCK);          assert(np->parent->type == ROFFT_BLOCK);
         assert(MDOC_Bf == np->parent->tok);          assert(np->parent->tok == MDOC_Bf);
   
         /* Check the number of arguments. */          /* Check the number of arguments. */
   
         nch = np->child;          nch = np->child;
         if (NULL == np->parent->args) {          if (np->parent->args == NULL) {
                 if (NULL == nch) {                  if (nch == NULL) {
                         mandoc_msg(MANDOCERR_BF_NOFONT, mdoc->parse,                          mandoc_msg(MANDOCERR_BF_NOFONT, mdoc->parse,
                             np->line, np->pos, "Bf");                              np->line, np->pos, "Bf");
                         return;                          return;
                 }                  }
                 nch = nch->next;                  nch = nch->next;
         }          }
         if (NULL != nch)          if (nch != NULL)
                 mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,                  mandoc_vmsg(MANDOCERR_ARG_EXCESS, mdoc->parse,
                     nch->line, nch->pos, "Bf ... %s", nch->string);                      nch->line, nch->pos, "Bf ... %s", nch->string);
   
         /* Extract argument into data. */          /* Extract argument into data. */
   
         if (np->parent->args) {          if (np->parent->args != NULL) {
                 arg = np->parent->args->argv[0].arg;                  switch (np->parent->args->argv[0].arg) {
                 if (MDOC_Emphasis == arg)                  case MDOC_Emphasis:
                         np->norm->Bf.font = FONT_Em;                          np->norm->Bf.font = FONT_Em;
                 else if (MDOC_Literal == arg)                          break;
                   case MDOC_Literal:
                         np->norm->Bf.font = FONT_Li;                          np->norm->Bf.font = FONT_Li;
                 else if (MDOC_Symbolic == arg)                          break;
                   case MDOC_Symbolic:
                         np->norm->Bf.font = FONT_Sy;                          np->norm->Bf.font = FONT_Sy;
                 else                          break;
                   default:
                         abort();                          abort();
                   }
                 return;                  return;
         }          }
   
         /* Extract parameter into data. */          /* Extract parameter into data. */
   
         if (0 == strcmp(np->child->string, "Em"))          if ( ! strcmp(np->child->string, "Em"))
                 np->norm->Bf.font = FONT_Em;                  np->norm->Bf.font = FONT_Em;
         else if (0 == strcmp(np->child->string, "Li"))          else if ( ! strcmp(np->child->string, "Li"))
                 np->norm->Bf.font = FONT_Li;                  np->norm->Bf.font = FONT_Li;
         else if (0 == strcmp(np->child->string, "Sy"))          else if ( ! strcmp(np->child->string, "Sy"))
                 np->norm->Bf.font = FONT_Sy;                  np->norm->Bf.font = FONT_Sy;
         else          else
                 mandoc_vmsg(MANDOCERR_BF_BADFONT, mdoc->parse,                  mandoc_vmsg(MANDOCERR_BF_BADFONT, mdoc->parse,
Line 855  post_eoln(POST_ARGS)
Line 846  post_eoln(POST_ARGS)
         const struct roff_node *n;          const struct roff_node *n;
   
         n = mdoc->last;          n = mdoc->last;
         if (n->child)          if (n->child != NULL)
                 mandoc_vmsg(MANDOCERR_ARG_SKIP,                  mandoc_vmsg(MANDOCERR_ARG_SKIP,
                     mdoc->parse, n->line, n->pos,                      mdoc->parse, n->line, n->pos,
                     "%s %s", mdoc_macronames[n->tok],                      "%s %s", mdoc_macronames[n->tok],
Line 933  post_fa(POST_ARGS)
Line 924  post_fa(POST_ARGS)
 }  }
   
 static void  static void
 post_vt(POST_ARGS)  
 {  
         const struct roff_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->last->type != ROFFT_BODY)  
                 return;  
   
         for (n = mdoc->last->child; n; n = n->next)  
                 if (n->type != ROFFT_TEXT)  
                         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 roff_node        *n;          struct roff_node        *n;
Line 966  post_nm(POST_ARGS)
Line 935  post_nm(POST_ARGS)
              n->last->tok == MDOC_Lp))               n->last->tok == MDOC_Lp))
                 mdoc_node_relink(mdoc, n->last);                  mdoc_node_relink(mdoc, n->last);
   
         if (NULL != mdoc->meta.name)          if (mdoc->meta.name != NULL)
                 return;                  return;
   
         mdoc_deroff(&mdoc->meta.name, n);          deroff(&mdoc->meta.name, n);
   
         if (NULL == mdoc->meta.name)          if (mdoc->meta.name == NULL)
                 mandoc_msg(MANDOCERR_NM_NONAME, mdoc->parse,                  mandoc_msg(MANDOCERR_NM_NONAME, mdoc->parse,
                     n->line, n->pos, "Nm");                      n->line, n->pos, "Nm");
 }  }
Line 1043  post_defaults(POST_ARGS)
Line 1012  post_defaults(POST_ARGS)
          * gets an empty string.           * gets an empty string.
          */           */
   
         if (mdoc->last->child)          if (mdoc->last->child != NULL)
                 return;                  return;
   
         nn = mdoc->last;          nn = mdoc->last;
Line 1051  post_defaults(POST_ARGS)
Line 1020  post_defaults(POST_ARGS)
   
         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 1076  post_at(POST_ARGS)
Line 1043  post_at(POST_ARGS)
         n = mdoc->last;          n = mdoc->last;
         if (n->child == NULL) {          if (n->child == NULL) {
                 mdoc->next = ROFF_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 1089  post_at(POST_ARGS)
Line 1056  post_at(POST_ARGS)
   
         n = n->child;          n = n->child;
         assert(n->type == ROFFT_TEXT);          assert(n->type == ROFFT_TEXT);
         if (NULL == (std_att = mdoc_a2att(n->string))) {          if ((std_att = mdoc_a2att(n->string)) == NULL) {
                 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);
                 mandoc_asprintf(&att, "AT&T UNIX %s", n->string);                  mandoc_asprintf(&att, "AT&T UNIX %s", n->string);
Line 1147  post_it(POST_ARGS)
Line 1114  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 1162  post_it(POST_ARGS)
Line 1125  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 1185  post_it(POST_ARGS)
Line 1145  post_it(POST_ARGS)
   
                 assert(nit->head->child == NULL);                  assert(nit->head->child == NULL);
   
                 for (i = 0, nch = nit->child; nch; nch = nch->next)                  i = 0;
                   for (nch = nit->child; nch != NULL; nch = nch->next)
                         if (nch->type == ROFFT_BODY)                          if (nch->type == ROFFT_BODY)
                                 i++;                                  i++;
   
Line 1214  post_bl_block(POST_ARGS)
Line 1175  post_bl_block(POST_ARGS)
   
         n = mdoc->last;          n = mdoc->last;
   
         if (LIST_tag == n->norm->Bl.type &&          if (n->norm->Bl.type == LIST_tag &&
             NULL == n->norm->Bl.width) {              n->norm->Bl.width == NULL) {
                 post_bl_block_tag(mdoc);                  post_bl_block_tag(mdoc);
                 assert(n->norm->Bl.width);                  assert(n->norm->Bl.width != NULL);
         }          }
   
         for (ni = n->body->child; ni; ni = ni->next) {          for (ni = n->body->child; ni != NULL; ni = ni->next) {
                 if (NULL == ni->body)                  if (ni->body == NULL)
                         continue;                          continue;
                 nc = ni->body->last;                  nc = ni->body->last;
                 while (NULL != nc) {                  while (nc != NULL) {
                         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:
                                 nc = NULL;                                  nc = NULL;
                                 continue;                                  continue;
                         }                          }
                         if (NULL == ni->next) {                          if (ni->next == NULL) {
                                 mandoc_msg(MANDOCERR_PAR_MOVE,                                  mandoc_msg(MANDOCERR_PAR_MOVE,
                                     mdoc->parse, nc->line, nc->pos,                                      mdoc->parse, nc->line, nc->pos,
                                     mdoc_macronames[nc->tok]);                                      mdoc_macronames[nc->tok]);
                                 mdoc_node_relink(mdoc, nc);                                  mdoc_node_relink(mdoc, nc);
                         } else if (0 == n->norm->Bl.comp &&                          } else if (n->norm->Bl.comp == 0 &&
                             LIST_column != n->norm->Bl.type) {                              n->norm->Bl.type != LIST_column) {
                                 mandoc_vmsg(MANDOCERR_PAR_SKIP,                                  mandoc_vmsg(MANDOCERR_PAR_SKIP,
                                     mdoc->parse, nc->line, nc->pos,                                      mdoc->parse, nc->line, nc->pos,
                                     "%s before It",                                      "%s before It",
Line 1296  post_bl_block_tag(POST_ARGS)
Line 1255  post_bl_block_tag(POST_ARGS)
         sz = 10;          sz = 10;
         n = mdoc->last;          n = mdoc->last;
   
         for (nn = n->body->child; nn; nn = nn->next) {          for (nn = n->body->child; nn != NULL; nn = nn->next) {
                 if (MDOC_It != nn->tok)                  if (nn->tok != MDOC_It)
                         continue;                          continue;
   
                 assert(nn->type == ROFFT_BLOCK);                  assert(nn->type == ROFFT_BLOCK);
Line 1326  post_bl_block_tag(POST_ARGS)
Line 1285  post_bl_block_tag(POST_ARGS)
          * We're guaranteed that a MDOC_Width doesn't already exist.           * We're guaranteed that a MDOC_Width doesn't already exist.
          */           */
   
         assert(n->args);          assert(n->args != NULL);
         i = (int)(n->args->argc)++;          i = (int)(n->args->argc)++;
   
         n->args->argv = mandoc_reallocarray(n->args->argv,          n->args->argv = mandoc_reallocarray(n->args->argv,
Line 1459  post_bl(POST_ARGS)
Line 1418  post_bl(POST_ARGS)
                  * Unlink this child.                   * Unlink this child.
                  */                   */
   
                 assert(NULL == nchild->prev);                  assert(nchild->prev == NULL);
                 if (0 == --nbody->nchild) {                  if (--nbody->nchild == 0) {
                         nbody->child = NULL;                          nbody->child = NULL;
                         nbody->last  = NULL;                          nbody->last  = NULL;
                         assert(NULL == nnext);                          assert(nnext == NULL);
                 } else {                  } else {
                         nbody->child = nnext;                          nbody->child = nnext;
                         nnext->prev = NULL;                          nnext->prev = NULL;
Line 1479  post_bl(POST_ARGS)
Line 1438  post_bl(POST_ARGS)
   
                 nblock->prev = nchild;                  nblock->prev = nchild;
                 nparent->nchild++;                  nparent->nchild++;
                 if (NULL == nprev)                  if (nprev == NULL)
                         nparent->child = nchild;                          nparent->child = nchild;
                 else                  else
                         nprev->next = nchild;                          nprev->next = nchild;
Line 1503  post_bk(POST_ARGS)
Line 1462  post_bk(POST_ARGS)
 }  }
   
 static void  static void
 post_sm(struct roff_man *mdoc)  post_sm(POST_ARGS)
 {  {
         struct roff_node        *nch;          struct roff_node        *nch;
   
Line 1562  post_root(POST_ARGS)
Line 1521  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 1583  post_st(POST_ARGS)
Line 1543  post_st(POST_ARGS)
   
         assert(nch->type == ROFFT_TEXT);          assert(nch->type == ROFFT_TEXT);
   
         if (NULL == (p = mdoc_a2st(nch->string))) {          if ((p = mdoc_a2st(nch->string)) == NULL) {
                 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);
                 roff_node_delete(mdoc, n);                  roff_node_delete(mdoc, n);
Line 1711  static void
Line 1671  static void
 post_ns(POST_ARGS)  post_ns(POST_ARGS)
 {  {
   
         if (MDOC_LINE & mdoc->last->flags)          if (mdoc->last->flags & MDOC_LINE)
                 mandoc_msg(MANDOCERR_NS_SKIP, mdoc->parse,                  mandoc_msg(MANDOCERR_NS_SKIP, mdoc->parse,
                     mdoc->last->line, mdoc->last->pos, NULL);                      mdoc->last->line, mdoc->last->pos, NULL);
 }  }
Line 1852  child_an(const struct roff_node *n)
Line 1812  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 1881  post_sh_head(POST_ARGS)
Line 1841  post_sh_head(POST_ARGS)
          */           */
   
         secname = NULL;          secname = NULL;
         sec = SEC_CUSTOM;          deroff(&secname, mdoc->last);
         mdoc_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 1917  post_sh_head(POST_ARGS)
Line 1876  post_sh_head(POST_ARGS)
   
         mdoc->last->parent->sec = sec;          mdoc->last->parent->sec = sec;
         mdoc->last->sec = sec;          mdoc->last->sec = sec;
         for (n = mdoc->last->child; n; n = n->next)          for (n = mdoc->last->child; n != NULL; n = n->next)
                 n->sec = sec;                  n->sec = sec;
   
         /* We don't care about custom sections after this. */          /* We don't care about custom sections after this. */
Line 1961  post_sh_head(POST_ARGS)
Line 1920  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 2000  post_ignpar(POST_ARGS)
Line 1958  post_ignpar(POST_ARGS)
                 return;                  return;
         }          }
   
         if (NULL != (np = mdoc->last->child))          if ((np = mdoc->last->child) != NULL)
                 if (MDOC_Pp == np->tok || MDOC_Lp == np->tok) {                  if (np->tok == MDOC_Pp || np->tok == MDOC_Lp) {
                         mandoc_vmsg(MANDOCERR_PAR_SKIP,                          mandoc_vmsg(MANDOCERR_PAR_SKIP,
                             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],
Line 2009  post_ignpar(POST_ARGS)
Line 1967  post_ignpar(POST_ARGS)
                         roff_node_delete(mdoc, np);                          roff_node_delete(mdoc, np);
                 }                  }
   
         if (NULL != (np = mdoc->last->last))          if ((np = mdoc->last->last) != NULL)
                 if (MDOC_Pp == np->tok || MDOC_Lp == np->tok) {                  if (np->tok == MDOC_Pp || np->tok == MDOC_Lp) {
                         mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,                          mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,
                             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],
Line 2068  post_par(POST_ARGS)
Line 2026  post_par(POST_ARGS)
                     mdoc->parse, np->line, np->pos, "%s %s",                      mdoc->parse, np->line, np->pos, "%s %s",
                     mdoc_macronames[np->tok], np->child->string);                      mdoc_macronames[np->tok], np->child->string);
   
         if (NULL == (np = mdoc->last->prev)) {          if ((np = mdoc->last->prev) == NULL) {
                 np = mdoc->last->parent;                  np = mdoc->last->parent;
                 if (MDOC_Sh != np->tok && MDOC_Ss != np->tok)                  if (np->tok != MDOC_Sh && np->tok != MDOC_Ss)
                         return;                          return;
         } else if (MDOC_Pp != np->tok && MDOC_Lp != np->tok &&          } else if (np->tok != MDOC_Pp && np->tok != MDOC_Lp &&
             (MDOC_br != mdoc->last->tok ||              (mdoc->last->tok != MDOC_br ||
              (MDOC_sp != np->tok && MDOC_br != np->tok)))               (np->tok != MDOC_sp && np->tok != MDOC_br)))
                 return;                  return;
   
         mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,          mandoc_vmsg(MANDOCERR_PAR_SKIP, mdoc->parse,
Line 2110  pre_literal(PRE_ARGS)
Line 2068  pre_literal(PRE_ARGS)
                 break;                  break;
         default:          default:
                 abort();                  abort();
                 /* NOTREACHED */  
         }          }
 }  }
   
Line 2124  post_dd(POST_ARGS)
Line 2081  post_dd(POST_ARGS)
                 free(mdoc->meta.date);                  free(mdoc->meta.date);
   
         n = mdoc->last;          n = mdoc->last;
         if (NULL == n->child || '\0' == n->child->string[0]) {          if (n->child == NULL || n->child->string[0] == '\0') {
                 mdoc->meta.date = mdoc->quick ? mandoc_strdup("") :                  mdoc->meta.date = mdoc->quick ? mandoc_strdup("") :
                     mandoc_normdate(mdoc->parse, NULL, n->line, n->pos);                      mandoc_normdate(mdoc->parse, NULL, n->line, n->pos);
                 goto out;                  goto out;
         }          }
   
         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 2239  post_bx(POST_ARGS)
Line 2196  post_bx(POST_ARGS)
          * uppercase blindly.           * uppercase blindly.
          */           */
   
         n = mdoc->last->child;          if ((n = mdoc->last->child) != NULL && (n = n->next) != NULL)
         if (n && NULL != (n = n->next))  
                 *n->string = (char)toupper((unsigned char)*n->string);                  *n->string = (char)toupper((unsigned char)*n->string);
 }  }
   
Line 2266  post_os(POST_ARGS)
Line 2222  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 2278  post_os(POST_ARGS)
Line 2234  post_os(POST_ARGS)
 #ifdef OSNAME  #ifdef OSNAME
         mdoc->meta.os = mandoc_strdup(OSNAME);          mdoc->meta.os = mandoc_strdup(OSNAME);
 #else /*!OSNAME */  #else /*!OSNAME */
         if (NULL == defbuf) {          if (defbuf == NULL) {
                 if (-1 == uname(&utsname)) {                  if (uname(&utsname) == -1) {
                         mandoc_msg(MANDOCERR_OS_UNAME, mdoc->parse,                          mandoc_msg(MANDOCERR_OS_UNAME, mdoc->parse,
                             n->line, n->pos, "Os");                              n->line, n->pos, "Os");
                         defbuf = mandoc_strdup("UNKNOWN");                          defbuf = mandoc_strdup("UNKNOWN");
Line 2305  post_ex(POST_ARGS)
Line 2261  post_ex(POST_ARGS)
   
         n = mdoc->last;          n = mdoc->last;
   
         if (n->child)          if (n->child != NULL)
                 return;                  return;
   
         if (mdoc->meta.name == NULL) {          if (mdoc->meta.name == NULL) {
Line 2315  post_ex(POST_ARGS)
Line 2271  post_ex(POST_ARGS)
         }          }
   
         mdoc->next = ROFF_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;
 }  }
   
Line 2326  a2sec(const char *p)
Line 2282  a2sec(const char *p)
   
         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 roff_sec)i);                          return (enum roff_sec)i;
   
         return(SEC_CUSTOM);          return SEC_CUSTOM;
 }  }
   
 static size_t  static size_t
Line 2337  macro2len(int macro)
Line 2293  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.288  
changed lines
  Added in v.1.297
CVSweb