[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.21 and 1.23

version 1.21, 2009/08/13 12:31:50 version 1.23, 2009/08/17 11:03:07
Line 66  static int    pre_sp(DECL_ARGS);
Line 66  static int    pre_sp(DECL_ARGS);
   
 static  void              post_B(DECL_ARGS);  static  void              post_B(DECL_ARGS);
 static  void              post_I(DECL_ARGS);  static  void              post_I(DECL_ARGS);
   static  void              post_IP(DECL_ARGS);
 static  void              post_HP(DECL_ARGS);  static  void              post_HP(DECL_ARGS);
 static  void              post_SH(DECL_ARGS);  static  void              post_SH(DECL_ARGS);
 static  void              post_SS(DECL_ARGS);  static  void              post_SS(DECL_ARGS);
Line 81  static const struct termact termacts[MAN_MAX] = {
Line 82  static const struct termact termacts[MAN_MAX] = {
         { pre_PP, NULL }, /* LP */          { pre_PP, NULL }, /* LP */
         { pre_PP, NULL }, /* PP */          { pre_PP, NULL }, /* PP */
         { pre_PP, NULL }, /* P */          { pre_PP, NULL }, /* P */
         { pre_IP, NULL }, /* IP */          { pre_IP, post_IP }, /* IP */
         { pre_HP, post_HP }, /* HP */          { pre_HP, post_HP }, /* HP */
         { NULL, NULL }, /* SM */          { NULL, NULL }, /* SM */
         { pre_B, post_B }, /* SB */          { pre_B, post_B }, /* SB */
Line 468  pre_PP(DECL_ARGS)
Line 469  pre_PP(DECL_ARGS)
 static int  static int
 pre_IP(DECL_ARGS)  pre_IP(DECL_ARGS)
 {  {
         /* TODO */          const struct man_node   *nn;
 #if 0          size_t                   len;
         const struct man_node *nn;          int                      ival;
         size_t           offs, sv;  
         int              ival;  
   
         fmt_block_vspace(p, n);          switch (n->type) {
           case (MAN_BODY):
                   p->flags |= TERMP_NOLPAD;
                   p->flags |= TERMP_NOSPACE;
                   break;
           case (MAN_HEAD):
                   p->flags |= TERMP_NOBREAK;
                   p->flags |= TERMP_TWOSPACE;
                   break;
           case (MAN_BLOCK):
                   fmt_block_vspace(p, n);
                   /* FALLTHROUGH */
           default:
                   return(1);
           }
   
         p->flags |= TERMP_NOSPACE;          len = INDENT;
           ival = -1;
   
         sv = p->offset;          /* Calculate offset. */
         p->offset = INDENT;  
   
         if (NULL == n->child)          if (NULL != (nn = n->parent->head->child))
                 return(1);                  if (NULL != (nn = nn->next)) {
                           for ( ; nn->next; nn = nn->next)
                                   /* Do nothing. */ ;
                           if ((ival = arg_width(nn)) >= 0)
                                   len = (size_t)ival;
                   }
   
         p->flags |= TERMP_NOBREAK;          switch (n->type) {
           case (MAN_HEAD):
                   /* Handle zero-width lengths. */
                   if (0 == len)
                           len = 1;
   
         offs = sv;                  p->offset = INDENT;
                   p->rmargin = INDENT + len;
                   if (ival < 0)
                           break;
   
         /*                  /* Don't print the length value. */
          * If the last token is number-looking (3m, 3n, 3) then                  for (nn = n->child; nn->next; nn = nn->next)
          * interpret it as the width specifier, else we stick with the                          print_node(p, fl, nn, m);
          * prior saved offset.  XXX - obviously not documented.                  return(0);
          */          case (MAN_BODY):
         for (nn = n->child; nn; nn = nn->next) {                  p->offset = INDENT + len;
                 if (NULL == nn->next) {                  p->rmargin = p->maxrmargin;
                         ival = arg_width(nn);                  break;
                         if (ival >= 0) {          default:
                                 offs = (size_t)ival;                  break;
                                 break;  
                         }  
                 }  
                 print_node(p, fl, nn, m);  
         }          }
   
         p->rmargin = p->offset + offs;          return(1);
   }
   
         term_flushln(p);  
   
         p->offset = offs;  /* ARGSUSED */
         p->rmargin = p->maxrmargin;  static void
   post_IP(DECL_ARGS)
   {
   
         p->flags |= TERMP_NOLPAD | TERMP_NOSPACE;          switch (n->type) {
           case (MAN_HEAD):
         return(0);                  term_flushln(p);
 #endif                  p->flags &= ~TERMP_NOBREAK;
         return(1);                  p->flags &= ~TERMP_TWOSPACE;
                   p->rmargin = p->maxrmargin;
                   break;
           case (MAN_BODY):
                   term_flushln(p);
                   p->flags &= ~TERMP_NOLPAD;
                   break;
           default:
                   break;
           }
 }  }
   
   
Line 523  pre_IP(DECL_ARGS)
Line 555  pre_IP(DECL_ARGS)
 static int  static int
 pre_TP(DECL_ARGS)  pre_TP(DECL_ARGS)
 {  {
           const struct man_node   *nn;
           size_t                   len;
           int                      ival;
   
         switch (n->type) {          switch (n->type) {
         case (MAN_BLOCK):  
                 fmt_block_vspace(p, n);  
                 break;  
         case (MAN_HEAD):          case (MAN_HEAD):
                 p->rmargin = INDENT * 2;  
                 p->offset = INDENT;  
                 p->flags |= TERMP_NOBREAK;                  p->flags |= TERMP_NOBREAK;
                 p->flags |= TERMP_TWOSPACE;                  p->flags |= TERMP_TWOSPACE;
                 break;                  break;
         case (MAN_BODY):          case (MAN_BODY):
                 p->flags |= TERMP_NOLPAD;                  p->flags |= TERMP_NOLPAD;
                 p->flags |= TERMP_NOSPACE;                  p->flags |= TERMP_NOSPACE;
                 p->offset = INDENT * 2;  
                 break;                  break;
           case (MAN_BLOCK):
                   fmt_block_vspace(p, n);
                   /* FALLTHROUGH */
         default:          default:
                   return(1);
           }
   
           len = INDENT;
           ival = -1;
   
           /* Calculate offset. */
   
           if (NULL != (nn = n->parent->head->child))
                   if (NULL != nn->next)
                           if ((ival = arg_width(nn)) >= 0)
                                   len = (size_t)ival;
   
           switch (n->type) {
           case (MAN_HEAD):
                   /* Handle zero-length properly. */
                   if (0 == len)
                           len = 1;
   
                   p->offset = INDENT;
                   p->rmargin = INDENT + len;
   
                   /* Don't print same-line elements. */
                   for (nn = n->child; nn; nn = nn->next)
                           if (nn->line > n->line)
                                   print_node(p, fl, nn, m);
                   return(0);
           case (MAN_BODY):
                   p->offset = INDENT + len;
                   p->rmargin = p->maxrmargin;
                 break;                  break;
           default:
                   break;
         }          }
   
         return(1);          return(1);
Line 613  post_SS(DECL_ARGS)
Line 677  post_SS(DECL_ARGS)
 static int  static int
 pre_SH(DECL_ARGS)  pre_SH(DECL_ARGS)
 {  {
         /*  
          * XXX: undocumented: using two `SH' macros in sequence has no  
          * vspace between calls, only a newline.  
          */  
         switch (n->type) {          switch (n->type) {
         case (MAN_BLOCK):          case (MAN_BLOCK):
                   /* If following a prior empty `SH', no vspace. */
                 if (n->prev && MAN_SH == n->prev->tok)                  if (n->prev && MAN_SH == n->prev->tok)
                         if (NULL == n->prev->body->child)                          if (NULL == n->prev->body->child)
                                 break;                                  break;
Legend:
Removed from v.1.21  
changed lines
  Added in v.1.23
CVSweb