#
# == About ==
#
# This script wraps certain code block patterns in spans, enabling code syntax highlighting.
# The styling classes are defined in the bottom of styles.css
# You'll need to specify the language in markdown, like this
#
# ```cpp
# code here
# ```
#
# where cpp should be your language of choice.

BEGIN {
	# This variable specifies what language is currently being highlighted.
	# 0 is none, and >0 is the index/id of the language.
	syntaxhighlighting=0;
}

#
# -- Grammars --
#
# Code in the form
# name -> expression | expression | ...
#
# Supports "grammar" and "grammar+", the difference being that the first resets
# what grammer names have been found in predvious grammar code blocks,
# while the second doesn't.
# The idea is that you could want to define a grammar in one code block,
# do some explanations and then continue the definition with other rules.
#

syntaxhighlighting == 0 && /class="language-grammar"/ {
	grammarNamesI = 0;
	syntaxhighlighting = 1;
}

syntaxhighlighting == 0 && /class="language-grammar\+"/ {
	syntaxhighlighting = 1;
}

syntaxhighlighting == 1 {
	# Extract the name of the current grammar in the array grammarNames
	# Since a grammar name could appear in multiple different rule expressions
	grammarDef = match($0, /[[:alnum:]]+[[:blank:]]*-&#62/);
	grammarNames[++grammarNamesI] = substr($0, grammarDef, match($0, /[[:blank:]]+->[[:blank:]]+/) - grammarDef);
	# If we couldn't find a name in the current line, or the rule name already exists,
	# make sure not to "add" it. grammarNamesI acts as an array size, so decrementing it
	# effectively "removes" the current string.
	if (grammarDef == 0 || grammarNames[grammarNamesI] == "") grammarNamesI--;
	else {
		for (i = 1; i < grammarNamesI; i++) {
			if (grammarNames[i] == grammarNames[grammarNamesI]) {
				grammarNamesI--;
				break;
			}
		}
	}

	for (i = 1; i <= grammarNamesI; i++) {
		$0 = gesub(grammarNames[i], "<span [^>]*>[^<]*</[^>]*>", "<span class=\"SH-fnc\">&</span>");
	}
	gsub(/[[:blank:]]*[^-\\]-&#62;/, "<span class=\"SH-kwd\">&</span>");
	gsub(/\|/, "<span class=\"SH-kwd2\">&</span>");
}

#
# -- Regexes --
#
# Supports "regex"

syntaxhighlighting == 0 && /class="language-regex"/ {
	syntaxhighlighting = 2;
}

syntaxhighlighting == 2 {
	syntaxhighlighting = 2;

	gsub(/[\*]/, "<span class=\"SH-kwd\">&</span>");
	gsub(/[\(\)\|]/, "<span class=\"SH-kwd2\">&</span>");
}

# 
# -- Bash
#
# Supports "bash"

/class="language-bash"/ {
	syntaxhighlighting = 3;
	# The first code block line could look something like
	# <pre><code class="language-bash">class="langage-bash"
	# So, if we want to do something with the word class or strings,
	# we'll need to skip the tags from the beginning.
	tagend = match($0, /class="language-bash"/) + 21;
	prestart = substr($0, 0, tagend);
	$0 = substr($0, tagend + 1);
}

syntaxhighlighting == 3 {
	gsub(/("[^"]*"|'[^']*')/, "<span class=\"SH-str\">&</span>");
	gsub(/\$(\(|\(\(|{).+(\)|\)\)|})/, "<span class=\"SH-kwd3\">&</span>");
	gsub(/\$[^[:blank:]]+/, "<span class=\"SH-kwd3\">&</span>");
	gsub(/[[:blank:]]+-[-_[:alnum:]]+/, "<span class=\"SH-kwd2\">&</span>");
	gsub(/(^|[[:blank:]]+)(function|if|fi|then|case|esac|in|disown|==|!=|-eq|-ne|-gt|-ge|-lt|-le|;|\|\||&#38;&#38;)($|[[:blank:]])/, "<span class=\"SH-kwd\">&</span>");
	gsub(/^[[:blank:]]*[[:alnum:]]+=/, "<span class=\"SH-cls\">&</span>");
	gsub(/[-_[:alnum:]]+[[:blank:]]*\([^\)]*\)/, "<span class=\"SH-fnc\">&</span>");
	gsub(/[\{\}]/, "<span class=\"SH-fnc\">&</span>");
	gsub(/[[:blank:]]#.*$/, "<span class=\"SH-com\">&</span>");
	gsub(/(\|)/, "<span class=\"SH-none\">&</span>");
}

#
# -- C --
#
# Supports "c" and is used in C-like programming languages

/class="language-c"/ {
	syntaxhighlighting = 100;
}

syntaxhighlighting >= 100 {
	gsub(/([[:alnum:]]|[-_])+(&#60;[[:alnum:]]+&#62;)?\(/, "<span class=\"SH-fnc\">&</span>");
	gsub(/(&#47;&#47;.*|&#47;*.*&#47;)/, "<span class=\"SH-com\">&</span>");
	gsub(/[\(,\.]/, "<span class=\"SH-none\">&</span>");
	gsub(/(public|protected|private|override|new|if|else|while|for|return|struct|typedef|extern|const)[[:blank:]]/, "<span class=\"SH-kwd\">&</span>");
	gsub(/(&#38;&#38;|\|\||==|!=)/, "<span class=\"SH-kwd2\">&</span>");
	gsub(/#(include|if|ifndef|endif|define)/, "<span class=\"SH-kwd3\">&</span>");
	gsub(/(true|false)[[:blank:]]/, "<span class=\"SH-cst\">&</span>");
	gsub(/(int|void|double|bool|char)[[:blank:]]/, "<span class=\"SH-typ\">&</span>");
	$0 = gesub("(\"[^\"]*\"|'[^']*')", "<[^>]*>", "<span class=\"SH-str\">&</span>");
}

#
# -- C++ --
#
# Supports "cpp"

/class="language-cpp"/ {
	syntaxhighlighting = 101;
}

syntaxhighlighting == 101 {
	gsub(/([[:blank:]]|\()*[[:upper:]]([[:upper:]]|[-_])*([[:blank:]]|\)|,|;)+/, "<span class=\"SH-cst\">&</span>");
}

#
# -- C# --
#
# Supports "csharp"

/class="language-csharp"/ {
	syntaxhighlighting = 102;
}

syntaxhighlighting == 102 {
	gsub(/new ([[:alnum:]]|[-_])+[\(\.]/, "<span class=\"SH-cls\">&</span>");
	gsub(/(&#60;[[:alnum:]]+&#62;)/, "<span class=\"SH-kwd\">&</span>");
	gsub(/([[:blank:]]|\()*([[:upper:]]|[-_])+([[:blank:]]|\)|,|;)+/, "<span class=\"SH-cst\">&</span>");
	gsub(/(=&#62;)/, "<span class=\"SH-kwd2\">&</span>");
}

#
# -- lex --
#
# Supports "lex"

/class="language-lex"/ {
	syntaxhighlighting = 103;
}

syntaxhighlighting == 103 {
	gsub(/%[^[:blank:]]+/, "<span class=\"SH-kwd\">&</span>");
}

#
# -- yacc --
#
# Supports "yacc"

/class="language-yacc"/ {
	syntaxhighlighting = 104;
}

syntaxhighlighting == 104 {
	gsub(/%[^[:blank:]]+/, "<span class=\"SH-kwd\">&</span>");
}

tagend != 0 {
	$0 = prestart $0;
	tagend = 0;
}

syntaxhighlighting > 0 && /<\/code>/ {
	syntaxhighlighting = 0;
}