839 lines
24 KiB
C
839 lines
24 KiB
C
#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);
|
|
}
|