xtandard/xtandard.c

/*
 * Copyright (c) 2023 : Ognjen 'xolatile' Milan Robovic
 *
 * Xtandard is free software! You will redistribute it or modify it under the terms of the GNU General Public License by Free Software Foundation.
 * And when you do redistribute it or modify it, it will use either version 3 of the License, or (at yours truly opinion) any later version.
 * It is distributed in the hope that it will be useful or harmful, it really depends... But no warranty what so ever, seriously. See GNU/GPLv3.
 */

#ifndef XTANDARD_SOURCE
#define XTANDARD_SOURCE

#include "xtandard.h"

int       argument_count            = 0;
char  * * argument_nick             = NULL;
char  * * argument_name             = NULL;
void (* * argument_function) (void) = NULL;

int      file_list_active = 0;
int      file_list_count  = 0;
int    * file_list_mark   = NULL;
int    * file_list_size   = NULL;
char * * file_list_name   = NULL;
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 echo (char * data) {
	out (data, string_length (data));
}

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

		exit (EXIT_FAILURE);
	}
}

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

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

	fatal_failure (data == NULL, "allocate: Oh no...");

	return ((void *) data);
}

void * reallocate (void * data, int size) {
	data = realloc (data, (unsigned long int) size);

	fatal_failure (data == NULL, "reallocate: Oh no...");

	return (data);
}

void * deallocate (void * data) {
	fatal_failure (data == NULL, "deallocate: Oh no...");

	free (data);

	return (NULL);
}

void * memorize (int size) {
	static char * buffer = NULL;
	       char * points = NULL;
	static int    length = 0;
	static int    chunks = 0;
	static int    loling = 1024;

	if (size == 0) {
		free (buffer);

		buffer = NULL;
		length = 0;
		chunks = 0;

		return (NULL);
	}

	for (; length + size > chunks * loling; ) {
		int i;

		++chunks;

		buffer = realloc (buffer, (unsigned long int) (chunks * loling));

		fatal_failure (buffer == NULL, "memorize: Oh no...");

		for (i = (chunks - 1) * loling; i != chunks * loling; ++i) {
			buffer [i] = '\0';
		}
	}

	points = & buffer [length];

	length += size;

	return ((void *) points);
}

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], sizeof (* buffer));

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

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

	return (buffer);
}

void argument_define (char * nick, char * name, void (* function) (void)) {
	argument_nick     = reallocate (argument_nick,     (argument_count + 1) * (int) sizeof (* argument_nick));
	argument_name     = reallocate (argument_name,     (argument_count + 1) * (int) sizeof (* argument_name));
	argument_function = reallocate (argument_function, (argument_count + 1) * (int) sizeof (* argument_function));

	argument_nick [argument_count] = allocate (string_length (nick) + 1);
	argument_name [argument_count] = allocate (string_length (name) + 1);

	string_copy (argument_nick [argument_count], nick);
	string_copy (argument_name [argument_count], name);

	argument_function [argument_count] = function;

	++argument_count;
}

void argument_select (int count, char * * array) {
	int index_a, index_b;

	for (index_a = 0; index_a != count; ++index_a) {
		for (index_b = 0; index_b != argument_count; ++index_b) {
			if ((string_compare (array [index_a], argument_nick [index_b]) != 0)
			||  (string_compare (array [index_a], argument_name [index_b]) != 0)) {
				argument_function [index_b] ();
			}
		}
	}
}

void argument_delete (void) {
	int index;

	for (index = 0; index != argument_count; ++index) {
		argument_nick [index] = deallocate (argument_nick [index]);
		argument_name [index] = deallocate (argument_name [index]);
	}

	argument_nick     = deallocate (argument_nick);
	argument_name     = deallocate (argument_name);
	argument_function = deallocate (argument_function);
}

void file_list_import (char * name) {
	fatal_failure (name == NULL, "file_list_import: Failed to open 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_count - 1] = -1;
	file_list_size [file_list_count - 1] = -1;
	file_list_name [file_list_count - 1] = NULL;
	file_list_data [file_list_count - 1] = NULL;

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

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

	file_list_mark [file_list_count - 1] = open (name, O_RDONLY);

	fatal_failure (file_list_mark [file_list_count - 1] == -1, "file_list_import: Failed to open file, standard library failure.");

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

	(void) lseek (file_list_mark [file_list_count - 1], 0, SEEK_SET);

	file_list_data [file_list_count - 1] = allocate (file_list_size [file_list_count - 1]);

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

	close (file_list_mark [file_list_count - 1]);

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

void file_list_export (char * name) {
	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_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 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, standard library failure.");

	return (descriptor);
}

void file_read (int file, void * data, int size) {
	fatal_failure (file == -1,   "file_read: Failed to read from file, invalid file 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 file 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 file descriptor.");

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

int file_size (int file) {
	int size = 0;

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

	size = lseek (file, 0, SEEK_END);
	(void) lseek (file, 0, SEEK_SET);

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

	return (size);
}

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, standard library failure.");

	return (-1);
}

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

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


int string_length (char * string) {
	int length = 0;

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

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

	return (length);
}

void string_reverse (char * string) {
	int i      = 0;
	int length = 0;

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

	length = string_length (string);

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

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

	fatal_failure (string == NULL, "string_delete: String is null pointer.");
	fatal_failure (length == 0,    "string_delete: String length is zero.");

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

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

void string_copy (char * string_0, char * string_1) {
	int i      = 0;
	int length = 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.");

	length = string_length (string_1);

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

void string_concatenate (char * string_0, char * string_1) {
	int i        = 0;
	int length_0 = 0;
	int length_1 = 0;

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

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

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

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

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

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

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

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

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

#endif