src/eric7/QScintilla/Lexers/__init__.py

branch
eric7
changeset 9484
d2eb8f0a5bf0
parent 9482
a2bc06a54d9d
child 9497
8beca4047c53
--- a/src/eric7/QScintilla/Lexers/__init__.py	Mon Nov 07 19:07:21 2022 +0100
+++ b/src/eric7/QScintilla/Lexers/__init__.py	Tue Nov 08 11:14:44 2022 +0100
@@ -7,6 +7,8 @@
 Package implementing lexers for the various supported programming languages.
 """
 
+import importlib
+
 from PyQt6.QtCore import QCoreApplication
 
 from eric7 import Preferences
@@ -287,156 +289,56 @@
     @return reference to the instantiated lexer object (QsciLexer)
     """
     if not pyname:
+        languageLexerMapping = {
+            "Bash": "LexerBash",
+            "Batch": "LexerBatch",
+            "C#": "LexerCSharp",
+            "C++": "LexerCPP",
+            "CMake": "LexerCMake",
+            "CoffeeScript": "LexerCoffeeScript",
+            "CSS": "LexerCSS",
+            "Cython": "LexerPython",
+            "D": "LexerD",
+            "Diff": "LexerDiff",
+            "Fortran": "LexerFortran",
+            "Fortran77": "LexerFortran77",
+            "Gettext": "LexerPO",
+            "HTML": "LexerHTML",
+            "IDL": "LexerIDL",
+            "Java": "LexerJava",
+            "JavaScript": "LexerJavaScript",
+            "JSON": "LexerJSON",
+            "Lua": "LexerLua",
+            "Makefile": "LexerMakefile",
+            "Markdown": "LexerMarkdown",
+            "Matlab": "LexerMatlab",
+            "MicroPython": "LexerPython",
+            "Octave": "LexerOctave",
+            "Pascal": "LexerPascal",
+            "Perl": "LexerPerl",
+            "PostScript": "LexerPostScript",
+            "Properties": "LexerProperties",
+            "Povray": "LexerPOV",
+            "Python": "LexerPython",
+            "Python3": "LexerPython",
+            "QSS": "LexerQSS",
+            "Ruby": "LexerRuby",
+            "SQL": "LexerSQL",
+            "TCL": "LexerTCL",
+            "TeX": "LexerTeX",
+            "VHDL": "LexerVHDL",
+            "XML": "LexerXML",
+            "YAML": "LexerYAML",
+        }
         try:
-            if language in ["Python", "Python3", "Cython", "MicroPython"]:
-                from .LexerPython import LexerPython  # __IGNORE_WARNING_I101__
-
-                return LexerPython(language, parent)
-            elif language == "C++":
-                from .LexerCPP import LexerCPP  # __IGNORE_WARNING_I101__
-
-                return LexerCPP(
-                    parent, Preferences.getEditor("CppCaseInsensitiveKeywords")
+            if language in languageLexerMapping:
+                mod = importlib.import_module(
+                    "eric7.QScintilla.Lexers.{0}".format(languageLexerMapping[language])
                 )
-            elif language == "C#":
-                from .LexerCSharp import LexerCSharp  # __IGNORE_WARNING_I101__
-
-                return LexerCSharp(parent)
-            elif language == "IDL":
-                from .LexerIDL import LexerIDL  # __IGNORE_WARNING_I101__
-
-                return LexerIDL(parent)
-            elif language == "Java":
-                from .LexerJava import LexerJava  # __IGNORE_WARNING_I101__
-
-                return LexerJava(parent)
-            elif language == "JavaScript":
-                from .LexerJavaScript import LexerJavaScript  # __IGNORE_WARNING_I101__
-
-                return LexerJavaScript(parent)
-            elif language == "SQL":
-                from .LexerSQL import LexerSQL  # __IGNORE_WARNING_I101__
-
-                return LexerSQL(parent)
-            elif language == "HTML":
-                from .LexerHTML import LexerHTML  # __IGNORE_WARNING_I101__
-
-                return LexerHTML(parent)
-            elif language == "Perl":
-                from .LexerPerl import LexerPerl  # __IGNORE_WARNING_I101__
-
-                return LexerPerl(parent)
-            elif language == "Bash":
-                from .LexerBash import LexerBash  # __IGNORE_WARNING_I101__
-
-                return LexerBash(parent)
-            elif language == "Ruby":
-                from .LexerRuby import LexerRuby  # __IGNORE_WARNING_I101__
-
-                return LexerRuby(parent)
-            elif language == "Lua":
-                from .LexerLua import LexerLua  # __IGNORE_WARNING_I101__
-
-                return LexerLua(parent)
-            elif language == "CSS":
-                from .LexerCSS import LexerCSS  # __IGNORE_WARNING_I101__
-
-                return LexerCSS(parent)
-            elif language == "TeX":
-                from .LexerTeX import LexerTeX  # __IGNORE_WARNING_I101__
-
-                return LexerTeX(parent)
-            elif language == "Diff":
-                from .LexerDiff import LexerDiff  # __IGNORE_WARNING_I101__
-
-                return LexerDiff(parent)
-            elif language == "Makefile":
-                from .LexerMakefile import LexerMakefile  # __IGNORE_WARNING_I101__
-
-                return LexerMakefile(parent)
-            elif language == "Properties":
-                from .LexerProperties import LexerProperties  # __IGNORE_WARNING_I101__
-
-                return LexerProperties(parent)
-            elif language == "Batch":
-                from .LexerBatch import LexerBatch  # __IGNORE_WARNING_I101__
-
-                return LexerBatch(parent)
-            elif language == "D":
-                from .LexerD import LexerD  # __IGNORE_WARNING_I101__
-
-                return LexerD(parent)
-            elif language == "Povray":
-                from .LexerPOV import LexerPOV  # __IGNORE_WARNING_I101__
-
-                return LexerPOV(parent)
-            elif language == "CMake":
-                from .LexerCMake import LexerCMake  # __IGNORE_WARNING_I101__
-
-                return LexerCMake(parent)
-            elif language == "VHDL":
-                from .LexerVHDL import LexerVHDL  # __IGNORE_WARNING_I101__
-
-                return LexerVHDL(parent)
-            elif language == "TCL":
-                from .LexerTCL import LexerTCL  # __IGNORE_WARNING_I101__
-
-                return LexerTCL(parent)
-            elif language == "Fortran":
-                from .LexerFortran import LexerFortran  # __IGNORE_WARNING_I101__
-
-                return LexerFortran(parent)
-            elif language == "Fortran77":
-                from .LexerFortran77 import LexerFortran77  # __IGNORE_WARNING_I101__
-
-                return LexerFortran77(parent)
-            elif language == "Pascal":
-                from .LexerPascal import LexerPascal  # __IGNORE_WARNING_I101__
-
-                return LexerPascal(parent)
-            elif language == "PostScript":
-                from .LexerPostScript import LexerPostScript  # __IGNORE_WARNING_I101__
-
-                return LexerPostScript(parent)
-            elif language == "XML":
-                from .LexerXML import LexerXML  # __IGNORE_WARNING_I101__
-
-                return LexerXML(parent)
-            elif language == "YAML":
-                from .LexerYAML import LexerYAML  # __IGNORE_WARNING_I101__
-
-                return LexerYAML(parent)
-            elif language == "Matlab":
-                from .LexerMatlab import LexerMatlab  # __IGNORE_WARNING_I101__
-
-                return LexerMatlab(parent)
-            elif language == "Octave":
-                from .LexerOctave import LexerOctave  # __IGNORE_WARNING_I101__
-
-                return LexerOctave(parent)
-            elif language == "QSS":
-                from .LexerQSS import LexerQSS  # __IGNORE_WARNING_I101__
-
-                return LexerQSS(parent)
-            elif language == "Gettext":
-                from .LexerPO import LexerPO  # __IGNORE_WARNING_I101__
-
-                return LexerPO(parent)
-            elif language == "CoffeeScript":
-                from .LexerCoffeeScript import (  # __IGNORE_WARNING_I101__
-                    LexerCoffeeScript,
-                )
-
-                return LexerCoffeeScript(parent)
-            elif language == "JSON":
-                from .LexerJSON import LexerJSON  # __IGNORE_WARNING_I101__
-
-                return LexerJSON(parent)
-            elif language == "Markdown":
-                from .LexerMarkdown import LexerMarkdown  # __IGNORE_WARNING_I101__
-
-                return LexerMarkdown(parent)
-
+                if mod:
+                    return mod.createLexer(language, parent)
+                else:
+                    return __getPygmentsLexer(parent)
             elif language == "Protocol Buffer":
                 return __getPygmentsLexer(parent, name="Protocol Buffer")
 

eric ide

mercurial