xolatile/xarbon
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
6c099626ad
xarbon/xanguage.h
xolatile 6c099626ad Static...
2025-04-06 19:32:31 +02:00

202 lines
8.3 KiB
C
Executable File
Raw Blame History

/// __ ____ _ _ __ __ _ _ _ __ _ __ _ ___
/// \ \/ / _` | '_ \ / _` | | | |/ _` |/ _` |/ _ \
/// > < (_| | | | | (_| | |_| | (_| | (_| | __/
/// /_/\_\__,_|_| |_|\__, |\__,_|\__,_|\__, |\___|
/// |___/ |___/
///
/// 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);
}
}
}
Reference in New Issue View Git Blame Copy Permalink