xiranda/xiranda.c

#include <xolatile/xtandard.c>

enum {
	word_type,   word_loop,   word_if,     word_else,   word_case,   word_return, word_import, word_system,
	function,    variable,    constant,    type,        string,      number,      marker,      label,
	add,         subtract,    multiply,    divide,      modulus,     equal,       above,       below,
	open,        close,       next,        stop,        branch,      and,         or,          not,
	range,       enrange,     derange,     comment
};

static int function_code = 0;
static int variable_code = 0;
static int constant_code = 0;

static char function_name          [9]     [40] = { "" };
static int  function_type          [9]          = { 0 };
static char function_argument_name [9] [6] [40] = { { "" } };
static int  function_argument_type [9] [6]      = { { 0 } };

static char variable_name [27] [40] = { "" };
static int  variable_type [27]      = { 0 };
static int  variable_data [27]      = { 0 };

static char constant_name [30] [40] = { "" };
static int  constant_type [30]      = { 0 };
static int  constant_data [30]      = { 0 };

#include <stdio.h>

static char * word_list [] = {
	"type",   "loop",   "if",     "else",   "case",   "return", "import", "system"
};

static void add_token (int type, int data) {
	token_data = reallocate (token_data, (token_count + 1) * (int) sizeof (* token_data));
	token_type = reallocate (token_type, (token_count + 1) * (int) sizeof (* token_type));
	token_data [token_count] = data;
	token_type [token_count] = type;
	++token_count;
}

static void kill (char * data) {
	terminal_colour (colour_red, effect_bold);
	echo (data);
	terminal_cancel ();
	exit (log_failure);
}

int main (void) {
	char * buffer = null;
	int    offset = 0;
	int    length = 0;

	buffer = file_import ("./test.x");

	for (offset = 0; buffer [offset] != '\0'; ++offset) {
		if ((buffer [offset] == '-') && (buffer [offset + 1] == '-') && (buffer [offset + 2] == '-') && (buffer [offset + 1] != '\0') && (buffer [offset + 2] != '\0')) {
			for (; buffer [offset] != '\n'; ++offset);
		} else if (buffer [offset] == '"') {
			int size = 0;
			char data [STRING_LIMIT] = "";
			for (++offset; (buffer [offset] != '"') && (buffer [offset] != '\0'); ++offset) {
				data [size++] = buffer [offset];
			}
			data [size] = '\0';
			add_token (core_string, string_code);
			add_string (data, size);
		} else if (character_is_digit (buffer [offset]) == true) {
			int data = buffer [offset] - '0';
			for (++offset; (character_is_digit (buffer [offset]) == true) && (buffer [offset] != '\0'); ++offset) {
				data *= 10;
				data += (buffer [offset] - '0');
			}
			add_token (core_number, number_code);
			add_number (data);
			--offset;
		} else if (character_is_alpha (buffer [offset]) == true) {
			int size = 0;
			char name [NAME_LIMIT] = "";
			for (; ((character_is_alpha (buffer [offset]) == true) ||
			        (character_is_digit (buffer [offset]) == true) ||
			        (character_is_underscore (buffer [offset]) == true)) && (buffer [offset] != '\0'); ++offset) {
				name [size++] = buffer [offset];
			}
			name [size] = '\0';
			for (length = 0; length < (int) (sizeof (word_list) / sizeof (word_list [0])); ++length) {
				if (string_compare_limit (name, word_list [length], string_length (word_list [length]) + 1) == true) {
					add_token (core_word, length);
					goto here;
				}
			}
			add_token (core_marker, marker_code);
			add_marker (name, token_type [token_count - 1]);
			if ((token_type [token_count - 2] == core_word) && (token_data [token_count - 2] == word_type)) {
				token_type [token_count - 1] = core_type;
				add_type (name);
			}
			for (length = 0; length < type_code; ++length) {
				if (string_compare_limit (name, type_name [length], string_length (type_name [length]) + 1) == true) {
					token_type [token_count - 1] = core_type;
				}
			}
			here:
			--offset;
		} else if (character_compare_array (buffer [offset], ",.;:=<>&|!+-*/%()[]") == true) {
			add_token (core_symbol, symbol_code);
			add_symbol (buffer [offset]);
		} else {
			if (character_is_blank (buffer [offset]) == false) {
				echo ("\033[1;31mCharacter set exception point: Segmentation\033[0m\n");
				printf ("%c -- %i\n", buffer [offset], (int) buffer [offset]);
				exit (log_failure);
			}
		}
	}

	for (length = 0; length < token_count; ++length) {
		switch (token_type [length]) {
			case core_symbol: printf ("\033[1;34m%c\033[0m ", symbol_data [token_data [length]]); break;
			case core_string: printf ("\033[1;31m%s\033[0m ", string_data [token_data [length]]); break;
			case core_number: printf ("\033[1;32m%i\033[0m ", number_data [token_data [length]]); break;
			case core_type:   printf ("\033[1;36m%s\033[0m ", marker_name [token_data [length]]); break;
			case core_marker: printf ("\033[1;33m%s\033[0m ", marker_name [token_data [length]]); break;
			case core_word:   printf ("\033[1;35m%s\033[0m ", word_list   [token_data [length]]); break;
			default: break;
		}
	}

	printf ("\n");

	for (length = 0; length < token_count; ++length) {
		if ((token_type [length] == core_word) && (token_data [length] == word_return)) {
			++length;
			if ((token_type [length] == core_symbol) && (symbol_data [token_data [length]] == '(')) {
				echo ("return (\n");
				++length;
			} else if ((token_type [length] == core_symbol) && (symbol_data [token_data [length]] == ';')) {
				echo ("; return;\nxor rax, rax\nret\n");
				++length;
			} else if (token_type [length] == core_number && (token_type [length + 1] == core_symbol) && (symbol_data [token_data [length + 1]] == ';')) {
				printf ("; return {number};\nmov rax, %i\nret\n", number_data [token_data [length]]);
				++length;
			} else {
				kill ("return ?\n");
			}
		} else if ((token_type [length] == core_word) && (token_data [length] == word_if)) {
			++length;
			if ((token_type [length] == core_symbol) && (symbol_data [token_data [length]] == '(')) {
				echo ("if (\n");
				++length;
			} else {
				kill ("if ?\n");
			}
		} else if ((token_type [length] == core_word) && (token_data [length] == word_else)) {
			++length;
			if ((token_type [length] == core_symbol) && (symbol_data [token_data [length]] == ':')) {
				echo ("else :\n");
				++length;
			} else if ((token_type [length] == core_word) && (token_data [length] == word_if)) {
				echo ("else if\n");
				++length;
			} else {
				echo ("else expression\n");
			}
		} else if ((token_type [length] == core_word) && (token_data [length] == word_type)) {
			++length;
			if (token_type [length] == core_type) {
				echo ("type <name> -- ");
				echo (marker_name [token_data [length]]);
				echo ("\n");
				++length;
			} else {
				kill ("type ?\n");
			}
		}
	}

	for (length = 0; length < string_code; ++length) { string_data [length] = deallocate (string_data [length]); }
	for (length = 0; length < marker_code; ++length) { marker_name [length] = deallocate (marker_name [length]); }
	for (length = 0; length < type_code;   ++length) { type_name   [length] = deallocate (type_name   [length]); }

	string_data = deallocate (string_data);
	string_size = deallocate (string_size);
	marker_name = deallocate (marker_name);
	marker_type = deallocate (marker_type);
	type_name   = deallocate (type_name);
	symbol_data = deallocate (symbol_data);
	number_data = deallocate (number_data);
	token_data  = deallocate (token_data);
	token_type  = deallocate (token_type);

	buffer = deallocate (buffer);

	return (log_success);
}