Added x86 assembly syntax highlighting (Closes SpartanJ/ecode#75).

Added PICO8 syntax highlighting. Added PSQL syntax highlighting. Added Haskell linter, formatter and LSP support. Improved JSON syntax definition to CPP. Cleaning up SyntaxDefinitionManager.
2026-05-28 17:16:29 +03:00 · 2023-03-09 02:14:14 -03:00
parent 7c1edee00d
commit c6200f4b53
19 changed files with 4169 additions and 1341 deletions
--- a/bin/assets/plugins/formatters.json
+++ b/bin/assets/plugins/formatters.json
@@ -61,6 +61,11 @@
      "file_patterns": ["%.zig"],
      "command": "zig fmt $FILENAME",
      "type": "inplace"
+    },
+    {
+      "language": "haskell",
+      "file_patterns": ["%.hs$"],
+      "command": "ornolu $FILENAME"
    }
  ]
 }
--- a/bin/assets/plugins/linters.json
+++ b/bin/assets/plugins/linters.json
@@ -99,6 +99,13 @@
      "warning_pattern": "[^:]:(%d+):(%d+):[%s]?([^\n]+)",
      "command": "tl check $FILENAME",
      "expected_exitcodes": [0]
+    },
+    {
+      "language": "haskell",
+      "file_patterns": ["%.hs$"],
+      "warning_pattern": "$FILENAME:(%d+):(%d+):%s(%w*):%s([^\n]*)",
+      "warning_pattern_order": { "line": 1, "col": 2, "message": 4, "type": 3 },
+      "command": "hlint --color=never -j $FILENAME"
    }
  ]
 }
--- a/bin/assets/plugins/lspclient.json
+++ b/bin/assets/plugins/lspclient.json
@@ -190,6 +190,14 @@
      "url": "https://soliditylang.org",
      "command": "solc --lsp",
      "file_patterns": ["%.sol$"]
+    },
+    {
+      "language": "haskell",
+      "name": "haskell-language-server",
+      "url": "https://github.com/haskell/haskell-language-server --lsp",
+      "command": "haskell-language-server-wrapper",
+      "file_patterns": ["%.hs$"],
+      "rootIndicationFileNames": ["%.cabal$", "stack.yaml", "cabal.project", "package.yaml", "hie.yaml"]
    }
  ]
 }
--- a/include/eepp/ui/doc/syntaxdefinitionmanager.hpp
+++ b/include/eepp/ui/doc/syntaxdefinitionmanager.hpp
@@ -16,7 +16,7 @@ namespace EE { namespace UI { namespace Doc {
 class EE_API SyntaxDefinitionManager {
 	SINGLETON_DECLARE_HEADERS( SyntaxDefinitionManager )
  public:
-	static std::string toCPP( const SyntaxDefinition& def );
+	static std::pair<std::string, std::string> toCPP( const SyntaxDefinition& def );

 	SyntaxDefinition& add( SyntaxDefinition&& syntaxStyle );

@@ -69,7 +69,6 @@ class EE_API SyntaxDefinitionManager {
 	std::vector<SyntaxDefinition> mDefinitions;

 	std::optional<size_t> getLanguageIndex( const std::string& langName );
-
 };

 }}} // namespace EE::UI::Doc
--- a/premake4.lua
+++ b/premake4.lua
@@ -926,6 +926,7 @@ function build_eepp( build_name )
 			"src/eepp/ui/models/*.cpp",
 			"src/eepp/ui/css/*.cpp",
 			"src/eepp/ui/doc/*.cpp",
+			"src/eepp/ui/doc/languages/*.cpp",
 			"src/eepp/ui/tools/*.cpp"
 	}

--- a/premake5.lua
+++ b/premake5.lua
@@ -609,6 +609,7 @@ function build_eepp( build_name )
 			"src/eepp/ui/models/*.cpp",
 			"src/eepp/ui/css/*.cpp",
 			"src/eepp/ui/doc/*.cpp",
+			"src/eepp/ui/doc/languages/*.cpp",
 			"src/eepp/ui/tools/*.cpp",
 			"src/eepp/physics/*.cpp",
 			"src/eepp/physics/constraints/*.cpp"
--- a/projects/android-project/app/jni/eepp.mk
+++ b/projects/android-project/app/jni/eepp.mk
@@ -90,6 +90,7 @@ CODE_SRCS				:=  \
 	ui/*.cpp \
 	ui/css/*.cpp \
 	ui/doc/*.cpp \
+	ui/doc/languages/*.cpp \
 	ui/abstract/*.cpp \
 	ui/models/*.cpp \
 	ui/tools/*.cpp
--- a/src/eepp/ui/doc/languages/hlsl.cpp
+++ b/src/eepp/ui/doc/languages/hlsl.cpp
@@ -0,0 +1,269 @@
+#include <eepp/ui/doc/languages/x86assembly.hpp>
+#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
+
+namespace EE { namespace UI { namespace Doc { namespace Language {
+
+void addHLSL() {
+
+	SyntaxDefinitionManager::instance()->add(
+
+		{ "HLSL",
+		  {
+			  "%.hlsl$",
+		  },
+		  {
+			  { { "//.-\n" }, "comment" },
+			  { { "/%*", "%*/" }, "comment" },
+			  { { "#", "[^\\]\n" }, "comment" },
+			  { { "\"", "\"", "\\" }, "string" },
+			  { { "'", "'", "\\" }, "string" },
+			  { { "-?0x%x+" }, "number" },
+			  { { "-?%d+[%d%.eE]*f?" }, "number" },
+			  { { "-?%.?%d+f?" }, "number" },
+			  { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" },
+			  { { "int[1-9]x[1-9]" }, "keyword2" },
+			  { { "int1[0-6]x[1-9]" }, "keyword2" },
+			  { { "int[1-9]x1[0-6]" }, "keyword2" },
+			  { { "int1[0-6]x1[0-6]" }, "keyword2" },
+			  { { "int[1-4]" }, "keyword2" },
+			  { { "uint[1-9]x[1-9]" }, "keyword2" },
+			  { { "uint1[0-6]x[1-9]" }, "keyword2" },
+			  { { "uint[1-9]x1[0-6]" }, "keyword2" },
+			  { { "uint1[0-6]x1[0-6]" }, "keyword2" },
+			  { { "uint[1-4]" }, "keyword2" },
+			  { { "dword[1-9]x[1-9]" }, "keyword2" },
+			  { { "dword1[0-6]x[1-9]" }, "keyword2" },
+			  { { "dword[1-9]x1[0-6]" }, "keyword2" },
+			  { { "dword1[0-6]x1[0-6]" }, "keyword2" },
+			  { { "dword[1-4]" }, "keyword2" },
+			  { { "half[1-9]x[1-9]" }, "keyword2" },
+			  { { "half1[0-6]x[1-9]" }, "keyword2" },
+			  { { "half[1-9]x1[0-6]" }, "keyword2" },
+			  { { "half1[0-6]x1[0-6]" }, "keyword2" },
+			  { { "half[1-4]" }, "keyword2" },
+			  { { "float[1-9]x[1-9]" }, "keyword2" },
+			  { { "float1[0-6]x[1-9]" }, "keyword2" },
+			  { { "float[1-9]x1[0-6]" }, "keyword2" },
+			  { { "float1[0-6]x1[0-6]" }, "keyword2" },
+			  { { "float[1-4]" }, "keyword2" },
+			  { { "double[1-9]x[1-9]" }, "keyword2" },
+			  { { "double1[0-6]x[1-9]" }, "keyword2" },
+			  { { "double[1-9]x1[0-6]" }, "keyword2" },
+			  { { "double1[0-6]x1[0-6]" }, "keyword2" },
+			  { { "double[1-4]" }, "keyword2" },
+			  { { "[%a_][%w_]*%f[(]" }, "function" },
+			  { { "[%a_][%w_]*" }, "symbol" },
+		  },
+		  {
+			  { "AppendStructuredBuffer", "keyword" },
+			  { "asm", "keyword" },
+			  { "asm_fragment", "keyword" },
+			  { "BlendState", "keyword2" },
+			  { "bool", "keyword2" },
+			  { "break", "keyword" },
+			  { "Buffer", "keyword2" },
+			  { "ByteAddressBuffer", "keyword2" },
+			  { "case", "keyword" },
+			  { "cbuffer", "keyword2" },
+			  { "centroid", "keyword2" },
+			  { "class", "keyword" },
+			  { "column_major", "keyword" },
+			  { "compile", "keyword" },
+			  { "compile_fragment", "keyword" },
+			  { "CompileShader", "keyword" },
+			  { "const", "keyword" },
+			  { "continue", "keyword" },
+			  { "ComputeShader", "keyword" },
+			  { "ConsumeStructuredBuffer", "keyword" },
+			  { "default", "keyword" },
+			  { "DepthStencilState", "keyword" },
+			  { "DepthStencilView", "keyword" },
+			  { "discard", "keyword" },
+			  { "do", "keyword" },
+			  { "double", "keyword2" },
+			  { "DomainShader", "keyword2" },
+			  { "dword", "keyword2" },
+			  { "else", "keyword" },
+			  { "export", "keyword" },
+			  { "extern", "keyword" },
+			  { "false", "literal" },
+			  { "float", "keyword2" },
+			  { "for", "keyword" },
+			  { "fxgroup", "keyword2" },
+			  { "GeometryShader", "keyword2" },
+			  { "groupshared", "keyword" },
+			  { "half", "keyword2" },
+			  { "HullShader", "keyword2" },
+			  { "if", "keyword" },
+			  { "in", "keyword" },
+			  { "inline", "keyword" },
+			  { "inout", "keyword" },
+			  { "InputPatch", "keyword2" },
+			  { "int", "keyword2" },
+			  { "interface", "keyword" },
+			  { "line", "keyword2" },
+			  { "lineadj", "keyword2" },
+			  { "linear", "keyword" },
+			  { "LineStream", "keyword2" },
+			  { "matrix", "keyword2" },
+			  { "min16float", "keyword2" },
+			  { "min10float", "keyword2" },
+			  { "min16int", "keyword2" },
+			  { "min12int", "keyword2" },
+			  { "min16uint", "keyword2" },
+			  { "namespace", "keyword" },
+			  { "nointerpolation", "keyword" },
+			  { "noperspective", "keyword" },
+			  { "NULL", "literal" },
+			  { "out", "keyword" },
+			  { "OutputPatch", "keyword2" },
+			  { "packoffset", "keyword" },
+			  { "pass", "keyword" },
+			  { "pixelfragment", "keyword" },
+			  { "PixelShader", "keyword2" },
+			  { "point", "keyword2" },
+			  { "PointStream", "keyword2" },
+			  { "precise", "keyword" },
+			  { "RasterizerState", "keyword2" },
+			  { "RenderTargetView", "keyword2" },
+			  { "return", "keyword" },
+			  { "register", "keyword" },
+			  { "row_major", "keyword" },
+			  { "RWBuffer", "keyword2" },
+			  { "RWByteAddressBuffer", "keyword2" },
+			  { "RWStructuredBuffer", "keyword2" },
+			  { "RWTexture1D", "keyword2" },
+			  { "RWTexture1DArray", "keyword2" },
+			  { "RWTexture2D", "keyword2" },
+			  { "RWTexture2DArray", "keyword2" },
+			  { "RWTexture3D", "keyword2" },
+			  { "sample", "keyword" },
+			  { "sampler", "keyword2" },
+			  { "SamplerState", "keyword2" },
+			  { "SamplerComparisonState", "keyword2" },
+			  { "shared", "keyword" },
+			  { "snorm", "keyword" },
+			  { "stateblock", "keyword" },
+			  { "stateblock_state", "keyword" },
+			  { "static", "keyword" },
+			  { "string", "keyword2" },
+			  { "struct", "keyword" },
+			  { "switch", "keyword" },
+			  { "StructuredBuffer", "keyword2" },
+			  { "tbuffer", "keyword2" },
+			  { "technique", "keyword2" },
+			  { "technique10", "keyword2" },
+			  { "technique11", "keyword2" },
+			  { "texture", "keyword2" },
+			  { "Texture1D", "keyword2" },
+			  { "Texture1DArray", "keyword2" },
+			  { "Texture2D", "keyword2" },
+			  { "Texture2DArray", "keyword2" },
+			  { "Texture2DMS", "keyword2" },
+			  { "Texture2DMSArray", "keyword2" },
+			  { "Texture3D", "keyword2" },
+			  { "TextureCube", "keyword2" },
+			  { "TextureCubeArray", "keyword2" },
+			  { "true", "literal" },
+			  { "typedef", "keyword" },
+			  { "triangle", "keyword2" },
+			  { "triangleadj", "keyword2" },
+			  { "TriangleStream", "keyword2" },
+			  { "uint", "keyword2" },
+			  { "uniform", "keyword" },
+			  { "unorm", "keyword" },
+			  { "unsigned", "keyword" },
+			  { "vector", "keyword2" },
+			  { "vertexfragment", "keyword2" },
+			  { "VertexShader", "keyword2" },
+			  { "void", "keyword" },
+			  { "volatile", "keyword" },
+			  { "while", "keyword" },
+			  { "abort", "keyword" },
+			  { "abs", "keyword" },
+			  { "acos", "keyword" },
+			  { "all", "keyword" },
+			  { "any", "keyword" },
+			  { "asdouble", "keyword" },
+			  { "asfloat", "keyword" },
+			  { "asin", "keyword" },
+			  { "asint", "keyword" },
+			  { "asuint", "keyword" },
+			  { "atan", "keyword" },
+			  { "atan2", "keyword" },
+			  { "ceil", "keyword" },
+			  { "clamp", "keyword" },
+			  { "clip", "keyword" },
+			  { "cos", "keyword" },
+			  { "cosh", "keyword" },
+			  { "countbits", "keyword" },
+			  { "cross", "keyword" },
+			  { "ddx", "keyword" },
+			  { "ddx_coarse", "keyword" },
+			  { "ddx_fine", "keyword" },
+			  { "ddy", "keyword" },
+			  { "ddy_coarse", "keyword" },
+			  { "ddy_fine", "keyword" },
+			  { "degrees", "keyword" },
+			  { "determinant", "keyword" },
+			  { "distance", "keyword" },
+			  { "dot", "keyword" },
+			  { "dst", "keyword" },
+			  { "errorf", "keyword" },
+			  { "exp", "keyword" },
+			  { "exp2", "keyword" },
+			  { "f16tof32", "keyword" },
+			  { "f32tof16", "keyword" },
+			  { "faceforward", "keyword" },
+			  { "firstbithigh", "keyword" },
+			  { "firstbitlow", "keyword" },
+			  { "floor", "keyword" },
+			  { "fma", "keyword" },
+			  { "fmod", "keyword" },
+			  { "frac", "keyword" },
+			  { "frexp", "keyword" },
+			  { "fwidth", "keyword" },
+			  { "isfinite", "keyword" },
+			  { "isinf", "keyword" },
+			  { "isnan", "keyword" },
+			  { "ldexp", "keyword" },
+			  { "length", "keyword" },
+			  { "lerp", "keyword" },
+			  { "lit", "keyword" },
+			  { "log", "keyword" },
+			  { "log10", "keyword" },
+			  { "log2", "keyword" },
+			  { "mad", "keyword" },
+			  { "max", "keyword" },
+			  { "min", "keyword" },
+			  { "modf", "keyword" },
+			  { "msad4", "keyword" },
+			  { "mul", "keyword" },
+			  { "noise", "keyword" },
+			  { "normalize", "keyword" },
+			  { "pow", "keyword" },
+			  { "printf", "keyword" },
+			  { "radians", "keyword" },
+			  { "rcp", "keyword" },
+			  { "reflect", "keyword" },
+			  { "refract", "keyword" },
+			  { "reversebits", "keyword" },
+			  { "round", "keyword" },
+			  { "rsqrt", "keyword" },
+			  { "saturate", "keyword" },
+			  { "sign", "keyword" },
+			  { "sin", "keyword" },
+			  { "sincos", "keyword" },
+			  { "sinh", "keyword" },
+			  { "smoothstep", "keyword" },
+			  { "sqrt", "keyword" },
+			  { "step", "keyword" },
+			  { "tan", "keyword" },
+			  { "tanh", "keyword" },
+			  { "transpose", "keyword" },
+			  { "trunc", "keyword" },
+		  },
+		  "//" } );
+}
+
+}}}} // namespace EE::UI::Doc::Language
--- a/src/eepp/ui/doc/languages/hlsl.hpp
+++ b/src/eepp/ui/doc/languages/hlsl.hpp
@@ -0,0 +1,10 @@
+#ifndef EE_UI_DOC_HLSL
+#define EE_UI_DOC_HLSL
+
+namespace EE { namespace UI { namespace Doc { namespace Language {
+
+extern void addHLSL();
+
+}}}}
+
+#endif
--- a/src/eepp/ui/doc/languages/htaccess.cpp
+++ b/src/eepp/ui/doc/languages/htaccess.cpp
@@ -0,0 +1,699 @@
+#include <eepp/ui/doc/languages/x86assembly.hpp>
+#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
+
+namespace EE { namespace UI { namespace Doc { namespace Language {
+
+void addHtaccessFile() {
+
+	SyntaxDefinitionManager::instance()->add(
+		{ ".htaccess",
+		  { "^%.htaccess$" },
+		  {
+			  { { "#.*\n" }, "comment" },
+			  { { "\"", "\"", "\\" }, "string" },
+			  { { "'", "'", "\\" }, "string" },
+			  { { "`", "`", "\\" }, "string" },
+			  { { "%[!%[([^%]].-)%]%((https?://[%w_.~!*:@&+$/?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/"
+				  "?[%w_.~!*:@&+$/?%%#=-]*)%)%]%((https?://[%w_.~!*:@&+$/"
+				  "?%%#-]-%w[-.%w]*%.%w%w%w?%w?:?%d*/?[%w_.~!*:@&+$/?%%#=-]*)%)" },
+				{ "keyword", "function", "link", "link" } },
+			  { { "%f[%w]application/[%w%._+-]+" }, "keyword2" },
+			  { { "%f[%w]font/[%w%._+-]+" }, "keyword2" },
+			  { { "%f[%w]image/[%w%._+-]+" }, "keyword2" },
+			  { { "%f[%w]text/[%w%._+-]+" }, "keyword2" },
+			  { { "%f[%w]audio/[%w%._+-]+" }, "keyword2" },
+			  { { "%f[%w]video/[%w%._+-]+" }, "keyword2" },
+			  { { "%d+%.%d+%.%d+%.%d+" }, "keyword2" },
+			  { { "%d+%.%d+%.%d+%.%d+/%d+" }, "keyword2" },
+			  { { "%w+@%w+%.%w+" }, "keyword2" },
+			  { { "%f[%S]%b[]" }, "number" },
+			  { { "</?%w+", ">" }, "literal" },
+			  { { "[%%$]%d+" }, "keyword2" },
+			  { { "[%%$]%{[%w_:%-]+%}" }, "keyword2" },
+			  { { "A?%d+" }, "number" },
+			  { { "%f[%S][!=+%-]+" }, "operator" },
+			  { { "%f[^%s!]%^%S*" }, "literal" },
+			  { { "%f[^%s!]%S*%$" }, "literal" },
+			  { { "%f[^%s!]%b()" }, "literal" },
+			  { { "[%a_][%w_-]*" }, "symbol" },
+			  { { "%s+" }, "normal" },
+			  { { "%w+%f[%s]" }, "normal" },
+		  },
+		  {
+			  { "xml2EncDefault", "keyword" },
+			  { "unset", "literal" },
+			  { "php_value", "keyword" },
+			  { "php_flag", "keyword" },
+			  { "php_admin_flag", "keyword" },
+			  { "on", "literal" },
+			  { "off", "literal" },
+			  { "mmapfile", "keyword" },
+			  { "eq", "literal" },
+			  { "email", "literal" },
+			  { "denied", "literal" },
+			  { "append", "literal" },
+			  { "allow", "literal" },
+			  { "xml2StartParse", "keyword" },
+			  { "all", "literal" },
+			  { "_ROUTING__allow_POST", "keyword" },
+			  { "XBitHack", "keyword" },
+			  { "VirtualScriptAlias", "keyword" },
+			  { "VirtualHost", "keyword" },
+			  { "VHostUser", "keyword" },
+			  { "VHostPrivs", "keyword" },
+			  { "VHostGroup", "keyword" },
+			  { "VHostCGIMode", "keyword" },
+			  { "UserDir", "keyword" },
+			  { "UseCanonicalPhysicalPort", "keyword" },
+			  { "UseCanonicalName", "keyword" },
+			  { "UnsetEnv", "keyword" },
+			  { "UnDefine", "keyword" },
+			  { "TypesConfig", "keyword" },
+			  { "TrustedProxy", "keyword" },
+			  { "ThreadStackSize", "keyword" },
+			  { "ThreadLimit", "keyword" },
+			  { "SuexecUserGroup", "keyword" },
+			  { "VHostSecure", "keyword" },
+			  { "SimpleThreadCount", "keyword" },
+			  { "SimpleProcCount", "keyword" },
+			  { "SetOutputFilter", "keyword" },
+			  { "SetInputFilter", "keyword" },
+			  { "SetHandler", "keyword" },
+			  { "Set", "literal" },
+			  { "SessionExclude", "keyword" },
+			  { "SessionDBDSelectLabel", "keyword" },
+			  { "php_admin_value", "keyword" },
+			  { "SessionDBDDeleteLabel", "keyword" },
+			  { "SessionDBDPerUser", "keyword" },
+			  { "SessionDBDCookieName", "keyword" },
+			  { "SessionCryptoPassphraseFile", "keyword" },
+			  { "SessionCookieRemove", "keyword" },
+			  { "SessionMaxAge", "keyword" },
+			  { "SessionCookieName2", "keyword" },
+			  { "SessionCookieName", "keyword" },
+			  { "Session", "keyword" },
+			  { "ServerTokens", "keyword" },
+			  { "ServerSignature", "keyword" },
+			  { "ServerRoot", "keyword" },
+			  { "ServerAlias", "keyword" },
+			  { "SetEnv", "keyword" },
+			  { "ServerAdmin", "keyword" },
+			  { "SeeRequestTail", "keyword" },
+			  { "SecFilterEngine", "keyword" },
+			  { "SetEnvIfExpr", "keyword" },
+			  { "Scriptsock", "keyword" },
+			  { "ScriptSock", "keyword" },
+			  { "ExtFilterDefine", "keyword" },
+			  { "ISAPIReadAheadBuffer", "keyword" },
+			  { "Options", "keyword" },
+			  { "ExpiresByType", "keyword" },
+			  { "ErrorLogFormat", "keyword" },
+			  { "SessionDBDUpdateLabel", "keyword" },
+			  { "ProxyIOBufferSize", "keyword" },
+			  { "DirectorySlash", "keyword" },
+			  { "AllowCONNECT", "keyword" },
+			  { "CharsetSourceEnc", "keyword" },
+			  { "AddOutputFilterByType", "keyword" },
+			  { "DeflateWindowSize", "keyword" },
+			  { "DeflateMemLevel", "keyword" },
+			  { "DeflateInflateLimitRequestBody", "keyword" },
+			  { "DumpIOLogLevel", "keyword" },
+			  { "DefaultIcon", "keyword" },
+			  { "CacheSocacheMaxSize", "keyword" },
+			  { "AuthFormUsername", "keyword" },
+			  { "CookieStyle", "keyword" },
+			  { "EnableExceptionHook", "keyword" },
+			  { "AuthGroupFile", "keyword" },
+			  { "CookieExpires", "keyword" },
+			  { "SessionEnv", "keyword" },
+			  { "ProxyFtpDirCharset", "keyword" },
+			  { "CookieDomain", "keyword" },
+			  { "AddDefaultCharset", "keyword" },
+			  { "ClientRecheckTime", "keyword" },
+			  { "LDAPSharedCacheFile", "keyword" },
+			  { "MultiviewsMatch", "keyword" },
+			  { "CheckCaseOnly", "keyword" },
+			  { "AuthFormLocation", "keyword" },
+			  { "DeflateCompressionLevel", "keyword" },
+			  { "EnableMMAP", "keyword" },
+			  { "MaxClients", "keyword" },
+			  { "AuthFormDisableNoStore", "keyword" },
+			  { "NWSSLTrustedCerts", "keyword" },
+			  { "ScoreBoardFile", "keyword" },
+			  { "CaseFilter", "keyword" },
+			  { "ProxyHTMLLinks", "keyword" },
+			  { "MaxSpareThreads", "keyword" },
+			  { "CacheSocacheMaxTime", "keyword" },
+			  { "H2MaxWorkerIdleSeconds", "keyword" },
+			  { "MCacheSize", "keyword" },
+			  { "MaxClientConnections", "keyword" },
+			  { "CacheMinFileSize", "keyword" },
+			  { "Location", "keyword" },
+			  { "ContentDigest", "keyword" },
+			  { "CustomLog", "keyword" },
+			  { "CacheLockMaxAge", "keyword" },
+			  { "LuaHookCheckUserID", "keyword" },
+			  { "VHostCGIPrivs", "keyword" },
+			  { "LuaMapHandler", "keyword" },
+			  { "DBDMax", "keyword" },
+			  { "DTracePrivileges", "keyword" },
+			  { "CacheKeyBaseURL", "keyword" },
+			  { "SSILegacyExprParser", "keyword" },
+			  { "CacheIgnoreHeaders", "keyword" },
+			  { "CacheHeader", "keyword" },
+			  { "CacheGcUnused", "keyword" },
+			  { "AuthLDAPAuthoritative", "keyword" },
+			  { "LDAPSharedCacheSize", "keyword" },
+			  { "MaxSpareServers", "keyword" },
+			  { "Protocols", "keyword" },
+			  { "ScriptAliasMatch", "keyword" },
+			  { "CacheEnable", "keyword" },
+			  { "TransferLog", "keyword" },
+			  { "CacheSocacheMinTime", "keyword" },
+			  { "AuthzDefaultAuthoritative", "keyword" },
+			  { "SSLLogLevel", "keyword" },
+			  { "CacheDisable", "keyword" },
+			  { "DAVDepthInfinity", "keyword" },
+			  { "CacheMaxExpire", "keyword" },
+			  { "ProxyHCTPsize", "keyword" },
+			  { "RemoteIPInternalProxy", "keyword" },
+			  { "CacheSocache", "keyword" },
+			  { "CacheDetailHeader", "keyword" },
+			  { "DAVLockDB", "keyword" },
+			  { "DefaultLanguage", "keyword" },
+			  { "QualifyRedirectURL", "keyword" },
+			  { "CacheDirLevels", "keyword" },
+			  { "SessionCryptoDriver", "keyword" },
+			  { "CacheStoreExpired", "keyword" },
+			  { "CacheTimeMargin", "keyword" },
+			  { "LuaQuickHandler", "keyword" },
+			  { "CacheDefaultExpire", "keyword" },
+			  { "ProxyTimeout", "keyword" },
+			  { "RemoteIPInternalProxyList", "keyword" },
+			  { "CGIVar", "keyword" },
+			  { "DBDMin", "keyword" },
+			  { "SessionCryptoPassphrase", "keyword" },
+			  { "DirectoryIndexRedirect", "keyword" },
+			  { "CGIDScriptTimeout", "keyword" },
+			  { "CookieTracking", "keyword" },
+			  { "AuthDBDUserPWQuery", "keyword" },
+			  { "FilterProtocol", "keyword" },
+			  { "CacheGcMemUsage", "keyword" },
+			  { "CacheIgnoreURLSessionIdentifiers", "keyword" },
+			  { "BufferedLogs", "keyword" },
+			  { "BufferSize", "keyword" },
+			  { "RemoveLanguage", "keyword" },
+			  { "BrowserMatchNoCase", "keyword" },
+			  { "AuthDigestGroupFile", "keyword" },
+			  { "Basic", "literal" },
+			  { "CacheIgnoreQueryString", "keyword" },
+			  { "AuthzDBMAuthoritative", "keyword" },
+			  { "SetEnvIf", "keyword" },
+			  { "AuthLDAPBindAuthoritative", "keyword" },
+			  { "ProxyHTMLStripComments", "keyword" },
+			  { "BalancerNonce", "keyword" },
+			  { "AllowOverrideList", "keyword" },
+			  { "IfModule", "keyword" },
+			  { "AuthDefaultAuthoritative", "keyword" },
+			  { "AddIconByEncoding", "keyword" },
+			  { "AllowOverride", "keyword" },
+			  { "AuthDBMGroupFile", "keyword" },
+			  { "Eq", "literal" },
+			  { "DAVGenericLockDB", "keyword" },
+			  { "AsyncRequestWorkerFactor", "keyword" },
+			  { "AuthBasicProvider", "keyword" },
+			  { "AuthDigestAlgorithm", "keyword" },
+			  { "AuthDBDUserRealmQuery", "keyword" },
+			  { "HeartbeatAddress", "keyword" },
+			  { "ProxyReceiveBufferSize", "keyword" },
+			  { "AuthBasicUseDigestAlgorithm", "keyword" },
+			  { "VirtualDocumentRootIP", "keyword" },
+			  { "DirectoryMatch", "keyword" },
+			  { "CacheStoreNoStore", "keyword" },
+			  { "AuthLDAPGroupAttribute", "keyword" },
+			  { "LDAPLibraryDebug", "keyword" },
+			  { "DBDPersist", "keyword" },
+			  { "ScriptAlias", "keyword" },
+			  { "AuthzUserAuthoritative", "keyword" },
+			  { "AuthBasicFake", "keyword" },
+			  { "ForensicLog", "keyword" },
+			  { "ProxySourceAddress", "keyword" },
+			  { "AuthLDAPAuthzEnabled", "keyword" },
+			  { "AuthLDAPCharsetConfig", "keyword" },
+			  { "AuthDBMUserFile", "keyword" },
+			  { "LDAPReferrals", "keyword" },
+			  { "CacheNegotiatedDocs", "keyword" },
+			  { "CaseFilterIn", "keyword" },
+			  { "AssignUserID", "keyword" },
+			  { "Any", "literal" },
+			  { "AuthLDAPBindDN", "keyword" },
+			  { "Anonymous_NoUserID", "keyword" },
+			  { "AuthFormSize", "keyword" },
+			  { "DBDriver", "keyword" },
+			  { "CacheIgnoreCacheControl", "keyword" },
+			  { "H2SessionExtraFiles", "keyword" },
+			  { "ProtocolEcho", "keyword" },
+			  { "EnableSendfile", "keyword" },
+			  { "Anonymous_Authoritative", "keyword" },
+			  { "Email", "literal" },
+			  { "ForceLanguagePriority", "keyword" },
+			  { "CharsetOptions", "keyword" },
+			  { "AuthnCacheSOCache", "keyword" },
+			  { "Substitute", "keyword" },
+			  { "AuthLDAPCompareAsUser", "keyword" },
+			  { "H2Direct", "keyword" },
+			  { "Deny", "keyword" },
+			  { "AuthLDAPCompareDNOnServer", "keyword" },
+			  { "AuthLDAPSubGroupClass", "keyword" },
+			  { "AuthnCacheProvideFor", "keyword" },
+			  { "ChrootDir", "keyword" },
+			  { "_ROUTING__allow_GET", "keyword" },
+			  { "AddAltByType", "keyword" },
+			  { "ProxyHTMLExtended", "keyword" },
+			  { "AuthDBMType", "keyword" },
+			  { "ExtendedStatus", "keyword" },
+			  { "ModMimeUsePathInfo", "keyword" },
+			  { "AuthnCacheProvider", "keyword" },
+			  { "AuthDigestFile", "keyword" },
+			  { "H2AltSvc", "keyword" },
+			  { "IndexStyleSheet", "keyword" },
+			  { "AcceptFilter", "keyword" },
+			  { "ExpiresDefault", "keyword" },
+			  { "CheckSpelling", "keyword" },
+			  { "DBDParams", "keyword" },
+			  { "AddDescription", "keyword" },
+			  { "AcceptPathInfo", "keyword" },
+			  { "ProxyMaxForwards", "keyword" },
+			  { "DumpIOOutput", "keyword" },
+			  { "DeflateBufferSize", "keyword" },
+			  { "AddEncoding", "keyword" },
+			  { "AuthDigestNonceFormat", "keyword" },
+			  { "ProxyPassReverseCookiePath", "keyword" },
+			  { "AddInputFilter", "keyword" },
+			  { "AddIcon", "keyword" },
+			  { "AuthBasicAuthoritative", "keyword" },
+			  { "Define", "keyword" },
+			  { "HeartbeatListen", "keyword" },
+			  { "AddAltByEncoding", "keyword" },
+			  { "AccessFileName", "keyword" },
+			  { "RedirectMatch", "keyword" },
+			  { "DAV", "keyword" },
+			  { "IndexOrderDefault", "keyword" },
+			  { "AuthLDAPRemoteUserAttribute", "keyword" },
+			  { "AddAlt", "keyword" },
+			  { "H2PushDiarySize", "keyword" },
+			  { "LDAPTrustedCA", "keyword" },
+			  { "ProxyPassInherit", "keyword" },
+			  { "LuaHookLog", "keyword" },
+			  { "Anonymous_VerifyEmail", "keyword" },
+			  { "CacheDirLength", "keyword" },
+			  { "AcceptMutex", "keyword" },
+			  { "CacheReadTime", "keyword" },
+			  { "AuthFormProvider", "keyword" },
+			  { "ProxyMatch", "keyword" },
+			  { "Action", "keyword" },
+			  { "ProxyPass", "keyword" },
+			  { "DBDInitSQL", "keyword" },
+			  { "AddCharset", "keyword" },
+			  { "SSITimeFormat", "keyword" },
+			  { "CacheGcClean", "keyword" },
+			  { "AuthzLDAPAuthoritative", "keyword" },
+			  { "AuthnCacheContext", "keyword" },
+			  { "SessionDBDInsertLabel", "keyword" },
+			  { "SSLRequire", "keyword" },
+			  { "CacheGcInterval", "keyword" },
+			  { "Anonymous_LogEmail", "keyword" },
+			  { "Anonymous_MustGiveEmail", "keyword" },
+			  { "CGIPassAuth", "keyword" },
+			  { "CoreDumpDirectory", "keyword" },
+			  { "AddOutputFilter", "keyword" },
+			  { "CacheExpiryCheck", "keyword" },
+			  { "ReflectorHeader", "keyword" },
+			  { "ScriptLogLength", "keyword" },
+			  { "AuthDigestQop", "keyword" },
+			  { "LDAPCacheTTL", "keyword" },
+			  { "AuthDigestDomain", "keyword" },
+			  { "ErrorDocument", "keyword" },
+			  { "BalancerGrowth", "keyword" },
+			  { "AuthzSendForbiddenOnFailure", "keyword" },
+			  { "DeflateFilterNote", "keyword" },
+			  { "CacheStaleOnError", "keyword" },
+			  { "DAVMinTimeout", "keyword" },
+			  { "AddLanguage", "keyword" },
+			  { "AuthDBMAuthoritative", "keyword" },
+			  { "CacheRoot", "keyword" },
+			  { "CacheMinExpire", "keyword" },
+			  { "ProxyFtpEscapeWildcards", "keyword" },
+			  { "AuthAuthoritative", "keyword" },
+			  { "RemoveOutputFilter", "keyword" },
+			  { "AuthFormFakeBasicAuth", "keyword" },
+			  { "FilterChain", "keyword" },
+			  { "IdentityCheckTimeout", "keyword" },
+			  { "TraceEnable", "keyword" },
+			  { "DefaultType", "keyword" },
+			  { "LuaHookTranslateName", "keyword" },
+			  { "ProxyHTMLFixups", "keyword" },
+			  { "AddModuleInfo", "keyword" },
+			  { "AuthzGroupFileAuthoritative", "keyword" },
+			  { "MaxRequestWorkers", "keyword" },
+			  { "LuaHookTypeChecker", "keyword" },
+			  { "Alias", "keyword" },
+			  { "basic", "literal" },
+			  { "CacheIgnoreNoLastMod", "keyword" },
+			  { "DocumentRoot", "keyword" },
+			  { "Header", "keyword" },
+			  { "valid-user", "literal" },
+			  { "All", "literal" },
+			  { "MaxRangeOverlaps", "keyword" },
+			  { "AddIconByType", "keyword" },
+			  { "Allow", "keyword" },
+			  { "SetEnvIfNoCase", "keyword" },
+			  { "DeflateInflateRatioBurst", "keyword" },
+			  { "AuthFormLoginRequiredLocation", "keyword" },
+			  { "AllowEncodedSlashes", "keyword" },
+			  { "CacheGcDaily", "keyword" },
+			  { "AuthDigestNonceLifetime", "keyword" },
+			  { "AuthzDBMType", "keyword" },
+			  { "CacheQuickHandler", "keyword" },
+			  { "PidFile", "keyword" },
+			  { "CGIMapExtension", "keyword" },
+			  { "AuthLDAPInitialBindAsUser", "keyword" },
+			  { "AuthFormAuthoritative", "keyword" },
+			  { "SerfPass", "keyword" },
+			  { "RewriteRule", "keyword" },
+			  { "User", "keyword" },
+			  { "AuthDigestProvider", "keyword" },
+			  { "AuthFormBody", "keyword" },
+			  { "AuthFormLoginSuccessLocation", "keyword" },
+			  { "ServerLimit", "keyword" },
+			  { "AuthLDAPAuthorizePrefix", "keyword" },
+			  { "KeepAliveTimeout", "keyword" },
+			  { "AuthzDBDQuery", "keyword" },
+			  { "NWSSLUpgradeable", "keyword" },
+			  { "AuthDigestNcCheck", "keyword" },
+			  { "BalancerMember", "keyword" },
+			  { "Valid-User", "literal" },
+			  { "AuthzDBDLoginToReferer", "keyword" },
+			  { "LimitInternalRecursion", "keyword" },
+			  { "AuthLDAPFrontPageHack", "keyword" },
+			  { "AuthFormMimetype", "keyword" },
+			  { "BrowserMatch", "keyword" },
+			  { "BalancerPersist", "keyword" },
+			  { "AuthFormPassword", "keyword" },
+			  { "BS2000Account", "keyword" },
+			  { "LDAPOpCacheTTL", "keyword" },
+			  { "Win32DisableAcceptEx", "keyword" },
+			  { "SubstituteInheritBefore", "keyword" },
+			  { "DirectoryCheckHandler", "keyword" },
+			  { "SSIErrorMsg", "keyword" },
+			  { "CacheSocacheReadSize", "keyword" },
+			  { "GlobalLog", "keyword" },
+			  { "ProxyExpressDBMFile", "keyword" },
+			  { "AuthLDAPDereferenceAliases", "keyword" },
+			  { "DBDKeep", "keyword" },
+			  { "ThreadsPerChild", "keyword" },
+			  { "Redirect", "keyword" },
+			  { "Unset", "literal" },
+			  { "Suexec", "keyword" },
+			  { "AuthLDAPEnabled", "keyword" },
+			  { "ProxyPassMatch", "keyword" },
+			  { "AuthUserFile", "keyword" },
+			  { "AliasMatch", "keyword" },
+			  { "MimeMagicFile", "keyword" },
+			  { "RewriteLogLevel", "keyword" },
+			  { "_ROUTING__allow_HEAD", "keyword" },
+			  { "CookieName", "keyword" },
+			  { "ProxyVia", "keyword" },
+			  { "AuthLDAPGroupAttributeIsDN", "keyword" },
+			  { "LuaScope", "keyword" },
+			  { "AddType", "keyword" },
+			  { "FancyIndexing", "keyword" },
+			  { "CookieLog", "keyword" },
+			  { "AuthLDAPInitialBindPattern", "keyword" },
+			  { "ErrorLog", "keyword" },
+			  { "AuthnCacheTimeout", "keyword" },
+			  { "LDAPConnectionPoolTTL", "keyword" },
+			  { "LocationMatch", "keyword" },
+			  { "CacheLockPath", "keyword" },
+			  { "ProxyHTMLDoctype", "keyword" },
+			  { "AuthnCacheEnable", "keyword" },
+			  { "Append", "literal" },
+			  { "AuthLDAPRemoteUserIsDN", "keyword" },
+			  { "Anonymous", "keyword" },
+			  { "AuthLDAPSearchAsUser", "keyword" },
+			  { "H2WindowSize", "keyword" },
+			  { "StartThreads", "keyword" },
+			  { "CacheMaxFileSize", "keyword" },
+			  { "AuthFormMethod", "keyword" },
+			  { "LimitExcept", "keyword" },
+			  { "LimitRequestFieldSize", "keyword" },
+			  { "MetaDir", "keyword" },
+			  { "ProxyHTMLBufSize", "keyword" },
+			  { "AuthLDAPSubGroupAttribute", "keyword" },
+			  { "LogIOTrackTTFB", "keyword" },
+			  { "AuthLDAPURL", "keyword" },
+			  { "LDAPTrustedGlobalCert", "keyword" },
+			  { "ChildperUserID", "keyword" },
+			  { "StartServers", "keyword" },
+			  { "AuthzOwnerAuthoritative", "keyword" },
+			  { "DirectoryIndex", "keyword" },
+			  { "SecureListen", "keyword" },
+			  { "FallbackResource", "keyword" },
+			  { "FileETag", "keyword" },
+			  { "ExtFilterOptions", "keyword" },
+			  { "H2MaxSessionStreams", "keyword" },
+			  { "MCacheMaxStreamingBuffer", "keyword" },
+			  { "Files", "keyword" },
+			  { "FilesMatch", "keyword" },
+			  { "FilterDeclare", "keyword" },
+			  { "FilterProvider", "keyword" },
+			  { "ProxyPassInterpolateEnv", "keyword" },
+			  { "FilterTrace", "keyword" },
+			  { "MinSpareServers", "keyword" },
+			  { "GprofDir", "keyword" },
+			  { "Group", "keyword" },
+			  { "H2AltSvcMaxAge", "keyword" },
+			  { "RemoteIPTrustedProxyList", "keyword" },
+			  { "VirtualScriptAliasIP", "keyword" },
+			  { "ScoreboardFile", "keyword" },
+			  { "AuthzDBDRedirectQuery", "keyword" },
+			  { "H2MaxWorkers", "keyword" },
+			  { "H2MinWorkers", "keyword" },
+			  { "LogMessage", "keyword" },
+			  { "ProxyHCTemplate", "keyword" },
+			  { "xml2EncAlias", "keyword" },
+			  { "CacheLastModifiedFactor", "keyword" },
+			  { "H2Push", "keyword" },
+			  { "H2PushPriority", "keyword" },
+			  { "SubstituteMaxLineLength", "keyword" },
+			  { "ProxyExpressEnable", "keyword" },
+			  { "H2SerializeHeaders", "keyword" },
+			  { "ServerPath", "keyword" },
+			  { "ProxyHTMLInterp", "keyword" },
+			  { "SSLLog", "keyword" },
+			  { "H2TLSCoolDownSecs", "keyword" },
+			  { "IndexHeadInsert", "keyword" },
+			  { "H2Upgrade", "keyword" },
+			  { "HeaderName", "keyword" },
+			  { "Script", "keyword" },
+			  { "ForceType", "keyword" },
+			  { "HeartbeatStorage", "keyword" },
+			  { "SSIAccessEnable", "keyword" },
+			  { "HostnameLookups", "keyword" },
+			  { "H2ModernTLSOnly", "keyword" },
+			  { "ProxyPassReverse", "keyword" },
+			  { "AuthFormLogoutLocation", "keyword" },
+			  { "ISAPIAppendLogToErrors", "keyword" },
+			  { "ISAPIAppendLogToQuery", "keyword" },
+			  { "ISAPICacheFile", "keyword" },
+			  { "set", "literal" },
+			  { "ISAPIFakeAsync", "keyword" },
+			  { "ISAPILogNotSupported", "keyword" },
+			  { "IdentityCheck", "keyword" },
+			  { "MaxRanges", "keyword" },
+			  { "H2StreamMaxMemSize", "keyword" },
+			  { "ImapBase", "keyword" },
+			  { "LDAPTrustedCAType", "keyword" },
+			  { "ImapDefault", "keyword" },
+			  { "Include", "keyword" },
+			  { "IncludeOptional", "keyword" },
+			  { "IfDefine", "keyword" },
+			  { "IndexIgnore", "keyword" },
+			  { "MaxRangeReversals", "keyword" },
+			  { "cachefile", "keyword" },
+			  { "IndexIgnoreReset", "keyword" },
+			  { "IndexOptions", "keyword" },
+			  { "On", "literal" },
+			  { "KeepAlive", "keyword" },
+			  { "KeptBodySize", "keyword" },
+			  { "LDAPCacheEntries", "keyword" },
+			  { "MaxThreadsPerChild", "keyword" },
+			  { "AuthLDAPMaxSubGroupDepth", "keyword" },
+			  { "LDAPConnectionTimeout", "keyword" },
+			  { "LDAPOpCacheEntries", "keyword" },
+			  { "ProxySCGISendfile", "keyword" },
+			  { "LDAPReferralHopLimit", "keyword" },
+			  { "LDAPRetries", "keyword" },
+			  { "RLimitMEM", "keyword" },
+			  { "LDAPRetryDelay", "keyword" },
+			  { "AuthType", "keyword" },
+			  { "LDAPTimeout", "keyword" },
+			  { "LDAPTrustedMode", "keyword" },
+			  { "LDAPVerifyServerCert", "keyword" },
+			  { "LuaInputFilter", "keyword" },
+			  { "VirtualDocumentRoot", "keyword" },
+			  { "LanguagePriority", "keyword" },
+			  { "CacheStorePrivate", "keyword" },
+			  { "DBDPrepareSQL", "keyword" },
+			  { "MaxKeepAliveRequests", "keyword" },
+			  { "AddHandler", "keyword" },
+			  { "LimitRequestBody", "keyword" },
+			  { "LimitRequestFields", "keyword" },
+			  { "ServerName", "keyword" },
+			  { "LimitRequestFieldsize", "keyword" },
+			  { "ProxyPreserveHost", "keyword" },
+			  { "LimitRequestLine", "keyword" },
+			  { "LimitXMLRequestBody", "keyword" },
+			  { "DefaultRuntimeDir", "keyword" },
+			  { "LoadFile", "keyword" },
+			  { "LoadModule", "keyword" },
+			  { "LogFormat", "keyword" },
+			  { "LuaAuthzProvider", "keyword" },
+			  { "Denied", "literal" },
+			  { "LuaCodeCache", "keyword" },
+			  { "LuaHookAccessChecker", "keyword" },
+			  { "ProxySCGIInternalRedirect", "keyword" },
+			  { "MaxThreads", "keyword" },
+			  { "LuaHookAuthChecker", "keyword" },
+			  { "RewriteBase", "keyword" },
+			  { "LuaHookFixups", "keyword" },
+			  { "ExpiresActive", "keyword" },
+			  { "Anonymous_NoUserId", "keyword" },
+			  { "LuaHookInsertFilter", "keyword" },
+			  { "SSLRequireSSL", "keyword" },
+			  { "AuthnzFcgiDefineProvider", "keyword" },
+			  { "LuaHookMapToStorage", "keyword" },
+			  { "LuaInherit", "keyword" },
+			  { "CacheReadSize", "keyword" },
+			  { "LuaOutputFilter", "keyword" },
+			  { "Protocol", "keyword" },
+			  { "MCacheRemovalAlgorithm", "keyword" },
+			  { "ProxyBadHeader", "keyword" },
+			  { "RedirectPermanent", "keyword" },
+			  { "LuaPackageCPath", "keyword" },
+			  { "LuaRoot", "keyword" },
+			  { "H2TLSWarmUpSize", "keyword" },
+			  { "MCacheMaxObjectCount", "keyword" },
+			  { "MCacheMaxObjectSize", "keyword" },
+			  { "MaxConnectionsPerChild", "keyword" },
+			  { "MCacheMinObjectSize", "keyword" },
+			  { "MaxMemFree", "keyword" },
+			  { "MaxRequestsPerThread", "keyword" },
+			  { "MemcacheConnTTL", "keyword" },
+			  { "MergeTrailers", "keyword" },
+			  { "MetaFiles", "keyword" },
+			  { "MetaSuffix", "keyword" },
+			  { "MinSpareThreads", "keyword" },
+			  { "ProxyRequests", "keyword" },
+			  { "CharsetDefault", "keyword" },
+			  { "AuthLDAPBindPassword", "keyword" },
+			  { "ModemStandard", "keyword" },
+			  { "Mutex", "keyword" },
+			  { "NameVirtualHost", "keyword" },
+			  { "LDAPTrustedClientCert", "keyword" },
+			  { "NumServers", "keyword" },
+			  { "Off", "literal" },
+			  { "AuthDigestShmemSize", "keyword" },
+			  { "AuthMerging", "keyword" },
+			  { "Order", "keyword" },
+			  { "RLimitNPROC", "keyword" },
+			  { "LuaPackagePath", "keyword" },
+			  { "OutputSed", "keyword" },
+			  { "Port", "keyword" },
+			  { "NoProxy", "keyword" },
+			  { "DeflateInflateRatioLimit", "keyword" },
+			  { "PrivilegesMode", "keyword" },
+			  { "from", "keyword" },
+			  { "ProtocolsHonorOrder", "keyword" },
+			  { "deny", "literal" },
+			  { "ProxyAddHeaders", "keyword" },
+			  { "ProxyHTMLEvents", "keyword" },
+			  { "ProxyBlock", "keyword" },
+			  { "ProxyHTMLMeta", "keyword" },
+			  { "ProxyDomain", "keyword" },
+			  { "ProxyErrorOverride", "keyword" },
+			  { "DumpIOInput", "keyword" },
+			  { "ProxyExpressDBMType", "keyword" },
+			  { "MaxRequestsPerChild", "keyword" },
+			  { "ProxyFtpListOnWildcard", "keyword" },
+			  { "BalancerInherit", "keyword" },
+			  { "ProxyHCExpr", "keyword" },
+			  { "ProxyHTMLCharsetOut", "keyword" },
+			  { "SessionDBDCookieRemove", "keyword" },
+			  { "ProxyHTMLEnable", "keyword" },
+			  { "ProxyHTMLURLMap", "keyword" },
+			  { "ProxyPassReverseCookieDomain", "keyword" },
+			  { "ProxyRemote", "keyword" },
+			  { "CacheLock", "keyword" },
+			  { "ProxyRemoteMatch", "keyword" },
+			  { "ImapMenu", "keyword" },
+			  { "ProxySet", "keyword" },
+			  { "ProxyStatus", "keyword" },
+			  { "SerfCluster", "keyword" },
+			  { "IfVersion", "keyword" },
+			  { "Lua_____ByteCodeHack", "keyword" },
+			  { "RLimitCPU", "keyword" },
+			  { "SessionHeader", "keyword" },
+			  { "RedirectTemp", "keyword" },
+			  { "ReadmeName", "keyword" },
+			  { "SSIStartTag", "keyword" },
+			  { "LogLevel", "keyword" },
+			  { "RemoteIPHeader", "keyword" },
+			  { "AuthnzFcgiCheckAuthnProvider", "keyword" },
+			  { "PassEnv", "keyword" },
+			  { "RequestHeader", "keyword" },
+			  { "SSLOptions", "keyword" },
+			  { "RemoteIPTrustedProxy", "keyword" },
+			  { "RemoveCharset", "keyword" },
+			  { "RemoveEncoding", "keyword" },
+			  { "RemoveHandler", "keyword" },
+			  { "RemoveInputFilter", "keyword" },
+			  { "SessionInclude", "keyword" },
+			  { "RemoveType", "keyword" },
+			  { "RequestReadTimeout", "keyword" },
+			  { "RequestTimeout", "keyword" },
+			  { "AllowMethods", "keyword" },
+			  { "Require", "keyword" },
+			  { "AuthFormSitePassphrase", "keyword" },
+			  { "RewriteCond", "keyword" },
+			  { "DBDExptime", "keyword" },
+			  { "CacheForceCompletion", "keyword" },
+			  { "RewriteEngine", "keyword" },
+			  { "any", "literal" },
+			  { "HeartbeatMaxServers", "keyword" },
+			  { "Satisfy", "keyword" },
+			  { "RewriteLock", "keyword" },
+			  { "SessionCryptoCipher", "keyword" },
+			  { "RewriteLog", "keyword" },
+			  { "RewriteMap", "keyword" },
+			  { "CacheSocacheReadTime", "keyword" },
+			  { "RemoteIPProxiesHeader", "keyword" },
+			  { "LockFile", "keyword" },
+			  { "RewriteOptions", "keyword" },
+			  { "SessionDBDCookieName2", "keyword" },
+			  { "SSIEndTag", "keyword" },
+			  { "InputSed", "keyword" },
+			  { "SSIEtag", "keyword" },
+			  { "SSILastModified", "keyword" },
+			  { "SSIUndefinedEcho", "keyword" },
+			  { "AuthName", "keyword" },
+			  { "ScriptInterpreterSource", "keyword" },
+			  { "ScriptLog", "keyword" },
+			  { "ScriptLogBuffer", "keyword" },
+
+		  },
+		  "#",
+		  {} } );
+}
+
+}}}} // namespace EE::UI::Doc::Language
--- a/src/eepp/ui/doc/languages/htaccess.hpp
+++ b/src/eepp/ui/doc/languages/htaccess.hpp
@@ -0,0 +1,10 @@
+#ifndef EE_UI_DOC_htaccess
+#define EE_UI_DOC_htaccess
+
+namespace EE { namespace UI { namespace Doc { namespace Language {
+
+extern void addHtaccessFile();
+
+}}}}
+
+#endif
--- a/src/eepp/ui/doc/languages/pico-8.cpp
+++ b/src/eepp/ui/doc/languages/pico-8.cpp
@@ -0,0 +1,50 @@
+#include <eepp/ui/doc/languages/x86assembly.hpp>
+#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
+
+namespace EE { namespace UI { namespace Doc { namespace Language {
+
+void addPICO8() {
+
+	SyntaxDefinitionManager::instance()->add(
+
+		{ "PICO-8",
+		  { "%.p8$" },
+		  {
+			  { { "pico%-8 cartridge", "__lua__" }, "comment" },
+			  { { "__gfx__\n", "%z" }, "comment" },
+			  { { "\"", "\"", "\\" }, "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" },
+			  { { "%s+" }, "normal" },
+			  { { "%w+%f[%s]" }, "normal" },
+
+		  },
+		  {
+			  { "true", "literal" },   { "self", "keyword2" }, { "return", "keyword" },
+			  { "repeat", "keyword" }, { "or", "keyword" },	   { "and", "keyword" },
+			  { "break", "keyword" },  { "else", "keyword" },  { "until", "keyword" },
+			  { "do", "keyword" },	   { "in", "keyword" },	   { "while", "keyword" },
+			  { "end", "keyword" },	   { "nil", "literal" },   { "elseif", "keyword" },
+			  { "false", "literal" },  { "not", "keyword" },   { "local", "keyword" },
+			  { "for", "keyword" },	   { "then", "keyword" },  { "function", "keyword" },
+			  { "goto", "keyword" },   { "if", "keyword" },
+
+		  },
+		  "--",
+		  {}
+
+		} );
+}
+
+}}}} // namespace EE::UI::Doc::Language
--- a/src/eepp/ui/doc/languages/pico-8.hpp
+++ b/src/eepp/ui/doc/languages/pico-8.hpp
@@ -0,0 +1,10 @@
+#ifndef EE_UI_DOC_PICO8
+#define EE_UI_DOC_PICO8
+
+namespace EE { namespace UI { namespace Doc { namespace Language {
+
+extern void addPICO8();
+
+}}}}
+
+#endif
--- a/src/eepp/ui/doc/languages/postgresql.cpp
+++ b/src/eepp/ui/doc/languages/postgresql.cpp
@@ -0,0 +1,410 @@
+#include <eepp/ui/doc/languages/x86assembly.hpp>
+#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
+
+namespace EE { namespace UI { namespace Doc { namespace Language {
+
+void addPostgreSQL() {
+
+	SyntaxDefinitionManager::instance()->add(
+
+		{ "PostgreSQL",
+		  { "%.sql$", "%.psql$" },
+		  {
+			  { { "%-%-.-\n" }, "comment" },
+			  { { "/%*", "%*/" }, "comment" },
+			  { { "'", "'", "\\" }, "string" },
+			  { { "-?%d+[%d%.eE]*f?" }, "number" },
+			  { { "-?%.?%d+f?" }, "number" },
+			  { { "[%+%-=/%*%%<>!~|&@%?$#]" }, "operator" },
+			  { { "[%a_][%w_]*%f[(]" }, "function" },
+			  { { "[%a_][%w_]*" }, "symbol" },
+			  { { "%s+" }, "normal" },
+			  { { "%w+%f[%s]" }, "normal" },
+
+		  },
+		  {
+			  { "zone", "keyword" },
+			  { "xmlparse", "keyword" },
+			  { "without", "keyword" },
+			  { "with", "keyword" },
+			  { "where", "keyword" },
+			  { "view", "keyword" },
+			  { "variadic", "keyword" },
+			  { "values", "keyword" },
+			  { "using", "keyword" },
+			  { "update", "keyword" },
+			  { "unnest", "keyword" },
+			  { "unknown", "keyword" },
+			  { "unique", "keyword" },
+			  { "union", "keyword" },
+			  { "unbounded", "keyword" },
+			  { "type", "keyword" },
+			  { "tsvector", "keyword2" },
+			  { "trigger", "keyword" },
+			  { "timezone", "keyword" },
+			  { "timez", "keyword2" },
+			  { "timestampz", "keyword2" },
+			  { "time", "keyword2" },
+			  { "sql", "keyword" },
+			  { "some", "keyword" },
+			  { "smallint", "keyword2" },
+			  { "true", "literal" },
+			  { "setof", "keyword" },
+			  { "serial4", "keyword2" },
+			  { "sequence", "keyword" },
+			  { "select", "keyword" },
+			  { "row", "keyword" },
+			  { "returns", "keyword" },
+			  { "returning", "keyword" },
+			  { "procedure", "keyword" },
+			  { "preceding", "keyword" },
+			  { "polygon", "keyword2" },
+			  { "point", "keyword2" },
+			  { "pg_lsn", "keyword2" },
+			  { "owned", "keyword" },
+			  { "outer", "keyword" },
+			  { "order", "keyword" },
+			  { "or", "keyword" },
+			  { "operator", "keyword" },
+			  { "only", "keyword" },
+			  { "offset", "keyword" },
+			  { "numrange", "keyword2" },
+			  { "numeric", "keyword2" },
+			  { "null", "keyword" },
+			  { "notnull", "keyword" },
+			  { "notice", "keyword" },
+			  { "not", "keyword" },
+			  { "natural", "keyword" },
+			  { "money", "keyword2" },
+			  { "lseg", "keyword2" },
+			  { "loop", "keyword" },
+			  { "localtime", "literal" },
+			  { "nulls", "keyword" },
+			  { "like", "keyword" },
+			  { "lateral", "keyword" },
+			  { "key", "keyword" },
+			  { "jsonb", "keyword2" },
+			  { "join", "keyword" },
+			  { "smallserial", "keyword2" },
+			  { "into", "keyword" },
+			  { "interval", "keyword2" },
+			  { "intersect", "keyword" },
+			  { "int8range", "keyword2" },
+			  { "int8", "keyword2" },
+			  { "int4", "keyword2" },
+			  { "int2", "keyword2" },
+			  { "table", "keyword" },
+			  { "insert", "keyword" },
+			  { "inner", "keyword" },
+			  { "index", "keyword" },
+			  { "INT4", "keyword2" },
+			  { "EXCEPT", "keyword" },
+			  { "txid_snapshot", "keyword2" },
+			  { "set", "keyword" },
+			  { "PRECISION", "keyword2" },
+			  { "EXISTS", "keyword" },
+			  { "TSRANGE", "keyword2" },
+			  { "ORDINALITY", "keyword" },
+			  { "NUMERIC", "keyword2" },
+			  { "LATERAL", "keyword" },
+			  { "FUNCTION", "keyword" },
+			  { "NULL", "keyword" },
+			  { "NOT", "keyword" },
+			  { "NUMRANGE", "keyword2" },
+			  { "WHERE", "keyword" },
+			  { "NOTNULL", "keyword" },
+			  { "case", "keyword" },
+			  { "MACADDR", "keyword2" },
+			  { "INTEGER", "keyword2" },
+			  { "NATURAL", "keyword" },
+			  { "LSEG", "keyword2" },
+			  { "LOOP", "keyword" },
+			  { "xmlserialize", "keyword" },
+			  { "JSON", "keyword2" },
+			  { "LOCALTIME", "literal" },
+			  { "LIKE", "keyword" },
+			  { "GROUP", "keyword" },
+			  { "json", "keyword2" },
+			  { "LAST", "keyword" },
+			  { "BIGSERIAL", "keyword2" },
+			  { "OR", "keyword" },
+			  { "SETOF", "keyword" },
+			  { "JSONB", "keyword2" },
+			  { "PATH", "keyword2" },
+			  { "ISNULL", "keyword" },
+			  { "option", "keyword" },
+			  { "TO", "keyword" },
+			  { "EXCLUDE", "keyword" },
+			  { "INT8", "keyword2" },
+			  { "CIRCLE", "keyword2" },
+			  { "INT2", "keyword2" },
+			  { "partition", "keyword" },
+			  { "INSTEAD", "keyword" },
+			  { "INET", "keyword2" },
+			  { "IN", "keyword" },
+			  { "ordinality", "keyword" },
+			  { "TIMEZONE", "keyword" },
+			  { "INNER", "keyword" },
+			  { "bigserial", "keyword2" },
+			  { "FOREIGN", "keyword" },
+			  { "UNKNOWN", "keyword" },
+			  { "CHAR", "keyword2" },
+			  { "BOOL", "keyword2" },
+			  { "EXECUTE", "keyword" },
+			  { "AT", "keyword" },
+			  { "CURRENT_DATE", "literal" },
+			  { "LEFT", "keyword" },
+			  { "COLLATION", "keyword" },
+			  { "FALSE", "literal" },
+			  { "ROW", "keyword" },
+			  { "CASE", "keyword" },
+			  { "INTERVAL", "keyword2" },
+			  { "boolean", "keyword2" },
+			  { "each", "keyword" },
+			  { "CHECK", "keyword" },
+			  { "EXTENSION", "keyword" },
+			  { "RIGHT", "keyword" },
+			  { "CHARACTER", "keyword2" },
+			  { "FOLLOWING", "keyword" },
+			  { "INTERSECT", "keyword" },
+			  { "DOCUMENT", "keyword" },
+			  { "ASC", "keyword" },
+			  { "varchar", "keyword2" },
+			  { "END", "keyword" },
+			  { "NULLS", "keyword" },
+			  { "when", "keyword" },
+			  { "CIDR", "keyword2" },
+			  { "POINT", "keyword2" },
+			  { "BIT", "keyword2" },
+			  { "ORDER", "keyword" },
+			  { "LANGUAGE", "keyword" },
+			  { "FLOAT8", "keyword2" },
+			  { "timestamp", "keyword2" },
+			  { "inet", "keyword2" },
+			  { "FLOAT4", "keyword2" },
+			  { "line", "keyword2" },
+			  { "PARTITION", "keyword" },
+			  { "AND", "keyword" },
+			  { "domain", "keyword" },
+			  { "FOR", "keyword" },
+			  { "BEFORE", "keyword" },
+			  { "SERIAL4", "keyword2" },
+			  { "varbit", "keyword2" },
+			  { "SELECT", "keyword" },
+			  { "NOTICE", "keyword" },
+			  { "BEGIN", "keyword" },
+			  { "PG_LSN", "keyword2" },
+			  { "end", "keyword" },
+			  { "INSERT", "keyword" },
+			  { "int", "keyword2" },
+			  { "RETURNING", "keyword" },
+			  { "SERIAL", "keyword2" },
+			  { "TIMEZ", "keyword2" },
+			  { "KEY", "keyword" },
+			  { "DOUBLE", "keyword2" },
+			  { "references", "keyword" },
+			  { "BOX", "keyword2" },
+			  { "MONEY", "keyword2" },
+			  { "ZONE", "keyword" },
+			  { "THEN", "keyword" },
+			  { "ARRAY", "keyword" },
+			  { "ANY", "keyword" },
+			  { "JOIN", "keyword" },
+			  { "precision", "keyword2" },
+			  { "ALTER", "keyword" },
+			  { "CROSS", "keyword" },
+			  { "OPTION", "keyword" },
+			  { "uuid", "keyword2" },
+			  { "then", "keyword" },
+			  { "SET", "keyword" },
+			  { "AS", "keyword" },
+			  { "to", "keyword" },
+			  { "TEXT", "keyword2" },
+			  { "serial2", "keyword2" },
+			  { "TSTZRANGE", "keyword2" },
+			  { "ONLY", "keyword" },
+			  { "limit", "keyword" },
+			  { "TIMESTAMP", "keyword2" },
+			  { "RECURSIVE", "keyword" },
+			  { "bit", "keyword2" },
+			  { "LINE", "keyword2" },
+			  { "FIRST", "keyword" },
+			  { "OUTER", "keyword" },
+			  { "CREATE", "keyword" },
+			  { "DATE", "keyword2" },
+			  { "TRIGGER", "keyword" },
+			  { "asc", "keyword" },
+			  { "serial", "keyword2" },
+			  { "BYTEA", "keyword2" },
+			  { "localtimestamp", "literal" },
+			  { "character", "keyword2" },
+			  { "EVENT", "keyword" },
+			  { "INDEX", "keyword" },
+			  { "DATERANGE", "keyword2" },
+			  { "recursive", "keyword" },
+			  { "on", "keyword" },
+			  { "VARBIT", "keyword2" },
+			  { "CONTENT", "keyword" },
+			  { "rows", "keyword" },
+			  { "WITH", "keyword" },
+			  { "INTO", "keyword" },
+			  { "DECLARE", "keyword" },
+			  { "ROWS", "keyword" },
+			  { "real", "keyword2" },
+			  { "int4range", "keyword2" },
+			  { "TRUE", "literal" },
+			  { "ALL", "keyword" },
+			  { "extension", "keyword" },
+			  { "DEFAULT", "keyword" },
+			  { "DELETE", "keyword" },
+			  { "declare", "keyword" },
+			  { "XMLSERIALIZE", "keyword" },
+			  { "left", "keyword" },
+			  { "PRECEDING", "keyword" },
+			  { "BIGINT", "keyword2" },
+			  { "CURRENT_TIME", "literal" },
+			  { "exists", "keyword" },
+			  { "BETWEEN", "keyword" },
+			  { "DESC", "keyword" },
+			  { "TIME", "keyword2" },
+			  { "FULL", "keyword" },
+			  { "INT4RANGE", "keyword2" },
+			  { "DOMAIN", "keyword" },
+			  { "SMALLINT", "keyword2" },
+			  { "TABLE", "keyword" },
+			  { "OPERATOR", "keyword" },
+			  { "ELSE", "keyword" },
+			  { "foreign", "keyword" },
+			  { "ENUM", "keyword" },
+			  { "also", "keyword" },
+			  { "BY", "keyword" },
+			  { "PRIMARY", "keyword" },
+			  { "UNBOUNDED", "keyword" },
+			  { "PROCEDURE", "keyword" },
+			  { "document", "keyword" },
+			  { "DROP", "keyword" },
+			  { "following", "keyword" },
+			  { "RAISE", "keyword" },
+			  { "REAL", "keyword2" },
+			  { "REFERENCES", "keyword" },
+			  { "RETURNS", "keyword" },
+			  { "xml", "keyword2" },
+			  { "last", "keyword" },
+			  { "SEQUENCE", "keyword" },
+			  { "OWNED", "keyword" },
+			  { "UNIQUE", "keyword" },
+			  { "text", "keyword2" },
+			  { "LIMIT", "keyword" },
+			  { "constraint", "keyword" },
+			  { "CONSTRAINT", "keyword" },
+			  { "double", "keyword2" },
+			  { "SERIAL2", "keyword2" },
+			  { "INT8RANGE", "keyword2" },
+			  { "SERIAL8", "keyword2" },
+			  { "SMALLSERIAL", "keyword2" },
+			  { "SQL", "keyword" },
+			  { "TIMESTAMPZ", "keyword2" },
+			  { "for", "keyword" },
+			  { "TSQUERY", "keyword2" },
+			  { "TSVECTOR", "keyword2" },
+			  { "TXID_SNAPSHOT", "keyword2" },
+			  { "instead", "keyword" },
+			  { "TYPE", "keyword" },
+			  { "language", "keyword" },
+			  { "distinct", "keyword" },
+			  { "circle", "keyword2" },
+			  { "collation", "keyword" },
+			  { "UNION", "keyword" },
+			  { "UNNEST", "keyword" },
+			  { "tsrange", "keyword2" },
+			  { "else", "keyword" },
+			  { "UPDATE", "keyword" },
+			  { "USING", "keyword" },
+			  { "LOCALTIMESTAMP", "literal" },
+			  { "VALUES", "keyword" },
+			  { "SOME", "keyword" },
+			  { "VARCHAR", "keyword2" },
+			  { "serial8", "keyword2" },
+			  { "VARIADIC", "keyword" },
+			  { "VIEW", "keyword" },
+			  { "DISTINCT", "keyword" },
+			  { "ALSO", "keyword" },
+			  { "WHEN", "keyword" },
+			  { "WITHOUT", "keyword" },
+			  { "primary", "keyword" },
+			  { "XML", "keyword2" },
+			  { "daterange", "keyword2" },
+			  { "all", "keyword" },
+			  { "DECIMAL", "keyword2" },
+			  { "any", "keyword" },
+			  { "integer", "keyword2" },
+			  { "array", "keyword" },
+			  { "OFFSET", "keyword" },
+			  { "as", "keyword" },
+			  { "first", "keyword" },
+			  { "UUID", "keyword2" },
+			  { "at", "keyword" },
+			  { "EACH", "keyword" },
+			  { "enum", "keyword" },
+			  { "before", "keyword" },
+			  { "begin", "keyword" },
+			  { "decimal", "keyword2" },
+			  { "between", "keyword" },
+			  { "bigint", "keyword2" },
+			  { "INT", "keyword2" },
+			  { "bool", "keyword2" },
+			  { "by", "keyword" },
+			  { "BOOLEAN", "keyword2" },
+			  { "bytea", "keyword2" },
+			  { "char", "keyword2" },
+			  { "float8", "keyword2" },
+			  { "check", "keyword" },
+			  { "cidr", "keyword2" },
+			  { "ON", "keyword" },
+			  { "content", "keyword" },
+			  { "right", "keyword" },
+			  { "and", "keyword" },
+			  { "FROM", "keyword" },
+			  { "create", "keyword" },
+			  { "box", "keyword2" },
+			  { "cross", "keyword" },
+			  { "tstzrange", "keyword2" },
+			  { "current_date", "literal" },
+			  { "tsquery", "keyword2" },
+			  { "current_time", "literal" },
+			  { "current_timestamp", "literal" },
+			  { "isnull", "keyword" },
+			  { "date", "keyword2" },
+			  { "default", "keyword" },
+			  { "function", "keyword" },
+			  { "delete", "keyword" },
+			  { "float4", "keyword2" },
+			  { "desc", "keyword" },
+			  { "drop", "keyword" },
+			  { "full", "keyword" },
+			  { "path", "keyword2" },
+			  { "CURRENT_TIMESTAMP", "literal" },
+			  { "event", "keyword" },
+			  { "except", "keyword" },
+			  { "exclude", "keyword" },
+			  { "raise", "keyword" },
+			  { "macaddr", "keyword2" },
+			  { "alter", "keyword" },
+			  { "execute", "keyword" },
+			  { "false", "literal" },
+			  { "HAVING", "keyword" },
+			  { "from", "keyword" },
+			  { "POLYGON", "keyword2" },
+			  { "group", "keyword" },
+			  { "having", "keyword" },
+			  { "XMLPARSE", "keyword" },
+			  { "in", "keyword" },
+
+		  },
+		  "--",
+		  {}
+
+		} );
+}
+
+}}}} // namespace EE::UI::Doc::Language
--- a/src/eepp/ui/doc/languages/postgresql.hpp
+++ b/src/eepp/ui/doc/languages/postgresql.hpp
@@ -0,0 +1,10 @@
+#ifndef EE_UI_DOC_PostgreSQL
+#define EE_UI_DOC_PostgreSQL
+
+namespace EE { namespace UI { namespace Doc { namespace Language {
+
+extern void addPostgreSQL();
+
+}}}}
+
+#endif
--- a/src/eepp/ui/doc/languages/x86assembly.cpp
+++ b/src/eepp/ui/doc/languages/x86assembly.cpp
--- a/src/eepp/ui/doc/languages/x86assembly.hpp
+++ b/src/eepp/ui/doc/languages/x86assembly.hpp
@@ -0,0 +1,10 @@
+#ifndef EE_UI_DOC_addX86Assembly
+#define EE_UI_DOC_addX86Assembly
+
+namespace EE { namespace UI { namespace Doc { namespace Language {
+
+extern void addX86Assembly();
+
+}}}}
+
+#endif
--- a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp
+++ b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp
--- a/src/tools/ecode/ecode.cpp
+++ b/src/tools/ecode/ecode.cpp
@@ -3517,6 +3517,10 @@ EE_MAIN_FUNC int main( int argc, char* argv[] ) {
 		parser, "convert-lang-path",
 		"Convert any JSON language definition to CPP syntax definition (development helper)",
 		{ "convert-lang-path" }, "" );
+	args::ValueFlag<std::string> convertLangOutput(
+		parser, "convert-lang-output",
+		"Sets the directory output path. If not set it will be printed to stdout",
+		{ "convert-lang-output" }, "" );

 	std::vector<std::string> args;
 	try {
@@ -3547,7 +3551,20 @@ EE_MAIN_FUNC int main( int argc, char* argv[] ) {
 				for ( const auto& lang : adedLangs ) {
 					const auto& def =
 						SyntaxDefinitionManager::instance()->getByLanguageName( lang );
-					std::cout << SyntaxDefinitionManager::toCPP( def ) << "\n";
+					auto code = SyntaxDefinitionManager::toCPP( def );
+					if ( convertLangOutput && !convertLangOutput.Get().empty() &&
+						 FileSystem::isDirectory( convertLangOutput.Get() ) ) {
+						std::string output( convertLangOutput.Get() );
+						FileSystem::dirAddSlashAtEnd( output );
+						FileSystem::fileWrite( output + String::toLower( def.getLanguageName() ) +
+												   ".hpp",
+											   code.first );
+						FileSystem::fileWrite( output + String::toLower( def.getLanguageName() ) +
+												   ".cpp",
+											   code.second );
+					} else {
+						std::cout << code.first << code.second << "\n";
+					}
 				}
 			}
 		}