xref: /plan9/sys/src/cmd/htmlroff/roff.c (revision 426d2b71458df9b491ba6c167f699b3f1f7b0428)

#include "a.h"

enum
{
	MAXREQ = 100,
	MAXRAW = 40,
	MAXESC = 60,
	MAXLINE = 1024,
	MAXIF = 20,
	MAXARG = 10,
};

typedef struct Esc Esc;
typedef struct Req Req;
typedef struct Raw Raw;

/* escape sequence handler, like for \c */
struct Esc
{
	Rune r;
	int (*f)(void);
	int mode;
};

/* raw request handler, like for .ie */
struct Raw
{
	Rune *name;
	void (*f)(Rune*);
};

/* regular request handler, like for .ft */
struct Req
{
	int argc;
	Rune *name;
	void (*f)(int, Rune**);
};

int		dot = '.';
int		tick = '\'';
int		backslash = '\\';

int		inputmode;
Req		req[MAXREQ];
int		nreq;
Raw		raw[MAXRAW];
int		nraw;
Esc		esc[MAXESC];
int		nesc;
int		iftrue[MAXIF];
int		niftrue;

int isoutput;
int linepos;


void
addraw(Rune *name, void (*f)(Rune*))
{
	Raw *r;

	if(nraw >= nelem(raw)){
		fprint(2, "too many raw requets\n");
		return;
	}
	r = &raw[nraw++];
	r->name = erunestrdup(name);
	r->f = f;
}

void
delraw(Rune *name)
{
	int i;

	for(i=0; i<nraw; i++){
		if(runestrcmp(raw[i].name, name) == 0){
			if(i != --nraw){
				free(raw[i].name);
				raw[i] = raw[nraw];
			}
			return;
		}
	}
}

void
renraw(Rune *from, Rune *to)
{
	int i;

	delraw(to);
	for(i=0; i<nraw; i++)
		if(runestrcmp(raw[i].name, from) == 0){
			free(raw[i].name);
			raw[i].name = erunestrdup(to);
			return;
		}
}


void
addreq(Rune *s, void (*f)(int, Rune**), int argc)
{
	Req *r;

	if(nreq >= nelem(req)){
		fprint(2, "too many requests\n");
		return;
	}
	r = &req[nreq++];
	r->name = erunestrdup(s);
	r->f = f;
	r->argc = argc;
}

void
delreq(Rune *name)
{
	int i;

	for(i=0; i<nreq; i++){
		if(runestrcmp(req[i].name, name) == 0){
			if(i != --nreq){
				free(req[i].name);
				req[i] = req[nreq];
			}
			return;
		}
	}
}

void
renreq(Rune *from, Rune *to)
{
	int i;

	delreq(to);
	for(i=0; i<nreq; i++)
		if(runestrcmp(req[i].name, from) == 0){
			free(req[i].name);
			req[i].name = erunestrdup(to);
			return;
		}
}

void
addesc(Rune r, int (*f)(void), int mode)
{
	Esc *e;

	if(nesc >= nelem(esc)){
		fprint(2, "too many escapes\n");
		return;
	}
	e = &esc[nesc++];
	e->r = r;
	e->f = f;
	e->mode = mode;
}

/*
 * Get the next logical character in the input stream.
 */
int
getnext(void)
{
	int i, r;

next:
	r = getrune();
	if(r < 0)
		return -1;
	if(r == Uformatted){
		br();
		assert(!isoutput);
		while((r = getrune()) >= 0 && r != Uunformatted){
			if(r == Uformatted)
				continue;
			outrune(r);
		}
		goto next;
	}
	if(r == Uunformatted)
		goto next;
	if(r == backslash){
		r = getrune();
		if(r < 0)
			return -1;
		for(i=0; i<nesc; i++){
			if(r == esc[i].r && (inputmode&esc[i].mode)==inputmode){
				if(esc[i].f == e_warn)
					warn("ignoring %C%C", backslash, r);
				r = esc[i].f();
				if(r <= 0)
					goto next;
				return r;
			}
		}
		if(inputmode&(ArgMode|CopyMode)){
			ungetrune(r);
			r = backslash;
		}
	}
	return r;
}

void
ungetnext(Rune r)
{
	/*
	 * really we want to undo the getrunes that led us here,
	 * since the call after ungetnext might be getrune!
	 */
	ungetrune(r);
}

int
_readx(Rune *p, int n, int nmode, int line)
{
	int c, omode;
	Rune *e;

	while((c = getrune()) == ' ' || c == '\t')
		;
	ungetrune(c);
	omode = inputmode;
	inputmode = nmode;
	e = p+n-1;
	for(c=getnext(); p<e; c=getnext()){
		if(c < 0)
			break;
		if(!line && (c == ' ' || c == '\t'))
			break;
		if(c == '\n'){
			if(!line)
				ungetnext(c);
			break;
		}
		*p++ = c;
	}
	inputmode = omode;
	*p = 0;
	if(c < 0)
		return -1;
	return 0;
}

/*
 * Get the next argument from the current line.
 */
Rune*
copyarg(void)
{
	static Rune buf[MaxLine];
	int c;
	Rune *r;

	if(_readx(buf, sizeof buf, ArgMode, 0) < 0)
		return nil;
	r = runestrstr(buf, L("\\\""));
	if(r){
		*r = 0;
		while((c = getrune()) >= 0 && c != '\n')
			;
		ungetrune('\n');
	}
	r = erunestrdup(buf);
	return r;
}

/*
 * Read the current line in given mode.  Newline not kept.
 * Uses different buffer from copyarg!
 */
Rune*
readline(int m)
{
	static Rune buf[MaxLine];
	Rune *r;

	if(_readx(buf, sizeof buf, m, 1) < 0)
		return nil;
	r = erunestrdup(buf);
	return r;
}

/*
 * Given the argument line (already read in copy+arg mode),
 * parse into arguments.  Note that \" has been left in place
 * during copy+arg mode parsing, so comments still need to be stripped.
 */
int
parseargs(Rune *p, Rune **argv)
{
	int argc;
	Rune *w;

	for(argc=0; argc<MAXARG; argc++){
		while(*p == ' ' || *p == '\t')
			p++;
		if(*p == 0)
			break;
		argv[argc] = p;
		if(*p == '"'){
			/* quoted argument */
			if(*(p+1) == '"'){
				/* empty argument */
				*p = 0;
				p += 2;
			}else{
				/* parse quoted string */
				w = p++;
				for(; *p; p++){
					if(*p == '"' && *(p+1) == '"')
						*w++ = '"';
					else if(*p == '"'){
						p++;
						break;
					}else
						*w++ = *p;
				}
				*w = 0;
			}
		}else{
			/* unquoted argument - need to watch out for \" comment */
			for(; *p; p++){
				if(*p == ' ' || *p == '\t'){
					*p++ = 0;
					break;
				}
				if(*p == '\\' && *(p+1) == '"'){
					*p = 0;
					if(p != argv[argc])
						argc++;
					return argc;
				}
			}
		}
	}
	return argc;
}

/*
 * Process a dot line.  The dot has been read.
 */
void
dotline(int dot)
{
	int argc, i;
	Rune *a, *argv[1+MAXARG];

	/*
	 * Read request/macro name
	 */
	a = copyarg();
	if(a == nil || a[0] == 0){
		free(a);
		getrune();	/* \n */
		return;
	}
	argv[0] = a;
	/*
	 * Check for .if, .ie, and others with special parsing.
	 */
	for(i=0; i<nraw; i++){
		if(runestrcmp(raw[i].name, a) == 0){
			raw[i].f(raw[i].name);
			free(a);
			return;
		}
	}

	/*
	 * Read rest of line in copy mode, invoke regular request.
	 */
	a = readline(ArgMode);
	if(a == nil){
		free(argv[0]);
		return;
	}
	argc = 1+parseargs(a, argv+1);
	for(i=0; i<nreq; i++){
		if(runestrcmp(req[i].name, argv[0]) == 0){
			if(req[i].argc != -1){
				if(argc < 1+req[i].argc){
					warn("not enough arguments for %C%S", dot, req[i].name);
					free(argv[0]);
					free(a);
					return;
				}
				if(argc > 1+req[i].argc)
					warn("too many arguments for %C%S", dot, req[i].name);
			}
			req[i].f(argc, argv);
			free(argv[0]);
			free(a);
			return;
		}
	}

	/*
	 * Invoke user-defined macros.
	 */
	runmacro(dot, argc, argv);
	free(argv[0]);
	free(a);
}

/*
 * newlines are magical in various ways.
 */
int bol;
void
newline(void)
{
	int n;

	if(bol)
		sp(eval(L("1v")));
	bol = 1;
	if((n=getnr(L(".ce"))) > 0){
		nr(L(".ce"), n-1);
		br();
	}
	if(getnr(L(".fi")) == 0)
		br();
	outrune('\n');
}

void
startoutput(void)
{
	char *align;
	double ps, vs, lm, rm, ti;
	Rune buf[200];

	if(isoutput)
		return;
	isoutput = 1;

	if(getnr(L(".paragraph")) == 0)
		return;

	nr(L(".ns"), 0);
	isoutput = 1;
	ps = getnr(L(".s"));
	if(ps <= 1)
		ps = 10;
	ps /= 72.0;
	USED(ps);

	vs = getnr(L(".v"))*getnr(L(".ls")) * 1.0/UPI;
	vs /= (10.0/72.0);	/* ps */
	if(vs == 0)
		vs = 1.2;

	lm = (getnr(L(".o"))+getnr(L(".i"))) * 1.0/UPI;
	ti = getnr(L(".ti")) * 1.0/UPI;
	nr(L(".ti"), 0);

	rm = 8.0 - getnr(L(".l"))*1.0/UPI - getnr(L(".o"))*1.0/UPI;
	if(rm < 0)
		rm = 0;
	switch(getnr(L(".j"))){
	default:
	case 0:
		align = "left";
		break;
	case 1:
		align = "justify";
		break;
	case 3:
		align = "center";
		break;
	case 5:
		align = "right";
		break;
	}
	if(getnr(L(".ce")))
		align = "center";
	if(!getnr(L(".margin")))
		runesnprint(buf, nelem(buf), "<p style=\"line-height: %.1fem; text-indent: %.2fin; margin-top: 0; margin-bottom: 0; text-align: %s;\">\n",
			vs, ti, align);
	else
		runesnprint(buf, nelem(buf), "<p style=\"line-height: %.1fem; margin-left: %.2fin; text-indent: %.2fin; margin-right: %.2fin; margin-top: 0; margin-bottom: 0; text-align: %s;\">\n",
			vs, lm, ti, rm, align);
	outhtml(buf);
}
void
br(void)
{
	if(!isoutput)
		return;
	isoutput = 0;

	nr(L(".dv"), 0);
	dv(0);
	hideihtml();
	if(getnr(L(".paragraph")))
		outhtml(L("</p>"));
}

void
r_margin(int argc, Rune **argv)
{
	USED(argc);

	nr(L(".margin"), eval(argv[1]));
}

int inrequest;
void
runinput(void)
{
	int c;

	bol = 1;
	for(;;){
		c = getnext();
		if(c < 0)
			break;
		if((c == dot || c == tick) && bol){
			inrequest = 1;
			dotline(c);
			bol = 1;
			inrequest = 0;
		}else if(c == '\n'){
			newline();
			itrap();
			linepos = 0;
		}else{
			outtrap();
			startoutput();
			showihtml();
			if(c == '\t'){
				/* XXX do better */
				outrune(' ');
				while(++linepos%4)
					outrune(' ');
			}else{
				outrune(c);
				linepos++;
			}
			bol = 0;
		}
	}
}

void
run(void)
{
	t1init();
	t2init();
	t3init();
	t4init();
	t5init();
	t6init();
	t7init();
	t8init();
	/* t9init(); t9.c */
	t10init();
	t11init();
	/* t12init(); t12.c */
	t13init();
	t14init();
	t15init();
	t16init();
	t17init();
	t18init();
	t19init();
	t20init();
	htmlinit();
	hideihtml();

	addreq(L("margin"), r_margin, 1);
	nr(L(".margin"), 1);
	nr(L(".paragraph"), 1);

	runinput();
	while(popinput())
		;
	dot = '.';
	if(verbose)
		fprint(2, "eof\n");
	runmacro1(L("eof"));
	closehtml();
}

void
out(Rune *s)
{
	if(s == nil)
		return;
	for(; *s; s++)
		outrune(*s);
}

void (*outcb)(Rune);

void
inroman(Rune r)
{
	int f;

	f = getnr(L(".f"));
	nr(L(".f"), 1);
	runmacro1(L("font"));
	outrune(r);
	nr(L(".f"), f);
	runmacro1(L("font"));
}

void
Brune(Rune r)
{
	if(r == '&')
		Bprint(&bout, "&amp;");
	else if(r == '<')
		Bprint(&bout, "&lt;");
	else if(r == '>')
		Bprint(&bout, "&gt;");
	else if(r < Runeself || utf8)
		Bprint(&bout, "%C", r);
	else
		Bprint(&bout, "%S", rune2html(r));
}

void
outhtml(Rune *s)
{
	Rune r;

	for(; *s; s++){
		switch(r = *s){
		case '<':
			r = Ult;
			break;
		case '>':
			r = Ugt;
			break;
		case '&':
			r = Uamp;
			break;
		case ' ':
			r = Uspace;
			break;
		}
		outrune(r);
	}
}

void
outrune(Rune r)
{
	switch(r){
	case ' ':
		if(getnr(L(".fi")) == 0)
			r = Unbsp;
		break;
	case Uformatted:
	case Uunformatted:
		abort();
	}
	if(outcb){
		if(r == ' ')
			r = Uspace;
		outcb(r);
		return;
	}
	/* writing to bout */
	switch(r){
	case Uempty:
		return;
	case Upl:
		inroman('+');
		return;
	case Ueq:
		inroman('=');
		return;
	case Umi:
		inroman(0x2212);
		return;
	case Utick:
		r = '\'';
		break;
	case Ubtick:
		r = '`';
		break;
	case Uminus:
		r = '-';
		break;
	case '\'':
		Bprint(&bout, "&rsquo;");
		return;
	case '`':
		Bprint(&bout, "&lsquo;");
		return;
	case Uamp:
		Bputrune(&bout, '&');
		return;
	case Ult:
		Bputrune(&bout, '<');
		return;
	case Ugt:
		Bputrune(&bout, '>');
		return;
	case Uspace:
		Bputrune(&bout, ' ');
		return;
	case 0x2032:
		/*
		 * In Firefox, at least, the prime is not
		 * a superscript by default.
		 */
		Bprint(&bout, "<sup>");
		Brune(r);
		Bprint(&bout, "</sup>");
		return;
	}
	Brune(r);
}

void
r_nop(int argc, Rune **argv)
{
	USED(argc);
	USED(argv);
}

void
r_warn(int argc, Rune **argv)
{
	USED(argc);
	warn("ignoring %C%S", dot, argv[0]);
}

int
e_warn(void)
{
	/* dispatch loop prints a warning for us */
	return 0;
}

int
e_nop(void)
{
	return 0;
}