cmd/html/html2rtf.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 1996-2011 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                 Eclipse Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*          http://www.eclipse.org/org/documents/epl-v10.html           *
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                 Glenn Fowler <gsf@research.att.com>                  *
*                                                                      *
***********************************************************************/
#pragma prototyped
/*
 * Glenn Fowler
 * AT&T Research
 *
 * html to rtf filter
 */

static const char usage[] =
"[-?\n@(#)$Id: html2rtf (AT&T Research) 1999-01-01 $\n]"
USAGE_LICENSE
"[+NAME?html2rtf - html to rtf filter]"
"[+DESCRIPTION?\bhtml2rtf\b converts input \bhtml\b documents to an \bRTF\b"
"	document on the standard output. \bhtml2rtf\b expects properly nested"
"	begin/end tags in the input \bhtml\b and warns about imbalance.]"

"[d:debug?Set the debug trace level to \alevel\a. Higher levels produce"
"	more output.]#[level]"
"[f:font-size?Set the initial font size to \asize\a points.]#[size:=12]"
"[p:project-file?Appends MS HELP project information to the help project file"
"	\afile\a. This file combines individual RTF files into a"
"	hyper-linked collection. Note that MS expects \afile\a to have a"
"	\b.hlp\b extension.]:[file]"
"[v:verbose?Enable verbose error and warning messages. Some \bhtml\b source"
"	can't stand the heat.]"

"\n"
"\n[ file ... ]\n"
"\n"

"[+SEE ALSO?\bman\b(1), \bmm\b(1), \bmm2html\b(1), \btroff\b(1),"
"	\btroff2html\b(1)]"
;

#include "html2rtf.h"

#include <error.h>

#define LIST_INDENT		140
#define STK_LIST_COMPACT	(STK_TAG<<0)

#define a_close			data[0].number
#define a_label			data[1].string

#define font_size		data[0].number

#define list_counter		data[0].number
#define list_hanging		data[1].number
#define list_indent		data[2].number
#define list_label		data[3].string
#define list_type		data[4].number

#define title_cc		data[0].number
#define title_lastlastc		data[1].number
#define title_op		data[2].io
#define title_tc		data[3].number

State_t			state;

/*
 * return the attribute pointer for name in ap
 */

static Attribute_t*
attribute(register Attribute_t* ap, const char* name)
{
	if (ap)
		for (; ap->name; ap++)
			if (!strcasecmp(ap->name, name))
				return ap;
	return 0;
}

/*
 * new paragraph with optional hanging indent
 */

static void
par(int hanging, const char* tail)
{
	if (hanging && !(state.sp->flags & STK_LIST_COMPACT))
		sfputr(state.out, "\\line", -1);
	sfputr(state.out, "\\par\\pard", -1);
	if (state.center)
		sfputr(state.out, "\\qc", -1);
	if (hanging)
		sfprintf(state.out, "\\fi%d", twips(state.hanging - state.indent));
	sfprintf(state.out, "\\li%d\\tx%d\\tx20000%s", twips(state.indent), twips(state.indent), tail ? tail : "");
	state.sep = 1;
}

static void
anchor(int ref, register char* s)
{
	register int	c;

	if (s)
	{
		if (ref)
		{
			if (*s != '#')
			{
				error(1, "%s: unknown link", s);
				return;
			}
			s++;
			sfprintf(state.out, "{\\uldb %s}{\\v", s);
		}
		else
			sfputr(state.out, "#{\\footnote", -1);
		sfprintf(state.out, " %s.", state.prefix);
		while (c = *s++)
			sfputc(state.out, isalnum(c) ? c : '.');
		sfputc(state.out, '}');
		if (ref)
		{
			sfputr(state.out, "{\\*\\comment", -1);
			state.sep = 1;
			state.sp->a_close = 1;
		}
	}
}

static int
start_a(Tag_t* tp, Attribute_t* ap)
{
	Attribute_t*	op;

	NoP(tp);
	state.sp->a_close = 0;
	if (op = attribute(ap, "HREF"))
		anchor(1, op->value);
	if (op = attribute(ap, "NAME"))
		anchor(0, op->value);
	return 1;
}

static int
end_a(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	if (state.sp->a_close)
	{
		sfputc(state.out, '}');
		state.sep = 0;
	}
	return 0;
}

static int
start_b(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	sfputr(state.out, "{\\b", -1);
	state.sep = 1;
	return 1;
}

static int
start_bq(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	state.sp->list_hanging = state.hanging;
	state.sp->list_indent = state.indent;
	state.hanging += LIST_INDENT;
	state.indent = state.hanging;
	par(0, NiL);
	sfprintf(state.out, "\\ri%d", state.indent);
	state.sep = 1;
	return 1;
}

static int
end_bq(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	state.hanging = state.sp->list_hanging;
	state.indent = state.sp->list_indent;
	sfprintf(state.out, "\\ri0");
	state.sep = 1;
	return 1;
}

static int
start_body(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	return 0;
}

static int
start_br(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	sfputr(state.out, "\\line", -1);
	state.sep = 1;
	return 0;
}

static int
start_caption(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	return 0;
}

static int
start_center(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	state.center++;
	state.pre++;
	par(0, NiL);
	return 1;
}

static int
end_center(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	if (state.center > 0)
		state.center--;
	if (state.pre > 0)
		state.pre--;
	return 1;
}

static int
start_dd(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	if (state.sp->flags & STK_HEADING)
		par(0, NiL);
	else
		sfputr(state.out, "\\tab", -1);
	state.sep = 1;
	return 1;
}

static int
start_dl(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	if (attribute(ap, "COMPACT"))
		state.sp->flags |= STK_LIST_COMPACT;
	state.sp->list_hanging = state.hanging;
	state.sp->list_indent = state.indent;
	state.hanging += LIST_INDENT;
	state.indent = state.hanging + LIST_INDENT * 2;
	return 1;
}

static int
end_LIST(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	state.hanging = state.sp->list_hanging;
	state.indent = state.sp->list_indent;
	return 1;
}

static int
start_dt(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	par(1, NiL);
	return 1;
}

static int
start_fn(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	sfputr(state.out, "\\~[\\~", -1);
	return 1;
}

static int
end_fn(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	sfputr(state.out, "\\~]\\~", -1);
	return 0;
}

static int
start_font(Tag_t* tp, Attribute_t* ap)
{
	char*		s;
	char*		e;
	int		n;
	Attribute_t*	op;

	NoP(tp);
	if ((op = attribute(ap, "SIZE")) && (s = op->value) && (n = strtol(s, &e, 10)) && !*e)
	{
		if (*s == '+' || *s == '-')
			n += state.fontsize;
		state.sp->font_size = state.fontsize;
		state.fontsize = n;
		sfprintf(state.out, "{\\fs%d", twips(n));
		state.sep = 1;
		return 1;
	}
	return 0;
}

static int
end_font(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	state.fontsize = state.sp->font_size;
	sfputc(state.out, '}');
	state.sep = 0;
	return 1;
}

static int
start_H(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	(state.sp - 1)->flags |= STK_HEADING;
	state.sp->font_size = state.fontsize;
	state.fontsize += (7 - (tp->name[1] - '0')) * 1;
	sfprintf(state.out, "{\\b\\fs%d", twips(state.fontsize));
	state.sep = 1;
	return 1;
}

static int
end_H(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	state.fontsize = state.sp->font_size;
	sfputc(state.out, '}');
	state.sep = 0;
	return 1;
}

static int
start_head(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	return 0;
}

static int
end_head(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	return 0;
}

static int
start_hr(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	sfputr(state.out, "{\\brdrt\\brdrsh\\par}", -1);
	state.sep = 0;
	return 0;
}

static int
start_html(Tag_t* tp, Attribute_t* ap)
{
	char*	s;

	NoP(tp);
	NoP(ap);
	sfputr(state.out, "{\\rtf1 \\ansi \\deff0", '\n');
	s = strchr(usage, '\n') + 5;
	sfprintf(state.out, "{\\*\\comment generator: %-.*s}\n", strchr(usage, '\n') - s, s);
	sfputr(state.out, "{\\fonttbl", '\n');
	sfputr(state.out, "{\\f0 \\froman Times New Roman;}", '\n');
	sfputr(state.out, "{\\f1 \\fmodern Line Printer;}", '\n');
	sfputr(state.out, "{\\f2 \\froman Symbol;}", '\n');
	sfputr(state.out, "{\\f3 \\fswiss Ariel;}", '\n');
	sfputr(state.out, "}", '\n');
	sfprintf(state.out, "\\fs%d\n", twips(state.fontsize));
	return 1;
}

static int
end_html(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	sfputr(state.out, "\n}", '\n');
	return 1;
}

static int
start_i(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	sfputr(state.out, "{\\i", -1);
	state.sep = 1;
	return 1;
}

static int
start_img(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	return 0;
}

/*
 * NOTE: roman() transcribed from GNU groff
 */

static void
roman(register int n, int format)
{
	register char*	dig;
	register int	i;
	register int	m;

	dig = islower(format) ? "zwmdclxvi" : "ZWMDCLXVI";
	if (n <= -40000 || n >= 40000)
	{
		sfprintf(state.out, "<%d>", n);
		return;
	}
	if (n == 0)
	{
		sfputc(state.out, '0');
		return;
	}
	if (n < 0)
	{
		n = -n;
		sfputc(state.out, '-');
	}
	while (n >= 10000)
	{
		n -= 10000;
		sfputc(state.out, dig[0]);
	}
	for (i = 1000; i > 0; i /= 10, dig += 2)
	{
		m = n / i;
		n -= m * i;
		switch (m)
		{
		case 9:
			sfputc(state.out, dig[2]);
			sfputc(state.out, dig[0]);
			break;
		case 8:
			sfputc(state.out, dig[1]);
			sfputc(state.out, dig[2]);
			sfputc(state.out, dig[2]);
			sfputc(state.out, dig[2]);
			break;
		case 7:
			sfputc(state.out, dig[1]);
			sfputc(state.out, dig[2]);
			sfputc(state.out, dig[2]);
			break;
		case 6:
			sfputc(state.out, dig[1]);
			sfputc(state.out, dig[2]);
			break;
		case 5:
			sfputc(state.out, dig[1]);
			break;
		case 4:
			sfputc(state.out, dig[2]);
			sfputc(state.out, dig[1]);
			break;
		case 3:
			sfputc(state.out, dig[2]);
			/*FALLTHROUGH*/
		case 2:
			sfputc(state.out, dig[2]);
			/*FALLTHROUGH*/
		case 1:
			sfputc(state.out, dig[2]);
			break;
		}
	}
}

static int
start_li(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	par(1, "{\\b ");
	switch (state.sp->list_type)
	{
	case '1':
		sfprintf(state.out, "%d.", state.sp->list_counter);
		break;
	case 'A':
		sfprintf(state.out, "%c)", 'A' + state.sp->list_counter);
		break;
	case 'a':
		sfprintf(state.out, "%c)", 'a' + state.sp->list_counter);
		break;
	case 'I':
	case 'i':
		roman(state.sp->list_counter, state.sp->list_type);
		sfputc(state.out, ')');
		break;
	default:
		sfputr(state.out, state.sp && state.sp->list_label ? state.sp->list_label : "\\bullet", -1);
		break;
	}
	state.sp->list_counter++;
	sfputr(state.out, "}\\tab", -1);
	state.sep = 1;
	return 1;
}

static int
start_meta(Tag_t* tp, Attribute_t* ap)
{
	Attribute_t*	op;

	NoP(tp);
	if ((op = attribute(ap, "NAME")) && op->value)
	{
		sfprintf(state.out, "{\\*\\comment %s", op->value);
		if ((op = attribute(ap, "CONTENT")) && op->value)
			sfprintf(state.out, ": %s", op->value);
		sfputr(state.out, "}", '\n');
	}
	return 0;
}

static int
start_ol(Tag_t* tp, Attribute_t* ap)
{
	char*		e;
	Attribute_t*	op;

	NoP(tp);
	if (attribute(ap, "COMPACT"))
		state.sp->flags |= STK_LIST_COMPACT;
	if (!(op = attribute(ap, "START")) || !op->value || (state.sp->list_counter = strtol(op->value, &e, 10)) < 0 || *e)
		state.sp->list_counter = 1;
	state.sp->list_type = (op = attribute(ap, "TYPE")) && op->value ? *op->value : '1';
	state.sp->list_hanging = state.hanging;
	state.sp->list_indent = state.indent;
	state.hanging += LIST_INDENT;
	state.indent = state.hanging + LIST_INDENT;
	return 1;
}

static int
start_p(Tag_t* tp, Attribute_t* ap)
{
	register char*	s;
	Attribute_t*	op;

	NoP(tp);
	par(0, NiL);
	if ((op = attribute(ap, "ALIGN")) && (s = op->value))
	{
		if (!strcasecmp(s, "CENTER"))
			sfputr(state.out, "\\qc", -1);
		else if (!strcasecmp(s, "LEFT"))
			sfputr(state.out, "\\ql", -1);
		else if (!strcasecmp(s, "RIGHT"))
			sfputr(state.out, "\\qr", -1);
	}
	return 1;
}

static int
start_pre(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	state.pre++;
	return 1;
}

static int
end_pre(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	if (state.pre > 0)
		state.pre--;
	return 1;
}

static int
start_rendering(register Tag_t* tp, Attribute_t* ap)
{
	register Render_t*	rp;
	register int		i;

	if (rp = (Render_t*)tp->data)
		for (i = 0; i < rp->tags; i++)
			if ((tp = rp->tag[i]) && tp->start)
				(*tp->start)(tp, ap);
	return 1;
}

static int
end_rendering(register Tag_t* tp, Attribute_t* ap)
{
	register Render_t*	rp;
	register int		i;

	if (rp = (Render_t*)tp->data)
		for (i = rp->tags - 1; i > 0; i--)
			if ((tp = rp->tag[i]) && tp->end)
				(*tp->end)(tp, ap);
	return 1;
}

static int
start_render(register Tag_t* tp, Attribute_t* ap)
{
	register Render_t*	rp;
	register char*		s;
	register char*		e;
	register int		n;
	Attribute_t*		op;

	if ((op = attribute(ap, "TAG")) && (s = op->value))
	{
		if (tp = (Tag_t*)hashget(state.tags, s))
		{
			if (tp->data)
				free(tp->data);
			tp->start = 0;
			tp->end = 0;
			tp->data = 0;
		}
		else if (!(tp = newof(NiL, Tag_t, 1, 0)) || !(tp->name = hashput(state.tags, 0, tp)))
			error(ERROR_SYSTEM|3, "out of space [tag]");
		if ((op = attribute(ap, "STYLE")) && (s = op->value))
		{
			for (n = 0, e = s; e && (e = strchr(e, ',')); n++, e++);
			if (!(rp = newof(NiL, Render_t, 1, n * sizeof(Tag_t*))))
				error(ERROR_SYSTEM|3, "out of space [render]");
			n = 0;
			do
			{
				if (e = strchr(s, ','))
					*e++ = 0;
				if (rp->tag[n] = (Tag_t*)hashget(state.tags, s))
					n++;
			} while (s = e);
			if (!(rp->tags = n))
				free(rp);
			else
			{
				tp->start = start_rendering;
				tp->end = end_rendering;
				tp->data = (void*)rp;
			}
		}
	}
	return 0;
}

static int
start_sub(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	return 0;
}

static int
end_sub(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	return 0;
}

static int
start_sup(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	return 0;
}

static int
end_sup(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	return 0;
}

static int
start_table(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	state.center++;
	par(0, NiL);
	return 1;
}

static int
end_table(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	if (state.center > 0)
		state.center++;
	sfputr(state.out, "}", '\n');
	return 0;
}

static int
start_td(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	return 0;
}

static int
end_td(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	return 1;
}

static int
start_th(Tag_t* tp, Attribute_t* ap)
{
	register Attribute_t*	op;

	NoP(tp);
	if (!(op = attribute(ap, "ALIGN")) || !op->value || *op->value != 'l' && *op->value != 'L')
		sfputr(state.out, "\\~\\~\\~\\~\\~\\~\\~\\~\\~\\~\\~\\~", -1);
	return 0;
}

static int
start_title(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	state.pre++;
	return 1;
}

static int
end_title(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	if (state.pre > 0)
		state.pre--;
	return 1;
}

static int
start_tr(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	return 0;
}

static int
end_tr(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	return 1;
}

static int
start_tt(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	sfputr(state.out, "{\\f1", -1);
	state.sep = 1;
	return 1;
}

static int
start_ul(Tag_t* tp, Attribute_t* ap)
{
	Attribute_t*	op;

	NoP(tp);
	if (attribute(ap, "COMPACT"))
		state.sp->flags |= STK_LIST_COMPACT;
	state.sp->list_type = 0;
	switch ((op = attribute(ap, "TYPE")) && op->value ? *op->value : 0)
	{
	case 'c':
		state.sp->list_label = "\\'b0";
		break;
	case 's':
		state.sp->list_label = "\\'a4";
		break;
	default:
		state.sp->list_label = "\\bullet";
		break;
	}
	state.sp->list_hanging = state.hanging;
	state.sp->list_indent = state.indent;
	state.hanging += LIST_INDENT;
	state.indent = state.hanging + LIST_INDENT;
	return 1;
}

static int
start_var(Tag_t* tp, Attribute_t* ap)
{
	NoP(tp);
	NoP(ap);
	sfputr(state.out, "{\\f3\\i", -1);
	state.sep = 1;
	return 1;
}

/*
 * generic tag end
 */

static int
end(Tag_t* tp, Attribute_t* ap)
{
	sfputc(state.out, '}');
	state.sep = 0;
	return 1;
}

/*
 * convert html file in to rtf file out
 */

#define COMMENT	1
#define PUN	4
#define STRING	2

static void
process(char* file, register Sfio_t* ip, register Sfio_t* op)
{
	register int	c;
	register int	lastc;
	register int	item;
	register int	cc;
	register int	tc;
	register char*	s;
	int		lastlastc;
	int		quote;
	int		n;
	Entity_t*	ep;
	Tag_t*		tp;
	Attribute_t	attributes[16];
	Attribute_t*	ap;
	Stack_t*	sp;

	error_info.file = file;
	error_info.line = 1;
	state.center = 0;
	state.in = ip;
	state.out = op;
	state.pre = 0;
	state.sp = state.sp_min;
	ap = 0;
	item = 0;
	lastc = 0;
	cc = tc = 0;
	for (;;)
	{
		switch (c = sfgetc(ip))
		{
		case EOF:
			goto done;
		case '<':
			if (!item)
			{
				item = c;
				lastlastc = lastc;
				quote = 0;
				ap = attributes;
				ap->name = 0;
				ap->value = 0;
				op = state.tmp;
				if ((c = sfgetc(ip)) != EOF)
				{
					sfungetc(ip, c);
					if (c == '!')
						quote |= COMMENT;
				}
				continue;
			}
			break;
		case '>':
			if (item == '<' && !(quote & STRING))
			{
				item = 0;
				if (!(s = sfstruse(op)))
					error(ERROR_SYSTEM|3, "out of space");
				op = state.out;
				if (*s == '!')
				{
					if ((cc -= strlen(s)) <= 0)
					{
						cc = 0;
						if ((c = sfgetc(ip)) != EOF)
						{
							if (c == '\n')
								error_info.line++;
							else
								sfungetc(ip, c);
						}
					}
					continue;
				}
				(ap + 1)->name = 0;
				for (;;)
				{
					ap->name = s + (((unsigned int)ap->name) >> PUN);
					if (!*ap->name)
						ap->name = 0;
					else if (ap->value)
					{
						ap->value = s + (((unsigned int)ap->value) >> PUN);
						if (!*ap->value)
							ap->value = 0;
					}
					if (ap == attributes)
						break;
					ap--;
				}
				if (c = *s == '/')
					s++;
				if (!(tp = (Tag_t*)hashget(state.tags, s)))
					error(1, "<%s>: unknown tag", s);
				else if (!c)
				{
					if (tp->end)
					{
						if (state.sp >= state.sp_max)
						{
							c = state.sp - state.sp_min;
							n = (state.sp_max - state.sp_min + 1) * 2;
							if (!(state.sp_min = oldof(state.sp_min, Stack_t, n, 0)))
								error(ERROR_SYSTEM|3, "out of space [tag stack]");
							state.sp_max = state.sp_min + n - 1;
							state.sp = state.sp_min + c;
						}
						state.sp++;
						state.sp->tag = tp;
						state.sp->line = error_info.line;
						state.sp->flags = 0;
						if (tp->flags & TAG_IGNORE)
						{
							state.sp->title_cc = cc;
							state.sp->title_lastlastc = lastlastc;
							state.sp->title_op = op;
							state.sp->title_tc = tc;
							op = state.nul;
							sfstrseek(op, 0, SEEK_SET);
						}
					}
					if (tp->start && !(*tp->start)(tp, ap) && tp->end)
						state.sp->flags |= STK_NOEND;
				}
				else
				{
					sp = state.sp;
					if (state.sp->tag != tp)
					{
						for (;;)
						{
							if (sp == state.sp_min)
							{
								if (!(tp->flags & TAG_UNBALANCED))
									error(1, "</%s> has no matching <%s>", tp->name, tp->name);
								sp = 0;
								break;
							}
							if (sp->tag == tp)
								break;
							sp--;
						}
						if (sp)
						{
							while (state.sp > sp)
							{
								if (state.sp->tag->end && !(state.sp->flags & STK_NOEND))
								{
									if (!(state.sp->tag->flags & TAG_UNBALANCED))
										error(1, "<%s> on line %d has no matching </%s>", state.sp->tag->name, state.sp->line, state.sp->tag->name);
									(*state.sp->tag->end)(state.sp->tag, NiL);
								}
								state.sp--;
							}
						}
					}
					if (sp)
					{
						if (tp->end && !(state.sp->flags & STK_NOEND))
							(*tp->end)(tp, ap);
						if (tp->flags & TAG_IGNORE)
						{
							cc = state.sp->title_cc;
							lastlastc = state.sp->title_lastlastc;
							op = state.sp->title_op;
							tc = state.sp->title_tc;
						}
						state.sp--;
					}
				}
				ap = 0;
				lastc = lastlastc;
				continue;
			}
			break;
		case '=':
			if (ap && !ap->value)
			{
				sfputc(op, 0);
				ap->value = (char*)(sfstrtell(op) << PUN);
				continue;
			}
			break;
		case '"':
			if (ap)
			{
				quote ^= STRING;
				if (!(quote & COMMENT))
					continue;
			}
			break;
		case '&':
			if (!item)
			{
				item = c;
				op = state.tmp;
				continue;
			}
			break;
		case ';':
			if (item == '&')
			{
				item = 0;
				if (!(s = sfstruse(op)))
					error(ERROR_SYSTEM|3, "out of space");
				op = state.out;
				if (*s == '#')
				{
					n = (int)strtol(s + 1, NiL, 10) & 0377;
					cc += sfprintf(op, "\\'%02x", n);
					tc++;
					if (isspace(n))
						lastc = ' ';
				}
				else if (ep = (Entity_t*)hashget(state.entities, s))
				{
					cc += sfputr(op, ep->value, -1);
					tc++;
					if (ep->flags & ENT_SPACE)
						lastc = ' ';
				}
				else
				{
					error(1, "&%s;: unknown entity reference", s);
					cc += sfprintf(op, "&%s;", s);
					tc++;
				}
				continue;
			}
			break;
		case '{':
		case '}':
		case '\\':
			sfputc(op, '\\');
			cc++;
			state.sep = 0;
			break;
		case '\n':
			error_info.line++;
			if (state.pre && !item)
			{
				state.sep = 0;
				sfputr(op, "\\line", -1);
				cc += 5;
				tc = 0;
				break;
			}
			/*FALLTHROUGH*/
		case ' ':
		case '\t':
		case '\v':
			if (ap)
			{
				if (!quote)
				{
					if (lastc != ' ' && ap < &attributes[elementsof(attributes) - 1])
					{
						sfputc(op, 0);
						ap++;
						ap->name = (char*)(sfstrtell(op) << PUN);
						ap->value = 0;
						lastc = ' ';
					}
					continue;
				}
			}
			else if (!state.pre)
			{
				if (lastc == ' ')
					continue;
				c = ' ';
				if (cc >= 72)
				{
					cc = 0;
					sfputc(op, '\n');
				}
			}
			else if (c == ' ')
			{
				sfputr(op, "\\~", -1);
				cc += 2;
				tc++;
				state.sep = 0;
				continue;
			}
			else if (c == '\t')
			{
				do
				{
					sfputr(op, "\\~", -1);
					cc += 2;
					tc++;
				} while (tc % 8);
				state.sep = 0;
				continue;
			}
			break;
		default:
			if (iscntrl(c))
				continue;
			if (c > 0177)
			{
				cc += sfprintf(op, "\\'%02x", c & 0377);
				tc++;
				continue;
			}
			break;
		}
		if (state.sep && op == state.out)
		{
			state.sep = 0;
			if (c != ' ')
			{
				sfputc(op, ' ');
				cc++;
				tc++;
			}
		}
		lastc = c;
		sfputc(op, c);
		cc++;
		tc++;
	}
 done:
	while (state.sp > state.sp_min)
	{
		error(1, "<%s> on line %d has no matching </%s>", state.sp->tag->name, state.sp->line, state.sp->tag->name);
		state.sp--;
	}
	error_info.file = 0;
	error_info.line = 0;
}

/*
 * return 1 if project file must be updated
 */

static int
project_update(const char* s, char* v, void* h)
{
	NoP(s);
	return v == (char*)h;
}

/*
 * list project file names
 */

static int
project_list(const char* s, char* v, void* h)
{
	NoP(v);
	sfputr((Sfio_t*)h, s, '\n');
	return 0;
}

/*
 * create/update help project file
 */

static void
project(char* file)
{
	register char*	s;
	Sfio_t*		fp;

	if (state.files)
	{
		if (fp = sfopen(NiL, file, "r"))
		{
			while (s = sfgetr(fp, '\n', 1))
			{
				if (*s == '[' && !strncasecmp(s, "[FILES]", 7))
				{
					while ((s = sfgetr(fp, '\n', 1)) && *s != '[')
						hashput(state.files, s, &state);
					if (!s)
						break;
				}
				sfputr(state.tmp, s, '\n');
			}
			sfclose(fp);
			if (!(s = sfstruse(state.tmp)))
				error(ERROR_SYSTEM|3, "out of space");
		}
		else
			s = "\
[OPTIONS]\n\
COMPRESS=TRUE\n\
REPORT=ON\n\
TITLE=Manual\n\
";
		if (hashwalk(state.files, 0, project_update, state.files))
		{
			if (!(fp = sfopen(NiL, file, "w")))
				error(ERROR_SYSTEM|2, "%s: cannot write", file);
			else
			{
				sfputr(fp, s, -1);
				sfputr(fp, "[FILES]", '\n');
				hashwalk(state.files, 0, project_list, fp);
				sfclose(fp);
			}
		}
	}
}

/*
 * html to rtf entity reference map
 */

static const Entity_t entities[] =
{
	"AElig",	"\\'c6",	0,
	"Aacute",	"\\'c1",	0,
	"Acirc",	"\\'c2",	0,
	"Agrave",	"\\'c0",	0,
	"Aring",	"\\'c5",	0,
	"Atilde",	"\\'c3",	0,
	"Auml",		"\\'c4",	0,
	"Ccedil",	"\\'c7",	0,
	"ETH",		"\\'d0",	0,
	"Eacute",	"\\'c9",	0,
	"Ecirc",	"\\'ca",	0,
	"Egrave",	"\\'c8",	0,
	"Euml",		"\\'cb",	0,
	"Iacute",	"\\'cd",	0,
	"Icirc",	"\\'ce",	0,
	"Igrave",	"\\'cc",	0,
	"Iuml",		"\\'cf",	0,
	"Ntilde",	"\\'d1",	0,
	"Oacute",	"\\'d3",	0,
	"Ocirc",	"\\'d4",	0,
	"Ograve",	"\\'d2",	0,
	"Oslash",	"\\'d8",	0,
	"Otilde",	"\\'d5",	0,
	"Ouml",		"\\'d6",	0,
	"THORN",	"\\'de",	0,
	"Uacute",	"\\'da",	0,
	"Ucirc",	"\\'db",	0,
	"Ugrave",	"\\'d9",	0,
	"Uuml",		"\\'dc",	0,
	"Yacute",	"\\'dd",	0,
	"aacute",	"\\'e1",	0,
	"acirc",	"\\'e2",	0,
	"acute",	"\\'b4",	0,
	"aelig",	"\\'e6",	0,
	"agrave",	"\\'e0",	0,
	"amp",		"&",		0,
	"aring",	"\\'e5",	0,
	"atilde",	"\\'e3",	0,
	"auml",		"\\'e4",	0,
	"brvbar",	"\\'a6",	0,
	"ccedil",	"\\'e7",	0,
	"cedil",	"\\'b8",	0,
	"cent",		"\\'a2",	0,
	"copy",		"\\'a9",	0,
	"curren",	"\\'a4",	0,
	"deg",		"\\'b0",	0,
	"divide",	"\\'f7",	0,
	"eacute",	"\\'e9",	0,
	"ecirc",	"\\'ea",	0,
	"egrave",	"\\'e8",	0,
	"emdash",	"\\emdash",	0,
	"emspace",	"\\emspace",	ENT_SPACE,
	"endash",	"\\endash",	0,
	"enspace",	"\\enspace",	ENT_SPACE,
	"eth",		"\\'f0",	0,
	"euml",		"\\'eb",	0,
	"frac12",	"\\'bd",	0,
	"frac14",	"\\'bc",	0,
	"frac34",	"\\'be",	0,
	"gt",		">",		0,
	"iacute",	"\\'ed",	0,
	"icirc",	"\\'ee",	0,
	"iexcl",	"\\'a1",	0,
	"igrave",	"\\'ec",	0,
	"iquest",	"\\'bf",	0,
	"iuml",		"\\'ef",	0,
	"laquo",	"\\'ab",	0,
	"lt",		"<",		0,
	"macr",		"\\'af",	0,
	"micro",	"\\'b5",	0,
	"middot",	"\\bullet",	0,
	"nbsp",		"\\~",		ENT_SPACE,
	"not",		"\\'ac",	0,
	"ntilde",	"\\'f1",	0,
	"oacute",	"\\'f3",	0,
	"ocirc",	"\\'f4",	0,
	"ograve",	"\\'f2",	0,
	"ordf",		"\\'aa",	0,
	"ordm",		"\\'ba",	0,
	"oslash",	"\\'f8",	0,
	"otilde",	"\\'f5",	0,
	"ouml",		"\\'f6",	0,
	"para",		"\\'b6",	0,
	"plusmn",	"\\'b1",	0,
	"pound",	"\\'a3",	0,
	"quot",		"\"",		0,
	"raquo",	"\\'bb",	0,
	"reg",		"\\'ae",	0,
	"sect",		"\\'a7",	0,
	"shy",		"\\'ad",	0,
	"sup1",		"\\'b9",	0,
	"sup2",		"\\'b2",	0,
	"sup3",		"\\'b3",	0,
	"szlig",	"\\'df",	0,
	"thorn",	"\\'fe",	0,
	"times",	"\\'d7",	0,
	"uacute",	"\\'fa",	0,
	"ucirc",	"\\'fb",	0,
	"ugrave",	"\\'f9",	0,
	"uml",		"\\'a8",	0,
	"uuml",		"\\'fc",	0,
	"yacute",	"\\'fd",	0,
	"yen",		"\\'a5",	0,
	"yuml",		"\\'ff",	0,
#if 0
	"trademark",	"",		0,
#endif
};

/*
 * html tag table
 */

static const Tag_t tags[] =
{
	"A",		start_a,	end_a,		0,0,
	"ADDRESS",	start_i,	end,		0,0,
	"B",		start_b,	end,		0,0,
	"BLOCKQUOTE",	start_bq,	end_bq,		0,0,
	"BQ",		start_bq,	end_bq,		0,0,
	"BODY",		start_body,	end,		0,0,
	"BR",		start_br,	0,		0,0,
	"CAPTION",	start_caption,	end,		0,0,
	"CENTER",	start_center,	end_center,	0,0,
	"CITE",		start_i,	end,		0,0,
	"CODE",		start_tt,	end,		0,0,
	"DD",		start_dd,	0,		0,0,
	"DIR",		start_ul,	end_LIST,	0,0,
	"DL",		start_dl,	end_LIST,	0,0,
	"DT",		start_dt,	0,		0,0,
	"EM",		start_i,	end,		0,0,
	"FN",		start_fn,	end_fn,		0,0,
	"FONT",		start_font,	end_font,	0,0,
	"H1",		start_H,	end_H,		0,0,
	"H2",		start_H,	end_H,		0,0,
	"H3",		start_H,	end_H,		0,0,
	"H4",		start_H,	end_H,		0,0,
	"H5",		start_H,	end_H,		0,0,
	"H6",		start_H,	end_H,		0,0,
	"HEAD",		start_head,	end_head,	0,TAG_UNBALANCED,
	"HR",		start_hr,	0,		0,0,
	"HTML",		start_html,	end_html,	0,0,
	"I",		start_i,	end,		0,0,
	"IMG",		start_img,	0,		0,0,
	"KBD",		start_tt,	end,		0,0,
	"LI",		start_li,	0,		0,TAG_UNBALANCED,
	"META",		start_meta,	0,		0,0,
	"MENU",		start_ul,	end_LIST,	0,0,
	"NULL",		0,		0,		0,0,
	"OL",		start_ol,	end_LIST,	0,0,
	"P",		start_p,	0,		0,TAG_UNBALANCED,
	"PRE",		start_pre,	end_pre,	0,0,
	"RENDER",	start_render,	0,		0,0,
	"SAMP",		start_tt,	end,		0,0,
	"STRONG",	start_b,	end,		0,0,
	"SUB",		start_sub,	end_sub,	0,0,
	"SUP",		start_sup,	end_sup,	0,0,
	"TABLE",	start_table,	end_table,	0,0,
	"TD",		start_td,	end_td,		0,0,
	"TH",		start_th,	0,		0,0,
	"TITLE",	start_title,	end_title,	0,TAG_IGNORE,
	"TR",		start_tr,	end_tr,		0,0,
	"TT",		start_tt,	end,		0,0,
	"UL",		start_ul,	end_LIST,	0,0,
	"UNKNOWN",	0,		0,		0,0,
	"VAR",		start_var,	end,		0,0,
};

/*
 * case insensitive hash
 */

static unsigned int
strcasehash(const char* s)
{
	register const unsigned char*	p = (const unsigned char*)s;
	register unsigned int		h = 0;
	register unsigned int		c;

	while (c = *p++)
	{
		if (isupper(c))
			c = tolower(c);
		HASHPART(h, c);
	}
	return h;
}

/*
 * initialize the global data
 */

static void
init(void)
{
	register int	i;

	if (!state.nul && !(state.nul = sfstropen()))
		error(ERROR_SYSTEM|3, "out of space [nul buffer]");
	if (!state.tmp && !(state.tmp = sfstropen()))
		error(ERROR_SYSTEM|3, "out of space [tmp buffer]");
	i = 1024;
	if (!(state.sp_min = oldof(NiL, Stack_t, i, 0)))
		error(ERROR_SYSTEM|3, "out of space [tag stack]");
	state.sp_max = state.sp_min + i - 1;
	if (!(state.entities = hashalloc(NiL, HASH_name, "entities", 0)))
		error(ERROR_SYSTEM|3, "out of space [entity hash]");
	if (!(state.tags = hashalloc(NiL, HASH_compare, strcasecmp, HASH_hash, strcasehash, HASH_name, "tags", 0)))
		error(ERROR_SYSTEM|3, "out of space [tag hash]");
	if (state.project && !(state.files = hashalloc(state.tags, HASH_set, HASH_ALLOCATE, HASH_name, "files", 0)))
		error(ERROR_SYSTEM|3, "out of space [file hash]");
	for (i = 0; i < elementsof(entities); i++)
		if (!(hashput(state.entities, entities[i].name, &entities[i])))
			error(ERROR_SYSTEM|3, "out of space [entity hash put]");
	for (i = 0; i < elementsof(tags); i++)
		if (!(hashput(state.tags, tags[i].name, &tags[i])))
			error(ERROR_SYSTEM|3, "out of space [tag hash put]");
	hashset(state.tags, HASH_ALLOCATE);
}

int
main(int argc, char** argv)
{
	register int		c;
	register char*		s;
	register char*		t;
	register char*		u;
	register Sfio_t*	ip;
	register Sfio_t*	op;

	NoP(argc);
	error_info.id = "html2rtf";
	state.fontsize = FONTSIZE;
	for (;;)
	{
		switch (optget(argv, usage))
		{
		case 'd':
			error_info.trace = -opt_info.num;
			continue;
		case 'f':
			state.fontsize = opt_info.num;
			continue;
		case 'p':
			state.project = opt_info.arg;
			continue;
		case 'v':
			state.verbose = 1;
			continue;
		case '?':
			error(ERROR_USAGE|4, "%s", opt_info.arg);
			continue;
		case ':':
			error(2, "%s", opt_info.arg);
			continue;
		}
		break;
	}
	argv += opt_info.index;
	if (error_info.errors)
		error(ERROR_USAGE|4, "%s", optusage(NiL));
	init();
	if (!*argv)
	{
		if (state.project)
			error(ERROR_SYSTEM|3, "%s: input files required when project file specified", state.project);
		process(NiL, sfstdin, sfstdout);
	}
	else while (s = *argv++)
	{
		if (ip = sfopen(NiL, s, "r"))
		{
			if (state.project)
			{
				if (!(t = strrchr(s, '/')))
					t = s;
				if (u = strrchr(t, '.'))
					c = u - t;
				else
					c = strlen(t);
				sfprintf(state.tmp, "%-.*s.rtf", c, t);
				if (!(u = sfstruse(state.tmp)))
					error(ERROR_SYSTEM|3, "out of space");
				if (!(op = sfopen(NiL, u, "w")))
				{
					error(ERROR_SYSTEM|2, "%s: cannot write", u);
					sfclose(ip);
					continue;
				}
				hashput(state.files, u, state.files);
				while (c = *t++)
					sfputc(state.tmp, isalnum(c) ? c : '.');
				if (!(state.prefix = strdup(sfstruse(state.tmp))))
					error(ERROR_SYSTEM|3, "out of space");
			}
			else
			{
				state.prefix = "HTML2RTF";
				op = sfstdout;
			}
			process(s, ip, op);
			sfclose(ip);
			if (state.project)
			{
				sfclose(op);
				free(state.prefix);
			}
		}
		else error(ERROR_SYSTEM|2, "%s: cannot read", s);
	}
	if (state.project)
		project(state.project);
	exit(error_info.errors != 0);
}