Added eC syntax highlighting (SpartanJ/ecode#485).

Fixed health feature.

src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/ec.cpp

@@ -0,0 +1,175 @@
+#include <eepp/ui/doc/languages/ec.hpp>
+#include <eepp/ui/doc/syntaxdefinitionmanager.hpp>
+
+namespace EE { namespace UI { namespace Doc { namespace Language {
+
+SyntaxDefinition& addeC() {
+
+	return SyntaxDefinitionManager::instance()
+		->add(
+
+			{ "eC",
+			  { "%.ec$", "%.eh$" },
+			  {
+				  { { "//.-\n" }, "comment" },
+				  { { "/%*", "%*/" }, "comment" },
+				  { { "(#%s*include)%s+([<%\"][%w%d%.%\\%/%_%-]+[>%\"])" },
+					{ "keyword", "keyword", "literal" } },
+				  { { "\"", "[\"\n]", "\\" }, "string" },
+				  { { "'", "'", "\\" }, "string" },
+				  { { "(class|struct)\\s+([A-Za-z]\\w*)\\s*:\\s*([A-Za-z]\\w*)" },
+					{ "keyword", "keyword", "keyword2", "keyword2" },
+					"",
+					SyntaxPatternMatchType::RegEx },
+				  { { "(class|struct)\\s+([A-Za-z]\\w*)" },
+					{ "keyword", "keyword", "keyword2" },
+					"",
+					SyntaxPatternMatchType::RegEx },
+				  { { "c_number_parser" }, "number", "", SyntaxPatternMatchType::Parser },
+				  { { "[%+%-=/%*%^%%<>!~|&]" }, "operator" },
+				  { { "(if|for|while|switch)\\s*(?=\\()" },
+					{ "normal", "keyword", "keyword" },
+					"",
+					SyntaxPatternMatchType::RegEx },
+				  { { "[%a_][%w_]*%f[(]" }, "function" },
+				  { { "#[%a_][%w_]*" }, "symbol" },
+				  { { "[%a_][%w_]*" }, "symbol" },
+
+			  },
+			  {
+
+				  { "elseif", "keyword" },
+				  { "int", "keyword2" },
+				  { "then", "keyword" },
+				  { "unsigned", "keyword2" },
+				  { "continue", "keyword" },
+				  { "default", "keyword" },
+				  { "volatile", "keyword" },
+				  { "switch", "keyword" },
+				  { "char", "keyword2" },
+				  { "double", "keyword2" },
+				  { "auto", "keyword" },
+				  { "bool", "keyword2" },
+				  { "return", "keyword" },
+				  { "extern", "keyword" },
+				  { "NULL", "literal" },
+				  { "long", "keyword2" },
+				  { "void", "keyword" },
+				  { "union", "keyword" },
+				  { "short", "keyword2" },
+				  { "static", "keyword" },
+				  { "inline", "keyword" },
+				  { "false", "literal" },
+				  { "for", "keyword" },
+				  { "goto", "keyword" },
+				  { "while", "keyword" },
+				  { "const", "keyword" },
+				  { "int32_t", "keyword2" },
+				  { "int16_t", "keyword2" },
+				  { "uint16_t", "keyword2" },
+				  { "typedef", "keyword" },
+				  { "true", "literal" },
+				  { "else", "keyword" },
+				  { "uint32_t", "keyword2" },
+				  { "enum", "keyword" },
+				  { "int8_t", "keyword2" },
+				  { "int64_t", "keyword2" },
+				  { "float", "keyword2" },
+				  { "struct", "keyword" },
+				  { "break", "keyword" },
+				  { "uint8_t", "keyword2" },
+				  { "uint64_t", "keyword2" },
+				  { "case", "keyword" },
+				  { "if", "keyword" },
+				  { "do", "keyword" },
+
+				  { "#if", "keyword" },
+				  { "#ifdef", "keyword" },
+				  { "#ifndef", "keyword" },
+				  { "#elif", "keyword" },
+				  { "#else", "keyword" },
+				  { "#endif", "keyword" },
+				  { "#define", "keyword" },
+				  { "#undef", "keyword" },
+				  { "#include", "keyword" },
+				  { "#line", "keyword" },
+				  { "#error", "keyword" },
+				  { "#pragma", "keyword" },
+				  { "#warning ", "keyword" },
+				  { "#elifdef ", "keyword" },
+				  { "#elifndef ", "keyword" },
+
+				  { "class", "keyword" },
+				  { "private", "keyword" },
+				  { "public", "keyword" },
+				  { "property", "keyword" },
+				  { "import", "keyword" },
+				  { "delete", "keyword" },
+				  { "new", "keyword" },
+				  { "new0", "keyword" },
+				  { "renew", "keyword" },
+				  { "renew0", "keyword" },
+				  { "define", "keyword" },
+				  { "get", "keyword" },
+				  { "set", "keyword" },
+				  { "remote", "keyword" },
+				  { "dllexport", "keyword" },
+				  { "dllimport", "keyword" },
+				  { "stdcall", "keyword" },
+				  { "subclass", "keyword" },
+				  { "__on_register_module", "keyword" },
+				  { "namespace", "keyword" },
+				  { "using", "keyword" },
+				  { "typed_object", "keyword" },
+				  { "any_object", "keyword" },
+				  { "incref", "keyword" },
+				  { "register", "keyword" },
+				  { "watch", "keyword" },
+				  { "stopwatching", "keyword" },
+				  { "firewatchers", "keyword" },
+				  { "watchable", "keyword" },
+				  { "class_designer", "keyword" },
+				  { "class_fixed", "keyword" },
+				  { "class_no_expansion", "keyword" },
+				  { "isset", "keyword" },
+				  { "class_default_property", "keyword" },
+				  { "property_category", "keyword" },
+				  { "class_data", "keyword" },
+				  { "class_property", "keyword" },
+				  { "virtual", "keyword" },
+				  { "thisclass", "keyword" },
+				  { "unichar", "keyword" },
+				  { "dbtable", "keyword" },
+				  { "dbindex", "keyword" },
+				  { "database_open", "keyword" },
+				  { "dbfield", "keyword" },
+
+				  { "uint", "keyword2" },
+				  { "uint32", "keyword2" },
+				  { "uint16", "keyword2" },
+				  { "uint64", "keyword2" },
+				  { "bool", "keyword2" },
+				  { "byte", "keyword2" },
+				  { "int64", "keyword2" },
+				  { "uintptr", "keyword2" },
+				  { "intptr", "keyword2" },
+				  { "intsize", "keyword2" },
+				  { "uintsize", "keyword2" },
+				  { "string", "keyword2" },
+				  { "unichar", "keyword2" },
+
+				  { "this", "keyword" },
+				  { "false", "keyword" },
+				  { "null", "literal" },
+				  { "value", "literal" },
+
+			  },
+			  "//",
+			  {}
+
+			} )
+		.setFoldRangeType( FoldRangeType::Braces )
+		.setFoldBraces( { { '{', '}' } } );
+}
+
+}}}} // namespace EE::UI::Doc::Language

src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languages/ec.hpp

@@ -0,0 +1,12 @@
+#ifndef EE_UI_DOC_eC
+#define EE_UI_DOC_eC
+
+#include <eepp/ui/doc/syntaxdefinition.hpp>
+
+namespace EE { namespace UI { namespace Doc { namespace Language {
+
+extern SyntaxDefinition& addeC();
+
+}}}} // namespace EE::UI::Doc::Language
+
+#endif

src/modules/languages-syntax-highlighting/src/eepp/ui/doc/languagessyntaxhighlighting.cpp

@@ -20,6 +20,7 @@
 #include <eepp/ui/doc/languages/d.hpp>
 #include <eepp/ui/doc/languages/dart.hpp>
 #include <eepp/ui/doc/languages/difffile.hpp>
+#include <eepp/ui/doc/languages/ec.hpp>
 #include <eepp/ui/doc/languages/elena.hpp>
 #include <eepp/ui/doc/languages/elixir.hpp>
 #include <eepp/ui/doc/languages/elm.hpp>
@@ -227,6 +228,12 @@ void LanguagesSyntaxHighlighting::load() {
 		"csharp",
 	} );
 
+	sdm->addPreDefinition( {
+		"eC",
+		[]() -> SyntaxDefinition& { return addeC(); },
+		{ "%.ec$", "%.eh$" },
+	} );
+
 	sdm->addPreDefinition( {
 		"OpenSCAD",
 		[]() -> SyntaxDefinition& { return addOpenSCAD(); },

src/tools/ecode/ecode.cpp

@@ -1786,73 +1786,67 @@ std::map<KeyBindings::Shortcut, std::string> App::getDefaultKeybindings() {
 std::map<KeyBindings::Shortcut, std::string> App::getLocalKeybindings() {
 	return {
 		{ { KEY_RETURN, KEYMOD_LALT | KEYMOD_LCTRL }, "fullscreen-toggle" },
-			{ { KEY_F3, KEYMOD_NONE }, "repeat-find" }, { { KEY_F3, KEYMOD_SHIFT }, "find-prev" },
-			{ { KEY_F12, KEYMOD_NONE }, "console-toggle" },
-			{ { KEY_F, KeyMod::getDefaultModifier() }, "find-replace" },
-			{ { KEY_Q, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "close-app" },
-			{ { KEY_O, KeyMod::getDefaultModifier() }, "open-file" },
-			{ { KEY_W, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "download-file-web" },
-			{ { KEY_O, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "open-folder" },
-			{ { KEY_F11, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "debug-widget-tree-view" },
-			{ { KEY_K, KeyMod::getDefaultModifier() }, "open-locatebar" },
-			{ { KEY_P, KeyMod::getDefaultModifier() }, "open-command-palette" },
-			{ { KEY_F, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "open-global-search" },
-			{ { KEY_L, KeyMod::getDefaultModifier() }, "go-to-line" },
+		{ { KEY_F3, KEYMOD_NONE }, "repeat-find" },
+		{ { KEY_F3, KEYMOD_SHIFT }, "find-prev" },
+		{ { KEY_F12, KEYMOD_NONE }, "console-toggle" },
+		{ { KEY_F, KeyMod::getDefaultModifier() }, "find-replace" },
+		{ { KEY_Q, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "close-app" },
+		{ { KEY_O, KeyMod::getDefaultModifier() }, "open-file" },
+		{ { KEY_W, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "download-file-web" },
+		{ { KEY_O, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "open-folder" },
+		{ { KEY_F11, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "debug-widget-tree-view" },
+		{ { KEY_K, KeyMod::getDefaultModifier() }, "open-locatebar" },
+		{ { KEY_P, KeyMod::getDefaultModifier() }, "open-command-palette" },
+		{ { KEY_F, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "open-global-search" },
+		{ { KEY_L, KeyMod::getDefaultModifier() }, "go-to-line" },
 #if EE_PLATFORM == EE_PLATFORM_MACOS
-			{ { KEY_M, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "menu-toggle" },
+		{ { KEY_M, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "menu-toggle" },
 #else
-			{ { KEY_M, KeyMod::getDefaultModifier() }, "menu-toggle" },
+		{ { KEY_M, KeyMod::getDefaultModifier() }, "menu-toggle" },
 #endif
-			{ { KEY_S, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "save-all" },
-			{ { KEY_F9, KEYMOD_LALT }, "switch-side-panel" },
-			{ { KEY_J, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
-			  "terminal-split-left" },
-			{ { KEY_L, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
-			  "terminal-split-right" },
-			{ { KEY_I, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
-			  "terminal-split-top" },
-			{ { KEY_K, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
-			  "terminal-split-bottom" },
-			{ { KEY_S, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
-			  "terminal-split-swap" },
-			{ { KEY_T, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
-			  "reopen-closed-tab" },
-			{ { KEY_1, KEYMOD_LALT }, "toggle-status-locate-bar" },
-			{ { KEY_2, KEYMOD_LALT }, "toggle-status-global-search-bar" },
-			{ { KEY_3, KEYMOD_LALT }, "toggle-status-terminal" },
-			{ { KEY_4, KEYMOD_LALT }, "toggle-status-build-output" },
-			{ { KEY_5, KEYMOD_LALT }, "toggle-status-app-output" },
-			{ { KEY_B, KeyMod::getDefaultModifier() | KEYMOD_SHIFT },
-			  "project-build-start-cancel" },
-			{ { KEY_C, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "project-build-cancel" },
-			{ { KEY_R, KeyMod::getDefaultModifier() }, "project-build-and-run" },
-			{ { KEY_O, KEYMOD_LALT | KEYMOD_SHIFT }, "show-open-documents" },
-			{ { KEY_K, KeyMod::getDefaultModifier() | KEYMOD_SHIFT },
-			  "open-workspace-symbol-search" },
-			{ { KEY_P, KeyMod::getDefaultModifier() | KEYMOD_SHIFT },
-			  "open-document-symbol-search" },
-			{ { KEY_N, KEYMOD_SHIFT | KEYMOD_LALT }, "create-new-window" },
+		{ { KEY_S, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "save-all" },
+		{ { KEY_F9, KEYMOD_LALT }, "switch-side-panel" },
+		{ { KEY_J, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
+		  "terminal-split-left" },
+		{ { KEY_L, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
+		  "terminal-split-right" },
+		{ { KEY_I, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
+		  "terminal-split-top" },
+		{ { KEY_K, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
+		  "terminal-split-bottom" },
+		{ { KEY_S, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
+		  "terminal-split-swap" },
+		{ { KEY_T, KeyMod::getDefaultModifier() | KEYMOD_LALT | KEYMOD_SHIFT },
+		  "reopen-closed-tab" },
+		{ { KEY_1, KEYMOD_LALT }, "toggle-status-locate-bar" },
+		{ { KEY_2, KEYMOD_LALT }, "toggle-status-global-search-bar" },
+		{ { KEY_3, KEYMOD_LALT }, "toggle-status-terminal" },
+		{ { KEY_4, KEYMOD_LALT }, "toggle-status-build-output" },
+		{ { KEY_5, KEYMOD_LALT }, "toggle-status-app-output" },
+		{ { KEY_B, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "project-build-start-cancel" },
+		{ { KEY_C, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "project-build-cancel" },
+		{ { KEY_R, KeyMod::getDefaultModifier() }, "project-build-and-run" },
+		{ { KEY_O, KEYMOD_LALT | KEYMOD_SHIFT }, "show-open-documents" },
+		{ { KEY_K, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "open-workspace-symbol-search" },
+		{ { KEY_P, KeyMod::getDefaultModifier() | KEYMOD_SHIFT }, "open-document-symbol-search" },
+		{ { KEY_N, KEYMOD_SHIFT | KEYMOD_LALT }, "create-new-window" },
 	};
 }
 
 // Old keybindings will be rebinded to the new keybindings when they are still set to the old
 // keybindind
 std::map<std::string, std::string> App::getMigrateKeybindings() {
-	return {
-		{ "fullscreen-toggle", "alt+return" }, { "switch-to-tab-1", "alt+1" },
-			{ "switch-to-tab-2", "alt+2" }, { "switch-to-tab-3", "alt+3" },
-			{ "switch-to-tab-4", "alt+4" }, { "switch-to-tab-5", "alt+5" },
-			{ "switch-to-tab-6", "alt+6" }, { "switch-to-tab-7", "alt+7" },
-			{ "switch-to-tab-8", "alt+8" }, { "switch-to-tab-9", "alt+9" },
-			{ "switch-to-last-tab", "alt+0" },
+	return { { "fullscreen-toggle", "alt+return" }, { "switch-to-tab-1", "alt+1" },
+			 { "switch-to-tab-2", "alt+2" },		{ "switch-to-tab-3", "alt+3" },
+			 { "switch-to-tab-4", "alt+4" },		{ "switch-to-tab-5", "alt+5" },
+			 { "switch-to-tab-6", "alt+6" },		{ "switch-to-tab-7", "alt+7" },
+			 { "switch-to-tab-8", "alt+8" },		{ "switch-to-tab-9", "alt+9" },
+			 { "switch-to-last-tab", "alt+0" },
 #if EE_PLATFORM == EE_PLATFORM_MACOS
-			{ "menu-toggle", "mod+shift+m" },
+			 { "menu-toggle", "mod+shift+m" },
 #endif
-			{ "lock-toggle", "mod+shift+l" }, { "debug-widget-tree-view", "f11" },
-			{ "project-build-and-run", "f5" }, {
-			"project-build-start", "mod+shift+b"
-		}
-	};
+			 { "lock-toggle", "mod+shift+l" },		{ "debug-widget-tree-view", "f11" },
+			 { "project-build-and-run", "f5" },		{ "project-build-start", "mod+shift+b" } };
 }
 
 std::vector<std::string> App::getUnlockedCommands() {
@@ -3497,10 +3491,9 @@ void App::init( const LogLevel& logLevel, std::string file, const Float& pidelDe
 	mConfig.windowState.pixelDensity =
 		pidelDensity > 0
 			? pidelDensity
-			: ( mConfig.windowState.pixelDensity > 0
-					? mConfig.windowState.pixelDensity
-					: currentDisplay->getPixelDensity() > 2 ? currentDisplay->getPixelDensity() / 2
-															: currentDisplay->getPixelDensity() );
+			: ( mConfig.windowState.pixelDensity > 0	? mConfig.windowState.pixelDensity
+				: currentDisplay->getPixelDensity() > 2 ? currentDisplay->getPixelDensity() / 2
+														: currentDisplay->getPixelDensity() );
 #else
 	mConfig.windowState.pixelDensity =
 		pidelDensity > 0
@@ -4269,7 +4262,8 @@ EE_MAIN_FUNC int main( int argc, char* argv[] ) {
 					   benchmarkMode.Get(), css.Get(), file.Get(), verbose.Get(),
 					   disableFileLogs.Get(), openClean.Get(), portable.Get(), language.Get(),
 					   incognito.Get(),
-					   health || ( exportLangPath && !exportLangPath.Get().empty() ) );
+					   health || ( healthLang && !healthLang.Get().empty() ) ||
+						   ( exportLangPath && !exportLangPath.Get().empty() ) );
 
 	if ( exportLangPath && !exportLangPath.Get().empty() ) {
 		Sys::windowAttachConsole();
@@ -4277,7 +4271,7 @@ EE_MAIN_FUNC int main( int argc, char* argv[] ) {
 		return EXIT_SUCCESS;
 	}
 
-	if ( health ) {
+	if ( health || ( healthLang && !healthLang.Get().empty() ) ) {
 		Sys::windowAttachConsole();
 		Language::LanguagesSyntaxHighlighting::load();
 		SyntaxDefinitionManager::instance()->loadFromFolder( appInstance->getLanguagesPath() );

src/tools/ecode/featureshealth.cpp

@@ -42,6 +42,16 @@ std::vector<FeaturesHealth::LangHealth> FeaturesHealth::getHealth( PluginManager
 	bool ownsDebugger = false;
 
 	const auto& definitions = SyntaxDefinitionManager::instance()->getDefinitions();
+	const auto& preDefinitions = SyntaxDefinitionManager::instance()->getPreDefinitions();
+
+	std::set<std::string> languages;
+
+	for ( const auto& def : definitions )
+		if ( def.isVisible() )
+			languages.insert( def.getLSPName() );
+
+	for ( const auto& pdef : preDefinitions )
+		languages.insert( pdef.getLSPName() );
 
 	LinterPlugin* linter = static_cast<LinterPlugin*>( pluginManager->get( "linter" ) );
 
@@ -71,19 +81,16 @@ std::vector<FeaturesHealth::LangHealth> FeaturesHealth::getHealth( PluginManager
 		debugger = static_cast<DebuggerPlugin*>( DebuggerPlugin::NewSync( pluginManager ) );
 	}
 
-	for ( const auto& def : definitions ) {
-		if ( !def.isVisible() )
-			continue;
-
-		if ( !langFilter.empty() && langFilter != def.getLSPName() )
+	for ( const auto& name : languages ) {
+		if ( !langFilter.empty() && langFilter != name )
 			continue;
 
 		FeaturesHealth::LangHealth lang;
-		lang.lang = def.getLSPName();
+		lang.lang = name;
 		lang.syntaxHighlighting = true;
 
 		if ( linter ) {
-			Linter found = linter->getLinterForLang( def.getLSPName() );
+			Linter found = linter->getLinterForLang( lang.lang );
 			if ( !found.command.empty() ) {
 				lang.linter.name =
 					found.isNative ? "native" : String::split( found.command, ' ' )[0];
@@ -94,7 +101,7 @@ std::vector<FeaturesHealth::LangHealth> FeaturesHealth::getHealth( PluginManager
 		}
 
 		if ( formatter ) {
-			FormatterPlugin::Formatter found = formatter->getFormatterForLang( def.getLSPName() );
+			FormatterPlugin::Formatter found = formatter->getFormatterForLang( lang.lang );
 			if ( !found.command.empty() ) {
 				lang.formatter.name = found.type == FormatterPlugin::FormatterType::Native
 										  ? "native"
@@ -107,7 +114,7 @@ std::vector<FeaturesHealth::LangHealth> FeaturesHealth::getHealth( PluginManager
 		}
 
 		if ( lsp ) {
-			LSPDefinition found = lsp->getClientManager().getLSPForLang( def.getLSPName() );
+			LSPDefinition found = lsp->getClientManager().getLSPForLang( lang.lang );
 			if ( !found.command.empty() ) {
 				lang.lsp.name = found.name;
 				lang.lsp.url = found.url;
@@ -117,7 +124,7 @@ std::vector<FeaturesHealth::LangHealth> FeaturesHealth::getHealth( PluginManager
 		}
 
 		if ( debugger ) {
-			std::vector<DapTool> found = debugger->getDebuggersForLang( def.getLSPName() );
+			std::vector<DapTool> found = debugger->getDebuggersForLang( lang.lang );
 			for ( const auto& dbg : found ) {
 				FeatureStatus fdbg;
 				fdbg.name = dbg.name;