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

Diff for /mandoc/man_html.c between version 1.131 and 1.132

version 1.131, 2017/01/29 14:02:42 version 1.132, 2017/01/30 20:24:02
Line 38 
Line 38 
   
 #define MAN_ARGS          const struct roff_meta *man, \  #define MAN_ARGS          const struct roff_meta *man, \
                           const struct roff_node *n, \                            const struct roff_node *n, \
                           struct mhtml *mh, \  
                           struct html *h                            struct html *h
   
 struct  mhtml {  
         struct tag       *nofill;  
 };  
   
 struct  htmlman {  struct  htmlman {
         int             (*pre)(MAN_ARGS);          int             (*pre)(MAN_ARGS);
         int             (*post)(MAN_ARGS);          int             (*post)(MAN_ARGS);
Line 55  static void    print_bvspace(struct html *,
Line 50  static void    print_bvspace(struct html *,
 static  void              print_man_head(MAN_ARGS);  static  void              print_man_head(MAN_ARGS);
 static  void              print_man_nodelist(MAN_ARGS);  static  void              print_man_nodelist(MAN_ARGS);
 static  void              print_man_node(MAN_ARGS);  static  void              print_man_node(MAN_ARGS);
   static  int               fillmode(struct html *, int);
 static  int               a2width(const struct roff_node *,  static  int               a2width(const struct roff_node *,
                                 struct roffsu *);                                  struct roffsu *);
 static  int               man_B_pre(MAN_ARGS);  static  int               man_B_pre(MAN_ARGS);
Line 70  static int    man_SS_pre(MAN_ARGS);
Line 66  static int    man_SS_pre(MAN_ARGS);
 static  int               man_UR_pre(MAN_ARGS);  static  int               man_UR_pre(MAN_ARGS);
 static  int               man_alt_pre(MAN_ARGS);  static  int               man_alt_pre(MAN_ARGS);
 static  int               man_br_pre(MAN_ARGS);  static  int               man_br_pre(MAN_ARGS);
 static  int               man_fill_pre(MAN_ARGS);  
 static  int               man_ign_pre(MAN_ARGS);  static  int               man_ign_pre(MAN_ARGS);
 static  int               man_in_pre(MAN_ARGS);  static  int               man_in_pre(MAN_ARGS);
 static  void              man_root_post(MAN_ARGS);  static  void              man_root_post(MAN_ARGS);
Line 99  static const struct htmlman mans[MAN_MAX] = {
Line 94  static const struct htmlman mans[MAN_MAX] = {
         { man_alt_pre, NULL }, /* IR */          { man_alt_pre, NULL }, /* IR */
         { man_alt_pre, NULL }, /* RI */          { man_alt_pre, NULL }, /* RI */
         { man_br_pre, NULL }, /* sp */          { man_br_pre, NULL }, /* sp */
         { man_fill_pre, NULL }, /* nf */          { NULL, NULL }, /* nf */
         { man_fill_pre, NULL }, /* fi */          { NULL, NULL }, /* fi */
         { NULL, NULL }, /* RE */          { NULL, NULL }, /* RE */
         { man_RS_pre, NULL }, /* RS */          { man_RS_pre, NULL }, /* RS */
         { man_ign_pre, NULL }, /* DT */          { man_ign_pre, NULL }, /* DT */
Line 110  static const struct htmlman mans[MAN_MAX] = {
Line 105  static const struct htmlman mans[MAN_MAX] = {
         { man_in_pre, NULL }, /* in */          { man_in_pre, NULL }, /* in */
         { man_ign_pre, NULL }, /* ft */          { man_ign_pre, NULL }, /* ft */
         { man_OP_pre, NULL }, /* OP */          { man_OP_pre, NULL }, /* OP */
         { man_fill_pre, NULL }, /* EX */          { NULL, NULL }, /* EX */
         { man_fill_pre, NULL }, /* EE */          { NULL, NULL }, /* EE */
         { man_UR_pre, NULL }, /* UR */          { man_UR_pre, NULL }, /* UR */
         { NULL, NULL }, /* UE */          { NULL, NULL }, /* UE */
         { man_ign_pre, NULL }, /* ll */          { man_ign_pre, NULL }, /* ll */
Line 144  print_bvspace(struct html *h, const struct roff_node *
Line 139  print_bvspace(struct html *h, const struct roff_node *
 void  void
 html_man(void *arg, const struct roff_man *man)  html_man(void *arg, const struct roff_man *man)
 {  {
         struct mhtml     mh;  
         struct html     *h;          struct html     *h;
         struct tag      *t;          struct tag      *t;
   
         mh.nofill = NULL;  
         h = (struct html *)arg;          h = (struct html *)arg;
   
         if ((h->oflags & HTML_FRAGMENT) == 0) {          if ((h->oflags & HTML_FRAGMENT) == 0) {
                 print_gen_decls(h);                  print_gen_decls(h);
                 print_otag(h, TAG_HTML, "");                  print_otag(h, TAG_HTML, "");
                 t = print_otag(h, TAG_HEAD, "");                  t = print_otag(h, TAG_HEAD, "");
                 print_man_head(&man->meta, man->first, &mh, h);                  print_man_head(&man->meta, man->first, h);
                 print_tagq(h, t);                  print_tagq(h, t);
                 print_otag(h, TAG_BODY, "");                  print_otag(h, TAG_BODY, "");
         }          }
   
         man_root_pre(&man->meta, man->first, &mh, h);          man_root_pre(&man->meta, man->first, h);
         t = print_otag(h, TAG_DIV, "c", "manual-text");          t = print_otag(h, TAG_DIV, "c", "manual-text");
         print_man_nodelist(&man->meta, man->first->child, &mh, h);          print_man_nodelist(&man->meta, man->first->child, h);
         print_tagq(h, t);          print_tagq(h, t);
         man_root_post(&man->meta, man->first, &mh, h);          man_root_post(&man->meta, man->first, h);
         print_tagq(h, NULL);          print_tagq(h, NULL);
 }  }
   
Line 185  print_man_nodelist(MAN_ARGS)
Line 178  print_man_nodelist(MAN_ARGS)
 {  {
   
         while (n != NULL) {          while (n != NULL) {
                 print_man_node(man, n, mh, h);                  print_man_node(man, n, h);
                 n = n->next;                  n = n->next;
         }          }
 }  }
Line 193  print_man_nodelist(MAN_ARGS)
Line 186  print_man_nodelist(MAN_ARGS)
 static void  static void
 print_man_node(MAN_ARGS)  print_man_node(MAN_ARGS)
 {  {
         int              child;          static int       want_fillmode = MAN_fi;
           static int       save_fillmode;
   
         struct tag      *t;          struct tag      *t;
           int              child;
   
         child = 1;          /*
         t = h->tag;           * Handle fill mode switch requests up front,
         if (t == mh->nofill)           * they would just cause trouble in the subsequent code.
                 t = t->next;           */
   
           switch (n->tok) {
           case MAN_nf:
           case MAN_EX:
                   want_fillmode = MAN_nf;
                   return;
           case MAN_fi:
           case MAN_EE:
                   want_fillmode = MAN_fi;
                   if (fillmode(h, 0) == MAN_fi)
                           print_otag(h, TAG_BR, "");
                   return;
           default:
                   break;
           }
   
           /* Set up fill mode for the upcoming node. */
   
         switch (n->type) {          switch (n->type) {
         case ROFFT_TEXT:          case ROFFT_BLOCK:
                 if ('\0' == *n->string) {                  save_fillmode = 0;
                         print_paragraph(h);                  /* Some block macros suspend or cancel .nf. */
                         return;                  switch (n->tok) {
                   case MAN_TP:  /* Tagged paragraphs              */
                   case MAN_IP:  /* temporarily disable .nf        */
                   case MAN_HP:  /* for the head.                  */
                           save_fillmode = want_fillmode;
                           /* FALLTHROUGH */
                   case MAN_SH:  /* Section headers                */
                   case MAN_SS:  /* permanently cancel .nf.        */
                           want_fillmode = MAN_fi;
                           /* FALLTHROUGH */
                   case MAN_PP:  /* These have no head.            */
                   case MAN_LP:  /* They will simply               */
                   case MAN_P:   /* reopen .nf in the body.        */
                   case MAN_RS:
                   case MAN_UR:
                           fillmode(h, MAN_fi);
                           break;
                   default:
                           break;
                 }                  }
                 if (mh->nofill == NULL &&                  break;
           case ROFFT_TBL:
                   fillmode(h, MAN_fi);
                   break;
           case ROFFT_ELEM:
                   /*
                    * Some in-line macros produce tags and/or text
                    * in the handler, so they require fill mode to be
                    * configured up front just like for text nodes.
                    * For the others, keep the traditional approach
                    * of doing the same, for now.
                    */
                   fillmode(h, want_fillmode);
                   break;
           case ROFFT_TEXT:
                   if (fillmode(h, want_fillmode) == MAN_fi &&
                       want_fillmode == MAN_fi &&
                     n->flags & NODE_LINE && *n->string == ' ')                      n->flags & NODE_LINE && *n->string == ' ')
                         print_otag(h, TAG_BR, "");                          print_otag(h, TAG_BR, "");
                   if (*n->string != '\0')
                           break;
                   print_paragraph(h);
                   return;
           default:
                   break;
           }
   
           /* Produce output for this node. */
   
           child = 1;
           switch (n->type) {
           case ROFFT_TEXT:
                   t = h->tag;
                 print_text(h, n->string);                  print_text(h, n->string);
                 break;                  break;
         case ROFFT_EQN:          case ROFFT_EQN:
                   t = h->tag;
                 print_eqn(h, n->eqn);                  print_eqn(h, n->eqn);
                 break;                  break;
         case ROFFT_TBL:          case ROFFT_TBL:
Line 238  print_man_node(MAN_ARGS)
Line 300  print_man_node(MAN_ARGS)
                  * the "meta" table state.  This will be reopened on the                   * the "meta" table state.  This will be reopened on the
                  * next table element.                   * next table element.
                  */                   */
                 if (h->tblt) {                  if (h->tblt)
                         print_tblclose(h);                          print_tblclose(h);
                         t = h->tag;  
                 }                  t = h->tag;
                 if (mans[n->tok].pre)                  if (mans[n->tok].pre)
                         child = (*mans[n->tok].pre)(man, n, mh, h);                          child = (*mans[n->tok].pre)(man, n, h);
   
                   /* Some block macros resume .nf in the body. */
                   if (save_fillmode && n->type == ROFFT_BODY)
                           want_fillmode = save_fillmode;
   
                 break;                  break;
         }          }
   
         if (child && n->child)          if (child && n->child)
                 print_man_nodelist(man, n->child, mh, h);                  print_man_nodelist(man, n->child, h);
   
         /* This will automatically close out any font scope. */          /* This will automatically close out any font scope. */
         print_stagq(h, mh->nofill == NULL ? t : mh->nofill);          print_stagq(h, t);
   
         if (n->type != ROFFT_TEXT && n->type != ROFFT_EQN &&          if (fillmode(h, 0) == MAN_nf &&
             mans[n->tok].post != NULL)              n->next != NULL && n->next->flags & NODE_LINE)
                 (*mans[n->tok].post)(man, n, mh, h);  
   
         if (mh->nofill != NULL &&  
             (n->next == NULL || n->next->flags & NODE_LINE))  
                 print_endline(h);                  print_endline(h);
 }  }
   
   /*
    * MAN_nf switches to no-fill mode, MAN_fi to fill mode.
    * Other arguments do not switch.
    * The old mode is returned.
    */
 static int  static int
   fillmode(struct html *h, int want)
   {
           struct tag      *pre;
           int              had;
   
           for (pre = h->tag; pre != NULL; pre = pre->next)
                   if (pre->tag == TAG_PRE)
                           break;
   
           had = pre == NULL ? MAN_fi : MAN_nf;
   
           if (want && want != had) {
                   if (want == MAN_nf)
                           print_otag(h, TAG_PRE, "");
                   else
                           print_tagq(h, pre);
           }
           return had;
   }
   
   static int
 a2width(const struct roff_node *n, struct roffsu *su)  a2width(const struct roff_node *n, struct roffsu *su)
 {  {
   
Line 347  man_br_pre(MAN_ARGS)
Line 436  man_br_pre(MAN_ARGS)
 static int  static int
 man_SH_pre(MAN_ARGS)  man_SH_pre(MAN_ARGS)
 {  {
         if (n->type == ROFFT_BLOCK && mh->nofill != NULL) {          if (n->type == ROFFT_HEAD)
                 print_tagq(h, mh->nofill);  
                 mh->nofill = NULL;  
         } else if (n->type == ROFFT_HEAD)  
                 print_otag(h, TAG_H1, "c", "Sh");                  print_otag(h, TAG_H1, "c", "Sh");
         return 1;          return 1;
 }  }
Line 413  man_SM_pre(MAN_ARGS)
Line 499  man_SM_pre(MAN_ARGS)
 static int  static int
 man_SS_pre(MAN_ARGS)  man_SS_pre(MAN_ARGS)
 {  {
         if (n->type == ROFFT_BLOCK && mh->nofill != NULL) {          if (n->type == ROFFT_HEAD)
                 print_tagq(h, mh->nofill);  
                 mh->nofill = NULL;  
         } else if (n->type == ROFFT_HEAD)  
                 print_otag(h, TAG_H2, "c", "Ss");                  print_otag(h, TAG_H2, "c", "Ss");
         return 1;          return 1;
 }  }
Line 453  man_IP_pre(MAN_ARGS)
Line 536  man_IP_pre(MAN_ARGS)
         /* For IP, only print the first header element. */          /* For IP, only print the first header element. */
   
         if (MAN_IP == n->tok && n->child)          if (MAN_IP == n->tok && n->child)
                 print_man_node(man, n->child, mh, h);                  print_man_node(man, n->child, h);
   
         /* For TP, only print next-line header elements. */          /* For TP, only print next-line header elements. */
   
Line 462  man_IP_pre(MAN_ARGS)
Line 545  man_IP_pre(MAN_ARGS)
                 while (NULL != nn && 0 == (NODE_LINE & nn->flags))                  while (NULL != nn && 0 == (NODE_LINE & nn->flags))
                         nn = nn->next;                          nn = nn->next;
                 while (NULL != nn) {                  while (NULL != nn) {
                         print_man_node(man, nn, mh, h);                          print_man_node(man, nn, h);
                         nn = nn->next;                          nn = nn->next;
                 }                  }
         }          }
Line 536  man_I_pre(MAN_ARGS)
Line 619  man_I_pre(MAN_ARGS)
 }  }
   
 static int  static int
 man_fill_pre(MAN_ARGS)  
 {  
         if (MAN_fi == n->tok || MAN_EE == n->tok) {  
                 if (mh->nofill != NULL) {  
                         print_tagq(h, mh->nofill);  
                         mh->nofill = NULL;  
                 } else  
                         print_otag(h, TAG_BR, "");  
         } else {  
                 if (mh->nofill == NULL)  
                         mh->nofill = print_otag(h, TAG_PRE, "");  
                 else  
                         print_otag(h, TAG_BR, "");  
         }  
         return 0;  
 }  
   
 static int  
 man_in_pre(MAN_ARGS)  man_in_pre(MAN_ARGS)
 {  {
         print_otag(h, TAG_BR, "");          print_otag(h, TAG_BR, "");
Line 599  man_UR_pre(MAN_ARGS)
Line 664  man_UR_pre(MAN_ARGS)
         if (n->next->child != NULL)          if (n->next->child != NULL)
                 n = n->next;                  n = n->next;
   
         print_man_nodelist(man, n->child, mh, h);          print_man_nodelist(man, n->child, h);
   
         return 0;          return 0;
 }  }
Legend:
Removed from v.1.131  
changed lines
  Added in v.1.132
CVSweb