diff --git a/include/eepp/config.hpp b/include/eepp/config.hpp index 7b79ab693..49f933125 100644 --- a/include/eepp/config.hpp +++ b/include/eepp/config.hpp @@ -138,7 +138,7 @@ #define EE_LITTLE_ENDIAN 1 #define EE_BIG_ENDIAN 2 -#if EE_PLATFORM == EE_PLATFORM_EMSCRIPTEN +#if EE_PLATFORM == EE_PLATFORM_EMSCRIPTEN || EE_PLATFORM == EE_PLATFORM_ANDROID #define EE_ENDIAN EE_LITTLE_ENDIAN #endif diff --git a/premake4.lua b/premake4.lua index 392600d59..f33c46c41 100644 --- a/premake4.lua +++ b/premake4.lua @@ -1107,7 +1107,7 @@ solution "eepp" project "ecode" set_kind() language "C++" - files { "src/tools/ecode/*.cpp" } + files { "src/tools/ecode/**.cpp" } includedirs { "src/thirdparty/efsw/include", "src/thirdparty" } links { "efsw-static" } if not os.is("windows") and not os.is("haiku") then diff --git a/premake5.lua b/premake5.lua index 2cbbfbc78..8c3bab1eb 100644 --- a/premake5.lua +++ b/premake5.lua @@ -858,7 +858,7 @@ workspace "eepp" project "ecode" set_kind() language "C++" - files { "src/tools/ecode/*.cpp" } + files { "src/tools/ecode/**.cpp" } incdirs { "src/thirdparty/efsw/include", "src/thirdparty" } links { "efsw-static" } build_link_configuration( "ecode", true ) diff --git a/projects/android-project/app/build.gradle b/projects/android-project/app/build.gradle index c92411e6d..d47f9e2a9 100644 --- a/projects/android-project/app/build.gradle +++ b/projects/android-project/app/build.gradle @@ -13,16 +13,16 @@ def getProcessesCountArg() { } android { - compileSdkVersion 28 - buildToolsVersion "28.0.3" + compileSdkVersion 30 + buildToolsVersion "30.0.3" defaultConfig { applicationId "com.ensoft.eepp" minSdkVersion 14 - targetSdkVersion 28 + targetSdkVersion 30 versionCode 1 versionName "1.0" ndk { - abiFilters 'x86', 'armeabi-v7a' + abiFilters 'arm64-v8a', 'x86_64' } externalNativeBuild { ndkBuild { diff --git a/projects/android-project/app/jni/Android.mk b/projects/android-project/app/jni/Android.mk index f48ed0943..f9ba6f852 100644 --- a/projects/android-project/app/jni/Android.mk +++ b/projects/android-project/app/jni/Android.mk @@ -59,7 +59,7 @@ LOCAL_CFLAGS := $(EEPP_C_FLAGS) LOCAL_C_INCLUDES := $(EEPP_C_INCLUDES) -CORE_SRCS := test/*.cpp +CORE_SRCS := tests/test_all/*.cpp LOCAL_SRC_FILES := $(SDL_MAIN_PATH) $(foreach F, $(CORE_SRCS), $(addprefix $(dir $(F)),$(notdir $(wildcard $(LOCAL_PATH)/$(F))))) diff --git a/projects/android-project/app/jni/eepp.mk b/projects/android-project/app/jni/eepp.mk index 1dcff4de5..ef4b13c47 100644 --- a/projects/android-project/app/jni/eepp.mk +++ b/projects/android-project/app/jni/eepp.mk @@ -9,6 +9,7 @@ SDL_MAIN_PATH := $(SDL_PATH)/src/main/android/*.c EEPP_C_INCLUDES := \ $(EEPP_THIRD_PARTY_PATH) \ $(EEPP_THIRD_PARTY_PATH)/freetype2/include \ + $(EEPP_THIRD_PARTY_PATH)/libpng \ $(SDL_PATH)/include \ $(EEPP_THIRD_PARTY_PATH)/chipmunk \ $(EEPP_INC_PATH)/eepp/thirdparty \ @@ -92,7 +93,7 @@ LOCAL_C_INCLUDES := $(EEPP_C_INCLUDES) LOCAL_SRC_FILES := $(foreach F, $(CODE_SRCS), $(addprefix $(dir $(F)),$(notdir $(wildcard $(LOCAL_PATH)/$(F))))) -LOCAL_STATIC_LIBRARIES := chipmunk freetype +LOCAL_STATIC_LIBRARIES := chipmunk freetype libpng LOCAL_SHARED_LIBRARIES := SDL2 @@ -133,7 +134,7 @@ LOCAL_MODULE := freetype APP_SUBDIRS := $(patsubst $(LOCAL_PATH)/%, %, $(shell find $(LOCAL_PATH)/src -type d)) -LOCAL_C_INCLUDES := $(foreach D, $(APP_SUBDIRS), $(LOCAL_PATH)/$(D)) $(LOCAL_PATH)/include +LOCAL_C_INCLUDES := $(foreach D, $(APP_SUBDIRS), $(LOCAL_PATH)/$(D)) $(LOCAL_PATH)/include $(EEPP_THIRD_PARTY_PATH)/libpng LOCAL_CFLAGS := -Os -DFT2_BUILD_LIBRARY LOCAL_SRC_FILES += $(foreach F, $(APP_SUBDIRS), $(addprefix $(F)/,$(notdir $(wildcard $(LOCAL_PATH)/$(F)/*.c)))) @@ -141,6 +142,28 @@ LOCAL_SRC_FILES += $(foreach F, $(APP_SUBDIRS), $(addprefix $(F)/,$(notdir $(w include $(BUILD_STATIC_LIBRARY) #*************** FREETYPE *************** +#*************** LIBPNG *************** +include $(CLEAR_VARS) + +LOCAL_PATH := $(EEPP_THIRD_PARTY_PATH) + +LOCAL_MODULE := libpng + +LIBPNG_SRCS := \ + libpng/*.c \ + libpng/arm/*.c \ + libpng/intel/*.c \ + libpng/mips/*.c \ + libpng/powerpc/*.c + +LOCAL_C_INCLUDES := $(LOCAL_PATH)/libpng/ +LOCAL_CFLAGS := -Os + +LOCAL_SRC_FILES := $(foreach F, $(LIBPNG_SRCS), $(addprefix $(dir $(F)),$(notdir $(wildcard $(LOCAL_PATH)/$(F))))) + +include $(BUILD_STATIC_LIBRARY) +#*************** LIBPNG *************** + #**************** SDL 2 *************** include $(CLEAR_VARS) diff --git a/projects/android-project/build.gradle b/projects/android-project/build.gradle index dd0d008b3..b91458701 100644 --- a/projects/android-project/build.gradle +++ b/projects/android-project/build.gradle @@ -6,10 +6,7 @@ buildscript { google() } dependencies { - classpath 'com.android.tools.build:gradle:3.2.1' - - // NOTE: Do not place your application dependencies here; they belong - // in the individual module build.gradle files + classpath 'com.android.tools.build:gradle:7.1.2' } } diff --git a/projects/android-project/gradle/wrapper/gradle-wrapper.jar b/projects/android-project/gradle/wrapper/gradle-wrapper.jar index 13372aef5..8c0fb64a8 100644 Binary files a/projects/android-project/gradle/wrapper/gradle-wrapper.jar and b/projects/android-project/gradle/wrapper/gradle-wrapper.jar differ diff --git a/projects/android-project/gradle/wrapper/gradle-wrapper.properties b/projects/android-project/gradle/wrapper/gradle-wrapper.properties index a5e90b79b..857ac358b 100644 --- a/projects/android-project/gradle/wrapper/gradle-wrapper.properties +++ b/projects/android-project/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ -#Sun Nov 26 15:24:16 ART 2017 +#Thu Mar 10 11:21:14 ART 2022 distributionBase=GRADLE_USER_HOME +distributionUrl=https\://services.gradle.org/distributions/gradle-7.2-bin.zip distributionPath=wrapper/dists -zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-4.6-all.zip +zipStoreBase=GRADLE_USER_HOME diff --git a/projects/linux/ee.files b/projects/linux/ee.files index 9cb7db7a3..7cb73580d 100644 --- a/projects/linux/ee.files +++ b/projects/linux/ee.files @@ -1098,8 +1098,6 @@ ../../src/thirdparty/efsw/src/test/efsw-test.cpp ../../src/tools/ecode/appconfig.cpp ../../src/tools/ecode/appconfig.hpp -../../src/tools/ecode/autocompletemodule.cpp -../../src/tools/ecode/autocompletemodule.hpp ../../src/tools/ecode/ecode.cpp ../../src/tools/ecode/ecode.hpp ../../src/tools/ecode/docsearchcontroller.cpp @@ -1108,14 +1106,16 @@ ../../src/tools/ecode/filelocator.hpp ../../src/tools/ecode/filesystemlistener.cpp ../../src/tools/ecode/filesystemlistener.hpp -../../src/tools/ecode/formattermodule.cpp -../../src/tools/ecode/formattermodule.hpp ../../src/tools/ecode/globalsearchcontroller.cpp ../../src/tools/ecode/globalsearchcontroller.hpp ../../src/tools/ecode/ignorematcher.cpp ../../src/tools/ecode/ignorematcher.hpp -../../src/tools/ecode/lintermodule.cpp -../../src/tools/ecode/lintermodule.hpp +../../src/tools/ecode/modules/autocomplete/autocompletemodule.cpp +../../src/tools/ecode/modules/autocomplete/autocompletemodule.hpp +../../src/tools/ecode/modules/formatter/formattermodule.cpp +../../src/tools/ecode/modules/formatter/formattermodule.hpp +../../src/tools/ecode/modules/linter/lintermodule.cpp +../../src/tools/ecode/modules/linter/lintermodule.hpp ../../src/tools/ecode/notificationcenter.cpp ../../src/tools/ecode/notificationcenter.hpp ../../src/tools/ecode/projectdirectorytree.cpp diff --git a/src/eepp/core/debug.cpp b/src/eepp/core/debug.cpp index 8fc829c66..dc5dba393 100644 --- a/src/eepp/core/debug.cpp +++ b/src/eepp/core/debug.cpp @@ -33,7 +33,7 @@ void eeREPORT_ASSERT( const char* File, int Line, const char* Exp ) { printf( "ASSERT: %s file:%s line:%d", Exp, File, Line ); } -#if defined( EE_COMPILER_GCC ) && !defined( EE_ARM ) && EE_PLATFORM != EE_PLATFORM_EMSCRIPTEN +#if defined( EE_COMPILER_GCC ) && !defined( EE_ARM ) && EE_PLATFORM != EE_PLATFORM_EMSCRIPTEN && EE_PLATFORM != EE_PLATFORM_ANDROID && EE_PLATFORM != EE_PLATFORM_IOS asm( "int3" ); #else assert( false ); diff --git a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp index 5f8e4de81..6065ad15d 100644 --- a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp +++ b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp @@ -6,8 +6,7 @@ using namespace EE::System; -namespace EE { -namespace UI { namespace Doc { +namespace EE { namespace UI { namespace Doc { SINGLETON_DECLARE_IMPLEMENTATION( SyntaxDefinitionManager ) @@ -555,1878 +554,1859 @@ SyntaxDefinitionManager::SyntaxDefinitionManager() { "//", { "^#!.*[ /]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$", "%.properties$", + "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& 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& el : table ) { + for ( const auto& it : el.second ) { + symbols[String::toLower( it )] = el.first; + symbols[String::toUpper( it )] = el.first; } - return symbols; - }; + } + 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" } ); + 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" }, - } } ); + // 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" }, - }, - "//" } ); + // 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" }, - }, - {}, - "#" } ); + // 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" }, - }, - "//" } ); + // 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" } } } ); + 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" } }, - "//" } ); + // 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" } }, - "//" } ); + // 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" } }, - "//" } ); + // 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 ) ) { - return *style; - } - } else if ( extension == ext ) { + 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; } } } - 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 = getStyleByHeader( header ); - if ( def.getLanguageName() == mStyles[0].getLanguageName() ) - return getStyleByExtension( filePath ); - 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/uicodeeditor.cpp b/src/eepp/ui/uicodeeditor.cpp index e18990e62..80bb049ce 100644 --- a/src/eepp/ui/uicodeeditor.cpp +++ b/src/eepp/ui/uicodeeditor.cpp @@ -1028,27 +1028,29 @@ Uint32 UICodeEditor::onMouseMove( const Vector2i& position, const Uint32& flags if ( module->onMouseMove( this, position, flags ) ) return UIWidget::onMouseMove( position, flags ); + bool minimapHover = false; if ( mMinimapEnabled ) { updateMipmapHover( position.asFloat() ); - Rectf rect( getMinimapRect( getScreenStart() ) ); if ( mMinimapDragging && ( flags & EE_BUTTON_LMASK ) ) { scrollTo( { calculateMinimapClickedLine( position ) - mMinimapScrollOffset, 0 }, false, true ); getUISceneNode()->setCursor( Cursor::Arrow ); return 1; } - if ( ( flags & EE_BUTTON_LMASK ) && rect.contains( position.asFloat() ) ) + minimapHover = getMinimapRect( getScreenStart() ).contains( position.asFloat() ); + if ( ( flags & EE_BUTTON_LMASK ) && minimapHover ) return 1; } - if ( isTextSelectionEnabled() && !getUISceneNode()->getEventDispatcher()->isNodeDragging() && - NULL != mFont && mMouseDown && ( flags & EE_BUTTON_LMASK ) ) { + if ( !minimapHover && isTextSelectionEnabled() && + !getUISceneNode()->getEventDispatcher()->isNodeDragging() && NULL != mFont && mMouseDown && + ( flags & EE_BUTTON_LMASK ) ) { TextRange selection = mDoc->getSelection(); selection.setStart( resolveScreenPosition( position.asFloat() ) ); mDoc->setSelection( selection ); } - if ( mMinimapEnabled && getMinimapRect( getScreenStart() ).contains( position.asFloat() ) ) { + if ( minimapHover ) { getUISceneNode()->setCursor( Cursor::Arrow ); } else { checkMouseOverColor( position ); @@ -1067,6 +1069,9 @@ Uint32 UICodeEditor::onMouseUp( const Vector2i& position, const Uint32& flags ) if ( NULL == mFont ) return UIWidget::onMouseUp( position, flags ); + bool minimapHover = + mMinimapEnabled && getMinimapRect( getScreenStart() ).contains( position.asFloat() ); + if ( flags & EE_BUTTON_LMASK ) { if ( mMinimapDragging ) { mMinimapDragging = false; @@ -1079,7 +1084,9 @@ Uint32 UICodeEditor::onMouseUp( const Vector2i& position, const Uint32& flags ) mMouseDown = false; getUISceneNode()->getWindow()->getInput()->captureMouse( false ); } - } else if ( flags & EE_BUTTON_WDMASK ) { + } + + if ( flags & EE_BUTTON_WDMASK ) { if ( getUISceneNode()->getWindow()->getInput()->isControlPressed() ) { mDoc->execute( "font-size-shrink" ); } else { @@ -1097,9 +1104,10 @@ Uint32 UICodeEditor::onMouseUp( const Vector2i& position, const Uint32& flags ) setScrollX( mScroll.x + PixelDensity::dpToPx( mMouseWheelScroll ) ); } else if ( flags & EE_BUTTON_WLMASK ) { setScrollX( mScroll.x - PixelDensity::dpToPx( mMouseWheelScroll ) ); - } else if ( ( flags & EE_BUTTON_RMASK ) ) { + } else if ( !minimapHover && ( flags & EE_BUTTON_RMASK ) ) { onCreateContextMenu( position, flags ); } + return UIWidget::onMouseUp( position, flags ); } diff --git a/src/eepp/window/backend/SDL2/inputsdl2.cpp b/src/eepp/window/backend/SDL2/inputsdl2.cpp index dd8dcbfbf..b2e59db87 100644 --- a/src/eepp/window/backend/SDL2/inputsdl2.cpp +++ b/src/eepp/window/backend/SDL2/inputsdl2.cpp @@ -291,6 +291,8 @@ void InputSDL::sendEvent( const SDL_Event& SDLEvent ) { button = EE_BUTTON_WHEELRIGHT; } else if ( SDLEvent.wheel.x < 0 ) { button = EE_BUTTON_WHEELLEFT; + } else { + return; } event.button.button = button; diff --git a/src/tools/ecode/ecode.cpp b/src/tools/ecode/ecode.cpp index 765fe25b1..5c8d6dc6f 100644 --- a/src/tools/ecode/ecode.cpp +++ b/src/tools/ecode/ecode.cpp @@ -1,7 +1,7 @@ #include "ecode.hpp" -#include "autocompletemodule.hpp" -#include "formattermodule.hpp" -#include "lintermodule.hpp" +#include "modules/autocomplete/autocompletemodule.hpp" +#include "modules/formatter/formattermodule.hpp" +#include "modules/linter/lintermodule.hpp" #include #include @@ -361,18 +361,23 @@ void App::onFileDropped( String file ) { Vector2f mousePos( mUISceneNode->getEventDispatcher()->getMousePosf() ); Node* node = mUISceneNode->overFind( mousePos ); UICodeEditor* codeEditor = mEditorSplitter->getCurEditor(); + UITab* tab = nullptr; if ( !node ) node = codeEditor; if ( node && node->isType( UI_TYPE_CODEEDITOR ) ) { codeEditor = node->asType(); - if ( !codeEditor->getDocument().isEmpty() && !Image::isImageExtension( file ) ) { + if ( ( codeEditor->getDocument().isLoading() || !codeEditor->getDocument().isEmpty() ) && + !Image::isImageExtension( file ) ) { auto d = mEditorSplitter->createCodeEditorInTabWidget( mEditorSplitter->tabWidgetFromEditor( codeEditor ) ); codeEditor = d.second; - d.first->getTabWidget()->setTabSelected( d.first ); + tab = d.first; } } - loadFileFromPath( file, false, codeEditor ); + loadFileFromPath( file, false, codeEditor, [tab]( UICodeEditor*, const std::string& ) { + if ( tab ) + tab->getTabWidget()->setTabSelected( tab ); + } ); } void App::onTextDropped( String text ) { diff --git a/src/tools/ecode/autocompletemodule.cpp b/src/tools/ecode/modules/autocomplete/autocompletemodule.cpp similarity index 100% rename from src/tools/ecode/autocompletemodule.cpp rename to src/tools/ecode/modules/autocomplete/autocompletemodule.cpp diff --git a/src/tools/ecode/autocompletemodule.hpp b/src/tools/ecode/modules/autocomplete/autocompletemodule.hpp similarity index 100% rename from src/tools/ecode/autocompletemodule.hpp rename to src/tools/ecode/modules/autocomplete/autocompletemodule.hpp diff --git a/src/tools/ecode/formattermodule.cpp b/src/tools/ecode/modules/formatter/formattermodule.cpp similarity index 98% rename from src/tools/ecode/formattermodule.cpp rename to src/tools/ecode/modules/formatter/formattermodule.cpp index 4b7560ae9..784444acd 100644 --- a/src/tools/ecode/formattermodule.cpp +++ b/src/tools/ecode/modules/formatter/formattermodule.cpp @@ -1,6 +1,6 @@ #include "formattermodule.hpp" -#include "thirdparty/json.hpp" -#include "thirdparty/subprocess.h" +#include "../../thirdparty/json.hpp" +#include "../../thirdparty/subprocess.h" #include #include #include diff --git a/src/tools/ecode/formattermodule.hpp b/src/tools/ecode/modules/formatter/formattermodule.hpp similarity index 100% rename from src/tools/ecode/formattermodule.hpp rename to src/tools/ecode/modules/formatter/formattermodule.hpp diff --git a/src/tools/ecode/lintermodule.cpp b/src/tools/ecode/modules/linter/lintermodule.cpp similarity index 99% rename from src/tools/ecode/lintermodule.cpp rename to src/tools/ecode/modules/linter/lintermodule.cpp index 5446e4d66..7c0f31eef 100644 --- a/src/tools/ecode/lintermodule.cpp +++ b/src/tools/ecode/modules/linter/lintermodule.cpp @@ -1,6 +1,6 @@ #include "lintermodule.hpp" -#include "thirdparty/json.hpp" -#include "thirdparty/subprocess.h" +#include "../../thirdparty/json.hpp" +#include "../../thirdparty/subprocess.h" #include #include #include diff --git a/src/tools/ecode/lintermodule.hpp b/src/tools/ecode/modules/linter/lintermodule.hpp similarity index 100% rename from src/tools/ecode/lintermodule.hpp rename to src/tools/ecode/modules/linter/lintermodule.hpp