[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.176 and 1.188

version 1.176, 2015/02/05 01:46:56 version 1.188, 2015/04/05 23:04:41
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 "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 42  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 *,  
                                  enum mdelim, int);  
 static  void            append_delims(struct mdoc *, int, int *, char *);  static  void            append_delims(struct mdoc *, int, int *, char *);
 static  enum mdoct      lookup(struct mdoc *, enum mdoct,  static  void            dword(struct mdoc *, int, int, const char *,
                                 int, int, const char *);                                  enum mdelim, int);
   static  int             find_pending(struct mdoc *, int, int, int,
                                   struct roff_node *);
   static  int             lookup(struct mdoc *, 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 mdoc *, 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 mdoc *, int);
                                 int, int *, char *);  static  void            rew_last(struct mdoc *, const struct roff_node *);
 static  enum mdoct      rew_alt(enum mdoct);  static  void            rew_pending(struct mdoc *, const struct roff_node *);
 static  void            rew_elem(struct mdoc *, enum mdoct);  
 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 211  const struct mdoc_macro * const mdoc_macros = __mdoc_m
Line 210  const struct mdoc_macro * const mdoc_macros = __mdoc_m
 void  void
 mdoc_macroend(struct mdoc *mdoc)  mdoc_macroend(struct mdoc *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 218  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 233  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 == MDOC_MAX.
  */   */
 static enum mdoct  static int
 lookup(struct mdoc *mdoc, enum mdoct from, int line, int ppos, const char *p)  lookup(struct mdoc *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 (from == MDOC_MAX || mdoc_macros[from].flags & MDOC_PARSED) {
                 res = mdoc_hash_find(p);                  res = mdoc_hash_find(p);
Line 255  lookup(struct mdoc *mdoc, enum mdoct from, int line, i
Line 254  lookup(struct mdoc *mdoc, enum mdoct from, int line, i
  * 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 mdoc *mdoc, const struct roff_node *to)
 {  {
         struct mdoc_node *n, *np;          struct roff_node *n, *np;
   
         assert(to);          if (to->flags & MDOC_VALID)
                   return;
   
         mdoc->next = MDOC_NEXT_SIBLING;          mdoc->next = MDOC_NEXT_SIBLING;
         while (mdoc->last != to) {          while (mdoc->last != to) {
                 /*                  /*
Line 282  rew_last(struct mdoc *mdoc, const struct mdoc_node *to
Line 283  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 mdoc *mdoc, const struct roff_node *n)
 {  {
   
         rew_last(mdoc, n);          for (;;) {
   
         if (n->type != MDOC_BLOCK)  
                 return;  
   
         while ((n = n->pending) != NULL) {  
                 rew_last(mdoc, n);                  rew_last(mdoc, n);
                 if (n->type == MDOC_HEAD)  
                   switch (n->type) {
                   case ROFFT_HEAD:
                         mdoc_body_alloc(mdoc, n->line, n->pos, n->tok);                          mdoc_body_alloc(mdoc, n->line, n->pos, n->tok);
                           return;
                   case ROFFT_BLOCK:
                           break;
                   default:
                           return;
                   }
   
                   if ( ! (n->flags & MDOC_BROKEN))
                           return;
   
                   for (;;) {
                           if ((n = n->parent) == NULL)
                                   return;
   
                           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 321  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:
Line 344  rew_alt(enum mdoct tok)
Line 364  rew_alt(enum mdoct tok)
 }  }
   
 static void  static void
 rew_elem(struct mdoc *mdoc, enum mdoct tok)  rew_elem(struct mdoc *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 mdoc *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 442  dword(struct mdoc *mdoc, int line, int col, const char
Line 428  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);                  mdoc_word_append(mdoc, p);
                 return;                  return;
Line 507  static int
Line 493  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 = MDOC_MAX;
Line 536  macro_or_word(MACRO_PROT_ARGS, int parsed)
Line 522  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 556  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 595  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 630  blk_exp_close(MACRO_PROT_ARGS)
Line 621  blk_exp_close(MACRO_PROT_ARGS)
                         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;
         }          }
   
Line 674  blk_exp_close(MACRO_PROT_ARGS)
Line 668  blk_exp_close(MACRO_PROT_ARGS)
         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)
Line 692  blk_exp_close(MACRO_PROT_ARGS)
Line 684  blk_exp_close(MACRO_PROT_ARGS)
                         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 (n != mdoc->last && 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 712  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 895  blk_full(MACRO_PROT_ARGS)
Line 896  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;
   
         nl = MDOC_NEWLINE & mdoc->flags;          nl = MDOC_NEWLINE & mdoc->flags;
   
           if (buf[*pos] == '\0' && (tok == MDOC_Sh || tok == MDOC_Ss)) {
                   mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,
                       line, ppos, mdoc_macronames[tok]);
                   return;
           }
   
         if ( ! (mdoc_macros[tok].flags & MDOC_EXPLICIT)) {          if ( ! (mdoc_macros[tok].flags & MDOC_EXPLICIT)) {
   
                 /* Here, tok is one of Sh Ss Nm Nd It. */                  /* Here, tok is one of Sh Ss Nm Nd It. */
   
                 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 935  blk_full(MACRO_PROT_ARGS)
Line 947  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 1052  blk_full(MACRO_PROT_ARGS)
Line 1065  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 &&
Line 1109  blk_full(MACRO_PROT_ARGS)
Line 1122  blk_full(MACRO_PROT_ARGS)
                 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);
Line 1143  blk_part_imp(MACRO_PROT_ARGS)
Line 1143  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 1188  blk_part_imp(MACRO_PROT_ARGS)
Line 1188  blk_part_imp(MACRO_PROT_ARGS)
         if (body == NULL)          if (body == NULL)
                 body = mdoc_body_alloc(mdoc, line, ppos, tok);                  body = mdoc_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 1224  blk_part_exp(MACRO_PROT_ARGS)
Line 1209  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 1278  blk_part_exp(MACRO_PROT_ARGS)
Line 1263  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 1316  in_line_argn(MACRO_PROT_ARGS)
Line 1302  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);                      MDOC_MAX : lookup(mdoc, tok, line, la, p);
   
                 if (ntok != MDOC_MAX) {                  if (ntok != MDOC_MAX) {
                         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) {
                 mdoc_elem_alloc(mdoc, line, ppos, tok, arg);                  mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,
                 if (ac == ARGS_PUNCT && tok == MDOC_Pf)                      line, ppos, mdoc_macronames[tok]);
                         append_delims(mdoc, line, pos, buf);                  return;
         }          }
         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 1380  in_line_argn(MACRO_PROT_ARGS)
Line 1380  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) &&
Line 1392  in_line_eoln(MACRO_PROT_ARGS)
Line 1392  in_line_eoln(MACRO_PROT_ARGS)
                         rew_last(mdoc, mdoc->last->parent);                          rew_last(mdoc, mdoc->last->parent);
         }          }
   
           if (buf[*pos] == '\0' &&
               (tok == MDOC_Fd || mdoc_macronames[tok][0] == '%')) {
                   mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,
                       line, ppos, mdoc_macronames[tok]);
                   return;
           }
   
         mdoc_argv(mdoc, line, tok, &arg, pos, buf);          mdoc_argv(mdoc, line, tok, &arg, pos, buf);
         mdoc_elem_alloc(mdoc, line, ppos, tok, arg);          mdoc_elem_alloc(mdoc, line, ppos, tok, arg);
         if (parse_rest(mdoc, tok, line, pos, buf))          if (parse_rest(mdoc, tok, line, pos, buf))
Line 1405  in_line_eoln(MACRO_PROT_ARGS)
Line 1412  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 mdoc *mdoc, int tok, int line, int *pos, char *buf)
 {  {
         int              la;          int              la;
   
Line 1440  ctx_synopsis(MACRO_PROT_ARGS)
Line 1447  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;
Legend:
Removed from v.1.176  
changed lines
  Added in v.1.188
CVSweb