From c1dfb83ed63612efc90e72c667c6ca246338768e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mart=C3=ADn=20Lucas=20Golini?= Date: Sat, 8 Jul 2023 02:16:35 -0300 Subject: [PATCH] Minor fixes and refactor. --- README.md | 18 +- bin/assets/colorschemes/colorschemes.conf | 81 +- include/eepp/system/time.hpp | 306 ++-- include/eepp/ui/doc/syntaxdefinition.hpp | 2 + include/eepp/ui/uicodeeditor.hpp | 1 + projects/linux/ee.files | 35 + src/eepp/system/time.cpp | 136 -- src/eepp/ui/doc/languages/batchscript.cpp | 148 ++ src/eepp/ui/doc/languages/batchscript.hpp | 10 + src/eepp/ui/doc/languages/css.cpp | 275 +++ src/eepp/ui/doc/languages/css.hpp | 10 + src/eepp/ui/doc/languages/d.cpp | 148 ++ src/eepp/ui/doc/languages/d.hpp | 10 + src/eepp/ui/doc/languages/glsl.cpp | 373 ++++ src/eepp/ui/doc/languages/glsl.hpp | 10 + src/eepp/ui/doc/languages/odin.cpp | 147 ++ src/eepp/ui/doc/languages/odin.hpp | 10 + src/eepp/ui/doc/languages/perl.cpp | 269 +++ src/eepp/ui/doc/languages/perl.hpp | 10 + src/eepp/ui/doc/languages/sass.cpp | 224 +++ src/eepp/ui/doc/languages/sass.hpp | 10 + src/eepp/ui/doc/languages/solidity.cpp | 153 ++ src/eepp/ui/doc/languages/solidity.hpp | 10 + src/eepp/ui/doc/languages/sql.cpp | 408 +++++ src/eepp/ui/doc/languages/sql.hpp | 10 + src/eepp/ui/doc/languages/swift.cpp | 230 +++ src/eepp/ui/doc/languages/swift.hpp | 10 + src/eepp/ui/doc/syntaxdefinition.cpp | 13 + src/eepp/ui/doc/syntaxdefinitionmanager.cpp | 1752 +------------------ src/eepp/ui/uicodeeditor.cpp | 34 +- src/tools/ecode/ecode.cpp | 37 +- 31 files changed, 2781 insertions(+), 2109 deletions(-) create mode 100644 src/eepp/ui/doc/languages/batchscript.cpp create mode 100644 src/eepp/ui/doc/languages/batchscript.hpp create mode 100644 src/eepp/ui/doc/languages/css.cpp create mode 100644 src/eepp/ui/doc/languages/css.hpp create mode 100644 src/eepp/ui/doc/languages/d.cpp create mode 100644 src/eepp/ui/doc/languages/d.hpp create mode 100644 src/eepp/ui/doc/languages/glsl.cpp create mode 100644 src/eepp/ui/doc/languages/glsl.hpp create mode 100644 src/eepp/ui/doc/languages/odin.cpp create mode 100644 src/eepp/ui/doc/languages/odin.hpp create mode 100644 src/eepp/ui/doc/languages/perl.cpp create mode 100644 src/eepp/ui/doc/languages/perl.hpp create mode 100644 src/eepp/ui/doc/languages/sass.cpp create mode 100644 src/eepp/ui/doc/languages/sass.hpp create mode 100644 src/eepp/ui/doc/languages/solidity.cpp create mode 100644 src/eepp/ui/doc/languages/solidity.hpp create mode 100644 src/eepp/ui/doc/languages/sql.cpp create mode 100644 src/eepp/ui/doc/languages/sql.hpp create mode 100644 src/eepp/ui/doc/languages/swift.cpp create mode 100644 src/eepp/ui/doc/languages/swift.hpp diff --git a/README.md b/README.md index e87e6b272..40197052f 100644 --- a/README.md +++ b/README.md @@ -366,7 +366,7 @@ Note: Please use a modern browser with good WebGL and WASM support (Chrome/ium 7 ## How to build it The library has only one external dependency. You will only need **SDL2** library with the headers -installed. Also **premake4** or **premake5** is needed to generate the Makefiles or project +installed. Also **premake5** or **premake4** is needed to generate the Makefiles or project files to build the library. I will assume that you know what you are doing and skip the basics. @@ -381,16 +381,16 @@ need to add the parameter `--without-mojoal` to any `premake` call In a Ubuntu system it would be something like ( also you will need gcc but it will be installed anyways ): -`sudo apt-get install premake4 libsdl2-2.0-0 libsdl2-dev libopenal1 libopenal-dev` +`sudo apt-get install premake5 libsdl2-2.0-0 libsdl2-dev libopenal1 libopenal-dev` Clone the repository and run on the repository root directory: -`premake4 gmake` - -or if you have premake5 installed you can run: - `premake5 gmake2` +or if you have premake4 installed you can run: + +`premake4 gmake` + Then just build the library: `make -C make/linux` @@ -402,7 +402,7 @@ That's it. That will build the whole project. You have two options: build with [Visual Studio](https://visualstudio.microsoft.com/) or with [MinGW](https://sourceforge.net/projects/mingw-w64/). To be able to build the project with any of these options first you will need to -generate the project files with [premake4 or premake5](https://premake.github.io/download.html). +generate the project files with [premake4 or premake5](https://premake.github.io/download). Then you will need to add the binary file to any of the executable paths defined in `PATH` ( or add one, or use it from a local path ). Also you will need to install the prebuild binaries and development libraries of [SDL2](http://libsdl.org/download-2.0.php) @@ -437,9 +437,9 @@ _VS2022 Community Edition_ the path usually is: #### MinGW -`premake4.exe gmake` +`premake5.exe gmake2` - Then just build the project located in `make/windows/` with `mingw32-make.exe` + Then just build the project located in `make/windows/` with `mingw32-make.exe` or `mingw64-make.exe` (depending on your target architecture) or any equivalent: `mingw32-make.exe -C make\windows` diff --git a/bin/assets/colorschemes/colorschemes.conf b/bin/assets/colorschemes/colorschemes.conf index 1e6e4b5e9..bc9315a52 100644 --- a/bin/assets/colorschemes/colorschemes.conf +++ b/bin/assets/colorschemes/colorschemes.conf @@ -40,6 +40,48 @@ function = #00dc7f,shadow link = #6ae0f9,shadow link_hover = transparent,shadow,underline +[onedark] +background = #282c34 +text = #e1e1e6 +caret = #93DDFA +selection = #394484 +line_highlight = #2d303d +line_number = #525259 +line_number2 = #83838f +gutter_background = #282c34 +whitespace = #394484 +line_break_column = #54575b99 +matching_bracket = #FFFFFF33 +matching_selection = #3e596e +matching_search = #181b1e +suggestion = #e1e1e6,#1d1f27 +suggestion_selected = #ffffff,#222533 +suggestion_scrollbar = #3daee9 +error = red +warning = yellow +notice = #8abdff +selection_region = #39448477 +minimap_background = #282c34AA +minimap_visible_area = #FFFFFF1A +minimap_current_line = #FFFFFF0A +minimap_hover = #FFFFFF1A +minimap_selection = #8abdff80 +minimap_highlight = #FFFF0080 + +normal = #aab2c0 +symbol = #aab2c0 +comment = #5c6370 +keyword = #d372e3 +keyword2 = #f6c976 +keyword3 = #ff7285 +number = #edba54 +literal = #f1fa8c +string = #9bdc7c +operator = #a4b2c0 +function = #46aff5 +link = #46aff5 +link_hover = transparent,shadow,underline + [lite] background = #2e2e32 text = #e1e1e6 @@ -62,6 +104,7 @@ symbol = #e1e1e6 comment = #676b6f keyword = #E58AC9 keyword2 = #F77483 +keyword3 = #FFA94D number = #FFA94D literal = #FFA94D string = #f7c95c @@ -85,6 +128,7 @@ symbol = #efdab9 comment = #615d5f keyword = #d36e2d keyword2 = #ef6179 +keyword3 = #ffd152 number = #ffd152 literal = #ffd152 string = #ffd152 @@ -106,6 +150,7 @@ symbol = #181818 comment = #22a21f keyword = #fb6620 keyword2 = #fc1785 +keyword3 = #1586d2 number = #1586d2 literal = #1586d2 string = #1586d2 @@ -156,6 +201,7 @@ symbol = #ebdbb2 comment = #928374 keyword = #fb4934 keyword2 = #83a598 +keyword3 = #d3869b number = #d3869b literal = #d3869b string = #b8bb26 @@ -177,6 +223,7 @@ symbol = #d4be98 comment = #a9b665 keyword = #e86861 keyword2 = #e78a4e +keyword3 = #d3869b number = #d3869b literal = #d3869b string = #d8a657 @@ -200,6 +247,7 @@ symbol = #71a9d7 comment = #5c6370 keyword = #98c875 keyword2 = #ffffff +keyword3 = #a3b2cf number = #ffffff literal = #ea5964 string = #ea5964 @@ -222,6 +270,7 @@ symbol = #a0a0a0 comment = #404040 keyword = #f0f0f0 keyword2 = #f0f0f0 +keyword3 = #f0f0f0 number = #f0f0f0 literal = #f0f0f0 string = #f0f0f0 @@ -243,6 +292,7 @@ symbol = #F8F8F2 comment = #75715E keyword = #F92672 keyword2 = #66DAEF +keyword3 = #AE81FF number = #AE81FF literal = #AE81FF string = #E6DB74 @@ -264,6 +314,7 @@ symbol = #f5faff comment = #6272a4 keyword = #ff79c6 keyword2 = #8be9fd +keyword3 = #bd93f9 number = #bd93f9 literal = #bd93f9 string = #f1fa8c @@ -285,6 +336,7 @@ symbol = #24292e comment = #6a737d keyword = #d73a49 keyword2 = #d73a49 +keyword3 = #005cc5 number = #005cc5 literal = #005cc5 string = #032f62 @@ -313,6 +365,7 @@ symbol = #657b83 comment = #93a1a1 keyword = #859900 keyword2 = #268bd2 +keyword3 = #d33682 number = #d33682 literal = #2aa198 string = #2aa198 @@ -341,6 +394,7 @@ symbol = #00ff7f comment = #6c71c4 keyword = #6c71c4 keyword2 = #6c71c4 +keyword3 = #00ff7f number = #00ff7f literal = #1586d2 string = #f7f97d @@ -362,6 +416,7 @@ symbol = #a0a0a0 comment = #404040 keyword = #dfdfdf keyword2 = #dfdfdf +keyword3 = #dfdfdf number = #dfdfdf literal = #dfdfdf string = #dfdfdf @@ -369,8 +424,8 @@ operator = #01A870 function = #01A870 [vscode dark] -background = #1E1E1E -text = #D4D4D4 +background = #1F1F1F +text = #cccccc caret = #FFFFFF accent = #76BCFF selection = #264F78 @@ -378,16 +433,17 @@ line_number = #707070 line_number2 = #A0A0A0 line_highlight = #333A40 -normal = #D4D4D4 -symbol = #D4D4D4 -comment = #6A9955 -keyword = #569CD6 -keyword2 = #C586C0 +normal = #cccccc +symbol = #cccccc +comment = #6a9955 +keyword = #C586C0 +keyword2 = #4CC1A9 +keyword3 = #99D7F8 number = #B5CEA8 -literal = #569CD6 +literal = #CE9178 string = #CE9178 -operator = #8590A5 -function = #DCDCAA +operator = #DA70D6 +function = #D1D1A2 [zenburn] background = #404040 @@ -404,6 +460,7 @@ symbol = #dcdccc comment = #7f9f7f keyword = #f0dfaf keyword2 = #dfdfbf +keyword3 = #8cd0d3 number = #8cd0d3 literal = #dfaf8f string = #cc9393 @@ -425,6 +482,7 @@ symbol = #D8DEE9 comment = #4C566A keyword = #81A1C1 keyword2 = #81A1C1 +keyword3 = #B48EAD number = #B48EAD literal = #81A1C1 string = #A3BE8C @@ -448,6 +506,7 @@ symbol = #97e1f1 comment = #676b6f keyword = #E58AC9 keyword2 = #F77483 +keyword3 = #FFA94D number = #FFA94D literal = #ee6666 string = #f7c95c @@ -469,6 +528,7 @@ symbol = #181818 comment = #43cdbd keyword = #5f7dcd keyword2 = #9c53c6 +keyword3 = #3daee9 number = #3daee9 literal = #3daee9 string = #3daee9 @@ -497,6 +557,7 @@ symbol = #4c4f82 comment = #93a1a1 keyword = #d33682 keyword2 = #6c71c4 +keyword3 = #859900 number = #859900 literal = #b58900 string = #cb4b16 diff --git a/include/eepp/system/time.hpp b/include/eepp/system/time.hpp index 29d8dcf9d..a8398edd1 100644 --- a/include/eepp/system/time.hpp +++ b/include/eepp/system/time.hpp @@ -7,9 +7,6 @@ namespace EE { namespace System { -/* Based on the SFML2 implementation ( not the same, this version uses doubles for seconds and - * milliseconds ) */ - /** Represents a time value */ class EE_API Time { public: @@ -19,22 +16,22 @@ class EE_API Time { /** @brief Default constructor ** Sets the time value to zero. */ - Time(); + constexpr Time(); /** @brief Return the time value as a number of seconds ** @return Time in seconds ** @see AsMilliseconds, AsMicroseconds */ - double asSeconds() const; + constexpr double asSeconds() const; /** @brief Return the time value as a number of milliseconds ** @return Time in milliseconds ** @see AsSeconds, AsMicroseconds */ - double asMilliseconds() const; + constexpr double asMilliseconds() const; /** @brief Return the time value as a number of microseconds ** @return Time in microseconds ** @see asSeconds, asMilliseconds */ - Int64 asMicroseconds() const; + constexpr Int64 asMicroseconds() const; static const Time Zero; ///< Predefined "zero" time value @@ -42,228 +39,155 @@ class EE_API Time { std::string toString() const; private: - friend EE_API Time Minutes( double ); - friend EE_API Time Seconds( double ); - friend EE_API Time Milliseconds( double ); - friend EE_API Time Microseconds( Int64 ); + friend EE_API constexpr Time Minutes( double ); + friend EE_API constexpr Time Seconds( double ); + friend EE_API constexpr Time Milliseconds( double ); + friend EE_API constexpr Time Microseconds( Int64 ); /** @brief Construct from a number of microseconds ** This function is internal. To construct time values, ** use Seconds, Milliseconds or Microseconds instead. ** @param microseconds Number of microseconds */ - explicit Time( Int64 microseconds ); + constexpr explicit Time( Int64 microseconds ); Int64 mMicroseconds; ///< Time value stored as microseconds }; -/// @relates EE::System::Time -/// @brief Construct a time value from a number of minutes -/// @param amount Number of minutes -/// @return Time value constructed from the amount of seconds -/// @see Milliseconds, Microseconds -EE_API Time Minutes( double amount ); +constexpr Time::Time() : mMicroseconds( 0 ) {} -/// @relates EE::System::Time -/// @brief Construct a time value from a number of seconds -/// @param amount Number of seconds -/// @return Time value constructed from the amount of seconds -/// @see Milliseconds, Microseconds -EE_API Time Seconds( double amount ); +constexpr Time::Time( Int64 Microseconds ) : mMicroseconds( Microseconds ) {} -/// @relates EE::System::Time -/// @brief Construct a time value from a number of milliseconds -/// @param amount Number of milliseconds -/// @return Time value constructed from the amount of milliseconds -/// @see Seconds, Microseconds -EE_API Time Milliseconds( double amount ); +constexpr double Time::asSeconds() const { + return mMicroseconds / 1000000.0; +} -/// @relates EE::System::Time -/// @brief Construct a time value from a number of microseconds -/// @param amount Number of microseconds -/// @return Time value constructed from the amount of microseconds -/// @see Seconds, Milliseconds -EE_API Time Microseconds( Int64 amount ); +constexpr double Time::asMilliseconds() const { + return mMicroseconds / 1000.0; +} -/// @relates EE::System::Time -/// @brief Overload of == operator to compare two time values -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return True if both time values are equal -EE_API bool operator==( Time left, Time right ); +constexpr Int64 Time::asMicroseconds() const { + return mMicroseconds; +} -/// @relates EE::System::Time -/// @brief Overload of != operator to compare two time values -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return True if both time values are different -EE_API bool operator!=( Time left, Time right ); +constexpr Time Minutes( double amount ) { + return Time( static_cast( amount * 1000000 * 60 ) ); +} -/// @relates EE::System::Time -/// @brief Overload of < operator to compare two time values -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return True if @a left is lesser than @a right -EE_API bool operator<( Time left, Time right ); +constexpr Time Seconds( double amount ) { + return Time( static_cast( amount * 1000000 ) ); +} -/// @relates EE::System::Time -/// @brief Overload of > operator to compare two time values -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return True if @a left is greater than @a right -EE_API bool operator>( Time left, Time right ); +constexpr Time Milliseconds( double amount ) { + return Time( static_cast( amount * 1000 ) ); +} -/// @relates EE::System::Time -/// @brief Overload of <= operator to compare two time values -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return True if @a left is lesser or equal than @a right -EE_API bool operator<=( Time left, Time right ); +constexpr Time Microseconds( Int64 amount ) { + return Time( amount ); +} -/// @relates EE::System::Time -/// @brief Overload of >= operator to compare two time values -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return True if @a left is greater or equal than @a right -EE_API bool operator>=( Time left, Time right ); +constexpr bool operator==( Time left, Time right ) { + return left.asMicroseconds() == right.asMicroseconds(); +} -/// @relates EE::System::Time -/// @brief Overload of unary - operator to negate a time value -/// @param right Right operand (a time) -/// @return Opposite of the time value -EE_API Time operator-( Time right ); +constexpr bool operator!=( Time left, Time right ) { + return left.asMicroseconds() != right.asMicroseconds(); +} -/// @relates EE::System::Time -/// @brief Overload of binary + operator to add two time values -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return Sum of the two times values -EE_API Time operator+( Time left, Time right ); +constexpr bool operator<( Time left, Time right ) { + return left.asMicroseconds() < right.asMicroseconds(); +} -/// @relates EE::System::Time -/// @brief Overload of binary += operator to add/assign two time values -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return Sum of the two times values -EE_API Time& operator+=( Time& left, Time right ); +constexpr bool operator>( Time left, Time right ) { + return left.asMicroseconds() > right.asMicroseconds(); +} -/// @relates EE::System::Time -/// @brief Overload of binary - operator to subtract two time values -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return Difference of the two times values -EE_API Time operator-( Time left, Time right ); +constexpr bool operator<=( Time left, Time right ) { + return left.asMicroseconds() <= right.asMicroseconds(); +} -/// @relates EE::System::Time -/// @brief Overload of binary -= operator to subtract/assign two time values -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return Difference of the two times values -EE_API Time& operator-=( Time& left, Time right ); +constexpr bool operator>=( Time left, Time right ) { + return left.asMicroseconds() >= right.asMicroseconds(); +} -/// @relates EE::System::Time -/// @brief Overload of binary * operator to scale a time value -/// @param left Left operand (a time) -/// @param right Right operand (a number) -/// @return @a left multiplied by @a right -EE_API Time operator*( Time left, Time right ); +constexpr Time operator-( Time right ) { + return Microseconds( -right.asMicroseconds() ); +} -/// @relates EE::System::Time -/// @brief Overload of binary * operator to scale a time value -/// @param left Left operand (a time) -/// @param right Right operand (a number) -/// @return @a left multiplied by @a right -EE_API Time operator*( Time left, double right ); +constexpr Time operator+( Time left, Time right ) { + return Microseconds( left.asMicroseconds() + right.asMicroseconds() ); +} -/// @relates EE::System::Time -/// @brief Overload of binary * operator to scale a time value -/// @param left Left operand (a number) -/// @param right Right operand (a time) -/// @return @a left multiplied by @a right -EE_API Time operator*( double left, Time right ); +constexpr Time& operator+=( Time& left, Time right ) { + return left = left + right; +} -/// @relates EE::System::Time -/// @brief Overload of binary * operator to scale a time value -/// @param left Left operand (a number) -/// @param right Right operand (a time) -/// @return @a left multiplied by @a right -EE_API Time operator*( Int64 left, Time right ); +constexpr Time operator-( Time left, Time right ) { + return Microseconds( left.asMicroseconds() - right.asMicroseconds() ); +} -/// @relates EE::System::Time -/// @brief Overload of binary * operator to scale a time value -/// @param left Left operand (a time) -/// @param right Right operand (a number) -/// @return @a left multiplied by @a right -EE_API Time operator*( Time left, Int64 right ); +constexpr Time& operator-=( Time& left, Time right ) { + return left = left - right; +} -/// @relates EE::System::Time -/// @brief Overload of binary *= operator to scale/assign a time value -/// @param left Left operand (a time) -/// @param right Right operand (a number) -/// @return @a left multiplied by @a right -EE_API Time& operator*=( Time& left, double right ); +constexpr Time operator*( Time left, Time right ) { + return Microseconds( left.asMicroseconds() * right.asMicroseconds() ); +} -/// @relates EE::System::Time -/// @brief Overload of binary *= operator to scale/assign a time value -/// @param left Left operand (a time) -/// @param right Right operand (a number) -/// @return @a left multiplied by @a right -EE_API Time& operator*=( Time& left, Int64 right ); +constexpr Time operator*( Time left, double right ) { + return Seconds( left.asSeconds() * right ); +} -/// @relates EE::System::Time -/// @brief Overload of binary *= operator to scale/assign a time value -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return @a left multiplied by @a right -EE_API Time& operator*=( Time& left, Time right ); +constexpr Time operator*( double left, Time right ) { + return right * left; +} -/// @relates EE::System::Time -/// @brief Overload of binary / operator to scale a time value -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return @a left divided by @a right -EE_API Time operator/( Time left, Time right ); +constexpr Time operator*( Time left, Int64 right ) { + return Microseconds( left.asMicroseconds() * right ); +} -/// @relates EE::System::Time -/// @brief Overload of binary / operator to scale a time value -/// @param left Left operand (a time) -/// @param right Right operand (a number) -/// @return @a left divided by @a right -EE_API Time operator/( Time left, double right ); +constexpr Time operator*( Int64 left, Time right ) { + return right * left; +} -/// @relates EE::System::Time -/// @brief Overload of binary / operator to scale a time value -/// @param left Left operand (a time) -/// @param right Right operand (a number) -/// @return @a left divided by @a right -EE_API Time operator/( Time left, Int64 right ); +constexpr Time& operator*=( Time& left, Time right ) { + return left = left * right; +} -/// @relates EE::System::Time -/// @brief Overload of binary /= operator to scale/assign a time value -/// @param left Left operand (a time) -/// @param right Right operand (a number) -/// @return @a left divided by @a right -EE_API Time& operator/=( Time& left, Int64 right ); +constexpr Time& operator*=( Time& left, double right ) { + return left = left * right; +} -/// @relates EE::System::Time -/// @brief Overload of binary /= operator to scale/assign a time value -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return @a left divided by @a right -EE_API Time& operator/=( Time& left, Time right ); +constexpr Time& operator*=( Time& left, Int64 right ) { + return left = left * right; +} -/// @relates EE::System::Time -/// @brief Overload of binary % operator to compute remainder of a time value -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return @a left modulo @a right -EE_API Time operator%( Time left, Time right ); +constexpr Time operator/( Time left, Time right ) { + return Microseconds( left.asMicroseconds() / right.asMicroseconds() ); +} -/// @relates EE::System::Time -/// @brief Overload of binary %= operator to compute/assign remainder of a time value -/// @param left Left operand (a time) -/// @param right Right operand (a time) -/// @return @a left modulo @a right -EE_API Time& operator%=( Time& left, Time right ); +constexpr Time operator/( Time left, double right ) { + return Seconds( left.asSeconds() / right ); +} + +constexpr Time operator/( Time left, Int64 right ) { + return Microseconds( left.asMicroseconds() / right ); +} + +constexpr Time& operator/=( Time& left, Time right ) { + return left = left / right; +} + +constexpr Time& operator/=( Time& left, Int64 right ) { + return left = left / right; +} + +constexpr Time operator%( Time left, Time right ) { + return Microseconds( left.asMicroseconds() % right.asMicroseconds() ); +} + +constexpr Time& operator%=( Time& left, Time right ) { + return left = left % right; +} }} // namespace EE::System diff --git a/include/eepp/ui/doc/syntaxdefinition.hpp b/include/eepp/ui/doc/syntaxdefinition.hpp index 0956dce7a..38525fba9 100644 --- a/include/eepp/ui/doc/syntaxdefinition.hpp +++ b/include/eepp/ui/doc/syntaxdefinition.hpp @@ -36,6 +36,8 @@ class EE_API SyntaxDefinition { const std::string& getLanguageName() const; + std::string getLanguageNameForFileSystem() const; + const String::HashType& getLanguageId() const; const std::vector& getFiles() const; diff --git a/include/eepp/ui/uicodeeditor.hpp b/include/eepp/ui/uicodeeditor.hpp index 33d1e2510..3f7d1ddd9 100644 --- a/include/eepp/ui/uicodeeditor.hpp +++ b/include/eepp/ui/uicodeeditor.hpp @@ -696,6 +696,7 @@ class EE_API UICodeEditor : public UIWidget, public TextDocument::Client { Float mLongestLineWidth{ 0 }; Time mFindLongestLineWidthUpdateFrequency; Clock mLongestLineWidthLastUpdate; + Clock mLastActivity; TextSearchParams mHighlightWord; TextRanges mHighlightWordCache; Mutex mHighlightWordCacheMutex; diff --git a/projects/linux/ee.files b/projects/linux/ee.files index 32c8baa15..93290f423 100644 --- a/projects/linux/ee.files +++ b/projects/linux/ee.files @@ -620,6 +620,27 @@ ../../src/eepp/graphics/vertexbuffervbo.cpp ../../src/eepp/graphics/view.cpp ../../src/eepp/main/eepp_main.cpp +../../src/eepp/ui/doc/languages/batchscript.cpp +../../src/eepp/ui/doc/languages/batchscript.hpp +../../src/eepp/ui/doc/languages/css.cpp +../../src/eepp/ui/doc/languages/css.hpp +../../src/eepp/ui/doc/languages/d.cpp +../../src/eepp/ui/doc/languages/d.hpp +../../src/eepp/ui/doc/languages/htaccess.hpp +../../src/eepp/ui/doc/languages/objeck.hpp +../../src/eepp/ui/doc/languages/odin.cpp +../../src/eepp/ui/doc/languages/odin.hpp +../../src/eepp/ui/doc/languages/pascal.hpp +../../src/eepp/ui/doc/languages/perl.cpp +../../src/eepp/ui/doc/languages/perl.hpp +../../src/eepp/ui/doc/languages/pico-8.hpp +../../src/eepp/ui/doc/languages/postgresql.hpp +../../src/eepp/ui/doc/languages/rust.hpp +../../src/eepp/ui/doc/languages/sass.cpp +../../src/eepp/ui/doc/languages/solidity.cpp +../../src/eepp/ui/doc/languages/solidity.hpp +../../src/eepp/ui/doc/languages/sql.hpp +../../src/eepp/ui/doc/languages/x86assembly.hpp ../../src/modules/maps/src/eepp/maps/gameobject.cpp ../../src/modules/maps/src/eepp/maps/gameobjectobject.cpp ../../src/modules/maps/src/eepp/maps/gameobjectpolygon.cpp @@ -833,13 +854,27 @@ ../../src/eepp/ui/css/stylesheetvariable.cpp ../../src/eepp/ui/css/timingfunction.cpp ../../src/eepp/ui/css/transitiondefinition.cpp +../../src/eepp/ui/doc/languages/glsl.cpp +../../src/eepp/ui/doc/languages/glsl.hpp +../../src/eepp/ui/doc/languages/hlsl.cpp ../../src/eepp/ui/doc/languages/hlsl.hpp +../../src/eepp/ui/doc/languages/htaccess.cpp ../../src/eepp/ui/doc/languages/htaccess.hpp +../../src/eepp/ui/doc/languages/objeck.cpp ../../src/eepp/ui/doc/languages/objeck.hpp +../../src/eepp/ui/doc/languages/pascal.cpp ../../src/eepp/ui/doc/languages/pascal.hpp +../../src/eepp/ui/doc/languages/pico-8.cpp ../../src/eepp/ui/doc/languages/pico-8.hpp +../../src/eepp/ui/doc/languages/postgresql.cpp +../../src/eepp/ui/doc/languages/rust.cpp +../../src/eepp/ui/doc/languages/sass.hpp +../../src/eepp/ui/doc/languages/sql.cpp +../../src/eepp/ui/doc/languages/swift.cpp +../../src/eepp/ui/doc/languages/swift.hpp ../../src/eepp/ui/doc/languages/vb.cpp ../../src/eepp/ui/doc/languages/vb.hpp +../../src/eepp/ui/doc/languages/x86assembly.cpp ../../src/eepp/ui/doc/syntaxcolorscheme.cpp ../../src/eepp/ui/doc/syntaxdefinition.cpp ../../src/eepp/ui/doc/syntaxdefinitionmanager.cpp diff --git a/src/eepp/system/time.cpp b/src/eepp/system/time.cpp index fdecf0b8f..3fcc278b7 100644 --- a/src/eepp/system/time.cpp +++ b/src/eepp/system/time.cpp @@ -58,22 +58,6 @@ Time Time::fromString( const std::string& str ) { return time; } -Time::Time() : mMicroseconds( 0 ) {} - -double Time::asSeconds() const { - return mMicroseconds / 1000000.0; -} - -double Time::asMilliseconds() const { - return mMicroseconds / 1000.0; -} - -Int64 Time::asMicroseconds() const { - return mMicroseconds; -} - -Time::Time( Int64 Microseconds ) : mMicroseconds( Microseconds ) {} - std::string Time::toString() const { Uint64 totalSeconds = asSeconds(); @@ -101,124 +85,4 @@ std::string Time::toString() const { } } -Time Minutes( double amount ) { - return Time( static_cast( amount * 1000000 * 60 ) ); -} - -Time Seconds( double amount ) { - return Time( static_cast( amount * 1000000 ) ); -} - -Time Milliseconds( double amount ) { - return Time( static_cast( amount * 1000 ) ); -} - -Time Microseconds( Int64 amount ) { - return Time( amount ); -} - -bool operator==( Time left, Time right ) { - return left.asMicroseconds() == right.asMicroseconds(); -} - -bool operator!=( Time left, Time right ) { - return left.asMicroseconds() != right.asMicroseconds(); -} - -bool operator<( Time left, Time right ) { - return left.asMicroseconds() < right.asMicroseconds(); -} - -bool operator>( Time left, Time right ) { - return left.asMicroseconds() > right.asMicroseconds(); -} - -bool operator<=( Time left, Time right ) { - return left.asMicroseconds() <= right.asMicroseconds(); -} - -bool operator>=( Time left, Time right ) { - return left.asMicroseconds() >= right.asMicroseconds(); -} - -Time operator-( Time right ) { - return Microseconds( -right.asMicroseconds() ); -} - -Time operator+( Time left, Time right ) { - return Microseconds( left.asMicroseconds() + right.asMicroseconds() ); -} - -Time& operator+=( Time& left, Time right ) { - return left = left + right; -} - -Time operator-( Time left, Time right ) { - return Microseconds( left.asMicroseconds() - right.asMicroseconds() ); -} - -Time& operator-=( Time& left, Time right ) { - return left = left - right; -} - -Time operator*( Time left, Time right ) { - return Microseconds( left.asMicroseconds() * right.asMicroseconds() ); -} - -Time operator*( Time left, double right ) { - return Seconds( left.asSeconds() * right ); -} - -Time operator*( double left, Time right ) { - return right * left; -} - -Time operator*( Time left, Int64 right ) { - return Microseconds( left.asMicroseconds() * right ); -} - -Time operator*( Int64 left, Time right ) { - return right * left; -} - -Time& operator*=( Time& left, Time right ) { - return left = left * right; -} - -Time& operator*=( Time& left, double right ) { - return left = left * right; -} - -Time& operator*=( Time& left, Int64 right ) { - return left = left * right; -} - -Time operator/( Time left, Time right ) { - return Microseconds( left.asMicroseconds() / right.asMicroseconds() ); -} - -Time operator/( Time left, double right ) { - return Seconds( left.asSeconds() / right ); -} - -Time operator/( Time left, Int64 right ) { - return Microseconds( left.asMicroseconds() / right ); -} - -Time& operator/=( Time& left, Time right ) { - return left = left / right; -} - -Time& operator/=( Time& left, Int64 right ) { - return left = left / right; -} - -Time operator%( Time left, Time right ) { - return Microseconds( left.asMicroseconds() % right.asMicroseconds() ); -} - -Time& operator%=( Time& left, Time right ) { - return left = left % right; -} - }} // namespace EE::System diff --git a/src/eepp/ui/doc/languages/batchscript.cpp b/src/eepp/ui/doc/languages/batchscript.cpp new file mode 100644 index 000000000..cfef77304 --- /dev/null +++ b/src/eepp/ui/doc/languages/batchscript.cpp @@ -0,0 +1,148 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addBatchScript() { + + SyntaxDefinitionManager::instance()->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" }, + + }, + { + { "IF", "keyword" }, + { "if", "keyword" }, + { "FORFILES", "function" }, + { "CON", "keyword" }, + { "forfiles", "function" }, + { "cd", "function" }, + { "choice", "function" }, + { "command", "function" }, + { "shift", "function" }, + { "CMD", "function" }, + { "attrib", "function" }, + { "EXIT", "function" }, + { "for", "keyword" }, + { "com1", "keyword" }, + { "else", "keyword" }, + { "setlocal", "function" }, + { "in", "keyword" }, + { "SORT", "function" }, + { "FINDSTR", "function" }, + { "RMDIR", "function" }, + { "COMMAND", "function" }, + { "COM4", "keyword" }, + { "ren", "function" }, + { "ATTRIB", "function" }, + { "move", "function" }, + { "cmd", "function" }, + { "XCOPY", "function" }, + { "xcopy", "function" }, + { "COPY", "function" }, + { "findstr", "function" }, + { "ENDLOCAL", "function" }, + { "MOVE", "function" }, + { "ERRORLEVEL", "keyword" }, + { "copy", "function" }, + { "rmdir", "function" }, + { "RD", "function" }, + { "DEFINED", "keyword" }, + { "ECHO", "function" }, + { "DEL", "function" }, + { "echo", "function" }, + { "ENABLEDELAYEDEXPANSION", "function" }, + { "type", "function" }, + { "enabledelayedexpansion", "function" }, + { "TYPE", "function" }, + { "pause", "function" }, + { "set", "function" }, + { "CD", "function" }, + { "SETLOCAL", "function" }, + { "FIND", "function" }, + { "gtr", "keyword" }, + { "lpt1", "keyword" }, + { "chdir", "function" }, + { "LSS", "keyword" }, + { "lss", "keyword" }, + { "goto", "keyword" }, + { "GEQ", "keyword" }, + { "NEQ", "keyword" }, + { "LPT1", "keyword" }, + { "geq", "keyword" }, + { "defined", "keyword" }, + { "prn", "keyword" }, + { "del", "function" }, + { "VERIFY", "keyword" }, + { "verify", "keyword" }, + { "exist", "keyword" }, + { "DO", "keyword" }, + { "CALL", "keyword" }, + { "com4", "keyword" }, + { "EQU", "keyword" }, + { "COM1", "keyword" }, + { "GOTO", "keyword" }, + { "EXIST", "keyword" }, + { "SHIFT", "function" }, + { "equ", "keyword" }, + { "GTR", "keyword" }, + { "COM2", "keyword" }, + { "NUL", "keyword" }, + { "PRN", "keyword" }, + { "MD", "function" }, + { "COM3", "keyword" }, + { "LEQ", "keyword" }, + { "com2", "keyword" }, + { "nul", "keyword" }, + { "errorlevel", "keyword" }, + { "do", "keyword" }, + { "FOR", "keyword" }, + { "NOT", "keyword" }, + { "com3", "keyword" }, + { "call", "keyword" }, + { "not", "keyword" }, + { "ELSIF", "keyword" }, + { "ELSE", "keyword" }, + { "leq", "keyword" }, + { "exit", "function" }, + { "CHOICE", "function" }, + { "IN", "keyword" }, + { "cmdextversion", "keyword" }, + { "PAUSE", "function" }, + { "sort", "function" }, + { "CMDEXTVERSION", "keyword" }, + { "MKDIR", "function" }, + { "mkdir", "function" }, + { "CHDIR", "function" }, + { "rd", "function" }, + { "elsif", "keyword" }, + { "find", "function" }, + { "md", "function" }, + { "SET", "function" }, + { "endlocal", "function" }, + { "REN", "function" }, + { "neq", "keyword" }, + { "con", "keyword" }, + + }, + "rem", + {}, + "bat" } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/batchscript.hpp b/src/eepp/ui/doc/languages/batchscript.hpp new file mode 100644 index 000000000..de9f76e1e --- /dev/null +++ b/src/eepp/ui/doc/languages/batchscript.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Batchscript +#define EE_UI_DOC_Batchscript + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addBatchScript(); + +}}}} + +#endif diff --git a/src/eepp/ui/doc/languages/css.cpp b/src/eepp/ui/doc/languages/css.cpp new file mode 100644 index 000000000..a43ea478d --- /dev/null +++ b/src/eepp/ui/doc/languages/css.cpp @@ -0,0 +1,275 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addCSS() { + + SyntaxDefinitionManager::instance()->add( + + { "CSS", + { "%.css$" }, + { + { { "\\." }, "normal" }, + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "^%s*#[%a%_%-][%w%_%-]*" }, "keyword2" }, + { { ",%s*#[%a%_%-][%w%_%-]*" }, "keyword2" }, + { { "#%x%x%x%x?%x?%x?%x?%x?" }, "string" }, + { { "#[%a%_%-][%w%_%-]*" }, "keyword2" }, + { { "%-%-%a[%w%-%_]*" }, "keyword2" }, + { { "-?%d+[%d%.]*p[xt]" }, "number" }, + { { "-?%d+[%d%.]*deg" }, "number" }, + { { "-?%d+[%d%.]*" }, "number" }, + { { "@[%a][%w%_%-]*" }, "keyword2" }, + { { "%.[%a%_%-][%w%_%-]*" }, "keyword2" }, + { { "(:)(hover)" }, { "normal", "operator", "literal" } }, + { { "(:)(focus%-within)" }, { "normal", "operator", "literal" } }, + { { "(:)(focus)" }, { "normal", "operator", "literal" } }, + { { "(:)(selected)" }, { "normal", "operator", "literal" } }, + { { "(:)(pressed)" }, { "normal", "operator", "literal" } }, + { { "(:)(disabled)" }, { "normal", "operator", "literal" } }, + { { "(:)(checked)" }, { "normal", "operator", "literal" } }, + { { "(:)(root)" }, { "normal", "operator", "link" } }, + { { "(%a+)(%()" }, { "normal", "function", "normal" } }, + { { "[%a][%w-]*%s*%f[:]" }, "keyword" }, + { { "[{}:>~!]" }, "operator" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "orange", "literal" }, + { "tabwidget", "keyword" }, + { "olivedrab", "literal" }, + { "olive", "literal" }, + { "navajowhite", "literal" }, + { "mistyrose", "literal" }, + { "midnightblue", "literal" }, + { "darkseagreen", "literal" }, + { "mediumseagreen", "literal" }, + { "lavenderblush", "literal" }, + { "mediumaquamarine", "literal" }, + { "limegreen", "literal" }, + { "mediumspringgreen", "literal" }, + { "lightgreen", "literal" }, + { "lime", "literal" }, + { "mediumorchid", "literal" }, + { "gray", "literal" }, + { "black", "literal" }, + { "lightyellow", "literal" }, + { "mediumblue", "literal" }, + { "lightslategray", "literal" }, + { "lightseagreen", "literal" }, + { "tableview", "keyword" }, + { "input", "keyword" }, + { "lightpink", "literal" }, + { "lightslategrey", "literal" }, + { "lightgrey", "literal" }, + { "lightgoldenrodyellow", "literal" }, + { "lightblue", "literal" }, + { "lemonchiffon", "literal" }, + { "lawngreen", "literal" }, + { "mintcream", "literal" }, + { "pushbutton", "keyword" }, + { "khaki", "literal" }, + { "ivory", "literal" }, + { "moccasin", "literal" }, + { "indigo", "literal" }, + { "transparent", "literal" }, + { "oldlace", "literal" }, + { "indianred", "literal" }, + { "hotpink", "literal" }, + { "sizenwse", "literal" }, + { "honeydew", "literal" }, + { "false", "literal" }, + { "grey", "literal" }, + { "green", "literal" }, + { "cornflowerblue", "literal" }, + { "steelblue", "literal" }, + { "mediumturquoise", "literal" }, + { "lightgray", "literal" }, + { "goldenrod", "literal" }, + { "greenyellow", "literal" }, + { "saddlebrown", "literal" }, + { "lightcyan", "literal" }, + { "rlay", "keyword" }, + { "gainsboro", "literal" }, + { "hslider", "keyword" }, + { "fuchsia", "literal" }, + { "forestgreen", "literal" }, + { "palegoldenrod", "literal" }, + { "maroon", "literal" }, + { "floralwhite", "literal" }, + { "dodgerblue", "literal" }, + { "mediumvioletred", "literal" }, + { "dimgray", "literal" }, + { "peru", "literal" }, + { "deepskyblue", "literal" }, + { "textureregion", "keyword" }, + { "blue", "literal" }, + { "bisque", "literal" }, + { "slategray", "literal" }, + { "treeview", "keyword" }, + { "scrollbar", "keyword" }, + { "sizewe", "literal" }, + { "none", "literal" }, + { "image", "keyword" }, + { "checkbox", "keyword" }, + { "lavender", "literal" }, + { "cornsilk", "literal" }, + { "textinput", "keyword" }, + { "blueviolet", "literal" }, + { "skyblue", "literal" }, + { "darkslateblue", "literal" }, + { "lightsalmon", "literal" }, + { "a", "keyword" }, + { "widgettable", "keyword" }, + { "beige", "literal" }, + { "darkgray", "literal" }, + { "crimson", "literal" }, + { "menucheckbox", "keyword" }, + { "hscrollbar", "keyword" }, + { "dimgrey", "literal" }, + { "sizeall", "literal" }, + { "aliceblue", "literal" }, + { "progressbar", "keyword" }, + { "lightskyblue", "literal" }, + { "blanchedalmond", "literal" }, + { "darkslategray", "literal" }, + { "mediumpurple", "literal" }, + { "tomato", "literal" }, + { "paleturquoise", "literal" }, + { "darkturquoise", "literal" }, + { "powderblue", "literal" }, + { "codeeditor", "keyword" }, + { "wheat", "literal" }, + { "seashell", "literal" }, + { "hbox", "keyword" }, + { "sienna", "literal" }, + { "salmon", "literal" }, + { "menubar", "keyword" }, + { "silver", "literal" }, + { "tan", "literal" }, + { "thistle", "literal" }, + { "sandybrown", "literal" }, + { "turquoise", "literal" }, + { "azure", "literal" }, + { "plum", "literal" }, + { "vslider", "keyword" }, + { "waitarrow", "literal" }, + { "textview", "keyword" }, + { "springgreen", "literal" }, + { "widgettablerow", "keyword" }, + { "vscrollbar", "keyword" }, + { "wait", "literal" }, + { "relativelayout", "keyword" }, + { "palevioletred", "literal" }, + { "spinbox", "keyword" }, + { "darkblue", "literal" }, + { "linearlayout", "keyword" }, + { "chartreuse", "literal" }, + { "teal", "literal" }, + { "darkorchid", "literal" }, + { "seagreen", "literal" }, + { "listview", "keyword" }, + { "red", "literal" }, + { "selectbutton", "keyword" }, + { "viewpagerhorizontal", "keyword" }, + { "vbox", "keyword" }, + { "slategrey", "literal" }, + { "gridlayout", "keyword" }, + { "listbox", "keyword" }, + { "peachpuff", "literal" }, + { "coral", "literal" }, + { "stacklayout", "keyword" }, + { "center", "literal" }, + { "lightcoral", "literal" }, + { "rosybrown", "literal" }, + { "viewpager", "keyword" }, + { "tab", "keyword" }, + { "inputpassword", "keyword" }, + { "window", "keyword" }, + { "tooltip", "keyword" }, + { "scrollview", "keyword" }, + { "stackwidget", "keyword" }, + { "textedit", "keyword" }, + { "loader", "keyword" }, + { "combobox", "keyword" }, + { "radiobutton", "keyword" }, + { "dropdownlist", "keyword" }, + { "splitter", "keyword" }, + { "snow", "literal" }, + { "palegreen", "literal" }, + { "anchor", "keyword" }, + { "royalblue", "literal" }, + { "slider", "keyword" }, + { "violet", "literal" }, + { "whitesmoke", "literal" }, + { "white", "literal" }, + { "darksalmon", "literal" }, + { "pink", "literal" }, + { "slateblue", "literal" }, + { "darkred", "literal" }, + { "lightsteelblue", "literal" }, + { "darkolivegreen", "literal" }, + { "darkviolet", "literal" }, + { "yellowgreen", "literal" }, + { "widget", "keyword" }, + { "linen", "literal" }, + { "darkgrey", "literal" }, + { "menuradiobutton", "keyword" }, + { "crosshair", "literal" }, + { "darkcyan", "literal" }, + { "sprite", "keyword" }, + { "navy", "literal" }, + { "darkmagenta", "literal" }, + { "burlywood", "literal" }, + { "menuseparator", "keyword" }, + { "firebrick", "literal" }, + { "orchid", "literal" }, + { "chocolate", "literal" }, + { "darkgreen", "literal" }, + { "aquamarine", "literal" }, + { "ghostwhite", "literal" }, + { "arrow", "literal" }, + { "antiquewhite", "literal" }, + { "deeppink", "literal" }, + { "yellow", "literal" }, + { "console", "keyword" }, + { "cadetblue", "literal" }, + { "touchdraggable", "keyword" }, + { "gold", "literal" }, + { "darkkhaki", "literal" }, + { "viewpagervertical", "keyword" }, + { "mediumslateblue", "literal" }, + { "aqua", "literal" }, + { "brown", "literal" }, + { "cyan", "literal" }, + { "darkgoldenrod", "literal" }, + { "papayawhip", "literal" }, + { "hand", "literal" }, + { "purple", "literal" }, + { "tv", "keyword" }, + { "sizenesw", "literal" }, + { "darkslategrey", "literal" }, + { "button", "keyword" }, + { "nocursor", "literal" }, + { "orangered", "literal" }, + { "ibeam", "literal" }, + { "darkorange", "literal" }, + { "true", "literal" }, + { "sizens", "literal" }, + { "magenta", "literal" }, + { "textinputpassword", "keyword" }, + { "important", "literal" }, + + }, + "", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/css.hpp b/src/eepp/ui/doc/languages/css.hpp new file mode 100644 index 000000000..d04b12e6f --- /dev/null +++ b/src/eepp/ui/doc/languages/css.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Css +#define EE_UI_DOC_Css + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addCSS(); + +}}}} + +#endif diff --git a/src/eepp/ui/doc/languages/d.cpp b/src/eepp/ui/doc/languages/d.cpp new file mode 100644 index 000000000..5797a1312 --- /dev/null +++ b/src/eepp/ui/doc/languages/d.cpp @@ -0,0 +1,148 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addD() { + + SyntaxDefinitionManager::instance()->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" }, + + }, + { + { "new", "keyword" }, + { "invariant", "keyword" }, + { "static", "keyword" }, + { "module", "keyword" }, + { "mixin", "keyword" }, + { "interface", "keyword" }, + { "catch", "keyword" }, + { "macro", "keyword" }, + { "package", "keyword" }, + { "ireal", "keyword2" }, + { "foreach", "keyword" }, + { "int", "keyword2" }, + { "immutable", "keyword" }, + { "final", "keyword" }, + { "ifloat", "keyword2" }, + { "lazy", "keyword" }, + { "do", "keyword" }, + { "goto", "keyword" }, + { "__parameters", "keyword" }, + { "function", "keyword" }, + { "delegate", "keyword" }, + { "import", "keyword" }, + { "long", "keyword2" }, + { "continue", "keyword" }, + { "idouble", "keyword2" }, + { "ref", "keyword" }, + { "for", "keyword" }, + { "float", "keyword2" }, + { "version", "keyword" }, + { "finally", "keyword" }, + { "if", "keyword" }, + { "extern", "keyword" }, + { "in", "keyword" }, + { "break", "keyword" }, + { "else", "keyword" }, + { "__vector", "keyword" }, + { "false", "literal" }, + { "export", "keyword" }, + { "byte", "keyword2" }, + { "enum", "keyword" }, + { "cast", "keyword" }, + { "case", "keyword" }, + { "auto", "keyword" }, + { "null", "literal" }, + { "__MODULE__", "keyword" }, + { "asm", "keyword" }, + { "double", "keyword2" }, + { "default", "keyword" }, + { "inout", "keyword" }, + { "pragma", "keyword" }, + { "while", "keyword" }, + { "protected", "keyword" }, + { "pure", "keyword" }, + { "scope", "keyword" }, + { "override", "keyword" }, + { "shared", "keyword" }, + { "real", "keyword2" }, + { "short", "keyword2" }, + { "struct", "keyword" }, + { "uint", "keyword2" }, + { "return", "keyword" }, + { "super", "keyword" }, + { "throw", "keyword" }, + { "__traits", "keyword" }, + { "ubyte", "keyword2" }, + { "true", "literal" }, + { "__FUNCTION__", "keyword" }, + { "this", "keyword" }, + { "__FILE_FULL_PATH__", "keyword" }, + { "void", "keyword" }, + { "__FILE__", "keyword" }, + { "switch", "keyword" }, + { "ucent", "keyword2" }, + { "ushort", "keyword2" }, + { "with", "keyword" }, + { "typeof", "keyword" }, + { "typeid", "keyword" }, + { "ulong", "keyword2" }, + { "out", "keyword" }, + { "nothrow", "keyword" }, + { "char", "keyword2" }, + { "synchronized", "keyword" }, + { "debug", "keyword" }, + { "assert", "keyword" }, + { "foreach_reverse", "keyword" }, + { "unittest", "keyword" }, + { "dchar", "keyword2" }, + { "__PRETTY_FUNCTION__", "keyword" }, + { "class", "keyword" }, + { "cent", "keyword2" }, + { "align", "keyword" }, + { "__LINE__", "keyword" }, + { "cdouble", "keyword2" }, + { "abstract", "keyword" }, + { "__gshared", "keyword" }, + { "alias", "keyword" }, + { "deprecated", "keyword" }, + { "body", "keyword" }, + { "wchar", "keyword2" }, + { "template", "keyword" }, + { "is", "keyword" }, + { "private", "keyword" }, + { "creal", "keyword2" }, + { "cfloat", "keyword2" }, + { "try", "keyword" }, + { "bool", "keyword2" }, + { "public", "keyword" }, + { "union", "keyword" }, + { "const", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/d.hpp b/src/eepp/ui/doc/languages/d.hpp new file mode 100644 index 000000000..73329dfaf --- /dev/null +++ b/src/eepp/ui/doc/languages/d.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_D +#define EE_UI_DOC_D + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addD(); + +}}}} + +#endif diff --git a/src/eepp/ui/doc/languages/glsl.cpp b/src/eepp/ui/doc/languages/glsl.cpp new file mode 100644 index 000000000..a8fd59e24 --- /dev/null +++ b/src/eepp/ui/doc/languages/glsl.cpp @@ -0,0 +1,373 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addGLSL() { + + SyntaxDefinitionManager::instance()->add( + + { "GLSL", + { "%.glsl$", "%.frag$", "%.vert$", "%.fs$", "%.vs$" }, + { + { { "//.-\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" }, + + }, + { + { "atomicExchange", "keyword" }, + { "atomicXor", "keyword" }, + { "imageAtomicMax", "keyword" }, + { "atomicAnd", "keyword" }, + { "step", "keyword" }, + { "uimage2DArray", "keyword2" }, + { "atomicMax", "keyword" }, + { "atomicCounterCompSwap", "keyword" }, + { "atomicCounterExchange", "keyword" }, + { "atomicCounterXor", "keyword" }, + { "atomicMin", "keyword" }, + { "atomicCounterMax", "keyword" }, + { "utexture2DMSArray", "keyword" }, + { "atomicCounterMin", "keyword" }, + { "atomicCounterSubtract", "keyword" }, + { "textureProjGradOffset", "keyword" }, + { "textureGather", "keyword" }, + { "utextureBuffer", "keyword" }, + { "textureProjGrad", "keyword" }, + { "textureGrad", "keyword" }, + { "sampler2DMS", "keyword2" }, + { "textureProjLodOffset", "keyword" }, + { "textureProjLod", "keyword" }, + { "textureLodOffset", "keyword" }, + { "dFdy", "keyword" }, + { "textureOffset", "keyword" }, + { "textureProj", "keyword" }, + { "uaddCarry", "keyword" }, + { "patch", "keyword" }, + { "textureLod", "keyword" }, + { "imageSize", "keyword" }, + { "texture", "keyword" }, + { "sample", "keyword" }, + { "textureQueryLod", "keyword" }, + { "bitCount", "keyword" }, + { "bitfieldExtract", "keyword" }, + { "umulExtended", "keyword" }, + { "memoryBarrierImage", "keyword" }, + { "usubBorrow", "keyword" }, + { "atomicCounterAdd", "keyword" }, + { "interpolateAtOffset", "keyword" }, + { "not", "keyword" }, + { "bitfieldReverse", "keyword" }, + { "textureGatherOffset", "keyword" }, + { "equal", "keyword" }, + { "greaterThanEqual", "keyword" }, + { "greaterThan", "keyword" }, + { "lessThanEqual", "keyword" }, + { "isampler1D", "keyword2" }, + { "atomicCompSwap", "keyword" }, + { "lessThan", "keyword" }, + { "determinant", "keyword" }, + { "imageAtomicAdd", "keyword" }, + { "isampler1DArray", "keyword2" }, + { "matrixCompMult", "keyword" }, + { "floatBitsToInt", "keyword" }, + { "refract", "keyword" }, + { "imageAtomicMin", "keyword" }, + { "faceforward", "keyword" }, + { "ftransform", "keyword" }, + { "sqrt", "keyword" }, + { "cross", "keyword" }, + { "abs", "keyword" }, + { "packDouble2x32", "keyword" }, + { "unpackSnorm4x8", "keyword" }, + { "utexture1DArray", "keyword" }, + { "unpackUnorm4x8", "keyword" }, + { "texture1DArray", "keyword" }, + { "packUnorm2x16", "keyword" }, + { "frexp", "keyword" }, + { "fma", "keyword" }, + { "isnan", "keyword" }, + { "mix", "keyword" }, + { "exp2", "keyword" }, + { "isampler3D", "keyword2" }, + { "false", "literal" }, + { "sampler2DMSArray", "keyword2" }, + { "packHalf2x16", "keyword" }, + { "sampler2DArrayShadow", "keyword2" }, + { "lowp", "keyword" }, + { "length", "keyword" }, + { "imageLoad", "keyword" }, + { "imulExtended", "keyword" }, + { "smooth", "keyword" }, + { "sampler1DShadow", "keyword2" }, + { "utexture2DArray", "keyword" }, + { "isampler2D", "keyword2" }, + { "iimage1D", "keyword2" }, + { "uimageCubeArray", "keyword2" }, + { "memoryBarrierAtomicCounter", "keyword" }, + { "utexture2DMS", "keyword" }, + { "tanh", "keyword" }, + { "atomicCounterAnd", "keyword" }, + { "invariant", "keyword" }, + { "layout", "keyword" }, + { "imageStore", "keyword" }, + { "sampler2DRectShadow", "keyword2" }, + { "fwidth", "keyword" }, + { "volatile", "keyword" }, + { "imageBuffer", "keyword2" }, + { "usampler1DArray", "keyword2" }, + { "usampler2DArray", "keyword2" }, + { "utextureCubeArray", "keyword" }, + { "findLSB", "keyword" }, + { "texelFetch", "keyword" }, + { "dot", "keyword" }, + { "atomicOr", "keyword" }, + { "isinf", "keyword" }, + { "imageCube", "keyword2" }, + { "true", "literal" }, + { "texture1D", "keyword" }, + { "inverse", "keyword" }, + { "dFdyFine", "keyword" }, + { "memoryBarrierShared", "keyword" }, + { "atomicCounterOr", "keyword" }, + { "usampler1D", "keyword2" }, + { "uniform", "keyword" }, + { "image1DArray", "keyword2" }, + { "writeonly", "keyword" }, + { "itexture2DRect", "keyword" }, + { "precision", "keyword" }, + { "imageSamples", "keyword" }, + { "isampler2DMSArray", "keyword2" }, + { "dFdx", "keyword" }, + { "image1D", "keyword2" }, + { "atomicCounterIncrement", "keyword" }, + { "image2D", "keyword2" }, + { "image2DArray", "keyword2" }, + { "any", "keyword" }, + { "uimageCube", "keyword2" }, + { "iimage2DArray", "keyword2" }, + { "memoryBarrierBuffer", "keyword" }, + { "allInvocationsEqual", "keyword" }, + { "sampler3D", "keyword2" }, + { "subpassLoad", "keyword" }, + { "itexture2D", "keyword" }, + { "image2DMS", "keyword2" }, + { "itexture1DArray", "keyword" }, + { "centroid", "keyword" }, + { "dFdyCoarse", "keyword" }, + { "texture2DArray", "keyword" }, + { "iimage2DRect", "keyword2" }, + { "utexture2D", "keyword" }, + { "texture3D", "keyword" }, + { "itextureCube", "keyword" }, + { "degrees", "keyword" }, + { "texture2DMS", "keyword" }, + { "itexture2DMS", "keyword" }, + { "iimage2DMS", "keyword2" }, + { "isubpassInput", "keyword2" }, + { "imageAtomicXor", "keyword" }, + { "samplerShadow", "keyword2" }, + { "iimage2D", "keyword2" }, + { "usampler3D", "keyword2" }, + { "itexture2DMSArray", "keyword" }, + { "sin", "keyword" }, + { "utexture2DRect", "keyword" }, + { "do", "keyword" }, + { "groupMemoryBarrier", "keyword" }, + { "image3D", "keyword2" }, + { "usubpassInput", "keyword2" }, + { "isampler2DMS", "keyword2" }, + { "samplerBuffer", "keyword2" }, + { "texture2DRect", "keyword" }, + { "while", "keyword" }, + { "memoryBarrier", "keyword" }, + { "samplerCubeArrayShadow", "keyword2" }, + { "outerProduct", "keyword" }, + { "interpolateAtCentroid", "keyword" }, + { "subpassInput", "keyword2" }, + { "noperspective", "keyword" }, + { "textureBuffer", "keyword" }, + { "EmitVertex", "keyword" }, + { "usubpassInputMS", "keyword2" }, + { "iimageCubeArray", "keyword2" }, + { "interpolateAtSample", "keyword" }, + { "const", "keyword" }, + { "uimage2DMSArray", "keyword2" }, + { "uimage1D", "keyword2" }, + { "texture2D", "keyword" }, + { "subpassInputMS", "keyword2" }, + { "textureGatherOffsets", "keyword" }, + { "EmitStreamVertex", "keyword" }, + { "precise", "keyword" }, + { "uimage2DRect", "keyword2" }, + { "textureCube", "keyword" }, + { "uimage2DMS", "keyword2" }, + { "EndPrimitive", "keyword" }, + { "utexture3D", "keyword" }, + { "utextureCube", "keyword" }, + { "fwidthCoarse", "keyword" }, + { "varying", "keyword" }, + { "itexture1D", "keyword" }, + { "dFdxCoarse", "keyword" }, + { "imageCubeArray", "keyword2" }, + { "image2DMSArray", "keyword2" }, + { "dFdxFine", "keyword" }, + { "EndStreamPrimitive", "keyword" }, + { "imageAtomicExchange", "keyword" }, + { "imageAtomicAnd", "keyword" }, + { "imageAtomicOr", "keyword" }, + { "allInvocations", "keyword" }, + { "imageAtomicCompSwap", "keyword" }, + { "highp", "keyword" }, + { "fwidthFine", "keyword" }, + { "cos", "keyword" }, + { "texture2DMSArray", "keyword" }, + { "radians", "keyword" }, + { "itexture3D", "keyword" }, + { "modf", "keyword" }, + { "unpackDouble2x32", "keyword" }, + { "usampler2DMSArray", "keyword2" }, + { "acos", "keyword" }, + { "smoothstep", "keyword" }, + { "atomicCounterDecrement", "keyword" }, + { "iimageCube", "keyword2" }, + { "uimage3D", "keyword2" }, + { "samplerCube", "keyword2" }, + { "mod", "keyword" }, + { "clamp", "keyword" }, + { "isubpassInputMS", "keyword2" }, + { "textureGradOffset", "keyword" }, + { "asin", "keyword" }, + { "attribute", "keyword" }, + { "sampler2DArray", "keyword2" }, + { "image2DRect", "keyword2" }, + { "notEqual", "keyword" }, + { "log2", "keyword" }, + { "readonly", "keyword" }, + { "uimageBuffer", "keyword2" }, + { "floatBitsToUint", "keyword" }, + { "itextureBuffer", "keyword" }, + { "iimage3D", "keyword2" }, + { "packUnorm4x8", "keyword" }, + { "inout", "keyword" }, + { "return", "keyword" }, + { "uimage1DArray", "keyword2" }, + { "min", "keyword" }, + { "samplerCubeArray", "keyword2" }, + { "texelFetchOffset", "keyword" }, + { "sampler", "keyword2" }, + { "float", "keyword2" }, + { "uintBitsToFloat", "keyword" }, + { "int", "keyword2" }, + { "mediump", "keyword" }, + { "subroutine", "keyword" }, + { "distance", "keyword" }, + { "reflect", "keyword" }, + { "usampler2D", "keyword2" }, + { "all", "keyword" }, + { "intBitsToFloat", "keyword" }, + { "out", "keyword" }, + { "double", "keyword2" }, + { "usamplerBuffer", "keyword2" }, + { "atomicCounter", "keyword" }, + { "if", "keyword" }, + { "tan", "keyword" }, + { "continue", "keyword" }, + { "in", "keyword" }, + { "atan", "keyword" }, + { "else", "keyword" }, + { "switch", "keyword" }, + { "bool", "keyword2" }, + { "anyInvocation", "keyword" }, + { "usampler2DRect", "keyword2" }, + { "packSnorm2x16", "keyword" }, + { "textureProjOffset", "keyword" }, + { "usamplerCube", "keyword2" }, + { "atomicAdd", "keyword" }, + { "shared", "keyword" }, + { "textureSamples", "keyword" }, + { "iimageBuffer", "keyword2" }, + { "iimage1DArray", "keyword2" }, + { "inversesqrt", "keyword" }, + { "itexture2DArray", "keyword" }, + { "barrier", "keyword" }, + { "textureCubeArray", "keyword" }, + { "usampler2DMS", "keyword2" }, + { "atomic_uint", "keyword2" }, + { "itextureCubeArray", "keyword" }, + { "fract", "keyword" }, + { "flat", "keyword" }, + { "samplerCubeShadow", "keyword2" }, + { "sampler1DArrayShadow", "keyword2" }, + { "isampler2DRect", "keyword2" }, + { "ldexp", "keyword" }, + { "for", "keyword" }, + { "normalize", "keyword" }, + { "buffer", "keyword" }, + { "sampler1DArray", "keyword2" }, + { "sampler2DRect", "keyword2" }, + { "void", "keyword" }, + { "acosh", "keyword" }, + { "sign", "keyword" }, + { "packSnorm4x8", "keyword" }, + { "case", "keyword" }, + { "bitfieldInsert", "keyword" }, + { "isamplerCube", "keyword2" }, + { "unpackHalf2x16", "keyword" }, + { "isampler2DArray", "keyword2" }, + { "uimage2D", "keyword2" }, + { "unpackSnorm2x16", "keyword" }, + { "default", "keyword" }, + { "transpose", "keyword" }, + { "findMSB", "keyword" }, + { "coherent", "keyword" }, + { "exp", "keyword" }, + { "utexture1D", "keyword" }, + { "sampler1D", "keyword2" }, + { "struct", "keyword" }, + { "uint", "keyword2" }, + { "NULL", "literal" }, + { "unpackUnorm2x16", "keyword" }, + { "break", "keyword" }, + { "textureQueryLevels", "keyword" }, + { "sampler2DShadow", "keyword2" }, + { "sinh", "keyword" }, + { "isamplerBuffer", "keyword2" }, + { "sampler2D", "keyword2" }, + { "iimage2DMSArray", "keyword2" }, + { "cosh", "keyword" }, + { "asinh", "keyword" }, + { "pow", "keyword" }, + { "floor", "keyword" }, + { "trunc", "keyword" }, + { "textureSize", "keyword" }, + { "round", "keyword" }, + { "roundEven", "keyword" }, + { "max", "keyword" }, + { "ceil", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/glsl.hpp b/src/eepp/ui/doc/languages/glsl.hpp new file mode 100644 index 000000000..7336cfbe1 --- /dev/null +++ b/src/eepp/ui/doc/languages/glsl.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Glsl +#define EE_UI_DOC_Glsl + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addGLSL(); + +}}}} + +#endif diff --git a/src/eepp/ui/doc/languages/odin.cpp b/src/eepp/ui/doc/languages/odin.cpp new file mode 100644 index 000000000..330063f3a --- /dev/null +++ b/src/eepp/ui/doc/languages/odin.cpp @@ -0,0 +1,147 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addOdin() { + + SyntaxDefinitionManager::instance()->add( + + { "Odin", + { "%.odin$" }, + { + { { "//.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "`", "`" }, "string" }, + { { "0b[01_]+" }, "number" }, + { { "0o[0-7_]+" }, "number" }, + { { "0[dz][%d_]+" }, "number" }, + { { "0x[%da-fA-F_]+" }, "number" }, + { { "-?%d+[%d%._e]*i?" }, "number" }, + { { "[<>~=+-*/]=" }, "operator" }, + { { "[%+%-=/%*%^%%<>!~|&:]" }, "operator" }, + { { "%$[%a_][%w_]*" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[#@][%a_][%w_]*" }, "keyword2" }, + { { "[#@]%b()" }, "keyword2" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "typeid", "keyword2" }, + { "i64be", "keyword2" }, + { "conj", "keyword2" }, + { "i32le", "keyword2" }, + { "rawptr", "keyword2" }, + { "real", "keyword2" }, + { "typeid_of", "keyword2" }, + { "type_info_of", "keyword2" }, + { "offset_of", "keyword2" }, + { "i64le", "keyword2" }, + { "align_of", "keyword2" }, + { "f32", "keyword2" }, + { "min", "keyword2" }, + { "u64", "keyword2" }, + { "cap", "keyword2" }, + { "cstring", "keyword2" }, + { "len", "keyword2" }, + { "byte", "keyword2" }, + { "transmute", "keyword2" }, + { "proc", "keyword" }, + { "any", "keyword2" }, + { "clamp", "keyword2" }, + { "auto_cast", "keyword2" }, + { "uintptr", "keyword2" }, + { "u16le", "keyword2" }, + { "complex", "keyword2" }, + { "const", "keyword" }, + { "union", "keyword" }, + { "u32", "keyword2" }, + { "opaque", "keyword" }, + { "type_info_base", "keyword2" }, + { "defer", "keyword" }, + { "max", "keyword2" }, + { "do", "keyword" }, + { "for", "keyword" }, + { "macro", "keyword" }, + { "package", "keyword" }, + { "bit_set", "keyword" }, + { "switch", "keyword" }, + { "no_inline", "keyword" }, + { "quaternion256", "keyword2" }, + { "if", "keyword" }, + { "case", "keyword" }, + { "foreign", "keyword" }, + { "not_in", "keyword" }, + { "inline", "keyword" }, + { "import", "keyword" }, + { "u8", "keyword2" }, + { "nil", "literal" }, + { "i16", "keyword2" }, + { "swizzle", "keyword2" }, + { "u16", "keyword2" }, + { "false", "literal" }, + { "f16", "keyword2" }, + { "distinct", "keyword" }, + { "rune", "keyword2" }, + { "i16le", "keyword2" }, + { "b64", "keyword2" }, + { "i128le", "keyword2" }, + { "quaternion128", "keyword2" }, + { "u16be", "keyword2" }, + { "i32be", "keyword2" }, + { "u128be", "keyword2" }, + { "i16be", "keyword2" }, + { "u32be", "keyword2" }, + { "complex64", "keyword2" }, + { "b8", "keyword2" }, + { "b32", "keyword2" }, + { "i32", "keyword2" }, + { "assert", "keyword2" }, + { "complex128", "keyword2" }, + { "complex32", "keyword2" }, + { "return", "keyword" }, + { "u128", "keyword2" }, + { "b128", "keyword2" }, + { "i128be", "keyword2" }, + { "i8", "keyword2" }, + { "int", "keyword2" }, + { "i64", "keyword2" }, + { "bool", "keyword2" }, + { "imag", "keyword2" }, + { "u64be", "keyword2" }, + { "true", "literal" }, + { "context", "keyword" }, + { "dynamic", "keyword" }, + { "string", "keyword2" }, + { "i128", "keyword2" }, + { "when", "keyword" }, + { "u32le", "keyword2" }, + { "size_of", "keyword2" }, + { "u64le", "keyword2" }, + { "type_of", "keyword2" }, + { "using", "keyword" }, + { "map", "keyword" }, + { "uint", "keyword2" }, + { "struct", "keyword" }, + { "cast", "keyword2" }, + { "enum", "keyword" }, + { "abs", "keyword2" }, + { "f64", "keyword2" }, + { "u128le", "keyword2" }, + { "continue", "keyword" }, + { "fallthrough", "keyword" }, + { "in", "keyword" }, + { "break", "keyword" }, + { "else", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/odin.hpp b/src/eepp/ui/doc/languages/odin.hpp new file mode 100644 index 000000000..62b431aa4 --- /dev/null +++ b/src/eepp/ui/doc/languages/odin.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Odin +#define EE_UI_DOC_Odin + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addOdin(); + +}}}} + +#endif diff --git a/src/eepp/ui/doc/languages/perl.cpp b/src/eepp/ui/doc/languages/perl.cpp new file mode 100644 index 000000000..e0385d66f --- /dev/null +++ b/src/eepp/ui/doc/languages/perl.cpp @@ -0,0 +1,269 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addPerl() { + + SyntaxDefinitionManager::instance()->add( + + { "Perl", + { "%.pm$", "%.pl$" }, + { + { { "%#.-\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "-?%d+[%d%.eE]*" }, "number" }, + { { "-?%.?%d+" }, "number" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%@%$%*]+[%a_][%w_]*" }, "keyword2" }, + { { "%--[%a_][%w_]*" }, "symbol" }, + + }, + { + { "atan2", "keyword" }, + { "endhostent", "keyword" }, + { "sysread", "keyword" }, + { "last", "keyword" }, + { "alarm", "keyword" }, + { "getpwnam", "keyword" }, + { "syscall", "keyword" }, + { "prototype", "keyword" }, + { "abs", "keyword" }, + { "umask", "keyword" }, + { "symlink", "keyword" }, + { "dbmclose", "keyword" }, + { "printf", "keyword" }, + { "endpwent", "keyword" }, + { "substr", "keyword" }, + { "print", "keyword" }, + { "sysseek", "keyword" }, + { "caller", "keyword" }, + { "sysopen", "keyword" }, + { "getlogin", "keyword" }, + { "-d", "keyword" }, + { "-x", "keyword" }, + { "chmod", "keyword" }, + { "getpgrp", "keyword" }, + { "study", "keyword" }, + { "pos", "keyword" }, + { "gethostent", "keyword" }, + { "sort", "keyword" }, + { "state", "keyword" }, + { "pop", "keyword" }, + { "seekdir", "keyword" }, + { "gethostbyname", "keyword" }, + { "getc", "keyword" }, + { "-W", "keyword" }, + { "-w", "keyword" }, + { "eof$", "keyword" }, + { "pack", "keyword" }, + { "-u", "keyword" }, + { "sprintf", "keyword" }, + { "AUTOLOAD", "keyword" }, + { "die", "keyword" }, + { "-t", "keyword" }, + { "ord", "keyword" }, + { "-T", "keyword" }, + { "-M", "keyword" }, + { "split", "keyword" }, + { "-s", "keyword" }, + { "lcfirst", "keyword" }, + { "open", "keyword" }, + { "getpeername", "keyword" }, + { "quotemeta", "keyword" }, + { "srand", "keyword" }, + { "-S", "keyword" }, + { "oct", "keyword" }, + { "format", "keyword" }, + { "-b", "keyword" }, + { "socketpair", "keyword" }, + { "getgrent", "keyword" }, + { "-R", "keyword" }, + { "not", "keyword" }, + { "-e", "keyword" }, + { "-r", "keyword" }, + { "lstat", "keyword" }, + { "pipe", "keyword" }, + { "flock", "keyword" }, + { "endprotoent", "keyword" }, + { "-X", "keyword" }, + { "system", "keyword" }, + { "select", "keyword" }, + { "localtime", "keyword" }, + { "index", "keyword" }, + { "getnetbyaddr", "keyword" }, + { "next", "keyword" }, + { "local", "keyword" }, + { "fork", "keyword" }, + { "length", "keyword" }, + { "getnetbyname", "keyword" }, + { "setpwent", "keyword" }, + { "shift", "keyword" }, + { "map", "keyword" }, + { "readline", "keyword" }, + { "-k", "keyword" }, + { "splice", "keyword" }, + { "setpgrp", "keyword" }, + { "setprotoent", "keyword" }, + { "endservent", "keyword" }, + { "UNITCHECK", "keyword" }, + { "-c", "keyword" }, + { "-f", "keyword" }, + { "keys", "keyword" }, + { "kill", "keyword" }, + { "lc", "keyword" }, + { "msgsnd", "keyword" }, + { "dump", "keyword" }, + { "-l", "keyword" }, + { "-z", "keyword" }, + { "syswrite", "keyword" }, + { "shutdown", "keyword" }, + { "bind", "keyword" }, + { "CHECK", "keyword" }, + { "setnetent", "keyword" }, + { "sqrt", "keyword" }, + { "setsockopt", "keyword" }, + { "getnetent", "keyword" }, + { "-p", "keyword" }, + { "BEGIN", "keyword" }, + { "waitpid", "keyword" }, + { "-B", "keyword" }, + { "scalar", "keyword" }, + { "gethostbyaddr", "keyword" }, + { "bless", "keyword" }, + { "getprotobyname", "keyword" }, + { "tie", "keyword" }, + { "say", "keyword" }, + { "each", "keyword" }, + { "telldir", "keyword" }, + { "recv", "keyword" }, + { "chr", "keyword" }, + { "getpwuid", "keyword" }, + { "getservbyname", "keyword" }, + { "return", "keyword" }, + { "rename", "keyword" }, + { "getservbyport", "keyword" }, + { "unshift", "keyword" }, + { "truncate", "keyword" }, + { "getservent", "keyword" }, + { "ucfirst", "keyword" }, + { "rindex", "keyword" }, + { "time", "keyword" }, + { "chdir", "keyword" }, + { "chown", "keyword" }, + { "unlink", "keyword" }, + { "getpwent", "keyword" }, + { "undef", "keyword" }, + { "cos", "keyword" }, + { "utime", "keyword" }, + { "END", "keyword" }, + { "unpack", "keyword" }, + { "untie", "keyword" }, + { "semop", "keyword" }, + { "setgrent", "keyword" }, + { "getsockname", "keyword" }, + { "ioctl", "keyword" }, + { "getprotoent", "keyword" }, + { "times", "keyword" }, + { "defined", "keyword" }, + { "opendir", "keyword" }, + { "use", "keyword" }, + { "readpipe", "keyword" }, + { "chomp", "keyword" }, + { "sub", "keyword" }, + { "rmdir", "keyword" }, + { "delete", "keyword" }, + { "gmtime", "keyword" }, + { "connect", "keyword" }, + { "join", "keyword" }, + { "grep", "keyword" }, + { "DESTROY", "keyword" }, + { "read", "keyword" }, + { "sethostent", "keyword" }, + { "fileno", "keyword" }, + { "redo", "keyword" }, + { "hex", "keyword" }, + { "int", "keyword" }, + { "ref", "keyword" }, + { "INIT", "keyword" }, + { "semget", "keyword" }, + { "close", "keyword" }, + { "SUPER", "keyword" }, + { "reset", "keyword" }, + { "warn", "keyword" }, + { "glob", "keyword" }, + { "closedir", "keyword" }, + { "goto", "keyword" }, + { "rewinddir", "keyword" }, + { "tied", "keyword" }, + { "push", "keyword" }, + { "getsockopt", "keyword" }, + { "readlink", "keyword" }, + { "require", "keyword" }, + { "getprotobynumber", "keyword" }, + { "crypt", "keyword" }, + { "tell", "keyword" }, + { "exists", "keyword" }, + { "getgrgid", "keyword" }, + { "getpriority", "keyword" }, + { "send", "keyword" }, + { "rand", "keyword" }, + { "chroot", "keyword" }, + { "seek", "keyword" }, + { "sleep", "keyword" }, + { "shmctl", "keyword" }, + { "sin", "keyword" }, + { "semctl", "keyword" }, + { "exit", "keyword" }, + { "getppid", "keyword" }, + { "-O", "keyword" }, + { "shmget", "keyword" }, + { "accept", "keyword" }, + { "my", "keyword" }, + { "shmwrite", "keyword" }, + { "uc", "keyword" }, + { "setpriority", "keyword" }, + { "write", "keyword" }, + { "vec", "keyword" }, + { "-A", "keyword" }, + { "getgrnam", "keyword" }, + { "exec", "keyword" }, + { "-o", "keyword" }, + { "msgctl", "keyword" }, + { "msgget", "keyword" }, + { "mkdir", "keyword" }, + { "eval", "keyword" }, + { "wait", "keyword" }, + { "fcntl", "keyword" }, + { "-g", "keyword" }, + { "values", "keyword" }, + { "binmode", "keyword" }, + { "reverse", "keyword" }, + { "msgrcv", "keyword" }, + { "socket", "keyword" }, + { "link", "keyword" }, + { "setservent", "keyword" }, + { "wantarray", "keyword" }, + { "dbmopen", "keyword" }, + { "shmread", "keyword" }, + { "endnetent", "keyword" }, + { "readdir", "keyword" }, + { "-C", "keyword" }, + { "package", "keyword" }, + { "endgrent", "keyword" }, + { "our", "keyword" }, + { "stat", "keyword" }, + { "chop", "keyword" }, + { "listen", "keyword" }, + { "log", "keyword" }, + { "formline", "keyword" }, + + }, + "#", + { "^#!.*[ /]perl" } + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/perl.hpp b/src/eepp/ui/doc/languages/perl.hpp new file mode 100644 index 000000000..9711d2858 --- /dev/null +++ b/src/eepp/ui/doc/languages/perl.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Perl +#define EE_UI_DOC_Perl + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addPerl(); + +}}}} + +#endif diff --git a/src/eepp/ui/doc/languages/sass.cpp b/src/eepp/ui/doc/languages/sass.cpp new file mode 100644 index 000000000..8124d4059 --- /dev/null +++ b/src/eepp/ui/doc/languages/sass.cpp @@ -0,0 +1,224 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addSass() { + + SyntaxDefinitionManager::instance()->add( + + { "Sass", + { "%.sass$", "%.scss$" }, + { + { { "/[/%*].-\n" }, "comment" }, + { { "\"", "\"", "\\" }, "string" }, + { { "'", "'", "\\" }, "string" }, + { { "$%w+" }, "keyword" }, + { { "@%w+" }, "literal" }, + { { "&" }, "keyword2" }, + { { "[:%/%*%-]" }, "operator" }, + { { "[%a][%w-]*%s*%f[:]" }, "keyword2" }, + { { "-?%d+[%d%.]*p[xt]" }, "number" }, + { { "-?%d+[%d%.]*deg" }, "number" }, + { { "-?%d+[%d%.]*[s%%]" }, "number" }, + { { "-?%d+[%d%.]*" }, "number" }, + { { "^%s*#[%a%_%-][%w%_%-]*" }, "keyword2" }, + { { ",%s*#[%a%_%-][%w%_%-]*" }, "keyword2" }, + { { "#%x%x?%x?%x?%x?%x?%x?%x?" }, "string" }, + { { "#[%a%_%-][%w%_%-]*" }, "keyword2" }, + { { "%-%-%a[%w%-%_]*" }, "keyword2" }, + { { "-?%d+[%d%.]*p[xt]" }, "number" }, + { { "-?%d+[%d%.]*deg" }, "number" }, + { { "-?%d+[%d%.]*" }, "number" }, + { { "@[%a][%w%_%-]*" }, "keyword2" }, + { { "%.[%a%_%-][%w%_%-]*" }, "keyword2" }, + { { "(:)(hover)" }, { "normal", "operator", "literal" } }, + { { "(:)(focus%-within)" }, { "normal", "operator", "literal" } }, + { { "(:)(focus)" }, { "normal", "operator", "literal" } }, + { { "(:)(selected)" }, { "normal", "operator", "literal" } }, + { { "(:)(pressed)" }, { "normal", "operator", "literal" } }, + { { "(:)(disabled)" }, { "normal", "operator", "literal" } }, + { { "(:)(checked)" }, { "normal", "operator", "literal" } }, + { { "(:)(root)" }, { "normal", "operator", "link" } }, + { { "(%a+)(%()" }, { "normal", "function", "normal" } }, + { { "[%a][%w-]*%s*%f[:]" }, "keyword" }, + { { "[{}:>~!]" }, "operator" }, + { { "[#,]%w+" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "orange", "literal" }, + { "olivedrab", "literal" }, + { "olive", "literal" }, + { "navajowhite", "literal" }, + { "mistyrose", "literal" }, + { "midnightblue", "literal" }, + { "darkseagreen", "literal" }, + { "mediumseagreen", "literal" }, + { "lavenderblush", "literal" }, + { "mediumaquamarine", "literal" }, + { "limegreen", "literal" }, + { "mediumspringgreen", "literal" }, + { "lightgreen", "literal" }, + { "lime", "literal" }, + { "mediumorchid", "literal" }, + { "gray", "literal" }, + { "black", "literal" }, + { "lightyellow", "literal" }, + { "mediumblue", "literal" }, + { "lightslategray", "literal" }, + { "lightseagreen", "literal" }, + { "lightpink", "literal" }, + { "lightslategrey", "literal" }, + { "lightgrey", "literal" }, + { "lightgoldenrodyellow", "literal" }, + { "lightblue", "literal" }, + { "lemonchiffon", "literal" }, + { "lawngreen", "literal" }, + { "mintcream", "literal" }, + { "khaki", "literal" }, + { "ivory", "literal" }, + { "moccasin", "literal" }, + { "indigo", "literal" }, + { "transparent", "literal" }, + { "oldlace", "literal" }, + { "indianred", "literal" }, + { "hotpink", "literal" }, + { "sizenwse", "literal" }, + { "wait", "literal" }, + { "deeppink", "literal" }, + { "antiquewhite", "literal" }, + { "crosshair", "literal" }, + { "arrow", "literal" }, + { "coral", "literal" }, + { "peachpuff", "literal" }, + { "darkgreen", "literal" }, + { "firebrick", "literal" }, + { "burlywood", "literal" }, + { "darkblue", "literal" }, + { "darkcyan", "literal" }, + { "darkturquoise", "literal" }, + { "paleturquoise", "literal" }, + { "whitesmoke", "literal" }, + { "sienna", "literal" }, + { "tan", "literal" }, + { "grey", "literal" }, + { "darkolivegreen", "literal" }, + { "slategrey", "literal" }, + { "springgreen", "literal" }, + { "gold", "literal" }, + { "darkgrey", "literal" }, + { "darkviolet", "literal" }, + { "yellowgreen", "literal" }, + { "linen", "literal" }, + { "white", "literal" }, + { "dodgerblue", "literal" }, + { "thistle", "literal" }, + { "sandybrown", "literal" }, + { "tomato", "literal" }, + { "violet", "literal" }, + { "palevioletred", "literal" }, + { "chartreuse", "literal" }, + { "turquoise", "literal" }, + { "azure", "literal" }, + { "lightsteelblue", "literal" }, + { "seashell", "literal" }, + { "navy", "literal" }, + { "darkmagenta", "literal" }, + { "silver", "literal" }, + { "teal", "literal" }, + { "darkorchid", "literal" }, + { "seagreen", "literal" }, + { "wheat", "literal" }, + { "darkred", "literal" }, + { "slateblue", "literal" }, + { "red", "literal" }, + { "orchid", "literal" }, + { "salmon", "literal" }, + { "lightcoral", "literal" }, + { "center", "literal" }, + { "royalblue", "literal" }, + { "snow", "literal" }, + { "palegreen", "literal" }, + { "greenyellow", "literal" }, + { "saddlebrown", "literal" }, + { "goldenrod", "literal" }, + { "plum", "literal" }, + { "cornsilk", "literal" }, + { "lavender", "literal" }, + { "rosybrown", "literal" }, + { "waitarrow", "literal" }, + { "powderblue", "literal" }, + { "darkslateblue", "literal" }, + { "chocolate", "literal" }, + { "cadetblue", "literal" }, + { "yellow", "literal" }, + { "ghostwhite", "literal" }, + { "aquamarine", "literal" }, + { "darkslategray", "literal" }, + { "mediumpurple", "literal" }, + { "darksalmon", "literal" }, + { "pink", "literal" }, + { "darkkhaki", "literal" }, + { "mediumslateblue", "literal" }, + { "cyan", "literal" }, + { "hand", "literal" }, + { "purple", "literal" }, + { "brown", "literal" }, + { "aqua", "literal" }, + { "sizenesw", "literal" }, + { "papayawhip", "literal" }, + { "darkgoldenrod", "literal" }, + { "darkslategrey", "literal" }, + { "nocursor", "literal" }, + { "blue", "literal" }, + { "slategray", "literal" }, + { "bisque", "literal" }, + { "orangered", "literal" }, + { "ibeam", "literal" }, + { "darkorange", "literal" }, + { "true", "literal" }, + { "sizens", "literal" }, + { "magenta", "literal" }, + { "important", "literal" }, + { "blanchedalmond", "literal" }, + { "lightskyblue", "literal" }, + { "aliceblue", "literal" }, + { "sizeall", "literal" }, + { "dimgrey", "literal" }, + { "crimson", "literal" }, + { "darkgray", "literal" }, + { "beige", "literal" }, + { "lightsalmon", "literal" }, + { "skyblue", "literal" }, + { "blueviolet", "literal" }, + { "none", "literal" }, + { "sizewe", "literal" }, + { "deepskyblue", "literal" }, + { "peru", "literal" }, + { "dimgray", "literal" }, + { "mediumvioletred", "literal" }, + { "floralwhite", "literal" }, + { "maroon", "literal" }, + { "palegoldenrod", "literal" }, + { "forestgreen", "literal" }, + { "fuchsia", "literal" }, + { "gainsboro", "literal" }, + { "lightcyan", "literal" }, + { "lightgray", "literal" }, + { "mediumturquoise", "literal" }, + { "cornflowerblue", "literal" }, + { "steelblue", "literal" }, + { "green", "literal" }, + { "false", "literal" }, + { "honeydew", "literal" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/sass.hpp b/src/eepp/ui/doc/languages/sass.hpp new file mode 100644 index 000000000..b41683aa8 --- /dev/null +++ b/src/eepp/ui/doc/languages/sass.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Sass +#define EE_UI_DOC_Sass + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addSass(); + +}}}} + +#endif diff --git a/src/eepp/ui/doc/languages/solidity.cpp b/src/eepp/ui/doc/languages/solidity.cpp new file mode 100644 index 000000000..caa74ecca --- /dev/null +++ b/src/eepp/ui/doc/languages/solidity.cpp @@ -0,0 +1,153 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addSolidity() { + + SyntaxDefinitionManager::instance()->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" }, + + }, + { + { "interface", "keyword" }, + { "bytes3", "keyword2" }, + { "blockhash", "keyword2" }, + { "uint64", "keyword2" }, + { "ecrecover", "keyword2" }, + { "new", "keyword" }, + { "ripemd160", "keyword2" }, + { "sha3", "keyword2" }, + { "byte", "keyword2" }, + { "bytes32", "keyword2" }, + { "suicide", "keyword2" }, + { "virtual", "keyword2" }, + { "revert", "keyword2" }, + { "bytes30", "keyword2" }, + { "msg", "keyword2" }, + { "bytes15", "keyword2" }, + { "enum", "keyword" }, + { "payable", "keyword2" }, + { "assembly", "keyword" }, + { "super", "keyword2" }, + { "library", "keyword" }, + { "private", "keyword2" }, + { "is", "keyword" }, + { "now", "keyword2" }, + { "throw", "keyword" }, + { "bytes18", "keyword2" }, + { "contract", "keyword" }, + { "view", "keyword2" }, + { "bytes14", "keyword2" }, + { "let", "keyword" }, + { "external", "keyword2" }, + { "return", "keyword" }, + { "mulmod", "keyword2" }, + { "modifier", "keyword" }, + { "bytes12", "keyword2" }, + { "uint256", "keyword2" }, + { "assert", "keyword2" }, + { "tx", "keyword2" }, + { "require", "keyword" }, + { "bytes8", "keyword2" }, + { "uint32", "keyword2" }, + { "returns", "keyword" }, + { "do", "keyword" }, + { "sha256", "keyword2" }, + { "while", "keyword" }, + { "bytes23", "keyword2" }, + { "function", "keyword" }, + { "memory", "keyword2" }, + { "event", "keyword" }, + { "else", "keyword" }, + { "break", "keyword" }, + { "for", "keyword" }, + { "address", "keyword2" }, + { "bytes4", "keyword2" }, + { "abstract", "keyword" }, + { "gasleft", "keyword2" }, + { "keccak256", "keyword2" }, + { "bytes25", "keyword2" }, + { "bytes28", "keyword2" }, + { "this", "keyword2" }, + { "bytes10", "keyword2" }, + { "protected", "keyword" }, + { "uint8", "keyword2" }, + { "delete", "keyword" }, + { "indexed", "keyword2" }, + { "bytes11", "keyword2" }, + { "bytes17", "keyword2" }, + { "bytes21", "keyword2" }, + { "bytes5", "keyword2" }, + { "bytes26", "keyword2" }, + { "bytes16", "keyword2" }, + { "string", "keyword2" }, + { "bytes31", "keyword2" }, + { "emit", "keyword" }, + { "int32", "keyword2" }, + { "bytes19", "keyword2" }, + { "bytes27", "keyword2" }, + { "int16", "keyword2" }, + { "int8", "keyword2" }, + { "bytes13", "keyword2" }, + { "bytes22", "keyword2" }, + { "hash", "keyword2" }, + { "bytes7", "keyword2" }, + { "pragma", "keyword2" }, + { "int128", "keyword2" }, + { "bytes29", "keyword2" }, + { "int256", "keyword2" }, + { "bytes", "keyword2" }, + { "int64", "keyword2" }, + { "uint16", "keyword2" }, + { "int", "keyword2" }, + { "uint", "keyword2" }, + { "bytes24", "keyword2" }, + { "struct", "keyword" }, + { "uint128", "keyword2" }, + { "bytes2", "keyword2" }, + { "bytes6", "keyword2" }, + { "bytes1", "keyword2" }, + { "override", "keyword2" }, + { "constructor", "keyword" }, + { "using", "keyword" }, + { "nonpayable", "keyword2" }, + { "mapping", "keyword2" }, + { "inherited", "keyword2" }, + { "bytes9", "keyword2" }, + { "pure", "keyword2" }, + { "selfdestruct", "keyword2" }, + { "immutable", "keyword2" }, + { "constant", "keyword2" }, + { "bytes20", "keyword2" }, + { "addmod", "keyword2" }, + { "internal", "keyword2" }, + { "bool", "keyword2" }, + { "public", "keyword2" }, + { "block", "keyword2" }, + { "storage", "keyword2" }, + { "calldata", "keyword2" }, + { "if", "keyword" }, + { "continue", "keyword" }, + + }, + "", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/solidity.hpp b/src/eepp/ui/doc/languages/solidity.hpp new file mode 100644 index 000000000..720826d7c --- /dev/null +++ b/src/eepp/ui/doc/languages/solidity.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Solidity +#define EE_UI_DOC_Solidity + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addSolidity(); + +}}}} + +#endif diff --git a/src/eepp/ui/doc/languages/sql.cpp b/src/eepp/ui/doc/languages/sql.cpp new file mode 100644 index 000000000..bc96e5a1a --- /dev/null +++ b/src/eepp/ui/doc/languages/sql.cpp @@ -0,0 +1,408 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addSQL() { + + SyntaxDefinitionManager::instance()->add( + + { "SQL", + { "%.sql$", "%.psql$" }, + { + { { "%-%-.-\n" }, "comment" }, + { { "/%*", "%*/" }, "comment" }, + { { "'", "'", "\\" }, "string" }, + { { "-?%d+[%d%.eE]*f?" }, "number" }, + { { "-?%.?%d+f?" }, "number" }, + { { "[%+%-=/%*%%<>!~|&@%?$#]" }, "operator" }, + { { "[%a_][%w_]*%f[(]" }, "function" }, + { { "[%a_][%w_]*" }, "symbol" }, + + }, + { + { "SERIAL8", "keyword2" }, + { "INT8RANGE", "keyword2" }, + { "INT8", "keyword2" }, + { "bigint", "keyword2" }, + { "VARBIT", "keyword2" }, + { "recursive", "keyword" }, + { "on", "keyword" }, + { "foreign", "keyword" }, + { "ENUM", "keyword" }, + { "VARIADIC", "keyword" }, + { "serial8", "keyword2" }, + { "DOMAIN", "keyword" }, + { "INT4RANGE", "keyword2" }, + { "OPERATOR", "keyword" }, + { "EVENT", "keyword" }, + { "INDEX", "keyword" }, + { "DATERANGE", "keyword2" }, + { "event", "keyword" }, + { "path", "keyword2" }, + { "CURRENT_TIMESTAMP", "literal" }, + { "RAISE", "keyword" }, + { "LOOP", "keyword" }, + { "loop", "keyword" }, + { "BEGIN", "keyword" }, + { "NOTICE", "keyword" }, + { "EXECUTE", "keyword" }, + { "execute", "keyword" }, + { "raise", "keyword" }, + { "alter", "keyword" }, + { "macaddr", "keyword2" }, + { "ROW", "keyword" }, + { "CASE", "keyword" }, + { "FALSE", "literal" }, + { "row", "keyword" }, + { "BEFORE", "keyword" }, + { "trigger", "keyword" }, + { "FOR", "keyword" }, + { "for", "keyword" }, + { "collation", "keyword" }, + { "UNION", "keyword" }, + { "circle", "keyword2" }, + { "some", "keyword" }, + { "PRECEDING", "keyword" }, + { "left", "keyword" }, + { "varbit", "keyword2" }, + { "SELECT", "keyword" }, + { "EACH", "keyword" }, + { "enum", "keyword" }, + { "preceding", "keyword" }, + { "BETWEEN", "keyword" }, + { "exists", "keyword" }, + { "DESC", "keyword" }, + { "between", "keyword" }, + { "end", "keyword" }, + { "ELSE", "keyword" }, + { "WHEN", "keyword" }, + { "ALSO", "keyword" }, + { "DISTINCT", "keyword" }, + { "END", "keyword" }, + { "varchar", "keyword2" }, + { "when", "keyword" }, + { "CIDR", "keyword2" }, + { "notice", "keyword" }, + { "then", "keyword" }, + { "SET", "keyword" }, + { "uuid", "keyword2" }, + { "FOREIGN", "keyword" }, + { "UNKNOWN", "keyword" }, + { "unknown", "keyword" }, + { "int8", "keyword2" }, + { "NOTNULL", "keyword" }, + { "notnull", "keyword" }, + { "isnull", "keyword" }, + { "date", "keyword2" }, + { "DECLARE", "keyword" }, + { "INTO", "keyword" }, + { "ROWS", "keyword" }, + { "extension", "keyword" }, + { "ALL", "keyword" }, + { "ANY", "keyword" }, + { "content", "keyword" }, + { "ON", "keyword" }, + { "case", "keyword" }, + { "XMLPARSE", "keyword" }, + { "in", "keyword" }, + { "DOCUMENT", "keyword" }, + { "PROCEDURE", "keyword" }, + { "following", "keyword" }, + { "DROP", "keyword" }, + { "document", "keyword" }, + { "type", "keyword" }, + { "TO", "keyword" }, + { "EXCLUDE", "keyword" }, + { "option", "keyword" }, + { "else", "keyword" }, + { "UPDATE", "keyword" }, + { "tsrange", "keyword2" }, + { "xmlparse", "keyword" }, + { "without", "keyword" }, + { "zone", "keyword" }, + { "sequence", "keyword" }, + { "ALTER", "keyword" }, + { "precision", "keyword2" }, + { "INSTEAD", "keyword" }, + { "partition", "keyword" }, + { "THEN", "keyword" }, + { "ZONE", "keyword" }, + { "MONEY", "keyword2" }, + { "instead", "keyword" }, + { "TYPE", "keyword" }, + { "also", "keyword" }, + { "set", "keyword" }, + { "EXISTS", "keyword" }, + { "PRECISION", "keyword2" }, + { "txid_snapshot", "keyword2" }, + { "returning", "keyword" }, + { "ARRAY", "keyword" }, + { "any", "keyword" }, + { "DECIMAL", "keyword2" }, + { "bigserial", "keyword2" }, + { "INNER", "keyword" }, + { "drop", "keyword" }, + { "full", "keyword" }, + { "FULL", "keyword" }, + { "NATURAL", "keyword" }, + { "MACADDR", "keyword2" }, + { "INTEGER", "keyword2" }, + { "inner", "keyword" }, + { "RIGHT", "keyword" }, + { "CHECK", "keyword" }, + { "jsonb", "keyword2" }, + { "EXTENSION", "keyword" }, + { "AND", "keyword" }, + { "SETOF", "keyword" }, + { "PARTITION", "keyword" }, + { "line", "keyword2" }, + { "SERIAL4", "keyword2" }, + { "AS", "keyword" }, + { "LIKE", "keyword" }, + { "GROUP", "keyword" }, + { "ORDINALITY", "keyword" }, + { "RETURNS", "keyword" }, + { "sql", "keyword" }, + { "LATERAL", "keyword" }, + { "NUMERIC", "keyword2" }, + { "int4", "keyword2" }, + { "FUNCTION", "keyword" }, + { "references", "keyword" }, + { "BOX", "keyword2" }, + { "intersect", "keyword" }, + { "CURRENT_DATE", "literal" }, + { "AT", "keyword" }, + { "ASC", "keyword" }, + { "current_timestamp", "literal" }, + { "NULLS", "keyword" }, + { "first", "keyword" }, + { "BOOLEAN", "keyword2" }, + { "bytea", "keyword2" }, + { "BOOL", "keyword2" }, + { "BIGSERIAL", "keyword2" }, + { "json", "keyword2" }, + { "LAST", "keyword" }, + { "localtimestamp", "literal" }, + { "character", "keyword2" }, + { "LEFT", "keyword" }, + { "BYTEA", "keyword2" }, + { "serial", "keyword2" }, + { "time", "keyword2" }, + { "operator", "keyword" }, + { "CHARACTER", "keyword2" }, + { "char", "keyword2" }, + { "float8", "keyword2" }, + { "CHAR", "keyword2" }, + { "EXCEPT", "keyword" }, + { "INT4", "keyword2" }, + { "view", "keyword" }, + { "TSRANGE", "keyword2" }, + { "CIRCLE", "keyword2" }, + { "INT2", "keyword2" }, + { "daterange", "keyword2" }, + { "TIMEZ", "keyword2" }, + { "SERIAL", "keyword2" }, + { "INSERT", "keyword" }, + { "timestampz", "keyword2" }, + { "TSQUERY", "keyword2" }, + { "point", "keyword2" }, + { "pg_lsn", "keyword2" }, + { "unnest", "keyword" }, + { "begin", "keyword" }, + { "decimal", "keyword2" }, + { "LOCALTIME", "literal" }, + { "TIME", "keyword2" }, + { "UNNEST", "keyword" }, + { "tsquery", "keyword2" }, + { "current_time", "literal" }, + { "xmlserialize", "keyword" }, + { "JSON", "keyword2" }, + { "returns", "keyword" }, + { "TSVECTOR", "keyword2" }, + { "TXID_SNAPSHOT", "keyword2" }, + { "lseg", "keyword2" }, + { "int8range", "keyword2" }, + { "localtime", "literal" }, + { "index", "keyword" }, + { "serial4", "keyword2" }, + { "check", "keyword" }, + { "INET", "keyword2" }, + { "smallserial", "keyword2" }, + { "into", "keyword" }, + { "PRIMARY", "keyword" }, + { "UNBOUNDED", "keyword" }, + { "or", "keyword" }, + { "FOLLOWING", "keyword" }, + { "INTERSECT", "keyword" }, + { "SERIAL2", "keyword2" }, + { "false", "literal" }, + { "smallint", "keyword2" }, + { "union", "keyword" }, + { "TIMESTAMPZ", "keyword2" }, + { "float4", "keyword2" }, + { "desc", "keyword" }, + { "tstzrange", "keyword2" }, + { "current_date", "literal" }, + { "KEY", "keyword" }, + { "DOUBLE", "keyword2" }, + { "PG_LSN", "keyword2" }, + { "DATE", "keyword2" }, + { "TRIGGER", "keyword" }, + { "asc", "keyword" }, + { "numrange", "keyword2" }, + { "RECURSIVE", "keyword" }, + { "bit", "keyword2" }, + { "SQL", "keyword" }, + { "SMALLINT", "keyword2" }, + { "TABLE", "keyword" }, + { "tsvector", "keyword2" }, + { "language", "keyword" }, + { "distinct", "keyword" }, + { "LSEG", "keyword2" }, + { "int2", "keyword2" }, + { "as", "keyword" }, + { "OFFSET", "keyword" }, + { "REAL", "keyword2" }, + { "JSONB", "keyword2" }, + { "TRUE", "literal" }, + { "int4range", "keyword2" }, + { "real", "keyword2" }, + { "cidr", "keyword2" }, + { "polygon", "keyword2" }, + { "null", "keyword" }, + { "CONTENT", "keyword" }, + { "rows", "keyword" }, + { "WITH", "keyword" }, + { "LANGUAGE", "keyword" }, + { "POINT", "keyword2" }, + { "BIT", "keyword2" }, + { "ORDER", "keyword" }, + { "numeric", "keyword2" }, + { "unbounded", "keyword" }, + { "SMALLSERIAL", "keyword2" }, + { "timez", "keyword2" }, + { "money", "keyword2" }, + { "lateral", "keyword" }, + { "LINE", "keyword2" }, + { "FIRST", "keyword" }, + { "join", "keyword" }, + { "bool", "keyword2" }, + { "INT", "keyword2" }, + { "inet", "keyword2" }, + { "timestamp", "keyword2" }, + { "FLOAT4", "keyword2" }, + { "FLOAT8", "keyword2" }, + { "all", "keyword" }, + { "RETURNING", "keyword" }, + { "int", "keyword2" }, + { "box", "keyword2" }, + { "cross", "keyword" }, + { "IN", "keyword" }, + { "ordinality", "keyword" }, + { "TIMEZONE", "keyword" }, + { "INTERVAL", "keyword2" }, + { "each", "keyword" }, + { "boolean", "keyword2" }, + { "TSTZRANGE", "keyword2" }, + { "serial2", "keyword2" }, + { "ONLY", "keyword" }, + { "JOIN", "keyword" }, + { "default", "keyword" }, + { "function", "keyword" }, + { "NOT", "keyword" }, + { "NUMRANGE", "keyword2" }, + { "WHERE", "keyword" }, + { "SOME", "keyword" }, + { "VARCHAR", "keyword2" }, + { "XML", "keyword2" }, + { "primary", "keyword" }, + { "delete", "keyword" }, + { "variadic", "keyword" }, + { "not", "keyword" }, + { "DELETE", "keyword" }, + { "declare", "keyword" }, + { "XMLSERIALIZE", "keyword" }, + { "OR", "keyword" }, + { "natural", "keyword" }, + { "interval", "keyword2" }, + { "using", "keyword" }, + { "before", "keyword" }, + { "except", "keyword" }, + { "owned", "keyword" }, + { "values", "keyword" }, + { "exclude", "keyword" }, + { "timezone", "keyword" }, + { "CONSTRAINT", "keyword" }, + { "double", "keyword2" }, + { "OWNED", "keyword" }, + { "UNIQUE", "keyword" }, + { "text", "keyword2" }, + { "LIMIT", "keyword" }, + { "constraint", "keyword" }, + { "NULL", "keyword" }, + { "update", "keyword" }, + { "select", "keyword" }, + { "REFERENCES", "keyword" }, + { "only", "keyword" }, + { "TEXT", "keyword2" }, + { "to", "keyword" }, + { "like", "keyword" }, + { "nulls", "keyword" }, + { "UUID", "keyword2" }, + { "at", "keyword" }, + { "HAVING", "keyword" }, + { "from", "keyword" }, + { "insert", "keyword" }, + { "table", "keyword" }, + { "setof", "keyword" }, + { "true", "literal" }, + { "key", "keyword" }, + { "DEFAULT", "keyword" }, + { "VIEW", "keyword" }, + { "OUTER", "keyword" }, + { "CREATE", "keyword" }, + { "and", "keyword" }, + { "right", "keyword" }, + { "FROM", "keyword" }, + { "create", "keyword" }, + { "unique", "keyword" }, + { "COLLATION", "keyword" }, + { "order", "keyword" }, + { "outer", "keyword" }, + { "xml", "keyword2" }, + { "SEQUENCE", "keyword" }, + { "last", "keyword" }, + { "BY", "keyword" }, + { "where", "keyword" }, + { "WITHOUT", "keyword" }, + { "procedure", "keyword" }, + { "POLYGON", "keyword2" }, + { "group", "keyword" }, + { "LOCALTIMESTAMP", "literal" }, + { "VALUES", "keyword" }, + { "CROSS", "keyword" }, + { "OPTION", "keyword" }, + { "PATH", "keyword2" }, + { "ISNULL", "keyword" }, + { "with", "keyword" }, + { "by", "keyword" }, + { "USING", "keyword" }, + { "having", "keyword" }, + { "domain", "keyword" }, + { "offset", "keyword" }, + { "TIMESTAMP", "keyword2" }, + { "limit", "keyword" }, + { "BIGINT", "keyword2" }, + { "CURRENT_TIME", "literal" }, + { "integer", "keyword2" }, + { "array", "keyword" }, + + }, + "--", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/sql.hpp b/src/eepp/ui/doc/languages/sql.hpp new file mode 100644 index 000000000..9c436fa55 --- /dev/null +++ b/src/eepp/ui/doc/languages/sql.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Sql +#define EE_UI_DOC_Sql + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addSQL(); + +}}}} + +#endif diff --git a/src/eepp/ui/doc/languages/swift.cpp b/src/eepp/ui/doc/languages/swift.cpp new file mode 100644 index 000000000..1841d9309 --- /dev/null +++ b/src/eepp/ui/doc/languages/swift.cpp @@ -0,0 +1,230 @@ +#include +#include + +namespace EE { namespace UI { namespace Doc { namespace Language { + +void addSwift() { + + SyntaxDefinitionManager::instance()->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" }, + + }, + { + { "encodeBitsAsWords", "keyword2" }, + { "postfix", "keyword" }, + { "open", "keyword" }, + { "debugPrintln", "keyword2" }, + { "debugPrint", "keyword2" }, + { "convenience", "keyword" }, + { "count", "keyword2" }, + { "contains", "keyword2" }, + { "#imageLiteral", "keyword" }, + { "enumerate", "keyword2" }, + { "c", "keyword2" }, + { "bridgeToObjectiveCUnconditional", "keyword2" }, + { "try?", "keyword" }, + { "assertionFailure", "keyword2" }, + { "withUnsafePointers", "keyword2" }, + { "Void", "keyword2" }, + { "assert", "keyword2" }, + { "in", "keyword" }, + { "anyGenerator", "keyword2" }, + { "fatalError", "keyword2" }, + { "alignofValue", "keyword2" }, + { "bridgeToObjectiveC", "keyword2" }, + { "alignof", "keyword2" }, + { "willSet", "keyword" }, + { "where", "keyword" }, + { "weak", "keyword" }, + { "typealias", "keyword" }, + { "isBridgedToObjectiveC", "keyword2" }, + { "isUniquelyReferenced", "keyword2" }, + { "underestimateCount", "keyword2" }, + { "try!", "keyword" }, + { "as!", "keyword" }, + { "none", "keyword" }, + { "maxElement", "keyword2" }, + { "throws", "keyword" }, + { "associatedtype", "keyword" }, + { "throw", "keyword" }, + { "lazy", "keyword" }, + { "switch", "keyword" }, + { "super", "keyword" }, + { "struct", "keyword" }, + { "static", "keyword" }, + { "unsafeReflect", "keyword2" }, + { "dropLast", "keyword2" }, + { "Self", "keyword" }, + { "fallthrough", "keyword" }, + { "unowned", "keyword" }, + { "__FILE__", "keyword" }, + { "right", "keyword" }, + { "required", "keyword" }, + { "nonmutating", "keyword" }, + { "try", "keyword" }, + { "withExtendedLifetime", "keyword2" }, + { "public", "keyword" }, + { "final", "keyword" }, + { "Protocol", "keyword" }, + { "guard", "keyword" }, + { "operator", "keyword" }, + { "let", "keyword" }, + { "extension", "keyword" }, + { "posix", "keyword2" }, + { "precedence", "keyword" }, + { "case", "keyword" }, + { "left", "keyword" }, + { "filter", "keyword2" }, + { "min", "keyword2" }, + { "countElements", "keyword2" }, + { "unsafeBitCast", "keyword2" }, + { "do", "keyword" }, + { "max", "keyword2" }, + { "dynamicType", "keyword" }, + { "reverse", "keyword2" }, + { "while", "keyword" }, + { "init", "keyword" }, + { "func", "keyword" }, + { "abs", "keyword2" }, + { "sizeof", "keyword2" }, + { "true", "keyword" }, + { "default", "keyword" }, + { "dynamic", "keyword" }, + { "var", "keyword" }, + { "#sourceLocation", "keyword" }, + { "indices", "keyword2" }, + { "isUniquelyReferencedNonObjC", "keyword2" }, + { "getBridgedObjectiveCType", "keyword2" }, + { "precondition", "keyword2" }, + { "getVaList", "keyword2" }, + { "get", "keyword" }, + { "Double", "keyword2" }, + { "join", "keyword2" }, + { "startsWith", "keyword2" }, + { "Bool", "keyword2" }, + { "associativity", "keyword" }, + { "self", "keyword" }, + { "prefix", "keyword" }, + { "sort", "keyword2" }, + { "lexicographicalCompare", "keyword2" }, + { "insertionSort", "keyword2" }, + { "__LINE__", "keyword" }, + { "Array", "keyword2" }, + { "stride", "keyword2" }, + { "unsafeDowncast", "keyword2" }, + { "strideof", "keyword2" }, + { "continue", "keyword" }, + { "sizeofValue", "keyword2" }, + { "swap", "keyword2" }, + { "withUnsafeMutablePointer", "keyword2" }, + { "Type", "keyword" }, + { "find", "keyword2" }, + { "zip", "keyword2" }, + { "preconditionFailure", "keyword2" }, + { "enum", "keyword" }, + { "withObjectAtPlusZero", "keyword2" }, + { "strideofValue", "keyword2" }, + { "transcode", "keyword2" }, + { "withUnsafePointerToObject", "keyword2" }, + { "overlaps", "keyword2" }, + { "split", "keyword2" }, + { "withUnsafePointer", "keyword2" }, + { "internal", "keyword" }, + { "reinterpretCast", "keyword2" }, + { "reduce", "keyword2" }, + { "toString", "keyword2" }, + { "readLine", "keyword2" }, + { "as", "keyword" }, + { "deinit", "keyword" }, + { "break", "keyword" }, + { "optional", "keyword" }, + { "withVaList", "keyword2" }, + { "quickSort", "keyword2" }, + { "unsafeAddressOf", "keyword2" }, + { "fileprivate", "keyword" }, + { "bridgeFromObjectiveCUnconditional", "keyword2" }, + { "if", "keyword" }, + { "isBridgedVerbatimToObjectiveC", "keyword2" }, + { "String", "keyword2" }, + { "print", "keyword2" }, + { "roundUpToAlignment", "keyword2" }, + { "catch", "keyword" }, + { "equal", "keyword2" }, + { "Optional", "keyword2" }, + { "map", "keyword2" }, + { "println", "keyword2" }, + { "as?", "keyword" }, + { "didSet", "keyword" }, + { "defer", "keyword" }, + { "inout", "keyword" }, + { "is", "keyword" }, + { "Int", "keyword2" }, + { "minElement", "keyword2" }, + { "private", "keyword" }, + { "countLeadingZeros", "keyword2" }, + { "bridgeFromObjectiveC", "keyword2" }, + { "nil", "keyword" }, + { "rethrows", "keyword" }, + { "withUnsafeMutablePointers", "keyword2" }, + { "compactMap", "keyword2" }, + { "unsafeUnwrap", "keyword2" }, + { "#if", "keyword" }, + { "#column", "keyword" }, + { "protocol", "keyword" }, + { "#file", "keyword" }, + { "indirect", "keyword" }, + { "numericCast", "keyword2" }, + { "#elseif", "keyword" }, + { "infix", "keyword" }, + { "override", "keyword" }, + { "#else", "keyword" }, + { "dropFirst", "keyword2" }, + { "subscript", "keyword" }, + { "#line", "keyword" }, + { "for", "keyword" }, + { "import", "keyword" }, + { "false", "keyword" }, + { "#fileLiteral", "keyword" }, + { "advance", "keyword2" }, + { "partition", "keyword2" }, + { "__FUNCTION__", "keyword" }, + { "#endif", "keyword" }, + { "repeat", "keyword" }, + { "#selector", "keyword" }, + { "#available", "keyword" }, + { "mutating", "keyword" }, + { "#colorLiteral", "keyword" }, + { "class", "keyword" }, + { "dump", "keyword2" }, + { "#function", "keyword" }, + { "__COLUMN__", "keyword" }, + { "set", "keyword" }, + { "Any", "keyword" }, + { "return", "keyword" }, + { "distance", "keyword2" }, + { "reflect", "keyword2" }, + { "else", "keyword" }, + { "Float", "keyword2" }, + { "_", "keyword" }, + + }, + "//", + {} + + } ); +} + +}}}} // namespace EE::UI::Doc::Language diff --git a/src/eepp/ui/doc/languages/swift.hpp b/src/eepp/ui/doc/languages/swift.hpp new file mode 100644 index 000000000..813dc7d02 --- /dev/null +++ b/src/eepp/ui/doc/languages/swift.hpp @@ -0,0 +1,10 @@ +#ifndef EE_UI_DOC_Swift +#define EE_UI_DOC_Swift + +namespace EE { namespace UI { namespace Doc { namespace Language { + +extern void addSwift(); + +}}}} + +#endif diff --git a/src/eepp/ui/doc/syntaxdefinition.cpp b/src/eepp/ui/doc/syntaxdefinition.cpp index 5ac8e51be..9dd71fb23 100644 --- a/src/eepp/ui/doc/syntaxdefinition.cpp +++ b/src/eepp/ui/doc/syntaxdefinition.cpp @@ -170,6 +170,19 @@ const std::string& SyntaxDefinition::getLanguageName() const { return mLanguageName; } +std::string SyntaxDefinition::getLanguageNameForFileSystem() const { + std::string lang( mLanguageName ); + String::replaceAll( lang, " ", "" ); + String::replaceAll( lang, ".", "" ); + String::replaceAll( lang, "!", "" ); + String::replaceAll( lang, "[", "" ); + String::replaceAll( lang, "]", "" ); + String::replaceAll( lang, "+", "p" ); + String::replaceAll( lang, "#", "sharp" ); + String::toLowerInPlace( lang ); + return lang; +} + const String::HashType& SyntaxDefinition::getLanguageId() const { return mLanguageId; } diff --git a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp index 22cccf4e5..494da7695 100644 --- a/src/eepp/ui/doc/syntaxdefinitionmanager.cpp +++ b/src/eepp/ui/doc/syntaxdefinitionmanager.cpp @@ -3,13 +3,23 @@ #include #include #include +#include +#include +#include +#include #include #include #include +#include #include +#include #include #include #include +#include +#include +#include +#include #include #include #include @@ -93,209 +103,6 @@ static void addHTML() { .setAutoCloseXMLTags( true ); } -static void addCSS() { - SyntaxDefinitionManager::instance() - ->add( { "CSS", - { "%.css$" }, - { - { { "\\." }, "normal" }, - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "^%s*#[%a%_%-][%w%_%-]*" }, "keyword2" }, - { { ",%s*#[%a%_%-][%w%_%-]*" }, "keyword2" }, - { { "#%x%x%x%x?%x?%x?%x?%x?" }, "string" }, - { { "#[%a%_%-][%w%_%-]*" }, "keyword2" }, - { { "%-%-%a[%w%-%_]*" }, "keyword2" }, - { { "-?%d+[%d%.]*p[xt]" }, "number" }, - { { "-?%d+[%d%.]*deg" }, "number" }, - { { "-?%d+[%d%.]*" }, "number" }, - { { "@[%a][%w%_%-]*" }, "keyword2" }, - { { "%.[%a%_%-][%w%_%-]*" }, "keyword2" }, - { { "(:)(hover)" }, { "normal", "operator", "literal" } }, - { { "(:)(focus%-within)" }, { "normal", "operator", "literal" } }, - { { "(:)(focus)" }, { "normal", "operator", "literal" } }, - { { "(:)(selected)" }, { "normal", "operator", "literal" } }, - { { "(:)(pressed)" }, { "normal", "operator", "literal" } }, - { { "(:)(disabled)" }, { "normal", "operator", "literal" } }, - { { "(:)(checked)" }, { "normal", "operator", "literal" } }, - { { "(:)(root)" }, { "normal", "operator", "link" } }, - { { "(%a+)(%()" }, { "normal", "function", "normal" } }, - { { "[%a][%w-]*%s*%f[:]" }, "keyword" }, - { { "[{}:>~!]" }, "operator" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "true", "literal" }, - { "false", "literal" }, - { "transparent", "literal" }, - { "none", "literal" }, - { "center", "literal" }, - { "arrow", "literal" }, - { "hand", "literal" }, - { "ibeam", "literal" }, - { "wait", "literal" }, - { "crosshair", "literal" }, - { "waitarrow", "literal" }, - { "sizenwse", "literal" }, - { "sizenesw", "literal" }, - { "sizewe", "literal" }, - { "sizens", "literal" }, - { "sizeall", "literal" }, - { "nocursor", "literal" }, - { "important", "literal" }, - { "aliceblue", "literal" }, - { "antiquewhite", "literal" }, - { "aqua", "literal" }, - { "aquamarine", "literal" }, - { "azure", "literal" }, - { "beige", "literal" }, - { "bisque", "literal" }, - { "black", "literal" }, - { "blanchedalmond", "literal" }, - { "blue", "literal" }, - { "blueviolet", "literal" }, - { "brown", "literal" }, - { "burlywood", "literal" }, - { "cadetblue", "literal" }, - { "chartreuse", "literal" }, - { "chocolate", "literal" }, - { "coral", "literal" }, - { "cornflowerblue", "literal" }, - { "cornsilk", "literal" }, - { "crimson", "literal" }, - { "cyan", "literal" }, - { "darkblue", "literal" }, - { "darkcyan", "literal" }, - { "darkgoldenrod", "literal" }, - { "darkgray", "literal" }, - { "darkgreen", "literal" }, - { "darkgrey", "literal" }, - { "darkkhaki", "literal" }, - { "darkmagenta", "literal" }, - { "darkolivegreen", "literal" }, - { "darkorange", "literal" }, - { "darkorchid", "literal" }, - { "darkred", "literal" }, - { "darksalmon", "literal" }, - { "darkseagreen", "literal" }, - { "darkslateblue", "literal" }, - { "darkslategray", "literal" }, - { "darkslategrey", "literal" }, - { "darkturquoise", "literal" }, - { "darkviolet", "literal" }, - { "deeppink", "literal" }, - { "deepskyblue", "literal" }, - { "dimgray", "literal" }, - { "dimgrey", "literal" }, - { "dodgerblue", "literal" }, - { "firebrick", "literal" }, - { "floralwhite", "literal" }, - { "forestgreen", "literal" }, - { "fuchsia", "literal" }, - { "gainsboro", "literal" }, - { "ghostwhite", "literal" }, - { "gold", "literal" }, - { "goldenrod", "literal" }, - { "gray", "literal" }, - { "green", "literal" }, - { "greenyellow", "literal" }, - { "grey", "literal" }, - { "honeydew", "literal" }, - { "hotpink", "literal" }, - { "indianred", "literal" }, - { "indigo", "literal" }, - { "ivory", "literal" }, - { "khaki", "literal" }, - { "lavender", "literal" }, - { "lavenderblush", "literal" }, - { "lawngreen", "literal" }, - { "lemonchiffon", "literal" }, - { "lightblue", "literal" }, - { "lightcoral", "literal" }, - { "lightcyan", "literal" }, - { "lightgoldenrodyellow", "literal" }, - { "lightgray", "literal" }, - { "lightgreen", "literal" }, - { "lightgrey", "literal" }, - { "lightpink", "literal" }, - { "lightsalmon", "literal" }, - { "lightseagreen", "literal" }, - { "lightskyblue", "literal" }, - { "lightslategray", "literal" }, - { "lightslategrey", "literal" }, - { "lightsteelblue", "literal" }, - { "lightyellow", "literal" }, - { "lime", "literal" }, - { "limegreen", "literal" }, - { "linen", "literal" }, - { "magenta", "literal" }, - { "maroon", "literal" }, - { "mediumaquamarine", "literal" }, - { "mediumblue", "literal" }, - { "mediumorchid", "literal" }, - { "mediumpurple", "literal" }, - { "mediumseagreen", "literal" }, - { "mediumslateblue", "literal" }, - { "mediumspringgreen", "literal" }, - { "mediumturquoise", "literal" }, - { "mediumvioletred", "literal" }, - { "midnightblue", "literal" }, - { "mintcream", "literal" }, - { "mistyrose", "literal" }, - { "moccasin", "literal" }, - { "navajowhite", "literal" }, - { "navy", "literal" }, - { "oldlace", "literal" }, - { "olive", "literal" }, - { "olivedrab", "literal" }, - { "orange", "literal" }, - { "orangered", "literal" }, - { "orchid", "literal" }, - { "palegoldenrod", "literal" }, - { "palegreen", "literal" }, - { "paleturquoise", "literal" }, - { "palevioletred", "literal" }, - { "papayawhip", "literal" }, - { "peachpuff", "literal" }, - { "peru", "literal" }, - { "pink", "literal" }, - { "plum", "literal" }, - { "powderblue", "literal" }, - { "purple", "literal" }, - { "red", "literal" }, - { "rosybrown", "literal" }, - { "royalblue", "literal" }, - { "saddlebrown", "literal" }, - { "salmon", "literal" }, - { "sandybrown", "literal" }, - { "seagreen", "literal" }, - { "seashell", "literal" }, - { "sienna", "literal" }, - { "silver", "literal" }, - { "skyblue", "literal" }, - { "slateblue", "literal" }, - { "slategray", "literal" }, - { "slategrey", "literal" }, - { "snow", "literal" }, - { "springgreen", "literal" }, - { "steelblue", "literal" }, - { "tan", "literal" }, - { "teal", "literal" }, - { "thistle", "literal" }, - { "tomato", "literal" }, - { "turquoise", "literal" }, - { "violet", "literal" }, - { "wheat", "literal" }, - { "white", "literal" }, - { "whitesmoke", "literal" }, - { "yellow", "literal" }, - { "yellowgreen", "literal" }, - } } ) - .addSymbols( UIWidgetCreator::getWidgetNames(), "keyword" ); -} - static void addMarkdown() { SyntaxDefinitionManager::instance()->add( { "Markdown", @@ -923,439 +730,6 @@ static void addPHP() { .setVisible( false ); } -static void addSQL() { - const 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" }; - - const 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" }; - - const 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"; - } - - SyntaxDefinitionManager::instance()->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, - "--" } ); -} - -static void addGLSL() { - SyntaxDefinitionManager::instance()->add( - { "GLSL", - { "%.glsl$", "%.frag$", "%.vert$", "%.fs$", "%.vs$" }, - { - { { "//.-\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" }, - }, - "//" } ); -} - static void addIni() { SyntaxDefinitionManager::instance()->add( { "Config File", @@ -1592,142 +966,6 @@ static void addGDScript() { "#" } ); } -static void addD() { - SyntaxDefinitionManager::instance()->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" }, - }, - "//" } ); -} - static void addHaskell() { SyntaxDefinitionManager::instance()->add( { "Haskell", @@ -1854,61 +1092,6 @@ static void addAngelScript() { "//" } ); } -static void addBatchScript() { - std::unordered_map> batchSymTable = { - { "keyword", - { - "if", "else", "elsif", "not", "for", "do", "in", "equ", - "neq", "lss", "leq", "gtr", "geq", "nul", "con", "prn", - "prn", "lpt1", "com1", "com2", "com3", "com4", "exist", "defined", - "errorlevel", "cmdextversion", "goto", "call", "verify", - } }, - { "function", - { - "set", "setlocal", "endlocal", "enabledelayedexpansion", - "echo", "type", "cd", "chdir", - "md", "mkdir", "pause", "choice", - "exit", "del", "rd", "rmdir", - "copy", "xcopy", "move", "ren", - "find", "findstr", "sort", "shift", - "attrib", "cmd", "command", "forfiles", - } } }; - - auto prepareBatchSymbols = []( std::unordered_map> table ) - -> std::unordered_map { - std::unordered_map symbols; - for ( auto& el : table ) { - for ( const auto& it : el.second ) { - symbols[String::toLower( it )] = el.first; - symbols[String::toUpper( it )] = el.first; - } - } - return symbols; - }; - - SyntaxDefinitionManager::instance()->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", - {}, - "bat" } ); -} - static void addDiff() { SyntaxDefinitionManager::instance()->add( { "Diff File", { "%.diff$", "%.patch$" }, @@ -2003,306 +1186,6 @@ static void addYAML() { "#" } ); } -static void addSwift() { - SyntaxDefinitionManager::instance()->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" }, - }, - "//" } ); -} - -static void addSolidity() { - SyntaxDefinitionManager::instance()->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" } } } ); -} - static void addObjetiveC() { SyntaxDefinitionManager::instance()->add( { "Objective-C", @@ -2754,141 +1637,6 @@ static void addContainerfile() { "dockerfile" } ); } -static void addOdin() { - SyntaxDefinitionManager::instance()->add( - - { "Odin", - { "%.odin$" }, - { - { { "//.-\n" }, "comment" }, - { { "/%*", "%*/" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "`", "`" }, "string" }, - { { "0b[01_]+" }, "number" }, - { { "0o[0-7_]+" }, "number" }, - { { "0[dz][%d_]+" }, "number" }, - { { "0x[%da-fA-F_]+" }, "number" }, - { { "-?%d+[%d%._e]*i?" }, "number" }, - { { "[<>~=+-*/]=" }, "operator" }, - { { "[%+%-=/%*%^%%<>!~|&:]" }, "operator" }, - { { "%$[%a_][%w_]*" }, "operator" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[#@][%a_][%w_]*" }, "keyword2" }, - { { "[#@]%b()" }, "keyword2" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "package", "keyword" }, - { "import", "keyword" }, - { "foreign", "keyword" }, - { "when", "keyword" }, - { "if", "keyword" }, - { "else", "keyword" }, - { "for", "keyword" }, - { "defer", "keyword" }, - { "return", "keyword" }, - { "switch", "keyword" }, - { "case", "keyword" }, - { "in", "keyword" }, - { "not_in", "keyword" }, - { "do", "keyword" }, - { "break", "keyword" }, - { "continue", "keyword" }, - { "fallthrough", "keyword" }, - { "proc", "keyword" }, - { "struct", "keyword" }, - { "union", "keyword" }, - { "enum", "keyword" }, - { "bit_set", "keyword" }, - { "map", "keyword" }, - { "dynamic", "keyword" }, - { "using", "keyword" }, - { "inline", "keyword" }, - { "no_inline", "keyword" }, - { "context", "keyword" }, - { "distinct", "keyword" }, - { "opaque", "keyword" }, - { "macro", "keyword" }, - { "const", "keyword" }, - { "cast", "keyword2" }, - { "auto_cast", "keyword2" }, - { "transmute", "keyword2" }, - { "len", "keyword2" }, - { "cap", "keyword2" }, - { "size_of", "keyword2" }, - { "align_of", "keyword2" }, - { "offset_of", "keyword2" }, - { "typeid_of", "keyword2" }, - { "type_of", "keyword2" }, - { "type_info_of", "keyword2" }, - { "type_info_base", "keyword2" }, - { "swizzle", "keyword2" }, - { "complex", "keyword2" }, - { "real", "keyword2" }, - { "imag", "keyword2" }, - { "conj", "keyword2" }, - { "min", "keyword2" }, - { "max", "keyword2" }, - { "abs", "keyword2" }, - { "clamp", "keyword2" }, - { "assert", "keyword2" }, - { "rawptr", "keyword2" }, - { "typeid", "keyword2" }, - { "any", "keyword2" }, - { "string", "keyword2" }, - { "cstring", "keyword2" }, - { "int", "keyword2" }, - { "uint", "keyword2" }, - { "uintptr", "keyword2" }, - { "rune", "keyword2" }, - { "byte", "keyword2" }, - { "u8", "keyword2" }, - { "u16", "keyword2" }, - { "u32", "keyword2" }, - { "u64", "keyword2" }, - { "u128", "keyword2" }, - { "i8", "keyword2" }, - { "i16", "keyword2" }, - { "i32", "keyword2" }, - { "i64", "keyword2" }, - { "i128", "keyword2" }, - { "f16", "keyword2" }, - { "f32", "keyword2" }, - { "f64", "keyword2" }, - { "u16le", "keyword2" }, - { "u32le", "keyword2" }, - { "u64le", "keyword2" }, - { "u128le", "keyword2" }, - { "i16le", "keyword2" }, - { "i32le", "keyword2" }, - { "i64le", "keyword2" }, - { "i128le", "keyword2" }, - { "u16be", "keyword2" }, - { "u32be", "keyword2" }, - { "u64be", "keyword2" }, - { "u128be", "keyword2" }, - { "i16be", "keyword2" }, - { "i32be", "keyword2" }, - { "i64be", "keyword2" }, - { "i128be", "keyword2" }, - { "complex32", "keyword2" }, - { "complex64", "keyword2" }, - { "complex128", "keyword2" }, - { "quaternion128", "keyword2" }, - { "quaternion256", "keyword2" }, - { "bool", "keyword2" }, - { "b8", "keyword2" }, - { "b32", "keyword2" }, - { "b64", "keyword2" }, - { "b128", "keyword2" }, - { "true", "literal" }, - { "false", "literal" }, - { "nil", "literal" }, - }, - "//" } ); -} - static void addIgnore() { SyntaxDefinitionManager::instance()->add( { ".ignore file", { "%..*ignore$" }, @@ -3137,218 +1885,6 @@ static void addScala() { } ); } -static void addSass() { - SyntaxDefinitionManager::instance()->add( { - "Sass", - { "%.sass$", "%.scss$" }, - { - { { "/[/%*].-\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "$%w+" }, "keyword" }, - { { "@%w+" }, "literal" }, - { { "&" }, "keyword2" }, - { { "[:%/%*%-]" }, "operator" }, - { { "[%a][%w-]*%s*%f[:]" }, "keyword2" }, - { { "-?%d+[%d%.]*p[xt]" }, "number" }, - { { "-?%d+[%d%.]*deg" }, "number" }, - { { "-?%d+[%d%.]*[s%%]" }, "number" }, - { { "-?%d+[%d%.]*" }, "number" }, - { { "^%s*#[%a%_%-][%w%_%-]*" }, "keyword2" }, - { { ",%s*#[%a%_%-][%w%_%-]*" }, "keyword2" }, - { { "#%x%x?%x?%x?%x?%x?%x?%x?" }, "string" }, - { { "#[%a%_%-][%w%_%-]*" }, "keyword2" }, - { { "%-%-%a[%w%-%_]*" }, "keyword2" }, - { { "-?%d+[%d%.]*p[xt]" }, "number" }, - { { "-?%d+[%d%.]*deg" }, "number" }, - { { "-?%d+[%d%.]*" }, "number" }, - { { "@[%a][%w%_%-]*" }, "keyword2" }, - { { "%.[%a%_%-][%w%_%-]*" }, "keyword2" }, - { { "(:)(hover)" }, { "normal", "operator", "literal" } }, - { { "(:)(focus%-within)" }, { "normal", "operator", "literal" } }, - { { "(:)(focus)" }, { "normal", "operator", "literal" } }, - { { "(:)(selected)" }, { "normal", "operator", "literal" } }, - { { "(:)(pressed)" }, { "normal", "operator", "literal" } }, - { { "(:)(disabled)" }, { "normal", "operator", "literal" } }, - { { "(:)(checked)" }, { "normal", "operator", "literal" } }, - { { "(:)(root)" }, { "normal", "operator", "link" } }, - { { "(%a+)(%()" }, { "normal", "function", "normal" } }, - { { "[%a][%w-]*%s*%f[:]" }, "keyword" }, - { { "[{}:>~!]" }, "operator" }, - { { "[#,]%w+" }, "function" }, - { { "[%a_][%w_]*" }, "symbol" }, - }, - { - { "true", "literal" }, - { "false", "literal" }, - { "transparent", "literal" }, - { "none", "literal" }, - { "center", "literal" }, - { "arrow", "literal" }, - { "hand", "literal" }, - { "ibeam", "literal" }, - { "wait", "literal" }, - { "crosshair", "literal" }, - { "waitarrow", "literal" }, - { "sizenwse", "literal" }, - { "sizenesw", "literal" }, - { "sizewe", "literal" }, - { "sizens", "literal" }, - { "sizeall", "literal" }, - { "nocursor", "literal" }, - { "important", "literal" }, - { "aliceblue", "literal" }, - { "antiquewhite", "literal" }, - { "aqua", "literal" }, - { "aquamarine", "literal" }, - { "azure", "literal" }, - { "beige", "literal" }, - { "bisque", "literal" }, - { "black", "literal" }, - { "blanchedalmond", "literal" }, - { "blue", "literal" }, - { "blueviolet", "literal" }, - { "brown", "literal" }, - { "burlywood", "literal" }, - { "cadetblue", "literal" }, - { "chartreuse", "literal" }, - { "chocolate", "literal" }, - { "coral", "literal" }, - { "cornflowerblue", "literal" }, - { "cornsilk", "literal" }, - { "crimson", "literal" }, - { "cyan", "literal" }, - { "darkblue", "literal" }, - { "darkcyan", "literal" }, - { "darkgoldenrod", "literal" }, - { "darkgray", "literal" }, - { "darkgreen", "literal" }, - { "darkgrey", "literal" }, - { "darkkhaki", "literal" }, - { "darkmagenta", "literal" }, - { "darkolivegreen", "literal" }, - { "darkorange", "literal" }, - { "darkorchid", "literal" }, - { "darkred", "literal" }, - { "darksalmon", "literal" }, - { "darkseagreen", "literal" }, - { "darkslateblue", "literal" }, - { "darkslategray", "literal" }, - { "darkslategrey", "literal" }, - { "darkturquoise", "literal" }, - { "darkviolet", "literal" }, - { "deeppink", "literal" }, - { "deepskyblue", "literal" }, - { "dimgray", "literal" }, - { "dimgrey", "literal" }, - { "dodgerblue", "literal" }, - { "firebrick", "literal" }, - { "floralwhite", "literal" }, - { "forestgreen", "literal" }, - { "fuchsia", "literal" }, - { "gainsboro", "literal" }, - { "ghostwhite", "literal" }, - { "gold", "literal" }, - { "goldenrod", "literal" }, - { "gray", "literal" }, - { "green", "literal" }, - { "greenyellow", "literal" }, - { "grey", "literal" }, - { "honeydew", "literal" }, - { "hotpink", "literal" }, - { "indianred", "literal" }, - { "indigo", "literal" }, - { "ivory", "literal" }, - { "khaki", "literal" }, - { "lavender", "literal" }, - { "lavenderblush", "literal" }, - { "lawngreen", "literal" }, - { "lemonchiffon", "literal" }, - { "lightblue", "literal" }, - { "lightcoral", "literal" }, - { "lightcyan", "literal" }, - { "lightgoldenrodyellow", "literal" }, - { "lightgray", "literal" }, - { "lightgreen", "literal" }, - { "lightgrey", "literal" }, - { "lightpink", "literal" }, - { "lightsalmon", "literal" }, - { "lightseagreen", "literal" }, - { "lightskyblue", "literal" }, - { "lightslategray", "literal" }, - { "lightslategrey", "literal" }, - { "lightsteelblue", "literal" }, - { "lightyellow", "literal" }, - { "lime", "literal" }, - { "limegreen", "literal" }, - { "linen", "literal" }, - { "magenta", "literal" }, - { "maroon", "literal" }, - { "mediumaquamarine", "literal" }, - { "mediumblue", "literal" }, - { "mediumorchid", "literal" }, - { "mediumpurple", "literal" }, - { "mediumseagreen", "literal" }, - { "mediumslateblue", "literal" }, - { "mediumspringgreen", "literal" }, - { "mediumturquoise", "literal" }, - { "mediumvioletred", "literal" }, - { "midnightblue", "literal" }, - { "mintcream", "literal" }, - { "mistyrose", "literal" }, - { "moccasin", "literal" }, - { "navajowhite", "literal" }, - { "navy", "literal" }, - { "oldlace", "literal" }, - { "olive", "literal" }, - { "olivedrab", "literal" }, - { "orange", "literal" }, - { "orangered", "literal" }, - { "orchid", "literal" }, - { "palegoldenrod", "literal" }, - { "palegreen", "literal" }, - { "paleturquoise", "literal" }, - { "palevioletred", "literal" }, - { "papayawhip", "literal" }, - { "peachpuff", "literal" }, - { "peru", "literal" }, - { "pink", "literal" }, - { "plum", "literal" }, - { "powderblue", "literal" }, - { "purple", "literal" }, - { "red", "literal" }, - { "rosybrown", "literal" }, - { "royalblue", "literal" }, - { "saddlebrown", "literal" }, - { "salmon", "literal" }, - { "sandybrown", "literal" }, - { "seagreen", "literal" }, - { "seashell", "literal" }, - { "sienna", "literal" }, - { "silver", "literal" }, - { "skyblue", "literal" }, - { "slateblue", "literal" }, - { "slategray", "literal" }, - { "slategrey", "literal" }, - { "snow", "literal" }, - { "springgreen", "literal" }, - { "steelblue", "literal" }, - { "tan", "literal" }, - { "teal", "literal" }, - { "thistle", "literal" }, - { "tomato", "literal" }, - { "turquoise", "literal" }, - { "violet", "literal" }, - { "wheat", "literal" }, - { "white", "literal" }, - { "whitesmoke", "literal" }, - { "yellow", "literal" }, - { "yellowgreen", "literal" }, - }, - "//", - } ); -} - static void addPO() { SyntaxDefinitionManager::instance()->add( { "PO", @@ -3370,264 +1906,6 @@ static void addPO() { } ); } -static void addPerl() { - SyntaxDefinitionManager::instance()->add( { - "Perl", - { "%.pm$", "%.pl$" }, - { - { { "%#.-\n" }, "comment" }, - { { "\"", "\"", "\\" }, "string" }, - { { "'", "'", "\\" }, "string" }, - { { "-?%d+[%d%.eE]*" }, "number" }, - { { "-?%.?%d+" }, "number" }, - { { "[%a_][%w_]*%f[(]" }, "function" }, - { { "[%@%$%*]+[%a_][%w_]*" }, "keyword2" }, - { { "%--[%a_][%w_]*" }, "symbol" }, - }, - { - { "-A", "keyword" }, - { "END", "keyword" }, - { "length", "keyword" }, - { "setpgrp", "keyword" }, - { "-B", "keyword" }, - { "endgrent", "keyword" }, - { "link", "keyword" }, - { "setpriority", "keyword" }, - { "-b", "keyword" }, - { "endhostent", "keyword" }, - { "listen", "keyword" }, - { "setprotoent", "keyword" }, - { "-C", "keyword" }, - { "endnetent", "keyword" }, - { "local", "keyword" }, - { "setpwent", "keyword" }, - { "-c", "keyword" }, - { "endprotoent", "keyword" }, - { "localtime", "keyword" }, - { "setservent", "keyword" }, - { "-d", "keyword" }, - { "endpwent", "keyword" }, - { "log", "keyword" }, - { "setsockopt", "keyword" }, - { "-e", "keyword" }, - { "endservent", "keyword" }, - { "lstat", "keyword" }, - { "shift", "keyword" }, - { "-f", "keyword" }, - { "eof$", "keyword" }, - { "map", "keyword" }, - { "shmctl", "keyword" }, - { "-g", "keyword" }, - { "eval", "keyword" }, - { "mkdir", "keyword" }, - { "shmget", "keyword" }, - { "-k", "keyword" }, - { "exec", "keyword" }, - { "msgctl", "keyword" }, - { "shmread", "keyword" }, - { "-l", "keyword" }, - { "exists", "keyword" }, - { "msgget", "keyword" }, - { "shmwrite", "keyword" }, - { "-M", "keyword" }, - { "exit", "keyword" }, - { "msgrcv", "keyword" }, - { "shutdown", "keyword" }, - { "-O", "keyword" }, - { "fcntl", "keyword" }, - { "msgsnd", "keyword" }, - { "sin", "keyword" }, - { "-o", "keyword" }, - { "fileno", "keyword" }, - { "my", "keyword" }, - { "sleep", "keyword" }, - { "-p", "keyword" }, - { "flock", "keyword" }, - { "next", "keyword" }, - { "socket", "keyword" }, - { "package", "keyword" }, - { "-r", "keyword" }, - { "fork", "keyword" }, - { "not", "keyword" }, - { "socketpair", "keyword" }, - { "-R", "keyword" }, - { "format", "keyword" }, - { "oct", "keyword" }, - { "sort", "keyword" }, - { "-S", "keyword" }, - { "formline", "keyword" }, - { "open", "keyword" }, - { "splice", "keyword" }, - { "-s", "keyword" }, - { "getc", "keyword" }, - { "opendir", "keyword" }, - { "split", "keyword" }, - { "-T", "keyword" }, - { "getgrent", "keyword" }, - { "ord", "keyword" }, - { "sprintf", "keyword" }, - { "-t", "keyword" }, - { "getgrgid", "keyword" }, - { "our", "keyword" }, - { "sqrt", "keyword" }, - { "-u", "keyword" }, - { "getgrnam", "keyword" }, - { "pack", "keyword" }, - { "srand", "keyword" }, - { "-w", "keyword" }, - { "gethostbyaddr", "keyword" }, - { "pipe", "keyword" }, - { "stat", "keyword" }, - { "-W", "keyword" }, - { "gethostbyname", "keyword" }, - { "pop", "keyword" }, - { "state", "keyword" }, - { "-X", "keyword" }, - { "gethostent", "keyword" }, - { "pos", "keyword" }, - { "study", "keyword" }, - { "-x", "keyword" }, - { "getlogin", "keyword" }, - { "print", "keyword" }, - { "substr", "keyword" }, - { "-z", "keyword" }, - { "getnetbyaddr", "keyword" }, - { "printf", "keyword" }, - { "symlink", "keyword" }, - { "abs", "keyword" }, - { "getnetbyname", "keyword" }, - { "prototype", "keyword" }, - { "syscall", "keyword" }, - { "accept", "keyword" }, - { "getnetent", "keyword" }, - { "push", "keyword" }, - { "sysopen", "keyword" }, - { "alarm", "keyword" }, - { "getpeername", "keyword" }, - { "quotemeta", "keyword" }, - { "sysread", "keyword" }, - { "atan2", "keyword" }, - { "getpgrp", "keyword" }, - { "rand", "keyword" }, - { "sysseek", "keyword" }, - { "AUTOLOAD", "keyword" }, - { "getppid", "keyword" }, - { "read", "keyword" }, - { "system", "keyword" }, - { "BEGIN", "keyword" }, - { "getpriority", "keyword" }, - { "readdir", "keyword" }, - { "syswrite", "keyword" }, - { "bind", "keyword" }, - { "getprotobyname", "keyword" }, - { "readline", "keyword" }, - { "tell", "keyword" }, - { "binmode", "keyword" }, - { "getprotobynumber", "keyword" }, - { "SUPER", "keyword" }, - { "readlink", "keyword" }, - { "telldir", "keyword" }, - { "bless", "keyword" }, - { "sub", "keyword" }, - { "getprotoent", "keyword" }, - { "readpipe", "keyword" }, - { "tie", "keyword" }, - { "getpwent", "keyword" }, - { "recv", "keyword" }, - { "tied", "keyword" }, - { "caller", "keyword" }, - { "getpwnam", "keyword" }, - { "redo", "keyword" }, - { "time", "keyword" }, - { "chdir", "keyword" }, - { "getpwuid", "keyword" }, - { "ref", "keyword" }, - { "times", "keyword" }, - { "CHECK", "keyword" }, - { "getservbyname", "keyword" }, - { "rename", "keyword" }, - { "truncate", "keyword" }, - { "chmod", "keyword" }, - { "getservbyport", "keyword" }, - { "require", "keyword" }, - { "uc", "keyword" }, - { "chomp", "keyword" }, - { "getservent", "keyword" }, - { "reset", "keyword" }, - { "ucfirst", "keyword" }, - { "chop", "keyword" }, - { "getsockname", "keyword" }, - { "return", "keyword" }, - { "umask", "keyword" }, - { "chown", "keyword" }, - { "getsockopt", "keyword" }, - { "reverse", "keyword" }, - { "undef", "keyword" }, - { "chr", "keyword" }, - { "glob", "keyword" }, - { "rewinddir", "keyword" }, - { "UNITCHECK", "keyword" }, - { "chroot", "keyword" }, - { "gmtime", "keyword" }, - { "rindex", "keyword" }, - { "unlink", "keyword" }, - { "close", "keyword" }, - { "goto", "keyword" }, - { "rmdir", "keyword" }, - { "unpack", "keyword" }, - { "closedir", "keyword" }, - { "grep", "keyword" }, - { "say", "keyword" }, - { "unshift", "keyword" }, - { "connect", "keyword" }, - { "hex", "keyword" }, - { "scalar", "keyword" }, - { "untie", "keyword" }, - { "cos", "keyword" }, - { "index", "keyword" }, - { "seek", "keyword" }, - { "use", "keyword" }, - { "crypt", "keyword" }, - { "INIT", "keyword" }, - { "seekdir", "keyword" }, - { "utime", "keyword" }, - { "dbmclose", "keyword" }, - { "int", "keyword" }, - { "select", "keyword" }, - { "values", "keyword" }, - { "dbmopen", "keyword" }, - { "ioctl", "keyword" }, - { "semctl", "keyword" }, - { "vec", "keyword" }, - { "defined", "keyword" }, - { "join", "keyword" }, - { "semget", "keyword" }, - { "wait", "keyword" }, - { "delete", "keyword" }, - { "keys", "keyword" }, - { "semop", "keyword" }, - { "waitpid", "keyword" }, - { "DESTROY", "keyword" }, - { "kill", "keyword" }, - { "send", "keyword" }, - { "wantarray", "keyword" }, - { "die", "keyword" }, - { "last", "keyword" }, - { "setgrent", "keyword" }, - { "warn", "keyword" }, - { "dump", "keyword" }, - { "lc", "keyword" }, - { "sethostent", "keyword" }, - { "write", "keyword" }, - { "each", "keyword" }, - { "lcfirst", "keyword" }, - { "setnetent", "keyword" }, - }, - "#", - { "^#!.*[ /]perl" }, - } ); -} - static void addxit() { SyntaxDefinitionManager::instance()->add( { "[x]it!", @@ -4493,16 +2771,18 @@ static std::string funcName( std::string name ) { } std::pair SyntaxDefinitionManager::toCPP( const SyntaxDefinition& def ) { - std::string func( funcName( def.getLanguageName() ) ); + std::string lang( def.getLanguageNameForFileSystem() ); + std::string func( funcName( lang ) ); std::string header = "#ifndef EE_UI_DOC_" + func + "\n#define EE_UI_DOC_" + func + "\n\nnamespace EE { namespace UI { namespace " "Doc { namespace Language {\n\nextern void add" + func + "();\n\n}}}}\n\n#endif\n"; - std::string buf = R"cpp(#include + std::string buf = String::format( R"cpp(#include #include namespace EE { namespace UI { namespace Doc { namespace Language { -)cpp"; +)cpp", + lang.c_str() ); buf += "\nvoid add" + func + "() {\n"; buf += "\nSyntaxDefinitionManager::instance()->add(\n\n{"; // lang name @@ -4520,7 +2800,7 @@ namespace EE { namespace UI { namespace Doc { namespace Language { for ( const auto& symbol : def.getSymbols() ) buf += "{ " + str( symbol.first ) + " , " + str( symbol.second ) + " },\n"; buf += "\n},\n"; - buf += str( def.getComment(), "", "", false ) + ",\n"; + buf += str( def.getComment(), "", "", true ) + ",\n"; std::string lspName = def.getLSPName().empty() || def.getLSPName() == String::toLower( def.getLanguageName() ) ? "" diff --git a/src/eepp/ui/uicodeeditor.cpp b/src/eepp/ui/uicodeeditor.cpp index de6f0fde7..fef0aad62 100644 --- a/src/eepp/ui/uicodeeditor.cpp +++ b/src/eepp/ui/uicodeeditor.cpp @@ -261,11 +261,11 @@ void UICodeEditor::draw() { } if ( !mLocked && mHighlightCurrentLine ) { - for ( const auto& cursor : mDoc->getSelections() ) { + for ( const auto& sel : mDoc->getSelections() ) { primitives.setColor( Color( mCurrentLineBackgroundColor ).blendAlpha( mAlpha ) ); primitives.drawRectangle( Rectf( Vector2f( startScroll.x + mScroll.x, - startScroll.y + cursor.start().line() * lineHeight ), + startScroll.y + sel.start().line() * lineHeight ), Sizef( mSize.getWidth(), lineHeight ) ) ); } } @@ -335,8 +335,8 @@ void UICodeEditor::draw() { if ( mPluginsGutterSpace > 0 ) { Float curGutterPos = 0.f; for ( auto& plugin : mPluginGutterSpaces ) { - for ( unsigned long i = lineRange.first; i <= lineRange.second; i++ ) { - plugin.plugin->drawGutter( this, i, + for ( unsigned long gi = lineRange.first; gi <= lineRange.second; gi++ ) { + plugin.plugin->drawGutter( this, gi, { screenStart.x + curGutterPos, curScroll.y }, lineHeight, plugin.space, charSize ); } @@ -345,8 +345,8 @@ void UICodeEditor::draw() { } } - for ( const auto& cursor : mDoc->getSelections() ) - drawCursor( startScroll, lineHeight, cursor.start() ); + for ( const auto& sel : mDoc->getSelections() ) + drawCursor( startScroll, lineHeight, sel.start() ); if ( mShowLineNumber ) { drawLineNumbers( lineRange, startScroll, @@ -368,7 +368,12 @@ void UICodeEditor::draw() { } void UICodeEditor::scheduledUpdate( const Time& ) { - if ( hasFocus() && getUISceneNode()->getWindow()->hasFocus() ) { + if ( mLastActivity.getElapsedTime() > Seconds(60) ) { + if (!mCursorVisible) { + mCursorVisible = true; + invalidateDraw(); + } + } else if ( hasFocus() && getUISceneNode()->getWindow()->hasFocus() ) { if ( mBlinkTime != Time::Zero && mBlinkTimer.getElapsedTime() > mBlinkTime ) { mCursorVisible = !mCursorVisible; mBlinkTimer.restart(); @@ -855,6 +860,7 @@ Uint32 UICodeEditor::onFocus() { } for ( auto& plugin : mPlugins ) plugin->onFocus( this ); + mLastActivity.restart(); return UIWidget::onFocus(); } @@ -870,10 +876,13 @@ Uint32 UICodeEditor::onFocusLoss() { mDoc->setActiveClient( nullptr ); for ( auto& plugin : mPlugins ) plugin->onFocusLoss( this ); + mLastActivity.restart(); return UIWidget::onFocusLoss(); } Uint32 UICodeEditor::onTextInput( const TextInputEvent& event ) { + mLastActivity.restart(); + if ( mLocked || NULL == mFont ) return 0; Input* input = getUISceneNode()->getWindow()->getInput(); @@ -898,6 +907,8 @@ Uint32 UICodeEditor::onTextInput( const TextInputEvent& event ) { } Uint32 UICodeEditor::onKeyDown( const KeyEvent& event ) { + mLastActivity.restart(); + if ( NULL == mFont || mUISceneNode->getUIEventDispatcher()->justGainedFocus() ) return 0; @@ -918,6 +929,7 @@ Uint32 UICodeEditor::onKeyDown( const KeyEvent& event ) { } Uint32 UICodeEditor::onKeyUp( const KeyEvent& event ) { + mLastActivity.restart(); for ( auto& plugin : mPlugins ) if ( plugin->onKeyUp( this, event ) ) return 1; @@ -1087,6 +1099,7 @@ Int64 UICodeEditor::calculateMinimapClickedLine( const Vector2i& position ) { } Uint32 UICodeEditor::onMouseDown( const Vector2i& position, const Uint32& flags ) { + mLastActivity.restart(); for ( auto& plugin : mPlugins ) if ( plugin->onMouseDown( this, position, flags ) ) return UIWidget::onMouseDown( position, flags ); @@ -1188,6 +1201,7 @@ void UICodeEditor::updateMipmapHover( const Vector2f& position ) { } Uint32 UICodeEditor::onMouseMove( const Vector2i& position, const Uint32& flags ) { + mLastActivity.restart(); for ( auto& plugin : mPlugins ) if ( plugin->onMouseMove( this, position, flags ) ) return UIWidget::onMouseMove( position, flags ); @@ -1226,6 +1240,7 @@ Uint32 UICodeEditor::onMouseMove( const Vector2i& position, const Uint32& flags } Uint32 UICodeEditor::onMouseUp( const Vector2i& position, const Uint32& flags ) { + mLastActivity.restart(); for ( auto& plugin : mPlugins ) if ( plugin->onMouseUp( this, position, flags ) ) return UIWidget::onMouseUp( position, flags ); @@ -1271,6 +1286,7 @@ Uint32 UICodeEditor::onMouseUp( const Vector2i& position, const Uint32& flags ) } Uint32 UICodeEditor::onMouseClick( const Vector2i& position, const Uint32& flags ) { + mLastActivity.restart(); for ( auto& plugin : mPlugins ) if ( plugin->onMouseClick( this, position, flags ) ) return UIWidget::onMouseClick( position, flags ); @@ -1307,6 +1323,7 @@ Uint32 UICodeEditor::onMouseClick( const Vector2i& position, const Uint32& flags } Uint32 UICodeEditor::onMouseDoubleClick( const Vector2i& position, const Uint32& flags ) { + mLastActivity.restart(); for ( auto& plugin : mPlugins ) if ( plugin->onMouseDoubleClick( this, position, flags ) ) return UIWidget::onMouseDoubleClick( position, flags ); @@ -1329,6 +1346,7 @@ Uint32 UICodeEditor::onMouseDoubleClick( const Vector2i& position, const Uint32& } Uint32 UICodeEditor::onMouseOver( const Vector2i& position, const Uint32& flags ) { + mLastActivity.restart(); for ( auto& plugin : mPlugins ) if ( plugin->onMouseOver( this, position, flags ) ) return UIWidget::onMouseOver( position, flags ); @@ -1338,6 +1356,7 @@ Uint32 UICodeEditor::onMouseOver( const Vector2i& position, const Uint32& flags } Uint32 UICodeEditor::onMouseLeave( const Vector2i& position, const Uint32& flags ) { + mLastActivity.restart(); if ( mMinimapHover ) { mMinimapHover = false; invalidateDraw(); @@ -3206,6 +3225,7 @@ void UICodeEditor::registerKeybindings() { } void UICodeEditor::onCursorPosChange() { + mLastActivity.restart(); sendCommonEvent( Event::OnCursorPosChange ); invalidateDraw(); } diff --git a/src/tools/ecode/ecode.cpp b/src/tools/ecode/ecode.cpp index 4acf67a2d..4cc7f0872 100644 --- a/src/tools/ecode/ecode.cpp +++ b/src/tools/ecode/ecode.cpp @@ -3503,26 +3503,23 @@ EE_MAIN_FUNC int main( int argc, char* argv[] ) { if ( convertLangPath && !convertLangPath.Get().empty() ) { Sys::windowAttachConsole(); IOStreamFile sfile( convertLangPath.Get() ); - if ( sfile.isOpen() ) { - std::vector adedLangs; - if ( SyntaxDefinitionManager::instance()->loadFromStream( sfile, &adedLangs ) ) { - for ( const auto& lang : adedLangs ) { - const auto& def = - SyntaxDefinitionManager::instance()->getByLanguageName( lang ); - auto code = SyntaxDefinitionManager::toCPP( def ); - if ( convertLangOutput && !convertLangOutput.Get().empty() && - FileSystem::isDirectory( convertLangOutput.Get() ) ) { - std::string output( convertLangOutput.Get() ); - FileSystem::dirAddSlashAtEnd( output ); - FileSystem::fileWrite( output + String::toLower( def.getLanguageName() ) + - ".hpp", - code.first ); - FileSystem::fileWrite( output + String::toLower( def.getLanguageName() ) + - ".cpp", - code.second ); - } else { - std::cout << code.first << code.second << "\n"; - } + if ( !sfile.isOpen() ) + return EXIT_FAILURE; + std::vector adedLangs; + if ( SyntaxDefinitionManager::instance()->loadFromStream( sfile, &adedLangs ) ) { + for ( const auto& lang : adedLangs ) { + const auto& def = + SyntaxDefinitionManager::instance()->getByLanguageName( lang ); + auto code = SyntaxDefinitionManager::toCPP( def ); + if ( convertLangOutput && !convertLangOutput.Get().empty() && + FileSystem::isDirectory( convertLangOutput.Get() ) ) { + std::string output( convertLangOutput.Get() ); + FileSystem::dirAddSlashAtEnd( output ); + std::string fileName( def.getLanguageNameForFileSystem() ); + FileSystem::fileWrite( output + fileName + ".hpp", code.first ); + FileSystem::fileWrite( output + fileName + ".cpp", code.second ); + } else { + std::cout << code.first << code.second << "\n"; } } }