Static...
This commit is contained in:
parent
c178371655
commit
6c099626ad
@ -1,3 +1,6 @@
|
||||
# xarbon
|
||||
|
||||
Static version of Xarbon...
|
||||
Static version of Xarbon...
|
||||
|
||||
Compile: `sh compile.sh`
|
||||
Install: `sudo sh install.sh`
|
||||
|
||||
7
compile.sh
Executable file
7
compile.sh
Executable 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
7
install.sh
Executable file
@ -0,0 +1,7 @@
|
||||
#!/bin/bash
|
||||
|
||||
set -xe
|
||||
|
||||
cp -f xarbon /usr/local/bin/xarbon
|
||||
|
||||
exit
|
||||
201
xanguage.h
Executable file
201
xanguage.h
Executable 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
31
xanguage/ada.h
Executable 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
24
xanguage/bash.h
Executable 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
53
xanguage/c++.h
Executable 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
49
xanguage/c.h
Executable 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
9
xanguage/common.h
Executable 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
49
xanguage/d.h
Executable 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
79
xanguage/eaxhla.h
Executable 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
66
xanguage/flat.h
Executable 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
47
xanguage/fortran.h
Executable 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
46
xanguage/go.h
Executable 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
34
xanguage/haskell.h
Executable 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
50
xanguage/lua.h
Executable 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
29
xanguage/pascal.h
Executable 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
47
xanguage/python.h
Executable 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
25
xanguage/valgrind.h
Executable 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);
|
||||
}
|
||||
276
xarbon.c
Executable file
276
xarbon.c
Executable 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
122
xormat.h
Normal 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
68
xormat/jxl.h
Normal 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
6
xormat/ply.h
Normal file
@ -0,0 +1,6 @@
|
||||
|
||||
#ifndef use_ply_library
|
||||
#define use_ply_library
|
||||
#endif
|
||||
|
||||
|
||||
106
xormat/png.h
Normal file
106
xormat/png.h
Normal 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
1136
xtandard.h
Executable file
File diff suppressed because it is too large
Load Diff
175
xyntax.h
Executable file
175
xyntax.h
Executable 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);
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user