%{
#include <string.h>
#include "menusmarf.tab.c"

static char str_buf[16384], *str_buf_head;
static int caller, parens;
static int bronze;

static char *qccpy(char *buffer, const char *str);
%}

%s s_string
%s s_comment
%s s_code
%s s_code_string

%%

<INITIAL>{
	[-+]?([0-9]+\.?)|(\.[0-9]+)|([0-9]+\.[0-9]+)	yylval.number = atof(yytext); return NUMBER;
	default			yylval.string = NULL; return TOK_DEFAULT;
	[a-z0-9][a-z0-9_]*	yylval.string = strdup(yytext); return TOKEN;
	"{"			parens = 0; str_buf_head = str_buf; *str_buf_head++ = '{'; BEGIN(s_code);
	\"			str_buf_head = str_buf; bronze = 0; BEGIN(s_string);
}

<INITIAL,s_code>{
	"//".*\n
	"/*"			caller = YY_START; BEGIN(s_comment);
}

<s_comment>{
	[^*]+
	"*"+[^*/]*
	"*"+"/"		BEGIN(caller);
}

<s_code>{
	\"		bronze = 0; BEGIN(s_code_string);
	[^"{}]*		bronze = 0; str_buf_head = qccpy(str_buf_head, yytext);
	"{"		*str_buf_head++ = '{'; parens++;
	"}"		{
				*str_buf_head++ = '}';
				if (!parens--) {
					*str_buf_head = '\0';
					yylval.string = strdup(str_buf);
					BEGIN(INITIAL);
					return CODE;
				}
			}
}

<s_code_string>{
	\\.		str_buf_head = qccpy(str_buf_head, yytext);
	[^"]*		str_buf_head = qccpy(str_buf_head, yytext);
	\"		BEGIN(s_code);
}

<s_string>{
	\\b			bronze = !bronze;
	\\\{[0-9]{1,3}\}	*str_buf_head++ = atoi(yytext+2);
	\\\[			*str_buf_head++ = 0x10;
	\\\]			*str_buf_head++ = 0x11;
	\\\.			*str_buf_head++ = bronze?(0x1C|0x80):0x1C;
	\\<			*str_buf_head++ = 29;
	\\-			*str_buf_head++ = 30;
	\\>			*str_buf_head++ = 31;
	\\\(			*str_buf_head++ = 128;
	\\=			*str_buf_head++ = 129;
	\\\)			*str_buf_head++ = 130;
	\\.			*str_buf_head++ = bronze?(yytext[1]^0x80):yytext[1];
	[^"\\]*			str_buf_head = qccpy(str_buf_head, yytext);
	\"			{
					*str_buf_head = '\0';
					yylval.string = strdup(str_buf);
					BEGIN(INITIAL);
					return STRING;
				}
}

[ \t]*

(.|\n)			return *yytext;

<*><<EOF>>		return 0;

%%

static char *qccpy(char *buffer, const char *str) {
	while (*str) {
		if (bronze && (*str & ~0x80) > 32) *buffer++ = *str++ ^ 0x80;
		else *buffer++ = *str++;
	}
	*buffer = '\0';
	return buffer;
}

static char *bronzize(const char *str, int bronzetype) {
	static char *ret = NULL;
	char *tmp;
	
	if (ret) free(ret);
	tmp = ret = strdup(str);
	
	switch (bronzetype) {
	  case -1:
		while (*tmp) {
			if ((*tmp & ~0x80) > 32) *tmp++ &= ~0x80;
			else tmp++;
		}
		break;
	  case 0:
		while (*tmp) {
			if ((*tmp & ~0x80) > 32) *tmp++ ^= 0x80;
			else tmp++;
		}
		break;
	  case 1:
		while (*tmp) {
			if ((*tmp & ~0x80) > 32) *tmp++ |= 0x80;
			else tmp++;
		}
		break;
	}

	return ret;
}

yywrap() { return 1; }

static void writewrites(const char *str) {
	signed short shrt;
	while (str[0] && str[1]) {
		shrt = (str[0]&0xff) | (str[1] << 8);
		printf("\t\tWriteShort(MSG_ONE, %d);\n", shrt);
		str += 2;
	}

	if (*str)
		printf("\t\tWriteByte(MSG_ONE, %d);\n", (unsigned char)*str);
}

struct {
	const char *func_name;
	const char *def, *disabled, *selected, *unmangled;
} func_names[4096];
static char func_names_count = 0;
static int mungefunc(struct menu_entry *e, const char *def, const char *disabled, const char *selected, const char *unmangled) {
	int i, j;
	char *func1 = NULL, *func2 = NULL;

  do_over:
	for (i = 0; i < func_names_count; i++) {
		if ((func_names[i].def && !strcmp(func_names[i].def, def))
		 && ((!disabled && !func_names[i].disabled) || !strcmp(func_names[i].disabled, disabled))
		 && ((!selected && !func_names[i].selected) || !strcmp(func_names[i].selected, selected))
		 && ((!unmangled && !func_names[i].unmangled) || !strcmp(func_names[i].unmangled, unmangled))) {
			e->func_name = (char*)func_names[i].func_name;
			return 0;
		}
		
		if (!strcmp(func_names[i].func_name, e->func_name)) {
			if (!func1) {
				j = 2;
				func1 = e->func_name;
				func2 = malloc(strlen(e->func_name) + 10 + 1);
				e->func_name = func2;
			}

			sprintf(func2, "%s%d", func1, j);
			j++;
			
			goto do_over;
		}
	}
	
	func_names[i].func_name = e->func_name;
	func_names[i].def = strdup(def);
	func_names[i].disabled = disabled?strdup(disabled):NULL;
	func_names[i].selected = selected?strdup(selected):NULL;
	func_names[i].unmangled = unmangled?strdup(unmangled):NULL;
	func_names_count++;
	
	return 1;
}

static int writefunc(struct menu_entry *e, const char *def, const char *disabled, const char *selected, const char *unmangled) {
	if (!mungefunc(e, def, disabled, selected, unmangled)) return 0;

	printf("void(float type) %s = {\n", e->func_name);
	if (disabled || selected || unmangled)
		printf("\tif (type == K_DEFAULT) {\n");

	writewrites(def);

	if (disabled) {
		printf("\t} else if (type == K_DISABLED) {\n");
		writewrites(disabled);
	}
	if (selected) {
		printf("\t} else if (type == K_SELECTED) {\n");
		writewrites(selected);
	}
	if (unmangled) {
		printf("\t} else if (type == K_UNMANGLED) {\n");
		writewrites(unmangled);
	}
	if (disabled || selected || unmangled)
		printf("\t}\n");
	printf("}\n\n");
	
	return 1;
}

static const char default_activate_code[] =
	"{\n"
	"\t\tstatus = k_weapon_toggle(self, %1$s, %2$s);\n"
	"\t\tif (status == FALSE) bs = k_menup_sold_;\n"
	"\t\telse if (status == TRUE) bs = k_menup_bought_;\n"
	"\t\telse if (status == -1) bs = k_menup_can_t_afford_;\n"
	"\t\tselected = %3$s;\n"
	"\t}"
;

static const char default_strings_code[] =
	"{\n"
	"\tif (k_weapon_query(self, %1$s)) return K_SELECTED;\n"
	"\n"
	"\treturn K_DEFAULT;\n"
	"}"
;

int main(int argc, char *argv[]) {
	unsigned int i, j;
	unsigned int runwidth, thiswidth;
	unsigned int bit = 0;
	char buffer[4096];

	yydebug = 0;

	printf("/* This file was automatically generated by menusmarf */\n\n");

	func_names[0].func_name = "k_menup_begin";
	func_names[0].def = NULL;
	func_names_count++;
	printf(	"void() k_menup_begin = {\n"
		"\tmsg_entity = self;\n"
		"\tWriteByte(MSG_ONE, SVC_CENTERPRINT);\n"
		"}\n\n");

	func_names[1].func_name = "k_menup_end";
	func_names[1].def = NULL;
	func_names_count++;
	printf(	"void() k_menup_end = {\n"
		"\tWriteByte(MSG_ONE, 0);\n"
		"}\n\n");

	{
		struct menu_entry decor[] = {
			{ func_name: "k_menup_entry_begin" },
			{ func_name: "k_menup_entry_end" },
			{ func_name: "k_menup_bought_" },
			{ func_name: "k_menup_sold_" },
			{ func_name: "k_menup_points__" },
			{ func_name: "k_menup_can_t_afford_" },
		};

		writefunc(&decor[0], "\20  ", bronzize("[  ", 1), "\20 \274", NULL);
		writefunc(&decor[1], "  \21\n", bronzize("  ]\n", 1), "\276 \21\n", NULL);
		writefunc(&decor[2], bronzize("Bought ", 1), NULL, NULL, NULL);
		writefunc(&decor[3], bronzize("Sold ", 1), NULL, NULL, NULL);
		writefunc(&decor[4], "Points\272 ", NULL, NULL, NULL);
		writefunc(&decor[5], bronzize("Can't afford ", 1), NULL, NULL, NULL);
	}

	while (!yyparse() && menu_name) {
		for (i = 0; i < menu_entries_count; i++) {
			runwidth = 0;
	
			for (j = i; menu_entries[j].type == menu_entries[i].type; j++) {
				switch (menu_entries[j].type) {
				  case 0:
					continue; /* Don't need to pad. */
				  case 1:
					thiswidth = strlen(menu_entries[j].name);
					break;
				  case 2:
					thiswidth = strlen(menu_entries[j].name);
					break;
				}
				
				if (thiswidth > runwidth)
					runwidth = thiswidth;
			}
	
			for (j = i; menu_entries[j].type == menu_entries[i].type; j++) {
				switch (menu_entries[j].type) {
				  case 0:
					/* Don't need to pad. */
					snprintf(buffer, sizeof(buffer), "%s\n", menu_entries[j].name);
					writefunc(&menu_entries[j], buffer, NULL, NULL, NULL);

					menu_entries[j].bit = -1;
					break;
				  case 1:
					snprintf(buffer, sizeof(buffer), "%d. %-*s", menu_entries[j].impulse%10, runwidth, menu_entries[j].name);
					writefunc(&menu_entries[j], buffer, bronzize(buffer, 1), NULL, NULL);
					
					menu_entries[j].bit = -1;
					break;
				  case 2:
					printf("float %-30s = %d;\n", menu_entries[j].number_name, bit);
					printf("float %-30s = %.0f;\n", menu_entries[j].price_name, menu_entries[j].price);

					snprintf(buffer, sizeof(buffer), "%d\256 %-*s \234\34\234%6.0f", menu_entries[j].impulse%10, runwidth, menu_entries[j].name, menu_entries[j].price);
					writefunc(&menu_entries[j], buffer, bronzize(buffer, 1), buffer, menu_entries[j].name);

					menu_entries[j].bit = bit++;
					break;
				}
			}
	
			i = j-1;
		}

		for (i = 0; i < menu_entries_count; i++) {
			if (menu_entries[i].bit != -1 && !menu_entries[i].code_strings)
				menu_entries[i].code_strings = (char*)default_strings_code;

			if (menu_entries[i].code_strings) {
				printf("float() %s_%d = ", menu_name, i);
				printf(menu_entries[i].code_strings,
					menu_entries[i].number_name,
					menu_entries[i].price_name,
					menu_entries[i].func_name,
					menu_entries[i].name,
					menu_entries[i].impulse);
				printf(";\n\n");
			}
		}
		
		printf(	"float() %s = {\n"
			"\tlocal float status, nomenu;\n"
			"\tlocal void() bs;\n"
			"\tlocal void(float type) selected;\n"
			"\n"
			"\tnomenu = 0;\n"
			"\tbs = SUB_Null;\n"
			"\tselected = SUB_Null;\n"
			"\n", menu_name);
		for (i = 0; i < menu_entries_count; i++) {
			if (menu_entries[i].impulse) {
				printf("\tif (self.impulse == %d) ", menu_entries[i].impulse);
				snprintf(buffer, sizeof(buffer), default_activate_code,
					menu_entries[i].number_name,
					menu_entries[i].price_name,
					menu_entries[i].func_name,
					menu_entries[i].name,
					menu_entries[i].impulse);
				if (menu_entries[i].code_activate)
					printf(menu_entries[i].code_activate,
						menu_entries[i].number_name,
						menu_entries[i].price_name,
						menu_entries[i].func_name,
						menu_entries[i].name,
						menu_entries[i].impulse,
						buffer);
				else
					printf("%s", buffer);
				printf("\n");
			}
		}
		printf(	"\n"
			"\tif (nomenu || (!self.impulse && time < self.menu_time)) { self.impulse = 0; return TRUE; }\n"
			"\tself.menu_time = time + 1.4;\n"
			"\n"
			"\tself.impulse = 0;\n"
			"\n"
			"\tk_menup_begin();\n");

		for (i = 0; i < menu_entries_count; i++) {
			if (menu_entries[i].code_strings)
				printf(	"\tstatus = %s_%d();\n"
					"%s"
					"\t%s(status);\n"
					"%s",
					menu_name, i,
					menu_entries[i].type?"\tk_menup_entry_begin(status);\n":"",
					menu_entries[i].func_name,
					menu_entries[i].type?"\tk_menup_entry_end(status);\n":"");
					
			else
				printf(	"%s"
					"\t%s(K_DEFAULT);\n"
					"%s",
					menu_entries[i].type?"\tk_menup_entry_begin(K_DEFAULT);\n":"",
					menu_entries[i].func_name,
					menu_entries[i].type?"\tk_menup_entry_end(K_DEFAULT);\n":"");
		}
		
		printf(	"\tk_menu_status();\n"
			"\tif (bs != SUB_Null) {\n"
			"\t\tbs();\n"
			"\t\tselected(K_UNMANGLED);\n"
			"\t} else\n"
			"\t\tWriteByte(MSG_ONE, 10);\n"
			"\tk_menup_end();\n"
			"\n"
			"\treturn TRUE;"
			"\n"
			"}\n\n");
	}
}