#include <u.h>
#include <libc.h>
#include <bio.h>
#include <ctype.h>

typedef struct Symbol Symbol;
typedef struct Event Event;
typedef struct Signal Signal;

struct Symbol {
	char *name;
	int t;
	double e;
	Symbol *next;
};
struct Event {
	double t;
	int val;
	Event *next;
	char *data;
	int line;
};
struct Signal {
	char *name;
	Event *ev;
	Signal *next;
};

int lineno, lastc, peeked;
char sname[512];
double sval;
double width, rheight;
double mint, maxt;
double left, right;
int nsig;
Biobuf *bp;
Symbol *stab[256];
Signal *sigfirst, **siglast = &sigfirst;

enum {
	SYMFREE,
	SYMNUM,
};

enum {
	VZ,
	VX,
	VL,
	VH,
	VMULT,
};

enum {
	CMD = -1,
	SYM = -2,
	NUM = -3,
	EOF = -4,
	STR = -5,
};

static int
Tfmt(Fmt *f)
{
	int n;
	
	n = va_arg(f->args, int);
	if(n >= 0 && n < 0x80 && isprint(n))
		return fmtprint(f, "'%c'", n);
	else
		switch(n){
		case CMD: return fmtprint(f, ".%s", sname);
		case SYM: return fmtprint(f, "'%s'", sname);
		case NUM: return fmtprint(f, "%g", sval);
		case EOF: return fmtprint(f, "EOF");
		case STR: return fmtprint(f, "%#q", sname);
		default: return fmtprint(f, "%d", n);
		}
}

static void *
emalloc(int n)
{
	void *v;
	
	v = malloc(n);
	if(v == nil)
		sysfatal("malloc: %r");
	memset(v, 0, n);
	setmalloctag(v, getcallerpc(&n));
	return v;
}

static void
error(int l, char *fmt, ...)
{
	va_list va;
	char *s;
	
	va_start(va, fmt);
	s = vsmprint(fmt, va);
	fprint(2, "%d %s\n", l, s);
	free(s);
	va_end(va);
}

static int
hash(char *s)
{
	int c;

	for(c = 0; *s != 0; s++)
		c += *s;
	return c;
}

static Symbol *
getsym(char *st)
{
	Symbol *s, **p;
	
	for(p = &stab[hash(st)%nelem(stab)]; s = *p, s != nil; p = &s->next){
		if(strcmp(s->name, st) == 0)
			return s;
	}
	s = emalloc(sizeof(Symbol));
	s->name = strdup(st);
	*p = s;
	return s;
}

static int
issym(int c)
{
	return isalnum(c) || c == '_' || c >= 0x80;
}

static int
numfsm(int c, int *st)
{
	enum {
		PREDOT,
		POSTDOT,
		ESIGN,
		EDIG
	};
	
	switch(*st){
	case PREDOT:
		if(c == '.')
			*st = POSTDOT;
		if(c == 'e')
			*st = ESIGN;
		return isdigit(c) || c == '.' || c == 'e';
	case POSTDOT:
		if(c == 'e')
			*st = ESIGN;
		return isdigit(c) || c == 'e';
	case ESIGN:
		*st = EDIG;
		return isdigit(c) || c == '+' || c == '-';
	case EDIG:
		return isdigit(c);
	}
	return 0;
}

static int
lex(void)
{
	int c;
	char *p;
	int st;

	do{
		c = Bgetc(bp);
		if(c < 0)
			return EOF;
		if(!isspace(c))
			break;
		if(c == '\n')
			lineno++;
		lastc = c;
	}while(1);
	
	if(lastc == 10 && c == '.'){
		for(p = sname; c = Bgetc(bp), issym(c); )
			if(p < sname + sizeof(sname) - 1)
				*p++ = c;
		Bungetc(bp);
		*p = 0;
		return CMD;
	}
	if(isdigit(c) || c == '.'){
		st = 0;
		for(p = sname; numfsm(c, &st); c = Bgetc(bp))
			if(p < sname + sizeof(sname) - 1)
				*p++ = c;
		Bungetc(bp);
		*p = 0;
		sval = strtol(sname, &p, 0);
		if(*p != 0)
			sval = strtod(sname, &p);
		if(*p != 0)
			error(lineno, "invalid number %s", sname);
		return NUM;
	}
	if(issym(c)){
		for(p = sname; issym(c); c = Bgetc(bp))
			if(p < sname + sizeof(sname) - 1)
				*p++ = c;
		Bungetc(bp);
		*p = 0;
		return SYM;
	}
	if(c == '\''){
		for(p = sname; c = Bgetc(bp), c != '\'' || Bgetc(bp) == '\''; )
			if(p < sname + sizeof(sname) - 1)
				*p++ = c;
		Bungetc(bp);
		*p = 0;
		return STR;
	}
	return c;
}

static int
next(void)
{
	int rc;

	if(peeked != 0){
		rc = peeked;
		peeked = 0;
		return rc;
	}
	return lex();
}

static int
peek(void)
{
	if(peeked == 0)
		peeked = lex();
	return peeked;
}

static void
expect(int n)
{
	int s;

	if((s = peek()) != n)
		error(lineno, "expected %T, got %T", n, s);
	else
		next();
}

static double expr(void);

static double
factor(void)
{
	int t;
	double g;
	Symbol *s;

	switch(t = next()){
	case NUM:
		return sval;
	case SYM:
		s = getsym(sname);
		if(s->t != SYMNUM)
			error(lineno, "not a number: %s", s->name);
		return s->e;
	case '(':
		g = expr();
		expect(')');
		return g;
	default:
		error(lineno, "factor: unexpected %T", t);
		return 0;
	}
}

static double
term(void)
{
	double g;

	g = factor();
	while(peek() == '*' || peek() == '/'){
		switch(next()){
		case '*': g *= factor(); break;
		case '/': g /= factor(); break;
		}
	}
	return g;
}

static double
expr(void)
{
	int s;
	double g;
	
	s = 1;
	if(peek() == '+' || peek() == '-')
		s = next() == '-' ? -1 : 1;
	g = s * term();
	while(peek() == '+' || peek() == '-'){
		s = next() == '-' ? -1 : 1;
		g += s * term();
	}
	return g;
}

static void
assign(Symbol *s)
{
	next();
	if(s->t != SYMFREE){
		error(lineno, "symbol already exists: %s", s->name);
		return;
	}
	s->t = SYMNUM;
	s->e = expr();
	expect(';');
}

static int
parseval(Event *e)
{
	int t;
	
	switch(t = next()){
	case SYM:
		if(strcmp(sname, "x") == 0)
			return VX;
		if(strcmp(sname, "z") == 0)
			return VZ;
		e->data = strdup(sname);
		return VMULT;
	case NUM:
		if(sval == 0)
			return VL;
		if(sval == 1)
			return VH;
		e->data = smprint("%g", sval);
		return VMULT;
	case STR:
		e->data = strdup(sname);
		return VMULT;
	default:
		error(lineno, "unexpected %T", t);
		return VZ;
	}
}

static void
append(double off, Event ***ep, Event *e)
{
	Event *f;
	
	for(; e != nil; e = e->next){
		f = emalloc(sizeof(Event));
		f->t = e->t + off;
		f->val = e->val;
		f->line = e->line;
		if(e->data != nil)
			f->data = strdup(e->data);
		**ep = f;
		*ep = &f->next;
	}
}

static void
freeev(Event *e)
{
	Event *en;
	
	for(; e != nil; e = en){
		en = e->next;
		free(e->data);
		free(e);
	}
}

static Event *
events(double *off, int ronly)
{
	int rela;
	Event *e, *ev, **ep;
	int i, n;
	double f;
	Symbol *sy;
	double len;
	int line;
	
	rela = 0;
	line = 0;
	ev = nil;
	ep = &ev;
	for(;;)
		switch(peek()){
		case '+':
			rela = 1;
			next();
			break;
		case '}':
		case ';':
			return ev;
		case ':':
			next();
			e = emalloc(sizeof(Event));
			e->t = *off;
			e->val = parseval(e);
			e->line = line;
			line = 0;
			*ep = e;
			ep = &e->next;
			break;
		case '|':
			line = 1;
			next();
			break;
		default:
			f = expr();
			if(peek() == '{'){
				next();
				if(f < 0 || isNaN(f) || f >= 0x7fffffff){
					error(lineno, "invalid repeat count");
					f = 0;
				}
				len = 0;
				e = events(&len, 1);
				expect('}');
				n = f + 0.5;
				for(i = 0; i < n; i++){
					append(*off, &ep, e);
					*off += len;
				}
				if(*off > maxt) maxt = *off;
				freeev(e);
				break;
			}
			if(ronly && !rela){
				error(lineno, "only relative addressing allowed");
				rela = 1;
			}
			if(peek() == SYM){
				next();
				sy = getsym(sname);
				if(sy->t == SYMFREE)
					error(lineno, "undefined %s", sy->name);
				else
					f *= sy->e;
			}
			if(rela)
				*off += f;
			else
				*off = f;
			if(peek() == '['){
				next();
				sy = getsym(sname);
				if(sy->t != SYMFREE && sy->t != SYMNUM)
					error(lineno, "already defined %s", sy->name);
				else{
					sy->t = SYMNUM;
					sy->e = *off;
				}
				expect(']');
			}
			if(*off < mint) mint = *off;
			if(*off > maxt) maxt = *off;
			rela = 0;
			break;
		}
	
}

static void
signal(char *st)
{
	Signal *s;
	double off;

	s = emalloc(sizeof(Signal));
	s->name = strdup(st);
	s->ev = events(&off, 0);
	expect(';');
	*siglast = s;
	siglast = &s->next;
	nsig++;
}

static void
slantfill(double x1, double x2, double t, double b, double tw)
{
	double x;
	double sw = 0.05;
	double soff = 0.05;

	for(x = x1; x < x2 - sw; x += soff)
		print("line from %g,%g to %g,%g\n", x, t, x+sw, b);
	if(x < x2)
		print("line from %g,%g to %g,%g\n", x, t, (2*sw*tw+2*tw*x+sw*x2)/(sw+2*tw), (sw*t+t*(x-x2)+b*(2*tw-x+x2))/(sw+2*tw));
}

static void
sigout(Signal *s, double top)
{
	Event *e, *n;
	double l, w, t, b, x1, x2, tw, m;
	
	for(e = s->ev; e != nil && e->next != nil && e->next->t < left; e = e->next)
		;
	if(e == nil)
		return;
	b = top - rheight * 0.75;
	t = top - rheight * 0.25;
	tw = width * 0.003;
	m = (t+b)/2;
	l = width * 0.2;
	w = width * 0.8 / (right - left);
	x1 = l;
	print("\"%s\" ljust at %g,%g\n", s->name, width * 0.1, m);
	while(n = e->next, n != nil && n->t < right){
		x2 = (n->t - left) * w + l;
		if(n->line)
			print("line from %g,%g to %g,%g dashed\n", x2, 0.0, x2, nsig*rheight);
		switch(e->val){
		case VZ:
			print("line from %g,%g to %g,%g\n", x1, m, x2, m);
			break;
		case VL:
			print("line from %g,%g to %g,%g\n", x1, b, x2-tw, b);
			print("line from %g,%g to %g,%g\n", x2-tw, b, x2, m);
			break;
		case VH:
			print("line from %g,%g to %g,%g\n", x1, t, x2-tw, t);
			print("line from %g,%g to %g,%g\n", x2-tw, t, x2, m);
			break;
		case VMULT:
			print("\"%s\" at %g,%g\n", e->data, (x1+x2)/2, m);
			if(0){
		case VX:
				slantfill(x1, x2-tw, t, b, tw);
			}
			print("line from %g,%g to %g,%g\n", x1, b, x2-tw, b);
			print("line from %g,%g to %g,%g\n", x2-tw, b, x2, m);
			print("line from %g,%g to %g,%g\n", x1, t, x2-tw, t);
			print("line from %g,%g to %g,%g\n", x2-tw, t, x2, m);
			break;
		default:
			fprint(2, "unknown event type %d\n", e->val);
		}
		switch(n->val){
		case VL:
			print("line from %g,%g to %g,%g\n", x2, m, x2+tw, b);
			break;
		case VH:
			print("line from %g,%g to %g,%g\n", x2, m, x2+tw, t);
			break;
		case VMULT:
		case VX:
			print("line from %g,%g to %g,%g\n", x2, m, x2+tw, b);
			print("line from %g,%g to %g,%g\n", x2, m, x2+tw, t);
			break;
		}
		e = e->next;
		if(e->val == VZ)
			x1 = x2;
		else
			x1 = x2 + tw;
	}
	x2 = (right - left) * w + l;
	switch(e->val){
	case VZ:
		print("line from %g,%g to %g,%g\n", x1, m, x2, m);
		break;
	case VL:
		print("line from %g,%g to %g,%g\n", x1, b, x2, b);
		break;
	case VH:
		print("line from %g,%g to %g,%g\n", x1, t, x2, t);
		break;
	case VMULT:
		print("\"%s\" at %g,%g\n", e->data, (x1+x2)/2, m);
		if(0){
	case VX:
			slantfill(x1, x2, t, b, tw);
		}
		print("line from %g,%g to %g,%g\n", x1, b, x2, b);
		print("line from %g,%g to %g,%g\n", x1, t, x2, t);
		break;
	default:
		fprint(2, "unknown event type %d\n", e->val);
	}
}

static void
parseopts(char *l)
{
	char *f[3];
	int rc;

	rc = tokenize(l, f, nelem(f));
	if(rc != 3){
		error(lineno, ".TPS wrong syntax");
		return;
	}
	width = strtod(f[1], 0);
	rheight = strtod(f[2], 0);
}

static void
cleansym(void)
{
	Symbol **p, *s, *sn;
	Signal *si, *sin;
	Event *e, *en;
	
	for(p = stab; p < stab + nelem(stab); p++)
		for(s = *p, *p = nil; s != nil; s = sn){

			free(s->name);
			sn = s->next;
			free(s);
		}
	memset(stab, 0, sizeof(stab));
	
	for(si = sigfirst; si != nil; si = sin){
		for(e = si->ev; e != nil; e = en){
			en = e->next;
			free(e);
		}
		free(si->name);
		sin = si->next;
		free(si);
	}
	siglast = &sigfirst;
}

static void
diagram(char *l)
{
	Symbol *s;
	Signal *si;
	int t;
	double top;
	
	lastc = 10;
	mint = 0;
	maxt = 0;
	nsig = 0;
	parseopts(l);

	for(;;){
		switch(t = next()){
		case SYM:
			s = getsym(sname);
			if(peek() == '=')
				assign(s);
			else
				signal(s->name);
			break;
		case STR:
			signal(sname);
			break;
		case CMD:
			if(strcmp(sname, "TPE") == 0)
				goto end;
			error(lineno, "unknown command %s", sname);
			break;
		default:
			error(lineno, "unexpected %T", t);
		}
	}
end:

	print(".PS %g %g\n", width, rheight * nsig);
	left = mint;
	right = maxt;
	top = rheight * nsig;
	for(si = sigfirst; si != nil; si = si->next, top -= rheight)
		sigout(si, top);
	print(".PE\n");
	
	cleansym();
}

static void
run(char *f)
{
	char *l;

	if(f == nil)
		bp = Bfdopen(0, OREAD);
	else
		bp = Bopen(f, OREAD);
	if(bp == nil)
		sysfatal("open: %r");
	Blethal(bp, nil);
	lineno = 1;
	
	for(;;){
		l = Brdstr(bp, '\n', 1);
		if(l == nil)
			break;
		lineno++;
		if(strncmp(l, ".TPS", 4) == 0 && (!l[4] || isspace(l[4])))
			diagram(l);
		else
			print("%s\n", l);
		free(l);
	}
	Bterm(bp);
}

static void
usage(void)
{
	fprint(2, "usage: %s [ files ]\n", argv0);
	exits("usage");
}

void
main(int argc, char **argv)
{
	int i;

	fmtinstall('T', Tfmt);
	quotefmtinstall();

	ARGBEGIN {
	default: usage();
	} ARGEND;
	
	if(argc == 0)
		run(nil);
	else
		for(i = 0; i < argc; i++)
			run(argv[i]);
	
	exits(nil);
}