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

Diff for /mandoc/mdoc_term.c between version 1.370 and 1.377

version 1.370, 2018/12/13 11:55:47 version 1.377, 2020/02/27 01:43:52
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
  * Copyright (c) 2010, 2012-2018 Ingo Schwarze <schwarze@openbsd.org>   * Copyright (c) 2010, 2012-2020 Ingo Schwarze <schwarze@openbsd.org>
  * Copyright (c) 2013 Franco Fichtner <franco@lastsummer.de>   * Copyright (c) 2013 Franco Fichtner <franco@lastsummer.de>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
Line 54  struct mdoc_term_act {
Line 54  struct mdoc_term_act {
 static  int       a2width(const struct termp *, const char *);  static  int       a2width(const struct termp *, const char *);
   
 static  void      print_bvspace(struct termp *,  static  void      print_bvspace(struct termp *,
                         const struct roff_node *,                          struct roff_node *, struct roff_node *);
                         const struct roff_node *);  
 static  void      print_mdoc_node(DECL_ARGS);  static  void      print_mdoc_node(DECL_ARGS);
 static  void      print_mdoc_nodelist(DECL_ARGS);  static  void      print_mdoc_nodelist(DECL_ARGS);
 static  void      print_mdoc_head(struct termp *, const struct roff_meta *);  static  void      print_mdoc_head(struct termp *, const struct roff_meta *);
 static  void      print_mdoc_foot(struct termp *, const struct roff_meta *);  static  void      print_mdoc_foot(struct termp *, const struct roff_meta *);
 static  void      synopsis_pre(struct termp *,  static  void      synopsis_pre(struct termp *, struct roff_node *);
                         const struct roff_node *);  
   
 static  void      termp____post(DECL_ARGS);  static  void      termp____post(DECL_ARGS);
 static  void      termp__t_post(DECL_ARGS);  static  void      termp__t_post(DECL_ARGS);
Line 119  static int   termp_pp_pre(DECL_ARGS);
Line 117  static int   termp_pp_pre(DECL_ARGS);
 static  int       termp_ss_pre(DECL_ARGS);  static  int       termp_ss_pre(DECL_ARGS);
 static  int       termp_sy_pre(DECL_ARGS);  static  int       termp_sy_pre(DECL_ARGS);
 static  int       termp_tag_pre(DECL_ARGS);  static  int       termp_tag_pre(DECL_ARGS);
   static  int       termp_tg_pre(DECL_ARGS);
 static  int       termp_under_pre(DECL_ARGS);  static  int       termp_under_pre(DECL_ARGS);
 static  int       termp_vt_pre(DECL_ARGS);  static  int       termp_vt_pre(DECL_ARGS);
 static  int       termp_xr_pre(DECL_ARGS);  static  int       termp_xr_pre(DECL_ARGS);
Line 245  static const struct mdoc_term_act mdoc_term_acts[MDOC_
Line 244  static const struct mdoc_term_act mdoc_term_acts[MDOC_
         { NULL, termp____post }, /* %Q */          { NULL, termp____post }, /* %Q */
         { NULL, termp____post }, /* %U */          { NULL, termp____post }, /* %U */
         { NULL, NULL }, /* Ta */          { NULL, NULL }, /* Ta */
           { termp_tg_pre, NULL }, /* Tg */
 };  };
   
 static  int      fn_prio;  static  int      fn_prio = TAG_STRONG;
   
   
 void  void
 terminal_mdoc(void *arg, const struct roff_man *mdoc)  terminal_mdoc(void *arg, const struct roff_meta *mdoc)
 {  {
         struct roff_node        *n;          struct roff_node        *n, *nn;
         struct termp            *p;          struct termp            *p;
         size_t                   save_defindent;          size_t                   save_defindent;
   
Line 265  terminal_mdoc(void *arg, const struct roff_man *mdoc)
Line 265  terminal_mdoc(void *arg, const struct roff_man *mdoc)
   
         n = mdoc->first->child;          n = mdoc->first->child;
         if (p->synopsisonly) {          if (p->synopsisonly) {
                 while (n != NULL) {                  for (nn = NULL; n != NULL; n = n->next) {
                         if (n->tok == MDOC_Sh && n->sec == SEC_SYNOPSIS) {                          if (n->tok != MDOC_Sh)
                                 if (n->child->next->child != NULL)                                  continue;
                                         print_mdoc_nodelist(p, NULL,                          if (n->sec == SEC_SYNOPSIS)
                                             &mdoc->meta,  
                                             n->child->next->child);  
                                 term_newln(p);  
                                 break;                                  break;
                         }                          if (nn == NULL && n->sec == SEC_NAME)
                         n = n->next;                                  nn = n;
                 }                  }
                   if (n == NULL)
                           n = nn;
                   p->flags |= TERMP_NOSPACE;
                   if (n != NULL && (n = n->child->next->child) != NULL)
                           print_mdoc_nodelist(p, NULL, mdoc, n);
                   term_newln(p);
         } else {          } else {
                 save_defindent = p->defindent;                  save_defindent = p->defindent;
                 if (p->defindent == 0)                  if (p->defindent == 0)
                         p->defindent = 5;                          p->defindent = 5;
                 term_begin(p, print_mdoc_head, print_mdoc_foot,                  term_begin(p, print_mdoc_head, print_mdoc_foot, mdoc);
                     &mdoc->meta);  
                 while (n != NULL &&                  while (n != NULL &&
                     (n->type == ROFFT_COMMENT ||                      (n->type == ROFFT_COMMENT ||
                      n->flags & NODE_NOPRT))                       n->flags & NODE_NOPRT))
Line 289  terminal_mdoc(void *arg, const struct roff_man *mdoc)
Line 291  terminal_mdoc(void *arg, const struct roff_man *mdoc)
                 if (n != NULL) {                  if (n != NULL) {
                         if (n->tok != MDOC_Sh)                          if (n->tok != MDOC_Sh)
                                 term_vspace(p);                                  term_vspace(p);
                         print_mdoc_nodelist(p, NULL, &mdoc->meta, n);                          print_mdoc_nodelist(p, NULL, mdoc, n);
                 }                  }
                 term_end(p);                  term_end(p);
                 p->defindent = save_defindent;                  p->defindent = save_defindent;
Line 314  print_mdoc_node(DECL_ARGS)
Line 316  print_mdoc_node(DECL_ARGS)
         size_t           offset, rmargin;          size_t           offset, rmargin;
         int              chld;          int              chld;
   
           /*
            * In no-fill mode, break the output line at the beginning
            * of new input lines except after \c, and nowhere else.
            */
   
           if (n->flags & NODE_NOFILL) {
                   if (n->flags & NODE_LINE &&
                       (p->flags & TERMP_NONEWLINE) == 0)
                           term_newln(p);
                   p->flags |= TERMP_BRNEVER;
           } else
                   p->flags &= ~TERMP_BRNEVER;
   
         if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT)          if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT)
                 return;                  return;
   
Line 341  print_mdoc_node(DECL_ARGS)
Line 356  print_mdoc_node(DECL_ARGS)
          * produce output.  Note that some pre-handlers do so.           * produce output.  Note that some pre-handlers do so.
          */           */
   
           act = NULL;
         switch (n->type) {          switch (n->type) {
         case ROFFT_TEXT:          case ROFFT_TEXT:
                 if (*n->string == ' ' && n->flags & NODE_LINE &&                  if (n->flags & NODE_LINE) {
                     (p->flags & TERMP_NONEWLINE) == 0)                          switch (*n->string) {
                         term_newln(p);                          case '\0':
                                   if (p->flags & TERMP_NONEWLINE)
                                           term_newln(p);
                                   else
                                           term_vspace(p);
                                   return;
                           case ' ':
                                   if ((p->flags & TERMP_NONEWLINE) == 0)
                                           term_newln(p);
                                   break;
                           default:
                                   break;
                           }
                   }
                 if (NODE_DELIMC & n->flags)                  if (NODE_DELIMC & n->flags)
                         p->flags |= TERMP_NOSPACE;                          p->flags |= TERMP_NOSPACE;
                 term_word(p, n->string);                  term_word(p, n->string);
Line 551  a2width(const struct termp *p, const char *v)
Line 580  a2width(const struct termp *p, const char *v)
  * too.   * too.
  */   */
 static void  static void
 print_bvspace(struct termp *p,  print_bvspace(struct termp *p, struct roff_node *bl, struct roff_node *n)
         const struct roff_node *bl,  
         const struct roff_node *n)  
 {  {
         const struct roff_node  *nn;          struct roff_node *nn;
   
         assert(n);  
   
         term_newln(p);          term_newln(p);
   
         if (MDOC_Bd == bl->tok && bl->norm->Bd.comp)          if ((bl->tok == MDOC_Bd && bl->norm->Bd.comp) ||
               (bl->tok == MDOC_Bl && bl->norm->Bl.comp))
                 return;                  return;
         if (MDOC_Bl == bl->tok && bl->norm->Bl.comp)  
                 return;  
   
         /* Do not vspace directly after Ss/Sh. */          /* Do not vspace directly after Ss/Sh. */
   
         nn = n;          nn = n;
         while (nn->prev != NULL &&          while (roff_node_prev(nn) == NULL) {
             (nn->prev->type == ROFFT_COMMENT ||  
              nn->prev->flags & NODE_NOPRT))  
                 nn = nn->prev;  
         while (nn->prev == NULL) {  
                 do {                  do {
                         nn = nn->parent;                          nn = nn->parent;
                         if (nn->type == ROFFT_ROOT)                          if (nn->type == ROFFT_ROOT)
Line 586  print_bvspace(struct termp *p,
Line 606  print_bvspace(struct termp *p,
                         break;                          break;
         }          }
   
         /* A `-column' does not assert vspace within the list. */          /*
            * No vertical space after:
            * items in .Bl -column
            * items without a body in .Bl -diag
            */
   
         if (MDOC_Bl == bl->tok && LIST_column == bl->norm->Bl.type)          if (bl->tok != MDOC_Bl ||
                 if (n->prev && MDOC_It == n->prev->tok)              n->prev == NULL || n->prev->tok != MDOC_It ||
                         return;              (bl->norm->Bl.type != LIST_column &&
                (bl->norm->Bl.type != LIST_diag ||
         /* A `-diag' without body does not vspace. */                n->prev->body->child != NULL)))
                   term_vspace(p);
         if (MDOC_Bl == bl->tok && LIST_diag == bl->norm->Bl.type)  
                 if (n->prev && MDOC_It == n->prev->tok) {  
                         assert(n->prev->body);  
                         if (NULL == n->prev->body->child)  
                                 return;  
                 }  
   
         term_vspace(p);  
 }  }
   
   
Line 1012  termp_nm_post(DECL_ARGS)
Line 1028  termp_nm_post(DECL_ARGS)
 static int  static int
 termp_fl_pre(DECL_ARGS)  termp_fl_pre(DECL_ARGS)
 {  {
           struct roff_node *nn;
   
         termp_tag_pre(p, pair, meta, n);          termp_tag_pre(p, pair, meta, n);
         term_fontpush(p, TERMFONT_BOLD);          term_fontpush(p, TERMFONT_BOLD);
         term_word(p, "\\-");          term_word(p, "\\-");
   
         if (!(n->child == NULL &&          if (n->child != NULL ||
             (n->next == NULL ||              ((nn = roff_node_next(n)) != NULL &&
              n->next->type == ROFFT_TEXT ||               nn->type != ROFFT_TEXT &&
              n->next->flags & NODE_LINE)))               (nn->flags & NODE_LINE) == 0))
                 p->flags |= TERMP_NOSPACE;                  p->flags |= TERMP_NOSPACE;
   
         return 1;          return 1;
Line 1029  termp_fl_pre(DECL_ARGS)
Line 1046  termp_fl_pre(DECL_ARGS)
 static int  static int
 termp__a_pre(DECL_ARGS)  termp__a_pre(DECL_ARGS)
 {  {
           struct roff_node *nn;
   
         if (n->prev && MDOC__A == n->prev->tok)          if ((nn = roff_node_prev(n)) != NULL && nn->tok == MDOC__A &&
                 if (NULL == n->next || MDOC__A != n->next->tok)              ((nn = roff_node_next(n)) == NULL || nn->tok != MDOC__A))
                         term_word(p, "and");                  term_word(p, "and");
   
         return 1;          return 1;
 }  }
Line 1073  termp_ns_pre(DECL_ARGS)
Line 1091  termp_ns_pre(DECL_ARGS)
 static int  static int
 termp_rs_pre(DECL_ARGS)  termp_rs_pre(DECL_ARGS)
 {  {
   
         if (SEC_SEE_ALSO != n->sec)          if (SEC_SEE_ALSO != n->sec)
                 return 1;                  return 1;
         if (n->type == ROFFT_BLOCK && n->prev != NULL)          if (n->type == ROFFT_BLOCK && roff_node_prev(n) != NULL)
                 term_vspace(p);                  term_vspace(p);
         return 1;          return 1;
 }  }
Line 1150  termp_xr_pre(DECL_ARGS)
Line 1167  termp_xr_pre(DECL_ARGS)
  * macro combos).   * macro combos).
  */   */
 static void  static void
 synopsis_pre(struct termp *p, const struct roff_node *n)  synopsis_pre(struct termp *p, struct roff_node *n)
 {  {
         /*          struct roff_node        *np;
          * Obviously, if we're not in a SYNOPSIS or no prior macros  
          * exist, do nothing.          if ((n->flags & NODE_SYNPRETTY) == 0 ||
          */              (np = roff_node_prev(n)) == NULL)
         if (NULL == n->prev || ! (NODE_SYNPRETTY & n->flags))  
                 return;                  return;
   
         /*          /*
Line 1164  synopsis_pre(struct termp *p, const struct roff_node *
Line 1180  synopsis_pre(struct termp *p, const struct roff_node *
          * newline and return.  UNLESS we're `Fo', `Fn', `Fn', in which           * newline and return.  UNLESS we're `Fo', `Fn', `Fn', in which
          * case we soldier on.           * case we soldier on.
          */           */
         if (n->prev->tok == n->tok &&          if (np->tok == n->tok &&
             MDOC_Ft != n->tok &&              MDOC_Ft != n->tok &&
             MDOC_Fo != n->tok &&              MDOC_Fo != n->tok &&
             MDOC_Fn != n->tok) {              MDOC_Fn != n->tok) {
Line 1177  synopsis_pre(struct termp *p, const struct roff_node *
Line 1193  synopsis_pre(struct termp *p, const struct roff_node *
          * another (or Fn/Fo, which we've let slip through) then assert           * another (or Fn/Fo, which we've let slip through) then assert
          * vertical space, else only newline and move on.           * vertical space, else only newline and move on.
          */           */
         switch (n->prev->tok) {          switch (np->tok) {
         case MDOC_Fd:          case MDOC_Fd:
         case MDOC_Fn:          case MDOC_Fn:
         case MDOC_Fo:          case MDOC_Fo:
Line 1186  synopsis_pre(struct termp *p, const struct roff_node *
Line 1202  synopsis_pre(struct termp *p, const struct roff_node *
                 term_vspace(p);                  term_vspace(p);
                 break;                  break;
         case MDOC_Ft:          case MDOC_Ft:
                 if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {                  if (n->tok != MDOC_Fn && n->tok != MDOC_Fo) {
                         term_vspace(p);                          term_vspace(p);
                         break;                          break;
                 }                  }
Line 1240  termp_fd_post(DECL_ARGS)
Line 1256  termp_fd_post(DECL_ARGS)
 static int  static int
 termp_sh_pre(DECL_ARGS)  termp_sh_pre(DECL_ARGS)
 {  {
           struct roff_node        *np;
   
         switch (n->type) {          switch (n->type) {
         case ROFFT_BLOCK:          case ROFFT_BLOCK:
Line 1247  termp_sh_pre(DECL_ARGS)
Line 1264  termp_sh_pre(DECL_ARGS)
                  * Vertical space before sections, except                   * Vertical space before sections, except
                  * when the previous section was empty.                   * when the previous section was empty.
                  */                   */
                 if (n->prev == NULL ||                  if ((np = roff_node_prev(n)) == NULL ||
                     n->prev->tok != MDOC_Sh ||                      np->tok != MDOC_Sh ||
                     (n->prev->body != NULL &&                      (np->body != NULL && np->body->child != NULL))
                      n->prev->body->child != NULL))  
                         term_vspace(p);                          term_vspace(p);
                 break;                  break;
         case ROFFT_HEAD:          case ROFFT_HEAD:
Line 1263  termp_sh_pre(DECL_ARGS)
Line 1279  termp_sh_pre(DECL_ARGS)
                 term_tab_set(p, ".5i");                  term_tab_set(p, ".5i");
                 switch (n->sec) {                  switch (n->sec) {
                 case SEC_DESCRIPTION:                  case SEC_DESCRIPTION:
                         fn_prio = 0;                          fn_prio = TAG_STRONG;
                         break;                          break;
                 case SEC_AUTHORS:                  case SEC_AUTHORS:
                         p->flags &= ~(TERMP_SPLIT|TERMP_NOSPLIT);                          p->flags &= ~(TERMP_SPLIT|TERMP_NOSPLIT);
Line 1352  termp_fn_pre(DECL_ARGS)
Line 1368  termp_fn_pre(DECL_ARGS)
         term_fontpop(p);          term_fontpop(p);
   
         if (n->sec == SEC_DESCRIPTION || n->sec == SEC_CUSTOM)          if (n->sec == SEC_DESCRIPTION || n->sec == SEC_CUSTOM)
                 tag_put(n->string, ++fn_prio, p->line);                  tag_put(n->string, fn_prio++, p->line);
   
         if (pretty) {          if (pretty) {
                 term_flushln(p);                  term_flushln(p);
Line 1401  termp_fa_pre(DECL_ARGS)
Line 1417  termp_fa_pre(DECL_ARGS)
                 term_fontpush(p, TERMFONT_UNDER);                  term_fontpush(p, TERMFONT_UNDER);
                 return 1;                  return 1;
         }          }
           for (nn = n->child; nn != NULL; nn = nn->next) {
         for (nn = n->child; nn; nn = nn->next) {  
                 term_fontpush(p, TERMFONT_UNDER);                  term_fontpush(p, TERMFONT_UNDER);
                 p->flags |= TERMP_NBRWORD;                  p->flags |= TERMP_NBRWORD;
                 term_word(p, nn->string);                  term_word(p, nn->string);
                 term_fontpop(p);                  term_fontpop(p);
                   if (nn->next != NULL) {
                 if (nn->next || (n->next && n->next->tok == MDOC_Fa)) {  
                         p->flags |= TERMP_NOSPACE;                          p->flags |= TERMP_NOSPACE;
                         term_word(p, ",");                          term_word(p, ",");
                 }                  }
         }          }
           if (n->child != NULL &&
               (nn = roff_node_next(n)) != NULL &&
               nn->tok == MDOC_Fa) {
                   p->flags |= TERMP_NOSPACE;
                   term_word(p, ",");
           }
         return 0;          return 0;
 }  }
   
 static int  static int
 termp_bd_pre(DECL_ARGS)  termp_bd_pre(DECL_ARGS)
 {  {
         size_t                   lm, len;  
         struct roff_node        *nn;  
         int                      offset;          int                      offset;
   
         if (n->type == ROFFT_BLOCK) {          if (n->type == ROFFT_BLOCK) {
Line 1447  termp_bd_pre(DECL_ARGS)
Line 1464  termp_bd_pre(DECL_ARGS)
                         p->tcol->offset += offset;                          p->tcol->offset += offset;
         }          }
   
         /*          switch (n->norm->Bd.type) {
          * If -ragged or -filled are specified, the block does nothing          case DISP_literal:
          * but change the indentation.  If -unfilled or -literal are  
          * specified, text is printed exactly as entered in the display:  
          * for macro lines, a newline is appended to the line.  Blank  
          * lines are allowed.  
          */  
   
         if (n->norm->Bd.type != DISP_literal &&  
             n->norm->Bd.type != DISP_unfilled &&  
             n->norm->Bd.type != DISP_centered)  
                 return 1;  
   
         if (n->norm->Bd.type == DISP_literal) {  
                 term_tab_set(p, NULL);                  term_tab_set(p, NULL);
                 term_tab_set(p, "T");                  term_tab_set(p, "T");
                 term_tab_set(p, "8n");                  term_tab_set(p, "8n");
                   break;
           case DISP_centered:
                   p->flags |= TERMP_CENTER;
                   break;
           default:
                   break;
         }          }
           return 1;
         lm = p->tcol->offset;  
         p->flags |= TERMP_BRNEVER;  
         for (nn = n->child; nn != NULL; nn = nn->next) {  
                 if (n->norm->Bd.type == DISP_centered) {  
                         if (nn->type == ROFFT_TEXT) {  
                                 len = term_strlen(p, nn->string);  
                                 p->tcol->offset = len >= p->tcol->rmargin ?  
                                     0 : lm + len >= p->tcol->rmargin ?  
                                     p->tcol->rmargin - len :  
                                     (lm + p->tcol->rmargin - len) / 2;  
                         } else  
                                 p->tcol->offset = lm;  
                 }  
                 print_mdoc_node(p, pair, meta, nn);  
                 /*  
                  * If the printed node flushes its own line, then we  
                  * needn't do it here as well.  This is hacky, but the  
                  * notion of selective eoln whitespace is pretty dumb  
                  * anyway, so don't sweat it.  
                  */  
                 if (nn->tok < ROFF_MAX)  
                         continue;  
                 switch (nn->tok) {  
                 case MDOC_Sm:  
                 case MDOC_Bl:  
                 case MDOC_D1:  
                 case MDOC_Dl:  
                 case MDOC_Pp:  
                         continue;  
                 default:  
                         break;  
                 }  
                 if (p->flags & TERMP_NONEWLINE ||  
                     (nn->next && ! (nn->next->flags & NODE_LINE)))  
                         continue;  
                 term_flushln(p);  
                 p->flags |= TERMP_NOSPACE;  
         }  
         p->flags &= ~TERMP_BRNEVER;  
         return 0;  
 }  }
   
 static void  static void
Line 1513  termp_bd_post(DECL_ARGS)
Line 1484  termp_bd_post(DECL_ARGS)
 {  {
         if (n->type != ROFFT_BODY)          if (n->type != ROFFT_BODY)
                 return;                  return;
         if (DISP_literal == n->norm->Bd.type ||          if (n->norm->Bd.type == DISP_unfilled ||
             DISP_unfilled == n->norm->Bd.type)              n->norm->Bd.type == DISP_literal)
                 p->flags |= TERMP_BRNEVER;                  p->flags |= TERMP_BRNEVER;
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         term_newln(p);          term_newln(p);
         p->flags &= ~TERMP_BRNEVER;          p->flags &= ~TERMP_BRNEVER;
           if (n->norm->Bd.type == DISP_centered)
                   p->flags &= ~TERMP_CENTER;
 }  }
   
 static int  static int
Line 1539  termp_xx_post(DECL_ARGS)
Line 1512  termp_xx_post(DECL_ARGS)
 static void  static void
 termp_pf_post(DECL_ARGS)  termp_pf_post(DECL_ARGS)
 {  {
           if (n->next != NULL && (n->next->flags & NODE_LINE) == 0)
         if ( ! (n->next == NULL || n->next->flags & NODE_LINE))  
                 p->flags |= TERMP_NOSPACE;                  p->flags |= TERMP_NOSPACE;
 }  }
   
 static int  static int
 termp_ss_pre(DECL_ARGS)  termp_ss_pre(DECL_ARGS)
 {  {
         struct roff_node *nn;  
   
         switch (n->type) {          switch (n->type) {
         case ROFFT_BLOCK:          case ROFFT_BLOCK:
                 term_newln(p);                  if (roff_node_prev(n) == NULL)
                 for (nn = n->prev; nn != NULL; nn = nn->prev)                          term_newln(p);
                         if (nn->type != ROFFT_COMMENT &&                  else
                             (nn->flags & NODE_NOPRT) == 0)  
                                 break;  
                 if (nn != NULL)  
                         term_vspace(p);                          term_vspace(p);
                 break;                  break;
         case ROFFT_HEAD:          case ROFFT_HEAD:
Line 1572  termp_ss_pre(DECL_ARGS)
Line 1539  termp_ss_pre(DECL_ARGS)
         default:          default:
                 break;                  break;
         }          }
   
         return 1;          return 1;
 }  }
   
 static void  static void
 termp_ss_post(DECL_ARGS)  termp_ss_post(DECL_ARGS)
 {  {
   
         if (n->type == ROFFT_HEAD || n->type == ROFFT_BODY)          if (n->type == ROFFT_HEAD || n->type == ROFFT_BODY)
                 term_newln(p);                  term_newln(p);
 }  }
Line 1629  termp_in_post(DECL_ARGS)
Line 1594  termp_in_post(DECL_ARGS)
 static int  static int
 termp_pp_pre(DECL_ARGS)  termp_pp_pre(DECL_ARGS)
 {  {
         fn_prio = 0;          fn_prio = TAG_STRONG;
         term_vspace(p);          term_vspace(p);
         return 0;          return 0;
 }  }
Line 1907  termp_ap_pre(DECL_ARGS)
Line 1872  termp_ap_pre(DECL_ARGS)
 static void  static void
 termp____post(DECL_ARGS)  termp____post(DECL_ARGS)
 {  {
           struct roff_node *nn;
   
         /*          /*
          * Handle lists of authors.  In general, print each followed by           * Handle lists of authors.  In general, print each followed by
          * a comma.  Don't print the comma if there are only two           * a comma.  Don't print the comma if there are only two
          * authors.           * authors.
          */           */
         if (MDOC__A == n->tok && n->next && MDOC__A == n->next->tok)          if (n->tok == MDOC__A &&
                 if (NULL == n->next->next || MDOC__A != n->next->next->tok)              (nn = roff_node_next(n)) != NULL && nn->tok == MDOC__A &&
                         if (NULL == n->prev || MDOC__A != n->prev->tok)              ((nn = roff_node_next(nn)) == NULL || nn->tok != MDOC__A) &&
                                 return;              ((nn = roff_node_prev(n)) == NULL || nn->tok != MDOC__A))
                   return;
   
         /* TODO: %U. */          /* TODO: %U. */
   
         if (NULL == n->parent || MDOC_Rs != n->parent->tok)          if (n->parent == NULL || n->parent->tok != MDOC_Rs)
                 return;                  return;
   
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         if (NULL == n->next) {          if (roff_node_next(n) == NULL) {
                 term_word(p, ".");                  term_word(p, ".");
                 p->flags |= TERMP_SENTENCE;                  p->flags |= TERMP_SENTENCE;
         } else          } else
Line 2054  termp_em_pre(DECL_ARGS)
Line 2021  termp_em_pre(DECL_ARGS)
 {  {
         if (n->child != NULL &&          if (n->child != NULL &&
             n->child->type == ROFFT_TEXT)              n->child->type == ROFFT_TEXT)
                 tag_put(n->child->string, 0, p->line);                  tag_put(n->child->string, TAG_FALLBACK, p->line);
         term_fontpush(p, TERMFONT_UNDER);          term_fontpush(p, TERMFONT_UNDER);
         return 1;          return 1;
 }  }
Line 2064  termp_sy_pre(DECL_ARGS)
Line 2031  termp_sy_pre(DECL_ARGS)
 {  {
         if (n->child != NULL &&          if (n->child != NULL &&
             n->child->type == ROFFT_TEXT)              n->child->type == ROFFT_TEXT)
                 tag_put(n->child->string, 0, p->line);                  tag_put(n->child->string, TAG_FALLBACK, p->line);
         term_fontpush(p, TERMFONT_BOLD);          term_fontpush(p, TERMFONT_BOLD);
         return 1;          return 1;
 }  }
Line 2077  termp_er_pre(DECL_ARGS)
Line 2044  termp_er_pre(DECL_ARGS)
             (n->parent->tok == MDOC_It ||              (n->parent->tok == MDOC_It ||
              (n->parent->tok == MDOC_Bq &&               (n->parent->tok == MDOC_Bq &&
               n->parent->parent->parent->tok == MDOC_It)))                n->parent->parent->parent->tok == MDOC_It)))
                 tag_put(n->child->string, 1, p->line);                  tag_put(n->child->string, TAG_STRONG, p->line);
         return 1;          return 1;
 }  }
   
Line 2094  termp_tag_pre(DECL_ARGS)
Line 2061  termp_tag_pre(DECL_ARGS)
              (n->parent->tok == MDOC_Xo &&               (n->parent->tok == MDOC_Xo &&
               n->parent->parent->prev == NULL &&                n->parent->parent->prev == NULL &&
               n->parent->parent->parent->tok == MDOC_It)))                n->parent->parent->parent->tok == MDOC_It)))
                 tag_put(n->child->string, 1, p->line);                  tag_put(n->child->string, TAG_STRONG, p->line);
         return 1;          return 1;
   }
   
   static int
   termp_tg_pre(DECL_ARGS)
   {
           tag_put(n->child->string, TAG_MANUAL, p->line);
           return 0;
 }  }
   
 static int  static int
Legend:
Removed from v.1.370  
changed lines
  Added in v.1.377
CVSweb