hamlit 1.7.2 → 2.0.1

data/ext/hamlit/houdini/houdini_js_u.c

@@ -0,0 +1,60 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+int
+houdini_unescape_js(gh_buf *ob, const uint8_t *src, size_t size)
+{
+	size_t  i = 0, org, ch;
+
+	while (i < size) {
+		org = i;
+		while (i < size && src[i] != '\\')
+			i++;
+
+		if (likely(i > org)) {
+			if (unlikely(org == 0)) {
+				if (i >= size)
+					return 0;
+
+				gh_buf_grow(ob, HOUDINI_UNESCAPED_SIZE(size));
+			}
+
+			gh_buf_put(ob, src + org, i - org);
+		}
+
+		/* escaping */
+		if (i == size)
+			break;
+
+		if (++i == size) {
+			gh_buf_putc(ob, '\\');
+			break;
+		}
+
+		ch = src[i];
+
+		switch (ch) {
+		case 'n':
+			ch = '\n';
+			/* pass through */
+
+		case '\\':
+		case '\'':
+		case '\"':
+		case '/':
+			gh_buf_putc(ob, ch);
+			i++;
+			break;
+
+		default:
+			gh_buf_putc(ob, '\\');
+			break;
+		}
+	}
+
+	return 1;
+}
+

data/ext/hamlit/houdini/houdini_uri_e.c

@@ -0,0 +1,107 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+static const char URL_SAFE[] = {
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 
+	0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 
+	0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static const char URI_SAFE[] = {
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 
+	0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static int
+escape(gh_buf *ob, const uint8_t *src, size_t size,
+	const char *safe_table, bool escape_plus)
+{
+	static const uint8_t hex_chars[] = "0123456789ABCDEF";
+
+	size_t  i = 0, org;
+	uint8_t hex_str[3];
+
+	hex_str[0] = '%';
+
+	while (i < size) {
+		org = i;
+		while (i < size && safe_table[src[i]] != 0)
+			i++;
+
+		if (likely(i > org)) {
+			if (unlikely(org == 0)) {
+				if (i >= size)
+					return 0;
+
+				gh_buf_grow(ob, HOUDINI_ESCAPED_SIZE(size));
+			}
+
+			gh_buf_put(ob, src + org, i - org);
+		}
+
+		/* escaping */
+		if (i >= size)
+			break;
+
+		if (src[i] == ' ' && escape_plus) {
+			gh_buf_putc(ob, '+');
+		} else {
+			hex_str[1] = hex_chars[(src[i] >> 4) & 0xF];
+			hex_str[2] = hex_chars[src[i] & 0xF];
+			gh_buf_put(ob, hex_str, 3);
+		}
+
+		i++;
+	}
+
+	return 1;
+}
+
+int
+houdini_escape_uri(gh_buf *ob, const uint8_t *src, size_t size)
+{
+	return escape(ob, src, size, URI_SAFE, false);
+}
+
+int
+houdini_escape_uri_component(gh_buf *ob, const uint8_t *src, size_t size)
+{
+	return escape(ob, src, size, URL_SAFE, false);
+}
+
+int
+houdini_escape_url(gh_buf *ob, const uint8_t *src, size_t size)
+{
+	return escape(ob, src, size, URL_SAFE, true);
+}
+

data/ext/hamlit/houdini/houdini_uri_u.c

@@ -0,0 +1,68 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+#define hex2c(c) ((c | 32) % 39 - 9)
+
+static int
+unescape(gh_buf *ob, const uint8_t *src, size_t size, bool unescape_plus)
+{
+	size_t  i = 0, org;
+
+	while (i < size) {
+		org = i;
+		while (i < size && src[i] != '%' && src[i] != '+')
+			i++;
+
+		if (likely(i > org)) {
+			if (unlikely(org == 0)) {
+				if (i >= size)
+					return 0;
+
+				gh_buf_grow(ob, HOUDINI_UNESCAPED_SIZE(size));
+			}
+
+			gh_buf_put(ob, src + org, i - org);
+		}
+
+		/* escaping */
+		if (i >= size)
+			break;
+
+		if (src[i++] == '+') {
+			gh_buf_putc(ob, unescape_plus ? ' ' : '+');
+			continue;
+		}
+
+		if (i + 1 < size && _isxdigit(src[i]) && _isxdigit(src[i + 1])) {
+			unsigned char new_char = (hex2c(src[i]) << 4) + hex2c(src[i + 1]);
+			gh_buf_putc(ob, new_char);
+			i += 2;
+		} else {
+			gh_buf_putc(ob, '%');
+		}
+	}
+
+	return 1;
+}
+
+int
+houdini_unescape_uri(gh_buf *ob, const uint8_t *src, size_t size)
+{
+	return unescape(ob, src, size, false);
+}
+
+int
+houdini_unescape_uri_component(gh_buf *ob, const uint8_t *src, size_t size)
+{
+	return unescape(ob, src, size, false);
+}
+
+int
+houdini_unescape_url(gh_buf *ob, const uint8_t *src, size_t size)
+{
+	return unescape(ob, src, size, true);
+}
+

data/ext/hamlit/houdini/houdini_xml_e.c

@@ -0,0 +1,136 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+/**
+ * & --> &amp;
+ * < --> &lt;
+ * > --> &gt;
+ * " --> &quot;
+ * ' --> &apos;
+ */
+static const char *LOOKUP_CODES[] = {
+	"", /* reserved: use literal single character */
+	"", /* unused */
+	"", /* reserved: 2 character UTF-8 */
+	"", /* reserved: 3 character UTF-8 */
+	"", /* reserved: 4 character UTF-8 */
+	"?", /* invalid UTF-8 character */
+	"&quot;",
+	"&amp;",
+	"&apos;",
+	"&lt;",
+	"&gt;"
+};
+
+static const char CODE_INVALID = 5;
+
+static const char XML_LOOKUP_TABLE[] = {
+	/* ASCII: 0xxxxxxx */
+	5, 5, 5, 5, 5, 5, 5, 5, 5, 0, 0, 5, 5, 0, 5, 5,
+	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+	0, 0, 6, 0, 0, 0, 7, 8, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0,10, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+
+	/* Invalid UTF-8 char start: 10xxxxxx */
+	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+
+	/* Multibyte UTF-8 */
+
+	/* 2 bytes: 110xxxxx */
+	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+
+	/* 3 bytes: 1110xxxx */
+	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+
+	/* 4 bytes: 11110xxx */
+	4, 4, 4, 4, 4, 4, 4, 4,
+
+	/* Invalid UTF-8: 11111xxx */
+	5, 5, 5, 5, 5, 5, 5, 5,
+};
+
+int
+houdini_escape_xml(gh_buf *ob, const uint8_t *src, size_t size)
+{
+	size_t i = 0;
+	unsigned char code = 0;
+
+	gh_buf_grow(ob, HOUDINI_ESCAPED_SIZE(size));
+
+	while (i < size) {
+		size_t start, end;
+
+		start = end = i;
+
+		while (i < size) {
+			unsigned int byte;
+
+			byte = src[i++];
+			code = XML_LOOKUP_TABLE[byte];
+
+			if (!code) {
+				/* single character used literally */
+			} else if (code >= CODE_INVALID) {
+				break; /* insert lookup code string */
+			} else if (code > size - end) {
+				code = CODE_INVALID; /* truncated UTF-8 character */
+				break;
+			} else {
+				unsigned int chr = byte & (0xff >> code);
+
+				while (--code) {
+					byte = src[i++];
+					if ((byte & 0xc0) != 0x80) {
+						code = CODE_INVALID;
+						break;
+					}
+					chr = (chr << 6) + (byte & 0x3f);
+				}
+
+				switch (i - end) {
+					case 2:
+						if (chr < 0x80)
+							code = CODE_INVALID;
+						break;
+					case 3:
+						if (chr < 0x800 ||
+						    (chr > 0xd7ff && chr < 0xe000) ||
+							chr > 0xfffd)
+							code = CODE_INVALID;
+						break;
+					case 4:
+						if (chr < 0x10000 || chr > 0x10ffff)
+							code = CODE_INVALID;
+						break;
+					default:
+						break;
+				}
+				if (code == CODE_INVALID)
+					break;
+			}
+			end = i;
+		}
+
+		if (end > start)
+			gh_buf_put(ob, src + start, end - start);
+
+		/* escaping */
+		if (end >= size)
+			break;
+
+		gh_buf_puts(ob, LOOKUP_CODES[code]);
+	}
+
+	return 1;
+}

data/ext/hamlit/houdini/html_unescape.gperf

@@ -0,0 +1,258 @@
+struct html_ent {
+	const char *entity;
+	unsigned char utf8_len;
+	unsigned char utf8[3];
+};
+%%
+"quot", 1, { 0x22 }
+"amp", 1, { 0x26 }
+"apos", 1, { 0x27 }
+"lt", 1, { 0x3C }
+"gt", 1, { 0x3E }
+"nbsp", 2, { 0xC2, 0xA0 }
+"iexcl", 2, { 0xC2, 0xA1 }
+"cent", 2, { 0xC2, 0xA2 }
+"pound", 2, { 0xC2, 0xA3 }
+"curren", 2, { 0xC2, 0xA4 }
+"yen", 2, { 0xC2, 0xA5 }
+"brvbar", 2, { 0xC2, 0xA6 }
+"sect", 2, { 0xC2, 0xA7 }
+"uml", 2, { 0xC2, 0xA8 }
+"copy", 2, { 0xC2, 0xA9 }
+"ordf", 2, { 0xC2, 0xAA }
+"laquo", 2, { 0xC2, 0xAB }
+"not", 2, { 0xC2, 0xAC }
+"shy", 2, { 0xC2, 0xAD }
+"reg", 2, { 0xC2, 0xAE }
+"macr", 2, { 0xC2, 0xAF }
+"deg", 2, { 0xC2, 0xB0 }
+"plusmn", 2, { 0xC2, 0xB1 }
+"sup2", 2, { 0xC2, 0xB2 }
+"sup3", 2, { 0xC2, 0xB3 }
+"acute", 2, { 0xC2, 0xB4 }
+"micro", 2, { 0xC2, 0xB5 }
+"para", 2, { 0xC2, 0xB6 }
+"middot", 2, { 0xC2, 0xB7 }
+"cedil", 2, { 0xC2, 0xB8 }
+"sup1", 2, { 0xC2, 0xB9 }
+"ordm", 2, { 0xC2, 0xBA }
+"raquo", 2, { 0xC2, 0xBB }
+"frac14", 2, { 0xC2, 0xBC }
+"frac12", 2, { 0xC2, 0xBD }
+"frac34", 2, { 0xC2, 0xBE }
+"iquest", 2, { 0xC2, 0xBF }
+"Agrave", 2, { 0xC3, 0x80 }
+"Aacute", 2, { 0xC3, 0x81 }
+"Acirc", 2, { 0xC3, 0x82 }
+"Atilde", 2, { 0xC3, 0x83 }
+"Auml", 2, { 0xC3, 0x84 }
+"Aring", 2, { 0xC3, 0x85 }
+"AElig", 2, { 0xC3, 0x86 }
+"Ccedil", 2, { 0xC3, 0x87 }
+"Egrave", 2, { 0xC3, 0x88 }
+"Eacute", 2, { 0xC3, 0x89 }
+"Ecirc", 2, { 0xC3, 0x8A }
+"Euml", 2, { 0xC3, 0x8B }
+"Igrave", 2, { 0xC3, 0x8C }
+"Iacute", 2, { 0xC3, 0x8D }
+"Icirc", 2, { 0xC3, 0x8E }
+"Iuml", 2, { 0xC3, 0x8F }
+"ETH", 2, { 0xC3, 0x90 }
+"Ntilde", 2, { 0xC3, 0x91 }
+"Ograve", 2, { 0xC3, 0x92 }
+"Oacute", 2, { 0xC3, 0x93 }
+"Ocirc", 2, { 0xC3, 0x94 }
+"Otilde", 2, { 0xC3, 0x95 }
+"Ouml", 2, { 0xC3, 0x96 }
+"times", 2, { 0xC3, 0x97 }
+"Oslash", 2, { 0xC3, 0x98 }
+"Ugrave", 2, { 0xC3, 0x99 }
+"Uacute", 2, { 0xC3, 0x9A }
+"Ucirc", 2, { 0xC3, 0x9B }
+"Uuml", 2, { 0xC3, 0x9C }
+"Yacute", 2, { 0xC3, 0x9D }
+"THORN", 2, { 0xC3, 0x9E }
+"szlig", 2, { 0xC3, 0x9F }
+"agrave", 2, { 0xC3, 0xA0 }
+"aacute", 2, { 0xC3, 0xA1 }
+"acirc", 2, { 0xC3, 0xA2 }
+"atilde", 2, { 0xC3, 0xA3 }
+"auml", 2, { 0xC3, 0xA4 }
+"aring", 2, { 0xC3, 0xA5 }
+"aelig", 2, { 0xC3, 0xA6 }
+"ccedil", 2, { 0xC3, 0xA7 }
+"egrave", 2, { 0xC3, 0xA8 }
+"eacute", 2, { 0xC3, 0xA9 }
+"ecirc", 2, { 0xC3, 0xAA }
+"euml", 2, { 0xC3, 0xAB }
+"igrave", 2, { 0xC3, 0xAC }
+"iacute", 2, { 0xC3, 0xAD }
+"icirc", 2, { 0xC3, 0xAE }
+"iuml", 2, { 0xC3, 0xAF }
+"eth", 2, { 0xC3, 0xB0 }
+"ntilde", 2, { 0xC3, 0xB1 }
+"ograve", 2, { 0xC3, 0xB2 }
+"oacute", 2, { 0xC3, 0xB3 }
+"ocirc", 2, { 0xC3, 0xB4 }
+"otilde", 2, { 0xC3, 0xB5 }
+"ouml", 2, { 0xC3, 0xB6 }
+"divide", 2, { 0xC3, 0xB7 }
+"oslash", 2, { 0xC3, 0xB8 }
+"ugrave", 2, { 0xC3, 0xB9 }
+"uacute", 2, { 0xC3, 0xBA }
+"ucirc", 2, { 0xC3, 0xBB }
+"uuml", 2, { 0xC3, 0xBC }
+"yacute", 2, { 0xC3, 0xBD }
+"thorn", 2, { 0xC3, 0xBE }
+"yuml", 2, { 0xC3, 0xBF }
+"OElig", 2, { 0xC5, 0x92 }
+"oelig", 2, { 0xC5, 0x93 }
+"Scaron", 2, { 0xC5, 0xA0 }
+"scaron", 2, { 0xC5, 0xA1 }
+"Yuml", 2, { 0xC5, 0xB8 }
+"fnof", 2, { 0xC6, 0x92 }
+"circ", 2, { 0xCB, 0x86 }
+"tilde", 2, { 0xCB, 0x9C }
+"Alpha", 2, { 0xCE, 0x91 }
+"Beta", 2, { 0xCE, 0x92 }
+"Gamma", 2, { 0xCE, 0x93 }
+"Delta", 2, { 0xCE, 0x94 }
+"Epsilon", 2, { 0xCE, 0x95 }
+"Zeta", 2, { 0xCE, 0x96 }
+"Eta", 2, { 0xCE, 0x97 }
+"Theta", 2, { 0xCE, 0x98 }
+"Iota", 2, { 0xCE, 0x99 }
+"Kappa", 2, { 0xCE, 0x9A }
+"Lambda", 2, { 0xCE, 0x9B }
+"Mu", 2, { 0xCE, 0x9C }
+"Nu", 2, { 0xCE, 0x9D }
+"Xi", 2, { 0xCE, 0x9E }
+"Omicron", 2, { 0xCE, 0x9F }
+"Pi", 2, { 0xCE, 0xA0 }
+"Rho", 2, { 0xCE, 0xA1 }
+"Sigma", 2, { 0xCE, 0xA3 }
+"Tau", 2, { 0xCE, 0xA4 }
+"Upsilon", 2, { 0xCE, 0xA5 }
+"Phi", 2, { 0xCE, 0xA6 }
+"Chi", 2, { 0xCE, 0xA7 }
+"Psi", 2, { 0xCE, 0xA8 }
+"Omega", 2, { 0xCE, 0xA9 }
+"alpha", 2, { 0xCE, 0xB1 }
+"beta", 2, { 0xCE, 0xB2 }
+"gamma", 2, { 0xCE, 0xB3 }
+"delta", 2, { 0xCE, 0xB4 }
+"epsilon", 2, { 0xCE, 0xB5 }
+"zeta", 2, { 0xCE, 0xB6 }
+"eta", 2, { 0xCE, 0xB7 }
+"theta", 2, { 0xCE, 0xB8 }
+"iota", 2, { 0xCE, 0xB9 }
+"kappa", 2, { 0xCE, 0xBA }
+"lambda", 2, { 0xCE, 0xBB }
+"mu", 2, { 0xCE, 0xBC }
+"nu", 2, { 0xCE, 0xBD }
+"xi", 2, { 0xCE, 0xBE }
+"omicron", 2, { 0xCE, 0xBF }
+"pi", 2, { 0xCF, 0x80 }
+"rho", 2, { 0xCF, 0x81 }
+"sigmaf", 2, { 0xCF, 0x82 }
+"sigma", 2, { 0xCF, 0x83 }
+"tau", 2, { 0xCF, 0x84 }
+"upsilon", 2, { 0xCF, 0x85 }
+"phi", 2, { 0xCF, 0x86 }
+"chi", 2, { 0xCF, 0x87 }
+"psi", 2, { 0xCF, 0x88 }
+"omega", 2, { 0xCF, 0x89 }
+"thetasym", 2, { 0xCF, 0x91 }
+"piv", 2, { 0xCF, 0x96 }
+"ensp", 3, { 0xE2, 0x80, 0x82 }
+"emsp", 3, { 0xE2, 0x80, 0x83 }
+"thinsp", 3, { 0xE2, 0x80, 0x89 }
+"zwnj", 3, { 0xE2, 0x80, 0x8C }
+"zwj", 3, { 0xE2, 0x80, 0x8D }
+"lrm", 3, { 0xE2, 0x80, 0x8E }
+"rlm", 3, { 0xE2, 0x80, 0x8F }
+"ndash", 3, { 0xE2, 0x80, 0x93 }
+"mdash", 3, { 0xE2, 0x80, 0x94 }
+"lsquo", 3, { 0xE2, 0x80, 0x98 }
+"rsquo", 3, { 0xE2, 0x80, 0x99 }
+"sbquo", 3, { 0xE2, 0x80, 0x9A }
+"ldquo", 3, { 0xE2, 0x80, 0x9C }
+"rdquo", 3, { 0xE2, 0x80, 0x9D }
+"bdquo", 3, { 0xE2, 0x80, 0x9E }
+"dagger", 3, { 0xE2, 0x80, 0xA0 }
+"Dagger", 3, { 0xE2, 0x80, 0xA1 }
+"bull", 3, { 0xE2, 0x80, 0xA2 }
+"hellip", 3, { 0xE2, 0x80, 0xA6 }
+"permil", 3, { 0xE2, 0x80, 0xB0 }
+"prime", 3, { 0xE2, 0x80, 0xB2 }
+"Prime", 3, { 0xE2, 0x80, 0xB3 }
+"lsaquo", 3, { 0xE2, 0x80, 0xB9 }
+"rsaquo", 3, { 0xE2, 0x80, 0xBA }
+"oline", 3, { 0xE2, 0x80, 0xBE }
+"frasl", 3, { 0xE2, 0x81, 0x84 }
+"euro", 3, { 0xE2, 0x82, 0xAC }
+"image", 3, { 0xE2, 0x84, 0x91 }
+"weierp", 3, { 0xE2, 0x84, 0x98 }
+"real", 3, { 0xE2, 0x84, 0x9C }
+"trade", 3, { 0xE2, 0x84, 0xA2 }
+"alefsym", 3, { 0xE2, 0x84, 0xB5 }
+"larr", 3, { 0xE2, 0x86, 0x90 }
+"uarr", 3, { 0xE2, 0x86, 0x91 }
+"rarr", 3, { 0xE2, 0x86, 0x92 }
+"darr", 3, { 0xE2, 0x86, 0x93 }
+"harr", 3, { 0xE2, 0x86, 0x94 }
+"crarr", 3, { 0xE2, 0x86, 0xB5 }
+"lArr", 3, { 0xE2, 0x87, 0x90 }
+"uArr", 3, { 0xE2, 0x87, 0x91 }
+"rArr", 3, { 0xE2, 0x87, 0x92 }
+"dArr", 3, { 0xE2, 0x87, 0x93 }
+"hArr", 3, { 0xE2, 0x87, 0x94 }
+"forall", 3, { 0xE2, 0x88, 0x80 }
+"part", 3, { 0xE2, 0x88, 0x82 }
+"exist", 3, { 0xE2, 0x88, 0x83 }
+"empty", 3, { 0xE2, 0x88, 0x85 }
+"nabla", 3, { 0xE2, 0x88, 0x87 }
+"isin", 3, { 0xE2, 0x88, 0x88 }
+"notin", 3, { 0xE2, 0x88, 0x89 }
+"ni", 3, { 0xE2, 0x88, 0x8B }
+"prod", 3, { 0xE2, 0x88, 0x8F }
+"sum", 3, { 0xE2, 0x88, 0x91 }
+"minus", 3, { 0xE2, 0x88, 0x92 }
+"lowast", 3, { 0xE2, 0x88, 0x97 }
+"radic", 3, { 0xE2, 0x88, 0x9A }
+"prop", 3, { 0xE2, 0x88, 0x9D }
+"infin", 3, { 0xE2, 0x88, 0x9E }
+"ang", 3, { 0xE2, 0x88, 0xA0 }
+"and", 3, { 0xE2, 0x88, 0xA7 }
+"or", 3, { 0xE2, 0x88, 0xA8 }
+"cap", 3, { 0xE2, 0x88, 0xA9 }
+"cup", 3, { 0xE2, 0x88, 0xAA }
+"int", 3, { 0xE2, 0x88, 0xAB }
+"there4", 3, { 0xE2, 0x88, 0xB4 }
+"sim", 3, { 0xE2, 0x88, 0xBC }
+"cong", 3, { 0xE2, 0x89, 0x85 }
+"asymp", 3, { 0xE2, 0x89, 0x88 }
+"ne", 3, { 0xE2, 0x89, 0xA0 }
+"equiv", 3, { 0xE2, 0x89, 0xA1 }
+"le", 3, { 0xE2, 0x89, 0xA4 }
+"ge", 3, { 0xE2, 0x89, 0xA5 }
+"sub", 3, { 0xE2, 0x8A, 0x82 }
+"sup", 3, { 0xE2, 0x8A, 0x83 }
+"nsub", 3, { 0xE2, 0x8A, 0x84 }
+"sube", 3, { 0xE2, 0x8A, 0x86 }
+"supe", 3, { 0xE2, 0x8A, 0x87 }
+"oplus", 3, { 0xE2, 0x8A, 0x95 }
+"otimes", 3, { 0xE2, 0x8A, 0x97 }
+"perp", 3, { 0xE2, 0x8A, 0xA5 }
+"sdot", 3, { 0xE2, 0x8B, 0x85 }
+"lceil", 3, { 0xE2, 0x8C, 0x88 }
+"rceil", 3, { 0xE2, 0x8C, 0x89 }
+"lfloor", 3, { 0xE2, 0x8C, 0x8A }
+"rfloor", 3, { 0xE2, 0x8C, 0x8B }
+"lang", 3, { 0xE2, 0x9F, 0xA8 }
+"rang", 3, { 0xE2, 0x9F, 0xA9 }
+"loz", 3, { 0xE2, 0x97, 0x8A }
+"spades", 3, { 0xE2, 0x99, 0xA0 }
+"clubs", 3, { 0xE2, 0x99, 0xA3 }
+"hearts", 3, { 0xE2, 0x99, 0xA5 }
+"diams", 3, { 0xE2, 0x99, 0xA6 }