xolatile/xighlight
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Trying...

Browse Source
This commit is contained in:
xolatile 2025-04-20 12:12:07 +02:00
parent c53055c9b7
commit e767bea2c8
16 changed files with 686 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
xanguage/ada.h Executable file
View File

@ -0,0 +1,30 @@
static procedure language_highlight_ada (language_structure * language, syntax_structure * syntax) {
character * separators = ".,:;<=>+-*/&|()\" \t\r\n";
character * 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"
};
syntax_define (syntax, false, false, "--", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "'", "'", '\\', language->character_colour, language->character_effect);
syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
syntax_define (syntax, true, false, "()", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,:;<=>+-*/&|'", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_letters, separators, '\0', language->lowercase_colour, language->lowercase_effect);
}

24
xanguage/bash.h Executable file
View File

@ -0,0 +1,24 @@
static procedure language_highlight_bash (language_structure * language, syntax_structure * syntax) {
character * separators = ".,:;<=>+-*/%!&~^?|@#$()[]{}'\" \t\r\n";
character * keywords [] = {
"exit", "set", "elif", "done", "in", "then", "function", "fi",
"if", "else", "do", "while", "for"
};
syntax_define (syntax, false, false, "#", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "'", "'", '\0', language->string_colour, language->string_effect);
syntax_define (syntax, false, false, "\"", "\"", '\0', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
syntax_define (syntax, true, false, "()[]{}", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,:;<=>+*-/%!&~^?|@#$", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_lowercase, separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, language_uppercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

53
xanguage/c++.h Executable file
View File

@ -0,0 +1,53 @@
static procedure language_highlight_cpp (language_structure * language, syntax_structure * syntax) {
character * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
character * keywords [] = {
"alignas", "alignof", "and", "asm", "auto", "break", "case",
"catch", "class", "compl", "concept", "const", "consteval", "constexpr",
"constinit", "continue", "decltype", "default", "delete", "do", "else",
"enum", "explicit", "export", "extern", "false", "for", "friend",
"goto", "if", "inline", "mutable", "namespace", "new",
"noexcept", "not", "nullptr", "operator", "or", "private", "protected", "public",
"reflexpr", "register", "requires", "return", "sizeof", "static",
"struct", "switch", "synchronized", "template", "this", "throw", "true", "try",
"typedef", "typeid", "typename", "union", "using", "virtual",
"volatile", "while", "xor", "final", "override", "import", "module"
};
character * types [] = {
"v0", "boolean", "off_t", "va_list", "float", "double", "float_t", "double_t",
"char", "short", "int", "long", "uchar", "ushort", "uint", "ulong",
"int8_t", "int16_t", "int32_t", "int64_t", "uint8_t", "uint16_t", "uint32_t", "uint64_t",
"signed", "unsigned", "size_t", "ssize_t"
};
character * commons [] = {
"std", "FILE", "DIR", "EOF", "va_arg", "va_start", "va_end", "va_copy"
};
syntax_define (syntax, false, false, "/*", "*/", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "//", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "#", "\n", '\\', language->processor_colour, language->processor_effect);
syntax_define (syntax, false, false, "'", "'", '\\', language->character_colour, language->character_effect);
syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (natural_64 word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
for (natural_64 word = 0; word < array_length (commons); ++word) {
syntax_define (syntax, false, true, commons [word], separators, '\0', language->extension_colour, language->extension_effect);
}
syntax_define (syntax, true, false, "()[]{}", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,:;<=>+*-/%!&~^?|", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_lowercase, separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, language_uppercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

52
xanguage/c.h Executable file
View File

@ -0,0 +1,52 @@
static procedure language_highlight_c (language_structure * language, syntax_structure * syntax) {
character * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
character * keywords [] = {
"register", "volatile", "auto", "const", "static", "extern", "if", "else",
"do", "while", "for", "continue", "switch", "case", "default", "break",
"enum", "union", "struct", "typedef", "goto", "return", "sizeof", "inline",
"restrict", "true", "false"
};
character * types [] = {
"void", "bool", "off_t", "va_list", "float", "double", "float_t", "double_t",
"char", "short", "int", "long", "uchar", "ushort", "uint", "ulong",
"int8_t", "int16_t", "int32_t", "int64_t", "uint8_t", "uint16_t", "uint32_t", "uint64_t",
"integer_8", "integer_16", "integer", "integer_64", "natural_8", "natural_16", "natural", "natural_64",
"real", "real_64", "v0", "character", "boolean", "pstring", "signed", "unsigned",
"size_t", "ssize_t"
};
character * commons [] = {
"null", "NULL", "FILE", "DIR", "va_arg", "va_start", "va_end", "va_copy",
"alignas", "alignof", "offsetof", "typeof", "EOF", "ABS", "MIN", "MAX",
"ARRAYSIZE", "SWAP", "UNUSED", "UNREACHABLE", "STRINGIFY", "CONCAT", "assert", "nullptr",
"thread_local", "static_assert"
};
syntax_define (syntax, false, false, "/*", "*/", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "//", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "#", "\n", '\\', language->processor_colour, language->processor_effect);
syntax_define (syntax, false, false, "'", "'", '\\', language->character_colour, language->character_effect);
syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (natural_64 word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
for (natural_64 word = 0; word < array_length (commons); ++word) {
syntax_define (syntax, false, true, commons [word], separators, '\0', language->extension_colour, language->extension_effect);
}
syntax_define (syntax, true, false, "()[]{}", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,:;<=>+*-/%!&~^?|", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_lowercase, separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, language_uppercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

11
xanguage/common.h Executable file
View File

@ -0,0 +1,11 @@
static procedure language_highlight_common (language_structure * language, syntax_structure * syntax) {
character * separators = ".,:;<=>+*-/%!&~^?|()[]{}'\"@#$` \t\r\n";
syntax_define (syntax, false, false, "'", "'", '\\', language->character_colour, language->character_effect);
syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour, language->string_effect);
syntax_define (syntax, true, false, "()[]{}", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,:;<=>+*-/%!&~^?|@#$`", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
}

49
xanguage/d.h Executable file
View File

@ -0,0 +1,49 @@
static procedure language_highlight_d (language_structure * language, syntax_structure * syntax) {
character * separators = ".,:;<=>+-*/%!&~^?|@()[]{}'\"` \t\r\n";
character * keywords [] = {
"abstract", "alias", "align", "asm", "assert", "auto", "body", "boolean",
"break", "byte", "case", "cast", "catch", "cdouble", "cent", "cfloat",
"char", "class", "const", "continue", "creal", "dchar", "debug", "default",
"delegate", "delete", "deprecated", "do", "double", "else", "enum", "export",
"extern", "false", "final", "finally", "float", "for", "foreach", "with",
"function", "goto", "idouble", "if", "ifloat", "immutable", "import", "in",
"inout", "int", "interface", "invariant", "ireal", "is", "lazy", "long",
"macro", "mixin", "module", "new", "nothrow", "null", "out", "override",
"package", "pragma", "private", "protected", "public", "pure", "real", "ref",
"return", "scope", "shared", "short", "static", "struct", "super", "switch",
"synchronized", "template", "this", "throw", "true", "try", "typeid", "typeof",
"ubyte", "ucent", "uint", "ulong", "union", "unittest", "ushort", "version",
"v0", "wchar", "while", "foreach_reverse"
};
character * types [] = {
"byte", "ubyte", "short", "ushort", "int", "uint", "long", "ulong",
"cent", "ucent", "char", "wchar", "dchar", "float", "double", "real",
"ifloat", "idouble", "ireal", "cfloat", "cdouble", "creal", "v0", "boolean",
"string"
};
syntax_define (syntax, false, false, "/+", "+/", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "/*", "*/", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "//", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "'", "'", '\\', language->character_colour, language->character_effect);
syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour, language->string_effect);
syntax_define (syntax, false, false, "`", "`", '\0', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (natural_64 word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
syntax_define (syntax, true, false, "()[]{}", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,:;<=>+*-/%!&~^?|@", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_lowercase, separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, language_uppercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

79
xanguage/eaxhla.h Executable file
View File

@ -0,0 +1,79 @@
static procedure language_highlight_eaxhla (language_structure * language, syntax_structure * syntax) {
character * separators = ".,+-*/[]<>=; \t\r\n";
character * declarations [] = {
"program", "procedure", "machine", "library", "fast", "unix", "begin", "end",
"if", "then", "else", "repeat", "break", "continue", "until", "exit",
"fastcall", "shell", "alias", "macro", "scope", "unscope", "use", "include"
};
character * types [] = {
"integer_64", "character6", "s32", "s64", "natural_64", "natural_86", "u32", "u64",
"f32", "f64", "real_640", "v0", "character28", "natural_828", "integer_1656", "natural_1656",
"s512", "u512"
};
character * instructions [] = {
"jnpe", "jpo", "jnpo", "jpe", "jnb", "jae", "jnbe", "ja",
"jna", "jbe", "jnae", "jb", "jnl", "jge", "jnle", "jg",
"jng", "jle", "jnge", "jl", "cmovng", "cmovle", "cmovnge", "cmovl",
"cmovnpe", "cmovpo", "cmovnpo", "cmovpe", "cmovnb", "cmovae", "cmovnbe", "cmova",
"cmovna", "cmovbe", "cmovnae", "cmovb", "cmovnl", "cmovge", "cmovnle", "cmovg",
"setnpe", "setpo", "setnpo", "setpe", "setnb", "setae", "setnbe", "seta",
"setna", "setbe", "setnae", "setb", "setnl", "setge", "setnle", "setg",
"setng", "setle", "setnge", "setl", "enter", "call", "jmp", "mov",
"add", "or", "adc", "sbb", "and", "sub", "xor", "cmp",
"inc", "dec", "not", "neg", "mul", "imul", "div", "idiv",
"fadd", "fmul", "fcom", "fcomp", "fsub", "fsubr", "fdiv", "fdivr",
"rol", "ror", "rcl", "rcr", "sal", "shr", "shl", "sar",
"nop", "retn", "retf", "leave", "popf", "pushf", "in", "out",
"syscall", "cpuid", "fnop", "fchs", "fabs", "ftst", "fxam", "fld1",
"fldl2t", "fldl2e", "fldpi", "fldlg2", "fldln2", "fldz", "f2xm1", "fyl2x",
"fptan", "fpatan", "fxtract", "fprem1", "fdecstp", "fincstp", "fprem", "fyl2xp1",
"fsqrt", "fsincos", "frndint", "fscale", "fsin", "fcos", "pop", "push",
"bswap", "bsf", "bsr", "loop", "loope", "loopne"
};
character * 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"
};
integer word;
syntax_define (syntax, false, false, "#", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "---", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "//", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "'", "'", '\\', language->character_colour, language->character_effect);
syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (declarations); ++word) {
syntax_define (syntax, false, true, declarations [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (natural_64 word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
for (natural_64 word = 0; word < array_length (instructions); ++word) {
syntax_define (syntax, false, true, instructions [word], " \t\n", '\0', language->extension_colour, language->extension_effect);
}
for (natural_64 word = 0; word < array_length (registers); ++word) {
syntax_define (syntax, false, true, registers [word], separators, '\0', language->register_colour, language->register_effect);
}
syntax_define (syntax, true, false, "()[]{}", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,+*-/%$<>=;", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_lowercase, separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, language_uppercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

66
xanguage/flat.h Executable file
View File

@ -0,0 +1,66 @@
static procedure language_highlight_flat (language_structure * language, syntax_structure * syntax) {
character * separators = ".,+-=:;(){}[]%$<> \t\r\n";
character * declarations [] = {
"format", "executable", "readable", "writable", "segment", "sector", "entry", "macro",
"db", "dw", "dd", "dq", "rb", "rw", "rd", "rq"
};
character * 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"
};
character * 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"
};
integer word;
syntax_define (syntax, false, false, ";", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "'", "'", '\\', language->string_colour, language->string_effect);
syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (declarations); ++word) {
syntax_define (syntax, false, true, declarations [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (natural_64 word = 0; word < array_length (instructions); ++word) {
syntax_define (syntax, false, true, instructions [word], " \t", '\0', language->extension_colour, language->extension_effect);
}
for (natural_64 word = 0; word < array_length (registers); ++word) {
syntax_define (syntax, false, true, registers [word], separators, '\0', language->register_colour, language->register_effect);
}
syntax_define (syntax, true, false, "()[]{}", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,+-=:;%$<>", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_lowercase, separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, language_uppercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

47
xanguage/fortran.h Executable file
View File

@ -0,0 +1,47 @@
static procedure language_highlight_fortran (language_structure * language, syntax_structure * syntax) {
character * separators = ",:<=>+-*/&()[]\"\' \t\r\n";
character * keywords [] = {
"allocatable", "allocate", "associate", "backspace", "block", "call", "case", "common",
"contains", "cycle", "data", "deallocate", "d0", "do", "else", "elseif",
"end", "enddo", "endfile", "endif", "entry", "equivalence", "exit", "external",
"forall", "format", "function", "goto", "if", "implicit", "inquire", "intent",
"intrinsic", "module", "namelist", "none", "nullify", "only", "open", "optional",
"parameter", "pointer", "print", "private", "program", "public", "read", "recursive",
"return", "rewind", "save", "select", "sequence", "stop", "subroutine", "target",
"then", "to", "type", "use", "where", "write"
};
character * types [] = {
"character", "integer", "boolean", "real", "complex"
};
character * commons [] = {
".and.", ".or.", ".not.", ".true.", ".false.", "in", "out", "len",
"dimension", "modulo", "advance"
};
syntax_define (syntax, false, false, "!", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "'", "'", '\\', language->character_colour, language->character_effect);
syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (natural_64 word = 0; word < array_length (commons); ++word) {
syntax_define (syntax, false, true, commons [word], separators, '\0', language->processor_colour, language->processor_effect);
}
for (natural_64 word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
syntax_define (syntax, true, false, "()[]", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ",:<=>+-*/&", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_lowercase, separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, language_uppercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

46
xanguage/go.h Executable file
View File

@ -0,0 +1,46 @@
static procedure language_highlight_go (language_structure * language, syntax_structure * syntax) {
character * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\"` \t\r\n";
character * keywords [] = {
"break", "default", "func", "interface", "select", "case", "defer", "go",
"struct", "else", "goto", "package", "switch", "const", "var", "for",
"fallthrough", "if", "range", "type", "continue", "import", "return"
};
character * types [] = {
"map", "uint", "int", "uintptr", "uint8", "uint16", "uint32", "uint64",
"int8", "int16", "int32", "int64", "float32", "float64", "complex64", "complex128",
"byte", "rune", "string", "chan", "boolean"
};
character * commons [] = {
"true", "false", "nil", "err"
};
syntax_define (syntax, false, false, "/*", "*/", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "//", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "'", "'", '\\', language->character_colour, language->character_effect);
syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour, language->string_effect);
syntax_define (syntax, false, false, "`", "`", '\0', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (natural_64 word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
for (natural_64 word = 0; word < array_length (commons); ++word) {
syntax_define (syntax, false, true, commons [word], separators, '\0', language->extension_colour, language->extension_effect);
}
syntax_define (syntax, true, false, "()[]{}", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,:;<=>+*-/%!&~^?|", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_lowercase, separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, language_uppercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

34
xanguage/haskell.h Executable file
View File

@ -0,0 +1,34 @@
static procedure language_highlight_haskell (language_structure * language, syntax_structure * syntax) {
character * separators = ".,:;<=>+-*/%!@#$&~^?|()[]{}'\" \t\r\n";
character * keywords [] = {
"case", "class", "data", "deriving", "do", "else", "if", "import",
"in", "infix", "infixl", "infixr", "instance", "let", "of", "module",
"newtype", "then", "type", "where"
};
character * types [] = {
"Int", "Integer", "String", "Char", "Float", "Boolean"
};
syntax_define (syntax, false, false, "{-", "-}", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "--", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "'", "'", '\\', language->character_colour, language->character_effect);
syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (natural_64 word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
syntax_define (syntax, true, false, "()[]{}", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,:;<=>+*-/%!@#$&~^?|", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_lowercase, separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, language_uppercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

46
xanguage/holy_c.h Executable file
View File

@ -0,0 +1,46 @@
static procedure language_highlight_holy_c (language_structure * language, syntax_structure * syntax) {
character * separators = ".,:;<=>+-*/%!&~^|()[]{}'\" \t\r\n";
character * keywords [] = {
"static", "extern", "import", "auto", "public", "sizeof", "asm", "no_warn",
"do", "while", "for", "switch", "case", "default", "start", "end",
"if", "else", "goto", "return", "break", "try", "catch", "throw",
"enum", "union", "class"
};
character * types [] = {
"U8", "U16", "U32", "U64", "I8", "I16", "I32", "I64",
"U0", "I0", "F64", "Bool"
};
character * commons [] = {
"_extern", "_intern", "_import", "lastclass", "offset", "defined", "lock", "interrupt",
"reg", "noreg", "argpop", "noargpop", "haserrcode", "NULL", "TRUE", "FALSE"
};
syntax_define (syntax, false, false, "/*", "*/", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "//", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "#", "\n", '\\', language->processor_colour, language->processor_effect);
syntax_define (syntax, false, false, "'", "'", '\\', language->character_colour, language->character_effect);
syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (natural_64 word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
for (natural_64 word = 0; word < array_length (commons); ++word) {
syntax_define (syntax, false, true, commons [word], separators, '\0', language->extension_colour, language->extension_effect);
}
syntax_define (syntax, true, false, "()[]{}", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,:;<=>+*-/%!&~^|", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_lowercase, separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, language_uppercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

50
xanguage/lua.h Executable file
View File

@ -0,0 +1,50 @@
static procedure language_highlight_lua (language_structure * language, syntax_structure * syntax) {
character * separators = ".,:;<=>+-*/%~^#|()[]{}'\" \t\r\n";
character * keywords [] = {
"and", "break", "do", "else", "elseif", "end", "false", "for",
"function", "if", "in", "local", "nil", "not", "or", "until",
"repeat", "return", "then", "true", "while"
};
character * types [] = {
"booleanean", "number", "string", "userdata", "function", "thread", "table"
};
character * commons [] = {
"require", "print", "seek", "dofile", "loadfile", "assert", "rawset", "rawget",
"setfenv", "pairs", "ipairs", "tonumber", "tostring", "foreach", "setn", "getn",
"insert", "concat", "sort", "remove", "abs", "ceil", "floor", "log10",
"rad", "sqrt", "acos", "cos", "fmod", "max", "random", "tan",
"asin", "cosh", "frexp", "min", "randomseed", "tanh", "atan", "deg",
"ldexp", "modf", "sin", "atan2", "sinh", "exp", "log", "pow",
"open", "close", "read", "write", "input", "output", "format", "lines",
"upper", "lower", "find", "gfind", "match", "gmatch", "sub", "gsub",
"len", "rep", "char", "dump", "reverse", "byte"
};
syntax_define (syntax, false, false, "--[[", "]]", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "--", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "'", "'", '\\', language->character_colour, language->character_effect);
syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (natural_64 word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
for (natural_64 word = 0; word < array_length (commons); ++word) {
syntax_define (syntax, false, true, commons [word], separators, '\0', language->extension_colour, language->extension_effect);
}
syntax_define (syntax, true, false, "()[]{}", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,:;<=>+-*/%~^#|", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_lowercase, separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, language_uppercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

28
xanguage/pascal.h Executable file
View File

@ -0,0 +1,28 @@
static procedure language_highlight_pascal (language_structure * language, syntax_structure * syntax) {
character * separators = ".,:;<=>+-*/&@#$%^()[] \t\r\n";
character * keywords [] = {
"absolute", "and", "array", "asm", "begin", "case", "const", "constructor",
"destructor", "div", "do", "downto", "else", "end", "file", "for",
"function", "goto", "if", "in", "inherited", "inline", "interface", "xor",
"label", "mod", "nil", "not", "object", "of", "operator", "or",
"packed", "procedure", "program", "record", "reintroduce", "repeat", "self", "set",
"shl", "shr", "string", "then", "to", "type", "unit", "until",
"uses", "var", "while", "with"
};
syntax_define (syntax, false, false, "//", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "(*", "*)", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "{", "}", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "'", "'", '#', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
syntax_define (syntax, true, false, "[]()", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,:;<=>+-*/&@#$%^", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_letters, separators, '\0', language->lowercase_colour, language->lowercase_effect);
}

47
xanguage/python.h Executable file
View File

@ -0,0 +1,47 @@
static procedure language_highlight_python (language_structure * language, syntax_structure * syntax) {
character * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
character * keywords [] = {
"and", "as", "assert", "break", "class", "continue", "def", "del",
"elif", "else", "except", "False", "finally", "for", "from", "global",
"if", "import", "in", "is", "labmda", "None", "nonlocal", "not",
"or", "pass", "raise", "return", "True", "try", "while", "with",
"yield", "async", "await"
};
character * commons [] = {
"abs", "all", "any", "apply", "ascii", "basestring", "bin", "boolean",
"breakpoint", "buffer", "bytearray", "bytes", "callable", "chr", "classmethod", "cmp",
"coerce", "compile", "complex", "copyright", "credits", "delattr", "dict", "dir",
"divmod", "enumerate", "eval", "execfile", "exit", "file", "filter", "float",
"format", "frozenset", "getattr", "globals", "hasattr", "hash", "help", "hex",
"id", "input", "int", "intern", "isinstance", "issubclass", "iter", "len",
"license", "list", "locals", "long", "map", "max", "memoryview", "min",
"next", "object", "oct", "open", "ord", "pow", "property", "quit",
"range", "raw_input", "reduce", "reload", "repr", "reversed", "round", "set",
"setattr", "slice", "sorted", "staticmethod", "str", "sum", "super", "tuple",
"type", "unichr", "unicode", "vars", "xrange", "zip"
};
syntax_define (syntax, false, false, "#", "\n", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "'''", "'''", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "\"\"\"", "\"\"\"", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "'", "'", '\\', language->character_colour, language->character_effect);
syntax_define (syntax, false, false, "\"", "\"", '\\', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (natural_64 word = 0; word < array_length (commons); ++word) {
syntax_define (syntax, false, true, commons [word], separators, '\0', language->extension_colour, language->extension_effect);
}
syntax_define (syntax, true, false, "()[]", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,:;<=>+*-/%!&~^?|", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_lowercase, separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, language_uppercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

24
xanguage/valgrind.h Executable file
View File

@ -0,0 +1,24 @@
static procedure language_highlight_valgrind (language_structure * language, syntax_structure * syntax) {
character * separators = ".,:;<=>+-*/%!&~^?|@#$()[]{}'\" \t\r\n";
character * titles [] = {
"HEAP", "LEAK", "ERROR", "SUMMARY"
};
syntax_define (syntax, false, false, "==", "==", '\0', language->comment_colour, language->comment_effect);
syntax_define (syntax, false, false, "\"", "\"", '\0', language->string_colour, language->string_effect);
syntax_define (syntax, false, false, "(", ")", '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, false, false, "0x", ":", '\0', language->string_colour, language->string_effect);
for (natural_64 word = 0; word < array_length (titles); ++word) {
syntax_define (syntax, false, true, titles [word], separators, '\0', language->fatal_colour, language->fatal_effect);
}
syntax_define (syntax, true, false, "()[]{}", "", '\0', language->bracket_colour, language->bracket_effect);
syntax_define (syntax, true, false, ".,:;<=>+*-/%!&~^?|@#$", "", '\0', language->operator_colour, language->operator_effect);
syntax_define (syntax, true, true, language_digits, ": ()\t\r\n", '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, language_lowercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, language_uppercase, separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->uppercase_colour, language->uppercase_effect);
}