From aade7371f81c9579eccb40944c02b531ed64de8d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mart=C3=ADn=20Lucas=20Golini?= Date: Sat, 2 Apr 2022 21:14:36 -0300 Subject: [PATCH] Added XML tags auto-close. --- TODO.md | 8 +- include/eepp/ui/doc/syntaxhighlighter.hpp | 2 + include/eepp/ui/doc/syntaxtokenizer.hpp | 9 + include/eepp/ui/uicodeeditor.hpp | 8 + src/eepp/ui/doc/syntaxdefinition.cpp | 2 +- src/eepp/ui/doc/syntaxdefinitionmanager.cpp | 3617 ++++++++++--------- src/eepp/ui/doc/syntaxhighlighter.cpp | 17 + src/eepp/ui/doc/syntaxtokenizer.cpp | 10 +- src/eepp/ui/uicodeeditor.cpp | 46 +- src/tools/ecode/appconfig.cpp | 2 + src/tools/ecode/appconfig.hpp | 1 + src/tools/ecode/ecode.cpp | 13 +- 12 files changed, 1921 insertions(+), 1814 deletions(-) diff --git a/TODO.md b/TODO.md index 208ddd2b3..b447aa9a0 100644 --- a/TODO.md +++ b/TODO.md @@ -13,15 +13,11 @@ Detect errors and log them. -## TextDocument - -* Add XML tags auto-close. - ## ecode - Code Editor -* Support single instance (when a new file is opened while a previous instance exists, open it in the first instance). +* Add LSP support. -* Add support for function listing. +* Add terminal support. ## UI Editor diff --git a/include/eepp/ui/doc/syntaxhighlighter.hpp b/include/eepp/ui/doc/syntaxhighlighter.hpp index c508909f6..62e9087e8 100644 --- a/include/eepp/ui/doc/syntaxhighlighter.hpp +++ b/include/eepp/ui/doc/syntaxhighlighter.hpp @@ -32,6 +32,8 @@ class EE_API SyntaxHighlighter { bool updateDirty( int visibleLinesCount = 40 ); + const SyntaxDefinition& getSyntaxDefinitionFromTextPosition( const TextPosition& position ); + protected: TextDocument* mDoc; std::map mLines; diff --git a/include/eepp/ui/doc/syntaxtokenizer.hpp b/include/eepp/ui/doc/syntaxtokenizer.hpp index 299c0678a..ac1c9b6ec 100644 --- a/include/eepp/ui/doc/syntaxtokenizer.hpp +++ b/include/eepp/ui/doc/syntaxtokenizer.hpp @@ -15,12 +15,21 @@ struct EE_API SyntaxToken { #define SYNTAX_TOKENIZER_STATE_NONE ( 0 ) +struct SyntaxState { + const SyntaxDefinition* currentSyntax{ nullptr }; + const SyntaxPattern* subsyntaxInfo{ nullptr }; + Uint32 currentPatternIdx{ 0 }; + Uint32 currentLevel{ 0 }; +}; + class EE_API SyntaxTokenizer { public: static std::pair, Uint32> tokenize( const SyntaxDefinition& syntax, const std::string& text, const Uint32& state, const size_t& startIndex = 0 ); + + static SyntaxState retrieveSyntaxState( const SyntaxDefinition& syntax, const Uint32& state ); }; }}} // namespace EE::UI::Doc diff --git a/include/eepp/ui/uicodeeditor.hpp b/include/eepp/ui/uicodeeditor.hpp index 3ece8a64f..9359c6eda 100644 --- a/include/eepp/ui/uicodeeditor.hpp +++ b/include/eepp/ui/uicodeeditor.hpp @@ -452,6 +452,10 @@ class EE_API UICodeEditor : public UIWidget, public TextDocument::Client { void showMinimap( bool showMinimap ); + bool getAutoCloseXMLTags() const; + + void setAutoCloseXMLTags( bool autoCloseXMLTags ); + protected: struct LastXOffset { TextPosition position; @@ -483,6 +487,7 @@ class EE_API UICodeEditor : public UIWidget, public TextDocument::Client { bool mMinimapEnabled{ false }; bool mMinimapDragging{ false }; bool mMinimapHover{ false }; + bool mAutoCloseXMLTags{ false }; TextRange mLinkPosition; String mLink; Uint32 mTabWidth; @@ -686,6 +691,9 @@ class EE_API UICodeEditor : public UIWidget, public TextDocument::Client { Float getMinimapWidth() const; void updateMipmapHover( const Vector2f& position ); + + bool checkAutoCloseXMLTag( const String& text ); + }; }} // namespace EE::UI diff --git a/src/eepp/ui/doc/syntaxdefinition.cpp b/src/eepp/ui/doc/syntaxdefinition.cpp index 03f5f8b70..608c2bb74 100644 --- a/src/eepp/ui/doc/syntaxdefinition.cpp +++ b/src/eepp/ui/doc/syntaxdefinition.cpp @@ -13,7 +13,7 @@ SyntaxDefinition::SyntaxDefinition( const std::string& languageName, const std::string& comment, const std::vector headers ) : mLanguageName( languageName ), - mLanguageId( String::hash( languageName ) ), + mLanguageId( String::hash( String::toLower( languageName ) ) ), mFiles( files ), mPatterns( patterns ), mSymbols( symbols ), diff --git a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp index 8a0f43eb8..5f8e4de81 100644 --- a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp +++ b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp @@ -6,7 +6,8 @@ using namespace EE::System; -namespace EE { namespace UI { namespace Doc { +namespace EE { +namespace UI { namespace Doc { SINGLETON_DECLARE_IMPLEMENTATION( SyntaxDefinitionManager ) @@ -42,7 +43,7 @@ SyntaxDefinitionManager::SyntaxDefinitionManager() { // HTML add( { "HTML", - { "%.html?$" }, + { "%.html?$", "%.php$", "%.php3$", "%.php4$", "%.php5$", "%.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*>", @@ -55,6 +56,7 @@ SyntaxDefinitionManager::SyntaxDefinitionManager() { { { "<%s*[sS][tT][yY][lL][eE][^>]*>", "<%s*/%s*[sS][tT][yY][lL][eE]%s*>" }, "function", "CSS" }, + { { "<%?p?h?p?", "%?>" }, "function", "PHP" }, { { "" }, "comment" }, { { "%f[^>][^<]", "%f[<]" }, "normal" }, { { "\"", "\"", "\\" }, "string" }, @@ -492,8 +494,10 @@ SyntaxDefinitionManager::SyntaxDefinitionManager() { // PHP add( { "PHP", - { "%.php$", "%.php3$", "%.php4$", "%.php5$", "%.phtml" }, + {}, { + { { "<%?p?h?p?" }, "function" }, + { { "%?>", "<%?p?h?p?" }, "function", "HTML" }, { { "//.-\n" }, "comment" }, { { "/%*", "%*/" }, "comment" }, { { "#.-\n" }, "comment" }, @@ -549,1861 +553,1880 @@ SyntaxDefinitionManager::SyntaxDefinitionManager() { { "NULL", "literal" }, { "parent", "literal" }, { "self", "literal" }, { "echo", "function" } }, "//", - { "^#!.*[ /]php", "^<%?php" } } ); + { "^#!.*[ /]php" } } ); - // Add SQL - std::vector keywords = { - "CREATE", "SELECT", "INSERT", "INTO", "UPDATE", "DELETE", - "TABLE", "DROP", "VALUES", "NOT", "NULL", "PRIMARY", - "KEY", "REFERENCES", "DEFAULT", "UNIQUE", "CONSTRAINT", "CHECK", - "ON", "EXCLUDE", "WITH", "USING", "WHERE", "GROUP", - "BY", "HAVING", "DISTINCT", "LIMIT", "OFFSET", "ONLY", - "CROSS", "JOIN", "INNER", "LEFT", "RIGHT", "FULL", - "OUTER", "NATURAL", "AND", "OR", "AS", "ORDER", - "ORDINALITY", "UNNEST", "FROM", "VIEW", "RETURNS", "SETOF", - "LANGUAGE", "SQL", "LIKE", "LATERAL", "INTERVAL", "PARTITION", - "UNION", "INTERSECT", "EXCEPT", "ALL", "ASC", "DESC", - "NULLS", "FIRST", "LAST", "IN", "RECURSIVE", "ARRAY", - "RETURNING", "SET", "ALSO", "INSTEAD", "ALTER", "SEQUENCE", - "OWNED", "AT", "ZONE", "WITHOUT", "TO", "TIMEZONE", - "TYPE", "ENUM", "DOCUMENT", "XMLPARSE", "XMLSERIALIZE", "CONTENT", - "OPTION", "INDEX", "ANY", "EXTENSION", "ISNULL", "NOTNULL", - "UNKNOWN", "CASE", "THEN", "WHEN", "ELSE", "END", - "ROWS", "BETWEEN", "UNBOUNDED", "PRECEDING", "UNBOUNDED", "FOLLOWING", - "EXISTS", "SOME", "COLLATION", "FOR", "TRIGGER", "BEFORE", - "EACH", "ROW", "EXECUTE", "PROCEDURE", "FUNCTION", "DECLARE", - "BEGIN", "LOOP", "RAISE", "NOTICE", "LOOP", "EVENT", - "OPERATOR", "DOMAIN", "VARIADIC", "FOREIGN" }; + // Add SQL + std::vector keywords = { + "CREATE", "SELECT", "INSERT", "INTO", "UPDATE", "DELETE", + "TABLE", "DROP", "VALUES", "NOT", "NULL", "PRIMARY", + "KEY", "REFERENCES", "DEFAULT", "UNIQUE", "CONSTRAINT", "CHECK", + "ON", "EXCLUDE", "WITH", "USING", "WHERE", "GROUP", + "BY", "HAVING", "DISTINCT", "LIMIT", "OFFSET", "ONLY", + "CROSS", "JOIN", "INNER", "LEFT", "RIGHT", "FULL", + "OUTER", "NATURAL", "AND", "OR", "AS", "ORDER", + "ORDINALITY", "UNNEST", "FROM", "VIEW", "RETURNS", "SETOF", + "LANGUAGE", "SQL", "LIKE", "LATERAL", "INTERVAL", "PARTITION", + "UNION", "INTERSECT", "EXCEPT", "ALL", "ASC", "DESC", + "NULLS", "FIRST", "LAST", "IN", "RECURSIVE", "ARRAY", + "RETURNING", "SET", "ALSO", "INSTEAD", "ALTER", "SEQUENCE", + "OWNED", "AT", "ZONE", "WITHOUT", "TO", "TIMEZONE", + "TYPE", "ENUM", "DOCUMENT", "XMLPARSE", "XMLSERIALIZE", "CONTENT", + "OPTION", "INDEX", "ANY", "EXTENSION", "ISNULL", "NOTNULL", + "UNKNOWN", "CASE", "THEN", "WHEN", "ELSE", "END", + "ROWS", "BETWEEN", "UNBOUNDED", "PRECEDING", "UNBOUNDED", "FOLLOWING", + "EXISTS", "SOME", "COLLATION", "FOR", "TRIGGER", "BEFORE", + "EACH", "ROW", "EXECUTE", "PROCEDURE", "FUNCTION", "DECLARE", + "BEGIN", "LOOP", "RAISE", "NOTICE", "LOOP", "EVENT", + "OPERATOR", "DOMAIN", "VARIADIC", "FOREIGN" }; - std::vector types = { - "BIGINT", "INT8", "BIGSERIAL", "SERIAL8", "BIT", "VARBIT", - "BOOLEAN", "BOOL", "BOX", "BYTEA", "CHARACTER", "CHAR", - "VARCHAR", "CIDR", "CIRCLE", "DATE", "DOUBLE", "PRECISION", - "FLOAT8", "INET", "INTEGER", "INT", "INT4", "INTERVAL", - "JSON", "JSONB", "LINE", "LSEG", "MACADDR", "MONEY", - "NUMERIC", "DECIMAL", "PATH", "POINT", "POLYGON", "REAL", - "FLOAT4", "INT2", "SMALLINT", "SMALLSERIAL", "SERIAL2", "SERIAL", - "SERIAL4", "TEXT", "TIME", "TIMEZ", "TIMESTAMP", "TIMESTAMPZ", - "TSQUERY", "TSVECTOR", "TXID_SNAPSHOT", "UUID", "XML", "INT4RANGE", - "INT8RANGE", "NUMRANGE", "TSRANGE", "TSTZRANGE", "DATERANGE", "PG_LSN" }; + std::vector types = { + "BIGINT", "INT8", "BIGSERIAL", "SERIAL8", "BIT", "VARBIT", + "BOOLEAN", "BOOL", "BOX", "BYTEA", "CHARACTER", "CHAR", + "VARCHAR", "CIDR", "CIRCLE", "DATE", "DOUBLE", "PRECISION", + "FLOAT8", "INET", "INTEGER", "INT", "INT4", "INTERVAL", + "JSON", "JSONB", "LINE", "LSEG", "MACADDR", "MONEY", + "NUMERIC", "DECIMAL", "PATH", "POINT", "POLYGON", "REAL", + "FLOAT4", "INT2", "SMALLINT", "SMALLSERIAL", "SERIAL2", "SERIAL", + "SERIAL4", "TEXT", "TIME", "TIMEZ", "TIMESTAMP", "TIMESTAMPZ", + "TSQUERY", "TSVECTOR", "TXID_SNAPSHOT", "UUID", "XML", "INT4RANGE", + "INT8RANGE", "NUMRANGE", "TSRANGE", "TSTZRANGE", "DATERANGE", "PG_LSN" }; - std::vector literals = { "FALSE", "TRUE", "CURRENT_TIMESTAMP", - "CURRENT_TIME", "CURRENT_DATE", "LOCALTIME", - "LOCALTIMESTAMP" }; + std::vector literals = { "FALSE", "TRUE", "CURRENT_TIMESTAMP", + "CURRENT_TIME", "CURRENT_DATE", "LOCALTIME", + "LOCALTIMESTAMP" }; - std::unordered_map symbols; - for ( auto& keyword : keywords ) { - symbols[String::toLower( keyword )] = "keyword"; - symbols[keyword] = "keyword"; - } - - for ( auto& type : types ) { - symbols[String::toLower( type )] = "keyword2"; - symbols[type] = "keyword2"; - } - - for ( auto& literal : literals ) { - symbols[String::toLower( literal )] = "literal"; - symbols[literal] = "literal"; - } - - add( { "SQL", - { "%.sql$", "%.psql$" }, - { - { { "%-%-.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "'", "'", "\\" }, "string" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%%<>!~|&@%?$#]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - symbols, - "--" } ); - - // GLSL - add( { "GLSL", - { "%.glsl$", "%.frag$", "%.vert$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "#", "[^\\]\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "ivec[2-4]" }, "keyword2" }, - { { "bvec[2-4]" }, "keyword2" }, - { { "uvec[2-4]" }, "keyword2" }, - { { "vec[2-4]" }, "keyword2" }, - { { "dmat[2-4]x[2-4]" }, "keyword2" }, - { { "dmat[2-4]" }, "keyword2" }, - { { "mat[2-4]x[2-4]" }, "keyword2" }, - { { "mat[2-4]" }, "keyword2" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "if", "keyword" }, - { "else", "keyword" }, - { "do", "keyword" }, - { "while", "keyword" }, - { "for", "keyword" }, - { "break", "keyword" }, - { "continue", "keyword" }, - { "return", "keyword" }, - { "const", "keyword" }, - { "switch", "keyword" }, - { "case", "keyword" }, - { "default", "keyword" }, - { "const", "keyword" }, - { "void", "keyword" }, - { "bool", "keyword2" }, - { "int", "keyword2" }, - { "uint", "keyword2" }, - { "float", "keyword2" }, - { "double", "keyword2" }, - { "true", "literal" }, - { "false", "literal" }, - { "NULL", "literal" }, - { "attribute", "keyword" }, - { "varying", "keyword" }, - { "uniform", "keyword" }, - { "buffer", "keyword" }, - { "shared", "keyword" }, - { "layout", "keyword" }, - { "centroid", "keyword" }, - { "flat", "keyword" }, - { "smooth", "keyword" }, - { "noperspective", "keyword" }, - { "patch", "keyword" }, - { "sample", "keyword" }, - { "in", "keyword" }, - { "out", "keyword" }, - { "inout", "keyword" }, - { "invariant", "keyword" }, - { "precise", "keyword" }, - { "lowp", "keyword" }, - { "mediump", "keyword" }, - { "highp", "keyword" }, - { "precision", "keyword" }, - { "struct", "keyword" }, - { "subroutine", "keyword" }, - { "coherent", "keyword" }, - { "volatile", "keyword" }, - { "readonly", "keyword" }, - { "writeonly", "keyword" }, - { "sampler1D", "keyword2" }, - { "sampler2D", "keyword2" }, - { "sampler3D", "keyword2" }, - { "samplerCube", "keyword2" }, - { "sampler1DShadow", "keyword2" }, - { "sampler2DShadow", "keyword2" }, - { "samplerCubeShadow", "keyword2" }, - { "sampler1DArray", "keyword2" }, - { "sampler2DArray", "keyword2" }, - { "samplerCubeArray", "keyword2" }, - { "sampler1DArrayShadow", "keyword2" }, - { "sampler2DArrayShadow", "keyword2" }, - { "samplerCubeArrayShadow", "keyword2" }, - { "isampler1D", "keyword2" }, - { "isampler2D", "keyword2" }, - { "isampler3D", "keyword2" }, - { "isamplerCube", "keyword2" }, - { "sampler2DMS", "keyword2" }, - { "isampler2DMS", "keyword2" }, - { "usampler2DMS", "keyword2" }, - { "sampler2DMSArray", "keyword2" }, - { "isampler2DMSArray", "keyword2" }, - { "usampler2DMSArray", "keyword2" }, - { "isampler1DArray", "keyword2" }, - { "isampler2DArray", "keyword2" }, - { "usampler1D", "keyword2" }, - { "usampler2D", "keyword2" }, - { "usampler3D", "keyword2" }, - { "usamplerCube", "keyword2" }, - { "usampler1DArray", "keyword2" }, - { "usampler2DArray", "keyword2" }, - { "sampler2DRect", "keyword2" }, - { "sampler2DRectShadow", "keyword2" }, - { "isampler2DRect", "keyword2" }, - { "usampler2DRect", "keyword2" }, - { "samplerBuffer", "keyword2" }, - { "isamplerBuffer", "keyword2" }, - { "usamplerBuffer", "keyword2" }, - { "image1D", "keyword2" }, - { "iimage1D", "keyword2" }, - { "uimage1D", "keyword2" }, - { "image1DArray", "keyword2" }, - { "iimage1DArray", "keyword2" }, - { "uimage1DArray", "keyword2" }, - { "image2D", "keyword2" }, - { "iimage2D", "keyword2" }, - { "uimage2D", "keyword2" }, - { "image2DArray", "keyword2" }, - { "iimage2DArray", "keyword2" }, - { "uimage2DArray", "keyword2" }, - { "image2DRect", "keyword2" }, - { "iimage2DRect", "keyword2" }, - { "uimage2DRect", "keyword2" }, - { "image2DMS", "keyword2" }, - { "iimage2DMS", "keyword2" }, - { "uimage2DMS", "keyword2" }, - { "image2DMSArray", "keyword2" }, - { "iimage2DMSArray", "keyword2" }, - { "uimage2DMSArray", "keyword2" }, - { "image3D", "keyword2" }, - { "iimage3D", "keyword2" }, - { "uimage3D", "keyword2" }, - { "imageCube", "keyword2" }, - { "iimageCube", "keyword2" }, - { "uimageCube", "keyword2" }, - { "imageCubeArray", "keyword2" }, - { "iimageCubeArray", "keyword2" }, - { "uimageCubeArray", "keyword2" }, - { "imageBuffer", "keyword2" }, - { "iimageBuffer", "keyword2" }, - { "uimageBuffer", "keyword2" }, - { "atomic_uint", "keyword2" }, - { "radians", "keyword" }, - { "degrees", "keyword" }, - { "sin", "keyword" }, - { "cos", "keyword" }, - { "tan", "keyword" }, - { "asin", "keyword" }, - { "acos", "keyword" }, - { "atan", "keyword" }, - { "sinh", "keyword" }, - { "cosh", "keyword" }, - { "tanh", "keyword" }, - { "asinh", "keyword" }, - { "acosh", "keyword" }, - { "pow", "keyword" }, - { "exp", "keyword" }, - { "exp2", "keyword" }, - { "log2", "keyword" }, - { "sqrt", "keyword" }, - { "inversesqrt", "keyword" }, - { "abs", "keyword" }, - { "sign", "keyword" }, - { "floor", "keyword" }, - { "trunc", "keyword" }, - { "round", "keyword" }, - { "roundEven", "keyword" }, - { "ceil", "keyword" }, - { "fract", "keyword" }, - { "mod", "keyword" }, - { "modf", "keyword" }, - { "min", "keyword" }, - { "max", "keyword" }, - { "clamp", "keyword" }, - { "mix", "keyword" }, - { "step", "keyword" }, - { "smoothstep", "keyword" }, - { "isnan", "keyword" }, - { "isinf", "keyword" }, - { "floatBitsToInt", "keyword" }, - { "floatBitsToUint", "keyword" }, - { "intBitsToFloat", "keyword" }, - { "uintBitsToFloat", "keyword" }, - { "fma", "keyword" }, - { "frexp", "keyword" }, - { "ldexp", "keyword" }, - { "packUnorm2x16", "keyword" }, - { "packSnorm2x16", "keyword" }, - { "packUnorm4x8", "keyword" }, - { "packSnorm4x8", "keyword" }, - { "unpackUnorm2x16", "keyword" }, - { "unpackSnorm2x16", "keyword" }, - { "unpackUnorm4x8", "keyword" }, - { "unpackSnorm4x8", "keyword" }, - { "packHalf2x16", "keyword" }, - { "unpackHalf2x16", "keyword" }, - { "packDouble2x32", "keyword" }, - { "unpackDouble2x32", "keyword" }, - { "length", "keyword" }, - { "distance", "keyword" }, - { "dot", "keyword" }, - { "cross", "keyword" }, - { "normalize", "keyword" }, - { "ftransform", "keyword" }, - { "faceforward", "keyword" }, - { "reflect", "keyword" }, - { "refract", "keyword" }, - { "matrixCompMult", "keyword" }, - { "outerProduct", "keyword" }, - { "transpose", "keyword" }, - { "determinant", "keyword" }, - { "inverse", "keyword" }, - { "lessThan", "keyword" }, - { "lessThanEqual", "keyword" }, - { "greaterThan", "keyword" }, - { "greaterThanEqual", "keyword" }, - { "equal", "keyword" }, - { "notEqual", "keyword" }, - { "any", "keyword" }, - { "all", "keyword" }, - { "not", "keyword" }, - { "uaddCarry", "keyword" }, - { "usubBorrow", "keyword" }, - { "umulExtended", "keyword" }, - { "imulExtended", "keyword" }, - { "bitfieldExtract", "keyword" }, - { "bitfieldInsert", "keyword" }, - { "bitfieldReverse", "keyword" }, - { "bitCount", "keyword" }, - { "findLSB", "keyword" }, - { "findMSB", "keyword" }, - { "textureSize", "keyword" }, - { "textureQueryLod", "keyword" }, - { "textureQueryLevels", "keyword" }, - { "textureSamples", "keyword" }, - { "texture", "keyword" }, - { "textureProj", "keyword" }, - { "textureLod", "keyword" }, - { "textureOffset", "keyword" }, - { "texelFetch", "keyword" }, - { "texelFetchOffset", "keyword" }, - { "textureProjOffset", "keyword" }, - { "textureLodOffset", "keyword" }, - { "textureProjLod", "keyword" }, - { "textureProjLodOffset", "keyword" }, - { "textureGrad", "keyword" }, - { "textureGradOffset", "keyword" }, - { "textureProjGrad", "keyword" }, - { "textureProjGradOffset", "keyword" }, - { "textureGather", "keyword" }, - { "textureGatherOffset", "keyword" }, - { "textureGatherOffsets", "keyword" }, - { "atomicCounterIncrement", "keyword" }, - { "atomicCounterDecrement", "keyword" }, - { "atomicCounter", "keyword" }, - { "atomicCounterAdd", "keyword" }, - { "atomicCounterSubtract", "keyword" }, - { "atomicCounterMin", "keyword" }, - { "atomicCounterMax", "keyword" }, - { "atomicCounterAnd", "keyword" }, - { "atomicCounterOr", "keyword" }, - { "atomicCounterXor", "keyword" }, - { "atomicCounterExchange", "keyword" }, - { "atomicCounterCompSwap", "keyword" }, - { "atomicAdd", "keyword" }, - { "atomicMin", "keyword" }, - { "atomicMax", "keyword" }, - { "atomicAnd", "keyword" }, - { "atomicOr", "keyword" }, - { "atomicXor", "keyword" }, - { "atomicExchange", "keyword" }, - { "atomicCompSwap", "keyword" }, - { "imageSize", "keyword" }, - { "imageSamples", "keyword" }, - { "imageLoad", "keyword" }, - { "imageStore", "keyword" }, - { "imageAtomicAdd", "keyword" }, - { "imageAtomicMin", "keyword" }, - { "imageAtomicMax", "keyword" }, - { "imageAtomicAnd", "keyword" }, - { "imageAtomicOr", "keyword" }, - { "imageAtomicXor", "keyword" }, - { "imageAtomicExchange", "keyword" }, - { "imageAtomicCompSwap", "keyword" }, - { "EmitStreamVertex", "keyword" }, - { "EndStreamPrimitive", "keyword" }, - { "EmitVertex", "keyword" }, - { "EndPrimitive", "keyword" }, - { "dFdx", "keyword" }, - { "dFdy", "keyword" }, - { "dFdxFine", "keyword" }, - { "dFdyFine", "keyword" }, - { "dFdxCoarse", "keyword" }, - { "dFdyCoarse", "keyword" }, - { "fwidth", "keyword" }, - { "fwidthFine", "keyword" }, - { "fwidthCoarse", "keyword" }, - { "interpolateAtCentroid", "keyword" }, - { "interpolateAtSample", "keyword" }, - { "interpolateAtOffset", "keyword" }, - { "barrier", "keyword" }, - { "memoryBarrier", "keyword" }, - { "memoryBarrierAtomicCounter", "keyword" }, - { "memoryBarrierBuffer", "keyword" }, - { "memoryBarrierShared", "keyword" }, - { "memoryBarrierImage", "keyword" }, - { "groupMemoryBarrier", "keyword" }, - { "subpassLoad", "keyword" }, - { "anyInvocation", "keyword" }, - { "allInvocations", "keyword" }, - { "allInvocationsEqual", "keyword" }, - { "texture1D", "keyword" }, - { "texture1DArray", "keyword" }, - { "itexture1D", "keyword" }, - { "itexture1DArray", "keyword" }, - { "utexture1D", "keyword" }, - { "utexture1DArray", "keyword" }, - { "texture2D", "keyword" }, - { "texture2DArray", "keyword" }, - { "itexture2D", "keyword" }, - { "itexture2DArray", "keyword" }, - { "utexture2D", "keyword" }, - { "utexture2DArray", "keyword" }, - { "texture2DRect", "keyword" }, - { "itexture2DRect", "keyword" }, - { "utexture2DRect", "keyword" }, - { "texture2DMS", "keyword" }, - { "itexture2DMS", "keyword" }, - { "utexture2DMS", "keyword" }, - { "texture2DMSArray", "keyword" }, - { "itexture2DMSArray", "keyword" }, - { "utexture2DMSArray", "keyword" }, - { "texture3D", "keyword" }, - { "itexture3D", "keyword" }, - { "utexture3D", "keyword" }, - { "textureCube", "keyword" }, - { "itextureCube", "keyword" }, - { "utextureCube", "keyword" }, - { "textureCubeArray", "keyword" }, - { "itextureCubeArray", "keyword" }, - { "utextureCubeArray", "keyword" }, - { "textureBuffer", "keyword" }, - { "itextureBuffer", "keyword" }, - { "utextureBuffer", "keyword" }, - { "sampler", "keyword2" }, - { "samplerShadow", "keyword2" }, - { "subpassInput", "keyword2" }, - { "isubpassInput", "keyword2" }, - { "usubpassInput", "keyword2" }, - { "subpassInputMS", "keyword2" }, - { "isubpassInputMS", "keyword2" }, - { "usubpassInputMS", "keyword2" }, - }, - "//" } ); - - // ini / conf - add( { "Config File", - { "%.ini$", "%.conf$", "%.desktop$", "%.service$", "%.cfg$", "%.env$", "Doxyfile" }, - { { { "^#.-\n" }, "comment" }, - { { "%s#.-\n" }, "comment" }, - { { "%s?#%x+" }, "string" }, - { { "[%a_][%w-+_%s%p]-%f[=]" }, "keyword" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "^%[.-%]" }, "keyword2" }, - { { "%s%[.-%]" }, "keyword2" }, - { { "=" }, "operator" }, - { { "https?://(([%w_.~!*:@&+$/?%%#-]-)(%w[-.%w]*%.)(%w%w%w?%w?)(:?)(%d*)(/" - "?)([%w_.~!*:@&+$/?%%#=-]*))" }, - "link" }, - { { "[a-z]+" }, "symbol" } }, - { { "true", "literal" }, { "false", "literal" } }, - "#", - { "^%[.-%]" } } ); - - // Makefile - add( { "Makefile", - { "Makefile", "makefile", "%.mk$", "%.make$" }, - { - { { "#.*\n" }, "comment" }, - { { "[[.]]}" }, "normal" }, - { { "$[@^<%%?+|*]" }, "keyword2" }, - { { "$%(", "%)" }, "keyword" }, - { { "%f[%w_][%d%.]+%f[^%w_]" }, "number" }, - { { "%..*:" }, "keyword2" }, - { { ".*:=" }, "function" }, - { { ".*+=" }, "function" }, - { { ".*%s=" }, "function" }, - }, - {}, - "#" } ); - - // C# - add( { "C#", - { "%.cs$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "[%$%@]?\"", "\"", "\\" }, "string" }, - { { "'\\x%x?%x?%x?%x'" }, "string" }, - { { "'\\u%x%x%x%x'" }, "string" }, - { { "'\\?.'" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "%?%?" }, "operator" }, - { { "%?%." }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { { "abstract", "keyword" }, { "as", "keyword" }, { "await", "keyword" }, - { "base", "keyword" }, { "break", "keyword" }, { "case", "keyword" }, - { "catch", "keyword" }, { "checked", "keyword" }, { "class", "keyword" }, - { "const", "keyword" }, { "continue", "keyword" }, { "default", "keyword" }, - { "delegate", "keyword" }, { "do", "keyword" }, { "else", "keyword" }, - { "enum", "keyword" }, { "event", "keyword" }, { "explicit", "keyword" }, - { "extern", "keyword" }, { "finally", "keyword" }, { "fixed", "keyword" }, - { "for", "keyword" }, { "foreach", "keyword" }, { "get", "keyword" }, - { "goto", "keyword" }, { "if", "keyword" }, { "implicit", "keyword" }, - { "in", "keyword" }, { "interface", "keyword" }, { "internal", "keyword" }, - { "is", "keyword" }, { "lock", "keyword" }, { "namespace", "keyword" }, - { "new", "keyword" }, { "operator", "keyword" }, { "out", "keyword" }, - { "override", "keyword" }, { "params", "keyword" }, { "private", "keyword" }, - { "protected", "keyword" }, { "public", "keyword" }, { "readonly", "keyword" }, - { "ref", "keyword" }, { "return", "keyword" }, { "sealed", "keyword" }, - { "set", "keyword" }, { "sizeof", "keyword" }, { "stackalloc", "keyword" }, - { "static", "keyword" }, { "struct", "keyword" }, { "switch", "keyword" }, - { "this", "keyword" }, { "throw", "keyword" }, { "try", "keyword" }, - { "typeof", "keyword" }, { "unchecked", "keyword" }, { "unsafe", "keyword" }, - { "using", "keyword" }, { "var", "keyword" }, { "virtual", "keyword" }, - { "void", "keyword" }, { "volatile", "keyword" }, { "where", "keyword" }, - { "while", "keyword" }, { "yield", "keyword" }, { "bool", "keyword2" }, - { "byte", "keyword2" }, { "char", "keyword2" }, { "decimal", "keyword2" }, - { "double", "keyword2" }, { "float", "keyword2" }, { "int", "keyword2" }, - { "long", "keyword2" }, { "object", "keyword2" }, { "sbyte", "keyword2" }, - { "short", "keyword2" }, { "string", "keyword2" }, { "uint", "keyword2" }, - { "ulong", "keyword2" }, { "ushort", "keyword2" }, { "true", "literal" }, - { "false", "literal" }, { "null", "literal" }, { "add", "keyword" }, - { "record", "keyword" }, { "remove", "keyword" }, { "partial", "keyword" }, - { "dynamic", "keyword" }, { "value", "keyword" }, { "global", "keyword" }, - { "when", "keyword" } }, - "//" } ); - - // Go - add( { "Go", - { "%.go$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "`", "`", "\\" }, "string" }, - { { "0[oO_][0-7]+" }, "number" }, - { { "-?0x[%x_]+" }, "number" }, - { { "-?%d+_%d" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { ":=" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "if", "keyword" }, { "else", "keyword" }, { "elseif", "keyword" }, - { "for", "keyword" }, { "continue", "keyword" }, { "return", "keyword" }, - { "struct", "keyword" }, { "switch", "keyword" }, { "case", "keyword" }, - { "default", "keyword" }, { "const", "keyword" }, { "package", "keyword" }, - { "import", "keyword" }, { "func", "keyword" }, { "var", "keyword" }, - { "type", "keyword" }, { "interface", "keyword" }, { "select", "keyword" }, - { "break", "keyword" }, { "range", "keyword" }, { "chan", "keyword" }, - { "defer", "keyword" }, { "go", "keyword" }, { "fallthrough", "keyword" }, - { "int", "keyword2" }, { "int64", "keyword2" }, { "int32", "keyword2" }, - { "int16", "keyword2" }, { "int8", "keyword2" }, { "uint", "keyword2" }, - { "uint64", "keyword2" }, { "uint32", "keyword2" }, { "uint16", "keyword2" }, - { "uint8", "keyword2" }, { "uintptr", "keyword2" }, { "float64", "keyword2" }, - { "float32", "keyword2" }, { "map", "keyword2" }, { "string", "keyword2" }, - { "rune", "keyword2" }, { "bool", "keyword2" }, { "byte", "keyword2" }, - { "error", "keyword2" }, { "complex64", "keyword2" }, { "complex128", "keyword2" }, - { "true", "literal" }, { "false", "literal" }, { "nil", "literal" }, - }, - "//" } ); - - // Rust - add( { "Rust", - { "%.rs$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "`", "`", "\\" }, "string" }, - { { "0[oO_][0-7]+" }, "number" }, - { { "-?0x[%x_]+" }, "number" }, - { { "-?%d+_%d" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "as", "keyword" }, { "async", "keyword" }, { "await", "keyword" }, - { "break", "keyword" }, { "const", "keyword" }, { "continue", "keyword" }, - { "crate", "keyword" }, { "dyn", "keyword" }, { "else", "keyword" }, - { "enum", "keyword" }, { "extern", "keyword" }, { "false", "keyword" }, - { "fn", "keyword" }, { "for", "keyword" }, { "if", "keyword" }, - { "impl", "keyword" }, { "in", "keyword" }, { "let", "keyword" }, - { "loop", "keyword" }, { "match", "keyword" }, { "mod", "keyword" }, - { "move", "keyword" }, { "mut", "keyword" }, { "pub", "keyword" }, - { "ref", "keyword" }, { "return", "keyword" }, { "Self", "keyword" }, - { "self", "keyword" }, { "static", "keyword" }, { "struct", "keyword" }, - { "super", "keyword" }, { "trait", "keyword" }, { "true", "keyword" }, - { "type", "keyword" }, { "unsafe", "keyword" }, { "use", "keyword" }, - { "where", "keyword" }, { "while", "keyword" }, { "i32", "keyword2" }, - { "i64", "keyword2" }, { "i128", "keyword2" }, { "i16", "keyword2" }, - { "i8", "keyword2" }, { "u8", "keyword2" }, { "u16", "keyword2" }, - { "u32", "keyword2" }, { "u64", "keyword2" }, { "usize", "keyword2" }, - { "isize", "keyword2" }, { "f32", "keyword2" }, { "f64", "keyword2" }, - { "f128", "keyword2" }, { "String", "keyword2" }, { "char", "keyword2" }, - { "&str", "keyword2" }, { "bool", "keyword2" }, { "true", "literal" }, - { "false", "literal" }, { "None", "literal" }, { "Some", "literal" }, - { "Option", "literal" }, { "Result", "literal" }, - }, - "//" } ); - - // GDScript - 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" }, - }, - "#" } ); - - // D - add( { "D", - { "%.d$", "%.di$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "/%+", "%+/" }, "comment" }, - { { "`", "`", "\\" }, "string" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&%$]+" }, "operator" }, - { { "[%a_][%w_]*!" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - { { "@safe" }, "keyword" }, - { { "@trusted" }, "keyword" }, - { { "@nogc" }, "keyword" }, - }, - { - { "abstract", "keyword" }, - { "alias", "keyword" }, - { "align", "keyword" }, - { "asm", "keyword" }, - { "assert", "keyword" }, - { "auto", "keyword" }, - { "body", "keyword" }, - { "bool", "keyword2" }, - { "break", "keyword" }, - { "byte", "keyword2" }, - { "case", "keyword" }, - { "cast", "keyword" }, - { "catch", "keyword" }, - { "cdouble", "keyword2" }, - { "cent", "keyword2" }, - { "cfloat", "keyword2" }, - { "char", "keyword2" }, - { "class", "keyword" }, - { "const", "keyword" }, - { "continue", "keyword" }, - { "creal", "keyword2" }, - { "dchar", "keyword2" }, - { "debug", "keyword" }, - { "default", "keyword" }, - { "delegate", "keyword" }, - { "deprecated", "keyword" }, - { "do", "keyword" }, - { "double", "keyword2" }, - { "else", "keyword" }, - { "enum", "keyword" }, - { "export", "keyword" }, - { "extern", "keyword" }, - { "false", "literal" }, - { "final", "keyword" }, - { "finally", "keyword" }, - { "float", "keyword2" }, - { "for", "keyword" }, - { "foreach", "keyword" }, - { "foreach_reverse", "keyword" }, - { "function", "keyword" }, - { "goto", "keyword" }, - { "idouble", "keyword2" }, - { "if", "keyword" }, - { "ifloat", "keyword2" }, - { "immutable", "keyword" }, - { "import", "keyword" }, - { "in", "keyword" }, - { "inout", "keyword" }, - { "int", "keyword2" }, - { "interface", "keyword" }, - { "invariant", "keyword" }, - { "ireal", "keyword2" }, - { "is", "keyword" }, - { "lazy", "keyword" }, - { "long", "keyword2" }, - { "macro", "keyword" }, - { "mixin", "keyword" }, - { "module", "keyword" }, - { "new", "keyword" }, - { "nothrow", "keyword" }, - { "null", "literal" }, - { "out", "keyword" }, - { "override", "keyword" }, - { "package", "keyword" }, - { "pragma", "keyword" }, - { "private", "keyword" }, - { "protected", "keyword" }, - { "public", "keyword" }, - { "pure", "keyword" }, - { "real", "keyword2" }, - { "ref", "keyword" }, - { "return", "keyword" }, - { "scope", "keyword" }, - { "shared", "keyword" }, - { "short", "keyword2" }, - { "static", "keyword" }, - { "struct", "keyword" }, - { "super", "keyword" }, - { "switch", "keyword" }, - { "synchronized", "keyword" }, - { "template", "keyword" }, - { "this", "keyword" }, - { "throw", "keyword" }, - { "true", "literal" }, - { "try", "keyword" }, - { "typeid", "keyword" }, - { "typeof", "keyword" }, - { "ubyte", "keyword2" }, - { "ucent", "keyword2" }, - { "uint", "keyword2" }, - { "ulong", "keyword2" }, - { "union", "keyword" }, - { "unittest", "keyword" }, - { "ushort", "keyword2" }, - { "version", "keyword" }, - { "void", "keyword" }, - { "wchar", "keyword2" }, - { "while", "keyword" }, - { "with", "keyword" }, - { "__FILE__", "keyword" }, - { "__FILE_FULL_PATH__", "keyword" }, - { "__MODULE__", "keyword" }, - { "__LINE__", "keyword" }, - { "__FUNCTION__", "keyword" }, - { "__PRETTY_FUNCTION__", "keyword" }, - { "__gshared", "keyword" }, - { "__traits", "keyword" }, - { "__vector", "keyword" }, - { "__parameters", "keyword" }, - }, - "//" } ); - - // Haskell - add( { "Haskell", - { "%.hs$" }, - { - { { "%-%-", "\n" }, "comment" }, - { { "{%-", "%-}" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[!%#%$%%&*+./%<=>%?@\\%^|%-~:]" }, "operator" }, - { { "[%a_'][%w_']*" }, "symbol" }, - }, - { - { "as", "keyword" }, { "case", "keyword" }, { "of", "keyword" }, - { "class", "keyword" }, { "data", "keyword" }, { "default", "keyword" }, - { "deriving", "keyword" }, { "do", "keyword" }, { "forall", "keyword" }, - { "foreign", "keyword" }, { "hiding", "keyword" }, { "if", "keyword" }, - { "then", "keyword" }, { "else", "keyword" }, { "import", "keyword" }, - { "infix", "keyword" }, { "infixl", "keyword" }, { "infixr", "keyword" }, - { "let", "keyword" }, { "in", "keyword" }, { "mdo", "keyword" }, - { "module", "keyword" }, { "newtype", "keyword" }, { "qualified", "keyword" }, - { "type", "keyword" }, { "where", "keyword" }, - }, - "%-%-" } ); - - // HLSL - 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" }, - }, - "//" } ); - - // LaTeX - add( { "LaTeX", - { "%.tex$" }, - { - { { "%%", "\n" }, "comment" }, - { { "&" }, "operator" }, - { { "\\\\" }, "operator" }, - { { "%$", "%$" }, "operator" }, - { { "\\%[", "\\]" }, "operator" }, - { { "{", "}" }, "keyword" }, - { { "\\%w*" }, "keyword2" }, - }, - {}, - "%%" } ); - - // Meson - add( { "Meson", - { "meson.build$" }, - { - { { "#", "\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "'''", "'''" }, "string" }, - { { "0x[%da-fA-F]+" }, "number" }, - { { "-?%d+%d*" }, "number" }, - { { "[%+%-=/%%%*!]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "if", "keyword" }, - { "then", "keyword" }, - { "else", "keyword" }, - { "elif", "keyword" }, - { "endif", "keyword" }, - { "foreach", "keyword" }, - { "endforeach", "keyword" }, - { "break", "keyword" }, - { "continue", "keyword" }, - { "and", "keyword" }, - { "not", "keyword" }, - { "or", "keyword" }, - { "in", "keyword" }, - { "true", "literal" }, - { "false", "literal" }, - }, - "#" } ); - - // AngelScript - add( { "AlgelScript", - { "%.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" }, - }, - "//" } ); - - // Batch script - std::unordered_map> batchSymTable = { - { "keyword", - { - "if", "else", "elsif", "not", "for", "do", "in", "equ", - "neq", "lss", "leq", "gtr", "geq", "nul", "con", "prn", - "prn", "lpt1", "com1", "com2", "com3", "com4", "exist", "defined", - "errorlevel", "cmdextversion", "goto", "call", "verify", - } }, - { "function", - { - "set", "setlocal", "endlocal", "enabledelayedexpansion", - "echo", "type", "cd", "chdir", - "md", "mkdir", "pause", "choice", - "exit", "del", "rd", "rmdir", - "copy", "xcopy", "move", "ren", - "find", "findstr", "sort", "shift", - "attrib", "cmd", "command", "forfiles", - } } }; - - auto prepareBatchSymbols = []( std::unordered_map> table ) - -> std::unordered_map { std::unordered_map symbols; - for ( auto& el : table ) { - for ( const auto& it : el.second ) { - symbols[String::toLower( it )] = el.first; - symbols[String::toUpper( it )] = el.first; - } + for ( auto& keyword : keywords ) { + symbols[String::toLower( keyword )] = "keyword"; + symbols[keyword] = "keyword"; } - return symbols; - }; - add( { "Batch script", - { "%.bat$", "%.cmd$" }, - { - { { "@echo off\n" }, "keyword" }, - { { "@echo on\n" }, "keyword" }, - { { "rem.-\n" }, "comment" }, - { { "REM.-\n" }, "comment" }, - { { "%s*:[%w%-]+" }, "symbol" }, - { { "%:%:.-\n" }, "comment" }, - { { "%%%w+%%" }, "symbol" }, - { { "%%%%?~?[%w:]+" }, "symbol" }, - { { "[!=()%>&%^/\\@]" }, "operator" }, - { { "-?%.?%d+f?" }, "number" }, - { { "\"", "\"", "\\" }, "string" }, - { { "[%a_][%w_]*" }, "normal" }, - { { ":eof" }, "keyword" }, - }, - prepareBatchSymbols( batchSymTable ), - "rem" } ); + for ( auto& type : types ) { + symbols[String::toLower( type )] = "keyword2"; + symbols[type] = "keyword2"; + } - // diff - patch - add( { "Diff File", - { "%.diff$", "%.patch$" }, - { - { { "^%+%+%+%s.-\n" }, "keyword" }, - { { "^%-%-%-%s.-\n" }, "keyword" }, - { { "^diff%s.-\n" }, "string" }, - { { "^index%s.-\n" }, "comment" }, - { { "^@@.-\n" }, "number" }, - { { "^%+.-\n" }, "function" }, - { { "^%-.-\n" }, "keyword2" }, - } } ); + for ( auto& literal : literals ) { + symbols[String::toLower( literal )] = "literal"; + symbols[literal] = "literal"; + } - // Add Java - add( - { "Java", - { "%.java$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "'\\x%x?%x?%x?%x'" }, "string" }, - { { "'\\u%x%x%x%x'" }, "string" }, - { { "'\\?.'" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "if", "keyword" }, { "then", "keyword" }, { "else", "keyword" }, - { "elseif", "keyword" }, { "do", "keyword" }, { "while", "keyword" }, - { "for", "keyword" }, { "new", "keyword" }, { "break", "keyword" }, - { "continue", "keyword" }, { "return", "keyword" }, { "goto", "keyword" }, - { "class", "keyword" }, { "implements", "keyword" }, { "extends", "keyword" }, - { "private", "keyword" }, { "protected", "keyword" }, { "public", "keyword" }, - { "abstract", "keyword" }, { "interface", "keyword" }, { "assert", "keyword" }, - { "import", "keyword" }, { "native", "keyword" }, { "package", "keyword" }, - { "super", "keyword" }, { "synchronized", "keyword" }, { "instanceof", "keyword" }, - { "enum", "keyword" }, { "catch", "keyword" }, { "throw", "keyword" }, - { "throws", "keyword" }, { "try", "keyword" }, { "transient", "keyword" }, - { "finally", "keyword" }, { "static", "keyword" }, { "volatile", "keyword" }, - { "final", "keyword" }, { "switch", "keyword" }, { "case", "keyword" }, - { "default", "keyword" }, { "void", "keyword" }, { "int", "keyword2" }, - { "short", "keyword2" }, { "byte", "keyword2" }, { "long", "keyword2" }, - { "float", "keyword2" }, { "double", "keyword2" }, { "char", "keyword2" }, - { "boolean", "keyword2" }, { "true", "literal" }, { "false", "literal" }, - { "null", "literal" }, - }, - "//" } ); + add( { "SQL", + { "%.sql$", "%.psql$" }, + { + { { "%-%-.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "'", "'", "\\" }, "string" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%%<>!~|&@%?$#]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + }, + symbols, + "--" } ); - // YAML - add( { "YAML", - { "%.yml$", "%.yaml$" }, - { - { { "^#.-\n" }, "comment" }, - { { "%s#.-\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "!!str", "\n", "\\" }, "string" }, - { { "%s-%-%s+.*\n" }, "keyword2" }, - { { "%s+[%w%s-_]+:%s+" }, "keyword" }, - { { "^[%w%s-_]+:%s+" }, "keyword" }, - { { "%f[%S]%-?0x%x+" }, "number" }, - { { "%f[%S]%-?%d+[%d%.eE]*f?" }, "number" }, - { { "%f[%S]%-?%.?%d+f?" }, "number" }, - { { "!!float", "\n", "\\" }, "number" }, - { { "https?://(([%w_.~!*:@&+$/?%%#-]-)(%w[-.%w]*%.)(%w%w%w?%w?)(:?)(%d*)(/" - "?)([%w_.~!*:@&+$/?%%#=-]*))" }, - "link" }, - { { "%-%-%-" }, "literal" }, - }, - {}, - "#" } ); + // GLSL + add( { "GLSL", + { "%.glsl$", "%.frag$", "%.vert$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "#", "[^\\]\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "ivec[2-4]" }, "keyword2" }, + { { "bvec[2-4]" }, "keyword2" }, + { { "uvec[2-4]" }, "keyword2" }, + { { "vec[2-4]" }, "keyword2" }, + { { "dmat[2-4]x[2-4]" }, "keyword2" }, + { { "dmat[2-4]" }, "keyword2" }, + { { "mat[2-4]x[2-4]" }, "keyword2" }, + { { "mat[2-4]" }, "keyword2" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + }, + { + { "if", "keyword" }, + { "else", "keyword" }, + { "do", "keyword" }, + { "while", "keyword" }, + { "for", "keyword" }, + { "break", "keyword" }, + { "continue", "keyword" }, + { "return", "keyword" }, + { "const", "keyword" }, + { "switch", "keyword" }, + { "case", "keyword" }, + { "default", "keyword" }, + { "const", "keyword" }, + { "void", "keyword" }, + { "bool", "keyword2" }, + { "int", "keyword2" }, + { "uint", "keyword2" }, + { "float", "keyword2" }, + { "double", "keyword2" }, + { "true", "literal" }, + { "false", "literal" }, + { "NULL", "literal" }, + { "attribute", "keyword" }, + { "varying", "keyword" }, + { "uniform", "keyword" }, + { "buffer", "keyword" }, + { "shared", "keyword" }, + { "layout", "keyword" }, + { "centroid", "keyword" }, + { "flat", "keyword" }, + { "smooth", "keyword" }, + { "noperspective", "keyword" }, + { "patch", "keyword" }, + { "sample", "keyword" }, + { "in", "keyword" }, + { "out", "keyword" }, + { "inout", "keyword" }, + { "invariant", "keyword" }, + { "precise", "keyword" }, + { "lowp", "keyword" }, + { "mediump", "keyword" }, + { "highp", "keyword" }, + { "precision", "keyword" }, + { "struct", "keyword" }, + { "subroutine", "keyword" }, + { "coherent", "keyword" }, + { "volatile", "keyword" }, + { "readonly", "keyword" }, + { "writeonly", "keyword" }, + { "sampler1D", "keyword2" }, + { "sampler2D", "keyword2" }, + { "sampler3D", "keyword2" }, + { "samplerCube", "keyword2" }, + { "sampler1DShadow", "keyword2" }, + { "sampler2DShadow", "keyword2" }, + { "samplerCubeShadow", "keyword2" }, + { "sampler1DArray", "keyword2" }, + { "sampler2DArray", "keyword2" }, + { "samplerCubeArray", "keyword2" }, + { "sampler1DArrayShadow", "keyword2" }, + { "sampler2DArrayShadow", "keyword2" }, + { "samplerCubeArrayShadow", "keyword2" }, + { "isampler1D", "keyword2" }, + { "isampler2D", "keyword2" }, + { "isampler3D", "keyword2" }, + { "isamplerCube", "keyword2" }, + { "sampler2DMS", "keyword2" }, + { "isampler2DMS", "keyword2" }, + { "usampler2DMS", "keyword2" }, + { "sampler2DMSArray", "keyword2" }, + { "isampler2DMSArray", "keyword2" }, + { "usampler2DMSArray", "keyword2" }, + { "isampler1DArray", "keyword2" }, + { "isampler2DArray", "keyword2" }, + { "usampler1D", "keyword2" }, + { "usampler2D", "keyword2" }, + { "usampler3D", "keyword2" }, + { "usamplerCube", "keyword2" }, + { "usampler1DArray", "keyword2" }, + { "usampler2DArray", "keyword2" }, + { "sampler2DRect", "keyword2" }, + { "sampler2DRectShadow", "keyword2" }, + { "isampler2DRect", "keyword2" }, + { "usampler2DRect", "keyword2" }, + { "samplerBuffer", "keyword2" }, + { "isamplerBuffer", "keyword2" }, + { "usamplerBuffer", "keyword2" }, + { "image1D", "keyword2" }, + { "iimage1D", "keyword2" }, + { "uimage1D", "keyword2" }, + { "image1DArray", "keyword2" }, + { "iimage1DArray", "keyword2" }, + { "uimage1DArray", "keyword2" }, + { "image2D", "keyword2" }, + { "iimage2D", "keyword2" }, + { "uimage2D", "keyword2" }, + { "image2DArray", "keyword2" }, + { "iimage2DArray", "keyword2" }, + { "uimage2DArray", "keyword2" }, + { "image2DRect", "keyword2" }, + { "iimage2DRect", "keyword2" }, + { "uimage2DRect", "keyword2" }, + { "image2DMS", "keyword2" }, + { "iimage2DMS", "keyword2" }, + { "uimage2DMS", "keyword2" }, + { "image2DMSArray", "keyword2" }, + { "iimage2DMSArray", "keyword2" }, + { "uimage2DMSArray", "keyword2" }, + { "image3D", "keyword2" }, + { "iimage3D", "keyword2" }, + { "uimage3D", "keyword2" }, + { "imageCube", "keyword2" }, + { "iimageCube", "keyword2" }, + { "uimageCube", "keyword2" }, + { "imageCubeArray", "keyword2" }, + { "iimageCubeArray", "keyword2" }, + { "uimageCubeArray", "keyword2" }, + { "imageBuffer", "keyword2" }, + { "iimageBuffer", "keyword2" }, + { "uimageBuffer", "keyword2" }, + { "atomic_uint", "keyword2" }, + { "radians", "keyword" }, + { "degrees", "keyword" }, + { "sin", "keyword" }, + { "cos", "keyword" }, + { "tan", "keyword" }, + { "asin", "keyword" }, + { "acos", "keyword" }, + { "atan", "keyword" }, + { "sinh", "keyword" }, + { "cosh", "keyword" }, + { "tanh", "keyword" }, + { "asinh", "keyword" }, + { "acosh", "keyword" }, + { "pow", "keyword" }, + { "exp", "keyword" }, + { "exp2", "keyword" }, + { "log2", "keyword" }, + { "sqrt", "keyword" }, + { "inversesqrt", "keyword" }, + { "abs", "keyword" }, + { "sign", "keyword" }, + { "floor", "keyword" }, + { "trunc", "keyword" }, + { "round", "keyword" }, + { "roundEven", "keyword" }, + { "ceil", "keyword" }, + { "fract", "keyword" }, + { "mod", "keyword" }, + { "modf", "keyword" }, + { "min", "keyword" }, + { "max", "keyword" }, + { "clamp", "keyword" }, + { "mix", "keyword" }, + { "step", "keyword" }, + { "smoothstep", "keyword" }, + { "isnan", "keyword" }, + { "isinf", "keyword" }, + { "floatBitsToInt", "keyword" }, + { "floatBitsToUint", "keyword" }, + { "intBitsToFloat", "keyword" }, + { "uintBitsToFloat", "keyword" }, + { "fma", "keyword" }, + { "frexp", "keyword" }, + { "ldexp", "keyword" }, + { "packUnorm2x16", "keyword" }, + { "packSnorm2x16", "keyword" }, + { "packUnorm4x8", "keyword" }, + { "packSnorm4x8", "keyword" }, + { "unpackUnorm2x16", "keyword" }, + { "unpackSnorm2x16", "keyword" }, + { "unpackUnorm4x8", "keyword" }, + { "unpackSnorm4x8", "keyword" }, + { "packHalf2x16", "keyword" }, + { "unpackHalf2x16", "keyword" }, + { "packDouble2x32", "keyword" }, + { "unpackDouble2x32", "keyword" }, + { "length", "keyword" }, + { "distance", "keyword" }, + { "dot", "keyword" }, + { "cross", "keyword" }, + { "normalize", "keyword" }, + { "ftransform", "keyword" }, + { "faceforward", "keyword" }, + { "reflect", "keyword" }, + { "refract", "keyword" }, + { "matrixCompMult", "keyword" }, + { "outerProduct", "keyword" }, + { "transpose", "keyword" }, + { "determinant", "keyword" }, + { "inverse", "keyword" }, + { "lessThan", "keyword" }, + { "lessThanEqual", "keyword" }, + { "greaterThan", "keyword" }, + { "greaterThanEqual", "keyword" }, + { "equal", "keyword" }, + { "notEqual", "keyword" }, + { "any", "keyword" }, + { "all", "keyword" }, + { "not", "keyword" }, + { "uaddCarry", "keyword" }, + { "usubBorrow", "keyword" }, + { "umulExtended", "keyword" }, + { "imulExtended", "keyword" }, + { "bitfieldExtract", "keyword" }, + { "bitfieldInsert", "keyword" }, + { "bitfieldReverse", "keyword" }, + { "bitCount", "keyword" }, + { "findLSB", "keyword" }, + { "findMSB", "keyword" }, + { "textureSize", "keyword" }, + { "textureQueryLod", "keyword" }, + { "textureQueryLevels", "keyword" }, + { "textureSamples", "keyword" }, + { "texture", "keyword" }, + { "textureProj", "keyword" }, + { "textureLod", "keyword" }, + { "textureOffset", "keyword" }, + { "texelFetch", "keyword" }, + { "texelFetchOffset", "keyword" }, + { "textureProjOffset", "keyword" }, + { "textureLodOffset", "keyword" }, + { "textureProjLod", "keyword" }, + { "textureProjLodOffset", "keyword" }, + { "textureGrad", "keyword" }, + { "textureGradOffset", "keyword" }, + { "textureProjGrad", "keyword" }, + { "textureProjGradOffset", "keyword" }, + { "textureGather", "keyword" }, + { "textureGatherOffset", "keyword" }, + { "textureGatherOffsets", "keyword" }, + { "atomicCounterIncrement", "keyword" }, + { "atomicCounterDecrement", "keyword" }, + { "atomicCounter", "keyword" }, + { "atomicCounterAdd", "keyword" }, + { "atomicCounterSubtract", "keyword" }, + { "atomicCounterMin", "keyword" }, + { "atomicCounterMax", "keyword" }, + { "atomicCounterAnd", "keyword" }, + { "atomicCounterOr", "keyword" }, + { "atomicCounterXor", "keyword" }, + { "atomicCounterExchange", "keyword" }, + { "atomicCounterCompSwap", "keyword" }, + { "atomicAdd", "keyword" }, + { "atomicMin", "keyword" }, + { "atomicMax", "keyword" }, + { "atomicAnd", "keyword" }, + { "atomicOr", "keyword" }, + { "atomicXor", "keyword" }, + { "atomicExchange", "keyword" }, + { "atomicCompSwap", "keyword" }, + { "imageSize", "keyword" }, + { "imageSamples", "keyword" }, + { "imageLoad", "keyword" }, + { "imageStore", "keyword" }, + { "imageAtomicAdd", "keyword" }, + { "imageAtomicMin", "keyword" }, + { "imageAtomicMax", "keyword" }, + { "imageAtomicAnd", "keyword" }, + { "imageAtomicOr", "keyword" }, + { "imageAtomicXor", "keyword" }, + { "imageAtomicExchange", "keyword" }, + { "imageAtomicCompSwap", "keyword" }, + { "EmitStreamVertex", "keyword" }, + { "EndStreamPrimitive", "keyword" }, + { "EmitVertex", "keyword" }, + { "EndPrimitive", "keyword" }, + { "dFdx", "keyword" }, + { "dFdy", "keyword" }, + { "dFdxFine", "keyword" }, + { "dFdyFine", "keyword" }, + { "dFdxCoarse", "keyword" }, + { "dFdyCoarse", "keyword" }, + { "fwidth", "keyword" }, + { "fwidthFine", "keyword" }, + { "fwidthCoarse", "keyword" }, + { "interpolateAtCentroid", "keyword" }, + { "interpolateAtSample", "keyword" }, + { "interpolateAtOffset", "keyword" }, + { "barrier", "keyword" }, + { "memoryBarrier", "keyword" }, + { "memoryBarrierAtomicCounter", "keyword" }, + { "memoryBarrierBuffer", "keyword" }, + { "memoryBarrierShared", "keyword" }, + { "memoryBarrierImage", "keyword" }, + { "groupMemoryBarrier", "keyword" }, + { "subpassLoad", "keyword" }, + { "anyInvocation", "keyword" }, + { "allInvocations", "keyword" }, + { "allInvocationsEqual", "keyword" }, + { "texture1D", "keyword" }, + { "texture1DArray", "keyword" }, + { "itexture1D", "keyword" }, + { "itexture1DArray", "keyword" }, + { "utexture1D", "keyword" }, + { "utexture1DArray", "keyword" }, + { "texture2D", "keyword" }, + { "texture2DArray", "keyword" }, + { "itexture2D", "keyword" }, + { "itexture2DArray", "keyword" }, + { "utexture2D", "keyword" }, + { "utexture2DArray", "keyword" }, + { "texture2DRect", "keyword" }, + { "itexture2DRect", "keyword" }, + { "utexture2DRect", "keyword" }, + { "texture2DMS", "keyword" }, + { "itexture2DMS", "keyword" }, + { "utexture2DMS", "keyword" }, + { "texture2DMSArray", "keyword" }, + { "itexture2DMSArray", "keyword" }, + { "utexture2DMSArray", "keyword" }, + { "texture3D", "keyword" }, + { "itexture3D", "keyword" }, + { "utexture3D", "keyword" }, + { "textureCube", "keyword" }, + { "itextureCube", "keyword" }, + { "utextureCube", "keyword" }, + { "textureCubeArray", "keyword" }, + { "itextureCubeArray", "keyword" }, + { "utextureCubeArray", "keyword" }, + { "textureBuffer", "keyword" }, + { "itextureBuffer", "keyword" }, + { "utextureBuffer", "keyword" }, + { "sampler", "keyword2" }, + { "samplerShadow", "keyword2" }, + { "subpassInput", "keyword2" }, + { "isubpassInput", "keyword2" }, + { "usubpassInput", "keyword2" }, + { "subpassInputMS", "keyword2" }, + { "isubpassInputMS", "keyword2" }, + { "usubpassInputMS", "keyword2" }, + }, + "//" } ); - // Swift - add( { "Swift", - { "%.swift$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"\"\"", "\"\"\"" }, "string" }, - { { "\"", "\"", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*[?!]?" }, "symbol" }, - }, - { - { "#available", "keyword" }, - { "#colorLiteral", "keyword" }, - { "#column", "keyword" }, - { "#else", "keyword" }, - { "#elseif", "keyword" }, - { "#endif", "keyword" }, - { "#file", "keyword" }, - { "#fileLiteral", "keyword" }, - { "#function", "keyword" }, - { "#if", "keyword" }, - { "#imageLiteral", "keyword" }, - { "#line", "keyword" }, - { "#selector", "keyword" }, - { "#sourceLocation", "keyword" }, - { "_", "keyword" }, - { "__COLUMN__", "keyword" }, - { "__FILE__", "keyword" }, - { "__FUNCTION__", "keyword" }, - { "__LINE__", "keyword" }, - { "Any", "keyword" }, - { "as", "keyword" }, - { "as!", "keyword" }, - { "as?", "keyword" }, - { "associatedtype", "keyword" }, - { "associativity", "keyword" }, - { "break", "keyword" }, - { "case", "keyword" }, - { "catch", "keyword" }, - { "class", "keyword" }, - { "continue", "keyword" }, - { "convenience", "keyword" }, - { "default", "keyword" }, - { "defer", "keyword" }, - { "deinit", "keyword" }, - { "didSet", "keyword" }, - { "do", "keyword" }, - { "dynamic", "keyword" }, - { "dynamicType", "keyword" }, - { "else", "keyword" }, - { "enum", "keyword" }, - { "extension", "keyword" }, - { "fallthrough", "keyword" }, - { "false", "keyword" }, - { "fileprivate", "keyword" }, - { "final", "keyword" }, - { "for", "keyword" }, - { "func", "keyword" }, - { "get", "keyword" }, - { "guard", "keyword" }, - { "if", "keyword" }, - { "import", "keyword" }, - { "in", "keyword" }, - { "indirect", "keyword" }, - { "infix", "keyword" }, - { "init", "keyword" }, - { "inout", "keyword" }, - { "internal", "keyword" }, - { "is", "keyword" }, - { "lazy", "keyword" }, - { "left", "keyword" }, - { "let", "keyword" }, - { "mutating", "keyword" }, - { "nil", "keyword" }, - { "none", "keyword" }, - { "nonmutating", "keyword" }, - { "open", "keyword" }, - { "operator", "keyword" }, - { "optional", "keyword" }, - { "override", "keyword" }, - { "postfix", "keyword" }, - { "precedence", "keyword" }, - { "prefix", "keyword" }, - { "private", "keyword" }, - { "protocol", "keyword" }, - { "Protocol", "keyword" }, - { "public", "keyword" }, - { "repeat", "keyword" }, - { "required", "keyword" }, - { "rethrows", "keyword" }, - { "return", "keyword" }, - { "right", "keyword" }, - { "self", "keyword" }, - { "Self", "keyword" }, - { "set", "keyword" }, - { "static", "keyword" }, - { "struct", "keyword" }, - { "subscript", "keyword" }, - { "super", "keyword" }, - { "switch", "keyword" }, - { "throw", "keyword" }, - { "throws", "keyword" }, - { "true", "keyword" }, - { "try", "keyword" }, - { "try!", "keyword" }, - { "try?", "keyword" }, - { "Type", "keyword" }, - { "typealias", "keyword" }, - { "unowned", "keyword" }, - { "var", "keyword" }, - { "weak", "keyword" }, - { "where", "keyword" }, - { "while", "keyword" }, - { "willSet", "keyword" }, - { "true", "literal" }, - { "false", "literal" }, - { "nil", "literal" }, - { "abs", "keyword2" }, - { "advance", "keyword2" }, - { "alignof", "keyword2" }, - { "alignofValue", "keyword2" }, - { "anyGenerator", "keyword2" }, - { "assert", "keyword2" }, - { "assertionFailure", "keyword2" }, - { "bridgeFromObjectiveC", "keyword2" }, - { "bridgeFromObjectiveCUnconditional", "keyword2" }, - { "bridgeToObjectiveC", "keyword2" }, - { "bridgeToObjectiveCUnconditional", "keyword2" }, - { "c", "keyword2" }, - { "compactMap", "keyword2" }, - { "contains", "keyword2" }, - { "count", "keyword2" }, - { "countElements", "keyword2" }, - { "countLeadingZeros", "keyword2" }, - { "debugPrint", "keyword2" }, - { "debugPrintln", "keyword2" }, - { "distance", "keyword2" }, - { "dropFirst", "keyword2" }, - { "dropLast", "keyword2" }, - { "dump", "keyword2" }, - { "encodeBitsAsWords", "keyword2" }, - { "enumerate", "keyword2" }, - { "equal", "keyword2" }, - { "fatalError", "keyword2" }, - { "filter", "keyword2" }, - { "find", "keyword2" }, - { "getBridgedObjectiveCType", "keyword2" }, - { "getVaList", "keyword2" }, - { "indices", "keyword2" }, - { "insertionSort", "keyword2" }, - { "isBridgedToObjectiveC", "keyword2" }, - { "isBridgedVerbatimToObjectiveC", "keyword2" }, - { "isUniquelyReferenced", "keyword2" }, - { "isUniquelyReferencedNonObjC", "keyword2" }, - { "join", "keyword2" }, - { "lazy", "keyword2" }, - { "lexicographicalCompare", "keyword2" }, - { "map", "keyword2" }, - { "max", "keyword2" }, - { "maxElement", "keyword2" }, - { "min", "keyword2" }, - { "minElement", "keyword2" }, - { "numericCast", "keyword2" }, - { "overlaps", "keyword2" }, - { "partition", "keyword2" }, - { "posix", "keyword2" }, - { "precondition", "keyword2" }, - { "preconditionFailure", "keyword2" }, - { "print", "keyword2" }, - { "println", "keyword2" }, - { "quickSort", "keyword2" }, - { "readLine", "keyword2" }, - { "reduce", "keyword2" }, - { "reflect", "keyword2" }, - { "reinterpretCast", "keyword2" }, - { "reverse", "keyword2" }, - { "roundUpToAlignment", "keyword2" }, - { "sizeof", "keyword2" }, - { "sizeofValue", "keyword2" }, - { "sort", "keyword2" }, - { "split", "keyword2" }, - { "startsWith", "keyword2" }, - { "stride", "keyword2" }, - { "strideof", "keyword2" }, - { "strideofValue", "keyword2" }, - { "swap", "keyword2" }, - { "toString", "keyword2" }, - { "transcode", "keyword2" }, - { "underestimateCount", "keyword2" }, - { "unsafeAddressOf", "keyword2" }, - { "unsafeBitCast", "keyword2" }, - { "unsafeDowncast", "keyword2" }, - { "unsafeUnwrap", "keyword2" }, - { "unsafeReflect", "keyword2" }, - { "withExtendedLifetime", "keyword2" }, - { "withObjectAtPlusZero", "keyword2" }, - { "withUnsafePointer", "keyword2" }, - { "withUnsafePointerToObject", "keyword2" }, - { "withUnsafeMutablePointer", "keyword2" }, - { "withUnsafeMutablePointers", "keyword2" }, - { "withUnsafePointer", "keyword2" }, - { "withUnsafePointers", "keyword2" }, - { "withVaList", "keyword2" }, - { "zip", "keyword2" }, - { "Int", "keyword2" }, - { "Float", "keyword2" }, - { "Double", "keyword2" }, - { "String", "keyword2" }, - { "Void", "keyword2" }, - { "Bool", "keyword2" }, - { "Array", "keyword2" }, - { "Optional", "keyword2" }, - }, - "//" } ); + // ini / conf + add( { "Config File", + { "%.ini$", "%.conf$", "%.desktop$", "%.service$", "%.cfg$", "%.env$", "Doxyfile" }, + { { { "^#.-\n" }, "comment" }, + { { "%s#.-\n" }, "comment" }, + { { "%s?#%x+" }, "string" }, + { { "[%a_][%w-+_%s%p]-%f[=]" }, "keyword" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "^%[.-%]" }, "keyword2" }, + { { "%s%[.-%]" }, "keyword2" }, + { { "=" }, "operator" }, + { { "https?://(([%w_.~!*:@&+$/?%%#-]-)(%w[-.%w]*%.)(%w%w%w?%w?)(:?)(%d*)(/" + "?)([%w_.~!*:@&+$/?%%#=-]*))" }, + "link" }, + { { "[a-z]+" }, "symbol" } }, + { { "true", "literal" }, { "false", "literal" } }, + "#", + { "^%[.-%]" } } ); - add( { "Solidity", - { "%.sol$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"\"\"", "\"\"\"" }, "string" }, - { { "\"", "\"", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { { "if", "keyword" }, { "else", "keyword" }, - { "for", "keyword" }, { "while", "keyword" }, - { "do", "keyword" }, { "break", "keyword" }, - { "continue", "keyword" }, { "throw", "keyword" }, - { "returns", "keyword" }, { "return", "keyword" }, - { "function", "keyword" }, { "private", "keyword2" }, - { "public", "keyword2" }, { "internal", "keyword2" }, - { "external", "keyword2" }, { "constant", "keyword2" }, - { "immutable", "keyword2" }, { "pure", "keyword2" }, - { "view", "keyword2" }, { "payable", "keyword2" }, - { "nonpayable", "keyword2" }, { "inherited", "keyword2" }, - { "indexed", "keyword2" }, { "storage", "keyword2" }, - { "memory", "keyword2" }, { "virtual", "keyword2" }, - { "calldata", "keyword2" }, { "override", "keyword2" }, - { "abstract", "keyword" }, { "library", "keyword" }, - { "enum", "keyword" }, { "constructor", "keyword" }, - { "event", "keyword" }, { "modifier", "keyword" }, - { "assembly", "keyword" }, { "let", "keyword" }, - { "msg", "keyword2" }, { "block", "keyword2" }, - { "tx", "keyword2" }, { "now", "keyword2" }, - { "this", "keyword2" }, { "super", "keyword2" }, - { "require", "keyword" }, { "assert", "keyword2" }, - { "revert", "keyword2" }, { "selfdestruct", "keyword2" }, - { "suicide", "keyword2" }, { "addmod", "keyword2" }, - { "mulmod", "keyword2" }, { "keccak256", "keyword2" }, - { "sha256", "keyword2" }, { "sha3", "keyword2" }, - { "ripemd160", "keyword2" }, { "ecrecover", "keyword2" }, - { "blockhash", "keyword2" }, { "gasleft", "keyword2" }, - { "contract", "keyword" }, { "interface", "keyword" }, - { "modifier", "keyword" }, { "mapping", "keyword2" }, - { "address", "keyword2" }, { "string", "keyword2" }, - { "byte", "keyword2" }, { "bytes", "keyword2" }, - { "bytes1", "keyword2" }, { "bytes2", "keyword2" }, - { "bytes3", "keyword2" }, { "bytes4", "keyword2" }, - { "bytes5", "keyword2" }, { "bytes6", "keyword2" }, - { "bytes7", "keyword2" }, { "bytes8", "keyword2" }, - { "bytes9", "keyword2" }, { "bytes10", "keyword2" }, - { "bytes11", "keyword2" }, { "bytes12", "keyword2" }, - { "bytes13", "keyword2" }, { "bytes14", "keyword2" }, - { "bytes15", "keyword2" }, { "bytes16", "keyword2" }, - { "bytes17", "keyword2" }, { "bytes18", "keyword2" }, - { "bytes19", "keyword2" }, { "bytes20", "keyword2" }, - { "bytes21", "keyword2" }, { "bytes22", "keyword2" }, - { "bytes23", "keyword2" }, { "bytes24", "keyword2" }, - { "bytes25", "keyword2" }, { "bytes26", "keyword2" }, - { "bytes27", "keyword2" }, { "bytes28", "keyword2" }, - { "bytes29", "keyword2" }, { "bytes30", "keyword2" }, - { "bytes31", "keyword2" }, { "bytes32", "keyword2" }, - { "int", "keyword2" }, { "int8", "keyword2" }, - { "int16", "keyword2" }, { "int32", "keyword2" }, - { "int64", "keyword2" }, { "int128", "keyword2" }, - { "int256", "keyword2" }, { "uint", "keyword2" }, - { "uint8", "keyword2" }, { "uint16", "keyword2" }, - { "uint32", "keyword2" }, { "uint64", "keyword2" }, - { "uint128", "keyword2" }, { "uint256", "keyword2" }, - { "bool", "keyword2" }, { "hash", "keyword2" }, - { "pragma", "keyword2" }, { "using", "keyword" }, - { "is", "keyword" }, { "new", "keyword" }, - { "delete", "keyword" }, { "emit", "keyword" }, - { "struct", "keyword" }, { "protected", "keyword" } } } ); + // Makefile + add( { "Makefile", + { "Makefile", "makefile", "%.mk$", "%.make$" }, + { + { { "#.*\n" }, "comment" }, + { { "[[.]]}" }, "normal" }, + { { "$[@^<%%?+|*]" }, "keyword2" }, + { { "$%(", "%)" }, "keyword" }, + { { "%f[%w_][%d%.]+%f[^%w_]" }, "number" }, + { { "%..*:" }, "keyword2" }, + { { ".*:=" }, "function" }, + { { ".*+=" }, "function" }, + { { ".*%s=" }, "function" }, + }, + {}, + "#" } ); - // Objective-C - add( { "Objective-C", - { "%.m$" }, - { { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "#", "[^\\]\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "@[%a_][%w_]*" }, "keyword2" }, - { { "[%a_][%w_]*" }, "symbol" } }, - { { "if", "keyword" }, { "then", "keyword" }, { "else", "keyword" }, - { "elseif", "keyword" }, { "do", "keyword" }, { "while", "keyword" }, - { "for", "keyword" }, { "break", "keyword" }, { "continue", "keyword" }, - { "return", "keyword" }, { "goto", "keyword" }, { "struct", "keyword" }, - { "union", "keyword" }, { "typedef", "keyword" }, { "enum", "keyword" }, - { "extern", "keyword" }, { "static", "keyword" }, { "volatile", "keyword" }, - { "const", "keyword" }, { "inline", "keyword" }, { "switch", "keyword" }, - { "case", "keyword" }, { "default", "keyword" }, { "auto", "keyword" }, - { "const", "keyword" }, { "void", "keyword" }, { "int", "keyword2" }, - { "short", "keyword2" }, { "long", "keyword2" }, { "float", "keyword2" }, - { "double", "keyword2" }, { "char", "keyword2" }, { "unsigned", "keyword2" }, - { "bool", "keyword2" }, { "true", "literal" }, { "false", "literal" }, - { "NULL", "literal" }, { "nil", "literal" } }, - "//" } ); + // C# + add( + { "C#", + { "%.cs$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "[%$%@]?\"", "\"", "\\" }, "string" }, + { { "'\\x%x?%x?%x?%x'" }, "string" }, + { { "'\\u%x%x%x%x'" }, "string" }, + { { "'\\?.'" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "%?%?" }, "operator" }, + { { "%?%." }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + }, + { { "abstract", "keyword" }, { "as", "keyword" }, { "await", "keyword" }, + { "base", "keyword" }, { "break", "keyword" }, { "case", "keyword" }, + { "catch", "keyword" }, { "checked", "keyword" }, { "class", "keyword" }, + { "const", "keyword" }, { "continue", "keyword" }, { "default", "keyword" }, + { "delegate", "keyword" }, { "do", "keyword" }, { "else", "keyword" }, + { "enum", "keyword" }, { "event", "keyword" }, { "explicit", "keyword" }, + { "extern", "keyword" }, { "finally", "keyword" }, { "fixed", "keyword" }, + { "for", "keyword" }, { "foreach", "keyword" }, { "get", "keyword" }, + { "goto", "keyword" }, { "if", "keyword" }, { "implicit", "keyword" }, + { "in", "keyword" }, { "interface", "keyword" }, { "internal", "keyword" }, + { "is", "keyword" }, { "lock", "keyword" }, { "namespace", "keyword" }, + { "new", "keyword" }, { "operator", "keyword" }, { "out", "keyword" }, + { "override", "keyword" }, { "params", "keyword" }, { "private", "keyword" }, + { "protected", "keyword" }, { "public", "keyword" }, { "readonly", "keyword" }, + { "ref", "keyword" }, { "return", "keyword" }, { "sealed", "keyword" }, + { "set", "keyword" }, { "sizeof", "keyword" }, { "stackalloc", "keyword" }, + { "static", "keyword" }, { "struct", "keyword" }, { "switch", "keyword" }, + { "this", "keyword" }, { "throw", "keyword" }, { "try", "keyword" }, + { "typeof", "keyword" }, { "unchecked", "keyword" }, { "unsafe", "keyword" }, + { "using", "keyword" }, { "var", "keyword" }, { "virtual", "keyword" }, + { "void", "keyword" }, { "volatile", "keyword" }, { "where", "keyword" }, + { "while", "keyword" }, { "yield", "keyword" }, { "bool", "keyword2" }, + { "byte", "keyword2" }, { "char", "keyword2" }, { "decimal", "keyword2" }, + { "double", "keyword2" }, { "float", "keyword2" }, { "int", "keyword2" }, + { "long", "keyword2" }, { "object", "keyword2" }, { "sbyte", "keyword2" }, + { "short", "keyword2" }, { "string", "keyword2" }, { "uint", "keyword2" }, + { "ulong", "keyword2" }, { "ushort", "keyword2" }, { "true", "literal" }, + { "false", "literal" }, { "null", "literal" }, { "add", "keyword" }, + { "record", "keyword" }, { "remove", "keyword" }, { "partial", "keyword" }, + { "dynamic", "keyword" }, { "value", "keyword" }, { "global", "keyword" }, + { "when", "keyword" } }, + "//" } ); - // Dart - add( { "Dart", - { "%.dart$" }, - { - { { "//.-\n" }, "comment" }, - { { "///.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?0x%x+" }, "number" }, - { { "-?%d+[%d%.eE]*f?" }, "number" }, - { { "-?%.?%d+f?" }, "number" }, - { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, - { { "%?%?" }, "operator" }, - { { "%?%." }, "operator" }, - { { "[%$%@]?\"", "\"", "\\" }, "string" }, - { { "'\\x%x?%x?%x?%x'" }, "string" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { { "await", "keyword" }, { "bool", "keyword2" }, { "break", "keyword" }, - { "case", "keyword" }, { "class", "keyword" }, { "const", "keyword" }, - { "continue", "keyword" }, { "default", "keyword" }, { "do", "keyword" }, - { "double", "keyword2" }, { "dynamic", "keyword2" }, { "else", "keyword" }, - { "enum", "keyword" }, { "false", "literal" }, { "final", "keyword" }, - { "finally", "keyword" }, { "for", "keyword" }, { "Function", "keyword2" }, - { "if", "keyword" }, { "in", "keyword" }, { "int", "keyword2" }, - { "List", "keyword2" }, { "Map", "keyword2" }, { "new", "keyword" }, - { "null", "literal" }, { "part of", "keyword" }, { "print", "keyword" }, - { "return", "keyword" }, { "static", "keyword" }, { "String", "keyword2" }, - { "switch", "keyword" }, { "then", "keyword" }, { "this", "keyword2" }, - { "true", "literal" }, { "void", "keyword" }, { "while", "keyword" } }, - "//" } ); + // Go + add( { "Go", + { "%.go$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "`", "`", "\\" }, "string" }, + { { "0[oO_][0-7]+" }, "number" }, + { { "-?0x[%x_]+" }, "number" }, + { { "-?%d+_%d" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { ":=" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + }, + { + { "if", "keyword" }, { "else", "keyword" }, + { "elseif", "keyword" }, { "for", "keyword" }, + { "continue", "keyword" }, { "return", "keyword" }, + { "struct", "keyword" }, { "switch", "keyword" }, + { "case", "keyword" }, { "default", "keyword" }, + { "const", "keyword" }, { "package", "keyword" }, + { "import", "keyword" }, { "func", "keyword" }, + { "var", "keyword" }, { "type", "keyword" }, + { "interface", "keyword" }, { "select", "keyword" }, + { "break", "keyword" }, { "range", "keyword" }, + { "chan", "keyword" }, { "defer", "keyword" }, + { "go", "keyword" }, { "fallthrough", "keyword" }, + { "int", "keyword2" }, { "int64", "keyword2" }, + { "int32", "keyword2" }, { "int16", "keyword2" }, + { "int8", "keyword2" }, { "uint", "keyword2" }, + { "uint64", "keyword2" }, { "uint32", "keyword2" }, + { "uint16", "keyword2" }, { "uint8", "keyword2" }, + { "uintptr", "keyword2" }, { "float64", "keyword2" }, + { "float32", "keyword2" }, { "map", "keyword2" }, + { "string", "keyword2" }, { "rune", "keyword2" }, + { "bool", "keyword2" }, { "byte", "keyword2" }, + { "error", "keyword2" }, { "complex64", "keyword2" }, + { "complex128", "keyword2" }, { "true", "literal" }, + { "false", "literal" }, { "nil", "literal" }, + }, + "//" } ); - // Add Kotlin - 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" } }, - "//" } ); + // Rust + add( { "Rust", + { "%.rs$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "`", "`", "\\" }, "string" }, + { { "0[oO_][0-7]+" }, "number" }, + { { "-?0x[%x_]+" }, "number" }, + { { "-?%d+_%d" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + }, + { + { "as", "keyword" }, { "async", "keyword" }, { "await", "keyword" }, + { "break", "keyword" }, { "const", "keyword" }, { "continue", "keyword" }, + { "crate", "keyword" }, { "dyn", "keyword" }, { "else", "keyword" }, + { "enum", "keyword" }, { "extern", "keyword" }, { "false", "keyword" }, + { "fn", "keyword" }, { "for", "keyword" }, { "if", "keyword" }, + { "impl", "keyword" }, { "in", "keyword" }, { "let", "keyword" }, + { "loop", "keyword" }, { "match", "keyword" }, { "mod", "keyword" }, + { "move", "keyword" }, { "mut", "keyword" }, { "pub", "keyword" }, + { "ref", "keyword" }, { "return", "keyword" }, { "Self", "keyword" }, + { "self", "keyword" }, { "static", "keyword" }, { "struct", "keyword" }, + { "super", "keyword" }, { "trait", "keyword" }, { "true", "keyword" }, + { "type", "keyword" }, { "unsafe", "keyword" }, { "use", "keyword" }, + { "where", "keyword" }, { "while", "keyword" }, { "i32", "keyword2" }, + { "i64", "keyword2" }, { "i128", "keyword2" }, { "i16", "keyword2" }, + { "i8", "keyword2" }, { "u8", "keyword2" }, { "u16", "keyword2" }, + { "u32", "keyword2" }, { "u64", "keyword2" }, { "usize", "keyword2" }, + { "isize", "keyword2" }, { "f32", "keyword2" }, { "f64", "keyword2" }, + { "f128", "keyword2" }, { "String", "keyword2" }, { "char", "keyword2" }, + { "&str", "keyword2" }, { "bool", "keyword2" }, { "true", "literal" }, + { "false", "literal" }, { "None", "literal" }, { "Some", "literal" }, + { "Option", "literal" }, { "Result", "literal" }, + }, + "//" } ); + + // GDScript + 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" }, + }, + "#" } ); + + // D + add( { "D", + { "%.d$", "%.di$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "/%+", "%+/" }, "comment" }, + { { "`", "`", "\\" }, "string" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&%$]+" }, "operator" }, + { { "[%a_][%w_]*!" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + { { "@safe" }, "keyword" }, + { { "@trusted" }, "keyword" }, + { { "@nogc" }, "keyword" }, + }, + { + { "abstract", "keyword" }, + { "alias", "keyword" }, + { "align", "keyword" }, + { "asm", "keyword" }, + { "assert", "keyword" }, + { "auto", "keyword" }, + { "body", "keyword" }, + { "bool", "keyword2" }, + { "break", "keyword" }, + { "byte", "keyword2" }, + { "case", "keyword" }, + { "cast", "keyword" }, + { "catch", "keyword" }, + { "cdouble", "keyword2" }, + { "cent", "keyword2" }, + { "cfloat", "keyword2" }, + { "char", "keyword2" }, + { "class", "keyword" }, + { "const", "keyword" }, + { "continue", "keyword" }, + { "creal", "keyword2" }, + { "dchar", "keyword2" }, + { "debug", "keyword" }, + { "default", "keyword" }, + { "delegate", "keyword" }, + { "deprecated", "keyword" }, + { "do", "keyword" }, + { "double", "keyword2" }, + { "else", "keyword" }, + { "enum", "keyword" }, + { "export", "keyword" }, + { "extern", "keyword" }, + { "false", "literal" }, + { "final", "keyword" }, + { "finally", "keyword" }, + { "float", "keyword2" }, + { "for", "keyword" }, + { "foreach", "keyword" }, + { "foreach_reverse", "keyword" }, + { "function", "keyword" }, + { "goto", "keyword" }, + { "idouble", "keyword2" }, + { "if", "keyword" }, + { "ifloat", "keyword2" }, + { "immutable", "keyword" }, + { "import", "keyword" }, + { "in", "keyword" }, + { "inout", "keyword" }, + { "int", "keyword2" }, + { "interface", "keyword" }, + { "invariant", "keyword" }, + { "ireal", "keyword2" }, + { "is", "keyword" }, + { "lazy", "keyword" }, + { "long", "keyword2" }, + { "macro", "keyword" }, + { "mixin", "keyword" }, + { "module", "keyword" }, + { "new", "keyword" }, + { "nothrow", "keyword" }, + { "null", "literal" }, + { "out", "keyword" }, + { "override", "keyword" }, + { "package", "keyword" }, + { "pragma", "keyword" }, + { "private", "keyword" }, + { "protected", "keyword" }, + { "public", "keyword" }, + { "pure", "keyword" }, + { "real", "keyword2" }, + { "ref", "keyword" }, + { "return", "keyword" }, + { "scope", "keyword" }, + { "shared", "keyword" }, + { "short", "keyword2" }, + { "static", "keyword" }, + { "struct", "keyword" }, + { "super", "keyword" }, + { "switch", "keyword" }, + { "synchronized", "keyword" }, + { "template", "keyword" }, + { "this", "keyword" }, + { "throw", "keyword" }, + { "true", "literal" }, + { "try", "keyword" }, + { "typeid", "keyword" }, + { "typeof", "keyword" }, + { "ubyte", "keyword2" }, + { "ucent", "keyword2" }, + { "uint", "keyword2" }, + { "ulong", "keyword2" }, + { "union", "keyword" }, + { "unittest", "keyword" }, + { "ushort", "keyword2" }, + { "version", "keyword" }, + { "void", "keyword" }, + { "wchar", "keyword2" }, + { "while", "keyword" }, + { "with", "keyword" }, + { "__FILE__", "keyword" }, + { "__FILE_FULL_PATH__", "keyword" }, + { "__MODULE__", "keyword" }, + { "__LINE__", "keyword" }, + { "__FUNCTION__", "keyword" }, + { "__PRETTY_FUNCTION__", "keyword" }, + { "__gshared", "keyword" }, + { "__traits", "keyword" }, + { "__vector", "keyword" }, + { "__parameters", "keyword" }, + }, + "//" } ); + + // Haskell + add( { "Haskell", + { "%.hs$" }, + { + { { "%-%-", "\n" }, "comment" }, + { { "{%-", "%-}" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[!%#%$%%&*+./%<=>%?@\\%^|%-~:]" }, "operator" }, + { { "[%a_'][%w_']*" }, "symbol" }, + }, + { + { "as", "keyword" }, { "case", "keyword" }, { "of", "keyword" }, + { "class", "keyword" }, { "data", "keyword" }, { "default", "keyword" }, + { "deriving", "keyword" }, { "do", "keyword" }, { "forall", "keyword" }, + { "foreign", "keyword" }, { "hiding", "keyword" }, { "if", "keyword" }, + { "then", "keyword" }, { "else", "keyword" }, { "import", "keyword" }, + { "infix", "keyword" }, { "infixl", "keyword" }, { "infixr", "keyword" }, + { "let", "keyword" }, { "in", "keyword" }, { "mdo", "keyword" }, + { "module", "keyword" }, { "newtype", "keyword" }, { "qualified", "keyword" }, + { "type", "keyword" }, { "where", "keyword" }, + }, + "%-%-" } ); + + // HLSL + 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" }, + }, + "//" } ); + + // LaTeX + add( { "LaTeX", + { "%.tex$" }, + { + { { "%%", "\n" }, "comment" }, + { { "&" }, "operator" }, + { { "\\\\" }, "operator" }, + { { "%$", "%$" }, "operator" }, + { { "\\%[", "\\]" }, "operator" }, + { { "{", "}" }, "keyword" }, + { { "\\%w*" }, "keyword2" }, + }, + {}, + "%%" } ); + + // Meson + add( { "Meson", + { "meson.build$" }, + { + { { "#", "\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "'''", "'''" }, "string" }, + { { "0x[%da-fA-F]+" }, "number" }, + { { "-?%d+%d*" }, "number" }, + { { "[%+%-=/%%%*!]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + }, + { + { "if", "keyword" }, + { "then", "keyword" }, + { "else", "keyword" }, + { "elif", "keyword" }, + { "endif", "keyword" }, + { "foreach", "keyword" }, + { "endforeach", "keyword" }, + { "break", "keyword" }, + { "continue", "keyword" }, + { "and", "keyword" }, + { "not", "keyword" }, + { "or", "keyword" }, + { "in", "keyword" }, + { "true", "literal" }, + { "false", "literal" }, + }, + "#" } ); + + // AngelScript + add( + { "AlgelScript", + { "%.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" }, + }, + "//" } ); + + // Batch script + std::unordered_map> batchSymTable = { + { "keyword", + { + "if", "else", "elsif", "not", "for", "do", + "in", "equ", "neq", "lss", "leq", "gtr", + "geq", "nul", "con", "prn", "prn", "lpt1", + "com1", "com2", "com3", "com4", "exist", "defined", + "errorlevel", "cmdextversion", "goto", "call", "verify", + } }, + { "function", + { + "set", "setlocal", "endlocal", "enabledelayedexpansion", + "echo", "type", "cd", "chdir", + "md", "mkdir", "pause", "choice", + "exit", "del", "rd", "rmdir", + "copy", "xcopy", "move", "ren", + "find", "findstr", "sort", "shift", + "attrib", "cmd", "command", "forfiles", + } } }; + + auto prepareBatchSymbols = + []( std::unordered_map> table ) + -> std::unordered_map { + std::unordered_map symbols; + for ( auto& el : table ) { + for ( const auto& it : el.second ) { + symbols[String::toLower( it )] = el.first; + symbols[String::toUpper( it )] = el.first; + } + } + return symbols; + }; + + add( { "Batch script", + { "%.bat$", "%.cmd$" }, + { + { { "@echo off\n" }, "keyword" }, + { { "@echo on\n" }, "keyword" }, + { { "rem.-\n" }, "comment" }, + { { "REM.-\n" }, "comment" }, + { { "%s*:[%w%-]+" }, "symbol" }, + { { "%:%:.-\n" }, "comment" }, + { { "%%%w+%%" }, "symbol" }, + { { "%%%%?~?[%w:]+" }, "symbol" }, + { { "[!=()%>&%^/\\@]" }, "operator" }, + { { "-?%.?%d+f?" }, "number" }, + { { "\"", "\"", "\\" }, "string" }, + { { "[%a_][%w_]*" }, "normal" }, + { { ":eof" }, "keyword" }, + }, + prepareBatchSymbols( batchSymTable ), + "rem" } ); + + // diff - patch + add( { "Diff File", + { "%.diff$", "%.patch$" }, + { + { { "^%+%+%+%s.-\n" }, "keyword" }, + { { "^%-%-%-%s.-\n" }, "keyword" }, + { { "^diff%s.-\n" }, "string" }, + { { "^index%s.-\n" }, "comment" }, + { { "^@@.-\n" }, "number" }, + { { "^%+.-\n" }, "function" }, + { { "^%-.-\n" }, "keyword2" }, + } } ); + + // Add Java + add( { "Java", + { "%.java$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "'\\x%x?%x?%x?%x'" }, "string" }, + { { "'\\u%x%x%x%x'" }, "string" }, + { { "'\\?.'" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + }, + { + { "if", "keyword" }, { "then", "keyword" }, + { "else", "keyword" }, { "elseif", "keyword" }, + { "do", "keyword" }, { "while", "keyword" }, + { "for", "keyword" }, { "new", "keyword" }, + { "break", "keyword" }, { "continue", "keyword" }, + { "return", "keyword" }, { "goto", "keyword" }, + { "class", "keyword" }, { "implements", "keyword" }, + { "extends", "keyword" }, { "private", "keyword" }, + { "protected", "keyword" }, { "public", "keyword" }, + { "abstract", "keyword" }, { "interface", "keyword" }, + { "assert", "keyword" }, { "import", "keyword" }, + { "native", "keyword" }, { "package", "keyword" }, + { "super", "keyword" }, { "synchronized", "keyword" }, + { "instanceof", "keyword" }, { "enum", "keyword" }, + { "catch", "keyword" }, { "throw", "keyword" }, + { "throws", "keyword" }, { "try", "keyword" }, + { "transient", "keyword" }, { "finally", "keyword" }, + { "static", "keyword" }, { "volatile", "keyword" }, + { "final", "keyword" }, { "switch", "keyword" }, + { "case", "keyword" }, { "default", "keyword" }, + { "void", "keyword" }, { "int", "keyword2" }, + { "short", "keyword2" }, { "byte", "keyword2" }, + { "long", "keyword2" }, { "float", "keyword2" }, + { "double", "keyword2" }, { "char", "keyword2" }, + { "boolean", "keyword2" }, { "true", "literal" }, + { "false", "literal" }, { "null", "literal" }, + }, + "//" } ); + + // YAML + add( { "YAML", + { "%.yml$", "%.yaml$" }, + { + { { "^#.-\n" }, "comment" }, + { { "%s#.-\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "!!str", "\n", "\\" }, "string" }, + { { "%s-%-%s+.*\n" }, "keyword2" }, + { { "%s+[%w%s-_]+:%s+" }, "keyword" }, + { { "^[%w%s-_]+:%s+" }, "keyword" }, + { { "%f[%S]%-?0x%x+" }, "number" }, + { { "%f[%S]%-?%d+[%d%.eE]*f?" }, "number" }, + { { "%f[%S]%-?%.?%d+f?" }, "number" }, + { { "!!float", "\n", "\\" }, "number" }, + { { "https?://(([%w_.~!*:@&+$/?%%#-]-)(%w[-.%w]*%.)(%w%w%w?%w?)(:?)(%d*)(/" + "?)([%w_.~!*:@&+$/?%%#=-]*))" }, + "link" }, + { { "%-%-%-" }, "literal" }, + }, + {}, + "#" } ); + + // Swift + add( { "Swift", + { "%.swift$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"\"\"", "\"\"\"" }, "string" }, + { { "\"", "\"", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*[?!]?" }, "symbol" }, + }, + { + { "#available", "keyword" }, + { "#colorLiteral", "keyword" }, + { "#column", "keyword" }, + { "#else", "keyword" }, + { "#elseif", "keyword" }, + { "#endif", "keyword" }, + { "#file", "keyword" }, + { "#fileLiteral", "keyword" }, + { "#function", "keyword" }, + { "#if", "keyword" }, + { "#imageLiteral", "keyword" }, + { "#line", "keyword" }, + { "#selector", "keyword" }, + { "#sourceLocation", "keyword" }, + { "_", "keyword" }, + { "__COLUMN__", "keyword" }, + { "__FILE__", "keyword" }, + { "__FUNCTION__", "keyword" }, + { "__LINE__", "keyword" }, + { "Any", "keyword" }, + { "as", "keyword" }, + { "as!", "keyword" }, + { "as?", "keyword" }, + { "associatedtype", "keyword" }, + { "associativity", "keyword" }, + { "break", "keyword" }, + { "case", "keyword" }, + { "catch", "keyword" }, + { "class", "keyword" }, + { "continue", "keyword" }, + { "convenience", "keyword" }, + { "default", "keyword" }, + { "defer", "keyword" }, + { "deinit", "keyword" }, + { "didSet", "keyword" }, + { "do", "keyword" }, + { "dynamic", "keyword" }, + { "dynamicType", "keyword" }, + { "else", "keyword" }, + { "enum", "keyword" }, + { "extension", "keyword" }, + { "fallthrough", "keyword" }, + { "false", "keyword" }, + { "fileprivate", "keyword" }, + { "final", "keyword" }, + { "for", "keyword" }, + { "func", "keyword" }, + { "get", "keyword" }, + { "guard", "keyword" }, + { "if", "keyword" }, + { "import", "keyword" }, + { "in", "keyword" }, + { "indirect", "keyword" }, + { "infix", "keyword" }, + { "init", "keyword" }, + { "inout", "keyword" }, + { "internal", "keyword" }, + { "is", "keyword" }, + { "lazy", "keyword" }, + { "left", "keyword" }, + { "let", "keyword" }, + { "mutating", "keyword" }, + { "nil", "keyword" }, + { "none", "keyword" }, + { "nonmutating", "keyword" }, + { "open", "keyword" }, + { "operator", "keyword" }, + { "optional", "keyword" }, + { "override", "keyword" }, + { "postfix", "keyword" }, + { "precedence", "keyword" }, + { "prefix", "keyword" }, + { "private", "keyword" }, + { "protocol", "keyword" }, + { "Protocol", "keyword" }, + { "public", "keyword" }, + { "repeat", "keyword" }, + { "required", "keyword" }, + { "rethrows", "keyword" }, + { "return", "keyword" }, + { "right", "keyword" }, + { "self", "keyword" }, + { "Self", "keyword" }, + { "set", "keyword" }, + { "static", "keyword" }, + { "struct", "keyword" }, + { "subscript", "keyword" }, + { "super", "keyword" }, + { "switch", "keyword" }, + { "throw", "keyword" }, + { "throws", "keyword" }, + { "true", "keyword" }, + { "try", "keyword" }, + { "try!", "keyword" }, + { "try?", "keyword" }, + { "Type", "keyword" }, + { "typealias", "keyword" }, + { "unowned", "keyword" }, + { "var", "keyword" }, + { "weak", "keyword" }, + { "where", "keyword" }, + { "while", "keyword" }, + { "willSet", "keyword" }, + { "true", "literal" }, + { "false", "literal" }, + { "nil", "literal" }, + { "abs", "keyword2" }, + { "advance", "keyword2" }, + { "alignof", "keyword2" }, + { "alignofValue", "keyword2" }, + { "anyGenerator", "keyword2" }, + { "assert", "keyword2" }, + { "assertionFailure", "keyword2" }, + { "bridgeFromObjectiveC", "keyword2" }, + { "bridgeFromObjectiveCUnconditional", "keyword2" }, + { "bridgeToObjectiveC", "keyword2" }, + { "bridgeToObjectiveCUnconditional", "keyword2" }, + { "c", "keyword2" }, + { "compactMap", "keyword2" }, + { "contains", "keyword2" }, + { "count", "keyword2" }, + { "countElements", "keyword2" }, + { "countLeadingZeros", "keyword2" }, + { "debugPrint", "keyword2" }, + { "debugPrintln", "keyword2" }, + { "distance", "keyword2" }, + { "dropFirst", "keyword2" }, + { "dropLast", "keyword2" }, + { "dump", "keyword2" }, + { "encodeBitsAsWords", "keyword2" }, + { "enumerate", "keyword2" }, + { "equal", "keyword2" }, + { "fatalError", "keyword2" }, + { "filter", "keyword2" }, + { "find", "keyword2" }, + { "getBridgedObjectiveCType", "keyword2" }, + { "getVaList", "keyword2" }, + { "indices", "keyword2" }, + { "insertionSort", "keyword2" }, + { "isBridgedToObjectiveC", "keyword2" }, + { "isBridgedVerbatimToObjectiveC", "keyword2" }, + { "isUniquelyReferenced", "keyword2" }, + { "isUniquelyReferencedNonObjC", "keyword2" }, + { "join", "keyword2" }, + { "lazy", "keyword2" }, + { "lexicographicalCompare", "keyword2" }, + { "map", "keyword2" }, + { "max", "keyword2" }, + { "maxElement", "keyword2" }, + { "min", "keyword2" }, + { "minElement", "keyword2" }, + { "numericCast", "keyword2" }, + { "overlaps", "keyword2" }, + { "partition", "keyword2" }, + { "posix", "keyword2" }, + { "precondition", "keyword2" }, + { "preconditionFailure", "keyword2" }, + { "print", "keyword2" }, + { "println", "keyword2" }, + { "quickSort", "keyword2" }, + { "readLine", "keyword2" }, + { "reduce", "keyword2" }, + { "reflect", "keyword2" }, + { "reinterpretCast", "keyword2" }, + { "reverse", "keyword2" }, + { "roundUpToAlignment", "keyword2" }, + { "sizeof", "keyword2" }, + { "sizeofValue", "keyword2" }, + { "sort", "keyword2" }, + { "split", "keyword2" }, + { "startsWith", "keyword2" }, + { "stride", "keyword2" }, + { "strideof", "keyword2" }, + { "strideofValue", "keyword2" }, + { "swap", "keyword2" }, + { "toString", "keyword2" }, + { "transcode", "keyword2" }, + { "underestimateCount", "keyword2" }, + { "unsafeAddressOf", "keyword2" }, + { "unsafeBitCast", "keyword2" }, + { "unsafeDowncast", "keyword2" }, + { "unsafeUnwrap", "keyword2" }, + { "unsafeReflect", "keyword2" }, + { "withExtendedLifetime", "keyword2" }, + { "withObjectAtPlusZero", "keyword2" }, + { "withUnsafePointer", "keyword2" }, + { "withUnsafePointerToObject", "keyword2" }, + { "withUnsafeMutablePointer", "keyword2" }, + { "withUnsafeMutablePointers", "keyword2" }, + { "withUnsafePointer", "keyword2" }, + { "withUnsafePointers", "keyword2" }, + { "withVaList", "keyword2" }, + { "zip", "keyword2" }, + { "Int", "keyword2" }, + { "Float", "keyword2" }, + { "Double", "keyword2" }, + { "String", "keyword2" }, + { "Void", "keyword2" }, + { "Bool", "keyword2" }, + { "Array", "keyword2" }, + { "Optional", "keyword2" }, + }, + "//" } ); + + add( { "Solidity", + { "%.sol$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"\"\"", "\"\"\"" }, "string" }, + { { "\"", "\"", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + }, + { { "if", "keyword" }, { "else", "keyword" }, + { "for", "keyword" }, { "while", "keyword" }, + { "do", "keyword" }, { "break", "keyword" }, + { "continue", "keyword" }, { "throw", "keyword" }, + { "returns", "keyword" }, { "return", "keyword" }, + { "function", "keyword" }, { "private", "keyword2" }, + { "public", "keyword2" }, { "internal", "keyword2" }, + { "external", "keyword2" }, { "constant", "keyword2" }, + { "immutable", "keyword2" }, { "pure", "keyword2" }, + { "view", "keyword2" }, { "payable", "keyword2" }, + { "nonpayable", "keyword2" }, { "inherited", "keyword2" }, + { "indexed", "keyword2" }, { "storage", "keyword2" }, + { "memory", "keyword2" }, { "virtual", "keyword2" }, + { "calldata", "keyword2" }, { "override", "keyword2" }, + { "abstract", "keyword" }, { "library", "keyword" }, + { "enum", "keyword" }, { "constructor", "keyword" }, + { "event", "keyword" }, { "modifier", "keyword" }, + { "assembly", "keyword" }, { "let", "keyword" }, + { "msg", "keyword2" }, { "block", "keyword2" }, + { "tx", "keyword2" }, { "now", "keyword2" }, + { "this", "keyword2" }, { "super", "keyword2" }, + { "require", "keyword" }, { "assert", "keyword2" }, + { "revert", "keyword2" }, { "selfdestruct", "keyword2" }, + { "suicide", "keyword2" }, { "addmod", "keyword2" }, + { "mulmod", "keyword2" }, { "keccak256", "keyword2" }, + { "sha256", "keyword2" }, { "sha3", "keyword2" }, + { "ripemd160", "keyword2" }, { "ecrecover", "keyword2" }, + { "blockhash", "keyword2" }, { "gasleft", "keyword2" }, + { "contract", "keyword" }, { "interface", "keyword" }, + { "modifier", "keyword" }, { "mapping", "keyword2" }, + { "address", "keyword2" }, { "string", "keyword2" }, + { "byte", "keyword2" }, { "bytes", "keyword2" }, + { "bytes1", "keyword2" }, { "bytes2", "keyword2" }, + { "bytes3", "keyword2" }, { "bytes4", "keyword2" }, + { "bytes5", "keyword2" }, { "bytes6", "keyword2" }, + { "bytes7", "keyword2" }, { "bytes8", "keyword2" }, + { "bytes9", "keyword2" }, { "bytes10", "keyword2" }, + { "bytes11", "keyword2" }, { "bytes12", "keyword2" }, + { "bytes13", "keyword2" }, { "bytes14", "keyword2" }, + { "bytes15", "keyword2" }, { "bytes16", "keyword2" }, + { "bytes17", "keyword2" }, { "bytes18", "keyword2" }, + { "bytes19", "keyword2" }, { "bytes20", "keyword2" }, + { "bytes21", "keyword2" }, { "bytes22", "keyword2" }, + { "bytes23", "keyword2" }, { "bytes24", "keyword2" }, + { "bytes25", "keyword2" }, { "bytes26", "keyword2" }, + { "bytes27", "keyword2" }, { "bytes28", "keyword2" }, + { "bytes29", "keyword2" }, { "bytes30", "keyword2" }, + { "bytes31", "keyword2" }, { "bytes32", "keyword2" }, + { "int", "keyword2" }, { "int8", "keyword2" }, + { "int16", "keyword2" }, { "int32", "keyword2" }, + { "int64", "keyword2" }, { "int128", "keyword2" }, + { "int256", "keyword2" }, { "uint", "keyword2" }, + { "uint8", "keyword2" }, { "uint16", "keyword2" }, + { "uint32", "keyword2" }, { "uint64", "keyword2" }, + { "uint128", "keyword2" }, { "uint256", "keyword2" }, + { "bool", "keyword2" }, { "hash", "keyword2" }, + { "pragma", "keyword2" }, { "using", "keyword" }, + { "is", "keyword" }, { "new", "keyword" }, + { "delete", "keyword" }, { "emit", "keyword" }, + { "struct", "keyword" }, { "protected", "keyword" } } } ); + + // Objective-C + add( { "Objective-C", + { "%.m$" }, + { { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "#", "[^\\]\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "@[%a_][%w_]*" }, "keyword2" }, + { { "[%a_][%w_]*" }, "symbol" } }, + { { "if", "keyword" }, { "then", "keyword" }, { "else", "keyword" }, + { "elseif", "keyword" }, { "do", "keyword" }, { "while", "keyword" }, + { "for", "keyword" }, { "break", "keyword" }, { "continue", "keyword" }, + { "return", "keyword" }, { "goto", "keyword" }, { "struct", "keyword" }, + { "union", "keyword" }, { "typedef", "keyword" }, { "enum", "keyword" }, + { "extern", "keyword" }, { "static", "keyword" }, { "volatile", "keyword" }, + { "const", "keyword" }, { "inline", "keyword" }, { "switch", "keyword" }, + { "case", "keyword" }, { "default", "keyword" }, { "auto", "keyword" }, + { "const", "keyword" }, { "void", "keyword" }, { "int", "keyword2" }, + { "short", "keyword2" }, { "long", "keyword2" }, { "float", "keyword2" }, + { "double", "keyword2" }, { "char", "keyword2" }, { "unsigned", "keyword2" }, + { "bool", "keyword2" }, { "true", "literal" }, { "false", "literal" }, + { "NULL", "literal" }, { "nil", "literal" } }, + "//" } ); + + // Dart + add( { "Dart", + { "%.dart$" }, + { + { { "//.-\n" }, "comment" }, + { { "///.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?0x%x+" }, "number" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" }, + { { "%?%?" }, "operator" }, + { { "%?%." }, "operator" }, + { { "[%$%@]?\"", "\"", "\\" }, "string" }, + { { "'\\x%x?%x?%x?%x'" }, "string" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + }, + { { "await", "keyword" }, { "bool", "keyword2" }, { "break", "keyword" }, + { "case", "keyword" }, { "class", "keyword" }, { "const", "keyword" }, + { "continue", "keyword" }, { "default", "keyword" }, { "do", "keyword" }, + { "double", "keyword2" }, { "dynamic", "keyword2" }, { "else", "keyword" }, + { "enum", "keyword" }, { "false", "literal" }, { "final", "keyword" }, + { "finally", "keyword" }, { "for", "keyword" }, { "Function", "keyword2" }, + { "if", "keyword" }, { "in", "keyword" }, { "int", "keyword2" }, + { "List", "keyword2" }, { "Map", "keyword2" }, { "new", "keyword" }, + { "null", "literal" }, { "part of", "keyword" }, { "print", "keyword" }, + { "return", "keyword" }, { "static", "keyword" }, { "String", "keyword2" }, + { "switch", "keyword" }, { "then", "keyword" }, { "this", "keyword2" }, + { "true", "literal" }, { "void", "keyword" }, { "while", "keyword" } }, + "//" } ); + + // Add Kotlin + 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" } }, + "//" } ); } SyntaxDefinition& SyntaxDefinitionManager::add( SyntaxDefinition&& syntaxStyle ) { - mStyles.emplace_back( std::move( syntaxStyle ) ); - return mStyles.back(); + mStyles.emplace_back( std::move( syntaxStyle ) ); + return mStyles.back(); } const SyntaxDefinition& SyntaxDefinitionManager::getPlainStyle() const { - return mStyles[0]; + return mStyles[0]; } SyntaxDefinition& SyntaxDefinitionManager::getStyleByExtensionRef( const std::string& filePath ) { - return const_cast( getStyleByExtension( filePath ) ); + return const_cast( getStyleByExtension( filePath ) ); } const SyntaxDefinition& SyntaxDefinitionManager::getStyleByLanguageName( const std::string& name ) const { - for ( auto& style : mStyles ) { - if ( style.getLanguageName() == name ) - return style; - } - return mStyles[0]; + for ( auto& style : mStyles ) { + if ( style.getLanguageName() == name ) + return style; + } + return mStyles[0]; } const SyntaxDefinition& SyntaxDefinitionManager::getStyleByLanguageId( const String::HashType& id ) const { - for ( auto& style : mStyles ) { - if ( style.getLanguageId() == id ) - return style; - } - return mStyles[0]; + for ( auto& style : mStyles ) { + if ( style.getLanguageId() == id ) + return style; + } + return mStyles[0]; } SyntaxDefinition& SyntaxDefinitionManager::getStyleByLanguageNameRef( const std::string& name ) { - return const_cast( getStyleByLanguageName( name ) ); + return const_cast( getStyleByLanguageName( name ) ); } std::vector SyntaxDefinitionManager::getLanguageNames() const { - std::vector names; - for ( auto& style : mStyles ) { - names.push_back( style.getLanguageName() ); - } - std::sort( names.begin(), names.end() ); - return names; + std::vector names; + for ( auto& style : mStyles ) { + names.push_back( style.getLanguageName() ); + } + std::sort( names.begin(), names.end() ); + return names; } std::vector SyntaxDefinitionManager::getExtensionsPatternsSupported() const { - std::vector exts; - for ( auto& style : mStyles ) - for ( auto& pattern : style.getFiles() ) - exts.emplace_back( pattern ); - return exts; + std::vector exts; + for ( auto& style : mStyles ) + for ( auto& pattern : style.getFiles() ) + exts.emplace_back( pattern ); + return exts; } const SyntaxDefinition& SyntaxDefinitionManager::getStyleByExtension( const std::string& filePath ) const { - std::string extension( FileSystem::fileExtension( filePath ) ); + std::string extension( FileSystem::fileExtension( filePath ) ); - // Use the filename instead - if ( extension.empty() ) { - extension = FileSystem::fileNameFromPath( filePath ); - } + // Use the filename instead + if ( extension.empty() ) { + extension = FileSystem::fileNameFromPath( filePath ); + } - if ( !extension.empty() ) { - for ( auto style = mStyles.rbegin(); style != mStyles.rend(); ++style ) { - for ( const auto& ext : style->getFiles() ) { - if ( String::startsWith( ext, "%." ) || String::endsWith( ext, "$" ) ) { - LuaPattern words( ext ); - int start, end; - if ( words.find( filePath, start, end ) ) { + if ( !extension.empty() ) { + for ( auto style = mStyles.rbegin(); style != mStyles.rend(); ++style ) { + for ( const auto& ext : style->getFiles() ) { + if ( String::startsWith( ext, "%." ) || String::endsWith( ext, "$" ) ) { + LuaPattern words( ext ); + int start, end; + if ( words.find( filePath, start, end ) ) { + return *style; + } + } else if ( extension == ext ) { return *style; } - } else if ( extension == ext ) { - return *style; } } } - } - return mStyles[0]; + return mStyles[0]; } const SyntaxDefinition& SyntaxDefinitionManager::getStyleByHeader( const std::string& header ) const { - if ( !header.empty() ) { - for ( auto style = mStyles.rbegin(); style != mStyles.rend(); ++style ) { - for ( const auto& hdr : style->getHeaders() ) { - LuaPattern words( hdr ); - int start, end; - if ( words.find( header, start, end ) ) { - return *style; + if ( !header.empty() ) { + for ( auto style = mStyles.rbegin(); style != mStyles.rend(); ++style ) { + for ( const auto& hdr : style->getHeaders() ) { + LuaPattern words( hdr ); + int start, end; + if ( words.find( header, start, end ) ) { + return *style; + } } } } - } - return mStyles[0]; + return mStyles[0]; } const SyntaxDefinition& SyntaxDefinitionManager::find( const std::string& filePath, const std::string& header ) { - const SyntaxDefinition& def = getStyleByExtension( filePath ); - if ( def.getLanguageName() == mStyles[0].getLanguageName() ) - return getStyleByHeader( header ); - return def; + const SyntaxDefinition& def = getStyleByHeader( header ); + if ( def.getLanguageName() == mStyles[0].getLanguageName() ) + return getStyleByExtension( filePath ); + return def; } - -}}} // namespace EE::UI::Doc +} +}} // namespace EE::UI::Doc diff --git a/src/eepp/ui/doc/syntaxhighlighter.cpp b/src/eepp/ui/doc/syntaxhighlighter.cpp index 6633d65eb..03c4e817e 100644 --- a/src/eepp/ui/doc/syntaxhighlighter.cpp +++ b/src/eepp/ui/doc/syntaxhighlighter.cpp @@ -1,3 +1,4 @@ +#include #include #include @@ -90,4 +91,20 @@ bool SyntaxHighlighter::updateDirty( int visibleLinesCount ) { return false; } +const SyntaxDefinition& +SyntaxHighlighter::getSyntaxDefinitionFromTextPosition( const TextPosition& position ) { + auto found = mLines.find( position.line() ); + if ( found == mLines.end() ) + return SyntaxDefinitionManager::instance()->getPlainStyle(); + + TokenizedLine& line = found->second; + SyntaxState state = + SyntaxTokenizer::retrieveSyntaxState( mDoc->getSyntaxDefinition(), line.state ); + + if ( nullptr == state.currentSyntax ) + return SyntaxDefinitionManager::instance()->getPlainStyle(); + + return *state.currentSyntax; +} + }}} // namespace EE::UI::Doc diff --git a/src/eepp/ui/doc/syntaxtokenizer.cpp b/src/eepp/ui/doc/syntaxtokenizer.cpp index c3962a02a..47a85bc7a 100644 --- a/src/eepp/ui/doc/syntaxtokenizer.cpp +++ b/src/eepp/ui/doc/syntaxtokenizer.cpp @@ -61,14 +61,8 @@ std::pair findNonEscaped( const std::string& text, const std::string& } } -struct SyntaxState { - const SyntaxDefinition* currentSyntax{ nullptr }; - const SyntaxPattern* subsyntaxInfo{ nullptr }; - Uint32 currentPatternIdx{ 0 }; - Uint32 currentLevel{ 0 }; -}; - -SyntaxState retrieveSyntaxState( const SyntaxDefinition& syntax, const Uint32& state ) { +SyntaxState SyntaxTokenizer::retrieveSyntaxState( const SyntaxDefinition& syntax, + const Uint32& state ) { SyntaxState syntaxState{ &syntax, nullptr, state, 0 }; if ( state > 0 && ( state > 255 || diff --git a/src/eepp/ui/uicodeeditor.cpp b/src/eepp/ui/uicodeeditor.cpp index 3eb93f781..a36549e23 100644 --- a/src/eepp/ui/uicodeeditor.cpp +++ b/src/eepp/ui/uicodeeditor.cpp @@ -766,6 +766,8 @@ Uint32 UICodeEditor::onTextInput( const TextInputEvent& event ) { mDoc->textInput( event.getText() ); + checkAutoCloseXMLTag( event.getText() ); + for ( auto& module : mModules ) if ( module->onTextInput( this, event ) ) return 1; @@ -2569,7 +2571,8 @@ Rectf UICodeEditor::getMinimapRect( const Vector2f& start ) const { void UICodeEditor::drawMinimap( const Vector2f& start, const std::pair& lineRange ) { Float charHeight = PixelDensity::getPixelDensity() * mMinimapConfig.scale; - Float charSpacing = eemax( 1.f, eefloor( 0.8 * PixelDensity::getPixelDensity() * mMinimapConfig.scale ) ); + Float charSpacing = + eemax( 1.f, eefloor( 0.8 * PixelDensity::getPixelDensity() * mMinimapConfig.scale ) ); Float lineSpacing = getMinimapLineSpacing(); Rectf rect( getMinimapRect( start ) ); int visibleLinesCount = ( lineRange.second - lineRange.first ); @@ -2756,4 +2759,45 @@ bool UICodeEditor::isMinimapFileTooLarge() const { eefloor( getMinimapRect( getScreenStart() ).getHeight() / getMinimapLineSpacing() ); } +bool UICodeEditor::getAutoCloseXMLTags() const { + return mAutoCloseXMLTags; +} + +void UICodeEditor::setAutoCloseXMLTags( bool autoCloseXMLTags ) { + mAutoCloseXMLTags = autoCloseXMLTags; +} + +bool UICodeEditor::checkAutoCloseXMLTag( const String& text ) { + if ( !mAutoCloseXMLTags || text.empty() || text.size() > 1 || text[0] != '>' || + mDoc->getSelection().hasSelection() ) + return false; + TextPosition start( mDoc->getSelection().start() ); + if ( start.line() >= (Int64)mDoc->linesCount() ) + return false; + const auto& line = mDoc->line( start.line() ).getText(); + if ( start.column() >= (Int64)line.size() ) + return false; + if ( line[start.column() - 1] != '>' || ( line.size() > 2 && line[start.column() - 2] == '/' ) ) + return false; + // Only close tags if the current line syntax is XML or HTML + const SyntaxDefinition& definition = mHighlighter.getSyntaxDefinitionFromTextPosition( start ); + const String::HashType xmlType = String::hash( "xml" ); + const String::HashType htmlType = String::hash( "html" ); + if ( definition.getLanguageId() != xmlType && definition.getLanguageId() != htmlType ) + return false; + size_t foundOpenPos = line.find_last_of( "<", start.column() - 1 ); + if ( foundOpenPos == String::InvalidPos || start.column() - foundOpenPos < 1 ) + return false; + std::string tag( line.substr( foundOpenPos, start.column() - foundOpenPos ).toUtf8() ); + LuaPattern pattern( "<([%w_%-]+).*>" ); + auto match = pattern.gmatch( tag ); + if ( match.matches() ) { + std::string tagName( match.group( 1 ) ); + mDoc->textInput( String( "" ) ); + mDoc->setSelection( start ); + return true; + } + return false; +} + }} // namespace EE::UI diff --git a/src/tools/ecode/appconfig.cpp b/src/tools/ecode/appconfig.cpp index 0789d2b6a..59fc27e6a 100644 --- a/src/tools/ecode/appconfig.cpp +++ b/src/tools/ecode/appconfig.cpp @@ -98,6 +98,7 @@ void AppConfig::load( std::string& confPath, std::string& keybindingsPath, ini.getValueB( "editor", "single_click_tree_navigation", false ); editor.syncProjectTreeWithEditor = ini.getValueB( "editor", "sync_project_tree_with_editor", false ); + editor.autoCloseXMLTags = ini.getValueB( "editor", "auto_close_xml_tags", true ); iniInfo = FileInfo( ini.path() ); } @@ -164,6 +165,7 @@ void AppConfig::save( const std::vector& recentFiles, ini.setValueB( "editor", "hide_tab_bar_on_single_tab", editor.hideTabBarOnSingleTab ); ini.setValueB( "editor", "single_click_tree_navigation", editor.singleClickTreeNavigation ); ini.setValueB( "editor", "sync_project_tree_with_editor", editor.syncProjectTreeWithEditor ); + ini.setValueB( "editor", "auto_close_xml_tags", editor.autoCloseXMLTags ); ini.writeFile(); iniState.writeFile(); } diff --git a/src/tools/ecode/appconfig.hpp b/src/tools/ecode/appconfig.hpp index 0f1f34c8f..fd87c5bb0 100644 --- a/src/tools/ecode/appconfig.hpp +++ b/src/tools/ecode/appconfig.hpp @@ -63,6 +63,7 @@ struct CodeEditorConfig { bool hideTabBarOnSingleTab{ true }; bool singleClickTreeNavigation{ false }; bool syncProjectTreeWithEditor{ true }; + bool autoCloseXMLTags{ true }; std::string autoCloseBrackets{ "" }; int indentWidth{ 4 }; int tabWidth{ 4 }; diff --git a/src/tools/ecode/ecode.cpp b/src/tools/ecode/ecode.cpp index fe0dacb7b..d22cf1315 100644 --- a/src/tools/ecode/ecode.cpp +++ b/src/tools/ecode/ecode.cpp @@ -916,7 +916,7 @@ UIMenu* App::createDocumentMenu() { } ); UIPopUpMenu* bracketsMenu = UIPopUpMenu::New(); - mDocMenu->addSubMenu( "Auto-Close Brackets", nullptr, bracketsMenu ); + mDocMenu->addSubMenu( "Auto-Close Brackets & Tags", nullptr, bracketsMenu ); auto& closeBrackets = mConfig.editor.autoCloseBrackets; auto shouldCloseCb = []( UIMenuItem* ) -> bool { return false; }; bracketsMenu->addCheckBox( "Brackets ()", closeBrackets.find( '(' ) != std::string::npos ) @@ -939,10 +939,20 @@ UIMenu* App::createDocumentMenu() { bracketsMenu->addCheckBox( "Back Quotes ``", closeBrackets.find( '`' ) != std::string::npos ) ->setOnShouldCloseCb( shouldCloseCb ) ->setId( "``" ); + bracketsMenu->addCheckBox( "Auto Close XML Tags", mConfig.editor.autoCloseXMLTags ) + ->setOnShouldCloseCb( shouldCloseCb ) + ->setId( "XML" ); bracketsMenu->addEventListener( Event::OnItemClicked, [&]( const Event* event ) { std::string id = event->getNode()->getId(); if ( event->getNode()->isType( UI_TYPE_MENUCHECKBOX ) ) { UIMenuCheckBox* item = event->getNode()->asType(); + if ( item->getId() == "XML" ) { + mConfig.editor.autoCloseXMLTags = item->isActive(); + mEditorSplitter->forEachEditor( [&]( UICodeEditor* editor ) { + editor->setAutoCloseXMLTags( mConfig.editor.autoCloseXMLTags ); + } ); + return; + } auto curPairs = String::split( mConfig.editor.autoCloseBrackets, ',' ); auto found = std::find( curPairs.begin(), curPairs.end(), id ); if ( item->isActive() ) { @@ -1372,6 +1382,7 @@ void App::onCodeEditorCreated( UICodeEditor* editor, TextDocument& doc ) { editor->setColorPreview( config.colorPreview ); editor->setFont( mFontMono ); editor->setMenuIconSize( mMenuIconSize ); + editor->setAutoCloseXMLTags( config.autoCloseXMLTags ); doc.setAutoCloseBrackets( !mConfig.editor.autoCloseBrackets.empty() ); doc.setAutoCloseBracketsPairs( makeAutoClosePairs( mConfig.editor.autoCloseBrackets ) ); doc.setAutoDetectIndentType( config.autoDetectIndentType );