[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.186 and 1.192

version 1.186, 2015/04/05 14:43:36 version 1.192, 2015/04/19 14:25:41
Line 30 
Line 30 
 #include "roff.h"  #include "roff.h"
 #include "mdoc.h"  #include "mdoc.h"
 #include "libmandoc.h"  #include "libmandoc.h"
   #include "roff_int.h"
 #include "libmdoc.h"  #include "libmdoc.h"
   
 static  void            blk_full(MACRO_PROT_ARGS);  static  void            blk_full(MACRO_PROT_ARGS);
Line 42  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  int             lookup(struct mdoc *, int, int, int, const char *);  static  int             find_pending(struct roff_man *, int, int, int,
                                   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  int             parse_rest(struct mdoc *, int, int, int *, char *);  static  int             parse_rest(struct roff_man *, int, int, int *, char *);
 static  int             rew_alt(int);  static  int             rew_alt(int);
 static  void            rew_elem(struct mdoc *, int);  static  void            rew_elem(struct roff_man *, int);
 static  void            rew_last(struct mdoc *, const struct roff_node *);  static  void            rew_last(struct roff_man *, const struct roff_node *);
 static  void            rew_pending(struct mdoc *, const struct roff_node *);  static  void            rew_pending(struct roff_man *,
                                   const struct roff_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 206  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_macroend(struct roff_man *mdoc)
 {  {
         struct roff_node *n;          struct roff_node *n;
   
Line 228  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 int  static int
 lookup(struct mdoc *mdoc, int from, int line, int ppos, const char *p)  lookup(struct roff_man *mdoc, int from, int line, int ppos, const char *p)
 {  {
         int      res;          int      res;
   
         if (from == MDOC_MAX || mdoc_macros[from].flags & MDOC_PARSED) {          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)
Line 245  lookup(struct mdoc *mdoc, int from, int line, int ppos
Line 249  lookup(struct mdoc *mdoc, int from, int line, int ppos
                                     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 roff_node *to)  rew_last(struct roff_man *mdoc, const struct roff_node *to)
 {  {
         struct roff_node *n, *np;          struct roff_node *n, *np;
   
         if (to->flags & MDOC_VALID)          if (to->flags & MDOC_VALID)
                 return;                  return;
   
         mdoc->next = MDOC_NEXT_SIBLING;          mdoc->next = ROFF_NEXT_SIBLING;
         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 281  rew_last(struct mdoc *mdoc, const struct roff_node *to
Line 285  rew_last(struct mdoc *mdoc, const struct roff_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 roff_node *n)  rew_pending(struct roff_man *mdoc, const struct roff_node *n)
 {  {
   
         for (;;) {          for (;;) {
Line 289  rew_pending(struct mdoc *mdoc, const struct roff_node 
Line 293  rew_pending(struct mdoc *mdoc, const struct roff_node 
   
                 switch (n->type) {                  switch (n->type) {
                 case ROFFT_HEAD:                  case ROFFT_HEAD:
                         mdoc_body_alloc(mdoc, n->line, n->pos, n->tok);                          roff_body_alloc(mdoc, n->line, n->pos, n->tok);
                         return;                          return;
                 case ROFFT_BLOCK:                  case ROFFT_BLOCK:
                         break;                          break;
Line 362  rew_alt(int tok)
Line 366  rew_alt(int tok)
 }  }
   
 static void  static void
 rew_elem(struct mdoc *mdoc, int tok)  rew_elem(struct roff_man *mdoc, int tok)
 {  {
         struct roff_node *n;          struct roff_node *n;
   
Line 375  rew_elem(struct mdoc *mdoc, int tok)
Line 379  rew_elem(struct mdoc *mdoc, int tok)
 }  }
   
 /*  /*
    * If there is an open sub-block of the target requiring
    * explicit close-out, postpone closing out the target until
    * the rew_pending() call closing out the sub-block.
    */
   static int
   find_pending(struct roff_man *mdoc, int tok, int line, int ppos,
           struct roff_node *target)
   {
           struct roff_node        *n;
           int                      irc;
   
           irc = 0;
           for (n = mdoc->last; n != NULL && n != target; n = n->parent) {
                   if (n->flags & MDOC_ENDED) {
                           if ( ! (n->flags & MDOC_VALID))
                                   n->flags |= MDOC_BROKEN;
                           continue;
                   }
                   if (n->type == ROFFT_BLOCK &&
                       mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {
                           irc = 1;
                           n->flags = MDOC_BROKEN;
                           if (target->type == ROFFT_HEAD)
                                   target->flags = MDOC_ENDED;
                           else if ( ! (target->flags & MDOC_ENDED)) {
                                   mandoc_vmsg(MANDOCERR_BLK_NEST,
                                       mdoc->parse, line, ppos,
                                       "%s breaks %s", mdoc_macronames[tok],
                                       mdoc_macronames[n->tok]);
                                   mdoc_endbody_alloc(mdoc, line, ppos,
                                       tok, target, ENDBODY_NOSPACE);
                           }
                   }
           }
           return(irc);
   }
   
   /*
  * Allocate a word and check whether it's punctuation or not.   * Allocate a word and check whether it's punctuation or not.
  * 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 390  dword(struct mdoc *mdoc, int line, int col, const char
Line 432  dword(struct mdoc *mdoc, int line, int col, const char
             ! (mdoc->flags & (MDOC_SYNOPSIS | MDOC_KEEP | MDOC_SMOFF)) &&              ! (mdoc->flags & (MDOC_SYNOPSIS | MDOC_KEEP | MDOC_SMOFF)) &&
             d == DELIM_NONE && mdoc->last->type == ROFFT_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 413  dword(struct mdoc *mdoc, int line, int col, const char
Line 455  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 423  append_delims(struct mdoc *mdoc, int line, int *pos, c
Line 465  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 456  macro_or_word(MACRO_PROT_ARGS, int parsed)
Line 499  macro_or_word(MACRO_PROT_ARGS, int parsed)
         int              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 487  blk_exp_close(MACRO_PROT_ARGS)
Line 530  blk_exp_close(MACRO_PROT_ARGS)
         struct roff_node *itblk;        /* An It block starting later. */          struct roff_node *itblk;        /* An It block starting later. */
         struct roff_node *later;        /* A sub-block starting later. */          struct roff_node *later;        /* A sub-block starting later. */
         struct roff_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;
         int              atok, ntok;          int              atok, ntok;
         char            *p;          char            *p;
Line 576  blk_exp_close(MACRO_PROT_ARGS)
Line 620  blk_exp_close(MACRO_PROT_ARGS)
                          */                           */
   
                         if (maxargs)                          if (maxargs)
                                 mdoc->next = MDOC_NEXT_CHILD;                                  mdoc->next = ROFF_NEXT_CHILD;
                         break;                          break;
                 }                  }
   
Line 634  blk_exp_close(MACRO_PROT_ARGS)
Line 678  blk_exp_close(MACRO_PROT_ARGS)
                 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;
Line 650  blk_exp_close(MACRO_PROT_ARGS)
Line 694  blk_exp_close(MACRO_PROT_ARGS)
                 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 727  in_line(MACRO_PROT_ARGS)
Line 782  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 736  in_line(MACRO_PROT_ARGS)
Line 791  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 969  blk_full(MACRO_PROT_ARGS)
Line 1024  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)
Line 994  blk_full(MACRO_PROT_ARGS)
Line 1049  blk_full(MACRO_PROT_ARGS)
                          */                           */
                         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);
                         break;                          break;
                 }                  }
                 if (tok == MDOC_Bd || tok == MDOC_Bk) {                  if (tok == MDOC_Bd || tok == MDOC_Bk) {
Line 1029  blk_full(MACRO_PROT_ARGS)
Line 1084  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_PEND ||
Line 1041  blk_full(MACRO_PROT_ARGS)
Line 1096  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 phrases: set whether we're in a                           * Process phrases: set whether we're in a
Line 1053  blk_full(MACRO_PROT_ARGS)
Line 1108  blk_full(MACRO_PROT_ARGS)
                                 mdoc->flags |= MDOC_PPHRASE;                                  mdoc->flags |= MDOC_PPHRASE;
                         if (ac == ARGS_PEND && lac == ARGS_PPHRASE)                          if (ac == ARGS_PEND && lac == ARGS_PPHRASE)
                                 mdoc->flags |= MDOC_PPHRASE;                                  mdoc->flags |= MDOC_PPHRASE;
                         parse_rest(mdoc, MDOC_MAX, line, &la, buf);                          parse_rest(mdoc, TOKEN_NONE, line, &la, buf);
                         mdoc->flags &= ~MDOC_PPHRASE;                          mdoc->flags &= ~MDOC_PPHRASE;
                         continue;                          continue;
                 }                  }
Line 1065  blk_full(MACRO_PROT_ARGS)
Line 1120  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))
         /*  
          * 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->flags & MDOC_ENDED) {  
                         if ( ! (n->flags & MDOC_VALID))  
                                 n->flags |= MDOC_BROKEN;  
                         continue;  
                 }  
                 if (n->type == ROFFT_BLOCK &&  
                     mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {  
                         n->flags = MDOC_BROKEN;  
                         head->flags = MDOC_ENDED;  
                 }  
         }  
         if (head->flags & MDOC_ENDED)  
                 return;                  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 1126  blk_part_imp(MACRO_PROT_ARGS)
Line 1162  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 1147  blk_part_imp(MACRO_PROT_ARGS)
Line 1183  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,  
          * 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->flags & MDOC_ENDED) {  
                         if ( ! (n->flags & MDOC_VALID))  
                                 n->flags |= MDOC_BROKEN;  
                         continue;  
                 }  
                 if (n->type == ROFFT_BLOCK &&  
                     mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {  
                         n->flags |= MDOC_BROKEN;  
                         if ( ! (body->flags & MDOC_ENDED)) {  
                                 mandoc_vmsg(MANDOCERR_BLK_NEST,  
                                     mdoc->parse, line, ppos,  
                                     "%s breaks %s", mdoc_macronames[tok],  
                                     mdoc_macronames[n->tok]);  
                                 mdoc_endbody_alloc(mdoc, line, ppos,  
                                     tok, body, ENDBODY_NOSPACE);  
                         }  
                 }  
         }  
         assert(n == body);  
         if (body->flags & MDOC_ENDED)  
                 return;                  return;
   
         rew_last(mdoc, body);          rew_last(mdoc, body);
Line 1231  blk_part_exp(MACRO_PROT_ARGS)
Line 1240  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 1247  blk_part_exp(MACRO_PROT_ARGS)
Line 1256  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 1329  in_line_argn(MACRO_PROT_ARGS)
Line 1338  in_line_argn(MACRO_PROT_ARGS)
                 }                  }
   
                 ntok = (ac == ARGS_QWORD || (tok == MDOC_Pf && state == 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 (state >= 0) {                          if (state >= 0) {
                                 rew_elem(mdoc, tok);                                  rew_elem(mdoc, tok);
                                 state = -2;                                  state = -2;
Line 1380  in_line_eoln(MACRO_PROT_ARGS)
Line 1389  in_line_eoln(MACRO_PROT_ARGS)
         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, mdoc->last->parent);
Line 1406  in_line_eoln(MACRO_PROT_ARGS)
Line 1415  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, int 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;
   
Line 1464  phrase_ta(MACRO_PROT_ARGS)
Line 1473  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.186  
changed lines
  Added in v.1.192
CVSweb