Major redesign...
This commit is contained in:
xolatile
parent
2d6b8ed626
commit
e7d650c90b
1
.gitignore
vendored
1
.gitignore
vendored
@ -1 +0,0 @@
|
||||
xtandard.o
|
||||
@ -1,7 +0,0 @@
|
||||
#!/bin/bash
|
||||
|
||||
set -xe
|
||||
|
||||
gcc -g -ansi -Wall -Wextra -Wpedantic -Werror -O0 -c -o xtandard.o xtandard.c
|
||||
|
||||
exit
|
||||
@ -5,7 +5,5 @@ set -xe
|
||||
mkdir -p /usr/local/include/xolatile
|
||||
|
||||
cp xtandard.h /usr/local/include/xolatile/xtandard.h
|
||||
cp xtandard.c /usr/local/include/xolatile/xtandard.c
|
||||
cp xtandard.o /usr/local/include/xolatile/xtandard.o
|
||||
|
||||
exit
|
||||
|
||||
919
xtandard.c
919
xtandard.c
@ -1,919 +0,0 @@
|
||||
#ifndef xtandard_source
|
||||
#define xtandard_source
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdarg.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
#include <xolatile/xtandard.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) {
|
||||
read (STDIN_FILENO, data, (unsigned long int) size);
|
||||
}
|
||||
|
||||
void out (void * data, int size) {
|
||||
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);
|
||||
}
|
||||
|
||||
extern void clean_up (void (* procedure) (void)) {
|
||||
atexit (procedure);
|
||||
}
|
||||
|
||||
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_WRONLY | 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;31m FATAL \033[0m] ");
|
||||
echo (message);
|
||||
echo ("\n");
|
||||
exit (log_failure);
|
||||
}
|
||||
}
|
||||
|
||||
int randomize (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, "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, "reallocate: Failed to reallocate memory, internal function 'realloc' returned null pointer.");
|
||||
|
||||
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, 0666);
|
||||
|
||||
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_echo (int file, char * data) {
|
||||
file_write (file, data, string_length (data));
|
||||
}
|
||||
|
||||
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.");
|
||||
|
||||
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.");
|
||||
|
||||
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);
|
||||
|
||||
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, open returned invalid descriptor.");
|
||||
|
||||
file_list_size [file_list_active] = (int) lseek (file_list_mark [file_list_active], 0, SEEK_END) + 1;
|
||||
|
||||
lseek (file_list_mark [file_list_active], 0, SEEK_SET);
|
||||
|
||||
file_list_data [file_list_active] = allocate (file_list_size [file_list_active]);
|
||||
|
||||
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);
|
||||
|
||||
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;
|
||||
|
||||
fatal_failure (string == null, "string_length: String is null pointer.");
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
string_0 += string_length (string_0);
|
||||
|
||||
while (* string_1 != '\0') {
|
||||
* 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: Destination string is null pointer.");
|
||||
fatal_failure (string_1 == null, "string_compare: Source string is null pointer.");
|
||||
|
||||
for (i = 0; (i != limit) && (string_0 [i] != '\0') && (string_1 [i] != '\0'); ++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;
|
||||
|
||||
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;
|
||||
|
||||
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) { /* refactor me please... */
|
||||
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);
|
||||
}
|
||||
|
||||
extern int string_to_number (char * string) { /* refactor me please... */
|
||||
int number = 0;
|
||||
|
||||
for (; * string != '\0'; ++string) {
|
||||
if (number > 1000000) break; /* */
|
||||
|
||||
number += (int) (* string - '0');
|
||||
|
||||
number *= 10;
|
||||
}
|
||||
|
||||
return (number / 10);
|
||||
}
|
||||
|
||||
char * format_to_string (int number, int sign, int base, int amount, char character) { /* refactor me please... */
|
||||
static char string [32];
|
||||
|
||||
int i;
|
||||
|
||||
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, ...) { /* refactor me please... */
|
||||
va_list list;
|
||||
|
||||
va_start (list, format);
|
||||
|
||||
for (; * format != character_null; ++format) {
|
||||
switch (* format) {
|
||||
case '%': {
|
||||
char * string;
|
||||
++format;
|
||||
switch (* format) {
|
||||
case '%': out ("%", 1); break;
|
||||
case 'i': string = number_to_string (va_arg (list, int)); 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_normal); break;
|
||||
case '1': terminal_colour (colour_red, effect_normal); break;
|
||||
case '2': terminal_colour (colour_green, effect_normal); break;
|
||||
case '3': terminal_colour (colour_yellow, effect_normal); break;
|
||||
case '4': terminal_colour (colour_blue, effect_normal); break;
|
||||
case '5': terminal_colour (colour_pink, effect_normal); break;
|
||||
case '6': terminal_colour (colour_cyan, effect_normal); break;
|
||||
case '7': terminal_colour (colour_white, effect_normal); break;
|
||||
case '-': terminal_cancel (); break;
|
||||
default: out ("?", 1); break;
|
||||
}
|
||||
} break;
|
||||
default: {
|
||||
out (format, 1);
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
va_end (list);
|
||||
}
|
||||
|
||||
char * format (char * base, ...) { /* refactor me please... */
|
||||
static char output [256];
|
||||
|
||||
va_list list;
|
||||
|
||||
string_delete (output, 256);
|
||||
|
||||
va_start (list, base);
|
||||
|
||||
for (; * base != character_null; ++base) {
|
||||
switch (* base) {
|
||||
case '%': {
|
||||
++base;
|
||||
switch (* base) {
|
||||
case '%': string_concatenate (output, "%"); break;
|
||||
case 'i': string_concatenate (output, number_to_string (va_arg (list, int))); break;
|
||||
case 's': string_concatenate (output, va_arg (list, char *)); break;
|
||||
default: string_concatenate (output, "?"); break;
|
||||
}
|
||||
} break;
|
||||
case '/': {
|
||||
++base;
|
||||
switch (* base) {
|
||||
case '/': string_concatenate (output, "/"); break;
|
||||
case '0': string_concatenate (output, "\033[1;30m"); break;
|
||||
case '1': string_concatenate (output, "\033[1;31m"); break;
|
||||
case '2': string_concatenate (output, "\033[1;32m"); break;
|
||||
case '3': string_concatenate (output, "\033[1;33m"); break;
|
||||
case '4': string_concatenate (output, "\033[1;34m"); break;
|
||||
case '5': string_concatenate (output, "\033[1;35m"); break;
|
||||
case '6': string_concatenate (output, "\033[1;36m"); break;
|
||||
case '7': string_concatenate (output, "\033[1;37m"); break;
|
||||
case '-': string_concatenate (output, "\033[0m"); break;
|
||||
default: string_concatenate (output, "?"); break;
|
||||
}
|
||||
} break;
|
||||
default: {
|
||||
string_concatenate_limit (output, base, 1);
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
va_end (list);
|
||||
|
||||
return (output);
|
||||
}
|
||||
|
||||
int execute (char * command) {
|
||||
return (system (command));
|
||||
}
|
||||
|
||||
#endif
|
||||
1005
xtandard.h
1005
xtandard.h
File diff suppressed because it is too large
Load Diff
Loading…
x
Reference in New Issue
Block a user