From a7c389a042f613c8fef3c1089a8e872148c33641 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mart=C3=ADn=20Lucas=20Golini?= Date: Sun, 23 Feb 2025 11:29:28 -0300 Subject: [PATCH] Minor fixes and improvements in Odin, Lobster, OpenSCAD and SQL syntax language definitions. Added YueScript syntax highlighting. --- src/eepp/ui/doc/syntaxdefinitionmanager.cpp | 3 +- .../src/eepp/ui/doc/languages/lobster.cpp | 41 +-- .../src/eepp/ui/doc/languages/odin.cpp | 239 +++++++++--------- .../src/eepp/ui/doc/languages/odin.hpp | 2 +- .../src/eepp/ui/doc/languages/openscad.cpp | 1 + .../src/eepp/ui/doc/languages/sql.cpp | 1 + .../src/eepp/ui/doc/languages/yuescript.cpp | 118 +++++++++ .../src/eepp/ui/doc/languages/yuescript.hpp | 10 + .../ui/doc/languagessyntaxhighlighting.cpp | 2 + src/tools/ecode/ecode.cpp | 2 +- 10 files changed, 285 insertions(+), 134 deletions(-) create mode 100644 src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/yuescript.cpp create mode 100644 src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/yuescript.hpp diff --git a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp index 73becc639..c6917d85f 100644 --- a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp +++ b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp @@ -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"; diff --git a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/lobster.cpp b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/lobster.cpp index 85ae69189..d3e8398a4 100644 --- a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/lobster.cpp +++ b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/lobster.cpp @@ -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 diff --git a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.cpp b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.cpp index d81e8a892..df2556667 100644 --- a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.cpp +++ b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.cpp @@ -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 diff --git a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.hpp b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.hpp index 62b431aa4..c24cab814 100644 --- a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.hpp +++ b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/odin.hpp @@ -5,6 +5,6 @@ namespace EE { namespace UI { namespace Doc { namespace Language { extern void addOdin(); -}}}} +}}}} // namespace EE::UI::Doc::Language #endif diff --git a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/openscad.cpp b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/openscad.cpp index 553c3aee2..26c849ef0 100644 --- a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/openscad.cpp +++ b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/openscad.cpp @@ -65,6 +65,7 @@ void addOpenSCAD() { { "hull", "keyword" }, { "is_bool", "function" }, { "version_num", "function" }, + { "parent_module", "function" }, { "scale", "keyword" }, { "atan2", "keyword" }, { "intersection", "keyword" }, diff --git a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/sql.cpp b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/sql.cpp index bc96e5a1a..9a84a559f 100644 --- a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/sql.cpp +++ b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/sql.cpp @@ -352,6 +352,7 @@ void addSQL() { { "UUID", "keyword2" }, { "at", "keyword" }, { "HAVING", "keyword" }, + { "ADD", "keyword" }, { "from", "keyword" }, { "insert", "keyword" }, { "table", "keyword" }, diff --git a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/yuescript.cpp b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/yuescript.cpp new file mode 100644 index 000000000..de1094745 --- /dev/null +++ b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/yuescript.cpp @@ -0,0 +1,118 @@ +#include +#include + +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 diff --git a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/yuescript.hpp b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/yuescript.hpp new file mode 100644 index 000000000..f4dd40436 --- /dev/null +++ b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/yuescript.hpp @@ -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 diff --git a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languagessyntaxhighlighting.cpp b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languagessyntaxhighlighting.cpp index 78c331bd2..1767f6f1b 100644 --- a/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languagessyntaxhighlighting.cpp +++ b/src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languagessyntaxhighlighting.cpp @@ -84,6 +84,7 @@ #include #include #include +#include #include #include @@ -176,6 +177,7 @@ void LanguagesSyntaxHighlighting::load() { addXit(); addXtend(); addYAML(); + addYueScript(); addZig(); } diff --git a/src/tools/ecode/ecode.cpp b/src/tools/ecode/ecode.cpp index 9383b83d1..9ef2e656e 100644 --- a/src/tools/ecode/ecode.cpp +++ b/src/tools/ecode/ecode.cpp @@ -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 );