[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.367 and 1.373

version 1.367, 2018/04/11 17:11:13 version 1.373, 2019/06/03 19:50:33
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-2019 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 29 
Line 29 
 #include <string.h>  #include <string.h>
   
 #include "mandoc_aux.h"  #include "mandoc_aux.h"
 #include "mandoc.h"  
 #include "roff.h"  #include "roff.h"
 #include "mdoc.h"  #include "mdoc.h"
 #include "out.h"  #include "out.h"
Line 47  struct termpair {
Line 46  struct termpair {
                   const struct roff_meta *meta, \                    const struct roff_meta *meta, \
                   struct roff_node *n                    struct roff_node *n
   
 struct  termact {  struct  mdoc_term_act {
         int     (*pre)(DECL_ARGS);          int     (*pre)(DECL_ARGS);
         void    (*post)(DECL_ARGS);          void    (*post)(DECL_ARGS);
 };  };
Line 84  static void   termp_xx_post(DECL_ARGS);
Line 83  static void   termp_xx_post(DECL_ARGS);
   
 static  int       termp__a_pre(DECL_ARGS);  static  int       termp__a_pre(DECL_ARGS);
 static  int       termp__t_pre(DECL_ARGS);  static  int       termp__t_pre(DECL_ARGS);
   static  int       termp_abort_pre(DECL_ARGS);
 static  int       termp_an_pre(DECL_ARGS);  static  int       termp_an_pre(DECL_ARGS);
 static  int       termp_ap_pre(DECL_ARGS);  static  int       termp_ap_pre(DECL_ARGS);
 static  int       termp_bd_pre(DECL_ARGS);  static  int       termp_bd_pre(DECL_ARGS);
Line 124  static int   termp_vt_pre(DECL_ARGS);
Line 124  static int   termp_vt_pre(DECL_ARGS);
 static  int       termp_xr_pre(DECL_ARGS);  static  int       termp_xr_pre(DECL_ARGS);
 static  int       termp_xx_pre(DECL_ARGS);  static  int       termp_xx_pre(DECL_ARGS);
   
 static  const struct termact __termacts[MDOC_MAX - MDOC_Dd] = {  static const struct mdoc_term_act mdoc_term_acts[MDOC_MAX - MDOC_Dd] = {
         { NULL, NULL }, /* Dd */          { NULL, NULL }, /* Dd */
         { NULL, NULL }, /* Dt */          { NULL, NULL }, /* Dt */
         { NULL, NULL }, /* Os */          { NULL, NULL }, /* Os */
Line 159  static const struct termact __termacts[MDOC_MAX - MDOC
Line 159  static const struct termact __termacts[MDOC_MAX - MDOC
         { termp_nd_pre, NULL }, /* Nd */          { termp_nd_pre, NULL }, /* Nd */
         { termp_nm_pre, termp_nm_post }, /* Nm */          { termp_nm_pre, termp_nm_post }, /* Nm */
         { termp_quote_pre, termp_quote_post }, /* Op */          { termp_quote_pre, termp_quote_post }, /* Op */
         { termp_ft_pre, NULL }, /* Ot */          { termp_abort_pre, NULL }, /* Ot */
         { termp_under_pre, NULL }, /* Pa */          { termp_under_pre, NULL }, /* Pa */
         { termp_ex_pre, NULL }, /* Rv */          { termp_ex_pre, NULL }, /* Rv */
         { NULL, NULL }, /* St */          { NULL, NULL }, /* St */
Line 232  static const struct termact __termacts[MDOC_MAX - MDOC
Line 232  static const struct termact __termacts[MDOC_MAX - MDOC
         { termp_under_pre, NULL }, /* Fr */          { termp_under_pre, NULL }, /* Fr */
         { NULL, NULL }, /* Ud */          { NULL, NULL }, /* Ud */
         { NULL, termp_lb_post }, /* Lb */          { NULL, termp_lb_post }, /* Lb */
         { termp_pp_pre, NULL }, /* Lp */          { termp_abort_pre, NULL }, /* Lp */
         { termp_lk_pre, NULL }, /* Lk */          { termp_lk_pre, NULL }, /* Lk */
         { termp_under_pre, NULL }, /* Mt */          { termp_under_pre, NULL }, /* Mt */
         { termp_quote_pre, termp_quote_post }, /* Brq */          { termp_quote_pre, termp_quote_post }, /* Brq */
Line 246  static const struct termact __termacts[MDOC_MAX - MDOC
Line 246  static const struct termact __termacts[MDOC_MAX - MDOC
         { NULL, termp____post }, /* %U */          { NULL, termp____post }, /* %U */
         { NULL, NULL }, /* Ta */          { NULL, NULL }, /* Ta */
 };  };
 static  const struct termact *const termacts = __termacts - MDOC_Dd;  
   
 static  int      fn_prio;  static  int      fn_prio;
   
   
 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;
         struct termp            *p;          struct termp            *p;
Line 270  terminal_mdoc(void *arg, const struct roff_man *mdoc)
Line 269  terminal_mdoc(void *arg, const struct roff_man *mdoc)
                         if (n->tok == MDOC_Sh && n->sec == SEC_SYNOPSIS) {                          if (n->tok == MDOC_Sh && n->sec == SEC_SYNOPSIS) {
                                 if (n->child->next->child != NULL)                                  if (n->child->next->child != NULL)
                                         print_mdoc_nodelist(p, NULL,                                          print_mdoc_nodelist(p, NULL,
                                             &mdoc->meta,                                              mdoc, n->child->next->child);
                                             n->child->next->child);  
                                 term_newln(p);                                  term_newln(p);
                                 break;                                  break;
                         }                          }
Line 281  terminal_mdoc(void *arg, const struct roff_man *mdoc)
Line 279  terminal_mdoc(void *arg, const struct roff_man *mdoc)
                 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 290  terminal_mdoc(void *arg, const struct roff_man *mdoc)
Line 287  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 310  print_mdoc_nodelist(DECL_ARGS)
Line 307  print_mdoc_nodelist(DECL_ARGS)
 static void  static void
 print_mdoc_node(DECL_ARGS)  print_mdoc_node(DECL_ARGS)
 {  {
         int              chld;          const struct mdoc_term_act *act;
         struct termpair  npair;          struct termpair  npair;
         size_t           offset, rmargin;          size_t           offset, rmargin;
           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 352  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 370  print_mdoc_node(DECL_ARGS)
Line 395  print_mdoc_node(DECL_ARGS)
                         return;                          return;
                 }                  }
                 assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX);                  assert(n->tok >= MDOC_Dd && n->tok < MDOC_MAX);
                 if (termacts[n->tok].pre != NULL &&                  act = mdoc_term_acts + (n->tok - MDOC_Dd);
                   if (act->pre != NULL &&
                     (n->end == ENDBODY_NOT || n->child != NULL))                      (n->end == ENDBODY_NOT || n->child != NULL))
                         chld = (*termacts[n->tok].pre)                          chld = (*act->pre)(p, &npair, meta, n);
                                 (p, &npair, meta, n);  
                 break;                  break;
         }          }
   
Line 391  print_mdoc_node(DECL_ARGS)
Line 416  print_mdoc_node(DECL_ARGS)
         case ROFFT_EQN:          case ROFFT_EQN:
                 break;                  break;
         default:          default:
                 if (termacts[n->tok].post == NULL || n->flags & NODE_ENDED)                  if (act->post == NULL || n->flags & NODE_ENDED)
                         break;                          break;
                 (void)(*termacts[n->tok].post)(p, &npair, meta, n);                  (void)(*act->post)(p, &npair, meta, n);
   
                 /*                  /*
                  * Explicit end tokens not only call the post                   * Explicit end tokens not only call the post
Line 1420  termp_fa_pre(DECL_ARGS)
Line 1445  termp_fa_pre(DECL_ARGS)
 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 1470  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_Lp:  
                 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 1514  termp_bd_post(DECL_ARGS)
Line 1490  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 2097  termp_tag_pre(DECL_ARGS)
Line 2075  termp_tag_pre(DECL_ARGS)
               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, 1, p->line);
         return 1;          return 1;
   }
   
   static int
   termp_abort_pre(DECL_ARGS)
   {
           abort();
 }  }
Legend:
Removed from v.1.367  
changed lines
  Added in v.1.373
CVSweb