#include <u.h>
#include <libc.h>
#include <ctype.h>
#include <dtracy.h>
#include <bio.h>
#include "dat.h"
#include "fns.h"
#include "y.tab.h"

char *str, *strp, *stre;
int lineno = 1;
int errors;

typedef struct Keyword Keyword;
struct Keyword {
	char *name;
	int tok;
};
/* both tables must be sorted */
Keyword kwtab[] = {
	"if", TIF,
	"print", TPRINT,
	"printf", TPRINTF,
	"s16", TS16,
	"s32", TS32,
	"s64", TS64,
	"s8", TS8,
	"string", TSTRING,
	"u16", TU16,
	"u32", TU32,
	"u64", TU64,
	"u8", TU8,
};
Keyword optab[] = {
	"!=", TNE,
	"&&", TAND,
	"<<", TLSL,
	"<=", TLE,
	"==", TEQ,
	">=", TGE,
	">>", TLSR,
	"||", TOR,
};
Keyword *kwchar[128], *opchar[128];

void
lexinit(void)
{
	Keyword *kw;
	
	for(kw = kwtab; kw < kwtab + nelem(kwtab); kw++)
		if(kwchar[*kw->name] == nil)
			kwchar[*kw->name] = kw;
	for(kw = optab; kw < optab + nelem(optab); kw++)
		if(opchar[*kw->name] == nil)
			opchar[*kw->name] = kw;
}

void
lexstring(char *s)
{
	str = strp = s;
	stre = str + strlen(str);
}

void
error(char *fmt, ...)
{
	Fmt f;
	char buf[128];
	va_list va;
	
	fmtfdinit(&f, 2, buf, sizeof(buf));
	fmtprint(&f, "%d ", lineno);
	va_start(va, fmt);
	fmtvprint(&f, fmt, va);
	fmtrune(&f, '\n');
	va_end(va);
	fmtfdflush(&f);
	errors++;
}

void
yyerror(char *msg)
{
	error("%s", msg);
}

static int
getch(void)
{
	if(strp >= stre){
		strp++;
		return -1;
	}
	return *strp++;
}

static void
ungetch(void)
{
	assert(strp > str);
	strp--;
}

int
yylex(void)
{
	int ch;
	static char buf[512];
	char *p;
	Keyword *kw;
	u64int v;

again:
	while(ch = getch(), ch >= 0 && isspace(ch)){
		if(ch == '\n')
			lineno++;
	}
	if(ch < 0)
		return -1;
	if(ch == '/'){
		ch = getch();
		if(ch == '/'){
			while(ch = getch(), ch >= 0 && ch != '\n')
				;
			if(ch == '\n')
				lineno++;
			goto again;
		}
		if(ch == '*'){
		s1:
			ch = getch();
			if(ch < 0) return -1;
			if(ch == '\n') lineno++;
			if(ch != '*') goto s1;
		s2:
			ch = getch();
			if(ch < 0) return -1;
			if(ch == '\n') lineno++;
			if(ch == '*') goto s2;
			if(ch != '/') goto s1;
			goto again;
		}
		ungetch();
		return '/';
	}
	if(isalnum(ch) || ch == '_' || ch >= 0x80 || ch == ':'){
		p = buf;
		*p++ = ch;
		while(ch = getch(), isalnum(ch) || ch == '_' || ch >= 0x80 || ch == ':')
			if(p < buf + sizeof(buf) - 1)
				*p++ = ch;
		*p = 0;
		ungetch();
		v = strtoull(buf, &p, 0);
		if(p != buf && *p == 0){
			yylval.num = v;
			return TNUM;
		}
		if(strcmp(buf, ":") == 0)
			return ':';
		if((uchar)buf[0] < 0x80 && kwchar[buf[0]] != nil)
			for(kw = kwchar[buf[0]]; kw < kwtab + nelem(kwtab) && kw->name[0] == buf[0]; kw++)
				if(strcmp(kw->name, buf) == 0)
					return kw->tok;
		yylval.sym = getsym(buf);
		return TSYM;
	}
	if(ch == '"'){
		p = buf;
		while(ch = getch(), ch >= 0 && ch != '"'){
			if(ch == '\n')
				error("unterminated string");
			if(ch == '\\')
				switch(ch = getch()){
				case 'n': ch = '\n'; break;
				case 'r': ch = '\r'; break;
				case 't': ch = '\t'; break;
				case 'v': ch = '\v'; break;
				case 'b': ch = '\b'; break;
				case 'a': ch = '\a'; break;
				case '"': case '\\': break;
				default: error("unknown escape code \\%c", ch);
				}
			if(p < buf + sizeof(buf) - 1)
				*p++ = ch;
		}
		if(ch < 0) error("unterminated string");
		*p = 0;
		yylval.str = strdup(buf);
		return TSTR;
	}
	if(opchar[ch] != nil){
		buf[0] = ch;
		buf[1] = getch();
		for(kw = opchar[buf[0]]; kw < optab + nelem(optab) && kw->name[0] == buf[0]; kw++)
			if(buf[1] == kw->name[1]){
				buf[2] = getch();
				buf[3] = 0;
				if(kw + 1 < optab + nelem(optab) && strcmp(kw[1].name, buf) == 0)
					return kw[1].tok;
				ungetch();
				return kw->tok;
			}
		ungetch();
	}
	return ch;
}

int
nodetfmt(Fmt *f)
{
	int t;
	static char *nodestr[] = {
		[OINVAL] "OINVAL",
		[OBIN] "OBIN",
		[OLNOT] "OLNOT",
		[OSYM] "OSYM",
		[ONUM] "ONUM",
		[OSTR] "OSTR",
		[OTERN] "OTERN",
		[ORECORD] "ORECORD",
		[OCAST] "OCAST",
	};
	
	t = va_arg(f->args, int);
	if(t >= nelem(nodestr) || nodestr[t] == nil)
		return fmtprint(f, "??? (%d)", t);
	else
		return fmtprint(f, "%s", nodestr[t]);
}

Node *
node(int type, ...)
{
	va_list va;
	Node *n;
	
	n = emalloc(sizeof(Node));
	n->type = type;
	n->line = lineno;
	va_start(va, type);
	switch(type){
	case OBIN:
		n->op = va_arg(va, int);
		n->n1 = va_arg(va, Node *);
		n->n2 = va_arg(va, Node *);
		break;
	case OLNOT:
		n->n1 = va_arg(va, Node *);
		break;
	case OSYM:
		n->sym = va_arg(va, Symbol *);
		break;
	case ONUM:
		n->num = va_arg(va, s64int);
		break;
	case OTERN:
		n->n1 = va_arg(va, Node *);
		n->n2 = va_arg(va, Node *);
		n->n3 = va_arg(va, Node *);
		break;
	case ORECORD:
		n->n1 = va_arg(va, Node *);
		break;
	case OCAST:
		n->typ = va_arg(va, Type *);
		n->n1 = va_arg(va, Node *);
		break;
	case OSTR:
		n->str = va_arg(va, char *);
		break;
	default:
		sysfatal("node: unknown type %α", type);
	}
	va_end(va);
	return n;
}

SymTab globals;

static u64int
hash(char *s)
{
	u64int h;
	
	h = 0xcbf29ce484222325ULL;
	for(; *s != 0; s++){
		h ^= *s;
		h *= 0x100000001b3ULL;
	}
	return h;
}

Symbol *
getsym(char *name)
{
	u64int h;
	Symbol **sp, *s;
	
	h = hash(name);
	for(sp = &globals.sym[h % SYMHASH]; s = *sp, s != nil; sp = &s->next)
		if(strcmp(s->name, name) == 0)
			return s;
	*sp = s = emalloc(sizeof(Symbol));
	s->name = strdup(name);
	return s;
}

int
typetfmt(Fmt *f)
{
	int t;
	static char *tstr[] = {
		[TYPINVAL] "TYPINVAL",
		[TYPINT] "TYPINT",
		[TYPPTR] "TYPPTR",
		[TYPSTRING] "TYPSTRING",
	};
	
	t = va_arg(f->args, int);
	if(t >= nelem(tstr) || tstr[t] == nil)
		return fmtprint(f, "??? (%d)", t);
	else
		return fmtprint(f, "%s", tstr[t]);
}

int
typefmt(Fmt *f)
{
	Type *t;
	
	t = va_arg(f->args, Type *);
	switch(t->type){
	case TYPINT: return fmtprint(f, "%c%d", t->sign ? 's' : 'u', t->size * 8);
	case TYPSTRING: return fmtprint(f, "string");
	case TYPPTR: return fmtprint(f, "%τ*", t->ref);
	default: return fmtprint(f, "%t", t->type);
	}
}

static Type typu8 = {.type TYPINT, .size 1, .sign 0};
static Type typs8 = {.type TYPINT, .size 1, .sign 1};
static Type typu16 = {.type TYPINT, .size 2, .sign 0};
static Type typs16 = {.type TYPINT, .size 2, .sign 1};
static Type typu32 = {.type TYPINT, .size 4, .sign 0};
static Type typs32 = {.type TYPINT, .size 4, .sign 1};
static Type typu64 = {.type TYPINT, .size 8, .sign 0};
static Type typs64 = {.type TYPINT, .size 8, .sign 1};
static Type typstr = {.type TYPSTRING, .size DTSTRMAX };
static Type *typereg;

static Type *
mkptr(Type *t)
{
	Type *s;
	
	for(s = typereg; s != nil; s = s->typenext)
		if(s->type == TYPPTR && s->ref == t)
			return s;
	s = emalloc(sizeof(Type));
	s->type = TYPPTR;
	s->ref = t;
	return s;
}

Type *
type(int typ, ...)
{
	int size, sign;
	va_list va;
	
	va_start(va, typ);
	switch(typ){
	case TYPINT:
		size = va_arg(va, int);
		sign = va_arg(va, int);
		switch(size << 4 | sign){
		case 0x10: return &typu8;
		case 0x11: return &typs8;
		case 0x20: return &typu16;
		case 0x21: return &typs16;
		case 0x40: return &typu32;
		case 0x41: return &typs32;
		case 0x80: return &typu64;
		case 0x81: return &typs64;
		default: sysfatal("type: invalid (size,sign) = (%d,%d)\n", size, sign); return nil;
		}
	case TYPSTRING: return &typstr;
	case TYPPTR: return mkptr(va_arg(va, Type *));
	default: sysfatal("type: unknown %t", typ); return nil;
	}
}