Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <bio.h>

#include "hdr.h"

#include "conv.h"

typedef struct Hchar Hchar;

struct Hchar

{

	char *s;

	Rune r;

};

/* <, >, ", & intentionally omitted */

/*

 * Names beginning with _ are names we recognize

 * (without the underscore) but will not generate,

 * because they are nonstandard.

 */

static Hchar byname[] =

{

	{"AElig", 198},

	{"Aacute", 193},

	{"Acirc", 194},

	{"Agrave", 192},

	{"Alpha", 913},

	{"Aring", 197},

	{"Atilde", 195},

	{"Auml", 196},

	{"Beta", 914},

	{"Ccedil", 199},

	{"Chi", 935},

	{"Dagger", 8225},

	{"Delta", 916},

	{"ETH", 208},

	{"Eacute", 201},

	{"Ecirc", 202},

	{"Egrave", 200},

	{"Epsilon", 917},

	{"Eta", 919},

	{"Euml", 203},

	{"Gamma", 915},

	{"Iacute", 205},

	{"Icirc", 206},

	{"Igrave", 204},

	{"Iota", 921},

	{"Iuml", 207},

	{"Kappa", 922},

	{"Lambda", 923},

	{"Mu", 924},

	{"Ntilde", 209},

	{"Nu", 925},

	{"OElig", 338},

	{"Oacute", 211},

	{"Ocirc", 212},

	{"Ograve", 210},

	{"Omega", 937},

	{"Omicron", 927},

	{"Oslash", 216},

	{"Otilde", 213},

	{"Ouml", 214},

	{"Phi", 934},

	{"Pi", 928},

	{"Prime", 8243},

	{"Psi", 936},

	{"Rho", 929},

	{"Scaron", 352},

	{"Sigma", 931},

	{"THORN", 222},

	{"Tau", 932},

	{"Theta", 920},

	{"Uacute", 218},

	{"Ucirc", 219},

	{"Ugrave", 217},

	{"Upsilon", 933},

	{"Uuml", 220},

	{"Xi", 926},

	{"Yacute", 221},

	{"Yuml", 376},

	{"Zeta", 918},

	{"aacute", 225},

	{"acirc", 226},

	{"acute", 180},

	{"aelig", 230},

	{"agrave", 224},

	{"alefsym", 8501},

	{"alpha", 945},

	{"amp", 38},

	{"and", 8743},

	{"ang", 8736},

	{"aring", 229},

	{"asymp", 8776},

	{"atilde", 227},

	{"auml", 228},

	{"bdquo", 8222},

	{"beta", 946},

	{"brvbar", 166},

	{"bull", 8226},

	{"cap", 8745},

	{"ccedil", 231},

	{"cdots", 8943},

	{"cedil", 184},

	{"cent", 162},

	{"chi", 967},

	{"circ", 710},

	{"clubs", 9827},

	{"cong", 8773},

	{"copy", 169},

	{"crarr", 8629},

	{"cup", 8746},

	{"curren", 164},

	{"dArr", 8659},

	{"dagger", 8224},

	{"darr", 8595},

	{"ddots", 8945},

	{"deg", 176},

	{"delta", 948},

	{"diams", 9830},

	{"divide", 247},

	{"eacute", 233},

	{"ecirc", 234},

	{"egrave", 232},

	{"_emdash", 8212},	/* non-standard but commonly used */

	{"empty", 8709},

	{"emsp", 8195},

	{"_endash", 8211},	/* non-standard but commonly used */

	{"ensp", 8194},

	{"epsilon", 949},

	{"equiv", 8801},

	{"eta", 951},

	{"eth", 240},

	{"euml", 235},

	{"euro", 8364},

	{"exist", 8707},

	{"fnof", 402},

	{"forall", 8704},

	{"frac12", 189},

	{"frac14", 188},

	{"frac34", 190},

	{"frasl", 8260},

	{"gamma", 947},

	{"ge", 8805},

	{"gt", 62},

	{"hArr", 8660},

	{"harr", 8596},

	{"hearts", 9829},

	{"hellip", 8230},

	{"iacute", 237},

	{"icirc", 238},

	{"iexcl", 161},

	{"igrave", 236},

	{"image", 8465},

	{"infin", 8734},

	{"int", 8747},

	{"iota", 953},

	{"iquest", 191},

	{"isin", 8712},

	{"iuml", 239},

	{"kappa", 954},

	{"lArr", 8656},

	{"lambda", 955},

	{"lang", 9001},

	{"laquo", 171},

	{"larr", 8592},

	{"lceil", 8968},

	{"_ldots", 8230},

	{"ldquo", 8220},

	{"le", 8804},

	{"lfloor", 8970},

	{"lowast", 8727},

	{"loz", 9674},

	{"lrm", 8206},

	{"lsaquo", 8249},

	{"lsquo", 8216},

	{"lt", 60},

	{"macr", 175},

	{"mdash", 8212},

	{"micro", 181},

	{"middot", 183},

	{"minus", 8722},

	{"mu", 956},

	{"nabla", 8711},

	{"nbsp", 160},

	{"ndash", 8211},

	{"ne", 8800},

	{"ni", 8715},

	{"not", 172},

	{"notin", 8713},

	{"nsub", 8836},

	{"ntilde", 241},

	{"nu", 957},

	{"oacute", 243},

	{"ocirc", 244},

	{"oelig", 339},

	{"ograve", 242},

	{"oline", 8254},

	{"omega", 969},

	{"omicron", 959},

	{"oplus", 8853},

	{"or", 8744},

	{"ordf", 170},

	{"ordm", 186},

	{"oslash", 248},

	{"otilde", 245},

	{"otimes", 8855},

	{"ouml", 246},

	{"para", 182},

	{"part", 8706},

	{"permil", 8240},

	{"perp", 8869},

	{"phi", 966},

	{"pi", 960},

	{"piv", 982},

	{"plusmn", 177},

	{"pound", 163},

	{"prime", 8242},

	{"prod", 8719},

	{"prop", 8733},

	{"psi", 968},

	{"quad", 8193},

	{"quot", 34},

	{"rArr", 8658},

	{"radic", 8730},

	{"rang", 9002},

	{"raquo", 187},

	{"rarr", 8594},

	{"rceil", 8969},

	{"rdquo", 8221},

	{"real", 8476},

	{"reg", 174},

	{"rfloor", 8971},

	{"rho", 961},

	{"rlm", 8207},

	{"rsaquo", 8250},

	{"rsquo", 8217},

	{"sbquo", 8218},

	{"scaron", 353},

	{"sdot", 8901},

	{"sect", 167},

	{"shy", 173},

	{"sigma", 963},

	{"sigmaf", 962},

	{"sim", 8764},

	{"_sp", 8194},

	{"spades", 9824},

	{"sub", 8834},

	{"sube", 8838},

	{"sum", 8721},

	{"sup", 8835},

	{"sup1", 185},

	{"sup2", 178},

	{"sup3", 179},

	{"supe", 8839},

	{"szlig", 223},

	{"tau", 964},

	{"there4", 8756},

	{"theta", 952},

	{"thetasym", 977},

	{"thinsp", 8201},

	{"thorn", 254},

	{"tilde", 732},

	{"times", 215},

	{"trade", 8482},

	{"uArr", 8657},

	{"uacute", 250},

	{"uarr", 8593},

	{"ucirc", 251},

	{"ugrave", 249},

	{"uml", 168},

	{"upsih", 978},

	{"upsilon", 965},

	{"uuml", 252},

	{"_varepsilon", 8712},

	{"varphi", 981},

	{"_varpi", 982},

	{"varrho", 1009},

	{"vdots", 8942},

	{"_vsigma", 962},

	{"_vtheta", 977},

	{"weierp", 8472},

	{"xi", 958},

	{"yacute", 253},

	{"yen", 165},

	{"yuml", 255},

	{"zeta", 950},

	{"zwj", 8205},

	{"zwnj", 8204}

};

static Hchar byrune[nelem(byname)];

static int

hnamecmp(const void *va, const void *vb)

{

	Hchar *a, *b;

	a = (Hchar*)va;

	b = (Hchar*)vb;

	return strcmp(a->s, b->s);

}

static int

hrunecmp(const void *va, const void *vb)

{

	Hchar *a, *b;

	a = (Hchar*)va;

	b = (Hchar*)vb;

	return a->r - b->r;

}

static void

html_init(void)

{

	static int init;

	int i;

	if(init)

		return;

	init = 1;

	memmove(byrune, byname, sizeof byrune);

	/* Eliminate names we aren't allowed to generate. */

	for(i=0; i<nelem(byrune); i++){

		if(byrune[i].s[0] == '_'){

			byrune[i].r = Runeerror;

			byname[i].s++;

		}

	}

	qsort(byname, nelem(byname), sizeof byname[0], hnamecmp);

	qsort(byrune, nelem(byrune), sizeof byrune[0], hrunecmp);

}

static Rune

findbyname(char *s)

{

	Hchar *h;

	int n, m, x;

	h = byname;

	n = nelem(byname);

	while(n > 0){

		m = n/2;

		x = strcmp(h[m].s, s);

		if(x == 0)

			return h[m].r;

		if(x < 0){

			h += m+1;

			n -= m+1;

		}else

			n = m;

	}

	return Runeerror;

}

static char*

findbyrune(Rune r)

{

	Hchar *h;

	int n, m;

	if(r == Runeerror)

		return nil;

	h = byrune;

	n = nelem(byrune);

	while(n > 0){

		m = n/2;

		if(h[m].r == r)

			return h[m].s;

		if(h[m].r < r){

			h += m+1;

			n -= m+1;

		}else

			n = m;

	}

	return nil;

}

void

html_in(int fd, long *x, struct convert *out)

{

	char buf[100], *p;

	Biobuf b;

	Rune rbuf[N];

	Rune *r, *er;

	int c, i;

	USED(x);

	html_init();

	r = rbuf;

	er = rbuf+N;

	Binit(&b, fd, OREAD);

	while((c = Bgetrune(&b)) != Beof){

		if(r >= er){

			OUT(out, rbuf, r-rbuf);

			r = rbuf;

		}

		if(c == '&'){

			buf[0] = c;

			for(i=1; i<nelem(buf)-1;){

				c = Bgetc(&b);

				if(c == Beof)

					break;

				buf[i++] = c;

				if(strchr("; \t\r\n", c))

					break;

			}

			buf[i] = 0;

			if(buf[i-1] == ';'){

				buf[i-1] = 0;

				if((c = findbyname(buf+1)) != Runeerror){

					*r++ = c;

					continue;

				}

				buf[i-1] = ';';

				if(buf[1] == '#'){

					if(buf[2] == 'x')

						c = strtol(buf+3, &p, 16);

					else

						c = strtol(buf+2, &p, 10);

					if(*p != ';' || c >= NRUNE || c < 0)

						goto bad;

					*r++ = c;

					continue;

				}

			}

		bad:

			for(p=buf; p<buf+i; ){

				p += chartorune(r++, p);

				if(r >= er){

					OUT(out, rbuf, r-rbuf);

					r = rbuf;

				}

			}

			continue;

		}

		*r++ = c;

	}

	if(r > rbuf)

		OUT(out, rbuf, r-rbuf);

	OUT(out, rbuf, 0);

}

/*

 * use biobuf because can use more than UTFmax bytes per rune

 */

void

html_out(Rune *r, int n, long *x)

{

	char *s;

	Biobuf b;

	Rune *er;

	USED(x);

	html_init();

	Binit(&b, 1, OWRITE);

	er = r+n;

	for(; r<er; r++){

		if(*r < Runeself)

			Bputrune(&b, *r);

		else if((s = findbyrune(*r)) != nil)

			Bprint(&b, "&%s;", s);

		else

			Bprint(&b, "&#%d;", *r);

	}

	Bflush(&b);

}