/// __  ____ _ _ __   __ _ _   _  __ _  __ _  ___
/// \ \/ / _` | '_ \ / _` | | | |/ _` |/ _` |/ _ \
///  >  < (_| | | | | (_| | |_| | (_| | (_| |  __/
/// /_/\_\__,_|_| |_|\__, |\__,_|\__,_|\__, |\___|
///                  |___/             |___/
///
/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
///
/// xolatile@chud.cyou - xanguage - Syntax definitions of programming languages that I care about (and some that I don't care about).
///
/// This program is free software, free as in freedom and as in free beer, you can redistribute it and/or modify it under the terms of the GNU
/// General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version if you wish...
///
/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied
/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License
/// for more details, if you dare, it is a lot of text that nobody wants to read...

typedef enum {
	language_common,                language_ada,                   language_c,                     language_cpp,
	language_d,                     language_eaxhla,                language_flat,                  language_fortran,
	language_pascal,                language_python,                language_go,                    language_lua,
	language_bash,                  language_haskell,               language_valgrind,
	language_count
} language_enumeration;

typedef struct {
	uint comment_colour;
	uint processor_colour;
	uint character_colour;
	uint string_colour;
	uint keyword_colour;
	uint type_colour;
	uint bracket_colour;
	uint operator_colour;
	uint number_colour;
	uint lowercase_colour;
	uint uppercase_colour;
	uint underscore_colour;
	uint register_colour;
	uint extension_colour;
	uint fatal_colour;
	uint comment_effect;
	uint processor_effect;
	uint character_effect;
	uint string_effect;
	uint keyword_effect;
	uint type_effect;
	uint bracket_effect;
	uint operator_effect;
	uint number_effect;
	uint lowercase_effect;
	uint uppercase_effect;
	uint underscore_effect;
	uint register_effect;
	uint extension_effect;
	uint fatal_effect;
} language_structure;

#include "./xanguage/common.h"
#include "./xanguage/ada.h"
#include "./xanguage/c.h"
#include "./xanguage/c++.h"
#include "./xanguage/d.h"
#include "./xanguage/eaxhla.h"
#include "./xanguage/flat.h"
#include "./xanguage/fortran.h"
#include "./xanguage/pascal.h"
#include "./xanguage/python.h"
#include "./xanguage/go.h"
#include "./xanguage/lua.h"
#include "./xanguage/bash.h"
#include "./xanguage/haskell.h"
#include "./xanguage/valgrind.h"

static language_structure * language_initialize (bool true_colour) {
	language_structure * language = allocate (sizeof (* language));

	if (true_colour == true) {
		language->comment_colour    = 0xff777777u;
		language->processor_colour  = 0xff3377aau;
		language->character_colour  = 0xff7733ccu;
		language->string_colour     = 0xffcc3377u;
		language->keyword_colour    = 0xff33cceeu;
		language->type_colour       = 0xff55cceeu;
		language->bracket_colour    = 0xffee5533u;
		language->operator_colour   = 0xffeeaa33u;
		language->number_colour     = 0xffee33aau;
		language->lowercase_colour  = 0xffccccccu;
		language->uppercase_colour  = 0xffeeeeeeu;
		language->underscore_colour = 0xffaaaaaau;
		language->register_colour   = 0xff5577aau;
		language->extension_colour  = 0xff55aaccu;
		language->fatal_colour      = 0xffcc7755u;
	} else {
		language->comment_colour    = colour_grey;
		language->processor_colour  = colour_cyan;
		language->character_colour  = colour_pink;
		language->string_colour     = colour_pink;
		language->keyword_colour    = colour_yellow;
		language->type_colour       = colour_yellow;
		language->bracket_colour    = colour_blue;
		language->operator_colour   = colour_cyan;
		language->number_colour     = colour_pink;
		language->lowercase_colour  = colour_white;
		language->uppercase_colour  = colour_white;
		language->underscore_colour = colour_white;
		language->register_colour   = colour_cyan;
		language->extension_colour  = colour_yellow;
		language->fatal_colour      = colour_red;
		language->comment_effect    = effect_bold;
		language->processor_effect  = effect_italic;
		language->character_effect  = effect_bold;
		language->string_effect     = effect_normal;
		language->keyword_effect    = effect_bold;
		language->type_effect       = effect_normal;
		language->bracket_effect    = effect_bold;
		language->operator_effect   = effect_normal;
		language->number_effect     = effect_bold;
		language->lowercase_effect  = effect_normal;
		language->uppercase_effect  = effect_bold;
		language->underscore_effect = effect_italic;
		language->register_effect   = effect_italic;
		language->extension_effect  = effect_italic;
		language->fatal_effect      = effect_bold;
	}

	return (language);
}

static language_structure * language_deinitialize (language_structure * language) {
	return (deallocate (language));
}

static void (* language_highlighter (language_enumeration language)) (language_structure * language, syntax_structure * syntax) {
	static void (* highlighter [language_count]) (language_structure * language, syntax_structure * syntax) = {
		language_highlight_common,      language_highlight_ada,         language_highlight_c,           language_highlight_cpp,
		language_highlight_d,           language_highlight_eaxhla,      language_highlight_flat,        language_highlight_fortran,
		language_highlight_pascal,      language_highlight_python,      language_highlight_go,          language_highlight_lua,
		language_highlight_bash,        language_highlight_haskell,     language_highlight_valgrind
	};

	fatal_failure (language >= language_count, "language_highlighter: Language index not in enumeration.");

	return (highlighter [language]);
}

static char * language_short_option (language_enumeration language) {
	static char * short_option [language_count] = {
		"-X",   "-A",   "-C",   "-S",   "-D",   "-E",   "-T",   "-F",   "-P",   "-Y",   "-G",   "-L",   "-B",   "-H",   "-V"
	};

	fatal_failure (language >= language_count, "language_short_option: Language index not in enumeration.");

	return (short_option [language]);
}

static char * language_long_option (language_enumeration language) {
	static char * long_option [language_count] = {
		"--common",     "--ada",        "--c",          "--cpp",        "--d",          "--eaxhla",     "--flat",       "--fortran",
		"--pascal",     "--python",     "--go",         "--lua",        "--bash",       "--haskell",    "--valgrind"
	};

	fatal_failure (language >= language_count, "language_long_option: Language index not in enumeration.");

	return (long_option [language]);
}

static char * language_identifier (language_enumeration language) {
	static char * identifier [language_count] = {
		"Common",       "Ada",          "C",            "C++",          "D",            "EAXHLA",       "Flat",         "Fortran",
		"Pascal",       "Python",       "Go",           "Lua",          "Bash",         "Haskell",      "Valgrind"
	};

	fatal_failure (language >= language_count, "language_identifier: Language index not in enumeration.");

	return (identifier [language]);
}

static void language_conditionally_select (language_structure * language, syntax_structure * syntax, uint select) {
	if (syntax->count == 0) {
		if ((select == file_type_c_source) || (select == file_type_c_header)) {
			language_highlight_c (language, syntax);
		} else if ((select == file_type_ada_sexy_body) || (select == file_type_ada_specification)) {
			language_highlight_ada (language, syntax);
		} else if ((select == file_type_cpp_source) || (select == file_type_cpp_header)) {
			language_highlight_cpp (language, syntax);
		} else if (select == file_type_flat_assembly) {
			language_highlight_flat (language, syntax);
		} else if (select == file_type_fortran_90_source) {
			language_highlight_fortran (language, syntax);
		} else if (select == file_type_pascal_source) {
			language_highlight_pascal (language, syntax);
		} else if (select == file_type_eax_assembly) {
			language_highlight_eaxhla (language, syntax);
		} else if (select == file_type_python_script) {
			language_highlight_python (language, syntax);
		} else {
			language_highlight_common (language, syntax);
		}
	}
}