Clean up SyntaxDefinitionManager, move all language syntax definitions to its own files.

This commit is contained in:
Martín Lucas Golini
2024-03-23 16:45:57 -03:00
parent 892d3ba9c9
commit bdcf47dfeb
73 changed files with 2510 additions and 1622 deletions

View File

@@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject>
<!-- Written by QtCreator 12.0.2, 2024-02-21T01:01:02. -->
<!-- Written by QtCreator 12.0.2, 2024-03-23T16:43:54. -->
<qtcreator>
<data>
<variable>EnvironmentId</variable>
@@ -114,7 +114,7 @@
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">{388e5431-b31b-42b3-b9ad-9002d279d75d}</value>
<value type="qlonglong" key="ProjectExplorer.Target.ActiveBuildConfiguration">10</value>
<value type="qlonglong" key="ProjectExplorer.Target.ActiveBuildConfiguration">11</value>
<value type="qlonglong" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
<value type="qlonglong" key="ProjectExplorer.Target.ActiveRunConfiguration">19</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">

View File

@@ -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

View File

@@ -0,0 +1,55 @@
#include <eepp/ui/doc/languages/c.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,82 @@
#include <eepp/ui/doc/languages/cmake.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,41 @@
#include <eepp/ui/doc/languages/configfile.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,46 @@
#include <eepp/ui/doc/languages/containerfile.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,105 @@
#include <eepp/ui/doc/languages/cpp.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,69 @@
#include <eepp/ui/doc/languages/csharp.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,52 @@
#include <eepp/ui/doc/languages/dart.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,30 @@
#include <eepp/ui/doc/languages/difffile.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,44 @@
#include <eepp/ui/doc/languages/environmentfile.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,61 @@
#include <eepp/ui/doc/languages/go.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,42 @@
#include <eepp/ui/doc/languages/haskell.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,100 @@
#include <eepp/ui/doc/languages/haxe.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,20 @@
#include <eepp/ui/doc/languages/ignorefile.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addIgnoreFile() {
SyntaxDefinitionManager::instance()->add(
{ ".ignore file",
{ "%..*ignore$" },
{
{ { "^%s*#.*$" }, "comment" },
{ { "^%!.*$" }, "keyword" },
},
{},
"#" } );
}
}}}} // namespace EE::UI::Doc::Language

View File

@@ -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

View File

@@ -0,0 +1,63 @@
#include <eepp/ui/doc/languages/java.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,65 @@
#include <eepp/ui/doc/languages/javascript.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,35 @@
#include <eepp/ui/doc/languages/json.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,63 @@
#include <eepp/ui/doc/languages/jsx.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,31 @@
#include <eepp/ui/doc/languages/latex.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,46 @@
#include <eepp/ui/doc/languages/lua.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,33 @@
#include <eepp/ui/doc/languages/makefile.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,48 @@
#include <eepp/ui/doc/languages/meson.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,91 @@
#include <eepp/ui/doc/languages/nim.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addNim() {
std::vector<SyntaxPattern> nim_patterns;
UnorderedMap<std::string, std::string> nim_symbols;
const std::vector<std::string> 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<std::string> nim_type_suffix_patterns;
const std::vector<std::string> 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<std::string> 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<std::string> 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<std::string> 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<SyntaxPattern> 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

View File

@@ -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

View File

@@ -0,0 +1,49 @@
#include <eepp/ui/doc/languages/objective-c.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,108 @@
#include <eepp/ui/doc/languages/php.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,24 @@
#include <eepp/ui/doc/languages/plaintext.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
namespace EE { namespace UI { namespace Doc { namespace Language {
void addPlaintext() {
SyntaxDefinitionManager::instance()->add(
{"Plain Text",
{},
{
},
{
},
"",
{},
"plaintext"
});
}
}}}} // namespace EE::UI::Doc::Language

View File

@@ -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

View File

@@ -0,0 +1,84 @@
#include <eepp/ui/doc/languages/powershell.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,46 @@
#include <eepp/ui/doc/languages/python.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,83 @@
#include <eepp/ui/doc/languages/ruby.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,54 @@
#include <eepp/ui/doc/languages/scala.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,60 @@
#include <eepp/ui/doc/languages/shellscript.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,107 @@
#include <eepp/ui/doc/languages/typescript.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,66 @@
#include <eepp/ui/doc/languages/vue.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,41 @@
#include <eepp/ui/doc/languages/wren.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,53 @@
#include <eepp/ui/doc/languages/xit.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

View File

@@ -0,0 +1,52 @@
#include <eepp/ui/doc/languages/yaml.hpp>
#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
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

View File

@@ -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

File diff suppressed because it is too large Load Diff