%{

#include <assert.h>
#include <errno.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <sys/queue.h>

#include "evtr.h"
#include "tok.h"
#include "internal.h"
#include "ktrfmt.tab.h"

int __ktrfmtlex(YYSTYPE *);
#define __ktrfmt_lex __ktrfmtlex

void __ktrfmt_error (struct ktrfmt_parse_ctx *, const char *);

static void do_parse_err(struct ktrfmt_parse_ctx *, const char *, ...)
		__printflike(2, 3);

static
void
do_parse_err(struct ktrfmt_parse_ctx *ctx, const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	vsnprintf(ctx->errbuf, ctx->errbufsz, fmt, ap);
	va_end(ap);
	ctx->err = !0;
}

#define parse_err(fmt, ...)			\
	do {					\
		do_parse_err(ctx, fmt, ##__VA_ARGS__);	\
		YYABORT;				\
 	} while (0)

static
struct evtr_variable *
evtr_var_new(const char *name)
{
	struct evtr_variable *var;

	var = calloc(1, sizeof(*var));
	if (var) {
		if (!(var->name = strdup(name))) {
			free(var);
			return NULL;
		}
		var->val.type = EVTR_VAL_NIL;
	}
	return var;
}

/*
 * XXX: should be reentrant
 */
static
char *
uniq_varname(void)
{
	static long serno;
	static char buf[100];

	serno++;
	snprintf(buf, sizeof(buf), "@%ld", serno);
	return &buf[0];
}

static
int
index_hash(struct ktrfmt_parse_ctx *ctx, const char *hashname,
	   evtr_variable_value_t val, evtr_var_t *_var)
{
	evtr_var_t hsh, var;
	uintptr_t ret, key;
	hsh = symtab_find(ctx->symtab, hashname);
	if (hsh->val.type == EVTR_VAL_NIL) {
		/* it's probably the first time we see this "variable" */
		printd(PARSE, "creating hash for %s\n", hsh->name);
		hsh->val.type = EVTR_VAL_HASH;
		hsh->val.hashtab = hash_new();
	} else if (hsh->val.type != EVTR_VAL_HASH) {
		printd(PARSE, "trying to use type %d as hash\n", hsh->val.type);
		return !0;
	}
	if (val->type == EVTR_VAL_INT) {
		key = val->num;
		printd(PARSE, "looking up %s[%jd] in %p\n", hsh->name,
		       val->num, hsh->val.hashtab);
	} else if (val->type == EVTR_VAL_STR) {
		key = (uintptr_t)val->str;
		printd(PARSE, "looking up %s[\"%s\"] in %p\n", hsh->name,
		       val->str, hsh->val.hashtab);
	} else {
		do_parse_err(ctx, "trying to index hash '%s' with "
			     "non-supported value", hashname);
		return !0;
	}

      	if (hash_find(hsh->val.hashtab, key, &ret)) {
		printd(PARSE, "didn't find it\n");
		var = evtr_var_new(uniq_varname());
		if (var) {
			printd(PARSE, "inserting it as %s\n", var->name);
			if (!hash_insert(hsh->val.hashtab, key,
					 (uintptr_t)var)) {
				do_parse_err(ctx, "can't insert temporary "
					"variable into hash\n");
				return !0;
			}
			symtab_insert(ctx->symtab, var->name, var);
		} else {
			do_parse_err(ctx, "out of memory");
		}
	} else {
		var = (struct evtr_variable *)ret;
	}
	if (!var) {
		fprintf(stderr, "no var!\n");
		return !0;
		/* XXX */
	}
	*_var = var;
	return 0;
}

%}

%verbose
%error-verbose
%debug
%name-prefix "__ktrfmt_"
%define api.pure
%parse-param{struct ktrfmt_parse_ctx *ctx}

%union {
	struct token *tok;
	struct evtr_variable *var;
	struct evtr_variable_value *val;
	void *na;
}

%token<tok> TOK_ID
%token<tok> TOK_CTOR
%token<tok> TOK_INT
%token<tok> TOK_STR

%token<na> TOK_EQ
%token<na> TOK_LEFT_BRACK
%token<na> TOK_RIGHT_BRACK
%token<na> TOK_DOT

%type<var> constant
%type<var> ctor_args
%type<var> construct_expr
%type<var> primary_expr
%type<var> postfix_expr
%type<var> unary_expr
%type<na> assign_expr
%type<na> expr

%%

input: stmt

stmt: unary_expr {
	ctx->var = $1;
 }
     | expr
     ;
constant: TOK_INT {
	evtr_var_t var;
	if (!$1->str)
		parse_err("out of memory");
	var = evtr_var_new(uniq_varname());
	var->val.type = EVTR_VAL_INT;
	errno = 0;
	var->val.num = strtoll($1->str, NULL, 0);
	if (errno) {
		parse_err("Can't parse numeric constant '%s'", $1->str);
	}
	$$ = var;
	tok_free($1);
	}
	| TOK_STR {
	evtr_var_t var;
	if (!$1->str)
		parse_err("out of memory");
	var = evtr_var_new(uniq_varname());
	var->val.type = EVTR_VAL_STR;
	var->val.str = $1->str;
	if (!var->val.str) {
		parse_err("out of memory");
	}
	$$ = var;
	tok_free($1);
	}
	;
ctor_args: constant {
	evtr_var_t ctor;
	ctor = evtr_var_new(uniq_varname());
	ctor->val.type = EVTR_VAL_CTOR;
	ctor->val.ctor.name = NULL;
	TAILQ_INIT(&ctor->val.ctor.args);
	TAILQ_INSERT_HEAD(&ctor->val.ctor.args, &$1->val, link);
	$$ = ctor;
 }
| constant ctor_args {
	TAILQ_INSERT_HEAD(&$2->val.ctor.args, &$1->val, link);
	$$ = $2;
 }
;
construct_expr: TOK_CTOR {
	evtr_var_t var;
	if (!$1->str)
		parse_err("out of memory");
	printd(PARSE, "TOK_CTOR\n");
	printd(PARSE, "tok: %p, str = %p\n", $1, $1->str);
	var = evtr_var_new(uniq_varname());
	var->val.type = EVTR_VAL_CTOR;
	var->val.ctor.name = $1->str;
	TAILQ_INIT(&var->val.ctor.args);
	tok_free($1);
	$$ = var;
 }
| TOK_CTOR ctor_args {
	evtr_variable_value_t val;
	if (!$1->str)
		parse_err("out of memory");
	printd(PARSE, "TOK_CTOR\n");
	printd(PARSE, "tok: %p, str = %p\n", $1, $1->str);
	$2->val.ctor.name = $1->str;
	$$ = $2;
	printd(PARSE, "CTOR: %s\n", $1->str);
	TAILQ_FOREACH(val, &$2->val.ctor.args, link) {
		switch (val->type) {
		case EVTR_VAL_INT:
			printd(PARSE, "\t%jd\n", val->num);
			break;
		case EVTR_VAL_STR:
			printd(PARSE, "\t\"%s\"\n", val->str);
			break;
		case EVTR_VAL_NIL:
			assert(!"can't get here");
		default:
			;
		}
	}
 }
;
primary_expr: TOK_ID {
	evtr_var_t var;
	if (!$1->str)
		parse_err("out of memory");
	printd(PARSE, "TOK_ID\n");
	printd(PARSE, "tok: %p, str = %p\n", $1, $1->str);
	var = symtab_find(ctx->symtab, $1->str);
	if (!var) {
		if (!(var = evtr_var_new($1->str))) {
			tok_free($1);
			parse_err("out of memory");
		}
		printd(PARSE, "creating var %s\n", $1->str);
		symtab_insert(ctx->symtab, $1->str, var);
	}
	$$ = var;
	tok_free($1);
 }
| constant {
	$$ = $1;
  }
;
postfix_expr: postfix_expr TOK_LEFT_BRACK postfix_expr TOK_RIGHT_BRACK {
	evtr_var_t var;

	if (index_hash(ctx, $1->name, &$3->val, &var))
		YYABORT;
	$$ = var;
 }
| postfix_expr TOK_DOT TOK_ID {
	evtr_var_t var, tmp;
	if (!$3->str)
		parse_err("out of memory");
	tmp = evtr_var_new(uniq_varname());
	tmp->val.type = EVTR_VAL_STR;
	tmp->val.str = $3->str;

	if (index_hash(ctx, $1->name, &tmp->val, &var))
		YYABORT;
	tok_free($3);
	$$ = var;
 }
            | primary_expr {
	$$ = $1;
 }
;
unary_expr: postfix_expr {
	$$ = $1;
 }
;
assign_expr: unary_expr TOK_EQ constant {
	$1->val = $3->val;
	ctx->ev->type = EVTR_TYPE_STMT;
	ctx->ev->stmt.var = $1;
	ctx->ev->stmt.val = &$3->val;
	ctx->ev->stmt.op = EVTR_OP_SET;
 }
| unary_expr TOK_EQ construct_expr {
	$1->val = $3->val;
	ctx->ev->type = EVTR_TYPE_STMT;
	ctx->ev->stmt.var = $1;
	ctx->ev->stmt.val = &$3->val;
	ctx->ev->stmt.op = EVTR_OP_SET;
 }
;
expr: assign_expr {
	$$ = $1;
 }
;

%%

void * __ktrfmt_scan_string(const char *);
void __ktrfmt_delete_buffer(void *);

void
__ktrfmt_error (struct ktrfmt_parse_ctx *ctx, const char *s)
{
	do_parse_err(ctx, "%s", s);
}

int
parse_string(evtr_event_t ev, struct symtab *symtab, const char *str,
	     char *errbuf, size_t errbufsz)
{
	void *bufstate;
	int ret;
	struct ktrfmt_parse_ctx ctx;

	printd(PARSE, "parsing \"%s\"\n", str);
	ctx.ev = ev;
	ctx.symtab = symtab;
	ctx.errbuf = errbuf;
	ctx.errbuf[0] = '\0';
	ctx.errbufsz = errbufsz;
	ctx.err = 0;
	bufstate = __ktrfmt_scan_string(str);
	ret = __ktrfmt_parse(&ctx);
	__ktrfmt_delete_buffer(bufstate);

	return ret;
}

int
parse_var(const char *str, struct symtab *symtab, struct evtr_variable **var,
	  char *errbuf, size_t errbufsz)
{
	void *bufstate;
	int ret;
	struct ktrfmt_parse_ctx ctx;

	printd(PARSE, "parsing \"%s\"\n", str);
	ctx.ev = NULL;
	ctx.symtab = symtab;
	ctx.var = NULL;
	ctx.errbuf = errbuf;
	ctx.errbuf[0] = '\0';
	ctx.errbufsz = errbufsz;
	ctx.err = 0;
	bufstate = __ktrfmt_scan_string(str);
	ret = __ktrfmt_parse(&ctx);
	__ktrfmt_delete_buffer(bufstate);

	*var = ctx.var;
	return ret;
}