/* Copyright (C) 2003, 2004 Dave Bayer. Subject to the terms and conditions of the MIT License. */

#include "root.h"
#include "file.h"
#include "filter.h"
#include "rules.h"

/*. sourceTable */
filterRules *sourceTable[docNStates][NCHARS];

/*. sourceRules */
filterRules sourceRules[] =
{
	/* leading blank states */
	{ " ", 0, docStart, docStart },
	{ "\t", 0, docStart, docStart },
	{ "\n", 0, docStart, docStart, mergeBlank },
	{ "\n", 0, docPrint, docStart },
	{ "", 0, docStart, docPrint },

	/* comment states */
	{ "//.", 0, docStart, docPrint, mergeGlobal },
	{ "/*.", 0, docStart, docPrint, mergeGlobal },
	{ "//,", 0, docStart, docPrint, mergeLocal },
	{ "/*,", 0, docStart, docPrint, mergeLocal },
	{ "//", 0, docStart, docPrint, mergeTag },
	{ "/*", 0, docStart, docPrint, mergeTag },

	{ 0 }
};

/*. docTable */
filterRules *docTable[docNStates][NCHARS];

/*. docRules */
filterRules docRules[] =
{
	/* command states */
	{ "//@", 0, docStart, docCmd },
	{ " ", 0, docCmd, docCmd },
	{ "\t", 0, docCmd, docCmd },
	{ "", 0, docCmd, docFile, mergeCmd },
	{ "\n", 0, docFile, docStart },
	{ ".html\n", 0, docFile, docStart, mergeHtml },

	/* quote states */
	{ "\"", "<samp>", docStart, docQuote },
	{ "\"", "<samp>", docPrint, docQuote },
	{ "\"", "</samp>", docQuote, docPrint },
	{ "\\\"", "\"", docStart, docPrint },
	{ "\\\"", "\"", docPrint, docPrint },
	{ "\\\"", "\"", docQuote, docQuote },
	{ "\\\\", "\\", docStart, docPrint },
	{ "\\\\", "\\", docPrint, docPrint },
	{ "\\\\", "\\", docQuote, docQuote },
	
	/* pre states */
	{ "<pre>", 0, docStart, docPre },
	{ "<pre class=samp>", 0, docStart, docPre },
	{ "<pre class=code>", 0, docStart, docPre },
	{ "<pre>", 0, docPrint, docPre },
	{ "<pre class=samp>", 0, docPrint, docPre },
	{ "<pre class=code>", 0, docPrint, docPre },
	{ "</pre>", 0, docPre, docPrint },

	/* HTML delimiter states */
	{ "<", 0, docPrint, docHtml },
	{ ">", 0, docHtml, docPrint },
	{ "\"", 0, docHtml, docHtmlQuote },
	{ "\"", 0, docHtmlQuote, docHtml },
		
	{ 0 }
};

/*. htmlTable */
filterRules *htmlTable[htmlNStates][NCHARS];

/*. htmlRules */
filterRules htmlRules[] =
{
	/* leading blank states */
	{ " ", 0, htmlDocStart, htmlDocStart },
	{ "\t", 0, htmlDocStart, htmlDocStart },
	{ "\n", 0, htmlDocStart, htmlDocStart },
	{ "\n", 0, htmlDoc, htmlDocStart },
	{ "", 0, htmlDocStart, htmlDoc },

	{ " ", 0, htmlPreStart, htmlPreStart },
	{ "\t", 0, htmlPreStart, htmlPreStart },
	{ "\n", 0, htmlPreStart, htmlPreStart },
	{ "\n", 0, htmlPre, htmlPreStart },
	{ "", 0, htmlPreStart, htmlPre },

	/* code, samp, pre elements */
	{ "<code>", 0, htmlDoc, htmlCode },
	{ "</code>", 0, htmlCode, htmlDoc },
	
	{ "<samp>", 0, htmlDoc, htmlSamp },
	{ "</samp>", 0, htmlSamp, htmlDoc },
	
	{ "<pre>", 0, htmlDocStart, htmlPreStart },
	{ "<pre class=code>", 0, htmlDocStart, htmlPreStart },
	{ "<pre class=samp>", 0, htmlDocStart, htmlPreStart },
	{ "</pre>\n", 0, htmlPre, htmlDocStart },
	
	/* allow strong element to enclose lines within pre elements */
	{ "<strong>", 0, htmlPreStart, htmlPreStrong },
	{ "</strong>\n", 0, htmlPreStrong, htmlPreStart },

	/* html escape sequences */
	{ "<", "&lt;", htmlCode, htmlCode },
	{ ">", "&gt;", htmlCode, htmlCode },
	{ "&", "&amp;", htmlCode, htmlCode },

	{ "<", "&lt;", htmlSamp, htmlSamp },
	{ ">", "&gt;", htmlSamp, htmlSamp },
	{ "&", "&amp;", htmlSamp, htmlSamp },

	{ "<", "&lt;", htmlPre, htmlPre },
	{ ">", "&gt;", htmlPre, htmlPre },
	{ "&", "&amp;", htmlPre, htmlPre },

	{ "<", "&lt;", htmlPreStrong, htmlPreStrong },
	{ ">", "&gt;", htmlPreStrong, htmlPreStrong },
	{ "&", "&amp;", htmlPreStrong, htmlPreStrong },

	{ 0 }
};

/*. parTable */
filterRules *parTable[parNStates][NCHARS];

/*. parRules */
filterRules parRules[] =
{
	{ "<!-- par off -->", 0, parStart, parOff },
	{ "<!-- par on -->", 0, parOff, parStart },
	
	{ " ", 0, parStart, parStart },
	{ "\t", 0, parStart, parStart },
	{ "\n", 0, parStart, parStart },
	{ "", "<p>\n", parStart, parPar },
	
	{ " ", 0, parPar, parPar },
	{ "\t", 0, parPar, parPar },
	{ "\n", "</p>\n\n", parPar, parStart },
	{ "", 0, parPar, parParIn },
	{ "\n", 0, parParIn, parPar },
	
	{ "<hr>", 0, parStart, parStart },
	
	/* rules for entering block-level elements */
	{ "<pre", 0, parStart, parSkip },
	{ "<ol", 0, parStart, parSkip },
	{ "<ul", 0, parStart, parSkip },
	{ "<table", 0, parStart, parSkip },
	{ "<h1", 0, parStart, parSkip },
	{ "<h2", 0, parStart, parSkip },
	{ "<h3", 0, parStart, parSkip },
	{ "<h4", 0, parStart, parSkip },
	{ "<h5", 0, parStart, parSkip },
	{ "<h6", 0, parStart, parSkip },

	/* if already in a paragraph, first close the paragraph */
	{ "<pre", "</p>\n<pre", parPar, parSkip },
	{ "<ol", "</p>\n<ol", parPar, parSkip },
	{ "<ul", "</p>\n<ul", parPar, parSkip },
	{ "<table", "</p>\n<table", parPar, parSkip },

	/* rules for exiting block-level elements */
	{ "</pre>", 0, parSkip, parStart },
	{ "</ol>", 0, parSkip, parStart },
	{ "</ul>", 0, parSkip, parStart },
	{ "</table>", 0, parSkip, parStart },
	{ "</h1>", 0, parSkip, parStart },
	{ "</h2>", 0, parSkip, parStart },
	{ "</h3>", 0, parSkip, parStart },
	{ "</h4>", 0, parSkip, parStart },
	{ "</h5>", 0, parSkip, parStart },
	{ "</h6>", 0, parSkip, parStart },

	{ 0 }
};

/*. dictTable */
filterRules *dictTable[dictNStates][NCHARS];

/*. dictRules */
filterRules dictRules[] =
{
	/* code rules */
	{ "<code>", 0, dictStart, dictCode },
	{ "</code>", 0, dictCode, dictStart },
	{ "</code>", 0, dictCodeSQuote, dictStart },
	{ "</code>", 0, dictCodeDQuote, dictStart },

	{ "<strong>", 0, dictCode, dictCode },
	{ "</strong>", 0, dictCode, dictCode },

	{ "'", 0, dictCode, dictCodeSQuote },
	{ "'", 0, dictCodeSQuote, dictCode },
	
	{ "\"", 0, dictCode, dictCodeDQuote },
	{ "\"", 0, dictCodeDQuote, dictCode },
	
	{ "\\'", 0, dictCode, dictCode },
	{ "\\'", 0, dictCodeSQuote, dictCodeSQuote },
	{ "\\'", 0, dictCodeDQuote, dictCodeDQuote },
	
	{ "\\\"", 0, dictCode, dictCode },
	{ "\\\"", 0, dictCodeSQuote, dictCodeSQuote },
	{ "\\\"", 0, dictCodeDQuote, dictCodeDQuote },

	/* samp rules */
	{ "<samp>", 0, dictStart, dictSamp },
	{ "</samp>", 0, dictSamp, dictStart },
	{ "</samp>", 0, dictSampSQuote, dictStart },
	{ "</samp>", 0, dictSampDQuote, dictStart },
	
	{ "<strong>", 0, dictSamp, dictSamp },
	{ "</strong>", 0, dictSamp, dictSamp },
	
	{ "'", 0, dictSamp, dictSampSQuote },
	{ "'", 0, dictSampSQuote, dictSamp },
	
	{ "\"", 0, dictSamp, dictSampDQuote },
	{ "\"", 0, dictSampDQuote, dictSamp },
	
	{ "\\'", 0, dictSamp, dictSamp },
	{ "\\'", 0, dictSampSQuote, dictSampSQuote },
	{ "\\'", 0, dictSampDQuote, dictSampDQuote },
	
	{ "\\\"", 0, dictSamp, dictSamp },
	{ "\\\"", 0, dictSampSQuote, dictSampSQuote },
	{ "\\\"", 0, dictSampDQuote, dictSampDQuote },

	/* pre rules */
	{ "<pre>", 0, dictStart, dictPre },
	{ "<pre class=code>", 0, dictStart, dictPre },
	{ "<pre class=samp>", 0, dictStart, dictPre },
	{ "</pre>", 0, dictPre, dictStart },
	{ "</pre>", 0, dictPreSQuote, dictStart },
	{ "</pre>", 0, dictPreDQuote, dictStart },

	{ "<strong>", 0, dictPre, dictPre },
	{ "</strong>", 0, dictPre, dictPre },

	{ "'", 0, dictPre, dictPreSQuote },
	{ "'", 0, dictPreSQuote, dictPre },
	
	{ "\"", 0, dictPre, dictPreDQuote },
	{ "\"", 0, dictPreDQuote, dictPre },
	
	{ "\\'", 0, dictPre, dictPre },
	{ "\\'", 0, dictPreSQuote, dictPreSQuote },
	{ "\\'", 0, dictPreDQuote, dictPreDQuote },
	
	{ "\\\"", 0, dictPre, dictPre },
	{ "\\\"", 0, dictPreSQuote, dictPreSQuote },
	{ "\\\"", 0, dictPreDQuote, dictPreDQuote },

	{ 0 }
};