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

version 1.184, 2015/04/02 21:36:50 version 1.188, 2015/04/05 23:04:41
Line 42  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  int             parse_rest(struct mdoc *, enum mdoct,  static  int             parse_rest(struct mdoc *, int, int, int *, char *);
                                 int, int *, char *);  static  int             rew_alt(int);
 static  enum mdoct      rew_alt(enum mdoct);  static  void            rew_elem(struct mdoc *, int);
 static  void            rew_elem(struct mdoc *, enum mdoct);  static  void            rew_last(struct mdoc *, const struct roff_node *);
 static  void            rew_last(struct mdoc *, const struct mdoc_node *);  static  void            rew_pending(struct mdoc *, const struct roff_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 210  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 232  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 254  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 281  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)
 {  {
   
         for (;;) {          for (;;) {
Line 319  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 362  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 (n->type != ROFFT_ELEM)          if (n->type != ROFFT_ELEM)
Line 375  rew_elem(struct mdoc *mdoc, enum mdoct tok)
Line 377  rew_elem(struct mdoc *mdoc, enum mdoct 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 mdoc *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().
  */   */
Line 453  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 482  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 627  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 645  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 664  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 848  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;
   
Line 1074  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))
         /*  
          * 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. */
Line 1114  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 1159  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,  
          * 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 1207  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 1264  in_line_argn(MACRO_PROT_ARGS)
Line 1266  in_line_argn(MACRO_PROT_ARGS)
         struct mdoc_arg *arg;          struct mdoc_arg *arg;
         char            *p;          char            *p;
         enum margserr    ac;          enum margserr    ac;
         enum mdoct       ntok;          int              ntok;
         int              state; /* arg#; -1: not yet open; -2: closed */          int              state; /* arg#; -1: not yet open; -2: closed */
         int              la, maxargs, nl;          int              la, maxargs, nl;
   
Line 1378  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 1410  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 1445  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. */
   
Legend:
Removed from v.1.184  
changed lines
  Added in v.1.188
CVSweb