#ifndef null
#define null ((void *) 0)
#endif

enum {
	false,
	true
};

enum {
	file_type_text,                         file_type_common_assembly,              file_type_flat_assembly,                file_type_gnu_assembly,
	file_type_netwide_assembly,             file_type_yet_another_assembly,         file_type_c_source,                     file_type_c_header,
	file_type_ada_body,                     file_type_ada_specification,            file_type_cpp_source,                   file_type_cpp_header,
	file_type_count
};

enum {
	effect_normal,      effect_bold,        effect_italic,      effect_underline,   effect_blink,       effect_reverse,
	effect_count
};

enum {
	colour_grey,        colour_red,         colour_green,       colour_yellow,      colour_blue,        colour_pink,        colour_cyan,        colour_white,
	colour_count
};

enum {
	character_null,                         character_start_header,                 character_start_text,                   character_end_text,
	character_end_transmission,             character_enquiry,                      character_acknowledge,                  character_bell,
	character_backspace,                    character_tab_horizontal,               character_line_feed,                    character_tab_vertical,
	character_form_feed,                    character_carriage_return,              character_shift_out,                    character_shift_in,
	character_data_link_escape,             character_device_control_1,             character_device_control_2,             character_device_control_3,
	character_device_control_4,             character_not_acknowledge,              character_synchronous_idle,             character_end_transmission_block,
	character_cancel,                       character_end_medium,                   character_substitute,                   character_escape,
	character_file_separator,               character_group_separator,              character_record_separator,             character_unit_separator
};

enum {
	signal_none,
	signal_any,
	signal_a,           signal_b,           signal_c,           signal_d,           signal_e,           signal_f,           signal_g,           signal_h,
	signal_i,           signal_j,           signal_k,           signal_l,           signal_m,           signal_n,           signal_o,           signal_p,
	signal_q,           signal_r,           signal_s,           signal_t,           signal_u,           signal_v,           signal_w,           signal_x,
	signal_y,           signal_z,           signal_0,           signal_1,           signal_2,           signal_3,           signal_4,           signal_5,
	signal_6,           signal_7,           signal_8,           signal_9,           signal_escape,      signal_tabulator,   signal_return,      signal_new_line,
	signal_slash,       signal_backslash,   signal_quote,       signal_backquote,   signal_space,       signal_backspace,   signal_dot,         signal_comma,
	signal_cite,        signal_caps_lock,   signal_l_bracket,   signal_r_bracket,   signal_minus,       signal_equal,
	signal_count
};

static void in  (void * data, int size);
static void out (void * data, int size);

extern void echo (char * data);

extern void fatal_failure (int condition, char * message);

extern void limit (int * value, int minimum, int maximum);

extern void * allocate   (int size);
extern void * reallocate (void * data, int size);
extern void * deallocate (void * data);

extern int    file_open   (char * name, int mode);
extern int    file_close  (int file);
extern void   file_read   (int file, void * data, int size);
extern void   file_write  (int file, void * data, int size);
extern int    file_seek   (int file, int whence);
extern int    file_size   (char * name);
extern int    file_type   (char * name);
extern void * file_record (char * name);
extern char * file_import (char * name);
extern void   file_export (char * name, void * data);

extern void file_list_import           (char * name);
extern void file_list_export           (char * name);
extern void file_list_insert_character (char character, int position);
extern void file_list_remove_character (int position);
extern void file_list_delete           (void);

extern int character_compare_array (char character, char * character_array);

extern int character_count (char * string, char this, int from, int to, char stop);

extern int string_length (char * string);

extern char * string_reverse_limit (char * string, int limit);
extern char * string_reverse       (char * string);

extern char * string_delete (char * string, int length);

extern int    string_compare     (char * string_0, char * string_1);
extern char * string_copy        (char * string_0, char * string_1);
extern char * string_concatenate (char * string_0, char * string_1);

extern int    string_compare_limit     (char * string_0, char * string_1, int limit);
extern char * string_copy_limit        (char * string_0, char * string_1, int limit);
extern char * string_concatenate_limit (char * string_0, char * string_1, int limit);

extern char * string_realign (char * string, int amount, char character);

extern void terminal_clear       (void);
extern void terminal_colour      (int colour, int effect);
extern void terminal_cancel      (void);
extern void terminal_show_cursor (int show);

extern char * number_to_string (int number);
extern char * format_to_string (int number, int sigmoid, int base, int amount, char character);

extern int random_integer (int minimum, int maximum);

extern int syntax_define (int enrange, int derange, char * begin, char * end, char escape, int colour, int effect);

extern int syntax_select (char * string, int * length);

#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>

static int      file_list_active = 0;
static int      file_list_count  = 0;
static int    * file_list_mark   = null;
static int    * file_list_size   = null;
static char * * file_list_name   = null;
static char * * file_list_data   = null;

static int      syntax_count     = 0;
static int      syntax_active    = false;
static int    * syntax_enrange   = null;
static int    * syntax_derange   = null;
static char * * syntax_begin     = null;
static char * * syntax_end       = null;
static char   * syntax_escape    = null;
static int    * syntax_colour    = null;
static int    * syntax_effect    = null;

void in (void * data, int size) {
	fatal_failure (data == null, "in: Failed to read from standard input, data is null pointer.");
	fatal_failure (size == 0,    "in: Failed to read from standard input, size is zero.");

	(void) read (STDIN_FILENO, data, (unsigned long int) size);
}

void out (void * data, int size) {
	fatal_failure (data == null, "out: Failed to write to standard output, data is null pointer.");
	fatal_failure (size == 0,    "out: Failed to write to standard output, size is zero.");

	(void) write (STDOUT_FILENO, data, (unsigned long int) size);
}

void echo (char * data) {
	if (data == null) {
		return;
	}

	out (data, string_length (data));
}

void fatal_failure (int condition, char * message) {
	if (condition != 0) {
		echo ("[\033[1;31mExiting\033[0m] ");
		echo (message);
		echo ("\n");

		exit (EXIT_FAILURE);
	}
}

void limit (int * value, int minimum, int maximum) {
	if (  value == null   ) { return;            }
	if (* value <= minimum) { * value = minimum; }
	if (* value >= maximum) { * value = maximum; }
}

void * allocate (int size) {
	char * data = null;

	if (size <= 0) {
		return (null);
	}

	data = calloc ((unsigned long int) size, sizeof (* data));

	fatal_failure (data == null, "standard : allocate : Failed to allocate memory, internal function 'calloc' returned null pointer.");

	return ((void *) data);
}

void * reallocate (void * data, int size) {
	if (size <= 0) {
		return (data);
	}

	data = realloc (data, (unsigned long int) size);

	fatal_failure (data == null, "standard : reallocate: Failed to reallocate memory, internal function 'realloc' returned null pointer.");

	/* Set new data to 0. */

	return (data);
}

void * deallocate (void * data) {
	if (data != null) {
		free (data);
	}

	return (null);
}

int file_open (char * name, int mode) {
	int descriptor = -1;

	fatal_failure (name == null, "file_open: Failed to open file, name is null pointer.");

	descriptor = open (name, mode);

	fatal_failure (descriptor == -1, "file_open: Failed to open file, function open returned invalid descriptor.");

	return (descriptor);
}

int file_close (int file) {
	fatal_failure (file         == -1, "file_close: Failed to close file, invalid file descriptor.");
	fatal_failure (close (file) == -1, "file_close: Failed to close file, function close returned invalid code.");

	return (-1);
}

void file_read (int file, void * data, int size) {
	fatal_failure (file == -1,   "file_read: Failed to read from file, invalid descriptor.");
	fatal_failure (data == null, "file_read: Failed to read from file, data is null pointer.");
	fatal_failure (size == 0,    "file_read: Failed to read from file, size is zero.");

	(void) read (file, data, (unsigned long int) size);
}

void file_write (int file, void * data, int size) {
	fatal_failure (file == -1,   "file_write: Failed to write to file, invalid descriptor.");
	fatal_failure (data == null, "file_write: Failed to write to file, data is null pointer.");
	fatal_failure (size == 0,    "file_write: Failed to write to file, size is zero.");

	(void) write (file, data, (unsigned long int) size);
}

int file_seek (int file, int whence) {
	fatal_failure (file == -1, "file_seek: Failed to seek in file, invalid descriptor.");

	return ((int) lseek (file, 0, whence));
}

int file_size (char * name) {
	int size = -1;
	int file = -1;

	file = file_open (name, O_RDONLY);

	size = lseek (file, 0, SEEK_END);

	fatal_failure (size == -1, "file_size: Failed to get size of file, invalid file size.");

	file = file_close (file);

	return (size);
}

int file_type (char * name) {
	char * file_type_data [file_type_count] = {
		".txt",     ".s",       ".fasm",    ".gasm",    ".nasm",    ".yasm",    ".c",       ".h",
		".adb",     ".ads",     ".cpp",     ".hpp"
	};

	int type = 0;

	while (* name != '.') {
		++name;
	}

	for (type = 0; type != file_type_count; ++type) {
		if (string_compare (name, file_type_data [type]) != 0) {
			return (type);
		}
	}

	return (-1);
}

void * file_record (char * name) {
	int    file = -1;
	int    size = -1;
	char * data = null;

	fatal_failure (name == null, "file_import: Failed to import file, name is null pointer.");

	file = file_open (name, O_RDONLY);
	size = file_size (name);
	data = allocate  (size);

	file_read (file, data, size);

	file = file_close (file);

	return (data);
}

char * file_import (char * name) {
	int    file = -1;
	int    size = -1;
	char * data = null;

	fatal_failure (name == null, "file_import: Failed to import file, name is null pointer.");

	file = file_open (name, O_RDONLY);
	size = file_size (name) + 1;
	data = allocate  (size);

	file_read (file, data, size - 1);

	data [size - 1] = '\0';

	file = file_close (file);

	return (data);
}

void file_export (char * name, void * data) {
	(void) name;
	(void) data;
}

void file_list_import (char * name) {
	fatal_failure (name == null, "file_list_import: Failed to import file, name is null pointer.");

	++file_list_count;

	file_list_active = file_list_count - 1;

	file_list_mark = reallocate (file_list_mark, (int) sizeof (* file_list_mark) * file_list_count);
	file_list_size = reallocate (file_list_size, (int) sizeof (* file_list_size) * file_list_count);
	file_list_name = reallocate (file_list_name, (int) sizeof (* file_list_name) * file_list_count);
	file_list_data = reallocate (file_list_data, (int) sizeof (* file_list_data) * file_list_count);

	file_list_mark [file_list_active] = -1;
	file_list_size [file_list_active] = -1;
	file_list_name [file_list_active] = null;
	file_list_data [file_list_active] = null;

	file_list_name [file_list_active] = allocate (string_length (name) + 1);

	(void) string_copy_limit (file_list_name [file_list_active], name, string_length (name) + 1);

	file_list_mark [file_list_active] = open (name, O_RDWR);

	fatal_failure (file_list_mark [file_list_active] == -1, "file_list_import: Failed to open file, function open returned invalid descriptor.");

	file_list_size [file_list_active] = (int) lseek (file_list_mark [file_list_active], 0, SEEK_END) + 1;

	(void) lseek (file_list_mark [file_list_active], 0, SEEK_SET);

	file_list_data [file_list_active] = allocate (file_list_size [file_list_active]);

	(void) read (file_list_mark [file_list_active], file_list_data [file_list_active], (unsigned long int) (file_list_size [file_list_active] - 1));

	close (file_list_mark [file_list_active]);

	file_list_data [file_list_active] [file_list_size [file_list_active] - 1] = '\0';
}

void file_list_export (char * name) {
	fatal_failure (name == null, "file_list_export: Failed to export file, name is null pointer.");

	file_list_mark [file_list_active] = open (name, O_WRONLY | O_CREAT | O_TRUNC);

	(void) write (file_list_mark [file_list_active], file_list_data [file_list_active], (unsigned long int) file_list_size [file_list_active]);

	close (file_list_mark [file_list_active]);
}

void file_list_insert_character (char character, int position) {
	int offset;

	++file_list_size [file_list_active];

	if (file_list_size [file_list_active] < string_length (file_list_data [file_list_active])) {
		file_list_data [file_list_active] = reallocate (file_list_data [file_list_active], file_list_size [file_list_active]);
	}

	file_list_data [file_list_active] = reallocate (file_list_data [file_list_active], file_list_size [file_list_active]);

	for (offset = file_list_size [file_list_active] - 1; offset != position; --offset) {
		file_list_data [file_list_active] [offset] = file_list_data [file_list_active] [offset - 1];
	}

	file_list_data [file_list_active] [position] = character;
}

void file_list_remove_character (int position) {
	int offset;

	if (position == 0) {
		return;
	}

	--file_list_size [file_list_active];

	for (offset = position - 1; offset != file_list_size [file_list_active] - 1; ++offset) {
		file_list_data [file_list_active] [offset] = file_list_data [file_list_active] [offset + 1];
	}

	file_list_data [file_list_active] [offset] = '\0';
}

void file_list_delete (void) {
	int i;

	for (i = 0; i != file_list_count; ++i) {
		file_list_name [i] = deallocate (file_list_name [i]);
		file_list_data [i] = deallocate (file_list_data [i]);
	}

	file_list_mark = deallocate (file_list_mark);
	file_list_size = deallocate (file_list_size);
	file_list_name = deallocate (file_list_name);
	file_list_data = deallocate (file_list_data);
}

int character_compare_array (char character, char * character_array) {
	int i = 0;

	do {
		if (character == character_array [i]) {
			return (1);
		}
	} while (++i != string_length (character_array));

	return (0);
}

int character_count (char * string, char this, int from, int to, char stop) {
	int count;

	for (count = 0; (from != to) && (string [from] != stop); from += ((to < from) ? -1 : 1)) {
		count += (int) ((string [from] == this) || (this == '\0'));
	}

	return (count);
}

int string_length (char * string) {
	int length;

	if (string == null) {
		return (0);
	}

	for (length = 0; string [length] != '\0'; ++length);

	return (length);
}

char * string_reverse_limit (char * string, int limit) {
	int i;

	fatal_failure (string == null, "string_reverse: String is null pointer.");

	for (i = 0; i < limit / 2; ++i) {
		char temporary         = string [i];
		string [i]             = string [limit - 1 - i];
		string [limit - 1 - i] = temporary;
	}

	return (string);
}

char * string_reverse (char * string) {
	return (string_reverse_limit (string, string_length (string)));
}

char * string_delete (char * string, int length) {
	int i;

	if ((string == null) || (length <= 0)) {
		return (string);
	}

	for (i = 0; i != length; ++i) {
		string [i] = '\0';
	}

	return (string);
}

int string_compare (char * string_0, char * string_1) {
	int i = 0;

	fatal_failure (string_0 == null, "string_compare: Destination string is null pointer.");
	fatal_failure (string_1 == null, "string_compare: Source string is null pointer.");

	for (i = 0; (string_0 [i] != '\0') && (string_1 [i] != '\0'); ++i) {
		if (string_0 [i] != string_1 [i]) {
			return (0);
		}
	}

	return (1);
}

char * string_copy (char * string_0, char * string_1) {
	int i = 0;

	fatal_failure (string_0 == null, "string_copy: Destination string is null pointer.");
	fatal_failure (string_1 == null, "string_copy: Source string is null pointer.");

	for (i = 0; i != string_length (string_1) + 1; ++i) {
		string_0 [i] = string_1 [i];
	}

	return (string_0);
}

char * string_concatenate (char * string_0, char * string_1) {
	fatal_failure (string_0 == null, "string_concatenate: Destination string is null pointer.");
	fatal_failure (string_1 == null, "string_concatenate: Source string is null pointer.");

	string_0 += string_length (string_0);

	while (* string_1 != '\0') {
		* string_0++ = * string_1++;
		/*++string_0;
		++string_1;*/
	}

	* string_0 = '\0';

	return (string_0);
}

int string_compare_limit (char * string_0, char * string_1, int limit) {
	int i = 0;

	fatal_failure (string_0 == null, "string_compare_limit: Destination string is null pointer.");
	fatal_failure (string_1 == null, "string_compare_limit: Source string is null pointer.");

	for (i = 0; i != limit; ++i) {
		if (string_0 [i] != string_1 [i]) {
			return (0);
		}
	}

	return (1);
}

char * string_copy_limit (char * string_0, char * string_1, int limit) {
	int i = 0;

	fatal_failure (string_0 == null, "string_copy_limit: Destination string is null pointer.");
	fatal_failure (string_1 == null, "string_copy_limit: Source string is null pointer.");

	if (limit <= 0) {
		return (string_0);
	}

	for (i = 0; i != limit; ++i) {
		string_0 [i] = string_1 [i];
	}

	return (string_0);
}

char * string_concatenate_limit (char * string_0, char * string_1, int limit) {
	int i        = 0;
	int length_0 = 0;
	int length_1 = 0;

	fatal_failure (string_0 == null, "string_concatenate_limit: Destination string is null pointer.");
	fatal_failure (string_1 == null, "string_concatenate_limit: Source string is null pointer.");

	if (limit <= 0) {
		return (string_0);
	}

	length_0 = string_length (string_0);
	length_1 = string_length (string_1);

	for (i = 0; (i != length_1) && (i != limit); ++i) {
		string_0 [length_0 + i] = string_1 [i];
	}

	return (string_0);
}

char * string_realign (char * string, int amount, char character) {
	int offset, length;

	length = string_length (string);

	for (offset = 0; offset != length; ++offset) {
		string [amount - offset - 1] = string [length - offset - 1];
	}

	for (offset = 0; offset != amount - length; ++offset) {
		string [offset] = character;
	}

	string [amount] = '\0';

	return (string);
}

void terminal_clear (void) {
	echo ("\033[2J\033[H");
}

void terminal_colour (int colour, int effect) {
	char format [8] = "\033[ ;3 m";

	format [2] = (char) (effect % effect_count) + '0';
	format [5] = (char) (colour % colour_count) + '0';

	echo (format);
}

void terminal_cancel (void) {
	echo ("\033[0m");
}

void terminal_show_cursor (int show) {
	if (show != 0) {
		echo ("\033[?25h");
	} else {
		echo ("\033[?25l");
	}
}

char * number_to_string (int number) {
	int i, sigmoid;

	static char string [32];

	string_delete (string, 32);

	if (number == 0) {
		string [0] = '0';
		string [1] = '\0';
		return (string);
	}

	if (number < 0) {
		number *= -1;
		sigmoid = 1;
	} else {
		sigmoid = 0;
	}

	for (i = (string [0] == '-'); number != 0; ++i) {
		string [i] = (char) (number % 10) + '0';
		number /= 10;
	}

	if (sigmoid != 0) {
		string [i] = '-';
		++i;
	}

	string [i] = '\0';

	string_reverse (string);

	return (string);
}

char * format_to_string (int number, int sigmoid, int base, int amount, char character) {
	int i;

	static char string [32];

	string_delete (string, 32);

	if (number == 0) {
		string [0] = '0';
		string [1] = '\0';

		string_realign (string, amount, character);

		return (string);
	}

	if (number < 0) {
		number *= -1;
	}

	for (i = (string [0] == '-'); number != 0; ++i) {
		string [i] = "0123456789ABCDEF" [number % base];
		number /= base;
	}

	if (sigmoid != 0) {
		string [i] = '-';
		++i;
	}

	string [i] = '\0';

	string_reverse (string);

	string_realign (string, amount, character);

	return (string);
}

static void syntax_delete (void) {
	int offset;

	if (syntax_active == false) {
		return;
	}

	for (offset = 0; offset < syntax_count; ++offset) {
		syntax_begin [offset] = deallocate (syntax_begin [offset]);
		syntax_end   [offset] = deallocate (syntax_end   [offset]);
	}

	syntax_enrange = deallocate (syntax_enrange);
	syntax_derange = deallocate (syntax_derange);
	syntax_begin   = deallocate (syntax_begin);
	syntax_end     = deallocate (syntax_end);
	syntax_escape  = deallocate (syntax_escape);
	syntax_colour  = deallocate (syntax_colour);
	syntax_effect  = deallocate (syntax_effect);

	syntax_active = false;
	syntax_count  = 0;
}

int random_integer (int minimum, int maximum) {
	return (((int) rand () % (maximum - minimum + 1)) + minimum);
}

int syntax_define (int enrange, int derange, char * begin, char * end, char escape, int colour, int effect) {
	if (syntax_active == false) {
		syntax_active = true;

		atexit (syntax_delete);
	}

	fatal_failure (begin == null, "syntax_define: Begin string is null pointer.");
	fatal_failure (end   == null, "syntax_define: End string is null pointer.");

	++syntax_count;

	syntax_enrange = reallocate (syntax_enrange, syntax_count * (int) sizeof (* syntax_enrange));
	syntax_derange = reallocate (syntax_derange, syntax_count * (int) sizeof (* syntax_derange));
	syntax_begin   = reallocate (syntax_begin,   syntax_count * (int) sizeof (* syntax_begin));
	syntax_end     = reallocate (syntax_end,     syntax_count * (int) sizeof (* syntax_end));
	syntax_escape  = reallocate (syntax_escape,  syntax_count * (int) sizeof (* syntax_escape));
	syntax_colour  = reallocate (syntax_colour,  syntax_count * (int) sizeof (* syntax_colour));
	syntax_effect  = reallocate (syntax_effect,  syntax_count * (int) sizeof (* syntax_effect));

	syntax_begin [syntax_count - 1] = allocate ((string_length (begin) + 1) * (int) sizeof (* * syntax_begin));
	syntax_end   [syntax_count - 1] = allocate ((string_length (end)   + 1) * (int) sizeof (* * syntax_end));

	syntax_enrange [syntax_count - 1] = enrange;
	syntax_derange [syntax_count - 1] = derange;
	syntax_escape  [syntax_count - 1] = escape;
	syntax_colour  [syntax_count - 1] = colour;
	syntax_effect  [syntax_count - 1] = effect;

	string_copy (syntax_begin [syntax_count - 1], begin);
	string_copy (syntax_end   [syntax_count - 1], end);

	return (syntax_count - 1);
}

int syntax_select (char * string, int * length) {
	int offset, subset, select;

	fatal_failure (syntax_active == false, "syntax_select: Syntax is not active.");
	fatal_failure (string        == null,  "syntax_select: String is null.");
	fatal_failure (length        == null,  "syntax_select: Length is null.");

	for (select = offset = 0; select != syntax_count; ++select) {
		if (syntax_enrange [select] == false) {
			if (syntax_derange [select] == false) {
				if (string_compare_limit (string, syntax_begin [select], string_length (syntax_begin [select])) == true) {
					break;
				}
			} else {
				if ((string_compare_limit    (string, syntax_begin [select], string_length (syntax_begin [select]))         == true)
				&&  (character_compare_array (string [offset + string_length (syntax_begin [select])], syntax_end [select]) == true)) {
					break;
				}
			}
		} else {
			for (subset = 0; subset != string_length (syntax_begin [select]); ++subset) {
				if (string [offset] == syntax_begin [select] [subset]) {
					goto selected;
				}
			}
		}
	}

	selected:

	if (select >= syntax_count) {
		* length = 1;

		return (syntax_count);
	}

	for (offset = 1; string [offset - 1] != '\0'; ++offset) {
		if (string [offset] == syntax_escape [select]) {
			++offset;
			continue;
		}

		if (syntax_derange [select] == false) {
			if (string_compare_limit (& string [offset], syntax_end [select], string_length (syntax_end [select])) == true) {
				* length = offset + string_length (syntax_end [select]);
				return (select);
			}
		} else {
			subset = 0;
			if (string_compare (syntax_end [select], "") == false) {
				break;
			} do {
				if (string [offset] == syntax_end [select] [subset]) {
					* length = offset;
					goto finished;
				}
			} while (++subset != string_length (syntax_end [select]));
		}
	}

	finished:

	return (select);
}