diff --git a/projects/linux/ee.creator.user b/projects/linux/ee.creator.user index b6fac7308..c3be696b6 100644 --- a/projects/linux/ee.creator.user +++ b/projects/linux/ee.creator.user @@ -1,6 +1,6 @@ - + EnvironmentId @@ -114,7 +114,7 @@ Desktop Desktop {388e5431-b31b-42b3-b9ad-9002d279d75d} - 10 + 11 0 19 diff --git a/projects/linux/ee.files b/projects/linux/ee.files index 7eac524e5..96367a1cc 100644 --- a/projects/linux/ee.files +++ b/projects/linux/ee.files @@ -866,6 +866,10 @@ ../../src/eepp/ui/doc/languages/batchscript.hpp ../../src/eepp/ui/doc/languages/blueprint.cpp ../../src/eepp/ui/doc/languages/blueprint.hpp +../../src/eepp/ui/doc/languages/c.cpp +../../src/eepp/ui/doc/languages/c.hpp +../../src/eepp/ui/doc/languages/cpp.cpp +../../src/eepp/ui/doc/languages/cpp.hpp ../../src/eepp/ui/doc/languages/crystal.hpp ../../src/eepp/ui/doc/languages/css.hpp ../../src/eepp/ui/doc/languages/d.hpp @@ -878,6 +882,10 @@ ../../src/eepp/ui/doc/languages/hare.hpp ../../src/eepp/ui/doc/languages/hlsl.cpp ../../src/eepp/ui/doc/languages/htaccess.cpp +../../src/eepp/ui/doc/languages/javascript.cpp +../../src/eepp/ui/doc/languages/javascript.hpp +../../src/eepp/ui/doc/languages/json.cpp +../../src/eepp/ui/doc/languages/json.hpp ../../src/eepp/ui/doc/languages/objeck.cpp ../../src/eepp/ui/doc/languages/pascal.cpp ../../src/eepp/ui/doc/languages/pico-8.cpp @@ -912,44 +920,84 @@ ../../src/eepp/ui/css/stylesheetvariable.cpp ../../src/eepp/ui/css/timingfunction.cpp ../../src/eepp/ui/css/transitiondefinition.cpp +../../src/eepp/ui/doc/languages/cmake.cpp +../../src/eepp/ui/doc/languages/cmake.hpp +../../src/eepp/ui/doc/languages/configfile.cpp +../../src/eepp/ui/doc/languages/configfile.hpp +../../src/eepp/ui/doc/languages/containerfile.cpp +../../src/eepp/ui/doc/languages/containerfile.hpp ../../src/eepp/ui/doc/languages/crystal.cpp +../../src/eepp/ui/doc/languages/csharp.cpp +../../src/eepp/ui/doc/languages/csharp.hpp ../../src/eepp/ui/doc/languages/css.cpp ../../src/eepp/ui/doc/languages/d.cpp +../../src/eepp/ui/doc/languages/dart.cpp +../../src/eepp/ui/doc/languages/dart.hpp +../../src/eepp/ui/doc/languages/difffile.cpp +../../src/eepp/ui/doc/languages/difffile.hpp ../../src/eepp/ui/doc/languages/elixir.cpp ../../src/eepp/ui/doc/languages/elm.cpp +../../src/eepp/ui/doc/languages/environmentfile.cpp +../../src/eepp/ui/doc/languages/environmentfile.hpp ../../src/eepp/ui/doc/languages/fstab.cpp ../../src/eepp/ui/doc/languages/glsl.cpp ../../src/eepp/ui/doc/languages/glsl.hpp +../../src/eepp/ui/doc/languages/go.cpp +../../src/eepp/ui/doc/languages/go.hpp ../../src/eepp/ui/doc/languages/graphql.cpp ../../src/eepp/ui/doc/languages/hare.cpp +../../src/eepp/ui/doc/languages/haskell.cpp +../../src/eepp/ui/doc/languages/haskell.hpp +../../src/eepp/ui/doc/languages/haxe.cpp +../../src/eepp/ui/doc/languages/haxe.hpp ../../src/eepp/ui/doc/languages/hlsl.cpp ../../src/eepp/ui/doc/languages/hlsl.hpp ../../src/eepp/ui/doc/languages/htaccess.cpp ../../src/eepp/ui/doc/languages/htaccess.hpp ../../src/eepp/ui/doc/languages/html.cpp ../../src/eepp/ui/doc/languages/html.hpp +../../src/eepp/ui/doc/languages/ignorefile.cpp +../../src/eepp/ui/doc/languages/ignorefile.hpp ../../src/eepp/ui/doc/languages/jai.cpp ../../src/eepp/ui/doc/languages/jai.hpp +../../src/eepp/ui/doc/languages/java.cpp +../../src/eepp/ui/doc/languages/java.hpp +../../src/eepp/ui/doc/languages/jsx.cpp +../../src/eepp/ui/doc/languages/jsx.hpp ../../src/eepp/ui/doc/languages/julia.cpp ../../src/eepp/ui/doc/languages/julia.hpp ../../src/eepp/ui/doc/languages/kotlin.cpp ../../src/eepp/ui/doc/languages/kotlin.hpp +../../src/eepp/ui/doc/languages/latex.cpp +../../src/eepp/ui/doc/languages/latex.hpp ../../src/eepp/ui/doc/languages/lobster.cpp ../../src/eepp/ui/doc/languages/lobster.hpp +../../src/eepp/ui/doc/languages/lua.cpp +../../src/eepp/ui/doc/languages/lua.hpp +../../src/eepp/ui/doc/languages/makefile.cpp +../../src/eepp/ui/doc/languages/makefile.hpp ../../src/eepp/ui/doc/languages/markdown.cpp ../../src/eepp/ui/doc/languages/markdown.hpp +../../src/eepp/ui/doc/languages/meson.cpp +../../src/eepp/ui/doc/languages/meson.hpp ../../src/eepp/ui/doc/languages/moonscript.cpp ../../src/eepp/ui/doc/languages/moonscript.hpp ../../src/eepp/ui/doc/languages/nelua.cpp ../../src/eepp/ui/doc/languages/nelua.hpp +../../src/eepp/ui/doc/languages/nim.cpp +../../src/eepp/ui/doc/languages/nim.hpp ../../src/eepp/ui/doc/languages/objeck.cpp ../../src/eepp/ui/doc/languages/objeck.hpp +../../src/eepp/ui/doc/languages/objective-c.cpp +../../src/eepp/ui/doc/languages/objective-c.hpp ../../src/eepp/ui/doc/languages/odin.cpp ../../src/eepp/ui/doc/languages/odin.hpp ../../src/eepp/ui/doc/languages/pascal.cpp ../../src/eepp/ui/doc/languages/pascal.hpp ../../src/eepp/ui/doc/languages/perl.cpp ../../src/eepp/ui/doc/languages/perl.hpp +../../src/eepp/ui/doc/languages/php.cpp +../../src/eepp/ui/doc/languages/php.hpp ../../src/eepp/ui/doc/languages/pico-8.cpp ../../src/eepp/ui/doc/languages/pico-8.hpp ../../src/eepp/ui/doc/languages/po.cpp @@ -958,12 +1006,22 @@ ../../src/eepp/ui/doc/languages/pony.hpp ../../src/eepp/ui/doc/languages/postgresql.cpp ../../src/eepp/ui/doc/languages/postgresql.hpp +../../src/eepp/ui/doc/languages/powershell.cpp +../../src/eepp/ui/doc/languages/powershell.hpp +../../src/eepp/ui/doc/languages/python.cpp +../../src/eepp/ui/doc/languages/python.hpp ../../src/eepp/ui/doc/languages/r.cpp ../../src/eepp/ui/doc/languages/r.hpp +../../src/eepp/ui/doc/languages/ruby.cpp +../../src/eepp/ui/doc/languages/ruby.hpp ../../src/eepp/ui/doc/languages/rust.cpp ../../src/eepp/ui/doc/languages/rust.hpp ../../src/eepp/ui/doc/languages/sass.cpp ../../src/eepp/ui/doc/languages/sass.hpp +../../src/eepp/ui/doc/languages/scala.cpp +../../src/eepp/ui/doc/languages/scala.hpp +../../src/eepp/ui/doc/languages/shellscript.cpp +../../src/eepp/ui/doc/languages/shellscript.hpp ../../src/eepp/ui/doc/languages/solidity.cpp ../../src/eepp/ui/doc/languages/solidity.hpp ../../src/eepp/ui/doc/languages/sql.cpp @@ -974,16 +1032,26 @@ ../../src/eepp/ui/doc/languages/teal.hpp ../../src/eepp/ui/doc/languages/toml.cpp ../../src/eepp/ui/doc/languages/toml.hpp +../../src/eepp/ui/doc/languages/typescript.cpp +../../src/eepp/ui/doc/languages/typescript.hpp ../../src/eepp/ui/doc/languages/v.cpp ../../src/eepp/ui/doc/languages/v.hpp ../../src/eepp/ui/doc/languages/vb.cpp ../../src/eepp/ui/doc/languages/vb.hpp ../../src/eepp/ui/doc/languages/verilog.cpp ../../src/eepp/ui/doc/languages/verilog.hpp +../../src/eepp/ui/doc/languages/vue.cpp +../../src/eepp/ui/doc/languages/vue.hpp +../../src/eepp/ui/doc/languages/wren.cpp +../../src/eepp/ui/doc/languages/wren.hpp ../../src/eepp/ui/doc/languages/x86assembly.cpp ../../src/eepp/ui/doc/languages/x86assembly.hpp +../../src/eepp/ui/doc/languages/xit.cpp +../../src/eepp/ui/doc/languages/xit.hpp ../../src/eepp/ui/doc/languages/xml.cpp ../../src/eepp/ui/doc/languages/xml.hpp +../../src/eepp/ui/doc/languages/yaml.cpp +../../src/eepp/ui/doc/languages/yaml.hpp ../../src/eepp/ui/doc/languages/zig.cpp ../../src/eepp/ui/doc/languages/zig.hpp ../../src/eepp/ui/doc/syntaxcolorscheme.cpp diff --git a/src/eepp/ui/doc/languages/c.cpp b/src/eepp/ui/doc/languages/c.cpp new file mode 100644 index 000000000..f360b2641 --- /dev/null +++ b/src/eepp/ui/doc/languages/c.cpp @@ -0,0 +1,55 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addC() { + + SyntaxDefinitionManager::instance()->add( + + { "C", + { "%.c$", "%.C", "%.h$", "%.icc" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "^%s*(#include)%s+([<%\"][%w%d%.%\\%/%_%-]+[>%\"])" }, + { "keyword", "keyword", "literal" } }, + { { "^%s*(#e?l?n?d?ifn?d?e?f?)%s+" }, { "keyword", "keyword", "literal" } }, + { { "^%s*(#define)%s*" }, { "keyword", "keyword", "literal" } }, + { { "^%s*(#else)%s*" }, { "keyword", "keyword", "literal" } }, + { { "^%s*#", "[^\\]\n" }, "comment" }, + { { "\"", "[\"\n]", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "elseif", "keyword" }, { "int", "keyword2" }, { "then", "keyword" }, + { "unsigned", "keyword2" }, { "continue", "keyword" }, { "default", "keyword" }, + { "volatile", "keyword" }, { "switch", "keyword" }, { "char", "keyword2" }, + { "double", "keyword2" }, { "auto", "keyword" }, { "bool", "keyword2" }, + { "return", "keyword" }, { "extern", "keyword" }, { "NULL", "literal" }, + { "long", "keyword2" }, { "void", "keyword" }, { "union", "keyword" }, + { "short", "keyword2" }, { "static", "keyword" }, { "inline", "keyword" }, + { "false", "literal" }, { "for", "keyword" }, { "goto", "keyword" }, + { "while", "keyword" }, { "const", "keyword" }, { "int32_t", "keyword2" }, + { "int16_t", "keyword2" }, { "uint16_t", "keyword2" }, { "typedef", "keyword" }, + { "true", "literal" }, { "else", "keyword" }, { "uint32_t", "keyword2" }, + { "enum", "keyword" }, { "int8_t", "keyword2" }, { "int64_t", "keyword2" }, + { "float", "keyword2" }, { "struct", "keyword" }, { "break", "keyword" }, + { "uint8_t", "keyword2" }, { "uint64_t", "keyword2" }, { "case", "keyword" }, + { "if", "keyword" }, { "do", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/c.hpp b/src/eepp/ui/doc/languages/c.hpp new file mode 100644 index 000000000..03ad29674 --- /dev/null +++ b/src/eepp/ui/doc/languages/c.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_C +#define EE_UI_DOC_C + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addC(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/cmake.cpp b/src/eepp/ui/doc/languages/cmake.cpp new file mode 100644 index 000000000..4ada6b7f8 --- /dev/null +++ b/src/eepp/ui/doc/languages/cmake.cpp @@ -0,0 +1,82 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addCMake() { + + SyntaxDefinitionManager::instance()->add( + + { "CMake", + { "%.cmake$", "CMakeLists.txt$" }, + { + { { "#", "[^\\]\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "[%a_][%w_]*%s?%f[(]" }, "function" }, + { { "CMAKE_[%w%d_]+" }, "keyword" }, + { { "CTEST_[%w%d_]+" }, "keyword" }, + { { "%u[%u%d_]*_[%u%d_]+" }, "keyword" }, + { { "%${[%a_][%w_]*%}" }, "keyword2" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "MSVC90", "keyword2" }, { "UNIX", "keyword2" }, + { "REPLACE", "literal" }, { "MATCHES", "operator" }, + { "SOURCES", "keyword2" }, { "REGEX", "literal" }, + { "MSVC12", "keyword2" }, { "RUNTIME", "literal" }, + { "LANGUAGE", "keyword2" }, { "BORLAND", "keyword2" }, + { "MINGW", "keyword2" }, { "C", "literal" }, + { "TOLOWER", "literal" }, { "FALSE", "literal" }, + { "OR", "operator" }, { "DEPRECATION", "keyword2" }, + { "LIBTYPE", "literal" }, { "COMMAND", "literal" }, + { "DISABLED", "keyword2" }, { "VARIABLES", "keyword2" }, + { "PREFIX", "keyword2" }, { "APPEND", "literal" }, + { "OFF", "literal" }, { "XCTEST", "keyword2" }, + { "GHSMULTI", "keyword2" }, { "HELPSTRING", "keyword2" }, + { "MSVC14", "keyword2" }, { "AUTORCC", "keyword2" }, + { "TESTS", "keyword2" }, { "WINCE", "keyword2" }, + { "DEFINED", "literal" }, { "TARGET", "literal" }, + { "NAME", "keyword2" }, { "LABELS", "keyword2" }, + { "VALUE", "keyword2" }, { "TYPE", "keyword2" }, + { "TRUE", "literal" }, { "EchoString", "keyword2" }, + { "MSVC60", "keyword2" }, { "ARCHIVE", "literal" }, + { "IMMEDIATE", "literal" }, { "MSVC71", "keyword2" }, + { "DESTINATION", "literal" }, { "INTERFACE", "literal" }, + { "PROCESSORS", "keyword2" }, { "CYGWIN", "keyword2" }, + { "ENVIRONMENT", "keyword2" }, { "IOS", "keyword2" }, + { "SUFFIX", "keyword2" }, { "TOUPPER", "literal" }, + { "ANDROID", "keyword2" }, { "ENV", "keyword2" }, + { "WIN32", "keyword2" }, { "STATUS", "literal" }, + { "BUNDLE", "keyword2" }, { "STREQUAL", "literal" }, + { "MSVC10", "keyword2" }, { "AUTOUIC", "keyword2" }, + { "GNUtoMS", "keyword2" }, { "SOVERSION", "keyword2" }, + { "AUTOMOC", "keyword2" }, { "SUBDIRECTORIES", "keyword2" }, + { "SYMBOLIC", "keyword2" }, { "AND", "operator" }, + { "FOLDER", "keyword2" }, { "APPLE", "keyword2" }, + { "MSVC70", "keyword2" }, { "COST", "keyword2" }, + { "ABSTRACT", "keyword2" }, { "MSVC11", "keyword2" }, + { "IMPORTED", "keyword2" }, { "NOT", "operator" }, + { "MODIFIED", "keyword2" }, { "GLOB", "literal" }, + { "MSVC80", "keyword2" }, { "MACROS", "keyword2" }, + { "LOCATION", "keyword2" }, { "CXX", "literal" }, + { "WARNING", "literal" }, { "MSYS", "keyword2" }, + { "TIMEOUT", "keyword2" }, { "CACHE", "keyword2" }, + { "EXPR", "literal" }, { "FRAMEWORK", "keyword2" }, + { "DEPENDS", "keyword2" }, { "XCODE", "keyword2" }, + { "LIBRARY", "literal" }, { "MEASUREMENT", "keyword2" }, + { "GENERATED", "keyword2" }, { "STRINGS", "keyword2" }, + { "VERSION", "keyword2" }, { "KEEP_EXTENSION", "keyword2" }, + { "EQUAL", "operator" }, { "MSVC", "keyword2" }, + { "RESOURCE", "keyword2" }, { "ADVANCED", "keyword2" }, + { "ON", "literal" }, + + }, + "#", + { "^cmake_minimum_required.*%c" } + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/cmake.hpp b/src/eepp/ui/doc/languages/cmake.hpp new file mode 100644 index 000000000..b88022ae3 --- /dev/null +++ b/src/eepp/ui/doc/languages/cmake.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Cmake +#define EE_UI_DOC_Cmake + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addCMake(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/configfile.cpp b/src/eepp/ui/doc/languages/configfile.cpp new file mode 100644 index 000000000..2497b2967 --- /dev/null +++ b/src/eepp/ui/doc/languages/configfile.cpp @@ -0,0 +1,41 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addConfigFile() { + + SyntaxDefinitionManager::instance()->add( + + { "Config File", + { "%.ini$", "%.conf$", "%.desktop$", "%.service$", "%.cfg$", "%.properties$", + "Doxyfile" }, + { + { { "%s?#%x%x%x%x%x%x%x%x" }, "string" }, + { { "%s?#%x%x%x%x%x%x" }, "string" }, + { { "^#.-\n" }, "comment" }, + { { "^;.-\n" }, "comment" }, + { { "%s#.-\n" }, "comment" }, + { { "[%a_][%w-+_%s%p]-%f[=]" }, "keyword" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "^%[.-%]" }, "keyword2" }, + { { "%s%[.-%]" }, "keyword2" }, + { { "=" }, "operator" }, + { { "https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/?[%w_.~!*:@&+$/" + "?%%#=-]*" }, + "link" }, + { { "[a-z]+" }, "symbol" }, + + }, + { + { "false", "literal" }, + { "true", "literal" }, + + }, + "#", + { "^%[.-%]%f[^\n]" }, + "ini" } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/configfile.hpp b/src/eepp/ui/doc/languages/configfile.hpp new file mode 100644 index 000000000..92cb349df --- /dev/null +++ b/src/eepp/ui/doc/languages/configfile.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Configfile +#define EE_UI_DOC_Configfile + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addConfigFile(); + +}}}} + +#endif diff --git a/src/eepp/ui/doc/languages/containerfile.cpp b/src/eepp/ui/doc/languages/containerfile.cpp new file mode 100644 index 000000000..9863c04b4 --- /dev/null +++ b/src/eepp/ui/doc/languages/containerfile.cpp @@ -0,0 +1,46 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addContainerFile() { + + SyntaxDefinitionManager::instance()->add( + + { "Containerfile", + { "^[Cc]ontainerfile$", "^[dD]ockerfile$" }, + { + { { "#.*\n" }, "comment" }, + { { "%[", "%]" }, "string" }, + { { "%sas%s" }, "literal" }, + { { "--platform=" }, "literal" }, + { { "--chown=" }, "literal" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "EXPOSE", "keyword2" }, + { "FROM", "keyword" }, + { "STOPSIGNAL", "keyword2" }, + { "HEALTHCHECK", "keyword2" }, + { "SHELL", "keyword2" }, + { "ENV", "keyword2" }, + { "RUN", "keyword2" }, + { "ENTRYPOINT", "function" }, + { "VOLUME", "keyword2" }, + { "WORKDIR", "keyword2" }, + { "LABEL", "keyword2" }, + { "USER", "keyword2" }, + { "ONBUILD", "keyword2" }, + { "COPY", "keyword2" }, + { "ARG", "keyword2" }, + { "ADD", "keyword2" }, + { "CMD", "function" }, + + }, + "#", + {}, + "dockerfile" } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/containerfile.hpp b/src/eepp/ui/doc/languages/containerfile.hpp new file mode 100644 index 000000000..49727a0bc --- /dev/null +++ b/src/eepp/ui/doc/languages/containerfile.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Containerfile +#define EE_UI_DOC_Containerfile + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addContainerFile(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/cpp.cpp b/src/eepp/ui/doc/languages/cpp.cpp new file mode 100644 index 000000000..eb94a2370 --- /dev/null +++ b/src/eepp/ui/doc/languages/cpp.cpp @@ -0,0 +1,105 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addCPP() { + + SyntaxDefinitionManager::instance()->add( + + { "C++", + { "%.cpp$", "%.cc$", "%.cxx$", "%.c++$", "%.hh$", "%.inl$", "%.hxx$", "%.hpp$", + "%.h++$" }, + { + { { "R%\"xml%(", "%)xml%\"" }, "function", "XML" }, + { { "R%\"css%(", "%)css%\"" }, "function", "CSS" }, + { { "R%\"html%(", "%)html%\"" }, "function", "HTML" }, + { { "R%\"json%(", "%)json%\"" }, "function", "JSON" }, + { { "R\"[%a-\"]+%(", "%)[%a-\"]+%\"" }, "string" }, + { { "R\"%(", "%)\"" }, "string" }, + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "[\"\n]", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "^%s*(#include)%s+([<%\"][%w%d%.%\\%/%_%-]+[>%\"])" }, + { "keyword", "keyword", "literal" } }, + { { "^%s*(#e?l?n?d?ifn?d?e?f?)%s+" }, { "keyword", "keyword", "literal" } }, + { { "^%s*(#define)%s*" }, { "keyword", "keyword", "literal" } }, + { { "^%s*(#else)%s*" }, { "keyword", "keyword", "literal" } }, + { { "^%s*#", "[^\\]\n" }, "comment" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "std%:%:[%w_]*" }, "keyword2" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "int", "keyword2" }, { "then", "keyword" }, + { "new", "keyword" }, { "reinterpret_cast", "keyword" }, + { "this", "keyword" }, { "long", "keyword2" }, + { "Uint64", "keyword2" }, { "Vector2i", "keyword2" }, + { "String", "keyword2" }, { "Int8", "keyword2" }, + { "short", "keyword2" }, { "nullptr", "keyword" }, + { "dynamic_cast", "keyword" }, { "for", "keyword" }, + { "goto", "keyword" }, { "while", "keyword" }, + { "const", "keyword" }, { "enum", "keyword" }, + { "break", "keyword" }, { "Uint32", "keyword2" }, + { "Uint8", "keyword2" }, { "or", "keyword" }, + { "compl", "keyword" }, { "char8_t", "keyword2" }, + { "friend", "keyword" }, { "alignof", "keyword" }, + { "volatile", "keyword" }, { "noexcept", "keyword" }, + { "decltype", "keyword" }, { "auto", "keyword2" }, + { "constinit", "keyword" }, { "class", "keyword" }, + { "constexpr", "keyword" }, { "void", "keyword" }, + { "char16_t", "keyword2" }, { "static", "keyword" }, + { "inline", "keyword" }, { "typedef", "keyword" }, + { "const_cast", "keyword" }, { "co_return", "keyword" }, + { "throw", "keyword" }, { "true", "keyword2" }, + { "float", "keyword2" }, { "Vector2f", "keyword2" }, + { "bitand", "keyword" }, { "size_t", "keyword2" }, + { "Uint16", "keyword2" }, { "case", "keyword" }, + { "mutable", "keyword" }, { "protected", "keyword" }, + { "do", "keyword" }, { "continue", "keyword" }, + { "asm", "keyword" }, { "default", "keyword" }, + { "Recti", "keyword2" }, { "char", "keyword2" }, + { "bool", "keyword2" }, { "Rectf", "keyword2" }, + { "requires", "keyword" }, { "extern", "keyword" }, + { "not_eq", "keyword" }, { "static_cast", "keyword" }, + { "namespace", "keyword" }, { "union", "keyword" }, + { "xor", "keyword" }, { "Int64", "keyword2" }, + { "false", "keyword2" }, { "int32_t", "keyword2" }, + { "int16_t", "keyword2" }, { "uint16_t", "keyword2" }, + { "concept", "keyword" }, { "typename", "keyword" }, + { "else", "keyword" }, { "co_yield", "keyword" }, + { "uint32_t", "keyword2" }, { "operator", "keyword" }, + { "Int32", "keyword2" }, { "struct", "keyword" }, + { "if", "keyword" }, { "and_eq", "keyword" }, + { "Int16", "keyword2" }, { "xor_eq", "keyword" }, + { "elseif", "keyword" }, { "public", "keyword" }, + { "virtual", "keyword" }, { "unsigned", "keyword2" }, + { "and", "keyword" }, { "Float", "keyword2" }, + { "private", "keyword" }, { "or_eq", "keyword" }, + { "switch", "keyword" }, { "using", "keyword" }, + { "double", "keyword2" }, { "typeid", "keyword" }, + { "delete", "keyword" }, { "return", "keyword" }, + { "NULL", "literal" }, { "static_assert", "keyword" }, + { "try", "keyword" }, { "consteval", "keyword" }, + { "Color", "keyword2" }, { "register", "keyword" }, + { "explicit", "keyword" }, { "catch", "keyword" }, + { "co_wait", "keyword" }, { "override", "keyword" }, + { "not", "keyword" }, { "template", "keyword" }, + { "int64_t", "keyword2" }, { "wchar_t", "keyword2" }, + { "bitor", "keyword" }, { "thread_local", "keyword" }, + { "uint64_t", "keyword2" }, { "char32_t", "keyword2" }, + { "alignas", "keyword" }, { "export", "keyword" }, + + }, + "//", + {}, + "cpp" } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/cpp.hpp b/src/eepp/ui/doc/languages/cpp.hpp new file mode 100644 index 000000000..efca9d217 --- /dev/null +++ b/src/eepp/ui/doc/languages/cpp.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Cpp +#define EE_UI_DOC_Cpp + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addCPP(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/csharp.cpp b/src/eepp/ui/doc/languages/csharp.cpp new file mode 100644 index 000000000..b997984f3 --- /dev/null +++ b/src/eepp/ui/doc/languages/csharp.cpp @@ -0,0 +1,69 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addCSharp() { + + SyntaxDefinitionManager::instance()->add( + + { "C#", + { "%.cs$", "%.csx$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "[%$%@]?\"", "\"", "\\" }, "string" }, + { { "'\\x%x?%x?%x?%x'" }, "string" }, + { { "'\\u%x%x%x%x'" }, "string" }, + { { "'\\?.'" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "%?%?" }, "operator" }, + { { "%?%." }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "internal", "keyword" }, { "int", "keyword2" }, { "new", "keyword" }, + { "continue", "keyword" }, { "default", "keyword" }, { "remove", "keyword" }, + { "sizeof", "keyword" }, { "char", "keyword2" }, { "set", "keyword" }, + { "bool", "keyword2" }, { "this", "keyword" }, { "extern", "keyword" }, + { "long", "keyword2" }, { "foreach", "keyword" }, { "namespace", "keyword" }, + { "partial", "keyword" }, { "short", "keyword2" }, { "typeof", "keyword" }, + { "object", "keyword2" }, { "false", "literal" }, { "for", "keyword" }, + { "goto", "keyword" }, { "while", "keyword" }, { "const", "keyword" }, + { "get", "keyword" }, { "delegate", "keyword" }, { "add", "keyword" }, + { "null", "literal" }, { "unsafe", "keyword" }, { "fixed", "keyword" }, + { "else", "keyword" }, { "stackalloc", "keyword" }, { "global", "keyword" }, + { "record", "keyword" }, { "enum", "keyword" }, { "value", "keyword" }, + { "lock", "keyword" }, { "operator", "keyword" }, { "when", "keyword" }, + { "struct", "keyword" }, { "break", "keyword" }, { "is", "keyword" }, + { "decimal", "keyword2" }, { "string", "keyword2" }, { "if", "keyword" }, + { "await", "keyword" }, { "in", "keyword" }, { "public", "keyword" }, + { "virtual", "keyword" }, { "dynamic", "keyword" }, { "private", "keyword" }, + { "finally", "keyword" }, { "abstract", "keyword" }, { "unchecked", "keyword" }, + { "volatile", "keyword" }, { "switch", "keyword" }, { "using", "keyword" }, + { "checked", "keyword" }, { "double", "keyword2" }, { "event", "keyword" }, + { "ulong", "keyword2" }, { "return", "keyword" }, { "var", "keyword" }, + { "out", "keyword" }, { "try", "keyword" }, { "as", "keyword" }, + { "class", "keyword" }, { "void", "keyword" }, { "byte", "keyword2" }, + { "yield", "keyword" }, { "static", "keyword" }, { "uint", "keyword2" }, + { "explicit", "keyword" }, { "sbyte", "keyword2" }, { "throw", "keyword" }, + { "where", "keyword" }, { "catch", "keyword" }, { "true", "literal" }, + { "ushort", "keyword2" }, { "override", "keyword" }, { "sealed", "keyword" }, + { "float", "keyword2" }, { "params", "keyword" }, { "readonly", "keyword" }, + { "base", "keyword" }, { "case", "keyword" }, { "interface", "keyword" }, + { "protected", "keyword" }, { "do", "keyword" }, { "implicit", "keyword" }, + { "ref", "keyword" }, + + }, + "//", + {}, + "csharp" } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/csharp.hpp b/src/eepp/ui/doc/languages/csharp.hpp new file mode 100644 index 000000000..86eec3f11 --- /dev/null +++ b/src/eepp/ui/doc/languages/csharp.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Csharp +#define EE_UI_DOC_Csharp + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addCSharp(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/dart.cpp b/src/eepp/ui/doc/languages/dart.cpp new file mode 100644 index 000000000..327e0546c --- /dev/null +++ b/src/eepp/ui/doc/languages/dart.cpp @@ -0,0 +1,52 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addDart() { + + SyntaxDefinitionManager::instance()->add( + + { "Dart", + { "%.dart$" }, + { + { { "//.-\n" }, "comment" }, + { { "///.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "%?%?" }, "operator" }, + { { "%?%." }, "operator" }, + { { "[%$%@]?\"", "\"", "\\" }, "string" }, + { { "'\\x%x?%x?%x?%x'" }, "string" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "int", "keyword2" }, { "in", "keyword" }, { "then", "keyword" }, + { "dynamic", "keyword2" }, { "new", "keyword" }, { "continue", "keyword" }, + { "finally", "keyword" }, { "default", "keyword" }, { "switch", "keyword" }, + { "double", "keyword2" }, { "bool", "keyword2" }, { "this", "keyword2" }, + { "return", "keyword" }, { "var", "keyword" }, { "part of", "keyword" }, + { "String", "keyword2" }, { "class", "keyword" }, { "void", "keyword" }, + { "static", "keyword" }, { "false", "literal" }, { "for", "keyword" }, + { "while", "keyword" }, { "const", "keyword" }, { "null", "literal" }, + { "true", "literal" }, { "else", "keyword" }, { "final", "keyword" }, + { "enum", "keyword" }, { "print", "keyword" }, { "Map", "keyword2" }, + { "break", "keyword" }, { "List", "keyword2" }, { "Function", "keyword2" }, + { "case", "keyword" }, { "if", "keyword" }, { "await", "keyword" }, + { "do", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/dart.hpp b/src/eepp/ui/doc/languages/dart.hpp new file mode 100644 index 000000000..2d73ddc96 --- /dev/null +++ b/src/eepp/ui/doc/languages/dart.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Dart +#define EE_UI_DOC_Dart + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addDart(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/difffile.cpp b/src/eepp/ui/doc/languages/difffile.cpp new file mode 100644 index 000000000..cf4110449 --- /dev/null +++ b/src/eepp/ui/doc/languages/difffile.cpp @@ -0,0 +1,30 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addDiff() { + + SyntaxDefinitionManager::instance()->add( + + { "Diff File", + { "%.diff$", "%.patch$" }, + { + { { "^%+%+%+%s.-\n" }, "keyword" }, + { { "^%-%-%-%s.-\n" }, "keyword" }, + { { "^diff%s.-\n" }, "string" }, + { { "^index%s.-\n" }, "comment" }, + { { "^@@.-\n" }, "number" }, + { { "^%+.-\n" }, "function" }, + { { "^%-.-\n" }, "keyword2" }, + + }, + { + + }, + "", + {}, + "diff" } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/difffile.hpp b/src/eepp/ui/doc/languages/difffile.hpp new file mode 100644 index 000000000..5992543fc --- /dev/null +++ b/src/eepp/ui/doc/languages/difffile.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Difffile +#define EE_UI_DOC_Difffile + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addDiff(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/environmentfile.cpp b/src/eepp/ui/doc/languages/environmentfile.cpp new file mode 100644 index 000000000..ae036ef60 --- /dev/null +++ b/src/eepp/ui/doc/languages/environmentfile.cpp @@ -0,0 +1,44 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addEnvironmentFile() { + + SyntaxDefinitionManager::instance()->add( + + { "Environment File", + { "%.env$", "%.env.[%w%-%_]*$" }, + { + { { "^#.-\n" }, "comment" }, + { { "%s#.-\n" }, "comment" }, + { { "\\[nrtfb\\\"']" }, "literal" }, + { { "'?\\u%x%x%x%x'?" }, "literal" }, + { { "(%${)([%w]+[%w_]*)(})" }, { "keyword", "keyword", "keyword2", "keyword" } }, + { { "%$[%w]+[%w_]*" }, "keyword2" }, + { { "[%a_][%w-+_%s%p]-%f[=]" }, "keyword" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "^%[.-%]" }, "keyword2" }, + { { "%s%[.-%]" }, "keyword2" }, + { { "=" }, "operator" }, + { { "https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/?[%w_.~!*:@&+$/" + "?%%#=-]*" }, + "link" }, + { { "[a-z]+" }, "symbol" }, + + }, + { + { "false", "literal" }, + { "export", "literal" }, + { "null", "literal" }, + { "true", "literal" }, + + }, + "#", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/environmentfile.hpp b/src/eepp/ui/doc/languages/environmentfile.hpp new file mode 100644 index 000000000..5ae7b46ee --- /dev/null +++ b/src/eepp/ui/doc/languages/environmentfile.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Environmentfile +#define EE_UI_DOC_Environmentfile + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addEnvironmentFile(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/go.cpp b/src/eepp/ui/doc/languages/go.cpp new file mode 100644 index 000000000..bf8b7f2d5 --- /dev/null +++ b/src/eepp/ui/doc/languages/go.cpp @@ -0,0 +1,61 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addGo() { + + SyntaxDefinitionManager::instance()->add( + + { "Go", + { "%.go$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "`", "`", "\\" }, "string" }, + { { "0[oO_][0-7]+" }, "number" }, + { { "-?0x[%x_]+" }, "number" }, + { { "-?%d+_%d" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { ":=" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "elseif", "keyword" }, { "int", "keyword2" }, + { "uint8", "keyword2" }, { "int64", "keyword2" }, + { "go", "keyword" }, { "continue", "keyword" }, + { "float64", "keyword2" }, { "default", "keyword" }, + { "switch", "keyword" }, { "bool", "keyword2" }, + { "map", "keyword2" }, { "int16", "keyword2" }, + { "uintptr", "keyword2" }, { "return", "keyword" }, + { "var", "keyword" }, { "error", "keyword2" }, + { "import", "keyword" }, { "byte", "keyword2" }, + { "defer", "keyword" }, { "int8", "keyword2" }, + { "complex128", "keyword2" }, { "range", "keyword" }, + { "false", "literal" }, { "uint", "keyword2" }, + { "uint64", "keyword2" }, { "for", "keyword" }, + { "const", "keyword" }, { "select", "keyword" }, + { "complex64", "keyword2" }, { "true", "literal" }, + { "else", "keyword" }, { "chan", "keyword" }, + { "func", "keyword" }, { "int32", "keyword2" }, + { "float32", "keyword2" }, { "uint16", "keyword2" }, + { "package", "keyword" }, { "nil", "literal" }, + { "rune", "keyword2" }, { "struct", "keyword" }, + { "break", "keyword" }, { "uint32", "keyword2" }, + { "string", "keyword2" }, { "case", "keyword" }, + { "if", "keyword" }, { "interface", "keyword" }, + { "fallthrough", "keyword" }, { "type", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/go.hpp b/src/eepp/ui/doc/languages/go.hpp new file mode 100644 index 000000000..21d1bd208 --- /dev/null +++ b/src/eepp/ui/doc/languages/go.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Go +#define EE_UI_DOC_Go + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addGo(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/haskell.cpp b/src/eepp/ui/doc/languages/haskell.cpp new file mode 100644 index 000000000..290822464 --- /dev/null +++ b/src/eepp/ui/doc/languages/haskell.cpp @@ -0,0 +1,42 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addHaskell() { + + SyntaxDefinitionManager::instance()->add( + + { "Haskell", + { "%.hs$" }, + { + { { "%-%-", "\n" }, "comment" }, + { { "{%-", "%-}" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[!%#%$%%&*+./%<=>%?@\\%^|%-~:]" }, "operator" }, + { { "[%a_'][%w_']*" }, "symbol" }, + + }, + { + { "in", "keyword" }, { "then", "keyword" }, { "default", "keyword" }, + { "mdo", "keyword" }, { "forall", "keyword" }, { "hiding", "keyword" }, + { "data", "keyword" }, { "import", "keyword" }, { "as", "keyword" }, + { "class", "keyword" }, { "infixl", "keyword" }, { "newtype", "keyword" }, + { "of", "keyword" }, { "module", "keyword" }, { "infix", "keyword" }, + { "deriving", "keyword" }, { "where", "keyword" }, { "else", "keyword" }, + { "foreign", "keyword" }, { "infixr", "keyword" }, { "qualified", "keyword" }, + { "case", "keyword" }, { "if", "keyword" }, { "let", "keyword" }, + { "do", "keyword" }, { "type", "keyword" }, + + }, + "%-%-", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/haskell.hpp b/src/eepp/ui/doc/languages/haskell.hpp new file mode 100644 index 000000000..48fb9e963 --- /dev/null +++ b/src/eepp/ui/doc/languages/haskell.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Haskell +#define EE_UI_DOC_Haskell + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addHaskell(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/haxe.cpp b/src/eepp/ui/doc/languages/haxe.cpp new file mode 100644 index 000000000..25d94aa2d --- /dev/null +++ b/src/eepp/ui/doc/languages/haxe.cpp @@ -0,0 +1,100 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addHaxe() { + + SyntaxDefinitionManager::instance()->add( + { "Haxe Compiler Arguments", + { "%.hxml$" }, + { + { { "#.*" }, "comment" }, + { { "%-[%-%w_]*" }, "keyword" }, + { { "(%.)(%u[%w_]*)" }, { "normal", "normal", "keyword2" } }, + { { "%s+" }, "normal" }, + { { "%w+%f[%s]" }, "normal" }, + }, + {}, + "#" } ); + + SyntaxDefinitionManager::instance() + ->add( { "HaxeStringInterpolation", + {}, + { + { { "%${", "}", "\\" }, "keyword", ".hx" }, + { { "%$", "%s", "\\" }, "keyword", ".hx" }, + { { "[^ ]" }, "string" }, + { { "%s+" }, "normal" }, + { { "%w+%f[%s]" }, "normal" }, + }, + {} } ) + .setVisible( false ); + + SyntaxDefinitionManager::instance() + ->add( { "HaxeRegularExpressions", + {}, + { + { { "[%[%]%(%)]" }, "string" }, + { { "[%.%*%+%?%^%$%|%-]" }, "operator" }, + { { "%s+" }, "normal" }, + { { "%w+%f[%s]" }, "normal" }, + }, + {} } ) + .setVisible( false ); + + SyntaxDefinitionManager::instance()->add( + { "Haxe", + { "%.hx$" }, + { + { { "%~%/", "%/[igmsu]*" }, "keyword2", "HaxeRegularExpressions" }, + { { "%.%.%." }, "operator" }, + { { "(%<)(%u[%w_]*)(%>*)" }, { "normal", "operator", "keyword2", "operator" } }, + { { "(%#%s*[%a_]*)(.*\n)" }, { "normal", "keyword", "normal" } }, + { { "(import%s+)(%u[%w]*)" }, { "normal", "keyword", "keyword2" } }, + { { "(import%s+)([%w%.]*%.)(%u[%w]*)" }, + { "normal", "keyword", "normal", "keyword2" } }, + { { "(abstract%s+)(%u[%w_]*%s*%()(%s*%u[%w_]*)" }, + { "normal", "keyword2", "normal", "keyword2" } }, + { { "(from%s+)(%u[%w_]*%s+)(to%s+)(%u[%w_]*)" }, + { "normal", "keyword", "keyword2", "keyword", "keyword2" } }, + { { "//.*\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string", "HaxeStringInterpolation" }, + { { "-?%.?%d+" }, "number" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+%.[%deE]+" }, "number" }, + { { "-?%d+[%deE]+" }, "number" }, + { { "[%+%-%.=/%*%^%%<>!~|&]" }, "operator" }, + { { "([%a_][%w_]*)(%s*%f[(])" }, { "normal", "function", "normal" } }, + { { "[%a_][%w_]*" }, "symbol" }, + { { "(:)(%u[%a_][%w_]*)" }, { "normal", "normal", "keyword2" } }, + { { "@:[%a_][%w_]*%f[(]" }, "keyword" }, + { { "%$type" }, "keyword" }, + { { "%s+" }, "normal" }, + { { "%w+%f[%s]" }, "normal" }, + }, + { + { "using", "keyword2" }, { "true", "literal" }, { "trace", "keyword" }, + { "throw", "keyword" }, { "typedef", "keyword2" }, { "switch", "keyword" }, + { "try", "keyword" }, { "static", "keyword" }, { "set", "keyword" }, + { "return", "keyword" }, { "public", "keyword" }, { "package", "keyword" }, + { "do", "keyword" }, { "default", "keyword" }, { "new", "keyword" }, + { "private", "keyword" }, { "macro", "keyword2" }, { "cast", "keyword" }, + { "class", "keyword" }, { "case", "keyword" }, { "this", "keyword" }, + { "continue", "keyword" }, { "else", "keyword" }, { "extern", "keyword2" }, + { "break", "keyword" }, { "extends", "keyword2" }, { "interface", "keyword" }, + { "abstract", "keyword2" }, { "for", "keyword" }, { "override", "keyword" }, + { "function", "keyword2" }, { "never", "keyword" }, { "get", "keyword" }, + { "final", "keyword" }, { "if", "keyword" }, { "implements", "keyword2" }, + { "var", "keyword2" }, { "catch", "keyword" }, { "import", "keyword" }, + { "false", "literal" }, { "in", "keyword" }, { "while", "keyword" }, + { "inline", "keyword" }, { "enum", "keyword" }, { "null", "literal" }, + + }, + "//", + {} } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/haxe.hpp b/src/eepp/ui/doc/languages/haxe.hpp new file mode 100644 index 000000000..b77930f00 --- /dev/null +++ b/src/eepp/ui/doc/languages/haxe.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Haxe +#define EE_UI_DOC_Haxe + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addHaxe(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/ignorefile.cpp b/src/eepp/ui/doc/languages/ignorefile.cpp new file mode 100644 index 000000000..8d261399e --- /dev/null +++ b/src/eepp/ui/doc/languages/ignorefile.cpp @@ -0,0 +1,20 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addIgnoreFile() { + + SyntaxDefinitionManager::instance()->add( + + { ".ignore file", + { "%..*ignore$" }, + { + { { "^%s*#.*$" }, "comment" }, + { { "^%!.*$" }, "keyword" }, + }, + {}, + "#" } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/ignorefile.hpp b/src/eepp/ui/doc/languages/ignorefile.hpp new file mode 100644 index 000000000..96a46de0b --- /dev/null +++ b/src/eepp/ui/doc/languages/ignorefile.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Ignorefile +#define EE_UI_DOC_Ignorefile + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addIgnoreFile(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/java.cpp b/src/eepp/ui/doc/languages/java.cpp new file mode 100644 index 000000000..d60bcf720 --- /dev/null +++ b/src/eepp/ui/doc/languages/java.cpp @@ -0,0 +1,63 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addJava() { + + SyntaxDefinitionManager::instance()->add( + + { "Java", + { "%.java$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "'\\x%x?%x?%x?%x'" }, "string" }, + { { "'\\u%x%x%x%x'" }, "string" }, + { { "'\\?.'" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "int", "keyword2" }, { "then", "keyword" }, + { "new", "keyword" }, { "continue", "keyword" }, + { "default", "keyword" }, { "char", "keyword2" }, + { "long", "keyword2" }, { "short", "keyword2" }, + { "extends", "keyword" }, { "false", "literal" }, + { "for", "keyword" }, { "goto", "keyword" }, + { "while", "keyword" }, { "null", "literal" }, + { "else", "keyword" }, { "final", "keyword" }, + { "enum", "keyword" }, { "break", "keyword" }, + { "if", "keyword" }, { "elseif", "keyword" }, + { "native", "keyword" }, { "public", "keyword" }, + { "throws", "keyword" }, { "private", "keyword" }, + { "finally", "keyword" }, { "abstract", "keyword" }, + { "volatile", "keyword" }, { "switch", "keyword" }, + { "double", "keyword2" }, { "return", "keyword" }, + { "import", "keyword" }, { "try", "keyword" }, + { "class", "keyword" }, { "void", "keyword" }, + { "byte", "keyword2" }, { "static", "keyword" }, + { "super", "keyword" }, { "boolean", "keyword2" }, + { "assert", "keyword" }, { "throw", "keyword" }, + { "catch", "keyword" }, { "true", "literal" }, + { "implements", "keyword" }, { "instanceof", "keyword" }, + { "package", "keyword" }, { "transient", "keyword" }, + { "float", "keyword2" }, { "synchronized", "keyword" }, + { "case", "keyword" }, { "interface", "keyword" }, + { "protected", "keyword" }, { "do", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/java.hpp b/src/eepp/ui/doc/languages/java.hpp new file mode 100644 index 000000000..51a40b2c7 --- /dev/null +++ b/src/eepp/ui/doc/languages/java.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Java +#define EE_UI_DOC_Java + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addJava(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/javascript.cpp b/src/eepp/ui/doc/languages/javascript.cpp new file mode 100644 index 000000000..720957e28 --- /dev/null +++ b/src/eepp/ui/doc/languages/javascript.cpp @@ -0,0 +1,65 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addJavaScript() { + + SyntaxDefinitionManager::instance()->add( + + { "JavaScript", + { "%.js$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "`", "`", "\\" }, "string" }, + { { "/[%+%-%*%^%!%=%&%|%?%:%;%,%(%[%{%<%>%\\].*%f[/]", + "/[igmsuyd\n]?[igmsuyd\n]?[igmsuyd\n]?", "\\" }, + "string" }, + { { "0x[%da-fA-F]+" }, "number" }, + { { "-?%d+[%d%.eE]*" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "([%w_][%w_]+)%.([%w_][%w%d_]*)%s*(=)%s*(function)" }, + { "normal", "keyword2", "function", "operator", "keyword" } }, + { { "([%w_][%w_]+)%.([%w_][%w%d_]*)%s*(=)%s*(async%s*function)" }, + { "normal", "keyword2", "function", "operator", "keyword" } }, + { { "([%w_][%w_]+)%.([%w_][%w%d_]*)%s*(=)%s*%f[(]" }, + { "normal", "keyword2", "function", "operator" } }, + { { "([%w_][%w_]+)%.([%w_][%w%d_]*)%s*(=)%s*(async)%s*%f[(]" }, + { "normal", "keyword2", "function", "operator", "function" } }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "new", "keyword" }, { "continue", "keyword" }, { "default", "keyword" }, + { "set", "keyword" }, { "this", "keyword2" }, { "Array", "keyword2" }, + { "namespace", "keyword" }, { "any", "keyword" }, { "of", "keyword" }, + { "typeof", "keyword" }, { "extends", "keyword" }, { "with", "keyword" }, + { "undefined", "literal" }, { "false", "literal" }, { "for", "keyword" }, + { "while", "keyword" }, { "const", "keyword" }, { "get", "keyword" }, + { "from", "keyword" }, { "null", "literal" }, { "function", "keyword" }, + { "else", "keyword" }, { "enum", "keyword" }, { "async", "keyword" }, + { "break", "keyword" }, { "declare", "keyword" }, { "arguments", "keyword2" }, + { "if", "keyword" }, { "await", "keyword" }, { "let", "keyword" }, + { "in", "keyword" }, { "public", "keyword" }, { "debugger", "keyword" }, + { "private", "keyword" }, { "NaN", "keyword2" }, { "finally", "keyword" }, + { "switch", "keyword" }, { "delete", "keyword" }, { "return", "keyword" }, + { "var", "keyword" }, { "import", "keyword" }, { "try", "keyword" }, + { "class", "keyword" }, { "void", "keyword" }, { "yield", "keyword" }, + { "static", "keyword" }, { "super", "keyword" }, { "throw", "keyword" }, + { "catch", "keyword" }, { "true", "literal" }, { "implements", "keyword" }, + { "instanceof", "keyword" }, { "Infinity", "keyword2" }, { "case", "keyword" }, + { "export", "keyword" }, { "protected", "keyword" }, { "do", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/javascript.hpp b/src/eepp/ui/doc/languages/javascript.hpp new file mode 100644 index 000000000..79d06274a --- /dev/null +++ b/src/eepp/ui/doc/languages/javascript.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Javascript +#define EE_UI_DOC_Javascript + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addJavaScript(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/json.cpp b/src/eepp/ui/doc/languages/json.cpp new file mode 100644 index 000000000..1e979f895 --- /dev/null +++ b/src/eepp/ui/doc/languages/json.cpp @@ -0,0 +1,35 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addJSON() { + + SyntaxDefinitionManager::instance()->add( + + { "JSON", + { "%.json$", "%.cson$", "%.webmanifest" }, + { + { { "(%b\"\")(:)" }, { "normal", "keyword", "operator" } }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "`", "`", "\\" }, "string" }, + { { "0x[%da-fA-F]+" }, "number" }, + { { "-?%d+[%d%.eE]*" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "[%[%]%{%}]" }, "operator" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "false", "literal" }, + { "true", "literal" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/json.hpp b/src/eepp/ui/doc/languages/json.hpp new file mode 100644 index 000000000..cc097e786 --- /dev/null +++ b/src/eepp/ui/doc/languages/json.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Json +#define EE_UI_DOC_Json + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addJSON(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/jsx.cpp b/src/eepp/ui/doc/languages/jsx.cpp new file mode 100644 index 000000000..a93d96173 --- /dev/null +++ b/src/eepp/ui/doc/languages/jsx.cpp @@ -0,0 +1,63 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addJSX() { + + SyntaxDefinitionManager::instance() + ->add( { "JSX", + { "%.jsx$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "`", "`", "\\" }, "string" }, + { { "/[%+%-%*%^%!%=%&%|%?%:%;%,%(%[%{%<%>%\\].*%f[/]", + "/[igmsuyd\n]?[igmsuyd\n]?[igmsuyd\n]?", "\\" }, + "string" }, + { { "%f[^<]![%a_][%w%_%-]*" }, "keyword2" }, + { { "%f[^<][%a_][%w%_%-]*" }, "function" }, + { { "%f[^<]/[%a_][%w%_%-]*" }, "function" }, + { { "([%a_-][%w-_]*)(%\?\?)(=)%f[%{%\"]" }, + { "normal", "keyword", "normal", "operator" } }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "0x[%da-fA-F]+" }, "number" }, + { { "-?%d+[%d%.eE]*" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + }, + { + { "async", "keyword" }, { "await", "keyword" }, + { "break", "keyword" }, { "case", "keyword" }, + { "catch", "keyword" }, { "class", "keyword" }, + { "const", "keyword" }, { "continue", "keyword" }, + { "debugger", "keyword" }, { "default", "keyword" }, + { "delete", "keyword" }, { "do", "keyword" }, + { "else", "keyword" }, { "export", "keyword" }, + { "extends", "keyword" }, { "finally", "keyword" }, + { "for", "keyword" }, { "function", "keyword" }, + { "get", "keyword" }, { "if", "keyword" }, + { "import", "keyword" }, { "in", "keyword" }, + { "instanceof", "keyword" }, { "let", "keyword" }, + { "new", "keyword" }, { "return", "keyword" }, + { "set", "keyword" }, { "static", "keyword" }, + { "super", "keyword" }, { "switch", "keyword" }, + { "throw", "keyword" }, { "try", "keyword" }, + { "typeof", "keyword" }, { "var", "keyword" }, + { "void", "keyword" }, { "while", "keyword" }, + { "with", "keyword" }, { "yield", "keyword" }, + { "true", "literal" }, { "false", "literal" }, + { "null", "literal" }, { "undefined", "literal" }, + { "arguments", "keyword2" }, { "Infinity", "keyword2" }, + { "NaN", "keyword2" }, { "this", "keyword2" }, + }, + "//" } ) + .setAutoCloseXMLTags( true ) + .setLSPName( "javascriptreact" ); + +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/jsx.hpp b/src/eepp/ui/doc/languages/jsx.hpp new file mode 100644 index 000000000..20ff5d497 --- /dev/null +++ b/src/eepp/ui/doc/languages/jsx.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Jsx +#define EE_UI_DOC_Jsx + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addJSX(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/latex.cpp b/src/eepp/ui/doc/languages/latex.cpp new file mode 100644 index 000000000..59dfe6008 --- /dev/null +++ b/src/eepp/ui/doc/languages/latex.cpp @@ -0,0 +1,31 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addLatex() { + + SyntaxDefinitionManager::instance()->add( + + { "LaTeX", + { "%.tex$" }, + { + { { "%%", "\n" }, "comment" }, + { { "&" }, "operator" }, + { { "\\\\" }, "operator" }, + { { "%$", "%$" }, "operator" }, + { { "\\%[", "\\]" }, "operator" }, + { { "{", "}" }, "keyword" }, + { { "\\%w*" }, "keyword2" }, + + }, + { + + }, + "%%", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/latex.hpp b/src/eepp/ui/doc/languages/latex.hpp new file mode 100644 index 000000000..c8808f7b4 --- /dev/null +++ b/src/eepp/ui/doc/languages/latex.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Latex +#define EE_UI_DOC_Latex + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addLatex(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/lua.cpp b/src/eepp/ui/doc/languages/lua.cpp new file mode 100644 index 000000000..aa48e5f9a --- /dev/null +++ b/src/eepp/ui/doc/languages/lua.cpp @@ -0,0 +1,46 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addLua() { + + SyntaxDefinitionManager::instance()->add( + + { "Lua", + { "%.lua$" }, + { + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "%[%[", "%]%]" }, "string" }, + { { "%-%-%[%[", "%]%]" }, "comment" }, + { { "%-%-.-\n" }, "comment" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "%.%.%.?" }, "operator" }, + { { "[<>~=]=" }, "operator" }, + { { "[%+%-=/%*%^%%#<>]" }, "operator" }, + { { "[%a_][%w_]*%s*%f[(\"{]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + { { "::[%a_][%w_]*::" }, "function" }, + + }, + { + { "elseif", "keyword" }, { "false", "literal" }, { "in", "keyword" }, + { "then", "keyword" }, { "for", "keyword" }, { "goto", "keyword" }, + { "while", "keyword" }, { "and", "keyword" }, { "function", "keyword" }, + { "self", "keyword2" }, { "true", "literal" }, { "else", "keyword" }, + { "nil", "literal" }, { "not", "keyword" }, { "return", "keyword" }, + { "local", "keyword" }, { "break", "keyword" }, { "or", "keyword" }, + { "end", "keyword" }, { "until", "keyword" }, { "if", "keyword" }, + { "repeat", "keyword" }, { "do", "keyword" }, + + }, + "--", + { "^#!.*[ /]lua" } + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/lua.hpp b/src/eepp/ui/doc/languages/lua.hpp new file mode 100644 index 000000000..b15edd6f6 --- /dev/null +++ b/src/eepp/ui/doc/languages/lua.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Lua +#define EE_UI_DOC_Lua + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addLua(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/makefile.cpp b/src/eepp/ui/doc/languages/makefile.cpp new file mode 100644 index 000000000..aad71b6c8 --- /dev/null +++ b/src/eepp/ui/doc/languages/makefile.cpp @@ -0,0 +1,33 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addMakefile() { + + SyntaxDefinitionManager::instance()->add( + + { "Makefile", + { "^[Mm]akefile$", "%.mk$", "%.make$", "%.mak$", "^Makefile%.am$", "^Makefile%.in$" }, + { + { { "#.*\n" }, "comment" }, + { { "[[.]]}" }, "normal" }, + { { "$[@^<%%?+|*]" }, "keyword2" }, + { { "$%(", "%)" }, "keyword" }, + { { "%f[%w_][%d%.]+%f[^%w_]" }, "number" }, + { { "%..*:" }, "keyword2" }, + { { ".*:=" }, "function" }, + { { ".*+=" }, "function" }, + { { ".*%s=" }, "function" }, + + }, + { + + }, + "#", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/makefile.hpp b/src/eepp/ui/doc/languages/makefile.hpp new file mode 100644 index 000000000..2b53e7ef9 --- /dev/null +++ b/src/eepp/ui/doc/languages/makefile.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Makefile +#define EE_UI_DOC_Makefile + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addMakefile(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/meson.cpp b/src/eepp/ui/doc/languages/meson.cpp new file mode 100644 index 000000000..b928e992c --- /dev/null +++ b/src/eepp/ui/doc/languages/meson.cpp @@ -0,0 +1,48 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addMeson() { + + SyntaxDefinitionManager::instance()->add( + + { "Meson", + { "meson.build$", "^meson_options.txt$" }, + { + { { "#", "\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "'''", "'''" }, "string" }, + { { "0x[%da-fA-F]+" }, "number" }, + { { "-?%d+%d*" }, "number" }, + { { "[%+%-=/%%%*!]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "false", "literal" }, + { "in", "keyword" }, + { "then", "keyword" }, + { "and", "keyword" }, + { "continue", "keyword" }, + { "elif", "keyword" }, + { "true", "literal" }, + { "else", "keyword" }, + { "not", "keyword" }, + { "break", "keyword" }, + { "foreach", "keyword" }, + { "endif", "keyword" }, + { "or", "keyword" }, + { "if", "keyword" }, + { "endforeach", "keyword" }, + + }, + "#", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/meson.hpp b/src/eepp/ui/doc/languages/meson.hpp new file mode 100644 index 000000000..2e9539b65 --- /dev/null +++ b/src/eepp/ui/doc/languages/meson.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Meson +#define EE_UI_DOC_Meson + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addMeson(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/nim.cpp b/src/eepp/ui/doc/languages/nim.cpp new file mode 100644 index 000000000..030e85715 --- /dev/null +++ b/src/eepp/ui/doc/languages/nim.cpp @@ -0,0 +1,91 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addNim() { + std::vector nim_patterns; + UnorderedMap nim_symbols; + + const std::vector nim_number_patterns = { + "0[bB][01][01_]*", "0o[0-7][0-7_]*", + "0[xX]%x[%x_]*", "%d[%d_]*%.%d[%d_]*[eE][-+]?%d[%d_]*", + "%d[%d_]*%.%d[%d_]*", "%d[%d_]*", + }; + + std::vector nim_type_suffix_patterns; + const std::vector nim_num_number_list = { "", "8", "16", "32", "64" }; + nim_type_suffix_patterns.reserve( nim_num_number_list.size() ); + for ( auto& num : nim_num_number_list ) + nim_type_suffix_patterns.push_back( "'?[fuiFUI]" + num ); + + nim_patterns.reserve( nim_number_patterns.size() * nim_type_suffix_patterns.size() + + nim_number_patterns.size() ); + for ( const auto& pattern : nim_number_patterns ) { + for ( const auto& suffix : nim_type_suffix_patterns ) + nim_patterns.push_back( { { pattern + suffix }, "literal" } ); + nim_patterns.push_back( { { pattern }, "literal" } ); + } + + const std::vector nim_keywords{ + "addr", "and", "as", "asm", "bind", "block", "break", "case", + "cast", "concept", "const", "continue", "converter", "defer", "discard", "distinct", + "div", "do", "elif", "else", "end", "enum", "except", "export", + "finally", "for", "from", "func", "if", "import", "in", "include", + "interface", "is", "isnot", "iterator", "let", "macro", "method", "mixin", + "mod", "not", "notin", "object", "of", "or", "out", "proc", + "ptr", "raise", "ref", "return", "shl", "shr", "static", "template", + "try", "tuple", "type", "using", "var", "when", "while", "xor", + "yield", + }; + + for ( const auto& keyword : nim_keywords ) + nim_symbols[keyword] = "keyword"; + + const std::vector nim_standard_types{ + "bool", "byte", "int", "int8", "int16", "int32", "int64", + "uint", "uint8", "uint16", "uint32", "uint64", "float", "float32", + "float64", "char", "string", "cstring", "pointer", "typedesc", "void", + "auto", "any", "untyped", "typed", "clong", "culong", "cchar", + "cschar", "cshort", "cint", "csize", "csize_t", "clonglong", "cfloat", + "cdouble", "clongdouble", "cuchar", "cushort", "cuint", "culonglong", "cstringArray", + }; + + for ( const auto& keyword : nim_standard_types ) + nim_symbols[keyword] = "keyword2"; + + const std::vector nim_standard_generic_types{ + "range", "array", "open[aA]rray", "varargs", "seq", "set", "sink", "lent", "owned", + }; + + for ( const auto& type : nim_standard_generic_types ) { + nim_patterns.push_back( { { type + "%f[%[]" }, "keyword2" } ); + nim_patterns.push_back( { { type + "+%f[%w]" }, "keyword2" } ); + } + + const std::vector nim_user_patterns{ + { { "##?%[", "]##?" }, "comment" }, + { { "##?.-\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "\"\"\"", "\"\"\"[^\"]" }, "string" }, + { { "'", "'", "\\" }, "literal" }, + { { "[a-zA-Z][a-zA-Z0-9_]*%f[(]" }, "function" }, + { { "[A-Z][a-zA-Z0-9_]*" }, "keyword2" }, + { { "[a-zA-Z][a-zA-Z0-9_]*" }, "symbol" }, + { { "%.%f[^.]" }, "normal" }, + { { ":%f[ ]" }, "normal" }, + { { "[=+%-*/<>@$~&%%|!?%^&.:\\]+" }, "operator" }, + }; + + nim_patterns.insert( nim_patterns.end(), nim_user_patterns.begin(), nim_user_patterns.end() ); + + SyntaxDefinitionManager::instance()->add( { + "Nim", + { "%.nim$", "%.nims$", "%.nimble$" }, + std::move( nim_patterns ), + std::move( nim_symbols ), + "#", + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/nim.hpp b/src/eepp/ui/doc/languages/nim.hpp new file mode 100644 index 000000000..5e94e9d42 --- /dev/null +++ b/src/eepp/ui/doc/languages/nim.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Nim +#define EE_UI_DOC_Nim + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addNim(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/objective-c.cpp b/src/eepp/ui/doc/languages/objective-c.cpp new file mode 100644 index 000000000..d02c33e08 --- /dev/null +++ b/src/eepp/ui/doc/languages/objective-c.cpp @@ -0,0 +1,49 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addObjectiveC() { + + SyntaxDefinitionManager::instance()->add( + + { "Objective-C", + { "%.m$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "#", "[^\\]\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "@[%a_][%w_]*" }, "keyword2" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "elseif", "keyword" }, { "int", "keyword2" }, { "then", "keyword" }, + { "unsigned", "keyword2" }, { "continue", "keyword" }, { "default", "keyword" }, + { "volatile", "keyword" }, { "switch", "keyword" }, { "char", "keyword2" }, + { "double", "keyword2" }, { "auto", "keyword" }, { "bool", "keyword2" }, + { "return", "keyword" }, { "extern", "keyword" }, { "NULL", "literal" }, + { "long", "keyword2" }, { "void", "keyword" }, { "union", "keyword" }, + { "short", "keyword2" }, { "static", "keyword" }, { "inline", "keyword" }, + { "false", "literal" }, { "for", "keyword" }, { "goto", "keyword" }, + { "while", "keyword" }, { "const", "keyword" }, { "typedef", "keyword" }, + { "true", "literal" }, { "else", "keyword" }, { "enum", "keyword" }, + { "nil", "literal" }, { "float", "keyword2" }, { "struct", "keyword" }, + { "break", "keyword" }, { "case", "keyword" }, { "if", "keyword" }, + { "do", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/objective-c.hpp b/src/eepp/ui/doc/languages/objective-c.hpp new file mode 100644 index 000000000..71bf6df80 --- /dev/null +++ b/src/eepp/ui/doc/languages/objective-c.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_ObjectiveC +#define EE_UI_DOC_ObjectiveC + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addObjectiveC(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/php.cpp b/src/eepp/ui/doc/languages/php.cpp new file mode 100644 index 000000000..94d70924c --- /dev/null +++ b/src/eepp/ui/doc/languages/php.cpp @@ -0,0 +1,108 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addPHP() { + + SyntaxDefinitionManager::instance() + ->add( { "PHP", + { "%.php$", "%.php3$", "%.php4$", "%.php5$" }, + { + { { "<%s*[sS][cC][rR][iI][pP][tT]%s+[tT][yY][pP][eE]%s*=%s*['\"]%a+/" + "[jJ][aA][vV][aA][sS][cC][rR][iI][pP][tT]['\"]%s*>", + "<%s*/[sS][cC][rR][iI][pP][tT]>" }, + "function", + "JavaScript" }, + { { "<%s*[sS][cC][rR][iI][pP][tT]%s*>", "<%s*/%s*[sS][cC][rR][iI][pP][tT]>" }, + "function", + "JavaScript" }, + { { "<%s*[sS][tT][yY][lL][eE][^>]*>", "<%s*/%s*[sS][tT][yY][lL][eE]%s*>" }, + "function", + "CSS" }, + { { "<%?p?h?p?", "%?>" }, "function", "PHPCore" }, + { { "" }, "comment" }, + { { "%f[^>][^<]", "%f[<]" }, "normal" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "0x[%da-fA-F]+" }, "number" }, + { { "-?%d+[%d%.]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "%f[^<]![%a_][%w%_%-]*" }, "keyword2" }, + { { "%f[^<][%a_][%w%_%-]*" }, "function" }, + { { "%f[^<]/[%a_][%w%_%-]*" }, "function" }, + { { "[%a_][%w_]*" }, "keyword" }, + { { "[/<>=]" }, "operator" }, + }, + {}, + "", + { "^#!.*[ /]php" } } ) + .setAutoCloseXMLTags( true ); + + SyntaxDefinitionManager::instance() + ->add( { "PHPCore", + {}, + { + { { "<%?p?h?p?" }, "function" }, + { { "%?>", "<%?p?h?p?" }, "function", "HTML" }, + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "#.-\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "%\\x[%da-fA-F]+" }, "number" }, + { { "-?%d+[%d%.eE]*" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "[%.%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + { { "%$[%a][%w_]*" }, "keyword2" }, + }, + { { "return", "keyword" }, { "if", "keyword" }, + { "else", "keyword" }, { "elseif", "keyword" }, + { "endif", "keyword" }, { "declare", "keyword" }, + { "enddeclare", "keyword" }, { "switch", "keyword" }, + { "endswitch", "keyword" }, { "as", "keyword" }, + { "do", "keyword" }, { "for", "keyword" }, + { "endfor", "keyword" }, { "foreach", "keyword" }, + { "endforeach", "keyword" }, { "while", "keyword" }, + { "endwhile", "keyword" }, { "switch", "keyword" }, + { "case", "keyword" }, { "continue", "keyword" }, + { "default", "keyword" }, { "break", "keyword" }, + { "exit", "keyword" }, { "goto", "keyword" }, + + { "catch", "keyword" }, { "throw", "keyword" }, + { "try", "keyword" }, { "finally", "keyword" }, + + { "class", "keyword" }, { "trait", "keyword" }, + { "interface", "keyword" }, { "public", "keyword" }, + { "static", "keyword" }, { "protected", "keyword" }, + { "private", "keyword" }, { "abstract", "keyword" }, + { "final", "keyword" }, + + { "function", "keyword2" }, { "global", "keyword2" }, + { "var", "keyword2" }, { "const", "keyword2" }, + { "bool", "keyword2" }, { "boolean", "keyword2" }, + { "int", "keyword2" }, { "integer", "keyword2" }, + { "real", "keyword2" }, { "double", "keyword2" }, + { "float", "keyword2" }, { "string", "keyword2" }, + { "array", "keyword2" }, { "object", "keyword2" }, + { "callable", "keyword2" }, { "iterable", "keyword2" }, + + { "namespace", "keyword2" }, { "extends", "keyword2" }, + { "implements", "keyword2" }, { "instanceof", "keyword2" }, + { "require", "keyword2" }, { "require_once", "keyword2" }, + { "include", "keyword2" }, { "include_once", "keyword2" }, + { "use", "keyword2" }, { "new", "keyword2" }, + { "clone", "keyword2" }, + + { "true", "literal" }, { "false", "literal" }, + { "NULL", "literal" }, { "parent", "literal" }, + { "self", "literal" }, { "echo", "function" } }, + "//", + {}, + "php" } ) + .setVisible( false ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/php.hpp b/src/eepp/ui/doc/languages/php.hpp new file mode 100644 index 000000000..eb0e75f3b --- /dev/null +++ b/src/eepp/ui/doc/languages/php.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Php +#define EE_UI_DOC_Php + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addPHP(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/plaintext.cpp b/src/eepp/ui/doc/languages/plaintext.cpp new file mode 100644 index 000000000..e43c26250 --- /dev/null +++ b/src/eepp/ui/doc/languages/plaintext.cpp @@ -0,0 +1,24 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addPlaintext() { + +SyntaxDefinitionManager::instance()->add( + +{"Plain Text", +{}, +{ + +}, +{ + +}, +"", +{}, +"plaintext" +}); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/plaintext.hpp b/src/eepp/ui/doc/languages/plaintext.hpp new file mode 100644 index 000000000..873b9ce98 --- /dev/null +++ b/src/eepp/ui/doc/languages/plaintext.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Plaintext +#define EE_UI_DOC_Plaintext + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addPlaintext(); + +}}}} + +#endif diff --git a/src/eepp/ui/doc/languages/powershell.cpp b/src/eepp/ui/doc/languages/powershell.cpp new file mode 100644 index 000000000..5ccf41fe0 --- /dev/null +++ b/src/eepp/ui/doc/languages/powershell.cpp @@ -0,0 +1,84 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addPowerShell() { + + SyntaxDefinitionManager::instance()->add( + + { "PowerShell", + { "%.ps1$", "%.psm1$", "%.psd1$", "%.ps1xml$", "%.pssc$", "%.psrc$", "%.cdxml$" }, + { + { { "#.*\n" }, "comment" }, + { { "[[\\.]]" }, "normal" }, + { { "\"", "\"" }, "string" }, + { { "'", "'" }, "string" }, + { { "%f[%w_][%d%.]+%f[^%w_]" }, "number" }, + { { "[%+=/%*%^%%<>!~|&,:]+" }, "operator" }, + { { "%f[%S]%-[%w%-%_]+" }, "function" }, + { { "[%u][%a]+[%-][%u][%a]+" }, "function" }, + { { "${.*}" }, "symbol" }, + { { "$[%a_@*][%w_]*" }, "keyword2" }, + { { "$[%$][%a]+" }, "keyword2" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "elseif", "keyword" }, + { "in", "keyword" }, + { "exit", "function" }, + { "TBD", "comment" }, + { "XXX", "comment" }, + { "dynamicparam", "keyword" }, + { "continue", "keyword" }, + { "finally", "keyword" }, + { "default", "keyword" }, + { "begin", "function" }, + { "Parameter", "keyword" }, + { "switch", "keyword" }, + { "data", "keyword" }, + { "sequence", "function" }, + { "workflow", "keyword" }, + { "configuration", "keyword" }, + { "return", "keyword" }, + { "try", "keyword" }, + { "foreach", "keyword" }, + { "class", "keyword" }, + { "process", "function" }, + { "end", "function" }, + { "TODO", "comment" }, + { "filter", "keyword" }, + { "ValidateScript", "keyword" }, + { "false", "literal" }, + { "inlinescript", "function" }, + { "for", "keyword" }, + { "while", "keyword" }, + { "select", "function" }, + { "function", "keyword" }, + { "throw", "keyword" }, + { "where", "function" }, + { "catch", "keyword" }, + { "true", "literal" }, + { "else", "keyword" }, + { "parallel", "function" }, + { "enum", "keyword" }, + { "param", "keyword" }, + { "NOTE", "comment" }, + { "break", "keyword" }, + { "CmdletBinding", "keyword" }, + { "trap", "keyword" }, + { "until", "keyword" }, + { "if", "keyword" }, + { "do", "keyword" }, + { "FIXME", "comment" }, + { "HACK", "comment" }, + + }, + "#", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/powershell.hpp b/src/eepp/ui/doc/languages/powershell.hpp new file mode 100644 index 000000000..d381ea6ea --- /dev/null +++ b/src/eepp/ui/doc/languages/powershell.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Powershell +#define EE_UI_DOC_Powershell + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addPowerShell(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/python.cpp b/src/eepp/ui/doc/languages/python.cpp new file mode 100644 index 000000000..c5b5affad --- /dev/null +++ b/src/eepp/ui/doc/languages/python.cpp @@ -0,0 +1,46 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addPython() { + + SyntaxDefinitionManager::instance()->add( + + { "Python", + { "%.py$", "%.pyw$", "%.bry$" }, + { + { { "#", "\n" }, "comment" }, + { { "[ruU]?\"", "\"", "\\" }, "string" }, + { { "[ruU]?'", "'", "\\" }, "string" }, + { { "\"\"\"", "\"\"\"" }, "string" }, + { { "0x[%da-fA-F]+" }, "number" }, + { { "-?%d+[%d%.eE]*" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "in", "keyword" }, { "and", "keyword" }, { "continue", "keyword" }, + { "finally", "keyword" }, { "False", "literal" }, { "True", "literal" }, + { "lambda", "keyword" }, { "None", "literal" }, { "del", "keyword" }, + { "return", "keyword" }, { "pass", "keyword" }, { "import", "keyword" }, + { "try", "keyword" }, { "as", "keyword" }, { "class", "keyword" }, + { "raise", "keyword" }, { "yield", "keyword" }, { "with", "keyword" }, + { "for", "keyword" }, { "while", "keyword" }, { "assert", "keyword" }, + { "from", "keyword" }, { "elif", "keyword" }, { "def", "keyword" }, + { "self", "keyword2" }, { "else", "keyword" }, { "global", "keyword" }, + { "not", "keyword" }, { "break", "keyword" }, { "nonlocal", "keyword" }, + { "is", "keyword" }, { "or", "keyword" }, { "if", "keyword" }, + { "except", "keyword" }, + + }, + "#", + { "^#!.*[ /]python", "^#!.*[ /]python3" } + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/python.hpp b/src/eepp/ui/doc/languages/python.hpp new file mode 100644 index 000000000..cd68214ef --- /dev/null +++ b/src/eepp/ui/doc/languages/python.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Python +#define EE_UI_DOC_Python + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addPython(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/ruby.cpp b/src/eepp/ui/doc/languages/ruby.cpp new file mode 100644 index 000000000..717f1368a --- /dev/null +++ b/src/eepp/ui/doc/languages/ruby.cpp @@ -0,0 +1,83 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addRuby() { + + SyntaxDefinitionManager::instance()->add( + + { "Ruby", + { "%.rb", "%.gemspec", "%.ruby" }, + { + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "%#.-\n" }, "comment" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "@?@[%a_][%w_]*" }, "keyword2" }, + { { "::[%w_]*" }, "symbol" }, + { { ":[%w_]*" }, "keyword2" }, + { { "[%a_][%w_]*:[^:]" }, "keyword2" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "__FILE__", "keyword" }, + { "in", "keyword" }, + { "then", "keyword" }, + { "alias", "keyword" }, + { "and", "keyword" }, + { "private", "keyword" }, + { "require_dependency", "keyword" }, + { "include", "keyword" }, + { "__LINE__", "keyword" }, + { "unless", "keyword" }, + { "begin", "keyword" }, + { "extend", "keyword" }, + { "return", "keyword" }, + { "BEGIN", "keyword" }, + { "class", "keyword" }, + { "__ENCODING__", "keyword" }, + { "END", "keyword" }, + { "end", "literal" }, + { "undef", "keyword" }, + { "yield", "keyword" }, + { "super", "keyword" }, + { "module", "keyword" }, + { "elsif", "keyword" }, + { "false", "literal" }, + { "for", "keyword" }, + { "while", "keyword" }, + { "def", "keyword" }, + { "self", "keyword" }, + { "true", "literal" }, + { "else", "keyword" }, + { "next", "keyword" }, + { "rescue", "keyword" }, + { "nil", "literal" }, + { "not", "keyword" }, + { "require", "keyword" }, + { "when", "keyword" }, + { "retry", "keyword" }, + { "break", "keyword" }, + { "defined?", "keyword" }, + { "or", "keyword" }, + { "case", "keyword" }, + { "until", "keyword" }, + { "if", "keyword" }, + { "ensure", "keyword" }, + { "do", "keyword" }, + { "redo", "keyword" }, + + }, + "#", + { "^#!.*[ /]ruby" } + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/ruby.hpp b/src/eepp/ui/doc/languages/ruby.hpp new file mode 100644 index 000000000..b23480f5e --- /dev/null +++ b/src/eepp/ui/doc/languages/ruby.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Ruby +#define EE_UI_DOC_Ruby + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addRuby(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/scala.cpp b/src/eepp/ui/doc/languages/scala.cpp new file mode 100644 index 000000000..e87b8b9e3 --- /dev/null +++ b/src/eepp/ui/doc/languages/scala.cpp @@ -0,0 +1,54 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addScala() { + + SyntaxDefinitionManager::instance()->add( + + { "Scala", + { "%.sc$", "%.scala$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "[ruU]?\"", "\"", "\\" }, "string" }, + { { "[ruU]?'", "'", "\\" }, "string" }, + { { "0x[%da-fA-F]+" }, "number" }, + { { "-?%d+[%d%.eE]*" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*\"\"\"*[%a_][%w_]*\"\"\"" }, "string" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "Nothing", "literal" }, { "AnyRef", "literal" }, { "new", "keyword" }, + { "val", "keyword" }, { "this", "keyword2" }, { "Array", "keyword2" }, + { "String", "keyword2" }, { "Long", "keyword2" }, { "extends", "keyword" }, + { "object", "keyword" }, { "match", "keyword" }, { "with", "keyword" }, + { "false", "literal" }, { "for", "keyword" }, { "forSome", "keyword" }, + { "while", "keyword" }, { "else", "keyword" }, { "final", "keyword" }, + { "List", "keyword2" }, { "if", "keyword" }, { "println", "keyword" }, + { "Any", "literal" }, { "Char", "keyword2" }, { "Float", "keyword2" }, + { "private", "keyword2" }, { "finally", "keyword" }, { "abstract", "keyword" }, + { "Int", "keyword2" }, { "trait", "keyword" }, { "return", "keyword" }, + { "var", "keyword" }, { "import", "keyword" }, { "class", "keyword" }, + { "Byte", "keyword2" }, { "lazy", "keyword" }, { "yield", "keyword" }, + { "Double", "keyword2" }, { "super", "keyword2" }, { "Null", "literal" }, + { "Short", "keyword2" }, { "throw", "keyword" }, { "def", "keyword" }, + { "Try", "keyword" }, { "Unit", "literal" }, { "catch", "keyword" }, + { "true", "literal" }, { "Boolean", "keyword2" }, { "package", "keyword" }, + { "override", "keyword" }, { "sealed", "keyword2" }, { "case", "keyword" }, + { "protected", "keyword2" }, { "do", "keyword" }, { "implicit", "keyword" }, + { "type", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/scala.hpp b/src/eepp/ui/doc/languages/scala.hpp new file mode 100644 index 000000000..c1772f572 --- /dev/null +++ b/src/eepp/ui/doc/languages/scala.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Scala +#define EE_UI_DOC_Scala + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addScala(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/shellscript.cpp b/src/eepp/ui/doc/languages/shellscript.cpp new file mode 100644 index 000000000..8c607c91a --- /dev/null +++ b/src/eepp/ui/doc/languages/shellscript.cpp @@ -0,0 +1,60 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addShellScript() { + + SyntaxDefinitionManager::instance()->add( + + { "Shell script", + { "%.sh$", "%.bash$", "^%.bashrc$", "^%.bash_profile$", "^%.profile$", "%.zsh$", + "%.fish$", "^PKGBUILD$" }, + { + { { "$[%a_@*#][%w_]*" }, "keyword2" }, + { { "#.*\n" }, "comment" }, + { { "<<%-?%s*EOF", "EOF" }, "string" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "`", "`", "\\" }, "string" }, + { { "%f[%w_%.%/]%d[%d%.]*%f[^%w_%.]" }, "number" }, + { { "[!<>|&%[%]:=*]" }, "operator" }, + { { "%f[%S][%+%-][%w%-_:]+" }, "function" }, + { { "%f[%S][%+%-][%w%-_]+%f[=]" }, "function" }, + { { "(%s%-%a[%w_%-]*%s+)(%d[%d%.]+)" }, { "normal", "function", "number" } }, + { { "(%s%-%a[%w_%-]*%s+)(%a[%a%-_:=]+)" }, { "normal", "function", "symbol" } }, + { { "[_%a][%w_]+%f[%+=]" }, "keyword2" }, + { { "${.-}" }, "keyword2" }, + { { "$[%d$%a_@*][%w_]*" }, "keyword2" }, + { { "[%a_%-][%w_%-]*[%s]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + { { "%s+" }, "normal" }, + { { "%w+%f[%s]" }, "normal" }, + + }, + { + { "in", "keyword" }, { "then", "keyword" }, { "exit", "keyword" }, + { "alias", "keyword" }, { "continue", "keyword" }, { "getopts", "keyword" }, + { "set", "keyword" }, { "return", "keyword" }, { "unalias", "keyword" }, + { "pwd", "keyword" }, { "fi", "keyword" }, { "printf", "keyword" }, + { "unset", "keyword" }, { "cd", "keyword" }, { "echo", "keyword" }, + { "false", "literal" }, { "help", "keyword" }, { "for", "keyword" }, + { "test", "keyword" }, { "mapfile", "keyword" }, { "shift", "keyword" }, + { "while", "keyword" }, { "readarray", "keyword" }, { "eval", "keyword" }, + { "select", "keyword" }, { "elif", "keyword" }, { "function", "keyword" }, + { "true", "literal" }, { "else", "keyword" }, { "exec", "keyword" }, + { "enable", "keyword" }, { "local", "keyword" }, { "jobs", "keyword" }, + { "source", "keyword" }, { "break", "keyword" }, { "declare", "keyword" }, + { "history", "keyword" }, { "case", "keyword" }, { "until", "keyword" }, + { "if", "keyword" }, { "esac", "keyword" }, { "hash", "keyword" }, + { "kill", "keyword" }, { "time", "keyword" }, { "let", "keyword" }, + { "export", "keyword" }, { "do", "keyword" }, { "done", "keyword" }, + { "read", "keyword" }, { "type", "keyword" }, + + }, + "#", + { "^#!.*[ /]bash", "^#!.*[ /]sh" }, + "shellscript" } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/shellscript.hpp b/src/eepp/ui/doc/languages/shellscript.hpp new file mode 100644 index 000000000..bade01b7c --- /dev/null +++ b/src/eepp/ui/doc/languages/shellscript.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Shellscript +#define EE_UI_DOC_Shellscript + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addShellScript(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/typescript.cpp b/src/eepp/ui/doc/languages/typescript.cpp new file mode 100644 index 000000000..d2d8a3cc6 --- /dev/null +++ b/src/eepp/ui/doc/languages/typescript.cpp @@ -0,0 +1,107 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addTypeScript() { + + SyntaxDefinition& ts = SyntaxDefinitionManager::instance()->add( + + { "TypeScript", + { "%.ts$", "%.d.ts$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "`", "`", "\\" }, "string" }, + { { "/[%+%-%*%^%!%=%&%|%?%:%;%,%(%[%{%<%>%\\].*%f[/]", + "/[igmsuyd\n]?[igmsuyd\n]?[igmsuyd\n]?", "\\" }, + "string" }, + { { "0x[%da-fA-F]+" }, "number" }, + { { "-?%d+[%d%.eE]*" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "(interface%s)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } }, + { { "(type%s)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } }, + { { "[%a_][%w_$]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "new", "keyword" }, { "continue", "keyword" }, + { "default", "keyword" }, { "set", "keyword" }, + { "this", "keyword2" }, { "namespace", "keyword" }, + { "any", "keyword2" }, { "of", "keyword" }, + { "typeof", "keyword" }, { "extends", "keyword" }, + { "with", "keyword" }, { "undefined", "literal" }, + { "false", "literal" }, { "for", "keyword" }, + { "while", "keyword" }, { "const", "keyword" }, + { "get", "keyword" }, { "from", "keyword" }, + { "null", "literal" }, { "function", "keyword" }, + { "else", "keyword" }, { "constructor", "function" }, + { "enum", "keyword" }, { "async", "keyword" }, + { "break", "keyword" }, { "declare", "keyword" }, + { "arguments", "keyword2" }, { "string", "keyword2" }, + { "if", "keyword" }, { "await", "keyword" }, + { "let", "keyword" }, { "in", "keyword" }, + { "public", "keyword" }, { "debugger", "keyword" }, + { "private", "keyword" }, { "finally", "keyword" }, + { "abstract", "keyword" }, { "number", "keyword2" }, + { "switch", "keyword" }, { "delete", "keyword" }, + { "return", "keyword" }, { "var", "keyword" }, + { "import", "keyword" }, { "try", "keyword" }, + { "as", "keyword" }, { "class", "keyword" }, + { "void", "keyword" }, { "unknown", "keyword2" }, + { "yield", "keyword" }, { "static", "keyword" }, + { "super", "keyword" }, { "module", "keyword" }, + { "boolean", "keyword2" }, { "throw", "keyword" }, + { "catch", "keyword" }, { "true", "literal" }, + { "implements", "keyword" }, { "symbol", "keyword2" }, + { "instanceof", "keyword" }, { "package", "keyword" }, + { "require", "keyword" }, { "Infinity", "keyword2" }, + { "readonly", "keyword" }, { "case", "keyword" }, + { "export", "keyword" }, { "interface", "keyword" }, + { "protected", "keyword" }, { "do", "keyword" }, + { "type", "keyword2" }, + + }, + "//", + {} + + } ); + + SyntaxDefinitionManager::instance() + ->add( { "TSX", + { "%.tsx$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "`", "`", "\\" }, "string" }, + { { "/[%+%-%*%^%!%=%&%|%?%:%;%,%(%[%{%<%>%\\].*%f[/]", + "/[igmsuyd\n]?[igmsuyd\n]?[igmsuyd\n]?", "\\" }, + "string" }, + { { "%f[^<]![%a_][%w%_%-]*" }, "keyword2" }, + { { "%f[^<][%a_][%w%_%-]*" }, "function" }, + { { "%f[^<]/[%a_][%w%_%-]*" }, "function" }, + { { "([%a_-][%w-_]*)(%\?\?)(=)%f[%{%\"]" }, + { "normal", "keyword", "normal", "operator" } }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "0x[%da-fA-F]+" }, "number" }, + { { "-?%d+[%d%.eE]*" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "(interface%s)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } }, + { { "(type%s)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } }, + { { "[%a_][%w_$]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + }, + {}, + "//" } ) + .setSymbols( ts.getSymbols() ) + .setLSPName( "typescriptreact" ) + .setAutoCloseXMLTags( true ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/typescript.hpp b/src/eepp/ui/doc/languages/typescript.hpp new file mode 100644 index 000000000..e2558b44e --- /dev/null +++ b/src/eepp/ui/doc/languages/typescript.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Typescript +#define EE_UI_DOC_Typescript + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addTypeScript(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/vue.cpp b/src/eepp/ui/doc/languages/vue.cpp new file mode 100644 index 000000000..486f706dd --- /dev/null +++ b/src/eepp/ui/doc/languages/vue.cpp @@ -0,0 +1,66 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addVue() { + + SyntaxDefinitionManager::instance() + ->add( { "Vue-HTML", + {}, + { + { { "%{%{%{", "%}%}%}" }, "function", "JavaScript" }, + { { "%{%{", "%}%}" }, "function", "JavaScript" }, + { { "" }, "comment" }, + { { "%f[^>][^<]", "%f[<]" }, "normal" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "0x[%da-fA-F]+" }, "number" }, + { { "-?%d+[%d%.]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "%f[^<]![%a_][%w%_%-]*" }, "keyword2" }, + { { "%f[^<][%a_][%w%_%-]*" }, "function" }, + { { "%f[^<]/[%a_][%w%_%-]*" }, "function" }, + { { "[%a_][%w_]*" }, "keyword" }, + { { "[/<>=]" }, "operator" }, + }, + {}, + "", + {} } ) + .setVisible( false ) + .setAutoCloseXMLTags( true ); + + SyntaxDefinitionManager::instance()->add( + { "Vue", + { "%.vue?$" }, + { + { { "<%s*[sS][cC][rR][iI][pP][tT]%s*>", "<%s*/%s*[sS][cC][rR][iI][pP][tT]>" }, + "function", + "JavaScript" }, + { { "<%s*[sS][tT][yY][lL][eE][^>]*>", "<%s*/%s*[sS][tT][yY][lL][eE]%s*>" }, + "function", + "CSS" }, + { { "<%s*[tT][eE][mM][pP][lL][aA][tT][eE][^>]*>", + "<%s*/%s*[tT][eE][mM][pP][lL][aA][tT][eE]%s*>" }, + "function", + "Vue-HTML" }, + { { "" }, "comment" }, + { { "%f[^>][^<]", "%f[<]" }, "normal" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "0x[%da-fA-F]+" }, "number" }, + { { "-?%d+[%d%.]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "%f[^<]![%a_][%w%_%-]*" }, "keyword2" }, + { { "%f[^<][%a_][%w%_%-]*" }, "function" }, + { { "%f[^<]/[%a_][%w%_%-]*" }, "function" }, + { { "[%a_][%w_]*" }, "keyword" }, + { { "[/<>=]" }, "operator" }, + }, + {}, + "", + {} } ); + +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/vue.hpp b/src/eepp/ui/doc/languages/vue.hpp new file mode 100644 index 000000000..2ac779c45 --- /dev/null +++ b/src/eepp/ui/doc/languages/vue.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Vue +#define EE_UI_DOC_Vue + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addVue(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/wren.cpp b/src/eepp/ui/doc/languages/wren.cpp new file mode 100644 index 000000000..17479829f --- /dev/null +++ b/src/eepp/ui/doc/languages/wren.cpp @@ -0,0 +1,41 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addWren() { + + SyntaxDefinitionManager::instance()->add( + + { "Wren", + { "%.wren$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?%.?%d+" }, "number" }, + { { "%.%.%.?" }, "operator" }, + { { "[<>!=]=" }, "operator" }, + { { "[%+%-=/%*%^%%<>!~|&?:]" }, "operator" }, + { { "[%a_][%w_]*%s*%f[(\"{]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "false", "literal" }, { "in", "keyword" }, { "for", "keyword" }, + { "while", "keyword" }, { "null", "literal" }, { "true", "literal" }, + { "else", "keyword" }, { "construct", "keyword" }, { "foreign", "keyword" }, + { "this", "keyword2" }, { "return", "keyword" }, { "var", "keyword" }, + { "import", "keyword" }, { "break", "keyword" }, { "class", "keyword" }, + { "is", "keyword" }, { "if", "keyword" }, { "static", "keyword" }, + { "super", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/wren.hpp b/src/eepp/ui/doc/languages/wren.hpp new file mode 100644 index 000000000..8e35651d7 --- /dev/null +++ b/src/eepp/ui/doc/languages/wren.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Wren +#define EE_UI_DOC_Wren + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addWren(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/xit.cpp b/src/eepp/ui/doc/languages/xit.cpp new file mode 100644 index 000000000..223ffcfdb --- /dev/null +++ b/src/eepp/ui/doc/languages/xit.cpp @@ -0,0 +1,53 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addXit() { + + SyntaxDefinitionManager::instance()->add( + + { "[x]it!", + { "%.xit$" }, + { + { { "%f[^%s%(]%-%>%s%d%d%d%d%-%d%d%-%d%d%f[\n%s%!%?%)]" }, "number" }, + { { "%f[^%s%(]%-%>%s%d%d%d%d%/%d%d%/%d%d%f[\n%s%!%?%)]" }, "number" }, + { { "%f[^%s%(]%-%>%s%d%d%d%d%-[wWqQ]?%d%d?%f[\n%s%!%?%)]" }, "number" }, + { { "%f[^%s%(]%-%>%s%d%d%d%d%/[wWqQ]?%d%d?%f[\n%s%!%?%)]" }, "number" }, + { { "%f[^%s%(]%-%>%s%d%d%d%d%f[\n%s%!%?%)]" }, "number" }, + { { "^(%[%s%]%s)([%.!]+)%s" }, { "operator", "operator", "red" } }, + { { "^(%[x%]%s)([%.!]+)%s" }, { "function", "function", "red" } }, + { { "^(%[@%]%s)([%.!]+)%s" }, { "keyword", "keyword", "red" } }, + { { "^(%[~%]%s)([%.!]+)%s" }, { "comment", "comment", "red" } }, + { { "^(%[%.%]%s)([%.!]+)%s" }, { "comment", "comment", "red" } }, + { { "%#[%wñàáâãäåèéêëìíîïòóôõöùúûüýÿÑÀÁÂÃÄÅÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝ%-%_]+%=\"", "\"" }, + "string" }, + { { "%#[%wñàáâãäåèéêëìíîïòóôõöùúûüýÿÑÀÁÂÃÄÅÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝ%-%_]+%='", "'" }, + "string" }, + { { "%#[%wñàáâãäåèéêëìíîïòóôõöùúûüýÿÑÀÁÂÃÄÅÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝ%-%_]+%=[%w%-%_]*" }, + "string" }, + { { "%#[%wñàáâãäåèéêëìíîïòóôõöùúûüýÿÑÀÁÂÃÄÅÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝ%-%_]+" }, "string" }, + { { "^%[%s%]%s" }, "operator" }, + { { "^%[x%]%s" }, "function" }, + { { "^%[@%]%s" }, "keyword" }, + { { "^%[~%]%s" }, "comment" }, + { { "^%[%?%]%s" }, "warning" }, + { { "^%[%.%]%s" }, "notice" }, + { { "^[%wñàáâãäåèéêëìíîïòóôõöùúûüýÿÑÀÁÂÃÄÅÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝ][%" + "wñàáâãäåèéêëìíîïòóôõöùúûüýÿÑÀÁÂÃÄÅÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝ%s%p]*%f[\n]" }, + "underline" }, + { { "https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/?[%w_.~!*:@&+$/" + "?%%#=-]*" }, + "link" }, + + }, + { + + }, + "", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/xit.hpp b/src/eepp/ui/doc/languages/xit.hpp new file mode 100644 index 000000000..95b682da0 --- /dev/null +++ b/src/eepp/ui/doc/languages/xit.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Xit +#define EE_UI_DOC_Xit + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addXit(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/yaml.cpp b/src/eepp/ui/doc/languages/yaml.cpp new file mode 100644 index 000000000..4d1370f38 --- /dev/null +++ b/src/eepp/ui/doc/languages/yaml.cpp @@ -0,0 +1,52 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addYAML() { + + SyntaxDefinitionManager::instance()->add( + + { "YAML", + { "%.yml$", "%.yaml$" }, + { + { { "#", "\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "%-?%.inf" }, "number" }, + { { "%.NaN" }, "number" }, + { { "(%&)(%g+)" }, { "normal", "keyword", "literal" } }, + { { "!%g+" }, "keyword" }, + { { "<<" }, "literal" }, + { { "https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/?[%w_.~!*:@&+$/" + "?%%#=-]*" }, + "link" }, + { { "([%s]%*)([%w%d_]+)" }, { "keyword", "keyword", "keyword2" } }, + { { "(%*)([%w%d_]+)" }, { "keyword", "keyword", "literal" } }, + { { "([%[%{])(%s*[%w%d]+%g+%s*)(:%s)" }, + { "keyword", "operator", "operator", "keyword" } }, + { { "([%s][%w%d]+%g+%s*)(:%s)" }, { "keyword", "keyword", "operator" } }, + { { "([%w%d]+%g+%s*)(:%s)" }, { "keyword", "keyword", "operator" } }, + { { "0%d+" }, "number" }, + { { "0x%x+" }, "number" }, + { { "[%+%-]?%d+[,%.eE:%+%d]*%d+" }, "number" }, + { { "[%*%|%!>%%]" }, "keyword" }, + { { "[%-:%?%*%{%}%[%]]" }, "operator" }, + { { "([%d%a_][%g_]*)([%]%},])" }, { "string", "operator", "operator" } }, + { { "[%d%a$/_][%g_]*" }, "string" }, + + }, + { + { "false", "number" }, + { "n", "number" }, + { "y", "number" }, + { "true", "number" }, + + }, + "#", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/yaml.hpp b/src/eepp/ui/doc/languages/yaml.hpp new file mode 100644 index 000000000..7fdafa47a --- /dev/null +++ b/src/eepp/ui/doc/languages/yaml.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Yaml +#define EE_UI_DOC_Yaml + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addYAML(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp index a8bea8b40..dc813f4e2 100644 --- a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp +++ b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp @@ -1,4 +1,3 @@ -#include #include #include #include @@ -9,52 +8,85 @@ #include #include #include +#include +#include +#include +#include +#include #include +#include #include #include +#include +#include #include #include +#include #include #include #include +#include #include #include +#include +#include #include #include #include +#include #include +#include +#include +#include +#include #include #include +#include #include +#include +#include #include +#include #include #include +#include #include +#include #include #include #include +#include #include #include #include #include +#include +#include #include +#include #include #include +#include +#include #include #include #include #include #include #include +#include #include #include #include #include +#include +#include #include +#include #include +#include #include #include -#include #include using namespace EE::System; @@ -70,1617 +102,6 @@ static void addPlainText() { SyntaxDefinitionManager::instance()->add( { "Plain Text", {}, {}, {}, "", {}, "plaintext" } ); } -static void addC() { - SyntaxDefinitionManager::instance()->add( - { "C", - { "%.c$", "%.C", "%.h$", "%.icc" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "^%s*(#include)%s+([<%\"][%w%d%.%\\%/%_%-]+[>%\"])" }, - { "keyword", "keyword", "literal" } }, - { { "^%s*(#e?l?n?d?ifn?d?e?f?)%s+" }, { "keyword", "keyword", "literal" } }, - { { "^%s*(#define)%s*" }, { "keyword", "keyword", "literal" } }, - { { "^%s*(#else)%s*" }, { "keyword", "keyword", "literal" } }, - { { "^%s*#", "[^\\]\n" }, "comment" }, - { { "\"", "[\"\n]", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { { "if", "keyword" }, { "then", "keyword" }, { "else", "keyword" }, - { "elseif", "keyword" }, { "do", "keyword" }, { "while", "keyword" }, - { "for", "keyword" }, { "break", "keyword" }, { "continue", "keyword" }, - { "return", "keyword" }, { "goto", "keyword" }, { "struct", "keyword" }, - { "union", "keyword" }, { "typedef", "keyword" }, { "enum", "keyword" }, - { "extern", "keyword" }, { "static", "keyword" }, { "volatile", "keyword" }, - { "const", "keyword" }, { "inline", "keyword" }, { "switch", "keyword" }, - { "case", "keyword" }, { "default", "keyword" }, { "auto", "keyword" }, - { "const", "keyword" }, { "void", "keyword" }, { "int", "keyword2" }, - { "short", "keyword2" }, { "long", "keyword2" }, { "float", "keyword2" }, - { "double", "keyword2" }, { "char", "keyword2" }, { "unsigned", "keyword2" }, - { "bool", "keyword2" }, { "true", "literal" }, { "false", "literal" }, - { "NULL", "literal" }, { "uint64_t", "keyword2" }, { "uint32_t", "keyword2" }, - { "uint16_t", "keyword2" }, { "uint8_t", "keyword2" }, { "int64_t", "keyword2" }, - { "int32_t", "keyword2" }, { "int16_t", "keyword2" }, { "int8_t", "keyword2" } }, - "//" } ); -} - -static void addLua() { - SyntaxDefinitionManager::instance()->add( - { "Lua", - { "%.lua$" }, - { - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "%[%[", "%]%]" }, "string" }, - { { "%-%-%[%[", "%]%]" }, "comment" }, - { { "%-%-.-\n" }, "comment" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "%.%.%.?" }, "operator" }, - { { "[<>~=]=" }, "operator" }, - { { "[%+%-=/%*%^%%#<>]" }, "operator" }, - { { "[%a_][%w_]*%s*%f[(\"{]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - { { "::[%a_][%w_]*::" }, "function" }, - }, - { - { "if", "keyword" }, { "then", "keyword" }, { "else", "keyword" }, - { "elseif", "keyword" }, { "end", "keyword" }, { "do", "keyword" }, - { "function", "keyword" }, { "repeat", "keyword" }, { "until", "keyword" }, - { "while", "keyword" }, { "for", "keyword" }, { "break", "keyword" }, - { "return", "keyword" }, { "local", "keyword" }, { "in", "keyword" }, - { "not", "keyword" }, { "and", "keyword" }, { "or", "keyword" }, - { "goto", "keyword" }, { "self", "keyword2" }, { "true", "literal" }, - { "false", "literal" }, { "nil", "literal" }, - }, - "--", - { "^#!.*[ /]lua" } } ); -} - -static void addJavaScript() { - SyntaxDefinitionManager::instance()->add( - { "JavaScript", - { "%.js$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "`", "`", "\\" }, "string" }, - { { "/[%+%-%*%^%!%=%&%|%?%:%;%,%(%[%{%<%>%\\].*%f[/]", - "/[igmsuyd\n]?[igmsuyd\n]?[igmsuyd\n]?", "\\" }, - "string" }, - { { "0x[%da-fA-F]+" }, "number" }, - { { "-?%d+[%d%.eE]*" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "([%w_][%w_]+)%.([%w_][%w%d_]*)%s*(=)%s*(function)" }, - { "normal", "keyword2", "function", "operator", "keyword" } }, - { { "([%w_][%w_]+)%.([%w_][%w%d_]*)%s*(=)%s*(async%s*function)" }, - { "normal", "keyword2", "function", "operator", "keyword" } }, - { { "([%w_][%w_]+)%.([%w_][%w%d_]*)%s*(=)%s*%f[(]" }, - { "normal", "keyword2", "function", "operator" } }, - { { "([%w_][%w_]+)%.([%w_][%w%d_]*)%s*(=)%s*(async)%s*%f[(]" }, - { "normal", "keyword2", "function", "operator", "function" } }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { { "arguments", "keyword2" }, { "async", "keyword" }, { "await", "keyword" }, - { "break", "keyword" }, { "case", "keyword" }, { "catch", "keyword" }, - { "class", "keyword" }, { "const", "keyword" }, { "continue", "keyword" }, - { "debugger", "keyword" }, { "default", "keyword" }, { "delete", "keyword" }, - { "do", "keyword" }, { "else", "keyword" }, { "export", "keyword" }, - { "extends", "keyword" }, { "false", "literal" }, { "finally", "keyword" }, - { "for", "keyword" }, { "get", "keyword" }, { "if", "keyword" }, - { "import", "keyword" }, { "in", "keyword" }, { "Infinity", "keyword2" }, - { "instanceof", "keyword" }, { "let", "keyword" }, { "NaN", "keyword2" }, - { "new", "keyword" }, { "null", "literal" }, { "return", "keyword" }, - { "set", "keyword" }, { "super", "keyword" }, { "static", "keyword" }, - { "switch", "keyword" }, { "this", "keyword2" }, { "throw", "keyword" }, - { "true", "literal" }, { "try", "keyword" }, { "typeof", "keyword" }, - { "undefined", "literal" }, { "var", "keyword" }, { "void", "keyword" }, - { "while", "keyword" }, { "with", "keyword" }, { "yield", "keyword" }, - { "implements", "keyword" }, { "Array", "keyword2" }, { "any", "keyword" }, - { "from", "keyword" }, { "public", "keyword" }, { "private", "keyword" }, - { "declare", "keyword" }, { "namespace", "keyword" }, { "protected", "keyword" }, - { "enum", "keyword" }, { "function", "keyword" }, { "of", "keyword" } }, - "//" } ); -} - -static void addJSON() { - SyntaxDefinitionManager::instance()->add( - { "JSON", - { "%.json$", "%.cson$", "%.webmanifest" }, - { - { { "(%b\"\")(:)" }, { "normal", "keyword", "operator" } }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "`", "`", "\\" }, "string" }, - { { "0x[%da-fA-F]+" }, "number" }, - { { "-?%d+[%d%.eE]*" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "[%[%]%{%}]" }, "operator" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { { "true", "literal" }, { "false", "literal" } }, - "//" } ); -} - -static void addTypeScript() { - SyntaxDefinition& ts = SyntaxDefinitionManager::instance()->add( - { "TypeScript", - { "%.ts$", "%.d.ts$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "`", "`", "\\" }, "string" }, - { { "/[%+%-%*%^%!%=%&%|%?%:%;%,%(%[%{%<%>%\\].*%f[/]", - "/[igmsuyd\n]?[igmsuyd\n]?[igmsuyd\n]?", "\\" }, - "string" }, - { { "0x[%da-fA-F]+" }, "number" }, - { { "-?%d+[%d%.eE]*" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "(interface%s)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } }, - { { "(type%s)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } }, - { { "[%a_][%w_$]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { { "any", "keyword2" }, { "arguments", "keyword2" }, { "as", "keyword" }, - { "async", "keyword" }, { "await", "keyword" }, { "boolean", "keyword2" }, - { "break", "keyword" }, { "case", "keyword" }, { "catch", "keyword" }, - { "class", "keyword" }, { "const", "keyword" }, { "constructor", "function" }, - { "continue", "keyword" }, { "debugger", "keyword" }, { "declare", "keyword" }, - { "default", "keyword" }, { "delete", "keyword" }, { "do", "keyword" }, - { "else", "keyword" }, { "enum", "keyword" }, { "export", "keyword" }, - { "extends", "keyword" }, { "false", "literal" }, { "finally", "keyword" }, - { "for", "keyword" }, { "from", "keyword" }, { "function", "keyword" }, - { "get", "keyword" }, { "if", "keyword" }, { "implements", "keyword" }, - { "import", "keyword" }, { "in", "keyword" }, { "Infinity", "keyword2" }, - { "instanceof", "keyword" }, { "interface", "keyword" }, { "let", "keyword" }, - { "module", "keyword" }, { "new", "keyword" }, { "null", "literal" }, - { "number", "keyword2" }, { "of", "keyword" }, { "package", "keyword" }, - { "private", "keyword" }, { "protected", "keyword" }, { "public", "keyword" }, - { "require", "keyword" }, { "return", "keyword" }, { "set", "keyword" }, - { "static", "keyword" }, { "string", "keyword2" }, { "super", "keyword" }, - { "switch", "keyword" }, { "symbol", "keyword2" }, { "this", "keyword2" }, - { "throw", "keyword" }, { "true", "literal" }, { "try", "keyword" }, - { "type", "keyword2" }, { "typeof", "keyword" }, { "undefined", "literal" }, - { "var", "keyword" }, { "void", "keyword" }, { "while", "keyword" }, - { "with", "keyword" }, { "yield", "keyword" }, { "unknown", "keyword2" }, - { "namespace", "keyword" }, { "abstract", "keyword" }, { "readonly", "keyword" } }, - "//" } ); - - SyntaxDefinitionManager::instance() - ->add( { "TSX", - { "%.tsx$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "`", "`", "\\" }, "string" }, - { { "/[%+%-%*%^%!%=%&%|%?%:%;%,%(%[%{%<%>%\\].*%f[/]", - "/[igmsuyd\n]?[igmsuyd\n]?[igmsuyd\n]?", "\\" }, - "string" }, - { { "%f[^<]![%a_][%w%_%-]*" }, "keyword2" }, - { { "%f[^<][%a_][%w%_%-]*" }, "function" }, - { { "%f[^<]/[%a_][%w%_%-]*" }, "function" }, - { { "([%a_-][%w-_]*)(%\?\?)(=)%f[%{%\"]" }, - { "normal", "keyword", "normal", "operator" } }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "0x[%da-fA-F]+" }, "number" }, - { { "-?%d+[%d%.eE]*" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "(interface%s)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } }, - { { "(type%s)([%a_][%w_]*)" }, { "normal", "keyword", "keyword2" } }, - { { "[%a_][%w_$]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - {}, - "//" } ) - .setSymbols( ts.getSymbols() ) - .setLSPName( "typescriptreact" ) - .setAutoCloseXMLTags( true ); - ; -} - -static void addPython() { - SyntaxDefinitionManager::instance()->add( - { "Python", - { "%.py$", "%.pyw$", "%.bry$" }, - { - { { "#", "\n" }, "comment" }, - { { "[ruU]?\"", "\"", "\\" }, "string" }, - { { "[ruU]?'", "'", "\\" }, "string" }, - { { "\"\"\"", "\"\"\"" }, "string" }, - { { "0x[%da-fA-F]+" }, "number" }, - { { "-?%d+[%d%.eE]*" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "class", "keyword" }, { "finally", "keyword" }, { "is", "keyword" }, - { "return", "keyword" }, { "continue", "keyword" }, { "for", "keyword" }, - { "lambda", "keyword" }, { "try", "keyword" }, { "def", "keyword" }, - { "from", "keyword" }, { "nonlocal", "keyword" }, { "while", "keyword" }, - { "and", "keyword" }, { "global", "keyword" }, { "not", "keyword" }, - { "with", "keyword" }, { "as", "keyword" }, { "elif", "keyword" }, - { "if", "keyword" }, { "or", "keyword" }, { "else", "keyword" }, - { "import", "keyword" }, { "pass", "keyword" }, { "break", "keyword" }, - { "except", "keyword" }, { "in", "keyword" }, { "del", "keyword" }, - { "raise", "keyword" }, { "yield", "keyword" }, { "assert", "keyword" }, - { "self", "keyword2" }, { "None", "literal" }, { "True", "literal" }, - { "False", "literal" }, - }, - "#", - { "^#!.*[ /]python", "^#!.*[ /]python3" } } ); -} - -static void addBash() { - SyntaxDefinitionManager::instance()->add( - - { "Shell script", - { "%.sh$", "%.bash$", "^%.bashrc$", "^%.bash_profile$", "^%.profile$", "%.zsh$", - "%.fish$", "^PKGBUILD$" }, - { - { { "$[%a_@*#][%w_]*" }, "keyword2" }, - { { "#.*\n" }, "comment" }, - { { "<<%-?%s*EOF", "EOF" }, "string" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "`", "`", "\\" }, "string" }, - { { "%f[%w_%.%/]%d[%d%.]*%f[^%w_%.]" }, "number" }, - { { "[!<>|&%[%]:=*]" }, "operator" }, - { { "%f[%S][%+%-][%w%-_:]+" }, "function" }, - { { "%f[%S][%+%-][%w%-_]+%f[=]" }, "function" }, - { { "(%s%-%a[%w_%-]*%s+)(%d[%d%.]+)" }, { "normal", "function", "number" } }, - { { "(%s%-%a[%w_%-]*%s+)(%a[%a%-_:=]+)" }, { "normal", "function", "symbol" } }, - { { "[_%a][%w_]+%f[%+=]" }, "keyword2" }, - { { "${.-}" }, "keyword2" }, - { { "$[%d$%a_@*][%w_]*" }, "keyword2" }, - { { "[%a_%-][%w_%-]*[%s]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - { { "%s+" }, "normal" }, - { { "%w+%f[%s]" }, "normal" }, - - }, - { - { "until", "keyword" }, { "unset", "keyword" }, { "unalias", "keyword" }, - { "type", "keyword" }, { "time", "keyword" }, { "test", "keyword" }, - { "source", "keyword" }, { "true", "literal" }, { "shift", "keyword" }, - { "set", "keyword" }, { "then", "keyword" }, { "select", "keyword" }, - { "readarray", "keyword" }, { "pwd", "keyword" }, { "mapfile", "keyword" }, - { "local", "keyword" }, { "return", "keyword" }, { "let", "keyword" }, - { "fi", "keyword" }, { "getopts", "keyword" }, { "echo", "keyword" }, - { "do", "keyword" }, { "eval", "keyword" }, { "elif", "keyword" }, - { "declare", "keyword" }, { "cd", "keyword" }, { "case", "keyword" }, - { "printf", "keyword" }, { "break", "keyword" }, { "exec", "keyword" }, - { "alias", "keyword" }, { "exit", "keyword" }, { "esac", "keyword" }, - { "export", "keyword" }, { "for", "keyword" }, { "enable", "keyword" }, - { "jobs", "keyword" }, { "function", "keyword" }, { "while", "keyword" }, - { "read", "keyword" }, { "hash", "keyword" }, { "help", "keyword" }, - { "history", "keyword" }, { "done", "keyword" }, { "if", "keyword" }, - { "false", "literal" }, { "in", "keyword" }, { "else", "keyword" }, - { "continue", "keyword" }, { "kill", "keyword" }, - - }, - "#", - { "^#!.*[ /]bash", "^#!.*[ /]sh" }, - "shellscript" } ); -} - -static void addCPP() { - SyntaxDefinitionManager::instance()->add( - { "C++", - { "%.cpp$", "%.cc$", "%.cxx$", "%.c++$", "%.hh$", "%.inl$", "%.hxx$", "%.hpp$", - "%.h++$" }, - { - { { "R%\"xml%(", "%)xml%\"" }, "function", "XML" }, - { { "R%\"css%(", "%)css%\"" }, "function", "CSS" }, - { { "R%\"html%(", "%)html%\"" }, "function", "HTML" }, - { { "R%\"json%(", "%)json%\"" }, "function", "JSON" }, - { { "R\"[%a-\"]+%(", "%)[%a-\"]+%\"" }, "string" }, - { { "R\"%(", "%)\"" }, "string" }, - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "[\"\n]", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "^%s*(#include)%s+([<%\"][%w%d%.%\\%/%_%-]+[>%\"])" }, - { "keyword", "keyword", "literal" } }, - { { "^%s*(#e?l?n?d?ifn?d?e?f?)%s+" }, { "keyword", "keyword", "literal" } }, - { { "^%s*(#define)%s*" }, { "keyword", "keyword", "literal" } }, - { { "^%s*(#else)%s*" }, { "keyword", "keyword", "literal" } }, - { { "^%s*#", "[^\\]\n" }, "comment" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "std%:%:[%w_]*" }, "keyword2" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "alignof", "keyword" }, - { "alignas", "keyword" }, - { "and", "keyword" }, - { "and_eq", "keyword" }, - { "not", "keyword" }, - { "not_eq", "keyword" }, - { "or", "keyword" }, - { "or_eq", "keyword" }, - { "xor", "keyword" }, - { "xor_eq", "keyword" }, - { "private", "keyword" }, - { "protected", "keyword" }, - { "public", "keyword" }, - { "register", "keyword" }, - { "nullptr", "keyword" }, - { "operator", "keyword" }, - { "asm", "keyword" }, - { "bitand", "keyword" }, - { "bitor", "keyword" }, - { "catch", "keyword" }, - { "throw", "keyword" }, - { "try", "keyword" }, - { "class", "keyword" }, - { "compl", "keyword" }, - { "explicit", "keyword" }, - { "export", "keyword" }, - { "concept", "keyword" }, - { "consteval", "keyword" }, - { "constexpr", "keyword" }, - { "constinit", "keyword" }, - { "const_cast", "keyword" }, - { "dynamic_cast", "keyword" }, - { "reinterpret_cast", "keyword" }, - { "static_cast", "keyword" }, - { "static_assert", "keyword" }, - { "template", "keyword" }, - { "this", "keyword" }, - { "thread_local", "keyword" }, - { "requires", "keyword" }, - { "co_wait", "keyword" }, - { "co_return", "keyword" }, - { "co_yield", "keyword" }, - { "decltype", "keyword" }, - { "delete", "keyword" }, - { "export", "keyword" }, - { "friend", "keyword" }, - { "typeid", "keyword" }, - { "typename", "keyword" }, - { "mutable", "keyword" }, - { "virtual", "keyword" }, - { "using", "keyword" }, - { "namespace", "keyword" }, - { "new", "keyword" }, - { "noexcept", "keyword" }, - { "if", "keyword" }, - { "then", "keyword" }, - { "else", "keyword" }, - { "elseif", "keyword" }, - { "do", "keyword" }, - { "while", "keyword" }, - { "for", "keyword" }, - { "break", "keyword" }, - { "continue", "keyword" }, - { "return", "keyword" }, - { "goto", "keyword" }, - { "struct", "keyword" }, - { "union", "keyword" }, - { "typedef", "keyword" }, - { "enum", "keyword" }, - { "extern", "keyword" }, - { "static", "keyword" }, - { "volatile", "keyword" }, - { "const", "keyword" }, - { "inline", "keyword" }, - { "switch", "keyword" }, - { "case", "keyword" }, - { "default", "keyword" }, - { "auto", "keyword2" }, - { "const", "keyword" }, - { "void", "keyword" }, - { "override", "keyword" }, - { "int", "keyword2" }, - { "short", "keyword2" }, - { "long", "keyword2" }, - { "float", "keyword2" }, - { "double", "keyword2" }, - { "char", "keyword2" }, - { "unsigned", "keyword2" }, - { "bool", "keyword2" }, - { "true", "keyword2" }, - { "false", "keyword2" }, - { "wchar_t", "keyword2" }, - { "char8_t", "keyword2" }, - { "char16_t", "keyword2" }, - { "char32_t", "keyword2" }, - { "size_t", "keyword2" }, - { "int16_t", "keyword2" }, - { "int32_t", "keyword2" }, - { "int64_t", "keyword2" }, - { "uint16_t", "keyword2" }, - { "uint32_t", "keyword2" }, - { "uint64_t", "keyword2" }, - { "String", "keyword2" }, - { "Int8", "keyword2" }, - { "Uint8", "keyword2" }, - { "Int16", "keyword2" }, - { "Uint16", "keyword2" }, - { "Int32", "keyword2" }, - { "Uint32", "keyword2" }, - { "Int64", "keyword2" }, - { "Uint64", "keyword2" }, - { "Float", "keyword2" }, - { "Color", "keyword2" }, - { "Vector2f", "keyword2" }, - { "Vector2i", "keyword2" }, - { "Recti", "keyword2" }, - { "Rectf", "keyword2" }, - { "NULL", "literal" }, - }, - "//", - {}, - "cpp" } ); -} - -static void addPHP() { - SyntaxDefinitionManager::instance() - ->add( { "PHP", - { "%.php$", "%.php3$", "%.php4$", "%.php5$" }, - { - { { "<%s*[sS][cC][rR][iI][pP][tT]%s+[tT][yY][pP][eE]%s*=%s*['\"]%a+/" - "[jJ][aA][vV][aA][sS][cC][rR][iI][pP][tT]['\"]%s*>", - "<%s*/[sS][cC][rR][iI][pP][tT]>" }, - "function", - "JavaScript" }, - { { "<%s*[sS][cC][rR][iI][pP][tT]%s*>", "<%s*/%s*[sS][cC][rR][iI][pP][tT]>" }, - "function", - "JavaScript" }, - { { "<%s*[sS][tT][yY][lL][eE][^>]*>", "<%s*/%s*[sS][tT][yY][lL][eE]%s*>" }, - "function", - "CSS" }, - { { "<%?p?h?p?", "%?>" }, "function", "PHPCore" }, - { { "" }, "comment" }, - { { "%f[^>][^<]", "%f[<]" }, "normal" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "0x[%da-fA-F]+" }, "number" }, - { { "-?%d+[%d%.]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "%f[^<]![%a_][%w%_%-]*" }, "keyword2" }, - { { "%f[^<][%a_][%w%_%-]*" }, "function" }, - { { "%f[^<]/[%a_][%w%_%-]*" }, "function" }, - { { "[%a_][%w_]*" }, "keyword" }, - { { "[/<>=]" }, "operator" }, - }, - {}, - "", - { "^#!.*[ /]php" } } ) - .setAutoCloseXMLTags( true ); - - SyntaxDefinitionManager::instance() - ->add( { "PHPCore", - {}, - { - { { "<%?p?h?p?" }, "function" }, - { { "%?>", "<%?p?h?p?" }, "function", "HTML" }, - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "#.-\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "%\\x[%da-fA-F]+" }, "number" }, - { { "-?%d+[%d%.eE]*" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "[%.%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - { { "%$[%a][%w_]*" }, "keyword2" }, - }, - { { "return", "keyword" }, { "if", "keyword" }, - { "else", "keyword" }, { "elseif", "keyword" }, - { "endif", "keyword" }, { "declare", "keyword" }, - { "enddeclare", "keyword" }, { "switch", "keyword" }, - { "endswitch", "keyword" }, { "as", "keyword" }, - { "do", "keyword" }, { "for", "keyword" }, - { "endfor", "keyword" }, { "foreach", "keyword" }, - { "endforeach", "keyword" }, { "while", "keyword" }, - { "endwhile", "keyword" }, { "switch", "keyword" }, - { "case", "keyword" }, { "continue", "keyword" }, - { "default", "keyword" }, { "break", "keyword" }, - { "exit", "keyword" }, { "goto", "keyword" }, - - { "catch", "keyword" }, { "throw", "keyword" }, - { "try", "keyword" }, { "finally", "keyword" }, - - { "class", "keyword" }, { "trait", "keyword" }, - { "interface", "keyword" }, { "public", "keyword" }, - { "static", "keyword" }, { "protected", "keyword" }, - { "private", "keyword" }, { "abstract", "keyword" }, - { "final", "keyword" }, - - { "function", "keyword2" }, { "global", "keyword2" }, - { "var", "keyword2" }, { "const", "keyword2" }, - { "bool", "keyword2" }, { "boolean", "keyword2" }, - { "int", "keyword2" }, { "integer", "keyword2" }, - { "real", "keyword2" }, { "double", "keyword2" }, - { "float", "keyword2" }, { "string", "keyword2" }, - { "array", "keyword2" }, { "object", "keyword2" }, - { "callable", "keyword2" }, { "iterable", "keyword2" }, - - { "namespace", "keyword2" }, { "extends", "keyword2" }, - { "implements", "keyword2" }, { "instanceof", "keyword2" }, - { "require", "keyword2" }, { "require_once", "keyword2" }, - { "include", "keyword2" }, { "include_once", "keyword2" }, - { "use", "keyword2" }, { "new", "keyword2" }, - { "clone", "keyword2" }, - - { "true", "literal" }, { "false", "literal" }, - { "NULL", "literal" }, { "parent", "literal" }, - { "self", "literal" }, { "echo", "function" } }, - "//", - {}, - "php" } ) - .setVisible( false ); -} - -static void addIni() { - SyntaxDefinitionManager::instance()->add( - { "Config File", - { "%.ini$", "%.conf$", "%.desktop$", "%.service$", "%.cfg$", "%.properties$", - "Doxyfile" }, - { { { "%s?#%x%x%x%x%x%x%x%x" }, "string" }, - { { "%s?#%x%x%x%x%x%x" }, "string" }, - { { "^#.-\n" }, "comment" }, - { { "^;.-\n" }, "comment" }, - { { "%s#.-\n" }, "comment" }, - { { "[%a_][%w-+_%s%p]-%f[=]" }, "keyword" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "^%[.-%]" }, "keyword2" }, - { { "%s%[.-%]" }, "keyword2" }, - { { "=" }, "operator" }, - { { "https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/?[%w_.~!*:@&+$/" - "?%%#=-]*" }, - "link" }, - { { "[a-z]+" }, "symbol" } }, - { { "true", "literal" }, { "false", "literal" } }, - "#", - { "^%[.-%]%f[^\n]" }, - "ini" } ); -} - -static void addMakefile() { - SyntaxDefinitionManager::instance()->add( - { "Makefile", - { "^[Mm]akefile$", "%.mk$", "%.make$", "%.mak$", "^Makefile%.am$", "^Makefile%.in$" }, - { - { { "#.*\n" }, "comment" }, - { { "[[.]]}" }, "normal" }, - { { "$[@^<%%?+|*]" }, "keyword2" }, - { { "$%(", "%)" }, "keyword" }, - { { "%f[%w_][%d%.]+%f[^%w_]" }, "number" }, - { { "%..*:" }, "keyword2" }, - { { ".*:=" }, "function" }, - { { ".*+=" }, "function" }, - { { ".*%s=" }, "function" }, - }, - {}, - "#" } ); -} - -static void addCSharp() { - SyntaxDefinitionManager::instance()->add( - { "C#", - { "%.cs$", "%.csx$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "[%$%@]?\"", "\"", "\\" }, "string" }, - { { "'\\x%x?%x?%x?%x'" }, "string" }, - { { "'\\u%x%x%x%x'" }, "string" }, - { { "'\\?.'" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "%?%?" }, "operator" }, - { { "%?%." }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { { "abstract", "keyword" }, { "as", "keyword" }, { "await", "keyword" }, - { "base", "keyword" }, { "break", "keyword" }, { "case", "keyword" }, - { "catch", "keyword" }, { "checked", "keyword" }, { "class", "keyword" }, - { "const", "keyword" }, { "continue", "keyword" }, { "default", "keyword" }, - { "delegate", "keyword" }, { "do", "keyword" }, { "else", "keyword" }, - { "enum", "keyword" }, { "event", "keyword" }, { "explicit", "keyword" }, - { "extern", "keyword" }, { "finally", "keyword" }, { "fixed", "keyword" }, - { "for", "keyword" }, { "foreach", "keyword" }, { "get", "keyword" }, - { "goto", "keyword" }, { "if", "keyword" }, { "implicit", "keyword" }, - { "in", "keyword" }, { "interface", "keyword" }, { "internal", "keyword" }, - { "is", "keyword" }, { "lock", "keyword" }, { "namespace", "keyword" }, - { "new", "keyword" }, { "operator", "keyword" }, { "out", "keyword" }, - { "override", "keyword" }, { "params", "keyword" }, { "private", "keyword" }, - { "protected", "keyword" }, { "public", "keyword" }, { "readonly", "keyword" }, - { "ref", "keyword" }, { "return", "keyword" }, { "sealed", "keyword" }, - { "set", "keyword" }, { "sizeof", "keyword" }, { "stackalloc", "keyword" }, - { "static", "keyword" }, { "struct", "keyword" }, { "switch", "keyword" }, - { "this", "keyword" }, { "throw", "keyword" }, { "try", "keyword" }, - { "typeof", "keyword" }, { "unchecked", "keyword" }, { "unsafe", "keyword" }, - { "using", "keyword" }, { "var", "keyword" }, { "virtual", "keyword" }, - { "void", "keyword" }, { "volatile", "keyword" }, { "where", "keyword" }, - { "while", "keyword" }, { "yield", "keyword" }, { "bool", "keyword2" }, - { "byte", "keyword2" }, { "char", "keyword2" }, { "decimal", "keyword2" }, - { "double", "keyword2" }, { "float", "keyword2" }, { "int", "keyword2" }, - { "long", "keyword2" }, { "object", "keyword2" }, { "sbyte", "keyword2" }, - { "short", "keyword2" }, { "string", "keyword2" }, { "uint", "keyword2" }, - { "ulong", "keyword2" }, { "ushort", "keyword2" }, { "true", "literal" }, - { "false", "literal" }, { "null", "literal" }, { "add", "keyword" }, - { "record", "keyword" }, { "remove", "keyword" }, { "partial", "keyword" }, - { "dynamic", "keyword" }, { "value", "keyword" }, { "global", "keyword" }, - { "when", "keyword" } }, - "//", - {}, - "csharp" } ); -} - -static void addGo() { - SyntaxDefinitionManager::instance()->add( - { "Go", - { "%.go$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "`", "`", "\\" }, "string" }, - { { "0[oO_][0-7]+" }, "number" }, - { { "-?0x[%x_]+" }, "number" }, - { { "-?%d+_%d" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { ":=" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "if", "keyword" }, { "else", "keyword" }, { "elseif", "keyword" }, - { "for", "keyword" }, { "continue", "keyword" }, { "return", "keyword" }, - { "struct", "keyword" }, { "switch", "keyword" }, { "case", "keyword" }, - { "default", "keyword" }, { "const", "keyword" }, { "package", "keyword" }, - { "import", "keyword" }, { "func", "keyword" }, { "var", "keyword" }, - { "type", "keyword" }, { "interface", "keyword" }, { "select", "keyword" }, - { "break", "keyword" }, { "range", "keyword" }, { "chan", "keyword" }, - { "defer", "keyword" }, { "go", "keyword" }, { "fallthrough", "keyword" }, - { "int", "keyword2" }, { "int64", "keyword2" }, { "int32", "keyword2" }, - { "int16", "keyword2" }, { "int8", "keyword2" }, { "uint", "keyword2" }, - { "uint64", "keyword2" }, { "uint32", "keyword2" }, { "uint16", "keyword2" }, - { "uint8", "keyword2" }, { "uintptr", "keyword2" }, { "float64", "keyword2" }, - { "float32", "keyword2" }, { "map", "keyword2" }, { "string", "keyword2" }, - { "rune", "keyword2" }, { "bool", "keyword2" }, { "byte", "keyword2" }, - { "error", "keyword2" }, { "complex64", "keyword2" }, { "complex128", "keyword2" }, - { "true", "literal" }, { "false", "literal" }, { "nil", "literal" }, - }, - "//" } ); -} - -static void addHaskell() { - SyntaxDefinitionManager::instance()->add( - { "Haskell", - { "%.hs$" }, - { - { { "%-%-", "\n" }, "comment" }, - { { "{%-", "%-}" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[!%#%$%%&*+./%<=>%?@\\%^|%-~:]" }, "operator" }, - { { "[%a_'][%w_']*" }, "symbol" }, - }, - { - { "as", "keyword" }, { "case", "keyword" }, { "of", "keyword" }, - { "class", "keyword" }, { "data", "keyword" }, { "default", "keyword" }, - { "deriving", "keyword" }, { "do", "keyword" }, { "forall", "keyword" }, - { "foreign", "keyword" }, { "hiding", "keyword" }, { "if", "keyword" }, - { "then", "keyword" }, { "else", "keyword" }, { "import", "keyword" }, - { "infix", "keyword" }, { "infixl", "keyword" }, { "infixr", "keyword" }, - { "let", "keyword" }, { "in", "keyword" }, { "mdo", "keyword" }, - { "module", "keyword" }, { "newtype", "keyword" }, { "qualified", "keyword" }, - { "type", "keyword" }, { "where", "keyword" }, - }, - "%-%-" } ); -} - -static void addLatex() { - SyntaxDefinitionManager::instance()->add( { "LaTeX", - { "%.tex$" }, - { - { { "%%", "\n" }, "comment" }, - { { "&" }, "operator" }, - { { "\\\\" }, "operator" }, - { { "%$", "%$" }, "operator" }, - { { "\\%[", "\\]" }, "operator" }, - { { "{", "}" }, "keyword" }, - { { "\\%w*" }, "keyword2" }, - }, - {}, - "%%" } ); -} - -static void addMeson() { - SyntaxDefinitionManager::instance()->add( { "Meson", - { "meson.build$", "^meson_options.txt$" }, - { - { { "#", "\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "'''", "'''" }, "string" }, - { { "0x[%da-fA-F]+" }, "number" }, - { { "-?%d+%d*" }, "number" }, - { { "[%+%-=/%%%*!]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "if", "keyword" }, - { "then", "keyword" }, - { "else", "keyword" }, - { "elif", "keyword" }, - { "endif", "keyword" }, - { "foreach", "keyword" }, - { "endforeach", "keyword" }, - { "break", "keyword" }, - { "continue", "keyword" }, - { "and", "keyword" }, - { "not", "keyword" }, - { "or", "keyword" }, - { "in", "keyword" }, - { "true", "literal" }, - { "false", "literal" }, - }, - "#" } ); -} - -static void addDiff() { - SyntaxDefinitionManager::instance()->add( { "Diff File", - { "%.diff$", "%.patch$" }, - { - { { "^%+%+%+%s.-\n" }, "keyword" }, - { { "^%-%-%-%s.-\n" }, "keyword" }, - { { "^diff%s.-\n" }, "string" }, - { { "^index%s.-\n" }, "comment" }, - { { "^@@.-\n" }, "number" }, - { { "^%+.-\n" }, "function" }, - { { "^%-.-\n" }, "keyword2" }, - }, - {}, - "", - {}, - "diff" } ); -} - -static void addJava() { - SyntaxDefinitionManager::instance()->add( - { "Java", - { "%.java$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "'\\x%x?%x?%x?%x'" }, "string" }, - { { "'\\u%x%x%x%x'" }, "string" }, - { { "'\\?.'" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "if", "keyword" }, { "then", "keyword" }, { "else", "keyword" }, - { "elseif", "keyword" }, { "do", "keyword" }, { "while", "keyword" }, - { "for", "keyword" }, { "new", "keyword" }, { "break", "keyword" }, - { "continue", "keyword" }, { "return", "keyword" }, { "goto", "keyword" }, - { "class", "keyword" }, { "implements", "keyword" }, { "extends", "keyword" }, - { "private", "keyword" }, { "protected", "keyword" }, { "public", "keyword" }, - { "abstract", "keyword" }, { "interface", "keyword" }, { "assert", "keyword" }, - { "import", "keyword" }, { "native", "keyword" }, { "package", "keyword" }, - { "super", "keyword" }, { "synchronized", "keyword" }, { "instanceof", "keyword" }, - { "enum", "keyword" }, { "catch", "keyword" }, { "throw", "keyword" }, - { "throws", "keyword" }, { "try", "keyword" }, { "transient", "keyword" }, - { "finally", "keyword" }, { "static", "keyword" }, { "volatile", "keyword" }, - { "final", "keyword" }, { "switch", "keyword" }, { "case", "keyword" }, - { "default", "keyword" }, { "void", "keyword" }, { "int", "keyword2" }, - { "short", "keyword2" }, { "byte", "keyword2" }, { "long", "keyword2" }, - { "float", "keyword2" }, { "double", "keyword2" }, { "char", "keyword2" }, - { "boolean", "keyword2" }, { "true", "literal" }, { "false", "literal" }, - { "null", "literal" }, - }, - "//" } ); -} - -static void addYAML() { - SyntaxDefinitionManager::instance()->add( - { "YAML", - { "%.yml$", "%.yaml$" }, - { - { { "#", "\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "%-?%.inf" }, "number" }, - { { "%.NaN" }, "number" }, - { { "(%&)(%g+)" }, { "normal", "keyword", "literal" } }, - { { "!%g+" }, "keyword" }, - { { "<<" }, "literal" }, - { { "https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/?[%w_.~!*:@&+$/" - "?%%#=-]*" }, - "link" }, - { { "([%s]%*)([%w%d_]+)" }, { "keyword", "keyword", "keyword2" } }, - { { "(%*)([%w%d_]+)" }, { "keyword", "keyword", "literal" } }, - { { "([%[%{])(%s*[%w%d]+%g+%s*)(:%s)" }, - { "keyword", "operator", "operator", "keyword" } }, - { { "([%s][%w%d]+%g+%s*)(:%s)" }, { "keyword", "keyword", "operator" } }, - { { "([%w%d]+%g+%s*)(:%s)" }, { "keyword", "keyword", "operator" } }, - { { "0%d+" }, "number" }, - { { "0x%x+" }, "number" }, - { { "[%+%-]?%d+[,%.eE:%+%d]*%d+" }, "number" }, - { { "[%*%|%!>%%]" }, "keyword" }, - { { "[%-:%?%*%{%}%[%]]" }, "operator" }, - { { "([%d%a_][%g_]*)([%]%},])" }, { "string", "operator", "operator" } }, - { { "[%d%a$/_][%g_]*" }, "string" }, - }, - { { "true", "number" }, { "false", "number" }, { "y", "number" }, { "n", "number" } }, - "#" } ); -} - -static void addObjetiveC() { - SyntaxDefinitionManager::instance()->add( - { "Objective-C", - { "%.m$" }, - { { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "#", "[^\\]\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "@[%a_][%w_]*" }, "keyword2" }, - { { "[%a_][%w_]*" }, "symbol" } }, - { { "if", "keyword" }, { "then", "keyword" }, { "else", "keyword" }, - { "elseif", "keyword" }, { "do", "keyword" }, { "while", "keyword" }, - { "for", "keyword" }, { "break", "keyword" }, { "continue", "keyword" }, - { "return", "keyword" }, { "goto", "keyword" }, { "struct", "keyword" }, - { "union", "keyword" }, { "typedef", "keyword" }, { "enum", "keyword" }, - { "extern", "keyword" }, { "static", "keyword" }, { "volatile", "keyword" }, - { "const", "keyword" }, { "inline", "keyword" }, { "switch", "keyword" }, - { "case", "keyword" }, { "default", "keyword" }, { "auto", "keyword" }, - { "const", "keyword" }, { "void", "keyword" }, { "int", "keyword2" }, - { "short", "keyword2" }, { "long", "keyword2" }, { "float", "keyword2" }, - { "double", "keyword2" }, { "char", "keyword2" }, { "unsigned", "keyword2" }, - { "bool", "keyword2" }, { "true", "literal" }, { "false", "literal" }, - { "NULL", "literal" }, { "nil", "literal" } }, - "//" } ); -} - -static void addDart() { - SyntaxDefinitionManager::instance()->add( - { "Dart", - { "%.dart$" }, - { - { { "//.-\n" }, "comment" }, - { { "///.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "%?%?" }, "operator" }, - { { "%?%." }, "operator" }, - { { "[%$%@]?\"", "\"", "\\" }, "string" }, - { { "'\\x%x?%x?%x?%x'" }, "string" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { { "await", "keyword" }, { "bool", "keyword2" }, { "break", "keyword" }, - { "case", "keyword" }, { "class", "keyword" }, { "const", "keyword" }, - { "continue", "keyword" }, { "default", "keyword" }, { "do", "keyword" }, - { "double", "keyword2" }, { "dynamic", "keyword2" }, { "else", "keyword" }, - { "enum", "keyword" }, { "false", "literal" }, { "final", "keyword" }, - { "finally", "keyword" }, { "for", "keyword" }, { "Function", "keyword2" }, - { "if", "keyword" }, { "in", "keyword" }, { "int", "keyword2" }, - { "List", "keyword2" }, { "Map", "keyword2" }, { "new", "keyword" }, - { "null", "literal" }, { "part of", "keyword" }, { "print", "keyword" }, - { "return", "keyword" }, { "static", "keyword" }, { "String", "keyword2" }, - { "switch", "keyword" }, { "then", "keyword" }, { "this", "keyword2" }, - { "true", "literal" }, { "void", "keyword" }, { "while", "keyword" }, - { "var", "keyword" } }, - "//" } ); -} - -static void addNim() { - std::vector nim_patterns; - UnorderedMap nim_symbols; - - const std::vector nim_number_patterns = { - "0[bB][01][01_]*", "0o[0-7][0-7_]*", - "0[xX]%x[%x_]*", "%d[%d_]*%.%d[%d_]*[eE][-+]?%d[%d_]*", - "%d[%d_]*%.%d[%d_]*", "%d[%d_]*", - }; - - std::vector nim_type_suffix_patterns; - const std::vector nim_num_number_list = { "", "8", "16", "32", "64" }; - for ( auto& num : nim_num_number_list ) - nim_type_suffix_patterns.push_back( "'?[fuiFUI]" + num ); - - for ( const auto& pattern : nim_number_patterns ) { - for ( const auto& suffix : nim_type_suffix_patterns ) - nim_patterns.push_back( { { pattern + suffix }, "literal" } ); - nim_patterns.push_back( { { pattern }, "literal" } ); - } - - const std::vector nim_keywords{ - "addr", "and", "as", "asm", "bind", "block", "break", "case", - "cast", "concept", "const", "continue", "converter", "defer", "discard", "distinct", - "div", "do", "elif", "else", "end", "enum", "except", "export", - "finally", "for", "from", "func", "if", "import", "in", "include", - "interface", "is", "isnot", "iterator", "let", "macro", "method", "mixin", - "mod", "not", "notin", "object", "of", "or", "out", "proc", - "ptr", "raise", "ref", "return", "shl", "shr", "static", "template", - "try", "tuple", "type", "using", "var", "when", "while", "xor", - "yield", - }; - - for ( const auto& keyword : nim_keywords ) - nim_symbols[keyword] = "keyword"; - - const std::vector nim_standard_types{ - "bool", "byte", "int", "int8", "int16", "int32", "int64", - "uint", "uint8", "uint16", "uint32", "uint64", "float", "float32", - "float64", "char", "string", "cstring", "pointer", "typedesc", "void", - "auto", "any", "untyped", "typed", "clong", "culong", "cchar", - "cschar", "cshort", "cint", "csize", "csize_t", "clonglong", "cfloat", - "cdouble", "clongdouble", "cuchar", "cushort", "cuint", "culonglong", "cstringArray", - }; - - for ( const auto& keyword : nim_standard_types ) - nim_symbols[keyword] = "keyword2"; - - const std::vector nim_standard_generic_types{ - "range", "array", "open[aA]rray", "varargs", "seq", "set", "sink", "lent", "owned", - }; - - for ( const auto& type : nim_standard_generic_types ) { - nim_patterns.push_back( { { type + "%f[%[]" }, "keyword2" } ); - nim_patterns.push_back( { { type + "+%f[%w]" }, "keyword2" } ); - } - - const std::vector nim_user_patterns{ - { { "##?%[", "]##?" }, "comment" }, - { { "##?.-\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "\"\"\"", "\"\"\"[^\"]" }, "string" }, - { { "'", "'", "\\" }, "literal" }, - { { "[a-zA-Z][a-zA-Z0-9_]*%f[(]" }, "function" }, - { { "[A-Z][a-zA-Z0-9_]*" }, "keyword2" }, - { { "[a-zA-Z][a-zA-Z0-9_]*" }, "symbol" }, - { { "%.%f[^.]" }, "normal" }, - { { ":%f[ ]" }, "normal" }, - { { "[=+%-*/<>@$~&%%|!?%^&.:\\]+" }, "operator" }, - }; - - nim_patterns.insert( nim_patterns.end(), nim_user_patterns.begin(), nim_user_patterns.end() ); - - SyntaxDefinitionManager::instance()->add( { - "Nim", - { "%.nim$", "%.nims$", "%.nimble$" }, - std::move( nim_patterns ), - std::move( nim_symbols ), - "#", - } ); -} - -static void addCMake() { - UnorderedMap cmake_symbols; - const std::vector cmake_keywords{ - "ANDROID", "APPLE", "BORLAND", "CACHE", "CYGWIN", "ENV", - "GHSMULTI", "IOS", "MINGW", "MSVC", "MSVC10", "MSVC11", - "MSVC12", "MSVC14", "MSVC60", "MSVC70", "MSVC71", "MSVC80", - "MSVC90", "MSYS", "UNIX", "WIN32", "WINCE", "XCODE", - "ABSTRACT", "ADVANCED", "AUTOMOC", "AUTORCC", "AUTOUIC", "BUNDLE", - "COST", "DEPENDS", "DEPRECATION", "DISABLED", "ENVIRONMENT", "EchoString", - "FOLDER", "FRAMEWORK", "GENERATED", "GNUtoMS", "HELPSTRING", "IMPORTED", - "KEEP_EXTENSION", "LABELS", "LANGUAGE", "LOCATION", "MACROS", "MEASUREMENT", - "MODIFIED", "NAME", "PREFIX", "PROCESSORS", "RESOURCE", "SOURCES", - "SOVERSION", "STRINGS", "SUBDIRECTORIES", "SUFFIX", "SYMBOLIC", "TESTS", - "TIMEOUT", "TYPE", "VALUE", "VARIABLES", "VERSION", "XCTEST" }; - - for ( const auto& keyword : cmake_keywords ) - cmake_symbols[keyword] = "keyword2"; - - const std::vector cmake_operators{ "AND", "OR", "NOT", "EQUAL", "MATCHES" }; - - for ( const auto& keyword : cmake_operators ) - cmake_symbols[keyword] = "operator"; - - const std::vector cmake_literals{ - "TRUE", "FALSE", "INTERFACE", "C", "CXX", "EXPR", "LIBTYPE", - "ON", "OFF", "WARNING", "REPLACE", "REGEX", "APPEND", "DEFINED", - "TOUPPER", "TOLOWER", "STREQUAL", "GLOB", "LIBRARY", "RUNTIME", "ARCHIVE", - "DESTINATION", "IMMEDIATE", "TARGET", "COMMAND", "STATUS" }; - - for ( const auto& keyword : cmake_literals ) - cmake_symbols[keyword] = "literal"; - - SyntaxDefinitionManager::instance()->add( { "CMake", - { "%.cmake$", "CMakeLists.txt$" }, - { - { { "#", "[^\\]\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "[%a_][%w_]*%s?%f[(]" }, "function" }, - { { "CMAKE_[%w%d_]+" }, "keyword" }, - { { "CTEST_[%w%d_]+" }, "keyword" }, - { { "%u[%u%d_]*_[%u%d_]+" }, "keyword" }, - { { "%${[%a_][%w_]*%}" }, "keyword2" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - std::move( cmake_symbols ), - "#", - { "^cmake_minimum_required.*%c" } } ); -} - -static void addJSX() { - SyntaxDefinitionManager::instance() - ->add( { "JSX", - { "%.jsx$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "`", "`", "\\" }, "string" }, - { { "/[%+%-%*%^%!%=%&%|%?%:%;%,%(%[%{%<%>%\\].*%f[/]", - "/[igmsuyd\n]?[igmsuyd\n]?[igmsuyd\n]?", "\\" }, - "string" }, - { { "%f[^<]![%a_][%w%_%-]*" }, "keyword2" }, - { { "%f[^<][%a_][%w%_%-]*" }, "function" }, - { { "%f[^<]/[%a_][%w%_%-]*" }, "function" }, - { { "([%a_-][%w-_]*)(%\?\?)(=)%f[%{%\"]" }, - { "normal", "keyword", "normal", "operator" } }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "0x[%da-fA-F]+" }, "number" }, - { { "-?%d+[%d%.eE]*" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "async", "keyword" }, { "await", "keyword" }, - { "break", "keyword" }, { "case", "keyword" }, - { "catch", "keyword" }, { "class", "keyword" }, - { "const", "keyword" }, { "continue", "keyword" }, - { "debugger", "keyword" }, { "default", "keyword" }, - { "delete", "keyword" }, { "do", "keyword" }, - { "else", "keyword" }, { "export", "keyword" }, - { "extends", "keyword" }, { "finally", "keyword" }, - { "for", "keyword" }, { "function", "keyword" }, - { "get", "keyword" }, { "if", "keyword" }, - { "import", "keyword" }, { "in", "keyword" }, - { "instanceof", "keyword" }, { "let", "keyword" }, - { "new", "keyword" }, { "return", "keyword" }, - { "set", "keyword" }, { "static", "keyword" }, - { "super", "keyword" }, { "switch", "keyword" }, - { "throw", "keyword" }, { "try", "keyword" }, - { "typeof", "keyword" }, { "var", "keyword" }, - { "void", "keyword" }, { "while", "keyword" }, - { "with", "keyword" }, { "yield", "keyword" }, - { "true", "literal" }, { "false", "literal" }, - { "null", "literal" }, { "undefined", "literal" }, - { "arguments", "keyword2" }, { "Infinity", "keyword2" }, - { "NaN", "keyword2" }, { "this", "keyword2" }, - }, - "//" } ) - .setAutoCloseXMLTags( true ) - .setLSPName( "javascriptreact" ); - ; -} - -static void addContainerfile() { - SyntaxDefinitionManager::instance()->add( { "Containerfile", - { "^[Cc]ontainerfile$", "^[dD]ockerfile$" }, - { { { "#.*\n" }, "comment" }, - { { "%[", "%]" }, "string" }, - { { "%sas%s" }, "literal" }, - { { "--platform=" }, "literal" }, - { { "--chown=" }, "literal" }, - { { "[%a_][%w_]*" }, "symbol" } }, - { - { "FROM", "keyword" }, - { "ARG", "keyword2" }, - { "ENV", "keyword2" }, - { "RUN", "keyword2" }, - { "ADD", "keyword2" }, - { "COPY", "keyword2" }, - { "WORKDIR", "keyword2" }, - { "USER", "keyword2" }, - { "LABEL", "keyword2" }, - { "EXPOSE", "keyword2" }, - { "VOLUME", "keyword2" }, - { "ONBUILD", "keyword2" }, - { "STOPSIGNAL", "keyword2" }, - { "HEALTHCHECK", "keyword2" }, - { "SHELL", "keyword2" }, - { "ENTRYPOINT", "function" }, - { "CMD", "function" }, - }, - "#", - {}, - "dockerfile" } ); -} - -static void addIgnore() { - SyntaxDefinitionManager::instance()->add( { ".ignore file", - { "%..*ignore$" }, - { - { { "^%s*#.*$" }, "comment" }, - { { "^%!.*$" }, "keyword" }, - }, - {}, - "#" } ); -} - -static void addPowerShell() { - SyntaxDefinitionManager::instance()->add( - { "PowerShell", - { "%.ps1$", "%.psm1$", "%.psd1$", "%.ps1xml$", "%.pssc$", "%.psrc$", "%.cdxml$" }, - { { { "#.*\n" }, "comment" }, - { { "[[\\.]]" }, "normal" }, - { { "\"", "\"" }, "string" }, - { { "'", "'" }, "string" }, - { { "%f[%w_][%d%.]+%f[^%w_]" }, "number" }, - { { "[%+=/%*%^%%<>!~|&,:]+" }, "operator" }, - { { "%f[%S]%-[%w%-%_]+" }, "function" }, - { { "[%u][%a]+[%-][%u][%a]+" }, "function" }, - { { "${.*}" }, "symbol" }, - { { "$[%a_@*][%w_]*" }, "keyword2" }, - { { "$[%$][%a]+" }, "keyword2" }, - { { "[%a_][%w_]*" }, "symbol" } }, - { { "if", "keyword" }, - { "else", "keyword" }, - { "elseif", "keyword" }, - { "switch", "keyword" }, - { "default", "keyword" }, - { "function", "keyword" }, - { "filter", "keyword" }, - { "workflow", "keyword" }, - { "configuration", "keyword" }, - { "class", "keyword" }, - { "enum", "keyword" }, - { "Parameter", "keyword" }, - { "ValidateScript", "keyword" }, - { "CmdletBinding", "keyword" }, - { "try", "keyword" }, - { "catch", "keyword" }, - { "finally", "keyword" }, - { "throw", "keyword" }, - { "while", "keyword" }, - { "for", "keyword" }, - { "do", "keyword" }, - { "until", "keyword" }, - { "break", "keyword" }, - { "continue", "keyword" }, - { "foreach", "keyword" }, - { "in", "keyword" }, - { "return", "keyword" }, - { "where", "function" }, - { "select", "function" }, - { "filter", "keyword" }, - { "trap", "keyword" }, - { "param", "keyword" }, - { "data", "keyword" }, - { "dynamicparam", "keyword" }, - { "begin", "function" }, - { "process", "function" }, - { "end", "function" }, - { "exit", "function" }, - { "inlinescript", "function" }, - { "parallel", "function" }, - { "sequence", "function" }, - { "true", "literal" }, - { "false", "literal" }, - { "TODO", "comment" }, - { "FIXME", "comment" }, - { "XXX", "comment" }, - { "TBD", "comment" }, - { "HACK", "comment" }, - { "NOTE", "comment" } }, - "#" } ); -} - -static void addWren() { - SyntaxDefinitionManager::instance()->add( - { "Wren", - { "%.wren$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?%.?%d+" }, "number" }, - { { "%.%.%.?" }, "operator" }, - { { "[<>!=]=" }, "operator" }, - { { "[%+%-=/%*%^%%<>!~|&?:]" }, "operator" }, - { { "[%a_][%w_]*%s*%f[(\"{]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "break", "keyword" }, { "class", "keyword" }, { "construct", "keyword" }, - { "else", "keyword" }, { "for", "keyword" }, { "foreign", "keyword" }, - { "if", "keyword" }, { "import", "keyword" }, { "in", "keyword" }, - { "is", "keyword" }, { "return", "keyword" }, { "static", "keyword" }, - { "super", "keyword" }, { "var", "keyword" }, { "while", "keyword" }, - { "this", "keyword2" }, { "true", "literal" }, { "false", "literal" }, - { "null", "literal" }, - }, - "//" } ); -} - -static void addEnv() { - SyntaxDefinitionManager::instance()->add( - { "Environment File", - { "%.env$", "%.env.[%w%-%_]*$" }, - { { { "^#.-\n" }, "comment" }, - { { "%s#.-\n" }, "comment" }, - { { "\\[nrtfb\\\"']" }, "literal" }, - { { "'?\\u%x%x%x%x'?" }, "literal" }, - { { "(%${)([%w]+[%w_]*)(})" }, { "keyword", "keyword", "keyword2", "keyword" } }, - { { "%$[%w]+[%w_]*" }, "keyword2" }, - { { "[%a_][%w-+_%s%p]-%f[=]" }, "keyword" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "^%[.-%]" }, "keyword2" }, - { { "%s%[.-%]" }, "keyword2" }, - { { "=" }, "operator" }, - { { "https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/?[%w_.~!*:@&+$/" - "?%%#=-]*" }, - "link" }, - { { "[a-z]+" }, "symbol" } }, - { { "true", "literal" }, - { "false", "literal" }, - { "export", "literal" }, - { "null", "literal" } }, - "#" } ); -} - -static void addRuby() { - SyntaxDefinitionManager::instance()->add( { - "Ruby", - { "%.rb", "%.gemspec", "%.ruby" }, - { - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "%#.-\n" }, "comment" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "@?@[%a_][%w_]*" }, "keyword2" }, - { { "::[%w_]*" }, "symbol" }, - { { ":[%w_]*" }, "keyword2" }, - { { "[%a_][%w_]*:[^:]" }, "keyword2" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "nil", "literal" }, - { "end", "literal" }, - { "true", "literal" }, - { "false", "literal" }, - { "private", "keyword" }, - { "extend", "keyword" }, - { "include", "keyword" }, - { "require", "keyword" }, - { "require_dependency", "keyword" }, - { "__ENCODING__", "keyword" }, - { "__LINE__", "keyword" }, - { "__FILE__", "keyword" }, - { "BEGIN", "keyword" }, - { "END", "keyword" }, - { "alias", "keyword" }, - { "and", "keyword" }, - { "begin", "keyword" }, - { "break", "keyword" }, - { "case", "keyword" }, - { "class", "keyword" }, - { "def", "keyword" }, - { "defined?", "keyword" }, - { "do", "keyword" }, - { "else", "keyword" }, - { "elsif", "keyword" }, - { "ensure", "keyword" }, - { "for", "keyword" }, - { "if", "keyword" }, - { "in", "keyword" }, - { "module", "keyword" }, - { "next", "keyword" }, - { "not", "keyword" }, - { "or", "keyword" }, - { "redo", "keyword" }, - { "rescue", "keyword" }, - { "retry", "keyword" }, - { "return", "keyword" }, - { "self", "keyword" }, - { "super", "keyword" }, - { "then", "keyword" }, - { "undef", "keyword" }, - { "unless", "keyword" }, - { "until", "keyword" }, - { "when", "keyword" }, - { "while", "keyword" }, - { "yield", "keyword" }, - }, - "#", - { "^#!.*[ /]ruby" }, - } ); -} - -static void addScala() { - SyntaxDefinitionManager::instance()->add( { - "Scala", - { "%.sc$", "%.scala$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "[ruU]?\"", "\"", "\\" }, "string" }, - { { "[ruU]?'", "'", "\\" }, "string" }, - { { "0x[%da-fA-F]+" }, "number" }, - { { "-?%d+[%d%.eE]*" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*\"\"\"*[%a_][%w_]*\"\"\"" }, "string" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "abstract", "keyword" }, { "case", "keyword" }, { "catch", "keyword" }, - { "class", "keyword" }, { "finally", "keyword" }, { "final", "keyword" }, - { "do", "keyword" }, { "extends", "keyword" }, { "forSome", "keyword" }, - { "implicit", "keyword" }, { "lazy", "keyword" }, { "match", "keyword" }, - { "new", "keyword" }, { "override", "keyword" }, { "package", "keyword" }, - { "throw", "keyword" }, { "trait", "keyword" }, { "type", "keyword" }, - { "var", "keyword" }, { "val", "keyword" }, { "println", "keyword" }, - { "return", "keyword" }, { "for", "keyword" }, { "Try", "keyword" }, - { "def", "keyword" }, { "while", "keyword" }, { "with", "keyword" }, - { "if", "keyword" }, { "else", "keyword" }, { "import", "keyword" }, - { "object", "keyword" }, { "yield", "keyword" }, { "private", "keyword2" }, - { "protected", "keyword2" }, { "sealed", "keyword2" }, { "super", "keyword2" }, - { "this", "keyword2" }, { "Byte", "keyword2" }, { "Short", "keyword2" }, - { "Int", "keyword2" }, { "Long", "keyword2" }, { "Float", "keyword2" }, - { "Double", "keyword2" }, { "Char", "keyword2" }, { "String", "keyword2" }, - { "List", "keyword2" }, { "Array", "keyword2" }, { "Boolean", "keyword2" }, - { "Null", "literal" }, { "Any", "literal" }, { "AnyRef", "literal" }, - { "Nothing", "literal" }, { "Unit", "literal" }, { "true", "literal" }, - { "false", "literal" }, - }, - "//", - } ); -} - -static void addxit() { - SyntaxDefinitionManager::instance()->add( { - "[x]it!", - { "%.xit$" }, - { - { { "%f[^%s%(]%-%>%s%d%d%d%d%-%d%d%-%d%d%f[\n%s%!%?%)]" }, "number" }, - { { "%f[^%s%(]%-%>%s%d%d%d%d%/%d%d%/%d%d%f[\n%s%!%?%)]" }, "number" }, - { { "%f[^%s%(]%-%>%s%d%d%d%d%-[wWqQ]?%d%d?%f[\n%s%!%?%)]" }, "number" }, - { { "%f[^%s%(]%-%>%s%d%d%d%d%/[wWqQ]?%d%d?%f[\n%s%!%?%)]" }, "number" }, - { { "%f[^%s%(]%-%>%s%d%d%d%d%f[\n%s%!%?%)]" }, "number" }, - { { "^(%[%s%]%s)([%.!]+)%s" }, { "operator", "operator", "red" } }, - { { "^(%[x%]%s)([%.!]+)%s" }, { "function", "function", "red" } }, - { { "^(%[@%]%s)([%.!]+)%s" }, { "keyword", "keyword", "red" } }, - { { "^(%[~%]%s)([%.!]+)%s" }, { "comment", "comment", "red" } }, - { { "^(%[%.%]%s)([%.!]+)%s" }, { "comment", "comment", "red" } }, - { { "%#[%wñàáâãäåèéêëìíîïòóôõöùúûüýÿÑÀÁÂÃÄÅÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝ%-%_]+%=\"", "\"" }, - "string" }, - { { "%#[%wñàáâãäåèéêëìíîïòóôõöùúûüýÿÑÀÁÂÃÄÅÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝ%-%_]+%='", "'" }, - "string" }, - { { "%#[%wñàáâãäåèéêëìíîïòóôõöùúûüýÿÑÀÁÂÃÄÅÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝ%-%_]+%=[%w%-%_]*" }, - "string" }, - { { "%#[%wñàáâãäåèéêëìíîïòóôõöùúûüýÿÑÀÁÂÃÄÅÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝ%-%_]+" }, "string" }, - { { "^%[%s%]%s" }, "operator" }, - { { "^%[x%]%s" }, "function" }, - { { "^%[@%]%s" }, "keyword" }, - { { "^%[~%]%s" }, "comment" }, - { { "^%[%?%]%s" }, "warning" }, - { { "^%[%.%]%s" }, "notice" }, - { { "^[%wñàáâãäåèéêëìíîïòóôõöùúûüýÿÑÀÁÂÃÄÅÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝ][%w" - "ñàáâãäåèéêëìíîïòóôõöùúûüýÿÑÀÁÂÃÄÅÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝ%s%p]*%f[\n]" }, - "underline" }, - { { "https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/?[%w_.~!*:@&+$/" - "?%%#=-]*" }, - "link" }, - }, - {}, - "", - } ); -} - -static void addVue() { - SyntaxDefinitionManager::instance() - ->add( { "Vue-HTML", - {}, - { - { { "%{%{%{", "%}%}%}" }, "function", "JavaScript" }, - { { "%{%{", "%}%}" }, "function", "JavaScript" }, - { { "" }, "comment" }, - { { "%f[^>][^<]", "%f[<]" }, "normal" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "0x[%da-fA-F]+" }, "number" }, - { { "-?%d+[%d%.]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "%f[^<]![%a_][%w%_%-]*" }, "keyword2" }, - { { "%f[^<][%a_][%w%_%-]*" }, "function" }, - { { "%f[^<]/[%a_][%w%_%-]*" }, "function" }, - { { "[%a_][%w_]*" }, "keyword" }, - { { "[/<>=]" }, "operator" }, - }, - {}, - "", - {} } ) - .setVisible( false ) - .setAutoCloseXMLTags( true ); - - SyntaxDefinitionManager::instance()->add( - { "Vue", - { "%.vue?$" }, - { - { { "<%s*[sS][cC][rR][iI][pP][tT]%s*>", "<%s*/%s*[sS][cC][rR][iI][pP][tT]>" }, - "function", - "JavaScript" }, - { { "<%s*[sS][tT][yY][lL][eE][^>]*>", "<%s*/%s*[sS][tT][yY][lL][eE]%s*>" }, - "function", - "CSS" }, - { { "<%s*[tT][eE][mM][pP][lL][aA][tT][eE][^>]*>", - "<%s*/%s*[tT][eE][mM][pP][lL][aA][tT][eE]%s*>" }, - "function", - "Vue-HTML" }, - { { "" }, "comment" }, - { { "%f[^>][^<]", "%f[<]" }, "normal" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "0x[%da-fA-F]+" }, "number" }, - { { "-?%d+[%d%.]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "%f[^<]![%a_][%w%_%-]*" }, "keyword2" }, - { { "%f[^<][%a_][%w%_%-]*" }, "function" }, - { { "%f[^<]/[%a_][%w%_%-]*" }, "function" }, - { { "[%a_][%w_]*" }, "keyword" }, - { { "[/<>=]" }, "operator" }, - }, - {}, - "", - {} } ); -} - -static void addHaxe() { - SyntaxDefinitionManager::instance()->add( - { "Haxe Compiler Arguments", - { "%.hxml$" }, - { - { { "#.*" }, "comment" }, - { { "%-[%-%w_]*" }, "keyword" }, - { { "(%.)(%u[%w_]*)" }, { "normal", "normal", "keyword2" } }, - { { "%s+" }, "normal" }, - { { "%w+%f[%s]" }, "normal" }, - }, - {}, - "#" } ); - - SyntaxDefinitionManager::instance() - ->add( { "HaxeStringInterpolation", - {}, - { - { { "%${", "}", "\\" }, "keyword", ".hx" }, - { { "%$", "%s", "\\" }, "keyword", ".hx" }, - { { "[^ ]" }, "string" }, - { { "%s+" }, "normal" }, - { { "%w+%f[%s]" }, "normal" }, - }, - {} } ) - .setVisible( false ); - - SyntaxDefinitionManager::instance() - ->add( { "HaxeRegularExpressions", - {}, - { - { { "[%[%]%(%)]" }, "string" }, - { { "[%.%*%+%?%^%$%|%-]" }, "operator" }, - { { "%s+" }, "normal" }, - { { "%w+%f[%s]" }, "normal" }, - }, - {} } ) - .setVisible( false ); - - SyntaxDefinitionManager::instance()->add( - { "Haxe", - { "%.hx$" }, - { - { { "%~%/", "%/[igmsu]*" }, "keyword2", "HaxeRegularExpressions" }, - { { "%.%.%." }, "operator" }, - { { "(%<)(%u[%w_]*)(%>*)" }, { "normal", "operator", "keyword2", "operator" } }, - { { "(%#%s*[%a_]*)(.*\n)" }, { "normal", "keyword", "normal" } }, - { { "(import%s+)(%u[%w]*)" }, { "normal", "keyword", "keyword2" } }, - { { "(import%s+)([%w%.]*%.)(%u[%w]*)" }, - { "normal", "keyword", "normal", "keyword2" } }, - { { "(abstract%s+)(%u[%w_]*%s*%()(%s*%u[%w_]*)" }, - { "normal", "keyword2", "normal", "keyword2" } }, - { { "(from%s+)(%u[%w_]*%s+)(to%s+)(%u[%w_]*)" }, - { "normal", "keyword", "keyword2", "keyword", "keyword2" } }, - { { "//.*\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string", "HaxeStringInterpolation" }, - { { "-?%.?%d+" }, "number" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+%.[%deE]+" }, "number" }, - { { "-?%d+[%deE]+" }, "number" }, - { { "[%+%-%.=/%*%^%%<>!~|&]" }, "operator" }, - { { "([%a_][%w_]*)(%s*%f[(])" }, { "normal", "function", "normal" } }, - { { "[%a_][%w_]*" }, "symbol" }, - { { "(:)(%u[%a_][%w_]*)" }, { "normal", "normal", "keyword2" } }, - { { "@:[%a_][%w_]*%f[(]" }, "keyword" }, - { { "%$type" }, "keyword" }, - { { "%s+" }, "normal" }, - { { "%w+%f[%s]" }, "normal" }, - }, - { - { "using", "keyword2" }, { "true", "literal" }, { "trace", "keyword" }, - { "throw", "keyword" }, { "typedef", "keyword2" }, { "switch", "keyword" }, - { "try", "keyword" }, { "static", "keyword" }, { "set", "keyword" }, - { "return", "keyword" }, { "public", "keyword" }, { "package", "keyword" }, - { "do", "keyword" }, { "default", "keyword" }, { "new", "keyword" }, - { "private", "keyword" }, { "macro", "keyword2" }, { "cast", "keyword" }, - { "class", "keyword" }, { "case", "keyword" }, { "this", "keyword" }, - { "continue", "keyword" }, { "else", "keyword" }, { "extern", "keyword2" }, - { "break", "keyword" }, { "extends", "keyword2" }, { "interface", "keyword" }, - { "abstract", "keyword2" }, { "for", "keyword" }, { "override", "keyword" }, - { "function", "keyword2" }, { "never", "keyword" }, { "get", "keyword" }, - { "final", "keyword" }, { "if", "keyword" }, { "implements", "keyword2" }, - { "var", "keyword2" }, { "catch", "keyword" }, { "import", "keyword" }, - { "false", "literal" }, { "in", "keyword" }, { "while", "keyword" }, - { "inline", "keyword" }, { "enum", "keyword" }, { "null", "literal" }, - - }, - "//", - {} } ); -} - // Syntax definitions can be directly converted from the lite (https://github.com/rxi/lite) and // lite-plugins (https://github.com/rxi/lite-plugins) supported languages. @@ -1694,12 +115,12 @@ SyntaxDefinitionManager::SyntaxDefinitionManager() { addPlainText(); addAdept(); addAngelScript(); - addBash(); addBatchScript(); addBlueprint(); addC(); addCMake(); - addContainerfile(); + addContainerFile(); + addConfigFile(); addCPP(); addCrystal(); addCSharp(); @@ -1709,7 +130,7 @@ SyntaxDefinitionManager::SyntaxDefinitionManager() { addDiff(); addElixir(); addElm(); - addEnv(); + addEnvironmentFile(); addFstab(); addGDScript(); addGLSL(); @@ -1721,8 +142,7 @@ SyntaxDefinitionManager::SyntaxDefinitionManager() { addHLSL(); addHtaccessFile(); addHTML(); - addIgnore(); - addIni(); + addIgnoreFile(); addJai(); addJava(); addJavaScript(); @@ -1740,7 +160,7 @@ SyntaxDefinitionManager::SyntaxDefinitionManager() { addNelua(); addNim(); addObjeck(); - addObjetiveC(); + addObjectiveC(); addOdin(); addPascal(); addPerl(); @@ -1756,6 +176,7 @@ SyntaxDefinitionManager::SyntaxDefinitionManager() { addRust(); addSass(); addScala(); + addShellScript(); addSmallBASIC(); addSolidity(); addSQL(); @@ -1770,7 +191,7 @@ SyntaxDefinitionManager::SyntaxDefinitionManager() { addVue(); addWren(); addX86Assembly(); - addxit(); + addXit(); addXML(); addYAML(); addZig();