[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.135 and 1.150

version 1.135, 2010/05/31 10:28:04 version 1.150, 2010/06/12 12:10:55
Line 54  struct termact {
Line 54  struct termact {
   
 static  size_t    a2width(const struct mdoc_argv *, int);  static  size_t    a2width(const struct mdoc_argv *, int);
 static  size_t    a2height(const struct mdoc_node *);  static  size_t    a2height(const struct mdoc_node *);
 static  size_t    a2offs(const struct mdoc_argv *);  static  size_t    a2offs(const char *);
   
 static  int       arg_hasattr(int, const struct mdoc_node *);  static  int       arg_hasattr(int, const struct mdoc_node *);
 static  int       arg_getattrs(const int *, int *, size_t,  static  int       arg_getattrs(const int *, int *, size_t,
                         const struct mdoc_node *);                          const struct mdoc_node *);
 static  int       arg_getattr(int, const struct mdoc_node *);  static  int       arg_getattr(int, const struct mdoc_node *);
 static  int       arg_disptype(const struct mdoc_node *);  
 static  void      print_bvspace(struct termp *,  static  void      print_bvspace(struct termp *,
                         const struct mdoc_node *,  
                         const struct mdoc_node *);                          const struct mdoc_node *);
 static  void      print_mdoc_node(DECL_ARGS);  static  void      print_mdoc_node(DECL_ARGS);
 static  void      print_mdoc_head(DECL_ARGS);  
 static  void      print_mdoc_nodelist(DECL_ARGS);  static  void      print_mdoc_nodelist(DECL_ARGS);
 static  void      print_foot(DECL_ARGS);  static  void      print_mdoc_head(struct termp *, const void *);
   static  void      print_mdoc_foot(struct termp *, const void *);
   static  void      synopsis_pre(struct termp *,
                           const struct mdoc_node *);
   
 static  void      termp____post(DECL_ARGS);  static  void      termp____post(DECL_ARGS);
 static  void      termp_an_post(DECL_ARGS);  static  void      termp_an_post(DECL_ARGS);
Line 79  static void   termp_brq_post(DECL_ARGS);
Line 79  static void   termp_brq_post(DECL_ARGS);
 static  void      termp_bx_post(DECL_ARGS);  static  void      termp_bx_post(DECL_ARGS);
 static  void      termp_d1_post(DECL_ARGS);  static  void      termp_d1_post(DECL_ARGS);
 static  void      termp_dq_post(DECL_ARGS);  static  void      termp_dq_post(DECL_ARGS);
 static  void      termp_fd_post(DECL_ARGS);  static  int       termp_fd_pre(DECL_ARGS);
 static  void      termp_fn_post(DECL_ARGS);  
 static  void      termp_fo_post(DECL_ARGS);  static  void      termp_fo_post(DECL_ARGS);
 static  void      termp_ft_post(DECL_ARGS);  
 static  void      termp_in_post(DECL_ARGS);  static  void      termp_in_post(DECL_ARGS);
 static  void      termp_it_post(DECL_ARGS);  static  void      termp_it_post(DECL_ARGS);
 static  void      termp_lb_post(DECL_ARGS);  static  void      termp_lb_post(DECL_ARGS);
Line 93  static void   termp_qq_post(DECL_ARGS);
Line 91  static void   termp_qq_post(DECL_ARGS);
 static  void      termp_sh_post(DECL_ARGS);  static  void      termp_sh_post(DECL_ARGS);
 static  void      termp_sq_post(DECL_ARGS);  static  void      termp_sq_post(DECL_ARGS);
 static  void      termp_ss_post(DECL_ARGS);  static  void      termp_ss_post(DECL_ARGS);
 static  void      termp_vt_post(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);
Line 163  static const struct termact termacts[MDOC_MAX] = {
Line 160  static const struct termact termacts[MDOC_MAX] = {
         { NULL, NULL }, /* Ev */          { NULL, NULL }, /* Ev */
         { termp_ex_pre, NULL }, /* Ex */          { termp_ex_pre, NULL }, /* Ex */
         { termp_fa_pre, NULL }, /* Fa */          { termp_fa_pre, NULL }, /* Fa */
         { termp_bold_pre, termp_fd_post }, /* Fd */          { termp_fd_pre, NULL }, /* Fd */
         { termp_fl_pre, NULL }, /* Fl */          { termp_fl_pre, NULL }, /* Fl */
         { termp_fn_pre, termp_fn_post }, /* Fn */          { termp_fn_pre, NULL }, /* Fn */
         { termp_ft_pre, termp_ft_post }, /* Ft */          { termp_ft_pre, NULL }, /* Ft */
         { termp_bold_pre, NULL }, /* Ic */          { termp_bold_pre, NULL }, /* Ic */
         { termp_in_pre, termp_in_post }, /* In */          { termp_in_pre, termp_in_post }, /* In */
         { termp_li_pre, NULL }, /* Li */          { termp_li_pre, NULL }, /* Li */
Line 178  static const struct termact termacts[MDOC_MAX] = {
Line 175  static const struct termact termacts[MDOC_MAX] = {
         { termp_rv_pre, NULL }, /* Rv */          { termp_rv_pre, NULL }, /* Rv */
         { NULL, NULL }, /* St */          { NULL, NULL }, /* St */
         { termp_under_pre, NULL }, /* Va */          { termp_under_pre, NULL }, /* Va */
         { termp_vt_pre, termp_vt_post }, /* Vt */          { termp_vt_pre, NULL }, /* Vt */
         { termp_xr_pre, NULL }, /* Xr */          { termp_xr_pre, NULL }, /* Xr */
         { NULL, termp____post }, /* %A */          { NULL, termp____post }, /* %A */
         { termp_under_pre, termp____post }, /* %B */          { termp_under_pre, termp____post }, /* %B */
Line 290  terminal_mdoc(void *arg, const struct mdoc *mdoc)
Line 287  terminal_mdoc(void *arg, const struct mdoc *mdoc)
         n = mdoc_node(mdoc);          n = mdoc_node(mdoc);
         m = mdoc_meta(mdoc);          m = mdoc_meta(mdoc);
   
         print_mdoc_head(p, NULL, m, n);          term_begin(p, print_mdoc_head, print_mdoc_foot, m);
   
         if (n->child)          if (n->child)
                 print_mdoc_nodelist(p, NULL, m, n->child);                  print_mdoc_nodelist(p, NULL, m, n->child);
         print_foot(p, NULL, m, n);  
           term_end(p);
 }  }
   
   
Line 347  print_mdoc_node(DECL_ARGS)
Line 346  print_mdoc_node(DECL_ARGS)
 }  }
   
   
 /* ARGSUSED */  
 static void  static void
 print_foot(DECL_ARGS)  print_mdoc_foot(struct termp *p, const void *arg)
 {  {
         char            buf[DATESIZ], os[BUFSIZ];          char            buf[DATESIZ], os[BUFSIZ];
           const struct mdoc_meta *m;
   
           m = (const struct mdoc_meta *)arg;
   
         term_fontrepl(p, TERMFONT_NONE);          term_fontrepl(p, TERMFONT_NONE);
   
         /*          /*
Line 396  print_foot(DECL_ARGS)
Line 397  print_foot(DECL_ARGS)
 }  }
   
   
 /* ARGSUSED */  
 static void  static void
 print_mdoc_head(DECL_ARGS)  print_mdoc_head(struct termp *p, const void *arg)
 {  {
         char            buf[BUFSIZ], title[BUFSIZ];          char            buf[BUFSIZ], title[BUFSIZ];
           const struct mdoc_meta *m;
   
           m = (const struct mdoc_meta *)arg;
   
         p->rmargin = p->maxrmargin;          p->rmargin = p->maxrmargin;
         p->offset = 0;          p->offset = 0;
   
Line 484  a2width(const struct mdoc_argv *arg, int pos)
Line 487  a2width(const struct mdoc_argv *arg, int pos)
 }  }
   
   
 static int  
 arg_disptype(const struct mdoc_node *n)  
 {  
         int              i, len;  
   
         assert(MDOC_BLOCK == n->type);  
   
         len = (int)(n->args ? n->args->argc : 0);  
   
         for (i = 0; i < len; i++)  
                 switch (n->args->argv[i].arg) {  
                 case (MDOC_Centred):  
                         /* FALLTHROUGH */  
                 case (MDOC_Ragged):  
                         /* FALLTHROUGH */  
                 case (MDOC_Filled):  
                         /* FALLTHROUGH */  
                 case (MDOC_Unfilled):  
                         /* FALLTHROUGH */  
                 case (MDOC_Literal):  
                         return(n->args->argv[i].arg);  
                 default:  
                         break;  
                 }  
   
         return(-1);  
 }  
   
   
 static size_t  static size_t
 a2offs(const struct mdoc_argv *arg)  a2offs(const char *v)
 {  {
         struct roffsu    su;          struct roffsu    su;
   
         if ('\0' == arg->value[0][0])          if ('\0' == *v)
                 return(0);                  return(0);
         else if (0 == strcmp(arg->value[0], "left"))          else if (0 == strcmp(v, "left"))
                 return(0);                  return(0);
         else if (0 == strcmp(arg->value[0], "indent"))          else if (0 == strcmp(v, "indent"))
                 return(INDENT + 1);                  return(INDENT + 1);
         else if (0 == strcmp(arg->value[0], "indent-two"))          else if (0 == strcmp(v, "indent-two"))
                 return((INDENT + 1) * 2);                  return((INDENT + 1) * 2);
         else if ( ! a2roffsu(arg->value[0], &su, SCALE_MAX))          else if ( ! a2roffsu(v, &su, SCALE_MAX))
                 SCALE_HS_INIT(&su, strlen(arg->value[0]));                  SCALE_HS_INIT(&su, strlen(v));
   
         return(term_hspan(&su));          return(term_hspan(&su));
 }  }
Line 589  arg_getattrs(const int *keys, int *vals, 
Line 563  arg_getattrs(const int *keys, int *vals, 
  * too.   * too.
  */   */
 static void  static void
 print_bvspace(struct termp *p,  print_bvspace(struct termp *p, const struct mdoc_node *n)
                 const struct mdoc_node *bl,  
                 const struct mdoc_node *n)  
 {  {
         const struct mdoc_node  *nn;          const struct mdoc_node  *nn;
   
         term_newln(p);          term_newln(p);
         if (arg_hasattr(MDOC_Compact, bl))  
           if (MDOC_Bl == n->tok && n->data.Bl.comp)
                 return;                  return;
           if (MDOC_Bd == n->tok && n->data.Bd.comp)
                   return;
   
         /* Do not vspace directly after Ss/Sh. */          /* Do not vspace directly after Ss/Sh. */
   
Line 615  print_bvspace(struct termp *p, 
Line 590  print_bvspace(struct termp *p, 
   
         /* A `-column' does not assert vspace within the list. */          /* A `-column' does not assert vspace within the list. */
   
         if (MDOC_Bl == bl->tok && LIST_column == bl->data.list)          if (MDOC_Bl == n->tok && LIST_column == n->data.Bl.type)
                 if (n->prev && MDOC_It == n->prev->tok)                  if (n->prev && MDOC_It == n->prev->tok)
                         return;                          return;
   
         /* A `-diag' without body does not vspace. */          /* A `-diag' without body does not vspace. */
   
         if (MDOC_Bl == bl->tok && LIST_diag == bl->data.list)          if (MDOC_Bl == n->tok && LIST_diag == n->data.Bl.type)
                 if (n->prev && MDOC_It == n->prev->tok) {                  if (n->prev && MDOC_It == n->prev->tok) {
                         assert(n->prev->body);                          assert(n->prev->body);
                         if (NULL == n->prev->body->child)                          if (NULL == n->prev->body->child)
Line 670  termp_it_pre(DECL_ARGS)
Line 645  termp_it_pre(DECL_ARGS)
         enum mdoc_list          type;          enum mdoc_list          type;
   
         if (MDOC_BLOCK == n->type) {          if (MDOC_BLOCK == n->type) {
                 print_bvspace(p, n->parent->parent, n);                  print_bvspace(p, n);
                 return(1);                  return(1);
         }          }
   
Line 686  termp_it_pre(DECL_ARGS)
Line 661  termp_it_pre(DECL_ARGS)
   
         arg_getattrs(keys, vals, 3, bl);          arg_getattrs(keys, vals, 3, bl);
   
         type = bl->data.list;          type = bl->data.Bl.type;
   
         /*          /*
          * First calculate width and offset.  This is pretty easy unless           * First calculate width and offset.  This is pretty easy unless
Line 697  termp_it_pre(DECL_ARGS)
Line 672  termp_it_pre(DECL_ARGS)
         width = offset = 0;          width = offset = 0;
   
         if (vals[1] >= 0)          if (vals[1] >= 0)
                 offset = a2offs(&bl->args->argv[vals[1]]);                  offset = a2offs(bl->args->argv[vals[1]].value[0]);
   
         switch (type) {          switch (type) {
         case (LIST_column):          case (LIST_column):
Line 1014  termp_it_post(DECL_ARGS)
Line 989  termp_it_post(DECL_ARGS)
         if (MDOC_BLOCK == n->type)          if (MDOC_BLOCK == n->type)
                 return;                  return;
   
         type = n->parent->parent->parent->data.list;          type = n->parent->parent->parent->data.Bl.type;
   
         switch (type) {          switch (type) {
         case (LIST_item):          case (LIST_item):
Line 1056  termp_nm_pre(DECL_ARGS)
Line 1031  termp_nm_pre(DECL_ARGS)
         if (NULL == n->child && NULL == m->name)          if (NULL == n->child && NULL == m->name)
                 return(1);                  return(1);
   
         if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags)          synopsis_pre(p, n);
                 term_newln(p);  
   
         term_fontpush(p, TERMFONT_BOLD);          term_fontpush(p, TERMFONT_BOLD);
   
         if (NULL == n->child)          if (NULL == n->child)
                 term_word(p, m->name);                  term_word(p, m->name);
   
         return(1);          return(1);
 }  }
   
Line 1314  termp_xr_pre(DECL_ARGS)
Line 1286  termp_xr_pre(DECL_ARGS)
 }  }
   
   
   /*
    * This decides how to assert whitespace before any of the SYNOPSIS set
    * of macros (which, as in the case of Ft/Fo and Ft/Fn, may contain
    * macro combos).
    */
   static void
   synopsis_pre(struct termp *p, const struct mdoc_node *n)
   {
           /*
            * Obviously, if we're not in a SYNOPSIS or no prior macros
            * exist, do nothing.
            */
           if (NULL == n->prev || SEC_SYNOPSIS != n->sec)
                   return;
   
           /*
            * If we're the second in a pair of like elements, emit our
            * newline and return.  UNLESS we're `Fo', `Fn', `Fn', in which
            * case we soldier on.
            */
           if (n->prev->tok == n->tok &&
                           MDOC_Ft != n->tok &&
                           MDOC_Fo != n->tok &&
                           MDOC_Fn != n->tok) {
                   term_newln(p);
                   return;
           }
   
           /*
            * If we're one of the SYNOPSIS set and non-like pair-wise after
            * another (or Fn/Fo, which we've let slip through) then assert
            * vertical space, else only newline and move on.
            */
           switch (n->prev->tok) {
           case (MDOC_Fd):
                   /* FALLTHROUGH */
           case (MDOC_Fn):
                   /* FALLTHROUGH */
           case (MDOC_Fo):
                   /* FALLTHROUGH */
           case (MDOC_In):
                   /* FALLTHROUGH */
           case (MDOC_Vt):
                   term_vspace(p);
                   break;
           case (MDOC_Ft):
                   if (MDOC_Fn != n->tok && MDOC_Fo != n->tok) {
                           term_vspace(p);
                           break;
                   }
                   /* FALLTHROUGH */
           default:
                   term_newln(p);
                   break;
           }
   }
   
   
 static int  static int
 termp_vt_pre(DECL_ARGS)  termp_vt_pre(DECL_ARGS)
 {  {
   
         if (MDOC_ELEM == n->type)          if (MDOC_ELEM == n->type) {
                   synopsis_pre(p, n);
                 return(termp_under_pre(p, pair, m, n));                  return(termp_under_pre(p, pair, m, n));
         else if (MDOC_HEAD == n->type)          } else if (MDOC_BLOCK == n->type) {
                 return(0);                  synopsis_pre(p, n);
         else if (MDOC_BLOCK == n->type)  
                 return(1);                  return(1);
           } else if (MDOC_HEAD == n->type)
                   return(0);
   
         return(termp_under_pre(p, pair, m, n));          return(termp_under_pre(p, pair, m, n));
 }  }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  
 termp_vt_post(DECL_ARGS)  
 {  
   
         if (MDOC_BLOCK != n->type)  
                 return;  
         if (n->next && MDOC_Vt == n->next->tok)  
                 term_newln(p);  
         else if (n->next)  
                 term_vspace(p);  
 }  
   
   
 /* ARGSUSED */  
 static int  static int
 termp_bold_pre(DECL_ARGS)  termp_bold_pre(DECL_ARGS)
 {  {
Line 1354  termp_bold_pre(DECL_ARGS)
Line 1372  termp_bold_pre(DECL_ARGS)
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  static int
 termp_fd_post(DECL_ARGS)  termp_fd_pre(DECL_ARGS)
 {  {
   
         if (n->sec != SEC_SYNOPSIS || ! (MDOC_LINE & n->flags))          synopsis_pre(p, n);
                 return;          return(termp_bold_pre(p, pair, m, n));
   
         term_newln(p);  
         if (n->next && MDOC_Fd != n->next->tok)  
                 term_vspace(p);  
 }  }
   
   
Line 1516  static int
Line 1530  static int
 termp_ft_pre(DECL_ARGS)  termp_ft_pre(DECL_ARGS)
 {  {
   
         if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags)          /* NB: MDOC_LINE does not effect this! */
                 if (n->prev && MDOC_Fo == n->prev->tok)          synopsis_pre(p, n);
                         term_vspace(p);  
   
         term_fontpush(p, TERMFONT_UNDER);          term_fontpush(p, TERMFONT_UNDER);
         return(1);          return(1);
 }  }
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  
 termp_ft_post(DECL_ARGS)  
 {  
   
         if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags)  
                 term_newln(p);  
 }  
   
   
 /* ARGSUSED */  
 static int  static int
 termp_fn_pre(DECL_ARGS)  termp_fn_pre(DECL_ARGS)
 {  {
         const struct mdoc_node  *nn;          const struct mdoc_node  *nn;
   
           synopsis_pre(p, n);
   
         term_fontpush(p, TERMFONT_BOLD);          term_fontpush(p, TERMFONT_BOLD);
         term_word(p, n->child->string);          term_word(p, n->child->string);
         term_fontpop(p);          term_fontpop(p);
Line 1567  termp_fn_pre(DECL_ARGS)
Line 1571  termp_fn_pre(DECL_ARGS)
   
   
 /* ARGSUSED */  /* ARGSUSED */
 static void  
 termp_fn_post(DECL_ARGS)  
 {  
   
         if (n->sec == SEC_SYNOPSIS && n->next && MDOC_LINE & n->flags)  
                 term_vspace(p);  
 }  
   
   
 /* ARGSUSED */  
 static int  static int
 termp_fa_pre(DECL_ARGS)  termp_fa_pre(DECL_ARGS)
 {  {
Line 1608  static int
Line 1602  static int
 termp_bd_pre(DECL_ARGS)  termp_bd_pre(DECL_ARGS)
 {  {
         size_t                   tabwidth;          size_t                   tabwidth;
         int                      i, type;  
         size_t                   rm, rmax;          size_t                   rm, rmax;
         const struct mdoc_node  *nn;          const struct mdoc_node  *nn;
   
         if (MDOC_BLOCK == n->type) {          if (MDOC_BLOCK == n->type) {
                 print_bvspace(p, n, n);                  print_bvspace(p, n);
                 return(1);                  return(1);
         } else if (MDOC_HEAD == n->type)          } else if (MDOC_HEAD == n->type)
                 return(0);                  return(0);
   
         nn = n->parent;          if (n->data.Bd.offs)
                   p->offset += a2offs(n->data.Bd.offs);
   
         type = arg_disptype(nn);  
         assert(-1 != type);  
   
         if (-1 != (i = arg_getattr(MDOC_Offset, nn)))  
                 p->offset += a2offs(&nn->args->argv[i]);  
   
         /*          /*
          * If -ragged or -filled are specified, the block does nothing           * If -ragged or -filled are specified, the block does nothing
          * but change the indentation.  If -unfilled or -literal are           * but change the indentation.  If -unfilled or -literal are
Line 1634  termp_bd_pre(DECL_ARGS)
Line 1622  termp_bd_pre(DECL_ARGS)
          * lines are allowed.           * lines are allowed.
          */           */
   
         if (MDOC_Literal != type && MDOC_Unfilled != type)          if (DISP_literal != n->data.Bd.type &&
                           DISP_unfilled != n->data.Bd.type)
                 return(1);                  return(1);
   
         tabwidth = p->tabwidth;          tabwidth = p->tabwidth;
Line 1651  termp_bd_pre(DECL_ARGS)
Line 1640  termp_bd_pre(DECL_ARGS)
                     NULL == nn->next)                      NULL == nn->next)
                         term_flushln(p);                          term_flushln(p);
         }          }
         p->tabwidth = tabwidth;  
   
           p->tabwidth = tabwidth;
         p->rmargin = rm;          p->rmargin = rm;
         p->maxrmargin = rmax;          p->maxrmargin = rmax;
         return(0);          return(0);
Line 1663  termp_bd_pre(DECL_ARGS)
Line 1652  termp_bd_pre(DECL_ARGS)
 static void  static void
 termp_bd_post(DECL_ARGS)  termp_bd_post(DECL_ARGS)
 {  {
         int              type;  
         size_t           rm, rmax;          size_t           rm, rmax;
   
         if (MDOC_BODY != n->type)          if (MDOC_BODY != n->type)
                 return;                  return;
   
         type = arg_disptype(n->parent);  
         assert(-1 != type);  
   
         rm = p->rmargin;          rm = p->rmargin;
         rmax = p->maxrmargin;          rmax = p->maxrmargin;
   
         if (MDOC_Literal == type || MDOC_Unfilled == type)          if (DISP_literal == n->data.Bd.type ||
                           DISP_unfilled == n->data.Bd.type)
                 p->rmargin = p->maxrmargin = TERM_MAXMARGIN;                  p->rmargin = p->maxrmargin = TERM_MAXMARGIN;
   
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
Line 1841  static int
Line 1827  static int
 termp_cd_pre(DECL_ARGS)  termp_cd_pre(DECL_ARGS)
 {  {
   
           synopsis_pre(p, n);
         term_fontpush(p, TERMFONT_BOLD);          term_fontpush(p, TERMFONT_BOLD);
         term_newln(p);  
         return(1);          return(1);
 }  }
   
Line 1852  static int
Line 1838  static int
 termp_in_pre(DECL_ARGS)  termp_in_pre(DECL_ARGS)
 {  {
   
         term_fontpush(p, TERMFONT_BOLD);          synopsis_pre(p, n);
         if (SEC_SYNOPSIS == n->sec)  
           if (SEC_SYNOPSIS == n->sec && MDOC_LINE & n->flags) {
                   term_fontpush(p, TERMFONT_BOLD);
                 term_word(p, "#include");                  term_word(p, "#include");
                   term_word(p, "<");
           } else {
                   term_word(p, "<");
                   term_fontpush(p, TERMFONT_UNDER);
           }
   
         term_word(p, "<");  
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         return(1);          return(1);
 }  }
Line 1867  static void
Line 1859  static void
 termp_in_post(DECL_ARGS)  termp_in_post(DECL_ARGS)
 {  {
   
         term_fontpush(p, TERMFONT_BOLD);          if (SEC_SYNOPSIS == n->sec)
                   term_fontpush(p, TERMFONT_BOLD);
   
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         term_word(p, ">");          term_word(p, ">");
         term_fontpop(p);  
   
         if (SEC_SYNOPSIS != n->sec && ! (MDOC_LINE & n->flags))          if (SEC_SYNOPSIS == n->sec)
                 return;                  term_fontpop(p);
   
         term_newln(p);  
         /*  
          * XXX Not entirely correct.  If `.In foo bar' is specified in  
          * the SYNOPSIS section, then it produces a single break after  
          * the <foo>; mandoc asserts a vertical space.  Since this  
          * construction is rarely used, I think it's fine.  
          */  
         if (n->next && MDOC_In != n->next->tok)  
                 term_vspace(p);  
 }  }
   
   
Line 1992  termp_pq_post(DECL_ARGS)
Line 1975  termp_pq_post(DECL_ARGS)
 static int  static int
 termp_fo_pre(DECL_ARGS)  termp_fo_pre(DECL_ARGS)
 {  {
         const struct mdoc_node *nn;  
   
         if (MDOC_BODY == n->type) {          if (MDOC_BLOCK == n->type) {
                   synopsis_pre(p, n);
                   return(1);
           } else if (MDOC_BODY == n->type) {
                 p->flags |= TERMP_NOSPACE;                  p->flags |= TERMP_NOSPACE;
                 term_word(p, "(");                  term_word(p, "(");
                 p->flags |= TERMP_NOSPACE;                  p->flags |= TERMP_NOSPACE;
                 return(1);                  return(1);
         } else if (MDOC_HEAD != n->type)          }
                 return(1);  
   
         term_fontpush(p, TERMFONT_BOLD);          /* XXX: we drop non-initial arguments as per groff. */
         for (nn = n->child; nn; nn = nn->next) {  
                 assert(MDOC_TEXT == nn->type);  
                 term_word(p, nn->string);  
         }  
         term_fontpop(p);  
   
           assert(n->child);
           assert(n->child->string);
           term_fontpush(p, TERMFONT_BOLD);
           term_word(p, n->child->string);
         return(0);          return(0);
 }  }
   
Line 2018  static void
Line 2001  static void
 termp_fo_post(DECL_ARGS)  termp_fo_post(DECL_ARGS)
 {  {
   
         if (MDOC_BODY != n->type)          if (MDOC_BODY != n->type)
                 return;                  return;
   
         p->flags |= TERMP_NOSPACE;          p->flags |= TERMP_NOSPACE;
         term_word(p, ")");          term_word(p, ")");
         p->flags |= TERMP_NOSPACE;  
         term_word(p, ";");          if (SEC_SYNOPSIS == n->sec) {
         term_newln(p);                  p->flags |= TERMP_NOSPACE;
                   term_word(p, ";");
           }
 }  }
   
   
Legend:
Removed from v.1.135  
changed lines
  Added in v.1.150
CVSweb