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

Diff for /mandoc/html.c between version 1.73 and 1.86

version 1.73, 2009/10/30 18:50:11 version 1.86, 2009/11/14 12:00:24
Line 18 
Line 18 
   
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
 #include <err.h>  
 #include <stdio.h>  
 #include <stdarg.h>  #include <stdarg.h>
   #include <stdio.h>
 #include <stdint.h>  #include <stdint.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
Line 67  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 htmlattrs[ATTR_MAX] = {
         "http-equiv",          "http-equiv",
         "content",          "content",
         "name",          "name",
Line 88  static const char  *const htmlattrs[ATTR_MAX] = {
Line 87  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 *);
   
   
 void *  void *
 html_alloc(char *outopts)  html_alloc(char *outopts)
 {  {
Line 102  html_alloc(char *outopts)
Line 108  html_alloc(char *outopts)
   
         h = calloc(1, sizeof(struct html));          h = calloc(1, sizeof(struct html));
         if (NULL == h) {          if (NULL == h) {
                 fprintf(stderr, "memory exhausted\n");                  perror(NULL);
                 exit(EXIT_FAILURE);                  exit(EXIT_FAILURE);
         }          }
   
Line 187  print_gen_head(struct html *h)
Line 193  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;
         int              i;  
         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;
         for (i = 0; i < (int)sz; i++)          fwrite(rhs, 1, sz, stdout);
                 putchar(rhs[i]);  
 }  }
   
   
 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;
         int              i;  
         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;
         for (i = 0; i < (int)sz; i++)          fwrite(rhs, 1, sz, stdout);
                 putchar(rhs[i]);  
 }  }
   
   
 static void  static int
 print_escape(struct html *h, const char **p)  print_encode(struct html *h, const char *p)
 {  {
         int              j, type;          size_t           sz;
         const char      *wp;          int              len, nospace;
           const char      *seq;
           enum roffdeco    deco;
   
         wp = *p;          nospace = 0;
         type = 1;  
   
         if (0 == *(++wp)) {          for (; *p; p++) {
                 *p = wp;                  sz = strcspn(p, "\\<>&");
                 return;  
         }  
   
         if ('(' == *wp) {                  fwrite(p, 1, sz, stdout);
                 wp++;                  p += /* LINTED */
                 if (0 == *wp || 0 == *(wp + 1)) {                          sz;
                         *p = 0 == *wp ? wp : wp + 1;  
                         return;  
                 }  
   
                 print_spec(h, wp, 2);                  if ('<' == *p) {
                 *p = ++wp;                          printf("&lt;");
                 return;                          continue;
                   } else if ('>' == *p) {
                           printf("&gt;");
                           continue;
                   } else if ('&' == *p) {
                           printf("&amp;");
                           continue;
                   } else if ('\0' == *p)
                           break;
   
         } else if ('*' == *wp) {                  seq = ++p;
                 if (0 == *(++wp)) {                  len = a2roffdeco(&deco, &seq, &sz);
                         *p = wp;  
                         return;  
                 }  
   
                 switch (*wp) {                  switch (deco) {
                 case ('('):                  case (DECO_RESERVED):
                         wp++;                          print_res(h, seq, sz);
                         if (0 == *wp || 0 == *(wp + 1)) {  
                                 *p = 0 == *wp ? wp : wp + 1;  
                                 return;  
                         }  
   
                         print_res(h, wp, 2);  
                         *p = ++wp;  
                         return;  
                 case ('['):  
                         type = 0;  
                         break;                          break;
                 default:                  case (DECO_SPECIAL):
                         print_res(h, wp, 1);                          print_spec(h, seq, sz);
                         *p = wp;  
                         return;  
                 }  
   
         } else if ('f' == *wp) {  
                 if (0 == *(++wp)) {  
                         *p = wp;  
                         return;  
                 }  
   
                 switch (*wp) {  
                 case ('B'):  
                         /* TODO */  
                         break;                          break;
                 case ('I'):  
                         /* TODO */  
                         break;  
                 case ('P'):  
                         /* FALLTHROUGH */  
                 case ('R'):  
                         /* TODO */  
                         break;  
                 default:                  default:
                         break;                          break;
                 }                  }
   
                 *p = wp;                  p += len - 1;
                 return;  
   
         } else if ('[' != *wp) {                  if (DECO_NOSPACE == deco && '\0' == *(p + 1))
                 print_spec(h, wp, 1);                          nospace = 1;
                 *p = wp;  
                 return;  
         }          }
   
         wp++;          return(nospace);
         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  
 print_encode(struct html *h, const char *p)  
 {  
   
         for (; *p; p++) {  
                 if ('\\' == *p) {  
                         print_escape(h, &p);  
                         continue;  
                 }  
                 switch (*p) {  
                 case ('<'):  
                         printf("&lt;");  
                         break;  
                 case ('>'):  
                         printf("&gt;");  
                         break;  
                 case ('&'):  
                         printf("&amp;");  
                         break;  
                 default:  
                         putchar(*p);  
                         break;  
                 }  
         }  
 }  
   
   
 struct tag *  struct tag *
 print_otag(struct html *h, enum htmltag tag,  print_otag(struct html *h, enum htmltag tag,
                 int sz, const struct htmlpair *p)                  int sz, const struct htmlpair *p)
Line 355  print_otag(struct html *h, enum htmltag tag, 
Line 283  print_otag(struct html *h, enum htmltag tag, 
         if ( ! (HTML_NOSTACK & htmltags[tag].flags)) {          if ( ! (HTML_NOSTACK & htmltags[tag].flags)) {
                 t = malloc(sizeof(struct tag));                  t = malloc(sizeof(struct tag));
                 if (NULL == t) {                  if (NULL == t) {
                         fprintf(stderr, "memory exhausted\n");                          perror(NULL);
                         exit(EXIT_FAILURE);                          exit(EXIT_FAILURE);
                 }                  }
                 t->tag = tag;                  t->tag = tag;
Line 366  print_otag(struct html *h, enum htmltag tag, 
Line 294  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);
                 printf("\"");                  putchar('\"');
         }          }
         printf(">");          putchar('>');
   
         h->flags |= HTML_NOSPACE;          h->flags |= HTML_NOSPACE;
         if (HTML_CLRLINE & htmltags[tag].flags)          if (HTML_CLRLINE & htmltags[tag].flags)
Line 396  print_ctag(struct html *h, enum htmltag tag)
Line 324  print_ctag(struct html *h, enum htmltag tag)
         if (HTML_CLRLINE & htmltags[tag].flags) {          if (HTML_CLRLINE & htmltags[tag].flags) {
                 h->flags |= HTML_NOSPACE;                  h->flags |= HTML_NOSPACE;
                 h->flags |= HTML_NEWLINE;                  h->flags |= HTML_NEWLINE;
                 printf("\n");                  putchar('\n');
         } else          } else
                 h->flags &= ~HTML_NEWLINE;                  h->flags &= ~HTML_NEWLINE;
 }  }
Line 442  print_text(struct html *h, const char *p)
Line 370  print_text(struct html *h, const char *p)
                 }                  }
   
         if ( ! (h->flags & HTML_NOSPACE))          if ( ! (h->flags & HTML_NOSPACE))
                 printf(" ");                  putchar(' ');
   
         h->flags &= ~HTML_NOSPACE;  
         h->flags &= ~HTML_NEWLINE;          h->flags &= ~HTML_NEWLINE;
   
         if (p)          assert(p);
                 print_encode(h, p);          if ( ! print_encode(h, p))
                   h->flags &= ~HTML_NOSPACE;
   
         if (*p && 0 == *(p + 1))          if (*p && 0 == *(p + 1))
                 switch (*p) {                  switch (*p) {
Legend:
Removed from v.1.73  
changed lines
  Added in v.1.86
CVSweb