[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.376 and 1.377

version 1.376, 2020/01/20 10:37:15 version 1.377, 2020/02/27 01:43:52
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 582  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 617  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 1043  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 1060  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 1104  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 1181  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 1195  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 1208  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 1217  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 1271  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 1278  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 1432  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;
 }  }
   
Line 1524  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 1557  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 1892  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

Legend:
Removed from v.1.376  
changed lines
  Added in v.1.377

CVSweb