xhartae/program/program_4.c

#include "../chapter/chapter_0.c"
#include "../chapter/chapter_1.c"
#include "../chapter/chapter_2.c"
#include "../chapter/chapter_3.c"
#include "../chapter/chapter_4.c"

static void highlight_common (void) {
	char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\"@#$` \t\r\n";

	syntax_define (FALSE, FALSE, "\"",                         "\"",       '\\', COLOUR_PINK,  EFFECT_NORMAL);
	syntax_define (TRUE,  FALSE, "()[]{}",                     "",         '\0', COLOUR_BLUE,  EFFECT_NORMAL);
	syntax_define (TRUE,  FALSE, ".,:;<=>+*-/%!&~^?|@#$`",     "",         '\0', COLOUR_CYAN,  EFFECT_NORMAL);
	syntax_define (TRUE,  TRUE,  "0123456789",                 separators, '\0', COLOUR_PINK,  EFFECT_BOLD);
	syntax_define (TRUE,  TRUE,  "abcdefghijklmnopqrstuvwxyz", separators, '\0', COLOUR_WHITE, EFFECT_NORMAL);
	syntax_define (TRUE,  TRUE,  "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', COLOUR_WHITE, EFFECT_BOLD);
	syntax_define (TRUE,  TRUE,  "_",                          separators, '\0', COLOUR_WHITE, EFFECT_ITALIC);
}

static void highlight_c (void) {
	char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";

	char * keywords [] = {
		"register",         "volatile",         "auto",             "const",            "static",           "extern",           "if",               "else",
		"do",               "while",            "for",              "continue",         "switch",           "case",             "default",          "break",
		"enum",             "union",            "struct",           "typedef",          "goto",             "void",             "return",           "sizeof",
		"char",             "short",            "int",              "long",             "signed",           "unsigned",         "float",            "double"
	};

	int word;

	syntax_define (FALSE, FALSE, "/*",      "*/", '\0', COLOUR_GREY,   EFFECT_BOLD);
	syntax_define (FALSE, FALSE, "//",      "\n", '\0', COLOUR_GREY,   EFFECT_BOLD);
	syntax_define (FALSE, FALSE, "#",       "\n", '\\', COLOUR_YELLOW, EFFECT_ITALIC);
	syntax_define (FALSE, FALSE, "'",       "'",  '\\', COLOUR_PINK,   EFFECT_BOLD);
	syntax_define (FALSE, FALSE, "\"",      "\"", '\\', COLOUR_PINK,   EFFECT_NORMAL);

	for (word = 0; word != (int) (sizeof (keywords) / sizeof (keywords [0])); ++word) {
		syntax_define (FALSE, TRUE, keywords [word], separators, '\0', COLOUR_YELLOW, EFFECT_BOLD);
	}

	syntax_define (TRUE, FALSE, "()[]{}",             "", '\0', COLOUR_BLUE, EFFECT_NORMAL);
	syntax_define (TRUE, FALSE, ".,:;<=>+*-/%!&~^?|", "", '\0', COLOUR_CYAN, EFFECT_NORMAL);

	syntax_define (TRUE, TRUE, "0123456789",                 separators, '\0', COLOUR_PINK,  EFFECT_BOLD);
	syntax_define (TRUE, TRUE, "abcdefghijklmnopqrstuvwxyz", separators, '\0', COLOUR_WHITE, EFFECT_NORMAL);
	syntax_define (TRUE, TRUE, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', COLOUR_WHITE, EFFECT_BOLD);
	syntax_define (TRUE, TRUE, "_",                          separators, '\0', COLOUR_WHITE, EFFECT_ITALIC);
}

static void highlight_ada (void) {
	char * separators = ".,:;<=>+-*/&|()\" \t\r\n";

	char * keywords [] = {
		"abort",            "else",             "new",              "return",           "abs",              "elsif",            "not",              "reverse",
		"abstract",         "end",              "null",             "accept",           "entry",            "select",           "access",           "of",
		"separate",         "aliased",          "exit",             "or",               "some",             "all",              "others",           "subtype",
		"and",              "for",              "out",              "array",            "function",         "at",               "tagged",           "generic",
		"package",          "task",             "begin",            "goto",             "pragma",           "body",             "private",          "then",
		"type",             "case",             "in",               "constant",         "until",            "is",               "raise",            "use",
		"if",               "declare",          "range",            "delay",            "limited",          "record",           "when",             "delta",
		"loop",             "rem",              "while",            "digits",           "renames",          "with",             "do",               "mod",
		"requeue",          "xor",              "procedure",        "protected",        "interface",        "synchronized",     "exception",        "overriding",
		"terminate"
	};

	int word;

	syntax_define (FALSE, FALSE, "--",      "\n", '\0', COLOUR_GREY,   EFFECT_BOLD);
	syntax_define (FALSE, FALSE, "'",       "'",  '\\', COLOUR_PINK,   EFFECT_BOLD);
	syntax_define (FALSE, FALSE, "\"",      "\"", '\\', COLOUR_PINK,   EFFECT_NORMAL);

	for (word = 0; word != (int) (sizeof (keywords) / sizeof (keywords [0])); ++word) {
		syntax_define (FALSE, TRUE, keywords [word], separators, '\0', COLOUR_YELLOW, EFFECT_BOLD);
	}

	syntax_define (TRUE, FALSE, "()",             "", '\0', COLOUR_BLUE, EFFECT_NORMAL);
	syntax_define (TRUE, FALSE, ".,:;<=>+-*/&|'", "", '\0', COLOUR_CYAN, EFFECT_NORMAL);

	syntax_define (TRUE, TRUE, "0123456789",                 separators, '\0', COLOUR_PINK,  EFFECT_BOLD);
	syntax_define (TRUE, TRUE, "abcdefghijklmnopqrstuvwxyz", separators, '\0', COLOUR_WHITE, EFFECT_NORMAL);
	syntax_define (TRUE, TRUE, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', COLOUR_WHITE, EFFECT_BOLD);
}

static void highlight_cpp (void) {
	char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";

	char * keywords [] = {
		"alignas",          "alignof",          "and",              "and_eq",           "asm",              "atomic_cancel",    "atomic_commit",    "atomic_noexcept",
		"auto",             "bitand",           "bitor",            "bool",             "break",            "case",             "catch",            "char",
		"char8_t",          "char16_t",         "char32_t",         "class",            "compl",            "concept",          "const",            "consteval",
		"constexpr",        "constinit",        "const_cast",       "continue",         "co_await",         "co_return",        "co_yield",         "decltype",
		"default",          "delete",           "do",               "double",           "dynamic_cast",     "else",             "enum",             "explicit",
		"export",           "extern",           "false",            "float",            "for",              "friend",           "goto",             "if",
		"inline",           "int",              "long",             "mutable",          "namespace",        "new",              "noexcept",         "not",
		"not_eq",           "nullptr",          "operator",         "or",               "or_eq",            "private",          "protected",        "public",
		"reflexpr",         "register",         "reinterpret_cast", "requires",         "return",           "short",            "signed",           "sizeof",
		"static",           "static_assert",    "static_cast",      "struct",           "switch",           "synchronized",     "template",         "this",
		"thread_local",     "throw",            "true",             "try",              "typedef",          "typeid",           "typename",         "union",
		"unsigned",         "using",            "virtual",          "void",             "volatile",         "wchar_t",          "while",            "xor",
		"xor_eq",           "final",            "override",         "import",           "module",           "transaction_safe"
	};

	int word;

	syntax_define (FALSE, FALSE, "/*",      "*/", '\0', COLOUR_GREY,   EFFECT_BOLD);
	syntax_define (FALSE, FALSE, "//",      "\n", '\0', COLOUR_GREY,   EFFECT_BOLD);
	syntax_define (FALSE, FALSE, "#",       "\n", '\\', COLOUR_YELLOW, EFFECT_ITALIC);
	syntax_define (FALSE, FALSE, "'",       "'",  '\\', COLOUR_PINK,   EFFECT_BOLD);
	syntax_define (FALSE, FALSE, "\"",      "\"", '\\', COLOUR_PINK,   EFFECT_NORMAL);

	for (word = 0; word != (int) (sizeof (keywords) / sizeof (keywords [0])); ++word) {
		syntax_define (FALSE, TRUE, keywords [word], separators, '\0', COLOUR_YELLOW, EFFECT_BOLD);
	}

	syntax_define (TRUE, FALSE, "()[]{}",             "", '\0', COLOUR_BLUE, EFFECT_NORMAL);
	syntax_define (TRUE, FALSE, ".,:;<=>+*-/%!&~^?|", "", '\0', COLOUR_CYAN, EFFECT_NORMAL);

	syntax_define (TRUE, TRUE, "0123456789",                 separators, '\0', COLOUR_PINK,  EFFECT_BOLD);
	syntax_define (TRUE, TRUE, "abcdefghijklmnopqrstuvwxyz", separators, '\0', COLOUR_WHITE, EFFECT_NORMAL);
	syntax_define (TRUE, TRUE, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', COLOUR_WHITE, EFFECT_BOLD);
	syntax_define (TRUE, TRUE, "_",                          separators, '\0', COLOUR_WHITE, EFFECT_ITALIC);
}

static void highlight_flat_assembly (void) {
	char * separators = ".,+-=:;(){}[]%$<> \t\r\n";

	char * instructions [] = {
		"mov",              "movabs",           "movapd",           "movaps",           "movebe",           "movsd",            "movsx",            "movzx",
		"movsxd",           "movd",             "movq",             "movs",             "movsb",            "movsw",            "movsd",            "movsq",
		"cmovmp",           "cmovrcxz",         "cmovc",            "cmovnc",           "cmove",            "cmovne",           "cmovz",            "cmovnz",
		"cmovg",            "cmovng",           "cmovge",           "cmovnge",          "cmovl",            "cmovnl",           "cmovle",           "cmovnle",
		"cmova",            "cmovna",           "cmovae",           "cmovnae",          "cmovb",            "cmovnb",           "cmovbe",           "cmovnbe",
		"cmovs",            "cmovns",           "cmovo",            "cmovno",           "cmovp",            "cmovnp",           "cmovpo",           "cmovpe",
		"cmp",              "cmps",             "cmpsb",            "cmpsw",            "cmpsd",            "cmpsq",            "cmpxchg",          "lea",
		"monitor",          "cpuid",            "in",               "out",              "syscall",          "sysenter",         "sysret",           "sysexit",
		"swap",             "bswap",            "pop",              "push",             "call",             "ret",              "enter",            "leave",
		"and",              "or",               "not",              "neg",              "sal",              "sar",              "shl",              "shr",
		"inc",              "dec",              "add",              "sub",              "mul",              "div",              "imul",             "idiv",
		"nop",              "fnop",             "adc",              "sbb",              "aaa",              "aas",              "aam",              "aad",
		"jmp",              "jrcxz",            "jc",               "jnc",              "je",               "jne",              "jz",               "jnz",
		"jg",               "jng",              "jge",              "jnge",             "jl",               "jnl",              "jle",              "jnle",
		"ja",               "jna",              "jae",              "jnae",             "jb",               "jnb",              "jbe",              "jnbe",
		"js",               "jns",              "jo",               "jno",              "jp",               "jnp",              "jpo",              "jpe",
		"rep",              "repe",             "repz",             "repne",            "repnz",            "loop",             "loope",            "loopne"
	};

	char * registers [] = {
		"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",
		"ah",               "ch",               "dh",               "bh"
	};

	char * keywords [] = {
		"format",           "executable",       "readable",         "writable",         "segment",          "sector",           "entry",            "macro",
		"db",               "dw",               "dd",               "dq",               "rb",               "rw",               "rd",               "rq"
	};

	int word;

	syntax_define (FALSE, FALSE, ";",  "\n", '\0', COLOUR_GREY, EFFECT_BOLD);
	syntax_define (FALSE, FALSE, "'",  "'",  '\\', COLOUR_PINK, EFFECT_BOLD);
	syntax_define (FALSE, FALSE, "\"", "\"", '\\', COLOUR_PINK, EFFECT_NORMAL);

	for (word = 0; word != (int) (sizeof (instructions) / sizeof (instructions [0])); ++word) {
		syntax_define (FALSE, TRUE, instructions [word], separators, '\0', COLOUR_YELLOW, EFFECT_BOLD);
	}

	for (word = 0; word != (int) (sizeof (registers) / sizeof (registers [0])); ++word) {
		syntax_define (FALSE, TRUE, registers [word], separators, '\0', COLOUR_CYAN, EFFECT_BOLD);
	}

	for (word = 0; word != (int) (sizeof (keywords) / sizeof (keywords [0])); ++word) {
		syntax_define (FALSE, TRUE, keywords [word], separators, '\0', COLOUR_YELLOW, EFFECT_ITALIC);
	}

	syntax_define (TRUE, FALSE, "()[]{}",      "", '\0', COLOUR_BLUE, EFFECT_NORMAL);
	syntax_define (TRUE, FALSE, ".,+-=:;%$<>", "", '\0', COLOUR_CYAN, EFFECT_NORMAL);

	syntax_define (TRUE, TRUE, "0123456789",                 separators, '\0', COLOUR_PINK,  EFFECT_BOLD);
	syntax_define (TRUE, TRUE, "abcdefghijklmnopqrstuvwxyz", separators, '\0', COLOUR_WHITE, EFFECT_NORMAL);
	syntax_define (TRUE, TRUE, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', COLOUR_WHITE, EFFECT_BOLD);
	syntax_define (TRUE, TRUE, "_",                          separators, '\0', COLOUR_WHITE, EFFECT_ITALIC);
}

int main (int argc, char * * argv) {
	int    offset = 0;
	int    select = 0;
	int    length = 0;
	char * buffer = NULL;

	if (argc < 2) {
		print ("Usage: /1.//program_4 [text_file]/-\n");

		return (EXIT_FAILURE);
	}

	select = file_type   (argv [1]);
	buffer = file_record (argv [1]);

	if ((select == FILE_TYPE_C_SOURCE) || (select == FILE_TYPE_C_HEADER)) {
		highlight_c ();
	} else if ((select == FILE_TYPE_ADA_BODY) || (select == FILE_TYPE_ADA_SPECIFICATION)) {
		highlight_ada ();
	} else if ((select == FILE_TYPE_CPP_SOURCE) || (select == FILE_TYPE_CPP_HEADER)) {
		highlight_cpp ();
	} else if (select == FILE_TYPE_FLAT_ASSEMBLY) {
		highlight_flat_assembly ();
	} else {
		highlight_common ();
	}

	for (offset = 0; buffer [offset] != '\0'; offset += length) {
		select = syntax_select (& buffer [offset], & length);

		if (select >= syntax_count) {
			terminal_colour (COLOUR_WHITE, EFFECT_NORMAL);
		} else {
			terminal_colour (syntax_colour [select], syntax_effect [select]);
		}

		out (& buffer [offset], length);

		terminal_cancel ();
	}

	buffer = deallocate (buffer);

	return (EXIT_SUCCESS);
}