xighlight/xighlight.c

/*
Copyright (c) 2023 : Ognjen 'xolatile' Milan Robovic

Xighlight is free software! You will redistribute it or modify it under the terms of the GNU General Public License by Free Software Foundation.
And when you do redistribute it or modify it, it will use either version 3 of the License, or (at yours truly opinion) any later version.
It is distributed in the hope that it will be useful or harmful, it really depends... But no warranty what so ever, seriously. See GNU/GPLv3.
*/

#include <xolatile/xtandard.c>
#include <xolatile/xyntax.c>

static int highlighted = 0;

static void echo_version (void) {
	echo ("xighlight: Terminal syntax highlighter (version 144000)\n");
}

static void echo_license (void) {
	echo ("xighlight: Terminal syntax highlighter (GNU general public license version 3)\n");
}

static void highlight_common (void) { /* Should be changed to support basic GCC, Clang, Valgrind and Splint output... */
	char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";

	if (highlighted != 0) {
		syntax_delete ();
	}

	syntax_define_separators (separators);

	syntax_define_range ("'", "'", '\\', COLOUR_PINK, EFFECT_BOLD);
	syntax_define_range ("`", "'", '\\', COLOUR_PINK, EFFECT_BOLD);

	syntax_define_operators (".,:;<=>+*-/%!&~^?|()[]{}", COLOUR_BLUE, EFFECT_BOLD);

	syntax_define_default (1, COLOUR_RED, EFFECT_NORMAL, COLOUR_CYAN, EFFECT_BOLD);

	highlighted = 1;
}

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"
	};

	if (highlighted != 0) {
		syntax_delete ();
	}

	syntax_define_separators (separators);

	syntax_define_range ("/*", "*/", '\0', COLOUR_GREY, EFFECT_BOLD);
	syntax_define_range ("//", "\n", '\0', COLOUR_GREY, EFFECT_BOLD);
	syntax_define_range ("#",  "\n", '\\', COLOUR_PINK, EFFECT_NORMAL);
	syntax_define_range ("'",  "'",  '\\', COLOUR_PINK, EFFECT_BOLD);

	syntax_define_operators (".,:;<=>+*-/%!&~^?|()[]{}", COLOUR_BLUE, EFFECT_BOLD);

	syntax_define_words (keywords, sizeof (keywords) / sizeof (keywords [0]), COLOUR_BLUE, EFFECT_NORMAL);

	syntax_define_default (1, COLOUR_RED, EFFECT_NORMAL, COLOUR_CYAN, EFFECT_BOLD);

	highlighted = 1;
}

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"
	};

	if (highlighted != 0) {
		syntax_delete ();
	}

	syntax_define_separators (separators);

	syntax_define_range ("--", "\n", '\0', COLOUR_GREY, EFFECT_BOLD);
	syntax_define_range ("'",  "'",  '\0', COLOUR_PINK, EFFECT_BOLD);

	syntax_define_operators (".,:;<=>+-*/&|()'", COLOUR_BLUE, EFFECT_BOLD);

	syntax_define_words (keywords, sizeof (keywords) / sizeof (keywords [0]), COLOUR_BLUE, EFFECT_NORMAL);

	syntax_define_default (0, COLOUR_RED, EFFECT_NORMAL, COLOUR_CYAN, EFFECT_BOLD);

	highlighted = 1;
}

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"
	};

	if (highlighted != 0) {
		syntax_delete ();
	}

	syntax_define_separators (separators);

	syntax_define_range ("/*", "*/", '\0', COLOUR_GREY, EFFECT_BOLD);
	syntax_define_range ("//", "\n", '\0', COLOUR_GREY, EFFECT_BOLD);
	syntax_define_range ("#",  "\n", '\\', COLOUR_PINK, EFFECT_NORMAL);
	syntax_define_range ("'",  "'",  '\\', COLOUR_PINK, EFFECT_BOLD);

	syntax_define_operators (".,:;<=>+*-/%!&~^?|()[]{}", COLOUR_BLUE, EFFECT_BOLD);

	syntax_define_words (keywords, sizeof (keywords) / sizeof (keywords [0]), COLOUR_BLUE, EFFECT_NORMAL);

	syntax_define_default (1, COLOUR_RED, EFFECT_NORMAL, COLOUR_CYAN, EFFECT_BOLD);

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

	char * keywords [] = {
		"False",            "await",            "else",             "import",           "pass",             "None",             "break",            "except",
		"in",               "raise",            "True",             "class",            "finally",          "is",               "return",           "and",
		"continue",         "for",              "lambda",           "try",              "as",               "def",              "from",             "nonlocal",
		"while",            "assert",           "del",              "global",           "not",              "with",             "async",            "elif",
		"if",               "or",               "yield"
	};

	if (highlighted != 0) {
		syntax_delete ();
	}

	syntax_define_separators (separators);

	syntax_define_range ("#", "\n", '\\', COLOUR_GREY, EFFECT_BOLD);
	syntax_define_range ("'", "'",  '\\', COLOUR_PINK, EFFECT_BOLD);

	syntax_define_operators (".,:<=>+*-/%!&~^?|()[]", COLOUR_BLUE, EFFECT_BOLD);

	syntax_define_words (keywords, sizeof (keywords) / sizeof (keywords [0]), COLOUR_BLUE, EFFECT_NORMAL);

	syntax_define_default (0, COLOUR_RED, EFFECT_NORMAL, COLOUR_CYAN, EFFECT_BOLD);

	highlighted = 1;
}
*/
static void highlight_valgrind (void) {
	char * separators = "./-=?() \t\r\n";

	char * keywords [] = {
		"Invalid"
	};

	if (highlighted != 0) {
		syntax_delete ();
	}

	syntax_define_separators (separators);

	syntax_define_range ("==",  "==", '\0', COLOUR_GREY, EFFECT_BOLD);
	syntax_define_range ("(",   ")",  '\0', COLOUR_PINK, EFFECT_NORMAL);
	syntax_define_range ("???", "\n", '\0', COLOUR_RED,  EFFECT_BOLD);

	syntax_define_operators ("./-:", COLOUR_BLUE, EFFECT_BOLD);

	syntax_define_words (keywords, sizeof (keywords) / sizeof (keywords [0]), COLOUR_BLUE, EFFECT_NORMAL);

	syntax_define_default (0, COLOUR_RED, EFFECT_NORMAL, COLOUR_CYAN, EFFECT_BOLD);

	highlighted = 1;
}

static void highlight_common_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"
	};

	if (highlighted != 0) {
		syntax_delete ();
	}

	syntax_define_separators (separators);

	syntax_define_range ("[", "]", '\0', COLOUR_RED, EFFECT_NORMAL);

	syntax_define_operators (".,+-", COLOUR_BLUE, EFFECT_BOLD);

	syntax_define_words (instructions, sizeof (instructions) / sizeof (instructions [0]), COLOUR_BLUE, EFFECT_NORMAL);
	syntax_define_words (registers,    sizeof (registers)    / sizeof (registers [0]),    COLOUR_CYAN, EFFECT_NORMAL);

	syntax_define_default (1, COLOUR_WHITE, EFFECT_NORMAL, COLOUR_WHITE, EFFECT_NORMAL);

	highlighted = 1;
}

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"
	};

	if (highlighted != 0) {
		syntax_delete ();
	}

	syntax_define_separators (separators);

	syntax_define_range (";", "\n", '\0', COLOUR_GREY, EFFECT_BOLD);
	syntax_define_range ("[", "]",  '\0', COLOUR_RED,  EFFECT_NORMAL);

	syntax_define_operators (".,+-=:{}$", COLOUR_BLUE, EFFECT_BOLD);

	syntax_define_words (instructions, sizeof (instructions) / sizeof (instructions [0]), COLOUR_BLUE, EFFECT_NORMAL);
	syntax_define_words (registers,    sizeof (registers)    / sizeof (registers [0]),    COLOUR_CYAN, EFFECT_NORMAL);
	syntax_define_words (keywords,     sizeof (keywords)     / sizeof (keywords [0]),     COLOUR_PINK, EFFECT_NORMAL);

	syntax_define_default (1, COLOUR_RED, EFFECT_NORMAL, COLOUR_CYAN, EFFECT_NORMAL);

	highlighted = 1;
}

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

	argument_define ("-v", "--version",       echo_version);
	argument_define ("-l", "--license",       echo_license);
	argument_define ("-c", "--c",             highlight_c);
	argument_define ("-a", "--ada",           highlight_ada);
	argument_define ("-C", "--c++",           highlight_cpp);
	/*argument_define ("-p", "--python",           highlight_python);*/
	argument_define ("-V", "--valgrind",      highlight_valgrind);
	argument_define ("-A", "--assembly",      highlight_common_assembly);
	argument_define ("-F", "--flat-assembly", highlight_flat_assembly);

	if (argc != 1) {
		argument_select (argc, argv);
	}

	if (buffer == NULL) {
		if (argument_input == NULL) {
			buffer = record ();
		} else {
			select = file_type   (argument_input);
			buffer = file_import (argument_input);
		}
	}

	if (highlighted == 0) {
		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_COMMON_ASSEMBLY) {
			highlight_common_assembly ();
		} 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_RED, EFFECT_REVERSE);
		} else {
			terminal_colour (syntax_colour [select], syntax_effect [select]);
		}

		out (& buffer [offset], length);

		terminal_cancel ();
	}

	buffer = deallocate (buffer);

	syntax_delete ();

	argument_delete ();

	return (EXIT_SUCCESS);
}