/*

**	tek.lib.luahtml - Lua+HTML parser/decoding library

**	Written by Timm S. Mueller <tmueller at neoscientists.org>

**	See copyright notice in COPYRIGHT

*/

#include <ctype.h>

#include <stdlib.h>

#include <string.h>

#include <lua.h>

#include <lualib.h>

#include <lauxlib.h>

#define topfile(L)	((FILE **)luaL_checkudata(L, 1, LUA_FILEHANDLE))

static FILE *tofile (lua_State *L) {

  FILE **f = topfile(L);

  if (*f == NULL)

    luaL_error(L, "attempt to use a closed file");

  return *f;

}

static unsigned char *encodeutf8(unsigned char *buf, int c)

{

	if (c < 128)

	{

		*buf++ = c;

	}

	else if (c < 2048)

	{

		*buf++ = 0xc0 + (c >> 6);

		*buf++ = 0x80 + (c & 0x3f);

	}

	else if (c < 65536)

	{

		*buf++ = 0xe0 + (c >> 12);

		*buf++ = 0x80 + ((c & 0xfff) >> 6);

		*buf++ = 0x80 + (c & 0x3f);

	}

	else if (c < 2097152)

	{

		*buf++ = 0xf0 + (c >> 18);

		*buf++ = 0x80 + ((c & 0x3ffff) >> 12);

		*buf++ = 0x80 + ((c & 0xfff) >> 6);

		*buf++ = 0x80 + (c & 0x3f);

	}

	else if (c < 67108864)

	{

		*buf++ = 0xf8 + (c >> 24);

		*buf++ = 0x80 + ((c & 0xffffff) >> 18);

		*buf++ = 0x80 + ((c & 0x3ffff) >> 12);

		*buf++ = 0x80 + ((c & 0xfff) >> 6);

		*buf++ = 0x80 + (c & 0x3f);

	}

	else

	{

		*buf++ = 0xfc + (c >> 30);

		*buf++ = 0x80 + ((c & 0x3fffffff) >> 24);

		*buf++ = 0x80 + ((c & 0xffffff) >> 18);

		*buf++ = 0x80 + ((c & 0x3ffff) >> 12);

		*buf++ = 0x80 + ((c & 0xfff) >> 6);

		*buf++ = 0x80 + (c & 0x3f);

	}

	return buf;

}

struct utf8reader

{

	int (*readchar)(struct utf8reader *);

	int accu, numa, min, bufc;

	const unsigned char *src;

	size_t srclen;

	FILE *file;

	void *udata;

};

static int readstring(struct utf8reader *rd)

{

	if (rd->srclen == 0)

		return -1;

	rd->srclen--;

	return *rd->src++;

}

static int readfile(struct utf8reader *rd)

{

	return fgetc(rd->file);

}

static int readutf8(struct utf8reader *rd)

{

	int c;

	for (;;)

	{

		if (rd->bufc >= 0)

		{

			c = rd->bufc;

			rd->bufc = -1;

		}

		else

			c = rd->readchar(rd);

		if (c < 0)

			return c;

		if (c == 254 || c == 255)

			break;

		if (c < 128)

		{

			if (rd->numa > 0)

			{

				rd->bufc = c;

				break;

			}

			return c;

		}

		else if (c < 192)

		{

			if (rd->numa == 0)

				break;

			rd->accu <<= 6;

			rd->accu += c - 128;

			rd->numa--;

			if (rd->numa == 0)

			{

				if (rd->accu == 0 || rd->accu < rd->min ||

					(rd->accu >= 55296 && rd->accu <= 57343))

					break;

				c = rd->accu;

				rd->accu = 0;

				return c;

			}

		}

		else

		{

			if (rd->numa > 0)

			{

				rd->bufc = c;

				break;

			}

			if (c < 224)

			{

				rd->min = 128;

				rd->accu = c - 192;

				rd->numa = 1;

			}

			else if (c < 240)

			{

				rd->min = 2048;

				rd->accu = c - 224;

				rd->numa = 2;

			}

			else if (c < 248)

			{

				rd->min = 65536;

				rd->accu = c - 240;

				rd->numa = 3;

			}

			else if (c < 252)

			{

				rd->min = 2097152;

				rd->accu = c - 248;

				rd->numa = 4;

			}

			else

			{

				rd->min = 67108864;

				rd->accu = c - 252;

				rd->numa = 5;

			}

		}

	}

	/* bad char */

	rd->accu = 0;

	rd->numa = 0;

	return 65533;

}

typedef enum { PARSER_UNDEF = -1, PARSER_HTML, PARSER_OPEN1, PARSER_OPEN2,

PARSER_CODE, PARSER_VAR, PARSER_CLOSE } parser_state_t;

static unsigned char *outchar(lua_State *L, unsigned char *buf, parser_state_t state, int c)

{

	if (state == PARSER_HTML)

	{

		if (c > 127 || c == '[' || c == ']')

			return buf + sprintf((char *) buf, "&#%02d;", c);

	}

	else if (state == PARSER_CODE)

	{

		if (c > 127)

			return encodeutf8(buf, c);

	}

	else if (c > 127)

		luaL_error(L, "Non-ASCII character outside code or HTML context");

	*buf++ = c;

	return buf;

}

struct readdata

{

	/* buffer including " " .. outfunc .. "(": */

	unsigned char buf0[256];

	/* pointer into buf0 past outfunc: */

	unsigned char *buf;

	/* html+lua parser state: */

	parser_state_t state;

	/* utf8 reader state: */

	struct utf8reader utf8;

};

static const char *readparsed(lua_State *L, void *udata, size_t *sz)

{

	struct readdata *rd = udata;

	parser_state_t news = rd->state;

	int c;

	while ((c = readutf8(&rd->utf8)) >= 0)

	{

		switch (news)

		{

			case PARSER_UNDEF:

				if (c == '<')

				{

					news = PARSER_OPEN1;

					continue;

				}

				rd->state = PARSER_HTML;

				rd->buf[0] = '[';

				rd->buf[1] = '[';

				*sz = outchar(L, rd->buf + 2, rd->state, c) - rd->buf0;

				return (char *) rd->buf0;

			case PARSER_HTML:

				if (c == '<')

				{

					news = PARSER_OPEN1;

					continue;

				}

				break;

			case PARSER_OPEN1:

				if (c == '%')

				{

					news = PARSER_OPEN2;

					continue;

				}

				rd->buf[0] = '<';

				rd->buf[1] = c;

				*sz = 2;

				return (char *) rd->buf;

			case PARSER_OPEN2:

				if (c == '=')

				{

					if (rd->state == PARSER_UNDEF)

					{

						rd->state = PARSER_VAR;

						*sz = rd->buf - rd->buf0;

						return (char *) rd->buf0;

					}

					rd->state = PARSER_VAR;

					strcpy((char *) rd->buf, "]])");

					memcpy(rd->buf + 3, rd->buf0, rd->buf - rd->buf0);

					*sz = 3 + rd->buf - rd->buf0;

					return (char *) rd->buf;

				}

				if (rd->state == PARSER_UNDEF)

					rd->state = PARSER_CODE;

				else

				{

					rd->state = PARSER_CODE;

					rd->buf[0] = ']';

					rd->buf[1] = ']';

					rd->buf[2] = ')';

					rd->buf[3] = ' ';

					rd->buf[4] = c;

					*sz = 5;

					return (char *) rd->buf;

				}

				break;

			case PARSER_VAR:

			case PARSER_CODE:

				if (c == '%')

				{

					news = PARSER_CLOSE;

					continue;

				}

				break;

			case PARSER_CLOSE:

				if (c == '>')

				{

					size_t len;

					if (rd->state == PARSER_CODE)

					{

						rd->state = PARSER_HTML;

						rd->buf[0] = '[';

						rd->buf[1] = '[';

						*sz = rd->buf + 2 - rd->buf0;

						return (char *) rd->buf0;

					}

					rd->state = PARSER_HTML;

					strcpy((char *) rd->buf, " or \"nil\")");

					memcpy(rd->buf + 10, rd->buf0, rd->buf - rd->buf0);

					len = 10 + rd->buf - rd->buf0;

					rd->buf[len++] = '[';

					rd->buf[len++] = '[';

					*sz = len;

					return (char *) rd->buf;

				}

				rd->buf[0] = '%';

				rd->buf[1] = c;

				*sz = 2;

				return (char *) rd->buf;

		}

		*sz = outchar(L, rd->buf, rd->state, c) - rd->buf;

		return (char *) rd->buf;

	}

	rd->state = PARSER_UNDEF;

	if (news == PARSER_HTML)

	{

		*sz = 4;

		return "]]) ";

	}

	return NULL;

}

static int load(lua_State *L)

{

	struct readdata rd;

	const char *outfunc = lua_tostring(L, 2);

	const char *chunkname = lua_tostring(L, 3);

	int res;

	if (lua_isuserdata(L, 1))

	{

		rd.utf8.file = tofile(L);

		rd.utf8.readchar = readfile;

	}

	else

	{

		rd.utf8.src = (unsigned char *) lua_tolstring(L, 1, &rd.utf8.srclen);

		rd.utf8.readchar = readstring;

	}

	rd.utf8.accu = 0;

	rd.utf8.numa = 0;

	rd.utf8.bufc = -1;

	rd.state = PARSER_UNDEF;

	strcpy((char *) rd.buf0, " ");

	strcat((char *) rd.buf0, outfunc);

	strcat((char *) rd.buf0, "(");

	rd.buf = rd.buf0 + strlen((char *) rd.buf0);

	res = lua_load(L, readparsed, &rd, chunkname);

	if (res == 0)

		return 1;

	lua_pushnil(L);

	lua_insert(L, -2);

	/* nil, message on stack */

	return 2;

}

/*****************************************************************************/

static int encodeform(lua_State *L)

{

	struct readdata rd;

	char sbuf[16];

	luaL_Buffer b;

	int c;

	if (lua_isuserdata(L, 1))

	{

		rd.utf8.file = tofile(L);

		rd.utf8.readchar = readfile;

	}

	else

	{

		rd.utf8.src = (unsigned char *) lua_tolstring(L, 1, &rd.utf8.srclen);

		rd.utf8.readchar = readstring;

	}

	luaL_buffinit(L, &b);

	rd.utf8.accu = 0;

	rd.utf8.numa = 0;

	rd.utf8.bufc = -1;

	while ((c = readutf8(&rd.utf8)) >= 0)

	{

		switch(c)

		{

			case 34:

				luaL_addlstring(&b, """, 6);

				break;

			case 38:

				luaL_addlstring(&b, "&", 5);

				break;

			case 60:

				luaL_addlstring(&b, "<", 4);

				break;

			case 62:

				luaL_addlstring(&b, ">", 4);

				break;

			default:

				if (c == 91 || c == 93 || c > 126)

				{

					sprintf(sbuf, "&#%03d;", c);

					luaL_addstring(&b, sbuf);

				}

				else

					luaL_addchar(&b, c);

		}

	}

	luaL_pushresult(&b);

	return 1;

}

/*****************************************************************************/

static const luaL_Reg lib[] =

{

	{ "load", load },

	{ "encodeform", encodeform },

	{ NULL, NULL }

};

int luaopen_tek_lib_luahtml(lua_State *L)

{

	luaL_register(L, "tek.lib.luahtml", lib);

	return 0;

}