From: xolatile Date: Sun, 20 Apr 2025 10:12:07 +0000 (+0200) Subject: Trying... X-Git-Url: https://git.xolatile.top/?a=commitdiff_plain;h=e767bea2c871e30c32305ad4035527188c844f29;p=xolatile-xighlight.git Trying... --- diff --git a/xanguage/ada.h b/xanguage/ada.h new file mode 100755 index 0000000..05392cb --- /dev/null +++ b/xanguage/ada.h @@ -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); +} diff --git a/xanguage/bash.h b/xanguage/bash.h new file mode 100755 index 0000000..eca4c43 --- /dev/null +++ b/xanguage/bash.h @@ -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); +} diff --git a/xanguage/c++.h b/xanguage/c++.h new file mode 100755 index 0000000..7552a71 --- /dev/null +++ b/xanguage/c++.h @@ -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); +} diff --git a/xanguage/c.h b/xanguage/c.h new file mode 100755 index 0000000..95d1719 --- /dev/null +++ b/xanguage/c.h @@ -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); +} diff --git a/xanguage/common.h b/xanguage/common.h new file mode 100755 index 0000000..ffa6e2f --- /dev/null +++ b/xanguage/common.h @@ -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); +} diff --git a/xanguage/d.h b/xanguage/d.h new file mode 100755 index 0000000..f59bc4b --- /dev/null +++ b/xanguage/d.h @@ -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); +} diff --git a/xanguage/eaxhla.h b/xanguage/eaxhla.h new file mode 100755 index 0000000..cca50c9 --- /dev/null +++ b/xanguage/eaxhla.h @@ -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); +} diff --git a/xanguage/flat.h b/xanguage/flat.h new file mode 100755 index 0000000..044d6b6 --- /dev/null +++ b/xanguage/flat.h @@ -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); +} diff --git a/xanguage/fortran.h b/xanguage/fortran.h new file mode 100755 index 0000000..2de4e68 --- /dev/null +++ b/xanguage/fortran.h @@ -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); +} diff --git a/xanguage/go.h b/xanguage/go.h new file mode 100755 index 0000000..967b960 --- /dev/null +++ b/xanguage/go.h @@ -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); +} diff --git a/xanguage/haskell.h b/xanguage/haskell.h new file mode 100755 index 0000000..537ce49 --- /dev/null +++ b/xanguage/haskell.h @@ -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); +} diff --git a/xanguage/holy_c.h b/xanguage/holy_c.h new file mode 100755 index 0000000..b9cdb1d --- /dev/null +++ b/xanguage/holy_c.h @@ -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); +} diff --git a/xanguage/lua.h b/xanguage/lua.h new file mode 100755 index 0000000..ca22057 --- /dev/null +++ b/xanguage/lua.h @@ -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); +} diff --git a/xanguage/pascal.h b/xanguage/pascal.h new file mode 100755 index 0000000..16cec4b --- /dev/null +++ b/xanguage/pascal.h @@ -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); +} diff --git a/xanguage/python.h b/xanguage/python.h new file mode 100755 index 0000000..188ffd3 --- /dev/null +++ b/xanguage/python.h @@ -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); +} diff --git a/xanguage/valgrind.h b/xanguage/valgrind.h new file mode 100755 index 0000000..f187721 --- /dev/null +++ b/xanguage/valgrind.h @@ -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); +}