Ticket #7550: htmlencode.patch.txt

*** hdrs/ansi.h.orig    Fri Oct  5 23:36:32 2007
--- hdrs/ansi.h Mon Jan 28 21:54:50 2008
***************
*** 185,188 ****
--- 185,190 ----
      int safe_tag_wrap(char const *a_tag, char const *params,
                        char const *data, char *buf, char **bp, dbref player);
  
+ 
+ char * decompose_to_html(char *what);
  #endif                          /* __ANSI_H */
*** src/function.c.orig Fri Oct  5 23:36:32 2007
--- src/function.c  Mon Jan 28 21:01:39 2008
***************
*** 785,790 ****
--- 785,791 ----
    {"TAG", fun_tag, 1, INT_MAX, FN_REG},
    {"ENDTAG", fun_endtag, 1, 1, FN_REG},
    {"TAGWRAP", fun_tagwrap, 2, 3, FN_REG},
+   {"HTMLENCODE", fun_htmlencode, 1, -1, FN_REG},
    {NULL, NULL, 0, 0, 0}
  };
  
*** src/funstr.c.orig   Fri Oct  5 23:36:32 2007
--- src/funstr.c    Mon Jan 28 21:55:47 2008
***************
*** 1469,1474 ****
--- 1469,1488 ----
    }
  }
  
+ FUNCTION(fun_htmlencode)
+ {
+   /*
+   int n;
+   for (n = 0; n < arglens[0]; n++) {
+       if(accent_table[(unsigned char) args[0][n]].base)
+           safe_str(accent_table[(unsigned char) args[0][n]].entity, buff, bp);
+       else
+           safe_chr(args[0][n], buff, bp);
+   }
+   */
+   safe_str(decompose_to_html(args[0]), buff, bp);
+ }
+ 
  /* ARGSUSED */
  FUNCTION(fun_edit)
  {
*** src/markup.c.orig   Fri Oct  5 23:36:32 2007
--- src/markup.c    Mon Jan 28 22:30:59 2008
***************
*** 60,65 ****
--- 60,67 ----
   safe_markup_cancel(char const *a_tag, char *buf, char **bp, char type);
  static int compare_starts(const void *a, const void *b);
  static int escape_marked_str(char **str, char *buff, char **bp);
+ static int escape_marked_str_to_html(char **str, char *buff, char **bp);
+ static int real_decompose_to_html(char *orig, char *buff, char **bp);
  
  const char *is_allowed_tag(const char *s, unsigned int len);
  
***************
*** 1897,1902 ****
--- 1899,1960 ----
    return retval;
  }
  
+ static int
+ escape_marked_str_to_html(char **str, char *buff, char **bp)
+ {
+   unsigned char *in;
+   int retval = 0;
+   int dospace = 1;
+   int spaces = 0;
+   int i;
+ 
+   if (!str || !*str || !**str)
+     return 0;
+   in = (unsigned char *) *str;
+   for (; *in && *in != ESC_CHAR && *in != TAG_START; in++) {
+     if (*in == ' ') {
+       spaces++;
+     } else {
+       if (spaces) {
+         if (dospace) {
+             spaces--;
+             retval += safe_str("&nbsp;", buff, bp);
+           }
+           while (spaces) {
+             retval += safe_chr(' ', buff, bp);
+             if (--spaces) {
+               --spaces;
+               retval += safe_str("&nbsp;", buff, bp);
+             }
+           }
+       }
+       spaces = 0;
+       dospace = 0;
+       if(accent_table[(unsigned char) *in].base)
+               safe_str(accent_table[(unsigned char) *in].entity, buff, bp);
+           else
+           safe_chr(*in, buff, bp);
+     }
+   }
+   if (spaces) {
+     spaces--;                 /* This is for the final %b space */
+       if (spaces && dospace) {
+         spaces--;
+         retval += safe_str("&nbsp;", buff, bp);
+       }
+       while (spaces) {
+         safe_chr(' ', buff, bp);
+         if (--spaces) {
+           --spaces;
+           retval += safe_str("&nbsp;", buff, bp);
+         }
+       }
+       retval += safe_str("&nbsp;", buff, bp);
+   }
+   *str = (char *) in;
+   return retval;
+ }
+ 
  /* Does the work of decompose_str, which is found in look.c.
   * Even handles ANSI and Pueblo, which is why it's so ugly.
   * Code based off of real_parse_ansi_string, not safe_ansi_string.
***************
*** 2093,2098 ****
--- 2151,2415 ----
    return retval;
  }
  
+ char *
+ decompose_to_html(char *what)
+ {
+   static char value[BUFFER_LEN];
+   char *vp = value;
+ 
+   real_decompose_to_html(what, value, &vp);
+   *vp = '\0';
+ 
+   return value;
+ }
+ 
+ static int
+ real_decompose_to_html(char *orig, char *buff, char **bp)
+ {
+   int i;
+   char *str = orig;
+   char *tmp;
+   char *pstr;
+   char type;
+ 
+   ansi_data ansistack[BUFFER_LEN];
+   ansistack[0] = ansi_null;
+   ansi_data oldansi;
+   ansi_data tmpansi;
+   int ansitop = 0;
+   int ansiheight = 0;
+   int howmanyopen = 0;
+   int oldcodes = 0;
+   int underline = 0, bold = 0;
+ 
+   char *pueblostack[BUFFER_LEN];
+   char tagbuff[BUFFER_LEN];
+   int pueblotop = -1;
+ 
+   int retval = 0;
+ 
+   if (!str || !*str)
+     return 0;
+ 
+   retval += escape_marked_str_to_html(&str, buff, bp);
+ 
+   while (str && *str && *str != '\0') {
+     oldansi = ansistack[ansitop];
+     ansiheight = ansitop;
+     while (*str == TAG_START || *str == ESC_CHAR) {
+       switch (*str) {
+       case TAG_START:
+         for (tmp = str; *tmp && *tmp != TAG_END; tmp++) ;
+         if (*tmp) {
+           *tmp = '\0';
+         } else {
+           tmp--;
+         }
+         str++;
+         type = *(str++);
+         switch (type) {
+         case MARKUP_COLOR:
+           if (!*str)
+             break;
+           if (oldcodes == 1) {
+             ansitop--;
+             oldcodes = 0;
+           }
+           /* Start or end tag? */
+           if (*str != '/') {
+             define_ansi_data(&tmpansi, str);
+             nest_ansi_data(&(ansistack[ansitop]), &tmpansi);
+             ansitop++;
+             ansistack[ansitop] = tmpansi;
+           } else {
+             if (*(str + 1) == 'a') {
+               ansitop = 0;
+             } else {
+               if (ansitop > 0) {
+                 ansitop--;
+               }
+             }
+           }
+           break;
+         case MARKUP_HTML:
+           if (!*str)
+             break;
+           if (*str != '/') {
+             pueblotop++;
+             snprintf(tagbuff, BUFFER_LEN, "%s", parse_tagname(str));
+             pueblostack[pueblotop] = mush_strdup(tagbuff, "markup_code");
+ 
+             retval += safe_chr('<', buff, bp);
+             retval += safe_str(tagbuff, buff, bp);
+             retval += safe_chr(' ', buff, bp);
+             str += strlen(tagbuff);
+             if (str && *str) {
+               while (str && str != tmp) {
+                 str++;
+                 pstr = strchr(str, '=');
+                 if (pstr) {
+                   *pstr = '\0';
+                   retval += safe_str(str, buff, bp);
+                   retval += safe_chr('=', buff, bp);
+                   str = pstr + 1;
+                   pstr = strchr(str, '\"');
+ 
+                   retval += safe_chr('\"', buff, bp);
+                   if (str == pstr) {
+                     str++;
+                     pstr = strchr(str, '\"');
+                   } else {
+                     pstr = strchr(str, ' ');
+                   }
+ 
+                   if (!pstr)
+                     pstr = tmp;
+ 
+                   *pstr = '\0';
+                   retval += safe_str(str, buff, bp);
+                   retval += safe_chr('\"', buff, bp);
+                   str = pstr;
+                 } else {
+                   safe_str(str, buff, bp);
+                   break;
+                 }
+               }
+             }
+             retval += safe_chr('>', buff, bp);
+ 
+           } else {
+             if (pueblotop > -1) {
+               i = (*(str + 1) == 'a') ? 0 : pueblotop;
+               for (i--; pueblotop > i; pueblotop--) {
+                 retval += safe_str("</", buff, bp);
+                 retval += safe_str(pueblostack[pueblotop], buff, bp);
+                 retval += safe_chr('>', buff, bp);
+                 mush_free(pueblostack[pueblotop], "markup_code");
+               }
+             }
+           }
+           break;
+         }
+         tmp++;
+         str = tmp;
+         break;
+       case ESC_CHAR:
+         /* It SHOULD be impossible to get here... */
+         for (tmp = str; *tmp && *tmp != 'm'; tmp++) ;
+ 
+         /* Store the "background" colors */
+         tmpansi = ansistack[ansitop];
+         if (oldcodes == 0) {
+           oldcodes = 1;
+           ansitop++;
+           ansistack[ansitop] = tmpansi;
+           ansistack[ansitop].offbits = 0;
+         }
+ 
+         read_raw_ansi_data(&tmpansi, str);
+         ansistack[ansitop].bits |= tmpansi.bits;
+         ansistack[ansitop].bits &= ~(tmpansi.offbits);  /* ANSI_RAW_NORMAL */
+         if (tmpansi.fore)
+           ansistack[ansitop].fore = tmpansi.fore;
+         if (tmpansi.back)
+           ansistack[ansitop].back = tmpansi.back;
+ 
+         str = tmp;
+         if (*tmp)
+           str++;
+         break;
+       }
+     }
+ 
+     /* Handle ANSI/Text */
+     tmpansi = ansistack[ansitop];
+     if (ansitop > 0 || ansiheight > 0) {
+       /* Close existing tags as necessary to cleanly open the next. */
+       /*  oldansi = ansistack[ansiheight]; */
+       if (!ansi_equal(oldansi, tmpansi)) {
+         while (ansiheight > 0) {
+           if (howmanyopen > 0) {
+             howmanyopen--;
+             if (bold) {
+               bold--;
+               retval += safe_str("</b>", buff, bp);
+           }
+           if (underline) {
+               underline--;
+               retval += safe_str("</u>", buff, bp);
+           }
+             retval += safe_str("</font>", buff, bp);
+           }
+           ansiheight--;
+         }
+       }
+       if (!ansi_isnull(tmpansi) && !ansi_equal(oldansi, tmpansi)) {
+         if (tmpansi.fore == 'n' || tmpansi.fore == 'd') {
+           } else {
+           retval += safe_str("<font color=\"", buff, bp);
+             switch (tmpansi.fore) {
+                 case 'r':
+                   retval += safe_str("red", buff, bp);
+                   break;
+                 case 'g':
+                   retval += safe_str("green", buff, bp);
+                   break;
+                 case 'b':
+                   retval += safe_str("blue", buff, bp);
+                   break;
+                 case 'c':
+                   retval += safe_str("cyan", buff, bp);
+                   break;
+                 case 'm':
+                   retval += safe_str("magenta", buff, bp);
+                   break;
+                 case 'y':
+                   retval += safe_str("yellow", buff, bp);
+                   break;
+                 case 'x':
+                   retval += safe_str("black", buff, bp);
+                   break;
+                 case 'w':
+                   retval += safe_str("white", buff, bp);
+                   break;
+                 default:
+                   break;
+             }
+             retval += safe_str("\">", buff, bp);
+               howmanyopen++;
+         }
+         #define CBIT_SET(x,y) (x.bits & y)
+         if (CBIT_SET(tmpansi, CBIT_HILITE)) {
+             retval += safe_str("<b>", buff, bp);
+             bold++;
+         }
+         if (CBIT_SET(tmpansi, CBIT_UNDERSCORE)) {
+             retval += safe_str("<u>", buff, bp);
+             underline++;
+         }
+         #undef CBIT_SET
+ 
+ 
+       }
+     }
+     retval += escape_marked_str_to_html(&str, buff, bp);
+   }
+ 
+   for (; underline > 0; underline--)
+     retval += safe_str("</u>", buff, bp);
+   for (; bold > 0; bold--)
+     retval += safe_str("</b>", buff, bp);
+   for (; howmanyopen > 0; howmanyopen--)
+     retval += safe_str("</font>", buff, bp);
+   for (; pueblotop > -1; pueblotop--) {
+     retval += safe_str("</", buff, bp);
+     retval += safe_str(pueblostack[pueblotop], buff, bp);
+     retval += safe_chr('>', buff, bp);
+   }
+ 
+   return retval;
+ }
+ 
  /** Our version of pcre_copy_substring, with ansi-safeness.
   * \param as the ansi_string whose .text value was matched against.
   * \param ovector the offset vectors