xtandard/xtandard.c

#ifndef XTANDARD_SOURCE
#define XTANDARD_SOURCE

#include <xolatile/xtandard.h>

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

static char * log_notify = null;

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;

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 log_in (int type, int flag, char * data) {
	int start;

	char * type_mark [log_count] = {
		"[\033[1;32mSuccess\033[0m] ",
		"[\033[1;33mWarning\033[0m] ",
		"[\033[1;31mFailure\033[0m] ",
		"[\033[1;30mComment\033[0m] "
	};

	if ((flag == 0) || (type <= -1) || (type >= log_count)) {
		return;
	}

	start = string_length (log_notify);

	log_notify = reallocate (log_notify, start + string_length (type_mark [type]) + string_length (data) + 2);

	log_notify [start] = '\0';

	string_concatenate (log_notify, type_mark [type]);
	string_concatenate (log_notify, data);
	string_concatenate (log_notify, "\n");
}

void log_out (char * name) {
	dump (name, log_notify);

	log_notify = deallocate (log_notify);
}

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

	out (data, string_length (data));
}

void dump (char * name, char * data) {
	int file = -1;

	if (name == null) {
		echo (data);
		return;
	}

	if (data == null) {
		return;
	}

	file = file_open (name, O_RDWR | O_CREAT | O_APPEND);

	file_write (file, data, string_length (data));

	file = file_close (file);
}

void echo_byte (int byte) {
	out ("0123456789ABCDEF" + (byte % 256) / 16, 1);
	out ("0123456789ABCDEF" + (byte % 256) % 16, 1);
	out (" ",                                    1);
}

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

		exit (EXIT_FAILURE);
	}
}

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

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);
}

void * record (void) {
	char * buffer = null;
	int    offset = 0;
	int    loling = 1024;

	buffer = reallocate (buffer, loling);

	do {
		if ((offset + 1) % loling == 0) {
			buffer = reallocate (buffer, ((offset + 1) / loling + 1) * loling);
		}

		buffer [offset] = '\0';

		in (& buffer [offset], (int) sizeof (* buffer));

		++offset;
	} while (buffer [offset - 1] != '\0');

	buffer [offset - 1] = '\0';

	return (buffer);
}

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 * extensions [file_type_count] = {
		".txt",     ".asm",     ".fasm",    ".gasm",    ".nasm",    ".yasm",    ".c",       ".h",       ".adb",     ".ads",     ".cpp",     ".hpp",
		".f90",     ".sh",      ".cfg",     ".x"
	};

	int type = 0;

	for (; * name != '.'; ++name);

	for (type = 0; type != file_type_count; ++type) {
		if (string_compare_limit (name, extensions [type], string_length (extensions [type]))) {
			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_is_uppercase (char character) {
	return ((int) ((character >= 'A') && (character <= 'Z')));
}

int character_is_lowercase (char character) {
	return ((int) ((character >= 'a') && (character <= 'z')));
}

int character_is_digit (char character) {
	return ((int) ((character >= '0') && (character <= '9')));
}

int character_is_blank (char character) {
	return ((int) ((character == ' ') || (character == '\t') || (character == '\r') || (character == '\n')));
}

int character_is_alpha (char character) {
	return ((character_is_uppercase (character) != 0) || (character_is_lowercase (character) != 0));
}

int character_is_symbol (char character) {
	char * symbols = "~!@#$%^&*()+{}|:\"<>?`-=[]\\;',./";

	return (character_compare_array (character, symbols));
}

int character_is_visible (char character) {
	return ((int) ((character >= ' ') && (character <= '~')));
}

int character_is_invisible (char character) {
	return (character_is_visible (character) == 0);
}

int character_is_escape (char character) {
	return ((int) (character == '\033'));
}

int character_is_underscore (char character) {
	return ((int) (character == '_'));
}

int character_is_hexadecimal (char character) {
	char * hexadecimals = "0123456789ABCDEF";

	return (character_compare_array (character, hexadecimals));
}

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

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

	return (false);
}

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 (false);
		}
	}

	if (string_0 [i] != string_1 [i]) {
		return (false);
	} else {
		return (true);
	}
}

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 (false);
		}
	}

	return (true);
}

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);
}

int string_split_space (char * string) {
	int i     = 0;
	int count = 0;

	fatal_failure (string == null, "string_split_space: Source string is null pointer.");

	for (i = 0; string [i] != '\0'; ++i) {
		if ((string [i] == ' ') || (string [i] == '\t') || (string [i] == '\n')) {
			string [i] = '\0';
			++count;
		}
	}

	return (++count);
}

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 memory_delete (void * memory, int length) {
	int i = 0;

	char * cast = (char *) memory;

	fatal_failure (memory == null, "memory_delete: Memory is null pointer.");

	if (length <= 0) {
		return;
	}

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

int memory_compare (void * memory, void * source, int length) {
	int i = 0;

	char * cast_0 = (char *) memory;
	char * cast_1 = (char *) source;

	fatal_failure (memory == null, "memory_compare: Memory is null pointer.");
	fatal_failure (source == null, "memory_compare: Source is null pointer.");

	if (length <= 0) {
		return (-1);
	}

	for (i = 0; (cast_0 [i] != '\0') && (cast_1 [i] != '\0'); ++i) {
		if (cast_0 [i] != cast_1 [i]) {
			return (false);
		}
	}

	return (true);
}

void memory_copy (void * memory, void * source, int length) {
	int i = 0;

	char * cast_0 = (char *) memory;
	char * cast_1 = (char *) source;

	fatal_failure (memory == null, "memory_copy: Memory is null pointer.");
	fatal_failure (source == null, "memory_copy: Source is null pointer.");

	if (length <= 0) {
		return;
	}

	for (i = 0; i != length; ++i) {
		cast_0 [i] = cast_1 [i];
	}
}

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");
	}
}

int encode_byte (char * byte) {
	int encode = 0;

	fatal_failure (character_is_hexadecimal (byte [0]) == 0, "encode_byte: Upper byte character is not hexadecimal digit.");
	fatal_failure (character_is_hexadecimal (byte [1]) == 0, "encode_byte: Lower byte character is not hexadecimal digit.");

	encode = ((byte [0] - (character_is_digit (byte [0]) ? ('0') : ('A' - 10))) << 4) | (byte [1] - (character_is_digit (byte [1]) ? ('0') : ('A' - 10)));

	return (encode);
}

char * decode_byte (int byte) {
	char * decode = "  ";

	fatal_failure ((byte <= -1) || (byte >= 256), "decode_byte: Byte is out of range.");

	decode [0] = byte / 16;
	decode [1] = byte % 16;

	return (decode);
}

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

	static char string [32];

	string_delete (string, 32);

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

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

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

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

	string [i] = '\0';

	string_reverse (string);

	return (string);
}

char * format_to_string (int number, int sign, 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 (sign != 0) {
		string [i] = '-';
		++i;
	}

	string [i] = '\0';

	string_reverse (string);

	string_realign (string, amount, character);

	return (string);
}

void print (char * format, ...) {
	va_list list;

	va_start (list, format);

	for (; * format != character_null; ++format) {
		switch (* format) {
			case '%': {
				int    integer;
				char * string;
				++format;
				switch (* format) {
					case '%': out ("%", 1);                                                                                               break;
					case 'i': integer = va_arg (list, int);    string = number_to_string (integer); out (string, string_length (string)); break;
					case 's': string  = va_arg (list, char *);                                      out (string, string_length (string)); break;
					default:  out ("?", 1);                                                                                               break;
				}
			} break;
			case '/': {
				++format;
				switch (* format) {
					case '/': out ("/", 1);                                 break;
					case '0': terminal_colour (colour_grey,   effect_bold); break;
					case '1': terminal_colour (colour_red,    effect_bold); break;
					case '2': terminal_colour (colour_green,  effect_bold); break;
					case '3': terminal_colour (colour_yellow, effect_bold); break;
					case '4': terminal_colour (colour_blue,   effect_bold); break;
					case '5': terminal_colour (colour_pink,   effect_bold); break;
					case '6': terminal_colour (colour_cyan,   effect_bold); break;
					case '7': terminal_colour (colour_white,  effect_bold); break;
					case '-': terminal_cancel ();                           break;
					default:  out ("?", 1);                                 break;
				}
			} break;
			default: {
				out (format, 1);
			} break;
		}
	}

	va_end (list);
}

#endif