xiranda/xiranda.c

#include <xolatile/xtandard.c>

enum {
	coin_type,          coin_loop,          coin_if,            coin_else,          coin_case,          coin_return,        coin_import,        coin_system,
	coin_function,      coin_variable,      coin_constant,      coin_data_type,     coin_string,        coin_number,        coin_marker,        coin_label,
	coin_add,           coin_subtract,      coin_multiply,      coin_divide,        coin_modulus,       coin_equal,         coin_above,         coin_below,
	coin_open,          coin_close,         coin_next,          coin_stop,          coin_branch,        coin_and,           coin_or,            coin_not,
	coin_range,         coin_enrange,       coin_derange,       coin_machine
};

static int coin_code     = 0;
static int type_code     = 0;/*
static int function_code = 0;
static int variable_code = 0;
static int constant_code = 0;*/

static int  coin_enum [240]      = { 0 };
static int  coin_data [240]      = { 0 };
static char coin_text [240] [40] = { "" };

static char type_name [27] [40] = { "" };
static int  type_size [27]      = { 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>

#define STRING_LIMIT (40)

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

static char * register_list [] = {
	"rax","rdi","rsi","rdx","r10","r8","r9"
	/*"rax",              "rcx",              "rdx",              "rbx",              "rsp",              "rbp",              "rsi",              "rdi",
	"r8",               "r9",               "r10",              "r11",              "r12",              "r13",              "r14",              "r15",
	"eax",              "ecx",              "edx",              "ebx",              "esp",              "ebp",              "esi",              "edi",
	"r8d",              "r9d",              "r10d",             "r11d",             "r12d",             "r13d",             "r14d",             "r15d",
	"ax",               "cx",               "dx",               "bx",               "sp",               "bp",               "si",               "di",
	"r8w",              "r9w",              "r10w",             "r11w",             "r12w",             "r13w",             "r14w",             "r15w",
	"al",               "cl",               "dl",               "bl",               "spl",              "bpl",              "sil",              "dil",
	"r8b",              "r9b",              "r10b",             "r11b",             "r12b",             "r13b",             "r14b",             "r15b"*/
};

static void add_coin (int type, int data, char * text) {
	coin_enum [coin_code] = type;
	coin_data [coin_code] = data;
	string_copy (coin_text [coin_code], text);
	++coin_code;
}

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

	buffer = record ();

	for (offset = 0; buffer [offset] != '\0'; ++offset) {
		int  size                = 0;
		char data [STRING_LIMIT] = "";
		if (buffer [offset] == '"') {
			for (++offset; (buffer [offset] != '"') && (buffer [offset] != '\0'); ++offset) {
				data [size++] = buffer [offset];
			}
			data [size] = '\0';
			add_coin (coin_string, 0, data);
		} else if (character_is_digit (buffer [offset]) == true) {
			for (; (character_is_digit (buffer [offset]) == true) && (buffer [offset] != '\0'); ++offset) {
				data [size++] = buffer [offset];
			}
			add_coin (coin_number, 0, data);
			data [size] = '\0';
			--offset;
		} else if (character_is_alpha (buffer [offset]) == true) {
			for (; ((character_is_alpha (buffer [offset]) == true) ||
			        (character_is_digit (buffer [offset]) == true) ||
			        (character_is_underscore (buffer [offset]) == true)) && (buffer [offset] != '\0'); ++offset) {
				data [size++] = buffer [offset];
			}
			data [size] = '\0';
			for (length = 0; length < (int) (sizeof (word_list) / sizeof (word_list [0])); ++length) {
				if (string_compare_limit (data, word_list [length], string_length (word_list [length]) + 1) == true) {
					add_coin (length, 0, data);
					goto here;
				}
			}
			add_coin (coin_marker, 0, data);
			if (coin_enum [coin_code - 2] == coin_type) {
				coin_enum [coin_code - 1] = coin_data_type;
				string_copy (type_name [type_code], coin_text [coin_code - 1]);
				type_size [type_code] = 8;
				++type_code;
			}
			for (length = 0; length < type_code; ++length) {
				if (string_compare_limit (data, type_name [length], string_length (type_name [length]) + 1) == true) {
					coin_enum [coin_code - 1] = coin_data_type;
				}
			}
			here:
			--offset;
		} else if (character_compare_array (buffer [offset], ",.;:=<>#&|!+*-/%()[]") == true) {
			char s [2] = "";
			int kind = 0;
			s [0] = buffer [offset];
			switch (buffer [offset]) {
				case '+': kind = coin_add;      break;
				case '-': kind = coin_subtract; break;
				case '*': kind = coin_multiply; break;
				case '/': kind = coin_divide;   break;
				case '%': kind = coin_modulus;  break;
				case '=': kind = coin_equal;    break;
				case '>': kind = coin_above;    break;
				case '<': kind = coin_below;    break;
				case '(': kind = coin_open;     break;
				case ')': kind = coin_close;    break;
				case ',': kind = coin_next;     break;
				case ';': kind = coin_stop;     break;
				case ':': kind = coin_branch;   break;
				case '&': kind = coin_and;      break;
				case '|': kind = coin_or;       break;
				case '!': kind = coin_not;      break;
				case '.': kind = coin_range;    break;
				case '[': kind = coin_enrange;  break;
				case ']': kind = coin_derange;  break;
				case '#': kind = coin_machine;  break;
			}
			add_coin (kind, (int) buffer [offset], s);
		} 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 < coin_code; ++length) {
		switch (coin_enum [length]) {
			case coin_string:    printf ("\033[1;32m%s\033[0m ", coin_text [length]); break;
			case coin_number:    printf ("\033[1;34m%s\033[0m ", coin_text [length]); break;
			case coin_data_type: printf ("\033[1;36m%s\033[0m ", coin_text [length]); break;
			case coin_marker:    printf ("\033[1;37m%s\033[0m ", coin_text [length]); break;
			case coin_type:
			case coin_if:
			case coin_else:
			case coin_case:
			case coin_loop:
			case coin_import:
			case coin_system:
			case coin_return: printf ("\033[1;33m%s\033[0m ", coin_text [length]); break;
			default:          printf ("\033[1;31m%s\033[0m ", coin_text [length]); break;
		}
	}
*/
	printf ("\n");

	printf ("format ELF64 executable 3\n\n");
	printf ("segment readable executable\n\n");
	printf ("entry main\n\n");
	printf ("main:\n\n");

	for (length = 0; length < coin_code; ++length) {
		if ((coin_enum [length] == coin_return) && (coin_enum [length + 1] == coin_stop)) {
			printf ("; return;\nxor rax, rax\nret\n\n");
			length += 1;
		} else if ((coin_enum [length] == coin_return) && (coin_enum [length + 1] == coin_number) && (coin_enum [length + 2] == coin_stop)) {
			printf ("; return {number};\nmov rax, %s\nret\n\n", coin_text [length + 1]);
			length += 2;
		} else if ((coin_enum [length] == coin_system) && (coin_enum [length + 1] == coin_open)) {
			int use = 0;
			/*int fit = 0;*/
			printf ("; system ({...});\n");
			length += 2;
			while (coin_enum [length] != coin_close) {
				switch (coin_enum [length]) {
					case coin_machine: length += 1; printf ("mov %s, %s\n",   register_list [use], coin_text [length]); use++; break;
					case coin_number:               printf ("mov %s, %s\n",   register_list [use], coin_text [length]); use++; break;
					case coin_marker:               printf ("mov %s, [%s]\n", register_list [use], coin_text [length]); use++; break;
					default: break;
				}
				length += 1;
				if (coin_enum [length] == coin_next)
					length += 1;
			}
			if (coin_enum [length] == coin_close)
				length += 1;
			if (coin_enum [length] != coin_stop)
				echo ("EXPECTED STOP ';'\n");
			printf ("syscall\n\n");
		}
	}

	printf (";end\nmov rax, 60\nmov rdi, 0\nsyscall\n\n");
	printf ("segment readable writable\n\n");
	printf ("text db 'Heyo world!', 10, 0\n\n");
	printf ("size dq 12\n\n");

	buffer = deallocate (buffer);

	return (log_success);
}