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

Diff for /mandoc/man_term.c between version 1.93 and 1.118

version 1.93, 2011/01/03 15:30:25 version 1.118, 2011/09/20 09:02:23
Line 1 
Line 1 
 /*      $Id$ */  /*      $Id$ */
 /*  /*
  * Copyright (c) 2008, 2009, 2010 Kristaps Dzonsons <kristaps@bsd.lv>   * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv>
    * Copyright (c) 2010, 2011 Ingo Schwarze <schwarze@openbsd.org>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above   * purpose with or without fee is hereby granted, provided that the above
Line 30 
Line 31 
 #include "out.h"  #include "out.h"
 #include "man.h"  #include "man.h"
 #include "term.h"  #include "term.h"
 #include "chars.h"  
 #include "main.h"  #include "main.h"
   
 #define INDENT            7  #define INDENT            7 /* fixed-width char full-indent */
 #define HALFINDENT        3  #define HALFINDENT        3 /* fixed-width char half-indent */
   #define MAXMARGINS        64 /* maximum number of indented scopes */
   
 /* FIXME: have PD set the default vspace width. */  /* FIXME: have PD set the default vspace width. */
   
 struct  mtermp {  struct  mtermp {
         int               fl;          int               fl;
 #define MANT_LITERAL     (1 << 0)  #define MANT_LITERAL     (1 << 0)
         /*          size_t            lmargin[MAXMARGINS]; /* margins (incl. visible page) */
          * Default amount to indent the left margin after leading text          int               lmargincur; /* index of current margin */
          * has been printed (e.g., `HP' left-indent, `TP' and `IP' body          int               lmarginsz; /* actual number of nested margins */
          * indent).  This needs to be saved because `HP' and so on, if          size_t            offset; /* default offset to visible page */
          * not having a specified value, must default.  
          *  
          * Note that this is the indentation AFTER the left offset, so  
          * the total offset is usually offset + lmargin.  
          */  
         size_t            lmargin;  
         /*  
          * The default offset, i.e., the amount between any text and the  
          * page boundary.  
          */  
         size_t            offset;  
 };  };
   
 #define DECL_ARGS         struct termp *p, \  #define DECL_ARGS         struct termp *p, \
Line 125  static const struct termact termacts[MAN_MAX] = {
Line 115  static const struct termact termacts[MAN_MAX] = {
         { pre_I, NULL, 0 }, /* I */          { pre_I, NULL, 0 }, /* I */
         { pre_alternate, NULL, 0 }, /* IR */          { pre_alternate, NULL, 0 }, /* IR */
         { pre_alternate, NULL, 0 }, /* RI */          { pre_alternate, NULL, 0 }, /* RI */
         { NULL, NULL, MAN_NOTEXT }, /* na */          { pre_ign, NULL, MAN_NOTEXT }, /* na */
         { pre_sp, NULL, MAN_NOTEXT }, /* sp */          { pre_sp, NULL, MAN_NOTEXT }, /* sp */
         { pre_literal, NULL, 0 }, /* nf */          { pre_literal, NULL, 0 }, /* nf */
         { pre_literal, NULL, 0 }, /* fi */          { pre_literal, NULL, 0 }, /* fi */
Line 156  terminal_man(void *arg, const struct man *man)
Line 146  terminal_man(void *arg, const struct man *man)
         p->tabwidth = term_len(p, 5);          p->tabwidth = term_len(p, 5);
   
         if (NULL == p->symtab)          if (NULL == p->symtab)
                 switch (p->enc) {                  p->symtab = mchars_alloc();
                 case (TERMENC_ASCII):  
                         p->symtab = chars_init(CHARS_ASCII);  
                         break;  
                 default:  
                         abort();  
                         /* NOTREACHED */  
                 }  
   
         n = man_node(man);          n = man_node(man);
         m = man_meta(man);          m = man_meta(man);
Line 171  terminal_man(void *arg, const struct man *man)
Line 154  terminal_man(void *arg, const struct man *man)
         term_begin(p, print_man_head, print_man_foot, m);          term_begin(p, print_man_head, print_man_foot, m);
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
   
         mt.fl = 0;          memset(&mt, 0, sizeof(struct mtermp));
         mt.lmargin = term_len(p, INDENT);  
           mt.lmargin[mt.lmargincur] = term_len(p, INDENT);
         mt.offset = term_len(p, INDENT);          mt.offset = term_len(p, INDENT);
   
         if (n->child)          if (n->child)
Line 188  a2height(const struct termp *p, const char *cp)
Line 172  a2height(const struct termp *p, const char *cp)
         struct roffsu    su;          struct roffsu    su;
   
         if ( ! a2roffsu(cp, &su, SCALE_VS))          if ( ! a2roffsu(cp, &su, SCALE_VS))
                 SCALE_VS_INIT(&su, term_strlen(p, cp));                  SCALE_VS_INIT(&su, atoi(cp));
   
         return(term_vspan(p, &su));          return(term_vspan(p, &su));
 }  }
Line 205  a2width(const struct termp *p, const char *cp)
Line 189  a2width(const struct termp *p, const char *cp)
         return((int)term_hspan(p, &su));          return((int)term_hspan(p, &su));
 }  }
   
   /*
    * Printing leading vertical space before a block.
    * This is used for the paragraph macros.
    * The rules are pretty simple, since there's very little nesting going
    * on here.  Basically, if we're the first within another block (SS/SH),
    * then don't emit vertical space.  If we are (RS), then do.  If not the
    * first, print it.
    */
 static void  static void
 print_bvspace(struct termp *p, const struct man_node *n)  print_bvspace(struct termp *p, const struct man_node *n)
 {  {
   
         term_newln(p);          term_newln(p);
   
         if (NULL == n->prev)          if (n->body && n->body->child)
                 return;                  if (MAN_TBL == n->body->child->type)
                           return;
   
         if (MAN_SS == n->prev->tok)          if (MAN_ROOT == n->parent->type || MAN_RS != n->parent->tok)
                 return;                  if (NULL == n->prev)
         if (MAN_SH == n->prev->tok)                          return;
                 return;  
   
         term_vspace(p);          term_vspace(p);
 }  }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static int  static int
 pre_ign(DECL_ARGS)  pre_ign(DECL_ARGS)
Line 254  pre_literal(DECL_ARGS)
Line 245  pre_literal(DECL_ARGS)
         else          else
                 mt->fl &= ~MANT_LITERAL;                  mt->fl &= ~MANT_LITERAL;
   
         return(1);          /*
            * Unlike .IP and .TP, .HP does not have a HEAD.
            * So in case a second call to term_flushln() is needed,
            * indentation has to be set up explicitly.
            */
           if (MAN_HP == n->parent->tok && p->rmargin < p->maxrmargin) {
                   p->offset = p->rmargin + 1;
                   p->rmargin = p->maxrmargin;
                   p->flags &= ~(TERMP_NOBREAK | TERMP_TWOSPACE);
                   p->flags |= TERMP_NOSPACE;
           }
   
           return(0);
 }  }
   
 /* ARGSUSED */  /* ARGSUSED */
Line 396  pre_in(DECL_ARGS)
Line 399  pre_in(DECL_ARGS)
         else          else
                 p->offset = v;                  p->offset = v;
   
           /* Don't let this creep beyond the right margin. */
   
           if (p->offset > p->rmargin)
                   p->offset = p->rmargin;
   
         return(0);          return(0);
 }  }
   
Line 406  pre_sp(DECL_ARGS)
Line 414  pre_sp(DECL_ARGS)
 {  {
         size_t           i, len;          size_t           i, len;
   
           if ((NULL == n->prev && n->parent)) {
                   if (MAN_SS == n->parent->tok)
                           return(0);
                   if (MAN_SH == n->parent->tok)
                           return(0);
           }
   
         switch (n->tok) {          switch (n->tok) {
         case (MAN_br):          case (MAN_br):
                 len = 0;                  len = 0;
Line 428  pre_sp(DECL_ARGS)
Line 443  pre_sp(DECL_ARGS)
 static int  static int
 pre_HP(DECL_ARGS)  pre_HP(DECL_ARGS)
 {  {
         size_t                   len;          size_t                   len, one;
         int                      ival;          int                      ival;
         const struct man_node   *nn;          const struct man_node   *nn;
   
Line 444  pre_HP(DECL_ARGS)
Line 459  pre_HP(DECL_ARGS)
                 return(0);                  return(0);
         }          }
   
         len = mt->lmargin;          len = mt->lmargin[mt->lmargincur];
         ival = -1;          ival = -1;
   
         /* Calculate offset. */          /* Calculate offset. */
Line 453  pre_HP(DECL_ARGS)
Line 468  pre_HP(DECL_ARGS)
                 if ((ival = a2width(p, nn->string)) >= 0)                  if ((ival = a2width(p, nn->string)) >= 0)
                         len = (size_t)ival;                          len = (size_t)ival;
   
         if (0 == len)          one = term_len(p, 1);
                 len = term_len(p, 1);          if (len > one)
                   len -= one;
           else
                   len = one;
   
         p->offset = mt->offset;          p->offset = mt->offset;
         p->rmargin = mt->offset + len;          p->rmargin = mt->offset + len;
   
         if (ival >= 0)          if (ival >= 0)
                 mt->lmargin = (size_t)ival;                  mt->lmargin[mt->lmargincur] = (size_t)ival;
   
         return(1);          return(1);
 }  }
Line 495  pre_PP(DECL_ARGS)
Line 513  pre_PP(DECL_ARGS)
   
         switch (n->type) {          switch (n->type) {
         case (MAN_BLOCK):          case (MAN_BLOCK):
                 mt->lmargin = term_len(p, INDENT);                  mt->lmargin[mt->lmargincur] = term_len(p, INDENT);
                 print_bvspace(p, n);                  print_bvspace(p, n);
                 break;                  break;
         default:          default:
Line 513  pre_IP(DECL_ARGS)
Line 531  pre_IP(DECL_ARGS)
 {  {
         const struct man_node   *nn;          const struct man_node   *nn;
         size_t                   len;          size_t                   len;
         int                      ival;          int                      savelit, ival;
   
         switch (n->type) {          switch (n->type) {
         case (MAN_BODY):          case (MAN_BODY):
                 p->flags |= TERMP_NOLPAD;  
                 p->flags |= TERMP_NOSPACE;                  p->flags |= TERMP_NOSPACE;
                 break;                  break;
         case (MAN_HEAD):          case (MAN_HEAD):
Line 530  pre_IP(DECL_ARGS)
Line 547  pre_IP(DECL_ARGS)
                 return(1);                  return(1);
         }          }
   
         len = mt->lmargin;          len = mt->lmargin[mt->lmargincur];
         ival = -1;          ival = -1;
   
         /* Calculate offset. */          /* Calculate the offset from the optional second argument. */
   
         if (NULL != (nn = n->parent->head->child))          if (NULL != (nn = n->parent->head->child))
                 if (NULL != (nn = nn->next)) {                  if (NULL != (nn = nn->next))
                         for ( ; nn->next; nn = nn->next)  
                                 /* Do nothing. */ ;  
                         if ((ival = a2width(p, nn->string)) >= 0)                          if ((ival = a2width(p, nn->string)) >= 0)
                                 len = (size_t)ival;                                  len = (size_t)ival;
                 }  
   
         switch (n->type) {          switch (n->type) {
         case (MAN_HEAD):          case (MAN_HEAD):
Line 555  pre_IP(DECL_ARGS)
Line 568  pre_IP(DECL_ARGS)
                         break;                          break;
   
                 /* Set the saved left-margin. */                  /* Set the saved left-margin. */
                 mt->lmargin = (size_t)ival;                  mt->lmargin[mt->lmargincur] = (size_t)ival;
   
                 /* Don't print the length value. */                  savelit = MANT_LITERAL & mt->fl;
                 for (nn = n->child; nn->next; nn = nn->next)                  mt->fl &= ~MANT_LITERAL;
                         print_man_node(p, mt, nn, m);  
                   if (n->child)
                           print_man_node(p, mt, n->child, m);
   
                   if (savelit)
                           mt->fl |= MANT_LITERAL;
   
                 return(0);                  return(0);
         case (MAN_BODY):          case (MAN_BODY):
                 p->offset = mt->offset + len;                  p->offset = mt->offset + len;
Line 585  post_IP(DECL_ARGS)
Line 604  post_IP(DECL_ARGS)
                 p->rmargin = p->maxrmargin;                  p->rmargin = p->maxrmargin;
                 break;                  break;
         case (MAN_BODY):          case (MAN_BODY):
                 term_flushln(p);                  term_newln(p);
                 p->flags &= ~TERMP_NOLPAD;  
                 break;                  break;
         default:          default:
                 break;                  break;
Line 600  pre_TP(DECL_ARGS)
Line 618  pre_TP(DECL_ARGS)
 {  {
         const struct man_node   *nn;          const struct man_node   *nn;
         size_t                   len;          size_t                   len;
         int                      ival;          int                      savelit, ival;
   
         switch (n->type) {          switch (n->type) {
         case (MAN_HEAD):          case (MAN_HEAD):
                 p->flags |= TERMP_NOBREAK;                  p->flags |= TERMP_NOBREAK;
                 p->flags |= TERMP_TWOSPACE;  
                 break;                  break;
         case (MAN_BODY):          case (MAN_BODY):
                 p->flags |= TERMP_NOLPAD;  
                 p->flags |= TERMP_NOSPACE;                  p->flags |= TERMP_NOSPACE;
                 break;                  break;
         case (MAN_BLOCK):          case (MAN_BLOCK):
Line 618  pre_TP(DECL_ARGS)
Line 634  pre_TP(DECL_ARGS)
                 return(1);                  return(1);
         }          }
   
         len = (size_t)mt->lmargin;          len = (size_t)mt->lmargin[mt->lmargincur];
         ival = -1;          ival = -1;
   
         /* Calculate offset. */          /* Calculate offset. */
   
         if (NULL != (nn = n->parent->head->child)) {          if (NULL != (nn = n->parent->head->child))
                 while (nn && MAN_TEXT != nn->type)                  if (nn->parent->line == nn->line)
                         nn = nn->next;  
                 if (nn && nn->next)  
                         if ((ival = a2width(p, nn->string)) >= 0)                          if ((ival = a2width(p, nn->string)) >= 0)
                                 len = (size_t)ival;                                  len = (size_t)ival;
         }  
   
         switch (n->type) {          switch (n->type) {
         case (MAN_HEAD):          case (MAN_HEAD):
Line 640  pre_TP(DECL_ARGS)
Line 653  pre_TP(DECL_ARGS)
                 p->offset = mt->offset;                  p->offset = mt->offset;
                 p->rmargin = mt->offset + len;                  p->rmargin = mt->offset + len;
   
                   savelit = MANT_LITERAL & mt->fl;
                   mt->fl &= ~MANT_LITERAL;
   
                 /* Don't print same-line elements. */                  /* Don't print same-line elements. */
                 for (nn = n->child; nn; nn = nn->next)                  for (nn = n->child; nn; nn = nn->next)
                         if (nn->line > n->line)                          if (nn->line > n->line)
                                 print_man_node(p, mt, nn, m);                                  print_man_node(p, mt, nn, m);
   
                   if (savelit)
                           mt->fl |= MANT_LITERAL;
                 if (ival >= 0)                  if (ival >= 0)
                         mt->lmargin = (size_t)ival;                          mt->lmargin[mt->lmargincur] = (size_t)ival;
   
                 return(0);                  return(0);
         case (MAN_BODY):          case (MAN_BODY):
Line 674  post_TP(DECL_ARGS)
Line 692  post_TP(DECL_ARGS)
                 p->rmargin = p->maxrmargin;                  p->rmargin = p->maxrmargin;
                 break;                  break;
         case (MAN_BODY):          case (MAN_BODY):
                 term_flushln(p);                  term_newln(p);
                 p->flags &= ~TERMP_NOLPAD;  
                 break;                  break;
         default:          default:
                 break;                  break;
Line 690  pre_SS(DECL_ARGS)
Line 707  pre_SS(DECL_ARGS)
   
         switch (n->type) {          switch (n->type) {
         case (MAN_BLOCK):          case (MAN_BLOCK):
                 mt->lmargin = term_len(p, INDENT);                  mt->fl &= ~MANT_LITERAL;
                   mt->lmargin[mt->lmargincur] = term_len(p, INDENT);
                 mt->offset = term_len(p, INDENT);                  mt->offset = term_len(p, INDENT);
                 /* If following a prior empty `SS', no vspace. */                  /* If following a prior empty `SS', no vspace. */
                 if (n->prev && MAN_SS == n->prev->tok)                  if (n->prev && MAN_SS == n->prev->tok)
Line 740  pre_SH(DECL_ARGS)
Line 758  pre_SH(DECL_ARGS)
   
         switch (n->type) {          switch (n->type) {
         case (MAN_BLOCK):          case (MAN_BLOCK):
                 mt->lmargin = term_len(p, INDENT);                  mt->fl &= ~MANT_LITERAL;
                   mt->lmargin[mt->lmargincur] = term_len(p, INDENT);
                 mt->offset = term_len(p, INDENT);                  mt->offset = term_len(p, INDENT);
                 /* If following a prior empty `SH', no vspace. */                  /* If following a prior empty `SH', no vspace. */
                 if (n->prev && MAN_SH == n->prev->tok)                  if (n->prev && MAN_SH == n->prev->tok)
Line 783  post_SH(DECL_ARGS)
Line 802  post_SH(DECL_ARGS)
         }          }
 }  }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static int  static int
 pre_RS(DECL_ARGS)  pre_RS(DECL_ARGS)
 {  {
         const struct man_node   *nn;          int              ival;
         int                      ival;          size_t           sz;
   
         switch (n->type) {          switch (n->type) {
         case (MAN_BLOCK):          case (MAN_BLOCK):
Line 801  pre_RS(DECL_ARGS)
Line 819  pre_RS(DECL_ARGS)
                 break;                  break;
         }          }
   
         if (NULL == (nn = n->parent->head->child)) {          sz = term_len(p, INDENT);
                 mt->offset = mt->lmargin + term_len(p, INDENT);  
                 p->offset = mt->offset;  
                 return(1);  
         }  
   
         if ((ival = a2width(p, nn->string)) < 0)          if (NULL != (n = n->parent->head->child))
                 return(1);                  if ((ival = a2width(p, n->string)) >= 0)
                           sz = (size_t)ival;
   
         mt->offset = term_len(p, INDENT) + (size_t)ival;          mt->offset += sz;
         p->offset = mt->offset;          p->offset = mt->offset;
   
           if (++mt->lmarginsz < MAXMARGINS)
                   mt->lmargincur = mt->lmarginsz;
   
           mt->lmargin[mt->lmargincur] = mt->lmargin[mt->lmargincur - 1];
         return(1);          return(1);
 }  }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static void
 post_RS(DECL_ARGS)  post_RS(DECL_ARGS)
 {  {
           int              ival;
           size_t           sz;
   
         switch (n->type) {          switch (n->type) {
         case (MAN_BLOCK):          case (MAN_BLOCK):
                 mt->offset = mt->lmargin = term_len(p, INDENT);                  return;
                 break;  
         case (MAN_HEAD):          case (MAN_HEAD):
                 break;                  return;
         default:          default:
                 term_newln(p);                  term_newln(p);
                 p->offset = term_len(p, INDENT);  
                 break;                  break;
         }          }
 }  
   
           sz = term_len(p, INDENT);
   
           if (NULL != (n = n->parent->head->child))
                   if ((ival = a2width(p, n->string)) >= 0)
                           sz = (size_t)ival;
   
           mt->offset = mt->offset < sz ?  0 : mt->offset - sz;
           p->offset = mt->offset;
   
           if (--mt->lmarginsz < MAXMARGINS)
                   mt->lmargincur = mt->lmarginsz;
   }
   
 static void  static void
 print_man_node(DECL_ARGS)  print_man_node(DECL_ARGS)
 {  {
         size_t           rm, rmax;          size_t           rm, rmax;
         int              c;          int              c;
   
         c = 1;  
   
         switch (n->type) {          switch (n->type) {
         case(MAN_TEXT):          case(MAN_TEXT):
                 if (0 == *n->string) {                  /*
                    * If we have a blank line, output a vertical space.
                    * If we have a space as the first character, break
                    * before printing the line's data.
                    */
                   if ('\0' == *n->string) {
                         term_vspace(p);                          term_vspace(p);
                         break;                          return;
                 }                  } else if (' ' == *n->string && MAN_LINE & n->flags)
                           term_newln(p);
   
                 term_word(p, n->string);                  term_word(p, n->string);
   
                 /* FIXME: this means that macro lines are munged!  */                  /*
                    * If we're in a literal context, make sure that words
                 if (MANT_LITERAL & mt->fl) {                   * togehter on the same line stay together.  This is a
                    * POST-printing call, so we check the NEXT word.  Since
                    * -man doesn't have nested macros, we don't need to be
                    * more specific than this.
                    */
                   if (MANT_LITERAL & mt->fl && ! (TERMP_NOBREAK & p->flags) &&
                                   (NULL == n->next ||
                                    n->next->line > n->line)) {
                         rm = p->rmargin;                          rm = p->rmargin;
                         rmax = p->maxrmargin;                          rmax = p->maxrmargin;
                         p->rmargin = p->maxrmargin = TERM_MAXMARGIN;                          p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
Line 864  print_man_node(DECL_ARGS)
Line 904  print_man_node(DECL_ARGS)
                         p->rmargin = rm;                          p->rmargin = rm;
                         p->maxrmargin = rmax;                          p->maxrmargin = rmax;
                 }                  }
                 break;  
                   if (MAN_EOS & n->flags)
                           p->flags |= TERMP_SENTENCE;
                   return;
           case (MAN_EQN):
                   term_eqn(p, n->eqn);
                   return;
         case (MAN_TBL):          case (MAN_TBL):
                   /*
                    * Tables are preceded by a newline.  Then process a
                    * table line, which will cause line termination,
                    */
                 if (TBL_SPAN_FIRST & n->span->flags)                  if (TBL_SPAN_FIRST & n->span->flags)
                         term_newln(p);                          term_newln(p);
                 term_tbl(p, n->span);                  term_tbl(p, n->span);
                 break;                  return;
         default:          default:
                 if ( ! (MAN_NOTEXT & termacts[n->tok].flags))  
                         term_fontrepl(p, TERMFONT_NONE);  
                 if (termacts[n->tok].pre)  
                         c = (*termacts[n->tok].pre)(p, mt, n, m);  
                 break;                  break;
         }          }
   
           if ( ! (MAN_NOTEXT & termacts[n->tok].flags))
                   term_fontrepl(p, TERMFONT_NONE);
   
           c = 1;
           if (termacts[n->tok].pre)
                   c = (*termacts[n->tok].pre)(p, mt, n, m);
   
         if (c && n->child)          if (c && n->child)
                 print_man_nodelist(p, mt, n->child, m);                  print_man_nodelist(p, mt, n->child, m);
   
         switch (n->type) {          if (termacts[n->tok].post)
         case (MAN_TEXT):                  (*termacts[n->tok].post)(p, mt, n, m);
                 /* FALLTHROUGH */          if ( ! (MAN_NOTEXT & termacts[n->tok].flags))
         case (MAN_TBL):                  term_fontrepl(p, TERMFONT_NONE);
                 break;  
         default:  
                 if (termacts[n->tok].post)  
                         (*termacts[n->tok].post)(p, mt, n, m);  
                 if ( ! (MAN_NOTEXT & termacts[n->tok].flags))  
                         term_fontrepl(p, TERMFONT_NONE);  
                 break;  
         }  
   
         if (MAN_EOS & n->flags)          if (MAN_EOS & n->flags)
                 p->flags |= TERMP_SENTENCE;                  p->flags |= TERMP_SENTENCE;
Line 913  print_man_nodelist(DECL_ARGS)
Line 958  print_man_nodelist(DECL_ARGS)
 static void  static void
 print_man_foot(struct termp *p, const void *arg)  print_man_foot(struct termp *p, const void *arg)
 {  {
         char            buf[DATESIZ];  
         const struct man_meta *meta;          const struct man_meta *meta;
   
         meta = (const struct man_meta *)arg;          meta = (const struct man_meta *)arg;
   
         term_fontrepl(p, TERMFONT_NONE);          term_fontrepl(p, TERMFONT_NONE);
   
         if (meta->rawdate)  
                 strlcpy(buf, meta->rawdate, DATESIZ);  
         else  
                 time2a(meta->date, buf, DATESIZ);  
   
         term_vspace(p);          term_vspace(p);
         term_vspace(p);          term_vspace(p);
         term_vspace(p);          term_vspace(p);
   
         p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;          p->flags |= TERMP_NOSPACE | TERMP_NOBREAK;
         p->rmargin = p->maxrmargin - term_strlen(p, buf);          p->rmargin = p->maxrmargin - term_strlen(p, meta->date);
         p->offset = 0;          p->offset = 0;
   
         /* term_strlen() can return zero. */          /* term_strlen() can return zero. */
Line 943  print_man_foot(struct termp *p, const void *arg)
Line 982  print_man_foot(struct termp *p, const void *arg)
                 term_word(p, "");                  term_word(p, "");
         term_flushln(p);          term_flushln(p);
   
         p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         p->offset = p->rmargin;          p->offset = p->rmargin;
         p->rmargin = p->maxrmargin;          p->rmargin = p->maxrmargin;
         p->flags &= ~TERMP_NOBREAK;          p->flags &= ~TERMP_NOBREAK;
   
         term_word(p, buf);          term_word(p, meta->date);
         term_flushln(p);          term_flushln(p);
 }  }
   
Line 968  print_man_head(struct termp *p, const void *arg)
Line 1007  print_man_head(struct termp *p, const void *arg)
          * point we did so here.           * point we did so here.
          */           */
   
           p->offset = 0;
         p->rmargin = p->maxrmargin;          p->rmargin = p->maxrmargin;
   
         p->offset = 0;  
         buf[0] = title[0] = '\0';          buf[0] = title[0] = '\0';
   
         if (m->vol)          if (m->vol)
Line 980  print_man_head(struct termp *p, const void *arg)
Line 1019  print_man_head(struct termp *p, const void *arg)
         snprintf(title, BUFSIZ, "%s(%s)", m->title, m->msec);          snprintf(title, BUFSIZ, "%s(%s)", m->title, m->msec);
         titlen = term_strlen(p, title);          titlen = term_strlen(p, title);
   
           p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;
         p->offset = 0;          p->offset = 0;
         p->rmargin = 2 * (titlen+1) + buflen < p->maxrmargin ?          p->rmargin = 2 * (titlen+1) + buflen < p->maxrmargin ?
             (p->maxrmargin -              (p->maxrmargin -
              term_strlen(p, buf) + term_len(p, 1)) / 2 :               term_strlen(p, buf) + term_len(p, 1)) / 2 :
             p->maxrmargin - buflen;              p->maxrmargin - buflen;
         p->flags |= TERMP_NOBREAK | TERMP_NOSPACE;  
   
         term_word(p, title);          term_word(p, title);
         term_flushln(p);          term_flushln(p);
   
         p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         p->offset = p->rmargin;          p->offset = p->rmargin;
         p->rmargin = p->offset + buflen + titlen < p->maxrmargin ?          p->rmargin = p->offset + buflen + titlen < p->maxrmargin ?
             p->maxrmargin - titlen : p->maxrmargin;              p->maxrmargin - titlen : p->maxrmargin;
Line 1000  print_man_head(struct termp *p, const void *arg)
Line 1039  print_man_head(struct termp *p, const void *arg)
   
         p->flags &= ~TERMP_NOBREAK;          p->flags &= ~TERMP_NOBREAK;
         if (p->rmargin + titlen <= p->maxrmargin) {          if (p->rmargin + titlen <= p->maxrmargin) {
                 p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;                  p->flags |= TERMP_NOSPACE;
                 p->offset = p->rmargin;                  p->offset = p->rmargin;
                 p->rmargin = p->maxrmargin;                  p->rmargin = p->maxrmargin;
                 term_word(p, title);                  term_word(p, title);
                 term_flushln(p);                  term_flushln(p);
         }          }
   
         p->rmargin = p->maxrmargin;  
         p->offset = 0;  
         p->flags &= ~TERMP_NOSPACE;          p->flags &= ~TERMP_NOSPACE;
           p->offset = 0;
           p->rmargin = p->maxrmargin;
   
         /*          /*
          * Groff likes to have some leading spaces before content.  Well           * Groff likes to have some leading spaces before content.  Well
Legend:
Removed from v.1.93  
changed lines
  Added in v.1.118
CVSweb