//*****************************************************************
//
//	$file: main.cpp $
//	$author: Martin Fouilleul $
//	$date: 23/12/2017 $
//
//*****************************************************************

/*
------------------------------------------------------------------------------
This software is available under 2 licenses -- choose whichever you prefer.
------------------------------------------------------------------------------
ALTERNATIVE A - MIT License
Copyright (c) 2017 Martin Fouilleul
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
------------------------------------------------------------------------------
ALTERNATIVE B - Public Domain (www.unlicense.org)
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
software, either in source code form or as a compiled binary, for any purpose,
commercial or non-commercial, and by any means.
In jurisdictions that recognize copyright laws, the author or authors of this
software dedicate any and all copyright interest in the software to the public
domain. We make this dedication for the benefit of the public at large and to
the detriment of our heirs and successors. We intend this dedication to be an
overt act of relinquishment in perpetuity of all present and future rights to
this software under copyright law.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
------------------------------------------------------------------------------
*/

#include<stdio.h>
#include<strings.h>

#include"scanner.h"

int section = 0;
int enterCount = 0;

bool underline = false;
bool bold = false;
bool italic = false;
bool regular = false;
bool paragraph = false;
bool ldquo = false;

FILE* input = 0;
FILE* output = 0;


int HighlightCode(FILE* in, FILE* out);

void EvalMarkup(token* t);
void EvalTag(token* t);
void EvalEsc(token* t);


void EatSpaceUntilEndl(FILE* input, token* t)
{
	GetNextToken(input, t);
	while(t->type == CHAR && (t->c == ' ' || t->c == '\t'))
	{
		GetNextToken(input, t);
	}
	if(t->type == ENDL)
	{
		GetNextToken(input, t);
	}
}

void EvalCharInCodeMode(token* t)
{
	//NOTE(martin): replaces special characters with html entities

	switch(t->c)
	{
		case '<':
			fprintf(output, "&lt;");
		break;

		case '>':
			fprintf(output, "&gt;");
		break;

		case '&':
			fprintf(output, "&amp;");
		break;

		default:
			putc(t->c, output);
		break;
	}
}

void EvalChar(token* t)
{
	//NOTE(martin): replaces special characters with html entities

	switch(t->c)
	{
		case '<':
			fprintf(output, "&lt;");
		break;

		case '>':
			fprintf(output, "&gt;");
		break;

		case '&':
			fprintf(output, "&amp;");
		break;

		case '"':
			if(!ldquo)
			{
				fprintf(output, "&ldquo;");
				ldquo = true;
			}
			else
			{
				fprintf(output, "&rdquo;");
				ldquo = false;
			}
		break;

		case '\t':
			fprintf(output, "<span style=\"white-space:pre;\">\t</span>");
		break;

		default:
			putc(t->c, output);
		break;
	}
}

void EvalSymbol(token* t)
{
	switch(t->symbol.code)
	{
		case MULTIPLY:
			fprintf(output, "&times;");
			break;
		case DIVIDE:
			fprintf(output, "&div;");
			break;
		case SUBSTRACT:
			fprintf(output, "&minus;");
			break;
		case STAR:
			fprintf(output, "&ast;");
			break;
		case LOSTAR:
			fprintf(output, "&lowast;");
			break;
		case CDOT:
			fprintf(output, "&middot;");
			break;
		case LEQ:
			fprintf(output, "&leq;");
			break;
		case GEQ:
			fprintf(output, "&geq;");
			break;
		case INF:
			fprintf(output, "&infin;");
			break;
		case OTIMES:
			fprintf(output, "&otimes;");
			break;
		case LARR:
			fprintf(output, "&larr;");
			break;
		case RARR:
			fprintf(output, "&rarr;");
			break;
		case EMDASH:
			fprintf(output, "&mdash;");
			break;
		case LINE:
			fprintf(output, "<hr/>");
			break;
		case THINSPACE:
			fprintf(output, "&#8239;");
			break;
		case ALPHA:
			fprintf(output, "&alpha;");
			break;
		case BETA:
			fprintf(output, "&beta;");
			break;
		case GAMMA:
			fprintf(output, "&gamma;");
			break;
		case DELTA:
			fprintf(output, "&delta;");
			break;
		case EPSILON:
			fprintf(output, "&epsilon;");
			break;
		case ZETA:
			fprintf(output, "&zeta;");
			break;
		case ETA:
			fprintf(output, "&eta;");
			break;
		case THETA:
			fprintf(output, "&theta;");
			break;
		case IOTA:
			fprintf(output, "&iota;");
			break;
		case KAPPA:
			fprintf(output, "&kappa;");
			break;
		case LAMBDA:
			fprintf(output, "&lambda;");
			break;
		case MU:
			fprintf(output, "&mu;");
			break;
		case NU:
			fprintf(output, "&nu;");
			break;
		case XI:
			fprintf(output, "&xi;");
			break;
		case OMICRON:
			fprintf(output, "&omicron;");
			break;
		case PI:
			fprintf(output, "&pi;");
			break;
		case RHO:
			fprintf(output, "&rho;");
			break;
		case SIGMA:
			fprintf(output, "&sigma;");
			break;
		case TAU:
			fprintf(output, "&tau;");
			break;
		case UPSILON:
			fprintf(output, "&upsilon;");
			break;
		case PHI:
			fprintf(output, "&phi;");
			break;
		case CHI:
			fprintf(output, "&chi;");
			break;
		case PSI:
			fprintf(output, "&psi;");
			break;
		case OMEGA:
			fprintf(output, "&omega;");
			break;
		case ALPHA_UPPER:
			fprintf(output, "&Alpha;");
			break;
		case BETA_UPPER:
			fprintf(output, "&Beta;");
			break;
		case GAMMA_UPPER:
			fprintf(output, "&Gamma;");
			break;
		case DELTA_UPPER:
			fprintf(output, "&Delta;");
			break;
		case EPSILON_UPPER:
			fprintf(output, "&Epsilon;");
			break;
		case ZETA_UPPER:
			fprintf(output, "&Zeta;");
			break;
		case ETA_UPPER:
			fprintf(output, "&Eta;");
			break;
		case THETA_UPPER:
			fprintf(output, "&Theta;");
			break;
		case IOTA_UPPER:
			fprintf(output, "&Iota;");
			break;
		case KAPPA_UPPER:
			fprintf(output, "&Kappa;");
			break;
		case LAMBDA_UPPER:
			fprintf(output, "&Lambda;");
			break;
		case MU_UPPER:
			fprintf(output, "&Mu;");
			break;
		case NU_UPPER:
			fprintf(output, "&Nu;");
			break;
		case XI_UPPER:
			fprintf(output, "&Xi;");
			break;
		case OMICRON_UPPER:
			fprintf(output, "&Omicron;");
			break;
		case PI_UPPER:
			fprintf(output, "&Pi;");
			break;
		case RHO_UPPER:
			fprintf(output, "&Rho;");
			break;
		case SIGMA_UPPER:
			fprintf(output, "&Sigma;");
			break;
		case TAU_UPPER:
			fprintf(output, "&Tau;");
			break;
		case UPSILON_UPPER:
			fprintf(output, "&Upsilon;");
			break;
		case PHI_UPPER:
			fprintf(output, "&Phi;");
			break;
		case CHI_UPPER:
			fprintf(output, "&Chi;");
			break;
		case PSI_UPPER:
			fprintf(output, "&Psi;");
			break;
		case OMEGA_UPPER:
			fprintf(output, "&Omega;");
			break;
	}
}

void EvalURL(token* t)
{
	fprintf(output, "<a href=\"%s\">", t->markup.text);
	GetNextToken(input, t);
	while(t->type != ENDF)
	{
		switch(t->type)
		{
			case ESC:
				EvalEsc(t);
			break;
			case MARKUP:
				if(  t->markup.type == CODE_BLOCK_START
				  || t->markup.type == MATHS_BLOCK_START
				  || t->markup.type == HTML_BLOCK_START
				  || t->markup.type == LIST)
				{
					//error
					return;
				}
				else if(t->markup.type == URL_STOP)
				{
					fprintf(output, "</a>\n");
					return;
				}
				else
				{
					EvalMarkup(t);
				}
			break;
			case HTML_TAG:
				EvalTag(t);
			break;
			case ENDL:
				fprintf(output, "<br>\n");
			break;

			case SYMBOL:
				EvalSymbol(t);
			break;

			case CHAR: default:
				EvalChar(t);
			break;
		}
		GetNextToken(input, t);
	}
	//error
}

void EvalImage(token* t)
{
	fprintf(output, "<img src=\"%s\">", t->markup.text);
}

void EvalMathsChar(token* t)
{
	//NOTE(martin): replaces special characters with html entities

	switch(t->c)
	{
		case '<':
			fprintf(output, "<span class=\"rel\">&lt;</span>");
		break;

		case '>':
			fprintf(output, "<span class=\"rel\">&gt;</span>");
		break;

		case '&':
			fprintf(output, "&amp;");
		break;

		case '\t':
			fprintf(output, "&emsp;&emsp;");
		break;

		case '+': case '/' : case '*': case '!': case '=':
			fprintf(output, "<span class=\"op\">&thinsp;%c&thinsp;</span>", t->c);
		break;

		case '(': case ')' : case '[' : case ']': case ',': case ';':
			fprintf(output, "<span class=\"delim\">%c</span>", t->c);
		break;

		case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
			fprintf(output, "<span class=\"digit\">%c</span>", t->c);
		break;

		default:
			if(t->c >= 'A' && t->c <= 'Z' && !italic)
			{
				fprintf(output, "<span class=\"regular\">%c</span>", t->c);
			}
			else
			{
				putc(t->c, output);
			}
		break;
	}
}

void EvalMathsSymbol(token* t)
{
	switch(t->symbol.code)
	{
		case MULTIPLY:
			fprintf(output, "<span class=\"op\">&thinsp;&times;&thinsp;</span>");
			break;
		case DIVIDE:
			fprintf(output, "<span class=\"op\">&thinsp;&div;&thinsp;</span>");
			break;
		case SUBSTRACT:
			fprintf(output, "<span class=\"op\">&thinsp;&minus;&thinsp;</span>");
			break;
		case STAR:
			fprintf(output, "<span class=\"op\">&thinsp;&ast;&thinsp;</span>");
			break;
		case LOSTAR:
			fprintf(output, "<span class=\"op\">&thinsp;&lowast;&thinsp;</span>");
			break;
		case CDOT:
			fprintf(output, "<span class=\"op\">&thinsp;&middot;&thinsp;</span>");
			break;
		case LEQ:
			fprintf(output, "<span class=\"rel\">&leq;</span>");
			break;
		case GEQ:
			fprintf(output, "<span class=\"rel\">&geq;</span>");
			break;
		case INF:
			fprintf(output, "<span class=\"symbol\">&infin;</span>");
			break;
		case OTIMES:
			fprintf(output, "<span class=\"op\">&thinsp;&otimes;&thinsp;</span>");
			break;
		case LARR:
			fprintf(output, "<span class=\"delim\">&larr;</span>");
			break;
		case RARR:
			fprintf(output, "<span class=\"delim\">&rarr;</span>");
			break;
		case EMDASH:
			fprintf(output, "&mdash;");
			break;
		case LINE:
			fprintf(output, "<hr/>");
			break;
		case THINSPACE:
			fprintf(output, "&#8239;");
			break;
		case ALPHA:
			fprintf(output, "<span class=\"greek-letter\">&alpha;</span>");
			break;
		case BETA:
			fprintf(output, "<span class=\"greek-letter\">&beta;</span>");
			break;
		case GAMMA:
			fprintf(output, "<span class=\"greek-letter\">&gamma;</span>");
			break;
		case DELTA:
			fprintf(output, "<span class=\"greek-letter\">&delta;</span>");
			break;
		case EPSILON:
			fprintf(output, "<span class=\"greek-letter\">&epsilon;</span>");
			break;
		case ZETA:
			fprintf(output, "<span class=\"greek-letter\">&zeta;</span>");
			break;
		case ETA:
			fprintf(output, "<span class=\"greek-letter\">&eta;</span>");
			break;
		case THETA:
			fprintf(output, "<span class=\"greek-letter\">&theta;</span>");
			break;
		case IOTA:
			fprintf(output, "<span class=\"greek-letter\">&iota;</span>");
			break;
		case KAPPA:
			fprintf(output, "<span class=\"greek-letter\">&kappa;</span>");
			break;
		case LAMBDA:
			fprintf(output, "<span class=\"greek-letter\">&lambda;</span>");
			break;
		case MU:
			fprintf(output, "<span class=\"greek-letter\">&mu;</span>");
			break;
		case NU:
			fprintf(output, "<span class=\"greek-letter\">&nu;</span>");
			break;
		case XI:
			fprintf(output, "<span class=\"greek-letter\">&xi;</span>");
			break;
		case OMICRON:
			fprintf(output, "<span class=\"greek-letter\">&omicron;</span>");
			break;
		case PI:
			fprintf(output, "<span class=\"greek-letter\">&pi;</span>");
			break;
		case RHO:
			fprintf(output, "<span class=\"greek-letter\">&rho;</span>");
			break;
		case SIGMA:
			fprintf(output, "<span class=\"greek-letter\">&sigma;</span>");
			break;
		case TAU:
			fprintf(output, "<span class=\"greek-letter\">&tau;</span>");
			break;
		case UPSILON:
			fprintf(output, "<span class=\"greek-letter\">&upsilon;</span>");
			break;
		case PHI:
			fprintf(output, "<span class=\"greek-letter\">&phi;</span>");
			break;
		case CHI:
			fprintf(output, "<span class=\"greek-letter\">&chi;</span>");
			break;
		case PSI:
			fprintf(output, "<span class=\"greek-letter\">&psi;</span>");
			break;
		case OMEGA:
			fprintf(output, "<span class=\"greek-letter\">&omega;</span>");
			break;

		case ALPHA_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Alpha;</span>");
			break;
		case BETA_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Beta;</span>");
			break;
		case GAMMA_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Gamma;</span>");
			break;
		case DELTA_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Delta;</span>");
			break;
		case EPSILON_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Epsilon;</span>");
			break;
		case ZETA_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Zeta;</span>");
			break;
		case ETA_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Eta;</span>");
			break;
		case THETA_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Theta;</span>");
			break;
		case IOTA_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Iota;</span>");
			break;
		case KAPPA_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Kappa;</span>");
			break;
		case LAMBDA_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Lambda;</span>");
			break;
		case MU_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Mu;</span>");
			break;
		case NU_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Nu;</span>");
			break;
		case XI_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Xi;</span>");
			break;
		case OMICRON_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Omicron;</span>");
			break;
		case PI_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Pi;</span>");
			break;
		case RHO_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Rho;</span>");
			break;
		case SIGMA_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Sigma;</span>");
			break;
		case TAU_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Tau;</span>");
			break;
		case UPSILON_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Upsilon;</span>");
			break;
		case PHI_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Phi;</span>");
			break;
		case CHI_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Chi;</span>");
			break;
		case PSI_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Psi;</span>");
			break;
		case OMEGA_UPPER:
			fprintf(output, "<span class=\"greek-letter\">&Omega;</span>");
			break;
	}
}

void EvalEsc(token* t)
{
	switch(t->c)
	{
		case '\n':
			fprintf(output, "\n");
		break;

		case 'n':
			fprintf(output, "<br>\n");
		break;

		case 't':
			fprintf(output, "&emsp;&emsp;");
		break;

		case 's': case ' ':
			fprintf(output, "&nbsp;");
		break;
		case '&':
			putc('&', output);
		break;
		default:
			EvalChar(t);
		break;
	}
}

void EvalSection(token* t)
{
	int sectionLevel = t->markup.value;

	fprintf(output, "<h%i>", sectionLevel);

	GetNextToken(input, t);
	while(t->type != ENDF)
	{
		switch(t->type)
		{
			case ESC:
				EvalEsc(t);
			break;
			case MARKUP:
				if(  t->markup.type == CODE_BLOCK_START
				  || t->markup.type == MATHS_BLOCK_START
				  || t->markup.type == HTML_BLOCK_START
				  || t->markup.type == LIST)
				{
					//error
					return;
				}
				else if(t->markup.type == SECTION)
				{
					if(t->markup.value != sectionLevel)
					{
						//error
					}
					fprintf(output, "</h%i>\n", sectionLevel);
					return;
				}
				else
				{
					EvalMarkup(t);
				}
			break;
			case HTML_TAG:
				EvalTag(t);
			break;
			case ENDL:
				fprintf(output, "<br>\n");
			break;

			case SYMBOL:
				EvalSymbol(t);
			break;

			case CHAR: default:
				EvalChar(t);
			break;
		}
		GetNextToken(input, t);
	}
}

void EvalBold()
{
	if(!bold)
	{
		fprintf(output, "<b>");
		bold = true;
	}
	else
	{
		fprintf(output, "</b>");
		bold = false;
	}
}
void EvalItalic()
{
	if(!italic)
	{
		fprintf(output, "<i>");
		italic = true;
	}
	else
	{
		fprintf(output, "</i>");
		italic = false;
	}
}

void EvalUnderline()
{
	if(!underline)
	{
		fprintf(output, "<u>");
		underline = true;
	}
	else
	{
		fprintf(output, "</u>");
		underline = false;
	}
}

void EvalRegular()
{
	if(!regular)
	{
		fprintf(output, "<span class=\"regular\">");
		regular = true;
	}
	else
	{
		fprintf(output, "</span>");
		regular = false;
	}
}

void EvalCode(token* t, bool inlineCode)
{
	if(inlineCode || (t->markup.text && !strcmp(t->markup.text, "none")))
	{
		fprintf(output, "<%s class=\"code\">", inlineCode ? "span" : "div");

		GetNextToken(input, t);

		bool exit = false;
		while(t->type != ENDF && !exit)
		{
			switch(t->type)
			{
				case MARKUP:
				{
					if(t->markup.type != CODE_INLINE_STOP)
					{
						//error;
					}
					exit = true;
				}
				break;
				case CHAR:
				{
					EvalCharInCodeMode(t);
				}
				break;
				default:
					//error
					exit = true;
				break;
			}
			if(!exit)
			{
				GetNextToken(input, t);
			}
		}
		fprintf(output, "</%s>", inlineCode ? "span" : "div");
	}
	else
	{
		fprintf(output, "<div class=\"code\">");
		HighlightCode(input, output);
		fprintf(output, "</div>\n");
		ResetScanMode();
	}
}

void EvalMaths(bool inlineMaths)
{
	if(inlineMaths)
	{
		fprintf(output, "<span class=\"maths\">");
	}
	else
	{
		fprintf(output, "<div class=\"maths\">\n");
	}

	token t;
	EatSpaceUntilEndl(input, &t);

	while(t.type != ENDF)
	{
		if(t.type == MARKUP)
		{
			if(   (!inlineMaths && t.markup.type == MATHS_BLOCK_STOP)
			        || (inlineMaths && t.markup.type == MATHS_INLINE_STOP))
			{
				//ok
				break;
			}
			else if(   t.markup.type == MATHS_BLOCK_START
				|| t.markup.type == MATHS_INLINE_START
				|| t.markup.type == CODE_BLOCK_START
				|| t.markup.type == CODE_INLINE_START
				|| t.markup.type == HTML_BLOCK_START
				|| t.markup.type == CODE_BLOCK_STOP
				|| t.markup.type == CODE_INLINE_STOP
				|| t.markup.type == LIST)
			{
				//error
				break;
			}
		}
		switch(t.type)
		{
			case ESC:
				EvalEsc(&t);
			break;
			case MARKUP:
				EvalMarkup(&t);
			break;
			case HTML_TAG:
				EvalTag(&t);
			break;
			case ENDL:
				fprintf(output, "<br>\n");
			break;
			case SYMBOL:
				EvalMathsSymbol(&t);
			break;
			case CHAR: default:
				EvalMathsChar(&t);
			break;
		}
		GetNextToken(input, &t);
	}

	if(inlineMaths)
	{
		fprintf(output, "</span>");
	}
	else
	{
		fprintf(output, "</div>\n");
	}
}

void EvalHTMLBlock()
{
	token t;
	GetNextToken(input, &t);

	bool exit = false;
	while(t.type != ENDF && !exit)
	{
		switch(t.type)
		{
			case MARKUP:
			{
				if(t.markup.type != CODE_BLOCK_STOP)
				{
					//error;
				}
				exit = true;
			}
			break;
			case CHAR:
				putc(t.c, output);
			break;
			default:
				//error
				exit = true;
			break;
		}
		GetNextToken(input, &t);
	}
}

void Indent(int level)
{
	for(int i=0;i<level;i++)
	{
		putc('\t', output);
	}
}

void EvalList(int listLevel, int destLevel)
{
	while(listLevel < destLevel)
	{
		fprintf(output, "\n");
		Indent(listLevel);
		fprintf(output, "<ul>\n");

		listLevel++;

		Indent(listLevel);
		fprintf(output, "<li>");
		if(listLevel != destLevel)
		{
			fprintf(output, "\n");
		}
	}

	token t;
	GetNextToken(input, &t);
	bool exit = false;
	while(t.type != ENDF && !exit)
	{
		if(t.type == MARKUP && t.markup.type == LIST)
		{
			break;
		}
		switch(t.type)
		{
			case ESC:
				EvalEsc(&t);
			break;
			case MARKUP:
				EvalMarkup(&t);
			break;
			case HTML_TAG:
				EvalTag(&t);
			break;
			case ENDL:
			{
				GetNextToken(input, &t);
				if(t.type == ENDL)
				{
					exit = true;
				}
				else
				{
					if(t.type != MARKUP || t.markup.type != LIST)
					{
						fprintf(output, "<br>\n");
					}
					continue;
				}
			}
			break;
			case SYMBOL:
				EvalSymbol(&t);
			break;
			case CHAR: default:
				EvalChar(&t);
			break;
		}
		if(!exit)
		{
			GetNextToken(input, &t);
		}
	}

	if(t.type == MARKUP && t.markup.type == LIST)
	{
		if(t.markup.value >= listLevel)
		{
			if(t.markup.value == listLevel)
			{
				fprintf(output, "</li>\n");
				Indent(listLevel);
				fprintf(output, "<li>");
			}
			EvalList(listLevel, t.markup.value);
			return;
		}
		else
		{
			fprintf(output, "</li>\n");
			while(listLevel > t.markup.value )
			{
				listLevel--;
				Indent(listLevel);
				fprintf(output, "</ul>\n");
				Indent(listLevel);
				fprintf(output, "</li>\n");
			}
			if(listLevel)
			{
				Indent(listLevel);
				fprintf(output, "<li>");
				EvalList(listLevel, t.markup.value);
			}
			else
			{
				fprintf(output, "</ul>\n");
			}
		}
	}
	else
	{
		fprintf(output, "</li>\n");
		while(listLevel > 1)
		{
			listLevel--;
			Indent(listLevel);
			fprintf(output, "</ul>\n");
			Indent(listLevel);
			fprintf(output, "</li>\n");
		}
		fprintf(output, "</ul>\n");
	}
}

void EvalLongSuperscript(token* t)
{
	fprintf(output, "<sup>");
	GetNextToken(input, t);
	while(t->type != ENDF)
	{
		switch(t->type)
		{
			case ESC:
				EvalEsc(t);
			break;
			case MARKUP:
				if(  t->markup.type == CODE_BLOCK_START
				  || t->markup.type == MATHS_BLOCK_START
				  || t->markup.type == HTML_BLOCK_START
				  || t->markup.type == LIST
				  || t->markup.type == SECTION)
				{
					//error
					return;
				}
				else
				{
					EvalMarkup(t);
				}
			break;
			case HTML_TAG:
				EvalTag(t);
			break;

			case SYMBOL:
				EvalMathsSymbol(t);
			break;
			case CHAR:
				if(t->c == '}')
				{
					fprintf(output, "</sup>");
					return;
				}
				EvalMathsChar(t);
			break;

			default:
				//error
				return;
		}
		GetNextToken(input, t);
	}
}
void EvalSuperscript(token* t)
{
	GetNextToken(input, t);
	if(t->type == CHAR && t->c == '{')
	{
		EvalLongSuperscript(t);
		return;
	}
	else
	{
		fprintf(output, "<sup>&thinsp;");
		if(t->type == CHAR)
		{
			EvalMathsChar(t);
		}
		else if(t->type == SYMBOL)
		{
			EvalMathsSymbol(t);
		}
		else if(t->type == ESC)
		{
			EvalEsc(t);
		}
		else
		{
			//error
		}
		fprintf(output, "</sup>");
	}
}

void EvalLongSubscript(token* t)
{
	fprintf(output, "<sub>");
	GetNextToken(input, t);
	while(t->type != ENDF)
	{
		switch(t->type)
		{
			case ESC:
				EvalEsc(t);
			break;
			case MARKUP:
				if(  t->markup.type == CODE_BLOCK_START
				  || t->markup.type == MATHS_BLOCK_START
				  || t->markup.type == HTML_BLOCK_START
				  || t->markup.type == LIST
				  || t->markup.type == SECTION)
				{
					//error
					return;
				}
				else
				{
					EvalMarkup(t);
				}
			break;
			case HTML_TAG:
				EvalTag(t);
			break;

			case SYMBOL:
				EvalMathsSymbol(t);
			case CHAR:
				if(t->c == '}')
				{
					fprintf(output, "</sub>");
					return;
				}
				EvalMathsChar(t);
			break;

			default:
				//error
				return;
		}
		GetNextToken(input, t);
	}
}
void EvalSubscript(token* t)
{
	GetNextToken(input, t);
	if(t->type == CHAR && t->c == '{')
	{
		EvalLongSubscript(t);
		return;
	}
	else
	{
		fprintf(output, "<sub>");
		if(t->type == CHAR)
		{
			EvalMathsChar(t);
		}
		else if(t->type == SYMBOL)
		{
			EvalMathsSymbol(t);
		}
		else if(t->type == ESC)
		{
			EvalEsc(t);
		}
		else
		{
			//error
		}
		fprintf(output, "</sub>");
	}
}

void EvalVector(token* t)
{
	GetNextToken(input, t);

	if(t->type == CHAR)
	{
		EvalMathsChar(t);
	}
	else if(t->type == SYMBOL)
	{
		EvalMathsSymbol(t);
	}
	else if(t->type == ESC)
	{
		EvalEsc(t);
	}
	else
	{
		//error
	}
	fprintf(output, "<span class=\"vector\">&#8407;</span>");
}

void EvalSqrt(token* t)
{
	fprintf(output, "<span class=\"sqrt-symbol\">&radic;</span><span class=\"sqrt-arg\">&thinsp;");

	GetNextToken(input, t);
	if(t->type == CHAR && t->c == '{')
	{
		GetNextToken(input, t);
		bool exit = false;
		while(t->type != ENDF && !exit)
		{
			switch(t->type)
			{
				case ESC:
					EvalEsc(t);
				break;
				case MARKUP:
					if(  t->markup.type == CODE_BLOCK_START
					  || t->markup.type == MATHS_BLOCK_START
					  || t->markup.type == HTML_BLOCK_START
					  || t->markup.type == LIST
					  || t->markup.type == SECTION)
					{
						//error
						return;
					}
					else
					{
						EvalMarkup(t);
					}
				break;
				case HTML_TAG:
					EvalTag(t);
				break;

				case SYMBOL:
					EvalMathsSymbol(t);
				case CHAR:
					if(t->c == '}')
					{
						exit = true;
						break;
					}
					EvalMathsChar(t);
				break;

				default:
					//error
					return;
			}
			if(!exit)
			{
				GetNextToken(input, t);
			}
		}

	}
	else
	{
		if(t->type == CHAR)
		{
			EvalMathsChar(t);
		}
		else if(t->type == SYMBOL)
		{
			EvalMathsSymbol(t);
		}
		else if(t->type == ESC)
		{
			EvalEsc(t);
		}
		else
		{
			//error
		}
	}
	fprintf(output, "&nbsp;</span>");
}

void GetMathArg(token* t)
{
	GetNextToken(input, t);
	bool exit = false;
	while(t->type != ENDF && !exit)
	{
		switch(t->type)
		{
			case ESC:
				EvalEsc(t);
			break;
			case MARKUP:
				if(  t->markup.type == CODE_BLOCK_START
				  || t->markup.type == MATHS_BLOCK_START
				  || t->markup.type == HTML_BLOCK_START
				  || t->markup.type == LIST
				  || t->markup.type == SECTION)
				{
					//error
					return;
				}
				else
				{
					EvalMarkup(t);
				}
			break;
			case HTML_TAG:
				EvalTag(t);
			break;

			case SYMBOL:
				EvalMathsSymbol(t);
			case CHAR:
				if(t->c == '}')
				{
					exit = true;
					break;
				}
				EvalMathsChar(t);
			break;

			default:
				//error
				return;
		}
		if(!exit)
		{
			GetNextToken(input, t);
		}
	}
}

void EvalSumProd(token* t, bool sum)
{
	fprintf(output, "<span class=\"n-sum-product\">");

	GetNextToken(input, t);
	if(t->type == CHAR && t->c == '{')
	{
		GetNextToken(input, t);

		if(t->type == CHAR && t->c == '{')
		{
			fprintf(output, "<span class=\"range-max\">");
			GetMathArg(t);
			fprintf(output, "</span>");
		}
		else
		{
			//error
		}

		fprintf(output, "<span class=\"n-op-symbol\">%s</span>", sum ? "&sum;" : "&prod;");

		GetNextToken(input, t);
		if(t->type == CHAR && t->c == '{')
		{
			fprintf(output, "<span class=\"range-min\">");
			GetMathArg(t);
			fprintf(output, "</span>");
		}
		else
		{
			//error
		}

		GetNextToken(input, t);
		if(t->type != CHAR || t->c == '}')
		{
			//error
		}
	}
	else
	{
		//error
	}
	fprintf(output, "</span>&thinsp;");
}


void EvalFrac(token* t)
{
	fprintf(output, "<span class=\"fraction\">");

	GetNextToken(input, t);
	if(t->type == CHAR && t->c == '{')
	{
		GetNextToken(input, t);

		if(t->type == CHAR && t->c == '{')
		{
			fprintf(output, "<span class=\"numerator\">");
			GetMathArg(t);
			fprintf(output, "</span>");
		}
		else
		{
			//error
		}
		GetNextToken(input, t);
		if(t->type == CHAR && t->c == '{')
		{
			fprintf(output, "<span class=\"denominator\">");
			GetMathArg(t);
			fprintf(output, "</span>");
		}
		else
		{
			//error
		}

		GetNextToken(input, t);
		if(t->type != CHAR || t->c == '}')
		{
			//error
		}
	}
	else
	{
		//error
	}
	fprintf(output, "</span>");
}

void EvalMarkup(token* t)
{
	markup_tag* markup = &t->markup;

	switch(markup->type)
	{
		case MATHS_INLINE_START:
			EvalMaths(true);
			break;
		case MATHS_BLOCK_START:
			EvalMaths(false);
			break;
		case CODE_INLINE_START:
			EvalCode(t, true);
			break;
		case CODE_BLOCK_START:
			EvalCode(t, false);
			break;
		case HTML_BLOCK_START:
			EvalHTMLBlock();
			break;
		case URL_START:
			EvalURL(t);
			break;
		case IMG:
			EvalImage(t);
			break;
		case SECTION:
			EvalSection(t);
			break;
		case UNDERLINE:
			EvalUnderline();
			break;
		case BOLD:
			EvalBold();
			break;
		case ITALIC:
			EvalItalic();
			break;
		case REGULAR:
			EvalRegular();
			break;
		case LIST:
			EvalList(0, 1);
			break;
		case SUBSCRIPT:
			EvalSubscript(t);
			break;
		case SUPERSCRIPT:
			EvalSuperscript(t);
			break;
		case VECTOR:
			EvalVector(t);
			break;
		case SQRT:
			EvalSqrt(t);
			break;
		case FRACTION:
			EvalFrac(t);
			break;
		case NSUM:
			EvalSumProd(t, true);
			break;
		case NPRODUCT:
			EvalSumProd(t, false);
			break;

		default:
			//error
			break;
	}
}

void EvalTag(token* t)
{
	fprintf(output, "%s", t->html.text);
}

void EvalParagraph(token* t)
{
	fprintf(output, "<p>\n");

	while(t->type != ENDF)
	{
		switch(t->type)
		{
			case ESC:
				EvalEsc(t);
			break;
			case MARKUP:
				if(  t->markup.type == CODE_BLOCK_START
				  || t->markup.type == MATHS_BLOCK_START
				  || t->markup.type == HTML_BLOCK_START
				  || t->markup.type == SECTION
				  || t->markup.type == LIST)
				{
					fprintf(output, "\n</p>\n");
					return;
				}
				EvalMarkup(t);
			break;
			case HTML_TAG:
				EvalTag(t);
			break;
			case ENDL:
				GetNextToken(input, t);
				if(t->type == ENDL)
				{
					fprintf(output, "\n</p>\n");
					GetNextToken(input, t);
					return;
				}
				else
				{
					fprintf(output, "<br>\n");
				}
				continue;

			case SYMBOL:
				EvalSymbol(t);
			break;
			case CHAR: default:
				EvalChar(t);
			break;
		}
		GetNextToken(input, t);
	}
	fprintf(output, "\n</p>\n");
}

int main(int argc, char** argv)
{
    if(argc > 1)
	{
		input = fopen(argv[1], "r");
	}
	if(argc > 2)
	{
		output = fopen(argv[2], "w");
	}
	if(!input)
	{
		input = stdin;
	}
	if(!output)
	{
		output = stdout;
	}

	token t;
	GetNextToken(input, &t);

	while(t.type != ENDF)
	{
		switch(t.type)
		{
			case MARKUP:
				if(  t.markup.type == CODE_BLOCK_START
				  || t.markup.type == MATHS_BLOCK_START
				  || t.markup.type == HTML_BLOCK_START)
				{
					EvalMarkup(&t);

					//NOTE(martin): we eat the first newline after blocks
					EatSpaceUntilEndl(input, &t);
					continue;
				}
				else if(t.markup.type == SECTION)
				{
					EvalMarkup(&t);

					//NOTE(martin): we eat the first newline after blocks
					EatSpaceUntilEndl(input, &t);
					EatSpaceUntilEndl(input, &t);
					continue;
				}
				else if(t.markup.type == LIST)
				{
					EvalMarkup(&t);
					//NOTE(martin): we eat the first newline after blocks
					break;
				}
				else
				{
					EvalParagraph(&t);
					continue;
				}
			break;
			case HTML_TAG:
				EvalTag(&t);
				//NOTE(martin): we eat the first newline after a block
				EatSpaceUntilEndl(input, &t);
				continue;

			break;
			case ENDL:
				fprintf(output, "<br>\n");
			break;
			case ESC:
				if(t.c == '\n')
				{
					EvalEsc(&t);
					break;
				}
				else
				{
					EvalParagraph(&t);
				}
			break;
			case SYMBOL:
			case CHAR: default:
				EvalParagraph(&t);
				continue;
			break;
		}
		GetNextToken(input, &t);
	}

	if(input != stdin)
	{
		fclose(input);
	}
	if(output != stdout)
	{
		fclose(output);
	}
	return(0);
}