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

Static...

Browse Source
This commit is contained in:
Ognjen Milan Robovic 2025-04-06 19:32:31 +02:00
parent c178371655
commit 6c099626ad
27 changed files with 2746 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
README.md
View File

@ -1,3 +1,6 @@
# xarbon # xarbon
Static version of Xarbon... Static version of Xarbon...
Compile: `sh compile.sh`
Install: `sudo sh install.sh`

7
compile.sh Executable file
View File

@ -0,0 +1,7 @@
#!/bin/bash
set -xe
gcc -std=gnu99 -Wall -Wno-comment -Wno-unused-variable -Wno-unused-function -Ofast -o xarbon xarbon.c -lpng
exit

7
install.sh Executable file
View File

@ -0,0 +1,7 @@
#!/bin/bash
set -xe
cp -f xarbon /usr/local/bin/xarbon
exit

201
xanguage.h Executable file
View File

@ -0,0 +1,201 @@
/// __ ____ _ _ __ __ _ _ _ __ _ __ _ ___
/// \ \/ / _` | '_ \ / _` | | | |/ _` |/ _` |/ _ \
/// > < (_| | | | | (_| | |_| | (_| | (_| | __/
/// /_/\_\__,_|_| |_|\__, |\__,_|\__,_|\__, |\___|
/// |___/ |___/
///
/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
///
/// xolatile@chud.cyou - xanguage - Syntax definitions of programming languages that I care about (and some that I don't care about).
///
/// This program is free software, free as in freedom and as in free beer, you can redistribute it and/or modify it under the terms of the GNU
/// General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version if you wish...
///
/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied
/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License
/// for more details, if you dare, it is a lot of text that nobody wants to read...
typedef enum {
language_common, language_ada, language_c, language_cpp,
language_d, language_eaxhla, language_flat, language_fortran,
language_pascal, language_python, language_go, language_lua,
language_bash, language_haskell, language_valgrind,
language_count
} language_enumeration;
typedef struct {
uint comment_colour;
uint processor_colour;
uint character_colour;
uint string_colour;
uint keyword_colour;
uint type_colour;
uint bracket_colour;
uint operator_colour;
uint number_colour;
uint lowercase_colour;
uint uppercase_colour;
uint underscore_colour;
uint register_colour;
uint extension_colour;
uint fatal_colour;
uint comment_effect;
uint processor_effect;
uint character_effect;
uint string_effect;
uint keyword_effect;
uint type_effect;
uint bracket_effect;
uint operator_effect;
uint number_effect;
uint lowercase_effect;
uint uppercase_effect;
uint underscore_effect;
uint register_effect;
uint extension_effect;
uint fatal_effect;
} language_structure;
#include "./xanguage/common.h"
#include "./xanguage/ada.h"
#include "./xanguage/c.h"
#include "./xanguage/c++.h"
#include "./xanguage/d.h"
#include "./xanguage/eaxhla.h"
#include "./xanguage/flat.h"
#include "./xanguage/fortran.h"
#include "./xanguage/pascal.h"
#include "./xanguage/python.h"
#include "./xanguage/go.h"
#include "./xanguage/lua.h"
#include "./xanguage/bash.h"
#include "./xanguage/haskell.h"
#include "./xanguage/valgrind.h"
static language_structure * language_initialize (bool true_colour) {
language_structure * language = allocate (sizeof (* language));
if (true_colour == true) {
language->comment_colour = 0xff777777u;
language->processor_colour = 0xff3377aau;
language->character_colour = 0xff7733ccu;
language->string_colour = 0xffcc3377u;
language->keyword_colour = 0xff33cceeu;
language->type_colour = 0xff55cceeu;
language->bracket_colour = 0xffee5533u;
language->operator_colour = 0xffeeaa33u;
language->number_colour = 0xffee33aau;
language->lowercase_colour = 0xffccccccu;
language->uppercase_colour = 0xffeeeeeeu;
language->underscore_colour = 0xffaaaaaau;
language->register_colour = 0xff5577aau;
language->extension_colour = 0xff55aaccu;
language->fatal_colour = 0xffcc7755u;
} else {
language->comment_colour = colour_grey;
language->processor_colour = colour_cyan;
language->character_colour = colour_pink;
language->string_colour = colour_pink;
language->keyword_colour = colour_yellow;
language->type_colour = colour_yellow;
language->bracket_colour = colour_blue;
language->operator_colour = colour_cyan;
language->number_colour = colour_pink;
language->lowercase_colour = colour_white;
language->uppercase_colour = colour_white;
language->underscore_colour = colour_white;
language->register_colour = colour_cyan;
language->extension_colour = colour_yellow;
language->fatal_colour = colour_red;
language->comment_effect = effect_bold;
language->processor_effect = effect_italic;
language->character_effect = effect_bold;
language->string_effect = effect_normal;
language->keyword_effect = effect_bold;
language->type_effect = effect_normal;
language->bracket_effect = effect_bold;
language->operator_effect = effect_normal;
language->number_effect = effect_bold;
language->lowercase_effect = effect_normal;
language->uppercase_effect = effect_bold;
language->underscore_effect = effect_italic;
language->register_effect = effect_italic;
language->extension_effect = effect_italic;
language->fatal_effect = effect_bold;
}
return (language);
}
static language_structure * language_deinitialize (language_structure * language) {
return (deallocate (language));
}
static void (* language_highlighter (language_enumeration language)) (language_structure * language, syntax_structure * syntax) {
static void (* highlighter [language_count]) (language_structure * language, syntax_structure * syntax) = {
language_highlight_common, language_highlight_ada, language_highlight_c, language_highlight_cpp,
language_highlight_d, language_highlight_eaxhla, language_highlight_flat, language_highlight_fortran,
language_highlight_pascal, language_highlight_python, language_highlight_go, language_highlight_lua,
language_highlight_bash, language_highlight_haskell, language_highlight_valgrind
};
fatal_failure (language >= language_count, "language_highlighter: Language index not in enumeration.");
return (highlighter [language]);
}
static char * language_short_option (language_enumeration language) {
static char * short_option [language_count] = {
"-X", "-A", "-C", "-S", "-D", "-E", "-T", "-F", "-P", "-Y", "-G", "-L", "-B", "-H", "-V"
};
fatal_failure (language >= language_count, "language_short_option: Language index not in enumeration.");
return (short_option [language]);
}
static char * language_long_option (language_enumeration language) {
static char * long_option [language_count] = {
"--common", "--ada", "--c", "--cpp", "--d", "--eaxhla", "--flat", "--fortran",
"--pascal", "--python", "--go", "--lua", "--bash", "--haskell", "--valgrind"
};
fatal_failure (language >= language_count, "language_long_option: Language index not in enumeration.");
return (long_option [language]);
}
static char * language_identifier (language_enumeration language) {
static char * identifier [language_count] = {
"Common", "Ada", "C", "C++", "D", "EAXHLA", "Flat", "Fortran",
"Pascal", "Python", "Go", "Lua", "Bash", "Haskell", "Valgrind"
};
fatal_failure (language >= language_count, "language_identifier: Language index not in enumeration.");
return (identifier [language]);
}
static void language_conditionally_select (language_structure * language, syntax_structure * syntax, uint select) {
if (syntax->count == 0) {
if ((select == file_type_c_source) || (select == file_type_c_header)) {
language_highlight_c (language, syntax);
} else if ((select == file_type_ada_sexy_body) || (select == file_type_ada_specification)) {
language_highlight_ada (language, syntax);
} else if ((select == file_type_cpp_source) || (select == file_type_cpp_header)) {
language_highlight_cpp (language, syntax);
} else if (select == file_type_flat_assembly) {
language_highlight_flat (language, syntax);
} else if (select == file_type_fortran_90_source) {
language_highlight_fortran (language, syntax);
} else if (select == file_type_pascal_source) {
language_highlight_pascal (language, syntax);
} else if (select == file_type_eax_assembly) {
language_highlight_eaxhla (language, syntax);
} else if (select == file_type_python_script) {
language_highlight_python (language, syntax);
} else {
language_highlight_common (language, syntax);
}
}
}

31
xanguage/ada.h Executable file
View File

@ -0,0 +1,31 @@
static void language_highlight_ada (language_structure * language, syntax_structure * syntax) {
const char * separators = ".,:;<=>+-*/&|()\" \t\r\n";
const 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"
};
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 (ulong 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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', language->uppercase_colour, language->uppercase_effect);
}

24
xanguage/bash.h Executable file
View File

@ -0,0 +1,24 @@
static void language_highlight_bash (language_structure * language, syntax_structure * syntax) {
const char * separators = ".,:;<=>+-*/%!&~^?|@#$()[]{}'\" \t\r\n";
const char * 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 (ulong 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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 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 void language_highlight_cpp (language_structure * language, syntax_structure * syntax) {
const char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
const char * 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"
};
const char * 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",
"signed", "unsigned", "size_t", "ssize_t"
};
const char * 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 (ulong word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (ulong word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
for (ulong 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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

49
xanguage/c.h Executable file
View File

@ -0,0 +1,49 @@
static void language_highlight_c (language_structure * language, syntax_structure * syntax) {
const char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
const char * 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"
};
const char * 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",
"signed", "unsigned", "size_t", "ssize_t"
};
const char * 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", "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 (ulong word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (ulong word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
for (ulong 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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

9
xanguage/common.h Executable file
View File

@ -0,0 +1,9 @@
static void language_highlight_common (language_structure * language, syntax_structure * syntax) {
const char * 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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
}

49
xanguage/d.h Executable file
View File

@ -0,0 +1,49 @@
static void language_highlight_d (language_structure * language, syntax_structure * syntax) {
const char * separators = ".,:;<=>+-*/%!&~^?|@()[]{}'\"` \t\r\n";
const char * keywords [] = {
"abstract", "alias", "align", "asm", "assert", "auto", "body", "bool",
"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",
"void", "wchar", "while", "foreach_reverse"
};
const char * types [] = {
"byte", "ubyte", "short", "ushort", "int", "uint", "long", "ulong",
"cent", "ucent", "char", "wchar", "dchar", "float", "double", "real",
"ifloat", "idouble", "ireal", "cfloat", "cdouble", "creal", "void", "bool",
"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 (ulong word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (ulong 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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 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 void language_highlight_eaxhla (language_structure * language, syntax_structure * syntax) {
const char * separators = ".,+-*/[]<>=; \t\r\n";
const char * 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"
};
const char * types [] = {
"s8", "s16", "s32", "s64", "u8", "u16", "u32", "u64",
"f32", "f64", "f80", "v0", "s128", "u128", "s256", "u256",
"s512", "u512"
};
const char * 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"
};
const 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"
};
int 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 (ulong word = 0; word < array_length (declarations); ++word) {
syntax_define (syntax, false, true, declarations [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (ulong word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
for (ulong word = 0; word < array_length (instructions); ++word) {
syntax_define (syntax, false, true, instructions [word], separators, '\0', language->extension_colour, language->extension_effect);
}
for (ulong 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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 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 void language_highlight_flat (language_structure * language, syntax_structure * syntax) {
const char * separators = ".,+-=:;(){}[]%$<> \t\r\n";
const char * declarations [] = {
"format", "executable", "readable", "writable", "segment", "sector", "entry", "macro",
"db", "dw", "dd", "dq", "rb", "rw", "rd", "rq"
};
const 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"
};
const 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"
};
int 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 (ulong word = 0; word < array_length (declarations); ++word) {
syntax_define (syntax, false, true, declarations [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (ulong word = 0; word < array_length (instructions); ++word) {
syntax_define (syntax, false, true, instructions [word], separators, '\0', language->extension_colour, language->extension_effect);
}
for (ulong 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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 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 void language_highlight_fortran (language_structure * language, syntax_structure * syntax) {
const char * separators = ",:<=>+-*/&()[]\"\' \t\r\n";
const char * 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"
};
const char * types [] = {
"character", "integer", "logical", "real", "complex"
};
const char * subkeywords [] = {
".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 (ulong word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (ulong word = 0; word < array_length (subkeywords); ++word) {
syntax_define (syntax, false, true, subkeywords [word], separators, '\0', language->processor_colour, language->processor_effect);
}
for (ulong 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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 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 void language_highlight_go (language_structure * language, syntax_structure * syntax) {
const char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\"` \t\r\n";
const char * keywords [] = {
"break", "default", "func", "interface", "select", "case", "defer", "go",
"struct", "else", "goto", "package", "switch", "const", "var", "for",
"fallthrough", "if", "range", "type", "continue", "import", "return"
};
const char * types [] = {
"map", "uint", "int", "uintptr", "uint8", "uint16", "uint32", "uint64",
"int8", "int16", "int32", "int64", "float32", "float64", "complex64", "complex128",
"byte", "rune", "string", "chan", "bool"
};
const char * 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 (ulong word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (ulong word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
for (ulong 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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 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 void language_highlight_haskell (language_structure * language, syntax_structure * syntax) {
const char * separators = ".,:;<=>+-*/%!@#$&~^?|()[]{}'\" \t\r\n";
const char * keywords [] = {
"case", "class", "data", "deriving", "do", "else", "if", "import",
"in", "infix", "infixl", "infixr", "instance", "let", "of", "module",
"newtype", "then", "type", "where"
};
const char * 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 (ulong word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (ulong 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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 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 void language_highlight_lua (language_structure * language, syntax_structure * syntax) {
const char * separators = ".,:;<=>+-*/%~^#|()[]{}'\" \t\r\n";
const char * keywords [] = {
"and", "break", "do", "else", "elseif", "end", "false", "for",
"function", "if", "in", "local", "nil", "not", "or", "until",
"repeat", "return", "then", "true", "while"
};
const char * types [] = {
"boolean", "number", "string", "userdata", "function", "thread", "table"
};
const char * 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 (ulong word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (ulong word = 0; word < array_length (types); ++word) {
syntax_define (syntax, false, true, types [word], separators, '\0', language->type_colour, language->type_effect);
}
for (ulong 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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

29
xanguage/pascal.h Executable file
View File

@ -0,0 +1,29 @@
static void language_highlight_pascal (language_structure * language, syntax_structure * syntax) {
const char * separators = ".,:;<=>+-*/&@#$%^()[] \t\r\n";
const char * 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 (ulong 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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', language->uppercase_colour, language->uppercase_effect);
}

47
xanguage/python.h Executable file
View File

@ -0,0 +1,47 @@
static void language_highlight_python (language_structure * language, syntax_structure * syntax) {
const char * separators = ".,:;<=>+-*/%!&~^?|()[]{}'\" \t\r\n";
const char * 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"
};
const char * subkeywords [] = {
"abs", "all", "any", "apply", "ascii", "basestring", "bin", "bool",
"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 (ulong word = 0; word < array_length (keywords); ++word) {
syntax_define (syntax, false, true, keywords [word], separators, '\0', language->keyword_colour, language->keyword_effect);
}
for (ulong word = 0; word < array_length (subkeywords); ++word) {
syntax_define (syntax, false, true, subkeywords [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, "0123456789", separators, '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->lowercase_colour, language->lowercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->underscore_colour, language->underscore_effect);
}

25
xanguage/valgrind.h Executable file
View File

@ -0,0 +1,25 @@
static void language_highlight_valgrind (language_structure * language, syntax_structure * syntax) {
const char * separators = ".,:;<=>+-*/%!&~^?|@#$()[]{}'\" \t\r\n";
const char * titles [] = {
//~"exit", "set", "elif", "done", "in", "then", "function", "fi",
"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 (ulong 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, "0123456789", ": ()\t\r\n", '\0', language->number_colour, language->number_effect);
syntax_define (syntax, true, true, "abcdefghijklmnopqrstuvwxyz", separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", separators, '\0', language->uppercase_colour, language->uppercase_effect);
syntax_define (syntax, true, true, "_", separators, '\0', language->uppercase_colour, language->uppercase_effect);
}

BIN
xarbon Executable file
View File

Binary file not shown.

276
xarbon.c Executable file
View File

@ -0,0 +1,276 @@
/// _
/// __ ____ _ _ __| |__ ___ _ __
/// \ \/ / _` | '__| '_ \ / _ \| '_ |
/// > < (_| | | | |_) | (_) | | | |
/// /_/\_\__,_|_| |_.__/ \___/|_| |_|
///
/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
///
/// xolatile@chud.cyou - xarbon - Source code renderer to PNG image, very slow but self-contained, hardcoded font.
///
/// This program is free software, free as in freedom and as in free beer, you can redistribute it and/or modify it under the terms of the GNU
/// General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version if you wish...
///
/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied
/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License
/// for more details, if you dare, it is a lot of text that nobody wants to read...
#define use_png_library
#include "./xtandard.h"
#include "./xyntax.h"
#include "./xanguage.h"
#include "./xormat.h"
static const uint background = 0xff181818;
static const uint foreground = 0xffcccccc;
static const uint font_width = 8;
static const uint font_height = 16;
static const uint tab_width = 8;
static const uint render_border = 10;
static uint * render_image = null;
static uint render_width = 0;
static uint render_height = 0;
static uint line_number = 0;
static uint line_digits = 0;
static void conditionally_exit (language_structure * language, syntax_structure * syntax, bool terminate) {
syntax = syntax_deinitialize (syntax);
language = language_deinitialize (language);
if (terminate == true) {
exit (log_success);
}
}
static void print_common (void) {
print ("/B/4xarbon/-: /4Source code PNG renderer/-\n\n");
print ("\tAuthor: /4Ognjen 'xolatile' Milan Robovic/-\n");
print ("\tLicense: /4GNU//GPLv3/-\n\n");
}
static void print_help (void) {
print_common ();
print ("Example usage:\n\n");
print ("\t/6$ cat file.ext | xarbon [flags]/- /0---/- You need to pass language flag in this case.\n");
print ("\t/6$ xarbon [flags] < file.ext/- /0---/- You need to pass language flag in this case.\n");
print ("\t/6$ xarbon file.ext/- /0---/- Language is automatically detected in this case.\n\n");
print ("Supported languages:\n\n");
for (uint index = 0; index < language_count; ++index) {
char align [32] = "";
print ("\t/B/4%s/- /4%s/- /0---/- %s syntax highlighting\n",
language_short_option (index),
string_align_left (string_copy (align, language_long_option (index)), 9, ' '),
language_identifier (index));
}
}
static void print_version (void) {
print_common ();
print ("\tVersion: /40 (Zero)/-\n");
}
static uint fetch_width (const char * data) {
uint image_width = 0;
uint count = 0;
do {
if (* data == '\t') {
count += tab_width;
} else if (* data == '\n') {
image_width = (++count > image_width) ? count : image_width;
count = 0;
} else {
++count;
}
} while (* (++data) != '\0');
return (image_width - 1);
}
static uint fetch_height (const char * data) {
uint image_height = 0;
uint count = 0;
do {
if (* data == '\n') {
++image_height;
}
} while (* (++data) != '\0');
count = image_height + 1;
do {
++line_digits;
count /= 10;
} while (count > 0);
return (image_height + 1);
}
static void render_character (char character, uint * x, uint * y, uint colour) {
const ulong glyphmap [192] = {
0x0000000000000000, 0x0000000000000000, 0x0000101010101010, 0x1000101000000000, 0x0024242400000000, 0x0000000000000000,
0x00002424247e2424, 0x7e24242400000000, 0x0010107c9290907c, 0x1212927c10100000, 0x0000649468081010, 0x202c524c00000000,
0x000018242418304a, 0x4444443a00000000, 0x0010101000000000, 0x0000000000000000, 0x0000081020202020, 0x2020100800000000,
0x0000201008080808, 0x0808102000000000, 0x000000000024187e, 0x1824000000000000, 0x000000000010107c, 0x1010000000000000,
0x0000000000000000, 0x0000101020000000, 0x000000000000007e, 0x0000000000000000, 0x0000000000000000, 0x0000101000000000,
0x0000040408081010, 0x2020404000000000, 0x00003c4242464a52, 0x6242423c00000000, 0x0000081828080808, 0x0808083e00000000,
0x00003c4242020408, 0x1020407e00000000, 0x00003c4242021c02, 0x0242423c00000000, 0x000002060a122242, 0x7e02020200000000,
0x00007e4040407c02, 0x0202423c00000000, 0x00001c2040407c42, 0x4242423c00000000, 0x00007e0202040408, 0x0810101000000000,
0x00003c4242423c42, 0x4242423c00000000, 0x00003c424242423e, 0x0202043800000000, 0x0000000000101000, 0x0000101000000000,
0x0000000000101000, 0x0000101020000000, 0x0000000408102040, 0x2010080400000000, 0x00000000007e0000, 0x7e00000000000000,
0x0000004020100804, 0x0810204000000000, 0x00003c4242420408, 0x0800080800000000, 0x00007c829ea2a2a2, 0xa69a807e00000000,
0x00003c424242427e, 0x4242424200000000, 0x00007c4242427c42, 0x4242427c00000000, 0x00003c4242404040, 0x4042423c00000000,
0x0000784442424242, 0x4242447800000000, 0x00007e4040407840, 0x4040407e00000000, 0x00007e4040407840, 0x4040404000000000,
0x00003c424240404e, 0x4242423c00000000, 0x0000424242427e42, 0x4242424200000000, 0x0000381010101010, 0x1010103800000000,
0x00000e0404040404, 0x0444443800000000, 0x0000424448506060, 0x5048444200000000, 0x0000404040404040, 0x4040407e00000000,
0x000082c6aa929282, 0x8282828200000000, 0x000042424262524a, 0x4642424200000000, 0x00003c4242424242, 0x4242423c00000000,
0x00007c424242427c, 0x4040404000000000, 0x00003c4242424242, 0x42424a3c02000000, 0x00007c424242427c, 0x5048444200000000,
0x00003c4240403c02, 0x0242423c00000000, 0x0000fe1010101010, 0x1010101000000000, 0x0000424242424242, 0x4242423c00000000,
0x0000424242424224, 0x2424181800000000, 0x0000828282828292, 0x92aac68200000000, 0x0000424224241818, 0x2424424200000000,
0x0000828244442810, 0x1010101000000000, 0x00007e0202040810, 0x2040407e00000000, 0x0000382020202020, 0x2020203800000000,
0x0000404020201010, 0x0808040400000000, 0x0000380808080808, 0x0808083800000000, 0x0000102844000000, 0x0000000000000000,
0x0000000000000000, 0x0000007e00000000, 0x1008000000000000, 0x0000000000000000, 0x00000000003c023e, 0x4242423e00000000,
0x00004040407c4242, 0x4242427c00000000, 0x00000000003c4240, 0x4040423c00000000, 0x00000202023e4242, 0x4242423e00000000,
0x00000000003c4242, 0x7e40403c00000000, 0x00000e10107c1010, 0x1010101000000000, 0x00000000003e4242, 0x4242423e02023c00,
0x00004040407c4242, 0x4242424200000000, 0x0000101000301010, 0x1010103800000000, 0x00000404000c0404, 0x0404040444443800,
0x0000404040424448, 0x7048444200000000, 0x0000301010101010, 0x1010103800000000, 0x0000000000fc9292, 0x9292929200000000,
0x00000000007c4242, 0x4242424200000000, 0x00000000003c4242, 0x4242423c00000000, 0x00000000007c4242, 0x4242427c40404000,
0x00000000003e4242, 0x4242423e02020200, 0x00000000005e6040, 0x4040404000000000, 0x00000000003e4040, 0x3c02027c00000000,
0x00001010107c1010, 0x1010100e00000000, 0x0000000000424242, 0x4242423e00000000, 0x0000000000424242, 0x2424181800000000,
0x0000000000828292, 0x9292927c00000000, 0x0000000000424224, 0x1824424200000000, 0x0000000000424242, 0x4242423e02023c00,
0x00000000007e0408, 0x1020407e00000000, 0x00000c1010102010, 0x1010100c00000000, 0x0000101010101010, 0x1010101000000000,
0x0000300808080408, 0x0808083000000000, 0x000000000062928c, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000
};
for (ulong index = 0; index < 2; ++index) {
for (ulong bit = 64; bit > 0; --bit) {
ulong destination = (* y + (index << 3) - ((bit - 1) >> 3) + 7) * render_width + (* x - ((bit - 1) & 7) + 7);
ulong source = (glyphmap [2 * (ulong) (character - ' ') + index] >> (bit - 1)) & 1;
render_image [destination] = (source) ? colour : background;
}
}
* x += font_width;
}
static void render_string (char * string, uint length, uint * x, uint * y, uint colour) {
for (uint offset = 0; offset < length; ++offset) {
if (string [offset] == '\t') {
* x += font_width * tab_width;
} else if (string [offset] == '\n') {
* y += font_height;
* x = render_border;
render_string (format_to_string ((int) ++line_number, false, 10, (int) line_digits, ' '), line_digits, x, y, foreground);
* x += font_width;
} else {
render_character (string [offset], x, y, colour);
}
}
}
int main (int argc, char * * argv) {
uint select = language_count;
uint offset = 0;
uint length = 0;
uint x = render_border;
uint y = render_border;
char * buffer = null;
char * dump = null;
syntax_structure * syntax = syntax_initialize (666);
language_structure * language = language_initialize (true);
for (int argument = 1; argument < argc; ++argument) {
if (argument_compare (argv [argument], "-h", "--help") == true) {
print_help ();
conditionally_exit (language, syntax, true);
} else if (argument_compare (argv [argument], "-v", "--version") == true) {
print_version ();
conditionally_exit (language, syntax, true);
} else if (argument_compare (argv [argument], "-o", "--output") == true) {
if (argument + 1 >= argc) {
print ("/f Expected output file name: /1%s/-\n", argv [argument]);
conditionally_exit (language, syntax, true);
}
++argument;
dump = string_duplicate (argv [argument]);
continue;
}
for (uint index = 0; index < language_count; ++index) {
if (argument_compare (argv [argument], language_short_option (index), language_long_option (index)) == true) {
(* (language_highlighter (index))) (language, syntax);
select = index;
break;
}
}
if (file_exists (argv [argument]) == true) {
if (select == language_count) {
select = (uint) file_type (argv [argument]);
}
if (buffer == null) {
buffer = file_import (argv [argument]);
} continue;
} else {
print ("/f Unrecognized command line argument: /1%s/-\n", argv [argument]);
conditionally_exit (language, syntax, true);
}
}
if (dump == null) {
dump = string_duplicate ("xarbon.png");
}
if (select == language_count) {
select = language_common;
}
if (buffer == null) {
buffer = record ();
}
language_conditionally_select (language, syntax, select);
render_width = fetch_width (buffer) * font_width + 2 * render_border;
render_height = fetch_height (buffer) * font_height + 2 * render_border;
render_width += (line_digits + 1) * font_width;
render_image = allocate (render_width * render_height * sizeof (* render_image));
for (offset = 0; offset < render_width * render_height; ++offset) {
render_image [offset] = background;
}
render_string (format_to_string ((int) ++line_number, false, 10, (int) line_digits, ' '), line_digits, & x, & y, foreground);
x += font_width;
for (offset = 0; buffer [offset] != '\0'; offset += length) {
select = syntax_select (syntax, & buffer [offset], & length);
render_string (& buffer [offset], length, & x, & y, (select >= syntax->count) ? background : (uint) syntax->colour [select]);
}
png_image_export (dump, render_image, render_width, render_height);
conditionally_exit (language, syntax, false);
render_image = deallocate (render_image);
buffer = deallocate (buffer);
dump = deallocate (dump);
return (log_success);
}

122
xormat.h Normal file
View File

@ -0,0 +1,122 @@
/// _
/// __ _____ _ __ _ __ ___ __ _| |_
/// \ \/ / _ \| '__| '_ ` _ \ / _` | __|
/// > < (_) | | | | | | | | (_| | |_
/// /_/\_\___/|_| |_| |_| |_|\__,_|\__|
///
/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
///
/// xolatile@chud.cyou - xormat - Very simple file format wrapper for things I hate but have to use anyway...
///
/// This program is free software, free as in freedom and as in free beer, you can redistribute it and/or modify it under the terms of the GNU
/// General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version if you wish...
///
/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied
/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License
/// for more details, if you dare, it is a lot of text that nobody wants to read...
#ifdef use_png_library
#include "./xormat/png.h"
#endif
#ifdef use_jxl_library
#include "./xormat/jxl.h"
#endif
#ifdef use_jpg_library
#include "./xormat/jpg.h"
#endif
#ifdef use_tga_library
#include "./xormat/tga.h"
#endif
static void * format_image_import (const char * path, uint * width, uint * height) {
uint * data = null;
#ifdef use_png_library
if (data == null) {
char buffer [256] = "";
if (file_exists (string_concatenate (string_copy (buffer, path), ".png")) == true) {
data = png_image_import (buffer, width, height);
}
}
#endif
#ifdef use_jxl_library
if (data == null) {
char buffer [256] = "";
if (file_exists (string_concatenate (string_copy (buffer, path), ".jxl")) == true) {
data = jxl_image_import (buffer, width, height);
}
}
#endif
#ifdef use_jpg_library
if (data == null) {
char buffer [256] = "";
if (file_exists (string_concatenate (string_copy (buffer, path), ".jpg")) == true) {
data = jpg_image_import (buffer, width, height);
}
}
#endif
#ifdef use_tga_library
if (data == null) {
char buffer [256] = "";
if (file_exists (string_concatenate (string_copy (buffer, path), ".tga")) == true) {
data = tga_image_import (buffer, width, height);
}
}
#endif
if (data == null) {
switch (file_type (path)) {
#ifdef use_png_library
case (file_type_png_image): {
if (file_exists (path) == true) {
data = png_image_import (path, width, height);
} else {
print ("/w File '/3%s/-' doesn't exist.\n", path);
}
} break;
#endif
#ifdef use_jxl_library
case (file_type_jxl_image): {
if (file_exists (path) == true) {
data = jxl_image_import (path, width, height);
} else {
print ("/w File '/3%s/-' doesn't exist.\n", path);
}
} break;
#endif
#ifdef use_jpg_library
case (file_type_jpg_image): {
if (file_exists (path) == true) {
data = jpg_image_import (path, width, height);
} else {
print ("/w File '/3%s/-' doesn't exist.\n", path);
}
} break;
#endif
#ifdef use_tga_library
case (file_type_tga_image): {
if (file_exists (path) == true) {
data = tga_image_import (path, width, height);
} else {
print ("/w File '/3%s/-' doesn't exist.\n", path);
}
} break;
#endif
default: {
print ("/w File '/3%s/-' doesn't exist or file type isn't supported.\n", path);
} break;
}
}
return (data);
}

68
xormat/jxl.h Normal file
View File

@ -0,0 +1,68 @@
#include <jxl/decode.h>
#ifndef use_jxl_library
#define use_jxl_library
#endif
static void * jxl_image_import (const char * path, uint * width, uint * height) {
JxlDecoder * decoder = null;
JxlBasicInfo information = { 0 };
JxlPixelFormat format = { 4, JXL_TYPE_UINT8, JXL_NATIVE_ENDIAN, 0 };
JxlDecoderStatus status = JXL_DEC_ERROR;
fatal_failure (path == null, "jxl_image_import: File path is null pointer.");
fatal_failure (width == null, "jxl_image_import: Width is null pointer.");
fatal_failure (height == null, "jxl_image_import: Height is null pointer.");
ulong size = file_size (path);
uchar * data = file_record (path);
uint * pixel_array = null;
ulong output_size = 0;
decoder = JxlDecoderCreate (null);
fatal_failure (decoder == null, "jxl_image_import: Failed to create a decoder.");
status = JxlDecoderSubscribeEvents (decoder, JXL_DEC_BASIC_INFO | JXL_DEC_FULL_IMAGE);
fatal_failure (status != JXL_DEC_SUCCESS, "jxl_image_import: Failed to subscribe decoder basic information and full image events.");
status = JxlDecoderSetInput (decoder, data, size);
fatal_failure (status != JXL_DEC_SUCCESS, "jxl_image_import: Failed to set decoder input data and size.");
for (status = JxlDecoderProcessInput (decoder); true; status = JxlDecoderProcessInput (decoder)) {
fatal_failure (status == JXL_DEC_ERROR, "jxl_image_import: Decoder internal error.");
fatal_failure (status == JXL_DEC_NEED_MORE_INPUT, "jxl_image_import: Decoder needs more input data.");
if (status == JXL_DEC_BASIC_INFO) {
status = JxlDecoderGetBasicInfo(decoder, &information);
fatal_failure (status != JXL_DEC_SUCCESS, "jxl_image_import: Failed to get basic image information.");
continue;
}
if (status == JXL_DEC_NEED_IMAGE_OUT_BUFFER) {
status = JxlDecoderImageOutBufferSize(decoder, & format, & output_size);
fatal_failure (status != JXL_DEC_SUCCESS, "jxl_image_import: Failed to get image output buffer size.");
if (pixel_array != null) {
pixel_array = deallocate (pixel_array);
}
pixel_array = allocate (output_size);
status = JxlDecoderSetImageOutBuffer(decoder, & format, pixel_array, output_size);
fatal_failure (status != JXL_DEC_SUCCESS, "jxl_image_import: Failed to set image output buffer data.");
continue;
}
if (status == JXL_DEC_FULL_IMAGE) continue;
if (status == JXL_DEC_SUCCESS) break;
}
* width = information.xsize;
* height = information.ysize;
JxlDecoderDestroy (decoder);
data = deallocate (data);
return (pixel_array);
}

6
xormat/ply.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef use_ply_library
#define use_ply_library
#endif

106
xormat/png.h Normal file
View File

@ -0,0 +1,106 @@
#include <stdio.h>
#include <png.h>
#ifndef use_png_library
#define use_png_library
#endif
static void * png_image_import (const char * path, uint * width, uint * height) {
FILE * file;
uint * data;
uint index;
png_byte colour_type = 0;
png_byte bit_depth = 0;
png_bytep * row_pointers = null;
png_structp structure = null;
png_infop information = null;
fatal_failure (path == null, "png_image_import: File path is null pointer.");
fatal_failure (width == null, "png_image_import: Width is null pointer.");
fatal_failure (height == null, "png_image_import: Height is null pointer.");
file = fopen (path, "rb");
fatal_failure (file == null, path);
structure = png_create_read_struct (PNG_LIBPNG_VER_STRING, null, null, null);
information = png_create_info_struct (structure);
png_init_io (structure, file);
png_read_info (structure, information);
* width = png_get_image_width (structure, information);
* height = png_get_image_height (structure, information);
colour_type = png_get_color_type (structure, information);
bit_depth = png_get_bit_depth (structure, information);
if (bit_depth == 16) {
png_set_strip_16 (structure);
}
if (colour_type == PNG_COLOR_TYPE_PALETTE) {
png_set_palette_to_rgb (structure);
}
if ((colour_type == PNG_COLOR_TYPE_GRAY) && (bit_depth < 8)) {
png_set_expand_gray_1_2_4_to_8 (structure);
}
if (png_get_valid (structure, information, PNG_INFO_tRNS)) {
png_set_tRNS_to_alpha (structure);
}
if ((colour_type == PNG_COLOR_TYPE_RGB) || (colour_type == PNG_COLOR_TYPE_GRAY) || (colour_type == PNG_COLOR_TYPE_PALETTE)) {
png_set_filler (structure, 0xff, PNG_FILLER_AFTER);
}
if ((colour_type == PNG_COLOR_TYPE_GRAY) || (colour_type == PNG_COLOR_TYPE_GRAY_ALPHA)) {
png_set_gray_to_rgb (structure);
}
png_read_update_info (structure, information);
row_pointers = allocate ((* height) * sizeof (* row_pointers));
for (index = 0; index < (* height); ++index) {
row_pointers [index] = allocate (png_get_rowbytes (structure, information));
}
png_read_image (structure, row_pointers);
fclose (file);
data = allocate ((* width) * (* height) * sizeof (* data));
for (index = 0; index < (* height); ++index) {
memory_copy (& data [index * (* width)], row_pointers [index], (* width) * sizeof (* data));
row_pointers [index] = deallocate (row_pointers [index]);
}
row_pointers = deallocate (row_pointers);
png_destroy_read_struct (& structure, & information, null);
return (data);
}
static void png_image_export (const char * path, uint * data, uint width, uint height) {
png_image image = { 0 };
fatal_failure (path == null, "png_image_export: File path is null pointer.");
fatal_failure (data == null, "png_image_export: Data is null pointer.");
fatal_failure (width == 0, "png_image_export: Width is equal to zero.");
fatal_failure (height == 0, "png_image_export: Height is equal to zero.");
image.version = PNG_IMAGE_VERSION;
image.format = PNG_FORMAT_RGBA;
image.width = width;
image.height = height;
png_image_write_to_file (& image, path, 0, data, 0, null);
png_image_free (& image);
}

1136
xtandard.h Executable file
View File

File diff suppressed because it is too large Load Diff

175
xyntax.h Executable file
View File

@ -0,0 +1,175 @@
/// _
/// __ ___ _ _ __ | |_ __ ___ __
/// \ \/ / | | | '_ \| __/ _` \ \/ /
/// > <| |_| | | | | || (_| |> <
/// /_/\_\\__, |_| |_|\__\__,_/_/\_\
/// |___/
///
/// Copyright (c) 1997 - Ognjen 'xolatile' Milan Robovic
///
/// xolatile@chud.cyou - xyntax - Tiny, unsafe and somewhat insane unity header for generic syntax definition.
///
/// This program is free software, free as in freedom and as in free beer, you can redistribute it and/or modify it under the terms of the GNU
/// General Public License as published by the Free Software Foundation, either version 3 of the License, or any later version if you wish...
///
/// This program is distributed in the hope that it will be useful, but it is probably not, and without any warranty, without even the implied
/// warranty of merchantability or fitness for a particular purpose, because it is pointless. Please see the GNU (Geenoo) General Public License
/// for more details, if you dare, it is a lot of text that nobody wants to read...
typedef struct {
uint count;
uint limit;
bool * enrange;
bool * derange;
char * * begin;
char * * end;
char * escape;
uint * colour;
uint * effect;
} syntax_structure;
static syntax_structure * syntax_initialize (uint limit) {
syntax_structure * syntax = allocate (sizeof (* syntax));
syntax->limit = limit;
if (limit != 0) {
syntax->enrange = allocate (syntax->limit * sizeof (* syntax->enrange));
syntax->derange = allocate (syntax->limit * sizeof (* syntax->derange));
syntax->begin = allocate (syntax->limit * sizeof (* syntax->begin));
syntax->end = allocate (syntax->limit * sizeof (* syntax->end));
syntax->escape = allocate (syntax->limit * sizeof (* syntax->escape));
syntax->colour = allocate (syntax->limit * sizeof (* syntax->colour));
syntax->effect = allocate (syntax->limit * sizeof (* syntax->effect));
}
return (syntax);
}
static syntax_structure * syntax_deinitialize (syntax_structure * syntax) {
for (uint index = 0; index < syntax->count; ++index) {
syntax->begin [index] = deallocate (syntax->begin [index]);
syntax->end [index] = deallocate (syntax->end [index]);
}
syntax->enrange = deallocate (syntax->enrange);
syntax->derange = deallocate (syntax->derange);
syntax->begin = deallocate (syntax->begin);
syntax->end = deallocate (syntax->end);
syntax->escape = deallocate (syntax->escape);
syntax->colour = deallocate (syntax->colour);
syntax->effect = deallocate (syntax->effect);
return (deallocate (syntax));
}
static uint syntax_define (syntax_structure * syntax, bool enrange, bool derange, const char * begin, const char * end, char escape,
uint colour, uint effect) {
++syntax->count;
uint current = syntax->count - 1;
fatal_failure (begin == null, "syntax_define: Begin string is null pointer.");
fatal_failure (end == null, "syntax_define: End string is null pointer.");
fatal_failure (syntax->count >= syntax->limit, "syntax_define: Reached the hardcoded limit.");
if (syntax->limit == 0) {
syntax->enrange = reallocate (syntax->enrange, syntax->count * sizeof (* syntax->enrange));
syntax->derange = reallocate (syntax->derange, syntax->count * sizeof (* syntax->derange));
syntax->begin = reallocate (syntax->begin, syntax->count * sizeof (* syntax->begin));
syntax->end = reallocate (syntax->end, syntax->count * sizeof (* syntax->end));
syntax->escape = reallocate (syntax->escape, syntax->count * sizeof (* syntax->escape));
syntax->colour = reallocate (syntax->colour, syntax->count * sizeof (* syntax->colour));
syntax->effect = reallocate (syntax->effect, syntax->count * sizeof (* syntax->effect));
}
syntax->begin [current] = allocate ((string_length (begin) + 1) * sizeof (* * syntax->begin));
syntax->end [current] = allocate ((string_length (end) + 1) * sizeof (* * syntax->end));
syntax->enrange [current] = enrange;
syntax->derange [current] = derange;
syntax->escape [current] = escape;
syntax->colour [current] = colour;
syntax->effect [current] = effect;
string_copy (syntax->begin [current], begin);
string_copy (syntax->end [current], end);
return (current);
}
static uint syntax_select (syntax_structure * syntax, const char * string, uint * length) {
uint offset = 0;
uint subset = 0;
uint select = 0;
ulong begin_length = 0;
ulong end_length = 0;
for (; select != syntax->count; ++select) {
begin_length = string_length (syntax->begin [select]);
if (! syntax->enrange [select]) {
if (! syntax->derange [select]) {
if (string_compare_limit (string, syntax->begin [select], begin_length)) {
break;
}
} else {
if ((string_compare_limit (string, syntax->begin [select], begin_length))
&& (character_compare_array (string [offset + begin_length], syntax->end [select]))) {
break;
}
}
} else {
for (subset = 0; subset != begin_length; ++subset) {
if (string [offset] == syntax->begin [select] [subset]) {
goto selected;
}
}
}
}
selected:
if (select >= syntax->count) {
* length = 1;
return (syntax->count);
}
end_length = string_length (syntax->end [select]);
for (offset = 1; string [offset - 1] != character_null; ++offset) {
if (string [offset] == syntax->escape [select]) {
++offset;
continue;
}
if (syntax->derange [select]) {
subset = 0;
if (end_length == 0) {
break;
} do {
if (string [offset] == syntax->end [select] [subset]) {
* length = offset;
goto finished;
}
} while (++subset != end_length);
} else {
if (end_length != 0) {
if (string_compare_limit (& string [offset], syntax->end [select], end_length)) {
* length = offset + end_length;
return (select);
}
} else {
* length = 1;
return (select);
}
}
}
finished:
return (select);
}