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

Diff for /mandoc/html.c between version 1.76 and 1.91

version 1.76, 2009/11/01 07:44:32 version 1.91, 2009/11/16 08:46:58
Line 66  static const struct htmldata htmltags[TAG_MAX] = {
Line 66  static const struct htmldata htmltags[TAG_MAX] = {
         {"base",        HTML_CLRLINE | HTML_NOSTACK}, /* TAG_BASE */          {"base",        HTML_CLRLINE | HTML_NOSTACK}, /* TAG_BASE */
 };  };
   
 static  const char       *const htmlattrs[ATTR_MAX] = {  static  const char      *const htmlfonts[HTMLFONT_MAX] = {
           "roman",
           "bold",
           "italic"
   };
   
   static  const char      *const htmlattrs[ATTR_MAX] = {
         "http-equiv",          "http-equiv",
         "content",          "content",
         "name",          "name",
Line 87  static const char  *const htmlattrs[ATTR_MAX] = {
Line 93  static const char  *const htmlattrs[ATTR_MAX] = {
 extern  int               getsubopt(char **, char * const *, char **);  extern  int               getsubopt(char **, char * const *, char **);
 #endif  #endif
   
   
   static  void              print_spec(struct html *, const char *, size_t);
   static  void              print_res(struct html *, const char *, size_t);
   static  void              print_ctag(struct html *, enum htmltag);
   static  int               print_encode(struct html *, const char *, int);
   static  void              print_metaf(struct html *, enum roffdeco);
   
   
 void *  void *
 html_alloc(char *outopts)  html_alloc(char *outopts)
 {  {
Line 186  print_gen_head(struct html *h)
Line 200  print_gen_head(struct html *h)
   
   
 static void  static void
 print_spec(struct html *h, const char *p, int len)  print_spec(struct html *h, const char *p, size_t len)
 {  {
         const char      *rhs;          const char      *rhs;
         size_t           sz;          size_t           sz;
   
         rhs = chars_a2ascii(h->symtab, p, (size_t)len, &sz);          rhs = chars_a2ascii(h->symtab, p, len, &sz);
   
         if (NULL == rhs)          if (NULL == rhs)
                 return;                  return;
Line 200  print_spec(struct html *h, const char *p, int len)
Line 214  print_spec(struct html *h, const char *p, int len)
   
   
 static void  static void
 print_res(struct html *h, const char *p, int len)  print_res(struct html *h, const char *p, size_t len)
 {  {
         const char      *rhs;          const char      *rhs;
         size_t           sz;          size_t           sz;
   
         rhs = chars_a2res(h->symtab, p, (size_t)len, &sz);          rhs = chars_a2res(h->symtab, p, len, &sz);
   
         if (NULL == rhs)          if (NULL == rhs)
                 return;                  return;
Line 213  print_res(struct html *h, const char *p, int len)
Line 227  print_res(struct html *h, const char *p, int len)
 }  }
   
   
 static void  struct tag *
 print_escape(struct html *h, const char **p)  print_ofont(struct html *h, enum htmlfont font)
 {  {
         int              j, type;          struct htmlpair  tag;
         const char      *wp;  
   
         wp = *p;          h->metal = h->metac;
         type = 1;          h->metac = font;
   
         if (0 == *(++wp)) {          /* FIXME: DECO_ROMAN should just close out preexisting. */
                 *p = wp;  
                 return;  
         }  
   
         if ('(' == *wp) {          if (h->metaf && h->tags.head == h->metaf)
                 wp++;                  print_tagq(h, h->metaf);
                 if (0 == *wp || 0 == *(wp + 1)) {  
                         *p = 0 == *wp ? wp : wp + 1;  
                         return;  
                 }  
   
                 print_spec(h, wp, 2);          PAIR_CLASS_INIT(&tag, htmlfonts[font]);
                 *p = ++wp;          h->metaf = print_otag(h, TAG_SPAN, 1, &tag);
                 return;          return(h->metaf);
   }
   
         } else if ('*' == *wp) {  
                 if (0 == *(++wp)) {  
                         *p = wp;  
                         return;  
                 }  
   
                 switch (*wp) {  static void
                 case ('('):  print_metaf(struct html *h, enum roffdeco deco)
                         wp++;  {
                         if (0 == *wp || 0 == *(wp + 1)) {          enum htmlfont    font;
                                 *p = 0 == *wp ? wp : wp + 1;  
                                 return;  
                         }  
   
                         print_res(h, wp, 2);          switch (deco) {
                         *p = ++wp;          case (DECO_PREVIOUS):
                         return;                  font = h->metal;
                 case ('['):                  break;
                         type = 0;          case (DECO_ITALIC):
                         break;                  font = HTMLFONT_ITALIC;
                 default:                  break;
                         print_res(h, wp, 1);          case (DECO_BOLD):
                         *p = wp;                  font = HTMLFONT_BOLD;
                         return;                  break;
                 }          case (DECO_ROMAN):
                   font = HTMLFONT_NONE;
         } else if ('f' == *wp) {                  break;
                 if (0 == *(++wp)) {          default:
                         *p = wp;                  abort();
                         return;                  /* NOTREACHED */
                 }  
   
                 switch (*wp) {  
                 case ('B'):  
                         /* TODO */  
                         break;  
                 case ('I'):  
                         /* TODO */  
                         break;  
                 case ('P'):  
                         /* FALLTHROUGH */  
                 case ('R'):  
                         /* TODO */  
                         break;  
                 default:  
                         break;  
                 }  
   
                 *p = wp;  
                 return;  
   
         } else if ('[' != *wp) {  
                 print_spec(h, wp, 1);  
                 *p = wp;  
                 return;  
         }          }
   
         wp++;          (void)print_ofont(h, font);
         for (j = 0; *wp && ']' != *wp; wp++, j++)  
                 /* Loop... */ ;  
   
         if (0 == *wp) {  
                 *p = wp;  
                 return;  
         }  
   
         if (type)  
                 print_spec(h, wp - j, j);  
         else  
                 print_res(h, wp - j, j);  
   
         *p = wp;  
 }  }
   
   
 static void  static int
 print_encode(struct html *h, const char *p)  print_encode(struct html *h, const char *p, int norecurse)
 {  {
           size_t           sz;
           int              len, nospace;
           const char      *seq;
           enum roffdeco    deco;
   
           nospace = 0;
   
         for (; *p; p++) {          for (; *p; p++) {
                 if ('\\' == *p) {                  sz = strcspn(p, "\\<>&");
                         print_escape(h, &p);  
                         continue;                  fwrite(p, 1, sz, stdout);
                 }                  p += /* LINTED */
                 switch (*p) {                          sz;
                 case ('<'):  
                   if ('<' == *p) {
                         printf("&lt;");                          printf("&lt;");
                         break;                          continue;
                 case ('>'):                  } else if ('>' == *p) {
                         printf("&gt;");                          printf("&gt;");
                         break;                          continue;
                 case ('&'):                  } else if ('&' == *p) {
                         printf("&amp;");                          printf("&amp;");
                           continue;
                   } else if ('\0' == *p)
                         break;                          break;
   
                   seq = ++p;
                   len = a2roffdeco(&deco, &seq, &sz);
   
                   switch (deco) {
                   case (DECO_RESERVED):
                           print_res(h, seq, sz);
                           break;
                   case (DECO_SPECIAL):
                           print_spec(h, seq, sz);
                           break;
                   case (DECO_PREVIOUS):
                           /* FALLTHROUGH */
                   case (DECO_BOLD):
                           /* FALLTHROUGH */
                   case (DECO_ITALIC):
                           /* FALLTHROUGH */
                   case (DECO_ROMAN):
                           if (norecurse)
                                   break;
                           print_metaf(h, deco);
                           break;
                 default:                  default:
                         putchar(*p);  
                         break;                          break;
                 }                  }
   
                   p += len - 1;
   
                   if (DECO_NOSPACE == deco && '\0' == *(p + 1))
                           nospace = 1;
         }          }
   
           return(nospace);
 }  }
   
   
Line 361  print_otag(struct html *h, enum htmltag tag, 
Line 358  print_otag(struct html *h, enum htmltag tag, 
   
         if ( ! (HTML_NOSPACE & h->flags))          if ( ! (HTML_NOSPACE & h->flags))
                 if ( ! (HTML_CLRLINE & htmltags[tag].flags))                  if ( ! (HTML_CLRLINE & htmltags[tag].flags))
                         printf(" ");                          putchar(' ');
   
         printf("<%s", htmltags[tag].name);          printf("<%s", htmltags[tag].name);
         for (i = 0; i < sz; i++) {          for (i = 0; i < sz; i++) {
                 printf(" %s=\"", htmlattrs[p[i].key]);                  printf(" %s=\"", htmlattrs[p[i].key]);
                 assert(p->val);                  assert(p->val);
                 print_encode(h, p[i].val);                  (void)print_encode(h, p[i].val, 1);
                 printf("\"");                  putchar('\"');
         }          }
         printf(">");          putchar('>');
   
         h->flags |= HTML_NOSPACE;          h->flags |= HTML_NOSPACE;
         if (HTML_CLRLINE & htmltags[tag].flags)  
                 h->flags |= HTML_NEWLINE;  
         else  
                 h->flags &= ~HTML_NEWLINE;  
   
         return(t);          return(t);
 }  }
   
   
 /* ARGSUSED */  
 static void  static void
 print_ctag(struct html *h, enum htmltag tag)  print_ctag(struct html *h, enum htmltag tag)
 {  {
Line 390  print_ctag(struct html *h, enum htmltag tag)
Line 381  print_ctag(struct html *h, enum htmltag tag)
         printf("</%s>", htmltags[tag].name);          printf("</%s>", htmltags[tag].name);
         if (HTML_CLRLINE & htmltags[tag].flags) {          if (HTML_CLRLINE & htmltags[tag].flags) {
                 h->flags |= HTML_NOSPACE;                  h->flags |= HTML_NOSPACE;
                 h->flags |= HTML_NEWLINE;                  putchar('\n');
                 printf("\n");          }
         } else  
                 h->flags &= ~HTML_NEWLINE;  
 }  }
   
   
Line 437  print_text(struct html *h, const char *p)
Line 426  print_text(struct html *h, const char *p)
                 }                  }
   
         if ( ! (h->flags & HTML_NOSPACE))          if ( ! (h->flags & HTML_NOSPACE))
                 printf(" ");                  putchar(' ');
   
         h->flags &= ~HTML_NOSPACE;          assert(p);
         h->flags &= ~HTML_NEWLINE;          if ( ! print_encode(h, p, 0))
                   h->flags &= ~HTML_NOSPACE;
   
         if (p)  
                 print_encode(h, p);  
   
         if (*p && 0 == *(p + 1))          if (*p && 0 == *(p + 1))
                 switch (*p) {                  switch (*p) {
                 case('('):                  case('('):
Line 466  print_tagq(struct html *h, const struct tag *until)
Line 453  print_tagq(struct html *h, const struct tag *until)
         struct tag      *tag;          struct tag      *tag;
   
         while ((tag = h->tags.head) != NULL) {          while ((tag = h->tags.head) != NULL) {
                   if (tag == h->metaf)
                           h->metaf = NULL;
                 print_ctag(h, tag->tag);                  print_ctag(h, tag->tag);
                 h->tags.head = tag->next;                  h->tags.head = tag->next;
                 free(tag);                  free(tag);
Line 483  print_stagq(struct html *h, const struct tag *suntil)
Line 472  print_stagq(struct html *h, const struct tag *suntil)
         while ((tag = h->tags.head) != NULL) {          while ((tag = h->tags.head) != NULL) {
                 if (suntil && tag == suntil)                  if (suntil && tag == suntil)
                         return;                          return;
                   if (tag == h->metaf)
                           h->metaf = NULL;
                 print_ctag(h, tag->tag);                  print_ctag(h, tag->tag);
                 h->tags.head = tag->next;                  h->tags.head = tag->next;
                 free(tag);                  free(tag);
Legend:
Removed from v.1.76  
changed lines
  Added in v.1.91
CVSweb