Define ILexer5 with methods for retrieving name, ID, and property values.

Implement ILexer5 on object lexers.
Implement ILexer5 on LexerSimple wrapper for function lexers.

39 files changed, 309 insertions, 102 deletions

diff --git a/doc/ScintillaDoc.html b/doc/ScintillaDoc.html
index 3a25677c7..53bfec16a 100644
--- a/doc/ScintillaDoc.html
+++ b/doc/ScintillaDoc.html
@@ -285,7 +285,7 @@
     <p>Lexilla follows the <a class="seealso" href="#SCI_LOADLEXERLIBRARY">external lexer protocol</a>
     so can be loaded by applications that support this.
     As the protocol only supports object lexers, an additional function <code>CreateLexer(const char *name)</code>
-    is exposed which will create a lexer object (ILexer4 *) for any object lexer or function lexer.
+    is exposed which will create a lexer object (ILexer5 *) for any object lexer or function lexer.
     </p>
 
     <h2 id="MessageCategories">Contents</h2>
@@ -7123,6 +7123,8 @@ sptr_t CallScintilla(unsigned int iMessage, uptr_t wParam, sptr_t lParam){
     can be used during lexing. For example a C++ lexer may store a set of preprocessor definitions
     or variable declarations and style these depending on their role.</p>
 
+    <p class="provisional">ILexer4 is extended with the provisional ILexer5 interface to support use of Lexilla.</p>
+
     <p>A set of helper classes allows older lexers defined by functions to be used in Scintilla.</p>
 <h4>ILexer4</h4>
 
@@ -7157,6 +7159,18 @@ sptr_t CallScintilla(unsigned int iMessage, uptr_t wParam, sptr_t lParam){
 <span class="S10">};</span><br />
 </div>
 
+<h4 class="provisional">ILexer5</h4>
+
+<div class="highlighted">
+<span><span class="S5">class</span><span class="S0"> </span>ILexer5<span class="S0"> </span><span class="S10">:</span><span class="S0"> </span><span class="S5">public</span><span class="S0"> </span>ILexer4<span class="S0"> </span><span class="S10">{</span><br />
+<span class="S5">public</span><span class="S10">:</span><br />
+<span class="S0">&nbsp; &nbsp; &nbsp; &nbsp; </span><span class="S5">virtual</span><span class="S0"> </span><span class="S5">const</span><span class="S0"> </span><span class="S5">char</span><span class="S0"> </span><span class="S10">*</span><span class="S0"> </span>SCI_METHOD<span class="S0"> </span>GetName<span class="S10">()</span><span class="S0"> </span><span class="S10">=</span><span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br />
+<span class="S0">&nbsp; &nbsp; &nbsp; &nbsp; </span><span class="S5">virtual</span><span class="S0"> </span><span class="S5">int</span><span class="S0"> </span>SCI_METHOD<span class="S0"> &nbsp;</span>GetIdentifier<span class="S10">()</span><span class="S0"> </span><span class="S10">=</span><span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br />
+<span class="S0">&nbsp; &nbsp; &nbsp; &nbsp; </span><span class="S5">virtual</span><span class="S0"> </span><span class="S5">const</span><span class="S0"> </span><span class="S5">char</span><span class="S0"> </span><span class="S10">*</span><span class="S0"> </span>SCI_METHOD<span class="S0"> </span>PropertyGet<span class="S10">(</span><span class="S5">const</span><span class="S0"> </span><span class="S5">char</span><span class="S0"> </span><span class="S10">*</span>key<span class="S10">)</span><span class="S0"> </span><span class="S10">=</span><span class="S0"> </span><span class="S4">0</span><span class="S10">;</span><br />
+<span class="S10">};</span><br />
+<span class="S0"></span></span>
+</div>
+
 <p>
 The types <code>Sci_Position</code> and <code>Sci_PositionU</code> are used for positions and line numbers in the document.
 With Scintilla 4, 64-bit builds define these as 64-bit types to allow future implementation of documents larger than 2 GB.
@@ -7204,6 +7218,15 @@ A set of common tags and conventions for combining them is <a  class="jump" href
 <code>DescriptionOfStyle</code> is an English description of the style like "<code>Function or method name definition</code>".
 </p>
 
+<p class="provisional"><code>GetName</code> and <code>GetIdentifier</code> may be called
+to discover the identity of a lexer and be used to implement
+<a class="message" href="#SCI_GETLEXERLANGUAGE">SCI_GETLEXERLANGUAGE</a> and
+<a class="message" href="#SCI_GETLEXER">SCI_GETLEXER</a>.</p>
+
+<p class="provisional"><code>PropertyGet</code> may be called
+to discover the value of a property stored by a lexer and be used to implement
+<a class="message" href="#SCI_GETPROPERTY">SCI_GETPROPERTY</a>.</p>
+
 <h4>IDocument</h4>
 
 <div class="highlighted">
diff --git a/doc/ScintillaHistory.html b/doc/ScintillaHistory.html
index ddad79d68..282118ded 100644
--- a/doc/ScintillaHistory.html
+++ b/doc/ScintillaHistory.html
@@ -570,6 +570,10 @@
 	Lexers made available as Lexilla library.
 	</li>
 	<li>
+	ILexer5 interface defined provisionally to support use of Lexilla.
+	The details of this interface may change before being stabilised in Scintilla 5.0.
+	</li>
+	<li>
 	SCI_LOADLEXERLIBRARY implemented on Cocoa.
 	</li>
 	<li>
diff --git a/include/ILexer.h b/include/ILexer.h
index 9bc995c3d..bc9ee1ab5 100644
--- a/include/ILexer.h
+++ b/include/ILexer.h
@@ -42,7 +42,7 @@ public:
 	virtual int SCI_METHOD GetCharacterAndWidth(Sci_Position position, Sci_Position *pWidth) const = 0;
 };
 
-enum { lvRelease4=2 };
+enum { lvRelease4=2, lvRelease5=3 };
 
 class ILexer4 {
 public:
@@ -73,6 +73,13 @@ public:
 	virtual const char * SCI_METHOD DescriptionOfStyle(int style) = 0;
 };
 
+class ILexer5 : public ILexer4 {
+public:
+	virtual const char * SCI_METHOD GetName() = 0;
+	virtual int SCI_METHOD  GetIdentifier() = 0;
+	virtual const char * SCI_METHOD PropertyGet(const char *key) = 0;
+};
+
 }
 
 #endif
diff --git a/lexers/LexAsm.cxx b/lexers/LexAsm.cxx
index f34c8b50c..8c30087cd 100644
--- a/lexers/LexAsm.cxx
+++ b/lexers/LexAsm.cxx
@@ -151,7 +151,7 @@ class LexerAsm : public DefaultLexer {
 	OptionSetAsm osAsm;
 	int commentChar;
 public:
-	LexerAsm(int commentChar_) {
+	LexerAsm(const char *languageName_, int language_, int commentChar_) : DefaultLexer(languageName_, language_) {
 		commentChar = commentChar_;
 	}
 	virtual ~LexerAsm() {
@@ -160,7 +160,7 @@ public:
 		delete this;
 	}
 	int SCI_METHOD Version() const override {
-		return lvRelease4;
+		return lvRelease5;
 	}
 	const char * SCI_METHOD PropertyNames() override {
 		return osAsm.PropertyNames();
@@ -172,6 +172,9 @@ public:
 		return osAsm.DescribeProperty(name);
 	}
 	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return osAsm.PropertyGet(key);
+	}
 	const char * SCI_METHOD DescribeWordListSets() override {
 		return osAsm.DescribeWordListSets();
 	}
@@ -183,12 +186,12 @@ public:
 		return 0;
 	}
 
-	static ILexer4 *LexerFactoryAsm() {
-		return new LexerAsm(';');
+	static ILexer5 *LexerFactoryAsm() {
+		return new LexerAsm("asm", SCLEX_ASM, ';');
 	}
 
-	static ILexer4 *LexerFactoryAs() {
-		return new LexerAsm('#');
+	static ILexer5 *LexerFactoryAs() {
+		return new LexerAsm("as", SCLEX_AS, '#');
 	}
 };
 
diff --git a/lexers/LexBaan.cxx b/lexers/LexBaan.cxx
index c26b2fda1..80b4f40ab 100644
--- a/lexers/LexBaan.cxx
+++ b/lexers/LexBaan.cxx
@@ -393,14 +393,14 @@ class LexerBaan : public DefaultLexer {
 	OptionsBaan options;
 	OptionSetBaan osBaan;
 public:
-	LexerBaan() {
+	LexerBaan() : DefaultLexer("baan", SCLEX_BAAN) {
 	}
 
 	virtual ~LexerBaan() {
 	}
 
 	int SCI_METHOD Version() const override {
-		return lvRelease4;
+		return lvRelease5;
 	}
 
 	void SCI_METHOD Release() override {
@@ -421,6 +421,10 @@ public:
 
 	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
 
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return osBaan.PropertyGet(key);
+	}
+
 	const char * SCI_METHOD DescribeWordListSets() override {
 		return osBaan.DescribeWordListSets();
 	}
@@ -435,7 +439,7 @@ public:
 		return NULL;
 	}
 
-	static ILexer4 * LexerFactoryBaan() {
+	static ILexer5 * LexerFactoryBaan() {
 		return new LexerBaan();
 	}
 };
diff --git a/lexers/LexBash.cxx b/lexers/LexBash.cxx
index 4bcecc761..07dc6c1ce 100644
--- a/lexers/LexBash.cxx
+++ b/lexers/LexBash.cxx
@@ -201,7 +201,7 @@ class LexerBash : public DefaultLexer {
 	SubStyles subStyles;
 public:
 	LexerBash() :
-		DefaultLexer(lexicalClasses, ELEMENTS(lexicalClasses)),
+		DefaultLexer("bash", SCLEX_BASH, lexicalClasses, ELEMENTS(lexicalClasses)),
 		subStyles(styleSubable, 0x80, 0x40, 0) {
 	}
 	virtual ~LexerBash() {
@@ -210,7 +210,7 @@ public:
 		delete this;
 	}
 	int SCI_METHOD Version() const override {
-		return lvRelease4;
+		return lvRelease5;
 	}
 	const char * SCI_METHOD PropertyNames() override {
 		return osBash.PropertyNames();
@@ -222,6 +222,9 @@ public:
 		return osBash.DescribeProperty(name);
 	}
 	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char * SCI_METHOD PropertyGet(const char* key) override {
+		return osBash.PropertyGet(key);
+	}
 	const char * SCI_METHOD DescribeWordListSets() override {
 		return osBash.DescribeWordListSets();
 	}
@@ -262,7 +265,7 @@ public:
 		return styleSubable;
 	}
 
-	static ILexer4 *LexerFactoryBash() {
+	static ILexer5 *LexerFactoryBash() {
 		return new LexerBash();
 	}
 };
diff --git a/lexers/LexBasic.cxx b/lexers/LexBasic.cxx
index 3998af93b..e9004b1a1 100644
--- a/lexers/LexBasic.cxx
+++ b/lexers/LexBasic.cxx
@@ -232,7 +232,9 @@ class LexerBasic : public DefaultLexer {
 	OptionsBasic options;
 	OptionSetBasic osBasic;
 public:
-	LexerBasic(char comment_char_, int (*CheckFoldPoint_)(char const *, int &), const char * const wordListDescriptions[]) :
+	LexerBasic(const char *languageName_, int language_, char comment_char_,
+		int (*CheckFoldPoint_)(char const *, int &), const char * const wordListDescriptions[]) :
+						 DefaultLexer(languageName_, language_),
 						 comment_char(comment_char_),
 						 CheckFoldPoint(CheckFoldPoint_),
 						 osBasic(wordListDescriptions) {
@@ -243,7 +245,7 @@ public:
 		delete this;
 	}
 	int SCI_METHOD Version() const override {
-		return lvRelease4;
+		return lvRelease5;
 	}
 	const char * SCI_METHOD PropertyNames() override {
 		return osBasic.PropertyNames();
@@ -255,6 +257,9 @@ public:
 		return osBasic.DescribeProperty(name);
 	}
 	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return osBasic.PropertyGet(key);
+	}
 	const char * SCI_METHOD DescribeWordListSets() override {
 		return osBasic.DescribeWordListSets();
 	}
@@ -265,14 +270,14 @@ public:
 	void * SCI_METHOD PrivateCall(int, void *) override {
 		return 0;
 	}
-	static ILexer4 *LexerFactoryBlitzBasic() {
-		return new LexerBasic(';', CheckBlitzFoldPoint, blitzbasicWordListDesc);
+	static ILexer5 *LexerFactoryBlitzBasic() {
+		return new LexerBasic("blitzbasic", SCLEX_BLITZBASIC, ';', CheckBlitzFoldPoint, blitzbasicWordListDesc);
 	}
-	static ILexer4 *LexerFactoryPureBasic() {
-		return new LexerBasic(';', CheckPureFoldPoint, purebasicWordListDesc);
+	static ILexer5 *LexerFactoryPureBasic() {
+		return new LexerBasic("purebasic", SCLEX_PUREBASIC, ';', CheckPureFoldPoint, purebasicWordListDesc);
 	}
-	static ILexer4 *LexerFactoryFreeBasic() {
-		return new LexerBasic('\'', CheckFreeFoldPoint, freebasicWordListDesc );
+	static ILexer5 *LexerFactoryFreeBasic() {
+		return new LexerBasic("freebasic", SCLEX_FREEBASIC, '\'', CheckFreeFoldPoint, freebasicWordListDesc );
 	}
 };
 
diff --git a/lexers/LexCIL.cxx b/lexers/LexCIL.cxx
index 6f498315a..4e0fdb696 100644
--- a/lexers/LexCIL.cxx
+++ b/lexers/LexCIL.cxx
@@ -114,7 +114,7 @@ class LexerCIL : public DefaultLexer {
     OptionSetCIL osCIL;
 
 public:
-    LexerCIL() : DefaultLexer(lexicalClasses, ELEMENTS(lexicalClasses)) { }
+    LexerCIL() : DefaultLexer("cil", SCLEX_CIL, lexicalClasses, ELEMENTS(lexicalClasses)) { }
 
     virtual ~LexerCIL() { }
 
@@ -123,7 +123,7 @@ public:
     }
 
     int SCI_METHOD Version() const override {
-        return lvRelease4;
+        return lvRelease5;
     }
 
     const char * SCI_METHOD PropertyNames() override {
@@ -140,6 +140,10 @@ public:
 
     Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
 
+	const char * SCI_METHOD PropertyGet(const char* key) override {
+		return osCIL.PropertyGet(key);
+	}
+
     const char * SCI_METHOD DescribeWordListSets() override {
         return osCIL.DescribeWordListSets();
     }
@@ -161,7 +165,7 @@ public:
         return style;
     }
 
-    static ILexer4 *LexerFactoryCIL() {
+    static ILexer5 *LexerFactoryCIL() {
         return new LexerCIL();
     }
 };
diff --git a/lexers/LexCPP.cxx b/lexers/LexCPP.cxx
index 6d3f55684..908949aaf 100644
--- a/lexers/LexCPP.cxx
+++ b/lexers/LexCPP.cxx
@@ -501,7 +501,7 @@ const int sizeLexicalClasses = static_cast<int>(std::size(lexicalClasses));
 
 }
 
-class LexerCPP : public ILexer4 {
+class LexerCPP : public ILexer5 {
 	bool caseSensitive;
 	CharacterSet setWord;
 	CharacterSet setNegationOp;
@@ -564,7 +564,7 @@ public:
 		delete this;
 	}
 	int SCI_METHOD Version() const noexcept override {
-		return lvRelease4;
+		return lvRelease5;
 	}
 	const char * SCI_METHOD PropertyNames() override {
 		return osCPP.PropertyNames();
@@ -674,10 +674,19 @@ public:
 		return "";
 	}
 
-	static ILexer4 *LexerFactoryCPP() {
+	// ILexer5 methods
+	const char * SCI_METHOD GetName() override {
+		return caseSensitive ? "cpp" : "cppnocase";
+	}
+	int SCI_METHOD  GetIdentifier() override {
+		return caseSensitive ? SCLEX_CPP : SCLEX_CPPNOCASE;
+	}
+	const char * SCI_METHOD PropertyGet(const char *key) override;
+
+	static ILexer5 *LexerFactoryCPP() {
 		return new LexerCPP(true);
 	}
-	static ILexer4 *LexerFactoryCPPInsensitive() {
+	static ILexer5 *LexerFactoryCPPInsensitive() {
 		return new LexerCPP(false);
 	}
 	constexpr static int MaskActive(int style) noexcept {
@@ -701,6 +710,10 @@ Sci_Position SCI_METHOD LexerCPP::PropertySet(const char *key, const char *val)
 	return -1;
 }
 
+const char * SCI_METHOD LexerCPP::PropertyGet(const char *key) {
+	return osCPP.PropertyGet(key);
+}
+
 Sci_Position SCI_METHOD LexerCPP::WordListSet(int n, const char *wl) {
 	WordList *wordListN = nullptr;
 	switch (n) {
diff --git a/lexers/LexD.cxx b/lexers/LexD.cxx
index 9465942f5..9381a0d07 100644
--- a/lexers/LexD.cxx
+++ b/lexers/LexD.cxx
@@ -157,6 +157,7 @@ class LexerD : public DefaultLexer {
 	OptionSetD osD;
 public:
 	LexerD(bool caseSensitive_) :
+		DefaultLexer("D", SCLEX_D),
 		caseSensitive(caseSensitive_) {
 	}
 	virtual ~LexerD() {
@@ -165,7 +166,7 @@ public:
 		delete this;
 	}
 	int SCI_METHOD Version() const override {
-		return lvRelease4;
+		return lvRelease5;
 	}
 	const char * SCI_METHOD PropertyNames() override {
 		return osD.PropertyNames();
@@ -177,6 +178,9 @@ public:
 		return osD.DescribeProperty(name);
 	}
 	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return osD.PropertyGet(key);
+	}
 	const char * SCI_METHOD DescribeWordListSets() override {
 		return osD.DescribeWordListSets();
 	}
@@ -188,10 +192,10 @@ public:
 		return 0;
 	}
 
-	static ILexer4 *LexerFactoryD() {
+	static ILexer5 *LexerFactoryD() {
 		return new LexerD(true);
 	}
-	static ILexer4 *LexerFactoryDInsensitive() {
+	static ILexer5 *LexerFactoryDInsensitive() {
 		return new LexerD(false);
 	}
 };
diff --git a/lexers/LexDMIS.cxx b/lexers/LexDMIS.cxx
index ce36ff056..3c8da6081 100644
--- a/lexers/LexDMIS.cxx
+++ b/lexers/LexDMIS.cxx
@@ -56,7 +56,7 @@ class LexerDMIS : public DefaultLexer
 		virtual ~LexerDMIS(void);
 
 		int SCI_METHOD Version() const override {
-			return lvRelease4;
+			return lvRelease5;
 		}
 
 		void SCI_METHOD Release() override {
@@ -79,13 +79,17 @@ class LexerDMIS : public DefaultLexer
 			return -1;
 		}
 
+		const char * SCI_METHOD PropertyGet(const char *) override {
+			return NULL;
+		}
+
 		Sci_Position SCI_METHOD WordListSet(int n, const char *wl) override;
 
 		void * SCI_METHOD PrivateCall(int, void *) override {
 			return NULL;
 		}
 
-		static ILexer4 *LexerFactoryDMIS() {
+		static ILexer5 *LexerFactoryDMIS() {
 			return new LexerDMIS;
 		}
 
@@ -129,7 +133,7 @@ void SCI_METHOD LexerDMIS::InitWordListSets(void)
 }
 
 
-LexerDMIS::LexerDMIS(void) {
+LexerDMIS::LexerDMIS(void) : DefaultLexer("DMIS", SCLEX_DMIS) {
 	this->InitWordListSets();
 
 	this->m_majorWords.Clear();
diff --git a/lexers/LexEDIFACT.cxx b/lexers/LexEDIFACT.cxx
index 45f13bb3f..3623807a4 100644
--- a/lexers/LexEDIFACT.cxx
+++ b/lexers/LexEDIFACT.cxx
@@ -13,6 +13,8 @@
 #include <cstring>
 #include <cctype>
 
+#include <string>
+
 #include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
@@ -29,13 +31,13 @@ public:
 	LexerEDIFACT();
 	virtual ~LexerEDIFACT() {} // virtual destructor, as we inherit from ILexer
 
-	static ILexer4 *Factory() {
+	static ILexer5 *Factory() {
 		return new LexerEDIFACT;
 	}
 
 	int SCI_METHOD Version() const override
 	{
-		return lvRelease4;
+		return lvRelease5;
 	}
 	void SCI_METHOD Release() override
 	{
@@ -73,6 +75,21 @@ public:
 		}
 		return -1;
 	}
+
+	const char * SCI_METHOD PropertyGet(const char *key) override
+	{
+		m_lastPropertyValue = "";
+		if (!strcmp(key, "fold"))
+		{
+			m_lastPropertyValue = m_bFold ? "1" : "0";
+		}
+		if (!strcmp(key, "lexer.edifact.highlight.un.all"))	// GetProperty
+		{
+			m_lastPropertyValue = m_bHighlightAllUN ? "1" : "0";
+		}
+		return m_lastPropertyValue.c_str();
+	}
+
 	const char * SCI_METHOD DescribeWordListSets() override
 	{
 		return NULL;
@@ -105,6 +122,8 @@ protected:
 	char m_chDecimal;
 	char m_chRelease;
 	char m_chSegment;
+
+	std::string m_lastPropertyValue;
 };
 
 LexerModule lmEDIFACT(SCLEX_EDIFACT, LexerEDIFACT::Factory, "edifact");
@@ -115,7 +134,7 @@ LexerModule lmEDIFACT(SCLEX_EDIFACT, LexerEDIFACT::Factory, "edifact");
 
 ///////////////////////////////////////////////////////////////////////////////
 
-LexerEDIFACT::LexerEDIFACT()
+LexerEDIFACT::LexerEDIFACT() : DefaultLexer("edifact", SCLEX_EDIFACT)
 {
 	m_bFold = false;
 	m_bHighlightAllUN = false;
diff --git a/lexers/LexHTML.cxx b/lexers/LexHTML.cxx
index 7519afeb2..c6042f2b6 100644
--- a/lexers/LexHTML.cxx
+++ b/lexers/LexHTML.cxx
@@ -861,7 +861,10 @@ class LexerHTML : public DefaultLexer {
 	std::set<std::string> nonFoldingTags;
 public:
 	explicit LexerHTML(bool isXml_, bool isPHPScript_) :
-		DefaultLexer(isXml_ ? lexicalClassesHTML : lexicalClassesXML,
+		DefaultLexer(
+			isXml_ ? "xml" : (isPHPScript_ ? "phpscript" : "hypertext"),
+			isXml_ ? SCLEX_XML : (isPHPScript_ ? SCLEX_PHPSCRIPT : SCLEX_HTML),
+			isXml_ ? lexicalClassesHTML : lexicalClassesXML,
 			isXml_ ? std::size(lexicalClassesHTML) : std::size(lexicalClassesXML)),
 		isXml(isXml_),
 		isPHPScript(isPHPScript_),
@@ -883,6 +886,9 @@ public:
 		return osHTML.DescribeProperty(name);
 	}
 	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return osHTML.PropertyGet(key);
+	}
 	const char *SCI_METHOD DescribeWordListSets() override {
 		return osHTML.DescribeWordListSets();
 	}
@@ -890,13 +896,13 @@ public:
 	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;
 	// No Fold as all folding performs in Lex.
 
-	static ILexer4 *LexerFactoryHTML() {
+	static ILexer5 *LexerFactoryHTML() {
 		return new LexerHTML(false, false);
 	}
-	static ILexer4 *LexerFactoryXML() {
+	static ILexer5 *LexerFactoryXML() {
 		return new LexerHTML(true, false);
 	}
-	static ILexer4 *LexerFactoryPHPScript() {
+	static ILexer5 *LexerFactoryPHPScript() {
 		return new LexerHTML(false, true);
 	}
 };
diff --git a/lexers/LexHaskell.cxx b/lexers/LexHaskell.cxx
index 8ed53d772..4d4fe1dd6 100644
--- a/lexers/LexHaskell.cxx
+++ b/lexers/LexHaskell.cxx
@@ -390,7 +390,8 @@ class LexerHaskell : public DefaultLexer {
 
 public:
    LexerHaskell(bool literate_)
-      : literate(literate_)
+      : DefaultLexer(literate_ ? "literatehaskell" : "haskell", literate_ ? SCLEX_LITERATEHASKELL : SCLEX_HASKELL)
+	  , literate(literate_)
       , firstImportLine(-1)
       , firstImportIndent(0)
       {}
@@ -401,7 +402,7 @@ public:
    }
 
    int SCI_METHOD Version() const override {
-      return lvRelease4;
+      return lvRelease5;
    }
 
    const char * SCI_METHOD PropertyNames() override {
@@ -418,6 +419,10 @@ public:
 
    Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
 
+   const char * SCI_METHOD PropertyGet(const char *key) override {
+	   return osHaskell.PropertyGet(key);
+   }
+
    const char * SCI_METHOD DescribeWordListSets() override {
       return osHaskell.DescribeWordListSets();
    }
@@ -432,11 +437,11 @@ public:
       return 0;
    }
 
-   static ILexer4 *LexerFactoryHaskell() {
+   static ILexer5 *LexerFactoryHaskell() {
       return new LexerHaskell(false);
    }
 
-   static ILexer4 *LexerFactoryLiterateHaskell() {
+   static ILexer5 *LexerFactoryLiterateHaskell() {
       return new LexerHaskell(true);
    }
 };
diff --git a/lexers/LexHollywood.cxx b/lexers/LexHollywood.cxx
index 41c295686..673381282 100644
--- a/lexers/LexHollywood.cxx
+++ b/lexers/LexHollywood.cxx
@@ -252,38 +252,42 @@ class LexerHollywood : public DefaultLexer {
 	OptionSetHollywood osHollywood;
 public:
 	LexerHollywood(int (*CheckFoldPoint_)(char const *), const char * const wordListDescriptions[]) :
+						 DefaultLexer("hollywood", SCLEX_HOLLYWOOD),
 						 CheckFoldPoint(CheckFoldPoint_),
 						 osHollywood(wordListDescriptions) {
 	}
 	virtual ~LexerHollywood() {
 	}
-	void SCI_METHOD Release() {
+	void SCI_METHOD Release() override {
 		delete this;
 	}
-	int SCI_METHOD Version() const {
-		return lvRelease4;
+	int SCI_METHOD Version() const override {
+		return lvRelease5;
 	}
-	const char * SCI_METHOD PropertyNames() {
+	const char * SCI_METHOD PropertyNames() override {
 		return osHollywood.PropertyNames();
 	}
-	int SCI_METHOD PropertyType(const char *name) {
+	int SCI_METHOD PropertyType(const char *name) override {
 		return osHollywood.PropertyType(name);
 	}
-	const char * SCI_METHOD DescribeProperty(const char *name) {
+	const char * SCI_METHOD DescribeProperty(const char *name) override {
 		return osHollywood.DescribeProperty(name);
 	}
-	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val);
-	const char * SCI_METHOD DescribeWordListSets() {
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char * SCI_METHOD PropertyGet(const char* key) override {
+		return osHollywood.PropertyGet(key);
+	}
+	const char * SCI_METHOD DescribeWordListSets() override {
 		return osHollywood.DescribeWordListSets();
 	}
-	Sci_Position SCI_METHOD WordListSet(int n, const char *wl);
-	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
-	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess);
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl) override;
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;
 
-	void * SCI_METHOD PrivateCall(int, void *) {
+	void * SCI_METHOD PrivateCall(int, void *) override {
 		return 0;
 	}
-	static ILexer4 *LexerFactoryHollywood() {
+	static ILexer5 *LexerFactoryHollywood() {
 		return new LexerHollywood(CheckHollywoodFoldPoint, hollywoodWordListDesc);
 	}
 };
diff --git a/lexers/LexJSON.cxx b/lexers/LexJSON.cxx
index 8e27bca6d..3712e931f 100644
--- a/lexers/LexJSON.cxx
+++ b/lexers/LexJSON.cxx
@@ -201,6 +201,7 @@ class LexerJSON : public DefaultLexer {
 
 	public:
 	LexerJSON() :
+		DefaultLexer("json", SCLEX_JSON),
 		setOperators(CharacterSet::setNone, "[{}]:,"),
 		setURL(CharacterSet::setAlphaNum, "-._~:/?#[]@!$&'()*+,),="),
 		setKeywordJSONLD(CharacterSet::setAlpha, ":@"),
@@ -208,7 +209,7 @@ class LexerJSON : public DefaultLexer {
 	}
 	virtual ~LexerJSON() {}
 	int SCI_METHOD Version() const override {
-		return lvRelease4;
+		return lvRelease5;
 	}
 	void SCI_METHOD Release() override {
 		delete this;
@@ -228,6 +229,9 @@ class LexerJSON : public DefaultLexer {
 		}
 		return -1;
 	}
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return optSetJSON.PropertyGet(key);
+	}
 	Sci_Position SCI_METHOD WordListSet(int n, const char *wl) override {
 		WordList *wordListN = 0;
 		switch (n) {
@@ -252,7 +256,7 @@ class LexerJSON : public DefaultLexer {
 	void *SCI_METHOD PrivateCall(int, void *) override {
 		return 0;
 	}
-	static ILexer4 *LexerFactoryJSON() {
+	static ILexer5 *LexerFactoryJSON() {
 		return new LexerJSON;
 	}
 	const char *SCI_METHOD DescribeWordListSets() override {
diff --git a/lexers/LexLaTeX.cxx b/lexers/LexLaTeX.cxx
index 930c8173b..52f10aec7 100644
--- a/lexers/LexLaTeX.cxx
+++ b/lexers/LexLaTeX.cxx
@@ -84,11 +84,19 @@ private:
 			saves.resize(numLines + 128);
 	}
 public:
-	static ILexer4 *LexerFactoryLaTeX() {
+	static ILexer5 *LexerFactoryLaTeX() {
 		return new LexerLaTeX();
 	}
 	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;
 	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) override;
+
+	// ILexer5 methods
+	const char * SCI_METHOD GetName() override {
+		return "latex";
+	}
+	int SCI_METHOD  GetIdentifier() override {
+		return SCLEX_LATEX;
+	}
 };
 
 static bool latexIsSpecial(int ch) {
diff --git a/lexers/LexNim.cxx b/lexers/LexNim.cxx
index da21cdb50..d1b462abe 100644
--- a/lexers/LexNim.cxx
+++ b/lexers/LexNim.cxx
@@ -225,7 +225,7 @@ class LexerNim : public DefaultLexer {
 
 public:
     LexerNim() :
-        DefaultLexer(lexicalClasses, ELEMENTS(lexicalClasses)),
+        DefaultLexer("nim", SCLEX_NIM, lexicalClasses, ELEMENTS(lexicalClasses)),
         setWord(CharacterSet::setAlphaNum, "_", 0x80, true) { }
 
     virtual ~LexerNim() { }
@@ -235,7 +235,7 @@ public:
     }
 
     int SCI_METHOD Version() const noexcept override {
-        return lvRelease4;
+        return lvRelease5;
     }
 
     const char * SCI_METHOD PropertyNames() override {
@@ -252,6 +252,10 @@ public:
 
     Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
 
+	const char * SCI_METHOD PropertyGet(const char* key) override {
+		return osNim.PropertyGet(key);
+	}
+
     const char * SCI_METHOD DescribeWordListSets() override {
         return osNim.DescribeWordListSets();
     }
@@ -273,7 +277,7 @@ public:
         return style;
     }
 
-    static ILexer4 *LexerFactoryNim() {
+    static ILexer5 *LexerFactoryNim() {
         return new LexerNim();
     }
 };
diff --git a/lexers/LexPerl.cxx b/lexers/LexPerl.cxx
index 834638f41..f01d26ba4 100644
--- a/lexers/LexPerl.cxx
+++ b/lexers/LexPerl.cxx
@@ -423,6 +423,7 @@ class LexerPerl : public DefaultLexer {
 	OptionSetPerl osPerl;
 public:
 	LexerPerl() :
+		DefaultLexer("perl", SCLEX_PERL),
 		setWordStart(CharacterSet::setAlpha, "_", 0x80, true),
 		setWord(CharacterSet::setAlphaNum, "_", 0x80, true),
 		setSpecialVar(CharacterSet::setNone, "\"$;<>&`'+,./\\%:=~!?@[]"),
@@ -434,7 +435,7 @@ public:
 		delete this;
 	}
 	int SCI_METHOD Version() const override {
-		return lvRelease4;
+		return lvRelease5;
 	}
 	const char *SCI_METHOD PropertyNames() override {
 		return osPerl.PropertyNames();
@@ -446,6 +447,9 @@ public:
 		return osPerl.DescribeProperty(name);
 	}
 	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return osPerl.PropertyGet(key);
+	}
 	const char *SCI_METHOD DescribeWordListSets() override {
 		return osPerl.DescribeWordListSets();
 	}
@@ -457,7 +461,7 @@ public:
 		return 0;
 	}
 
-	static ILexer4 *LexerFactoryPerl() {
+	static ILexer5 *LexerFactoryPerl() {
 		return new LexerPerl();
 	}
 	int InputSymbolScan(StyleContext &sc);
diff --git a/lexers/LexProgress.cxx b/lexers/LexProgress.cxx
index 2034a7996..2a545b6ec 100644
--- a/lexers/LexProgress.cxx
+++ b/lexers/LexProgress.cxx
@@ -136,6 +136,7 @@ class LexerABL : public DefaultLexer {
    OptionSetABL osABL;
 public:
    LexerABL() :
+      DefaultLexer("abl", SCLEX_PROGRESS),
       setWord(CharacterSet::setAlphaNum, "_", 0x80, true),
       setNegationOp(CharacterSet::setNone, "!"),
       setArithmethicOp(CharacterSet::setNone, "+-/*%"),
@@ -148,7 +149,7 @@ public:
       delete this;
    }
    int SCI_METHOD Version() const override {
-      return lvRelease4;
+      return lvRelease5;
    }
    const char * SCI_METHOD PropertyNames() override {
       return osABL.PropertyNames();
@@ -160,6 +161,9 @@ public:
       return osABL.DescribeProperty(name);
    }
    Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override ;
+   const char * SCI_METHOD PropertyGet(const char *key) override {
+	   return osABL.PropertyGet(key);
+   }
 
    const char * SCI_METHOD DescribeWordListSets() override {
       return osABL.DescribeWordListSets();
@@ -174,7 +178,7 @@ public:
    int SCI_METHOD LineEndTypesSupported() override {
       return SC_LINE_END_TYPE_DEFAULT;
    }
-   static ILexer4 *LexerFactoryABL() {
+   static ILexer5 *LexerFactoryABL() {
       return new LexerABL();
    }
 };
diff --git a/lexers/LexPython.cxx b/lexers/LexPython.cxx
index f325ca360..24a11e3b0 100644
--- a/lexers/LexPython.cxx
+++ b/lexers/LexPython.cxx
@@ -344,7 +344,7 @@ class LexerPython : public DefaultLexer {
 	std::map<Sci_Position, std::vector<SingleFStringExpState> > ftripleStateAtEol;
 public:
 	explicit LexerPython() :
-		DefaultLexer(lexicalClasses, ELEMENTS(lexicalClasses)),
+		DefaultLexer("python", SCLEX_PYTHON, lexicalClasses, ELEMENTS(lexicalClasses)),
 		subStyles(styleSubable, 0x80, 0x40, 0) {
 	}
 	~LexerPython() override {
@@ -353,7 +353,7 @@ public:
 		delete this;
 	}
 	int SCI_METHOD Version() const override {
-		return lvRelease4;
+		return lvRelease5;
 	}
 	const char *SCI_METHOD PropertyNames() override {
 		return osPython.PropertyNames();
@@ -365,6 +365,9 @@ public:
 		return osPython.DescribeProperty(name);
 	}
 	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return osPython.PropertyGet(key);
+	}
 	const char *SCI_METHOD DescribeWordListSets() override {
 		return osPython.DescribeWordListSets();
 	}
@@ -409,7 +412,7 @@ public:
 		return styleSubable;
 	}
 
-	static ILexer4 *LexerFactoryPython() {
+	static ILexer5 *LexerFactoryPython() {
 		return new LexerPython();
 	}
 
diff --git a/lexers/LexRegistry.cxx b/lexers/LexRegistry.cxx
index 779ea2f47..acdaccebe 100644
--- a/lexers/LexRegistry.cxx
+++ b/lexers/LexRegistry.cxx
@@ -161,10 +161,10 @@ class LexerRegistry : public DefaultLexer {
 	}
 
 public:
-	LexerRegistry() {}
+	LexerRegistry() : DefaultLexer("registry", SCLEX_REGISTRY) {}
 	virtual ~LexerRegistry() {}
 	int SCI_METHOD Version() const override {
-		return lvRelease4;
+		return lvRelease5;
 	}
 	void SCI_METHOD Release() override {
 		delete this;
@@ -184,13 +184,17 @@ public:
 		}
 		return -1;
 	}
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return optSetRegistry.PropertyGet(key);
+	}
+
 	Sci_Position SCI_METHOD WordListSet(int, const char *) override {
 		return -1;
 	}
 	void *SCI_METHOD PrivateCall(int, void *) override {
 		return 0;
 	}
-	static ILexer4 *LexerFactoryRegistry() {
+	static ILexer5 *LexerFactoryRegistry() {
 		return new LexerRegistry;
 	}
 	const char *SCI_METHOD DescribeWordListSets() override {
diff --git a/lexers/LexRust.cxx b/lexers/LexRust.cxx
index ec930e470..439d2d3b0 100644
--- a/lexers/LexRust.cxx
+++ b/lexers/LexRust.cxx
@@ -120,13 +120,15 @@ class LexerRust : public DefaultLexer {
 	OptionsRust options;
 	OptionSetRust osRust;
 public:
+	LexerRust() : DefaultLexer("rust", SCLEX_RUST) {
+	}
 	virtual ~LexerRust() {
 	}
 	void SCI_METHOD Release() override {
 		delete this;
 	}
 	int SCI_METHOD Version() const override {
-		return lvRelease4;
+		return lvRelease5;
 	}
 	const char * SCI_METHOD PropertyNames() override {
 		return osRust.PropertyNames();
@@ -138,6 +140,9 @@ public:
 		return osRust.DescribeProperty(name);
 	}
 	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return osRust.PropertyGet(key);
+	}
 	const char * SCI_METHOD DescribeWordListSets() override {
 		return osRust.DescribeWordListSets();
 	}
@@ -147,7 +152,7 @@ public:
 	void * SCI_METHOD PrivateCall(int, void *) override {
 		return 0;
 	}
-	static ILexer4 *LexerFactoryRust() {
+	static ILexer5 *LexerFactoryRust() {
 		return new LexerRust();
 	}
 };
diff --git a/lexers/LexSQL.cxx b/lexers/LexSQL.cxx
index a8dd3c393..d45dc2098 100644
--- a/lexers/LexSQL.cxx
+++ b/lexers/LexSQL.cxx
@@ -303,12 +303,12 @@ struct OptionSetSQL : public OptionSet<OptionsSQL> {
 
 class LexerSQL : public DefaultLexer {
 public :
-	LexerSQL() {}
+	LexerSQL() : DefaultLexer("sql", SCLEX_SQL) {}
 
 	virtual ~LexerSQL() {}
 
 	int SCI_METHOD Version () const override {
-		return lvRelease4;
+		return lvRelease5;
 	}
 
 	void SCI_METHOD Release() override {
@@ -334,6 +334,10 @@ public :
 		return -1;
 	}
 
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return osSQL.PropertyGet(key);
+	}
+
 	const char * SCI_METHOD DescribeWordListSets() override {
 		return osSQL.DescribeWordListSets();
 	}
@@ -346,7 +350,7 @@ public :
 		return 0;
 	}
 
-	static ILexer4 *LexerFactorySQL() {
+	static ILexer5 *LexerFactorySQL() {
 		return new LexerSQL();
 	}
 private:
diff --git a/lexers/LexVerilog.cxx b/lexers/LexVerilog.cxx
index 640f12fcb..ac5859e93 100644
--- a/lexers/LexVerilog.cxx
+++ b/lexers/LexVerilog.cxx
@@ -216,12 +216,13 @@ class LexerVerilog : public DefaultLexer {
 
 public:
 	LexerVerilog() :
+		DefaultLexer("verilog", SCLEX_VERILOG),
 		setWord(CharacterSet::setAlphaNum, "._", 0x80, true),
 		subStyles(styleSubable, 0x80, 0x40, activeFlag) {
 		}
 	virtual ~LexerVerilog() {}
 	int SCI_METHOD Version() const override {
-		return lvRelease4;
+		return lvRelease5;
 	}
 	void SCI_METHOD Release() override {
 		delete this;
@@ -238,6 +239,9 @@ public:
 	Sci_Position SCI_METHOD PropertySet(const char* key, const char* val) override {
 	    return osVerilog.PropertySet(&options, key, val);
 	}
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return osVerilog.PropertyGet(key);
+	}
 	const char* SCI_METHOD DescribeWordListSets() override {
 		return osVerilog.DescribeWordListSets();
 	}
@@ -279,7 +283,7 @@ public:
 	const char * SCI_METHOD GetSubStyleBases() override {
 		return styleSubable;
 	}
-	static ILexer4* LexerFactoryVerilog() {
+	static ILexer5* LexerFactoryVerilog() {
 		return new LexerVerilog();
 	}
 	static int MaskActive(int style) {
diff --git a/lexers/LexVisualProlog.cxx b/lexers/LexVisualProlog.cxx
index 552c0ffc8..ba5b222c1 100644
--- a/lexers/LexVisualProlog.cxx
+++ b/lexers/LexVisualProlog.cxx
@@ -71,7 +71,7 @@ class LexerVisualProlog : public DefaultLexer {
     OptionsVisualProlog options;
     OptionSetVisualProlog osVisualProlog;
 public:
-    LexerVisualProlog() {
+    LexerVisualProlog() : DefaultLexer("visualprolog", SCLEX_VISUALPROLOG) {
     }
     virtual ~LexerVisualProlog() {
     }
@@ -79,7 +79,7 @@ public:
         delete this;
     }
     int SCI_METHOD Version() const override {
-        return lvRelease4;
+        return lvRelease5;
     }
     const char * SCI_METHOD PropertyNames() override {
         return osVisualProlog.PropertyNames();
@@ -91,6 +91,9 @@ public:
         return osVisualProlog.DescribeProperty(name);
     }
     Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return osVisualProlog.PropertyGet(key);
+	}
     const char * SCI_METHOD DescribeWordListSets() override {
         return osVisualProlog.DescribeWordListSets();
     }
@@ -102,7 +105,7 @@ public:
         return 0;
     }
 
-    static ILexer4 *LexerFactoryVisualProlog() {
+    static ILexer5 *LexerFactoryVisualProlog() {
         return new LexerVisualProlog();
     }
 };
diff --git a/lexers/LexX12.cxx b/lexers/LexX12.cxx
index 65ce99b4f..303bcf5d2 100644
--- a/lexers/LexX12.cxx
+++ b/lexers/LexX12.cxx
@@ -30,13 +30,13 @@ public:
 	LexerX12();
 	virtual ~LexerX12() {} // virtual destructor, as we inherit from ILexer
 
-	static ILexer4 *Factory() {
+	static ILexer5 *Factory() {
 		return new LexerX12;
 	}
 
 	int SCI_METHOD Version() const override
 	{
-		return lvRelease4;
+		return lvRelease5;
 	}
 	void SCI_METHOD Release() override
 	{
@@ -67,6 +67,9 @@ public:
 		}
 		return -1;
 	}
+	const char * SCI_METHOD PropertyGet(const char *) override {
+		return "";
+	}
 	const char * SCI_METHOD DescribeWordListSets() override
 	{
 		return NULL;
@@ -109,7 +112,7 @@ LexerModule lmX12(SCLEX_X12, LexerX12::Factory, "x12");
 
 ///////////////////////////////////////////////////////////////////////////////
 
-LexerX12::LexerX12()
+LexerX12::LexerX12() : DefaultLexer("x12", SCLEX_X12)
 {
 	m_bFold = false;
 	m_chSegment[0] = m_chSegment[1] = m_chSegment[2] = m_chElement = m_chSubElement = 0;
diff --git a/lexilla/src/Lexilla.cxx b/lexilla/src/Lexilla.cxx
index e12d65640..1e01598f6 100644
--- a/lexilla/src/Lexilla.cxx
+++ b/lexilla/src/Lexilla.cxx
@@ -322,7 +322,7 @@ LexerFactoryFunction EXPORT_FUNCTION GetLexerFactory(unsigned int index) {
 	return catalogueLexilla.Factory(index);
 }
 
-ILexer4 EXPORT_FUNCTION *CreateLexer(const char *name) {
+ILexer5 EXPORT_FUNCTION *CreateLexer(const char *name) {
 	AddEachLexer();
 	for (unsigned int i = 0; i < catalogueLexilla.Count(); i++) {
 		const char *lexerName = catalogueLexilla.Name(i);
diff --git a/lexilla/src/Lexilla.h b/lexilla/src/Lexilla.h
index a2a2e010d..e44567bed 100644
--- a/lexilla/src/Lexilla.h
+++ b/lexilla/src/Lexilla.h
@@ -8,6 +8,6 @@
 
 extern "C" {
 
-Scintilla::ILexer4 *CreateLexer(const char *name);
+Scintilla::ILexer5 *CreateLexer(const char *name);
 
 }
diff --git a/lexlib/CatalogueModules.h b/lexlib/CatalogueModules.h
index 1a170cf70..197a66460 100644
--- a/lexlib/CatalogueModules.h
+++ b/lexlib/CatalogueModules.h
@@ -56,7 +56,7 @@ public:
 		return lexerCatalogue[index]->fnFactory;
 	}
 
-	ILexer4 *Create(unsigned int index) {
+	ILexer5 *Create(unsigned int index) {
 		const LexerModule *plm = lexerCatalogue[index];
 		if (!plm) {
 			return nullptr;
diff --git a/lexlib/DefaultLexer.cxx b/lexlib/DefaultLexer.cxx
index 42abac50f..89671aa30 100644
--- a/lexlib/DefaultLexer.cxx
+++ b/lexlib/DefaultLexer.cxx
@@ -24,8 +24,12 @@ using namespace Scintilla;
 
 static const char styleSubable[] = { 0 };
 
-DefaultLexer::DefaultLexer(const LexicalClass *lexClasses_, size_t nClasses_) :
-	lexClasses(lexClasses_), nClasses(nClasses_) {
+DefaultLexer::DefaultLexer(const char *languageName_, int language_,
+	const LexicalClass *lexClasses_, size_t nClasses_) :
+	languageName(languageName_),
+	language(language_),
+	lexClasses(lexClasses_),
+	nClasses(nClasses_) {
 }
 
 DefaultLexer::~DefaultLexer() {
@@ -36,7 +40,7 @@ void SCI_METHOD DefaultLexer::Release() {
 }
 
 int SCI_METHOD DefaultLexer::Version() const {
-	return lvRelease4;
+	return lvRelease5;
 }
 
 const char * SCI_METHOD DefaultLexer::PropertyNames() {
@@ -123,3 +127,13 @@ const char * SCI_METHOD DefaultLexer::TagsOfStyle(int style) {
 const char * SCI_METHOD DefaultLexer::DescriptionOfStyle(int style) {
 	return (style < NamedStyles()) ? lexClasses[style].description : "";
 }
+
+// ILexer5 methods
+const char * SCI_METHOD DefaultLexer::GetName() {
+	return languageName;
+}
+
+int SCI_METHOD DefaultLexer::GetIdentifier() {
+	return language;
+}
+
diff --git a/lexlib/DefaultLexer.h b/lexlib/DefaultLexer.h
index 6e3d7ac22..9139c4595 100644
--- a/lexlib/DefaultLexer.h
+++ b/lexlib/DefaultLexer.h
@@ -13,11 +13,14 @@
 namespace Scintilla {
 
 // A simple lexer with no state
-class DefaultLexer : public ILexer4 {
+class DefaultLexer : public ILexer5 {
+	const char *languageName;
+	int language;
 	const LexicalClass *lexClasses;
 	size_t nClasses;
 public:
-	DefaultLexer(const LexicalClass *lexClasses_ = nullptr, size_t nClasses_ = 0);
+	DefaultLexer(const char *languageName_, int language_,
+		const LexicalClass *lexClasses_ = nullptr, size_t nClasses_ = 0);
 	virtual ~DefaultLexer();
 	void SCI_METHOD Release() override;
 	int SCI_METHOD Version() const override;
@@ -44,6 +47,9 @@ public:
 	const char * SCI_METHOD NameOfStyle(int style) override;
 	const char * SCI_METHOD TagsOfStyle(int style) override;
 	const char * SCI_METHOD DescriptionOfStyle(int style) override;
+	// ILexer5 methods
+	const char * SCI_METHOD GetName() override;
+	int SCI_METHOD GetIdentifier() override;
 };
 
 }
diff --git a/lexlib/LexerBase.cxx b/lexlib/LexerBase.cxx
index ee3aa797e..bf195d824 100644
--- a/lexlib/LexerBase.cxx
+++ b/lexlib/LexerBase.cxx
@@ -44,7 +44,7 @@ void SCI_METHOD LexerBase::Release() {
 }
 
 int SCI_METHOD LexerBase::Version() const {
-	return lvRelease4;
+	return lvRelease5;
 }
 
 const char * SCI_METHOD LexerBase::PropertyNames() {
@@ -69,6 +69,10 @@ Sci_Position SCI_METHOD LexerBase::PropertySet(const char *key, const char *val)
 	}
 }
 
+const char *SCI_METHOD LexerBase::PropertyGet(const char *key) {
+	return props.Get(key);
+}
+
 const char * SCI_METHOD LexerBase::DescribeWordListSets() {
 	return "";
 }
@@ -139,3 +143,13 @@ const char * SCI_METHOD LexerBase::TagsOfStyle(int style) {
 const char * SCI_METHOD LexerBase::DescriptionOfStyle(int style) {
 	return (style < NamedStyles()) ? lexClasses[style].description : "";
 }
+
+// ILexer5 methods
+
+const char *SCI_METHOD LexerBase::GetName() {
+	return "";
+}
+
+int SCI_METHOD LexerBase::GetIdentifier() {
+	return SCLEX_AUTOMATIC;
+}
diff --git a/lexlib/LexerBase.h b/lexlib/LexerBase.h
index ae8096591..22d17fea1 100644
--- a/lexlib/LexerBase.h
+++ b/lexlib/LexerBase.h
@@ -11,7 +11,7 @@
 namespace Scintilla {
 
 // A simple lexer with no state
-class LexerBase : public ILexer4 {
+class LexerBase : public ILexer5 {
 protected:
 	const LexicalClass *lexClasses;
 	size_t nClasses;
@@ -46,6 +46,10 @@ public:
 	const char * SCI_METHOD NameOfStyle(int style) override;
 	const char * SCI_METHOD TagsOfStyle(int style) override;
 	const char * SCI_METHOD DescriptionOfStyle(int style) override;
+	// ILexer5 methods
+	const char * SCI_METHOD GetName() override;
+	int SCI_METHOD GetIdentifier() override;
+	const char *SCI_METHOD PropertyGet(const char *key) override;
 };
 
 }
diff --git a/lexlib/LexerModule.cxx b/lexlib/LexerModule.cxx
index a03be30ef..3d4010756 100644
--- a/lexlib/LexerModule.cxx
+++ b/lexlib/LexerModule.cxx
@@ -93,7 +93,7 @@ size_t LexerModule::NamedStyles() const {
 	return nClasses;
 }
 
-ILexer4 *LexerModule::Create() const {
+ILexer5 *LexerModule::Create() const {
 	if (fnFactory)
 		return fnFactory();
 	else
diff --git a/lexlib/LexerModule.h b/lexlib/LexerModule.h
index 96cff9645..d3b378c9b 100644
--- a/lexlib/LexerModule.h
+++ b/lexlib/LexerModule.h
@@ -16,7 +16,7 @@ struct LexicalClass;
 
 typedef void (*LexerFunction)(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle,
                   WordList *keywordlists[], Accessor &styler);
-typedef ILexer4 *(*LexerFactoryFunction)();
+typedef ILexer5 *(*LexerFactoryFunction)();
 
 /**
  * A LexerModule is responsible for lexing and folding a particular language.
@@ -58,7 +58,7 @@ public:
 	const LexicalClass *LexClasses() const;
 	size_t NamedStyles() const;
 
-	ILexer4 *Create() const;
+	ILexer5 *Create() const;
 
 	virtual void Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle,
                   WordList *keywordlists[], Accessor &styler) const;
diff --git a/lexlib/LexerSimple.cxx b/lexlib/LexerSimple.cxx
index 0be7d97ca..e69c44ad6 100644
--- a/lexlib/LexerSimple.cxx
+++ b/lexlib/LexerSimple.cxx
@@ -51,3 +51,11 @@ void SCI_METHOD LexerSimple::Fold(Sci_PositionU startPos, Sci_Position lengthDoc
 		astyler.Flush();
 	}
 }
+
+const char * SCI_METHOD LexerSimple::GetName() {
+	return module->languageName;
+}
+
+int SCI_METHOD LexerSimple::GetIdentifier() {
+	return module->GetLanguage();
+}
diff --git a/lexlib/LexerSimple.h b/lexlib/LexerSimple.h
index 87882eaeb..ae4177769 100644
--- a/lexlib/LexerSimple.h
+++ b/lexlib/LexerSimple.h
@@ -19,6 +19,9 @@ public:
 	const char * SCI_METHOD DescribeWordListSets() override;
 	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) override;
 	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) override;
+	// ILexer5 methods
+	const char * SCI_METHOD GetName() override;
+	int SCI_METHOD  GetIdentifier() override;
 };
 
 }
diff --git a/src/Document.h b/src/Document.h
index ee0024f38..ea89877ec 100644
--- a/src/Document.h
+++ b/src/Document.h
@@ -171,7 +171,7 @@ constexpr int LevelNumber(int level) noexcept {
 class LexInterface {
 protected:
 	Document *pdoc;
-	ILexer4 *instance;
+	ILexer5 *instance;
 	bool performingStyle;	///< Prevent reentrance
 public:
 	explicit LexInterface(Document *pdoc_) noexcept : pdoc(pdoc_), instance(nullptr), performingStyle(false) {