Mirrors/eepp
1
0
Fork 0
mirror of https://github.com/SpartanJ/eepp.git synced 2026-06-04 20:46:29 +03:00
Code Issues Packages Projects Releases Wiki Activity

Minor fixes and improvements in Odin, Lobster, OpenSCAD and SQL syntax language definitions.

Browse Source 
Added YueScript syntax highlighting.
This commit is contained in:
Martín Lucas Golini
2025-02-23 11:29:28 -03:00
parent 173f976d21
commit a7c389a042
10 changed files with 285 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/eepp/ui/doc/syntaxdefinitionmanager.cpp
View File

@@ -205,8 +205,7 @@ namespace EE { namespace UI { namespace Doc { namespace Language {
buf += "{ " + join( pattern.patterns ) + ", " + join( pattern.typesNames, true, true ) +
str( pattern.syntax, ", ", "", false );
if ( pattern.isRegEx )
buf += ", "
", true";
buf += ", \"\", true";
buf += " },\n";
}
buf += "\n},\n";

41
src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/lobster.cpp
View File

@@ -5,7 +5,7 @@ namespace EE { namespace UI { namespace Doc { namespace Language {
void addLobster() {
auto& sd = SyntaxDefinitionManager::instance()->add(
SyntaxDefinitionManager::instance()->add(
{ "Lobster",
{ "%.lobster$" },
@@ -14,14 +14,14 @@ void addLobster() {
{ { "/%*", "%*/" }, "comment" },
{ { "(struct%s)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } },
{ { "(class%s)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } },
{ { "import%s+from" }, "keyword" },
{ { "[%w_]+%s*%f[{]" }, "keyword2" },
{ { "\"", "\"", "\\" }, "string" },
{ { "'", "'", "\\" }, "string" },
{ { "\"\"\"", "\"\"\"" }, "string" },
{ { "0x%x+" }, "number" },
{ { "%d+[%d%.eE]*f?" }, "number" },
{ { "%.?%d+f?" }, "number" },
{ { "[%+%-=/%*%^%%<>!~|&]" }, "operator" },
{ { "[%+%-=/%*%^%%<>!~|&%?]" }, "operator" },
{ { "[%a_][%w_]*%f[(]" }, "function" },
{ { "[%a_][%w_]*" }, "symbol" },
{ { "%s+" }, "normal" },
@@ -29,25 +29,34 @@ void addLobster() {
},
{
{ "int", "keyword2" }, { "and", "operator" }, { "private", "keyword" },
{ "default", "keyword" }, { "switch", "keyword" }, { "pakfile", "keyword" },
{ "return", "keyword" }, { "var", "keyword" }, { "import", "keyword" },
{ "namespace", "keyword" }, { "void", "keyword2" }, { "any", "keyword2" },
{ "typeof", "keyword" }, { "enum_flags", "keyword" }, { "for", "keyword" },
{ "while", "keyword" }, { "def", "keyword" }, { "else", "keyword" },
{ "enum", "keyword" }, { "nil", "literal" }, { "not", "operator" },
{ "float", "keyword2" }, { "is", "keyword" }, { "fn", "keyword" },
{ "string", "keyword2" }, { "or", "operator" }, { "case", "keyword" },
{ "if", "keyword" }, { "resource", "keyword" }, { "let", "keyword" },
{ "program", "keyword" },
{ "int", "keyword2" }, { "and", "keyword" },
{ "private", "keyword" }, { "default", "keyword" },
{ "abstract", "keyword" }, { "static_frame", "keyword" },
{ "switch", "keyword" }, { "guard", "keyword" },
{ "pakfile", "keyword" }, { "attribute", "keyword" },
{ "return", "keyword" }, { "var", "keyword" },
{ "import", "keyword" }, { "class", "keyword" },
{ "namespace", "keyword" }, { "void", "keyword2" },
{ "static", "keyword" }, { "any", "keyword2" },
{ "typeof", "keyword" }, { "enum_flags", "keyword" },
{ "super", "keyword" }, { "member", "keyword" },
{ "for", "keyword" }, { "while", "keyword" },
{ "from", "keyword" }, { "member_frame", "keyword" },
{ "def", "keyword" }, { "else", "keyword" },
{ "constructor", "keyword" }, { "enum", "keyword" },
{ "operator", "keyword" }, { "nil", "literal" },
{ "not", "keyword" }, { "float", "keyword2" },
{ "struct", "keyword" }, { "is", "keyword" },
{ "fn", "keyword" }, { "string", "keyword2" },
{ "or", "keyword" }, { "case", "keyword" },
{ "if", "keyword" }, { "resource", "keyword" },
{ "let", "keyword" }, { "program", "keyword" },
},
"//",
{}
} );
sd.setFoldRangeType( FoldRangeType::Indentation );
}
}}}} // namespace EE::UI::Doc::Language

239
src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.cpp
View File

@@ -5,7 +5,7 @@ namespace EE { namespace UI { namespace Doc { namespace Language {
void addOdin() {
auto& sd = SyntaxDefinitionManager::instance()->add(
SyntaxDefinitionManager::instance()->add(
{ "Odin",
{ "%.odin$" },
@@ -20,138 +20,149 @@ void addOdin() {
{ { "0[dz][%d_]+" }, "number" },
{ { "0x[%da-fA-F_]+" }, "number" },
{ { "-?%d+[%d%._e]*i?" }, "number" },
{ { "([%a_][%w_]+)(%s+::%s+)(proc%s*)%f[(]" },
{ "normal", "function", "operator", "keyword" } },
{ { "([%a_][%w_]+)(%s+::%s+)%f[(]" }, { "normal", "function", "operator" } },
{ { "([%a_][%w_]+)(%s+::%s+)(struct%s*)%f[{]" },
{ "normal", "keyword2", "operator", "keyword" } },
{ { "([%a_][%w_]+)(%s+::%s+)(enum%s*)(%w+%s*)%f[{]" },
{ "normal", "keyword2", "operator", "keyword", "keyword2" } },
{ { "[<>~=+-*/]=" }, "operator" },
{ { "[%+%-=/%*%^%%<>!~|&:]" }, "operator" },
{ { "%.%." }, "operator" },
{ { "[%+%-=/%*%^%%<>!~|&:%?]" }, "operator" },
{ { "%$[%a_][%w_]*" }, "operator" },
{ { "[%a_][%w_]*%f[(]" }, "function" },
{ { "[#@][%a_][%w_]*" }, "keyword2" },
{ { "[#@]%b()" }, "keyword2" },
{ { "[%a_][%w_]*" }, "symbol" },
{ { "%s+" }, "normal" },
{ { "%w+%f[%s]" }, "normal" },
},
{
{ "typeid", "keyword2" },
{ "i64be", "keyword2" },
{ "conj", "keyword2" },
{ "i32le", "keyword2" },
{ "rawptr", "keyword2" },
{ "real", "keyword2" },
{ "typeid_of", "keyword2" },
{ "type_info_of", "keyword2" },
{ "offset_of", "keyword2" },
{ "i64le", "keyword2" },
{ "align_of", "keyword2" },
{ "f32", "keyword2" },
{ "min", "keyword2" },
{ "u64", "keyword2" },
{ "cap", "keyword2" },
{ "cstring", "keyword2" },
{ "len", "keyword2" },
{ "byte", "keyword2" },
{ "transmute", "keyword2" },
{ "proc", "keyword" },
{ "any", "keyword2" },
{ "clamp", "keyword2" },
{ "auto_cast", "keyword2" },
{ "uintptr", "keyword2" },
{ "u16le", "keyword2" },
{ "complex", "keyword2" },
{ "const", "keyword" },
{ "union", "keyword" },
{ "u32", "keyword2" },
{ "opaque", "keyword" },
{ "type_info_base", "keyword2" },
{ "defer", "keyword" },
{ "max", "keyword2" },
{ "do", "keyword" },
{ "for", "keyword" },
{ "macro", "keyword" },
{ "package", "keyword" },
{ "bit_set", "keyword" },
{ "switch", "keyword" },
{ "no_inline", "keyword" },
{ "quaternion256", "keyword2" },
{ "if", "keyword" },
{ "case", "keyword" },
{ "foreign", "keyword" },
{ "not_in", "keyword" },
{ "inline", "keyword" },
{ "import", "keyword" },
{ "u8", "keyword2" },
{ "nil", "literal" },
{ "i16", "keyword2" },
{ "swizzle", "keyword2" },
{ "u16", "keyword2" },
{ "false", "literal" },
{ "f16", "keyword2" },
{ "distinct", "keyword" },
{ "rune", "keyword2" },
{ "i16le", "keyword2" },
{ "b64", "keyword2" },
{ "i128le", "keyword2" },
{ "quaternion128", "keyword2" },
{ "u16be", "keyword2" },
{ "i32be", "keyword2" },
{ "u128be", "keyword2" },
{ "i16be", "keyword2" },
{ "u32be", "keyword2" },
{ "complex64", "keyword2" },
{ "b8", "keyword2" },
{ "b32", "keyword2" },
{ "i32", "keyword2" },
{ "assert", "keyword2" },
{ "complex128", "keyword2" },
{ "complex32", "keyword2" },
{ "return", "keyword" },
{ "u128", "keyword2" },
{ "b128", "keyword2" },
{ "i128be", "keyword2" },
{ "i8", "keyword2" },
{ "int", "keyword2" },
{ "i64", "keyword2" },
{ "bool", "keyword2" },
{ "imag", "keyword2" },
{ "u64be", "keyword2" },
{ "true", "literal" },
{ "context", "keyword" },
{ "dynamic", "keyword" },
{ "string", "keyword2" },
{ "i128", "keyword2" },
{ "when", "keyword" },
{ "u32le", "keyword2" },
{ "i32le", "keyword2" },
{ "bit_set", "keyword" },
{ "len", "keyword2" },
{ "not_in", "keyword" },
{ "f16be", "keyword2" },
{ "uintptr", "keyword2" },
{ "offset_of", "keyword2" },
{ "min", "keyword2" },
{ "i64be", "keyword2" },
{ "size_of", "keyword2" },
{ "u64le", "keyword2" },
{ "type_of", "keyword2" },
{ "using", "keyword" },
{ "map", "keyword" },
{ "uint", "keyword2" },
{ "struct", "keyword" },
{ "cast", "keyword2" },
{ "enum", "keyword" },
{ "abs", "keyword2" },
{ "i64le", "keyword2" },
{ "any", "keyword2" },
{ "i64", "keyword2" },
{ "cap", "keyword2" },
{ "or_return", "keyword" },
{ "for", "keyword" },
{ "u64", "keyword2" },
{ "jmag", "keyword2" },
{ "context", "keyword" },
{ "f64", "keyword2" },
{ "u128le", "keyword2" },
{ "continue", "keyword" },
{ "fallthrough", "keyword" },
{ "in", "keyword" },
{ "swizzle", "keyword2" },
{ "enum", "keyword" },
{ "u16be", "keyword2" },
{ "when", "keyword" },
{ "break", "keyword" },
{ "else", "keyword" },
{ "or_break", "keyword" },
{ "f64be", "keyword2" },
{ "f64le", "keyword2" },
{ "type_info_base", "keyword2" },
{ "cstring", "keyword2" },
{ "u32be", "keyword2" },
{ "b64", "keyword2" },
{ "i32be", "keyword2" },
{ "clamp", "keyword2" },
{ "u16le", "keyword2" },
{ "i16be", "keyword2" },
{ "b16", "keyword2" },
{ "dynamic", "keyword" },
{ "or_continue", "keyword" },
{ "map", "keyword" },
{ "b32", "keyword2" },
{ "transmute", "keyword2" },
{ "byte", "keyword2" },
{ "type_of", "keyword2" },
{ "defer", "keyword" },
{ "quaternion", "keyword2" },
{ "assert", "keyword2" },
{ "true", "literal" },
{ "soa_unzip", "keyword2" },
{ "f16le", "keyword2" },
{ "kmag", "keyword2" },
{ "real", "keyword2" },
{ "offset_of_selector", "keyword2" },
{ "f32le", "keyword2" },
{ "case", "keyword" },
{ "cast", "keyword2" },
{ "distinct", "keyword" },
{ "do", "keyword" },
{ "quaternion128", "keyword2" },
{ "continue", "keyword" },
{ "asm", "keyword" },
{ "i128be", "keyword2" },
{ "i16", "keyword2" },
{ "quaternion256", "keyword2" },
{ "expand_values", "keyword2" },
{ "bool", "keyword2" },
{ "u64le", "keyword2" },
{ "i16le", "keyword2" },
{ "i8", "keyword2" },
{ "u32", "keyword2" },
{ "or_else", "keyword" },
{ "union", "keyword" },
{ "rawptr", "keyword2" },
{ "u128be", "keyword2" },
{ "complex", "keyword2" },
{ "i128le", "keyword2" },
{ "b8", "keyword2" },
{ "conj", "keyword2" },
{ "false", "literal" },
{ "b128", "keyword2" },
{ "type_info_of", "keyword2" },
{ "else", "keyword" },
{ "foreign", "keyword" },
{ "u128le", "keyword2" },
{ "typeid_of", "keyword2" },
{ "align_of", "keyword2" },
{ "u64be", "keyword2" },
{ "auto_cast", "keyword2" },
{ "struct", "keyword" },
{ "quaternion64", "keyword2" },
{ "soa_zip", "keyword2" },
{ "string", "keyword2" },
{ "complex32", "keyword2" },
{ "if", "keyword" },
{ "raw_data", "keyword2" },
{ "in", "keyword" },
{ "f32", "keyword2" },
{ "i32", "keyword2" },
{ "switch", "keyword" },
{ "using", "keyword" },
{ "offset_of_by_string", "keyword2" },
{ "typeid", "keyword2" },
{ "offset_of_member", "keyword2" },
{ "return", "keyword" },
{ "f16", "keyword2" },
{ "u8", "keyword2" },
{ "import", "keyword" },
{ "max", "keyword2" },
{ "imag", "keyword2" },
{ "proc", "keyword" },
{ "complex128", "keyword2" },
{ "uint", "keyword2" },
{ "or_break", "keyword" },
{ "complex64", "keyword2" },
{ "i128", "keyword2" },
{ "abs", "keyword2" },
{ "package", "keyword" },
{ "nil", "literal" },
{ "rune", "keyword2" },
{ "u128", "keyword2" },
{ "fallthrough", "keyword" },
{ "f32be", "keyword2" },
{ "u16", "keyword2" },
{ "u32le", "keyword2" },
},
"//",
{}
} );
sd.setFoldRangeType( FoldRangeType::Braces ).setFoldBraces( { { '{', '}' } } );
}
}}}} // namespace EE::UI::Doc::Language

2
src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.hpp
View File

@@ -5,6 +5,6 @@ namespace EE { namespace UI { namespace Doc { namespace Language {
extern void addOdin();
}}}}
}}}} // namespace EE::UI::Doc::Language
#endif

1
src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/openscad.cpp
View File

@@ -65,6 +65,7 @@ void addOpenSCAD() {
{ "hull", "keyword" },
{ "is_bool", "function" },
{ "version_num", "function" },
{ "parent_module", "function" },
{ "scale", "keyword" },
{ "atan2", "keyword" },
{ "intersection", "keyword" },

1
src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/sql.cpp
View File

@@ -352,6 +352,7 @@ void addSQL() {
{ "UUID", "keyword2" },
{ "at", "keyword" },
{ "HAVING", "keyword" },
{ "ADD", "keyword" },
{ "from", "keyword" },
{ "insert", "keyword" },
{ "table", "keyword" },

118
src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/yuescript.cpp Normal file
View File

@@ -0,0 +1,118 @@
#include <eepp/ui/doc/languages/yuescript.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addYueScript() {
SyntaxDefinitionManager::instance()
->add(
{ "YueScriptStringInterpolation",
{},
{
{ { "#{", "}", "\\" }, "keyword", "YueScript" },
{ { "[^ ]" }, "string" },
{ { "%s+" }, "normal" },
{ { "%w+%f[%s]" }, "normal" },
},
{
},
"",
{}
} )
.setVisible( false );
SyntaxDefinitionManager::instance()->add(
{ "YueScript",
{ "%.yue$" },
{
{ { "%-%-%[%[", "%]%]" }, "comment" },
{ { "%-%-.*\n" }, "comment" },
{ { "#!.*\n" }, "comment" },
{ { "%u[%w_]*" }, "keyword2" },
{ { "(<)(%s*close)" }, { "normal", "operator", "normal" } },
{ { "close" }, "keyword" },
{ { "(macro%s+)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } },
{ { "(class%s+)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } },
{ { "([%a_][%w_]*)(%s*%f[%(@\"'{#])" }, { "normal", "function", "normal" } },
{ { "([a-zA-Z_][\\w_]*)(\\s+(?:try|default|do|export|switch|and|while|unless|global|"
"catch|until|goto|in|or|when|with|extends|for|from|then|as|return|macro|const|"
"local|class|if|else|elseif|repeat|continue|break|using|import)\\s+)" },
{ "normal", "normal", "keyword" },
"",
true },
{ { "([%a_][%w_]*)(%s+not%s+in)" }, { "normal", "normal", "keyword" } },
{ { "([%a_][%w_]*)(%s+%f[%[%$%a_])" }, { "normal", "function", "normal" } },
{ { "(|>%s*)([%a_][%.%w_]*%.%s*)([%a_][%w_]*)" },
{ "normal", "operator", "normal", "function" } },
{ { "(|>%s*)([%a_][%w_]*)" }, { "normal", "operator", "function" } },
{ { "([a-zA-Z_]\\w*\\s+)(\\-?0x[\\da-fA-F](?:_?[\\da-fA-F])*(?:\\.[\\da-fA-F](?:_?["
"\\da-fA-F])*)?)" },
{ "normal", "function", "number" },
"",
true },
{ { "([a-zA-Z_]\\w*\\s+)(\\-?\\.\\d(?:_?\\d)*(?:[eE][\\+\\-]?\\d(?:_?\\d)*)?)" },
{ "normal", "function", "number" },
"",
true },
{ { "([a-zA-Z_]\\w*\\s+)(\\-?(?:\\d(?:_?\\d)*)(?:(?:\\.\\d(?:_?\\d)*(?:[eE][\\+\\-]?"
"\\d(?:_?\\d)*)?)|[eE][\\+\\-]?\\d(?:_?\\d)*)?)" },
{ "normal", "function", "number" },
"",
true },
{ { "([%a_][%w_]*)(%??%s*!=)" }, { "normal", "normal", "operator" } },
{ { "([%a_][%w_]*)(%??%s*!)" }, { "normal", "function", "operator" } },
{ { "(::)([%a_][%w_]*)(::)" }, { "normal", "operator", "keyword2", "operator" } },
{ { "(::)([%a_][%w_]*)" }, { "normal", "operator", "function" } },
{ { "(\\)([%a_][%w_]*)" }, { "normal", "operator", "function" } },
{ { "\\-?0x[\\da-fA-F](?:_?[\\da-fA-F])*(?:\\.[\\da-fA-F](?:_?[\\da-fA-F])*)?" },
"number",
"",
true },
{ { "\\-?\\.\\d(?:_?\\d)*(?:[eE][\\+\\-]?\\d(?:_?\\d)*)?" }, "number", "", true },
{ { "\\-?(?:\\d(?:_?\\d)*)(?:(?:\\.\\d(?:_?\\d)*(?:[eE][\\+\\-]?\\d(?:_?\\d)*)?)|[eE]"
"[\\+\\-]?\\d(?:_?\\d)*)?" },
"number",
"",
true },
{ { "@@?[%w_]*" }, "keyword2" },
{ { "$[%w_]+" }, "keyword2" },
{ { "[%a_][%w_]*" }, "symbol" },
{ { "\"", "\"", "\\" }, "string", "YueScriptStringInterpolation" },
{ { "'", "'", "\\" }, "string" },
{ { "%[=*%[", "%]=*%]" }, "string" },
{ { "[&<>%+-%*/=#%[%]!|?:~%%%.%^]+" }, "operator" },
{ { "\\" }, "operator" },
{ { "%s+" }, "normal" },
{ { "%w+%f[%s]" }, "normal" },
},
{
{ "elseif", "keyword" }, { "in", "keyword" }, { "then", "keyword" },
{ "and", "keyword" }, { "continue", "keyword" }, { "macro", "keyword" },
{ "default", "keyword" }, { "unless", "keyword" }, { "switch", "keyword" },
{ "using", "keyword" }, { "return", "keyword" }, { "import", "keyword" },
{ "try", "keyword" }, { "as", "keyword" }, { "class", "keyword" },
{ "repeat", "keyword" }, { "super", "keyword2" }, { "extends", "keyword" },
{ "with", "keyword" }, { "false", "literal" }, { "for", "keyword" },
{ "goto", "keyword" }, { "while", "keyword" }, { "const", "keyword" },
{ "from", "keyword" }, { "self", "keyword2" }, { "catch", "keyword" },
{ "true", "literal" }, { "else", "keyword" }, { "global", "keyword" },
{ "nil", "literal" }, { "not", "keyword" }, { "when", "keyword" },
{ "local", "keyword" }, { "break", "keyword" }, { "or", "keyword" },
{ "until", "keyword" }, { "if", "keyword" }, { "export", "keyword" },
{ "do", "keyword" },
},
"--",
{}
} );
}
}}}} // namespace EE::UI::Doc::Language

10
src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/yuescript.hpp Normal file
View File

@@ -0,0 +1,10 @@
#ifndef EE_UI_DOC_YueScript
#define EE_UI_DOC_YueScript
namespace EE { namespace UI { namespace Doc { namespace Language {
extern void addYueScript();
}}}} // namespace EE::UI::Doc::Language
#endif

2
src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languagessyntaxhighlighting.cpp
View File

@@ -84,6 +84,7 @@
#include <eepp/ui/doc/languages/xit.hpp>
#include <eepp/ui/doc/languages/xtend.hpp>
#include <eepp/ui/doc/languages/yaml.hpp>
#include <eepp/ui/doc/languages/yuescript.hpp>
#include <eepp/ui/doc/languages/zig.hpp>
#include <eepp/ui/doc/languagessyntaxhighlighting.hpp>
@@ -176,6 +177,7 @@ void LanguagesSyntaxHighlighting::load() {
addXit();
addXtend();
addYAML();
addYueScript();
addZig();
}

2
src/tools/ecode/ecode.cpp
View File

@@ -3488,7 +3488,7 @@ void App::init( const LogLevel& logLevel, std::string file, const Float& pidelDe
mThreadPool->run( [this] {
// Load language definitions
Clock defClock;
SyntaxDefinitionManager::createSingleton( 105 );
SyntaxDefinitionManager::createSingleton( 107 );
Language::LanguagesSyntaxHighlighting::load();
SyntaxDefinitionManager::instance()->setLanguageExtensionsPriority(
mConfig.languagesExtensions.priorities );