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

Diff for /mandoc/mdoc_macro.c between version 1.178 and 1.205

version 1.178, 2015/02/06 03:38:45 version 1.205, 2015/10/17 00:21:07
Line 7 
Line 7 
  * 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 26 
Line 26 
 #include <string.h>  #include <string.h>
 #include <time.h>  #include <time.h>
   
 #include "mdoc.h"  
 #include "mandoc.h"  #include "mandoc.h"
 #include "libmdoc.h"  #include "roff.h"
   #include "mdoc.h"
 #include "libmandoc.h"  #include "libmandoc.h"
   #include "roff_int.h"
   #include "libmdoc.h"
   
 static  void            blk_full(MACRO_PROT_ARGS);  static  void            blk_full(MACRO_PROT_ARGS);
 static  void            blk_exp_close(MACRO_PROT_ARGS);  static  void            blk_exp_close(MACRO_PROT_ARGS);
Line 41  static void  in_line_argn(MACRO_PROT_ARGS);
Line 43  static void  in_line_argn(MACRO_PROT_ARGS);
 static  void            in_line(MACRO_PROT_ARGS);  static  void            in_line(MACRO_PROT_ARGS);
 static  void            phrase_ta(MACRO_PROT_ARGS);  static  void            phrase_ta(MACRO_PROT_ARGS);
   
 static  void            dword(struct mdoc *, int, int, const char *,  static  void            append_delims(struct roff_man *, int, int *, char *);
                                  enum mdelim, int);  static  void            dword(struct roff_man *, int, int, const char *,
 static  void            append_delims(struct mdoc *, int, int *, char *);                                  enum mdelim, int);
 static  enum mdoct      lookup(struct mdoc *, enum mdoct,  static  int             find_pending(struct roff_man *, int, int, int,
                                 int, int, const char *);                                  struct roff_node *);
   static  int             lookup(struct roff_man *, int, int, int, const char *);
 static  int             macro_or_word(MACRO_PROT_ARGS, int);  static  int             macro_or_word(MACRO_PROT_ARGS, int);
 static  void            make_pending(struct mdoc *, struct mdoc_node *,  static  int             parse_rest(struct roff_man *, int, int, int *, char *);
                                 struct mdoc_node *, int, int);  static  int             rew_alt(int);
 static  int             parse_rest(struct mdoc *, enum mdoct,  static  void            rew_elem(struct roff_man *, int);
                                 int, int *, char *);  static  void            rew_last(struct roff_man *, const struct roff_node *);
 static  enum mdoct      rew_alt(enum mdoct);  static  void            rew_pending(struct roff_man *,
 static  void            rew_elem(struct mdoc *, enum mdoct);                                  const struct roff_node *);
 static  void            rew_last(struct mdoc *, const struct mdoc_node *);  
 static  void            rew_pending(struct mdoc *, const struct mdoc_node *);  
   
 const   struct mdoc_macro __mdoc_macros[MDOC_MAX] = {  const   struct mdoc_macro __mdoc_macros[MDOC_MAX] = {
         { in_line_argn, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* Ap */          { in_line_argn, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* Ap */
Line 209  const struct mdoc_macro * const mdoc_macros = __mdoc_m
Line 210  const struct mdoc_macro * const mdoc_macros = __mdoc_m
  * are errors.   * are errors.
  */   */
 void  void
 mdoc_macroend(struct mdoc *mdoc)  mdoc_endparse(struct roff_man *mdoc)
 {  {
         struct mdoc_node *n;          struct roff_node *n;
   
         /* Scan for open explicit scopes. */          /* Scan for open explicit scopes. */
   
Line 219  mdoc_macroend(struct mdoc *mdoc)
Line 220  mdoc_macroend(struct mdoc *mdoc)
             mdoc->last->parent : mdoc->last;              mdoc->last->parent : mdoc->last;
   
         for ( ; n; n = n->parent)          for ( ; n; n = n->parent)
                 if (n->type == MDOC_BLOCK &&                  if (n->type == ROFFT_BLOCK &&
                     mdoc_macros[n->tok].flags & MDOC_EXPLICIT)                      mdoc_macros[n->tok].flags & MDOC_EXPLICIT)
                         mandoc_msg(MANDOCERR_BLK_NOEND, mdoc->parse,                          mandoc_msg(MANDOCERR_BLK_NOEND, mdoc->parse,
                             n->line, n->pos, mdoc_macronames[n->tok]);                              n->line, n->pos, mdoc_macronames[n->tok]);
Line 231  mdoc_macroend(struct mdoc *mdoc)
Line 232  mdoc_macroend(struct mdoc *mdoc)
   
 /*  /*
  * Look up the macro at *p called by "from",   * Look up the macro at *p called by "from",
  * or as a line macro if from == MDOC_MAX.   * or as a line macro if from == TOKEN_NONE.
  */   */
 static enum mdoct  static int
 lookup(struct mdoc *mdoc, enum mdoct from, int line, int ppos, const char *p)  lookup(struct roff_man *mdoc, int from, int line, int ppos, const char *p)
 {  {
         enum mdoct       res;          int      res;
   
         if (from == MDOC_MAX || mdoc_macros[from].flags & MDOC_PARSED) {          if (mdoc->flags & MDOC_PHRASEQF) {
                   mdoc->flags &= ~MDOC_PHRASEQF;
                   return TOKEN_NONE;
           }
           if (from == TOKEN_NONE || mdoc_macros[from].flags & MDOC_PARSED) {
                 res = mdoc_hash_find(p);                  res = mdoc_hash_find(p);
                 if (res != MDOC_MAX) {                  if (res != TOKEN_NONE) {
                         if (mdoc_macros[res].flags & MDOC_CALLABLE)                          if (mdoc_macros[res].flags & MDOC_CALLABLE)
                                 return(res);                                  return res;
                         if (res != MDOC_br && res != MDOC_sp && res != MDOC_ll)                          if (res != MDOC_br && res != MDOC_sp && res != MDOC_ll)
                                 mandoc_msg(MANDOCERR_MACRO_CALL,                                  mandoc_msg(MANDOCERR_MACRO_CALL,
                                     mdoc->parse, line, ppos, p);                                      mdoc->parse, line, ppos, p);
                 }                  }
         }          }
         return(MDOC_MAX);          return TOKEN_NONE;
 }  }
   
 /*  /*
  * Rewind up to and including a specific node.   * Rewind up to and including a specific node.
  */   */
 static void  static void
 rew_last(struct mdoc *mdoc, const struct mdoc_node *to)  rew_last(struct roff_man *mdoc, const struct roff_node *to)
 {  {
         struct mdoc_node *n, *np;          struct roff_node        *np;
   
         assert(to);          if (to->flags & MDOC_VALID)
         mdoc->next = MDOC_NEXT_SIBLING;                  return;
   
         while (mdoc->last != to) {          while (mdoc->last != to) {
                 /*                  /*
                  * Save the parent here, because we may delete the                   * Save the parent here, because we may delete the
Line 270  rew_last(struct mdoc *mdoc, const struct mdoc_node *to
Line 276  rew_last(struct mdoc *mdoc, const struct mdoc_node *to
                  */                   */
                 np = mdoc->last->parent;                  np = mdoc->last->parent;
                 mdoc_valid_post(mdoc);                  mdoc_valid_post(mdoc);
                 n = mdoc->last;  
                 mdoc->last = np;                  mdoc->last = np;
                 assert(mdoc->last);                  assert(mdoc->last);
                 mdoc->last->last = n;  
         }          }
           mdoc->next = ROFF_NEXT_SIBLING;
         mdoc_valid_post(mdoc);          mdoc_valid_post(mdoc);
 }  }
   
Line 282  rew_last(struct mdoc *mdoc, const struct mdoc_node *to
Line 287  rew_last(struct mdoc *mdoc, const struct mdoc_node *to
  * Rewind up to a specific block, including all blocks that broke it.   * Rewind up to a specific block, including all blocks that broke it.
  */   */
 static void  static void
 rew_pending(struct mdoc *mdoc, const struct mdoc_node *n)  rew_pending(struct roff_man *mdoc, const struct roff_node *n)
 {  {
   
         rew_last(mdoc, n);          for (;;) {
                   rew_last(mdoc, n);
   
         if (n->type != MDOC_BLOCK)                  if (mdoc->last == n) {
                 return;                          switch (n->type) {
                           case ROFFT_HEAD:
                                   roff_body_alloc(mdoc, n->line, n->pos,
                                       n->tok);
                                   return;
                           case ROFFT_BLOCK:
                                   break;
                           default:
                                   return;
                           }
                           if ( ! (n->flags & MDOC_BROKEN))
                                   return;
                   } else
                           n = mdoc->last;
   
         while ((n = n->pending) != NULL) {                  for (;;) {
                 rew_last(mdoc, n);                          if ((n = n->parent) == NULL)
                 if (n->type == MDOC_HEAD)                                  return;
                         mdoc_body_alloc(mdoc, n->line, n->pos, n->tok);  
                           if (n->type == ROFFT_BLOCK ||
                               n->type == ROFFT_HEAD) {
                                   if (n->flags & MDOC_ENDED)
                                           break;
                                   else
                                           return;
                           }
                   }
         }          }
 }  }
   
Line 301  rew_pending(struct mdoc *mdoc, const struct mdoc_node 
Line 328  rew_pending(struct mdoc *mdoc, const struct mdoc_node 
  * For a block closing macro, return the corresponding opening one.   * For a block closing macro, return the corresponding opening one.
  * Otherwise, return the macro itself.   * Otherwise, return the macro itself.
  */   */
 static enum mdoct  static int
 rew_alt(enum mdoct tok)  rew_alt(int tok)
 {  {
         switch (tok) {          switch (tok) {
         case MDOC_Ac:          case MDOC_Ac:
                 return(MDOC_Ao);                  return MDOC_Ao;
         case MDOC_Bc:          case MDOC_Bc:
                 return(MDOC_Bo);                  return MDOC_Bo;
         case MDOC_Brc:          case MDOC_Brc:
                 return(MDOC_Bro);                  return MDOC_Bro;
         case MDOC_Dc:          case MDOC_Dc:
                 return(MDOC_Do);                  return MDOC_Do;
         case MDOC_Ec:          case MDOC_Ec:
                 return(MDOC_Eo);                  return MDOC_Eo;
         case MDOC_Ed:          case MDOC_Ed:
                 return(MDOC_Bd);                  return MDOC_Bd;
         case MDOC_Ef:          case MDOC_Ef:
                 return(MDOC_Bf);                  return MDOC_Bf;
         case MDOC_Ek:          case MDOC_Ek:
                 return(MDOC_Bk);                  return MDOC_Bk;
         case MDOC_El:          case MDOC_El:
                 return(MDOC_Bl);                  return MDOC_Bl;
         case MDOC_Fc:          case MDOC_Fc:
                 return(MDOC_Fo);                  return MDOC_Fo;
         case MDOC_Oc:          case MDOC_Oc:
                 return(MDOC_Oo);                  return MDOC_Oo;
         case MDOC_Pc:          case MDOC_Pc:
                 return(MDOC_Po);                  return MDOC_Po;
         case MDOC_Qc:          case MDOC_Qc:
                 return(MDOC_Qo);                  return MDOC_Qo;
         case MDOC_Re:          case MDOC_Re:
                 return(MDOC_Rs);                  return MDOC_Rs;
         case MDOC_Sc:          case MDOC_Sc:
                 return(MDOC_So);                  return MDOC_So;
         case MDOC_Xc:          case MDOC_Xc:
                 return(MDOC_Xo);                  return MDOC_Xo;
         default:          default:
                 return(tok);                  return tok;
         }          }
         /* NOTREACHED */  
 }  }
   
 static void  static void
 rew_elem(struct mdoc *mdoc, enum mdoct tok)  rew_elem(struct roff_man *mdoc, int tok)
 {  {
         struct mdoc_node *n;          struct roff_node *n;
   
         n = mdoc->last;          n = mdoc->last;
         if (MDOC_ELEM != n->type)          if (n->type != ROFFT_ELEM)
                 n = n->parent;                  n = n->parent;
         assert(MDOC_ELEM == n->type);          assert(n->type == ROFFT_ELEM);
         assert(tok == n->tok);          assert(tok == n->tok);
         rew_last(mdoc, n);          rew_last(mdoc, n);
 }  }
   
 /*  /*
  * We are trying to close the block *breaker,   * If there is an open sub-block of the target requiring
  * but the child block *broken is still open.   * explicit close-out, postpone closing out the target until
  * Thus, postpone closing the *breaker   * the rew_pending() call closing out the sub-block.
  * until the rew_pending() call closing *broken.  
  */   */
 static void  static int
 make_pending(struct mdoc *mdoc, struct mdoc_node *breaker,  find_pending(struct roff_man *mdoc, int tok, int line, int ppos,
         struct mdoc_node *broken, int line, int ppos)          struct roff_node *target)
 {  {
         struct mdoc_node *n;          struct roff_node        *n;
           int                      irc;
   
         mandoc_vmsg(MANDOCERR_BLK_NEST, mdoc->parse, line, ppos,          irc = 0;
             "%s breaks %s", mdoc_macronames[breaker->tok],          for (n = mdoc->last; n != NULL && n != target; n = n->parent) {
             mdoc_macronames[broken->tok]);                  if (n->flags & MDOC_ENDED) {
                           if ( ! (n->flags & MDOC_VALID))
         /*                                  n->flags |= MDOC_BROKEN;
          * If the *broken block (Z) is already broken by a block (B)                          continue;
          * contained in the breaker (A), make the breaker pending                  }
          * on that inner breaker (B).  Graphically,                  if (n->type == ROFFT_BLOCK &&
          *                      mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {
          * breaker=[A! broken=n=[B!->A (old broken=)[Z->B B] A] Z]                          irc = 1;
          *                          n->flags = MDOC_BROKEN;
          * In these graphics, "->" indicates the "pending" pointer and                          if (target->type == ROFFT_HEAD)
          * "!" indicates the MDOC_BREAK flag.  Each of the cases gets                                  target->flags = MDOC_ENDED;
          * one additional pointer (B->A) and one additional flag (A!).                          else if ( ! (target->flags & MDOC_ENDED)) {
          */                                  mandoc_vmsg(MANDOCERR_BLK_NEST,
                                       mdoc->parse, line, ppos,
         for (n = broken->parent; ; n = n->parent)                                      "%s breaks %s", mdoc_macronames[tok],
                 if (n == broken->pending)                                      mdoc_macronames[n->tok]);
                         broken = n;                                  mdoc_endbody_alloc(mdoc, line, ppos,
                 else if (n == breaker)                                      tok, target, ENDBODY_NOSPACE);
                         break;                          }
                   }
         /*  
          * Found the breaker.  
          *  
          * If another, outer breaker (X) is already pending on  
          * the *broken block (B), we must not clobber the link  
          * to the outer breaker, but make it pending on the new,  
          * now inner breaker (A).  Graphically,  
          *  
          * [X! n=breaker=[A!->X broken=[B(->X)->A X] A] B].  
          */  
   
         if (broken->pending != NULL) {  
                 n = breaker;  
   
                 /*  
                  * If the inner breaker (A) is already broken, too,  
                  * it cannot take on the outer breaker (X) but must  
                  * hand it on to its own breakers (Y).  Graphically,  
                  *  
                  * [X! n=[Y!->X breaker=[A!->Y Y] broken=[B(->X)->A X] A] B]  
                  */  
   
                 while (n->pending)  
                         n = n->pending;  
                 n->pending = broken->pending;  
         }          }
           return irc;
         /*  
          * Now we have reduced the situation to the simplest case:  
          * breaker=[A! broken=[B->A A] B].  
          */  
   
         broken->pending = breaker;  
         breaker->flags |= MDOC_BREAK;  
         if (breaker->body != NULL)  
                 breaker->body->flags |= MDOC_BREAK;  
 }  }
   
 /*  /*
Line 433  make_pending(struct mdoc *mdoc, struct mdoc_node *brea
Line 425  make_pending(struct mdoc *mdoc, struct mdoc_node *brea
  * Punctuation consists of those tokens found in mdoc_isdelim().   * Punctuation consists of those tokens found in mdoc_isdelim().
  */   */
 static void  static void
 dword(struct mdoc *mdoc, int line, int col, const char *p,  dword(struct roff_man *mdoc, int line, int col, const char *p,
                 enum mdelim d, int may_append)                  enum mdelim d, int may_append)
 {  {
   
Line 442  dword(struct mdoc *mdoc, int line, int col, const char
Line 434  dword(struct mdoc *mdoc, int line, int col, const char
   
         if (may_append &&          if (may_append &&
             ! (mdoc->flags & (MDOC_SYNOPSIS | MDOC_KEEP | MDOC_SMOFF)) &&              ! (mdoc->flags & (MDOC_SYNOPSIS | MDOC_KEEP | MDOC_SMOFF)) &&
             d == DELIM_NONE && mdoc->last->type == MDOC_TEXT &&              d == DELIM_NONE && mdoc->last->type == ROFFT_TEXT &&
             mdoc_isdelim(mdoc->last->string) == DELIM_NONE) {              mdoc_isdelim(mdoc->last->string) == DELIM_NONE) {
                 mdoc_word_append(mdoc, p);                  roff_word_append(mdoc, p);
                 return;                  return;
         }          }
   
         mdoc_word_alloc(mdoc, line, col, p);          roff_word_alloc(mdoc, line, col, p);
   
         /*          /*
          * If the word consists of a bare delimiter,           * If the word consists of a bare delimiter,
Line 467  dword(struct mdoc *mdoc, int line, int col, const char
Line 459  dword(struct mdoc *mdoc, int line, int col, const char
 }  }
   
 static void  static void
 append_delims(struct mdoc *mdoc, int line, int *pos, char *buf)  append_delims(struct roff_man *mdoc, int line, int *pos, char *buf)
 {  {
         char            *p;          char            *p;
         int              la;          int              la;
Line 477  append_delims(struct mdoc *mdoc, int line, int *pos, c
Line 469  append_delims(struct mdoc *mdoc, int line, int *pos, c
   
         for (;;) {          for (;;) {
                 la = *pos;                  la = *pos;
                 if (mdoc_args(mdoc, line, pos, buf, MDOC_MAX, &p) == ARGS_EOLN)                  if (mdoc_args(mdoc, line, pos, buf, TOKEN_NONE, &p) ==
                       ARGS_EOLN)
                         break;                          break;
                 dword(mdoc, line, la, p, DELIM_MAX, 1);                  dword(mdoc, line, la, p, DELIM_MAX, 1);
   
Line 507  static int
Line 500  static int
 macro_or_word(MACRO_PROT_ARGS, int parsed)  macro_or_word(MACRO_PROT_ARGS, int parsed)
 {  {
         char            *p;          char            *p;
         enum mdoct       ntok;          int              ntok;
   
         p = buf + ppos;          p = buf + ppos;
         ntok = MDOC_MAX;          ntok = TOKEN_NONE;
         if (*p == '"')          if (*p == '"')
                 p++;                  p++;
         else if (parsed && ! (mdoc->flags & MDOC_PHRASELIT))          else if (parsed && ! (mdoc->flags & MDOC_PHRASELIT))
                 ntok = lookup(mdoc, tok, line, ppos, p);                  ntok = lookup(mdoc, tok, line, ppos, p);
   
         if (ntok == MDOC_MAX) {          if (ntok == TOKEN_NONE) {
                 dword(mdoc, line, ppos, p, DELIM_MAX, tok == MDOC_MAX ||                  dword(mdoc, line, ppos, p, DELIM_MAX, tok == TOKEN_NONE ||
                     mdoc_macros[tok].flags & MDOC_JOIN);                      mdoc_macros[tok].flags & MDOC_JOIN);
                 return(0);                  return 0;
         } else {          } else {
                 if (mdoc_macros[tok].fp == in_line_eoln)                  if (mdoc_macros[tok].fp == in_line_eoln)
                         rew_elem(mdoc, tok);                          rew_elem(mdoc, tok);
                 mdoc_macro(mdoc, ntok, line, ppos, pos, buf);                  mdoc_macro(mdoc, ntok, line, ppos, pos, buf);
                 if (tok == MDOC_MAX)                  if (tok == TOKEN_NONE)
                         append_delims(mdoc, line, pos, buf);                          append_delims(mdoc, line, pos, buf);
                 return(1);                  return 1;
         }          }
 }  }
   
Line 536  macro_or_word(MACRO_PROT_ARGS, int parsed)
Line 529  macro_or_word(MACRO_PROT_ARGS, int parsed)
 static void  static void
 blk_exp_close(MACRO_PROT_ARGS)  blk_exp_close(MACRO_PROT_ARGS)
 {  {
         struct mdoc_node *body;         /* Our own body. */          struct roff_node *body;         /* Our own body. */
         struct mdoc_node *endbody;      /* Our own end marker. */          struct roff_node *endbody;      /* Our own end marker. */
         struct mdoc_node *itblk;        /* An It block starting later. */          struct roff_node *itblk;        /* An It block starting later. */
         struct mdoc_node *later;        /* A sub-block starting later. */          struct roff_node *later;        /* A sub-block starting later. */
         struct mdoc_node *n;            /* Search back to our block. */          struct roff_node *n;            /* Search back to our block. */
           struct roff_node *target;       /* For find_pending(). */
   
         int              j, lastarg, maxargs, nl;          int              j, lastarg, maxargs, nl, pending;
         enum margserr    ac;          enum margserr    ac;
         enum mdoct       atok, ntok;          int              atok, ntok;
         char            *p;          char            *p;
   
         nl = MDOC_NEWLINE & mdoc->flags;          nl = MDOC_NEWLINE & mdoc->flags;
Line 569  blk_exp_close(MACRO_PROT_ARGS)
Line 563  blk_exp_close(MACRO_PROT_ARGS)
         atok = rew_alt(tok);          atok = rew_alt(tok);
         body = endbody = itblk = later = NULL;          body = endbody = itblk = later = NULL;
         for (n = mdoc->last; n; n = n->parent) {          for (n = mdoc->last; n; n = n->parent) {
                 if (n->flags & (MDOC_VALID | MDOC_BREAK))                  if (n->flags & MDOC_ENDED) {
                           if ( ! (n->flags & MDOC_VALID))
                                   n->flags |= MDOC_BROKEN;
                         continue;                          continue;
                   }
   
                 /* Remember the start of our own body. */                  /* Remember the start of our own body. */
   
                 if (n->type == MDOC_BODY && atok == n->tok) {                  if (n->type == ROFFT_BODY && atok == n->tok) {
                         if (n->end == ENDBODY_NOT)                          if (n->end == ENDBODY_NOT)
                                 body = n;                                  body = n;
                         continue;                          continue;
                 }                  }
   
                 if (n->type != MDOC_BLOCK || n->tok == MDOC_Nm)                  if (n->type != ROFFT_BLOCK || n->tok == MDOC_Nm)
                         continue;                          continue;
   
                 if (n->tok == MDOC_It) {                  if (n->tok == MDOC_It) {
Line 605  blk_exp_close(MACRO_PROT_ARGS)
Line 602  blk_exp_close(MACRO_PROT_ARGS)
                          * When there is a pending sub block, postpone                           * When there is a pending sub block, postpone
                          * closing out the current block until the                           * closing out the current block until the
                          * rew_pending() closing out the sub-block.                           * rew_pending() closing out the sub-block.
                          */  
   
                         make_pending(mdoc, n, later, line, ppos);  
                         if (tok == MDOC_El)  
                                 itblk->flags |= MDOC_BREAK;  
   
                         /*  
                          * Mark the place where the formatting - but not                           * Mark the place where the formatting - but not
                          * the scope - of the current block ends.                           * the scope - of the current block ends.
                          */                           */
   
                           mandoc_vmsg(MANDOCERR_BLK_NEST, mdoc->parse,
                               line, ppos, "%s breaks %s",
                               mdoc_macronames[atok],
                               mdoc_macronames[later->tok]);
   
                         endbody = mdoc_endbody_alloc(mdoc, line, ppos,                          endbody = mdoc_endbody_alloc(mdoc, line, ppos,
                             atok, body, ENDBODY_SPACE);                              atok, body, ENDBODY_SPACE);
   
                           if (tok == MDOC_El)
                                   itblk->flags |= MDOC_ENDED | MDOC_BROKEN;
   
                         /*                          /*
                          * If a block closing macro taking arguments                           * If a block closing macro taking arguments
                          * breaks another block, put the arguments                           * breaks another block, put the arguments
Line 626  blk_exp_close(MACRO_PROT_ARGS)
Line 624  blk_exp_close(MACRO_PROT_ARGS)
                          */                           */
   
                         if (maxargs)                          if (maxargs)
                                 mdoc->next = MDOC_NEXT_CHILD;                                  mdoc->next = ROFF_NEXT_CHILD;
                         break;                          break;
                 }                  }
   
                 /*                  /* Explicit blocks close out description lines. */
                  * When finding an open sub block, remember the last  
                  * open explicit block, or, in case there are only  
                  * implicit ones, the first open implicit block.  
                  */  
   
                 if (later == NULL ||                  if (n->tok == MDOC_Nd) {
                     ! (mdoc_macros[later->tok].flags & MDOC_EXPLICIT))                          rew_last(mdoc, n);
                           continue;
                   }
   
                   /* Breaking an open sub block. */
   
                   n->flags |= MDOC_BROKEN;
                   if (later == NULL)
                         later = n;                          later = n;
         }          }
   
         if (body == NULL) {          if (body == NULL) {
                 mandoc_msg(MANDOCERR_BLK_NOTOPEN, mdoc->parse,                  mandoc_msg(MANDOCERR_BLK_NOTOPEN, mdoc->parse,
                     line, ppos, mdoc_macronames[tok]);                      line, ppos, mdoc_macronames[tok]);
                   if (later != NULL)
                           later->flags &= ~MDOC_BROKEN;
                 if (maxargs && endbody == NULL) {                  if (maxargs && endbody == NULL) {
                         /*                          /*
                          * Stray .Ec without previous .Eo:                           * Stray .Ec without previous .Eo:
                          * Break the output line, keep the arguments.                           * Break the output line, keep the arguments.
                          */                           */
                         mdoc_elem_alloc(mdoc, line, ppos, MDOC_br, NULL);                          roff_elem_alloc(mdoc, line, ppos, MDOC_br);
                         rew_elem(mdoc, MDOC_br);                          rew_elem(mdoc, MDOC_br);
                 }                  }
         } else if (endbody == NULL) {          } else if (endbody == NULL) {
Line 671  blk_exp_close(MACRO_PROT_ARGS)
Line 674  blk_exp_close(MACRO_PROT_ARGS)
   
         if (endbody != NULL)          if (endbody != NULL)
                 n = endbody;                  n = endbody;
   
           ntok = TOKEN_NONE;
         for (j = 0; ; j++) {          for (j = 0; ; j++) {
                 lastarg = *pos;                  lastarg = *pos;
   
                 if (j == maxargs && n != NULL) {                  if (j == maxargs && n != NULL)
                         rew_pending(mdoc, n);                          rew_last(mdoc, n);
                         n = NULL;  
                 }  
   
                 ac = mdoc_args(mdoc, line, pos, buf, tok, &p);                  ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
                 if (ac == ARGS_PUNCT || ac == ARGS_EOLN)                  if (ac == ARGS_PUNCT || ac == ARGS_EOLN)
                         break;                          break;
   
                 ntok = ac == ARGS_QWORD ? MDOC_MAX :                  ntok = ac == ARGS_QWORD ? TOKEN_NONE :
                     lookup(mdoc, tok, line, lastarg, p);                      lookup(mdoc, tok, line, lastarg, p);
   
                 if (ntok == MDOC_MAX) {                  if (ntok == TOKEN_NONE) {
                         dword(mdoc, line, lastarg, p, DELIM_MAX,                          dword(mdoc, line, lastarg, p, DELIM_MAX,
                             MDOC_JOIN & mdoc_macros[tok].flags);                              MDOC_JOIN & mdoc_macros[tok].flags);
                         continue;                          continue;
                 }                  }
   
                 if (n != NULL) {                  if (n != NULL)
                         rew_pending(mdoc, n);                          rew_last(mdoc, n);
                         n = NULL;  
                 }  
                 mdoc->flags &= ~MDOC_NEWLINE;                  mdoc->flags &= ~MDOC_NEWLINE;
                 mdoc_macro(mdoc, ntok, line, lastarg, pos, buf);                  mdoc_macro(mdoc, ntok, line, lastarg, pos, buf);
                 break;                  break;
         }          }
   
         if (n != NULL)          if (n != NULL) {
                 rew_pending(mdoc, n);                  if (ntok != TOKEN_NONE && n->flags & MDOC_BROKEN) {
                           target = n;
                           do
                                   target = target->parent;
                           while ( ! (target->flags & MDOC_ENDED));
                           pending = find_pending(mdoc, ntok, line, ppos,
                               target);
                   } else
                           pending = 0;
                   if ( ! pending)
                           rew_pending(mdoc, n);
           }
         if (nl)          if (nl)
                 append_delims(mdoc, line, pos, buf);                  append_delims(mdoc, line, pos, buf);
 }  }
Line 711  static void
Line 723  static void
 in_line(MACRO_PROT_ARGS)  in_line(MACRO_PROT_ARGS)
 {  {
         int              la, scope, cnt, firstarg, mayopen, nc, nl;          int              la, scope, cnt, firstarg, mayopen, nc, nl;
         enum mdoct       ntok;          int              ntok;
         enum margserr    ac;          enum margserr    ac;
         enum mdelim      d;          enum mdelim      d;
         struct mdoc_arg *arg;          struct mdoc_arg *arg;
Line 726  in_line(MACRO_PROT_ARGS)
Line 738  in_line(MACRO_PROT_ARGS)
   
         switch (tok) {          switch (tok) {
         case MDOC_An:          case MDOC_An:
                 /* FALLTHROUGH */  
         case MDOC_Ar:          case MDOC_Ar:
                 /* FALLTHROUGH */  
         case MDOC_Fl:          case MDOC_Fl:
                 /* FALLTHROUGH */  
         case MDOC_Mt:          case MDOC_Mt:
                 /* FALLTHROUGH */  
         case MDOC_Nm:          case MDOC_Nm:
                 /* FALLTHROUGH */  
         case MDOC_Pa:          case MDOC_Pa:
                 nc = 1;                  nc = 1;
                 break;                  break;
Line 778  in_line(MACRO_PROT_ARGS)
Line 785  in_line(MACRO_PROT_ARGS)
                 }                  }
   
                 ntok = (ac == ARGS_QWORD || (tok == MDOC_Fn && !cnt)) ?                  ntok = (ac == ARGS_QWORD || (tok == MDOC_Fn && !cnt)) ?
                     MDOC_MAX : lookup(mdoc, tok, line, la, p);                      TOKEN_NONE : lookup(mdoc, tok, line, la, p);
   
                 /*                  /*
                  * In this case, we've located a submacro and must                   * In this case, we've located a submacro and must
Line 787  in_line(MACRO_PROT_ARGS)
Line 794  in_line(MACRO_PROT_ARGS)
                  * or raise a warning.                   * or raise a warning.
                  */                   */
   
                 if (ntok != MDOC_MAX) {                  if (ntok != TOKEN_NONE) {
                         if (scope)                          if (scope)
                                 rew_elem(mdoc, tok);                                  rew_elem(mdoc, tok);
                         if (nc && ! cnt) {                          if (nc && ! cnt) {
Line 895  blk_full(MACRO_PROT_ARGS)
Line 902  blk_full(MACRO_PROT_ARGS)
 {  {
         int               la, nl, parsed;          int               la, nl, parsed;
         struct mdoc_arg  *arg;          struct mdoc_arg  *arg;
         struct mdoc_node *blk; /* Our own or a broken block. */          struct roff_node *blk; /* Our own or a broken block. */
         struct mdoc_node *head; /* Our own head. */          struct roff_node *head; /* Our own head. */
         struct mdoc_node *body; /* Our own body. */          struct roff_node *body; /* Our own body. */
         struct mdoc_node *n;          struct roff_node *n;
         enum margserr     ac, lac;          enum margserr     ac, lac;
         char             *p;          char             *p;
   
Line 916  blk_full(MACRO_PROT_ARGS)
Line 923  blk_full(MACRO_PROT_ARGS)
   
                 blk = NULL;                  blk = NULL;
                 for (n = mdoc->last; n != NULL; n = n->parent) {                  for (n = mdoc->last; n != NULL; n = n->parent) {
                         if (n->flags & (MDOC_VALID | MDOC_BREAK) ||                          if (n->flags & MDOC_ENDED) {
                             n->type != MDOC_BLOCK)                                  if ( ! (n->flags & MDOC_VALID))
                                           n->flags |= MDOC_BROKEN;
                                 continue;                                  continue;
                           }
                           if (n->type != ROFFT_BLOCK)
                                   continue;
   
                         if (tok == MDOC_It && n->tok == MDOC_Bl) {                          if (tok == MDOC_It && n->tok == MDOC_Bl) {
                                 if (blk != NULL) {                                  if (blk != NULL) {
                                         mandoc_vmsg(MANDOCERR_BLK_BROKEN,                                          mandoc_vmsg(MANDOCERR_BLK_BROKEN,
Line 933  blk_full(MACRO_PROT_ARGS)
Line 945  blk_full(MACRO_PROT_ARGS)
                         if (mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {                          if (mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {
                                 switch (tok) {                                  switch (tok) {
                                 case MDOC_Sh:                                  case MDOC_Sh:
                                         /* FALLTHROUGH */  
                                 case MDOC_Ss:                                  case MDOC_Ss:
                                         mandoc_vmsg(MANDOCERR_BLK_BROKEN,                                          mandoc_vmsg(MANDOCERR_BLK_BROKEN,
                                             mdoc->parse, line, ppos,                                              mdoc->parse, line, ppos,
Line 941  blk_full(MACRO_PROT_ARGS)
Line 952  blk_full(MACRO_PROT_ARGS)
                                             mdoc_macronames[tok],                                              mdoc_macronames[tok],
                                             mdoc_macronames[n->tok]);                                              mdoc_macronames[n->tok]);
                                         rew_pending(mdoc, n);                                          rew_pending(mdoc, n);
                                           n = mdoc->last;
                                         continue;                                          continue;
                                 case MDOC_It:                                  case MDOC_It:
                                         /* Delay in case it's astray. */                                          /* Delay in case it's astray. */
Line 980  blk_full(MACRO_PROT_ARGS)
Line 992  blk_full(MACRO_PROT_ARGS)
                 if (tok == MDOC_It && (n == NULL || n->tok != MDOC_Bl)) {                  if (tok == MDOC_It && (n == NULL || n->tok != MDOC_Bl)) {
                         mandoc_vmsg(MANDOCERR_IT_STRAY, mdoc->parse,                          mandoc_vmsg(MANDOCERR_IT_STRAY, mdoc->parse,
                             line, ppos, "It %s", buf + *pos);                              line, ppos, "It %s", buf + *pos);
                         mdoc_elem_alloc(mdoc, line, ppos, MDOC_br, NULL);                          roff_elem_alloc(mdoc, line, ppos, MDOC_br);
                         rew_elem(mdoc, MDOC_br);                          rew_elem(mdoc, MDOC_br);
                         return;                          return;
                 }                  }
Line 1014  blk_full(MACRO_PROT_ARGS)
Line 1026  blk_full(MACRO_PROT_ARGS)
          */           */
   
         if (tok == MDOC_Nd) {          if (tok == MDOC_Nd) {
                 head = mdoc_head_alloc(mdoc, line, ppos, tok);                  head = roff_head_alloc(mdoc, line, ppos, tok);
                 rew_last(mdoc, head);                  rew_last(mdoc, head);
                 body = mdoc_body_alloc(mdoc, line, ppos, tok);                  body = roff_body_alloc(mdoc, line, ppos, tok);
         }          }
   
         if (tok == MDOC_Bk)          if (tok == MDOC_Bk)
                 mdoc->flags |= MDOC_KEEP;                  mdoc->flags |= MDOC_KEEP;
   
         ac = ARGS_PEND;          ac = ARGS_EOLN;
         for (;;) {          for (;;) {
   
                   /*
                    * If we are right after a tab character,
                    * do not parse the first word for macros.
                    */
   
                   if (mdoc->flags & MDOC_PHRASEQN) {
                           mdoc->flags &= ~MDOC_PHRASEQN;
                           mdoc->flags |= MDOC_PHRASEQF;
                   }
   
                 la = *pos;                  la = *pos;
                 lac = ac;                  lac = ac;
                 ac = mdoc_args(mdoc, line, pos, buf, tok, &p);                  ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
                 if (ac == ARGS_EOLN) {                  if (ac == ARGS_EOLN) {
                         if (lac != ARGS_PPHRASE && lac != ARGS_PHRASE)                          if (lac != ARGS_PHRASE ||
                               ! (mdoc->flags & MDOC_PHRASEQF))
                                 break;                                  break;
   
                         /*                          /*
                          * This is necessary: if the last token on a                           * This line ends in a tab; start the next
                          * line is a `Ta' or tab, then we'll get                           * column now, with a leading blank.
                          * ARGS_EOLN, so we must be smart enough to  
                          * reopen our scope if the last parse was a  
                          * phrase or partial phrase.  
                          */                           */
   
                         if (body != NULL)                          if (body != NULL)
                                 rew_last(mdoc, body);                                  rew_last(mdoc, body);
                         body = mdoc_body_alloc(mdoc, line, ppos, tok);                          body = roff_body_alloc(mdoc, line, ppos, tok);
                           roff_word_alloc(mdoc, line, ppos, "\\&");
                         break;                          break;
                 }                  }
   
                 if (tok == MDOC_Bd || tok == MDOC_Bk) {                  if (tok == MDOC_Bd || tok == MDOC_Bk) {
                         mandoc_vmsg(MANDOCERR_ARG_EXCESS,                          mandoc_vmsg(MANDOCERR_ARG_EXCESS,
                             mdoc->parse, line, la, "%s ... %s",                              mdoc->parse, line, la, "%s ... %s",
Line 1058  blk_full(MACRO_PROT_ARGS)
Line 1083  blk_full(MACRO_PROT_ARGS)
   
                 /*                  /*
                  * Emit leading punctuation (i.e., punctuation before                   * Emit leading punctuation (i.e., punctuation before
                  * the MDOC_HEAD) for non-phrase types.                   * the ROFFT_HEAD) for non-phrase types.
                  */                   */
   
                 if (head == NULL &&                  if (head == NULL &&
                     ac != ARGS_PEND &&  
                     ac != ARGS_PHRASE &&                      ac != ARGS_PHRASE &&
                     ac != ARGS_PPHRASE &&  
                     ac != ARGS_QWORD &&                      ac != ARGS_QWORD &&
                     mdoc_isdelim(p) == DELIM_OPEN) {                      mdoc_isdelim(p) == DELIM_OPEN) {
                         dword(mdoc, line, la, p, DELIM_OPEN, 0);                          dword(mdoc, line, la, p, DELIM_OPEN, 0);
Line 1074  blk_full(MACRO_PROT_ARGS)
Line 1097  blk_full(MACRO_PROT_ARGS)
                 /* Open a head if one hasn't been opened. */                  /* Open a head if one hasn't been opened. */
   
                 if (head == NULL)                  if (head == NULL)
                         head = mdoc_head_alloc(mdoc, line, ppos, tok);                          head = roff_head_alloc(mdoc, line, ppos, tok);
   
                 if (ac == ARGS_PHRASE ||                  if (ac == ARGS_PHRASE) {
                     ac == ARGS_PEND ||  
                     ac == ARGS_PPHRASE) {  
   
                         /*                          /*
                          * If we haven't opened a body yet, rewind the                           * If we haven't opened a body yet, rewind the
Line 1086  blk_full(MACRO_PROT_ARGS)
Line 1107  blk_full(MACRO_PROT_ARGS)
                          */                           */
   
                         rew_last(mdoc, body == NULL ? head : body);                          rew_last(mdoc, body == NULL ? head : body);
                         body = mdoc_body_alloc(mdoc, line, ppos, tok);                          body = roff_body_alloc(mdoc, line, ppos, tok);
   
                         /*                          /* Process to the tab or to the end of the line. */
                          * Process phrases: set whether we're in a  
                          * partial-phrase (this effects line handling)  
                          * then call down into the phrase parser.  
                          */  
   
                         if (ac == ARGS_PPHRASE)                          mdoc->flags |= MDOC_PHRASE;
                                 mdoc->flags |= MDOC_PPHRASE;                          parse_rest(mdoc, TOKEN_NONE, line, &la, buf);
                         if (ac == ARGS_PEND && lac == ARGS_PPHRASE)                          mdoc->flags &= ~MDOC_PHRASE;
                                 mdoc->flags |= MDOC_PPHRASE;  
                         parse_rest(mdoc, MDOC_MAX, line, &la, buf);                          /* There may have been `Ta' macros. */
                         mdoc->flags &= ~MDOC_PPHRASE;  
                           while (body->next != NULL)
                                   body = body->next;
                         continue;                          continue;
                 }                  }
   
Line 1110  blk_full(MACRO_PROT_ARGS)
Line 1129  blk_full(MACRO_PROT_ARGS)
         if (blk->flags & MDOC_VALID)          if (blk->flags & MDOC_VALID)
                 return;                  return;
         if (head == NULL)          if (head == NULL)
                 head = mdoc_head_alloc(mdoc, line, ppos, tok);                  head = roff_head_alloc(mdoc, line, ppos, tok);
         if (nl && tok != MDOC_Bd && tok != MDOC_Bl && tok != MDOC_Rs)          if (nl && tok != MDOC_Bd && tok != MDOC_Bl && tok != MDOC_Rs)
                 append_delims(mdoc, line, pos, buf);                  append_delims(mdoc, line, pos, buf);
         if (body != NULL)          if (body != NULL)
                 goto out;                  goto out;
           if (find_pending(mdoc, tok, line, ppos, head))
                   return;
   
         /*  
          * If there is an open (i.e., unvalidated) sub-block requiring  
          * explicit close-out, postpone switching the current block from  
          * head to body until the rew_pending() call closing out that  
          * sub-block.  
          */  
         for (n = mdoc->last; n && n != head; n = n->parent) {  
                 if (n->type == MDOC_BLOCK &&  
                     mdoc_macros[n->tok].flags & MDOC_EXPLICIT &&  
                     ! (n->flags & MDOC_VALID)) {  
                         n->pending = head;  
                         return;  
                 }  
         }  
   
         /* Close out scopes to remain in a consistent state. */          /* Close out scopes to remain in a consistent state. */
   
         rew_last(mdoc, head);          rew_last(mdoc, head);
         body = mdoc_body_alloc(mdoc, line, ppos, tok);          body = roff_body_alloc(mdoc, line, ppos, tok);
 out:  out:
         if (mdoc->flags & MDOC_FREECOL) {          if (mdoc->flags & MDOC_FREECOL) {
                 rew_last(mdoc, body);                  rew_last(mdoc, body);
Line 1149  blk_part_imp(MACRO_PROT_ARGS)
Line 1155  blk_part_imp(MACRO_PROT_ARGS)
         int               la, nl;          int               la, nl;
         enum margserr     ac;          enum margserr     ac;
         char             *p;          char             *p;
         struct mdoc_node *blk; /* saved block context */          struct roff_node *blk; /* saved block context */
         struct mdoc_node *body; /* saved body context */          struct roff_node *body; /* saved body context */
         struct mdoc_node *n;          struct roff_node *n;
   
         nl = MDOC_NEWLINE & mdoc->flags;          nl = MDOC_NEWLINE & mdoc->flags;
   
Line 1165  blk_part_imp(MACRO_PROT_ARGS)
Line 1171  blk_part_imp(MACRO_PROT_ARGS)
          */           */
   
         blk = mdoc_block_alloc(mdoc, line, ppos, tok, NULL);          blk = mdoc_block_alloc(mdoc, line, ppos, tok, NULL);
         rew_last(mdoc, mdoc_head_alloc(mdoc, line, ppos, tok));          rew_last(mdoc, roff_head_alloc(mdoc, line, ppos, tok));
   
         /*          /*
          * Open the body scope "on-demand", that is, after we've           * Open the body scope "on-demand", that is, after we've
Line 1186  blk_part_imp(MACRO_PROT_ARGS)
Line 1192  blk_part_imp(MACRO_PROT_ARGS)
                 }                  }
   
                 if (body == NULL)                  if (body == NULL)
                         body = mdoc_body_alloc(mdoc, line, ppos, tok);                          body = roff_body_alloc(mdoc, line, ppos, tok);
   
                 if (macro_or_word(mdoc, tok, line, la, pos, buf, 1))                  if (macro_or_word(mdoc, tok, line, la, pos, buf, 1))
                         break;                          break;
         }          }
         if (body == NULL)          if (body == NULL)
                 body = mdoc_body_alloc(mdoc, line, ppos, tok);                  body = roff_body_alloc(mdoc, line, ppos, tok);
   
         /*          if (find_pending(mdoc, tok, line, ppos, body))
          * If there is an open sub-block requiring explicit close-out,                  return;
          * postpone closing out the current block until the  
          * rew_pending() call closing out the sub-block.  
          */  
   
         for (n = mdoc->last; n && n != body && n != blk->parent;  
              n = n->parent) {  
                 if (n->type == MDOC_BLOCK &&  
                     mdoc_macros[n->tok].flags & MDOC_EXPLICIT &&  
                     ! (n->flags & MDOC_VALID)) {  
                         make_pending(mdoc, blk, n, line, ppos);  
                         mdoc_endbody_alloc(mdoc, line, ppos,  
                             tok, body, ENDBODY_NOSPACE);  
                         return;  
                 }  
         }  
         assert(n == body);  
         rew_last(mdoc, body);          rew_last(mdoc, body);
         if (nl)          if (nl)
                 append_delims(mdoc, line, pos, buf);                  append_delims(mdoc, line, pos, buf);
Line 1230  blk_part_exp(MACRO_PROT_ARGS)
Line 1221  blk_part_exp(MACRO_PROT_ARGS)
 {  {
         int               la, nl;          int               la, nl;
         enum margserr     ac;          enum margserr     ac;
         struct mdoc_node *head; /* keep track of head */          struct roff_node *head; /* keep track of head */
         char             *p;          char             *p;
   
         nl = MDOC_NEWLINE & mdoc->flags;          nl = MDOC_NEWLINE & mdoc->flags;
Line 1241  blk_part_exp(MACRO_PROT_ARGS)
Line 1232  blk_part_exp(MACRO_PROT_ARGS)
          * case of `Eo'); and a body that may be empty.           * case of `Eo'); and a body that may be empty.
          */           */
   
         mdoc_block_alloc(mdoc, line, ppos, tok, NULL);          roff_block_alloc(mdoc, line, ppos, tok);
         head = NULL;          head = NULL;
         for (;;) {          for (;;) {
                 la = *pos;                  la = *pos;
Line 1258  blk_part_exp(MACRO_PROT_ARGS)
Line 1249  blk_part_exp(MACRO_PROT_ARGS)
                 }                  }
   
                 if (head == NULL) {                  if (head == NULL) {
                         head = mdoc_head_alloc(mdoc, line, ppos, tok);                          head = roff_head_alloc(mdoc, line, ppos, tok);
                         if (tok == MDOC_Eo)  /* Not parsed. */                          if (tok == MDOC_Eo)  /* Not parsed. */
                                 dword(mdoc, line, la, p, DELIM_MAX, 0);                                  dword(mdoc, line, la, p, DELIM_MAX, 0);
                         rew_last(mdoc, head);                          rew_last(mdoc, head);
                         mdoc_body_alloc(mdoc, line, ppos, tok);                          roff_body_alloc(mdoc, line, ppos, tok);
                         if (tok == MDOC_Eo)                          if (tok == MDOC_Eo)
                                 continue;                                  continue;
                 }                  }
Line 1274  blk_part_exp(MACRO_PROT_ARGS)
Line 1265  blk_part_exp(MACRO_PROT_ARGS)
         /* Clean-up to leave in a consistent state. */          /* Clean-up to leave in a consistent state. */
   
         if (head == NULL) {          if (head == NULL) {
                 rew_last(mdoc, mdoc_head_alloc(mdoc, line, ppos, tok));                  rew_last(mdoc, roff_head_alloc(mdoc, line, ppos, tok));
                 mdoc_body_alloc(mdoc, line, ppos, tok);                  roff_body_alloc(mdoc, line, ppos, tok);
         }          }
         if (nl)          if (nl)
                 append_delims(mdoc, line, pos, buf);                  append_delims(mdoc, line, pos, buf);
Line 1284  blk_part_exp(MACRO_PROT_ARGS)
Line 1275  blk_part_exp(MACRO_PROT_ARGS)
 static void  static void
 in_line_argn(MACRO_PROT_ARGS)  in_line_argn(MACRO_PROT_ARGS)
 {  {
         int              la, flushed, j, maxargs, nl;  
         enum margserr    ac;  
         struct mdoc_arg *arg;          struct mdoc_arg *arg;
         char            *p;          char            *p;
         enum mdoct       ntok;          enum margserr    ac;
           int              ntok;
           int              state; /* arg#; -1: not yet open; -2: closed */
           int              la, maxargs, nl;
   
         nl = mdoc->flags & MDOC_NEWLINE;          nl = mdoc->flags & MDOC_NEWLINE;
   
Line 1302  in_line_argn(MACRO_PROT_ARGS)
Line 1294  in_line_argn(MACRO_PROT_ARGS)
   
         switch (tok) {          switch (tok) {
         case MDOC_Ap:          case MDOC_Ap:
                 /* FALLTHROUGH */  
         case MDOC_Ns:          case MDOC_Ns:
                 /* FALLTHROUGH */  
         case MDOC_Ux:          case MDOC_Ux:
                 maxargs = 0;                  maxargs = 0;
                 break;                  break;
         case MDOC_Bx:          case MDOC_Bx:
                 /* FALLTHROUGH */  
         case MDOC_Es:          case MDOC_Es:
                 /* FALLTHROUGH */  
         case MDOC_Xr:          case MDOC_Xr:
                 maxargs = 2;                  maxargs = 2;
                 break;                  break;
Line 1322  in_line_argn(MACRO_PROT_ARGS)
Line 1310  in_line_argn(MACRO_PROT_ARGS)
   
         mdoc_argv(mdoc, line, tok, &arg, pos, buf);          mdoc_argv(mdoc, line, tok, &arg, pos, buf);
   
           state = -1;
         p = NULL;          p = NULL;
         flushed = j = 0;  
         for (;;) {          for (;;) {
                 la = *pos;                  la = *pos;
                 ac = mdoc_args(mdoc, line, pos, buf, tok, &p);                  ac = mdoc_args(mdoc, line, pos, buf, tok, &p);
   
                   if (ac == ARGS_WORD && state == -1 &&
                       ! (mdoc_macros[tok].flags & MDOC_IGNDELIM) &&
                       mdoc_isdelim(p) == DELIM_OPEN) {
                           dword(mdoc, line, la, p, DELIM_OPEN, 0);
                           continue;
                   }
   
                   if (state == -1 && tok != MDOC_In &&
                       tok != MDOC_St && tok != MDOC_Xr) {
                           mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
                           state = 0;
                   }
   
                 if (ac == ARGS_PUNCT || ac == ARGS_EOLN) {                  if (ac == ARGS_PUNCT || ac == ARGS_EOLN) {
                         if (j < 2 && tok == MDOC_Pf)                          if (abs(state) < 2 && tok == MDOC_Pf)
                                 mandoc_vmsg(MANDOCERR_PF_SKIP,                                  mandoc_vmsg(MANDOCERR_PF_SKIP,
                                     mdoc->parse, line, ppos, "Pf %s",                                      mdoc->parse, line, ppos, "Pf %s",
                                     p == NULL ? "at eol" : p);                                      p == NULL ? "at eol" : p);
                         break;                          break;
                 }                  }
   
                 if ( ! (mdoc_macros[tok].flags & MDOC_IGNDELIM) &&                  if (state == maxargs) {
                     ac != ARGS_QWORD && j == 0 &&  
                     mdoc_isdelim(p) == DELIM_OPEN) {  
                         dword(mdoc, line, la, p, DELIM_OPEN, 0);  
                         continue;  
                 } else if (j == 0)  
                        mdoc_elem_alloc(mdoc, line, ppos, tok, arg);  
   
                 if (j == maxargs && ! flushed) {  
                         rew_elem(mdoc, tok);                          rew_elem(mdoc, tok);
                         flushed = 1;                          state = -2;
                 }                  }
   
                 ntok = (ac == ARGS_QWORD || (tok == MDOC_Pf && j == 0)) ?                  ntok = (ac == ARGS_QWORD || (tok == MDOC_Pf && state == 0)) ?
                     MDOC_MAX : lookup(mdoc, tok, line, la, p);                      TOKEN_NONE : lookup(mdoc, tok, line, la, p);
   
                 if (ntok != MDOC_MAX) {                  if (ntok != TOKEN_NONE) {
                         if ( ! flushed)                          if (state >= 0) {
                                 rew_elem(mdoc, tok);                                  rew_elem(mdoc, tok);
                         flushed = 1;                                  state = -2;
                           }
                         mdoc_macro(mdoc, ntok, line, la, pos, buf);                          mdoc_macro(mdoc, ntok, line, la, pos, buf);
                         j++;  
                         break;                          break;
                 }                  }
   
                 if ( ! (mdoc_macros[tok].flags & MDOC_IGNDELIM) &&                  if (ac == ARGS_QWORD ||
                     ac != ARGS_QWORD && ! flushed &&                      mdoc_macros[tok].flags & MDOC_IGNDELIM ||
                     mdoc_isdelim(p) != DELIM_NONE) {                      mdoc_isdelim(p) == DELIM_NONE) {
                           if (state == -1) {
                                   mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
                                   state = 1;
                           } else if (state >= 0)
                                   state++;
                   } else if (state >= 0) {
                         rew_elem(mdoc, tok);                          rew_elem(mdoc, tok);
                         flushed = 1;                          state = -2;
                 }                  }
   
                 dword(mdoc, line, la, p, DELIM_MAX,                  dword(mdoc, line, la, p, DELIM_MAX,
                     MDOC_JOIN & mdoc_macros[tok].flags);                      MDOC_JOIN & mdoc_macros[tok].flags);
                 j++;  
         }          }
   
         if (j == 0) {          if (state == -1) {
                 if (tok == MDOC_In || tok == MDOC_St || tok == MDOC_Xr) {                  mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,
                         mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,                      line, ppos, mdoc_macronames[tok]);
                             line, ppos, mdoc_macronames[tok]);                  return;
                         return;  
                 }  
                 mdoc_elem_alloc(mdoc, line, ppos, tok, arg);  
                 if (ac == ARGS_PUNCT && tok == MDOC_Pf)  
                         append_delims(mdoc, line, pos, buf);  
         }          }
         if ( ! flushed)  
           if (state == 0 && tok == MDOC_Pf)
                   append_delims(mdoc, line, pos, buf);
           if (state >= 0)
                 rew_elem(mdoc, tok);                  rew_elem(mdoc, tok);
         if (nl)          if (nl)
                 append_delims(mdoc, line, pos, buf);                  append_delims(mdoc, line, pos, buf);
Line 1391  in_line_argn(MACRO_PROT_ARGS)
Line 1388  in_line_argn(MACRO_PROT_ARGS)
 static void  static void
 in_line_eoln(MACRO_PROT_ARGS)  in_line_eoln(MACRO_PROT_ARGS)
 {  {
         struct mdoc_node        *n;          struct roff_node        *n;
         struct mdoc_arg         *arg;          struct mdoc_arg         *arg;
   
         if ((tok == MDOC_Pp || tok == MDOC_Lp) &&          if ((tok == MDOC_Pp || tok == MDOC_Lp) &&
             ! (mdoc->flags & MDOC_SYNOPSIS)) {              ! (mdoc->flags & MDOC_SYNOPSIS)) {
                 n = mdoc->last;                  n = mdoc->last;
                 if (mdoc->next == MDOC_NEXT_SIBLING)                  if (mdoc->next == ROFF_NEXT_SIBLING)
                         n = n->parent;                          n = n->parent;
                 if (n->tok == MDOC_Nm)                  if (n->tok == MDOC_Nm)
                         rew_last(mdoc, mdoc->last->parent);                          rew_last(mdoc, n->parent);
         }          }
   
         if (buf[*pos] == '\0' && tok == MDOC_Fd) {          if (buf[*pos] == '\0' &&
               (tok == MDOC_Fd || mdoc_macronames[tok][0] == '%')) {
                 mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,                  mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,
                     line, ppos, "Fd");                      line, ppos, mdoc_macronames[tok]);
                 return;                  return;
         }          }
   
Line 1422  in_line_eoln(MACRO_PROT_ARGS)
Line 1420  in_line_eoln(MACRO_PROT_ARGS)
  * or until the next macro, call that macro, and return 1.   * or until the next macro, call that macro, and return 1.
  */   */
 static int  static int
 parse_rest(struct mdoc *mdoc, enum mdoct tok, int line, int *pos, char *buf)  parse_rest(struct roff_man *mdoc, int tok, int line, int *pos, char *buf)
 {  {
         int              la;          int              la;
   
         for (;;) {          for (;;) {
                 la = *pos;                  la = *pos;
                 if (mdoc_args(mdoc, line, pos, buf, tok, NULL) == ARGS_EOLN)                  if (mdoc_args(mdoc, line, pos, buf, tok, NULL) == ARGS_EOLN)
                         return(0);                          return 0;
                 if (macro_or_word(mdoc, tok, line, la, pos, buf, 1))                  if (macro_or_word(mdoc, tok, line, la, pos, buf, 1))
                         return(1);                          return 1;
         }          }
 }  }
   
Line 1457  ctx_synopsis(MACRO_PROT_ARGS)
Line 1455  ctx_synopsis(MACRO_PROT_ARGS)
 static void  static void
 phrase_ta(MACRO_PROT_ARGS)  phrase_ta(MACRO_PROT_ARGS)
 {  {
         struct mdoc_node *body, *n;          struct roff_node *body, *n;
   
         /* Make sure we are in a column list or ignore this macro. */          /* Make sure we are in a column list or ignore this macro. */
   
         body = NULL;          body = NULL;
         for (n = mdoc->last; n != NULL; n = n->parent) {          for (n = mdoc->last; n != NULL; n = n->parent) {
                 if (n->flags & (MDOC_VALID | MDOC_BREAK))                  if (n->flags & MDOC_ENDED)
                         continue;                          continue;
                 if (n->tok == MDOC_It && n->type == MDOC_BODY)                  if (n->tok == MDOC_It && n->type == ROFFT_BODY)
                         body = n;                          body = n;
                 if (n->tok == MDOC_Bl)                  if (n->tok == MDOC_Bl)
                         break;                          break;
Line 1480  phrase_ta(MACRO_PROT_ARGS)
Line 1478  phrase_ta(MACRO_PROT_ARGS)
         /* Advance to the next column. */          /* Advance to the next column. */
   
         rew_last(mdoc, body);          rew_last(mdoc, body);
         mdoc_body_alloc(mdoc, line, ppos, MDOC_It);          roff_body_alloc(mdoc, line, ppos, MDOC_It);
         parse_rest(mdoc, MDOC_MAX, line, pos, buf);          parse_rest(mdoc, TOKEN_NONE, line, pos, buf);
 }  }
Legend:
Removed from v.1.178  
changed lines
  Added in v.1.205
CVSweb