diff --git a/projects/linux/ee.files b/projects/linux/ee.files index ef6a61b57..fb07cccb0 100644 --- a/projects/linux/ee.files +++ b/projects/linux/ee.files @@ -620,22 +620,55 @@ ../../src/eepp/graphics/vertexbuffervbo.cpp ../../src/eepp/graphics/view.cpp ../../src/eepp/main/eepp_main.cpp +../../src/eepp/ui/doc/languages/angelscript.cpp +../../src/eepp/ui/doc/languages/angelscript.hpp ../../src/eepp/ui/doc/languages/batchscript.cpp ../../src/eepp/ui/doc/languages/batchscript.hpp +../../src/eepp/ui/doc/languages/crystal.cpp +../../src/eepp/ui/doc/languages/crystal.hpp ../../src/eepp/ui/doc/languages/css.cpp ../../src/eepp/ui/doc/languages/css.hpp ../../src/eepp/ui/doc/languages/d.cpp ../../src/eepp/ui/doc/languages/d.hpp +../../src/eepp/ui/doc/languages/elixir.cpp +../../src/eepp/ui/doc/languages/elixir.hpp +../../src/eepp/ui/doc/languages/elm.cpp +../../src/eepp/ui/doc/languages/elm.hpp +../../src/eepp/ui/doc/languages/fstab.cpp +../../src/eepp/ui/doc/languages/fstab.hpp +../../src/eepp/ui/doc/languages/gdscript.cpp +../../src/eepp/ui/doc/languages/gdscript.hpp +../../src/eepp/ui/doc/languages/glsl.cpp +../../src/eepp/ui/doc/languages/glsl.hpp ../../src/eepp/ui/doc/languages/hare.cpp ../../src/eepp/ui/doc/languages/hare.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/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/markdown.cpp +../../src/eepp/ui/doc/languages/markdown.hpp +../../src/eepp/ui/doc/languages/nelua.cpp +../../src/eepp/ui/doc/languages/nelua.hpp +../../src/eepp/ui/doc/languages/objeck.cpp ../../src/eepp/ui/doc/languages/objeck.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/pico-8.cpp ../../src/eepp/ui/doc/languages/pico-8.hpp +../../src/eepp/ui/doc/languages/po.cpp +../../src/eepp/ui/doc/languages/po.hpp +../../src/eepp/ui/doc/languages/postgresql.cpp ../../src/eepp/ui/doc/languages/postgresql.hpp ../../src/eepp/ui/doc/languages/rust.hpp ../../src/eepp/ui/doc/languages/sass.cpp @@ -864,21 +897,45 @@ ../../src/eepp/ui/doc/languages/htaccess.hpp ../../src/eepp/ui/doc/languages/objeck.cpp ../../src/eepp/ui/doc/languages/objeck.hpp +../../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/pico-8.cpp ../../src/eepp/ui/doc/languages/pico-8.hpp +../../src/eepp/ui/doc/languages/po.cpp +../../src/eepp/ui/doc/languages/po.hpp ../../src/eepp/ui/doc/languages/postgresql.cpp +../../src/eepp/ui/doc/languages/postgresql.hpp +../../src/eepp/ui/doc/languages/r.cpp +../../src/eepp/ui/doc/languages/r.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/solidity.cpp +../../src/eepp/ui/doc/languages/solidity.hpp ../../src/eepp/ui/doc/languages/sql.cpp +../../src/eepp/ui/doc/languages/sql.hpp ../../src/eepp/ui/doc/languages/swift.cpp ../../src/eepp/ui/doc/languages/swift.hpp +../../src/eepp/ui/doc/languages/teal.cpp +../../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/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/x86assembly.cpp +../../src/eepp/ui/doc/languages/x86assembly.hpp +../../src/eepp/ui/doc/languages/xml.cpp +../../src/eepp/ui/doc/languages/xml.hpp +../../src/eepp/ui/doc/languages/zig.cpp +../../src/eepp/ui/doc/languages/zig.hpp ../../src/eepp/ui/doc/syntaxcolorscheme.cpp ../../src/eepp/ui/doc/syntaxdefinition.cpp ../../src/eepp/ui/doc/syntaxdefinitionmanager.cpp diff --git a/src/eepp/ui/doc/languages/angelscript.cpp b/src/eepp/ui/doc/languages/angelscript.cpp new file mode 100644 index 000000000..a6fdf3a77 --- /dev/null +++ b/src/eepp/ui/doc/languages/angelscript.cpp @@ -0,0 +1,60 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addAngelScript() { + + SyntaxDefinitionManager::instance()->add( + + { "AngelScript", + { "%.as$", "%.asc$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "#", "[^\\]\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?0[xX]%x+" }, "number" }, + { { "-?0[bB][0-1]+" }, "number" }, + { { "-?0[oO][0-7]+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "&inout" }, "keyword" }, + { { "&in" }, "keyword" }, + { { "&out" }, "keyword" }, + { { "[%a_][%w_]*@" }, "keyword2" }, + { { "[%-%+!~@%?:&|%^<>%*/=%%]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "float", "keyword2" }, { "uint64", "keyword2" }, { "uint", "keyword2" }, + { "int64", "keyword2" }, { "mixin", "keyword" }, { "set", "keyword" }, + { "get", "keyword" }, { "uint16", "keyword2" }, { "funcdef", "keyword" }, + { "false", "literal" }, { "shared", "keyword" }, { "uint32", "keyword2" }, + { "override", "keyword" }, { "class", "keyword" }, { "int16", "keyword2" }, + { "external", "keyword" }, { "default", "keyword" }, { "uint8", "keyword2" }, + { "protected", "keyword" }, { "int8", "keyword2" }, { "typedef", "keyword" }, + { "switch", "keyword" }, { "private", "keyword" }, { "final", "keyword" }, + { "if", "keyword" }, { "int", "keyword2" }, { "import", "keyword" }, + { "catch", "keyword" }, { "return", "keyword" }, { "case", "keyword" }, + { "and", "operator" }, { "while", "keyword" }, { "do", "keyword" }, + { "cast", "keyword" }, { "break", "keyword" }, { "continue", "keyword" }, + { "else", "keyword" }, { "try", "keyword" }, { "true", "literal" }, + { "function", "keyword" }, { "bool", "keyword2" }, { "is", "operator" }, + { "property", "keyword" }, { "const", "keyword" }, { "void", "keyword2" }, + { "abstract", "keyword" }, { "or", "operator" }, { "for", "keyword" }, + { "explicit", "keyword" }, { "int32", "keyword2" }, { "xor", "operator" }, + { "auto", "keyword" }, { "namespace", "keyword" }, { "double", "keyword2" }, + { "null", "literal" }, { "enum", "keyword" }, { "interface", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/angelscript.hpp b/src/eepp/ui/doc/languages/angelscript.hpp new file mode 100644 index 000000000..8f4922d8b --- /dev/null +++ b/src/eepp/ui/doc/languages/angelscript.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Angelscript +#define EE_UI_DOC_Angelscript + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addAngelScript(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/crystal.cpp b/src/eepp/ui/doc/languages/crystal.cpp new file mode 100644 index 000000000..b0af811f0 --- /dev/null +++ b/src/eepp/ui/doc/languages/crystal.cpp @@ -0,0 +1,90 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addCrystal() { + + SyntaxDefinitionManager::instance()->add( + + { "Crystal", + { "%.cr$" }, + { + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "%#.-\n" }, "comment" }, + { { " : [%w_| :]*" }, "comment" }, + { { "-?%d+[%d%.eE]*%f[^eE]" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(?]" }, "function" }, + { { "%.[%a_][%w_]*%f[(%s]" }, "function" }, + { { "@?@[%a_][%w_]*" }, "keyword2" }, + { { ":-[%u_][%u%d_]*%f[^%w]" }, "keyword2" }, + { { "::[%w_]*" }, "symbol" }, + { { ":[%w_]*" }, "symbol" }, + { { "[%a_][%w_]*:[^:]" }, "keyword2" }, + { { "[%a_][%w_]*" }, "symbol" }, + { { "%s+" }, "normal" }, + { { "%w+%f[%s]" }, "normal" }, + + }, + { + { "end", "keyword" }, + { "END", "keyword" }, + { "else", "keyword" }, + { "case", "keyword" }, + { "BEGIN", "keyword" }, + { "__FILE__", "keyword" }, + { "annotation", "keyword2" }, + { "__LINE__", "keyword" }, + { "until", "keyword" }, + { "abstract", "keyword" }, + { "Void", "literal" }, + { "fun", "keyword" }, + { "alias", "keyword" }, + { "self", "keyword2" }, + { "break", "keyword" }, + { "class", "keyword" }, + { "yield", "keyword" }, + { "then", "keyword" }, + { "unless", "keyword" }, + { "include", "keyword" }, + { "when", "keyword" }, + { "extend", "keyword" }, + { "next", "keyword" }, + { "enum", "keyword2" }, + { "nil", "literal" }, + { "begin", "keyword" }, + { "if", "keyword" }, + { "out", "function" }, + { "false", "literal" }, + { "in", "keyword" }, + { "def", "keyword" }, + { "elsif", "keyword" }, + { "responds_to?", "function" }, + { "module", "keyword" }, + { "ensure", "keyword" }, + { "while", "keyword" }, + { "do", "keyword" }, + { "require", "keyword" }, + { "defined?", "keyword" }, + { "private", "keyword2" }, + { "rescue", "keyword" }, + { "p!", "function" }, + { "puts", "function" }, + { "true", "literal" }, + { "__ENCODING__", "keyword" }, + { "return", "keyword" }, + { "super", "keyword2" }, + { "undef", "keyword" }, + + }, + "#", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/crystal.hpp b/src/eepp/ui/doc/languages/crystal.hpp new file mode 100644 index 000000000..bbc180e6a --- /dev/null +++ b/src/eepp/ui/doc/languages/crystal.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Crystal +#define EE_UI_DOC_Crystal + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addCrystal(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/elixir.cpp b/src/eepp/ui/doc/languages/elixir.cpp new file mode 100644 index 000000000..3e2eb68ae --- /dev/null +++ b/src/eepp/ui/doc/languages/elixir.cpp @@ -0,0 +1,64 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addElixir() { + + SyntaxDefinitionManager::instance()->add( + + { "Elixir", + { "%.ex$", "%.exs$" }, + { + { { "#.*\n" }, "comment" }, + { { ":\"", "\"", "\\" }, "number" }, + { { "\"\"\"", "\"\"\"", "\\" }, "string" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "~%a\"\"\"", "\"\"\"" }, "string" }, + { { "~%a[/\"|'%(%[%{<]", "[/\"|'%)%]%}>]", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { ":\"?[%a_][%w_]*\"?" }, "number" }, + { { "[%a][%w_!?]*%f[(]" }, "function" }, + { { "%u%w+" }, "normal" }, + { { "@[%a_][%w_]*" }, "keyword2" }, + { { "_%a[%w_]*" }, "keyword2" }, + { { "[%+%-=/%*<>!|&]" }, "operator" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "raise", "keyword" }, { "use", "keyword2" }, + { "try", "keyword" }, { "defrecordp", "keyword" }, + { "unless", "keyword" }, { "for", "keyword" }, + { "receive", "keyword" }, { "or", "operator" }, + { "if", "keyword" }, { "fn", "keyword" }, + { "when", "keyword" }, { "after", "keyword" }, + { "case", "keyword" }, { "and", "operator" }, + { "rescue", "keyword" }, { "defcallback", "keyword" }, + { "defexception", "keyword" }, { "cond", "keyword" }, + { "defdelegate", "keyword" }, { "else", "keyword" }, + { "end", "keyword" }, { "quote", "keyword" }, + { "super", "keyword" }, { "do", "keyword" }, + { "require", "keyword2" }, { "unquote_splicing", "keyword" }, + { "alias", "keyword2" }, { "nil", "literal" }, + { "true", "literal" }, { "unquote", "keyword" }, + { "defmacro", "keyword" }, { "def", "keyword" }, + { "defrecord", "keyword" }, { "false", "literal" }, + { "defp", "keyword" }, { "defoverridable", "keyword" }, + { "defprotocol", "keyword" }, { "with", "keyword" }, + { "defmodule", "keyword" }, { "defguardp", "keyword" }, + { "defmacrop", "keyword" }, { "defimpl", "keyword" }, + { "defstruct", "keyword" }, { "catch", "keyword" }, + { "import", "keyword2" }, { "defguard", "keyword" }, + + }, + "#", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/elixir.hpp b/src/eepp/ui/doc/languages/elixir.hpp new file mode 100644 index 000000000..f42b7d95e --- /dev/null +++ b/src/eepp/ui/doc/languages/elixir.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Elixir +#define EE_UI_DOC_Elixir + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addElixir(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/elm.cpp b/src/eepp/ui/doc/languages/elm.cpp new file mode 100644 index 000000000..be3bc8436 --- /dev/null +++ b/src/eepp/ui/doc/languages/elm.cpp @@ -0,0 +1,46 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addElm() { + + SyntaxDefinitionManager::instance()->add( + + { "Elm", + { "%.elm$" }, + { + { { "%-%-", "\n" }, "comment" }, + { { "{%-", "%-}" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "\"\"\"", "\"\"\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "%.%." }, "operator" }, + { { "[=:|&<>%+%-%*\\/%^%%]" }, "operator" }, + { { "[%a_'][%w_']*" }, "symbol" }, + { { "%s+" }, "normal" }, + { { "%w+%f[%s]" }, "normal" }, + + }, + { + { "import", "keyword" }, { "port", "keyword" }, { "type", "keyword" }, + { "case", "keyword" }, { "in", "keyword" }, { "let", "keyword" }, + { "not", "keyword" }, { "module", "keyword" }, { "number", "keyword2" }, + { "Bool", "keyword2" }, { "of", "keyword" }, { "if", "keyword" }, + { "or", "keyword" }, { "as", "keyword" }, { "then", "keyword" }, + { "and", "keyword" }, { "Int", "keyword2" }, { "else", "keyword" }, + { "exposing", "keyword" }, { "False", "literal" }, { "True", "literal" }, + { "String", "keyword2" }, { "Float", "keyword2" }, { "Char", "keyword2" }, + { "xor", "keyword" }, { "alias", "keyword" }, + + }, + "%-%-", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/elm.hpp b/src/eepp/ui/doc/languages/elm.hpp new file mode 100644 index 000000000..953a271ec --- /dev/null +++ b/src/eepp/ui/doc/languages/elm.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Elm +#define EE_UI_DOC_Elm + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addElm(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/fstab.cpp b/src/eepp/ui/doc/languages/fstab.cpp new file mode 100644 index 000000000..ca6461867 --- /dev/null +++ b/src/eepp/ui/doc/languages/fstab.cpp @@ -0,0 +1,60 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addFstab() { + + SyntaxDefinitionManager::instance()->add( + + { "fstab", + { "fstab" }, + { + { { "^#.*$" }, "comment" }, + { { "[=/:.,]+" }, "operator" }, + { { "/.*/" }, "string" }, + { { "#" }, "operator" }, + { { "%w-%-%w-%-%w-%-%w-%-%w- " }, "string" }, + { { "%d+%.%d+%.%d+%.%d+" }, "string" }, + { { " %d+ " }, "number" }, + { { "[%w_]+" }, "symbol" }, + { { "%s+" }, "normal" }, + { { "%w+%f[%s]" }, "normal" }, + + }, + { + { "vfat", "keyword2" }, { "ecryptfs", "keyword2" }, + { "devpts", "keyword2" }, { "squashfs", "keyword2" }, + { "LABEL", "keyword" }, { "aufs", "keyword2" }, + { "hugetlbfs", "keyword2" }, { "proc", "keyword2" }, + { "btrfs", "keyword2" }, { "binder", "keyword2" }, + { "binfmt_misc", "keyword2" }, { "securityfs", "keyword2" }, + { "cgroup", "keyword2" }, { "cgroup2", "keyword2" }, + { "sockfs", "keyword2" }, { "swap", "keyword2" }, + { "pipefs", "keyword2" }, { "sysfs", "keyword2" }, + { "none", "literal" }, { "mqueue", "keyword2" }, + { "configfs", "keyword2" }, { "UUID", "keyword" }, + { "rpc_pipefs", "keyword2" }, { "hfs", "keyword2" }, + { "bdev", "keyword2" }, { "fusectl", "keyword2" }, + { "ntfs", "keyword2" }, { "tmpfs", "keyword2" }, + { "hfsplus", "keyword2" }, { "devtmpfs", "keyword2" }, + { "fuseblk", "keyword2" }, { "debugfs", "keyword2" }, + { "autofs", "keyword2" }, { "cpuset", "keyword2" }, + { "ufs", "keyword2" }, { "nfs", "keyword2" }, + { "jfs", "keyword2" }, { "fuse", "keyword2" }, + { "bpf", "keyword2" }, { "nfs4", "keyword2" }, + { "pstore", "keyword2" }, { "ext2", "keyword2" }, + { "ext3", "keyword2" }, { "tracefs", "keyword2" }, + { "minix", "keyword2" }, { "msdos", "keyword2" }, + { "xfs", "keyword2" }, { "ext4", "keyword2" }, + { "ramfs", "keyword2" }, { "nfsd", "keyword2" }, + { "qnx4", "keyword2" }, + + }, + "#", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/fstab.hpp b/src/eepp/ui/doc/languages/fstab.hpp new file mode 100644 index 000000000..79568b007 --- /dev/null +++ b/src/eepp/ui/doc/languages/fstab.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Fstab +#define EE_UI_DOC_Fstab + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addFstab(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/gdscript.cpp b/src/eepp/ui/doc/languages/gdscript.cpp new file mode 100644 index 000000000..c30828ee1 --- /dev/null +++ b/src/eepp/ui/doc/languages/gdscript.cpp @@ -0,0 +1,107 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addGDScript() { + + SyntaxDefinitionManager::instance()->add( + + { "GDScript", + { "%.gd$" }, + { + { { "#.-\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?0x%x*" }, "number" }, + { { "-?%d+[%d%.e]*" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "[%+%:%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "Array", "keyword2" }, + { "RID", "keyword2" }, + { "NodePath", "keyword2" }, + { "Basis", "keyword2" }, + { "Transform", "keyword2" }, + { "Quat", "keyword2" }, + { "void", "keyword2" }, + { "Transform2D", "keyword2" }, + { "AABB", "keyword2" }, + { "true", "literal" }, + { "Vector3", "keyword2" }, + { "int", "keyword2" }, + { "mastersync", "keyword" }, + { "is", "keyword" }, + { "signal", "keyword" }, + { "class", "keyword" }, + { "Rect2", "keyword2" }, + { "pass", "keyword" }, + { "elif", "keyword" }, + { "PoolStringArray", "keyword2" }, + { "as", "keyword" }, + { "TAU", "literal" }, + { "INF", "literal" }, + { "and", "keyword" }, + { "PoolVector2Array", "keyword2" }, + { "for", "keyword" }, + { "Color", "keyword2" }, + { "PoolIntArray", "keyword2" }, + { "tool", "keyword" }, + { "bool", "keyword2" }, + { "continue", "keyword" }, + { "Object", "keyword2" }, + { "NAN", "literal" }, + { "Dictionary", "keyword2" }, + { "self", "keyword" }, + { "const", "keyword" }, + { "or", "keyword" }, + { "false", "literal" }, + { "PoolByteArray", "keyword2" }, + { "PI", "literal" }, + { "var", "keyword" }, + { "while", "keyword" }, + { "PoolVector3Array", "keyword2" }, + { "func", "keyword" }, + { "if", "keyword" }, + { "setget", "keyword" }, + { "String", "keyword2" }, + { "else", "keyword" }, + { "in", "keyword" }, + { "onready", "keyword" }, + { "break", "keyword" }, + { "not", "keyword" }, + { "match", "keyword" }, + { "static", "keyword" }, + { "extends", "keyword" }, + { "PoolColorArray", "keyword2" }, + { "float", "keyword2" }, + { "Plane", "keyword2" }, + { "puppet", "keyword" }, + { "remotesync", "keyword" }, + { "return", "keyword" }, + { "class_name", "keyword" }, + { "enum", "keyword" }, + { "breakpoint", "keyword" }, + { "null", "literal" }, + { "Vector2", "keyword2" }, + { "preload", "keyword" }, + { "export", "keyword" }, + { "yield", "keyword" }, + { "puppetsync", "keyword" }, + { "assert", "keyword" }, + { "remote", "keyword" }, + { "master", "keyword" }, + { "PoolRealArray", "keyword2" }, + + }, + "#", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/gdscript.hpp b/src/eepp/ui/doc/languages/gdscript.hpp new file mode 100644 index 000000000..b9bce1c2c --- /dev/null +++ b/src/eepp/ui/doc/languages/gdscript.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Gdscript +#define EE_UI_DOC_Gdscript + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addGDScript(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/html.cpp b/src/eepp/ui/doc/languages/html.cpp new file mode 100644 index 000000000..32ae3b820 --- /dev/null +++ b/src/eepp/ui/doc/languages/html.cpp @@ -0,0 +1,50 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addHTML() { + + SyntaxDefinitionManager::instance() + ->add( + + { "HTML", + { "%.html?$", "%.phtml", "%.handlebars" }, + { + { { "<%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" }, + + }, + { + + }, + "", + { "" } + + } ) + .setAutoCloseXMLTags( true ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/html.hpp b/src/eepp/ui/doc/languages/html.hpp new file mode 100644 index 000000000..d8bc56d67 --- /dev/null +++ b/src/eepp/ui/doc/languages/html.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Html +#define EE_UI_DOC_Html + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addHTML(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/julia.cpp b/src/eepp/ui/doc/languages/julia.cpp new file mode 100644 index 000000000..33e90cf1c --- /dev/null +++ b/src/eepp/ui/doc/languages/julia.cpp @@ -0,0 +1,73 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addJulia() { + + SyntaxDefinitionManager::instance()->add( + + { "Julia", + { "%.jl$" }, + { + { { "#=", "=#" }, "comment" }, + { { "#.*$" }, "comment" }, + { { "icxx\"\"\"", "\"\"\"" }, "string", "C++" }, + { { "cxx\"\"\"", "\"\"\"" }, "string", "C++" }, + { { "py\"\"\"", "\"\"\"" }, "string", "Python" }, + { { "js\"\"\"", "\"\"\"" }, "string", "JavaScript" }, + { { "md\"\"\"", "\"\"\"" }, "string", "Markdown" }, + { { "%d%w*[%.-+*//]" }, "number" }, + { { "0[oO_][0-7]+" }, "number" }, + { { "-?0x[%x_]+" }, "number" }, + { { "-?0b[%x_]+" }, "number" }, + { { "-?%d+_%d" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[^%d%g]%:%a*" }, "function" }, + { { "[%+%-=/%*%^%%<>!~|&%:]" }, "operator" }, + { { "\"\"\".*\"\"\"" }, "string" }, + { { "\".*\"" }, "string" }, + { { "[bv]\".*\"" }, "string" }, + { { "r\".*$" }, "string" }, + { { "'\\.*'" }, "string" }, + { { "'.'" }, "string" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "%g*!" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + { { "%s+" }, "normal" }, + { { "%w+%f[%s]" }, "normal" }, + + }, + { + { "function", "keyword" }, { "import", "keyword" }, { "for", "keyword" }, + { "begin", "keyword" }, { "local", "keyword" }, { "const", "keyword" }, + { "mutable", "keyword2" }, { "using", "keyword" }, { "where", "keyword" }, + { "finally", "keyword" }, { "Float64", "keyword2" }, { "UInt8", "keyword2" }, + { "elseif", "keyword" }, { "Dict", "keyword" }, { "global", "keyword" }, + { "Function", "keyword2" }, { "Ref", "keyword2" }, { "try", "keyword" }, + { "UInt128", "keyword2" }, { "Vector", "keyword2" }, { "module", "keyword" }, + { "Matrix", "keyword2" }, { "nothing", "literal" }, { "struct", "keyword2" }, + { "Number", "keyword2" }, { "let", "keyword" }, { "return", "keyword" }, + { "UInt32", "keyword2" }, { "Int8", "keyword2" }, { "Float16", "keyword2" }, + { "typeof", "keyword" }, { "if", "keyword" }, { "type", "keyword" }, + { "String", "keyword2" }, { "baremodule", "keyword" }, { "Int128", "keyword2" }, + { "Char", "keyword2" }, { "continue", "keyword" }, { "end", "keyword" }, + { "while", "keyword" }, { "quote", "keyword" }, { "Float32", "keyword2" }, + { "true", "literal" }, { "Set", "keyword" }, { "UInt16", "keyword2" }, + { "Union", "keyword" }, { "abstract", "keyword2" }, { "Inf", "literal" }, + { "Int16", "keyword2" }, { "primitive", "keyword2" }, { "Int64", "keyword2" }, + { "missing", "literal" }, { "NaN", "literal" }, { "Bool", "keyword2" }, + { "Int32", "keyword2" }, { "macro", "keyword" }, { "UInt64", "keyword2" }, + { "Int", "keyword2" }, { "catch", "keyword" }, { "do", "keyword" }, + { "export", "keyword" }, { "false", "literal" }, { "Integer", "keyword2" }, + { "else", "keyword" }, { "in", "keyword" }, { "break", "keyword" }, + + }, + "#", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/julia.hpp b/src/eepp/ui/doc/languages/julia.hpp new file mode 100644 index 000000000..f6befe5e6 --- /dev/null +++ b/src/eepp/ui/doc/languages/julia.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Julia +#define EE_UI_DOC_Julia + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addJulia(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/kotlin.cpp b/src/eepp/ui/doc/languages/kotlin.cpp new file mode 100644 index 000000000..94e5b50be --- /dev/null +++ b/src/eepp/ui/doc/languages/kotlin.cpp @@ -0,0 +1,75 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addKotlin() { + + SyntaxDefinitionManager::instance()->add( + + { "Kotlin", + { "%.kt$" }, + { + { { "//.-\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_]*" }, "function" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "object", "keyword" }, { "case", "keyword" }, + { "sealed", "keyword" }, { "lateinit", "literal" }, + { "override", "keyword" }, { "false", "literal" }, + { "true", "literal" }, { "Double", "keyword2" }, + { "companion", "keyword" }, { "break", "keyword" }, + { "else", "keyword" }, { "Float", "keyword2" }, + { "try", "keyword" }, { "public", "keyword" }, + { "if", "keyword" }, { "String", "keyword2" }, + { "var", "keyword" }, { "import", "keyword" }, + { "synchronized", "keyword" }, { "package", "keyword" }, + { "Long", "keyword2" }, { "protected", "keyword" }, + { "val", "keyword" }, { "Short", "keyword2" }, + { "UByte", "keyword2" }, { "do", "keyword" }, + { "assert", "keyword" }, { "native", "keyword" }, + { "private", "keyword" }, { "UShortArray", "keyword2" }, + { "UInt", "keyword2" }, { "implements", "keyword" }, + { "extends", "keyword" }, { "catch", "keyword" }, + { "interface", "keyword" }, { "UByteArray", "keyword2" }, + { "IntArray", "keyword2" }, { "UIntArray", "keyword2" }, + { "ULong", "keyword2" }, { "null", "literal" }, + { "ShortArray", "keyword2" }, { "ByteArray", "keyword2" }, + { "for", "keyword" }, { "UShort", "keyword2" }, + { "Array", "keyword2" }, { "enum", "keyword" }, + { "elseif", "keyword" }, { "fun", "keyword" }, + { "final", "keyword" }, { "ULongArray", "keyword2" }, + { "then", "keyword" }, { "class", "keyword" }, + { "continue", "keyword" }, { "instanceof", "keyword" }, + { "while", "keyword" }, { "abstract", "keyword" }, + { "super", "keyword" }, { "return", "keyword" }, + { "Byte", "keyword2" }, { "LongArray", "keyword2" }, + { "goto", "keyword" }, { "Boolean", "keyword2" }, + { "throws", "keyword" }, { "throw", "keyword" }, + { "finally", "keyword" }, { "new", "keyword" }, + { "static", "keyword" }, { "switch", "keyword" }, + { "default", "keyword" }, { "transient", "keyword" }, + { "void", "keyword" }, { "volatile", "keyword" }, + { "Int", "keyword2" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/kotlin.hpp b/src/eepp/ui/doc/languages/kotlin.hpp new file mode 100644 index 000000000..3fbb3e8c8 --- /dev/null +++ b/src/eepp/ui/doc/languages/kotlin.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Kotlin +#define EE_UI_DOC_Kotlin + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addKotlin(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/markdown.cpp b/src/eepp/ui/doc/languages/markdown.cpp new file mode 100644 index 000000000..52a86da34 --- /dev/null +++ b/src/eepp/ui/doc/languages/markdown.cpp @@ -0,0 +1,83 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addMarkdown() { + + SyntaxDefinitionManager::instance()->add( + + { "Markdown", + { "%.md$", "%.markdown$" }, + { + { { "\\." }, "normal" }, + { { "```[Xx][Mm][Ll]", "```" }, "function", "XML" }, + { { "```[Hh][Tt][Mm][Ll]", "```" }, "function", "html" }, + { { "```[Cc]++", "```" }, "function", "C++" }, + { { "```[Cc][Pp][Pp]", "```" }, "function", "C++" }, + { { "```[Cc]sharp", "```" }, "function", "C#" }, + { { "```[Cc][Ss][Ss]", "```" }, "function", "CSS" }, + { { "```[Cc]", "```" }, "function", "C" }, + { { "```[Dd][Aa][Rr][Tt]", "```" }, "function", "Dart" }, + { { "```[Dd]", "```" }, "function", "D" }, + { { "```[Ll]ua", "```" }, "function", "Lua" }, + { { "```[Jj][Ss][Oo][Nn]", "```" }, "function", "JSON" }, + { { "```[Ja]va[Ss]cript", "```" }, "function", "JavaScript" }, + { { "```[Tt]ype[Ss]cript", "```" }, "function", "TypeScript" }, + { { "```[Pp]ython", "```" }, "function", "Python" }, + { { "```[Bb]ash", "```" }, "function", "Bash" }, + { { "```[Pp][Hh][Pp]", "```" }, "function", "PHPCore" }, + { { "```[Ss][Qq][Ll]", "```" }, "function", "SQL" }, + { { "```[Gg][Ll][Ss][Ll]", "```" }, "function", "GLSL" }, + { { "```[Ii][Nn][Ii]", "```" }, "function", "Config File" }, + { { "```[Mm]akefile", "```" }, "function", "Makefile" }, + { { "```[Gg][Oo]", "```" }, "function", "Go" }, + { { "```[Rr]ust", "```" }, "function", "Rust" }, + { { "```[Rr]uby", "```" }, "function", "Ruby" }, + { { "```[Gg][Dd][Ss]cript", "```" }, "function", "GSCript" }, + { { "```[Jj]ava", "```" }, "function", "java" }, + { { "```[Ss]wift", "```" }, "function", "Swift" }, + { { "```[Oo]bjective[Cc]", "```" }, "function", "Objective-C" }, + { { "```[Yy][Aa][Mm][Ll]", "```" }, "function", "YAML" }, + { { "```[Kk]otlin", "```" }, "function", "Kotlin" }, + { { "```[Ss]olidity", "```" }, "function", "Solidity" }, + { { "```[Hh]askell", "```" }, "function", "Haskell" }, + { { "```[Oo]din", "```" }, "function", "Odin" }, + { { "```[Nn]im", "```" }, "function", "Nim" }, + { { "```[Zz]ig", "```" }, "function", "Zig" }, + { { "" }, "comment" }, + { { "```", "```" }, "string" }, + { { "``", "``" }, "string" }, + { { "`", "`" }, "string" }, + { { "~~", "~~", "\\" }, "keyword2" }, + { { "%-%-%-+" }, "comment" }, + { { "%*%s+" }, "operator" }, + { { "%*", "[%*\n]", "\\" }, "operator" }, + { { "%s%_", "[%_\n]", "\\" }, "keyword2" }, + { { "^%_", "[%_\n]", "\\" }, "keyword2" }, + { { "^#.-\n" }, "keyword" }, + { { "\n%_", "[%_\n]", "\\" }, "keyword2" }, + { { "\n#.-\n" }, "keyword" }, + { { "%[!%[([^%]].-)%]%((https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/" + "?[%w_.~!*:@&+$/?%%#=-]*)%)%]%((https?://[%w_.~!*:@&+$/" + "?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/?[%w_.~!*:@&+$/?%%#=-]*)%)" }, + { "keyword", "function", "link", "link" } }, + { { "!?%[([^%]].-)%]%((https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/" + "?[%w_.~!*:@&+$/?%%#=-]*)%)" }, + { "keyword", "function", "link" } }, + { { "!?%[([^%]].-)%]%((%#+[%w-]*)%)" }, { "keyword", "function", "link" } }, + { { "https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/?[%w_.~!*:@&+$/" + "?%%#=-]*" }, + "link" }, + + }, + { + + }, + "", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/markdown.hpp b/src/eepp/ui/doc/languages/markdown.hpp new file mode 100644 index 000000000..324d41f02 --- /dev/null +++ b/src/eepp/ui/doc/languages/markdown.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Markdown +#define EE_UI_DOC_Markdown + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addMarkdown(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/nelua.cpp b/src/eepp/ui/doc/languages/nelua.cpp new file mode 100644 index 000000000..dd04dbe38 --- /dev/null +++ b/src/eepp/ui/doc/languages/nelua.cpp @@ -0,0 +1,96 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addNelua() { + + SyntaxDefinitionManager::instance()->add( + + { "Nelua", + { "%.nelua$" }, + { + { { "##%[=*%[", "%]=*%]" }, "function", "Lua" }, + { { "#|", "|#" }, "function", "Lua" }, + { { "##", "\n" }, "function", "Lua" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "%[%[", "%]%]" }, "string" }, + { { "%-%-%[%[", "%]%]" }, "comment" }, + { { "%-%-%[=+%[", "%]=+%]" }, "comment" }, + { { "%-%-.-\n" }, "comment" }, + { { "0x%x+%.%x*[pP][-+]?%d+" }, "number" }, + { { "0x%x+%.%x*" }, "number" }, + { { "0x%.%x+[pP][-+]?%d+" }, "number" }, + { { "0x%.%x+" }, "number" }, + { { "0x%x+[pP][-+]?%d+" }, "number" }, + { { "0x%x+" }, "number" }, + { { "0b[01_]+" }, "number" }, + { { "%d%.%d*[eE][-+]?%d+" }, "number" }, + { { "%d%.%d*" }, "number" }, + { { "%.?%d*[eE][-+]?%d+" }, "number" }, + { { "%.?%d+" }, "number" }, + { { "%.%.%.?" }, "operator" }, + { { "[<>~=]=" }, "operator" }, + { { "_[iunbf][s1368][246i]?[8z]?[e]?" }, "keyword2" }, + { { "[%+%-=/%*%^%%#<>]" }, "operator" }, + { { "([%a_][%w_]*)(%s*%f[(\"'{])" }, { "function", "function", "normal" } }, + { { "(@)(enum)" }, { "normal", "keyword", "keyword2" } }, + { { "(@)(record)" }, { "normal", "keyword", "keyword2" } }, + { { "(@)(union)" }, { "normal", "keyword", "keyword2" } }, + { { "%((@)(%w+)%)" }, { "normal", "keyword", "keyword2" } }, + { { "[%a_][%w_]*" }, "symbol" }, + { { "::[%a_][%w_]*::" }, "function" }, + + }, + { + { "isize", "keyword2" }, { "break", "keyword" }, + { "else", "keyword" }, { "in", "keyword" }, + { "number", "keyword2" }, { "byte", "keyword2" }, + { "boolean", "keyword2" }, { "culonglong", "keyword2" }, + { "false", "literal" }, { "or", "keyword" }, + { "culong", "keyword2" }, { "clongdouble", "keyword2" }, + { "clonglong", "keyword2" }, { "cshort", "keyword2" }, + { "cemit", "keyword2" }, { "global", "keyword" }, + { "cemitdecl", "keyword2" }, { "nodecl", "keyword2" }, + { "integer", "keyword2" }, { "cuchar", "keyword2" }, + { "cint", "keyword2" }, { "cimport", "keyword2" }, + { "for", "keyword" }, { "cemitdefn", "keyword2" }, + { "defer", "keyword" }, { "codename", "keyword2" }, + { "int8", "keyword2" }, { "goto", "keyword" }, + { "true", "literal" }, { "usize", "keyword2" }, + { "niltype", "keyword2" }, { "uint8", "keyword2" }, + { "inline", "literal" }, { "while", "keyword" }, + { "uint32", "keyword2" }, { "auto", "keyword2" }, + { "then", "keyword" }, { "self", "keyword2" }, + { "void", "keyword2" }, { "function", "keyword" }, + { "string", "keyword2" }, { "float128", "keyword2" }, + { "and", "keyword" }, { "case", "keyword" }, + { "float32", "keyword2" }, { "float64", "keyword2" }, + { "int64", "keyword2" }, { "uint16", "keyword2" }, + { "noinit", "literal" }, { "volatile", "literal" }, + { "int16", "keyword2" }, { "comptime", "literal" }, + { "uint128", "keyword2" }, { "uint64", "keyword2" }, + { "int32", "keyword2" }, { "repeat", "keyword" }, + { "continue", "keyword" }, { "not", "keyword" }, + { "cexport", "keyword2" }, { "cptrdiff", "keyword2" }, + { "nil", "literal" }, { "cstring", "keyword2" }, + { "end", "keyword" }, { "nilptr", "keyword" }, + { "clong", "keyword2" }, { "switch", "keyword" }, + { "cchar", "keyword2" }, { "cuint", "keyword2" }, + { "pointer", "keyword2" }, { "int128", "keyword2" }, + { "return", "keyword" }, { "elseif", "keyword" }, + { "uinteger", "keyword2" }, { "csize", "keyword2" }, + { "if", "keyword" }, { "const", "literal" }, + { "local", "keyword" }, { "cushort", "keyword2" }, + { "do", "keyword" }, { "until", "keyword" }, + { "cschar", "keyword2" }, { "cinclude", "keyword2" }, + + }, + "--", + { "^#!.*[ /]nelua" } + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/nelua.hpp b/src/eepp/ui/doc/languages/nelua.hpp new file mode 100644 index 000000000..fd4b2dcae --- /dev/null +++ b/src/eepp/ui/doc/languages/nelua.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Nelua +#define EE_UI_DOC_Nelua + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addNelua(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/po.cpp b/src/eepp/ui/doc/languages/po.cpp new file mode 100644 index 000000000..ab7a39506 --- /dev/null +++ b/src/eepp/ui/doc/languages/po.cpp @@ -0,0 +1,33 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addPO() { + + SyntaxDefinitionManager::instance()->add( + + { "PO", + { "%.po$", "%.pot$" }, + { + { { "#", "\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "[%[%]]" }, "operator" }, + { { "%d+" }, "number" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "msgctxt", "keyword" }, + { "msgid", "keyword" }, + { "msgstr", "keyword" }, + { "msgid_plural", "keyword" }, + + }, + "#", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/po.hpp b/src/eepp/ui/doc/languages/po.hpp new file mode 100644 index 000000000..8291ccc11 --- /dev/null +++ b/src/eepp/ui/doc/languages/po.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Po +#define EE_UI_DOC_Po + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addPO(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/r.cpp b/src/eepp/ui/doc/languages/r.cpp new file mode 100644 index 000000000..2a05fb228 --- /dev/null +++ b/src/eepp/ui/doc/languages/r.cpp @@ -0,0 +1,53 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addR() { + + SyntaxDefinitionManager::instance()->add( + + { "R", + { "%.r$", "%.rds$", "%.rda$", "%.rdata$", "%.R$" }, + { + { { "#", "\n" }, "comment" }, + { { "\"", "\"" }, "string" }, + { { "'", "'" }, "string" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + { { "[%+%-=/%*%^%%<>!|&]" }, "operator" }, + { { "0x[%da-fA-F]+" }, "number" }, + { { "-?%d+[%d%.eE]*" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "%s+" }, "normal" }, + { { "%w+%f[%s]" }, "normal" }, + + }, + { + { "NULL", "literal" }, + { "else", "keyword" }, + { "NA_real", "keyword" }, + { "NA_complex", "keyword" }, + { "while", "keyword" }, + { "repeat", "keyword" }, + { "function", "keyword" }, + { "NA", "literal" }, + { "NA_integer", "keyword" }, + { "for", "keyword" }, + { "Inf", "literal" }, + { "TRUE", "literal" }, + { "next", "keyword" }, + { "in", "keyword" }, + { "if", "keyword" }, + { "FALSE", "literal" }, + { "NA_character", "keyword" }, + { "break", "keyword" }, + + }, + "#", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/r.hpp b/src/eepp/ui/doc/languages/r.hpp new file mode 100644 index 000000000..a9fdcbd93 --- /dev/null +++ b/src/eepp/ui/doc/languages/r.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_R +#define EE_UI_DOC_R + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addR(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/teal.cpp b/src/eepp/ui/doc/languages/teal.cpp new file mode 100644 index 000000000..d1ba574ef --- /dev/null +++ b/src/eepp/ui/doc/languages/teal.cpp @@ -0,0 +1,49 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addTeal() { + + SyntaxDefinitionManager::instance()->add( + + { "Teal", + { "%.tl$", "%.d.tl$" }, + { + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "%[%[", "%]%]" }, "string" }, + { { "%-%-%[%[", "%]%]" }, "comment" }, + { { "%-%-.-\n" }, "comment" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "<%a+>" }, "keyword2" }, + { { "%.%.%.?" }, "operator" }, + { { "[<>~=]=" }, "operator" }, + { { "[%+%-=/%*%^%%#<>]" }, "operator" }, + { { "[%a_][%w_]*%s*%f[(\"{]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + { { "::[%a_][%w_]*::" }, "function" }, + + }, + { + { "true", "literal" }, { "if", "keyword" }, { "any", "keyword2" }, + { "boolean", "keyword2" }, { "while", "keyword" }, { "end", "keyword" }, + { "else", "keyword" }, { "number", "keyword2" }, { "break", "keyword" }, + { "not", "keyword" }, { "local", "keyword" }, { "elseif", "keyword" }, + { "then", "keyword" }, { "return", "keyword" }, { "do", "keyword" }, + { "until", "keyword" }, { "function", "keyword" }, { "string", "keyword2" }, + { "global", "keyword" }, { "false", "literal" }, { "repeat", "keyword" }, + { "in", "keyword" }, { "and", "keyword" }, { "for", "keyword" }, + { "or", "keyword" }, { "goto", "keyword" }, { "record", "keyword" }, + { "nil", "literal" }, { "enum", "keyword" }, { "thread", "keyword2" }, + + }, + "--", + { "^#!.*[ /]tl" } + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/teal.hpp b/src/eepp/ui/doc/languages/teal.hpp new file mode 100644 index 000000000..ba678e853 --- /dev/null +++ b/src/eepp/ui/doc/languages/teal.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Teal +#define EE_UI_DOC_Teal + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addTeal(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/toml.cpp b/src/eepp/ui/doc/languages/toml.cpp new file mode 100644 index 000000000..0a7fe2aa2 --- /dev/null +++ b/src/eepp/ui/doc/languages/toml.cpp @@ -0,0 +1,46 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addToml() { + + SyntaxDefinitionManager::instance()->add( + + { "TOML", + { "%.toml$" }, + { + { { "#.-\n" }, "comment" }, + { { "\"\"\"", "\"\"\"", "\\" }, "string" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'''", "'''" }, "string" }, + { { "'", "'" }, "string" }, + { { "[A-Za-z0-9_%.%-]+%s*%f[=]" }, "function" }, + { { "%[[A-Za-z0-9_%.%- ]+%]" }, "keyword" }, + { { "%[%[[A-Za-z0-9_%.%- ]+%]%]" }, "keyword" }, + { { "[%-+]?[0-9_]+%.[0-9_]+[eE][%-+]?[0-9_]+" }, "number" }, + { { "[%-+]?[0-9_]+%.[0-9_]+" }, "number" }, + { { "[%-+]?[0-9_]+[eE][%-+]?[0-9_]+" }, "number" }, + { { "[%-+]?[0-9_]+" }, "number" }, + { { "[%-+]?0x[0-9a-fA-F_]+" }, "number" }, + { { "[%-+]?0o[0-7_]+" }, "number" }, + { { "[%-+]?0b[01_]+" }, "number" }, + { { "[%-+]?nan" }, "number" }, + { { "[%-+]?inf" }, "number" }, + { { "[a-z]+" }, "symbol" }, + { { "%s+" }, "normal" }, + { { "%w+%f[%s]" }, "normal" }, + + }, + { + { "true", "literal" }, + { "false", "literal" }, + + }, + "#", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/toml.hpp b/src/eepp/ui/doc/languages/toml.hpp new file mode 100644 index 000000000..ae5680ee0 --- /dev/null +++ b/src/eepp/ui/doc/languages/toml.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Toml +#define EE_UI_DOC_Toml + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addToml(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/v.cpp b/src/eepp/ui/doc/languages/v.cpp new file mode 100644 index 000000000..be76d6f70 --- /dev/null +++ b/src/eepp/ui/doc/languages/v.cpp @@ -0,0 +1,65 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addV() { + + SyntaxDefinitionManager::instance()->add( + + { "V", + { "%.v$", "%.vsh$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "`", "`", "\\" }, "string" }, + { { "r'", "'" }, "string" }, + { { "r\"", "\"" }, "string" }, + { { "0x[%da-fA-F_]+" }, "number" }, + { { "0b[01_]+" }, "number" }, + { { "00[01234567_]+" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%+%-%*%/%%%~%&%|%^%!%=]" }, "operator" }, + { { "%:%=" }, "operator" }, + { { "%.%.%.?" }, "operator" }, + { { "[%a_][%w_]*" }, "symbol" }, + { { "%$%s?[%a_][%w_]*" }, "keyword2" }, + { { "%@%s?[%a_][%w_]*" }, "keyword2" }, + { { "%s+" }, "normal" }, + { { "%w+%f[%s]" }, "normal" }, + + }, + { + { "thread", "keyword2" }, { "struct", "keyword" }, { "string", "keyword2" }, + { "go", "keyword" }, { "i128", "keyword2" }, { "bool", "keyword2" }, + { "import", "keyword" }, { "as", "keyword" }, { "goto", "keyword" }, + { "union", "keyword" }, { "u32", "keyword2" }, { "const", "keyword" }, + { "f32", "keyword2" }, { "u16", "keyword2" }, { "unsafe", "keyword" }, + { "voidptr", "keyword2" }, { "i64", "keyword2" }, { "typeof", "keyword" }, + { "if", "keyword" }, { "fn", "keyword" }, { "continue", "keyword" }, + { "char", "keyword2" }, { "atomic", "keyword" }, { "isreftype", "keyword" }, + { "u64", "keyword2" }, { "true", "literal" }, { "u128", "keyword2" }, + { "u8", "keyword2" }, { "chan", "keyword2" }, { "assert", "keyword" }, + { "i16", "keyword2" }, { "byte", "keyword2" }, { "type", "keyword" }, + { "__offsetof", "keyword" }, { "for", "keyword" }, { "i8", "keyword2" }, + { "int", "keyword2" }, { "is", "keyword" }, { "defer", "keyword" }, + { "interface", "keyword" }, { "false", "literal" }, { "or", "keyword" }, + { "pub", "keyword" }, { "lock", "keyword" }, { "map", "keyword2" }, + { "module", "keyword" }, { "rune", "keyword2" }, { "shared", "keyword" }, + { "mut", "keyword" }, { "match", "keyword" }, { "static", "keyword" }, + { "asm", "keyword" }, { "none", "literal" }, { "return", "keyword" }, + { "in", "keyword" }, { "else", "keyword" }, { "break", "keyword" }, + { "rlock", "keyword" }, { "select", "keyword" }, { "enum", "keyword" }, + { "f64", "keyword2" }, { "sizeof", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/v.hpp b/src/eepp/ui/doc/languages/v.hpp new file mode 100644 index 000000000..b61f6b622 --- /dev/null +++ b/src/eepp/ui/doc/languages/v.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_V +#define EE_UI_DOC_V + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addV(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/xml.cpp b/src/eepp/ui/doc/languages/xml.cpp new file mode 100644 index 000000000..8fa522140 --- /dev/null +++ b/src/eepp/ui/doc/languages/xml.cpp @@ -0,0 +1,41 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addXML() { + + SyntaxDefinitionManager::instance() + ->add( + + { "XML", + { "%.xml$", "%.svg$" }, + { + { { "<%s*[sS][tT][yY][lL][eE]%s*>", "<%s*/%s*[sS][tT][yY][lL][eE]%s*>" }, + "function", + "CSS" }, + { { "" }, "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" }, + + }, + { + + }, + "", + { "<%?xml" } + + } ) + .setAutoCloseXMLTags( true ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/xml.hpp b/src/eepp/ui/doc/languages/xml.hpp new file mode 100644 index 000000000..875db794c --- /dev/null +++ b/src/eepp/ui/doc/languages/xml.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Xml +#define EE_UI_DOC_Xml + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addXML(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/languages/zig.cpp b/src/eepp/ui/doc/languages/zig.cpp new file mode 100644 index 000000000..b716e185b --- /dev/null +++ b/src/eepp/ui/doc/languages/zig.cpp @@ -0,0 +1,125 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addZig() { + + SyntaxDefinitionManager::instance()->add( + + { "Zig", + { "%.zig$" }, + { + { { "//.-\n" }, "comment" }, + { { "\\\\.-\n" }, "string" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "[iu][%d_]+" }, "keyword2" }, + { { "0b[01_]+" }, "number" }, + { { "0o[0-7_]+" }, "number" }, + { { "0x[%x_]+" }, "number" }, + { { "0x[%x_]+%.[%x_]*[pP][-+]?%d+" }, "number" }, + { { "0x[%x_]+%.[%x_]*" }, "number" }, + { { "0x%.[%x_]+[pP][-+]?%d+" }, "number" }, + { { "0x%.[%x_]+" }, "number" }, + { { "0x[%x_]+[pP][-+]?%d+" }, "number" }, + { { "0x[%x_]+" }, "number" }, + { { "%d[%d_]*%.[%d_]*[eE][-+]?%d+" }, "number" }, + { { "%d[%d_]*%.[%d_]*" }, "number" }, + { { "%d[%d_]*" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&%.%?]" }, "operator" }, + { { "([%a_][%w_]*)(%s*%()" }, { "function", "function", "normal" } }, + { { "[A-Z][%w_]*" }, "keyword2" }, + { { "[%a_][%w_]*" }, "symbol" }, + { { "(@)([%a_][%w_]*)" }, { "operator", "operator", "function" } }, + + }, + { + { "f64", "keyword2" }, + { "enum", "keyword" }, + { "noalias", "keyword" }, + { "c_void", "keyword2" }, + { "allowzero", "keyword" }, + { "opaque", "keyword" }, + { "c_uint", "keyword2" }, + { "and", "keyword" }, + { "f16", "keyword2" }, + { "c_ulong", "keyword2" }, + { "nakedcc", "keyword" }, + { "error", "keyword" }, + { "callconv", "keyword" }, + { "test", "keyword" }, + { "f32", "keyword2" }, + { "const", "keyword" }, + { "union", "keyword" }, + { "nosuspend", "keyword" }, + { "align", "keyword" }, + { "anytype", "keyword" }, + { "async", "keyword" }, + { "return", "keyword" }, + { "errdefer", "keyword" }, + { "cancel", "keyword" }, + { "undefined", "literal" }, + { "true", "literal" }, + { "usingnamespace", "keyword" }, + { "void", "keyword2" }, + { "volatile", "keyword" }, + { "linksection", "keyword" }, + { "threadlocal", "keyword" }, + { "suspend", "keyword" }, + { "struct", "keyword" }, + { "comptime", "keyword" }, + { "null", "literal" }, + { "try", "keyword" }, + { "bool", "keyword2" }, + { "comptime_int", "keyword2" }, + { "continue", "keyword" }, + { "anyerror", "keyword2" }, + { "type", "keyword2" }, + { "c_longdouble", "keyword2" }, + { "resume", "keyword" }, + { "noreturn", "keyword2" }, + { "c_ulonglong", "keyword2" }, + { "c_long", "keyword2" }, + { "c_int", "keyword2" }, + { "c_longlong", "keyword2" }, + { "c_ushort", "keyword2" }, + { "c_short", "keyword2" }, + { "noasync", "keyword" }, + { "defer", "keyword" }, + { "f128", "keyword2" }, + { "else", "keyword" }, + { "isize", "keyword2" }, + { "break", "keyword" }, + { "export", "keyword" }, + { "packed", "keyword" }, + { "extern", "keyword" }, + { "fn", "keyword" }, + { "if", "keyword" }, + { "anyframe", "keyword" }, + { "switch", "keyword" }, + { "orelse", "keyword" }, + { "usize", "keyword2" }, + { "unreachable", "keyword" }, + { "asm", "keyword" }, + { "for", "keyword" }, + { "while", "keyword" }, + { "inline", "keyword" }, + { "comptime_float", "keyword2" }, + { "var", "keyword" }, + { "catch", "keyword" }, + { "or", "keyword" }, + { "false", "literal" }, + { "pub", "keyword" }, + { "await", "keyword" }, + { "ccc", "keyword" }, + { "stdcallcc", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/zig.hpp b/src/eepp/ui/doc/languages/zig.hpp new file mode 100644 index 000000000..2b41f14aa --- /dev/null +++ b/src/eepp/ui/doc/languages/zig.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Zig +#define EE_UI_DOC_Zig + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addZig(); + +}}}} // namespace EE::UI::Doc::Language + +#endif diff --git a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp index c1157c4bc..65dff4fb4 100644 --- a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp +++ b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp @@ -3,27 +3,45 @@ #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 @@ -42,136 +60,6 @@ static void addPlainText() { { "Plain Text", { "%.txt$" }, {}, {}, "", {}, "plaintext" } ); } -static void addXML() { - SyntaxDefinitionManager::instance() - ->add( { "XML", - { "%.xml$", "%.svg$" }, - { - { { "<%s*[sS][tT][yY][lL][eE]%s*>", "<%s*/%s*[sS][tT][yY][lL][eE]%s*>" }, - "function", - "CSS" }, - { { "" }, "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" }, - }, - {}, - "", - { "<%?xml" } } ) - .setAutoCloseXMLTags( true ); -} - -static void addHTML() { - SyntaxDefinitionManager::instance() - ->add( { "HTML", - { "%.html?$", "%.phtml", "%.handlebars" }, - { - { { "<%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" }, - }, - {}, - "", - { "" } } ) - .setAutoCloseXMLTags( true ); -} - -static void addMarkdown() { - SyntaxDefinitionManager::instance()->add( - { "Markdown", - { "%.md$", "%.markdown$" }, - { - { { "\\." }, "normal" }, - { { "```[Xx][Mm][Ll]", "```" }, "function", "XML" }, - { { "```[Hh][Tt][Mm][Ll]", "```" }, "function", "html" }, - { { "```[Cc]++", "```" }, "function", "C++" }, - { { "```[Cc][Pp][Pp]", "```" }, "function", "C++" }, - { { "```[Cc]sharp", "```" }, "function", "C#" }, - { { "```[Cc][Ss][Ss]", "```" }, "function", "CSS" }, - { { "```[Cc]", "```" }, "function", "C" }, - { { "```[Dd][Aa][Rr][Tt]", "```" }, "function", "Dart" }, - { { "```[Dd]", "```" }, "function", "D" }, - { { "```[Ll]ua", "```" }, "function", "Lua" }, - { { "```[Jj][Ss][Oo][Nn]", "```" }, "function", "JSON" }, - { { "```[Ja]va[Ss]cript", "```" }, "function", "JavaScript" }, - { { "```[Tt]ype[Ss]cript", "```" }, "function", "TypeScript" }, - { { "```[Pp]ython", "```" }, "function", "Python" }, - { { "```[Bb]ash", "```" }, "function", "Bash" }, - { { "```[Pp][Hh][Pp]", "```" }, "function", "PHPCore" }, - { { "```[Ss][Qq][Ll]", "```" }, "function", "SQL" }, - { { "```[Gg][Ll][Ss][Ll]", "```" }, "function", "GLSL" }, - { { "```[Ii][Nn][Ii]", "```" }, "function", "Config File" }, - { { "```[Mm]akefile", "```" }, "function", "Makefile" }, - { { "```[Gg][Oo]", "```" }, "function", "Go" }, - { { "```[Rr]ust", "```" }, "function", "Rust" }, - { { "```[Rr]uby", "```" }, "function", "Ruby" }, - { { "```[Gg][Dd][Ss]cript", "```" }, "function", "GSCript" }, - { { "```[Jj]ava", "```" }, "function", "java" }, - { { "```[Ss]wift", "```" }, "function", "Swift" }, - { { "```[Oo]bjective[Cc]", "```" }, "function", "Objective-C" }, - { { "```[Yy][Aa][Mm][Ll]", "```" }, "function", "YAML" }, - { { "```[Kk]otlin", "```" }, "function", "Kotlin" }, - { { "```[Ss]olidity", "```" }, "function", "Solidity" }, - { { "```[Hh]askell", "```" }, "function", "Haskell" }, - { { "```[Oo]din", "```" }, "function", "Odin" }, - { { "```[Nn]im", "```" }, "function", "Nim" }, - { { "```[Zz]ig", "```" }, "function", "Zig" }, - { { "" }, "comment" }, - { { "```", "```" }, "string" }, - { { "``", "``" }, "string" }, - { { "`", "`" }, "string" }, - { { "~~", "~~", "\\" }, "keyword2" }, - { { "%-%-%-+" }, "comment" }, - { { "%*%s+" }, "operator" }, - { { "%*", "[%*\n]", "\\" }, "operator" }, - { { "%s%_", "[%_\n]", "\\" }, "keyword2" }, - { { "^%_", "[%_\n]", "\\" }, "keyword2" }, - { { "^#.-\n" }, "keyword" }, - { { "\n%_", "[%_\n]", "\\" }, "keyword2" }, - { { "\n#.-\n" }, "keyword" }, - { { "%[!%[([^%]].-)%]%((https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/" - "?[%w_.~!*:@&+$/?%%#=-]*)%)%]%((https?://[%w_.~!*:@&+$/" - "?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/?[%w_.~!*:@&+$/?%%#=-]*)%)" }, - { "keyword", "function", "link", "link" } }, - { { "!?%[([^%]].-)%]%((https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/" - "?[%w_.~!*:@&+$/?%%#=-]*)%)" }, - { "keyword", "function", "link" } }, - { { "!?%[([^%]].-)%]%((%#+[%w-]*)%)" }, { "keyword", "function", "link" } }, - { { "https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/?[%w_.~!*:@&+$/" - "?%%#=-]*" }, - "link" }, - } } ); -} - static void addC() { SyntaxDefinitionManager::instance()->add( { "C", @@ -359,7 +247,7 @@ static void addTypeScript() { { "type", "keyword2" }, { "typeof", "keyword" }, { "undefined", "literal" }, { "var", "keyword" }, { "void", "keyword" }, { "while", "keyword" }, { "with", "keyword" }, { "yield", "keyword" }, { "unknown", "keyword2" }, - { "namespace", "keyword" }, { "abstract", "keyword"} }, + { "namespace", "keyword" }, { "abstract", "keyword" } }, "//" } ); SyntaxDefinitionManager::instance()->add( @@ -873,101 +761,6 @@ static void addGo() { "//" } ); } -static void addGDScript() { - SyntaxDefinitionManager::instance()->add( - - { "GDScript", - { "%.gd$" }, - { - { { "#.-\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?0x%x*" }, "number" }, - { { "-?%d+[%d%.e]*" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "[%+%:%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "if", "keyword" }, - { "elif", "keyword" }, - { "else", "keyword" }, - { "for", "keyword" }, - { "while", "keyword" }, - { "match", "keyword" }, - { "break", "keyword" }, - { "continue", "keyword" }, - { "pass", "keyword" }, - { "return", "keyword" }, - { "class", "keyword" }, - { "class_name", "keyword" }, - { "extends", "keyword" }, - { "is", "keyword" }, - { "in", "keyword" }, - { "as", "keyword" }, - { "and", "keyword" }, - { "or", "keyword" }, - { "not", "keyword" }, - { "self", "keyword" }, - { "tool", "keyword" }, - { "signal", "keyword" }, - { "func", "keyword" }, - { "static", "keyword" }, - { "const", "keyword" }, - { "enum", "keyword" }, - { "var", "keyword" }, - { "onready", "keyword" }, - { "export", "keyword" }, - { "setget", "keyword" }, - { "breakpoint", "keyword" }, - { "preload", "keyword" }, - { "yield", "keyword" }, - { "assert", "keyword" }, - { "remote", "keyword" }, - { "master", "keyword" }, - { "puppet", "keyword" }, - { "remotesync", "keyword" }, - { "mastersync", "keyword" }, - { "puppetsync", "keyword" }, - { "void", "keyword2" }, - { "int", "keyword2" }, - { "float", "keyword2" }, - { "bool", "keyword2" }, - { "String", "keyword2" }, - { "Vector2", "keyword2" }, - { "Rect2", "keyword2" }, - { "Vector3", "keyword2" }, - { "Transform2D", "keyword2" }, - { "Plane", "keyword2" }, - { "Quat", "keyword2" }, - { "AABB", "keyword2" }, - { "Basis", "keyword2" }, - { "Transform", "keyword2" }, - { "Color", "keyword2" }, - { "NodePath", "keyword2" }, - { "RID", "keyword2" }, - { "Object", "keyword2" }, - { "Array", "keyword2" }, - { "PoolByteArray", "keyword2" }, - { "PoolIntArray", "keyword2" }, - { "PoolRealArray", "keyword2" }, - { "PoolStringArray", "keyword2" }, - { "PoolVector2Array", "keyword2" }, - { "PoolVector3Array", "keyword2" }, - { "PoolColorArray", "keyword2" }, - { "Dictionary", "keyword2" }, - { "null", "literal" }, - { "true", "literal" }, - { "false", "literal" }, - { "PI", "literal" }, - { "TAU", "literal" }, - { "INF", "literal" }, - { "NAN", "literal" }, - }, - "#" } ); -} - static void addHaskell() { SyntaxDefinitionManager::instance()->add( { "Haskell", @@ -1047,53 +840,6 @@ static void addMeson() { "#" } ); } -static void addAngelScript() { - SyntaxDefinitionManager::instance()->add( - { "AngelScript", - { "%.as$", "%.asc$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "#", "[^\\]\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?0[xX]%x+" }, "number" }, - { { "-?0[bB][0-1]+" }, "number" }, - { { "-?0[oO][0-7]+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "&inout" }, "keyword" }, - { { "&in" }, "keyword" }, - { { "&out" }, "keyword" }, - { { "[%a_][%w_]*@" }, "keyword2" }, - { { "[%-%+!~@%?:&|%^<>%*/=%%]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "shared", "keyword" }, { "external", "keyword" }, { "private", "keyword" }, - { "protected", "keyword" }, { "const", "keyword" }, { "final", "keyword" }, - { "abstract", "keyword" }, { "class", "keyword" }, { "typedef", "keyword" }, - { "namespace", "keyword" }, { "interface", "keyword" }, { "import", "keyword" }, - { "enum", "keyword" }, { "funcdef", "keyword" }, { "get", "keyword" }, - { "set", "keyword" }, { "mixin", "keyword" }, { "void", "keyword2" }, - { "int", "keyword2" }, { "int8", "keyword2" }, { "int16", "keyword2" }, - { "int32", "keyword2" }, { "int64", "keyword2" }, { "uint", "keyword2" }, - { "uint8", "keyword2" }, { "uint16", "keyword2" }, { "uint32", "keyword2" }, - { "uint64", "keyword2" }, { "float", "keyword2" }, { "double", "keyword2" }, - { "bool", "keyword2" }, { "auto", "keyword" }, { "override", "keyword" }, - { "explicit", "keyword" }, { "property", "keyword" }, { "break", "keyword" }, - { "continue", "keyword" }, { "return", "keyword" }, { "switch", "keyword" }, - { "case", "keyword" }, { "default", "keyword" }, { "for", "keyword" }, - { "while", "keyword" }, { "do", "keyword" }, { "if", "keyword" }, - { "else", "keyword" }, { "try", "keyword" }, { "catch", "keyword" }, - { "cast", "keyword" }, { "function", "keyword" }, { "true", "literal" }, - { "false", "literal" }, { "null", "literal" }, { "is", "operator" }, - { "and", "operator" }, { "or", "operator" }, { "xor", "operator" }, - }, - "//" } ); -} - static void addDiff() { SyntaxDefinitionManager::instance()->add( { "Diff File", { "%.diff$", "%.patch$" }, @@ -1257,178 +1003,6 @@ static void addDart() { "//" } ); } -static void addKotlin() { - SyntaxDefinitionManager::instance()->add( - { "Kotlin", - { "%.kt$" }, - { - { { "//.-\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_]*" }, "function" }, - { { "[%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" }, { "String", "keyword2" }, - { "Boolean", "keyword2" }, { "true", "literal" }, - { "false", "literal" }, { "null", "literal" }, - { "var", "keyword" }, { "lateinit", "literal" }, - { "override", "keyword" }, { "fun", "keyword" }, - { "sealed", "keyword" }, { "companion", "keyword" }, - { "object", "keyword" }, { "val", "keyword" }, - { "UInt", "keyword2" }, { "UShort", "keyword2" }, - { "UByte", "keyword2" }, { "ULong", "keyword2" }, - { "IntArray", "keyword2" }, { "ShortArray", "keyword2" }, - { "ByteArray", "keyword2" }, { "LongArray", "keyword2" }, - { "UIntArray", "keyword2" }, { "UShortArray", "keyword2" }, - { "UByteArray", "keyword2" }, { "ULongArray", "keyword2" }, - { "Array", "keyword2" } }, - "//" } ); -} - -static void addZig() { - SyntaxDefinitionManager::instance()->add( - { "Zig", - { "%.zig$" }, - { - { { "//.-\n" }, "comment" }, - { { "\\\\.-\n" }, "string" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "[iu][%d_]+" }, "keyword2" }, - { { "0b[01_]+" }, "number" }, - { { "0o[0-7_]+" }, "number" }, - { { "0x[%x_]+" }, "number" }, - { { "0x[%x_]+%.[%x_]*[pP][-+]?%d+" }, "number" }, - { { "0x[%x_]+%.[%x_]*" }, "number" }, - { { "0x%.[%x_]+[pP][-+]?%d+" }, "number" }, - { { "0x%.[%x_]+" }, "number" }, - { { "0x[%x_]+[pP][-+]?%d+" }, "number" }, - { { "0x[%x_]+" }, "number" }, - { { "%d[%d_]*%.[%d_]*[eE][-+]?%d+" }, "number" }, - { { "%d[%d_]*%.[%d_]*" }, "number" }, - { { "%d[%d_]*" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&%.%?]" }, "operator" }, - { { "([%a_][%w_]*)(%s*%()" }, { "function", "function", "normal" } }, - { { "[A-Z][%w_]*" }, "keyword2" }, - { { "[%a_][%w_]*" }, "symbol" }, - { { "(@)([%a_][%w_]*)" }, { "operator", "operator", "function" } }, - }, - { - { "fn", "keyword" }, - { "asm", "keyword" }, - { "volatile", "keyword" }, - { "continue", "keyword" }, - { "break", "keyword" }, - { "switch", "keyword" }, - { "for", "keyword" }, - { "while", "keyword" }, - { "var", "keyword" }, - { "anytype", "keyword" }, - { "anyframe", "keyword" }, - { "const", "keyword" }, - { "test", "keyword" }, - { "packed", "keyword" }, - { "extern", "keyword" }, - { "export", "keyword" }, - { "pub", "keyword" }, - { "defer", "keyword" }, - { "errdefer", "keyword" }, - { "align", "keyword" }, - { "usingnamespace", "keyword" }, - { "noasync", "keyword" }, - { "async", "keyword" }, - { "await", "keyword" }, - { "cancel", "keyword" }, - { "suspend", "keyword" }, - { "resume", "keyword" }, - { "threadlocal", "keyword" }, - { "linksection", "keyword" }, - { "callconv", "keyword" }, - { "try", "keyword" }, - { "catch", "keyword" }, - { "orelse", "keyword" }, - { "unreachable", "keyword" }, - { "error", "keyword" }, - { "if", "keyword" }, - { "else", "keyword" }, - { "return", "keyword" }, - { "comptime", "keyword" }, - { "stdcallcc", "keyword" }, - { "ccc", "keyword" }, - { "nakedcc", "keyword" }, - { "and", "keyword" }, - { "or", "keyword" }, - { "struct", "keyword" }, - { "enum", "keyword" }, - { "union", "keyword" }, - { "opaque", "keyword" }, - { "inline", "keyword" }, - { "allowzero", "keyword" }, - { "noalias", "keyword" }, - { "nosuspend", "keyword" }, - { "f16", "keyword2" }, - { "f32", "keyword2" }, - { "f64", "keyword2" }, - { "f128", "keyword2" }, - { "void", "keyword2" }, - { "c_void", "keyword2" }, - { "isize", "keyword2" }, - { "usize", "keyword2" }, - { "c_short", "keyword2" }, - { "c_ushort", "keyword2" }, - { "c_int", "keyword2" }, - { "c_uint", "keyword2" }, - { "c_long", "keyword2" }, - { "c_ulong", "keyword2" }, - { "c_longlong", "keyword2" }, - { "c_ulonglong", "keyword2" }, - { "c_longdouble", "keyword2" }, - { "bool", "keyword2" }, - { "noreturn", "keyword2" }, - { "type", "keyword2" }, - { "anyerror", "keyword2" }, - { "comptime_int", "keyword2" }, - { "comptime_float", "keyword2" }, - { "true", "literal" }, - { "false", "literal" }, - { "null", "literal" }, - { "undefined", "literal" }, - }, - "//" } ); -} - static void addNim() { std::vector nim_patterns; std::unordered_map nim_symbols; @@ -1887,27 +1461,6 @@ static void addScala() { } ); } -static void addPO() { - SyntaxDefinitionManager::instance()->add( { - "PO", - { "%.po$", "%.pot$" }, - { - { { "#", "\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "[%[%]]" }, "operator" }, - { { "%d+" }, "number" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "msgctxt", "keyword" }, - { "msgid", "keyword" }, - { "msgid_plural", "keyword" }, - { "msgstr", "keyword" }, - }, - "#", - } ); -} - static void addxit() { SyntaxDefinitionManager::instance()->add( { "[x]it!", @@ -1946,90 +1499,6 @@ static void addxit() { } ); } -static void addNelua() { - SyntaxDefinitionManager::instance()->add( - { "Nelua", - { "%.nelua$" }, - { - { { "##%[=*%[", "%]=*%]" }, "function", "Lua" }, - { { "#|", "|#" }, "function", "Lua" }, - { { "##", "\n" }, "function", "Lua" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "%[%[", "%]%]" }, "string" }, - { { "%-%-%[=*%[", "%]=*%]" }, "comment" }, - { { "%-%-.-\n" }, "comment" }, - { { "0x%x+%.%x*[pP][-+]?%d+" }, "number" }, - { { "0x%x+%.%x*" }, "number" }, - { { "0x%.%x+[pP][-+]?%d+" }, "number" }, - { { "0x%.%x+" }, "number" }, - { { "0x%x+[pP][-+]?%d+" }, "number" }, - { { "0x%x+" }, "number" }, - { { "%d%.%d*[eE][-+]?%d+" }, "number" }, - { { "%d%.%d*" }, "number" }, - { { "%.?%d*[eE][-+]?%d+" }, "number" }, - { { "<%S[%w+%._,%s*'\"()<>]-%S>" }, "keyword2" }, - { { "%.?%d+" }, "number" }, - { { "%.%.%.?" }, "operator" }, - { { "[<>~=]=" }, "operator" }, - { { "[%+%-=/%*%^%%#<>]" }, "operator" }, - { { "([%a_][%w_]*)(%s*%f[(\"'{])" }, { "function", "function", "normal" } }, - { { "[%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" }, { "global", "keyword" }, - { "switch", "keyword" }, { "case", "keyword" }, { "defer", "keyword" }, - { "continue", "keyword" }, { "nilptr", "keyword" }, - }, - "--", - { "^#!.*[ /]nelua" } } ); -} - -static void addTeal() { - SyntaxDefinitionManager::instance()->add( - { "Teal", - { "%.tl$", "%.d.tl$" }, - { - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "%[%[", "%]%]" }, "string" }, - { { "%-%-%[%[", "%]%]" }, "comment" }, - { { "%-%-.-\n" }, "comment" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "<%a+>" }, "keyword2" }, - { { "%.%.%.?" }, "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" }, { "global", "keyword" }, - { "in", "keyword" }, { "not", "keyword" }, { "and", "keyword" }, - { "or", "keyword" }, { "goto", "keyword" }, { "enum", "keyword" }, - { "record", "keyword" }, { "any", "keyword2" }, { "boolean", "keyword2" }, - { "number", "keyword2" }, { "string", "keyword2" }, { "thread", "keyword2" }, - { "true", "literal" }, { "false", "literal" }, { "nil", "literal" }, - }, - "--", - { "^#!.*[ /]tl" } } ); -} - static void addVue() { SyntaxDefinitionManager::instance() ->add( { "Vue-HTML", @@ -2088,361 +1557,6 @@ static void addVue() { {} } ); } -static void addElixir() { - SyntaxDefinitionManager::instance()->add( - { "Elixir", - { "%.ex$", "%.exs$" }, - { { { "#.*\n" }, "comment" }, - { { ":\"", "\"", "\\" }, "number" }, - { { "\"\"\"", "\"\"\"", "\\" }, "string" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "~%a\"\"\"", "\"\"\"" }, "string" }, - { { "~%a[/\"|'%(%[%{<]", "[/\"|'%)%]%}>]", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { ":\"?[%a_][%w_]*\"?" }, "number" }, - { { "[%a][%w_!?]*%f[(]" }, "function" }, - { { "%u%w+" }, "normal" }, - { { "@[%a_][%w_]*" }, "keyword2" }, - { { "_%a[%w_]*" }, "keyword2" }, - { { "[%+%-=/%*<>!|&]" }, "operator" }, - { { "[%a_][%w_]*" }, "symbol" } }, - { { "def", "keyword" }, - { "defp", "keyword" }, - { "defguard", "keyword" }, - { "defguardp", "keyword" }, - { "defmodule", "keyword" }, - { "defprotocol", "keyword" }, - { "defimpl", "keyword" }, - { "defrecord", "keyword" }, - { "defrecordp", "keyword" }, - { "defmacro", "keyword" }, - { "defmacrop", "keyword" }, - { "defdelegate", "keyword" }, - { "defoverridable", "keyword" }, - { "defexception", "keyword" }, - { "defcallback", "keyword" }, - { "defstruct", "keyword" }, - { "for", "keyword" }, - { "case", "keyword" }, - { "when", "keyword" }, - { "with", "keyword" }, - { "cond", "keyword" }, - { "if", "keyword" }, - { "unless", "keyword" }, - { "try", "keyword" }, - { "receive", "keyword" }, - { "after", "keyword" }, - { "raise", "keyword" }, - { "rescue", "keyword" }, - { "catch", "keyword" }, - { "else", "keyword" }, - { "quote", "keyword" }, - { "unquote", "keyword" }, - { "super", "keyword" }, - { "unquote_splicing", "keyword" }, - { "do", "keyword" }, - { "end", "keyword" }, - { "fn", "keyword" }, - { "import", "keyword2" }, - { "alias", "keyword2" }, - { "use", "keyword2" }, - { "require", "keyword2" }, - { "and", "operator" }, - { "or", "operator" }, - { "true", "literal" }, - { "false", "literal" }, - { "nil", "literal" } }, - "#" } ); -} - -static void addCrystal() { - SyntaxDefinitionManager::instance()->add( - { "Crystal", - { "%.cr$" }, - { - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "%#.-\n" }, "comment" }, - { { " : [%w_| :]*" }, "comment" }, - { { "-?%d+[%d%.eE]*%f[^eE]" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(?]" }, "function" }, - { { "%.[%a_][%w_]*%f[(%s]" }, "function" }, - { { "@?@[%a_][%w_]*" }, "keyword2" }, - { { ":-[%u_][%u%d_]*%f[^%w]" }, "keyword2" }, - { { "::[%w_]*" }, "symbol" }, - { { ":[%w_]*" }, "symbol" }, - { { "[%a_][%w_]*:[^:]" }, "keyword2" }, - { { "[%a_][%w_]*" }, "symbol" }, - { { "%s+" }, "normal" }, - { { "%w+%f[%s]" }, "normal" }, - }, - { - { "yield", "keyword" }, { "unless", "keyword" }, - { "undef", "keyword" }, { "true", "literal" }, - { "then", "keyword" }, { "super", "keyword2" }, - { "return", "keyword" }, { "responds_to?", "function" }, - { "rescue", "keyword" }, { "private", "keyword2" }, - { "puts", "function" }, { "p!", "function" }, - { "out", "function" }, { "class", "keyword" }, - { "break", "keyword" }, { "self", "keyword2" }, - { "alias", "keyword" }, { "fun", "keyword" }, - { "Void", "literal" }, { "until", "keyword" }, - { "abstract", "keyword" }, { "__LINE__", "keyword" }, - { "annotation", "keyword2" }, { "__FILE__", "keyword" }, - { "__ENCODING__", "keyword" }, { "case", "keyword" }, - { "BEGIN", "keyword" }, { "END", "keyword" }, - { "end", "keyword" }, { "else", "keyword" }, - { "defined?", "keyword" }, { "require", "keyword" }, - { "do", "keyword" }, { "while", "keyword" }, - { "ensure", "keyword" }, { "include", "keyword" }, - { "nil", "literal" }, { "begin", "keyword" }, - { "enum", "keyword2" }, { "when", "keyword" }, - { "extend", "keyword" }, { "next", "keyword" }, - { "if", "keyword" }, { "false", "literal" }, - { "def", "keyword" }, { "elsif", "keyword" }, - { "in", "keyword" }, { "module", "keyword" }, - - }, - "#", - {} } ); -} - -static void addV() { - SyntaxDefinitionManager::instance()->add( - { "V", - { "%.v$", "%.vsh$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "`", "`", "\\" }, "string" }, - { { "r'", "'" }, "string" }, - { { "r\"", "\"" }, "string" }, - { { "0x[%da-fA-F_]+" }, "number" }, - { { "0b[01_]+" }, "number" }, - { { "00[01234567_]+" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%+%-%*%/%%%~%&%|%^%!%=]" }, "operator" }, - { { "%:%=" }, "operator" }, - { { "%.%.%.?" }, "operator" }, - { { "[%a_][%w_]*" }, "symbol" }, - { { "%$%s?[%a_][%w_]*" }, "keyword2" }, - { { "%@%s?[%a_][%w_]*" }, "keyword2" }, - { { "%s+" }, "normal" }, - { { "%w+%f[%s]" }, "normal" }, - }, - { - { "voidptr", "keyword2" }, { "unsafe", "keyword" }, { "u16", "keyword2" }, - { "i128", "keyword2" }, { "goto", "keyword" }, { "as", "keyword" }, - { "go", "keyword" }, { "for", "keyword" }, { "import", "keyword" }, - { "fn", "keyword" }, { "if", "keyword" }, { "i64", "keyword2" }, - { "typeof", "keyword" }, { "f32", "keyword2" }, { "union", "keyword" }, - { "u32", "keyword2" }, { "const", "keyword" }, { "char", "keyword2" }, - { "continue", "keyword" }, { "byte", "keyword2" }, { "i16", "keyword2" }, - { "assert", "keyword" }, { "bool", "keyword2" }, { "atomic", "keyword" }, - { "isreftype", "keyword" }, { "u8", "keyword2" }, { "chan", "keyword2" }, - { "u128", "keyword2" }, { "__offsetof", "keyword" }, { "i8", "keyword2" }, - { "int", "keyword2" }, { "is", "keyword" }, { "defer", "keyword" }, - { "interface", "keyword" }, { "false", "literal" }, { "or", "keyword" }, - { "pub", "keyword" }, { "lock", "keyword" }, { "map", "keyword2" }, - { "module", "keyword" }, { "rune", "keyword2" }, { "shared", "keyword" }, - { "mut", "keyword" }, { "match", "keyword" }, { "static", "keyword" }, - { "asm", "keyword" }, { "none", "literal" }, { "return", "keyword" }, - { "in", "keyword" }, { "else", "keyword" }, { "break", "keyword" }, - { "rlock", "keyword" }, { "select", "keyword" }, { "enum", "keyword" }, - { "f64", "keyword2" }, { "sizeof", "keyword" }, { "string", "keyword2" }, - { "struct", "keyword" }, { "thread", "keyword2" }, { "true", "literal" }, - { "type", "keyword" }, { "u64", "keyword2" }, - }, - "//", - {} } ); -} - -static void addJulia() { - SyntaxDefinitionManager::instance()->add( - { "Julia", - { "%.jl$" }, - { - { { "#=", "=#" }, "comment" }, - { { "#.*$" }, "comment" }, - { { "icxx\"\"\"", "\"\"\"" }, "string", "C++" }, - { { "cxx\"\"\"", "\"\"\"" }, "string", "C++" }, - { { "py\"\"\"", "\"\"\"" }, "string", "Python" }, - { { "js\"\"\"", "\"\"\"" }, "string", "JavaScript" }, - { { "md\"\"\"", "\"\"\"" }, "string", "Markdown" }, - { { "%d%w*[%.-+*//]" }, "number" }, - { { "0[oO_][0-7]+" }, "number" }, - { { "-?0x[%x_]+" }, "number" }, - { { "-?0b[%x_]+" }, "number" }, - { { "-?%d+_%d" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[^%d%g]%:%a*" }, "function" }, - { { "[%+%-=/%*%^%%<>!~|&%:]" }, "operator" }, - { { "\"\"\".*\"\"\"" }, "string" }, - { { "\".*\"" }, "string" }, - { { "[bv]\".*\"" }, "string" }, - { { "r\".*$" }, "string" }, - { { "'\\.*'" }, "string" }, - { { "'.'" }, "string" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "%g*!" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - { { "%s+" }, "normal" }, - { { "%w+%f[%s]" }, "normal" }, - }, - { - { "while", "keyword" }, { "where", "keyword" }, { "using", "keyword" }, - { "typeof", "keyword" }, { "true", "literal" }, { "UInt8", "keyword2" }, - { "elseif", "keyword" }, { "type", "keyword" }, { "String", "keyword2" }, - { "Float16", "keyword2" }, { "if", "keyword" }, { "Set", "keyword" }, - { "Union", "keyword" }, { "UInt16", "keyword2" }, { "Float32", "keyword2" }, - { "try", "keyword" }, { "UInt128", "keyword2" }, { "Ref", "keyword2" }, - { "Function", "keyword2" }, { "Matrix", "keyword2" }, { "Vector", "keyword2" }, - { "module", "keyword" }, { "UInt32", "keyword2" }, { "Int8", "keyword2" }, - { "continue", "keyword" }, { "end", "keyword" }, { "Int128", "keyword2" }, - { "baremodule", "keyword" }, { "Char", "keyword2" }, { "abstract", "keyword2" }, - { "Inf", "literal" }, { "Int16", "keyword2" }, { "primitive", "keyword2" }, - { "Int64", "keyword2" }, { "missing", "literal" }, { "mutable", "keyword2" }, - { "NaN", "literal" }, { "Bool", "keyword2" }, { "Int32", "keyword2" }, - { "macro", "keyword" }, { "UInt64", "keyword2" }, { "Int", "keyword2" }, - { "catch", "keyword" }, { "do", "keyword" }, { "export", "keyword" }, - { "false", "literal" }, { "Integer", "keyword2" }, { "else", "keyword" }, - { "break", "keyword" }, { "in", "keyword" }, { "Float64", "keyword2" }, - { "finally", "keyword" }, { "const", "keyword" }, { "local", "keyword" }, - { "begin", "keyword" }, { "for", "keyword" }, { "import", "keyword" }, - { "function", "keyword" }, { "Dict", "keyword" }, { "global", "keyword" }, - { "let", "keyword" }, { "return", "keyword" }, { "nothing", "literal" }, - { "quote", "keyword" }, { "Number", "keyword2" }, { "struct", "keyword2" }, - }, - "#", - {} } ); -} - -static void addElm() { - SyntaxDefinitionManager::instance()->add( - { "Elm", - { "%.elm$" }, - { - { { "%-%-", "\n" }, "comment" }, - { { "{%-", "%-}" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "\"\"\"", "\"\"\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "%.%." }, "operator" }, - { { "[=:|&<>%+%-%*\\/%^%%]" }, "operator" }, - { { "[%a_'][%w_']*" }, "symbol" }, - { { "%s+" }, "normal" }, - { { "%w+%f[%s]" }, "normal" }, - }, - { - { "or", "keyword" }, { "of", "keyword" }, { "number", "keyword2" }, - { "module", "keyword" }, { "not", "keyword" }, { "let", "keyword" }, - { "in", "keyword" }, { "port", "keyword" }, { "import", "keyword" }, - { "if", "keyword" }, { "Bool", "keyword2" }, { "type", "keyword" }, - { "case", "keyword" }, { "xor", "keyword" }, { "alias", "keyword" }, - { "String", "keyword2" }, { "True", "literal" }, { "Char", "keyword2" }, - { "Float", "keyword2" }, { "else", "keyword" }, { "False", "literal" }, - { "exposing", "keyword" }, { "Int", "keyword2" }, { "and", "keyword" }, - { "then", "keyword" }, { "as", "keyword" }, - }, - "%-%-", - {} } ); -} - -static void addToml() { - SyntaxDefinitionManager::instance()->add( - { "TOML", - { "%.toml$" }, - { - { { "#.-\n" }, "comment" }, - { { "\"\"\"", "\"\"\"", "\\" }, "string" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'''", "'''" }, "string" }, - { { "'", "'" }, "string" }, - { { "[A-Za-z0-9_%.%-]+%s*%f[=]" }, "function" }, - { { "%[[A-Za-z0-9_%.%- ]+%]" }, "keyword" }, - { { "%[%[[A-Za-z0-9_%.%- ]+%]%]" }, "keyword" }, - { { "[%-+]?[0-9_]+%.[0-9_]+[eE][%-+]?[0-9_]+" }, "number" }, - { { "[%-+]?[0-9_]+%.[0-9_]+" }, "number" }, - { { "[%-+]?[0-9_]+[eE][%-+]?[0-9_]+" }, "number" }, - { { "[%-+]?[0-9_]+" }, "number" }, - { { "[%-+]?0x[0-9a-fA-F_]+" }, "number" }, - { { "[%-+]?0o[0-7_]+" }, "number" }, - { { "[%-+]?0b[01_]+" }, "number" }, - { { "[%-+]?nan" }, "number" }, - { { "[%-+]?inf" }, "number" }, - { { "[a-z]+" }, "symbol" }, - { { "%s+" }, "normal" }, - { { "%w+%f[%s]" }, "normal" }, - }, - { - { "true", "literal" }, - { "false", "literal" }, - }, - "#", - {} } ); -} - -static void addFstab() { - SyntaxDefinitionManager::instance()->add( - { "fstab", - { "fstab" }, - { - { { "^#.*$" }, "comment" }, - { { "[=/:.,]+" }, "operator" }, - { { "/.*/" }, "string" }, - { { "#" }, "operator" }, - { { "%w-%-%w-%-%w-%-%w-%-%w- " }, "string" }, - { { "%d+%.%d+%.%d+%.%d+" }, "string" }, - { { " %d+ " }, "number" }, - { { "[%w_]+" }, "symbol" }, - { { "%s+" }, "normal" }, - { { "%w+%f[%s]" }, "normal" }, - }, - { - { "xfs", "keyword2" }, { "ufs", "keyword2" }, - { "sysfs", "keyword2" }, { "swap", "keyword2" }, - { "sockfs", "keyword2" }, { "qnx4", "keyword2" }, - { "pipefs", "keyword2" }, { "none", "literal" }, - { "nfsd", "keyword2" }, { "msdos", "keyword2" }, - { "cpuset", "keyword2" }, { "autofs", "keyword2" }, - { "configfs", "keyword2" }, { "mqueue", "keyword2" }, - { "cgroup2", "keyword2" }, { "securityfs", "keyword2" }, - { "cgroup", "keyword2" }, { "binfmt_misc", "keyword2" }, - { "binder", "keyword2" }, { "proc", "keyword2" }, - { "btrfs", "keyword2" }, { "hugetlbfs", "keyword2" }, - { "aufs", "keyword2" }, { "UUID", "keyword" }, - { "LABEL", "keyword" }, { "squashfs", "keyword2" }, - { "devpts", "keyword2" }, { "vfat", "keyword2" }, - { "ecryptfs", "keyword2" }, { "ramfs", "keyword2" }, - { "ext4", "keyword2" }, { "minix", "keyword2" }, - { "ext2", "keyword2" }, { "tracefs", "keyword2" }, - { "ext3", "keyword2" }, { "pstore", "keyword2" }, - { "nfs4", "keyword2" }, { "bpf", "keyword2" }, - { "fuse", "keyword2" }, { "debugfs", "keyword2" }, - { "fuseblk", "keyword2" }, { "tmpfs", "keyword2" }, - { "ntfs", "keyword2" }, { "bdev", "keyword2" }, - { "fusectl", "keyword2" }, { "rpc_pipefs", "keyword2" }, - { "hfs", "keyword2" }, { "devtmpfs", "keyword2" }, - { "hfsplus", "keyword2" }, { "nfs", "keyword2" }, - { "jfs", "keyword2" }, - }, - "#", - {} } ); -} - static void addHaxe() { SyntaxDefinitionManager::instance()->add( { "Haxe Compiler Arguments", @@ -2536,50 +1650,6 @@ static void addHaxe() { {} } ); } -static void addR() { - SyntaxDefinitionManager::instance()->add( - - { "R", - { "%.r$", "%.rds$", "%.rda$", "%.rdata$", "%.R$" }, - { - { { "#", "\n" }, "comment" }, - { { "\"", "\"" }, "string" }, - { { "'", "'" }, "string" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - { { "[%+%-=/%*%^%%<>!|&]" }, "operator" }, - { { "0x[%da-fA-F]+" }, "number" }, - { { "-?%d+[%d%.eE]*" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "%s+" }, "normal" }, - { { "%w+%f[%s]" }, "normal" }, - }, - { - { "repeat", "keyword" }, - { "next", "keyword" }, - { "in", "keyword" }, - { "if", "keyword" }, - { "FALSE", "literal" }, - { "NA_integer", "keyword" }, - { "NA_character", "keyword" }, - { "break", "keyword" }, - { "while", "keyword" }, - { "NA_complex", "keyword" }, - { "NA_real", "keyword" }, - { "else", "keyword" }, - { "NULL", "literal" }, - { "TRUE", "literal" }, - { "Inf", "literal" }, - { "for", "keyword" }, - { "NA", "literal" }, - { "function", "keyword" }, - }, - "#", - {} - - } ); -} - // 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. @@ -2587,7 +1657,7 @@ SyntaxDefinitionManager::SyntaxDefinitionManager() { if ( ms_singleton == nullptr ) ms_singleton = this; - mDefinitions.reserve( 65 ); + mDefinitions.reserve( 66 ); // Register some languages support. addPlainText(); @@ -3085,21 +2155,21 @@ const SyntaxDefinition& SyntaxDefinitionManager::getByExtension( const std::stri extension = FileSystem::fileNameFromPath( filePath ); if ( !extension.empty() ) { - for ( auto style = mDefinitions.rbegin(); style != mDefinitions.rend(); ++style ) { - for ( const auto& ext : style->getFiles() ) { + for ( const auto& style : mDefinitions ) { + for ( const auto& ext : style.getFiles() ) { if ( String::startsWith( ext, "%." ) || String::startsWith( ext, "^" ) || String::endsWith( ext, "$" ) ) { LuaPattern words( ext ); int start, end; if ( words.find( fileName, start, end ) ) { - if ( hFileAsCPP && style->getLSPName() == "c" && ext == "%.h$" ) + if ( hFileAsCPP && style.getLSPName() == "c" && ext == "%.h$" ) return getByLSPName( "cpp" ); - return *style; + return style; } } else if ( extension == ext ) { - if ( hFileAsCPP && style->getLSPName() == "c" && ext == ".h" ) + if ( hFileAsCPP && style.getLSPName() == "c" && ext == ".h" ) return getByLSPName( "cpp" ); - return *style; + return style; } } }