diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index edeb8e066..0cb4702dd 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -3,15 +3,18 @@ name: docs
 on:
   create:
     tags:
-    # https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#filter-pattern-cheat-sheet
+      # https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#filter-pattern-cheat-sheet
       - b[0-9][0-9][0-9]
       - publish-docs*
   push:
     branches:
       - main
+  pull_request: # Temporary just for test
+    branches:
+      - main
 
 jobs:
-  decompile:
+  generate:
     runs-on: windows-latest
 
     steps:
@@ -22,44 +25,43 @@ jobs:
         with:
           python-version: '3.9'
 
+      # We still need to install pywin32 because
+      # AutoDuck/py2d.py currently relies on runtime imports for introspection
+      # Downloading latest release is faster than re-building
       - name: Install latest release
         run: pip install --user --upgrade pywin32
 
-      - name: Set Python user site directory
-        run: python -c "import os,site;open(os.environ['GITHUB_ENV'], 'a').write(f'USER_DIR={site.USER_SITE}\n')"
+      - name: Generate PyWin32.chm help file
+        run: python AutoDuck/make.py
 
-      - name: Decompile shipped help file
-        run: hh -decompile site ${env:USER_DIR}\PyWin32.chm
+      - name: Decompile help file into HTML
+        run: hh -decompile site PyWin32.chm
 
       - name: Rename root HTML file
         run: mv site\PyWin32.HTML site\index.html
 
-    # Compress first to avoid slowly uploading thousands of individual files
-      - name: Create archive
-        run: python -m zipfile -c site.zip site
-
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: documentation
-          path: site.zip
+          path: site/
 
   publish:
     runs-on: ubuntu-latest
     needs:
-      - decompile
+      - generate
 
     # Only publish tags
     if: github.event_name == 'create' && github.event.ref_type == 'tag'
 
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: documentation
 
       - name: Unpack archive
         run: python -m zipfile -e site.zip .
 
-      - uses: peaceiris/actions-gh-pages@v3
+      - uses: peaceiris/actions-gh-pages@v4
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           publish_dir: site
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index b2d6ff5c8..d2c233d7f 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -43,6 +43,13 @@ jobs:
         run: |
           python setup.py install --user
 
+      # This needs to happen *after* installing pywin32 since
+      # AutoDuck/py2d.py currently relies on runtime imports for introspection
+      # This isn't included in the wheel (TODO: could we?)
+      # and only servces as a PR test for the docs.yaml workflow
+      - name: Generate PyWin32.chm help file
+        run: python AutoDuck/make.py
+
       - name: Run tests
         # Run the tests directly from the source dir so support files (eg, .wav files etc)
         # can be found - they aren't installed into the Python tree.
diff --git a/AutoDuck/README b/AutoDuck/README.md
similarity index 77%
rename from AutoDuck/README
rename to AutoDuck/README.md
index 5d0520aed..192828d79 100644
--- a/AutoDuck/README
+++ b/AutoDuck/README.md
@@ -1,4 +1,4 @@
-Just run MAKE.BAT to build the documentation.
+Just run [make.py](./make.py) to build the documentation.
 
 Main focus these days is on the .chm file - a single .chm
 provides the best documentation solution.  We don't even
diff --git a/AutoDuck/common_top.mak b/AutoDuck/common_top.mak
index a76ffcda9..a2ebbd9e0 100644
--- a/AutoDuck/common_top.mak
+++ b/AutoDuck/common_top.mak
@@ -1,13 +1,12 @@
 # Common AutoDuck make file
 
-AD		  = bin\autoduck.exe /Spythonwin.fmt
+AD        = bin\autoduck.exe /Spythonwin.fmt
 ADHTMLFMT = bin\autoduck.exe /Spyhtml.fmt
 ADHTMLLOG = /R html "/L$(GENDIR)\$(TARGET).HHLOG" /N
-ADLOG	  = /R help "/L$(GENDIR)\$(TARGET).HLOG" /N
-ADHTML	  = /R html "/G$(GENDIR)\$(TARGET).DUMP" "/C$(GENDIR)\$(TARGET).HHLOG" "/I$(GENDIR)\$(TARGET).IDX" "/O$(GENDIR)\$(TARGET).HTML" /D "title=$(TITLE)"
-ADHLP	  = /R help "/C$(GENDIR)\$(TARGET).HLOG" "/O$(GENDIR)\$(TARGET).RTF" /D "title=$(TITLE)"
-ADDOC	  = /RD "/O$(GENDIR)\$(TARGET).DOC" /D "doc_header=$(DOCHDR)"
-ADTAB	  = 8
-HC		  = hcw /a /c /e
-HHC		  = hhc
-PYTHON   = py -2.7
+ADLOG     = /R help "/L$(GENDIR)\$(TARGET).HLOG" /N
+ADHTML    = /R html "/G$(GENDIR)\$(TARGET).DUMP" "/C$(GENDIR)\$(TARGET).HHLOG" "/I$(GENDIR)\$(TARGET).IDX" "/O$(GENDIR)\$(TARGET).HTML" /D "title=$(TITLE)"
+ADHLP     = /R help "/C$(GENDIR)\$(TARGET).HLOG" "/O$(GENDIR)\$(TARGET).RTF" /D "title=$(TITLE)"
+ADDOC     = /RD "/O$(GENDIR)\$(TARGET).DOC" /D "doc_header=$(DOCHDR)"
+ADTAB     = 8
+HC        = hcw /a /c /e
+HHC       = hhc
diff --git a/AutoDuck/make.py b/AutoDuck/make.py
index d3b9ee39a..c205aa0da 100644
--- a/AutoDuck/make.py
+++ b/AutoDuck/make.py
@@ -26,5 +26,7 @@
     ).splitlines()[-1]
 
     subprocess.run(
-        [nmake, "-E", "-f", "pywin32.mak"], cwd=os.path.dirname(sys.argv[0]), check=True
+        [nmake, f'PYTHON="{sys.executable}"', "-E", "-f", "pywin32.mak"],
+        cwd=os.path.dirname(sys.argv[0]),
+        check=True,
     )
diff --git a/AutoDuck/py2d.py b/AutoDuck/py2d.py
index 2b2d779b8..5000b5ec6 100644
--- a/AutoDuck/py2d.py
+++ b/AutoDuck/py2d.py
@@ -7,9 +7,6 @@ def ad_escape(s):
     return re.sub(r"([^<]*)<([^>]*)>", r"\g<1>\\<\g<2>\\>", s)
 
 
-Print = __builtins__.__dict__["print"]
-
-
 class DocInfo:
     def __init__(self, name, ob):
         self.name = name
@@ -112,30 +109,30 @@ def build_module(fp, mod_name):
         elif name.upper() == name and isinstance(ob, (int, str)):
             constants.append((name, ob))
     info = BuildInfo(mod_name, mod)
-    Print(f"// @module {mod_name}|{format_desc(info.desc)}", file=fp)
+    print(f"// @module {mod_name}|{format_desc(info.desc)}", file=fp)
     functions = [f for f in functions if should_build_function(f)]
     for ob in functions:
-        Print(f"// @pymeth {ob.name}|{ob.short_desc}", file=fp)
+        print(f"// @pymeth {ob.name}|{ob.short_desc}", file=fp)
     for ob in classes:
         # only classes with docstrings get printed.
         if not ob.ob.__doc__:
             continue
         ob_name = mod_name + "." + ob.name
-        Print(f"// @pyclass {ob.name}|{ob.short_desc}", file=fp)
+        print(f"// @pyclass {ob.name}|{ob.short_desc}", file=fp)
     for ob in functions:
-        Print(
+        print(
             f"// @pymethod |{mod_name}|{ob.name}|{format_desc(ob.desc)}",
             file=fp,
         )
         for ai in BuildArgInfos(ob.ob):
-            Print(f"// @pyparm |{ai.name}|{ai.default}|{ai.short_desc}", file=fp)
+            print(f"// @pyparm |{ai.name}|{ai.default}|{ai.short_desc}", file=fp)
 
     for ob in classes:
         # only classes with docstrings get printed.
         if not ob.ob.__doc__:
             continue
         ob_name = mod_name + "." + ob.name
-        Print(f"// @object {ob_name}|{format_desc(ob.desc)}", file=fp)
+        print(f"// @object {ob_name}|{format_desc(ob.desc)}", file=fp)
         func_infos = []
         # We need to iter the keys then to a getattr() so the funky descriptor
         # things work.
@@ -146,20 +143,20 @@ def build_module(fp, mod_name):
                 if should_build_function(info):
                     func_infos.append(info)
         for fi in func_infos:
-            Print(f"// @pymeth {fi.name}|{fi.short_desc}", file=fp)
+            print(f"// @pymeth {fi.name}|{fi.short_desc}", file=fp)
         for fi in func_infos:
-            Print(
+            print(
                 f"// @pymethod |{ob_name}|{fi.name}|{format_desc(fi.desc)}",
                 file=fp,
             )
             if hasattr(fi.ob, "im_self") and fi.ob.im_self is ob.ob:
-                Print("// @comm This is a @classmethod.", file=fp)
-            Print(
+                print("// @comm This is a @classmethod.", file=fp)
+            print(
                 f"// @pymethod |{ob_name}|{fi.name}|{format_desc(fi.desc)}",
                 file=fp,
             )
             for ai in BuildArgInfos(fi.ob):
-                Print(
+                print(
                     f"// @pyparm |{ai.name}|{ai.default}|{ai.short_desc}",
                     file=fp,
                 )
@@ -168,11 +165,11 @@ def build_module(fp, mod_name):
         desc = f"{name} = {val!r}"
         if isinstance(val, int):
             desc += f" (0x{val:x})"
-        Print(f"// @const {mod_name}|{name}|{desc}", file=fp)
+        print(f"// @const {mod_name}|{name}|{desc}", file=fp)
 
 
 def main(fp, args):
-    Print("// @doc", file=fp)
+    print("// @doc", file=fp)
     for arg in args:
         build_module(sys.stdout, arg)
 
diff --git a/CHANGES.txt b/CHANGES.txt
index 83ca2052e..f14663b68 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -14,6 +14,9 @@ https://mhammond.github.io/pywin32_installers.html.
 Coming in build 309, as yet unreleased
 --------------------------------------
 
+* Pythonwin: Bumped Scintilla from 1.77 to 4.4.6. The full changelog can be found here: https://www.scintilla.org/ScintillaHistory.html
+* Fixed `ddeclient` and `ddeserver` demos import error (#2290, @Avasam)
+* The `EvtSubscribe_push` demo now actually demonstrates the callback action and the event context being filled. (#2281, @Avasam)
 * Fixed Pythonwin's editor failing due to invalid regex import (#2419, @Avasam)
 * Last error wrongly set by some modules (#2302, @CristiFati)
 * Dropped support for Python 3.7 (#2207, @Avasam)
diff --git a/Pythonwin/Scintilla/License.txt b/Pythonwin/Scintilla/License.txt
index cbe25b2fc..47c792655 100644
--- a/Pythonwin/Scintilla/License.txt
+++ b/Pythonwin/Scintilla/License.txt
@@ -2,19 +2,19 @@ License for Scintilla and SciTE
 
 Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
 
-All Rights Reserved 
+All Rights Reserved
 
-Permission to use, copy, modify, and distribute this software and its 
-documentation for any purpose and without fee is hereby granted, 
-provided that the above copyright notice appear in all copies and that 
-both that copyright notice and this permission notice appear in 
-supporting documentation. 
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation.
 
-NEIL HODGSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
-SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
-AND FITNESS, IN NO EVENT SHALL NEIL HODGSON BE LIABLE FOR ANY 
-SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 
-WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 
-TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE 
-OR PERFORMANCE OF THIS SOFTWARE. 
\ No newline at end of file
+NEIL HODGSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS, IN NO EVENT SHALL NEIL HODGSON BE LIABLE FOR ANY
+SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
+OR PERFORMANCE OF THIS SOFTWARE.
\ No newline at end of file
diff --git a/Pythonwin/Scintilla/README b/Pythonwin/Scintilla/README
index c66baf66a..618842b42 100644
--- a/Pythonwin/Scintilla/README
+++ b/Pythonwin/Scintilla/README
@@ -3,12 +3,19 @@ README for building of Scintilla and SciTE
 Scintilla can be built by itself.
 To build SciTE, Scintilla must first be built.
 
+Lexers can be either compiled into Scintilla or built separately into a Lexilla
+shared library.
+A separate Lexilla is the preferred option and will become the only supported
+direction in Scintilla 5.0.
+See lexilla/src/README for information on building Lexilla.
 
 *** GTK+/Linux version ***
 
-You must first have GTK+ 1.2 or later and GCC (3.1 or better) installed.
-GTK+ 1.0x will not work and when it did it was very slow.
+You must first have GTK+ 2.24 or later and GCC (7.1 or better) installed.
+Clang may be used by adding CLANG=1 to the make command line.
 Other C++ compilers may work but may require tweaking the make file.
+Either GTK+ 2.x or 3.x may be used with 2.x the default and 3.x
+chosen with the make argument GTK3=1.
 
 To build Scintilla, use the makefile located in the scintilla/gtk directory
 	cd scintilla/gtk
@@ -18,7 +25,7 @@ To build Scintilla, use the makefile located in the scintilla/gtk directory
 To build and install SciTE, use the makefile located in the scite/gtk directory
 	cd scite/gtk
 	make
-	make install
+	sudo make install
 
 This installs SciTE into $prefix/bin. The value of $prefix is determined from
 the location of Gnome if it is installed. This is usually /usr if installed
@@ -29,12 +36,8 @@ and make install as this location is compiled into the executable. The global
 properties file is installed at $prefix/share/scite/SciTEGlobal.properties.
 The language specific properties files are also installed into this directory.
 
-To build Scintilla for GTK+ 1 rather than the default GTK+ 2, define GTK1 on
-the make command line:
-	make GTK1=1
-
 To remove SciTE
-	make uninstall
+	sudo make uninstall
 
 To clean the object files which may be needed to change $prefix
 	make clean
@@ -44,26 +47,58 @@ The current make file only supports static linking between SciTE and Scintilla.
 
 *** Windows version ***
 
-A C++ compiler is required. Visual Studio .NET 2008 is the development system
-used for most development although Mingw32 3.1 is also supported.
-Borland did work but the command lines are now too long and the most recent
-Borland version does not work. For older versions such as version 5.02, add the -l option.
+A C++ 17 compiler is required.
+Visual Studio 2017 is the development system used for most development
+although Mingw-w64 7.1 is also supported.
+
+There are versions of Scintilla with lexers (SciLexer.DLL) and without lexers
+(Scintilla.DLL). Make builds both versions.
 
 To build Scintilla, make in the scintilla/win32 directory
 		cd scintilla\win32
 GCC:		mingw32-make
-VS .NET:	nmake -f scintilla.mak
-VC++ 6:	nmake -f scintilla_vc6.mak
-Borland: 	make -fscintilla.mak
+Visual C++:	nmake -f scintilla.mak
 		cd ..\..
 
 To build SciTE, use the makefiles located in the scite/win32 directory
 		cd scite\win32
 GCC:		mingw32-make
-VS .NET: 	nmake -f scite.mak
-Borland:	make -fscite.mak
+Visual C++: 	nmake -f scite.mak
+
+An executable SciTE will now be in scite/bin.
+
+*** GTK+/Windows version ***
+
+Mingw-w64 is known to work. Other compilers will probably not work.
+
+Only Scintilla will build with GTK+ on Windows. SciTE will not work.
+
+Make builds both a static library version of Scintilla with lexers (scintilla.a) and
+a shared library without lexers (libscintilla.so or or libscintilla.dll).
+
+To build Scintilla, make in the scintilla/gtk directory
+	cd scintilla\gtk
+	mingw32-make
+
+*** macOS Cocoa version ***
+
+Xcode 9.2 or later may be used to build Scintilla on macOS.
+
+There is no open source version of SciTE for macOS but there is a commercial
+version available through the App Store.
+
+There are versions of Scintilla.framework with lexers (ScintillaFramework) and
+without lexers (Scintilla).
+
+To build Scintilla, run xcodebuild in the scintilla/cocoa/ScintillaFramework or 
+scintilla/cocoa/Scintilla directory
+
+        cd cocoa/Scintilla
+		or
+        cd cocoa/ScintillaFramework
+
+	xcodebuild
 
-An executable SciTE will now be in scite\bin.
+*** Qt version ***
 
-The Visual C++ 6.0 project (.dsp) files are no longer supported but are left
-in the download for people that are prepared to update them.
+See the qt/README file to build Scintilla with Qt.
diff --git a/Pythonwin/Scintilla/README_pythonwin b/Pythonwin/Scintilla/README_pythonwin
index 9a9ede15e..6ad4a6405 100644
--- a/Pythonwin/Scintilla/README_pythonwin
+++ b/Pythonwin/Scintilla/README_pythonwin
@@ -1,8 +1,13 @@
-This is a copy of Scintilla 1.77 used for Pythonwin.
+This is a copy of Scintilla 4.4.6 used for Pythonwin.
 
-Scintilla's home is www.scintilla.org
+Scintilla's home is https://www.scintilla.org/
 
 Only the sources relevant to Scintilla under Pythonwin are
-included (plus the Scintilla licence and readme).  For the
-full set of Scintilla sources, including its documentation and
-companion editor Scite, see www.scintilla.org.
\ No newline at end of file
+included (plus the Scintilla Licence.txt and README).
+For the full set of Scintilla sources, including its documentation
+and companion editor SciTE, see https://www.scintilla.org/.
+
+When updating the Scintilla source, also update the copyright year
+in Pythonwin/pywin/framework/app.py and regenerate
+Pythonwin/pywin/scintilla/scintillacon.py using h2py:
+https://github.com/python/cpython/blob/3.8/Tools/scripts/h2py.py
diff --git a/Pythonwin/Scintilla/include/Accessor.h b/Pythonwin/Scintilla/include/Accessor.h
deleted file mode 100644
index d9db9c7bf..000000000
--- a/Pythonwin/Scintilla/include/Accessor.h
+++ /dev/null
@@ -1,79 +0,0 @@
-// Scintilla source code edit control
-/** @file Accessor.h
- ** Rapid easy access to contents of a Scintilla.
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-enum { wsSpace = 1, wsTab = 2, wsSpaceTab = 4, wsInconsistent=8};
-
-class Accessor;
-
-typedef bool (*PFNIsCommentLeader)(Accessor &styler, int pos, int len);
-
-/**
- * Interface to data in a Scintilla.
- */
-class Accessor {
-protected:
-	enum {extremePosition=0x7FFFFFFF};
-	/** @a bufferSize is a trade off between time taken to copy the characters
-	 * and retrieval overhead.
-	 * @a slopSize positions the buffer before the desired position
-	 * in case there is some backtracking. */
-	enum {bufferSize=4000, slopSize=bufferSize/8};
-	char buf[bufferSize+1];
-	int startPos;
-	int endPos;
-	int codePage;	
-
-	virtual bool InternalIsLeadByte(char ch)=0;
-	virtual void Fill(int position)=0;
-
-public:
-	Accessor() : startPos(extremePosition), endPos(0), codePage(0) {}
-	virtual ~Accessor() {}
-	char operator[](int position) {
-		if (position < startPos || position >= endPos) {
-			Fill(position);
-		}
-		return buf[position - startPos];
-	}
-	/** Safe version of operator[], returning a defined value for invalid position. */
-	char SafeGetCharAt(int position, char chDefault=' ') {
-		if (position < startPos || position >= endPos) {
-			Fill(position);
-			if (position < startPos || position >= endPos) {
-				// Position is outside range of document 
-				return chDefault;
-			}
-		}
-		return buf[position - startPos];
-	}
-	bool IsLeadByte(char ch) {
-		return codePage && InternalIsLeadByte(ch);
-	}
-	void SetCodePage(int codePage_) { codePage = codePage_; }
-
-	virtual bool Match(int pos, const char *s)=0;
-	virtual char StyleAt(int position)=0;
-	virtual int GetLine(int position)=0;
-	virtual int LineStart(int line)=0;
-	virtual int LevelAt(int line)=0;
-	virtual int Length()=0;
-	virtual void Flush()=0;
-	virtual int GetLineState(int line)=0;
-	virtual int SetLineState(int line, int state)=0;
-	virtual int GetPropertyInt(const char *key, int defaultValue=0)=0;
-	virtual char *GetProperties()=0;
-
-	// Style setting
-	virtual void StartAt(unsigned int start, char chMask=31)=0;
-	virtual void SetFlags(char chFlags_, char chWhile_)=0;
-	virtual unsigned int GetStartSegment()=0;
-	virtual void StartSegment(unsigned int pos)=0;
-	virtual void ColourTo(unsigned int pos, int chAttr)=0;
-	virtual void SetLevel(int line, int level)=0;
-	virtual int IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader = 0)=0;
-	virtual void IndicatorFill(int start, int end, int indicator, int value)=0;
-};
diff --git a/Pythonwin/Scintilla/include/ILexer.h b/Pythonwin/Scintilla/include/ILexer.h
new file mode 100644
index 000000000..bc9ee1ab5
--- /dev/null
+++ b/Pythonwin/Scintilla/include/ILexer.h
@@ -0,0 +1,85 @@
+// Scintilla source code edit control
+/** @file ILexer.h
+ ** Interface between Scintilla and lexers.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef ILEXER_H
+#define ILEXER_H
+
+#include "Sci_Position.h"
+
+namespace Scintilla {
+
+enum { dvRelease4=2 };
+
+class IDocument {
+public:
+	virtual int SCI_METHOD Version() const = 0;
+	virtual void SCI_METHOD SetErrorStatus(int status) = 0;
+	virtual Sci_Position SCI_METHOD Length() const = 0;
+	virtual void SCI_METHOD GetCharRange(char *buffer, Sci_Position position, Sci_Position lengthRetrieve) const = 0;
+	virtual char SCI_METHOD StyleAt(Sci_Position position) const = 0;
+	virtual Sci_Position SCI_METHOD LineFromPosition(Sci_Position position) const = 0;
+	virtual Sci_Position SCI_METHOD LineStart(Sci_Position line) const = 0;
+	virtual int SCI_METHOD GetLevel(Sci_Position line) const = 0;
+	virtual int SCI_METHOD SetLevel(Sci_Position line, int level) = 0;
+	virtual int SCI_METHOD GetLineState(Sci_Position line) const = 0;
+	virtual int SCI_METHOD SetLineState(Sci_Position line, int state) = 0;
+	virtual void SCI_METHOD StartStyling(Sci_Position position) = 0;
+	virtual bool SCI_METHOD SetStyleFor(Sci_Position length, char style) = 0;
+	virtual bool SCI_METHOD SetStyles(Sci_Position length, const char *styles) = 0;
+	virtual void SCI_METHOD DecorationSetCurrentIndicator(int indicator) = 0;
+	virtual void SCI_METHOD DecorationFillRange(Sci_Position position, int value, Sci_Position fillLength) = 0;
+	virtual void SCI_METHOD ChangeLexerState(Sci_Position start, Sci_Position end) = 0;
+	virtual int SCI_METHOD CodePage() const = 0;
+	virtual bool SCI_METHOD IsDBCSLeadByte(char ch) const = 0;
+	virtual const char * SCI_METHOD BufferPointer() = 0;
+	virtual int SCI_METHOD GetLineIndentation(Sci_Position line) = 0;
+	virtual Sci_Position SCI_METHOD LineEnd(Sci_Position line) const = 0;
+	virtual Sci_Position SCI_METHOD GetRelativePosition(Sci_Position positionStart, Sci_Position characterOffset) const = 0;
+	virtual int SCI_METHOD GetCharacterAndWidth(Sci_Position position, Sci_Position *pWidth) const = 0;
+};
+
+enum { lvRelease4=2, lvRelease5=3 };
+
+class ILexer4 {
+public:
+	virtual int SCI_METHOD Version() const = 0;
+	virtual void SCI_METHOD Release() = 0;
+	virtual const char * SCI_METHOD PropertyNames() = 0;
+	virtual int SCI_METHOD PropertyType(const char *name) = 0;
+	virtual const char * SCI_METHOD DescribeProperty(const char *name) = 0;
+	virtual Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) = 0;
+	virtual const char * SCI_METHOD DescribeWordListSets() = 0;
+	virtual Sci_Position SCI_METHOD WordListSet(int n, const char *wl) = 0;
+	virtual void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) = 0;
+	virtual void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) = 0;
+	virtual void * SCI_METHOD PrivateCall(int operation, void *pointer) = 0;
+	virtual int SCI_METHOD LineEndTypesSupported() = 0;
+	virtual int SCI_METHOD AllocateSubStyles(int styleBase, int numberStyles) = 0;
+	virtual int SCI_METHOD SubStylesStart(int styleBase) = 0;
+	virtual int SCI_METHOD SubStylesLength(int styleBase) = 0;
+	virtual int SCI_METHOD StyleFromSubStyle(int subStyle) = 0;
+	virtual int SCI_METHOD PrimaryStyleFromStyle(int style) = 0;
+	virtual void SCI_METHOD FreeSubStyles() = 0;
+	virtual void SCI_METHOD SetIdentifiers(int style, const char *identifiers) = 0;
+	virtual int SCI_METHOD DistanceToSecondaryStyles() = 0;
+	virtual const char * SCI_METHOD GetSubStyleBases() = 0;
+	virtual int SCI_METHOD NamedStyles() = 0;
+	virtual const char * SCI_METHOD NameOfStyle(int style) = 0;
+	virtual const char * SCI_METHOD TagsOfStyle(int style) = 0;
+	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/Pythonwin/Scintilla/include/ILoader.h b/Pythonwin/Scintilla/include/ILoader.h
new file mode 100644
index 000000000..e989de873
--- /dev/null
+++ b/Pythonwin/Scintilla/include/ILoader.h
@@ -0,0 +1,21 @@
+// Scintilla source code edit control
+/** @file ILoader.h
+ ** Interface for loading into a Scintilla document from a background thread.
+ **/
+// Copyright 1998-2017 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef ILOADER_H
+#define ILOADER_H
+
+#include "Sci_Position.h"
+
+class ILoader {
+public:
+	virtual int SCI_METHOD Release() = 0;
+	// Returns a status code from SC_STATUS_*
+	virtual int SCI_METHOD AddData(const char *data, Sci_Position length) = 0;
+	virtual void * SCI_METHOD ConvertToDocument() = 0;
+};
+
+#endif
diff --git a/Pythonwin/Scintilla/include/KeyWords.h b/Pythonwin/Scintilla/include/KeyWords.h
deleted file mode 100644
index 6abae5945..000000000
--- a/Pythonwin/Scintilla/include/KeyWords.h
+++ /dev/null
@@ -1,90 +0,0 @@
-// Scintilla source code edit control
-/** @file KeyWords.h
- ** Colourise for particular languages.
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#ifdef SCI_NAMESPACE
-namespace Scintilla {
-#endif
-
-typedef void (*LexerFunction)(unsigned int startPos, int lengthDoc, int initStyle,
-                  WordList *keywordlists[], Accessor &styler);
-                  
-/**
- * A LexerModule is responsible for lexing and folding a particular language.
- * The class maintains a list of LexerModules which can be searched to find a
- * module appropriate to a particular language.
- */
-class LexerModule {
-protected:
-	const LexerModule *next;
-	int language;
-	LexerFunction fnLexer;
-	LexerFunction fnFolder;
-	const char * const * wordListDescriptions;
-	int styleBits;
-
-	static const LexerModule *base;
-	static int nextLanguage;
-
-public:
-	const char *languageName;
-	LexerModule(int language_, 
-		LexerFunction fnLexer_, 
-		const char *languageName_=0, 
-		LexerFunction fnFolder_=0,
-		const char * const wordListDescriptions_[] = NULL,
-		int styleBits_=5);
-	virtual ~LexerModule() {
-	}
-	int GetLanguage() const { return language; }
-
-	// -1 is returned if no WordList information is available
-	int GetNumWordLists() const;
-	const char *GetWordListDescription(int index) const;
-
-	int GetStyleBitsNeeded() const;
-
-	virtual void Lex(unsigned int startPos, int lengthDoc, int initStyle,
-                  WordList *keywordlists[], Accessor &styler) const;
-	virtual void Fold(unsigned int startPos, int lengthDoc, int initStyle,
-                  WordList *keywordlists[], Accessor &styler) const;
-	static const LexerModule *Find(int language);
-	static const LexerModule *Find(const char *languageName);
-};
-
-#ifdef SCI_NAMESPACE
-}
-#endif
-
-/**
- * Check if a character is a space.
- * This is ASCII specific but is safe with chars >= 0x80.
- */
-inline bool isspacechar(unsigned char ch) {
-    return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d));
-}
-
-inline bool iswordchar(char ch) {
-	return isascii(ch) && (isalnum(ch) || ch == '.' || ch == '_');
-}
-
-inline bool iswordstart(char ch) {
-	return isascii(ch) && (isalnum(ch) || ch == '_');
-}
-
-inline bool isoperator(char ch) {
-	if (isascii(ch) && isalnum(ch))
-		return false;
-	// '.' left out as it is used to make up numbers
-	if (ch == '%' || ch == '^' || ch == '&' || ch == '*' ||
-	        ch == '(' || ch == ')' || ch == '-' || ch == '+' ||
-	        ch == '=' || ch == '|' || ch == '{' || ch == '}' ||
-	        ch == '[' || ch == ']' || ch == ':' || ch == ';' ||
-	        ch == '<' || ch == '>' || ch == ',' || ch == '/' ||
-	        ch == '?' || ch == '!' || ch == '.' || ch == '~')
-		return true;
-	return false;
-}
diff --git a/Pythonwin/Scintilla/include/Platform.h b/Pythonwin/Scintilla/include/Platform.h
index 98fd7e042..628611132 100644
--- a/Pythonwin/Scintilla/include/Platform.h
+++ b/Pythonwin/Scintilla/include/Platform.h
@@ -3,7 +3,7 @@
  ** Interface to platform facilities. Also includes some basic utilities.
  ** Implemented in PlatGTK.cxx for GTK+/Linux, PlatWin.cxx for Windows, and PlatWX.cxx for wxWindows.
  **/
-// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+// Copyright 1998-2009 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
 #ifndef PLATFORM_H
@@ -13,13 +13,19 @@
 // PLAT_GTK_WIN32 is defined additionally when running PLAT_GTK under Win32
 // PLAT_WIN = Win32 API on Win32 OS
 // PLAT_WX is wxWindows on any supported platform
+// PLAT_TK = Tcl/TK on Linux or Win32
 
 #define PLAT_GTK 0
 #define PLAT_GTK_WIN32 0
+#define PLAT_GTK_MACOSX 0
 #define PLAT_MACOSX 0
 #define PLAT_WIN 0
 #define PLAT_WX  0
+#define PLAT_QT 0
 #define PLAT_FOX 0
+#define PLAT_CURSES 0
+#define PLAT_TK 0
+#define PLAT_HAIKU 0
 
 #if defined(FOX)
 #undef PLAT_FOX
@@ -29,6 +35,22 @@
 #undef PLAT_WX
 #define PLAT_WX  1
 
+#elif defined(CURSES)
+#undef PLAT_CURSES
+#define PLAT_CURSES 1
+
+#elif defined(__HAIKU__)
+#undef PLAT_HAIKU
+#define PLAT_HAIKU 1
+
+#elif defined(SCINTILLA_QT)
+#undef PLAT_QT
+#define PLAT_QT 1
+
+#elif defined(TK)
+#undef PLAT_TK
+#define PLAT_TK 1
+
 #elif defined(GTK)
 #undef PLAT_GTK
 #define PLAT_GTK 1
@@ -38,7 +60,13 @@
 #define PLAT_GTK_WIN32 1
 #endif
 
-#elif defined(MACOSX)
+#if defined(__APPLE__)
+#undef PLAT_GTK_MACOSX
+#define PLAT_GTK_MACOSX 1
+#endif
+
+#elif defined(__APPLE__)
+
 #undef PLAT_MACOSX
 #define PLAT_MACOSX 1
 
@@ -48,9 +76,10 @@
 
 #endif
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
+
+typedef float XYPOSITION;
+typedef double XYACCUMULATOR;
 
 // Underlying the implementation of the platform classes are platform specific types.
 // Sometimes these need to be passed around by client code so they are defined here
@@ -65,257 +94,285 @@ typedef void *IdlerID;
 
 /**
  * A geometric point class.
- * Point is exactly the same as the Win32 POINT and GTK+ GdkPoint so can be used interchangeably.
+ * Point is similar to the Win32 POINT and GTK+ GdkPoint types.
  */
 class Point {
 public:
-	int x;
-	int y;
+	XYPOSITION x;
+	XYPOSITION y;
 
-	explicit Point(int x_=0, int y_=0) : x(x_), y(y_) {
+	constexpr explicit Point(XYPOSITION x_=0, XYPOSITION y_=0) noexcept : x(x_), y(y_) {
 	}
 
-	// Other automatically defined methods (assignment, copy constructor, destructor) are fine
+	static constexpr Point FromInts(int x_, int y_) noexcept {
+		return Point(static_cast<XYPOSITION>(x_), static_cast<XYPOSITION>(y_));
+	}
+
+	constexpr bool operator!=(Point other) const noexcept {
+		return (x != other.x) || (y != other.y);
+	}
 
-	static Point FromLong(long lpoint);
+	constexpr Point operator+(Point other) const noexcept {
+		return Point(x + other.x, y + other.y);
+	}
+
+	constexpr Point operator-(Point other) const noexcept {
+		return Point(x - other.x, y - other.y);
+	}
+
+	// Other automatically defined methods (assignment, copy constructor, destructor) are fine
 };
 
 /**
  * A geometric rectangle class.
- * PRectangle is exactly the same as the Win32 RECT so can be used interchangeably.
+ * PRectangle is similar to Win32 RECT.
  * PRectangles contain their top and left sides, but not their right and bottom sides.
  */
 class PRectangle {
 public:
-	int left;
-	int top;
-	int right;
-	int bottom;
+	XYPOSITION left;
+	XYPOSITION top;
+	XYPOSITION right;
+	XYPOSITION bottom;
 
-	PRectangle(int left_=0, int top_=0, int right_=0, int bottom_ = 0) :
+	constexpr explicit PRectangle(XYPOSITION left_=0, XYPOSITION top_=0, XYPOSITION right_=0, XYPOSITION bottom_ = 0) noexcept :
 		left(left_), top(top_), right(right_), bottom(bottom_) {
 	}
 
+	static constexpr PRectangle FromInts(int left_, int top_, int right_, int bottom_) noexcept {
+		return PRectangle(static_cast<XYPOSITION>(left_), static_cast<XYPOSITION>(top_),
+			static_cast<XYPOSITION>(right_), static_cast<XYPOSITION>(bottom_));
+	}
+
 	// Other automatically defined methods (assignment, copy constructor, destructor) are fine
 
-	bool operator==(PRectangle &rc) {
+	constexpr bool operator==(const PRectangle &rc) const noexcept {
 		return (rc.left == left) && (rc.right == right) &&
 			(rc.top == top) && (rc.bottom == bottom);
 	}
-	bool Contains(Point pt) {
+	constexpr bool Contains(Point pt) const noexcept {
 		return (pt.x >= left) && (pt.x <= right) &&
 			(pt.y >= top) && (pt.y <= bottom);
 	}
-	bool Contains(PRectangle rc) {
+	constexpr bool ContainsWholePixel(Point pt) const noexcept {
+		// Does the rectangle contain all of the pixel to left/below the point
+		return (pt.x >= left) && ((pt.x+1) <= right) &&
+			(pt.y >= top) && ((pt.y+1) <= bottom);
+	}
+	constexpr bool Contains(PRectangle rc) const noexcept {
 		return (rc.left >= left) && (rc.right <= right) &&
 			(rc.top >= top) && (rc.bottom <= bottom);
 	}
-	bool Intersects(PRectangle other) {
+	constexpr bool Intersects(PRectangle other) const noexcept {
 		return (right > other.left) && (left < other.right) &&
 			(bottom > other.top) && (top < other.bottom);
 	}
-	void Move(int xDelta, int yDelta) {
+	void Move(XYPOSITION xDelta, XYPOSITION yDelta) noexcept {
 		left += xDelta;
 		top += yDelta;
 		right += xDelta;
 		bottom += yDelta;
 	}
-	int Width() { return right - left; }
-	int Height() { return bottom - top; }
-	bool Empty() {
+	constexpr XYPOSITION Width() const noexcept { return right - left; }
+	constexpr XYPOSITION Height() const noexcept { return bottom - top; }
+	constexpr bool Empty() const noexcept {
 		return (Height() <= 0) || (Width() <= 0);
 	}
 };
 
 /**
- * In some circumstances, including Win32 in paletted mode and GTK+, each colour
- * must be allocated before use. The desired colours are held in the ColourDesired class,
- * and after allocation the allocation entry is stored in the ColourAllocated class. In other
- * circumstances, such as Win32 in true colour mode, the allocation process just copies
- * the RGB values from the desired to the allocated class.
- * As each desired colour requires allocation before it can be used, the ColourPair class
- * holds both a ColourDesired and a ColourAllocated
- * The Palette class is responsible for managing the palette of colours which contains a
- * list of ColourPair objects and performs the allocation.
- */
-
-/**
- * Holds a desired RGB colour.
+ * Holds an RGB colour with 8 bits for each component.
  */
+constexpr const float componentMaximum = 255.0f;
 class ColourDesired {
-	long co;
+	int co;
 public:
-	ColourDesired(long lcol=0) {
-		co = lcol;
+	constexpr explicit ColourDesired(int co_=0) noexcept : co(co_) {
 	}
 
-	ColourDesired(unsigned int red, unsigned int green, unsigned int blue) {
-		Set(red, green, blue);
+	constexpr ColourDesired(unsigned int red, unsigned int green, unsigned int blue) noexcept :
+		co(red | (green << 8) | (blue << 16)) {
 	}
 
-	bool operator==(const ColourDesired &other) const {
+	constexpr bool operator==(const ColourDesired &other) const noexcept {
 		return co == other.co;
 	}
 
-	void Set(long lcol) {
-		co = lcol;
+	constexpr int AsInteger() const noexcept {
+		return co;
 	}
 
-	void Set(unsigned int red, unsigned int green, unsigned int blue) {
-		co = red | (green << 8) | (blue << 16);
+	// Red, green and blue values as bytes 0..255
+	constexpr unsigned char GetRed() const noexcept {
+		return co & 0xff;
 	}
-
-	static inline unsigned int ValueOfHex(const char ch) {
-		if (ch >= '0' && ch <= '9')
-			return ch - '0';
-		else if (ch >= 'A' && ch <= 'F')
-			return ch - 'A' + 10;
-		else if (ch >= 'a' && ch <= 'f')
-			return ch - 'a' + 10;
-		else
-			return 0;
+	constexpr unsigned char GetGreen() const noexcept {
+		return (co >> 8) & 0xff;
 	}
-
-	void Set(const char *val) {
-		if (*val == '#') {
-			val++;
-		}
-		unsigned int r = ValueOfHex(val[0]) * 16 + ValueOfHex(val[1]);
-		unsigned int g = ValueOfHex(val[2]) * 16 + ValueOfHex(val[3]);
-		unsigned int b = ValueOfHex(val[4]) * 16 + ValueOfHex(val[5]);
-		Set(r, g, b);
+	constexpr unsigned char GetBlue() const noexcept {
+		return (co >> 16) & 0xff;
 	}
 
-	long AsLong() const {
-		return co;
+	// Red, green and blue values as float 0..1.0
+	constexpr float GetRedComponent() const noexcept {
+		return GetRed() / componentMaximum;
+	}
+	constexpr float GetGreenComponent() const noexcept {
+		return GetGreen() / componentMaximum;
+	}
+	constexpr float GetBlueComponent() const noexcept {
+		return GetBlue() / componentMaximum;
 	}
+};
 
-	unsigned int GetRed() {
-		return co & 0xff;
+/**
+* Holds an RGBA colour.
+*/
+class ColourAlpha : public ColourDesired {
+public:
+	constexpr explicit ColourAlpha(int co_ = 0) noexcept : ColourDesired(co_) {
 	}
 
-	unsigned int GetGreen() {
-		return (co >> 8) & 0xff;
+	constexpr ColourAlpha(unsigned int red, unsigned int green, unsigned int blue) noexcept :
+		ColourDesired(red | (green << 8) | (blue << 16)) {
 	}
 
-	unsigned int GetBlue() {
-		return (co >> 16) & 0xff;
+	constexpr ColourAlpha(unsigned int red, unsigned int green, unsigned int blue, unsigned int alpha) noexcept :
+		ColourDesired(red | (green << 8) | (blue << 16) | (alpha << 24)) {
 	}
-};
 
-/**
- * Holds an allocated RGB colour which may be an approximation to the desired colour.
- */
-class ColourAllocated {
-	long coAllocated;
+	constexpr ColourAlpha(ColourDesired cd, unsigned int alpha) noexcept :
+		ColourDesired(cd.AsInteger() | (alpha << 24)) {
+	}
 
-public:
+	constexpr ColourDesired GetColour() const noexcept {
+		return ColourDesired(AsInteger() & 0xffffff);
+	}
 
-	ColourAllocated(long lcol=0) {
-		coAllocated = lcol;
+	constexpr unsigned char GetAlpha() const noexcept {
+		return (AsInteger() >> 24) & 0xff;
 	}
 
-	void Set(long lcol) {
-		coAllocated = lcol;
+	constexpr float GetAlphaComponent() const noexcept {
+		return GetAlpha() / componentMaximum;
 	}
 
-	long AsLong() const {
-		return coAllocated;
+	constexpr ColourAlpha MixedWith(ColourAlpha other) const noexcept {
+		const unsigned int red = (GetRed() + other.GetRed()) / 2;
+		const unsigned int green = (GetGreen() + other.GetGreen()) / 2;
+		const unsigned int blue = (GetBlue() + other.GetBlue()) / 2;
+		const unsigned int alpha = (GetAlpha() + other.GetAlpha()) / 2;
+		return ColourAlpha(red, green, blue, alpha);
 	}
 };
 
 /**
- * Colour pairs hold a desired colour and an allocated colour.
- */
-struct ColourPair {
-	ColourDesired desired;
-	ColourAllocated allocated;
-
-	ColourPair(ColourDesired desired_=ColourDesired(0,0,0)) {
-		desired = desired_;
-		allocated.Set(desired.AsLong());
-	}
-	void Copy() {
-		allocated.Set(desired.AsLong());
+* Holds an element of a gradient with an RGBA colour and a relative position.
+*/
+class ColourStop {
+public:
+	float position;
+	ColourAlpha colour;
+	ColourStop(float position_, ColourAlpha colour_) noexcept :
+		position(position_), colour(colour_) {
 	}
 };
 
-class Window;	// Forward declaration for Palette
-
 /**
- * Colour palette management.
+ * Font management.
  */
-class Palette {
-	int used;
-	int size;
-	ColourPair *entries;
-#if PLAT_GTK
-	void *allocatedPalette; // GdkColor *
-	int allocatedLen;
-#endif
-	// Private so Palette objects can not be copied
-	Palette(const Palette &) {}
-	Palette &operator=(const Palette &) { return *this; }
-public:
-#if PLAT_WIN
-	void *hpal;
-#endif
-	bool allowRealization;
-
-	Palette();
-	~Palette();
-
-	void Release();
 
-	/**
-	 * This method either adds a colour to the list of wanted colours (want==true)
-	 * or retrieves the allocated colour back to the ColourPair.
-	 * This is one method to make it easier to keep the code for wanting and retrieving in sync.
-	 */
-	void WantFind(ColourPair &cp, bool want);
+struct FontParameters {
+	const char *faceName;
+	float size;
+	int weight;
+	bool italic;
+	int extraFontFlag;
+	int technology;
+	int characterSet;
+
+	FontParameters(
+		const char *faceName_,
+		float size_=10,
+		int weight_=400,
+		bool italic_=false,
+		int extraFontFlag_=0,
+		int technology_=0,
+		int characterSet_=0) noexcept :
+
+		faceName(faceName_),
+		size(size_),
+		weight(weight_),
+		italic(italic_),
+		extraFontFlag(extraFontFlag_),
+		technology(technology_),
+		characterSet(characterSet_)
+	{
+	}
 
-	void Allocate(Window &w);
 };
 
-/**
- * Font management.
- */
 class Font {
 protected:
-	FontID id;
-#if PLAT_WX
-	int ascent;
-#endif
-	// Private so Font objects can not be copied
-	Font(const Font &) {}
-	Font &operator=(const Font &) { id=0; return *this; }
+	FontID fid;
 public:
-	Font();
+	Font() noexcept;
+	// Deleted so Font objects can not be copied
+	Font(const Font &) = delete;
+	Font(Font &&) = delete;
+	Font &operator=(const Font &) = delete;
+	Font &operator=(Font &&) = delete;
 	virtual ~Font();
 
-	virtual void Create(const char *faceName, int characterSet, int size,
-		bool bold, bool italic, bool extraFontFlag=false);
+	virtual void Create(const FontParameters &fp);
 	virtual void Release();
 
-	FontID GetID() { return id; }
+	FontID GetID() const noexcept { return fid; }
 	// Alias another font - caller guarantees not to Release
-	void SetID(FontID id_) { id = id_; }
+	void SetID(FontID fid_) noexcept { fid = fid_; }
 	friend class Surface;
-        friend class SurfaceImpl;
+	friend class SurfaceImpl;
+};
+
+class IScreenLine {
+public:
+	virtual std::string_view Text() const = 0;
+	virtual size_t Length() const = 0;
+	virtual size_t RepresentationCount() const = 0;
+	virtual XYPOSITION Width() const = 0;
+	virtual XYPOSITION Height() const = 0;
+	virtual XYPOSITION TabWidth() const = 0;
+	virtual XYPOSITION TabWidthMinimumPixels() const = 0;
+	virtual const Font *FontOfPosition(size_t position) const = 0;
+	virtual XYPOSITION RepresentationWidth(size_t position) const = 0;
+	virtual XYPOSITION TabPositionAfter(XYPOSITION xPosition) const = 0;
+};
+
+struct Interval {
+	XYPOSITION left;
+	XYPOSITION right;
+};
+
+class IScreenLineLayout {
+public:
+	virtual ~IScreenLineLayout() = default;
+	virtual size_t PositionFromX(XYPOSITION xDistance, bool charPosition) = 0;
+	virtual XYPOSITION XFromPosition(size_t caretPosition) = 0;
+	virtual std::vector<Interval> FindRangeIntervals(size_t start, size_t end) = 0;
 };
 
 /**
  * A surface abstracts a place to draw.
  */
 class Surface {
-private:
-	// Private so Surface objects can not be copied
-	Surface(const Surface &) {}
-	Surface &operator=(const Surface &) { return *this; }
 public:
-	Surface() {};
-	virtual ~Surface() {};
-	static Surface *Allocate();
+	Surface() noexcept = default;
+	Surface(const Surface &) = delete;
+	Surface(Surface &&) = delete;
+	Surface &operator=(const Surface &) = delete;
+	Surface &operator=(Surface &&) = delete;
+	virtual ~Surface() {}
+	static Surface *Allocate(int technology);
 
 	virtual void Init(WindowID wid)=0;
 	virtual void Init(SurfaceID sid, WindowID wid)=0;
@@ -323,96 +380,79 @@ class Surface {
 
 	virtual void Release()=0;
 	virtual bool Initialised()=0;
-	virtual void PenColour(ColourAllocated fore)=0;
+	virtual void PenColour(ColourDesired fore)=0;
 	virtual int LogPixelsY()=0;
 	virtual int DeviceHeightFont(int points)=0;
 	virtual void MoveTo(int x_, int y_)=0;
 	virtual void LineTo(int x_, int y_)=0;
-	virtual void Polygon(Point *pts, int npts, ColourAllocated fore, ColourAllocated back)=0;
-	virtual void RectangleDraw(PRectangle rc, ColourAllocated fore, ColourAllocated back)=0;
-	virtual void FillRectangle(PRectangle rc, ColourAllocated back)=0;
+	virtual void Polygon(Point *pts, size_t npts, ColourDesired fore, ColourDesired back)=0;
+	virtual void RectangleDraw(PRectangle rc, ColourDesired fore, ColourDesired back)=0;
+	virtual void FillRectangle(PRectangle rc, ColourDesired back)=0;
 	virtual void FillRectangle(PRectangle rc, Surface &surfacePattern)=0;
-	virtual void RoundedRectangle(PRectangle rc, ColourAllocated fore, ColourAllocated back)=0;
-	virtual void AlphaRectangle(PRectangle rc, int cornerSize, ColourAllocated fill, int alphaFill,
-		ColourAllocated outline, int alphaOutline, int flags)=0;
-	virtual void Ellipse(PRectangle rc, ColourAllocated fore, ColourAllocated back)=0;
+	virtual void RoundedRectangle(PRectangle rc, ColourDesired fore, ColourDesired back)=0;
+	virtual void AlphaRectangle(PRectangle rc, int cornerSize, ColourDesired fill, int alphaFill,
+		ColourDesired outline, int alphaOutline, int flags)=0;
+	enum class GradientOptions { leftToRight, topToBottom };
+	virtual void GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options)=0;
+	virtual void DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) = 0;
+	virtual void Ellipse(PRectangle rc, ColourDesired fore, ColourDesired back)=0;
 	virtual void Copy(PRectangle rc, Point from, Surface &surfaceSource)=0;
 
-	virtual void DrawTextNoClip(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore, ColourAllocated back)=0;
-	virtual void DrawTextClipped(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore, ColourAllocated back)=0;
-	virtual void DrawTextTransparent(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore)=0;
-	virtual void MeasureWidths(Font &font_, const char *s, int len, int *positions)=0;
-	virtual int WidthText(Font &font_, const char *s, int len)=0;
-	virtual int WidthChar(Font &font_, char ch)=0;
-	virtual int Ascent(Font &font_)=0;
-	virtual int Descent(Font &font_)=0;
-	virtual int InternalLeading(Font &font_)=0;
-	virtual int ExternalLeading(Font &font_)=0;
-	virtual int Height(Font &font_)=0;
-	virtual int AverageCharWidth(Font &font_)=0;
-
-	virtual int SetPalette(Palette *pal, bool inBackGround)=0;
+	virtual std::unique_ptr<IScreenLineLayout> Layout(const IScreenLine *screenLine) = 0;
+
+	virtual void DrawTextNoClip(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text, ColourDesired fore, ColourDesired back) = 0;
+	virtual void DrawTextClipped(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text, ColourDesired fore, ColourDesired back) = 0;
+	virtual void DrawTextTransparent(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text, ColourDesired fore) = 0;
+	virtual void MeasureWidths(Font &font_, std::string_view text, XYPOSITION *positions) = 0;
+	virtual XYPOSITION WidthText(Font &font_, std::string_view text) = 0;
+	virtual XYPOSITION Ascent(Font &font_)=0;
+	virtual XYPOSITION Descent(Font &font_)=0;
+	virtual XYPOSITION InternalLeading(Font &font_)=0;
+	virtual XYPOSITION Height(Font &font_)=0;
+	virtual XYPOSITION AverageCharWidth(Font &font_)=0;
+
 	virtual void SetClip(PRectangle rc)=0;
 	virtual void FlushCachedState()=0;
 
 	virtual void SetUnicodeMode(bool unicodeMode_)=0;
 	virtual void SetDBCSMode(int codePage)=0;
+	virtual void SetBidiR2L(bool bidiR2L_)=0;
 };
 
-/**
- * A simple callback action passing one piece of untyped user data.
- */
-typedef void (*CallBackAction)(void*);
-
 /**
  * Class to hide the details of window manipulation.
  * Does not own the window which will normally have a longer life than this object.
  */
 class Window {
 protected:
-	WindowID id;
-#if PLAT_MACOSX
-	void *windowRef;
-	void *control;
-#endif
+	WindowID wid;
 public:
-	Window() : id(0), cursorLast(cursorInvalid) {
-#if PLAT_MACOSX
-	  windowRef = 0;
-	  control = 0;
-#endif
+	Window() noexcept : wid(nullptr), cursorLast(cursorInvalid) {
 	}
-	Window(const Window &source) : id(source.id), cursorLast(cursorInvalid) {
-#if PLAT_MACOSX
-	  windowRef = 0;
-	  control = 0;
-#endif
-	}
-	virtual ~Window();
-	Window &operator=(WindowID id_) {
-		id = id_;
+	Window(const Window &source) = delete;
+	Window(Window &&) = delete;
+	Window &operator=(WindowID wid_) noexcept {
+		wid = wid_;
+		cursorLast = cursorInvalid;
 		return *this;
 	}
-	WindowID GetID() const { return id; }
-	bool Created() const { return id != 0; }
+	Window &operator=(const Window &) = delete;
+	Window &operator=(Window &&) = delete;
+	virtual ~Window();
+	WindowID GetID() const noexcept { return wid; }
+	bool Created() const noexcept { return wid != nullptr; }
 	void Destroy();
-	bool HasFocus();
-	PRectangle GetPosition();
+	PRectangle GetPosition() const;
 	void SetPosition(PRectangle rc);
-	void SetPositionRelative(PRectangle rc, Window relativeTo);
-	PRectangle GetClientPosition();
+	void SetPositionRelative(PRectangle rc, const Window *relativeTo);
+	PRectangle GetClientPosition() const;
 	void Show(bool show=true);
 	void InvalidateAll();
 	void InvalidateRectangle(PRectangle rc);
 	virtual void SetFont(Font &font);
 	enum Cursor { cursorInvalid, cursorText, cursorArrow, cursorUp, cursorWait, cursorHoriz, cursorVert, cursorReverseArrow, cursorHand };
 	void SetCursor(Cursor curs);
-	void SetTitle(const char *s);
 	PRectangle GetMonitorRect(Point pt);
-#if PLAT_MACOSX
-	void SetWindow(void *ref) { windowRef = ref; };
-	void SetControl(void *_control) { control = _control; };
-#endif
 private:
 	Cursor cursorLast;
 };
@@ -421,14 +461,27 @@ class Window {
  * Listbox management.
  */
 
+// ScintillaBase implements IListBoxDelegate to receive ListBoxEvents from a ListBox
+
+struct ListBoxEvent {
+	enum class EventType { selectionChange, doubleClick } event;
+	ListBoxEvent(EventType event_) noexcept : event(event_) {
+	}
+};
+
+class IListBoxDelegate {
+public:
+	virtual void ListNotify(ListBoxEvent *plbe)=0;
+};
+
 class ListBox : public Window {
 public:
-	ListBox();
-	virtual ~ListBox();
+	ListBox() noexcept;
+	~ListBox() override;
 	static ListBox *Allocate();
 
-	virtual void SetFont(Font &font)=0;
-	virtual void Create(Window &parent, int ctrlID, Point location, int lineHeight_, bool unicodeMode_)=0;
+	void SetFont(Font &font) override =0;
+	virtual void Create(Window &parent, int ctrlID, Point location, int lineHeight_, bool unicodeMode_, int technology_)=0;
 	virtual void SetAverageCharWidth(int width)=0;
 	virtual void SetVisibleRows(int rows)=0;
 	virtual int GetVisibleRows() const=0;
@@ -442,8 +495,9 @@ class ListBox : public Window {
 	virtual int Find(const char *prefix)=0;
 	virtual void GetValue(int n, char *value, int len)=0;
 	virtual void RegisterImage(int type, const char *xpm_data)=0;
+	virtual void RegisterRGBAImage(int type, int width, int height, const unsigned char *pixelsImage) = 0;
 	virtual void ClearRegisteredImages()=0;
-	virtual void SetDoubleClickAction(CallBackAction, void *)=0;
+	virtual void SetDelegate(IListBoxDelegate *lbDelegate)=0;
 	virtual void SetList(const char* list, char separator, char typesep)=0;
 };
 
@@ -451,29 +505,21 @@ class ListBox : public Window {
  * Menu management.
  */
 class Menu {
-	MenuID id;
+	MenuID mid;
 public:
-	Menu();
-	MenuID GetID() { return id; }
+	Menu() noexcept;
+	MenuID GetID() const noexcept { return mid; }
 	void CreatePopUp();
 	void Destroy();
 	void Show(Point pt, Window &w);
 };
 
-class ElapsedTime {
-	long bigBit;
-	long littleBit;
-public:
-	ElapsedTime();
-	double Duration(bool reset=false);
-};
-
 /**
  * Dynamic Library (DLL/SO/...) loading
  */
 class DynamicLibrary {
 public:
-	virtual ~DynamicLibrary() {};
+	virtual ~DynamicLibrary() = default;
 
 	/// @return Pointer to function "name", or NULL on failure.
 	virtual Function FindFunction(const char *name) = 0;
@@ -485,71 +531,49 @@ class DynamicLibrary {
 	static DynamicLibrary *Load(const char *modulePath);
 };
 
+#if defined(__clang__)
+# if __has_feature(attribute_analyzer_noreturn)
+#  define CLANG_ANALYZER_NORETURN __attribute__((analyzer_noreturn))
+# else
+#  define CLANG_ANALYZER_NORETURN
+# endif
+#else
+# define CLANG_ANALYZER_NORETURN
+#endif
+
 /**
  * Platform class used to retrieve system wide parameters such as double click speed
  * and chrome colour. Not a creatable object, more of a module with several functions.
  */
 class Platform {
-	// Private so Platform objects can not be copied
-	Platform(const Platform &) {}
-	Platform &operator=(const Platform &) { return *this; }
 public:
-	// Should be private because no new Platforms are ever created
-	// but gcc warns about this
-	Platform() {}
-	~Platform() {}
+	Platform() = default;
+	Platform(const Platform &) = delete;
+	Platform(Platform &&) = delete;
+	Platform &operator=(const Platform &) = delete;
+	Platform &operator=(Platform &&) = delete;
+	~Platform() = default;
 	static ColourDesired Chrome();
 	static ColourDesired ChromeHighlight();
 	static const char *DefaultFont();
 	static int DefaultFontSize();
 	static unsigned int DoubleClickTime();
-	static bool MouseButtonBounce();
 	static void DebugDisplay(const char *s);
-	static bool IsKeyDown(int key);
-	static long SendScintilla(
-		WindowID w, unsigned int msg, unsigned long wParam=0, long lParam=0);
-	static long SendScintillaPointer(
-		WindowID w, unsigned int msg, unsigned long wParam=0, void *lParam=0);
-	static bool IsDBCSLeadByte(int codePage, char ch);
-	static int DBCSCharLength(int codePage, const char *s);
-	static int DBCSCharMaxLength();
-
-	// These are utility functions not really tied to a platform
-	static int Minimum(int a, int b);
-	static int Maximum(int a, int b);
-	// Next three assume 16 bit shorts and 32 bit longs
-	static long LongFromTwoShorts(short a,short b) {
+	static constexpr long LongFromTwoShorts(short a,short b) noexcept {
 		return (a) | ((b) << 16);
 	}
-	static short HighShortFromLong(long x) {
-		return static_cast<short>(x >> 16);
-	}
-	static short LowShortFromLong(long x) {
-		return static_cast<short>(x & 0xffff);
-	}
+
 	static void DebugPrintf(const char *format, ...);
 	static bool ShowAssertionPopUps(bool assertionPopUps_);
-	static void Assert(const char *c, const char *file, int line);
-	static int Clamp(int val, int minVal, int maxVal);
+	static void Assert(const char *c, const char *file, int line) CLANG_ANALYZER_NORETURN;
 };
 
 #ifdef  NDEBUG
 #define PLATFORM_ASSERT(c) ((void)0)
 #else
-#ifdef SCI_NAMESPACE
 #define PLATFORM_ASSERT(c) ((c) ? (void)(0) : Scintilla::Platform::Assert(#c, __FILE__, __LINE__))
-#else
-#define PLATFORM_ASSERT(c) ((c) ? (void)(0) : Platform::Assert(#c, __FILE__, __LINE__))
-#endif
 #endif
 
-#ifdef SCI_NAMESPACE
 }
-#endif
-
-// Shut up annoying Visual C++ warnings:
-#ifdef _MSC_VER
-#pragma warning(disable: 4244 4309 4514 4710)
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/include/PropSet.h b/Pythonwin/Scintilla/include/PropSet.h
deleted file mode 100644
index 91bc7072b..000000000
--- a/Pythonwin/Scintilla/include/PropSet.h
+++ /dev/null
@@ -1,104 +0,0 @@
-// Scintilla source code edit control
-/** @file PropSet.h
- ** A Java style properties file module.
- **/
-// Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#ifndef PROPSET_H
-#define PROPSET_H
-#include "SString.h"
-
-bool EqualCaseInsensitive(const char *a, const char *b);
-
-bool isprefix(const char *target, const char *prefix);
-
-#ifdef SCI_NAMESPACE
-namespace Scintilla {
-#endif
-
-struct Property {
-	unsigned int hash;
-	char *key;
-	char *val;
-	Property *next;
-	Property() : hash(0), key(0), val(0), next(0) {}
-};
-
-/**
- */
-class PropSet {
-protected:
-	enum { hashRoots=31 };
-	Property *props[hashRoots];
-	Property *enumnext;
-	int enumhash;
-	static unsigned int HashString(const char *s, size_t len) {
-		unsigned int ret = 0;
-		while (len--) {
-			ret <<= 4;
-			ret ^= *s;
-			s++;
-		}
-		return ret;
-	}
-
-public:
-	PropSet *superPS;
-	PropSet();
-	~PropSet();
-	void Set(const char *key, const char *val, int lenKey=-1, int lenVal=-1);
-	void Set(const char *keyVal);
-	void Unset(const char *key, int lenKey=-1);
-	void SetMultiple(const char *s);
-	SString Get(const char *key) const;
-	SString GetExpanded(const char *key) const;
-	SString Expand(const char *withVars, int maxExpands=100) const;
-	int GetInt(const char *key, int defaultValue=0) const;
-	void Clear();
-	char *ToString() const;	// Caller must delete[] the return value
-
-private:
-	// copy-value semantics not implemented
-	PropSet(const PropSet &copy);
-	void operator=(const PropSet &assign);
-};
-
-/**
- */
-class WordList {
-public:
-	// Each word contains at least one character - a empty word acts as sentinel at the end.
-	char **words;
-	char *list;
-	int len;
-	bool onlyLineEnds;	///< Delimited by any white space or only line ends
-	bool sorted;
-	int starts[256];
-	WordList(bool onlyLineEnds_ = false) :
-		words(0), list(0), len(0), onlyLineEnds(onlyLineEnds_),
-		sorted(false)
-		{}
-	~WordList() { Clear(); }
-	operator bool() { return len ? true : false; }
-	void Clear();
-	void Set(const char *s);
-	bool InList(const char *s);
-	bool InListAbbreviated(const char *s, const char marker);
-};
-
-inline bool IsAlphabetic(unsigned int ch) {
-	return ((ch >= 'A') && (ch <= 'Z')) || ((ch >= 'a') && (ch <= 'z'));
-}
-
-#ifdef SCI_NAMESPACE
-}
-#endif
-
-#ifdef _MSC_VER
-// Visual C++ doesn't like the private copy idiom for disabling
-// the default copy constructor and operator=, but it's fine.
-#pragma warning(disable: 4511 4512)
-#endif
-
-#endif
diff --git a/Pythonwin/Scintilla/include/SString.h b/Pythonwin/Scintilla/include/SString.h
deleted file mode 100644
index b770afebe..000000000
--- a/Pythonwin/Scintilla/include/SString.h
+++ /dev/null
@@ -1,289 +0,0 @@
-// SciTE - Scintilla based Text Editor
-/** @file SString.h
- ** A simple string class.
- **/
-// Copyright 1998-2004 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#ifndef SSTRING_H
-#define SSTRING_H
-
-
-// These functions are implemented because each platform calls them something different.
-int CompareCaseInsensitive(const char *a, const char *b);
-int CompareNCaseInsensitive(const char *a, const char *b, size_t len);
-bool EqualCaseInsensitive(const char *a, const char *b);
-
-#ifdef SCI_NAMESPACE
-namespace Scintilla {
-#endif
-
-// Define another string class.
-// While it would be 'better' to use std::string, that doubles the executable size.
-// An SString may contain embedded nul characters.
-
-/**
- * Base class from which the two other classes (SBuffer & SString)
- * are derived.
- */
-class SContainer {
-public:
-	/** Type of string lengths (sizes) and positions (indexes). */
-	typedef size_t lenpos_t;
-	/** Out of bounds value indicating that the string argument should be measured. */
-	enum { measure_length=0xffffffffU};
-
-protected:
-	char *s;				///< The C string
-	lenpos_t sSize;			///< The size of the buffer, less 1: ie. the maximum size of the string
-
-	SContainer() : s(0), sSize(0) {}
-	~SContainer() {
-		delete []s;	// Suppose it was allocated using StringAllocate
-		s = 0;
-		sSize = 0;
-	}
-	/** Size of buffer. */
-	lenpos_t size() const {
-		if (s) {
-			return sSize;
-		} else {
-			return 0;
-		}
-	}
-public:
-	/**
-	 * Allocate uninitialized memory big enough to fit a string of the given length.
-	 * @return the pointer to the new string
-	 */
-	static char *StringAllocate(lenpos_t len);
-	/**
-	 * Duplicate a buffer/C string.
-	 * Allocate memory of the given size, or big enough to fit the string if length isn't given;
-	 * then copy the given string in the allocated memory.
-	 * @return the pointer to the new string
-	 */
-	static char *StringAllocate(
-		const char *s,			///< The string to duplicate
-		lenpos_t len=measure_length);	///< The length of memory to allocate. Optional.
-};
-
-
-/**
- * @brief A string buffer class.
- *
- * Main use is to ask an API the length of a string it can provide,
- * then to allocate a buffer of the given size, and to provide this buffer
- * to the API to put the string.
- * This class is intended to be shortlived, to be transformed as SString
- * as soon as it holds the string, so it has little members.
- * Note: we assume the buffer is filled by the API. If the length can be shorter,
- * we should set sLen to strlen(sb.ptr()) in related SString constructor and assignment.
- */
-class SBuffer : protected SContainer {
-public:
-	SBuffer(lenpos_t len) {
-		s = StringAllocate(len);
-		if (s) {
-			*s = '\0';
-		sSize = len;
-		} else {
-			sSize = 0;
-		}
-	}
-private:
-	/// Copy constructor
-	// Here only to be on the safe size, user should avoid returning SBuffer values.
-	SBuffer(const SBuffer &source) : SContainer() {
-		s = StringAllocate(source.s, source.sSize);
-		sSize = (s) ? source.sSize : 0;
-	}
-	/// Default assignment operator
-	// Same here, shouldn't be used
-	SBuffer &operator=(const SBuffer &source) {
-		if (this != &source) {
-			delete []s;
-			s = StringAllocate(source.s, source.sSize);
-			sSize = (s) ? source.sSize : 0;
-		}
-		return *this;
-	}
-public:
-	/** Provide direct read/write access to buffer. */
-	char *ptr() {
-	    return s;
-	}
-	/** Ownership of the buffer have been taken, so release it. */
-	void reset() {
-		s = 0;
-		sSize = 0;
-	}
-	/** Size of buffer. */
-	lenpos_t size() const {
-		return SContainer::size();
-	}
-};
-
-
-/**
- * @brief A simple string class.
- *
- * Hold the length of the string for quick operations,
- * can have a buffer bigger than the string to avoid too many memory allocations and copies.
- * May have embedded zeroes as a result of @a substitute, but relies too heavily on C string
- * functions to allow reliable manipulations of these strings, other than simple appends, etc.
- */
-class SString : protected SContainer {
-	lenpos_t sLen;			///< The size of the string in s
-	lenpos_t sizeGrowth;	///< Minimum growth size when appending strings
-	enum { sizeGrowthDefault = 64 };
-
-	bool grow(lenpos_t lenNew);
-	SString &assign(const char *sOther, lenpos_t sSize_=measure_length);
-
-public:
-	SString() : sLen(0), sizeGrowth(sizeGrowthDefault) {}
-	SString(const SString &source) : SContainer(), sizeGrowth(sizeGrowthDefault) {
-		s = StringAllocate(source.s, source.sLen);
-		sSize = sLen = (s) ? source.sLen : 0;
-	}
-	SString(const char *s_) : sizeGrowth(sizeGrowthDefault) {
-		s = StringAllocate(s_);
-		sSize = sLen = (s) ? strlen(s) : 0;
-	}
-	SString(SBuffer &buf) : sizeGrowth(sizeGrowthDefault) {
-		s = buf.ptr();
-		sSize = sLen = buf.size();
-		// Consumes the given buffer!
-		buf.reset();
-	}
-	SString(const char *s_, lenpos_t first, lenpos_t last) : sizeGrowth(sizeGrowthDefault) {
-		// note: expects the "last" argument to point one beyond the range end (a la STL iterators)
-		s = StringAllocate(s_ + first, last - first);
-		sSize = sLen = (s) ? last - first : 0;
-	}
-	SString(int i);
-	SString(double d, int precision);
-	~SString() {
-		sLen = 0;
-	}
-	void clear() {
-		if (s) {
-			*s = '\0';
-		}
-		sLen = 0;
-	}
-	/** Size of buffer. */
-	lenpos_t size() const {
-		return SContainer::size();
-	}
-	/** Size of string in buffer. */
-	lenpos_t length() const {
-		return sLen;
-	}
-	/** Read access to a character of the string. */
-	char operator[](lenpos_t i) const {
-		return (s && i < sSize) ? s[i] : '\0';
-	}
-	SString &operator=(const char *source) {
-		return assign(source);
-	}
-	SString &operator=(const SString &source) {
-		if (this != &source) {
-			assign(source.s, source.sLen);
-		}
-		return *this;
-	}
-	bool operator==(const SString &sOther) const;
-	bool operator!=(const SString &sOther) const {
-		return !operator==(sOther);
-	}
-	bool operator==(const char *sOther) const;
-	bool operator!=(const char *sOther) const {
-		return !operator==(sOther);
-	}
-	bool contains(char ch) const {
-		return (s && *s) ? strchr(s, ch) != 0 : false;
-	}
-	void setsizegrowth(lenpos_t sizeGrowth_) {
-		sizeGrowth = sizeGrowth_;
-	}
-	const char *c_str() const {
-		return s ? s : "";
-	}
-	/** Give ownership of buffer to caller which must use delete[] to free buffer. */
-	char *detach() {
-		char *sRet = s;
-		s = 0;
-		sSize = 0;
-		sLen = 0;
-		return sRet;
-	}
-	SString substr(lenpos_t subPos, lenpos_t subLen=measure_length) const;
-	SString &lowercase(lenpos_t subPos = 0, lenpos_t subLen=measure_length);
-	SString &uppercase(lenpos_t subPos = 0, lenpos_t subLen=measure_length);
-	SString &append(const char *sOther, lenpos_t sLenOther=measure_length, char sep = '\0');
-	SString &operator+=(const char *sOther) {
-		return append(sOther, static_cast<lenpos_t>(measure_length));
-	}
-	SString &operator+=(const SString &sOther) {
-		return append(sOther.s, sOther.sLen);
-	}
-	SString &operator+=(char ch) {
-		return append(&ch, 1);
-	}
-	SString &appendwithseparator(const char *sOther, char sep) {
-		return append(sOther, strlen(sOther), sep);
-	}
-	SString &insert(lenpos_t pos, const char *sOther, lenpos_t sLenOther=measure_length);
-
-	/**
-	 * Remove @a len characters from the @a pos position, included.
-	 * Characters at pos + len and beyond replace characters at pos.
-	 * If @a len is 0, or greater than the length of the string
-	 * starting at @a pos, the string is just truncated at @a pos.
-	 */
-	void remove(lenpos_t pos, lenpos_t len);
-
-	SString &change(lenpos_t pos, char ch) {
-		if (pos < sLen) {					// character changed must be in string bounds
-			*(s + pos) = ch;
-		}
-		return *this;
-	}
-	/** Read an integral numeric value from the string. */
-	int value() const {
-		return s ? atoi(s) : 0;
-	}
-	bool startswith(const char *prefix);
-	bool endswith(const char *suffix);
-	int search(const char *sFind, lenpos_t start=0) const;
-	bool contains(const char *sFind) const {
-		return search(sFind) >= 0;
-	}
-	int substitute(char chFind, char chReplace);
-	int substitute(const char *sFind, const char *sReplace);
-	int remove(const char *sFind) {
-		return substitute(sFind, "");
-	}
-};
-
-
-/**
- * Duplicate a C string.
- * Allocate memory of the given size, or big enough to fit the string if length isn't given;
- * then copy the given string in the allocated memory.
- * @return the pointer to the new string
- */
-inline char *StringDup(
-	const char *s,			///< The string to duplicate
-	SContainer::lenpos_t len=SContainer::measure_length)	///< The length of memory to allocate. Optional.
-{
-	return SContainer::StringAllocate(s, len);
-}
-
-#ifdef SCI_NAMESPACE
-}
-#endif
-
-#endif
diff --git a/Pythonwin/Scintilla/include/SciLexer.h b/Pythonwin/Scintilla/include/SciLexer.h
index defd72cfa..d23e18e0c 100644
--- a/Pythonwin/Scintilla/include/SciLexer.h
+++ b/Pythonwin/Scintilla/include/SciLexer.h
@@ -1,19 +1,19 @@
-// Scintilla source code edit control
+/* Scintilla source code edit control */
 /** @file SciLexer.h
  ** Interface to the added lexer functions in the SciLexer version of the edit control.
  **/
-// Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
+/* Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
+ * The License.txt file describes the conditions under which this software may be distributed. */
 
-// Most of this file is automatically generated from the Scintilla.iface interface definition
-// file which contains any comments about the definitions. HFacer.py does the generation.
+/* Most of this file is automatically generated from the Scintilla.iface interface definition
+ * file which contains any comments about the definitions. HFacer.py does the generation. */
 
 #ifndef SCILEXER_H
 #define SCILEXER_H
 
-// SciLexer features - not in standard Scintilla
+/* SciLexer features - not in standard Scintilla */
 
-//++Autogenerated -- start of section automatically generated from Scintilla.iface
+/* ++Autogenerated -- start of section automatically generated from Scintilla.iface */
 #define SCLEX_CONTAINER 0
 #define SCLEX_NULL 1
 #define SCLEX_PYTHON 2
@@ -103,6 +103,47 @@
 #define SCLEX_POWERSHELL 88
 #define SCLEX_MYSQL 89
 #define SCLEX_PO 90
+#define SCLEX_TAL 91
+#define SCLEX_COBOL 92
+#define SCLEX_TACL 93
+#define SCLEX_SORCUS 94
+#define SCLEX_POWERPRO 95
+#define SCLEX_NIMROD 96
+#define SCLEX_SML 97
+#define SCLEX_MARKDOWN 98
+#define SCLEX_TXT2TAGS 99
+#define SCLEX_A68K 100
+#define SCLEX_MODULA 101
+#define SCLEX_COFFEESCRIPT 102
+#define SCLEX_TCMD 103
+#define SCLEX_AVS 104
+#define SCLEX_ECL 105
+#define SCLEX_OSCRIPT 106
+#define SCLEX_VISUALPROLOG 107
+#define SCLEX_LITERATEHASKELL 108
+#define SCLEX_STTXT 109
+#define SCLEX_KVIRC 110
+#define SCLEX_RUST 111
+#define SCLEX_DMAP 112
+#define SCLEX_AS 113
+#define SCLEX_DMIS 114
+#define SCLEX_REGISTRY 115
+#define SCLEX_BIBTEX 116
+#define SCLEX_SREC 117
+#define SCLEX_IHEX 118
+#define SCLEX_TEHEX 119
+#define SCLEX_JSON 120
+#define SCLEX_EDIFACT 121
+#define SCLEX_INDENT 122
+#define SCLEX_MAXIMA 123
+#define SCLEX_STATA 124
+#define SCLEX_SAS 125
+#define SCLEX_NIM 126
+#define SCLEX_CIL 127
+#define SCLEX_X12 128
+#define SCLEX_DATAFLEX 129
+#define SCLEX_HOLLYWOOD 130
+#define SCLEX_RAKU 131
 #define SCLEX_AUTOMATIC 1000
 #define SCE_P_DEFAULT 0
 #define SCE_P_COMMENTLINE 1
@@ -120,6 +161,10 @@
 #define SCE_P_STRINGEOL 13
 #define SCE_P_WORD2 14
 #define SCE_P_DECORATOR 15
+#define SCE_P_FSTRING 16
+#define SCE_P_FCHARACTER 17
+#define SCE_P_FTRIPLE 18
+#define SCE_P_FTRIPLEDOUBLE 19
 #define SCE_C_DEFAULT 0
 #define SCE_C_COMMENT 1
 #define SCE_C_COMMENTLINE 2
@@ -140,6 +185,14 @@
 #define SCE_C_COMMENTDOCKEYWORD 17
 #define SCE_C_COMMENTDOCKEYWORDERROR 18
 #define SCE_C_GLOBALCLASS 19
+#define SCE_C_STRINGRAW 20
+#define SCE_C_TRIPLEVERBATIM 21
+#define SCE_C_HASHQUOTEDSTRING 22
+#define SCE_C_PREPROCESSORCOMMENT 23
+#define SCE_C_PREPROCESSORCOMMENTDOC 24
+#define SCE_C_USERLITERAL 25
+#define SCE_C_TASKMARKER 26
+#define SCE_C_ESCAPESEQUENCE 27
 #define SCE_D_DEFAULT 0
 #define SCE_D_COMMENT 1
 #define SCE_D_COMMENTLINE 2
@@ -158,6 +211,11 @@
 #define SCE_D_COMMENTLINEDOC 15
 #define SCE_D_COMMENTDOCKEYWORD 16
 #define SCE_D_COMMENTDOCKEYWORDERROR 17
+#define SCE_D_STRINGB 18
+#define SCE_D_STRINGR 19
+#define SCE_D_WORD5 20
+#define SCE_D_WORD6 21
+#define SCE_D_WORD7 22
 #define SCE_TCL_DEFAULT 0
 #define SCE_TCL_COMMENT 1
 #define SCE_TCL_COMMENTLINE 2
@@ -326,6 +384,16 @@
 #define SCE_PL_SUB_PROTOTYPE 40
 #define SCE_PL_FORMAT_IDENT 41
 #define SCE_PL_FORMAT 42
+#define SCE_PL_STRING_VAR 43
+#define SCE_PL_XLAT 44
+#define SCE_PL_REGEX_VAR 54
+#define SCE_PL_REGSUBST_VAR 55
+#define SCE_PL_BACKTICKS_VAR 57
+#define SCE_PL_HERE_QQ_VAR 61
+#define SCE_PL_HERE_QX_VAR 62
+#define SCE_PL_STRING_QQ_VAR 64
+#define SCE_PL_STRING_QX_VAR 65
+#define SCE_PL_STRING_QR_VAR 66
 #define SCE_RB_DEFAULT 0
 #define SCE_RB_ERROR 1
 #define SCE_RB_COMMENTLINE 2
@@ -379,6 +447,10 @@
 #define SCE_B_ERROR 16
 #define SCE_B_HEXNUMBER 17
 #define SCE_B_BINNUMBER 18
+#define SCE_B_COMMENTBLOCK 19
+#define SCE_B_DOCLINE 20
+#define SCE_B_DOCBLOCK 21
+#define SCE_B_DOCKEYWORD 22
 #define SCE_PROPS_DEFAULT 0
 #define SCE_PROPS_COMMENT 1
 #define SCE_PROPS_SECTION 2
@@ -390,6 +462,14 @@
 #define SCE_L_TAG 2
 #define SCE_L_MATH 3
 #define SCE_L_COMMENT 4
+#define SCE_L_TAG2 5
+#define SCE_L_MATH2 6
+#define SCE_L_COMMENT2 7
+#define SCE_L_VERBATIM 8
+#define SCE_L_SHORTCMD 9
+#define SCE_L_SPECIAL 10
+#define SCE_L_CMDOPT 11
+#define SCE_L_ERROR 12
 #define SCE_LUA_DEFAULT 0
 #define SCE_LUA_COMMENT 1
 #define SCE_LUA_COMMENTLINE 2
@@ -410,6 +490,7 @@
 #define SCE_LUA_WORD6 17
 #define SCE_LUA_WORD7 18
 #define SCE_LUA_WORD8 19
+#define SCE_LUA_LABEL 20
 #define SCE_ERR_DEFAULT 0
 #define SCE_ERR_PYTHON 1
 #define SCE_ERR_GCC 2
@@ -432,6 +513,26 @@
 #define SCE_ERR_TIDY 19
 #define SCE_ERR_JAVA_STACK 20
 #define SCE_ERR_VALUE 21
+#define SCE_ERR_GCC_INCLUDED_FROM 22
+#define SCE_ERR_ESCSEQ 23
+#define SCE_ERR_ESCSEQ_UNKNOWN 24
+#define SCE_ERR_GCC_EXCERPT 25
+#define SCE_ERR_ES_BLACK 40
+#define SCE_ERR_ES_RED 41
+#define SCE_ERR_ES_GREEN 42
+#define SCE_ERR_ES_BROWN 43
+#define SCE_ERR_ES_BLUE 44
+#define SCE_ERR_ES_MAGENTA 45
+#define SCE_ERR_ES_CYAN 46
+#define SCE_ERR_ES_GRAY 47
+#define SCE_ERR_ES_DARK_GRAY 48
+#define SCE_ERR_ES_BRIGHT_RED 49
+#define SCE_ERR_ES_BRIGHT_GREEN 50
+#define SCE_ERR_ES_YELLOW 51
+#define SCE_ERR_ES_BRIGHT_BLUE 52
+#define SCE_ERR_ES_BRIGHT_MAGENTA 53
+#define SCE_ERR_ES_BRIGHT_CYAN 54
+#define SCE_ERR_ES_WHITE 55
 #define SCE_BAT_DEFAULT 0
 #define SCE_BAT_COMMENT 1
 #define SCE_BAT_WORD 2
@@ -440,6 +541,17 @@
 #define SCE_BAT_COMMAND 5
 #define SCE_BAT_IDENTIFIER 6
 #define SCE_BAT_OPERATOR 7
+#define SCE_TCMD_DEFAULT 0
+#define SCE_TCMD_COMMENT 1
+#define SCE_TCMD_WORD 2
+#define SCE_TCMD_LABEL 3
+#define SCE_TCMD_HIDE 4
+#define SCE_TCMD_COMMAND 5
+#define SCE_TCMD_IDENTIFIER 6
+#define SCE_TCMD_OPERATOR 7
+#define SCE_TCMD_ENVIRONMENT 8
+#define SCE_TCMD_EXPANSION 9
+#define SCE_TCMD_CLABEL 10
 #define SCE_MAKE_DEFAULT 0
 #define SCE_MAKE_COMMENT 1
 #define SCE_MAKE_PREPROCESSOR 2
@@ -455,6 +567,10 @@
 #define SCE_DIFF_DELETED 5
 #define SCE_DIFF_ADDED 6
 #define SCE_DIFF_CHANGED 7
+#define SCE_DIFF_PATCH_ADD 8
+#define SCE_DIFF_PATCH_DELETE 9
+#define SCE_DIFF_REMOVED_PATCH_ADD 10
+#define SCE_DIFF_REMOVED_PATCH_DELETE 11
 #define SCE_CONF_DEFAULT 0
 #define SCE_CONF_COMMENT 1
 #define SCE_CONF_NUMBER 2
@@ -503,6 +619,20 @@
 #define SCE_BAAN_IDENTIFIER 8
 #define SCE_BAAN_STRINGEOL 9
 #define SCE_BAAN_WORD2 10
+#define SCE_BAAN_WORD3 11
+#define SCE_BAAN_WORD4 12
+#define SCE_BAAN_WORD5 13
+#define SCE_BAAN_WORD6 14
+#define SCE_BAAN_WORD7 15
+#define SCE_BAAN_WORD8 16
+#define SCE_BAAN_WORD9 17
+#define SCE_BAAN_TABLEDEF 18
+#define SCE_BAAN_TABLESQL 19
+#define SCE_BAAN_FUNCTION 20
+#define SCE_BAAN_DOMDEF 21
+#define SCE_BAAN_FUNCDEF 22
+#define SCE_BAAN_OBJECTDEF 23
+#define SCE_BAAN_DEFINEDEF 24
 #define SCE_LISP_DEFAULT 0
 #define SCE_LISP_COMMENT 1
 #define SCE_LISP_NUMBER 2
@@ -556,6 +686,14 @@
 #define SCE_MATLAB_OPERATOR 6
 #define SCE_MATLAB_IDENTIFIER 7
 #define SCE_MATLAB_DOUBLEQUOTESTRING 8
+#define SCE_MAXIMA_OPERATOR 0
+#define SCE_MAXIMA_COMMANDENDING 1
+#define SCE_MAXIMA_COMMENT 2
+#define SCE_MAXIMA_NUMBER 3
+#define SCE_MAXIMA_STRING 4
+#define SCE_MAXIMA_COMMAND 5
+#define SCE_MAXIMA_VARIABLE 6
+#define SCE_MAXIMA_UNKNOWN 7
 #define SCE_SCRIPTOL_DEFAULT 0
 #define SCE_SCRIPTOL_WHITE 1
 #define SCE_SCRIPTOL_COMMENTLINE 2
@@ -587,6 +725,7 @@
 #define SCE_ASM_CHARACTER 12
 #define SCE_ASM_STRINGEOL 13
 #define SCE_ASM_EXTINSTRUCTION 14
+#define SCE_ASM_COMMENTDIRECTIVE 15
 #define SCE_F_DEFAULT 0
 #define SCE_F_COMMENT 1
 #define SCE_F_NUMBER 2
@@ -624,6 +763,8 @@
 #define SCE_CSS_EXTENDED_IDENTIFIER 19
 #define SCE_CSS_EXTENDED_PSEUDOCLASS 20
 #define SCE_CSS_EXTENDED_PSEUDOELEMENT 21
+#define SCE_CSS_MEDIA 22
+#define SCE_CSS_VARIABLE 23
 #define SCE_POV_DEFAULT 0
 #define SCE_POV_COMMENT 1
 #define SCE_POV_COMMENTLINE 2
@@ -776,8 +917,19 @@
 #define SCE_ERLANG_CHARACTER 9
 #define SCE_ERLANG_MACRO 10
 #define SCE_ERLANG_RECORD 11
-#define SCE_ERLANG_SEPARATOR 12
+#define SCE_ERLANG_PREPROC 12
 #define SCE_ERLANG_NODE_NAME 13
+#define SCE_ERLANG_COMMENT_FUNCTION 14
+#define SCE_ERLANG_COMMENT_MODULE 15
+#define SCE_ERLANG_COMMENT_DOC 16
+#define SCE_ERLANG_COMMENT_DOC_MACRO 17
+#define SCE_ERLANG_ATOM_QUOTED 18
+#define SCE_ERLANG_MACRO_QUOTED 19
+#define SCE_ERLANG_RECORD_QUOTED 20
+#define SCE_ERLANG_NODE_NAME_QUOTED 21
+#define SCE_ERLANG_BIFS 22
+#define SCE_ERLANG_MODULES 23
+#define SCE_ERLANG_MODULES_ATT 24
 #define SCE_ERLANG_UNKNOWN 31
 #define SCE_MSSQL_DEFAULT 0
 #define SCE_MSSQL_COMMENT 1
@@ -810,6 +962,11 @@
 #define SCE_V_IDENTIFIER 11
 #define SCE_V_STRINGEOL 12
 #define SCE_V_USER 19
+#define SCE_V_COMMENT_WORD 20
+#define SCE_V_INPUT 21
+#define SCE_V_OUTPUT 22
+#define SCE_V_INOUT 23
+#define SCE_V_PORT_CONNECT 24
 #define SCE_KIX_DEFAULT 0
 #define SCE_KIX_COMMENT 1
 #define SCE_KIX_STRING1 2
@@ -820,6 +977,7 @@
 #define SCE_KIX_KEYWORD 7
 #define SCE_KIX_FUNCTIONS 8
 #define SCE_KIX_OPERATOR 9
+#define SCE_KIX_COMMENTSTREAM 10
 #define SCE_KIX_IDENTIFIER 31
 #define SCE_GC_DEFAULT 0
 #define SCE_GC_COMMENTLINE 1
@@ -916,6 +1074,7 @@
 #define SCE_VHDL_STDPACKAGE 12
 #define SCE_VHDL_STDTYPE 13
 #define SCE_VHDL_USERWORD 14
+#define SCE_VHDL_BLOCK_COMMENT 15
 #define SCE_CAML_DEFAULT 0
 #define SCE_CAML_IDENTIFIER 1
 #define SCE_CAML_TAGNAME 2
@@ -926,6 +1085,7 @@
 #define SCE_CAML_OPERATOR 7
 #define SCE_CAML_NUMBER 8
 #define SCE_CAML_CHAR 9
+#define SCE_CAML_WHITE 10
 #define SCE_CAML_STRING 11
 #define SCE_CAML_COMMENT 12
 #define SCE_CAML_COMMENT1 13
@@ -948,6 +1108,12 @@
 #define SCE_HA_COMMENTBLOCK 14
 #define SCE_HA_COMMENTBLOCK2 15
 #define SCE_HA_COMMENTBLOCK3 16
+#define SCE_HA_PRAGMA 17
+#define SCE_HA_PREPROCESSOR 18
+#define SCE_HA_STRINGEOL 19
+#define SCE_HA_RESERVED_OPERATOR 20
+#define SCE_HA_LITERATE_COMMENT 21
+#define SCE_HA_LITERATE_CODEDELIM 22
 #define SCE_T3_DEFAULT 0
 #define SCE_T3_X_DEFAULT 1
 #define SCE_T3_PREPROCESSOR 2
@@ -1020,6 +1186,7 @@
 #define SCE_SQL_USER3 21
 #define SCE_SQL_USER4 22
 #define SCE_SQL_QUOTEDIDENTIFIER 23
+#define SCE_SQL_QOPERATOR 24
 #define SCE_ST_DEFAULT 0
 #define SCE_ST_STRING 1
 #define SCE_ST_NUMBER 2
@@ -1056,11 +1223,19 @@
 #define SCE_FS_DATE 16
 #define SCE_FS_STRINGEOL 17
 #define SCE_FS_CONSTANT 18
-#define SCE_FS_ASM 19
-#define SCE_FS_LABEL 20
-#define SCE_FS_ERROR 21
-#define SCE_FS_HEXNUMBER 22
-#define SCE_FS_BINNUMBER 23
+#define SCE_FS_WORDOPERATOR 19
+#define SCE_FS_DISABLEDCODE 20
+#define SCE_FS_DEFAULT_C 21
+#define SCE_FS_COMMENTDOC_C 22
+#define SCE_FS_COMMENTLINEDOC_C 23
+#define SCE_FS_KEYWORD_C 24
+#define SCE_FS_KEYWORD2_C 25
+#define SCE_FS_NUMBER_C 26
+#define SCE_FS_STRING_C 27
+#define SCE_FS_PREPROCESSOR_C 28
+#define SCE_FS_OPERATOR_C 29
+#define SCE_FS_IDENTIFIER_C 30
+#define SCE_FS_STRINGEOL_C 31
 #define SCE_CSOUND_DEFAULT 0
 #define SCE_CSOUND_COMMENT 1
 #define SCE_CSOUND_NUMBER 2
@@ -1083,7 +1258,7 @@
 #define SCE_INNO_PARAMETER 3
 #define SCE_INNO_SECTION 4
 #define SCE_INNO_PREPROC 5
-#define SCE_INNO_PREPROC_INLINE 6
+#define SCE_INNO_INLINE_EXPANSION 6
 #define SCE_INNO_COMMENT_PASCAL 7
 #define SCE_INNO_KEYWORD_PASCAL 8
 #define SCE_INNO_KEYWORD_USER 9
@@ -1144,38 +1319,19 @@
 #define SCE_PLM_OPERATOR 5
 #define SCE_PLM_CONTROL 6
 #define SCE_PLM_KEYWORD 7
-#define SCE_4GL_DEFAULT 0
-#define SCE_4GL_NUMBER 1
-#define SCE_4GL_WORD 2
-#define SCE_4GL_STRING 3
-#define SCE_4GL_CHARACTER 4
-#define SCE_4GL_PREPROCESSOR 5
-#define SCE_4GL_OPERATOR 6
-#define SCE_4GL_IDENTIFIER 7
-#define SCE_4GL_BLOCK 8
-#define SCE_4GL_END 9
-#define SCE_4GL_COMMENT1 10
-#define SCE_4GL_COMMENT2 11
-#define SCE_4GL_COMMENT3 12
-#define SCE_4GL_COMMENT4 13
-#define SCE_4GL_COMMENT5 14
-#define SCE_4GL_COMMENT6 15
-#define SCE_4GL_DEFAULT_ 16
-#define SCE_4GL_NUMBER_ 17
-#define SCE_4GL_WORD_ 18
-#define SCE_4GL_STRING_ 19
-#define SCE_4GL_CHARACTER_ 20
-#define SCE_4GL_PREPROCESSOR_ 21
-#define SCE_4GL_OPERATOR_ 22
-#define SCE_4GL_IDENTIFIER_ 23
-#define SCE_4GL_BLOCK_ 24
-#define SCE_4GL_END_ 25
-#define SCE_4GL_COMMENT1_ 26
-#define SCE_4GL_COMMENT2_ 27
-#define SCE_4GL_COMMENT3_ 28
-#define SCE_4GL_COMMENT4_ 29
-#define SCE_4GL_COMMENT5_ 30
-#define SCE_4GL_COMMENT6_ 31
+#define SCE_ABL_DEFAULT 0
+#define SCE_ABL_NUMBER 1
+#define SCE_ABL_WORD 2
+#define SCE_ABL_STRING 3
+#define SCE_ABL_CHARACTER 4
+#define SCE_ABL_PREPROCESSOR 5
+#define SCE_ABL_OPERATOR 6
+#define SCE_ABL_IDENTIFIER 7
+#define SCE_ABL_BLOCK 8
+#define SCE_ABL_END 9
+#define SCE_ABL_COMMENT 10
+#define SCE_ABL_TASKMARKER 11
+#define SCE_ABL_LINECOMMENT 12
 #define SCE_ABAQUS_DEFAULT 0
 #define SCE_ABAQUS_COMMENT 1
 #define SCE_ABAQUS_COMMENTBLOCK 2
@@ -1241,6 +1397,12 @@
 #define SCE_POWERSHELL_KEYWORD 8
 #define SCE_POWERSHELL_CMDLET 9
 #define SCE_POWERSHELL_ALIAS 10
+#define SCE_POWERSHELL_FUNCTION 11
+#define SCE_POWERSHELL_USER1 12
+#define SCE_POWERSHELL_COMMENTSTREAM 13
+#define SCE_POWERSHELL_HERE_STRING 14
+#define SCE_POWERSHELL_HERE_CHARACTER 15
+#define SCE_POWERSHELL_COMMENTDOCKEYWORD 16
 #define SCE_MYSQL_DEFAULT 0
 #define SCE_MYSQL_COMMENT 1
 #define SCE_MYSQL_COMMENTLINE 2
@@ -1262,6 +1424,8 @@
 #define SCE_MYSQL_USER1 18
 #define SCE_MYSQL_USER2 19
 #define SCE_MYSQL_USER3 20
+#define SCE_MYSQL_HIDDENCOMMAND 21
+#define SCE_MYSQL_PLACEHOLDER 22
 #define SCE_PO_DEFAULT 0
 #define SCE_PO_COMMENT 1
 #define SCE_PO_MSGID 2
@@ -1271,8 +1435,529 @@
 #define SCE_PO_MSGCTXT 6
 #define SCE_PO_MSGCTXT_TEXT 7
 #define SCE_PO_FUZZY 8
-#define SCLEX_ASP 29
-#define SCLEX_PHP 30
-//--Autogenerated -- end of section automatically generated from Scintilla.iface
+#define SCE_PO_PROGRAMMER_COMMENT 9
+#define SCE_PO_REFERENCE 10
+#define SCE_PO_FLAGS 11
+#define SCE_PO_MSGID_TEXT_EOL 12
+#define SCE_PO_MSGSTR_TEXT_EOL 13
+#define SCE_PO_MSGCTXT_TEXT_EOL 14
+#define SCE_PO_ERROR 15
+#define SCE_PAS_DEFAULT 0
+#define SCE_PAS_IDENTIFIER 1
+#define SCE_PAS_COMMENT 2
+#define SCE_PAS_COMMENT2 3
+#define SCE_PAS_COMMENTLINE 4
+#define SCE_PAS_PREPROCESSOR 5
+#define SCE_PAS_PREPROCESSOR2 6
+#define SCE_PAS_NUMBER 7
+#define SCE_PAS_HEXNUMBER 8
+#define SCE_PAS_WORD 9
+#define SCE_PAS_STRING 10
+#define SCE_PAS_STRINGEOL 11
+#define SCE_PAS_CHARACTER 12
+#define SCE_PAS_OPERATOR 13
+#define SCE_PAS_ASM 14
+#define SCE_SORCUS_DEFAULT 0
+#define SCE_SORCUS_COMMAND 1
+#define SCE_SORCUS_PARAMETER 2
+#define SCE_SORCUS_COMMENTLINE 3
+#define SCE_SORCUS_STRING 4
+#define SCE_SORCUS_STRINGEOL 5
+#define SCE_SORCUS_IDENTIFIER 6
+#define SCE_SORCUS_OPERATOR 7
+#define SCE_SORCUS_NUMBER 8
+#define SCE_SORCUS_CONSTANT 9
+#define SCE_POWERPRO_DEFAULT 0
+#define SCE_POWERPRO_COMMENTBLOCK 1
+#define SCE_POWERPRO_COMMENTLINE 2
+#define SCE_POWERPRO_NUMBER 3
+#define SCE_POWERPRO_WORD 4
+#define SCE_POWERPRO_WORD2 5
+#define SCE_POWERPRO_WORD3 6
+#define SCE_POWERPRO_WORD4 7
+#define SCE_POWERPRO_DOUBLEQUOTEDSTRING 8
+#define SCE_POWERPRO_SINGLEQUOTEDSTRING 9
+#define SCE_POWERPRO_LINECONTINUE 10
+#define SCE_POWERPRO_OPERATOR 11
+#define SCE_POWERPRO_IDENTIFIER 12
+#define SCE_POWERPRO_STRINGEOL 13
+#define SCE_POWERPRO_VERBATIM 14
+#define SCE_POWERPRO_ALTQUOTE 15
+#define SCE_POWERPRO_FUNCTION 16
+#define SCE_SML_DEFAULT 0
+#define SCE_SML_IDENTIFIER 1
+#define SCE_SML_TAGNAME 2
+#define SCE_SML_KEYWORD 3
+#define SCE_SML_KEYWORD2 4
+#define SCE_SML_KEYWORD3 5
+#define SCE_SML_LINENUM 6
+#define SCE_SML_OPERATOR 7
+#define SCE_SML_NUMBER 8
+#define SCE_SML_CHAR 9
+#define SCE_SML_STRING 11
+#define SCE_SML_COMMENT 12
+#define SCE_SML_COMMENT1 13
+#define SCE_SML_COMMENT2 14
+#define SCE_SML_COMMENT3 15
+#define SCE_MARKDOWN_DEFAULT 0
+#define SCE_MARKDOWN_LINE_BEGIN 1
+#define SCE_MARKDOWN_STRONG1 2
+#define SCE_MARKDOWN_STRONG2 3
+#define SCE_MARKDOWN_EM1 4
+#define SCE_MARKDOWN_EM2 5
+#define SCE_MARKDOWN_HEADER1 6
+#define SCE_MARKDOWN_HEADER2 7
+#define SCE_MARKDOWN_HEADER3 8
+#define SCE_MARKDOWN_HEADER4 9
+#define SCE_MARKDOWN_HEADER5 10
+#define SCE_MARKDOWN_HEADER6 11
+#define SCE_MARKDOWN_PRECHAR 12
+#define SCE_MARKDOWN_ULIST_ITEM 13
+#define SCE_MARKDOWN_OLIST_ITEM 14
+#define SCE_MARKDOWN_BLOCKQUOTE 15
+#define SCE_MARKDOWN_STRIKEOUT 16
+#define SCE_MARKDOWN_HRULE 17
+#define SCE_MARKDOWN_LINK 18
+#define SCE_MARKDOWN_CODE 19
+#define SCE_MARKDOWN_CODE2 20
+#define SCE_MARKDOWN_CODEBK 21
+#define SCE_TXT2TAGS_DEFAULT 0
+#define SCE_TXT2TAGS_LINE_BEGIN 1
+#define SCE_TXT2TAGS_STRONG1 2
+#define SCE_TXT2TAGS_STRONG2 3
+#define SCE_TXT2TAGS_EM1 4
+#define SCE_TXT2TAGS_EM2 5
+#define SCE_TXT2TAGS_HEADER1 6
+#define SCE_TXT2TAGS_HEADER2 7
+#define SCE_TXT2TAGS_HEADER3 8
+#define SCE_TXT2TAGS_HEADER4 9
+#define SCE_TXT2TAGS_HEADER5 10
+#define SCE_TXT2TAGS_HEADER6 11
+#define SCE_TXT2TAGS_PRECHAR 12
+#define SCE_TXT2TAGS_ULIST_ITEM 13
+#define SCE_TXT2TAGS_OLIST_ITEM 14
+#define SCE_TXT2TAGS_BLOCKQUOTE 15
+#define SCE_TXT2TAGS_STRIKEOUT 16
+#define SCE_TXT2TAGS_HRULE 17
+#define SCE_TXT2TAGS_LINK 18
+#define SCE_TXT2TAGS_CODE 19
+#define SCE_TXT2TAGS_CODE2 20
+#define SCE_TXT2TAGS_CODEBK 21
+#define SCE_TXT2TAGS_COMMENT 22
+#define SCE_TXT2TAGS_OPTION 23
+#define SCE_TXT2TAGS_PREPROC 24
+#define SCE_TXT2TAGS_POSTPROC 25
+#define SCE_A68K_DEFAULT 0
+#define SCE_A68K_COMMENT 1
+#define SCE_A68K_NUMBER_DEC 2
+#define SCE_A68K_NUMBER_BIN 3
+#define SCE_A68K_NUMBER_HEX 4
+#define SCE_A68K_STRING1 5
+#define SCE_A68K_OPERATOR 6
+#define SCE_A68K_CPUINSTRUCTION 7
+#define SCE_A68K_EXTINSTRUCTION 8
+#define SCE_A68K_REGISTER 9
+#define SCE_A68K_DIRECTIVE 10
+#define SCE_A68K_MACRO_ARG 11
+#define SCE_A68K_LABEL 12
+#define SCE_A68K_STRING2 13
+#define SCE_A68K_IDENTIFIER 14
+#define SCE_A68K_MACRO_DECLARATION 15
+#define SCE_A68K_COMMENT_WORD 16
+#define SCE_A68K_COMMENT_SPECIAL 17
+#define SCE_A68K_COMMENT_DOXYGEN 18
+#define SCE_MODULA_DEFAULT 0
+#define SCE_MODULA_COMMENT 1
+#define SCE_MODULA_DOXYCOMM 2
+#define SCE_MODULA_DOXYKEY 3
+#define SCE_MODULA_KEYWORD 4
+#define SCE_MODULA_RESERVED 5
+#define SCE_MODULA_NUMBER 6
+#define SCE_MODULA_BASENUM 7
+#define SCE_MODULA_FLOAT 8
+#define SCE_MODULA_STRING 9
+#define SCE_MODULA_STRSPEC 10
+#define SCE_MODULA_CHAR 11
+#define SCE_MODULA_CHARSPEC 12
+#define SCE_MODULA_PROC 13
+#define SCE_MODULA_PRAGMA 14
+#define SCE_MODULA_PRGKEY 15
+#define SCE_MODULA_OPERATOR 16
+#define SCE_MODULA_BADSTR 17
+#define SCE_COFFEESCRIPT_DEFAULT 0
+#define SCE_COFFEESCRIPT_COMMENT 1
+#define SCE_COFFEESCRIPT_COMMENTLINE 2
+#define SCE_COFFEESCRIPT_COMMENTDOC 3
+#define SCE_COFFEESCRIPT_NUMBER 4
+#define SCE_COFFEESCRIPT_WORD 5
+#define SCE_COFFEESCRIPT_STRING 6
+#define SCE_COFFEESCRIPT_CHARACTER 7
+#define SCE_COFFEESCRIPT_UUID 8
+#define SCE_COFFEESCRIPT_PREPROCESSOR 9
+#define SCE_COFFEESCRIPT_OPERATOR 10
+#define SCE_COFFEESCRIPT_IDENTIFIER 11
+#define SCE_COFFEESCRIPT_STRINGEOL 12
+#define SCE_COFFEESCRIPT_VERBATIM 13
+#define SCE_COFFEESCRIPT_REGEX 14
+#define SCE_COFFEESCRIPT_COMMENTLINEDOC 15
+#define SCE_COFFEESCRIPT_WORD2 16
+#define SCE_COFFEESCRIPT_COMMENTDOCKEYWORD 17
+#define SCE_COFFEESCRIPT_COMMENTDOCKEYWORDERROR 18
+#define SCE_COFFEESCRIPT_GLOBALCLASS 19
+#define SCE_COFFEESCRIPT_STRINGRAW 20
+#define SCE_COFFEESCRIPT_TRIPLEVERBATIM 21
+#define SCE_COFFEESCRIPT_COMMENTBLOCK 22
+#define SCE_COFFEESCRIPT_VERBOSE_REGEX 23
+#define SCE_COFFEESCRIPT_VERBOSE_REGEX_COMMENT 24
+#define SCE_COFFEESCRIPT_INSTANCEPROPERTY 25
+#define SCE_AVS_DEFAULT 0
+#define SCE_AVS_COMMENTBLOCK 1
+#define SCE_AVS_COMMENTBLOCKN 2
+#define SCE_AVS_COMMENTLINE 3
+#define SCE_AVS_NUMBER 4
+#define SCE_AVS_OPERATOR 5
+#define SCE_AVS_IDENTIFIER 6
+#define SCE_AVS_STRING 7
+#define SCE_AVS_TRIPLESTRING 8
+#define SCE_AVS_KEYWORD 9
+#define SCE_AVS_FILTER 10
+#define SCE_AVS_PLUGIN 11
+#define SCE_AVS_FUNCTION 12
+#define SCE_AVS_CLIPPROP 13
+#define SCE_AVS_USERDFN 14
+#define SCE_ECL_DEFAULT 0
+#define SCE_ECL_COMMENT 1
+#define SCE_ECL_COMMENTLINE 2
+#define SCE_ECL_NUMBER 3
+#define SCE_ECL_STRING 4
+#define SCE_ECL_WORD0 5
+#define SCE_ECL_OPERATOR 6
+#define SCE_ECL_CHARACTER 7
+#define SCE_ECL_UUID 8
+#define SCE_ECL_PREPROCESSOR 9
+#define SCE_ECL_UNKNOWN 10
+#define SCE_ECL_IDENTIFIER 11
+#define SCE_ECL_STRINGEOL 12
+#define SCE_ECL_VERBATIM 13
+#define SCE_ECL_REGEX 14
+#define SCE_ECL_COMMENTLINEDOC 15
+#define SCE_ECL_WORD1 16
+#define SCE_ECL_COMMENTDOCKEYWORD 17
+#define SCE_ECL_COMMENTDOCKEYWORDERROR 18
+#define SCE_ECL_WORD2 19
+#define SCE_ECL_WORD3 20
+#define SCE_ECL_WORD4 21
+#define SCE_ECL_WORD5 22
+#define SCE_ECL_COMMENTDOC 23
+#define SCE_ECL_ADDED 24
+#define SCE_ECL_DELETED 25
+#define SCE_ECL_CHANGED 26
+#define SCE_ECL_MOVED 27
+#define SCE_OSCRIPT_DEFAULT 0
+#define SCE_OSCRIPT_LINE_COMMENT 1
+#define SCE_OSCRIPT_BLOCK_COMMENT 2
+#define SCE_OSCRIPT_DOC_COMMENT 3
+#define SCE_OSCRIPT_PREPROCESSOR 4
+#define SCE_OSCRIPT_NUMBER 5
+#define SCE_OSCRIPT_SINGLEQUOTE_STRING 6
+#define SCE_OSCRIPT_DOUBLEQUOTE_STRING 7
+#define SCE_OSCRIPT_CONSTANT 8
+#define SCE_OSCRIPT_IDENTIFIER 9
+#define SCE_OSCRIPT_GLOBAL 10
+#define SCE_OSCRIPT_KEYWORD 11
+#define SCE_OSCRIPT_OPERATOR 12
+#define SCE_OSCRIPT_LABEL 13
+#define SCE_OSCRIPT_TYPE 14
+#define SCE_OSCRIPT_FUNCTION 15
+#define SCE_OSCRIPT_OBJECT 16
+#define SCE_OSCRIPT_PROPERTY 17
+#define SCE_OSCRIPT_METHOD 18
+#define SCE_VISUALPROLOG_DEFAULT 0
+#define SCE_VISUALPROLOG_KEY_MAJOR 1
+#define SCE_VISUALPROLOG_KEY_MINOR 2
+#define SCE_VISUALPROLOG_KEY_DIRECTIVE 3
+#define SCE_VISUALPROLOG_COMMENT_BLOCK 4
+#define SCE_VISUALPROLOG_COMMENT_LINE 5
+#define SCE_VISUALPROLOG_COMMENT_KEY 6
+#define SCE_VISUALPROLOG_COMMENT_KEY_ERROR 7
+#define SCE_VISUALPROLOG_IDENTIFIER 8
+#define SCE_VISUALPROLOG_VARIABLE 9
+#define SCE_VISUALPROLOG_ANONYMOUS 10
+#define SCE_VISUALPROLOG_NUMBER 11
+#define SCE_VISUALPROLOG_OPERATOR 12
+#define SCE_VISUALPROLOG_CHARACTER 13
+#define SCE_VISUALPROLOG_CHARACTER_TOO_MANY 14
+#define SCE_VISUALPROLOG_CHARACTER_ESCAPE_ERROR 15
+#define SCE_VISUALPROLOG_STRING 16
+#define SCE_VISUALPROLOG_STRING_ESCAPE 17
+#define SCE_VISUALPROLOG_STRING_ESCAPE_ERROR 18
+#define SCE_VISUALPROLOG_STRING_EOL_OPEN 19
+#define SCE_VISUALPROLOG_STRING_VERBATIM 20
+#define SCE_VISUALPROLOG_STRING_VERBATIM_SPECIAL 21
+#define SCE_VISUALPROLOG_STRING_VERBATIM_EOL 22
+#define SCE_STTXT_DEFAULT 0
+#define SCE_STTXT_COMMENT 1
+#define SCE_STTXT_COMMENTLINE 2
+#define SCE_STTXT_KEYWORD 3
+#define SCE_STTXT_TYPE 4
+#define SCE_STTXT_FUNCTION 5
+#define SCE_STTXT_FB 6
+#define SCE_STTXT_NUMBER 7
+#define SCE_STTXT_HEXNUMBER 8
+#define SCE_STTXT_PRAGMA 9
+#define SCE_STTXT_OPERATOR 10
+#define SCE_STTXT_CHARACTER 11
+#define SCE_STTXT_STRING1 12
+#define SCE_STTXT_STRING2 13
+#define SCE_STTXT_STRINGEOL 14
+#define SCE_STTXT_IDENTIFIER 15
+#define SCE_STTXT_DATETIME 16
+#define SCE_STTXT_VARS 17
+#define SCE_STTXT_PRAGMAS 18
+#define SCE_KVIRC_DEFAULT 0
+#define SCE_KVIRC_COMMENT 1
+#define SCE_KVIRC_COMMENTBLOCK 2
+#define SCE_KVIRC_STRING 3
+#define SCE_KVIRC_WORD 4
+#define SCE_KVIRC_KEYWORD 5
+#define SCE_KVIRC_FUNCTION_KEYWORD 6
+#define SCE_KVIRC_FUNCTION 7
+#define SCE_KVIRC_VARIABLE 8
+#define SCE_KVIRC_NUMBER 9
+#define SCE_KVIRC_OPERATOR 10
+#define SCE_KVIRC_STRING_FUNCTION 11
+#define SCE_KVIRC_STRING_VARIABLE 12
+#define SCE_RUST_DEFAULT 0
+#define SCE_RUST_COMMENTBLOCK 1
+#define SCE_RUST_COMMENTLINE 2
+#define SCE_RUST_COMMENTBLOCKDOC 3
+#define SCE_RUST_COMMENTLINEDOC 4
+#define SCE_RUST_NUMBER 5
+#define SCE_RUST_WORD 6
+#define SCE_RUST_WORD2 7
+#define SCE_RUST_WORD3 8
+#define SCE_RUST_WORD4 9
+#define SCE_RUST_WORD5 10
+#define SCE_RUST_WORD6 11
+#define SCE_RUST_WORD7 12
+#define SCE_RUST_STRING 13
+#define SCE_RUST_STRINGR 14
+#define SCE_RUST_CHARACTER 15
+#define SCE_RUST_OPERATOR 16
+#define SCE_RUST_IDENTIFIER 17
+#define SCE_RUST_LIFETIME 18
+#define SCE_RUST_MACRO 19
+#define SCE_RUST_LEXERROR 20
+#define SCE_RUST_BYTESTRING 21
+#define SCE_RUST_BYTESTRINGR 22
+#define SCE_RUST_BYTECHARACTER 23
+#define SCE_DMAP_DEFAULT 0
+#define SCE_DMAP_COMMENT 1
+#define SCE_DMAP_NUMBER 2
+#define SCE_DMAP_STRING1 3
+#define SCE_DMAP_STRING2 4
+#define SCE_DMAP_STRINGEOL 5
+#define SCE_DMAP_OPERATOR 6
+#define SCE_DMAP_IDENTIFIER 7
+#define SCE_DMAP_WORD 8
+#define SCE_DMAP_WORD2 9
+#define SCE_DMAP_WORD3 10
+#define SCE_DMIS_DEFAULT 0
+#define SCE_DMIS_COMMENT 1
+#define SCE_DMIS_STRING 2
+#define SCE_DMIS_NUMBER 3
+#define SCE_DMIS_KEYWORD 4
+#define SCE_DMIS_MAJORWORD 5
+#define SCE_DMIS_MINORWORD 6
+#define SCE_DMIS_UNSUPPORTED_MAJOR 7
+#define SCE_DMIS_UNSUPPORTED_MINOR 8
+#define SCE_DMIS_LABEL 9
+#define SCE_REG_DEFAULT 0
+#define SCE_REG_COMMENT 1
+#define SCE_REG_VALUENAME 2
+#define SCE_REG_STRING 3
+#define SCE_REG_HEXDIGIT 4
+#define SCE_REG_VALUETYPE 5
+#define SCE_REG_ADDEDKEY 6
+#define SCE_REG_DELETEDKEY 7
+#define SCE_REG_ESCAPED 8
+#define SCE_REG_KEYPATH_GUID 9
+#define SCE_REG_STRING_GUID 10
+#define SCE_REG_PARAMETER 11
+#define SCE_REG_OPERATOR 12
+#define SCE_BIBTEX_DEFAULT 0
+#define SCE_BIBTEX_ENTRY 1
+#define SCE_BIBTEX_UNKNOWN_ENTRY 2
+#define SCE_BIBTEX_KEY 3
+#define SCE_BIBTEX_PARAMETER 4
+#define SCE_BIBTEX_VALUE 5
+#define SCE_BIBTEX_COMMENT 6
+#define SCE_HEX_DEFAULT 0
+#define SCE_HEX_RECSTART 1
+#define SCE_HEX_RECTYPE 2
+#define SCE_HEX_RECTYPE_UNKNOWN 3
+#define SCE_HEX_BYTECOUNT 4
+#define SCE_HEX_BYTECOUNT_WRONG 5
+#define SCE_HEX_NOADDRESS 6
+#define SCE_HEX_DATAADDRESS 7
+#define SCE_HEX_RECCOUNT 8
+#define SCE_HEX_STARTADDRESS 9
+#define SCE_HEX_ADDRESSFIELD_UNKNOWN 10
+#define SCE_HEX_EXTENDEDADDRESS 11
+#define SCE_HEX_DATA_ODD 12
+#define SCE_HEX_DATA_EVEN 13
+#define SCE_HEX_DATA_UNKNOWN 14
+#define SCE_HEX_DATA_EMPTY 15
+#define SCE_HEX_CHECKSUM 16
+#define SCE_HEX_CHECKSUM_WRONG 17
+#define SCE_HEX_GARBAGE 18
+#define SCE_JSON_DEFAULT 0
+#define SCE_JSON_NUMBER 1
+#define SCE_JSON_STRING 2
+#define SCE_JSON_STRINGEOL 3
+#define SCE_JSON_PROPERTYNAME 4
+#define SCE_JSON_ESCAPESEQUENCE 5
+#define SCE_JSON_LINECOMMENT 6
+#define SCE_JSON_BLOCKCOMMENT 7
+#define SCE_JSON_OPERATOR 8
+#define SCE_JSON_URI 9
+#define SCE_JSON_COMPACTIRI 10
+#define SCE_JSON_KEYWORD 11
+#define SCE_JSON_LDKEYWORD 12
+#define SCE_JSON_ERROR 13
+#define SCE_EDI_DEFAULT 0
+#define SCE_EDI_SEGMENTSTART 1
+#define SCE_EDI_SEGMENTEND 2
+#define SCE_EDI_SEP_ELEMENT 3
+#define SCE_EDI_SEP_COMPOSITE 4
+#define SCE_EDI_SEP_RELEASE 5
+#define SCE_EDI_UNA 6
+#define SCE_EDI_UNH 7
+#define SCE_EDI_BADSEGMENT 8
+#define SCE_STATA_DEFAULT 0
+#define SCE_STATA_COMMENT 1
+#define SCE_STATA_COMMENTLINE 2
+#define SCE_STATA_COMMENTBLOCK 3
+#define SCE_STATA_NUMBER 4
+#define SCE_STATA_OPERATOR 5
+#define SCE_STATA_IDENTIFIER 6
+#define SCE_STATA_STRING 7
+#define SCE_STATA_TYPE 8
+#define SCE_STATA_WORD 9
+#define SCE_STATA_GLOBAL_MACRO 10
+#define SCE_STATA_MACRO 11
+#define SCE_SAS_DEFAULT 0
+#define SCE_SAS_COMMENT 1
+#define SCE_SAS_COMMENTLINE 2
+#define SCE_SAS_COMMENTBLOCK 3
+#define SCE_SAS_NUMBER 4
+#define SCE_SAS_OPERATOR 5
+#define SCE_SAS_IDENTIFIER 6
+#define SCE_SAS_STRING 7
+#define SCE_SAS_TYPE 8
+#define SCE_SAS_WORD 9
+#define SCE_SAS_GLOBAL_MACRO 10
+#define SCE_SAS_MACRO 11
+#define SCE_SAS_MACRO_KEYWORD 12
+#define SCE_SAS_BLOCK_KEYWORD 13
+#define SCE_SAS_MACRO_FUNCTION 14
+#define SCE_SAS_STATEMENT 15
+#define SCE_NIM_DEFAULT 0
+#define SCE_NIM_COMMENT 1
+#define SCE_NIM_COMMENTDOC 2
+#define SCE_NIM_COMMENTLINE 3
+#define SCE_NIM_COMMENTLINEDOC 4
+#define SCE_NIM_NUMBER 5
+#define SCE_NIM_STRING 6
+#define SCE_NIM_CHARACTER 7
+#define SCE_NIM_WORD 8
+#define SCE_NIM_TRIPLE 9
+#define SCE_NIM_TRIPLEDOUBLE 10
+#define SCE_NIM_BACKTICKS 11
+#define SCE_NIM_FUNCNAME 12
+#define SCE_NIM_STRINGEOL 13
+#define SCE_NIM_NUMERROR 14
+#define SCE_NIM_OPERATOR 15
+#define SCE_NIM_IDENTIFIER 16
+#define SCE_CIL_DEFAULT 0
+#define SCE_CIL_COMMENT 1
+#define SCE_CIL_COMMENTLINE 2
+#define SCE_CIL_WORD 3
+#define SCE_CIL_WORD2 4
+#define SCE_CIL_WORD3 5
+#define SCE_CIL_STRING 6
+#define SCE_CIL_LABEL 7
+#define SCE_CIL_OPERATOR 8
+#define SCE_CIL_IDENTIFIER 9
+#define SCE_CIL_STRINGEOL 10
+#define SCE_X12_DEFAULT 0
+#define SCE_X12_BAD 1
+#define SCE_X12_ENVELOPE 2
+#define SCE_X12_FUNCTIONGROUP 3
+#define SCE_X12_TRANSACTIONSET 4
+#define SCE_X12_SEGMENTHEADER 5
+#define SCE_X12_SEGMENTEND 6
+#define SCE_X12_SEP_ELEMENT 7
+#define SCE_X12_SEP_SUBELEMENT 8
+#define SCE_DF_DEFAULT 0
+#define SCE_DF_IDENTIFIER 1
+#define SCE_DF_METATAG 2
+#define SCE_DF_IMAGE 3
+#define SCE_DF_COMMENTLINE 4
+#define SCE_DF_PREPROCESSOR 5
+#define SCE_DF_PREPROCESSOR2 6
+#define SCE_DF_NUMBER 7
+#define SCE_DF_HEXNUMBER 8
+#define SCE_DF_WORD 9
+#define SCE_DF_STRING 10
+#define SCE_DF_STRINGEOL 11
+#define SCE_DF_SCOPEWORD 12
+#define SCE_DF_OPERATOR 13
+#define SCE_DF_ICODE 14
+#define SCE_HOLLYWOOD_DEFAULT 0
+#define SCE_HOLLYWOOD_COMMENT 1
+#define SCE_HOLLYWOOD_COMMENTBLOCK 2
+#define SCE_HOLLYWOOD_NUMBER 3
+#define SCE_HOLLYWOOD_KEYWORD 4
+#define SCE_HOLLYWOOD_STDAPI 5
+#define SCE_HOLLYWOOD_PLUGINAPI 6
+#define SCE_HOLLYWOOD_PLUGINMETHOD 7
+#define SCE_HOLLYWOOD_STRING 8
+#define SCE_HOLLYWOOD_STRINGBLOCK 9
+#define SCE_HOLLYWOOD_PREPROCESSOR 10
+#define SCE_HOLLYWOOD_OPERATOR 11
+#define SCE_HOLLYWOOD_IDENTIFIER 12
+#define SCE_HOLLYWOOD_CONSTANT 13
+#define SCE_HOLLYWOOD_HEXNUMBER 14
+#define SCE_RAKU_DEFAULT 0
+#define SCE_RAKU_ERROR 1
+#define SCE_RAKU_COMMENTLINE 2
+#define SCE_RAKU_COMMENTEMBED 3
+#define SCE_RAKU_POD 4
+#define SCE_RAKU_CHARACTER 5
+#define SCE_RAKU_HEREDOC_Q 6
+#define SCE_RAKU_HEREDOC_QQ 7
+#define SCE_RAKU_STRING 8
+#define SCE_RAKU_STRING_Q 9
+#define SCE_RAKU_STRING_QQ 10
+#define SCE_RAKU_STRING_Q_LANG 11
+#define SCE_RAKU_STRING_VAR 12
+#define SCE_RAKU_REGEX 13
+#define SCE_RAKU_REGEX_VAR 14
+#define SCE_RAKU_ADVERB 15
+#define SCE_RAKU_NUMBER 16
+#define SCE_RAKU_PREPROCESSOR 17
+#define SCE_RAKU_OPERATOR 18
+#define SCE_RAKU_WORD 19
+#define SCE_RAKU_FUNCTION 20
+#define SCE_RAKU_IDENTIFIER 21
+#define SCE_RAKU_TYPEDEF 22
+#define SCE_RAKU_MU 23
+#define SCE_RAKU_POSITIONAL 24
+#define SCE_RAKU_ASSOCIATIVE 25
+#define SCE_RAKU_CALLABLE 26
+#define SCE_RAKU_GRAMMAR 27
+#define SCE_RAKU_CLASS 28
+/* --Autogenerated -- end of section automatically generated from Scintilla.iface */
 
 #endif
diff --git a/Pythonwin/Scintilla/include/Sci_Position.h b/Pythonwin/Scintilla/include/Sci_Position.h
new file mode 100644
index 000000000..abd0f3408
--- /dev/null
+++ b/Pythonwin/Scintilla/include/Sci_Position.h
@@ -0,0 +1,29 @@
+// Scintilla source code edit control
+/** @file Sci_Position.h
+ ** Define the Sci_Position type used in Scintilla's external interfaces.
+ ** These need to be available to clients written in C so are not in a C++ namespace.
+ **/
+// Copyright 2015 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef SCI_POSITION_H
+#define SCI_POSITION_H
+
+#include <stddef.h>
+
+// Basic signed type used throughout interface
+typedef ptrdiff_t Sci_Position;
+
+// Unsigned variant used for ILexer::Lex and ILexer::Fold
+typedef size_t Sci_PositionU;
+
+// For Sci_CharacterRange  which is defined as long to be compatible with Win32 CHARRANGE
+typedef long Sci_PositionCR;
+
+#ifdef _WIN32
+	#define SCI_METHOD __stdcall
+#else
+	#define SCI_METHOD
+#endif
+
+#endif
diff --git a/Pythonwin/Scintilla/include/Scintilla.h b/Pythonwin/Scintilla/include/Scintilla.h
index 7dca10ae4..acde9a5f9 100644
--- a/Pythonwin/Scintilla/include/Scintilla.h
+++ b/Pythonwin/Scintilla/include/Scintilla.h
@@ -1,44 +1,46 @@
-// Scintilla source code edit control
+/* Scintilla source code edit control */
 /** @file Scintilla.h
  ** Interface to the edit control.
  **/
-// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
+/* Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+ * The License.txt file describes the conditions under which this software may be distributed. */
 
-// Most of this file is automatically generated from the Scintilla.iface interface definition
-// file which contains any comments about the definitions. HFacer.py does the generation.
+/* Most of this file is automatically generated from the Scintilla.iface interface definition
+ * file which contains any comments about the definitions. HFacer.py does the generation. */
 
 #ifndef SCINTILLA_H
 #define SCINTILLA_H
 
-#if LCCWIN
-typedef BOOL bool;
+#ifdef __cplusplus
+extern "C" {
 #endif
 
-#if PLAT_WIN
-// Return false on failure:
-bool Scintilla_RegisterClasses(void *hInstance);
-bool Scintilla_ReleaseResources();
+#if defined(_WIN32)
+/* Return false on failure: */
+int Scintilla_RegisterClasses(void *hInstance);
+int Scintilla_ReleaseResources(void);
 #endif
-int Scintilla_LinkLexers();
+int Scintilla_LinkLexers(void);
 
-// Here should be placed typedefs for uptr_t, an unsigned integer type large enough to
-// hold a pointer and sptr_t, a signed integer large enough to hold a pointer.
-// May need to be changed for 64 bit platforms.
-#if _MSC_VER >= 1300
-#include <BaseTsd.h>
-#endif
-#ifdef MAXULONG_PTR
-typedef ULONG_PTR uptr_t;
-typedef LONG_PTR sptr_t;
-#else
-typedef unsigned long uptr_t;
-typedef long sptr_t;
+#ifdef __cplusplus
+}
 #endif
 
+// Include header that defines basic numeric types.
+#include <stdint.h>
+
+// Define uptr_t, an unsigned integer type large enough to hold a pointer.
+typedef uintptr_t uptr_t;
+// Define sptr_t, a signed integer large enough to hold a pointer.
+typedef intptr_t sptr_t;
+
+#include "Sci_Position.h"
+
 typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam, sptr_t lParam);
 
-//++Autogenerated -- start of section automatically generated from Scintilla.iface
+#ifndef SCI_DISABLE_AUTOGENERATED
+
+/* ++Autogenerated -- start of section automatically generated from Scintilla.iface */
 #define INVALID_POSITION -1
 #define SCI_START 2000
 #define SCI_OPTIONAL_START 3000
@@ -46,7 +48,9 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_ADDTEXT 2001
 #define SCI_ADDSTYLEDTEXT 2002
 #define SCI_INSERTTEXT 2003
+#define SCI_CHANGEINSERTION 2672
 #define SCI_CLEARALL 2004
+#define SCI_DELETERANGE 2645
 #define SCI_CLEARDOCUMENTSTYLE 2005
 #define SCI_GETLENGTH 2006
 #define SCI_GETCHARAT 2007
@@ -61,12 +65,19 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_CANREDO 2016
 #define SCI_MARKERLINEFROMHANDLE 2017
 #define SCI_MARKERDELETEHANDLE 2018
+#define SCI_MARKERHANDLEFROMLINE 2732
+#define SCI_MARKERNUMBERFROMLINE 2733
 #define SCI_GETUNDOCOLLECTION 2019
 #define SCWS_INVISIBLE 0
 #define SCWS_VISIBLEALWAYS 1
 #define SCWS_VISIBLEAFTERINDENT 2
+#define SCWS_VISIBLEONLYININDENT 3
 #define SCI_GETVIEWWS 2020
 #define SCI_SETVIEWWS 2021
+#define SCTD_LONGARROW 0
+#define SCTD_STRIKEOUT 1
+#define SCI_GETTABDRAWMODE 2698
+#define SCI_SETTABDRAWMODE 2699
 #define SCI_POSITIONFROMPOINT 2022
 #define SCI_POSITIONFROMPOINTCLOSE 2023
 #define SCI_GOTOLINE 2024
@@ -86,10 +97,24 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_SETBUFFEREDDRAW 2035
 #define SCI_SETTABWIDTH 2036
 #define SCI_GETTABWIDTH 2121
+#define SCI_SETTABMINIMUMWIDTH 2724
+#define SCI_GETTABMINIMUMWIDTH 2725
+#define SCI_CLEARTABSTOPS 2675
+#define SCI_ADDTABSTOP 2676
+#define SCI_GETNEXTTABSTOP 2677
 #define SC_CP_UTF8 65001
-#define SC_CP_DBCS 1
 #define SCI_SETCODEPAGE 2037
-#define SCI_SETUSEPALETTE 2039
+#define SC_IME_WINDOWED 0
+#define SC_IME_INLINE 1
+#define SCI_GETIMEINTERACTION 2678
+#define SCI_SETIMEINTERACTION 2679
+#define SC_ALPHA_TRANSPARENT 0
+#define SC_ALPHA_OPAQUE 255
+#define SC_ALPHA_NOALPHA 256
+#define SC_CURSORNORMAL -1
+#define SC_CURSORARROW 2
+#define SC_CURSORWAIT 4
+#define SC_CURSORREVERSEARROW 7
 #define MARKER_MAX 31
 #define SC_MARK_CIRCLE 0
 #define SC_MARK_ROUNDRECT 1
@@ -119,6 +144,11 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SC_MARK_PIXMAP 25
 #define SC_MARK_FULLRECT 26
 #define SC_MARK_LEFTRECT 27
+#define SC_MARK_AVAILABLE 28
+#define SC_MARK_UNDERLINE 29
+#define SC_MARK_RGBAIMAGE 30
+#define SC_MARK_BOOKMARK 31
+#define SC_MARK_VERTICALBOOKMARK 32
 #define SC_MARK_CHARACTER 10000
 #define SC_MARKNUM_FOLDEREND 25
 #define SC_MARKNUM_FOLDEROPENMID 26
@@ -131,6 +161,8 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_MARKERDEFINE 2040
 #define SCI_MARKERSETFORE 2041
 #define SCI_MARKERSETBACK 2042
+#define SCI_MARKERSETBACKSELECTED 2292
+#define SCI_MARKERENABLEHIGHLIGHT 2293
 #define SCI_MARKERADD 2043
 #define SCI_MARKERDELETE 2044
 #define SCI_MARKERDELETEALL 2045
@@ -140,10 +172,14 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_MARKERDEFINEPIXMAP 2049
 #define SCI_MARKERADDSET 2466
 #define SCI_MARKERSETALPHA 2476
+#define SC_MAX_MARGIN 4
 #define SC_MARGIN_SYMBOL 0
 #define SC_MARGIN_NUMBER 1
 #define SC_MARGIN_BACK 2
 #define SC_MARGIN_FORE 3
+#define SC_MARGIN_TEXT 4
+#define SC_MARGIN_RTEXT 5
+#define SC_MARGIN_COLOUR 6
 #define SCI_SETMARGINTYPEN 2240
 #define SCI_GETMARGINTYPEN 2241
 #define SCI_SETMARGINWIDTHN 2242
@@ -152,6 +188,12 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_GETMARGINMASKN 2245
 #define SCI_SETMARGINSENSITIVEN 2246
 #define SCI_GETMARGINSENSITIVEN 2247
+#define SCI_SETMARGINCURSORN 2248
+#define SCI_GETMARGINCURSORN 2249
+#define SCI_SETMARGINBACKN 2250
+#define SCI_GETMARGINBACKN 2251
+#define SCI_SETMARGINS 2252
+#define SCI_GETMARGINS 2253
 #define STYLE_DEFAULT 32
 #define STYLE_LINENUMBER 33
 #define STYLE_BRACELIGHT 34
@@ -159,6 +201,7 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define STYLE_CONTROLCHAR 36
 #define STYLE_INDENTGUIDE 37
 #define STYLE_CALLTIP 38
+#define STYLE_FOLDDISPLAYTEXT 39
 #define STYLE_LASTPREDEFINED 39
 #define STYLE_MAX 255
 #define SC_CHARSET_ANSI 0
@@ -172,6 +215,7 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SC_CHARSET_MAC 77
 #define SC_CHARSET_OEM 255
 #define SC_CHARSET_RUSSIAN 204
+#define SC_CHARSET_OEM866 866
 #define SC_CHARSET_CYRILLIC 1251
 #define SC_CHARSET_SHIFTJIS 128
 #define SC_CHARSET_SYMBOL 2
@@ -195,6 +239,7 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SC_CASE_MIXED 0
 #define SC_CASE_UPPER 1
 #define SC_CASE_LOWER 2
+#define SC_CASE_CAMEL 3
 #define SCI_STYLEGETFORE 2481
 #define SCI_STYLEGETBACK 2482
 #define SCI_STYLEGETBOLD 2483
@@ -209,6 +254,14 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_STYLEGETCHANGEABLE 2492
 #define SCI_STYLEGETHOTSPOT 2493
 #define SCI_STYLESETCASE 2060
+#define SC_FONT_SIZE_MULTIPLIER 100
+#define SCI_STYLESETSIZEFRACTIONAL 2061
+#define SCI_STYLEGETSIZEFRACTIONAL 2062
+#define SC_WEIGHT_NORMAL 400
+#define SC_WEIGHT_SEMIBOLD 600
+#define SC_WEIGHT_BOLD 700
+#define SCI_STYLESETWEIGHT 2063
+#define SCI_STYLEGETWEIGHT 2064
 #define SCI_STYLESETCHARACTERSET 2066
 #define SCI_STYLESETHOTSPOT 2409
 #define SCI_SETSELFORE 2067
@@ -226,6 +279,9 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_GETCARETPERIOD 2075
 #define SCI_SETCARETPERIOD 2076
 #define SCI_SETWORDCHARS 2077
+#define SCI_GETWORDCHARS 2646
+#define SCI_SETCHARACTERCATEGORYOPTIMIZATION 2720
+#define SCI_GETCHARACTERCATEGORYOPTIMIZATION 2721
 #define SCI_BEGINUNDOACTION 2078
 #define SCI_ENDUNDOACTION 2079
 #define INDIC_PLAIN 0
@@ -236,22 +292,47 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define INDIC_HIDDEN 5
 #define INDIC_BOX 6
 #define INDIC_ROUNDBOX 7
-#define INDIC_MAX 31
+#define INDIC_STRAIGHTBOX 8
+#define INDIC_DASH 9
+#define INDIC_DOTS 10
+#define INDIC_SQUIGGLELOW 11
+#define INDIC_DOTBOX 12
+#define INDIC_SQUIGGLEPIXMAP 13
+#define INDIC_COMPOSITIONTHICK 14
+#define INDIC_COMPOSITIONTHIN 15
+#define INDIC_FULLBOX 16
+#define INDIC_TEXTFORE 17
+#define INDIC_POINT 18
+#define INDIC_POINTCHARACTER 19
+#define INDIC_GRADIENT 20
+#define INDIC_GRADIENTCENTRE 21
 #define INDIC_CONTAINER 8
-#define INDIC0_MASK 0x20
-#define INDIC1_MASK 0x40
-#define INDIC2_MASK 0x80
-#define INDICS_MASK 0xE0
+#define INDIC_IME 32
+#define INDIC_IME_MAX 35
+#define INDIC_MAX 35
+#define INDICATOR_CONTAINER 8
+#define INDICATOR_IME 32
+#define INDICATOR_IME_MAX 35
+#define INDICATOR_MAX 35
 #define SCI_INDICSETSTYLE 2080
 #define SCI_INDICGETSTYLE 2081
 #define SCI_INDICSETFORE 2082
 #define SCI_INDICGETFORE 2083
 #define SCI_INDICSETUNDER 2510
 #define SCI_INDICGETUNDER 2511
+#define SCI_INDICSETHOVERSTYLE 2680
+#define SCI_INDICGETHOVERSTYLE 2681
+#define SCI_INDICSETHOVERFORE 2682
+#define SCI_INDICGETHOVERFORE 2683
+#define SC_INDICVALUEBIT 0x1000000
+#define SC_INDICVALUEMASK 0xFFFFFF
+#define SC_INDICFLAG_VALUEFORE 1
+#define SCI_INDICSETFLAGS 2684
+#define SCI_INDICGETFLAGS 2685
 #define SCI_SETWHITESPACEFORE 2084
 #define SCI_SETWHITESPACEBACK 2085
-#define SCI_SETSTYLEBITS 2090
-#define SCI_GETSTYLEBITS 2091
+#define SCI_SETWHITESPACESIZE 2086
+#define SCI_GETWHITESPACESIZE 2087
 #define SCI_SETLINESTATE 2092
 #define SCI_GETLINESTATE 2093
 #define SCI_GETMAXLINESTATE 2094
@@ -259,6 +340,8 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_SETCARETLINEVISIBLE 2096
 #define SCI_GETCARETLINEBACK 2097
 #define SCI_SETCARETLINEBACK 2098
+#define SCI_GETCARETLINEFRAME 2704
+#define SCI_SETCARETLINEFRAME 2705
 #define SCI_STYLESETCHANGEABLE 2099
 #define SCI_AUTOCSHOW 2100
 #define SCI_AUTOCCANCEL 2101
@@ -297,6 +380,8 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_GETLINEINDENTATION 2127
 #define SCI_GETLINEINDENTPOSITION 2128
 #define SCI_GETCOLUMN 2129
+#define SCI_COUNTCHARACTERS 2633
+#define SCI_COUNTCODEUNITS 2715
 #define SCI_SETHSCROLLBAR 2130
 #define SCI_GETHSCROLLBAR 2131
 #define SC_IV_NONE 0
@@ -310,13 +395,13 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_GETLINEENDPOSITION 2136
 #define SCI_GETCODEPAGE 2137
 #define SCI_GETCARETFORE 2138
-#define SCI_GETUSEPALETTE 2139
 #define SCI_GETREADONLY 2140
 #define SCI_SETCURRENTPOS 2141
 #define SCI_SETSELECTIONSTART 2142
 #define SCI_GETSELECTIONSTART 2143
 #define SCI_SETSELECTIONEND 2144
 #define SCI_GETSELECTIONEND 2145
+#define SCI_SETEMPTYSELECTION 2556
 #define SCI_SETPRINTMAGNIFICATION 2146
 #define SCI_GETPRINTMAGNIFICATION 2147
 #define SC_PRINT_NORMAL 0
@@ -324,13 +409,16 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SC_PRINT_BLACKONWHITE 2
 #define SC_PRINT_COLOURONWHITE 3
 #define SC_PRINT_COLOURONWHITEDEFAULTBG 4
+#define SC_PRINT_SCREENCOLOURS 5
 #define SCI_SETPRINTCOLOURMODE 2148
 #define SCI_GETPRINTCOLOURMODE 2149
-#define SCFIND_WHOLEWORD 2
-#define SCFIND_MATCHCASE 4
+#define SCFIND_NONE 0x0
+#define SCFIND_WHOLEWORD 0x2
+#define SCFIND_MATCHCASE 0x4
 #define SCFIND_WORDSTART 0x00100000
 #define SCFIND_REGEXP 0x00200000
 #define SCFIND_POSIX 0x00400000
+#define SCFIND_CXX11REGEX 0x00800000
 #define SCI_FINDTEXT 2150
 #define SCI_FORMATRANGE 2151
 #define SCI_GETFIRSTVISIBLELINE 2152
@@ -351,6 +439,7 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_POSITIONFROMLINE 2167
 #define SCI_LINESCROLL 2168
 #define SCI_SCROLLCARET 2169
+#define SCI_SCROLLRANGE 2569
 #define SCI_REPLACESEL 2170
 #define SCI_SETREADONLY 2171
 #define SCI_NULL 2172
@@ -373,8 +462,16 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_GETCARETWIDTH 2189
 #define SCI_SETTARGETSTART 2190
 #define SCI_GETTARGETSTART 2191
+#define SCI_SETTARGETSTARTVIRTUALSPACE 2728
+#define SCI_GETTARGETSTARTVIRTUALSPACE 2729
 #define SCI_SETTARGETEND 2192
 #define SCI_GETTARGETEND 2193
+#define SCI_SETTARGETENDVIRTUALSPACE 2730
+#define SCI_GETTARGETENDVIRTUALSPACE 2731
+#define SCI_SETTARGETRANGE 2686
+#define SCI_GETTARGETTEXT 2687
+#define SCI_TARGETFROMSELECTION 2287
+#define SCI_TARGETWHOLEDOCUMENT 2690
 #define SCI_REPLACETARGET 2194
 #define SCI_REPLACETARGETRE 2195
 #define SCI_SEARCHINTARGET 2197
@@ -384,21 +481,19 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_CALLTIPCANCEL 2201
 #define SCI_CALLTIPACTIVE 2202
 #define SCI_CALLTIPPOSSTART 2203
+#define SCI_CALLTIPSETPOSSTART 2214
 #define SCI_CALLTIPSETHLT 2204
 #define SCI_CALLTIPSETBACK 2205
 #define SCI_CALLTIPSETFORE 2206
 #define SCI_CALLTIPSETFOREHLT 2207
 #define SCI_CALLTIPUSESTYLE 2212
+#define SCI_CALLTIPSETPOSITION 2213
 #define SCI_VISIBLEFROMDOCLINE 2220
 #define SCI_DOCLINEFROMVISIBLE 2221
 #define SCI_WRAPCOUNT 2235
 #define SC_FOLDLEVELBASE 0x400
 #define SC_FOLDLEVELWHITEFLAG 0x1000
 #define SC_FOLDLEVELHEADERFLAG 0x2000
-#define SC_FOLDLEVELBOXHEADERFLAG 0x4000
-#define SC_FOLDLEVELBOXFOOTERFLAG 0x8000
-#define SC_FOLDLEVELCONTRACTED 0x10000
-#define SC_FOLDLEVELUNINDENT 0x20000
 #define SC_FOLDLEVELNUMBERMASK 0x0FFF
 #define SCI_SETFOLDLEVEL 2222
 #define SCI_GETFOLDLEVEL 2223
@@ -407,16 +502,37 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_SHOWLINES 2226
 #define SCI_HIDELINES 2227
 #define SCI_GETLINEVISIBLE 2228
+#define SCI_GETALLLINESVISIBLE 2236
 #define SCI_SETFOLDEXPANDED 2229
 #define SCI_GETFOLDEXPANDED 2230
 #define SCI_TOGGLEFOLD 2231
+#define SCI_TOGGLEFOLDSHOWTEXT 2700
+#define SC_FOLDDISPLAYTEXT_HIDDEN 0
+#define SC_FOLDDISPLAYTEXT_STANDARD 1
+#define SC_FOLDDISPLAYTEXT_BOXED 2
+#define SCI_FOLDDISPLAYTEXTSETSTYLE 2701
+#define SCI_FOLDDISPLAYTEXTGETSTYLE 2707
+#define SCI_SETDEFAULTFOLDDISPLAYTEXT 2722
+#define SCI_GETDEFAULTFOLDDISPLAYTEXT 2723
+#define SC_FOLDACTION_CONTRACT 0
+#define SC_FOLDACTION_EXPAND 1
+#define SC_FOLDACTION_TOGGLE 2
+#define SCI_FOLDLINE 2237
+#define SCI_FOLDCHILDREN 2238
+#define SCI_EXPANDCHILDREN 2239
+#define SCI_FOLDALL 2662
 #define SCI_ENSUREVISIBLE 2232
+#define SC_AUTOMATICFOLD_SHOW 0x0001
+#define SC_AUTOMATICFOLD_CLICK 0x0002
+#define SC_AUTOMATICFOLD_CHANGE 0x0004
+#define SCI_SETAUTOMATICFOLD 2663
+#define SCI_GETAUTOMATICFOLD 2664
 #define SC_FOLDFLAG_LINEBEFORE_EXPANDED 0x0002
 #define SC_FOLDFLAG_LINEBEFORE_CONTRACTED 0x0004
 #define SC_FOLDFLAG_LINEAFTER_EXPANDED 0x0008
 #define SC_FOLDFLAG_LINEAFTER_CONTRACTED 0x0010
 #define SC_FOLDFLAG_LEVELNUMBERS 0x0040
-#define SC_FOLDFLAG_BOX 0x0001
+#define SC_FOLDFLAG_LINESTATE 0x0080
 #define SCI_SETFOLDFLAGS 2233
 #define SCI_ENSUREVISIBLEENFORCEPOLICY 2234
 #define SCI_SETTABINDENTS 2260
@@ -428,14 +544,23 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_GETMOUSEDWELLTIME 2265
 #define SCI_WORDSTARTPOSITION 2266
 #define SCI_WORDENDPOSITION 2267
+#define SCI_ISRANGEWORD 2691
+#define SC_IDLESTYLING_NONE 0
+#define SC_IDLESTYLING_TOVISIBLE 1
+#define SC_IDLESTYLING_AFTERVISIBLE 2
+#define SC_IDLESTYLING_ALL 3
+#define SCI_SETIDLESTYLING 2692
+#define SCI_GETIDLESTYLING 2693
 #define SC_WRAP_NONE 0
 #define SC_WRAP_WORD 1
 #define SC_WRAP_CHAR 2
+#define SC_WRAP_WHITESPACE 3
 #define SCI_SETWRAPMODE 2268
 #define SCI_GETWRAPMODE 2269
 #define SC_WRAPVISUALFLAG_NONE 0x0000
 #define SC_WRAPVISUALFLAG_END 0x0001
 #define SC_WRAPVISUALFLAG_START 0x0002
+#define SC_WRAPVISUALFLAG_MARGIN 0x0004
 #define SCI_SETWRAPVISUALFLAGS 2460
 #define SCI_GETWRAPVISUALFLAGS 2461
 #define SC_WRAPVISUALFLAGLOC_DEFAULT 0x0000
@@ -445,6 +570,12 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_GETWRAPVISUALFLAGSLOCATION 2463
 #define SCI_SETWRAPSTARTINDENT 2464
 #define SCI_GETWRAPSTARTINDENT 2465
+#define SC_WRAPINDENT_FIXED 0
+#define SC_WRAPINDENT_SAME 1
+#define SC_WRAPINDENT_INDENT 2
+#define SC_WRAPINDENT_DEEPINDENT 3
+#define SCI_SETWRAPINDENTMODE 2472
+#define SCI_GETWRAPINDENTMODE 2473
 #define SC_CACHE_NONE 0
 #define SC_CACHE_CARET 1
 #define SC_CACHE_PAGE 2
@@ -462,13 +593,32 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_SETVSCROLLBAR 2280
 #define SCI_GETVSCROLLBAR 2281
 #define SCI_APPENDTEXT 2282
-#define SCI_GETTWOPHASEDRAW 2283
-#define SCI_SETTWOPHASEDRAW 2284
-#define SCI_TARGETFROMSELECTION 2287
+#define SC_PHASES_ONE 0
+#define SC_PHASES_TWO 1
+#define SC_PHASES_MULTIPLE 2
+#define SCI_GETPHASESDRAW 2673
+#define SCI_SETPHASESDRAW 2674
+#define SC_EFF_QUALITY_MASK 0xF
+#define SC_EFF_QUALITY_DEFAULT 0
+#define SC_EFF_QUALITY_NON_ANTIALIASED 1
+#define SC_EFF_QUALITY_ANTIALIASED 2
+#define SC_EFF_QUALITY_LCD_OPTIMIZED 3
+#define SCI_SETFONTQUALITY 2611
+#define SCI_GETFONTQUALITY 2612
+#define SCI_SETFIRSTVISIBLELINE 2613
+#define SC_MULTIPASTE_ONCE 0
+#define SC_MULTIPASTE_EACH 1
+#define SCI_SETMULTIPASTE 2614
+#define SCI_GETMULTIPASTE 2615
+#define SCI_GETTAG 2616
 #define SCI_LINESJOIN 2288
 #define SCI_LINESSPLIT 2289
 #define SCI_SETFOLDMARGINCOLOUR 2290
 #define SCI_SETFOLDMARGINHICOLOUR 2291
+#define SC_ACCESSIBILITY_DISABLED 0
+#define SC_ACCESSIBILITY_ENABLED 1
+#define SCI_SETACCESSIBILITY 2702
+#define SCI_GETACCESSIBILITY 2703
 #define SCI_LINEDOWN 2300
 #define SCI_LINEDOWNEXTEND 2301
 #define SCI_LINEUP 2302
@@ -510,6 +660,7 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_LINECUT 2337
 #define SCI_LINEDELETE 2338
 #define SCI_LINETRANSPOSE 2339
+#define SCI_LINEREVERSE 2354
 #define SCI_LINEDUPLICATE 2404
 #define SCI_LOWERCASE 2340
 #define SCI_UPPERCASE 2341
@@ -530,8 +681,11 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_MOVECARETINSIDEVIEW 2401
 #define SCI_LINELENGTH 2350
 #define SCI_BRACEHIGHLIGHT 2351
+#define SCI_BRACEHIGHLIGHTINDICATOR 2498
 #define SCI_BRACEBADLIGHT 2352
+#define SCI_BRACEBADLIGHTINDICATOR 2499
 #define SCI_BRACEMATCH 2353
+#define SCI_BRACEMATCHNEXT 2369
 #define SCI_GETVIEWEOL 2355
 #define SCI_SETVIEWEOL 2356
 #define SCI_GETDOCPOINTER 2357
@@ -540,32 +694,50 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define EDGE_NONE 0
 #define EDGE_LINE 1
 #define EDGE_BACKGROUND 2
+#define EDGE_MULTILINE 3
 #define SCI_GETEDGECOLUMN 2360
 #define SCI_SETEDGECOLUMN 2361
 #define SCI_GETEDGEMODE 2362
 #define SCI_SETEDGEMODE 2363
 #define SCI_GETEDGECOLOUR 2364
 #define SCI_SETEDGECOLOUR 2365
+#define SCI_MULTIEDGEADDLINE 2694
+#define SCI_MULTIEDGECLEARALL 2695
+#define SCI_GETMULTIEDGECOLUMN 2749
 #define SCI_SEARCHANCHOR 2366
 #define SCI_SEARCHNEXT 2367
 #define SCI_SEARCHPREV 2368
 #define SCI_LINESONSCREEN 2370
+#define SC_POPUP_NEVER 0
+#define SC_POPUP_ALL 1
+#define SC_POPUP_TEXT 2
 #define SCI_USEPOPUP 2371
 #define SCI_SELECTIONISRECTANGLE 2372
 #define SCI_SETZOOM 2373
 #define SCI_GETZOOM 2374
+#define SC_DOCUMENTOPTION_DEFAULT 0
+#define SC_DOCUMENTOPTION_STYLES_NONE 0x1
+#define SC_DOCUMENTOPTION_TEXT_LARGE 0x100
 #define SCI_CREATEDOCUMENT 2375
 #define SCI_ADDREFDOCUMENT 2376
 #define SCI_RELEASEDOCUMENT 2377
+#define SCI_GETDOCUMENTOPTIONS 2379
 #define SCI_GETMODEVENTMASK 2378
+#define SCI_SETCOMMANDEVENTS 2717
+#define SCI_GETCOMMANDEVENTS 2718
 #define SCI_SETFOCUS 2380
 #define SCI_GETFOCUS 2381
+#define SC_STATUS_OK 0
+#define SC_STATUS_FAILURE 1
+#define SC_STATUS_BADALLOC 2
+#define SC_STATUS_WARN_START 1000
+#define SC_STATUS_WARN_REGEX 1001
 #define SCI_SETSTATUS 2382
 #define SCI_GETSTATUS 2383
 #define SCI_SETMOUSEDOWNCAPTURES 2384
 #define SCI_GETMOUSEDOWNCAPTURES 2385
-#define SC_CURSORNORMAL -1
-#define SC_CURSORWAIT 4
+#define SCI_SETMOUSEWHEELCAPTURES 2696
+#define SCI_GETMOUSEWHEELCAPTURES 2697
 #define SCI_SETCURSOR 2386
 #define SCI_GETCURSOR 2387
 #define SCI_SETCONTROLCHARSYMBOL 2388
@@ -605,13 +777,17 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_PARAUPEXTEND 2416
 #define SCI_POSITIONBEFORE 2417
 #define SCI_POSITIONAFTER 2418
+#define SCI_POSITIONRELATIVE 2670
+#define SCI_POSITIONRELATIVECODEUNITS 2716
 #define SCI_COPYRANGE 2419
 #define SCI_COPYTEXT 2420
 #define SC_SEL_STREAM 0
 #define SC_SEL_RECTANGLE 1
 #define SC_SEL_LINES 2
+#define SC_SEL_THIN 3
 #define SCI_SETSELECTIONMODE 2422
 #define SCI_GETSELECTIONMODE 2423
+#define SCI_GETMOVEEXTENDSSELECTION 2706
 #define SCI_GETLINESELSTARTPOSITION 2424
 #define SCI_GETLINESELENDPOSITION 2425
 #define SCI_LINEDOWNRECTEXTEND 2426
@@ -632,27 +808,48 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_WORDRIGHTEND 2441
 #define SCI_WORDRIGHTENDEXTEND 2442
 #define SCI_SETWHITESPACECHARS 2443
+#define SCI_GETWHITESPACECHARS 2647
+#define SCI_SETPUNCTUATIONCHARS 2648
+#define SCI_GETPUNCTUATIONCHARS 2649
 #define SCI_SETCHARSDEFAULT 2444
 #define SCI_AUTOCGETCURRENT 2445
+#define SCI_AUTOCGETCURRENTTEXT 2610
+#define SC_CASEINSENSITIVEBEHAVIOUR_RESPECTCASE 0
+#define SC_CASEINSENSITIVEBEHAVIOUR_IGNORECASE 1
+#define SCI_AUTOCSETCASEINSENSITIVEBEHAVIOUR 2634
+#define SCI_AUTOCGETCASEINSENSITIVEBEHAVIOUR 2635
+#define SC_MULTIAUTOC_ONCE 0
+#define SC_MULTIAUTOC_EACH 1
+#define SCI_AUTOCSETMULTI 2636
+#define SCI_AUTOCGETMULTI 2637
+#define SC_ORDER_PRESORTED 0
+#define SC_ORDER_PERFORMSORT 1
+#define SC_ORDER_CUSTOM 2
+#define SCI_AUTOCSETORDER 2660
+#define SCI_AUTOCGETORDER 2661
 #define SCI_ALLOCATE 2446
 #define SCI_TARGETASUTF8 2447
 #define SCI_SETLENGTHFORENCODE 2448
 #define SCI_ENCODEDFROMUTF8 2449
 #define SCI_FINDCOLUMN 2456
+#define SC_CARETSTICKY_OFF 0
+#define SC_CARETSTICKY_ON 1
+#define SC_CARETSTICKY_WHITESPACE 2
 #define SCI_GETCARETSTICKY 2457
 #define SCI_SETCARETSTICKY 2458
 #define SCI_TOGGLECARETSTICKY 2459
 #define SCI_SETPASTECONVERTENDINGS 2467
 #define SCI_GETPASTECONVERTENDINGS 2468
 #define SCI_SELECTIONDUPLICATE 2469
-#define SC_ALPHA_TRANSPARENT 0
-#define SC_ALPHA_OPAQUE 255
-#define SC_ALPHA_NOALPHA 256
 #define SCI_SETCARETLINEBACKALPHA 2470
 #define SCI_GETCARETLINEBACKALPHA 2471
 #define CARETSTYLE_INVISIBLE 0
 #define CARETSTYLE_LINE 1
 #define CARETSTYLE_BLOCK 2
+#define CARETSTYLE_OVERSTRIKE_BAR 0
+#define CARETSTYLE_OVERSTRIKE_BLOCK 0x10
+#define CARETSTYLE_INS_MASK 0xF
+#define CARETSTYLE_BLOCK_AFTER 0x100
 #define SCI_SETCARETSTYLE 2512
 #define SCI_GETCARETSTYLE 2513
 #define SCI_SETINDICATORCURRENT 2500
@@ -669,8 +866,159 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_GETPOSITIONCACHE 2515
 #define SCI_COPYALLOWLINE 2519
 #define SCI_GETCHARACTERPOINTER 2520
-#define SCI_SETKEYSUNICODE 2521
-#define SCI_GETKEYSUNICODE 2522
+#define SCI_GETRANGEPOINTER 2643
+#define SCI_GETGAPPOSITION 2644
+#define SCI_INDICSETALPHA 2523
+#define SCI_INDICGETALPHA 2524
+#define SCI_INDICSETOUTLINEALPHA 2558
+#define SCI_INDICGETOUTLINEALPHA 2559
+#define SCI_SETEXTRAASCENT 2525
+#define SCI_GETEXTRAASCENT 2526
+#define SCI_SETEXTRADESCENT 2527
+#define SCI_GETEXTRADESCENT 2528
+#define SCI_MARKERSYMBOLDEFINED 2529
+#define SCI_MARGINSETTEXT 2530
+#define SCI_MARGINGETTEXT 2531
+#define SCI_MARGINSETSTYLE 2532
+#define SCI_MARGINGETSTYLE 2533
+#define SCI_MARGINSETSTYLES 2534
+#define SCI_MARGINGETSTYLES 2535
+#define SCI_MARGINTEXTCLEARALL 2536
+#define SCI_MARGINSETSTYLEOFFSET 2537
+#define SCI_MARGINGETSTYLEOFFSET 2538
+#define SC_MARGINOPTION_NONE 0
+#define SC_MARGINOPTION_SUBLINESELECT 1
+#define SCI_SETMARGINOPTIONS 2539
+#define SCI_GETMARGINOPTIONS 2557
+#define SCI_ANNOTATIONSETTEXT 2540
+#define SCI_ANNOTATIONGETTEXT 2541
+#define SCI_ANNOTATIONSETSTYLE 2542
+#define SCI_ANNOTATIONGETSTYLE 2543
+#define SCI_ANNOTATIONSETSTYLES 2544
+#define SCI_ANNOTATIONGETSTYLES 2545
+#define SCI_ANNOTATIONGETLINES 2546
+#define SCI_ANNOTATIONCLEARALL 2547
+#define ANNOTATION_HIDDEN 0
+#define ANNOTATION_STANDARD 1
+#define ANNOTATION_BOXED 2
+#define ANNOTATION_INDENTED 3
+#define SCI_ANNOTATIONSETVISIBLE 2548
+#define SCI_ANNOTATIONGETVISIBLE 2549
+#define SCI_ANNOTATIONSETSTYLEOFFSET 2550
+#define SCI_ANNOTATIONGETSTYLEOFFSET 2551
+#define SCI_RELEASEALLEXTENDEDSTYLES 2552
+#define SCI_ALLOCATEEXTENDEDSTYLES 2553
+#define UNDO_NONE 0
+#define UNDO_MAY_COALESCE 1
+#define SCI_ADDUNDOACTION 2560
+#define SCI_CHARPOSITIONFROMPOINT 2561
+#define SCI_CHARPOSITIONFROMPOINTCLOSE 2562
+#define SCI_SETMOUSESELECTIONRECTANGULARSWITCH 2668
+#define SCI_GETMOUSESELECTIONRECTANGULARSWITCH 2669
+#define SCI_SETMULTIPLESELECTION 2563
+#define SCI_GETMULTIPLESELECTION 2564
+#define SCI_SETADDITIONALSELECTIONTYPING 2565
+#define SCI_GETADDITIONALSELECTIONTYPING 2566
+#define SCI_SETADDITIONALCARETSBLINK 2567
+#define SCI_GETADDITIONALCARETSBLINK 2568
+#define SCI_SETADDITIONALCARETSVISIBLE 2608
+#define SCI_GETADDITIONALCARETSVISIBLE 2609
+#define SCI_GETSELECTIONS 2570
+#define SCI_GETSELECTIONEMPTY 2650
+#define SCI_CLEARSELECTIONS 2571
+#define SCI_SETSELECTION 2572
+#define SCI_ADDSELECTION 2573
+#define SCI_DROPSELECTIONN 2671
+#define SCI_SETMAINSELECTION 2574
+#define SCI_GETMAINSELECTION 2575
+#define SCI_SETSELECTIONNCARET 2576
+#define SCI_GETSELECTIONNCARET 2577
+#define SCI_SETSELECTIONNANCHOR 2578
+#define SCI_GETSELECTIONNANCHOR 2579
+#define SCI_SETSELECTIONNCARETVIRTUALSPACE 2580
+#define SCI_GETSELECTIONNCARETVIRTUALSPACE 2581
+#define SCI_SETSELECTIONNANCHORVIRTUALSPACE 2582
+#define SCI_GETSELECTIONNANCHORVIRTUALSPACE 2583
+#define SCI_SETSELECTIONNSTART 2584
+#define SCI_GETSELECTIONNSTART 2585
+#define SCI_GETSELECTIONNSTARTVIRTUALSPACE 2726
+#define SCI_SETSELECTIONNEND 2586
+#define SCI_GETSELECTIONNENDVIRTUALSPACE 2727
+#define SCI_GETSELECTIONNEND 2587
+#define SCI_SETRECTANGULARSELECTIONCARET 2588
+#define SCI_GETRECTANGULARSELECTIONCARET 2589
+#define SCI_SETRECTANGULARSELECTIONANCHOR 2590
+#define SCI_GETRECTANGULARSELECTIONANCHOR 2591
+#define SCI_SETRECTANGULARSELECTIONCARETVIRTUALSPACE 2592
+#define SCI_GETRECTANGULARSELECTIONCARETVIRTUALSPACE 2593
+#define SCI_SETRECTANGULARSELECTIONANCHORVIRTUALSPACE 2594
+#define SCI_GETRECTANGULARSELECTIONANCHORVIRTUALSPACE 2595
+#define SCVS_NONE 0
+#define SCVS_RECTANGULARSELECTION 1
+#define SCVS_USERACCESSIBLE 2
+#define SCVS_NOWRAPLINESTART 4
+#define SCI_SETVIRTUALSPACEOPTIONS 2596
+#define SCI_GETVIRTUALSPACEOPTIONS 2597
+#define SCI_SETRECTANGULARSELECTIONMODIFIER 2598
+#define SCI_GETRECTANGULARSELECTIONMODIFIER 2599
+#define SCI_SETADDITIONALSELFORE 2600
+#define SCI_SETADDITIONALSELBACK 2601
+#define SCI_SETADDITIONALSELALPHA 2602
+#define SCI_GETADDITIONALSELALPHA 2603
+#define SCI_SETADDITIONALCARETFORE 2604
+#define SCI_GETADDITIONALCARETFORE 2605
+#define SCI_ROTATESELECTION 2606
+#define SCI_SWAPMAINANCHORCARET 2607
+#define SCI_MULTIPLESELECTADDNEXT 2688
+#define SCI_MULTIPLESELECTADDEACH 2689
+#define SCI_CHANGELEXERSTATE 2617
+#define SCI_CONTRACTEDFOLDNEXT 2618
+#define SCI_VERTICALCENTRECARET 2619
+#define SCI_MOVESELECTEDLINESUP 2620
+#define SCI_MOVESELECTEDLINESDOWN 2621
+#define SCI_SETIDENTIFIER 2622
+#define SCI_GETIDENTIFIER 2623
+#define SCI_RGBAIMAGESETWIDTH 2624
+#define SCI_RGBAIMAGESETHEIGHT 2625
+#define SCI_RGBAIMAGESETSCALE 2651
+#define SCI_MARKERDEFINERGBAIMAGE 2626
+#define SCI_REGISTERRGBAIMAGE 2627
+#define SCI_SCROLLTOSTART 2628
+#define SCI_SCROLLTOEND 2629
+#define SC_TECHNOLOGY_DEFAULT 0
+#define SC_TECHNOLOGY_DIRECTWRITE 1
+#define SC_TECHNOLOGY_DIRECTWRITERETAIN 2
+#define SC_TECHNOLOGY_DIRECTWRITEDC 3
+#define SCI_SETTECHNOLOGY 2630
+#define SCI_GETTECHNOLOGY 2631
+#define SCI_CREATELOADER 2632
+#define SCI_FINDINDICATORSHOW 2640
+#define SCI_FINDINDICATORFLASH 2641
+#define SCI_FINDINDICATORHIDE 2642
+#define SCI_VCHOMEDISPLAY 2652
+#define SCI_VCHOMEDISPLAYEXTEND 2653
+#define SCI_GETCARETLINEVISIBLEALWAYS 2654
+#define SCI_SETCARETLINEVISIBLEALWAYS 2655
+#define SC_LINE_END_TYPE_DEFAULT 0
+#define SC_LINE_END_TYPE_UNICODE 1
+#define SCI_SETLINEENDTYPESALLOWED 2656
+#define SCI_GETLINEENDTYPESALLOWED 2657
+#define SCI_GETLINEENDTYPESACTIVE 2658
+#define SCI_SETREPRESENTATION 2665
+#define SCI_GETREPRESENTATION 2666
+#define SCI_CLEARREPRESENTATION 2667
+#define SCI_EOLANNOTATIONSETTEXT 2740
+#define SCI_EOLANNOTATIONGETTEXT 2741
+#define SCI_EOLANNOTATIONSETSTYLE 2742
+#define SCI_EOLANNOTATIONGETSTYLE 2743
+#define SCI_EOLANNOTATIONCLEARALL 2744
+#define EOLANNOTATION_HIDDEN 0
+#define EOLANNOTATION_STANDARD 1
+#define EOLANNOTATION_BOXED 2
+#define SCI_EOLANNOTATIONSETVISIBLE 2745
+#define SCI_EOLANNOTATIONGETVISIBLE 2746
+#define SCI_EOLANNOTATIONSETSTYLEOFFSET 2747
+#define SCI_EOLANNOTATIONGETSTYLEOFFSET 2748
 #define SCI_STARTRECORD 3001
 #define SCI_STOPRECORD 3002
 #define SCI_SETLEXER 4001
@@ -684,7 +1032,31 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCI_GETPROPERTY 4008
 #define SCI_GETPROPERTYEXPANDED 4009
 #define SCI_GETPROPERTYINT 4010
-#define SCI_GETSTYLEBITSNEEDED 4011
+#define SCI_GETLEXERLANGUAGE 4012
+#define SCI_PRIVATELEXERCALL 4013
+#define SCI_PROPERTYNAMES 4014
+#define SC_TYPE_BOOLEAN 0
+#define SC_TYPE_INTEGER 1
+#define SC_TYPE_STRING 2
+#define SCI_PROPERTYTYPE 4015
+#define SCI_DESCRIBEPROPERTY 4016
+#define SCI_DESCRIBEKEYWORDSETS 4017
+#define SCI_GETLINEENDTYPESSUPPORTED 4018
+#define SCI_ALLOCATESUBSTYLES 4020
+#define SCI_GETSUBSTYLESSTART 4021
+#define SCI_GETSUBSTYLESLENGTH 4022
+#define SCI_GETSTYLEFROMSUBSTYLE 4027
+#define SCI_GETPRIMARYSTYLEFROMSTYLE 4028
+#define SCI_FREESUBSTYLES 4023
+#define SCI_SETIDENTIFIERS 4024
+#define SCI_DISTANCETOSECONDARYSTYLES 4025
+#define SCI_GETSUBSTYLEBASES 4026
+#define SCI_GETNAMEDSTYLES 4029
+#define SCI_NAMEOFSTYLE 4030
+#define SCI_TAGSOFSTYLE 4031
+#define SCI_DESCRIPTIONOFSTYLE 4032
+#define SCI_SETILEXER 4033
+#define SC_MOD_NONE 0x0
 #define SC_MOD_INSERTTEXT 0x1
 #define SC_MOD_DELETETEXT 0x2
 #define SC_MOD_CHANGESTYLE 0x4
@@ -701,7 +1073,18 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SC_STARTACTION 0x2000
 #define SC_MOD_CHANGEINDICATOR 0x4000
 #define SC_MOD_CHANGELINESTATE 0x8000
-#define SC_MODEVENTMASKALL 0xFFFF
+#define SC_MOD_CHANGEMARGIN 0x10000
+#define SC_MOD_CHANGEANNOTATION 0x20000
+#define SC_MOD_CONTAINER 0x40000
+#define SC_MOD_LEXERSTATE 0x80000
+#define SC_MOD_INSERTCHECK 0x100000
+#define SC_MOD_CHANGETABSTOPS 0x200000
+#define SC_MOD_CHANGEEOLANNOTATION 0x400000
+#define SC_MODEVENTMASKALL 0x7FFFFF
+#define SC_UPDATE_CONTENT 0x1
+#define SC_UPDATE_SELECTION 0x2
+#define SC_UPDATE_V_SCROLL 0x4
+#define SC_UPDATE_H_SCROLL 0x8
 #define SCEN_CHANGE 768
 #define SCEN_SETFOCUS 512
 #define SCEN_KILLFOCUS 256
@@ -729,6 +1112,16 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCMOD_SHIFT 1
 #define SCMOD_CTRL 2
 #define SCMOD_ALT 4
+#define SCMOD_SUPER 8
+#define SCMOD_META 16
+#define SC_AC_FILLUP 1
+#define SC_AC_DOUBLECLICK 2
+#define SC_AC_TAB 3
+#define SC_AC_NEWLINE 4
+#define SC_AC_COMMAND 5
+#define SC_CHARACTERSOURCE_DIRECT_INPUT 0
+#define SC_CHARACTERSOURCE_TENTATIVE_INPUT 1
+#define SC_CHARACTERSOURCE_IME_RESULT 2
 #define SCN_STYLENEEDED 2000
 #define SCN_CHARADDED 2001
 #define SCN_SAVEPOINTREACHED 2002
@@ -754,94 +1147,150 @@ typedef sptr_t (*SciFnDirect)(sptr_t ptr, unsigned int iMessage, uptr_t wParam,
 #define SCN_INDICATORCLICK 2023
 #define SCN_INDICATORRELEASE 2024
 #define SCN_AUTOCCANCELLED 2025
-//--Autogenerated -- end of section automatically generated from Scintilla.iface
-
-// These structures are defined to be exactly the same shape as the Win32
-// CHARRANGE, TEXTRANGE, FINDTEXTEX, FORMATRANGE, and NMHDR structs.
-// So older code that treats Scintilla as a RichEdit will work.
+#define SCN_AUTOCCHARDELETED 2026
+#define SCN_HOTSPOTRELEASECLICK 2027
+#define SCN_FOCUSIN 2028
+#define SCN_FOCUSOUT 2029
+#define SCN_AUTOCCOMPLETED 2030
+#define SCN_MARGINRIGHTCLICK 2031
+#define SCN_AUTOCSELECTIONCHANGE 2032
+#ifndef SCI_DISABLE_PROVISIONAL
+#define SC_BIDIRECTIONAL_DISABLED 0
+#define SC_BIDIRECTIONAL_L2R 1
+#define SC_BIDIRECTIONAL_R2L 2
+#define SCI_GETBIDIRECTIONAL 2708
+#define SCI_SETBIDIRECTIONAL 2709
+#define SC_LINECHARACTERINDEX_NONE 0
+#define SC_LINECHARACTERINDEX_UTF32 1
+#define SC_LINECHARACTERINDEX_UTF16 2
+#define SCI_GETLINECHARACTERINDEX 2710
+#define SCI_ALLOCATELINECHARACTERINDEX 2711
+#define SCI_RELEASELINECHARACTERINDEX 2712
+#define SCI_LINEFROMINDEXPOSITION 2713
+#define SCI_INDEXPOSITIONFROMLINE 2714
+#endif
+/* --Autogenerated -- end of section automatically generated from Scintilla.iface */
 
-#ifdef SCI_NAMESPACE
-namespace Scintilla {
 #endif
 
-struct CharacterRange {
-	long cpMin;
-	long cpMax;
+/* These structures are defined to be exactly the same shape as the Win32
+ * CHARRANGE, TEXTRANGE, FINDTEXTEX, FORMATRANGE, and NMHDR structs.
+ * So older code that treats Scintilla as a RichEdit will work. */
+
+struct Sci_CharacterRange {
+	Sci_PositionCR cpMin;
+	Sci_PositionCR cpMax;
 };
 
-struct TextRange {
-	struct CharacterRange chrg;
+struct Sci_TextRange {
+	struct Sci_CharacterRange chrg;
 	char *lpstrText;
 };
 
-struct TextToFind {
-	struct CharacterRange chrg;
-	char *lpstrText;
-	struct CharacterRange chrgText;
+struct Sci_TextToFind {
+	struct Sci_CharacterRange chrg;
+	const char *lpstrText;
+	struct Sci_CharacterRange chrgText;
 };
 
-#ifdef PLATFORM_H
+typedef void *Sci_SurfaceID;
+
+struct Sci_Rectangle {
+	int left;
+	int top;
+	int right;
+	int bottom;
+};
 
-// This structure is used in printing and requires some of the graphics types
-// from Platform.h.  Not needed by most client code.
+/* This structure is used in printing and requires some of the graphics types
+ * from Platform.h.  Not needed by most client code. */
 
-struct RangeToFormat {
-	SurfaceID hdc;
-	SurfaceID hdcTarget;
-	PRectangle rc;
-	PRectangle rcPage;
-	CharacterRange chrg;
+struct Sci_RangeToFormat {
+	Sci_SurfaceID hdc;
+	Sci_SurfaceID hdcTarget;
+	struct Sci_Rectangle rc;
+	struct Sci_Rectangle rcPage;
+	struct Sci_CharacterRange chrg;
 };
 
+#ifndef __cplusplus
+/* For the GTK+ platform, g-ir-scanner needs to have these typedefs. This
+ * is not required in C++ code and actually seems to break ScintillaEditPy */
+typedef struct Sci_NotifyHeader Sci_NotifyHeader;
+typedef struct SCNotification SCNotification;
 #endif
 
-struct NotifyHeader {
-	// Compatible with Windows NMHDR.
-	// hwndFrom is really an environment specific window handle or pointer
-	// but most clients of Scintilla.h do not have this type visible.
+struct Sci_NotifyHeader {
+	/* Compatible with Windows NMHDR.
+	 * hwndFrom is really an environment specific window handle or pointer
+	 * but most clients of Scintilla.h do not have this type visible. */
 	void *hwndFrom;
 	uptr_t idFrom;
 	unsigned int code;
 };
 
 struct SCNotification {
-	struct NotifyHeader nmhdr;
-	int position;	// SCN_STYLENEEDED, SCN_MODIFIED, SCN_DWELLSTART, SCN_DWELLEND
-	int ch;		// SCN_CHARADDED, SCN_KEY
-	int modifiers;	// SCN_KEY
-	int modificationType;	// SCN_MODIFIED
-	const char *text;	// SCN_MODIFIED, SCN_USERLISTSELECTION, SCN_AUTOCSELECTION
-	int length;		// SCN_MODIFIED
-	int linesAdded;	// SCN_MODIFIED
-	int message;	// SCN_MACRORECORD
-	uptr_t wParam;	// SCN_MACRORECORD
-	sptr_t lParam;	// SCN_MACRORECORD
-	int line;		// SCN_MODIFIED
-	int foldLevelNow;	// SCN_MODIFIED
-	int foldLevelPrev;	// SCN_MODIFIED
-	int margin;		// SCN_MARGINCLICK
-	int listType;	// SCN_USERLISTSELECTION
-	int x;			// SCN_DWELLSTART, SCN_DWELLEND
-	int y;		// SCN_DWELLSTART, SCN_DWELLEND
-};
+	Sci_NotifyHeader nmhdr;
+	Sci_Position position;
+	/* SCN_STYLENEEDED, SCN_DOUBLECLICK, SCN_MODIFIED, SCN_MARGINCLICK, */
+	/* SCN_NEEDSHOWN, SCN_DWELLSTART, SCN_DWELLEND, SCN_CALLTIPCLICK, */
+	/* SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK, SCN_HOTSPOTRELEASECLICK, */
+	/* SCN_INDICATORCLICK, SCN_INDICATORRELEASE, */
+	/* SCN_USERLISTSELECTION, SCN_AUTOCSELECTION */
 
-#ifdef SCI_NAMESPACE
-}
-#endif
+	int ch;
+	/* SCN_CHARADDED, SCN_KEY, SCN_AUTOCCOMPLETED, SCN_AUTOCSELECTION, */
+	/* SCN_USERLISTSELECTION */
+	int modifiers;
+	/* SCN_KEY, SCN_DOUBLECLICK, SCN_HOTSPOTCLICK, SCN_HOTSPOTDOUBLECLICK, */
+	/* SCN_HOTSPOTRELEASECLICK, SCN_INDICATORCLICK, SCN_INDICATORRELEASE, */
 
-// Deprecation section listing all API features that are deprecated and will
-// will be removed completely in a future version.
-// To enable these features define INCLUDE_DEPRECATED_FEATURES
+	int modificationType;	/* SCN_MODIFIED */
+	const char *text;
+	/* SCN_MODIFIED, SCN_USERLISTSELECTION, SCN_AUTOCSELECTION, SCN_URIDROPPED */
+
+	Sci_Position length;		/* SCN_MODIFIED */
+	Sci_Position linesAdded;	/* SCN_MODIFIED */
+	int message;	/* SCN_MACRORECORD */
+	uptr_t wParam;	/* SCN_MACRORECORD */
+	sptr_t lParam;	/* SCN_MACRORECORD */
+	Sci_Position line;		/* SCN_MODIFIED */
+	int foldLevelNow;	/* SCN_MODIFIED */
+	int foldLevelPrev;	/* SCN_MODIFIED */
+	int margin;		/* SCN_MARGINCLICK */
+	int listType;	/* SCN_USERLISTSELECTION */
+	int x;			/* SCN_DWELLSTART, SCN_DWELLEND */
+	int y;		/* SCN_DWELLSTART, SCN_DWELLEND */
+	int token;		/* SCN_MODIFIED with SC_MOD_CONTAINER */
+	Sci_Position annotationLinesAdded;	/* SCN_MODIFIED with SC_MOD_CHANGEANNOTATION */
+	int updated;	/* SCN_UPDATEUI */
+	int listCompletionMethod;
+	/* SCN_AUTOCSELECTION, SCN_AUTOCCOMPLETED, SCN_USERLISTSELECTION, */
+	int characterSource;	/* SCN_CHARADDED */
+};
 
 #ifdef INCLUDE_DEPRECATED_FEATURES
 
-#define SCI_SETCARETPOLICY 2369
-#define CARET_CENTER 0x02
-#define CARET_XEVEN 0x08
-#define CARET_XJUMPS 0x10
+#define SCI_SETKEYSUNICODE 2521
+#define SCI_GETKEYSUNICODE 2522
+
+#define SCI_GETTWOPHASEDRAW 2283
+#define SCI_SETTWOPHASEDRAW 2284
 
-#define SCN_POSCHANGED 2012
-#define SCN_CHECKBRACE 2007
+#define CharacterRange Sci_CharacterRange
+#define TextRange Sci_TextRange
+#define TextToFind Sci_TextToFind
+#define RangeToFormat Sci_RangeToFormat
+#define NotifyHeader Sci_NotifyHeader
+
+#define SCI_SETSTYLEBITS 2090
+#define SCI_GETSTYLEBITS 2091
+#define SCI_GETSTYLEBITSNEEDED 4011
+
+#define INDIC0_MASK 0x20
+#define INDIC1_MASK 0x40
+#define INDIC2_MASK 0x80
+#define INDICS_MASK 0xE0
 
 #endif
 
diff --git a/Pythonwin/Scintilla/include/Scintilla.iface b/Pythonwin/Scintilla/include/Scintilla.iface
new file mode 100644
index 000000000..2c044d1a8
--- /dev/null
+++ b/Pythonwin/Scintilla/include/Scintilla.iface
@@ -0,0 +1,5417 @@
+## First line may be used for shbang
+
+## This file defines the interface to Scintilla
+
+## Copyright 2000-2003 by Neil Hodgson <neilh@scintilla.org>
+## The License.txt file describes the conditions under which this software may be distributed.
+
+## A line starting with ## is a pure comment and should be stripped by readers.
+## A line starting with #! is for future shbang use
+## A line starting with # followed by a space is a documentation comment and refers
+## to the next feature definition.
+
+## Each feature is defined by a line starting with fun, get, set, val, evt, enu, lex, or ali.
+##     cat -> start a category
+##     fun -> a function
+##     get -> a property get function
+##     set -> a property set function
+##     val -> definition of a constant
+##     evt -> an event
+##     enu -> associate an enumeration with a set of vals with a prefix
+##     lex -> associate a lexer with the lexical classes it produces
+##     ali -> add an alias for a val, commonly adding '_' to separate words
+##
+## All other feature names should be ignored. They may be defined in the future.
+## A property may have a set function, a get function or both. Each will have
+## "Get" or "Set" in their names and the corresponding name will have the obvious switch.
+## A property may be subscripted, in which case the first parameter is the subscript.
+## fun, get, and set features have a strict syntax:
+## <featureType><ws><returnType><ws><name>[=<number](<param>,<param>)
+## where <ws> stands for white space.
+## param may be empty (null value) or is <paramType><ws><paramName>[=<value>]
+## Additional white space is allowed between elements.
+## The syntax for evt is <featureType><ws><returnType><ws><name>[=<number]([<param>[,<param>]*])
+## Feature names that contain an underscore are defined by Windows, so in these
+## cases, using the Windows definition is preferred where available.
+## The feature numbers are stable so features will not be renumbered.
+## Features may be removed but they will go through a period of deprecation
+## before removal which is signalled by moving them into the Deprecated category.
+##
+## enu has the syntax enu<ws><enumeration>=<prefix>[<ws><prefix>]* where all the val
+## features in this file starting with a given <prefix> are considered part of the
+## enumeration.
+##
+## lex has the syntax lex<ws><name>=<lexerVal><ws><prefix>[<ws><prefix>]*
+## where name is a reasonably capitalised (Python, XML) identifier or UI name,
+## lexerVal is the val used to specify the lexer, and the list of prefixes is similar
+## to enu. The name may not be the same as that used within the lexer so the lexerVal
+## should be used to tie these entities together.
+
+## Types: Never start with a capital letter
+##     void
+##     int
+##     bool -> integer, 1=true, 0=false
+##     position -> intptr_t position in a document
+##     line -> intptr_t line in a document
+##     colour -> colour integer containing red, green and blue bytes.
+##     string -> pointer to const character
+##     stringresult -> pointer to character, NULL-> return size of result
+##     cells -> pointer to array of cells, each cell containing a style byte and character byte
+##     pointer -> void* pointer that may point to a document, loader, internal text storage or similar
+##     textrange -> range of a min and a max position with an output string
+##     findtext -> searchrange, text -> foundposition
+##     keymod -> integer containing key in low half and modifiers in high half
+##     formatrange
+## Enumeration types always start with a capital letter
+## Types no longer used:
+##     findtextex -> searchrange
+##     charrange -> range of a min and a max position
+##     charrangeresult -> like charrange, but output param
+##     countedstring
+##     point -> x,y
+##     pointresult  -> like point, but output param
+##     rectangle -> left,top,right,bottom
+## Client code should ignore definitions containing types it does not understand, except
+## for possibly #defining the constants
+
+## Line numbers and positions start at 0.
+## String arguments may contain NUL ('\0') characters where the calls provide a length
+## argument and retrieve NUL characters. APIs marked as NUL-terminated also have a
+## NUL appended but client code should calculate the size that will be returned rather
+## than relying upon the NUL whenever possible. Allow for the extra NUL character when
+## allocating buffers. The size to allocate for a stringresult (not including NUL) can be
+## determined by calling with a NULL (0) pointer.
+
+cat Basics
+
+################################################
+## For Scintilla.h
+val INVALID_POSITION=-1
+# Define start of Scintilla messages to be greater than all Windows edit (EM_*) messages
+# as many EM_ messages can be used although that use is deprecated.
+val SCI_START=2000
+val SCI_OPTIONAL_START=3000
+val SCI_LEXER_START=4000
+
+# Add text to the document at current position.
+fun void AddText=2001(position length, string text)
+
+# Add array of cells to document.
+fun void AddStyledText=2002(position length, cells c)
+
+# Insert string at a position.
+fun void InsertText=2003(position pos, string text)
+
+# Change the text that is being inserted in response to SC_MOD_INSERTCHECK
+fun void ChangeInsertion=2672(position length, string text)
+
+# Delete all text in the document.
+fun void ClearAll=2004(,)
+
+# Delete a range of text in the document.
+fun void DeleteRange=2645(position start, position lengthDelete)
+
+# Set all style bytes to 0, remove all folding information.
+fun void ClearDocumentStyle=2005(,)
+
+# Returns the number of bytes in the document.
+get position GetLength=2006(,)
+
+# Returns the character byte at the position.
+get int GetCharAt=2007(position pos,)
+
+# Returns the position of the caret.
+get position GetCurrentPos=2008(,)
+
+# Returns the position of the opposite end of the selection to the caret.
+get position GetAnchor=2009(,)
+
+# Returns the style byte at the position.
+get int GetStyleAt=2010(position pos,)
+
+# Redoes the next action on the undo history.
+fun void Redo=2011(,)
+
+# Choose between collecting actions into the undo
+# history and discarding them.
+set void SetUndoCollection=2012(bool collectUndo,)
+
+# Select all the text in the document.
+fun void SelectAll=2013(,)
+
+# Remember the current position in the undo history as the position
+# at which the document was saved.
+fun void SetSavePoint=2014(,)
+
+# Retrieve a buffer of cells.
+# Returns the number of bytes in the buffer not including terminating NULs.
+fun position GetStyledText=2015(, textrange tr)
+
+# Are there any redoable actions in the undo history?
+fun bool CanRedo=2016(,)
+
+# Retrieve the line number at which a particular marker is located.
+fun line MarkerLineFromHandle=2017(int markerHandle,)
+
+# Delete a marker.
+fun void MarkerDeleteHandle=2018(int markerHandle,)
+
+# Retrieve marker handles of a line
+fun int MarkerHandleFromLine=2732(line line, int which)
+
+# Retrieve marker number of a marker handle
+fun int MarkerNumberFromLine=2733(line line, int which)
+
+# Is undo history being collected?
+get bool GetUndoCollection=2019(,)
+
+enu WhiteSpace=SCWS_
+val SCWS_INVISIBLE=0
+val SCWS_VISIBLEALWAYS=1
+val SCWS_VISIBLEAFTERINDENT=2
+val SCWS_VISIBLEONLYININDENT=3
+
+ali SCWS_VISIBLEALWAYS=VISIBLE_ALWAYS
+ali SCWS_VISIBLEAFTERINDENT=VISIBLE_AFTER_INDENT
+ali SCWS_VISIBLEONLYININDENT=VISIBLE_ONLY_IN_INDENT
+
+# Are white space characters currently visible?
+# Returns one of SCWS_* constants.
+get WhiteSpace GetViewWS=2020(,)
+
+# Make white space characters invisible, always visible or visible outside indentation.
+set void SetViewWS=2021(WhiteSpace viewWS,)
+
+enu TabDrawMode=SCTD_
+val SCTD_LONGARROW=0
+val SCTD_STRIKEOUT=1
+
+ali SCTD_LONGARROW=LONG_ARROW
+ali SCTD_STRIKEOUT=STRIKE_OUT
+
+# Retrieve the current tab draw mode.
+# Returns one of SCTD_* constants.
+get TabDrawMode GetTabDrawMode=2698(,)
+
+# Set how tabs are drawn when visible.
+set void SetTabDrawMode=2699(TabDrawMode tabDrawMode,)
+
+# Find the position from a point within the window.
+fun position PositionFromPoint=2022(int x, int y)
+
+# Find the position from a point within the window but return
+# INVALID_POSITION if not close to text.
+fun position PositionFromPointClose=2023(int x, int y)
+
+# Set caret to start of a line and ensure it is visible.
+fun void GotoLine=2024(line line,)
+
+# Set caret to a position and ensure it is visible.
+fun void GotoPos=2025(position caret,)
+
+# Set the selection anchor to a position. The anchor is the opposite
+# end of the selection from the caret.
+set void SetAnchor=2026(position anchor,)
+
+# Retrieve the text of the line containing the caret.
+# Returns the index of the caret on the line.
+# Result is NUL-terminated.
+fun position GetCurLine=2027(position length, stringresult text)
+
+# Retrieve the position of the last correctly styled character.
+get position GetEndStyled=2028(,)
+
+enu EndOfLine=SC_EOL_
+val SC_EOL_CRLF=0
+val SC_EOL_CR=1
+val SC_EOL_LF=2
+
+ali SC_EOL_CRLF=CR_LF
+
+# Convert all line endings in the document to one mode.
+fun void ConvertEOLs=2029(EndOfLine eolMode,)
+
+# Retrieve the current end of line mode - one of CRLF, CR, or LF.
+get EndOfLine GetEOLMode=2030(,)
+
+# Set the current end of line mode.
+set void SetEOLMode=2031(EndOfLine eolMode,)
+
+# Set the current styling position to start.
+# The unused parameter is no longer used and should be set to 0.
+fun void StartStyling=2032(position start, int unused)
+
+# Change style from current styling position for length characters to a style
+# and move the current styling position to after this newly styled segment.
+fun void SetStyling=2033(position length, int style)
+
+# Is drawing done first into a buffer or direct to the screen?
+get bool GetBufferedDraw=2034(,)
+
+# If drawing is buffered then each line of text is drawn into a bitmap buffer
+# before drawing it to the screen to avoid flicker.
+set void SetBufferedDraw=2035(bool buffered,)
+
+# Change the visible size of a tab to be a multiple of the width of a space character.
+set void SetTabWidth=2036(int tabWidth,)
+
+# Retrieve the visible size of a tab.
+get int GetTabWidth=2121(,)
+
+# Set the minimum visual width of a tab.
+set void SetTabMinimumWidth=2724(int pixels,)
+
+# Get the minimum visual width of a tab.
+get int GetTabMinimumWidth=2725(,)
+
+# Clear explicit tabstops on a line.
+fun void ClearTabStops=2675(line line,)
+
+# Add an explicit tab stop for a line.
+fun void AddTabStop=2676(line line, int x)
+
+# Find the next explicit tab stop position on a line after a position.
+fun int GetNextTabStop=2677(line line, int x)
+
+# The SC_CP_UTF8 value can be used to enter Unicode mode.
+# This is the same value as CP_UTF8 in Windows
+val SC_CP_UTF8=65001
+
+# Set the code page used to interpret the bytes of the document as characters.
+# The SC_CP_UTF8 value can be used to enter Unicode mode.
+set void SetCodePage=2037(int codePage,)
+
+enu IMEInteraction=SC_IME_
+val SC_IME_WINDOWED=0
+val SC_IME_INLINE=1
+
+# Is the IME displayed in a window or inline?
+get IMEInteraction GetIMEInteraction=2678(,)
+
+# Choose to display the IME in a window or inline.
+set void SetIMEInteraction=2679(IMEInteraction imeInteraction,)
+
+enu Alpha=SC_ALPHA_
+val SC_ALPHA_TRANSPARENT=0
+val SC_ALPHA_OPAQUE=255
+val SC_ALPHA_NOALPHA=256
+
+ali SC_ALPHA_NOALPHA=NO_ALPHA
+
+enu CursorShape=SC_CURSOR
+val SC_CURSORNORMAL=-1
+val SC_CURSORARROW=2
+val SC_CURSORWAIT=4
+val SC_CURSORREVERSEARROW=7
+
+ali SC_CURSORREVERSEARROW=REVERSE_ARROW
+
+enu MarkerSymbol=SC_MARK_
+val MARKER_MAX=31
+val SC_MARK_CIRCLE=0
+val SC_MARK_ROUNDRECT=1
+val SC_MARK_ARROW=2
+val SC_MARK_SMALLRECT=3
+val SC_MARK_SHORTARROW=4
+val SC_MARK_EMPTY=5
+val SC_MARK_ARROWDOWN=6
+val SC_MARK_MINUS=7
+val SC_MARK_PLUS=8
+
+# Shapes used for outlining column.
+val SC_MARK_VLINE=9
+val SC_MARK_LCORNER=10
+val SC_MARK_TCORNER=11
+val SC_MARK_BOXPLUS=12
+val SC_MARK_BOXPLUSCONNECTED=13
+val SC_MARK_BOXMINUS=14
+val SC_MARK_BOXMINUSCONNECTED=15
+val SC_MARK_LCORNERCURVE=16
+val SC_MARK_TCORNERCURVE=17
+val SC_MARK_CIRCLEPLUS=18
+val SC_MARK_CIRCLEPLUSCONNECTED=19
+val SC_MARK_CIRCLEMINUS=20
+val SC_MARK_CIRCLEMINUSCONNECTED=21
+
+# Invisible mark that only sets the line background colour.
+val SC_MARK_BACKGROUND=22
+val SC_MARK_DOTDOTDOT=23
+val SC_MARK_ARROWS=24
+val SC_MARK_PIXMAP=25
+val SC_MARK_FULLRECT=26
+val SC_MARK_LEFTRECT=27
+val SC_MARK_AVAILABLE=28
+val SC_MARK_UNDERLINE=29
+val SC_MARK_RGBAIMAGE=30
+val SC_MARK_BOOKMARK=31
+val SC_MARK_VERTICALBOOKMARK=32
+
+val SC_MARK_CHARACTER=10000
+
+ali SC_MARK_ROUNDRECT=ROUND_RECT
+ali SC_MARK_SMALLRECT=SMALL_RECT
+ali SC_MARK_SHORTARROW=SHORT_ARROW
+ali SC_MARK_ARROWDOWN=ARROW_DOWN
+ali SC_MARK_VLINE=V_LINE
+ali SC_MARK_LCORNER=L_CORNER
+ali SC_MARK_TCORNER=T_CORNER
+ali SC_MARK_BOXPLUS=BOX_PLUS
+ali SC_MARK_BOXPLUSCONNECTED=BOX_PLUS_CONNECTED
+ali SC_MARK_BOXMINUS=BOX_MINUS
+ali SC_MARK_BOXMINUSCONNECTED=BOX_MINUS_CONNECTED
+ali SC_MARK_LCORNERCURVE=L_CORNER_CURVE
+ali SC_MARK_TCORNERCURVE=T_CORNER_CURVE
+ali SC_MARK_CIRCLEPLUS=CIRCLE_PLUS
+ali SC_MARK_CIRCLEPLUSCONNECTED=CIRCLE_PLUS_CONNECTED
+ali SC_MARK_CIRCLEMINUS=CIRCLE_MINUS
+ali SC_MARK_CIRCLEMINUSCONNECTED=CIRCLE_MINUS_CONNECTED
+ali SC_MARK_DOTDOTDOT=DOT_DOT_DOT
+ali SC_MARK_FULLRECT=FULL_RECT
+ali SC_MARK_LEFTRECT=LEFT_RECT
+ali SC_MARK_RGBAIMAGE=RGBA_IMAGE
+ali SC_MARK_VERTICALBOOKMARK=VERTICAL_BOOKMARK
+
+enu MarkerOutline=SC_MARKNUM_
+# Markers used for outlining column.
+val SC_MARKNUM_FOLDEREND=25
+val SC_MARKNUM_FOLDEROPENMID=26
+val SC_MARKNUM_FOLDERMIDTAIL=27
+val SC_MARKNUM_FOLDERTAIL=28
+val SC_MARKNUM_FOLDERSUB=29
+val SC_MARKNUM_FOLDER=30
+val SC_MARKNUM_FOLDEROPEN=31
+
+ali SC_MARKNUM_FOLDEREND=FOLDER_END
+ali SC_MARKNUM_FOLDEROPENMID=FOLDER_OPEN_MID
+ali SC_MARKNUM_FOLDERMIDTAIL=FOLDER_MID_TAIL
+ali SC_MARKNUM_FOLDERTAIL=FOLDER_TAIL
+ali SC_MARKNUM_FOLDERSUB=FOLDER_SUB
+ali SC_MARKNUM_FOLDEROPEN=FOLDER_OPEN
+
+# SC_MASK_FOLDERS doesn't go in an enumeration as larger than max 32-bit positive integer
+val SC_MASK_FOLDERS=0xFE000000
+
+# Set the symbol used for a particular marker number.
+fun void MarkerDefine=2040(int markerNumber, MarkerSymbol markerSymbol)
+
+# Set the foreground colour used for a particular marker number.
+set void MarkerSetFore=2041(int markerNumber, colour fore)
+
+# Set the background colour used for a particular marker number.
+set void MarkerSetBack=2042(int markerNumber, colour back)
+
+# Set the background colour used for a particular marker number when its folding block is selected.
+set void MarkerSetBackSelected=2292(int markerNumber, colour back)
+
+# Enable/disable highlight for current folding block (smallest one that contains the caret)
+fun void MarkerEnableHighlight=2293(bool enabled,)
+
+# Add a marker to a line, returning an ID which can be used to find or delete the marker.
+fun int MarkerAdd=2043(line line, int markerNumber)
+
+# Delete a marker from a line.
+fun void MarkerDelete=2044(line line, int markerNumber)
+
+# Delete all markers with a particular number from all lines.
+fun void MarkerDeleteAll=2045(int markerNumber,)
+
+# Get a bit mask of all the markers set on a line.
+fun int MarkerGet=2046(line line,)
+
+# Find the next line at or after lineStart that includes a marker in mask.
+# Return -1 when no more lines.
+fun line MarkerNext=2047(line lineStart, int markerMask)
+
+# Find the previous line before lineStart that includes a marker in mask.
+fun line MarkerPrevious=2048(line lineStart, int markerMask)
+
+# Define a marker from a pixmap.
+fun void MarkerDefinePixmap=2049(int markerNumber, string pixmap)
+
+# Add a set of markers to a line.
+fun void MarkerAddSet=2466(line line, int markerSet)
+
+# Set the alpha used for a marker that is drawn in the text area, not the margin.
+set void MarkerSetAlpha=2476(int markerNumber, Alpha alpha)
+
+val SC_MAX_MARGIN=4
+
+enu MarginType=SC_MARGIN_
+val SC_MARGIN_SYMBOL=0
+val SC_MARGIN_NUMBER=1
+val SC_MARGIN_BACK=2
+val SC_MARGIN_FORE=3
+val SC_MARGIN_TEXT=4
+val SC_MARGIN_RTEXT=5
+val SC_MARGIN_COLOUR=6
+
+ali SC_MARGIN_RTEXT=R_TEXT
+
+# Set a margin to be either numeric or symbolic.
+set void SetMarginTypeN=2240(int margin, MarginType marginType)
+
+# Retrieve the type of a margin.
+get MarginType GetMarginTypeN=2241(int margin,)
+
+# Set the width of a margin to a width expressed in pixels.
+set void SetMarginWidthN=2242(int margin, int pixelWidth)
+
+# Retrieve the width of a margin in pixels.
+get int GetMarginWidthN=2243(int margin,)
+
+# Set a mask that determines which markers are displayed in a margin.
+set void SetMarginMaskN=2244(int margin, int mask)
+
+# Retrieve the marker mask of a margin.
+get int GetMarginMaskN=2245(int margin,)
+
+# Make a margin sensitive or insensitive to mouse clicks.
+set void SetMarginSensitiveN=2246(int margin, bool sensitive)
+
+# Retrieve the mouse click sensitivity of a margin.
+get bool GetMarginSensitiveN=2247(int margin,)
+
+# Set the cursor shown when the mouse is inside a margin.
+set void SetMarginCursorN=2248(int margin, CursorShape cursor)
+
+# Retrieve the cursor shown in a margin.
+get CursorShape GetMarginCursorN=2249(int margin,)
+
+# Set the background colour of a margin. Only visible for SC_MARGIN_COLOUR.
+set void SetMarginBackN=2250(int margin, colour back)
+
+# Retrieve the background colour of a margin
+get colour GetMarginBackN=2251(int margin,)
+
+# Allocate a non-standard number of margins.
+set void SetMargins=2252(int margins,)
+
+# How many margins are there?.
+get int GetMargins=2253(,)
+
+# Styles in range 32..39 are predefined for parts of the UI and are not used as normal styles.
+enu StylesCommon=STYLE_
+val STYLE_DEFAULT=32
+val STYLE_LINENUMBER=33
+val STYLE_BRACELIGHT=34
+val STYLE_BRACEBAD=35
+val STYLE_CONTROLCHAR=36
+val STYLE_INDENTGUIDE=37
+val STYLE_CALLTIP=38
+val STYLE_FOLDDISPLAYTEXT=39
+val STYLE_LASTPREDEFINED=39
+val STYLE_MAX=255
+
+ali STYLE_LINENUMBER=LINE_NUMBER
+ali STYLE_BRACELIGHT=BRACE_LIGHT
+ali STYLE_BRACEBAD=BRACE_BAD
+ali STYLE_CONTROLCHAR=CONTROL_CHAR
+ali STYLE_INDENTGUIDE=INDENT_GUIDE
+ali STYLE_CALLTIP=CALL_TIP
+ali STYLE_FOLDDISPLAYTEXT=FOLD_DISPLAY_TEXT
+ali STYLE_LASTPREDEFINED=LAST_PREDEFINED
+
+# Character set identifiers are used in StyleSetCharacterSet.
+# The values are the same as the Windows *_CHARSET values.
+enu CharacterSet=SC_CHARSET_
+val SC_CHARSET_ANSI=0
+val SC_CHARSET_DEFAULT=1
+val SC_CHARSET_BALTIC=186
+val SC_CHARSET_CHINESEBIG5=136
+val SC_CHARSET_EASTEUROPE=238
+val SC_CHARSET_GB2312=134
+val SC_CHARSET_GREEK=161
+val SC_CHARSET_HANGUL=129
+val SC_CHARSET_MAC=77
+val SC_CHARSET_OEM=255
+val SC_CHARSET_RUSSIAN=204
+val SC_CHARSET_OEM866=866
+val SC_CHARSET_CYRILLIC=1251
+val SC_CHARSET_SHIFTJIS=128
+val SC_CHARSET_SYMBOL=2
+val SC_CHARSET_TURKISH=162
+val SC_CHARSET_JOHAB=130
+val SC_CHARSET_HEBREW=177
+val SC_CHARSET_ARABIC=178
+val SC_CHARSET_VIETNAMESE=163
+val SC_CHARSET_THAI=222
+val SC_CHARSET_8859_15=1000
+
+ali SC_CHARSET_CHINESEBIG5=CHINESE_BIG5
+ali SC_CHARSET_EASTEUROPE=EAST_EUROPE
+ali SC_CHARSET_GB2312=G_B_2312
+ali SC_CHARSET_OEM866=OEM_866
+ali SC_CHARSET_SHIFTJIS=SHIFT_JIS
+ali SC_CHARSET_8859_15=ISO_8859_15
+
+# Clear all the styles and make equivalent to the global default style.
+fun void StyleClearAll=2050(,)
+
+# Set the foreground colour of a style.
+set void StyleSetFore=2051(int style, colour fore)
+
+# Set the background colour of a style.
+set void StyleSetBack=2052(int style, colour back)
+
+# Set a style to be bold or not.
+set void StyleSetBold=2053(int style, bool bold)
+
+# Set a style to be italic or not.
+set void StyleSetItalic=2054(int style, bool italic)
+
+# Set the size of characters of a style.
+set void StyleSetSize=2055(int style, int sizePoints)
+
+# Set the font of a style.
+set void StyleSetFont=2056(int style, string fontName)
+
+# Set a style to have its end of line filled or not.
+set void StyleSetEOLFilled=2057(int style, bool eolFilled)
+
+# Reset the default style to its state at startup
+fun void StyleResetDefault=2058(,)
+
+# Set a style to be underlined or not.
+set void StyleSetUnderline=2059(int style, bool underline)
+
+enu CaseVisible=SC_CASE_
+val SC_CASE_MIXED=0
+val SC_CASE_UPPER=1
+val SC_CASE_LOWER=2
+val SC_CASE_CAMEL=3
+
+# Get the foreground colour of a style.
+get colour StyleGetFore=2481(int style,)
+
+# Get the background colour of a style.
+get colour StyleGetBack=2482(int style,)
+
+# Get is a style bold or not.
+get bool StyleGetBold=2483(int style,)
+
+# Get is a style italic or not.
+get bool StyleGetItalic=2484(int style,)
+
+# Get the size of characters of a style.
+get int StyleGetSize=2485(int style,)
+
+# Get the font of a style.
+# Returns the length of the fontName
+# Result is NUL-terminated.
+get int StyleGetFont=2486(int style, stringresult fontName)
+
+# Get is a style to have its end of line filled or not.
+get bool StyleGetEOLFilled=2487(int style,)
+
+# Get is a style underlined or not.
+get bool StyleGetUnderline=2488(int style,)
+
+# Get is a style mixed case, or to force upper or lower case.
+get CaseVisible StyleGetCase=2489(int style,)
+
+# Get the character get of the font in a style.
+get CharacterSet StyleGetCharacterSet=2490(int style,)
+
+# Get is a style visible or not.
+get bool StyleGetVisible=2491(int style,)
+
+# Get is a style changeable or not (read only).
+# Experimental feature, currently buggy.
+get bool StyleGetChangeable=2492(int style,)
+
+# Get is a style a hotspot or not.
+get bool StyleGetHotSpot=2493(int style,)
+
+# Set a style to be mixed case, or to force upper or lower case.
+set void StyleSetCase=2060(int style, CaseVisible caseVisible)
+
+val SC_FONT_SIZE_MULTIPLIER=100
+
+# Set the size of characters of a style. Size is in points multiplied by 100.
+set void StyleSetSizeFractional=2061(int style, int sizeHundredthPoints)
+
+# Get the size of characters of a style in points multiplied by 100
+get int StyleGetSizeFractional=2062(int style,)
+
+enu FontWeight=SC_WEIGHT_
+val SC_WEIGHT_NORMAL=400
+val SC_WEIGHT_SEMIBOLD=600
+val SC_WEIGHT_BOLD=700
+
+ali SC_WEIGHT_SEMIBOLD=SEMI_BOLD
+
+# Set the weight of characters of a style.
+set void StyleSetWeight=2063(int style, FontWeight weight)
+
+# Get the weight of characters of a style.
+get FontWeight StyleGetWeight=2064(int style,)
+
+# Set the character set of the font in a style.
+set void StyleSetCharacterSet=2066(int style, CharacterSet characterSet)
+
+# Set a style to be a hotspot or not.
+set void StyleSetHotSpot=2409(int style, bool hotspot)
+
+# Set the foreground colour of the main and additional selections and whether to use this setting.
+fun void SetSelFore=2067(bool useSetting, colour fore)
+
+# Set the background colour of the main and additional selections and whether to use this setting.
+fun void SetSelBack=2068(bool useSetting, colour back)
+
+# Get the alpha of the selection.
+get Alpha GetSelAlpha=2477(,)
+
+# Set the alpha of the selection.
+set void SetSelAlpha=2478(Alpha alpha,)
+
+# Is the selection end of line filled?
+get bool GetSelEOLFilled=2479(,)
+
+# Set the selection to have its end of line filled or not.
+set void SetSelEOLFilled=2480(bool filled,)
+
+# Set the foreground colour of the caret.
+set void SetCaretFore=2069(colour fore,)
+
+# When key+modifier combination keyDefinition is pressed perform sciCommand.
+fun void AssignCmdKey=2070(keymod keyDefinition, int sciCommand)
+
+# When key+modifier combination keyDefinition is pressed do nothing.
+fun void ClearCmdKey=2071(keymod keyDefinition,)
+
+# Drop all key mappings.
+fun void ClearAllCmdKeys=2072(,)
+
+# Set the styles for a segment of the document.
+fun void SetStylingEx=2073(position length, string styles)
+
+# Set a style to be visible or not.
+set void StyleSetVisible=2074(int style, bool visible)
+
+# Get the time in milliseconds that the caret is on and off.
+get int GetCaretPeriod=2075(,)
+
+# Get the time in milliseconds that the caret is on and off. 0 = steady on.
+set void SetCaretPeriod=2076(int periodMilliseconds,)
+
+# Set the set of characters making up words for when moving or selecting by word.
+# First sets defaults like SetCharsDefault.
+set void SetWordChars=2077(, string characters)
+
+# Get the set of characters making up words for when moving or selecting by word.
+# Returns the number of characters
+get int GetWordChars=2646(, stringresult characters)
+
+# Set the number of characters to have directly indexed categories
+set void SetCharacterCategoryOptimization=2720(int countCharacters,)
+
+# Get the number of characters to have directly indexed categories
+get int GetCharacterCategoryOptimization=2721(,)
+
+# Start a sequence of actions that is undone and redone as a unit.
+# May be nested.
+fun void BeginUndoAction=2078(,)
+
+# End a sequence of actions that is undone and redone as a unit.
+fun void EndUndoAction=2079(,)
+
+# Indicator style enumeration and some constants
+enu IndicatorStyle=INDIC_
+val INDIC_PLAIN=0
+val INDIC_SQUIGGLE=1
+val INDIC_TT=2
+val INDIC_DIAGONAL=3
+val INDIC_STRIKE=4
+val INDIC_HIDDEN=5
+val INDIC_BOX=6
+val INDIC_ROUNDBOX=7
+val INDIC_STRAIGHTBOX=8
+val INDIC_DASH=9
+val INDIC_DOTS=10
+val INDIC_SQUIGGLELOW=11
+val INDIC_DOTBOX=12
+val INDIC_SQUIGGLEPIXMAP=13
+val INDIC_COMPOSITIONTHICK=14
+val INDIC_COMPOSITIONTHIN=15
+val INDIC_FULLBOX=16
+val INDIC_TEXTFORE=17
+val INDIC_POINT=18
+val INDIC_POINTCHARACTER=19
+val INDIC_GRADIENT=20
+val INDIC_GRADIENTCENTRE=21
+
+# INDIC_CONTAINER, INDIC_IME, INDIC_IME_MAX, and INDIC_MAX are indicator numbers,
+# not IndicatorStyles so should not really be in the INDIC_ enumeration.
+# They are redeclared in IndicatorNumbers INDICATOR_.
+val INDIC_CONTAINER=8
+val INDIC_IME=32
+val INDIC_IME_MAX=35
+val INDIC_MAX=35
+
+enu IndicatorNumbers=INDICATOR_
+val INDICATOR_CONTAINER=8
+val INDICATOR_IME=32
+val INDICATOR_IME_MAX=35
+val INDICATOR_MAX=35
+
+ali INDIC_TT=T_T
+ali INDIC_ROUNDBOX=ROUND_BOX
+ali INDIC_STRAIGHTBOX=STRAIGHT_BOX
+ali INDIC_SQUIGGLELOW=SQUIGGLE_LOW
+ali INDIC_DOTBOX=DOT_BOX
+ali INDIC_SQUIGGLEPIXMAP=SQUIGGLE_PIXMAP
+ali INDIC_COMPOSITIONTHICK=COMPOSITION_THICK
+ali INDIC_COMPOSITIONTHIN=COMPOSITION_THIN
+ali INDIC_FULLBOX=FULL_BOX
+ali INDIC_TEXTFORE=TEXT_FORE
+ali INDIC_POINTCHARACTER=POINT_CHARACTER
+ali INDIC_GRADIENTCENTRE=GRADIENT_CENTRE
+
+# Set an indicator to plain, squiggle or TT.
+set void IndicSetStyle=2080(int indicator, IndicatorStyle indicatorStyle)
+
+# Retrieve the style of an indicator.
+get IndicatorStyle IndicGetStyle=2081(int indicator,)
+
+# Set the foreground colour of an indicator.
+set void IndicSetFore=2082(int indicator, colour fore)
+
+# Retrieve the foreground colour of an indicator.
+get colour IndicGetFore=2083(int indicator,)
+
+# Set an indicator to draw under text or over(default).
+set void IndicSetUnder=2510(int indicator, bool under)
+
+# Retrieve whether indicator drawn under or over text.
+get bool IndicGetUnder=2511(int indicator,)
+
+# Set a hover indicator to plain, squiggle or TT.
+set void IndicSetHoverStyle=2680(int indicator, IndicatorStyle indicatorStyle)
+
+# Retrieve the hover style of an indicator.
+get IndicatorStyle IndicGetHoverStyle=2681(int indicator,)
+
+# Set the foreground hover colour of an indicator.
+set void IndicSetHoverFore=2682(int indicator, colour fore)
+
+# Retrieve the foreground hover colour of an indicator.
+get colour IndicGetHoverFore=2683(int indicator,)
+
+enu IndicValue=SC_INDICVALUE
+val SC_INDICVALUEBIT=0x1000000
+val SC_INDICVALUEMASK=0xFFFFFF
+
+enu IndicFlag=SC_INDICFLAG_
+val SC_INDICFLAG_VALUEFORE=1
+
+ali SC_INDICFLAG_VALUEFORE=VALUE_FORE
+
+# Set the attributes of an indicator.
+set void IndicSetFlags=2684(int indicator, IndicFlag flags)
+
+# Retrieve the attributes of an indicator.
+get IndicFlag IndicGetFlags=2685(int indicator,)
+
+# Set the foreground colour of all whitespace and whether to use this setting.
+fun void SetWhitespaceFore=2084(bool useSetting, colour fore)
+
+# Set the background colour of all whitespace and whether to use this setting.
+fun void SetWhitespaceBack=2085(bool useSetting, colour back)
+
+# Set the size of the dots used to mark space characters.
+set void SetWhitespaceSize=2086(int size,)
+
+# Get the size of the dots used to mark space characters.
+get int GetWhitespaceSize=2087(,)
+
+# Used to hold extra styling information for each line.
+set void SetLineState=2092(line line, int state)
+
+# Retrieve the extra styling information for a line.
+get int GetLineState=2093(line line,)
+
+# Retrieve the last line number that has line state.
+get int GetMaxLineState=2094(,)
+
+# Is the background of the line containing the caret in a different colour?
+get bool GetCaretLineVisible=2095(,)
+
+# Display the background of the line containing the caret in a different colour.
+set void SetCaretLineVisible=2096(bool show,)
+
+# Get the colour of the background of the line containing the caret.
+get colour GetCaretLineBack=2097(,)
+
+# Set the colour of the background of the line containing the caret.
+set void SetCaretLineBack=2098(colour back,)
+
+# Retrieve the caret line frame width.
+# Width = 0 means this option is disabled.
+get int GetCaretLineFrame=2704(,)
+
+# Display the caret line framed.
+# Set width != 0 to enable this option and width = 0 to disable it.
+set void SetCaretLineFrame=2705(int width,)
+
+# Set a style to be changeable or not (read only).
+# Experimental feature, currently buggy.
+set void StyleSetChangeable=2099(int style, bool changeable)
+
+# Display a auto-completion list.
+# The lengthEntered parameter indicates how many characters before
+# the caret should be used to provide context.
+fun void AutoCShow=2100(position lengthEntered, string itemList)
+
+# Remove the auto-completion list from the screen.
+fun void AutoCCancel=2101(,)
+
+# Is there an auto-completion list visible?
+fun bool AutoCActive=2102(,)
+
+# Retrieve the position of the caret when the auto-completion list was displayed.
+fun position AutoCPosStart=2103(,)
+
+# User has selected an item so remove the list and insert the selection.
+fun void AutoCComplete=2104(,)
+
+# Define a set of character that when typed cancel the auto-completion list.
+fun void AutoCStops=2105(, string characterSet)
+
+# Change the separator character in the string setting up an auto-completion list.
+# Default is space but can be changed if items contain space.
+set void AutoCSetSeparator=2106(int separatorCharacter,)
+
+# Retrieve the auto-completion list separator character.
+get int AutoCGetSeparator=2107(,)
+
+# Select the item in the auto-completion list that starts with a string.
+fun void AutoCSelect=2108(, string select)
+
+# Should the auto-completion list be cancelled if the user backspaces to a
+# position before where the box was created.
+set void AutoCSetCancelAtStart=2110(bool cancel,)
+
+# Retrieve whether auto-completion cancelled by backspacing before start.
+get bool AutoCGetCancelAtStart=2111(,)
+
+# Define a set of characters that when typed will cause the autocompletion to
+# choose the selected item.
+set void AutoCSetFillUps=2112(, string characterSet)
+
+# Should a single item auto-completion list automatically choose the item.
+set void AutoCSetChooseSingle=2113(bool chooseSingle,)
+
+# Retrieve whether a single item auto-completion list automatically choose the item.
+get bool AutoCGetChooseSingle=2114(,)
+
+# Set whether case is significant when performing auto-completion searches.
+set void AutoCSetIgnoreCase=2115(bool ignoreCase,)
+
+# Retrieve state of ignore case flag.
+get bool AutoCGetIgnoreCase=2116(,)
+
+# Display a list of strings and send notification when user chooses one.
+fun void UserListShow=2117(int listType, string itemList)
+
+# Set whether or not autocompletion is hidden automatically when nothing matches.
+set void AutoCSetAutoHide=2118(bool autoHide,)
+
+# Retrieve whether or not autocompletion is hidden automatically when nothing matches.
+get bool AutoCGetAutoHide=2119(,)
+
+# Set whether or not autocompletion deletes any word characters
+# after the inserted text upon completion.
+set void AutoCSetDropRestOfWord=2270(bool dropRestOfWord,)
+
+# Retrieve whether or not autocompletion deletes any word characters
+# after the inserted text upon completion.
+get bool AutoCGetDropRestOfWord=2271(,)
+
+# Register an XPM image for use in autocompletion lists.
+fun void RegisterImage=2405(int type, string xpmData)
+
+# Clear all the registered XPM images.
+fun void ClearRegisteredImages=2408(,)
+
+# Retrieve the auto-completion list type-separator character.
+get int AutoCGetTypeSeparator=2285(,)
+
+# Change the type-separator character in the string setting up an auto-completion list.
+# Default is '?' but can be changed if items contain '?'.
+set void AutoCSetTypeSeparator=2286(int separatorCharacter,)
+
+# Set the maximum width, in characters, of auto-completion and user lists.
+# Set to 0 to autosize to fit longest item, which is the default.
+set void AutoCSetMaxWidth=2208(int characterCount,)
+
+# Get the maximum width, in characters, of auto-completion and user lists.
+get int AutoCGetMaxWidth=2209(,)
+
+# Set the maximum height, in rows, of auto-completion and user lists.
+# The default is 5 rows.
+set void AutoCSetMaxHeight=2210(int rowCount,)
+
+# Set the maximum height, in rows, of auto-completion and user lists.
+get int AutoCGetMaxHeight=2211(,)
+
+# Set the number of spaces used for one level of indentation.
+set void SetIndent=2122(int indentSize,)
+
+# Retrieve indentation size.
+get int GetIndent=2123(,)
+
+# Indentation will only use space characters if useTabs is false, otherwise
+# it will use a combination of tabs and spaces.
+set void SetUseTabs=2124(bool useTabs,)
+
+# Retrieve whether tabs will be used in indentation.
+get bool GetUseTabs=2125(,)
+
+# Change the indentation of a line to a number of columns.
+set void SetLineIndentation=2126(line line, int indentation)
+
+# Retrieve the number of columns that a line is indented.
+get int GetLineIndentation=2127(line line,)
+
+# Retrieve the position before the first non indentation character on a line.
+get position GetLineIndentPosition=2128(line line,)
+
+# Retrieve the column number of a position, taking tab width into account.
+get position GetColumn=2129(position pos,)
+
+# Count characters between two positions.
+fun position CountCharacters=2633(position start, position end)
+
+# Count code units between two positions.
+fun position CountCodeUnits=2715(position start, position end)
+
+# Show or hide the horizontal scroll bar.
+set void SetHScrollBar=2130(bool visible,)
+# Is the horizontal scroll bar visible?
+get bool GetHScrollBar=2131(,)
+
+enu IndentView=SC_IV_
+val SC_IV_NONE=0
+val SC_IV_REAL=1
+val SC_IV_LOOKFORWARD=2
+val SC_IV_LOOKBOTH=3
+
+ali SC_IV_LOOKFORWARD=LOOK_FORWARD
+ali SC_IV_LOOKBOTH=LOOK_BOTH
+
+# Show or hide indentation guides.
+set void SetIndentationGuides=2132(IndentView indentView,)
+
+# Are the indentation guides visible?
+get IndentView GetIndentationGuides=2133(,)
+
+# Set the highlighted indentation guide column.
+# 0 = no highlighted guide.
+set void SetHighlightGuide=2134(position column,)
+
+# Get the highlighted indentation guide column.
+get position GetHighlightGuide=2135(,)
+
+# Get the position after the last visible characters on a line.
+get position GetLineEndPosition=2136(line line,)
+
+# Get the code page used to interpret the bytes of the document as characters.
+get int GetCodePage=2137(,)
+
+# Get the foreground colour of the caret.
+get colour GetCaretFore=2138(,)
+
+# In read-only mode?
+get bool GetReadOnly=2140(,)
+
+# Sets the position of the caret.
+set void SetCurrentPos=2141(position caret,)
+
+# Sets the position that starts the selection - this becomes the anchor.
+set void SetSelectionStart=2142(position anchor,)
+
+# Returns the position at the start of the selection.
+get position GetSelectionStart=2143(,)
+
+# Sets the position that ends the selection - this becomes the caret.
+set void SetSelectionEnd=2144(position caret,)
+
+# Returns the position at the end of the selection.
+get position GetSelectionEnd=2145(,)
+
+# Set caret to a position, while removing any existing selection.
+fun void SetEmptySelection=2556(position caret,)
+
+# Sets the print magnification added to the point size of each style for printing.
+set void SetPrintMagnification=2146(int magnification,)
+
+# Returns the print magnification.
+get int GetPrintMagnification=2147(,)
+
+enu PrintOption=SC_PRINT_
+# PrintColourMode - use same colours as screen.
+# with the exception of line number margins, which use a white background
+val SC_PRINT_NORMAL=0
+# PrintColourMode - invert the light value of each style for printing.
+val SC_PRINT_INVERTLIGHT=1
+# PrintColourMode - force black text on white background for printing.
+val SC_PRINT_BLACKONWHITE=2
+# PrintColourMode - text stays coloured, but all background is forced to be white for printing.
+val SC_PRINT_COLOURONWHITE=3
+# PrintColourMode - only the default-background is forced to be white for printing.
+val SC_PRINT_COLOURONWHITEDEFAULTBG=4
+# PrintColourMode - use same colours as screen, including line number margins.
+val SC_PRINT_SCREENCOLOURS=5
+
+ali SC_PRINT_INVERTLIGHT=INVERT_LIGHT
+ali SC_PRINT_BLACKONWHITE=BLACK_ON_WHITE
+ali SC_PRINT_COLOURONWHITE=COLOUR_ON_WHITE
+ali SC_PRINT_COLOURONWHITEDEFAULTBG=COLOUR_ON_WHITE_DEFAULT_B_G
+ali SC_PRINT_SCREENCOLOURS=SCREEN_COLOURS
+
+# Modify colours when printing for clearer printed text.
+set void SetPrintColourMode=2148(PrintOption mode,)
+
+# Returns the print colour mode.
+get PrintOption GetPrintColourMode=2149(,)
+
+enu FindOption=SCFIND_
+val SCFIND_NONE=0x0
+val SCFIND_WHOLEWORD=0x2
+val SCFIND_MATCHCASE=0x4
+val SCFIND_WORDSTART=0x00100000
+val SCFIND_REGEXP=0x00200000
+val SCFIND_POSIX=0x00400000
+val SCFIND_CXX11REGEX=0x00800000
+
+ali SCFIND_WHOLEWORD=WHOLE_WORD
+ali SCFIND_MATCHCASE=MATCH_CASE
+ali SCFIND_WORDSTART=WORD_START
+ali SCFIND_REGEXP=REG_EXP
+ali SCFIND_CXX11REGEX=CXX11_REG_EX
+
+# Find some text in the document.
+fun position FindText=2150(FindOption searchFlags, findtext ft)
+
+# On Windows, will draw the document into a display context such as a printer.
+fun position FormatRange=2151(bool draw, formatrange fr)
+
+# Retrieve the display line at the top of the display.
+get line GetFirstVisibleLine=2152(,)
+
+# Retrieve the contents of a line.
+# Returns the length of the line.
+fun position GetLine=2153(line line, stringresult text)
+
+# Returns the number of lines in the document. There is always at least one.
+get line GetLineCount=2154(,)
+
+# Sets the size in pixels of the left margin.
+set void SetMarginLeft=2155(, int pixelWidth)
+
+# Returns the size in pixels of the left margin.
+get int GetMarginLeft=2156(,)
+
+# Sets the size in pixels of the right margin.
+set void SetMarginRight=2157(, int pixelWidth)
+
+# Returns the size in pixels of the right margin.
+get int GetMarginRight=2158(,)
+
+# Is the document different from when it was last saved?
+get bool GetModify=2159(,)
+
+# Select a range of text.
+fun void SetSel=2160(position anchor, position caret)
+
+# Retrieve the selected text.
+# Return the length of the text.
+# Result is NUL-terminated.
+fun position GetSelText=2161(, stringresult text)
+
+# Retrieve a range of text.
+# Return the length of the text.
+fun position GetTextRange=2162(, textrange tr)
+
+# Draw the selection either highlighted or in normal (non-highlighted) style.
+fun void HideSelection=2163(bool hide,)
+
+# Retrieve the x value of the point in the window where a position is displayed.
+fun int PointXFromPosition=2164(, position pos)
+
+# Retrieve the y value of the point in the window where a position is displayed.
+fun int PointYFromPosition=2165(, position pos)
+
+# Retrieve the line containing a position.
+fun line LineFromPosition=2166(position pos,)
+
+# Retrieve the position at the start of a line.
+fun position PositionFromLine=2167(line line,)
+
+# Scroll horizontally and vertically.
+fun void LineScroll=2168(position columns, line lines)
+
+# Ensure the caret is visible.
+fun void ScrollCaret=2169(,)
+
+# Scroll the argument positions and the range between them into view giving
+# priority to the primary position then the secondary position.
+# This may be used to make a search match visible.
+fun void ScrollRange=2569(position secondary, position primary)
+
+# Replace the selected text with the argument text.
+fun void ReplaceSel=2170(, string text)
+
+# Set to read only or read write.
+set void SetReadOnly=2171(bool readOnly,)
+
+# Null operation.
+fun void Null=2172(,)
+
+# Will a paste succeed?
+fun bool CanPaste=2173(,)
+
+# Are there any undoable actions in the undo history?
+fun bool CanUndo=2174(,)
+
+# Delete the undo history.
+fun void EmptyUndoBuffer=2175(,)
+
+# Undo one action in the undo history.
+fun void Undo=2176(,)
+
+# Cut the selection to the clipboard.
+fun void Cut=2177(,)
+
+# Copy the selection to the clipboard.
+fun void Copy=2178(,)
+
+# Paste the contents of the clipboard into the document replacing the selection.
+fun void Paste=2179(,)
+
+# Clear the selection.
+fun void Clear=2180(,)
+
+# Replace the contents of the document with the argument text.
+fun void SetText=2181(, string text)
+
+# Retrieve all the text in the document.
+# Returns number of characters retrieved.
+# Result is NUL-terminated.
+fun position GetText=2182(position length, stringresult text)
+
+# Retrieve the number of characters in the document.
+get position GetTextLength=2183(,)
+
+# Retrieve a pointer to a function that processes messages for this Scintilla.
+get pointer GetDirectFunction=2184(,)
+
+# Retrieve a pointer value to use as the first argument when calling
+# the function returned by GetDirectFunction.
+get pointer GetDirectPointer=2185(,)
+
+# Set to overtype (true) or insert mode.
+set void SetOvertype=2186(bool overType,)
+
+# Returns true if overtype mode is active otherwise false is returned.
+get bool GetOvertype=2187(,)
+
+# Set the width of the insert mode caret.
+set void SetCaretWidth=2188(int pixelWidth,)
+
+# Returns the width of the insert mode caret.
+get int GetCaretWidth=2189(,)
+
+# Sets the position that starts the target which is used for updating the
+# document without affecting the scroll position.
+set void SetTargetStart=2190(position start,)
+
+# Get the position that starts the target.
+get position GetTargetStart=2191(,)
+
+# Sets the virtual space of the target start
+set void SetTargetStartVirtualSpace=2728(position space,)
+
+# Get the virtual space of the target start
+get position GetTargetStartVirtualSpace=2729(,)
+
+# Sets the position that ends the target which is used for updating the
+# document without affecting the scroll position.
+set void SetTargetEnd=2192(position end,)
+
+# Get the position that ends the target.
+get position GetTargetEnd=2193(,)
+
+# Sets the virtual space of the target end
+set void SetTargetEndVirtualSpace=2730(position space,)
+
+# Get the virtual space of the target end
+get position GetTargetEndVirtualSpace=2731(,)
+
+# Sets both the start and end of the target in one call.
+fun void SetTargetRange=2686(position start, position end)
+
+# Retrieve the text in the target.
+get position GetTargetText=2687(, stringresult text)
+
+# Make the target range start and end be the same as the selection range start and end.
+fun void TargetFromSelection=2287(,)
+
+# Sets the target to the whole document.
+fun void TargetWholeDocument=2690(,)
+
+# Replace the target text with the argument text.
+# Text is counted so it can contain NULs.
+# Returns the length of the replacement text.
+fun position ReplaceTarget=2194(position length, string text)
+
+# Replace the target text with the argument text after \d processing.
+# Text is counted so it can contain NULs.
+# Looks for \d where d is between 1 and 9 and replaces these with the strings
+# matched in the last search operation which were surrounded by \( and \).
+# Returns the length of the replacement text including any change
+# caused by processing the \d patterns.
+fun position ReplaceTargetRE=2195(position length, string text)
+
+# Search for a counted string in the target and set the target to the found
+# range. Text is counted so it can contain NULs.
+# Returns start of found range or -1 for failure in which case target is not moved.
+fun position SearchInTarget=2197(position length, string text)
+
+# Set the search flags used by SearchInTarget.
+set void SetSearchFlags=2198(FindOption searchFlags,)
+
+# Get the search flags used by SearchInTarget.
+get FindOption GetSearchFlags=2199(,)
+
+# Show a call tip containing a definition near position pos.
+fun void CallTipShow=2200(position pos, string definition)
+
+# Remove the call tip from the screen.
+fun void CallTipCancel=2201(,)
+
+# Is there an active call tip?
+fun bool CallTipActive=2202(,)
+
+# Retrieve the position where the caret was before displaying the call tip.
+fun position CallTipPosStart=2203(,)
+
+# Set the start position in order to change when backspacing removes the calltip.
+set void CallTipSetPosStart=2214(position posStart,)
+
+# Highlight a segment of the definition.
+fun void CallTipSetHlt=2204(position highlightStart, position highlightEnd)
+
+# Set the background colour for the call tip.
+set void CallTipSetBack=2205(colour back,)
+
+# Set the foreground colour for the call tip.
+set void CallTipSetFore=2206(colour fore,)
+
+# Set the foreground colour for the highlighted part of the call tip.
+set void CallTipSetForeHlt=2207(colour fore,)
+
+# Enable use of STYLE_CALLTIP and set call tip tab size in pixels.
+set void CallTipUseStyle=2212(int tabSize,)
+
+# Set position of calltip, above or below text.
+set void CallTipSetPosition=2213(bool above,)
+
+# Find the display line of a document line taking hidden lines into account.
+fun line VisibleFromDocLine=2220(line docLine,)
+
+# Find the document line of a display line taking hidden lines into account.
+fun line DocLineFromVisible=2221(line displayLine,)
+
+# The number of display lines needed to wrap a document line
+fun line WrapCount=2235(line docLine,)
+
+enu FoldLevel=SC_FOLDLEVEL
+val SC_FOLDLEVELBASE=0x400
+val SC_FOLDLEVELWHITEFLAG=0x1000
+val SC_FOLDLEVELHEADERFLAG=0x2000
+val SC_FOLDLEVELNUMBERMASK=0x0FFF
+
+ali SC_FOLDLEVELWHITEFLAG=WHITE_FLAG
+ali SC_FOLDLEVELHEADERFLAG=HEADER_FLAG
+ali SC_FOLDLEVELNUMBERMASK=NUMBER_MASK
+
+# Set the fold level of a line.
+# This encodes an integer level along with flags indicating whether the
+# line is a header and whether it is effectively white space.
+set void SetFoldLevel=2222(line line, FoldLevel level)
+
+# Retrieve the fold level of a line.
+get FoldLevel GetFoldLevel=2223(line line,)
+
+# Find the last child line of a header line.
+get line GetLastChild=2224(line line, FoldLevel level)
+
+# Find the parent line of a child line.
+get line GetFoldParent=2225(line line,)
+
+# Make a range of lines visible.
+fun void ShowLines=2226(line lineStart, line lineEnd)
+
+# Make a range of lines invisible.
+fun void HideLines=2227(line lineStart, line lineEnd)
+
+# Is a line visible?
+get bool GetLineVisible=2228(line line,)
+
+# Are all lines visible?
+get bool GetAllLinesVisible=2236(,)
+
+# Show the children of a header line.
+set void SetFoldExpanded=2229(line line, bool expanded)
+
+# Is a header line expanded?
+get bool GetFoldExpanded=2230(line line,)
+
+# Switch a header line between expanded and contracted.
+fun void ToggleFold=2231(line line,)
+
+# Switch a header line between expanded and contracted and show some text after the line.
+fun void ToggleFoldShowText=2700(line line, string text)
+
+enu FoldDisplayTextStyle=SC_FOLDDISPLAYTEXT_
+val SC_FOLDDISPLAYTEXT_HIDDEN=0
+val SC_FOLDDISPLAYTEXT_STANDARD=1
+val SC_FOLDDISPLAYTEXT_BOXED=2
+
+# Set the style of fold display text.
+set void FoldDisplayTextSetStyle=2701(FoldDisplayTextStyle style,)
+
+# Get the style of fold display text.
+get FoldDisplayTextStyle FoldDisplayTextGetStyle=2707(,)
+
+# Set the default fold display text.
+fun void SetDefaultFoldDisplayText=2722(, string text)
+
+# Get the default fold display text.
+fun int GetDefaultFoldDisplayText=2723(, stringresult text)
+
+enu FoldAction=SC_FOLDACTION_
+val SC_FOLDACTION_CONTRACT=0
+val SC_FOLDACTION_EXPAND=1
+val SC_FOLDACTION_TOGGLE=2
+
+# Expand or contract a fold header.
+fun void FoldLine=2237(line line, FoldAction action)
+
+# Expand or contract a fold header and its children.
+fun void FoldChildren=2238(line line, FoldAction action)
+
+# Expand a fold header and all children. Use the level argument instead of the line's current level.
+fun void ExpandChildren=2239(line line, FoldLevel level)
+
+# Expand or contract all fold headers.
+fun void FoldAll=2662(FoldAction action,)
+
+# Ensure a particular line is visible by expanding any header line hiding it.
+fun void EnsureVisible=2232(line line,)
+
+enu AutomaticFold=SC_AUTOMATICFOLD_
+val SC_AUTOMATICFOLD_SHOW=0x0001
+val SC_AUTOMATICFOLD_CLICK=0x0002
+val SC_AUTOMATICFOLD_CHANGE=0x0004
+
+# Set automatic folding behaviours.
+set void SetAutomaticFold=2663(AutomaticFold automaticFold,)
+
+# Get automatic folding behaviours.
+get AutomaticFold GetAutomaticFold=2664(,)
+
+enu FoldFlag=SC_FOLDFLAG_
+val SC_FOLDFLAG_LINEBEFORE_EXPANDED=0x0002
+val SC_FOLDFLAG_LINEBEFORE_CONTRACTED=0x0004
+val SC_FOLDFLAG_LINEAFTER_EXPANDED=0x0008
+val SC_FOLDFLAG_LINEAFTER_CONTRACTED=0x0010
+val SC_FOLDFLAG_LEVELNUMBERS=0x0040
+val SC_FOLDFLAG_LINESTATE=0x0080
+
+ali SC_FOLDFLAG_LINEBEFORE_EXPANDED=LINE_BEFORE_EXPANDED
+ali SC_FOLDFLAG_LINEBEFORE_CONTRACTED=LINE_BEFORE_CONTRACTED
+ali SC_FOLDFLAG_LINEAFTER_EXPANDED=LINE_AFTER_EXPANDED
+ali SC_FOLDFLAG_LINEAFTER_CONTRACTED=LINE_AFTER_CONTRACTED
+ali SC_FOLDFLAG_LEVELNUMBERS=LEVEL_NUMBERS
+ali SC_FOLDFLAG_LINESTATE=LINE_STATE
+
+# Set some style options for folding.
+set void SetFoldFlags=2233(FoldFlag flags,)
+
+# Ensure a particular line is visible by expanding any header line hiding it.
+# Use the currently set visibility policy to determine which range to display.
+fun void EnsureVisibleEnforcePolicy=2234(line line,)
+
+# Sets whether a tab pressed when caret is within indentation indents.
+set void SetTabIndents=2260(bool tabIndents,)
+
+# Does a tab pressed when caret is within indentation indent?
+get bool GetTabIndents=2261(,)
+
+# Sets whether a backspace pressed when caret is within indentation unindents.
+set void SetBackSpaceUnIndents=2262(bool bsUnIndents,)
+
+# Does a backspace pressed when caret is within indentation unindent?
+get bool GetBackSpaceUnIndents=2263(,)
+
+val SC_TIME_FOREVER=10000000
+
+# Sets the time the mouse must sit still to generate a mouse dwell event.
+set void SetMouseDwellTime=2264(int periodMilliseconds,)
+
+# Retrieve the time the mouse must sit still to generate a mouse dwell event.
+get int GetMouseDwellTime=2265(,)
+
+# Get position of start of word.
+fun position WordStartPosition=2266(position pos, bool onlyWordCharacters)
+
+# Get position of end of word.
+fun position WordEndPosition=2267(position pos, bool onlyWordCharacters)
+
+# Is the range start..end considered a word?
+fun bool IsRangeWord=2691(position start, position end)
+
+enu IdleStyling=SC_IDLESTYLING_
+val SC_IDLESTYLING_NONE=0
+val SC_IDLESTYLING_TOVISIBLE=1
+val SC_IDLESTYLING_AFTERVISIBLE=2
+val SC_IDLESTYLING_ALL=3
+
+ali SC_IDLESTYLING_TOVISIBLE=TO_VISIBLE
+ali SC_IDLESTYLING_AFTERVISIBLE=AFTER_VISIBLE
+
+# Sets limits to idle styling.
+set void SetIdleStyling=2692(IdleStyling idleStyling,)
+
+# Retrieve the limits to idle styling.
+get IdleStyling GetIdleStyling=2693(,)
+
+enu Wrap=SC_WRAP_
+val SC_WRAP_NONE=0
+val SC_WRAP_WORD=1
+val SC_WRAP_CHAR=2
+val SC_WRAP_WHITESPACE=3
+
+ali SC_WRAP_WHITESPACE=WHITE_SPACE
+
+# Sets whether text is word wrapped.
+set void SetWrapMode=2268(Wrap wrapMode,)
+
+# Retrieve whether text is word wrapped.
+get Wrap GetWrapMode=2269(,)
+
+enu WrapVisualFlag=SC_WRAPVISUALFLAG_
+val SC_WRAPVISUALFLAG_NONE=0x0000
+val SC_WRAPVISUALFLAG_END=0x0001
+val SC_WRAPVISUALFLAG_START=0x0002
+val SC_WRAPVISUALFLAG_MARGIN=0x0004
+
+# Set the display mode of visual flags for wrapped lines.
+set void SetWrapVisualFlags=2460(WrapVisualFlag wrapVisualFlags,)
+
+# Retrive the display mode of visual flags for wrapped lines.
+get WrapVisualFlag GetWrapVisualFlags=2461(,)
+
+enu WrapVisualLocation=SC_WRAPVISUALFLAGLOC_
+val SC_WRAPVISUALFLAGLOC_DEFAULT=0x0000
+val SC_WRAPVISUALFLAGLOC_END_BY_TEXT=0x0001
+val SC_WRAPVISUALFLAGLOC_START_BY_TEXT=0x0002
+
+# Set the location of visual flags for wrapped lines.
+set void SetWrapVisualFlagsLocation=2462(WrapVisualLocation wrapVisualFlagsLocation,)
+
+# Retrive the location of visual flags for wrapped lines.
+get WrapVisualLocation GetWrapVisualFlagsLocation=2463(,)
+
+# Set the start indent for wrapped lines.
+set void SetWrapStartIndent=2464(int indent,)
+
+# Retrive the start indent for wrapped lines.
+get int GetWrapStartIndent=2465(,)
+
+enu WrapIndentMode=SC_WRAPINDENT_
+val SC_WRAPINDENT_FIXED=0
+val SC_WRAPINDENT_SAME=1
+val SC_WRAPINDENT_INDENT=2
+val SC_WRAPINDENT_DEEPINDENT=3
+
+ali SC_WRAPINDENT_DEEPINDENT=DEEP_INDENT
+
+# Sets how wrapped sublines are placed. Default is fixed.
+set void SetWrapIndentMode=2472(WrapIndentMode wrapIndentMode,)
+
+# Retrieve how wrapped sublines are placed. Default is fixed.
+get WrapIndentMode GetWrapIndentMode=2473(,)
+
+enu LineCache=SC_CACHE_
+val SC_CACHE_NONE=0
+val SC_CACHE_CARET=1
+val SC_CACHE_PAGE=2
+val SC_CACHE_DOCUMENT=3
+
+# Sets the degree of caching of layout information.
+set void SetLayoutCache=2272(LineCache cacheMode,)
+
+# Retrieve the degree of caching of layout information.
+get LineCache GetLayoutCache=2273(,)
+
+# Sets the document width assumed for scrolling.
+set void SetScrollWidth=2274(int pixelWidth,)
+
+# Retrieve the document width assumed for scrolling.
+get int GetScrollWidth=2275(,)
+
+# Sets whether the maximum width line displayed is used to set scroll width.
+set void SetScrollWidthTracking=2516(bool tracking,)
+
+# Retrieve whether the scroll width tracks wide lines.
+get bool GetScrollWidthTracking=2517(,)
+
+# Measure the pixel width of some text in a particular style.
+# NUL terminated text argument.
+# Does not handle tab or control characters.
+fun int TextWidth=2276(int style, string text)
+
+# Sets the scroll range so that maximum scroll position has
+# the last line at the bottom of the view (default).
+# Setting this to false allows scrolling one page below the last line.
+set void SetEndAtLastLine=2277(bool endAtLastLine,)
+
+# Retrieve whether the maximum scroll position has the last
+# line at the bottom of the view.
+get bool GetEndAtLastLine=2278(,)
+
+# Retrieve the height of a particular line of text in pixels.
+fun int TextHeight=2279(line line,)
+
+# Show or hide the vertical scroll bar.
+set void SetVScrollBar=2280(bool visible,)
+
+# Is the vertical scroll bar visible?
+get bool GetVScrollBar=2281(,)
+
+# Append a string to the end of the document without changing the selection.
+fun void AppendText=2282(position length, string text)
+
+enu PhasesDraw=SC_PHASES_
+val SC_PHASES_ONE=0
+val SC_PHASES_TWO=1
+val SC_PHASES_MULTIPLE=2
+
+# How many phases is drawing done in?
+get PhasesDraw GetPhasesDraw=2673(,)
+
+# In one phase draw, text is drawn in a series of rectangular blocks with no overlap.
+# In two phase draw, text is drawn in a series of lines allowing runs to overlap horizontally.
+# In multiple phase draw, each element is drawn over the whole drawing area, allowing text
+# to overlap from one line to the next.
+set void SetPhasesDraw=2674(PhasesDraw phases,)
+
+# Control font anti-aliasing.
+
+enu FontQuality=SC_EFF_
+val SC_EFF_QUALITY_MASK=0xF
+val SC_EFF_QUALITY_DEFAULT=0
+val SC_EFF_QUALITY_NON_ANTIALIASED=1
+val SC_EFF_QUALITY_ANTIALIASED=2
+val SC_EFF_QUALITY_LCD_OPTIMIZED=3
+
+# Choose the quality level for text from the FontQuality enumeration.
+set void SetFontQuality=2611(FontQuality fontQuality,)
+
+# Retrieve the quality level for text.
+get FontQuality GetFontQuality=2612(,)
+
+# Scroll so that a display line is at the top of the display.
+set void SetFirstVisibleLine=2613(line displayLine,)
+
+enu MultiPaste=SC_MULTIPASTE_
+val SC_MULTIPASTE_ONCE=0
+val SC_MULTIPASTE_EACH=1
+
+# Change the effect of pasting when there are multiple selections.
+set void SetMultiPaste=2614(MultiPaste multiPaste,)
+
+# Retrieve the effect of pasting when there are multiple selections.
+get MultiPaste GetMultiPaste=2615(,)
+
+# Retrieve the value of a tag from a regular expression search.
+# Result is NUL-terminated.
+get int GetTag=2616(int tagNumber, stringresult tagValue)
+
+# Join the lines in the target.
+fun void LinesJoin=2288(,)
+
+# Split the lines in the target into lines that are less wide than pixelWidth
+# where possible.
+fun void LinesSplit=2289(int pixelWidth,)
+
+# Set one of the colours used as a chequerboard pattern in the fold margin
+fun void SetFoldMarginColour=2290(bool useSetting, colour back)
+# Set the other colour used as a chequerboard pattern in the fold margin
+fun void SetFoldMarginHiColour=2291(bool useSetting, colour fore)
+
+enu Accessibility=SC_ACCESSIBILITY_
+val SC_ACCESSIBILITY_DISABLED=0
+val SC_ACCESSIBILITY_ENABLED=1
+
+# Enable or disable accessibility.
+set void SetAccessibility=2702(Accessibility accessibility,)
+
+# Report accessibility status.
+get Accessibility GetAccessibility=2703(,)
+
+## New messages go here
+
+## Start of key messages
+# Move caret down one line.
+fun void LineDown=2300(,)
+
+# Move caret down one line extending selection to new caret position.
+fun void LineDownExtend=2301(,)
+
+# Move caret up one line.
+fun void LineUp=2302(,)
+
+# Move caret up one line extending selection to new caret position.
+fun void LineUpExtend=2303(,)
+
+# Move caret left one character.
+fun void CharLeft=2304(,)
+
+# Move caret left one character extending selection to new caret position.
+fun void CharLeftExtend=2305(,)
+
+# Move caret right one character.
+fun void CharRight=2306(,)
+
+# Move caret right one character extending selection to new caret position.
+fun void CharRightExtend=2307(,)
+
+# Move caret left one word.
+fun void WordLeft=2308(,)
+
+# Move caret left one word extending selection to new caret position.
+fun void WordLeftExtend=2309(,)
+
+# Move caret right one word.
+fun void WordRight=2310(,)
+
+# Move caret right one word extending selection to new caret position.
+fun void WordRightExtend=2311(,)
+
+# Move caret to first position on line.
+fun void Home=2312(,)
+
+# Move caret to first position on line extending selection to new caret position.
+fun void HomeExtend=2313(,)
+
+# Move caret to last position on line.
+fun void LineEnd=2314(,)
+
+# Move caret to last position on line extending selection to new caret position.
+fun void LineEndExtend=2315(,)
+
+# Move caret to first position in document.
+fun void DocumentStart=2316(,)
+
+# Move caret to first position in document extending selection to new caret position.
+fun void DocumentStartExtend=2317(,)
+
+# Move caret to last position in document.
+fun void DocumentEnd=2318(,)
+
+# Move caret to last position in document extending selection to new caret position.
+fun void DocumentEndExtend=2319(,)
+
+# Move caret one page up.
+fun void PageUp=2320(,)
+
+# Move caret one page up extending selection to new caret position.
+fun void PageUpExtend=2321(,)
+
+# Move caret one page down.
+fun void PageDown=2322(,)
+
+# Move caret one page down extending selection to new caret position.
+fun void PageDownExtend=2323(,)
+
+# Switch from insert to overtype mode or the reverse.
+fun void EditToggleOvertype=2324(,)
+
+# Cancel any modes such as call tip or auto-completion list display.
+fun void Cancel=2325(,)
+
+# Delete the selection or if no selection, the character before the caret.
+fun void DeleteBack=2326(,)
+
+# If selection is empty or all on one line replace the selection with a tab character.
+# If more than one line selected, indent the lines.
+fun void Tab=2327(,)
+
+# Dedent the selected lines.
+fun void BackTab=2328(,)
+
+# Insert a new line, may use a CRLF, CR or LF depending on EOL mode.
+fun void NewLine=2329(,)
+
+# Insert a Form Feed character.
+fun void FormFeed=2330(,)
+
+# Move caret to before first visible character on line.
+# If already there move to first character on line.
+fun void VCHome=2331(,)
+
+# Like VCHome but extending selection to new caret position.
+fun void VCHomeExtend=2332(,)
+
+# Magnify the displayed text by increasing the sizes by 1 point.
+fun void ZoomIn=2333(,)
+
+# Make the displayed text smaller by decreasing the sizes by 1 point.
+fun void ZoomOut=2334(,)
+
+# Delete the word to the left of the caret.
+fun void DelWordLeft=2335(,)
+
+# Delete the word to the right of the caret.
+fun void DelWordRight=2336(,)
+
+# Delete the word to the right of the caret, but not the trailing non-word characters.
+fun void DelWordRightEnd=2518(,)
+
+# Cut the line containing the caret.
+fun void LineCut=2337(,)
+
+# Delete the line containing the caret.
+fun void LineDelete=2338(,)
+
+# Switch the current line with the previous.
+fun void LineTranspose=2339(,)
+
+# Reverse order of selected lines.
+fun void LineReverse=2354(,)
+
+# Duplicate the current line.
+fun void LineDuplicate=2404(,)
+
+# Transform the selection to lower case.
+fun void LowerCase=2340(,)
+
+# Transform the selection to upper case.
+fun void UpperCase=2341(,)
+
+# Scroll the document down, keeping the caret visible.
+fun void LineScrollDown=2342(,)
+
+# Scroll the document up, keeping the caret visible.
+fun void LineScrollUp=2343(,)
+
+# Delete the selection or if no selection, the character before the caret.
+# Will not delete the character before at the start of a line.
+fun void DeleteBackNotLine=2344(,)
+
+# Move caret to first position on display line.
+fun void HomeDisplay=2345(,)
+
+# Move caret to first position on display line extending selection to
+# new caret position.
+fun void HomeDisplayExtend=2346(,)
+
+# Move caret to last position on display line.
+fun void LineEndDisplay=2347(,)
+
+# Move caret to last position on display line extending selection to new
+# caret position.
+fun void LineEndDisplayExtend=2348(,)
+
+# Like Home but when word-wrap is enabled goes first to start of display line
+# HomeDisplay, then to start of document line Home.
+fun void HomeWrap=2349(,)
+
+# Like HomeExtend but when word-wrap is enabled extends first to start of display line
+# HomeDisplayExtend, then to start of document line HomeExtend.
+fun void HomeWrapExtend=2450(,)
+
+# Like LineEnd but when word-wrap is enabled goes first to end of display line
+# LineEndDisplay, then to start of document line LineEnd.
+fun void LineEndWrap=2451(,)
+
+# Like LineEndExtend but when word-wrap is enabled extends first to end of display line
+# LineEndDisplayExtend, then to start of document line LineEndExtend.
+fun void LineEndWrapExtend=2452(,)
+
+# Like VCHome but when word-wrap is enabled goes first to start of display line
+# VCHomeDisplay, then behaves like VCHome.
+fun void VCHomeWrap=2453(,)
+
+# Like VCHomeExtend but when word-wrap is enabled extends first to start of display line
+# VCHomeDisplayExtend, then behaves like VCHomeExtend.
+fun void VCHomeWrapExtend=2454(,)
+
+# Copy the line containing the caret.
+fun void LineCopy=2455(,)
+
+# Move the caret inside current view if it's not there already.
+fun void MoveCaretInsideView=2401(,)
+
+# How many characters are on a line, including end of line characters?
+fun position LineLength=2350(line line,)
+
+# Highlight the characters at two positions.
+fun void BraceHighlight=2351(position posA, position posB)
+
+# Use specified indicator to highlight matching braces instead of changing their style.
+fun void BraceHighlightIndicator=2498(bool useSetting, int indicator)
+
+# Highlight the character at a position indicating there is no matching brace.
+fun void BraceBadLight=2352(position pos,)
+
+# Use specified indicator to highlight non matching brace instead of changing its style.
+fun void BraceBadLightIndicator=2499(bool useSetting, int indicator)
+
+# Find the position of a matching brace or INVALID_POSITION if no match.
+# The maxReStyle must be 0 for now. It may be defined in a future release.
+fun position BraceMatch=2353(position pos, int maxReStyle)
+
+# Similar to BraceMatch, but matching starts at the explicit start position.
+fun position BraceMatchNext=2369(position pos, position startPos)
+
+# Are the end of line characters visible?
+get bool GetViewEOL=2355(,)
+
+# Make the end of line characters visible or invisible.
+set void SetViewEOL=2356(bool visible,)
+
+# Retrieve a pointer to the document object.
+get pointer GetDocPointer=2357(,)
+
+# Change the document object used.
+set void SetDocPointer=2358(, pointer doc)
+
+# Set which document modification events are sent to the container.
+set void SetModEventMask=2359(ModificationFlags eventMask,)
+
+enu EdgeVisualStyle=EDGE_
+val EDGE_NONE=0
+val EDGE_LINE=1
+val EDGE_BACKGROUND=2
+val EDGE_MULTILINE=3
+
+ali EDGE_MULTILINE=MULTI_LINE
+
+# Retrieve the column number which text should be kept within.
+get position GetEdgeColumn=2360(,)
+
+# Set the column number of the edge.
+# If text goes past the edge then it is highlighted.
+set void SetEdgeColumn=2361(position column,)
+
+# Retrieve the edge highlight mode.
+get EdgeVisualStyle GetEdgeMode=2362(,)
+
+# The edge may be displayed by a line (EDGE_LINE/EDGE_MULTILINE) or by highlighting text that
+# goes beyond it (EDGE_BACKGROUND) or not displayed at all (EDGE_NONE).
+set void SetEdgeMode=2363(EdgeVisualStyle edgeMode,)
+
+# Retrieve the colour used in edge indication.
+get colour GetEdgeColour=2364(,)
+
+# Change the colour used in edge indication.
+set void SetEdgeColour=2365(colour edgeColour,)
+
+# Add a new vertical edge to the view.
+fun void MultiEdgeAddLine=2694(position column, colour edgeColour)
+
+# Clear all vertical edges.
+fun void MultiEdgeClearAll=2695(,)
+
+# Get multi edge positions.
+get position GetMultiEdgeColumn=2749(int which,)
+
+# Sets the current caret position to be the search anchor.
+fun void SearchAnchor=2366(,)
+
+# Find some text starting at the search anchor.
+# Does not ensure the selection is visible.
+fun position SearchNext=2367(FindOption searchFlags, string text)
+
+# Find some text starting at the search anchor and moving backwards.
+# Does not ensure the selection is visible.
+fun position SearchPrev=2368(FindOption searchFlags, string text)
+
+# Retrieves the number of lines completely visible.
+get line LinesOnScreen=2370(,)
+
+enu PopUp=SC_POPUP_
+val SC_POPUP_NEVER=0
+val SC_POPUP_ALL=1
+val SC_POPUP_TEXT=2
+
+# Set whether a pop up menu is displayed automatically when the user presses
+# the wrong mouse button on certain areas.
+fun void UsePopUp=2371(PopUp popUpMode,)
+
+# Is the selection rectangular? The alternative is the more common stream selection.
+get bool SelectionIsRectangle=2372(,)
+
+# Set the zoom level. This number of points is added to the size of all fonts.
+# It may be positive to magnify or negative to reduce.
+set void SetZoom=2373(int zoomInPoints,)
+# Retrieve the zoom level.
+get int GetZoom=2374(,)
+
+enu DocumentOption=SC_DOCUMENTOPTION_
+val SC_DOCUMENTOPTION_DEFAULT=0
+val SC_DOCUMENTOPTION_STYLES_NONE=0x1
+val SC_DOCUMENTOPTION_TEXT_LARGE=0x100
+
+# Create a new document object.
+# Starts with reference count of 1 and not selected into editor.
+fun pointer CreateDocument=2375(position bytes, DocumentOption documentOptions)
+# Extend life of document.
+fun void AddRefDocument=2376(, pointer doc)
+# Release a reference to the document, deleting document if it fades to black.
+fun void ReleaseDocument=2377(, pointer doc)
+
+# Get which document options are set.
+get DocumentOption GetDocumentOptions=2379(,)
+
+# Get which document modification events are sent to the container.
+get ModificationFlags GetModEventMask=2378(,)
+
+# Set whether command events are sent to the container.
+set void SetCommandEvents=2717(bool commandEvents,)
+
+# Get whether command events are sent to the container.
+get bool GetCommandEvents=2718(,)
+
+# Change internal focus flag.
+set void SetFocus=2380(bool focus,)
+# Get internal focus flag.
+get bool GetFocus=2381(,)
+
+enu Status=SC_STATUS_
+val SC_STATUS_OK=0
+val SC_STATUS_FAILURE=1
+val SC_STATUS_BADALLOC=2
+val SC_STATUS_WARN_START=1000
+val SC_STATUS_WARN_REGEX=1001
+
+ali SC_STATUS_BADALLOC=BAD_ALLOC
+ali SC_STATUS_WARN_REGEX=REG_EX
+
+# Change error status - 0 = OK.
+set void SetStatus=2382(Status status,)
+# Get error status.
+get Status GetStatus=2383(,)
+
+# Set whether the mouse is captured when its button is pressed.
+set void SetMouseDownCaptures=2384(bool captures,)
+# Get whether mouse gets captured.
+get bool GetMouseDownCaptures=2385(,)
+
+# Set whether the mouse wheel can be active outside the window.
+set void SetMouseWheelCaptures=2696(bool captures,)
+# Get whether mouse wheel can be active outside the window.
+get bool GetMouseWheelCaptures=2697(,)
+
+# Sets the cursor to one of the SC_CURSOR* values.
+set void SetCursor=2386(CursorShape cursorType,)
+# Get cursor type.
+get CursorShape GetCursor=2387(,)
+
+# Change the way control characters are displayed:
+# If symbol is < 32, keep the drawn way, else, use the given character.
+set void SetControlCharSymbol=2388(int symbol,)
+# Get the way control characters are displayed.
+get int GetControlCharSymbol=2389(,)
+
+# Move to the previous change in capitalisation.
+fun void WordPartLeft=2390(,)
+# Move to the previous change in capitalisation extending selection
+# to new caret position.
+fun void WordPartLeftExtend=2391(,)
+# Move to the change next in capitalisation.
+fun void WordPartRight=2392(,)
+# Move to the next change in capitalisation extending selection
+# to new caret position.
+fun void WordPartRightExtend=2393(,)
+
+# Constants for use with SetVisiblePolicy, similar to SetCaretPolicy.
+enu VisiblePolicy=VISIBLE_
+val VISIBLE_SLOP=0x01
+val VISIBLE_STRICT=0x04
+
+# Set the way the display area is determined when a particular line
+# is to be moved to by Find, FindNext, GotoLine, etc.
+fun void SetVisiblePolicy=2394(VisiblePolicy visiblePolicy, int visibleSlop)
+
+# Delete back from the current position to the start of the line.
+fun void DelLineLeft=2395(,)
+
+# Delete forwards from the current position to the end of the line.
+fun void DelLineRight=2396(,)
+
+# Set the xOffset (ie, horizontal scroll position).
+set void SetXOffset=2397(int xOffset,)
+
+# Get the xOffset (ie, horizontal scroll position).
+get int GetXOffset=2398(,)
+
+# Set the last x chosen value to be the caret x position.
+fun void ChooseCaretX=2399(,)
+
+# Set the focus to this Scintilla widget.
+fun void GrabFocus=2400(,)
+
+enu CaretPolicy=CARET_
+# Caret policy, used by SetXCaretPolicy and SetYCaretPolicy.
+# If CARET_SLOP is set, we can define a slop value: caretSlop.
+# This value defines an unwanted zone (UZ) where the caret is... unwanted.
+# This zone is defined as a number of pixels near the vertical margins,
+# and as a number of lines near the horizontal margins.
+# By keeping the caret away from the edges, it is seen within its context,
+# so it is likely that the identifier that the caret is on can be completely seen,
+# and that the current line is seen with some of the lines following it which are
+# often dependent on that line.
+val CARET_SLOP=0x01
+# If CARET_STRICT is set, the policy is enforced... strictly.
+# The caret is centred on the display if slop is not set,
+# and cannot go in the UZ if slop is set.
+val CARET_STRICT=0x04
+# If CARET_JUMPS is set, the display is moved more energetically
+# so the caret can move in the same direction longer before the policy is applied again.
+val CARET_JUMPS=0x10
+# If CARET_EVEN is not set, instead of having symmetrical UZs,
+# the left and bottom UZs are extended up to right and top UZs respectively.
+# This way, we favour the displaying of useful information: the beginning of lines,
+# where most code reside, and the lines after the caret, eg. the body of a function.
+val CARET_EVEN=0x08
+
+# Set the way the caret is kept visible when going sideways.
+# The exclusion zone is given in pixels.
+fun void SetXCaretPolicy=2402(CaretPolicy caretPolicy, int caretSlop)
+
+# Set the way the line the caret is on is kept visible.
+# The exclusion zone is given in lines.
+fun void SetYCaretPolicy=2403(CaretPolicy caretPolicy, int caretSlop)
+
+# Set printing to line wrapped (SC_WRAP_WORD) or not line wrapped (SC_WRAP_NONE).
+set void SetPrintWrapMode=2406(Wrap wrapMode,)
+
+# Is printing line wrapped?
+get Wrap GetPrintWrapMode=2407(,)
+
+# Set a fore colour for active hotspots.
+set void SetHotspotActiveFore=2410(bool useSetting, colour fore)
+
+# Get the fore colour for active hotspots.
+get colour GetHotspotActiveFore=2494(,)
+
+# Set a back colour for active hotspots.
+set void SetHotspotActiveBack=2411(bool useSetting, colour back)
+
+# Get the back colour for active hotspots.
+get colour GetHotspotActiveBack=2495(,)
+
+# Enable / Disable underlining active hotspots.
+set void SetHotspotActiveUnderline=2412(bool underline,)
+
+# Get whether underlining for active hotspots.
+get bool GetHotspotActiveUnderline=2496(,)
+
+# Limit hotspots to single line so hotspots on two lines don't merge.
+set void SetHotspotSingleLine=2421(bool singleLine,)
+
+# Get the HotspotSingleLine property
+get bool GetHotspotSingleLine=2497(,)
+
+# Move caret down one paragraph (delimited by empty lines).
+fun void ParaDown=2413(,)
+
+# Extend selection down one paragraph (delimited by empty lines).
+fun void ParaDownExtend=2414(,)
+
+# Move caret up one paragraph (delimited by empty lines).
+fun void ParaUp=2415(,)
+
+# Extend selection up one paragraph (delimited by empty lines).
+fun void ParaUpExtend=2416(,)
+
+# Given a valid document position, return the previous position taking code
+# page into account. Returns 0 if passed 0.
+fun position PositionBefore=2417(position pos,)
+
+# Given a valid document position, return the next position taking code
+# page into account. Maximum value returned is the last position in the document.
+fun position PositionAfter=2418(position pos,)
+
+# Given a valid document position, return a position that differs in a number
+# of characters. Returned value is always between 0 and last position in document.
+fun position PositionRelative=2670(position pos, position relative)
+
+# Given a valid document position, return a position that differs in a number
+# of UTF-16 code units. Returned value is always between 0 and last position in document.
+# The result may point half way (2 bytes) inside a non-BMP character.
+fun position PositionRelativeCodeUnits=2716(position pos, position relative)
+
+# Copy a range of text to the clipboard. Positions are clipped into the document.
+fun void CopyRange=2419(position start, position end)
+
+# Copy argument text to the clipboard.
+fun void CopyText=2420(position length, string text)
+
+enu SelectionMode=SC_SEL_
+val SC_SEL_STREAM=0
+val SC_SEL_RECTANGLE=1
+val SC_SEL_LINES=2
+val SC_SEL_THIN=3
+
+# Set the selection mode to stream (SC_SEL_STREAM) or rectangular (SC_SEL_RECTANGLE/SC_SEL_THIN) or
+# by lines (SC_SEL_LINES).
+set void SetSelectionMode=2422(SelectionMode selectionMode,)
+
+# Get the mode of the current selection.
+get SelectionMode GetSelectionMode=2423(,)
+
+# Get whether or not regular caret moves will extend or reduce the selection.
+get bool GetMoveExtendsSelection=2706(,)
+
+# Retrieve the position of the start of the selection at the given line (INVALID_POSITION if no selection on this line).
+fun position GetLineSelStartPosition=2424(line line,)
+
+# Retrieve the position of the end of the selection at the given line (INVALID_POSITION if no selection on this line).
+fun position GetLineSelEndPosition=2425(line line,)
+
+## RectExtended rectangular selection moves
+# Move caret down one line, extending rectangular selection to new caret position.
+fun void LineDownRectExtend=2426(,)
+
+# Move caret up one line, extending rectangular selection to new caret position.
+fun void LineUpRectExtend=2427(,)
+
+# Move caret left one character, extending rectangular selection to new caret position.
+fun void CharLeftRectExtend=2428(,)
+
+# Move caret right one character, extending rectangular selection to new caret position.
+fun void CharRightRectExtend=2429(,)
+
+# Move caret to first position on line, extending rectangular selection to new caret position.
+fun void HomeRectExtend=2430(,)
+
+# Move caret to before first visible character on line.
+# If already there move to first character on line.
+# In either case, extend rectangular selection to new caret position.
+fun void VCHomeRectExtend=2431(,)
+
+# Move caret to last position on line, extending rectangular selection to new caret position.
+fun void LineEndRectExtend=2432(,)
+
+# Move caret one page up, extending rectangular selection to new caret position.
+fun void PageUpRectExtend=2433(,)
+
+# Move caret one page down, extending rectangular selection to new caret position.
+fun void PageDownRectExtend=2434(,)
+
+
+# Move caret to top of page, or one page up if already at top of page.
+fun void StutteredPageUp=2435(,)
+
+# Move caret to top of page, or one page up if already at top of page, extending selection to new caret position.
+fun void StutteredPageUpExtend=2436(,)
+
+# Move caret to bottom of page, or one page down if already at bottom of page.
+fun void StutteredPageDown=2437(,)
+
+# Move caret to bottom of page, or one page down if already at bottom of page, extending selection to new caret position.
+fun void StutteredPageDownExtend=2438(,)
+
+
+# Move caret left one word, position cursor at end of word.
+fun void WordLeftEnd=2439(,)
+
+# Move caret left one word, position cursor at end of word, extending selection to new caret position.
+fun void WordLeftEndExtend=2440(,)
+
+# Move caret right one word, position cursor at end of word.
+fun void WordRightEnd=2441(,)
+
+# Move caret right one word, position cursor at end of word, extending selection to new caret position.
+fun void WordRightEndExtend=2442(,)
+
+# Set the set of characters making up whitespace for when moving or selecting by word.
+# Should be called after SetWordChars.
+set void SetWhitespaceChars=2443(, string characters)
+
+# Get the set of characters making up whitespace for when moving or selecting by word.
+get int GetWhitespaceChars=2647(, stringresult characters)
+
+# Set the set of characters making up punctuation characters
+# Should be called after SetWordChars.
+set void SetPunctuationChars=2648(, string characters)
+
+# Get the set of characters making up punctuation characters
+get int GetPunctuationChars=2649(, stringresult characters)
+
+# Reset the set of characters for whitespace and word characters to the defaults.
+fun void SetCharsDefault=2444(,)
+
+# Get currently selected item position in the auto-completion list
+get int AutoCGetCurrent=2445(,)
+
+# Get currently selected item text in the auto-completion list
+# Returns the length of the item text
+# Result is NUL-terminated.
+get int AutoCGetCurrentText=2610(, stringresult text)
+
+enu CaseInsensitiveBehaviour=SC_CASEINSENSITIVEBEHAVIOUR_
+val SC_CASEINSENSITIVEBEHAVIOUR_RESPECTCASE=0
+val SC_CASEINSENSITIVEBEHAVIOUR_IGNORECASE=1
+
+ali SC_CASEINSENSITIVEBEHAVIOUR_RESPECTCASE=RESPECT_CASE
+ali SC_CASEINSENSITIVEBEHAVIOUR_IGNORECASE=IGNORE_CASE
+
+# Set auto-completion case insensitive behaviour to either prefer case-sensitive matches or have no preference.
+set void AutoCSetCaseInsensitiveBehaviour=2634(CaseInsensitiveBehaviour behaviour,)
+
+# Get auto-completion case insensitive behaviour.
+get CaseInsensitiveBehaviour AutoCGetCaseInsensitiveBehaviour=2635(,)
+
+enu MultiAutoComplete=SC_MULTIAUTOC_
+val SC_MULTIAUTOC_ONCE=0
+val SC_MULTIAUTOC_EACH=1
+
+# Change the effect of autocompleting when there are multiple selections.
+set void AutoCSetMulti=2636(MultiAutoComplete multi,)
+
+# Retrieve the effect of autocompleting when there are multiple selections.
+get MultiAutoComplete AutoCGetMulti=2637(,)
+
+enu Ordering=SC_ORDER_
+val SC_ORDER_PRESORTED=0
+val SC_ORDER_PERFORMSORT=1
+val SC_ORDER_CUSTOM=2
+
+ali SC_ORDER_PRESORTED=PRE_SORTED
+ali SC_ORDER_PERFORMSORT=PERFORM_SORT
+
+# Set the way autocompletion lists are ordered.
+set void AutoCSetOrder=2660(Ordering order,)
+
+# Get the way autocompletion lists are ordered.
+get Ordering AutoCGetOrder=2661(,)
+
+# Enlarge the document to a particular size of text bytes.
+fun void Allocate=2446(position bytes,)
+
+# Returns the target converted to UTF8.
+# Return the length in bytes.
+fun position TargetAsUTF8=2447(, stringresult s)
+
+# Set the length of the utf8 argument for calling EncodedFromUTF8.
+# Set to -1 and the string will be measured to the first nul.
+fun void SetLengthForEncode=2448(position bytes,)
+
+# Translates a UTF8 string into the document encoding.
+# Return the length of the result in bytes.
+# On error return 0.
+fun position EncodedFromUTF8=2449(string utf8, stringresult encoded)
+
+# Find the position of a column on a line taking into account tabs and
+# multi-byte characters. If beyond end of line, return line end position.
+fun position FindColumn=2456(line line, position column)
+
+enu CaretSticky=SC_CARETSTICKY_
+val SC_CARETSTICKY_OFF=0
+val SC_CARETSTICKY_ON=1
+val SC_CARETSTICKY_WHITESPACE=2
+
+ali SC_CARETSTICKY_WHITESPACE=WHITE_SPACE
+
+# Can the caret preferred x position only be changed by explicit movement commands?
+get CaretSticky GetCaretSticky=2457(,)
+
+# Stop the caret preferred x position changing when the user types.
+set void SetCaretSticky=2458(CaretSticky useCaretStickyBehaviour,)
+
+# Switch between sticky and non-sticky: meant to be bound to a key.
+fun void ToggleCaretSticky=2459(,)
+
+# Enable/Disable convert-on-paste for line endings
+set void SetPasteConvertEndings=2467(bool convert,)
+
+# Get convert-on-paste setting
+get bool GetPasteConvertEndings=2468(,)
+
+# Duplicate the selection. If selection empty duplicate the line containing the caret.
+fun void SelectionDuplicate=2469(,)
+
+# Set background alpha of the caret line.
+set void SetCaretLineBackAlpha=2470(Alpha alpha,)
+
+# Get the background alpha of the caret line.
+get Alpha GetCaretLineBackAlpha=2471(,)
+
+enu CaretStyle=CARETSTYLE_
+val CARETSTYLE_INVISIBLE=0
+val CARETSTYLE_LINE=1
+val CARETSTYLE_BLOCK=2
+val CARETSTYLE_OVERSTRIKE_BAR=0
+val CARETSTYLE_OVERSTRIKE_BLOCK=0x10
+val CARETSTYLE_INS_MASK=0xF
+val CARETSTYLE_BLOCK_AFTER=0x100
+
+# Set the style of the caret to be drawn.
+set void SetCaretStyle=2512(CaretStyle caretStyle,)
+
+# Returns the current style of the caret.
+get CaretStyle GetCaretStyle=2513(,)
+
+# Set the indicator used for IndicatorFillRange and IndicatorClearRange
+set void SetIndicatorCurrent=2500(int indicator,)
+
+# Get the current indicator
+get int GetIndicatorCurrent=2501(,)
+
+# Set the value used for IndicatorFillRange
+set void SetIndicatorValue=2502(int value,)
+
+# Get the current indicator value
+get int GetIndicatorValue=2503(,)
+
+# Turn a indicator on over a range.
+fun void IndicatorFillRange=2504(position start, position lengthFill)
+
+# Turn a indicator off over a range.
+fun void IndicatorClearRange=2505(position start, position lengthClear)
+
+# Are any indicators present at pos?
+fun int IndicatorAllOnFor=2506(position pos,)
+
+# What value does a particular indicator have at a position?
+fun int IndicatorValueAt=2507(int indicator, position pos)
+
+# Where does a particular indicator start?
+fun position IndicatorStart=2508(int indicator, position pos)
+
+# Where does a particular indicator end?
+fun position IndicatorEnd=2509(int indicator, position pos)
+
+# Set number of entries in position cache
+set void SetPositionCache=2514(int size,)
+
+# How many entries are allocated to the position cache?
+get int GetPositionCache=2515(,)
+
+# Copy the selection, if selection empty copy the line with the caret
+fun void CopyAllowLine=2519(,)
+
+# Compact the document buffer and return a read-only pointer to the
+# characters in the document.
+get pointer GetCharacterPointer=2520(,)
+
+# Return a read-only pointer to a range of characters in the document.
+# May move the gap so that the range is contiguous, but will only move up
+# to lengthRange bytes.
+get pointer GetRangePointer=2643(position start, position lengthRange)
+
+# Return a position which, to avoid performance costs, should not be within
+# the range of a call to GetRangePointer.
+get position GetGapPosition=2644(,)
+
+# Set the alpha fill colour of the given indicator.
+set void IndicSetAlpha=2523(int indicator, Alpha alpha)
+
+# Get the alpha fill colour of the given indicator.
+get Alpha IndicGetAlpha=2524(int indicator,)
+
+# Set the alpha outline colour of the given indicator.
+set void IndicSetOutlineAlpha=2558(int indicator, Alpha alpha)
+
+# Get the alpha outline colour of the given indicator.
+get Alpha IndicGetOutlineAlpha=2559(int indicator,)
+
+# Set extra ascent for each line
+set void SetExtraAscent=2525(int extraAscent,)
+
+# Get extra ascent for each line
+get int GetExtraAscent=2526(,)
+
+# Set extra descent for each line
+set void SetExtraDescent=2527(int extraDescent,)
+
+# Get extra descent for each line
+get int GetExtraDescent=2528(,)
+
+# Which symbol was defined for markerNumber with MarkerDefine
+fun int MarkerSymbolDefined=2529(int markerNumber,)
+
+# Set the text in the text margin for a line
+set void MarginSetText=2530(line line, string text)
+
+# Get the text in the text margin for a line
+get int MarginGetText=2531(line line, stringresult text)
+
+# Set the style number for the text margin for a line
+set void MarginSetStyle=2532(line line, int style)
+
+# Get the style number for the text margin for a line
+get int MarginGetStyle=2533(line line,)
+
+# Set the style in the text margin for a line
+set void MarginSetStyles=2534(line line, string styles)
+
+# Get the styles in the text margin for a line
+get int MarginGetStyles=2535(line line, stringresult styles)
+
+# Clear the margin text on all lines
+fun void MarginTextClearAll=2536(,)
+
+# Get the start of the range of style numbers used for margin text
+set void MarginSetStyleOffset=2537(int style,)
+
+# Get the start of the range of style numbers used for margin text
+get int MarginGetStyleOffset=2538(,)
+
+enu MarginOption=SC_MARGINOPTION_
+val SC_MARGINOPTION_NONE=0
+val SC_MARGINOPTION_SUBLINESELECT=1
+
+ali SC_MARGINOPTION_SUBLINESELECT=SUB_LINE_SELECT
+
+# Set the margin options.
+set void SetMarginOptions=2539(MarginOption marginOptions,)
+
+# Get the margin options.
+get MarginOption GetMarginOptions=2557(,)
+
+# Set the annotation text for a line
+set void AnnotationSetText=2540(line line, string text)
+
+# Get the annotation text for a line
+get int AnnotationGetText=2541(line line, stringresult text)
+
+# Set the style number for the annotations for a line
+set void AnnotationSetStyle=2542(line line, int style)
+
+# Get the style number for the annotations for a line
+get int AnnotationGetStyle=2543(line line,)
+
+# Set the annotation styles for a line
+set void AnnotationSetStyles=2544(line line, string styles)
+
+# Get the annotation styles for a line
+get int AnnotationGetStyles=2545(line line, stringresult styles)
+
+# Get the number of annotation lines for a line
+get int AnnotationGetLines=2546(line line,)
+
+# Clear the annotations from all lines
+fun void AnnotationClearAll=2547(,)
+
+enu AnnotationVisible=ANNOTATION_
+val ANNOTATION_HIDDEN=0
+val ANNOTATION_STANDARD=1
+val ANNOTATION_BOXED=2
+val ANNOTATION_INDENTED=3
+
+# Set the visibility for the annotations for a view
+set void AnnotationSetVisible=2548(AnnotationVisible visible,)
+
+# Get the visibility for the annotations for a view
+get AnnotationVisible AnnotationGetVisible=2549(,)
+
+# Get the start of the range of style numbers used for annotations
+set void AnnotationSetStyleOffset=2550(int style,)
+
+# Get the start of the range of style numbers used for annotations
+get int AnnotationGetStyleOffset=2551(,)
+
+# Release all extended (>255) style numbers
+fun void ReleaseAllExtendedStyles=2552(,)
+
+# Allocate some extended (>255) style numbers and return the start of the range
+fun int AllocateExtendedStyles=2553(int numberStyles,)
+
+enu UndoFlags=UNDO_
+val UNDO_NONE=0
+val UNDO_MAY_COALESCE=1
+
+# Add a container action to the undo stack
+fun void AddUndoAction=2560(int token, UndoFlags flags)
+
+# Find the position of a character from a point within the window.
+fun position CharPositionFromPoint=2561(int x, int y)
+
+# Find the position of a character from a point within the window.
+# Return INVALID_POSITION if not close to text.
+fun position CharPositionFromPointClose=2562(int x, int y)
+
+# Set whether switching to rectangular mode while selecting with the mouse is allowed.
+set void SetMouseSelectionRectangularSwitch=2668(bool mouseSelectionRectangularSwitch,)
+
+# Whether switching to rectangular mode while selecting with the mouse is allowed.
+get bool GetMouseSelectionRectangularSwitch=2669(,)
+
+# Set whether multiple selections can be made
+set void SetMultipleSelection=2563(bool multipleSelection,)
+
+# Whether multiple selections can be made
+get bool GetMultipleSelection=2564(,)
+
+# Set whether typing can be performed into multiple selections
+set void SetAdditionalSelectionTyping=2565(bool additionalSelectionTyping,)
+
+# Whether typing can be performed into multiple selections
+get bool GetAdditionalSelectionTyping=2566(,)
+
+# Set whether additional carets will blink
+set void SetAdditionalCaretsBlink=2567(bool additionalCaretsBlink,)
+
+# Whether additional carets will blink
+get bool GetAdditionalCaretsBlink=2568(,)
+
+# Set whether additional carets are visible
+set void SetAdditionalCaretsVisible=2608(bool additionalCaretsVisible,)
+
+# Whether additional carets are visible
+get bool GetAdditionalCaretsVisible=2609(,)
+
+# How many selections are there?
+get int GetSelections=2570(,)
+
+# Is every selected range empty?
+get bool GetSelectionEmpty=2650(,)
+
+# Clear selections to a single empty stream selection
+fun void ClearSelections=2571(,)
+
+# Set a simple selection
+fun void SetSelection=2572(position caret, position anchor)
+
+# Add a selection
+fun void AddSelection=2573(position caret, position anchor)
+
+# Drop one selection
+fun void DropSelectionN=2671(int selection,)
+
+# Set the main selection
+set void SetMainSelection=2574(int selection,)
+
+# Which selection is the main selection
+get int GetMainSelection=2575(,)
+
+# Set the caret position of the nth selection.
+set void SetSelectionNCaret=2576(int selection, position caret)
+
+# Return the caret position of the nth selection.
+get position GetSelectionNCaret=2577(int selection,)
+
+# Set the anchor position of the nth selection.
+set void SetSelectionNAnchor=2578(int selection, position anchor)
+
+# Return the anchor position of the nth selection.
+get position GetSelectionNAnchor=2579(int selection,)
+
+# Set the virtual space of the caret of the nth selection.
+set void SetSelectionNCaretVirtualSpace=2580(int selection, position space)
+
+# Return the virtual space of the caret of the nth selection.
+get position GetSelectionNCaretVirtualSpace=2581(int selection,)
+
+# Set the virtual space of the anchor of the nth selection.
+set void SetSelectionNAnchorVirtualSpace=2582(int selection, position space)
+
+# Return the virtual space of the anchor of the nth selection.
+get position GetSelectionNAnchorVirtualSpace=2583(int selection,)
+
+# Sets the position that starts the selection - this becomes the anchor.
+set void SetSelectionNStart=2584(int selection, position anchor)
+
+# Returns the position at the start of the selection.
+get position GetSelectionNStart=2585(int selection,)
+
+# Returns the virtual space at the start of the selection.
+get position GetSelectionNStartVirtualSpace=2726(int selection,)
+
+# Sets the position that ends the selection - this becomes the currentPosition.
+set void SetSelectionNEnd=2586(int selection, position caret)
+
+# Returns the virtual space at the end of the selection.
+get position GetSelectionNEndVirtualSpace=2727(int selection,)
+
+# Returns the position at the end of the selection.
+get position GetSelectionNEnd=2587(int selection,)
+
+# Set the caret position of the rectangular selection.
+set void SetRectangularSelectionCaret=2588(position caret,)
+
+# Return the caret position of the rectangular selection.
+get position GetRectangularSelectionCaret=2589(,)
+
+# Set the anchor position of the rectangular selection.
+set void SetRectangularSelectionAnchor=2590(position anchor,)
+
+# Return the anchor position of the rectangular selection.
+get position GetRectangularSelectionAnchor=2591(,)
+
+# Set the virtual space of the caret of the rectangular selection.
+set void SetRectangularSelectionCaretVirtualSpace=2592(position space,)
+
+# Return the virtual space of the caret of the rectangular selection.
+get position GetRectangularSelectionCaretVirtualSpace=2593(,)
+
+# Set the virtual space of the anchor of the rectangular selection.
+set void SetRectangularSelectionAnchorVirtualSpace=2594(position space,)
+
+# Return the virtual space of the anchor of the rectangular selection.
+get position GetRectangularSelectionAnchorVirtualSpace=2595(,)
+
+enu VirtualSpace=SCVS_
+val SCVS_NONE=0
+val SCVS_RECTANGULARSELECTION=1
+val SCVS_USERACCESSIBLE=2
+val SCVS_NOWRAPLINESTART=4
+
+ali SCVS_RECTANGULARSELECTION=RECTANGULAR_SELECTION
+ali SCVS_USERACCESSIBLE=USER_ACCESSIBLE
+ali SCVS_NOWRAPLINESTART=NO_WRAP_LINE_START
+
+# Set options for virtual space behaviour.
+set void SetVirtualSpaceOptions=2596(VirtualSpace virtualSpaceOptions,)
+
+# Return options for virtual space behaviour.
+get VirtualSpace GetVirtualSpaceOptions=2597(,)
+
+# On GTK, allow selecting the modifier key to use for mouse-based
+# rectangular selection. Often the window manager requires Alt+Mouse Drag
+# for moving windows.
+# Valid values are SCMOD_CTRL(default), SCMOD_ALT, or SCMOD_SUPER.
+
+set void SetRectangularSelectionModifier=2598(int modifier,)
+
+# Get the modifier key used for rectangular selection.
+get int GetRectangularSelectionModifier=2599(,)
+
+# Set the foreground colour of additional selections.
+# Must have previously called SetSelFore with non-zero first argument for this to have an effect.
+set void SetAdditionalSelFore=2600(colour fore,)
+
+# Set the background colour of additional selections.
+# Must have previously called SetSelBack with non-zero first argument for this to have an effect.
+set void SetAdditionalSelBack=2601(colour back,)
+
+# Set the alpha of the selection.
+set void SetAdditionalSelAlpha=2602(Alpha alpha,)
+
+# Get the alpha of the selection.
+get Alpha GetAdditionalSelAlpha=2603(,)
+
+# Set the foreground colour of additional carets.
+set void SetAdditionalCaretFore=2604(colour fore,)
+
+# Get the foreground colour of additional carets.
+get colour GetAdditionalCaretFore=2605(,)
+
+# Set the main selection to the next selection.
+fun void RotateSelection=2606(,)
+
+# Swap that caret and anchor of the main selection.
+fun void SwapMainAnchorCaret=2607(,)
+
+# Add the next occurrence of the main selection to the set of selections as main.
+# If the current selection is empty then select word around caret.
+fun void MultipleSelectAddNext=2688(,)
+
+# Add each occurrence of the main selection in the target to the set of selections.
+# If the current selection is empty then select word around caret.
+fun void MultipleSelectAddEach=2689(,)
+
+# Indicate that the internal state of a lexer has changed over a range and therefore
+# there may be a need to redraw.
+fun int ChangeLexerState=2617(position start, position end)
+
+# Find the next line at or after lineStart that is a contracted fold header line.
+# Return -1 when no more lines.
+fun line ContractedFoldNext=2618(line lineStart,)
+
+# Centre current line in window.
+fun void VerticalCentreCaret=2619(,)
+
+# Move the selected lines up one line, shifting the line above after the selection
+fun void MoveSelectedLinesUp=2620(,)
+
+# Move the selected lines down one line, shifting the line below before the selection
+fun void MoveSelectedLinesDown=2621(,)
+
+# Set the identifier reported as idFrom in notification messages.
+set void SetIdentifier=2622(int identifier,)
+
+# Get the identifier.
+get int GetIdentifier=2623(,)
+
+# Set the width for future RGBA image data.
+set void RGBAImageSetWidth=2624(int width,)
+
+# Set the height for future RGBA image data.
+set void RGBAImageSetHeight=2625(int height,)
+
+# Set the scale factor in percent for future RGBA image data.
+set void RGBAImageSetScale=2651(int scalePercent,)
+
+# Define a marker from RGBA data.
+# It has the width and height from RGBAImageSetWidth/Height
+fun void MarkerDefineRGBAImage=2626(int markerNumber, string pixels)
+
+# Register an RGBA image for use in autocompletion lists.
+# It has the width and height from RGBAImageSetWidth/Height
+fun void RegisterRGBAImage=2627(int type, string pixels)
+
+# Scroll to start of document.
+fun void ScrollToStart=2628(,)
+
+# Scroll to end of document.
+fun void ScrollToEnd=2629(,)
+
+enu Technology=SC_TECHNOLOGY_
+val SC_TECHNOLOGY_DEFAULT=0
+val SC_TECHNOLOGY_DIRECTWRITE=1
+val SC_TECHNOLOGY_DIRECTWRITERETAIN=2
+val SC_TECHNOLOGY_DIRECTWRITEDC=3
+
+ali SC_TECHNOLOGY_DIRECTWRITE=DIRECT_WRITE
+ali SC_TECHNOLOGY_DIRECTWRITERETAIN=DIRECT_WRITE_RETAIN
+ali SC_TECHNOLOGY_DIRECTWRITEDC=DIRECT_WRITE_D_C
+
+# Set the technology used.
+set void SetTechnology=2630(Technology technology,)
+
+# Get the tech.
+get Technology GetTechnology=2631(,)
+
+# Create an ILoader*.
+fun pointer CreateLoader=2632(position bytes, DocumentOption documentOptions)
+
+# On OS X, show a find indicator.
+fun void FindIndicatorShow=2640(position start, position end)
+
+# On OS X, flash a find indicator, then fade out.
+fun void FindIndicatorFlash=2641(position start, position end)
+
+# On OS X, hide the find indicator.
+fun void FindIndicatorHide=2642(,)
+
+# Move caret to before first visible character on display line.
+# If already there move to first character on display line.
+fun void VCHomeDisplay=2652(,)
+
+# Like VCHomeDisplay but extending selection to new caret position.
+fun void VCHomeDisplayExtend=2653(,)
+
+# Is the caret line always visible?
+get bool GetCaretLineVisibleAlways=2654(,)
+
+# Sets the caret line to always visible.
+set void SetCaretLineVisibleAlways=2655(bool alwaysVisible,)
+
+# Line end types which may be used in addition to LF, CR, and CRLF
+# SC_LINE_END_TYPE_UNICODE includes U+2028 Line Separator,
+# U+2029 Paragraph Separator, and U+0085 Next Line
+enu LineEndType=SC_LINE_END_TYPE_
+val SC_LINE_END_TYPE_DEFAULT=0
+val SC_LINE_END_TYPE_UNICODE=1
+
+# Set the line end types that the application wants to use. May not be used if incompatible with lexer or encoding.
+set void SetLineEndTypesAllowed=2656(LineEndType lineEndBitSet,)
+
+# Get the line end types currently allowed.
+get LineEndType GetLineEndTypesAllowed=2657(,)
+
+# Get the line end types currently recognised. May be a subset of the allowed types due to lexer limitation.
+get LineEndType GetLineEndTypesActive=2658(,)
+
+# Set the way a character is drawn.
+set void SetRepresentation=2665(string encodedCharacter, string representation)
+
+# Set the way a character is drawn.
+# Result is NUL-terminated.
+get int GetRepresentation=2666(string encodedCharacter, stringresult representation)
+
+# Remove a character representation.
+fun void ClearRepresentation=2667(string encodedCharacter,)
+
+# Set the end of line annotation text for a line
+set void EOLAnnotationSetText=2740(line line, string text)
+
+# Get the end of line annotation text for a line
+get int EOLAnnotationGetText=2741(line line, stringresult text)
+
+# Set the style number for the end of line annotations for a line
+set void EOLAnnotationSetStyle=2742(line line, int style)
+
+# Get the style number for the end of line annotations for a line
+get int EOLAnnotationGetStyle=2743(line line,)
+
+# Clear the end of annotations from all lines
+fun void EOLAnnotationClearAll=2744(,)
+
+enu EOLAnnotationVisible=EOLANNOTATION_
+val EOLANNOTATION_HIDDEN=0
+val EOLANNOTATION_STANDARD=1
+val EOLANNOTATION_BOXED=2
+
+# Set the visibility for the end of line annotations for a view
+set void EOLAnnotationSetVisible=2745(EOLAnnotationVisible visible,)
+
+# Get the visibility for the end of line annotations for a view
+get EOLAnnotationVisible EOLAnnotationGetVisible=2746(,)
+
+# Get the start of the range of style numbers used for end of line annotations
+set void EOLAnnotationSetStyleOffset=2747(int style,)
+
+# Get the start of the range of style numbers used for end of line annotations
+get int EOLAnnotationGetStyleOffset=2748(,)
+
+# Start notifying the container of all key presses and commands.
+fun void StartRecord=3001(,)
+
+# Stop notifying the container of all key presses and commands.
+fun void StopRecord=3002(,)
+
+# Set the lexing language of the document.
+set void SetLexer=4001(int lexer,)
+
+# Retrieve the lexing language of the document.
+get int GetLexer=4002(,)
+
+# Colourise a segment of the document using the current lexing language.
+fun void Colourise=4003(position start, position end)
+
+# Set up a value that may be used by a lexer for some optional feature.
+set void SetProperty=4004(string key, string value)
+
+# Maximum value of keywordSet parameter of SetKeyWords.
+val KEYWORDSET_MAX=8
+
+# Set up the key words used by the lexer.
+set void SetKeyWords=4005(int keyWordSet, string keyWords)
+
+# Set the lexing language of the document based on string name.
+set void SetLexerLanguage=4006(, string language)
+
+# Load a lexer library (dll / so).
+fun void LoadLexerLibrary=4007(, string path)
+
+# Retrieve a "property" value previously set with SetProperty.
+# Result is NUL-terminated.
+get int GetProperty=4008(string key, stringresult value)
+
+# Retrieve a "property" value previously set with SetProperty,
+# with "$()" variable replacement on returned buffer.
+# Result is NUL-terminated.
+get int GetPropertyExpanded=4009(string key, stringresult value)
+
+# Retrieve a "property" value previously set with SetProperty,
+# interpreted as an int AFTER any "$()" variable replacement.
+get int GetPropertyInt=4010(string key, int defaultValue)
+
+# Retrieve the name of the lexer.
+# Return the length of the text.
+# Result is NUL-terminated.
+get int GetLexerLanguage=4012(, stringresult language)
+
+# For private communication between an application and a known lexer.
+fun pointer PrivateLexerCall=4013(int operation, pointer pointer)
+
+# Retrieve a '\n' separated list of properties understood by the current lexer.
+# Result is NUL-terminated.
+fun int PropertyNames=4014(, stringresult names)
+
+enu TypeProperty=SC_TYPE_
+val SC_TYPE_BOOLEAN=0
+val SC_TYPE_INTEGER=1
+val SC_TYPE_STRING=2
+
+# Retrieve the type of a property.
+fun TypeProperty PropertyType=4015(string name,)
+
+# Describe a property.
+# Result is NUL-terminated.
+fun int DescribeProperty=4016(string name, stringresult description)
+
+# Retrieve a '\n' separated list of descriptions of the keyword sets understood by the current lexer.
+# Result is NUL-terminated.
+fun int DescribeKeyWordSets=4017(, stringresult descriptions)
+
+# Bit set of LineEndType enumertion for which line ends beyond the standard
+# LF, CR, and CRLF are supported by the lexer.
+get int GetLineEndTypesSupported=4018(,)
+
+# Allocate a set of sub styles for a particular base style, returning start of range
+fun int AllocateSubStyles=4020(int styleBase, int numberStyles)
+
+# The starting style number for the sub styles associated with a base style
+get int GetSubStylesStart=4021(int styleBase,)
+
+# The number of sub styles associated with a base style
+get int GetSubStylesLength=4022(int styleBase,)
+
+# For a sub style, return the base style, else return the argument.
+get int GetStyleFromSubStyle=4027(int subStyle,)
+
+# For a secondary style, return the primary style, else return the argument.
+get int GetPrimaryStyleFromStyle=4028(int style,)
+
+# Free allocated sub styles
+fun void FreeSubStyles=4023(,)
+
+# Set the identifiers that are shown in a particular style
+set void SetIdentifiers=4024(int style, string identifiers)
+
+# Where styles are duplicated by a feature such as active/inactive code
+# return the distance between the two types.
+get int DistanceToSecondaryStyles=4025(,)
+
+# Get the set of base styles that can be extended with sub styles
+# Result is NUL-terminated.
+get int GetSubStyleBases=4026(, stringresult styles)
+
+# Retrieve the number of named styles for the lexer.
+get int GetNamedStyles=4029(,)
+
+# Retrieve the name of a style.
+# Result is NUL-terminated.
+fun int NameOfStyle=4030(int style, stringresult name)
+
+# Retrieve a ' ' separated list of style tags like "literal quoted string".
+# Result is NUL-terminated.
+fun int TagsOfStyle=4031(int style, stringresult tags)
+
+# Retrieve a description of a style.
+# Result is NUL-terminated.
+fun int DescriptionOfStyle=4032(int style, stringresult description)
+
+# Set the lexer from an ILexer*.
+set void SetILexer=4033(, pointer ilexer)
+
+# Notifications
+# Type of modification and the action which caused the modification.
+# These are defined as a bit mask to make it easy to specify which notifications are wanted.
+# One bit is set from each of SC_MOD_* and SC_PERFORMED_*.
+enu ModificationFlags=SC_MOD_ SC_PERFORMED_ SC_MULTISTEPUNDOREDO SC_LASTSTEPINUNDOREDO SC_MULTILINEUNDOREDO SC_STARTACTION SC_MODEVENTMASKALL
+val SC_MOD_NONE=0x0
+val SC_MOD_INSERTTEXT=0x1
+val SC_MOD_DELETETEXT=0x2
+val SC_MOD_CHANGESTYLE=0x4
+val SC_MOD_CHANGEFOLD=0x8
+val SC_PERFORMED_USER=0x10
+val SC_PERFORMED_UNDO=0x20
+val SC_PERFORMED_REDO=0x40
+val SC_MULTISTEPUNDOREDO=0x80
+val SC_LASTSTEPINUNDOREDO=0x100
+val SC_MOD_CHANGEMARKER=0x200
+val SC_MOD_BEFOREINSERT=0x400
+val SC_MOD_BEFOREDELETE=0x800
+val SC_MULTILINEUNDOREDO=0x1000
+val SC_STARTACTION=0x2000
+val SC_MOD_CHANGEINDICATOR=0x4000
+val SC_MOD_CHANGELINESTATE=0x8000
+val SC_MOD_CHANGEMARGIN=0x10000
+val SC_MOD_CHANGEANNOTATION=0x20000
+val SC_MOD_CONTAINER=0x40000
+val SC_MOD_LEXERSTATE=0x80000
+val SC_MOD_INSERTCHECK=0x100000
+val SC_MOD_CHANGETABSTOPS=0x200000
+val SC_MOD_CHANGEEOLANNOTATION=0x400000
+val SC_MODEVENTMASKALL=0x7FFFFF
+
+ali SC_MOD_INSERTTEXT=INSERT_TEXT
+ali SC_MOD_DELETETEXT=DELETE_TEXT
+ali SC_MOD_CHANGESTYLE=CHANGE_STYLE
+ali SC_MOD_CHANGEFOLD=CHANGE_FOLD
+ali SC_MULTISTEPUNDOREDO=MULTI_STEP_UNDO_REDO
+ali SC_LASTSTEPINUNDOREDO=LAST_STEP_IN_UNDO_REDO
+ali SC_MOD_CHANGEMARKER=CHANGE_MARKER
+ali SC_MOD_BEFOREINSERT=BEFORE_INSERT
+ali SC_MOD_BEFOREDELETE=BEFORE_DELETE
+ali SC_MULTILINEUNDOREDO=MULTILINE_UNDO_REDO
+ali SC_STARTACTION=START_ACTION
+ali SC_MOD_CHANGEINDICATOR=CHANGE_INDICATOR
+ali SC_MOD_CHANGELINESTATE=CHANGE_LINE_STATE
+ali SC_MOD_CHANGEMARGIN=CHANGE_MARGIN
+ali SC_MOD_CHANGEANNOTATION=CHANGE_ANNOTATION
+ali SC_MOD_LEXERSTATE=LEXER_STATE
+ali SC_MOD_INSERTCHECK=INSERT_CHECK
+ali SC_MOD_CHANGETABSTOPS=CHANGE_TAB_STOPS
+ali SC_MOD_CHANGEEOLANNOTATION=CHANGE_E_O_L_ANNOTATION
+ali SC_MODEVENTMASKALL=EVENT_MASK_ALL
+
+enu Update=SC_UPDATE_
+val SC_UPDATE_CONTENT=0x1
+val SC_UPDATE_SELECTION=0x2
+val SC_UPDATE_V_SCROLL=0x4
+val SC_UPDATE_H_SCROLL=0x8
+
+# For compatibility, these go through the COMMAND notification rather than NOTIFY
+# and should have had exactly the same values as the EN_* constants.
+# Unfortunately the SETFOCUS and KILLFOCUS are flipped over from EN_*
+# As clients depend on these constants, this will not be changed.
+val SCEN_CHANGE=768
+val SCEN_SETFOCUS=512
+val SCEN_KILLFOCUS=256
+
+# Symbolic key codes and modifier flags.
+# ASCII and other printable characters below 256.
+# Extended keys above 300.
+
+enu Keys=SCK_
+val SCK_DOWN=300
+val SCK_UP=301
+val SCK_LEFT=302
+val SCK_RIGHT=303
+val SCK_HOME=304
+val SCK_END=305
+val SCK_PRIOR=306
+val SCK_NEXT=307
+val SCK_DELETE=308
+val SCK_INSERT=309
+val SCK_ESCAPE=7
+val SCK_BACK=8
+val SCK_TAB=9
+val SCK_RETURN=13
+val SCK_ADD=310
+val SCK_SUBTRACT=311
+val SCK_DIVIDE=312
+val SCK_WIN=313
+val SCK_RWIN=314
+val SCK_MENU=315
+
+ali SCK_RWIN=R_WIN
+
+enu KeyMod=SCMOD_
+val SCMOD_NORM=0
+val SCMOD_SHIFT=1
+val SCMOD_CTRL=2
+val SCMOD_ALT=4
+val SCMOD_SUPER=8
+val SCMOD_META=16
+
+enu CompletionMethods=SC_AC_
+val SC_AC_FILLUP=1
+val SC_AC_DOUBLECLICK=2
+val SC_AC_TAB=3
+val SC_AC_NEWLINE=4
+val SC_AC_COMMAND=5
+
+ali SC_AC_FILLUP=FILL_UP
+ali SC_AC_DOUBLECLICK=DOUBLE_CLICK
+
+# characterSource for SCN_CHARADDED
+enu CharacterSource=SC_CHARACTERSOURCE_
+# Direct input characters.
+val SC_CHARACTERSOURCE_DIRECT_INPUT=0
+# IME (inline mode) or dead key tentative input characters.
+val SC_CHARACTERSOURCE_TENTATIVE_INPUT=1
+# IME (either inline or windowed mode) full composited string.
+val SC_CHARACTERSOURCE_IME_RESULT=2
+
+################################################
+# For SciLexer.h
+enu Lexer=SCLEX_
+val SCLEX_CONTAINER=0
+val SCLEX_NULL=1
+val SCLEX_PYTHON=2
+val SCLEX_CPP=3
+val SCLEX_HTML=4
+val SCLEX_XML=5
+val SCLEX_PERL=6
+val SCLEX_SQL=7
+val SCLEX_VB=8
+val SCLEX_PROPERTIES=9
+val SCLEX_ERRORLIST=10
+val SCLEX_MAKEFILE=11
+val SCLEX_BATCH=12
+val SCLEX_XCODE=13
+val SCLEX_LATEX=14
+val SCLEX_LUA=15
+val SCLEX_DIFF=16
+val SCLEX_CONF=17
+val SCLEX_PASCAL=18
+val SCLEX_AVE=19
+val SCLEX_ADA=20
+val SCLEX_LISP=21
+val SCLEX_RUBY=22
+val SCLEX_EIFFEL=23
+val SCLEX_EIFFELKW=24
+val SCLEX_TCL=25
+val SCLEX_NNCRONTAB=26
+val SCLEX_BULLANT=27
+val SCLEX_VBSCRIPT=28
+val SCLEX_BAAN=31
+val SCLEX_MATLAB=32
+val SCLEX_SCRIPTOL=33
+val SCLEX_ASM=34
+val SCLEX_CPPNOCASE=35
+val SCLEX_FORTRAN=36
+val SCLEX_F77=37
+val SCLEX_CSS=38
+val SCLEX_POV=39
+val SCLEX_LOUT=40
+val SCLEX_ESCRIPT=41
+val SCLEX_PS=42
+val SCLEX_NSIS=43
+val SCLEX_MMIXAL=44
+val SCLEX_CLW=45
+val SCLEX_CLWNOCASE=46
+val SCLEX_LOT=47
+val SCLEX_YAML=48
+val SCLEX_TEX=49
+val SCLEX_METAPOST=50
+val SCLEX_POWERBASIC=51
+val SCLEX_FORTH=52
+val SCLEX_ERLANG=53
+val SCLEX_OCTAVE=54
+val SCLEX_MSSQL=55
+val SCLEX_VERILOG=56
+val SCLEX_KIX=57
+val SCLEX_GUI4CLI=58
+val SCLEX_SPECMAN=59
+val SCLEX_AU3=60
+val SCLEX_APDL=61
+val SCLEX_BASH=62
+val SCLEX_ASN1=63
+val SCLEX_VHDL=64
+val SCLEX_CAML=65
+val SCLEX_BLITZBASIC=66
+val SCLEX_PUREBASIC=67
+val SCLEX_HASKELL=68
+val SCLEX_PHPSCRIPT=69
+val SCLEX_TADS3=70
+val SCLEX_REBOL=71
+val SCLEX_SMALLTALK=72
+val SCLEX_FLAGSHIP=73
+val SCLEX_CSOUND=74
+val SCLEX_FREEBASIC=75
+val SCLEX_INNOSETUP=76
+val SCLEX_OPAL=77
+val SCLEX_SPICE=78
+val SCLEX_D=79
+val SCLEX_CMAKE=80
+val SCLEX_GAP=81
+val SCLEX_PLM=82
+val SCLEX_PROGRESS=83
+val SCLEX_ABAQUS=84
+val SCLEX_ASYMPTOTE=85
+val SCLEX_R=86
+val SCLEX_MAGIK=87
+val SCLEX_POWERSHELL=88
+val SCLEX_MYSQL=89
+val SCLEX_PO=90
+val SCLEX_TAL=91
+val SCLEX_COBOL=92
+val SCLEX_TACL=93
+val SCLEX_SORCUS=94
+val SCLEX_POWERPRO=95
+val SCLEX_NIMROD=96
+val SCLEX_SML=97
+val SCLEX_MARKDOWN=98
+val SCLEX_TXT2TAGS=99
+val SCLEX_A68K=100
+val SCLEX_MODULA=101
+val SCLEX_COFFEESCRIPT=102
+val SCLEX_TCMD=103
+val SCLEX_AVS=104
+val SCLEX_ECL=105
+val SCLEX_OSCRIPT=106
+val SCLEX_VISUALPROLOG=107
+val SCLEX_LITERATEHASKELL=108
+val SCLEX_STTXT=109
+val SCLEX_KVIRC=110
+val SCLEX_RUST=111
+val SCLEX_DMAP=112
+val SCLEX_AS=113
+val SCLEX_DMIS=114
+val SCLEX_REGISTRY=115
+val SCLEX_BIBTEX=116
+val SCLEX_SREC=117
+val SCLEX_IHEX=118
+val SCLEX_TEHEX=119
+val SCLEX_JSON=120
+val SCLEX_EDIFACT=121
+val SCLEX_INDENT=122
+val SCLEX_MAXIMA=123
+val SCLEX_STATA=124
+val SCLEX_SAS=125
+val SCLEX_NIM=126
+val SCLEX_CIL=127
+val SCLEX_X12=128
+val SCLEX_DATAFLEX=129
+val SCLEX_HOLLYWOOD=130
+val SCLEX_RAKU=131
+
+# When a lexer specifies its language as SCLEX_AUTOMATIC it receives a
+# value assigned in sequence from SCLEX_AUTOMATIC+1.
+val SCLEX_AUTOMATIC=1000
+# Lexical states for SCLEX_PYTHON
+lex Python=SCLEX_PYTHON SCE_P_
+lex Nimrod=SCLEX_NIMROD SCE_P_
+val SCE_P_DEFAULT=0
+val SCE_P_COMMENTLINE=1
+val SCE_P_NUMBER=2
+val SCE_P_STRING=3
+val SCE_P_CHARACTER=4
+val SCE_P_WORD=5
+val SCE_P_TRIPLE=6
+val SCE_P_TRIPLEDOUBLE=7
+val SCE_P_CLASSNAME=8
+val SCE_P_DEFNAME=9
+val SCE_P_OPERATOR=10
+val SCE_P_IDENTIFIER=11
+val SCE_P_COMMENTBLOCK=12
+val SCE_P_STRINGEOL=13
+val SCE_P_WORD2=14
+val SCE_P_DECORATOR=15
+val SCE_P_FSTRING=16
+val SCE_P_FCHARACTER=17
+val SCE_P_FTRIPLE=18
+val SCE_P_FTRIPLEDOUBLE=19
+# Lexical states for SCLEX_CPP
+# Lexical states for SCLEX_BULLANT
+# Lexical states for SCLEX_COBOL
+# Lexical states for SCLEX_TACL
+# Lexical states for SCLEX_TAL
+lex Cpp=SCLEX_CPP SCE_C_
+lex BullAnt=SCLEX_BULLANT SCE_C_
+lex COBOL=SCLEX_COBOL SCE_C_
+lex TACL=SCLEX_TACL SCE_C_
+lex TAL=SCLEX_TAL SCE_C_
+val SCE_C_DEFAULT=0
+val SCE_C_COMMENT=1
+val SCE_C_COMMENTLINE=2
+val SCE_C_COMMENTDOC=3
+val SCE_C_NUMBER=4
+val SCE_C_WORD=5
+val SCE_C_STRING=6
+val SCE_C_CHARACTER=7
+val SCE_C_UUID=8
+val SCE_C_PREPROCESSOR=9
+val SCE_C_OPERATOR=10
+val SCE_C_IDENTIFIER=11
+val SCE_C_STRINGEOL=12
+val SCE_C_VERBATIM=13
+val SCE_C_REGEX=14
+val SCE_C_COMMENTLINEDOC=15
+val SCE_C_WORD2=16
+val SCE_C_COMMENTDOCKEYWORD=17
+val SCE_C_COMMENTDOCKEYWORDERROR=18
+val SCE_C_GLOBALCLASS=19
+val SCE_C_STRINGRAW=20
+val SCE_C_TRIPLEVERBATIM=21
+val SCE_C_HASHQUOTEDSTRING=22
+val SCE_C_PREPROCESSORCOMMENT=23
+val SCE_C_PREPROCESSORCOMMENTDOC=24
+val SCE_C_USERLITERAL=25
+val SCE_C_TASKMARKER=26
+val SCE_C_ESCAPESEQUENCE=27
+# Lexical states for SCLEX_D
+lex D=SCLEX_D SCE_D_
+val SCE_D_DEFAULT=0
+val SCE_D_COMMENT=1
+val SCE_D_COMMENTLINE=2
+val SCE_D_COMMENTDOC=3
+val SCE_D_COMMENTNESTED=4
+val SCE_D_NUMBER=5
+val SCE_D_WORD=6
+val SCE_D_WORD2=7
+val SCE_D_WORD3=8
+val SCE_D_TYPEDEF=9
+val SCE_D_STRING=10
+val SCE_D_STRINGEOL=11
+val SCE_D_CHARACTER=12
+val SCE_D_OPERATOR=13
+val SCE_D_IDENTIFIER=14
+val SCE_D_COMMENTLINEDOC=15
+val SCE_D_COMMENTDOCKEYWORD=16
+val SCE_D_COMMENTDOCKEYWORDERROR=17
+val SCE_D_STRINGB=18
+val SCE_D_STRINGR=19
+val SCE_D_WORD5=20
+val SCE_D_WORD6=21
+val SCE_D_WORD7=22
+# Lexical states for SCLEX_TCL
+lex TCL=SCLEX_TCL SCE_TCL_
+val SCE_TCL_DEFAULT=0
+val SCE_TCL_COMMENT=1
+val SCE_TCL_COMMENTLINE=2
+val SCE_TCL_NUMBER=3
+val SCE_TCL_WORD_IN_QUOTE=4
+val SCE_TCL_IN_QUOTE=5
+val SCE_TCL_OPERATOR=6
+val SCE_TCL_IDENTIFIER=7
+val SCE_TCL_SUBSTITUTION=8
+val SCE_TCL_SUB_BRACE=9
+val SCE_TCL_MODIFIER=10
+val SCE_TCL_EXPAND=11
+val SCE_TCL_WORD=12
+val SCE_TCL_WORD2=13
+val SCE_TCL_WORD3=14
+val SCE_TCL_WORD4=15
+val SCE_TCL_WORD5=16
+val SCE_TCL_WORD6=17
+val SCE_TCL_WORD7=18
+val SCE_TCL_WORD8=19
+val SCE_TCL_COMMENT_BOX=20
+val SCE_TCL_BLOCK_COMMENT=21
+# Lexical states for SCLEX_HTML, SCLEX_XML
+lex HTML=SCLEX_HTML SCE_H_ SCE_HJ_ SCE_HJA_ SCE_HB_ SCE_HBA_ SCE_HP_ SCE_HPHP_ SCE_HPA_
+lex XML=SCLEX_XML SCE_H_ SCE_HJ_ SCE_HJA_ SCE_HB_ SCE_HBA_ SCE_HP_ SCE_HPHP_ SCE_HPA_
+val SCE_H_DEFAULT=0
+val SCE_H_TAG=1
+val SCE_H_TAGUNKNOWN=2
+val SCE_H_ATTRIBUTE=3
+val SCE_H_ATTRIBUTEUNKNOWN=4
+val SCE_H_NUMBER=5
+val SCE_H_DOUBLESTRING=6
+val SCE_H_SINGLESTRING=7
+val SCE_H_OTHER=8
+val SCE_H_COMMENT=9
+val SCE_H_ENTITY=10
+# XML and ASP
+val SCE_H_TAGEND=11
+val SCE_H_XMLSTART=12
+val SCE_H_XMLEND=13
+val SCE_H_SCRIPT=14
+val SCE_H_ASP=15
+val SCE_H_ASPAT=16
+val SCE_H_CDATA=17
+val SCE_H_QUESTION=18
+# More HTML
+val SCE_H_VALUE=19
+# X-Code
+val SCE_H_XCCOMMENT=20
+# SGML
+val SCE_H_SGML_DEFAULT=21
+val SCE_H_SGML_COMMAND=22
+val SCE_H_SGML_1ST_PARAM=23
+val SCE_H_SGML_DOUBLESTRING=24
+val SCE_H_SGML_SIMPLESTRING=25
+val SCE_H_SGML_ERROR=26
+val SCE_H_SGML_SPECIAL=27
+val SCE_H_SGML_ENTITY=28
+val SCE_H_SGML_COMMENT=29
+val SCE_H_SGML_1ST_PARAM_COMMENT=30
+val SCE_H_SGML_BLOCK_DEFAULT=31
+# Embedded Javascript
+val SCE_HJ_START=40
+val SCE_HJ_DEFAULT=41
+val SCE_HJ_COMMENT=42
+val SCE_HJ_COMMENTLINE=43
+val SCE_HJ_COMMENTDOC=44
+val SCE_HJ_NUMBER=45
+val SCE_HJ_WORD=46
+val SCE_HJ_KEYWORD=47
+val SCE_HJ_DOUBLESTRING=48
+val SCE_HJ_SINGLESTRING=49
+val SCE_HJ_SYMBOLS=50
+val SCE_HJ_STRINGEOL=51
+val SCE_HJ_REGEX=52
+# ASP Javascript
+val SCE_HJA_START=55
+val SCE_HJA_DEFAULT=56
+val SCE_HJA_COMMENT=57
+val SCE_HJA_COMMENTLINE=58
+val SCE_HJA_COMMENTDOC=59
+val SCE_HJA_NUMBER=60
+val SCE_HJA_WORD=61
+val SCE_HJA_KEYWORD=62
+val SCE_HJA_DOUBLESTRING=63
+val SCE_HJA_SINGLESTRING=64
+val SCE_HJA_SYMBOLS=65
+val SCE_HJA_STRINGEOL=66
+val SCE_HJA_REGEX=67
+# Embedded VBScript
+val SCE_HB_START=70
+val SCE_HB_DEFAULT=71
+val SCE_HB_COMMENTLINE=72
+val SCE_HB_NUMBER=73
+val SCE_HB_WORD=74
+val SCE_HB_STRING=75
+val SCE_HB_IDENTIFIER=76
+val SCE_HB_STRINGEOL=77
+# ASP VBScript
+val SCE_HBA_START=80
+val SCE_HBA_DEFAULT=81
+val SCE_HBA_COMMENTLINE=82
+val SCE_HBA_NUMBER=83
+val SCE_HBA_WORD=84
+val SCE_HBA_STRING=85
+val SCE_HBA_IDENTIFIER=86
+val SCE_HBA_STRINGEOL=87
+# Embedded Python
+val SCE_HP_START=90
+val SCE_HP_DEFAULT=91
+val SCE_HP_COMMENTLINE=92
+val SCE_HP_NUMBER=93
+val SCE_HP_STRING=94
+val SCE_HP_CHARACTER=95
+val SCE_HP_WORD=96
+val SCE_HP_TRIPLE=97
+val SCE_HP_TRIPLEDOUBLE=98
+val SCE_HP_CLASSNAME=99
+val SCE_HP_DEFNAME=100
+val SCE_HP_OPERATOR=101
+val SCE_HP_IDENTIFIER=102
+# PHP
+val SCE_HPHP_COMPLEX_VARIABLE=104
+# ASP Python
+val SCE_HPA_START=105
+val SCE_HPA_DEFAULT=106
+val SCE_HPA_COMMENTLINE=107
+val SCE_HPA_NUMBER=108
+val SCE_HPA_STRING=109
+val SCE_HPA_CHARACTER=110
+val SCE_HPA_WORD=111
+val SCE_HPA_TRIPLE=112
+val SCE_HPA_TRIPLEDOUBLE=113
+val SCE_HPA_CLASSNAME=114
+val SCE_HPA_DEFNAME=115
+val SCE_HPA_OPERATOR=116
+val SCE_HPA_IDENTIFIER=117
+# PHP
+val SCE_HPHP_DEFAULT=118
+val SCE_HPHP_HSTRING=119
+val SCE_HPHP_SIMPLESTRING=120
+val SCE_HPHP_WORD=121
+val SCE_HPHP_NUMBER=122
+val SCE_HPHP_VARIABLE=123
+val SCE_HPHP_COMMENT=124
+val SCE_HPHP_COMMENTLINE=125
+val SCE_HPHP_HSTRING_VARIABLE=126
+val SCE_HPHP_OPERATOR=127
+# Lexical states for SCLEX_PERL
+lex Perl=SCLEX_PERL SCE_PL_
+val SCE_PL_DEFAULT=0
+val SCE_PL_ERROR=1
+val SCE_PL_COMMENTLINE=2
+val SCE_PL_POD=3
+val SCE_PL_NUMBER=4
+val SCE_PL_WORD=5
+val SCE_PL_STRING=6
+val SCE_PL_CHARACTER=7
+val SCE_PL_PUNCTUATION=8
+val SCE_PL_PREPROCESSOR=9
+val SCE_PL_OPERATOR=10
+val SCE_PL_IDENTIFIER=11
+val SCE_PL_SCALAR=12
+val SCE_PL_ARRAY=13
+val SCE_PL_HASH=14
+val SCE_PL_SYMBOLTABLE=15
+val SCE_PL_VARIABLE_INDEXER=16
+val SCE_PL_REGEX=17
+val SCE_PL_REGSUBST=18
+val SCE_PL_LONGQUOTE=19
+val SCE_PL_BACKTICKS=20
+val SCE_PL_DATASECTION=21
+val SCE_PL_HERE_DELIM=22
+val SCE_PL_HERE_Q=23
+val SCE_PL_HERE_QQ=24
+val SCE_PL_HERE_QX=25
+val SCE_PL_STRING_Q=26
+val SCE_PL_STRING_QQ=27
+val SCE_PL_STRING_QX=28
+val SCE_PL_STRING_QR=29
+val SCE_PL_STRING_QW=30
+val SCE_PL_POD_VERB=31
+val SCE_PL_SUB_PROTOTYPE=40
+val SCE_PL_FORMAT_IDENT=41
+val SCE_PL_FORMAT=42
+val SCE_PL_STRING_VAR=43
+val SCE_PL_XLAT=44
+val SCE_PL_REGEX_VAR=54
+val SCE_PL_REGSUBST_VAR=55
+val SCE_PL_BACKTICKS_VAR=57
+val SCE_PL_HERE_QQ_VAR=61
+val SCE_PL_HERE_QX_VAR=62
+val SCE_PL_STRING_QQ_VAR=64
+val SCE_PL_STRING_QX_VAR=65
+val SCE_PL_STRING_QR_VAR=66
+# Lexical states for SCLEX_RUBY
+lex Ruby=SCLEX_RUBY SCE_RB_
+val SCE_RB_DEFAULT=0
+val SCE_RB_ERROR=1
+val SCE_RB_COMMENTLINE=2
+val SCE_RB_POD=3
+val SCE_RB_NUMBER=4
+val SCE_RB_WORD=5
+val SCE_RB_STRING=6
+val SCE_RB_CHARACTER=7
+val SCE_RB_CLASSNAME=8
+val SCE_RB_DEFNAME=9
+val SCE_RB_OPERATOR=10
+val SCE_RB_IDENTIFIER=11
+val SCE_RB_REGEX=12
+val SCE_RB_GLOBAL=13
+val SCE_RB_SYMBOL=14
+val SCE_RB_MODULE_NAME=15
+val SCE_RB_INSTANCE_VAR=16
+val SCE_RB_CLASS_VAR=17
+val SCE_RB_BACKTICKS=18
+val SCE_RB_DATASECTION=19
+val SCE_RB_HERE_DELIM=20
+val SCE_RB_HERE_Q=21
+val SCE_RB_HERE_QQ=22
+val SCE_RB_HERE_QX=23
+val SCE_RB_STRING_Q=24
+val SCE_RB_STRING_QQ=25
+val SCE_RB_STRING_QX=26
+val SCE_RB_STRING_QR=27
+val SCE_RB_STRING_QW=28
+val SCE_RB_WORD_DEMOTED=29
+val SCE_RB_STDIN=30
+val SCE_RB_STDOUT=31
+val SCE_RB_STDERR=40
+val SCE_RB_UPPER_BOUND=41
+# Lexical states for SCLEX_VB, SCLEX_VBSCRIPT, SCLEX_POWERBASIC, SCLEX_BLITZBASIC, SCLEX_PUREBASIC, SCLEX_FREEBASIC
+lex VB=SCLEX_VB SCE_B_
+lex VBScript=SCLEX_VBSCRIPT SCE_B_
+lex PowerBasic=SCLEX_POWERBASIC SCE_B_
+lex BlitzBasic=SCLEX_BLITZBASIC SCE_B_
+lex PureBasic=SCLEX_PUREBASIC SCE_B_
+lex FreeBasic=SCLEX_FREEBASIC SCE_B_
+val SCE_B_DEFAULT=0
+val SCE_B_COMMENT=1
+val SCE_B_NUMBER=2
+val SCE_B_KEYWORD=3
+val SCE_B_STRING=4
+val SCE_B_PREPROCESSOR=5
+val SCE_B_OPERATOR=6
+val SCE_B_IDENTIFIER=7
+val SCE_B_DATE=8
+val SCE_B_STRINGEOL=9
+val SCE_B_KEYWORD2=10
+val SCE_B_KEYWORD3=11
+val SCE_B_KEYWORD4=12
+val SCE_B_CONSTANT=13
+val SCE_B_ASM=14
+val SCE_B_LABEL=15
+val SCE_B_ERROR=16
+val SCE_B_HEXNUMBER=17
+val SCE_B_BINNUMBER=18
+val SCE_B_COMMENTBLOCK=19
+val SCE_B_DOCLINE=20
+val SCE_B_DOCBLOCK=21
+val SCE_B_DOCKEYWORD=22
+# Lexical states for SCLEX_PROPERTIES
+lex Properties=SCLEX_PROPERTIES SCE_PROPS_
+val SCE_PROPS_DEFAULT=0
+val SCE_PROPS_COMMENT=1
+val SCE_PROPS_SECTION=2
+val SCE_PROPS_ASSIGNMENT=3
+val SCE_PROPS_DEFVAL=4
+val SCE_PROPS_KEY=5
+# Lexical states for SCLEX_LATEX
+lex LaTeX=SCLEX_LATEX SCE_L_
+val SCE_L_DEFAULT=0
+val SCE_L_COMMAND=1
+val SCE_L_TAG=2
+val SCE_L_MATH=3
+val SCE_L_COMMENT=4
+val SCE_L_TAG2=5
+val SCE_L_MATH2=6
+val SCE_L_COMMENT2=7
+val SCE_L_VERBATIM=8
+val SCE_L_SHORTCMD=9
+val SCE_L_SPECIAL=10
+val SCE_L_CMDOPT=11
+val SCE_L_ERROR=12
+# Lexical states for SCLEX_LUA
+lex Lua=SCLEX_LUA SCE_LUA_
+val SCE_LUA_DEFAULT=0
+val SCE_LUA_COMMENT=1
+val SCE_LUA_COMMENTLINE=2
+val SCE_LUA_COMMENTDOC=3
+val SCE_LUA_NUMBER=4
+val SCE_LUA_WORD=5
+val SCE_LUA_STRING=6
+val SCE_LUA_CHARACTER=7
+val SCE_LUA_LITERALSTRING=8
+val SCE_LUA_PREPROCESSOR=9
+val SCE_LUA_OPERATOR=10
+val SCE_LUA_IDENTIFIER=11
+val SCE_LUA_STRINGEOL=12
+val SCE_LUA_WORD2=13
+val SCE_LUA_WORD3=14
+val SCE_LUA_WORD4=15
+val SCE_LUA_WORD5=16
+val SCE_LUA_WORD6=17
+val SCE_LUA_WORD7=18
+val SCE_LUA_WORD8=19
+val SCE_LUA_LABEL=20
+# Lexical states for SCLEX_ERRORLIST
+lex ErrorList=SCLEX_ERRORLIST SCE_ERR_
+val SCE_ERR_DEFAULT=0
+val SCE_ERR_PYTHON=1
+val SCE_ERR_GCC=2
+val SCE_ERR_MS=3
+val SCE_ERR_CMD=4
+val SCE_ERR_BORLAND=5
+val SCE_ERR_PERL=6
+val SCE_ERR_NET=7
+val SCE_ERR_LUA=8
+val SCE_ERR_CTAG=9
+val SCE_ERR_DIFF_CHANGED=10
+val SCE_ERR_DIFF_ADDITION=11
+val SCE_ERR_DIFF_DELETION=12
+val SCE_ERR_DIFF_MESSAGE=13
+val SCE_ERR_PHP=14
+val SCE_ERR_ELF=15
+val SCE_ERR_IFC=16
+val SCE_ERR_IFORT=17
+val SCE_ERR_ABSF=18
+val SCE_ERR_TIDY=19
+val SCE_ERR_JAVA_STACK=20
+val SCE_ERR_VALUE=21
+val SCE_ERR_GCC_INCLUDED_FROM=22
+val SCE_ERR_ESCSEQ=23
+val SCE_ERR_ESCSEQ_UNKNOWN=24
+val SCE_ERR_GCC_EXCERPT=25
+val SCE_ERR_ES_BLACK=40
+val SCE_ERR_ES_RED=41
+val SCE_ERR_ES_GREEN=42
+val SCE_ERR_ES_BROWN=43
+val SCE_ERR_ES_BLUE=44
+val SCE_ERR_ES_MAGENTA=45
+val SCE_ERR_ES_CYAN=46
+val SCE_ERR_ES_GRAY=47
+val SCE_ERR_ES_DARK_GRAY=48
+val SCE_ERR_ES_BRIGHT_RED=49
+val SCE_ERR_ES_BRIGHT_GREEN=50
+val SCE_ERR_ES_YELLOW=51
+val SCE_ERR_ES_BRIGHT_BLUE=52
+val SCE_ERR_ES_BRIGHT_MAGENTA=53
+val SCE_ERR_ES_BRIGHT_CYAN=54
+val SCE_ERR_ES_WHITE=55
+# Lexical states for SCLEX_BATCH
+lex Batch=SCLEX_BATCH SCE_BAT_
+val SCE_BAT_DEFAULT=0
+val SCE_BAT_COMMENT=1
+val SCE_BAT_WORD=2
+val SCE_BAT_LABEL=3
+val SCE_BAT_HIDE=4
+val SCE_BAT_COMMAND=5
+val SCE_BAT_IDENTIFIER=6
+val SCE_BAT_OPERATOR=7
+# Lexical states for SCLEX_TCMD
+lex TCMD=SCLEX_TCMD SCE_TCMD_
+val SCE_TCMD_DEFAULT=0
+val SCE_TCMD_COMMENT=1
+val SCE_TCMD_WORD=2
+val SCE_TCMD_LABEL=3
+val SCE_TCMD_HIDE=4
+val SCE_TCMD_COMMAND=5
+val SCE_TCMD_IDENTIFIER=6
+val SCE_TCMD_OPERATOR=7
+val SCE_TCMD_ENVIRONMENT=8
+val SCE_TCMD_EXPANSION=9
+val SCE_TCMD_CLABEL=10
+# Lexical states for SCLEX_MAKEFILE
+lex MakeFile=SCLEX_MAKEFILE SCE_MAKE_
+val SCE_MAKE_DEFAULT=0
+val SCE_MAKE_COMMENT=1
+val SCE_MAKE_PREPROCESSOR=2
+val SCE_MAKE_IDENTIFIER=3
+val SCE_MAKE_OPERATOR=4
+val SCE_MAKE_TARGET=5
+val SCE_MAKE_IDEOL=9
+# Lexical states for SCLEX_DIFF
+lex Diff=SCLEX_DIFF SCE_DIFF_
+val SCE_DIFF_DEFAULT=0
+val SCE_DIFF_COMMENT=1
+val SCE_DIFF_COMMAND=2
+val SCE_DIFF_HEADER=3
+val SCE_DIFF_POSITION=4
+val SCE_DIFF_DELETED=5
+val SCE_DIFF_ADDED=6
+val SCE_DIFF_CHANGED=7
+val SCE_DIFF_PATCH_ADD=8
+val SCE_DIFF_PATCH_DELETE=9
+val SCE_DIFF_REMOVED_PATCH_ADD=10
+val SCE_DIFF_REMOVED_PATCH_DELETE=11
+# Lexical states for SCLEX_CONF (Apache Configuration Files Lexer)
+lex Conf=SCLEX_CONF SCE_CONF_
+val SCE_CONF_DEFAULT=0
+val SCE_CONF_COMMENT=1
+val SCE_CONF_NUMBER=2
+val SCE_CONF_IDENTIFIER=3
+val SCE_CONF_EXTENSION=4
+val SCE_CONF_PARAMETER=5
+val SCE_CONF_STRING=6
+val SCE_CONF_OPERATOR=7
+val SCE_CONF_IP=8
+val SCE_CONF_DIRECTIVE=9
+# Lexical states for SCLEX_AVE, Avenue
+lex Avenue=SCLEX_AVE SCE_AVE_
+val SCE_AVE_DEFAULT=0
+val SCE_AVE_COMMENT=1
+val SCE_AVE_NUMBER=2
+val SCE_AVE_WORD=3
+val SCE_AVE_STRING=6
+val SCE_AVE_ENUM=7
+val SCE_AVE_STRINGEOL=8
+val SCE_AVE_IDENTIFIER=9
+val SCE_AVE_OPERATOR=10
+val SCE_AVE_WORD1=11
+val SCE_AVE_WORD2=12
+val SCE_AVE_WORD3=13
+val SCE_AVE_WORD4=14
+val SCE_AVE_WORD5=15
+val SCE_AVE_WORD6=16
+# Lexical states for SCLEX_ADA
+lex Ada=SCLEX_ADA SCE_ADA_
+val SCE_ADA_DEFAULT=0
+val SCE_ADA_WORD=1
+val SCE_ADA_IDENTIFIER=2
+val SCE_ADA_NUMBER=3
+val SCE_ADA_DELIMITER=4
+val SCE_ADA_CHARACTER=5
+val SCE_ADA_CHARACTEREOL=6
+val SCE_ADA_STRING=7
+val SCE_ADA_STRINGEOL=8
+val SCE_ADA_LABEL=9
+val SCE_ADA_COMMENTLINE=10
+val SCE_ADA_ILLEGAL=11
+# Lexical states for SCLEX_BAAN
+lex Baan=SCLEX_BAAN SCE_BAAN_
+val SCE_BAAN_DEFAULT=0
+val SCE_BAAN_COMMENT=1
+val SCE_BAAN_COMMENTDOC=2
+val SCE_BAAN_NUMBER=3
+val SCE_BAAN_WORD=4
+val SCE_BAAN_STRING=5
+val SCE_BAAN_PREPROCESSOR=6
+val SCE_BAAN_OPERATOR=7
+val SCE_BAAN_IDENTIFIER=8
+val SCE_BAAN_STRINGEOL=9
+val SCE_BAAN_WORD2=10
+val SCE_BAAN_WORD3=11
+val SCE_BAAN_WORD4=12
+val SCE_BAAN_WORD5=13
+val SCE_BAAN_WORD6=14
+val SCE_BAAN_WORD7=15
+val SCE_BAAN_WORD8=16
+val SCE_BAAN_WORD9=17
+val SCE_BAAN_TABLEDEF=18
+val SCE_BAAN_TABLESQL=19
+val SCE_BAAN_FUNCTION=20
+val SCE_BAAN_DOMDEF=21
+val SCE_BAAN_FUNCDEF=22
+val SCE_BAAN_OBJECTDEF=23
+val SCE_BAAN_DEFINEDEF=24
+# Lexical states for SCLEX_LISP
+lex Lisp=SCLEX_LISP SCE_LISP_
+val SCE_LISP_DEFAULT=0
+val SCE_LISP_COMMENT=1
+val SCE_LISP_NUMBER=2
+val SCE_LISP_KEYWORD=3
+val SCE_LISP_KEYWORD_KW=4
+val SCE_LISP_SYMBOL=5
+val SCE_LISP_STRING=6
+val SCE_LISP_STRINGEOL=8
+val SCE_LISP_IDENTIFIER=9
+val SCE_LISP_OPERATOR=10
+val SCE_LISP_SPECIAL=11
+val SCE_LISP_MULTI_COMMENT=12
+# Lexical states for SCLEX_EIFFEL and SCLEX_EIFFELKW
+lex Eiffel=SCLEX_EIFFEL SCE_EIFFEL_
+lex EiffelKW=SCLEX_EIFFELKW SCE_EIFFEL_
+val SCE_EIFFEL_DEFAULT=0
+val SCE_EIFFEL_COMMENTLINE=1
+val SCE_EIFFEL_NUMBER=2
+val SCE_EIFFEL_WORD=3
+val SCE_EIFFEL_STRING=4
+val SCE_EIFFEL_CHARACTER=5
+val SCE_EIFFEL_OPERATOR=6
+val SCE_EIFFEL_IDENTIFIER=7
+val SCE_EIFFEL_STRINGEOL=8
+# Lexical states for SCLEX_NNCRONTAB (nnCron crontab Lexer)
+lex NNCronTab=SCLEX_NNCRONTAB SCE_NNCRONTAB_
+val SCE_NNCRONTAB_DEFAULT=0
+val SCE_NNCRONTAB_COMMENT=1
+val SCE_NNCRONTAB_TASK=2
+val SCE_NNCRONTAB_SECTION=3
+val SCE_NNCRONTAB_KEYWORD=4
+val SCE_NNCRONTAB_MODIFIER=5
+val SCE_NNCRONTAB_ASTERISK=6
+val SCE_NNCRONTAB_NUMBER=7
+val SCE_NNCRONTAB_STRING=8
+val SCE_NNCRONTAB_ENVIRONMENT=9
+val SCE_NNCRONTAB_IDENTIFIER=10
+# Lexical states for SCLEX_FORTH (Forth Lexer)
+lex Forth=SCLEX_FORTH SCE_FORTH_
+val SCE_FORTH_DEFAULT=0
+val SCE_FORTH_COMMENT=1
+val SCE_FORTH_COMMENT_ML=2
+val SCE_FORTH_IDENTIFIER=3
+val SCE_FORTH_CONTROL=4
+val SCE_FORTH_KEYWORD=5
+val SCE_FORTH_DEFWORD=6
+val SCE_FORTH_PREWORD1=7
+val SCE_FORTH_PREWORD2=8
+val SCE_FORTH_NUMBER=9
+val SCE_FORTH_STRING=10
+val SCE_FORTH_LOCALE=11
+# Lexical states for SCLEX_MATLAB
+lex MatLab=SCLEX_MATLAB SCE_MATLAB_
+val SCE_MATLAB_DEFAULT=0
+val SCE_MATLAB_COMMENT=1
+val SCE_MATLAB_COMMAND=2
+val SCE_MATLAB_NUMBER=3
+val SCE_MATLAB_KEYWORD=4
+# single quoted string
+val SCE_MATLAB_STRING=5
+val SCE_MATLAB_OPERATOR=6
+val SCE_MATLAB_IDENTIFIER=7
+val SCE_MATLAB_DOUBLEQUOTESTRING=8
+# Lexical states for SCLEX_MAXIMA
+lex Maxima=SCLEX_MAXIMA SCE_MAXIMA_
+val SCE_MAXIMA_OPERATOR=0
+val SCE_MAXIMA_COMMANDENDING=1
+val SCE_MAXIMA_COMMENT=2
+val SCE_MAXIMA_NUMBER=3
+val SCE_MAXIMA_STRING=4
+val SCE_MAXIMA_COMMAND=5
+val SCE_MAXIMA_VARIABLE=6
+val SCE_MAXIMA_UNKNOWN=7
+# Lexical states for SCLEX_SCRIPTOL
+lex Sol=SCLEX_SCRIPTOL SCE_SCRIPTOL_
+val SCE_SCRIPTOL_DEFAULT=0
+val SCE_SCRIPTOL_WHITE=1
+val SCE_SCRIPTOL_COMMENTLINE=2
+val SCE_SCRIPTOL_PERSISTENT=3
+val SCE_SCRIPTOL_CSTYLE=4
+val SCE_SCRIPTOL_COMMENTBLOCK=5
+val SCE_SCRIPTOL_NUMBER=6
+val SCE_SCRIPTOL_STRING=7
+val SCE_SCRIPTOL_CHARACTER=8
+val SCE_SCRIPTOL_STRINGEOL=9
+val SCE_SCRIPTOL_KEYWORD=10
+val SCE_SCRIPTOL_OPERATOR=11
+val SCE_SCRIPTOL_IDENTIFIER=12
+val SCE_SCRIPTOL_TRIPLE=13
+val SCE_SCRIPTOL_CLASSNAME=14
+val SCE_SCRIPTOL_PREPROCESSOR=15
+# Lexical states for SCLEX_ASM, SCLEX_AS
+lex Asm=SCLEX_ASM SCE_ASM_
+lex As=SCLEX_AS SCE_ASM_
+val SCE_ASM_DEFAULT=0
+val SCE_ASM_COMMENT=1
+val SCE_ASM_NUMBER=2
+val SCE_ASM_STRING=3
+val SCE_ASM_OPERATOR=4
+val SCE_ASM_IDENTIFIER=5
+val SCE_ASM_CPUINSTRUCTION=6
+val SCE_ASM_MATHINSTRUCTION=7
+val SCE_ASM_REGISTER=8
+val SCE_ASM_DIRECTIVE=9
+val SCE_ASM_DIRECTIVEOPERAND=10
+val SCE_ASM_COMMENTBLOCK=11
+val SCE_ASM_CHARACTER=12
+val SCE_ASM_STRINGEOL=13
+val SCE_ASM_EXTINSTRUCTION=14
+val SCE_ASM_COMMENTDIRECTIVE=15
+# Lexical states for SCLEX_FORTRAN
+lex Fortran=SCLEX_FORTRAN SCE_F_
+lex F77=SCLEX_F77 SCE_F_
+val SCE_F_DEFAULT=0
+val SCE_F_COMMENT=1
+val SCE_F_NUMBER=2
+val SCE_F_STRING1=3
+val SCE_F_STRING2=4
+val SCE_F_STRINGEOL=5
+val SCE_F_OPERATOR=6
+val SCE_F_IDENTIFIER=7
+val SCE_F_WORD=8
+val SCE_F_WORD2=9
+val SCE_F_WORD3=10
+val SCE_F_PREPROCESSOR=11
+val SCE_F_OPERATOR2=12
+val SCE_F_LABEL=13
+val SCE_F_CONTINUATION=14
+# Lexical states for SCLEX_CSS
+lex CSS=SCLEX_CSS SCE_CSS_
+val SCE_CSS_DEFAULT=0
+val SCE_CSS_TAG=1
+val SCE_CSS_CLASS=2
+val SCE_CSS_PSEUDOCLASS=3
+val SCE_CSS_UNKNOWN_PSEUDOCLASS=4
+val SCE_CSS_OPERATOR=5
+val SCE_CSS_IDENTIFIER=6
+val SCE_CSS_UNKNOWN_IDENTIFIER=7
+val SCE_CSS_VALUE=8
+val SCE_CSS_COMMENT=9
+val SCE_CSS_ID=10
+val SCE_CSS_IMPORTANT=11
+val SCE_CSS_DIRECTIVE=12
+val SCE_CSS_DOUBLESTRING=13
+val SCE_CSS_SINGLESTRING=14
+val SCE_CSS_IDENTIFIER2=15
+val SCE_CSS_ATTRIBUTE=16
+val SCE_CSS_IDENTIFIER3=17
+val SCE_CSS_PSEUDOELEMENT=18
+val SCE_CSS_EXTENDED_IDENTIFIER=19
+val SCE_CSS_EXTENDED_PSEUDOCLASS=20
+val SCE_CSS_EXTENDED_PSEUDOELEMENT=21
+val SCE_CSS_MEDIA=22
+val SCE_CSS_VARIABLE=23
+# Lexical states for SCLEX_POV
+lex POV=SCLEX_POV SCE_POV_
+val SCE_POV_DEFAULT=0
+val SCE_POV_COMMENT=1
+val SCE_POV_COMMENTLINE=2
+val SCE_POV_NUMBER=3
+val SCE_POV_OPERATOR=4
+val SCE_POV_IDENTIFIER=5
+val SCE_POV_STRING=6
+val SCE_POV_STRINGEOL=7
+val SCE_POV_DIRECTIVE=8
+val SCE_POV_BADDIRECTIVE=9
+val SCE_POV_WORD2=10
+val SCE_POV_WORD3=11
+val SCE_POV_WORD4=12
+val SCE_POV_WORD5=13
+val SCE_POV_WORD6=14
+val SCE_POV_WORD7=15
+val SCE_POV_WORD8=16
+# Lexical states for SCLEX_LOUT
+lex LOUT=SCLEX_LOUT SCE_LOUT_
+val SCE_LOUT_DEFAULT=0
+val SCE_LOUT_COMMENT=1
+val SCE_LOUT_NUMBER=2
+val SCE_LOUT_WORD=3
+val SCE_LOUT_WORD2=4
+val SCE_LOUT_WORD3=5
+val SCE_LOUT_WORD4=6
+val SCE_LOUT_STRING=7
+val SCE_LOUT_OPERATOR=8
+val SCE_LOUT_IDENTIFIER=9
+val SCE_LOUT_STRINGEOL=10
+# Lexical states for SCLEX_ESCRIPT
+lex ESCRIPT=SCLEX_ESCRIPT SCE_ESCRIPT_
+val SCE_ESCRIPT_DEFAULT=0
+val SCE_ESCRIPT_COMMENT=1
+val SCE_ESCRIPT_COMMENTLINE=2
+val SCE_ESCRIPT_COMMENTDOC=3
+val SCE_ESCRIPT_NUMBER=4
+val SCE_ESCRIPT_WORD=5
+val SCE_ESCRIPT_STRING=6
+val SCE_ESCRIPT_OPERATOR=7
+val SCE_ESCRIPT_IDENTIFIER=8
+val SCE_ESCRIPT_BRACE=9
+val SCE_ESCRIPT_WORD2=10
+val SCE_ESCRIPT_WORD3=11
+# Lexical states for SCLEX_PS
+lex PS=SCLEX_PS SCE_PS_
+val SCE_PS_DEFAULT=0
+val SCE_PS_COMMENT=1
+val SCE_PS_DSC_COMMENT=2
+val SCE_PS_DSC_VALUE=3
+val SCE_PS_NUMBER=4
+val SCE_PS_NAME=5
+val SCE_PS_KEYWORD=6
+val SCE_PS_LITERAL=7
+val SCE_PS_IMMEVAL=8
+val SCE_PS_PAREN_ARRAY=9
+val SCE_PS_PAREN_DICT=10
+val SCE_PS_PAREN_PROC=11
+val SCE_PS_TEXT=12
+val SCE_PS_HEXSTRING=13
+val SCE_PS_BASE85STRING=14
+val SCE_PS_BADSTRINGCHAR=15
+# Lexical states for SCLEX_NSIS
+lex NSIS=SCLEX_NSIS SCE_NSIS_
+val SCE_NSIS_DEFAULT=0
+val SCE_NSIS_COMMENT=1
+val SCE_NSIS_STRINGDQ=2
+val SCE_NSIS_STRINGLQ=3
+val SCE_NSIS_STRINGRQ=4
+val SCE_NSIS_FUNCTION=5
+val SCE_NSIS_VARIABLE=6
+val SCE_NSIS_LABEL=7
+val SCE_NSIS_USERDEFINED=8
+val SCE_NSIS_SECTIONDEF=9
+val SCE_NSIS_SUBSECTIONDEF=10
+val SCE_NSIS_IFDEFINEDEF=11
+val SCE_NSIS_MACRODEF=12
+val SCE_NSIS_STRINGVAR=13
+val SCE_NSIS_NUMBER=14
+val SCE_NSIS_SECTIONGROUP=15
+val SCE_NSIS_PAGEEX=16
+val SCE_NSIS_FUNCTIONDEF=17
+val SCE_NSIS_COMMENTBOX=18
+# Lexical states for SCLEX_MMIXAL
+lex MMIXAL=SCLEX_MMIXAL SCE_MMIXAL_
+val SCE_MMIXAL_LEADWS=0
+val SCE_MMIXAL_COMMENT=1
+val SCE_MMIXAL_LABEL=2
+val SCE_MMIXAL_OPCODE=3
+val SCE_MMIXAL_OPCODE_PRE=4
+val SCE_MMIXAL_OPCODE_VALID=5
+val SCE_MMIXAL_OPCODE_UNKNOWN=6
+val SCE_MMIXAL_OPCODE_POST=7
+val SCE_MMIXAL_OPERANDS=8
+val SCE_MMIXAL_NUMBER=9
+val SCE_MMIXAL_REF=10
+val SCE_MMIXAL_CHAR=11
+val SCE_MMIXAL_STRING=12
+val SCE_MMIXAL_REGISTER=13
+val SCE_MMIXAL_HEX=14
+val SCE_MMIXAL_OPERATOR=15
+val SCE_MMIXAL_SYMBOL=16
+val SCE_MMIXAL_INCLUDE=17
+# Lexical states for SCLEX_CLW
+lex Clarion=SCLEX_CLW SCE_CLW_
+val SCE_CLW_DEFAULT=0
+val SCE_CLW_LABEL=1
+val SCE_CLW_COMMENT=2
+val SCE_CLW_STRING=3
+val SCE_CLW_USER_IDENTIFIER=4
+val SCE_CLW_INTEGER_CONSTANT=5
+val SCE_CLW_REAL_CONSTANT=6
+val SCE_CLW_PICTURE_STRING=7
+val SCE_CLW_KEYWORD=8
+val SCE_CLW_COMPILER_DIRECTIVE=9
+val SCE_CLW_RUNTIME_EXPRESSIONS=10
+val SCE_CLW_BUILTIN_PROCEDURES_FUNCTION=11
+val SCE_CLW_STRUCTURE_DATA_TYPE=12
+val SCE_CLW_ATTRIBUTE=13
+val SCE_CLW_STANDARD_EQUATE=14
+val SCE_CLW_ERROR=15
+val SCE_CLW_DEPRECATED=16
+# Lexical states for SCLEX_LOT
+lex LOT=SCLEX_LOT SCE_LOT_
+val SCE_LOT_DEFAULT=0
+val SCE_LOT_HEADER=1
+val SCE_LOT_BREAK=2
+val SCE_LOT_SET=3
+val SCE_LOT_PASS=4
+val SCE_LOT_FAIL=5
+val SCE_LOT_ABORT=6
+# Lexical states for SCLEX_YAML
+lex YAML=SCLEX_YAML SCE_YAML_
+val SCE_YAML_DEFAULT=0
+val SCE_YAML_COMMENT=1
+val SCE_YAML_IDENTIFIER=2
+val SCE_YAML_KEYWORD=3
+val SCE_YAML_NUMBER=4
+val SCE_YAML_REFERENCE=5
+val SCE_YAML_DOCUMENT=6
+val SCE_YAML_TEXT=7
+val SCE_YAML_ERROR=8
+val SCE_YAML_OPERATOR=9
+# Lexical states for SCLEX_TEX
+lex TeX=SCLEX_TEX SCE_TEX_
+val SCE_TEX_DEFAULT=0
+val SCE_TEX_SPECIAL=1
+val SCE_TEX_GROUP=2
+val SCE_TEX_SYMBOL=3
+val SCE_TEX_COMMAND=4
+val SCE_TEX_TEXT=5
+lex Metapost=SCLEX_METAPOST SCE_METAPOST_
+val SCE_METAPOST_DEFAULT=0
+val SCE_METAPOST_SPECIAL=1
+val SCE_METAPOST_GROUP=2
+val SCE_METAPOST_SYMBOL=3
+val SCE_METAPOST_COMMAND=4
+val SCE_METAPOST_TEXT=5
+val SCE_METAPOST_EXTRA=6
+# Lexical states for SCLEX_ERLANG
+lex Erlang=SCLEX_ERLANG SCE_ERLANG_
+val SCE_ERLANG_DEFAULT=0
+val SCE_ERLANG_COMMENT=1
+val SCE_ERLANG_VARIABLE=2
+val SCE_ERLANG_NUMBER=3
+val SCE_ERLANG_KEYWORD=4
+val SCE_ERLANG_STRING=5
+val SCE_ERLANG_OPERATOR=6
+val SCE_ERLANG_ATOM=7
+val SCE_ERLANG_FUNCTION_NAME=8
+val SCE_ERLANG_CHARACTER=9
+val SCE_ERLANG_MACRO=10
+val SCE_ERLANG_RECORD=11
+val SCE_ERLANG_PREPROC=12
+val SCE_ERLANG_NODE_NAME=13
+val SCE_ERLANG_COMMENT_FUNCTION=14
+val SCE_ERLANG_COMMENT_MODULE=15
+val SCE_ERLANG_COMMENT_DOC=16
+val SCE_ERLANG_COMMENT_DOC_MACRO=17
+val SCE_ERLANG_ATOM_QUOTED=18
+val SCE_ERLANG_MACRO_QUOTED=19
+val SCE_ERLANG_RECORD_QUOTED=20
+val SCE_ERLANG_NODE_NAME_QUOTED=21
+val SCE_ERLANG_BIFS=22
+val SCE_ERLANG_MODULES=23
+val SCE_ERLANG_MODULES_ATT=24
+val SCE_ERLANG_UNKNOWN=31
+# Lexical states for SCLEX_OCTAVE are identical to MatLab
+lex Octave=SCLEX_OCTAVE SCE_MATLAB_
+# Lexical states for SCLEX_MSSQL
+lex MSSQL=SCLEX_MSSQL SCE_MSSQL_
+val SCE_MSSQL_DEFAULT=0
+val SCE_MSSQL_COMMENT=1
+val SCE_MSSQL_LINE_COMMENT=2
+val SCE_MSSQL_NUMBER=3
+val SCE_MSSQL_STRING=4
+val SCE_MSSQL_OPERATOR=5
+val SCE_MSSQL_IDENTIFIER=6
+val SCE_MSSQL_VARIABLE=7
+val SCE_MSSQL_COLUMN_NAME=8
+val SCE_MSSQL_STATEMENT=9
+val SCE_MSSQL_DATATYPE=10
+val SCE_MSSQL_SYSTABLE=11
+val SCE_MSSQL_GLOBAL_VARIABLE=12
+val SCE_MSSQL_FUNCTION=13
+val SCE_MSSQL_STORED_PROCEDURE=14
+val SCE_MSSQL_DEFAULT_PREF_DATATYPE=15
+val SCE_MSSQL_COLUMN_NAME_2=16
+# Lexical states for SCLEX_VERILOG
+lex Verilog=SCLEX_VERILOG SCE_V_
+val SCE_V_DEFAULT=0
+val SCE_V_COMMENT=1
+val SCE_V_COMMENTLINE=2
+val SCE_V_COMMENTLINEBANG=3
+val SCE_V_NUMBER=4
+val SCE_V_WORD=5
+val SCE_V_STRING=6
+val SCE_V_WORD2=7
+val SCE_V_WORD3=8
+val SCE_V_PREPROCESSOR=9
+val SCE_V_OPERATOR=10
+val SCE_V_IDENTIFIER=11
+val SCE_V_STRINGEOL=12
+val SCE_V_USER=19
+val SCE_V_COMMENT_WORD=20
+val SCE_V_INPUT=21
+val SCE_V_OUTPUT=22
+val SCE_V_INOUT=23
+val SCE_V_PORT_CONNECT=24
+# Lexical states for SCLEX_KIX
+lex Kix=SCLEX_KIX SCE_KIX_
+val SCE_KIX_DEFAULT=0
+val SCE_KIX_COMMENT=1
+val SCE_KIX_STRING1=2
+val SCE_KIX_STRING2=3
+val SCE_KIX_NUMBER=4
+val SCE_KIX_VAR=5
+val SCE_KIX_MACRO=6
+val SCE_KIX_KEYWORD=7
+val SCE_KIX_FUNCTIONS=8
+val SCE_KIX_OPERATOR=9
+val SCE_KIX_COMMENTSTREAM=10
+val SCE_KIX_IDENTIFIER=31
+# Lexical states for SCLEX_GUI4CLI
+lex Gui4Cli=SCLEX_GUI4CLI SCE_GC_
+val SCE_GC_DEFAULT=0
+val SCE_GC_COMMENTLINE=1
+val SCE_GC_COMMENTBLOCK=2
+val SCE_GC_GLOBAL=3
+val SCE_GC_EVENT=4
+val SCE_GC_ATTRIBUTE=5
+val SCE_GC_CONTROL=6
+val SCE_GC_COMMAND=7
+val SCE_GC_STRING=8
+val SCE_GC_OPERATOR=9
+# Lexical states for SCLEX_SPECMAN
+lex Specman=SCLEX_SPECMAN SCE_SN_
+val SCE_SN_DEFAULT=0
+val SCE_SN_CODE=1
+val SCE_SN_COMMENTLINE=2
+val SCE_SN_COMMENTLINEBANG=3
+val SCE_SN_NUMBER=4
+val SCE_SN_WORD=5
+val SCE_SN_STRING=6
+val SCE_SN_WORD2=7
+val SCE_SN_WORD3=8
+val SCE_SN_PREPROCESSOR=9
+val SCE_SN_OPERATOR=10
+val SCE_SN_IDENTIFIER=11
+val SCE_SN_STRINGEOL=12
+val SCE_SN_REGEXTAG=13
+val SCE_SN_SIGNAL=14
+val SCE_SN_USER=19
+# Lexical states for SCLEX_AU3
+lex Au3=SCLEX_AU3 SCE_AU3_
+val SCE_AU3_DEFAULT=0
+val SCE_AU3_COMMENT=1
+val SCE_AU3_COMMENTBLOCK=2
+val SCE_AU3_NUMBER=3
+val SCE_AU3_FUNCTION=4
+val SCE_AU3_KEYWORD=5
+val SCE_AU3_MACRO=6
+val SCE_AU3_STRING=7
+val SCE_AU3_OPERATOR=8
+val SCE_AU3_VARIABLE=9
+val SCE_AU3_SENT=10
+val SCE_AU3_PREPROCESSOR=11
+val SCE_AU3_SPECIAL=12
+val SCE_AU3_EXPAND=13
+val SCE_AU3_COMOBJ=14
+val SCE_AU3_UDF=15
+# Lexical states for SCLEX_APDL
+lex APDL=SCLEX_APDL SCE_APDL_
+val SCE_APDL_DEFAULT=0
+val SCE_APDL_COMMENT=1
+val SCE_APDL_COMMENTBLOCK=2
+val SCE_APDL_NUMBER=3
+val SCE_APDL_STRING=4
+val SCE_APDL_OPERATOR=5
+val SCE_APDL_WORD=6
+val SCE_APDL_PROCESSOR=7
+val SCE_APDL_COMMAND=8
+val SCE_APDL_SLASHCOMMAND=9
+val SCE_APDL_STARCOMMAND=10
+val SCE_APDL_ARGUMENT=11
+val SCE_APDL_FUNCTION=12
+# Lexical states for SCLEX_BASH
+lex Bash=SCLEX_BASH SCE_SH_
+val SCE_SH_DEFAULT=0
+val SCE_SH_ERROR=1
+val SCE_SH_COMMENTLINE=2
+val SCE_SH_NUMBER=3
+val SCE_SH_WORD=4
+val SCE_SH_STRING=5
+val SCE_SH_CHARACTER=6
+val SCE_SH_OPERATOR=7
+val SCE_SH_IDENTIFIER=8
+val SCE_SH_SCALAR=9
+val SCE_SH_PARAM=10
+val SCE_SH_BACKTICKS=11
+val SCE_SH_HERE_DELIM=12
+val SCE_SH_HERE_Q=13
+# Lexical states for SCLEX_ASN1
+lex Asn1=SCLEX_ASN1 SCE_ASN1_
+val SCE_ASN1_DEFAULT=0
+val SCE_ASN1_COMMENT=1
+val SCE_ASN1_IDENTIFIER=2
+val SCE_ASN1_STRING=3
+val SCE_ASN1_OID=4
+val SCE_ASN1_SCALAR=5
+val SCE_ASN1_KEYWORD=6
+val SCE_ASN1_ATTRIBUTE=7
+val SCE_ASN1_DESCRIPTOR=8
+val SCE_ASN1_TYPE=9
+val SCE_ASN1_OPERATOR=10
+# Lexical states for SCLEX_VHDL
+lex VHDL=SCLEX_VHDL SCE_VHDL_
+val SCE_VHDL_DEFAULT=0
+val SCE_VHDL_COMMENT=1
+val SCE_VHDL_COMMENTLINEBANG=2
+val SCE_VHDL_NUMBER=3
+val SCE_VHDL_STRING=4
+val SCE_VHDL_OPERATOR=5
+val SCE_VHDL_IDENTIFIER=6
+val SCE_VHDL_STRINGEOL=7
+val SCE_VHDL_KEYWORD=8
+val SCE_VHDL_STDOPERATOR=9
+val SCE_VHDL_ATTRIBUTE=10
+val SCE_VHDL_STDFUNCTION=11
+val SCE_VHDL_STDPACKAGE=12
+val SCE_VHDL_STDTYPE=13
+val SCE_VHDL_USERWORD=14
+val SCE_VHDL_BLOCK_COMMENT=15
+# Lexical states for SCLEX_CAML
+lex Caml=SCLEX_CAML SCE_CAML_
+val SCE_CAML_DEFAULT=0
+val SCE_CAML_IDENTIFIER=1
+val SCE_CAML_TAGNAME=2
+val SCE_CAML_KEYWORD=3
+val SCE_CAML_KEYWORD2=4
+val SCE_CAML_KEYWORD3=5
+val SCE_CAML_LINENUM=6
+val SCE_CAML_OPERATOR=7
+val SCE_CAML_NUMBER=8
+val SCE_CAML_CHAR=9
+val SCE_CAML_WHITE=10
+val SCE_CAML_STRING=11
+val SCE_CAML_COMMENT=12
+val SCE_CAML_COMMENT1=13
+val SCE_CAML_COMMENT2=14
+val SCE_CAML_COMMENT3=15
+# Lexical states for SCLEX_HASKELL
+lex Haskell=SCLEX_HASKELL SCE_HA_
+val SCE_HA_DEFAULT=0
+val SCE_HA_IDENTIFIER=1
+val SCE_HA_KEYWORD=2
+val SCE_HA_NUMBER=3
+val SCE_HA_STRING=4
+val SCE_HA_CHARACTER=5
+val SCE_HA_CLASS=6
+val SCE_HA_MODULE=7
+val SCE_HA_CAPITAL=8
+val SCE_HA_DATA=9
+val SCE_HA_IMPORT=10
+val SCE_HA_OPERATOR=11
+val SCE_HA_INSTANCE=12
+val SCE_HA_COMMENTLINE=13
+val SCE_HA_COMMENTBLOCK=14
+val SCE_HA_COMMENTBLOCK2=15
+val SCE_HA_COMMENTBLOCK3=16
+val SCE_HA_PRAGMA=17
+val SCE_HA_PREPROCESSOR=18
+val SCE_HA_STRINGEOL=19
+val SCE_HA_RESERVED_OPERATOR=20
+val SCE_HA_LITERATE_COMMENT=21
+val SCE_HA_LITERATE_CODEDELIM=22
+# Lexical states of SCLEX_TADS3
+lex TADS3=SCLEX_TADS3 SCE_T3_
+val SCE_T3_DEFAULT=0
+val SCE_T3_X_DEFAULT=1
+val SCE_T3_PREPROCESSOR=2
+val SCE_T3_BLOCK_COMMENT=3
+val SCE_T3_LINE_COMMENT=4
+val SCE_T3_OPERATOR=5
+val SCE_T3_KEYWORD=6
+val SCE_T3_NUMBER=7
+val SCE_T3_IDENTIFIER=8
+val SCE_T3_S_STRING=9
+val SCE_T3_D_STRING=10
+val SCE_T3_X_STRING=11
+val SCE_T3_LIB_DIRECTIVE=12
+val SCE_T3_MSG_PARAM=13
+val SCE_T3_HTML_TAG=14
+val SCE_T3_HTML_DEFAULT=15
+val SCE_T3_HTML_STRING=16
+val SCE_T3_USER1=17
+val SCE_T3_USER2=18
+val SCE_T3_USER3=19
+val SCE_T3_BRACE=20
+# Lexical states for SCLEX_REBOL
+lex Rebol=SCLEX_REBOL SCE_REBOL_
+val SCE_REBOL_DEFAULT=0
+val SCE_REBOL_COMMENTLINE=1
+val SCE_REBOL_COMMENTBLOCK=2
+val SCE_REBOL_PREFACE=3
+val SCE_REBOL_OPERATOR=4
+val SCE_REBOL_CHARACTER=5
+val SCE_REBOL_QUOTEDSTRING=6
+val SCE_REBOL_BRACEDSTRING=7
+val SCE_REBOL_NUMBER=8
+val SCE_REBOL_PAIR=9
+val SCE_REBOL_TUPLE=10
+val SCE_REBOL_BINARY=11
+val SCE_REBOL_MONEY=12
+val SCE_REBOL_ISSUE=13
+val SCE_REBOL_TAG=14
+val SCE_REBOL_FILE=15
+val SCE_REBOL_EMAIL=16
+val SCE_REBOL_URL=17
+val SCE_REBOL_DATE=18
+val SCE_REBOL_TIME=19
+val SCE_REBOL_IDENTIFIER=20
+val SCE_REBOL_WORD=21
+val SCE_REBOL_WORD2=22
+val SCE_REBOL_WORD3=23
+val SCE_REBOL_WORD4=24
+val SCE_REBOL_WORD5=25
+val SCE_REBOL_WORD6=26
+val SCE_REBOL_WORD7=27
+val SCE_REBOL_WORD8=28
+# Lexical states for SCLEX_SQL
+lex SQL=SCLEX_SQL SCE_SQL_
+val SCE_SQL_DEFAULT=0
+val SCE_SQL_COMMENT=1
+val SCE_SQL_COMMENTLINE=2
+val SCE_SQL_COMMENTDOC=3
+val SCE_SQL_NUMBER=4
+val SCE_SQL_WORD=5
+val SCE_SQL_STRING=6
+val SCE_SQL_CHARACTER=7
+val SCE_SQL_SQLPLUS=8
+val SCE_SQL_SQLPLUS_PROMPT=9
+val SCE_SQL_OPERATOR=10
+val SCE_SQL_IDENTIFIER=11
+val SCE_SQL_SQLPLUS_COMMENT=13
+val SCE_SQL_COMMENTLINEDOC=15
+val SCE_SQL_WORD2=16
+val SCE_SQL_COMMENTDOCKEYWORD=17
+val SCE_SQL_COMMENTDOCKEYWORDERROR=18
+val SCE_SQL_USER1=19
+val SCE_SQL_USER2=20
+val SCE_SQL_USER3=21
+val SCE_SQL_USER4=22
+val SCE_SQL_QUOTEDIDENTIFIER=23
+val SCE_SQL_QOPERATOR=24
+# Lexical states for SCLEX_SMALLTALK
+lex Smalltalk=SCLEX_SMALLTALK SCE_ST_
+val SCE_ST_DEFAULT=0
+val SCE_ST_STRING=1
+val SCE_ST_NUMBER=2
+val SCE_ST_COMMENT=3
+val SCE_ST_SYMBOL=4
+val SCE_ST_BINARY=5
+val SCE_ST_BOOL=6
+val SCE_ST_SELF=7
+val SCE_ST_SUPER=8
+val SCE_ST_NIL=9
+val SCE_ST_GLOBAL=10
+val SCE_ST_RETURN=11
+val SCE_ST_SPECIAL=12
+val SCE_ST_KWSEND=13
+val SCE_ST_ASSIGN=14
+val SCE_ST_CHARACTER=15
+val SCE_ST_SPEC_SEL=16
+# Lexical states for SCLEX_FLAGSHIP (clipper)
+lex FlagShip=SCLEX_FLAGSHIP SCE_FS_
+val SCE_FS_DEFAULT=0
+val SCE_FS_COMMENT=1
+val SCE_FS_COMMENTLINE=2
+val SCE_FS_COMMENTDOC=3
+val SCE_FS_COMMENTLINEDOC=4
+val SCE_FS_COMMENTDOCKEYWORD=5
+val SCE_FS_COMMENTDOCKEYWORDERROR=6
+val SCE_FS_KEYWORD=7
+val SCE_FS_KEYWORD2=8
+val SCE_FS_KEYWORD3=9
+val SCE_FS_KEYWORD4=10
+val SCE_FS_NUMBER=11
+val SCE_FS_STRING=12
+val SCE_FS_PREPROCESSOR=13
+val SCE_FS_OPERATOR=14
+val SCE_FS_IDENTIFIER=15
+val SCE_FS_DATE=16
+val SCE_FS_STRINGEOL=17
+val SCE_FS_CONSTANT=18
+val SCE_FS_WORDOPERATOR=19
+val SCE_FS_DISABLEDCODE=20
+val SCE_FS_DEFAULT_C=21
+val SCE_FS_COMMENTDOC_C=22
+val SCE_FS_COMMENTLINEDOC_C=23
+val SCE_FS_KEYWORD_C=24
+val SCE_FS_KEYWORD2_C=25
+val SCE_FS_NUMBER_C=26
+val SCE_FS_STRING_C=27
+val SCE_FS_PREPROCESSOR_C=28
+val SCE_FS_OPERATOR_C=29
+val SCE_FS_IDENTIFIER_C=30
+val SCE_FS_STRINGEOL_C=31
+# Lexical states for SCLEX_CSOUND
+lex Csound=SCLEX_CSOUND SCE_CSOUND_
+val SCE_CSOUND_DEFAULT=0
+val SCE_CSOUND_COMMENT=1
+val SCE_CSOUND_NUMBER=2
+val SCE_CSOUND_OPERATOR=3
+val SCE_CSOUND_INSTR=4
+val SCE_CSOUND_IDENTIFIER=5
+val SCE_CSOUND_OPCODE=6
+val SCE_CSOUND_HEADERSTMT=7
+val SCE_CSOUND_USERKEYWORD=8
+val SCE_CSOUND_COMMENTBLOCK=9
+val SCE_CSOUND_PARAM=10
+val SCE_CSOUND_ARATE_VAR=11
+val SCE_CSOUND_KRATE_VAR=12
+val SCE_CSOUND_IRATE_VAR=13
+val SCE_CSOUND_GLOBAL_VAR=14
+val SCE_CSOUND_STRINGEOL=15
+# Lexical states for SCLEX_INNOSETUP
+lex Inno=SCLEX_INNOSETUP SCE_INNO_
+val SCE_INNO_DEFAULT=0
+val SCE_INNO_COMMENT=1
+val SCE_INNO_KEYWORD=2
+val SCE_INNO_PARAMETER=3
+val SCE_INNO_SECTION=4
+val SCE_INNO_PREPROC=5
+val SCE_INNO_INLINE_EXPANSION=6
+val SCE_INNO_COMMENT_PASCAL=7
+val SCE_INNO_KEYWORD_PASCAL=8
+val SCE_INNO_KEYWORD_USER=9
+val SCE_INNO_STRING_DOUBLE=10
+val SCE_INNO_STRING_SINGLE=11
+val SCE_INNO_IDENTIFIER=12
+# Lexical states for SCLEX_OPAL
+lex Opal=SCLEX_OPAL SCE_OPAL_
+val SCE_OPAL_SPACE=0
+val SCE_OPAL_COMMENT_BLOCK=1
+val SCE_OPAL_COMMENT_LINE=2
+val SCE_OPAL_INTEGER=3
+val SCE_OPAL_KEYWORD=4
+val SCE_OPAL_SORT=5
+val SCE_OPAL_STRING=6
+val SCE_OPAL_PAR=7
+val SCE_OPAL_BOOL_CONST=8
+val SCE_OPAL_DEFAULT=32
+# Lexical states for SCLEX_SPICE
+lex Spice=SCLEX_SPICE SCE_SPICE_
+val SCE_SPICE_DEFAULT=0
+val SCE_SPICE_IDENTIFIER=1
+val SCE_SPICE_KEYWORD=2
+val SCE_SPICE_KEYWORD2=3
+val SCE_SPICE_KEYWORD3=4
+val SCE_SPICE_NUMBER=5
+val SCE_SPICE_DELIMITER=6
+val SCE_SPICE_VALUE=7
+val SCE_SPICE_COMMENTLINE=8
+# Lexical states for SCLEX_CMAKE
+lex CMAKE=SCLEX_CMAKE SCE_CMAKE_
+val SCE_CMAKE_DEFAULT=0
+val SCE_CMAKE_COMMENT=1
+val SCE_CMAKE_STRINGDQ=2
+val SCE_CMAKE_STRINGLQ=3
+val SCE_CMAKE_STRINGRQ=4
+val SCE_CMAKE_COMMANDS=5
+val SCE_CMAKE_PARAMETERS=6
+val SCE_CMAKE_VARIABLE=7
+val SCE_CMAKE_USERDEFINED=8
+val SCE_CMAKE_WHILEDEF=9
+val SCE_CMAKE_FOREACHDEF=10
+val SCE_CMAKE_IFDEFINEDEF=11
+val SCE_CMAKE_MACRODEF=12
+val SCE_CMAKE_STRINGVAR=13
+val SCE_CMAKE_NUMBER=14
+# Lexical states for SCLEX_GAP
+lex Gap=SCLEX_GAP SCE_GAP_
+val SCE_GAP_DEFAULT=0
+val SCE_GAP_IDENTIFIER=1
+val SCE_GAP_KEYWORD=2
+val SCE_GAP_KEYWORD2=3
+val SCE_GAP_KEYWORD3=4
+val SCE_GAP_KEYWORD4=5
+val SCE_GAP_STRING=6
+val SCE_GAP_CHAR=7
+val SCE_GAP_OPERATOR=8
+val SCE_GAP_COMMENT=9
+val SCE_GAP_NUMBER=10
+val SCE_GAP_STRINGEOL=11
+# Lexical state for SCLEX_PLM
+lex PLM=SCLEX_PLM SCE_PLM_
+val SCE_PLM_DEFAULT=0
+val SCE_PLM_COMMENT=1
+val SCE_PLM_STRING=2
+val SCE_PLM_NUMBER=3
+val SCE_PLM_IDENTIFIER=4
+val SCE_PLM_OPERATOR=5
+val SCE_PLM_CONTROL=6
+val SCE_PLM_KEYWORD=7
+# Lexical state for SCLEX_PROGRESS
+lex Progress=SCLEX_PROGRESS SCE_ABL_
+val SCE_ABL_DEFAULT=0
+val SCE_ABL_NUMBER=1
+val SCE_ABL_WORD=2
+val SCE_ABL_STRING=3
+val SCE_ABL_CHARACTER=4
+val SCE_ABL_PREPROCESSOR=5
+val SCE_ABL_OPERATOR=6
+val SCE_ABL_IDENTIFIER=7
+val SCE_ABL_BLOCK=8
+val SCE_ABL_END=9
+val SCE_ABL_COMMENT=10
+val SCE_ABL_TASKMARKER=11
+val SCE_ABL_LINECOMMENT=12
+# Lexical states for SCLEX_ABAQUS
+lex ABAQUS=SCLEX_ABAQUS SCE_ABAQUS_
+val SCE_ABAQUS_DEFAULT=0
+val SCE_ABAQUS_COMMENT=1
+val SCE_ABAQUS_COMMENTBLOCK=2
+val SCE_ABAQUS_NUMBER=3
+val SCE_ABAQUS_STRING=4
+val SCE_ABAQUS_OPERATOR=5
+val SCE_ABAQUS_WORD=6
+val SCE_ABAQUS_PROCESSOR=7
+val SCE_ABAQUS_COMMAND=8
+val SCE_ABAQUS_SLASHCOMMAND=9
+val SCE_ABAQUS_STARCOMMAND=10
+val SCE_ABAQUS_ARGUMENT=11
+val SCE_ABAQUS_FUNCTION=12
+# Lexical states for SCLEX_ASYMPTOTE
+lex Asymptote=SCLEX_ASYMPTOTE SCE_ASY_
+val SCE_ASY_DEFAULT=0
+val SCE_ASY_COMMENT=1
+val SCE_ASY_COMMENTLINE=2
+val SCE_ASY_NUMBER=3
+val SCE_ASY_WORD=4
+val SCE_ASY_STRING=5
+val SCE_ASY_CHARACTER=6
+val SCE_ASY_OPERATOR=7
+val SCE_ASY_IDENTIFIER=8
+val SCE_ASY_STRINGEOL=9
+val SCE_ASY_COMMENTLINEDOC=10
+val SCE_ASY_WORD2=11
+# Lexical states for SCLEX_R
+lex R=SCLEX_R SCE_R_
+val SCE_R_DEFAULT=0
+val SCE_R_COMMENT=1
+val SCE_R_KWORD=2
+val SCE_R_BASEKWORD=3
+val SCE_R_OTHERKWORD=4
+val SCE_R_NUMBER=5
+val SCE_R_STRING=6
+val SCE_R_STRING2=7
+val SCE_R_OPERATOR=8
+val SCE_R_IDENTIFIER=9
+val SCE_R_INFIX=10
+val SCE_R_INFIXEOL=11
+# Lexical state for SCLEX_MAGIK
+lex MagikSF=SCLEX_MAGIK SCE_MAGIK_
+val SCE_MAGIK_DEFAULT=0
+val SCE_MAGIK_COMMENT=1
+val SCE_MAGIK_HYPER_COMMENT=16
+val SCE_MAGIK_STRING=2
+val SCE_MAGIK_CHARACTER=3
+val SCE_MAGIK_NUMBER=4
+val SCE_MAGIK_IDENTIFIER=5
+val SCE_MAGIK_OPERATOR=6
+val SCE_MAGIK_FLOW=7
+val SCE_MAGIK_CONTAINER=8
+val SCE_MAGIK_BRACKET_BLOCK=9
+val SCE_MAGIK_BRACE_BLOCK=10
+val SCE_MAGIK_SQBRACKET_BLOCK=11
+val SCE_MAGIK_UNKNOWN_KEYWORD=12
+val SCE_MAGIK_KEYWORD=13
+val SCE_MAGIK_PRAGMA=14
+val SCE_MAGIK_SYMBOL=15
+# Lexical state for SCLEX_POWERSHELL
+lex PowerShell=SCLEX_POWERSHELL SCE_POWERSHELL_
+val SCE_POWERSHELL_DEFAULT=0
+val SCE_POWERSHELL_COMMENT=1
+val SCE_POWERSHELL_STRING=2
+val SCE_POWERSHELL_CHARACTER=3
+val SCE_POWERSHELL_NUMBER=4
+val SCE_POWERSHELL_VARIABLE=5
+val SCE_POWERSHELL_OPERATOR=6
+val SCE_POWERSHELL_IDENTIFIER=7
+val SCE_POWERSHELL_KEYWORD=8
+val SCE_POWERSHELL_CMDLET=9
+val SCE_POWERSHELL_ALIAS=10
+val SCE_POWERSHELL_FUNCTION=11
+val SCE_POWERSHELL_USER1=12
+val SCE_POWERSHELL_COMMENTSTREAM=13
+val SCE_POWERSHELL_HERE_STRING=14
+val SCE_POWERSHELL_HERE_CHARACTER=15
+val SCE_POWERSHELL_COMMENTDOCKEYWORD=16
+# Lexical state for SCLEX_MYSQL
+lex MySQL=SCLEX_MYSQL SCE_MYSQL_
+val SCE_MYSQL_DEFAULT=0
+val SCE_MYSQL_COMMENT=1
+val SCE_MYSQL_COMMENTLINE=2
+val SCE_MYSQL_VARIABLE=3
+val SCE_MYSQL_SYSTEMVARIABLE=4
+val SCE_MYSQL_KNOWNSYSTEMVARIABLE=5
+val SCE_MYSQL_NUMBER=6
+val SCE_MYSQL_MAJORKEYWORD=7
+val SCE_MYSQL_KEYWORD=8
+val SCE_MYSQL_DATABASEOBJECT=9
+val SCE_MYSQL_PROCEDUREKEYWORD=10
+val SCE_MYSQL_STRING=11
+val SCE_MYSQL_SQSTRING=12
+val SCE_MYSQL_DQSTRING=13
+val SCE_MYSQL_OPERATOR=14
+val SCE_MYSQL_FUNCTION=15
+val SCE_MYSQL_IDENTIFIER=16
+val SCE_MYSQL_QUOTEDIDENTIFIER=17
+val SCE_MYSQL_USER1=18
+val SCE_MYSQL_USER2=19
+val SCE_MYSQL_USER3=20
+val SCE_MYSQL_HIDDENCOMMAND=21
+val SCE_MYSQL_PLACEHOLDER=22
+# Lexical state for SCLEX_PO
+lex Po=SCLEX_PO SCE_PO_
+val SCE_PO_DEFAULT=0
+val SCE_PO_COMMENT=1
+val SCE_PO_MSGID=2
+val SCE_PO_MSGID_TEXT=3
+val SCE_PO_MSGSTR=4
+val SCE_PO_MSGSTR_TEXT=5
+val SCE_PO_MSGCTXT=6
+val SCE_PO_MSGCTXT_TEXT=7
+val SCE_PO_FUZZY=8
+val SCE_PO_PROGRAMMER_COMMENT=9
+val SCE_PO_REFERENCE=10
+val SCE_PO_FLAGS=11
+val SCE_PO_MSGID_TEXT_EOL=12
+val SCE_PO_MSGSTR_TEXT_EOL=13
+val SCE_PO_MSGCTXT_TEXT_EOL=14
+val SCE_PO_ERROR=15
+# Lexical states for SCLEX_PASCAL
+lex Pascal=SCLEX_PASCAL SCE_PAS_
+val SCE_PAS_DEFAULT=0
+val SCE_PAS_IDENTIFIER=1
+val SCE_PAS_COMMENT=2
+val SCE_PAS_COMMENT2=3
+val SCE_PAS_COMMENTLINE=4
+val SCE_PAS_PREPROCESSOR=5
+val SCE_PAS_PREPROCESSOR2=6
+val SCE_PAS_NUMBER=7
+val SCE_PAS_HEXNUMBER=8
+val SCE_PAS_WORD=9
+val SCE_PAS_STRING=10
+val SCE_PAS_STRINGEOL=11
+val SCE_PAS_CHARACTER=12
+val SCE_PAS_OPERATOR=13
+val SCE_PAS_ASM=14
+# Lexical state for SCLEX_SORCUS
+lex SORCUS=SCLEX_SORCUS SCE_SORCUS_
+val SCE_SORCUS_DEFAULT=0
+val SCE_SORCUS_COMMAND=1
+val SCE_SORCUS_PARAMETER=2
+val SCE_SORCUS_COMMENTLINE=3
+val SCE_SORCUS_STRING=4
+val SCE_SORCUS_STRINGEOL=5
+val SCE_SORCUS_IDENTIFIER=6
+val SCE_SORCUS_OPERATOR=7
+val SCE_SORCUS_NUMBER=8
+val SCE_SORCUS_CONSTANT=9
+# Lexical state for SCLEX_POWERPRO
+lex PowerPro=SCLEX_POWERPRO SCE_POWERPRO_
+val SCE_POWERPRO_DEFAULT=0
+val SCE_POWERPRO_COMMENTBLOCK=1
+val SCE_POWERPRO_COMMENTLINE=2
+val SCE_POWERPRO_NUMBER=3
+val SCE_POWERPRO_WORD=4
+val SCE_POWERPRO_WORD2=5
+val SCE_POWERPRO_WORD3=6
+val SCE_POWERPRO_WORD4=7
+val SCE_POWERPRO_DOUBLEQUOTEDSTRING=8
+val SCE_POWERPRO_SINGLEQUOTEDSTRING=9
+val SCE_POWERPRO_LINECONTINUE=10
+val SCE_POWERPRO_OPERATOR=11
+val SCE_POWERPRO_IDENTIFIER=12
+val SCE_POWERPRO_STRINGEOL=13
+val SCE_POWERPRO_VERBATIM=14
+val SCE_POWERPRO_ALTQUOTE=15
+val SCE_POWERPRO_FUNCTION=16
+# Lexical states for SCLEX_SML
+lex SML=SCLEX_SML SCE_SML_
+val SCE_SML_DEFAULT=0
+val SCE_SML_IDENTIFIER=1
+val SCE_SML_TAGNAME=2
+val SCE_SML_KEYWORD=3
+val SCE_SML_KEYWORD2=4
+val SCE_SML_KEYWORD3=5
+val SCE_SML_LINENUM=6
+val SCE_SML_OPERATOR=7
+val SCE_SML_NUMBER=8
+val SCE_SML_CHAR=9
+val SCE_SML_STRING=11
+val SCE_SML_COMMENT=12
+val SCE_SML_COMMENT1=13
+val SCE_SML_COMMENT2=14
+val SCE_SML_COMMENT3=15
+# Lexical state for SCLEX_MARKDOWN
+lex Markdown=SCLEX_MARKDOWN SCE_MARKDOWN_
+val SCE_MARKDOWN_DEFAULT=0
+val SCE_MARKDOWN_LINE_BEGIN=1
+val SCE_MARKDOWN_STRONG1=2
+val SCE_MARKDOWN_STRONG2=3
+val SCE_MARKDOWN_EM1=4
+val SCE_MARKDOWN_EM2=5
+val SCE_MARKDOWN_HEADER1=6
+val SCE_MARKDOWN_HEADER2=7
+val SCE_MARKDOWN_HEADER3=8
+val SCE_MARKDOWN_HEADER4=9
+val SCE_MARKDOWN_HEADER5=10
+val SCE_MARKDOWN_HEADER6=11
+val SCE_MARKDOWN_PRECHAR=12
+val SCE_MARKDOWN_ULIST_ITEM=13
+val SCE_MARKDOWN_OLIST_ITEM=14
+val SCE_MARKDOWN_BLOCKQUOTE=15
+val SCE_MARKDOWN_STRIKEOUT=16
+val SCE_MARKDOWN_HRULE=17
+val SCE_MARKDOWN_LINK=18
+val SCE_MARKDOWN_CODE=19
+val SCE_MARKDOWN_CODE2=20
+val SCE_MARKDOWN_CODEBK=21
+# Lexical state for SCLEX_TXT2TAGS
+lex Txt2tags=SCLEX_TXT2TAGS SCE_TXT2TAGS_
+val SCE_TXT2TAGS_DEFAULT=0
+val SCE_TXT2TAGS_LINE_BEGIN=1
+val SCE_TXT2TAGS_STRONG1=2
+val SCE_TXT2TAGS_STRONG2=3
+val SCE_TXT2TAGS_EM1=4
+val SCE_TXT2TAGS_EM2=5
+val SCE_TXT2TAGS_HEADER1=6
+val SCE_TXT2TAGS_HEADER2=7
+val SCE_TXT2TAGS_HEADER3=8
+val SCE_TXT2TAGS_HEADER4=9
+val SCE_TXT2TAGS_HEADER5=10
+val SCE_TXT2TAGS_HEADER6=11
+val SCE_TXT2TAGS_PRECHAR=12
+val SCE_TXT2TAGS_ULIST_ITEM=13
+val SCE_TXT2TAGS_OLIST_ITEM=14
+val SCE_TXT2TAGS_BLOCKQUOTE=15
+val SCE_TXT2TAGS_STRIKEOUT=16
+val SCE_TXT2TAGS_HRULE=17
+val SCE_TXT2TAGS_LINK=18
+val SCE_TXT2TAGS_CODE=19
+val SCE_TXT2TAGS_CODE2=20
+val SCE_TXT2TAGS_CODEBK=21
+val SCE_TXT2TAGS_COMMENT=22
+val SCE_TXT2TAGS_OPTION=23
+val SCE_TXT2TAGS_PREPROC=24
+val SCE_TXT2TAGS_POSTPROC=25
+# Lexical states for SCLEX_A68K
+lex A68k=SCLEX_A68K SCE_A68K_
+val SCE_A68K_DEFAULT=0
+val SCE_A68K_COMMENT=1
+val SCE_A68K_NUMBER_DEC=2
+val SCE_A68K_NUMBER_BIN=3
+val SCE_A68K_NUMBER_HEX=4
+val SCE_A68K_STRING1=5
+val SCE_A68K_OPERATOR=6
+val SCE_A68K_CPUINSTRUCTION=7
+val SCE_A68K_EXTINSTRUCTION=8
+val SCE_A68K_REGISTER=9
+val SCE_A68K_DIRECTIVE=10
+val SCE_A68K_MACRO_ARG=11
+val SCE_A68K_LABEL=12
+val SCE_A68K_STRING2=13
+val SCE_A68K_IDENTIFIER=14
+val SCE_A68K_MACRO_DECLARATION=15
+val SCE_A68K_COMMENT_WORD=16
+val SCE_A68K_COMMENT_SPECIAL=17
+val SCE_A68K_COMMENT_DOXYGEN=18
+# Lexical states for SCLEX_MODULA
+lex Modula=SCLEX_MODULA SCE_MODULA_
+val SCE_MODULA_DEFAULT=0
+val SCE_MODULA_COMMENT=1
+val SCE_MODULA_DOXYCOMM=2
+val SCE_MODULA_DOXYKEY=3
+val SCE_MODULA_KEYWORD=4
+val SCE_MODULA_RESERVED=5
+val SCE_MODULA_NUMBER=6
+val SCE_MODULA_BASENUM=7
+val SCE_MODULA_FLOAT=8
+val SCE_MODULA_STRING=9
+val SCE_MODULA_STRSPEC=10
+val SCE_MODULA_CHAR=11
+val SCE_MODULA_CHARSPEC=12
+val SCE_MODULA_PROC=13
+val SCE_MODULA_PRAGMA=14
+val SCE_MODULA_PRGKEY=15
+val SCE_MODULA_OPERATOR=16
+val SCE_MODULA_BADSTR=17
+# Lexical states for SCLEX_COFFEESCRIPT
+lex CoffeeScript=SCLEX_COFFEESCRIPT SCE_COFFEESCRIPT_
+val SCE_COFFEESCRIPT_DEFAULT=0
+val SCE_COFFEESCRIPT_COMMENT=1
+val SCE_COFFEESCRIPT_COMMENTLINE=2
+val SCE_COFFEESCRIPT_COMMENTDOC=3
+val SCE_COFFEESCRIPT_NUMBER=4
+val SCE_COFFEESCRIPT_WORD=5
+val SCE_COFFEESCRIPT_STRING=6
+val SCE_COFFEESCRIPT_CHARACTER=7
+val SCE_COFFEESCRIPT_UUID=8
+val SCE_COFFEESCRIPT_PREPROCESSOR=9
+val SCE_COFFEESCRIPT_OPERATOR=10
+val SCE_COFFEESCRIPT_IDENTIFIER=11
+val SCE_COFFEESCRIPT_STRINGEOL=12
+val SCE_COFFEESCRIPT_VERBATIM=13
+val SCE_COFFEESCRIPT_REGEX=14
+val SCE_COFFEESCRIPT_COMMENTLINEDOC=15
+val SCE_COFFEESCRIPT_WORD2=16
+val SCE_COFFEESCRIPT_COMMENTDOCKEYWORD=17
+val SCE_COFFEESCRIPT_COMMENTDOCKEYWORDERROR=18
+val SCE_COFFEESCRIPT_GLOBALCLASS=19
+val SCE_COFFEESCRIPT_STRINGRAW=20
+val SCE_COFFEESCRIPT_TRIPLEVERBATIM=21
+val SCE_COFFEESCRIPT_COMMENTBLOCK=22
+val SCE_COFFEESCRIPT_VERBOSE_REGEX=23
+val SCE_COFFEESCRIPT_VERBOSE_REGEX_COMMENT=24
+val SCE_COFFEESCRIPT_INSTANCEPROPERTY=25
+# Lexical states for SCLEX_AVS
+lex AVS=SCLEX_AVS SCE_AVS_
+val SCE_AVS_DEFAULT=0
+val SCE_AVS_COMMENTBLOCK=1
+val SCE_AVS_COMMENTBLOCKN=2
+val SCE_AVS_COMMENTLINE=3
+val SCE_AVS_NUMBER=4
+val SCE_AVS_OPERATOR=5
+val SCE_AVS_IDENTIFIER=6
+val SCE_AVS_STRING=7
+val SCE_AVS_TRIPLESTRING=8
+val SCE_AVS_KEYWORD=9
+val SCE_AVS_FILTER=10
+val SCE_AVS_PLUGIN=11
+val SCE_AVS_FUNCTION=12
+val SCE_AVS_CLIPPROP=13
+val SCE_AVS_USERDFN=14
+# Lexical states for SCLEX_ECL
+lex ECL=SCLEX_ECL SCE_ECL_
+val SCE_ECL_DEFAULT=0
+val SCE_ECL_COMMENT=1
+val SCE_ECL_COMMENTLINE=2
+val SCE_ECL_NUMBER=3
+val SCE_ECL_STRING=4
+val SCE_ECL_WORD0=5
+val SCE_ECL_OPERATOR=6
+val SCE_ECL_CHARACTER=7
+val SCE_ECL_UUID=8
+val SCE_ECL_PREPROCESSOR=9
+val SCE_ECL_UNKNOWN=10
+val SCE_ECL_IDENTIFIER=11
+val SCE_ECL_STRINGEOL=12
+val SCE_ECL_VERBATIM=13
+val SCE_ECL_REGEX=14
+val SCE_ECL_COMMENTLINEDOC=15
+val SCE_ECL_WORD1=16
+val SCE_ECL_COMMENTDOCKEYWORD=17
+val SCE_ECL_COMMENTDOCKEYWORDERROR=18
+val SCE_ECL_WORD2=19
+val SCE_ECL_WORD3=20
+val SCE_ECL_WORD4=21
+val SCE_ECL_WORD5=22
+val SCE_ECL_COMMENTDOC=23
+val SCE_ECL_ADDED=24
+val SCE_ECL_DELETED=25
+val SCE_ECL_CHANGED=26
+val SCE_ECL_MOVED=27
+# Lexical states for SCLEX_OSCRIPT
+lex OScript=SCLEX_OSCRIPT SCE_OSCRIPT_
+val SCE_OSCRIPT_DEFAULT=0
+val SCE_OSCRIPT_LINE_COMMENT=1
+val SCE_OSCRIPT_BLOCK_COMMENT=2
+val SCE_OSCRIPT_DOC_COMMENT=3
+val SCE_OSCRIPT_PREPROCESSOR=4
+val SCE_OSCRIPT_NUMBER=5
+val SCE_OSCRIPT_SINGLEQUOTE_STRING=6
+val SCE_OSCRIPT_DOUBLEQUOTE_STRING=7
+val SCE_OSCRIPT_CONSTANT=8
+val SCE_OSCRIPT_IDENTIFIER=9
+val SCE_OSCRIPT_GLOBAL=10
+val SCE_OSCRIPT_KEYWORD=11
+val SCE_OSCRIPT_OPERATOR=12
+val SCE_OSCRIPT_LABEL=13
+val SCE_OSCRIPT_TYPE=14
+val SCE_OSCRIPT_FUNCTION=15
+val SCE_OSCRIPT_OBJECT=16
+val SCE_OSCRIPT_PROPERTY=17
+val SCE_OSCRIPT_METHOD=18
+# Lexical states for SCLEX_VISUALPROLOG
+lex VisualProlog=SCLEX_VISUALPROLOG SCE_VISUALPROLOG_
+val SCE_VISUALPROLOG_DEFAULT=0
+val SCE_VISUALPROLOG_KEY_MAJOR=1
+val SCE_VISUALPROLOG_KEY_MINOR=2
+val SCE_VISUALPROLOG_KEY_DIRECTIVE=3
+val SCE_VISUALPROLOG_COMMENT_BLOCK=4
+val SCE_VISUALPROLOG_COMMENT_LINE=5
+val SCE_VISUALPROLOG_COMMENT_KEY=6
+val SCE_VISUALPROLOG_COMMENT_KEY_ERROR=7
+val SCE_VISUALPROLOG_IDENTIFIER=8
+val SCE_VISUALPROLOG_VARIABLE=9
+val SCE_VISUALPROLOG_ANONYMOUS=10
+val SCE_VISUALPROLOG_NUMBER=11
+val SCE_VISUALPROLOG_OPERATOR=12
+val SCE_VISUALPROLOG_CHARACTER=13
+val SCE_VISUALPROLOG_CHARACTER_TOO_MANY=14
+val SCE_VISUALPROLOG_CHARACTER_ESCAPE_ERROR=15
+val SCE_VISUALPROLOG_STRING=16
+val SCE_VISUALPROLOG_STRING_ESCAPE=17
+val SCE_VISUALPROLOG_STRING_ESCAPE_ERROR=18
+val SCE_VISUALPROLOG_STRING_EOL_OPEN=19
+val SCE_VISUALPROLOG_STRING_VERBATIM=20
+val SCE_VISUALPROLOG_STRING_VERBATIM_SPECIAL=21
+val SCE_VISUALPROLOG_STRING_VERBATIM_EOL=22
+# Lexical states for SCLEX_STTXT
+lex StructuredText=SCLEX_STTXT SCE_STTXT_
+val SCE_STTXT_DEFAULT=0
+val SCE_STTXT_COMMENT=1
+val SCE_STTXT_COMMENTLINE=2
+val SCE_STTXT_KEYWORD=3
+val SCE_STTXT_TYPE=4
+val SCE_STTXT_FUNCTION=5
+val SCE_STTXT_FB=6
+val SCE_STTXT_NUMBER=7
+val SCE_STTXT_HEXNUMBER=8
+val SCE_STTXT_PRAGMA=9
+val SCE_STTXT_OPERATOR=10
+val SCE_STTXT_CHARACTER=11
+val SCE_STTXT_STRING1=12
+val SCE_STTXT_STRING2=13
+val SCE_STTXT_STRINGEOL=14
+val SCE_STTXT_IDENTIFIER=15
+val SCE_STTXT_DATETIME=16
+val SCE_STTXT_VARS=17
+val SCE_STTXT_PRAGMAS=18
+# Lexical states for SCLEX_KVIRC
+lex KVIrc=SCLEX_KVIRC SCE_KVIRC_
+val SCE_KVIRC_DEFAULT=0
+val SCE_KVIRC_COMMENT=1
+val SCE_KVIRC_COMMENTBLOCK=2
+val SCE_KVIRC_STRING=3
+val SCE_KVIRC_WORD=4
+val SCE_KVIRC_KEYWORD=5
+val SCE_KVIRC_FUNCTION_KEYWORD=6
+val SCE_KVIRC_FUNCTION=7
+val SCE_KVIRC_VARIABLE=8
+val SCE_KVIRC_NUMBER=9
+val SCE_KVIRC_OPERATOR=10
+val SCE_KVIRC_STRING_FUNCTION=11
+val SCE_KVIRC_STRING_VARIABLE=12
+# Lexical states for SCLEX_RUST
+lex Rust=SCLEX_RUST SCE_RUST_
+val SCE_RUST_DEFAULT=0
+val SCE_RUST_COMMENTBLOCK=1
+val SCE_RUST_COMMENTLINE=2
+val SCE_RUST_COMMENTBLOCKDOC=3
+val SCE_RUST_COMMENTLINEDOC=4
+val SCE_RUST_NUMBER=5
+val SCE_RUST_WORD=6
+val SCE_RUST_WORD2=7
+val SCE_RUST_WORD3=8
+val SCE_RUST_WORD4=9
+val SCE_RUST_WORD5=10
+val SCE_RUST_WORD6=11
+val SCE_RUST_WORD7=12
+val SCE_RUST_STRING=13
+val SCE_RUST_STRINGR=14
+val SCE_RUST_CHARACTER=15
+val SCE_RUST_OPERATOR=16
+val SCE_RUST_IDENTIFIER=17
+val SCE_RUST_LIFETIME=18
+val SCE_RUST_MACRO=19
+val SCE_RUST_LEXERROR=20
+val SCE_RUST_BYTESTRING=21
+val SCE_RUST_BYTESTRINGR=22
+val SCE_RUST_BYTECHARACTER=23
+# Lexical states for SCLEX_DMAP
+lex DMAP=SCLEX_DMAP SCE_DMAP_
+val SCE_DMAP_DEFAULT=0
+val SCE_DMAP_COMMENT=1
+val SCE_DMAP_NUMBER=2
+val SCE_DMAP_STRING1=3
+val SCE_DMAP_STRING2=4
+val SCE_DMAP_STRINGEOL=5
+val SCE_DMAP_OPERATOR=6
+val SCE_DMAP_IDENTIFIER=7
+val SCE_DMAP_WORD=8
+val SCE_DMAP_WORD2=9
+val SCE_DMAP_WORD3=10
+# Lexical states for SCLEX_DMIS
+lex DMIS=SCLEX_DMIS SCE_DMIS_
+val SCE_DMIS_DEFAULT=0
+val SCE_DMIS_COMMENT=1
+val SCE_DMIS_STRING=2
+val SCE_DMIS_NUMBER=3
+val SCE_DMIS_KEYWORD=4
+val SCE_DMIS_MAJORWORD=5
+val SCE_DMIS_MINORWORD=6
+val SCE_DMIS_UNSUPPORTED_MAJOR=7
+val SCE_DMIS_UNSUPPORTED_MINOR=8
+val SCE_DMIS_LABEL=9
+# Lexical states for SCLEX_REGISTRY
+lex REG=SCLEX_REGISTRY SCE_REG_
+val SCE_REG_DEFAULT=0
+val SCE_REG_COMMENT=1
+val SCE_REG_VALUENAME=2
+val SCE_REG_STRING=3
+val SCE_REG_HEXDIGIT=4
+val SCE_REG_VALUETYPE=5
+val SCE_REG_ADDEDKEY=6
+val SCE_REG_DELETEDKEY=7
+val SCE_REG_ESCAPED=8
+val SCE_REG_KEYPATH_GUID=9
+val SCE_REG_STRING_GUID=10
+val SCE_REG_PARAMETER=11
+val SCE_REG_OPERATOR=12
+# Lexical state for SCLEX_BIBTEX
+lex BibTeX=SCLEX_BIBTEX SCE_BIBTEX_
+val SCE_BIBTEX_DEFAULT=0
+val SCE_BIBTEX_ENTRY=1
+val SCE_BIBTEX_UNKNOWN_ENTRY=2
+val SCE_BIBTEX_KEY=3
+val SCE_BIBTEX_PARAMETER=4
+val SCE_BIBTEX_VALUE=5
+val SCE_BIBTEX_COMMENT=6
+# Lexical state for SCLEX_SREC
+lex Srec=SCLEX_SREC SCE_HEX_
+val SCE_HEX_DEFAULT=0
+val SCE_HEX_RECSTART=1
+val SCE_HEX_RECTYPE=2
+val SCE_HEX_RECTYPE_UNKNOWN=3
+val SCE_HEX_BYTECOUNT=4
+val SCE_HEX_BYTECOUNT_WRONG=5
+val SCE_HEX_NOADDRESS=6
+val SCE_HEX_DATAADDRESS=7
+val SCE_HEX_RECCOUNT=8
+val SCE_HEX_STARTADDRESS=9
+val SCE_HEX_ADDRESSFIELD_UNKNOWN=10
+val SCE_HEX_EXTENDEDADDRESS=11
+val SCE_HEX_DATA_ODD=12
+val SCE_HEX_DATA_EVEN=13
+val SCE_HEX_DATA_UNKNOWN=14
+val SCE_HEX_DATA_EMPTY=15
+val SCE_HEX_CHECKSUM=16
+val SCE_HEX_CHECKSUM_WRONG=17
+val SCE_HEX_GARBAGE=18
+# Lexical state for SCLEX_IHEX (shared with Srec)
+lex IHex=SCLEX_IHEX SCE_HEX_
+# Lexical state for SCLEX_TEHEX (shared with Srec)
+lex TEHex=SCLEX_TEHEX SCE_HEX_
+# Lexical states for SCLEX_JSON
+lex JSON=SCLEX_JSON SCE_JSON_
+val SCE_JSON_DEFAULT=0
+val SCE_JSON_NUMBER=1
+val SCE_JSON_STRING=2
+val SCE_JSON_STRINGEOL=3
+val SCE_JSON_PROPERTYNAME=4
+val SCE_JSON_ESCAPESEQUENCE=5
+val SCE_JSON_LINECOMMENT=6
+val SCE_JSON_BLOCKCOMMENT=7
+val SCE_JSON_OPERATOR=8
+val SCE_JSON_URI=9
+val SCE_JSON_COMPACTIRI=10
+val SCE_JSON_KEYWORD=11
+val SCE_JSON_LDKEYWORD=12
+val SCE_JSON_ERROR=13
+lex EDIFACT=SCLEX_EDIFACT SCE_EDI_
+val SCE_EDI_DEFAULT=0
+val SCE_EDI_SEGMENTSTART=1
+val SCE_EDI_SEGMENTEND=2
+val SCE_EDI_SEP_ELEMENT=3
+val SCE_EDI_SEP_COMPOSITE=4
+val SCE_EDI_SEP_RELEASE=5
+val SCE_EDI_UNA=6
+val SCE_EDI_UNH=7
+val SCE_EDI_BADSEGMENT=8
+# Lexical states for SCLEX_STATA
+lex STATA=SCLEX_STATA SCE_STATA_
+val SCE_STATA_DEFAULT=0
+val SCE_STATA_COMMENT=1
+val SCE_STATA_COMMENTLINE=2
+val SCE_STATA_COMMENTBLOCK=3
+val SCE_STATA_NUMBER=4
+val SCE_STATA_OPERATOR=5
+val SCE_STATA_IDENTIFIER=6
+val SCE_STATA_STRING=7
+val SCE_STATA_TYPE=8
+val SCE_STATA_WORD=9
+val SCE_STATA_GLOBAL_MACRO=10
+val SCE_STATA_MACRO=11
+# Lexical states for SCLEX_SAS
+lex SAS=SCLEX_SAS SCE_SAS_
+val SCE_SAS_DEFAULT=0
+val SCE_SAS_COMMENT=1
+val SCE_SAS_COMMENTLINE=2
+val SCE_SAS_COMMENTBLOCK=3
+val SCE_SAS_NUMBER=4
+val SCE_SAS_OPERATOR=5
+val SCE_SAS_IDENTIFIER=6
+val SCE_SAS_STRING=7
+val SCE_SAS_TYPE=8
+val SCE_SAS_WORD=9
+val SCE_SAS_GLOBAL_MACRO=10
+val SCE_SAS_MACRO=11
+val SCE_SAS_MACRO_KEYWORD=12
+val SCE_SAS_BLOCK_KEYWORD=13
+val SCE_SAS_MACRO_FUNCTION=14
+val SCE_SAS_STATEMENT=15
+# Lexical states for SCLEX_NIM
+lex Nim=SCLEX_NIM SCE_NIM_
+val SCE_NIM_DEFAULT=0
+val SCE_NIM_COMMENT=1
+val SCE_NIM_COMMENTDOC=2
+val SCE_NIM_COMMENTLINE=3
+val SCE_NIM_COMMENTLINEDOC=4
+val SCE_NIM_NUMBER=5
+val SCE_NIM_STRING=6
+val SCE_NIM_CHARACTER=7
+val SCE_NIM_WORD=8
+val SCE_NIM_TRIPLE=9
+val SCE_NIM_TRIPLEDOUBLE=10
+val SCE_NIM_BACKTICKS=11
+val SCE_NIM_FUNCNAME=12
+val SCE_NIM_STRINGEOL=13
+val SCE_NIM_NUMERROR=14
+val SCE_NIM_OPERATOR=15
+val SCE_NIM_IDENTIFIER=16
+# Lexical states for SCLEX_CIL
+lex CIL=SCLEX_CIL SCE_CIL_
+val SCE_CIL_DEFAULT=0
+val SCE_CIL_COMMENT=1
+val SCE_CIL_COMMENTLINE=2
+val SCE_CIL_WORD=3
+val SCE_CIL_WORD2=4
+val SCE_CIL_WORD3=5
+val SCE_CIL_STRING=6
+val SCE_CIL_LABEL=7
+val SCE_CIL_OPERATOR=8
+val SCE_CIL_IDENTIFIER=9
+val SCE_CIL_STRINGEOL=10
+# Lexical states for SCLEX_X12
+lex X12=SCLEX_X12 SCE_X12_
+val SCE_X12_DEFAULT=0
+val SCE_X12_BAD=1
+val SCE_X12_ENVELOPE=2
+val SCE_X12_FUNCTIONGROUP=3
+val SCE_X12_TRANSACTIONSET=4
+val SCE_X12_SEGMENTHEADER=5
+val SCE_X12_SEGMENTEND=6
+val SCE_X12_SEP_ELEMENT=7
+val SCE_X12_SEP_SUBELEMENT=8
+# Lexical states for SCLEX_DATAFLEX
+lex Dataflex=SCLEX_DATAFLEX SCE_DF_
+val SCE_DF_DEFAULT=0
+val SCE_DF_IDENTIFIER=1
+val SCE_DF_METATAG=2
+val SCE_DF_IMAGE=3
+val SCE_DF_COMMENTLINE=4
+val SCE_DF_PREPROCESSOR=5
+val SCE_DF_PREPROCESSOR2=6
+val SCE_DF_NUMBER=7
+val SCE_DF_HEXNUMBER=8
+val SCE_DF_WORD=9
+val SCE_DF_STRING=10
+val SCE_DF_STRINGEOL=11
+val SCE_DF_SCOPEWORD=12
+val SCE_DF_OPERATOR=13
+val SCE_DF_ICODE=14
+# Lexical states for SCLEX_HOLLYWOOD
+lex Hollywood=SCLEX_HOLLYWOOD SCE_HOLLYWOOD_
+val SCE_HOLLYWOOD_DEFAULT=0
+val SCE_HOLLYWOOD_COMMENT=1
+val SCE_HOLLYWOOD_COMMENTBLOCK=2
+val SCE_HOLLYWOOD_NUMBER=3
+val SCE_HOLLYWOOD_KEYWORD=4
+val SCE_HOLLYWOOD_STDAPI=5
+val SCE_HOLLYWOOD_PLUGINAPI=6
+val SCE_HOLLYWOOD_PLUGINMETHOD=7
+val SCE_HOLLYWOOD_STRING=8
+val SCE_HOLLYWOOD_STRINGBLOCK=9
+val SCE_HOLLYWOOD_PREPROCESSOR=10
+val SCE_HOLLYWOOD_OPERATOR=11
+val SCE_HOLLYWOOD_IDENTIFIER=12
+val SCE_HOLLYWOOD_CONSTANT=13
+val SCE_HOLLYWOOD_HEXNUMBER=14
+# Lexical states for SCLEX_RAKU
+lex Raku=SCLEX_RAKU SCE_RAKU_
+val SCE_RAKU_DEFAULT=0
+val SCE_RAKU_ERROR=1
+val SCE_RAKU_COMMENTLINE=2
+val SCE_RAKU_COMMENTEMBED=3
+val SCE_RAKU_POD=4
+val SCE_RAKU_CHARACTER=5
+val SCE_RAKU_HEREDOC_Q=6
+val SCE_RAKU_HEREDOC_QQ=7
+val SCE_RAKU_STRING=8
+val SCE_RAKU_STRING_Q=9
+val SCE_RAKU_STRING_QQ=10
+val SCE_RAKU_STRING_Q_LANG=11
+val SCE_RAKU_STRING_VAR=12
+val SCE_RAKU_REGEX=13
+val SCE_RAKU_REGEX_VAR=14
+val SCE_RAKU_ADVERB=15
+val SCE_RAKU_NUMBER=16
+val SCE_RAKU_PREPROCESSOR=17
+val SCE_RAKU_OPERATOR=18
+val SCE_RAKU_WORD=19
+val SCE_RAKU_FUNCTION=20
+val SCE_RAKU_IDENTIFIER=21
+val SCE_RAKU_TYPEDEF=22
+val SCE_RAKU_MU=23
+val SCE_RAKU_POSITIONAL=24
+val SCE_RAKU_ASSOCIATIVE=25
+val SCE_RAKU_CALLABLE=26
+val SCE_RAKU_GRAMMAR=27
+val SCE_RAKU_CLASS=28
+
+# Events
+
+evt void StyleNeeded=2000(int position)
+evt void CharAdded=2001(int ch, int characterSource)
+evt void SavePointReached=2002(void)
+evt void SavePointLeft=2003(void)
+evt void ModifyAttemptRO=2004(void)
+# GTK Specific to work around focus and accelerator problems:
+evt void Key=2005(int ch, int modifiers)
+evt void DoubleClick=2006(int modifiers, int position, int line)
+evt void UpdateUI=2007(int updated)
+evt void Modified=2008(int position, int modificationType, string text, int length, int linesAdded, int line, int foldLevelNow, int foldLevelPrev, int token, int annotationLinesAdded)
+evt void MacroRecord=2009(int message, int wParam, int lParam)
+evt void MarginClick=2010(int modifiers, int position, int margin)
+evt void NeedShown=2011(int position, int length)
+evt void Painted=2013(void)
+evt void UserListSelection=2014(int listType, string text, int position, int ch, CompletionMethods listCompletionMethod)
+evt void URIDropped=2015(string text)
+evt void DwellStart=2016(int position, int x, int y)
+evt void DwellEnd=2017(int position, int x, int y)
+evt void Zoom=2018(void)
+evt void HotSpotClick=2019(int modifiers, int position)
+evt void HotSpotDoubleClick=2020(int modifiers, int position)
+evt void CallTipClick=2021(int position)
+evt void AutoCSelection=2022(string text, int position, int ch, CompletionMethods listCompletionMethod)
+evt void IndicatorClick=2023(int modifiers, int position)
+evt void IndicatorRelease=2024(int modifiers, int position)
+evt void AutoCCancelled=2025(void)
+evt void AutoCCharDeleted=2026(void)
+evt void HotSpotReleaseClick=2027(int modifiers, int position)
+evt void FocusIn=2028(void)
+evt void FocusOut=2029(void)
+evt void AutoCCompleted=2030(string text, int position, int ch, CompletionMethods listCompletionMethod)
+evt void MarginRightClick=2031(int modifiers, int position, int margin)
+evt void AutoCSelectionChange=2032(int listType, string text, int position)
+
+cat Provisional
+
+enu Bidirectional=SC_BIDIRECTIONAL_
+val SC_BIDIRECTIONAL_DISABLED=0
+val SC_BIDIRECTIONAL_L2R=1
+val SC_BIDIRECTIONAL_R2L=2
+
+# Retrieve bidirectional text display state.
+get Bidirectional GetBidirectional=2708(,)
+
+# Set bidirectional text display state.
+set void SetBidirectional=2709(Bidirectional bidirectional,)
+
+enu LineCharacterIndexType=SC_LINECHARACTERINDEX_
+val SC_LINECHARACTERINDEX_NONE=0
+val SC_LINECHARACTERINDEX_UTF32=1
+val SC_LINECHARACTERINDEX_UTF16=2
+
+# Retrieve line character index state.
+get LineCharacterIndexType GetLineCharacterIndex=2710(,)
+
+# Request line character index be created or its use count increased.
+fun void AllocateLineCharacterIndex=2711(LineCharacterIndexType lineCharacterIndex,)
+
+# Decrease use count of line character index and remove if 0.
+fun void ReleaseLineCharacterIndex=2712(LineCharacterIndexType lineCharacterIndex,)
+
+# Retrieve the document line containing a position measured in index units.
+fun line LineFromIndexPosition=2713(position pos, LineCharacterIndexType lineCharacterIndex)
+
+# Retrieve the position measured in index units at the start of a document line.
+fun position IndexPositionFromLine=2714(line line, LineCharacterIndexType lineCharacterIndex)
+
+cat Deprecated
+
+# Divide each styling byte into lexical class bits (default: 5) and indicator
+# bits (default: 3). If a lexer requires more than 32 lexical states, then this
+# is used to expand the possible states.
+set void SetStyleBits=2090(int bits,)
+
+# Retrieve number of bits in style bytes used to hold the lexical state.
+get int GetStyleBits=2091(,)
+
+# Retrieve the number of bits the current lexer needs for styling.
+get int GetStyleBitsNeeded=4011(,)
+
+# Deprecated in 3.5.5
+
+# Always interpret keyboard input as Unicode
+set void SetKeysUnicode=2521(bool keysUnicode,)
+
+# Are keys always interpreted as Unicode?
+get bool GetKeysUnicode=2522(,)
+
+# Is drawing done in two phases with backgrounds drawn before foregrounds?
+get bool GetTwoPhaseDraw=2283(,)
+
+# In twoPhaseDraw mode, drawing is performed in two phases, first the background
+# and then the foreground. This avoids chopping off characters that overlap the next run.
+set void SetTwoPhaseDraw=2284(bool twoPhase,)
+
+val INDIC0_MASK=0x20
+val INDIC1_MASK=0x40
+val INDIC2_MASK=0x80
+val INDICS_MASK=0xE0
diff --git a/Pythonwin/Scintilla/include/ScintillaWidget.h b/Pythonwin/Scintilla/include/ScintillaWidget.h
new file mode 100644
index 000000000..1721f65d9
--- /dev/null
+++ b/Pythonwin/Scintilla/include/ScintillaWidget.h
@@ -0,0 +1,72 @@
+/* Scintilla source code edit control */
+/* @file ScintillaWidget.h
+ * Definition of Scintilla widget for GTK+.
+ * Only needed by GTK+ code but is harmless on other platforms.
+ * This comment is not a doc-comment as that causes warnings from g-ir-scanner.
+ */
+/* Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+ * The License.txt file describes the conditions under which this software may be distributed. */
+
+#ifndef SCINTILLAWIDGET_H
+#define SCINTILLAWIDGET_H
+
+#if defined(GTK)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SCINTILLA(obj)          G_TYPE_CHECK_INSTANCE_CAST (obj, scintilla_get_type (), ScintillaObject)
+#define SCINTILLA_CLASS(klass)  G_TYPE_CHECK_CLASS_CAST (klass, scintilla_get_type (), ScintillaClass)
+#define IS_SCINTILLA(obj)       G_TYPE_CHECK_INSTANCE_TYPE (obj, scintilla_get_type ())
+
+#define SCINTILLA_TYPE_OBJECT             (scintilla_object_get_type())
+#define SCINTILLA_OBJECT(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj), SCINTILLA_TYPE_OBJECT, ScintillaObject))
+#define SCINTILLA_IS_OBJECT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SCINTILLA_TYPE_OBJECT))
+#define SCINTILLA_OBJECT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST((klass), SCINTILLA_TYPE_OBJECT, ScintillaObjectClass))
+#define SCINTILLA_IS_OBJECT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE((klass), SCINTILLA_TYPE_OBJECT))
+#define SCINTILLA_OBJECT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), SCINTILLA_TYPE_OBJECT, ScintillaObjectClass))
+
+typedef struct _ScintillaObject ScintillaObject;
+typedef struct _ScintillaClass  ScintillaObjectClass;
+
+struct _ScintillaObject {
+	GtkContainer cont;
+	void *pscin;
+};
+
+struct _ScintillaClass {
+	GtkContainerClass parent_class;
+
+	void (* command) (ScintillaObject *sci, int cmd, GtkWidget *window);
+	void (* notify) (ScintillaObject *sci, int id, SCNotification *scn);
+};
+
+GType		scintilla_object_get_type		(void);
+GtkWidget*	scintilla_object_new			(void);
+gintptr		scintilla_object_send_message	(ScintillaObject *sci, unsigned int iMessage, guintptr wParam, gintptr lParam);
+
+
+GType		scnotification_get_type			(void);
+#define SCINTILLA_TYPE_NOTIFICATION        (scnotification_get_type())
+
+#ifndef G_IR_SCANNING
+/* The legacy names confuse the g-ir-scanner program */
+typedef struct _ScintillaClass  ScintillaClass;
+
+GType		scintilla_get_type	(void);
+GtkWidget*	scintilla_new		(void);
+void		scintilla_set_id	(ScintillaObject *sci, uptr_t id);
+sptr_t		scintilla_send_message	(ScintillaObject *sci,unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+void		scintilla_release_resources(void);
+#endif
+
+#define SCINTILLA_NOTIFY "sci-notify"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#endif
diff --git a/Pythonwin/Scintilla/include/WinDefs.h b/Pythonwin/Scintilla/include/WinDefs.h
deleted file mode 100644
index bab41662e..000000000
--- a/Pythonwin/Scintilla/include/WinDefs.h
+++ /dev/null
@@ -1,185 +0,0 @@
-// Scintilla source code edit control
-/** @file WinDefs.h
- ** The subset of definitions from Windows needed by Scintilla for GTK+.
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#ifndef WINDEFS_H
-#define WINDEFS_H
-
-#define WORD short
-#define WPARAM unsigned long
-#define LPARAM long
-#define LRESULT long
-#define DWORD long
-
-#define UINT unsigned int
-#define LPSTR char *
-#define LONG long
-
-//#if 0
-/* RTF control */
-#define EM_CANPASTE	(1074)
-#define EM_CANUNDO	(198)
-#define EM_CHARFROMPOS	(215)
-#define EM_EMPTYUNDOBUFFER	(205)
-#define EM_EXGETSEL	(1076)
-#define EM_EXLINEFROMCHAR	(1078)
-#define EM_EXSETSEL	(1079)
-#define EM_FINDTEXT	(1080)
-#define EM_FINDTEXTEX	(1103)
-#define EM_FORMATRANGE	(1081)
-#define EM_GETFIRSTVISIBLELINE	(206)
-#define EM_GETLINE	(196)
-#define EM_GETLINECOUNT	(186)
-#define EM_GETMARGINS	(212)
-#define EM_GETMODIFY	(184)
-#define EM_GETRECT	(178)
-#define EM_GETSEL	(176)
-#define EM_GETSELTEXT	(1086)
-#define EM_GETTEXTRANGE	(1099)
-#define EM_HIDESELECTION	(1087)
-#define EM_LINEFROMCHAR	(201)
-#define EM_LINEINDEX	(187)
-#define EM_LINELENGTH	(193)
-#define EM_LINESCROLL	(182)
-#define EM_POSFROMCHAR	(214)
-#define EM_REPLACESEL	(194)
-#define EM_SCROLLCARET	(183)
-#define EM_SELECTIONTYPE	(1090)
-#define EM_SETMARGINS	(211)
-#define EM_SETREADONLY	(207)
-#define EM_SETSEL	(177)
-#define EM_UNDO	(199)
-
-#define WM_NULL		(0)
-#define WM_CLEAR	(771)
-#define WM_COPY	(769)
-#define WM_CUT	(768)
-#define WM_GETTEXT	(13)
-#define WM_GETTEXTLENGTH	(14)
-#define WM_PASTE	(770)
-#define WM_SETTEXT	(12)
-#define WM_UNDO	(772)
-
-#define EN_CHANGE	(768)
-#define EN_KILLFOCUS (512)
-#define EN_SETFOCUS (256)
-
-#define EC_LEFTMARGIN 1
-#define EC_RIGHTMARGIN 2
-#define EC_USEFONTINFO 0xffff
-
-//#endif
-
-#if 0
-#if PLAT_GTK
-#define VK_DOWN GDK_Down
-#define VK_UP GDK_Up
-#define VK_LEFT GDK_Left
-#define VK_RIGHT GDK_Right
-#define VK_HOME GDK_Home
-#define VK_END GDK_End
-#define VK_PRIOR GDK_Page_Up
-#define VK_NEXT GDK_Page_Down
-#define VK_DELETE GDK_Delete
-#define VK_INSERT GDK_Insert
-#define VK_ESCAPE GDK_Escape
-#define VK_BACK GDK_BackSpace
-#define VK_TAB GDK_Tab
-#define VK_RETURN GDK_Return
-#define VK_ADD GDK_KP_Add
-#define VK_SUBTRACT GDK_KP_Subtract
-#define VK_DIVIDE GDK_KP_Divide
-#endif
-
-#if PLAT_WX
-#define VK_DOWN         WXK_DOWN
-#define VK_UP           WXK_UP
-#define VK_LEFT         WXK_LEFT
-#define VK_RIGHT        WXK_RIGHT
-#define VK_HOME         WXK_HOME
-#define VK_END          WXK_END
-#define VK_PRIOR        WXK_PRIOR
-#define VK_NEXT         WXK_NEXT
-#define VK_DELETE       WXK_DELETE
-#define VK_INSERT       WXK_INSERT
-#define VK_ESCAPE       WXK_ESCAPE
-#define VK_BACK         WXK_BACK
-#define VK_TAB          WXK_TAB
-#define VK_RETURN       WXK_RETURN
-#define VK_ADD          WXK_ADD
-#define VK_SUBTRACT     WXK_SUBTRACT
-//TODO:
-#define VK_DIVIDE	WXK_DIVIDE
-#endif
-
-#define SHIFT_PRESSED 1
-#define LEFT_CTRL_PRESSED 2
-#define LEFT_ALT_PRESSED 4
-
-// Are these needed any more
-#define LPSTR char *
-#define LONG long
-#define LPDWORD (long *)
-
-/* SELCHANGE structure */
-#define SEL_EMPTY	(0)
-#define SEL_TEXT	(1)
-#define SEL_OBJECT	(2)
-#define SEL_MULTICHAR	(4)
-#define SEL_MULTIOBJECT	(8)
-
-struct RECT {
-	LONG left;
-	LONG top;
-	LONG right;
-	LONG bottom;
-};
-
-/* FINDREPLACE structure */
-
-#define FR_MATCHCASE	(0x4)
-#define FR_WHOLEWORD	(0x2)
-#define FR_DOWN		(0x1)
-
-#endif
-
-#if 0
-struct CHARRANGE {
-	LONG cpMin;
-	LONG cpMax;
-};
-
-struct TEXTRANGE {
-	CHARRANGE chrg;
-	LPSTR lpstrText;
-};
-
-struct FINDTEXTEX {
-	CHARRANGE chrg;
-	LPSTR lpstrText;
-	CHARRANGE chrgText;
-};
-
-struct NMHDR {
-	WindowID hwndFrom;
-	UINT idFrom;
-	UINT code;
-};
-
-struct FORMATRANGE {
-	SurfaceID hdc;
-	SurfaceID hdcTarget;
-	RECT rc;
-	RECT rcPage;
-	CHARRANGE chrg;
-};
-#endif
-
-//#define MAKELONG(a, b) ((a) | ((b) << 16))
-//#define LOWORD(x) (x & 0xffff)
-//#define HIWORD(x) (x >> 16)
-
-#endif
diff --git a/Pythonwin/Scintilla/include/WindowAccessor.h b/Pythonwin/Scintilla/include/WindowAccessor.h
deleted file mode 100644
index e107a0659..000000000
--- a/Pythonwin/Scintilla/include/WindowAccessor.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// Scintilla source code edit control
-/** @file WindowAccessor.h
- ** Implementation of BufferAccess and StylingAccess on a Scintilla
- ** rapid easy access to contents of a Scintilla.
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#ifdef SCI_NAMESPACE
-namespace Scintilla {
-#endif
-
-/**
- */
-class WindowAccessor : public Accessor {
-	// Private so WindowAccessor objects can not be copied
-	WindowAccessor(const WindowAccessor &source) : Accessor(), props(source.props) {}
-	WindowAccessor &operator=(const WindowAccessor &) { return *this; }
-protected:
-	WindowID id;
-	PropSet &props;
-	int lenDoc;
-
-	char styleBuf[bufferSize];
-	int validLen;
-	char chFlags;
-	char chWhile;
-	unsigned int startSeg;
-
-	bool InternalIsLeadByte(char ch);
-	void Fill(int position);
-public:
-	WindowAccessor(WindowID id_, PropSet &props_) : 
-		Accessor(), id(id_), props(props_), 
-		lenDoc(-1), validLen(0), chFlags(0), chWhile(0) {
-	}
-	~WindowAccessor();
-	bool Match(int pos, const char *s);
-	char StyleAt(int position);
-	int GetLine(int position);
-	int LineStart(int line);
-	int LevelAt(int line);
-	int Length();
-	void Flush();
-	int GetLineState(int line);
-	int SetLineState(int line, int state);
-	int GetPropertyInt(const char *key, int defaultValue=0) { 
-		return props.GetInt(key, defaultValue); 
-	}
-	char *GetProperties() {
-		return props.ToString();
-	}
-
-	void StartAt(unsigned int start, char chMask=31);
-	void SetFlags(char chFlags_, char chWhile_) {chFlags = chFlags_; chWhile = chWhile_; };
-	unsigned int GetStartSegment() { return startSeg; }
-	void StartSegment(unsigned int pos);
-	void ColourTo(unsigned int pos, int chAttr);
-	void SetLevel(int line, int level);
-	int IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader = 0);
-	void IndicatorFill(int start, int end, int indicator, int value);
-};
-
-#ifdef SCI_NAMESPACE
-}
-#endif
diff --git a/Pythonwin/Scintilla/lexers/LexA68k.cxx b/Pythonwin/Scintilla/lexers/LexA68k.cxx
new file mode 100644
index 000000000..1475ad078
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexA68k.cxx
@@ -0,0 +1,345 @@
+// Scintilla source code edit control
+/** @file LexA68k.cxx
+ ** Lexer for Assembler, just for the MASM syntax
+ ** Written by Martial Demolins AKA Folco
+ **/
+// Copyright 2010 Martial Demolins <mdemolins(a)gmail.com>
+// The License.txt file describes the conditions under which this software
+// may be distributed.
+
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+
+// Return values for GetOperatorType
+#define NO_OPERATOR     0
+#define OPERATOR_1CHAR  1
+#define OPERATOR_2CHAR  2
+
+
+/**
+ *  IsIdentifierStart
+ *
+ *  Return true if the given char is a valid identifier first char
+ */
+
+static inline bool IsIdentifierStart (const int ch)
+{
+    return (isalpha(ch) || (ch == '_') || (ch == '\\'));
+}
+
+
+/**
+ *  IsIdentifierChar
+ *
+ *  Return true if the given char is a valid identifier char
+ */
+
+static inline bool IsIdentifierChar (const int ch)
+{
+    return (isalnum(ch) || (ch == '_') || (ch == '@') || (ch == ':') || (ch == '.'));
+}
+
+
+/**
+ *  GetOperatorType
+ *
+ *  Return:
+ *  NO_OPERATOR     if char is not an operator
+ *  OPERATOR_1CHAR  if the operator is one char long
+ *  OPERATOR_2CHAR  if the operator is two chars long
+ */
+
+static inline int GetOperatorType (const int ch1, const int ch2)
+{
+    int OpType = NO_OPERATOR;
+
+    if ((ch1 == '+') || (ch1 == '-') || (ch1 == '*') || (ch1 == '/') || (ch1 == '#') ||
+        (ch1 == '(') || (ch1 == ')') || (ch1 == '~') || (ch1 == '&') || (ch1 == '|') || (ch1 == ','))
+        OpType = OPERATOR_1CHAR;
+
+    else if ((ch1 == ch2) && (ch1 == '<' || ch1 == '>'))
+        OpType = OPERATOR_2CHAR;
+
+    return OpType;
+}
+
+
+/**
+ *  IsBin
+ *
+ *  Return true if the given char is 0 or 1
+ */
+
+static inline bool IsBin (const int ch)
+{
+    return (ch == '0') || (ch == '1');
+}
+
+
+/**
+ *  IsDoxygenChar
+ *
+ *  Return true if the char may be part of a Doxygen keyword
+ */
+
+static inline bool IsDoxygenChar (const int ch)
+{
+    return isalpha(ch) || (ch == '$') || (ch == '[') || (ch == ']') || (ch == '{') || (ch == '}');
+}
+
+
+/**
+ *  ColouriseA68kDoc
+ *
+ *  Main function, which colourises a 68k source
+ */
+
+static void ColouriseA68kDoc (Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[], Accessor &styler)
+{
+    // Used to buffer a string, to be able to compare it using built-in functions
+    char Buffer[100];
+
+
+    // Used to know the length of an operator
+    int OpType;
+
+
+    // Get references to keywords lists
+    WordList &cpuInstruction = *keywordlists[0];
+    WordList &registers = *keywordlists[1];
+    WordList &directive = *keywordlists[2];
+    WordList &extInstruction = *keywordlists[3];
+    WordList &alert          = *keywordlists[4];
+    WordList &doxygenKeyword = *keywordlists[5];
+
+
+    // Instanciate a context for our source
+    StyleContext sc(startPos, length, initStyle, styler);
+
+
+    /************************************************************
+    *
+    *   Parse the source
+    *
+    ************************************************************/
+
+    for ( ; sc.More(); sc.Forward())
+    {
+        /************************************************************
+        *
+        *   A style always terminates at the end of a line, even for
+        *   comments (no multi-lines comments)
+        *
+        ************************************************************/
+        if (sc.atLineStart) {
+            sc.SetState(SCE_A68K_DEFAULT);
+        }
+
+
+        /************************************************************
+        *
+        *   If we are not in "default style", check if the style continues
+        *   In this case, we just have to loop
+        *
+        ************************************************************/
+
+        if (sc.state != SCE_A68K_DEFAULT)
+        {
+            if (   ((sc.state == SCE_A68K_NUMBER_DEC)        && isdigit(sc.ch))                      // Decimal number
+                || ((sc.state == SCE_A68K_NUMBER_BIN) && IsBin(sc.ch))                                      // Binary number
+                || ((sc.state == SCE_A68K_NUMBER_HEX) && isxdigit(sc.ch))                                   // Hexa number
+                || ((sc.state == SCE_A68K_MACRO_ARG)         && isdigit(sc.ch))                      // Macro argument
+                || ((sc.state == SCE_A68K_STRING1)    && (sc.ch != '\''))                                   // String single-quoted
+                || ((sc.state == SCE_A68K_STRING2)    && (sc.ch != '\"'))                                   // String double-quoted
+                || ((sc.state == SCE_A68K_MACRO_DECLARATION) && IsIdentifierChar(sc.ch))             // Macro declaration (or global label, we don't know at this point)
+                || ((sc.state == SCE_A68K_IDENTIFIER)        && IsIdentifierChar(sc.ch))             // Identifier
+                || ((sc.state == SCE_A68K_LABEL)             && IsIdentifierChar(sc.ch))             // Label (local)
+                || ((sc.state == SCE_A68K_COMMENT_DOXYGEN)   && IsDoxygenChar(sc.ch))                // Doxygen keyword
+                || ((sc.state == SCE_A68K_COMMENT_SPECIAL)   && isalpha(sc.ch))                      // Alert
+                || ((sc.state == SCE_A68K_COMMENT)           && !isalpha(sc.ch) && (sc.ch != '\\'))) // Normal comment
+            {
+                continue;
+            }
+
+        /************************************************************
+        *
+        *   Check if current state terminates
+        *
+        ************************************************************/
+
+            // Strings: include terminal ' or " in the current string by skipping it
+            if ((sc.state == SCE_A68K_STRING1) || (sc.state == SCE_A68K_STRING2)) {
+                sc.Forward();
+                }
+
+
+            // If a macro declaration was terminated with ':', it was a label
+            else if ((sc.state == SCE_A68K_MACRO_DECLARATION) && (sc.chPrev == ':')) {
+                sc.ChangeState(SCE_A68K_LABEL);
+            }
+
+
+            // If it wasn't a Doxygen keyword, change it to normal comment
+            else if (sc.state == SCE_A68K_COMMENT_DOXYGEN) {
+                sc.GetCurrent(Buffer, sizeof(Buffer));
+                if (!doxygenKeyword.InList(Buffer)) {
+                    sc.ChangeState(SCE_A68K_COMMENT);
+                }
+                sc.SetState(SCE_A68K_COMMENT);
+                continue;
+            }
+
+
+            // If it wasn't an Alert, change it to normal comment
+            else if (sc.state == SCE_A68K_COMMENT_SPECIAL) {
+                sc.GetCurrent(Buffer, sizeof(Buffer));
+                if (!alert.InList(Buffer)) {
+                    sc.ChangeState(SCE_A68K_COMMENT);
+                }
+                // Reset style to normal comment, or to Doxygen keyword if it begins with '\'
+                if (sc.ch == '\\') {
+                    sc.SetState(SCE_A68K_COMMENT_DOXYGEN);
+                }
+                else {
+                sc.SetState(SCE_A68K_COMMENT);
+                }
+                continue;
+            }
+
+
+            // If we are in a comment, it's a Doxygen keyword or an Alert
+            else if (sc.state == SCE_A68K_COMMENT) {
+                if (sc.ch == '\\') {
+                    sc.SetState(SCE_A68K_COMMENT_DOXYGEN);
+                }
+                else {
+                    sc.SetState(SCE_A68K_COMMENT_SPECIAL);
+                }
+                continue;
+            }
+
+
+            // Check if we are at the end of an identifier
+            // In this case, colourise it if was a keyword.
+            else if ((sc.state == SCE_A68K_IDENTIFIER) && !IsIdentifierChar(sc.ch)) {
+                sc.GetCurrentLowered(Buffer, sizeof(Buffer));                           // Buffer the string of the current context
+                if (cpuInstruction.InList(Buffer)) {                                    // And check if it belongs to a keyword list
+                    sc.ChangeState(SCE_A68K_CPUINSTRUCTION);
+                }
+                else if (extInstruction.InList(Buffer)) {
+                    sc.ChangeState(SCE_A68K_EXTINSTRUCTION);
+                }
+                else if (registers.InList(Buffer)) {
+                    sc.ChangeState(SCE_A68K_REGISTER);
+                }
+                else if (directive.InList(Buffer)) {
+                    sc.ChangeState(SCE_A68K_DIRECTIVE);
+                }
+            }
+
+            // All special contexts are now handled.Come back to default style
+            sc.SetState(SCE_A68K_DEFAULT);
+        }
+
+
+        /************************************************************
+        *
+        *   Check if we must enter a new state
+        *
+        ************************************************************/
+
+        // Something which begins at the beginning of a line, and with
+        // - '\' + an identifier start char, or
+        // - '\\@' + an identifier start char
+        // is a local label (second case is used for macro local labels). We set it already as a label, it can't be a macro/equ declaration
+        if (sc.atLineStart && (sc.ch < 0x80) && IsIdentifierStart(sc.chNext) && (sc.ch == '\\')) {
+            sc.SetState(SCE_A68K_LABEL);
+        }
+
+        if (sc.atLineStart && (sc.ch < 0x80) && (sc.ch == '\\') && (sc.chNext == '\\')) {
+            sc.Forward(2);
+            if ((sc.ch == '@') && IsIdentifierStart(sc.chNext)) {
+                sc.ChangeState(SCE_A68K_LABEL);
+                sc.SetState(SCE_A68K_LABEL);
+            }
+        }
+
+        // Label and macro identifiers start at the beginning of a line
+        // We set both as a macro id, but if it wasn't one (':' at the end),
+        // it will be changed as a label.
+        if (sc.atLineStart && (sc.ch < 0x80) && IsIdentifierStart(sc.ch)) {
+            sc.SetState(SCE_A68K_MACRO_DECLARATION);
+        }
+        else if ((sc.ch < 0x80) && (sc.ch == ';')) {                            // Default: alert in a comment. If it doesn't match
+            sc.SetState(SCE_A68K_COMMENT);                                      // with an alert, it will be toggle to a normal comment
+        }
+        else if ((sc.ch < 0x80) && isdigit(sc.ch)) {                            // Decimal numbers haven't prefix
+            sc.SetState(SCE_A68K_NUMBER_DEC);
+        }
+        else if ((sc.ch < 0x80) && (sc.ch == '%')) {                            // Binary numbers are prefixed with '%'
+            sc.SetState(SCE_A68K_NUMBER_BIN);
+        }
+        else if ((sc.ch < 0x80) && (sc.ch == '$')) {                            // Hexadecimal numbers are prefixed with '$'
+            sc.SetState(SCE_A68K_NUMBER_HEX);
+        }
+        else if ((sc.ch < 0x80) && (sc.ch == '\'')) {                           // String (single-quoted)
+            sc.SetState(SCE_A68K_STRING1);
+        }
+        else if ((sc.ch < 0x80) && (sc.ch == '\"')) {                           // String (double-quoted)
+            sc.SetState(SCE_A68K_STRING2);
+        }
+        else if ((sc.ch < 0x80) && (sc.ch == '\\') && (isdigit(sc.chNext))) {   // Replacement symbols in macro are prefixed with '\'
+            sc.SetState(SCE_A68K_MACRO_ARG);
+        }
+        else if ((sc.ch < 0x80) && IsIdentifierStart(sc.ch)) {                  // An identifier: constant, label, etc...
+            sc.SetState(SCE_A68K_IDENTIFIER);
+        }
+        else {
+            if (sc.ch < 0x80) {
+                OpType = GetOperatorType(sc.ch, sc.chNext);                     // Check if current char is an operator
+                if (OpType != NO_OPERATOR) {
+                    sc.SetState(SCE_A68K_OPERATOR);
+                    if (OpType == OPERATOR_2CHAR) {                             // Check if the operator is 2 bytes long
+                        sc.ForwardSetState(SCE_A68K_OPERATOR);                  // (>> or <<)
+                    }
+                }
+            }
+        }
+    }                                                                           // End of for()
+    sc.Complete();
+}
+
+
+// Names of the keyword lists
+
+static const char * const a68kWordListDesc[] =
+{
+    "CPU instructions",
+    "Registers",
+    "Directives",
+    "Extended instructions",
+    "Comment special words",
+    "Doxygen keywords",
+    0
+};
+
+LexerModule lmA68k(SCLEX_A68K, ColouriseA68kDoc, "a68k", 0, a68kWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexAPDL.cxx b/Pythonwin/Scintilla/lexers/LexAPDL.cxx
similarity index 94%
rename from Pythonwin/Scintilla/src/LexAPDL.cxx
rename to Pythonwin/Scintilla/lexers/LexAPDL.cxx
index 7bf597b42..447e40d58 100644
--- a/Pythonwin/Scintilla/src/LexAPDL.cxx
+++ b/Pythonwin/Scintilla/lexers/LexAPDL.cxx
@@ -8,22 +8,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static inline bool IsAWordChar(const int ch) {
 	return (ch < 0x80 && (isalnum(ch) || ch == '_'));
@@ -40,7 +41,7 @@ static inline bool IsAnOperator(char ch) {
 	return false;
 }
 
-static void ColouriseAPDLDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
+static void ColouriseAPDLDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
                             Accessor &styler) {
 
 	int stringStart = ' ';
@@ -181,16 +182,16 @@ static int CheckAPDLFoldPoint(char const *token, int &level) {
 	return 0;
 }
 
-static void FoldAPDLDoc(unsigned int startPos, int length, int,
+static void FoldAPDLDoc(Sci_PositionU startPos, Sci_Position length, int,
 	WordList *[], Accessor &styler) {
 
-	int line = styler.GetLine(startPos);
+	Sci_Position line = styler.GetLine(startPos);
 	int level = styler.LevelAt(line);
 	int go = 0, done = 0;
-	int endPos = startPos + length;
+	Sci_Position endPos = startPos + length;
 	char word[256];
 	int wordlen = 0;
-	int i;
+	Sci_Position i;
     bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
 	// Scan for tokens at the start of the line (they may include
 	// whitespace, for tokens like "End Function"
diff --git a/Pythonwin/Scintilla/src/LexASY.cxx b/Pythonwin/Scintilla/lexers/LexASY.cxx
similarity index 89%
rename from Pythonwin/Scintilla/src/LexASY.cxx
rename to Pythonwin/Scintilla/lexers/LexASY.cxx
index 5bf979fd3..612d24b40 100644
--- a/Pythonwin/Scintilla/src/LexASY.cxx
+++ b/Pythonwin/Scintilla/lexers/LexASY.cxx
@@ -1,28 +1,28 @@
 // Scintilla source code edit control
+// @file LexASY.cxx
 //Author: instanton (email: soft_share<at>126<dot>com)
 // The License.txt file describes the conditions under which this software may be distributed.
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
 #include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-static void ColouriseAsyDoc(unsigned int startPos, int length, int initStyle, 
+static void ColouriseAsyDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
 		WordList *keywordlists[], Accessor &styler) {
 
 	WordList &keywords = *keywordlists[0];
@@ -118,7 +118,7 @@ static void ColouriseAsyDoc(unsigned int startPos, int length, int initStyle,
 				sc.SetState(SCE_ASY_IDENTIFIER);
 			} else if (sc.Match('/', '*')) {
 				sc.SetState(SCE_ASY_COMMENT);
-				sc.Forward();	// 
+				sc.Forward();	//
 			} else if (sc.Match('/', '/')) {
 				sc.SetState(SCE_ASY_COMMENTLINE);
 			} else if (sc.ch == '\"') {
@@ -151,7 +151,7 @@ static inline bool isASYidentifier(int ch) {
       ((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z')) ;
 }
 
-static int ParseASYWord(unsigned int pos, Accessor &styler, char *word)
+static int ParseASYWord(Sci_PositionU pos, Accessor &styler, char *word)
 {
   int length=0;
   char ch=styler.SafeGetCharAt(pos);
@@ -162,15 +162,15 @@ static int ParseASYWord(unsigned int pos, Accessor &styler, char *word)
           length++;
           ch=styler.SafeGetCharAt(pos+length);
   }
-  word[length]=0;   
+  word[length]=0;
   return length;
 }
 
-static bool IsASYDrawingLine(int line, Accessor &styler) {
-	int pos = styler.LineStart(line);
-	int eol_pos = styler.LineStart(line + 1) - 1;
-	
-	int startpos = pos;
+static bool IsASYDrawingLine(Sci_Position line, Accessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+
+	Sci_Position startpos = pos;
 	char buffer[100]="";
 
 	while (startpos<eol_pos){
@@ -181,18 +181,18 @@ static bool IsASYDrawingLine(int line, Accessor &styler) {
 		if (!drawcommands && ch!=' ') return false;
 		else if (drawcommands) return true;
 		startpos++;
-	}		
+	}
 	return false;
 }
 
-static void FoldAsyDoc(unsigned int startPos, int length, int initStyle, 
+static void FoldAsyDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
 					   WordList *[], Accessor &styler) {
 	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
 	bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0;
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelCurrent = SC_FOLDLEVELBASE;
 	if (lineCurrent > 0)
 		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
@@ -201,7 +201,7 @@ static void FoldAsyDoc(unsigned int startPos, int length, int initStyle,
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
 	int style = initStyle;
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int stylePrev = style;
@@ -236,7 +236,7 @@ static void FoldAsyDoc(unsigned int startPos, int length, int initStyle,
 			else if (lineCurrent!=0 && IsASYDrawingLine(lineCurrent - 1, styler) &&
 				!IsASYDrawingLine(lineCurrent+1, styler))
 				levelNext--;
-		}	
+		}
 
 		if (atEOL) {
 			int levelUse = levelCurrent;
diff --git a/Pythonwin/Scintilla/src/LexAU3.cxx b/Pythonwin/Scintilla/lexers/LexAU3.cxx
similarity index 89%
rename from Pythonwin/Scintilla/src/LexAU3.cxx
rename to Pythonwin/Scintilla/lexers/LexAU3.cxx
index cedf261f5..417c832e0 100644
--- a/Pythonwin/Scintilla/src/LexAU3.cxx
+++ b/Pythonwin/Scintilla/lexers/LexAU3.cxx
@@ -1,15 +1,15 @@
 // Scintilla source code edit control
 // @file LexAU3.cxx
-// Lexer for AutoIt3  http://www.hiddensoft.com/autoit3
-// by Jos van der Zande, jvdzande@yahoo.com 
+// Lexer for AutoIt3 https://www.autoitscript.com/site/
+// by Jos van der Zande, jvdzande@yahoo.com
 //
 // Changes:
 // March 28, 2004 - Added the standard Folding code
 // April 21, 2004 - Added Preprosessor Table + Syntax Highlighting
 //                  Fixed Number highlighting
 //                  Changed default isoperator to IsAOperator to have a better match to AutoIt3
-//                  Fixed "#comments_start" -> "#comments-start"  
-//                  Fixed "#comments_end" -> "#comments-end"  
+//                  Fixed "#comments_start" -> "#comments-start"
+//                  Fixed "#comments_end" -> "#comments-end"
 //                  Fixed Sendkeys in Strings when not terminated with }
 //                  Added support for Sendkey strings that have second parameter e.g. {UP 5} or {a down}
 // April 26, 2004 - Fixed # pre-processor statement inside of comment block would invalidly change the color.
@@ -25,9 +25,9 @@
 //                  Added fold.compact support set with fold.compact=1
 //                  Changed folding inside of #cs-#ce. Default is no keyword folding inside comment blocks when fold.comment=1
 //                        it will now only happen when fold.comment=2.
-// Sep 5, 2004    - Added logic to handle colourizing words on the last line. 
+// Sep 5, 2004    - Added logic to handle colourizing words on the last line.
 //                        Typed Characters now show as "default" till they match any table.
-// Oct 10, 2004   - Added logic to show Comments in "Special" directives. 
+// Oct 10, 2004   - Added logic to show Comments in "Special" directives.
 // Nov  1, 2004   - Added better testing for Numbers supporting x and e notation.
 // Nov 28, 2004   - Added logic to handle continuation lines for syntax highlighting.
 // Jan 10, 2005   - Added Abbreviations Keyword used for expansion
@@ -52,22 +52,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static inline bool IsTypeCharacter(const int ch)
 {
@@ -84,7 +85,7 @@ static inline bool IsAWordStart(const int ch)
 }
 
 static inline bool IsAOperator(char ch) {
-	if (isascii(ch) && isalnum(ch))
+	if (IsASCII(ch) && isalnum(ch))
 		return false;
 	if (ch == '+' || ch == '-' || ch == '*' || ch == '/' ||
 	    ch == '&' || ch == '^' || ch == '=' || ch == '<' || ch == '>' ||
@@ -127,7 +128,7 @@ static int GetSendKey(const char *szLine, char *szKey)
 			}
 			else if (cTemp == ' ')
 			{
-				// skip other spaces 
+				// skip other spaces
 			}
 			else if (nFlag == 0)
 			{
@@ -139,7 +140,7 @@ static int GetSendKey(const char *szLine, char *szKey)
 				// Save second portion into var...
 				szSpecial[nSpecPos++] = cTemp;
 				// check if Second portion is all numbers for repeat fuction
-				if (isdigit(cTemp) == false) {nSpecNum = 0;} 
+				if (isdigit(cTemp) == false) {nSpecNum = 0;}
 			}
 		}
 		nPos++;									// skip to next char
@@ -151,7 +152,7 @@ static int GetSendKey(const char *szLine, char *szKey)
 	szKey[nKeyPos] = '\0';
 	szSpecial[nSpecPos] = '\0';
 	if (strcmp(szSpecial,"down")== 0    || strcmp(szSpecial,"up")== 0  ||
-		strcmp(szSpecial,"on")== 0      || strcmp(szSpecial,"off")== 0 || 
+		strcmp(szSpecial,"on")== 0      || strcmp(szSpecial,"off")== 0 ||
 		strcmp(szSpecial,"toggle")== 0  || nSpecNum == 1 )
 	{
 		nFlag = 0;
@@ -160,17 +161,17 @@ static int GetSendKey(const char *szLine, char *szKey)
 	{
 		nFlag = 1;
 	}
-	return nFlag;  // 1 is bad, 0 is good 
+	return nFlag;  // 1 is bad, 0 is good
 
-} // GetSendKey() 
+} // GetSendKey()
 
 //
 // Routine to check the last "none comment" character on a line to see if its a continuation
-// 
-static bool IsContinuationLine(unsigned int szLine, Accessor &styler)
+//
+static bool IsContinuationLine(Sci_PositionU szLine, Accessor &styler)
 {
-	int nsPos = styler.LineStart(szLine);
-	int nePos = styler.LineStart(szLine+1) - 2;
+	Sci_Position nsPos = styler.LineStart(szLine);
+	Sci_Position nePos = styler.LineStart(szLine+1) - 2;
 	//int stylech = styler.StyleAt(nsPos);
 	while (nsPos < nePos)
 	{
@@ -192,8 +193,8 @@ static bool IsContinuationLine(unsigned int szLine, Accessor &styler)
 
 //
 // syntax highlighting logic
-static void ColouriseAU3Doc(unsigned int startPos, 
-							int length, int initStyle,
+static void ColouriseAU3Doc(Sci_PositionU startPos,
+							Sci_Position length, int initStyle,
 							WordList *keywordlists[],
 							Accessor &styler) {
 
@@ -206,27 +207,27 @@ static void ColouriseAU3Doc(unsigned int startPos,
     WordList &keywords7 = *keywordlists[6];
     WordList &keywords8 = *keywordlists[7];
 	// find the first previous line without continuation character at the end
-	int lineCurrent = styler.GetLine(startPos);
-	int s_startPos = startPos;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	Sci_Position s_startPos = startPos;
 	// When not inside a Block comment: find First line without _
 	if (!(initStyle==SCE_AU3_COMMENTBLOCK)) {
 		while ((lineCurrent > 0 && IsContinuationLine(lineCurrent,styler)) ||
 			   (lineCurrent > 1 && IsContinuationLine(lineCurrent-1,styler))) {
 			lineCurrent--;
 			startPos = styler.LineStart(lineCurrent); // get start position
-			initStyle =  0;                           // reset the start style to 0 
+			initStyle =  0;                           // reset the start style to 0
 		}
 	}
 	// Set the new length to include it from the start and set the start position
 	length = length + s_startPos - startPos;      // correct the total length to process
     styler.StartAt(startPos);
-	
+
     StyleContext sc(startPos, length, initStyle, styler);
 	char si;     // string indicator "=1 '=2
 	char ni;     // Numeric indicator error=9 normal=0 normal+dec=1 hex=2 Enot=3
-	char ci;     // comment indicator 0=not linecomment(;) 
-	char s_save[100];
-	si=0;  
+	char ci;     // comment indicator 0=not linecomment(;)
+	char s_save[100] = "";
+	si=0;
 	ni=0;
 	ci=0;
 	//$$$
@@ -234,11 +235,11 @@ static void ColouriseAU3Doc(unsigned int startPos,
 		char s[100];
 		sc.GetCurrentLowered(s, sizeof(s));
 		// **********************************************
-		// save the total current word for eof processing 
-		if (IsAWordChar(sc.ch) || sc.ch == '}') 
+		// save the total current word for eof processing
+		if (IsAWordChar(sc.ch) || sc.ch == '}')
 		{
 			strcpy(s_save,s);
-			int tp = strlen(s_save);
+			int tp = static_cast<int>(strlen(s_save));
 			if (tp < 99) {
 				s_save[tp] = static_cast<char>(tolower(sc.ch));
 				s_save[tp+1] = '\0';
@@ -253,11 +254,12 @@ static void ColouriseAU3Doc(unsigned int startPos,
 				//Reset at line end
 				if (sc.atLineEnd) {
 					ci=0;
-					if ((strcmp(s, "#ce")== 0 || strcmp(s, "#comments-end")== 0))
-						if (sc.atLineEnd) 
+					if (strcmp(s, "#ce")== 0 || strcmp(s, "#comments-end")== 0) {
+						if (sc.atLineEnd)
 							sc.SetState(SCE_AU3_DEFAULT);
-						else	
+						else
 							sc.SetState(SCE_AU3_COMMENTBLOCK);
+					}
 					break;
 				}
 				//skip rest of line when a ; is encountered
@@ -266,9 +268,9 @@ static void ColouriseAU3Doc(unsigned int startPos,
 					sc.SetState(SCE_AU3_COMMENTBLOCK);
 				}
 				// skip rest of the line
-				if (ci==2) 
+				if (ci==2)
 					break;
-				// check when first character is detected on the line 
+				// check when first character is detected on the line
 				if (ci==0) {
 					if (IsAWordStart(static_cast<char>(sc.ch)) || IsAOperator(static_cast<char>(sc.ch))) {
 						ci=1;
@@ -291,10 +293,10 @@ static void ColouriseAU3Doc(unsigned int startPos,
             }
             case SCE_AU3_OPERATOR:
             {
-                // check if its a COMobject 
+                // check if its a COMobject
 				if (sc.chPrev == '.' && IsAWordChar(sc.ch)) {
 					sc.SetState(SCE_AU3_COMOBJ);
-				}	
+				}
 				else {
 					sc.SetState(SCE_AU3_DEFAULT);
 				}
@@ -359,7 +361,7 @@ static void ColouriseAU3Doc(unsigned int startPos,
 							sc.SetState(SCE_AU3_DEFAULT);
 						}
 					}
-				}	
+				}
                 if (sc.atLineEnd) {
 					sc.SetState(SCE_AU3_DEFAULT);}
                 break;
@@ -432,7 +434,7 @@ static void ColouriseAU3Doc(unsigned int startPos,
             case SCE_AU3_STRING:
             {
 				// check for " to end a double qouted string or
-				// check for ' to end a single qouted string 
+				// check for ' to end a single qouted string
 	            if ((si == 1 && sc.ch == '\"') || (si == 2 && sc.ch == '\'') || (si == 3 && sc.ch == '>'))
 				{
 					sc.ForwardSetState(SCE_AU3_DEFAULT);
@@ -443,8 +445,8 @@ static void ColouriseAU3Doc(unsigned int startPos,
 				{
 					si=0;
 					// at line end and not found a continuation char then reset to default
-					int lineCurrent = styler.GetLine(sc.currentPos);
-					if (!IsContinuationLine(lineCurrent,styler)) 
+					Sci_Position lineCurrent = styler.GetLine(sc.currentPos);
+					if (!IsContinuationLine(lineCurrent,styler))
 					{
 						sc.SetState(SCE_AU3_DEFAULT);
 						break;
@@ -455,27 +457,27 @@ static void ColouriseAU3Doc(unsigned int startPos,
 					sc.SetState(SCE_AU3_SENT);}
 				break;
             }
-            
+
             case SCE_AU3_SENT:
             {
-				// Send key string ended 
-				if (sc.chPrev == '}' && sc.ch != '}') 
+				// Send key string ended
+				if (sc.chPrev == '}' && sc.ch != '}')
 				{
 					// set color to SENDKEY when valid sendkey .. else set back to regular string
 					char sk[100];
 					// split {111 222} and return {111} and check if 222 is valid.
 					// if return code = 1 then invalid 222 so must be string
-					if (GetSendKey(s,sk))   
+					if (GetSendKey(s,sk))
 					{
 						sc.ChangeState(SCE_AU3_STRING);
 					}
 					// if single char between {?} then its ok as sendkey for a single character
-					else if (strlen(sk) == 3)  
+					else if (strlen(sk) == 3)
 					{
 						sc.ChangeState(SCE_AU3_SENT);
 					}
 					// if sendkey {111} is in table then ok as sendkey
-					else if (keywords4.InList(sk)) 
+					else if (keywords4.InList(sk))
 					{
 						sc.ChangeState(SCE_AU3_SENT);
 					}
@@ -488,12 +490,12 @@ static void ColouriseAU3Doc(unsigned int startPos,
 				else
 				{
 					// check if the start is a valid SendKey start
-					int		nPos	= 0;
+					Sci_Position		nPos	= 0;
 					int		nState	= 1;
 					char	cTemp;
-					while (!(nState == 2) && ((cTemp = s[nPos]) != '\0')) 
+					while (!(nState == 2) && ((cTemp = s[nPos]) != '\0'))
 					{
-						if (cTemp == '{' && nState == 1) 
+						if (cTemp == '{' && nState == 1)
 						{
 							nState = 2;
 						}
@@ -508,14 +510,14 @@ static void ColouriseAU3Doc(unsigned int startPos,
 						sc.ChangeState(SCE_AU3_STRING);
 						sc.SetState(SCE_AU3_STRING);
 					}
-					// If invalid character found then assume its a regular string	
+					// If invalid character found then assume its a regular string
 					if (nState == 0) {
 						sc.ChangeState(SCE_AU3_STRING);
 						sc.SetState(SCE_AU3_STRING);
 					}
 				}
 				// check if next portion is again a sendkey
-				if (sc.atLineEnd) 
+				if (sc.atLineEnd)
 				{
 					sc.ChangeState(SCE_AU3_STRING);
 					sc.SetState(SCE_AU3_DEFAULT);
@@ -546,14 +548,14 @@ static void ColouriseAU3Doc(unsigned int startPos,
             else if (sc.ch == '.' && !IsADigit(sc.chNext)) {sc.SetState(SCE_AU3_OPERATOR);}
             else if (sc.ch == '@') {sc.SetState(SCE_AU3_KEYWORD);}
             //else if (sc.ch == '_') {sc.SetState(SCE_AU3_KEYWORD);}
-            else if (sc.ch == '<' && si==3) {sc.SetState(SCE_AU3_STRING);}  // string after #include 
+            else if (sc.ch == '<' && si==3) {sc.SetState(SCE_AU3_STRING);}  // string after #include
             else if (sc.ch == '\"') {
 				sc.SetState(SCE_AU3_STRING);
 				si = 1;	}
             else if (sc.ch == '\'') {
 				sc.SetState(SCE_AU3_STRING);
 				si = 2;	}
-            else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) 
+            else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext)))
 			{
 				sc.SetState(SCE_AU3_NUMBER);
 				ni = 0;
@@ -565,7 +567,7 @@ static void ColouriseAU3Doc(unsigned int startPos,
     }      //for (; sc.More(); sc.Forward())
 
 	//*************************************
-	// Colourize the last word correctly 
+	// Colourize the last word correctly
 	//*************************************
 	if (sc.state == SCE_AU3_KEYWORD)
 		{
@@ -609,24 +611,24 @@ static void ColouriseAU3Doc(unsigned int startPos,
 	}
 	if (sc.state == SCE_AU3_SENT)
     {
-		// Send key string ended 
-		if (sc.chPrev == '}' && sc.ch != '}') 
+		// Send key string ended
+		if (sc.chPrev == '}' && sc.ch != '}')
 		{
 			// set color to SENDKEY when valid sendkey .. else set back to regular string
 			char sk[100];
 			// split {111 222} and return {111} and check if 222 is valid.
 			// if return code = 1 then invalid 222 so must be string
-			if (GetSendKey(s_save,sk))   
+			if (GetSendKey(s_save,sk))
 			{
 				sc.ChangeState(SCE_AU3_STRING);
 			}
 			// if single char between {?} then its ok as sendkey for a single character
-			else if (strlen(sk) == 3)  
+			else if (strlen(sk) == 3)
 			{
 				sc.ChangeState(SCE_AU3_SENT);
 			}
 			// if sendkey {111} is in table then ok as sendkey
-			else if (keywords4.InList(sk)) 
+			else if (keywords4.InList(sk))
 			{
 				sc.ChangeState(SCE_AU3_SENT);
 			}
@@ -637,7 +639,7 @@ static void ColouriseAU3Doc(unsigned int startPos,
 			sc.SetState(SCE_AU3_STRING);
 		}
 		// check if next portion is again a sendkey
-		if (sc.atLineEnd) 
+		if (sc.atLineEnd)
 		{
 			sc.ChangeState(SCE_AU3_STRING);
 			sc.SetState(SCE_AU3_DEFAULT);
@@ -654,11 +656,11 @@ static bool IsStreamCommentStyle(int style) {
 
 //
 // Routine to find first none space on the current line and return its Style
-// needed for comment lines not starting on pos 1 
-static int GetStyleFirstWord(unsigned int szLine, Accessor &styler)
+// needed for comment lines not starting on pos 1
+static int GetStyleFirstWord(Sci_PositionU szLine, Accessor &styler)
 {
-	int nsPos = styler.LineStart(szLine);
-	int nePos = styler.LineStart(szLine+1) - 1;
+	Sci_Position nsPos = styler.LineStart(szLine);
+	Sci_Position nePos = styler.LineStart(szLine+1) - 1;
 	while (isspacechar(styler.SafeGetCharAt(nsPos)) && nsPos < nePos)
 	{
 		nsPos++; // skip to next char
@@ -670,23 +672,23 @@ static int GetStyleFirstWord(unsigned int szLine, Accessor &styler)
 
 
 //
-static void FoldAU3Doc(unsigned int startPos, int length, int, WordList *[], Accessor &styler)
+static void FoldAU3Doc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler)
 {
-	int endPos = startPos + length;
+	Sci_Position endPos = startPos + length;
 	// get settings from the config files for folding comments and preprocessor lines
 	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
 	bool foldInComment = styler.GetPropertyInt("fold.comment") == 2;
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
 	bool foldpreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0;
 	// Backtrack to previous line in case need to fix its fold status
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	if (startPos > 0) {
 		if (lineCurrent > 0) {
 			lineCurrent--;
 			startPos = styler.LineStart(lineCurrent);
 		}
 	}
-	// vars for style of previous/current/next lines 
+	// vars for style of previous/current/next lines
 	int style = GetStyleFirstWord(lineCurrent,styler);
 	int stylePrev = 0;
 	// find the first previous line without continuation character at the end
@@ -711,12 +713,12 @@ static void FoldAU3Doc(unsigned int startPos, int length, int, WordList *[], Acc
 	if (lineCurrent > 0)
 		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
 	int levelNext = levelCurrent;
-	//  
+	//
 	int	visibleChars = 0;
 	char chNext = styler.SafeGetCharAt(startPos);
 	char chPrev = ' ';
 	//
-	for (int i = startPos; i < endPos; i++) {
+	for (Sci_Position i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		if (IsAWordChar(ch)) {
@@ -736,7 +738,7 @@ static void FoldAU3Doc(unsigned int startPos, int length, int, WordList *[], Acc
 				}
 			}
 		}
-		// start the capture of the first word 
+		// start the capture of the first word
 		if (!(FirstWordStart)) {
 			if (IsAWordChar(ch) || IsAWordStart(ch) || ch == ';') {
 				FirstWordStart = true;
@@ -748,7 +750,7 @@ static void FoldAU3Doc(unsigned int startPos, int length, int, WordList *[], Acc
 			if (ThenFoundLast) {
 				if (IsAWordChar(ch)) {
 					ThenFoundLast = false;
-				}		
+				}
 			}
 			// find out if the word "then" is the last on a "if" line
 			if (FirstWordEnd && strcmp(szKeyword,"if") == 0) {
@@ -769,21 +771,21 @@ static void FoldAU3Doc(unsigned int startPos, int length, int, WordList *[], Acc
 				}
 			}
 		}
-		// End of Line found so process the information 
+		// End of Line found so process the information
 		if ((ch == '\r' && chNext != '\n') || (ch == '\n') || (i == endPos)) {
 			// **************************
 			// Folding logic for Keywords
 			// **************************
 			// if a keyword is found on the current line and the line doesn't end with _ (continuation)
 			//    and we are not inside a commentblock.
-			if (szKeywordlen > 0 && (!(chPrev == '_')) && 
+			if (szKeywordlen > 0 && (!(chPrev == '_')) &&
 				((!(IsStreamCommentStyle(style)) || foldInComment)) ) {
 				szKeyword[szKeywordlen] = '\0';
 				// only fold "if" last keyword is "then"  (else its a one line if)
 				if (strcmp(szKeyword,"if") == 0  && ThenFoundLast) {
 						levelNext++;
 				}
-				// create new fold for these words 
+				// create new fold for these words
 				if (strcmp(szKeyword,"do") == 0   || strcmp(szKeyword,"for") == 0 ||
 					strcmp(szKeyword,"func") == 0 || strcmp(szKeyword,"while") == 0||
 					strcmp(szKeyword,"with") == 0 || strcmp(szKeyword,"#region") == 0 ) {
@@ -796,12 +798,12 @@ static void FoldAU3Doc(unsigned int startPos, int length, int, WordList *[], Acc
 				}
 				// end the fold for these words before the current line
 				if (strcmp(szKeyword,"endfunc") == 0 || strcmp(szKeyword,"endif") == 0 ||
-					strcmp(szKeyword,"next") == 0    || strcmp(szKeyword,"until") == 0 || 
+					strcmp(szKeyword,"next") == 0    || strcmp(szKeyword,"until") == 0 ||
 					strcmp(szKeyword,"endwith") == 0 ||strcmp(szKeyword,"wend") == 0){
 						levelNext--;
 						levelCurrent--;
 				}
-				// end the fold for these words before the current line and Start new fold 
+				// end the fold for these words before the current line and Start new fold
 				if (strcmp(szKeyword,"case") == 0      || strcmp(szKeyword,"else") == 0 ||
 					strcmp(szKeyword,"elseif") == 0 ) {
 						levelCurrent--;
@@ -840,16 +842,16 @@ static void FoldAU3Doc(unsigned int startPos, int length, int, WordList *[], Acc
 				// Start of a comment block
 				if (!(stylePrev==style) && IsStreamCommentStyle(styleNext) && styleNext==style) {
 				    levelNext++;
-				} 
+				}
 				// fold till the last line for normal comment lines
-				else if (IsStreamCommentStyle(stylePrev) 
+				else if (IsStreamCommentStyle(stylePrev)
 						&& !(styleNext == SCE_AU3_COMMENT)
-						&& stylePrev == SCE_AU3_COMMENT 
+						&& stylePrev == SCE_AU3_COMMENT
 						&& style == SCE_AU3_COMMENT) {
 					levelNext--;
 				}
 				// fold till the one but last line for Blockcomment lines
-				else if (IsStreamCommentStyle(stylePrev) 
+				else if (IsStreamCommentStyle(stylePrev)
 						&& !(styleNext == SCE_AU3_COMMENTBLOCK)
 						&& style == SCE_AU3_COMMENTBLOCK) {
 					levelNext--;
diff --git a/Pythonwin/Scintilla/src/LexAVE.cxx b/Pythonwin/Scintilla/lexers/LexAVE.cxx
similarity index 91%
rename from Pythonwin/Scintilla/src/LexAVE.cxx
rename to Pythonwin/Scintilla/lexers/LexAVE.cxx
index 2b7029b1a..b976734ae 100644
--- a/Pythonwin/Scintilla/src/LexAVE.cxx
+++ b/Pythonwin/Scintilla/lexers/LexAVE.cxx
@@ -9,22 +9,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
-#include <stdarg.h>
 #include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 
 static inline bool IsAWordChar(const int ch) {
@@ -42,7 +43,7 @@ inline bool IsAWordStart(const int ch) {
 }
 
 inline bool isAveOperator(char ch) {
-	if (isalnum(ch))
+	if (IsASCII(ch) && isalnum(ch))
 		return false;
 	// '.' left out as it is used to make up numbers
 	if (ch == '*' || ch == '/' || ch == '-' || ch == '+' ||
@@ -56,8 +57,8 @@ inline bool isAveOperator(char ch) {
 }
 
 static void ColouriseAveDoc(
-	unsigned int startPos,
-	int length,
+	Sci_PositionU startPos,
+	Sci_Position length,
 	int initStyle,
 	WordList *keywordlists[],
 	Accessor &styler) {
@@ -79,7 +80,7 @@ static void ColouriseAveDoc(
 	for (; sc.More(); sc.Forward()) {
 		if (sc.atLineEnd) {
 			// Update the line state, so it can be seen by next line
-			int currentLine = styler.GetLine(sc.currentPos);
+			Sci_Position currentLine = styler.GetLine(sc.currentPos);
 			styler.SetLineState(currentLine, 0);
 		}
 		if (sc.atLineStart && (sc.state == SCE_AVE_STRING)) {
@@ -154,19 +155,19 @@ static void ColouriseAveDoc(
 	sc.Complete();
 }
 
-static void FoldAveDoc(unsigned int startPos, int length, int /* initStyle */, WordList *[],
+static void FoldAveDoc(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, WordList *[],
                        Accessor &styler) {
-	unsigned int lengthDoc = startPos + length;
+	Sci_PositionU lengthDoc = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	char chNext = static_cast<char>(tolower(styler[startPos]));
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
 	int styleNext = styler.StyleAt(startPos);
-	char s[10];
+	char s[10] = "";
 
-	for (unsigned int i = startPos; i < lengthDoc; i++) {
+	for (Sci_PositionU i = startPos; i < lengthDoc; i++) {
 		char ch = static_cast<char>(tolower(chNext));
 		chNext = static_cast<char>(tolower(styler.SafeGetCharAt(i + 1)));
 		int style = styleNext;
diff --git a/Pythonwin/Scintilla/lexers/LexAVS.cxx b/Pythonwin/Scintilla/lexers/LexAVS.cxx
new file mode 100644
index 000000000..df5223f8d
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexAVS.cxx
@@ -0,0 +1,291 @@
+// Scintilla source code edit control
+/** @file LexAVS.cxx
+ ** Lexer for AviSynth.
+ **/
+// Copyright 2012 by Bruno Barbieri <brunorex@gmail.com>
+// Heavily based on LexPOV by Neil Hodgson
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static inline bool IsAWordChar(const int ch) {
+	return (ch < 0x80) && (isalnum(ch) || ch == '_');
+}
+
+static inline bool IsAWordStart(int ch) {
+	return isalpha(ch) || (ch != ' ' && ch != '\n' && ch != '(' && ch != '.' && ch != ',');
+}
+
+static inline bool IsANumberChar(int ch) {
+	// Not exactly following number definition (several dots are seen as OK, etc.)
+	// but probably enough in most cases.
+	return (ch < 0x80) &&
+			(isdigit(ch) || ch == '.' || ch == '-' || ch == '+');
+}
+
+static void ColouriseAvsDoc(
+	Sci_PositionU startPos,
+	Sci_Position length,
+	int initStyle,
+	WordList *keywordlists[],
+	Accessor &styler) {
+
+	WordList &keywords = *keywordlists[0];
+	WordList &filters = *keywordlists[1];
+	WordList &plugins = *keywordlists[2];
+	WordList &functions = *keywordlists[3];
+	WordList &clipProperties = *keywordlists[4];
+	WordList &userDefined = *keywordlists[5];
+
+	Sci_Position currentLine = styler.GetLine(startPos);
+	// Initialize the block comment nesting level, if we are inside such a comment.
+	int blockCommentLevel = 0;
+	if (initStyle == SCE_AVS_COMMENTBLOCK || initStyle == SCE_AVS_COMMENTBLOCKN) {
+		blockCommentLevel = styler.GetLineState(currentLine - 1);
+	}
+
+	// Do not leak onto next line
+	if (initStyle == SCE_AVS_COMMENTLINE) {
+		initStyle = SCE_AVS_DEFAULT;
+	}
+
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	for (; sc.More(); sc.Forward()) {
+		if (sc.atLineEnd) {
+			// Update the line state, so it can be seen by next line
+			currentLine = styler.GetLine(sc.currentPos);
+			if (sc.state == SCE_AVS_COMMENTBLOCK || sc.state == SCE_AVS_COMMENTBLOCKN) {
+				// Inside a block comment, we set the line state
+				styler.SetLineState(currentLine, blockCommentLevel);
+			} else {
+				// Reset the line state
+				styler.SetLineState(currentLine, 0);
+			}
+		}
+
+		// Determine if the current state should terminate.
+		if (sc.state == SCE_AVS_OPERATOR) {
+			sc.SetState(SCE_AVS_DEFAULT);
+		} else if (sc.state == SCE_AVS_NUMBER) {
+			// We stop the number definition on non-numerical non-dot non-sign char
+			if (!IsANumberChar(sc.ch)) {
+				sc.SetState(SCE_AVS_DEFAULT);
+			}
+		} else if (sc.state == SCE_AVS_IDENTIFIER) {
+			if (!IsAWordChar(sc.ch)) {
+				char s[100];
+				sc.GetCurrentLowered(s, sizeof(s));
+
+				if (keywords.InList(s)) {
+					sc.ChangeState(SCE_AVS_KEYWORD);
+				} else if (filters.InList(s)) {
+					sc.ChangeState(SCE_AVS_FILTER);
+				} else if (plugins.InList(s)) {
+					sc.ChangeState(SCE_AVS_PLUGIN);
+				} else if (functions.InList(s)) {
+					sc.ChangeState(SCE_AVS_FUNCTION);
+				} else if (clipProperties.InList(s)) {
+					sc.ChangeState(SCE_AVS_CLIPPROP);
+				} else if (userDefined.InList(s)) {
+					sc.ChangeState(SCE_AVS_USERDFN);
+				}
+				sc.SetState(SCE_AVS_DEFAULT);
+			}
+		} else if (sc.state == SCE_AVS_COMMENTBLOCK) {
+			if (sc.Match('/', '*')) {
+				blockCommentLevel++;
+				sc.Forward();
+			} else if (sc.Match('*', '/') && blockCommentLevel > 0) {
+				blockCommentLevel--;
+				sc.Forward();
+				if (blockCommentLevel == 0) {
+					sc.ForwardSetState(SCE_AVS_DEFAULT);
+				}
+			}
+		} else if (sc.state == SCE_AVS_COMMENTBLOCKN) {
+			if (sc.Match('[', '*')) {
+				blockCommentLevel++;
+				sc.Forward();
+			} else if (sc.Match('*', ']') && blockCommentLevel > 0) {
+				blockCommentLevel--;
+				sc.Forward();
+				if (blockCommentLevel == 0) {
+					sc.ForwardSetState(SCE_AVS_DEFAULT);
+				}
+			}
+		} else if (sc.state == SCE_AVS_COMMENTLINE) {
+			if (sc.atLineEnd) {
+				sc.ForwardSetState(SCE_AVS_DEFAULT);
+			}
+		} else if (sc.state == SCE_AVS_STRING) {
+			if (sc.ch == '\"') {
+				sc.ForwardSetState(SCE_AVS_DEFAULT);
+			}
+		} else if (sc.state == SCE_AVS_TRIPLESTRING) {
+			if (sc.Match("\"\"\"")) {
+				sc.Forward();
+				sc.Forward();
+				sc.ForwardSetState(SCE_AVS_DEFAULT);
+			}
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_AVS_DEFAULT) {
+			if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
+				sc.SetState(SCE_AVS_NUMBER);
+			} else 	if (IsADigit(sc.ch) || (sc.ch == ',' && IsADigit(sc.chNext))) {
+				sc.Forward();
+				sc.SetState(SCE_AVS_NUMBER);
+			} else if (sc.Match('/', '*')) {
+				blockCommentLevel = 1;
+				sc.SetState(SCE_AVS_COMMENTBLOCK);
+				sc.Forward();	// Eat the * so it isn't used for the end of the comment
+			} else if (sc.Match('[', '*')) {
+				blockCommentLevel = 1;
+				sc.SetState(SCE_AVS_COMMENTBLOCKN);
+				sc.Forward();	// Eat the * so it isn't used for the end of the comment
+			} else if (sc.ch == '#') {
+				sc.SetState(SCE_AVS_COMMENTLINE);
+			} else if (sc.ch == '\"') {
+				if (sc.Match("\"\"\"")) {
+					sc.SetState(SCE_AVS_TRIPLESTRING);
+				} else {
+					sc.SetState(SCE_AVS_STRING);
+				}
+			} else if (isoperator(static_cast<char>(sc.ch))) {
+				sc.SetState(SCE_AVS_OPERATOR);
+			} else if (IsAWordStart(sc.ch)) {
+				sc.SetState(SCE_AVS_IDENTIFIER);
+			}
+		}
+	}
+
+	// End of file: complete any pending changeState
+	if (sc.state == SCE_AVS_IDENTIFIER) {
+		if (!IsAWordChar(sc.ch)) {
+			char s[100];
+			sc.GetCurrentLowered(s, sizeof(s));
+
+			if (keywords.InList(s)) {
+				sc.ChangeState(SCE_AVS_KEYWORD);
+			} else if (filters.InList(s)) {
+				sc.ChangeState(SCE_AVS_FILTER);
+			} else if (plugins.InList(s)) {
+				sc.ChangeState(SCE_AVS_PLUGIN);
+			} else if (functions.InList(s)) {
+				sc.ChangeState(SCE_AVS_FUNCTION);
+			} else if (clipProperties.InList(s)) {
+				sc.ChangeState(SCE_AVS_CLIPPROP);
+			} else if (userDefined.InList(s)) {
+				sc.ChangeState(SCE_AVS_USERDFN);
+			}
+			sc.SetState(SCE_AVS_DEFAULT);
+		}
+	}
+
+	sc.Complete();
+}
+
+static void FoldAvsDoc(
+	Sci_PositionU startPos,
+	Sci_Position length,
+	int initStyle,
+	WordList *[],
+	Accessor &styler) {
+
+	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
+	int levelCurrent = levelPrev;
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int stylePrev = style;
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+		if (foldComment && style == SCE_AVS_COMMENTBLOCK) {
+			if (stylePrev != SCE_AVS_COMMENTBLOCK) {
+				levelCurrent++;
+			} else if ((styleNext != SCE_AVS_COMMENTBLOCK) && !atEOL) {
+				// Comments don't end at end of line and the next character may be unstyled.
+				levelCurrent--;
+			}
+		}
+
+		if (foldComment && style == SCE_AVS_COMMENTBLOCKN) {
+			if (stylePrev != SCE_AVS_COMMENTBLOCKN) {
+				levelCurrent++;
+			} else if ((styleNext != SCE_AVS_COMMENTBLOCKN) && !atEOL) {
+				// Comments don't end at end of line and the next character may be unstyled.
+				levelCurrent--;
+			}
+		}
+
+		if (style == SCE_AVS_OPERATOR) {
+			if (ch == '{') {
+				levelCurrent++;
+			} else if (ch == '}') {
+				levelCurrent--;
+			}
+		}
+
+		if (atEOL) {
+			int lev = levelPrev;
+			if (visibleChars == 0 && foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if ((levelCurrent > levelPrev) && (visibleChars > 0))
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			levelPrev = levelCurrent;
+			visibleChars = 0;
+		}
+
+		if (!isspacechar(ch))
+			visibleChars++;
+	}
+	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
+	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
+	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
+}
+
+static const char * const avsWordLists[] = {
+	"Keywords",
+	"Filters",
+	"Plugins",
+	"Functions",
+	"Clip properties",
+	"User defined functions",
+	0,
+};
+
+LexerModule lmAVS(SCLEX_AVS, ColouriseAvsDoc, "avs", FoldAvsDoc, avsWordLists);
diff --git a/Pythonwin/Scintilla/src/LexAbaqus.cxx b/Pythonwin/Scintilla/lexers/LexAbaqus.cxx
similarity index 89%
rename from Pythonwin/Scintilla/src/LexAbaqus.cxx
rename to Pythonwin/Scintilla/lexers/LexAbaqus.cxx
index 10e8b76b1..0b9bfb62a 100644
--- a/Pythonwin/Scintilla/src/LexAbaqus.cxx
+++ b/Pythonwin/Scintilla/lexers/LexAbaqus.cxx
@@ -1,5 +1,5 @@
 // Scintilla source code edit control
-/** @file LexABAQUS.cxx
+/** @file LexAbaqus.cxx
  ** Lexer for ABAQUS. Based on the lexer for APDL by Hadar Raz.
  ** By Sergio Lucato.
  ** Sort of completely rewritten by Gertjan Kloosterman
@@ -10,26 +10,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
-
-static inline bool IsAWordChar(const int ch) {
-	return (ch < 0x80 && (isalnum(ch) || (ch == '_')));
-}
 
 static inline bool IsAKeywordChar(const int ch) {
 	return (ch < 0x80 && (isalnum(ch) || (ch == '_') || (ch == ' ')));
@@ -39,18 +36,7 @@ static inline bool IsASetChar(const int ch) {
 	return (ch < 0x80 && (isalnum(ch) || (ch == '_') || (ch == '.') || (ch == '-')));
 }
 
-static inline bool IsAnOperator(char ch) {
-	// '.' left out as it is used to make up numbers
-	if (ch == '*' || ch == '/' || ch == '-' || ch == '+' ||
-		ch == '(' || ch == ')' || ch == '=' || ch == '^' ||
-		ch == '[' || ch == ']' || ch == '<' || ch == '&' ||
-		ch == '>' || ch == ',' || ch == '|' || ch == '~' ||
-		ch == '$' || ch == ':' || ch == '%')
-		return true;
-	return false;
-}
-
-static void ColouriseABAQUSDoc(unsigned int startPos, int length, int initStyle, WordList*[] /* *keywordlists[] */,
+static void ColouriseABAQUSDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList*[] /* *keywordlists[] */,
                             Accessor &styler) {
 	enum localState { KW_LINE_KW, KW_LINE_COMMA, KW_LINE_PAR, KW_LINE_EQ, KW_LINE_VAL, \
 					  DAT_LINE_VAL, DAT_LINE_COMMA,\
@@ -313,10 +299,10 @@ static int LowerCase(int c)
 	return c;
 }
 
-static int LineEnd(int line, Accessor &styler)
+static Sci_Position LineEnd(Sci_Position line, Accessor &styler)
 {
-    const int docLines = styler.GetLine(styler.Length() - 1);  // Available last line
-    int eol_pos ;
+    const Sci_Position docLines = styler.GetLine(styler.Length() - 1);  // Available last line
+    Sci_Position eol_pos ;
     // if the line is the last line, the eol_pos is styler.Length()
     // eol will contain a new line, or a virtual new line
     if ( docLines == line )
@@ -326,7 +312,7 @@ static int LineEnd(int line, Accessor &styler)
     return eol_pos ;
 }
 
-static int LineStart(int line, Accessor &styler)
+static Sci_Position LineStart(Sci_Position line, Accessor &styler)
 {
     return styler.LineStart(line) ;
 }
@@ -342,14 +328,14 @@ static int LineStart(int line, Accessor &styler)
 // 6  : block close keyword line
 // 7  : keyword line in error
 // 8  : comment line
-static int LineType(int line, Accessor &styler) {
-    int pos = LineStart(line, styler) ;
-    int eol_pos = LineEnd(line, styler) ;
+static int LineType(Sci_Position line, Accessor &styler) {
+    Sci_Position pos = LineStart(line, styler) ;
+    Sci_Position eol_pos = LineEnd(line, styler) ;
 
     int c ;
     char ch = ' ';
 
-    int i = pos ;
+    Sci_Position i = pos ;
     while ( i < eol_pos ) {
         c = styler.SafeGetCharAt(i);
         ch = static_cast<char>(LowerCase(c));
@@ -430,7 +416,7 @@ static int LineType(int line, Accessor &styler) {
     return 4 ;
 }
 
-static void SafeSetLevel(int line, int level, Accessor &styler)
+static void SafeSetLevel(Sci_Position line, int level, Accessor &styler)
 {
     if ( line < 0 )
         return ;
@@ -444,20 +430,20 @@ static void SafeSetLevel(int line, int level, Accessor &styler)
         styler.SetLevel(line, level) ;
 }
 
-static void FoldABAQUSDoc(unsigned int startPos, int length, int,
+static void FoldABAQUSDoc(Sci_PositionU startPos, Sci_Position length, int,
 WordList *[], Accessor &styler) {
-    int startLine = styler.GetLine(startPos) ;
-    int endLine   = styler.GetLine(startPos+length-1) ;
+    Sci_Position startLine = styler.GetLine(startPos) ;
+    Sci_Position endLine   = styler.GetLine(startPos+length-1) ;
 
     // bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
     // We want to deal with all the cases
     // To know the correct indentlevel, we need to look back to the
     // previous command line indentation level
 	// order of formatting keyline datalines commentlines
-    int beginData    = -1 ;
-    int beginComment = -1 ;
-    int prvKeyLine   = startLine ;
-    int prvKeyLineTp =  0 ;
+    Sci_Position beginData    = -1 ;
+    Sci_Position beginComment = -1 ;
+    Sci_Position prvKeyLine   = startLine ;
+    Sci_Position prvKeyLineTp =  0 ;
 
     // Scan until we find the previous keyword line
     // this will give us the level reference that we need
@@ -479,7 +465,7 @@ WordList *[], Accessor &styler) {
     prvKeyLine = -1 ;
 
     // Now start scanning over the lines.
-    for ( int line = startLine; line <= endLine; line++ ) {
+    for ( Sci_Position line = startLine; line <= endLine; line++ ) {
         int lineType = LineType(line, styler) ;
 
         // Check for comment line
@@ -528,7 +514,7 @@ WordList *[], Accessor &styler) {
 				datLevel = level ;
 			}
 
-            for ( int ll = beginData; ll < beginComment; ll++ )
+            for ( Sci_Position ll = beginData; ll < beginComment; ll++ )
                 SafeSetLevel(ll, datLevel, styler) ;
 
             // The keyword we just found is going to be written at another level
@@ -544,7 +530,7 @@ WordList *[], Accessor &styler) {
 				}
             }
 
-            for ( int lll = beginComment; lll < line; lll++ )
+            for ( Sci_Position lll = beginComment; lll < line; lll++ )
                 SafeSetLevel(lll, level, styler) ;
 
             // wrap and reset
@@ -561,10 +547,10 @@ WordList *[], Accessor &styler) {
     } else {
         // We need to find out whether this comment block is followed by
         // a data line or a keyword line
-        const int docLines = styler.GetLine(styler.Length() - 1);
+        const Sci_Position docLines = styler.GetLine(styler.Length() - 1);
 
-        for ( int line = endLine + 1; line <= docLines; line++ ) {
-            int lineType = LineType(line, styler) ;
+        for ( Sci_Position line = endLine + 1; line <= docLines; line++ ) {
+            Sci_Position lineType = LineType(line, styler) ;
 
             if ( lineType != 8 ) {
 				if ( !(lineType & 4) )  {
@@ -590,17 +576,17 @@ WordList *[], Accessor &styler) {
 		datLevel = level ;
 	}
 
-    for ( int ll = beginData; ll < beginComment; ll++ )
+    for ( Sci_Position ll = beginData; ll < beginComment; ll++ )
         SafeSetLevel(ll, datLevel, styler) ;
 
-	if ( prvKeyLineTp == 5 ) {
-		level += 1 ;
-	}
+    if ( prvKeyLineTp == 5 ) {
+        level += 1 ;
+    }
 
-	if ( prvKeyLineTp == 6 ) {
-		level -= 1 ;
-	}
-	for ( int m = beginComment; m <= endLine; m++ )
+    if ( prvKeyLineTp == 6 ) {
+        level -= 1 ;
+    }
+    for ( Sci_Position m = beginComment; m <= endLine; m++ )
         SafeSetLevel(m, level, styler) ;
 }
 
diff --git a/Pythonwin/Scintilla/src/LexAda.cxx b/Pythonwin/Scintilla/lexers/LexAda.cxx
similarity index 91%
rename from Pythonwin/Scintilla/src/LexAda.cxx
rename to Pythonwin/Scintilla/lexers/LexAda.cxx
index f6c9e7ee7..9d7f5d0f7 100644
--- a/Pythonwin/Scintilla/src/LexAda.cxx
+++ b/Pythonwin/Scintilla/lexers/LexAda.cxx
@@ -6,30 +6,34 @@
 // The License.txt file describes the conditions under which this software may be distributed.
 
 #include <stdlib.h>
-#include <ctype.h>
 #include <string.h>
 #include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include <string>
 
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "PropSet.h"
-#include "KeyWords.h"
-#include "SciLexer.h"
-#include "SString.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 /*
  * Interface
  */
 
 static void ColouriseDocument(
-    unsigned int startPos,
-    int length,
+    Sci_PositionU startPos,
+    Sci_Position length,
     int initStyle,
     WordList *keywordlists[],
     Accessor &styler);
@@ -59,11 +63,9 @@ static void ColouriseWhiteSpace(StyleContext& sc, bool& apostropheStartsAttribut
 static void ColouriseWord(StyleContext& sc, WordList& keywords, bool& apostropheStartsAttribute);
 
 static inline bool IsDelimiterCharacter(int ch);
-static inline bool IsNumberStartCharacter(int ch);
-static inline bool IsNumberCharacter(int ch);
 static inline bool IsSeparatorOrDelimiterCharacter(int ch);
-static bool IsValidIdentifier(const SString& identifier);
-static bool IsValidNumber(const SString& number);
+static bool IsValidIdentifier(const std::string& identifier);
+static bool IsValidNumber(const std::string& number);
 static inline bool IsWordStartCharacter(int ch);
 static inline bool IsWordCharacter(int ch);
 
@@ -117,7 +119,7 @@ static void ColouriseLabel(StyleContext& sc, WordList& keywords, bool& apostroph
 	sc.Forward();
 	sc.Forward();
 
-	SString identifier;
+	std::string identifier;
 
 	while (!sc.atLineEnd && !IsSeparatorOrDelimiterCharacter(sc.ch)) {
 		identifier += static_cast<char>(tolower(sc.ch));
@@ -144,7 +146,7 @@ static void ColouriseLabel(StyleContext& sc, WordList& keywords, bool& apostroph
 static void ColouriseNumber(StyleContext& sc, bool& apostropheStartsAttribute) {
 	apostropheStartsAttribute = true;
 
-	SString number;
+	std::string number;
 	sc.SetState(SCE_ADA_NUMBER);
 
 	// Get all characters up to a delimiter or a separator, including points, but excluding
@@ -192,7 +194,7 @@ static void ColouriseWord(StyleContext& sc, WordList& keywords, bool& apostrophe
 	apostropheStartsAttribute = true;
 	sc.SetState(SCE_ADA_IDENTIFIER);
 
-	SString word;
+	std::string word;
 
 	while (!sc.atLineEnd && !IsSeparatorOrDelimiterCharacter(sc.ch)) {
 		word += static_cast<char>(tolower(sc.ch));
@@ -218,8 +220,8 @@ static void ColouriseWord(StyleContext& sc, WordList& keywords, bool& apostrophe
 //
 
 static void ColouriseDocument(
-    unsigned int startPos,
-    int length,
+    Sci_PositionU startPos,
+    Sci_Position length,
     int initStyle,
     WordList *keywordlists[],
     Accessor &styler) {
@@ -227,7 +229,7 @@ static void ColouriseDocument(
 
 	StyleContext sc(startPos, length, initStyle, styler);
 
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	bool apostropheStartsAttribute = (styler.GetLineState(lineCurrent) & 1) != 0;
 
 	while (sc.More()) {
@@ -304,24 +306,11 @@ static inline bool IsDelimiterCharacter(int ch) {
 	}
 }
 
-static inline bool IsNumberCharacter(int ch) {
-	return IsNumberStartCharacter(ch) ||
-	       ch == '_' ||
-	       ch == '.' ||
-	       ch == '#' ||
-	       (ch >= 'a' && ch <= 'f') ||
-	       (ch >= 'A' && ch <= 'F');
-}
-
-static inline bool IsNumberStartCharacter(int ch) {
-	return IsADigit(ch);
-}
-
 static inline bool IsSeparatorOrDelimiterCharacter(int ch) {
 	return IsASpace(ch) || IsDelimiterCharacter(ch);
 }
 
-static bool IsValidIdentifier(const SString& identifier) {
+static bool IsValidIdentifier(const std::string& identifier) {
 	// First character can't be '_', so initialize the flag to true
 	bool lastWasUnderscore = true;
 
@@ -355,8 +344,8 @@ static bool IsValidIdentifier(const SString& identifier) {
 	return true;
 }
 
-static bool IsValidNumber(const SString& number) {
-	int hashPos = number.search("#");
+static bool IsValidNumber(const std::string& number) {
+	size_t hashPos = number.find("#");
 	bool seenDot = false;
 
 	size_t i = 0;
@@ -366,7 +355,7 @@ static bool IsValidNumber(const SString& number) {
 		return false; // Just in case
 
 	// Decimal number
-	if (hashPos == -1) {
+	if (hashPos == std::string::npos) {
 		bool canBeSpecial = false;
 
 		for (; i < length; i++) {
@@ -520,5 +509,5 @@ static inline bool IsWordCharacter(int ch) {
 }
 
 static inline bool IsWordStartCharacter(int ch) {
-	return (isascii(ch) && isalpha(ch)) || ch == '_';
+	return (IsASCII(ch) && isalpha(ch)) || ch == '_';
 }
diff --git a/Pythonwin/Scintilla/lexers/LexAsm.cxx b/Pythonwin/Scintilla/lexers/LexAsm.cxx
new file mode 100644
index 000000000..4560f9751
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexAsm.cxx
@@ -0,0 +1,477 @@
+// Scintilla source code edit control
+/** @file LexAsm.cxx
+ ** Lexer for Assembler, just for the MASM syntax
+ ** Written by The Black Horus
+ ** Enhancements and NASM stuff by Kein-Hong Man, 2003-10
+ ** SCE_ASM_COMMENTBLOCK and SCE_ASM_CHARACTER are for future GNU as colouring
+ ** Converted to lexer object and added further folding features/properties by "Udo Lechner" <dlchnr(at)gmx(dot)net>
+ **/
+// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+#include <map>
+#include <set>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+static inline bool IsAWordChar(const int ch) {
+	return (ch < 0x80) && (isalnum(ch) || ch == '.' ||
+		ch == '_' || ch == '?');
+}
+
+static inline bool IsAWordStart(const int ch) {
+	return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.' ||
+		ch == '%' || ch == '@' || ch == '$' || ch == '?');
+}
+
+static inline bool IsAsmOperator(const int ch) {
+	if ((ch < 0x80) && (isalnum(ch)))
+		return false;
+	// '.' left out as it is used to make up numbers
+	if (ch == '*' || ch == '/' || ch == '-' || ch == '+' ||
+		ch == '(' || ch == ')' || ch == '=' || ch == '^' ||
+		ch == '[' || ch == ']' || ch == '<' || ch == '&' ||
+		ch == '>' || ch == ',' || ch == '|' || ch == '~' ||
+		ch == '%' || ch == ':')
+		return true;
+	return false;
+}
+
+static bool IsStreamCommentStyle(int style) {
+	return style == SCE_ASM_COMMENTDIRECTIVE || style == SCE_ASM_COMMENTBLOCK;
+}
+
+static inline int LowerCase(int c) {
+	if (c >= 'A' && c <= 'Z')
+		return 'a' + c - 'A';
+	return c;
+}
+
+// An individual named option for use in an OptionSet
+
+// Options used for LexerAsm
+struct OptionsAsm {
+	std::string delimiter;
+	bool fold;
+	bool foldSyntaxBased;
+	bool foldCommentMultiline;
+	bool foldCommentExplicit;
+	std::string foldExplicitStart;
+	std::string foldExplicitEnd;
+	bool foldExplicitAnywhere;
+	bool foldCompact;
+	std::string commentChar;
+	OptionsAsm() {
+		delimiter = "";
+		fold = false;
+		foldSyntaxBased = true;
+		foldCommentMultiline = false;
+		foldCommentExplicit = false;
+		foldExplicitStart = "";
+		foldExplicitEnd   = "";
+		foldExplicitAnywhere = false;
+		foldCompact = true;
+		commentChar = "";
+	}
+};
+
+static const char * const asmWordListDesc[] = {
+	"CPU instructions",
+	"FPU instructions",
+	"Registers",
+	"Directives",
+	"Directive operands",
+	"Extended instructions",
+	"Directives4Foldstart",
+	"Directives4Foldend",
+	0
+};
+
+struct OptionSetAsm : public OptionSet<OptionsAsm> {
+	OptionSetAsm() {
+		DefineProperty("lexer.asm.comment.delimiter", &OptionsAsm::delimiter,
+			"Character used for COMMENT directive's delimiter, replacing the standard \"~\".");
+
+		DefineProperty("fold", &OptionsAsm::fold);
+
+		DefineProperty("fold.asm.syntax.based", &OptionsAsm::foldSyntaxBased,
+			"Set this property to 0 to disable syntax based folding.");
+
+		DefineProperty("fold.asm.comment.multiline", &OptionsAsm::foldCommentMultiline,
+			"Set this property to 1 to enable folding multi-line comments.");
+
+		DefineProperty("fold.asm.comment.explicit", &OptionsAsm::foldCommentExplicit,
+			"This option enables folding explicit fold points when using the Asm lexer. "
+			"Explicit fold points allows adding extra folding by placing a ;{ comment at the start and a ;} "
+			"at the end of a section that should fold.");
+
+		DefineProperty("fold.asm.explicit.start", &OptionsAsm::foldExplicitStart,
+			"The string to use for explicit fold start points, replacing the standard ;{.");
+
+		DefineProperty("fold.asm.explicit.end", &OptionsAsm::foldExplicitEnd,
+			"The string to use for explicit fold end points, replacing the standard ;}.");
+
+		DefineProperty("fold.asm.explicit.anywhere", &OptionsAsm::foldExplicitAnywhere,
+			"Set this property to 1 to enable explicit fold points anywhere, not just in line comments.");
+
+		DefineProperty("fold.compact", &OptionsAsm::foldCompact);
+
+		DefineProperty("lexer.as.comment.character", &OptionsAsm::commentChar,
+			"Overrides the default comment character (which is ';' for asm and '#' for as).");
+
+		DefineWordListSets(asmWordListDesc);
+	}
+};
+
+class LexerAsm : public DefaultLexer {
+	WordList cpuInstruction;
+	WordList mathInstruction;
+	WordList registers;
+	WordList directive;
+	WordList directiveOperand;
+	WordList extInstruction;
+	WordList directives4foldstart;
+	WordList directives4foldend;
+	OptionsAsm options;
+	OptionSetAsm osAsm;
+	int commentChar;
+public:
+	LexerAsm(const char *languageName_, int language_, int commentChar_) : DefaultLexer(languageName_, language_) {
+		commentChar = commentChar_;
+	}
+	virtual ~LexerAsm() {
+	}
+	void SCI_METHOD Release() override {
+		delete this;
+	}
+	int SCI_METHOD Version() const override {
+		return lvRelease5;
+	}
+	const char * SCI_METHOD PropertyNames() override {
+		return osAsm.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return osAsm.PropertyType(name);
+	}
+	const char * SCI_METHOD DescribeProperty(const char *name) override {
+		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();
+	}
+	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 *) override {
+		return 0;
+	}
+
+	static ILexer5 *LexerFactoryAsm() {
+		return new LexerAsm("asm", SCLEX_ASM, ';');
+	}
+
+	static ILexer5 *LexerFactoryAs() {
+		return new LexerAsm("as", SCLEX_AS, '#');
+	}
+};
+
+Sci_Position SCI_METHOD LexerAsm::PropertySet(const char *key, const char *val) {
+	if (osAsm.PropertySet(&options, key, val)) {
+		return 0;
+	}
+	return -1;
+}
+
+Sci_Position SCI_METHOD LexerAsm::WordListSet(int n, const char *wl) {
+	WordList *wordListN = 0;
+	switch (n) {
+	case 0:
+		wordListN = &cpuInstruction;
+		break;
+	case 1:
+		wordListN = &mathInstruction;
+		break;
+	case 2:
+		wordListN = &registers;
+		break;
+	case 3:
+		wordListN = &directive;
+		break;
+	case 4:
+		wordListN = &directiveOperand;
+		break;
+	case 5:
+		wordListN = &extInstruction;
+		break;
+	case 6:
+		wordListN = &directives4foldstart;
+		break;
+	case 7:
+		wordListN = &directives4foldend;
+		break;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN) {
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+		}
+	}
+	return firstModification;
+}
+
+void SCI_METHOD LexerAsm::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	LexAccessor styler(pAccess);
+
+	const char commentCharacter = options.commentChar.empty() ?
+		commentChar : options.commentChar.front();
+
+	// Do not leak onto next line
+	if (initStyle == SCE_ASM_STRINGEOL)
+		initStyle = SCE_ASM_DEFAULT;
+
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	for (; sc.More(); sc.Forward())
+	{
+
+		// Prevent SCE_ASM_STRINGEOL from leaking back to previous line
+		if (sc.atLineStart && (sc.state == SCE_ASM_STRING)) {
+			sc.SetState(SCE_ASM_STRING);
+		} else if (sc.atLineStart && (sc.state == SCE_ASM_CHARACTER)) {
+			sc.SetState(SCE_ASM_CHARACTER);
+		}
+
+		// Handle line continuation generically.
+		if (sc.ch == '\\') {
+			if (sc.chNext == '\n' || sc.chNext == '\r') {
+				sc.Forward();
+				if (sc.ch == '\r' && sc.chNext == '\n') {
+					sc.Forward();
+				}
+				continue;
+			}
+		}
+
+		// Determine if the current state should terminate.
+		if (sc.state == SCE_ASM_OPERATOR) {
+			if (!IsAsmOperator(sc.ch)) {
+			    sc.SetState(SCE_ASM_DEFAULT);
+			}
+		} else if (sc.state == SCE_ASM_NUMBER) {
+			if (!IsAWordChar(sc.ch)) {
+				sc.SetState(SCE_ASM_DEFAULT);
+			}
+		} else if (sc.state == SCE_ASM_IDENTIFIER) {
+			if (!IsAWordChar(sc.ch) ) {
+				char s[100];
+				sc.GetCurrentLowered(s, sizeof(s));
+				bool IsDirective = false;
+
+				if (cpuInstruction.InList(s)) {
+					sc.ChangeState(SCE_ASM_CPUINSTRUCTION);
+				} else if (mathInstruction.InList(s)) {
+					sc.ChangeState(SCE_ASM_MATHINSTRUCTION);
+				} else if (registers.InList(s)) {
+					sc.ChangeState(SCE_ASM_REGISTER);
+				}  else if (directive.InList(s)) {
+					sc.ChangeState(SCE_ASM_DIRECTIVE);
+					IsDirective = true;
+				} else if (directiveOperand.InList(s)) {
+					sc.ChangeState(SCE_ASM_DIRECTIVEOPERAND);
+				} else if (extInstruction.InList(s)) {
+					sc.ChangeState(SCE_ASM_EXTINSTRUCTION);
+				}
+				sc.SetState(SCE_ASM_DEFAULT);
+				if (IsDirective && !strcmp(s, "comment")) {
+					char delimiter = options.delimiter.empty() ? '~' : options.delimiter.c_str()[0];
+					while (IsASpaceOrTab(sc.ch) && !sc.atLineEnd) {
+						sc.ForwardSetState(SCE_ASM_DEFAULT);
+					}
+					if (sc.ch == delimiter) {
+						sc.SetState(SCE_ASM_COMMENTDIRECTIVE);
+					}
+				}
+			}
+		} else if (sc.state == SCE_ASM_COMMENTDIRECTIVE) {
+			char delimiter = options.delimiter.empty() ? '~' : options.delimiter.c_str()[0];
+			if (sc.ch == delimiter) {
+				while (!sc.atLineEnd) {
+					sc.Forward();
+				}
+				sc.SetState(SCE_ASM_DEFAULT);
+			}
+		} else if (sc.state == SCE_ASM_COMMENT ) {
+			if (sc.atLineEnd) {
+				sc.SetState(SCE_ASM_DEFAULT);
+			}
+		} else if (sc.state == SCE_ASM_STRING) {
+			if (sc.ch == '\\') {
+				if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+					sc.Forward();
+				}
+			} else if (sc.ch == '\"') {
+				sc.ForwardSetState(SCE_ASM_DEFAULT);
+			} else if (sc.atLineEnd) {
+				sc.ChangeState(SCE_ASM_STRINGEOL);
+				sc.ForwardSetState(SCE_ASM_DEFAULT);
+			}
+		} else if (sc.state == SCE_ASM_CHARACTER) {
+			if (sc.ch == '\\') {
+				if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+					sc.Forward();
+				}
+			} else if (sc.ch == '\'') {
+				sc.ForwardSetState(SCE_ASM_DEFAULT);
+			} else if (sc.atLineEnd) {
+				sc.ChangeState(SCE_ASM_STRINGEOL);
+				sc.ForwardSetState(SCE_ASM_DEFAULT);
+			}
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_ASM_DEFAULT) {
+			if (sc.ch == commentCharacter) {
+				sc.SetState(SCE_ASM_COMMENT);
+			} else if (IsASCII(sc.ch) && (isdigit(sc.ch) || (sc.ch == '.' && IsASCII(sc.chNext) && isdigit(sc.chNext)))) {
+				sc.SetState(SCE_ASM_NUMBER);
+			} else if (IsAWordStart(sc.ch)) {
+				sc.SetState(SCE_ASM_IDENTIFIER);
+			} else if (sc.ch == '\"') {
+				sc.SetState(SCE_ASM_STRING);
+			} else if (sc.ch == '\'') {
+				sc.SetState(SCE_ASM_CHARACTER);
+			} else if (IsAsmOperator(sc.ch)) {
+				sc.SetState(SCE_ASM_OPERATOR);
+			}
+		}
+
+	}
+	sc.Complete();
+}
+
+// Store both the current line's fold level and the next lines in the
+// level store to make it easy to pick up with each increment
+// and to make it possible to fiddle the current level for "else".
+
+void SCI_METHOD LexerAsm::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+
+	if (!options.fold)
+		return;
+
+	LexAccessor styler(pAccess);
+
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelCurrent = SC_FOLDLEVELBASE;
+	if (lineCurrent > 0)
+		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
+	int levelNext = levelCurrent;
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+	char word[100];
+	int wordlen = 0;
+	const bool userDefinedFoldMarkers = !options.foldExplicitStart.empty() && !options.foldExplicitEnd.empty();
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int stylePrev = style;
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+		if (options.foldCommentMultiline && IsStreamCommentStyle(style)) {
+			if (!IsStreamCommentStyle(stylePrev)) {
+				levelNext++;
+			} else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
+				// Comments don't end at end of line and the next character may be unstyled.
+				levelNext--;
+			}
+		}
+		if (options.foldCommentExplicit && ((style == SCE_ASM_COMMENT) || options.foldExplicitAnywhere)) {
+			if (userDefinedFoldMarkers) {
+				if (styler.Match(i, options.foldExplicitStart.c_str())) {
+ 					levelNext++;
+				} else if (styler.Match(i, options.foldExplicitEnd.c_str())) {
+ 					levelNext--;
+ 				}
+			} else {
+				if (ch == ';') {
+					if (chNext == '{') {
+						levelNext++;
+					} else if (chNext == '}') {
+						levelNext--;
+					}
+				}
+ 			}
+ 		}
+		if (options.foldSyntaxBased && (style == SCE_ASM_DIRECTIVE)) {
+			word[wordlen++] = static_cast<char>(LowerCase(ch));
+			if (wordlen == 100) {                   // prevent overflow
+				word[0] = '\0';
+				wordlen = 1;
+			}
+			if (styleNext != SCE_ASM_DIRECTIVE) {   // reading directive ready
+				word[wordlen] = '\0';
+				wordlen = 0;
+				if (directives4foldstart.InList(word)) {
+					levelNext++;
+				} else if (directives4foldend.InList(word)){
+					levelNext--;
+				}
+			}
+		}
+		if (!IsASpace(ch))
+			visibleChars++;
+		if (atEOL || (i == endPos-1)) {
+			int levelUse = levelCurrent;
+			int lev = levelUse | levelNext << 16;
+			if (visibleChars == 0 && options.foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if (levelUse < levelNext)
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			levelCurrent = levelNext;
+			if (atEOL && (i == static_cast<Sci_PositionU>(styler.Length() - 1))) {
+				// There is an empty line at end of file so give it same level and empty
+				styler.SetLevel(lineCurrent, (levelCurrent | levelCurrent << 16) | SC_FOLDLEVELWHITEFLAG);
+			}
+			visibleChars = 0;
+		}
+	}
+}
+
+LexerModule lmAsm(SCLEX_ASM, LexerAsm::LexerFactoryAsm, "asm", asmWordListDesc);
+LexerModule lmAs(SCLEX_AS, LexerAsm::LexerFactoryAs, "as", asmWordListDesc);
+
diff --git a/Pythonwin/Scintilla/src/LexAsn1.cxx b/Pythonwin/Scintilla/lexers/LexAsn1.cxx
similarity index 91%
rename from Pythonwin/Scintilla/src/LexAsn1.cxx
rename to Pythonwin/Scintilla/lexers/LexAsn1.cxx
index 36f1d5dc2..0ec2a0636 100644
--- a/Pythonwin/Scintilla/src/LexAsn1.cxx
+++ b/Pythonwin/Scintilla/lexers/LexAsn1.cxx
@@ -5,24 +5,25 @@
 // Copyright 2004 by Herr Pfarrer rpfarrer <at> yahoo <dot> de
 // Last Updated: 20/07/2004
 // The License.txt file describes the conditions under which this software may be distributed.
+
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 // Some char test functions
 static bool isAsn1Number(int ch)
@@ -44,7 +45,7 @@ static bool isAsn1Char(int ch)
 //	Function determining the color of a given code portion
 //	Based on a "state"
 //
-static void ColouriseAsn1Doc(unsigned int startPos, int length, int initStyle, WordList *keywordLists[], Accessor &styler)
+static void ColouriseAsn1Doc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordLists[], Accessor &styler)
 {
 	// The keywords
 	WordList &Keywords = *keywordLists[0];
@@ -165,7 +166,7 @@ static void ColouriseAsn1Doc(unsigned int startPos, int length, int initStyle, W
 	sc.Complete();
 }
 
-static void FoldAsn1Doc(unsigned int, int, int, WordList *[], Accessor &styler)
+static void FoldAsn1Doc(Sci_PositionU, Sci_Position, int, WordList *[], Accessor &styler)
 {
 	// No folding enabled, no reason to continue...
 	if( styler.GetPropertyInt("fold") == 0 )
@@ -182,4 +183,4 @@ static const char * const asn1WordLists[] = {
 	0, };
 
 
-LexerModule lmAns1(SCLEX_ASN1, ColouriseAsn1Doc, "asn1", FoldAsn1Doc, asn1WordLists);
+LexerModule lmAsn1(SCLEX_ASN1, ColouriseAsn1Doc, "asn1", FoldAsn1Doc, asn1WordLists);
diff --git a/Pythonwin/Scintilla/lexers/LexBaan.cxx b/Pythonwin/Scintilla/lexers/LexBaan.cxx
new file mode 100644
index 000000000..80b4f40ab
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexBaan.cxx
@@ -0,0 +1,992 @@
+// Scintilla source code edit control
+/** @file LexBaan.cxx
+** Lexer for Baan.
+** Based heavily on LexCPP.cxx
+**/
+// Copyright 2001- by Vamsi Potluru <vamsi@who.net> & Praveen Ambekar <ambekarpraveen@yahoo.com>
+// Maintainer Email: oirfeodent@yahoo.co.in
+// The License.txt file describes the conditions under which this software may be distributed.
+
+// C standard library
+#include <stdlib.h>
+#include <string.h>
+
+// C++ wrappers of C standard library
+#include <cassert>
+
+// C++ standard library
+#include <string>
+#include <map>
+
+// Scintilla headers
+
+// Non-platform-specific headers
+
+// include
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+// lexlib
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+namespace {
+// Use an unnamed namespace to protect the functions and classes from name conflicts
+
+// Options used for LexerBaan
+struct OptionsBaan {
+	bool fold;
+	bool foldComment;
+	bool foldPreprocessor;
+	bool foldCompact;
+	bool baanFoldSyntaxBased;
+	bool baanFoldKeywordsBased;
+	bool baanFoldSections;
+	bool baanFoldInnerLevel;
+	bool baanStylingWithinPreprocessor;
+	OptionsBaan() {
+		fold = false;
+		foldComment = false;
+		foldPreprocessor = false;
+		foldCompact = false;
+		baanFoldSyntaxBased = false;
+		baanFoldKeywordsBased = false;
+		baanFoldSections = false;
+		baanFoldInnerLevel = false;
+		baanStylingWithinPreprocessor = false;
+	}
+};
+
+const char *const baanWordLists[] = {
+	"Baan & BaanSQL Reserved Keywords ",
+	"Baan Standard functions",
+	"Baan Functions Abridged",
+	"Baan Main Sections ",
+	"Baan Sub Sections",
+	"PreDefined Variables",
+	"PreDefined Attributes",
+	"Enumerates",
+	0,
+};
+
+struct OptionSetBaan : public OptionSet<OptionsBaan> {
+	OptionSetBaan() {
+		DefineProperty("fold", &OptionsBaan::fold);
+
+		DefineProperty("fold.comment", &OptionsBaan::foldComment);
+
+		DefineProperty("fold.preprocessor", &OptionsBaan::foldPreprocessor);
+
+		DefineProperty("fold.compact", &OptionsBaan::foldCompact);
+
+		DefineProperty("fold.baan.syntax.based", &OptionsBaan::baanFoldSyntaxBased,
+			"Set this property to 0 to disable syntax based folding, which is folding based on '{' & '('.");
+
+		DefineProperty("fold.baan.keywords.based", &OptionsBaan::baanFoldKeywordsBased,
+			"Set this property to 0 to disable keywords based folding, which is folding based on "
+			" for, if, on (case), repeat, select, while and fold ends based on endfor, endif, endcase, until, endselect, endwhile respectively."
+			"Also folds declarations which are grouped together.");
+
+		DefineProperty("fold.baan.sections", &OptionsBaan::baanFoldSections,
+			"Set this property to 0 to disable folding of Main Sections as well as Sub Sections.");
+
+		DefineProperty("fold.baan.inner.level", &OptionsBaan::baanFoldInnerLevel,
+			"Set this property to 1 to enable folding of inner levels of select statements."
+			"Disabled by default. case and if statements are also eligible" );
+
+		DefineProperty("lexer.baan.styling.within.preprocessor", &OptionsBaan::baanStylingWithinPreprocessor,
+			"For Baan code, determines whether all preprocessor code is styled in the "
+			"preprocessor style (0, the default) or only from the initial # to the end "
+			"of the command word(1).");
+
+		DefineWordListSets(baanWordLists);
+	}
+};
+
+static inline bool IsAWordChar(const int  ch) {
+	return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_' || ch == '$');
+}
+
+static inline bool IsAnOperator(int ch) {
+	if (IsAlphaNumeric(ch))
+		return false;
+	if (ch == '#' || ch == '^' || ch == '&' || ch == '*' ||
+		ch == '(' || ch == ')' || ch == '-' || ch == '+' ||
+		ch == '=' || ch == '|' || ch == '{' || ch == '}' ||
+		ch == '[' || ch == ']' || ch == ':' || ch == ';' ||
+		ch == '<' || ch == '>' || ch == ',' || ch == '/' ||
+		ch == '?' || ch == '!' || ch == '"' || ch == '~' ||
+		ch == '\\')
+		return true;
+	return false;
+}
+
+static inline int IsAnyOtherIdentifier(char *s, Sci_Position sLength) {
+
+	/*	IsAnyOtherIdentifier uses standard templates used in baan.
+	The matching template is shown as comments just above the return condition.
+	^ - refers to any character [a-z].
+	# - refers to any number [0-9].
+	Other characters shown are compared as is.
+	Tried implementing with Regex... it was too complicated for me.
+	Any other implementation suggestion welcome.
+	*/
+	switch (sLength) {
+	case 8:
+		if (isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[5]) && IsADigit(s[6]) && IsADigit(s[7])) {
+			//^^^^^###
+			return(SCE_BAAN_TABLEDEF);
+		}
+		break;
+	case 9:
+		if (s[0] == 't' && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && isalpha(s[5]) && IsADigit(s[6]) && IsADigit(s[7]) && IsADigit(s[8])) {
+			//t^^^^^###
+			return(SCE_BAAN_TABLEDEF);
+		}
+		else if (s[8] == '.' && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[5]) && IsADigit(s[6]) && IsADigit(s[7])) {
+			//^^^^^###.
+			return(SCE_BAAN_TABLESQL);
+		}
+		break;
+	case 13:
+		if (s[8] == '.' && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[5]) && IsADigit(s[6]) && IsADigit(s[7])) {
+			//^^^^^###.****
+			return(SCE_BAAN_TABLESQL);
+		}
+		else if (s[0] == 'r' && s[1] == 'c' && s[2] == 'd' && s[3] == '.' && s[4] == 't' && isalpha(s[5]) && isalpha(s[6]) && isalpha(s[7]) && isalpha(s[8]) && isalpha(s[9]) && IsADigit(s[10]) && IsADigit(s[11]) && IsADigit(s[12])) {
+			//rcd.t^^^^^###
+			return(SCE_BAAN_TABLEDEF);
+		}
+		break;
+	case 14:
+	case 15:
+		if (s[8] == '.' && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[5]) && IsADigit(s[6]) && IsADigit(s[7])) {
+			if (s[13] != ':') {
+				//^^^^^###.******
+				return(SCE_BAAN_TABLESQL);
+			}
+		}
+		break;
+	case 16:
+	case 17:
+		if (s[8] == '.' && s[9] == '_' && s[10] == 'i' && s[11] == 'n' && s[12] == 'd' && s[13] == 'e' && s[14] == 'x' && IsADigit(s[15]) && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[5]) && IsADigit(s[6]) && IsADigit(s[7])) {
+			//^^^^^###._index##
+			return(SCE_BAAN_TABLEDEF);
+		}
+		else if (s[8] == '.' && s[9] == '_' && s[10] == 'c' && s[11] == 'o' && s[12] == 'm' && s[13] == 'p' && s[14] == 'n' && s[15] == 'r' && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[5]) && IsADigit(s[6]) && IsADigit(s[7])) {
+			//^^^^^###._compnr
+			return(SCE_BAAN_TABLEDEF);
+		}
+		break;
+	default:
+		break;
+	}
+	if (sLength > 14 && s[5] == '.' && s[6] == 'd' && s[7] == 'l' && s[8] == 'l' && s[13] == '.' && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && IsADigit(s[9]) && IsADigit(s[10]) && IsADigit(s[11]) && IsADigit(s[12])) {
+		//^^^^^.dll####.
+		return(SCE_BAAN_FUNCTION);
+	}
+	else if (sLength > 15 && s[2] == 'i' && s[3] == 'n' && s[4] == 't' && s[5] == '.' && s[6] == 'd' && s[7] == 'l' && s[8] == 'l' && isalpha(s[0]) && isalpha(s[1]) && isalpha(s[9]) && isalpha(s[10]) && isalpha(s[11]) && isalpha(s[12]) && isalpha(s[13])) {
+		//^^int.dll^^^^^.
+		return(SCE_BAAN_FUNCTION);
+	}
+	else if (sLength > 11 && s[0] == 'i' && s[10] == '.' && isalpha(s[1]) && isalpha(s[2]) && isalpha(s[3]) && isalpha(s[4]) && isalpha(s[5]) && IsADigit(s[6]) && IsADigit(s[7]) && IsADigit(s[8]) && IsADigit(s[9])) {
+		//i^^^^^####.
+		return(SCE_BAAN_FUNCTION);
+	}
+
+	return(SCE_BAAN_DEFAULT);
+}
+
+static bool IsCommentLine(Sci_Position line, LexAccessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eol_pos; i++) {
+		char ch = styler[i];
+		int style = styler.StyleAt(i);
+		if (ch == '|' && style == SCE_BAAN_COMMENT)
+			return true;
+		else if (!IsASpaceOrTab(ch))
+			return false;
+	}
+	return false;
+}
+
+static bool IsPreProcLine(Sci_Position line, LexAccessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eol_pos; i++) {
+		char ch = styler[i];
+		int style = styler.StyleAt(i);
+		if (ch == '#' && style == SCE_BAAN_PREPROCESSOR) {
+			if (styler.Match(i, "#elif") || styler.Match(i, "#else") || styler.Match(i, "#endif")
+				|| styler.Match(i, "#if") || styler.Match(i, "#ifdef") || styler.Match(i, "#ifndef"))
+				// Above PreProcessors has a seperate fold mechanism.
+				return false;
+			else
+				return true;
+		}
+		else if (ch == '^')
+			return true;
+		else if (!IsASpaceOrTab(ch))
+			return false;
+	}
+	return false;
+}
+
+static int mainOrSubSectionLine(Sci_Position line, LexAccessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eol_pos; i++) {
+		char ch = styler[i];
+		int style = styler.StyleAt(i);
+		if (style == SCE_BAAN_WORD5 || style == SCE_BAAN_WORD4)
+			return style;
+		else if (IsASpaceOrTab(ch))
+			continue;
+		else
+			break;
+	}
+	return 0;
+}
+
+static bool priorSectionIsSubSection(Sci_Position line, LexAccessor &styler){
+	while (line > 0) {
+		Sci_Position pos = styler.LineStart(line);
+		Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+		for (Sci_Position i = pos; i < eol_pos; i++) {
+			char ch = styler[i];
+			int style = styler.StyleAt(i);
+			if (style == SCE_BAAN_WORD4)
+				return true;
+			else if (style == SCE_BAAN_WORD5)
+				return false;
+			else if (IsASpaceOrTab(ch))
+				continue;
+			else
+				break;
+		}
+		line--;
+	}
+	return false;
+}
+
+static bool nextSectionIsSubSection(Sci_Position line, LexAccessor &styler) {
+	while (line > 0) {
+		Sci_Position pos = styler.LineStart(line);
+		Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+		for (Sci_Position i = pos; i < eol_pos; i++) {
+			char ch = styler[i];
+			int style = styler.StyleAt(i);
+			if (style == SCE_BAAN_WORD4)
+				return true;
+			else if (style == SCE_BAAN_WORD5)
+				return false;
+			else if (IsASpaceOrTab(ch))
+				continue;
+			else
+				break;
+		}
+		line++;
+	}
+	return false;
+}
+
+static bool IsDeclarationLine(Sci_Position line, LexAccessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eol_pos; i++) {
+		char ch = styler[i];
+		int style = styler.StyleAt(i);
+		if (style == SCE_BAAN_WORD) {
+			if (styler.Match(i, "table") || styler.Match(i, "extern") || styler.Match(i, "long")
+				|| styler.Match(i, "double") || styler.Match(i, "boolean") || styler.Match(i, "string")
+				|| styler.Match(i, "domain")) {
+				for (Sci_Position j = eol_pos; j > pos; j--) {
+					int styleFromEnd = styler.StyleAt(j);
+					if (styleFromEnd == SCE_BAAN_COMMENT)
+						continue;
+					else if (IsASpace(styler[j]))
+						continue;
+					else if (styler[j] != ',')
+						//Above conditions ensures, Declaration is not part of any function parameters.
+						return true;
+					else
+						return false;
+				}
+			}
+			else
+				return false;
+		}
+		else if (!IsASpaceOrTab(ch))
+			return false;
+	}
+	return false;
+}
+
+static bool IsInnerLevelFold(Sci_Position line, LexAccessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eol_pos; i++) {
+		char ch = styler[i];
+		int style = styler.StyleAt(i);
+		if (style == SCE_BAAN_WORD && (styler.Match(i, "else" ) || styler.Match(i, "case")
+			|| styler.Match(i, "default") || styler.Match(i, "selectdo") || styler.Match(i, "selecteos")
+			|| styler.Match(i, "selectempty") || styler.Match(i, "selecterror")))
+			return true;
+		else if (IsASpaceOrTab(ch))
+			continue;
+		else
+			return false;
+	}
+	return false;
+}
+
+static inline bool wordInArray(const std::string& value, std::string *array, int length)
+{
+	for (int i = 0; i < length; i++)
+	{
+		if (value == array[i])
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+class WordListAbridged : public WordList {
+public:
+	WordListAbridged() {
+		kwAbridged = false;
+		kwHasSection = false;
+	};
+	~WordListAbridged() {
+		Clear();
+	};
+	bool kwAbridged;
+	bool kwHasSection;
+	bool Contains(const char *s) {
+		return kwAbridged ? InListAbridged(s, '~') : InList(s);
+	};
+};
+
+}
+
+class LexerBaan : public DefaultLexer {
+	WordListAbridged keywords;
+	WordListAbridged keywords2;
+	WordListAbridged keywords3;
+	WordListAbridged keywords4;
+	WordListAbridged keywords5;
+	WordListAbridged keywords6;
+	WordListAbridged keywords7;
+	WordListAbridged keywords8;
+	WordListAbridged keywords9;
+	OptionsBaan options;
+	OptionSetBaan osBaan;
+public:
+	LexerBaan() : DefaultLexer("baan", SCLEX_BAAN) {
+	}
+
+	virtual ~LexerBaan() {
+	}
+
+	int SCI_METHOD Version() const override {
+		return lvRelease5;
+	}
+
+	void SCI_METHOD Release() override {
+		delete this;
+	}
+
+	const char * SCI_METHOD PropertyNames() override {
+		return osBaan.PropertyNames();
+	}
+
+	int SCI_METHOD PropertyType(const char * name) override {
+		return osBaan.PropertyType(name);
+	}
+
+	const char * SCI_METHOD DescribeProperty(const char * name) override {
+		return osBaan.DescribeProperty(name);
+	}
+
+	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();
+	}
+
+	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 *) override {
+		return NULL;
+	}
+
+	static ILexer5 * LexerFactoryBaan() {
+		return new LexerBaan();
+	}
+};
+
+Sci_Position SCI_METHOD LexerBaan::PropertySet(const char *key, const char *val) {
+	if (osBaan.PropertySet(&options, key, val)) {
+		return 0;
+	}
+	return -1;
+}
+
+Sci_Position SCI_METHOD LexerBaan::WordListSet(int n, const char *wl) {
+	WordListAbridged *WordListAbridgedN = 0;
+	switch (n) {
+	case 0:
+		WordListAbridgedN = &keywords;
+		break;
+	case 1:
+		WordListAbridgedN = &keywords2;
+		break;
+	case 2:
+		WordListAbridgedN = &keywords3;
+		break;
+	case 3:
+		WordListAbridgedN = &keywords4;
+		break;
+	case 4:
+		WordListAbridgedN = &keywords5;
+		break;
+	case 5:
+		WordListAbridgedN = &keywords6;
+		break;
+	case 6:
+		WordListAbridgedN = &keywords7;
+		break;
+	case 7:
+		WordListAbridgedN = &keywords8;
+		break;
+	case 8:
+		WordListAbridgedN = &keywords9;
+		break;
+	}
+	Sci_Position firstModification = -1;
+	if (WordListAbridgedN) {
+		WordListAbridged wlNew;
+		wlNew.Set(wl);
+		if (*WordListAbridgedN != wlNew) {
+			WordListAbridgedN->Set(wl);
+			WordListAbridgedN->kwAbridged = strchr(wl, '~') != NULL;
+			WordListAbridgedN->kwHasSection = strchr(wl, ':') != NULL;
+
+			firstModification = 0;
+		}
+	}
+	return firstModification;
+}
+
+void SCI_METHOD LexerBaan::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+
+	if (initStyle == SCE_BAAN_STRINGEOL)	// Does not leak onto next line
+		initStyle = SCE_BAAN_DEFAULT;
+
+	int visibleChars = 0;
+	bool lineHasDomain = false;
+	bool lineHasFunction = false;
+	bool lineHasPreProc = false;
+	bool lineIgnoreString = false;
+	bool lineHasDefines = false;
+	bool numberIsHex = false;
+	char word[1000];
+	int wordlen = 0;
+
+	std::string preProcessorTags[13] = { "#context_off", "#context_on",
+		"#define", "#elif", "#else", "#endif",
+		"#ident", "#if", "#ifdef", "#ifndef",
+		"#include", "#pragma", "#undef" };
+	LexAccessor styler(pAccess);
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	for (; sc.More(); sc.Forward()) {
+
+		// Determine if the current state should terminate.
+		switch (sc.state) {
+		case SCE_BAAN_OPERATOR:
+			sc.SetState(SCE_BAAN_DEFAULT);
+			break;
+		case SCE_BAAN_NUMBER:
+			if (IsASpaceOrTab(sc.ch) || sc.ch == '\r' || sc.ch == '\n' || IsAnOperator(sc.ch)) {
+				sc.SetState(SCE_BAAN_DEFAULT);
+			}
+			else if ((numberIsHex && !(MakeLowerCase(sc.ch) == 'x' || MakeLowerCase(sc.ch) == 'e' ||
+				IsADigit(sc.ch, 16) || sc.ch == '.' || sc.ch == '-' || sc.ch == '+')) ||
+				(!numberIsHex && !(MakeLowerCase(sc.ch) == 'e' || IsADigit(sc.ch)
+				|| sc.ch == '.' || sc.ch == '-' || sc.ch == '+'))) {
+					// check '-' for possible -10e-5. Add '+' as well.
+					numberIsHex = false;
+					sc.ChangeState(SCE_BAAN_IDENTIFIER);
+					sc.SetState(SCE_BAAN_DEFAULT);
+			}
+			break;
+		case SCE_BAAN_IDENTIFIER:
+			if (!IsAWordChar(sc.ch)) {
+				char s[1000];
+				char s1[1000];
+				sc.GetCurrentLowered(s, sizeof(s));
+				if (sc.ch == ':') {
+					memcpy(s1, s, sizeof(s));
+					s1[sc.LengthCurrent()] = sc.ch;
+					s1[sc.LengthCurrent() + 1] = '\0';
+				}
+				if ((keywords.kwHasSection && (sc.ch == ':')) ? keywords.Contains(s1) : keywords.Contains(s)) {
+					sc.ChangeState(SCE_BAAN_WORD);
+					if (0 == strcmp(s, "domain")) {
+						lineHasDomain = true;
+					}
+					else if (0 == strcmp(s, "function")) {
+						lineHasFunction = true;
+					}
+				}
+				else if (lineHasDomain) {
+					sc.ChangeState(SCE_BAAN_DOMDEF);
+					lineHasDomain = false;
+				}
+				else if (lineHasFunction) {
+					sc.ChangeState(SCE_BAAN_FUNCDEF);
+					lineHasFunction = false;
+				}
+				else if ((keywords2.kwHasSection && (sc.ch == ':')) ? keywords2.Contains(s1) : keywords2.Contains(s)) {
+					sc.ChangeState(SCE_BAAN_WORD2);
+				}
+				else if ((keywords3.kwHasSection && (sc.ch == ':')) ? keywords3.Contains(s1) : keywords3.Contains(s)) {
+					if (sc.ch == '(')
+						sc.ChangeState(SCE_BAAN_WORD3);
+					else
+						sc.ChangeState(SCE_BAAN_IDENTIFIER);
+				}
+				else if ((keywords4.kwHasSection && (sc.ch == ':')) ? keywords4.Contains(s1) : keywords4.Contains(s)) {
+					sc.ChangeState(SCE_BAAN_WORD4);
+				}
+				else if ((keywords5.kwHasSection && (sc.ch == ':')) ? keywords5.Contains(s1) : keywords5.Contains(s)) {
+					sc.ChangeState(SCE_BAAN_WORD5);
+				}
+				else if ((keywords6.kwHasSection && (sc.ch == ':')) ? keywords6.Contains(s1) : keywords6.Contains(s)) {
+					sc.ChangeState(SCE_BAAN_WORD6);
+				}
+				else if ((keywords7.kwHasSection && (sc.ch == ':')) ? keywords7.Contains(s1) : keywords7.Contains(s)) {
+					sc.ChangeState(SCE_BAAN_WORD7);
+				}
+				else if ((keywords8.kwHasSection && (sc.ch == ':')) ? keywords8.Contains(s1) : keywords8.Contains(s)) {
+					sc.ChangeState(SCE_BAAN_WORD8);
+				}
+				else if ((keywords9.kwHasSection && (sc.ch == ':')) ? keywords9.Contains(s1) : keywords9.Contains(s)) {
+					sc.ChangeState(SCE_BAAN_WORD9);
+				}
+				else if (lineHasPreProc) {
+					sc.ChangeState(SCE_BAAN_OBJECTDEF);
+					lineHasPreProc = false;
+				}
+				else if (lineHasDefines) {
+					sc.ChangeState(SCE_BAAN_DEFINEDEF);
+					lineHasDefines = false;
+				}
+				else {
+					int state = IsAnyOtherIdentifier(s, sc.LengthCurrent());
+					if (state > 0) {
+						sc.ChangeState(state);
+					}
+				}
+				sc.SetState(SCE_BAAN_DEFAULT);
+			}
+			break;
+		case SCE_BAAN_PREPROCESSOR:
+			if (options.baanStylingWithinPreprocessor) {
+				if (IsASpace(sc.ch) || IsAnOperator(sc.ch)) {
+					sc.SetState(SCE_BAAN_DEFAULT);
+				}
+			}
+			else {
+				if (sc.atLineEnd && (sc.chNext != '^')) {
+					sc.SetState(SCE_BAAN_DEFAULT);
+				}
+			}
+			break;
+		case SCE_BAAN_COMMENT:
+			if (sc.ch == '\r' || sc.ch == '\n') {
+				sc.SetState(SCE_BAAN_DEFAULT);
+			}
+			break;
+		case SCE_BAAN_COMMENTDOC:
+			if (sc.MatchIgnoreCase("enddllusage")) {
+				for (unsigned int i = 0; i < 10; i++) {
+					sc.Forward();
+				}
+				sc.ForwardSetState(SCE_BAAN_DEFAULT);
+			}
+			else if (sc.MatchIgnoreCase("endfunctionusage")) {
+				for (unsigned int i = 0; i < 15; i++) {
+					sc.Forward();
+				}
+				sc.ForwardSetState(SCE_BAAN_DEFAULT);
+			}
+			break;
+		case SCE_BAAN_STRING:
+			if (sc.ch == '\"') {
+				sc.ForwardSetState(SCE_BAAN_DEFAULT);
+			}
+			else if ((sc.atLineEnd) && (sc.chNext != '^')) {
+				sc.ChangeState(SCE_BAAN_STRINGEOL);
+				sc.ForwardSetState(SCE_BAAN_DEFAULT);
+				visibleChars = 0;
+			}
+			break;
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_BAAN_DEFAULT) {
+			if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))
+				|| ((sc.ch == '-' || sc.ch == '+') && (IsADigit(sc.chNext) || sc.chNext == '.'))
+				|| (MakeLowerCase(sc.ch) == 'e' && (IsADigit(sc.chNext) || sc.chNext == '+' || sc.chNext == '-'))) {
+				if ((sc.ch == '0' && MakeLowerCase(sc.chNext) == 'x') ||
+					((sc.ch == '-' || sc.ch == '+') && sc.chNext == '0' && MakeLowerCase(sc.GetRelativeCharacter(2)) == 'x')){
+					numberIsHex = true;
+				}
+				sc.SetState(SCE_BAAN_NUMBER);
+			}
+			else if (sc.MatchIgnoreCase("dllusage") || sc.MatchIgnoreCase("functionusage")) {
+				sc.SetState(SCE_BAAN_COMMENTDOC);
+				do {
+					sc.Forward();
+				} while ((!sc.atLineEnd) && sc.More());
+			}
+			else if (iswordstart(sc.ch)) {
+				sc.SetState(SCE_BAAN_IDENTIFIER);
+			}
+			else if (sc.Match('|')) {
+				sc.SetState(SCE_BAAN_COMMENT);
+			}
+			else if (sc.ch == '\"' && !(lineIgnoreString)) {
+				sc.SetState(SCE_BAAN_STRING);
+			}
+			else if (sc.ch == '#' && visibleChars == 0) {
+				// Preprocessor commands are alone on their line
+				sc.SetState(SCE_BAAN_PREPROCESSOR);
+				word[0] = '\0';
+				wordlen = 0;
+				while (sc.More() && !(IsASpace(sc.chNext) || IsAnOperator(sc.chNext))) {
+					sc.Forward();
+					wordlen++;
+				}
+				sc.GetCurrentLowered(word, sizeof(word));
+				if (!sc.atLineEnd) {
+					word[wordlen++] = sc.ch;
+					word[wordlen++] = '\0';
+				}
+				if (!wordInArray(word, preProcessorTags, 13))
+					// Colorise only preprocessor built in Baan.
+					sc.ChangeState(SCE_BAAN_IDENTIFIER);
+				if (strcmp(word, "#pragma") == 0 || strcmp(word, "#include") == 0) {
+					lineHasPreProc = true;
+					lineIgnoreString = true;
+				}
+				else if (strcmp(word, "#define") == 0 || strcmp(word, "#undef") == 0 ||
+					strcmp(word, "#ifdef") == 0 || strcmp(word, "#if") == 0 || strcmp(word, "#ifndef") == 0) {
+					lineHasDefines = true;
+					lineIgnoreString = false;
+				}
+			}
+			else if (IsAnOperator(static_cast<char>(sc.ch))) {
+				sc.SetState(SCE_BAAN_OPERATOR);
+			}
+		}
+
+		if (sc.atLineEnd) {
+			// Reset states to begining of colourise so no surprises
+			// if different sets of lines lexed.
+			visibleChars = 0;
+			lineHasDomain = false;
+			lineHasFunction = false;
+			lineHasPreProc = false;
+			lineIgnoreString = false;
+			lineHasDefines = false;
+			numberIsHex = false;
+		}
+		if (!IsASpace(sc.ch)) {
+			visibleChars++;
+		}
+	}
+	sc.Complete();
+}
+
+void SCI_METHOD LexerBaan::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	if (!options.fold)
+		return;
+
+	char word[100];
+	int wordlen = 0;
+	bool foldStart = true;
+	bool foldNextSelect = true;
+	bool afterFunctionSection = false;
+	bool beforeDeclarationSection = false;
+	int currLineStyle = 0;
+	int nextLineStyle = 0;
+
+	std::string startTags[6] = { "for", "if", "on", "repeat", "select", "while" };
+	std::string endTags[6] = { "endcase", "endfor", "endif", "endselect", "endwhile", "until" };
+	std::string selectCloseTags[5] = { "selectdo", "selecteos", "selectempty", "selecterror", "endselect" };
+
+	LexAccessor styler(pAccess);
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+
+	// Backtrack to previous line in case need to fix its fold status
+	if (startPos > 0) {
+		if (lineCurrent > 0) {
+			lineCurrent--;
+			startPos = styler.LineStart(lineCurrent);
+		}
+	}
+
+	int levelPrev = SC_FOLDLEVELBASE;
+	if (lineCurrent > 0)
+		levelPrev = styler.LevelAt(lineCurrent - 1) >> 16;
+	int levelCurrent = levelPrev;
+	char chNext = styler[startPos];
+	int style = initStyle;
+	int styleNext = styler.StyleAt(startPos);
+
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		int stylePrev = (i) ? styler.StyleAt(i - 1) : SCE_BAAN_DEFAULT;
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+
+		// Comment folding
+		if (options.foldComment && style == SCE_BAAN_COMMENTDOC) {
+			if (style != stylePrev) {
+				levelCurrent++;
+			}
+			else if (style != styleNext) {
+				levelCurrent--;
+			}
+		}
+		if (options.foldComment && atEOL && IsCommentLine(lineCurrent, styler)) {
+			if (!IsCommentLine(lineCurrent - 1, styler)
+				&& IsCommentLine(lineCurrent + 1, styler))
+				levelCurrent++;
+			else if (IsCommentLine(lineCurrent - 1, styler)
+				&& !IsCommentLine(lineCurrent + 1, styler))
+				levelCurrent--;
+		}
+		// PreProcessor Folding
+		if (options.foldPreprocessor) {
+			if (atEOL && IsPreProcLine(lineCurrent, styler)) {
+				if (!IsPreProcLine(lineCurrent - 1, styler)
+					&& IsPreProcLine(lineCurrent + 1, styler))
+					levelCurrent++;
+				else if (IsPreProcLine(lineCurrent - 1, styler)
+					&& !IsPreProcLine(lineCurrent + 1, styler))
+					levelCurrent--;
+			}
+			else if (style == SCE_BAAN_PREPROCESSOR) {
+				// folds #ifdef/#if/#ifndef - they are not part of the IsPreProcLine folding.
+				if (ch == '#') {
+					if (styler.Match(i, "#ifdef") || styler.Match(i, "#if") || styler.Match(i, "#ifndef")
+						|| styler.Match(i, "#context_on"))
+						levelCurrent++;
+					else if (styler.Match(i, "#endif") || styler.Match(i, "#context_off"))
+						levelCurrent--;
+				}
+			}
+		}
+		//Syntax Folding
+		if (options.baanFoldSyntaxBased && (style == SCE_BAAN_OPERATOR)) {
+			if (ch == '{' || ch == '(') {
+				levelCurrent++;
+			}
+			else if (ch == '}' || ch == ')') {
+				levelCurrent--;
+			}
+		}
+		//Keywords Folding
+		if (options.baanFoldKeywordsBased) {
+			if (atEOL && IsDeclarationLine(lineCurrent, styler)) {
+				if (!IsDeclarationLine(lineCurrent - 1, styler)
+					&& IsDeclarationLine(lineCurrent + 1, styler))
+					levelCurrent++;
+				else if (IsDeclarationLine(lineCurrent - 1, styler)
+					&& !IsDeclarationLine(lineCurrent + 1, styler))
+					levelCurrent--;
+			}
+			else if (style == SCE_BAAN_WORD) {
+				word[wordlen++] = static_cast<char>(MakeLowerCase(ch));
+				if (wordlen == 100) {                   // prevent overflow
+					word[0] = '\0';
+					wordlen = 1;
+				}
+				if (styleNext != SCE_BAAN_WORD) {
+					word[wordlen] = '\0';
+					wordlen = 0;
+					if (strcmp(word, "for") == 0) {
+						Sci_PositionU j = i + 1;
+						while ((j < endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
+							j++;
+						}
+						if (styler.Match(j, "update")) {
+							// Means this is a "for update" used by Select which is already folded.
+							foldStart = false;
+						}
+					}
+					else if (strcmp(word, "on") == 0) {
+						Sci_PositionU j = i + 1;
+						while ((j < endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
+							j++;
+						}
+						if (!styler.Match(j, "case")) {
+							// Means this is not a "on Case" statement... could be "on" used by index.
+							foldStart = false;
+						}
+					}
+					else if (strcmp(word, "select") == 0) {
+						if (foldNextSelect) {
+							// Next Selects are sub-clause till reach of selectCloseTags[] array.
+							foldNextSelect = false;
+							foldStart = true;
+						}
+						else {
+							foldNextSelect = false;
+							foldStart = false;
+						}
+					}
+					else if (wordInArray(word, selectCloseTags, 5)) {
+						// select clause ends, next select clause can be folded.
+						foldNextSelect = true;
+						foldStart = true;
+					}
+					else {
+						foldStart = true;
+					}
+					if (foldStart) {
+						if (wordInArray(word, startTags, 6)) {
+							levelCurrent++;
+						}
+						else if (wordInArray(word, endTags, 6)) {
+							levelCurrent--;
+						}
+					}
+				}
+			}
+		}
+		// Fold inner level of if/select/case statements
+		if (options.baanFoldInnerLevel && atEOL) {
+			bool currLineInnerLevel = IsInnerLevelFold(lineCurrent, styler);
+			bool nextLineInnerLevel = IsInnerLevelFold(lineCurrent + 1, styler);
+			if (currLineInnerLevel && currLineInnerLevel != nextLineInnerLevel) {
+				levelCurrent++;
+			}
+			else if (nextLineInnerLevel && nextLineInnerLevel != currLineInnerLevel) {
+				levelCurrent--;
+			}
+		}
+		// Section Foldings.
+		// One way of implementing Section Foldings, as there is no END markings of sections.
+		// first section ends on the previous line of next section.
+		// Re-written whole folding to accomodate this.
+		if (options.baanFoldSections && atEOL) {
+			currLineStyle = mainOrSubSectionLine(lineCurrent, styler);
+			nextLineStyle = mainOrSubSectionLine(lineCurrent + 1, styler);
+			if (currLineStyle != 0 && currLineStyle != nextLineStyle) {
+				if (levelCurrent < levelPrev)
+					--levelPrev;
+				for (Sci_Position j = styler.LineStart(lineCurrent); j < styler.LineStart(lineCurrent + 1) - 1; j++) {
+					if (IsASpaceOrTab(styler[j]))
+						continue;
+					else if (styler.StyleAt(j) == SCE_BAAN_WORD5) {
+						if (styler.Match(j, "functions:")) {
+							// Means functions: is the end of MainSections.
+							// Nothing to fold after this.
+							afterFunctionSection = true;
+							break;
+						}
+						else {
+							afterFunctionSection = false;
+							break;
+						}
+					}
+					else {
+						afterFunctionSection = false;
+						break;
+					}
+				}
+				if (!afterFunctionSection)
+					levelCurrent++;
+			}
+			else if (nextLineStyle != 0 && currLineStyle != nextLineStyle
+				&& (priorSectionIsSubSection(lineCurrent -1 ,styler)
+					|| !nextSectionIsSubSection(lineCurrent + 1, styler))) {
+				for (Sci_Position j = styler.LineStart(lineCurrent + 1); j < styler.LineStart(lineCurrent + 1 + 1) - 1; j++) {
+					if (IsASpaceOrTab(styler[j]))
+						continue;
+					else if (styler.StyleAt(j) == SCE_BAAN_WORD5) {
+						if (styler.Match(j, "declaration:")) {
+							// Means declaration: is the start of MainSections.
+							// Nothing to fold before this.
+							beforeDeclarationSection = true;
+							break;
+						}
+						else {
+							beforeDeclarationSection = false;
+							break;
+						}
+					}
+					else {
+						beforeDeclarationSection = false;
+						break;
+					}
+				}
+				if (!beforeDeclarationSection) {
+					levelCurrent--;
+					if (nextLineStyle == SCE_BAAN_WORD5 && priorSectionIsSubSection(lineCurrent-1, styler))
+						// next levelCurrent--; is to unfold previous subsection fold.
+						// On reaching the next main section, the previous main as well sub section ends.
+						levelCurrent--;
+				}
+			}
+		}
+		if (atEOL) {
+			int lev = levelPrev;
+			lev |= levelCurrent << 16;
+			if (visibleChars == 0 && options.foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if ((levelCurrent > levelPrev) && (visibleChars > 0))
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			levelPrev = levelCurrent;
+			visibleChars = 0;
+		}
+		if (!isspacechar(ch))
+			visibleChars++;
+	}
+	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
+	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
+}
+
+LexerModule lmBaan(SCLEX_BAAN, LexerBaan::LexerFactoryBaan, "baan", baanWordLists);
diff --git a/Pythonwin/Scintilla/lexers/LexBash.cxx b/Pythonwin/Scintilla/lexers/LexBash.cxx
new file mode 100644
index 000000000..07dc6c1ce
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexBash.cxx
@@ -0,0 +1,1086 @@
+// Scintilla source code edit control
+/** @file LexBash.cxx
+ ** Lexer for Bash.
+ **/
+// Copyright 2004-2012 by Neil Hodgson <neilh@scintilla.org>
+// Adapted from LexPerl by Kein-Hong Man 2004
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "StringCopy.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "SubStyles.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+#define HERE_DELIM_MAX			256
+
+// define this if you want 'invalid octals' to be marked as errors
+// usually, this is not a good idea, permissive lexing is better
+#undef PEDANTIC_OCTAL
+
+#define BASH_BASE_ERROR			65
+#define BASH_BASE_DECIMAL		66
+#define BASH_BASE_HEX			67
+#ifdef PEDANTIC_OCTAL
+#define BASH_BASE_OCTAL			68
+#define	BASH_BASE_OCTAL_ERROR	69
+#endif
+
+// state constants for parts of a bash command segment
+#define	BASH_CMD_BODY			0
+#define BASH_CMD_START			1
+#define BASH_CMD_WORD			2
+#define BASH_CMD_TEST			3
+#define BASH_CMD_ARITH			4
+#define BASH_CMD_DELIM			5
+
+// state constants for nested delimiter pairs, used by
+// SCE_SH_STRING and SCE_SH_BACKTICKS processing
+#define BASH_DELIM_LITERAL		0
+#define BASH_DELIM_STRING		1
+#define BASH_DELIM_CSTRING		2
+#define BASH_DELIM_LSTRING		3
+#define BASH_DELIM_COMMAND		4
+#define BASH_DELIM_BACKTICK		5
+
+#define BASH_DELIM_STACK_MAX	7
+
+namespace {
+
+inline int translateBashDigit(int ch) {
+	if (ch >= '0' && ch <= '9') {
+		return ch - '0';
+	} else if (ch >= 'a' && ch <= 'z') {
+		return ch - 'a' + 10;
+	} else if (ch >= 'A' && ch <= 'Z') {
+		return ch - 'A' + 36;
+	} else if (ch == '@') {
+		return 62;
+	} else if (ch == '_') {
+		return 63;
+	}
+	return BASH_BASE_ERROR;
+}
+
+inline int getBashNumberBase(char *s) {
+	int i = 0;
+	int base = 0;
+	while (*s) {
+		base = base * 10 + (*s++ - '0');
+		i++;
+	}
+	if (base > 64 || i > 2) {
+		return BASH_BASE_ERROR;
+	}
+	return base;
+}
+
+int opposite(int ch) {
+	if (ch == '(') return ')';
+	if (ch == '[') return ']';
+	if (ch == '{') return '}';
+	if (ch == '<') return '>';
+	return ch;
+}
+
+int GlobScan(StyleContext &sc) {
+	// forward scan for zsh globs, disambiguate versus bash arrays
+	// complex expressions may still fail, e.g. unbalanced () '' "" etc
+	int c, sLen = 0;
+	int pCount = 0;
+	int hash = 0;
+	while ((c = sc.GetRelativeCharacter(++sLen)) != 0) {
+		if (IsASpace(c)) {
+			return 0;
+		} else if (c == '\'' || c == '\"') {
+			if (hash != 2) return 0;
+		} else if (c == '#' && hash == 0) {
+			hash = (sLen == 1) ? 2:1;
+		} else if (c == '(') {
+			pCount++;
+		} else if (c == ')') {
+			if (pCount == 0) {
+				if (hash) return sLen;
+				return 0;
+			}
+			pCount--;
+		}
+	}
+	return 0;
+}
+
+bool IsCommentLine(Sci_Position line, LexAccessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eol_pos; i++) {
+		char ch = styler[i];
+		if (ch == '#')
+			return true;
+		else if (ch != ' ' && ch != '\t')
+			return false;
+	}
+	return false;
+}
+
+struct OptionsBash {
+	bool fold;
+	bool foldComment;
+	bool foldCompact;
+
+	OptionsBash() {
+		fold = false;
+		foldComment = false;
+		foldCompact = true;
+	}
+};
+
+const char * const bashWordListDesc[] = {
+	"Keywords",
+	0
+};
+
+struct OptionSetBash : public OptionSet<OptionsBash> {
+	OptionSetBash() {
+		DefineProperty("fold", &OptionsBash::fold);
+
+		DefineProperty("fold.comment", &OptionsBash::foldComment);
+
+		DefineProperty("fold.compact", &OptionsBash::foldCompact);
+
+		DefineWordListSets(bashWordListDesc);
+	}
+};
+
+const char styleSubable[] = { SCE_SH_IDENTIFIER, SCE_SH_SCALAR, 0 };
+
+LexicalClass lexicalClasses[] = {
+	// Lexer Bash SCLEX_BASH SCE_SH_:
+	0, "SCE_SH_DEFAULT", "default", "White space",
+	1, "SCE_SH_ERROR", "error", "Error",
+	2, "SCE_SH_COMMENTLINE", "comment line", "Line comment: #",
+	3, "SCE_SH_NUMBER", "literal numeric", "Number",
+	4, "SCE_SH_WORD", "keyword", "Keyword",
+	5, "SCE_SH_STRING", "literal string", "String",
+	6, "SCE_SH_CHARACTER", "literal string", "Single quoted string",
+	7, "SCE_SH_OPERATOR", "operator", "Operators",
+	8, "SCE_SH_IDENTIFIER", "identifier", "Identifiers",
+	9, "SCE_SH_SCALAR", "identifier", "Scalar variable",
+	10, "SCE_SH_PARAM", "identifier", "Parameter",
+	11, "SCE_SH_BACKTICKS", "literal string", "Backtick quoted command",
+	12, "SCE_SH_HERE_DELIM", "operator", "Heredoc delimiter",
+	13, "SCE_SH_HERE_Q", "literal string", "Heredoc quoted string",
+};
+
+}
+
+class LexerBash : public DefaultLexer {
+	WordList keywords;
+	OptionsBash options;
+	OptionSetBash osBash;
+	enum { ssIdentifier, ssScalar };
+	SubStyles subStyles;
+public:
+	LexerBash() :
+		DefaultLexer("bash", SCLEX_BASH, lexicalClasses, ELEMENTS(lexicalClasses)),
+		subStyles(styleSubable, 0x80, 0x40, 0) {
+	}
+	virtual ~LexerBash() {
+	}
+	void SCI_METHOD Release() override {
+		delete this;
+	}
+	int SCI_METHOD Version() const override {
+		return lvRelease5;
+	}
+	const char * SCI_METHOD PropertyNames() override {
+		return osBash.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char* name) override {
+		return osBash.PropertyType(name);
+	}
+	const char * SCI_METHOD DescribeProperty(const char *name) override {
+		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();
+	}
+	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 *) override {
+		return 0;
+	}
+
+	int SCI_METHOD AllocateSubStyles(int styleBase, int numberStyles) override {
+		return subStyles.Allocate(styleBase, numberStyles);
+	}
+	int SCI_METHOD SubStylesStart(int styleBase) override {
+		return subStyles.Start(styleBase);
+	}
+	int SCI_METHOD SubStylesLength(int styleBase) override {
+		return subStyles.Length(styleBase);
+	}
+	int SCI_METHOD StyleFromSubStyle(int subStyle) override {
+		const int styleBase = subStyles.BaseStyle(subStyle);
+		return styleBase;
+	}
+	int SCI_METHOD PrimaryStyleFromStyle(int style) override {
+		return style;
+	}
+	void SCI_METHOD FreeSubStyles() override {
+		subStyles.Free();
+	}
+	void SCI_METHOD SetIdentifiers(int style, const char *identifiers) override {
+		subStyles.SetIdentifiers(style, identifiers);
+	}
+	int SCI_METHOD DistanceToSecondaryStyles() override {
+		return 0;
+	}
+	const char *SCI_METHOD GetSubStyleBases() override {
+		return styleSubable;
+	}
+
+	static ILexer5 *LexerFactoryBash() {
+		return new LexerBash();
+	}
+};
+
+Sci_Position SCI_METHOD LexerBash::PropertySet(const char *key, const char *val) {
+	if (osBash.PropertySet(&options, key, val)) {
+		return 0;
+	}
+	return -1;
+}
+
+Sci_Position SCI_METHOD LexerBash::WordListSet(int n, const char *wl) {
+	WordList *wordListN = 0;
+	switch (n) {
+	case 0:
+		wordListN = &keywords;
+		break;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN) {
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+		}
+	}
+	return firstModification;
+}
+
+void SCI_METHOD LexerBash::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	WordList cmdDelimiter, bashStruct, bashStruct_in;
+	cmdDelimiter.Set("| || |& & && ; ;; ( ) { }");
+	bashStruct.Set("if elif fi while until else then do done esac eval");
+	bashStruct_in.Set("for case select");
+
+	CharacterSet setWordStart(CharacterSet::setAlpha, "_");
+	// note that [+-] are often parts of identifiers in shell scripts
+	CharacterSet setWord(CharacterSet::setAlphaNum, "._+-");
+	CharacterSet setMetaCharacter(CharacterSet::setNone, "|&;()<> \t\r\n");
+	setMetaCharacter.Add(0);
+	CharacterSet setBashOperator(CharacterSet::setNone, "^&%()-+=|{}[]:;>,*/<?!.~@");
+	CharacterSet setSingleCharOp(CharacterSet::setNone, "rwxoRWXOezsfdlpSbctugkTBMACahGLNn");
+	CharacterSet setParam(CharacterSet::setAlphaNum, "$_");
+	CharacterSet setHereDoc(CharacterSet::setAlpha, "_\\-+!%*,./:?@[]^`{}~");
+	CharacterSet setHereDoc2(CharacterSet::setAlphaNum, "_-+!%*,./:=?@[]^`{}~");
+	CharacterSet setLeftShift(CharacterSet::setDigits, "$");
+
+	class HereDocCls {	// Class to manage HERE document elements
+	public:
+		int State;		// 0: '<<' encountered
+		// 1: collect the delimiter
+		// 2: here doc text (lines after the delimiter)
+		int Quote;		// the char after '<<'
+		bool Quoted;		// true if Quote in ('\'','"','`')
+		bool Indent;		// indented delimiter (for <<-)
+		int DelimiterLength;	// strlen(Delimiter)
+		char Delimiter[HERE_DELIM_MAX];	// the Delimiter
+		HereDocCls() {
+			State = 0;
+			Quote = 0;
+			Quoted = false;
+			Indent = 0;
+			DelimiterLength = 0;
+			Delimiter[0] = '\0';
+		}
+		void Append(int ch) {
+			Delimiter[DelimiterLength++] = static_cast<char>(ch);
+			Delimiter[DelimiterLength] = '\0';
+		}
+		~HereDocCls() {
+		}
+	};
+	HereDocCls HereDoc;
+
+	class QuoteCls {	// Class to manage quote pairs (simplified vs LexPerl)
+		public:
+		int Count;
+		int Up, Down;
+		QuoteCls() {
+			Count = 0;
+			Up    = '\0';
+			Down  = '\0';
+		}
+		void Open(int u) {
+			Count++;
+			Up    = u;
+			Down  = opposite(Up);
+		}
+		void Start(int u) {
+			Count = 0;
+			Open(u);
+		}
+	};
+	QuoteCls Quote;
+
+	class QuoteStackCls {	// Class to manage quote pairs that nest
+		public:
+		int Count;
+		int Up, Down;
+		int Style;
+		int Depth;			// levels pushed
+		int CountStack[BASH_DELIM_STACK_MAX];
+		int UpStack   [BASH_DELIM_STACK_MAX];
+		int StyleStack[BASH_DELIM_STACK_MAX];
+		QuoteStackCls() {
+			Count = 0;
+			Up    = '\0';
+			Down  = '\0';
+			Style = 0;
+			Depth = 0;
+		}
+		void Start(int u, int s) {
+			Count = 1;
+			Up    = u;
+			Down  = opposite(Up);
+			Style = s;
+		}
+		void Push(int u, int s) {
+			if (Depth >= BASH_DELIM_STACK_MAX)
+				return;
+			CountStack[Depth] = Count;
+			UpStack   [Depth] = Up;
+			StyleStack[Depth] = Style;
+			Depth++;
+			Count = 1;
+			Up    = u;
+			Down  = opposite(Up);
+			Style = s;
+		}
+		void Pop(void) {
+			if (Depth <= 0)
+				return;
+			Depth--;
+			Count = CountStack[Depth];
+			Up    = UpStack   [Depth];
+			Style = StyleStack[Depth];
+			Down  = opposite(Up);
+		}
+		~QuoteStackCls() {
+		}
+	};
+	QuoteStackCls QuoteStack;
+
+	const WordClassifier &classifierIdentifiers = subStyles.Classifier(SCE_SH_IDENTIFIER);
+	const WordClassifier &classifierScalars = subStyles.Classifier(SCE_SH_SCALAR);
+
+	int numBase = 0;
+	int digit;
+	Sci_PositionU endPos = startPos + length;
+	int cmdState = BASH_CMD_START;
+	int testExprType = 0;
+	LexAccessor styler(pAccess);
+
+	// Always backtracks to the start of a line that is not a continuation
+	// of the previous line (i.e. start of a bash command segment)
+	Sci_Position ln = styler.GetLine(startPos);
+	if (ln > 0 && startPos == static_cast<Sci_PositionU>(styler.LineStart(ln)))
+		ln--;
+	for (;;) {
+		startPos = styler.LineStart(ln);
+		if (ln == 0 || styler.GetLineState(ln) == BASH_CMD_START)
+			break;
+		ln--;
+	}
+	initStyle = SCE_SH_DEFAULT;
+
+	StyleContext sc(startPos, endPos - startPos, initStyle, styler);
+
+	for (; sc.More(); sc.Forward()) {
+
+		// handle line continuation, updates per-line stored state
+		if (sc.atLineStart) {
+			ln = styler.GetLine(sc.currentPos);
+			if (sc.state == SCE_SH_STRING
+			 || sc.state == SCE_SH_BACKTICKS
+			 || sc.state == SCE_SH_CHARACTER
+			 || sc.state == SCE_SH_HERE_Q
+			 || sc.state == SCE_SH_COMMENTLINE
+			 || sc.state == SCE_SH_PARAM) {
+				// force backtrack while retaining cmdState
+				styler.SetLineState(ln, BASH_CMD_BODY);
+			} else {
+				if (ln > 0) {
+					if ((sc.GetRelative(-3) == '\\' && sc.GetRelative(-2) == '\r' && sc.chPrev == '\n')
+					 || sc.GetRelative(-2) == '\\') {	// handle '\' line continuation
+						// retain last line's state
+					} else
+						cmdState = BASH_CMD_START;
+				}
+				styler.SetLineState(ln, cmdState);
+			}
+		}
+
+		// controls change of cmdState at the end of a non-whitespace element
+		// states BODY|TEST|ARITH persist until the end of a command segment
+		// state WORD persist, but ends with 'in' or 'do' construct keywords
+		int cmdStateNew = BASH_CMD_BODY;
+		if (cmdState == BASH_CMD_TEST || cmdState == BASH_CMD_ARITH || cmdState == BASH_CMD_WORD)
+			cmdStateNew = cmdState;
+		int stylePrev = sc.state;
+
+		// Determine if the current state should terminate.
+		switch (sc.state) {
+			case SCE_SH_OPERATOR:
+				sc.SetState(SCE_SH_DEFAULT);
+				if (cmdState == BASH_CMD_DELIM)		// if command delimiter, start new command
+					cmdStateNew = BASH_CMD_START;
+				else if (sc.chPrev == '\\')			// propagate command state if line continued
+					cmdStateNew = cmdState;
+				break;
+			case SCE_SH_WORD:
+				// "." never used in Bash variable names but used in file names
+				if (!setWord.Contains(sc.ch)) {
+					char s[500];
+					char s2[10];
+					sc.GetCurrent(s, sizeof(s));
+					int identifierStyle = SCE_SH_IDENTIFIER;
+					int subStyle = classifierIdentifiers.ValueFor(s);
+					if (subStyle >= 0) {
+						identifierStyle = subStyle;
+					}
+					// allow keywords ending in a whitespace or command delimiter
+					s2[0] = static_cast<char>(sc.ch);
+					s2[1] = '\0';
+					bool keywordEnds = IsASpace(sc.ch) || cmdDelimiter.InList(s2);
+					// 'in' or 'do' may be construct keywords
+					if (cmdState == BASH_CMD_WORD) {
+						if (strcmp(s, "in") == 0 && keywordEnds)
+							cmdStateNew = BASH_CMD_BODY;
+						else if (strcmp(s, "do") == 0 && keywordEnds)
+							cmdStateNew = BASH_CMD_START;
+						else
+							sc.ChangeState(identifierStyle);
+						sc.SetState(SCE_SH_DEFAULT);
+						break;
+					}
+					// a 'test' keyword starts a test expression
+					if (strcmp(s, "test") == 0) {
+						if (cmdState == BASH_CMD_START && keywordEnds) {
+							cmdStateNew = BASH_CMD_TEST;
+							testExprType = 0;
+						} else
+							sc.ChangeState(identifierStyle);
+					}
+					// detect bash construct keywords
+					else if (bashStruct.InList(s)) {
+						if (cmdState == BASH_CMD_START && keywordEnds)
+							cmdStateNew = BASH_CMD_START;
+						else
+							sc.ChangeState(identifierStyle);
+					}
+					// 'for'|'case'|'select' needs 'in'|'do' to be highlighted later
+					else if (bashStruct_in.InList(s)) {
+						if (cmdState == BASH_CMD_START && keywordEnds)
+							cmdStateNew = BASH_CMD_WORD;
+						else
+							sc.ChangeState(identifierStyle);
+					}
+					// disambiguate option items and file test operators
+					else if (s[0] == '-') {
+						if (cmdState != BASH_CMD_TEST)
+							sc.ChangeState(identifierStyle);
+					}
+					// disambiguate keywords and identifiers
+					else if (cmdState != BASH_CMD_START
+						  || !(keywords.InList(s) && keywordEnds)) {
+						sc.ChangeState(identifierStyle);
+					}
+					sc.SetState(SCE_SH_DEFAULT);
+				}
+				break;
+			case SCE_SH_IDENTIFIER:
+				if (sc.chPrev == '\\' || !setWord.Contains(sc.ch) ||
+					  (cmdState == BASH_CMD_ARITH && !setWordStart.Contains(sc.ch))) {
+					char s[500];
+					sc.GetCurrent(s, sizeof(s));
+					int subStyle = classifierIdentifiers.ValueFor(s);
+					if (subStyle >= 0) {
+						sc.ChangeState(subStyle);
+					}
+					if (sc.chPrev == '\\') {	// for escaped chars
+						sc.ForwardSetState(SCE_SH_DEFAULT);
+					} else {
+						sc.SetState(SCE_SH_DEFAULT);
+					}
+				}
+				break;
+			case SCE_SH_NUMBER:
+				digit = translateBashDigit(sc.ch);
+				if (numBase == BASH_BASE_DECIMAL) {
+					if (sc.ch == '#') {
+						char s[10];
+						sc.GetCurrent(s, sizeof(s));
+						numBase = getBashNumberBase(s);
+						if (numBase != BASH_BASE_ERROR)
+							break;
+					} else if (IsADigit(sc.ch))
+						break;
+				} else if (numBase == BASH_BASE_HEX) {
+					if (IsADigit(sc.ch, 16))
+						break;
+#ifdef PEDANTIC_OCTAL
+				} else if (numBase == BASH_BASE_OCTAL ||
+						   numBase == BASH_BASE_OCTAL_ERROR) {
+					if (digit <= 7)
+						break;
+					if (digit <= 9) {
+						numBase = BASH_BASE_OCTAL_ERROR;
+						break;
+					}
+#endif
+				} else if (numBase == BASH_BASE_ERROR) {
+					if (digit <= 9)
+						break;
+				} else {	// DD#DDDD number style handling
+					if (digit != BASH_BASE_ERROR) {
+						if (numBase <= 36) {
+							// case-insensitive if base<=36
+							if (digit >= 36) digit -= 26;
+						}
+						if (digit < numBase)
+							break;
+						if (digit <= 9) {
+							numBase = BASH_BASE_ERROR;
+							break;
+						}
+					}
+				}
+				// fallthrough when number is at an end or error
+				if (numBase == BASH_BASE_ERROR
+#ifdef PEDANTIC_OCTAL
+					|| numBase == BASH_BASE_OCTAL_ERROR
+#endif
+				) {
+					sc.ChangeState(SCE_SH_ERROR);
+				}
+				sc.SetState(SCE_SH_DEFAULT);
+				break;
+			case SCE_SH_COMMENTLINE:
+				if (sc.atLineEnd && sc.chPrev != '\\') {
+					sc.SetState(SCE_SH_DEFAULT);
+				}
+				break;
+			case SCE_SH_HERE_DELIM:
+				// From Bash info:
+				// ---------------
+				// Specifier format is: <<[-]WORD
+				// Optional '-' is for removal of leading tabs from here-doc.
+				// Whitespace acceptable after <<[-] operator
+				//
+				if (HereDoc.State == 0) { // '<<' encountered
+					HereDoc.Quote = sc.chNext;
+					HereDoc.Quoted = false;
+					HereDoc.DelimiterLength = 0;
+					HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0';
+					if (sc.chNext == '\'' || sc.chNext == '\"') {	// a quoted here-doc delimiter (' or ")
+						sc.Forward();
+						HereDoc.Quoted = true;
+						HereDoc.State = 1;
+					} else if (setHereDoc.Contains(sc.chNext) ||
+					           (sc.chNext == '=' && cmdState != BASH_CMD_ARITH)) {
+						// an unquoted here-doc delimiter, no special handling
+						HereDoc.State = 1;
+					} else if (sc.chNext == '<') {	// HERE string <<<
+						sc.Forward();
+						sc.ForwardSetState(SCE_SH_DEFAULT);
+					} else if (IsASpace(sc.chNext)) {
+						// eat whitespace
+					} else if (setLeftShift.Contains(sc.chNext) ||
+					           (sc.chNext == '=' && cmdState == BASH_CMD_ARITH)) {
+						// left shift <<$var or <<= cases
+						sc.ChangeState(SCE_SH_OPERATOR);
+						sc.ForwardSetState(SCE_SH_DEFAULT);
+					} else {
+						// symbols terminates; deprecated zero-length delimiter
+						HereDoc.State = 1;
+					}
+				} else if (HereDoc.State == 1) { // collect the delimiter
+					// * if single quoted, there's no escape
+					// * if double quoted, there are \\ and \" escapes
+					if ((HereDoc.Quote == '\'' && sc.ch != HereDoc.Quote) ||
+					    (HereDoc.Quoted && sc.ch != HereDoc.Quote && sc.ch != '\\') ||
+					    (HereDoc.Quote != '\'' && sc.chPrev == '\\') ||
+					    (setHereDoc2.Contains(sc.ch))) {
+						HereDoc.Append(sc.ch);
+					} else if (HereDoc.Quoted && sc.ch == HereDoc.Quote) {	// closing quote => end of delimiter
+						sc.ForwardSetState(SCE_SH_DEFAULT);
+					} else if (sc.ch == '\\') {
+						if (HereDoc.Quoted && sc.chNext != HereDoc.Quote && sc.chNext != '\\') {
+							// in quoted prefixes only \ and the quote eat the escape
+							HereDoc.Append(sc.ch);
+						} else {
+							// skip escape prefix
+						}
+					} else if (!HereDoc.Quoted) {
+						sc.SetState(SCE_SH_DEFAULT);
+					}
+					if (HereDoc.DelimiterLength >= HERE_DELIM_MAX - 1) {	// force blowup
+						sc.SetState(SCE_SH_ERROR);
+						HereDoc.State = 0;
+					}
+				}
+				break;
+			case SCE_SH_HERE_Q:
+				// HereDoc.State == 2
+				if (sc.atLineStart) {
+					sc.SetState(SCE_SH_HERE_Q);
+					int prefixws = 0;
+					while (sc.ch == '\t' && !sc.atLineEnd) {	// tabulation prefix
+						sc.Forward();
+						prefixws++;
+					}
+					if (prefixws > 0)
+						sc.SetState(SCE_SH_HERE_Q);
+					while (!sc.atLineEnd) {
+						sc.Forward();
+					}
+					char s[HERE_DELIM_MAX];
+					sc.GetCurrent(s, sizeof(s));
+					if (sc.LengthCurrent() == 0) {  // '' or "" delimiters
+						if ((prefixws == 0 || HereDoc.Indent) &&
+							HereDoc.Quoted && HereDoc.DelimiterLength == 0)
+							sc.SetState(SCE_SH_DEFAULT);
+						break;
+					}
+					if (s[strlen(s) - 1] == '\r')
+						s[strlen(s) - 1] = '\0';
+					if (strcmp(HereDoc.Delimiter, s) == 0) {
+						if ((prefixws == 0) ||	// indentation rule
+							(prefixws > 0 && HereDoc.Indent)) {
+							sc.SetState(SCE_SH_DEFAULT);
+							break;
+						}
+					}
+				}
+				break;
+			case SCE_SH_SCALAR:	// variable names
+				if (!setParam.Contains(sc.ch)) {
+					char s[500];
+					sc.GetCurrent(s, sizeof(s));
+					int subStyle = classifierScalars.ValueFor(&s[1]); // skip the $
+					if (subStyle >= 0) {
+						sc.ChangeState(subStyle);
+					}
+					if (sc.LengthCurrent() == 1) {
+						// Special variable: $(, $_ etc.
+						sc.ForwardSetState(SCE_SH_DEFAULT);
+					} else {
+						sc.SetState(SCE_SH_DEFAULT);
+					}
+				}
+				break;
+			case SCE_SH_STRING:	// delimited styles, can nest
+			case SCE_SH_BACKTICKS:
+				if (sc.ch == '\\' && QuoteStack.Up != '\\') {
+					if (QuoteStack.Style != BASH_DELIM_LITERAL)
+						sc.Forward();
+				} else if (sc.ch == QuoteStack.Down) {
+					QuoteStack.Count--;
+					if (QuoteStack.Count == 0) {
+						if (QuoteStack.Depth > 0) {
+							QuoteStack.Pop();
+						} else
+							sc.ForwardSetState(SCE_SH_DEFAULT);
+					}
+				} else if (sc.ch == QuoteStack.Up) {
+					QuoteStack.Count++;
+				} else {
+					if (QuoteStack.Style == BASH_DELIM_STRING ||
+						QuoteStack.Style == BASH_DELIM_LSTRING
+					) {	// do nesting for "string", $"locale-string"
+						if (sc.ch == '`') {
+							QuoteStack.Push(sc.ch, BASH_DELIM_BACKTICK);
+						} else if (sc.ch == '$' && sc.chNext == '(') {
+							sc.Forward();
+							QuoteStack.Push(sc.ch, BASH_DELIM_COMMAND);
+						}
+					} else if (QuoteStack.Style == BASH_DELIM_COMMAND ||
+							   QuoteStack.Style == BASH_DELIM_BACKTICK
+					) {	// do nesting for $(command), `command`
+						if (sc.ch == '\'') {
+							QuoteStack.Push(sc.ch, BASH_DELIM_LITERAL);
+						} else if (sc.ch == '\"') {
+							QuoteStack.Push(sc.ch, BASH_DELIM_STRING);
+						} else if (sc.ch == '`') {
+							QuoteStack.Push(sc.ch, BASH_DELIM_BACKTICK);
+						} else if (sc.ch == '$') {
+							if (sc.chNext == '\'') {
+								sc.Forward();
+								QuoteStack.Push(sc.ch, BASH_DELIM_CSTRING);
+							} else if (sc.chNext == '\"') {
+								sc.Forward();
+								QuoteStack.Push(sc.ch, BASH_DELIM_LSTRING);
+							} else if (sc.chNext == '(') {
+								sc.Forward();
+								QuoteStack.Push(sc.ch, BASH_DELIM_COMMAND);
+							}
+						}
+					}
+				}
+				break;
+			case SCE_SH_PARAM: // ${parameter}
+				if (sc.ch == '\\' && Quote.Up != '\\') {
+					sc.Forward();
+				} else if (sc.ch == Quote.Down) {
+					Quote.Count--;
+					if (Quote.Count == 0) {
+						sc.ForwardSetState(SCE_SH_DEFAULT);
+					}
+				} else if (sc.ch == Quote.Up) {
+					Quote.Count++;
+				}
+				break;
+			case SCE_SH_CHARACTER: // singly-quoted strings
+				if (sc.ch == Quote.Down) {
+					Quote.Count--;
+					if (Quote.Count == 0) {
+						sc.ForwardSetState(SCE_SH_DEFAULT);
+					}
+				}
+				break;
+		}
+
+		// Must check end of HereDoc state 1 before default state is handled
+		if (HereDoc.State == 1 && sc.atLineEnd) {
+			// Begin of here-doc (the line after the here-doc delimiter):
+			// Lexically, the here-doc starts from the next line after the >>, but the
+			// first line of here-doc seem to follow the style of the last EOL sequence
+			HereDoc.State = 2;
+			if (HereDoc.Quoted) {
+				if (sc.state == SCE_SH_HERE_DELIM) {
+					// Missing quote at end of string! Syntax error in bash 4.3
+					// Mark this bit as an error, do not colour any here-doc
+					sc.ChangeState(SCE_SH_ERROR);
+					sc.SetState(SCE_SH_DEFAULT);
+				} else {
+					// HereDoc.Quote always == '\''
+					sc.SetState(SCE_SH_HERE_Q);
+				}
+			} else if (HereDoc.DelimiterLength == 0) {
+				// no delimiter, illegal (but '' and "" are legal)
+				sc.ChangeState(SCE_SH_ERROR);
+				sc.SetState(SCE_SH_DEFAULT);
+			} else {
+				sc.SetState(SCE_SH_HERE_Q);
+			}
+		}
+
+		// update cmdState about the current command segment
+		if (stylePrev != SCE_SH_DEFAULT && sc.state == SCE_SH_DEFAULT) {
+			cmdState = cmdStateNew;
+		}
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_SH_DEFAULT) {
+			if (sc.ch == '\\') {
+				// Bash can escape any non-newline as a literal
+				sc.SetState(SCE_SH_IDENTIFIER);
+				if (sc.chNext == '\r' || sc.chNext == '\n')
+					sc.SetState(SCE_SH_OPERATOR);
+			} else if (IsADigit(sc.ch)) {
+				sc.SetState(SCE_SH_NUMBER);
+				numBase = BASH_BASE_DECIMAL;
+				if (sc.ch == '0') {	// hex,octal
+					if (sc.chNext == 'x' || sc.chNext == 'X') {
+						numBase = BASH_BASE_HEX;
+						sc.Forward();
+					} else if (IsADigit(sc.chNext)) {
+#ifdef PEDANTIC_OCTAL
+						numBase = BASH_BASE_OCTAL;
+#else
+						numBase = BASH_BASE_HEX;
+#endif
+					}
+				}
+			} else if (setWordStart.Contains(sc.ch)) {
+				sc.SetState(SCE_SH_WORD);
+			} else if (sc.ch == '#') {
+				if (stylePrev != SCE_SH_WORD && stylePrev != SCE_SH_IDENTIFIER &&
+					(sc.currentPos == 0 || setMetaCharacter.Contains(sc.chPrev))) {
+					sc.SetState(SCE_SH_COMMENTLINE);
+				} else {
+					sc.SetState(SCE_SH_WORD);
+				}
+				// handle some zsh features within arithmetic expressions only
+				if (cmdState == BASH_CMD_ARITH) {
+					if (sc.chPrev == '[') {	// [#8] [##8] output digit setting
+						sc.SetState(SCE_SH_WORD);
+						if (sc.chNext == '#') {
+							sc.Forward();
+						}
+					} else if (sc.Match("##^") && IsUpperCase(sc.GetRelative(3))) {	// ##^A
+						sc.SetState(SCE_SH_IDENTIFIER);
+						sc.Forward(3);
+					} else if (sc.chNext == '#' && !IsASpace(sc.GetRelative(2))) {	// ##a
+						sc.SetState(SCE_SH_IDENTIFIER);
+						sc.Forward(2);
+					} else if (setWordStart.Contains(sc.chNext)) {	// #name
+						sc.SetState(SCE_SH_IDENTIFIER);
+					}
+				}
+			} else if (sc.ch == '\"') {
+				sc.SetState(SCE_SH_STRING);
+				QuoteStack.Start(sc.ch, BASH_DELIM_STRING);
+			} else if (sc.ch == '\'') {
+				sc.SetState(SCE_SH_CHARACTER);
+				Quote.Start(sc.ch);
+			} else if (sc.ch == '`') {
+				sc.SetState(SCE_SH_BACKTICKS);
+				QuoteStack.Start(sc.ch, BASH_DELIM_BACKTICK);
+			} else if (sc.ch == '$') {
+				if (sc.Match("$((")) {
+					sc.SetState(SCE_SH_OPERATOR);	// handle '((' later
+					continue;
+				}
+				sc.SetState(SCE_SH_SCALAR);
+				sc.Forward();
+				if (sc.ch == '{') {
+					sc.ChangeState(SCE_SH_PARAM);
+					Quote.Start(sc.ch);
+				} else if (sc.ch == '\'') {
+					sc.ChangeState(SCE_SH_STRING);
+					QuoteStack.Start(sc.ch, BASH_DELIM_CSTRING);
+				} else if (sc.ch == '"') {
+					sc.ChangeState(SCE_SH_STRING);
+					QuoteStack.Start(sc.ch, BASH_DELIM_LSTRING);
+				} else if (sc.ch == '(') {
+					sc.ChangeState(SCE_SH_BACKTICKS);
+					QuoteStack.Start(sc.ch, BASH_DELIM_COMMAND);
+				} else if (sc.ch == '`') {	// $` seen in a configure script, valid?
+					sc.ChangeState(SCE_SH_BACKTICKS);
+					QuoteStack.Start(sc.ch, BASH_DELIM_BACKTICK);
+				} else {
+					continue;	// scalar has no delimiter pair
+				}
+			} else if (sc.Match('<', '<')) {
+				sc.SetState(SCE_SH_HERE_DELIM);
+				HereDoc.State = 0;
+				if (sc.GetRelative(2) == '-') {	// <<- indent case
+					HereDoc.Indent = true;
+					sc.Forward();
+				} else {
+					HereDoc.Indent = false;
+				}
+			} else if (sc.ch == '-'	&&	// one-char file test operators
+					   setSingleCharOp.Contains(sc.chNext) &&
+					   !setWord.Contains(sc.GetRelative(2)) &&
+					   IsASpace(sc.chPrev)) {
+				sc.SetState(SCE_SH_WORD);
+				sc.Forward();
+			} else if (setBashOperator.Contains(sc.ch)) {
+				char s[10];
+				bool isCmdDelim = false;
+				sc.SetState(SCE_SH_OPERATOR);
+				// globs have no whitespace, do not appear in arithmetic expressions
+				if (cmdState != BASH_CMD_ARITH && sc.ch == '(' && sc.chNext != '(') {
+					int i = GlobScan(sc);
+					if (i > 1) {
+						sc.SetState(SCE_SH_IDENTIFIER);
+						sc.Forward(i);
+						continue;
+					}
+				}
+				// handle opening delimiters for test/arithmetic expressions - ((,[[,[
+				if (cmdState == BASH_CMD_START
+				 || cmdState == BASH_CMD_BODY) {
+					if (sc.Match('(', '(')) {
+						cmdState = BASH_CMD_ARITH;
+						sc.Forward();
+					} else if (sc.Match('[', '[') && IsASpace(sc.GetRelative(2))) {
+						cmdState = BASH_CMD_TEST;
+						testExprType = 1;
+						sc.Forward();
+					} else if (sc.ch == '[' && IsASpace(sc.chNext)) {
+						cmdState = BASH_CMD_TEST;
+						testExprType = 2;
+					}
+				}
+				// special state -- for ((x;y;z)) in ... looping
+				if (cmdState == BASH_CMD_WORD && sc.Match('(', '(')) {
+					cmdState = BASH_CMD_ARITH;
+					sc.Forward();
+					continue;
+				}
+				// handle command delimiters in command START|BODY|WORD state, also TEST if 'test'
+				if (cmdState == BASH_CMD_START
+				 || cmdState == BASH_CMD_BODY
+				 || cmdState == BASH_CMD_WORD
+				 || (cmdState == BASH_CMD_TEST && testExprType == 0)) {
+					s[0] = static_cast<char>(sc.ch);
+					if (setBashOperator.Contains(sc.chNext)) {
+						s[1] = static_cast<char>(sc.chNext);
+						s[2] = '\0';
+						isCmdDelim = cmdDelimiter.InList(s);
+						if (isCmdDelim)
+							sc.Forward();
+					}
+					if (!isCmdDelim) {
+						s[1] = '\0';
+						isCmdDelim = cmdDelimiter.InList(s);
+					}
+					if (isCmdDelim) {
+						cmdState = BASH_CMD_DELIM;
+						continue;
+					}
+				}
+				// handle closing delimiters for test/arithmetic expressions - )),]],]
+				if (cmdState == BASH_CMD_ARITH && sc.Match(')', ')')) {
+					cmdState = BASH_CMD_BODY;
+					sc.Forward();
+				} else if (cmdState == BASH_CMD_TEST && IsASpace(sc.chPrev)) {
+					if (sc.Match(']', ']') && testExprType == 1) {
+						sc.Forward();
+						cmdState = BASH_CMD_BODY;
+					} else if (sc.ch == ']' && testExprType == 2) {
+						cmdState = BASH_CMD_BODY;
+					}
+				}
+			}
+		}// sc.state
+	}
+	sc.Complete();
+	if (sc.state == SCE_SH_HERE_Q) {
+		styler.ChangeLexerState(sc.currentPos, styler.Length());
+	}
+	sc.Complete();
+}
+
+void SCI_METHOD LexerBash::Fold(Sci_PositionU startPos, Sci_Position length, int, IDocument *pAccess) {
+	if(!options.fold)
+		return;
+
+	LexAccessor styler(pAccess);
+
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	int skipHereCh = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
+	int levelCurrent = levelPrev;
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	char word[8] = { '\0' }; // we're not interested in long words anyway
+	unsigned int wordlen = 0;
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+		// Comment folding
+		if (options.foldComment && atEOL && IsCommentLine(lineCurrent, styler))
+		{
+			if (!IsCommentLine(lineCurrent - 1, styler)
+				&& IsCommentLine(lineCurrent + 1, styler))
+				levelCurrent++;
+			else if (IsCommentLine(lineCurrent - 1, styler)
+					 && !IsCommentLine(lineCurrent + 1, styler))
+				levelCurrent--;
+		}
+		if (style == SCE_SH_WORD) {
+			if ((wordlen + 1) < sizeof(word))
+				word[wordlen++] = ch;
+			if (styleNext != style) {
+				word[wordlen] = '\0';
+				wordlen = 0;
+				if (strcmp(word, "if") == 0 || strcmp(word, "case") == 0 || strcmp(word, "do") == 0) {
+					levelCurrent++;
+				} else if (strcmp(word, "fi") == 0 || strcmp(word, "esac") == 0 || strcmp(word, "done") == 0) {
+					levelCurrent--;
+				}
+			}
+		}
+		if (style == SCE_SH_OPERATOR) {
+			if (ch == '{') {
+				levelCurrent++;
+			} else if (ch == '}') {
+				levelCurrent--;
+			}
+		}
+		// Here Document folding
+		if (style == SCE_SH_HERE_DELIM) {
+			if (ch == '<' && chNext == '<') {
+				if (styler.SafeGetCharAt(i + 2) == '<') {
+					skipHereCh = 1;
+				} else {
+					if (skipHereCh == 0) {
+						levelCurrent++;
+					} else {
+						skipHereCh = 0;
+					}
+				}
+			}
+		} else if (style == SCE_SH_HERE_Q && styler.StyleAt(i+1) == SCE_SH_DEFAULT) {
+			levelCurrent--;
+		}
+		if (atEOL) {
+			int lev = levelPrev;
+			if (visibleChars == 0 && options.foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if ((levelCurrent > levelPrev) && (visibleChars > 0))
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			levelPrev = levelCurrent;
+			visibleChars = 0;
+		}
+		if (!isspacechar(ch))
+			visibleChars++;
+	}
+	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
+	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
+	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
+}
+
+LexerModule lmBash(SCLEX_BASH, LexerBash::LexerFactoryBash, "bash", bashWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexBasic.cxx b/Pythonwin/Scintilla/lexers/LexBasic.cxx
new file mode 100644
index 000000000..e9004b1a1
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexBasic.cxx
@@ -0,0 +1,570 @@
+// Scintilla source code edit control
+/** @file LexBasic.cxx
+ ** Lexer for BlitzBasic and PureBasic.
+ ** Converted to lexer object and added further folding features/properties by "Udo Lechner" <dlchnr(at)gmx(dot)net>
+ **/
+// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+// This tries to be a unified Lexer/Folder for all the BlitzBasic/BlitzMax/PurBasic basics
+// and derivatives. Once they diverge enough, might want to split it into multiple
+// lexers for more code clearity.
+//
+// Mail me (elias <at> users <dot> sf <dot> net) for any bugs.
+
+// Folding only works for simple things like functions or types.
+
+// You may want to have a look at my ctags lexer as well, if you additionally to coloring
+// and folding need to extract things like label tags in your editor.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+#include <map>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+/* Bits:
+ * 1  - whitespace
+ * 2  - operator
+ * 4  - identifier
+ * 8  - decimal digit
+ * 16 - hex digit
+ * 32 - bin digit
+ * 64 - letter
+ */
+static int character_classification[128] =
+{
+		0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  0,  0,  1,  0,  0,
+		0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+		1,  2,  0,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  10, 2,
+	 60, 60, 28, 28, 28, 28, 28, 28, 28, 28,  2,  2,  2,  2,  2,  2,
+		2, 84, 84, 84, 84, 84, 84, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+	 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,  2,  2,  2,  2, 68,
+		2, 84, 84, 84, 84, 84, 84, 68, 68, 68, 68, 68, 68, 68, 68, 68,
+	 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,  2,  2,  2,  2,  0
+};
+
+static bool IsSpace(int c) {
+	return c < 128 && (character_classification[c] & 1);
+}
+
+static bool IsOperator(int c) {
+	return c < 128 && (character_classification[c] & 2);
+}
+
+static bool IsIdentifier(int c) {
+	return c < 128 && (character_classification[c] & 4);
+}
+
+static bool IsDigit(int c) {
+	return c < 128 && (character_classification[c] & 8);
+}
+
+static bool IsHexDigit(int c) {
+	return c < 128 && (character_classification[c] & 16);
+}
+
+static bool IsBinDigit(int c) {
+	return c < 128 && (character_classification[c] & 32);
+}
+
+static bool IsLetter(int c) {
+	return c < 128 && (character_classification[c] & 64);
+}
+
+static int LowerCase(int c)
+{
+	if (c >= 'A' && c <= 'Z')
+		return 'a' + c - 'A';
+	return c;
+}
+
+static int CheckBlitzFoldPoint(char const *token, int &level) {
+	if (!strcmp(token, "function") ||
+		!strcmp(token, "type")) {
+		level |= SC_FOLDLEVELHEADERFLAG;
+		return 1;
+	}
+	if (!strcmp(token, "end function") ||
+		!strcmp(token, "end type")) {
+		return -1;
+	}
+	return 0;
+}
+
+static int CheckPureFoldPoint(char const *token, int &level) {
+	if (!strcmp(token, "procedure") ||
+		!strcmp(token, "enumeration") ||
+		!strcmp(token, "interface") ||
+		!strcmp(token, "structure")) {
+		level |= SC_FOLDLEVELHEADERFLAG;
+		return 1;
+	}
+	if (!strcmp(token, "endprocedure") ||
+		!strcmp(token, "endenumeration") ||
+		!strcmp(token, "endinterface") ||
+		!strcmp(token, "endstructure")) {
+		return -1;
+	}
+	return 0;
+}
+
+static int CheckFreeFoldPoint(char const *token, int &level) {
+	if (!strcmp(token, "function") ||
+		!strcmp(token, "sub") ||
+		!strcmp(token, "enum") ||
+		!strcmp(token, "type") ||
+		!strcmp(token, "union") ||
+		!strcmp(token, "property") ||
+		!strcmp(token, "destructor") ||
+		!strcmp(token, "constructor")) {
+		level |= SC_FOLDLEVELHEADERFLAG;
+		return 1;
+	}
+	if (!strcmp(token, "end function") ||
+		!strcmp(token, "end sub") ||
+		!strcmp(token, "end enum") ||
+		!strcmp(token, "end type") ||
+		!strcmp(token, "end union") ||
+		!strcmp(token, "end property") ||
+		!strcmp(token, "end destructor") ||
+		!strcmp(token, "end constructor")) {
+		return -1;
+	}
+	return 0;
+}
+
+// An individual named option for use in an OptionSet
+
+// Options used for LexerBasic
+struct OptionsBasic {
+	bool fold;
+	bool foldSyntaxBased;
+	bool foldCommentExplicit;
+	std::string foldExplicitStart;
+	std::string foldExplicitEnd;
+	bool foldExplicitAnywhere;
+	bool foldCompact;
+	OptionsBasic() {
+		fold = false;
+		foldSyntaxBased = true;
+		foldCommentExplicit = false;
+		foldExplicitStart = "";
+		foldExplicitEnd   = "";
+		foldExplicitAnywhere = false;
+		foldCompact = true;
+	}
+};
+
+static const char * const blitzbasicWordListDesc[] = {
+	"BlitzBasic Keywords",
+	"user1",
+	"user2",
+	"user3",
+	0
+};
+
+static const char * const purebasicWordListDesc[] = {
+	"PureBasic Keywords",
+	"PureBasic PreProcessor Keywords",
+	"user defined 1",
+	"user defined 2",
+	0
+};
+
+static const char * const freebasicWordListDesc[] = {
+	"FreeBasic Keywords",
+	"FreeBasic PreProcessor Keywords",
+	"user defined 1",
+	"user defined 2",
+	0
+};
+
+struct OptionSetBasic : public OptionSet<OptionsBasic> {
+	OptionSetBasic(const char * const wordListDescriptions[]) {
+		DefineProperty("fold", &OptionsBasic::fold);
+
+		DefineProperty("fold.basic.syntax.based", &OptionsBasic::foldSyntaxBased,
+			"Set this property to 0 to disable syntax based folding.");
+
+		DefineProperty("fold.basic.comment.explicit", &OptionsBasic::foldCommentExplicit,
+			"This option enables folding explicit fold points when using the Basic lexer. "
+			"Explicit fold points allows adding extra folding by placing a ;{ (BB/PB) or '{ (FB) comment at the start "
+			"and a ;} (BB/PB) or '} (FB) at the end of a section that should be folded.");
+
+		DefineProperty("fold.basic.explicit.start", &OptionsBasic::foldExplicitStart,
+			"The string to use for explicit fold start points, replacing the standard ;{ (BB/PB) or '{ (FB).");
+
+		DefineProperty("fold.basic.explicit.end", &OptionsBasic::foldExplicitEnd,
+			"The string to use for explicit fold end points, replacing the standard ;} (BB/PB) or '} (FB).");
+
+		DefineProperty("fold.basic.explicit.anywhere", &OptionsBasic::foldExplicitAnywhere,
+			"Set this property to 1 to enable explicit fold points anywhere, not just in line comments.");
+
+		DefineProperty("fold.compact", &OptionsBasic::foldCompact);
+
+		DefineWordListSets(wordListDescriptions);
+	}
+};
+
+class LexerBasic : public DefaultLexer {
+	char comment_char;
+	int (*CheckFoldPoint)(char const *, int &);
+	WordList keywordlists[4];
+	OptionsBasic options;
+	OptionSetBasic osBasic;
+public:
+	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) {
+	}
+	virtual ~LexerBasic() {
+	}
+	void SCI_METHOD Release() override {
+		delete this;
+	}
+	int SCI_METHOD Version() const override {
+		return lvRelease5;
+	}
+	const char * SCI_METHOD PropertyNames() override {
+		return osBasic.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return osBasic.PropertyType(name);
+	}
+	const char * SCI_METHOD DescribeProperty(const char *name) override {
+		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();
+	}
+	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 *) override {
+		return 0;
+	}
+	static ILexer5 *LexerFactoryBlitzBasic() {
+		return new LexerBasic("blitzbasic", SCLEX_BLITZBASIC, ';', CheckBlitzFoldPoint, blitzbasicWordListDesc);
+	}
+	static ILexer5 *LexerFactoryPureBasic() {
+		return new LexerBasic("purebasic", SCLEX_PUREBASIC, ';', CheckPureFoldPoint, purebasicWordListDesc);
+	}
+	static ILexer5 *LexerFactoryFreeBasic() {
+		return new LexerBasic("freebasic", SCLEX_FREEBASIC, '\'', CheckFreeFoldPoint, freebasicWordListDesc );
+	}
+};
+
+Sci_Position SCI_METHOD LexerBasic::PropertySet(const char *key, const char *val) {
+	if (osBasic.PropertySet(&options, key, val)) {
+		return 0;
+	}
+	return -1;
+}
+
+Sci_Position SCI_METHOD LexerBasic::WordListSet(int n, const char *wl) {
+	WordList *wordListN = 0;
+	switch (n) {
+	case 0:
+		wordListN = &keywordlists[0];
+		break;
+	case 1:
+		wordListN = &keywordlists[1];
+		break;
+	case 2:
+		wordListN = &keywordlists[2];
+		break;
+	case 3:
+		wordListN = &keywordlists[3];
+		break;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN) {
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+		}
+	}
+	return firstModification;
+}
+
+void SCI_METHOD LexerBasic::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	LexAccessor styler(pAccess);
+
+	bool wasfirst = true, isfirst = true; // true if first token in a line
+	styler.StartAt(startPos);
+	int styleBeforeKeyword = SCE_B_DEFAULT;
+
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	// Can't use sc.More() here else we miss the last character
+	for (; ; sc.Forward()) {
+		if (sc.state == SCE_B_IDENTIFIER) {
+			if (!IsIdentifier(sc.ch)) {
+				// Labels
+				if (wasfirst && sc.Match(':')) {
+					sc.ChangeState(SCE_B_LABEL);
+					sc.ForwardSetState(SCE_B_DEFAULT);
+				} else {
+					char s[100];
+					int kstates[4] = {
+						SCE_B_KEYWORD,
+						SCE_B_KEYWORD2,
+						SCE_B_KEYWORD3,
+						SCE_B_KEYWORD4,
+					};
+					sc.GetCurrentLowered(s, sizeof(s));
+					for (int i = 0; i < 4; i++) {
+						if (keywordlists[i].InList(s)) {
+							sc.ChangeState(kstates[i]);
+						}
+					}
+					// Types, must set them as operator else they will be
+					// matched as number/constant
+					if (sc.Match('.') || sc.Match('$') || sc.Match('%') ||
+						sc.Match('#')) {
+						sc.SetState(SCE_B_OPERATOR);
+					} else {
+						sc.SetState(SCE_B_DEFAULT);
+					}
+				}
+			}
+		} else if (sc.state == SCE_B_OPERATOR) {
+			if (!IsOperator(sc.ch) || sc.Match('#'))
+				sc.SetState(SCE_B_DEFAULT);
+		} else if (sc.state == SCE_B_LABEL) {
+			if (!IsIdentifier(sc.ch))
+				sc.SetState(SCE_B_DEFAULT);
+		} else if (sc.state == SCE_B_CONSTANT) {
+			if (!IsIdentifier(sc.ch))
+				sc.SetState(SCE_B_DEFAULT);
+		} else if (sc.state == SCE_B_NUMBER) {
+			if (!IsDigit(sc.ch))
+				sc.SetState(SCE_B_DEFAULT);
+		} else if (sc.state == SCE_B_HEXNUMBER) {
+			if (!IsHexDigit(sc.ch))
+				sc.SetState(SCE_B_DEFAULT);
+		} else if (sc.state == SCE_B_BINNUMBER) {
+			if (!IsBinDigit(sc.ch))
+				sc.SetState(SCE_B_DEFAULT);
+		} else if (sc.state == SCE_B_STRING) {
+			if (sc.ch == '"') {
+				sc.ForwardSetState(SCE_B_DEFAULT);
+			}
+			if (sc.atLineEnd) {
+				sc.ChangeState(SCE_B_ERROR);
+				sc.SetState(SCE_B_DEFAULT);
+			}
+		} else if (sc.state == SCE_B_COMMENT || sc.state == SCE_B_PREPROCESSOR) {
+			if (sc.atLineEnd) {
+				sc.SetState(SCE_B_DEFAULT);
+			}
+		} else if (sc.state == SCE_B_DOCLINE) {
+			if (sc.atLineEnd) {
+				sc.SetState(SCE_B_DEFAULT);
+			} else if (sc.ch == '\\' || sc.ch == '@') {
+				if (IsLetter(sc.chNext) && sc.chPrev != '\\') {
+					styleBeforeKeyword = sc.state;
+					sc.SetState(SCE_B_DOCKEYWORD);
+				};
+			}
+		} else if (sc.state == SCE_B_DOCKEYWORD) {
+			if (IsSpace(sc.ch)) {
+				sc.SetState(styleBeforeKeyword);
+			}	else if (sc.atLineEnd && styleBeforeKeyword == SCE_B_DOCLINE) {
+				sc.SetState(SCE_B_DEFAULT);
+			}
+		} else if (sc.state == SCE_B_COMMENTBLOCK) {
+			if (sc.Match("\'/")) {
+				sc.Forward();
+				sc.ForwardSetState(SCE_B_DEFAULT);
+			}
+		} else if (sc.state == SCE_B_DOCBLOCK) {
+			if (sc.Match("\'/")) {
+				sc.Forward();
+				sc.ForwardSetState(SCE_B_DEFAULT);
+			} else if (sc.ch == '\\' || sc.ch == '@') {
+				if (IsLetter(sc.chNext) && sc.chPrev != '\\') {
+					styleBeforeKeyword = sc.state;
+					sc.SetState(SCE_B_DOCKEYWORD);
+				};
+			}
+		}
+
+		if (sc.atLineStart)
+			isfirst = true;
+
+		if (sc.state == SCE_B_DEFAULT || sc.state == SCE_B_ERROR) {
+			if (isfirst && sc.Match('.') && comment_char != '\'') {
+					sc.SetState(SCE_B_LABEL);
+			} else if (isfirst && sc.Match('#')) {
+				wasfirst = isfirst;
+				sc.SetState(SCE_B_IDENTIFIER);
+			} else if (sc.Match(comment_char)) {
+				// Hack to make deprecated QBASIC '$Include show
+				// up in freebasic with SCE_B_PREPROCESSOR.
+				if (comment_char == '\'' && sc.Match(comment_char, '$'))
+					sc.SetState(SCE_B_PREPROCESSOR);
+				else if (sc.Match("\'*") || sc.Match("\'!")) {
+					sc.SetState(SCE_B_DOCLINE);
+				} else {
+					sc.SetState(SCE_B_COMMENT);
+				}
+			} else if (sc.Match("/\'")) {
+				if (sc.Match("/\'*") || sc.Match("/\'!")) {	// Support of gtk-doc/Doxygen doc. style
+					sc.SetState(SCE_B_DOCBLOCK);
+				} else {
+					sc.SetState(SCE_B_COMMENTBLOCK);
+				}
+				sc.Forward();	// Eat the ' so it isn't used for the end of the comment
+			} else if (sc.Match('"')) {
+				sc.SetState(SCE_B_STRING);
+			} else if (IsDigit(sc.ch)) {
+				sc.SetState(SCE_B_NUMBER);
+			} else if (sc.Match('$') || sc.Match("&h") || sc.Match("&H") || sc.Match("&o") || sc.Match("&O")) {
+				sc.SetState(SCE_B_HEXNUMBER);
+			} else if (sc.Match('%') || sc.Match("&b") || sc.Match("&B")) {
+				sc.SetState(SCE_B_BINNUMBER);
+			} else if (sc.Match('#')) {
+				sc.SetState(SCE_B_CONSTANT);
+			} else if (IsOperator(sc.ch)) {
+				sc.SetState(SCE_B_OPERATOR);
+			} else if (IsIdentifier(sc.ch)) {
+				wasfirst = isfirst;
+				sc.SetState(SCE_B_IDENTIFIER);
+			} else if (!IsSpace(sc.ch)) {
+				sc.SetState(SCE_B_ERROR);
+			}
+		}
+
+		if (!IsSpace(sc.ch))
+			isfirst = false;
+
+		if (!sc.More())
+			break;
+	}
+	sc.Complete();
+}
+
+
+void SCI_METHOD LexerBasic::Fold(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, IDocument *pAccess) {
+
+	if (!options.fold)
+		return;
+
+	LexAccessor styler(pAccess);
+
+	Sci_Position line = styler.GetLine(startPos);
+	int level = styler.LevelAt(line);
+	int go = 0, done = 0;
+	Sci_Position endPos = startPos + length;
+	char word[256];
+	int wordlen = 0;
+	const bool userDefinedFoldMarkers = !options.foldExplicitStart.empty() && !options.foldExplicitEnd.empty();
+	int cNext = styler[startPos];
+
+	// Scan for tokens at the start of the line (they may include
+	// whitespace, for tokens like "End Function"
+	for (Sci_Position i = startPos; i < endPos; i++) {
+		int c = cNext;
+		cNext = styler.SafeGetCharAt(i + 1);
+		bool atEOL = (c == '\r' && cNext != '\n') || (c == '\n');
+		if (options.foldSyntaxBased && !done && !go) {
+			if (wordlen) { // are we scanning a token already?
+				word[wordlen] = static_cast<char>(LowerCase(c));
+				if (!IsIdentifier(c)) { // done with token
+					word[wordlen] = '\0';
+					go = CheckFoldPoint(word, level);
+					if (!go) {
+						// Treat any whitespace as single blank, for
+						// things like "End   Function".
+						if (IsSpace(c) && IsIdentifier(word[wordlen - 1])) {
+							word[wordlen] = ' ';
+							if (wordlen < 255)
+								wordlen++;
+						}
+						else // done with this line
+							done = 1;
+					}
+				} else if (wordlen < 255) {
+					wordlen++;
+				}
+			} else { // start scanning at first non-whitespace character
+				if (!IsSpace(c)) {
+					if (IsIdentifier(c)) {
+						word[0] = static_cast<char>(LowerCase(c));
+						wordlen = 1;
+					} else // done with this line
+						done = 1;
+				}
+			}
+		}
+		if (options.foldCommentExplicit && ((styler.StyleAt(i) == SCE_B_COMMENT) || options.foldExplicitAnywhere)) {
+			if (userDefinedFoldMarkers) {
+				if (styler.Match(i, options.foldExplicitStart.c_str())) {
+ 					level |= SC_FOLDLEVELHEADERFLAG;
+					go = 1;
+				} else if (styler.Match(i, options.foldExplicitEnd.c_str())) {
+ 					go = -1;
+ 				}
+			} else {
+				if (c == comment_char) {
+					if (cNext == '{') {
+						level |= SC_FOLDLEVELHEADERFLAG;
+						go = 1;
+					} else if (cNext == '}') {
+						go = -1;
+					}
+				}
+ 			}
+ 		}
+		if (atEOL) { // line end
+			if (!done && wordlen == 0 && options.foldCompact) // line was only space
+				level |= SC_FOLDLEVELWHITEFLAG;
+			if (level != styler.LevelAt(line))
+				styler.SetLevel(line, level);
+			level += go;
+			line++;
+			// reset state
+			wordlen = 0;
+			level &= ~SC_FOLDLEVELHEADERFLAG;
+			level &= ~SC_FOLDLEVELWHITEFLAG;
+			go = 0;
+			done = 0;
+		}
+	}
+}
+
+LexerModule lmBlitzBasic(SCLEX_BLITZBASIC, LexerBasic::LexerFactoryBlitzBasic, "blitzbasic", blitzbasicWordListDesc);
+
+LexerModule lmPureBasic(SCLEX_PUREBASIC, LexerBasic::LexerFactoryPureBasic, "purebasic", purebasicWordListDesc);
+
+LexerModule lmFreeBasic(SCLEX_FREEBASIC, LexerBasic::LexerFactoryFreeBasic, "freebasic", freebasicWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexBatch.cxx b/Pythonwin/Scintilla/lexers/LexBatch.cxx
new file mode 100644
index 000000000..857b60ce6
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexBatch.cxx
@@ -0,0 +1,576 @@
+// Scintilla source code edit control
+/** @file LexBatch.cxx
+ ** Lexer for batch files.
+ **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static bool Is0To9(char ch) {
+	return (ch >= '0') && (ch <= '9');
+}
+
+static bool IsAlphabetic(int ch) {
+	return IsASCII(ch) && isalpha(ch);
+}
+
+static inline bool AtEOL(Accessor &styler, Sci_PositionU i) {
+	return (styler[i] == '\n') ||
+	       ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n'));
+}
+
+// Tests for BATCH Operators
+static bool IsBOperator(char ch) {
+	return (ch == '=') || (ch == '+') || (ch == '>') || (ch == '<') ||
+		(ch == '|') || (ch == '?') || (ch == '*')||
+		(ch == '&') || (ch == '(') || (ch == ')');
+}
+
+// Tests for BATCH Separators
+static bool IsBSeparator(char ch) {
+	return (ch == '\\') || (ch == '.') || (ch == ';') ||
+		(ch == '\"') || (ch == '\'') || (ch == '/');
+}
+
+// Tests for escape character
+static bool IsEscaped(char* wordStr, Sci_PositionU pos) {
+	bool isQoted=false;
+	while (pos>0){
+		pos--;
+		if (wordStr[pos]=='^')
+			isQoted=!isQoted;
+		else
+			break;
+	}
+	return isQoted;
+}
+
+// Tests for quote character
+static bool textQuoted(char *lineBuffer, Sci_PositionU endPos) {
+	char strBuffer[1024];
+	strncpy(strBuffer, lineBuffer, endPos);
+	strBuffer[endPos] = '\0';
+	char *pQuote;
+	pQuote = strchr(strBuffer, '"');
+	bool CurrentStatus = false;
+	while (pQuote != NULL)
+	{
+		if (!IsEscaped(strBuffer, pQuote - strBuffer)) {
+			CurrentStatus = !CurrentStatus;
+		}
+		pQuote = strchr(pQuote + 1, '"');
+	}
+	return CurrentStatus;
+}
+
+static void ColouriseBatchDoc(
+    Sci_PositionU startPos,
+    Sci_Position length,
+    int /*initStyle*/,
+    WordList *keywordlists[],
+    Accessor &styler) {
+	// Always backtracks to the start of a line that is not a continuation
+	// of the previous line
+	if (startPos > 0) {
+		Sci_Position ln = styler.GetLine(startPos); // Current line number
+		while (startPos > 0) {
+			ln--;
+			if ((styler.SafeGetCharAt(startPos-3) == '^' && styler.SafeGetCharAt(startPos-2) == '\r' && styler.SafeGetCharAt(startPos-1) == '\n')
+			|| styler.SafeGetCharAt(startPos-2) == '^') {	// handle '^' line continuation
+				// When the line continuation is found,
+				// set the Start Position to the Start of the previous line
+				length+=startPos-styler.LineStart(ln);
+				startPos=styler.LineStart(ln);
+			}
+			else
+				break;
+		}
+	}
+
+	char lineBuffer[1024];
+
+	styler.StartAt(startPos);
+	styler.StartSegment(startPos);
+	Sci_PositionU linePos = 0;
+	Sci_PositionU startLine = startPos;
+	bool continueProcessing = true;	// Used to toggle Regular Keyword Checking
+	bool isNotAssigned=false; // Used to flag Assignment in Set operation
+
+	for (Sci_PositionU i = startPos; i < startPos + length; i++) {
+		lineBuffer[linePos++] = styler[i];
+		if (AtEOL(styler, i) || (linePos >= sizeof(lineBuffer) - 1) || (i==startPos + length-1)) {
+			// End of line (or of line buffer) (or End of Last Line) met, colourise it
+			lineBuffer[linePos] = '\0';
+			Sci_PositionU lengthLine=linePos;
+			Sci_PositionU endPos=i;
+			Sci_PositionU offset = 0;	// Line Buffer Offset
+			Sci_PositionU cmdLoc;		// External Command / Program Location
+			char wordBuffer[81];		// Word Buffer - large to catch long paths
+			Sci_PositionU wbl;		// Word Buffer Length
+			Sci_PositionU wbo;		// Word Buffer Offset - also Special Keyword Buffer Length
+			WordList &keywords = *keywordlists[0];      // Internal Commands
+			WordList &keywords2 = *keywordlists[1];     // External Commands (optional)
+
+			// CHOICE, ECHO, GOTO, PROMPT and SET have Default Text that may contain Regular Keywords
+			//   Toggling Regular Keyword Checking off improves readability
+			// Other Regular Keywords and External Commands / Programs might also benefit from toggling
+			//   Need a more robust algorithm to properly toggle Regular Keyword Checking
+			bool stopLineProcessing=false;  // Used to stop line processing if Comment or Drive Change found
+			// Special Keywords are those that allow certain characters without whitespace after the command
+			// Examples are: cd. cd\ md. rd. dir| dir> echo: echo. path=
+			// Special Keyword Buffer used to determine if the first n characters is a Keyword
+			char sKeywordBuffer[10];	// Special Keyword Buffer
+			bool sKeywordFound;		// Exit Special Keyword for-loop if found
+
+			// Skip initial spaces
+			while ((offset < lengthLine) && (isspacechar(lineBuffer[offset]))) {
+				offset++;
+			}
+			// Colorize Default Text
+			styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
+			// Set External Command / Program Location
+			cmdLoc = offset;
+
+			// Check for Fake Label (Comment) or Real Label - return if found
+			if (lineBuffer[offset] == ':') {
+				if (lineBuffer[offset + 1] == ':') {
+					// Colorize Fake Label (Comment) - :: is similar to REM, see http://content.techweb.com/winmag/columns/explorer/2000/21.htm
+					styler.ColourTo(endPos, SCE_BAT_COMMENT);
+				} else {
+					// Colorize Real Label
+					styler.ColourTo(endPos, SCE_BAT_LABEL);
+				}
+				stopLineProcessing=true;
+			// Check for Drive Change (Drive Change is internal command) - return if found
+			} else if ((IsAlphabetic(lineBuffer[offset])) &&
+				(lineBuffer[offset + 1] == ':') &&
+				((isspacechar(lineBuffer[offset + 2])) ||
+				(((lineBuffer[offset + 2] == '\\')) &&
+				(isspacechar(lineBuffer[offset + 3]))))) {
+				// Colorize Regular Keyword
+				styler.ColourTo(endPos, SCE_BAT_WORD);
+				stopLineProcessing=true;
+			}
+
+			// Check for Hide Command (@ECHO OFF/ON)
+			if (lineBuffer[offset] == '@') {
+				styler.ColourTo(startLine + offset, SCE_BAT_HIDE);
+				offset++;
+			}
+			// Skip next spaces
+			while ((offset < lengthLine) && (isspacechar(lineBuffer[offset]))) {
+				offset++;
+			}
+
+			// Read remainder of line word-at-a-time or remainder-of-word-at-a-time
+			while (offset < lengthLine  && !stopLineProcessing) {
+				if (offset > startLine) {
+					// Colorize Default Text
+					styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
+				}
+				// Copy word from Line Buffer into Word Buffer
+				wbl = 0;
+				for (; offset < lengthLine && wbl < 80 &&
+						!isspacechar(lineBuffer[offset]); wbl++, offset++) {
+					wordBuffer[wbl] = static_cast<char>(tolower(lineBuffer[offset]));
+				}
+				wordBuffer[wbl] = '\0';
+				wbo = 0;
+
+				// Check for Comment - return if found
+				if ((CompareCaseInsensitive(wordBuffer, "rem") == 0) && continueProcessing) {
+					styler.ColourTo(endPos, SCE_BAT_COMMENT);
+					break;
+				}
+				// Check for Separator
+				if (IsBSeparator(wordBuffer[0])) {
+					// Check for External Command / Program
+					if ((cmdLoc == offset - wbl) &&
+						((wordBuffer[0] == ':') ||
+						(wordBuffer[0] == '\\') ||
+						(wordBuffer[0] == '.'))) {
+						// Reset Offset to re-process remainder of word
+						offset -= (wbl - 1);
+						// Colorize External Command / Program
+						if (!keywords2) {
+							styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
+						} else if (keywords2.InList(wordBuffer)) {
+							styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
+						} else {
+							styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
+						}
+						// Reset External Command / Program Location
+						cmdLoc = offset;
+					} else {
+						// Reset Offset to re-process remainder of word
+						offset -= (wbl - 1);
+						// Colorize Default Text
+						styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
+					}
+				// Check for Regular Keyword in list
+				} else if ((keywords.InList(wordBuffer)) &&
+					(continueProcessing)) {
+					// ECHO, GOTO, PROMPT and SET require no further Regular Keyword Checking
+					if ((CompareCaseInsensitive(wordBuffer, "echo") == 0) ||
+						(CompareCaseInsensitive(wordBuffer, "goto") == 0) ||
+						(CompareCaseInsensitive(wordBuffer, "prompt") == 0)) {
+						continueProcessing = false;
+					}
+					// SET requires additional processing for the assignment operator
+					if (CompareCaseInsensitive(wordBuffer, "set") == 0) {
+						continueProcessing = false;
+						isNotAssigned=true;
+					}
+					// Identify External Command / Program Location for ERRORLEVEL, and EXIST
+					if ((CompareCaseInsensitive(wordBuffer, "errorlevel") == 0) ||
+						(CompareCaseInsensitive(wordBuffer, "exist") == 0)) {
+						// Reset External Command / Program Location
+						cmdLoc = offset;
+						// Skip next spaces
+						while ((cmdLoc < lengthLine) &&
+							(isspacechar(lineBuffer[cmdLoc]))) {
+							cmdLoc++;
+						}
+						// Skip comparison
+						while ((cmdLoc < lengthLine) &&
+							(!isspacechar(lineBuffer[cmdLoc]))) {
+							cmdLoc++;
+						}
+						// Skip next spaces
+						while ((cmdLoc < lengthLine) &&
+							(isspacechar(lineBuffer[cmdLoc]))) {
+							cmdLoc++;
+						}
+					// Identify External Command / Program Location for CALL, DO, LOADHIGH and LH
+					} else if ((CompareCaseInsensitive(wordBuffer, "call") == 0) ||
+						(CompareCaseInsensitive(wordBuffer, "do") == 0) ||
+						(CompareCaseInsensitive(wordBuffer, "loadhigh") == 0) ||
+						(CompareCaseInsensitive(wordBuffer, "lh") == 0)) {
+						// Reset External Command / Program Location
+						cmdLoc = offset;
+						// Skip next spaces
+						while ((cmdLoc < lengthLine) &&
+							(isspacechar(lineBuffer[cmdLoc]))) {
+							cmdLoc++;
+						}
+					}
+					// Colorize Regular keyword
+					styler.ColourTo(startLine + offset - 1, SCE_BAT_WORD);
+					// No need to Reset Offset
+				// Check for Special Keyword in list, External Command / Program, or Default Text
+				} else if ((wordBuffer[0] != '%') &&
+						   (wordBuffer[0] != '!') &&
+					(!IsBOperator(wordBuffer[0])) &&
+					(continueProcessing)) {
+					// Check for Special Keyword
+					//     Affected Commands are in Length range 2-6
+					//     Good that ERRORLEVEL, EXIST, CALL, DO, LOADHIGH, and LH are unaffected
+					sKeywordFound = false;
+					for (Sci_PositionU keywordLength = 2; keywordLength < wbl && keywordLength < 7 && !sKeywordFound; keywordLength++) {
+						wbo = 0;
+						// Copy Keyword Length from Word Buffer into Special Keyword Buffer
+						for (; wbo < keywordLength; wbo++) {
+							sKeywordBuffer[wbo] = static_cast<char>(wordBuffer[wbo]);
+						}
+						sKeywordBuffer[wbo] = '\0';
+						// Check for Special Keyword in list
+						if ((keywords.InList(sKeywordBuffer)) &&
+							((IsBOperator(wordBuffer[wbo])) ||
+							(IsBSeparator(wordBuffer[wbo])))) {
+							sKeywordFound = true;
+							// ECHO requires no further Regular Keyword Checking
+							if (CompareCaseInsensitive(sKeywordBuffer, "echo") == 0) {
+								continueProcessing = false;
+							}
+							// Colorize Special Keyword as Regular Keyword
+							styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_WORD);
+							// Reset Offset to re-process remainder of word
+							offset -= (wbl - wbo);
+						}
+					}
+					// Check for External Command / Program or Default Text
+					if (!sKeywordFound) {
+						wbo = 0;
+						// Check for External Command / Program
+						if (cmdLoc == offset - wbl) {
+							// Read up to %, Operator or Separator
+							while ((wbo < wbl) &&
+								(((wordBuffer[wbo] != '%') &&
+								(wordBuffer[wbo] != '!') &&
+								(!IsBOperator(wordBuffer[wbo])) &&
+								(!IsBSeparator(wordBuffer[wbo]))))) {
+								wbo++;
+							}
+							// Reset External Command / Program Location
+							cmdLoc = offset - (wbl - wbo);
+							// Reset Offset to re-process remainder of word
+							offset -= (wbl - wbo);
+							// CHOICE requires no further Regular Keyword Checking
+							if (CompareCaseInsensitive(wordBuffer, "choice") == 0) {
+								continueProcessing = false;
+							}
+							// Check for START (and its switches) - What follows is External Command \ Program
+							if (CompareCaseInsensitive(wordBuffer, "start") == 0) {
+								// Reset External Command / Program Location
+								cmdLoc = offset;
+								// Skip next spaces
+								while ((cmdLoc < lengthLine) &&
+									(isspacechar(lineBuffer[cmdLoc]))) {
+									cmdLoc++;
+								}
+								// Reset External Command / Program Location if command switch detected
+								if (lineBuffer[cmdLoc] == '/') {
+									// Skip command switch
+									while ((cmdLoc < lengthLine) &&
+										(!isspacechar(lineBuffer[cmdLoc]))) {
+										cmdLoc++;
+									}
+									// Skip next spaces
+									while ((cmdLoc < lengthLine) &&
+										(isspacechar(lineBuffer[cmdLoc]))) {
+										cmdLoc++;
+									}
+								}
+							}
+							// Colorize External Command / Program
+							if (!keywords2) {
+								styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
+							} else if (keywords2.InList(wordBuffer)) {
+								styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
+							} else {
+								styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
+							}
+							// No need to Reset Offset
+						// Check for Default Text
+						} else {
+							// Read up to %, Operator or Separator
+							while ((wbo < wbl) &&
+								(((wordBuffer[wbo] != '%') &&
+								(wordBuffer[wbo] != '!') &&
+								(!IsBOperator(wordBuffer[wbo])) &&
+								(!IsBSeparator(wordBuffer[wbo]))))) {
+								wbo++;
+							}
+							// Colorize Default Text
+							styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_DEFAULT);
+							// Reset Offset to re-process remainder of word
+							offset -= (wbl - wbo);
+						}
+					}
+				// Check for Argument  (%n), Environment Variable (%x...%) or Local Variable (%%a)
+				} else if (wordBuffer[0] == '%') {
+					// Colorize Default Text
+					styler.ColourTo(startLine + offset - 1 - wbl, SCE_BAT_DEFAULT);
+					wbo++;
+					// Search to end of word for second % (can be a long path)
+					while ((wbo < wbl) &&
+						(wordBuffer[wbo] != '%')) {
+						wbo++;
+					}
+					// Check for Argument (%n) or (%*)
+					if (((Is0To9(wordBuffer[1])) || (wordBuffer[1] == '*')) &&
+						(wordBuffer[wbo] != '%')) {
+						// Check for External Command / Program
+						if (cmdLoc == offset - wbl) {
+							cmdLoc = offset - (wbl - 2);
+						}
+						// Colorize Argument
+						styler.ColourTo(startLine + offset - 1 - (wbl - 2), SCE_BAT_IDENTIFIER);
+						// Reset Offset to re-process remainder of word
+						offset -= (wbl - 2);
+					// Check for Expanded Argument (%~...) / Variable (%%~...)
+					} else if (((wbl > 1) && (wordBuffer[1] == '~')) ||
+						((wbl > 2) && (wordBuffer[1] == '%') && (wordBuffer[2] == '~'))) {
+						// Check for External Command / Program
+						if (cmdLoc == offset - wbl) {
+							cmdLoc = offset - (wbl - wbo);
+						}
+						// Colorize Expanded Argument / Variable
+						styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_IDENTIFIER);
+						// Reset Offset to re-process remainder of word
+						offset -= (wbl - wbo);
+					// Check for Environment Variable (%x...%)
+					} else if ((wordBuffer[1] != '%') &&
+						(wordBuffer[wbo] == '%')) {
+						wbo++;
+						// Check for External Command / Program
+						if (cmdLoc == offset - wbl) {
+							cmdLoc = offset - (wbl - wbo);
+						}
+						// Colorize Environment Variable
+						styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_IDENTIFIER);
+						// Reset Offset to re-process remainder of word
+						offset -= (wbl - wbo);
+					// Check for Local Variable (%%a)
+					} else if (
+						(wbl > 2) &&
+						(wordBuffer[1] == '%') &&
+						(wordBuffer[2] != '%') &&
+						(!IsBOperator(wordBuffer[2])) &&
+						(!IsBSeparator(wordBuffer[2]))) {
+						// Check for External Command / Program
+						if (cmdLoc == offset - wbl) {
+							cmdLoc = offset - (wbl - 3);
+						}
+						// Colorize Local Variable
+						styler.ColourTo(startLine + offset - 1 - (wbl - 3), SCE_BAT_IDENTIFIER);
+						// Reset Offset to re-process remainder of word
+						offset -= (wbl - 3);
+					}
+				// Check for Environment Variable (!x...!)
+				} else if (wordBuffer[0] == '!') {
+					// Colorize Default Text
+					styler.ColourTo(startLine + offset - 1 - wbl, SCE_BAT_DEFAULT);
+					wbo++;
+					// Search to end of word for second ! (can be a long path)
+					while ((wbo < wbl) &&
+						(wordBuffer[wbo] != '!')) {
+						wbo++;
+					}
+					if (wordBuffer[wbo] == '!') {
+						wbo++;
+						// Check for External Command / Program
+						if (cmdLoc == offset - wbl) {
+							cmdLoc = offset - (wbl - wbo);
+						}
+						// Colorize Environment Variable
+						styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_IDENTIFIER);
+						// Reset Offset to re-process remainder of word
+						offset -= (wbl - wbo);
+					}
+				// Check for Operator
+				} else if (IsBOperator(wordBuffer[0])) {
+					// Colorize Default Text
+					styler.ColourTo(startLine + offset - 1 - wbl, SCE_BAT_DEFAULT);
+					// Check for Comparison Operator
+					if ((wordBuffer[0] == '=') && (wordBuffer[1] == '=')) {
+						// Identify External Command / Program Location for IF
+						cmdLoc = offset;
+						// Skip next spaces
+						while ((cmdLoc < lengthLine) &&
+							(isspacechar(lineBuffer[cmdLoc]))) {
+							cmdLoc++;
+						}
+						// Colorize Comparison Operator
+						if (continueProcessing)
+							styler.ColourTo(startLine + offset - 1 - (wbl - 2), SCE_BAT_OPERATOR);
+						else
+							styler.ColourTo(startLine + offset - 1 - (wbl - 2), SCE_BAT_DEFAULT);
+						// Reset Offset to re-process remainder of word
+						offset -= (wbl - 2);
+					// Check for Pipe Operator
+					} else if ((wordBuffer[0] == '|') &&
+								!(IsEscaped(lineBuffer,offset - wbl + wbo) || textQuoted(lineBuffer, offset - wbl) )) {
+						// Reset External Command / Program Location
+						cmdLoc = offset - wbl + 1;
+						// Skip next spaces
+						while ((cmdLoc < lengthLine) &&
+							(isspacechar(lineBuffer[cmdLoc]))) {
+							cmdLoc++;
+						}
+						// Colorize Pipe Operator
+						styler.ColourTo(startLine + offset - 1 - (wbl - 1), SCE_BAT_OPERATOR);
+						// Reset Offset to re-process remainder of word
+						offset -= (wbl - 1);
+						continueProcessing = true;
+					// Check for Other Operator
+					} else {
+						// Check for Operators: >, |, &
+						if (((wordBuffer[0] == '>')||
+						   (wordBuffer[0] == ')')||
+						   (wordBuffer[0] == '(')||
+						   (wordBuffer[0] == '&' )) &&
+						   !(!continueProcessing && (IsEscaped(lineBuffer,offset - wbl + wbo)
+						   || textQuoted(lineBuffer, offset - wbl) ))){
+							// Turn Keyword and External Command / Program checking back on
+							continueProcessing = true;
+							isNotAssigned=false;
+						}
+						// Colorize Other Operators
+						// Do not Colorize Paranthesis, quoted text and escaped operators
+						if (((wordBuffer[0] != ')') && (wordBuffer[0] != '(')
+						&& !textQuoted(lineBuffer, offset - wbl)  && !IsEscaped(lineBuffer,offset - wbl + wbo))
+						&& !((wordBuffer[0] == '=') && !isNotAssigned ))
+							styler.ColourTo(startLine + offset - 1 - (wbl - 1), SCE_BAT_OPERATOR);
+						else
+							styler.ColourTo(startLine + offset - 1 - (wbl - 1), SCE_BAT_DEFAULT);
+						// Reset Offset to re-process remainder of word
+						offset -= (wbl - 1);
+
+						if ((wordBuffer[0] == '=') && isNotAssigned ){
+							isNotAssigned=false;
+						}
+					}
+				// Check for Default Text
+				} else {
+					// Read up to %, Operator or Separator
+					while ((wbo < wbl) &&
+						((wordBuffer[wbo] != '%') &&
+						(wordBuffer[wbo] != '!') &&
+						(!IsBOperator(wordBuffer[wbo])) &&
+						(!IsBSeparator(wordBuffer[wbo])))) {
+						wbo++;
+					}
+					// Colorize Default Text
+					styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_DEFAULT);
+					// Reset Offset to re-process remainder of word
+					offset -= (wbl - wbo);
+				}
+				// Skip next spaces - nothing happens if Offset was Reset
+				while ((offset < lengthLine) && (isspacechar(lineBuffer[offset]))) {
+					offset++;
+				}
+			}
+			// Colorize Default Text for remainder of line - currently not lexed
+			styler.ColourTo(endPos, SCE_BAT_DEFAULT);
+
+			// handle line continuation for SET and ECHO commands except the last line
+			if (!continueProcessing && (i<startPos + length-1)) {
+				if (linePos==1 || (linePos==2 && lineBuffer[1]=='\r')) // empty line on Unix and Mac or on Windows
+					continueProcessing=true;
+				else {
+					Sci_PositionU lineContinuationPos;
+					if ((linePos>2) && lineBuffer[linePos-2]=='\r') // Windows EOL
+						lineContinuationPos=linePos-3;
+					else
+						lineContinuationPos=linePos-2; // Unix or Mac EOL
+					// Reset continueProcessing	if line continuation was not found
+					if ((lineBuffer[lineContinuationPos]!='^')
+							|| IsEscaped(lineBuffer, lineContinuationPos)
+							|| textQuoted(lineBuffer, lineContinuationPos))
+						continueProcessing=true;
+				}
+			}
+
+			linePos = 0;
+			startLine = i + 1;
+		}
+	}
+}
+
+static const char *const batchWordListDesc[] = {
+	"Internal Commands",
+	"External Commands",
+	0
+};
+
+LexerModule lmBatch(SCLEX_BATCH, ColouriseBatchDoc, "batch", 0, batchWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexBibTeX.cxx b/Pythonwin/Scintilla/lexers/LexBibTeX.cxx
new file mode 100644
index 000000000..7e4cb9fc1
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexBibTeX.cxx
@@ -0,0 +1,308 @@
+// Copyright 2008-2010 Sergiu Dotenco. The License.txt file describes the
+// conditions under which this software may be distributed.
+
+/**
+ * @file LexBibTeX.cxx
+ * @brief General BibTeX coloring scheme.
+ * @author Sergiu Dotenco
+ * @date April 18, 2009
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <cassert>
+#include <cctype>
+
+#include <string>
+#include <algorithm>
+#include <functional>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+namespace {
+	bool IsAlphabetic(unsigned int ch)
+	{
+		return IsASCII(ch) && std::isalpha(ch) != 0;
+	}
+	bool IsAlphaNumeric(char ch)
+	{
+	    return IsASCII(ch) && std::isalnum(ch);
+	}
+
+	bool EqualCaseInsensitive(const char* a, const char* b)
+	{
+		return CompareCaseInsensitive(a, b) == 0;
+	}
+
+	bool EntryWithoutKey(const char* name)
+	{
+		return EqualCaseInsensitive(name,"string");
+	}
+
+	char GetClosingBrace(char openbrace)
+	{
+		char result = openbrace;
+
+		switch (openbrace) {
+			case '(': result = ')'; break;
+			case '{': result = '}'; break;
+		}
+
+		return result;
+	}
+
+	bool IsEntryStart(char prev, char ch)
+	{
+		return prev != '\\' && ch == '@';
+	}
+
+	bool IsEntryStart(const StyleContext& sc)
+	{
+		return IsEntryStart(sc.chPrev, sc.ch);
+	}
+
+	void ColorizeBibTeX(Sci_PositionU start_pos, Sci_Position length, int /*init_style*/, WordList* keywordlists[], Accessor& styler)
+	{
+	    WordList &EntryNames = *keywordlists[0];
+		bool fold_compact = styler.GetPropertyInt("fold.compact", 1) != 0;
+
+		std::string buffer;
+		buffer.reserve(25);
+
+		// We always colorize a section from the beginning, so let's
+		// search for the @ character which isn't escaped, i.e. \@
+		while (start_pos > 0 && !IsEntryStart(styler.SafeGetCharAt(start_pos - 1),
+			styler.SafeGetCharAt(start_pos))) {
+			--start_pos; ++length;
+		}
+
+		styler.StartAt(start_pos);
+		styler.StartSegment(start_pos);
+
+		Sci_Position current_line = styler.GetLine(start_pos);
+		int prev_level = styler.LevelAt(current_line) & SC_FOLDLEVELNUMBERMASK;
+		int current_level = prev_level;
+		int visible_chars = 0;
+
+		bool in_comment = false ;
+		StyleContext sc(start_pos, length, SCE_BIBTEX_DEFAULT, styler);
+
+		bool going = sc.More(); // needed because of a fuzzy end of file state
+		char closing_brace = 0;
+		bool collect_entry_name = false;
+
+		for (; going; sc.Forward()) {
+			if (!sc.More())
+				going = false; // we need to go one behind the end of text
+
+			if (in_comment) {
+				if (sc.atLineEnd) {
+					sc.SetState(SCE_BIBTEX_DEFAULT);
+					in_comment = false;
+				}
+			}
+			else {
+				// Found @entry
+				if (IsEntryStart(sc)) {
+					sc.SetState(SCE_BIBTEX_UNKNOWN_ENTRY);
+					sc.Forward();
+					++current_level;
+
+					buffer.clear();
+					collect_entry_name = true;
+				}
+				else if ((sc.state == SCE_BIBTEX_ENTRY || sc.state == SCE_BIBTEX_UNKNOWN_ENTRY)
+					&& (sc.ch == '{' || sc.ch == '(')) {
+					// Entry name colorization done
+					// Found either a { or a ( after entry's name, e.g. @entry(...) @entry{...}
+					// Closing counterpart needs to be stored.
+					closing_brace = GetClosingBrace(sc.ch);
+
+					sc.SetState(SCE_BIBTEX_DEFAULT); // Don't colorize { (
+
+					// @string doesn't have any key
+					if (EntryWithoutKey(buffer.c_str()))
+						sc.ForwardSetState(SCE_BIBTEX_PARAMETER);
+					else
+						sc.ForwardSetState(SCE_BIBTEX_KEY); // Key/label colorization
+				}
+
+				// Need to handle the case where entry's key is empty
+				// e.g. @book{,...}
+				if (sc.state == SCE_BIBTEX_KEY && sc.ch == ',') {
+					// Key/label colorization done
+					sc.SetState(SCE_BIBTEX_DEFAULT); // Don't colorize the ,
+					sc.ForwardSetState(SCE_BIBTEX_PARAMETER); // Parameter colorization
+				}
+				else if (sc.state == SCE_BIBTEX_PARAMETER && sc.ch == '=') {
+					sc.SetState(SCE_BIBTEX_DEFAULT); // Don't colorize the =
+					sc.ForwardSetState(SCE_BIBTEX_VALUE); // Parameter value colorization
+
+					Sci_Position start = sc.currentPos;
+
+					// We need to handle multiple situations:
+					// 1. name"one two {three}"
+					// 2. name={one {one two {two}} three}
+					// 3. year=2005
+
+					// Skip ", { until we encounter the first alphanumerical character
+					while (sc.More() && !(IsAlphaNumeric(sc.ch) || sc.ch == '"' || sc.ch == '{'))
+						sc.Forward();
+
+					if (sc.More()) {
+						// Store " or {
+						char ch = sc.ch;
+
+						// Not interested in alphanumerical characters
+						if (IsAlphaNumeric(ch))
+							ch = 0;
+
+						int skipped = 0;
+
+						if (ch) {
+							// Skip preceding " or { such as in name={{test}}.
+							// Remember how many characters have been skipped
+							// Make sure that empty values, i.e. "" are also handled correctly
+							while (sc.More() && (sc.ch == ch && (ch != '"' || skipped < 1))) {
+								sc.Forward();
+								++skipped;
+							}
+						}
+
+						// Closing counterpart for " is the same character
+						if (ch == '{')
+							ch = '}';
+
+						// We have reached the parameter value
+						// In case the open character was a alnum char, skip until , is found
+						// otherwise until skipped == 0
+						while (sc.More() && (skipped > 0 || (!ch && !(sc.ch == ',' || sc.ch == closing_brace)))) {
+							// Make sure the character isn't escaped
+							if (sc.chPrev != '\\') {
+								// Parameter value contains a { which is the 2nd case described above
+								if (sc.ch == '{')
+									++skipped; // Remember it
+								else if (sc.ch == '}')
+									--skipped;
+								else if (skipped == 1 && sc.ch == ch && ch == '"') // Don't ignore cases like {"o}
+									skipped = 0;
+							}
+
+							sc.Forward();
+						}
+					}
+
+					// Don't colorize the ,
+					sc.SetState(SCE_BIBTEX_DEFAULT);
+
+					// Skip until the , or entry's closing closing_brace is found
+					// since this parameter might be the last one
+					while (sc.More() && !(sc.ch == ',' || sc.ch == closing_brace))
+						sc.Forward();
+
+					int state = SCE_BIBTEX_PARAMETER; // The might be more parameters
+
+					// We've reached the closing closing_brace for the bib entry
+					// in case no " or {} has been used to enclose the value,
+					// as in 3rd case described above
+					if (sc.ch == closing_brace) {
+						--current_level;
+						// Make sure the text between entries is not colored
+						// using parameter's style
+						state = SCE_BIBTEX_DEFAULT;
+					}
+
+					Sci_Position end = sc.currentPos;
+					current_line = styler.GetLine(end);
+
+					// We have possibly skipped some lines, so the folding levels
+					// have to be adjusted separately
+					for (Sci_Position i = styler.GetLine(start); i <= styler.GetLine(end); ++i)
+						styler.SetLevel(i, prev_level);
+
+					sc.ForwardSetState(state);
+				}
+
+				if (sc.state == SCE_BIBTEX_PARAMETER && sc.ch == closing_brace) {
+					sc.SetState(SCE_BIBTEX_DEFAULT);
+					--current_level;
+				}
+
+				// Non escaped % found which represents a comment until the end of the line
+				if (sc.chPrev != '\\' && sc.ch == '%') {
+					in_comment = true;
+					sc.SetState(SCE_BIBTEX_COMMENT);
+				}
+			}
+
+			if (sc.state == SCE_BIBTEX_UNKNOWN_ENTRY || sc.state == SCE_BIBTEX_ENTRY) {
+				if (!IsAlphabetic(sc.ch) && collect_entry_name)
+					collect_entry_name = false;
+
+				if (collect_entry_name) {
+					buffer += static_cast<char>(tolower(sc.ch));
+                    if (EntryNames.InList(buffer.c_str()))
+                        sc.ChangeState(SCE_BIBTEX_ENTRY);
+                    else
+                        sc.ChangeState(SCE_BIBTEX_UNKNOWN_ENTRY);
+				}
+			}
+
+			if (sc.atLineEnd) {
+				int level = prev_level;
+
+				if (visible_chars == 0 && fold_compact)
+					level |= SC_FOLDLEVELWHITEFLAG;
+
+				if ((current_level > prev_level))
+					level |= SC_FOLDLEVELHEADERFLAG;
+				// else if (current_level < prev_level)
+				//	level |= SC_FOLDLEVELBOXFOOTERFLAG; // Deprecated
+
+				if (level != styler.LevelAt(current_line)) {
+					styler.SetLevel(current_line, level);
+				}
+
+				++current_line;
+				prev_level = current_level;
+				visible_chars = 0;
+			}
+
+			if (!isspacechar(sc.ch))
+				++visible_chars;
+		}
+
+		sc.Complete();
+
+		// Fill in the real level of the next line, keeping the current flags as they will be filled in later
+		int flagsNext = styler.LevelAt(current_line) & ~SC_FOLDLEVELNUMBERMASK;
+		styler.SetLevel(current_line, prev_level | flagsNext);
+	}
+}
+static const char * const BibTeXWordLists[] = {
+            "Entry Names",
+            0,
+};
+
+
+LexerModule lmBibTeX(SCLEX_BIBTEX, ColorizeBibTeX, "bib", 0, BibTeXWordLists);
+
+// Entry Names
+//    article, book, booklet, conference, inbook,
+//    incollection, inproceedings, manual, mastersthesis,
+//    misc, phdthesis, proceedings, techreport, unpublished,
+//    string, url
+
diff --git a/Pythonwin/Scintilla/src/LexBullant.cxx b/Pythonwin/Scintilla/lexers/LexBullant.cxx
similarity index 89%
rename from Pythonwin/Scintilla/src/LexBullant.cxx
rename to Pythonwin/Scintilla/lexers/LexBullant.cxx
index cc60cd2fc..2386d2252 100644
--- a/Pythonwin/Scintilla/src/LexBullant.cxx
+++ b/Pythonwin/Scintilla/lexers/LexBullant.cxx
@@ -3,25 +3,28 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
 
-#ifdef SCI_NAMESPACE
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
 using namespace Scintilla;
-#endif
 
-static int classifyWordBullant(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler) {
+static int classifyWordBullant(Sci_PositionU start, Sci_PositionU end, WordList &keywords, Accessor &styler) {
 	char s[100];
-	for (unsigned int i = 0; i < end - start + 1 && i < 30; i++) {
+	s[0] = '\0';
+	for (Sci_PositionU i = 0; i < end - start + 1 && i < 30; i++) {
 		s[i] = static_cast<char>(tolower(styler[start + i]));
 		s[i + 1] = '\0';
 	}
@@ -53,14 +56,14 @@ static int classifyWordBullant(unsigned int start, unsigned int end, WordList &k
 	return lev;
 }
 
-static void ColouriseBullantDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
+static void ColouriseBullantDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
 	Accessor &styler) {
 	WordList &keywords = *keywordlists[0];
 
 	styler.StartAt(startPos);
 
 	bool fold = styler.GetPropertyInt("fold") != 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 
@@ -69,11 +72,11 @@ static void ColouriseBullantDoc(unsigned int startPos, int length, int initStyle
 		state = SCE_C_DEFAULT;
 	char chPrev = ' ';
 	char chNext = styler[startPos];
-	unsigned int lengthDoc = startPos + length;
+	Sci_PositionU lengthDoc = startPos + length;
 	int visibleChars = 0;
 	styler.StartSegment(startPos);
 	int endFoundThisLine = 0;
-	for (unsigned int i = startPos; i < lengthDoc; i++) {
+	for (Sci_PositionU i = startPos; i < lengthDoc; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 
@@ -111,7 +114,7 @@ static void ColouriseBullantDoc(unsigned int startPos, int length, int initStyle
 			}
 			blockChange=0;
 */		}
-		if (!isspace(ch))
+		if (!(IsASCII(ch) && isspace(ch)))
 			visibleChars++;
 
 		if (styler.IsLeadByte(ch)) {
diff --git a/Pythonwin/Scintilla/lexers/LexCIL.cxx b/Pythonwin/Scintilla/lexers/LexCIL.cxx
new file mode 100644
index 000000000..4e0fdb696
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexCIL.cxx
@@ -0,0 +1,407 @@
+// Scintilla source code edit control
+/** @file LexCIL.cxx
+ ** Lexer for Common Intermediate Language
+ ** Written by Jad Altahan (github.com/xv)
+ ** CIL manual: https://www.ecma-international.org/publications/standards/Ecma-335.htm
+ **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+#include <map>
+#include <algorithm>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "StringCopy.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+namespace {
+    // Use an unnamed namespace to protect the functions and classes from name conflicts
+
+bool IsAWordChar(const int ch) {
+    return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.');
+}
+
+bool IsOperator(const int ch) {
+    if ((ch < 0x80) && (isalnum(ch)))
+        return false;
+
+    if (strchr("!%&*+-/<=>@^|~()[]{}", ch)) {
+        return true;
+    }
+
+    return false;
+}
+
+constexpr bool IsStreamCommentStyle(const int style) noexcept {
+    return style == SCE_CIL_COMMENT;
+}
+
+struct OptionsCIL {
+    bool fold;
+    bool foldComment;
+    bool foldCommentMultiline;
+    bool foldCompact;
+
+    OptionsCIL() {
+        fold = true;
+        foldComment = false;
+        foldCommentMultiline = true;
+        foldCompact = true;
+    }
+};
+
+static const char *const cilWordListDesc[] = {
+    "Primary CIL keywords",
+    "Metadata",
+    "Opcode instructions",
+    0
+};
+
+struct OptionSetCIL : public OptionSet<OptionsCIL> {
+    OptionSetCIL() {
+        DefineProperty("fold", &OptionsCIL::fold);
+        DefineProperty("fold.comment", &OptionsCIL::foldComment);
+
+        DefineProperty("fold.cil.comment.multiline", &OptionsCIL::foldCommentMultiline,
+            "Set this property to 0 to disable folding multi-line comments when fold.comment=1.");
+
+        DefineProperty("fold.compact", &OptionsCIL::foldCompact);
+
+        DefineWordListSets(cilWordListDesc);
+    }
+};
+
+LexicalClass lexicalClasses[] = {
+    // Lexer CIL SCLEX_CIL SCE_CIL_:
+    0,  "SCE_CIL_DEFAULT",     "default",              "White space",
+    1,  "SCE_CIL_COMMENT",     "comment",              "Multi-line comment",
+    2,  "SCE_CIL_COMMENTLINE", "comment line",         "Line comment",
+    3,  "SCE_CIL_WORD",        "keyword",              "Keyword 1",
+    4,  "SCE_CIL_WORD2",       "keyword",              "Keyword 2",
+    5,  "SCE_CIL_WORD3",       "keyword",              "Keyword 3",
+    6,  "SCE_CIL_STRING",      "literal string",       "Double quoted string",
+    7,  "SCE_CIL_LABEL",       "label",                "Code label",
+    8,  "SCE_CIL_OPERATOR",    "operator",             "Operators",
+    9,  "SCE_CIL_STRINGEOL",   "error literal string", "String is not closed",
+    10, "SCE_CIL_IDENTIFIER",  "identifier",           "Identifiers",
+};
+
+}
+
+class LexerCIL : public DefaultLexer {
+    WordList keywords, keywords2, keywords3;
+    OptionsCIL options;
+    OptionSetCIL osCIL;
+
+public:
+    LexerCIL() : DefaultLexer("cil", SCLEX_CIL, lexicalClasses, ELEMENTS(lexicalClasses)) { }
+
+    virtual ~LexerCIL() { }
+
+    void SCI_METHOD Release() override {
+        delete this;
+    }
+
+    int SCI_METHOD Version() const override {
+        return lvRelease5;
+    }
+
+    const char * SCI_METHOD PropertyNames() override {
+        return osCIL.PropertyNames();
+    }
+
+    int SCI_METHOD PropertyType(const char *name) override {
+        return osCIL.PropertyType(name);
+    }
+
+    const char * SCI_METHOD DescribeProperty(const char *name) override {
+        return osCIL.DescribeProperty(name);
+    }
+
+    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();
+    }
+
+    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 *) override {
+        return 0;
+    }
+
+    int SCI_METHOD LineEndTypesSupported() override {
+        return SC_LINE_END_TYPE_UNICODE;
+    }
+
+    int SCI_METHOD PrimaryStyleFromStyle(int style) override {
+        return style;
+    }
+
+    static ILexer5 *LexerFactoryCIL() {
+        return new LexerCIL();
+    }
+};
+
+Sci_Position SCI_METHOD LexerCIL::PropertySet(const char *key, const char *val) {
+    if (osCIL.PropertySet(&options, key, val)) {
+        return 0;
+    }
+
+    return -1;
+}
+
+Sci_Position SCI_METHOD LexerCIL::WordListSet(int n, const char *wl) {
+    WordList *wordListN = 0;
+
+    switch (n) {
+        case 0:
+            wordListN = &keywords;
+            break;
+        case 1:
+            wordListN = &keywords2;
+            break;
+        case 2:
+            wordListN = &keywords3;
+            break;
+    }
+
+    Sci_Position firstModification = -1;
+
+    if (wordListN) {
+        WordList wlNew;
+        wlNew.Set(wl);
+
+        if (*wordListN != wlNew) {
+            wordListN->Set(wl);
+            firstModification = 0;
+        }
+    }
+
+    return firstModification;
+}
+
+void SCI_METHOD LexerCIL::Lex(Sci_PositionU startPos, Sci_Position length,
+                              int initStyle, IDocument *pAccess) {
+    if (initStyle == SCE_CIL_STRINGEOL) {
+        initStyle = SCE_CIL_DEFAULT;
+    }
+
+    Accessor styler(pAccess, NULL);
+    StyleContext sc(startPos, length, initStyle, styler);
+
+    bool identAtLineStart = false, // Checks if an identifier is at line start (ignoring spaces)
+         canStyleLabels = false;   // Checks if conditions are met to style SCE_CIL_LABEL
+
+    for (; sc.More(); sc.Forward()) {
+        if (sc.atLineStart) {
+            if (sc.state == SCE_CIL_STRING) {
+                sc.SetState(SCE_CIL_STRING);
+            }
+
+            identAtLineStart = true;
+        }
+
+        // Handle string line continuation
+        if (sc.ch == '\\' && (sc.chNext == '\n' || sc.chNext == '\r') &&
+           (sc.state == SCE_CIL_STRING)) {
+            sc.Forward();
+
+            if (sc.ch == '\r' && sc.chNext == '\n') {
+                sc.Forward();
+            }
+
+            continue;
+        }
+
+        switch (sc.state) {
+            case SCE_CIL_OPERATOR:
+                sc.SetState(SCE_CIL_DEFAULT);
+                break;
+            case SCE_CIL_IDENTIFIER:
+                if (!IsAWordChar(sc.ch)) {
+                    if (canStyleLabels && (sc.ch == ':' && sc.chNext != ':')) {
+                        sc.ChangeState(SCE_CIL_LABEL);
+                        sc.ForwardSetState(SCE_CIL_DEFAULT);
+                    } else {
+                        char kwSize[100];
+                        sc.GetCurrent(kwSize, sizeof(kwSize));
+                        int style = SCE_CIL_IDENTIFIER;
+
+                        if (keywords.InList(kwSize)) {
+                            style = SCE_CIL_WORD;
+                        } else if (keywords2.InList(kwSize)) {
+                            style = SCE_CIL_WORD2;
+                        } else if (keywords3.InList(kwSize)) {
+                            style = SCE_CIL_WORD3;
+                        }
+
+                        sc.ChangeState(style);
+                        sc.SetState(SCE_CIL_DEFAULT);
+                    }
+                }
+                break;
+            case SCE_CIL_COMMENT:
+                if (sc.Match('*', '/')) {
+                    sc.Forward();
+                    sc.ForwardSetState(SCE_CIL_DEFAULT);
+                }
+                break;
+            case SCE_CIL_COMMENTLINE:
+                if (sc.atLineStart) {
+                    sc.SetState(SCE_CIL_DEFAULT);
+                }
+                break;
+            case SCE_CIL_STRING:
+                if (sc.ch == '\\') {
+                    if (sc.chNext == '"' || sc.chNext == '\\') {
+                        sc.Forward();
+                    }
+                } else if (sc.ch == '"') {
+                    sc.ForwardSetState(SCE_CIL_DEFAULT);
+                } else if (sc.atLineEnd) {
+                    sc.ChangeState(SCE_CIL_STRINGEOL);
+                    sc.ForwardSetState(SCE_CIL_DEFAULT);
+                }
+                break;
+        }
+
+        if (sc.state == SCE_CIL_DEFAULT) {
+            // String
+            if (sc.ch == '"') {
+                sc.SetState(SCE_CIL_STRING);
+            }
+            // Keyword
+            else if (IsAWordChar(sc.ch)) {
+                // Allow setting SCE_CIL_LABEL style only if the label is the
+                // first token in the line and does not start with a dot or a digit
+                canStyleLabels = identAtLineStart && !(sc.ch == '.' || IsADigit(sc.ch));
+                sc.SetState(SCE_CIL_IDENTIFIER);
+            }
+            // Multi-line comment
+            else if (sc.Match('/', '*')) {
+                sc.SetState(SCE_CIL_COMMENT);
+                sc.Forward();
+            }
+            // Line comment
+            else if (sc.Match('/', '/')) {
+                sc.SetState(SCE_CIL_COMMENTLINE);
+            }
+            // Operators
+            else if (IsOperator(sc.ch)) {
+                sc.SetState(SCE_CIL_OPERATOR);
+            }
+        }
+
+        if (!IsASpace(sc.ch)) {
+            identAtLineStart = false;
+        }
+    }
+
+    sc.Complete();
+}
+
+void SCI_METHOD LexerCIL::Fold(Sci_PositionU startPos, Sci_Position length, 
+                               int initStyle, IDocument *pAccess) {
+    if (!options.fold) {
+        return;
+    }
+
+    LexAccessor styler(pAccess);
+
+    const Sci_PositionU endPos = startPos + length;
+    Sci_Position lineCurrent = styler.GetLine(startPos);
+
+    int levelCurrent = SC_FOLDLEVELBASE;
+    if (lineCurrent > 0)
+        levelCurrent = styler.LevelAt(lineCurrent - 1) >> 16;
+    
+    int style = initStyle;
+    int styleNext = styler.StyleAt(startPos);
+    int levelNext = levelCurrent;
+    int visibleChars = 0;
+
+    char chNext = styler[startPos];
+
+    for (Sci_PositionU i = startPos; i < endPos; i++) {
+        const char ch = chNext;
+        int stylePrev = style;
+
+        chNext = styler.SafeGetCharAt(i + 1);
+        style = styleNext;
+        styleNext = styler.StyleAt(i + 1);
+
+        const bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+
+        if (options.foldComment && 
+            options.foldCommentMultiline && IsStreamCommentStyle(style)) {
+            if (!IsStreamCommentStyle(stylePrev)) {
+                levelNext++;
+            } else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
+                levelNext--;
+            }
+        }
+
+        if (style == SCE_CIL_OPERATOR) {
+            if (ch == '{') {
+                levelNext++;
+            } else if (ch == '}') {
+                levelNext--;
+            }
+        }
+
+        if (!IsASpace(ch)) {
+            visibleChars++;
+        }
+
+        if (atEOL || (i == endPos - 1)) {
+            int lev = levelCurrent | levelNext << 16;
+            if (visibleChars == 0 && options.foldCompact)
+                lev |= SC_FOLDLEVELWHITEFLAG;
+            if (levelCurrent < levelNext)
+                lev |= SC_FOLDLEVELHEADERFLAG;
+            if (lev != styler.LevelAt(lineCurrent)) {
+                styler.SetLevel(lineCurrent, lev);
+            }
+            
+            lineCurrent++;
+            levelCurrent = levelNext;
+            
+            if (options.foldCompact &&
+                i == static_cast<Sci_PositionU>(styler.Length() - 1)) {
+                styler.SetLevel(lineCurrent, lev | SC_FOLDLEVELWHITEFLAG);
+            }
+
+            visibleChars = 0;
+        }
+    }
+}
+
+LexerModule lmCIL(SCLEX_CIL, LexerCIL::LexerFactoryCIL, "cil", cilWordListDesc);
\ No newline at end of file
diff --git a/Pythonwin/Scintilla/src/LexCLW.cxx b/Pythonwin/Scintilla/lexers/LexCLW.cxx
similarity index 92%
rename from Pythonwin/Scintilla/src/LexCLW.cxx
rename to Pythonwin/Scintilla/lexers/LexCLW.cxx
index 624ef0f2b..fbc86e6c0 100644
--- a/Pythonwin/Scintilla/src/LexCLW.cxx
+++ b/Pythonwin/Scintilla/lexers/LexCLW.cxx
@@ -1,5 +1,5 @@
 // Scintilla source code edit control
-/** @file LexClw.cxx
+/** @file LexCLW.cxx
  ** Lexer for Clarion.
  ** 2004/12/17 Updated Lexer
  **/
@@ -10,20 +10,21 @@
 #include <string.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
 #include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 // Is an end of line character
 inline bool IsEOL(const int ch) {
@@ -60,10 +61,10 @@ inline bool IsALabelStart(const int iChar) {
 // Is a label character
 inline bool IsALabelCharacter(const int iChar) {
 
-	return(isalnum(iChar) || iChar == '_' || iChar == ':'); 
+	return(isalnum(iChar) || iChar == '_' || iChar == ':');
 }
 
-// Is the character is a ! and the the next character is not a ! 
+// Is the character is a ! and the the next character is not a !
 inline bool IsACommentStart(const int iChar) {
 
 	return(iChar == '!');
@@ -126,7 +127,7 @@ inline bool SetNumericConstantState(StyleContext &scDoc) {
 				break;
 			default :
 				break;
-		}	
+		}
 	}
 	// If points found (can be more than one for improper formatted number
 	if (iPoints > 0) {
@@ -139,12 +140,12 @@ inline bool SetNumericConstantState(StyleContext &scDoc) {
 }
 
 // Get the next word in uppercase from the current position (keyword lookahead)
-inline bool GetNextWordUpper(Accessor &styler, unsigned int uiStartPos, int iLength, char *cWord) {
+inline bool GetNextWordUpper(Accessor &styler, Sci_PositionU uiStartPos, Sci_Position iLength, char *cWord) {
 
-	unsigned int iIndex = 0;		// Buffer Index
+	Sci_PositionU iIndex = 0;		// Buffer Index
 
 	// Loop through the remaining string from the current position
-	for (int iOffset = uiStartPos; iOffset < iLength; iOffset++) {
+	for (Sci_Position iOffset = uiStartPos; iOffset < iLength; iOffset++) {
 		// Get the character from the buffer using the offset
 		char cCharacter = styler[iOffset];
 		if (IsEOL(cCharacter)) {
@@ -171,7 +172,7 @@ inline bool GetNextWordUpper(Accessor &styler, unsigned int uiStartPos, int iLen
 }
 
 // Clarion Language Colouring Procedure
-static void ColouriseClarionDoc(unsigned int uiStartPos, int iLength, int iInitStyle, WordList *wlKeywords[], Accessor &accStyler, bool bCaseSensitive) {
+static void ColouriseClarionDoc(Sci_PositionU uiStartPos, Sci_Position iLength, int iInitStyle, WordList *wlKeywords[], Accessor &accStyler, bool bCaseSensitive) {
 
 	int iParenthesesLevel = 0;		// Parenthese Level
 	int iColumn1Label = false;		// Label starts in Column 1
@@ -186,12 +187,12 @@ static void ColouriseClarionDoc(unsigned int uiStartPos, int iLength, int iInitS
 	WordList &wlLabelReservedWords = *wlKeywords[7];		// Clarion Reserved Keywords (Labels)
 	WordList &wlProcLabelReservedWords = *wlKeywords[8];	// Clarion Reserved Keywords (Procedure Labels)
 
-	const char wlProcReservedKeywordList[] = 
+	const char wlProcReservedKeywordList[] =
 	"PROCEDURE FUNCTION";
 	WordList wlProcReservedKeywords;
 	wlProcReservedKeywords.Set(wlProcReservedKeywordList);
 
-	const char wlCompilerKeywordList[] = 
+	const char wlCompilerKeywordList[] =
 	"COMPILE OMIT";
 	WordList wlCompilerKeywords;
 	wlCompilerKeywords.Set(wlCompilerKeywordList);
@@ -243,7 +244,7 @@ static void ColouriseClarionDoc(unsigned int uiStartPos, int iLength, int iInitS
 						// change the label to error state
 						scDoc.ChangeState(SCE_CLW_ERROR);
 					}
-					// Else if UPPERCASE label string is 
+					// Else if UPPERCASE label string is
 					else if (wlProcLabelReservedWords.InList(cLabel) && iColumn1Label) {
 						char cWord[512];	// Word buffer
 						// Get the next word from the current position
@@ -368,13 +369,13 @@ static void ColouriseClarionDoc(unsigned int uiStartPos, int iLength, int iInitS
 				// Increment the parenthese level
 				iParenthesesLevel++;
 			}
-			// Else if the character is a ) (close parenthese) 
+			// Else if the character is a ) (close parenthese)
 			else if (scDoc.ch == ')') {
 				// If the parenthese level is set to zero
 				// parentheses matched
 				if (!iParenthesesLevel) {
 					scDoc.SetState(SCE_CLW_DEFAULT);
-				} 
+				}
 				// Else parenthese level is greater than zero
 				// still looking for matching parentheses
 				else {
@@ -399,7 +400,7 @@ static void ColouriseClarionDoc(unsigned int uiStartPos, int iLength, int iInitS
 			|| IsAHexCharacter(scDoc.ch, bCaseSensitive)
 			|| scDoc.ch == '.'
 			|| IsANumericBaseCharacter(scDoc.ch, bCaseSensitive))) {
-				// If the number was a real 
+				// If the number was a real
 				if (SetNumericConstantState(scDoc)) {
 					// Colour the matched string to the real constant state
 					scDoc.ChangeState(SCE_CLW_REAL_CONSTANT);
@@ -461,7 +462,7 @@ static void ColouriseClarionDoc(unsigned int uiStartPos, int iLength, int iInitS
 		}
 		// Default Handling
 		else {
-			// If in default state 
+			// If in default state
 			if (scDoc.state == SCE_CLW_DEFAULT) {
 				// If is a letter could be a possible statement
 				if (isalpha(scDoc.ch)) {
@@ -477,10 +478,10 @@ static void ColouriseClarionDoc(unsigned int uiStartPos, int iLength, int iInitS
 				else if (IsACommentStart(scDoc.ch) || scDoc.ch == '|') {
 					// then set the state to comment.
 					scDoc.SetState(SCE_CLW_COMMENT);
-				}		
+				}
 				// else if the character is a ' (single quote)
 				else if (scDoc.ch == '\'') {
-					// If the character is also a ' (single quote) 
+					// If the character is also a ' (single quote)
 					// Embedded Apostrophe
 					if (scDoc.chNext == '\'') {
 						// Move forward colouring it as default state
@@ -490,7 +491,7 @@ static void ColouriseClarionDoc(unsigned int uiStartPos, int iLength, int iInitS
 						// move to the next character and then set the state to comment.
 						scDoc.ForwardSetState(SCE_CLW_STRING);
 					}
-				}		
+				}
 				// else the character is an @ (ampersand)
 				else if (scDoc.ch == '@') {
 					// Case insensitive.
@@ -509,7 +510,7 @@ static void ColouriseClarionDoc(unsigned int uiStartPos, int iLength, int iInitS
 							scDoc.SetState(SCE_CLW_PICTURE_STRING);
 						}
 					}
-				}		
+				}
 			}
 		}
 	}
@@ -518,22 +519,22 @@ static void ColouriseClarionDoc(unsigned int uiStartPos, int iLength, int iInitS
 }
 
 // Clarion Language Case Sensitive Colouring Procedure
-static void ColouriseClarionDocSensitive(unsigned int uiStartPos, int iLength, int iInitStyle, WordList *wlKeywords[], Accessor &accStyler) {
+static void ColouriseClarionDocSensitive(Sci_PositionU uiStartPos, Sci_Position iLength, int iInitStyle, WordList *wlKeywords[], Accessor &accStyler) {
 
 	ColouriseClarionDoc(uiStartPos, iLength, iInitStyle, wlKeywords, accStyler, true);
 }
 
 // Clarion Language Case Insensitive Colouring Procedure
-static void ColouriseClarionDocInsensitive(unsigned int uiStartPos, int iLength, int iInitStyle, WordList *wlKeywords[], Accessor &accStyler) {
+static void ColouriseClarionDocInsensitive(Sci_PositionU uiStartPos, Sci_Position iLength, int iInitStyle, WordList *wlKeywords[], Accessor &accStyler) {
 
 	ColouriseClarionDoc(uiStartPos, iLength, iInitStyle, wlKeywords, accStyler, false);
 }
 
 // Fill Buffer
 
-static void FillBuffer(unsigned int uiStart, unsigned int uiEnd, Accessor &accStyler, char *szBuffer, unsigned int uiLength) {
+static void FillBuffer(Sci_PositionU uiStart, Sci_PositionU uiEnd, Accessor &accStyler, char *szBuffer, Sci_PositionU uiLength) {
 
-	unsigned int uiPos = 0;
+	Sci_PositionU uiPos = 0;
 
 	while ((uiPos < uiEnd - uiStart + 1) && (uiPos < uiLength-1)) {
 		szBuffer[uiPos] = static_cast<char>(toupper(accStyler[uiStart + uiPos]));
@@ -596,19 +597,19 @@ static int ClassifyClarionFoldPoint(int iLevel, const char* szString) {
 }
 
 // Clarion Language Folding Procedure
-static void FoldClarionDoc(unsigned int uiStartPos, int iLength, int iInitStyle, WordList *[], Accessor &accStyler) {
+static void FoldClarionDoc(Sci_PositionU uiStartPos, Sci_Position iLength, int iInitStyle, WordList *[], Accessor &accStyler) {
 
-	unsigned int uiEndPos = uiStartPos + iLength;
-	int iLineCurrent = accStyler.GetLine(uiStartPos);
+	Sci_PositionU uiEndPos = uiStartPos + iLength;
+	Sci_Position iLineCurrent = accStyler.GetLine(uiStartPos);
 	int iLevelPrev = accStyler.LevelAt(iLineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int iLevelCurrent = iLevelPrev;
 	char chNext = accStyler[uiStartPos];
 	int iStyle = iInitStyle;
 	int iStyleNext = accStyler.StyleAt(uiStartPos);
 	int iVisibleChars = 0;
-	int iLastStart = 0;
+	Sci_Position iLastStart = 0;
 
-	for (unsigned int uiPos = uiStartPos; uiPos < uiEndPos; uiPos++) {
+	for (Sci_PositionU uiPos = uiStartPos; uiPos < uiEndPos; uiPos++) {
 
 		char chChar = chNext;
 		chNext = accStyler.SafeGetCharAt(uiPos + 1);
@@ -616,7 +617,7 @@ static void FoldClarionDoc(unsigned int uiStartPos, int iLength, int iInitStyle,
 		iStyle = iStyleNext;
 		iStyleNext = accStyler.StyleAt(uiPos + 1);
 		bool bEOL = (chChar == '\r' && chNext != '\n') || (chChar == '\n');
-	
+
 		if (iStylePrev == SCE_CLW_DEFAULT) {
 			if (iStyle == SCE_CLW_KEYWORD || iStyle == SCE_CLW_STRUCTURE_DATA_TYPE) {
 				// Store last word start point.
@@ -647,7 +648,7 @@ static void FoldClarionDoc(unsigned int uiStartPos, int iLength, int iInitStyle,
 			iLevelPrev = iLevelCurrent;
 			iVisibleChars = 0;
 		}
-		
+
 		if (!isspacechar(chChar))
 			iVisibleChars++;
 	}
diff --git a/Pythonwin/Scintilla/lexers/LexCOBOL.cxx b/Pythonwin/Scintilla/lexers/LexCOBOL.cxx
new file mode 100644
index 000000000..f0374824f
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexCOBOL.cxx
@@ -0,0 +1,379 @@
+// Scintilla source code edit control
+/** @file LexCOBOL.cxx
+ ** Lexer for COBOL
+ ** Based on LexPascal.cxx
+ ** Written by Laurent le Tynevez
+ ** Updated by Simon Steele <s.steele@pnotepad.org> September 2002
+ ** Updated by Mathias Rauen <scite@madshi.net> May 2003 (Delphi adjustments)
+ ** Updated by Rod Falck, Aug 2006 Converted to COBOL
+ **/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+#define IN_DIVISION 0x01
+#define IN_DECLARATIVES 0x02
+#define IN_SECTION 0x04
+#define IN_PARAGRAPH 0x08
+#define IN_FLAGS 0xF
+#define NOT_HEADER 0x10
+
+inline bool isCOBOLoperator(char ch)
+    {
+    return isoperator(ch);
+    }
+
+inline bool isCOBOLwordchar(char ch)
+    {
+    return IsASCII(ch) && (isalnum(ch) || ch == '-');
+
+    }
+
+inline bool isCOBOLwordstart(char ch)
+    {
+    return IsASCII(ch) && isalnum(ch);
+    }
+
+static int CountBits(int nBits)
+	{
+	int count = 0;
+	for (int i = 0; i < 32; ++i)
+		{
+		count += nBits & 1;
+		nBits >>= 1;
+		}
+	return count;
+	}
+
+static void getRange(Sci_PositionU start,
+        Sci_PositionU end,
+        Accessor &styler,
+        char *s,
+        Sci_PositionU len) {
+    Sci_PositionU i = 0;
+    while ((i < end - start + 1) && (i < len-1)) {
+        s[i] = static_cast<char>(tolower(styler[start + i]));
+        i++;
+    }
+    s[i] = '\0';
+}
+
+static void ColourTo(Accessor &styler, Sci_PositionU end, unsigned int attr) {
+    styler.ColourTo(end, attr);
+}
+
+
+static int classifyWordCOBOL(Sci_PositionU start, Sci_PositionU end, /*WordList &keywords*/WordList *keywordlists[], Accessor &styler, int nContainment, bool *bAarea) {
+    int ret = 0;
+
+    WordList& a_keywords = *keywordlists[0];
+    WordList& b_keywords = *keywordlists[1];
+    WordList& c_keywords = *keywordlists[2];
+
+    char s[100];
+    s[0] = '\0';
+    s[1] = '\0';
+    getRange(start, end, styler, s, sizeof(s));
+
+    char chAttr = SCE_C_IDENTIFIER;
+    if (isdigit(s[0]) || (s[0] == '.') || (s[0] == 'v')) {
+        chAttr = SCE_C_NUMBER;
+		char *p = s + 1;
+		while (*p) {
+			if ((!isdigit(*p) && (*p) != 'v') && isCOBOLwordchar(*p)) {
+				chAttr = SCE_C_IDENTIFIER;
+			    break;
+			}
+			++p;
+		}
+    }
+    else {
+        if (a_keywords.InList(s)) {
+            chAttr = SCE_C_WORD;
+        }
+        else if (b_keywords.InList(s)) {
+            chAttr = SCE_C_WORD2;
+        }
+        else if (c_keywords.InList(s)) {
+            chAttr = SCE_C_UUID;
+        }
+    }
+    if (*bAarea) {
+        if (strcmp(s, "division") == 0) {
+            ret = IN_DIVISION;
+			// we've determined the containment, anything else is just ignored for those purposes
+			*bAarea = false;
+		} else if (strcmp(s, "declaratives") == 0) {
+            ret = IN_DIVISION | IN_DECLARATIVES;
+			if (nContainment & IN_DECLARATIVES)
+				ret |= NOT_HEADER | IN_SECTION;
+			// we've determined the containment, anything else is just ignored for those purposes
+			*bAarea = false;
+		} else if (strcmp(s, "section") == 0) {
+            ret = (nContainment &~ IN_PARAGRAPH) | IN_SECTION;
+			// we've determined the containment, anything else is just ignored for those purposes
+			*bAarea = false;
+		} else if (strcmp(s, "end") == 0 && (nContainment & IN_DECLARATIVES)) {
+            ret = IN_DIVISION | IN_DECLARATIVES | IN_SECTION | NOT_HEADER;
+		} else {
+			ret = nContainment | IN_PARAGRAPH;
+        }
+    }
+    ColourTo(styler, end, chAttr);
+    return ret;
+}
+
+static void ColouriseCOBOLDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+    Accessor &styler) {
+
+    styler.StartAt(startPos);
+
+    int state = initStyle;
+    if (state == SCE_C_CHARACTER)   // Does not leak onto next line
+        state = SCE_C_DEFAULT;
+    char chPrev = ' ';
+    char chNext = styler[startPos];
+    Sci_PositionU lengthDoc = startPos + length;
+
+    int nContainment;
+
+    Sci_Position currentLine = styler.GetLine(startPos);
+    if (currentLine > 0) {
+        styler.SetLineState(currentLine, styler.GetLineState(currentLine-1));
+        nContainment = styler.GetLineState(currentLine);
+		nContainment &= ~NOT_HEADER;
+    } else {
+        styler.SetLineState(currentLine, 0);
+        nContainment = 0;
+    }
+
+    styler.StartSegment(startPos);
+    bool bNewLine = true;
+    bool bAarea = !isspacechar(chNext);
+	int column = 0;
+    for (Sci_PositionU i = startPos; i < lengthDoc; i++) {
+        char ch = chNext;
+
+        chNext = styler.SafeGetCharAt(i + 1);
+
+		++column;
+
+        if (bNewLine) {
+			column = 0;
+        }
+		if (column <= 1 && !bAarea) {
+			bAarea = !isspacechar(ch);
+			}
+        bool bSetNewLine = false;
+        if ((ch == '\r' && chNext != '\n') || (ch == '\n')) {
+            // Trigger on CR only (Mac style) or either on LF from CR+LF (Dos/Win) or on LF alone (Unix)
+            // Avoid triggering two times on Dos/Win
+            // End of line
+            if (state == SCE_C_CHARACTER) {
+                ColourTo(styler, i, state);
+                state = SCE_C_DEFAULT;
+            }
+            styler.SetLineState(currentLine, nContainment);
+            currentLine++;
+            bSetNewLine = true;
+			if (nContainment & NOT_HEADER)
+				nContainment &= ~(NOT_HEADER | IN_DECLARATIVES | IN_SECTION);
+        }
+
+        if (styler.IsLeadByte(ch)) {
+            chNext = styler.SafeGetCharAt(i + 2);
+            chPrev = ' ';
+            i += 1;
+            continue;
+        }
+
+        if (state == SCE_C_DEFAULT) {
+            if (isCOBOLwordstart(ch) || (ch == '$' && IsASCII(chNext) && isalpha(chNext))) {
+                ColourTo(styler, i-1, state);
+                state = SCE_C_IDENTIFIER;
+            } else if (column == 6 && ch == '*') {
+            // Cobol comment line: asterisk in column 7.
+                ColourTo(styler, i-1, state);
+                state = SCE_C_COMMENTLINE;
+            } else if (ch == '*' && chNext == '>') {
+            // Cobol inline comment: asterisk, followed by greater than.
+                ColourTo(styler, i-1, state);
+                state = SCE_C_COMMENTLINE;
+            } else if (column == 0 && ch == '*' && chNext != '*') {
+                ColourTo(styler, i-1, state);
+                state = SCE_C_COMMENTLINE;
+            } else if (column == 0 && ch == '/' && chNext != '*') {
+                ColourTo(styler, i-1, state);
+                state = SCE_C_COMMENTLINE;
+            } else if (column == 0 && ch == '*' && chNext == '*') {
+                ColourTo(styler, i-1, state);
+                state = SCE_C_COMMENTDOC;
+            } else if (column == 0 && ch == '/' && chNext == '*') {
+                ColourTo(styler, i-1, state);
+                state = SCE_C_COMMENTDOC;
+            } else if (ch == '"') {
+                ColourTo(styler, i-1, state);
+                state = SCE_C_STRING;
+            } else if (ch == '\'') {
+                ColourTo(styler, i-1, state);
+                state = SCE_C_CHARACTER;
+            } else if (ch == '?' && column == 0) {
+                ColourTo(styler, i-1, state);
+                state = SCE_C_PREPROCESSOR;
+            } else if (isCOBOLoperator(ch)) {
+                ColourTo(styler, i-1, state);
+                ColourTo(styler, i, SCE_C_OPERATOR);
+            }
+        } else if (state == SCE_C_IDENTIFIER) {
+            if (!isCOBOLwordchar(ch)) {
+                int lStateChange = classifyWordCOBOL(styler.GetStartSegment(), i - 1, keywordlists, styler, nContainment, &bAarea);
+
+                if(lStateChange != 0) {
+                    styler.SetLineState(currentLine, lStateChange);
+                    nContainment = lStateChange;
+                }
+
+                state = SCE_C_DEFAULT;
+                chNext = styler.SafeGetCharAt(i + 1);
+                if (ch == '"') {
+                    state = SCE_C_STRING;
+                } else if (ch == '\'') {
+                    state = SCE_C_CHARACTER;
+                } else if (isCOBOLoperator(ch)) {
+                    ColourTo(styler, i, SCE_C_OPERATOR);
+                }
+            }
+        } else {
+            if (state == SCE_C_PREPROCESSOR) {
+                if ((ch == '\r' || ch == '\n') && !(chPrev == '\\' || chPrev == '\r')) {
+                    ColourTo(styler, i-1, state);
+                    state = SCE_C_DEFAULT;
+                }
+            } else if (state == SCE_C_COMMENT) {
+                if (ch == '\r' || ch == '\n') {
+                    ColourTo(styler, i, state);
+                    state = SCE_C_DEFAULT;
+                }
+            } else if (state == SCE_C_COMMENTDOC) {
+                if (ch == '\r' || ch == '\n') {
+                    if (((i > styler.GetStartSegment() + 2) || (
+                        (initStyle == SCE_C_COMMENTDOC) &&
+                        (styler.GetStartSegment() == static_cast<Sci_PositionU>(startPos))))) {
+                            ColourTo(styler, i, state);
+                            state = SCE_C_DEFAULT;
+                    }
+                }
+            } else if (state == SCE_C_COMMENTLINE) {
+                if (ch == '\r' || ch == '\n') {
+                    ColourTo(styler, i-1, state);
+                    state = SCE_C_DEFAULT;
+                }
+            } else if (state == SCE_C_STRING) {
+                if (ch == '"') {
+                    ColourTo(styler, i, state);
+                    state = SCE_C_DEFAULT;
+                }
+            } else if (state == SCE_C_CHARACTER) {
+                if (ch == '\'') {
+                    ColourTo(styler, i, state);
+                    state = SCE_C_DEFAULT;
+                }
+            }
+        }
+        chPrev = ch;
+        bNewLine = bSetNewLine;
+		if (bNewLine)
+			{
+			bAarea = false;
+			}
+    }
+    ColourTo(styler, lengthDoc - 1, state);
+}
+
+static void FoldCOBOLDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[],
+                            Accessor &styler) {
+    bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+    Sci_PositionU endPos = startPos + length;
+    int visibleChars = 0;
+    Sci_Position lineCurrent = styler.GetLine(startPos);
+    int levelPrev = lineCurrent > 0 ? styler.LevelAt(lineCurrent - 1) & SC_FOLDLEVELNUMBERMASK : 0xFFF;
+    char chNext = styler[startPos];
+
+    bool bNewLine = true;
+    bool bAarea = !isspacechar(chNext);
+	int column = 0;
+	bool bComment = false;
+    for (Sci_PositionU i = startPos; i < endPos; i++) {
+        char ch = chNext;
+        chNext = styler.SafeGetCharAt(i + 1);
+		++column;
+
+        if (bNewLine) {
+			column = 0;
+			bComment = (ch == '*' || ch == '/' || ch == '?');
+        }
+		if (column <= 1 && !bAarea) {
+			bAarea = !isspacechar(ch);
+			}
+        bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+        if (atEOL) {
+			int nContainment = styler.GetLineState(lineCurrent);
+            int lev = CountBits(nContainment & IN_FLAGS) | SC_FOLDLEVELBASE;
+			if (bAarea && !bComment)
+				--lev;
+            if (visibleChars == 0 && foldCompact)
+                lev |= SC_FOLDLEVELWHITEFLAG;
+            if ((bAarea) && (visibleChars > 0) && !(nContainment & NOT_HEADER) && !bComment)
+                lev |= SC_FOLDLEVELHEADERFLAG;
+            if (lev != styler.LevelAt(lineCurrent)) {
+                styler.SetLevel(lineCurrent, lev);
+            }
+			if ((lev & SC_FOLDLEVELNUMBERMASK) <= (levelPrev & SC_FOLDLEVELNUMBERMASK)) {
+				// this level is at the same level or less than the previous line
+				// therefore these is nothing for the previous header to collapse, so remove the header
+				styler.SetLevel(lineCurrent - 1, levelPrev & ~SC_FOLDLEVELHEADERFLAG);
+			}
+            levelPrev = lev;
+            visibleChars = 0;
+			bAarea = false;
+            bNewLine = true;
+            lineCurrent++;
+        } else {
+            bNewLine = false;
+        }
+
+
+        if (!isspacechar(ch))
+            visibleChars++;
+    }
+
+    // Fill in the real level of the next line, keeping the current flags as they will be filled in later
+    int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
+    styler.SetLevel(lineCurrent, levelPrev | flagsNext);
+}
+
+static const char * const COBOLWordListDesc[] = {
+    "A Keywords",
+    "B Keywords",
+    "Extended Keywords",
+    0
+};
+
+LexerModule lmCOBOL(SCLEX_COBOL, ColouriseCOBOLDoc, "COBOL", FoldCOBOLDoc, COBOLWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexCPP.cxx b/Pythonwin/Scintilla/lexers/LexCPP.cxx
new file mode 100644
index 000000000..8ef4a1bfa
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexCPP.cxx
@@ -0,0 +1,1785 @@
+// Scintilla source code edit control
+/** @file LexCPP.cxx
+ ** Lexer for C++, C, Java, and JavaScript.
+ ** Further folding features and configuration properties added by "Udo Lechner" <dlchnr(at)gmx(dot)net>
+ **/
+// Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+
+#include <utility>
+#include <string>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <iterator>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "StringCopy.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "SparseState.h"
+#include "SubStyles.h"
+
+using namespace Scintilla;
+
+namespace {
+	// Use an unnamed namespace to protect the functions and classes from name conflicts
+
+constexpr bool IsSpaceEquiv(int state) noexcept {
+	return (state <= SCE_C_COMMENTDOC) ||
+		// including SCE_C_DEFAULT, SCE_C_COMMENT, SCE_C_COMMENTLINE
+		(state == SCE_C_COMMENTLINEDOC) || (state == SCE_C_COMMENTDOCKEYWORD) ||
+		(state == SCE_C_COMMENTDOCKEYWORDERROR);
+}
+
+// Preconditions: sc.currentPos points to a character after '+' or '-'.
+// The test for pos reaching 0 should be redundant,
+// and is in only for safety measures.
+// Limitation: this code will give the incorrect answer for code like
+// a = b+++/ptn/...
+// Putting a space between the '++' post-inc operator and the '+' binary op
+// fixes this, and is highly recommended for readability anyway.
+bool FollowsPostfixOperator(const StyleContext &sc, LexAccessor &styler) {
+	Sci_Position pos = sc.currentPos;
+	while (--pos > 0) {
+		const char ch = styler[pos];
+		if (ch == '+' || ch == '-') {
+			return styler[pos - 1] == ch;
+		}
+	}
+	return false;
+}
+
+bool followsReturnKeyword(const StyleContext &sc, LexAccessor &styler) {
+	// Don't look at styles, so no need to flush.
+	Sci_Position pos = sc.currentPos;
+	const Sci_Position currentLine = styler.GetLine(pos);
+	const Sci_Position lineStartPos = styler.LineStart(currentLine);
+	while (--pos > lineStartPos) {
+		const char ch = styler.SafeGetCharAt(pos);
+		if (ch != ' ' && ch != '\t') {
+			break;
+		}
+	}
+	const char *retBack = "nruter";
+	const char *s = retBack;
+	while (*s
+		&& pos >= lineStartPos
+		&& styler.SafeGetCharAt(pos) == *s) {
+		s++;
+		pos--;
+	}
+	return !*s;
+}
+
+constexpr bool IsSpaceOrTab(int ch) noexcept {
+	return ch == ' ' || ch == '\t';
+}
+
+bool OnlySpaceOrTab(const std::string &s) noexcept {
+	for (const char ch : s) {
+		if (!IsSpaceOrTab(ch))
+			return false;
+	}
+	return true;
+}
+
+std::vector<std::string> StringSplit(const std::string &text, int separator) {
+	std::vector<std::string> vs(text.empty() ? 0 : 1);
+	for (const char ch : text) {
+		if (ch == separator) {
+			vs.emplace_back();
+		} else {
+			vs.back() += ch;
+		}
+	}
+	return vs;
+}
+
+struct BracketPair {
+	std::vector<std::string>::iterator itBracket;
+	std::vector<std::string>::iterator itEndBracket;
+};
+
+BracketPair FindBracketPair(std::vector<std::string> &tokens) {
+	BracketPair bp;
+	std::vector<std::string>::iterator itTok = std::find(tokens.begin(), tokens.end(), "(");
+	bp.itBracket = tokens.end();
+	bp.itEndBracket = tokens.end();
+	if (itTok != tokens.end()) {
+		bp.itBracket = itTok;
+		size_t nest = 0;
+		while (itTok != tokens.end()) {
+			if (*itTok == "(") {
+				nest++;
+			} else if (*itTok == ")") {
+				nest--;
+				if (nest == 0) {
+					bp.itEndBracket = itTok;
+					return bp;
+				}
+			}
+			++itTok;
+		}
+	}
+	bp.itBracket = tokens.end();
+	return bp;
+}
+
+void highlightTaskMarker(StyleContext &sc, LexAccessor &styler,
+		int activity, const WordList &markerList, bool caseSensitive){
+	if ((isoperator(sc.chPrev) || IsASpace(sc.chPrev)) && markerList.Length()) {
+		constexpr Sci_PositionU lengthMarker = 50;
+		char marker[lengthMarker+1] = "";
+		const Sci_PositionU currPos = sc.currentPos;
+		Sci_PositionU i = 0;
+		while (i < lengthMarker) {
+			const char ch = styler.SafeGetCharAt(currPos + i);
+			if (IsASpace(ch) || isoperator(ch)) {
+				break;
+			}
+			if (caseSensitive)
+				marker[i] = ch;
+			else
+				marker[i] = MakeLowerCase(ch);
+			i++;
+		}
+		marker[i] = '\0';
+		if (markerList.InList(marker)) {
+			sc.SetState(SCE_C_TASKMARKER|activity);
+		}
+	}
+}
+
+class EscapeSequence {
+	const CharacterSet setHexDigits = CharacterSet(CharacterSet::setDigits, "ABCDEFabcdef");
+	const CharacterSet setOctDigits = CharacterSet(CharacterSet::setNone, "01234567");
+	const CharacterSet setNoneNumeric;
+	const CharacterSet *escapeSetValid = nullptr;
+	int digitsLeft = 0;
+public:
+	EscapeSequence() = default;
+	void resetEscapeState(int nextChar) {
+		digitsLeft = 0;
+		escapeSetValid = &setNoneNumeric;
+		if (nextChar == 'U') {
+			digitsLeft = 9;
+			escapeSetValid = &setHexDigits;
+		} else if (nextChar == 'u') {
+			digitsLeft = 5;
+			escapeSetValid = &setHexDigits;
+		} else if (nextChar == 'x') {
+			digitsLeft = 5;
+			escapeSetValid = &setHexDigits;
+		} else if (setOctDigits.Contains(nextChar)) {
+			digitsLeft = 3;
+			escapeSetValid = &setOctDigits;
+		}
+	}
+	bool atEscapeEnd(int currChar) const {
+		return (digitsLeft <= 0) || !escapeSetValid->Contains(currChar);
+	}
+	void consumeDigit() noexcept {
+		digitsLeft--;
+	}
+};
+
+std::string GetRestOfLine(LexAccessor &styler, Sci_Position start, bool allowSpace) {
+	std::string restOfLine;
+	Sci_Position line = styler.GetLine(start);
+	Sci_Position pos = start;
+	Sci_Position endLine = styler.LineEnd(line);
+	char ch = styler.SafeGetCharAt(start, '\n');
+	while (pos < endLine) {
+		if (ch == '\\' && ((pos + 1) == endLine)) {
+			// Continuation line
+			line++;
+			pos = styler.LineStart(line);
+			endLine = styler.LineEnd(line);
+			ch = styler.SafeGetCharAt(pos, '\n');
+		} else {
+			const char chNext = styler.SafeGetCharAt(pos + 1, '\n');
+			if (ch == '/' && (chNext == '/' || chNext == '*'))
+				break;
+			if (allowSpace || (ch != ' ')) {
+				restOfLine += ch;
+			}
+			pos++;
+			ch = chNext;
+		}
+	}
+	return restOfLine;
+}
+
+constexpr bool IsStreamCommentStyle(int style) noexcept {
+	return style == SCE_C_COMMENT ||
+		style == SCE_C_COMMENTDOC ||
+		style == SCE_C_COMMENTDOCKEYWORD ||
+		style == SCE_C_COMMENTDOCKEYWORDERROR;
+}
+
+struct PPDefinition {
+	Sci_Position line;
+	std::string key;
+	std::string value;
+	bool isUndef;
+	std::string arguments;
+	PPDefinition(Sci_Position line_, const std::string &key_, const std::string &value_, bool isUndef_ = false, const std::string &arguments_="") :
+		line(line_), key(key_), value(value_), isUndef(isUndef_), arguments(arguments_) {
+	}
+};
+
+constexpr int inactiveFlag = 0x40;
+
+class LinePPState {
+	// Track the state of preprocessor conditionals to allow showing active and inactive
+	// code in different styles.
+	// Only works up to 31 levels of conditional nesting.
+
+	// state is a bit mask with 1 bit per level
+	// bit is 1 for level if section inactive, so any bits set = inactive style
+	int state = 0;
+	// ifTaken is a bit mask with 1 bit per level
+	// bit is 1 for level if some branch at this level has been taken
+	int ifTaken = 0;
+	// level is the nesting level of #if constructs
+	int level = -1;
+	static const int maximumNestingLevel = 31;
+	bool ValidLevel() const noexcept {
+		return level >= 0 && level < maximumNestingLevel;
+	}
+	int maskLevel() const noexcept {
+		if (level >= 0) {
+			return 1 << level;
+		} else {
+			return 1;
+		}
+	}
+public:
+	LinePPState() noexcept {
+	}
+	bool IsActive() const noexcept {
+		return state == 0;
+	}
+	bool IsInactive() const noexcept {
+		return state != 0;
+	}
+	int ActiveState() const noexcept {
+		return state ? inactiveFlag : 0;
+	}
+	bool CurrentIfTaken() const noexcept {
+		return (ifTaken & maskLevel()) != 0;
+	}
+	void StartSection(bool on) noexcept {
+		level++;
+		if (ValidLevel()) {
+			if (on) {
+				state &= ~maskLevel();
+				ifTaken |= maskLevel();
+			} else {
+				state |= maskLevel();
+				ifTaken &= ~maskLevel();
+			}
+		}
+	}
+	void EndSection() noexcept {
+		if (ValidLevel()) {
+			state &= ~maskLevel();
+			ifTaken &= ~maskLevel();
+		}
+		level--;
+	}
+	void InvertCurrentLevel() noexcept {
+		if (ValidLevel()) {
+			state ^= maskLevel();
+			ifTaken |= maskLevel();
+		}
+	}
+};
+
+// Hold the preprocessor state for each line seen.
+// Currently one entry per line but could become sparse with just one entry per preprocessor line.
+class PPStates {
+	std::vector<LinePPState> vlls;
+public:
+	LinePPState ForLine(Sci_Position line) const noexcept {
+		if ((line > 0) && (vlls.size() > static_cast<size_t>(line))) {
+			return vlls[line];
+		} else {
+			return LinePPState();
+		}
+	}
+	void Add(Sci_Position line, LinePPState lls) {
+		vlls.resize(line+1);
+		vlls[line] = lls;
+	}
+};
+
+// An individual named option for use in an OptionSet
+
+// Options used for LexerCPP
+struct OptionsCPP {
+	bool stylingWithinPreprocessor;
+	bool identifiersAllowDollars;
+	bool trackPreprocessor;
+	bool updatePreprocessor;
+	bool verbatimStringsAllowEscapes;
+	bool triplequotedStrings;
+	bool hashquotedStrings;
+	bool backQuotedStrings;
+	bool escapeSequence;
+	bool fold;
+	bool foldSyntaxBased;
+	bool foldComment;
+	bool foldCommentMultiline;
+	bool foldCommentExplicit;
+	std::string foldExplicitStart;
+	std::string foldExplicitEnd;
+	bool foldExplicitAnywhere;
+	bool foldPreprocessor;
+	bool foldPreprocessorAtElse;
+	bool foldCompact;
+	bool foldAtElse;
+	OptionsCPP() {
+		stylingWithinPreprocessor = false;
+		identifiersAllowDollars = true;
+		trackPreprocessor = true;
+		updatePreprocessor = true;
+		verbatimStringsAllowEscapes = false;
+		triplequotedStrings = false;
+		hashquotedStrings = false;
+		backQuotedStrings = false;
+		escapeSequence = false;
+		fold = false;
+		foldSyntaxBased = true;
+		foldComment = false;
+		foldCommentMultiline = true;
+		foldCommentExplicit = true;
+		foldExplicitStart = "";
+		foldExplicitEnd = "";
+		foldExplicitAnywhere = false;
+		foldPreprocessor = false;
+		foldPreprocessorAtElse = false;
+		foldCompact = false;
+		foldAtElse = false;
+	}
+};
+
+const char *const cppWordLists[] = {
+            "Primary keywords and identifiers",
+            "Secondary keywords and identifiers",
+            "Documentation comment keywords",
+            "Global classes and typedefs",
+            "Preprocessor definitions",
+            "Task marker and error marker keywords",
+            nullptr,
+};
+
+struct OptionSetCPP : public OptionSet<OptionsCPP> {
+	OptionSetCPP() {
+		DefineProperty("styling.within.preprocessor", &OptionsCPP::stylingWithinPreprocessor,
+			"For C++ code, determines whether all preprocessor code is styled in the "
+			"preprocessor style (0, the default) or only from the initial # to the end "
+			"of the command word(1).");
+
+		DefineProperty("lexer.cpp.allow.dollars", &OptionsCPP::identifiersAllowDollars,
+			"Set to 0 to disallow the '$' character in identifiers with the cpp lexer.");
+
+		DefineProperty("lexer.cpp.track.preprocessor", &OptionsCPP::trackPreprocessor,
+			"Set to 1 to interpret #if/#else/#endif to grey out code that is not active.");
+
+		DefineProperty("lexer.cpp.update.preprocessor", &OptionsCPP::updatePreprocessor,
+			"Set to 1 to update preprocessor definitions when #define found.");
+
+		DefineProperty("lexer.cpp.verbatim.strings.allow.escapes", &OptionsCPP::verbatimStringsAllowEscapes,
+			"Set to 1 to allow verbatim strings to contain escape sequences.");
+
+		DefineProperty("lexer.cpp.triplequoted.strings", &OptionsCPP::triplequotedStrings,
+			"Set to 1 to enable highlighting of triple-quoted strings.");
+
+		DefineProperty("lexer.cpp.hashquoted.strings", &OptionsCPP::hashquotedStrings,
+			"Set to 1 to enable highlighting of hash-quoted strings.");
+
+		DefineProperty("lexer.cpp.backquoted.strings", &OptionsCPP::backQuotedStrings,
+			"Set to 1 to enable highlighting of back-quoted raw strings .");
+
+		DefineProperty("lexer.cpp.escape.sequence", &OptionsCPP::escapeSequence,
+			"Set to 1 to enable highlighting of escape sequences in strings");
+
+		DefineProperty("fold", &OptionsCPP::fold);
+
+		DefineProperty("fold.cpp.syntax.based", &OptionsCPP::foldSyntaxBased,
+			"Set this property to 0 to disable syntax based folding.");
+
+		DefineProperty("fold.comment", &OptionsCPP::foldComment,
+			"This option enables folding multi-line comments and explicit fold points when using the C++ lexer. "
+			"Explicit fold points allows adding extra folding by placing a //{ comment at the start and a //} "
+			"at the end of a section that should fold.");
+
+		DefineProperty("fold.cpp.comment.multiline", &OptionsCPP::foldCommentMultiline,
+			"Set this property to 0 to disable folding multi-line comments when fold.comment=1.");
+
+		DefineProperty("fold.cpp.comment.explicit", &OptionsCPP::foldCommentExplicit,
+			"Set this property to 0 to disable folding explicit fold points when fold.comment=1.");
+
+		DefineProperty("fold.cpp.explicit.start", &OptionsCPP::foldExplicitStart,
+			"The string to use for explicit fold start points, replacing the standard //{.");
+
+		DefineProperty("fold.cpp.explicit.end", &OptionsCPP::foldExplicitEnd,
+			"The string to use for explicit fold end points, replacing the standard //}.");
+
+		DefineProperty("fold.cpp.explicit.anywhere", &OptionsCPP::foldExplicitAnywhere,
+			"Set this property to 1 to enable explicit fold points anywhere, not just in line comments.");
+
+		DefineProperty("fold.cpp.preprocessor.at.else", &OptionsCPP::foldPreprocessorAtElse,
+			"This option enables folding on a preprocessor #else or #endif line of an #if statement.");
+
+		DefineProperty("fold.preprocessor", &OptionsCPP::foldPreprocessor,
+			"This option enables folding preprocessor directives when using the C++ lexer. "
+			"Includes C#'s explicit #region and #endregion folding directives.");
+
+		DefineProperty("fold.compact", &OptionsCPP::foldCompact);
+
+		DefineProperty("fold.at.else", &OptionsCPP::foldAtElse,
+			"This option enables C++ folding on a \"} else {\" line of an if statement.");
+
+		DefineWordListSets(cppWordLists);
+	}
+};
+
+const char styleSubable[] = {SCE_C_IDENTIFIER, SCE_C_COMMENTDOCKEYWORD, 0};
+
+LexicalClass lexicalClasses[] = {
+	// Lexer Cpp SCLEX_CPP SCE_C_:
+	0, "SCE_C_DEFAULT", "default", "White space",
+	1, "SCE_C_COMMENT", "comment", "Comment: /* */.",
+	2, "SCE_C_COMMENTLINE", "comment line", "Line Comment: //.",
+	3, "SCE_C_COMMENTDOC", "comment documentation", "Doc comment: block comments beginning with /** or /*!",
+	4, "SCE_C_NUMBER", "literal numeric", "Number",
+	5, "SCE_C_WORD", "keyword", "Keyword",
+	6, "SCE_C_STRING", "literal string", "Double quoted string",
+	7, "SCE_C_CHARACTER", "literal string character", "Single quoted string",
+	8, "SCE_C_UUID", "literal uuid", "UUIDs (only in IDL)",
+	9, "SCE_C_PREPROCESSOR", "preprocessor", "Preprocessor",
+	10, "SCE_C_OPERATOR", "operator", "Operators",
+	11, "SCE_C_IDENTIFIER", "identifier", "Identifiers",
+	12, "SCE_C_STRINGEOL", "error literal string", "End of line where string is not closed",
+	13, "SCE_C_VERBATIM", "literal string multiline raw", "Verbatim strings for C#",
+	14, "SCE_C_REGEX", "literal regex", "Regular expressions for JavaScript",
+	15, "SCE_C_COMMENTLINEDOC", "comment documentation line", "Doc Comment Line: line comments beginning with /// or //!.",
+	16, "SCE_C_WORD2", "identifier", "Keywords2",
+	17, "SCE_C_COMMENTDOCKEYWORD", "comment documentation keyword", "Comment keyword",
+	18, "SCE_C_COMMENTDOCKEYWORDERROR", "error comment documentation keyword", "Comment keyword error",
+	19, "SCE_C_GLOBALCLASS", "identifier", "Global class",
+	20, "SCE_C_STRINGRAW", "literal string multiline raw", "Raw strings for C++0x",
+	21, "SCE_C_TRIPLEVERBATIM", "literal string multiline raw", "Triple-quoted strings for Vala",
+	22, "SCE_C_HASHQUOTEDSTRING", "literal string", "Hash-quoted strings for Pike",
+	23, "SCE_C_PREPROCESSORCOMMENT", "comment preprocessor", "Preprocessor stream comment",
+	24, "SCE_C_PREPROCESSORCOMMENTDOC", "comment preprocessor documentation", "Preprocessor stream doc comment",
+	25, "SCE_C_USERLITERAL", "literal", "User defined literals",
+	26, "SCE_C_TASKMARKER", "comment taskmarker", "Task Marker",
+	27, "SCE_C_ESCAPESEQUENCE", "literal string escapesequence", "Escape sequence",
+};
+
+const int sizeLexicalClasses = static_cast<int>(std::size(lexicalClasses));
+
+}
+
+class LexerCPP : public ILexer5 {
+	bool caseSensitive;
+	CharacterSet setWord;
+	CharacterSet setNegationOp;
+	CharacterSet setAddOp;
+	CharacterSet setMultOp;
+	CharacterSet setRelOp;
+	CharacterSet setLogicalOp;
+	CharacterSet setWordStart;
+	PPStates vlls;
+	std::vector<PPDefinition> ppDefineHistory;
+	WordList keywords;
+	WordList keywords2;
+	WordList keywords3;
+	WordList keywords4;
+	WordList ppDefinitions;
+	WordList markerList;
+	struct SymbolValue {
+		std::string value;
+		std::string arguments;
+		SymbolValue() noexcept = default;
+		SymbolValue(const std::string &value_, const std::string &arguments_) : value(value_), arguments(arguments_) {
+		}
+		SymbolValue &operator = (const std::string &value_) {
+			value = value_;
+			arguments.clear();
+			return *this;
+		}
+		bool IsMacro() const noexcept {
+			return !arguments.empty();
+		}
+	};
+	typedef std::map<std::string, SymbolValue> SymbolTable;
+	SymbolTable preprocessorDefinitionsStart;
+	OptionsCPP options;
+	OptionSetCPP osCPP;
+	EscapeSequence escapeSeq;
+	SparseState<std::string> rawStringTerminators;
+	enum { ssIdentifier, ssDocKeyword };
+	SubStyles subStyles;
+	std::string returnBuffer;
+public:
+	explicit LexerCPP(bool caseSensitive_) :
+		caseSensitive(caseSensitive_),
+		setWord(CharacterSet::setAlphaNum, "._", 0x80, true),
+		setNegationOp(CharacterSet::setNone, "!"),
+		setAddOp(CharacterSet::setNone, "+-"),
+		setMultOp(CharacterSet::setNone, "*/%"),
+		setRelOp(CharacterSet::setNone, "=!<>"),
+		setLogicalOp(CharacterSet::setNone, "|&"),
+		subStyles(styleSubable, 0x80, 0x40, inactiveFlag) {
+	}
+	// Deleted so LexerCPP objects can not be copied.
+	LexerCPP(const LexerCPP &) = delete;
+	LexerCPP(LexerCPP &&) = delete;
+	void operator=(const LexerCPP &) = delete;
+	void operator=(LexerCPP &&) = delete;
+	virtual ~LexerCPP() {
+	}
+	void SCI_METHOD Release() noexcept override {
+		delete this;
+	}
+	int SCI_METHOD Version() const noexcept override {
+		return lvRelease5;
+	}
+	const char * SCI_METHOD PropertyNames() override {
+		return osCPP.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return osCPP.PropertyType(name);
+	}
+	const char * SCI_METHOD DescribeProperty(const char *name) override {
+		return osCPP.DescribeProperty(name);
+	}
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char * SCI_METHOD DescribeWordListSets() override {
+		return osCPP.DescribeWordListSets();
+	}
+	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 *) noexcept override {
+		return nullptr;
+	}
+
+	int SCI_METHOD LineEndTypesSupported() noexcept override {
+		return SC_LINE_END_TYPE_UNICODE;
+	}
+
+	int SCI_METHOD AllocateSubStyles(int styleBase, int numberStyles) override {
+		return subStyles.Allocate(styleBase, numberStyles);
+	}
+	int SCI_METHOD SubStylesStart(int styleBase) override {
+		return subStyles.Start(styleBase);
+	}
+	int SCI_METHOD SubStylesLength(int styleBase) override {
+		return subStyles.Length(styleBase);
+	}
+	int SCI_METHOD StyleFromSubStyle(int subStyle) override {
+		const int styleBase = subStyles.BaseStyle(MaskActive(subStyle));
+		const int inactive = subStyle & inactiveFlag;
+		return styleBase | inactive;
+	}
+	int SCI_METHOD PrimaryStyleFromStyle(int style) noexcept override {
+		return MaskActive(style);
+	}
+	void SCI_METHOD FreeSubStyles() override {
+		subStyles.Free();
+	}
+	void SCI_METHOD SetIdentifiers(int style, const char *identifiers) override {
+		subStyles.SetIdentifiers(style, identifiers);
+	}
+	int SCI_METHOD DistanceToSecondaryStyles() noexcept override {
+		return inactiveFlag;
+	}
+	const char * SCI_METHOD GetSubStyleBases() noexcept override {
+		return styleSubable;
+	}
+	int SCI_METHOD NamedStyles() override {
+		return std::max(subStyles.LastAllocated() + 1,
+			sizeLexicalClasses) +
+			inactiveFlag;
+	}
+	const char * SCI_METHOD NameOfStyle(int style) override {
+		if (style >= NamedStyles())
+			return "";
+		if (style < sizeLexicalClasses)
+			return lexicalClasses[style].name;
+		// TODO: inactive and substyles
+		return "";
+	}
+	const char * SCI_METHOD TagsOfStyle(int style) override {
+		if (style >= NamedStyles())
+			return "Excess";
+		returnBuffer.clear();
+		const int firstSubStyle = subStyles.FirstAllocated();
+		if (firstSubStyle >= 0) {
+			const int lastSubStyle = subStyles.LastAllocated();
+			if (((style >= firstSubStyle) && (style <= (lastSubStyle))) ||
+				((style >= firstSubStyle + inactiveFlag) && (style <= (lastSubStyle + inactiveFlag)))) {
+				int styleActive = style;
+				if (style > lastSubStyle) {
+					returnBuffer = "inactive ";
+					styleActive -= inactiveFlag;
+				}
+				const int styleMain = StyleFromSubStyle(styleActive);
+				returnBuffer += lexicalClasses[styleMain].tags;
+				return returnBuffer.c_str();
+			}
+		}
+		if (style < sizeLexicalClasses)
+			return lexicalClasses[style].tags;
+		if (style >= inactiveFlag) {
+			returnBuffer = "inactive ";
+			const int styleActive = style - inactiveFlag;
+			if (styleActive < sizeLexicalClasses)
+				returnBuffer += lexicalClasses[styleActive].tags;
+			else
+				returnBuffer = "";
+			return returnBuffer.c_str();
+		}
+		return "";
+	}
+	const char * SCI_METHOD DescriptionOfStyle(int style) override {
+		if (style >= NamedStyles())
+			return "";
+		if (style < sizeLexicalClasses)
+			return lexicalClasses[style].description;
+		// TODO: inactive and substyles
+		return "";
+	}
+
+	// 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 ILexer5 *LexerFactoryCPPInsensitive() {
+		return new LexerCPP(false);
+	}
+	constexpr static int MaskActive(int style) noexcept {
+		return style & ~inactiveFlag;
+	}
+	void EvaluateTokens(std::vector<std::string> &tokens, const SymbolTable &preprocessorDefinitions);
+	std::vector<std::string> Tokenize(const std::string &expr) const;
+	bool EvaluateExpression(const std::string &expr, const SymbolTable &preprocessorDefinitions);
+};
+
+Sci_Position SCI_METHOD LexerCPP::PropertySet(const char *key, const char *val) {
+	if (osCPP.PropertySet(&options, key, val)) {
+		if (strcmp(key, "lexer.cpp.allow.dollars") == 0) {
+			setWord = CharacterSet(CharacterSet::setAlphaNum, "._", 0x80, true);
+			if (options.identifiersAllowDollars) {
+				setWord.Add('$');
+			}
+		}
+		return 0;
+	}
+	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) {
+	case 0:
+		wordListN = &keywords;
+		break;
+	case 1:
+		wordListN = &keywords2;
+		break;
+	case 2:
+		wordListN = &keywords3;
+		break;
+	case 3:
+		wordListN = &keywords4;
+		break;
+	case 4:
+		wordListN = &ppDefinitions;
+		break;
+	case 5:
+		wordListN = &markerList;
+		break;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN) {
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+			if (n == 4) {
+				// Rebuild preprocessorDefinitions
+				preprocessorDefinitionsStart.clear();
+				for (int nDefinition = 0; nDefinition < ppDefinitions.Length(); nDefinition++) {
+					const char *cpDefinition = ppDefinitions.WordAt(nDefinition);
+					const char *cpEquals = strchr(cpDefinition, '=');
+					if (cpEquals) {
+						std::string name(cpDefinition, cpEquals - cpDefinition);
+						std::string val(cpEquals+1);
+						const size_t bracket = name.find('(');
+						const size_t bracketEnd = name.find(')');
+						if ((bracket != std::string::npos) && (bracketEnd != std::string::npos)) {
+							// Macro
+							std::string args = name.substr(bracket + 1, bracketEnd - bracket - 1);
+							name = name.substr(0, bracket);
+							preprocessorDefinitionsStart[name] = SymbolValue(val, args);
+						} else {
+							preprocessorDefinitionsStart[name] = val;
+						}
+					} else {
+						std::string name(cpDefinition);
+						std::string val("1");
+						preprocessorDefinitionsStart[name] = val;
+					}
+				}
+			}
+		}
+	}
+	return firstModification;
+}
+
+void SCI_METHOD LexerCPP::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	LexAccessor styler(pAccess);
+
+	CharacterSet setOKBeforeRE(CharacterSet::setNone, "([{=,:;!%^&*|?~+-");
+	CharacterSet setCouldBePostOp(CharacterSet::setNone, "+-");
+
+	CharacterSet setDoxygen(CharacterSet::setAlpha, "$@\\&<>#{}[]");
+
+	setWordStart = CharacterSet(CharacterSet::setAlpha, "_", 0x80, true);
+
+	CharacterSet setInvalidRawFirst(CharacterSet::setNone, " )\\\t\v\f\n");
+
+	if (options.identifiersAllowDollars) {
+		setWordStart.Add('$');
+	}
+
+	int chPrevNonWhite = ' ';
+	int visibleChars = 0;
+	bool lastWordWasUUID = false;
+	int styleBeforeDCKeyword = SCE_C_DEFAULT;
+	int styleBeforeTaskMarker = SCE_C_DEFAULT;
+	bool continuationLine = false;
+	bool isIncludePreprocessor = false;
+	bool isStringInPreprocessor = false;
+	bool inRERange = false;
+	bool seenDocKeyBrace = false;
+
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	if ((MaskActive(initStyle) == SCE_C_PREPROCESSOR) ||
+      (MaskActive(initStyle) == SCE_C_COMMENTLINE) ||
+      (MaskActive(initStyle) == SCE_C_COMMENTLINEDOC)) {
+		// Set continuationLine if last character of previous line is '\'
+		if (lineCurrent > 0) {
+			const Sci_Position endLinePrevious = styler.LineEnd(lineCurrent - 1);
+			if (endLinePrevious > 0) {
+				continuationLine = styler.SafeGetCharAt(endLinePrevious-1) == '\\';
+			}
+		}
+	}
+
+	// look back to set chPrevNonWhite properly for better regex colouring
+	if (startPos > 0) {
+		Sci_Position back = startPos;
+		while (--back && IsSpaceEquiv(MaskActive(styler.StyleAt(back))))
+			;
+		if (MaskActive(styler.StyleAt(back)) == SCE_C_OPERATOR) {
+			chPrevNonWhite = styler.SafeGetCharAt(back);
+		}
+	}
+
+	StyleContext sc(startPos, length, initStyle, styler);
+	LinePPState preproc = vlls.ForLine(lineCurrent);
+
+	bool definitionsChanged = false;
+
+	// Truncate ppDefineHistory before current line
+
+	if (!options.updatePreprocessor)
+		ppDefineHistory.clear();
+
+	std::vector<PPDefinition>::iterator itInvalid = std::find_if(ppDefineHistory.begin(), ppDefineHistory.end(),
+		[lineCurrent](const PPDefinition &p) noexcept { return p.line >= lineCurrent; });
+	if (itInvalid != ppDefineHistory.end()) {
+		ppDefineHistory.erase(itInvalid, ppDefineHistory.end());
+		definitionsChanged = true;
+	}
+
+	SymbolTable preprocessorDefinitions = preprocessorDefinitionsStart;
+	for (const PPDefinition &ppDef : ppDefineHistory) {
+		if (ppDef.isUndef)
+			preprocessorDefinitions.erase(ppDef.key);
+		else
+			preprocessorDefinitions[ppDef.key] = SymbolValue(ppDef.value, ppDef.arguments);
+	}
+
+	std::string rawStringTerminator = rawStringTerminators.ValueAt(lineCurrent-1);
+	SparseState<std::string> rawSTNew(lineCurrent);
+
+	int activitySet = preproc.ActiveState();
+
+	const WordClassifier &classifierIdentifiers = subStyles.Classifier(SCE_C_IDENTIFIER);
+	const WordClassifier &classifierDocKeyWords = subStyles.Classifier(SCE_C_COMMENTDOCKEYWORD);
+
+	Sci_PositionU lineEndNext = styler.LineEnd(lineCurrent);
+
+	for (; sc.More();) {
+
+		if (sc.atLineStart) {
+			// Using MaskActive() is not needed in the following statement.
+			// Inside inactive preprocessor declaration, state will be reset anyway at the end of this block.
+			if ((sc.state == SCE_C_STRING) || (sc.state == SCE_C_CHARACTER)) {
+				// Prevent SCE_C_STRINGEOL from leaking back to previous line which
+				// ends with a line continuation by locking in the state up to this position.
+				sc.SetState(sc.state);
+			}
+			if ((MaskActive(sc.state) == SCE_C_PREPROCESSOR) && (!continuationLine)) {
+				sc.SetState(SCE_C_DEFAULT|activitySet);
+			}
+			// Reset states to beginning of colourise so no surprises
+			// if different sets of lines lexed.
+			visibleChars = 0;
+			lastWordWasUUID = false;
+			isIncludePreprocessor = false;
+			inRERange = false;
+			if (preproc.IsInactive()) {
+				activitySet = inactiveFlag;
+				sc.SetState(sc.state | activitySet);
+			}
+		}
+
+		if (sc.atLineEnd) {
+			lineCurrent++;
+			lineEndNext = styler.LineEnd(lineCurrent);
+			vlls.Add(lineCurrent, preproc);
+			if (rawStringTerminator != "") {
+				rawSTNew.Set(lineCurrent-1, rawStringTerminator);
+			}
+		}
+
+		// Handle line continuation generically.
+		if (sc.ch == '\\') {
+			if ((sc.currentPos+1) >= lineEndNext) {
+				lineCurrent++;
+				lineEndNext = styler.LineEnd(lineCurrent);
+				vlls.Add(lineCurrent, preproc);
+				if (rawStringTerminator != "") {
+					rawSTNew.Set(lineCurrent-1, rawStringTerminator);
+				}
+				sc.Forward();
+				if (sc.ch == '\r' && sc.chNext == '\n') {
+					// Even in UTF-8, \r and \n are separate
+					sc.Forward();
+				}
+				continuationLine = true;
+				sc.Forward();
+				continue;
+			}
+		}
+
+		const bool atLineEndBeforeSwitch = sc.atLineEnd;
+
+		// Determine if the current state should terminate.
+		switch (MaskActive(sc.state)) {
+			case SCE_C_OPERATOR:
+				sc.SetState(SCE_C_DEFAULT|activitySet);
+				break;
+			case SCE_C_NUMBER:
+				// We accept almost anything because of hex. and number suffixes
+				if (sc.ch == '_') {
+					sc.ChangeState(SCE_C_USERLITERAL|activitySet);
+				} else if (!(setWord.Contains(sc.ch)
+				   || (sc.ch == '\'')
+				   || ((sc.ch == '+' || sc.ch == '-') && (sc.chPrev == 'e' || sc.chPrev == 'E' ||
+				                                          sc.chPrev == 'p' || sc.chPrev == 'P')))) {
+					sc.SetState(SCE_C_DEFAULT|activitySet);
+				}
+				break;
+			case SCE_C_USERLITERAL:
+				if (!(setWord.Contains(sc.ch)))
+					sc.SetState(SCE_C_DEFAULT|activitySet);
+				break;
+			case SCE_C_IDENTIFIER:
+				if (sc.atLineStart || sc.atLineEnd || !setWord.Contains(sc.ch) || (sc.ch == '.')) {
+					char s[1000];
+					if (caseSensitive) {
+						sc.GetCurrent(s, sizeof(s));
+					} else {
+						sc.GetCurrentLowered(s, sizeof(s));
+					}
+					if (keywords.InList(s)) {
+						lastWordWasUUID = strcmp(s, "uuid") == 0;
+						sc.ChangeState(SCE_C_WORD|activitySet);
+					} else if (keywords2.InList(s)) {
+						sc.ChangeState(SCE_C_WORD2|activitySet);
+					} else if (keywords4.InList(s)) {
+						sc.ChangeState(SCE_C_GLOBALCLASS|activitySet);
+					} else {
+						int subStyle = classifierIdentifiers.ValueFor(s);
+						if (subStyle >= 0) {
+							sc.ChangeState(subStyle|activitySet);
+						}
+					}
+					const bool literalString = sc.ch == '\"';
+					if (literalString || sc.ch == '\'') {
+						size_t lenS = strlen(s);
+						const bool raw = literalString && sc.chPrev == 'R' && !setInvalidRawFirst.Contains(sc.chNext);
+						if (raw)
+							s[lenS--] = '\0';
+						const bool valid =
+							(lenS == 0) ||
+							((lenS == 1) && ((s[0] == 'L') || (s[0] == 'u') || (s[0] == 'U'))) ||
+							((lenS == 2) && literalString && (s[0] == 'u') && (s[1] == '8'));
+						if (valid) {
+							if (literalString) {
+								if (raw) {
+									// Set the style of the string prefix to SCE_C_STRINGRAW but then change to
+									// SCE_C_DEFAULT as that allows the raw string start code to run.
+									sc.ChangeState(SCE_C_STRINGRAW|activitySet);
+									sc.SetState(SCE_C_DEFAULT|activitySet);
+								} else {
+									sc.ChangeState(SCE_C_STRING|activitySet);
+								}
+							} else {
+								sc.ChangeState(SCE_C_CHARACTER|activitySet);
+							}
+						} else {
+							sc.SetState(SCE_C_DEFAULT | activitySet);
+						}
+					} else {
+						sc.SetState(SCE_C_DEFAULT|activitySet);
+					}
+				}
+				break;
+			case SCE_C_PREPROCESSOR:
+				if (options.stylingWithinPreprocessor) {
+					if (IsASpace(sc.ch) || (sc.ch == '(')) {
+						sc.SetState(SCE_C_DEFAULT|activitySet);
+					}
+				} else if (isStringInPreprocessor && (sc.Match('>') || sc.Match('\"') || sc.atLineEnd)) {
+					isStringInPreprocessor = false;
+				} else if (!isStringInPreprocessor) {
+					if ((isIncludePreprocessor && sc.Match('<')) || sc.Match('\"')) {
+						isStringInPreprocessor = true;
+					} else if (sc.Match('/', '*')) {
+						if (sc.Match("/**") || sc.Match("/*!")) {
+							sc.SetState(SCE_C_PREPROCESSORCOMMENTDOC|activitySet);
+						} else {
+							sc.SetState(SCE_C_PREPROCESSORCOMMENT|activitySet);
+						}
+						sc.Forward();	// Eat the *
+					} else if (sc.Match('/', '/')) {
+						sc.SetState(SCE_C_DEFAULT|activitySet);
+					}
+				}
+				break;
+			case SCE_C_PREPROCESSORCOMMENT:
+			case SCE_C_PREPROCESSORCOMMENTDOC:
+				if (sc.Match('*', '/')) {
+					sc.Forward();
+					sc.ForwardSetState(SCE_C_PREPROCESSOR|activitySet);
+					continue;	// Without advancing in case of '\'.
+				}
+				break;
+			case SCE_C_COMMENT:
+				if (sc.Match('*', '/')) {
+					sc.Forward();
+					sc.ForwardSetState(SCE_C_DEFAULT|activitySet);
+				} else {
+					styleBeforeTaskMarker = SCE_C_COMMENT;
+					highlightTaskMarker(sc, styler, activitySet, markerList, caseSensitive);
+				}
+				break;
+			case SCE_C_COMMENTDOC:
+				if (sc.Match('*', '/')) {
+					sc.Forward();
+					sc.ForwardSetState(SCE_C_DEFAULT|activitySet);
+				} else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support
+					// Verify that we have the conditions to mark a comment-doc-keyword
+					if ((IsASpace(sc.chPrev) || sc.chPrev == '*') && (!IsASpace(sc.chNext))) {
+						styleBeforeDCKeyword = SCE_C_COMMENTDOC;
+						sc.SetState(SCE_C_COMMENTDOCKEYWORD|activitySet);
+					}
+				}
+				break;
+			case SCE_C_COMMENTLINE:
+				if (sc.atLineStart && !continuationLine) {
+					sc.SetState(SCE_C_DEFAULT|activitySet);
+				} else {
+					styleBeforeTaskMarker = SCE_C_COMMENTLINE;
+					highlightTaskMarker(sc, styler, activitySet, markerList, caseSensitive);
+				}
+				break;
+			case SCE_C_COMMENTLINEDOC:
+				if (sc.atLineStart && !continuationLine) {
+					sc.SetState(SCE_C_DEFAULT|activitySet);
+				} else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support
+					// Verify that we have the conditions to mark a comment-doc-keyword
+					if ((IsASpace(sc.chPrev) || sc.chPrev == '/' || sc.chPrev == '!') && (!IsASpace(sc.chNext))) {
+						styleBeforeDCKeyword = SCE_C_COMMENTLINEDOC;
+						sc.SetState(SCE_C_COMMENTDOCKEYWORD|activitySet);
+					}
+				}
+				break;
+			case SCE_C_COMMENTDOCKEYWORD:
+				if ((styleBeforeDCKeyword == SCE_C_COMMENTDOC) && sc.Match('*', '/')) {
+					sc.ChangeState(SCE_C_COMMENTDOCKEYWORDERROR);
+					sc.Forward();
+					sc.ForwardSetState(SCE_C_DEFAULT|activitySet);
+					seenDocKeyBrace = false;
+				} else if (sc.ch == '[' || sc.ch == '{') {
+					seenDocKeyBrace = true;
+				} else if (!setDoxygen.Contains(sc.ch)
+				           && !(seenDocKeyBrace && (sc.ch == ',' || sc.ch == '.'))) {
+					char s[100];
+					if (caseSensitive) {
+						sc.GetCurrent(s, sizeof(s));
+					} else {
+						sc.GetCurrentLowered(s, sizeof(s));
+					}
+					if (!(IsASpace(sc.ch) || (sc.ch == 0))) {
+						sc.ChangeState(SCE_C_COMMENTDOCKEYWORDERROR|activitySet);
+					} else if (!keywords3.InList(s + 1)) {
+						int subStyleCDKW = classifierDocKeyWords.ValueFor(s+1);
+						if (subStyleCDKW >= 0) {
+							sc.ChangeState(subStyleCDKW|activitySet);
+						} else {
+							sc.ChangeState(SCE_C_COMMENTDOCKEYWORDERROR|activitySet);
+						}
+					}
+					sc.SetState(styleBeforeDCKeyword|activitySet);
+					seenDocKeyBrace = false;
+				}
+				break;
+			case SCE_C_STRING:
+				if (sc.atLineEnd) {
+					sc.ChangeState(SCE_C_STRINGEOL|activitySet);
+				} else if (isIncludePreprocessor) {
+					if (sc.ch == '>') {
+						sc.ForwardSetState(SCE_C_DEFAULT|activitySet);
+						isIncludePreprocessor = false;
+					}
+				} else if (sc.ch == '\\') {
+					if (options.escapeSequence) {
+						sc.SetState(SCE_C_ESCAPESEQUENCE|activitySet);
+						escapeSeq.resetEscapeState(sc.chNext);
+					}
+					sc.Forward(); // Skip all characters after the backslash
+				} else if (sc.ch == '\"') {
+					if (sc.chNext == '_') {
+						sc.ChangeState(SCE_C_USERLITERAL|activitySet);
+					} else {
+						sc.ForwardSetState(SCE_C_DEFAULT|activitySet);
+					}
+				}
+				break;
+			case SCE_C_ESCAPESEQUENCE:
+				escapeSeq.consumeDigit();
+				if (!escapeSeq.atEscapeEnd(sc.ch)) {
+					break;
+				}
+				if (sc.ch == '"') {
+					sc.SetState(SCE_C_STRING|activitySet);
+					sc.ForwardSetState(SCE_C_DEFAULT|activitySet);
+				} else if (sc.ch == '\\') {
+					escapeSeq.resetEscapeState(sc.chNext);
+					sc.Forward();
+				} else {
+					sc.SetState(SCE_C_STRING|activitySet);
+					if (sc.atLineEnd) {
+						sc.ChangeState(SCE_C_STRINGEOL|activitySet);
+					}
+				}
+				break;
+			case SCE_C_HASHQUOTEDSTRING:
+				if (sc.ch == '\\') {
+					if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+						sc.Forward();
+					}
+				} else if (sc.ch == '\"') {
+					sc.ForwardSetState(SCE_C_DEFAULT|activitySet);
+				}
+				break;
+			case SCE_C_STRINGRAW:
+				if (sc.Match(rawStringTerminator.c_str())) {
+					for (size_t termPos=rawStringTerminator.size(); termPos; termPos--)
+						sc.Forward();
+					sc.SetState(SCE_C_DEFAULT|activitySet);
+					rawStringTerminator = "";
+				}
+				break;
+			case SCE_C_CHARACTER:
+				if (sc.atLineEnd) {
+					sc.ChangeState(SCE_C_STRINGEOL|activitySet);
+				} else if (sc.ch == '\\') {
+					if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+						sc.Forward();
+					}
+				} else if (sc.ch == '\'') {
+					if (sc.chNext == '_') {
+						sc.ChangeState(SCE_C_USERLITERAL|activitySet);
+					} else {
+						sc.ForwardSetState(SCE_C_DEFAULT|activitySet);
+					}
+				}
+				break;
+			case SCE_C_REGEX:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_C_DEFAULT|activitySet);
+				} else if (!inRERange && sc.ch == '/') {
+					sc.Forward();
+					while (IsLowerCase(sc.ch))
+						sc.Forward();    // gobble regex flags
+					sc.SetState(SCE_C_DEFAULT|activitySet);
+				} else if (sc.ch == '\\' && ((sc.currentPos+1) < lineEndNext)) {
+					// Gobble up the escaped character
+					sc.Forward();
+				} else if (sc.ch == '[') {
+					inRERange = true;
+				} else if (sc.ch == ']') {
+					inRERange = false;
+				}
+				break;
+			case SCE_C_STRINGEOL:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_C_DEFAULT|activitySet);
+				}
+				break;
+			case SCE_C_VERBATIM:
+				if (options.verbatimStringsAllowEscapes && (sc.ch == '\\')) {
+					sc.Forward(); // Skip all characters after the backslash
+				} else if (sc.ch == '\"') {
+					if (sc.chNext == '\"') {
+						sc.Forward();
+					} else {
+						sc.ForwardSetState(SCE_C_DEFAULT|activitySet);
+					}
+				}
+				break;
+			case SCE_C_TRIPLEVERBATIM:
+				if (sc.Match(R"(""")")) {
+					while (sc.Match('"')) {
+						sc.Forward();
+					}
+					sc.SetState(SCE_C_DEFAULT|activitySet);
+				}
+				break;
+			case SCE_C_UUID:
+				if (sc.atLineEnd || sc.ch == ')') {
+					sc.SetState(SCE_C_DEFAULT|activitySet);
+				}
+				break;
+			case SCE_C_TASKMARKER:
+				if (isoperator(sc.ch) || IsASpace(sc.ch)) {
+					sc.SetState(styleBeforeTaskMarker|activitySet);
+					styleBeforeTaskMarker = SCE_C_DEFAULT;
+				}
+		}
+
+		if (sc.atLineEnd && !atLineEndBeforeSwitch) {
+			// State exit processing consumed characters up to end of line.
+			lineCurrent++;
+			lineEndNext = styler.LineEnd(lineCurrent);
+			vlls.Add(lineCurrent, preproc);
+		}
+
+		// Determine if a new state should be entered.
+		if (MaskActive(sc.state) == SCE_C_DEFAULT) {
+			if (sc.Match('@', '\"')) {
+				sc.SetState(SCE_C_VERBATIM|activitySet);
+				sc.Forward();
+			} else if (options.triplequotedStrings && sc.Match(R"(""")")) {
+				sc.SetState(SCE_C_TRIPLEVERBATIM|activitySet);
+				sc.Forward(2);
+			} else if (options.hashquotedStrings && sc.Match('#', '\"')) {
+				sc.SetState(SCE_C_HASHQUOTEDSTRING|activitySet);
+				sc.Forward();
+			} else if (options.backQuotedStrings && sc.Match('`')) {
+				sc.SetState(SCE_C_STRINGRAW|activitySet);
+				rawStringTerminator = "`";
+			} else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
+				if (lastWordWasUUID) {
+					sc.SetState(SCE_C_UUID|activitySet);
+					lastWordWasUUID = false;
+				} else {
+					sc.SetState(SCE_C_NUMBER|activitySet);
+				}
+			} else if (!sc.atLineEnd && (setWordStart.Contains(sc.ch) || (sc.ch == '@'))) {
+				if (lastWordWasUUID) {
+					sc.SetState(SCE_C_UUID|activitySet);
+					lastWordWasUUID = false;
+				} else {
+					sc.SetState(SCE_C_IDENTIFIER|activitySet);
+				}
+			} else if (sc.Match('/', '*')) {
+				if (sc.Match("/**") || sc.Match("/*!")) {	// Support of Qt/Doxygen doc. style
+					sc.SetState(SCE_C_COMMENTDOC|activitySet);
+				} else {
+					sc.SetState(SCE_C_COMMENT|activitySet);
+				}
+				sc.Forward();	// Eat the * so it isn't used for the end of the comment
+			} else if (sc.Match('/', '/')) {
+				if ((sc.Match("///") && !sc.Match("////")) || sc.Match("//!"))
+					// Support of Qt/Doxygen doc. style
+					sc.SetState(SCE_C_COMMENTLINEDOC|activitySet);
+				else
+					sc.SetState(SCE_C_COMMENTLINE|activitySet);
+			} else if (sc.ch == '/'
+				   && (setOKBeforeRE.Contains(chPrevNonWhite)
+				       || followsReturnKeyword(sc, styler))
+				   && (!setCouldBePostOp.Contains(chPrevNonWhite)
+				       || !FollowsPostfixOperator(sc, styler))) {
+				sc.SetState(SCE_C_REGEX|activitySet);	// JavaScript's RegEx
+				inRERange = false;
+			} else if (sc.ch == '\"') {
+				if (sc.chPrev == 'R') {
+					styler.Flush();
+					if (MaskActive(styler.StyleAt(sc.currentPos - 1)) == SCE_C_STRINGRAW) {
+						sc.SetState(SCE_C_STRINGRAW|activitySet);
+						rawStringTerminator = ")";
+						for (Sci_Position termPos = sc.currentPos + 1;; termPos++) {
+							const char chTerminator = styler.SafeGetCharAt(termPos, '(');
+							if (chTerminator == '(')
+								break;
+							rawStringTerminator += chTerminator;
+						}
+						rawStringTerminator += '\"';
+					} else {
+						sc.SetState(SCE_C_STRING|activitySet);
+					}
+				} else {
+					sc.SetState(SCE_C_STRING|activitySet);
+				}
+				isIncludePreprocessor = false;	// ensure that '>' won't end the string
+			} else if (isIncludePreprocessor && sc.ch == '<') {
+				sc.SetState(SCE_C_STRING|activitySet);
+			} else if (sc.ch == '\'') {
+				sc.SetState(SCE_C_CHARACTER|activitySet);
+			} else if (sc.ch == '#' && visibleChars == 0) {
+				// Preprocessor commands are alone on their line
+				sc.SetState(SCE_C_PREPROCESSOR|activitySet);
+				// Skip whitespace between # and preprocessor word
+				do {
+					sc.Forward();
+				} while ((sc.ch == ' ' || sc.ch == '\t') && sc.More());
+				if (sc.atLineEnd) {
+					sc.SetState(SCE_C_DEFAULT|activitySet);
+				} else if (sc.Match("include")) {
+					isIncludePreprocessor = true;
+				} else {
+					if (options.trackPreprocessor) {
+						// If #if is nested too deeply (>31 levels) the active/inactive appearance
+						// will stop reflecting the code.
+						if (sc.Match("ifdef") || sc.Match("ifndef")) {
+							const bool isIfDef = sc.Match("ifdef");
+							const int startRest = isIfDef ? 5 : 6;
+							std::string restOfLine = GetRestOfLine(styler, sc.currentPos + startRest + 1, false);
+							bool foundDef = preprocessorDefinitions.find(restOfLine) != preprocessorDefinitions.end();
+							preproc.StartSection(isIfDef == foundDef);
+						} else if (sc.Match("if")) {
+							std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 2, true);
+							const bool ifGood = EvaluateExpression(restOfLine, preprocessorDefinitions);
+							preproc.StartSection(ifGood);
+						} else if (sc.Match("else")) {
+							// #else is shown as active if either preceding or following section is active
+							// as that means that it contributed to the result.
+							if (!preproc.CurrentIfTaken()) {
+								// Inactive, may become active if parent scope active
+								assert(sc.state == (SCE_C_PREPROCESSOR|inactiveFlag));
+								preproc.InvertCurrentLevel();
+								activitySet = preproc.ActiveState();
+								// If following is active then show "else" as active
+								if (!activitySet)
+									sc.ChangeState(SCE_C_PREPROCESSOR);
+							} else if (preproc.IsActive()) {
+								// Active -> inactive
+								assert(sc.state == SCE_C_PREPROCESSOR);
+								preproc.InvertCurrentLevel();
+								activitySet = preproc.ActiveState();
+								// Continue to show "else" as active as it ends active section.
+							}
+						} else if (sc.Match("elif")) {
+							// Ensure only one chosen out of #if .. #elif .. #elif .. #else .. #endif
+							// #elif is shown as active if either preceding or following section is active
+							// as that means that it contributed to the result.
+							if (!preproc.CurrentIfTaken()) {
+								// Inactive, if expression true then may become active if parent scope active
+								assert(sc.state == (SCE_C_PREPROCESSOR|inactiveFlag));
+								// Similar to #if
+								std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 4, true);
+								const bool ifGood = EvaluateExpression(restOfLine, preprocessorDefinitions);
+								if (ifGood) {
+									preproc.InvertCurrentLevel();
+									activitySet = preproc.ActiveState();
+									if (!activitySet)
+										sc.ChangeState(SCE_C_PREPROCESSOR);
+								}
+							} else if (preproc.IsActive()) {
+								// Active -> inactive
+								assert(sc.state == SCE_C_PREPROCESSOR);
+								preproc.InvertCurrentLevel();
+								activitySet = preproc.ActiveState();
+								// Continue to show "elif" as active as it ends active section.
+							}
+						} else if (sc.Match("endif")) {
+							preproc.EndSection();
+							activitySet = preproc.ActiveState();
+							sc.ChangeState(SCE_C_PREPROCESSOR|activitySet);
+						} else if (sc.Match("define")) {
+							if (options.updatePreprocessor && preproc.IsActive()) {
+								std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 6, true);
+								size_t startName = 0;
+								while ((startName < restOfLine.length()) && IsSpaceOrTab(restOfLine[startName]))
+									startName++;
+								size_t endName = startName;
+								while ((endName < restOfLine.length()) && setWord.Contains(restOfLine[endName]))
+									endName++;
+								std::string key = restOfLine.substr(startName, endName-startName);
+								if ((endName < restOfLine.length()) && (restOfLine.at(endName) == '(')) {
+									// Macro
+									size_t endArgs = endName;
+									while ((endArgs < restOfLine.length()) && (restOfLine[endArgs] != ')'))
+										endArgs++;
+									std::string args = restOfLine.substr(endName + 1, endArgs - endName - 1);
+									size_t startValue = endArgs+1;
+									while ((startValue < restOfLine.length()) && IsSpaceOrTab(restOfLine[startValue]))
+										startValue++;
+									std::string value;
+									if (startValue < restOfLine.length())
+										value = restOfLine.substr(startValue);
+									preprocessorDefinitions[key] = SymbolValue(value, args);
+									ppDefineHistory.push_back(PPDefinition(lineCurrent, key, value, false, args));
+									definitionsChanged = true;
+								} else {
+									// Value
+									size_t startValue = endName;
+									while ((startValue < restOfLine.length()) && IsSpaceOrTab(restOfLine[startValue]))
+										startValue++;
+									std::string value = restOfLine.substr(startValue);
+									if (OnlySpaceOrTab(value))
+										value = "1";	// No value defaults to 1
+									preprocessorDefinitions[key] = value;
+									ppDefineHistory.push_back(PPDefinition(lineCurrent, key, value));
+									definitionsChanged = true;
+								}
+							}
+						} else if (sc.Match("undef")) {
+							if (options.updatePreprocessor && preproc.IsActive()) {
+								const std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 5, false);
+								std::vector<std::string> tokens = Tokenize(restOfLine);
+								if (tokens.size() >= 1) {
+									const std::string key = tokens[0];
+									preprocessorDefinitions.erase(key);
+									ppDefineHistory.push_back(PPDefinition(lineCurrent, key, "", true));
+									definitionsChanged = true;
+								}
+							}
+						}
+					}
+				}
+			} else if (isoperator(sc.ch)) {
+				sc.SetState(SCE_C_OPERATOR|activitySet);
+			}
+		}
+
+		if (!IsASpace(sc.ch) && !IsSpaceEquiv(MaskActive(sc.state))) {
+			chPrevNonWhite = sc.ch;
+			visibleChars++;
+		}
+		continuationLine = false;
+		sc.Forward();
+	}
+	const bool rawStringsChanged = rawStringTerminators.Merge(rawSTNew, lineCurrent);
+	if (definitionsChanged || rawStringsChanged)
+		styler.ChangeLexerState(startPos, startPos + length);
+	sc.Complete();
+}
+
+// Store both the current line's fold level and the next lines in the
+// level store to make it easy to pick up with each increment
+// and to make it possible to fiddle the current level for "} else {".
+
+void SCI_METHOD LexerCPP::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+
+	if (!options.fold)
+		return;
+
+	LexAccessor styler(pAccess);
+
+	const Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	bool inLineComment = false;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelCurrent = SC_FOLDLEVELBASE;
+	if (lineCurrent > 0)
+		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
+	Sci_PositionU lineStartNext = styler.LineStart(lineCurrent+1);
+	int levelMinCurrent = levelCurrent;
+	int levelNext = levelCurrent;
+	char chNext = styler[startPos];
+	int styleNext = MaskActive(styler.StyleAt(startPos));
+	int style = MaskActive(initStyle);
+	const bool userDefinedFoldMarkers = !options.foldExplicitStart.empty() && !options.foldExplicitEnd.empty();
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		const char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		const int stylePrev = style;
+		style = styleNext;
+		styleNext = MaskActive(styler.StyleAt(i + 1));
+		const bool atEOL = i == (lineStartNext-1);
+		if ((style == SCE_C_COMMENTLINE) || (style == SCE_C_COMMENTLINEDOC))
+			inLineComment = true;
+		if (options.foldComment && options.foldCommentMultiline && IsStreamCommentStyle(style) && !inLineComment) {
+			if (!IsStreamCommentStyle(stylePrev)) {
+				levelNext++;
+			} else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
+				// Comments don't end at end of line and the next character may be unstyled.
+				levelNext--;
+			}
+		}
+		if (options.foldComment && options.foldCommentExplicit && ((style == SCE_C_COMMENTLINE) || options.foldExplicitAnywhere)) {
+			if (userDefinedFoldMarkers) {
+				if (styler.Match(i, options.foldExplicitStart.c_str())) {
+					levelNext++;
+				} else if (styler.Match(i, options.foldExplicitEnd.c_str())) {
+					levelNext--;
+				}
+			} else {
+				if ((ch == '/') && (chNext == '/')) {
+					const char chNext2 = styler.SafeGetCharAt(i + 2);
+					if (chNext2 == '{') {
+						levelNext++;
+					} else if (chNext2 == '}') {
+						levelNext--;
+					}
+				}
+			}
+		}
+		if (options.foldPreprocessor && (style == SCE_C_PREPROCESSOR)) {
+			if (ch == '#') {
+				Sci_PositionU j = i + 1;
+				while ((j < endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
+					j++;
+				}
+				if (styler.Match(j, "region") || styler.Match(j, "if")) {
+					levelNext++;
+				} else if (styler.Match(j, "end")) {
+					levelNext--;
+				}
+
+				if (options.foldPreprocessorAtElse && (styler.Match(j, "else") || styler.Match(j, "elif"))) {
+					levelMinCurrent--;
+				}
+			}
+		}
+		if (options.foldSyntaxBased && (style == SCE_C_OPERATOR)) {
+			if (ch == '{' || ch == '[' || ch == '(') {
+				// Measure the minimum before a '{' to allow
+				// folding on "} else {"
+				if (options.foldAtElse && levelMinCurrent > levelNext) {
+					levelMinCurrent = levelNext;
+				}
+				levelNext++;
+			} else if (ch == '}' || ch == ']' || ch == ')') {
+				levelNext--;
+			}
+		}
+		if (!IsASpace(ch))
+			visibleChars++;
+		if (atEOL || (i == endPos-1)) {
+			int levelUse = levelCurrent;
+			if ((options.foldSyntaxBased && options.foldAtElse) ||
+				(options.foldPreprocessor && options.foldPreprocessorAtElse)
+			) {
+				levelUse = levelMinCurrent;
+			}
+			int lev = levelUse | levelNext << 16;
+			if (visibleChars == 0 && options.foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if (levelUse < levelNext)
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			lineStartNext = styler.LineStart(lineCurrent+1);
+			levelCurrent = levelNext;
+			levelMinCurrent = levelCurrent;
+			if (atEOL && (i == static_cast<Sci_PositionU>(styler.Length()-1))) {
+				// There is an empty line at end of file so give it same level and empty
+				styler.SetLevel(lineCurrent, (levelCurrent | levelCurrent << 16) | SC_FOLDLEVELWHITEFLAG);
+			}
+			visibleChars = 0;
+			inLineComment = false;
+		}
+	}
+}
+
+void LexerCPP::EvaluateTokens(std::vector<std::string> &tokens, const SymbolTable &preprocessorDefinitions) {
+
+	// Remove whitespace tokens
+	tokens.erase(std::remove_if(tokens.begin(), tokens.end(), OnlySpaceOrTab), tokens.end());
+
+	// Evaluate defined statements to either 0 or 1
+	for (size_t i=0; (i+1)<tokens.size();) {
+		if (tokens[i] == "defined") {
+			const char *val = "0";
+			if (tokens[i+1] == "(") {
+				if (((i + 2)<tokens.size()) && (tokens[i + 2] == ")")) {
+					// defined()
+					tokens.erase(tokens.begin() + i + 1, tokens.begin() + i + 3);
+				} else if (((i+3)<tokens.size()) && (tokens[i+3] == ")")) {
+					// defined(<identifier>)
+					SymbolTable::const_iterator it = preprocessorDefinitions.find(tokens[i+2]);
+					if (it != preprocessorDefinitions.end()) {
+						val = "1";
+					}
+					tokens.erase(tokens.begin() + i + 1, tokens.begin() + i + 4);
+				} else {
+					// Spurious '(' so erase as more likely to result in false
+					tokens.erase(tokens.begin() + i + 1, tokens.begin() + i + 2);
+				}
+			} else {
+				// defined <identifier>
+				SymbolTable::const_iterator it = preprocessorDefinitions.find(tokens[i+1]);
+				if (it != preprocessorDefinitions.end()) {
+					val = "1";
+				}
+				tokens.erase(tokens.begin() + i + 1, tokens.begin() + i + 2);
+			}
+			tokens[i] = val;
+		} else {
+			i++;
+		}
+	}
+
+	// Evaluate identifiers
+	constexpr size_t maxIterations = 100;
+	size_t iterations = 0;	// Limit number of iterations in case there is a recursive macro.
+	for (size_t i = 0; (i<tokens.size()) && (iterations < maxIterations);) {
+		iterations++;
+		if (setWordStart.Contains(tokens[i][0])) {
+			SymbolTable::const_iterator it = preprocessorDefinitions.find(tokens[i]);
+			if (it != preprocessorDefinitions.end()) {
+				// Tokenize value
+				std::vector<std::string> macroTokens = Tokenize(it->second.value);
+				if (it->second.IsMacro()) {
+					if ((i + 1 < tokens.size()) && (tokens.at(i + 1) == "(")) {
+						// Create map of argument name to value
+						std::vector<std::string> argumentNames = StringSplit(it->second.arguments, ',');
+						std::map<std::string, std::string> arguments;
+						size_t arg = 0;
+						size_t tok = i+2;
+						while ((tok < tokens.size()) && (arg < argumentNames.size()) && (tokens.at(tok) != ")")) {
+							if (tokens.at(tok) != ",") {
+								arguments[argumentNames.at(arg)] = tokens.at(tok);
+								arg++;
+							}
+							tok++;
+						}
+
+						// Remove invocation
+						tokens.erase(tokens.begin() + i, tokens.begin() + tok + 1);
+
+						// Substitute values into macro
+						macroTokens.erase(std::remove_if(macroTokens.begin(), macroTokens.end(), OnlySpaceOrTab), macroTokens.end());
+
+						for (size_t iMacro = 0; iMacro < macroTokens.size();) {
+							if (setWordStart.Contains(macroTokens[iMacro][0])) {
+								std::map<std::string, std::string>::const_iterator itFind = arguments.find(macroTokens[iMacro]);
+								if (itFind != arguments.end()) {
+									// TODO: Possible that value will be expression so should insert tokenized form
+									macroTokens[iMacro] = itFind->second;
+								}
+							}
+							iMacro++;
+						}
+
+						// Insert results back into tokens
+						tokens.insert(tokens.begin() + i, macroTokens.begin(), macroTokens.end());
+
+					} else {
+						i++;
+					}
+				} else {
+					// Remove invocation
+					tokens.erase(tokens.begin() + i);
+					// Insert results back into tokens
+					tokens.insert(tokens.begin() + i, macroTokens.begin(), macroTokens.end());
+				}
+			} else {
+				// Identifier not found and value defaults to zero
+				tokens[i] = "0";
+			}
+		} else {
+			i++;
+		}
+	}
+
+	// Find bracketed subexpressions and recurse on them
+	BracketPair bracketPair = FindBracketPair(tokens);
+	while (bracketPair.itBracket != tokens.end()) {
+		std::vector<std::string> inBracket(bracketPair.itBracket + 1, bracketPair.itEndBracket);
+		EvaluateTokens(inBracket, preprocessorDefinitions);
+
+		// The insertion is done before the removal because there were failures with the opposite approach
+		tokens.insert(bracketPair.itBracket, inBracket.begin(), inBracket.end());
+
+		bracketPair = FindBracketPair(tokens);
+		tokens.erase(bracketPair.itBracket, bracketPair.itEndBracket + 1);
+
+		bracketPair = FindBracketPair(tokens);
+	}
+
+	// Evaluate logical negations
+	for (size_t j=0; (j+1)<tokens.size();) {
+		if (setNegationOp.Contains(tokens[j][0])) {
+			int isTrue = atoi(tokens[j+1].c_str());
+			if (tokens[j] == "!")
+				isTrue = !isTrue;
+			std::vector<std::string>::iterator itInsert =
+				tokens.erase(tokens.begin() + j, tokens.begin() + j + 2);
+			tokens.insert(itInsert, isTrue ? "1" : "0");
+		} else {
+			j++;
+		}
+	}
+
+	// Evaluate expressions in precedence order
+	enum precedence { precMult, precAdd, precRelative
+		, precLogical, /* end marker */ precLast };
+	for (int prec = precMult; prec < precLast; prec++) {
+		// Looking at 3 tokens at a time so end at 2 before end
+		for (size_t k=0; (k+2)<tokens.size();) {
+			const char chOp = tokens[k+1][0];
+			if (
+				((prec==precMult) && setMultOp.Contains(chOp)) ||
+				((prec==precAdd) && setAddOp.Contains(chOp)) ||
+				((prec==precRelative) && setRelOp.Contains(chOp)) ||
+				((prec==precLogical) && setLogicalOp.Contains(chOp))
+				) {
+				const int valA = atoi(tokens[k].c_str());
+				const int valB = atoi(tokens[k+2].c_str());
+				int result = 0;
+				if (tokens[k+1] == "+")
+					result = valA + valB;
+				else if (tokens[k+1] == "-")
+					result = valA - valB;
+				else if (tokens[k+1] == "*")
+					result = valA * valB;
+				else if (tokens[k+1] == "/")
+					result = valA / (valB ? valB : 1);
+				else if (tokens[k+1] == "%")
+					result = valA % (valB ? valB : 1);
+				else if (tokens[k+1] == "<")
+					result = valA < valB;
+				else if (tokens[k+1] == "<=")
+					result = valA <= valB;
+				else if (tokens[k+1] == ">")
+					result = valA > valB;
+				else if (tokens[k+1] == ">=")
+					result = valA >= valB;
+				else if (tokens[k+1] == "==")
+					result = valA == valB;
+				else if (tokens[k+1] == "!=")
+					result = valA != valB;
+				else if (tokens[k+1] == "||")
+					result = valA || valB;
+				else if (tokens[k+1] == "&&")
+					result = valA && valB;
+				std::vector<std::string>::iterator itInsert =
+					tokens.erase(tokens.begin() + k, tokens.begin() + k + 3);
+				tokens.insert(itInsert, std::to_string(result));
+			} else {
+				k++;
+			}
+		}
+	}
+}
+
+std::vector<std::string> LexerCPP::Tokenize(const std::string &expr) const {
+	// Break into tokens
+	std::vector<std::string> tokens;
+	const char *cp = expr.c_str();
+	while (*cp) {
+		std::string word;
+		if (setWord.Contains(*cp)) {
+			// Identifiers and numbers
+			while (setWord.Contains(*cp)) {
+				word += *cp;
+				cp++;
+			}
+		} else if (IsSpaceOrTab(*cp)) {
+			while (IsSpaceOrTab(*cp)) {
+				word += *cp;
+				cp++;
+			}
+		} else if (setRelOp.Contains(*cp)) {
+			word += *cp;
+			cp++;
+			if (setRelOp.Contains(*cp)) {
+				word += *cp;
+				cp++;
+			}
+		} else if (setLogicalOp.Contains(*cp)) {
+			word += *cp;
+			cp++;
+			if (setLogicalOp.Contains(*cp)) {
+				word += *cp;
+				cp++;
+			}
+		} else {
+			// Should handle strings, characters, and comments here
+			word += *cp;
+			cp++;
+		}
+		tokens.push_back(word);
+	}
+	return tokens;
+}
+
+bool LexerCPP::EvaluateExpression(const std::string &expr, const SymbolTable &preprocessorDefinitions) {
+	std::vector<std::string> tokens = Tokenize(expr);
+
+	EvaluateTokens(tokens, preprocessorDefinitions);
+
+	// "0" or "" -> false else true
+	const bool isFalse = tokens.empty() ||
+		((tokens.size() == 1) && ((tokens[0] == "") || tokens[0] == "0"));
+	return !isFalse;
+}
+
+LexerModule lmCPP(SCLEX_CPP, LexerCPP::LexerFactoryCPP, "cpp", cppWordLists);
+LexerModule lmCPPNoCase(SCLEX_CPPNOCASE, LexerCPP::LexerFactoryCPPInsensitive, "cppnocase", cppWordLists);
diff --git a/Pythonwin/Scintilla/src/LexCSS.cxx b/Pythonwin/Scintilla/lexers/LexCSS.cxx
similarity index 58%
rename from Pythonwin/Scintilla/src/LexCSS.cxx
rename to Pythonwin/Scintilla/lexers/LexCSS.cxx
index 3b139cdcd..c1a86f537 100644
--- a/Pythonwin/Scintilla/src/LexCSS.cxx
+++ b/Pythonwin/Scintilla/lexers/LexCSS.cxx
@@ -1,30 +1,38 @@
 // Scintilla source code edit control
+// Encoding: UTF-8
 /** @file LexCSS.cxx
  ** Lexer for Cascading Style Sheets
- ** Written by Jakub Vrána
+ ** Written by Jakub Vrána
  ** Improved by Philippe Lhoste (CSS2)
+ ** Improved by Ross McKay (SCSS mode; see http://sass-lang.com/ )
  **/
 // Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
+// TODO: handle SCSS nested properties like font: { weight: bold; size: 1em; }
+// TODO: handle SCSS interpolation: #{}
+// TODO: add features for Less if somebody feels like contributing; http://lesscss.org/
+// TODO: refactor this monster so that the next poor slob can read it!
+
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 
 static inline bool IsAWordChar(const unsigned int ch) {
@@ -48,7 +56,23 @@ inline bool IsCssOperator(const int ch) {
 	return false;
 }
 
-static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], Accessor &styler) {
+// look behind (from start of document to our start position) to determine current nesting level
+inline int NestingLevelLookBehind(Sci_PositionU startPos, Accessor &styler) {
+	int ch;
+	int nestingLevel = 0;
+
+	for (Sci_PositionU i = 0; i < startPos; i++) {
+		ch = styler.SafeGetCharAt(i);
+		if (ch == '{')
+			nestingLevel++;
+		else if (ch == '}')
+			nestingLevel--;
+	}
+
+	return nestingLevel;
+}
+
+static void ColouriseCssDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[], Accessor &styler) {
 	WordList &css1Props = *keywordlists[0];
 	WordList &pseudoClasses = *keywordlists[1];
 	WordList &css2Props = *keywordlists[2];
@@ -62,15 +86,51 @@ static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, Wo
 
 	int lastState = -1; // before operator
 	int lastStateC = -1; // before comment
+	int lastStateS = -1; // before single-quoted/double-quoted string
+	int lastStateVar = -1; // before variable (SCSS)
+	int lastStateVal = -1; // before value (SCSS)
 	int op = ' '; // last operator
 	int opPrev = ' '; // last operator
+	bool insideParentheses = false; // true if currently in a CSS url() or similar construct
+
+	// property lexer.css.scss.language
+	//	Set to 1 for Sassy CSS (.scss)
+	bool isScssDocument = styler.GetPropertyInt("lexer.css.scss.language") != 0;
+
+	// property lexer.css.less.language
+	// Set to 1 for Less CSS (.less)
+	bool isLessDocument = styler.GetPropertyInt("lexer.css.less.language") != 0;
+
+	// property lexer.css.hss.language
+	// Set to 1 for HSS (.hss)
+	bool isHssDocument = styler.GetPropertyInt("lexer.css.hss.language") != 0;
+
+	// SCSS/LESS/HSS have the concept of variable
+	bool hasVariables = isScssDocument || isLessDocument || isHssDocument;
+	char varPrefix = 0;
+	if (hasVariables)
+		varPrefix = isLessDocument ? '@' : '$';
+
+	// SCSS/LESS/HSS support single-line comments
+	typedef enum _CommentModes { eCommentBlock = 0, eCommentLine = 1} CommentMode;
+	CommentMode comment_mode = eCommentBlock;
+	bool hasSingleLineComments = isScssDocument || isLessDocument || isHssDocument;
+
+	// must keep track of nesting level in document types that support it (SCSS/LESS/HSS)
+	bool hasNesting = false;
+	int nestingLevel = 0;
+	if (isScssDocument || isLessDocument || isHssDocument) {
+		hasNesting = true;
+		nestingLevel = NestingLevelLookBehind(startPos, styler);
+	}
 
+	// "the loop"
 	for (; sc.More(); sc.Forward()) {
-		if (sc.state == SCE_CSS_COMMENT && sc.Match('*', '/')) {
+		if (sc.state == SCE_CSS_COMMENT && ((comment_mode == eCommentBlock && sc.Match('*', '/')) || (comment_mode == eCommentLine && sc.atLineEnd))) {
 			if (lastStateC == -1) {
 				// backtrack to get last state:
 				// comments are like whitespace, so we must return to the previous state
-				unsigned int i = startPos;
+				Sci_PositionU i = startPos;
 				for (; i > 0; i--) {
 					if ((lastStateC = styler.StyleAt(i-1)) != SCE_CSS_COMMENT) {
 						if (lastStateC == SCE_CSS_OPERATOR) {
@@ -90,8 +150,12 @@ static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, Wo
 				if (i == 0)
 					lastStateC = SCE_CSS_DEFAULT;
 			}
-			sc.Forward();
-			sc.ForwardSetState(lastStateC);
+			if (comment_mode == eCommentBlock) {
+				sc.Forward();
+				sc.ForwardSetState(lastStateC);
+			} else /* eCommentLine */ {
+				sc.SetState(lastStateC);
+			}
 		}
 
 		if (sc.state == SCE_CSS_COMMENT)
@@ -100,17 +164,17 @@ static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, Wo
 		if (sc.state == SCE_CSS_DOUBLESTRING || sc.state == SCE_CSS_SINGLESTRING) {
 			if (sc.ch != (sc.state == SCE_CSS_DOUBLESTRING ? '\"' : '\''))
 				continue;
-			unsigned int i = sc.currentPos;
+			Sci_PositionU i = sc.currentPos;
 			while (i && styler[i-1] == '\\')
 				i--;
 			if ((sc.currentPos - i) % 2 == 1)
 				continue;
-			sc.ForwardSetState(SCE_CSS_VALUE);
+			sc.ForwardSetState(lastStateS);
 		}
 
 		if (sc.state == SCE_CSS_OPERATOR) {
 			if (op == ' ') {
-				unsigned int i = startPos;
+				Sci_PositionU i = startPos;
 				op = styler.SafeGetCharAt(i-1);
 				opPrev = styler.SafeGetCharAt(i-2);
 				while (--i) {
@@ -121,7 +185,7 @@ static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, Wo
 			}
 			switch (op) {
 			case '@':
-				if (lastState == SCE_CSS_DEFAULT)
+				if (lastState == SCE_CSS_DEFAULT || hasNesting)
 					sc.SetState(SCE_CSS_DIRECTIVE);
 				break;
 			case '>':
@@ -140,15 +204,33 @@ static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, Wo
 					sc.SetState(SCE_CSS_TAG);
 				break;
 			case '{':
-				if (lastState == SCE_CSS_DIRECTIVE)
+				nestingLevel++;
+				switch (lastState) {
+				case SCE_CSS_MEDIA:
 					sc.SetState(SCE_CSS_DEFAULT);
-				else if (lastState == SCE_CSS_TAG)
+					break;
+				case SCE_CSS_TAG:
+				case SCE_CSS_DIRECTIVE:
 					sc.SetState(SCE_CSS_IDENTIFIER);
+					break;
+				}
 				break;
 			case '}':
-				if (lastState == SCE_CSS_DEFAULT || lastState == SCE_CSS_VALUE || lastState == SCE_CSS_IMPORTANT ||
-					lastState == SCE_CSS_IDENTIFIER || lastState == SCE_CSS_IDENTIFIER2 || lastState == SCE_CSS_IDENTIFIER3)
-					sc.SetState(SCE_CSS_DEFAULT);
+				if (--nestingLevel < 0)
+					nestingLevel = 0;
+				switch (lastState) {
+				case SCE_CSS_DEFAULT:
+				case SCE_CSS_VALUE:
+				case SCE_CSS_IMPORTANT:
+				case SCE_CSS_IDENTIFIER:
+				case SCE_CSS_IDENTIFIER2:
+				case SCE_CSS_IDENTIFIER3:
+					if (hasNesting)
+						sc.SetState(nestingLevel > 0 ? SCE_CSS_IDENTIFIER : SCE_CSS_DEFAULT);
+					else
+						sc.SetState(SCE_CSS_DEFAULT);
+					break;
+				}
 				break;
 			case '(':
 				if (lastState == SCE_CSS_PSEUDOCLASS)
@@ -163,14 +245,28 @@ static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, Wo
 					sc.SetState(SCE_CSS_TAG);
 				break;
 			case ':':
-				if (lastState == SCE_CSS_TAG || lastState == SCE_CSS_DEFAULT || lastState == SCE_CSS_CLASS || lastState == SCE_CSS_ID ||
-					lastState == SCE_CSS_PSEUDOCLASS || lastState == SCE_CSS_EXTENDED_PSEUDOCLASS || lastState == SCE_CSS_UNKNOWN_PSEUDOCLASS ||
-					lastState == SCE_CSS_PSEUDOELEMENT || lastState == SCE_CSS_EXTENDED_PSEUDOELEMENT)
+				switch (lastState) {
+				case SCE_CSS_TAG:
+				case SCE_CSS_DEFAULT:
+				case SCE_CSS_CLASS:
+				case SCE_CSS_ID:
+				case SCE_CSS_PSEUDOCLASS:
+				case SCE_CSS_EXTENDED_PSEUDOCLASS:
+				case SCE_CSS_UNKNOWN_PSEUDOCLASS:
+				case SCE_CSS_PSEUDOELEMENT:
+				case SCE_CSS_EXTENDED_PSEUDOELEMENT:
 					sc.SetState(SCE_CSS_PSEUDOCLASS);
-				else if (lastState == SCE_CSS_IDENTIFIER || lastState == SCE_CSS_IDENTIFIER2 ||
-					lastState == SCE_CSS_IDENTIFIER3 || lastState == SCE_CSS_EXTENDED_IDENTIFIER ||
-					lastState == SCE_CSS_UNKNOWN_IDENTIFIER)
+					break;
+				case SCE_CSS_IDENTIFIER:
+				case SCE_CSS_IDENTIFIER2:
+				case SCE_CSS_IDENTIFIER3:
+				case SCE_CSS_EXTENDED_IDENTIFIER:
+				case SCE_CSS_UNKNOWN_IDENTIFIER:
+				case SCE_CSS_VARIABLE:
 					sc.SetState(SCE_CSS_VALUE);
+					lastStateVal = lastState;
+					break;
+				}
 				break;
 			case '.':
 				if (lastState == SCE_CSS_TAG || lastState == SCE_CSS_DEFAULT || lastState == SCE_CSS_CLASS || lastState == SCE_CSS_ID ||
@@ -189,10 +285,40 @@ static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, Wo
 					sc.SetState(SCE_CSS_DEFAULT);
 				break;
 			case ';':
-				if (lastState == SCE_CSS_DIRECTIVE)
-					sc.SetState(SCE_CSS_DEFAULT);
-				else if (lastState == SCE_CSS_VALUE || lastState == SCE_CSS_IMPORTANT)
-					sc.SetState(SCE_CSS_IDENTIFIER);
+				switch (lastState) {
+				case SCE_CSS_DIRECTIVE:
+					if (hasNesting) {
+						sc.SetState(nestingLevel > 0 ? SCE_CSS_IDENTIFIER : SCE_CSS_DEFAULT);
+					} else {
+						sc.SetState(SCE_CSS_DEFAULT);
+					}
+					break;
+				case SCE_CSS_VALUE:
+				case SCE_CSS_IMPORTANT:
+					// data URLs can have semicolons; simplistically check for wrapping parentheses and move along
+					if (insideParentheses) {
+						sc.SetState(lastState);
+					} else {
+						if (lastStateVal == SCE_CSS_VARIABLE) {
+							sc.SetState(SCE_CSS_DEFAULT);
+						} else {
+							sc.SetState(SCE_CSS_IDENTIFIER);
+						}
+					}
+					break;
+				case SCE_CSS_VARIABLE:
+					if (lastStateVar == SCE_CSS_VALUE) {
+						// data URLs can have semicolons; simplistically check for wrapping parentheses and move along
+						if (insideParentheses) {
+							sc.SetState(SCE_CSS_VALUE);
+						} else {
+							sc.SetState(SCE_CSS_IDENTIFIER);
+						}
+					} else {
+						sc.SetState(SCE_CSS_DEFAULT);
+					}
+					break;
+				}
 				break;
 			case '!':
 				if (lastState == SCE_CSS_VALUE)
@@ -201,14 +327,78 @@ static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, Wo
 			}
 		}
 
-		if (IsAWordChar(sc.ch)) {
-			if (sc.state == SCE_CSS_DEFAULT)
-				sc.SetState(SCE_CSS_TAG);
+		if (sc.ch == '*' && sc.state == SCE_CSS_DEFAULT) {
+			sc.SetState(SCE_CSS_TAG);
 			continue;
 		}
 
-		if (sc.ch == '*' && sc.state == SCE_CSS_DEFAULT) {
-			sc.SetState(SCE_CSS_TAG);
+		// check for inside parentheses (whether part of an "operator" or not)
+		if (sc.ch == '(')
+			insideParentheses = true;
+		else if (sc.ch == ')')
+			insideParentheses = false;
+
+		// SCSS special modes
+		if (hasVariables) {
+			// variable name
+			if (sc.ch == varPrefix) {
+				switch (sc.state) {
+				case SCE_CSS_DEFAULT:
+					if (isLessDocument) // give priority to pseudo elements
+						break;
+					// Falls through.
+				case SCE_CSS_VALUE:
+					lastStateVar = sc.state;
+					sc.SetState(SCE_CSS_VARIABLE);
+					continue;
+				}
+			}
+			if (sc.state == SCE_CSS_VARIABLE) {
+				if (IsAWordChar(sc.ch)) {
+					// still looking at the variable name
+					continue;
+				}
+				if (lastStateVar == SCE_CSS_VALUE) {
+					// not looking at the variable name any more, and it was part of a value
+					sc.SetState(SCE_CSS_VALUE);
+				}
+			}
+
+			// nested rule parent selector
+			if (sc.ch == '&') {
+				switch (sc.state) {
+				case SCE_CSS_DEFAULT:
+				case SCE_CSS_IDENTIFIER:
+					sc.SetState(SCE_CSS_TAG);
+					continue;
+				}
+			}
+		}
+
+		// nesting rules that apply to SCSS and Less
+		if (hasNesting) {
+			// check for nested rule selector
+			if (sc.state == SCE_CSS_IDENTIFIER && (IsAWordChar(sc.ch) || sc.ch == ':' || sc.ch == '.' || sc.ch == '#')) {
+				// look ahead to see whether { comes before next ; and }
+				Sci_PositionU endPos = startPos + length;
+				int ch;
+
+				for (Sci_PositionU i = sc.currentPos; i < endPos; i++) {
+					ch = styler.SafeGetCharAt(i);
+					if (ch == ';' || ch == '}')
+						break;
+					if (ch == '{') {
+						sc.SetState(SCE_CSS_DEFAULT);
+						continue;
+					}
+				}
+			}
+
+		}
+
+		if (IsAWordChar(sc.ch)) {
+			if (sc.state == SCE_CSS_DEFAULT)
+				sc.SetState(SCE_CSS_TAG);
 			continue;
 		}
 
@@ -219,7 +409,8 @@ static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, Wo
 			sc.state == SCE_CSS_PSEUDOCLASS || sc.state == SCE_CSS_PSEUDOELEMENT ||
 			sc.state == SCE_CSS_EXTENDED_PSEUDOCLASS || sc.state == SCE_CSS_EXTENDED_PSEUDOELEMENT ||
 			sc.state == SCE_CSS_UNKNOWN_PSEUDOCLASS ||
-			sc.state == SCE_CSS_IMPORTANT
+			sc.state == SCE_CSS_IMPORTANT ||
+			sc.state == SCE_CSS_DIRECTIVE
 		)) {
 			char s[100];
 			sc.GetCurrentLowered(s, sizeof(s));
@@ -263,6 +454,10 @@ static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, Wo
 				if (strcmp(s2, "important") != 0)
 					sc.ChangeState(SCE_CSS_VALUE);
 				break;
+			case SCE_CSS_DIRECTIVE:
+				if (op == '@' && strcmp(s2, "media") == 0)
+					sc.ChangeState(SCE_CSS_MEDIA);
+				break;
 			}
 		}
 
@@ -278,14 +473,23 @@ static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, Wo
 
 		if (sc.Match('/', '*')) {
 			lastStateC = sc.state;
+			comment_mode = eCommentBlock;
+			sc.SetState(SCE_CSS_COMMENT);
+			sc.Forward();
+		} else if (hasSingleLineComments && sc.Match('/', '/') && !insideParentheses) {
+			// note that we've had to treat ([...]// as the start of a URL not a comment, e.g. url(http://example.com), url(//example.com)
+			lastStateC = sc.state;
+			comment_mode = eCommentLine;
 			sc.SetState(SCE_CSS_COMMENT);
 			sc.Forward();
-		} else if (sc.state == SCE_CSS_VALUE && (sc.ch == '\"' || sc.ch == '\'')) {
+		} else if ((sc.state == SCE_CSS_VALUE || sc.state == SCE_CSS_ATTRIBUTE)
+			&& (sc.ch == '\"' || sc.ch == '\'')) {
+			lastStateS = sc.state;
 			sc.SetState((sc.ch == '\"' ? SCE_CSS_DOUBLESTRING : SCE_CSS_SINGLESTRING));
 		} else if (IsCssOperator(sc.ch)
 			&& (sc.state != SCE_CSS_ATTRIBUTE || sc.ch == ']')
 			&& (sc.state != SCE_CSS_VALUE || sc.ch == ';' || sc.ch == '}' || sc.ch == '!')
-			&& (sc.state != SCE_CSS_DIRECTIVE || sc.ch == ';' || sc.ch == '{')
+			&& ((sc.state != SCE_CSS_DIRECTIVE && sc.state != SCE_CSS_MEDIA) || sc.ch == ';' || sc.ch == '{')
 		) {
 			if (sc.state != SCE_CSS_OPERATOR)
 				lastState = sc.state;
@@ -298,17 +502,17 @@ static void ColouriseCssDoc(unsigned int startPos, int length, int initStyle, Wo
 	sc.Complete();
 }
 
-static void FoldCSSDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
+static void FoldCSSDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
 	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	char chNext = styler[startPos];
 	bool inComment = (styler.StyleAt(startPos-1) == SCE_CSS_COMMENT);
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int style = styler.StyleAt(i);
diff --git a/Pythonwin/Scintilla/src/LexCaml.cxx b/Pythonwin/Scintilla/lexers/LexCaml.cxx
similarity index 63%
rename from Pythonwin/Scintilla/src/LexCaml.cxx
rename to Pythonwin/Scintilla/lexers/LexCaml.cxx
index 539eee0de..1339b5dcc 100644
--- a/Pythonwin/Scintilla/src/LexCaml.cxx
+++ b/Pythonwin/Scintilla/lexers/LexCaml.cxx
@@ -2,7 +2,7 @@
 /** @file LexCaml.cxx
  ** Lexer for Objective Caml.
  **/
-// Copyright 2005 by Robert Roessler <robertr@rftp.com>
+// Copyright 2005-2009 by Robert Roessler <robertr@rftp.com>
 // The License.txt file describes the conditions under which this software may be distributed.
 /*	Release History
 	20050204 Initial release.
@@ -15,61 +15,71 @@
 	20051125 Added 2nd "optional" keywords class.
 	20051129 Support "magic" (read-only) comments for RCaml.
 	20051204 Swtich to using StyleContext infrastructure.
+	20090629 Add full Standard ML '97 support.
 */
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wcomma"
+#endif
 
 //	Since the Microsoft __iscsym[f] funcs are not ANSI...
 inline int  iscaml(int c) {return isalnum(c) || c == '_';}
 inline int iscamlf(int c) {return isalpha(c) || c == '_';}
-inline int iscamld(int c) {return isdigit(c) || c == '_';}
 
 static const int baseT[24] = {
 	0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,	/* A - L */
 	0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0,16	/* M - X */
 };
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 #ifdef BUILD_AS_EXTERNAL_LEXER
 /*
 	(actually seems to work!)
 */
+#include <string>
 #include "WindowAccessor.h"
 #include "ExternalLexer.h"
 
+#undef EXT_LEXER_DECL
+#define EXT_LEXER_DECL __declspec( dllexport ) __stdcall
+
 #if PLAT_WIN
 #include <windows.h>
 #endif
 
 static void ColouriseCamlDoc(
-	unsigned int startPos, int length,
+	Sci_PositionU startPos, Sci_Position length,
 	int initStyle,
 	WordList *keywordlists[],
 	Accessor &styler);
 
 static void FoldCamlDoc(
-	unsigned int startPos, int length,
+	Sci_PositionU startPos, Sci_Position length,
 	int initStyle,
 	WordList *keywordlists[],
 	Accessor &styler);
 
-static void InternalLexOrFold(int lexOrFold, unsigned int startPos, int length,
+static void InternalLexOrFold(int lexOrFold, Sci_PositionU startPos, Sci_Position length,
 	int initStyle, char *words[], WindowID window, char *props);
 
 static const char* LexerName = "caml";
@@ -101,7 +111,7 @@ long Platform::SendScintillaPointer(WindowID w, unsigned int msg, unsigned long
 		reinterpret_cast<LPARAM>(lParam));
 }
 
-void EXT_LEXER_DECL Fold(unsigned int lexer, unsigned int startPos, int length,
+void EXT_LEXER_DECL Fold(unsigned int lexer, Sci_PositionU startPos, Sci_Position length,
 	int initStyle, char *words[], WindowID window, char *props)
 {
 	// below useless evaluation(s) to supress "not used" warnings
@@ -130,7 +140,7 @@ void EXT_LEXER_DECL GetLexerName(unsigned int Index, char *name, int buflength)
 	}
 }
 
-void EXT_LEXER_DECL Lex(unsigned int lexer, unsigned int startPos, int length,
+void EXT_LEXER_DECL Lex(unsigned int lexer, Sci_PositionU startPos, Sci_Position length,
 	int initStyle, char *words[], WindowID window, char *props)
 {
 	// below useless evaluation(s) to supress "not used" warnings
@@ -139,11 +149,11 @@ void EXT_LEXER_DECL Lex(unsigned int lexer, unsigned int startPos, int length,
 	InternalLexOrFold(0, startPos, length, initStyle, words, window, props);
 }
 
-static void InternalLexOrFold(int foldOrLex, unsigned int startPos, int length,
+static void InternalLexOrFold(int foldOrLex, Sci_PositionU startPos, Sci_Position length,
 	int initStyle, char *words[], WindowID window, char *props)
 {
 	// create and initialize a WindowAccessor (including contained PropSet)
-	PropSet ps;
+	PropSetSimple ps;
 	ps.SetMultiple(props);
 	WindowAccessor wa(window, ps);
 	// create and initialize WordList(s)
@@ -172,32 +182,35 @@ static
 #endif	/* BUILD_AS_EXTERNAL_LEXER */
 
 void ColouriseCamlDoc(
-	unsigned int startPos, int length,
+	Sci_PositionU startPos, Sci_Position length,
 	int initStyle,
 	WordList *keywordlists[],
 	Accessor &styler)
 {
 	// initialize styler
 	StyleContext sc(startPos, length, initStyle, styler);
-	// set up [initial] state info (terminating states that shouldn't "bleed")
-	int nesting = 0;
-	if (sc.state < SCE_CAML_STRING)
-		sc.state = SCE_CAML_DEFAULT;
-	if (sc.state >= SCE_CAML_COMMENT)
-		nesting = (sc.state & 0x0f) - SCE_CAML_COMMENT;
 
-	int chBase = 0, chToken = 0, chLit = 0;
+	Sci_PositionU chToken = 0;
+	int chBase = 0, chLit = 0;
 	WordList& keywords  = *keywordlists[0];
 	WordList& keywords2 = *keywordlists[1];
 	WordList& keywords3 = *keywordlists[2];
+	const bool isSML = keywords.InList("andalso");
 	const int useMagic = styler.GetPropertyInt("lexer.caml.magic", 0);
 
+	// set up [initial] state info (terminating states that shouldn't "bleed")
+	const int state_ = sc.state & 0x0f;
+	if (state_ <= SCE_CAML_CHAR
+		|| (isSML && state_ == SCE_CAML_STRING))
+		sc.state = SCE_CAML_DEFAULT;
+	int nesting = (state_ >= SCE_CAML_COMMENT)? (state_ - SCE_CAML_COMMENT): 0;
+
 	// foreach char in range...
 	while (sc.More()) {
 		// set up [per-char] state info
-		int state2 = -1;		// (ASSUME no state change)
-		int chColor = sc.currentPos - 1;// (ASSUME standard coloring range)
-		bool advance = true;	// (ASSUME scanner "eats" 1 char)
+		int state2 = -1;				// (ASSUME no state change)
+		Sci_Position chColor = sc.currentPos - 1;// (ASSUME standard coloring range)
+		bool advance = true;			// (ASSUME scanner "eats" 1 char)
 
 		// step state machine
 		switch (sc.state & 0x0f) {
@@ -206,36 +219,49 @@ void ColouriseCamlDoc(
 			// it's wide open; what do we have?
 			if (iscamlf(sc.ch))
 				state2 = SCE_CAML_IDENTIFIER;
-			else if (sc.Match('`') && iscamlf(sc.chNext))
+			else if (!isSML && sc.Match('`') && iscamlf(sc.chNext))
 				state2 = SCE_CAML_TAGNAME;
-			else if (sc.Match('#') && isdigit(sc.chNext))
+			else if (!isSML && sc.Match('#') && isdigit(sc.chNext))
 				state2 = SCE_CAML_LINENUM;
 			else if (isdigit(sc.ch)) {
+				// it's a number, assume base 10
 				state2 = SCE_CAML_NUMBER, chBase = 10;
-				if (sc.Match('0') && strchr("bBoOxX", sc.chNext))
-					chBase = baseT[tolower(sc.chNext) - 'a'], sc.Forward();
-			} else if (sc.Match('\''))	/* (char literal?) */
+				if (sc.Match('0')) {
+					// there MAY be a base specified...
+					const char* baseC = "bBoOxX";
+					if (isSML) {
+						if (sc.chNext == 'w')
+							sc.Forward();	// (consume SML "word" indicator)
+						baseC = "x";
+					}
+					// ... change to specified base AS REQUIRED
+					if (strchr(baseC, sc.chNext))
+						chBase = baseT[tolower(sc.chNext) - 'a'], sc.Forward();
+				}
+			} else if (!isSML && sc.Match('\''))	// (Caml char literal?)
 				state2 = SCE_CAML_CHAR, chLit = 0;
-			else if (sc.Match('\"'))
+			else if (isSML && sc.Match('#', '"'))	// (SML char literal?)
+				state2 = SCE_CAML_CHAR, sc.Forward();
+			else if (sc.Match('"'))
 				state2 = SCE_CAML_STRING;
 			else if (sc.Match('(', '*'))
-				state2 = SCE_CAML_COMMENT,
-					sc.ch = ' ',	// (make SURE "(*)" isn't seen as a closed comment)
-					sc.Forward();
-			else if (strchr("!?~"		/* Caml "prefix-symbol" */
-					"=<>@^|&+-*/$%"		/* Caml "infix-symbol" */
-					"()[]{};,:.#", sc.ch))	/* Caml "bracket" or ;,:.# */
+				state2 = SCE_CAML_COMMENT, sc.Forward(), sc.ch = ' '; // (*)...
+			else if (strchr("!?~"			/* Caml "prefix-symbol" */
+					"=<>@^|&+-*/$%"			/* Caml "infix-symbol" */
+					"()[]{};,:.#", sc.ch)	// Caml "bracket" or ;,:.#
+											// SML "extra" ident chars
+				|| (isSML && (sc.Match('\\') || sc.Match('`'))))
 				state2 = SCE_CAML_OPERATOR;
 			break;
 
 		case SCE_CAML_IDENTIFIER:
 			// [try to] interpret as [additional] identifier char
 			if (!(iscaml(sc.ch) || sc.Match('\''))) {
-				const int n = sc.currentPos - chToken;
+				const Sci_Position n = sc.currentPos - chToken;
 				if (n < 24) {
 					// length is believable as keyword, [re-]construct token
 					char t[24];
-					for (int i = -n; i < 0; i++)
+					for (Sci_Position i = -n; i < 0; i++)
 						t[n + i] = static_cast<char>(sc.GetRelative(i));
 					t[n] = '\0';
 					// special-case "_" token as KEYWORD
@@ -273,9 +299,12 @@ void ColouriseCamlDoc(
 		case SCE_CAML_OPERATOR: {
 			// [try to] interpret as [additional] operator char
 			const char* o = 0;
-			if (iscaml(sc.ch) || isspace(sc.ch)		   /* ident or whitespace */
-				|| (o = strchr(")]};,\'\"`#", sc.ch),o)/* "termination" chars */
-				|| !strchr("!$%&*+-./:<=>?@^|~", sc.ch)/* "operator" chars */) {
+			if (iscaml(sc.ch) || isspace(sc.ch)			// ident or whitespace
+				|| (o = strchr(")]};,\'\"#", sc.ch),o)	// "termination" chars
+				|| (!isSML && sc.Match('`'))			// Caml extra term char
+				|| (!strchr("!$%&*+-./:<=>?@^|~", sc.ch)// "operator" chars
+														// SML extra ident chars
+					&& !(isSML && (sc.Match('\\') || sc.Match('`'))))) {
 				// check for INCLUSIVE termination
 				if (o && strchr(")]};,", sc.ch)) {
 					if ((sc.Match(')') && sc.chPrev == '(')
@@ -292,24 +321,27 @@ void ColouriseCamlDoc(
 
 		case SCE_CAML_NUMBER:
 			// [try to] interpret as [additional] numeric literal char
-			// N.B. - improperly accepts "extra" digits in base 2 or 8 literals
-			if (iscamld(sc.ch) || IsADigit(sc.ch, chBase))
+			if ((!isSML && sc.Match('_')) || IsADigit(sc.ch, chBase))
 				break;
 			// how about an integer suffix?
-			if ((sc.Match('l') || sc.Match('L') || sc.Match('n'))
-				&& (iscamld(sc.chPrev) || IsADigit(sc.chPrev, chBase)))
+			if (!isSML && (sc.Match('l') || sc.Match('L') || sc.Match('n'))
+				&& (sc.chPrev == '_' || IsADigit(sc.chPrev, chBase)))
 				break;
 			// or a floating-point literal?
 			if (chBase == 10) {
 				// with a decimal point?
-				if (sc.Match('.') && iscamld(sc.chPrev))
+				if (sc.Match('.')
+					&& ((!isSML && sc.chPrev == '_')
+						|| IsADigit(sc.chPrev, chBase)))
 					break;
 				// with an exponent? (I)
 				if ((sc.Match('e') || sc.Match('E'))
-					&& (iscamld(sc.chPrev) || sc.chPrev == '.'))
+					&& ((!isSML && (sc.chPrev == '.' || sc.chPrev == '_'))
+						|| IsADigit(sc.chPrev, chBase)))
 					break;
 				// with an exponent? (II)
-				if ((sc.Match('+') || sc.Match('-'))
+				if (((!isSML && (sc.Match('+') || sc.Match('-')))
+						|| (isSML && sc.Match('~')))
 					&& (sc.chPrev == 'e' || sc.chPrev == 'E'))
 					break;
 			}
@@ -318,29 +350,57 @@ void ColouriseCamlDoc(
 			break;
 
 		case SCE_CAML_CHAR:
-			// [try to] interpret as [additional] char literal char
-			if (sc.Match('\\')) {
-				chLit = 1;	// (definitely IS a char literal)
-				if (sc.chPrev == '\\')
-					sc.ch = ' ';	// (so termination test isn't fooled)
+			if (!isSML) {
+				// [try to] interpret as [additional] char literal char
+				if (sc.Match('\\')) {
+					chLit = 1;	// (definitely IS a char literal)
+					if (sc.chPrev == '\\')
+						sc.ch = ' ';	// (...\\')
+				// should we be terminating - one way or another?
+				} else if ((sc.Match('\'') && sc.chPrev != '\\')
+					|| sc.atLineEnd) {
+					state2 = SCE_CAML_DEFAULT;
+					if (sc.Match('\''))
+						chColor++;
+					else
+						sc.ChangeState(SCE_CAML_IDENTIFIER);
+				// ... maybe a char literal, maybe not
+				} else if (chLit < 1 && sc.currentPos - chToken >= 2)
+					sc.ChangeState(SCE_CAML_IDENTIFIER), advance = false;
+				break;
+			}/* else
+				// fall through for SML char literal (handle like string) */
+			// Falls through.
+
+		case SCE_CAML_STRING:
+			// [try to] interpret as [additional] [SML char/] string literal char
+			if (isSML && sc.Match('\\') && sc.chPrev != '\\' && isspace(sc.chNext))
+				state2 = SCE_CAML_WHITE;
+			else if (sc.Match('\\') && sc.chPrev == '\\')
+				sc.ch = ' ';	// (...\\")
 			// should we be terminating - one way or another?
-			} else if ((sc.Match('\'') && sc.chPrev != '\\') || sc.atLineEnd) {
+			else if ((sc.Match('"') && sc.chPrev != '\\')
+				|| (isSML && sc.atLineEnd)) {
 				state2 = SCE_CAML_DEFAULT;
-				if (sc.Match('\''))
+				if (sc.Match('"'))
 					chColor++;
-				else
-					sc.ChangeState(SCE_CAML_IDENTIFIER);
-			// ... maybe a char literal, maybe not
-			} else if (chLit < 1 && sc.currentPos - chToken >= 2)
-				sc.ChangeState(SCE_CAML_IDENTIFIER), advance = false;
+			}
 			break;
 
-		case SCE_CAML_STRING:
-			// [try to] interpret as [additional] string literal char
-			if (sc.Match('\\') && sc.chPrev == '\\')
-				sc.ch = ' ';	// (so '\\' doesn't cause us trouble)
-			else if (sc.Match('\"') && sc.chPrev != '\\')
-				state2 = SCE_CAML_DEFAULT, chColor++;
+		case SCE_CAML_WHITE:
+			// [try to] interpret as [additional] SML embedded whitespace char
+			if (sc.Match('\\')) {
+				// style this puppy NOW...
+				state2 = SCE_CAML_STRING, sc.ch = ' ' /* (...\") */, chColor++,
+					styler.ColourTo(chColor, SCE_CAML_WHITE), styler.Flush();
+				// ... then backtrack to determine original SML literal type
+				Sci_Position p = chColor - 2;
+				for (; p >= 0 && styler.StyleAt(p) == SCE_CAML_WHITE; p--) ;
+				if (p >= 0)
+					state2 = static_cast<int>(styler.StyleAt(p));
+				// take care of state change NOW
+				sc.ChangeState(state2), state2 = -1;
+			}
 			break;
 
 		case SCE_CAML_COMMENT:
@@ -350,8 +410,7 @@ void ColouriseCamlDoc(
 			// we're IN a comment - does this start a NESTED comment?
 			if (sc.Match('(', '*'))
 				state2 = sc.state + 1, chToken = sc.currentPos,
-					sc.ch = ' ',	// (make SURE "(*)" isn't seen as a closed comment)
-					sc.Forward(), nesting++;
+					sc.Forward(), sc.ch = ' ' /* (*)... */, nesting++;
 			// [try to] interpret as [additional] comment char
 			else if (sc.Match(')') && sc.chPrev == '*') {
 				if (nesting)
@@ -366,7 +425,7 @@ void ColouriseCamlDoc(
 			break;
 		}
 
-		// handle state change and char coloring as required
+		// handle state change and char coloring AS REQUIRED
 		if (state2 >= 0)
 			styler.ColourTo(chColor, sc.state), sc.ChangeState(state2);
 		// move to next char UNLESS re-scanning current char
@@ -382,13 +441,11 @@ void ColouriseCamlDoc(
 static
 #endif	/* BUILD_AS_EXTERNAL_LEXER */
 void FoldCamlDoc(
-	unsigned int startPos, int length,
-	int initStyle,
-	WordList *keywordlists[],
-	Accessor &styler)
+	Sci_PositionU, Sci_Position,
+	int,
+	WordList *[],
+	Accessor &)
 {
-	// below useless evaluation(s) to supress "not used" warnings
-	startPos || length || initStyle || keywordlists[0] || styler.Length();
 }
 
 static const char * const camlWordListDesc[] = {
diff --git a/Pythonwin/Scintilla/src/LexCmake.cxx b/Pythonwin/Scintilla/lexers/LexCmake.cxx
similarity index 88%
rename from Pythonwin/Scintilla/src/LexCmake.cxx
rename to Pythonwin/Scintilla/lexers/LexCmake.cxx
index f63eb399f..e3835c5c3 100644
--- a/Pythonwin/Scintilla/src/LexCmake.cxx
+++ b/Pythonwin/Scintilla/lexers/LexCmake.cxx
@@ -5,23 +5,26 @@
 // Copyright 2007 by Cristian Adam <cristian [dot] adam [at] gmx [dot] net>
 // based on the NSIS lexer
 // The License.txt file describes the conditions under which this software may be distributed.
+
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
 
-#ifdef SCI_NAMESPACE
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
 using namespace Scintilla;
-#endif
 
 static bool isCmakeNumber(char ch)
 {
@@ -38,10 +41,10 @@ static bool isCmakeLetter(char ch)
     return(ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z');
 }
 
-static bool CmakeNextLineHasElse(unsigned int start, unsigned int end, Accessor &styler)
+static bool CmakeNextLineHasElse(Sci_PositionU start, Sci_PositionU end, Accessor &styler)
 {
-    int nNextLine = -1;
-    for ( unsigned int i = start; i < end; i++ ) {
+    Sci_Position nNextLine = -1;
+    for ( Sci_PositionU i = start; i < end; i++ ) {
         char cNext = styler.SafeGetCharAt( i );
         if ( cNext == '\n' ) {
             nNextLine = i+1;
@@ -52,7 +55,7 @@ static bool CmakeNextLineHasElse(unsigned int start, unsigned int end, Accessor
     if ( nNextLine == -1 ) // We never foudn the next line...
         return false;
 
-    for ( unsigned int firstChar = nNextLine; firstChar < end; firstChar++ ) {
+    for ( Sci_PositionU firstChar = nNextLine; firstChar < end; firstChar++ ) {
         char cNext = styler.SafeGetCharAt( firstChar );
         if ( cNext == ' ' )
             continue;
@@ -66,7 +69,7 @@ static bool CmakeNextLineHasElse(unsigned int start, unsigned int end, Accessor
     return false;
 }
 
-static int calculateFoldCmake(unsigned int start, unsigned int end, int foldlevel, Accessor &styler, bool bElse)
+static int calculateFoldCmake(Sci_PositionU start, Sci_PositionU end, int foldlevel, Accessor &styler, bool bElse)
 {
     // If the word is too long, it is not what we are looking for
     if ( end - start > 20 )
@@ -82,10 +85,11 @@ static int calculateFoldCmake(unsigned int start, unsigned int end, int foldleve
 
     if ( CompareCaseInsensitive(s, "IF") == 0 || CompareCaseInsensitive(s, "WHILE") == 0
          || CompareCaseInsensitive(s, "MACRO") == 0 || CompareCaseInsensitive(s, "FOREACH") == 0
-         || CompareCaseInsensitive(s, "ELSEIF") == 0 )
+         || CompareCaseInsensitive(s, "FUNCTION") == 0 || CompareCaseInsensitive(s, "ELSEIF") == 0)
         newFoldlevel++;
     else if ( CompareCaseInsensitive(s, "ENDIF") == 0 || CompareCaseInsensitive(s, "ENDWHILE") == 0
-              || CompareCaseInsensitive(s, "ENDMACRO") == 0 || CompareCaseInsensitive(s, "ENDFOREACH") == 0)
+              || CompareCaseInsensitive(s, "ENDMACRO") == 0 || CompareCaseInsensitive(s, "ENDFOREACH") == 0
+              || CompareCaseInsensitive(s, "ENDFUNCTION") == 0)
         newFoldlevel--;
     else if ( bElse && CompareCaseInsensitive(s, "ELSEIF") == 0 )
         newFoldlevel++;
@@ -95,7 +99,7 @@ static int calculateFoldCmake(unsigned int start, unsigned int end, int foldleve
     return newFoldlevel;
 }
 
-static int classifyWordCmake(unsigned int start, unsigned int end, WordList *keywordLists[], Accessor &styler )
+static int classifyWordCmake(Sci_PositionU start, Sci_PositionU end, WordList *keywordLists[], Accessor &styler )
 {
     char word[100] = {0};
     char lowercaseWord[100] = {0};
@@ -104,7 +108,7 @@ static int classifyWordCmake(unsigned int start, unsigned int end, WordList *key
     WordList &Parameters = *keywordLists[1];
     WordList &UserDefined = *keywordLists[2];
 
-    for (unsigned int i = 0; i < end - start + 1 && i < 99; i++) {
+    for (Sci_PositionU i = 0; i < end - start + 1 && i < 99; i++) {
         word[i] = static_cast<char>( styler[ start + i ] );
         lowercaseWord[i] = static_cast<char>(tolower(word[i]));
     }
@@ -157,7 +161,7 @@ static int classifyWordCmake(unsigned int start, unsigned int end, WordList *key
     return SCE_CMAKE_DEFAULT;
 }
 
-static void ColouriseCmakeDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler)
+static void ColouriseCmakeDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *keywordLists[], Accessor &styler)
 {
     int state = SCE_CMAKE_DEFAULT;
     if ( startPos > 0 )
@@ -166,14 +170,14 @@ static void ColouriseCmakeDoc(unsigned int startPos, int length, int, WordList *
     styler.StartAt( startPos );
     styler.GetLine( startPos );
 
-    unsigned int nLengthDoc = startPos + length;
+    Sci_PositionU nLengthDoc = startPos + length;
     styler.StartSegment( startPos );
 
     char cCurrChar;
     bool bVarInString = false;
     bool bClassicVarInString = false;
 
-    unsigned int i;
+    Sci_PositionU i;
     for ( i = startPos; i < nLengthDoc; i++ ) {
         cCurrChar = styler.SafeGetCharAt( i );
         char cNextChar = styler.SafeGetCharAt(i+1);
@@ -221,14 +225,13 @@ static void ColouriseCmakeDoc(unsigned int startPos, int length, int, WordList *
 
             break;
         case SCE_CMAKE_COMMENT:
-            if ( cNextChar == '\n' || cNextChar == '\r' ) {
-                // Special case:
-                if ( cCurrChar == '\\' ) {
+            if ( cCurrChar == '\n' || cCurrChar == '\r' ) {
+                if ( styler.SafeGetCharAt(i-1) == '\\' ) {
                     styler.ColourTo(i-2,state);
-                    styler.ColourTo(i,SCE_CMAKE_DEFAULT);
+                    styler.ColourTo(i-1,SCE_CMAKE_DEFAULT);
                 }
                 else {
-                    styler.ColourTo(i,state);
+                    styler.ColourTo(i-1,state);
                     state = SCE_CMAKE_DEFAULT;
                 }
             }
@@ -259,8 +262,8 @@ static void ColouriseCmakeDoc(unsigned int startPos, int length, int, WordList *
             }
 
             if ( cNextChar == '\r' || cNextChar == '\n' ) {
-                int nCurLine = styler.GetLine(i+1);
-                int nBack = i;
+                Sci_Position nCurLine = styler.GetLine(i+1);
+                Sci_Position nBack = i;
                 // We need to check if the previous line has a \ in it...
                 bool bNextLine = false;
 
@@ -330,10 +333,7 @@ static void ColouriseCmakeDoc(unsigned int startPos, int length, int, WordList *
             break;
         }
 
-        if ( state == SCE_CMAKE_COMMENT) {
-            styler.ColourTo(i,state);
-        }
-        else if ( state == SCE_CMAKE_STRINGDQ || state == SCE_CMAKE_STRINGLQ || state == SCE_CMAKE_STRINGRQ ) {
+        if ( state == SCE_CMAKE_STRINGDQ || state == SCE_CMAKE_STRINGLQ || state == SCE_CMAKE_STRINGRQ ) {
             bool bIngoreNextDollarSign = false;
 
             if ( bVarInString && cCurrChar == '$' ) {
@@ -376,7 +376,7 @@ static void ColouriseCmakeDoc(unsigned int startPos, int length, int, WordList *
     styler.ColourTo(nLengthDoc-1,state);
 }
 
-static void FoldCmakeDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler)
+static void FoldCmakeDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler)
 {
     // No folding enabled, no reason to continue...
     if ( styler.GetPropertyInt("fold") == 0 )
@@ -384,18 +384,18 @@ static void FoldCmakeDoc(unsigned int startPos, int length, int, WordList *[], A
 
     bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) == 1;
 
-    int lineCurrent = styler.GetLine(startPos);
-    unsigned int safeStartPos = styler.LineStart( lineCurrent );
+    Sci_Position lineCurrent = styler.GetLine(startPos);
+    Sci_PositionU safeStartPos = styler.LineStart( lineCurrent );
 
     bool bArg1 = true;
-    int nWordStart = -1;
+    Sci_Position nWordStart = -1;
 
     int levelCurrent = SC_FOLDLEVELBASE;
     if (lineCurrent > 0)
         levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
     int levelNext = levelCurrent;
 
-    for (unsigned int i = safeStartPos; i < startPos + length; i++) {
+    for (Sci_PositionU i = safeStartPos; i < startPos + length; i++) {
         char chCurr = styler.SafeGetCharAt(i);
 
         if ( bArg1 ) {
diff --git a/Pythonwin/Scintilla/lexers/LexCoffeeScript.cxx b/Pythonwin/Scintilla/lexers/LexCoffeeScript.cxx
new file mode 100644
index 000000000..a00162335
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexCoffeeScript.cxx
@@ -0,0 +1,483 @@
+// Scintilla source code edit control
+/** @file LexCoffeeScript.cxx
+ ** Lexer for CoffeeScript.
+ **/
+// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
+// Based on the Scintilla C++ Lexer
+// Written by Eric Promislow <ericp@activestate.com> in 2011 for the Komodo IDE
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <algorithm>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static bool IsSpaceEquiv(int state) {
+	return (state == SCE_COFFEESCRIPT_DEFAULT
+	    || state == SCE_COFFEESCRIPT_COMMENTLINE
+	    || state == SCE_COFFEESCRIPT_COMMENTBLOCK
+	    || state == SCE_COFFEESCRIPT_VERBOSE_REGEX
+	    || state == SCE_COFFEESCRIPT_VERBOSE_REGEX_COMMENT
+	    || state == SCE_COFFEESCRIPT_WORD
+	    || state == SCE_COFFEESCRIPT_REGEX);
+}
+
+// Store the current lexer state and brace count prior to starting a new
+// `#{}` interpolation level.
+// Based on LexRuby.cxx.
+static void enterInnerExpression(int  *p_inner_string_types,
+                                 int  *p_inner_expn_brace_counts,
+                                 int&  inner_string_count,
+                                 int   state,
+                                 int&  brace_counts
+                                 ) {
+	p_inner_string_types[inner_string_count] = state;
+	p_inner_expn_brace_counts[inner_string_count] = brace_counts;
+	brace_counts = 0;
+	++inner_string_count;
+}
+
+// Restore the lexer state and brace count for the previous `#{}` interpolation
+// level upon returning to it.
+// Note the previous lexer state is the return value and needs to be restored
+// manually by the StyleContext.
+// Based on LexRuby.cxx.
+static int exitInnerExpression(int  *p_inner_string_types,
+                               int  *p_inner_expn_brace_counts,
+                               int&  inner_string_count,
+                               int&  brace_counts
+                              ) {
+	--inner_string_count;
+	brace_counts = p_inner_expn_brace_counts[inner_string_count];
+	return p_inner_string_types[inner_string_count];
+}
+
+// Preconditions: sc.currentPos points to a character after '+' or '-'.
+// The test for pos reaching 0 should be redundant,
+// and is in only for safety measures.
+// Limitation: this code will give the incorrect answer for code like
+// a = b+++/ptn/...
+// Putting a space between the '++' post-inc operator and the '+' binary op
+// fixes this, and is highly recommended for readability anyway.
+static bool FollowsPostfixOperator(StyleContext &sc, Accessor &styler) {
+	Sci_Position pos = (Sci_Position) sc.currentPos;
+	while (--pos > 0) {
+		char ch = styler[pos];
+		if (ch == '+' || ch == '-') {
+			return styler[pos - 1] == ch;
+		}
+	}
+	return false;
+}
+
+static bool followsKeyword(StyleContext &sc, Accessor &styler) {
+	Sci_Position pos = (Sci_Position) sc.currentPos;
+	Sci_Position currentLine = styler.GetLine(pos);
+	Sci_Position lineStartPos = styler.LineStart(currentLine);
+	while (--pos > lineStartPos) {
+		char ch = styler.SafeGetCharAt(pos);
+		if (ch != ' ' && ch != '\t') {
+			break;
+		}
+	}
+	styler.Flush();
+	return styler.StyleAt(pos) == SCE_COFFEESCRIPT_WORD;
+}
+
+static void ColouriseCoffeeScriptDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+                            Accessor &styler) {
+
+	WordList &keywords = *keywordlists[0];
+	WordList &keywords2 = *keywordlists[1];
+	WordList &keywords4 = *keywordlists[3];
+
+	CharacterSet setOKBeforeRE(CharacterSet::setNone, "([{=,:;!%^&*|?~+-");
+	CharacterSet setCouldBePostOp(CharacterSet::setNone, "+-");
+
+	CharacterSet setWordStart(CharacterSet::setAlpha, "_$@", 0x80, true);
+	CharacterSet setWord(CharacterSet::setAlphaNum, "._$", 0x80, true);
+
+	int chPrevNonWhite = ' ';
+	int visibleChars = 0;
+
+	// String/Regex interpolation variables, based on LexRuby.cxx.
+	// In most cases a value of 2 should be ample for the code the user is
+	// likely to enter. For example,
+	//   "Filling the #{container} with #{liquid}..."
+	// from the CoffeeScript homepage nests to a level of 2
+	// If the user actually hits a 6th occurrence of '#{' in a double-quoted
+	// string (including regexes), it will stay as a string.  The problem with
+	// this is that quotes might flip, a 7th '#{' will look like a comment,
+	// and code-folding might be wrong.
+#define INNER_STRINGS_MAX_COUNT 5
+	// These vars track our instances of "...#{,,,'..#{,,,}...',,,}..."
+	int inner_string_types[INNER_STRINGS_MAX_COUNT];
+	// Track # braces when we push a new #{ thing
+	int inner_expn_brace_counts[INNER_STRINGS_MAX_COUNT];
+	int inner_string_count = 0;
+	int brace_counts = 0;   // Number of #{ ... } things within an expression
+	for (int i = 0; i < INNER_STRINGS_MAX_COUNT; i++) {
+		inner_string_types[i] = 0;
+		inner_expn_brace_counts[i] = 0;
+	}
+
+	// look back to set chPrevNonWhite properly for better regex colouring
+	Sci_Position endPos = startPos + length;
+        if (startPos > 0 && IsSpaceEquiv(initStyle)) {
+		Sci_PositionU back = startPos;
+		styler.Flush();
+		while (back > 0 && IsSpaceEquiv(styler.StyleAt(--back)))
+			;
+		if (styler.StyleAt(back) == SCE_COFFEESCRIPT_OPERATOR) {
+			chPrevNonWhite = styler.SafeGetCharAt(back);
+		}
+		if (startPos != back) {
+			initStyle = styler.StyleAt(back);
+			if (IsSpaceEquiv(initStyle)) {
+				initStyle = SCE_COFFEESCRIPT_DEFAULT;
+			}
+		}
+		startPos = back;
+	}
+
+	StyleContext sc(startPos, endPos - startPos, initStyle, styler);
+
+	for (; sc.More();) {
+
+		if (sc.atLineStart) {
+			// Reset states to beginning of colourise so no surprises
+			// if different sets of lines lexed.
+			visibleChars = 0;
+		}
+
+		// Determine if the current state should terminate.
+		switch (sc.state) {
+			case SCE_COFFEESCRIPT_OPERATOR:
+				sc.SetState(SCE_COFFEESCRIPT_DEFAULT);
+				break;
+			case SCE_COFFEESCRIPT_NUMBER:
+				// We accept almost anything because of hex. and number suffixes
+				if (!setWord.Contains(sc.ch) || sc.Match('.', '.')) {
+					sc.SetState(SCE_COFFEESCRIPT_DEFAULT);
+				}
+				break;
+			case SCE_COFFEESCRIPT_IDENTIFIER:
+				if (!setWord.Contains(sc.ch) || (sc.ch == '.') || (sc.ch == '$')) {
+					char s[1000];
+					sc.GetCurrent(s, sizeof(s));
+					if (keywords.InList(s)) {
+						sc.ChangeState(SCE_COFFEESCRIPT_WORD);
+					} else if (keywords2.InList(s)) {
+						sc.ChangeState(SCE_COFFEESCRIPT_WORD2);
+					} else if (keywords4.InList(s)) {
+						sc.ChangeState(SCE_COFFEESCRIPT_GLOBALCLASS);
+					} else if (sc.LengthCurrent() > 0 && s[0] == '@') {
+						sc.ChangeState(SCE_COFFEESCRIPT_INSTANCEPROPERTY);
+					}
+					sc.SetState(SCE_COFFEESCRIPT_DEFAULT);
+				}
+				break;
+			case SCE_COFFEESCRIPT_WORD:
+			case SCE_COFFEESCRIPT_WORD2:
+			case SCE_COFFEESCRIPT_GLOBALCLASS:
+			case SCE_COFFEESCRIPT_INSTANCEPROPERTY:
+				if (!setWord.Contains(sc.ch)) {
+					sc.SetState(SCE_COFFEESCRIPT_DEFAULT);
+				}
+				break;
+			case SCE_COFFEESCRIPT_COMMENTLINE:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_COFFEESCRIPT_DEFAULT);
+				}
+				break;
+			case SCE_COFFEESCRIPT_STRING:
+				if (sc.ch == '\\') {
+					if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+						sc.Forward();
+					}
+				} else if (sc.ch == '\"') {
+					sc.ForwardSetState(SCE_COFFEESCRIPT_DEFAULT);
+				} else if (sc.ch == '#' && sc.chNext == '{' && inner_string_count < INNER_STRINGS_MAX_COUNT) {
+					// process interpolated code #{ ... }
+					enterInnerExpression(inner_string_types,
+					                     inner_expn_brace_counts,
+					                     inner_string_count,
+					                     sc.state,
+					                     brace_counts);
+					sc.SetState(SCE_COFFEESCRIPT_OPERATOR);
+					sc.ForwardSetState(SCE_COFFEESCRIPT_DEFAULT);
+				}
+				break;
+			case SCE_COFFEESCRIPT_CHARACTER:
+				if (sc.ch == '\\') {
+					if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+						sc.Forward();
+					}
+				} else if (sc.ch == '\'') {
+					sc.ForwardSetState(SCE_COFFEESCRIPT_DEFAULT);
+				}
+				break;
+			case SCE_COFFEESCRIPT_REGEX:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_COFFEESCRIPT_DEFAULT);
+				} else if (sc.ch == '/') {
+					sc.Forward();
+					while ((sc.ch < 0x80) && islower(sc.ch))
+						sc.Forward();    // gobble regex flags
+					sc.SetState(SCE_COFFEESCRIPT_DEFAULT);
+				} else if (sc.ch == '\\') {
+					// Gobble up the quoted character
+					if (sc.chNext == '\\' || sc.chNext == '/') {
+						sc.Forward();
+					}
+				}
+				break;
+			case SCE_COFFEESCRIPT_STRINGEOL:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_COFFEESCRIPT_DEFAULT);
+				}
+				break;
+			case SCE_COFFEESCRIPT_COMMENTBLOCK:
+				if (sc.Match("###")) {
+					sc.Forward();
+					sc.Forward();
+					sc.ForwardSetState(SCE_COFFEESCRIPT_DEFAULT);
+				} else if (sc.ch == '\\') {
+					sc.Forward();
+				}
+				break;
+			case SCE_COFFEESCRIPT_VERBOSE_REGEX:
+				if (sc.Match("///")) {
+					sc.Forward();
+					sc.Forward();
+					sc.ForwardSetState(SCE_COFFEESCRIPT_DEFAULT);
+				} else if (sc.Match('#')) {
+					sc.SetState(SCE_COFFEESCRIPT_VERBOSE_REGEX_COMMENT);
+				} else if (sc.ch == '\\') {
+					sc.Forward();
+				}
+				break;
+			case SCE_COFFEESCRIPT_VERBOSE_REGEX_COMMENT:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_COFFEESCRIPT_VERBOSE_REGEX);
+				}
+				break;
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_COFFEESCRIPT_DEFAULT) {
+			if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
+				sc.SetState(SCE_COFFEESCRIPT_NUMBER);
+			} else if (setWordStart.Contains(sc.ch)) {
+				sc.SetState(SCE_COFFEESCRIPT_IDENTIFIER);
+			} else if (sc.Match("///")) {
+				sc.SetState(SCE_COFFEESCRIPT_VERBOSE_REGEX);
+				sc.Forward();
+				sc.Forward();
+			} else if (sc.ch == '/'
+				   && (setOKBeforeRE.Contains(chPrevNonWhite)
+				       || followsKeyword(sc, styler))
+				   && (!setCouldBePostOp.Contains(chPrevNonWhite)
+				       || !FollowsPostfixOperator(sc, styler))) {
+				sc.SetState(SCE_COFFEESCRIPT_REGEX);	// JavaScript's RegEx
+			} else if (sc.ch == '\"') {
+				sc.SetState(SCE_COFFEESCRIPT_STRING);
+			} else if (sc.ch == '\'') {
+				sc.SetState(SCE_COFFEESCRIPT_CHARACTER);
+			} else if (sc.ch == '#') {
+				if (sc.Match("###")) {
+					sc.SetState(SCE_COFFEESCRIPT_COMMENTBLOCK);
+					sc.Forward();
+					sc.Forward();
+				} else {
+					sc.SetState(SCE_COFFEESCRIPT_COMMENTLINE);
+				}
+			} else if (isoperator(static_cast<char>(sc.ch))) {
+				sc.SetState(SCE_COFFEESCRIPT_OPERATOR);
+				// Handle '..' and '...' operators correctly.
+				if (sc.ch == '.') {
+					for (int i = 0; i < 2 && sc.chNext == '.'; i++, sc.Forward()) ;
+				} else if (sc.ch == '{') {
+					++brace_counts;
+				} else if (sc.ch == '}' && --brace_counts <= 0 && inner_string_count > 0) {
+					// Return to previous state before #{ ... }
+					sc.ForwardSetState(exitInnerExpression(inner_string_types,
+					                                       inner_expn_brace_counts,
+					                                       inner_string_count,
+					                                       brace_counts));
+					continue; // skip sc.Forward() at loop end
+				}
+			}
+		}
+
+		if (!IsASpace(sc.ch) && !IsSpaceEquiv(sc.state)) {
+			chPrevNonWhite = sc.ch;
+			visibleChars++;
+		}
+		sc.Forward();
+	}
+	sc.Complete();
+}
+
+static bool IsCommentLine(Sci_Position line, Accessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eol_pos; i++) {
+		char ch = styler[i];
+		if (ch == '#')
+			return true;
+		else if (ch != ' ' && ch != '\t')
+			return false;
+	}
+	return false;
+}
+
+static void FoldCoffeeScriptDoc(Sci_PositionU startPos, Sci_Position length, int,
+				WordList *[], Accessor &styler) {
+	// A simplified version of FoldPyDoc
+	const Sci_Position maxPos = startPos + length;
+	const Sci_Position maxLines = styler.GetLine(maxPos - 1);             // Requested last line
+	const Sci_Position docLines = styler.GetLine(styler.Length() - 1);  // Available last line
+
+	// property fold.coffeescript.comment
+	const bool foldComment = styler.GetPropertyInt("fold.coffeescript.comment") != 0;
+
+	const bool foldCompact = styler.GetPropertyInt("fold.compact") != 0;
+
+	// Backtrack to previous non-blank line so we can determine indent level
+	// for any white space lines
+	// and so we can fix any preceding fold level (which is why we go back
+	// at least one line in all cases)
+	int spaceFlags = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, NULL);
+	while (lineCurrent > 0) {
+		lineCurrent--;
+		indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, NULL);
+		if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)
+		    && !IsCommentLine(lineCurrent, styler))
+			break;
+	}
+	int indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
+
+	// Set up initial loop state
+	int prevComment = 0;
+	if (lineCurrent >= 1)
+		prevComment = foldComment && IsCommentLine(lineCurrent - 1, styler);
+
+	// Process all characters to end of requested range
+	// or comment that hangs over the end of the range.  Cap processing in all cases
+	// to end of document (in case of comment at end).
+	while ((lineCurrent <= docLines) && ((lineCurrent <= maxLines) || prevComment)) {
+
+		// Gather info
+		int lev = indentCurrent;
+		Sci_Position lineNext = lineCurrent + 1;
+		int indentNext = indentCurrent;
+		if (lineNext <= docLines) {
+			// Information about next line is only available if not at end of document
+			indentNext = styler.IndentAmount(lineNext, &spaceFlags, NULL);
+		}
+		const int comment = foldComment && IsCommentLine(lineCurrent, styler);
+		const int comment_start = (comment && !prevComment && (lineNext <= docLines) &&
+		                           IsCommentLine(lineNext, styler) && (lev > SC_FOLDLEVELBASE));
+		const int comment_continue = (comment && prevComment);
+		if (!comment)
+			indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
+		if (indentNext & SC_FOLDLEVELWHITEFLAG)
+			indentNext = SC_FOLDLEVELWHITEFLAG | indentCurrentLevel;
+
+		if (comment_start) {
+			// Place fold point at start of a block of comments
+			lev |= SC_FOLDLEVELHEADERFLAG;
+		} else if (comment_continue) {
+			// Add level to rest of lines in the block
+			lev = lev + 1;
+		}
+
+		// Skip past any blank lines for next indent level info; we skip also
+		// comments (all comments, not just those starting in column 0)
+		// which effectively folds them into surrounding code rather
+		// than screwing up folding.
+
+		while ((lineNext < docLines) &&
+		        ((indentNext & SC_FOLDLEVELWHITEFLAG) ||
+		         (lineNext <= docLines && IsCommentLine(lineNext, styler)))) {
+
+			lineNext++;
+			indentNext = styler.IndentAmount(lineNext, &spaceFlags, NULL);
+		}
+
+		const int levelAfterComments = indentNext & SC_FOLDLEVELNUMBERMASK;
+		const int levelBeforeComments = std::max(indentCurrentLevel,levelAfterComments);
+
+		// Now set all the indent levels on the lines we skipped
+		// Do this from end to start.  Once we encounter one line
+		// which is indented more than the line after the end of
+		// the comment-block, use the level of the block before
+
+		Sci_Position skipLine = lineNext;
+		int skipLevel = levelAfterComments;
+
+		while (--skipLine > lineCurrent) {
+			int skipLineIndent = styler.IndentAmount(skipLine, &spaceFlags, NULL);
+
+			if (foldCompact) {
+				if ((skipLineIndent & SC_FOLDLEVELNUMBERMASK) > levelAfterComments)
+					skipLevel = levelBeforeComments;
+
+				int whiteFlag = skipLineIndent & SC_FOLDLEVELWHITEFLAG;
+
+				styler.SetLevel(skipLine, skipLevel | whiteFlag);
+			} else {
+				if ((skipLineIndent & SC_FOLDLEVELNUMBERMASK) > levelAfterComments &&
+					!(skipLineIndent & SC_FOLDLEVELWHITEFLAG) &&
+					!IsCommentLine(skipLine, styler))
+					skipLevel = levelBeforeComments;
+
+				styler.SetLevel(skipLine, skipLevel);
+			}
+		}
+
+		// Set fold header on non-comment line
+		if (!comment && !(indentCurrent & SC_FOLDLEVELWHITEFLAG)) {
+			if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK))
+				lev |= SC_FOLDLEVELHEADERFLAG;
+		}
+
+		// Keep track of block comment state of previous line
+		prevComment = comment_start || comment_continue;
+
+		// Set fold level for this line and move to next line
+		styler.SetLevel(lineCurrent, lev);
+		indentCurrent = indentNext;
+		lineCurrent = lineNext;
+	}
+}
+
+static const char *const csWordLists[] = {
+            "Keywords",
+            "Secondary keywords",
+            "Unused",
+            "Global classes",
+            0,
+};
+
+LexerModule lmCoffeeScript(SCLEX_COFFEESCRIPT, ColouriseCoffeeScriptDoc, "coffeescript", FoldCoffeeScriptDoc, csWordLists);
diff --git a/Pythonwin/Scintilla/src/LexConf.cxx b/Pythonwin/Scintilla/lexers/LexConf.cxx
similarity index 83%
rename from Pythonwin/Scintilla/src/LexConf.cxx
rename to Pythonwin/Scintilla/lexers/LexConf.cxx
index 969275f92..73fbe46ef 100644
--- a/Pythonwin/Scintilla/src/LexConf.cxx
+++ b/Pythonwin/Scintilla/lexers/LexConf.cxx
@@ -2,7 +2,7 @@
 /** @file LexConf.cxx
  ** Lexer for Apache Configuration Files.
  **
- ** First working version contributed by Ahmad Zawawi <zeus_go64@hotmail.com> on October 28, 2000.
+ ** First working version contributed by Ahmad Zawawi <ahmad.zawawi@gmail.com> on October 28, 2000.
  ** i created this lexer because i needed something pretty when dealing
  ** when Apache Configuration files...
  **/
@@ -11,30 +11,32 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
 
-#ifdef SCI_NAMESPACE
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
 using namespace Scintilla;
-#endif
 
-static void ColouriseConfDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler)
+static void ColouriseConfDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *keywordLists[], Accessor &styler)
 {
 	int state = SCE_CONF_DEFAULT;
 	char chNext = styler[startPos];
-	int lengthDoc = startPos + length;
+	Sci_Position lengthDoc = startPos + length;
 	// create a buffer large enough to take the largest chunk...
-	char *buffer = new char[length];
-	int bufferCount = 0;
+	char *buffer = new char[length+1];
+	Sci_Position bufferCount = 0;
 
 	// this assumes that we have 2 keyword list in conf.properties
 	WordList &directives = *keywordLists[0];
@@ -44,7 +46,7 @@ static void ColouriseConfDoc(unsigned int startPos, int length, int, WordList *k
 	// using the hand-written state machine shown below
 	styler.StartAt(startPos);
 	styler.StartSegment(startPos);
-	for (int i = startPos; i < lengthDoc; i++) {
+	for (Sci_Position i = startPos; i < lengthDoc; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 
@@ -70,17 +72,17 @@ static void ColouriseConfDoc(unsigned int startPos, int length, int, WordList *k
 				} else if( ch == '"') {
 					state = SCE_CONF_STRING;
 					styler.ColourTo(i,SCE_CONF_STRING);
-				} else if( ispunct(ch) ) {
+				} else if( IsASCII(ch) && ispunct(ch) ) {
 					// signals an operator...
 					// no state jump necessary for this
 					// simple case...
 					styler.ColourTo(i,SCE_CONF_OPERATOR);
-				} else if( isalpha(ch) ) {
+				} else if( IsASCII(ch) && isalpha(ch) ) {
 					// signals the start of an identifier
 					bufferCount = 0;
 					buffer[bufferCount++] = static_cast<char>(tolower(ch));
 					state = SCE_CONF_IDENTIFIER;
-				} else if( isdigit(ch) ) {
+				} else if( IsASCII(ch) && isdigit(ch) ) {
 					// signals the start of a number
 					bufferCount = 0;
 					buffer[bufferCount++] = ch;
@@ -107,7 +109,7 @@ static void ColouriseConfDoc(unsigned int startPos, int length, int, WordList *k
 				// if we find a non-alphanumeric char,
 				// we simply go to default state
 				// else we're still dealing with an extension...
-				if( isalnum(ch) || (ch == '_') ||
+				if( (IsASCII(ch) && isalnum(ch)) || (ch == '_') ||
 					(ch == '-') || (ch == '$') ||
 					(ch == '/') || (ch == '.') || (ch == '*') )
 				{
@@ -129,7 +131,7 @@ static void ColouriseConfDoc(unsigned int startPos, int length, int, WordList *k
 
 			case SCE_CONF_IDENTIFIER:
 				// stay  in CONF_IDENTIFIER state until we find a non-alphanumeric
-				if( isalnum(ch) || (ch == '_') || (ch == '-') || (ch == '/') || (ch == '$') || (ch == '.') || (ch == '*')) {
+				if( (IsASCII(ch) && isalnum(ch)) || (ch == '_') || (ch == '-') || (ch == '/') || (ch == '$') || (ch == '.') || (ch == '*')) {
 					buffer[bufferCount++] = static_cast<char>(tolower(ch));
 				} else {
 					state = SCE_CONF_DEFAULT;
@@ -154,7 +156,7 @@ static void ColouriseConfDoc(unsigned int startPos, int length, int, WordList *k
 
 			case SCE_CONF_NUMBER:
 				// stay  in CONF_NUMBER state until we find a non-numeric
-				if( isdigit(ch) || ch == '.') {
+				if( (IsASCII(ch) && isdigit(ch)) || ch == '.') {
 					buffer[bufferCount++] = ch;
 				} else {
 					state = SCE_CONF_DEFAULT;
diff --git a/Pythonwin/Scintilla/src/LexCrontab.cxx b/Pythonwin/Scintilla/lexers/LexCrontab.cxx
similarity index 90%
rename from Pythonwin/Scintilla/src/LexCrontab.cxx
rename to Pythonwin/Scintilla/lexers/LexCrontab.cxx
index 62044c370..7f6d5fb0c 100644
--- a/Pythonwin/Scintilla/src/LexCrontab.cxx
+++ b/Pythonwin/Scintilla/lexers/LexCrontab.cxx
@@ -9,31 +9,33 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
 
-#ifdef SCI_NAMESPACE
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
 using namespace Scintilla;
-#endif
 
-static void ColouriseNncrontabDoc(unsigned int startPos, int length, int, WordList
+static void ColouriseNncrontabDoc(Sci_PositionU startPos, Sci_Position length, int, WordList
 *keywordLists[], Accessor &styler)
 {
 	int state = SCE_NNCRONTAB_DEFAULT;
 	char chNext = styler[startPos];
-	int lengthDoc = startPos + length;
+	Sci_Position lengthDoc = startPos + length;
 	// create a buffer large enough to take the largest chunk...
-	char *buffer = new char[length];
-	int bufferCount = 0;
+	char *buffer = new char[length+1];
+	Sci_Position bufferCount = 0;
 	// used when highliting environment variables inside quoted string:
 	bool insideString = false;
 
@@ -46,7 +48,7 @@ static void ColouriseNncrontabDoc(unsigned int startPos, int length, int, WordLi
 	// using the hand-written state machine shown below
 	styler.StartAt(startPos);
 	styler.StartSegment(startPos);
-	for (int i = startPos; i < lengthDoc; i++) {
+	for (Sci_Position i = startPos; i < lengthDoc; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 
@@ -94,12 +96,12 @@ static void ColouriseNncrontabDoc(unsigned int startPos, int length, int, WordLi
 					// signals an asterisk
 					// no state jump necessary for this simple case...
 					styler.ColourTo(i,SCE_NNCRONTAB_ASTERISK);
-				} else if( isalpha(ch) || ch == '<' ) {
+				} else if( (IsASCII(ch) && isalpha(ch)) || ch == '<' ) {
 					// signals the start of an identifier
 					bufferCount = 0;
 					buffer[bufferCount++] = ch;
 					state = SCE_NNCRONTAB_IDENTIFIER;
-				} else if( isdigit(ch) ) {
+				} else if( IsASCII(ch) && isdigit(ch) ) {
 					// signals the start of a number
 					bufferCount = 0;
 					buffer[bufferCount++] = ch;
@@ -167,7 +169,7 @@ static void ColouriseNncrontabDoc(unsigned int startPos, int length, int, WordLi
 
 			case SCE_NNCRONTAB_IDENTIFIER:
 				// stay  in CONF_IDENTIFIER state until we find a non-alphanumeric
-				if( isalnum(ch) || (ch == '_') || (ch == '-') || (ch == '/') ||
+				if( (IsASCII(ch) && isalnum(ch)) || (ch == '_') || (ch == '-') || (ch == '/') ||
 					(ch == '$') || (ch == '.') || (ch == '<') || (ch == '>') ||
 					(ch == '@') ) {
 					buffer[bufferCount++] = ch;
@@ -196,7 +198,7 @@ static void ColouriseNncrontabDoc(unsigned int startPos, int length, int, WordLi
 
 			case SCE_NNCRONTAB_NUMBER:
 				// stay  in CONF_NUMBER state until we find a non-numeric
-				if( isdigit(ch) /* || ch == '.' */ ) {
+				if( IsASCII(ch) && isdigit(ch) /* || ch == '.' */ ) {
 					buffer[bufferCount++] = ch;
 				} else {
 					state = SCE_NNCRONTAB_DEFAULT;
diff --git a/Pythonwin/Scintilla/src/LexCsound.cxx b/Pythonwin/Scintilla/lexers/LexCsound.cxx
similarity index 91%
rename from Pythonwin/Scintilla/src/LexCsound.cxx
rename to Pythonwin/Scintilla/lexers/LexCsound.cxx
index 4162c9b3a..24603801e 100644
--- a/Pythonwin/Scintilla/src/LexCsound.cxx
+++ b/Pythonwin/Scintilla/lexers/LexCsound.cxx
@@ -8,21 +8,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
-#include "Platform.h"
+#include <assert.h>
+#include <ctype.h>
 
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
 
-#ifdef SCI_NAMESPACE
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
 using namespace Scintilla;
-#endif
 
 static inline bool IsAWordChar(const int ch) {
 	return (ch < 0x80) && (isalnum(ch) || ch == '.' ||
@@ -35,7 +37,7 @@ static inline bool IsAWordStart(const int ch) {
 }
 
 static inline bool IsCsoundOperator(char ch) {
-	if (isalnum(ch))
+	if (IsASCII(ch) && isalnum(ch))
 		return false;
 	// '.' left out as it is used to make up numbers
 	if (ch == '*' || ch == '/' || ch == '-' || ch == '+' ||
@@ -47,7 +49,7 @@ static inline bool IsCsoundOperator(char ch) {
 	return false;
 }
 
-static void ColouriseCsoundDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
+static void ColouriseCsoundDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
 				Accessor &styler) {
 
 	WordList &opcode = *keywordlists[0];
@@ -72,7 +74,7 @@ static void ColouriseCsoundDoc(unsigned int startPos, int length, int initStyle,
 				continue;
 			}
 		}
-              
+
 		// Determine if the current state should terminate.
 		if (sc.state == SCE_CSOUND_OPERATOR) {
 			if (!IsCsoundOperator(static_cast<char>(sc.ch))) {
@@ -119,7 +121,7 @@ static void ColouriseCsoundDoc(unsigned int startPos, int length, int initStyle,
 				sc.SetState(SCE_CSOUND_DEFAULT);
 			}
 		}
-		
+
 		// Determine if a new state should be entered.
 		if (sc.state == SCE_CSOUND_DEFAULT) {
 			if (sc.ch == ';'){
@@ -146,17 +148,17 @@ static void ColouriseCsoundDoc(unsigned int startPos, int length, int initStyle,
 	sc.Complete();
 }
 
-static void FoldCsoundInstruments(unsigned int startPos, int length, int /* initStyle */, WordList *[], 
+static void FoldCsoundInstruments(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, WordList *[],
 		Accessor &styler) {
-	unsigned int lengthDoc = startPos + length;
+	Sci_PositionU lengthDoc = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	char chNext = styler[startPos];
 	int stylePrev = 0;
 	int styleNext = styler.StyleAt(startPos);
-	for (unsigned int i = startPos; i < lengthDoc; i++) {
+	for (Sci_PositionU i = startPos; i < lengthDoc; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int style = styleNext;
diff --git a/Pythonwin/Scintilla/lexers/LexD.cxx b/Pythonwin/Scintilla/lexers/LexD.cxx
new file mode 100644
index 000000000..9381a0d07
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexD.cxx
@@ -0,0 +1,571 @@
+/** @file LexD.cxx
+ ** Lexer for D.
+ **
+ ** Copyright (c) 2006 by Waldemar Augustyn <waldemar@wdmsys.com>
+ ** Converted to lexer object and added further folding features/properties by "Udo Lechner" <dlchnr(at)gmx(dot)net>
+ **/
+// Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+#include <map>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+/* Nested comments require keeping the value of the nesting level for every
+   position in the document.  But since scintilla always styles line by line,
+   we only need to store one value per line. The non-negative number indicates
+   nesting level at the end of the line.
+*/
+
+// Underscore, letter, digit and universal alphas from C99 Appendix D.
+
+static bool IsWordStart(int ch) {
+	return (IsASCII(ch) && (isalpha(ch) || ch == '_')) || !IsASCII(ch);
+}
+
+static bool IsWord(int ch) {
+	return (IsASCII(ch) && (isalnum(ch) || ch == '_')) || !IsASCII(ch);
+}
+
+static bool IsDoxygen(int ch) {
+	if (IsASCII(ch) && islower(ch))
+		return true;
+	if (ch == '$' || ch == '@' || ch == '\\' ||
+		ch == '&' || ch == '#' || ch == '<' || ch == '>' ||
+		ch == '{' || ch == '}' || ch == '[' || ch == ']')
+		return true;
+	return false;
+}
+
+static bool IsStringSuffix(int ch) {
+	return ch == 'c' || ch == 'w' || ch == 'd';
+}
+
+static bool IsStreamCommentStyle(int style) {
+	return style == SCE_D_COMMENT ||
+		style == SCE_D_COMMENTDOC ||
+		style == SCE_D_COMMENTDOCKEYWORD ||
+		style == SCE_D_COMMENTDOCKEYWORDERROR;
+}
+
+// An individual named option for use in an OptionSet
+
+// Options used for LexerD
+struct OptionsD {
+	bool fold;
+	bool foldSyntaxBased;
+	bool foldComment;
+	bool foldCommentMultiline;
+	bool foldCommentExplicit;
+	std::string foldExplicitStart;
+	std::string foldExplicitEnd;
+	bool foldExplicitAnywhere;
+	bool foldCompact;
+	int  foldAtElseInt;
+	bool foldAtElse;
+	OptionsD() {
+		fold = false;
+		foldSyntaxBased = true;
+		foldComment = false;
+		foldCommentMultiline = true;
+		foldCommentExplicit = true;
+		foldExplicitStart = "";
+		foldExplicitEnd   = "";
+		foldExplicitAnywhere = false;
+		foldCompact = true;
+		foldAtElseInt = -1;
+		foldAtElse = false;
+	}
+};
+
+static const char * const dWordLists[] = {
+			"Primary keywords and identifiers",
+			"Secondary keywords and identifiers",
+			"Documentation comment keywords",
+			"Type definitions and aliases",
+			"Keywords 5",
+			"Keywords 6",
+			"Keywords 7",
+			0,
+		};
+
+struct OptionSetD : public OptionSet<OptionsD> {
+	OptionSetD() {
+		DefineProperty("fold", &OptionsD::fold);
+
+		DefineProperty("fold.d.syntax.based", &OptionsD::foldSyntaxBased,
+			"Set this property to 0 to disable syntax based folding.");
+
+		DefineProperty("fold.comment", &OptionsD::foldComment);
+
+		DefineProperty("fold.d.comment.multiline", &OptionsD::foldCommentMultiline,
+			"Set this property to 0 to disable folding multi-line comments when fold.comment=1.");
+
+		DefineProperty("fold.d.comment.explicit", &OptionsD::foldCommentExplicit,
+			"Set this property to 0 to disable folding explicit fold points when fold.comment=1.");
+
+		DefineProperty("fold.d.explicit.start", &OptionsD::foldExplicitStart,
+			"The string to use for explicit fold start points, replacing the standard //{.");
+
+		DefineProperty("fold.d.explicit.end", &OptionsD::foldExplicitEnd,
+			"The string to use for explicit fold end points, replacing the standard //}.");
+
+		DefineProperty("fold.d.explicit.anywhere", &OptionsD::foldExplicitAnywhere,
+			"Set this property to 1 to enable explicit fold points anywhere, not just in line comments.");
+
+		DefineProperty("fold.compact", &OptionsD::foldCompact);
+
+		DefineProperty("lexer.d.fold.at.else", &OptionsD::foldAtElseInt,
+			"This option enables D folding on a \"} else {\" line of an if statement.");
+
+		DefineProperty("fold.at.else", &OptionsD::foldAtElse);
+
+		DefineWordListSets(dWordLists);
+	}
+};
+
+class LexerD : public DefaultLexer {
+	bool caseSensitive;
+	WordList keywords;
+	WordList keywords2;
+	WordList keywords3;
+	WordList keywords4;
+	WordList keywords5;
+	WordList keywords6;
+	WordList keywords7;
+	OptionsD options;
+	OptionSetD osD;
+public:
+	LexerD(bool caseSensitive_) :
+		DefaultLexer("D", SCLEX_D),
+		caseSensitive(caseSensitive_) {
+	}
+	virtual ~LexerD() {
+	}
+	void SCI_METHOD Release() override {
+		delete this;
+	}
+	int SCI_METHOD Version() const override {
+		return lvRelease5;
+	}
+	const char * SCI_METHOD PropertyNames() override {
+		return osD.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return osD.PropertyType(name);
+	}
+	const char * SCI_METHOD DescribeProperty(const char *name) override {
+		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();
+	}
+	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 *) override {
+		return 0;
+	}
+
+	static ILexer5 *LexerFactoryD() {
+		return new LexerD(true);
+	}
+	static ILexer5 *LexerFactoryDInsensitive() {
+		return new LexerD(false);
+	}
+};
+
+Sci_Position SCI_METHOD LexerD::PropertySet(const char *key, const char *val) {
+	if (osD.PropertySet(&options, key, val)) {
+		return 0;
+	}
+	return -1;
+}
+
+Sci_Position SCI_METHOD LexerD::WordListSet(int n, const char *wl) {
+	WordList *wordListN = 0;
+	switch (n) {
+	case 0:
+		wordListN = &keywords;
+		break;
+	case 1:
+		wordListN = &keywords2;
+		break;
+	case 2:
+		wordListN = &keywords3;
+		break;
+	case 3:
+		wordListN = &keywords4;
+		break;
+	case 4:
+		wordListN = &keywords5;
+		break;
+	case 5:
+		wordListN = &keywords6;
+		break;
+	case 6:
+		wordListN = &keywords7;
+		break;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN) {
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+		}
+	}
+	return firstModification;
+}
+
+void SCI_METHOD LexerD::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	LexAccessor styler(pAccess);
+
+	int styleBeforeDCKeyword = SCE_D_DEFAULT;
+
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	Sci_Position curLine = styler.GetLine(startPos);
+	int curNcLevel = curLine > 0? styler.GetLineState(curLine-1): 0;
+	bool numFloat = false; // Float literals have '+' and '-' signs
+	bool numHex = false;
+
+	for (; sc.More(); sc.Forward()) {
+
+		if (sc.atLineStart) {
+			curLine = styler.GetLine(sc.currentPos);
+			styler.SetLineState(curLine, curNcLevel);
+		}
+
+		// Determine if the current state should terminate.
+		switch (sc.state) {
+			case SCE_D_OPERATOR:
+				sc.SetState(SCE_D_DEFAULT);
+				break;
+			case SCE_D_NUMBER:
+				// We accept almost anything because of hex. and number suffixes
+				if (IsASCII(sc.ch) && (isalnum(sc.ch) || sc.ch == '_')) {
+					continue;
+				} else if (sc.ch == '.' && sc.chNext != '.' && !numFloat) {
+					// Don't parse 0..2 as number.
+					numFloat=true;
+					continue;
+				} else if ( ( sc.ch == '-' || sc.ch == '+' ) && (		/*sign and*/
+					( !numHex && ( sc.chPrev == 'e' || sc.chPrev == 'E' ) ) || /*decimal or*/
+					( sc.chPrev == 'p' || sc.chPrev == 'P' ) ) ) {		/*hex*/
+					// Parse exponent sign in float literals: 2e+10 0x2e+10
+					continue;
+				} else {
+					sc.SetState(SCE_D_DEFAULT);
+				}
+				break;
+			case SCE_D_IDENTIFIER:
+				if (!IsWord(sc.ch)) {
+					char s[1000];
+					if (caseSensitive) {
+						sc.GetCurrent(s, sizeof(s));
+					} else {
+						sc.GetCurrentLowered(s, sizeof(s));
+					}
+					if (keywords.InList(s)) {
+						sc.ChangeState(SCE_D_WORD);
+					} else if (keywords2.InList(s)) {
+						sc.ChangeState(SCE_D_WORD2);
+					} else if (keywords4.InList(s)) {
+						sc.ChangeState(SCE_D_TYPEDEF);
+					} else if (keywords5.InList(s)) {
+						sc.ChangeState(SCE_D_WORD5);
+					} else if (keywords6.InList(s)) {
+						sc.ChangeState(SCE_D_WORD6);
+					} else if (keywords7.InList(s)) {
+						sc.ChangeState(SCE_D_WORD7);
+					}
+					sc.SetState(SCE_D_DEFAULT);
+				}
+				break;
+			case SCE_D_COMMENT:
+				if (sc.Match('*', '/')) {
+					sc.Forward();
+					sc.ForwardSetState(SCE_D_DEFAULT);
+				}
+				break;
+			case SCE_D_COMMENTDOC:
+				if (sc.Match('*', '/')) {
+					sc.Forward();
+					sc.ForwardSetState(SCE_D_DEFAULT);
+				} else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support
+					// Verify that we have the conditions to mark a comment-doc-keyword
+					if ((IsASpace(sc.chPrev) || sc.chPrev == '*') && (!IsASpace(sc.chNext))) {
+						styleBeforeDCKeyword = SCE_D_COMMENTDOC;
+						sc.SetState(SCE_D_COMMENTDOCKEYWORD);
+					}
+				}
+				break;
+			case SCE_D_COMMENTLINE:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_D_DEFAULT);
+				}
+				break;
+			case SCE_D_COMMENTLINEDOC:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_D_DEFAULT);
+				} else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support
+					// Verify that we have the conditions to mark a comment-doc-keyword
+					if ((IsASpace(sc.chPrev) || sc.chPrev == '/' || sc.chPrev == '!') && (!IsASpace(sc.chNext))) {
+						styleBeforeDCKeyword = SCE_D_COMMENTLINEDOC;
+						sc.SetState(SCE_D_COMMENTDOCKEYWORD);
+					}
+				}
+				break;
+			case SCE_D_COMMENTDOCKEYWORD:
+				if ((styleBeforeDCKeyword == SCE_D_COMMENTDOC) && sc.Match('*', '/')) {
+					sc.ChangeState(SCE_D_COMMENTDOCKEYWORDERROR);
+					sc.Forward();
+					sc.ForwardSetState(SCE_D_DEFAULT);
+				} else if (!IsDoxygen(sc.ch)) {
+					char s[100];
+					if (caseSensitive) {
+						sc.GetCurrent(s, sizeof(s));
+					} else {
+						sc.GetCurrentLowered(s, sizeof(s));
+					}
+					if (!IsASpace(sc.ch) || !keywords3.InList(s + 1)) {
+						sc.ChangeState(SCE_D_COMMENTDOCKEYWORDERROR);
+					}
+					sc.SetState(styleBeforeDCKeyword);
+				}
+				break;
+			case SCE_D_COMMENTNESTED:
+				if (sc.Match('+', '/')) {
+					if (curNcLevel > 0)
+						curNcLevel -= 1;
+					curLine = styler.GetLine(sc.currentPos);
+					styler.SetLineState(curLine, curNcLevel);
+					sc.Forward();
+					if (curNcLevel == 0) {
+						sc.ForwardSetState(SCE_D_DEFAULT);
+					}
+				} else if (sc.Match('/','+')) {
+					curNcLevel += 1;
+					curLine = styler.GetLine(sc.currentPos);
+					styler.SetLineState(curLine, curNcLevel);
+					sc.Forward();
+				}
+				break;
+			case SCE_D_STRING:
+				if (sc.ch == '\\') {
+					if (sc.chNext == '"' || sc.chNext == '\\') {
+						sc.Forward();
+					}
+				} else if (sc.ch == '"') {
+					if(IsStringSuffix(sc.chNext))
+						sc.Forward();
+					sc.ForwardSetState(SCE_D_DEFAULT);
+				}
+				break;
+			case SCE_D_CHARACTER:
+				if (sc.atLineEnd) {
+					sc.ChangeState(SCE_D_STRINGEOL);
+				} else if (sc.ch == '\\') {
+					if (sc.chNext == '\'' || sc.chNext == '\\') {
+						sc.Forward();
+					}
+				} else if (sc.ch == '\'') {
+					// Char has no suffixes
+					sc.ForwardSetState(SCE_D_DEFAULT);
+				}
+				break;
+			case SCE_D_STRINGEOL:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_D_DEFAULT);
+				}
+				break;
+			case SCE_D_STRINGB:
+				if (sc.ch == '`') {
+					if(IsStringSuffix(sc.chNext))
+						sc.Forward();
+					sc.ForwardSetState(SCE_D_DEFAULT);
+				}
+				break;
+			case SCE_D_STRINGR:
+				if (sc.ch == '"') {
+					if(IsStringSuffix(sc.chNext))
+						sc.Forward();
+					sc.ForwardSetState(SCE_D_DEFAULT);
+				}
+				break;
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_D_DEFAULT) {
+			if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
+				sc.SetState(SCE_D_NUMBER);
+				numFloat = sc.ch == '.';
+				// Remember hex literal
+				numHex = sc.ch == '0' && ( sc.chNext == 'x' || sc.chNext == 'X' );
+			} else if ( (sc.ch == 'r' || sc.ch == 'x' || sc.ch == 'q')
+				&& sc.chNext == '"' ) {
+				// Limited support for hex and delimited strings: parse as r""
+				sc.SetState(SCE_D_STRINGR);
+				sc.Forward();
+			} else if (IsWordStart(sc.ch) || sc.ch == '$') {
+				sc.SetState(SCE_D_IDENTIFIER);
+			} else if (sc.Match('/','+')) {
+				curNcLevel += 1;
+				curLine = styler.GetLine(sc.currentPos);
+				styler.SetLineState(curLine, curNcLevel);
+				sc.SetState(SCE_D_COMMENTNESTED);
+				sc.Forward();
+			} else if (sc.Match('/', '*')) {
+				if (sc.Match("/**") || sc.Match("/*!")) {   // Support of Qt/Doxygen doc. style
+					sc.SetState(SCE_D_COMMENTDOC);
+				} else {
+					sc.SetState(SCE_D_COMMENT);
+				}
+				sc.Forward();   // Eat the * so it isn't used for the end of the comment
+			} else if (sc.Match('/', '/')) {
+				if ((sc.Match("///") && !sc.Match("////")) || sc.Match("//!"))
+					// Support of Qt/Doxygen doc. style
+					sc.SetState(SCE_D_COMMENTLINEDOC);
+				else
+					sc.SetState(SCE_D_COMMENTLINE);
+			} else if (sc.ch == '"') {
+				sc.SetState(SCE_D_STRING);
+			} else if (sc.ch == '\'') {
+				sc.SetState(SCE_D_CHARACTER);
+			} else if (sc.ch == '`') {
+				sc.SetState(SCE_D_STRINGB);
+			} else if (isoperator(static_cast<char>(sc.ch))) {
+				sc.SetState(SCE_D_OPERATOR);
+				if (sc.ch == '.' && sc.chNext == '.') sc.Forward(); // Range operator
+			}
+		}
+	}
+	sc.Complete();
+}
+
+// Store both the current line's fold level and the next lines in the
+// level store to make it easy to pick up with each increment
+// and to make it possible to fiddle the current level for "} else {".
+
+void SCI_METHOD LexerD::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+
+	if (!options.fold)
+		return;
+
+	LexAccessor styler(pAccess);
+
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelCurrent = SC_FOLDLEVELBASE;
+	if (lineCurrent > 0)
+		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
+	int levelMinCurrent = levelCurrent;
+	int levelNext = levelCurrent;
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+	bool foldAtElse = options.foldAtElseInt >= 0 ? options.foldAtElseInt != 0 : options.foldAtElse;
+	const bool userDefinedFoldMarkers = !options.foldExplicitStart.empty() && !options.foldExplicitEnd.empty();
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int stylePrev = style;
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+		if (options.foldComment && options.foldCommentMultiline && IsStreamCommentStyle(style)) {
+			if (!IsStreamCommentStyle(stylePrev)) {
+				levelNext++;
+			} else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
+				// Comments don't end at end of line and the next character may be unstyled.
+				levelNext--;
+			}
+		}
+		if (options.foldComment && options.foldCommentExplicit && ((style == SCE_D_COMMENTLINE) || options.foldExplicitAnywhere)) {
+			if (userDefinedFoldMarkers) {
+				if (styler.Match(i, options.foldExplicitStart.c_str())) {
+ 					levelNext++;
+				} else if (styler.Match(i, options.foldExplicitEnd.c_str())) {
+ 					levelNext--;
+ 				}
+			} else {
+				if ((ch == '/') && (chNext == '/')) {
+					char chNext2 = styler.SafeGetCharAt(i + 2);
+					if (chNext2 == '{') {
+						levelNext++;
+					} else if (chNext2 == '}') {
+						levelNext--;
+					}
+				}
+ 			}
+ 		}
+		if (options.foldSyntaxBased && (style == SCE_D_OPERATOR)) {
+			if (ch == '{') {
+				// Measure the minimum before a '{' to allow
+				// folding on "} else {"
+				if (levelMinCurrent > levelNext) {
+					levelMinCurrent = levelNext;
+				}
+				levelNext++;
+			} else if (ch == '}') {
+				levelNext--;
+			}
+		}
+		if (atEOL || (i == endPos-1)) {
+			if (options.foldComment && options.foldCommentMultiline) {  // Handle nested comments
+				int nc;
+				nc =  styler.GetLineState(lineCurrent);
+				nc -= lineCurrent>0? styler.GetLineState(lineCurrent-1): 0;
+				levelNext += nc;
+			}
+			int levelUse = levelCurrent;
+			if (options.foldSyntaxBased && foldAtElse) {
+				levelUse = levelMinCurrent;
+			}
+			int lev = levelUse | levelNext << 16;
+			if (visibleChars == 0 && options.foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if (levelUse < levelNext)
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			levelCurrent = levelNext;
+			levelMinCurrent = levelCurrent;
+			visibleChars = 0;
+		}
+		if (!IsASpace(ch))
+			visibleChars++;
+	}
+}
+
+LexerModule lmD(SCLEX_D, LexerD::LexerFactoryD, "d", dWordLists);
diff --git a/Pythonwin/Scintilla/lexers/LexDMAP.cxx b/Pythonwin/Scintilla/lexers/LexDMAP.cxx
new file mode 100644
index 000000000..91b10c29b
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexDMAP.cxx
@@ -0,0 +1,226 @@
+// Scintilla source code edit control
+/** @file LexDMAP.cxx
+ ** Lexer for MSC Nastran DMAP.
+ ** Written by Mark Robinson, based on the Fortran lexer by Chuan-jian Shen, Last changed Aug. 2013
+ **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+/***************************************/
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+/***************************************/
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+/***************************************/
+
+using namespace Scintilla;
+
+/***********************************************/
+static inline bool IsAWordChar(const int ch) {
+    return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '%');
+}
+/**********************************************/
+static inline bool IsAWordStart(const int ch) {
+    return (ch < 0x80) && (isalnum(ch));
+}
+/***************************************/
+static void ColouriseDMAPDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+            WordList *keywordlists[], Accessor &styler) {
+    WordList &keywords = *keywordlists[0];
+    WordList &keywords2 = *keywordlists[1];
+    WordList &keywords3 = *keywordlists[2];
+    /***************************************/
+    Sci_Position posLineStart = 0, numNonBlank = 0;
+    Sci_Position endPos = startPos + length;
+    /***************************************/
+    // backtrack to the nearest keyword
+    while ((startPos > 1) && (styler.StyleAt(startPos) != SCE_DMAP_WORD)) {
+        startPos--;
+    }
+    startPos = styler.LineStart(styler.GetLine(startPos));
+    initStyle = styler.StyleAt(startPos - 1);
+    StyleContext sc(startPos, endPos-startPos, initStyle, styler);
+    /***************************************/
+    for (; sc.More(); sc.Forward()) {
+        // remember the start position of the line
+        if (sc.atLineStart) {
+            posLineStart = sc.currentPos;
+            numNonBlank = 0;
+            sc.SetState(SCE_DMAP_DEFAULT);
+        }
+        if (!IsASpaceOrTab(sc.ch)) numNonBlank ++;
+        /***********************************************/
+        // Handle data appearing after column 72; it is ignored
+        Sci_Position toLineStart = sc.currentPos - posLineStart;
+        if (toLineStart >= 72 || sc.ch == '$') {
+            sc.SetState(SCE_DMAP_COMMENT);
+            while (!sc.atLineEnd && sc.More()) sc.Forward(); // Until line end
+            continue;
+        }
+        /***************************************/
+        // Determine if the current state should terminate.
+        if (sc.state == SCE_DMAP_OPERATOR) {
+            sc.SetState(SCE_DMAP_DEFAULT);
+        } else if (sc.state == SCE_DMAP_NUMBER) {
+            if (!(IsAWordChar(sc.ch) || sc.ch=='\'' || sc.ch=='\"' || sc.ch=='.')) {
+                sc.SetState(SCE_DMAP_DEFAULT);
+            }
+        } else if (sc.state == SCE_DMAP_IDENTIFIER) {
+            if (!IsAWordChar(sc.ch) || (sc.ch == '%')) {
+                char s[100];
+                sc.GetCurrentLowered(s, sizeof(s));
+                if (keywords.InList(s)) {
+                    sc.ChangeState(SCE_DMAP_WORD);
+                } else if (keywords2.InList(s)) {
+                    sc.ChangeState(SCE_DMAP_WORD2);
+                } else if (keywords3.InList(s)) {
+                    sc.ChangeState(SCE_DMAP_WORD3);
+                }
+                sc.SetState(SCE_DMAP_DEFAULT);
+            }
+        } else if (sc.state == SCE_DMAP_COMMENT) {
+            if (sc.ch == '\r' || sc.ch == '\n') {
+                sc.SetState(SCE_DMAP_DEFAULT);
+            }
+        } else if (sc.state == SCE_DMAP_STRING1) {
+            if (sc.ch == '\'') {
+                if (sc.chNext == '\'') {
+                    sc.Forward();
+                } else {
+                    sc.ForwardSetState(SCE_DMAP_DEFAULT);
+                }
+            } else if (sc.atLineEnd) {
+                sc.ChangeState(SCE_DMAP_STRINGEOL);
+                sc.ForwardSetState(SCE_DMAP_DEFAULT);
+            }
+        } else if (sc.state == SCE_DMAP_STRING2) {
+            if (sc.atLineEnd) {
+                sc.ChangeState(SCE_DMAP_STRINGEOL);
+                sc.ForwardSetState(SCE_DMAP_DEFAULT);
+            } else if (sc.ch == '\"') {
+                if (sc.chNext == '\"') {
+                    sc.Forward();
+                } else {
+                    sc.ForwardSetState(SCE_DMAP_DEFAULT);
+                }
+            }
+        }
+        /***************************************/
+        // Determine if a new state should be entered.
+        if (sc.state == SCE_DMAP_DEFAULT) {
+            if (sc.ch == '$') {
+                sc.SetState(SCE_DMAP_COMMENT);
+            } else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext)) || (sc.ch == '-' && IsADigit(sc.chNext))) {
+                sc.SetState(SCE_F_NUMBER);
+            } else if (IsAWordStart(sc.ch)) {
+                sc.SetState(SCE_DMAP_IDENTIFIER);
+            } else if (sc.ch == '\"') {
+                sc.SetState(SCE_DMAP_STRING2);
+            } else if (sc.ch == '\'') {
+                sc.SetState(SCE_DMAP_STRING1);
+            } else if (isoperator(static_cast<char>(sc.ch))) {
+                sc.SetState(SCE_DMAP_OPERATOR);
+            }
+        }
+    }
+    sc.Complete();
+}
+/***************************************/
+// To determine the folding level depending on keywords
+static int classifyFoldPointDMAP(const char* s, const char* prevWord) {
+    int lev = 0;
+    if ((strcmp(prevWord, "else") == 0 && strcmp(s, "if") == 0) || strcmp(s, "enddo") == 0 || strcmp(s, "endif") == 0) {
+        lev = -1;
+    } else if ((strcmp(prevWord, "do") == 0 && strcmp(s, "while") == 0) || strcmp(s, "then") == 0) {
+        lev = 1;
+    }
+    return lev;
+}
+// Folding the code
+static void FoldDMAPDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+                           WordList *[], Accessor &styler) {
+    //
+    // bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+    // Do not know how to fold the comment at the moment.
+    //
+    bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+    Sci_PositionU endPos = startPos + length;
+    int visibleChars = 0;
+    Sci_Position lineCurrent = styler.GetLine(startPos);
+    int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
+    int levelCurrent = levelPrev;
+    char chNext = styler[startPos];
+    int styleNext = styler.StyleAt(startPos);
+    int style = initStyle;
+    /***************************************/
+    Sci_Position lastStart = 0;
+    char prevWord[32] = "";
+    /***************************************/
+    for (Sci_PositionU i = startPos; i < endPos; i++) {
+        char ch = chNext;
+        chNext = styler.SafeGetCharAt(i + 1);
+        int stylePrev = style;
+        style = styleNext;
+        styleNext = styler.StyleAt(i + 1);
+        bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+        //
+        if ((stylePrev == SCE_DMAP_DEFAULT || stylePrev == SCE_DMAP_OPERATOR || stylePrev == SCE_DMAP_COMMENT) && (style == SCE_DMAP_WORD)) {
+            // Store last word and label start point.
+            lastStart = i;
+        }
+        /***************************************/
+        if (style == SCE_DMAP_WORD) {
+            if(iswordchar(ch) && !iswordchar(chNext)) {
+                char s[32];
+                Sci_PositionU k;
+                for(k=0; (k<31 ) && (k<i-lastStart+1 ); k++) {
+                    s[k] = static_cast<char>(tolower(styler[lastStart+k]));
+                }
+                s[k] = '\0';
+                levelCurrent += classifyFoldPointDMAP(s, prevWord);
+                strcpy(prevWord, s);
+            }
+        }
+        if (atEOL) {
+            int lev = levelPrev;
+            if (visibleChars == 0 && foldCompact)
+                lev |= SC_FOLDLEVELWHITEFLAG;
+            if ((levelCurrent > levelPrev) && (visibleChars > 0))
+                lev |= SC_FOLDLEVELHEADERFLAG;
+            if (lev != styler.LevelAt(lineCurrent)) {
+                styler.SetLevel(lineCurrent, lev);
+            }
+            lineCurrent++;
+            levelPrev = levelCurrent;
+            visibleChars = 0;
+            strcpy(prevWord, "");
+        }
+        /***************************************/
+        if (!isspacechar(ch)) visibleChars++;
+    }
+    /***************************************/
+    // Fill in the real level of the next line, keeping the current flags as they will be filled in later
+    int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
+    styler.SetLevel(lineCurrent, levelPrev | flagsNext);
+}
+/***************************************/
+static const char * const DMAPWordLists[] = {
+    "Primary keywords and identifiers",
+    "Intrinsic functions",
+    "Extended and user defined functions",
+    0,
+};
+/***************************************/
+LexerModule lmDMAP(SCLEX_DMAP, ColouriseDMAPDoc, "DMAP", FoldDMAPDoc, DMAPWordLists);
diff --git a/Pythonwin/Scintilla/lexers/LexDMIS.cxx b/Pythonwin/Scintilla/lexers/LexDMIS.cxx
new file mode 100644
index 000000000..3c8da6081
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexDMIS.cxx
@@ -0,0 +1,358 @@
+// Scintilla source code edit control
+/** @file LexDMIS.cxx
+ ** Lexer for DMIS.
+  **/
+// Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
+// Copyright 2013-2014 by Andreas Tscharner <andy@vis.ethz.ch>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cctype>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+
+static const char *const DMISWordListDesc[] = {
+	"DMIS Major Words",
+	"DMIS Minor Words",
+	"Unsupported DMIS Major Words",
+	"Unsupported DMIS Minor Words",
+	"Keywords for code folding start",
+	"Corresponding keywords for code folding end",
+	0
+};
+
+
+class LexerDMIS : public DefaultLexer
+{
+	private:
+		char *m_wordListSets;
+		WordList m_majorWords;
+		WordList m_minorWords;
+		WordList m_unsupportedMajor;
+		WordList m_unsupportedMinor;
+		WordList m_codeFoldingStart;
+		WordList m_codeFoldingEnd;
+
+		char * SCI_METHOD UpperCase(char *item);
+		void SCI_METHOD InitWordListSets(void);
+
+	public:
+		LexerDMIS(void);
+		virtual ~LexerDMIS(void);
+
+		int SCI_METHOD Version() const override {
+			return lvRelease5;
+		}
+
+		void SCI_METHOD Release() override {
+			delete this;
+		}
+
+		const char * SCI_METHOD PropertyNames() override {
+			return NULL;
+		}
+
+		int SCI_METHOD PropertyType(const char *) override {
+			return -1;
+		}
+
+		const char * SCI_METHOD DescribeProperty(const char *) override {
+			return NULL;
+		}
+
+		Sci_Position SCI_METHOD PropertySet(const char *, const char *) override {
+			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 ILexer5 *LexerFactoryDMIS() {
+			return new LexerDMIS;
+		}
+
+		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;
+};
+
+
+char * SCI_METHOD LexerDMIS::UpperCase(char *item)
+{
+	char *itemStart;
+
+
+	itemStart = item;
+	while (item && *item) {
+		*item = toupper(*item);
+		item++;
+	};
+	return itemStart;
+}
+
+void SCI_METHOD LexerDMIS::InitWordListSets(void)
+{
+	size_t totalLen = 0;
+
+
+	for (int i=0; DMISWordListDesc[i]; i++) {
+		totalLen += strlen(DMISWordListDesc[i]);
+		totalLen++;
+	};
+
+	totalLen++;
+	this->m_wordListSets = new char[totalLen];
+	memset(this->m_wordListSets, 0, totalLen);
+
+	for (int i=0; DMISWordListDesc[i]; i++) {
+		strcat(this->m_wordListSets, DMISWordListDesc[i]);
+		strcat(this->m_wordListSets, "\n");
+	};
+}
+
+
+LexerDMIS::LexerDMIS(void) : DefaultLexer("DMIS", SCLEX_DMIS) {
+	this->InitWordListSets();
+
+	this->m_majorWords.Clear();
+	this->m_minorWords.Clear();
+	this->m_unsupportedMajor.Clear();
+	this->m_unsupportedMinor.Clear();
+	this->m_codeFoldingStart.Clear();
+	this->m_codeFoldingEnd.Clear();
+}
+
+LexerDMIS::~LexerDMIS(void) {
+	delete[] this->m_wordListSets;
+}
+
+Sci_Position SCI_METHOD LexerDMIS::WordListSet(int n, const char *wl)
+{
+	switch (n) {
+		case 0:
+			this->m_majorWords.Clear();
+			this->m_majorWords.Set(wl);
+			break;
+		case 1:
+			this->m_minorWords.Clear();
+			this->m_minorWords.Set(wl);
+			break;
+		case 2:
+			this->m_unsupportedMajor.Clear();
+			this->m_unsupportedMajor.Set(wl);
+			break;
+		case 3:
+			this->m_unsupportedMinor.Clear();
+			this->m_unsupportedMinor.Set(wl);
+			break;
+		case 4:
+			this->m_codeFoldingStart.Clear();
+			this->m_codeFoldingStart.Set(wl);
+			break;
+		case 5:
+			this->m_codeFoldingEnd.Clear();
+			this->m_codeFoldingEnd.Set(wl);
+			break;
+		default:
+			return -1;
+			break;
+	}
+
+	return 0;
+}
+
+const char * SCI_METHOD LexerDMIS::DescribeWordListSets()
+{
+	return this->m_wordListSets;
+}
+
+void SCI_METHOD LexerDMIS::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess)
+{
+	const Sci_PositionU MAX_STR_LEN = 100;
+
+	LexAccessor styler(pAccess);
+	StyleContext scCTX(startPos, lengthDoc, initStyle, styler);
+	CharacterSet setDMISNumber(CharacterSet::setDigits, ".-+eE");
+	CharacterSet setDMISWordStart(CharacterSet::setAlpha, "-234", 0x80, true);
+	CharacterSet setDMISWord(CharacterSet::setAlpha);
+
+
+	bool isIFLine = false;
+
+	for (; scCTX.More(); scCTX.Forward()) {
+		if (scCTX.atLineEnd) {
+			isIFLine = false;
+		};
+
+		switch (scCTX.state) {
+			case SCE_DMIS_DEFAULT:
+				if (scCTX.Match('$', '$')) {
+					scCTX.SetState(SCE_DMIS_COMMENT);
+					scCTX.Forward();
+				};
+				if (scCTX.Match('\'')) {
+					scCTX.SetState(SCE_DMIS_STRING);
+				};
+				if (IsADigit(scCTX.ch) || ((scCTX.Match('-') || scCTX.Match('+')) && IsADigit(scCTX.chNext))) {
+					scCTX.SetState(SCE_DMIS_NUMBER);
+					break;
+				};
+				if (setDMISWordStart.Contains(scCTX.ch)) {
+					scCTX.SetState(SCE_DMIS_KEYWORD);
+				};
+				if (scCTX.Match('(') && (!isIFLine)) {
+					scCTX.SetState(SCE_DMIS_LABEL);
+				};
+				break;
+
+			case SCE_DMIS_COMMENT:
+				if (scCTX.atLineEnd) {
+					scCTX.SetState(SCE_DMIS_DEFAULT);
+				};
+				break;
+
+			case SCE_DMIS_STRING:
+				if (scCTX.Match('\'')) {
+					scCTX.SetState(SCE_DMIS_DEFAULT);
+				};
+				break;
+
+			case SCE_DMIS_NUMBER:
+				if (!setDMISNumber.Contains(scCTX.ch)) {
+					scCTX.SetState(SCE_DMIS_DEFAULT);
+				};
+				break;
+
+			case SCE_DMIS_KEYWORD:
+				if (!setDMISWord.Contains(scCTX.ch)) {
+					char tmpStr[MAX_STR_LEN];
+					memset(tmpStr, 0, MAX_STR_LEN*sizeof(char));
+					scCTX.GetCurrent(tmpStr, (MAX_STR_LEN-1));
+					strncpy(tmpStr, this->UpperCase(tmpStr), (MAX_STR_LEN-1));
+
+					if (this->m_minorWords.InList(tmpStr)) {
+						scCTX.ChangeState(SCE_DMIS_MINORWORD);
+					};
+					if (this->m_majorWords.InList(tmpStr)) {
+						isIFLine = (strcmp(tmpStr, "IF") == 0);
+						scCTX.ChangeState(SCE_DMIS_MAJORWORD);
+					};
+					if (this->m_unsupportedMajor.InList(tmpStr)) {
+						scCTX.ChangeState(SCE_DMIS_UNSUPPORTED_MAJOR);
+					};
+					if (this->m_unsupportedMinor.InList(tmpStr)) {
+						scCTX.ChangeState(SCE_DMIS_UNSUPPORTED_MINOR);
+					};
+
+					if (scCTX.Match('(') && (!isIFLine)) {
+						scCTX.SetState(SCE_DMIS_LABEL);
+					} else {
+						scCTX.SetState(SCE_DMIS_DEFAULT);
+					};
+				};
+				break;
+
+			case SCE_DMIS_LABEL:
+				if (scCTX.Match(')')) {
+					scCTX.SetState(SCE_DMIS_DEFAULT);
+				};
+				break;
+		};
+	};
+	scCTX.Complete();
+}
+
+void SCI_METHOD LexerDMIS::Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int, IDocument *pAccess)
+{
+	const int MAX_STR_LEN = 100;
+
+	LexAccessor styler(pAccess);
+	Sci_PositionU endPos = startPos + lengthDoc;
+	char chNext = styler[startPos];
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
+	int levelCurrent = levelPrev;
+	int strPos = 0;
+	bool foldWordPossible = false;
+	CharacterSet setDMISFoldWord(CharacterSet::setAlpha);
+	char *tmpStr;
+
+
+	tmpStr = new char[MAX_STR_LEN];
+	memset(tmpStr, 0, MAX_STR_LEN*sizeof(char));
+
+	for (Sci_PositionU i=startPos; i<endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i+1);
+
+		bool atEOL = ((ch == '\r' && chNext != '\n') || (ch == '\n'));
+
+		if (strPos >= (MAX_STR_LEN-1)) {
+			strPos = MAX_STR_LEN-1;
+		};
+
+		int style = styler.StyleAt(i);
+		bool noFoldPos = ((style == SCE_DMIS_COMMENT) || (style == SCE_DMIS_STRING));
+
+		if (foldWordPossible) {
+			if (setDMISFoldWord.Contains(ch)) {
+				tmpStr[strPos++] = ch;
+			} else {
+				tmpStr = this->UpperCase(tmpStr);
+				if (this->m_codeFoldingStart.InList(tmpStr) && (!noFoldPos)) {
+					levelCurrent++;
+				};
+				if (this->m_codeFoldingEnd.InList(tmpStr) && (!noFoldPos)) {
+					levelCurrent--;
+				};
+				memset(tmpStr, 0, MAX_STR_LEN*sizeof(char));
+				strPos = 0;
+				foldWordPossible = false;
+			};
+		} else {
+			if (setDMISFoldWord.Contains(ch)) {
+				tmpStr[strPos++] = ch;
+				foldWordPossible = true;
+			};
+		};
+
+		if (atEOL || (i == (endPos-1))) {
+			int lev = levelPrev;
+
+			if (levelCurrent > levelPrev) {
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			};
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			};
+			lineCurrent++;
+			levelPrev = levelCurrent;
+		};
+	};
+	delete[] tmpStr;
+}
+
+
+LexerModule lmDMIS(SCLEX_DMIS, LexerDMIS::LexerFactoryDMIS, "DMIS", DMISWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexDataflex.cxx b/Pythonwin/Scintilla/lexers/LexDataflex.cxx
new file mode 100644
index 000000000..42bd39b6b
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexDataflex.cxx
@@ -0,0 +1,608 @@
+// Scintilla source code edit control
+/** @file LexDataflex.cxx
+ ** Lexer for DataFlex.
+ ** Based on LexPascal.cxx
+ ** Written by Wil van Antwerpen, June 2019
+ **/
+
+/*
+// The License.txt file describes the conditions under which this software may be distributed.
+
+A few words about features of LexDataflex...
+
+Generally speaking LexDataflex tries to support all available DataFlex features (up
+to DataFlex 19.1 at this time).
+
+~ FOLDING:
+
+Folding is supported in the following cases:
+
+- Folding of stream-like comments
+- Folding of groups of consecutive line comments
+- Folding of preprocessor blocks (the following preprocessor blocks are
+supported: #IFDEF, #IFNDEF, #ENDIF and #HEADER / #ENDHEADER 
+blocks), 
+- Folding of code blocks on appropriate keywords (the following code blocks are
+supported: "begin, struct, type, case / end" blocks, class & object
+declarations and interface declarations)
+
+Remarks:
+
+- We pass 4 arrays to the lexer:
+1. The DataFlex keyword list, these are normal DataFlex keywords
+2. The Scope Open list, for example, begin / procedure / while
+3. The Scope Close list, for example, end / end_procedure / loop
+4. Operator list, for ex. + / - / * / Lt / iand
+These lists are all mutually exclusive, scope open words should not be in the keyword list and vice versa
+
+- Folding of code blocks tries to handle all special cases in which folding
+should not occur. 
+
+~ KEYWORDS:
+
+The list of keywords that can be used in dataflex.properties file (up to DataFlex
+19.1):
+
+- Keywords: .. snipped .. see dataflex.properties file.
+
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+
+static void GetRangeLowered(Sci_PositionU start,
+		Sci_PositionU end,
+		Accessor &styler,
+		char *s,
+		Sci_PositionU len) {
+	Sci_PositionU i = 0;
+	while ((i < end - start + 1) && (i < len-1)) {
+		s[i] = static_cast<char>(tolower(styler[start + i]));
+		i++;
+	}
+	s[i] = '\0';
+}
+
+static void GetForwardRangeLowered(Sci_PositionU start,
+		CharacterSet &charSet,
+		Accessor &styler,
+		char *s,
+		Sci_PositionU len) {
+	Sci_PositionU i = 0;
+	while ((i < len-1) && charSet.Contains(styler.SafeGetCharAt(start + i))) {
+		s[i] = static_cast<char>(tolower(styler.SafeGetCharAt(start + i)));
+		i++;
+	}
+	s[i] = '\0';
+
+}
+
+enum {
+	stateInICode = 0x1000,
+	stateSingleQuoteOpen = 0x2000,
+	stateDoubleQuoteOpen = 0x4000,
+	stateFoldInPreprocessor = 0x0100,
+	stateFoldInCaseStatement = 0x0200,
+	stateFoldInPreprocessorLevelMask = 0x00FF,
+	stateFoldMaskAll = 0x0FFF
+};
+
+
+static bool IsFirstDataFlexWord(Sci_Position pos, Accessor &styler) {
+	Sci_Position line = styler.GetLine(pos);
+	Sci_Position start_pos = styler.LineStart(line);
+	for (Sci_Position i = start_pos; i < pos; i++) {
+		char ch = styler.SafeGetCharAt(i);
+		if (!(ch == ' ' || ch == '\t'))
+			return false;
+	}
+	return true;
+}
+
+
+inline bool IsADataFlexField(int ch) {
+	return (ch == '.');
+}
+
+
+static void ClassifyDataFlexWord(WordList *keywordlists[], StyleContext &sc, Accessor &styler) {
+	WordList& keywords = *keywordlists[0];
+	WordList& scopeOpen   = *keywordlists[1];
+	WordList& scopeClosed = *keywordlists[2];
+	WordList& operators   = *keywordlists[3];
+
+	char s[100];
+	int oldState;
+	int newState;
+	size_t tokenlen;
+
+    oldState = sc.state;
+	newState = oldState;
+	sc.GetCurrentLowered(s, sizeof(s));
+	tokenlen = strnlen(s,sizeof(s));
+	if (keywords.InList(s)) {
+		// keywords in DataFlex can be used as table column names (file.field) and as such they
+		// should not be characterized as a keyword. So test for that.
+		// for ex. somebody using date as field name.
+        if (!IsADataFlexField(sc.GetRelative(-static_cast<int>(tokenlen+1)))) {
+	      newState = SCE_DF_WORD;
+	    }
+	}
+	if (oldState == newState) {
+		if ((scopeOpen.InList(s) || scopeClosed.InList(s)) && (strcmp(s, "for") != 0) && (strcmp(s, "repeat") != 0)) {
+			// scope words in DataFlex can be used as table column names (file.field) and as such they
+			// should not be characterized as a scope word. So test for that.
+			// for ex. somebody using procedure for field name.
+			if (!IsADataFlexField(sc.GetRelative(-static_cast<int>(tokenlen+1)))) {
+				newState = SCE_DF_SCOPEWORD;
+			}
+		} 
+		// no code folding on the next words, but just want to paint them like keywords (as they are) (??? doesn't the code to the opposite?)
+		if (strcmp(s, "if") == 0 ||  
+			strcmp(s, "ifnot") == 0 ||
+			strcmp(s, "case") == 0 ||
+			strcmp(s, "else") == 0 ) {
+				newState = SCE_DF_SCOPEWORD;
+		} 
+	}
+	if (oldState != newState && newState == SCE_DF_WORD) {
+		// a for loop must have for at the start of the line, for is also used in "define abc for 123"
+		if ( (strcmp(s, "for") == 0) && (IsFirstDataFlexWord(sc.currentPos-3, styler)) ) {   
+				newState = SCE_DF_SCOPEWORD;
+		} 
+	}
+	if (oldState != newState && newState == SCE_DF_WORD) {
+		// a repeat loop must have repeat at the start of the line, repeat is also used in 'move (repeat("d",5)) to sFoo'
+		if ( (strcmp(s, "repeat") == 0) && (IsFirstDataFlexWord(sc.currentPos-6, styler)) ) {   
+				newState = SCE_DF_SCOPEWORD;
+		} 
+	}
+	if (oldState == newState)  {
+	  if (operators.InList(s)) {
+		  newState = SCE_DF_OPERATOR;
+		} 
+	}
+
+	if (oldState != newState) {
+		sc.ChangeState(newState);
+	}
+	sc.SetState(SCE_DF_DEFAULT);
+}
+
+static void ColouriseDataFlexDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+		Accessor &styler) {
+//	bool bSmartHighlighting = styler.GetPropertyInt("lexer.dataflex.smart.highlighting", 1) != 0;
+
+			CharacterSet setWordStart(CharacterSet::setAlpha, "_$#@", 0x80, true);
+			CharacterSet setWord(CharacterSet::setAlphaNum, "_$#@", 0x80, true);
+	CharacterSet setNumber(CharacterSet::setDigits, ".-+eE");
+	CharacterSet setHexNumber(CharacterSet::setDigits, "abcdefABCDEF");
+	CharacterSet setOperator(CharacterSet::setNone, "*+-/<=>^");
+
+	Sci_Position curLine = styler.GetLine(startPos);
+	int curLineState = curLine > 0 ? styler.GetLineState(curLine - 1) : 0;
+
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	for (; sc.More(); sc.Forward()) {
+		if (sc.atLineEnd) {
+			// Update the line state, so it can be seen by next line
+			curLine = styler.GetLine(sc.currentPos);
+			styler.SetLineState(curLine, curLineState);
+		}
+
+		// Determine if the current state should terminate.
+		switch (sc.state) {
+			case SCE_DF_NUMBER:
+				if (!setNumber.Contains(sc.ch) || (sc.ch == '.' && sc.chNext == '.')) {
+					sc.SetState(SCE_DF_DEFAULT);
+				} else if (sc.ch == '-' || sc.ch == '+') {
+					if (sc.chPrev != 'E' && sc.chPrev != 'e') {
+						sc.SetState(SCE_DF_DEFAULT);
+					}
+				}
+				break;
+			case SCE_DF_IDENTIFIER:
+				if (!setWord.Contains(sc.ch)) {
+					ClassifyDataFlexWord(keywordlists, sc, styler);
+				}
+				break;
+			case SCE_DF_HEXNUMBER:
+				if (!(setHexNumber.Contains(sc.ch) || sc.ch == 'I') ) { // in |CI$22a we also want to color the "I"
+					sc.SetState(SCE_DF_DEFAULT);
+				}
+				break;
+			case SCE_DF_METATAG:
+				if (sc.atLineStart || sc.chPrev == '}') {
+					sc.SetState(SCE_DF_DEFAULT);
+				}
+				break;
+			case SCE_DF_PREPROCESSOR:
+				if (sc.atLineStart || IsASpaceOrTab(sc.ch)) {
+					sc.SetState(SCE_DF_DEFAULT);
+				}
+				break;
+			case SCE_DF_IMAGE:
+				if (sc.atLineStart && sc.Match("/*")) {
+					sc.Forward();  // these characters are still part of the DF Image
+					sc.ForwardSetState(SCE_DF_DEFAULT);
+				}
+				break;
+			case SCE_DF_PREPROCESSOR2:
+				// we don't have inline comments or preprocessor2 commands
+				//if (sc.Match('*', ')')) {
+				//	sc.Forward();
+				//	sc.ForwardSetState(SCE_DF_DEFAULT);
+				//}
+				break;
+			case SCE_DF_COMMENTLINE:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_DF_DEFAULT);
+				}
+				break;
+			case SCE_DF_STRING:
+				if (sc.atLineEnd) {
+					sc.ChangeState(SCE_DF_STRINGEOL);
+				} else if (sc.ch == '\'' && sc.chNext == '\'') {
+					sc.Forward();
+				} else if (sc.ch == '\"' && sc.chNext == '\"') {
+					sc.Forward();
+				} else if (sc.ch == '\'' || sc.ch == '\"') {
+					if (sc.ch == '\'' && (curLineState & stateSingleQuoteOpen) ) {
+ 				    curLineState &= ~(stateSingleQuoteOpen);
+					sc.ForwardSetState(SCE_DF_DEFAULT);
+					}
+					else if (sc.ch == '\"' && (curLineState & stateDoubleQuoteOpen) ) {
+ 				    curLineState &= ~(stateDoubleQuoteOpen);
+					sc.ForwardSetState(SCE_DF_DEFAULT);
+					}
+				}
+				break;
+			case SCE_DF_STRINGEOL:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_DF_DEFAULT);
+				}
+				break;
+			case SCE_DF_SCOPEWORD:
+				//if (!setHexNumber.Contains(sc.ch) && sc.ch != '$') {
+				//	sc.SetState(SCE_DF_DEFAULT);
+				//}
+				break;
+			case SCE_DF_OPERATOR:
+//				if (bSmartHighlighting && sc.chPrev == ';') {
+//					curLineState &= ~(stateInProperty | stateInExport);
+//				}
+				sc.SetState(SCE_DF_DEFAULT);
+				break;
+			case SCE_DF_ICODE:
+				if (sc.atLineStart || IsASpace(sc.ch) || isoperator(sc.ch)) {
+				sc.SetState(SCE_DF_DEFAULT);
+				}
+				break;
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_DF_DEFAULT) {
+			if (IsADigit(sc.ch)) {
+				sc.SetState(SCE_DF_NUMBER);
+			} else if (sc.Match('/', '/') || sc.Match("#REM")) {
+				sc.SetState(SCE_DF_COMMENTLINE);
+			} else if ((sc.ch == '#' && !sc.Match("#REM")) && IsFirstDataFlexWord(sc.currentPos, styler)) {
+				sc.SetState(SCE_DF_PREPROCESSOR);
+			// || (sc.ch == '|' && sc.chNext == 'C' && sc.GetRelativeCharacter(2) == 'I' && sc.GetRelativeCharacter(3) == '$') ) {
+			} else if ((sc.ch == '$' && ((!setWord.Contains(sc.chPrev)) || sc.chPrev == 'I' ) ) || (sc.Match("|CI$")) ) {
+				sc.SetState(SCE_DF_HEXNUMBER); // start with $ and previous character not in a..zA..Z0..9 excluding "I" OR start with |CI$
+			} else if (setWordStart.Contains(sc.ch)) {
+				sc.SetState(SCE_DF_IDENTIFIER);
+			} else if (sc.ch == '{') {
+				sc.SetState(SCE_DF_METATAG);
+			//} else if (sc.Match("(*$")) {
+			//	sc.SetState(SCE_DF_PREPROCESSOR2);
+			} else if (sc.ch == '/' && setWord.Contains(sc.chNext) &&  sc.atLineStart) {
+				sc.SetState(SCE_DF_IMAGE);
+			//	sc.Forward();	// Eat the * so it isn't used for the end of the comment
+			} else if (sc.ch == '\'' || sc.ch == '\"') {
+				if (sc.ch == '\'' && !(curLineState & stateDoubleQuoteOpen)) {
+				  curLineState |= stateSingleQuoteOpen;
+				} else if (sc.ch == '\"' && !(curLineState & stateSingleQuoteOpen)) {
+				  curLineState |= stateDoubleQuoteOpen;
+				}
+			    sc.SetState(SCE_DF_STRING);
+			} else if (setOperator.Contains(sc.ch)) {
+				sc.SetState(SCE_DF_OPERATOR);
+//			} else if (curLineState & stateInICode) {
+				// ICode start ! in a string followed by close string mark is not icode
+			} else if ((sc.ch == '!') && !(sc.ch == '!' && ((sc.chNext == '\"') || (sc.ch == '\'')) )) {
+				sc.SetState(SCE_DF_ICODE);
+			}
+		}
+	}
+
+	if (sc.state == SCE_DF_IDENTIFIER && setWord.Contains(sc.chPrev)) {
+		ClassifyDataFlexWord(keywordlists, sc, styler);
+	}
+
+	sc.Complete();
+}
+
+static bool IsStreamCommentStyle(int style) {
+	return style == SCE_DF_IMAGE;
+}
+
+static bool IsCommentLine(Sci_Position line, Accessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eolPos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eolPos; i++) {
+		char ch = styler[i];
+		char chNext = styler.SafeGetCharAt(i + 1);
+		int style = styler.StyleAt(i);
+		if (ch == '/' && chNext == '/' && style == SCE_DF_COMMENTLINE) {
+			return true;
+		} else if (!IsASpaceOrTab(ch)) {
+			return false;
+		}
+	}
+	return false;
+}
+
+
+
+static unsigned int GetFoldInPreprocessorLevelFlag(int lineFoldStateCurrent) {
+	return lineFoldStateCurrent & stateFoldInPreprocessorLevelMask;
+}
+
+static void SetFoldInPreprocessorLevelFlag(int &lineFoldStateCurrent, unsigned int nestLevel) {
+	lineFoldStateCurrent &= ~stateFoldInPreprocessorLevelMask;
+	lineFoldStateCurrent |= nestLevel & stateFoldInPreprocessorLevelMask;
+}
+
+static int ClassifyDataFlexPreprocessorFoldPoint(int &levelCurrent, int &lineFoldStateCurrent,
+		Sci_PositionU startPos, Accessor &styler) {
+	CharacterSet setWord(CharacterSet::setAlpha);
+
+	char s[100];	// Size of the longest possible keyword + one additional character + null
+	GetForwardRangeLowered(startPos, setWord, styler, s, sizeof(s));
+	size_t iLen = strnlen(s,sizeof(s));
+	size_t iWordSize = 0;
+
+	unsigned int nestLevel = GetFoldInPreprocessorLevelFlag(lineFoldStateCurrent);
+
+	if (strcmp(s, "command") == 0 ||
+		// The #if/#ifdef etcetera commands are not currently foldable as it is easy to write code that
+		// breaks the collaps logic, so we keep things simple and not include that for now.
+		strcmp(s, "header") == 0) {
+		nestLevel++;
+		SetFoldInPreprocessorLevelFlag(lineFoldStateCurrent, nestLevel);
+		lineFoldStateCurrent |= stateFoldInPreprocessor;
+		levelCurrent++;
+		iWordSize = iLen;
+	} else if (strcmp(s, "endcommand") == 0 ||
+		strcmp(s, "endheader") == 0) {
+		nestLevel--;
+		SetFoldInPreprocessorLevelFlag(lineFoldStateCurrent, nestLevel);
+		if (nestLevel == 0) {
+			lineFoldStateCurrent &= ~stateFoldInPreprocessor;
+		}
+		levelCurrent--;
+		iWordSize = iLen;
+		if (levelCurrent < SC_FOLDLEVELBASE) {
+			levelCurrent = SC_FOLDLEVELBASE;
+		}
+	}
+	return static_cast<int>(iWordSize);
+}
+
+
+static void ClassifyDataFlexWordFoldPoint(int &levelCurrent, int &lineFoldStateCurrent,
+		Sci_PositionU lastStart, Sci_PositionU currentPos, WordList *[], Accessor &styler) {
+	char s[100];
+
+	// property fold.dataflex.compilerlist
+	//	Set to 1 for enabling the code folding feature in *.prn files
+	bool foldPRN = styler.GetPropertyInt("fold.dataflex.compilerlist",0) != 0;
+
+	GetRangeLowered(lastStart, currentPos, styler, s, sizeof(s));
+
+	if (strcmp(s, "case") == 0) {
+		lineFoldStateCurrent |= stateFoldInCaseStatement;
+	} else if (strcmp(s, "begin") == 0) {
+		levelCurrent++;
+	} else if (strcmp(s, "for") == 0 ||
+		strcmp(s, "while") == 0 ||
+		strcmp(s, "repeat") == 0 ||
+		strcmp(s, "for_all") == 0 ||
+		strcmp(s, "struct") == 0 ||
+		strcmp(s, "type") == 0 ||
+		strcmp(s, "begin_row") == 0 ||
+		strcmp(s, "item_list") == 0 ||
+		strcmp(s, "begin_constraints") == 0 ||
+		strcmp(s, "begin_transaction") == 0 ||
+		strcmp(s, "enum_list") == 0 ||
+		strcmp(s, "class") == 0 || 
+		strcmp(s, "object") == 0 ||
+		strcmp(s, "cd_popup_object") == 0 ||
+		strcmp(s, "procedure") == 0 ||
+		strcmp(s, "procedure_section") == 0 ||
+		strcmp(s, "function") == 0 ) {
+			if ((IsFirstDataFlexWord(lastStart, styler )) || foldPRN) {
+			levelCurrent++;
+			}
+	} else if (strcmp(s, "end") == 0) {  // end is not always the first keyword, for example "case end"
+		levelCurrent--;
+		if (levelCurrent < SC_FOLDLEVELBASE) {
+			levelCurrent = SC_FOLDLEVELBASE;
+		}
+	} else if (strcmp(s, "loop") == 0 ||
+				   strcmp(s, "until") == 0 ||
+				   strcmp(s, "end_class") == 0 ||
+				   strcmp(s, "end_object") == 0 ||
+				   strcmp(s, "cd_end_object") == 0 ||
+				   strcmp(s, "end_procedure") == 0 ||
+				   strcmp(s, "end_function") == 0 ||
+				   strcmp(s, "end_for_all") == 0 ||
+				   strcmp(s, "end_struct") == 0 ||
+				   strcmp(s, "end_type") == 0 ||
+				   strcmp(s, "end_row") == 0 ||
+				   strcmp(s, "end_item_list") == 0 ||
+				   strcmp(s, "end_constraints") == 0 ||
+				   strcmp(s, "end_transaction") == 0 ||
+				   strcmp(s, "end_enum_list") == 0 ) {
+	//		lineFoldStateCurrent &= ~stateFoldInRecord;
+			if ((IsFirstDataFlexWord(lastStart, styler )) || foldPRN) {
+				levelCurrent--;
+				if (levelCurrent < SC_FOLDLEVELBASE) {
+					levelCurrent = SC_FOLDLEVELBASE;
+				}
+			}
+	}
+
+}
+
+
+static void ClassifyDataFlexMetaDataFoldPoint(int &levelCurrent, 
+		Sci_PositionU lastStart, Sci_PositionU currentPos, WordList *[], Accessor &styler) {
+	char s[100];
+
+	GetRangeLowered(lastStart, currentPos, styler, s, sizeof(s));
+
+    if (strcmp(s, "#beginsection") == 0) {
+		levelCurrent++;
+	} else if (strcmp(s, "#endsection") == 0) {
+			levelCurrent--;
+			if (levelCurrent < SC_FOLDLEVELBASE) {
+				levelCurrent = SC_FOLDLEVELBASE;
+			}
+	}
+
+}
+
+static void FoldDataFlexDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+		Accessor &styler) {
+	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+	bool foldPreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0;
+	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
+	int levelCurrent = levelPrev;
+	int lineFoldStateCurrent = lineCurrent > 0 ? styler.GetLineState(lineCurrent - 1) & stateFoldMaskAll : 0;
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+	int iWordSize;
+
+	Sci_Position lastStart = 0;
+	CharacterSet setWord(CharacterSet::setAlphaNum, "_$#@", 0x80, true);
+
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int stylePrev = style;
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+
+		if (foldComment && IsStreamCommentStyle(style)) {
+			if (!IsStreamCommentStyle(stylePrev)) {
+				levelCurrent++;
+			} else if (!IsStreamCommentStyle(styleNext)) {
+				levelCurrent--;
+			}
+		}
+		if (foldComment && atEOL && IsCommentLine(lineCurrent, styler))
+		{
+			if (!IsCommentLine(lineCurrent - 1, styler)
+			    && IsCommentLine(lineCurrent + 1, styler))
+				levelCurrent++;
+			else if (IsCommentLine(lineCurrent - 1, styler)
+			         && !IsCommentLine(lineCurrent+1, styler))
+				levelCurrent--;
+		}
+		if (foldPreprocessor) {
+			if (style == SCE_DF_PREPROCESSOR) {
+				iWordSize = ClassifyDataFlexPreprocessorFoldPoint(levelCurrent, lineFoldStateCurrent, i + 1, styler);
+			//} else if (style == SCE_DF_PREPROCESSOR2 && ch == '(' && chNext == '*'
+			//           && styler.SafeGetCharAt(i + 2) == '$') {
+			//	ClassifyDataFlexPreprocessorFoldPoint(levelCurrent, lineFoldStateCurrent, i + 3, styler);
+				i = i + iWordSize;
+			}
+		}
+
+		if (stylePrev != SCE_DF_SCOPEWORD && style == SCE_DF_SCOPEWORD)
+		{
+			// Store last word start point.
+			lastStart = i;
+		}
+		if (stylePrev == SCE_DF_SCOPEWORD) {
+			if(setWord.Contains(ch) && !setWord.Contains(chNext)) {
+				ClassifyDataFlexWordFoldPoint(levelCurrent, lineFoldStateCurrent, lastStart, i, keywordlists, styler);
+			}
+		}
+
+		if (stylePrev == SCE_DF_METATAG && ch == '#')
+		{
+			// Store last word start point.
+			lastStart = i;
+		}
+		if (stylePrev == SCE_DF_METATAG) {
+			if(setWord.Contains(ch) && !setWord.Contains(chNext)) {
+				ClassifyDataFlexMetaDataFoldPoint(levelCurrent, lastStart, i, keywordlists, styler);
+			}
+		}
+
+		if (!IsASpace(ch))
+			visibleChars++;
+
+		if (atEOL) {
+			int lev = levelPrev;
+			if (visibleChars == 0 && foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if ((levelCurrent > levelPrev) && (visibleChars > 0))
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			int newLineState = (styler.GetLineState(lineCurrent) & ~stateFoldMaskAll) | lineFoldStateCurrent;
+			styler.SetLineState(lineCurrent, newLineState);
+			lineCurrent++;
+			levelPrev = levelCurrent;
+			visibleChars = 0;
+		}
+	}
+
+	// If we didn't reach the EOL in previous loop, store line level and whitespace information.
+	// The rest will be filled in later...
+	int lev = levelPrev;
+	if (visibleChars == 0 && foldCompact)
+		lev |= SC_FOLDLEVELWHITEFLAG;
+	styler.SetLevel(lineCurrent, lev);
+}
+
+static const char * const dataflexWordListDesc[] = {
+	"Keywords",
+	"Scope open",
+	"Scope close",
+	"Operators",
+	0
+};
+
+LexerModule lmDataflex(SCLEX_DATAFLEX, ColouriseDataFlexDoc, "dataflex", FoldDataFlexDoc, dataflexWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexDiff.cxx b/Pythonwin/Scintilla/lexers/LexDiff.cxx
new file mode 100644
index 000000000..dd008c5cb
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexDiff.cxx
@@ -0,0 +1,161 @@
+// Scintilla source code edit control
+/** @file LexDiff.cxx
+ ** Lexer for diff results.
+ **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static inline bool AtEOL(Accessor &styler, Sci_PositionU i) {
+	return (styler[i] == '\n') ||
+	       ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n'));
+}
+
+#define DIFF_BUFFER_START_SIZE 16
+// Note that ColouriseDiffLine analyzes only the first DIFF_BUFFER_START_SIZE
+// characters of each line to classify the line.
+
+static void ColouriseDiffLine(char *lineBuffer, Sci_Position endLine, Accessor &styler) {
+	// It is needed to remember the current state to recognize starting
+	// comment lines before the first "diff " or "--- ". If a real
+	// difference starts then each line starting with ' ' is a whitespace
+	// otherwise it is considered a comment (Only in..., Binary file...)
+	if (0 == strncmp(lineBuffer, "diff ", 5)) {
+		styler.ColourTo(endLine, SCE_DIFF_COMMAND);
+	} else if (0 == strncmp(lineBuffer, "Index: ", 7)) {  // For subversion's diff
+		styler.ColourTo(endLine, SCE_DIFF_COMMAND);
+	} else if (0 == strncmp(lineBuffer, "---", 3) && lineBuffer[3] != '-') {
+		// In a context diff, --- appears in both the header and the position markers
+		if (lineBuffer[3] == ' ' && atoi(lineBuffer + 4) && !strchr(lineBuffer, '/'))
+			styler.ColourTo(endLine, SCE_DIFF_POSITION);
+		else if (lineBuffer[3] == '\r' || lineBuffer[3] == '\n')
+			styler.ColourTo(endLine, SCE_DIFF_POSITION);
+		else if (lineBuffer[3] == ' ')
+			styler.ColourTo(endLine, SCE_DIFF_HEADER);
+		else
+			styler.ColourTo(endLine, SCE_DIFF_DELETED);
+	} else if (0 == strncmp(lineBuffer, "+++ ", 4)) {
+		// I don't know of any diff where "+++ " is a position marker, but for
+		// consistency, do the same as with "--- " and "*** ".
+		if (atoi(lineBuffer+4) && !strchr(lineBuffer, '/'))
+			styler.ColourTo(endLine, SCE_DIFF_POSITION);
+		else
+			styler.ColourTo(endLine, SCE_DIFF_HEADER);
+	} else if (0 == strncmp(lineBuffer, "====", 4)) {  // For p4's diff
+		styler.ColourTo(endLine, SCE_DIFF_HEADER);
+	} else if (0 == strncmp(lineBuffer, "***", 3)) {
+		// In a context diff, *** appears in both the header and the position markers.
+		// Also ******** is a chunk header, but here it's treated as part of the
+		// position marker since there is no separate style for a chunk header.
+		if (lineBuffer[3] == ' ' && atoi(lineBuffer+4) && !strchr(lineBuffer, '/'))
+			styler.ColourTo(endLine, SCE_DIFF_POSITION);
+		else if (lineBuffer[3] == '*')
+			styler.ColourTo(endLine, SCE_DIFF_POSITION);
+		else
+			styler.ColourTo(endLine, SCE_DIFF_HEADER);
+	} else if (0 == strncmp(lineBuffer, "? ", 2)) {    // For difflib
+		styler.ColourTo(endLine, SCE_DIFF_HEADER);
+	} else if (lineBuffer[0] == '@') {
+		styler.ColourTo(endLine, SCE_DIFF_POSITION);
+	} else if (lineBuffer[0] >= '0' && lineBuffer[0] <= '9') {
+		styler.ColourTo(endLine, SCE_DIFF_POSITION);
+	} else if (0 == strncmp(lineBuffer, "++", 2)) {
+		styler.ColourTo(endLine, SCE_DIFF_PATCH_ADD);
+	} else if (0 == strncmp(lineBuffer, "+-", 2)) {
+		styler.ColourTo(endLine, SCE_DIFF_PATCH_DELETE);
+	} else if (0 == strncmp(lineBuffer, "-+", 2)) {
+		styler.ColourTo(endLine, SCE_DIFF_REMOVED_PATCH_ADD);
+	} else if (0 == strncmp(lineBuffer, "--", 2)) {
+		styler.ColourTo(endLine, SCE_DIFF_REMOVED_PATCH_DELETE);
+	} else if (lineBuffer[0] == '-' || lineBuffer[0] == '<') {
+		styler.ColourTo(endLine, SCE_DIFF_DELETED);
+	} else if (lineBuffer[0] == '+' || lineBuffer[0] == '>') {
+		styler.ColourTo(endLine, SCE_DIFF_ADDED);
+	} else if (lineBuffer[0] == '!') {
+		styler.ColourTo(endLine, SCE_DIFF_CHANGED);
+	} else if (lineBuffer[0] != ' ') {
+		styler.ColourTo(endLine, SCE_DIFF_COMMENT);
+	} else {
+		styler.ColourTo(endLine, SCE_DIFF_DEFAULT);
+	}
+}
+
+static void ColouriseDiffDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
+	char lineBuffer[DIFF_BUFFER_START_SIZE] = "";
+	styler.StartAt(startPos);
+	styler.StartSegment(startPos);
+	Sci_PositionU linePos = 0;
+	for (Sci_PositionU i = startPos; i < startPos + length; i++) {
+		if (AtEOL(styler, i)) {
+			if (linePos < DIFF_BUFFER_START_SIZE) {
+				lineBuffer[linePos] = 0;
+			}
+			ColouriseDiffLine(lineBuffer, i, styler);
+			linePos = 0;
+		} else if (linePos < DIFF_BUFFER_START_SIZE - 1) {
+			lineBuffer[linePos++] = styler[i];
+		} else if (linePos == DIFF_BUFFER_START_SIZE - 1) {
+			lineBuffer[linePos++] = 0;
+		}
+	}
+	if (linePos > 0) {	// Last line does not have ending characters
+		if (linePos < DIFF_BUFFER_START_SIZE) {
+			lineBuffer[linePos] = 0;
+		}
+		ColouriseDiffLine(lineBuffer, startPos + length - 1, styler);
+	}
+}
+
+static void FoldDiffDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
+	Sci_Position curLine = styler.GetLine(startPos);
+	Sci_Position curLineStart = styler.LineStart(curLine);
+	int prevLevel = curLine > 0 ? styler.LevelAt(curLine - 1) : SC_FOLDLEVELBASE;
+	int nextLevel;
+
+	do {
+		const int lineType = styler.StyleAt(curLineStart);
+		if (lineType == SCE_DIFF_COMMAND)
+			nextLevel = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;
+		else if (lineType == SCE_DIFF_HEADER)
+			nextLevel = (SC_FOLDLEVELBASE + 1) | SC_FOLDLEVELHEADERFLAG;
+		else if (lineType == SCE_DIFF_POSITION && styler[curLineStart] != '-')
+			nextLevel = (SC_FOLDLEVELBASE + 2) | SC_FOLDLEVELHEADERFLAG;
+		else if (prevLevel & SC_FOLDLEVELHEADERFLAG)
+			nextLevel = (prevLevel & SC_FOLDLEVELNUMBERMASK) + 1;
+		else
+			nextLevel = prevLevel;
+
+		if ((nextLevel & SC_FOLDLEVELHEADERFLAG) && (nextLevel == prevLevel))
+			styler.SetLevel(curLine-1, prevLevel & ~SC_FOLDLEVELHEADERFLAG);
+
+		styler.SetLevel(curLine, nextLevel);
+		prevLevel = nextLevel;
+
+		curLineStart = styler.LineStart(++curLine);
+	} while (static_cast<Sci_Position>(startPos)+length > curLineStart);
+}
+
+static const char *const emptyWordListDesc[] = {
+	0
+};
+
+LexerModule lmDiff(SCLEX_DIFF, ColouriseDiffDoc, "diff", FoldDiffDoc, emptyWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexCPP.cxx b/Pythonwin/Scintilla/lexers/LexECL.cxx
similarity index 50%
rename from Pythonwin/Scintilla/src/LexCPP.cxx
rename to Pythonwin/Scintilla/lexers/LexECL.cxx
index c2933f41d..6c916bce4 100644
--- a/Pythonwin/Scintilla/src/LexCPP.cxx
+++ b/Pythonwin/Scintilla/lexers/LexECL.cxx
@@ -1,86 +1,94 @@
 // Scintilla source code edit control
-/** @file LexCPP.cxx
- ** Lexer for C++, C, Java, and JavaScript.
+/** @file LexECL.cxx
+ ** Lexer for ECL.
  **/
-// Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#ifdef _MSC_VER
+#pragma warning(disable: 4786)
+#endif
+#ifdef __BORLANDC__
+// Borland C++ displays warnings in vector header without this
+#pragma option -w-ccc -w-rch
+#endif
 
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include <string>
+#include <vector>
+#include <map>
+#include <algorithm>
+
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
 #include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+
+#define SET_LOWER "abcdefghijklmnopqrstuvwxyz"
+#define SET_UPPER "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+#define SET_DIGITS "0123456789"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static bool IsSpaceEquiv(int state) {
-	return (state <= SCE_C_COMMENTDOC) ||
-		// including SCE_C_DEFAULT, SCE_C_COMMENT, SCE_C_COMMENTLINE
-		(state == SCE_C_COMMENTLINEDOC) || (state == SCE_C_COMMENTDOCKEYWORD) ||
-		(state == SCE_C_COMMENTDOCKEYWORDERROR);
-}
+	switch (state) {
+	case SCE_ECL_DEFAULT:
+	case SCE_ECL_COMMENT:
+	case SCE_ECL_COMMENTLINE:
+	case SCE_ECL_COMMENTLINEDOC:
+	case SCE_ECL_COMMENTDOCKEYWORD:
+	case SCE_ECL_COMMENTDOCKEYWORDERROR:
+	case SCE_ECL_COMMENTDOC:
+		return true;
 
-// Preconditions: sc.currentPos points to a character after '+' or '-'.
-// The test for pos reaching 0 should be redundant,
-// and is in only for safety measures.
-// Limitation: this code will give the incorrect answer for code like
-// a = b+++/ptn/...
-// Putting a space between the '++' post-inc operator and the '+' binary op
-// fixes this, and is highly recommended for readability anyway.
-static bool FollowsPostfixOperator(StyleContext &sc, Accessor &styler) {
-	int pos = (int) sc.currentPos;
-	while (--pos > 0) {
-		char ch = styler[pos];
-		if (ch == '+' || ch == '-') {
-			return styler[pos - 1] == ch;
-		}
+	default:
+		return false;
 	}
-	return false;
 }
 
-static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                            Accessor &styler, bool caseSensitive) {
-
-	WordList &keywords = *keywordlists[0];
-	WordList &keywords2 = *keywordlists[1];
-	WordList &keywords3 = *keywordlists[2];
-	WordList &keywords4 = *keywordlists[3];
+static void ColouriseEclDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+                            Accessor &styler) {
+	WordList &keywords0 = *keywordlists[0];
+	WordList &keywords1 = *keywordlists[1];
+	WordList &keywords2 = *keywordlists[2];
+	WordList &keywords3 = *keywordlists[3]; //Value Types
+	WordList &keywords4 = *keywordlists[4];
+	WordList &keywords5 = *keywordlists[5];
+	WordList &keywords6 = *keywordlists[6];	//Javadoc Tags
+	WordList cplusplus;
+	cplusplus.Set("beginc endc");
 
-	bool stylingWithinPreprocessor = styler.GetPropertyInt("styling.within.preprocessor") != 0;
-
-	CharacterSet setOKBeforeRE(CharacterSet::setNone, "([{=,:;!%^&*|?~+-");
-	CharacterSet setCouldBePostOp(CharacterSet::setNone, "+-");
-
-	CharacterSet setDoxygen(CharacterSet::setAlpha, "$@\\&<>#{}[]");
+	bool stylingWithinPreprocessor = false;
 
+	CharacterSet setOKBeforeRE(CharacterSet::setNone, "(=,");
+	CharacterSet setDoxygen(CharacterSet::setLower, "$@\\&<>#{}[]");
 	CharacterSet setWordStart(CharacterSet::setAlpha, "_", 0x80, true);
 	CharacterSet setWord(CharacterSet::setAlphaNum, "._", 0x80, true);
-	if (styler.GetPropertyInt("lexer.cpp.allow.dollars", 1) != 0) {
-		setWordStart.Add('$');
-		setWord.Add('$');
-	}
+	CharacterSet setQualified(CharacterSet::setNone, "uUxX");
 
 	int chPrevNonWhite = ' ';
 	int visibleChars = 0;
 	bool lastWordWasUUID = false;
-	int styleBeforeDCKeyword = SCE_C_DEFAULT;
+	int styleBeforeDCKeyword = SCE_ECL_DEFAULT;
 	bool continuationLine = false;
 
-	if (initStyle == SCE_C_PREPROCESSOR) {
+	if (initStyle == SCE_ECL_PREPROCESSOR) {
 		// Set continuationLine if last character of previous line is '\'
-		int lineCurrent = styler.GetLine(startPos);
+		Sci_Position lineCurrent = styler.GetLine(startPos);
 		if (lineCurrent > 0) {
 			int chBack = styler.SafeGetCharAt(startPos-1, 0);
 			int chBack2 = styler.SafeGetCharAt(startPos-2, 0);
@@ -96,10 +104,10 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 
 	// look back to set chPrevNonWhite properly for better regex colouring
 	if (startPos > 0) {
-		int back = startPos;
+		Sci_Position back = startPos;
 		while (--back && IsSpaceEquiv(styler.StyleAt(back)))
 			;
-		if (styler.StyleAt(back) == SCE_C_OPERATOR) {
+		if (styler.StyleAt(back) == SCE_ECL_OPERATOR) {
 			chPrevNonWhite = styler.SafeGetCharAt(back);
 		}
 	}
@@ -107,12 +115,11 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 	StyleContext sc(startPos, length, initStyle, styler);
 
 	for (; sc.More(); sc.Forward()) {
-
 		if (sc.atLineStart) {
-			if (sc.state == SCE_C_STRING) {
-				// Prevent SCE_C_STRINGEOL from leaking back to previous line which
+			if (sc.state == SCE_ECL_STRING) {
+				// Prevent SCE_ECL_STRINGEOL from leaking back to previous line which
 				// ends with a line continuation by locking in the state upto this position.
-				sc.SetState(SCE_C_STRING);
+				sc.SetState(SCE_ECL_STRING);
 			}
 			// Reset states to begining of colourise so no surprises
 			// if different sets of lines lexed.
@@ -134,129 +141,145 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 
 		// Determine if the current state should terminate.
 		switch (sc.state) {
-			case SCE_C_OPERATOR:
-				sc.SetState(SCE_C_DEFAULT);
+			case SCE_ECL_ADDED:
+			case SCE_ECL_DELETED:
+			case SCE_ECL_CHANGED:
+			case SCE_ECL_MOVED:
+			if (sc.atLineStart)
+					sc.SetState(SCE_ECL_DEFAULT);
+				break;
+			case SCE_ECL_OPERATOR:
+				sc.SetState(SCE_ECL_DEFAULT);
 				break;
-			case SCE_C_NUMBER:
+			case SCE_ECL_NUMBER:
 				// We accept almost anything because of hex. and number suffixes
 				if (!setWord.Contains(sc.ch)) {
-					sc.SetState(SCE_C_DEFAULT);
+					sc.SetState(SCE_ECL_DEFAULT);
 				}
 				break;
-			case SCE_C_IDENTIFIER:
+			case SCE_ECL_IDENTIFIER:
 				if (!setWord.Contains(sc.ch) || (sc.ch == '.')) {
 					char s[1000];
-					if (caseSensitive) {
-						sc.GetCurrent(s, sizeof(s));
-					} else {
-						sc.GetCurrentLowered(s, sizeof(s));
-					}
-					if (keywords.InList(s)) {
+					sc.GetCurrentLowered(s, sizeof(s));
+					if (keywords0.InList(s)) {
 						lastWordWasUUID = strcmp(s, "uuid") == 0;
-						sc.ChangeState(SCE_C_WORD);
+						sc.ChangeState(SCE_ECL_WORD0);
+					} else if (keywords1.InList(s)) {
+						sc.ChangeState(SCE_ECL_WORD1);
 					} else if (keywords2.InList(s)) {
-						sc.ChangeState(SCE_C_WORD2);
+						sc.ChangeState(SCE_ECL_WORD2);
 					} else if (keywords4.InList(s)) {
-						sc.ChangeState(SCE_C_GLOBALCLASS);
+						sc.ChangeState(SCE_ECL_WORD4);
+					} else if (keywords5.InList(s)) {
+						sc.ChangeState(SCE_ECL_WORD5);
+					}
+					else	//Data types are of from KEYWORD##
+					{
+						int i = static_cast<int>(strlen(s)) - 1;
+						while(i >= 0 && (isdigit(s[i]) || s[i] == '_'))
+							--i;
+
+						char s2[1000];
+						strncpy(s2, s, i + 1);
+						s2[i + 1] = 0;
+						if (keywords3.InList(s2)) {
+							sc.ChangeState(SCE_ECL_WORD3);
+						}
 					}
-					sc.SetState(SCE_C_DEFAULT);
+					sc.SetState(SCE_ECL_DEFAULT);
 				}
 				break;
-			case SCE_C_PREPROCESSOR:
+			case SCE_ECL_PREPROCESSOR:
 				if (sc.atLineStart && !continuationLine) {
-					sc.SetState(SCE_C_DEFAULT);
+					sc.SetState(SCE_ECL_DEFAULT);
 				} else if (stylingWithinPreprocessor) {
 					if (IsASpace(sc.ch)) {
-						sc.SetState(SCE_C_DEFAULT);
+						sc.SetState(SCE_ECL_DEFAULT);
 					}
 				} else {
 					if (sc.Match('/', '*') || sc.Match('/', '/')) {
-						sc.SetState(SCE_C_DEFAULT);
+						sc.SetState(SCE_ECL_DEFAULT);
 					}
 				}
 				break;
-			case SCE_C_COMMENT:
+			case SCE_ECL_COMMENT:
 				if (sc.Match('*', '/')) {
 					sc.Forward();
-					sc.ForwardSetState(SCE_C_DEFAULT);
+					sc.ForwardSetState(SCE_ECL_DEFAULT);
 				}
 				break;
-			case SCE_C_COMMENTDOC:
+			case SCE_ECL_COMMENTDOC:
 				if (sc.Match('*', '/')) {
 					sc.Forward();
-					sc.ForwardSetState(SCE_C_DEFAULT);
+					sc.ForwardSetState(SCE_ECL_DEFAULT);
 				} else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support
 					// Verify that we have the conditions to mark a comment-doc-keyword
 					if ((IsASpace(sc.chPrev) || sc.chPrev == '*') && (!IsASpace(sc.chNext))) {
-						styleBeforeDCKeyword = SCE_C_COMMENTDOC;
-						sc.SetState(SCE_C_COMMENTDOCKEYWORD);
+						styleBeforeDCKeyword = SCE_ECL_COMMENTDOC;
+						sc.SetState(SCE_ECL_COMMENTDOCKEYWORD);
 					}
 				}
 				break;
-			case SCE_C_COMMENTLINE:
+			case SCE_ECL_COMMENTLINE:
 				if (sc.atLineStart) {
-					sc.SetState(SCE_C_DEFAULT);
+					sc.SetState(SCE_ECL_DEFAULT);
 				}
 				break;
-			case SCE_C_COMMENTLINEDOC:
+			case SCE_ECL_COMMENTLINEDOC:
 				if (sc.atLineStart) {
-					sc.SetState(SCE_C_DEFAULT);
+					sc.SetState(SCE_ECL_DEFAULT);
 				} else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support
 					// Verify that we have the conditions to mark a comment-doc-keyword
 					if ((IsASpace(sc.chPrev) || sc.chPrev == '/' || sc.chPrev == '!') && (!IsASpace(sc.chNext))) {
-						styleBeforeDCKeyword = SCE_C_COMMENTLINEDOC;
-						sc.SetState(SCE_C_COMMENTDOCKEYWORD);
+						styleBeforeDCKeyword = SCE_ECL_COMMENTLINEDOC;
+						sc.SetState(SCE_ECL_COMMENTDOCKEYWORD);
 					}
 				}
 				break;
-			case SCE_C_COMMENTDOCKEYWORD:
-				if ((styleBeforeDCKeyword == SCE_C_COMMENTDOC) && sc.Match('*', '/')) {
-					sc.ChangeState(SCE_C_COMMENTDOCKEYWORDERROR);
+			case SCE_ECL_COMMENTDOCKEYWORD:
+				if ((styleBeforeDCKeyword == SCE_ECL_COMMENTDOC) && sc.Match('*', '/')) {
+					sc.ChangeState(SCE_ECL_COMMENTDOCKEYWORDERROR);
 					sc.Forward();
-					sc.ForwardSetState(SCE_C_DEFAULT);
+					sc.ForwardSetState(SCE_ECL_DEFAULT);
 				} else if (!setDoxygen.Contains(sc.ch)) {
-					char s[100];
-					if (caseSensitive) {
-						sc.GetCurrent(s, sizeof(s));
-					} else {
-						sc.GetCurrentLowered(s, sizeof(s));
-					}
-					if (!IsASpace(sc.ch) || !keywords3.InList(s + 1)) {
-						sc.ChangeState(SCE_C_COMMENTDOCKEYWORDERROR);
+					char s[1000];
+					sc.GetCurrentLowered(s, sizeof(s));
+					if (!IsASpace(sc.ch) || !keywords6.InList(s+1)) {
+						sc.ChangeState(SCE_ECL_COMMENTDOCKEYWORDERROR);
 					}
 					sc.SetState(styleBeforeDCKeyword);
 				}
 				break;
-			case SCE_C_STRING:
+			case SCE_ECL_STRING:
 				if (sc.atLineEnd) {
-					sc.ChangeState(SCE_C_STRINGEOL);
+					sc.ChangeState(SCE_ECL_STRINGEOL);
 				} else if (sc.ch == '\\') {
 					if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
 						sc.Forward();
 					}
 				} else if (sc.ch == '\"') {
-					sc.ForwardSetState(SCE_C_DEFAULT);
+					sc.ForwardSetState(SCE_ECL_DEFAULT);
 				}
 				break;
-			case SCE_C_CHARACTER:
+			case SCE_ECL_CHARACTER:
 				if (sc.atLineEnd) {
-					sc.ChangeState(SCE_C_STRINGEOL);
+					sc.ChangeState(SCE_ECL_STRINGEOL);
 				} else if (sc.ch == '\\') {
 					if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
 						sc.Forward();
 					}
 				} else if (sc.ch == '\'') {
-					sc.ForwardSetState(SCE_C_DEFAULT);
+					sc.ForwardSetState(SCE_ECL_DEFAULT);
 				}
 				break;
-			case SCE_C_REGEX:
+			case SCE_ECL_REGEX:
 				if (sc.atLineStart) {
-					sc.SetState(SCE_C_DEFAULT);
+					sc.SetState(SCE_ECL_DEFAULT);
 				} else if (sc.ch == '/') {
 					sc.Forward();
 					while ((sc.ch < 0x80) && islower(sc.ch))
 						sc.Forward();    // gobble regex flags
-					sc.SetState(SCE_C_DEFAULT);
+					sc.SetState(SCE_ECL_DEFAULT);
 				} else if (sc.ch == '\\') {
 					// Gobble up the quoted character
 					if (sc.chNext == '\\' || sc.chNext == '/') {
@@ -264,77 +287,85 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 					}
 				}
 				break;
-			case SCE_C_STRINGEOL:
+			case SCE_ECL_STRINGEOL:
 				if (sc.atLineStart) {
-					sc.SetState(SCE_C_DEFAULT);
+					sc.SetState(SCE_ECL_DEFAULT);
 				}
 				break;
-			case SCE_C_VERBATIM:
+			case SCE_ECL_VERBATIM:
 				if (sc.ch == '\"') {
 					if (sc.chNext == '\"') {
 						sc.Forward();
 					} else {
-						sc.ForwardSetState(SCE_C_DEFAULT);
+						sc.ForwardSetState(SCE_ECL_DEFAULT);
 					}
 				}
 				break;
-			case SCE_C_UUID:
+			case SCE_ECL_UUID:
 				if (sc.ch == '\r' || sc.ch == '\n' || sc.ch == ')') {
-					sc.SetState(SCE_C_DEFAULT);
+					sc.SetState(SCE_ECL_DEFAULT);
 				}
+				break;
 		}
 
 		// Determine if a new state should be entered.
-		if (sc.state == SCE_C_DEFAULT) {
-			if (sc.Match('@', '\"')) {
-				sc.SetState(SCE_C_VERBATIM);
+		Sci_Position lineCurrent = styler.GetLine(sc.currentPos);
+		int lineState = styler.GetLineState(lineCurrent);
+		if (sc.state == SCE_ECL_DEFAULT) {
+			if (lineState) {
+				sc.SetState(lineState);
+			}
+			else if (sc.Match('@', '\"')) {
+				sc.SetState(SCE_ECL_VERBATIM);
+				sc.Forward();
+			} else if (setQualified.Contains(sc.ch) && sc.chNext == '\'') {
+				sc.SetState(SCE_ECL_CHARACTER);
 				sc.Forward();
 			} else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
 				if (lastWordWasUUID) {
-					sc.SetState(SCE_C_UUID);
+					sc.SetState(SCE_ECL_UUID);
 					lastWordWasUUID = false;
 				} else {
-					sc.SetState(SCE_C_NUMBER);
+					sc.SetState(SCE_ECL_NUMBER);
 				}
 			} else if (setWordStart.Contains(sc.ch) || (sc.ch == '@')) {
 				if (lastWordWasUUID) {
-					sc.SetState(SCE_C_UUID);
+					sc.SetState(SCE_ECL_UUID);
 					lastWordWasUUID = false;
 				} else {
-					sc.SetState(SCE_C_IDENTIFIER);
+					sc.SetState(SCE_ECL_IDENTIFIER);
 				}
 			} else if (sc.Match('/', '*')) {
 				if (sc.Match("/**") || sc.Match("/*!")) {	// Support of Qt/Doxygen doc. style
-					sc.SetState(SCE_C_COMMENTDOC);
+					sc.SetState(SCE_ECL_COMMENTDOC);
 				} else {
-					sc.SetState(SCE_C_COMMENT);
+					sc.SetState(SCE_ECL_COMMENT);
 				}
 				sc.Forward();	// Eat the * so it isn't used for the end of the comment
 			} else if (sc.Match('/', '/')) {
 				if ((sc.Match("///") && !sc.Match("////")) || sc.Match("//!"))
 					// Support of Qt/Doxygen doc. style
-					sc.SetState(SCE_C_COMMENTLINEDOC);
+					sc.SetState(SCE_ECL_COMMENTLINEDOC);
 				else
-					sc.SetState(SCE_C_COMMENTLINE);
-			} else if (sc.ch == '/' && setOKBeforeRE.Contains(chPrevNonWhite) &&
-				(!setCouldBePostOp.Contains(chPrevNonWhite) || !FollowsPostfixOperator(sc, styler))) {
-				sc.SetState(SCE_C_REGEX);	// JavaScript's RegEx
-			} else if (sc.ch == '\"') {
-				sc.SetState(SCE_C_STRING);
+					sc.SetState(SCE_ECL_COMMENTLINE);
+			} else if (sc.ch == '/' && setOKBeforeRE.Contains(chPrevNonWhite)) {
+				sc.SetState(SCE_ECL_REGEX);	// JavaScript's RegEx
+//			} else if (sc.ch == '\"') {
+//				sc.SetState(SCE_ECL_STRING);
 			} else if (sc.ch == '\'') {
-				sc.SetState(SCE_C_CHARACTER);
+				sc.SetState(SCE_ECL_CHARACTER);
 			} else if (sc.ch == '#' && visibleChars == 0) {
 				// Preprocessor commands are alone on their line
-				sc.SetState(SCE_C_PREPROCESSOR);
+				sc.SetState(SCE_ECL_PREPROCESSOR);
 				// Skip whitespace between # and preprocessor word
 				do {
 					sc.Forward();
 				} while ((sc.ch == ' ' || sc.ch == '\t') && sc.More());
 				if (sc.atLineEnd) {
-					sc.SetState(SCE_C_DEFAULT);
+					sc.SetState(SCE_ECL_DEFAULT);
 				}
 			} else if (isoperator(static_cast<char>(sc.ch))) {
-				sc.SetState(SCE_C_OPERATOR);
+				sc.SetState(SCE_ECL_OPERATOR);
 			}
 		}
 
@@ -345,27 +376,42 @@ static void ColouriseCppDoc(unsigned int startPos, int length, int initStyle, Wo
 		continuationLine = false;
 	}
 	sc.Complete();
+
 }
 
 static bool IsStreamCommentStyle(int style) {
-	return style == SCE_C_COMMENT ||
-		style == SCE_C_COMMENTDOC ||
-		style == SCE_C_COMMENTDOCKEYWORD ||
-		style == SCE_C_COMMENTDOCKEYWORDERROR;
+	return style == SCE_ECL_COMMENT ||
+		style == SCE_ECL_COMMENTDOC ||
+		style == SCE_ECL_COMMENTDOCKEYWORD ||
+		style == SCE_ECL_COMMENTDOCKEYWORDERROR;
+}
+
+static bool MatchNoCase(Accessor & styler, Sci_PositionU & pos, const char *s) {
+	Sci_Position i=0;
+	for (; *s; i++) {
+		char compare_char = tolower(*s);
+		char styler_char = tolower(styler.SafeGetCharAt(pos+i));
+		if (compare_char != styler_char)
+			return false;
+		s++;
+	}
+	pos+=i-1;
+	return true;
 }
 
+
 // Store both the current line's fold level and the next lines in the
 // level store to make it easy to pick up with each increment
 // and to make it possible to fiddle the current level for "} else {".
-static void FoldCppDoc(unsigned int startPos, int length, int initStyle,
+static void FoldEclDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
 					   WordList *[], Accessor &styler) {
-	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
-	bool foldPreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0;
-	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0;
-	unsigned int endPos = startPos + length;
+	bool foldComment = true;
+	bool foldPreprocessor = true;
+	bool foldCompact = true;
+	bool foldAtElse = true;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelCurrent = SC_FOLDLEVELBASE;
 	if (lineCurrent > 0)
 		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
@@ -374,7 +420,7 @@ static void FoldCppDoc(unsigned int startPos, int length, int initStyle,
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
 	int style = initStyle;
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int stylePrev = style;
@@ -382,14 +428,14 @@ static void FoldCppDoc(unsigned int startPos, int length, int initStyle,
 		styleNext = styler.StyleAt(i + 1);
 		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
 		if (foldComment && IsStreamCommentStyle(style)) {
-			if (!IsStreamCommentStyle(stylePrev) && (stylePrev != SCE_C_COMMENTLINEDOC)) {
+			if (!IsStreamCommentStyle(stylePrev) && (stylePrev != SCE_ECL_COMMENTLINEDOC)) {
 				levelNext++;
-			} else if (!IsStreamCommentStyle(styleNext) && (styleNext != SCE_C_COMMENTLINEDOC) && !atEOL) {
+			} else if (!IsStreamCommentStyle(styleNext) && (styleNext != SCE_ECL_COMMENTLINEDOC) && !atEOL) {
 				// Comments don't end at end of line and the next character may be unstyled.
 				levelNext--;
 			}
 		}
-		if (foldComment && (style == SCE_C_COMMENTLINE)) {
+		if (foldComment && (style == SCE_ECL_COMMENTLINE)) {
 			if ((ch == '/') && (chNext == '/')) {
 				char chNext2 = styler.SafeGetCharAt(i + 2);
 				if (chNext2 == '{') {
@@ -399,20 +445,20 @@ static void FoldCppDoc(unsigned int startPos, int length, int initStyle,
 				}
 			}
 		}
-		if (foldPreprocessor && (style == SCE_C_PREPROCESSOR)) {
+		if (foldPreprocessor && (style == SCE_ECL_PREPROCESSOR)) {
 			if (ch == '#') {
-				unsigned int j = i + 1;
+				Sci_PositionU j = i + 1;
 				while ((j < endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
 					j++;
 				}
-				if (styler.Match(j, "region") || styler.Match(j, "if")) {
+				if (MatchNoCase(styler, j, "region") || MatchNoCase(styler, j, "if")) {
 					levelNext++;
-				} else if (styler.Match(j, "end")) {
+				} else if (MatchNoCase(styler, j, "endregion") || MatchNoCase(styler, j, "end")) {
 					levelNext--;
 				}
 			}
 		}
-		if (style == SCE_C_OPERATOR) {
+		if (style == SCE_ECL_OPERATOR) {
 			if (ch == '{') {
 				// Measure the minimum before a '{' to allow
 				// folding on "} else {"
@@ -424,8 +470,15 @@ static void FoldCppDoc(unsigned int startPos, int length, int initStyle,
 				levelNext--;
 			}
 		}
-		if (!IsASpace(ch))
-			visibleChars++;
+		if (style == SCE_ECL_WORD2) {
+			if (MatchNoCase(styler, i, "record") || MatchNoCase(styler, i, "transform") || MatchNoCase(styler, i, "type") || MatchNoCase(styler, i, "function") ||
+				MatchNoCase(styler, i, "module") || MatchNoCase(styler, i, "service") || MatchNoCase(styler, i, "interface") || MatchNoCase(styler, i, "ifblock") ||
+				MatchNoCase(styler, i, "macro") || MatchNoCase(styler, i, "beginc++")) {
+				levelNext++;
+			} else if (MatchNoCase(styler, i, "endmacro") || MatchNoCase(styler, i, "endc++") || MatchNoCase(styler, i, "end")) {
+				levelNext--;
+			}
+		}
 		if (atEOL || (i == endPos-1)) {
 			int levelUse = levelCurrent;
 			if (foldAtElse) {
@@ -442,29 +495,25 @@ static void FoldCppDoc(unsigned int startPos, int length, int initStyle,
 			lineCurrent++;
 			levelCurrent = levelNext;
 			levelMinCurrent = levelCurrent;
+			if (atEOL && (i == static_cast<Sci_PositionU>(styler.Length()-1))) {
+				// There is an empty line at end of file so give it same level and empty
+				styler.SetLevel(lineCurrent, (levelCurrent | levelCurrent << 16) | SC_FOLDLEVELWHITEFLAG);
+			}
 			visibleChars = 0;
 		}
+		if (!IsASpace(ch))
+			visibleChars++;
 	}
 }
 
-static const char * const cppWordLists[] = {
-            "Primary keywords and identifiers",
-            "Secondary keywords and identifiers",
-            "Documentation comment keywords",
-            "Unused",
-            "Global classes and typedefs",
-            0,
-        };
-
-static void ColouriseCppDocSensitive(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                                     Accessor &styler) {
-	ColouriseCppDoc(startPos, length, initStyle, keywordlists, styler, true);
-}
-
-static void ColouriseCppDocInsensitive(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                                       Accessor &styler) {
-	ColouriseCppDoc(startPos, length, initStyle, keywordlists, styler, false);
-}
+static const char * const EclWordListDesc[] = {
+	"Keywords",
+	0
+};
 
-LexerModule lmCPP(SCLEX_CPP, ColouriseCppDocSensitive, "cpp", FoldCppDoc, cppWordLists);
-LexerModule lmCPPNoCase(SCLEX_CPPNOCASE, ColouriseCppDocInsensitive, "cppnocase", FoldCppDoc, cppWordLists);
+LexerModule lmECL(
+   SCLEX_ECL,
+   ColouriseEclDoc,
+   "ecl",
+   FoldEclDoc,
+   EclWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexEDIFACT.cxx b/Pythonwin/Scintilla/lexers/LexEDIFACT.cxx
new file mode 100644
index 000000000..3623807a4
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexEDIFACT.cxx
@@ -0,0 +1,403 @@
+// Scintilla Lexer for EDIFACT
+// @file LexEDIFACT.cxx
+// Written by Iain Clarke, IMCSoft & Inobiz AB.
+// EDIFACT documented here: https://www.unece.org/cefact/edifact/welcome.html
+// and more readably here: https://en.wikipedia.org/wiki/EDIFACT
+// This code is subject to the same license terms as the rest of the scintilla project:
+// The License.txt file describes the conditions under which this software may be distributed.
+//
+
+// Header order must match order in scripts/HeaderOrder.txt
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cctype>
+
+#include <string>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "LexAccessor.h"
+#include "LexerModule.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+class LexerEDIFACT : public DefaultLexer
+{
+public:
+	LexerEDIFACT();
+	virtual ~LexerEDIFACT() {} // virtual destructor, as we inherit from ILexer
+
+	static ILexer5 *Factory() {
+		return new LexerEDIFACT;
+	}
+
+	int SCI_METHOD Version() const override
+	{
+		return lvRelease5;
+	}
+	void SCI_METHOD Release() override
+	{
+		delete this;
+	}
+
+	const char * SCI_METHOD PropertyNames() override
+	{
+		return "fold\nlexer.edifact.highlight.un.all";
+	}
+	int SCI_METHOD PropertyType(const char *) override
+	{
+		return SC_TYPE_BOOLEAN; // Only one property!
+	}
+	const char * SCI_METHOD DescribeProperty(const char *name) override
+	{
+		if (!strcmp(name, "fold"))
+			return "Whether to apply folding to document or not";
+		if (!strcmp(name, "lexer.edifact.highlight.un.all"))
+			return "Whether to apply UN* highlighting to all UN segments, or just to UNH";
+		return NULL;
+	}
+
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override
+	{
+		if (!strcmp(key, "fold"))
+		{
+			m_bFold = strcmp(val, "0") ? true : false;
+			return 0;
+		}
+		if (!strcmp(key, "lexer.edifact.highlight.un.all"))	// GetProperty
+		{
+			m_bHighlightAllUN = strcmp(val, "0") ? true : false;
+			return 0;
+		}
+		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;
+	}
+	Sci_Position SCI_METHOD WordListSet(int, const char *) override
+	{
+		return -1;
+	}
+	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 *) override
+	{
+		return NULL;
+	}
+
+protected:
+	Sci_Position InitialiseFromUNA(IDocument *pAccess, Sci_PositionU MaxLength);
+	Sci_Position FindPreviousEnd(IDocument *pAccess, Sci_Position startPos) const;
+	Sci_Position ForwardPastWhitespace(IDocument *pAccess, Sci_Position startPos, Sci_Position MaxLength) const;
+	int DetectSegmentHeader(char SegmentHeader[3]) const;
+
+	bool m_bFold;
+
+	// property lexer.edifact.highlight.un.all
+	//	Set to 0 to highlight only UNA segments, or 1 to highlight all UNx segments.
+	bool m_bHighlightAllUN;
+
+	char m_chComponent;
+	char m_chData;
+	char m_chDecimal;
+	char m_chRelease;
+	char m_chSegment;
+
+	std::string m_lastPropertyValue;
+};
+
+LexerModule lmEDIFACT(SCLEX_EDIFACT, LexerEDIFACT::Factory, "edifact");
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+LexerEDIFACT::LexerEDIFACT() : DefaultLexer("edifact", SCLEX_EDIFACT)
+{
+	m_bFold = false;
+	m_bHighlightAllUN = false;
+	m_chComponent = ':';
+	m_chData = '+';
+	m_chDecimal = '.';
+	m_chRelease = '?';
+	m_chSegment = '\'';
+}
+
+void LexerEDIFACT::Lex(Sci_PositionU startPos, Sci_Position length, int, IDocument *pAccess)
+{
+	Sci_PositionU posFinish = startPos + length;
+	InitialiseFromUNA(pAccess, posFinish);
+
+	// Look backwards for a ' or a document beginning
+	Sci_PositionU posCurrent = FindPreviousEnd(pAccess, startPos);
+	// And jump past the ' if this was not the beginning of the document
+	if (posCurrent != 0)
+		posCurrent++;
+
+	// Style buffer, so we're not issuing loads of notifications
+	LexAccessor styler (pAccess);
+	pAccess->StartStyling(posCurrent);
+	styler.StartSegment(posCurrent);
+	Sci_Position posSegmentStart = -1;
+
+	while ((posCurrent < posFinish) && (posSegmentStart == -1))
+	{
+		posCurrent = ForwardPastWhitespace(pAccess, posCurrent, posFinish);
+		// Mark whitespace as default
+		styler.ColourTo(posCurrent - 1, SCE_EDI_DEFAULT);
+		if (posCurrent >= posFinish)
+			break;
+
+		// Does is start with 3 charaters? ie, UNH
+		char SegmentHeader[4] = { 0 };
+		pAccess->GetCharRange(SegmentHeader, posCurrent, 3);
+
+		int SegmentStyle = DetectSegmentHeader(SegmentHeader);
+		if (SegmentStyle == SCE_EDI_BADSEGMENT)
+			break;
+		if (SegmentStyle == SCE_EDI_UNA)
+		{
+			posCurrent += 9;
+			styler.ColourTo(posCurrent - 1, SCE_EDI_UNA); // UNA
+			continue;
+		}
+		posSegmentStart = posCurrent;
+		posCurrent += 3;
+
+		styler.ColourTo(posCurrent - 1, SegmentStyle); // UNH etc
+
+		// Colour in the rest of the segment
+		for (char c; posCurrent < posFinish; posCurrent++)
+		{
+			pAccess->GetCharRange(&c, posCurrent, 1);
+
+			if (c == m_chRelease) // ? escape character, check first, in case of ?'
+				posCurrent++;
+			else if (c == m_chSegment) // '
+			{
+				// Make sure the whole segment is on one line. styler won't let us go back in time, so we'll settle for marking the ' as bad.
+				Sci_Position lineSegmentStart = pAccess->LineFromPosition(posSegmentStart);
+				Sci_Position lineSegmentEnd = pAccess->LineFromPosition(posCurrent);
+				if (lineSegmentStart == lineSegmentEnd)
+					styler.ColourTo(posCurrent, SCE_EDI_SEGMENTEND);
+				else
+					styler.ColourTo(posCurrent, SCE_EDI_BADSEGMENT);
+				posSegmentStart = -1;
+				posCurrent++;
+				break;
+			}
+			else if (c == m_chComponent) // :
+				styler.ColourTo(posCurrent, SCE_EDI_SEP_COMPOSITE);
+			else if (c == m_chData) // +
+				styler.ColourTo(posCurrent, SCE_EDI_SEP_ELEMENT);
+			else
+				styler.ColourTo(posCurrent, SCE_EDI_DEFAULT);
+		}
+	}
+	styler.Flush();
+
+	if (posSegmentStart == -1)
+		return;
+
+	pAccess->StartStyling(posSegmentStart);
+	pAccess->SetStyleFor(posFinish - posSegmentStart, SCE_EDI_BADSEGMENT);
+}
+
+void LexerEDIFACT::Fold(Sci_PositionU startPos, Sci_Position length, int, IDocument *pAccess)
+{
+	if (!m_bFold)
+		return;
+
+	Sci_PositionU endPos = startPos + length;
+	startPos = FindPreviousEnd(pAccess, startPos);
+	char c;
+	char SegmentHeader[4] = { 0 };
+
+	bool AwaitingSegment = true;
+	Sci_PositionU currLine = pAccess->LineFromPosition(startPos);
+	int levelCurrentStyle = SC_FOLDLEVELBASE;
+	if (currLine > 0)
+		levelCurrentStyle = pAccess->GetLevel(currLine - 1); // bottom 12 bits are level
+	int indentCurrent = levelCurrentStyle & SC_FOLDLEVELNUMBERMASK;
+	int indentNext = indentCurrent;
+
+	while (startPos < endPos)
+	{
+		pAccess->GetCharRange(&c, startPos, 1);
+		switch (c)
+		{
+		case '\t':
+		case '\r':
+		case ' ':
+			startPos++;
+			continue;
+		case '\n':
+			currLine = pAccess->LineFromPosition(startPos);
+			pAccess->SetLevel(currLine, levelCurrentStyle | indentCurrent);
+			startPos++;
+			levelCurrentStyle = SC_FOLDLEVELBASE;
+			indentCurrent = indentNext;
+			continue;
+		}
+		if (c == m_chRelease)
+		{
+			startPos += 2;
+			continue;
+		}
+		if (c == m_chSegment)
+		{
+			AwaitingSegment = true;
+			startPos++;
+			continue;
+		}
+
+		if (!AwaitingSegment)
+		{
+			startPos++;
+			continue;
+		}
+		
+		// Segment!
+		pAccess->GetCharRange(SegmentHeader, startPos, 3);
+		if (SegmentHeader[0] != 'U' || SegmentHeader[1] != 'N')
+		{
+			startPos++;
+			continue;
+		}
+
+		AwaitingSegment = false;
+		switch (SegmentHeader[2])
+		{
+		case 'H':
+		case 'G':
+			indentNext++;
+			levelCurrentStyle = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;
+			break;
+
+		case 'T':
+		case 'E':
+			if (indentNext > 0)
+				indentNext--;
+			break;
+		}
+
+		startPos += 3;
+	}
+}
+
+Sci_Position LexerEDIFACT::InitialiseFromUNA(IDocument *pAccess, Sci_PositionU MaxLength)
+{
+	MaxLength -= 9; // drop 9 chars, to give us room for UNA:+.? '
+
+	Sci_PositionU startPos = 0;
+	startPos += ForwardPastWhitespace(pAccess, 0, MaxLength);
+	if (startPos < MaxLength)
+	{
+		char bufUNA[9];
+		pAccess->GetCharRange(bufUNA, startPos, 9);
+
+		// Check it's UNA segment
+		if (!memcmp(bufUNA, "UNA", 3))
+		{
+			m_chComponent = bufUNA[3];
+			m_chData = bufUNA[4];
+			m_chDecimal = bufUNA[5];
+			m_chRelease = bufUNA[6];
+			// bufUNA [7] should be space - reserved.
+			m_chSegment = bufUNA[8];
+
+			return 0; // success!
+		}
+	}
+
+	// We failed to find a UNA, so drop to defaults
+	m_chComponent = ':';
+	m_chData = '+';
+	m_chDecimal = '.';
+	m_chRelease = '?';
+	m_chSegment = '\'';
+
+	return -1;
+}
+
+Sci_Position LexerEDIFACT::ForwardPastWhitespace(IDocument *pAccess, Sci_Position startPos, Sci_Position MaxLength) const
+{
+	char c;
+
+	while (startPos < MaxLength)
+	{
+		pAccess->GetCharRange(&c, startPos, 1);
+		switch (c)
+		{
+		case '\t':
+		case '\r':
+		case '\n':
+		case ' ':
+			break;
+		default:
+			return startPos;
+		}
+
+		startPos++;
+	}
+
+	return MaxLength;
+}
+
+int LexerEDIFACT::DetectSegmentHeader(char SegmentHeader[3]) const
+{
+	if (
+		SegmentHeader[0] < 'A' || SegmentHeader[0] > 'Z' ||
+		SegmentHeader[1] < 'A' || SegmentHeader[1] > 'Z' ||
+		SegmentHeader[2] < 'A' || SegmentHeader[2] > 'Z')
+		return SCE_EDI_BADSEGMENT;
+
+	if (!memcmp(SegmentHeader, "UNA", 3))
+		return SCE_EDI_UNA;
+
+	if (m_bHighlightAllUN && !memcmp(SegmentHeader, "UN", 2))
+		return SCE_EDI_UNH;
+	else if (!memcmp(SegmentHeader, "UNH", 3))
+		return SCE_EDI_UNH;
+	else if (!memcmp(SegmentHeader, "UNG", 3))
+		return SCE_EDI_UNH;
+
+	return SCE_EDI_SEGMENTSTART;
+}
+
+// Look backwards for a ' or a document beginning
+Sci_Position LexerEDIFACT::FindPreviousEnd(IDocument *pAccess, Sci_Position startPos) const
+{
+	for (char c; startPos > 0; startPos--)
+	{
+		pAccess->GetCharRange(&c, startPos, 1);
+		if (c == m_chSegment)
+			return startPos;
+	}
+	// We didn't find a ', so just go with the beginning
+	return 0;
+}
+
+
diff --git a/Pythonwin/Scintilla/src/LexEScript.cxx b/Pythonwin/Scintilla/lexers/LexEScript.cxx
similarity index 92%
rename from Pythonwin/Scintilla/src/LexEScript.cxx
rename to Pythonwin/Scintilla/lexers/LexEScript.cxx
index 295aaec53..79f99aedd 100644
--- a/Pythonwin/Scintilla/src/LexEScript.cxx
+++ b/Pythonwin/Scintilla/lexers/LexEScript.cxx
@@ -1,27 +1,28 @@
 // Scintilla source code edit control
-/** @file LexESCRIPT.cxx
+/** @file LexEScript.cxx
  ** Lexer for ESCRIPT
  **/
 // Copyright 2003 by Patrizio Bekerle (patrizio@bekerle.com)
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 
 static inline bool IsAWordChar(const int ch) {
@@ -34,7 +35,7 @@ static inline bool IsAWordStart(const int ch) {
 
 
 
-static void ColouriseESCRIPTDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
+static void ColouriseESCRIPTDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
                             Accessor &styler) {
 
 	WordList &keywords = *keywordlists[0];
@@ -173,24 +174,24 @@ static bool IsStreamCommentStyle(int style) {
 	       style == SCE_ESCRIPT_COMMENTLINE;
 }
 
-static void FoldESCRIPTDoc(unsigned int startPos, int length, int initStyle, WordList *[], Accessor &styler) {
+static void FoldESCRIPTDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[], Accessor &styler) {
 	//~ bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
 	// Do not know how to fold the comment at the moment.
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
         bool foldComment = true;
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
 	int style = initStyle;
 
-	int lastStart = 0;
+	Sci_Position lastStart = 0;
 	char prevWord[32] = "";
 
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int stylePrev = style;
@@ -198,7 +199,7 @@ static void FoldESCRIPTDoc(unsigned int startPos, int length, int initStyle, Wor
 		styleNext = styler.StyleAt(i + 1);
 		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
 
-            
+
 		if (foldComment && IsStreamCommentStyle(style)) {
 			if (!IsStreamCommentStyle(stylePrev)) {
 				levelCurrent++;
@@ -228,7 +229,7 @@ static void FoldESCRIPTDoc(unsigned int startPos, int length, int initStyle, Wor
 		if (style == SCE_ESCRIPT_WORD3) {
 			if(iswordchar(ch) && !iswordchar(chNext)) {
 				char s[32];
-				unsigned int j;
+				Sci_PositionU j;
 				for(j = 0; ( j < 31 ) && ( j < i-lastStart+1 ); j++) {
 					s[j] = static_cast<char>(tolower(styler[lastStart + j]));
 				}
diff --git a/Pythonwin/Scintilla/src/LexEiffel.cxx b/Pythonwin/Scintilla/lexers/LexEiffel.cxx
similarity index 88%
rename from Pythonwin/Scintilla/src/LexEiffel.cxx
rename to Pythonwin/Scintilla/lexers/LexEiffel.cxx
index 03dea5e73..d1d42a960 100644
--- a/Pythonwin/Scintilla/src/LexEiffel.cxx
+++ b/Pythonwin/Scintilla/lexers/LexEiffel.cxx
@@ -7,22 +7,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
-#include <stdarg.h>
 #include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static inline bool isEiffelOperator(unsigned int ch) {
 	// '.' left out as it is used to make up numbers
@@ -43,8 +44,8 @@ static inline bool IsAWordStart(unsigned int ch) {
 	return (ch < 0x80) && (isalnum(ch) || ch == '_');
 }
 
-static void ColouriseEiffelDoc(unsigned int startPos,
-                            int length,
+static void ColouriseEiffelDoc(Sci_PositionU startPos,
+                            Sci_Position length,
                             int initStyle,
                             WordList *keywordlists[],
                             Accessor &styler) {
@@ -115,16 +116,16 @@ static void ColouriseEiffelDoc(unsigned int startPos,
 	sc.Complete();
 }
 
-static bool IsEiffelComment(Accessor &styler, int pos, int len) {
+static bool IsEiffelComment(Accessor &styler, Sci_Position pos, Sci_Position len) {
 	return len>1 && styler[pos]=='-' && styler[pos+1]=='-';
 }
 
-static void FoldEiffelDocIndent(unsigned int startPos, int length, int,
+static void FoldEiffelDocIndent(Sci_PositionU startPos, Sci_Position length, int,
 						   WordList *[], Accessor &styler) {
-	int lengthDoc = startPos + length;
+	Sci_Position lengthDoc = startPos + length;
 
 	// Backtrack to previous line in case need to fix its fold status
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	if (startPos > 0) {
 		if (lineCurrent > 0) {
 			lineCurrent--;
@@ -134,7 +135,7 @@ static void FoldEiffelDocIndent(unsigned int startPos, int length, int,
 	int spaceFlags = 0;
 	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, IsEiffelComment);
 	char chNext = styler[startPos];
-	for (int i = startPos; i < lengthDoc; i++) {
+	for (Sci_Position i = startPos; i < lengthDoc; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 
@@ -161,11 +162,11 @@ static void FoldEiffelDocIndent(unsigned int startPos, int length, int,
 	}
 }
 
-static void FoldEiffelDocKeyWords(unsigned int startPos, int length, int /* initStyle */, WordList *[],
+static void FoldEiffelDocKeyWords(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, WordList *[],
                        Accessor &styler) {
-	unsigned int lengthDoc = startPos + length;
+	Sci_PositionU lengthDoc = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	char chNext = styler[startPos];
@@ -174,7 +175,7 @@ static void FoldEiffelDocKeyWords(unsigned int startPos, int length, int /* init
 	// lastDeferred should be determined by looking back to last keyword in case
 	// the "deferred" is on a line before "class"
 	bool lastDeferred = false;
-	for (unsigned int i = startPos; i < lengthDoc; i++) {
+	for (Sci_PositionU i = startPos; i < lengthDoc; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int style = styleNext;
@@ -182,7 +183,7 @@ static void FoldEiffelDocKeyWords(unsigned int startPos, int length, int /* init
 		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
 		if ((stylePrev != SCE_EIFFEL_WORD) && (style == SCE_EIFFEL_WORD)) {
 			char s[20];
-			unsigned int j = 0;
+			Sci_PositionU j = 0;
 			while ((j < (sizeof(s) - 1)) && (iswordchar(styler[i + j]))) {
 				s[j] = styler[i + j];
 				j++;
diff --git a/Pythonwin/Scintilla/lexers/LexErlang.cxx b/Pythonwin/Scintilla/lexers/LexErlang.cxx
new file mode 100644
index 000000000..4ca5962c3
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexErlang.cxx
@@ -0,0 +1,624 @@
+// Scintilla source code edit control
+// Encoding: UTF-8
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+/** @file LexErlang.cxx
+ ** Lexer for Erlang.
+ ** Enhanced by Etienne 'Lenain' Girondel (lenaing@gmail.com)
+ ** Originally wrote by Peter-Henry Mander,
+ ** based on Matlab lexer by José Fonseca.
+ **/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static int is_radix(int radix, int ch) {
+	int digit;
+
+	if (36 < radix || 2 > radix)
+		return 0;
+
+	if (isdigit(ch)) {
+		digit = ch - '0';
+	} else if (isalnum(ch)) {
+		digit = toupper(ch) - 'A' + 10;
+	} else {
+		return 0;
+	}
+
+	return (digit < radix);
+}
+
+typedef enum {
+	STATE_NULL,
+	COMMENT,
+	COMMENT_FUNCTION,
+	COMMENT_MODULE,
+	COMMENT_DOC,
+	COMMENT_DOC_MACRO,
+	ATOM_UNQUOTED,
+	ATOM_QUOTED,
+	NODE_NAME_UNQUOTED,
+	NODE_NAME_QUOTED,
+	MACRO_START,
+	MACRO_UNQUOTED,
+	MACRO_QUOTED,
+	RECORD_START,
+	RECORD_UNQUOTED,
+	RECORD_QUOTED,
+	NUMERAL_START,
+	NUMERAL_BASE_VALUE,
+	NUMERAL_FLOAT,
+	NUMERAL_EXPONENT,
+	PREPROCESSOR
+} atom_parse_state_t;
+
+static inline bool IsAWordChar(const int ch) {
+	return (ch < 0x80) && (ch != ' ') && (isalnum(ch) || ch == '_');
+}
+
+static void ColouriseErlangDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+								WordList *keywordlists[], Accessor &styler) {
+
+	StyleContext sc(startPos, length, initStyle, styler);
+	WordList &reservedWords = *keywordlists[0];
+	WordList &erlangBIFs = *keywordlists[1];
+	WordList &erlangPreproc = *keywordlists[2];
+	WordList &erlangModulesAtt = *keywordlists[3];
+	WordList &erlangDoc = *keywordlists[4];
+	WordList &erlangDocMacro = *keywordlists[5];
+	int radix_digits = 0;
+	int exponent_digits = 0;
+	atom_parse_state_t parse_state = STATE_NULL;
+	atom_parse_state_t old_parse_state = STATE_NULL;
+	bool to_late_to_comment = false;
+	char cur[100];
+	int old_style = SCE_ERLANG_DEFAULT;
+
+	styler.StartAt(startPos);
+
+	for (; sc.More(); sc.Forward()) {
+		int style = SCE_ERLANG_DEFAULT;
+		if (STATE_NULL != parse_state) {
+
+			switch (parse_state) {
+
+				case STATE_NULL : sc.SetState(SCE_ERLANG_DEFAULT); break;
+
+			/* COMMENTS ------------------------------------------------------*/
+				case COMMENT : {
+					if (sc.ch != '%') {
+						to_late_to_comment = true;
+					} else if (!to_late_to_comment && sc.ch == '%') {
+						// Switch to comment level 2 (Function)
+						sc.ChangeState(SCE_ERLANG_COMMENT_FUNCTION);
+						old_style = SCE_ERLANG_COMMENT_FUNCTION;
+						parse_state = COMMENT_FUNCTION;
+						sc.Forward();
+					}
+				}
+				// V--- Falling through!
+				// Falls through.
+				case COMMENT_FUNCTION : {
+					if (sc.ch != '%') {
+						to_late_to_comment = true;
+					} else if (!to_late_to_comment && sc.ch == '%') {
+						// Switch to comment level 3 (Module)
+						sc.ChangeState(SCE_ERLANG_COMMENT_MODULE);
+						old_style = SCE_ERLANG_COMMENT_MODULE;
+						parse_state = COMMENT_MODULE;
+						sc.Forward();
+					}
+				}
+				// V--- Falling through!
+				// Falls through.
+				case COMMENT_MODULE : {
+					if (parse_state != COMMENT) {
+						// Search for comment documentation
+						if (sc.chNext == '@') {
+							old_parse_state = parse_state;
+							parse_state = ('{' == sc.ch)
+											? COMMENT_DOC_MACRO
+											: COMMENT_DOC;
+							sc.ForwardSetState(sc.state);
+						}
+					}
+
+					// All comments types fall here.
+					if (sc.atLineEnd) {
+						to_late_to_comment = false;
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+				case COMMENT_DOC :
+				// V--- Falling through!
+				case COMMENT_DOC_MACRO : {
+
+					if (!isalnum(sc.ch)) {
+						// Try to match documentation comment
+						sc.GetCurrent(cur, sizeof(cur));
+
+						if (parse_state == COMMENT_DOC_MACRO
+							&& erlangDocMacro.InList(cur)) {
+								sc.ChangeState(SCE_ERLANG_COMMENT_DOC_MACRO);
+								while (sc.ch != '}' && !sc.atLineEnd)
+									sc.Forward();
+						} else if (erlangDoc.InList(cur)) {
+							sc.ChangeState(SCE_ERLANG_COMMENT_DOC);
+						} else {
+							sc.ChangeState(old_style);
+						}
+
+						// Switch back to old state
+						sc.SetState(old_style);
+						parse_state = old_parse_state;
+					}
+
+					if (sc.atLineEnd) {
+						to_late_to_comment = false;
+						sc.ChangeState(old_style);
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+			/* -------------------------------------------------------------- */
+			/* Atoms ---------------------------------------------------------*/
+				case ATOM_UNQUOTED : {
+					if ('@' == sc.ch){
+						parse_state = NODE_NAME_UNQUOTED;
+					} else if (sc.ch == ':') {
+						// Searching for module name
+						if (sc.chNext == ' ') {
+							// error
+							sc.ChangeState(SCE_ERLANG_UNKNOWN);
+							parse_state = STATE_NULL;
+						} else {
+							sc.Forward();
+							if (isalnum(sc.ch))  {
+								sc.GetCurrent(cur, sizeof(cur));
+								sc.ChangeState(SCE_ERLANG_MODULES);
+								sc.SetState(SCE_ERLANG_MODULES);
+							}
+						}
+					} else if (!IsAWordChar(sc.ch)) {
+
+						sc.GetCurrent(cur, sizeof(cur));
+						if (reservedWords.InList(cur)) {
+							style = SCE_ERLANG_KEYWORD;
+						} else if (erlangBIFs.InList(cur)
+									&& strcmp(cur,"erlang:")){
+							style = SCE_ERLANG_BIFS;
+						} else if (sc.ch == '(' || '/' == sc.ch){
+							style = SCE_ERLANG_FUNCTION_NAME;
+						} else {
+							style = SCE_ERLANG_ATOM;
+						}
+
+						sc.ChangeState(style);
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+
+				} break;
+
+				case ATOM_QUOTED : {
+					if ( '@' == sc.ch ){
+						parse_state = NODE_NAME_QUOTED;
+					} else if ('\'' == sc.ch && '\\' != sc.chPrev) {
+						sc.ChangeState(SCE_ERLANG_ATOM);
+						sc.ForwardSetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+			/* -------------------------------------------------------------- */
+			/* Node names ----------------------------------------------------*/
+				case NODE_NAME_UNQUOTED : {
+					if ('@' == sc.ch) {
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					} else if (!IsAWordChar(sc.ch)) {
+						sc.ChangeState(SCE_ERLANG_NODE_NAME);
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+				case NODE_NAME_QUOTED : {
+					if ('@' == sc.ch) {
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					} else if ('\'' == sc.ch && '\\' != sc.chPrev) {
+						sc.ChangeState(SCE_ERLANG_NODE_NAME_QUOTED);
+						sc.ForwardSetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+			/* -------------------------------------------------------------- */
+			/* Records -------------------------------------------------------*/
+				case RECORD_START : {
+					if ('\'' == sc.ch) {
+						parse_state = RECORD_QUOTED;
+					} else if (isalpha(sc.ch) && islower(sc.ch)) {
+						parse_state = RECORD_UNQUOTED;
+					} else { // error
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+				case RECORD_UNQUOTED : {
+					if (!IsAWordChar(sc.ch)) {
+						sc.ChangeState(SCE_ERLANG_RECORD);
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+				case RECORD_QUOTED : {
+					if ('\'' == sc.ch && '\\' != sc.chPrev) {
+						sc.ChangeState(SCE_ERLANG_RECORD_QUOTED);
+						sc.ForwardSetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+			/* -------------------------------------------------------------- */
+			/* Macros --------------------------------------------------------*/
+				case MACRO_START : {
+					if ('\'' == sc.ch) {
+						parse_state = MACRO_QUOTED;
+					} else if (isalpha(sc.ch)) {
+						parse_state = MACRO_UNQUOTED;
+					} else { // error
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+				case MACRO_UNQUOTED : {
+					if (!IsAWordChar(sc.ch)) {
+						sc.ChangeState(SCE_ERLANG_MACRO);
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+				case MACRO_QUOTED : {
+					if ('\'' == sc.ch && '\\' != sc.chPrev) {
+						sc.ChangeState(SCE_ERLANG_MACRO_QUOTED);
+						sc.ForwardSetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+			/* -------------------------------------------------------------- */
+			/* Numerics ------------------------------------------------------*/
+			/* Simple integer */
+				case NUMERAL_START : {
+					if (isdigit(sc.ch)) {
+						radix_digits *= 10;
+						radix_digits += sc.ch - '0'; // Assuming ASCII here!
+					} else if ('#' == sc.ch) {
+						if (2 > radix_digits || 36 < radix_digits) {
+							sc.SetState(SCE_ERLANG_DEFAULT);
+							parse_state = STATE_NULL;
+						} else {
+							parse_state = NUMERAL_BASE_VALUE;
+						}
+					} else if ('.' == sc.ch && isdigit(sc.chNext)) {
+						radix_digits = 0;
+						parse_state = NUMERAL_FLOAT;
+					} else if ('e' == sc.ch || 'E' == sc.ch) {
+						exponent_digits = 0;
+						parse_state = NUMERAL_EXPONENT;
+					} else {
+						radix_digits = 0;
+						sc.ChangeState(SCE_ERLANG_NUMBER);
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+			/* Integer in other base than 10 (x#yyy) */
+				case NUMERAL_BASE_VALUE : {
+					if (!is_radix(radix_digits,sc.ch)) {
+						radix_digits = 0;
+
+						if (!isalnum(sc.ch))
+							sc.ChangeState(SCE_ERLANG_NUMBER);
+
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+			/* Float (x.yyy) */
+				case NUMERAL_FLOAT : {
+					if ('e' == sc.ch || 'E' == sc.ch) {
+						exponent_digits = 0;
+						parse_state = NUMERAL_EXPONENT;
+					} else if (!isdigit(sc.ch)) {
+						sc.ChangeState(SCE_ERLANG_NUMBER);
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+			/* Exponent, either integer or float (xEyy, x.yyEzzz) */
+				case NUMERAL_EXPONENT : {
+					if (('-' == sc.ch || '+' == sc.ch)
+							&& (isdigit(sc.chNext))) {
+						sc.Forward();
+					} else if (!isdigit(sc.ch)) {
+						if (0 < exponent_digits)
+							sc.ChangeState(SCE_ERLANG_NUMBER);
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					} else {
+						++exponent_digits;
+					}
+				} break;
+
+			/* -------------------------------------------------------------- */
+			/* Preprocessor --------------------------------------------------*/
+				case PREPROCESSOR : {
+					if (!IsAWordChar(sc.ch)) {
+
+						sc.GetCurrent(cur, sizeof(cur));
+						if (erlangPreproc.InList(cur)) {
+							style = SCE_ERLANG_PREPROC;
+						} else if (erlangModulesAtt.InList(cur)) {
+							style = SCE_ERLANG_MODULES_ATT;
+						}
+
+						sc.ChangeState(style);
+						sc.SetState(SCE_ERLANG_DEFAULT);
+						parse_state = STATE_NULL;
+					}
+				} break;
+
+			}
+
+		} /* End of : STATE_NULL != parse_state */
+		else
+		{
+			switch (sc.state) {
+				case SCE_ERLANG_VARIABLE : {
+					if (!IsAWordChar(sc.ch))
+						sc.SetState(SCE_ERLANG_DEFAULT);
+				} break;
+				case SCE_ERLANG_STRING : {
+					 if (sc.ch == '\"' && sc.chPrev != '\\')
+						sc.ForwardSetState(SCE_ERLANG_DEFAULT);
+				} break;
+				case SCE_ERLANG_COMMENT : {
+					 if (sc.atLineEnd)
+						sc.SetState(SCE_ERLANG_DEFAULT);
+				} break;
+				case SCE_ERLANG_CHARACTER : {
+					if (sc.chPrev == '\\') {
+						sc.ForwardSetState(SCE_ERLANG_DEFAULT);
+					} else if (sc.ch != '\\') {
+						sc.ForwardSetState(SCE_ERLANG_DEFAULT);
+					}
+				} break;
+				case SCE_ERLANG_OPERATOR : {
+					if (sc.chPrev == '.') {
+						if (sc.ch == '*' || sc.ch == '/' || sc.ch == '\\'
+							|| sc.ch == '^') {
+							sc.ForwardSetState(SCE_ERLANG_DEFAULT);
+						} else if (sc.ch == '\'') {
+							sc.ForwardSetState(SCE_ERLANG_DEFAULT);
+						} else {
+							sc.SetState(SCE_ERLANG_DEFAULT);
+						}
+					} else {
+						sc.SetState(SCE_ERLANG_DEFAULT);
+					}
+				} break;
+			}
+		}
+
+		if (sc.state == SCE_ERLANG_DEFAULT) {
+			bool no_new_state = false;
+
+			switch (sc.ch) {
+				case '\"' : sc.SetState(SCE_ERLANG_STRING); break;
+				case '$' : sc.SetState(SCE_ERLANG_CHARACTER); break;
+				case '%' : {
+					parse_state = COMMENT;
+					sc.SetState(SCE_ERLANG_COMMENT);
+				} break;
+				case '#' : {
+					parse_state = RECORD_START;
+					sc.SetState(SCE_ERLANG_UNKNOWN);
+				} break;
+				case '?' : {
+					parse_state = MACRO_START;
+					sc.SetState(SCE_ERLANG_UNKNOWN);
+				} break;
+				case '\'' : {
+					parse_state = ATOM_QUOTED;
+					sc.SetState(SCE_ERLANG_UNKNOWN);
+				} break;
+				case '+' :
+				case '-' : {
+					if (IsADigit(sc.chNext)) {
+						parse_state = NUMERAL_START;
+						radix_digits = 0;
+						sc.SetState(SCE_ERLANG_UNKNOWN);
+					} else if (sc.ch != '+') {
+						parse_state = PREPROCESSOR;
+						sc.SetState(SCE_ERLANG_UNKNOWN);
+					}
+				} break;
+				default : no_new_state = true;
+			}
+
+			if (no_new_state) {
+				if (isdigit(sc.ch)) {
+					parse_state = NUMERAL_START;
+					radix_digits = sc.ch - '0';
+					sc.SetState(SCE_ERLANG_UNKNOWN);
+				} else if (isupper(sc.ch) || '_' == sc.ch) {
+					sc.SetState(SCE_ERLANG_VARIABLE);
+				} else if (isalpha(sc.ch)) {
+					parse_state = ATOM_UNQUOTED;
+					sc.SetState(SCE_ERLANG_UNKNOWN);
+				} else if (isoperator(static_cast<char>(sc.ch))
+							|| sc.ch == '\\') {
+					sc.SetState(SCE_ERLANG_OPERATOR);
+				}
+			}
+		}
+
+	}
+	sc.Complete();
+}
+
+static int ClassifyErlangFoldPoint(
+	Accessor &styler,
+	int styleNext,
+	Sci_Position keyword_start
+) {
+	int lev = 0;
+	if (styler.Match(keyword_start,"case")
+		|| (
+			styler.Match(keyword_start,"fun")
+			&& (SCE_ERLANG_FUNCTION_NAME != styleNext)
+			)
+		|| styler.Match(keyword_start,"if")
+		|| styler.Match(keyword_start,"query")
+		|| styler.Match(keyword_start,"receive")
+	) {
+		++lev;
+	} else if (styler.Match(keyword_start,"end")) {
+		--lev;
+	}
+
+	return lev;
+}
+
+static void FoldErlangDoc(
+	Sci_PositionU startPos, Sci_Position length, int initStyle,
+	WordList** /*keywordlists*/, Accessor &styler
+) {
+	Sci_PositionU endPos = startPos + length;
+	Sci_Position currentLine = styler.GetLine(startPos);
+	int lev;
+	int previousLevel = styler.LevelAt(currentLine) & SC_FOLDLEVELNUMBERMASK;
+	int currentLevel = previousLevel;
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+	int stylePrev;
+	Sci_Position keyword_start = 0;
+	char ch;
+	char chNext = styler.SafeGetCharAt(startPos);
+	bool atEOL;
+
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+
+		// Get styles
+		stylePrev = style;
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		atEOL = ((ch == '\r') && (chNext != '\n')) || (ch == '\n');
+
+		if (stylePrev != SCE_ERLANG_KEYWORD
+			&& style == SCE_ERLANG_KEYWORD) {
+			keyword_start = i;
+		}
+
+		// Fold on keywords
+		if (stylePrev == SCE_ERLANG_KEYWORD
+			&& style != SCE_ERLANG_KEYWORD
+			&& style != SCE_ERLANG_ATOM
+		) {
+			currentLevel += ClassifyErlangFoldPoint(styler,
+													styleNext,
+													keyword_start);
+		}
+
+		// Fold on comments
+		if (style == SCE_ERLANG_COMMENT
+			|| style == SCE_ERLANG_COMMENT_MODULE
+			|| style == SCE_ERLANG_COMMENT_FUNCTION) {
+
+			if (ch == '%' && chNext == '{') {
+				currentLevel++;
+			} else if (ch == '%' && chNext == '}') {
+				currentLevel--;
+			}
+		}
+
+		// Fold on braces
+		if (style == SCE_ERLANG_OPERATOR) {
+			if (ch == '{' || ch == '(' || ch == '[') {
+				currentLevel++;
+			} else if (ch == '}' || ch == ')' || ch == ']') {
+				currentLevel--;
+			}
+		}
+
+
+		if (atEOL) {
+			lev = previousLevel;
+
+			if (currentLevel > previousLevel)
+				lev |= SC_FOLDLEVELHEADERFLAG;
+
+			if (lev != styler.LevelAt(currentLine))
+				styler.SetLevel(currentLine, lev);
+
+			currentLine++;
+			previousLevel = currentLevel;
+		}
+
+	}
+
+	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
+	styler.SetLevel(currentLine,
+					previousLevel
+					| (styler.LevelAt(currentLine) & ~SC_FOLDLEVELNUMBERMASK));
+}
+
+static const char * const erlangWordListDesc[] = {
+	"Erlang Reserved words",
+	"Erlang BIFs",
+	"Erlang Preprocessor",
+	"Erlang Module Attributes",
+	"Erlang Documentation",
+	"Erlang Documentation Macro",
+	0
+};
+
+LexerModule lmErlang(
+	SCLEX_ERLANG,
+	ColouriseErlangDoc,
+	"erlang",
+	FoldErlangDoc,
+	erlangWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexErrorList.cxx b/Pythonwin/Scintilla/lexers/LexErrorList.cxx
new file mode 100644
index 000000000..0fc389646
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexErrorList.cxx
@@ -0,0 +1,409 @@
+// Scintilla source code edit control
+/** @file LexErrorList.cxx
+ ** Lexer for error lists. Used for the output pane in SciTE.
+ **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+namespace {
+
+bool strstart(const char *haystack, const char *needle) noexcept {
+	return strncmp(haystack, needle, strlen(needle)) == 0;
+}
+
+constexpr bool Is0To9(char ch) noexcept {
+	return (ch >= '0') && (ch <= '9');
+}
+
+constexpr bool Is1To9(char ch) noexcept {
+	return (ch >= '1') && (ch <= '9');
+}
+
+bool IsAlphabetic(int ch) {
+	return IsASCII(ch) && isalpha(ch);
+}
+
+inline bool AtEOL(Accessor &styler, Sci_PositionU i) {
+	return (styler[i] == '\n') ||
+	       ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n'));
+}
+
+bool IsGccExcerpt(const char *s) noexcept {
+	while (*s) {
+		if (s[0] == ' ' && s[1] == '|' && (s[2] == ' ' || s[2] == '+')) {
+			return true;
+		}
+		if (!(s[0] == ' ' || s[0] == '+' || Is0To9(s[0]))) {
+			return false;
+		}
+		s++;
+	}
+	return true;
+}
+
+int RecogniseErrorListLine(const char *lineBuffer, Sci_PositionU lengthLine, Sci_Position &startValue) {
+	if (lineBuffer[0] == '>') {
+		// Command or return status
+		return SCE_ERR_CMD;
+	} else if (lineBuffer[0] == '<') {
+		// Diff removal.
+		return SCE_ERR_DIFF_DELETION;
+	} else if (lineBuffer[0] == '!') {
+		return SCE_ERR_DIFF_CHANGED;
+	} else if (lineBuffer[0] == '+') {
+		if (strstart(lineBuffer, "+++ ")) {
+			return SCE_ERR_DIFF_MESSAGE;
+		} else {
+			return SCE_ERR_DIFF_ADDITION;
+		}
+	} else if (lineBuffer[0] == '-') {
+		if (strstart(lineBuffer, "--- ")) {
+			return SCE_ERR_DIFF_MESSAGE;
+		} else {
+			return SCE_ERR_DIFF_DELETION;
+		}
+	} else if (strstart(lineBuffer, "cf90-")) {
+		// Absoft Pro Fortran 90/95 v8.2 error and/or warning message
+		return SCE_ERR_ABSF;
+	} else if (strstart(lineBuffer, "fortcom:")) {
+		// Intel Fortran Compiler v8.0 error/warning message
+		return SCE_ERR_IFORT;
+	} else if (strstr(lineBuffer, "File \"") && strstr(lineBuffer, ", line ")) {
+		return SCE_ERR_PYTHON;
+	} else if (strstr(lineBuffer, " in ") && strstr(lineBuffer, " on line ")) {
+		return SCE_ERR_PHP;
+	} else if ((strstart(lineBuffer, "Error ") ||
+	            strstart(lineBuffer, "Warning ")) &&
+	           strstr(lineBuffer, " at (") &&
+	           strstr(lineBuffer, ") : ") &&
+	           (strstr(lineBuffer, " at (") < strstr(lineBuffer, ") : "))) {
+		// Intel Fortran Compiler error/warning message
+		return SCE_ERR_IFC;
+	} else if (strstart(lineBuffer, "Error ")) {
+		// Borland error message
+		return SCE_ERR_BORLAND;
+	} else if (strstart(lineBuffer, "Warning ")) {
+		// Borland warning message
+		return SCE_ERR_BORLAND;
+	} else if (strstr(lineBuffer, "at line ") &&
+	        (strstr(lineBuffer, "at line ") < (lineBuffer + lengthLine)) &&
+	           strstr(lineBuffer, "file ") &&
+	           (strstr(lineBuffer, "file ") < (lineBuffer + lengthLine))) {
+		// Lua 4 error message
+		return SCE_ERR_LUA;
+	} else if (strstr(lineBuffer, " at ") &&
+	        (strstr(lineBuffer, " at ") < (lineBuffer + lengthLine)) &&
+	           strstr(lineBuffer, " line ") &&
+	           (strstr(lineBuffer, " line ") < (lineBuffer + lengthLine)) &&
+	        (strstr(lineBuffer, " at ") + 4 < (strstr(lineBuffer, " line ")))) {
+		// perl error message:
+		// <message> at <file> line <line>
+		return SCE_ERR_PERL;
+	} else if ((lengthLine >= 6) &&
+	           (memcmp(lineBuffer, "   at ", 6) == 0) &&
+	           strstr(lineBuffer, ":line ")) {
+		// A .NET traceback
+		return SCE_ERR_NET;
+	} else if (strstart(lineBuffer, "Line ") &&
+	           strstr(lineBuffer, ", file ")) {
+		// Essential Lahey Fortran error message
+		return SCE_ERR_ELF;
+	} else if (strstart(lineBuffer, "line ") &&
+	           strstr(lineBuffer, " column ")) {
+		// HTML tidy style: line 42 column 1
+		return SCE_ERR_TIDY;
+	} else if (strstart(lineBuffer, "\tat ") &&
+	           strstr(lineBuffer, "(") &&
+	           strstr(lineBuffer, ".java:")) {
+		// Java stack back trace
+		return SCE_ERR_JAVA_STACK;
+	} else if (strstart(lineBuffer, "In file included from ") ||
+	           strstart(lineBuffer, "                 from ")) {
+		// GCC showing include path to following error
+		return SCE_ERR_GCC_INCLUDED_FROM;
+	} else if (strstr(lineBuffer, "warning LNK")) {
+		// Microsoft linker warning:
+		// {<object> : } warning LNK9999
+		return SCE_ERR_MS;
+	} else if (IsGccExcerpt(lineBuffer)) {
+		// GCC code excerpt and pointer to issue
+		//    73 |   GTimeVal last_popdown;
+		//       |            ^~~~~~~~~~~~
+		return SCE_ERR_GCC_EXCERPT;
+	} else {
+		// Look for one of the following formats:
+		// GCC: <filename>:<line>:<message>
+		// Microsoft: <filename>(<line>) :<message>
+		// Common: <filename>(<line>): warning|error|note|remark|catastrophic|fatal
+		// Common: <filename>(<line>) warning|error|note|remark|catastrophic|fatal
+		// Microsoft: <filename>(<line>,<column>)<message>
+		// CTags: <identifier>\t<filename>\t<message>
+		// Lua 5 traceback: \t<filename>:<line>:<message>
+		// Lua 5.1: <exe>: <filename>:<line>:<message>
+		const bool initialTab = (lineBuffer[0] == '\t');
+		bool initialColonPart = false;
+		bool canBeCtags = !initialTab;	// For ctags must have an identifier with no spaces then a tab
+		enum { stInitial,
+			stGccStart, stGccDigit, stGccColumn, stGcc,
+			stMsStart, stMsDigit, stMsBracket, stMsVc, stMsDigitComma, stMsDotNet,
+			stCtagsStart, stCtagsFile, stCtagsStartString, stCtagsStringDollar, stCtags,
+			stUnrecognized
+		} state = stInitial;
+		for (Sci_PositionU i = 0; i < lengthLine; i++) {
+			const char ch = lineBuffer[i];
+			char chNext = ' ';
+			if ((i + 1) < lengthLine)
+				chNext = lineBuffer[i + 1];
+			if (state == stInitial) {
+				if (ch == ':') {
+					// May be GCC, or might be Lua 5 (Lua traceback same but with tab prefix)
+					if ((chNext != '\\') && (chNext != '/') && (chNext != ' ')) {
+						// This check is not completely accurate as may be on
+						// GTK+ with a file name that includes ':'.
+						state = stGccStart;
+					} else if (chNext == ' ') { // indicates a Lua 5.1 error message
+						initialColonPart = true;
+					}
+				} else if ((ch == '(') && Is1To9(chNext) && (!initialTab)) {
+					// May be Microsoft
+					// Check against '0' often removes phone numbers
+					state = stMsStart;
+				} else if ((ch == '\t') && canBeCtags) {
+					// May be CTags
+					state = stCtagsStart;
+				} else if (ch == ' ') {
+					canBeCtags = false;
+				}
+			} else if (state == stGccStart) {	// <filename>:
+				state = ((ch == '-') || Is0To9(ch)) ? stGccDigit : stUnrecognized;
+			} else if (state == stGccDigit) {	// <filename>:<line>
+				if (ch == ':') {
+					state = stGccColumn;	// :9.*: is GCC
+					startValue = i + 1;
+				} else if (!Is0To9(ch)) {
+					state = stUnrecognized;
+				}
+			} else if (state == stGccColumn) {	// <filename>:<line>:<column>
+				if (!Is0To9(ch)) {
+					state = stGcc;
+					if (ch == ':')
+						startValue = i + 1;
+					break;
+				}
+			} else if (state == stMsStart) {	// <filename>(
+				state = Is0To9(ch) ? stMsDigit : stUnrecognized;
+			} else if (state == stMsDigit) {	// <filename>(<line>
+				if (ch == ',') {
+					state = stMsDigitComma;
+				} else if (ch == ')') {
+					state = stMsBracket;
+				} else if ((ch != ' ') && !Is0To9(ch)) {
+					state = stUnrecognized;
+				}
+			} else if (state == stMsBracket) {	// <filename>(<line>)
+				if ((ch == ' ') && (chNext == ':')) {
+					state = stMsVc;
+				} else if ((ch == ':' && chNext == ' ') || (ch == ' ')) {
+					// Possibly Delphi.. don't test against chNext as it's one of the strings below.
+					char word[512];
+					unsigned numstep;
+					if (ch == ' ')
+						numstep = 1; // ch was ' ', handle as if it's a delphi errorline, only add 1 to i.
+					else
+						numstep = 2; // otherwise add 2.
+					Sci_PositionU chPos = 0;
+					for (Sci_PositionU j = i + numstep; j < lengthLine && IsAlphabetic(lineBuffer[j]) && chPos < sizeof(word) - 1; j++)
+						word[chPos++] = lineBuffer[j];
+					word[chPos] = 0;
+					if (!CompareCaseInsensitive(word, "error") || !CompareCaseInsensitive(word, "warning") ||
+						!CompareCaseInsensitive(word, "fatal") || !CompareCaseInsensitive(word, "catastrophic") ||
+						!CompareCaseInsensitive(word, "note") || !CompareCaseInsensitive(word, "remark")) {
+						state = stMsVc;
+					} else {
+						state = stUnrecognized;
+					}
+				} else {
+					state = stUnrecognized;
+				}
+			} else if (state == stMsDigitComma) {	// <filename>(<line>,
+				if (ch == ')') {
+					state = stMsDotNet;
+					break;
+				} else if ((ch != ' ') && !Is0To9(ch)) {
+					state = stUnrecognized;
+				}
+			} else if (state == stCtagsStart) {
+				if (ch == '\t') {
+					state = stCtagsFile;
+				}
+			} else if (state == stCtagsFile) {
+				if ((lineBuffer[i - 1] == '\t') &&
+				        ((ch == '/' && chNext == '^') || Is0To9(ch))) {
+					state = stCtags;
+					break;
+				} else if ((ch == '/') && (chNext == '^')) {
+					state = stCtagsStartString;
+				}
+			} else if ((state == stCtagsStartString) && ((lineBuffer[i] == '$') && (lineBuffer[i + 1] == '/'))) {
+				state = stCtagsStringDollar;
+				break;
+			}
+		}
+		if (state == stGcc) {
+			return initialColonPart ? SCE_ERR_LUA : SCE_ERR_GCC;
+		} else if ((state == stMsVc) || (state == stMsDotNet)) {
+			return SCE_ERR_MS;
+		} else if ((state == stCtagsStringDollar) || (state == stCtags)) {
+			return SCE_ERR_CTAG;
+		} else if (initialColonPart && strstr(lineBuffer, ": warning C")) {
+			// Microsoft warning without line number
+			// <filename>: warning C9999
+			return SCE_ERR_MS;
+		} else {
+			return SCE_ERR_DEFAULT;
+		}
+	}
+}
+
+#define CSI "\033["
+
+constexpr bool SequenceEnd(int ch) noexcept {
+	return (ch == 0) || ((ch >= '@') && (ch <= '~'));
+}
+
+int StyleFromSequence(const char *seq) noexcept {
+	int bold = 0;
+	int colour = 0;
+	while (!SequenceEnd(*seq)) {
+		if (Is0To9(*seq)) {
+			int base = *seq - '0';
+			if (Is0To9(seq[1])) {
+				base = base * 10;
+				base += seq[1] - '0';
+				seq++;
+			}
+			if (base == 0) {
+				colour = 0;
+				bold = 0;
+			}
+			else if (base == 1) {
+				bold = 1;
+			}
+			else if (base >= 30 && base <= 37) {
+				colour = base - 30;
+			}
+		}
+		seq++;
+	}
+	return SCE_ERR_ES_BLACK + bold * 8 + colour;
+}
+
+void ColouriseErrorListLine(
+    const std::string &lineBuffer,
+    Sci_PositionU endPos,
+    Accessor &styler,
+	bool valueSeparate,
+	bool escapeSequences) {
+	Sci_Position startValue = -1;
+	const Sci_PositionU lengthLine = lineBuffer.length();
+	const int style = RecogniseErrorListLine(lineBuffer.c_str(), lengthLine, startValue);
+	if (escapeSequences && strstr(lineBuffer.c_str(), CSI)) {
+		const Sci_Position startPos = endPos - lengthLine;
+		const char *linePortion = lineBuffer.c_str();
+		Sci_Position startPortion = startPos;
+		int portionStyle = style;
+		while (const char *startSeq = strstr(linePortion, CSI)) {
+			if (startSeq > linePortion) {
+				styler.ColourTo(startPortion + static_cast<int>(startSeq - linePortion), portionStyle);
+			}
+			const char *endSeq = startSeq + 2;
+			while (!SequenceEnd(*endSeq))
+				endSeq++;
+			const Sci_Position endSeqPosition = startPortion + static_cast<Sci_Position>(endSeq - linePortion) + 1;
+			switch (*endSeq) {
+			case 0:
+				styler.ColourTo(endPos, SCE_ERR_ESCSEQ_UNKNOWN);
+				return;
+			case 'm':	// Colour command
+				styler.ColourTo(endSeqPosition, SCE_ERR_ESCSEQ);
+				portionStyle = StyleFromSequence(startSeq+2);
+				break;
+			case 'K':	// Erase to end of line -> ignore
+				styler.ColourTo(endSeqPosition, SCE_ERR_ESCSEQ);
+				break;
+			default:
+				styler.ColourTo(endSeqPosition, SCE_ERR_ESCSEQ_UNKNOWN);
+				portionStyle = style;
+			}
+			startPortion = endSeqPosition;
+			linePortion = endSeq + 1;
+		}
+		styler.ColourTo(endPos, portionStyle);
+	} else {
+		if (valueSeparate && (startValue >= 0)) {
+			styler.ColourTo(endPos - (lengthLine - startValue), style);
+			styler.ColourTo(endPos, SCE_ERR_VALUE);
+		} else {
+			styler.ColourTo(endPos, style);
+		}
+	}
+}
+
+void ColouriseErrorListDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
+	std::string lineBuffer;
+	styler.StartAt(startPos);
+	styler.StartSegment(startPos);
+
+	// property lexer.errorlist.value.separate
+	//	For lines in the output pane that are matches from Find in Files or GCC-style
+	//	diagnostics, style the path and line number separately from the rest of the
+	//	line with style 21 used for the rest of the line.
+	//	This allows matched text to be more easily distinguished from its location.
+	const bool valueSeparate = styler.GetPropertyInt("lexer.errorlist.value.separate", 0) != 0;
+
+	// property lexer.errorlist.escape.sequences
+	//	Set to 1 to interpret escape sequences.
+	const bool escapeSequences = styler.GetPropertyInt("lexer.errorlist.escape.sequences") != 0;
+
+	for (Sci_PositionU i = startPos; i < startPos + length; i++) {
+		lineBuffer.push_back(styler[i]);
+		if (AtEOL(styler, i)) {
+			// End of line met, colourise it
+			ColouriseErrorListLine(lineBuffer, i, styler, valueSeparate, escapeSequences);
+			lineBuffer.clear();
+		}
+	}
+	if (!lineBuffer.empty()) {	// Last line does not have ending characters
+		ColouriseErrorListLine(lineBuffer, startPos + length - 1, styler, valueSeparate, escapeSequences);
+	}
+}
+
+const char *const emptyWordListDesc[] = {
+	nullptr
+};
+
+}
+
+LexerModule lmErrorList(SCLEX_ERRORLIST, ColouriseErrorListDoc, "errorlist", 0, emptyWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexFlagship.cxx b/Pythonwin/Scintilla/lexers/LexFlagship.cxx
new file mode 100644
index 000000000..2dfb687aa
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexFlagship.cxx
@@ -0,0 +1,352 @@
+// Scintilla source code edit control
+/** @file LexFlagship.cxx
+ ** Lexer for Harbour and FlagShip.
+ ** (Syntactically compatible to other xBase dialects, like Clipper, dBase, Clip, FoxPro etc.)
+ **/
+// Copyright 2005 by Randy Butler
+// Copyright 2010 by Xavi <jarabal/at/gmail.com> (Harbour)
+// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+// Extended to accept accented characters
+static inline bool IsAWordChar(int ch)
+{
+	return ch >= 0x80 ||
+				(isalnum(ch) || ch == '_');
+}
+
+static void ColouriseFlagShipDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+                                 WordList *keywordlists[], Accessor &styler)
+{
+
+	WordList &keywords = *keywordlists[0];
+	WordList &keywords2 = *keywordlists[1];
+	WordList &keywords3 = *keywordlists[2];
+	WordList &keywords4 = *keywordlists[3];
+	WordList &keywords5 = *keywordlists[4];
+
+	// property lexer.flagship.styling.within.preprocessor
+	//	For Harbour code, determines whether all preprocessor code is styled in the preprocessor style (0) or only from the
+	//	initial # to the end of the command word(1, the default). It also determines how to present text, dump, and disabled code.
+	bool stylingWithinPreprocessor = styler.GetPropertyInt("lexer.flagship.styling.within.preprocessor", 1) != 0;
+
+	CharacterSet setDoxygen(CharacterSet::setAlpha, "$@\\&<>#{}[]");
+
+	int visibleChars = 0;
+	int closeStringChar = 0;
+	int styleBeforeDCKeyword = SCE_FS_DEFAULT;
+	bool bEnableCode = initStyle < SCE_FS_DISABLEDCODE;
+
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	for (; sc.More(); sc.Forward()) {
+
+		// Determine if the current state should terminate.
+		switch (sc.state) {
+			case SCE_FS_OPERATOR:
+			case SCE_FS_OPERATOR_C:
+			case SCE_FS_WORDOPERATOR:
+				sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C);
+				break;
+			case SCE_FS_IDENTIFIER:
+			case SCE_FS_IDENTIFIER_C:
+				if (!IsAWordChar(sc.ch)) {
+					char s[64];
+					sc.GetCurrentLowered(s, sizeof(s));
+					if (keywords.InList(s)) {
+						sc.ChangeState(bEnableCode ? SCE_FS_KEYWORD : SCE_FS_KEYWORD_C);
+					} else if (keywords2.InList(s)) {
+						sc.ChangeState(bEnableCode ? SCE_FS_KEYWORD2 : SCE_FS_KEYWORD2_C);
+					} else if (bEnableCode && keywords3.InList(s)) {
+						sc.ChangeState(SCE_FS_KEYWORD3);
+					} else if (bEnableCode && keywords4.InList(s)) {
+						sc.ChangeState(SCE_FS_KEYWORD4);
+					}// Else, it is really an identifier...
+					sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C);
+				}
+				break;
+			case SCE_FS_NUMBER:
+				if (!IsAWordChar(sc.ch) && !(sc.ch == '.' && IsADigit(sc.chNext))) {
+					sc.SetState(SCE_FS_DEFAULT);
+				}
+				break;
+			case SCE_FS_NUMBER_C:
+				if (!IsAWordChar(sc.ch) && sc.ch != '.') {
+					sc.SetState(SCE_FS_DEFAULT_C);
+				}
+				break;
+			case SCE_FS_CONSTANT:
+				if (!IsAWordChar(sc.ch)) {
+					sc.SetState(SCE_FS_DEFAULT);
+				}
+				break;
+			case SCE_FS_STRING:
+			case SCE_FS_STRING_C:
+				if (sc.ch == closeStringChar) {
+					sc.ForwardSetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C);
+				} else if (sc.atLineEnd) {
+					sc.ChangeState(bEnableCode ? SCE_FS_STRINGEOL : SCE_FS_STRINGEOL_C);
+				}
+				break;
+			case SCE_FS_STRINGEOL:
+			case SCE_FS_STRINGEOL_C:
+				if (sc.atLineStart) {
+					sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C);
+				}
+				break;
+			case SCE_FS_COMMENTDOC:
+			case SCE_FS_COMMENTDOC_C:
+				if (sc.Match('*', '/')) {
+					sc.Forward();
+					sc.ForwardSetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C);
+				} else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support
+					// Verify that we have the conditions to mark a comment-doc-keyword
+					if ((IsASpace(sc.chPrev) || sc.chPrev == '*') && (!IsASpace(sc.chNext))) {
+						styleBeforeDCKeyword = bEnableCode ? SCE_FS_COMMENTDOC : SCE_FS_COMMENTDOC_C;
+						sc.SetState(SCE_FS_COMMENTDOCKEYWORD);
+					}
+				}
+				break;
+			case SCE_FS_COMMENT:
+			case SCE_FS_COMMENTLINE:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_FS_DEFAULT);
+				}
+				break;
+			case SCE_FS_COMMENTLINEDOC:
+			case SCE_FS_COMMENTLINEDOC_C:
+				if (sc.atLineStart) {
+					sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C);
+				} else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support
+					// Verify that we have the conditions to mark a comment-doc-keyword
+					if ((IsASpace(sc.chPrev) || sc.chPrev == '/' || sc.chPrev == '!') && (!IsASpace(sc.chNext))) {
+						styleBeforeDCKeyword = bEnableCode ? SCE_FS_COMMENTLINEDOC : SCE_FS_COMMENTLINEDOC_C;
+						sc.SetState(SCE_FS_COMMENTDOCKEYWORD);
+					}
+				}
+				break;
+			case SCE_FS_COMMENTDOCKEYWORD:
+				if ((styleBeforeDCKeyword == SCE_FS_COMMENTDOC || styleBeforeDCKeyword == SCE_FS_COMMENTDOC_C) &&
+						sc.Match('*', '/')) {
+					sc.ChangeState(SCE_FS_COMMENTDOCKEYWORDERROR);
+					sc.Forward();
+					sc.ForwardSetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C);
+				} else if (!setDoxygen.Contains(sc.ch)) {
+					char s[64];
+					sc.GetCurrentLowered(s, sizeof(s));
+					if (!IsASpace(sc.ch) || !keywords5.InList(s + 1)) {
+						sc.ChangeState(SCE_FS_COMMENTDOCKEYWORDERROR);
+					}
+					sc.SetState(styleBeforeDCKeyword);
+				}
+				break;
+			case SCE_FS_PREPROCESSOR:
+			case SCE_FS_PREPROCESSOR_C:
+				if (sc.atLineEnd) {
+					if (!(sc.chPrev == ';' || sc.GetRelative(-2) == ';')) {
+						sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C);
+					}
+				} else if (stylingWithinPreprocessor) {
+					if (IsASpaceOrTab(sc.ch)) {
+						sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C);
+					}
+				} else if (sc.Match('/', '*') || sc.Match('/', '/') || sc.Match('&', '&')) {
+					sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C);
+				}
+				break;
+			case SCE_FS_DISABLEDCODE:
+				if (sc.ch == '#' && visibleChars == 0) {
+					sc.SetState(bEnableCode ? SCE_FS_PREPROCESSOR : SCE_FS_PREPROCESSOR_C);
+					do {	// Skip whitespace between # and preprocessor word
+						sc.Forward();
+					} while (IsASpaceOrTab(sc.ch) && sc.More());
+					if (sc.MatchIgnoreCase("pragma")) {
+						sc.Forward(6);
+						do {	// Skip more whitespace until keyword
+							sc.Forward();
+						} while (IsASpaceOrTab(sc.ch) && sc.More());
+						if (sc.MatchIgnoreCase("enddump") || sc.MatchIgnoreCase("__endtext")) {
+							bEnableCode = true;
+							sc.SetState(SCE_FS_DISABLEDCODE);
+							sc.Forward(sc.ch == '_' ? 8 : 6);
+							sc.ForwardSetState(SCE_FS_DEFAULT);
+						} else {
+							sc.ChangeState(SCE_FS_DISABLEDCODE);
+						}
+					} else {
+						sc.ChangeState(SCE_FS_DISABLEDCODE);
+					}
+				}
+				break;
+			case SCE_FS_DATE:
+				if (sc.ch == '}') {
+					sc.ForwardSetState(SCE_FS_DEFAULT);
+				} else if (sc.atLineEnd) {
+					sc.ChangeState(SCE_FS_STRINGEOL);
+				}
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_FS_DEFAULT || sc.state == SCE_FS_DEFAULT_C) {
+			if (bEnableCode &&
+					(sc.MatchIgnoreCase(".and.") || sc.MatchIgnoreCase(".not."))) {
+				sc.SetState(SCE_FS_WORDOPERATOR);
+				sc.Forward(4);
+			} else if (bEnableCode && sc.MatchIgnoreCase(".or.")) {
+				sc.SetState(SCE_FS_WORDOPERATOR);
+				sc.Forward(3);
+			} else if (bEnableCode &&
+					(sc.MatchIgnoreCase(".t.") || sc.MatchIgnoreCase(".f.") ||
+					(!IsAWordChar(sc.GetRelative(3)) && sc.MatchIgnoreCase("nil")))) {
+				sc.SetState(SCE_FS_CONSTANT);
+				sc.Forward(2);
+			} else if (sc.Match('/', '*')) {
+				sc.SetState(bEnableCode ? SCE_FS_COMMENTDOC : SCE_FS_COMMENTDOC_C);
+				sc.Forward();
+			} else if (bEnableCode && sc.Match('&', '&')) {
+				sc.SetState(SCE_FS_COMMENTLINE);
+				sc.Forward();
+			} else if (sc.Match('/', '/')) {
+				sc.SetState(bEnableCode ? SCE_FS_COMMENTLINEDOC : SCE_FS_COMMENTLINEDOC_C);
+				sc.Forward();
+			} else if (bEnableCode && sc.ch == '*' && visibleChars == 0) {
+				sc.SetState(SCE_FS_COMMENT);
+			} else if (sc.ch == '\"' || sc.ch == '\'') {
+				sc.SetState(bEnableCode ? SCE_FS_STRING : SCE_FS_STRING_C);
+				closeStringChar = sc.ch;
+			} else if (closeStringChar == '>' && sc.ch == '<') {
+				sc.SetState(bEnableCode ? SCE_FS_STRING : SCE_FS_STRING_C);
+			} else if (sc.ch == '#' && visibleChars == 0) {
+				sc.SetState(bEnableCode ? SCE_FS_PREPROCESSOR : SCE_FS_PREPROCESSOR_C);
+				do {	// Skip whitespace between # and preprocessor word
+					sc.Forward();
+				} while (IsASpaceOrTab(sc.ch) && sc.More());
+				if (sc.atLineEnd) {
+					sc.SetState(bEnableCode ? SCE_FS_DEFAULT : SCE_FS_DEFAULT_C);
+				} else if (sc.MatchIgnoreCase("include")) {
+					if (stylingWithinPreprocessor) {
+						closeStringChar = '>';
+					}
+				} else if (sc.MatchIgnoreCase("pragma")) {
+					sc.Forward(6);
+					do {	// Skip more whitespace until keyword
+						sc.Forward();
+					} while (IsASpaceOrTab(sc.ch) && sc.More());
+					if (sc.MatchIgnoreCase("begindump") || sc.MatchIgnoreCase("__cstream")) {
+						bEnableCode = false;
+						if (stylingWithinPreprocessor) {
+							sc.SetState(SCE_FS_DISABLEDCODE);
+							sc.Forward(8);
+							sc.ForwardSetState(SCE_FS_DEFAULT_C);
+						} else {
+							sc.SetState(SCE_FS_DISABLEDCODE);
+						}
+					} else if (sc.MatchIgnoreCase("enddump") || sc.MatchIgnoreCase("__endtext")) {
+						bEnableCode = true;
+						sc.SetState(SCE_FS_DISABLEDCODE);
+						sc.Forward(sc.ch == '_' ? 8 : 6);
+						sc.ForwardSetState(SCE_FS_DEFAULT);
+					}
+				}
+			} else if (bEnableCode && sc.ch == '{') {
+				Sci_Position p = 0;
+				int chSeek;
+				Sci_PositionU endPos(startPos + length);
+				do {	// Skip whitespace
+					chSeek = sc.GetRelative(++p);
+				} while (IsASpaceOrTab(chSeek) && (sc.currentPos + p < endPos));
+				if (chSeek == '^') {
+					sc.SetState(SCE_FS_DATE);
+				} else {
+					sc.SetState(SCE_FS_OPERATOR);
+				}
+			} else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
+				sc.SetState(bEnableCode ? SCE_FS_NUMBER : SCE_FS_NUMBER_C);
+			} else if (IsAWordChar(sc.ch)) {
+				sc.SetState(bEnableCode ? SCE_FS_IDENTIFIER : SCE_FS_IDENTIFIER_C);
+			} else if (isoperator(static_cast<char>(sc.ch)) || (bEnableCode && sc.ch == '@')) {
+				sc.SetState(bEnableCode ? SCE_FS_OPERATOR : SCE_FS_OPERATOR_C);
+			}
+		}
+
+		if (sc.atLineEnd) {
+			visibleChars = 0;
+			closeStringChar = 0;
+		}
+		if (!IsASpace(sc.ch)) {
+			visibleChars++;
+		}
+	}
+	sc.Complete();
+}
+
+static void FoldFlagShipDoc(Sci_PositionU startPos, Sci_Position length, int,
+									WordList *[], Accessor &styler)
+{
+
+	Sci_Position endPos = startPos + length;
+
+	// Backtrack to previous line in case need to fix its fold status
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	if (startPos > 0 && lineCurrent > 0) {
+			lineCurrent--;
+			startPos = styler.LineStart(lineCurrent);
+	}
+	int spaceFlags = 0;
+	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags);
+	char chNext = styler[startPos];
+	for (Sci_Position i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+
+		if ((ch == '\r' && chNext != '\n') || (ch == '\n') || (i == endPos-1)) {
+			int lev = indentCurrent;
+			int indentNext = styler.IndentAmount(lineCurrent + 1, &spaceFlags);
+			if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) {
+				if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK)) {
+					lev |= SC_FOLDLEVELHEADERFLAG;
+				} else if (indentNext & SC_FOLDLEVELWHITEFLAG) {
+					int spaceFlags2 = 0;
+					int indentNext2 = styler.IndentAmount(lineCurrent + 2, &spaceFlags2);
+					if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext2 & SC_FOLDLEVELNUMBERMASK)) {
+						lev |= SC_FOLDLEVELHEADERFLAG;
+					}
+				}
+			}
+			indentCurrent = indentNext;
+			styler.SetLevel(lineCurrent, lev);
+			lineCurrent++;
+		}
+	}
+}
+
+static const char * const FSWordListDesc[] = {
+	"Keywords Commands",
+	"Std Library Functions",
+	"Procedure, return, exit",
+	"Class (oop)",
+	"Doxygen keywords",
+	0
+};
+
+LexerModule lmFlagShip(SCLEX_FLAGSHIP, ColouriseFlagShipDoc, "flagship", FoldFlagShipDoc, FSWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexForth.cxx b/Pythonwin/Scintilla/lexers/LexForth.cxx
new file mode 100644
index 000000000..80842097d
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexForth.cxx
@@ -0,0 +1,168 @@
+// Scintilla source code edit control
+/** @file LexForth.cxx
+ ** Lexer for FORTH
+ **/
+// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static inline bool IsAWordStart(int ch) {
+	return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.');
+}
+
+static inline bool IsANumChar(int ch) {
+	return (ch < 0x80) && (isxdigit(ch) || ch == '.' || ch == 'e' || ch == 'E' );
+}
+
+static inline bool IsASpaceChar(int ch) {
+	return (ch < 0x80) && isspace(ch);
+}
+
+static void ColouriseForthDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordLists[],
+                            Accessor &styler) {
+
+    WordList &control = *keywordLists[0];
+    WordList &keyword = *keywordLists[1];
+    WordList &defword = *keywordLists[2];
+    WordList &preword1 = *keywordLists[3];
+    WordList &preword2 = *keywordLists[4];
+    WordList &strings = *keywordLists[5];
+
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	for (; sc.More(); sc.Forward())
+	{
+		// Determine if the current state should terminate.
+		if (sc.state == SCE_FORTH_COMMENT) {
+			if (sc.atLineEnd) {
+				sc.SetState(SCE_FORTH_DEFAULT);
+			}
+		}else if (sc.state == SCE_FORTH_COMMENT_ML) {
+			if (sc.ch == ')') {
+				sc.ForwardSetState(SCE_FORTH_DEFAULT);
+			}
+		}else if (sc.state == SCE_FORTH_IDENTIFIER || sc.state == SCE_FORTH_NUMBER) {
+			// handle numbers here too, because what we thought was a number might
+			// turn out to be a keyword e.g. 2DUP
+			if (IsASpaceChar(sc.ch) ) {
+				char s[100];
+				sc.GetCurrentLowered(s, sizeof(s));
+				int newState = sc.state == SCE_FORTH_NUMBER ? SCE_FORTH_NUMBER : SCE_FORTH_DEFAULT;
+				if (control.InList(s)) {
+					sc.ChangeState(SCE_FORTH_CONTROL);
+				} else if (keyword.InList(s)) {
+					sc.ChangeState(SCE_FORTH_KEYWORD);
+				} else if (defword.InList(s)) {
+					sc.ChangeState(SCE_FORTH_DEFWORD);
+				}  else if (preword1.InList(s)) {
+					sc.ChangeState(SCE_FORTH_PREWORD1);
+				} else if (preword2.InList(s)) {
+					sc.ChangeState(SCE_FORTH_PREWORD2);
+				} else if (strings.InList(s)) {
+					sc.ChangeState(SCE_FORTH_STRING);
+					newState = SCE_FORTH_STRING;
+				}
+				sc.SetState(newState);
+			}
+			if (sc.state == SCE_FORTH_NUMBER) {
+				if (IsASpaceChar(sc.ch)) {
+					sc.SetState(SCE_FORTH_DEFAULT);
+				} else if (!IsANumChar(sc.ch)) {
+					sc.ChangeState(SCE_FORTH_IDENTIFIER);
+				}
+			}
+		}else if (sc.state == SCE_FORTH_STRING) {
+			if (sc.ch == '\"') {
+				sc.ForwardSetState(SCE_FORTH_DEFAULT);
+			}
+		}else if (sc.state == SCE_FORTH_LOCALE) {
+			if (sc.ch == '}') {
+				sc.ForwardSetState(SCE_FORTH_DEFAULT);
+			}
+		}else if (sc.state == SCE_FORTH_DEFWORD) {
+			if (IsASpaceChar(sc.ch)) {
+				sc.SetState(SCE_FORTH_DEFAULT);
+			}
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_FORTH_DEFAULT) {
+			if (sc.ch == '\\'){
+				sc.SetState(SCE_FORTH_COMMENT);
+			} else if (sc.ch == '(' &&
+					(sc.atLineStart || IsASpaceChar(sc.chPrev)) &&
+					(sc.atLineEnd   || IsASpaceChar(sc.chNext))) {
+				sc.SetState(SCE_FORTH_COMMENT_ML);
+			} else if (	(sc.ch == '$' && (IsASCII(sc.chNext) && isxdigit(sc.chNext))) ) {
+				// number starting with $ is a hex number
+				sc.SetState(SCE_FORTH_NUMBER);
+				while(sc.More() && IsASCII(sc.chNext) && isxdigit(sc.chNext))
+					sc.Forward();
+			} else if ( (sc.ch == '%' && (IsASCII(sc.chNext) && (sc.chNext == '0' || sc.chNext == '1'))) ) {
+				// number starting with % is binary
+				sc.SetState(SCE_FORTH_NUMBER);
+				while(sc.More() && IsASCII(sc.chNext) && (sc.chNext == '0' || sc.chNext == '1'))
+					sc.Forward();
+			} else if (	IsASCII(sc.ch) &&
+						(isxdigit(sc.ch) || ((sc.ch == '.' || sc.ch == '-') && IsASCII(sc.chNext) && isxdigit(sc.chNext)) )
+					){
+				sc.SetState(SCE_FORTH_NUMBER);
+			} else if (IsAWordStart(sc.ch)) {
+				sc.SetState(SCE_FORTH_IDENTIFIER);
+			} else if (sc.ch == '{') {
+				sc.SetState(SCE_FORTH_LOCALE);
+			} else if (sc.ch == ':' && IsASCII(sc.chNext) && isspace(sc.chNext)) {
+				// highlight word definitions e.g.  : GCD ( n n -- n ) ..... ;
+				//                                  ^ ^^^
+				sc.SetState(SCE_FORTH_DEFWORD);
+				while(sc.More() && IsASCII(sc.chNext) && isspace(sc.chNext))
+					sc.Forward();
+			} else if (sc.ch == ';' &&
+					(sc.atLineStart || IsASpaceChar(sc.chPrev)) &&
+					(sc.atLineEnd   || IsASpaceChar(sc.chNext))	) {
+				// mark the ';' that ends a word
+				sc.SetState(SCE_FORTH_DEFWORD);
+				sc.ForwardSetState(SCE_FORTH_DEFAULT);
+			}
+		}
+
+	}
+	sc.Complete();
+}
+
+static void FoldForthDoc(Sci_PositionU, Sci_Position, int, WordList *[],
+						Accessor &) {
+}
+
+static const char * const forthWordLists[] = {
+			"control keywords",
+			"keywords",
+			"definition words",
+			"prewords with one argument",
+			"prewords with two arguments",
+			"string definition keywords",
+			0,
+		};
+
+LexerModule lmForth(SCLEX_FORTH, ColouriseForthDoc, "forth", FoldForthDoc, forthWordLists);
+
+
diff --git a/Pythonwin/Scintilla/lexers/LexFortran.cxx b/Pythonwin/Scintilla/lexers/LexFortran.cxx
new file mode 100644
index 000000000..28298b3ed
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexFortran.cxx
@@ -0,0 +1,721 @@
+// Scintilla source code edit control
+/** @file LexFortran.cxx
+ ** Lexer for Fortran.
+ ** Written by Chuan-jian Shen, Last changed Sep. 2003
+ **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+/***************************************/
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+/***************************************/
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+/***************************************/
+
+using namespace Scintilla;
+
+/***********************************************/
+static inline bool IsAWordChar(const int ch) {
+	return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '%');
+}
+/**********************************************/
+static inline bool IsAWordStart(const int ch) {
+	return (ch < 0x80) && (isalnum(ch));
+}
+/***************************************/
+static inline bool IsABlank(unsigned int ch) {
+	return (ch == ' ') || (ch == 0x09) || (ch == 0x0b) ;
+}
+/***************************************/
+static inline bool IsALineEnd(char ch) {
+	return ((ch == '\n') || (ch == '\r')) ;
+}
+/***************************************/
+static Sci_PositionU GetContinuedPos(Sci_PositionU pos, Accessor &styler) {
+	while (!IsALineEnd(styler.SafeGetCharAt(pos++))) continue;
+	if (styler.SafeGetCharAt(pos) == '\n') pos++;
+	while (IsABlank(styler.SafeGetCharAt(pos++))) continue;
+	char chCur = styler.SafeGetCharAt(pos);
+	if (chCur == '&') {
+		while (IsABlank(styler.SafeGetCharAt(++pos))) continue;
+		return pos;
+	} else {
+		return pos;
+	}
+}
+/***************************************/
+static void ColouriseFortranDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+        WordList *keywordlists[], Accessor &styler, bool isFixFormat) {
+	WordList &keywords = *keywordlists[0];
+	WordList &keywords2 = *keywordlists[1];
+	WordList &keywords3 = *keywordlists[2];
+	/***************************************/
+	Sci_Position posLineStart = 0;
+	int numNonBlank = 0, prevState = 0;
+	Sci_Position endPos = startPos + length;
+	/***************************************/
+	// backtrack to the nearest keyword
+	while ((startPos > 1) && (styler.StyleAt(startPos) != SCE_F_WORD)) {
+		startPos--;
+	}
+	startPos = styler.LineStart(styler.GetLine(startPos));
+	initStyle = styler.StyleAt(startPos - 1);
+	StyleContext sc(startPos, endPos-startPos, initStyle, styler);
+	/***************************************/
+	for (; sc.More(); sc.Forward()) {
+		// remember the start position of the line
+		if (sc.atLineStart) {
+			posLineStart = sc.currentPos;
+			numNonBlank = 0;
+			sc.SetState(SCE_F_DEFAULT);
+		}
+		if (!IsASpaceOrTab(sc.ch)) numNonBlank ++;
+		/***********************************************/
+		// Handle the fix format generically
+		Sci_Position toLineStart = sc.currentPos - posLineStart;
+		if (isFixFormat && (toLineStart < 6 || toLineStart >= 72)) {
+			if ((toLineStart == 0 && (tolower(sc.ch) == 'c' || sc.ch == '*')) || sc.ch == '!') {
+				if (sc.MatchIgnoreCase("cdec$") || sc.MatchIgnoreCase("*dec$") || sc.MatchIgnoreCase("!dec$") ||
+				        sc.MatchIgnoreCase("cdir$") || sc.MatchIgnoreCase("*dir$") || sc.MatchIgnoreCase("!dir$") ||
+				        sc.MatchIgnoreCase("cms$")  || sc.MatchIgnoreCase("*ms$")  || sc.MatchIgnoreCase("!ms$")  ||
+				        sc.chNext == '$') {
+					sc.SetState(SCE_F_PREPROCESSOR);
+				} else {
+					sc.SetState(SCE_F_COMMENT);
+				}
+
+				while (!sc.atLineEnd && sc.More()) sc.Forward(); // Until line end
+			} else if (toLineStart >= 72) {
+				sc.SetState(SCE_F_COMMENT);
+				while (!sc.atLineEnd && sc.More()) sc.Forward(); // Until line end
+			} else if (toLineStart < 5) {
+				if (IsADigit(sc.ch))
+					sc.SetState(SCE_F_LABEL);
+				else
+					sc.SetState(SCE_F_DEFAULT);
+			} else if (toLineStart == 5) {
+				//if (!IsASpace(sc.ch) && sc.ch != '0') {
+				if (sc.ch != '\r' && sc.ch != '\n') {
+					sc.SetState(SCE_F_CONTINUATION);
+					if (!IsASpace(sc.ch) && sc.ch != '0')
+						sc.ForwardSetState(prevState);
+				} else
+					sc.SetState(SCE_F_DEFAULT);
+			}
+			continue;
+		}
+		/***************************************/
+		// Handle line continuation generically.
+		if (!isFixFormat && sc.ch == '&' && sc.state != SCE_F_COMMENT) {
+			char chTemp = ' ';
+			Sci_Position j = 1;
+			while (IsABlank(chTemp) && j<132) {
+				chTemp = static_cast<char>(sc.GetRelative(j));
+				j++;
+			}
+			if (chTemp == '!') {
+				sc.SetState(SCE_F_CONTINUATION);
+				if (sc.chNext == '!') sc.ForwardSetState(SCE_F_COMMENT);
+			} else if (chTemp == '\r' || chTemp == '\n') {
+				int currentState = sc.state;
+				sc.SetState(SCE_F_CONTINUATION);
+				sc.ForwardSetState(SCE_F_DEFAULT);
+				while (IsASpace(sc.ch) && sc.More()) {
+					sc.Forward();
+					if (sc.atLineStart) numNonBlank = 0;
+					if (!IsASpaceOrTab(sc.ch)) numNonBlank ++;
+				}
+				if (sc.ch == '&') {
+					sc.SetState(SCE_F_CONTINUATION);
+					sc.Forward();
+				}
+				sc.SetState(currentState);
+			}
+		}
+		/***************************************/
+		// Hanndle preprocessor directives
+		if (sc.ch == '#' && numNonBlank == 1)
+		{
+			sc.SetState(SCE_F_PREPROCESSOR);
+			while (!sc.atLineEnd && sc.More())
+				sc.Forward(); // Until line end
+		}
+		/***************************************/
+		// Determine if the current state should terminate.
+		if (sc.state == SCE_F_OPERATOR) {
+			sc.SetState(SCE_F_DEFAULT);
+		} else if (sc.state == SCE_F_NUMBER) {
+			if (!(IsAWordChar(sc.ch) || sc.ch=='\'' || sc.ch=='\"' || sc.ch=='.')) {
+				sc.SetState(SCE_F_DEFAULT);
+			}
+		} else if (sc.state == SCE_F_IDENTIFIER) {
+			if (!IsAWordChar(sc.ch) || (sc.ch == '%')) {
+				char s[100];
+				sc.GetCurrentLowered(s, sizeof(s));
+				if (keywords.InList(s)) {
+					sc.ChangeState(SCE_F_WORD);
+				} else if (keywords2.InList(s)) {
+					sc.ChangeState(SCE_F_WORD2);
+				} else if (keywords3.InList(s)) {
+					sc.ChangeState(SCE_F_WORD3);
+				}
+				sc.SetState(SCE_F_DEFAULT);
+			}
+		} else if (sc.state == SCE_F_COMMENT || sc.state == SCE_F_PREPROCESSOR) {
+			if (sc.ch == '\r' || sc.ch == '\n') {
+				sc.SetState(SCE_F_DEFAULT);
+			}
+		} else if (sc.state == SCE_F_STRING1) {
+			prevState = sc.state;
+			if (sc.ch == '\'') {
+				if (sc.chNext == '\'') {
+					sc.Forward();
+				} else {
+					sc.ForwardSetState(SCE_F_DEFAULT);
+					prevState = SCE_F_DEFAULT;
+				}
+			} else if (sc.atLineEnd) {
+				sc.ChangeState(SCE_F_STRINGEOL);
+				sc.ForwardSetState(SCE_F_DEFAULT);
+			}
+		} else if (sc.state == SCE_F_STRING2) {
+			prevState = sc.state;
+			if (sc.atLineEnd) {
+				sc.ChangeState(SCE_F_STRINGEOL);
+				sc.ForwardSetState(SCE_F_DEFAULT);
+			} else if (sc.ch == '\"') {
+				if (sc.chNext == '\"') {
+					sc.Forward();
+				} else {
+					sc.ForwardSetState(SCE_F_DEFAULT);
+					prevState = SCE_F_DEFAULT;
+				}
+			}
+		} else if (sc.state == SCE_F_OPERATOR2) {
+			if (sc.ch == '.') {
+				sc.ForwardSetState(SCE_F_DEFAULT);
+			}
+		} else if (sc.state == SCE_F_CONTINUATION) {
+			sc.SetState(SCE_F_DEFAULT);
+		} else if (sc.state == SCE_F_LABEL) {
+			if (!IsADigit(sc.ch)) {
+				sc.SetState(SCE_F_DEFAULT);
+			} else {
+				if (isFixFormat && sc.currentPos-posLineStart > 4)
+					sc.SetState(SCE_F_DEFAULT);
+				else if (numNonBlank > 5)
+					sc.SetState(SCE_F_DEFAULT);
+			}
+		}
+		/***************************************/
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_F_DEFAULT) {
+			if (sc.ch == '!') {
+				if (sc.MatchIgnoreCase("!dec$") || sc.MatchIgnoreCase("!dir$") ||
+					sc.MatchIgnoreCase("!ms$") || sc.chNext == '$') {
+					sc.SetState(SCE_F_PREPROCESSOR);
+				} else {
+					sc.SetState(SCE_F_COMMENT);
+				}
+			} else if ((!isFixFormat) && IsADigit(sc.ch) && numNonBlank == 1) {
+				sc.SetState(SCE_F_LABEL);
+			} else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
+				sc.SetState(SCE_F_NUMBER);
+			} else if ((tolower(sc.ch) == 'b' || tolower(sc.ch) == 'o' ||
+				tolower(sc.ch) == 'z') && (sc.chNext == '\"' || sc.chNext == '\'')) {
+				sc.SetState(SCE_F_NUMBER);
+				sc.Forward();
+			} else if (sc.ch == '.' && isalpha(sc.chNext)) {
+				sc.SetState(SCE_F_OPERATOR2);
+			} else if (IsAWordStart(sc.ch)) {
+				sc.SetState(SCE_F_IDENTIFIER);
+			} else if (sc.ch == '\"') {
+				sc.SetState(SCE_F_STRING2);
+			} else if (sc.ch == '\'') {
+				sc.SetState(SCE_F_STRING1);
+			} else if (isoperator(static_cast<char>(sc.ch))) {
+				sc.SetState(SCE_F_OPERATOR);
+			}
+		}
+	}
+	sc.Complete();
+}
+/***************************************/
+static void CheckLevelCommentLine(const unsigned int nComL,
+				  Sci_Position nComColB[], Sci_Position nComColF[], Sci_Position &nComCur,
+				  bool comLineB[], bool comLineF[], bool &comLineCur,
+				  int &levelDeltaNext) {
+	levelDeltaNext = 0;
+	if (!comLineCur) {
+		return;
+	}
+
+	if (!comLineF[0] || nComColF[0] != nComCur) {
+		unsigned int i=0;
+		for (; i<nComL; i++) {
+			if (!comLineB[i] || nComColB[i] != nComCur) {
+				break;
+			}
+		}
+		if (i == nComL) {
+			levelDeltaNext = -1;
+		}
+	}
+	else if (!comLineB[0] || nComColB[0] != nComCur) {
+		unsigned int i=0;
+		for (; i<nComL; i++) {
+			if (!comLineF[i] || nComColF[i] != nComCur) {
+				break;
+			}
+		}
+		if (i == nComL) {
+			levelDeltaNext = 1;
+		}
+	}
+}
+/***************************************/
+static void GetIfLineComment(Accessor &styler, bool isFixFormat, const Sci_Position line, bool &isComLine, Sci_Position &comCol) {
+	Sci_Position col = 0;
+	isComLine = false;
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position len = styler.Length();
+	while(pos<len) {
+		char ch = styler.SafeGetCharAt(pos);
+		if (ch == '!' || (isFixFormat && col == 0 && (tolower(ch) == 'c' || ch == '*'))) {
+			isComLine = true;
+			comCol = col;
+			break;
+		}
+		else if (!IsABlank(ch) || IsALineEnd(ch)) {
+			break;
+		}
+		pos++;
+		col++;
+	}
+}
+/***************************************/
+static void StepCommentLine(Accessor &styler, bool isFixFormat, Sci_Position lineCurrent, const unsigned int nComL,
+				  Sci_Position nComColB[], Sci_Position nComColF[], Sci_Position &nComCur,
+				  bool comLineB[], bool comLineF[], bool &comLineCur) {
+	Sci_Position nLineTotal = styler.GetLine(styler.Length()-1) + 1;
+	if (lineCurrent >= nLineTotal) {
+		return;
+	}
+
+	for (int i=nComL-2; i>=0; i--) {
+		nComColB[i+1] = nComColB[i];
+		comLineB[i+1] = comLineB[i];
+	}
+	nComColB[0] = nComCur;
+	comLineB[0] = comLineCur;
+	nComCur = nComColF[0];
+	comLineCur = comLineF[0];
+	for (unsigned int i=0; i+1<nComL; i++) {
+		nComColF[i] = nComColF[i+1];
+		comLineF[i] = comLineF[i+1];
+	}
+	Sci_Position chL = lineCurrent + nComL;
+	if (chL < nLineTotal) {
+		GetIfLineComment(styler, isFixFormat, chL, comLineF[nComL-1], nComColF[nComL-1]);
+	}
+	else {
+		comLineF[nComL-1] = false;
+	}
+}
+/***************************************/
+static void CheckBackComLines(Accessor &styler, bool isFixFormat, Sci_Position lineCurrent, const unsigned int nComL,
+				  Sci_Position nComColB[], Sci_Position nComColF[], Sci_Position nComCur,
+				  bool comLineB[], bool comLineF[], bool &comLineCur) {
+	unsigned int nLines = nComL + nComL + 1;
+	bool* comL = new bool[nLines];
+	Sci_Position* nComCol = new Sci_Position[nLines];
+	bool comL0;
+	Sci_Position nComCol0;
+	GetIfLineComment(styler, isFixFormat, lineCurrent-nComL-1, comL0, nComCol0);
+	for (unsigned int i=0; i<nComL; i++) {
+		unsigned copyTo = nComL - i - 1;
+		comL[copyTo]    = comLineB[i];
+		nComCol[copyTo] = nComColB[i];
+	}
+	assert(nComL < nLines);
+	comL[nComL] = comLineCur;
+	nComCol[nComL] = nComCur;
+	for (unsigned int i=0; i<nComL; i++) {
+		unsigned copyTo = i + nComL + 1;
+		comL[copyTo]    = comLineF[i];
+		nComCol[copyTo] = nComColF[i];
+	}
+	
+	Sci_Position lineC = lineCurrent - nComL + 1;
+	Sci_PositionU iStart;
+	if (lineC <= 0) {
+		lineC = 0;
+		iStart = nComL - lineCurrent;
+	}
+	else {
+		iStart = 1;
+	}
+	bool levChanged = false;
+	int lev = styler.LevelAt(lineC) & SC_FOLDLEVELNUMBERMASK;
+	
+	for (Sci_PositionU i=iStart; i<=nComL; i++) {
+		if (comL[i] && (!comL[i-1] || nComCol[i] != nComCol[i-1])) {
+			bool increase = true;
+			Sci_PositionU until = i + nComL;
+			for (Sci_PositionU j=i+1; j<=until; j++) {
+				if (!comL[j] || nComCol[j] != nComCol[i]) {
+					increase = false;
+					break;
+				}
+			}
+			lev = styler.LevelAt(lineC) & SC_FOLDLEVELNUMBERMASK;
+			if (increase) {
+				int levH = lev | SC_FOLDLEVELHEADERFLAG;
+				lev += 1;
+				if (levH != styler.LevelAt(lineC)) {
+					styler.SetLevel(lineC, levH);
+				}
+				for (Sci_Position j=lineC+1; j<=lineCurrent; j++) {
+					if (lev != styler.LevelAt(j)) {
+						styler.SetLevel(j, lev);
+					}
+				}
+				break;
+			}
+			else {
+				if (lev != styler.LevelAt(lineC)) {
+					styler.SetLevel(lineC, lev);
+				}
+			}
+			levChanged = true;
+		}
+		else if (levChanged && comL[i]) {
+			if (lev != styler.LevelAt(lineC)) {
+				styler.SetLevel(lineC, lev);
+			}
+		}
+		lineC++;
+	}
+	delete[] comL;
+	delete[] nComCol;
+}
+/***************************************/
+// To determine the folding level depending on keywords
+static int classifyFoldPointFortran(const char* s, const char* prevWord, const char chNextNonBlank) {
+	int lev = 0;
+
+	if ((strcmp(prevWord, "module") == 0 && strcmp(s, "subroutine") == 0)
+		|| (strcmp(prevWord, "module") == 0 && strcmp(s, "function") == 0)) {
+		lev = 0;
+	} else if (strcmp(s, "associate") == 0 || strcmp(s, "block") == 0
+	        || strcmp(s, "blockdata") == 0 || strcmp(s, "select") == 0
+	        || strcmp(s, "selecttype") == 0 || strcmp(s, "selectcase") == 0
+	        || strcmp(s, "do") == 0 || strcmp(s, "enum") ==0
+	        || strcmp(s, "function") == 0 || strcmp(s, "interface") == 0
+	        || strcmp(s, "module") == 0 || strcmp(s, "program") == 0
+	        || strcmp(s, "subroutine") == 0 || strcmp(s, "then") == 0
+	        || (strcmp(s, "type") == 0 && chNextNonBlank != '(')
+		|| strcmp(s, "critical") == 0 || strcmp(s, "submodule") == 0){
+		if (strcmp(prevWord, "end") == 0)
+			lev = 0;
+		else
+			lev = 1;
+	} else if ((strcmp(s, "end") == 0 && chNextNonBlank != '=')
+	        || strcmp(s, "endassociate") == 0 || strcmp(s, "endblock") == 0
+	        || strcmp(s, "endblockdata") == 0 || strcmp(s, "endselect") == 0
+	        || strcmp(s, "enddo") == 0 || strcmp(s, "endenum") ==0
+	        || strcmp(s, "endif") == 0 || strcmp(s, "endforall") == 0
+	        || strcmp(s, "endfunction") == 0 || strcmp(s, "endinterface") == 0
+	        || strcmp(s, "endmodule") == 0 || strcmp(s, "endprogram") == 0
+	        || strcmp(s, "endsubroutine") == 0 || strcmp(s, "endtype") == 0
+	        || strcmp(s, "endwhere") == 0 || strcmp(s, "endcritical") == 0
+		|| (strcmp(prevWord, "module") == 0 && strcmp(s, "procedure") == 0)  // Take care of the "module procedure" statement
+		|| strcmp(s, "endsubmodule") == 0 || strcmp(s, "endteam") == 0) {
+		lev = -1;
+	} else if (strcmp(prevWord, "end") == 0 && strcmp(s, "if") == 0){ // end if
+		lev = 0;
+	} else if (strcmp(prevWord, "type") == 0 && strcmp(s, "is") == 0){ // type is
+		lev = -1;
+	} else if ((strcmp(prevWord, "end") == 0 && strcmp(s, "procedure") == 0)
+			   || strcmp(s, "endprocedure") == 0) {
+			lev = 1; // level back to 0, because no folding support for "module procedure" in submodule
+	} else if (strcmp(prevWord, "change") == 0 && strcmp(s, "team") == 0){ // change team
+		lev = 1;
+	}
+	return lev;
+}
+/***************************************/
+// Folding the code
+static void FoldFortranDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+        Accessor &styler, bool isFixFormat) {
+
+	bool foldComment = styler.GetPropertyInt("fold.comment", 1) != 0;
+	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	bool isPrevLine;
+	if (lineCurrent > 0) {
+		lineCurrent--;
+		startPos = styler.LineStart(lineCurrent);
+		isPrevLine = true;
+	} else {
+		isPrevLine = false;
+	}
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+	int levelDeltaNext = 0;
+
+	const unsigned int nComL = 3; // defines how many comment lines should be before they are folded
+	Sci_Position nComColB[nComL] = {};
+	Sci_Position nComColF[nComL] = {};
+	Sci_Position nComCur = 0;
+	bool comLineB[nComL] = {};
+	bool comLineF[nComL] = {};
+	bool comLineCur;
+	Sci_Position nLineTotal = styler.GetLine(styler.Length()-1) + 1;
+	if (foldComment) {
+		for (unsigned int i=0; i<nComL; i++) {
+			Sci_Position chL = lineCurrent-(i+1);
+			if (chL < 0) {
+				comLineB[i] = false;
+				break;
+			}
+			GetIfLineComment(styler, isFixFormat, chL, comLineB[i], nComColB[i]);
+			if (!comLineB[i]) {
+				for (unsigned int j=i+1; j<nComL; j++) {
+					comLineB[j] = false;
+				}
+				break;
+			}
+		}
+		for (unsigned int i=0; i<nComL; i++) {
+			Sci_Position chL = lineCurrent+i+1;
+			if (chL >= nLineTotal) {
+				comLineF[i] = false;
+				break;
+			}
+			GetIfLineComment(styler, isFixFormat, chL, comLineF[i], nComColF[i]);
+		}
+		GetIfLineComment(styler, isFixFormat, lineCurrent, comLineCur, nComCur);
+		CheckBackComLines(styler, isFixFormat, lineCurrent, nComL, nComColB, nComColF, nComCur, 
+				comLineB, comLineF, comLineCur);
+	}
+	int levelCurrent = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
+
+	/***************************************/
+	Sci_Position lastStart = 0;
+	char prevWord[32] = "";
+	/***************************************/
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		char chNextNonBlank = chNext;
+		bool nextEOL = false;
+		if (IsALineEnd(chNextNonBlank)) {
+			nextEOL = true;
+		}
+		Sci_PositionU j=i+1;
+		while(IsABlank(chNextNonBlank) && j<endPos) {
+			j ++ ;
+			chNextNonBlank = styler.SafeGetCharAt(j);
+			if (IsALineEnd(chNextNonBlank)) {
+				nextEOL = true;
+			}
+		}
+		if (!nextEOL && j == endPos) {
+			nextEOL = true;
+		}
+		int stylePrev = style;
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+		//
+		if (((isFixFormat && stylePrev == SCE_F_CONTINUATION) || stylePrev == SCE_F_DEFAULT
+			|| stylePrev == SCE_F_OPERATOR) && (style == SCE_F_WORD || style == SCE_F_LABEL)) {
+			// Store last word and label start point.
+			lastStart = i;
+		}
+		/***************************************/
+		if (style == SCE_F_WORD) {
+			if(iswordchar(ch) && !iswordchar(chNext)) {
+				char s[32];
+				Sci_PositionU k;
+				for(k=0; (k<31 ) && (k<i-lastStart+1 ); k++) {
+					s[k] = static_cast<char>(tolower(styler[lastStart+k]));
+				}
+				s[k] = '\0';
+				// Handle the forall and where statement and structure.
+				if (strcmp(s, "forall") == 0 || (strcmp(s, "where") == 0 && strcmp(prevWord, "else") != 0)) {
+					if (strcmp(prevWord, "end") != 0) {
+						j = i + 1;
+						char chBrace = '(', chSeek = ')', ch1 = styler.SafeGetCharAt(j);
+						// Find the position of the first (
+						while (ch1 != chBrace && j<endPos) {
+							j++;
+							ch1 = styler.SafeGetCharAt(j);
+						}
+						char styBrace = styler.StyleAt(j);
+						int depth = 1;
+						char chAtPos;
+						char styAtPos;
+						while (j<endPos) {
+							j++;
+							chAtPos = styler.SafeGetCharAt(j);
+							styAtPos = styler.StyleAt(j);
+							if (styAtPos == styBrace) {
+								if (chAtPos == chBrace) depth++;
+								if (chAtPos == chSeek) depth--;
+								if (depth == 0) break;
+							}
+						}
+						Sci_Position tmpLineCurrent = lineCurrent;
+						while (j<endPos) {
+							j++;
+							chAtPos = styler.SafeGetCharAt(j);
+							styAtPos = styler.StyleAt(j);
+							if (!IsALineEnd(chAtPos) && (styAtPos == SCE_F_COMMENT || IsABlank(chAtPos))) continue;
+							if (isFixFormat) {
+								if (!IsALineEnd(chAtPos)) {
+									break;
+								} else {
+									if (tmpLineCurrent < styler.GetLine(styler.Length()-1)) {
+										tmpLineCurrent++;
+										j = styler.LineStart(tmpLineCurrent);
+										if (styler.StyleAt(j+5) == SCE_F_CONTINUATION
+											&& !IsABlank(styler.SafeGetCharAt(j+5)) && styler.SafeGetCharAt(j+5) != '0') {
+											j += 5;
+											continue;
+										} else {
+											levelDeltaNext++;
+											break;
+										}
+									}
+								}
+							} else {
+								if (chAtPos == '&' && styler.StyleAt(j) == SCE_F_CONTINUATION) {
+									j = GetContinuedPos(j+1, styler);
+									continue;
+								} else if (IsALineEnd(chAtPos)) {
+									levelDeltaNext++;
+									break;
+								} else {
+									break;
+								}
+							}
+						}
+					}
+				} else {
+					int wordLevelDelta = classifyFoldPointFortran(s, prevWord, chNextNonBlank);
+					levelDeltaNext += wordLevelDelta;
+					if (((strcmp(s, "else") == 0) && (nextEOL || chNextNonBlank == '!')) ||
+						(strcmp(prevWord, "else") == 0 && strcmp(s, "where") == 0) || strcmp(s, "elsewhere") == 0) {
+						if (!isPrevLine) {
+							levelCurrent--;
+						}
+						levelDeltaNext++;
+					} else if ((strcmp(prevWord, "else") == 0 && strcmp(s, "if") == 0) || strcmp(s, "elseif") == 0) {
+						if (!isPrevLine) {
+							levelCurrent--;
+						}
+					} else if ((strcmp(prevWord, "select") == 0 && strcmp(s, "case") == 0) || strcmp(s, "selectcase") == 0 ||
+							   (strcmp(prevWord, "select") == 0 && strcmp(s, "type") == 0) || strcmp(s, "selecttype") == 0) {
+						levelDeltaNext += 2;
+					} else if ((strcmp(s, "case") == 0 && chNextNonBlank == '(') || (strcmp(prevWord, "case") == 0 && strcmp(s, "default") == 0) ||
+							   (strcmp(prevWord, "type") == 0 && strcmp(s, "is") == 0) ||
+							   (strcmp(prevWord, "class") == 0 && strcmp(s, "is") == 0) ||
+							   (strcmp(prevWord, "class") == 0 && strcmp(s, "default") == 0) ) {
+						if (!isPrevLine) {
+							levelCurrent--;
+						}
+						levelDeltaNext++;
+					} else if ((strcmp(prevWord, "end") == 0 && strcmp(s, "select") == 0) || strcmp(s, "endselect") == 0) {
+						levelDeltaNext -= 2;
+					}
+
+					// There are multiple forms of "do" loop. The older form with a label "do 100 i=1,10" would require matching
+					// labels to ensure the folding level does not decrease too far when labels are used for other purposes.
+					// Since this is difficult, do-label constructs are not folded.
+					if (strcmp(s, "do") == 0 && IsADigit(chNextNonBlank)) {
+						// Remove delta for do-label
+						levelDeltaNext -= wordLevelDelta;
+					}
+				}
+				strcpy(prevWord, s);
+			}
+		}
+		if (atEOL) {
+			if (foldComment) {
+				int ldNext;
+				CheckLevelCommentLine(nComL, nComColB, nComColF, nComCur, comLineB, comLineF, comLineCur, ldNext);
+				levelDeltaNext += ldNext;
+			}
+			int lev = levelCurrent;
+			if (visibleChars == 0 && foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if ((levelDeltaNext > 0) && (visibleChars > 0))
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent))
+				styler.SetLevel(lineCurrent, lev);
+
+			lineCurrent++;
+			levelCurrent += levelDeltaNext;
+			levelDeltaNext = 0;
+			visibleChars = 0;
+			strcpy(prevWord, "");
+			isPrevLine = false;
+
+			if (foldComment) {
+				StepCommentLine(styler, isFixFormat, lineCurrent, nComL, nComColB, nComColF, nComCur,
+						comLineB, comLineF, comLineCur);
+			}
+		}
+		/***************************************/
+		if (!isspacechar(ch)) visibleChars++;
+	}
+	/***************************************/
+}
+/***************************************/
+static const char * const FortranWordLists[] = {
+	"Primary keywords and identifiers",
+	"Intrinsic functions",
+	"Extended and user defined functions",
+	0,
+};
+/***************************************/
+static void ColouriseFortranDocFreeFormat(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+        Accessor &styler) {
+	ColouriseFortranDoc(startPos, length, initStyle, keywordlists, styler, false);
+}
+/***************************************/
+static void ColouriseFortranDocFixFormat(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+        Accessor &styler) {
+	ColouriseFortranDoc(startPos, length, initStyle, keywordlists, styler, true);
+}
+/***************************************/
+static void FoldFortranDocFreeFormat(Sci_PositionU startPos, Sci_Position length, int initStyle,
+        WordList *[], Accessor &styler) {
+	FoldFortranDoc(startPos, length, initStyle,styler, false);
+}
+/***************************************/
+static void FoldFortranDocFixFormat(Sci_PositionU startPos, Sci_Position length, int initStyle,
+        WordList *[], Accessor &styler) {
+	FoldFortranDoc(startPos, length, initStyle,styler, true);
+}
+/***************************************/
+LexerModule lmFortran(SCLEX_FORTRAN, ColouriseFortranDocFreeFormat, "fortran", FoldFortranDocFreeFormat, FortranWordLists);
+LexerModule lmF77(SCLEX_F77, ColouriseFortranDocFixFormat, "f77", FoldFortranDocFixFormat, FortranWordLists);
diff --git a/Pythonwin/Scintilla/src/LexGAP.cxx b/Pythonwin/Scintilla/lexers/LexGAP.cxx
similarity index 89%
rename from Pythonwin/Scintilla/src/LexGAP.cxx
rename to Pythonwin/Scintilla/lexers/LexGAP.cxx
index 25bd33b90..a2eca95ab 100644
--- a/Pythonwin/Scintilla/src/LexGAP.cxx
+++ b/Pythonwin/Scintilla/lexers/LexGAP.cxx
@@ -8,25 +8,26 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static inline bool IsGAPOperator(char ch) {
-	if (isalnum(ch)) return false;
+	if (IsASCII(ch) && isalnum(ch)) return false;
 	if (ch == '+' || ch == '-' || ch == '*' || ch == '/' ||
 		ch == '^' || ch == ',' || ch == '!' || ch == '.' ||
 		ch == '=' || ch == '<' || ch == '>' || ch == '(' ||
@@ -36,8 +37,8 @@ static inline bool IsGAPOperator(char ch) {
 	return false;
 }
 
-static void GetRange(unsigned int start, unsigned int end, Accessor &styler, char *s, unsigned int len) {
-	unsigned int i = 0;
+static void GetRange(Sci_PositionU start, Sci_PositionU end, Accessor &styler, char *s, Sci_PositionU len) {
+	Sci_PositionU i = 0;
 	while ((i < end - start + 1) && (i < len-1)) {
 		s[i] = static_cast<char>(styler[start + i]);
 		i++;
@@ -45,7 +46,7 @@ static void GetRange(unsigned int start, unsigned int end, Accessor &styler, cha
 	s[i] = '\0';
 }
 
-static void ColouriseGAPDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], Accessor &styler) {
+static void ColouriseGAPDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[], Accessor &styler) {
 
 	WordList &keywords1 = *keywordlists[0];
 	WordList &keywords2 = *keywordlists[1];
@@ -194,19 +195,19 @@ static int ClassifyFoldPointGAP(const char* s) {
 	return level;
 }
 
-static void FoldGAPDoc( unsigned int startPos, int length, int initStyle,   WordList** , Accessor &styler) {
-	unsigned int endPos = startPos + length;
+static void FoldGAPDoc( Sci_PositionU startPos, Sci_Position length, int initStyle,   WordList** , Accessor &styler) {
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
 	int style = initStyle;
 
-	int lastStart = 0;
+	Sci_Position lastStart = 0;
 
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int stylePrev = style;
diff --git a/Pythonwin/Scintilla/src/LexGui4Cli.cxx b/Pythonwin/Scintilla/lexers/LexGui4Cli.cxx
similarity index 91%
rename from Pythonwin/Scintilla/src/LexGui4Cli.cxx
rename to Pythonwin/Scintilla/lexers/LexGui4Cli.cxx
index 1c92de72e..664fa4f2f 100644
--- a/Pythonwin/Scintilla/src/LexGui4Cli.cxx
+++ b/Pythonwin/Scintilla/lexers/LexGui4Cli.cxx
@@ -1,13 +1,14 @@
 // Scintilla source code edit control
 // Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
+// @file LexGui4Cli.cxx
 /*
 This is the Lexer for Gui4Cli, included in SciLexer.dll
 - by d. Keletsekis, 2/10/2003
 
 To add to SciLexer.dll:
 1. Add the values below to INCLUDE\Scintilla.iface
-2. Run the include/HFacer.py script
-3. Run the src/lexGen.py script
+2. Run the scripts/HFacer.py script
+3. Run the scripts/LexGen.py script
 
 val SCE_GC_DEFAULT=0
 val SCE_GC_COMMENTLINE=1
@@ -23,22 +24,23 @@ val SCE_GC_OPERATOR=9
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 #define debug Platform::DebugPrintf
 
@@ -46,10 +48,6 @@ static inline bool IsAWordChar(const int ch) {
 	return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_' || ch =='\\');
 }
 
-static inline bool IsAWordStart(const int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.');
-}
-
 inline bool isGCOperator(int ch)
 {	if (isalnum(ch))
 		return false;
@@ -69,9 +67,9 @@ inline bool isGCOperator(int ch)
 #define isFoldPoint(x)  ((styler.LevelAt(x) & SC_FOLDLEVELNUMBERMASK) == 1024)
 
 static void colorFirstWord(WordList *keywordlists[], Accessor &styler,
-									StyleContext *sc, char *buff, int length, int)
+									StyleContext *sc, char *buff, Sci_Position length, Sci_Position)
 {
-	int c = 0;
+	Sci_Position c = 0;
 	while (sc->More() && isSpaceOrNL(sc->ch))
 	{	sc->Forward();
 	}
@@ -120,12 +118,13 @@ static void colorFirstWord(WordList *keywordlists[], Accessor &styler,
 
 // Main colorizing function called by Scintilla
 static void
-ColouriseGui4CliDoc(unsigned int startPos, int length, int initStyle,
+ColouriseGui4CliDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                     WordList *keywordlists[], Accessor &styler)
 {
 	styler.StartAt(startPos);
 
-	int quotestart = 0, oldstate, currentline = styler.GetLine(startPos);
+	Sci_Position currentline = styler.GetLine(startPos);
+	int quotestart = 0, oldstate;
 	styler.StartSegment(startPos);
 	bool noforward;
 	char buff[BUFFSIZE+1];	// buffer for command name
@@ -244,20 +243,20 @@ ColouriseGui4CliDoc(unsigned int startPos, int length, int initStyle,
 }
 
 // Main folding function called by Scintilla - (based on props (.ini) files function)
-static void FoldGui4Cli(unsigned int startPos, int length, int,
+static void FoldGui4Cli(Sci_PositionU startPos, Sci_Position length, int,
 								WordList *[], Accessor &styler)
 {
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
 
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
 	bool headerPoint = false;
 
-	for (unsigned int i = startPos; i < endPos; i++)
+	for (Sci_PositionU i = startPos; i < endPos; i++)
 	{
 		char ch = chNext;
 		chNext = styler[i+1];
diff --git a/Pythonwin/Scintilla/src/LexHTML.cxx b/Pythonwin/Scintilla/lexers/LexHTML.cxx
similarity index 57%
rename from Pythonwin/Scintilla/src/LexHTML.cxx
rename to Pythonwin/Scintilla/lexers/LexHTML.cxx
index 6d16c53f9..c6042f2b6 100644
--- a/Pythonwin/Scintilla/src/LexHTML.cxx
+++ b/Pythonwin/Scintilla/lexers/LexHTML.cxx
@@ -7,23 +7,29 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+#include <string>
+#include <map>
+#include <set>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
 #include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
+
+namespace {
 
 #define SCE_HA_JS (SCE_HJA_START - SCE_HJ_START)
 #define SCE_HA_VBS (SCE_HBA_START - SCE_HB_START)
@@ -32,16 +38,16 @@ using namespace Scintilla;
 enum script_type { eScriptNone = 0, eScriptJS, eScriptVBS, eScriptPython, eScriptPHP, eScriptXML, eScriptSGML, eScriptSGMLblock, eScriptComment };
 enum script_mode { eHtml = 0, eNonHtmlScript, eNonHtmlPreProc, eNonHtmlScriptPreProc };
 
-static inline bool IsAWordChar(const int ch) {
+inline bool IsAWordChar(const int ch) {
 	return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_');
 }
 
-static inline bool IsAWordStart(const int ch) {
+inline bool IsAWordStart(const int ch) {
 	return (ch < 0x80) && (isalnum(ch) || ch == '_');
 }
 
 inline bool IsOperator(int ch) {
-	if (isascii(ch) && isalnum(ch))
+	if (IsASCII(ch) && isalnum(ch))
 		return false;
 	// '.' left out as it is used to make up numbers
 	if (ch == '%' || ch == '^' || ch == '&' || ch == '*' ||
@@ -54,22 +60,38 @@ inline bool IsOperator(int ch) {
 	return false;
 }
 
-static inline int MakeLowerCase(int ch) {
-	if (ch < 'A' || ch > 'Z')
-		return ch;
-	else
-		return ch - 'A' + 'a';
-}
-
-static void GetTextSegment(Accessor &styler, unsigned int start, unsigned int end, char *s, size_t len) {
-	size_t i = 0;
+void GetTextSegment(Accessor &styler, Sci_PositionU start, Sci_PositionU end, char *s, size_t len) {
+	Sci_PositionU i = 0;
 	for (; (i < end - start + 1) && (i < len-1); i++) {
-		s[i] = static_cast<char>(MakeLowerCase(styler[start + i]));
+		s[i] = MakeLowerCase(styler[start + i]);
 	}
 	s[i] = '\0';
 }
 
-static script_type segIsScriptingIndicator(Accessor &styler, unsigned int start, unsigned int end, script_type prevValue) {
+std::string GetStringSegment(Accessor &styler, Sci_PositionU start, Sci_PositionU end) {
+	std::string s;
+	Sci_PositionU i = 0;
+	for (; (i < end - start + 1); i++) {
+		s.push_back(MakeLowerCase(styler[start + i]));
+	}
+	return s;
+}
+
+std::string GetNextWord(Accessor &styler, Sci_PositionU start) {
+	std::string ret;
+	Sci_PositionU i = 0;
+	for (; i < 200; i++) {	// Put an upper limit to bound time taken for unexpected text.
+		const char ch = styler.SafeGetCharAt(start + i);
+		if ((i == 0) && !IsAWordStart(ch))
+			break;
+		if ((i > 0) && !IsAWordChar(ch))
+			break;
+		ret.push_back(ch);
+	}
+	return ret;
+}
+
+script_type segIsScriptingIndicator(Accessor &styler, Sci_PositionU start, Sci_PositionU end, script_type prevValue) {
 	char s[100];
 	GetTextSegment(styler, start, end, s, sizeof(s));
 	//Platform::DebugPrintf("Scripting indicator [%s]\n", s);
@@ -98,18 +120,16 @@ static script_type segIsScriptingIndicator(Accessor &styler, unsigned int start,
 	return prevValue;
 }
 
-static int PrintScriptingIndicatorOffset(Accessor &styler, unsigned int start, unsigned int end) {
+int PrintScriptingIndicatorOffset(Accessor &styler, Sci_PositionU start, Sci_PositionU end) {
 	int iResult = 0;
-	char s[100];
-	GetTextSegment(styler, start, end, s, sizeof(s));
-	if (0 == strncmp(s, "php", 3)) {
+	std::string s = GetStringSegment(styler, start, end);
+	if (0 == strncmp(s.c_str(), "php", 3)) {
 		iResult = 3;
 	}
-
 	return iResult;
 }
 
-static script_type ScriptOfState(int state) {
+script_type ScriptOfState(int state) {
 	if ((state >= SCE_HP_START) && (state <= SCE_HP_IDENTIFIER)) {
 		return eScriptPython;
 	} else if ((state >= SCE_HB_START) && (state <= SCE_HB_STRINGEOL)) {
@@ -127,7 +147,7 @@ static script_type ScriptOfState(int state) {
 	}
 }
 
-static int statePrintForState(int state, script_mode inScriptType) {
+int statePrintForState(int state, script_mode inScriptType) {
 	int StateToPrint = state;
 
 	if (state >= SCE_HJ_START) {
@@ -143,7 +163,7 @@ static int statePrintForState(int state, script_mode inScriptType) {
 	return StateToPrint;
 }
 
-static int stateForPrintState(int StateToPrint) {
+int stateForPrintState(int StateToPrint) {
 	int state;
 
 	if ((StateToPrint >= SCE_HPA_START) && (StateToPrint <= SCE_HPA_IDENTIFIER)) {
@@ -159,12 +179,12 @@ static int stateForPrintState(int StateToPrint) {
 	return state;
 }
 
-static inline bool IsNumber(unsigned int start, Accessor &styler) {
+inline bool IsNumber(Sci_PositionU start, Accessor &styler) {
 	return IsADigit(styler[start]) || (styler[start] == '.') ||
 	       (styler[start] == '-') || (styler[start] == '#');
 }
 
-static inline bool isStringState(int state) {
+inline bool isStringState(int state) {
 	bool bResult;
 
 	switch (state) {
@@ -195,7 +215,7 @@ static inline bool isStringState(int state) {
 	return bResult;
 }
 
-static inline bool stateAllowsTermination(int state) {
+inline bool stateAllowsTermination(int state) {
 	bool allowTermination = !isStringState(state);
 	if (allowTermination) {
 		switch (state) {
@@ -210,7 +230,7 @@ static inline bool stateAllowsTermination(int state) {
 }
 
 // not really well done, since it's only comments that should lex the %> and <%
-static inline bool isCommentASPState(int state) {
+inline bool isCommentASPState(int state) {
 	bool bResult;
 
 	switch (state) {
@@ -230,15 +250,14 @@ static inline bool isCommentASPState(int state) {
 	return bResult;
 }
 
-static void classifyAttribHTML(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler) {
-	bool wordIsNumber = IsNumber(start, styler);
+void classifyAttribHTML(Sci_PositionU start, Sci_PositionU end, const WordList &keywords, Accessor &styler) {
+	const bool wordIsNumber = IsNumber(start, styler);
 	char chAttr = SCE_H_ATTRIBUTEUNKNOWN;
 	if (wordIsNumber) {
 		chAttr = SCE_H_NUMBER;
 	} else {
-		char s[100];
-		GetTextSegment(styler, start, end, s, sizeof(s));
-		if (keywords.InList(s))
+		std::string s = GetStringSegment(styler, start, end);
+		if (keywords.InList(s.c_str()))
 			chAttr = SCE_H_ATTRIBUTE;
 	}
 	if ((chAttr == SCE_H_ATTRIBUTEUNKNOWN) && !keywords)
@@ -247,81 +266,103 @@ static void classifyAttribHTML(unsigned int start, unsigned int end, WordList &k
 	styler.ColourTo(end, chAttr);
 }
 
-static int classifyTagHTML(unsigned int start, unsigned int end,
-                           WordList &keywords, Accessor &styler, bool &tagDontFold,
-			   bool caseSensitive, bool isXml, bool allowScripts) {
-	char s[30 + 2];
-	// Copy after the '<'
-	unsigned int i = 0;
-	for (unsigned int cPos = start; cPos <= end && i < 30; cPos++) {
-		char ch = styler[cPos];
+// https://html.spec.whatwg.org/multipage/custom-elements.html#custom-elements-core-concepts
+bool isHTMLCustomElement(const std::string &tag) {
+	// check valid HTML custom element name: starts with an ASCII lower alpha and contains hyphen.
+	// IsUpperOrLowerCase() is used for `html.tags.case.sensitive=1`.
+	if (tag.length() < 2 || !IsUpperOrLowerCase(tag[0])) {
+		return false;
+	}
+	if (tag.find('-') == std::string::npos) {
+		return false;
+	}
+	return true;
+}
+
+int classifyTagHTML(Sci_PositionU start, Sci_PositionU end,
+                           const WordList &keywords, Accessor &styler, bool &tagDontFold,
+                    bool caseSensitive, bool isXml, bool allowScripts,
+                    const std::set<std::string> &nonFoldingTags) {
+	std::string tag;
+	// Copy after the '<' and stop before ' '
+	for (Sci_PositionU cPos = start; cPos <= end; cPos++) {
+		const char ch = styler[cPos];
+		if (IsASpace(ch)) {
+			break;
+		}
 		if ((ch != '<') && (ch != '/')) {
-			s[i++] = caseSensitive ? ch : static_cast<char>(MakeLowerCase(ch));
+			tag.push_back(caseSensitive ? ch : MakeLowerCase(ch));
 		}
 	}
-
-	//The following is only a quick hack, to see if this whole thing would work
-	//we first need the tagname with a trailing space...
-	s[i] = ' ';
-	s[i+1] = '\0';
-
 	// if the current language is XML, I can fold any tag
 	// if the current language is HTML, I don't want to fold certain tags (input, meta, etc.)
 	//...to find it in the list of no-container-tags
-	tagDontFold = (!isXml) && (NULL != strstr("meta link img area br hr input ", s));
-
-	//now we can remove the trailing space
-	s[i] = '\0';
-
+	tagDontFold = (!isXml) && (nonFoldingTags.count(tag) > 0);
 	// No keywords -> all are known
-	// Name of a closing tag starts at s + 1
 	char chAttr = SCE_H_TAGUNKNOWN;
-	if (s[0] == '!') {
+	if (!tag.empty() && (tag[0] == '!')) {
 		chAttr = SCE_H_SGML_DEFAULT;
-	} else if (!keywords || keywords.InList(s[0] == '/' ? s + 1 : s)) {
+	} else if (!keywords || keywords.InList(tag.c_str())) {
+		chAttr = SCE_H_TAG;
+	} else if (!isXml && isHTMLCustomElement(tag)) {
 		chAttr = SCE_H_TAG;
 	}
-	styler.ColourTo(end, chAttr);
+	if (chAttr != SCE_H_TAGUNKNOWN) {
+		styler.ColourTo(end, chAttr);
+	}
 	if (chAttr == SCE_H_TAG) {
-		if (allowScripts && 0 == strcmp(s, "script")) {
-			chAttr = SCE_H_SCRIPT;
-		} else if (!isXml && 0 == strcmp(s, "comment")) {
+		if (allowScripts && (tag == "script")) {
+			// check to see if this is a self-closing tag by sniffing ahead
+			bool isSelfClose = false;
+			for (Sci_PositionU cPos = end; cPos <= end + 200; cPos++) {
+				const char ch = styler.SafeGetCharAt(cPos, '\0');
+				if (ch == '\0' || ch == '>')
+					break;
+				else if (ch == '/' && styler.SafeGetCharAt(cPos + 1, '\0') == '>') {
+					isSelfClose = true;
+					break;
+				}
+			}
+
+			// do not enter a script state if the tag self-closed
+			if (!isSelfClose)
+				chAttr = SCE_H_SCRIPT;
+		} else if (!isXml && (tag == "comment")) {
 			chAttr = SCE_H_COMMENT;
 		}
 	}
 	return chAttr;
 }
 
-static void classifyWordHTJS(unsigned int start, unsigned int end,
-                             WordList &keywords, Accessor &styler, script_mode inScriptType) {
+void classifyWordHTJS(Sci_PositionU start, Sci_PositionU end,
+                             const WordList &keywords, Accessor &styler, script_mode inScriptType) {
+	char s[30 + 1];
+	Sci_PositionU i = 0;
+	for (; i < end - start + 1 && i < 30; i++) {
+		s[i] = styler[start + i];
+	}
+	s[i] = '\0';
+
 	char chAttr = SCE_HJ_WORD;
-	bool wordIsNumber = IsADigit(styler[start]) || (styler[start] == '.');
-	if (wordIsNumber)
+	const bool wordIsNumber = IsADigit(s[0]) || ((s[0] == '.') && IsADigit(s[1]));
+	if (wordIsNumber) {
 		chAttr = SCE_HJ_NUMBER;
-	else {
-		char s[30 + 1];
-		unsigned int i = 0;
-		for (; i < end - start + 1 && i < 30; i++) {
-			s[i] = styler[start + i];
-		}
-		s[i] = '\0';
-		if (keywords.InList(s))
-			chAttr = SCE_HJ_KEYWORD;
+	} else if (keywords.InList(s)) {
+		chAttr = SCE_HJ_KEYWORD;
 	}
 	styler.ColourTo(end, statePrintForState(chAttr, inScriptType));
 }
 
-static int classifyWordHTVB(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler, script_mode inScriptType) {
+int classifyWordHTVB(Sci_PositionU start, Sci_PositionU end, const WordList &keywords, Accessor &styler, script_mode inScriptType) {
 	char chAttr = SCE_HB_IDENTIFIER;
-	bool wordIsNumber = IsADigit(styler[start]) || (styler[start] == '.');
-	if (wordIsNumber)
+	const bool wordIsNumber = IsADigit(styler[start]) || (styler[start] == '.');
+	if (wordIsNumber) {
 		chAttr = SCE_HB_NUMBER;
-	else {
-		char s[100];
-		GetTextSegment(styler, start, end, s, sizeof(s));
-		if (keywords.InList(s)) {
+	} else {
+		std::string s = GetStringSegment(styler, start, end);
+		if (keywords.InList(s.c_str())) {
 			chAttr = SCE_HB_WORD;
-			if (strcmp(s, "rem") == 0)
+			if (s == "rem")
 				chAttr = SCE_HB_COMMENTLINE;
 		}
 	}
@@ -332,65 +373,60 @@ static int classifyWordHTVB(unsigned int start, unsigned int end, WordList &keyw
 		return SCE_HB_DEFAULT;
 }
 
-static void classifyWordHTPy(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler, char *prevWord, script_mode inScriptType) {
-	bool wordIsNumber = IsADigit(styler[start]);
-	char s[30 + 1];
-	unsigned int i = 0;
-	for (; i < end - start + 1 && i < 30; i++) {
-		s[i] = styler[start + i];
+void classifyWordHTPy(Sci_PositionU start, Sci_PositionU end, const WordList &keywords, Accessor &styler, std::string &prevWord, script_mode inScriptType, bool isMako) {
+	const bool wordIsNumber = IsADigit(styler[start]);
+	std::string s;
+	for (Sci_PositionU i = 0; i < end - start + 1 && i < 30; i++) {
+		s.push_back(styler[start + i]);
 	}
-	s[i] = '\0';
 	char chAttr = SCE_HP_IDENTIFIER;
-	if (0 == strcmp(prevWord, "class"))
+	if (prevWord == "class")
 		chAttr = SCE_HP_CLASSNAME;
-	else if (0 == strcmp(prevWord, "def"))
+	else if (prevWord == "def")
 		chAttr = SCE_HP_DEFNAME;
 	else if (wordIsNumber)
 		chAttr = SCE_HP_NUMBER;
-	else if (keywords.InList(s))
+	else if (keywords.InList(s.c_str()))
+		chAttr = SCE_HP_WORD;
+	else if (isMako && (s == "block"))
 		chAttr = SCE_HP_WORD;
 	styler.ColourTo(end, statePrintForState(chAttr, inScriptType));
-	strcpy(prevWord, s);
+	prevWord = s;
 }
 
 // Update the word colour to default or keyword
 // Called when in a PHP word
-static void classifyWordHTPHP(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler) {
+void classifyWordHTPHP(Sci_PositionU start, Sci_PositionU end, const WordList &keywords, Accessor &styler) {
 	char chAttr = SCE_HPHP_DEFAULT;
-	bool wordIsNumber = IsADigit(styler[start]) || (styler[start] == '.' && start+1 <= end && IsADigit(styler[start+1]));
-	if (wordIsNumber)
+	const bool wordIsNumber = IsADigit(styler[start]) || (styler[start] == '.' && start+1 <= end && IsADigit(styler[start+1]));
+	if (wordIsNumber) {
 		chAttr = SCE_HPHP_NUMBER;
-	else {
-		char s[100];
-		GetTextSegment(styler, start, end, s, sizeof(s));
-		if (keywords.InList(s))
+	} else {
+		std::string s = GetStringSegment(styler, start, end);
+		if (keywords.InList(s.c_str()))
 			chAttr = SCE_HPHP_WORD;
 	}
 	styler.ColourTo(end, chAttr);
 }
 
-static bool isWordHSGML(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler) {
-	char s[30 + 1];
-	unsigned int i = 0;
-	for (; i < end - start + 1 && i < 30; i++) {
-		s[i] = styler[start + i];
+bool isWordHSGML(Sci_PositionU start, Sci_PositionU end, const WordList &keywords, Accessor &styler) {
+	std::string s;
+	for (Sci_PositionU i = 0; i < end - start + 1 && i < 30; i++) {
+		s.push_back(styler[start + i]);
 	}
-	s[i] = '\0';
-	return keywords.InList(s);
+	return keywords.InList(s.c_str());
 }
 
-static bool isWordCdata(unsigned int start, unsigned int end, Accessor &styler) {
-	char s[30 + 1];
-	unsigned int i = 0;
-	for (; i < end - start + 1 && i < 30; i++) {
-		s[i] = styler[start + i];
+bool isWordCdata(Sci_PositionU start, Sci_PositionU end, Accessor &styler) {
+	std::string s;
+	for (Sci_PositionU i = 0; i < end - start + 1 && i < 30; i++) {
+		s.push_back(styler[start + i]);
 	}
-	s[i] = '\0';
-	return (0 == strcmp(s, "[CDATA["));
+	return s == "[CDATA[";
 }
 
 // Return the first state to reach when entering a scripting language
-static int StateForScript(script_type scriptLanguage) {
+int StateForScript(script_type scriptLanguage) {
 	int Result;
 	switch (scriptLanguage) {
 	case eScriptVBS:
@@ -418,25 +454,20 @@ static int StateForScript(script_type scriptLanguage) {
 	return Result;
 }
 
-static inline bool ishtmlwordchar(int ch) {
-	return !isascii(ch) ||
-		(isalnum(ch) || ch == '.' || ch == '-' || ch == '_' || ch == ':' || ch == '!' || ch == '#');
-}
-
-static inline bool issgmlwordchar(int ch) {
-	return !isascii(ch) ||
+inline bool issgmlwordchar(int ch) {
+	return !IsASCII(ch) ||
 		(isalnum(ch) || ch == '.' || ch == '_' || ch == ':' || ch == '!' || ch == '#' || ch == '[');
 }
 
-static inline bool IsPhpWordStart(int ch) {
-	return (isascii(ch) && (isalpha(ch) || (ch == '_'))) || (ch >= 0x7f);
+inline bool IsPhpWordStart(int ch) {
+	return (IsASCII(ch) && (isalpha(ch) || (ch == '_'))) || (ch >= 0x7f);
 }
 
-static inline bool IsPhpWordChar(int ch) {
+inline bool IsPhpWordChar(int ch) {
 	return IsADigit(ch) || IsPhpWordStart(ch);
 }
 
-static bool InTagState(int state) {
+bool InTagState(int state) {
 	return state == SCE_H_TAG || state == SCE_H_TAGUNKNOWN ||
 	       state == SCE_H_SCRIPT ||
 	       state == SCE_H_ATTRIBUTE || state == SCE_H_ATTRIBUTEUNKNOWN ||
@@ -444,24 +475,52 @@ static bool InTagState(int state) {
 	       state == SCE_H_DOUBLESTRING || state == SCE_H_SINGLESTRING;
 }
 
-static bool IsCommentState(const int state) {
+bool IsCommentState(const int state) {
 	return state == SCE_H_COMMENT || state == SCE_H_SGML_COMMENT;
 }
 
-static bool IsScriptCommentState(const int state) {
+bool IsScriptCommentState(const int state) {
 	return state == SCE_HJ_COMMENT || state == SCE_HJ_COMMENTLINE || state == SCE_HJA_COMMENT ||
 		   state == SCE_HJA_COMMENTLINE || state == SCE_HB_COMMENTLINE || state == SCE_HBA_COMMENTLINE;
 }
 
-static bool isLineEnd(int ch) {
+bool isLineEnd(int ch) {
 	return ch == '\r' || ch == '\n';
 }
 
-static bool isOKBeforeRE(int ch) {
-	return (ch == '(') || (ch == '=') || (ch == ',');
+bool isMakoBlockEnd(const int ch, const int chNext, const std::string &blockType) {
+	if (blockType.empty()) {
+		return ((ch == '%') && (chNext == '>'));
+	} else if ((blockType == "inherit") ||
+			   (blockType == "namespace") ||
+			   (blockType == "include") ||
+			   (blockType == "page")) {
+		return ((ch == '/') && (chNext == '>'));
+	} else if (blockType == "%") {
+		if (ch == '/' && isLineEnd(chNext))
+			return true;
+		else
+			return isLineEnd(ch);
+	} else if (blockType == "{") {
+		return ch == '}';
+	} else {
+		return (ch == '>');
+	}
+}
+
+bool isDjangoBlockEnd(const int ch, const int chNext, const std::string &blockType) {
+	if (blockType.empty()) {
+		return false;
+	} else if (blockType == "%") {
+		return ((ch == '%') && (chNext == '}'));
+	} else if (blockType == "{") {
+		return ((ch == '}') && (chNext == '}'));
+	} else {
+		return false;
+	}
 }
 
-static bool isPHPStringState(int state) {
+bool isPHPStringState(int state) {
 	return
 	    (state == SCE_HPHP_HSTRING) ||
 	    (state == SCE_HPHP_SIMPLESTRING) ||
@@ -469,29 +528,27 @@ static bool isPHPStringState(int state) {
 	    (state == SCE_HPHP_COMPLEX_VARIABLE);
 }
 
-static int FindPhpStringDelimiter(char *phpStringDelimiter, const int phpStringDelimiterSize, int i, const int lengthDoc, Accessor &styler, bool &isSimpleString) {
-	int j;
-	const int beginning = i - 1;
+Sci_Position FindPhpStringDelimiter(std::string &phpStringDelimiter, Sci_Position i, const Sci_Position lengthDoc, Accessor &styler, bool &isSimpleString) {
+	Sci_Position j;
+	const Sci_Position beginning = i - 1;
 	bool isValidSimpleString = false;
 
 	while (i < lengthDoc && (styler[i] == ' ' || styler[i] == '\t'))
 		i++;
-
 	char ch = styler.SafeGetCharAt(i);
 	const char chNext = styler.SafeGetCharAt(i + 1);
+	phpStringDelimiter.clear();
 	if (!IsPhpWordStart(ch)) {
 		if (ch == '\'' && IsPhpWordStart(chNext)) {
 			i++;
 			ch = chNext;
 			isSimpleString = true;
 		} else {
-			phpStringDelimiter[0] = '\0';
 			return beginning;
 		}
 	}
-	phpStringDelimiter[0] = ch;
+	phpStringDelimiter.push_back(ch);
 	i++;
-
 	for (j = i; j < lengthDoc && !isLineEnd(styler[j]); j++) {
 		if (!IsPhpWordChar(styler[j])) {
 			if (isSimpleString && (styler[j] == '\'') && isLineEnd(styler.SafeGetCharAt(j + 1))) {
@@ -499,46 +556,417 @@ static int FindPhpStringDelimiter(char *phpStringDelimiter, const int phpStringD
 				j++;
 				break;
 			} else {
-				phpStringDelimiter[0] = '\0';
+				phpStringDelimiter.clear();
 				return beginning;
 			}
 		}
-		if (j - i < phpStringDelimiterSize - 2)
-			phpStringDelimiter[j-i+1] = styler[j];
-		else
-			i++;
+		phpStringDelimiter.push_back(styler[j]);
 	}
 	if (isSimpleString && !isValidSimpleString) {
-		phpStringDelimiter[0] = '\0';
+		phpStringDelimiter.clear();
 		return beginning;
 	}
-	phpStringDelimiter[j-i+1 - (isSimpleString ? 1 : 0)] = '\0';
 	return j - 1;
 }
 
-static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                                  Accessor &styler, bool isXml) {
-	WordList &keywords = *keywordlists[0];
-	WordList &keywords2 = *keywordlists[1];
-	WordList &keywords3 = *keywordlists[2];
-	WordList &keywords4 = *keywordlists[3];
-	WordList &keywords5 = *keywordlists[4];
-	WordList &keywords6 = *keywordlists[5]; // SGML (DTD) keywords
-
-	// Lexer for HTML requires more lexical states (8 bits worth) than most lexers
-	styler.StartAt(startPos, static_cast<char>(STYLE_MAX));
-	char prevWord[200];
-	prevWord[0] = '\0';
-	char phpStringDelimiter[200]; // PHP is not limited in length, we are
-	phpStringDelimiter[0] = '\0';
+// Options used for LexerHTML
+struct OptionsHTML {
+	int aspDefaultLanguage = eScriptJS;
+	bool caseSensitive = false;
+	bool allowScripts = true;
+	bool isMako = false;
+	bool isDjango = false;
+	bool fold = false;
+	bool foldHTML = false;
+	bool foldHTMLPreprocessor = true;
+	bool foldCompact = true;
+	bool foldComment = false;
+	bool foldHeredoc = false;
+	bool foldXmlAtTagOpen = false;
+	OptionsHTML() noexcept {
+	}
+};
+
+const char * const htmlWordListDesc[] = {
+	"HTML elements and attributes",
+	"JavaScript keywords",
+	"VBScript keywords",
+	"Python keywords",
+	"PHP keywords",
+	"SGML and DTD keywords",
+	0,
+};
+
+const char * const phpscriptWordListDesc[] = {
+	"", //Unused
+	"", //Unused
+	"", //Unused
+	"", //Unused
+	"PHP keywords",
+	"", //Unused
+	0,
+};
+
+struct OptionSetHTML : public OptionSet<OptionsHTML> {
+	OptionSetHTML(bool isPHPScript_) {
+
+		DefineProperty("asp.default.language", &OptionsHTML::aspDefaultLanguage,
+			"Script in ASP code is initially assumed to be in JavaScript. "
+			"To change this to VBScript set asp.default.language to 2. Python is 3.");
+
+		DefineProperty("html.tags.case.sensitive", &OptionsHTML::caseSensitive,
+			"For XML and HTML, setting this property to 1 will make tags match in a case "
+			"sensitive way which is the expected behaviour for XML and XHTML.");
+
+		DefineProperty("lexer.xml.allow.scripts", &OptionsHTML::allowScripts,
+			"Set to 0 to disable scripts in XML.");
+
+		DefineProperty("lexer.html.mako", &OptionsHTML::isMako,
+			"Set to 1 to enable the mako template language.");
+
+		DefineProperty("lexer.html.django", &OptionsHTML::isDjango,
+			"Set to 1 to enable the django template language.");
+
+		DefineProperty("fold", &OptionsHTML::fold);
+
+		DefineProperty("fold.html", &OptionsHTML::foldHTML,
+			"Folding is turned on or off for HTML and XML files with this option. "
+			"The fold option must also be on for folding to occur.");
+
+		DefineProperty("fold.html.preprocessor", &OptionsHTML::foldHTMLPreprocessor,
+			"Folding is turned on or off for scripts embedded in HTML files with this option. "
+			"The default is on.");
+
+		DefineProperty("fold.compact", &OptionsHTML::foldCompact);
+
+		DefineProperty("fold.hypertext.comment", &OptionsHTML::foldComment,
+			"Allow folding for comments in scripts embedded in HTML. "
+			"The default is off.");
+
+		DefineProperty("fold.hypertext.heredoc", &OptionsHTML::foldHeredoc,
+			"Allow folding for heredocs in scripts embedded in HTML. "
+			"The default is off.");
+
+		DefineProperty("fold.xml.at.tag.open", &OptionsHTML::foldXmlAtTagOpen,
+			"Enable folding for XML at the start of open tag. "
+			"The default is off.");
+
+		DefineWordListSets(isPHPScript_ ? phpscriptWordListDesc : htmlWordListDesc);
+	}
+};
+
+LexicalClass lexicalClassesHTML[] = {
+	// Lexer HTML SCLEX_HTML SCE_H_ SCE_HJ_ SCE_HJA_ SCE_HB_ SCE_HBA_ SCE_HP_ SCE_HPHP_ SCE_HPA_:
+	0, "SCE_H_DEFAULT", "default", "Text",
+	1, "SCE_H_TAG", "tag", "Tags",
+	2, "SCE_H_ERRORTAGUNKNOWN", "error tag", "Unknown Tags",
+	3, "SCE_H_ATTRIBUTE", "attribute", "Attributes",
+	4, "SCE_H_ATTRIBUTEUNKNOWN", "error attribute", "Unknown Attributes",
+	5, "SCE_H_NUMBER", "literal numeric", "Numbers",
+	6, "SCE_H_DOUBLESTRING", "literal string", "Double quoted strings",
+	7, "SCE_H_SINGLESTRING", "literal string", "Single quoted strings",
+	8, "SCE_H_OTHER", "tag operator", "Other inside tag, including space and '='",
+	9, "SCE_H_COMMENT", "comment", "Comment",
+	10, "SCE_H_ENTITY", "literal", "Entities",
+	11, "SCE_H_TAGEND", "tag", "XML style tag ends '/>'",
+	12, "SCE_H_XMLSTART", "identifier", "XML identifier start '<?'",
+	13, "SCE_H_XMLEND", "identifier", "XML identifier end '?>'",
+	14, "SCE_H_SCRIPT", "error", "Internal state which should never be visible",
+	15, "SCE_H_ASP", "preprocessor", "ASP <% ... %>",
+	16, "SCE_H_ASPAT", "preprocessor", "ASP <% ... %>",
+	17, "SCE_H_CDATA", "literal", "CDATA",
+	18, "SCE_H_QUESTION", "preprocessor", "PHP",
+	19, "SCE_H_VALUE", "literal string", "Unquoted values",
+	20, "SCE_H_XCCOMMENT", "comment", "JSP Comment <%-- ... --%>",
+	21, "SCE_H_SGML_DEFAULT", "default", "SGML tags <! ... >",
+	22, "SCE_H_SGML_COMMAND", "preprocessor", "SGML command",
+	23, "SCE_H_SGML_1ST_PARAM", "preprocessor", "SGML 1st param",
+	24, "SCE_H_SGML_DOUBLESTRING", "literal string", "SGML double string",
+	25, "SCE_H_SGML_SIMPLESTRING", "literal string", "SGML single string",
+	26, "SCE_H_SGML_ERROR", "error", "SGML error",
+	27, "SCE_H_SGML_SPECIAL", "literal", "SGML special (#XXXX type)",
+	28, "SCE_H_SGML_ENTITY", "literal", "SGML entity",
+	29, "SCE_H_SGML_COMMENT", "comment", "SGML comment",
+	30, "SCE_H_SGML_1ST_PARAM_COMMENT", "error comment", "SGML first parameter - lexer internal. It is an error if any text is in this style.",
+	31, "SCE_H_SGML_BLOCK_DEFAULT", "default", "SGML block",
+	32, "", "predefined", "",
+	33, "", "predefined", "",
+	34, "", "predefined", "",
+	35, "", "predefined", "",
+	36, "", "predefined", "",
+	37, "", "predefined", "",
+	38, "", "predefined", "",
+	39, "", "predefined", "",
+	40, "SCE_HJ_START", "client javascript default", "JS Start - allows eol filled background to not start on same line as SCRIPT tag",
+	41, "SCE_HJ_DEFAULT", "client javascript default", "JS Default",
+	42, "SCE_HJ_COMMENT", "client javascript comment", "JS Comment",
+	43, "SCE_HJ_COMMENTLINE", "client javascript comment line", "JS Line Comment",
+	44, "SCE_HJ_COMMENTDOC", "client javascript comment documentation", "JS Doc comment",
+	45, "SCE_HJ_NUMBER", "client javascript literal numeric", "JS Number",
+	46, "SCE_HJ_WORD", "client javascript identifier", "JS Word",
+	47, "SCE_HJ_KEYWORD", "client javascript keyword", "JS Keyword",
+	48, "SCE_HJ_DOUBLESTRING", "client javascript literal string", "JS Double quoted string",
+	49, "SCE_HJ_SINGLESTRING", "client javascript literal string", "JS Single quoted string",
+	50, "SCE_HJ_SYMBOLS", "client javascript operator", "JS Symbols",
+	51, "SCE_HJ_STRINGEOL", "client javascript error literal string", "JavaScript EOL",
+	52, "SCE_HJ_REGEX", "client javascript literal regex", "JavaScript RegEx",
+	53, "", "unused", "",
+	54, "", "unused", "",
+	55, "SCE_HJA_START", "server javascript default", "JS Start - allows eol filled background to not start on same line as SCRIPT tag",
+	56, "SCE_HJA_DEFAULT", "server javascript default", "JS Default",
+	57, "SCE_HJA_COMMENT", "server javascript comment", "JS Comment",
+	58, "SCE_HJA_COMMENTLINE", "server javascript comment line", "JS Line Comment",
+	59, "SCE_HJA_COMMENTDOC", "server javascript comment documentation", "JS Doc comment",
+	60, "SCE_HJA_NUMBER", "server javascript literal numeric", "JS Number",
+	61, "SCE_HJA_WORD", "server javascript identifier", "JS Word",
+	62, "SCE_HJA_KEYWORD", "server javascript keyword", "JS Keyword",
+	63, "SCE_HJA_DOUBLESTRING", "server javascript literal string", "JS Double quoted string",
+	64, "SCE_HJA_SINGLESTRING", "server javascript literal string", "JS Single quoted string",
+	65, "SCE_HJA_SYMBOLS", "server javascript operator", "JS Symbols",
+	66, "SCE_HJA_STRINGEOL", "server javascript error literal string", "JavaScript EOL",
+	67, "SCE_HJA_REGEX", "server javascript literal regex", "JavaScript RegEx",
+	68, "", "unused", "",
+	69, "", "unused", "",
+	70, "SCE_HB_START", "client basic default", "Start",
+	71, "SCE_HB_DEFAULT", "client basic default", "Default",
+	72, "SCE_HB_COMMENTLINE", "client basic comment line", "Comment",
+	73, "SCE_HB_NUMBER", "client basic literal numeric", "Number",
+	74, "SCE_HB_WORD", "client basic keyword", "KeyWord",
+	75, "SCE_HB_STRING", "client basic literal string", "String",
+	76, "SCE_HB_IDENTIFIER", "client basic identifier", "Identifier",
+	77, "SCE_HB_STRINGEOL", "client basic literal string", "Unterminated string",
+	78, "", "unused", "",
+	79, "", "unused", "",
+	80, "SCE_HBA_START", "server basic default", "Start",
+	81, "SCE_HBA_DEFAULT", "server basic default", "Default",
+	82, "SCE_HBA_COMMENTLINE", "server basic comment line", "Comment",
+	83, "SCE_HBA_NUMBER", "server basic literal numeric", "Number",
+	84, "SCE_HBA_WORD", "server basic keyword", "KeyWord",
+	85, "SCE_HBA_STRING", "server basic literal string", "String",
+	86, "SCE_HBA_IDENTIFIER", "server basic identifier", "Identifier",
+	87, "SCE_HBA_STRINGEOL", "server basic literal string", "Unterminated string",
+	88, "", "unused", "",
+	89, "", "unused", "",
+	90, "SCE_HP_START", "client python default", "Embedded Python",
+	91, "SCE_HP_DEFAULT", "client python default", "Embedded Python",
+	92, "SCE_HP_COMMENTLINE", "client python comment line", "Comment",
+	93, "SCE_HP_NUMBER", "client python literal numeric", "Number",
+	94, "SCE_HP_STRING", "client python literal string", "String",
+	95, "SCE_HP_CHARACTER", "client python literal string character", "Single quoted string",
+	96, "SCE_HP_WORD", "client python keyword", "Keyword",
+	97, "SCE_HP_TRIPLE", "client python literal string", "Triple quotes",
+	98, "SCE_HP_TRIPLEDOUBLE", "client python literal string", "Triple double quotes",
+	99, "SCE_HP_CLASSNAME", "client python identifier", "Class name definition",
+	100, "SCE_HP_DEFNAME", "client python identifier", "Function or method name definition",
+	101, "SCE_HP_OPERATOR", "client python operator", "Operators",
+	102, "SCE_HP_IDENTIFIER", "client python identifier", "Identifiers",
+	103, "", "unused", "",
+	104, "SCE_HPHP_COMPLEX_VARIABLE", "server php identifier", "PHP complex variable",
+	105, "SCE_HPA_START", "server python default", "ASP Python",
+	106, "SCE_HPA_DEFAULT", "server python default", "ASP Python",
+	107, "SCE_HPA_COMMENTLINE", "server python comment line", "Comment",
+	108, "SCE_HPA_NUMBER", "server python literal numeric", "Number",
+	109, "SCE_HPA_STRING", "server python literal string", "String",
+	110, "SCE_HPA_CHARACTER", "server python literal string character", "Single quoted string",
+	111, "SCE_HPA_WORD", "server python keyword", "Keyword",
+	112, "SCE_HPA_TRIPLE", "server python literal string", "Triple quotes",
+	113, "SCE_HPA_TRIPLEDOUBLE", "server python literal string", "Triple double quotes",
+	114, "SCE_HPA_CLASSNAME", "server python identifier", "Class name definition",
+	115, "SCE_HPA_DEFNAME", "server python identifier", "Function or method name definition",
+	116, "SCE_HPA_OPERATOR", "server python operator", "Operators",
+	117, "SCE_HPA_IDENTIFIER", "server python identifier", "Identifiers",
+	118, "SCE_HPHP_DEFAULT", "server php default", "Default",
+	119, "SCE_HPHP_HSTRING", "server php literal string", "Double quoted String",
+	120, "SCE_HPHP_SIMPLESTRING", "server php literal string", "Single quoted string",
+	121, "SCE_HPHP_WORD", "server php keyword", "Keyword",
+	122, "SCE_HPHP_NUMBER", "server php literal numeric", "Number",
+	123, "SCE_HPHP_VARIABLE", "server php identifier", "Variable",
+	124, "SCE_HPHP_COMMENT", "server php comment", "Comment",
+	125, "SCE_HPHP_COMMENTLINE", "server php comment line", "One line comment",
+	126, "SCE_HPHP_HSTRING_VARIABLE", "server php literal string identifier", "PHP variable in double quoted string",
+	127, "SCE_HPHP_OPERATOR", "server php operator", "PHP operator",
+};
+
+LexicalClass lexicalClassesXML[] = {
+	// Lexer.Secondary XML SCLEX_XML SCE_H_:
+	0, "SCE_H_DEFAULT", "default", "Default",
+	1, "SCE_H_TAG", "tag", "Tags",
+	2, "SCE_H_TAGUNKNOWN", "error tag", "Unknown Tags",
+	3, "SCE_H_ATTRIBUTE", "attribute", "Attributes",
+	4, "SCE_H_ERRORATTRIBUTEUNKNOWN", "error attribute", "Unknown Attributes",
+	5, "SCE_H_NUMBER", "literal numeric", "Numbers",
+	6, "SCE_H_DOUBLESTRING", "literal string", "Double quoted strings",
+	7, "SCE_H_SINGLESTRING", "literal string", "Single quoted strings",
+	8, "SCE_H_OTHER", "tag operator", "Other inside tag, including space and '='",
+	9, "SCE_H_COMMENT", "comment", "Comment",
+	10, "SCE_H_ENTITY", "literal", "Entities",
+	11, "SCE_H_TAGEND", "tag", "XML style tag ends '/>'",
+	12, "SCE_H_XMLSTART", "identifier", "XML identifier start '<?'",
+	13, "SCE_H_XMLEND", "identifier", "XML identifier end '?>'",
+	14, "", "unused", "",
+	15, "", "unused", "",
+	16, "", "unused", "",
+	17, "SCE_H_CDATA", "literal", "CDATA",
+	18, "SCE_H_QUESTION", "preprocessor", "Question",
+	19, "SCE_H_VALUE", "literal string", "Unquoted Value",
+	20, "", "unused", "",
+	21, "SCE_H_SGML_DEFAULT", "default", "SGML tags <! ... >",
+	22, "SCE_H_SGML_COMMAND", "preprocessor", "SGML command",
+	23, "SCE_H_SGML_1ST_PARAM", "preprocessor", "SGML 1st param",
+	24, "SCE_H_SGML_DOUBLESTRING", "literal string", "SGML double string",
+	25, "SCE_H_SGML_SIMPLESTRING", "literal string", "SGML single string",
+	26, "SCE_H_SGML_ERROR", "error", "SGML error",
+	27, "SCE_H_SGML_SPECIAL", "literal", "SGML special (#XXXX type)",
+	28, "SCE_H_SGML_ENTITY", "literal", "SGML entity",
+	29, "SCE_H_SGML_COMMENT", "comment", "SGML comment",
+	30, "", "unused", "",
+	31, "SCE_H_SGML_BLOCK_DEFAULT", "default", "SGML block",
+};
+
+const char *tagsThatDoNotFold[] = {
+	"area",
+	"base",
+	"basefont",
+	"br",
+	"col",
+	"command",
+	"embed",
+	"frame",
+	"hr",
+	"img",
+	"input",
+	"isindex",
+	"keygen",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+};
+
+}
+
+class LexerHTML : public DefaultLexer {
+	bool isXml;
+	bool isPHPScript;
+	WordList keywords;
+	WordList keywords2;
+	WordList keywords3;
+	WordList keywords4;
+	WordList keywords5;
+	WordList keywords6; // SGML (DTD) keywords
+	OptionsHTML options;
+	OptionSetHTML osHTML;
+	std::set<std::string> nonFoldingTags;
+public:
+	explicit LexerHTML(bool isXml_, bool isPHPScript_) :
+		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_),
+		osHTML(isPHPScript_),
+		nonFoldingTags(std::begin(tagsThatDoNotFold), std::end(tagsThatDoNotFold)) {
+	}
+	~LexerHTML() override {
+	}
+	void SCI_METHOD Release() override {
+		delete this;
+	}
+	const char *SCI_METHOD PropertyNames() override {
+		return osHTML.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return osHTML.PropertyType(name);
+	}
+	const char *SCI_METHOD DescribeProperty(const char *name) override {
+		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();
+	}
+	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;
+	// No Fold as all folding performs in Lex.
+
+	static ILexer5 *LexerFactoryHTML() {
+		return new LexerHTML(false, false);
+	}
+	static ILexer5 *LexerFactoryXML() {
+		return new LexerHTML(true, false);
+	}
+	static ILexer5 *LexerFactoryPHPScript() {
+		return new LexerHTML(false, true);
+	}
+};
+
+Sci_Position SCI_METHOD LexerHTML::PropertySet(const char *key, const char *val) {
+	if (osHTML.PropertySet(&options, key, val)) {
+		return 0;
+	}
+	return -1;
+}
+
+Sci_Position SCI_METHOD LexerHTML::WordListSet(int n, const char *wl) {
+	WordList *wordListN = 0;
+	switch (n) {
+	case 0:
+		wordListN = &keywords;
+		break;
+	case 1:
+		wordListN = &keywords2;
+		break;
+	case 2:
+		wordListN = &keywords3;
+		break;
+	case 3:
+		wordListN = &keywords4;
+		break;
+	case 4:
+		wordListN = &keywords5;
+		break;
+	case 5:
+		wordListN = &keywords6;
+		break;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN) {
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+		}
+	}
+	return firstModification;
+}
+
+void SCI_METHOD LexerHTML::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	Accessor styler(pAccess, nullptr);
+	if (isPHPScript && (startPos == 0)) {
+		initStyle = SCE_HPHP_DEFAULT;
+	}
+	styler.StartAt(startPos);
+	std::string prevWord;
+	std::string phpStringDelimiter;
 	int StateToPrint = initStyle;
 	int state = stateForPrintState(StateToPrint);
-
-	// If inside a tag, it may be a script tag, so reread from the start to ensure any language tags are seen
+	std::string makoBlockType;
+	int makoComment = 0;
+	std::string djangoBlockType;
+	// If inside a tag, it may be a script tag, so reread from the start of line starting tag to ensure any language tags are seen
 	if (InTagState(state)) {
 		while ((startPos > 0) && (InTagState(styler.StyleAt(startPos - 1)))) {
-			startPos--;
-			length++;
+			const Sci_Position backLineStart = styler.LineStart(styler.GetLine(startPos-1));
+			length += startPos - backLineStart;
+			startPos = backLineStart;
 		}
 		state = SCE_H_DEFAULT;
 	}
@@ -552,23 +980,35 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 		if (startPos == 0)
 			state = SCE_H_DEFAULT;
 	}
-	styler.StartAt(startPos, static_cast<char>(STYLE_MAX));
+	styler.StartAt(startPos);
 
-	int lineCurrent = styler.GetLine(startPos);
+	/* Nothing handles getting out of these, so we need not start in any of them.
+	 * As we're at line start and they can't span lines, we'll re-detect them anyway */
+	switch (state) {
+		case SCE_H_QUESTION:
+		case SCE_H_XMLSTART:
+		case SCE_H_XMLEND:
+		case SCE_H_ASP:
+			state = SCE_H_DEFAULT;
+			break;
+	}
+
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int lineState;
 	if (lineCurrent > 0) {
-		lineState = styler.GetLineState(lineCurrent);
+		lineState = styler.GetLineState(lineCurrent-1);
 	} else {
 		// Default client and ASP scripting language is JavaScript
 		lineState = eScriptJS << 8;
-		lineState |= styler.GetPropertyInt("asp.default.language", eScriptJS) << 4;
+		lineState |= options.aspDefaultLanguage << 4;
 	}
-	script_mode inScriptType = script_mode((lineState >> 0) & 0x03); // 2 bits of scripting mode
+	script_mode inScriptType = static_cast<script_mode>((lineState >> 0) & 0x03); // 2 bits of scripting mode
+
 	bool tagOpened = (lineState >> 2) & 0x01; // 1 bit to know if we are in an opened tag
 	bool tagClosing = (lineState >> 3) & 0x01; // 1 bit to know if we are in a closing tag
 	bool tagDontFold = false; //some HTML tags should not be folded
-	script_type aspScript = script_type((lineState >> 4) & 0x0F); // 4 bits of script name
-	script_type clientScript = script_type((lineState >> 8) & 0x0F); // 4 bits of script name
+	script_type aspScript = static_cast<script_type>((lineState >> 4) & 0x0F); // 4 bits of script name
+	script_type clientScript = static_cast<script_type>((lineState >> 8) & 0x0F); // 4 bits of script name
 	int beforePreProc = (lineState >> 12) & 0xFF; // 8 bits of state
 
 	script_type scriptLanguage = ScriptOfState(state);
@@ -576,30 +1016,35 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 	if (inScriptType == eNonHtmlScript && state == SCE_H_COMMENT) {
 		scriptLanguage = eScriptComment;
 	}
-
-	const bool foldHTML = styler.GetPropertyInt("fold.html", 0) != 0;
-	const bool fold = foldHTML && styler.GetPropertyInt("fold", 0);
-	const bool foldHTMLPreprocessor = foldHTML && styler.GetPropertyInt("fold.html.preprocessor", 1);
-	const bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	const bool foldComment = fold && styler.GetPropertyInt("fold.hypertext.comment", 0) != 0;
-	const bool foldHeredoc = fold && styler.GetPropertyInt("fold.hypertext.heredoc", 0) != 0;
-	const bool caseSensitive = styler.GetPropertyInt("html.tags.case.sensitive", 0) != 0;
-	const bool allowScripts = styler.GetPropertyInt("lexer.xml.allow.scripts", 1) != 0;
-
+	script_type beforeLanguage = ScriptOfState(beforePreProc);
+	const bool foldHTML = options.foldHTML;
+	const bool fold = foldHTML && options.fold;
+	const bool foldHTMLPreprocessor = foldHTML && options.foldHTMLPreprocessor;
+	const bool foldCompact = options.foldCompact;
+	const bool foldComment = fold && options.foldComment;
+	const bool foldHeredoc = fold && options.foldHeredoc;
+	const bool foldXmlAtTagOpen = isXml && fold && options.foldXmlAtTagOpen;
+	const bool caseSensitive = options.caseSensitive;
+	const bool allowScripts = options.allowScripts;
+	const bool isMako = options.isMako;
+	const bool isDjango = options.isDjango;
 	const CharacterSet setHTMLWord(CharacterSet::setAlphaNum, ".-_:!#", 0x80, true);
 	const CharacterSet setTagContinue(CharacterSet::setAlphaNum, ".-_:!#[", 0x80, true);
 	const CharacterSet setAttributeContinue(CharacterSet::setAlphaNum, ".-_:!#/", 0x80, true);
+	// TODO: also handle + and - (except if they're part of ++ or --) and return keywords
+	const CharacterSet setOKBeforeJSRE(CharacterSet::setNone, "([{=,:;!%^&*|?~");
 
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	int visibleChars = 0;
+	int lineStartVisibleChars = 0;
 
 	int chPrev = ' ';
 	int ch = ' ';
 	int chPrevNonWhite = ' ';
 	// look back to set chPrevNonWhite properly for better regex colouring
 	if (scriptLanguage == eScriptJS && startPos > 0) {
-		int back = startPos;
+		Sci_Position back = startPos;
 		int style = 0;
 		while (--back) {
 			style = styler.StyleAt(back);
@@ -613,8 +1058,8 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 	}
 
 	styler.StartSegment(startPos);
-	const int lengthDoc = startPos + length;
-	for (int i = startPos; i < lengthDoc; i++) {
+	const Sci_Position lengthDoc = startPos + length;
+	for (Sci_Position i = startPos; i < lengthDoc; i++) {
 		const int chPrev2 = chPrev;
 		chPrev = ch;
 		if (!IsASpace(ch) && state != SCE_HJ_COMMENT &&
@@ -633,6 +1078,8 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 
 		if ((!IsASpace(ch) || !foldCompact) && fold)
 			visibleChars++;
+		if (!IsASpace(ch))
+			lineStartVisibleChars++;
 
 		// decide what is the current state to print (depending of the script tag)
 		StateToPrint = statePrintForState(state, inScriptType);
@@ -647,22 +1094,32 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				if ((state != SCE_HPHP_COMMENT) && (state != SCE_HPHP_COMMENTLINE) && (state != SCE_HJ_COMMENT) && (state != SCE_HJ_COMMENTLINE) && (state != SCE_HJ_COMMENTDOC) && (!isStringState(state))) {
 				//Platform::DebugPrintf("state=%d, StateToPrint=%d, initStyle=%d\n", state, StateToPrint, initStyle);
 				//if ((state == SCE_HPHP_OPERATOR) || (state == SCE_HPHP_DEFAULT) || (state == SCE_HJ_SYMBOLS) || (state == SCE_HJ_START) || (state == SCE_HJ_DEFAULT)) {
-					if ((ch == '{') || (ch == '}') || (foldComment && (ch == '/') && (chNext == '*'))) {
-						levelCurrent += ((ch == '{') || (ch == '/')) ? 1 : -1;
+					if (ch == '#') {
+						Sci_Position j = i + 1;
+						while ((j < lengthDoc) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
+							j++;
+						}
+						if (styler.Match(j, "region") || styler.Match(j, "if")) {
+							levelCurrent++;
+						} else if (styler.Match(j, "end")) {
+							levelCurrent--;
+						}
+					} else if ((ch == '{') || (ch == '}') || (foldComment && (ch == '/') && (chNext == '*'))) {
+						levelCurrent += (((ch == '{') || (ch == '/')) ? 1 : -1);
 					}
 				} else if (((state == SCE_HPHP_COMMENT) || (state == SCE_HJ_COMMENT)) && foldComment && (ch == '*') && (chNext == '/')) {
 					levelCurrent--;
 				}
 				break;
 			case eScriptPython:
-				if (state != SCE_HP_COMMENTLINE) {
+				if (state != SCE_HP_COMMENTLINE && !isMako) {
 					if ((ch == ':') && ((chNext == '\n') || (chNext == '\r' && chNext2 == '\n'))) {
 						levelCurrent++;
 					} else if ((ch == '\n') && !((chNext == '\r') && (chNext2 == '\n')) && (chNext != '\n')) {
 						// check if the number of tabs is lower than the level
 						int Findlevel = (levelCurrent & ~SC_FOLDLEVELBASE) * 8;
-						for (int j = 0; Findlevel > 0; j++) {
-							char chTmp = styler.SafeGetCharAt(i + j + 1);
+						for (Sci_Position j = 0; Findlevel > 0; j++) {
+							const char chTmp = styler.SafeGetCharAt(i + j + 1);
 							if (chTmp == '\t') {
 								Findlevel -= 8;
 							} else if (chTmp == ' ') {
@@ -700,14 +1157,39 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				visibleChars = 0;
 				levelPrev = levelCurrent;
 			}
-			lineCurrent++;
 			styler.SetLineState(lineCurrent,
 			                    ((inScriptType & 0x03) << 0) |
-			                    ((tagOpened & 0x01) << 2) |
-			                    ((tagClosing & 0x01) << 3) |
+			                    ((tagOpened ? 1 : 0) << 2) |
+			                    ((tagClosing ? 1 : 0) << 3) |
 			                    ((aspScript & 0x0F) << 4) |
 			                    ((clientScript & 0x0F) << 8) |
 			                    ((beforePreProc & 0xFF) << 12));
+			lineCurrent++;
+			lineStartVisibleChars = 0;
+		}
+
+		// handle start of Mako comment line
+		if (isMako && ch == '#' && chNext == '#') {
+			makoComment = 1;
+			state = SCE_HP_COMMENTLINE;
+		}
+
+		// handle end of Mako comment line
+		else if (isMako && makoComment && (ch == '\r' || ch == '\n')) {
+			makoComment = 0;
+			styler.ColourTo(i - 1, StateToPrint);
+			if (scriptLanguage == eScriptPython) {
+				state = SCE_HP_DEFAULT;
+			} else {
+				state = SCE_H_DEFAULT;
+			}
+		}
+		// Allow falling through to mako handling code if newline is going to end a block
+		if (((ch == '\r' && chNext != '\n') || (ch == '\n')) &&
+			(!isMako || (makoBlockType != "%"))) {
+		}
+		// Ignore everything in mako comment until the line ends
+		else if (isMako && makoComment) {
 		}
 
 		// generic end of script processing
@@ -741,7 +1223,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				if (const char *tag =
 						state == SCE_HJ_COMMENTLINE || isXml ? "script" :
 						state == SCE_H_COMMENT ? "comment" : 0) {
-					int j = i + 2;
+					Sci_Position j = i + 2;
 					int chr;
 					do {
 						chr = static_cast<int>(*tag++);
@@ -757,6 +1239,9 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				i += 2;
 				visibleChars += 2;
 				tagClosing = true;
+				if (foldXmlAtTagOpen) {
+					levelCurrent--;
+				}
 				continue;
 			}
 		}
@@ -764,13 +1249,15 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 		/////////////////////////////////////
 		// handle the start of PHP pre-processor = Non-HTML
 		else if ((state != SCE_H_ASPAT) &&
-		         !isPHPStringState(state) &&
+		         !isStringState(state) &&
 		         (state != SCE_HPHP_COMMENT) &&
+		         (state != SCE_HPHP_COMMENTLINE) &&
 		         (ch == '<') &&
 		         (chNext == '?') &&
-				 !IsScriptCommentState(state) ) {
-			scriptLanguage = segIsScriptingIndicator(styler, i + 2, i + 6, eScriptPHP);
-			if (scriptLanguage != eScriptPHP && isStringState(state)) continue;
+				 !IsScriptCommentState(state)) {
+ 			beforeLanguage = scriptLanguage;
+			scriptLanguage = segIsScriptingIndicator(styler, i + 2, i + 6, isXml ? eScriptXML : eScriptPHP);
+			if ((scriptLanguage != eScriptPHP) && (isStringState(state) || (state==SCE_H_COMMENT))) continue;
 			styler.ColourTo(i - 1, StateToPrint);
 			beforePreProc = state;
 			i++;
@@ -794,8 +1281,106 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 			continue;
 		}
 
+		// handle the start Mako template Python code
+		else if (isMako && scriptLanguage == eScriptNone && ((ch == '<' && chNext == '%') ||
+															 (lineStartVisibleChars == 1 && ch == '%') ||
+															 (lineStartVisibleChars == 1 && ch == '/' && chNext == '%') ||
+															 (ch == '$' && chNext == '{') ||
+															 (ch == '<' && chNext == '/' && chNext2 == '%'))) {
+			if (ch == '%' || ch == '/')
+				makoBlockType = "%";
+			else if (ch == '$')
+				makoBlockType = "{";
+			else if (chNext == '/')
+				makoBlockType = GetNextWord(styler, i+3);
+			else
+				makoBlockType = GetNextWord(styler, i+2);
+			styler.ColourTo(i - 1, StateToPrint);
+			beforePreProc = state;
+			if (inScriptType == eNonHtmlScript)
+				inScriptType = eNonHtmlScriptPreProc;
+			else
+				inScriptType = eNonHtmlPreProc;
+
+			if (chNext == '/') {
+				i += 2;
+				visibleChars += 2;
+			} else if (ch != '%') {
+				i++;
+				visibleChars++;
+			}
+			state = SCE_HP_START;
+			scriptLanguage = eScriptPython;
+			styler.ColourTo(i, SCE_H_ASP);
+			if (ch != '%' && ch != '$' && ch != '/') {
+				i += makoBlockType.length();
+				visibleChars += static_cast<int>(makoBlockType.length());
+				if (keywords4.InList(makoBlockType.c_str()))
+					styler.ColourTo(i, SCE_HP_WORD);
+				else
+					styler.ColourTo(i, SCE_H_TAGUNKNOWN);
+			}
+
+			ch = static_cast<unsigned char>(styler.SafeGetCharAt(i));
+			continue;
+		}
+
+		// handle the start/end of Django comment
+		else if (isDjango && state != SCE_H_COMMENT && (ch == '{' && chNext == '#')) {
+			styler.ColourTo(i - 1, StateToPrint);
+			beforePreProc = state;
+			beforeLanguage = scriptLanguage;
+			if (inScriptType == eNonHtmlScript)
+				inScriptType = eNonHtmlScriptPreProc;
+			else
+				inScriptType = eNonHtmlPreProc;
+			i += 1;
+			visibleChars += 1;
+			scriptLanguage = eScriptComment;
+			state = SCE_H_COMMENT;
+			styler.ColourTo(i, SCE_H_ASP);
+			ch = static_cast<unsigned char>(styler.SafeGetCharAt(i));
+			continue;
+		} else if (isDjango && state == SCE_H_COMMENT && (ch == '#' && chNext == '}')) {
+			styler.ColourTo(i - 1, StateToPrint);
+			i += 1;
+			visibleChars += 1;
+			styler.ColourTo(i, SCE_H_ASP);
+			state = beforePreProc;
+			if (inScriptType == eNonHtmlScriptPreProc)
+				inScriptType = eNonHtmlScript;
+			else
+				inScriptType = eHtml;
+			scriptLanguage = beforeLanguage;
+			continue;
+		}
+
+		// handle the start Django template code
+		else if (isDjango && scriptLanguage != eScriptPython && scriptLanguage != eScriptComment && (ch == '{' && (chNext == '%' ||  chNext == '{'))) {
+			if (chNext == '%')
+				djangoBlockType = "%";
+			else
+				djangoBlockType = "{";
+			styler.ColourTo(i - 1, StateToPrint);
+			beforePreProc = state;
+			if (inScriptType == eNonHtmlScript)
+				inScriptType = eNonHtmlScriptPreProc;
+			else
+				inScriptType = eNonHtmlPreProc;
+
+			i += 1;
+			visibleChars += 1;
+			state = SCE_HP_START;
+			beforeLanguage = scriptLanguage;
+			scriptLanguage = eScriptPython;
+			styler.ColourTo(i, SCE_H_ASP);
+
+			ch = static_cast<unsigned char>(styler.SafeGetCharAt(i));
+			continue;
+		}
+
 		// handle the start of ASP pre-processor = Non-HTML
-		else if (!isCommentASPState(state) && (ch == '<') && (chNext == '%') && !isPHPStringState(state)) {
+		else if (!isMako && !isDjango && !isCommentASPState(state) && (ch == '<') && (chNext == '%') && !isPHPStringState(state)) {
 			styler.ColourTo(i - 1, StateToPrint);
 			beforePreProc = state;
 			if (inScriptType == eNonHtmlScript)
@@ -840,7 +1425,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				 (ch == '!') &&
 				 (StateToPrint != SCE_H_CDATA) &&
 				 (!IsCommentState(StateToPrint)) &&
-				 (!IsScriptCommentState(StateToPrint)) ) {
+				 (!IsScriptCommentState(StateToPrint))) {
 			beforePreProc = state;
 			styler.ColourTo(i - 2, StateToPrint);
 			if ((chNext == '-') && (chNext2 == '-')) {
@@ -855,17 +1440,75 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				state = SCE_H_SGML_COMMAND; // wait for a pending command
 			}
 			// fold whole tag (-- when closing the tag)
-			if (foldHTMLPreprocessor)
+			if (foldHTMLPreprocessor || state == SCE_H_COMMENT || state == SCE_H_CDATA)
 				levelCurrent++;
 			continue;
 		}
 
+		// handle the end of Mako Python code
+		else if (isMako &&
+			     ((inScriptType == eNonHtmlPreProc) || (inScriptType == eNonHtmlScriptPreProc)) &&
+				 (scriptLanguage != eScriptNone) && stateAllowsTermination(state) &&
+				 isMakoBlockEnd(ch, chNext, makoBlockType)) {
+			if (state == SCE_H_ASPAT) {
+				aspScript = segIsScriptingIndicator(styler,
+				                                    styler.GetStartSegment(), i - 1, aspScript);
+			}
+			if (state == SCE_HP_WORD) {
+				classifyWordHTPy(styler.GetStartSegment(), i - 1, keywords4, styler, prevWord, inScriptType, isMako);
+			} else {
+				styler.ColourTo(i - 1, StateToPrint);
+			}
+			if ((makoBlockType != "%") && (makoBlockType != "{") && ch != '>') {
+				i++;
+				visibleChars++;
+		    }
+			else if ((makoBlockType == "%") && ch == '/') {
+				i++;
+				visibleChars++;
+			}
+			if ((makoBlockType != "%") || ch == '/') {
+				styler.ColourTo(i, SCE_H_ASP);
+			}
+			state = beforePreProc;
+			if (inScriptType == eNonHtmlScriptPreProc)
+				inScriptType = eNonHtmlScript;
+			else
+				inScriptType = eHtml;
+			scriptLanguage = eScriptNone;
+			continue;
+		}
+
+		// handle the end of Django template code
+		else if (isDjango &&
+			     ((inScriptType == eNonHtmlPreProc) || (inScriptType == eNonHtmlScriptPreProc)) &&
+				 (scriptLanguage != eScriptNone) && stateAllowsTermination(state) &&
+				 isDjangoBlockEnd(ch, chNext, djangoBlockType)) {
+			if (state == SCE_H_ASPAT) {
+				aspScript = segIsScriptingIndicator(styler,
+				                                    styler.GetStartSegment(), i - 1, aspScript);
+			}
+			if (state == SCE_HP_WORD) {
+				classifyWordHTPy(styler.GetStartSegment(), i - 1, keywords4, styler, prevWord, inScriptType, isMako);
+			} else {
+				styler.ColourTo(i - 1, StateToPrint);
+			}
+			i += 1;
+			visibleChars += 1;
+			styler.ColourTo(i, SCE_H_ASP);
+			state = beforePreProc;
+			if (inScriptType == eNonHtmlScriptPreProc)
+				inScriptType = eNonHtmlScript;
+			else
+				inScriptType = eHtml;
+			scriptLanguage = beforeLanguage;
+			continue;
+		}
+
 		// handle the end of a pre-processor = Non-HTML
-		else if ((
-		             ((inScriptType == eNonHtmlPreProc)
-		              || (inScriptType == eNonHtmlScriptPreProc)) && (
-		                 ((scriptLanguage != eScriptNone) && stateAllowsTermination(state) && ((ch == '%') || (ch == '?')))
-		             ) && (chNext == '>')) ||
+		else if ((!isMako && !isDjango && ((inScriptType == eNonHtmlPreProc) || (inScriptType == eNonHtmlScriptPreProc)) &&
+				  (((scriptLanguage != eScriptNone) && stateAllowsTermination(state))) &&
+				  (((ch == '%') || (ch == '?')) && (chNext == '>'))) ||
 		         ((scriptLanguage == eScriptSGML) && (ch == '>') && (state != SCE_H_SGML_COMMENT))) {
 			if (state == SCE_H_ASPAT) {
 				aspScript = segIsScriptingIndicator(styler,
@@ -880,7 +1523,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				classifyWordHTVB(styler.GetStartSegment(), i - 1, keywords3, styler, inScriptType);
 				break;
 			case SCE_HP_WORD:
-				classifyWordHTPy(styler.GetStartSegment(), i - 1, keywords4, styler, prevWord, inScriptType);
+				classifyWordHTPy(styler.GetStartSegment(), i - 1, keywords4, styler, prevWord, inScriptType, isMako);
 				break;
 			case SCE_HPHP_WORD:
 				classifyWordHTPHP(styler.GetStartSegment(), i - 1, keywords5, styler);
@@ -913,7 +1556,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 			if (foldHTMLPreprocessor && (scriptLanguage != eScriptXML)) {
 				levelCurrent--;
 			}
-			scriptLanguage = eScriptNone;
+			scriptLanguage = beforeLanguage;
 			continue;
 		}
 		/////////////////////////////////////
@@ -924,6 +1567,12 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				// in HTML, fold on tag open and unfold on tag close
 				tagOpened = true;
 				tagClosing = (chNext == '/');
+				if (foldXmlAtTagOpen && !(chNext == '/' || chNext == '?' || chNext == '!' || chNext == '-' || chNext == '%')) {
+					levelCurrent++;
+				}
+				if (foldXmlAtTagOpen && chNext == '/') {
+					levelCurrent--;
+				}
 				styler.ColourTo(i - 1, StateToPrint);
 				if (chNext != '!')
 					state = SCE_H_TAGUNKNOWN;
@@ -944,11 +1593,11 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				styler.ColourTo(i - 1, StateToPrint);
 				state = SCE_H_SGML_SIMPLESTRING;
 			} else if ((ch == '-') && (chPrev == '-')) {
-				if (static_cast<int>(styler.GetStartSegment()) <= (i - 2)) {
+				if (static_cast<Sci_Position>(styler.GetStartSegment()) <= (i - 2)) {
 					styler.ColourTo(i - 2, StateToPrint);
 				}
 				state = SCE_H_SGML_COMMENT;
-			} else if (isascii(ch) && isalpha(ch) && (chPrev == '%')) {
+			} else if (IsASCII(ch) && isalpha(ch) && (chPrev == '%')) {
 				styler.ColourTo(i - 2, StateToPrint);
 				state = SCE_H_SGML_ENTITY;
 			} else if (ch == '#') {
@@ -1027,6 +1676,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				styler.ColourTo(i - 2, StateToPrint);
 				state = SCE_H_SGML_COMMENT;
 			}
+			break;
 		case SCE_H_SGML_DOUBLESTRING:
 			if (ch == '\"') {
 				styler.ColourTo(i, StateToPrint);
@@ -1066,7 +1716,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 			}
 			break;
 		case SCE_H_SGML_SPECIAL:
-			if (!(isascii(ch) && isupper(ch))) {
+			if (!(IsASCII(ch) && isupper(ch))) {
 				styler.ColourTo(i - 1, StateToPrint);
 				if (isalnum(ch)) {
 					state = SCE_H_SGML_ERROR;
@@ -1079,7 +1729,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 			if (ch == ';') {
 				styler.ColourTo(i, StateToPrint);
 				state = SCE_H_SGML_DEFAULT;
-			} else if (!(isascii(ch) && isalnum(ch)) && ch != '-' && ch != '.') {
+			} else if (!(IsASCII(ch) && isalnum(ch)) && ch != '-' && ch != '.') {
 				styler.ColourTo(i, SCE_H_SGML_ERROR);
 				state = SCE_H_SGML_DEFAULT;
 			}
@@ -1089,16 +1739,19 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				styler.ColourTo(i, StateToPrint);
 				state = SCE_H_DEFAULT;
 			}
-			if (ch != '#' && !(isascii(ch) && isalnum(ch))	// Should check that '#' follows '&', but it is unlikely anyway...
+			if (ch != '#' && !(IsASCII(ch) && isalnum(ch))	// Should check that '#' follows '&', but it is unlikely anyway...
 				&& ch != '.' && ch != '-' && ch != '_' && ch != ':') { // valid in XML
-				styler.ColourTo(i, SCE_H_TAGUNKNOWN);
+				if (!IsASCII(ch))	// Possibly start of a multibyte character so don't allow this byte to be in entity style
+					styler.ColourTo(i-1, SCE_H_TAGUNKNOWN);
+				else
+					styler.ColourTo(i, SCE_H_TAGUNKNOWN);
 				state = SCE_H_DEFAULT;
 			}
 			break;
 		case SCE_H_TAGUNKNOWN:
 			if (!setTagContinue.Contains(ch) && !((ch == '/') && (chPrev == '<'))) {
 				int eClass = classifyTagHTML(styler.GetStartSegment(),
-					i - 1, keywords, styler, tagDontFold, caseSensitive, isXml, allowScripts);
+					i - 1, keywords, styler, tagDontFold, caseSensitive, isXml, allowScripts, nonFoldingTags);
 				if (eClass == SCE_H_SCRIPT || eClass == SCE_H_COMMENT) {
 					if (!tagClosing) {
 						inScriptType = eNonHtmlScript;
@@ -1116,7 +1769,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 						state = SCE_H_DEFAULT;
 					}
 					tagOpened = false;
-					if (!tagDontFold) {
+					if (!(foldXmlAtTagOpen || tagDontFold)) {
 						if (tagClosing) {
 							levelCurrent--;
 						} else {
@@ -1135,6 +1788,9 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 					ch = chNext;
 					state = SCE_H_DEFAULT;
 					tagOpened = false;
+					if (foldXmlAtTagOpen) {
+						levelCurrent--;
+					}
 				} else {
 					if (eClass != SCE_H_TAGUNKNOWN) {
 						if (eClass == SCE_H_SGML_DEFAULT) {
@@ -1149,7 +1805,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 		case SCE_H_ATTRIBUTE:
 			if (!setAttributeContinue.Contains(ch)) {
 				if (inScriptType == eNonHtmlScript) {
-					int scriptLanguagePrev = scriptLanguage;
+					const int scriptLanguagePrev = scriptLanguage;
 					clientScript = segIsScriptingIndicator(styler, styler.GetStartSegment(), i - 1, scriptLanguage);
 					scriptLanguage = clientScript;
 					if ((scriptLanguagePrev != scriptLanguage) && (scriptLanguage == eScriptNone))
@@ -1164,7 +1820,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 						state = SCE_H_DEFAULT;
 					}
 					tagOpened = false;
-					if (!tagDontFold) {
+					if (!(foldXmlAtTagOpen || tagDontFold)) {
 						if (tagClosing) {
 							levelCurrent--;
 						} else {
@@ -1190,7 +1846,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 					state = SCE_H_DEFAULT;
 				}
 				tagOpened = false;
-				if (!tagDontFold) {
+				if (!(foldXmlAtTagOpen || tagDontFold)) {
 					if (tagClosing) {
 						levelCurrent--;
 					} else {
@@ -1214,6 +1870,9 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				ch = chNext;
 				state = SCE_H_DEFAULT;
 				tagOpened = false;
+				if (foldXmlAtTagOpen) {
+					levelCurrent--;
+				}
 			} else if (ch == '?' && chNext == '>') {
 				styler.ColourTo(i - 1, StateToPrint);
 				styler.ColourTo(i + 1, SCE_H_XMLEND);
@@ -1290,10 +1949,14 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 					state = SCE_HJ_COMMENTDOC;
 				else
 					state = SCE_HJ_COMMENT;
+				if (chNext2 == '/') {
+					// Eat the * so it isn't used for the end of the comment
+					i++;
+				}
 			} else if (ch == '/' && chNext == '/') {
 				styler.ColourTo(i - 1, StateToPrint);
 				state = SCE_HJ_COMMENTLINE;
-			} else if (ch == '/' && isOKBeforeRE(chPrevNonWhite)) {
+			} else if (ch == '/' && setOKBeforeJSRE.Contains(chPrevNonWhite)) {
 				styler.ColourTo(i - 1, StateToPrint);
 				state = SCE_HJ_REGEX;
 			} else if (ch == '\"') {
@@ -1393,7 +2056,9 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				i += 2;
 			} else if (isLineEnd(ch)) {
 				styler.ColourTo(i - 1, StateToPrint);
-				state = SCE_HJ_STRINGEOL;
+				if (chPrev != '\\' && (chPrev2 != '\\' || chPrev != '\r' || ch != '\n')) {
+					state = SCE_HJ_STRINGEOL;
+				}
 			}
 			break;
 		case SCE_HJ_STRINGEOL:
@@ -1408,7 +2073,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 		case SCE_HJ_REGEX:
 			if (ch == '\r' || ch == '\n' || ch == '/') {
 				if (ch == '/') {
-					while (isascii(chNext) && islower(chNext)) {   // gobble regex flags
+					while (IsASCII(chNext) && islower(chNext)) {   // gobble regex flags
 						i++;
 						ch = chNext;
 						chNext = static_cast<unsigned char>(styler.SafeGetCharAt(i + 1));
@@ -1537,7 +2202,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 			break;
 		case SCE_HP_WORD:
 			if (!IsAWordChar(ch)) {
-				classifyWordHTPy(styler.GetStartSegment(), i - 1, keywords4, styler, prevWord, inScriptType);
+				classifyWordHTPy(styler.GetStartSegment(), i - 1, keywords4, styler, prevWord, inScriptType, isMako);
 				state = SCE_HP_DEFAULT;
 				if (ch == '#') {
 					state = SCE_HP_COMMENTLINE;
@@ -1622,17 +2287,17 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 					state = SCE_HPHP_COMMENTLINE;
 				} else if (ch == '\"') {
 					state = SCE_HPHP_HSTRING;
-					strcpy(phpStringDelimiter, "\"");
+					phpStringDelimiter = "\"";
 				} else if (styler.Match(i, "<<<")) {
 					bool isSimpleString = false;
-					i = FindPhpStringDelimiter(phpStringDelimiter, sizeof(phpStringDelimiter), i + 3, lengthDoc, styler, isSimpleString);
-					if (strlen(phpStringDelimiter)) {
+					i = FindPhpStringDelimiter(phpStringDelimiter, i + 3, lengthDoc, styler, isSimpleString);
+					if (!phpStringDelimiter.empty()) {
 						state = (isSimpleString ? SCE_HPHP_SIMPLESTRING : SCE_HPHP_HSTRING);
 						if (foldHeredoc) levelCurrent++;
 					}
 				} else if (ch == '\'') {
 					state = SCE_HPHP_SIMPLESTRING;
-					strcpy(phpStringDelimiter, "\'");
+					phpStringDelimiter = "\'";
 				} else if (ch == '$' && IsPhpWordStart(chNext)) {
 					state = SCE_HPHP_VARIABLE;
 				} else if (IsOperator(ch)) {
@@ -1673,7 +2338,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 			}
 			break;
 		case SCE_HPHP_HSTRING:
-			if (ch == '\\' && (phpStringDelimiter[0] == '\"' || chNext == '$' || chNext == '{')) {
+			if (ch == '\\' && ((phpStringDelimiter == "\"") || chNext == '$' || chNext == '{')) {
 				// skip the next char
 				i++;
 			} else if (((ch == '{' && chNext == '$') || (ch == '$' && chNext == '{'))
@@ -1683,12 +2348,12 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 			} else if (ch == '$' && IsPhpWordStart(chNext)) {
 				styler.ColourTo(i - 1, StateToPrint);
 				state = SCE_HPHP_HSTRING_VARIABLE;
-			} else if (styler.Match(i, phpStringDelimiter)) {
-				if (phpStringDelimiter[0] == '\"') {
+			} else if (styler.Match(i, phpStringDelimiter.c_str())) {
+				if (phpStringDelimiter == "\"") {
 					styler.ColourTo(i, StateToPrint);
 					state = SCE_HPHP_DEFAULT;
 				} else if (isLineEnd(chPrev)) {
-				const int psdLength = strlen(phpStringDelimiter);
+					const int psdLength = static_cast<int>(phpStringDelimiter.length());
 					const char chAfterPsd = styler.SafeGetCharAt(i + psdLength);
 					const char chAfterPsd2 = styler.SafeGetCharAt(i + psdLength + 1);
 					if (isLineEnd(chAfterPsd) ||
@@ -1702,7 +2367,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 			}
 			break;
 		case SCE_HPHP_SIMPLESTRING:
-			if (phpStringDelimiter[0] == '\'') {
+			if (phpStringDelimiter == "\'") {
 				if (ch == '\\') {
 					// skip the next char
 					i++;
@@ -1710,8 +2375,8 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 					styler.ColourTo(i, StateToPrint);
 					state = SCE_HPHP_DEFAULT;
 				}
-			} else if (isLineEnd(chPrev) && styler.Match(i, phpStringDelimiter)) {
-				const int psdLength = strlen(phpStringDelimiter);
+			} else if (isLineEnd(chPrev) && styler.Match(i, phpStringDelimiter.c_str())) {
+				const int psdLength = static_cast<int>(phpStringDelimiter.length());
 				const char chAfterPsd = styler.SafeGetCharAt(i + psdLength);
 				const char chAfterPsd2 = styler.SafeGetCharAt(i + psdLength + 1);
 				if (isLineEnd(chAfterPsd) ||
@@ -1752,17 +2417,17 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 				state = SCE_HPHP_COMMENTLINE;
 			} else if (ch == '\"') {
 				state = SCE_HPHP_HSTRING;
-				strcpy(phpStringDelimiter, "\"");
+				phpStringDelimiter = "\"";
 			} else if (styler.Match(i, "<<<")) {
 				bool isSimpleString = false;
-				i = FindPhpStringDelimiter(phpStringDelimiter, sizeof(phpStringDelimiter), i + 3, lengthDoc, styler, isSimpleString);
-				if (strlen(phpStringDelimiter)) {
+				i = FindPhpStringDelimiter(phpStringDelimiter, i + 3, lengthDoc, styler, isSimpleString);
+				if (!phpStringDelimiter.empty()) {
 					state = (isSimpleString ? SCE_HPHP_SIMPLESTRING : SCE_HPHP_HSTRING);
 					if (foldHeredoc) levelCurrent++;
 				}
 			} else if (ch == '\'') {
 				state = SCE_HPHP_SIMPLESTRING;
-				strcpy(phpStringDelimiter, "\'");
+				phpStringDelimiter = "\'";
 			} else if (ch == '$' && IsPhpWordStart(chNext)) {
 				state = SCE_HPHP_VARIABLE;
 			} else if (IsOperator(ch)) {
@@ -1777,7 +2442,7 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 		// Some of the above terminated their lexeme but since the same character starts
 		// the same class again, only reenter if non empty segment.
 
-		bool nonEmptySegment = i >= static_cast<int>(styler.GetStartSegment());
+		const bool nonEmptySegment = i >= static_cast<Sci_Position>(styler.GetStartSegment());
 		if (state == SCE_HB_DEFAULT) {    // One of the above succeeded
 			if ((ch == '\"') && (nonEmptySegment)) {
 				state = SCE_HB_STRING;
@@ -1826,359 +2491,26 @@ static void ColouriseHyperTextDoc(unsigned int startPos, int length, int initSty
 		classifyWordHTVB(styler.GetStartSegment(), lengthDoc - 1, keywords3, styler, inScriptType);
 		break;
 	case SCE_HP_WORD:
-		classifyWordHTPy(styler.GetStartSegment(), lengthDoc - 1, keywords4, styler, prevWord, inScriptType);
+		classifyWordHTPy(styler.GetStartSegment(), lengthDoc - 1, keywords4, styler, prevWord, inScriptType, isMako);
 		break;
 	case SCE_HPHP_WORD:
 		classifyWordHTPHP(styler.GetStartSegment(), lengthDoc - 1, keywords5, styler);
 		break;
 	default:
 		StateToPrint = statePrintForState(state, inScriptType);
-		styler.ColourTo(lengthDoc - 1, StateToPrint);
+		if (static_cast<Sci_Position>(styler.GetStartSegment()) < lengthDoc)
+			styler.ColourTo(lengthDoc - 1, StateToPrint);
 		break;
 	}
 
 	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
 	if (fold) {
-		int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
+		const int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
 		styler.SetLevel(lineCurrent, levelPrev | flagsNext);
 	}
+	styler.Flush();
 }
 
-static void ColouriseXMLDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                                  Accessor &styler) {
-	// Passing in true because we're lexing XML
-	ColouriseHyperTextDoc(startPos, length, initStyle, keywordlists, styler, true);
-}
-
-static void ColouriseHTMLDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                                  Accessor &styler) {
-	// Passing in false because we're notlexing XML
-	ColouriseHyperTextDoc(startPos, length, initStyle, keywordlists, styler, false);
-}
-
-static bool isASPScript(int state) {
-	return
-		(state >= SCE_HJA_START && state <= SCE_HJA_REGEX) ||
-		(state >= SCE_HBA_START && state <= SCE_HBA_STRINGEOL) ||
-		(state >= SCE_HPA_DEFAULT && state <= SCE_HPA_IDENTIFIER);
-}
-
-static void ColouriseHBAPiece(StyleContext &sc, WordList *keywordlists[]) {
-	WordList &keywordsVBS = *keywordlists[2];
-	if (sc.state == SCE_HBA_WORD) {
-		if (!IsAWordChar(sc.ch)) {
-			char s[100];
-			sc.GetCurrentLowered(s, sizeof(s));
-			if (keywordsVBS.InList(s)) {
-				if (strcmp(s, "rem") == 0) {
-					sc.ChangeState(SCE_HBA_COMMENTLINE);
-					if (sc.atLineEnd) {
-						sc.SetState(SCE_HBA_DEFAULT);
-					}
-				} else {
-					sc.SetState(SCE_HBA_DEFAULT);
-				}
-			} else {
-				sc.ChangeState(SCE_HBA_IDENTIFIER);
-				sc.SetState(SCE_HBA_DEFAULT);
-			}
-		}
-	} else if (sc.state == SCE_HBA_NUMBER) {
-		if (!IsAWordChar(sc.ch)) {
-			sc.SetState(SCE_HBA_DEFAULT);
-		}
-	} else if (sc.state == SCE_HBA_STRING) {
-		if (sc.ch == '\"') {
-			sc.ForwardSetState(SCE_HBA_DEFAULT);
-		} else if (sc.ch == '\r' || sc.ch == '\n') {
-			sc.ChangeState(SCE_HBA_STRINGEOL);
-			sc.ForwardSetState(SCE_HBA_DEFAULT);
-		}
-	} else if (sc.state == SCE_HBA_COMMENTLINE) {
-		if (sc.ch == '\r' || sc.ch == '\n') {
-			sc.SetState(SCE_HBA_DEFAULT);
-		}
-	}
-
-	if (sc.state == SCE_HBA_DEFAULT) {
-		if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
-			sc.SetState(SCE_HBA_NUMBER);
-		} else if (IsAWordStart(sc.ch)) {
-			sc.SetState(SCE_HBA_WORD);
-		} else if (sc.ch == '\'') {
-			sc.SetState(SCE_HBA_COMMENTLINE);
-		} else if (sc.ch == '\"') {
-			sc.SetState(SCE_HBA_STRING);
-		}
-	}
-}
-
-static void ColouriseHTMLPiece(StyleContext &sc, WordList *keywordlists[]) {
-	WordList &keywordsTags = *keywordlists[0];
-	if (sc.state == SCE_H_COMMENT) {
-		if (sc.Match("-->")) {
-			sc.Forward();
-			sc.Forward();
-			sc.ForwardSetState(SCE_H_DEFAULT);
-		}
-	} else if (sc.state == SCE_H_ENTITY) {
-		if (sc.ch == ';') {
-			sc.ForwardSetState(SCE_H_DEFAULT);
-		} else if (sc.ch != '#' && (sc.ch < 0x80) && !isalnum(sc.ch)	// Should check that '#' follows '&', but it is unlikely anyway...
-			&& sc.ch != '.' && sc.ch != '-' && sc.ch != '_' && sc.ch != ':') { // valid in XML
-			sc.ChangeState(SCE_H_TAGUNKNOWN);
-			sc.SetState(SCE_H_DEFAULT);
-		}
-	} else if (sc.state == SCE_H_TAGUNKNOWN) {
-		if (!ishtmlwordchar(sc.ch) && !((sc.ch == '/') && (sc.chPrev == '<')) && sc.ch != '[') {
-			char s[100];
-			sc.GetCurrentLowered(s, sizeof(s));
-			if (s[1] == '/') {
-				if (keywordsTags.InList(s + 2)) {
-					sc.ChangeState(SCE_H_TAG);
-				}
-			} else {
-				if (keywordsTags.InList(s + 1)) {
-					sc.ChangeState(SCE_H_TAG);
-				}
-			}
-			if (sc.ch == '>') {
-				sc.ForwardSetState(SCE_H_DEFAULT);
-			} else if (sc.Match('/', '>')) {
-				sc.SetState(SCE_H_TAGEND);
-				sc.Forward();
-				sc.ForwardSetState(SCE_H_DEFAULT);
-			} else {
-				sc.SetState(SCE_H_OTHER);
-			}
-		}
-	} else if (sc.state == SCE_H_ATTRIBUTE) {
-		if (!ishtmlwordchar(sc.ch)) {
-			char s[100];
-			sc.GetCurrentLowered(s, sizeof(s));
-			if (!keywordsTags.InList(s)) {
-				sc.ChangeState(SCE_H_ATTRIBUTEUNKNOWN);
-			}
-			sc.SetState(SCE_H_OTHER);
-		}
-	} else if (sc.state == SCE_H_OTHER) {
-		if (sc.ch == '>') {
-			sc.SetState(SCE_H_TAG);
-			sc.ForwardSetState(SCE_H_DEFAULT);
-		} else if (sc.Match('/', '>')) {
-			sc.SetState(SCE_H_TAG);
-			sc.Forward();
-			sc.ForwardSetState(SCE_H_DEFAULT);
-		} else if (sc.chPrev == '=') {
-			sc.SetState(SCE_H_VALUE);
-		}
-	} else if (sc.state == SCE_H_DOUBLESTRING) {
-		if (sc.ch == '\"') {
-			sc.ForwardSetState(SCE_H_OTHER);
-		}
-	} else if (sc.state == SCE_H_SINGLESTRING) {
-		if (sc.ch == '\'') {
-			sc.ForwardSetState(SCE_H_OTHER);
-		}
-	} else if (sc.state == SCE_H_NUMBER) {
-		if (!IsADigit(sc.ch)) {
-			sc.SetState(SCE_H_OTHER);
-		}
-	}
-
-	if (sc.state == SCE_H_DEFAULT) {
-		if (sc.ch == '<') {
-			if (sc.Match("<!--"))
-				sc.SetState(SCE_H_COMMENT);
-			else
-				sc.SetState(SCE_H_TAGUNKNOWN);
-		} else if (sc.ch == '&') {
-			sc.SetState(SCE_H_ENTITY);
-		}
-	} else if ((sc.state == SCE_H_OTHER) || (sc.state == SCE_H_VALUE)) {
-		if (sc.ch == '\"' && sc.chPrev == '=') {
-			sc.SetState(SCE_H_DOUBLESTRING);
-		} else if (sc.ch == '\'' && sc.chPrev == '=') {
-			sc.SetState(SCE_H_SINGLESTRING);
-		} else if (IsADigit(sc.ch)) {
-			sc.SetState(SCE_H_NUMBER);
-		} else if (sc.ch == '>') {
-			sc.SetState(SCE_H_TAG);
-			sc.ForwardSetState(SCE_H_DEFAULT);
-		} else if (ishtmlwordchar(sc.ch)) {
-			sc.SetState(SCE_H_ATTRIBUTE);
-		}
-	}
-}
-
-static void ColouriseASPPiece(StyleContext &sc, WordList *keywordlists[]) {
-	// Possibly exit current state to either SCE_H_DEFAULT or SCE_HBA_DEFAULT
-	if ((sc.state == SCE_H_ASPAT || isASPScript(sc.state)) && sc.Match('%', '>')) {
-		sc.SetState(SCE_H_ASP);
-		sc.Forward();
-		sc.ForwardSetState(SCE_H_DEFAULT);
-	}
-
-	// Handle some ASP script
-	if (sc.state >= SCE_HBA_START && sc.state <= SCE_HBA_STRINGEOL) {
-		ColouriseHBAPiece(sc, keywordlists);
-	} else if (sc.state >= SCE_H_DEFAULT && sc.state <= SCE_H_SGML_BLOCK_DEFAULT) {
-		ColouriseHTMLPiece(sc, keywordlists);
-	}
-
-	// Enter new sc.state
-	if ((sc.state == SCE_H_DEFAULT) || (sc.state == SCE_H_TAGUNKNOWN)) {
-		if (sc.Match('<', '%')) {
-			if (sc.state == SCE_H_TAGUNKNOWN)
-				sc.ChangeState(SCE_H_ASP);
-			else
-				sc.SetState(SCE_H_ASP);
-			sc.Forward();
-			sc.Forward();
-			if (sc.ch == '@') {
-				sc.ForwardSetState(SCE_H_ASPAT);
-			} else {
-				if (sc.ch == '=') {
-					sc.Forward();
-				}
-				sc.SetState(SCE_HBA_DEFAULT);
-			}
-		}
-	}
-}
-
-static void ColouriseASPDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                                  Accessor &styler) {
-	// Lexer for HTML requires more lexical states (8 bits worth) than most lexers
-	StyleContext sc(startPos, length, initStyle, styler, static_cast<char>(STYLE_MAX));
-	for (; sc.More(); sc.Forward()) {
-		ColouriseASPPiece(sc, keywordlists);
-	}
-	sc.Complete();
-}
-
-static void ColourisePHPPiece(StyleContext &sc, WordList *keywordlists[]) {
-	// Possibly exit current state to either SCE_H_DEFAULT or SCE_HBA_DEFAULT
-	if (sc.state >= SCE_HPHP_DEFAULT && sc.state <= SCE_HPHP_OPERATOR) {
-		if (!isPHPStringState(sc.state) &&
-			(sc.state != SCE_HPHP_COMMENT) &&
-			(sc.Match('?', '>'))) {
-			sc.SetState(SCE_H_QUESTION);
-			sc.Forward();
-			sc.ForwardSetState(SCE_H_DEFAULT);
-		}
-	}
-
-	if (sc.state >= SCE_H_DEFAULT && sc.state <= SCE_H_SGML_BLOCK_DEFAULT) {
-		ColouriseHTMLPiece(sc, keywordlists);
-	}
-
-	// Handle some PHP script
-	if (sc.state == SCE_HPHP_WORD) {
-		if (!IsPhpWordChar(static_cast<char>(sc.ch))) {
-			sc.SetState(SCE_HPHP_DEFAULT);
-		}
-	} else if (sc.state == SCE_HPHP_COMMENTLINE) {
-		if (sc.ch == '\r' || sc.ch == '\n') {
-			sc.SetState(SCE_HPHP_DEFAULT);
-		}
-	} else if (sc.state == SCE_HPHP_COMMENT) {
-		if (sc.Match('*', '/')) {
-			sc.Forward();
-			sc.Forward();
-			sc.SetState(SCE_HPHP_DEFAULT);
-		}
-	} else if (sc.state == SCE_HPHP_HSTRING) {
-		if (sc.ch == '\"') {
-			sc.ForwardSetState(SCE_HPHP_DEFAULT);
-		}
-	} else if (sc.state == SCE_HPHP_SIMPLESTRING) {
-		if (sc.ch == '\'') {
-			sc.ForwardSetState(SCE_HPHP_DEFAULT);
-		}
-	} else if (sc.state == SCE_HPHP_VARIABLE) {
-		if (!IsPhpWordChar(static_cast<char>(sc.ch))) {
-			sc.SetState(SCE_HPHP_DEFAULT);
-		}
-	} else if (sc.state == SCE_HPHP_OPERATOR) {
-		sc.SetState(SCE_HPHP_DEFAULT);
-	}
-
-	// Enter new sc.state
-	if ((sc.state == SCE_H_DEFAULT) || (sc.state == SCE_H_TAGUNKNOWN)) {
-		if (sc.Match("<?php")) {
-			sc.SetState(SCE_H_QUESTION);
-			sc.Forward();
-			sc.Forward();
-			sc.Forward();
-			sc.Forward();
-			sc.Forward();
-			sc.SetState(SCE_HPHP_DEFAULT);
-		}
-	}
-	if (sc.state == SCE_HPHP_DEFAULT) {
-		if (IsPhpWordStart(static_cast<char>(sc.ch))) {
-			sc.SetState(SCE_HPHP_WORD);
-		} else if (sc.ch == '#') {
-			sc.SetState(SCE_HPHP_COMMENTLINE);
-		} else if (sc.Match("<!--")) {
-			sc.SetState(SCE_HPHP_COMMENTLINE);
-		} else if (sc.Match('/', '/')) {
-			sc.SetState(SCE_HPHP_COMMENTLINE);
-		} else if (sc.Match('/', '*')) {
-			sc.SetState(SCE_HPHP_COMMENT);
-		} else if (sc.ch == '\"') {
-			sc.SetState(SCE_HPHP_HSTRING);
-		} else if (sc.ch == '\'') {
-			sc.SetState(SCE_HPHP_SIMPLESTRING);
-		} else if (sc.ch == '$' && IsPhpWordStart(static_cast<char>(sc.chNext))) {
-			sc.SetState(SCE_HPHP_VARIABLE);
-		} else if (IsOperator(static_cast<char>(sc.ch))) {
-			sc.SetState(SCE_HPHP_OPERATOR);
-		}
-	}
-}
-
-static void ColourisePHPDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                                  Accessor &styler) {
-	// Lexer for HTML requires more lexical states (8 bits worth) than most lexers
-	StyleContext sc(startPos, length, initStyle, styler, static_cast<char>(STYLE_MAX));
-	for (; sc.More(); sc.Forward()) {
-		ColourisePHPPiece(sc, keywordlists);
-	}
-	sc.Complete();
-}
-
-static void ColourisePHPScriptDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-        Accessor &styler) {
-	if (startPos == 0)
-		initStyle = SCE_HPHP_DEFAULT;
-	ColouriseHTMLDoc(startPos, length, initStyle, keywordlists, styler);
-}
-
-static const char * const htmlWordListDesc[] = {
-	"HTML elements and attributes",
-	"JavaScript keywords",
-	"VBScript keywords",
-	"Python keywords",
-	"PHP keywords",
-	"SGML and DTD keywords",
-	0,
-};
-
-static const char * const phpscriptWordListDesc[] = {
-	"", //Unused
-	"", //Unused
-	"", //Unused
-	"", //Unused
-	"PHP keywords",
-	"", //Unused
-	0,
-};
-
-LexerModule lmHTML(SCLEX_HTML, ColouriseHTMLDoc, "hypertext", 0, htmlWordListDesc, 8);
-LexerModule lmXML(SCLEX_XML, ColouriseXMLDoc, "xml", 0, htmlWordListDesc, 8);
-// SCLEX_ASP and SCLEX_PHP should not be used in new code: use SCLEX_HTML instead.
-LexerModule lmASP(SCLEX_ASP, ColouriseASPDoc, "asp", 0, htmlWordListDesc, 8);
-LexerModule lmPHP(SCLEX_PHP, ColourisePHPDoc, "php", 0, htmlWordListDesc, 8);
-LexerModule lmPHPSCRIPT(SCLEX_PHPSCRIPT, ColourisePHPScriptDoc, "phpscript", 0, phpscriptWordListDesc, 8);
+LexerModule lmHTML(SCLEX_HTML, LexerHTML::LexerFactoryHTML, "hypertext", htmlWordListDesc);
+LexerModule lmXML(SCLEX_XML, LexerHTML::LexerFactoryXML, "xml", htmlWordListDesc);
+LexerModule lmPHPSCRIPT(SCLEX_PHPSCRIPT, LexerHTML::LexerFactoryPHPScript, "phpscript", phpscriptWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexHaskell.cxx b/Pythonwin/Scintilla/lexers/LexHaskell.cxx
new file mode 100644
index 000000000..4d4fe1dd6
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexHaskell.cxx
@@ -0,0 +1,1116 @@
+/******************************************************************
+ *    LexHaskell.cxx
+ *
+ *    A haskell lexer for the scintilla code control.
+ *    Some stuff "lended" from LexPython.cxx and LexCPP.cxx.
+ *    External lexer stuff inspired from the caml external lexer.
+ *    Folder copied from Python's.
+ *
+ *    Written by Tobias Engvall - tumm at dtek dot chalmers dot se
+ *
+ *    Several bug fixes by Krasimir Angelov - kr.angelov at gmail.com
+ *
+ *    Improved by kudah <kudahkukarek@gmail.com>
+ *
+ *    TODO:
+ *    * A proper lexical folder to fold group declarations, comments, pragmas,
+ *      #ifdefs, explicit layout, lists, tuples, quasi-quotes, splces, etc, etc,
+ *      etc.
+ *
+ *****************************************************************/
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "CharacterCategory.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+// See https://github.com/ghc/ghc/blob/master/compiler/parser/Lexer.x#L1682
+// Note, letter modifiers are prohibited.
+
+static int u_iswupper (int ch) {
+   CharacterCategory c = CategoriseCharacter(ch);
+   return c == ccLu || c == ccLt;
+}
+
+static int u_iswalpha (int ch) {
+   CharacterCategory c = CategoriseCharacter(ch);
+   return c == ccLl || c == ccLu || c == ccLt || c == ccLo;
+}
+
+static int u_iswalnum (int ch) {
+   CharacterCategory c = CategoriseCharacter(ch);
+   return c == ccLl || c == ccLu || c == ccLt || c == ccLo
+       || c == ccNd || c == ccNo;
+}
+
+static int u_IsHaskellSymbol(int ch) {
+   CharacterCategory c = CategoriseCharacter(ch);
+   return c == ccPc || c == ccPd || c == ccPo
+       || c == ccSm || c == ccSc || c == ccSk || c == ccSo;
+}
+
+static inline bool IsHaskellLetter(const int ch) {
+   if (IsASCII(ch)) {
+      return (ch >= 'a' && ch <= 'z')
+          || (ch >= 'A' && ch <= 'Z');
+   } else {
+      return u_iswalpha(ch) != 0;
+   }
+}
+
+static inline bool IsHaskellAlphaNumeric(const int ch) {
+   if (IsASCII(ch)) {
+      return IsAlphaNumeric(ch);
+   } else {
+      return u_iswalnum(ch) != 0;
+   }
+}
+
+static inline bool IsHaskellUpperCase(const int ch) {
+   if (IsASCII(ch)) {
+      return ch >= 'A' && ch <= 'Z';
+   } else {
+      return u_iswupper(ch) != 0;
+   }
+}
+
+static inline bool IsAnHaskellOperatorChar(const int ch) {
+   if (IsASCII(ch)) {
+      return
+         (  ch == '!' || ch == '#' || ch == '$' || ch == '%'
+         || ch == '&' || ch == '*' || ch == '+' || ch == '-'
+         || ch == '.' || ch == '/' || ch == ':' || ch == '<'
+         || ch == '=' || ch == '>' || ch == '?' || ch == '@'
+         || ch == '^' || ch == '|' || ch == '~' || ch == '\\');
+   } else {
+      return u_IsHaskellSymbol(ch) != 0;
+   }
+}
+
+static inline bool IsAHaskellWordStart(const int ch) {
+   return IsHaskellLetter(ch) || ch == '_';
+}
+
+static inline bool IsAHaskellWordChar(const int ch) {
+   return (  IsHaskellAlphaNumeric(ch)
+          || ch == '_'
+          || ch == '\'');
+}
+
+static inline bool IsCommentBlockStyle(int style) {
+   return (style >= SCE_HA_COMMENTBLOCK && style <= SCE_HA_COMMENTBLOCK3);
+}
+
+static inline bool IsCommentStyle(int style) {
+   return (style >= SCE_HA_COMMENTLINE && style <= SCE_HA_COMMENTBLOCK3)
+       || ( style == SCE_HA_LITERATE_COMMENT
+         || style == SCE_HA_LITERATE_CODEDELIM);
+}
+
+// styles which do not belong to Haskell, but to external tools
+static inline bool IsExternalStyle(int style) {
+   return ( style == SCE_HA_PREPROCESSOR
+         || style == SCE_HA_LITERATE_COMMENT
+         || style == SCE_HA_LITERATE_CODEDELIM);
+}
+
+static inline int CommentBlockStyleFromNestLevel(const unsigned int nestLevel) {
+   return SCE_HA_COMMENTBLOCK + (nestLevel % 3);
+}
+
+// Mangled version of lexlib/Accessor.cxx IndentAmount.
+// Modified to treat comment blocks as whitespace
+// plus special case for commentline/preprocessor.
+static int HaskellIndentAmount(Accessor &styler, const Sci_Position line) {
+
+   // Determines the indentation level of the current line
+   // Comment blocks are treated as whitespace
+
+   Sci_Position pos = styler.LineStart(line);
+   Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+
+   char ch = styler[pos];
+   int style = styler.StyleAt(pos);
+
+   int indent = 0;
+   bool inPrevPrefix = line > 0;
+
+   Sci_Position posPrev = inPrevPrefix ? styler.LineStart(line-1) : 0;
+
+   while ((  ch == ' ' || ch == '\t'
+          || IsCommentBlockStyle(style)
+          || style == SCE_HA_LITERATE_CODEDELIM)
+         && (pos < eol_pos)) {
+      if (inPrevPrefix) {
+         char chPrev = styler[posPrev++];
+         if (chPrev != ' ' && chPrev != '\t') {
+            inPrevPrefix = false;
+         }
+      }
+      if (ch == '\t') {
+         indent = (indent / 8 + 1) * 8;
+      } else { // Space or comment block
+         indent++;
+      }
+      pos++;
+      ch = styler[pos];
+      style = styler.StyleAt(pos);
+   }
+
+   indent += SC_FOLDLEVELBASE;
+   // if completely empty line or the start of a comment or preprocessor...
+   if (  styler.LineStart(line) == styler.Length()
+      || ch == ' '
+      || ch == '\t'
+      || ch == '\n'
+      || ch == '\r'
+      || IsCommentStyle(style)
+      || style == SCE_HA_PREPROCESSOR)
+      return indent | SC_FOLDLEVELWHITEFLAG;
+   else
+      return indent;
+}
+
+struct OptionsHaskell {
+   bool magicHash;
+   bool allowQuotes;
+   bool implicitParams;
+   bool highlightSafe;
+   bool cpp;
+   bool stylingWithinPreprocessor;
+   bool fold;
+   bool foldComment;
+   bool foldCompact;
+   bool foldImports;
+   OptionsHaskell() {
+      magicHash = true;       // Widespread use, enabled by default.
+      allowQuotes = true;     // Widespread use, enabled by default.
+      implicitParams = false; // Fell out of favor, seldom used, disabled.
+      highlightSafe = true;   // Moderately used, doesn't hurt to enable.
+      cpp = true;             // Widespread use, enabled by default;
+      stylingWithinPreprocessor = false;
+      fold = false;
+      foldComment = false;
+      foldCompact = false;
+      foldImports = false;
+   }
+};
+
+static const char * const haskellWordListDesc[] = {
+   "Keywords",
+   "FFI",
+   "Reserved operators",
+   0
+};
+
+struct OptionSetHaskell : public OptionSet<OptionsHaskell> {
+   OptionSetHaskell() {
+      DefineProperty("lexer.haskell.allow.hash", &OptionsHaskell::magicHash,
+         "Set to 0 to disallow the '#' character at the end of identifiers and "
+         "literals with the haskell lexer "
+         "(GHC -XMagicHash extension)");
+
+      DefineProperty("lexer.haskell.allow.quotes", &OptionsHaskell::allowQuotes,
+         "Set to 0 to disable highlighting of Template Haskell name quotations "
+         "and promoted constructors "
+         "(GHC -XTemplateHaskell and -XDataKinds extensions)");
+
+      DefineProperty("lexer.haskell.allow.questionmark", &OptionsHaskell::implicitParams,
+         "Set to 1 to allow the '?' character at the start of identifiers "
+         "with the haskell lexer "
+         "(GHC & Hugs -XImplicitParams extension)");
+
+      DefineProperty("lexer.haskell.import.safe", &OptionsHaskell::highlightSafe,
+         "Set to 0 to disallow \"safe\" keyword in imports "
+         "(GHC -XSafe, -XTrustworthy, -XUnsafe extensions)");
+
+      DefineProperty("lexer.haskell.cpp", &OptionsHaskell::cpp,
+         "Set to 0 to disable C-preprocessor highlighting "
+         "(-XCPP extension)");
+
+      DefineProperty("styling.within.preprocessor", &OptionsHaskell::stylingWithinPreprocessor,
+         "For Haskell code, determines whether all preprocessor code is styled in the "
+         "preprocessor style (0, the default) or only from the initial # to the end "
+         "of the command word(1)."
+         );
+
+      DefineProperty("fold", &OptionsHaskell::fold);
+
+      DefineProperty("fold.comment", &OptionsHaskell::foldComment);
+
+      DefineProperty("fold.compact", &OptionsHaskell::foldCompact);
+
+      DefineProperty("fold.haskell.imports", &OptionsHaskell::foldImports,
+         "Set to 1 to enable folding of import declarations");
+
+      DefineWordListSets(haskellWordListDesc);
+   }
+};
+
+class LexerHaskell : public DefaultLexer {
+   bool literate;
+   Sci_Position firstImportLine;
+   int firstImportIndent;
+   WordList keywords;
+   WordList ffi;
+   WordList reserved_operators;
+   OptionsHaskell options;
+   OptionSetHaskell osHaskell;
+
+   enum HashCount {
+       oneHash
+      ,twoHashes
+      ,unlimitedHashes
+   };
+
+   enum KeywordMode {
+       HA_MODE_DEFAULT = 0
+      ,HA_MODE_IMPORT1 = 1 // after "import", before "qualified" or "safe" or package name or module name.
+      ,HA_MODE_IMPORT2 = 2 // after module name, before "as" or "hiding".
+      ,HA_MODE_IMPORT3 = 3 // after "as", before "hiding"
+      ,HA_MODE_MODULE  = 4 // after "module", before module name.
+      ,HA_MODE_FFI     = 5 // after "foreign", before FFI keywords
+      ,HA_MODE_TYPE    = 6 // after "type" or "data", before "family"
+   };
+
+   enum LiterateMode {
+       LITERATE_BIRD  = 0 // if '>' is the first character on the line,
+                          //   color '>' as a codedelim and the rest of
+                          //   the line as code.
+                          // else if "\begin{code}" is the only word on the
+                          //    line except whitespace, switch to LITERATE_BLOCK
+                          // otherwise color the line as a literate comment.
+      ,LITERATE_BLOCK = 1 // if the string "\end{code}" is encountered at column
+                          //   0 ignoring all later characters, color the line
+                          //   as a codedelim and switch to LITERATE_BIRD
+                          // otherwise color the line as code.
+   };
+
+   struct HaskellLineInfo {
+      unsigned int nestLevel; // 22 bits ought to be enough for anybody
+      unsigned int nonexternalStyle; // 5 bits, widen if number of styles goes
+                                     // beyond 31.
+      bool pragma;
+      LiterateMode lmode;
+      KeywordMode mode;
+
+      HaskellLineInfo(int state) :
+         nestLevel (state >> 10)
+       , nonexternalStyle ((state >> 5) & 0x1F)
+       , pragma ((state >> 4) & 0x1)
+       , lmode (static_cast<LiterateMode>((state >> 3) & 0x1))
+       , mode (static_cast<KeywordMode>(state & 0x7))
+         {}
+
+      int ToLineState() {
+         return
+              (nestLevel << 10)
+            | (nonexternalStyle << 5)
+            | (pragma << 4)
+            | (lmode << 3)
+            | mode;
+      }
+   };
+
+   inline void skipMagicHash(StyleContext &sc, const HashCount hashes) const {
+      if (options.magicHash && sc.ch == '#') {
+         sc.Forward();
+         if (hashes == twoHashes && sc.ch == '#') {
+            sc.Forward();
+         } else if (hashes == unlimitedHashes) {
+            while (sc.ch == '#') {
+               sc.Forward();
+            }
+         }
+      }
+   }
+
+   bool LineContainsImport(const Sci_Position line, Accessor &styler) const {
+      if (options.foldImports) {
+         Sci_Position currentPos = styler.LineStart(line);
+         int style = styler.StyleAt(currentPos);
+
+         Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+
+         while (currentPos < eol_pos) {
+            int ch = styler[currentPos];
+            style = styler.StyleAt(currentPos);
+
+            if (ch == ' ' || ch == '\t'
+             || IsCommentBlockStyle(style)
+             || style == SCE_HA_LITERATE_CODEDELIM) {
+               currentPos++;
+            } else {
+               break;
+            }
+         }
+
+         return (style == SCE_HA_KEYWORD
+              && styler.Match(currentPos, "import"));
+      } else {
+         return false;
+      }
+   }
+
+   inline int IndentAmountWithOffset(Accessor &styler, const Sci_Position line) const {
+      const int indent = HaskellIndentAmount(styler, line);
+      const int indentLevel = indent & SC_FOLDLEVELNUMBERMASK;
+      return indentLevel <= ((firstImportIndent - 1) + SC_FOLDLEVELBASE)
+               ? indent
+               : (indentLevel + firstImportIndent) | (indent & ~SC_FOLDLEVELNUMBERMASK);
+   }
+
+   inline int IndentLevelRemoveIndentOffset(const int indentLevel) const {
+      return indentLevel <= ((firstImportIndent - 1) + SC_FOLDLEVELBASE)
+            ? indentLevel
+            : indentLevel - firstImportIndent;
+   }
+
+public:
+   LexerHaskell(bool literate_)
+      : DefaultLexer(literate_ ? "literatehaskell" : "haskell", literate_ ? SCLEX_LITERATEHASKELL : SCLEX_HASKELL)
+	  , literate(literate_)
+      , firstImportLine(-1)
+      , firstImportIndent(0)
+      {}
+   virtual ~LexerHaskell() {}
+
+   void SCI_METHOD Release() override {
+      delete this;
+   }
+
+   int SCI_METHOD Version() const override {
+      return lvRelease5;
+   }
+
+   const char * SCI_METHOD PropertyNames() override {
+      return osHaskell.PropertyNames();
+   }
+
+   int SCI_METHOD PropertyType(const char *name) override {
+      return osHaskell.PropertyType(name);
+   }
+
+   const char * SCI_METHOD DescribeProperty(const char *name) override {
+      return osHaskell.DescribeProperty(name);
+   }
+
+   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();
+   }
+
+   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 *) override {
+      return 0;
+   }
+
+   static ILexer5 *LexerFactoryHaskell() {
+      return new LexerHaskell(false);
+   }
+
+   static ILexer5 *LexerFactoryLiterateHaskell() {
+      return new LexerHaskell(true);
+   }
+};
+
+Sci_Position SCI_METHOD LexerHaskell::PropertySet(const char *key, const char *val) {
+   if (osHaskell.PropertySet(&options, key, val)) {
+      return 0;
+   }
+   return -1;
+}
+
+Sci_Position SCI_METHOD LexerHaskell::WordListSet(int n, const char *wl) {
+   WordList *wordListN = 0;
+   switch (n) {
+   case 0:
+      wordListN = &keywords;
+      break;
+   case 1:
+      wordListN = &ffi;
+      break;
+   case 2:
+      wordListN = &reserved_operators;
+      break;
+   }
+   Sci_Position firstModification = -1;
+   if (wordListN) {
+      WordList wlNew;
+      wlNew.Set(wl);
+      if (*wordListN != wlNew) {
+         wordListN->Set(wl);
+         firstModification = 0;
+      }
+   }
+   return firstModification;
+}
+
+void SCI_METHOD LexerHaskell::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle
+                                 ,IDocument *pAccess) {
+   LexAccessor styler(pAccess);
+
+   Sci_Position lineCurrent = styler.GetLine(startPos);
+
+   HaskellLineInfo hs = HaskellLineInfo(lineCurrent ? styler.GetLineState(lineCurrent-1) : 0);
+
+   // Do not leak onto next line
+   if (initStyle == SCE_HA_STRINGEOL)
+      initStyle = SCE_HA_DEFAULT;
+   else if (initStyle == SCE_HA_LITERATE_CODEDELIM)
+      initStyle = hs.nonexternalStyle;
+
+   StyleContext sc(startPos, length, initStyle, styler);
+
+   int base = 10;
+   bool dot = false;
+
+   bool inDashes = false;
+   bool alreadyInTheMiddleOfOperator = false;
+
+   assert(!(IsCommentBlockStyle(initStyle) && hs.nestLevel == 0));
+
+   while (sc.More()) {
+      // Check for state end
+
+      if (!IsExternalStyle(sc.state)) {
+         hs.nonexternalStyle = sc.state;
+      }
+
+      // For lexer to work, states should unconditionally forward at least one
+      // character.
+      // If they don't, they should still check if they are at line end and
+      // forward if so.
+      // If a state forwards more than one character, it should check every time
+      // that it is not a line end and cease forwarding otherwise.
+      if (sc.atLineEnd) {
+         // Remember the line state for future incremental lexing
+         styler.SetLineState(lineCurrent, hs.ToLineState());
+         lineCurrent++;
+      }
+
+      // Handle line continuation generically.
+      if (sc.ch == '\\' && (sc.chNext == '\n' || sc.chNext == '\r')
+         && (  sc.state == SCE_HA_STRING
+            || sc.state == SCE_HA_PREPROCESSOR)) {
+         // Remember the line state for future incremental lexing
+         styler.SetLineState(lineCurrent, hs.ToLineState());
+         lineCurrent++;
+
+         sc.Forward();
+         if (sc.ch == '\r' && sc.chNext == '\n') {
+            sc.Forward();
+         }
+         sc.Forward();
+
+         continue;
+      }
+
+      if (sc.atLineStart) {
+
+         if (sc.state == SCE_HA_STRING || sc.state == SCE_HA_CHARACTER) {
+            // Prevent SCE_HA_STRINGEOL from leaking back to previous line
+            sc.SetState(sc.state);
+         }
+
+         if (literate && hs.lmode == LITERATE_BIRD) {
+            if (!IsExternalStyle(sc.state)) {
+               sc.SetState(SCE_HA_LITERATE_COMMENT);
+            }
+         }
+      }
+
+      // External
+         // Literate
+      if (  literate && hs.lmode == LITERATE_BIRD && sc.atLineStart
+         && sc.ch == '>') {
+            sc.SetState(SCE_HA_LITERATE_CODEDELIM);
+            sc.ForwardSetState(hs.nonexternalStyle);
+      }
+      else if (literate && hs.lmode == LITERATE_BIRD && sc.atLineStart
+            && (  sc.ch == ' ' || sc.ch == '\t'
+               || sc.Match("\\begin{code}"))) {
+         sc.SetState(sc.state);
+
+         while ((sc.ch == ' ' || sc.ch == '\t') && sc.More())
+            sc.Forward();
+
+         if (sc.Match("\\begin{code}")) {
+            sc.Forward(static_cast<int>(strlen("\\begin{code}")));
+
+            bool correct = true;
+
+            while (!sc.atLineEnd && sc.More()) {
+               if (sc.ch != ' ' && sc.ch != '\t') {
+                  correct = false;
+               }
+               sc.Forward();
+            }
+
+            if (correct) {
+               sc.ChangeState(SCE_HA_LITERATE_CODEDELIM); // color the line end
+               hs.lmode = LITERATE_BLOCK;
+            }
+         }
+      }
+      else if (literate && hs.lmode == LITERATE_BLOCK && sc.atLineStart
+            && sc.Match("\\end{code}")) {
+         sc.SetState(SCE_HA_LITERATE_CODEDELIM);
+
+         sc.Forward(static_cast<int>(strlen("\\end{code}")));
+
+         while (!sc.atLineEnd && sc.More()) {
+            sc.Forward();
+         }
+
+         sc.SetState(SCE_HA_LITERATE_COMMENT);
+         hs.lmode = LITERATE_BIRD;
+      }
+         // Preprocessor
+      else if (sc.atLineStart && sc.ch == '#' && options.cpp
+            && (!options.stylingWithinPreprocessor || sc.state == SCE_HA_DEFAULT)) {
+         sc.SetState(SCE_HA_PREPROCESSOR);
+         sc.Forward();
+      }
+            // Literate
+      else if (sc.state == SCE_HA_LITERATE_COMMENT) {
+         sc.Forward();
+      }
+      else if (sc.state == SCE_HA_LITERATE_CODEDELIM) {
+         sc.ForwardSetState(hs.nonexternalStyle);
+      }
+            // Preprocessor
+      else if (sc.state == SCE_HA_PREPROCESSOR) {
+         if (sc.atLineEnd) {
+            sc.SetState(options.stylingWithinPreprocessor
+                        ? SCE_HA_DEFAULT
+                        : hs.nonexternalStyle);
+            sc.Forward(); // prevent double counting a line
+         } else if (options.stylingWithinPreprocessor && !IsHaskellLetter(sc.ch)) {
+            sc.SetState(SCE_HA_DEFAULT);
+         } else {
+            sc.Forward();
+         }
+      }
+      // Haskell
+         // Operator
+      else if (sc.state == SCE_HA_OPERATOR) {
+         int style = SCE_HA_OPERATOR;
+
+         if ( sc.ch == ':'
+            && !alreadyInTheMiddleOfOperator
+            // except "::"
+            && !( sc.chNext == ':'
+               && !IsAnHaskellOperatorChar(sc.GetRelative(2)))) {
+            style = SCE_HA_CAPITAL;
+         }
+
+         alreadyInTheMiddleOfOperator = false;
+
+         while (IsAnHaskellOperatorChar(sc.ch))
+               sc.Forward();
+
+         char s[100];
+         sc.GetCurrent(s, sizeof(s));
+
+         if (reserved_operators.InList(s))
+            style = SCE_HA_RESERVED_OPERATOR;
+
+         sc.ChangeState(style);
+         sc.SetState(SCE_HA_DEFAULT);
+      }
+         // String
+      else if (sc.state == SCE_HA_STRING) {
+         if (sc.atLineEnd) {
+            sc.ChangeState(SCE_HA_STRINGEOL);
+            sc.ForwardSetState(SCE_HA_DEFAULT);
+         } else if (sc.ch == '\"') {
+            sc.Forward();
+            skipMagicHash(sc, oneHash);
+            sc.SetState(SCE_HA_DEFAULT);
+         } else if (sc.ch == '\\') {
+            sc.Forward(2);
+         } else {
+            sc.Forward();
+         }
+      }
+         // Char
+      else if (sc.state == SCE_HA_CHARACTER) {
+         if (sc.atLineEnd) {
+            sc.ChangeState(SCE_HA_STRINGEOL);
+            sc.ForwardSetState(SCE_HA_DEFAULT);
+         } else if (sc.ch == '\'') {
+            sc.Forward();
+            skipMagicHash(sc, oneHash);
+            sc.SetState(SCE_HA_DEFAULT);
+         } else if (sc.ch == '\\') {
+            sc.Forward(2);
+         } else {
+            sc.Forward();
+         }
+      }
+         // Number
+      else if (sc.state == SCE_HA_NUMBER) {
+         if (sc.atLineEnd) {
+            sc.SetState(SCE_HA_DEFAULT);
+            sc.Forward(); // prevent double counting a line
+         } else if (IsADigit(sc.ch, base)) {
+            sc.Forward();
+         } else if (sc.ch=='.' && dot && IsADigit(sc.chNext, base)) {
+            sc.Forward(2);
+            dot = false;
+         } else if ((base == 10) &&
+                    (sc.ch == 'e' || sc.ch == 'E') &&
+                    (IsADigit(sc.chNext) || sc.chNext == '+' || sc.chNext == '-')) {
+            sc.Forward();
+            if (sc.ch == '+' || sc.ch == '-')
+                sc.Forward();
+         } else {
+            skipMagicHash(sc, twoHashes);
+            sc.SetState(SCE_HA_DEFAULT);
+         }
+      }
+         // Keyword or Identifier
+      else if (sc.state == SCE_HA_IDENTIFIER) {
+         int style = IsHaskellUpperCase(sc.ch) ? SCE_HA_CAPITAL : SCE_HA_IDENTIFIER;
+
+         assert(IsAHaskellWordStart(sc.ch));
+
+         sc.Forward();
+
+         while (sc.More()) {
+            if (IsAHaskellWordChar(sc.ch)) {
+               sc.Forward();
+            } else if (sc.ch == '.' && style == SCE_HA_CAPITAL) {
+               if (IsHaskellUpperCase(sc.chNext)) {
+                  sc.Forward();
+                  style = SCE_HA_CAPITAL;
+               } else if (IsAHaskellWordStart(sc.chNext)) {
+                  sc.Forward();
+                  style = SCE_HA_IDENTIFIER;
+               } else if (IsAnHaskellOperatorChar(sc.chNext)) {
+                  sc.Forward();
+                  style = sc.ch == ':' ? SCE_HA_CAPITAL : SCE_HA_OPERATOR;
+                  while (IsAnHaskellOperatorChar(sc.ch))
+                     sc.Forward();
+                  break;
+               } else {
+                  break;
+               }
+            } else {
+               break;
+            }
+         }
+
+         skipMagicHash(sc, unlimitedHashes);
+
+         char s[100];
+         sc.GetCurrent(s, sizeof(s));
+
+         KeywordMode new_mode = HA_MODE_DEFAULT;
+
+         if (keywords.InList(s)) {
+            style = SCE_HA_KEYWORD;
+         } else if (style == SCE_HA_CAPITAL) {
+            if (hs.mode == HA_MODE_IMPORT1 || hs.mode == HA_MODE_IMPORT3) {
+               style    = SCE_HA_MODULE;
+               new_mode = HA_MODE_IMPORT2;
+            } else if (hs.mode == HA_MODE_MODULE) {
+               style = SCE_HA_MODULE;
+            }
+         } else if (hs.mode == HA_MODE_IMPORT1 &&
+                    strcmp(s,"qualified") == 0) {
+             style    = SCE_HA_KEYWORD;
+             new_mode = HA_MODE_IMPORT1;
+         } else if (options.highlightSafe &&
+                    hs.mode == HA_MODE_IMPORT1 &&
+                    strcmp(s,"safe") == 0) {
+             style    = SCE_HA_KEYWORD;
+             new_mode = HA_MODE_IMPORT1;
+         } else if (hs.mode == HA_MODE_IMPORT2) {
+             if (strcmp(s,"as") == 0) {
+                style    = SCE_HA_KEYWORD;
+                new_mode = HA_MODE_IMPORT3;
+            } else if (strcmp(s,"hiding") == 0) {
+                style     = SCE_HA_KEYWORD;
+            }
+         } else if (hs.mode == HA_MODE_TYPE) {
+            if (strcmp(s,"family") == 0)
+               style    = SCE_HA_KEYWORD;
+         }
+
+         if (hs.mode == HA_MODE_FFI) {
+            if (ffi.InList(s)) {
+               style = SCE_HA_KEYWORD;
+               new_mode = HA_MODE_FFI;
+            }
+         }
+
+         sc.ChangeState(style);
+         sc.SetState(SCE_HA_DEFAULT);
+
+         if (strcmp(s,"import") == 0 && hs.mode != HA_MODE_FFI)
+            new_mode = HA_MODE_IMPORT1;
+         else if (strcmp(s,"module") == 0)
+            new_mode = HA_MODE_MODULE;
+         else if (strcmp(s,"foreign") == 0)
+            new_mode = HA_MODE_FFI;
+         else if (strcmp(s,"type") == 0
+               || strcmp(s,"data") == 0)
+            new_mode = HA_MODE_TYPE;
+
+         hs.mode = new_mode;
+      }
+
+         // Comments
+            // Oneliner
+      else if (sc.state == SCE_HA_COMMENTLINE) {
+         if (sc.atLineEnd) {
+            sc.SetState(hs.pragma ? SCE_HA_PRAGMA : SCE_HA_DEFAULT);
+            sc.Forward(); // prevent double counting a line
+         } else if (inDashes && sc.ch != '-' && !hs.pragma) {
+            inDashes = false;
+            if (IsAnHaskellOperatorChar(sc.ch)) {
+               alreadyInTheMiddleOfOperator = true;
+               sc.ChangeState(SCE_HA_OPERATOR);
+            }
+         } else {
+            sc.Forward();
+         }
+      }
+            // Nested
+      else if (IsCommentBlockStyle(sc.state)) {
+         if (sc.Match('{','-')) {
+            sc.SetState(CommentBlockStyleFromNestLevel(hs.nestLevel));
+            sc.Forward(2);
+            hs.nestLevel++;
+         } else if (sc.Match('-','}')) {
+            sc.Forward(2);
+            assert(hs.nestLevel > 0);
+            if (hs.nestLevel > 0)
+               hs.nestLevel--;
+            sc.SetState(
+               hs.nestLevel == 0
+                  ? (hs.pragma ? SCE_HA_PRAGMA : SCE_HA_DEFAULT)
+                  : CommentBlockStyleFromNestLevel(hs.nestLevel - 1));
+         } else {
+            sc.Forward();
+         }
+      }
+            // Pragma
+      else if (sc.state == SCE_HA_PRAGMA) {
+         if (sc.Match("#-}")) {
+            hs.pragma = false;
+            sc.Forward(3);
+            sc.SetState(SCE_HA_DEFAULT);
+         } else if (sc.Match('-','-')) {
+            sc.SetState(SCE_HA_COMMENTLINE);
+            sc.Forward(2);
+            inDashes = false;
+         } else if (sc.Match('{','-')) {
+            sc.SetState(CommentBlockStyleFromNestLevel(hs.nestLevel));
+            sc.Forward(2);
+            hs.nestLevel = 1;
+         } else {
+            sc.Forward();
+         }
+      }
+            // New state?
+      else if (sc.state == SCE_HA_DEFAULT) {
+         // Digit
+         if (IsADigit(sc.ch)) {
+            hs.mode = HA_MODE_DEFAULT;
+
+            sc.SetState(SCE_HA_NUMBER);
+            if (sc.ch == '0' && (sc.chNext == 'X' || sc.chNext == 'x')) {
+               // Match anything starting with "0x" or "0X", too
+               sc.Forward(2);
+               base = 16;
+               dot = false;
+            } else if (sc.ch == '0' && (sc.chNext == 'O' || sc.chNext == 'o')) {
+               // Match anything starting with "0o" or "0O", too
+               sc.Forward(2);
+               base = 8;
+               dot = false;
+            } else {
+               sc.Forward();
+               base = 10;
+               dot = true;
+            }
+         }
+         // Pragma
+         else if (sc.Match("{-#")) {
+            hs.pragma = true;
+            sc.SetState(SCE_HA_PRAGMA);
+            sc.Forward(3);
+         }
+         // Comment line
+         else if (sc.Match('-','-')) {
+            sc.SetState(SCE_HA_COMMENTLINE);
+            sc.Forward(2);
+            inDashes = true;
+         }
+         // Comment block
+         else if (sc.Match('{','-')) {
+            sc.SetState(CommentBlockStyleFromNestLevel(hs.nestLevel));
+            sc.Forward(2);
+            hs.nestLevel = 1;
+         }
+         // String
+         else if (sc.ch == '\"') {
+            sc.SetState(SCE_HA_STRING);
+            sc.Forward();
+         }
+         // Character or quoted name or promoted term
+         else if (sc.ch == '\'') {
+            hs.mode = HA_MODE_DEFAULT;
+
+            sc.SetState(SCE_HA_CHARACTER);
+            sc.Forward();
+
+            if (options.allowQuotes) {
+               // Quoted type ''T
+               if (sc.ch=='\'' && IsAHaskellWordStart(sc.chNext)) {
+                  sc.Forward();
+                  sc.ChangeState(SCE_HA_IDENTIFIER);
+               } else if (sc.chNext != '\'') {
+                  // Quoted name 'n or promoted constructor 'N
+                  if (IsAHaskellWordStart(sc.ch)) {
+                     sc.ChangeState(SCE_HA_IDENTIFIER);
+                  // Promoted constructor operator ':~>
+                  } else if (sc.ch == ':') {
+                     alreadyInTheMiddleOfOperator = false;
+                     sc.ChangeState(SCE_HA_OPERATOR);
+                  // Promoted list or tuple '[T]
+                  } else if (sc.ch == '[' || sc.ch== '(') {
+                     sc.ChangeState(SCE_HA_OPERATOR);
+                     sc.ForwardSetState(SCE_HA_DEFAULT);
+                  }
+               }
+            }
+         }
+         // Operator starting with '?' or an implicit parameter
+         else if (sc.ch == '?') {
+            hs.mode = HA_MODE_DEFAULT;
+
+            alreadyInTheMiddleOfOperator = false;
+            sc.SetState(SCE_HA_OPERATOR);
+
+            if (  options.implicitParams
+               && IsAHaskellWordStart(sc.chNext)
+               && !IsHaskellUpperCase(sc.chNext)) {
+               sc.Forward();
+               sc.ChangeState(SCE_HA_IDENTIFIER);
+            }
+         }
+         // Operator
+         else if (IsAnHaskellOperatorChar(sc.ch)) {
+            hs.mode = HA_MODE_DEFAULT;
+
+            sc.SetState(SCE_HA_OPERATOR);
+         }
+         // Braces and punctuation
+         else if (sc.ch == ',' || sc.ch == ';'
+               || sc.ch == '(' || sc.ch == ')'
+               || sc.ch == '[' || sc.ch == ']'
+               || sc.ch == '{' || sc.ch == '}') {
+            sc.SetState(SCE_HA_OPERATOR);
+            sc.ForwardSetState(SCE_HA_DEFAULT);
+         }
+         // Keyword or Identifier
+         else if (IsAHaskellWordStart(sc.ch)) {
+            sc.SetState(SCE_HA_IDENTIFIER);
+         // Something we don't care about
+         } else {
+            sc.Forward();
+         }
+      }
+            // This branch should never be reached.
+      else {
+         assert(false);
+         sc.Forward();
+      }
+   }
+   sc.Complete();
+}
+
+void SCI_METHOD LexerHaskell::Fold(Sci_PositionU startPos, Sci_Position length, int // initStyle
+                                  ,IDocument *pAccess) {
+   if (!options.fold)
+      return;
+
+   Accessor styler(pAccess, NULL);
+
+   Sci_Position lineCurrent = styler.GetLine(startPos);
+
+   if (lineCurrent <= firstImportLine) {
+      firstImportLine = -1; // readjust first import position
+      firstImportIndent = 0;
+   }
+
+   const Sci_Position maxPos = startPos + length;
+   const Sci_Position maxLines =
+      maxPos == styler.Length()
+         ? styler.GetLine(maxPos)
+         : styler.GetLine(maxPos - 1);  // Requested last line
+   const Sci_Position docLines = styler.GetLine(styler.Length()); // Available last line
+
+   // Backtrack to previous non-blank line so we can determine indent level
+   // for any white space lines
+   // and so we can fix any preceding fold level (which is why we go back
+   // at least one line in all cases)
+   bool importHere = LineContainsImport(lineCurrent, styler);
+   int indentCurrent = IndentAmountWithOffset(styler, lineCurrent);
+
+   while (lineCurrent > 0) {
+      lineCurrent--;
+      importHere = LineContainsImport(lineCurrent, styler);
+      indentCurrent = IndentAmountWithOffset(styler, lineCurrent);
+      if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG))
+         break;
+   }
+
+   int indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
+
+   if (importHere) {
+      indentCurrentLevel = IndentLevelRemoveIndentOffset(indentCurrentLevel);
+      if (firstImportLine == -1) {
+         firstImportLine = lineCurrent;
+         firstImportIndent = (1 + indentCurrentLevel) - SC_FOLDLEVELBASE;
+      }
+      if (firstImportLine != lineCurrent) {
+         indentCurrentLevel++;
+      }
+   }
+
+   indentCurrent = indentCurrentLevel | (indentCurrent & ~SC_FOLDLEVELNUMBERMASK);
+
+   // Process all characters to end of requested range
+   //that hangs over the end of the range.  Cap processing in all cases
+   // to end of document.
+   while (lineCurrent <= docLines && lineCurrent <= maxLines) {
+
+      // Gather info
+      Sci_Position lineNext = lineCurrent + 1;
+      importHere = false;
+      int indentNext = indentCurrent;
+
+      if (lineNext <= docLines) {
+         // Information about next line is only available if not at end of document
+         importHere = LineContainsImport(lineNext, styler);
+         indentNext = IndentAmountWithOffset(styler, lineNext);
+      }
+      if (indentNext & SC_FOLDLEVELWHITEFLAG)
+         indentNext = SC_FOLDLEVELWHITEFLAG | indentCurrentLevel;
+
+      // Skip past any blank lines for next indent level info; we skip also
+      // comments (all comments, not just those starting in column 0)
+      // which effectively folds them into surrounding code rather
+      // than screwing up folding.
+
+      while (lineNext < docLines && (indentNext & SC_FOLDLEVELWHITEFLAG)) {
+         lineNext++;
+         importHere = LineContainsImport(lineNext, styler);
+         indentNext = IndentAmountWithOffset(styler, lineNext);
+      }
+
+      int indentNextLevel = indentNext & SC_FOLDLEVELNUMBERMASK;
+
+      if (importHere) {
+         indentNextLevel = IndentLevelRemoveIndentOffset(indentNextLevel);
+         if (firstImportLine == -1) {
+            firstImportLine = lineNext;
+            firstImportIndent = (1 + indentNextLevel) - SC_FOLDLEVELBASE;
+         }
+         if (firstImportLine != lineNext) {
+            indentNextLevel++;
+         }
+      }
+
+      indentNext = indentNextLevel | (indentNext & ~SC_FOLDLEVELNUMBERMASK);
+
+      const int levelBeforeComments = Maximum(indentCurrentLevel,indentNextLevel);
+
+      // Now set all the indent levels on the lines we skipped
+      // Do this from end to start.  Once we encounter one line
+      // which is indented more than the line after the end of
+      // the comment-block, use the level of the block before
+
+      Sci_Position skipLine = lineNext;
+      int skipLevel = indentNextLevel;
+
+      while (--skipLine > lineCurrent) {
+         int skipLineIndent = IndentAmountWithOffset(styler, skipLine);
+
+         if (options.foldCompact) {
+            if ((skipLineIndent & SC_FOLDLEVELNUMBERMASK) > indentNextLevel) {
+               skipLevel = levelBeforeComments;
+            }
+
+            int whiteFlag = skipLineIndent & SC_FOLDLEVELWHITEFLAG;
+
+            styler.SetLevel(skipLine, skipLevel | whiteFlag);
+         } else {
+            if (  (skipLineIndent & SC_FOLDLEVELNUMBERMASK) > indentNextLevel
+               && !(skipLineIndent & SC_FOLDLEVELWHITEFLAG)) {
+               skipLevel = levelBeforeComments;
+            }
+
+            styler.SetLevel(skipLine, skipLevel);
+         }
+      }
+
+      int lev = indentCurrent;
+
+      if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) {
+         if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK))
+            lev |= SC_FOLDLEVELHEADERFLAG;
+      }
+
+      // Set fold level for this line and move to next line
+      styler.SetLevel(lineCurrent, options.foldCompact ? lev : lev & ~SC_FOLDLEVELWHITEFLAG);
+
+      indentCurrent = indentNext;
+      indentCurrentLevel = indentNextLevel;
+      lineCurrent = lineNext;
+   }
+
+   // NOTE: Cannot set level of last line here because indentCurrent doesn't have
+   // header flag set; the loop above is crafted to take care of this case!
+   //styler.SetLevel(lineCurrent, indentCurrent);
+}
+
+LexerModule lmHaskell(SCLEX_HASKELL, LexerHaskell::LexerFactoryHaskell, "haskell", haskellWordListDesc);
+LexerModule lmLiterateHaskell(SCLEX_LITERATEHASKELL, LexerHaskell::LexerFactoryLiterateHaskell, "literatehaskell", haskellWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexHex.cxx b/Pythonwin/Scintilla/lexers/LexHex.cxx
new file mode 100644
index 000000000..6e1099786
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexHex.cxx
@@ -0,0 +1,1045 @@
+// Scintilla source code edit control
+/** @file LexHex.cxx
+ ** Lexers for Motorola S-Record, Intel HEX and Tektronix extended HEX.
+ **
+ ** Written by Markus Heidelberg
+ **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+/*
+ *  Motorola S-Record
+ * ===============================
+ *
+ * Each record (line) is built as follows:
+ *
+ *    field       digits          states
+ *
+ *  +----------+
+ *  | start    |  1 ('S')         SCE_HEX_RECSTART
+ *  +----------+
+ *  | type     |  1               SCE_HEX_RECTYPE, (SCE_HEX_RECTYPE_UNKNOWN)
+ *  +----------+
+ *  | count    |  2               SCE_HEX_BYTECOUNT, SCE_HEX_BYTECOUNT_WRONG
+ *  +----------+
+ *  | address  |  4/6/8           SCE_HEX_NOADDRESS, SCE_HEX_DATAADDRESS, SCE_HEX_RECCOUNT, SCE_HEX_STARTADDRESS, (SCE_HEX_ADDRESSFIELD_UNKNOWN)
+ *  +----------+
+ *  | data     |  0..504/502/500  SCE_HEX_DATA_ODD, SCE_HEX_DATA_EVEN, SCE_HEX_DATA_EMPTY, (SCE_HEX_DATA_UNKNOWN)
+ *  +----------+
+ *  | checksum |  2               SCE_HEX_CHECKSUM, SCE_HEX_CHECKSUM_WRONG
+ *  +----------+
+ *
+ *
+ *  Intel HEX
+ * ===============================
+ *
+ * Each record (line) is built as follows:
+ *
+ *    field       digits          states
+ *
+ *  +----------+
+ *  | start    |  1 (':')         SCE_HEX_RECSTART
+ *  +----------+
+ *  | count    |  2               SCE_HEX_BYTECOUNT, SCE_HEX_BYTECOUNT_WRONG
+ *  +----------+
+ *  | address  |  4               SCE_HEX_NOADDRESS, SCE_HEX_DATAADDRESS, (SCE_HEX_ADDRESSFIELD_UNKNOWN)
+ *  +----------+
+ *  | type     |  2               SCE_HEX_RECTYPE, (SCE_HEX_RECTYPE_UNKNOWN)
+ *  +----------+
+ *  | data     |  0..510          SCE_HEX_DATA_ODD, SCE_HEX_DATA_EVEN, SCE_HEX_DATA_EMPTY, SCE_HEX_EXTENDEDADDRESS, SCE_HEX_STARTADDRESS, (SCE_HEX_DATA_UNKNOWN)
+ *  +----------+
+ *  | checksum |  2               SCE_HEX_CHECKSUM, SCE_HEX_CHECKSUM_WRONG
+ *  +----------+
+ *
+ *
+ * Folding:
+ *
+ *   Data records (type 0x00), which follow an extended address record (type
+ *   0x02 or 0x04), can be folded. The extended address record is the fold
+ *   point at fold level 0, the corresponding data records are set to level 1.
+ *
+ *   Any record, which is not a data record, sets the fold level back to 0.
+ *   Any line, which is not a record (blank lines and lines starting with a
+ *   character other than ':'), leaves the fold level unchanged.
+ *
+ *
+ *  Tektronix extended HEX
+ * ===============================
+ *
+ * Each record (line) is built as follows:
+ *
+ *    field       digits          states
+ *
+ *  +----------+
+ *  | start    |  1 ('%')         SCE_HEX_RECSTART
+ *  +----------+
+ *  | length   |  2               SCE_HEX_BYTECOUNT, SCE_HEX_BYTECOUNT_WRONG
+ *  +----------+
+ *  | type     |  1               SCE_HEX_RECTYPE, (SCE_HEX_RECTYPE_UNKNOWN)
+ *  +----------+
+ *  | checksum |  2               SCE_HEX_CHECKSUM, SCE_HEX_CHECKSUM_WRONG
+ *  +----------+
+ *  | address  |  9               SCE_HEX_DATAADDRESS, SCE_HEX_STARTADDRESS, (SCE_HEX_ADDRESSFIELD_UNKNOWN)
+ *  +----------+
+ *  | data     |  0..241          SCE_HEX_DATA_ODD, SCE_HEX_DATA_EVEN
+ *  +----------+
+ *
+ *
+ *  General notes for all lexers
+ * ===============================
+ *
+ * - Depending on where the helper functions are invoked, some of them have to
+ *   read beyond the current position. In case of malformed data (record too
+ *   short), it has to be ensured that this either does not have bad influence
+ *   or will be captured deliberately.
+ *
+ * - States in parentheses in the upper format descriptions indicate that they
+ *   should not appear in a valid hex file.
+ *
+ * - State SCE_HEX_GARBAGE means garbage data after the intended end of the
+ *   record, the line is too long then. This state is used in all lexers.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+// prototypes for general helper functions
+static inline bool IsNewline(const int ch);
+static int GetHexaNibble(char hd);
+static int GetHexaChar(char hd1, char hd2);
+static int GetHexaChar(Sci_PositionU pos, Accessor &styler);
+static bool ForwardWithinLine(StyleContext &sc, Sci_Position nb = 1);
+static bool PosInSameRecord(Sci_PositionU pos1, Sci_PositionU pos2, Accessor &styler);
+static Sci_Position CountByteCount(Sci_PositionU startPos, Sci_Position uncountedDigits, Accessor &styler);
+static int CalcChecksum(Sci_PositionU startPos, Sci_Position cnt, bool twosCompl, Accessor &styler);
+
+// prototypes for file format specific helper functions
+static Sci_PositionU GetSrecRecStartPosition(Sci_PositionU pos, Accessor &styler);
+static int GetSrecByteCount(Sci_PositionU recStartPos, Accessor &styler);
+static Sci_Position CountSrecByteCount(Sci_PositionU recStartPos, Accessor &styler);
+static int GetSrecAddressFieldSize(Sci_PositionU recStartPos, Accessor &styler);
+static int GetSrecAddressFieldType(Sci_PositionU recStartPos, Accessor &styler);
+static int GetSrecDataFieldType(Sci_PositionU recStartPos, Accessor &styler);
+static Sci_Position GetSrecRequiredDataFieldSize(Sci_PositionU recStartPos, Accessor &styler);
+static int GetSrecChecksum(Sci_PositionU recStartPos, Accessor &styler);
+static int CalcSrecChecksum(Sci_PositionU recStartPos, Accessor &styler);
+
+static Sci_PositionU GetIHexRecStartPosition(Sci_PositionU pos, Accessor &styler);
+static int GetIHexByteCount(Sci_PositionU recStartPos, Accessor &styler);
+static Sci_Position CountIHexByteCount(Sci_PositionU recStartPos, Accessor &styler);
+static int GetIHexAddressFieldType(Sci_PositionU recStartPos, Accessor &styler);
+static int GetIHexDataFieldType(Sci_PositionU recStartPos, Accessor &styler);
+static int GetIHexRequiredDataFieldSize(Sci_PositionU recStartPos, Accessor &styler);
+static int GetIHexChecksum(Sci_PositionU recStartPos, Accessor &styler);
+static int CalcIHexChecksum(Sci_PositionU recStartPos, Accessor &styler);
+
+static int GetTEHexDigitCount(Sci_PositionU recStartPos, Accessor &styler);
+static Sci_Position CountTEHexDigitCount(Sci_PositionU recStartPos, Accessor &styler);
+static int GetTEHexAddressFieldType(Sci_PositionU recStartPos, Accessor &styler);
+static int GetTEHexChecksum(Sci_PositionU recStartPos, Accessor &styler);
+static int CalcTEHexChecksum(Sci_PositionU recStartPos, Accessor &styler);
+
+static inline bool IsNewline(const int ch)
+{
+    return (ch == '\n' || ch == '\r');
+}
+
+static int GetHexaNibble(char hd)
+{
+	int hexValue = 0;
+
+	if (hd >= '0' && hd <= '9') {
+		hexValue += hd - '0';
+	} else if (hd >= 'A' && hd <= 'F') {
+		hexValue += hd - 'A' + 10;
+	} else if (hd >= 'a' && hd <= 'f') {
+		hexValue += hd - 'a' + 10;
+	} else {
+		return -1;
+	}
+
+	return hexValue;
+}
+
+static int GetHexaChar(char hd1, char hd2)
+{
+	int hexValue = 0;
+
+	if (hd1 >= '0' && hd1 <= '9') {
+		hexValue += 16 * (hd1 - '0');
+	} else if (hd1 >= 'A' && hd1 <= 'F') {
+		hexValue += 16 * (hd1 - 'A' + 10);
+	} else if (hd1 >= 'a' && hd1 <= 'f') {
+		hexValue += 16 * (hd1 - 'a' + 10);
+	} else {
+		return -1;
+	}
+
+	if (hd2 >= '0' && hd2 <= '9') {
+		hexValue += hd2 - '0';
+	} else if (hd2 >= 'A' && hd2 <= 'F') {
+		hexValue += hd2 - 'A' + 10;
+	} else if (hd2 >= 'a' && hd2 <= 'f') {
+		hexValue += hd2 - 'a' + 10;
+	} else {
+		return -1;
+	}
+
+	return hexValue;
+}
+
+static int GetHexaChar(Sci_PositionU pos, Accessor &styler)
+{
+	char highNibble, lowNibble;
+
+	highNibble = styler.SafeGetCharAt(pos);
+	lowNibble = styler.SafeGetCharAt(pos + 1);
+
+	return GetHexaChar(highNibble, lowNibble);
+}
+
+// Forward <nb> characters, but abort (and return false) if hitting the line
+// end. Return true if forwarding within the line was possible.
+// Avoids influence on highlighting of the subsequent line if the current line
+// is malformed (too short).
+static bool ForwardWithinLine(StyleContext &sc, Sci_Position nb)
+{
+	for (Sci_Position i = 0; i < nb; i++) {
+		if (sc.atLineEnd) {
+			// line is too short
+			sc.SetState(SCE_HEX_DEFAULT);
+			sc.Forward();
+			return false;
+		} else {
+			sc.Forward();
+		}
+	}
+
+	return true;
+}
+
+// Checks whether the given positions are in the same record.
+static bool PosInSameRecord(Sci_PositionU pos1, Sci_PositionU pos2, Accessor &styler)
+{
+	return styler.GetLine(pos1) == styler.GetLine(pos2);
+}
+
+// Count the number of digit pairs from <startPos> till end of record, ignoring
+// <uncountedDigits> digits.
+// If the record is too short, a negative count may be returned.
+static Sci_Position CountByteCount(Sci_PositionU startPos, Sci_Position uncountedDigits, Accessor &styler)
+{
+	Sci_Position cnt;
+	Sci_PositionU pos;
+
+	pos = startPos;
+
+	while (!IsNewline(styler.SafeGetCharAt(pos, '\n'))) {
+		pos++;
+	}
+
+	// number of digits in this line minus number of digits of uncounted fields
+	cnt = static_cast<Sci_Position>(pos - startPos) - uncountedDigits;
+
+	// Prepare round up if odd (digit pair incomplete), this way the byte
+	// count is considered to be valid if the checksum is incomplete.
+	if (cnt >= 0) {
+		cnt++;
+	}
+
+	// digit pairs
+	cnt /= 2;
+
+	return cnt;
+}
+
+// Calculate the checksum of the record.
+// <startPos> is the position of the first character of the starting digit
+// pair, <cnt> is the number of digit pairs.
+static int CalcChecksum(Sci_PositionU startPos, Sci_Position cnt, bool twosCompl, Accessor &styler)
+{
+	int cs = 0;
+
+	for (Sci_PositionU pos = startPos; pos < startPos + cnt; pos += 2) {
+		int val = GetHexaChar(pos, styler);
+
+		if (val < 0) {
+			return val;
+		}
+
+		// overflow does not matter
+		cs += val;
+	}
+
+	if (twosCompl) {
+		// low byte of two's complement
+		return -cs & 0xFF;
+	} else {
+		// low byte of one's complement
+		return ~cs & 0xFF;
+	}
+}
+
+// Get the position of the record "start" field (first character in line) in
+// the record around position <pos>.
+static Sci_PositionU GetSrecRecStartPosition(Sci_PositionU pos, Accessor &styler)
+{
+	while (styler.SafeGetCharAt(pos) != 'S') {
+		pos--;
+	}
+
+	return pos;
+}
+
+// Get the value of the "byte count" field, it counts the number of bytes in
+// the subsequent fields ("address", "data" and "checksum" fields).
+static int GetSrecByteCount(Sci_PositionU recStartPos, Accessor &styler)
+{
+	int val;
+
+	val = GetHexaChar(recStartPos + 2, styler);
+	if (val < 0) {
+	       val = 0;
+	}
+
+	return val;
+}
+
+// Count the number of digit pairs for the "address", "data" and "checksum"
+// fields in this record. Has to be equal to the "byte count" field value.
+// If the record is too short, a negative count may be returned.
+static Sci_Position CountSrecByteCount(Sci_PositionU recStartPos, Accessor &styler)
+{
+	return CountByteCount(recStartPos, 4, styler);
+}
+
+// Get the size of the "address" field.
+static int GetSrecAddressFieldSize(Sci_PositionU recStartPos, Accessor &styler)
+{
+	switch (styler.SafeGetCharAt(recStartPos + 1)) {
+		case '0':
+		case '1':
+		case '5':
+		case '9':
+			return 2; // 16 bit
+
+		case '2':
+		case '6':
+		case '8':
+			return 3; // 24 bit
+
+		case '3':
+		case '7':
+			return 4; // 32 bit
+
+		default:
+			return 0;
+	}
+}
+
+// Get the type of the "address" field content.
+static int GetSrecAddressFieldType(Sci_PositionU recStartPos, Accessor &styler)
+{
+	switch (styler.SafeGetCharAt(recStartPos + 1)) {
+		case '0':
+			return SCE_HEX_NOADDRESS;
+
+		case '1':
+		case '2':
+		case '3':
+			return SCE_HEX_DATAADDRESS;
+
+		case '5':
+		case '6':
+			return SCE_HEX_RECCOUNT;
+
+		case '7':
+		case '8':
+		case '9':
+			return SCE_HEX_STARTADDRESS;
+
+		default: // handle possible format extension in the future
+			return SCE_HEX_ADDRESSFIELD_UNKNOWN;
+	}
+}
+
+// Get the type of the "data" field content.
+static int GetSrecDataFieldType(Sci_PositionU recStartPos, Accessor &styler)
+{
+	switch (styler.SafeGetCharAt(recStartPos + 1)) {
+		case '0':
+		case '1':
+		case '2':
+		case '3':
+			return SCE_HEX_DATA_ODD;
+
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+			return SCE_HEX_DATA_EMPTY;
+
+		default: // handle possible format extension in the future
+			return SCE_HEX_DATA_UNKNOWN;
+	}
+}
+
+// Get the required size of the "data" field. Useless for block header and
+// ordinary data records (type S0, S1, S2, S3), return the value calculated
+// from the "byte count" and "address field" size in this case.
+static Sci_Position GetSrecRequiredDataFieldSize(Sci_PositionU recStartPos, Accessor &styler)
+{
+	switch (styler.SafeGetCharAt(recStartPos + 1)) {
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':
+			return 0;
+
+		default:
+			return GetSrecByteCount(recStartPos, styler)
+				- GetSrecAddressFieldSize(recStartPos, styler)
+				- 1; // -1 for checksum field
+	}
+}
+
+// Get the value of the "checksum" field.
+static int GetSrecChecksum(Sci_PositionU recStartPos, Accessor &styler)
+{
+	int byteCount;
+
+	byteCount = GetSrecByteCount(recStartPos, styler);
+
+	return GetHexaChar(recStartPos + 2 + byteCount * 2, styler);
+}
+
+// Calculate the checksum of the record.
+static int CalcSrecChecksum(Sci_PositionU recStartPos, Accessor &styler)
+{
+	Sci_Position byteCount;
+
+	byteCount = GetSrecByteCount(recStartPos, styler);
+
+	// sum over "byte count", "address" and "data" fields (6..510 digits)
+	return CalcChecksum(recStartPos + 2, byteCount * 2, false, styler);
+}
+
+// Get the position of the record "start" field (first character in line) in
+// the record around position <pos>.
+static Sci_PositionU GetIHexRecStartPosition(Sci_PositionU pos, Accessor &styler)
+{
+	while (styler.SafeGetCharAt(pos) != ':') {
+		pos--;
+	}
+
+	return pos;
+}
+
+// Get the value of the "byte count" field, it counts the number of bytes in
+// the "data" field.
+static int GetIHexByteCount(Sci_PositionU recStartPos, Accessor &styler)
+{
+	int val;
+
+	val = GetHexaChar(recStartPos + 1, styler);
+	if (val < 0) {
+	       val = 0;
+	}
+
+	return val;
+}
+
+// Count the number of digit pairs for the "data" field in this record. Has to
+// be equal to the "byte count" field value.
+// If the record is too short, a negative count may be returned.
+static Sci_Position CountIHexByteCount(Sci_PositionU recStartPos, Accessor &styler)
+{
+	return CountByteCount(recStartPos, 11, styler);
+}
+
+// Get the type of the "address" field content.
+static int GetIHexAddressFieldType(Sci_PositionU recStartPos, Accessor &styler)
+{
+	if (!PosInSameRecord(recStartPos, recStartPos + 7, styler)) {
+		// malformed (record too short)
+		// type cannot be determined
+		return SCE_HEX_ADDRESSFIELD_UNKNOWN;
+	}
+
+	switch (GetHexaChar(recStartPos + 7, styler)) {
+		case 0x00:
+			return SCE_HEX_DATAADDRESS;
+
+		case 0x01:
+		case 0x02:
+		case 0x03:
+		case 0x04:
+		case 0x05:
+			return SCE_HEX_NOADDRESS;
+
+		default: // handle possible format extension in the future
+			return SCE_HEX_ADDRESSFIELD_UNKNOWN;
+	}
+}
+
+// Get the type of the "data" field content.
+static int GetIHexDataFieldType(Sci_PositionU recStartPos, Accessor &styler)
+{
+	switch (GetHexaChar(recStartPos + 7, styler)) {
+		case 0x00:
+			return SCE_HEX_DATA_ODD;
+
+		case 0x01:
+			return SCE_HEX_DATA_EMPTY;
+
+		case 0x02:
+		case 0x04:
+			return SCE_HEX_EXTENDEDADDRESS;
+
+		case 0x03:
+		case 0x05:
+			return SCE_HEX_STARTADDRESS;
+
+		default: // handle possible format extension in the future
+			return SCE_HEX_DATA_UNKNOWN;
+	}
+}
+
+// Get the required size of the "data" field. Useless for an ordinary data
+// record (type 00), return the "byte count" in this case.
+static int GetIHexRequiredDataFieldSize(Sci_PositionU recStartPos, Accessor &styler)
+{
+	switch (GetHexaChar(recStartPos + 7, styler)) {
+		case 0x01:
+			return 0;
+
+		case 0x02:
+		case 0x04:
+			return 2;
+
+		case 0x03:
+		case 0x05:
+			return 4;
+
+		default:
+			return GetIHexByteCount(recStartPos, styler);
+	}
+}
+
+// Get the value of the "checksum" field.
+static int GetIHexChecksum(Sci_PositionU recStartPos, Accessor &styler)
+{
+	int byteCount;
+
+	byteCount = GetIHexByteCount(recStartPos, styler);
+
+	return GetHexaChar(recStartPos + 9 + byteCount * 2, styler);
+}
+
+// Calculate the checksum of the record.
+static int CalcIHexChecksum(Sci_PositionU recStartPos, Accessor &styler)
+{
+	int byteCount;
+
+	byteCount = GetIHexByteCount(recStartPos, styler);
+
+	// sum over "byte count", "address", "type" and "data" fields (8..518 digits)
+	return CalcChecksum(recStartPos + 1, 8 + byteCount * 2, true, styler);
+}
+
+
+// Get the value of the "record length" field, it counts the number of digits in
+// the record excluding the percent.
+static int GetTEHexDigitCount(Sci_PositionU recStartPos, Accessor &styler)
+{
+	int val = GetHexaChar(recStartPos + 1, styler);
+	if (val < 0)
+	       val = 0;
+
+	return val;
+}
+
+// Count the number of digits in this record. Has to
+// be equal to the "record length" field value.
+static Sci_Position CountTEHexDigitCount(Sci_PositionU recStartPos, Accessor &styler)
+{
+	Sci_PositionU pos;
+
+	pos = recStartPos+1;
+
+	while (!IsNewline(styler.SafeGetCharAt(pos, '\n'))) {
+		pos++;
+	}
+
+	return static_cast<Sci_Position>(pos - (recStartPos+1));
+}
+
+// Get the type of the "address" field content.
+static int GetTEHexAddressFieldType(Sci_PositionU recStartPos, Accessor &styler)
+{
+	switch (styler.SafeGetCharAt(recStartPos + 3)) {
+		case '6':
+			return SCE_HEX_DATAADDRESS;
+
+		case '8':
+			return SCE_HEX_STARTADDRESS;
+
+		default: // handle possible format extension in the future
+			return SCE_HEX_ADDRESSFIELD_UNKNOWN;
+	}
+}
+
+// Get the value of the "checksum" field.
+static int GetTEHexChecksum(Sci_PositionU recStartPos, Accessor &styler)
+{
+	return GetHexaChar(recStartPos+4, styler);
+}
+
+// Calculate the checksum of the record (excluding the checksum field).
+static int CalcTEHexChecksum(Sci_PositionU recStartPos, Accessor &styler)
+{
+	Sci_PositionU pos = recStartPos +1;
+	Sci_PositionU length = GetTEHexDigitCount(recStartPos, styler);
+
+	int cs = GetHexaNibble(styler.SafeGetCharAt(pos++));//length
+	cs += GetHexaNibble(styler.SafeGetCharAt(pos++));//length
+
+	cs += GetHexaNibble(styler.SafeGetCharAt(pos++));//type
+
+	pos += 2;// jump over CS field
+
+	for (; pos <= recStartPos + length; ++pos) {
+		int val = GetHexaNibble(styler.SafeGetCharAt(pos));
+
+		if (val < 0) {
+			return val;
+		}
+
+		// overflow does not matter
+		cs += val;
+	}
+
+	// low byte
+	return cs & 0xFF;
+
+}
+
+static void ColouriseSrecDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[], Accessor &styler)
+{
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	while (sc.More()) {
+		Sci_PositionU recStartPos;
+		Sci_Position reqByteCount;
+		Sci_Position dataFieldSize;
+		int byteCount, addrFieldSize, addrFieldType, dataFieldType;
+		int cs1, cs2;
+
+		switch (sc.state) {
+			case SCE_HEX_DEFAULT:
+				if (sc.atLineStart && sc.Match('S')) {
+					sc.SetState(SCE_HEX_RECSTART);
+				}
+				ForwardWithinLine(sc);
+				break;
+
+			case SCE_HEX_RECSTART:
+				recStartPos = sc.currentPos - 1;
+				addrFieldType = GetSrecAddressFieldType(recStartPos, styler);
+
+				if (addrFieldType == SCE_HEX_ADDRESSFIELD_UNKNOWN) {
+					sc.SetState(SCE_HEX_RECTYPE_UNKNOWN);
+				} else {
+					sc.SetState(SCE_HEX_RECTYPE);
+				}
+
+				ForwardWithinLine(sc);
+				break;
+
+			case SCE_HEX_RECTYPE:
+			case SCE_HEX_RECTYPE_UNKNOWN:
+				recStartPos = sc.currentPos - 2;
+				byteCount = GetSrecByteCount(recStartPos, styler);
+				reqByteCount = GetSrecAddressFieldSize(recStartPos, styler)
+						+ GetSrecRequiredDataFieldSize(recStartPos, styler)
+						+ 1; // +1 for checksum field
+
+				if (byteCount == CountSrecByteCount(recStartPos, styler)
+						&& byteCount == reqByteCount) {
+					sc.SetState(SCE_HEX_BYTECOUNT);
+				} else {
+					sc.SetState(SCE_HEX_BYTECOUNT_WRONG);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+			case SCE_HEX_BYTECOUNT:
+			case SCE_HEX_BYTECOUNT_WRONG:
+				recStartPos = sc.currentPos - 4;
+				addrFieldSize = GetSrecAddressFieldSize(recStartPos, styler);
+				addrFieldType = GetSrecAddressFieldType(recStartPos, styler);
+
+				sc.SetState(addrFieldType);
+				ForwardWithinLine(sc, addrFieldSize * 2);
+				break;
+
+			case SCE_HEX_NOADDRESS:
+			case SCE_HEX_DATAADDRESS:
+			case SCE_HEX_RECCOUNT:
+			case SCE_HEX_STARTADDRESS:
+			case SCE_HEX_ADDRESSFIELD_UNKNOWN:
+				recStartPos = GetSrecRecStartPosition(sc.currentPos, styler);
+				dataFieldType = GetSrecDataFieldType(recStartPos, styler);
+
+				// Using the required size here if possible has the effect that the
+				// checksum is highlighted at a fixed position after this field for
+				// specific record types, independent on the "byte count" value.
+				dataFieldSize = GetSrecRequiredDataFieldSize(recStartPos, styler);
+
+				sc.SetState(dataFieldType);
+
+				if (dataFieldType == SCE_HEX_DATA_ODD) {
+					for (int i = 0; i < dataFieldSize * 2; i++) {
+						if ((i & 0x3) == 0) {
+							sc.SetState(SCE_HEX_DATA_ODD);
+						} else if ((i & 0x3) == 2) {
+							sc.SetState(SCE_HEX_DATA_EVEN);
+						}
+
+						if (!ForwardWithinLine(sc)) {
+							break;
+						}
+					}
+				} else {
+					ForwardWithinLine(sc, dataFieldSize * 2);
+				}
+				break;
+
+			case SCE_HEX_DATA_ODD:
+			case SCE_HEX_DATA_EVEN:
+			case SCE_HEX_DATA_EMPTY:
+			case SCE_HEX_DATA_UNKNOWN:
+				recStartPos = GetSrecRecStartPosition(sc.currentPos, styler);
+				cs1 = CalcSrecChecksum(recStartPos, styler);
+				cs2 = GetSrecChecksum(recStartPos, styler);
+
+				if (cs1 != cs2 || cs1 < 0 || cs2 < 0) {
+					sc.SetState(SCE_HEX_CHECKSUM_WRONG);
+				} else {
+					sc.SetState(SCE_HEX_CHECKSUM);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+			case SCE_HEX_CHECKSUM:
+			case SCE_HEX_CHECKSUM_WRONG:
+			case SCE_HEX_GARBAGE:
+				// record finished or line too long
+				sc.SetState(SCE_HEX_GARBAGE);
+				ForwardWithinLine(sc);
+				break;
+
+			default:
+				// prevent endless loop in faulty state
+				sc.SetState(SCE_HEX_DEFAULT);
+				break;
+		}
+	}
+	sc.Complete();
+}
+
+static void ColouriseIHexDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[], Accessor &styler)
+{
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	while (sc.More()) {
+		Sci_PositionU recStartPos;
+		int byteCount, addrFieldType, dataFieldSize, dataFieldType;
+		int cs1, cs2;
+
+		switch (sc.state) {
+			case SCE_HEX_DEFAULT:
+				if (sc.atLineStart && sc.Match(':')) {
+					sc.SetState(SCE_HEX_RECSTART);
+				}
+				ForwardWithinLine(sc);
+				break;
+
+			case SCE_HEX_RECSTART:
+				recStartPos = sc.currentPos - 1;
+				byteCount = GetIHexByteCount(recStartPos, styler);
+				dataFieldSize = GetIHexRequiredDataFieldSize(recStartPos, styler);
+
+				if (byteCount == CountIHexByteCount(recStartPos, styler)
+						&& byteCount == dataFieldSize) {
+					sc.SetState(SCE_HEX_BYTECOUNT);
+				} else {
+					sc.SetState(SCE_HEX_BYTECOUNT_WRONG);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+			case SCE_HEX_BYTECOUNT:
+			case SCE_HEX_BYTECOUNT_WRONG:
+				recStartPos = sc.currentPos - 3;
+				addrFieldType = GetIHexAddressFieldType(recStartPos, styler);
+
+				sc.SetState(addrFieldType);
+				ForwardWithinLine(sc, 4);
+				break;
+
+			case SCE_HEX_NOADDRESS:
+			case SCE_HEX_DATAADDRESS:
+			case SCE_HEX_ADDRESSFIELD_UNKNOWN:
+				recStartPos = sc.currentPos - 7;
+				addrFieldType = GetIHexAddressFieldType(recStartPos, styler);
+
+				if (addrFieldType == SCE_HEX_ADDRESSFIELD_UNKNOWN) {
+					sc.SetState(SCE_HEX_RECTYPE_UNKNOWN);
+				} else {
+					sc.SetState(SCE_HEX_RECTYPE);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+			case SCE_HEX_RECTYPE:
+			case SCE_HEX_RECTYPE_UNKNOWN:
+				recStartPos = sc.currentPos - 9;
+				dataFieldType = GetIHexDataFieldType(recStartPos, styler);
+
+				// Using the required size here if possible has the effect that the
+				// checksum is highlighted at a fixed position after this field for
+				// specific record types, independent on the "byte count" value.
+				dataFieldSize = GetIHexRequiredDataFieldSize(recStartPos, styler);
+
+				sc.SetState(dataFieldType);
+
+				if (dataFieldType == SCE_HEX_DATA_ODD) {
+					for (int i = 0; i < dataFieldSize * 2; i++) {
+						if ((i & 0x3) == 0) {
+							sc.SetState(SCE_HEX_DATA_ODD);
+						} else if ((i & 0x3) == 2) {
+							sc.SetState(SCE_HEX_DATA_EVEN);
+						}
+
+						if (!ForwardWithinLine(sc)) {
+							break;
+						}
+					}
+				} else {
+					ForwardWithinLine(sc, dataFieldSize * 2);
+				}
+				break;
+
+			case SCE_HEX_DATA_ODD:
+			case SCE_HEX_DATA_EVEN:
+			case SCE_HEX_DATA_EMPTY:
+			case SCE_HEX_EXTENDEDADDRESS:
+			case SCE_HEX_STARTADDRESS:
+			case SCE_HEX_DATA_UNKNOWN:
+				recStartPos = GetIHexRecStartPosition(sc.currentPos, styler);
+				cs1 = CalcIHexChecksum(recStartPos, styler);
+				cs2 = GetIHexChecksum(recStartPos, styler);
+
+				if (cs1 != cs2 || cs1 < 0 || cs2 < 0) {
+					sc.SetState(SCE_HEX_CHECKSUM_WRONG);
+				} else {
+					sc.SetState(SCE_HEX_CHECKSUM);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+			case SCE_HEX_CHECKSUM:
+			case SCE_HEX_CHECKSUM_WRONG:
+			case SCE_HEX_GARBAGE:
+				// record finished or line too long
+				sc.SetState(SCE_HEX_GARBAGE);
+				ForwardWithinLine(sc);
+				break;
+
+			default:
+				// prevent endless loop in faulty state
+				sc.SetState(SCE_HEX_DEFAULT);
+				break;
+		}
+	}
+	sc.Complete();
+}
+
+static void FoldIHexDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler)
+{
+	Sci_PositionU endPos = startPos + length;
+
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelCurrent = SC_FOLDLEVELBASE;
+	if (lineCurrent > 0)
+		levelCurrent = styler.LevelAt(lineCurrent - 1);
+
+	Sci_PositionU lineStartNext = styler.LineStart(lineCurrent + 1);
+	int levelNext = SC_FOLDLEVELBASE; // default if no specific line found
+
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		bool atEOL = i == (lineStartNext - 1);
+		int style = styler.StyleAt(i);
+
+		// search for specific lines
+		if (style == SCE_HEX_EXTENDEDADDRESS) {
+			// extended addres record
+			levelNext = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;
+		} else if (style == SCE_HEX_DATAADDRESS
+			|| (style == SCE_HEX_DEFAULT
+				&& i == (Sci_PositionU)styler.LineStart(lineCurrent))) {
+			// data record or no record start code at all
+			if (levelCurrent & SC_FOLDLEVELHEADERFLAG) {
+				levelNext = SC_FOLDLEVELBASE + 1;
+			} else {
+				// continue level 0 or 1, no fold point
+				levelNext = levelCurrent;
+			}
+		}
+
+		if (atEOL || (i == endPos - 1)) {
+			styler.SetLevel(lineCurrent, levelNext);
+
+			lineCurrent++;
+			lineStartNext = styler.LineStart(lineCurrent + 1);
+			levelCurrent = levelNext;
+			levelNext = SC_FOLDLEVELBASE;
+		}
+	}
+}
+
+static void ColouriseTEHexDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[], Accessor &styler)
+{
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	while (sc.More()) {
+		Sci_PositionU recStartPos;
+		int digitCount, addrFieldType;
+		int cs1, cs2;
+
+		switch (sc.state) {
+			case SCE_HEX_DEFAULT:
+				if (sc.atLineStart && sc.Match('%')) {
+					sc.SetState(SCE_HEX_RECSTART);
+				}
+				ForwardWithinLine(sc);
+				break;
+
+			case SCE_HEX_RECSTART:
+
+				recStartPos = sc.currentPos - 1;
+
+				if (GetTEHexDigitCount(recStartPos, styler) == CountTEHexDigitCount(recStartPos, styler)) {
+					sc.SetState(SCE_HEX_BYTECOUNT);
+				} else {
+					sc.SetState(SCE_HEX_BYTECOUNT_WRONG);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+			case SCE_HEX_BYTECOUNT:
+			case SCE_HEX_BYTECOUNT_WRONG:
+				recStartPos = sc.currentPos - 3;
+				addrFieldType = GetTEHexAddressFieldType(recStartPos, styler);
+
+				if (addrFieldType == SCE_HEX_ADDRESSFIELD_UNKNOWN) {
+					sc.SetState(SCE_HEX_RECTYPE_UNKNOWN);
+				} else {
+					sc.SetState(SCE_HEX_RECTYPE);
+				}
+
+				ForwardWithinLine(sc);
+				break;
+
+			case SCE_HEX_RECTYPE:
+			case SCE_HEX_RECTYPE_UNKNOWN:
+				recStartPos = sc.currentPos - 4;
+				cs1 = CalcTEHexChecksum(recStartPos, styler);
+				cs2 = GetTEHexChecksum(recStartPos, styler);
+
+				if (cs1 != cs2 || cs1 < 0 || cs2 < 0) {
+					sc.SetState(SCE_HEX_CHECKSUM_WRONG);
+				} else {
+					sc.SetState(SCE_HEX_CHECKSUM);
+				}
+
+				ForwardWithinLine(sc, 2);
+				break;
+
+
+			case SCE_HEX_CHECKSUM:
+			case SCE_HEX_CHECKSUM_WRONG:
+				recStartPos = sc.currentPos - 6;
+				addrFieldType = GetTEHexAddressFieldType(recStartPos, styler);
+
+				sc.SetState(addrFieldType);
+				ForwardWithinLine(sc, 9);
+				break;
+
+			case SCE_HEX_DATAADDRESS:
+			case SCE_HEX_STARTADDRESS:
+			case SCE_HEX_ADDRESSFIELD_UNKNOWN:
+				recStartPos = sc.currentPos - 15;
+				digitCount = GetTEHexDigitCount(recStartPos, styler) - 14;
+
+				sc.SetState(SCE_HEX_DATA_ODD);
+
+				for (int i = 0; i < digitCount; i++) {
+					if ((i & 0x3) == 0) {
+						sc.SetState(SCE_HEX_DATA_ODD);
+					} else if ((i & 0x3) == 2) {
+						sc.SetState(SCE_HEX_DATA_EVEN);
+					}
+
+					if (!ForwardWithinLine(sc)) {
+						break;
+					}
+				}
+				break;
+
+			case SCE_HEX_DATA_ODD:
+			case SCE_HEX_DATA_EVEN:
+			case SCE_HEX_GARBAGE:
+				// record finished or line too long
+				sc.SetState(SCE_HEX_GARBAGE);
+				ForwardWithinLine(sc);
+				break;
+
+			default:
+				// prevent endless loop in faulty state
+				sc.SetState(SCE_HEX_DEFAULT);
+				break;
+		}
+	}
+	sc.Complete();
+}
+
+LexerModule lmSrec(SCLEX_SREC, ColouriseSrecDoc, "srec", 0, NULL);
+LexerModule lmIHex(SCLEX_IHEX, ColouriseIHexDoc, "ihex", FoldIHexDoc, NULL);
+LexerModule lmTEHex(SCLEX_TEHEX, ColouriseTEHexDoc, "tehex", 0, NULL);
diff --git a/Pythonwin/Scintilla/lexers/LexHollywood.cxx b/Pythonwin/Scintilla/lexers/LexHollywood.cxx
new file mode 100644
index 000000000..673381282
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexHollywood.cxx
@@ -0,0 +1,516 @@
+// Scintilla source code edit control
+/** @file LexHollywood.cxx
+ ** Lexer for Hollywood
+ ** Written by Andreas Falkenhahn, based on the BlitzBasic/PureBasic/Lua lexers
+ ** Thanks to Nicholai Benalal
+ ** For more information on Hollywood, see http://www.hollywood-mal.com/
+ ** Mail me (andreas <at> airsoftsoftwair <dot> de) for any bugs.
+ ** This code is subject to the same license terms as the rest of the Scintilla project:
+ ** The License.txt file describes the conditions under which this software may be distributed. 
+ **/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+#include <map>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+/* Bits:
+ * 1  - whitespace
+ * 2  - operator
+ * 4  - identifier
+ * 8  - decimal digit
+ * 16 - hex digit
+ * 32 - bin digit
+ * 64 - letter
+ */
+static int character_classification[128] =
+{
+	0, // NUL ($0)
+	0, // SOH ($1)
+	0, // STX ($2)
+	0, // ETX ($3)
+	0, // EOT ($4)
+	0, // ENQ ($5)
+	0, // ACK ($6)
+	0, // BEL ($7)
+	0, // BS ($8)
+	1, // HT ($9)
+	1, // LF ($A)
+	0, // VT ($B)
+	0, // FF ($C)
+	1, // CR ($D)
+	0, // SO ($E)
+	0, // SI ($F)
+	0, // DLE ($10)
+	0, // DC1 ($11)
+	0, // DC2 ($12)
+	0, // DC3 ($13)
+	0, // DC4 ($14)
+	0, // NAK ($15)
+	0, // SYN ($16)
+	0, // ETB ($17)
+	0, // CAN ($18)
+	0, // EM ($19)
+	0, // SUB ($1A)
+	0, // ESC ($1B)
+	0, // FS ($1C)
+	0, // GS ($1D)
+	0, // RS ($1E)
+	0, // US ($1F)
+	1, // space ($20)
+	4, // ! ($21)
+	0, // " ($22)
+	0, // # ($23)
+	4, // $ ($24)
+	2, // % ($25)
+	2, // & ($26)
+	2, // ' ($27)
+	2, // ( ($28)
+	2, // ) ($29)
+	2, // * ($2A)
+	2, // + ($2B)
+	2, // , ($2C)
+	2, // - ($2D)
+	// NB: we treat "." as an identifier although it is also an operator and a decimal digit
+	// the reason why we treat it as an identifier is to support syntax highlighting for
+	// plugin commands which always use a "." in their names, e.g. pdf.OpenDocument();
+	// we handle the decimal digit case manually below so that 3.1415 and .123 is styled correctly
+	// the collateral damage of treating "." as an identifier is that "." is never styled
+	// SCE_HOLLYWOOD_OPERATOR
+	4, // . ($2E) 
+	2, // / ($2F)
+	28, // 0 ($30)
+	28, // 1 ($31)
+	28, // 2 ($32)
+	28, // 3 ($33)
+	28, // 4 ($34)
+	28, // 5 ($35)
+	28, // 6 ($36)
+	28, // 7 ($37)
+	28, // 8 ($38)
+	28, // 9 ($39)
+	2, // : ($3A)
+	2, // ; ($3B)
+	2, // < ($3C)
+	2, // = ($3D)
+	2, // > ($3E)
+	2, // ? ($3F)
+	0, // @ ($40)
+	84, // A ($41)
+	84, // B ($42)
+	84, // C ($43)
+	84, // D ($44)
+	84, // E ($45)
+	84, // F ($46)
+	68, // G ($47)
+	68, // H ($48)
+	68, // I ($49)
+	68, // J ($4A)
+	68, // K ($4B)
+	68, // L ($4C)
+	68, // M ($4D)
+	68, // N ($4E)
+	68, // O ($4F)
+	68, // P ($50)
+	68, // Q ($51)
+	68, // R ($52)
+	68, // S ($53)
+	68, // T ($54)
+	68, // U ($55)
+	68, // V ($56)
+	68, // W ($57)
+	68, // X ($58)
+	68, // Y ($59)
+	68, // Z ($5A)
+	2, // [ ($5B)
+	2, // \ ($5C)
+	2, // ] ($5D)
+	2, // ^ ($5E)
+	68, // _ ($5F)
+	2, // ` ($60)
+	84, // a ($61)
+	84, // b ($62)
+	84, // c ($63)
+	84, // d ($64)
+	84, // e ($65)
+	84, // f ($66)
+	68, // g ($67)
+	68, // h ($68)
+	68, // i ($69)
+	68, // j ($6A)
+	68, // k ($6B)
+	68, // l ($6C)
+	68, // m ($6D)
+	68, // n ($6E)
+	68, // o ($6F)
+	68, // p ($70)
+	68, // q ($71)
+	68, // r ($72)
+	68, // s ($73)
+	68, // t ($74)
+	68, // u ($75)
+	68, // v ($76)
+	68, // w ($77)
+	68, // x ($78)
+	68, // y ($79)
+	68, // z ($7A)
+	2, // { ($7B)
+	2, // | ($7C)
+	2, // } ($7D)
+	2, // ~ ($7E)
+	0, // &#127; ($7F)
+};
+
+static bool IsSpace(int c) {
+	return c < 128 && (character_classification[c] & 1);
+}
+
+static bool IsOperator(int c) {
+	return c < 128 && (character_classification[c] & 2);
+}
+
+static bool IsIdentifier(int c) {
+	return c < 128 && (character_classification[c] & 4);
+}
+
+static bool IsDigit(int c) {
+	return c < 128 && (character_classification[c] & 8);
+}
+
+static bool IsHexDigit(int c) {
+	return c < 128 && (character_classification[c] & 16);
+}
+
+static int LowerCase(int c)
+{
+	if (c >= 'A' && c <= 'Z')
+		return 'a' + c - 'A';
+	return c;
+}
+
+static int CheckHollywoodFoldPoint(char const *token) {
+	if (!strcmp(token, "function")) {
+		return 1;
+	}
+	if (!strcmp(token, "endfunction")) {
+		return -1;
+	}
+	return 0;
+}
+
+// An individual named option for use in an OptionSet
+
+// Options used for LexerHollywood
+struct OptionsHollywood {
+	bool fold;
+	bool foldCompact;
+	OptionsHollywood() {
+		fold = false;
+		foldCompact = false;
+	}
+};
+
+static const char * const hollywoodWordListDesc[] = {
+	"Hollywood keywords",
+	"Hollywood standard API functions",
+	"Hollywood plugin API functions",
+	"Hollywood plugin methods",
+	0
+};
+
+struct OptionSetHollywood : public OptionSet<OptionsHollywood> {
+	OptionSetHollywood(const char * const wordListDescriptions[]) {
+		DefineProperty("fold", &OptionsHollywood::fold);
+		DefineProperty("fold.compact", &OptionsHollywood::foldCompact);
+		DefineWordListSets(wordListDescriptions);
+	}
+};
+
+class LexerHollywood : public DefaultLexer {
+	int (*CheckFoldPoint)(char const *);
+	WordList keywordlists[4];	
+	OptionsHollywood options;
+	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() override {
+		delete this;
+	}
+	int SCI_METHOD Version() const override {
+		return lvRelease5;
+	}
+	const char * SCI_METHOD PropertyNames() override {
+		return osHollywood.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return osHollywood.PropertyType(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) 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) 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 *) override {
+		return 0;
+	}
+	static ILexer5 *LexerFactoryHollywood() {
+		return new LexerHollywood(CheckHollywoodFoldPoint, hollywoodWordListDesc);
+	}
+};
+
+Sci_Position SCI_METHOD LexerHollywood::PropertySet(const char *key, const char *val) {
+	if (osHollywood.PropertySet(&options, key, val)) {
+		return 0;
+	}
+	return -1;
+}
+
+Sci_Position SCI_METHOD LexerHollywood::WordListSet(int n, const char *wl) {
+	WordList *wordListN = 0;
+	switch (n) {
+	case 0:
+		wordListN = &keywordlists[0];
+		break;
+	case 1:
+		wordListN = &keywordlists[1];
+		break;
+	case 2:
+		wordListN = &keywordlists[2];
+		break;
+	case 3:
+		wordListN = &keywordlists[3];
+		break;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN) {
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+		}
+	}
+	return firstModification;	
+}
+
+void SCI_METHOD LexerHollywood::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	LexAccessor styler(pAccess);
+
+	styler.StartAt(startPos);
+	bool inString = false;
+	
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	// Can't use sc.More() here else we miss the last character
+	for (; ; sc.Forward())
+	 {
+	 	if (sc.atLineStart) inString = false;
+	 		
+	 	if (sc.ch == '\"' && sc.chPrev != '\\') inString = !inString;
+	 		
+		if (sc.state == SCE_HOLLYWOOD_IDENTIFIER) {
+			if (!IsIdentifier(sc.ch)) {				
+				char s[100];
+				int kstates[4] = {
+					SCE_HOLLYWOOD_KEYWORD,
+					SCE_HOLLYWOOD_STDAPI,
+					SCE_HOLLYWOOD_PLUGINAPI,
+					SCE_HOLLYWOOD_PLUGINMETHOD,
+				};
+				sc.GetCurrentLowered(s, sizeof(s));
+				for (int i = 0; i < 4; i++) {
+					if (keywordlists[i].InList(s)) {
+						sc.ChangeState(kstates[i]);
+					}
+				}
+				sc.SetState(SCE_HOLLYWOOD_DEFAULT);				
+			}
+		} else if (sc.state == SCE_HOLLYWOOD_OPERATOR) {
+			
+			// always reset to default on operators because otherwise
+			// comments won't be recognized in sequences like "+/* Hello*/"
+			// --> "+/*" would be recognized as a sequence of operators
+			
+			// if (!IsOperator(sc.ch)) sc.SetState(SCE_HOLLYWOOD_DEFAULT);
+			sc.SetState(SCE_HOLLYWOOD_DEFAULT);
+			
+		} else if (sc.state == SCE_HOLLYWOOD_PREPROCESSOR) {
+			if (!IsIdentifier(sc.ch))
+				sc.SetState(SCE_HOLLYWOOD_DEFAULT);
+		} else if (sc.state == SCE_HOLLYWOOD_CONSTANT) {
+			if (!IsIdentifier(sc.ch))
+				sc.SetState(SCE_HOLLYWOOD_DEFAULT);
+		} else if (sc.state == SCE_HOLLYWOOD_NUMBER) {
+			if (!IsDigit(sc.ch) && sc.ch != '.')
+				sc.SetState(SCE_HOLLYWOOD_DEFAULT);
+		} else if (sc.state == SCE_HOLLYWOOD_HEXNUMBER) {
+			if (!IsHexDigit(sc.ch))
+				sc.SetState(SCE_HOLLYWOOD_DEFAULT);
+		} else if (sc.state == SCE_HOLLYWOOD_STRING) {
+			if (sc.ch == '"') {
+				sc.ForwardSetState(SCE_HOLLYWOOD_DEFAULT);
+			}
+			if (sc.atLineEnd) {
+				sc.SetState(SCE_HOLLYWOOD_DEFAULT);
+			}
+		} else if (sc.state == SCE_HOLLYWOOD_COMMENT) {
+			if (sc.atLineEnd) {
+				sc.SetState(SCE_HOLLYWOOD_DEFAULT);
+			}
+		} else if (sc.state == SCE_HOLLYWOOD_COMMENTBLOCK) {
+			if (sc.Match("*/") && !inString) {
+				sc.Forward();
+				sc.ForwardSetState(SCE_HOLLYWOOD_DEFAULT);
+			}
+		} else if (sc.state == SCE_HOLLYWOOD_STRINGBLOCK) {
+			if (sc.Match("]]") && !inString) {
+				sc.Forward();
+				sc.ForwardSetState(SCE_HOLLYWOOD_DEFAULT);
+			}			
+		}
+
+		if (sc.state == SCE_HOLLYWOOD_DEFAULT) {
+			if (sc.Match(';')) {
+				sc.SetState(SCE_HOLLYWOOD_COMMENT);
+			} else if (sc.Match("/*")) {
+				sc.SetState(SCE_HOLLYWOOD_COMMENTBLOCK);
+				sc.Forward();
+			} else if (sc.Match("[[")) {
+				sc.SetState(SCE_HOLLYWOOD_STRINGBLOCK);
+				sc.Forward();				
+			} else if (sc.Match('"')) {
+				sc.SetState(SCE_HOLLYWOOD_STRING);
+			} else if (sc.Match('$')) { 
+				sc.SetState(SCE_HOLLYWOOD_HEXNUMBER);
+			} else if (sc.Match("0x") || sc.Match("0X")) {  // must be before IsDigit() because of 0x
+				sc.SetState(SCE_HOLLYWOOD_HEXNUMBER);
+				sc.Forward();
+			} else if (sc.ch == '.' && (sc.chNext >= '0' && sc.chNext <= '9')) {  // ".1234" style numbers
+				sc.SetState(SCE_HOLLYWOOD_NUMBER);
+				sc.Forward();	
+			} else if (IsDigit(sc.ch)) {
+				sc.SetState(SCE_HOLLYWOOD_NUMBER);
+			} else if (sc.Match('#')) {
+				sc.SetState(SCE_HOLLYWOOD_CONSTANT);
+			} else if (sc.Match('@')) {
+				sc.SetState(SCE_HOLLYWOOD_PREPROCESSOR);	
+			} else if (IsOperator(sc.ch)) {
+				sc.SetState(SCE_HOLLYWOOD_OPERATOR);
+			} else if (IsIdentifier(sc.ch)) {
+				sc.SetState(SCE_HOLLYWOOD_IDENTIFIER);
+			}
+		}
+
+		if (!sc.More())
+			break;
+	}
+	sc.Complete();
+}
+
+void SCI_METHOD LexerHollywood::Fold(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, IDocument *pAccess) {
+
+	if (!options.fold)
+		return;
+
+	LexAccessor styler(pAccess);
+	
+	Sci_PositionU lengthDoc = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
+	int levelCurrent = levelPrev;
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	int done = 0;
+	char word[256];
+	int wordlen = 0;
+		
+	for (Sci_PositionU i = startPos; i < lengthDoc; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+		if (!done) {
+			if (wordlen) { // are we scanning a token already?
+				word[wordlen] = static_cast<char>(LowerCase(ch));
+				if (!IsIdentifier(ch)) { // done with token
+					word[wordlen] = '\0';
+					levelCurrent += CheckFoldPoint(word);
+					done = 1;
+				} else if (wordlen < 255) {
+					wordlen++;
+				}
+			} else { // start scanning at first non-whitespace character
+				if (!IsSpace(ch)) {
+					if (style != SCE_HOLLYWOOD_COMMENTBLOCK && IsIdentifier(ch)) {
+						word[0] = static_cast<char>(LowerCase(ch));
+						wordlen = 1;
+					} else // done with this line
+						done = 1;
+				}
+			}
+		}		
+
+		if (atEOL) {
+			int lev = levelPrev;
+			if (visibleChars == 0 && options.foldCompact) {
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			}
+			if ((levelCurrent > levelPrev) && (visibleChars > 0)) {
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			}
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			levelPrev = levelCurrent;
+			visibleChars = 0;
+			done = 0;
+			wordlen = 0;			
+		}
+		if (!IsSpace(ch)) {
+			visibleChars++;
+		}
+	}
+	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
+
+	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
+	styler.SetLevel(lineCurrent, levelPrev | flagsNext);	
+}
+
+LexerModule lmHollywood(SCLEX_HOLLYWOOD, LexerHollywood::LexerFactoryHollywood, "hollywood", hollywoodWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexIndent.cxx b/Pythonwin/Scintilla/lexers/LexIndent.cxx
new file mode 100644
index 000000000..053bdd928
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexIndent.cxx
@@ -0,0 +1,71 @@
+// Scintilla source code edit control
+/** @file LexIndent.cxx
+ ** Lexer for no language. Used for indentation-based folding of files.
+ **/
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static void ColouriseIndentDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[],
+                            Accessor &styler) {
+	// Indent language means all style bytes are 0 so just mark the end - no need to fill in.
+	if (length > 0) {
+		styler.StartAt(startPos + length - 1);
+		styler.StartSegment(startPos + length - 1);
+		styler.ColourTo(startPos + length - 1, 0);
+	}
+}
+
+static void FoldIndentDoc(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, WordList *[], Accessor &styler) {
+	int visibleCharsCurrent, visibleCharsNext;
+	int levelCurrent, levelNext;
+	Sci_PositionU i, lineEnd;
+	Sci_PositionU lengthDoc   = startPos + length;
+	Sci_Position  lineCurrent = styler.GetLine(startPos);
+
+	i       = styler.LineStart(lineCurrent  );
+	lineEnd = styler.LineStart(lineCurrent+1)-1;
+	if(lineEnd>=lengthDoc) lineEnd = lengthDoc-1;
+	while(styler[lineEnd]=='\n' || styler[lineEnd]=='\r') lineEnd--;
+	for(visibleCharsCurrent=0, levelCurrent=SC_FOLDLEVELBASE; !visibleCharsCurrent && i<=lineEnd; i++){
+		if(isspacechar(styler[i])) levelCurrent++;
+		else                       visibleCharsCurrent=1;
+	}
+
+	for(; i<lengthDoc; lineCurrent++) {
+		i       = styler.LineStart(lineCurrent+1);
+		lineEnd = styler.LineStart(lineCurrent+2)-1;
+		if(lineEnd>=lengthDoc) lineEnd = lengthDoc-1;
+		while(styler[lineEnd]=='\n' || styler[lineEnd]=='\r') lineEnd--;
+		for(visibleCharsNext=0, levelNext=SC_FOLDLEVELBASE; !visibleCharsNext && i<=lineEnd; i++){
+			if(isspacechar(styler[i])) levelNext++;
+			else                       visibleCharsNext=1;
+		}
+		int lev = levelCurrent;
+		if(!visibleCharsCurrent) lev |= SC_FOLDLEVELWHITEFLAG;
+		else if(levelNext > levelCurrent) lev |= SC_FOLDLEVELHEADERFLAG;
+		styler.SetLevel(lineCurrent, lev);
+		levelCurrent = levelNext;
+		visibleCharsCurrent = visibleCharsNext;
+	}
+}
+
+LexerModule lmIndent(SCLEX_INDENT, ColouriseIndentDoc, "indent", FoldIndentDoc);
diff --git a/Pythonwin/Scintilla/src/LexInno.cxx b/Pythonwin/Scintilla/lexers/LexInno.cxx
similarity index 69%
rename from Pythonwin/Scintilla/src/LexInno.cxx
rename to Pythonwin/Scintilla/lexers/LexInno.cxx
index 3af9b2f1d..5d01c0588 100644
--- a/Pythonwin/Scintilla/src/LexInno.cxx
+++ b/Pythonwin/Scintilla/lexers/LexInno.cxx
@@ -7,32 +7,34 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-static void ColouriseInnoDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler) {
+static void ColouriseInnoDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *keywordLists[], Accessor &styler) {
 	int state = SCE_INNO_DEFAULT;
 	char chPrev;
 	char ch = 0;
 	char chNext = styler[startPos];
-	int lengthDoc = startPos + length;
-	char *buffer = new char[length];
-	int bufferCount = 0;
+	Sci_Position lengthDoc = startPos + length;
+	char *buffer = new char[length+1];
+	Sci_Position bufferCount = 0;
 	bool isBOL, isEOL, isWS, isBOLWS = 0;
+	bool isCStyleComment = false;
 
 	WordList &sectionKeywords = *keywordLists[0];
 	WordList &standardKeywords = *keywordLists[1];
@@ -41,11 +43,15 @@ static void ColouriseInnoDoc(unsigned int startPos, int length, int, WordList *k
 	WordList &pascalKeywords = *keywordLists[4];
 	WordList &userKeywords = *keywordLists[5];
 
+	Sci_Position curLine = styler.GetLine(startPos);
+	int curLineState = curLine > 0 ? styler.GetLineState(curLine - 1) : 0;
+	bool isCode = (curLineState == 1);
+
 	// Go through all provided text segment
 	// using the hand-written state machine shown below
 	styler.StartAt(startPos);
 	styler.StartSegment(startPos);
-	for (int i = startPos; i < lengthDoc; i++) {
+	for (Sci_Position i = startPos; i < lengthDoc; i++) {
 		chPrev = ch;
 		ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
@@ -61,9 +67,15 @@ static void ColouriseInnoDoc(unsigned int startPos, int length, int, WordList *k
 		isEOL = (ch == '\n' || ch == '\r');
 		isWS = (ch == ' ' || ch == '\t');
 
+		if ((ch == '\r' && chNext != '\n') || (ch == '\n')) {
+			// Remember the line state for future incremental lexing
+			curLine = styler.GetLine(i);
+			styler.SetLineState(curLine, (isCode ? 1 : 0));
+		}
+
 		switch(state) {
 			case SCE_INNO_DEFAULT:
-				if (ch == ';' && isBOLWS) {
+				if (!isCode && ch == ';' && isBOLWS) {
 					// Start of a comment
 					state = SCE_INNO_COMMENT;
 				} else if (ch == '[' && isBOLWS) {
@@ -73,20 +85,24 @@ static void ColouriseInnoDoc(unsigned int startPos, int length, int, WordList *k
 				} else if (ch == '#' && isBOLWS) {
 					// Start of a preprocessor directive
 					state = SCE_INNO_PREPROC;
-				} else if (ch == '{' && chNext == '#') {
-					// Start of a preprocessor inline directive
-					state = SCE_INNO_PREPROC_INLINE;
-				} else if ((ch == '{' && (chNext == ' ' || chNext == '\t'))
-					   || (ch == '(' && chNext == '*')) {
+				} else if (!isCode && ch == '{' && chNext != '{' && chPrev != '{') {
+					// Start of an inline expansion
+					state = SCE_INNO_INLINE_EXPANSION;
+				} else if (isCode && (ch == '{' || (ch == '(' && chNext == '*'))) {
 					// Start of a Pascal comment
 					state = SCE_INNO_COMMENT_PASCAL;
+					isCStyleComment = false;
+				} else if (isCode && ch == '/' && chNext == '/') {
+					// Apparently, C-style comments are legal, too
+					state = SCE_INNO_COMMENT_PASCAL;
+					isCStyleComment = true;
 				} else if (ch == '"') {
 					// Start of a double-quote string
 					state = SCE_INNO_STRING_DOUBLE;
 				} else if (ch == '\'') {
 					// Start of a single-quote string
 					state = SCE_INNO_STRING_SINGLE;
-				} else if (isascii(ch) && (isalpha(ch) || (ch == '_'))) {
+				} else if (IsASCII(ch) && (isalpha(ch) || (ch == '_'))) {
 					// Start of an identifier
 					bufferCount = 0;
 					buffer[bufferCount++] = static_cast<char>(tolower(ch));
@@ -105,20 +121,20 @@ static void ColouriseInnoDoc(unsigned int startPos, int length, int, WordList *k
 				break;
 
 			case SCE_INNO_IDENTIFIER:
-				if (isascii(ch) && (isalnum(ch) || (ch == '_'))) {
+				if (IsASCII(ch) && (isalnum(ch) || (ch == '_'))) {
 					buffer[bufferCount++] = static_cast<char>(tolower(ch));
 				} else {
 					state = SCE_INNO_DEFAULT;
 					buffer[bufferCount] = '\0';
 
 					// Check if the buffer contains a keyword
-					if (standardKeywords.InList(buffer)) {
+					if (!isCode && standardKeywords.InList(buffer)) {
 						styler.ColourTo(i-1,SCE_INNO_KEYWORD);
-					} else if (parameterKeywords.InList(buffer)) {
+					} else if (!isCode && parameterKeywords.InList(buffer)) {
 						styler.ColourTo(i-1,SCE_INNO_PARAMETER);
-					} else if (pascalKeywords.InList(buffer)) {
+					} else if (isCode && pascalKeywords.InList(buffer)) {
 						styler.ColourTo(i-1,SCE_INNO_KEYWORD_PASCAL);
-					} else if (userKeywords.InList(buffer)) {
+					} else if (!isCode && userKeywords.InList(buffer)) {
 						styler.ColourTo(i-1,SCE_INNO_KEYWORD_USER);
 					} else {
 						styler.ColourTo(i-1,SCE_INNO_DEFAULT);
@@ -138,10 +154,11 @@ static void ColouriseInnoDoc(unsigned int startPos, int length, int, WordList *k
 					// Check if the buffer contains a section name
 					if (sectionKeywords.InList(buffer)) {
 						styler.ColourTo(i,SCE_INNO_SECTION);
+						isCode = !CompareCaseInsensitive(buffer, "code");
 					} else {
 						styler.ColourTo(i,SCE_INNO_DEFAULT);
 					}
-				} else if (isascii(ch) && (isalnum(ch) || (ch == '_'))) {
+				} else if (IsASCII(ch) && (isalnum(ch) || (ch == '_'))) {
 					buffer[bufferCount++] = static_cast<char>(tolower(ch));
 				} else {
 					state = SCE_INNO_DEFAULT;
@@ -151,7 +168,7 @@ static void ColouriseInnoDoc(unsigned int startPos, int length, int, WordList *k
 
 			case SCE_INNO_PREPROC:
 				if (isWS || isEOL) {
-					if (isascii(chPrev) && isalpha(chPrev)) {
+					if (IsASCII(chPrev) && isalpha(chPrev)) {
 						state = SCE_INNO_DEFAULT;
 						buffer[bufferCount] = '\0';
 
@@ -166,7 +183,7 @@ static void ColouriseInnoDoc(unsigned int startPos, int length, int, WordList *k
 						chNext = styler[i--];
 						ch = chPrev;
 					}
-				} else if (isascii(ch) && isalpha(ch)) {
+				} else if (IsASCII(ch) && isalpha(ch)) {
 					if (chPrev == '#' || chPrev == ' ' || chPrev == '\t')
 						bufferCount = 0;
 					buffer[bufferCount++] = static_cast<char>(tolower(ch));
@@ -187,10 +204,10 @@ static void ColouriseInnoDoc(unsigned int startPos, int length, int, WordList *k
 				}
 				break;
 
-			case SCE_INNO_PREPROC_INLINE:
+			case SCE_INNO_INLINE_EXPANSION:
 				if (ch == '}') {
 					state = SCE_INNO_DEFAULT;
-					styler.ColourTo(i,SCE_INNO_PREPROC_INLINE);
+					styler.ColourTo(i,SCE_INNO_INLINE_EXPANSION);
 				} else if (isEOL) {
 					state = SCE_INNO_DEFAULT;
 					styler.ColourTo(i,SCE_INNO_DEFAULT);
@@ -198,12 +215,19 @@ static void ColouriseInnoDoc(unsigned int startPos, int length, int, WordList *k
 				break;
 
 			case SCE_INNO_COMMENT_PASCAL:
-				if (ch == '}' || (ch == ')' && chPrev == '*')) {
-					state = SCE_INNO_DEFAULT;
-					styler.ColourTo(i,SCE_INNO_COMMENT_PASCAL);
-				} else if (isEOL) {
-					state = SCE_INNO_DEFAULT;
-					styler.ColourTo(i,SCE_INNO_DEFAULT);
+				if (isCStyleComment) {
+					if (isEOL) {
+						state = SCE_INNO_DEFAULT;
+						styler.ColourTo(i,SCE_INNO_COMMENT_PASCAL);
+					}
+				} else {
+					if (ch == '}' || (ch == ')' && chPrev == '*')) {
+						state = SCE_INNO_DEFAULT;
+						styler.ColourTo(i,SCE_INNO_COMMENT_PASCAL);
+					} else if (isEOL) {
+						state = SCE_INNO_DEFAULT;
+						styler.ColourTo(i,SCE_INNO_DEFAULT);
+					}
 				}
 				break;
 
@@ -222,17 +246,17 @@ static const char * const innoWordListDesc[] = {
 	0
 };
 
-static void FoldInnoDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
-	unsigned int endPos = startPos + length;
+static void FoldInnoDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
+	Sci_PositionU endPos = startPos + length;
 	char chNext = styler[startPos];
 
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 
 	bool sectionFlag = false;
 	int levelPrev = lineCurrent > 0 ? styler.LevelAt(lineCurrent - 1) : SC_FOLDLEVELBASE;
 	int level;
 
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler[i+1];
 		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
diff --git a/Pythonwin/Scintilla/lexers/LexJSON.cxx b/Pythonwin/Scintilla/lexers/LexJSON.cxx
new file mode 100644
index 000000000..3712e931f
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexJSON.cxx
@@ -0,0 +1,502 @@
+// Scintilla source code edit control
+/**
+ * @file LexJSON.cxx
+ * @date February 19, 2016
+ * @brief Lexer for JSON and JSON-LD formats
+ * @author nkmathew
+ *
+ * The License.txt file describes the conditions under which this software may
+ * be distributed.
+ *
+ */
+
+#include <cstdlib>
+#include <cassert>
+#include <cctype>
+#include <cstdio>
+#include <string>
+#include <vector>
+#include <map>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+static const char *const JSONWordListDesc[] = {
+	"JSON Keywords",
+	"JSON-LD Keywords",
+	0
+};
+
+/**
+ * Used to detect compact IRI/URLs in JSON-LD without first looking ahead for the
+ * colon separating the prefix and suffix
+ *
+ * https://www.w3.org/TR/json-ld/#dfn-compact-iri
+ */
+struct CompactIRI {
+	int colonCount;
+	bool foundInvalidChar;
+	CharacterSet setCompactIRI;
+	CompactIRI() {
+		colonCount = 0;
+		foundInvalidChar = false;
+		setCompactIRI = CharacterSet(CharacterSet::setAlpha, "$_-");
+	}
+	void resetState() {
+		colonCount = 0;
+		foundInvalidChar = false;
+	}
+	void checkChar(int ch) {
+		if (ch == ':') {
+			colonCount++;
+		} else {
+			foundInvalidChar |= !setCompactIRI.Contains(ch);
+		}
+	}
+	bool shouldHighlight() const {
+		return !foundInvalidChar && colonCount == 1;
+	}
+};
+
+/**
+ * Keeps track of escaped characters in strings as per:
+ *
+ * https://tools.ietf.org/html/rfc7159#section-7
+ */
+struct EscapeSequence {
+	int digitsLeft;
+	CharacterSet setHexDigits;
+	CharacterSet setEscapeChars;
+	EscapeSequence() {
+		digitsLeft = 0;
+		setHexDigits = CharacterSet(CharacterSet::setDigits, "ABCDEFabcdef");
+		setEscapeChars = CharacterSet(CharacterSet::setNone, "\\\"tnbfru/");
+	}
+	// Returns true if the following character is a valid escaped character
+	bool newSequence(int nextChar) {
+		digitsLeft = 0;
+		if (nextChar == 'u') {
+			digitsLeft = 5;
+		} else if (!setEscapeChars.Contains(nextChar)) {
+			return false;
+		}
+		return true;
+	}
+	bool atEscapeEnd() const {
+		return digitsLeft <= 0;
+	}
+	bool isInvalidChar(int currChar) const {
+		return !setHexDigits.Contains(currChar);
+	}
+};
+
+struct OptionsJSON {
+	bool foldCompact;
+	bool fold;
+	bool allowComments;
+	bool escapeSequence;
+	OptionsJSON() {
+		foldCompact = false;
+		fold = false;
+		allowComments = false;
+		escapeSequence = false;
+	}
+};
+
+struct OptionSetJSON : public OptionSet<OptionsJSON> {
+	OptionSetJSON() {
+		DefineProperty("lexer.json.escape.sequence", &OptionsJSON::escapeSequence,
+					   "Set to 1 to enable highlighting of escape sequences in strings");
+
+		DefineProperty("lexer.json.allow.comments", &OptionsJSON::allowComments,
+					   "Set to 1 to enable highlighting of line/block comments in JSON");
+
+		DefineProperty("fold.compact", &OptionsJSON::foldCompact);
+		DefineProperty("fold", &OptionsJSON::fold);
+		DefineWordListSets(JSONWordListDesc);
+	}
+};
+
+class LexerJSON : public DefaultLexer {
+	OptionsJSON options;
+	OptionSetJSON optSetJSON;
+	EscapeSequence escapeSeq;
+	WordList keywordsJSON;
+	WordList keywordsJSONLD;
+	CharacterSet setOperators;
+	CharacterSet setURL;
+	CharacterSet setKeywordJSONLD;
+	CharacterSet setKeywordJSON;
+	CompactIRI compactIRI;
+
+	static bool IsNextNonWhitespace(LexAccessor &styler, Sci_Position start, char ch) {
+		Sci_Position i = 0;
+		while (i < 50) {
+			i++;
+			char curr = styler.SafeGetCharAt(start+i, '\0');
+			char next = styler.SafeGetCharAt(start+i+1, '\0');
+			bool atEOL = (curr == '\r' && next != '\n') || (curr == '\n');
+			if (curr == ch) {
+				return true;
+			} else if (!isspacechar(curr) || atEOL) {
+				return false;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Looks for the colon following the end quote
+	 *
+	 * Assumes property names of lengths no longer than a 100 characters.
+	 * The colon is also expected to be less than 50 spaces after the end
+	 * quote for the string to be considered a property name
+	 */
+	static bool AtPropertyName(LexAccessor &styler, Sci_Position start) {
+		Sci_Position i = 0;
+		bool escaped = false;
+		while (i < 100) {
+			i++;
+			char curr = styler.SafeGetCharAt(start+i, '\0');
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			escaped = curr == '\\';
+			if (curr == '"') {
+				return IsNextNonWhitespace(styler, start+i, ':');
+			} else if (!curr) {
+				return false;
+			}
+		}
+		return false;
+	}
+
+	static bool IsNextWordInList(WordList &keywordList, CharacterSet wordSet,
+								 StyleContext &context, LexAccessor &styler) {
+		char word[51];
+		Sci_Position currPos = (Sci_Position) context.currentPos;
+		int i = 0;
+		while (i < 50) {
+			char ch = styler.SafeGetCharAt(currPos + i);
+			if (!wordSet.Contains(ch)) {
+				break;
+			}
+			word[i] = ch;
+			i++;
+		}
+		word[i] = '\0';
+		return keywordList.InList(word);
+	}
+
+	public:
+	LexerJSON() :
+		DefaultLexer("json", SCLEX_JSON),
+		setOperators(CharacterSet::setNone, "[{}]:,"),
+		setURL(CharacterSet::setAlphaNum, "-._~:/?#[]@!$&'()*+,),="),
+		setKeywordJSONLD(CharacterSet::setAlpha, ":@"),
+		setKeywordJSON(CharacterSet::setAlpha, "$_") {
+	}
+	virtual ~LexerJSON() {}
+	int SCI_METHOD Version() const override {
+		return lvRelease5;
+	}
+	void SCI_METHOD Release() override {
+		delete this;
+	}
+	const char *SCI_METHOD PropertyNames() override {
+		return optSetJSON.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return optSetJSON.PropertyType(name);
+	}
+	const char *SCI_METHOD DescribeProperty(const char *name) override {
+		return optSetJSON.DescribeProperty(name);
+	}
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override {
+		if (optSetJSON.PropertySet(&options, key, val)) {
+			return 0;
+		}
+		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) {
+			case 0:
+				wordListN = &keywordsJSON;
+				break;
+			case 1:
+				wordListN = &keywordsJSONLD;
+				break;
+		}
+		Sci_Position firstModification = -1;
+		if (wordListN) {
+			WordList wlNew;
+			wlNew.Set(wl);
+			if (*wordListN != wlNew) {
+				wordListN->Set(wl);
+				firstModification = 0;
+			}
+		}
+		return firstModification;
+	}
+	void *SCI_METHOD PrivateCall(int, void *) override {
+		return 0;
+	}
+	static ILexer5 *LexerFactoryJSON() {
+		return new LexerJSON;
+	}
+	const char *SCI_METHOD DescribeWordListSets() override {
+		return optSetJSON.DescribeWordListSets();
+	}
+	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 LexerJSON::Lex(Sci_PositionU startPos,
+							   Sci_Position length,
+							   int initStyle,
+							   IDocument *pAccess) {
+	LexAccessor styler(pAccess);
+	StyleContext context(startPos, length, initStyle, styler);
+	int stringStyleBefore = SCE_JSON_STRING;
+	while (context.More()) {
+		switch (context.state) {
+			case SCE_JSON_BLOCKCOMMENT:
+				if (context.Match("*/")) {
+					context.Forward();
+					context.ForwardSetState(SCE_JSON_DEFAULT);
+				}
+				break;
+			case SCE_JSON_LINECOMMENT:
+				if (context.atLineEnd) {
+					context.SetState(SCE_JSON_DEFAULT);
+				}
+				break;
+			case SCE_JSON_STRINGEOL:
+				if (context.atLineStart) {
+					context.SetState(SCE_JSON_DEFAULT);
+				}
+				break;
+			case SCE_JSON_ESCAPESEQUENCE:
+				escapeSeq.digitsLeft--;
+				if (!escapeSeq.atEscapeEnd()) {
+					if (escapeSeq.isInvalidChar(context.ch)) {
+						context.SetState(SCE_JSON_ERROR);
+					}
+					break;
+				}
+				if (context.ch == '"') {
+					context.SetState(stringStyleBefore);
+					context.ForwardSetState(SCE_C_DEFAULT);
+				} else if (context.ch == '\\') {
+					if (!escapeSeq.newSequence(context.chNext)) {
+						context.SetState(SCE_JSON_ERROR);
+					}
+					context.Forward();
+				} else {
+					context.SetState(stringStyleBefore);
+					if (context.atLineEnd) {
+						context.ChangeState(SCE_JSON_STRINGEOL);
+					}
+				}
+				break;
+			case SCE_JSON_PROPERTYNAME:
+			case SCE_JSON_STRING:
+				if (context.ch == '"') {
+					if (compactIRI.shouldHighlight()) {
+						context.ChangeState(SCE_JSON_COMPACTIRI);
+						context.ForwardSetState(SCE_JSON_DEFAULT);
+						compactIRI.resetState();
+					} else {
+						context.ForwardSetState(SCE_JSON_DEFAULT);
+					}
+				} else if (context.atLineEnd) {
+					context.ChangeState(SCE_JSON_STRINGEOL);
+				} else if (context.ch == '\\') {
+					stringStyleBefore = context.state;
+					if (options.escapeSequence) {
+						context.SetState(SCE_JSON_ESCAPESEQUENCE);
+						if (!escapeSeq.newSequence(context.chNext)) {
+							context.SetState(SCE_JSON_ERROR);
+						}
+					}
+					context.Forward();
+				} else if (context.Match("https://") ||
+						   context.Match("http://") ||
+						   context.Match("ssh://") ||
+						   context.Match("git://") ||
+						   context.Match("svn://") ||
+						   context.Match("ftp://") ||
+						   context.Match("mailto:")) {
+					// Handle most common URI schemes only
+					stringStyleBefore = context.state;
+					context.SetState(SCE_JSON_URI);
+				} else if (context.ch == '@') {
+					// https://www.w3.org/TR/json-ld/#dfn-keyword
+					if (IsNextWordInList(keywordsJSONLD, setKeywordJSONLD, context, styler)) {
+						stringStyleBefore = context.state;
+						context.SetState(SCE_JSON_LDKEYWORD);
+					}
+				} else {
+					compactIRI.checkChar(context.ch);
+				}
+				break;
+			case SCE_JSON_LDKEYWORD:
+			case SCE_JSON_URI:
+				if ((!setKeywordJSONLD.Contains(context.ch) &&
+					 (context.state == SCE_JSON_LDKEYWORD)) ||
+					(!setURL.Contains(context.ch))) {
+					context.SetState(stringStyleBefore);
+				}
+				if (context.ch == '"') {
+					context.ForwardSetState(SCE_JSON_DEFAULT);
+				} else if (context.atLineEnd) {
+					context.ChangeState(SCE_JSON_STRINGEOL);
+				}
+				break;
+			case SCE_JSON_OPERATOR:
+			case SCE_JSON_NUMBER:
+				context.SetState(SCE_JSON_DEFAULT);
+				break;
+			case SCE_JSON_ERROR:
+				if (context.atLineEnd) {
+					context.SetState(SCE_JSON_DEFAULT);
+				}
+				break;
+			case SCE_JSON_KEYWORD:
+				if (!setKeywordJSON.Contains(context.ch)) {
+					context.SetState(SCE_JSON_DEFAULT);
+				}
+				break;
+		}
+		if (context.state == SCE_JSON_DEFAULT) {
+			if (context.ch == '"') {
+				compactIRI.resetState();
+				context.SetState(SCE_JSON_STRING);
+				Sci_Position currPos = static_cast<Sci_Position>(context.currentPos);
+				if (AtPropertyName(styler, currPos)) {
+					context.SetState(SCE_JSON_PROPERTYNAME);
+				}
+			} else if (setOperators.Contains(context.ch)) {
+				context.SetState(SCE_JSON_OPERATOR);
+			} else if (options.allowComments && context.Match("/*")) {
+				context.SetState(SCE_JSON_BLOCKCOMMENT);
+				context.Forward();
+			} else if (options.allowComments && context.Match("//")) {
+				context.SetState(SCE_JSON_LINECOMMENT);
+			} else if (setKeywordJSON.Contains(context.ch)) {
+				if (IsNextWordInList(keywordsJSON, setKeywordJSON, context, styler)) {
+					context.SetState(SCE_JSON_KEYWORD);
+				}
+			}
+			bool numberStart =
+				IsADigit(context.ch) && (context.chPrev == '+'||
+										 context.chPrev == '-' ||
+										 context.atLineStart ||
+										 IsASpace(context.chPrev) ||
+										 setOperators.Contains(context.chPrev));
+			bool exponentPart =
+				tolower(context.ch) == 'e' &&
+				IsADigit(context.chPrev) &&
+				(IsADigit(context.chNext) ||
+				 context.chNext == '+' ||
+				 context.chNext == '-');
+			bool signPart =
+				(context.ch == '-' || context.ch == '+') &&
+				((tolower(context.chPrev) == 'e' && IsADigit(context.chNext)) ||
+				 ((IsASpace(context.chPrev) || setOperators.Contains(context.chPrev))
+				  && IsADigit(context.chNext)));
+			bool adjacentDigit =
+				IsADigit(context.ch) && IsADigit(context.chPrev);
+			bool afterExponent = IsADigit(context.ch) && tolower(context.chPrev) == 'e';
+			bool dotPart = context.ch == '.' &&
+				IsADigit(context.chPrev) &&
+				IsADigit(context.chNext);
+			bool afterDot = IsADigit(context.ch) && context.chPrev == '.';
+			if (numberStart ||
+				exponentPart ||
+				signPart ||
+				adjacentDigit ||
+				dotPart ||
+				afterExponent ||
+				afterDot) {
+				context.SetState(SCE_JSON_NUMBER);
+			} else if (context.state == SCE_JSON_DEFAULT && !IsASpace(context.ch)) {
+				context.SetState(SCE_JSON_ERROR);
+			}
+		}
+		context.Forward();
+	}
+	context.Complete();
+}
+
+void SCI_METHOD LexerJSON::Fold(Sci_PositionU startPos,
+								Sci_Position length,
+								int,
+								IDocument *pAccess) {
+	if (!options.fold) {
+		return;
+	}
+	LexAccessor styler(pAccess);
+	Sci_PositionU currLine = styler.GetLine(startPos);
+	Sci_PositionU endPos = startPos + length;
+	int currLevel = SC_FOLDLEVELBASE;
+	if (currLine > 0)
+		currLevel = styler.LevelAt(currLine - 1) >> 16;
+	int nextLevel = currLevel;
+	int visibleChars = 0;
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char curr = styler.SafeGetCharAt(i);
+		char next = styler.SafeGetCharAt(i+1);
+		bool atEOL = (curr == '\r' && next != '\n') || (curr == '\n');
+		if (styler.StyleAt(i) == SCE_JSON_OPERATOR) {
+			if (curr == '{' || curr == '[') {
+				nextLevel++;
+			} else if (curr == '}' || curr == ']') {
+				nextLevel--;
+			}
+		}
+		if (atEOL || i == (endPos-1)) {
+			int level = currLevel | nextLevel << 16;
+			if (!visibleChars && options.foldCompact) {
+				level |= SC_FOLDLEVELWHITEFLAG;
+			} else if (nextLevel > currLevel) {
+				level |= SC_FOLDLEVELHEADERFLAG;
+			}
+			if (level != styler.LevelAt(currLine)) {
+				styler.SetLevel(currLine, level);
+			}
+			currLine++;
+			currLevel = nextLevel;
+			visibleChars = 0;
+		}
+		if (!isspacechar(curr)) {
+			visibleChars++;
+		}
+	}
+}
+
+LexerModule lmJSON(SCLEX_JSON,
+				   LexerJSON::LexerFactoryJSON,
+				   "json",
+				   JSONWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexKVIrc.cxx b/Pythonwin/Scintilla/lexers/LexKVIrc.cxx
new file mode 100644
index 000000000..0cae2a234
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexKVIrc.cxx
@@ -0,0 +1,471 @@
+// Scintilla source code edit control
+/** @file LexKVIrc.cxx
+ ** Lexer for KVIrc script.
+ **/
+// Copyright 2013 by OmegaPhil <OmegaPhil+scintilla@gmail.com>, based in
+// part from LexPython Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
+// and LexCmake Copyright 2007 by Cristian Adam <cristian [dot] adam [at] gmx [dot] net>
+
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+
+/* KVIrc Script syntactic rules: http://www.kvirc.net/doc/doc_syntactic_rules.html */
+
+/* Utility functions */
+static inline bool IsAWordChar(int ch) {
+
+    /* Keyword list includes modules, i.e. words including '.', and
+     * alias namespaces include ':' */
+    return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.'
+            || ch == ':');
+}
+static inline bool IsAWordStart(int ch) {
+
+    /* Functions (start with '$') are treated separately to keywords */
+    return (ch < 0x80) && (isalnum(ch) || ch == '_' );
+}
+
+/* Interface function called by Scintilla to request some text to be
+ syntax highlighted */
+static void ColouriseKVIrcDoc(Sci_PositionU startPos, Sci_Position length,
+                              int initStyle, WordList *keywordlists[],
+                              Accessor &styler)
+{
+    /* Fetching style context */
+    StyleContext sc(startPos, length, initStyle, styler);
+
+    /* Accessing keywords and function-marking keywords */
+    WordList &keywords = *keywordlists[0];
+    WordList &functionKeywords = *keywordlists[1];
+
+    /* Looping for all characters - only automatically moving forward
+     * when asked for (transitions leaving strings and keywords do this
+     * already) */
+    bool next = true;
+    for( ; sc.More(); next ? sc.Forward() : (void)0 )
+    {
+        /* Resetting next */
+        next = true;
+
+        /* Dealing with different states */
+        switch (sc.state)
+        {
+            case SCE_KVIRC_DEFAULT:
+
+                /* Detecting single-line comments
+                 * Unfortunately KVIrc script allows raw '#<channel
+                 * name>' to be used, and appending # to an array returns
+                 * its length...
+                 * Going for a compromise where single line comments not
+                 * starting on a newline are allowed in all cases except
+                 * when they are preceeded with an opening bracket or comma
+                 * (this will probably be the most common style a valid
+                 * string-less channel name will be used with), with the
+                 * array length case included
+                 */
+                if (
+                    (sc.ch == '#' && sc.atLineStart) ||
+                    (sc.ch == '#' && (
+                        sc.chPrev != '(' && sc.chPrev != ',' &&
+                        sc.chPrev != ']')
+                    )
+                )
+                {
+                    sc.SetState(SCE_KVIRC_COMMENT);
+                    break;
+                }
+
+                /* Detecting multi-line comments */
+                if (sc.Match('/', '*'))
+                {
+                    sc.SetState(SCE_KVIRC_COMMENTBLOCK);
+                    break;
+                }
+
+                /* Detecting strings */
+                if (sc.ch == '"')
+                {
+                    sc.SetState(SCE_KVIRC_STRING);
+                    break;
+                }
+
+                /* Detecting functions */
+                if (sc.ch == '$')
+                {
+                    sc.SetState(SCE_KVIRC_FUNCTION);
+                    break;
+                }
+
+                /* Detecting variables */
+                if (sc.ch == '%')
+                {
+                    sc.SetState(SCE_KVIRC_VARIABLE);
+                    break;
+                }
+
+                /* Detecting numbers - isdigit is unsafe as it does not
+                 * validate, use CharacterSet.h functions */
+                if (IsADigit(sc.ch))
+                {
+                    sc.SetState(SCE_KVIRC_NUMBER);
+                    break;
+                }
+
+                /* Detecting words */
+                if (IsAWordStart(sc.ch) && IsAWordChar(sc.chNext))
+                {
+                    sc.SetState(SCE_KVIRC_WORD);
+                    sc.Forward();
+                    break;
+                }
+
+                /* Detecting operators */
+                if (isoperator(sc.ch))
+                {
+                    sc.SetState(SCE_KVIRC_OPERATOR);
+                    break;
+                }
+
+                break;
+
+            case SCE_KVIRC_COMMENT:
+
+                /* Breaking out of single line comment when a newline
+                 * is introduced */
+                if (sc.ch == '\r' || sc.ch == '\n')
+                {
+                    sc.SetState(SCE_KVIRC_DEFAULT);
+                    break;
+                }
+
+                break;
+
+            case SCE_KVIRC_COMMENTBLOCK:
+
+                /* Detecting end of multi-line comment */
+                if (sc.Match('*', '/'))
+                {
+                    // Moving the current position forward two characters
+                    // so that '*/' is included in the comment
+                    sc.Forward(2);
+                    sc.SetState(SCE_KVIRC_DEFAULT);
+
+                    /* Comment has been exited and the current position
+                     * moved forward, yet the new current character
+                     * has yet to be defined - loop without moving
+                     * forward again */
+                    next = false;
+                    break;
+                }
+
+                break;
+
+            case SCE_KVIRC_STRING:
+
+                /* Detecting end of string - closing speechmarks */
+                if (sc.ch == '"')
+                {
+                    /* Allowing escaped speechmarks to pass */
+                    if (sc.chPrev == '\\')
+                        break;
+
+                    /* Moving the current position forward to capture the
+                     * terminating speechmarks, and ending string */
+                    sc.ForwardSetState(SCE_KVIRC_DEFAULT);
+
+                    /* String has been exited and the current position
+                     * moved forward, yet the new current character
+                     * has yet to be defined - loop without moving
+                     * forward again */
+                    next = false;
+                    break;
+                }
+
+                /* Functions and variables are now highlighted in strings
+                 * Detecting functions */
+                if (sc.ch == '$')
+                {
+                    /* Allowing escaped functions to pass */
+                    if (sc.chPrev == '\\')
+                        break;
+
+                    sc.SetState(SCE_KVIRC_STRING_FUNCTION);
+                    break;
+                }
+
+                /* Detecting variables */
+                if (sc.ch == '%')
+                {
+                    /* Allowing escaped variables to pass */
+                    if (sc.chPrev == '\\')
+                        break;
+
+                    sc.SetState(SCE_KVIRC_STRING_VARIABLE);
+                    break;
+                }
+
+                /* Breaking out of a string when a newline is introduced */
+                if (sc.ch == '\r' || sc.ch == '\n')
+                {
+                    /* Allowing escaped newlines */
+                    if (sc.chPrev == '\\')
+                        break;
+
+                    sc.SetState(SCE_KVIRC_DEFAULT);
+                    break;
+                }
+
+                break;
+
+            case SCE_KVIRC_FUNCTION:
+            case SCE_KVIRC_VARIABLE:
+
+                /* Detecting the end of a function/variable (word) */
+                if (!IsAWordChar(sc.ch))
+                {
+                    sc.SetState(SCE_KVIRC_DEFAULT);
+
+                    /* Word has been exited yet the current character
+                     * has yet to be defined - loop without moving
+                     * forward again */
+                    next = false;
+                    break;
+                }
+
+                break;
+
+            case SCE_KVIRC_STRING_FUNCTION:
+            case SCE_KVIRC_STRING_VARIABLE:
+
+                /* A function or variable in a string
+                 * Detecting the end of a function/variable (word) */
+                if (!IsAWordChar(sc.ch))
+                {
+                    sc.SetState(SCE_KVIRC_STRING);
+
+                    /* Word has been exited yet the current character
+                     * has yet to be defined - loop without moving
+                     * forward again */
+                    next = false;
+                    break;
+                }
+
+                break;
+
+            case SCE_KVIRC_NUMBER:
+
+                /* Detecting the end of a number */
+                if (!IsADigit(sc.ch))
+                {
+                    sc.SetState(SCE_KVIRC_DEFAULT);
+
+                    /* Number has been exited yet the current character
+                     * has yet to be defined - loop without moving
+                     * forward */
+                    next = false;
+                    break;
+                }
+
+                break;
+
+            case SCE_KVIRC_OPERATOR:
+
+                /* Because '%' is an operator but is also the marker for
+                 * a variable, I need to always treat operators as single
+                 * character strings and therefore redo their detection
+                 * after every character */
+                sc.SetState(SCE_KVIRC_DEFAULT);
+
+                /* Operator has been exited yet the current character
+                 * has yet to be defined - loop without moving
+                 * forward */
+                next = false;
+                break;
+
+            case SCE_KVIRC_WORD:
+
+                /* Detecting the end of a word */
+                if (!IsAWordChar(sc.ch))
+                {
+                    /* Checking if the word was actually a keyword -
+                     * fetching the current word, NULL-terminated like
+                     * the keyword list */
+                    char s[100];
+                    Sci_Position wordLen = sc.currentPos - styler.GetStartSegment();
+                    if (wordLen > 99)
+                        wordLen = 99;  /* Include '\0' in buffer */
+                    Sci_Position i;
+                    for( i = 0; i < wordLen; ++i )
+                    {
+                        s[i] = styler.SafeGetCharAt( styler.GetStartSegment() + i );
+                    }
+                    s[wordLen] = '\0';
+
+                    /* Actually detecting keywords and fixing the state */
+                    if (keywords.InList(s))
+                    {
+                        /* The SetState call actually commits the
+                         * previous keyword state */
+                        sc.ChangeState(SCE_KVIRC_KEYWORD);
+                    }
+                    else if (functionKeywords.InList(s))
+                    {
+                        // Detecting function keywords and fixing the state
+                        sc.ChangeState(SCE_KVIRC_FUNCTION_KEYWORD);
+                    }
+
+                    /* Transitioning to default and committing the previous
+                     * word state */
+                    sc.SetState(SCE_KVIRC_DEFAULT);
+
+                    /* Word has been exited yet the current character
+                     * has yet to be defined - loop without moving
+                     * forward again */
+                    next = false;
+                    break;
+                }
+
+                break;
+        }
+    }
+
+    /* Indicating processing is complete */
+    sc.Complete();
+}
+
+static void FoldKVIrcDoc(Sci_PositionU startPos, Sci_Position length, int /*initStyle - unused*/,
+                      WordList *[], Accessor &styler)
+{
+    /* Based on CMake's folder */
+
+    /* Exiting if folding isnt enabled */
+    if ( styler.GetPropertyInt("fold") == 0 )
+        return;
+
+    /* Obtaining current line number*/
+    Sci_Position currentLine = styler.GetLine(startPos);
+
+    /* Obtaining starting character - indentation is done on a line basis,
+     * not character */
+    Sci_PositionU safeStartPos = styler.LineStart( currentLine );
+
+    /* Initialising current level - this is defined as indentation level
+     * in the low 12 bits, with flag bits in the upper four bits.
+     * It looks like two indentation states are maintained in the returned
+     * 32bit value - 'nextLevel' in the most-significant bits, 'currentLevel'
+     * in the least-significant bits. Since the next level is the most
+     * up to date, this must refer to the current state of indentation.
+     * So the code bitshifts the old current level out of existence to
+     * get at the actual current state of indentation
+     * Based on the LexerCPP.cxx line 958 comment */
+    int currentLevel = SC_FOLDLEVELBASE;
+    if (currentLine > 0)
+        currentLevel = styler.LevelAt(currentLine - 1) >> 16;
+    int nextLevel = currentLevel;
+
+    // Looping for characters in range
+    for (Sci_PositionU i = safeStartPos; i < startPos + length; ++i)
+    {
+        /* Folding occurs after syntax highlighting, meaning Scintilla
+         * already knows where the comments are
+         * Fetching the current state */
+        int state = styler.StyleAt(i) & 31;
+
+        switch( styler.SafeGetCharAt(i) )
+        {
+            case '{':
+
+                /* Indenting only when the braces are not contained in
+                 * a comment */
+                if (state != SCE_KVIRC_COMMENT &&
+                    state != SCE_KVIRC_COMMENTBLOCK)
+                    ++nextLevel;
+                break;
+
+            case '}':
+
+                /* Outdenting only when the braces are not contained in
+                 * a comment */
+                if (state != SCE_KVIRC_COMMENT &&
+                    state != SCE_KVIRC_COMMENTBLOCK)
+                    --nextLevel;
+                break;
+
+            case '\n':
+            case '\r':
+
+                /* Preparing indentation information to return - combining
+                 * current and next level data */
+                int lev = currentLevel | nextLevel << 16;
+
+                /* If the next level increases the indent level, mark the
+                 * current line as a fold point - current level data is
+                 * in the least significant bits */
+                if (nextLevel > currentLevel )
+                    lev |= SC_FOLDLEVELHEADERFLAG;
+
+                /* Updating indentation level if needed */
+                if (lev != styler.LevelAt(currentLine))
+                    styler.SetLevel(currentLine, lev);
+
+                /* Updating variables */
+                ++currentLine;
+                currentLevel = nextLevel;
+
+                /* Dealing with problematic Windows newlines -
+                 * incrementing to avoid the extra newline breaking the
+                 * fold point */
+                if (styler.SafeGetCharAt(i) == '\r' &&
+                    styler.SafeGetCharAt(i + 1) == '\n')
+                    ++i;
+                break;
+        }
+    }
+
+    /* At this point the data has ended, so presumably the end of the line?
+     * Preparing indentation information to return - combining current
+     * and next level data */
+    int lev = currentLevel | nextLevel << 16;
+
+    /* If the next level increases the indent level, mark the current
+     * line as a fold point - current level data is in the least
+     * significant bits */
+    if (nextLevel > currentLevel )
+        lev |= SC_FOLDLEVELHEADERFLAG;
+
+    /* Updating indentation level if needed */
+    if (lev != styler.LevelAt(currentLine))
+        styler.SetLevel(currentLine, lev);
+}
+
+/* Registering wordlists */
+static const char *const kvircWordListDesc[] = {
+	"primary",
+	"function_keywords",
+	0
+};
+
+
+/* Registering functions and wordlists */
+LexerModule lmKVIrc(SCLEX_KVIRC, ColouriseKVIrcDoc, "kvirc", FoldKVIrcDoc,
+                    kvircWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexKix.cxx b/Pythonwin/Scintilla/lexers/LexKix.cxx
similarity index 85%
rename from Pythonwin/Scintilla/src/LexKix.cxx
rename to Pythonwin/Scintilla/lexers/LexKix.cxx
index 06e7c1791..bcd68137e 100644
--- a/Pythonwin/Scintilla/src/LexKix.cxx
+++ b/Pythonwin/Scintilla/lexers/LexKix.cxx
@@ -4,25 +4,27 @@
  **/
 // Copyright 2004 by Manfred Becker <manfred@becker-trdf.de>
 // The License.txt file describes the conditions under which this software may be distributed.
+// Edited by Lee Wilmott (24-Jun-2014) added support for block comments
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 // Extended to accept accented characters
 static inline bool IsAWordChar(int ch) {
@@ -33,7 +35,7 @@ static inline bool IsOperator(const int ch) {
 	return (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '&' || ch == '|' || ch == '<' || ch == '>' || ch == '=');
 }
 
-static void ColouriseKixDoc(unsigned int startPos, int length, int initStyle,
+static void ColouriseKixDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                            WordList *keywordlists[], Accessor &styler) {
 
 	WordList &keywords = *keywordlists[0];
@@ -51,6 +53,10 @@ static void ColouriseKixDoc(unsigned int startPos, int length, int initStyle,
 			if (sc.atLineEnd) {
 				sc.SetState(SCE_KIX_DEFAULT);
 			}
+		} else if (sc.state == SCE_KIX_COMMENTSTREAM) {
+			if (sc.ch == '/' && sc.chPrev == '*') {
+				sc.ForwardSetState(SCE_KIX_DEFAULT);
+			}
 		} else if (sc.state == SCE_KIX_STRING1) {
 			// This is a doubles quotes string
 			if (sc.ch == '\"') {
@@ -101,6 +107,8 @@ static void ColouriseKixDoc(unsigned int startPos, int length, int initStyle,
 		if (sc.state == SCE_KIX_DEFAULT) {
 			if (sc.ch == ';') {
 				sc.SetState(SCE_KIX_COMMENT);
+			} else if (sc.ch == '/' && sc.chNext == '*') {
+				sc.SetState(SCE_KIX_COMMENTSTREAM);
 			} else if (sc.ch == '\"') {
 				sc.SetState(SCE_KIX_STRING1);
 			} else if (sc.ch == '\'') {
diff --git a/Pythonwin/Scintilla/lexers/LexLaTeX.cxx b/Pythonwin/Scintilla/lexers/LexLaTeX.cxx
new file mode 100644
index 000000000..6376bd7d6
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexLaTeX.cxx
@@ -0,0 +1,559 @@
+// Scintilla source code edit control
+/** @file LexLaTeX.cxx
+ ** Lexer for LaTeX2e.
+  **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+// Modified by G. HU in 2013. Added folding, syntax highting inside math environments, and changed some minor behaviors.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+#include <vector>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "DefaultLexer.h"
+#include "LexerBase.h"
+
+using namespace Scintilla;
+
+using namespace std;
+
+struct latexFoldSave {
+	latexFoldSave() : structLev(0) {
+		for (int i = 0; i < 8; ++i) openBegins[i] = 0;
+	}
+	latexFoldSave(const latexFoldSave &save) : structLev(save.structLev) {
+		for (int i = 0; i < 8; ++i) openBegins[i] = save.openBegins[i];
+	}
+	latexFoldSave &operator=(const latexFoldSave &save) {
+		if (this != &save) {
+			structLev = save.structLev;
+			for (int i = 0; i < 8; ++i) openBegins[i] = save.openBegins[i];
+		}
+		return *this;
+	}
+	int openBegins[8];
+	Sci_Position structLev;
+};
+
+class LexerLaTeX : public LexerBase {
+private:
+	vector<int> modes;
+	void setMode(Sci_Position line, int mode) {
+		if (line >= static_cast<Sci_Position>(modes.size())) modes.resize(line + 1, 0);
+		modes[line] = mode;
+	}
+	int getMode(Sci_Position line) {
+		if (line >= 0 && line < static_cast<Sci_Position>(modes.size())) return modes[line];
+		return 0;
+	}
+	void truncModes(Sci_Position numLines) {
+		if (static_cast<Sci_Position>(modes.size()) > numLines * 2 + 256)
+			modes.resize(numLines + 128);
+	}
+
+	vector<latexFoldSave> saves;
+	void setSave(Sci_Position line, const latexFoldSave &save) {
+		if (line >= static_cast<Sci_Position>(saves.size())) saves.resize(line + 1);
+		saves[line] = save;
+	}
+	void getSave(Sci_Position line, latexFoldSave &save) {
+		if (line >= 0 && line < static_cast<Sci_Position>(saves.size())) save = saves[line];
+		else {
+			save.structLev = 0;
+			for (int i = 0; i < 8; ++i) save.openBegins[i] = 0;
+		}
+	}
+	void truncSaves(Sci_Position numLines) {
+		if (static_cast<Sci_Position>(saves.size()) > numLines * 2 + 256)
+			saves.resize(numLines + 128);
+	}
+public:
+	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) {
+	return (ch == '#') || (ch == '$') || (ch == '%') || (ch == '&') || (ch == '_') ||
+		   (ch == '{') || (ch == '}') || (ch == ' ');
+}
+
+static bool latexIsBlank(int ch) {
+	return (ch == ' ') || (ch == '\t');
+}
+
+static bool latexIsBlankAndNL(int ch) {
+	return (ch == ' ') || (ch == '\t') || (ch == '\r') || (ch == '\n');
+}
+
+static bool latexIsLetter(int ch) {
+	return IsASCII(ch) && isalpha(ch);
+}
+
+static bool latexIsTagValid(Sci_Position &i, Sci_Position l, Accessor &styler) {
+	while (i < l) {
+		if (styler.SafeGetCharAt(i) == '{') {
+			while (i < l) {
+				i++;
+				if (styler.SafeGetCharAt(i) == '}') {
+					return true;
+				}	else if (!latexIsLetter(styler.SafeGetCharAt(i)) &&
+                   styler.SafeGetCharAt(i)!='*') {
+					return false;
+				}
+			}
+		} else if (!latexIsBlank(styler.SafeGetCharAt(i))) {
+			return false;
+		}
+		i++;
+	}
+	return false;
+}
+
+static bool latexNextNotBlankIs(Sci_Position i, Accessor &styler, char needle) {
+  char ch;
+	while (i < styler.Length()) {
+    ch = styler.SafeGetCharAt(i);
+		if (!latexIsBlankAndNL(ch) && ch != '*') {
+      if (ch == needle)
+        return true;
+      else
+        return false;
+		}
+		i++;
+	}
+	return false;
+}
+
+static bool latexLastWordIs(Sci_Position start, Accessor &styler, const char *needle) {
+	Sci_PositionU i = 0;
+	Sci_PositionU l = static_cast<Sci_PositionU>(strlen(needle));
+	Sci_Position ini = start-l+1;
+	char s[32];
+
+	while (i < l && i < 31) {
+		s[i] = styler.SafeGetCharAt(ini + i);
+		i++;
+	}
+	s[i] = '\0';
+
+	return (strcmp(s, needle) == 0);
+}
+
+static bool latexLastWordIsMathEnv(Sci_Position pos, Accessor &styler) {
+	Sci_Position i, j;
+	char s[32];
+	const char *mathEnvs[] = { "align", "alignat", "flalign", "gather",
+		"multiline", "displaymath", "eqnarray", "equation" };
+	if (styler.SafeGetCharAt(pos) != '}') return false;
+	for (i = pos - 1; i >= 0; --i) {
+		if (styler.SafeGetCharAt(i) == '{') break;
+		if (pos - i >= 20) return false;
+	}
+	if (i < 0 || i == pos - 1) return false;
+	++i;
+	for (j = 0; i + j < pos; ++j)
+		s[j] = styler.SafeGetCharAt(i + j);
+	s[j] = '\0';
+	if (j == 0) return false;
+	if (s[j - 1] == '*') s[--j] = '\0';
+	for (i = 0; i < static_cast<int>(sizeof(mathEnvs) / sizeof(const char *)); ++i)
+		if (strcmp(s, mathEnvs[i]) == 0) return true;
+	return false;
+}
+
+static inline void latexStateReset(int &mode, int &state) {
+	switch (mode) {
+	case 1:     state = SCE_L_MATH; break;
+	case 2:     state = SCE_L_MATH2; break;
+	default:    state = SCE_L_DEFAULT; break;
+	}
+}
+
+// There are cases not handled correctly, like $abcd\textrm{what is $x+y$}z+w$.
+// But I think it's already good enough.
+void SCI_METHOD LexerLaTeX::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	// startPos is assumed to be the first character of a line
+	Accessor styler(pAccess, &props);
+	styler.StartAt(startPos);
+	int mode = getMode(styler.GetLine(startPos) - 1);
+	int state = initStyle;
+	if (state == SCE_L_ERROR || state == SCE_L_SHORTCMD || state == SCE_L_SPECIAL)   // should not happen
+		latexStateReset(mode, state);
+
+	char chNext = styler.SafeGetCharAt(startPos);
+	char chVerbatimDelim = '\0';
+	styler.StartSegment(startPos);
+	Sci_Position lengthDoc = startPos + length;
+
+	for (Sci_Position i = startPos; i < lengthDoc; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+
+		if (styler.IsLeadByte(ch)) {
+			i++;
+			chNext = styler.SafeGetCharAt(i + 1);
+			continue;
+		}
+
+		if (ch == '\r' || ch == '\n')
+			setMode(styler.GetLine(i), mode);
+
+		switch (state) {
+		case SCE_L_DEFAULT :
+			switch (ch) {
+			case '\\' :
+				styler.ColourTo(i - 1, state);
+				if (latexIsLetter(chNext)) {
+					state = SCE_L_COMMAND;
+				} else if (latexIsSpecial(chNext)) {
+					styler.ColourTo(i + 1, SCE_L_SPECIAL);
+					i++;
+					chNext = styler.SafeGetCharAt(i + 1);
+				} else if (chNext == '\r' || chNext == '\n') {
+					styler.ColourTo(i, SCE_L_ERROR);
+				} else if (IsASCII(chNext)) {
+					styler.ColourTo(i + 1, SCE_L_SHORTCMD);
+					if (chNext == '(') {
+						mode = 1;
+						state = SCE_L_MATH;
+					} else if (chNext == '[') {
+						mode = 2;
+						state = SCE_L_MATH2;
+					}
+					i++;
+					chNext = styler.SafeGetCharAt(i + 1);
+				}
+				break;
+			case '$' :
+				styler.ColourTo(i - 1, state);
+				if (chNext == '$') {
+					styler.ColourTo(i + 1, SCE_L_SHORTCMD);
+					mode = 2;
+					state = SCE_L_MATH2;
+					i++;
+					chNext = styler.SafeGetCharAt(i + 1);
+				} else {
+					styler.ColourTo(i, SCE_L_SHORTCMD);
+					mode = 1;
+					state = SCE_L_MATH;
+				}
+				break;
+			case '%' :
+				styler.ColourTo(i - 1, state);
+				state = SCE_L_COMMENT;
+				break;
+			}
+			break;
+		// These 3 will never be reached.
+		case SCE_L_ERROR:
+		case SCE_L_SPECIAL:
+		case SCE_L_SHORTCMD:
+			break;
+		case SCE_L_COMMAND :
+			if (!latexIsLetter(chNext)) {
+				styler.ColourTo(i, state);
+				if (latexNextNotBlankIs(i + 1, styler, '[' )) {
+					state = SCE_L_CMDOPT;
+				} else if (latexLastWordIs(i, styler, "\\begin")) {
+					state = SCE_L_TAG;
+				} else if (latexLastWordIs(i, styler, "\\end")) {
+					state = SCE_L_TAG2;
+				} else if (latexLastWordIs(i, styler, "\\verb") && chNext != '*' && chNext != ' ') {
+					chVerbatimDelim = chNext;
+					state = SCE_L_VERBATIM;
+				} else {
+					latexStateReset(mode, state);
+				}
+			}
+			break;
+		case SCE_L_CMDOPT :
+			if (ch == ']') {
+				styler.ColourTo(i, state);
+				latexStateReset(mode, state);
+			}
+			break;
+		case SCE_L_TAG :
+			if (latexIsTagValid(i, lengthDoc, styler)) {
+				styler.ColourTo(i, state);
+				latexStateReset(mode, state);
+				if (latexLastWordIs(i, styler, "{verbatim}")) {
+					state = SCE_L_VERBATIM;
+				} else if (latexLastWordIs(i, styler, "{lstlisting}")) {
+					state = SCE_L_VERBATIM;
+				} else if (latexLastWordIs(i, styler, "{comment}")) {
+					state = SCE_L_COMMENT2;
+				} else if (latexLastWordIs(i, styler, "{math}") && mode == 0) {
+					mode = 1;
+					state = SCE_L_MATH;
+				} else if (latexLastWordIsMathEnv(i, styler) && mode == 0) {
+					mode = 2;
+					state = SCE_L_MATH2;
+				}
+			} else {
+				styler.ColourTo(i, SCE_L_ERROR);
+				latexStateReset(mode, state);
+				ch = styler.SafeGetCharAt(i);
+				if (ch == '\r' || ch == '\n') setMode(styler.GetLine(i), mode);
+			}
+			chNext = styler.SafeGetCharAt(i+1);
+			break;
+		case SCE_L_TAG2 :
+			if (latexIsTagValid(i, lengthDoc, styler)) {
+				styler.ColourTo(i, state);
+				latexStateReset(mode, state);
+			} else {
+				styler.ColourTo(i, SCE_L_ERROR);
+				latexStateReset(mode, state);
+				ch = styler.SafeGetCharAt(i);
+				if (ch == '\r' || ch == '\n') setMode(styler.GetLine(i), mode);
+			}
+			chNext = styler.SafeGetCharAt(i+1);
+			break;
+		case SCE_L_MATH :
+			switch (ch) {
+			case '\\' :
+				styler.ColourTo(i - 1, state);
+				if (latexIsLetter(chNext)) {
+					Sci_Position match = i + 3;
+					if (latexLastWordIs(match, styler, "\\end")) {
+						match++;
+						if (latexIsTagValid(match, lengthDoc, styler)) {
+							if (latexLastWordIs(match, styler, "{math}"))
+								mode = 0;
+						}
+					}
+					state = SCE_L_COMMAND;
+				} else if (latexIsSpecial(chNext)) {
+					styler.ColourTo(i + 1, SCE_L_SPECIAL);
+					i++;
+					chNext = styler.SafeGetCharAt(i + 1);
+				} else if (chNext == '\r' || chNext == '\n') {
+					styler.ColourTo(i, SCE_L_ERROR);
+				} else if (IsASCII(chNext)) {
+					if (chNext == ')') {
+						mode = 0;
+						state = SCE_L_DEFAULT;
+					}
+					styler.ColourTo(i + 1, SCE_L_SHORTCMD);
+					i++;
+					chNext = styler.SafeGetCharAt(i + 1);
+				}
+				break;
+			case '$' :
+				styler.ColourTo(i - 1, state);
+				styler.ColourTo(i, SCE_L_SHORTCMD);
+				mode = 0;
+				state = SCE_L_DEFAULT;
+				break;
+			case '%' :
+				styler.ColourTo(i - 1, state);
+				state = SCE_L_COMMENT;
+				break;
+			}
+			break;
+		case SCE_L_MATH2 :
+			switch (ch) {
+			case '\\' :
+				styler.ColourTo(i - 1, state);
+				if (latexIsLetter(chNext)) {
+					Sci_Position match = i + 3;
+					if (latexLastWordIs(match, styler, "\\end")) {
+						match++;
+						if (latexIsTagValid(match, lengthDoc, styler)) {
+							if (latexLastWordIsMathEnv(match, styler))
+								mode = 0;
+						}
+					}
+					state = SCE_L_COMMAND;
+				} else if (latexIsSpecial(chNext)) {
+					styler.ColourTo(i + 1, SCE_L_SPECIAL);
+					i++;
+					chNext = styler.SafeGetCharAt(i + 1);
+				} else if (chNext == '\r' || chNext == '\n') {
+					styler.ColourTo(i, SCE_L_ERROR);
+				} else if (IsASCII(chNext)) {
+					if (chNext == ']') {
+						mode = 0;
+						state = SCE_L_DEFAULT;
+					}
+					styler.ColourTo(i + 1, SCE_L_SHORTCMD);
+					i++;
+					chNext = styler.SafeGetCharAt(i + 1);
+				}
+				break;
+			case '$' :
+				styler.ColourTo(i - 1, state);
+				if (chNext == '$') {
+					styler.ColourTo(i + 1, SCE_L_SHORTCMD);
+					i++;
+					chNext = styler.SafeGetCharAt(i + 1);
+					mode = 0;
+					state = SCE_L_DEFAULT;
+				} else { // This may not be an error, e.g. \begin{equation}\text{$a$}\end{equation}
+					styler.ColourTo(i, SCE_L_SHORTCMD);
+				}
+				break;
+			case '%' :
+				styler.ColourTo(i - 1, state);
+				state = SCE_L_COMMENT;
+				break;
+			}
+			break;
+		case SCE_L_COMMENT :
+			if (ch == '\r' || ch == '\n') {
+				styler.ColourTo(i - 1, state);
+				latexStateReset(mode, state);
+			}
+			break;
+		case SCE_L_COMMENT2 :
+			if (ch == '\\') {
+				Sci_Position match = i + 3;
+				if (latexLastWordIs(match, styler, "\\end")) {
+					match++;
+					if (latexIsTagValid(match, lengthDoc, styler)) {
+						if (latexLastWordIs(match, styler, "{comment}")) {
+							styler.ColourTo(i - 1, state);
+							state = SCE_L_COMMAND;
+						}
+					}
+				}
+			}
+			break;
+		case SCE_L_VERBATIM :
+			if (ch == '\\') {
+				Sci_Position match = i + 3;
+				if (latexLastWordIs(match, styler, "\\end")) {
+					match++;
+					if (latexIsTagValid(match, lengthDoc, styler)) {
+						if (latexLastWordIs(match, styler, "{verbatim}")) {
+							styler.ColourTo(i - 1, state);
+							state = SCE_L_COMMAND;
+						} else if (latexLastWordIs(match, styler, "{lstlisting}")) {
+							styler.ColourTo(i - 1, state);
+							state = SCE_L_COMMAND;
+						}
+					}
+				}
+			} else if (chNext == chVerbatimDelim) {
+				styler.ColourTo(i + 1, state);
+				latexStateReset(mode, state);
+				chVerbatimDelim = '\0';
+				i++;
+				chNext = styler.SafeGetCharAt(i + 1);
+			} else if (chVerbatimDelim != '\0' && (ch == '\n' || ch == '\r')) {
+				styler.ColourTo(i, SCE_L_ERROR);
+				latexStateReset(mode, state);
+				chVerbatimDelim = '\0';
+			}
+			break;
+		}
+	}
+	if (lengthDoc == styler.Length()) truncModes(styler.GetLine(lengthDoc - 1));
+	styler.ColourTo(lengthDoc - 1, state);
+	styler.Flush();
+}
+
+static int latexFoldSaveToInt(const latexFoldSave &save) {
+	int sum = 0;
+	for (int i = 0; i <= save.structLev; ++i)
+		sum += save.openBegins[i];
+	return ((sum + save.structLev + SC_FOLDLEVELBASE) & SC_FOLDLEVELNUMBERMASK);
+}
+
+// Change folding state while processing a line
+// Return the level before the first relevant command
+void SCI_METHOD LexerLaTeX::Fold(Sci_PositionU startPos, Sci_Position length, int, IDocument *pAccess) {
+	const char *structWords[7] = {"part", "chapter", "section", "subsection",
+		"subsubsection", "paragraph", "subparagraph"};
+	Accessor styler(pAccess, &props);
+	Sci_PositionU endPos = startPos + length;
+	Sci_Position curLine = styler.GetLine(startPos);
+	latexFoldSave save;
+	getSave(curLine - 1, save);
+	do {
+		char ch, buf[16];
+		Sci_Position i, j;
+		int lev = -1;
+		bool needFold = false;
+		for (i = static_cast<Sci_Position>(startPos); i < static_cast<Sci_Position>(endPos); ++i) {
+			ch = styler.SafeGetCharAt(i);
+			if (ch == '\r' || ch == '\n') break;
+			if (ch != '\\' || styler.StyleAt(i) != SCE_L_COMMAND) continue;
+			for (j = 0; j < 15 && i + 1 < static_cast<Sci_Position>(endPos); ++j, ++i) {
+				buf[j] = styler.SafeGetCharAt(i + 1);
+				if (!latexIsLetter(buf[j])) break;
+			}
+			buf[j] = '\0';
+			if (strcmp(buf, "begin") == 0) {
+				if (lev < 0) lev = latexFoldSaveToInt(save);
+				++save.openBegins[save.structLev];
+				needFold = true;
+			}
+			else if (strcmp(buf, "end") == 0) {
+				while (save.structLev > 0 && save.openBegins[save.structLev] == 0)
+					--save.structLev;
+				if (lev < 0) lev = latexFoldSaveToInt(save);
+				if (save.openBegins[save.structLev] > 0) --save.openBegins[save.structLev];
+			}
+			else {
+				for (j = 0; j < 7; ++j)
+					if (strcmp(buf, structWords[j]) == 0) break;
+				if (j >= 7) continue;
+				save.structLev = j;   // level before the command
+				for (j = save.structLev + 1; j < 8; ++j) {
+					save.openBegins[save.structLev] += save.openBegins[j];
+					save.openBegins[j] = 0;
+				}
+				if (lev < 0) lev = latexFoldSaveToInt(save);
+				++save.structLev;   // level after the command
+				needFold = true;
+			}
+		}
+		if (lev < 0) lev = latexFoldSaveToInt(save);
+		if (needFold) lev |= SC_FOLDLEVELHEADERFLAG;
+		styler.SetLevel(curLine, lev);
+		setSave(curLine, save);
+		++curLine;
+		startPos = styler.LineStart(curLine);
+		if (static_cast<Sci_Position>(startPos) == styler.Length()) {
+			lev = latexFoldSaveToInt(save);
+			styler.SetLevel(curLine, lev);
+			setSave(curLine, save);
+			truncSaves(curLine);
+		}
+	} while (startPos < endPos);
+	styler.Flush();
+}
+
+static const char *const emptyWordListDesc[] = {
+	0
+};
+
+LexerModule lmLatex(SCLEX_LATEX, LexerLaTeX::LexerFactoryLaTeX, "latex", emptyWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexLisp.cxx b/Pythonwin/Scintilla/lexers/LexLisp.cxx
similarity index 84%
rename from Pythonwin/Scintilla/src/LexLisp.cxx
rename to Pythonwin/Scintilla/lexers/LexLisp.cxx
index 1072e13a3..8e7586355 100644
--- a/Pythonwin/Scintilla/src/LexLisp.cxx
+++ b/Pythonwin/Scintilla/lexers/LexLisp.cxx
@@ -8,45 +8,46 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
 #include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 #define SCE_LISP_CHARACTER 29
 #define SCE_LISP_MACRO 30
 #define SCE_LISP_MACRO_DISPATCH 31
 
 static inline bool isLispoperator(char ch) {
-	if (isascii(ch) && isalnum(ch))
+	if (IsASCII(ch) && isalnum(ch))
 		return false;
-	if (ch == '\'' || ch == '`' || ch == '(' || ch == ')' )
+	if (ch == '\'' || ch == '`' || ch == '(' || ch == ')' || ch == '[' || ch == ']' || ch == '{' || ch == '}')
 		return true;
 	return false;
 }
 
 static inline bool isLispwordstart(char ch) {
-	return isascii(ch) && ch != ';'  && !isspacechar(ch) && !isLispoperator(ch) &&
+	return IsASCII(ch) && ch != ';'  && !isspacechar(ch) && !isLispoperator(ch) &&
 		ch != '\n' && ch != '\r' &&  ch != '\"';
 }
 
 
-static void classifyWordLisp(unsigned int start, unsigned int end, WordList &keywords, WordList &keywords_kw, Accessor &styler) {
-	PLATFORM_ASSERT(end >= start);
+static void classifyWordLisp(Sci_PositionU start, Sci_PositionU end, WordList &keywords, WordList &keywords_kw, Accessor &styler) {
+	assert(end >= start);
 	char s[100];
-	unsigned int i;
+	Sci_PositionU i;
 	bool digit_flag = true;
 	for (i = 0; (i < end - start + 1) && (i < 99); i++) {
 		s[i] = styler[start + i];
@@ -71,7 +72,7 @@ static void classifyWordLisp(unsigned int start, unsigned int end, WordList &key
 }
 
 
-static void ColouriseLispDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
+static void ColouriseLispDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
                             Accessor &styler) {
 
 	WordList &keywords = *keywordlists[0];
@@ -81,9 +82,9 @@ static void ColouriseLispDoc(unsigned int startPos, int length, int initStyle, W
 
 	int state = initStyle, radix = -1;
 	char chNext = styler[startPos];
-	unsigned int lengthDoc = startPos + length;
+	Sci_PositionU lengthDoc = startPos + length;
 	styler.StartSegment(startPos);
-	for (unsigned int i = startPos; i < lengthDoc; i++) {
+	for (Sci_PositionU i = startPos; i < lengthDoc; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 
@@ -100,6 +101,9 @@ static void ColouriseLispDoc(unsigned int startPos, int length, int initStyle, W
 				styler.ColourTo(i - 1, state);
 				radix = -1;
 				state = SCE_LISP_MACRO_DISPATCH;
+			} else if (ch == ':' && isLispwordstart(chNext)) {
+				styler.ColourTo(i - 1, state);
+				state = SCE_LISP_SYMBOL;
 			} else if (isLispwordstart(ch)) {
 				styler.ColourTo(i - 1, state);
 				state = SCE_LISP_IDENTIFIER;
@@ -136,7 +140,7 @@ static void ColouriseLispDoc(unsigned int startPos, int length, int initStyle, W
 				}
 			}
 		} else if (state == SCE_LISP_MACRO_DISPATCH) {
-			if (!isdigit(ch)) {
+			if (!(IsASCII(ch) && isdigit(ch))) {
 				if (ch != 'r' && ch != 'R' && (i - styler.GetStartSegment()) > 1) {
 					state = SCE_LISP_DEFAULT;
 				} else {
@@ -227,25 +231,25 @@ static void ColouriseLispDoc(unsigned int startPos, int length, int initStyle, W
 	styler.ColourTo(lengthDoc - 1, state);
 }
 
-static void FoldLispDoc(unsigned int startPos, int length, int /* initStyle */, WordList *[],
+static void FoldLispDoc(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, WordList *[],
                             Accessor &styler) {
-	unsigned int lengthDoc = startPos + length;
+	Sci_PositionU lengthDoc = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
-	for (unsigned int i = startPos; i < lengthDoc; i++) {
+	for (Sci_PositionU i = startPos; i < lengthDoc; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int style = styleNext;
 		styleNext = styler.StyleAt(i + 1);
 		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
 		if (style == SCE_LISP_OPERATOR) {
-			if (ch == '(') {
+			if (ch == '(' || ch == '[' || ch == '{') {
 				levelCurrent++;
-			} else if (ch == ')') {
+			} else if (ch == ')' || ch == ']' || ch == '}') {
 				levelCurrent--;
 			}
 		}
diff --git a/Pythonwin/Scintilla/src/LexLout.cxx b/Pythonwin/Scintilla/lexers/LexLout.cxx
similarity index 91%
rename from Pythonwin/Scintilla/src/LexLout.cxx
rename to Pythonwin/Scintilla/lexers/LexLout.cxx
index 492e4ed6d..abba91ad1 100644
--- a/Pythonwin/Scintilla/src/LexLout.cxx
+++ b/Pythonwin/Scintilla/lexers/LexLout.cxx
@@ -7,22 +7,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static inline bool IsAWordChar(const int ch) {
 	return (ch < 0x80) && (isalpha(ch) || ch == '@' || ch == '_');
@@ -37,7 +38,7 @@ static inline bool IsAnOther(const int ch) {
 	ch == ']' || ch == '^' || ch == '`' || ch == '|' || ch == '~');
 }
 
-static void ColouriseLoutDoc(unsigned int startPos, int length, int initStyle,
+static void ColouriseLoutDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
 			     WordList *keywordlists[], Accessor &styler) {
 
 	WordList &keywords = *keywordlists[0];
@@ -137,20 +138,20 @@ static void ColouriseLoutDoc(unsigned int startPos, int length, int initStyle,
 	sc.Complete();
 }
 
-static void FoldLoutDoc(unsigned int startPos, int length, int, WordList *[],
+static void FoldLoutDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[],
                         Accessor &styler) {
 
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	char chNext = styler[startPos];
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
 	int styleNext = styler.StyleAt(startPos);
-	char s[10];
+	char s[10] = "";
 
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int style = styleNext;
@@ -159,7 +160,7 @@ static void FoldLoutDoc(unsigned int startPos, int length, int, WordList *[],
 
 		if (style == SCE_LOUT_WORD) {
 			if (ch == '@') {
-				for (unsigned int j = 0; j < 8; j++) {
+				for (Sci_PositionU j = 0; j < 8; j++) {
 					if (!IsAWordChar(styler[i + j])) {
 						break;
 					}
diff --git a/Pythonwin/Scintilla/lexers/LexLua.cxx b/Pythonwin/Scintilla/lexers/LexLua.cxx
new file mode 100644
index 000000000..9e6e8a70c
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexLua.cxx
@@ -0,0 +1,502 @@
+// Scintilla source code edit control
+/** @file LexLua.cxx
+ ** Lexer for Lua language.
+ **
+ ** Written by Paul Winwood.
+ ** Folder by Alexey Yutkin.
+ ** Modified by Marcos E. Wurzius & Philippe Lhoste
+ **/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "StringCopy.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+// Test for [=[ ... ]=] delimiters, returns 0 if it's only a [ or ],
+// return 1 for [[ or ]], returns >=2 for [=[ or ]=] and so on.
+// The maximum number of '=' characters allowed is 254.
+static int LongDelimCheck(StyleContext &sc) {
+	int sep = 1;
+	while (sc.GetRelative(sep) == '=' && sep < 0xFF)
+		sep++;
+	if (sc.GetRelative(sep) == sc.ch)
+		return sep;
+	return 0;
+}
+
+static void ColouriseLuaDoc(
+	Sci_PositionU startPos,
+	Sci_Position length,
+	int initStyle,
+	WordList *keywordlists[],
+	Accessor &styler) {
+
+	const WordList &keywords = *keywordlists[0];
+	const WordList &keywords2 = *keywordlists[1];
+	const WordList &keywords3 = *keywordlists[2];
+	const WordList &keywords4 = *keywordlists[3];
+	const WordList &keywords5 = *keywordlists[4];
+	const WordList &keywords6 = *keywordlists[5];
+	const WordList &keywords7 = *keywordlists[6];
+	const WordList &keywords8 = *keywordlists[7];
+
+	// Accepts accented characters
+	CharacterSet setWordStart(CharacterSet::setAlpha, "_", 0x80, true);
+	CharacterSet setWord(CharacterSet::setAlphaNum, "_", 0x80, true);
+	// Not exactly following number definition (several dots are seen as OK, etc.)
+	// but probably enough in most cases. [pP] is for hex floats.
+	CharacterSet setNumber(CharacterSet::setDigits, ".-+abcdefpABCDEFP");
+	CharacterSet setExponent(CharacterSet::setNone, "eEpP");
+	CharacterSet setLuaOperator(CharacterSet::setNone, "*/-+()={}~[];<>,.^%:#&|");
+	CharacterSet setEscapeSkip(CharacterSet::setNone, "\"'\\");
+
+	Sci_Position currentLine = styler.GetLine(startPos);
+	// Initialize long string [[ ... ]] or block comment --[[ ... ]] nesting level,
+	// if we are inside such a string. Block comment was introduced in Lua 5.0,
+	// blocks with separators [=[ ... ]=] in Lua 5.1.
+	// Continuation of a string (\z whitespace escaping) is controlled by stringWs.
+	int nestLevel = 0;
+	int sepCount = 0;
+	int stringWs = 0;
+	if (initStyle == SCE_LUA_LITERALSTRING || initStyle == SCE_LUA_COMMENT ||
+		initStyle == SCE_LUA_STRING || initStyle == SCE_LUA_CHARACTER) {
+		const int lineState = styler.GetLineState(currentLine - 1);
+		nestLevel = lineState >> 9;
+		sepCount = lineState & 0xFF;
+		stringWs = lineState & 0x100;
+	}
+
+	// results of identifier/keyword matching
+	Sci_Position idenPos = 0;
+	Sci_Position idenWordPos = 0;
+	int idenStyle = SCE_LUA_IDENTIFIER;
+	bool foundGoto = false;
+
+	// Do not leak onto next line
+	if (initStyle == SCE_LUA_STRINGEOL || initStyle == SCE_LUA_COMMENTLINE || initStyle == SCE_LUA_PREPROCESSOR) {
+		initStyle = SCE_LUA_DEFAULT;
+	}
+
+	StyleContext sc(startPos, length, initStyle, styler);
+	if (startPos == 0 && sc.ch == '#' && sc.chNext == '!') {
+		// shbang line: "#!" is a comment only if located at the start of the script
+		sc.SetState(SCE_LUA_COMMENTLINE);
+	}
+	for (; sc.More(); sc.Forward()) {
+		if (sc.atLineEnd) {
+			// Update the line state, so it can be seen by next line
+			currentLine = styler.GetLine(sc.currentPos);
+			switch (sc.state) {
+			case SCE_LUA_LITERALSTRING:
+			case SCE_LUA_COMMENT:
+			case SCE_LUA_STRING:
+			case SCE_LUA_CHARACTER:
+				// Inside a literal string, block comment or string, we set the line state
+				styler.SetLineState(currentLine, (nestLevel << 9) | stringWs | sepCount);
+				break;
+			default:
+				// Reset the line state
+				styler.SetLineState(currentLine, 0);
+				break;
+			}
+		}
+		if (sc.atLineStart && (sc.state == SCE_LUA_STRING)) {
+			// Prevent SCE_LUA_STRINGEOL from leaking back to previous line
+			sc.SetState(SCE_LUA_STRING);
+		}
+
+		// Handle string line continuation
+		if ((sc.state == SCE_LUA_STRING || sc.state == SCE_LUA_CHARACTER) &&
+				sc.ch == '\\') {
+			if (sc.chNext == '\n' || sc.chNext == '\r') {
+				sc.Forward();
+				if (sc.ch == '\r' && sc.chNext == '\n') {
+					sc.Forward();
+				}
+				continue;
+			}
+		}
+
+		// Determine if the current state should terminate.
+		if (sc.state == SCE_LUA_OPERATOR) {
+			if (sc.ch == ':' && sc.chPrev == ':') {	// :: <label> :: forward scan
+				sc.Forward();
+				Sci_Position ln = 0;
+				while (IsASpaceOrTab(sc.GetRelative(ln)))	// skip over spaces/tabs
+					ln++;
+				Sci_Position ws1 = ln;
+				if (setWordStart.Contains(sc.GetRelative(ln))) {
+					int c, i = 0;
+					char s[100];
+					while (setWord.Contains(c = sc.GetRelative(ln))) {	// get potential label
+						if (i < 90)
+							s[i++] = static_cast<char>(c);
+						ln++;
+					}
+					s[i] = '\0'; Sci_Position lbl = ln;
+					if (!keywords.InList(s)) {
+						while (IsASpaceOrTab(sc.GetRelative(ln)))	// skip over spaces/tabs
+							ln++;
+						Sci_Position ws2 = ln - lbl;
+						if (sc.GetRelative(ln) == ':' && sc.GetRelative(ln + 1) == ':') {
+							// final :: found, complete valid label construct
+							sc.ChangeState(SCE_LUA_LABEL);
+							if (ws1) {
+								sc.SetState(SCE_LUA_DEFAULT);
+								sc.ForwardBytes(ws1);
+							}
+							sc.SetState(SCE_LUA_LABEL);
+							sc.ForwardBytes(lbl - ws1);
+							if (ws2) {
+								sc.SetState(SCE_LUA_DEFAULT);
+								sc.ForwardBytes(ws2);
+							}
+							sc.SetState(SCE_LUA_LABEL);
+							sc.ForwardBytes(2);
+						}
+					}
+				}
+			}
+			sc.SetState(SCE_LUA_DEFAULT);
+		} else if (sc.state == SCE_LUA_NUMBER) {
+			// We stop the number definition on non-numerical non-dot non-eEpP non-sign non-hexdigit char
+			if (!setNumber.Contains(sc.ch)) {
+				sc.SetState(SCE_LUA_DEFAULT);
+			} else if (sc.ch == '-' || sc.ch == '+') {
+				if (!setExponent.Contains(sc.chPrev))
+					sc.SetState(SCE_LUA_DEFAULT);
+			}
+		} else if (sc.state == SCE_LUA_IDENTIFIER) {
+			idenPos--;			// commit already-scanned identitier/word parts
+			if (idenWordPos > 0) {
+				idenWordPos--;
+				sc.ChangeState(idenStyle);
+				sc.ForwardBytes(idenWordPos);
+				idenPos -= idenWordPos;
+				if (idenPos > 0) {
+					sc.SetState(SCE_LUA_IDENTIFIER);
+					sc.ForwardBytes(idenPos);
+				}
+			} else {
+				sc.ForwardBytes(idenPos);
+			}
+			sc.SetState(SCE_LUA_DEFAULT);
+			if (foundGoto) {					// goto <label> forward scan
+				while (IsASpaceOrTab(sc.ch) && !sc.atLineEnd)
+					sc.Forward();
+				if (setWordStart.Contains(sc.ch)) {
+					sc.SetState(SCE_LUA_LABEL);
+					sc.Forward();
+					while (setWord.Contains(sc.ch))
+						sc.Forward();
+					char s[100];
+					sc.GetCurrent(s, sizeof(s));
+					if (keywords.InList(s))		// labels cannot be keywords
+						sc.ChangeState(SCE_LUA_WORD);
+				}
+				sc.SetState(SCE_LUA_DEFAULT);
+			}
+		} else if (sc.state == SCE_LUA_COMMENTLINE || sc.state == SCE_LUA_PREPROCESSOR) {
+			if (sc.atLineEnd) {
+				sc.ForwardSetState(SCE_LUA_DEFAULT);
+			}
+		} else if (sc.state == SCE_LUA_STRING) {
+			if (stringWs) {
+				if (!IsASpace(sc.ch))
+					stringWs = 0;
+			}
+			if (sc.ch == '\\') {
+				if (setEscapeSkip.Contains(sc.chNext)) {
+					sc.Forward();
+				} else if (sc.chNext == 'z') {
+					sc.Forward();
+					stringWs = 0x100;
+				}
+			} else if (sc.ch == '\"') {
+				sc.ForwardSetState(SCE_LUA_DEFAULT);
+			} else if (stringWs == 0 && sc.atLineEnd) {
+				sc.ChangeState(SCE_LUA_STRINGEOL);
+				sc.ForwardSetState(SCE_LUA_DEFAULT);
+			}
+		} else if (sc.state == SCE_LUA_CHARACTER) {
+			if (stringWs) {
+				if (!IsASpace(sc.ch))
+					stringWs = 0;
+			}
+			if (sc.ch == '\\') {
+				if (setEscapeSkip.Contains(sc.chNext)) {
+					sc.Forward();
+				} else if (sc.chNext == 'z') {
+					sc.Forward();
+					stringWs = 0x100;
+				}
+			} else if (sc.ch == '\'') {
+				sc.ForwardSetState(SCE_LUA_DEFAULT);
+			} else if (stringWs == 0 && sc.atLineEnd) {
+				sc.ChangeState(SCE_LUA_STRINGEOL);
+				sc.ForwardSetState(SCE_LUA_DEFAULT);
+			}
+		} else if (sc.state == SCE_LUA_LITERALSTRING || sc.state == SCE_LUA_COMMENT) {
+			if (sc.ch == '[') {
+				const int sep = LongDelimCheck(sc);
+				if (sep == 1 && sepCount == 1) {    // [[-only allowed to nest
+					nestLevel++;
+					sc.Forward();
+				}
+			} else if (sc.ch == ']') {
+				int sep = LongDelimCheck(sc);
+				if (sep == 1 && sepCount == 1) {    // un-nest with ]]-only
+					nestLevel--;
+					sc.Forward();
+					if (nestLevel == 0) {
+						sc.ForwardSetState(SCE_LUA_DEFAULT);
+					}
+				} else if (sep > 1 && sep == sepCount) {   // ]=]-style delim
+					sc.Forward(sep);
+					sc.ForwardSetState(SCE_LUA_DEFAULT);
+				}
+			}
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_LUA_DEFAULT) {
+			if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
+				sc.SetState(SCE_LUA_NUMBER);
+				if (sc.ch == '0' && toupper(sc.chNext) == 'X') {
+					sc.Forward();
+				}
+			} else if (setWordStart.Contains(sc.ch)) {
+				// For matching various identifiers with dots and colons, multiple
+				// matches are done as identifier segments are added. Longest match is
+				// set to a word style. The non-matched part is in identifier style.
+				std::string ident;
+				idenPos = 0;
+				idenWordPos = 0;
+				idenStyle = SCE_LUA_IDENTIFIER;
+				foundGoto = false;
+				int cNext;
+				do {
+					int c;
+					const Sci_Position idenPosOld = idenPos;
+					std::string identSeg;
+					identSeg += static_cast<char>(sc.GetRelative(idenPos++));
+					while (setWord.Contains(c = sc.GetRelative(idenPos))) {
+						identSeg += static_cast<char>(c);
+						idenPos++;
+					}
+					if (keywords.InList(identSeg.c_str()) && (idenPosOld > 0)) {
+						idenPos = idenPosOld - 1;	// keywords cannot mix
+						ident.pop_back();
+						break;
+					}
+					ident += identSeg;
+					const char* s = ident.c_str();
+					int newStyle = SCE_LUA_IDENTIFIER;
+					if (keywords.InList(s)) {
+						newStyle = SCE_LUA_WORD;
+					} else if (keywords2.InList(s)) {
+						newStyle = SCE_LUA_WORD2;
+					} else if (keywords3.InList(s)) {
+						newStyle = SCE_LUA_WORD3;
+					} else if (keywords4.InList(s)) {
+						newStyle = SCE_LUA_WORD4;
+					} else if (keywords5.InList(s)) {
+						newStyle = SCE_LUA_WORD5;
+					} else if (keywords6.InList(s)) {
+						newStyle = SCE_LUA_WORD6;
+					} else if (keywords7.InList(s)) {
+						newStyle = SCE_LUA_WORD7;
+					} else if (keywords8.InList(s)) {
+						newStyle = SCE_LUA_WORD8;
+					}
+					if (newStyle != SCE_LUA_IDENTIFIER) {
+						idenStyle = newStyle;
+						idenWordPos = idenPos;
+					}
+					if (idenStyle == SCE_LUA_WORD)	// keywords cannot mix
+						break;
+					cNext = sc.GetRelative(idenPos + 1);
+					if ((c == '.' || c == ':') && setWordStart.Contains(cNext)) {
+						ident += static_cast<char>(c);
+						idenPos++;
+					} else {
+						cNext = 0;
+					}
+				} while (cNext);
+				if ((idenStyle == SCE_LUA_WORD) && (ident.compare("goto") == 0)) {
+					foundGoto = true;
+				}
+				sc.SetState(SCE_LUA_IDENTIFIER);
+			} else if (sc.ch == '\"') {
+				sc.SetState(SCE_LUA_STRING);
+				stringWs = 0;
+			} else if (sc.ch == '\'') {
+				sc.SetState(SCE_LUA_CHARACTER);
+				stringWs = 0;
+			} else if (sc.ch == '[') {
+				sepCount = LongDelimCheck(sc);
+				if (sepCount == 0) {
+					sc.SetState(SCE_LUA_OPERATOR);
+				} else {
+					nestLevel = 1;
+					sc.SetState(SCE_LUA_LITERALSTRING);
+					sc.Forward(sepCount);
+				}
+			} else if (sc.Match('-', '-')) {
+				sc.SetState(SCE_LUA_COMMENTLINE);
+				if (sc.Match("--[")) {
+					sc.Forward(2);
+					sepCount = LongDelimCheck(sc);
+					if (sepCount > 0) {
+						nestLevel = 1;
+						sc.ChangeState(SCE_LUA_COMMENT);
+						sc.Forward(sepCount);
+					}
+				} else {
+					sc.Forward();
+				}
+			} else if (sc.atLineStart && sc.Match('$')) {
+				sc.SetState(SCE_LUA_PREPROCESSOR);	// Obsolete since Lua 4.0, but still in old code
+			} else if (setLuaOperator.Contains(sc.ch)) {
+				sc.SetState(SCE_LUA_OPERATOR);
+			}
+		}
+	}
+
+	sc.Complete();
+}
+
+static void FoldLuaDoc(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, WordList *[],
+                       Accessor &styler) {
+	const Sci_PositionU lengthDoc = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
+	int levelCurrent = levelPrev;
+	char chNext = styler[startPos];
+	const bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+	int styleNext = styler.StyleAt(startPos);
+
+	for (Sci_PositionU i = startPos; i < lengthDoc; i++) {
+		const char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		const int style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		const bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+		if (style == SCE_LUA_WORD) {
+			if (ch == 'i' || ch == 'd' || ch == 'f' || ch == 'e' || ch == 'r' || ch == 'u') {
+				char s[10] = "";
+				for (Sci_PositionU j = 0; j < 8; j++) {
+					if (!iswordchar(styler[i + j])) {
+						break;
+					}
+					s[j] = styler[i + j];
+					s[j + 1] = '\0';
+				}
+
+				if ((strcmp(s, "if") == 0) || (strcmp(s, "do") == 0) || (strcmp(s, "function") == 0) || (strcmp(s, "repeat") == 0)) {
+					levelCurrent++;
+				}
+				if ((strcmp(s, "end") == 0) || (strcmp(s, "elseif") == 0) || (strcmp(s, "until") == 0)) {
+					levelCurrent--;
+				}
+			}
+		} else if (style == SCE_LUA_OPERATOR) {
+			if (ch == '{' || ch == '(') {
+				levelCurrent++;
+			} else if (ch == '}' || ch == ')') {
+				levelCurrent--;
+			}
+		} else if (style == SCE_LUA_LITERALSTRING || style == SCE_LUA_COMMENT) {
+			if (ch == '[') {
+				levelCurrent++;
+			} else if (ch == ']') {
+				levelCurrent--;
+			}
+		}
+
+		if (atEOL) {
+			int lev = levelPrev;
+			if (visibleChars == 0 && foldCompact) {
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			}
+			if ((levelCurrent > levelPrev) && (visibleChars > 0)) {
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			}
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			levelPrev = levelCurrent;
+			visibleChars = 0;
+		}
+		if (!isspacechar(ch)) {
+			visibleChars++;
+		}
+	}
+	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
+
+	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
+	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
+}
+
+static const char * const luaWordListDesc[] = {
+	"Keywords",
+	"Basic functions",
+	"String, (table) & math functions",
+	"(coroutines), I/O & system facilities",
+	"user1",
+	"user2",
+	"user3",
+	"user4",
+	0
+};
+
+namespace {
+
+LexicalClass lexicalClasses[] = {
+	// Lexer Lua SCLEX_LUA SCE_LUA_:
+	0, "SCE_LUA_DEFAULT", "default", "White space: Visible only in View Whitespace mode (or if it has a back colour)",
+	1, "SCE_LUA_COMMENT", "comment", "Block comment (Lua 5.0)",
+	2, "SCE_LUA_COMMENTLINE", "comment line", "Line comment",
+	3, "SCE_LUA_COMMENTDOC", "comment documentation", "Doc comment -- Not used in Lua (yet?)",
+	4, "SCE_LUA_NUMBER", "literal numeric", "Number",
+	5, "SCE_LUA_WORD", "keyword", "Keyword",
+	6, "SCE_LUA_STRING", "literal string", "(Double quoted) String",
+	7, "SCE_LUA_CHARACTER", "literal string character", "Character (Single quoted string)",
+	8, "SCE_LUA_LITERALSTRING", "literal string", "Literal string",
+	9, "SCE_LUA_PREPROCESSOR", "preprocessor", "Preprocessor (obsolete in Lua 4.0 and up)",
+	10, "SCE_LUA_OPERATOR", "operator", "Operators",
+	11, "SCE_LUA_IDENTIFIER", "identifier", "Identifier (everything else...)",
+	12, "SCE_LUA_STRINGEOL", "error literal string", "End of line where string is not closed",
+	13, "SCE_LUA_WORD2", "identifier", "Other keywords",
+	14, "SCE_LUA_WORD3", "identifier", "Other keywords",
+	15, "SCE_LUA_WORD4", "identifier", "Other keywords",
+	16, "SCE_LUA_WORD5", "identifier", "Other keywords",
+	17, "SCE_LUA_WORD6", "identifier", "Other keywords",
+	18, "SCE_LUA_WORD7", "identifier", "Other keywords",
+	19, "SCE_LUA_WORD8", "identifier", "Other keywords",
+	20, "SCE_LUA_LABEL", "label", "Labels",
+};
+
+}
+
+LexerModule lmLua(SCLEX_LUA, ColouriseLuaDoc, "lua", FoldLuaDoc, luaWordListDesc, lexicalClasses, ELEMENTS(lexicalClasses));
diff --git a/Pythonwin/Scintilla/src/LexMMIXAL.cxx b/Pythonwin/Scintilla/lexers/LexMMIXAL.cxx
similarity index 88%
rename from Pythonwin/Scintilla/src/LexMMIXAL.cxx
rename to Pythonwin/Scintilla/lexers/LexMMIXAL.cxx
index a00f35ca0..1e0552075 100644
--- a/Pythonwin/Scintilla/src/LexMMIXAL.cxx
+++ b/Pythonwin/Scintilla/lexers/LexMMIXAL.cxx
@@ -1,7 +1,8 @@
 // Scintilla source code edit control
+// Encoding: UTF-8
 /** @file LexMMIXAL.cxx
  ** Lexer for MMIX Assembler Language.
- ** Written by Christoph Hösler <christoph.hoesler@student.uni-tuebingen.de>
+ ** Written by Christoph Hösler <christoph.hoesler@student.uni-tuebingen.de>
  ** For information about MMIX visit http://www-cs-faculty.stanford.edu/~knuth/mmix.html
  **/
 // Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
@@ -9,33 +10,34 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 
 static inline bool IsAWordChar(const int ch) {
 	return (ch < 0x80) && (isalnum(ch) || ch == ':' || ch == '_');
 }
 
-inline bool isMMIXALOperator(char ch) {
-	if (isalnum(ch))
+static inline bool isMMIXALOperator(char ch) {
+	if (IsASCII(ch) && isalnum(ch))
 		return false;
 	if (ch == '+' || ch == '-' || ch == '|' || ch == '^' ||
-		ch == '*' || ch == '/' || ch == '/' ||
+		ch == '*' || ch == '/' ||
 		ch == '%' || ch == '<' || ch == '>' || ch == '&' ||
 		ch == '~' || ch == '$' ||
 		ch == ',' || ch == '(' || ch == ')' ||
@@ -44,7 +46,7 @@ inline bool isMMIXALOperator(char ch) {
 	return false;
 }
 
-static void ColouriseMMIXALDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
+static void ColouriseMMIXALDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
                             Accessor &styler) {
 
 	WordList &opcodes = *keywordlists[0];
@@ -83,8 +85,6 @@ static void ColouriseMMIXALDoc(unsigned int startPos, int length, int initStyle,
 		} else if (sc.state == SCE_MMIXAL_NUMBER) {		// NUMBER
 			if (!isdigit(sc.ch)) {
 				if (IsAWordChar(sc.ch)) {
-					char s[100];
-					sc.GetCurrent(s, sizeof(s));
 					sc.ChangeState(SCE_MMIXAL_REF);
 					sc.SetState(SCE_MMIXAL_REF);
 				} else {
@@ -97,12 +97,11 @@ static void ColouriseMMIXALDoc(unsigned int startPos, int length, int initStyle,
 			}
 		} else if (sc.state == SCE_MMIXAL_REF) {			// REF
 			if (!IsAWordChar(sc.ch) ) {
-				char s[100];
-				sc.GetCurrent(s, sizeof(s));
+				char s0[100];
+				sc.GetCurrent(s0, sizeof(s0));
+				const char *s = s0;
 				if (*s == ':') {	// ignore base prefix for match
-					for (size_t i = 0; i != sizeof(s); ++i) {
-						*(s+i) = *(s+i+1);
-					}
+					++s;
 				}
 				if (special_register.InList(s)) {
 					sc.ChangeState(SCE_MMIXAL_REGISTER);
@@ -152,9 +151,7 @@ static void ColouriseMMIXALDoc(unsigned int startPos, int length, int initStyle,
 		if (sc.state == SCE_MMIXAL_OPCODE_POST ||		// OPCODE_POST
 			sc.state == SCE_MMIXAL_OPERANDS) {			// OPERANDS
 			if (sc.state == SCE_MMIXAL_OPERANDS && isspace(sc.ch)) {
-				if (!sc.atLineEnd) {
-					sc.SetState(SCE_MMIXAL_COMMENT);
-				}
+				sc.SetState(SCE_MMIXAL_COMMENT);
 			} else if (isdigit(sc.ch)) {
 				sc.SetState(SCE_MMIXAL_NUMBER);
 			} else if (IsAWordChar(sc.ch) || sc.Match('@')) {
diff --git a/Pythonwin/Scintilla/src/LexMPT.cxx b/Pythonwin/Scintilla/lexers/LexMPT.cxx
similarity index 76%
rename from Pythonwin/Scintilla/src/LexMPT.cxx
rename to Pythonwin/Scintilla/lexers/LexMPT.cxx
index 93b8caba7..0f5469840 100644
--- a/Pythonwin/Scintilla/src/LexMPT.cxx
+++ b/Pythonwin/Scintilla/lexers/LexMPT.cxx
@@ -7,30 +7,35 @@
 // Copyright 2003 by Marius Gheorghe <mgheorghe@cabletest.com>
 // The License.txt file describes the conditions under which this software may be distributed.
 
+#include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
 #include <ctype.h>
-#include <stdlib.h>
-#include "Platform.h"
 
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include <string>
+
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
-#include "SString.h"
 
-#ifdef SCI_NAMESPACE
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
 using namespace Scintilla;
-#endif
 
-static int GetLotLineState(SString &line) {
+static int GetLotLineState(std::string &line) {
 	if (line.length()) {
 		// Most of the time the first non-blank character in line determines that line's type
 		// Now finds the first non-blank character
 		unsigned i; // Declares counter here to make it persistent after the for loop
 		for (i = 0; i < line.length(); ++i) {
-			if (!isspace(line[i]))
+			if (!(IsASCII(line[i]) && isspace(line[i])))
 				break;
 		}
 
@@ -54,17 +59,17 @@ static int GetLotLineState(SString &line) {
 
 		default:  // Any other line
 			// Checks for message at the end of lot file
-			if (line.contains("PASSED")) {
+			if (line.find("PASSED") != std::string::npos) {
 				return SCE_LOT_PASS;
 			}
-			else if (line.contains("FAILED")) {
+			else if (line.find("FAILED") != std::string::npos) {
 				return SCE_LOT_FAIL;
 			}
-			else if (line.contains("ABORTED")) {
+			else if (line.find("ABORTED") != std::string::npos) {
 				return SCE_LOT_ABORT;
 			}
 			else {
-				return i ? SCE_LOT_PASS : SCE_LOT_DEFAULT;			
+				return i ? SCE_LOT_PASS : SCE_LOT_DEFAULT;
 			}
 		}
 	}
@@ -73,16 +78,16 @@ static int GetLotLineState(SString &line) {
 	}
 }
 
-static void ColourizeLotDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
+static void ColourizeLotDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
 	styler.StartAt(startPos);
 	styler.StartSegment(startPos);
 	bool atLineStart = true;// Arms the 'at line start' flag
 	char chNext = styler.SafeGetCharAt(startPos);
-	SString line("");
-	line.setsizegrowth(256);	// Lot lines are less than 256 chars long most of the time. This should avoid reallocations
+	std::string line("");
+	line.reserve(256);	// Lot lines are less than 256 chars long most of the time. This should avoid reallocations
 
 	// Styles LOT document
-	unsigned int i;			// Declared here because it's used after the for loop
+	Sci_PositionU i;			// Declared here because it's used after the for loop
 	for (i = startPos; i < startPos + length; ++i) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
@@ -111,11 +116,11 @@ static void ColourizeLotDoc(unsigned int startPos, int length, int, WordList *[]
 // sections (headed by a set line)
 // passes (contiguous pass results within a section)
 // fails (contiguous fail results within a section)
-static void FoldLotDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
+static void FoldLotDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 0) != 0;
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 
 	char chNext = styler.SafeGetCharAt(startPos);
 	int style = SCE_LOT_DEFAULT;
@@ -126,17 +131,17 @@ static void FoldLotDoc(unsigned int startPos, int length, int, WordList *[], Acc
 	if (startPos > 1)
 		style = styler.StyleAt(startPos - 2);
 
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 
 		if (ch == '\r' && chNext == '\n') {
 			// TO DO:
 			// Should really get the state of the previous line from the styler
-			int stylePrev = style;	
+			int stylePrev = style;
 			style = styleNext;
 			styleNext = styler.StyleAt(i + 2);
-		
+
 			switch (style) {
 /*
 			case SCE_LOT_SET:
@@ -145,7 +150,7 @@ static void FoldLotDoc(unsigned int startPos, int length, int, WordList *[], Acc
 */
 			case SCE_LOT_FAIL:
 /*
-				if (stylePrev != SCE_LOT_FAIL) 
+				if (stylePrev != SCE_LOT_FAIL)
 					lev = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;
 				else
 					lev = SC_FOLDLEVELBASE + 1;
@@ -154,7 +159,7 @@ static void FoldLotDoc(unsigned int startPos, int length, int, WordList *[], Acc
 				break;
 
 			default:
-				if (lineCurrent == 0 || stylePrev == SCE_LOT_FAIL) 
+				if (lineCurrent == 0 || stylePrev == SCE_LOT_FAIL)
 					lev = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;
 				else
 					lev = SC_FOLDLEVELBASE + 1;
@@ -164,7 +169,7 @@ static void FoldLotDoc(unsigned int startPos, int length, int, WordList *[], Acc
 				break;
 			}
 
-			if (lev != styler.LevelAt(lineCurrent)) 
+			if (lev != styler.LevelAt(lineCurrent))
 				styler.SetLevel(lineCurrent, lev);
 
 			lineCurrent++;
diff --git a/Pythonwin/Scintilla/src/LexMSSQL.cxx b/Pythonwin/Scintilla/lexers/LexMSSQL.cxx
similarity index 89%
rename from Pythonwin/Scintilla/src/LexMSSQL.cxx
rename to Pythonwin/Scintilla/lexers/LexMSSQL.cxx
index 4a3f3bed8..a06ff32c3 100644
--- a/Pythonwin/Scintilla/src/LexMSSQL.cxx
+++ b/Pythonwin/Scintilla/lexers/LexMSSQL.cxx
@@ -7,21 +7,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
 
-#ifdef SCI_NAMESPACE
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
 using namespace Scintilla;
-#endif
 
 #define KW_MSSQL_STATEMENTS         0
 #define KW_MSSQL_DATA_TYPES         1
@@ -31,21 +33,8 @@ using namespace Scintilla;
 #define KW_MSSQL_STORED_PROCEDURES  5
 #define KW_MSSQL_OPERATORS          6
 
-static bool isMSSQLOperator(char ch) {
-	if (isascii(ch) && isalnum(ch))
-		return false;
-	// '.' left out as it is used to make up numbers
-	if (ch == '%' || ch == '^' || ch == '&' || ch == '*' ||
-        ch == '-' || ch == '+' || ch == '=' || ch == '|' ||
-        ch == '<' || ch == '>' || ch == '/' ||
-        ch == '!' || ch == '~' || ch == '(' || ch == ')' ||
-		ch == ',')
-		return true;
-	return false;
-}
-
-static char classifyWordSQL(unsigned int start,
-                            unsigned int end,
+static char classifyWordSQL(Sci_PositionU start,
+                            Sci_PositionU end,
                             WordList *keywordlists[],
                             Accessor &styler,
                             unsigned int actualState,
@@ -61,7 +50,7 @@ static char classifyWordSQL(unsigned int start,
     WordList &kwStoredProcedures    = *keywordlists[KW_MSSQL_STORED_PROCEDURES];
     WordList &kwOperators           = *keywordlists[KW_MSSQL_OPERATORS];
 
-	for (unsigned int i = 0; i < end - start + 1 && i < 128; i++) {
+	for (Sci_PositionU i = 0; i < end - start + 1 && i < 128; i++) {
 		s[i] = static_cast<char>(tolower(styler[start + i]));
 		s[i + 1] = '\0';
 	}
@@ -110,14 +99,14 @@ static char classifyWordSQL(unsigned int start,
 	return chAttr;
 }
 
-static void ColouriseMSSQLDoc(unsigned int startPos, int length,
+static void ColouriseMSSQLDoc(Sci_PositionU startPos, Sci_Position length,
                               int initStyle, WordList *keywordlists[], Accessor &styler) {
 
 
 	styler.StartAt(startPos);
 
 	bool fold = styler.GetPropertyInt("fold") != 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int spaceFlags = 0;
 
 	int state = initStyle;
@@ -125,8 +114,8 @@ static void ColouriseMSSQLDoc(unsigned int startPos, int length,
 	char chPrev = ' ';
 	char chNext = styler[startPos];
 	styler.StartSegment(startPos);
-	unsigned int lengthDoc = startPos + length;
-	for (unsigned int i = startPos; i < lengthDoc; i++) {
+	Sci_PositionU lengthDoc = startPos + length;
+	for (Sci_PositionU i = startPos; i < lengthDoc; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 
@@ -216,7 +205,7 @@ static void ColouriseMSSQLDoc(unsigned int startPos, int length,
 				styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
 				prevState = state;
 				state = SCE_MSSQL_COLUMN_NAME_2;
-			} else if (isMSSQLOperator(ch)) {
+			} else if (isoperator(ch)) {
 				styler.ColourTo(i - 1, SCE_MSSQL_DEFAULT);
 				styler.ColourTo(i, SCE_MSSQL_OPERATOR);
                 //~ style = SCE_MSSQL_DEFAULT;
@@ -286,18 +275,18 @@ static void ColouriseMSSQLDoc(unsigned int startPos, int length,
 	styler.ColourTo(lengthDoc - 1, state);
 }
 
-static void FoldMSSQLDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
+static void FoldMSSQLDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
 	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	char chNext = styler[startPos];
 	bool inComment = (styler.StyleAt(startPos-1) == SCE_MSSQL_COMMENT);
-    char s[10];
-	for (unsigned int i = startPos; i < endPos; i++) {
+    char s[10] = "";
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int style = styler.StyleAt(i);
@@ -313,7 +302,7 @@ static void FoldMSSQLDoc(unsigned int startPos, int length, int, WordList *[], A
         if (style == SCE_MSSQL_STATEMENT) {
             // Folding between begin or case and end
             if (ch == 'b' || ch == 'B' || ch == 'c' || ch == 'C' || ch == 'e' || ch == 'E') {
-                for (unsigned int j = 0; j < 5; j++) {
+                for (Sci_PositionU j = 0; j < 5; j++) {
 					if (!iswordchar(styler[i + j])) {
 						break;
 					}
diff --git a/Pythonwin/Scintilla/src/LexMagik.cxx b/Pythonwin/Scintilla/lexers/LexMagik.cxx
similarity index 93%
rename from Pythonwin/Scintilla/src/LexMagik.cxx
rename to Pythonwin/Scintilla/lexers/LexMagik.cxx
index 8ab4d0887..89459d6a4 100644
--- a/Pythonwin/Scintilla/src/LexMagik.cxx
+++ b/Pythonwin/Scintilla/lexers/LexMagik.cxx
@@ -8,22 +8,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 /**
  * Is it a core character (C isalpha(), exclamation and question mark)
@@ -62,7 +63,7 @@ static inline bool IsAlphaSym(int ch) {
  * \return True if ch is a character, False otherwise
  */
 static inline bool IsAlNum(int ch) {
-    return ((ch > '0' && ch < '9') || IsAlpha(ch));
+    return ((ch >= '0' && ch <= '9') || IsAlpha(ch));
 }
 
 /**
@@ -81,10 +82,10 @@ static inline bool IsAlNumSym(int ch) {
  * \param  startPos Where to start scanning
  * \param  length Where to scan to
  * \param  initStyle The style at the initial point, not used in this folder
- * \param  keywordslists The keywordslists, currently, number 5 is used
+ * \param  keywordlists The keywordslists, currently, number 5 is used
  * \param  styler The styler
  */
-static void ColouriseMagikDoc(unsigned int startPos, int length, int initStyle,
+static void ColouriseMagikDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                            WordList *keywordlists[], Accessor &styler) {
     styler.StartAt(startPos);
 
@@ -138,7 +139,7 @@ static void ColouriseMagikDoc(unsigned int startPos, int length, int initStyle,
 	                char keywordChar = static_cast<char>(
                         tolower(styler.SafeGetCharAt(
                             scanPosition +
-                                static_cast<int>(sc.currentPos+1), ' ')));
+                                static_cast<Sci_Position>(sc.currentPos+1), ' ')));
                     if(IsAlpha(keywordChar)) {
                         keyword[scanPosition] = keywordChar;
                     } else {
@@ -230,7 +231,7 @@ static void ColouriseMagikDoc(unsigned int startPos, int length, int initStyle,
 	            }
 
 	            if(characters.InList(keyword)) {
-	                sc.Forward(strlen(keyword));
+	                sc.Forward(static_cast<int>(strlen(keyword)));
 	            } else {
 	                sc.Forward();
 	            }
@@ -327,7 +328,7 @@ static const char * const magikWordListDesc[] = {
  *
  * \param  keywordslist The list of keywords that are scanned, they should only
  *         contain the start keywords, not the end keywords
- * \param  The actual keyword
+ * \param  keyword The actual keyword
  * \return 1 if it is a folding start-keyword, -1 if it is a folding end-keyword
  *         0 otherwise
  */
@@ -356,24 +357,24 @@ static inline int IsFoldingContainer(WordList &keywordslist, char * keyword) {
  * \param  keywordslists The keywordslists, currently, number 5 is used
  * \param  styler The styler
  */
-static void FoldMagikDoc(unsigned int startPos, int length, int,
+static void FoldMagikDoc(Sci_PositionU startPos, Sci_Position length, int,
     WordList *keywordslists[], Accessor &styler) {
 
     bool compact = styler.GetPropertyInt("fold.compact") != 0;
 
     WordList &foldingElements = *keywordslists[5];
-    int endPos = startPos + length;
-    int line = styler.GetLine(startPos);
+    Sci_Position endPos = startPos + length;
+    Sci_Position line = styler.GetLine(startPos);
     int level = styler.LevelAt(line) & SC_FOLDLEVELNUMBERMASK;
     int flags = styler.LevelAt(line) & ~SC_FOLDLEVELNUMBERMASK;
 
     for(
-        int currentPos = startPos;
+        Sci_Position currentPos = startPos;
         currentPos < endPos;
         currentPos++) {
             char currentState = styler.StyleAt(currentPos);
             char c = styler.SafeGetCharAt(currentPos, ' ');
-            int prevLine = styler.GetLine(currentPos - 1);
+            Sci_Position prevLine = styler.GetLine(currentPos - 1);
             line = styler.GetLine(currentPos);
 
             // Default situation
diff --git a/Pythonwin/Scintilla/lexers/LexMake.cxx b/Pythonwin/Scintilla/lexers/LexMake.cxx
new file mode 100644
index 000000000..b3dc12aa1
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexMake.cxx
@@ -0,0 +1,142 @@
+// Scintilla source code edit control
+/** @file LexMake.cxx
+ ** Lexer for make files.
+ **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static inline bool AtEOL(Accessor &styler, Sci_PositionU i) {
+	return (styler[i] == '\n') ||
+	       ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n'));
+}
+
+static void ColouriseMakeLine(
+    char *lineBuffer,
+    Sci_PositionU lengthLine,
+    Sci_PositionU startLine,
+    Sci_PositionU endPos,
+    Accessor &styler) {
+
+	Sci_PositionU i = 0;
+	Sci_Position lastNonSpace = -1;
+	unsigned int state = SCE_MAKE_DEFAULT;
+	bool bSpecial = false;
+
+	// check for a tab character in column 0 indicating a command
+	bool bCommand = false;
+	if ((lengthLine > 0) && (lineBuffer[0] == '\t'))
+		bCommand = true;
+
+	// Skip initial spaces
+	while ((i < lengthLine) && isspacechar(lineBuffer[i])) {
+		i++;
+	}
+	if (i < lengthLine) {
+		if (lineBuffer[i] == '#') {	// Comment
+			styler.ColourTo(endPos, SCE_MAKE_COMMENT);
+			return;
+		}
+		if (lineBuffer[i] == '!') {	// Special directive
+			styler.ColourTo(endPos, SCE_MAKE_PREPROCESSOR);
+			return;
+		}
+	}
+	int varCount = 0;
+	while (i < lengthLine) {
+		if (((i + 1) < lengthLine) && (lineBuffer[i] == '$' && lineBuffer[i + 1] == '(')) {
+			styler.ColourTo(startLine + i - 1, state);
+			state = SCE_MAKE_IDENTIFIER;
+			varCount++;
+		} else if (state == SCE_MAKE_IDENTIFIER && lineBuffer[i] == ')') {
+			if (--varCount == 0) {
+				styler.ColourTo(startLine + i, state);
+				state = SCE_MAKE_DEFAULT;
+			}
+		}
+
+		// skip identifier and target styling if this is a command line
+		if (!bSpecial && !bCommand) {
+			if (lineBuffer[i] == ':') {
+				if (((i + 1) < lengthLine) && (lineBuffer[i + 1] == '=')) {
+					// it's a ':=', so style as an identifier
+					if (lastNonSpace >= 0)
+						styler.ColourTo(startLine + lastNonSpace, SCE_MAKE_IDENTIFIER);
+					styler.ColourTo(startLine + i - 1, SCE_MAKE_DEFAULT);
+					styler.ColourTo(startLine + i + 1, SCE_MAKE_OPERATOR);
+				} else {
+					// We should check that no colouring was made since the beginning of the line,
+					// to avoid colouring stuff like /OUT:file
+					if (lastNonSpace >= 0)
+						styler.ColourTo(startLine + lastNonSpace, SCE_MAKE_TARGET);
+					styler.ColourTo(startLine + i - 1, SCE_MAKE_DEFAULT);
+					styler.ColourTo(startLine + i, SCE_MAKE_OPERATOR);
+				}
+				bSpecial = true;	// Only react to the first ':' of the line
+				state = SCE_MAKE_DEFAULT;
+			} else if (lineBuffer[i] == '=') {
+				if (lastNonSpace >= 0)
+					styler.ColourTo(startLine + lastNonSpace, SCE_MAKE_IDENTIFIER);
+				styler.ColourTo(startLine + i - 1, SCE_MAKE_DEFAULT);
+				styler.ColourTo(startLine + i, SCE_MAKE_OPERATOR);
+				bSpecial = true;	// Only react to the first '=' of the line
+				state = SCE_MAKE_DEFAULT;
+			}
+		}
+		if (!isspacechar(lineBuffer[i])) {
+			lastNonSpace = i;
+		}
+		i++;
+	}
+	if (state == SCE_MAKE_IDENTIFIER) {
+		styler.ColourTo(endPos, SCE_MAKE_IDEOL);	// Error, variable reference not ended
+	} else {
+		styler.ColourTo(endPos, SCE_MAKE_DEFAULT);
+	}
+}
+
+static void ColouriseMakeDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
+	char lineBuffer[1024];
+	styler.StartAt(startPos);
+	styler.StartSegment(startPos);
+	Sci_PositionU linePos = 0;
+	Sci_PositionU startLine = startPos;
+	for (Sci_PositionU i = startPos; i < startPos + length; i++) {
+		lineBuffer[linePos++] = styler[i];
+		if (AtEOL(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
+			// End of line (or of line buffer) met, colourise it
+			lineBuffer[linePos] = '\0';
+			ColouriseMakeLine(lineBuffer, linePos, startLine, i, styler);
+			linePos = 0;
+			startLine = i + 1;
+		}
+	}
+	if (linePos > 0) {	// Last line does not have ending characters
+		ColouriseMakeLine(lineBuffer, linePos, startLine, startPos + length - 1, styler);
+	}
+}
+
+static const char *const emptyWordListDesc[] = {
+	0
+};
+
+LexerModule lmMake(SCLEX_MAKEFILE, ColouriseMakeDoc, "makefile", 0, emptyWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexMarkdown.cxx b/Pythonwin/Scintilla/lexers/LexMarkdown.cxx
new file mode 100644
index 000000000..e3410f6ca
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexMarkdown.cxx
@@ -0,0 +1,419 @@
+/******************************************************************
+ *  LexMarkdown.cxx
+ *
+ *  A simple Markdown lexer for scintilla.
+ *
+ *  Includes highlighting for some extra features from the
+ *  Pandoc implementation; strikeout, using '#.' as a default
+ *  ordered list item marker, and delimited code blocks.
+ *
+ *  Limitations:
+ *
+ *  Standard indented code blocks are not highlighted at all,
+ *  as it would conflict with other indentation schemes. Use
+ *  delimited code blocks for blanket highlighting of an
+ *  entire code block.  Embedded HTML is not highlighted either.
+ *  Blanket HTML highlighting has issues, because some Markdown
+ *  implementations allow Markdown markup inside of the HTML. Also,
+ *  there is a following blank line issue that can't be ignored,
+ *  explained in the next paragraph. Embedded HTML and code
+ *  blocks would be better supported with language specific
+ *  highlighting.
+ *
+ *  The highlighting aims to accurately reflect correct syntax,
+ *  but a few restrictions are relaxed. Delimited code blocks are
+ *  highlighted, even if the line following the code block is not blank.
+ *  Requiring a blank line after a block, breaks the highlighting
+ *  in certain cases, because of the way Scintilla ends up calling
+ *  the lexer.
+ *
+ *  Written by Jon Strait - jstrait@moonloop.net
+ *
+ *  The License.txt file describes the conditions under which this
+ *  software may be distributed.
+ *
+ *****************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static inline bool IsNewline(const int ch) {
+    return (ch == '\n' || ch == '\r');
+}
+
+// True if can follow ch down to the end with possibly trailing whitespace
+static bool FollowToLineEnd(const int ch, const int state, const Sci_PositionU endPos, StyleContext &sc) {
+    Sci_PositionU i = 0;
+    while (sc.GetRelative(++i) == ch)
+        ;
+    // Skip over whitespace
+    while (IsASpaceOrTab(sc.GetRelative(i)) && sc.currentPos + i < endPos)
+        ++i;
+    if (IsNewline(sc.GetRelative(i)) || sc.currentPos + i == endPos) {
+        sc.Forward(i);
+        sc.ChangeState(state);
+        sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
+        return true;
+    }
+    else return false;
+}
+
+// Set the state on text section from current to length characters,
+// then set the rest until the newline to default, except for any characters matching token
+static void SetStateAndZoom(const int state, const Sci_Position length, const int token, StyleContext &sc) {
+    sc.SetState(state);
+    sc.Forward(length);
+    sc.SetState(SCE_MARKDOWN_DEFAULT);
+    sc.Forward();
+    bool started = false;
+    while (sc.More() && !IsNewline(sc.ch)) {
+        if (sc.ch == token && !started) {
+            sc.SetState(state);
+            started = true;
+        }
+        else if (sc.ch != token) {
+            sc.SetState(SCE_MARKDOWN_DEFAULT);
+            started = false;
+        }
+        sc.Forward();
+    }
+    sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
+}
+
+// Does the previous line have more than spaces and tabs?
+static bool HasPrevLineContent(StyleContext &sc) {
+    Sci_Position i = 0;
+    // Go back to the previous newline
+    while ((--i + (Sci_Position)sc.currentPos) >= 0 && !IsNewline(sc.GetRelative(i)))
+        ;
+    while ((--i + (Sci_Position)sc.currentPos) >= 0) {
+        if (IsNewline(sc.GetRelative(i)))
+            break;
+        if (!IsASpaceOrTab(sc.GetRelative(i)))
+            return true;
+    }
+    return false;
+}
+
+static bool AtTermStart(StyleContext &sc) {
+    return sc.currentPos == 0 || sc.chPrev == 0 || isspacechar(sc.chPrev);
+}
+
+static bool IsValidHrule(const Sci_PositionU endPos, StyleContext &sc) {
+    int count = 1;
+    Sci_PositionU i = 0;
+    for (;;) {
+        ++i;
+        int c = sc.GetRelative(i);
+        if (c == sc.ch)
+            ++count;
+        // hit a terminating character
+        else if (!IsASpaceOrTab(c) || sc.currentPos + i == endPos) {
+            // Are we a valid HRULE
+            if ((IsNewline(c) || sc.currentPos + i == endPos) &&
+                    count >= 3 && !HasPrevLineContent(sc)) {
+                sc.SetState(SCE_MARKDOWN_HRULE);
+                sc.Forward(i);
+                sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
+                return true;
+            }
+            else {
+                sc.SetState(SCE_MARKDOWN_DEFAULT);
+		return false;
+            }
+        }
+    }
+}
+
+static void ColorizeMarkdownDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+                               WordList **, Accessor &styler) {
+    Sci_PositionU endPos = startPos + length;
+    int precharCount = 0;
+    bool isLinkNameDetecting = false;
+    // Don't advance on a new loop iteration and retry at the same position.
+    // Useful in the corner case of having to start at the beginning file position
+    // in the default state.
+    bool freezeCursor = false;
+
+    StyleContext sc(startPos, length, initStyle, styler);
+
+    while (sc.More()) {
+        // Skip past escaped characters
+        if (sc.ch == '\\') {
+            sc.Forward();
+            continue;
+        }
+
+        // A blockquotes resets the line semantics
+        if (sc.state == SCE_MARKDOWN_BLOCKQUOTE)
+            sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
+
+        // Conditional state-based actions
+        if (sc.state == SCE_MARKDOWN_CODE2) {
+            if (sc.Match("``") && sc.GetRelative(-2) != ' ') {
+                sc.Forward(2);
+                sc.SetState(SCE_MARKDOWN_DEFAULT);
+            }
+        }
+        else if (sc.state == SCE_MARKDOWN_CODE) {
+            if (sc.ch == '`' && sc.chPrev != ' ')
+                sc.ForwardSetState(SCE_MARKDOWN_DEFAULT);
+        }
+        /* De-activated because it gets in the way of other valid indentation
+         * schemes, for example multiple paragraphs inside a list item.
+        // Code block
+        else if (sc.state == SCE_MARKDOWN_CODEBK) {
+            bool d = true;
+            if (IsNewline(sc.ch)) {
+                if (sc.chNext != '\t') {
+                    for (int c = 1; c < 5; ++c) {
+                        if (sc.GetRelative(c) != ' ')
+                            d = false;
+                    }
+                }
+            }
+            else if (sc.atLineStart) {
+                if (sc.ch != '\t' ) {
+                    for (int i = 0; i < 4; ++i) {
+                        if (sc.GetRelative(i) != ' ')
+                            d = false;
+                    }
+                }
+            }
+            if (!d)
+                sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
+        }
+        */
+        // Strong
+        else if (sc.state == SCE_MARKDOWN_STRONG1) {
+            if (sc.Match("**") && sc.chPrev != ' ') {
+                sc.Forward(2);
+                sc.SetState(SCE_MARKDOWN_DEFAULT);
+            }
+        }
+        else if (sc.state == SCE_MARKDOWN_STRONG2) {
+            if (sc.Match("__") && sc.chPrev != ' ') {
+                sc.Forward(2);
+                sc.SetState(SCE_MARKDOWN_DEFAULT);
+            }
+        }
+        // Emphasis
+        else if (sc.state == SCE_MARKDOWN_EM1) {
+            if (sc.ch == '*' && sc.chPrev != ' ')
+                sc.ForwardSetState(SCE_MARKDOWN_DEFAULT);
+        }
+        else if (sc.state == SCE_MARKDOWN_EM2) {
+            if (sc.ch == '_' && sc.chPrev != ' ')
+                sc.ForwardSetState(SCE_MARKDOWN_DEFAULT);
+        }
+        else if (sc.state == SCE_MARKDOWN_CODEBK) {
+            if (sc.atLineStart && sc.Match("~~~")) {
+                Sci_Position i = 1;
+                while (!IsNewline(sc.GetRelative(i)) && sc.currentPos + i < endPos)
+                    i++;
+                sc.Forward(i);
+                sc.SetState(SCE_MARKDOWN_DEFAULT);
+            }
+        }
+        else if (sc.state == SCE_MARKDOWN_STRIKEOUT) {
+            if (sc.Match("~~") && sc.chPrev != ' ') {
+                sc.Forward(2);
+                sc.SetState(SCE_MARKDOWN_DEFAULT);
+            }
+        }
+        else if (sc.state == SCE_MARKDOWN_LINE_BEGIN) {
+            // Header
+            if (sc.Match("######"))
+                SetStateAndZoom(SCE_MARKDOWN_HEADER6, 6, '#', sc);
+            else if (sc.Match("#####"))
+                SetStateAndZoom(SCE_MARKDOWN_HEADER5, 5, '#', sc);
+            else if (sc.Match("####"))
+                SetStateAndZoom(SCE_MARKDOWN_HEADER4, 4, '#', sc);
+            else if (sc.Match("###"))
+                SetStateAndZoom(SCE_MARKDOWN_HEADER3, 3, '#', sc);
+            else if (sc.Match("##"))
+                SetStateAndZoom(SCE_MARKDOWN_HEADER2, 2, '#', sc);
+            else if (sc.Match("#")) {
+                // Catch the special case of an unordered list
+                if (sc.chNext == '.' && IsASpaceOrTab(sc.GetRelative(2))) {
+                    precharCount = 0;
+                    sc.SetState(SCE_MARKDOWN_PRECHAR);
+                }
+                else
+                    SetStateAndZoom(SCE_MARKDOWN_HEADER1, 1, '#', sc);
+            }
+            // Code block
+            else if (sc.Match("~~~")) {
+                if (!HasPrevLineContent(sc))
+                    sc.SetState(SCE_MARKDOWN_CODEBK);
+                else
+                    sc.SetState(SCE_MARKDOWN_DEFAULT);
+            }
+            else if (sc.ch == '=') {
+                if (HasPrevLineContent(sc) && FollowToLineEnd('=', SCE_MARKDOWN_HEADER1, endPos, sc))
+                    ;
+                else
+                    sc.SetState(SCE_MARKDOWN_DEFAULT);
+            }
+            else if (sc.ch == '-') {
+                if (HasPrevLineContent(sc) && FollowToLineEnd('-', SCE_MARKDOWN_HEADER2, endPos, sc))
+                    ;
+                else {
+                    precharCount = 0;
+                    sc.SetState(SCE_MARKDOWN_PRECHAR);
+                }
+            }
+            else if (IsNewline(sc.ch))
+                sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
+            else {
+                precharCount = 0;
+                sc.SetState(SCE_MARKDOWN_PRECHAR);
+            }
+        }
+
+        // The header lasts until the newline
+        else if (sc.state == SCE_MARKDOWN_HEADER1 || sc.state == SCE_MARKDOWN_HEADER2 ||
+                sc.state == SCE_MARKDOWN_HEADER3 || sc.state == SCE_MARKDOWN_HEADER4 ||
+                sc.state == SCE_MARKDOWN_HEADER5 || sc.state == SCE_MARKDOWN_HEADER6) {
+            if (IsNewline(sc.ch))
+                sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
+        }
+
+        // New state only within the initial whitespace
+        if (sc.state == SCE_MARKDOWN_PRECHAR) {
+            // Blockquote
+            if (sc.ch == '>' && precharCount < 5)
+                sc.SetState(SCE_MARKDOWN_BLOCKQUOTE);
+            /*
+            // Begin of code block
+            else if (!HasPrevLineContent(sc) && (sc.chPrev == '\t' || precharCount >= 4))
+                sc.SetState(SCE_MARKDOWN_CODEBK);
+            */
+            // HRule - Total of three or more hyphens, asterisks, or underscores
+            // on a line by themselves
+            else if ((sc.ch == '-' || sc.ch == '*' || sc.ch == '_') && IsValidHrule(endPos, sc))
+                ;
+            // Unordered list
+            else if ((sc.ch == '-' || sc.ch == '*' || sc.ch == '+') && IsASpaceOrTab(sc.chNext)) {
+                sc.SetState(SCE_MARKDOWN_ULIST_ITEM);
+                sc.ForwardSetState(SCE_MARKDOWN_DEFAULT);
+            }
+            // Ordered list
+            else if (IsADigit(sc.ch)) {
+                int digitCount = 0;
+                while (IsADigit(sc.GetRelative(++digitCount)))
+                    ;
+                if (sc.GetRelative(digitCount) == '.' &&
+                        IsASpaceOrTab(sc.GetRelative(digitCount + 1))) {
+                    sc.SetState(SCE_MARKDOWN_OLIST_ITEM);
+                    sc.Forward(digitCount + 1);
+                    sc.SetState(SCE_MARKDOWN_DEFAULT);
+                }
+            }
+            // Alternate Ordered list
+            else if (sc.ch == '#' && sc.chNext == '.' && IsASpaceOrTab(sc.GetRelative(2))) {
+                sc.SetState(SCE_MARKDOWN_OLIST_ITEM);
+                sc.Forward(2);
+                sc.SetState(SCE_MARKDOWN_DEFAULT);
+            }
+            else if (sc.ch != ' ' || precharCount > 2)
+                sc.SetState(SCE_MARKDOWN_DEFAULT);
+            else
+                ++precharCount;
+        }
+
+        // Any link
+        if (sc.state == SCE_MARKDOWN_LINK) {
+            if (sc.Match("](") && sc.GetRelative(-1) != '\\') {
+              sc.Forward(2);
+              isLinkNameDetecting = true;
+            }
+            else if (sc.Match("]:") && sc.GetRelative(-1) != '\\') {
+              sc.Forward(2);
+              sc.SetState(SCE_MARKDOWN_DEFAULT);
+            }
+            else if (!isLinkNameDetecting && sc.ch == ']' && sc.GetRelative(-1) != '\\') {
+              sc.Forward();
+              sc.SetState(SCE_MARKDOWN_DEFAULT);
+            }
+            else if (isLinkNameDetecting && sc.ch == ')' && sc.GetRelative(-1) != '\\') {
+              sc.Forward();
+              sc.SetState(SCE_MARKDOWN_DEFAULT);
+              isLinkNameDetecting = false;
+            }
+        }
+
+        // New state anywhere in doc
+        if (sc.state == SCE_MARKDOWN_DEFAULT) {
+            if (sc.atLineStart && sc.ch == '#') {
+                sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
+                freezeCursor = true;
+            }
+            // Links and Images
+            if (sc.Match("![")) {
+              sc.SetState(SCE_MARKDOWN_LINK);
+              sc.Forward(2);
+            }
+            else if (sc.ch == '[' && sc.GetRelative(-1) != '\\') {
+              sc.SetState(SCE_MARKDOWN_LINK);
+              sc.Forward();
+            }
+            // Code - also a special case for alternate inside spacing
+            else if (sc.Match("``") && sc.GetRelative(3) != ' ' && AtTermStart(sc)) {
+                sc.SetState(SCE_MARKDOWN_CODE2);
+                sc.Forward();
+            }
+            else if (sc.ch == '`' && sc.chNext != ' ' && AtTermStart(sc)) {
+                sc.SetState(SCE_MARKDOWN_CODE);
+            }
+            // Strong
+            else if (sc.Match("**") && sc.GetRelative(2) != ' ' && AtTermStart(sc)) {
+                sc.SetState(SCE_MARKDOWN_STRONG1);
+                sc.Forward();
+           }
+            else if (sc.Match("__") && sc.GetRelative(2) != ' ' && AtTermStart(sc)) {
+                sc.SetState(SCE_MARKDOWN_STRONG2);
+                sc.Forward();
+            }
+            // Emphasis
+            else if (sc.ch == '*' && sc.chNext != ' ' && AtTermStart(sc)) {
+                sc.SetState(SCE_MARKDOWN_EM1);
+            }
+            else if (sc.ch == '_' && sc.chNext != ' ' && AtTermStart(sc)) {
+                sc.SetState(SCE_MARKDOWN_EM2);
+            }
+            // Strikeout
+            else if (sc.Match("~~") && sc.GetRelative(2) != ' ' && AtTermStart(sc)) {
+                sc.SetState(SCE_MARKDOWN_STRIKEOUT);
+                sc.Forward();
+            }
+            // Beginning of line
+            else if (IsNewline(sc.ch)) {
+                sc.SetState(SCE_MARKDOWN_LINE_BEGIN);
+            }
+        }
+        // Advance if not holding back the cursor for this iteration.
+        if (!freezeCursor)
+            sc.Forward();
+        freezeCursor = false;
+    }
+    sc.Complete();
+}
+
+LexerModule lmMarkdown(SCLEX_MARKDOWN, ColorizeMarkdownDoc, "markdown");
diff --git a/Pythonwin/Scintilla/lexers/LexMatlab.cxx b/Pythonwin/Scintilla/lexers/LexMatlab.cxx
new file mode 100644
index 000000000..3d08c9a33
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexMatlab.cxx
@@ -0,0 +1,389 @@
+// Scintilla source code edit control
+// Encoding: UTF-8
+/** @file LexMatlab.cxx
+ ** Lexer for Matlab.
+ ** Written by José Fonseca
+ **
+ ** Changes by Christoph Dalitz 2003/12/04:
+ **   - added support for Octave
+ **   - Strings can now be included both in single or double quotes
+ **
+ ** Changes by John Donoghue 2012/04/02
+ **   - added block comment (and nested block comments)
+ **   - added ... displayed as a comment
+ **   - removed unused IsAWord functions
+ **   - added some comments
+ **
+ ** Changes by John Donoghue 2014/08/01
+ **   - fix allowed transpose ' after {} operator
+ **
+ ** Changes by John Donoghue 2016/11/15
+ **   - update matlab code folding
+ **
+ ** Changes by John Donoghue 2017/01/18
+ **   - update matlab block comment detection
+ **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static bool IsMatlabCommentChar(int c) {
+	return (c == '%') ;
+}
+
+static bool IsOctaveCommentChar(int c) {
+	return (c == '%' || c == '#') ;
+}
+
+static inline int LowerCase(int c) {
+	if (c >= 'A' && c <= 'Z')
+		return 'a' + c - 'A';
+	return c;
+}
+
+static int CheckKeywordFoldPoint(char *str) {
+	if (strcmp ("if", str) == 0 ||
+		strcmp ("for", str) == 0 ||
+		strcmp ("switch", str) == 0 ||
+		strcmp ("while", str) == 0 ||
+		strcmp ("try", str) == 0 ||
+		strcmp ("do", str) == 0 ||
+		strcmp ("parfor", str) == 0 ||
+		strcmp ("function", str) == 0)
+		return 1;
+	if (strncmp("end", str, 3) == 0 ||
+		strcmp("until", str) == 0)
+		return -1;
+	return 0;
+}
+
+static bool IsSpaceToEOL(Sci_Position startPos, Accessor &styler) {
+	Sci_Position line = styler.GetLine(startPos);
+	Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = startPos; i < eol_pos; i++) {
+		char ch = styler[i];
+		if(!IsASpace(ch)) return false;
+	}
+	return true;
+}
+
+static void ColouriseMatlabOctaveDoc(
+            Sci_PositionU startPos, Sci_Position length, int initStyle,
+            WordList *keywordlists[], Accessor &styler,
+            bool (*IsCommentChar)(int),
+            bool ismatlab) {
+
+	WordList &keywords = *keywordlists[0];
+
+	styler.StartAt(startPos);
+
+	// boolean for when the ' is allowed to be transpose vs the start/end
+	// of a string
+	bool transpose = false;
+
+	// count of brackets as boolean for when end could be an operator not a keyword
+	int allow_end_op = 0;
+
+	// approximate position of first non space character in a line
+	int nonSpaceColumn = -1;
+	// approximate column position of the current character in a line
+	int column = 0;
+
+        // use the line state of each line to store the block comment depth
+	Sci_Position curLine = styler.GetLine(startPos);
+        int commentDepth = curLine > 0 ? styler.GetLineState(curLine-1) : 0;
+
+
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	for (; sc.More(); sc.Forward(), column++) {
+
+               	if(sc.atLineStart) {
+			// set the line state to the current commentDepth
+			curLine = styler.GetLine(sc.currentPos);
+                        styler.SetLineState(curLine, commentDepth);
+
+			// reset the column to 0, nonSpace to -1 (not set)
+			column = 0;
+			nonSpaceColumn = -1;
+		}
+
+		// save the column position of first non space character in a line
+		if((nonSpaceColumn == -1) && (! IsASpace(sc.ch)))
+		{
+			nonSpaceColumn = column;
+		}
+
+		// check for end of states
+		if (sc.state == SCE_MATLAB_OPERATOR) {
+			if (sc.chPrev == '.') {
+				if (sc.ch == '*' || sc.ch == '/' || sc.ch == '\\' || sc.ch == '^') {
+					sc.ForwardSetState(SCE_MATLAB_DEFAULT);
+					transpose = false;
+				} else if (sc.ch == '\'') {
+					sc.ForwardSetState(SCE_MATLAB_DEFAULT);
+					transpose = true;
+                                } else if(sc.ch == '.' && sc.chNext == '.') {
+                                        // we werent an operator, but a '...'
+                                        sc.ChangeState(SCE_MATLAB_COMMENT);
+                                        transpose = false;
+				} else {
+					sc.SetState(SCE_MATLAB_DEFAULT);
+				}
+			} else {
+				sc.SetState(SCE_MATLAB_DEFAULT);
+			}
+		} else if (sc.state == SCE_MATLAB_KEYWORD) {
+			if (!isalnum(sc.ch) && sc.ch != '_') {
+				char s[100];
+				sc.GetCurrent(s, sizeof(s));
+
+				if (keywords.InList(s)) {
+					if (strcmp ("end", s) == 0 && allow_end_op) {
+						sc.ChangeState(SCE_MATLAB_NUMBER);
+					}
+					sc.SetState(SCE_MATLAB_DEFAULT);
+					transpose = false;
+				} else {
+					sc.ChangeState(SCE_MATLAB_IDENTIFIER);
+					sc.SetState(SCE_MATLAB_DEFAULT);
+					transpose = true;
+				}
+			}
+		} else if (sc.state == SCE_MATLAB_NUMBER) {
+			if (!isdigit(sc.ch) && sc.ch != '.'
+			        && !(sc.ch == 'e' || sc.ch == 'E')
+			        && !((sc.ch == '+' || sc.ch == '-') && (sc.chPrev == 'e' || sc.chPrev == 'E'))) {
+				sc.SetState(SCE_MATLAB_DEFAULT);
+				transpose = true;
+			}
+		} else if (sc.state == SCE_MATLAB_STRING) {
+			if (sc.ch == '\'') {
+				if (sc.chNext == '\'') {
+ 					sc.Forward();
+				} else {
+					sc.ForwardSetState(SCE_MATLAB_DEFAULT);
+ 				}
+			}
+		} else if (sc.state == SCE_MATLAB_DOUBLEQUOTESTRING) {
+			if (sc.ch == '\\') {
+				if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+					sc.Forward();
+				}
+			} else if (sc.ch == '\"') {
+				sc.ForwardSetState(SCE_MATLAB_DEFAULT);
+			}
+		} else if (sc.state == SCE_MATLAB_COMMAND) {
+			if (sc.atLineEnd) {
+				sc.SetState(SCE_MATLAB_DEFAULT);
+				transpose = false;
+			}
+		} else if (sc.state == SCE_MATLAB_COMMENT) {
+			// end or start of a nested a block comment?
+			if( IsCommentChar(sc.ch) && sc.chNext == '}' && nonSpaceColumn == column && IsSpaceToEOL(sc.currentPos+2, styler)) {
+                           	if(commentDepth > 0) commentDepth --;
+
+				curLine = styler.GetLine(sc.currentPos);
+				styler.SetLineState(curLine, commentDepth);
+				sc.Forward();
+
+				if (commentDepth == 0) {
+					sc.ForwardSetState(SCE_D_DEFAULT);
+					transpose = false;
+				}
+                        }
+                        else if( IsCommentChar(sc.ch) && sc.chNext == '{' && nonSpaceColumn == column && IsSpaceToEOL(sc.currentPos+2, styler))
+                        {
+ 				commentDepth ++;
+
+				curLine = styler.GetLine(sc.currentPos);
+				styler.SetLineState(curLine, commentDepth);
+				sc.Forward();
+				transpose = false;
+
+                        } else if(commentDepth == 0) {
+				// single line comment
+				if (sc.atLineEnd || sc.ch == '\r' || sc.ch == '\n') {
+					sc.SetState(SCE_MATLAB_DEFAULT);
+					transpose = false;
+				}
+			}
+		}
+
+		// check start of a new state
+		if (sc.state == SCE_MATLAB_DEFAULT) {
+			if (IsCommentChar(sc.ch)) {
+				// ncrement depth if we are a block comment
+				if(sc.chNext == '{' && nonSpaceColumn == column) {
+					if(IsSpaceToEOL(sc.currentPos+2, styler)) {
+						commentDepth ++;
+					}
+				}
+				curLine = styler.GetLine(sc.currentPos);
+				styler.SetLineState(curLine, commentDepth);
+				sc.SetState(SCE_MATLAB_COMMENT);
+			} else if (sc.ch == '!' && sc.chNext != '=' ) {
+				if(ismatlab) {
+					sc.SetState(SCE_MATLAB_COMMAND);
+				} else {
+					sc.SetState(SCE_MATLAB_OPERATOR);
+				}
+			} else if (sc.ch == '\'') {
+				if (transpose) {
+					sc.SetState(SCE_MATLAB_OPERATOR);
+				} else {
+					sc.SetState(SCE_MATLAB_STRING);
+				}
+			} else if (sc.ch == '"') {
+				sc.SetState(SCE_MATLAB_DOUBLEQUOTESTRING);
+			} else if (isdigit(sc.ch) || (sc.ch == '.' && isdigit(sc.chNext))) {
+				sc.SetState(SCE_MATLAB_NUMBER);
+			} else if (isalpha(sc.ch)) {
+				sc.SetState(SCE_MATLAB_KEYWORD);
+			} else if (isoperator(static_cast<char>(sc.ch)) || sc.ch == '@' || sc.ch == '\\') {
+				if (sc.ch == '(' || sc.ch == '[' || sc.ch == '{') {
+					allow_end_op ++;
+				} else if ((sc.ch == ')' || sc.ch == ']' || sc.ch == '}') && (allow_end_op > 0)) {
+					allow_end_op --;
+				}
+
+				if (sc.ch == ')' || sc.ch == ']' || sc.ch == '}') {
+					transpose = true;
+				} else {
+					transpose = false;
+				}
+				sc.SetState(SCE_MATLAB_OPERATOR);
+			} else {
+				transpose = false;
+			}
+		}
+	}
+	sc.Complete();
+}
+
+static void ColouriseMatlabDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+                               WordList *keywordlists[], Accessor &styler) {
+	ColouriseMatlabOctaveDoc(startPos, length, initStyle, keywordlists, styler, IsMatlabCommentChar, true);
+}
+
+static void ColouriseOctaveDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+                               WordList *keywordlists[], Accessor &styler) {
+	ColouriseMatlabOctaveDoc(startPos, length, initStyle, keywordlists, styler, IsOctaveCommentChar, false);
+}
+
+static void FoldMatlabOctaveDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+                                WordList *[], Accessor &styler,
+                                bool (*IsComment)(int ch)) {
+
+	if (styler.GetPropertyInt("fold") == 0)
+		return;
+
+	const bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+	const bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelCurrent = SC_FOLDLEVELBASE;
+	if (lineCurrent > 0)
+		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
+	int levelNext = levelCurrent;
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+	char word[100];
+	int wordlen = 0;
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+
+		// a line that starts with a comment
+		if (foldComment && style == SCE_MATLAB_COMMENT && IsComment(ch) && visibleChars == 0) {
+			// start/end of block comment
+			if (chNext == '{' && IsSpaceToEOL(i+2, styler))
+				levelNext ++;
+			if (chNext == '}' && IsSpaceToEOL(i+2, styler))
+				levelNext --;
+		}
+		// keyword
+		if(style == SCE_MATLAB_KEYWORD) {
+			word[wordlen++] = static_cast<char>(LowerCase(ch));
+			if (wordlen == 100) {  // prevent overflow
+				word[0] = '\0';
+				wordlen = 1;
+			}
+			if (styleNext !=  SCE_MATLAB_KEYWORD) {
+				word[wordlen] = '\0';
+				wordlen = 0;
+
+				levelNext += CheckKeywordFoldPoint(word);
+ 			}
+		}
+		if (!IsASpace(ch))
+			visibleChars++;
+		if (atEOL || (i == endPos-1)) {
+			int levelUse = levelCurrent;
+			int lev = levelUse | levelNext << 16;
+			if (visibleChars == 0 && foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if (levelUse < levelNext)
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			levelCurrent = levelNext;
+			if (atEOL && (i == static_cast<Sci_PositionU>(styler.Length() - 1))) {
+				// There is an empty line at end of file so give it same level and empty
+				styler.SetLevel(lineCurrent, (levelCurrent | levelCurrent << 16) | SC_FOLDLEVELWHITEFLAG);
+			}
+			visibleChars = 0;
+		}
+	}
+}
+
+static void FoldMatlabDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+                          WordList *keywordlists[], Accessor &styler) {
+	FoldMatlabOctaveDoc(startPos, length, initStyle, keywordlists, styler, IsMatlabCommentChar);
+}
+
+static void FoldOctaveDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+                          WordList *keywordlists[], Accessor &styler) {
+	FoldMatlabOctaveDoc(startPos, length, initStyle, keywordlists, styler, IsOctaveCommentChar);
+}
+
+static const char * const matlabWordListDesc[] = {
+	"Keywords",
+	0
+};
+
+static const char * const octaveWordListDesc[] = {
+	"Keywords",
+	0
+};
+
+LexerModule lmMatlab(SCLEX_MATLAB, ColouriseMatlabDoc, "matlab", FoldMatlabDoc, matlabWordListDesc);
+
+LexerModule lmOctave(SCLEX_OCTAVE, ColouriseOctaveDoc, "octave", FoldOctaveDoc, octaveWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexMaxima.cxx b/Pythonwin/Scintilla/lexers/LexMaxima.cxx
new file mode 100644
index 000000000..4897c995e
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexMaxima.cxx
@@ -0,0 +1,222 @@
+// Scintilla source code edit control
+/** @file LexMaxima.cxx
+ ** Lexer for Maxima (http://maxima.sourceforge.net).
+ ** Written by Gunter Königsmann based on the lisp lexer by Alexey Yutkin and Neil Hodgson .
+ **/
+// Copyright 2018 by Gunter Königsmann <wxMaxima@physikbuch.de>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+using namespace Scintilla;
+
+static inline bool isMaximaoperator(char ch) {
+  return (ch == '\'' || ch == '`' || ch == '(' ||
+	  ch == ')'  || ch == '[' || ch == ']' ||
+	  ch == '{'  || ch == '}' || ch == '!' ||
+	  ch == '*'  || ch == '/' || ch == '^' ||
+	  ch == ','  || ch == ':' || ch == '+' ||
+	  ch == '-');
+}
+
+static void ColouriseMaximaDoc(Sci_PositionU startPos, Sci_Position length, int lastStyle,
+			       WordList *[],
+			       Accessor &styler) {
+
+  styler.StartAt(startPos);
+
+  Sci_PositionU lengthDoc = startPos + length;
+  styler.StartSegment(startPos);
+
+  Sci_PositionU i = startPos;
+
+  // If we are in the middle of a comment we go back to its start before highlighting
+  if(lastStyle == SCE_MAXIMA_COMMENT)
+    {
+      while((i>0) &&
+	    !((styler.SafeGetCharAt(i+1) == '*') && (styler.SafeGetCharAt(i) == '/')))
+	i--;
+    }
+
+  for (; i < lengthDoc; i++) {
+    char ch = styler.SafeGetCharAt(i);
+    char chNext = styler.SafeGetCharAt(i + 1);
+
+    if (styler.IsLeadByte(ch))
+      continue;
+
+    // Handle comments.
+    // Comments start with /* and end with */
+    if((ch == '/') && (chNext == '*'))
+      {
+	i++;i++;
+
+	chNext = styler.SafeGetCharAt(i);
+	for (; i < lengthDoc; i++)
+	  {
+	    ch = chNext;
+	    chNext = styler.SafeGetCharAt(i + 1);
+	    if((ch == '*') && (chNext == '/'))
+	      {
+		i++;
+		i++;
+		break;
+	      }
+	  }
+	if(i > lengthDoc)
+	  i = lengthDoc;
+	i--;
+	styler.ColourTo(i, SCE_MAXIMA_COMMENT);
+	continue;
+      }
+
+    // Handle Operators
+    if(isMaximaoperator(ch))
+      {
+	styler.ColourTo(i, SCE_MAXIMA_OPERATOR);
+	continue;
+      }
+
+    // Handle command endings.
+    if((ch == '$') || (ch == ';'))
+      {
+	styler.ColourTo(i, SCE_MAXIMA_COMMANDENDING);
+	continue;
+      }
+
+    // Handle numbers. Numbers always begin with a digit.
+    if(IsASCII(ch) && isdigit(ch))
+      {
+	i++;
+	for (; i < lengthDoc; i++)
+	  {
+	    ch = chNext;
+	    chNext = styler.SafeGetCharAt(i + 1);
+
+	    if(ch == '.')
+	      continue;
+
+	    // A "e" or similar can be followed by a "+" or a "-"
+	    if(((ch == 'e') || (ch == 'b') || (ch == 'g') || (ch == 'f')) &&
+	       ((chNext == '+') || (chNext == '-')))
+	      {
+		i++;
+		chNext = styler.SafeGetCharAt(i + 1);
+		continue;
+	      }
+
+	    if(!IsASCII(ch) || !(isdigit(ch) || islower(ch) || isupper(ch)))
+	      {
+		i--;
+		break;
+	      }
+	  }
+	styler.ColourTo(i, SCE_MAXIMA_NUMBER);
+	continue;
+      }
+
+    // Handle strings
+    if(ch == '\"')
+      {
+	i++;
+	for (; i < lengthDoc; i++)
+	  {
+	    ch = chNext;
+	    chNext = styler.SafeGetCharAt(i + 1);
+	    if(ch == '\\')
+	      i++;
+	    else
+	      {
+		if(ch == '\"')
+		  break;
+	      }
+	  }
+	styler.ColourTo(i, SCE_MAXIMA_STRING);
+	continue;
+      }
+
+    // Handle keywords. Maxima treats Non-ASCII chars as ordinary letters.
+    if(((!IsASCII(ch))) || isalpha(ch) || (ch == '_'))
+      {
+	char cmd[100];
+	int cmdidx = 0;
+	memset(cmd,0,100);
+	cmd[cmdidx++] = ch;
+	i++;
+	for (; i < lengthDoc; i++)
+	  {
+	    ch = chNext;
+	    chNext = styler.SafeGetCharAt(i + 1);
+	    if(ch == '\\')
+	      {
+		if(cmdidx < 99)
+		  cmd[cmdidx++] = ch;
+		i++;
+		if(cmdidx < 99)
+		  cmd[cmdidx++] = ch;
+		continue;
+	      }
+	    if(isMaximaoperator(ch) || ((IsASCII(ch) && !isalpha(ch) && !isdigit(ch) && (ch != '_'))))
+	      {
+		i--;
+		break;
+	      }
+	    if(cmdidx < 99)
+	      cmd[cmdidx++] = ch;
+	  }
+
+	// A few known keywords
+	if(
+	   (strncmp(cmd,"if",99) == 0) ||
+	   (strncmp(cmd,"then",99) == 0) ||
+	   (strncmp(cmd,"else",99) == 0) ||
+	   (strncmp(cmd,"thru",99) == 0) ||
+	   (strncmp(cmd,"for",99) == 0) ||
+	   (strncmp(cmd,"while",99) == 0) ||
+	   (strncmp(cmd,"do",99) == 0)
+	   )
+	  {
+	    styler.ColourTo(i, SCE_MAXIMA_COMMAND);
+	    continue;
+	  }
+
+	// All other keywords are functions if they are followed
+	// by an opening parenthesis
+	char nextNonwhitespace = ' ';
+	for (Sci_PositionU o = i + 1; o < lengthDoc; o++)
+	  {
+	    nextNonwhitespace = styler.SafeGetCharAt(o);
+	    if(!IsASCII(nextNonwhitespace) || !isspacechar(nextNonwhitespace))
+	      break;
+	  }
+	if(nextNonwhitespace == '(')
+	  {
+	    styler.ColourTo(i, SCE_MAXIMA_COMMAND);
+	  }
+	else
+	  {
+	    styler.ColourTo(i, SCE_MAXIMA_VARIABLE);
+	  }
+	continue;
+      }
+
+    styler.ColourTo(i-1, SCE_MAXIMA_UNKNOWN);
+  }
+}
+
+LexerModule lmMaxima(SCLEX_MAXIMA, ColouriseMaximaDoc, "maxima", 0, 0);
diff --git a/Pythonwin/Scintilla/src/LexMetapost.cxx b/Pythonwin/Scintilla/lexers/LexMetapost.cxx
similarity index 91%
rename from Pythonwin/Scintilla/src/LexMetapost.cxx
rename to Pythonwin/Scintilla/lexers/LexMetapost.cxx
index 6afc9d826..6be99f6cb 100644
--- a/Pythonwin/Scintilla/src/LexMetapost.cxx
+++ b/Pythonwin/Scintilla/lexers/LexMetapost.cxx
@@ -1,6 +1,6 @@
 // Scintilla source code edit control
 
-// File: LexMetapost.cxx - general context conformant metapost coloring scheme
+// @file LexMetapost.cxx - general context conformant metapost coloring scheme
 // Author: Hans Hagen - PRAGMA ADE - Hasselt NL - www.pragma-ade.com
 // Version: September 28, 2003
 // Modified by instanton: July 10, 2007
@@ -14,22 +14,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
 #include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 // val SCE_METAPOST_DEFAULT = 0
 // val SCE_METAPOST_SPECIAL = 1
@@ -59,7 +60,7 @@ using namespace Scintilla;
 
 // Auxiliary functions:
 
-static inline bool endOfLine(Accessor &styler, unsigned int i) {
+static inline bool endOfLine(Accessor &styler, Sci_PositionU i) {
 	return
       (styler[i] == '\n') || ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n')) ;
 }
@@ -116,18 +117,18 @@ static inline bool isMETAPOSTequal(int ch) {
 }
 
 static int CheckMETAPOSTInterface(
-    unsigned int startPos,
-    int length,
+    Sci_PositionU startPos,
+    Sci_Position length,
     Accessor &styler,
 	int defaultInterface) {
 
     char lineBuffer[1024] ;
-	unsigned int linePos = 0 ;
+	Sci_PositionU linePos = 0 ;
 
 	// some day we can make something lexer.metapost.mapping=(none,0)(metapost,1)(mp,1)(metafun,2)...
 
     if (styler.SafeGetCharAt(0) == '%') {
-        for (unsigned int i = 0; i < startPos + length; i++) {
+        for (Sci_PositionU i = 0; i < startPos + length; i++) {
             lineBuffer[linePos++] = styler.SafeGetCharAt(i) ;
             if (endOfLine(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
                 lineBuffer[linePos] = '\0';
@@ -151,8 +152,8 @@ static int CheckMETAPOSTInterface(
 }
 
 static void ColouriseMETAPOSTDoc(
-    unsigned int startPos,
-    int length,
+    Sci_PositionU startPos,
+    Sci_Position length,
     int,
     WordList *keywordlists[],
     Accessor &styler) {
@@ -176,7 +177,8 @@ static void ColouriseMETAPOSTDoc(
 	}
 
 	WordList &keywords  = *keywordlists[0] ;
-	WordList &keywords2 = *keywordlists[extraInterface-1] ;
+	WordList kwEmpty;
+	WordList &keywords2 = (extraInterface > 0) ? *keywordlists[extraInterface - 1] : kwEmpty;
 
 	StyleContext sc(startPos, length, SCE_METAPOST_TEXT, styler) ;
 
@@ -326,14 +328,14 @@ static const char * const metapostWordListDesc[] = {
 static int classifyFoldPointMetapost(const char* s,WordList *keywordlists[]) {
 	WordList& keywordsStart=*keywordlists[3];
 	WordList& keywordsStop1=*keywordlists[4];
-	
+
 	if (keywordsStart.InList(s)) {return 1;}
 	else if (keywordsStop1.InList(s)) {return -1;}
 	return 0;
-	
+
 }
 
-static int ParseMetapostWord(unsigned int pos, Accessor &styler, char *word)
+static int ParseMetapostWord(Sci_PositionU pos, Accessor &styler, char *word)
 {
   int length=0;
   char ch=styler.SafeGetCharAt(pos);
@@ -344,23 +346,23 @@ static int ParseMetapostWord(unsigned int pos, Accessor &styler, char *word)
           length++;
           ch=styler.SafeGetCharAt(pos+length);
   }
-  word[length]=0;   
+  word[length]=0;
   return length;
 }
- 
-static void FoldMetapostDoc(unsigned int startPos, int length, int, WordList *keywordlists[], Accessor &styler) 
+
+static void FoldMetapostDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *keywordlists[], Accessor &styler)
 {
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	unsigned int endPos = startPos+length;
+	Sci_PositionU endPos = startPos+length;
 	int visibleChars=0;
-	int lineCurrent=styler.GetLine(startPos);
+	Sci_Position lineCurrent=styler.GetLine(startPos);
 	int levelPrev=styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent=levelPrev;
 	char chNext=styler[startPos];
-	
+
 	char buffer[100]="";
-	
-	for (unsigned int i=startPos; i < endPos; i++) {
+
+	for (Sci_PositionU i=startPos; i < endPos; i++) {
 		char ch=chNext;
 		chNext=styler.SafeGetCharAt(i+1);
 		char chPrev=styler.SafeGetCharAt(i-1);
@@ -371,7 +373,7 @@ static void FoldMetapostDoc(unsigned int startPos, int length, int, WordList *ke
             ParseMetapostWord(i, styler, buffer);
 			levelCurrent += classifyFoldPointMetapost(buffer,keywordlists);
 		}
-		
+
 		if (atEOL) {
 			int lev = levelPrev;
 			if (visibleChars == 0 && foldCompact)
diff --git a/Pythonwin/Scintilla/lexers/LexModula.cxx b/Pythonwin/Scintilla/lexers/LexModula.cxx
new file mode 100644
index 000000000..af4b8dd1b
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexModula.cxx
@@ -0,0 +1,741 @@
+//	-*- coding: utf-8 -*-
+//	Scintilla source code edit control
+/**
+ *	@file LexModula.cxx
+ *	@author Dariusz "DKnoto" Knociński
+ *	@date 2011/02/03
+ *	@brief Lexer for Modula-2/3 documents.
+ */
+//	The License.txt file describes the conditions under which this software may
+//	be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+#ifdef DEBUG_LEX_MODULA
+#define DEBUG_STATE( p, c )\
+		fprintf( stderr, "Unknown state: currentPos = %u, char = '%c'\n", static_cast<unsigned int>(p), c );
+#else
+#define DEBUG_STATE( p, c )
+#endif
+
+static inline bool IsDigitOfBase( unsigned ch, unsigned base ) {
+	if( ch < '0' || ch > 'f' ) return false;
+	if( base <= 10 ) {
+		if( ch >= ( '0' + base ) ) return false;
+	} else {
+		if( ch > '9' ) {
+			unsigned nb = base - 10;
+			if( ( ch < 'A' ) || ( ch >= ( 'A' + nb ) ) ) {
+				if( ( ch < 'a' ) || ( ch >= ( 'a' + nb ) ) ) {
+					return false;
+				}
+			}
+		}
+	}
+	return true;
+}
+
+static inline unsigned IsOperator( StyleContext & sc, WordList & op ) {
+	int i;
+	char s[3];
+
+	s[0] = sc.ch;
+	s[1] = sc.chNext;
+	s[2] = 0;
+	for( i = 0; i < op.Length(); i++ ) {
+		if( ( strlen( op.WordAt(i) ) == 2 ) &&
+			( s[0] == op.WordAt(i)[0] && s[1] == op.WordAt(i)[1] ) ) {
+			return 2;
+		}
+	}
+	s[1] = 0;
+	for( i = 0; i < op.Length(); i++ ) {
+		if( ( strlen( op.WordAt(i) ) == 1 ) &&
+			( s[0] == op.WordAt(i)[0] ) ) {
+			return 1;
+		}
+	}
+	return 0;
+}
+
+static inline bool IsEOL( Accessor &styler, Sci_PositionU curPos ) {
+	unsigned ch = styler.SafeGetCharAt( curPos );
+	if( ( ch == '\r' && styler.SafeGetCharAt( curPos + 1 ) == '\n' ) ||
+		( ch == '\n' ) ) {
+		return true;
+	}
+	return false;
+}
+
+static inline bool checkStatement(
+	Accessor &styler,
+	Sci_Position &curPos,
+	const char *stt, bool spaceAfter = true ) {
+	int len = static_cast<int>(strlen( stt ));
+	int i;
+	for( i = 0; i < len; i++ ) {
+		if( styler.SafeGetCharAt( curPos + i ) != stt[i] ) {
+			return false;
+		}
+	}
+	if( spaceAfter ) {
+		if( ! isspace( styler.SafeGetCharAt( curPos + i ) ) ) {
+			return false;
+		}
+	}
+	curPos += ( len - 1 );
+	return true;
+}
+
+static inline bool checkEndSemicolon(
+	Accessor &styler,
+	Sci_Position &curPos, Sci_Position endPos )
+{
+	const char *stt = "END";
+	int len = static_cast<int>(strlen( stt ));
+	int i;
+	for( i = 0; i < len; i++ ) {
+		if( styler.SafeGetCharAt( curPos + i ) != stt[i] ) {
+			return false;
+		}
+	}
+	while( isspace( styler.SafeGetCharAt( curPos + i ) ) ) {
+		i++;
+		if( ( curPos + i ) >= endPos ) return false;
+	}
+	if( styler.SafeGetCharAt( curPos + i ) != ';' ) {
+		return false;
+	}
+	curPos += ( i - 1 );
+	return true;
+}
+
+static inline bool checkKeyIdentOper(
+
+	Accessor &styler,
+	Sci_Position &curPos, Sci_Position endPos,
+	const char *stt, const char etk ) {
+	Sci_Position newPos = curPos;
+	if( ! checkStatement( styler, newPos, stt ) )
+		return false;
+	newPos++;
+	if( newPos >= endPos )
+		return false;
+	if( ! isspace( styler.SafeGetCharAt( newPos ) ) )
+		return false;
+	newPos++;
+	if( newPos >= endPos )
+		return false;
+	while( isspace( styler.SafeGetCharAt( newPos ) ) ) {
+		newPos++;
+		if( newPos >= endPos )
+			return false;
+	}
+	if( ! isalpha( styler.SafeGetCharAt( newPos ) ) )
+		return false;
+	newPos++;
+	if( newPos >= endPos )
+		return false;
+	char ch;
+	ch = styler.SafeGetCharAt( newPos );
+	while( isalpha( ch ) || isdigit( ch ) || ch == '_' ) {
+		newPos++;
+		if( newPos >= endPos ) return false;
+		ch = styler.SafeGetCharAt( newPos );
+	}
+	while( isspace( styler.SafeGetCharAt( newPos ) ) ) {
+		newPos++;
+		if( newPos >= endPos ) return false;
+	}
+	if( styler.SafeGetCharAt( newPos ) != etk )
+		return false;
+	curPos = newPos;
+	return true;
+}
+
+static void FoldModulaDoc( Sci_PositionU startPos,
+						 Sci_Position length,
+						 int , WordList *[],
+						 Accessor &styler)
+{
+	Sci_Position curLine = styler.GetLine(startPos);
+	int curLevel = SC_FOLDLEVELBASE;
+	Sci_Position endPos = startPos + length;
+	if( curLine > 0 )
+		curLevel = styler.LevelAt( curLine - 1 ) >> 16;
+	Sci_Position curPos = startPos;
+	int style = styler.StyleAt( curPos );
+	int visChars = 0;
+	int nextLevel = curLevel;
+
+	while( curPos < endPos ) {
+		if( ! isspace( styler.SafeGetCharAt( curPos ) ) ) visChars++;
+
+		switch( style ) {
+		case SCE_MODULA_COMMENT:
+			if( checkStatement( styler, curPos, "(*" ) )
+				nextLevel++;
+			else
+			if( checkStatement( styler, curPos, "*)" ) )
+				nextLevel--;
+			break;
+
+		case SCE_MODULA_DOXYCOMM:
+			if( checkStatement( styler, curPos, "(**", false ) )
+				nextLevel++;
+			else
+			if( checkStatement( styler, curPos, "*)" ) )
+				nextLevel--;
+			break;
+
+		case SCE_MODULA_KEYWORD:
+			if( checkStatement( styler, curPos, "IF" ) )
+				nextLevel++;
+			else
+			if( checkStatement( styler, curPos, "BEGIN" ) )
+				nextLevel++;
+			else
+			if( checkStatement( styler, curPos, "TRY" ) )
+				nextLevel++;
+			else
+			if( checkStatement( styler, curPos, "LOOP" ) )
+				nextLevel++;
+			else
+			if( checkStatement( styler, curPos, "FOR" ) )
+				nextLevel++;
+			else
+			if( checkStatement( styler, curPos, "WHILE" ) )
+				nextLevel++;
+			else
+			if( checkStatement( styler, curPos, "REPEAT" ) )
+				nextLevel++;
+			else
+			if( checkStatement( styler, curPos, "UNTIL" ) )
+				nextLevel--;
+			else
+			if( checkStatement( styler, curPos, "WITH" ) )
+				nextLevel++;
+			else
+			if( checkStatement( styler, curPos, "CASE" ) )
+				nextLevel++;
+			else
+			if( checkStatement( styler, curPos, "TYPECASE" ) )
+				nextLevel++;
+			else
+			if( checkStatement( styler, curPos, "LOCK" ) )
+				nextLevel++;
+			else
+			if( checkKeyIdentOper( styler, curPos, endPos, "PROCEDURE", '(' ) )
+				nextLevel++;
+			else
+			if( checkKeyIdentOper( styler, curPos, endPos, "END", ';' ) ) {
+				Sci_Position cln = curLine;
+				int clv_old = curLevel;
+				Sci_Position pos;
+				char ch;
+				int clv_new;
+				while( cln > 0 ) {
+					clv_new = styler.LevelAt( cln - 1 ) >> 16;
+					if( clv_new < clv_old ) {
+						nextLevel--;
+						pos = styler.LineStart( cln );
+						while( ( ch = styler.SafeGetCharAt( pos ) ) != '\n' ) {
+							if( ch == 'P' ) {
+								if( styler.StyleAt(pos) == SCE_MODULA_KEYWORD )	{
+									if( checkKeyIdentOper( styler, pos, endPos,
+														"PROCEDURE", '(' ) ) {
+										break;
+									}
+								}
+							}
+							pos++;
+						}
+						clv_old = clv_new;
+					}
+					cln--;
+				}
+			}
+			else
+			if( checkKeyIdentOper( styler, curPos, endPos, "END", '.' ) )
+				nextLevel--;
+			else
+			if( checkEndSemicolon( styler, curPos, endPos ) )
+				nextLevel--;
+			else {
+				while( styler.StyleAt( curPos + 1 ) == SCE_MODULA_KEYWORD )
+					curPos++;
+			}
+			break;
+
+		default:
+			break;
+		}
+
+		if( IsEOL( styler, curPos ) || ( curPos == endPos - 1 ) ) {
+			int efectiveLevel = curLevel | nextLevel << 16;
+			if( visChars == 0 )
+				efectiveLevel |= SC_FOLDLEVELWHITEFLAG;
+			if( curLevel < nextLevel )
+				efectiveLevel |= SC_FOLDLEVELHEADERFLAG;
+			if( efectiveLevel != styler.LevelAt(curLine) ) {
+				styler.SetLevel(curLine, efectiveLevel );
+			}
+			curLine++;
+			curLevel = nextLevel;
+			if( IsEOL( styler, curPos ) && ( curPos == endPos - 1 ) ) {
+				styler.SetLevel( curLine, ( curLevel | curLevel << 16)
+								| SC_FOLDLEVELWHITEFLAG);
+			}
+			visChars = 0;
+		}
+		curPos++;
+		style = styler.StyleAt( curPos );
+	}
+}
+
+static inline bool skipWhiteSpaces( StyleContext & sc ) {
+	while( isspace( sc.ch ) ) {
+		sc.SetState( SCE_MODULA_DEFAULT );
+		if( sc.More() )
+			sc.Forward();
+		else
+			return false;
+	}
+	return true;
+}
+
+static void ColouriseModulaDoc(	Sci_PositionU startPos,
+									Sci_Position length,
+									int initStyle,
+									WordList *wl[],
+									Accessor &styler ) {
+	WordList& keyWords		= *wl[0];
+	WordList& reservedWords	= *wl[1];
+	WordList& operators 	= *wl[2];
+	WordList& pragmaWords 	= *wl[3];
+	WordList& escapeCodes	= *wl[4];
+	WordList& doxyKeys		= *wl[5];
+
+	const int BUFLEN = 128;
+
+	char	buf[BUFLEN];
+	int		i, kl;
+
+	Sci_Position  charPos = 0;
+
+	StyleContext sc( startPos, length, initStyle, styler );
+
+	while( sc.More() ) 	{
+		switch( sc.state )	{
+		case SCE_MODULA_DEFAULT:
+			if( ! skipWhiteSpaces( sc ) ) break;
+
+			if( sc.ch == '(' && sc.chNext == '*' ) {
+				if( sc.GetRelative(2) == '*' ) {
+					sc.SetState( SCE_MODULA_DOXYCOMM );
+					sc.Forward();
+				} else {
+					sc.SetState( SCE_MODULA_COMMENT );
+				}
+				sc.Forward();
+			}
+			else
+			if( isalpha( sc.ch ) ) {
+				if( isupper( sc.ch ) && isupper( sc.chNext ) ) {
+					for( i = 0; i < BUFLEN - 1; i++ ) {
+						buf[i] = sc.GetRelative(i);
+						if( !isalpha( buf[i] ) && !(buf[i] == '_') )
+							break;
+					}
+					kl = i;
+					buf[kl] = 0;
+
+					if( keyWords.InList( buf ) ) {
+						sc.SetState( SCE_MODULA_KEYWORD );
+						sc.Forward( kl );
+						sc.SetState( SCE_MODULA_DEFAULT );
+						continue;
+					}
+					else
+					if( reservedWords.InList( buf ) ) {
+						sc.SetState( SCE_MODULA_RESERVED );
+						sc.Forward( kl );
+						sc.SetState( SCE_MODULA_DEFAULT );
+						continue;
+					} else {
+						/** check procedure identifier */
+					}
+				} else {
+					for( i = 0; i < BUFLEN - 1; i++ ) {
+						buf[i] = sc.GetRelative(i);
+						if( !isalpha( buf[i] ) &&
+							!isdigit( buf[i] ) &&
+							!(buf[i] == '_') )
+							break;
+					}
+					kl = i;
+					buf[kl] = 0;
+
+					sc.SetState( SCE_MODULA_DEFAULT );
+					sc.Forward( kl );
+					continue;
+				}
+			}
+			else
+			if( isdigit( sc.ch ) ) {
+				sc.SetState( SCE_MODULA_NUMBER );
+				continue;
+			}
+			else
+			if( sc.ch == '\"' ) {
+				sc.SetState( SCE_MODULA_STRING );
+			}
+			else
+			if( sc.ch == '\'' ) {
+				charPos = sc.currentPos;
+				sc.SetState( SCE_MODULA_CHAR );
+			}
+			else
+			if( sc.ch == '<' && sc.chNext == '*' ) {
+				sc.SetState( SCE_MODULA_PRAGMA );
+				sc.Forward();
+			} else {
+				unsigned len = IsOperator( sc, operators );
+				if( len > 0 ) {
+					sc.SetState( SCE_MODULA_OPERATOR );
+					sc.Forward( len );
+					sc.SetState( SCE_MODULA_DEFAULT );
+					continue;
+				} else {
+					DEBUG_STATE( sc.currentPos, sc.ch );
+				}
+			}
+			break;
+
+		case SCE_MODULA_COMMENT:
+			if( sc.ch == '*' && sc.chNext == ')' ) {
+				sc.Forward( 2 );
+				sc.SetState( SCE_MODULA_DEFAULT );
+				continue;
+			}
+			break;
+
+		case SCE_MODULA_DOXYCOMM:
+			switch( sc.ch ) {
+			case '*':
+				if( sc.chNext == ')' ) {
+					sc.Forward( 2 );
+					sc.SetState( SCE_MODULA_DEFAULT );
+					continue;
+				}
+				break;
+
+			case '@':
+				if( islower( sc.chNext ) ) {
+					for( i = 0; i < BUFLEN - 1; i++ ) {
+						buf[i] = sc.GetRelative(i+1);
+						if( isspace( buf[i] ) ) break;
+					}
+					buf[i] = 0;
+					kl = i;
+
+					if( doxyKeys.InList( buf ) ) {
+						sc.SetState( SCE_MODULA_DOXYKEY );
+						sc.Forward( kl + 1 );
+						sc.SetState( SCE_MODULA_DOXYCOMM );
+					}
+				}
+				break;
+
+			default:
+				break;
+			}
+			break;
+
+		case SCE_MODULA_NUMBER:
+			{
+				buf[0] = sc.ch;
+				for( i = 1; i < BUFLEN - 1; i++ ) {
+					buf[i] = sc.GetRelative(i);
+					if( ! isdigit( buf[i] ) )
+						break;
+				}
+				kl = i;
+				buf[kl] = 0;
+
+				switch( sc.GetRelative(kl) ) {
+				case '_':
+					{
+						int base = atoi( buf );
+						if( base < 2 || base > 16 ) {
+							sc.SetState( SCE_MODULA_BADSTR );
+						} else {
+							int imax;
+
+							kl++;
+							for( i = 0; i < BUFLEN - 1; i++ ) {
+								buf[i] = sc.GetRelative(kl+i);
+								if( ! IsDigitOfBase( buf[i], 16 ) ) {
+									break;
+								}
+							}
+							imax = i;
+							for( i = 0; i < imax; i++ ) {
+								if( ! IsDigitOfBase( buf[i], base ) ) {
+									sc.SetState( SCE_MODULA_BADSTR );
+									break;
+								}
+							}
+							kl += imax;
+						}
+						sc.SetState( SCE_MODULA_BASENUM );
+						for( i = 0; i < kl; i++ ) {
+							sc.Forward();
+						}
+						sc.SetState( SCE_MODULA_DEFAULT );
+						continue;
+					}
+					break;
+
+				case '.':
+					if( sc.GetRelative(kl+1) == '.' ) {
+						kl--;
+						for( i = 0; i < kl; i++ ) {
+							sc.Forward();
+						}
+						sc.Forward();
+						sc.SetState( SCE_MODULA_DEFAULT );
+						continue;
+					} else {
+						bool doNext = false;
+
+						kl++;
+
+						buf[0] = sc.GetRelative(kl);
+						if( isdigit( buf[0] ) ) {
+							for( i = 0;; i++ ) {
+								if( !isdigit(sc.GetRelative(kl+i)) )
+									break;
+							}
+							kl += i;
+							buf[0] = sc.GetRelative(kl);
+
+							switch( buf[0] )
+							{
+							case 'E':
+							case 'e':
+							case 'D':
+							case 'd':
+							case 'X':
+							case 'x':
+								kl++;
+								buf[0] = sc.GetRelative(kl);
+								if( buf[0] == '-' || buf[0] == '+' ) {
+									kl++;
+								}
+								buf[0] = sc.GetRelative(kl);
+								if( isdigit( buf[0] ) ) {
+									for( i = 0;; i++ ) {
+										if( !isdigit(sc.GetRelative(kl+i)) ) {
+											buf[0] = sc.GetRelative(kl+i);
+											break;
+										}
+									}
+									kl += i;
+									doNext = true;
+								} else {
+									sc.SetState( SCE_MODULA_BADSTR );
+								}
+								break;
+
+							default:
+								doNext = true;
+								break;
+							}
+						} else {
+							sc.SetState( SCE_MODULA_BADSTR );
+						}
+
+						if( doNext ) {
+							if( ! isspace( buf[0] ) &&
+								buf[0] != ')' &&
+								buf[0] != '>' &&
+								buf[0] != '<' &&
+								buf[0] != '=' &&
+								buf[0] != '#' &&
+								buf[0] != '+' &&
+								buf[0] != '-' &&
+								buf[0] != '*' &&
+								buf[0] != '/' &&
+								buf[0] != ',' &&
+								buf[0] != ';'
+								) {
+								sc.SetState( SCE_MODULA_BADSTR );
+							} else {
+								kl--;
+							}
+						}
+					}
+					sc.SetState( SCE_MODULA_FLOAT );
+					for( i = 0; i < kl; i++ ) {
+						sc.Forward();
+					}
+					sc.SetState( SCE_MODULA_DEFAULT );
+					continue;
+					break;
+
+				default:
+					for( i = 0; i < kl; i++ ) {
+						sc.Forward();
+					}
+					break;
+				}
+				sc.SetState( SCE_MODULA_DEFAULT );
+				continue;
+			}
+			break;
+
+		case SCE_MODULA_STRING:
+			if( sc.ch == '\"' ) {
+				sc.Forward();
+				sc.SetState( SCE_MODULA_DEFAULT );
+				continue;
+			} else {
+				if( sc.ch == '\\' ) {
+					i = 1;
+					if( IsDigitOfBase( sc.chNext, 8 ) ) {
+						for( i = 1; i < BUFLEN - 1; i++ ) {
+							if( ! IsDigitOfBase(sc.GetRelative(i+1), 8 ) )
+								break;
+						}
+						if( i == 3 ) {
+							sc.SetState( SCE_MODULA_STRSPEC );
+						} else {
+							sc.SetState( SCE_MODULA_BADSTR );
+						}
+					} else {
+						buf[0] = sc.chNext;
+						buf[1] = 0;
+
+						if( escapeCodes.InList( buf ) ) {
+							sc.SetState( SCE_MODULA_STRSPEC );
+						} else {
+							sc.SetState( SCE_MODULA_BADSTR );
+						}
+					}
+					sc.Forward(i+1);
+					sc.SetState( SCE_MODULA_STRING );
+					continue;
+				}
+			}
+			break;
+
+		case SCE_MODULA_CHAR:
+			if( sc.ch == '\'' ) {
+				sc.Forward();
+				sc.SetState( SCE_MODULA_DEFAULT );
+				continue;
+			}
+			else
+			if( ( sc.currentPos - charPos ) == 1 ) {
+				if( sc.ch == '\\' ) {
+					i = 1;
+					if( IsDigitOfBase( sc.chNext, 8 ) ) {
+						for( i = 1; i < BUFLEN - 1; i++ ) {
+							if( ! IsDigitOfBase(sc.GetRelative(i+1), 8 ) )
+								break;
+						}
+						if( i == 3 ) {
+							sc.SetState( SCE_MODULA_CHARSPEC );
+						} else {
+							sc.SetState( SCE_MODULA_BADSTR );
+						}
+					} else {
+						buf[0] = sc.chNext;
+						buf[1] = 0;
+
+						if( escapeCodes.InList( buf ) ) {
+							sc.SetState( SCE_MODULA_CHARSPEC );
+						} else {
+							sc.SetState( SCE_MODULA_BADSTR );
+						}
+					}
+					sc.Forward(i+1);
+					sc.SetState( SCE_MODULA_CHAR );
+					continue;
+				}
+			} else {
+				sc.SetState( SCE_MODULA_BADSTR );
+				sc.Forward();
+				sc.SetState( SCE_MODULA_CHAR );
+				continue;
+			}
+			break;
+
+		case SCE_MODULA_PRAGMA:
+			if( sc.ch == '*' && sc.chNext == '>' ) {
+				sc.Forward();
+				sc.Forward();
+				sc.SetState( SCE_MODULA_DEFAULT );
+				continue;
+			}
+			else
+			if( isupper( sc.ch ) && isupper( sc.chNext ) ) {
+				buf[0] = sc.ch;
+				buf[1] = sc.chNext;
+				for( i = 2; i < BUFLEN - 1; i++ ) {
+					buf[i] = sc.GetRelative(i);
+					if( !isupper( buf[i] ) )
+						break;
+				}
+				kl = i;
+				buf[kl] = 0;
+				if( pragmaWords.InList( buf ) ) {
+					sc.SetState( SCE_MODULA_PRGKEY );
+					sc.Forward( kl );
+					sc.SetState( SCE_MODULA_PRAGMA );
+					continue;
+				}
+			}
+			break;
+
+		default:
+			break;
+		}
+		sc.Forward();
+	}
+	sc.Complete();
+}
+
+static const char *const modulaWordListDesc[] =
+{
+	"Keywords",
+	"ReservedKeywords",
+	"Operators",
+	"PragmaKeyswords",
+	"EscapeCodes",
+	"DoxygeneKeywords",
+	0
+};
+
+LexerModule lmModula( SCLEX_MODULA, ColouriseModulaDoc, "modula", FoldModulaDoc,
+					  modulaWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexMySQL.cxx b/Pythonwin/Scintilla/lexers/LexMySQL.cxx
new file mode 100644
index 000000000..7ba52a3e2
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexMySQL.cxx
@@ -0,0 +1,574 @@
+/**
+ * Scintilla source code edit control
+ * @file LexMySQL.cxx
+ * Lexer for MySQL
+ *
+ * Improved by Mike Lischke <mike.lischke@oracle.com>
+ * Adopted from LexSQL.cxx by Anders Karlsson <anders@mysql.com>
+ * Original work by Neil Hodgson <neilh@scintilla.org>
+ * Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
+ * The License.txt file describes the conditions under which this software may be distributed.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static inline bool IsAWordChar(int ch) {
+	return (ch < 0x80) && (isalnum(ch) || ch == '_');
+}
+
+static inline bool IsAWordStart(int ch) {
+	return (ch < 0x80) && (isalpha(ch) || ch == '_');
+}
+
+static inline bool IsANumberChar(int ch) {
+	// Not exactly following number definition (several dots are seen as OK, etc.)
+	// but probably enough in most cases.
+	return (ch < 0x80) &&
+	        (isdigit(ch) || toupper(ch) == 'E' ||
+             ch == '.' || ch == '-' || ch == '+');
+}
+
+//--------------------------------------------------------------------------------------------------
+
+/**
+ * Check if the current content context represent a keyword and set the context state if so.
+ */
+static void CheckForKeyword(StyleContext& sc, WordList* keywordlists[], int activeState)
+{
+  Sci_Position length = sc.LengthCurrent() + 1; // +1 for the next char
+  char* s = new char[length];
+  sc.GetCurrentLowered(s, length);
+  if (keywordlists[0]->InList(s))
+    sc.ChangeState(SCE_MYSQL_MAJORKEYWORD | activeState);
+  else
+    if (keywordlists[1]->InList(s))
+      sc.ChangeState(SCE_MYSQL_KEYWORD | activeState);
+    else
+      if (keywordlists[2]->InList(s))
+        sc.ChangeState(SCE_MYSQL_DATABASEOBJECT | activeState);
+      else
+        if (keywordlists[3]->InList(s))
+          sc.ChangeState(SCE_MYSQL_FUNCTION | activeState);
+        else
+          if (keywordlists[5]->InList(s))
+            sc.ChangeState(SCE_MYSQL_PROCEDUREKEYWORD | activeState);
+          else
+            if (keywordlists[6]->InList(s))
+              sc.ChangeState(SCE_MYSQL_USER1 | activeState);
+            else
+              if (keywordlists[7]->InList(s))
+                sc.ChangeState(SCE_MYSQL_USER2 | activeState);
+              else
+                if (keywordlists[8]->InList(s))
+                  sc.ChangeState(SCE_MYSQL_USER3 | activeState);
+  delete [] s;
+}
+
+//--------------------------------------------------------------------------------------------------
+
+#define HIDDENCOMMAND_STATE 0x40 // Offset for states within a hidden command.
+#define MASKACTIVE(style) (style & ~HIDDENCOMMAND_STATE)
+
+static void SetDefaultState(StyleContext& sc, int activeState)
+{
+  if (activeState == 0)
+    sc.SetState(SCE_MYSQL_DEFAULT);
+  else
+    sc.SetState(SCE_MYSQL_HIDDENCOMMAND);
+}
+
+static void ForwardDefaultState(StyleContext& sc, int activeState)
+{
+  if (activeState == 0)
+    sc.ForwardSetState(SCE_MYSQL_DEFAULT);
+  else
+    sc.ForwardSetState(SCE_MYSQL_HIDDENCOMMAND);
+}
+
+static void ColouriseMySQLDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+                            Accessor &styler)
+{
+	StyleContext sc(startPos, length, initStyle, styler, 127);
+  int activeState = (initStyle == SCE_MYSQL_HIDDENCOMMAND) ? HIDDENCOMMAND_STATE : initStyle & HIDDENCOMMAND_STATE;
+
+	for (; sc.More(); sc.Forward())
+  {
+		// Determine if the current state should terminate.
+		switch (MASKACTIVE(sc.state))
+    {
+      case SCE_MYSQL_OPERATOR:
+        SetDefaultState(sc, activeState);
+        break;
+      case SCE_MYSQL_NUMBER:
+        // We stop the number definition on non-numerical non-dot non-eE non-sign char.
+        if (!IsANumberChar(sc.ch))
+          SetDefaultState(sc, activeState);
+        break;
+      case SCE_MYSQL_IDENTIFIER:
+        // Switch from identifier to keyword state and open a new state for the new char.
+        if (!IsAWordChar(sc.ch))
+        {
+          CheckForKeyword(sc, keywordlists, activeState);
+
+          // Additional check for function keywords needed.
+          // A function name must be followed by an opening parenthesis.
+          if (MASKACTIVE(sc.state) == SCE_MYSQL_FUNCTION && sc.ch != '(')
+          {
+            if (activeState > 0)
+              sc.ChangeState(SCE_MYSQL_HIDDENCOMMAND);
+            else
+              sc.ChangeState(SCE_MYSQL_DEFAULT);
+          }
+
+          SetDefaultState(sc, activeState);
+        }
+        break;
+      case SCE_MYSQL_VARIABLE:
+        if (!IsAWordChar(sc.ch))
+          SetDefaultState(sc, activeState);
+        break;
+      case SCE_MYSQL_SYSTEMVARIABLE:
+        if (!IsAWordChar(sc.ch))
+        {
+          Sci_Position length = sc.LengthCurrent() + 1;
+          char* s = new char[length];
+          sc.GetCurrentLowered(s, length);
+
+          // Check for known system variables here.
+          if (keywordlists[4]->InList(&s[2]))
+            sc.ChangeState(SCE_MYSQL_KNOWNSYSTEMVARIABLE | activeState);
+          delete [] s;
+
+          SetDefaultState(sc, activeState);
+        }
+        break;
+      case SCE_MYSQL_QUOTEDIDENTIFIER:
+        if (sc.ch == '`')
+        {
+          if (sc.chNext == '`')
+            sc.Forward();	// Ignore it
+          else
+            ForwardDefaultState(sc, activeState);
+				}
+  			break;
+      case SCE_MYSQL_COMMENT:
+        if (sc.Match('*', '/'))
+        {
+          sc.Forward();
+          ForwardDefaultState(sc, activeState);
+        }
+        break;
+      case SCE_MYSQL_COMMENTLINE:
+        if (sc.atLineStart)
+          SetDefaultState(sc, activeState);
+        break;
+      case SCE_MYSQL_SQSTRING:
+        if (sc.ch == '\\')
+          sc.Forward(); // Escape sequence
+        else
+          if (sc.ch == '\'')
+          {
+            // End of single quoted string reached?
+            if (sc.chNext == '\'')
+              sc.Forward();
+            else
+              ForwardDefaultState(sc, activeState);
+          }
+        break;
+      case SCE_MYSQL_DQSTRING:
+        if (sc.ch == '\\')
+          sc.Forward(); // Escape sequence
+        else
+          if (sc.ch == '\"')
+          {
+            // End of single quoted string reached?
+            if (sc.chNext == '\"')
+              sc.Forward();
+            else
+              ForwardDefaultState(sc, activeState);
+          }
+        break;
+      case SCE_MYSQL_PLACEHOLDER:
+        if (sc.Match('}', '>'))
+        {
+          sc.Forward();
+          ForwardDefaultState(sc, activeState);
+        }
+        break;
+    }
+
+    if (sc.state == SCE_MYSQL_HIDDENCOMMAND && sc.Match('*', '/'))
+    {
+      activeState = 0;
+      sc.Forward();
+      ForwardDefaultState(sc, activeState);
+    }
+
+    // Determine if a new state should be entered.
+    if (sc.state == SCE_MYSQL_DEFAULT || sc.state == SCE_MYSQL_HIDDENCOMMAND)
+    {
+      switch (sc.ch)
+      {
+        case '@':
+          if (sc.chNext == '@')
+          {
+            sc.SetState(SCE_MYSQL_SYSTEMVARIABLE | activeState);
+            sc.Forward(2); // Skip past @@.
+          }
+          else
+            if (IsAWordStart(sc.ch))
+            {
+              sc.SetState(SCE_MYSQL_VARIABLE | activeState);
+              sc.Forward(); // Skip past @.
+            }
+            else
+              sc.SetState(SCE_MYSQL_OPERATOR | activeState);
+          break;
+        case '`':
+          sc.SetState(SCE_MYSQL_QUOTEDIDENTIFIER | activeState);
+          break;
+        case '#':
+          sc.SetState(SCE_MYSQL_COMMENTLINE | activeState);
+          break;
+        case '\'':
+          sc.SetState(SCE_MYSQL_SQSTRING | activeState);
+          break;
+        case '\"':
+          sc.SetState(SCE_MYSQL_DQSTRING | activeState);
+          break;
+        default:
+          if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext)))
+            sc.SetState(SCE_MYSQL_NUMBER | activeState);
+          else
+            if (IsAWordStart(sc.ch))
+              sc.SetState(SCE_MYSQL_IDENTIFIER | activeState);
+            else
+              if (sc.Match('/', '*'))
+              {
+                sc.SetState(SCE_MYSQL_COMMENT | activeState);
+
+                // Skip first char of comment introducer and check for hidden command.
+                // The second char is skipped by the outer loop.
+                sc.Forward();
+                if (sc.GetRelativeCharacter(1) == '!')
+                {
+                  // Version comment found. Skip * now.
+                  sc.Forward();
+                  activeState = HIDDENCOMMAND_STATE;
+                  sc.ChangeState(SCE_MYSQL_HIDDENCOMMAND);
+                }
+              }
+              else if (sc.Match('<', '{'))
+              {
+                sc.SetState(SCE_MYSQL_PLACEHOLDER | activeState);
+              }
+              else
+                if (sc.Match("--"))
+                {
+                  // Special MySQL single line comment.
+                  sc.SetState(SCE_MYSQL_COMMENTLINE | activeState);
+                  sc.Forward(2);
+
+                  // Check the third character too. It must be a space or EOL.
+                  if (sc.ch != ' ' && sc.ch != '\n' && sc.ch != '\r')
+                    sc.ChangeState(SCE_MYSQL_OPERATOR | activeState);
+                }
+                else
+                  if (isoperator(static_cast<char>(sc.ch)))
+                    sc.SetState(SCE_MYSQL_OPERATOR | activeState);
+      }
+    }
+  }
+
+  // Do a final check for keywords if we currently have an identifier, to highlight them
+  // also at the end of a line.
+  if (sc.state == SCE_MYSQL_IDENTIFIER)
+  {
+    CheckForKeyword(sc, keywordlists, activeState);
+
+    // Additional check for function keywords needed.
+    // A function name must be followed by an opening parenthesis.
+    if (sc.state == SCE_MYSQL_FUNCTION && sc.ch != '(')
+      SetDefaultState(sc, activeState);
+  }
+
+  sc.Complete();
+}
+
+//--------------------------------------------------------------------------------------------------
+
+/**
+ * Helper function to determine if we have a foldable comment currently.
+ */
+static bool IsStreamCommentStyle(int style)
+{
+	return MASKACTIVE(style) == SCE_MYSQL_COMMENT;
+}
+
+//--------------------------------------------------------------------------------------------------
+
+/**
+ * Code copied from StyleContext and modified to work here. Should go into Accessor as a
+ * companion to Match()...
+ */
+static bool MatchIgnoreCase(Accessor &styler, Sci_Position currentPos, const char *s)
+{
+  for (Sci_Position n = 0; *s; n++)
+  {
+    if (*s != tolower(styler.SafeGetCharAt(currentPos + n)))
+      return false;
+    s++;
+  }
+  return true;
+}
+
+//--------------------------------------------------------------------------------------------------
+
+// Store both the current line's fold level and the next lines in the
+// level store to make it easy to pick up with each increment.
+static void FoldMySQLDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[], Accessor &styler)
+{
+	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+	bool foldOnlyBegin = styler.GetPropertyInt("fold.sql.only.begin", 0) != 0;
+
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelCurrent = SC_FOLDLEVELBASE;
+	if (lineCurrent > 0)
+		levelCurrent = styler.LevelAt(lineCurrent - 1) >> 16;
+	int levelNext = levelCurrent;
+
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+  int activeState = (style == SCE_MYSQL_HIDDENCOMMAND) ? HIDDENCOMMAND_STATE : style & HIDDENCOMMAND_STATE;
+
+  bool endPending = false;
+	bool whenPending = false;
+	bool elseIfPending = false;
+
+  char nextChar = styler.SafeGetCharAt(startPos);
+  for (Sci_PositionU i = startPos; length > 0; i++, length--)
+  {
+		int stylePrev = style;
+    int lastActiveState = activeState;
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+    activeState = (style == SCE_MYSQL_HIDDENCOMMAND) ? HIDDENCOMMAND_STATE : style & HIDDENCOMMAND_STATE;
+
+    char currentChar = nextChar;
+    nextChar = styler.SafeGetCharAt(i + 1);
+		bool atEOL = (currentChar == '\r' && nextChar != '\n') || (currentChar == '\n');
+
+    switch (MASKACTIVE(style))
+    {
+      case SCE_MYSQL_COMMENT:
+        if (foldComment)
+        {
+          // Multiline comment style /* .. */ just started or is still in progress.
+          if (IsStreamCommentStyle(style) && !IsStreamCommentStyle(stylePrev))
+            levelNext++;
+        }
+        break;
+      case SCE_MYSQL_COMMENTLINE:
+        if (foldComment)
+        {
+          // Not really a standard, but we add support for single line comments
+          // with special curly braces syntax as foldable comments too.
+          // MySQL needs -- comments to be followed by space or control char
+          if (styler.Match(i, "--"))
+          {
+            char chNext2 = styler.SafeGetCharAt(i + 2);
+            char chNext3 = styler.SafeGetCharAt(i + 3);
+            if (chNext2 == '{' || chNext3 == '{')
+              levelNext++;
+            else
+              if (chNext2 == '}' || chNext3 == '}')
+                levelNext--;
+          }
+        }
+        break;
+      case SCE_MYSQL_HIDDENCOMMAND:
+        /*
+        if (endPending)
+        {
+          // A conditional command is not a white space so it should end the current block
+          // before opening a new one.
+          endPending = false;
+          levelNext--;
+          if (levelNext < SC_FOLDLEVELBASE)
+            levelNext = SC_FOLDLEVELBASE;
+        }
+        }*/
+        if (activeState != lastActiveState)
+          levelNext++;
+        break;
+      case SCE_MYSQL_OPERATOR:
+        if (endPending)
+        {
+          endPending = false;
+          levelNext--;
+          if (levelNext < SC_FOLDLEVELBASE)
+            levelNext = SC_FOLDLEVELBASE;
+        }
+        if (currentChar == '(')
+          levelNext++;
+        else
+          if (currentChar == ')')
+          {
+            levelNext--;
+            if (levelNext < SC_FOLDLEVELBASE)
+              levelNext = SC_FOLDLEVELBASE;
+          }
+        break;
+      case SCE_MYSQL_MAJORKEYWORD:
+      case SCE_MYSQL_KEYWORD:
+      case SCE_MYSQL_FUNCTION:
+      case SCE_MYSQL_PROCEDUREKEYWORD:
+        // Reserved and other keywords.
+        if (style != stylePrev)
+        {
+          // END decreases the folding level, regardless which keyword follows.
+          bool endFound = MatchIgnoreCase(styler, i, "end");
+          if (endPending)
+          {
+            levelNext--;
+            if (levelNext < SC_FOLDLEVELBASE)
+              levelNext = SC_FOLDLEVELBASE;
+          }
+          else
+            if (!endFound)
+            {
+              if (MatchIgnoreCase(styler, i, "begin"))
+                levelNext++;
+              else
+              {
+                if (!foldOnlyBegin)
+                {
+                  bool whileFound = MatchIgnoreCase(styler, i, "while");
+                  bool loopFound = MatchIgnoreCase(styler, i, "loop");
+                  bool repeatFound = MatchIgnoreCase(styler, i, "repeat");
+                  bool caseFound = MatchIgnoreCase(styler, i, "case");
+
+                  if (whileFound || loopFound || repeatFound || caseFound)
+                    levelNext++;
+                  else
+                  {
+                    // IF alone does not increase the fold level as it is also used in non-block'ed
+                    // code like DROP PROCEDURE blah IF EXISTS.
+                    // Instead THEN opens the new level (if not part of an ELSEIF or WHEN (case) branch).
+                    if (MatchIgnoreCase(styler, i, "then"))
+                    {
+                      if (!elseIfPending && !whenPending)
+                        levelNext++;
+                      else
+                      {
+                        elseIfPending = false;
+                        whenPending = false;
+                      }
+                    }
+                    else
+                    {
+                      // Neither of if/then/while/loop/repeat/case, so check for
+                      // sub parts of IF and CASE.
+                      if (MatchIgnoreCase(styler, i, "elseif"))
+                        elseIfPending = true;
+                      if (MatchIgnoreCase(styler, i, "when"))
+                        whenPending = true;
+                    }
+                  }
+                }
+              }
+            }
+
+          // Keep the current end state for the next round.
+          endPending = endFound;
+        }
+        break;
+
+      default:
+        if (!isspacechar(currentChar) && endPending)
+        {
+          // END followed by a non-whitespace character (not covered by other cases like identifiers)
+          // also should end a folding block. Typical case: END followed by self defined delimiter.
+          levelNext--;
+          if (levelNext < SC_FOLDLEVELBASE)
+            levelNext = SC_FOLDLEVELBASE;
+        }
+        break;
+    }
+
+    // Go up one level if we just ended a multi line comment.
+    if (IsStreamCommentStyle(stylePrev) && !IsStreamCommentStyle(style))
+    {
+      levelNext--;
+      if (levelNext < SC_FOLDLEVELBASE)
+        levelNext = SC_FOLDLEVELBASE;
+    }
+
+    if (activeState == 0 && lastActiveState != 0)
+    {
+      // Decrease fold level when we left a hidden command.
+      levelNext--;
+      if (levelNext < SC_FOLDLEVELBASE)
+        levelNext = SC_FOLDLEVELBASE;
+    }
+
+    if (atEOL)
+    {
+      // Apply the new folding level to this line.
+      // Leave pending states as they are otherwise a line break will de-sync
+      // code folding and valid syntax.
+      int levelUse = levelCurrent;
+      int lev = levelUse | levelNext << 16;
+      if (visibleChars == 0 && foldCompact)
+        lev |= SC_FOLDLEVELWHITEFLAG;
+      if (levelUse < levelNext)
+        lev |= SC_FOLDLEVELHEADERFLAG;
+      if (lev != styler.LevelAt(lineCurrent))
+        styler.SetLevel(lineCurrent, lev);
+
+      lineCurrent++;
+      levelCurrent = levelNext;
+      visibleChars = 0;
+    }
+
+		if (!isspacechar(currentChar))
+      visibleChars++;
+  }
+}
+
+//--------------------------------------------------------------------------------------------------
+
+static const char * const mysqlWordListDesc[] = {
+	"Major Keywords",
+	"Keywords",
+	"Database Objects",
+	"Functions",
+	"System Variables",
+	"Procedure keywords",
+	"User Keywords 1",
+	"User Keywords 2",
+	"User Keywords 3",
+	0
+};
+
+LexerModule lmMySQL(SCLEX_MYSQL, ColouriseMySQLDoc, "mysql", FoldMySQLDoc, mysqlWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexNim.cxx b/Pythonwin/Scintilla/lexers/LexNim.cxx
new file mode 100644
index 000000000..d1b462abe
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexNim.cxx
@@ -0,0 +1,811 @@
+// Scintilla source code edit control
+/** @file LexNim.cxx
+** Lexer for Nim
+** Written by Jad Altahan (github.com/xv)
+** Nim manual: https://nim-lang.org/docs/manual.html
+**/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+#include <map>
+#include <algorithm>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "StringCopy.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+namespace {
+    // Use an unnamed namespace to protect the functions and classes from name conflicts
+
+enum NumType {
+    Binary,
+    Octal,
+    Exponent,
+    Hexadecimal,
+    Decimal,
+    FormatError
+};
+
+int GetNumStyle(const int numType) noexcept {
+    if (numType == NumType::FormatError) {
+        return SCE_NIM_NUMERROR;
+    }
+
+    return SCE_NIM_NUMBER;
+}
+
+constexpr bool IsLetter(const int ch) noexcept {
+    // 97 to 122 || 65 to 90
+    return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
+}
+
+bool IsAWordChar(const int ch) noexcept {
+    return ch < 0x80 && (isalnum(ch) || ch == '_' || ch == '.');
+}
+
+int IsNumHex(const StyleContext &sc) noexcept {
+    return sc.chNext == 'x' || sc.chNext == 'X';
+}
+
+int IsNumBinary(const StyleContext &sc) noexcept {
+    return sc.chNext == 'b' || sc.chNext == 'B';
+}
+
+int IsNumOctal(const StyleContext &sc) {
+    return IsADigit(sc.chNext) || sc.chNext == 'o';
+}
+
+constexpr bool IsNewline(const int ch) noexcept {
+    return (ch == '\n' || ch == '\r');
+}
+
+bool IsFuncName(const char *str) noexcept {
+    const char *identifiers[] = {
+        "proc",
+        "func",
+        "macro",
+        "method",
+        "template",
+        "iterator",
+        "converter"
+    };
+
+    for (const char *id : identifiers) {
+        if (strcmp(str, id) == 0) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+constexpr bool IsTripleLiteral(const int style) noexcept {
+    return style == SCE_NIM_TRIPLE || style == SCE_NIM_TRIPLEDOUBLE;
+}
+
+constexpr bool IsLineComment(const int style) noexcept {
+    return style == SCE_NIM_COMMENTLINE || style == SCE_NIM_COMMENTLINEDOC;
+}
+
+constexpr bool IsStreamComment(const int style) noexcept {
+    return style == SCE_NIM_COMMENT || style == SCE_NIM_COMMENTDOC;
+}
+
+// Adopted from Accessor.cxx
+int GetIndent(const Sci_Position line, Accessor &styler) {
+    Sci_Position startPos = styler.LineStart(line);
+    const Sci_Position eolPos = styler.LineStart(line + 1) - 1;
+
+    char ch = styler[startPos];
+    int style = styler.StyleAt(startPos);
+
+    int indent = 0;
+    bool inPrevPrefix = line > 0;
+    Sci_Position posPrev = inPrevPrefix ? styler.LineStart(line - 1) : 0;
+
+    // No fold points inside triple literals
+    while ((IsASpaceOrTab(ch) || IsTripleLiteral(style)) && (startPos < eolPos)) {
+        if (inPrevPrefix) {
+            const char chPrev = styler[posPrev++];
+            if (chPrev != ' ' && chPrev != '\t') {
+                inPrevPrefix = false;
+            }
+        }
+
+        if (ch == '\t') {
+            indent = (indent / 8 + 1) * 8;
+        } else {
+            indent++;
+        }
+
+        startPos++;
+        ch = styler[startPos];
+        style = styler.StyleAt(startPos);
+    }
+
+    // Prevent creating fold lines for comments if indented
+    if (!(IsStreamComment(style) || IsLineComment(style)))
+        indent += SC_FOLDLEVELBASE;
+
+    if (styler.LineStart(line) == styler.Length() 
+        || IsASpaceOrTab(ch) 
+        || IsNewline(ch) 
+        || IsStreamComment(style)
+        || IsLineComment(style)) {
+        return indent | SC_FOLDLEVELWHITEFLAG;
+    } else {
+        return indent;
+    }
+}
+
+int IndentAmount(const Sci_Position line, Accessor &styler) {
+    const int indent = GetIndent(line, styler);
+    const int indentLevel = indent & SC_FOLDLEVELNUMBERMASK;
+    return indentLevel <= SC_FOLDLEVELBASE ? indent : indentLevel | (indent & ~SC_FOLDLEVELNUMBERMASK);
+}
+
+struct OptionsNim {
+    bool fold;
+    bool foldCompact;
+    bool highlightRawStrIdent;
+
+    OptionsNim() {
+        fold = true;
+        foldCompact = true;
+        highlightRawStrIdent = false;
+    }
+};
+
+static const char *const nimWordListDesc[] = {
+    "Keywords",
+    nullptr
+};
+
+struct OptionSetNim : public OptionSet<OptionsNim> {
+    OptionSetNim() {
+        DefineProperty("lexer.nim.raw.strings.highlight.ident", &OptionsNim::highlightRawStrIdent,
+            "Set to 1 to enable highlighting generalized raw string identifiers. "
+            "Generalized raw string identifiers are anything other than r (or R).");
+
+        DefineProperty("fold", &OptionsNim::fold);
+        DefineProperty("fold.compact", &OptionsNim::foldCompact);
+
+        DefineWordListSets(nimWordListDesc);
+    }
+};
+
+LexicalClass lexicalClasses[] = {
+    // Lexer Nim SCLEX_NIM SCE_NIM_:
+    0,  "SCE_NIM_DEFAULT",        "default",              "White space",
+    1,  "SCE_NIM_COMMENT",        "comment block",        "Block comment",
+    2,  "SCE_NIM_COMMENTDOC",     "comment block doc",    "Block doc comment",
+    3,  "SCE_NIM_COMMENTLINE",    "comment line",         "Line comment",
+    4,  "SCE_NIM_COMMENTLINEDOC", "comment doc",          "Line doc comment",
+    5,  "SCE_NIM_NUMBER",         "literal numeric",      "Number",
+    6,  "SCE_NIM_STRING",         "literal string",       "String",
+    7,  "SCE_NIM_CHARACTER",      "literal string",       "Single quoted string",
+    8,  "SCE_NIM_WORD",           "keyword",              "Keyword",
+    9,  "SCE_NIM_TRIPLE",         "literal string",       "Triple quotes",
+    10, "SCE_NIM_TRIPLEDOUBLE",   "literal string",       "Triple double quotes",
+    11, "SCE_NIM_BACKTICKS",      "operator definition",  "Identifiers",
+    12, "SCE_NIM_FUNCNAME",       "identifier",           "Function name definition",
+    13, "SCE_NIM_STRINGEOL",      "error literal string", "String is not closed",
+    14, "SCE_NIM_NUMERROR",       "numeric error",        "Numeric format error",
+    15, "SCE_NIM_OPERATOR",       "operator",             "Operators",
+    16, "SCE_NIM_IDENTIFIER",     "identifier",           "Identifiers",
+};
+
+}
+
+class LexerNim : public DefaultLexer {
+    CharacterSet setWord;
+    WordList keywords;
+    OptionsNim options;
+    OptionSetNim osNim;
+
+public:
+    LexerNim() :
+        DefaultLexer("nim", SCLEX_NIM, lexicalClasses, ELEMENTS(lexicalClasses)),
+        setWord(CharacterSet::setAlphaNum, "_", 0x80, true) { }
+
+    virtual ~LexerNim() { }
+
+    void SCI_METHOD Release() noexcept override {
+        delete this;
+    }
+
+    int SCI_METHOD Version() const noexcept override {
+        return lvRelease5;
+    }
+
+    const char * SCI_METHOD PropertyNames() override {
+        return osNim.PropertyNames();
+    }
+
+    int SCI_METHOD PropertyType(const char *name) override {
+        return osNim.PropertyType(name);
+    }
+
+    const char * SCI_METHOD DescribeProperty(const char *name) override {
+        return osNim.DescribeProperty(name);
+    }
+
+    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();
+    }
+
+    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 *) noexcept override {
+        return nullptr;
+    }
+
+    int SCI_METHOD LineEndTypesSupported() noexcept override {
+        return SC_LINE_END_TYPE_UNICODE;
+    }
+
+    int SCI_METHOD PrimaryStyleFromStyle(int style) noexcept override {
+        return style;
+    }
+
+    static ILexer5 *LexerFactoryNim() {
+        return new LexerNim();
+    }
+};
+
+Sci_Position SCI_METHOD LexerNim::PropertySet(const char *key, const char *val) {
+    if (osNim.PropertySet(&options, key, val)) {
+        return 0;
+    }
+
+    return -1;
+}
+
+Sci_Position SCI_METHOD LexerNim::WordListSet(int n, const char *wl) {
+    WordList *wordListN = nullptr;
+
+    switch (n) {
+        case 0:
+            wordListN = &keywords;
+            break;
+    }
+
+    Sci_Position firstModification = -1;
+
+    if (wordListN) {
+        WordList wlNew;
+        wlNew.Set(wl);
+
+        if (*wordListN != wlNew) {
+            wordListN->Set(wl);
+            firstModification = 0;
+        }
+    }
+
+    return firstModification;
+}
+
+void SCI_METHOD LexerNim::Lex(Sci_PositionU startPos, Sci_Position length,
+                              int initStyle, IDocument *pAccess) {
+    // No one likes a leaky string
+    if (initStyle == SCE_NIM_STRINGEOL) {
+        initStyle = SCE_NIM_DEFAULT;
+    }
+
+    Accessor styler(pAccess, nullptr);
+    StyleContext sc(startPos, length, initStyle, styler);
+
+    // Nim supports nested block comments!
+    Sci_Position lineCurrent = styler.GetLine(startPos);
+    int commentNestLevel = lineCurrent > 0 ? styler.GetLineState(lineCurrent - 1) : 0;
+
+    int numType = NumType::Decimal;
+    int decimalCount = 0;
+
+    bool funcNameExists = false;
+    bool isStylingRawString = false;
+    bool isStylingRawStringIdent = false;
+
+    for (; sc.More(); sc.Forward()) {
+        if (sc.atLineStart) {
+            if (sc.state == SCE_NIM_STRING) {
+                sc.SetState(SCE_NIM_STRING);
+            }
+
+            lineCurrent = styler.GetLine(sc.currentPos);
+            styler.SetLineState(lineCurrent, commentNestLevel);
+        }
+
+        // Handle string line continuation
+        if (sc.ch == '\\' && (sc.chNext == '\n' || sc.chNext == '\r') &&
+           (sc.state == SCE_NIM_STRING || sc.state == SCE_NIM_CHARACTER) && !isStylingRawString) {
+            sc.Forward();
+
+            if (sc.ch == '\r' && sc.chNext == '\n') {
+                sc.Forward();
+            }
+
+            continue;
+        }
+
+        switch (sc.state) {
+            case SCE_NIM_OPERATOR:
+                funcNameExists = false;
+                sc.SetState(SCE_NIM_DEFAULT);
+                break;
+            case SCE_NIM_NUMBER:
+                // For a type suffix, such as 0x80'u8
+                if (sc.ch == '\'') {
+                    if (sc.chNext == 'i' || sc.chNext == 'I' || 
+                        sc.chNext == 'u' || sc.chNext == 'U' ||
+                        sc.chNext == 'f' || sc.chNext == 'F' || 
+                        sc.chNext == 'd' || sc.chNext == 'D') {
+                        sc.Forward(2);
+                    }
+                } else if (sc.ch == '.') {
+                    if (IsADigit(sc.chNext)) {
+                        sc.Forward();
+                    } else if (numType <= NumType::Exponent) {
+                        sc.SetState(SCE_NIM_OPERATOR);
+                        break;
+                    } else {
+                        decimalCount++;
+
+                        if (numType == NumType::Decimal) {
+                            if (decimalCount <= 1 && !IsAWordChar(sc.chNext)) {
+                                break;
+                            }
+                        } else if (numType == NumType::Hexadecimal) {
+                            if (decimalCount <= 1 && IsADigit(sc.chNext, 16)) {
+                                break;
+                            }
+
+                            sc.SetState(SCE_NIM_OPERATOR);
+                            break;
+                        }
+                    }
+                } else if (sc.ch == '_') {
+                    // Accept only one underscore between digits
+                    if (IsADigit(sc.chNext)) {
+                        sc.Forward();
+                    }
+                } else if (numType == NumType::Decimal) {
+                    if (sc.chPrev != '\'' && (sc.ch == 'e' || sc.ch == 'E')) {
+                        numType = NumType::Exponent;
+
+                        if (sc.chNext == '-' || sc.chNext == '+') {
+                            sc.Forward();
+                        }
+
+                        break;
+                    }
+
+                    if (IsADigit(sc.ch)) {
+                        break;
+                    }
+                } else if (numType == NumType::Hexadecimal) {
+                    if (IsADigit(sc.ch, 16)) {
+                        break;
+                    }
+                } else if (IsADigit(sc.ch)) {
+                    if (numType == NumType::Exponent) {
+                        break;
+                    }
+
+                    if (numType == NumType::Octal) {
+                        // Accept only 0-7
+                        if (sc.ch <= '7') {
+                            break;
+                        }
+                    } else if (numType == NumType::Binary) {
+                        // Accept only 0 and 1
+                        if (sc.ch <= '1') {
+                            break;
+                        }
+                    }
+
+                    numType = NumType::FormatError;
+                    break;
+                }
+
+                sc.ChangeState(GetNumStyle(numType));
+                sc.SetState(SCE_NIM_DEFAULT);
+                break;
+            case SCE_NIM_IDENTIFIER:
+                if (sc.ch == '.' || !IsAWordChar(sc.ch)) {
+                    char s[100];
+                    sc.GetCurrent(s, sizeof(s));
+                    int style = SCE_NIM_IDENTIFIER;
+
+                    if (keywords.InList(s) && !funcNameExists) {
+                        // Prevent styling keywords if they are sub-identifiers
+                        const Sci_Position segStart = styler.GetStartSegment() - 1;
+                        if (segStart < 0 || styler.SafeGetCharAt(segStart, '\0') != '.') {
+                            style = SCE_NIM_WORD;
+                        }
+                    } else if (funcNameExists) {
+                        style = SCE_NIM_FUNCNAME;
+                    }
+
+                    sc.ChangeState(style);
+                    sc.SetState(SCE_NIM_DEFAULT);
+
+                    if (style == SCE_NIM_WORD) {
+                        funcNameExists = IsFuncName(s);
+                    } else {
+                        funcNameExists = false;
+                    }
+                }
+
+                if (IsAlphaNumeric(sc.ch) && sc.chNext == '\"') {
+                    isStylingRawStringIdent = true;
+
+                    if (options.highlightRawStrIdent) {
+                        if (styler.SafeGetCharAt(sc.currentPos + 2) == '\"' &&
+                            styler.SafeGetCharAt(sc.currentPos + 3) == '\"') {
+                            sc.ChangeState(SCE_NIM_TRIPLEDOUBLE);
+                        } else {
+                            sc.ChangeState(SCE_NIM_STRING);
+                        }
+                    }
+
+                    sc.ForwardSetState(SCE_NIM_DEFAULT);
+                }
+                break;
+            case SCE_NIM_FUNCNAME:
+                if (sc.ch == '`') {
+                    funcNameExists = false;
+                    sc.ForwardSetState(SCE_NIM_DEFAULT);
+                } else if (sc.atLineEnd) {
+                    // Prevent leaking the style to the next line if not closed
+                    funcNameExists = false;
+
+                    sc.ChangeState(SCE_NIM_STRINGEOL);
+                    sc.ForwardSetState(SCE_NIM_DEFAULT);
+                }
+                break;
+            case SCE_NIM_COMMENT:
+                if (sc.Match(']', '#')) {
+                    if (commentNestLevel > 0) {
+                        commentNestLevel--;
+                    }
+
+                    lineCurrent = styler.GetLine(sc.currentPos);
+                    styler.SetLineState(lineCurrent, commentNestLevel);
+                    sc.Forward();
+
+                    if (commentNestLevel == 0) {
+                        sc.ForwardSetState(SCE_NIM_DEFAULT);
+                    }
+                } else if (sc.Match('#', '[')) {
+                    commentNestLevel++;
+                    lineCurrent = styler.GetLine(sc.currentPos);
+                    styler.SetLineState(lineCurrent, commentNestLevel);
+                }
+                break;
+            case SCE_NIM_COMMENTDOC:
+                if (sc.Match("]##")) {
+                    if (commentNestLevel > 0) {
+                        commentNestLevel--;
+                    }
+
+                    lineCurrent = styler.GetLine(sc.currentPos);
+                    styler.SetLineState(lineCurrent, commentNestLevel);
+                    sc.Forward(2);
+
+                    if (commentNestLevel == 0) {
+                        sc.ForwardSetState(SCE_NIM_DEFAULT);
+                    }
+                } else if (sc.Match("##[")) {
+                    commentNestLevel++;
+                    lineCurrent = styler.GetLine(sc.currentPos);
+                    styler.SetLineState(lineCurrent, commentNestLevel);
+                }
+                break;
+            case SCE_NIM_COMMENTLINE:
+            case SCE_NIM_COMMENTLINEDOC:
+                if (sc.atLineStart) {
+                    sc.SetState(SCE_NIM_DEFAULT);
+                }
+                break;
+            case SCE_NIM_STRING:
+                if (!isStylingRawStringIdent && !isStylingRawString && sc.ch == '\\') {
+                    if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+                        sc.Forward();
+                    }
+                } else if (isStylingRawString && sc.ch == '\"' && sc.chNext == '\"') {
+                    // Forward in situations such as r"a""bc\" so that "bc\" wouldn't be
+                    // considered a string of its own
+                    sc.Forward();
+                } else if (sc.ch == '\"') {
+                    sc.ForwardSetState(SCE_NIM_DEFAULT);
+                } else if (sc.atLineEnd) {
+                    sc.ChangeState(SCE_NIM_STRINGEOL);
+                    sc.ForwardSetState(SCE_NIM_DEFAULT);
+                }
+                break;
+            case SCE_NIM_CHARACTER:
+                if (sc.ch == '\\') {
+                    if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+                        sc.Forward();
+                    }
+                } else if (sc.ch == '\'') {
+                    sc.ForwardSetState(SCE_NIM_DEFAULT);
+                } else if (sc.atLineEnd) {
+                    sc.ChangeState(SCE_NIM_STRINGEOL);
+                    sc.ForwardSetState(SCE_NIM_DEFAULT);
+                }
+                break;
+            case SCE_NIM_BACKTICKS:
+                if (sc.ch == '`' ) {
+                    sc.ForwardSetState(SCE_NIM_DEFAULT);
+                } else if (sc.atLineEnd) {
+                    sc.ChangeState(SCE_NIM_STRINGEOL);
+                    sc.ForwardSetState(SCE_NIM_DEFAULT);
+                }
+                break;
+            case SCE_NIM_TRIPLEDOUBLE:
+                if (sc.Match(R"(""")")) {
+
+                    // Outright forward all " after the closing """ as a triple double
+                    //
+                    // A valid example where this is needed is: """8 double quotes->""""""""
+                    // You can have as many """ at the end as you wish, as long as the actual
+                    // closing literal is there
+                    while (sc.ch == '"') {
+                        sc.Forward();
+                    }
+
+                    sc.SetState(SCE_NIM_DEFAULT);
+                }
+                break;
+            case SCE_NIM_TRIPLE:
+                if (sc.Match("'''")) {
+                    sc.Forward(2);
+                    sc.ForwardSetState(SCE_NIM_DEFAULT);
+                }
+                break;
+        }
+
+        if (sc.state == SCE_NIM_DEFAULT) {
+            // Number
+            if (IsADigit(sc.ch)) {
+                sc.SetState(SCE_NIM_NUMBER);
+
+                numType = NumType::Decimal;
+                decimalCount = 0;
+
+                if (sc.ch == '0') {
+                    if (IsNumHex(sc)) {
+                        numType = NumType::Hexadecimal;
+                    } else if (IsNumBinary(sc)) {
+                        numType = NumType::Binary;
+                    } else if (IsNumOctal(sc)) {
+                        numType = NumType::Octal;
+                    }
+
+                    if (numType != NumType::Decimal) {
+                        sc.Forward();
+                    }
+                }
+            }
+            // Raw string
+            else if (IsAlphaNumeric(sc.ch) && sc.chNext == '\"') {
+                isStylingRawString = true;
+
+                // Triple doubles can be raw strings too. How sweet
+                if (styler.SafeGetCharAt(sc.currentPos + 2) == '\"' &&
+                    styler.SafeGetCharAt(sc.currentPos + 3) == '\"') {
+                    sc.SetState(SCE_NIM_TRIPLEDOUBLE);
+                } else {
+                    sc.SetState(SCE_NIM_STRING);
+                }
+
+                const int rawStrStyle = options.highlightRawStrIdent ? IsLetter(sc.ch) :
+                                        (sc.ch == 'r' || sc.ch == 'R');
+
+                if (rawStrStyle) {
+                    sc.Forward();
+
+                    if (sc.state == SCE_NIM_TRIPLEDOUBLE) {
+                        sc.Forward(2);
+                    }
+                } else {
+                    // Anything other than r/R is considered a general raw string identifier
+                    isStylingRawStringIdent = true;
+                    sc.SetState(SCE_NIM_IDENTIFIER);
+                }
+            }
+            // String and triple double literal
+            else if (sc.ch == '\"') {
+                isStylingRawString = false;
+
+                if (sc.Match(R"(""")")) {
+                    sc.SetState(SCE_NIM_TRIPLEDOUBLE);
+                    
+                    // Keep forwarding until the total opening literal count is 5
+                    // A valid example where this is needed is: """""<-5 double quotes"""
+                    while (sc.ch == '"') {
+                        sc.Forward();
+
+                        if (sc.Match(R"(""")")) {
+                            sc.Forward();
+                            break;
+                        }
+                    }
+                } else {
+                    sc.SetState(SCE_NIM_STRING);
+                }
+            }
+            // Charecter and triple literal
+            else if (sc.ch == '\'') {
+                if (sc.Match("'''")) {
+                    sc.SetState(SCE_NIM_TRIPLE);
+                } else {
+                    sc.SetState(SCE_NIM_CHARACTER);
+                }
+            }
+            // Operator definition
+            else if (sc.ch == '`') {
+                if (funcNameExists) {
+                    sc.SetState(SCE_NIM_FUNCNAME);
+                } else {
+                    sc.SetState(SCE_NIM_BACKTICKS);
+                }
+            }
+            // Keyword
+            else if (iswordstart(sc.ch)) {
+                sc.SetState(SCE_NIM_IDENTIFIER);
+            }
+            // Comments
+            else if (sc.ch == '#') {
+                if (sc.Match("##[") || sc.Match("#[")) {
+                    commentNestLevel++;
+                    lineCurrent = styler.GetLine(sc.currentPos);
+                    styler.SetLineState(lineCurrent, commentNestLevel);
+                }
+
+                if (sc.Match("##[")) {
+                    sc.SetState(SCE_NIM_COMMENTDOC);
+                    sc.Forward();
+                } else if (sc.Match("#[")) {
+                    sc.SetState(SCE_NIM_COMMENT);
+                    sc.Forward();
+                } else if (sc.Match("##")) {
+                    sc.SetState(SCE_NIM_COMMENTLINEDOC);
+                } else {
+                    sc.SetState(SCE_NIM_COMMENTLINE);
+                }
+            }
+            // Operators
+            else if (strchr("()[]{}:=;-\\/&%$!+<>|^?,.*~@", sc.ch)) {
+                sc.SetState(SCE_NIM_OPERATOR);
+            }
+        }
+
+        if (sc.atLineEnd) {
+            funcNameExists = false;
+            isStylingRawString = false;
+            isStylingRawStringIdent = false;
+        }
+    }
+
+    sc.Complete();
+}
+
+void SCI_METHOD LexerNim::Fold(Sci_PositionU startPos, Sci_Position length, int, IDocument *pAccess) {
+    if (!options.fold) {
+        return;
+    }
+
+    Accessor styler(pAccess, nullptr);
+
+    const Sci_Position docLines = styler.GetLine(styler.Length());
+    const Sci_Position maxPos = startPos + length;
+    const Sci_Position maxLines = styler.GetLine(maxPos == styler.Length() ? maxPos : maxPos - 1);
+
+    Sci_Position lineCurrent = styler.GetLine(startPos);
+    int indentCurrent = IndentAmount(lineCurrent, styler);
+
+    while (lineCurrent > 0) {
+        lineCurrent--;
+        indentCurrent = IndentAmount(lineCurrent, styler);
+
+        if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) {
+            break;
+        }
+    }
+
+    int indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
+    indentCurrent = indentCurrentLevel | (indentCurrent & ~SC_FOLDLEVELNUMBERMASK);
+
+    while (lineCurrent <= docLines && lineCurrent <= maxLines) {
+        Sci_Position lineNext = lineCurrent + 1;
+        int indentNext = indentCurrent;
+        int lev = indentCurrent;
+
+        if (lineNext <= docLines) {
+            indentNext = IndentAmount(lineNext, styler);
+        }
+
+        if (indentNext & SC_FOLDLEVELWHITEFLAG) {
+            indentNext = SC_FOLDLEVELWHITEFLAG | indentCurrentLevel;
+        }
+
+        while (lineNext < docLines && (indentNext & SC_FOLDLEVELWHITEFLAG)) {
+            lineNext++;
+            indentNext = IndentAmount(lineNext, styler);
+        }
+
+        const int indentNextLevel = indentNext & SC_FOLDLEVELNUMBERMASK;
+        indentNext = indentNextLevel | (indentNext & ~SC_FOLDLEVELNUMBERMASK);
+
+        const int levelBeforeComments = std::max(indentCurrentLevel, indentNextLevel);
+
+        Sci_Position skipLine = lineNext;
+        int skipLevel = indentNextLevel;
+
+        while (--skipLine > lineCurrent) {
+            const int skipLineIndent = IndentAmount(skipLine, styler);
+
+            if (options.foldCompact) {
+                if ((skipLineIndent & SC_FOLDLEVELNUMBERMASK) > indentNextLevel) {
+                    skipLevel = levelBeforeComments;
+                }
+
+                const int whiteFlag = skipLineIndent & SC_FOLDLEVELWHITEFLAG;
+                styler.SetLevel(skipLine, skipLevel | whiteFlag);
+            } else {
+                if ((skipLineIndent & SC_FOLDLEVELNUMBERMASK) > indentNextLevel &&
+                   !(skipLineIndent & SC_FOLDLEVELWHITEFLAG)) {
+                    skipLevel = levelBeforeComments;
+                }
+
+                styler.SetLevel(skipLine, skipLevel);
+            }
+        }
+
+        if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) {
+            if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK)) {
+                lev |= SC_FOLDLEVELHEADERFLAG;
+            }
+        }
+
+        styler.SetLevel(lineCurrent, options.foldCompact ? lev : lev & ~SC_FOLDLEVELWHITEFLAG);
+
+        indentCurrent = indentNext;
+        indentCurrentLevel = indentNextLevel;
+        lineCurrent = lineNext;
+    }
+}
+
+LexerModule lmNim(SCLEX_NIM, LexerNim::LexerFactoryNim, "nim", nimWordListDesc);
\ No newline at end of file
diff --git a/Pythonwin/Scintilla/lexers/LexNimrod.cxx b/Pythonwin/Scintilla/lexers/LexNimrod.cxx
new file mode 100644
index 000000000..5526ff843
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexNimrod.cxx
@@ -0,0 +1,431 @@
+// Scintilla source code edit control
+// Nimrod lexer
+// (c) 2009 Andreas Rumpf
+/** @file LexNimrod.cxx
+ ** Lexer for Nimrod.
+ **/
+// Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static inline bool IsAWordChar(int ch) {
+	return (ch >= 0x80) || isalnum(ch) || ch == '_';
+}
+
+static Sci_Position tillEndOfTripleQuote(Accessor &styler, Sci_Position pos, Sci_Position max) {
+  /* search for """ */
+  for (;;) {
+    if (styler.SafeGetCharAt(pos, '\0') == '\0') return pos;
+    if (pos >= max) return pos;
+    if (styler.Match(pos, "\"\"\"")) {
+      return pos + 2;
+    }
+    pos++;
+  }
+}
+
+#define CR 13 /* use both because Scite allows changing the line ending */
+#define LF 10
+
+static bool inline isNewLine(int ch) {
+  return ch == CR || ch == LF;
+}
+
+static Sci_Position scanString(Accessor &styler, Sci_Position pos, Sci_Position max, bool rawMode) {
+  for (;;) {
+    if (pos >= max) return pos;
+    char ch = styler.SafeGetCharAt(pos, '\0');
+    if (ch == CR || ch == LF || ch == '\0') return pos;
+    if (ch == '"') return pos;
+    if (ch == '\\' && !rawMode) {
+      pos += 2;
+    } else {
+      pos++;
+    }
+  }
+}
+
+static Sci_Position scanChar(Accessor &styler, Sci_Position pos, Sci_Position max) {
+  for (;;) {
+    if (pos >= max) return pos;
+    char ch = styler.SafeGetCharAt(pos, '\0');
+    if (ch == CR || ch == LF || ch == '\0') return pos;
+    if (ch == '\'' && !isalnum(styler.SafeGetCharAt(pos+1, '\0')) )
+      return pos;
+    if (ch == '\\') {
+      pos += 2;
+    } else {
+      pos++;
+    }
+  }
+}
+
+static Sci_Position scanIdent(Accessor &styler, Sci_Position pos, WordList &keywords) {
+  char buf[100]; /* copy to lowercase and ignore underscores */
+  Sci_Position i = 0;
+
+  for (;;) {
+    char ch = styler.SafeGetCharAt(pos, '\0');
+    if (!IsAWordChar(ch)) break;
+    if (ch != '_' && i < ((int)sizeof(buf))-1) {
+      buf[i] = static_cast<char>(tolower(ch));
+      i++;
+    }
+    pos++;
+  }
+  buf[i] = '\0';
+  /* look for keyword */
+  if (keywords.InList(buf)) {
+    styler.ColourTo(pos-1, SCE_P_WORD);
+  } else {
+    styler.ColourTo(pos-1, SCE_P_IDENTIFIER);
+  }
+  return pos;
+}
+
+static Sci_Position scanNumber(Accessor &styler, Sci_Position pos) {
+  char ch, ch2;
+  ch = styler.SafeGetCharAt(pos, '\0');
+  ch2 = styler.SafeGetCharAt(pos+1, '\0');
+  if (ch == '0' && (ch2 == 'b' || ch2 == 'B')) {
+    /* binary number: */
+    pos += 2;
+    for (;;) {
+      ch = styler.SafeGetCharAt(pos, '\0');
+      if (ch == '_' || (ch >= '0' && ch <= '1')) ++pos;
+      else break;
+    }
+  } else if (ch == '0' &&
+            (ch2 == 'o' || ch2 == 'O' || ch2 == 'c' || ch2 == 'C')) {
+    /* octal number: */
+    pos += 2;
+    for (;;) {
+      ch = styler.SafeGetCharAt(pos, '\0');
+      if (ch == '_' || (ch >= '0' && ch <= '7')) ++pos;
+      else break;
+    }
+  } else if (ch == '0' && (ch2 == 'x' || ch2 == 'X')) {
+    /* hexadecimal number: */
+    pos += 2;
+    for (;;) {
+      ch = styler.SafeGetCharAt(pos, '\0');
+      if (ch == '_' || (ch >= '0' && ch <= '9')
+          || (ch >= 'a' && ch <= 'f')
+          || (ch >= 'A' && ch <= 'F')) ++pos;
+      else break;
+    }
+  } else {
+    // skip decimal part:
+    for (;;) {
+      ch = styler.SafeGetCharAt(pos, '\0');
+      if (ch == '_' || (ch >= '0' && ch <= '9')) ++pos;
+      else break;
+    }
+    ch2 = styler.SafeGetCharAt(pos+1, '\0');
+    if (ch == '.' && ch2 >= '0' && ch2 <= '9') {
+      ++pos; // skip '.'
+      for (;;) {
+        ch = styler.SafeGetCharAt(pos, '\0');
+        if (ch == '_' || (ch >= '0' && ch <= '9')) ++pos;
+        else break;
+      }
+    }
+    if (ch == 'e' || ch == 'E') {
+      ++pos;
+      ch = styler.SafeGetCharAt(pos, '\0');
+      if (ch == '-' || ch == '+') ++pos;
+      for (;;) {
+        ch = styler.SafeGetCharAt(pos, '\0');
+        if (ch == '_' || (ch >= '0' && ch <= '9')) ++pos;
+        else break;
+      }
+    }
+  }
+  if (ch == '\'') {
+    /* a type suffix: */
+    pos++;
+    for (;;) {
+      ch = styler.SafeGetCharAt(pos);
+      if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z')
+         || (ch >= 'a' && ch <= 'z') || ch == '_') ++pos;
+      else break;
+    }
+  }
+  styler.ColourTo(pos-1, SCE_P_NUMBER);
+  return pos;
+}
+
+/* rewritten from scratch, because I couldn't get rid of the bugs...
+   (A character based approach sucks!)
+*/
+static void ColouriseNimrodDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+                                WordList *keywordlists[], Accessor &styler) {
+  Sci_Position pos = startPos;
+  Sci_Position max = startPos + length;
+  char ch;
+  WordList &keywords = *keywordlists[0];
+
+  styler.StartAt(startPos);
+  styler.StartSegment(startPos);
+
+  switch (initStyle) {
+    /* check where we are: */
+    case SCE_P_TRIPLEDOUBLE:
+      pos = tillEndOfTripleQuote(styler, pos, max);
+      styler.ColourTo(pos, SCE_P_TRIPLEDOUBLE);
+      pos++;
+    break;
+    default: /* nothing to do: */
+    break;
+  }
+  while (pos < max) {
+    ch = styler.SafeGetCharAt(pos, '\0');
+    switch (ch) {
+      case '\0': return;
+      case '#': {
+        bool doccomment = (styler.SafeGetCharAt(pos+1) == '#');
+        while (pos < max && !isNewLine(styler.SafeGetCharAt(pos, LF))) pos++;
+        if (doccomment)
+          styler.ColourTo(pos, SCE_C_COMMENTLINEDOC);
+        else
+          styler.ColourTo(pos, SCE_P_COMMENTLINE);
+      } break;
+      case 'r': case 'R': {
+        if (styler.SafeGetCharAt(pos+1) == '"') {
+          pos = scanString(styler, pos+2, max, true);
+          styler.ColourTo(pos, SCE_P_STRING);
+          pos++;
+        } else {
+          pos = scanIdent(styler, pos, keywords);
+        }
+      } break;
+      case '"':
+        if (styler.Match(pos+1, "\"\"")) {
+          pos = tillEndOfTripleQuote(styler, pos+3, max);
+          styler.ColourTo(pos, SCE_P_TRIPLEDOUBLE);
+        } else {
+          pos = scanString(styler, pos+1, max, false);
+          styler.ColourTo(pos, SCE_P_STRING);
+        }
+        pos++;
+      break;
+      case '\'':
+        pos = scanChar(styler, pos+1, max);
+        styler.ColourTo(pos, SCE_P_CHARACTER);
+        pos++;
+      break;
+      default: // identifers, numbers, operators, whitespace
+        if (ch >= '0' && ch <= '9') {
+          pos = scanNumber(styler, pos);
+        } else if (IsAWordChar(ch)) {
+          pos = scanIdent(styler, pos, keywords);
+        } else if (ch == '`') {
+          pos++;
+          while (pos < max) {
+            ch = styler.SafeGetCharAt(pos, LF);
+            if (ch == '`') {
+              ++pos;
+              break;
+            }
+            if (ch == CR || ch == LF) break;
+            ++pos;
+          }
+          styler.ColourTo(pos, SCE_P_IDENTIFIER);
+        } else if (strchr("()[]{}:=;-\\/&%$!+<>|^?,.*~@", ch)) {
+          styler.ColourTo(pos, SCE_P_OPERATOR);
+          pos++;
+        } else {
+          styler.ColourTo(pos, SCE_P_DEFAULT);
+          pos++;
+        }
+      break;
+    }
+  }
+}
+
+static bool IsCommentLine(Sci_Position line, Accessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eol_pos; i++) {
+		char ch = styler[i];
+		if (ch == '#')
+			return true;
+		else if (ch != ' ' && ch != '\t')
+			return false;
+	}
+	return false;
+}
+
+static bool IsQuoteLine(Sci_Position line, Accessor &styler) {
+	int style = styler.StyleAt(styler.LineStart(line)) & 31;
+	return ((style == SCE_P_TRIPLE) || (style == SCE_P_TRIPLEDOUBLE));
+}
+
+
+static void FoldNimrodDoc(Sci_PositionU startPos, Sci_Position length,
+                          int /*initStyle - unused*/,
+                          WordList *[], Accessor &styler) {
+	const Sci_Position maxPos = startPos + length;
+	const Sci_Position maxLines = styler.GetLine(maxPos - 1); // Requested last line
+	const Sci_Position docLines = styler.GetLine(styler.Length() - 1); // Available last line
+	const bool foldComment = styler.GetPropertyInt("fold.comment.nimrod") != 0;
+	const bool foldQuotes = styler.GetPropertyInt("fold.quotes.nimrod") != 0;
+
+	// Backtrack to previous non-blank line so we can determine indent level
+	// for any white space lines (needed esp. within triple quoted strings)
+	// and so we can fix any preceding fold level (which is why we go back
+	// at least one line in all cases)
+	int spaceFlags = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, NULL);
+	while (lineCurrent > 0) {
+		lineCurrent--;
+		indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, NULL);
+		if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG) &&
+		        (!IsCommentLine(lineCurrent, styler)) &&
+		        (!IsQuoteLine(lineCurrent, styler)))
+			break;
+	}
+	int indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
+
+	// Set up initial loop state
+	startPos = styler.LineStart(lineCurrent);
+	int prev_state = SCE_P_DEFAULT & 31;
+	if (lineCurrent >= 1)
+		prev_state = styler.StyleAt(startPos - 1) & 31;
+	int prevQuote = foldQuotes && ((prev_state == SCE_P_TRIPLE) ||
+	                               (prev_state == SCE_P_TRIPLEDOUBLE));
+	int prevComment = 0;
+	if (lineCurrent >= 1)
+		prevComment = foldComment && IsCommentLine(lineCurrent - 1, styler);
+
+	// Process all characters to end of requested range or end of any triple quote
+	// or comment that hangs over the end of the range.  Cap processing in all cases
+	// to end of document (in case of unclosed quote or comment at end).
+	while ((lineCurrent <= docLines) && ((lineCurrent <= maxLines) ||
+	                                      prevQuote || prevComment)) {
+
+		// Gather info
+		int lev = indentCurrent;
+		Sci_Position lineNext = lineCurrent + 1;
+		int indentNext = indentCurrent;
+		int quote = false;
+		if (lineNext <= docLines) {
+			// Information about next line is only available if not at end of document
+			indentNext = styler.IndentAmount(lineNext, &spaceFlags, NULL);
+			int style = styler.StyleAt(styler.LineStart(lineNext)) & 31;
+			quote = foldQuotes && ((style == SCE_P_TRIPLE) || (style == SCE_P_TRIPLEDOUBLE));
+		}
+		const int quote_start = (quote && !prevQuote);
+		const int quote_continue = (quote && prevQuote);
+		const int comment = foldComment && IsCommentLine(lineCurrent, styler);
+		const int comment_start = (comment && !prevComment && (lineNext <= docLines) &&
+		                           IsCommentLine(lineNext, styler) &&
+		                           (lev > SC_FOLDLEVELBASE));
+		const int comment_continue = (comment && prevComment);
+		if ((!quote || !prevQuote) && !comment)
+			indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
+		if (quote)
+			indentNext = indentCurrentLevel;
+		if (indentNext & SC_FOLDLEVELWHITEFLAG)
+			indentNext = SC_FOLDLEVELWHITEFLAG | indentCurrentLevel;
+
+		if (quote_start) {
+			// Place fold point at start of triple quoted string
+			lev |= SC_FOLDLEVELHEADERFLAG;
+		} else if (quote_continue || prevQuote) {
+			// Add level to rest of lines in the string
+			lev = lev + 1;
+		} else if (comment_start) {
+			// Place fold point at start of a block of comments
+			lev |= SC_FOLDLEVELHEADERFLAG;
+		} else if (comment_continue) {
+			// Add level to rest of lines in the block
+			lev = lev + 1;
+		}
+
+		// Skip past any blank lines for next indent level info; we skip also
+		// comments (all comments, not just those starting in column 0)
+		// which effectively folds them into surrounding code rather
+		// than screwing up folding.
+
+		while (!quote &&
+		        (lineNext < docLines) &&
+		        ((indentNext & SC_FOLDLEVELWHITEFLAG) ||
+		         (lineNext <= docLines && IsCommentLine(lineNext, styler)))) {
+
+			lineNext++;
+			indentNext = styler.IndentAmount(lineNext, &spaceFlags, NULL);
+		}
+
+		const int levelAfterComments = indentNext & SC_FOLDLEVELNUMBERMASK;
+		const int levelBeforeComments =
+		    Maximum(indentCurrentLevel,levelAfterComments);
+
+		// Now set all the indent levels on the lines we skipped
+		// Do this from end to start.  Once we encounter one line
+		// which is indented more than the line after the end of
+		// the comment-block, use the level of the block before
+
+		Sci_Position skipLine = lineNext;
+		int skipLevel = levelAfterComments;
+
+		while (--skipLine > lineCurrent) {
+			int skipLineIndent = styler.IndentAmount(skipLine, &spaceFlags, NULL);
+
+			if ((skipLineIndent & SC_FOLDLEVELNUMBERMASK) > levelAfterComments)
+				skipLevel = levelBeforeComments;
+
+			int whiteFlag = skipLineIndent & SC_FOLDLEVELWHITEFLAG;
+
+			styler.SetLevel(skipLine, skipLevel | whiteFlag);
+		}
+
+		// Set fold header on non-quote/non-comment line
+		if (!quote && !comment && !(indentCurrent & SC_FOLDLEVELWHITEFLAG) ) {
+			if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) <
+			     (indentNext & SC_FOLDLEVELNUMBERMASK))
+				lev |= SC_FOLDLEVELHEADERFLAG;
+		}
+
+		// Keep track of triple quote and block comment state of previous line
+		prevQuote = quote;
+		prevComment = comment_start || comment_continue;
+
+		// Set fold level for this line and move to next line
+		styler.SetLevel(lineCurrent, lev);
+		indentCurrent = indentNext;
+		lineCurrent = lineNext;
+	}
+
+	// NOTE: Cannot set level of last line here because indentCurrent doesn't have
+	// header flag set; the loop above is crafted to take care of this case!
+	//styler.SetLevel(lineCurrent, indentCurrent);
+}
+
+static const char * const nimrodWordListDesc[] = {
+	"Keywords",
+	0
+};
+
+LexerModule lmNimrod(SCLEX_NIMROD, ColouriseNimrodDoc, "nimrod", FoldNimrodDoc,
+				     nimrodWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexNsis.cxx b/Pythonwin/Scintilla/lexers/LexNsis.cxx
similarity index 88%
rename from Pythonwin/Scintilla/src/LexNsis.cxx
rename to Pythonwin/Scintilla/lexers/LexNsis.cxx
index ab6304c42..3b2b8a3ad 100644
--- a/Pythonwin/Scintilla/src/LexNsis.cxx
+++ b/Pythonwin/Scintilla/lexers/LexNsis.cxx
@@ -5,23 +5,26 @@
 // Copyright 2003 - 2005 by Angelo Mandato <angelo [at] spaceblue [dot] com>
 // Last Updated: 03/13/2005
 // The License.txt file describes the conditions under which this software may be distributed.
+
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
 
-#ifdef SCI_NAMESPACE
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
 using namespace Scintilla;
-#endif
 
 /*
 // located in SciLexer.h
@@ -64,10 +67,10 @@ static bool isNsisLetter(char ch)
   return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z');
 }
 
-static bool NsisNextLineHasElse(unsigned int start, unsigned int end, Accessor &styler)
+static bool NsisNextLineHasElse(Sci_PositionU start, Sci_PositionU end, Accessor &styler)
 {
-  int nNextLine = -1;
-  for( unsigned int i = start; i < end; i++ )
+  Sci_Position nNextLine = -1;
+  for( Sci_PositionU i = start; i < end; i++ )
   {
     char cNext = styler.SafeGetCharAt( i );
     if( cNext == '\n' )
@@ -77,10 +80,10 @@ static bool NsisNextLineHasElse(unsigned int start, unsigned int end, Accessor &
     }
   }
 
-  if( nNextLine == -1 ) // We never foudn the next line...
+  if( nNextLine == -1 ) // We never found the next line...
     return false;
 
-  for( unsigned int firstChar = nNextLine; firstChar < end; firstChar++ )
+  for( Sci_PositionU firstChar = nNextLine; firstChar < end; firstChar++ )
   {
     char cNext = styler.SafeGetCharAt( firstChar );
     if( cNext == ' ' )
@@ -106,7 +109,7 @@ static int NsisCmp( const char *s1, const char *s2, bool bIgnoreCase )
   return strcmp( s1, s2 );
 }
 
-static int calculateFoldNsis(unsigned int start, unsigned int end, int foldlevel, Accessor &styler, bool bElse, bool foldUtilityCmd )
+static int calculateFoldNsis(Sci_PositionU start, Sci_PositionU end, int foldlevel, Accessor &styler, bool bElse, bool foldUtilityCmd )
 {
   int style = styler.StyleAt(end);
 
@@ -137,7 +140,8 @@ static int calculateFoldNsis(unsigned int start, unsigned int end, int foldlevel
     bIgnoreCase = true;
 
   char s[20]; // The key word we are looking for has atmost 13 characters
-  for (unsigned int i = 0; i < end - start + 1 && i < 19; i++)
+  s[0] = '\0';
+  for (Sci_PositionU i = 0; i < end - start + 1 && i < 19; i++)
 	{
 		s[i] = static_cast<char>( styler[ start + i ] );
 		s[i + 1] = '\0';
@@ -145,7 +149,7 @@ static int calculateFoldNsis(unsigned int start, unsigned int end, int foldlevel
 
   if( s[0] == '!' )
   {
-    if( NsisCmp(s, "!ifndef", bIgnoreCase) == 0 || NsisCmp(s, "!ifdef", bIgnoreCase ) == 0 || NsisCmp(s, "!if", bIgnoreCase ) == 0 || NsisCmp(s, "!macro", bIgnoreCase ) == 0 )
+    if( NsisCmp(s, "!ifndef", bIgnoreCase) == 0 || NsisCmp(s, "!ifdef", bIgnoreCase ) == 0 || NsisCmp(s, "!ifmacrodef", bIgnoreCase ) == 0 || NsisCmp(s, "!ifmacrondef", bIgnoreCase ) == 0 || NsisCmp(s, "!if", bIgnoreCase ) == 0 || NsisCmp(s, "!macro", bIgnoreCase ) == 0 )
       newFoldlevel++;
     else if( NsisCmp(s, "!endif", bIgnoreCase) == 0 || NsisCmp(s, "!macroend", bIgnoreCase ) == 0 )
       newFoldlevel--;
@@ -163,7 +167,7 @@ static int calculateFoldNsis(unsigned int start, unsigned int end, int foldlevel
   return newFoldlevel;
 }
 
-static int classifyWordNsis(unsigned int start, unsigned int end, WordList *keywordLists[], Accessor &styler )
+static int classifyWordNsis(Sci_PositionU start, Sci_PositionU end, WordList *keywordLists[], Accessor &styler )
 {
   bool bIgnoreCase = false;
   if( styler.GetPropertyInt("nsis.ignorecase") == 1 )
@@ -174,13 +178,15 @@ static int classifyWordNsis(unsigned int start, unsigned int end, WordList *keyw
     bUserVars = true;
 
 	char s[100];
+	s[0] = '\0';
+	s[1] = '\0';
 
 	WordList &Functions = *keywordLists[0];
 	WordList &Variables = *keywordLists[1];
 	WordList &Lables = *keywordLists[2];
 	WordList &UserDefined = *keywordLists[3];
 
-	for (unsigned int i = 0; i < end - start + 1 && i < 99; i++)
+	for (Sci_PositionU i = 0; i < end - start + 1 && i < 99; i++)
 	{
     if( bIgnoreCase )
       s[i] = static_cast<char>( tolower(styler[ start + i ] ) );
@@ -190,16 +196,16 @@ static int classifyWordNsis(unsigned int start, unsigned int end, WordList *keyw
 	}
 
 	// Check for special words...
-	if( NsisCmp(s, "!macro", bIgnoreCase ) == 0 || NsisCmp(s, "!macroend", bIgnoreCase) == 0 ) // Covers !micro and !microend
+	if( NsisCmp(s, "!macro", bIgnoreCase ) == 0 || NsisCmp(s, "!macroend", bIgnoreCase) == 0 ) // Covers !macro and !macroend
 		return SCE_NSIS_MACRODEF;
 
-	if( NsisCmp(s, "!ifdef", bIgnoreCase ) == 0 ||  NsisCmp(s, "!ifndef", bIgnoreCase) == 0 ||  NsisCmp(s, "!endif", bIgnoreCase) == 0 )
+	if( NsisCmp(s, "!ifdef", bIgnoreCase ) == 0 ||  NsisCmp(s, "!ifndef", bIgnoreCase) == 0 ||  NsisCmp(s, "!endif", bIgnoreCase) == 0 ) // Covers !ifdef, !ifndef and !endif
 		return SCE_NSIS_IFDEFINEDEF;
 
-  if( NsisCmp(s, "!else", bIgnoreCase ) == 0 ) // ||  NsisCmp(s, "!ifndef", bIgnoreCase) == 0 ||  NsisCmp(s, "!endif", bIgnoreCase) == 0 )
+	if( NsisCmp(s, "!if", bIgnoreCase ) == 0 || NsisCmp(s, "!else", bIgnoreCase )  == 0 ) // Covers !if and else
 		return SCE_NSIS_IFDEFINEDEF;
 
-  if( NsisCmp(s, "!if", bIgnoreCase ) == 0 )
+	if (NsisCmp(s, "!ifmacrodef", bIgnoreCase ) == 0 || NsisCmp(s, "!ifmacrondef", bIgnoreCase )  == 0 ) // Covers !ifmacrodef and !ifnmacrodef
 		return SCE_NSIS_IFDEFINEDEF;
 
   if( NsisCmp(s, "SectionGroup", bIgnoreCase) == 0 || NsisCmp(s, "SectionGroupEnd", bIgnoreCase) == 0 ) // Covers SectionGroup and SectionGroupEnd
@@ -239,7 +245,7 @@ static int classifyWordNsis(unsigned int start, unsigned int end, WordList *keyw
   if( s[0] == '$' && bUserVars )
   {
     bool bHasSimpleNsisChars = true;
-    for (unsigned int j = 1; j < end - start + 1 && j < 99; j++)
+    for (Sci_PositionU j = 1; j < end - start + 1 && j < 99; j++)
 	  {
       if( !isNsisChar( s[j] ) )
       {
@@ -256,7 +262,7 @@ static int classifyWordNsis(unsigned int start, unsigned int end, WordList *keyw
   if( isNsisNumber( s[0] ) )
   {
     bool bHasSimpleNsisNumber = true;
-    for (unsigned int j = 1; j < end - start + 1 && j < 99; j++)
+    for (Sci_PositionU j = 1; j < end - start + 1 && j < 99; j++)
 	  {
       if( !isNsisNumber( s[j] ) )
       {
@@ -272,7 +278,7 @@ static int classifyWordNsis(unsigned int start, unsigned int end, WordList *keyw
 	return SCE_NSIS_DEFAULT;
 }
 
-static void ColouriseNsisDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler)
+static void ColouriseNsisDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *keywordLists[], Accessor &styler)
 {
 	int state = SCE_NSIS_DEFAULT;
   if( startPos > 0 )
@@ -281,14 +287,14 @@ static void ColouriseNsisDoc(unsigned int startPos, int length, int, WordList *k
 	styler.StartAt( startPos );
 	styler.GetLine( startPos );
 
-	unsigned int nLengthDoc = startPos + length;
+	Sci_PositionU nLengthDoc = startPos + length;
 	styler.StartSegment( startPos );
 
 	char cCurrChar;
 	bool bVarInString = false;
   bool bClassicVarInString = false;
 
-	unsigned int i;
+	Sci_PositionU i;
 	for( i = startPos; i < nLengthDoc; i++ )
 	{
 		cCurrChar = styler.SafeGetCharAt( i );
@@ -395,8 +401,8 @@ static void ColouriseNsisDoc(unsigned int startPos, int length, int, WordList *k
 
         if( cNextChar == '\r' || cNextChar == '\n' )
         {
-          int nCurLine = styler.GetLine(i+1);
-          int nBack = i;
+          Sci_Position nCurLine = styler.GetLine(i+1);
+          Sci_Position nBack = i;
           // We need to check if the previous line has a \ in it...
           bool bNextLine = false;
 
@@ -544,7 +550,7 @@ static void ColouriseNsisDoc(unsigned int startPos, int length, int, WordList *k
 	styler.ColourTo(nLengthDoc-1,state);
 }
 
-static void FoldNsisDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler)
+static void FoldNsisDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler)
 {
 	// No folding enabled, no reason to continue...
 	if( styler.GetPropertyInt("fold") == 0 )
@@ -554,11 +560,11 @@ static void FoldNsisDoc(unsigned int startPos, int length, int, WordList *[], Ac
   bool foldUtilityCmd = styler.GetPropertyInt("nsis.foldutilcmd", 1) == 1;
   bool blockComment = false;
 
-  int lineCurrent = styler.GetLine(startPos);
-  unsigned int safeStartPos = styler.LineStart( lineCurrent );
+  Sci_Position lineCurrent = styler.GetLine(startPos);
+  Sci_PositionU safeStartPos = styler.LineStart( lineCurrent );
 
   bool bArg1 = true;
-  int nWordStart = -1;
+  Sci_Position nWordStart = -1;
 
   int levelCurrent = SC_FOLDLEVELBASE;
 	if (lineCurrent > 0)
@@ -572,7 +578,7 @@ static void FoldNsisDoc(unsigned int startPos, int length, int, WordList *[], Ac
     blockComment = true;
   }
 
-  for (unsigned int i = safeStartPos; i < startPos + length; i++)
+  for (Sci_PositionU i = safeStartPos; i < startPos + length; i++)
 	{
     char chCurr = styler.SafeGetCharAt(i);
     style = styler.StyleAt(i);
diff --git a/Pythonwin/Scintilla/lexers/LexNull.cxx b/Pythonwin/Scintilla/lexers/LexNull.cxx
new file mode 100644
index 000000000..15a3a50aa
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexNull.cxx
@@ -0,0 +1,38 @@
+// Scintilla source code edit control
+/** @file LexNull.cxx
+ ** Lexer for no language. Used for plain text and unrecognized files.
+ **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static void ColouriseNullDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[],
+                            Accessor &styler) {
+	// Null language means all style bytes are 0 so just mark the end - no need to fill in.
+	if (length > 0) {
+		styler.StartAt(startPos + length - 1);
+		styler.StartSegment(startPos + length - 1);
+		styler.ColourTo(startPos + length - 1, 0);
+	}
+}
+
+LexerModule lmNull(SCLEX_NULL, ColouriseNullDoc, "null");
diff --git a/Pythonwin/Scintilla/lexers/LexOScript.cxx b/Pythonwin/Scintilla/lexers/LexOScript.cxx
new file mode 100644
index 000000000..3fe407063
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexOScript.cxx
@@ -0,0 +1,546 @@
+// Scintilla source code edit control
+/** @file LexOScript.cxx
+ ** Lexer for OScript sources; ocx files and/or OSpace dumps.
+ ** OScript is a programming language used to develop applications for the
+ ** Livelink server platform.
+ **/
+// Written by Ferdinand Prantl <prantlf@gmail.com>, inspired by the code from
+// LexVB.cxx and LexPascal.cxx. The License.txt file describes the conditions
+// under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+// -----------------------------------------
+// Functions classifying a single character.
+
+// This function is generic and should be probably moved to CharSet.h where
+// IsAlphaNumeric the others reside.
+inline bool IsAlpha(int ch) {
+	return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
+}
+
+static inline bool IsIdentifierChar(int ch) {
+	// Identifiers cannot contain non-ASCII letters; a word with non-English
+	// language-specific characters cannot be an identifier.
+	return IsAlphaNumeric(ch) || ch == '_';
+}
+
+static inline bool IsIdentifierStart(int ch) {
+	// Identifiers cannot contain non-ASCII letters; a word with non-English
+	// language-specific characters cannot be an identifier.
+	return IsAlpha(ch) || ch == '_';
+}
+
+static inline bool IsNumberChar(int ch, int chNext) {
+	// Numeric constructs are not checked for lexical correctness. They are
+	// expected to look like +1.23-E9 but actually any bunch of the following
+	// characters will be styled as number.
+	// KNOWN PROBLEM: if you put + or - operators immediately after a number
+	// and the next operand starts with the letter E, the operator will not be
+	// recognized and it will be styled together with the preceding number.
+	// This should not occur; at least not often. The coding style recommends
+	// putting spaces around operators.
+	return IsADigit(ch) || toupper(ch) == 'E' || ch == '.' ||
+		   ((ch == '-' || ch == '+') && toupper(chNext) == 'E');
+}
+
+// This function checks for the start or a natural number without any symbols
+// or operators as a prefix; the IsPrefixedNumberStart should be called
+// immediately after this one to cover all possible numeric constructs.
+static inline bool IsNaturalNumberStart(int ch) {
+	return IsADigit(ch) != 0;
+}
+
+static inline bool IsPrefixedNumberStart(int ch, int chNext) {
+	// KNOWN PROBLEM: if you put + or - operators immediately before a number
+	// the operator will not be recognized and it will be styled together with
+	// the succeeding number. This should not occur; at least not often. The
+	// coding style recommends putting spaces around operators.
+	return (ch == '.' || ch == '-' || ch == '+') && IsADigit(chNext);
+}
+
+static inline bool IsOperator(int ch) {
+	return strchr("%^&*()-+={}[]:;<>,/?!.~|\\", ch) != NULL;
+}
+
+// ---------------------------------------------------------------
+// Functions classifying a token currently processed in the lexer.
+
+// Checks if the current line starts with the preprocessor directive used
+// usually to introduce documentation comments: #ifdef DOC. This method is
+// supposed to be called if the line has been recognized as a preprocessor
+// directive already.
+static bool IsDocCommentStart(StyleContext &sc) {
+	// Check the line back to its start only if the end looks promising.
+	if (sc.LengthCurrent() == 10 && !IsAlphaNumeric(sc.ch)) {
+		char s[11];
+		sc.GetCurrentLowered(s, sizeof(s));
+		return strcmp(s, "#ifdef doc") == 0;
+	}
+	return false;
+}
+
+// Checks if the current line starts with the preprocessor directive that
+// is complementary to the #ifdef DOC start: #endif. This method is supposed
+// to be called if the current state point to the documentation comment.
+// QUESTIONAL ASSUMPTION: The complete #endif directive is not checked; just
+// the starting #e. However, there is no other preprocessor directive with
+// the same starting letter and thus this optimization should always work.
+static bool IsDocCommentEnd(StyleContext &sc) {
+	return sc.ch == '#' && sc.chNext == 'e';
+}
+
+class IdentifierClassifier {
+	WordList &keywords;  // Passed from keywords property.
+	WordList &constants; // Passed from keywords2 property.
+	WordList &operators; // Passed from keywords3 property.
+	WordList &types;     // Passed from keywords4 property.
+	WordList &functions; // Passed from keywords5 property.
+	WordList &objects;   // Passed from keywords6 property.
+
+	IdentifierClassifier(IdentifierClassifier const&);
+	IdentifierClassifier& operator=(IdentifierClassifier const&);
+
+public:
+	IdentifierClassifier(WordList *keywordlists[]) :
+		keywords(*keywordlists[0]), constants(*keywordlists[1]),
+		operators(*keywordlists[2]), types(*keywordlists[3]),
+		functions(*keywordlists[4]), objects(*keywordlists[5])
+	{}
+
+	void ClassifyIdentifier(StyleContext &sc) {
+		// Opening parenthesis following an identifier makes it a possible
+		// function call.
+		// KNOWN PROBLEM: If some whitespace is inserted between the
+		// identifier and the parenthesis they will not be able to be
+		// recognized as a function call. This should not occur; at
+		// least not often. Such coding style would be weird.
+		if (sc.Match('(')) {
+			char s[100];
+			sc.GetCurrentLowered(s, sizeof(s));
+			// Before an opening brace can be control statements and
+			// operators too; function call is the last option.
+			if (keywords.InList(s)) {
+				sc.ChangeState(SCE_OSCRIPT_KEYWORD);
+			} else if (operators.InList(s)) {
+				sc.ChangeState(SCE_OSCRIPT_OPERATOR);
+			} else if (functions.InList(s)) {
+				sc.ChangeState(SCE_OSCRIPT_FUNCTION);
+			} else {
+				sc.ChangeState(SCE_OSCRIPT_METHOD);
+			}
+			sc.SetState(SCE_OSCRIPT_OPERATOR);
+		} else {
+			char s[100];
+			sc.GetCurrentLowered(s, sizeof(s));
+			// A dot following an identifier means an access to an object
+			// member. The related object identifier can be special.
+			// KNOWN PROBLEM: If there is whitespace between the identifier
+			// and the following dot, the identifier will not be recognized
+			// as an object in an object member access. If it is one of the
+			// listed static objects it will not be styled.
+			if (sc.Match('.') && objects.InList(s)) {
+				sc.ChangeState(SCE_OSCRIPT_OBJECT);
+				sc.SetState(SCE_OSCRIPT_OPERATOR);
+			} else {
+				if (keywords.InList(s)) {
+					sc.ChangeState(SCE_OSCRIPT_KEYWORD);
+				} else if (constants.InList(s)) {
+					sc.ChangeState(SCE_OSCRIPT_CONSTANT);
+				} else if (operators.InList(s)) {
+					sc.ChangeState(SCE_OSCRIPT_OPERATOR);
+				} else if (types.InList(s)) {
+					sc.ChangeState(SCE_OSCRIPT_TYPE);
+				} else if (functions.InList(s)) {
+					sc.ChangeState(SCE_OSCRIPT_FUNCTION);
+				}
+				sc.SetState(SCE_OSCRIPT_DEFAULT);
+			}
+		}
+	}
+};
+
+// ------------------------------------------------
+// Function colourising an excerpt of OScript code.
+
+static void ColouriseOScriptDoc(Sci_PositionU startPos, Sci_Position length,
+								int initStyle, WordList *keywordlists[],
+								Accessor &styler) {
+	// I wonder how whole-line styles ended by EOLN can escape the resetting
+	// code in the loop below and overflow to the next line. Let us make sure
+	// that a new line does not start with them carried from the previous one.
+	// NOTE: An overflowing string is intentionally not checked; it reminds
+	// the developer that the string must be ended on the same line.
+	if (initStyle == SCE_OSCRIPT_LINE_COMMENT ||
+			initStyle == SCE_OSCRIPT_PREPROCESSOR) {
+		initStyle = SCE_OSCRIPT_DEFAULT;
+	}
+
+	styler.StartAt(startPos);
+	StyleContext sc(startPos, length, initStyle, styler);
+	IdentifierClassifier identifierClassifier(keywordlists);
+
+	// It starts with true at the beginning of a line and changes to false as
+	// soon as the first non-whitespace character has been processed.
+	bool isFirstToken = true;
+	// It starts with true at the beginning of a line and changes to false as
+	// soon as the first identifier on the line is passed by.
+	bool isFirstIdentifier = true;
+	// It becomes false when #ifdef DOC (the preprocessor directive often
+	// used to start a documentation comment) is encountered and remain false
+	// until the end of the documentation block is not detected. This is done
+	// by checking for the complementary #endif preprocessor directive.
+	bool endDocComment = false;
+
+	for (; sc.More(); sc.Forward()) {
+
+		if (sc.atLineStart) {
+			isFirstToken = true;
+			isFirstIdentifier = true;
+		// Detect the current state is neither whitespace nor identifier. It
+		// means that no next identifier can be the first token on the line.
+		} else if (isFirstIdentifier && sc.state != SCE_OSCRIPT_DEFAULT &&
+				   sc.state != SCE_OSCRIPT_IDENTIFIER) {
+			isFirstIdentifier = false;
+		}
+
+		// Check if the current state should be changed.
+		if (sc.state == SCE_OSCRIPT_OPERATOR) {
+			// Multiple-symbol operators are marked by single characters.
+			sc.SetState(SCE_OSCRIPT_DEFAULT);
+		} else if (sc.state == SCE_OSCRIPT_IDENTIFIER) {
+			if (!IsIdentifierChar(sc.ch)) {
+				// Colon after an identifier makes it a label if it is the
+				// first token on the line.
+				// KNOWN PROBLEM: If some whitespace is inserted between the
+				// identifier and the colon they will not be recognized as a
+				// label. This should not occur; at least not often. It would
+				// make the code structure less legible and examples in the
+				// Livelink documentation do not show it.
+				if (sc.Match(':') && isFirstIdentifier) {
+					sc.ChangeState(SCE_OSCRIPT_LABEL);
+					sc.ForwardSetState(SCE_OSCRIPT_DEFAULT);
+				} else {
+					identifierClassifier.ClassifyIdentifier(sc);
+				}
+				// Avoid a sequence of two words be mistaken for a label. A
+				// switch case would be an example.
+				isFirstIdentifier = false;
+			}
+		} else if (sc.state == SCE_OSCRIPT_GLOBAL) {
+			if (!IsIdentifierChar(sc.ch)) {
+				sc.SetState(SCE_OSCRIPT_DEFAULT);
+			}
+		} else if (sc.state == SCE_OSCRIPT_PROPERTY) {
+			if (!IsIdentifierChar(sc.ch)) {
+				// Any member access introduced by the dot operator is
+				// initially marked as a property access. If an opening
+				// parenthesis is detected later it is changed to method call.
+				// KNOWN PROBLEM: The same as at the function call recognition
+				// for SCE_OSCRIPT_IDENTIFIER above.
+				if (sc.Match('(')) {
+					sc.ChangeState(SCE_OSCRIPT_METHOD);
+				}
+				sc.SetState(SCE_OSCRIPT_DEFAULT);
+			}
+		} else if (sc.state == SCE_OSCRIPT_NUMBER) {
+			if (!IsNumberChar(sc.ch, sc.chNext)) {
+				sc.SetState(SCE_OSCRIPT_DEFAULT);
+			}
+		} else if (sc.state == SCE_OSCRIPT_SINGLEQUOTE_STRING) {
+			if (sc.ch == '\'') {
+				// Two consequential apostrophes convert to a single one.
+				if (sc.chNext == '\'') {
+					sc.Forward();
+				} else {
+					sc.ForwardSetState(SCE_OSCRIPT_DEFAULT);
+				}
+			} else if (sc.atLineEnd) {
+				sc.ForwardSetState(SCE_OSCRIPT_DEFAULT);
+			}
+		} else if (sc.state == SCE_OSCRIPT_DOUBLEQUOTE_STRING) {
+			if (sc.ch == '\"') {
+				// Two consequential quotation marks convert to a single one.
+				if (sc.chNext == '\"') {
+					sc.Forward();
+				} else {
+					sc.ForwardSetState(SCE_OSCRIPT_DEFAULT);
+				}
+			} else if (sc.atLineEnd) {
+				sc.ForwardSetState(SCE_OSCRIPT_DEFAULT);
+			}
+		} else if (sc.state == SCE_OSCRIPT_BLOCK_COMMENT) {
+			if (sc.Match('*', '/')) {
+				sc.Forward();
+				sc.ForwardSetState(SCE_OSCRIPT_DEFAULT);
+			}
+		} else if (sc.state == SCE_OSCRIPT_LINE_COMMENT) {
+			if (sc.atLineEnd) {
+				sc.ForwardSetState(SCE_OSCRIPT_DEFAULT);
+			}
+		} else if (sc.state == SCE_OSCRIPT_PREPROCESSOR) {
+			if (IsDocCommentStart(sc)) {
+				sc.ChangeState(SCE_OSCRIPT_DOC_COMMENT);
+				endDocComment = false;
+			} else if (sc.atLineEnd) {
+				sc.ForwardSetState(SCE_OSCRIPT_DEFAULT);
+			}
+		} else if (sc.state == SCE_OSCRIPT_DOC_COMMENT) {
+			// KNOWN PROBLEM: The first line detected that would close a
+			// conditional preprocessor block (#endif) the documentation
+			// comment block will end. (Nested #if-#endif blocks are not
+			// supported. Hopefully it will not occur often that a line
+			// within the text block would stat with #endif.
+			if (isFirstToken && IsDocCommentEnd(sc)) {
+				endDocComment = true;
+			} else if (sc.atLineEnd && endDocComment) {
+				sc.ForwardSetState(SCE_OSCRIPT_DEFAULT);
+			}
+		}
+
+		// Check what state starts with the current character.
+		if (sc.state == SCE_OSCRIPT_DEFAULT) {
+			if (sc.Match('\'')) {
+				sc.SetState(SCE_OSCRIPT_SINGLEQUOTE_STRING);
+			} else if (sc.Match('\"')) {
+				sc.SetState(SCE_OSCRIPT_DOUBLEQUOTE_STRING);
+			} else if (sc.Match('/', '/')) {
+				sc.SetState(SCE_OSCRIPT_LINE_COMMENT);
+				sc.Forward();
+			} else if (sc.Match('/', '*')) {
+				sc.SetState(SCE_OSCRIPT_BLOCK_COMMENT);
+				sc.Forward();
+			} else if (isFirstToken && sc.Match('#')) {
+				sc.SetState(SCE_OSCRIPT_PREPROCESSOR);
+			} else if (sc.Match('$')) {
+				// Both process-global ($xxx) and thread-global ($$xxx)
+				// variables are handled as one global.
+				sc.SetState(SCE_OSCRIPT_GLOBAL);
+			} else if (IsNaturalNumberStart(sc.ch)) {
+				sc.SetState(SCE_OSCRIPT_NUMBER);
+			} else if (IsPrefixedNumberStart(sc.ch, sc.chNext)) {
+				sc.SetState(SCE_OSCRIPT_NUMBER);
+				sc.Forward();
+			} else if (sc.Match('.') && IsIdentifierStart(sc.chNext)) {
+				// Every object member access is marked as a property access
+				// initially. The decision between property and method is made
+				// after parsing the identifier and looking what comes then.
+				// KNOWN PROBLEM: If there is whitespace between the following
+				// identifier and the dot, the dot will not be recognized
+				// as a member accessing operator. In turn, the identifier
+				// will not be recognizable as a property or a method too.
+				sc.SetState(SCE_OSCRIPT_OPERATOR);
+				sc.Forward();
+				sc.SetState(SCE_OSCRIPT_PROPERTY);
+			} else if (IsIdentifierStart(sc.ch)) {
+				sc.SetState(SCE_OSCRIPT_IDENTIFIER);
+			} else if (IsOperator(sc.ch)) {
+				sc.SetState(SCE_OSCRIPT_OPERATOR);
+			}
+		}
+
+		if (isFirstToken && !IsASpaceOrTab(sc.ch)) {
+			isFirstToken = false;
+		}
+	}
+
+	sc.Complete();
+}
+
+// ------------------------------------------
+// Functions supporting OScript code folding.
+
+static inline bool IsBlockComment(int style) {
+	return style == SCE_OSCRIPT_BLOCK_COMMENT;
+}
+
+static bool IsLineComment(Sci_Position line, Accessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eolPos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eolPos; i++) {
+		char ch = styler[i];
+		char chNext = styler.SafeGetCharAt(i + 1);
+		int style = styler.StyleAt(i);
+		if (ch == '/' && chNext == '/' && style == SCE_OSCRIPT_LINE_COMMENT) {
+			return true;
+		} else if (!IsASpaceOrTab(ch)) {
+			return false;
+		}
+	}
+	return false;
+}
+
+static inline bool IsPreprocessor(int style) {
+	return style == SCE_OSCRIPT_PREPROCESSOR ||
+		   style == SCE_OSCRIPT_DOC_COMMENT;
+}
+
+static void GetRangeLowered(Sci_PositionU start, Sci_PositionU end,
+							Accessor &styler, char *s, Sci_PositionU len) {
+	Sci_PositionU i = 0;
+	while (i < end - start + 1 && i < len - 1) {
+		s[i] = static_cast<char>(tolower(styler[start + i]));
+		i++;
+	}
+	s[i] = '\0';
+}
+
+static void GetForwardWordLowered(Sci_PositionU start, Accessor &styler,
+								  char *s, Sci_PositionU len) {
+	Sci_PositionU i = 0;
+	while (i < len - 1 && IsAlpha(styler.SafeGetCharAt(start + i))) {
+		s[i] = static_cast<char>(tolower(styler.SafeGetCharAt(start + i)));
+		i++;
+	}
+	s[i] = '\0';
+}
+
+static void UpdatePreprocessorFoldLevel(int &levelCurrent,
+		Sci_PositionU startPos, Accessor &styler) {
+	char s[7]; // Size of the longest possible keyword + null.
+	GetForwardWordLowered(startPos, styler, s, sizeof(s));
+
+	if (strcmp(s, "ifdef") == 0 ||
+		strcmp(s, "ifndef") == 0) {
+		levelCurrent++;
+	} else if (strcmp(s, "endif") == 0) {
+		levelCurrent--;
+		if (levelCurrent < SC_FOLDLEVELBASE) {
+			levelCurrent = SC_FOLDLEVELBASE;
+		}
+	}
+}
+
+static void UpdateKeywordFoldLevel(int &levelCurrent, Sci_PositionU lastStart,
+		Sci_PositionU currentPos, Accessor &styler) {
+	char s[9];
+	GetRangeLowered(lastStart, currentPos, styler, s, sizeof(s));
+
+	if (strcmp(s, "if") == 0 || strcmp(s, "for") == 0 ||
+		strcmp(s, "switch") == 0 || strcmp(s, "function") == 0 ||
+		strcmp(s, "while") == 0 || strcmp(s, "repeat") == 0) {
+		levelCurrent++;
+	} else if (strcmp(s, "end") == 0 || strcmp(s, "until") == 0) {
+		levelCurrent--;
+		if (levelCurrent < SC_FOLDLEVELBASE) {
+			levelCurrent = SC_FOLDLEVELBASE;
+		}
+	}
+}
+
+// ------------------------------
+// Function folding OScript code.
+
+static void FoldOScriptDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+						   WordList *[], Accessor &styler) {
+	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+	bool foldPreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0;
+	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+	Sci_Position endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
+	int levelCurrent = levelPrev;
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+	Sci_Position lastStart = 0;
+
+	for (Sci_Position i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int stylePrev = style;
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atLineEnd = (ch == '\r' && chNext != '\n') || (ch == '\n');
+
+		if (foldComment && IsBlockComment(style)) {
+			if (!IsBlockComment(stylePrev)) {
+				levelCurrent++;
+			} else if (!IsBlockComment(styleNext) && !atLineEnd) {
+				// Comments do not end at end of line and the next character
+				// may not be styled.
+				levelCurrent--;
+			}
+		}
+		if (foldComment && atLineEnd && IsLineComment(lineCurrent, styler)) {
+			if (!IsLineComment(lineCurrent - 1, styler) &&
+				IsLineComment(lineCurrent + 1, styler))
+				levelCurrent++;
+			else if (IsLineComment(lineCurrent - 1, styler) &&
+					 !IsLineComment(lineCurrent+1, styler))
+				levelCurrent--;
+		}
+		if (foldPreprocessor) {
+			if (ch == '#' && IsPreprocessor(style)) {
+				UpdatePreprocessorFoldLevel(levelCurrent, i + 1, styler);
+			}
+		}
+
+		if (stylePrev != SCE_OSCRIPT_KEYWORD && style == SCE_OSCRIPT_KEYWORD) {
+			lastStart = i;
+		}
+		if (stylePrev == SCE_OSCRIPT_KEYWORD) {
+			if(IsIdentifierChar(ch) && !IsIdentifierChar(chNext)) {
+				UpdateKeywordFoldLevel(levelCurrent, lastStart, i, styler);
+			}
+		}
+
+		if (!IsASpace(ch))
+			visibleChars++;
+
+		if (atLineEnd) {
+			int level = levelPrev;
+			if (visibleChars == 0 && foldCompact)
+				level |= SC_FOLDLEVELWHITEFLAG;
+			if ((levelCurrent > levelPrev) && (visibleChars > 0))
+				level |= SC_FOLDLEVELHEADERFLAG;
+			if (level != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, level);
+			}
+			lineCurrent++;
+			levelPrev = levelCurrent;
+			visibleChars = 0;
+		}
+	}
+
+	// If we did not reach EOLN in the previous loop, store the line level and
+	// whitespace information. The rest will be filled in later.
+	int lev = levelPrev;
+	if (visibleChars == 0 && foldCompact)
+		lev |= SC_FOLDLEVELWHITEFLAG;
+	styler.SetLevel(lineCurrent, lev);
+}
+
+// --------------------------------------------
+// Declaration of the OScript lexer descriptor.
+
+static const char * const oscriptWordListDesc[] = {
+	"Keywords and reserved words",
+	"Literal constants",
+	"Literal operators",
+	"Built-in value and reference types",
+	"Built-in global functions",
+	"Built-in static objects",
+	0
+};
+
+LexerModule lmOScript(SCLEX_OSCRIPT, ColouriseOScriptDoc, "oscript", FoldOScriptDoc, oscriptWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexOpal.cxx b/Pythonwin/Scintilla/lexers/LexOpal.cxx
similarity index 81%
rename from Pythonwin/Scintilla/src/LexOpal.cxx
rename to Pythonwin/Scintilla/lexers/LexOpal.cxx
index 221f95597..c23620405 100644
--- a/Pythonwin/Scintilla/src/LexOpal.cxx
+++ b/Pythonwin/Scintilla/lexers/LexOpal.cxx
@@ -6,26 +6,27 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
 #include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-inline static void getRange( unsigned int start, unsigned int end, Accessor & styler, char * s, unsigned int len )
+inline static void getRange( Sci_PositionU start, Sci_PositionU end, Accessor & styler, char * s, Sci_PositionU len )
 {
-	unsigned int i = 0;
+	Sci_PositionU i = 0;
 	while( ( i < end - start + 1 ) && ( i < len - 1 ) )
 	{
 		s[i] = static_cast<char>( styler[ start + i ] );
@@ -34,7 +35,7 @@ inline static void getRange( unsigned int start, unsigned int end, Accessor & st
 	s[ i ] = '\0';
 }
 
-inline bool HandleString( unsigned int & cur, unsigned int one_too_much, Accessor & styler )
+inline bool HandleString( Sci_PositionU & cur, Sci_PositionU one_too_much, Accessor & styler )
 {
 	char ch;
 
@@ -89,10 +90,10 @@ inline bool HandleString( unsigned int & cur, unsigned int one_too_much, Accesso
 	}
 }
 
-inline bool HandleCommentBlock( unsigned int & cur, unsigned int one_too_much, Accessor & styler, bool could_fail )
+inline bool HandleCommentBlock( Sci_PositionU & cur, Sci_PositionU one_too_much, Accessor & styler, bool could_fail )
 {
 	char ch;
-	
+
 	if( could_fail )
 	{
 		cur++;
@@ -101,7 +102,7 @@ inline bool HandleCommentBlock( unsigned int & cur, unsigned int one_too_much, A
 			styler.ColourTo( cur - 1, SCE_OPAL_DEFAULT );
 			return false; // STOP
 		}
-		
+
 		ch = styler.SafeGetCharAt( cur );
 		if( ch != '*' )
 		{
@@ -110,7 +111,7 @@ inline bool HandleCommentBlock( unsigned int & cur, unsigned int one_too_much, A
 			return true;
 		}
 	}
-	
+
 	// Wait for comment close
 	cur++;
 	bool star_found = false;
@@ -121,7 +122,7 @@ inline bool HandleCommentBlock( unsigned int & cur, unsigned int one_too_much, A
 			styler.ColourTo( cur - 1, SCE_OPAL_COMMENT_BLOCK );
 			return false; // STOP
 		}
-		
+
 		ch = styler.SafeGetCharAt( cur );
 		if( star_found )
 		{
@@ -152,10 +153,10 @@ inline bool HandleCommentBlock( unsigned int & cur, unsigned int one_too_much, A
 	}
 }
 
-inline bool HandleCommentLine( unsigned int & cur, unsigned int one_too_much, Accessor & styler, bool could_fail )
+inline bool HandleCommentLine( Sci_PositionU & cur, Sci_PositionU one_too_much, Accessor & styler, bool could_fail )
 {
 	char ch;
-	
+
 	if( could_fail )
 	{
 		cur++;
@@ -164,7 +165,7 @@ inline bool HandleCommentLine( unsigned int & cur, unsigned int one_too_much, Ac
 			styler.ColourTo( cur - 1, SCE_OPAL_DEFAULT );
 			return false; // STOP
 		}
-		
+
 		ch = styler.SafeGetCharAt( cur );
 		if( ch != '-' )
 		{
@@ -179,7 +180,7 @@ inline bool HandleCommentLine( unsigned int & cur, unsigned int one_too_much, Ac
 			styler.ColourTo( cur - 1, SCE_OPAL_DEFAULT );
 			return false; // STOP
 		}
-		
+
 		ch = styler.SafeGetCharAt( cur );
 		if( ( ch != ' ' ) && ( ch != '\t' ) )
 		{
@@ -224,7 +225,7 @@ inline bool HandleCommentLine( unsigned int & cur, unsigned int one_too_much, Ac
 		{
 			if( ch == '\015' )
 			{
-				fifteen_found = true;	
+				fifteen_found = true;
 			}
 			else if( ch == '\012' )
 			{
@@ -237,7 +238,7 @@ inline bool HandleCommentLine( unsigned int & cur, unsigned int one_too_much, Ac
 	}
 }
 
-inline bool HandlePar( unsigned int & cur, Accessor & styler )
+inline bool HandlePar( Sci_PositionU & cur, Accessor & styler )
 {
 	styler.ColourTo( cur, SCE_OPAL_PAR );
 
@@ -247,7 +248,7 @@ inline bool HandlePar( unsigned int & cur, Accessor & styler )
 	return true;
 }
 
-inline bool HandleSpace( unsigned int & cur, unsigned int one_too_much, Accessor & styler )
+inline bool HandleSpace( Sci_PositionU & cur, Sci_PositionU one_too_much, Accessor & styler )
 {
 	char ch;
 
@@ -259,7 +260,7 @@ inline bool HandleSpace( unsigned int & cur, unsigned int one_too_much, Accessor
 			styler.ColourTo( cur - 1, SCE_OPAL_SPACE );
 			return false;
 		}
-		
+
 		ch = styler.SafeGetCharAt( cur );
 		switch( ch )
 		{
@@ -269,7 +270,7 @@ inline bool HandleSpace( unsigned int & cur, unsigned int one_too_much, Accessor
 		case '\012':
 			cur++;
 			break;
-		
+
 		default:
 			styler.ColourTo( cur - 1, SCE_OPAL_SPACE );
 			styler.StartSegment( cur );
@@ -278,7 +279,7 @@ inline bool HandleSpace( unsigned int & cur, unsigned int one_too_much, Accessor
 	}
 }
 
-inline bool HandleInteger( unsigned int & cur, unsigned int one_too_much, Accessor & styler )
+inline bool HandleInteger( Sci_PositionU & cur, Sci_PositionU one_too_much, Accessor & styler )
 {
 	char ch;
 
@@ -292,7 +293,7 @@ inline bool HandleInteger( unsigned int & cur, unsigned int one_too_much, Access
 		}
 
 		ch = styler.SafeGetCharAt( cur );
-		if( !isdigit( ch ) )
+		if( !( IsASCII( ch ) && isdigit( ch ) ) )
 		{
 			styler.ColourTo( cur - 1, SCE_OPAL_INTEGER );
 			styler.StartSegment( cur );
@@ -301,29 +302,29 @@ inline bool HandleInteger( unsigned int & cur, unsigned int one_too_much, Access
 	}
 }
 
-inline bool HandleWord( unsigned int & cur, unsigned int one_too_much, Accessor & styler, WordList * keywordlists[] )
+inline bool HandleWord( Sci_PositionU & cur, Sci_PositionU one_too_much, Accessor & styler, WordList * keywordlists[] )
 {
 	char ch;
-	const unsigned int beg = cur;
+	const Sci_PositionU beg = cur;
 
 	cur++;
 	for( ; ; )
 	{
 		ch = styler.SafeGetCharAt( cur );
 		if( ( ch != '_' ) && ( ch != '-' ) &&
-			!islower( ch ) && !isupper( ch ) && !isdigit( ch ) ) break;
+			!( IsASCII( ch ) && ( islower( ch ) || isupper( ch ) || isdigit( ch ) ) ) ) break;
 
 		cur++;
-		if( cur >= one_too_much ) 
+		if( cur >= one_too_much )
 		{
 			break;
 		}
 	}
 
-	const int ide_len = cur - beg + 1;
+	const Sci_Position ide_len = cur - beg + 1;
 	char * ide = new char[ ide_len ];
 	getRange( beg, cur, styler, ide, ide_len );
-	
+
 	WordList & keywords    = *keywordlists[ 0 ];
 	WordList & classwords  = *keywordlists[ 1 ];
 
@@ -338,8 +339,8 @@ inline bool HandleWord( unsigned int & cur, unsigned int one_too_much, Accessor
 		}
 		else
 		{
-			styler.StartSegment( cur );	
-			return true;			
+			styler.StartSegment( cur );
+			return true;
 		}
 	}
 	else if( classwords.InList( ide ) ) // Sort
@@ -353,8 +354,8 @@ inline bool HandleWord( unsigned int & cur, unsigned int one_too_much, Accessor
 		}
 		else
 		{
-			styler.StartSegment( cur );	
-			return true;			
+			styler.StartSegment( cur );
+			return true;
 		}
 	}
 	else if( !strcmp( ide, "true" ) || !strcmp( ide, "false" ) ) // Bool const
@@ -368,8 +369,8 @@ inline bool HandleWord( unsigned int & cur, unsigned int one_too_much, Accessor
 		}
 		else
 		{
-			styler.StartSegment( cur );	
-			return true;			
+			styler.StartSegment( cur );
+			return true;
 		}
 	}
 	else // Unknown keyword
@@ -384,13 +385,13 @@ inline bool HandleWord( unsigned int & cur, unsigned int one_too_much, Accessor
 		else
 		{
 			styler.StartSegment( cur );
-			return true;			
+			return true;
 		}
 	}
 
 }
 
-inline bool HandleSkip( unsigned int & cur, unsigned int one_too_much, Accessor & styler )
+inline bool HandleSkip( Sci_PositionU & cur, Sci_PositionU one_too_much, Accessor & styler )
 {
 	cur++;
 	styler.ColourTo( cur - 1, SCE_OPAL_DEFAULT );
@@ -400,18 +401,18 @@ inline bool HandleSkip( unsigned int & cur, unsigned int one_too_much, Accessor
 	}
 	else
 	{
-		styler.StartSegment( cur );	
+		styler.StartSegment( cur );
 		return true;
 	}
 }
 
-static void ColouriseOpalDoc( unsigned int startPos, int length, int initStyle, WordList *keywordlists[], Accessor & styler )
+static void ColouriseOpalDoc( Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[], Accessor & styler )
 {
 	styler.StartAt( startPos );
 	styler.StartSegment( startPos );
 
-	unsigned int & cur = startPos;
-	const unsigned int one_too_much = startPos + length;
+	Sci_PositionU & cur = startPos;
+	const Sci_PositionU one_too_much = startPos + length;
 
 	int state = initStyle;
 
@@ -444,11 +445,11 @@ static void ColouriseOpalDoc( unsigned int startPos, int length, int initStyle,
 			if( !HandleString( cur, one_too_much, styler ) ) return;
 			state = SCE_OPAL_DEFAULT;
 			break;
-			
+
 		default: // SCE_OPAL_DEFAULT:
 			{
 				char ch = styler.SafeGetCharAt( cur );
-				
+
 				switch( ch )
 				{
 				// String
@@ -483,20 +484,20 @@ static void ColouriseOpalDoc( unsigned int startPos, int length, int initStyle,
 				case '\012':
 					if( !HandleSpace( cur, one_too_much, styler ) ) return;
 					break;
-				
+
 				default:
 					{
 						// Integer
-						if( isdigit( ch ) )
+						if( IsASCII( ch ) && isdigit( ch ) )
 						{
 							if( !HandleInteger( cur, one_too_much, styler ) ) return;
 						}
 
 						// Keyword
-						else if( islower( ch ) || isupper( ch ) )
+						else if( IsASCII( ch ) && ( islower( ch ) || isupper( ch ) ) )
 						{
 							if( !HandleWord( cur, one_too_much, styler, keywordlists ) ) return;
-							
+
 						}
 
 						// Skip
diff --git a/Pythonwin/Scintilla/src/LexPB.cxx b/Pythonwin/Scintilla/lexers/LexPB.cxx
similarity index 93%
rename from Pythonwin/Scintilla/src/LexPB.cxx
rename to Pythonwin/Scintilla/lexers/LexPB.cxx
index abc0ddc79..582a5899d 100644
--- a/Pythonwin/Scintilla/src/LexPB.cxx
+++ b/Pythonwin/Scintilla/lexers/LexPB.cxx
@@ -35,22 +35,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static inline bool IsTypeCharacter(const int ch)
 {
@@ -67,10 +68,10 @@ static inline bool IsAWordStart(const int ch)
     return (ch < 0x80) && (isalnum(ch) || ch == '_');
 }
 
-bool MatchUpperCase(Accessor &styler, int pos, const char *s)   //Same as styler.Match() but uppercase comparison (a-z,A-Z and space only)
+static bool MatchUpperCase(Accessor &styler, Sci_Position pos, const char *s)   //Same as styler.Match() but uppercase comparison (a-z,A-Z and space only)
 {
     char ch;
-    for (int i=0; *s; i++)
+    for (Sci_Position i=0; *s; i++)
     {
         ch=styler.SafeGetCharAt(pos+i);
         if (ch > 0x60) ch -= '\x20';
@@ -80,7 +81,7 @@ bool MatchUpperCase(Accessor &styler, int pos, const char *s)   //Same as styler
     return true;
 }
 
-static void ColourisePBDoc(unsigned int startPos, int length, int initStyle,WordList *keywordlists[],Accessor &styler) {
+static void ColourisePBDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,WordList *keywordlists[],Accessor &styler) {
 
     WordList &keywords = *keywordlists[0];
 
@@ -182,14 +183,14 @@ static void ColourisePBDoc(unsigned int startPos, int length, int initStyle,Word
 //GFA Basic which is dead now. After testing the feature of toggling FOR-NEXT loops, WHILE-WEND loops
 //and so on too I found this is more disturbing then helping (for me). So if You think in another way
 //you can (or must) write Your own toggling routine ;-)
-static void FoldPBDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler)
+static void FoldPBDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler)
 {
     // No folding enabled, no reason to continue...
     if( styler.GetPropertyInt("fold") == 0 )
         return;
 
-    unsigned int endPos = startPos + length;
-    int lineCurrent = styler.GetLine(startPos);
+    Sci_PositionU endPos = startPos + length;
+    Sci_Position lineCurrent = styler.GetLine(startPos);
     int levelCurrent = SC_FOLDLEVELBASE;
     if (lineCurrent > 0)
         levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
@@ -199,7 +200,7 @@ static void FoldPBDoc(unsigned int startPos, int length, int, WordList *[], Acce
     bool fNewLine=true;
     bool fMightBeMultiLineMacro=false;
     bool fBeginOfCommentFound=false;
-    for (unsigned int i = startPos; i < endPos; i++)
+    for (Sci_PositionU i = startPos; i < endPos; i++)
     {
         char ch = chNext;
         chNext = styler.SafeGetCharAt(i + 1);
@@ -351,7 +352,7 @@ static void FoldPBDoc(unsigned int startPos, int length, int, WordList *[], Acce
                 break;
             }
         }  //switch (ch)
-    }  //for (unsigned int i = startPos; i < endPos; i++)
+    }  //for (Sci_PositionU i = startPos; i < endPos; i++)
 }
 
 static const char * const pbWordListDesc[] = {
diff --git a/Pythonwin/Scintilla/src/LexPLM.cxx b/Pythonwin/Scintilla/lexers/LexPLM.cxx
similarity index 85%
rename from Pythonwin/Scintilla/src/LexPLM.cxx
rename to Pythonwin/Scintilla/lexers/LexPLM.cxx
index 604850fbe..653242fab 100644
--- a/Pythonwin/Scintilla/src/LexPLM.cxx
+++ b/Pythonwin/Scintilla/lexers/LexPLM.cxx
@@ -1,32 +1,34 @@
 // Copyright (c) 1990-2007, Scientific Toolworks, Inc.
+// @file LexPLM.cxx
 // Author: Jason Haslam
 // The License.txt file describes the conditions under which this software may be distributed.
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
 #include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-static void GetRange(unsigned int start,
-                     unsigned int end,
+static void GetRange(Sci_PositionU start,
+                     Sci_PositionU end,
                      Accessor &styler,
                      char *s,
-                     unsigned int len) {
-	unsigned int i = 0;
+                     Sci_PositionU len) {
+	Sci_PositionU i = 0;
 	while ((i < end - start + 1) && (i < len-1)) {
 		s[i] = static_cast<char>(tolower(styler[start + i]));
 		i++;
@@ -34,19 +36,19 @@ static void GetRange(unsigned int start,
 	s[i] = '\0';
 }
 
-static void ColourisePlmDoc(unsigned int startPos,
-                            int length,
+static void ColourisePlmDoc(Sci_PositionU startPos,
+                            Sci_Position length,
                             int initStyle,
                             WordList *keywordlists[],
                             Accessor &styler)
 {
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int state = initStyle;
 
 	styler.StartAt(startPos);
 	styler.StartSegment(startPos);
 
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = styler.SafeGetCharAt(i);
 		char chNext = styler.SafeGetCharAt(i + 1);
 
@@ -96,7 +98,7 @@ static void ColourisePlmDoc(unsigned int startPos,
 			if (!isdigit(ch) && !isalpha(ch) && ch != '$') {
 				// Get the entire identifier.
 				char word[1024];
-				int segmentStart = styler.GetStartSegment();
+				Sci_Position segmentStart = styler.GetStartSegment();
 				GetRange(segmentStart, i - 1, styler, word, sizeof(word));
 
 				i--;
@@ -122,25 +124,25 @@ static void ColourisePlmDoc(unsigned int startPos,
 	styler.ColourTo(endPos - 1, state);
 }
 
-static void FoldPlmDoc(unsigned int startPos,
-                       int length,
+static void FoldPlmDoc(Sci_PositionU startPos,
+                       Sci_Position length,
                        int initStyle,
                        WordList *[],
                        Accessor &styler)
 {
 	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
 	int style = initStyle;
-	int startKeyword = 0;
+	Sci_Position startKeyword = 0;
 
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int stylePrev = style;
diff --git a/Pythonwin/Scintilla/lexers/LexPO.cxx b/Pythonwin/Scintilla/lexers/LexPO.cxx
new file mode 100644
index 000000000..875c334f8
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexPO.cxx
@@ -0,0 +1,211 @@
+// Scintilla source code edit control
+/** @file LexPO.cxx
+ ** Lexer for GetText Translation (PO) files.
+ **/
+// Copyright 2012 by Colomban Wendling <ban@herbesfolles.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+// see https://www.gnu.org/software/gettext/manual/gettext.html#PO-Files for the syntax reference
+// some details are taken from the GNU msgfmt behavior (like that indent is allows in front of lines)
+
+// TODO:
+// * add keywords for flags (fuzzy, c-format, ...)
+// * highlight formats inside c-format strings (%s, %d, etc.)
+// * style for previous untranslated string? ("#|" comment)
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static void ColourisePODoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[], Accessor &styler) {
+	StyleContext sc(startPos, length, initStyle, styler);
+	bool escaped = false;
+	Sci_Position curLine = styler.GetLine(startPos);
+	// the line state holds the last state on or before the line that isn't the default style
+	int curLineState = curLine > 0 ? styler.GetLineState(curLine - 1) : SCE_PO_DEFAULT;
+
+	for (; sc.More(); sc.Forward()) {
+		// whether we should leave a state
+		switch (sc.state) {
+			case SCE_PO_COMMENT:
+			case SCE_PO_PROGRAMMER_COMMENT:
+			case SCE_PO_REFERENCE:
+			case SCE_PO_FLAGS:
+			case SCE_PO_FUZZY:
+				if (sc.atLineEnd)
+					sc.SetState(SCE_PO_DEFAULT);
+				else if (sc.state == SCE_PO_FLAGS && sc.Match("fuzzy"))
+					// here we behave like the previous parser, but this should probably be highlighted
+					// on its own like a keyword rather than changing the whole flags style
+					sc.ChangeState(SCE_PO_FUZZY);
+				break;
+
+			case SCE_PO_MSGCTXT:
+			case SCE_PO_MSGID:
+			case SCE_PO_MSGSTR:
+				if (isspacechar(sc.ch))
+					sc.SetState(SCE_PO_DEFAULT);
+				break;
+
+			case SCE_PO_ERROR:
+				if (sc.atLineEnd)
+					sc.SetState(SCE_PO_DEFAULT);
+				break;
+
+			case SCE_PO_MSGCTXT_TEXT:
+			case SCE_PO_MSGID_TEXT:
+			case SCE_PO_MSGSTR_TEXT:
+				if (sc.atLineEnd) { // invalid inside a string
+					if (sc.state == SCE_PO_MSGCTXT_TEXT)
+						sc.ChangeState(SCE_PO_MSGCTXT_TEXT_EOL);
+					else if (sc.state == SCE_PO_MSGID_TEXT)
+						sc.ChangeState(SCE_PO_MSGID_TEXT_EOL);
+					else if (sc.state == SCE_PO_MSGSTR_TEXT)
+						sc.ChangeState(SCE_PO_MSGSTR_TEXT_EOL);
+					sc.SetState(SCE_PO_DEFAULT);
+					escaped = false;
+				} else {
+					if (escaped)
+						escaped = false;
+					else if (sc.ch == '\\')
+						escaped = true;
+					else if (sc.ch == '"')
+						sc.ForwardSetState(SCE_PO_DEFAULT);
+				}
+				break;
+		}
+
+		// whether we should enter a new state
+		if (sc.state == SCE_PO_DEFAULT) {
+			// forward to the first non-white character on the line
+			bool atLineStart = sc.atLineStart;
+			if (atLineStart) {
+				// reset line state if it is set to comment state so empty lines don't get
+				// comment line state, and the folding code folds comments separately,
+				// and anyway the styling don't use line state for comments
+				if (curLineState == SCE_PO_COMMENT)
+					curLineState = SCE_PO_DEFAULT;
+
+				while (sc.More() && ! sc.atLineEnd && isspacechar(sc.ch))
+					sc.Forward();
+			}
+
+			if (atLineStart && sc.ch == '#') {
+				if (sc.chNext == '.')
+					sc.SetState(SCE_PO_PROGRAMMER_COMMENT);
+				else if (sc.chNext == ':')
+					sc.SetState(SCE_PO_REFERENCE);
+				else if (sc.chNext == ',')
+					sc.SetState(SCE_PO_FLAGS);
+				else
+					sc.SetState(SCE_PO_COMMENT);
+			} else if (atLineStart && sc.Match("msgid")) { // includes msgid_plural
+				sc.SetState(SCE_PO_MSGID);
+			} else if (atLineStart && sc.Match("msgstr")) { // includes [] suffixes
+				sc.SetState(SCE_PO_MSGSTR);
+			} else if (atLineStart && sc.Match("msgctxt")) {
+				sc.SetState(SCE_PO_MSGCTXT);
+			} else if (sc.ch == '"') {
+				if (curLineState == SCE_PO_MSGCTXT || curLineState == SCE_PO_MSGCTXT_TEXT)
+					sc.SetState(SCE_PO_MSGCTXT_TEXT);
+				else if (curLineState == SCE_PO_MSGID || curLineState == SCE_PO_MSGID_TEXT)
+					sc.SetState(SCE_PO_MSGID_TEXT);
+				else if (curLineState == SCE_PO_MSGSTR || curLineState == SCE_PO_MSGSTR_TEXT)
+					sc.SetState(SCE_PO_MSGSTR_TEXT);
+				else
+					sc.SetState(SCE_PO_ERROR);
+			} else if (! isspacechar(sc.ch))
+				sc.SetState(SCE_PO_ERROR);
+
+			if (sc.state != SCE_PO_DEFAULT)
+				curLineState = sc.state;
+		}
+
+		if (sc.atLineEnd) {
+			// Update the line state, so it can be seen by next line
+			curLine = styler.GetLine(sc.currentPos);
+			styler.SetLineState(curLine, curLineState);
+		}
+	}
+	sc.Complete();
+}
+
+static int FindNextNonEmptyLineState(Sci_PositionU startPos, Accessor &styler) {
+	Sci_PositionU length = styler.Length();
+	for (Sci_PositionU i = startPos; i < length; i++) {
+		if (! isspacechar(styler[i])) {
+			return styler.GetLineState(styler.GetLine(i));
+		}
+	}
+	return 0;
+}
+
+static void FoldPODoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
+	if (! styler.GetPropertyInt("fold"))
+		return;
+	bool foldCompact = styler.GetPropertyInt("fold.compact") != 0;
+	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+
+	Sci_PositionU endPos = startPos + length;
+	Sci_Position curLine = styler.GetLine(startPos);
+	int lineState = styler.GetLineState(curLine);
+	int nextLineState;
+	int level = styler.LevelAt(curLine) & SC_FOLDLEVELNUMBERMASK;
+	int nextLevel;
+	int visible = 0;
+	int chNext = styler[startPos];
+
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		int ch = chNext;
+		chNext = styler.SafeGetCharAt(i+1);
+
+		if (! isspacechar(ch)) {
+			visible++;
+		} else if ((ch == '\r' && chNext != '\n') || ch == '\n' || i+1 >= endPos) {
+			int lvl = level;
+			Sci_Position nextLine = curLine + 1;
+
+			nextLineState = styler.GetLineState(nextLine);
+			if ((lineState != SCE_PO_COMMENT || foldComment) &&
+					nextLineState == lineState &&
+					FindNextNonEmptyLineState(i, styler) == lineState)
+				nextLevel = SC_FOLDLEVELBASE + 1;
+			else
+				nextLevel = SC_FOLDLEVELBASE;
+
+			if (nextLevel > level)
+				lvl |= SC_FOLDLEVELHEADERFLAG;
+			if (visible == 0 && foldCompact)
+				lvl |= SC_FOLDLEVELWHITEFLAG;
+
+			styler.SetLevel(curLine, lvl);
+
+			lineState = nextLineState;
+			curLine = nextLine;
+			level = nextLevel;
+			visible = 0;
+		}
+	}
+}
+
+static const char *const poWordListDesc[] = {
+	0
+};
+
+LexerModule lmPO(SCLEX_PO, ColourisePODoc, "po", FoldPODoc, poWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexPOV.cxx b/Pythonwin/Scintilla/lexers/LexPOV.cxx
similarity index 95%
rename from Pythonwin/Scintilla/src/LexPOV.cxx
rename to Pythonwin/Scintilla/lexers/LexPOV.cxx
index b845b2d47..40d0d2e9d 100644
--- a/Pythonwin/Scintilla/src/LexPOV.cxx
+++ b/Pythonwin/Scintilla/lexers/LexPOV.cxx
@@ -16,22 +16,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static inline bool IsAWordChar(int ch) {
 	return ch < 0x80 && (isalnum(ch) || ch == '_');
@@ -50,8 +51,8 @@ static inline bool IsANumberChar(int ch) {
 }
 
 static void ColourisePovDoc(
-	unsigned int startPos,
-	int length,
+	Sci_PositionU startPos,
+	Sci_Position length,
 	int initStyle,
 	WordList *keywordlists[],
     Accessor &styler) {
@@ -65,7 +66,7 @@ static void ColourisePovDoc(
 	WordList &keywords7 = *keywordlists[6];
 	WordList &keywords8 = *keywordlists[7];
 
-	int currentLine = styler.GetLine(startPos);
+	Sci_Position currentLine = styler.GetLine(startPos);
 	// Initialize the block comment /* */ nesting level, if we are inside such a comment.
 	int blockCommentLevel = 0;
 	if (initStyle == SCE_POV_COMMENT) {
@@ -223,8 +224,8 @@ static void ColourisePovDoc(
 }
 
 static void FoldPovDoc(
-	unsigned int startPos,
-	int length,
+	Sci_PositionU startPos,
+	Sci_Position length,
 	int initStyle,
 	WordList *[],
 	Accessor &styler) {
@@ -232,15 +233,15 @@ static void FoldPovDoc(
 	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
 	bool foldDirective = styler.GetPropertyInt("fold.directive") != 0;
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
 	int style = initStyle;
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int stylePrev = style;
@@ -267,7 +268,7 @@ static void FoldPovDoc(
 		}
 		if (foldDirective && (style == SCE_POV_DIRECTIVE)) {
 			if (ch == '#') {
-				unsigned int j=i+1;
+				Sci_PositionU j=i+1;
 				while ((j<endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
 					j++;
 				}
diff --git a/Pythonwin/Scintilla/src/LexPS.cxx b/Pythonwin/Scintilla/lexers/LexPS.cxx
similarity index 89%
rename from Pythonwin/Scintilla/src/LexPS.cxx
rename to Pythonwin/Scintilla/lexers/LexPS.cxx
index 2edcff150..b7158e9bb 100644
--- a/Pythonwin/Scintilla/src/LexPS.cxx
+++ b/Pythonwin/Scintilla/lexers/LexPS.cxx
@@ -6,24 +6,31 @@
  ** The License.txt file describes the conditions under which this software may be distributed.
  **/
 
+// Previous releases of this lexer included support for marking token starts with
+// a style byte indicator. This was used by the wxGhostscript IDE/debugger.
+// Style byte indicators were removed in version 3.4.3.
+// Anyone wanting to restore this functionality for wxGhostscript using 'modern'
+// indicators can examine the earlier source in the Mercurial repository.
+
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
-#include <stdarg.h>
 #include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static inline bool IsASelfDelimitingChar(const int ch) {
     return (ch == '[' || ch == ']' || ch == '{' || ch == '}' ||
@@ -55,8 +62,8 @@ static inline bool IsABase85Char(const int ch) {
 }
 
 static void ColourisePSDoc(
-    unsigned int startPos,
-    int length,
+    Sci_PositionU startPos,
+    Sci_Position length,
     int initStyle,
     WordList *keywordlists[],
     Accessor &styler) {
@@ -69,9 +76,8 @@ static void ColourisePSDoc(
 
     StyleContext sc(startPos, length, initStyle, styler);
 
-    bool tokenizing = styler.GetPropertyInt("ps.tokenize") != 0;
     int pslevel = styler.GetPropertyInt("ps.level", 3);
-    int lineCurrent = styler.GetLine(startPos);
+    Sci_Position lineCurrent = styler.GetLine(startPos);
     int nestTextCurrent = 0;
     if (lineCurrent > 0 && initStyle == SCE_PS_TEXT)
         nestTextCurrent = styler.GetLineState(lineCurrent - 1);
@@ -80,15 +86,6 @@ static void ColourisePSDoc(
     bool numHasExponent = false;
     bool numHasSign = false;
 
-    // Clear out existing tokenization
-    if (tokenizing && length > 0) {
-        styler.StartAt(startPos, static_cast<char>(INDIC2_MASK));
-        styler.ColourTo(startPos + length-1, 0);
-        styler.Flush();
-        styler.StartAt(startPos);
-        styler.StartSegment(startPos);
-    }
-
     for (; sc.More(); sc.Forward()) {
         if (sc.atLineStart)
             lineCurrent = styler.GetLine(sc.currentPos);
@@ -193,7 +190,6 @@ static void ColourisePSDoc(
 
         // Determine if a new state should be entered.
         if (sc.state == SCE_C_DEFAULT) {
-            unsigned int tokenpos = sc.currentPos;
 
             if (sc.ch == '[' || sc.ch == ']') {
                 sc.SetState(SCE_PS_PAREN_ARRAY);
@@ -259,17 +255,6 @@ static void ColourisePSDoc(
             } else if (!IsAWhitespaceChar(sc.ch)) {
                 sc.SetState(SCE_PS_NAME);
             }
-
-            // Mark the start of tokens
-            if (tokenizing && sc.state != SCE_C_DEFAULT && sc.state != SCE_PS_COMMENT &&
-                sc.state != SCE_PS_DSC_COMMENT && sc.state != SCE_PS_DSC_VALUE) {
-                styler.Flush();
-                styler.StartAt(tokenpos, static_cast<char>(INDIC2_MASK));
-                styler.ColourTo(tokenpos, INDIC2_MASK);
-                styler.Flush();
-                styler.StartAt(tokenpos);
-                styler.StartSegment(tokenpos);
-            }
         }
 
         if (sc.atLineEnd)
@@ -279,13 +264,13 @@ static void ColourisePSDoc(
     sc.Complete();
 }
 
-static void FoldPSDoc(unsigned int startPos, int length, int, WordList *[],
+static void FoldPSDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[],
                        Accessor &styler) {
     bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
     bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0;
-    unsigned int endPos = startPos + length;
+    Sci_PositionU endPos = startPos + length;
     int visibleChars = 0;
-    int lineCurrent = styler.GetLine(startPos);
+    Sci_Position lineCurrent = styler.GetLine(startPos);
     int levelCurrent = SC_FOLDLEVELBASE;
     if (lineCurrent > 0)
         levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
@@ -293,11 +278,10 @@ static void FoldPSDoc(unsigned int startPos, int length, int, WordList *[],
     int levelNext = levelCurrent;
     char chNext = styler[startPos];
     int styleNext = styler.StyleAt(startPos);
-    int style;
-    for (unsigned int i = startPos; i < endPos; i++) {
+    for (Sci_PositionU i = startPos; i < endPos; i++) {
         char ch = chNext;
         chNext = styler.SafeGetCharAt(i + 1);
-        style = styleNext;
+        int style = styleNext;
         styleNext = styler.StyleAt(i + 1);
         bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');  //mac??
         if ((style & 31) == SCE_PS_PAREN_PROC) {
diff --git a/Pythonwin/Scintilla/lexers/LexPascal.cxx b/Pythonwin/Scintilla/lexers/LexPascal.cxx
new file mode 100644
index 000000000..426b3c3f3
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexPascal.cxx
@@ -0,0 +1,613 @@
+// Scintilla source code edit control
+/** @file LexPascal.cxx
+ ** Lexer for Pascal.
+ ** Written by Laurent le Tynevez
+ ** Updated by Simon Steele <s.steele@pnotepad.org> September 2002
+ ** Updated by Mathias Rauen <scite@madshi.net> May 2003 (Delphi adjustments)
+ ** Completely rewritten by Marko Njezic <sf@maxempire.com> October 2008
+ **/
+
+/*
+
+A few words about features of the new completely rewritten LexPascal...
+
+Generally speaking LexPascal tries to support all available Delphi features (up
+to Delphi XE4 at this time).
+
+~ HIGHLIGHTING:
+
+If you enable "lexer.pascal.smart.highlighting" property, some keywords will
+only be highlighted in appropriate context. As implemented those are keywords
+related to property and DLL exports declarations (similar to how Delphi IDE
+works).
+
+For example, keywords "read" and "write" will only be highlighted if they are in
+property declaration:
+
+property MyProperty: boolean read FMyProperty write FMyProperty;
+
+~ FOLDING:
+
+Folding is supported in the following cases:
+
+- Folding of stream-like comments
+- Folding of groups of consecutive line comments
+- Folding of preprocessor blocks (the following preprocessor blocks are
+supported: IF / IFEND; IFDEF, IFNDEF, IFOPT / ENDIF and REGION / ENDREGION
+blocks), including nesting of preprocessor blocks up to 255 levels
+- Folding of code blocks on appropriate keywords (the following code blocks are
+supported: "begin, asm, record, try, case / end" blocks, class & object
+declarations and interface declarations)
+
+Remarks:
+
+- Folding of code blocks tries to handle all special cases in which folding
+should not occur. As implemented those are:
+
+1. Structure "record case / end" (there's only one "end" statement and "case" is
+ignored as fold point)
+2. Forward class declarations ("type TMyClass = class;") and object method
+declarations ("TNotifyEvent = procedure(Sender: TObject) of object;") are
+ignored as fold points
+3. Simplified complete class declarations ("type TMyClass = class(TObject);")
+are ignored as fold points
+4. Every other situation when class keyword doesn't actually start class
+declaration ("class procedure", "class function", "class of", "class var",
+"class property" and "class operator")
+5. Forward (disp)interface declarations ("type IMyInterface = interface;") are
+ignored as fold points
+
+- Folding of code blocks inside preprocessor blocks is disabled (any comments
+inside them will be folded fine) because there is no guarantee that complete
+code block will be contained inside folded preprocessor block in which case
+folded code block could end prematurely at the end of preprocessor block if
+there is no closing statement inside. This was done in order to properly process
+document that may contain something like this:
+
+type
+{$IFDEF UNICODE}
+  TMyClass = class(UnicodeAncestor)
+{$ELSE}
+  TMyClass = class(AnsiAncestor)
+{$ENDIF}
+  private
+  ...
+  public
+  ...
+  published
+  ...
+end;
+
+If class declarations were folded, then the second class declaration would end
+at "$ENDIF" statement, first class statement would end at "end;" statement and
+preprocessor "$IFDEF" block would go all the way to the end of document.
+However, having in mind all this, if you want to enable folding of code blocks
+inside preprocessor blocks, you can disable folding of preprocessor blocks by
+changing "fold.preprocessor" property, in which case everything inside them
+would be folded.
+
+~ KEYWORDS:
+
+The list of keywords that can be used in pascal.properties file (up to Delphi
+XE4):
+
+- Keywords: absolute abstract and array as asm assembler automated begin case
+cdecl class const constructor delayed deprecated destructor dispid dispinterface
+div do downto dynamic else end except experimental export exports external far
+file final finalization finally for forward function goto helper if
+implementation in inherited initialization inline interface is label library
+message mod near nil not object of on operator or out overload override packed
+pascal platform private procedure program property protected public published
+raise record reference register reintroduce repeat resourcestring safecall
+sealed set shl shr static stdcall strict string then threadvar to try type unit
+unsafe until uses var varargs virtual while winapi with xor
+
+- Keywords related to the "smart highlithing" feature: add default implements
+index name nodefault read readonly remove stored write writeonly
+
+- Keywords related to Delphi packages (in addition to all above): package
+contains requires
+
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static void GetRangeLowered(Sci_PositionU start,
+		Sci_PositionU end,
+		Accessor &styler,
+		char *s,
+		Sci_PositionU len) {
+	Sci_PositionU i = 0;
+	while ((i < end - start + 1) && (i < len-1)) {
+		s[i] = static_cast<char>(tolower(styler[start + i]));
+		i++;
+	}
+	s[i] = '\0';
+}
+
+static void GetForwardRangeLowered(Sci_PositionU start,
+		CharacterSet &charSet,
+		Accessor &styler,
+		char *s,
+		Sci_PositionU len) {
+	Sci_PositionU i = 0;
+	while ((i < len-1) && charSet.Contains(styler.SafeGetCharAt(start + i))) {
+		s[i] = static_cast<char>(tolower(styler.SafeGetCharAt(start + i)));
+		i++;
+	}
+	s[i] = '\0';
+
+}
+
+enum {
+	stateInAsm = 0x1000,
+	stateInProperty = 0x2000,
+	stateInExport = 0x4000,
+	stateFoldInPreprocessor = 0x0100,
+	stateFoldInRecord = 0x0200,
+	stateFoldInPreprocessorLevelMask = 0x00FF,
+	stateFoldMaskAll = 0x0FFF
+};
+
+static void ClassifyPascalWord(WordList *keywordlists[], StyleContext &sc, int &curLineState, bool bSmartHighlighting) {
+	WordList& keywords = *keywordlists[0];
+
+	char s[100];
+	sc.GetCurrentLowered(s, sizeof(s));
+	if (keywords.InList(s)) {
+		if (curLineState & stateInAsm) {
+			if (strcmp(s, "end") == 0 && sc.GetRelative(-4) != '@') {
+				curLineState &= ~stateInAsm;
+				sc.ChangeState(SCE_PAS_WORD);
+			} else {
+				sc.ChangeState(SCE_PAS_ASM);
+			}
+		} else {
+			bool ignoreKeyword = false;
+			if (strcmp(s, "asm") == 0) {
+				curLineState |= stateInAsm;
+			} else if (bSmartHighlighting) {
+				if (strcmp(s, "property") == 0) {
+					curLineState |= stateInProperty;
+				} else if (strcmp(s, "exports") == 0) {
+					curLineState |= stateInExport;
+				} else if (!(curLineState & (stateInProperty | stateInExport)) && strcmp(s, "index") == 0) {
+					ignoreKeyword = true;
+				} else if (!(curLineState & stateInExport) && strcmp(s, "name") == 0) {
+					ignoreKeyword = true;
+				} else if (!(curLineState & stateInProperty) &&
+					(strcmp(s, "read") == 0 || strcmp(s, "write") == 0 ||
+					 strcmp(s, "default") == 0 || strcmp(s, "nodefault") == 0 ||
+					 strcmp(s, "stored") == 0 || strcmp(s, "implements") == 0 ||
+					 strcmp(s, "readonly") == 0 || strcmp(s, "writeonly") == 0 ||
+					 strcmp(s, "add") == 0 || strcmp(s, "remove") == 0)) {
+					ignoreKeyword = true;
+				}
+			}
+			if (!ignoreKeyword) {
+				sc.ChangeState(SCE_PAS_WORD);
+			}
+		}
+	} else if (curLineState & stateInAsm) {
+		sc.ChangeState(SCE_PAS_ASM);
+	}
+	sc.SetState(SCE_PAS_DEFAULT);
+}
+
+static void ColourisePascalDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+		Accessor &styler) {
+	bool bSmartHighlighting = styler.GetPropertyInt("lexer.pascal.smart.highlighting", 1) != 0;
+
+	CharacterSet setWordStart(CharacterSet::setAlpha, "_", 0x80, true);
+	CharacterSet setWord(CharacterSet::setAlphaNum, "_", 0x80, true);
+	CharacterSet setNumber(CharacterSet::setDigits, ".-+eE");
+	CharacterSet setHexNumber(CharacterSet::setDigits, "abcdefABCDEF");
+	CharacterSet setOperator(CharacterSet::setNone, "#$&'()*+,-./:;<=>@[]^{}");
+
+	Sci_Position curLine = styler.GetLine(startPos);
+	int curLineState = curLine > 0 ? styler.GetLineState(curLine - 1) : 0;
+
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	for (; sc.More(); sc.Forward()) {
+		if (sc.atLineEnd) {
+			// Update the line state, so it can be seen by next line
+			curLine = styler.GetLine(sc.currentPos);
+			styler.SetLineState(curLine, curLineState);
+		}
+
+		// Determine if the current state should terminate.
+		switch (sc.state) {
+			case SCE_PAS_NUMBER:
+				if (!setNumber.Contains(sc.ch) || (sc.ch == '.' && sc.chNext == '.')) {
+					sc.SetState(SCE_PAS_DEFAULT);
+				} else if (sc.ch == '-' || sc.ch == '+') {
+					if (sc.chPrev != 'E' && sc.chPrev != 'e') {
+						sc.SetState(SCE_PAS_DEFAULT);
+					}
+				}
+				break;
+			case SCE_PAS_IDENTIFIER:
+				if (!setWord.Contains(sc.ch)) {
+					ClassifyPascalWord(keywordlists, sc, curLineState, bSmartHighlighting);
+				}
+				break;
+			case SCE_PAS_HEXNUMBER:
+				if (!setHexNumber.Contains(sc.ch)) {
+					sc.SetState(SCE_PAS_DEFAULT);
+				}
+				break;
+			case SCE_PAS_COMMENT:
+			case SCE_PAS_PREPROCESSOR:
+				if (sc.ch == '}') {
+					sc.ForwardSetState(SCE_PAS_DEFAULT);
+				}
+				break;
+			case SCE_PAS_COMMENT2:
+			case SCE_PAS_PREPROCESSOR2:
+				if (sc.Match('*', ')')) {
+					sc.Forward();
+					sc.ForwardSetState(SCE_PAS_DEFAULT);
+				}
+				break;
+			case SCE_PAS_COMMENTLINE:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_PAS_DEFAULT);
+				}
+				break;
+			case SCE_PAS_STRING:
+				if (sc.atLineEnd) {
+					sc.ChangeState(SCE_PAS_STRINGEOL);
+				} else if (sc.ch == '\'' && sc.chNext == '\'') {
+					sc.Forward();
+				} else if (sc.ch == '\'') {
+					sc.ForwardSetState(SCE_PAS_DEFAULT);
+				}
+				break;
+			case SCE_PAS_STRINGEOL:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_PAS_DEFAULT);
+				}
+				break;
+			case SCE_PAS_CHARACTER:
+				if (!setHexNumber.Contains(sc.ch) && sc.ch != '$') {
+					sc.SetState(SCE_PAS_DEFAULT);
+				}
+				break;
+			case SCE_PAS_OPERATOR:
+				if (bSmartHighlighting && sc.chPrev == ';') {
+					curLineState &= ~(stateInProperty | stateInExport);
+				}
+				sc.SetState(SCE_PAS_DEFAULT);
+				break;
+			case SCE_PAS_ASM:
+				sc.SetState(SCE_PAS_DEFAULT);
+				break;
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_PAS_DEFAULT) {
+			if (IsADigit(sc.ch) && !(curLineState & stateInAsm)) {
+				sc.SetState(SCE_PAS_NUMBER);
+			} else if (setWordStart.Contains(sc.ch)) {
+				sc.SetState(SCE_PAS_IDENTIFIER);
+			} else if (sc.ch == '$' && !(curLineState & stateInAsm)) {
+				sc.SetState(SCE_PAS_HEXNUMBER);
+			} else if (sc.Match('{', '$')) {
+				sc.SetState(SCE_PAS_PREPROCESSOR);
+			} else if (sc.ch == '{') {
+				sc.SetState(SCE_PAS_COMMENT);
+			} else if (sc.Match("(*$")) {
+				sc.SetState(SCE_PAS_PREPROCESSOR2);
+			} else if (sc.Match('(', '*')) {
+				sc.SetState(SCE_PAS_COMMENT2);
+				sc.Forward();	// Eat the * so it isn't used for the end of the comment
+			} else if (sc.Match('/', '/')) {
+				sc.SetState(SCE_PAS_COMMENTLINE);
+			} else if (sc.ch == '\'') {
+				sc.SetState(SCE_PAS_STRING);
+			} else if (sc.ch == '#') {
+				sc.SetState(SCE_PAS_CHARACTER);
+			} else if (setOperator.Contains(sc.ch) && !(curLineState & stateInAsm)) {
+				sc.SetState(SCE_PAS_OPERATOR);
+			} else if (curLineState & stateInAsm) {
+				sc.SetState(SCE_PAS_ASM);
+			}
+		}
+	}
+
+	if (sc.state == SCE_PAS_IDENTIFIER && setWord.Contains(sc.chPrev)) {
+		ClassifyPascalWord(keywordlists, sc, curLineState, bSmartHighlighting);
+	}
+
+	sc.Complete();
+}
+
+static bool IsStreamCommentStyle(int style) {
+	return style == SCE_PAS_COMMENT || style == SCE_PAS_COMMENT2;
+}
+
+static bool IsCommentLine(Sci_Position line, Accessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eolPos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eolPos; i++) {
+		char ch = styler[i];
+		char chNext = styler.SafeGetCharAt(i + 1);
+		int style = styler.StyleAt(i);
+		if (ch == '/' && chNext == '/' && style == SCE_PAS_COMMENTLINE) {
+			return true;
+		} else if (!IsASpaceOrTab(ch)) {
+			return false;
+		}
+	}
+	return false;
+}
+
+static unsigned int GetFoldInPreprocessorLevelFlag(int lineFoldStateCurrent) {
+	return lineFoldStateCurrent & stateFoldInPreprocessorLevelMask;
+}
+
+static void SetFoldInPreprocessorLevelFlag(int &lineFoldStateCurrent, unsigned int nestLevel) {
+	lineFoldStateCurrent &= ~stateFoldInPreprocessorLevelMask;
+	lineFoldStateCurrent |= nestLevel & stateFoldInPreprocessorLevelMask;
+}
+
+static void ClassifyPascalPreprocessorFoldPoint(int &levelCurrent, int &lineFoldStateCurrent,
+		Sci_PositionU startPos, Accessor &styler) {
+	CharacterSet setWord(CharacterSet::setAlpha);
+
+	char s[11];	// Size of the longest possible keyword + one additional character + null
+	GetForwardRangeLowered(startPos, setWord, styler, s, sizeof(s));
+
+	unsigned int nestLevel = GetFoldInPreprocessorLevelFlag(lineFoldStateCurrent);
+
+	if (strcmp(s, "if") == 0 ||
+		strcmp(s, "ifdef") == 0 ||
+		strcmp(s, "ifndef") == 0 ||
+		strcmp(s, "ifopt") == 0 ||
+		strcmp(s, "region") == 0) {
+		nestLevel++;
+		SetFoldInPreprocessorLevelFlag(lineFoldStateCurrent, nestLevel);
+		lineFoldStateCurrent |= stateFoldInPreprocessor;
+		levelCurrent++;
+	} else if (strcmp(s, "endif") == 0 ||
+		strcmp(s, "ifend") == 0 ||
+		strcmp(s, "endregion") == 0) {
+		nestLevel--;
+		SetFoldInPreprocessorLevelFlag(lineFoldStateCurrent, nestLevel);
+		if (nestLevel == 0) {
+			lineFoldStateCurrent &= ~stateFoldInPreprocessor;
+		}
+		levelCurrent--;
+		if (levelCurrent < SC_FOLDLEVELBASE) {
+			levelCurrent = SC_FOLDLEVELBASE;
+		}
+	}
+}
+
+static Sci_PositionU SkipWhiteSpace(Sci_PositionU currentPos, Sci_PositionU endPos,
+		Accessor &styler, bool includeChars = false) {
+	CharacterSet setWord(CharacterSet::setAlphaNum, "_");
+	Sci_PositionU j = currentPos + 1;
+	char ch = styler.SafeGetCharAt(j);
+	while ((j < endPos) && (IsASpaceOrTab(ch) || ch == '\r' || ch == '\n' ||
+		IsStreamCommentStyle(styler.StyleAt(j)) || (includeChars && setWord.Contains(ch)))) {
+		j++;
+		ch = styler.SafeGetCharAt(j);
+	}
+	return j;
+}
+
+static void ClassifyPascalWordFoldPoint(int &levelCurrent, int &lineFoldStateCurrent,
+		Sci_Position startPos, Sci_PositionU endPos,
+		Sci_PositionU lastStart, Sci_PositionU currentPos, Accessor &styler) {
+	char s[100];
+	GetRangeLowered(lastStart, currentPos, styler, s, sizeof(s));
+
+	if (strcmp(s, "record") == 0) {
+		lineFoldStateCurrent |= stateFoldInRecord;
+		levelCurrent++;
+	} else if (strcmp(s, "begin") == 0 ||
+		strcmp(s, "asm") == 0 ||
+		strcmp(s, "try") == 0 ||
+		(strcmp(s, "case") == 0 && !(lineFoldStateCurrent & stateFoldInRecord))) {
+		levelCurrent++;
+	} else if (strcmp(s, "class") == 0 || strcmp(s, "object") == 0) {
+		// "class" & "object" keywords require special handling...
+		bool ignoreKeyword = false;
+		Sci_PositionU j = SkipWhiteSpace(currentPos, endPos, styler);
+		if (j < endPos) {
+			CharacterSet setWordStart(CharacterSet::setAlpha, "_");
+			CharacterSet setWord(CharacterSet::setAlphaNum, "_");
+
+			if (styler.SafeGetCharAt(j) == ';') {
+				// Handle forward class declarations ("type TMyClass = class;")
+				// and object method declarations ("TNotifyEvent = procedure(Sender: TObject) of object;")
+				ignoreKeyword = true;
+			} else if (strcmp(s, "class") == 0) {
+				// "class" keyword has a few more special cases...
+				if (styler.SafeGetCharAt(j) == '(') {
+					// Handle simplified complete class declarations ("type TMyClass = class(TObject);")
+					j = SkipWhiteSpace(j, endPos, styler, true);
+					if (j < endPos && styler.SafeGetCharAt(j) == ')') {
+						j = SkipWhiteSpace(j, endPos, styler);
+						if (j < endPos && styler.SafeGetCharAt(j) == ';') {
+							ignoreKeyword = true;
+						}
+					}
+				} else if (setWordStart.Contains(styler.SafeGetCharAt(j))) {
+					char s2[11];	// Size of the longest possible keyword + one additional character + null
+					GetForwardRangeLowered(j, setWord, styler, s2, sizeof(s2));
+
+					if (strcmp(s2, "procedure") == 0 ||
+						strcmp(s2, "function") == 0 ||
+						strcmp(s2, "of") == 0 ||
+						strcmp(s2, "var") == 0 ||
+						strcmp(s2, "property") == 0 ||
+						strcmp(s2, "operator") == 0) {
+						ignoreKeyword = true;
+					}
+				}
+			}
+		}
+		if (!ignoreKeyword) {
+			levelCurrent++;
+		}
+	} else if (strcmp(s, "interface") == 0) {
+		// "interface" keyword requires special handling...
+		bool ignoreKeyword = true;
+		Sci_Position j = lastStart - 1;
+		char ch = styler.SafeGetCharAt(j);
+		while ((j >= startPos) && (IsASpaceOrTab(ch) || ch == '\r' || ch == '\n' ||
+			IsStreamCommentStyle(styler.StyleAt(j)))) {
+			j--;
+			ch = styler.SafeGetCharAt(j);
+		}
+		if (j >= startPos && styler.SafeGetCharAt(j) == '=') {
+			ignoreKeyword = false;
+		}
+		if (!ignoreKeyword) {
+			Sci_PositionU k = SkipWhiteSpace(currentPos, endPos, styler);
+			if (k < endPos && styler.SafeGetCharAt(k) == ';') {
+				// Handle forward interface declarations ("type IMyInterface = interface;")
+				ignoreKeyword = true;
+			}
+		}
+		if (!ignoreKeyword) {
+			levelCurrent++;
+		}
+	} else if (strcmp(s, "dispinterface") == 0) {
+		// "dispinterface" keyword requires special handling...
+		bool ignoreKeyword = false;
+		Sci_PositionU j = SkipWhiteSpace(currentPos, endPos, styler);
+		if (j < endPos && styler.SafeGetCharAt(j) == ';') {
+			// Handle forward dispinterface declarations ("type IMyInterface = dispinterface;")
+			ignoreKeyword = true;
+		}
+		if (!ignoreKeyword) {
+			levelCurrent++;
+		}
+	} else if (strcmp(s, "end") == 0) {
+		lineFoldStateCurrent &= ~stateFoldInRecord;
+		levelCurrent--;
+		if (levelCurrent < SC_FOLDLEVELBASE) {
+			levelCurrent = SC_FOLDLEVELBASE;
+		}
+	}
+}
+
+static void FoldPascalDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[],
+		Accessor &styler) {
+	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+	bool foldPreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0;
+	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
+	int levelCurrent = levelPrev;
+	int lineFoldStateCurrent = lineCurrent > 0 ? styler.GetLineState(lineCurrent - 1) & stateFoldMaskAll : 0;
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+
+	Sci_Position lastStart = 0;
+	CharacterSet setWord(CharacterSet::setAlphaNum, "_", 0x80, true);
+
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int stylePrev = style;
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+
+		if (foldComment && IsStreamCommentStyle(style)) {
+			if (!IsStreamCommentStyle(stylePrev)) {
+				levelCurrent++;
+			} else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
+				// Comments don't end at end of line and the next character may be unstyled.
+				levelCurrent--;
+			}
+		}
+		if (foldComment && atEOL && IsCommentLine(lineCurrent, styler))
+		{
+			if (!IsCommentLine(lineCurrent - 1, styler)
+			    && IsCommentLine(lineCurrent + 1, styler))
+				levelCurrent++;
+			else if (IsCommentLine(lineCurrent - 1, styler)
+			         && !IsCommentLine(lineCurrent+1, styler))
+				levelCurrent--;
+		}
+		if (foldPreprocessor) {
+			if (style == SCE_PAS_PREPROCESSOR && ch == '{' && chNext == '$') {
+				ClassifyPascalPreprocessorFoldPoint(levelCurrent, lineFoldStateCurrent, i + 2, styler);
+			} else if (style == SCE_PAS_PREPROCESSOR2 && ch == '(' && chNext == '*'
+			           && styler.SafeGetCharAt(i + 2) == '$') {
+				ClassifyPascalPreprocessorFoldPoint(levelCurrent, lineFoldStateCurrent, i + 3, styler);
+			}
+		}
+
+		if (stylePrev != SCE_PAS_WORD && style == SCE_PAS_WORD)
+		{
+			// Store last word start point.
+			lastStart = i;
+		}
+		if (stylePrev == SCE_PAS_WORD && !(lineFoldStateCurrent & stateFoldInPreprocessor)) {
+			if(setWord.Contains(ch) && !setWord.Contains(chNext)) {
+				ClassifyPascalWordFoldPoint(levelCurrent, lineFoldStateCurrent, startPos, endPos, lastStart, i, styler);
+			}
+		}
+
+		if (!IsASpace(ch))
+			visibleChars++;
+
+		if (atEOL) {
+			int lev = levelPrev;
+			if (visibleChars == 0 && foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if ((levelCurrent > levelPrev) && (visibleChars > 0))
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			int newLineState = (styler.GetLineState(lineCurrent) & ~stateFoldMaskAll) | lineFoldStateCurrent;
+			styler.SetLineState(lineCurrent, newLineState);
+			lineCurrent++;
+			levelPrev = levelCurrent;
+			visibleChars = 0;
+		}
+	}
+
+	// If we didn't reach the EOL in previous loop, store line level and whitespace information.
+	// The rest will be filled in later...
+	int lev = levelPrev;
+	if (visibleChars == 0 && foldCompact)
+		lev |= SC_FOLDLEVELWHITEFLAG;
+	styler.SetLevel(lineCurrent, lev);
+}
+
+static const char * const pascalWordListDesc[] = {
+	"Keywords",
+	0
+};
+
+LexerModule lmPascal(SCLEX_PASCAL, ColourisePascalDoc, "pascal", FoldPascalDoc, pascalWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexPerl.cxx b/Pythonwin/Scintilla/lexers/LexPerl.cxx
new file mode 100644
index 000000000..705463991
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexPerl.cxx
@@ -0,0 +1,1848 @@
+// Scintilla source code edit control
+/** @file LexPerl.cxx
+ ** Lexer for Perl.
+ ** Converted to lexer object by "Udo Lechner" <dlchnr(at)gmx(dot)net>
+ **/
+// Copyright 1998-2008 by Neil Hodgson <neilh@scintilla.org>
+// Lexical analysis fixes by Kein-Hong Man <mkh@pl.jaring.my>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+#include <map>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+// Info for HERE document handling from perldata.pod (reformatted):
+// ----------------------------------------------------------------
+// A line-oriented form of quoting is based on the shell ``here-doc'' syntax.
+// Following a << you specify a string to terminate the quoted material, and
+// all lines following the current line down to the terminating string are
+// the value of the item.
+// Prefixing the terminating string with a "~" specifies that you want to
+// use "Indented Here-docs" (see below).
+// * The terminating string may be either an identifier (a word), or some
+//   quoted text.
+// * If quoted, the type of quotes you use determines the treatment of the
+//   text, just as in regular quoting.
+// * An unquoted identifier works like double quotes.
+// * There must be no space between the << and the identifier.
+//   (If you put a space it will be treated as a null identifier,
+//    which is valid, and matches the first empty line.)
+//   (This is deprecated, -w warns of this syntax)
+// * The terminating string must appear by itself (unquoted and
+//   with no surrounding whitespace) on the terminating line.
+//
+// Indented Here-docs
+// ------------------
+// The here-doc modifier "~" allows you to indent your here-docs to
+// make the code more readable.
+// The delimiter is used to determine the exact whitespace to remove
+// from the beginning of each line. All lines must have at least the
+// same starting whitespace (except lines only containing a newline)
+// or perl will croak. Tabs and spaces can be mixed, but are matched
+// exactly. One tab will not be equal to 8 spaces!
+// Additional beginning whitespace (beyond what preceded the
+// delimiter) will be preserved.
+
+#define HERE_DELIM_MAX 256		// maximum length of HERE doc delimiter
+
+#define PERLNUM_BINARY		1	// order is significant: 1-3 cannot have a dot
+#define PERLNUM_OCTAL		2
+#define PERLNUM_FLOAT_EXP	3	// exponent part only
+#define PERLNUM_HEX			4	// may be a hex float
+#define PERLNUM_DECIMAL		5	// 1-5 are numbers; 6-7 are strings
+#define PERLNUM_VECTOR		6
+#define PERLNUM_V_VECTOR	7
+#define PERLNUM_BAD			8
+
+#define BACK_NONE		0	// lookback state for bareword disambiguation:
+#define BACK_OPERATOR	1	// whitespace/comments are insignificant
+#define BACK_KEYWORD	2	// operators/keywords are needed for disambiguation
+
+#define SUB_BEGIN		0	// states for subroutine prototype scan:
+#define SUB_HAS_PROTO	1	// only 'prototype' attribute allows prototypes
+#define SUB_HAS_ATTRIB	2	// other attributes can exist leftward
+#define SUB_HAS_MODULE	3	// sub name can have a ::identifier part
+#define SUB_HAS_SUB		4	// 'sub' keyword
+
+// all interpolated styles are different from their parent styles by a constant difference
+// we also assume SCE_PL_STRING_VAR is the interpolated style with the smallest value
+#define	INTERPOLATE_SHIFT	(SCE_PL_STRING_VAR - SCE_PL_STRING)
+
+static bool isPerlKeyword(Sci_PositionU start, Sci_PositionU end, WordList &keywords, LexAccessor &styler) {
+	// old-style keyword matcher; needed because GetCurrent() needs
+	// current segment to be committed, but we may abandon early...
+	char s[100];
+	Sci_PositionU i, len = end - start;
+	if (len > 30) { len = 30; }
+	for (i = 0; i < len; i++, start++) s[i] = styler[start];
+	s[i] = '\0';
+	return keywords.InList(s);
+}
+
+static int disambiguateBareword(LexAccessor &styler, Sci_PositionU bk, Sci_PositionU fw,
+        int backFlag, Sci_PositionU backPos, Sci_PositionU endPos) {
+	// identifiers are recognized by Perl as barewords under some
+	// conditions, the following attempts to do the disambiguation
+	// by looking backward and forward; result in 2 LSB
+	int result = 0;
+	bool moreback = false;		// true if passed newline/comments
+	bool brace = false;			// true if opening brace found
+	// if BACK_NONE, neither operator nor keyword, so skip test
+	if (backFlag == BACK_NONE)
+		return result;
+	// first look backwards past whitespace/comments to set EOL flag
+	// (some disambiguation patterns must be on a single line)
+	if (backPos <= static_cast<Sci_PositionU>(styler.LineStart(styler.GetLine(bk))))
+		moreback = true;
+	// look backwards at last significant lexed item for disambiguation
+	bk = backPos - 1;
+	int ch = static_cast<unsigned char>(styler.SafeGetCharAt(bk));
+	if (ch == '{' && !moreback) {
+		// {bareword: possible variable spec
+		brace = true;
+	} else if ((ch == '&' && styler.SafeGetCharAt(bk - 1) != '&')
+	        // &bareword: subroutine call
+	        || styler.Match(bk - 1, "->")
+	        // ->bareword: part of variable spec
+	        || styler.Match(bk - 1, "::")
+	        // ::bareword: part of module spec
+	        || styler.Match(bk - 2, "sub")) {
+	        // sub bareword: subroutine declaration
+	        // (implied BACK_KEYWORD, no keywords end in 'sub'!)
+		result |= 1;
+	}
+	// next, scan forward after word past tab/spaces only;
+	// if ch isn't one of '[{(,' we can skip the test
+	if ((ch == '{' || ch == '(' || ch == '['|| ch == ',')
+	        && fw < endPos) {
+		while (IsASpaceOrTab(ch = static_cast<unsigned char>(styler.SafeGetCharAt(fw)))
+		        && fw < endPos) {
+			fw++;
+		}
+		if ((ch == '}' && brace)
+		        // {bareword}: variable spec
+		        || styler.Match(fw, "=>")) {
+		        // [{(, bareword=>: hash literal
+			result |= 2;
+		}
+	}
+	return result;
+}
+
+static void skipWhitespaceComment(LexAccessor &styler, Sci_PositionU &p) {
+	// when backtracking, we need to skip whitespace and comments
+	while (p > 0) {
+		const int style = styler.StyleAt(p);
+		if (style != SCE_PL_DEFAULT && style != SCE_PL_COMMENTLINE)
+			break;
+		p--;
+	}
+}
+
+static int findPrevLexeme(LexAccessor &styler, Sci_PositionU &bk, int &style) {
+	// scan backward past whitespace and comments to find a lexeme
+	skipWhitespaceComment(styler, bk);
+	if (bk == 0)
+		return 0;
+	int sz = 1;
+	style = styler.StyleAt(bk);
+	while (bk > 0) {	// find extent of lexeme
+		if (styler.StyleAt(bk - 1) == style) {
+			bk--; sz++;
+		} else
+			break;
+	}
+	return sz;
+}
+
+static int styleBeforeBracePair(LexAccessor &styler, Sci_PositionU bk) {
+	// backtrack to find open '{' corresponding to a '}', balanced
+	// return significant style to be tested for '/' disambiguation
+	int braceCount = 1;
+	if (bk == 0)
+		return SCE_PL_DEFAULT;
+	while (--bk > 0) {
+		if (styler.StyleAt(bk) == SCE_PL_OPERATOR) {
+			int bkch = static_cast<unsigned char>(styler.SafeGetCharAt(bk));
+			if (bkch == ';') {	// early out
+				break;
+			} else if (bkch == '}') {
+				braceCount++;
+			} else if (bkch == '{') {
+				if (--braceCount == 0) break;
+			}
+		}
+	}
+	if (bk > 0 && braceCount == 0) {
+		// balanced { found, bk > 0, skip more whitespace/comments
+		bk--;
+		skipWhitespaceComment(styler, bk);
+		return styler.StyleAt(bk);
+	}
+	return SCE_PL_DEFAULT;
+}
+
+static int styleCheckIdentifier(LexAccessor &styler, Sci_PositionU bk) {
+	// backtrack to classify sub-styles of identifier under test
+	// return sub-style to be tested for '/' disambiguation
+	if (styler.SafeGetCharAt(bk) == '>')	// inputsymbol, like <foo>
+		return 1;
+	// backtrack to check for possible "->" or "::" before identifier
+	while (bk > 0 && styler.StyleAt(bk) == SCE_PL_IDENTIFIER) {
+		bk--;
+	}
+	while (bk > 0) {
+		int bkstyle = styler.StyleAt(bk);
+		if (bkstyle == SCE_PL_DEFAULT
+		        || bkstyle == SCE_PL_COMMENTLINE) {
+			// skip whitespace, comments
+		} else if (bkstyle == SCE_PL_OPERATOR) {
+			// test for "->" and "::"
+			if (styler.Match(bk - 1, "->") || styler.Match(bk - 1, "::"))
+				return 2;
+		} else
+			return 3;	// bare identifier
+		bk--;
+	}
+	return 0;
+}
+
+static int podLineScan(LexAccessor &styler, Sci_PositionU &pos, Sci_PositionU endPos) {
+	// forward scan the current line to classify line for POD style
+	int state = -1;
+	while (pos < endPos) {
+		int ch = static_cast<unsigned char>(styler.SafeGetCharAt(pos));
+		if (ch == '\n' || ch == '\r') {
+			if (ch == '\r' && styler.SafeGetCharAt(pos + 1) == '\n') pos++;
+			break;
+		}
+		if (IsASpaceOrTab(ch)) {	// whitespace, take note
+			if (state == -1)
+				state = SCE_PL_DEFAULT;
+		} else if (state == SCE_PL_DEFAULT) {	// verbatim POD line
+			state = SCE_PL_POD_VERB;
+		} else if (state != SCE_PL_POD_VERB) {	// regular POD line
+			state = SCE_PL_POD;
+		}
+		pos++;
+	}
+	if (state == -1)
+		state = SCE_PL_DEFAULT;
+	return state;
+}
+
+static bool styleCheckSubPrototype(LexAccessor &styler, Sci_PositionU bk) {
+	// backtrack to identify if we're starting a subroutine prototype
+	// we also need to ignore whitespace/comments, format is like:
+	//     sub abc::pqr :const :prototype(...)
+	// lexemes are tested in pairs, e.g. '::'+'pqr', ':'+'const', etc.
+	// and a state machine generates legal subroutine syntax matches
+	styler.Flush();
+	int state = SUB_BEGIN;
+	do {
+		// find two lexemes, lexeme 2 follows lexeme 1
+		int style2 = SCE_PL_DEFAULT;
+		Sci_PositionU pos2 = bk;
+		int len2 = findPrevLexeme(styler, pos2, style2);
+		int style1 = SCE_PL_DEFAULT;
+		Sci_PositionU pos1 = pos2;
+		if (pos1 > 0) pos1--;
+		int len1 = findPrevLexeme(styler, pos1, style1);
+		if (len1 == 0 || len2 == 0)		// lexeme pair must exist
+			break;
+
+		// match parts of syntax, if invalid subroutine syntax, break off
+		if (style1 == SCE_PL_OPERATOR && len1 == 1 &&
+		    styler.SafeGetCharAt(pos1) == ':') {	// ':'
+			if (style2 == SCE_PL_IDENTIFIER || style2 == SCE_PL_WORD) {
+				if (len2 == 9 && styler.Match(pos2, "prototype")) {	// ':' 'prototype'
+					if (state == SUB_BEGIN) {
+						state = SUB_HAS_PROTO;
+					} else
+						break;
+				} else {	// ':' <attribute>
+					if (state == SUB_HAS_PROTO || state == SUB_HAS_ATTRIB) {
+						state = SUB_HAS_ATTRIB;
+					} else
+						break;
+				}
+			} else
+				break;
+		} else if (style1 == SCE_PL_OPERATOR && len1 == 2 &&
+		           styler.Match(pos1, "::")) {	// '::'
+			if (style2 == SCE_PL_IDENTIFIER) {	// '::' <identifier>
+				state = SUB_HAS_MODULE;
+			} else
+				break;
+		} else if (style1 == SCE_PL_WORD && len1 == 3 &&
+		           styler.Match(pos1, "sub")) {	// 'sub'
+			if (style2 == SCE_PL_IDENTIFIER) {	// 'sub' <identifier>
+				state = SUB_HAS_SUB;
+			} else
+				break;
+		} else
+			break;
+		bk = pos1;			// set position for finding next lexeme pair
+		if (bk > 0) bk--;
+	} while (state != SUB_HAS_SUB);
+	return (state == SUB_HAS_SUB);
+}
+
+static int actualNumStyle(int numberStyle) {
+	if (numberStyle == PERLNUM_VECTOR || numberStyle == PERLNUM_V_VECTOR) {
+		return SCE_PL_STRING;
+	} else if (numberStyle == PERLNUM_BAD) {
+		return SCE_PL_ERROR;
+	}
+	return SCE_PL_NUMBER;
+}
+
+static int opposite(int ch) {
+	if (ch == '(') return ')';
+	if (ch == '[') return ']';
+	if (ch == '{') return '}';
+	if (ch == '<') return '>';
+	return ch;
+}
+
+static bool IsCommentLine(Sci_Position line, LexAccessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eol_pos; i++) {
+		char ch = styler[i];
+		int style = styler.StyleAt(i);
+		if (ch == '#' && style == SCE_PL_COMMENTLINE)
+			return true;
+		else if (!IsASpaceOrTab(ch))
+			return false;
+	}
+	return false;
+}
+
+static bool IsPackageLine(Sci_Position line, LexAccessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	int style = styler.StyleAt(pos);
+	if (style == SCE_PL_WORD && styler.Match(pos, "package")) {
+		return true;
+	}
+	return false;
+}
+
+static int PodHeadingLevel(Sci_Position pos, LexAccessor &styler) {
+	int lvl = static_cast<unsigned char>(styler.SafeGetCharAt(pos + 5));
+	if (lvl >= '1' && lvl <= '4') {
+		return lvl - '0';
+	}
+	return 0;
+}
+
+// An individual named option for use in an OptionSet
+
+// Options used for LexerPerl
+struct OptionsPerl {
+	bool fold;
+	bool foldComment;
+	bool foldCompact;
+	// Custom folding of POD and packages
+	bool foldPOD;            // fold.perl.pod
+	// Enable folding Pod blocks when using the Perl lexer.
+	bool foldPackage;        // fold.perl.package
+	// Enable folding packages when using the Perl lexer.
+
+	bool foldCommentExplicit;
+
+	bool foldAtElse;
+
+	OptionsPerl() {
+		fold = false;
+		foldComment = false;
+		foldCompact = true;
+		foldPOD = true;
+		foldPackage = true;
+		foldCommentExplicit = true;
+		foldAtElse = false;
+	}
+};
+
+static const char *const perlWordListDesc[] = {
+	"Keywords",
+	0
+};
+
+struct OptionSetPerl : public OptionSet<OptionsPerl> {
+	OptionSetPerl() {
+		DefineProperty("fold", &OptionsPerl::fold);
+
+		DefineProperty("fold.comment", &OptionsPerl::foldComment);
+
+		DefineProperty("fold.compact", &OptionsPerl::foldCompact);
+
+		DefineProperty("fold.perl.pod", &OptionsPerl::foldPOD,
+		        "Set to 0 to disable folding Pod blocks when using the Perl lexer.");
+
+		DefineProperty("fold.perl.package", &OptionsPerl::foldPackage,
+		        "Set to 0 to disable folding packages when using the Perl lexer.");
+
+		DefineProperty("fold.perl.comment.explicit", &OptionsPerl::foldCommentExplicit,
+		        "Set to 0 to disable explicit folding.");
+
+		DefineProperty("fold.perl.at.else", &OptionsPerl::foldAtElse,
+		               "This option enables Perl folding on a \"} else {\" line of an if statement.");
+
+		DefineWordListSets(perlWordListDesc);
+	}
+};
+
+class LexerPerl : public DefaultLexer {
+	CharacterSet setWordStart;
+	CharacterSet setWord;
+	CharacterSet setSpecialVar;
+	CharacterSet setControlVar;
+	WordList keywords;
+	OptionsPerl options;
+	OptionSetPerl osPerl;
+public:
+	LexerPerl() :
+		DefaultLexer("perl", SCLEX_PERL),
+		setWordStart(CharacterSet::setAlpha, "_", 0x80, true),
+		setWord(CharacterSet::setAlphaNum, "_", 0x80, true),
+		setSpecialVar(CharacterSet::setNone, "\"$;<>&`'+,./\\%:=~!?@[]"),
+		setControlVar(CharacterSet::setNone, "ACDEFHILMNOPRSTVWX") {
+	}
+	virtual ~LexerPerl() {
+	}
+	void SCI_METHOD Release() override {
+		delete this;
+	}
+	int SCI_METHOD Version() const override {
+		return lvRelease5;
+	}
+	const char *SCI_METHOD PropertyNames() override {
+		return osPerl.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return osPerl.PropertyType(name);
+	}
+	const char *SCI_METHOD DescribeProperty(const char *name) override {
+		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();
+	}
+	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 *) override {
+		return 0;
+	}
+
+	static ILexer5 *LexerFactoryPerl() {
+		return new LexerPerl();
+	}
+	int InputSymbolScan(StyleContext &sc);
+	void InterpolateSegment(StyleContext &sc, int maxSeg, bool isPattern=false);
+};
+
+Sci_Position SCI_METHOD LexerPerl::PropertySet(const char *key, const char *val) {
+	if (osPerl.PropertySet(&options, key, val)) {
+		return 0;
+	}
+	return -1;
+}
+
+Sci_Position SCI_METHOD LexerPerl::WordListSet(int n, const char *wl) {
+	WordList *wordListN = 0;
+	switch (n) {
+	case 0:
+		wordListN = &keywords;
+		break;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN) {
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+		}
+	}
+	return firstModification;
+}
+
+int LexerPerl::InputSymbolScan(StyleContext &sc) {
+	// forward scan for matching > on same line; file handles
+	int c, sLen = 0;
+	while ((c = sc.GetRelativeCharacter(++sLen)) != 0) {
+		if (c == '\r' || c == '\n') {
+			return 0;
+		} else if (c == '>') {
+			if (sc.Match("<=>"))	// '<=>' case
+				return 0;
+			return sLen;
+		}
+	}
+	return 0;
+}
+
+void LexerPerl::InterpolateSegment(StyleContext &sc, int maxSeg, bool isPattern) {
+	// interpolate a segment (with no active backslashes or delimiters within)
+	// switch in or out of an interpolation style or continue current style
+	// commit variable patterns if found, trim segment, repeat until done
+	while (maxSeg > 0) {
+		bool isVar = false;
+		int sLen = 0;
+		if ((maxSeg > 1) && (sc.ch == '$' || sc.ch == '@')) {
+			// $#[$]*word [$@][$]*word (where word or {word} is always present)
+			bool braces = false;
+			sLen = 1;
+			if (sc.ch == '$' && sc.chNext == '#') {	// starts with $#
+				sLen++;
+			}
+			while ((maxSeg > sLen) && (sc.GetRelativeCharacter(sLen) == '$'))	// >0 $ dereference within
+				sLen++;
+			if ((maxSeg > sLen) && (sc.GetRelativeCharacter(sLen) == '{')) {	// { start for {word}
+				sLen++;
+				braces = true;
+			}
+			if (maxSeg > sLen) {
+				int c = sc.GetRelativeCharacter(sLen);
+				if (setWordStart.Contains(c)) {	// word (various)
+					sLen++;
+					isVar = true;
+					while (maxSeg > sLen) {
+						if (!setWord.Contains(sc.GetRelativeCharacter(sLen)))
+							break;
+						sLen++;
+					}
+				} else if (braces && IsADigit(c) && (sLen == 2)) {	// digit for ${digit}
+					sLen++;
+					isVar = true;
+				}
+			}
+			if (braces) {
+				if ((maxSeg > sLen) && (sc.GetRelativeCharacter(sLen) == '}')) {	// } end for {word}
+					sLen++;
+				} else
+					isVar = false;
+			}
+		}
+		if (!isVar && (maxSeg > 1)) {	// $- or @-specific variable patterns
+			int c = sc.chNext;
+			if (sc.ch == '$') {
+				sLen = 1;
+				if (IsADigit(c)) {	// $[0-9] and slurp trailing digits
+					sLen++;
+					isVar = true;
+					while ((maxSeg > sLen) && IsADigit(sc.GetRelativeCharacter(sLen)))
+						sLen++;
+				} else if (setSpecialVar.Contains(c)) {	// $ special variables
+					sLen++;
+					isVar = true;
+				} else if (!isPattern && ((c == '(') || (c == ')') || (c == '|'))) {	// $ additional
+					sLen++;
+					isVar = true;
+				} else if (c == '^') {	// $^A control-char style
+					sLen++;
+					if ((maxSeg > sLen) && setControlVar.Contains(sc.GetRelativeCharacter(sLen))) {
+						sLen++;
+						isVar = true;
+					}
+				}
+			} else if (sc.ch == '@') {
+				sLen = 1;
+				if (!isPattern && ((c == '+') || (c == '-'))) {	// @ specials non-pattern
+					sLen++;
+					isVar = true;
+				}
+			}
+		}
+		if (isVar) {	// commit as interpolated variable or normal character
+			if (sc.state < SCE_PL_STRING_VAR)
+				sc.SetState(sc.state + INTERPOLATE_SHIFT);
+			sc.Forward(sLen);
+			maxSeg -= sLen;
+		} else {
+			if (sc.state >= SCE_PL_STRING_VAR)
+				sc.SetState(sc.state - INTERPOLATE_SHIFT);
+			sc.Forward();
+			maxSeg--;
+		}
+	}
+	if (sc.state >= SCE_PL_STRING_VAR)
+		sc.SetState(sc.state - INTERPOLATE_SHIFT);
+}
+
+void SCI_METHOD LexerPerl::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	LexAccessor styler(pAccess);
+
+	// keywords that forces /PATTERN/ at all times; should track vim's behaviour
+	WordList reWords;
+	reWords.Set("elsif if split while");
+
+	// charset classes
+	CharacterSet setSingleCharOp(CharacterSet::setNone, "rwxoRWXOezsfdlpSbctugkTBMAC");
+	// lexing of "%*</" operators is non-trivial; these are missing in the set below
+	CharacterSet setPerlOperator(CharacterSet::setNone, "^&\\()-+=|{}[]:;>,?!.~");
+	CharacterSet setQDelim(CharacterSet::setNone, "qrwx");
+	CharacterSet setModifiers(CharacterSet::setAlpha);
+	CharacterSet setPreferRE(CharacterSet::setNone, "*/<%");
+	// setArray and setHash also accepts chars for special vars like $_,
+	// which are then truncated when the next char does not match setVar
+	CharacterSet setVar(CharacterSet::setAlphaNum, "#$_'", 0x80, true);
+	CharacterSet setArray(CharacterSet::setAlpha, "#$_+-", 0x80, true);
+	CharacterSet setHash(CharacterSet::setAlpha, "#$_!^+-", 0x80, true);
+	CharacterSet &setPOD = setModifiers;
+	CharacterSet setNonHereDoc(CharacterSet::setDigits, "=$@");
+	CharacterSet setHereDocDelim(CharacterSet::setAlphaNum, "_");
+	CharacterSet setSubPrototype(CharacterSet::setNone, "\\[$@%&*+];_ \t");
+	CharacterSet setRepetition(CharacterSet::setDigits, ")\"'");
+	// for format identifiers
+	CharacterSet setFormatStart(CharacterSet::setAlpha, "_=");
+	CharacterSet &setFormat = setHereDocDelim;
+
+	// Lexer for perl often has to backtrack to start of current style to determine
+	// which characters are being used as quotes, how deeply nested is the
+	// start position and what the termination string is for HERE documents.
+
+	class HereDocCls {	// Class to manage HERE doc sequence
+	public:
+		int State;
+		// 0: '<<' encountered
+		// 1: collect the delimiter
+		// 2: here doc text (lines after the delimiter)
+		int Quote;		// the char after '<<'
+		bool Quoted;		// true if Quote in ('\'','"','`')
+		bool StripIndent;	// true if '<<~' requested to strip leading whitespace
+		int DelimiterLength;	// strlen(Delimiter)
+		char Delimiter[HERE_DELIM_MAX];	// the Delimiter
+		HereDocCls() {
+			State = 0;
+			Quote = 0;
+			Quoted = false;
+			StripIndent = false;
+			DelimiterLength = 0;
+			Delimiter[0] = '\0';
+		}
+		void Append(int ch) {
+			Delimiter[DelimiterLength++] = static_cast<char>(ch);
+			Delimiter[DelimiterLength] = '\0';
+		}
+		~HereDocCls() {
+		}
+	};
+	HereDocCls HereDoc;		// TODO: FIFO for stacked here-docs
+
+	class QuoteCls {	// Class to manage quote pairs
+	public:
+		int Rep;
+		int Count;
+		int Up, Down;
+		QuoteCls() {
+			New(1);
+		}
+		void New(int r = 1) {
+			Rep   = r;
+			Count = 0;
+			Up    = '\0';
+			Down  = '\0';
+		}
+		void Open(int u) {
+			Count++;
+			Up    = u;
+			Down  = opposite(Up);
+		}
+	};
+	QuoteCls Quote;
+
+	// additional state for number lexing
+	int numState = PERLNUM_DECIMAL;
+	int dotCount = 0;
+
+	Sci_PositionU endPos = startPos + length;
+
+	// Backtrack to beginning of style if required...
+	// If in a long distance lexical state, backtrack to find quote characters.
+	// Includes strings (may be multi-line), numbers (additional state), format
+	// bodies, as well as POD sections.
+	if (initStyle == SCE_PL_HERE_Q
+	    || initStyle == SCE_PL_HERE_QQ
+	    || initStyle == SCE_PL_HERE_QX
+	    || initStyle == SCE_PL_FORMAT
+	    || initStyle == SCE_PL_HERE_QQ_VAR
+	    || initStyle == SCE_PL_HERE_QX_VAR
+	   ) {
+		// backtrack through multiple styles to reach the delimiter start
+		int delim = (initStyle == SCE_PL_FORMAT) ? SCE_PL_FORMAT_IDENT:SCE_PL_HERE_DELIM;
+		while ((startPos > 1) && (styler.StyleAt(startPos) != delim)) {
+			startPos--;
+		}
+		startPos = styler.LineStart(styler.GetLine(startPos));
+		initStyle = styler.StyleAt(startPos - 1);
+	}
+	if (initStyle == SCE_PL_STRING
+	    || initStyle == SCE_PL_STRING_QQ
+	    || initStyle == SCE_PL_BACKTICKS
+	    || initStyle == SCE_PL_STRING_QX
+	    || initStyle == SCE_PL_REGEX
+	    || initStyle == SCE_PL_STRING_QR
+	    || initStyle == SCE_PL_REGSUBST
+	    || initStyle == SCE_PL_STRING_VAR
+	    || initStyle == SCE_PL_STRING_QQ_VAR
+	    || initStyle == SCE_PL_BACKTICKS_VAR
+	    || initStyle == SCE_PL_STRING_QX_VAR
+	    || initStyle == SCE_PL_REGEX_VAR
+	    || initStyle == SCE_PL_STRING_QR_VAR
+	    || initStyle == SCE_PL_REGSUBST_VAR
+	   ) {
+		// for interpolation, must backtrack through a mix of two different styles
+		int otherStyle = (initStyle >= SCE_PL_STRING_VAR) ?
+			initStyle - INTERPOLATE_SHIFT : initStyle + INTERPOLATE_SHIFT;
+		while (startPos > 1) {
+			int st = styler.StyleAt(startPos - 1);
+			if ((st != initStyle) && (st != otherStyle))
+				break;
+			startPos--;
+		}
+		initStyle = SCE_PL_DEFAULT;
+	} else if (initStyle == SCE_PL_STRING_Q
+	        || initStyle == SCE_PL_STRING_QW
+	        || initStyle == SCE_PL_XLAT
+	        || initStyle == SCE_PL_CHARACTER
+	        || initStyle == SCE_PL_NUMBER
+	        || initStyle == SCE_PL_IDENTIFIER
+	        || initStyle == SCE_PL_ERROR
+	        || initStyle == SCE_PL_SUB_PROTOTYPE
+	   ) {
+		while ((startPos > 1) && (styler.StyleAt(startPos - 1) == initStyle)) {
+			startPos--;
+		}
+		initStyle = SCE_PL_DEFAULT;
+	} else if (initStyle == SCE_PL_POD
+	        || initStyle == SCE_PL_POD_VERB
+	          ) {
+		// POD backtracking finds preceding blank lines and goes back past them
+		Sci_Position ln = styler.GetLine(startPos);
+		if (ln > 0) {
+			initStyle = styler.StyleAt(styler.LineStart(--ln));
+			if (initStyle == SCE_PL_POD || initStyle == SCE_PL_POD_VERB) {
+				while (ln > 0 && styler.GetLineState(ln) == SCE_PL_DEFAULT)
+					ln--;
+			}
+			startPos = styler.LineStart(++ln);
+			initStyle = styler.StyleAt(startPos - 1);
+		} else {
+			startPos = 0;
+			initStyle = SCE_PL_DEFAULT;
+		}
+	}
+
+	// backFlag, backPos are additional state to aid identifier corner cases.
+	// Look backwards past whitespace and comments in order to detect either
+	// operator or keyword. Later updated as we go along.
+	int backFlag = BACK_NONE;
+	Sci_PositionU backPos = startPos;
+	if (backPos > 0) {
+		backPos--;
+		skipWhitespaceComment(styler, backPos);
+		if (styler.StyleAt(backPos) == SCE_PL_OPERATOR)
+			backFlag = BACK_OPERATOR;
+		else if (styler.StyleAt(backPos) == SCE_PL_WORD)
+			backFlag = BACK_KEYWORD;
+		backPos++;
+	}
+
+	StyleContext sc(startPos, endPos - startPos, initStyle, styler);
+
+	for (; sc.More(); sc.Forward()) {
+
+		// Determine if the current state should terminate.
+		switch (sc.state) {
+		case SCE_PL_OPERATOR:
+			sc.SetState(SCE_PL_DEFAULT);
+			backFlag = BACK_OPERATOR;
+			backPos = sc.currentPos;
+			break;
+		case SCE_PL_IDENTIFIER:		// identifier, bareword, inputsymbol
+			if ((!setWord.Contains(sc.ch) && sc.ch != '\'')
+			        || sc.Match('.', '.')
+			        || sc.chPrev == '>') {	// end of inputsymbol
+				sc.SetState(SCE_PL_DEFAULT);
+			}
+			break;
+		case SCE_PL_WORD:		// keyword, plus special cases
+			if (!setWord.Contains(sc.ch)) {
+				char s[100];
+				sc.GetCurrent(s, sizeof(s));
+				if ((strcmp(s, "__DATA__") == 0) || (strcmp(s, "__END__") == 0)) {
+					sc.ChangeState(SCE_PL_DATASECTION);
+				} else {
+					if ((strcmp(s, "format") == 0)) {
+						sc.SetState(SCE_PL_FORMAT_IDENT);
+						HereDoc.State = 0;
+					} else {
+						sc.SetState(SCE_PL_DEFAULT);
+					}
+					backFlag = BACK_KEYWORD;
+					backPos = sc.currentPos;
+				}
+			}
+			break;
+		case SCE_PL_SCALAR:
+		case SCE_PL_ARRAY:
+		case SCE_PL_HASH:
+		case SCE_PL_SYMBOLTABLE:
+			if (sc.Match(':', ':')) {	// skip ::
+				sc.Forward();
+			} else if (!setVar.Contains(sc.ch)) {
+				if (sc.LengthCurrent() == 1) {
+					// Special variable: $(, $_ etc.
+					sc.Forward();
+				}
+				sc.SetState(SCE_PL_DEFAULT);
+			}
+			break;
+		case SCE_PL_NUMBER:
+			// if no early break, number style is terminated at "(go through)"
+			if (sc.ch == '.') {
+				if (sc.chNext == '.') {
+					// double dot is always an operator (go through)
+				} else if (numState <= PERLNUM_FLOAT_EXP) {
+					// non-decimal number or float exponent, consume next dot
+					sc.SetState(SCE_PL_OPERATOR);
+					break;
+				} else {	// decimal or vectors allows dots
+					dotCount++;
+					if (numState == PERLNUM_DECIMAL) {
+						if (dotCount <= 1)	// number with one dot in it
+							break;
+						if (IsADigit(sc.chNext)) {	// really a vector
+							numState = PERLNUM_VECTOR;
+							break;
+						}
+						// number then dot (go through)
+					} else if (numState == PERLNUM_HEX) {
+						if (dotCount <= 1 && IsADigit(sc.chNext, 16)) {
+							break;	// hex with one dot is a hex float
+						} else {
+							sc.SetState(SCE_PL_OPERATOR);
+							break;
+						}
+						// hex then dot (go through)
+					} else if (IsADigit(sc.chNext))	// vectors
+						break;
+					// vector then dot (go through)
+				}
+			} else if (sc.ch == '_') {
+				// permissive underscoring for number and vector literals
+				break;
+			} else if (numState == PERLNUM_DECIMAL) {
+				if (sc.ch == 'E' || sc.ch == 'e') {	// exponent, sign
+					numState = PERLNUM_FLOAT_EXP;
+					if (sc.chNext == '+' || sc.chNext == '-') {
+						sc.Forward();
+					}
+					break;
+				} else if (IsADigit(sc.ch))
+					break;
+				// number then word (go through)
+			} else if (numState == PERLNUM_HEX) {
+				if (sc.ch == 'P' || sc.ch == 'p') {	// hex float exponent, sign
+					numState = PERLNUM_FLOAT_EXP;
+					if (sc.chNext == '+' || sc.chNext == '-') {
+						sc.Forward();
+					}
+					break;
+				} else if (IsADigit(sc.ch, 16))
+					break;
+				// hex or hex float then word (go through)
+			} else if (numState == PERLNUM_VECTOR || numState == PERLNUM_V_VECTOR) {
+				if (IsADigit(sc.ch))	// vector
+					break;
+				if (setWord.Contains(sc.ch) && dotCount == 0) {	// change to word
+					sc.ChangeState(SCE_PL_IDENTIFIER);
+					break;
+				}
+				// vector then word (go through)
+			} else if (IsADigit(sc.ch)) {
+				if (numState == PERLNUM_FLOAT_EXP) {
+					break;
+				} else if (numState == PERLNUM_OCTAL) {
+					if (sc.ch <= '7') break;
+				} else if (numState == PERLNUM_BINARY) {
+					if (sc.ch <= '1') break;
+				}
+				// mark invalid octal, binary numbers (go through)
+				numState = PERLNUM_BAD;
+				break;
+			}
+			// complete current number or vector
+			sc.ChangeState(actualNumStyle(numState));
+			sc.SetState(SCE_PL_DEFAULT);
+			break;
+		case SCE_PL_COMMENTLINE:
+			if (sc.atLineStart) {
+				sc.SetState(SCE_PL_DEFAULT);
+			}
+			break;
+		case SCE_PL_HERE_DELIM:
+			if (HereDoc.State == 0) { // '<<' encountered
+				int delim_ch = sc.chNext;
+				Sci_Position ws_skip = 0;
+				HereDoc.State = 1;	// pre-init HERE doc class
+				HereDoc.Quote = sc.chNext;
+				HereDoc.Quoted = false;
+				HereDoc.StripIndent = false;
+				HereDoc.DelimiterLength = 0;
+				HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0';
+				if (delim_ch == '~') { // was actually '<<~'
+					sc.Forward();
+					HereDoc.StripIndent = true;
+					HereDoc.Quote = delim_ch = sc.chNext;
+				}
+				if (IsASpaceOrTab(delim_ch)) {
+					// skip whitespace; legal only for quoted delimiters
+					Sci_PositionU i = sc.currentPos + 1;
+					while ((i < endPos) && IsASpaceOrTab(delim_ch)) {
+						i++;
+						delim_ch = static_cast<unsigned char>(styler.SafeGetCharAt(i));
+					}
+					ws_skip = i - sc.currentPos - 1;
+				}
+				if (delim_ch == '\'' || delim_ch == '"' || delim_ch == '`') {
+					// a quoted here-doc delimiter; skip any whitespace
+					sc.Forward(ws_skip + 1);
+					HereDoc.Quote = delim_ch;
+					HereDoc.Quoted = true;
+				} else if ((ws_skip == 0 && setNonHereDoc.Contains(sc.chNext))
+				        || ws_skip > 0) {
+					// left shift << or <<= operator cases
+					// restore position if operator
+					sc.ChangeState(SCE_PL_OPERATOR);
+					sc.ForwardSetState(SCE_PL_DEFAULT);
+					backFlag = BACK_OPERATOR;
+					backPos = sc.currentPos;
+					HereDoc.State = 0;
+				} else {
+					// specially handle initial '\' for identifier
+					if (ws_skip == 0 && HereDoc.Quote == '\\')
+						sc.Forward();
+					// an unquoted here-doc delimiter, no special handling
+					// (cannot be prefixed by spaces/tabs), or
+					// symbols terminates; deprecated zero-length delimiter
+				}
+			} else if (HereDoc.State == 1) { // collect the delimiter
+				backFlag = BACK_NONE;
+				if (HereDoc.Quoted) { // a quoted here-doc delimiter
+					if (sc.ch == HereDoc.Quote) { // closing quote => end of delimiter
+						sc.ForwardSetState(SCE_PL_DEFAULT);
+					} else if (!sc.atLineEnd) {
+						if (sc.Match('\\', static_cast<char>(HereDoc.Quote))) { // escaped quote
+							sc.Forward();
+						}
+						if (sc.ch != '\r') {	// skip CR if CRLF
+							int i = 0;			// else append char, possibly an extended char
+							while (i < sc.width) {
+								HereDoc.Append(static_cast<unsigned char>(styler.SafeGetCharAt(sc.currentPos + i)));
+								i++;
+							}
+						}
+					}
+				} else { // an unquoted here-doc delimiter, no extended charsets
+					if (setHereDocDelim.Contains(sc.ch)) {
+						HereDoc.Append(sc.ch);
+					} else {
+						sc.SetState(SCE_PL_DEFAULT);
+					}
+				}
+				if (HereDoc.DelimiterLength >= HERE_DELIM_MAX - 1) {
+					sc.SetState(SCE_PL_ERROR);
+					HereDoc.State = 0;
+				}
+			}
+			break;
+		case SCE_PL_HERE_Q:
+		case SCE_PL_HERE_QQ:
+		case SCE_PL_HERE_QX:
+			// also implies HereDoc.State == 2
+			sc.Complete();
+			if (HereDoc.StripIndent) {
+				// skip whitespace
+				while (IsASpaceOrTab(sc.ch) && !sc.atLineEnd)
+					sc.Forward();
+			}
+			if (HereDoc.DelimiterLength == 0 || sc.Match(HereDoc.Delimiter)) {
+				int c = sc.GetRelative(HereDoc.DelimiterLength);
+				if (c == '\r' || c == '\n') {	// peek first, do not consume match
+					sc.ForwardBytes(HereDoc.DelimiterLength);
+					sc.SetState(SCE_PL_DEFAULT);
+					backFlag = BACK_NONE;
+					HereDoc.State = 0;
+					if (!sc.atLineEnd)
+						sc.Forward();
+					break;
+				}
+			}
+			if (sc.state == SCE_PL_HERE_Q) {	// \EOF and 'EOF' non-interpolated
+				while (!sc.atLineEnd)
+					sc.Forward();
+				break;
+			}
+			while (!sc.atLineEnd) {		// "EOF" and `EOF` interpolated
+				int c, sLen = 0, endType = 0;
+				while ((c = sc.GetRelativeCharacter(sLen)) != 0) {
+					// scan to break string into segments
+					if (c == '\\') {
+						endType = 1; break;
+					} else if (c == '\r' || c == '\n') {
+						endType = 2; break;
+					}
+					sLen++;
+				}
+				if (sLen > 0)	// process non-empty segments
+					InterpolateSegment(sc, sLen);
+				if (endType == 1) {
+					sc.Forward();
+					// \ at end-of-line does not appear to have any effect, skip
+					if (sc.ch != '\r' && sc.ch != '\n')
+						sc.Forward();
+				} else if (endType == 2) {
+					if (!sc.atLineEnd)
+						sc.Forward();
+				}
+			}
+			break;
+		case SCE_PL_POD:
+		case SCE_PL_POD_VERB: {
+				Sci_PositionU fw = sc.currentPos;
+				Sci_Position ln = styler.GetLine(fw);
+				if (sc.atLineStart && sc.Match("=cut")) {	// end of POD
+					sc.SetState(SCE_PL_POD);
+					sc.Forward(4);
+					sc.SetState(SCE_PL_DEFAULT);
+					styler.SetLineState(ln, SCE_PL_POD);
+					break;
+				}
+				int pod = podLineScan(styler, fw, endPos);	// classify POD line
+				styler.SetLineState(ln, pod);
+				if (pod == SCE_PL_DEFAULT) {
+					if (sc.state == SCE_PL_POD_VERB) {
+						Sci_PositionU fw2 = fw;
+						while (fw2 < (endPos - 1) && pod == SCE_PL_DEFAULT) {
+							fw = fw2++;	// penultimate line (last blank line)
+							pod = podLineScan(styler, fw2, endPos);
+							styler.SetLineState(styler.GetLine(fw2), pod);
+						}
+						if (pod == SCE_PL_POD) {	// truncate verbatim POD early
+							sc.SetState(SCE_PL_POD);
+						} else
+							fw = fw2;
+					}
+				} else {
+					if (pod == SCE_PL_POD_VERB	// still part of current paragraph
+					        && (styler.GetLineState(ln - 1) == SCE_PL_POD)) {
+						pod = SCE_PL_POD;
+						styler.SetLineState(ln, pod);
+					} else if (pod == SCE_PL_POD
+					        && (styler.GetLineState(ln - 1) == SCE_PL_POD_VERB)) {
+						pod = SCE_PL_POD_VERB;
+						styler.SetLineState(ln, pod);
+					}
+					sc.SetState(pod);
+				}
+				sc.ForwardBytes(fw - sc.currentPos);	// commit style
+			}
+			break;
+		case SCE_PL_REGEX:
+		case SCE_PL_STRING_QR:
+			if (Quote.Rep <= 0) {
+				if (!setModifiers.Contains(sc.ch))
+					sc.SetState(SCE_PL_DEFAULT);
+			} else if (!Quote.Up && !IsASpace(sc.ch)) {
+				Quote.Open(sc.ch);
+			} else {
+				int c, sLen = 0, endType = 0;
+				while ((c = sc.GetRelativeCharacter(sLen)) != 0) {
+					// scan to break string into segments
+					if (IsASpace(c)) {
+						break;
+					} else if (c == '\\' && Quote.Up != '\\') {
+						endType = 1; break;
+					} else if (c == Quote.Down) {
+						Quote.Count--;
+						if (Quote.Count == 0) {
+							Quote.Rep--;
+							break;
+						}
+					} else if (c == Quote.Up)
+						Quote.Count++;
+					sLen++;
+				}
+				if (sLen > 0) {	// process non-empty segments
+					if (Quote.Up != '\'') {
+						InterpolateSegment(sc, sLen, true);
+					} else		// non-interpolated path
+						sc.Forward(sLen);
+				}
+				if (endType == 1)
+					sc.Forward();
+			}
+			break;
+		case SCE_PL_REGSUBST:
+		case SCE_PL_XLAT:
+			if (Quote.Rep <= 0) {
+				if (!setModifiers.Contains(sc.ch))
+					sc.SetState(SCE_PL_DEFAULT);
+			} else if (!Quote.Up && !IsASpace(sc.ch)) {
+				Quote.Open(sc.ch);
+			} else {
+				int c, sLen = 0, endType = 0;
+				bool isPattern = (Quote.Rep == 2);
+				while ((c = sc.GetRelativeCharacter(sLen)) != 0) {
+					// scan to break string into segments
+					if (c == '\\' && Quote.Up != '\\') {
+						endType = 2; break;
+					} else if (Quote.Count == 0 && Quote.Rep == 1) {
+						// We matched something like s(...) or tr{...}, Perl 5.10
+						// appears to allow almost any character for use as the
+						// next delimiters. Whitespace and comments are accepted in
+						// between, but we'll limit to whitespace here.
+						// For '#', if no whitespace in between, it's a delimiter.
+						if (IsASpace(c)) {
+							// Keep going
+						} else if (c == '#' && IsASpaceOrTab(sc.GetRelativeCharacter(sLen - 1))) {
+							endType = 3;
+						} else
+							Quote.Open(c);
+						break;
+					} else if (c == Quote.Down) {
+						Quote.Count--;
+						if (Quote.Count == 0) {
+							Quote.Rep--;
+							endType = 1;
+						}
+						if (Quote.Up == Quote.Down)
+							Quote.Count++;
+						if (endType == 1)
+							break;
+					} else if (c == Quote.Up) {
+						Quote.Count++;
+					} else if (IsASpace(c))
+						break;
+					sLen++;
+				}
+				if (sLen > 0) {	// process non-empty segments
+					if (sc.state == SCE_PL_REGSUBST && Quote.Up != '\'') {
+						InterpolateSegment(sc, sLen, isPattern);
+					} else		// non-interpolated path
+						sc.Forward(sLen);
+				}
+				if (endType == 2) {
+					sc.Forward();
+				} else if (endType == 3)
+					sc.SetState(SCE_PL_DEFAULT);
+			}
+			break;
+		case SCE_PL_STRING_Q:
+		case SCE_PL_STRING_QQ:
+		case SCE_PL_STRING_QX:
+		case SCE_PL_STRING_QW:
+		case SCE_PL_STRING:
+		case SCE_PL_CHARACTER:
+		case SCE_PL_BACKTICKS:
+			if (!Quote.Down && !IsASpace(sc.ch)) {
+				Quote.Open(sc.ch);
+			} else {
+				int c, sLen = 0, endType = 0;
+				while ((c = sc.GetRelativeCharacter(sLen)) != 0) {
+					// scan to break string into segments
+					if (IsASpace(c)) {
+						break;
+					} else if (c == '\\' && Quote.Up != '\\') {
+						endType = 2; break;
+					} else if (c == Quote.Down) {
+						Quote.Count--;
+						if (Quote.Count == 0) {
+							endType = 3; break;
+						}
+					} else if (c == Quote.Up)
+						Quote.Count++;
+					sLen++;
+				}
+				if (sLen > 0) {	// process non-empty segments
+					switch (sc.state) {
+					case SCE_PL_STRING:
+					case SCE_PL_STRING_QQ:
+					case SCE_PL_BACKTICKS:
+						InterpolateSegment(sc, sLen);
+						break;
+					case SCE_PL_STRING_QX:
+						if (Quote.Up != '\'') {
+							InterpolateSegment(sc, sLen);
+							break;
+						}
+						// (continued for ' delim)
+						// Falls through.
+					default:	// non-interpolated path
+						sc.Forward(sLen);
+					}
+				}
+				if (endType == 2) {
+					sc.Forward();
+				} else if (endType == 3)
+					sc.ForwardSetState(SCE_PL_DEFAULT);
+			}
+			break;
+		case SCE_PL_SUB_PROTOTYPE: {
+				int i = 0;
+				// forward scan; must all be valid proto characters
+				while (setSubPrototype.Contains(sc.GetRelative(i)))
+					i++;
+				if (sc.GetRelative(i) == ')') {	// valid sub prototype
+					sc.ForwardBytes(i);
+					sc.ForwardSetState(SCE_PL_DEFAULT);
+				} else {
+					// abandon prototype, restart from '('
+					sc.ChangeState(SCE_PL_OPERATOR);
+					sc.SetState(SCE_PL_DEFAULT);
+				}
+			}
+			break;
+		case SCE_PL_FORMAT: {
+				sc.Complete();
+				if (sc.Match('.')) {
+					sc.Forward();
+					if (sc.atLineEnd || ((sc.ch == '\r' && sc.chNext == '\n')))
+						sc.SetState(SCE_PL_DEFAULT);
+				}
+				while (!sc.atLineEnd)
+					sc.Forward();
+			}
+			break;
+		case SCE_PL_ERROR:
+			break;
+		}
+		// Needed for specific continuation styles (one follows the other)
+		switch (sc.state) {
+			// continued from SCE_PL_WORD
+		case SCE_PL_FORMAT_IDENT:
+			// occupies HereDoc state 3 to avoid clashing with HERE docs
+			if (IsASpaceOrTab(sc.ch)) {		// skip whitespace
+				sc.ChangeState(SCE_PL_DEFAULT);
+				while (IsASpaceOrTab(sc.ch) && !sc.atLineEnd)
+					sc.Forward();
+				sc.SetState(SCE_PL_FORMAT_IDENT);
+			}
+			if (setFormatStart.Contains(sc.ch)) {	// identifier or '='
+				if (sc.ch != '=') {
+					do {
+						sc.Forward();
+					} while (setFormat.Contains(sc.ch));
+				}
+				while (IsASpaceOrTab(sc.ch) && !sc.atLineEnd)
+					sc.Forward();
+				if (sc.ch == '=') {
+					sc.ForwardSetState(SCE_PL_DEFAULT);
+					HereDoc.State = 3;
+				} else {
+					// invalid identifier; inexact fallback, but hey
+					sc.ChangeState(SCE_PL_IDENTIFIER);
+					sc.SetState(SCE_PL_DEFAULT);
+				}
+			} else {
+				sc.ChangeState(SCE_PL_DEFAULT);	// invalid identifier
+			}
+			backFlag = BACK_NONE;
+			break;
+		}
+
+		// Must check end of HereDoc states here before default state is handled
+		if (HereDoc.State == 1 && sc.atLineEnd) {
+			// Begin of here-doc (the line after the here-doc delimiter):
+			// Lexically, the here-doc starts from the next line after the >>, but the
+			// first line of here-doc seem to follow the style of the last EOL sequence
+			int st_new = SCE_PL_HERE_QQ;
+			HereDoc.State = 2;
+			if (HereDoc.Quoted) {
+				if (sc.state == SCE_PL_HERE_DELIM) {
+					// Missing quote at end of string! We are stricter than perl.
+					// Colour here-doc anyway while marking this bit as an error.
+					sc.ChangeState(SCE_PL_ERROR);
+				}
+				switch (HereDoc.Quote) {
+				case '\'':
+					st_new = SCE_PL_HERE_Q;
+					break;
+				case '"' :
+					st_new = SCE_PL_HERE_QQ;
+					break;
+				case '`' :
+					st_new = SCE_PL_HERE_QX;
+					break;
+				}
+			} else {
+				if (HereDoc.Quote == '\\')
+					st_new = SCE_PL_HERE_Q;
+			}
+			sc.SetState(st_new);
+		}
+		if (HereDoc.State == 3 && sc.atLineEnd) {
+			// Start of format body.
+			HereDoc.State = 0;
+			sc.SetState(SCE_PL_FORMAT);
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_PL_DEFAULT) {
+			if (IsADigit(sc.ch) ||
+			        (IsADigit(sc.chNext) && (sc.ch == '.' || sc.ch == 'v'))) {
+				sc.SetState(SCE_PL_NUMBER);
+				backFlag = BACK_NONE;
+				numState = PERLNUM_DECIMAL;
+				dotCount = 0;
+				if (sc.ch == '0') {		// hex,bin,octal
+					if (sc.chNext == 'x' || sc.chNext == 'X') {
+						numState = PERLNUM_HEX;
+					} else if (sc.chNext == 'b' || sc.chNext == 'B') {
+						numState = PERLNUM_BINARY;
+					} else if (IsADigit(sc.chNext)) {
+						numState = PERLNUM_OCTAL;
+					}
+					if (numState != PERLNUM_DECIMAL) {
+						sc.Forward();
+					}
+				} else if (sc.ch == 'v') {		// vector
+					numState = PERLNUM_V_VECTOR;
+				}
+			} else if (setWord.Contains(sc.ch)) {
+				// if immediately prefixed by '::', always a bareword
+				sc.SetState(SCE_PL_WORD);
+				if (sc.chPrev == ':' && sc.GetRelative(-2) == ':') {
+					sc.ChangeState(SCE_PL_IDENTIFIER);
+				}
+				Sci_PositionU bk = sc.currentPos;
+				Sci_PositionU fw = sc.currentPos + 1;
+				// first check for possible quote-like delimiter
+				if (sc.ch == 's' && !setWord.Contains(sc.chNext)) {
+					sc.ChangeState(SCE_PL_REGSUBST);
+					Quote.New(2);
+				} else if (sc.ch == 'm' && !setWord.Contains(sc.chNext)) {
+					sc.ChangeState(SCE_PL_REGEX);
+					Quote.New();
+				} else if (sc.ch == 'q' && !setWord.Contains(sc.chNext)) {
+					sc.ChangeState(SCE_PL_STRING_Q);
+					Quote.New();
+				} else if (sc.ch == 'y' && !setWord.Contains(sc.chNext)) {
+					sc.ChangeState(SCE_PL_XLAT);
+					Quote.New(2);
+				} else if (sc.Match('t', 'r') && !setWord.Contains(sc.GetRelative(2))) {
+					sc.ChangeState(SCE_PL_XLAT);
+					Quote.New(2);
+					sc.Forward();
+					fw++;
+				} else if (sc.ch == 'q' && setQDelim.Contains(sc.chNext)
+				        && !setWord.Contains(sc.GetRelative(2))) {
+					if (sc.chNext == 'q') sc.ChangeState(SCE_PL_STRING_QQ);
+					else if (sc.chNext == 'x') sc.ChangeState(SCE_PL_STRING_QX);
+					else if (sc.chNext == 'r') sc.ChangeState(SCE_PL_STRING_QR);
+					else sc.ChangeState(SCE_PL_STRING_QW);	// sc.chNext == 'w'
+					Quote.New();
+					sc.Forward();
+					fw++;
+				} else if (sc.ch == 'x' && (sc.chNext == '=' ||	// repetition
+				        !setWord.Contains(sc.chNext) ||
+				        (setRepetition.Contains(sc.chPrev) && IsADigit(sc.chNext)))) {
+					sc.ChangeState(SCE_PL_OPERATOR);
+				}
+				// if potentially a keyword, scan forward and grab word, then check
+				// if it's really one; if yes, disambiguation test is performed
+				// otherwise it is always a bareword and we skip a lot of scanning
+				if (sc.state == SCE_PL_WORD) {
+					while (setWord.Contains(static_cast<unsigned char>(styler.SafeGetCharAt(fw))))
+						fw++;
+					if (!isPerlKeyword(styler.GetStartSegment(), fw, keywords, styler)) {
+						sc.ChangeState(SCE_PL_IDENTIFIER);
+					}
+				}
+				// if already SCE_PL_IDENTIFIER, then no ambiguity, skip this
+				// for quote-like delimiters/keywords, attempt to disambiguate
+				// to select for bareword, change state -> SCE_PL_IDENTIFIER
+				if (sc.state != SCE_PL_IDENTIFIER && bk > 0) {
+					if (disambiguateBareword(styler, bk, fw, backFlag, backPos, endPos))
+						sc.ChangeState(SCE_PL_IDENTIFIER);
+				}
+				backFlag = BACK_NONE;
+			} else if (sc.ch == '#') {
+				sc.SetState(SCE_PL_COMMENTLINE);
+			} else if (sc.ch == '\"') {
+				sc.SetState(SCE_PL_STRING);
+				Quote.New();
+				Quote.Open(sc.ch);
+				backFlag = BACK_NONE;
+			} else if (sc.ch == '\'') {
+				if (sc.chPrev == '&' && setWordStart.Contains(sc.chNext)) {
+					// Archaic call
+					sc.SetState(SCE_PL_IDENTIFIER);
+				} else {
+					sc.SetState(SCE_PL_CHARACTER);
+					Quote.New();
+					Quote.Open(sc.ch);
+				}
+				backFlag = BACK_NONE;
+			} else if (sc.ch == '`') {
+				sc.SetState(SCE_PL_BACKTICKS);
+				Quote.New();
+				Quote.Open(sc.ch);
+				backFlag = BACK_NONE;
+			} else if (sc.ch == '$') {
+				sc.SetState(SCE_PL_SCALAR);
+				if (sc.chNext == '{') {
+					sc.ForwardSetState(SCE_PL_OPERATOR);
+				} else if (IsASpace(sc.chNext)) {
+					sc.ForwardSetState(SCE_PL_DEFAULT);
+				} else {
+					sc.Forward();
+					if (sc.Match('`', '`') || sc.Match(':', ':')) {
+						sc.Forward();
+					}
+				}
+				backFlag = BACK_NONE;
+			} else if (sc.ch == '@') {
+				sc.SetState(SCE_PL_ARRAY);
+				if (setArray.Contains(sc.chNext)) {
+					// no special treatment
+				} else if (sc.chNext == ':' && sc.GetRelative(2) == ':') {
+					sc.ForwardBytes(2);
+				} else if (sc.chNext == '{' || sc.chNext == '[') {
+					sc.ForwardSetState(SCE_PL_OPERATOR);
+				} else {
+					sc.ChangeState(SCE_PL_OPERATOR);
+				}
+				backFlag = BACK_NONE;
+			} else if (setPreferRE.Contains(sc.ch)) {
+				// Explicit backward peeking to set a consistent preferRE for
+				// any slash found, so no longer need to track preferRE state.
+				// Find first previous significant lexed element and interpret.
+				// A few symbols shares this code for disambiguation.
+				bool preferRE = false;
+				bool isHereDoc = sc.Match('<', '<');
+				bool hereDocSpace = false;		// for: SCALAR [whitespace] '<<'
+				Sci_PositionU bk = (sc.currentPos > 0) ? sc.currentPos - 1: 0;
+				sc.Complete();
+				styler.Flush();
+				if (styler.StyleAt(bk) == SCE_PL_DEFAULT)
+					hereDocSpace = true;
+				skipWhitespaceComment(styler, bk);
+				if (bk == 0) {
+					// avoid backward scanning breakage
+					preferRE = true;
+				} else {
+					int bkstyle = styler.StyleAt(bk);
+					int bkch = static_cast<unsigned char>(styler.SafeGetCharAt(bk));
+					switch (bkstyle) {
+					case SCE_PL_OPERATOR:
+						preferRE = true;
+						if (bkch == ')' || bkch == ']') {
+							preferRE = false;
+						} else if (bkch == '}') {
+							// backtrack by counting balanced brace pairs
+							// needed to test for variables like ${}, @{} etc.
+							bkstyle = styleBeforeBracePair(styler, bk);
+							if (bkstyle == SCE_PL_SCALAR
+							        || bkstyle == SCE_PL_ARRAY
+							        || bkstyle == SCE_PL_HASH
+							        || bkstyle == SCE_PL_SYMBOLTABLE
+							        || bkstyle == SCE_PL_OPERATOR) {
+								preferRE = false;
+							}
+						} else if (bkch == '+' || bkch == '-') {
+							if (bkch == static_cast<unsigned char>(styler.SafeGetCharAt(bk - 1))
+							        && bkch != static_cast<unsigned char>(styler.SafeGetCharAt(bk - 2)))
+								// exceptions for operators: unary suffixes ++, --
+								preferRE = false;
+						}
+						break;
+					case SCE_PL_IDENTIFIER:
+						preferRE = true;
+						bkstyle = styleCheckIdentifier(styler, bk);
+						if ((bkstyle == 1) || (bkstyle == 2)) {
+							// inputsymbol or var with "->" or "::" before identifier
+							preferRE = false;
+						} else if (bkstyle == 3) {
+							// bare identifier, test cases follows:
+							if (sc.ch == '/') {
+								// if '/', /PATTERN/ unless digit/space immediately after '/'
+								// if '//', always expect defined-or operator to follow identifier
+								if (IsASpace(sc.chNext) || IsADigit(sc.chNext) || sc.chNext == '/')
+									preferRE = false;
+							} else if (sc.ch == '*' || sc.ch == '%') {
+								if (IsASpace(sc.chNext) || IsADigit(sc.chNext) || sc.Match('*', '*'))
+									preferRE = false;
+							} else if (sc.ch == '<') {
+								if (IsASpace(sc.chNext) || sc.chNext == '=')
+									preferRE = false;
+							}
+						}
+						break;
+					case SCE_PL_SCALAR:		// for $var<< case:
+						if (isHereDoc && hereDocSpace)	// if SCALAR whitespace '<<', *always* a HERE doc
+							preferRE = true;
+						break;
+					case SCE_PL_WORD:
+						preferRE = true;
+						// for HERE docs, always true
+						if (sc.ch == '/') {
+							// adopt heuristics similar to vim-style rules:
+							// keywords always forced as /PATTERN/: split, if, elsif, while
+							// everything else /PATTERN/ unless digit/space immediately after '/'
+							// for '//', defined-or favoured unless special keywords
+							Sci_PositionU bkend = bk + 1;
+							while (bk > 0 && styler.StyleAt(bk - 1) == SCE_PL_WORD) {
+								bk--;
+							}
+							if (isPerlKeyword(bk, bkend, reWords, styler))
+								break;
+							if (IsASpace(sc.chNext) || IsADigit(sc.chNext) || sc.chNext == '/')
+								preferRE = false;
+						} else if (sc.ch == '*' || sc.ch == '%') {
+							if (IsASpace(sc.chNext) || IsADigit(sc.chNext) || sc.Match('*', '*'))
+								preferRE = false;
+						} else if (sc.ch == '<') {
+							if (IsASpace(sc.chNext) || sc.chNext == '=')
+								preferRE = false;
+						}
+						break;
+
+						// other styles uses the default, preferRE=false
+					case SCE_PL_POD:
+					case SCE_PL_HERE_Q:
+					case SCE_PL_HERE_QQ:
+					case SCE_PL_HERE_QX:
+						preferRE = true;
+						break;
+					}
+				}
+				backFlag = BACK_NONE;
+				if (isHereDoc) {	// handle '<<', HERE doc
+					if (sc.Match("<<>>")) {		// double-diamond operator (5.22)
+						sc.SetState(SCE_PL_OPERATOR);
+						sc.Forward(3);
+					} else if (preferRE) {
+						sc.SetState(SCE_PL_HERE_DELIM);
+						HereDoc.State = 0;
+					} else {		// << operator
+						sc.SetState(SCE_PL_OPERATOR);
+						sc.Forward();
+					}
+				} else if (sc.ch == '*') {	// handle '*', typeglob
+					if (preferRE) {
+						sc.SetState(SCE_PL_SYMBOLTABLE);
+						if (sc.chNext == ':' && sc.GetRelative(2) == ':') {
+							sc.ForwardBytes(2);
+						} else if (sc.chNext == '{') {
+							sc.ForwardSetState(SCE_PL_OPERATOR);
+						} else {
+							sc.Forward();
+						}
+					} else {
+						sc.SetState(SCE_PL_OPERATOR);
+						if (sc.chNext == '*') 	// exponentiation
+							sc.Forward();
+					}
+				} else if (sc.ch == '%') {	// handle '%', hash
+					if (preferRE) {
+						sc.SetState(SCE_PL_HASH);
+						if (setHash.Contains(sc.chNext)) {
+							sc.Forward();
+						} else if (sc.chNext == ':' && sc.GetRelative(2) == ':') {
+							sc.ForwardBytes(2);
+						} else if (sc.chNext == '{') {
+							sc.ForwardSetState(SCE_PL_OPERATOR);
+						} else {
+							sc.ChangeState(SCE_PL_OPERATOR);
+						}
+					} else {
+						sc.SetState(SCE_PL_OPERATOR);
+					}
+				} else if (sc.ch == '<') {	// handle '<', inputsymbol
+					if (preferRE) {
+						// forward scan
+						int i = InputSymbolScan(sc);
+						if (i > 0) {
+							sc.SetState(SCE_PL_IDENTIFIER);
+							sc.Forward(i);
+						} else {
+							sc.SetState(SCE_PL_OPERATOR);
+						}
+					} else {
+						sc.SetState(SCE_PL_OPERATOR);
+					}
+				} else {			// handle '/', regexp
+					if (preferRE) {
+						sc.SetState(SCE_PL_REGEX);
+						Quote.New();
+						Quote.Open(sc.ch);
+					} else {		// / and // operators
+						sc.SetState(SCE_PL_OPERATOR);
+						if (sc.chNext == '/') {
+							sc.Forward();
+						}
+					}
+				}
+			} else if (sc.ch == '='		// POD
+			        && setPOD.Contains(sc.chNext)
+			        && sc.atLineStart) {
+				sc.SetState(SCE_PL_POD);
+				backFlag = BACK_NONE;
+			} else if (sc.ch == '-' && setWordStart.Contains(sc.chNext)) {	// extended '-' cases
+				Sci_PositionU bk = sc.currentPos;
+				Sci_PositionU fw = 2;
+				if (setSingleCharOp.Contains(sc.chNext) &&	// file test operators
+				        !setWord.Contains(sc.GetRelative(2))) {
+					sc.SetState(SCE_PL_WORD);
+				} else {
+					// nominally a minus and bareword; find extent of bareword
+					while (setWord.Contains(sc.GetRelative(fw)))
+						fw++;
+					sc.SetState(SCE_PL_OPERATOR);
+				}
+				// force to bareword for hash key => or {variable literal} cases
+				if (disambiguateBareword(styler, bk, bk + fw, backFlag, backPos, endPos) & 2) {
+					sc.ChangeState(SCE_PL_IDENTIFIER);
+				}
+				backFlag = BACK_NONE;
+			} else if (sc.ch == '(' && sc.currentPos > 0) {	// '(' or subroutine prototype
+				sc.Complete();
+				if (styleCheckSubPrototype(styler, sc.currentPos - 1)) {
+					sc.SetState(SCE_PL_SUB_PROTOTYPE);
+					backFlag = BACK_NONE;
+				} else {
+					sc.SetState(SCE_PL_OPERATOR);
+				}
+			} else if (setPerlOperator.Contains(sc.ch)) {	// operators
+				sc.SetState(SCE_PL_OPERATOR);
+				if (sc.Match('.', '.')) {	// .. and ...
+					sc.Forward();
+					if (sc.chNext == '.') sc.Forward();
+				}
+			} else if (sc.ch == 4 || sc.ch == 26) {		// ^D and ^Z ends valid perl source
+				sc.SetState(SCE_PL_DATASECTION);
+			} else {
+				// keep colouring defaults
+				sc.Complete();
+			}
+		}
+	}
+	sc.Complete();
+	if (sc.state == SCE_PL_HERE_Q
+	        || sc.state == SCE_PL_HERE_QQ
+	        || sc.state == SCE_PL_HERE_QX
+	        || sc.state == SCE_PL_FORMAT) {
+		styler.ChangeLexerState(sc.currentPos, styler.Length());
+	}
+	sc.Complete();
+}
+
+#define PERL_HEADFOLD_SHIFT		4
+#define PERL_HEADFOLD_MASK		0xF0
+
+void SCI_METHOD LexerPerl::Fold(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, IDocument *pAccess) {
+
+	if (!options.fold)
+		return;
+
+	LexAccessor styler(pAccess);
+
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+
+	// Backtrack to previous line in case need to fix its fold status
+	if (startPos > 0) {
+		if (lineCurrent > 0) {
+			lineCurrent--;
+			startPos = styler.LineStart(lineCurrent);
+		}
+	}
+
+	int levelPrev = SC_FOLDLEVELBASE;
+	if (lineCurrent > 0)
+		levelPrev = styler.LevelAt(lineCurrent - 1) >> 16;
+	int levelCurrent = levelPrev;
+	char chNext = styler[startPos];
+	char chPrev = styler.SafeGetCharAt(startPos - 1);
+	int styleNext = styler.StyleAt(startPos);
+	// Used at end of line to determine if the line was a package definition
+	bool isPackageLine = false;
+	int podHeading = 0;
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		int stylePrevCh = (i) ? styler.StyleAt(i - 1):SCE_PL_DEFAULT;
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+		bool atLineStart = ((chPrev == '\r') || (chPrev == '\n')) || i == 0;
+		// Comment folding
+		if (options.foldComment && atEOL && IsCommentLine(lineCurrent, styler)) {
+			if (!IsCommentLine(lineCurrent - 1, styler)
+			        && IsCommentLine(lineCurrent + 1, styler))
+				levelCurrent++;
+			else if (IsCommentLine(lineCurrent - 1, styler)
+			        && !IsCommentLine(lineCurrent + 1, styler))
+				levelCurrent--;
+		}
+		// {} [] block folding
+		if (style == SCE_PL_OPERATOR) {
+			if (ch == '{') {
+				if (options.foldAtElse && levelCurrent < levelPrev)
+					--levelPrev;
+				levelCurrent++;
+			} else if (ch == '}') {
+				levelCurrent--;
+			}
+			if (ch == '[') {
+				if (options.foldAtElse && levelCurrent < levelPrev)
+					--levelPrev;
+				levelCurrent++;
+			} else if (ch == ']') {
+				levelCurrent--;
+			}
+		} else if (style == SCE_PL_STRING_QW) {
+			// qw
+			if (stylePrevCh != style)
+				levelCurrent++;
+			else if (styleNext != style)
+				levelCurrent--;
+		}
+		// POD folding
+		if (options.foldPOD && atLineStart) {
+			if (style == SCE_PL_POD) {
+				if (stylePrevCh != SCE_PL_POD && stylePrevCh != SCE_PL_POD_VERB)
+					levelCurrent++;
+				else if (styler.Match(i, "=cut"))
+					levelCurrent = (levelCurrent & ~PERL_HEADFOLD_MASK) - 1;
+				else if (styler.Match(i, "=head"))
+					podHeading = PodHeadingLevel(i, styler);
+			} else if (style == SCE_PL_DATASECTION) {
+				if (ch == '=' && IsASCII(chNext) && isalpha(chNext) && levelCurrent == SC_FOLDLEVELBASE)
+					levelCurrent++;
+				else if (styler.Match(i, "=cut") && levelCurrent > SC_FOLDLEVELBASE)
+					levelCurrent = (levelCurrent & ~PERL_HEADFOLD_MASK) - 1;
+				else if (styler.Match(i, "=head"))
+					podHeading = PodHeadingLevel(i, styler);
+				// if package used or unclosed brace, level > SC_FOLDLEVELBASE!
+				// reset needed as level test is vs. SC_FOLDLEVELBASE
+				else if (stylePrevCh != SCE_PL_DATASECTION)
+					levelCurrent = SC_FOLDLEVELBASE;
+			}
+		}
+		// package folding
+		if (options.foldPackage && atLineStart) {
+			if (IsPackageLine(lineCurrent, styler)
+			        && !IsPackageLine(lineCurrent + 1, styler))
+				isPackageLine = true;
+		}
+
+		//heredoc folding
+		switch (style) {
+		case SCE_PL_HERE_QQ :
+		case SCE_PL_HERE_Q :
+		case SCE_PL_HERE_QX :
+			switch (stylePrevCh) {
+			case SCE_PL_HERE_QQ :
+			case SCE_PL_HERE_Q :
+			case SCE_PL_HERE_QX :
+				//do nothing;
+				break;
+			default :
+				levelCurrent++;
+				break;
+			}
+			break;
+		default:
+			switch (stylePrevCh) {
+			case SCE_PL_HERE_QQ :
+			case SCE_PL_HERE_Q :
+			case SCE_PL_HERE_QX :
+				levelCurrent--;
+				break;
+			default :
+				//do nothing;
+				break;
+			}
+			break;
+		}
+
+		//explicit folding
+		if (options.foldCommentExplicit && style == SCE_PL_COMMENTLINE && ch == '#') {
+			if (chNext == '{') {
+				levelCurrent++;
+			} else if (levelCurrent > SC_FOLDLEVELBASE  && chNext == '}') {
+				levelCurrent--;
+			}
+		}
+
+		if (atEOL) {
+			int lev = levelPrev;
+			// POD headings occupy bits 7-4, leaving some breathing room for
+			// non-standard practice -- POD sections stuck in blocks, etc.
+			if (podHeading > 0) {
+				levelCurrent = (lev & ~PERL_HEADFOLD_MASK) | (podHeading << PERL_HEADFOLD_SHIFT);
+				lev = levelCurrent - 1;
+				lev |= SC_FOLDLEVELHEADERFLAG;
+				podHeading = 0;
+			}
+			// Check if line was a package declaration
+			// because packages need "special" treatment
+			if (isPackageLine) {
+				lev = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;
+				levelCurrent = SC_FOLDLEVELBASE + 1;
+				isPackageLine = false;
+			}
+			lev |= levelCurrent << 16;
+			if (visibleChars == 0 && options.foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if ((levelCurrent > levelPrev) && (visibleChars > 0))
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			levelPrev = levelCurrent;
+			visibleChars = 0;
+		}
+		if (!isspacechar(ch))
+			visibleChars++;
+		chPrev = ch;
+	}
+	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
+	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
+	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
+}
+
+LexerModule lmPerl(SCLEX_PERL, LexerPerl::LexerFactoryPerl, "perl", perlWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexPowerPro.cxx b/Pythonwin/Scintilla/lexers/LexPowerPro.cxx
new file mode 100644
index 000000000..34debff24
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexPowerPro.cxx
@@ -0,0 +1,628 @@
+// Scintilla source code edit control
+// @file LexPowerPro.cxx
+// PowerPro utility, written by Bruce Switzer, is available from http://powerpro.webeddie.com
+// PowerPro lexer is written by Christopher Bean (cbean@cb-software.net)
+//
+// Lexer code heavily borrowed from:
+//	LexAU3.cxx by Jos van der Zande
+//	LexCPP.cxx by Neil Hodgson
+//	LexVB.cxx by Neil Hodgson
+//
+// Changes:
+// 	2008-10-25 - Initial release
+//	2008-10-26 - Changed how <name> is hilighted in  'function <name>' so that
+//				 local isFunction = "" and local functions = "" don't get falsely highlighted
+//	2008-12-14 - Added bounds checking for szFirstWord and szDo
+//			   - Replaced SetOfCharacters with CharacterSet
+//			   - Made sure that CharacterSet::Contains is passed only positive values
+//			   - Made sure that the return value of Accessor::SafeGetCharAt is positive before
+//				 passing to functions that require positive values like isspacechar()
+//			   - Removed unused visibleChars processing from ColourisePowerProDoc()
+//			   - Fixed bug with folding logic where line continuations didn't end where
+//				 they were supposed to
+//			   - Moved all helper functions to the top of the file
+//	2010-06-03 - Added onlySpaces variable to allow the @function and ;comment styles to be indented
+//			   - Modified HasFunction function to be a bit more robust
+//			   - Renamed HasFunction function to IsFunction
+//			   - Cleanup
+// Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static inline bool IsStreamCommentStyle(int style) {
+	return style == SCE_POWERPRO_COMMENTBLOCK;
+}
+
+static inline bool IsLineEndChar(unsigned char ch) {
+	return 	ch == 0x0a 		//LF
+			|| ch == 0x0c	//FF
+			|| ch == 0x0d;	//CR
+}
+
+static bool IsContinuationLine(Sci_PositionU szLine, Accessor &styler)
+{
+	Sci_Position startPos = styler.LineStart(szLine);
+	Sci_Position endPos = styler.LineStart(szLine + 1) - 2;
+	while (startPos < endPos)
+	{
+		char stylech = styler.StyleAt(startPos);
+		if (!(stylech == SCE_POWERPRO_COMMENTBLOCK)) {
+			char ch = styler.SafeGetCharAt(endPos);
+			char chPrev = styler.SafeGetCharAt(endPos - 1);
+			char chPrevPrev = styler.SafeGetCharAt(endPos - 2);
+			if (ch > 0 && chPrev > 0 && chPrevPrev > 0 && !isspacechar(ch) && !isspacechar(chPrev) && !isspacechar(chPrevPrev) )
+				return (chPrevPrev == ';' && chPrev == ';' && ch == '+');
+			}
+		endPos--; // skip to next char
+	}
+	return false;
+}
+
+// Routine to find first none space on the current line and return its Style
+// needed for comment lines not starting on pos 1
+static int GetStyleFirstWord(Sci_Position szLine, Accessor &styler)
+{
+	Sci_Position startPos = styler.LineStart(szLine);
+	Sci_Position endPos = styler.LineStart(szLine + 1) - 1;
+	char ch = styler.SafeGetCharAt(startPos);
+
+	while (ch > 0 && isspacechar(ch) && startPos < endPos)
+	{
+		startPos++; // skip to next char
+		ch = styler.SafeGetCharAt(startPos);
+	}
+	return styler.StyleAt(startPos);
+}
+
+//returns true if there is a function to highlight
+//used to highlight <name> in 'function <name>'
+//note:
+//		sample line (without quotes): "\tfunction asdf()
+//		currentPos will be the position of 'a'
+static bool IsFunction(Accessor &styler, Sci_PositionU currentPos) {
+
+	const char function[10] = "function "; //10 includes \0
+	unsigned int numberOfCharacters = sizeof(function) - 1;
+	Sci_PositionU position = currentPos - numberOfCharacters;
+
+	//compare each character with the letters in the function array
+	//return false if ALL don't match
+	for (Sci_PositionU i = 0; i < numberOfCharacters; i++) {
+		char c = styler.SafeGetCharAt(position++);
+		if (c != function[i])
+			return false;
+	}
+
+	//make sure that there are only spaces (or tabs) between the beginning
+	//of the line and the function declaration
+	position = currentPos - numberOfCharacters - 1; 		//-1 to move to char before 'function'
+	for (Sci_PositionU j = 0; j < 16; j++) {					//check up to 16 preceeding characters
+		char c = styler.SafeGetCharAt(position--, '\0');	//if can't read char, return NUL (past beginning of document)
+		if (c <= 0)	//reached beginning of document
+			return true;
+		if (c > 0 && IsLineEndChar(c))
+			return true;
+		else if (c > 0 && !IsASpaceOrTab(c))
+			return false;
+	}
+
+	//fall-through
+	return false;
+}
+
+static void ColourisePowerProDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+                            Accessor &styler, bool caseSensitive) {
+
+	WordList &keywords  = *keywordlists[0];
+	WordList &keywords2 = *keywordlists[1];
+	WordList &keywords3 = *keywordlists[2];
+	WordList &keywords4 = *keywordlists[3];
+
+	//define the character sets
+	CharacterSet setWordStart(CharacterSet::setAlpha, "_@", 0x80, true);
+	CharacterSet setWord(CharacterSet::setAlphaNum, "._", 0x80, true);
+
+	StyleContext sc(startPos, length, initStyle, styler);
+	char s_save[100]; //for last line highlighting
+
+	//are there only spaces between the first letter of the line and the beginning of the line
+	bool onlySpaces = true;
+
+	for (; sc.More(); sc.Forward()) {
+
+		// save the total current word for eof processing
+		char s[100];
+		sc.GetCurrentLowered(s, sizeof(s));
+
+		if ((sc.ch > 0) && setWord.Contains(sc.ch))
+		{
+			strcpy(s_save,s);
+			int tp = static_cast<int>(strlen(s_save));
+			if (tp < 99) {
+				s_save[tp] = static_cast<char>(tolower(sc.ch));
+				s_save[tp+1] = '\0';
+			}
+		}
+
+		if (sc.atLineStart) {
+			if (sc.state == SCE_POWERPRO_DOUBLEQUOTEDSTRING) {
+				// Prevent SCE_POWERPRO_STRINGEOL from leaking back to previous line which
+				// ends with a line continuation by locking in the state upto this position.
+				sc.SetState(SCE_POWERPRO_DOUBLEQUOTEDSTRING);
+			}
+		}
+
+		// Determine if the current state should terminate.
+		switch (sc.state) {
+			case SCE_POWERPRO_OPERATOR:
+				sc.SetState(SCE_POWERPRO_DEFAULT);
+				break;
+
+			case SCE_POWERPRO_NUMBER:
+
+				if (!IsADigit(sc.ch))
+					sc.SetState(SCE_POWERPRO_DEFAULT);
+
+				break;
+
+			case SCE_POWERPRO_IDENTIFIER:
+				//if ((sc.ch > 0) && !setWord.Contains(sc.ch) || (sc.ch == '.')) { // use this line if don't want to match keywords with . in them. ie: win.debug will match both win and debug so win debug will also be colorized
+				if ((sc.ch > 0) && !setWord.Contains(sc.ch)){  // || (sc.ch == '.')) { // use this line if you want to match keywords with a . ie: win.debug will only match win.debug neither win nor debug will be colorized separately
+					char s[1000];
+					if (caseSensitive) {
+						sc.GetCurrent(s, sizeof(s));
+					} else {
+						sc.GetCurrentLowered(s, sizeof(s));
+					}
+
+					if (keywords.InList(s)) {
+						sc.ChangeState(SCE_POWERPRO_WORD);
+					} else if (keywords2.InList(s)) {
+						sc.ChangeState(SCE_POWERPRO_WORD2);
+					} else if (keywords3.InList(s)) {
+						sc.ChangeState(SCE_POWERPRO_WORD3);
+					} else if (keywords4.InList(s)) {
+						sc.ChangeState(SCE_POWERPRO_WORD4);
+					}
+					sc.SetState(SCE_POWERPRO_DEFAULT);
+				}
+				break;
+
+			case SCE_POWERPRO_LINECONTINUE:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_POWERPRO_DEFAULT);
+				} else if (sc.Match('/', '*') || sc.Match('/', '/')) {
+					sc.SetState(SCE_POWERPRO_DEFAULT);
+				}
+				break;
+
+			case SCE_POWERPRO_COMMENTBLOCK:
+				if (sc.Match('*', '/')) {
+					sc.Forward();
+					sc.ForwardSetState(SCE_POWERPRO_DEFAULT);
+				}
+				break;
+
+			case SCE_POWERPRO_COMMENTLINE:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_POWERPRO_DEFAULT);
+				}
+				break;
+
+			case SCE_POWERPRO_DOUBLEQUOTEDSTRING:
+				if (sc.atLineEnd) {
+					sc.ChangeState(SCE_POWERPRO_STRINGEOL);
+				} else if (sc.ch == '\\') {
+					if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+						sc.Forward();
+					}
+				} else if (sc.ch == '\"') {
+					sc.ForwardSetState(SCE_POWERPRO_DEFAULT);
+				}
+				break;
+
+			case SCE_POWERPRO_SINGLEQUOTEDSTRING:
+				if (sc.atLineEnd) {
+					sc.ChangeState(SCE_POWERPRO_STRINGEOL);
+				} else if (sc.ch == '\\') {
+					if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+						sc.Forward();
+					}
+				} else if (sc.ch == '\'') {
+					sc.ForwardSetState(SCE_POWERPRO_DEFAULT);
+				}
+				break;
+
+			case SCE_POWERPRO_STRINGEOL:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_POWERPRO_DEFAULT);
+				}
+				break;
+
+			case SCE_POWERPRO_VERBATIM:
+				if (sc.ch == '\"') {
+					if (sc.chNext == '\"') {
+						sc.Forward();
+					} else {
+						sc.ForwardSetState(SCE_POWERPRO_DEFAULT);
+					}
+				}
+				break;
+
+			case SCE_POWERPRO_ALTQUOTE:
+				if (sc.ch == '#') {
+					if (sc.chNext == '#') {
+						sc.Forward();
+					} else {
+						sc.ForwardSetState(SCE_POWERPRO_DEFAULT);
+					}
+				}
+				break;
+
+			case SCE_POWERPRO_FUNCTION:
+				if (isspacechar(sc.ch) || sc.ch == '(') {
+					sc.SetState(SCE_POWERPRO_DEFAULT);
+				}
+			break;
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_POWERPRO_DEFAULT) {
+			if (sc.Match('?', '\"')) {
+				sc.SetState(SCE_POWERPRO_VERBATIM);
+				sc.Forward();
+			} else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
+				sc.SetState(SCE_POWERPRO_NUMBER);
+			}else if (sc.Match('?','#')) {
+				if (sc.ch == '?' && sc.chNext == '#') {
+					sc.SetState(SCE_POWERPRO_ALTQUOTE);
+					sc.Forward();
+				}
+			} else if (IsFunction(styler, sc.currentPos)) {	//highlight <name> in 'function <name>'
+				sc.SetState(SCE_POWERPRO_FUNCTION);
+			} else if (onlySpaces && sc.ch == '@') { 		//alternate function definition [label]
+				sc.SetState(SCE_POWERPRO_FUNCTION);
+			} else if ((sc.ch > 0) && (setWordStart.Contains(sc.ch) || (sc.ch == '?'))) {
+				sc.SetState(SCE_POWERPRO_IDENTIFIER);
+			} else if (sc.Match(";;+")) {
+				sc.SetState(SCE_POWERPRO_LINECONTINUE);
+			} else if (sc.Match('/', '*')) {
+				sc.SetState(SCE_POWERPRO_COMMENTBLOCK);
+				sc.Forward();	// Eat the * so it isn't used for the end of the comment
+			} else if (sc.Match('/', '/')) {
+				sc.SetState(SCE_POWERPRO_COMMENTLINE);
+			} else if (onlySpaces && sc.ch == ';') {		//legacy comment that can only have blank space in front of it
+				sc.SetState(SCE_POWERPRO_COMMENTLINE);
+			} else if (sc.Match(";;")) {
+				sc.SetState(SCE_POWERPRO_COMMENTLINE);
+			} else if (sc.ch == '\"') {
+				sc.SetState(SCE_POWERPRO_DOUBLEQUOTEDSTRING);
+			} else if (sc.ch == '\'') {
+				sc.SetState(SCE_POWERPRO_SINGLEQUOTEDSTRING);
+			} else if (isoperator(static_cast<char>(sc.ch))) {
+				sc.SetState(SCE_POWERPRO_OPERATOR);
+			}
+		}
+
+		//maintain a record of whether or not all the preceding characters on
+		//a line are space characters
+		if (onlySpaces && !IsASpaceOrTab(sc.ch))
+			onlySpaces = false;
+
+		//reset when starting a new line
+		if (sc.atLineEnd)
+			onlySpaces = true;
+	}
+
+	//*************************************
+	// Colourize the last word correctly
+	//*************************************
+	if (sc.state == SCE_POWERPRO_IDENTIFIER)
+	{
+		if (keywords.InList(s_save)) {
+			sc.ChangeState(SCE_POWERPRO_WORD);
+			sc.SetState(SCE_POWERPRO_DEFAULT);
+		}
+		else if (keywords2.InList(s_save)) {
+			sc.ChangeState(SCE_POWERPRO_WORD2);
+			sc.SetState(SCE_POWERPRO_DEFAULT);
+		}
+		else if (keywords3.InList(s_save)) {
+			sc.ChangeState(SCE_POWERPRO_WORD3);
+			sc.SetState(SCE_POWERPRO_DEFAULT);
+		}
+		else if (keywords4.InList(s_save)) {
+			sc.ChangeState(SCE_POWERPRO_WORD4);
+			sc.SetState(SCE_POWERPRO_DEFAULT);
+		}
+		else {
+			sc.SetState(SCE_POWERPRO_DEFAULT);
+		}
+	}
+	sc.Complete();
+}
+
+static void FoldPowerProDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler)
+{
+	//define the character sets
+	CharacterSet setWordStart(CharacterSet::setAlpha, "_@", 0x80, true);
+	CharacterSet setWord(CharacterSet::setAlphaNum, "._", 0x80, true);
+
+	//used to tell if we're recursively folding the whole document, or just a small piece (ie: if statement or 1 function)
+	bool isFoldingAll = true;
+
+	Sci_Position endPos = startPos + length;
+	Sci_Position lastLine = styler.GetLine(styler.Length()); //used to help fold the last line correctly
+
+	// get settings from the config files for folding comments and preprocessor lines
+	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+	bool foldInComment = styler.GetPropertyInt("fold.comment") == 2;
+	bool foldCompact = true;
+
+	// Backtrack to previous line in case need to fix its fold status
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	if (startPos > 0) {
+		isFoldingAll = false;
+		if (lineCurrent > 0) {
+			lineCurrent--;
+			startPos = styler.LineStart(lineCurrent);
+		}
+	}
+	// vars for style of previous/current/next lines
+	int style = GetStyleFirstWord(lineCurrent,styler);
+	int stylePrev = 0;
+
+	// find the first previous line without continuation character at the end
+	while ((lineCurrent > 0 && IsContinuationLine(lineCurrent, styler))
+	       || (lineCurrent > 1 && IsContinuationLine(lineCurrent - 1, styler))) {
+		lineCurrent--;
+		startPos = styler.LineStart(lineCurrent);
+	}
+
+	if (lineCurrent > 0) {
+		stylePrev = GetStyleFirstWord(lineCurrent-1,styler);
+	}
+
+	// vars for getting first word to check for keywords
+	bool isFirstWordStarted = false;
+	bool isFirstWordEnded = false;
+
+	const unsigned int FIRST_WORD_MAX_LEN = 10;
+	char szFirstWord[FIRST_WORD_MAX_LEN] = "";
+	unsigned int firstWordLen = 0;
+
+	char szDo[3]="";
+	int	 szDolen = 0;
+	bool isDoLastWord = false;
+
+	// var for indentlevel
+	int levelCurrent = SC_FOLDLEVELBASE;
+	if (lineCurrent > 0)
+		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
+	int levelNext = levelCurrent;
+
+	int	visibleChars = 0;
+	int functionCount = 0;
+
+	char chNext = styler.SafeGetCharAt(startPos);
+	char chPrev = '\0';
+	char chPrevPrev = '\0';
+	char chPrevPrevPrev = '\0';
+
+	for (Sci_Position i = startPos; i < endPos; i++) {
+
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+
+		if ((ch > 0) && setWord.Contains(ch))
+			visibleChars++;
+
+		// get the syle for the current character neede to check in comment
+		int stylech = styler.StyleAt(i);
+
+		// start the capture of the first word
+		if (!isFirstWordStarted && (ch > 0)) {
+			if (setWord.Contains(ch) || setWordStart.Contains(ch) || ch == ';' || ch == '/') {
+				isFirstWordStarted = true;
+				if (firstWordLen < FIRST_WORD_MAX_LEN - 1) {
+					szFirstWord[firstWordLen++] = static_cast<char>(tolower(ch));
+					szFirstWord[firstWordLen] = '\0';
+				}
+			}
+		} // continue capture of the first word on the line
+		else if (isFirstWordStarted && !isFirstWordEnded && (ch > 0)) {
+			if (!setWord.Contains(ch)) {
+				isFirstWordEnded = true;
+			}
+			else if (firstWordLen < (FIRST_WORD_MAX_LEN - 1)) {
+				szFirstWord[firstWordLen++] = static_cast<char>(tolower(ch));
+				szFirstWord[firstWordLen] = '\0';
+			}
+		}
+
+		if (stylech != SCE_POWERPRO_COMMENTLINE) {
+
+			//reset isDoLastWord if we find a character(ignoring spaces) after 'do'
+			if (isDoLastWord && (ch > 0) && setWord.Contains(ch))
+				isDoLastWord = false;
+
+			// --find out if the word "do" is the last on a "if" line--
+			// collect each letter and put it into a buffer 2 chars long
+			// if we end up with "do" in the buffer when we reach the end of
+			// the line, "do" was the last word on the line
+			if ((ch > 0) && isFirstWordEnded && strcmp(szFirstWord, "if") == 0) {
+				if (szDolen == 2) {
+					szDo[0] = szDo[1];
+					szDo[1] = static_cast<char>(tolower(ch));
+					szDo[2] = '\0';
+
+					if (strcmp(szDo, "do") == 0)
+						isDoLastWord = true;
+
+				} else if (szDolen < 2) {
+					szDo[szDolen++] = static_cast<char>(tolower(ch));
+					szDo[szDolen] = '\0';
+				}
+			}
+		}
+
+		// End of Line found so process the information
+		 if ((ch == '\r' && chNext != '\n') // \r\n
+			|| ch == '\n' 					// \n
+			|| i == endPos) {				// end of selection
+
+			// **************************
+			// Folding logic for Keywords
+			// **************************
+
+			// if a keyword is found on the current line and the line doesn't end with ;;+ (continuation)
+			//    and we are not inside a commentblock.
+			if (firstWordLen > 0
+				&& chPrev != '+' && chPrevPrev != ';' && chPrevPrevPrev !=';'
+				&& (!IsStreamCommentStyle(style) || foldInComment) ) {
+
+				// only fold "if" last keyword is "then"  (else its a one line if)
+				if (strcmp(szFirstWord, "if") == 0  && isDoLastWord)
+						levelNext++;
+
+				// create new fold for these words
+				if (strcmp(szFirstWord, "for") == 0)
+					levelNext++;
+
+				//handle folding for functions/labels
+				//Note: Functions and labels don't have an explicit end like [end function]
+				//	1. functions/labels end at the start of another function
+				//	2. functions/labels end at the end of the file
+				if ((strcmp(szFirstWord, "function") == 0) || (firstWordLen > 0 && szFirstWord[0] == '@')) {
+					if (isFoldingAll) { //if we're folding the whole document (recursivly by lua script)
+
+						if (functionCount > 0) {
+							levelCurrent--;
+						} else {
+							levelNext++;
+						}
+						functionCount++;
+
+					} else { //if just folding a small piece (by clicking on the minus sign next to the word)
+						levelCurrent--;
+					}
+				}
+
+				// end the fold for these words before the current line
+				if (strcmp(szFirstWord, "endif") == 0 || strcmp(szFirstWord, "endfor") == 0) {
+						levelNext--;
+						levelCurrent--;
+				}
+
+				// end the fold for these words before the current line and Start new fold
+				if (strcmp(szFirstWord, "else") == 0 || strcmp(szFirstWord, "elseif") == 0 )
+						levelCurrent--;
+
+			}
+			// Preprocessor and Comment folding
+			int styleNext = GetStyleFirstWord(lineCurrent + 1,styler);
+
+			// *********************************
+			// Folding logic for Comment blocks
+			// *********************************
+			if (foldComment && IsStreamCommentStyle(style)) {
+
+				// Start of a comment block
+				if (stylePrev != style && IsStreamCommentStyle(styleNext) && styleNext == style) {
+				    levelNext++;
+				} // fold till the last line for normal comment lines
+				else if (IsStreamCommentStyle(stylePrev)
+						&& styleNext != SCE_POWERPRO_COMMENTLINE
+						&& stylePrev == SCE_POWERPRO_COMMENTLINE
+						&& style == SCE_POWERPRO_COMMENTLINE) {
+					levelNext--;
+				} // fold till the one but last line for Blockcomment lines
+				else if (IsStreamCommentStyle(stylePrev)
+						&& styleNext != SCE_POWERPRO_COMMENTBLOCK
+						&& style == SCE_POWERPRO_COMMENTBLOCK) {
+					levelNext--;
+					levelCurrent--;
+				}
+			}
+
+			int levelUse = levelCurrent;
+			int lev = levelUse | levelNext << 16;
+			if (visibleChars == 0 && foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if (levelUse < levelNext)
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent))
+				styler.SetLevel(lineCurrent, lev);
+
+			// reset values for the next line
+			lineCurrent++;
+			stylePrev = style;
+			style = styleNext;
+			levelCurrent = levelNext;
+			visibleChars = 0;
+
+			// if the last characters are ;;+ then don't reset since the line continues on the next line.
+			if (chPrev != '+' && chPrevPrev != ';' && chPrevPrevPrev != ';') {
+				firstWordLen = 0;
+				szDolen = 0;
+				isFirstWordStarted = false;
+				isFirstWordEnded = false;
+				isDoLastWord = false;
+
+				//blank out first word
+				for (unsigned int i = 0; i < FIRST_WORD_MAX_LEN; i++)
+					szFirstWord[i] = '\0';
+			}
+		}
+
+		// save the last processed characters
+		if ((ch > 0) && !isspacechar(ch)) {
+			chPrevPrevPrev = chPrevPrev;
+			chPrevPrev = chPrev;
+			chPrev = ch;
+		}
+	}
+
+	//close folds on the last line - without this a 'phantom'
+	//fold can appear when an open fold is on the last line
+	//this can occur because functions and labels don't have an explicit end
+	if (lineCurrent >= lastLine) {
+		int lev = 0;
+		lev |= SC_FOLDLEVELWHITEFLAG;
+		styler.SetLevel(lineCurrent, lev);
+	}
+
+}
+
+static const char * const powerProWordLists[] = {
+            "Keyword list 1",
+            "Keyword list 2",
+            "Keyword list 3",
+            "Keyword list 4",
+            0,
+        };
+
+static void ColourisePowerProDocWrapper(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+                                       Accessor &styler) {
+	ColourisePowerProDoc(startPos, length, initStyle, keywordlists, styler, false);
+}
+
+LexerModule lmPowerPro(SCLEX_POWERPRO, ColourisePowerProDocWrapper, "powerpro", FoldPowerProDoc, powerProWordLists);
+
+
diff --git a/Pythonwin/Scintilla/src/LexPowerShell.cxx b/Pythonwin/Scintilla/lexers/LexPowerShell.cxx
similarity index 57%
rename from Pythonwin/Scintilla/src/LexPowerShell.cxx
rename to Pythonwin/Scintilla/lexers/LexPowerShell.cxx
index d16ba9842..9969df35d 100644
--- a/Pythonwin/Scintilla/src/LexPowerShell.cxx
+++ b/Pythonwin/Scintilla/lexers/LexPowerShell.cxx
@@ -7,34 +7,38 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 // Extended to accept accented characters
 static inline bool IsAWordChar(int ch) {
-	return ch >= 0x80 || isalnum(ch) || ch == '-';
+	return ch >= 0x80 || isalnum(ch) || ch == '-' || ch == '_';
 }
 
-static void ColourisePowerShellDoc(unsigned int startPos, int length, int initStyle,
-                           WordList *keywordlists[], Accessor &styler) {
+static void ColourisePowerShellDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+				   WordList *keywordlists[], Accessor &styler) {
 
 	WordList &keywords = *keywordlists[0];
 	WordList &keywords2 = *keywordlists[1];
 	WordList &keywords3 = *keywordlists[2];
+	WordList &keywords4 = *keywordlists[3];
+	WordList &keywords5 = *keywordlists[4];
+	WordList &keywords6 = *keywordlists[5];
 
 	styler.StartAt(startPos);
 
@@ -46,15 +50,52 @@ static void ColourisePowerShellDoc(unsigned int startPos, int length, int initSt
 			if (sc.atLineEnd) {
 				sc.SetState(SCE_POWERSHELL_DEFAULT);
 			}
+		} else if (sc.state == SCE_POWERSHELL_COMMENTSTREAM) {
+			if (sc.atLineStart) {
+				while (IsASpaceOrTab(sc.ch)) {
+					sc.Forward();
+				}
+				if (sc.ch == '.' && IsAWordChar(sc.chNext)) {
+					sc.SetState(SCE_POWERSHELL_COMMENTDOCKEYWORD);
+				}
+			}
+			if (sc.ch == '>' && sc.chPrev == '#') {
+				sc.ForwardSetState(SCE_POWERSHELL_DEFAULT);
+			}
+		} else if (sc.state == SCE_POWERSHELL_COMMENTDOCKEYWORD) {
+			if (!IsAWordChar(sc.ch)) {
+				char s[100];
+				sc.GetCurrentLowered(s, sizeof(s));
+				if (!keywords6.InList(s + 1)) {
+					sc.ChangeState(SCE_POWERSHELL_COMMENTSTREAM);
+				}
+				sc.SetState(SCE_POWERSHELL_COMMENTSTREAM);
+			}
 		} else if (sc.state == SCE_POWERSHELL_STRING) {
 			// This is a doubles quotes string
 			if (sc.ch == '\"') {
 				sc.ForwardSetState(SCE_POWERSHELL_DEFAULT);
+			} else if (sc.ch == '`') {
+				sc.Forward(); // skip next escaped character
 			}
 		} else if (sc.state == SCE_POWERSHELL_CHARACTER) {
 			// This is a single quote string
 			if (sc.ch == '\'') {
 				sc.ForwardSetState(SCE_POWERSHELL_DEFAULT);
+			} else if (sc.ch == '`') {
+				sc.Forward(); // skip next escaped character
+			}
+		} else if (sc.state == SCE_POWERSHELL_HERE_STRING) {
+			// This is a doubles quotes here-string
+			if (sc.atLineStart && sc.ch == '\"' && sc.chNext == '@') {
+				sc.Forward(2);
+				sc.SetState(SCE_POWERSHELL_DEFAULT);
+			}
+		} else if (sc.state == SCE_POWERSHELL_HERE_CHARACTER) {
+			// This is a single quote here-string
+			if (sc.atLineStart && sc.ch == '\'' && sc.chNext == '@') {
+				sc.Forward(2);
+				sc.SetState(SCE_POWERSHELL_DEFAULT);
 			}
 		} else if (sc.state == SCE_POWERSHELL_NUMBER) {
 			if (!IsADigit(sc.ch)) {
@@ -79,6 +120,10 @@ static void ColourisePowerShellDoc(unsigned int startPos, int length, int initSt
 					sc.ChangeState(SCE_POWERSHELL_CMDLET);
 				} else if (keywords3.InList(s)) {
 					sc.ChangeState(SCE_POWERSHELL_ALIAS);
+				} else if (keywords4.InList(s)) {
+					sc.ChangeState(SCE_POWERSHELL_FUNCTION);
+				} else if (keywords5.InList(s)) {
+					sc.ChangeState(SCE_POWERSHELL_USER1);
 				}
 				sc.SetState(SCE_POWERSHELL_DEFAULT);
 			}
@@ -88,10 +133,16 @@ static void ColourisePowerShellDoc(unsigned int startPos, int length, int initSt
 		if (sc.state == SCE_POWERSHELL_DEFAULT) {
 			if (sc.ch == '#') {
 				sc.SetState(SCE_POWERSHELL_COMMENT);
+			} else if (sc.ch == '<' && sc.chNext == '#') {
+				sc.SetState(SCE_POWERSHELL_COMMENTSTREAM);
 			} else if (sc.ch == '\"') {
 				sc.SetState(SCE_POWERSHELL_STRING);
 			} else if (sc.ch == '\'') {
 				sc.SetState(SCE_POWERSHELL_CHARACTER);
+			} else if (sc.ch == '@' && sc.chNext == '\"') {
+				sc.SetState(SCE_POWERSHELL_HERE_STRING);
+			} else if (sc.ch == '@' && sc.chNext == '\'') {
+				sc.SetState(SCE_POWERSHELL_HERE_CHARACTER);
 			} else if (sc.ch == '$') {
 				sc.SetState(SCE_POWERSHELL_VARIABLE);
 			} else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
@@ -100,6 +151,8 @@ static void ColourisePowerShellDoc(unsigned int startPos, int length, int initSt
 				sc.SetState(SCE_POWERSHELL_OPERATOR);
 			} else if (IsAWordChar(sc.ch)) {
 				sc.SetState(SCE_POWERSHELL_IDENTIFIER);
+			} else if (sc.ch == '`') {
+				sc.Forward(); // skip next escaped character
 			}
 		}
 	}
@@ -109,13 +162,14 @@ static void ColourisePowerShellDoc(unsigned int startPos, int length, int initSt
 // Store both the current line's fold level and the next lines in the
 // level store to make it easy to pick up with each increment
 // and to make it possible to fiddle the current level for "} else {".
-static void FoldPowerShellDoc(unsigned int startPos, int length, int,
-                           WordList *[], Accessor &styler) {
+static void FoldPowerShellDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+			      WordList *[], Accessor &styler) {
+	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
 	bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0;
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelCurrent = SC_FOLDLEVELBASE;
 	if (lineCurrent > 0)
 		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
@@ -123,10 +177,12 @@ static void FoldPowerShellDoc(unsigned int startPos, int length, int,
 	int levelNext = levelCurrent;
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
-	for (unsigned int i = startPos; i < endPos; i++) {
+	int style = initStyle;
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
-		int style = styleNext;
+		int stylePrev = style;
+		style = styleNext;
 		styleNext = styler.StyleAt(i + 1);
 		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
 		if (style == SCE_POWERSHELL_OPERATOR) {
@@ -140,6 +196,24 @@ static void FoldPowerShellDoc(unsigned int startPos, int length, int,
 			} else if (ch == '}') {
 				levelNext--;
 			}
+		} else if (foldComment && style == SCE_POWERSHELL_COMMENTSTREAM) {
+			if (stylePrev != SCE_POWERSHELL_COMMENTSTREAM && stylePrev != SCE_POWERSHELL_COMMENTDOCKEYWORD) {
+				levelNext++;
+			} else if (styleNext != SCE_POWERSHELL_COMMENTSTREAM && styleNext != SCE_POWERSHELL_COMMENTDOCKEYWORD) {
+				levelNext--;
+			}
+		} else if (foldComment && style == SCE_POWERSHELL_COMMENT) {
+			if (ch == '#') {
+				Sci_PositionU j = i + 1;
+				while ((j < endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
+					j++;
+				}
+				if (styler.Match(j, "region")) {
+					levelNext++;
+				} else if (styler.Match(j, "endregion")) {
+					levelNext--;
+				}
+			}
 		}
 		if (!IsASpace(ch))
 			visibleChars++;
@@ -164,10 +238,13 @@ static void FoldPowerShellDoc(unsigned int startPos, int length, int,
 	}
 }
 
-static const char * const powershellWordLists[] = {
+static const char *const powershellWordLists[] = {
 	"Commands",
 	"Cmdlets",
 	"Aliases",
+	"Functions",
+	"User1",
+	"DocComment",
 	0
 };
 
diff --git a/Pythonwin/Scintilla/lexers/LexProgress.cxx b/Pythonwin/Scintilla/lexers/LexProgress.cxx
new file mode 100644
index 000000000..2a545b6ec
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexProgress.cxx
@@ -0,0 +1,568 @@
+// Scintilla source code edit control
+/** @file LexProgress.cxx
+ **  Lexer for Progress 4GL.
+ ** Based on LexCPP.cxx of Neil Hodgson <neilh@scintilla.org>
+  **/
+// Copyright 2006-2016 by Yuval Papish <Yuval@YuvCom.com>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+/** TODO:
+
+SpeedScript support in html lexer
+Differentiate between labels and variables
+  Option 1: By symbols table
+  Option 2: As a single unidentified symbol in a sytactical line
+
+**/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+#include <vector>
+#include <map>
+#include <algorithm>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "SparseState.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+namespace {
+   // Use an unnamed namespace to protect the functions and classes from name conflicts
+
+   bool IsSpaceEquiv(int state) {
+      return (state == SCE_ABL_COMMENT ||
+              state == SCE_ABL_LINECOMMENT ||
+              state == SCE_ABL_DEFAULT);
+   }
+
+   void highlightTaskMarker(StyleContext &sc, LexAccessor &styler, WordList &markerList){
+      if ((isoperator(sc.chPrev) || IsASpace(sc.chPrev)) && markerList.Length()) {
+         const int lengthMarker = 50;
+         char marker[lengthMarker+1];
+         Sci_Position currPos = (Sci_Position) sc.currentPos;
+         Sci_Position i = 0;
+         while (i < lengthMarker) {
+            char ch = styler.SafeGetCharAt(currPos + i);
+            if (IsASpace(ch) || isoperator(ch)) {
+               break;
+            }
+            marker[i] = ch;
+            i++;
+         }
+         marker[i] = '\0';
+         if (markerList.InListAbbreviated (marker,'(')) {
+            sc.SetState(SCE_ABL_TASKMARKER);
+         }
+      }
+   }
+
+   bool IsStreamCommentStyle(int style) {
+      return style == SCE_ABL_COMMENT;
+             // style == SCE_ABL_LINECOMMENT;  Only block comments are used for folding
+   }
+
+   // Options used for LexerABL
+   struct OptionsABL {
+      bool fold;
+      bool foldSyntaxBased;
+      bool foldComment;
+      bool foldCommentMultiline;
+      bool foldCompact;
+      OptionsABL() {
+         fold = false;
+         foldSyntaxBased = true;
+         foldComment = true;
+         foldCommentMultiline = true;
+         foldCompact = false;
+      }
+   };
+
+   const char *const ablWordLists[] = {
+               "Primary keywords and identifiers",
+               "Keywords that opens a block, only when used to begin a syntactic line",
+               "Keywords that opens a block anywhere in a syntactic line",
+               "Task Marker", /* "END MODIFY START TODO" */
+               0,
+   };
+
+   struct OptionSetABL : public OptionSet<OptionsABL> {
+      OptionSetABL() {
+         DefineProperty("fold", &OptionsABL::fold);
+
+         DefineProperty("fold.abl.syntax.based", &OptionsABL::foldSyntaxBased,
+            "Set this property to 0 to disable syntax based folding.");
+
+         DefineProperty("fold.comment", &OptionsABL::foldComment,
+            "This option enables folding multi-line comments and explicit fold points when using the ABL lexer. ");
+
+         DefineProperty("fold.abl.comment.multiline", &OptionsABL::foldCommentMultiline,
+            "Set this property to 0 to disable folding multi-line comments when fold.comment=1.");
+
+         DefineProperty("fold.compact", &OptionsABL::foldCompact);
+
+         DefineWordListSets(ablWordLists);
+      }
+   };
+}
+
+class LexerABL : public DefaultLexer {
+   CharacterSet setWord;
+   CharacterSet setNegationOp;
+   CharacterSet setArithmethicOp;
+   CharacterSet setRelOp;
+   CharacterSet setLogicalOp;
+   CharacterSet setWordStart;
+   WordList keywords1;      // regular keywords
+   WordList keywords2;      // block opening keywords, only when isSentenceStart
+   WordList keywords3;      // block opening keywords
+   WordList keywords4;      // Task Marker
+   OptionsABL options;
+   OptionSetABL osABL;
+public:
+   LexerABL() :
+      DefaultLexer("abl", SCLEX_PROGRESS),
+      setWord(CharacterSet::setAlphaNum, "_", 0x80, true),
+      setNegationOp(CharacterSet::setNone, "!"),
+      setArithmethicOp(CharacterSet::setNone, "+-/*%"),
+      setRelOp(CharacterSet::setNone, "=!<>"),
+      setLogicalOp(CharacterSet::setNone, "|&"){
+   }
+   virtual ~LexerABL() {
+   }
+   void SCI_METHOD Release() override {
+      delete this;
+   }
+   int SCI_METHOD Version() const override {
+      return lvRelease5;
+   }
+   const char * SCI_METHOD PropertyNames() override {
+      return osABL.PropertyNames();
+   }
+   int SCI_METHOD PropertyType(const char *name) override {
+      return osABL.PropertyType(name);
+   }
+   const char * SCI_METHOD DescribeProperty(const char *name) override {
+      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();
+   }
+   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 *) override {
+      return 0;
+   }
+   int SCI_METHOD LineEndTypesSupported() override {
+      return SC_LINE_END_TYPE_DEFAULT;
+   }
+   static ILexer5 *LexerFactoryABL() {
+      return new LexerABL();
+   }
+};
+
+Sci_Position SCI_METHOD LexerABL::PropertySet(const char *key, const char *val) {
+   if (osABL.PropertySet(&options, key, val)) {
+      return 0;
+   }
+   return -1;
+}
+
+Sci_Position SCI_METHOD LexerABL::WordListSet(int n, const char *wl) {
+   WordList *wordListN = 0;
+   switch (n) {
+   case 0:
+      wordListN = &keywords1;
+      break;
+   case 1:
+      wordListN = &keywords2;
+      break;
+   case 2:
+      wordListN = &keywords3;
+      break;
+   case 3:
+      wordListN = &keywords4;
+      break;
+   }
+   Sci_Position firstModification = -1;
+   if (wordListN) {
+      WordList wlNew;
+      wlNew.Set(wl);
+      if (*wordListN != wlNew) {
+         wordListN->Set(wl);
+         firstModification = 0;
+      }
+   }
+   return firstModification;
+}
+
+void SCI_METHOD LexerABL::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+   LexAccessor styler(pAccess);
+
+   setWordStart = CharacterSet(CharacterSet::setAlpha, "_", 0x80, true);
+
+   int visibleChars = 0;
+   int visibleChars1 = 0;
+   int styleBeforeTaskMarker = SCE_ABL_DEFAULT;
+   bool continuationLine = false;
+   int commentNestingLevel = 0;
+   bool isSentenceStart = true;
+   bool possibleOOLChange = false;
+
+   Sci_Position lineCurrent = styler.GetLine(startPos);
+   if (initStyle == SCE_ABL_PREPROCESSOR) {
+      // Set continuationLine if last character of previous line is '~'
+      if (lineCurrent > 0) {
+         Sci_Position endLinePrevious = styler.LineEnd(lineCurrent-1);
+         if (endLinePrevious > 0) {
+            continuationLine = styler.SafeGetCharAt(endLinePrevious-1) == '~';
+         }
+      }
+   }
+
+    // Look back to set variables that are actually invisible secondary states. The reason to avoid formal states is to cut down on state's bits
+   if (startPos > 0) {
+      Sci_Position back = startPos;
+      bool checkCommentNestingLevel = (initStyle == SCE_ABL_COMMENT);
+      bool checkIsSentenceStart = (initStyle == SCE_ABL_DEFAULT || initStyle == SCE_ABL_IDENTIFIER);
+      char ch;
+      char st;
+      char chPrev;
+      char chPrev_1;
+      char chPrev_2;
+      char chPrev_3;
+
+      while (back >= 0 && (checkCommentNestingLevel || checkIsSentenceStart)) {
+         ch = styler.SafeGetCharAt(back);
+         styler.Flush();  // looking at styles so need to flush
+         st = styler.StyleAt(back);
+
+         chPrev = styler.SafeGetCharAt(back-1);
+         // isSentenceStart is a non-visible state, used to identify where statements and preprocessor declerations can start
+         if (checkIsSentenceStart && st != SCE_ABL_COMMENT && st != SCE_ABL_LINECOMMENT && st != SCE_ABL_CHARACTER  && st != SCE_ABL_STRING ) {
+            chPrev_1 = styler.SafeGetCharAt(back-2);
+            chPrev_2 = styler.SafeGetCharAt(back-3);
+            chPrev_3 = styler.SafeGetCharAt(back-4);
+            if ((chPrev == '.' || chPrev == ':' || chPrev == '}' ||
+               (chPrev_3 == 'e' && chPrev_2 == 'l' && chPrev_1 == 's' &&  chPrev == 'e') ||
+               (chPrev_3 == 't' && chPrev_2 == 'h' && chPrev_1 == 'e' &&  chPrev == 'n')) &&
+               (IsASpace(ch) || (ch == '/' && styler.SafeGetCharAt(back+1) == '*'))
+               ) {
+                  checkIsSentenceStart = false;
+                  isSentenceStart = true;
+            }
+            else if (IsASpace(chPrev) && ch == '{') {
+               checkIsSentenceStart = false;
+               isSentenceStart = false;
+            }
+         }
+
+         // commentNestingLevel is a non-visible state, used to identify the nesting level of a comment
+         if (checkCommentNestingLevel) {
+            if (chPrev == '/' && ch == '*') {
+               commentNestingLevel++;
+               // eat the '/' so we don't miscount a */ if we see /*/*
+               --back;
+            }
+            if (chPrev == '*' && ch == '/') {
+               commentNestingLevel--;
+               // eat the '*' so we don't miscount a /* if we see */*/
+               --back;
+            }
+         }
+         --back;
+      }
+   }
+
+   StyleContext sc(startPos, length, initStyle, styler, static_cast<unsigned char>(0xff));
+   Sci_Position lineEndNext = styler.LineEnd(lineCurrent);
+
+   for (; sc.More();) {
+      if (sc.atLineStart) {
+         visibleChars = 0;
+         visibleChars1 = 0;
+      }
+      if (sc.atLineEnd) {
+         lineCurrent++;
+         lineEndNext = styler.LineEnd(lineCurrent);
+      }
+      // Handle line continuation generically.
+      if (sc.ch == '~') {
+         if (static_cast<Sci_Position>((sc.currentPos+1)) >= lineEndNext) {
+            lineCurrent++;
+            lineEndNext = styler.LineEnd(lineCurrent);
+            sc.Forward();
+            if (sc.ch == '\r' && sc.chNext == '\n') {
+               sc.Forward();
+            }
+            continuationLine = true;
+            sc.Forward();
+            continue;
+         }
+      }
+
+      const bool atLineEndBeforeSwitch = sc.atLineEnd;
+      // Determine if the current state should terminate.
+      switch (sc.state) {
+         case SCE_ABL_OPERATOR:
+            sc.SetState(SCE_ABL_DEFAULT);
+            break;
+         case SCE_ABL_NUMBER:
+            // We accept almost anything because of hex. and maybe number suffixes and scientific notations in the future
+            if (!(setWord.Contains(sc.ch)
+				   || ((sc.ch == '+' || sc.ch == '-') && (sc.chPrev == 'e' || sc.chPrev == 'E' ||
+				                                          sc.chPrev == 'p' || sc.chPrev == 'P')))) {
+               sc.SetState(SCE_ABL_DEFAULT);
+            }
+            break;
+         case SCE_ABL_IDENTIFIER:
+            if (sc.atLineStart || sc.atLineEnd || (!setWord.Contains(sc.ch) && sc.ch != '-')) {
+               char s[1000];
+               sc.GetCurrentLowered(s, sizeof(s));
+               bool isLastWordEnd = (s[0] == 'e' && s[1] =='n' && s[2] == 'd' && !IsAlphaNumeric(s[3]) && s[3] != '-');  // helps to identify "end trigger" phrase
+               if ((isSentenceStart && keywords2.InListAbbreviated (s,'(')) || (!isLastWordEnd && keywords3.InListAbbreviated (s,'('))) {
+                  sc.ChangeState(SCE_ABL_BLOCK);
+                  isSentenceStart = false;
+               }
+               else if (keywords1.InListAbbreviated (s,'(')) {
+                  if (isLastWordEnd ||
+                     (s[0] == 'f' && s[1] =='o' && s[2] == 'r' && s[3] == 'w' && s[4] =='a' && s[5] == 'r' && s[6] == 'd'&& !IsAlphaNumeric(s[7]))) {
+                     sc.ChangeState(SCE_ABL_END);
+                     isSentenceStart = false;
+                  }
+                  else if ((s[0] == 'e' && s[1] =='l' && s[2] == 's' && s[3] == 'e') ||
+                         (s[0] == 't' && s[1] =='h' && s[2] == 'e' && s[3] == 'n')) {
+                     sc.ChangeState(SCE_ABL_WORD);
+                     isSentenceStart = true;
+                  }
+                  else {
+                     sc.ChangeState(SCE_ABL_WORD);
+                     isSentenceStart = false;
+                  }
+               }
+               sc.SetState(SCE_ABL_DEFAULT);
+            }
+            break;
+         case SCE_ABL_PREPROCESSOR:
+            if (sc.atLineStart && !continuationLine) {
+               sc.SetState(SCE_ABL_DEFAULT);
+               // Force Scintilla to acknowledge changed stated even though this change might happen outside of the current line
+               possibleOOLChange = true;
+               isSentenceStart = true;
+            }
+            break;
+         case SCE_ABL_LINECOMMENT:
+            if (sc.atLineStart && !continuationLine) {
+               sc.SetState(SCE_ABL_DEFAULT);
+               isSentenceStart = true;
+            } else {
+               styleBeforeTaskMarker = SCE_ABL_LINECOMMENT;
+               highlightTaskMarker(sc, styler, keywords4);
+            }
+            break;
+         case SCE_ABL_TASKMARKER:
+            if (isoperator(sc.ch) || IsASpace(sc.ch)) {
+               sc.SetState(styleBeforeTaskMarker);
+               styleBeforeTaskMarker = SCE_ABL_DEFAULT;
+            }
+            // fall through
+         case SCE_ABL_COMMENT:
+            if (sc.Match('*', '/')) {
+               sc.Forward();
+               commentNestingLevel--;
+               if (commentNestingLevel == 0) {
+                  sc.ForwardSetState(SCE_ABL_DEFAULT);
+                  possibleOOLChange = true;
+               }
+            } else if (sc.Match('/', '*')) {
+               commentNestingLevel++;
+               sc.Forward();
+            }
+            if (commentNestingLevel > 0) {
+               styleBeforeTaskMarker = SCE_ABL_COMMENT;
+               possibleOOLChange = true;
+               highlightTaskMarker(sc, styler, keywords4);
+            }
+            break;
+         case SCE_ABL_STRING:
+            if (sc.ch == '~') {
+               sc.Forward(); // Skip a character after a tilde
+            } else if (sc.ch == '\"') {
+                  sc.ForwardSetState(SCE_ABL_DEFAULT);
+            }
+            break;
+         case SCE_ABL_CHARACTER:
+            if (sc.ch == '~') {
+               sc.Forward(); // Skip a character after a tilde
+            } else if (sc.ch == '\'') {
+                  sc.ForwardSetState(SCE_ABL_DEFAULT);
+            }
+            break;
+      }
+
+      if (sc.atLineEnd && !atLineEndBeforeSwitch) {
+         // State exit processing consumed characters up to end of line.
+         lineCurrent++;
+         lineEndNext = styler.LineEnd(lineCurrent);
+      }
+
+      // Determine if a new state should be entered.
+      if (sc.state == SCE_ABL_DEFAULT) {
+         if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
+               sc.SetState(SCE_ABL_NUMBER);
+               isSentenceStart = false;
+         } else if (!sc.atLineEnd && (setWordStart.Contains(sc.ch)) && sc.chPrev != '&') {
+               sc.SetState(SCE_ABL_IDENTIFIER);
+         } else if (sc.Match('/', '*')) {
+            if (sc.chPrev == '.' || sc.chPrev == ':' || sc.chPrev == '}') {
+               isSentenceStart = true;
+            }
+            sc.SetState(SCE_ABL_COMMENT);
+            possibleOOLChange = true;
+            commentNestingLevel++;
+            sc.Forward();   // Eat the * so it isn't used for the end of the comment
+         } else if (sc.ch == '\"') {
+               sc.SetState(SCE_ABL_STRING);
+               isSentenceStart = false;
+         } else if (sc.ch == '\'') {
+            sc.SetState(SCE_ABL_CHARACTER);
+            isSentenceStart = false;
+         } else if (sc.ch == '&' && visibleChars1 == 0 && isSentenceStart) {
+            // Preprocessor commands are alone on their line
+            sc.SetState(SCE_ABL_PREPROCESSOR);
+            // Force Scintilla to acknowledge changed stated even though this change might happen outside of the current line
+            possibleOOLChange = true;
+            // Skip whitespace between & and preprocessor word
+            do {
+               sc.Forward();
+            } while ((sc.ch == ' ' || sc.ch == '\t') && sc.More());
+            if (sc.atLineEnd) {
+               sc.SetState(SCE_ABL_DEFAULT);
+            }
+         } else if (sc.Match('/','/') && (IsASpace(sc.chPrev) || isSentenceStart)) {
+            // Line comments are valid after a white space or EOL
+            sc.SetState(SCE_ABL_LINECOMMENT);
+            // Skip whitespace between // and preprocessor word
+            do {
+               sc.Forward();
+            } while ((sc.ch == ' ' || sc.ch == '\t') && sc.More());
+            if (sc.atLineEnd) {
+               sc.SetState(SCE_ABL_DEFAULT);
+            }
+         } else if (isoperator(sc.ch)) {
+            sc.SetState(SCE_ABL_OPERATOR);
+            /*    This code allows highlight of handles. Alas, it would cause the phrase "last-event:function"
+               to be recognized as a BlockBegin */
+               isSentenceStart = false;
+         }
+         else if ((sc.chPrev == '.' || sc.chPrev == ':' || sc.chPrev == '}') && (IsASpace(sc.ch))) {
+            isSentenceStart = true;
+         }
+      }
+      if (!IsASpace(sc.ch)) {
+         visibleChars1++;
+      }
+      if (!IsASpace(sc.ch) && !IsSpaceEquiv(sc.state)) {
+         visibleChars++;
+      }
+      continuationLine = false;
+      sc.Forward();
+   }
+	if (possibleOOLChange)
+		styler.ChangeLexerState(startPos, startPos + length);
+   sc.Complete();
+}
+
+
+// Store both the current line's fold level and the next lines in the
+// level store to make it easy to pick up with each increment
+// and to make it possible to fiddle the current level for "} else {".
+
+void SCI_METHOD LexerABL::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+
+   if (!options.fold)
+      return;
+
+   LexAccessor styler(pAccess);
+
+   Sci_PositionU endPos = startPos + length;
+   int visibleChars = 0;
+   Sci_Position lineCurrent = styler.GetLine(startPos);
+   int levelCurrent = SC_FOLDLEVELBASE;
+   if (lineCurrent > 0)
+      levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
+   Sci_PositionU lineStartNext = styler.LineStart(lineCurrent+1);
+   int levelNext = levelCurrent;
+   char chNext = styler[startPos];
+   int styleNext = styler.StyleAt(startPos);
+   int style = initStyle;
+   for (Sci_PositionU i = startPos; i < endPos; i++) {
+      chNext = static_cast<char>(tolower(chNext));  // check tolower
+      char ch = chNext;
+      chNext = styler.SafeGetCharAt(i+1);
+      int stylePrev = style;
+      style = styleNext;
+      styleNext = styler.StyleAt(i+1);
+      bool atEOL = i == (lineStartNext-1);
+      if (options.foldComment && options.foldCommentMultiline && IsStreamCommentStyle(style)) {
+         if (!IsStreamCommentStyle(stylePrev)) {
+            levelNext++;
+         } else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
+            // Comments don't end at end of line and the next character may be unstyled.
+            levelNext--;
+         }
+      }
+      if (options.foldSyntaxBased) {
+         if (style == SCE_ABL_BLOCK && !IsAlphaNumeric(chNext)) {
+            levelNext++;
+         }
+         else if (style == SCE_ABL_END  && (ch == 'e' || ch == 'f')) {
+            levelNext--;
+         }
+      }
+      if (!IsASpace(ch))
+         visibleChars++;
+      if (atEOL || (i == endPos-1)) {
+         int lev = levelCurrent | levelNext << 16;
+         if (visibleChars == 0 && options.foldCompact)
+            lev |= SC_FOLDLEVELWHITEFLAG;
+         if (levelCurrent < levelNext)
+            lev |= SC_FOLDLEVELHEADERFLAG;
+         if (lev != styler.LevelAt(lineCurrent)) {
+            styler.SetLevel(lineCurrent, lev);
+         }
+         lineCurrent++;
+         lineStartNext = styler.LineStart(lineCurrent+1);
+         levelCurrent = levelNext;
+         if (atEOL && (i == static_cast<Sci_PositionU>(styler.Length()-1))) {
+            // There is an empty line at end of file so give it same level and empty
+            styler.SetLevel(lineCurrent, (levelCurrent | levelCurrent << 16) | SC_FOLDLEVELWHITEFLAG);
+         }
+         visibleChars = 0;
+      }
+   }
+}
+
+LexerModule lmProgress(SCLEX_PROGRESS, LexerABL::LexerFactoryABL, "abl", ablWordLists);
diff --git a/Pythonwin/Scintilla/lexers/LexProps.cxx b/Pythonwin/Scintilla/lexers/LexProps.cxx
new file mode 100644
index 000000000..328033dd5
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexProps.cxx
@@ -0,0 +1,187 @@
+// Scintilla source code edit control
+/** @file LexProps.cxx
+ ** Lexer for properties files.
+ **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static inline bool AtEOL(Accessor &styler, Sci_PositionU i) {
+	return (styler[i] == '\n') ||
+	       ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n'));
+}
+
+static inline bool isassignchar(unsigned char ch) {
+	return (ch == '=') || (ch == ':');
+}
+
+static void ColourisePropsLine(
+	const char *lineBuffer,
+    Sci_PositionU lengthLine,
+    Sci_PositionU startLine,
+    Sci_PositionU endPos,
+    Accessor &styler,
+    bool allowInitialSpaces) {
+
+	Sci_PositionU i = 0;
+	if (allowInitialSpaces) {
+		while ((i < lengthLine) && isspacechar(lineBuffer[i]))	// Skip initial spaces
+			i++;
+	} else {
+		if (isspacechar(lineBuffer[i])) // don't allow initial spaces
+			i = lengthLine;
+	}
+
+	if (i < lengthLine) {
+		if (lineBuffer[i] == '#' || lineBuffer[i] == '!' || lineBuffer[i] == ';') {
+			styler.ColourTo(endPos, SCE_PROPS_COMMENT);
+		} else if (lineBuffer[i] == '[') {
+			styler.ColourTo(endPos, SCE_PROPS_SECTION);
+		} else if (lineBuffer[i] == '@') {
+			styler.ColourTo(startLine + i, SCE_PROPS_DEFVAL);
+			if (isassignchar(lineBuffer[i++]))
+				styler.ColourTo(startLine + i, SCE_PROPS_ASSIGNMENT);
+			styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
+		} else {
+			// Search for the '=' character
+			while ((i < lengthLine) && !isassignchar(lineBuffer[i]))
+				i++;
+			if ((i < lengthLine) && isassignchar(lineBuffer[i])) {
+				styler.ColourTo(startLine + i - 1, SCE_PROPS_KEY);
+				styler.ColourTo(startLine + i, SCE_PROPS_ASSIGNMENT);
+				styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
+			} else {
+				styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
+			}
+		}
+	} else {
+		styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
+	}
+}
+
+static void ColourisePropsDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
+	std::string lineBuffer;
+	styler.StartAt(startPos);
+	styler.StartSegment(startPos);
+	Sci_PositionU startLine = startPos;
+
+	// property lexer.props.allow.initial.spaces
+	//	For properties files, set to 0 to style all lines that start with whitespace in the default style.
+	//	This is not suitable for SciTE .properties files which use indentation for flow control but
+	//	can be used for RFC2822 text where indentation is used for continuation lines.
+	const bool allowInitialSpaces = styler.GetPropertyInt("lexer.props.allow.initial.spaces", 1) != 0;
+
+	for (Sci_PositionU i = startPos; i < startPos + length; i++) {
+		lineBuffer.push_back(styler[i]);
+		if (AtEOL(styler, i)) {
+			// End of line (or of line buffer) met, colourise it
+			ColourisePropsLine(lineBuffer.c_str(), lineBuffer.length(), startLine, i, styler, allowInitialSpaces);
+			lineBuffer.clear();
+			startLine = i + 1;
+		}
+	}
+	if (lineBuffer.length() > 0) {	// Last line does not have ending characters
+		ColourisePropsLine(lineBuffer.c_str(), lineBuffer.length(), startLine, startPos + length - 1, styler, allowInitialSpaces);
+	}
+}
+
+// adaption by ksc, using the "} else {" trick of 1.53
+// 030721
+static void FoldPropsDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler) {
+	const bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+
+	const Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	bool headerPoint = false;
+	int lev;
+
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		const char ch = chNext;
+		chNext = styler[i+1];
+
+		const int style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		const bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+
+		if (style == SCE_PROPS_SECTION) {
+			headerPoint = true;
+		}
+
+		if (atEOL) {
+			lev = SC_FOLDLEVELBASE;
+
+			if (lineCurrent > 0) {
+				const int levelPrevious = styler.LevelAt(lineCurrent - 1);
+
+				if (levelPrevious & SC_FOLDLEVELHEADERFLAG) {
+					lev = SC_FOLDLEVELBASE + 1;
+				} else {
+					lev = levelPrevious & SC_FOLDLEVELNUMBERMASK;
+				}
+			}
+
+			if (headerPoint) {
+				lev = SC_FOLDLEVELBASE;
+			}
+			if (visibleChars == 0 && foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+
+			if (headerPoint) {
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			}
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+
+			lineCurrent++;
+			visibleChars = 0;
+			headerPoint = false;
+		}
+		if (!isspacechar(ch))
+			visibleChars++;
+	}
+
+	if (lineCurrent > 0) {
+		const int levelPrevious = styler.LevelAt(lineCurrent - 1);
+		if (levelPrevious & SC_FOLDLEVELHEADERFLAG) {
+			lev = SC_FOLDLEVELBASE + 1;
+		} else {
+			lev = levelPrevious & SC_FOLDLEVELNUMBERMASK;
+		}
+	} else {
+		lev = SC_FOLDLEVELBASE;
+	}
+	int flagsNext = styler.LevelAt(lineCurrent);
+	styler.SetLevel(lineCurrent, lev | (flagsNext & ~SC_FOLDLEVELNUMBERMASK));
+}
+
+static const char *const emptyWordListDesc[] = {
+	0
+};
+
+LexerModule lmProps(SCLEX_PROPERTIES, ColourisePropsDoc, "props", FoldPropsDoc, emptyWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexPython.cxx b/Pythonwin/Scintilla/lexers/LexPython.cxx
new file mode 100644
index 000000000..d5ec1d558
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexPython.cxx
@@ -0,0 +1,984 @@
+// Scintilla source code edit control
+/** @file LexPython.cxx
+ ** Lexer for Python.
+ **/
+// Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+
+#include <string>
+#include <vector>
+#include <map>
+#include <algorithm>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "StringCopy.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "CharacterCategory.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "SubStyles.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+namespace {
+// Use an unnamed namespace to protect the functions and classes from name conflicts
+
+/* Notes on f-strings: f-strings are strings prefixed with f (e.g. f'') that may
+   have arbitrary expressions in {}.  The tokens in the expressions are lexed as if
+   they were outside of any string.  Expressions may contain { and } characters as
+   long as there is a closing } for every {, may be 2+ lines in a triple quoted
+   string, and may have a formatting specifier following a ! or :, but both !
+   and : are valid inside of a bracketed expression and != is a valid
+   expression token even outside of a bracketed expression.
+
+   When in an f-string expression, the lexer keeps track of the state value of
+   the f-string and the nesting count for the expression (# of [, (, { seen - # of
+   }, ), ] seen).  f-strings may be nested (e.g. f'{ a + f"{1+2}"') so a stack of
+   states and nesting counts is kept.  If a f-string expression continues beyond
+   the end of a line, this stack is saved in a std::map that maps a line number to
+   the stack at the end of that line.  std::vector is used for the stack.
+
+   The PEP for f-strings is at https://www.python.org/dev/peps/pep-0498/
+*/
+struct SingleFStringExpState {
+	int state;
+	int nestingCount;
+};
+
+/* kwCDef, kwCTypeName only used for Cython */
+enum kwType { kwOther, kwClass, kwDef, kwImport, kwCDef, kwCTypeName, kwCPDef };
+
+enum literalsAllowed { litNone = 0, litU = 1, litB = 2, litF = 4 };
+
+constexpr int indicatorWhitespace = 1;
+
+bool IsPyComment(Accessor &styler, Sci_Position pos, Sci_Position len) {
+	return len > 0 && styler[pos] == '#';
+}
+
+bool IsPyStringTypeChar(int ch, literalsAllowed allowed) noexcept {
+	return
+		((allowed & litB) && (ch == 'b' || ch == 'B')) ||
+		((allowed & litU) && (ch == 'u' || ch == 'U')) ||
+		((allowed & litF) && (ch == 'f' || ch == 'F'));
+}
+
+bool IsPyStringStart(int ch, int chNext, int chNext2, literalsAllowed allowed) noexcept {
+	if (ch == '\'' || ch == '"')
+		return true;
+	if (IsPyStringTypeChar(ch, allowed)) {
+		if (chNext == '"' || chNext == '\'')
+			return true;
+		if ((chNext == 'r' || chNext == 'R') && (chNext2 == '"' || chNext2 == '\''))
+			return true;
+	}
+	if ((ch == 'r' || ch == 'R') && (chNext == '"' || chNext == '\''))
+		return true;
+
+	return false;
+}
+
+bool IsPyFStringState(int st) noexcept {
+	return ((st == SCE_P_FCHARACTER) || (st == SCE_P_FSTRING) ||
+		(st == SCE_P_FTRIPLE) || (st == SCE_P_FTRIPLEDOUBLE));
+}
+
+bool IsPySingleQuoteStringState(int st) noexcept {
+	return ((st == SCE_P_CHARACTER) || (st == SCE_P_STRING) ||
+		(st == SCE_P_FCHARACTER) || (st == SCE_P_FSTRING));
+}
+
+bool IsPyTripleQuoteStringState(int st) noexcept {
+	return ((st == SCE_P_TRIPLE) || (st == SCE_P_TRIPLEDOUBLE) ||
+		(st == SCE_P_FTRIPLE) || (st == SCE_P_FTRIPLEDOUBLE));
+}
+
+char GetPyStringQuoteChar(int st) noexcept {
+	if ((st == SCE_P_CHARACTER) || (st == SCE_P_FCHARACTER) ||
+			(st == SCE_P_TRIPLE) || (st == SCE_P_FTRIPLE))
+		return '\'';
+	if ((st == SCE_P_STRING) || (st == SCE_P_FSTRING) ||
+			(st == SCE_P_TRIPLEDOUBLE) || (st == SCE_P_FTRIPLEDOUBLE))
+		return '"';
+
+	return '\0';
+}
+
+void PushStateToStack(int state, std::vector<SingleFStringExpState> &stack, SingleFStringExpState *&currentFStringExp) {
+	SingleFStringExpState single = {state, 0};
+	stack.push_back(single);
+
+	currentFStringExp = &stack.back();
+}
+
+int PopFromStateStack(std::vector<SingleFStringExpState> &stack, SingleFStringExpState *&currentFStringExp) noexcept {
+	int state = 0;
+
+	if (!stack.empty()) {
+		state = stack.back().state;
+		stack.pop_back();
+	}
+
+	if (stack.empty()) {
+		currentFStringExp = nullptr;
+	} else {
+		currentFStringExp = &stack.back();
+	}
+
+	return state;
+}
+
+/* Return the state to use for the string starting at i; *nextIndex will be set to the first index following the quote(s) */
+int GetPyStringState(Accessor &styler, Sci_Position i, Sci_PositionU *nextIndex, literalsAllowed allowed) {
+	char ch = styler.SafeGetCharAt(i);
+	char chNext = styler.SafeGetCharAt(i + 1);
+	const int firstIsF = (ch == 'f' || ch == 'F');
+
+	// Advance beyond r, u, or ur prefix (or r, b, or br in Python 2.7+ and r, f, or fr in Python 3.6+), but bail if there are any unexpected chars
+	if (ch == 'r' || ch == 'R') {
+		i++;
+		ch = styler.SafeGetCharAt(i);
+		chNext = styler.SafeGetCharAt(i + 1);
+	} else if (IsPyStringTypeChar(ch, allowed)) {
+		if (chNext == 'r' || chNext == 'R')
+			i += 2;
+		else
+			i += 1;
+		ch = styler.SafeGetCharAt(i);
+		chNext = styler.SafeGetCharAt(i + 1);
+	}
+
+	if (ch != '"' && ch != '\'') {
+		*nextIndex = i + 1;
+		return SCE_P_DEFAULT;
+	}
+
+	if (ch == chNext && ch == styler.SafeGetCharAt(i + 2)) {
+		*nextIndex = i + 3;
+
+		if (ch == '"')
+			return (firstIsF ? SCE_P_FTRIPLEDOUBLE : SCE_P_TRIPLEDOUBLE);
+		else
+			return (firstIsF ? SCE_P_FTRIPLE : SCE_P_TRIPLE);
+	} else {
+		*nextIndex = i + 1;
+
+		if (ch == '"')
+			return (firstIsF ? SCE_P_FSTRING : SCE_P_STRING);
+		else
+			return (firstIsF ? SCE_P_FCHARACTER : SCE_P_CHARACTER);
+	}
+}
+
+inline bool IsAWordChar(int ch, bool unicodeIdentifiers) {
+	if (IsASCII(ch))
+		return (IsAlphaNumeric(ch) || ch == '.' || ch == '_');
+
+	if (!unicodeIdentifiers)
+		return false;
+
+	// Python uses the XID_Continue set from Unicode data
+	return IsXidContinue(ch);
+}
+
+inline bool IsAWordStart(int ch, bool unicodeIdentifiers) {
+	if (IsASCII(ch))
+		return (IsUpperOrLowerCase(ch) || ch == '_');
+
+	if (!unicodeIdentifiers)
+		return false;
+
+	// Python uses the XID_Start set from Unicode data
+	return IsXidStart(ch);
+}
+
+bool IsFirstNonWhitespace(Sci_Position pos, Accessor &styler) {
+	const Sci_Position line = styler.GetLine(pos);
+	const Sci_Position start_pos = styler.LineStart(line);
+	for (Sci_Position i = start_pos; i < pos; i++) {
+		const char ch = styler[i];
+		if (!(ch == ' ' || ch == '\t'))
+			return false;
+	}
+	return true;
+}
+
+// Options used for LexerPython
+struct OptionsPython {
+	int whingeLevel;
+	bool base2or8Literals;
+	bool stringsU;
+	bool stringsB;
+	bool stringsF;
+	bool stringsOverNewline;
+	bool keywords2NoSubIdentifiers;
+	bool fold;
+	bool foldQuotes;
+	bool foldCompact;
+	bool unicodeIdentifiers;
+
+	OptionsPython() {
+		whingeLevel = 0;
+		base2or8Literals = true;
+		stringsU = true;
+		stringsB = true;
+		stringsF = true;
+		stringsOverNewline = false;
+		keywords2NoSubIdentifiers = false;
+		fold = false;
+		foldQuotes = false;
+		foldCompact = false;
+		unicodeIdentifiers = true;
+	}
+
+	literalsAllowed AllowedLiterals() const noexcept {
+		literalsAllowed allowedLiterals = stringsU ? litU : litNone;
+		if (stringsB)
+			allowedLiterals = static_cast<literalsAllowed>(allowedLiterals | litB);
+		if (stringsF)
+			allowedLiterals = static_cast<literalsAllowed>(allowedLiterals | litF);
+		return allowedLiterals;
+	}
+};
+
+const char *const pythonWordListDesc[] = {
+	"Keywords",
+	"Highlighted identifiers",
+	nullptr
+};
+
+struct OptionSetPython : public OptionSet<OptionsPython> {
+	OptionSetPython() {
+		DefineProperty("tab.timmy.whinge.level", &OptionsPython::whingeLevel,
+			       "For Python code, checks whether indenting is consistent. "
+			       "The default, 0 turns off indentation checking, "
+			       "1 checks whether each line is potentially inconsistent with the previous line, "
+			       "2 checks whether any space characters occur before a tab character in the indentation, "
+			       "3 checks whether any spaces are in the indentation, and "
+			       "4 checks for any tab characters in the indentation. "
+			       "1 is a good level to use.");
+
+		DefineProperty("lexer.python.literals.binary", &OptionsPython::base2or8Literals,
+			       "Set to 0 to not recognise Python 3 binary and octal literals: 0b1011 0o712.");
+
+		DefineProperty("lexer.python.strings.u", &OptionsPython::stringsU,
+			       "Set to 0 to not recognise Python Unicode literals u\"x\" as used before Python 3.");
+
+		DefineProperty("lexer.python.strings.b", &OptionsPython::stringsB,
+			       "Set to 0 to not recognise Python 3 bytes literals b\"x\".");
+
+		DefineProperty("lexer.python.strings.f", &OptionsPython::stringsF,
+			       "Set to 0 to not recognise Python 3.6 f-string literals f\"var={var}\".");
+
+		DefineProperty("lexer.python.strings.over.newline", &OptionsPython::stringsOverNewline,
+			       "Set to 1 to allow strings to span newline characters.");
+
+		DefineProperty("lexer.python.keywords2.no.sub.identifiers", &OptionsPython::keywords2NoSubIdentifiers,
+			       "When enabled, it will not style keywords2 items that are used as a sub-identifier. "
+			       "Example: when set, will not highlight \"foo.open\" when \"open\" is a keywords2 item.");
+
+		DefineProperty("fold", &OptionsPython::fold);
+
+		DefineProperty("fold.quotes.python", &OptionsPython::foldQuotes,
+			       "This option enables folding multi-line quoted strings when using the Python lexer.");
+
+		DefineProperty("fold.compact", &OptionsPython::foldCompact);
+
+		DefineProperty("lexer.python.unicode.identifiers", &OptionsPython::unicodeIdentifiers,
+			       "Set to 0 to not recognise Python 3 Unicode identifiers.");
+
+		DefineWordListSets(pythonWordListDesc);
+	}
+};
+
+const char styleSubable[] = { SCE_P_IDENTIFIER, 0 };
+
+LexicalClass lexicalClasses[] = {
+	// Lexer Python SCLEX_PYTHON SCE_P_:
+	0, "SCE_P_DEFAULT", "default", "White space",
+	1, "SCE_P_COMMENTLINE", "comment line", "Comment",
+	2, "SCE_P_NUMBER", "literal numeric", "Number",
+	3, "SCE_P_STRING", "literal string", "String",
+	4, "SCE_P_CHARACTER", "literal string", "Single quoted string",
+	5, "SCE_P_WORD", "keyword", "Keyword",
+	6, "SCE_P_TRIPLE", "literal string", "Triple quotes",
+	7, "SCE_P_TRIPLEDOUBLE", "literal string", "Triple double quotes",
+	8, "SCE_P_CLASSNAME", "identifier", "Class name definition",
+	9, "SCE_P_DEFNAME", "identifier", "Function or method name definition",
+	10, "SCE_P_OPERATOR", "operator", "Operators",
+	11, "SCE_P_IDENTIFIER", "identifier", "Identifiers",
+	12, "SCE_P_COMMENTBLOCK", "comment", "Comment-blocks",
+	13, "SCE_P_STRINGEOL", "error literal string", "End of line where string is not closed",
+	14, "SCE_P_WORD2", "identifier", "Highlighted identifiers",
+	15, "SCE_P_DECORATOR", "preprocessor", "Decorators",
+	16, "SCE_P_FSTRING", "literal string interpolated", "F-String",
+	17, "SCE_P_FCHARACTER", "literal string interpolated", "Single quoted f-string",
+	18, "SCE_P_FTRIPLE", "literal string interpolated", "Triple quoted f-string",
+	19, "SCE_P_FTRIPLEDOUBLE", "literal string interpolated", "Triple double quoted f-string",
+};
+
+}
+
+class LexerPython : public DefaultLexer {
+	WordList keywords;
+	WordList keywords2;
+	OptionsPython options;
+	OptionSetPython osPython;
+	enum { ssIdentifier };
+	SubStyles subStyles;
+	std::map<Sci_Position, std::vector<SingleFStringExpState> > ftripleStateAtEol;
+public:
+	explicit LexerPython() :
+		DefaultLexer("python", SCLEX_PYTHON, lexicalClasses, ELEMENTS(lexicalClasses)),
+		subStyles(styleSubable, 0x80, 0x40, 0) {
+	}
+	~LexerPython() override {
+	}
+	void SCI_METHOD Release() override {
+		delete this;
+	}
+	int SCI_METHOD Version() const override {
+		return lvRelease5;
+	}
+	const char *SCI_METHOD PropertyNames() override {
+		return osPython.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return osPython.PropertyType(name);
+	}
+	const char *SCI_METHOD DescribeProperty(const char *name) override {
+		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();
+	}
+	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 *) override {
+		return nullptr;
+	}
+
+	int SCI_METHOD LineEndTypesSupported() override {
+		return SC_LINE_END_TYPE_UNICODE;
+	}
+
+	int SCI_METHOD AllocateSubStyles(int styleBase, int numberStyles) override {
+		return subStyles.Allocate(styleBase, numberStyles);
+	}
+	int SCI_METHOD SubStylesStart(int styleBase) override {
+		return subStyles.Start(styleBase);
+	}
+	int SCI_METHOD SubStylesLength(int styleBase) override {
+		return subStyles.Length(styleBase);
+	}
+	int SCI_METHOD StyleFromSubStyle(int subStyle) override {
+		const int styleBase = subStyles.BaseStyle(subStyle);
+		return styleBase;
+	}
+	int SCI_METHOD PrimaryStyleFromStyle(int style) override {
+		return style;
+	}
+	void SCI_METHOD FreeSubStyles() override {
+		subStyles.Free();
+	}
+	void SCI_METHOD SetIdentifiers(int style, const char *identifiers) override {
+		subStyles.SetIdentifiers(style, identifiers);
+	}
+	int SCI_METHOD DistanceToSecondaryStyles() override {
+		return 0;
+	}
+	const char *SCI_METHOD GetSubStyleBases() override {
+		return styleSubable;
+	}
+
+	static ILexer5 *LexerFactoryPython() {
+		return new LexerPython();
+	}
+
+private:
+	void ProcessLineEnd(StyleContext &sc, std::vector<SingleFStringExpState> &fstringStateStack, SingleFStringExpState *&currentFStringExp, bool &inContinuedString);
+};
+
+Sci_Position SCI_METHOD LexerPython::PropertySet(const char *key, const char *val) {
+	if (osPython.PropertySet(&options, key, val)) {
+		return 0;
+	}
+	return -1;
+}
+
+Sci_Position SCI_METHOD LexerPython::WordListSet(int n, const char *wl) {
+	WordList *wordListN = nullptr;
+	switch (n) {
+	case 0:
+		wordListN = &keywords;
+		break;
+	case 1:
+		wordListN = &keywords2;
+		break;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN) {
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+		}
+	}
+	return firstModification;
+}
+
+void LexerPython::ProcessLineEnd(StyleContext &sc, std::vector<SingleFStringExpState> &fstringStateStack, SingleFStringExpState *&currentFStringExp, bool &inContinuedString) {
+	long deepestSingleStateIndex = -1;
+	unsigned long i;
+
+	// Find the deepest single quote state because that string will end; no \ continuation in f-string
+	for (i = 0; i < fstringStateStack.size(); i++) {
+		if (IsPySingleQuoteStringState(fstringStateStack[i].state)) {
+			deepestSingleStateIndex = i;
+			break;
+		}
+	}
+
+	if (deepestSingleStateIndex != -1) {
+		sc.SetState(fstringStateStack[deepestSingleStateIndex].state);
+		while (fstringStateStack.size() > static_cast<unsigned long>(deepestSingleStateIndex)) {
+			PopFromStateStack(fstringStateStack, currentFStringExp);
+		}
+	}
+	if (!fstringStateStack.empty()) {
+		std::pair<Sci_Position, std::vector<SingleFStringExpState> > val;
+		val.first = sc.currentLine;
+		val.second = fstringStateStack;
+
+		ftripleStateAtEol.insert(val);
+	}
+
+	if ((sc.state == SCE_P_DEFAULT)
+			|| IsPyTripleQuoteStringState(sc.state)) {
+		// Perform colourisation of white space and triple quoted strings at end of each line to allow
+		// tab marking to work inside white space and triple quoted strings
+		sc.SetState(sc.state);
+	}
+	if (IsPySingleQuoteStringState(sc.state)) {
+		if (inContinuedString || options.stringsOverNewline) {
+			inContinuedString = false;
+		} else {
+			sc.ChangeState(SCE_P_STRINGEOL);
+			sc.ForwardSetState(SCE_P_DEFAULT);
+		}
+	}
+}
+
+void SCI_METHOD LexerPython::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	Accessor styler(pAccess, nullptr);
+
+	// Track whether in f-string expression; vector is used for a stack to
+	// handle nested f-strings such as f"""{f'''{f"{f'{1}'}"}'''}"""
+	std::vector<SingleFStringExpState> fstringStateStack;
+	SingleFStringExpState *currentFStringExp = nullptr;
+
+	const Sci_Position endPos = startPos + length;
+
+	// Backtrack to previous line in case need to fix its tab whinging
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	if (startPos > 0) {
+		if (lineCurrent > 0) {
+			lineCurrent--;
+			// Look for backslash-continued lines
+			while (lineCurrent > 0) {
+				const Sci_Position eolPos = styler.LineStart(lineCurrent) - 1;
+				const int eolStyle = styler.StyleAt(eolPos);
+				if (eolStyle == SCE_P_STRING
+						|| eolStyle == SCE_P_CHARACTER
+						|| eolStyle == SCE_P_STRINGEOL) {
+					lineCurrent -= 1;
+				} else {
+					break;
+				}
+			}
+			startPos = styler.LineStart(lineCurrent);
+		}
+		initStyle = startPos == 0 ? SCE_P_DEFAULT : styler.StyleAt(startPos - 1);
+	}
+
+	const literalsAllowed allowedLiterals = options.AllowedLiterals();
+
+	initStyle = initStyle & 31;
+	if (initStyle == SCE_P_STRINGEOL) {
+		initStyle = SCE_P_DEFAULT;
+	}
+
+	// Set up fstate stack from last line and remove any subsequent ftriple at eol states
+	std::map<Sci_Position, std::vector<SingleFStringExpState> >::iterator it;
+	it = ftripleStateAtEol.find(lineCurrent - 1);
+	if (it != ftripleStateAtEol.end() && !it->second.empty()) {
+		fstringStateStack = it->second;
+		currentFStringExp = &fstringStateStack.back();
+	}
+	it = ftripleStateAtEol.lower_bound(lineCurrent);
+	if (it != ftripleStateAtEol.end()) {
+		ftripleStateAtEol.erase(it, ftripleStateAtEol.end());
+	}
+
+	kwType kwLast = kwOther;
+	int spaceFlags = 0;
+	styler.IndentAmount(lineCurrent, &spaceFlags, IsPyComment);
+	bool base_n_number = false;
+
+	const WordClassifier &classifierIdentifiers = subStyles.Classifier(SCE_P_IDENTIFIER);
+
+	StyleContext sc(startPos, endPos - startPos, initStyle, styler);
+
+	bool indentGood = true;
+	Sci_Position startIndicator = sc.currentPos;
+	bool inContinuedString = false;
+
+	for (; sc.More(); sc.Forward()) {
+
+		if (sc.atLineStart) {
+			styler.IndentAmount(lineCurrent, &spaceFlags, IsPyComment);
+			indentGood = true;
+			if (options.whingeLevel == 1) {
+				indentGood = (spaceFlags & wsInconsistent) == 0;
+			} else if (options.whingeLevel == 2) {
+				indentGood = (spaceFlags & wsSpaceTab) == 0;
+			} else if (options.whingeLevel == 3) {
+				indentGood = (spaceFlags & wsSpace) == 0;
+			} else if (options.whingeLevel == 4) {
+				indentGood = (spaceFlags & wsTab) == 0;
+			}
+			if (!indentGood) {
+				styler.IndicatorFill(startIndicator, sc.currentPos, indicatorWhitespace, 0);
+				startIndicator = sc.currentPos;
+			}
+		}
+
+		if (sc.atLineEnd) {
+			ProcessLineEnd(sc, fstringStateStack, currentFStringExp, inContinuedString);
+			lineCurrent++;
+			if (!sc.More())
+				break;
+		}
+
+		bool needEOLCheck = false;
+
+
+		if (sc.state == SCE_P_OPERATOR) {
+			kwLast = kwOther;
+			sc.SetState(SCE_P_DEFAULT);
+		} else if (sc.state == SCE_P_NUMBER) {
+			if (!IsAWordChar(sc.ch, false) &&
+					!(!base_n_number && ((sc.ch == '+' || sc.ch == '-') && (sc.chPrev == 'e' || sc.chPrev == 'E')))) {
+				sc.SetState(SCE_P_DEFAULT);
+			}
+		} else if (sc.state == SCE_P_IDENTIFIER) {
+			if ((sc.ch == '.') || (!IsAWordChar(sc.ch, options.unicodeIdentifiers))) {
+				char s[100];
+				sc.GetCurrent(s, sizeof(s));
+				int style = SCE_P_IDENTIFIER;
+				if ((kwLast == kwImport) && (strcmp(s, "as") == 0)) {
+					style = SCE_P_WORD;
+				} else if (keywords.InList(s)) {
+					style = SCE_P_WORD;
+				} else if (kwLast == kwClass) {
+					style = SCE_P_CLASSNAME;
+				} else if (kwLast == kwDef) {
+					style = SCE_P_DEFNAME;
+				} else if (kwLast == kwCDef || kwLast == kwCPDef) {
+					Sci_Position pos = sc.currentPos;
+					unsigned char ch = styler.SafeGetCharAt(pos, '\0');
+					while (ch != '\0') {
+						if (ch == '(') {
+							style = SCE_P_DEFNAME;
+							break;
+						} else if (ch == ':') {
+							style = SCE_P_CLASSNAME;
+							break;
+						} else if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') {
+							pos++;
+							ch = styler.SafeGetCharAt(pos, '\0');
+						} else {
+							break;
+						}
+					}
+				} else if (keywords2.InList(s)) {
+					if (options.keywords2NoSubIdentifiers) {
+						// We don't want to highlight keywords2
+						// that are used as a sub-identifier,
+						// i.e. not open in "foo.open".
+						const Sci_Position pos = styler.GetStartSegment() - 1;
+						if (pos < 0 || (styler.SafeGetCharAt(pos, '\0') != '.'))
+							style = SCE_P_WORD2;
+					} else {
+						style = SCE_P_WORD2;
+					}
+				} else {
+					int subStyle = classifierIdentifiers.ValueFor(s);
+					if (subStyle >= 0) {
+						style = subStyle;
+					}
+				}
+				sc.ChangeState(style);
+				sc.SetState(SCE_P_DEFAULT);
+				if (style == SCE_P_WORD) {
+					if (0 == strcmp(s, "class"))
+						kwLast = kwClass;
+					else if (0 == strcmp(s, "def"))
+						kwLast = kwDef;
+					else if (0 == strcmp(s, "import"))
+						kwLast = kwImport;
+					else if (0 == strcmp(s, "cdef"))
+						kwLast = kwCDef;
+					else if (0 == strcmp(s, "cpdef"))
+						kwLast = kwCPDef;
+					else if (0 == strcmp(s, "cimport"))
+						kwLast = kwImport;
+					else if (kwLast != kwCDef && kwLast != kwCPDef)
+						kwLast = kwOther;
+				} else if (kwLast != kwCDef && kwLast != kwCPDef) {
+					kwLast = kwOther;
+				}
+			}
+		} else if ((sc.state == SCE_P_COMMENTLINE) || (sc.state == SCE_P_COMMENTBLOCK)) {
+			if (sc.ch == '\r' || sc.ch == '\n') {
+				sc.SetState(SCE_P_DEFAULT);
+			}
+		} else if (sc.state == SCE_P_DECORATOR) {
+			if (!IsAWordStart(sc.ch, options.unicodeIdentifiers)) {
+				sc.SetState(SCE_P_DEFAULT);
+			}
+		} else if (IsPySingleQuoteStringState(sc.state)) {
+			if (sc.ch == '\\') {
+				if ((sc.chNext == '\r') && (sc.GetRelative(2) == '\n')) {
+					sc.Forward();
+				}
+				if (sc.chNext == '\n' || sc.chNext == '\r') {
+					inContinuedString = true;
+				} else {
+					// Don't roll over the newline.
+					sc.Forward();
+				}
+			} else if (sc.ch == GetPyStringQuoteChar(sc.state)) {
+				sc.ForwardSetState(SCE_P_DEFAULT);
+				needEOLCheck = true;
+			}
+		} else if ((sc.state == SCE_P_TRIPLE) || (sc.state == SCE_P_FTRIPLE)) {
+			if (sc.ch == '\\') {
+				sc.Forward();
+			} else if (sc.Match(R"(''')")) {
+				sc.Forward();
+				sc.Forward();
+				sc.ForwardSetState(SCE_P_DEFAULT);
+				needEOLCheck = true;
+			}
+		} else if ((sc.state == SCE_P_TRIPLEDOUBLE) || (sc.state == SCE_P_FTRIPLEDOUBLE)) {
+			if (sc.ch == '\\') {
+				sc.Forward();
+			} else if (sc.Match(R"(""")")) {
+				sc.Forward();
+				sc.Forward();
+				sc.ForwardSetState(SCE_P_DEFAULT);
+				needEOLCheck = true;
+			}
+		}
+
+		// Note if used and not if else because string states also match
+		// some of the above clauses
+		if (IsPyFStringState(sc.state) && sc.ch == '{') {
+			if (sc.chNext == '{') {
+				sc.Forward();
+			} else {
+				PushStateToStack(sc.state, fstringStateStack, currentFStringExp);
+				sc.ForwardSetState(SCE_P_DEFAULT);
+			}
+			needEOLCheck = true;
+		}
+
+		// If in an f-string expression, check for the ending quote(s)
+		// and end f-string to handle syntactically incorrect cases like
+		// f'{' and f"""{"""
+		if (!fstringStateStack.empty() && (sc.ch == '\'' || sc.ch == '"')) {
+			long matching_stack_i = -1;
+			for (unsigned long stack_i = 0; stack_i < fstringStateStack.size() && matching_stack_i == -1; stack_i++) {
+				const int stack_state = fstringStateStack[stack_i].state;
+				const char quote = GetPyStringQuoteChar(stack_state);
+				if (sc.ch == quote) {
+					if (IsPySingleQuoteStringState(stack_state)) {
+						matching_stack_i = stack_i;
+					} else if (quote == '"' ? sc.Match(R"(""")") : sc.Match("'''")) {
+						matching_stack_i = stack_i;
+					}
+				}
+			}
+
+			if (matching_stack_i != -1) {
+				sc.SetState(fstringStateStack[matching_stack_i].state);
+				if (IsPyTripleQuoteStringState(fstringStateStack[matching_stack_i].state)) {
+					sc.Forward();
+					sc.Forward();
+				}
+				sc.ForwardSetState(SCE_P_DEFAULT);
+				needEOLCheck = true;
+
+				while (fstringStateStack.size() > static_cast<unsigned long>(matching_stack_i)) {
+					PopFromStateStack(fstringStateStack, currentFStringExp);
+				}
+			}
+		}
+		// End of code to find the end of a state
+
+		if (!indentGood && !IsASpaceOrTab(sc.ch)) {
+			styler.IndicatorFill(startIndicator, sc.currentPos, indicatorWhitespace, 1);
+			startIndicator = sc.currentPos;
+			indentGood = true;
+		}
+
+		// One cdef or cpdef line, clear kwLast only at end of line
+		if ((kwLast == kwCDef || kwLast == kwCPDef) && sc.atLineEnd) {
+			kwLast = kwOther;
+		}
+
+		// State exit code may have moved on to end of line
+		if (needEOLCheck && sc.atLineEnd) {
+			ProcessLineEnd(sc, fstringStateStack, currentFStringExp, inContinuedString);
+			lineCurrent++;
+			styler.IndentAmount(lineCurrent, &spaceFlags, IsPyComment);
+			if (!sc.More())
+				break;
+		}
+
+		// If in f-string expression, check for }, :, ! to resume f-string state or update nesting count
+		if (currentFStringExp && !IsPySingleQuoteStringState(sc.state) && !IsPyTripleQuoteStringState(sc.state)) {
+			if (currentFStringExp->nestingCount == 0 && (sc.ch == '}' || sc.ch == ':' || (sc.ch == '!' && sc.chNext != '='))) {
+				sc.SetState(PopFromStateStack(fstringStateStack, currentFStringExp));
+			} else {
+				if (sc.ch == '{' || sc.ch == '[' || sc.ch == '(') {
+					currentFStringExp->nestingCount++;
+				} else if (sc.ch == '}' || sc.ch == ']' || sc.ch == ')') {
+					currentFStringExp->nestingCount--;
+				}
+			}
+		}
+
+		// Check for a new state starting character
+		if (sc.state == SCE_P_DEFAULT) {
+			if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
+				if (sc.ch == '0' && (sc.chNext == 'x' || sc.chNext == 'X')) {
+					base_n_number = true;
+					sc.SetState(SCE_P_NUMBER);
+				} else if (sc.ch == '0' &&
+						(sc.chNext == 'o' || sc.chNext == 'O' || sc.chNext == 'b' || sc.chNext == 'B')) {
+					if (options.base2or8Literals) {
+						base_n_number = true;
+						sc.SetState(SCE_P_NUMBER);
+					} else {
+						sc.SetState(SCE_P_NUMBER);
+						sc.ForwardSetState(SCE_P_IDENTIFIER);
+					}
+				} else {
+					base_n_number = false;
+					sc.SetState(SCE_P_NUMBER);
+				}
+			} else if (isoperator(sc.ch) || sc.ch == '`') {
+				sc.SetState(SCE_P_OPERATOR);
+			} else if (sc.ch == '#') {
+				sc.SetState(sc.chNext == '#' ? SCE_P_COMMENTBLOCK : SCE_P_COMMENTLINE);
+			} else if (sc.ch == '@') {
+				if (IsFirstNonWhitespace(sc.currentPos, styler))
+					sc.SetState(SCE_P_DECORATOR);
+				else
+					sc.SetState(SCE_P_OPERATOR);
+			} else if (IsPyStringStart(sc.ch, sc.chNext, sc.GetRelative(2), allowedLiterals)) {
+				Sci_PositionU nextIndex = 0;
+				sc.SetState(GetPyStringState(styler, sc.currentPos, &nextIndex, allowedLiterals));
+				while (nextIndex > (sc.currentPos + 1) && sc.More()) {
+					sc.Forward();
+				}
+			} else if (IsAWordStart(sc.ch, options.unicodeIdentifiers)) {
+				sc.SetState(SCE_P_IDENTIFIER);
+			}
+		}
+	}
+	styler.IndicatorFill(startIndicator, sc.currentPos, indicatorWhitespace, 0);
+	sc.Complete();
+}
+
+static bool IsCommentLine(Sci_Position line, Accessor &styler) {
+	const Sci_Position pos = styler.LineStart(line);
+	const Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eol_pos; i++) {
+		const char ch = styler[i];
+		if (ch == '#')
+			return true;
+		else if (ch != ' ' && ch != '\t')
+			return false;
+	}
+	return false;
+}
+
+static bool IsQuoteLine(Sci_Position line, const Accessor &styler) {
+	const int style = styler.StyleAt(styler.LineStart(line)) & 31;
+	return IsPyTripleQuoteStringState(style);
+}
+
+
+void SCI_METHOD LexerPython::Fold(Sci_PositionU startPos, Sci_Position length, int /*initStyle - unused*/, IDocument *pAccess) {
+	if (!options.fold)
+		return;
+
+	Accessor styler(pAccess, nullptr);
+
+	const Sci_Position maxPos = startPos + length;
+	const Sci_Position maxLines = (maxPos == styler.Length()) ? styler.GetLine(maxPos) : styler.GetLine(maxPos - 1);	// Requested last line
+	const Sci_Position docLines = styler.GetLine(styler.Length());	// Available last line
+
+	// Backtrack to previous non-blank line so we can determine indent level
+	// for any white space lines (needed esp. within triple quoted strings)
+	// and so we can fix any preceding fold level (which is why we go back
+	// at least one line in all cases)
+	int spaceFlags = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, nullptr);
+	while (lineCurrent > 0) {
+		lineCurrent--;
+		indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, nullptr);
+		if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG) &&
+				(!IsCommentLine(lineCurrent, styler)) &&
+				(!IsQuoteLine(lineCurrent, styler)))
+			break;
+	}
+	int indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
+
+	// Set up initial loop state
+	startPos = styler.LineStart(lineCurrent);
+	int prev_state = SCE_P_DEFAULT & 31;
+	if (lineCurrent >= 1)
+		prev_state = styler.StyleAt(startPos - 1) & 31;
+	int prevQuote = options.foldQuotes && IsPyTripleQuoteStringState(prev_state);
+
+	// Process all characters to end of requested range or end of any triple quote
+	//that hangs over the end of the range.  Cap processing in all cases
+	// to end of document (in case of unclosed quote at end).
+	while ((lineCurrent <= docLines) && ((lineCurrent <= maxLines) || prevQuote)) {
+
+		// Gather info
+		int lev = indentCurrent;
+		Sci_Position lineNext = lineCurrent + 1;
+		int indentNext = indentCurrent;
+		int quote = false;
+		if (lineNext <= docLines) {
+			// Information about next line is only available if not at end of document
+			indentNext = styler.IndentAmount(lineNext, &spaceFlags, nullptr);
+			const Sci_Position lookAtPos = (styler.LineStart(lineNext) == styler.Length()) ? styler.Length() - 1 : styler.LineStart(lineNext);
+			const int style = styler.StyleAt(lookAtPos) & 31;
+			quote = options.foldQuotes && IsPyTripleQuoteStringState(style);
+		}
+		const int quote_start = (quote && !prevQuote);
+		const int quote_continue = (quote && prevQuote);
+		if (!quote || !prevQuote)
+			indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
+		if (quote)
+			indentNext = indentCurrentLevel;
+		if (indentNext & SC_FOLDLEVELWHITEFLAG)
+			indentNext = SC_FOLDLEVELWHITEFLAG | indentCurrentLevel;
+
+		if (quote_start) {
+			// Place fold point at start of triple quoted string
+			lev |= SC_FOLDLEVELHEADERFLAG;
+		} else if (quote_continue || prevQuote) {
+			// Add level to rest of lines in the string
+			lev = lev + 1;
+		}
+
+		// Skip past any blank lines for next indent level info; we skip also
+		// comments (all comments, not just those starting in column 0)
+		// which effectively folds them into surrounding code rather
+		// than screwing up folding.  If comments end file, use the min
+		// comment indent as the level after
+
+		int minCommentLevel = indentCurrentLevel;
+		while (!quote &&
+				(lineNext < docLines) &&
+				((indentNext & SC_FOLDLEVELWHITEFLAG) ||
+				 (lineNext <= docLines && IsCommentLine(lineNext, styler)))) {
+
+			if (IsCommentLine(lineNext, styler) && indentNext < minCommentLevel) {
+				minCommentLevel = indentNext;
+			}
+
+			lineNext++;
+			indentNext = styler.IndentAmount(lineNext, &spaceFlags, nullptr);
+		}
+
+		const int levelAfterComments = ((lineNext < docLines) ? indentNext & SC_FOLDLEVELNUMBERMASK : minCommentLevel);
+		const int levelBeforeComments = std::max(indentCurrentLevel, levelAfterComments);
+
+		// Now set all the indent levels on the lines we skipped
+		// Do this from end to start.  Once we encounter one line
+		// which is indented more than the line after the end of
+		// the comment-block, use the level of the block before
+
+		Sci_Position skipLine = lineNext;
+		int skipLevel = levelAfterComments;
+
+		while (--skipLine > lineCurrent) {
+			const int skipLineIndent = styler.IndentAmount(skipLine, &spaceFlags, nullptr);
+
+			if (options.foldCompact) {
+				if ((skipLineIndent & SC_FOLDLEVELNUMBERMASK) > levelAfterComments)
+					skipLevel = levelBeforeComments;
+
+				const int whiteFlag = skipLineIndent & SC_FOLDLEVELWHITEFLAG;
+
+				styler.SetLevel(skipLine, skipLevel | whiteFlag);
+			} else {
+				if ((skipLineIndent & SC_FOLDLEVELNUMBERMASK) > levelAfterComments &&
+						!(skipLineIndent & SC_FOLDLEVELWHITEFLAG) &&
+						!IsCommentLine(skipLine, styler))
+					skipLevel = levelBeforeComments;
+
+				styler.SetLevel(skipLine, skipLevel);
+			}
+		}
+
+		// Set fold header on non-quote line
+		if (!quote && !(indentCurrent & SC_FOLDLEVELWHITEFLAG)) {
+			if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK))
+				lev |= SC_FOLDLEVELHEADERFLAG;
+		}
+
+		// Keep track of triple quote state of previous line
+		prevQuote = quote;
+
+		// Set fold level for this line and move to next line
+		styler.SetLevel(lineCurrent, options.foldCompact ? lev : lev & ~SC_FOLDLEVELWHITEFLAG);
+		indentCurrent = indentNext;
+		lineCurrent = lineNext;
+	}
+
+	// NOTE: Cannot set level of last line here because indentCurrent doesn't have
+	// header flag set; the loop above is crafted to take care of this case!
+	//styler.SetLevel(lineCurrent, indentCurrent);
+}
+
+LexerModule lmPython(SCLEX_PYTHON, LexerPython::LexerFactoryPython, "python",
+		     pythonWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexR.cxx b/Pythonwin/Scintilla/lexers/LexR.cxx
similarity index 90%
rename from Pythonwin/Scintilla/src/LexR.cxx
rename to Pythonwin/Scintilla/lexers/LexR.cxx
index 67e779f55..a3821fa3c 100644
--- a/Pythonwin/Scintilla/src/LexR.cxx
+++ b/Pythonwin/Scintilla/lexers/LexR.cxx
@@ -1,5 +1,5 @@
 // Scintilla source code edit control
-/** @file Lexr.cxx
+/** @file LexR.cxx
  ** Lexer for R, S, SPlus Statistics Program (Heavily derived from CPP Lexer).
  **
  **/
@@ -8,22 +8,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static inline bool IsAWordChar(const int ch) {
 	return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_');
@@ -34,7 +35,7 @@ static inline bool IsAWordStart(const int ch) {
 }
 
 static inline bool IsAnOperator(const int ch) {
-	if (isascii(ch) && isalnum(ch))
+	if (IsASCII(ch) && isalnum(ch))
 		return false;
 	// '.' left out as it is used to make up numbers
 	if (ch == '-' || ch == '+' || ch == '!' || ch == '~' ||
@@ -47,7 +48,7 @@ static inline bool IsAnOperator(const int ch) {
 	return false;
 }
 
-static void ColouriseRDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
+static void ColouriseRDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
                             Accessor &styler) {
 
 	WordList &keywords   = *keywordlists[0];
@@ -77,9 +78,9 @@ static void ColouriseRDoc(unsigned int startPos, int length, int initStyle, Word
 				sc.SetState(SCE_R_DEFAULT);
 			}
 		} else if (sc.state == SCE_R_IDENTIFIER) {
-			if (!IsAWordChar(sc.ch) || (sc.ch == '.')) {
+			if (!IsAWordChar(sc.ch)) {
 				char s[100];
-				sc.GetCurrentLowered(s, sizeof(s));
+				sc.GetCurrent(s, sizeof(s));
 				if (keywords.InList(s)) {
 					sc.ChangeState(SCE_R_KWORD);
 				} else if  (keywords2.InList(s)) {
@@ -143,13 +144,13 @@ static void ColouriseRDoc(unsigned int startPos, int length, int initStyle, Word
 // Store both the current line's fold level and the next lines in the
 // level store to make it easy to pick up with each increment
 // and to make it possible to fiddle the current level for "} else {".
-static void FoldRDoc(unsigned int startPos, int length, int, WordList *[],
+static void FoldRDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[],
                        Accessor &styler) {
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
 	bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0;
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelCurrent = SC_FOLDLEVELBASE;
 	if (lineCurrent > 0)
 		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
@@ -157,7 +158,7 @@ static void FoldRDoc(unsigned int startPos, int length, int, WordList *[],
 	int levelNext = levelCurrent;
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int style = styleNext;
diff --git a/Pythonwin/Scintilla/lexers/LexRaku.cxx b/Pythonwin/Scintilla/lexers/LexRaku.cxx
new file mode 100644
index 000000000..17fff5e94
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexRaku.cxx
@@ -0,0 +1,1605 @@
+/** @file LexRaku.cxx
+ ** Lexer for Raku
+ **
+ ** Copyright (c) 2019 Mark Reay <mark@reay.net.au>
+ **/
+// Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+/*
+ * Raku (Perl6) Lexer for Scintilla
+ * ---------------------------------
+ * ---------------------------------
+ * 06-Dec-2019: More Unicode support:
+ *              - Added a full scope of allowed numbers and letters
+ * 29-Nov-2019: More  highlighting / implemented basic folding:
+ *              - Operators (blanket cover, no sequence checking)
+ *              - Class / Grammar name highlighting
+ *              - Folding:
+ *                - Comments: line / multi-line
+ *                - POD sections
+ *                - Code blocks {}
+ * 26-Nov-2019: Basic syntax highlighting covering the following:
+ *              - Comments, both line and embedded (multi-line)
+ *              - POD, no inline highlighting as yet...
+ *              - Heredoc block string, with variable highlighting (with qq)
+ *              - Strings, with variable highlighting (with ")
+ *              - Q Language, including adverbs (also basic q and qq)
+ *              - Regex, including adverbs
+ *              - Numbers
+ *              - Bareword / identifiers
+ *              - Types
+ *              - Variables: mu, positional, associative, callable
+ * TODO:
+ *       - POD inline
+ *       - Better operator sequence coverage
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+#include <vector>
+#include <map>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "CharacterCategory.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+namespace { // anonymous namespace to isolate any name clashes
+/*----------------------------------------------------------------------------*
+ * --- DEFINITIONS: OPTIONS / CONSTANTS ---
+ *----------------------------------------------------------------------------*/
+
+// Number types
+#define RAKUNUM_BINARY		1	// order is significant: 1-3 cannot have a dot
+#define RAKUNUM_OCTAL		2
+#define RAKUNUM_FLOAT_EXP	3	// exponent part only
+#define RAKUNUM_HEX			4	// may be a hex float
+#define RAKUNUM_DECIMAL		5	// 1-5 are numbers; 6-7 are strings
+#define RAKUNUM_VECTOR		6
+#define RAKUNUM_V_VECTOR	7
+#define RAKUNUM_VERSION		8	// can contain multiple '.'s
+#define RAKUNUM_BAD			9
+
+// Regex / Q string types
+#define RAKUTYPE_REGEX_NORM		0	// 0 char ident
+#define RAKUTYPE_REGEX_S		1	// order is significant:
+#define RAKUTYPE_REGEX_M		2	// 1 char ident
+#define RAKUTYPE_REGEX_Y		3	// 1 char ident
+#define RAKUTYPE_REGEX			4	// > RAKUTYPE_REGEX == 2 char identifiers
+#define RAKUTYPE_REGEX_RX		5	// 2 char ident
+#define RAKUTYPE_REGEX_TR		6	// 2 char ident
+#define RAKUTYPE_QLANG			7	// < RAKUTYPE_QLANG == RAKUTYPE_REGEX_?
+#define RAKUTYPE_STR_WQ			8	// 0 char ident < word quote >
+#define RAKUTYPE_STR_Q			9	// 1 char ident
+#define RAKUTYPE_STR_QX			10	// 2 char ident
+#define RAKUTYPE_STR_QW			11	// 2 char ident
+#define RAKUTYPE_STR_QQ			12	// 2 char ident
+#define RAKUTYPE_STR_QQX		13	// 3 char ident
+#define RAKUTYPE_STR_QQW		14	// 3 char ident
+#define RAKUTYPE_STR_QQWW		15	// 4 char ident
+
+// Delimiter types
+#define RAKUDELIM_BRACKET		0	// bracket: regex, Q language
+#define RAKUDELIM_QUOTE			1	// quote: normal string
+
+// rakuWordLists: keywords as defined in config
+const char *const rakuWordLists[] = {
+	"Keywords and identifiers",
+	"Functions",
+	"Types basic",
+	"Types composite",
+	"Types domain-specific",
+	"Types exception",
+	"Adverbs",
+	nullptr,
+};
+
+// Options and defaults
+struct OptionsRaku {
+	bool fold;
+	bool foldCompact;
+	bool foldComment;
+	bool foldCommentMultiline;
+	bool foldCommentPOD;
+	OptionsRaku() {
+		fold					= true;
+		foldCompact				= false;
+		foldComment				= true;
+		foldCommentMultiline	= true;
+		foldCommentPOD			= true;
+	}
+};
+
+// init options and words
+struct OptionSetRaku : public OptionSet<OptionsRaku> {
+	OptionSetRaku() {
+		DefineProperty("fold",			&OptionsRaku::fold);
+		DefineProperty("fold.comment",	&OptionsRaku::foldComment);
+		DefineProperty("fold.compact",	&OptionsRaku::foldCompact);
+
+		DefineProperty("fold.raku.comment.multiline",	&OptionsRaku::foldCommentMultiline,
+			"Set this property to 0 to disable folding multi-line comments when fold.comment=1.");
+		DefineProperty("fold.raku.comment.pod",			&OptionsRaku::foldCommentPOD,
+			"Set this property to 0 to disable folding POD comments when fold.comment=1.");
+
+		// init word lists
+		DefineWordListSets(rakuWordLists);
+	}
+};
+
+// Delimiter pair
+struct DelimPair {
+	int opener;		// opener char
+	int closer[2];	// closer chars
+	bool interpol;	// can variables be interpolated?
+	short count;	// delimiter char count
+	DelimPair() {
+		opener = 0;
+		closer[0] = 0;
+		closer[1] = 0;
+		interpol = false;
+		count = 0;
+	}
+	bool isCloser(int ch) const {
+		return ch == closer[0] || ch == closer[1];
+	}
+};
+
+/*----------------------------------------------------------------------------*
+ * --- FUNCTIONS ---
+ *----------------------------------------------------------------------------*/
+
+/*
+ * IsANewLine
+ * - returns true if this is a new line char
+ */
+constexpr bool IsANewLine(int ch) noexcept {
+	return ch == '\r' || ch == '\n';
+}
+
+/*
+ * IsAWhitespace
+ * - returns true if this is a whitespace (or newline) char
+ */
+bool IsAWhitespace(int ch) noexcept {
+	return IsASpaceOrTab(ch) || IsANewLine(ch);
+}
+
+/*
+ * IsAlphabet
+ * - returns true if this is an alphabetical char
+ */
+constexpr bool IsAlphabet(int ch) noexcept {
+	return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
+}
+
+/*
+ * IsCommentLine
+ * - returns true if this is a comment line
+ *   - tests: SCE_RAKU_COMMENTLINE or SCE_RAKU_COMMENTEMBED
+ * modified from: LexPerl.cxx
+ */
+bool IsCommentLine(Sci_Position line, LexAccessor &styler, int type = SCE_RAKU_COMMENTLINE) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eol_pos; i++) {
+		char ch = styler[i];
+		int style = styler.StyleAt(i);
+		if (type == SCE_RAKU_COMMENTEMBED) {
+			if (i == (eol_pos - 1) && style == type)
+				return true;
+		} else { // make sure the line is NOT a SCE_RAKU_COMMENTEMBED
+			if (ch == '#' && style == type && styler[i+1] != '`' )
+				return true;
+			else if (!IsASpaceOrTab(ch))
+				return false;
+		}
+	}
+	return false;
+}
+
+/*
+ * GetBracketCloseChar
+ * - returns the end bracket char: opposite of start
+ *   - see: http://www.unicode.org/Public/5.1.0/ucd/BidiMirroring.txt (first section)
+ * - Categories are general matches for valid BiDi types
+ * - Most closer chars are opener + 1
+ */
+int GetBracketCloseChar(const int ch) noexcept {
+	const CharacterCategory cc = CategoriseCharacter(ch);
+	switch (cc) {
+		case ccSm:
+			switch (ch) {
+				case 0x3C: return 0x3E; // LESS-THAN SIGN
+				case 0x2208: return 0x220B; // ELEMENT OF
+				case 0x2209: return 0x220C; // NOT AN ELEMENT OF
+				case 0x220A: return 0x220D; // SMALL ELEMENT OF
+				case 0x2215: return 0x29F5; // DIVISION SLASH
+				case 0x2243: return 0x22CD; // ASYMPTOTICALLY EQUAL TO
+				case 0x2298: return 0x29B8; // CIRCLED DIVISION SLASH
+				case 0x22A6: return 0x2ADE; // ASSERTION
+				case 0x22A8: return 0x2AE4; // TRUE
+				case 0x22A9: return 0x2AE3; // FORCES
+				case 0x22AB: return 0x2AE5; // DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE
+				case 0x22F2: return 0x22FA; // ELEMENT OF WITH LONG HORIZONTAL STROKE
+				case 0x22F3: return 0x22FB; // ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE
+				case 0x22F4: return 0x22FC; // SMALL ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE
+				case 0x22F6: return 0x22FD; // ELEMENT OF WITH OVERBAR
+				case 0x22F7: return 0x22FE; // SMALL ELEMENT OF WITH OVERBAR
+				case 0xFF1C: return 0xFF1E; // FULLWIDTH LESS-THAN SIGN
+			}
+			break;
+		case ccPs:
+			switch (ch) {
+				case 0x5B: return 0x5D; // LEFT SQUARE BRACKET
+				case 0x7B: return 0x7D; // LEFT CURLY BRACKET
+				case 0x298D: return 0x2990; // LEFT SQUARE BRACKET WITH TICK IN TOP CORNER
+				case 0x298F: return 0x298E; // LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
+				case 0xFF3B: return 0xFF3D; // FULLWIDTH LEFT SQUARE BRACKET
+				case 0xFF5B: return 0xFF5D; // FULLWIDTH LEFT CURLY BRACKET
+			}
+			break;
+		case ccPi:
+			break;
+		default: return 0;
+	}
+	return ch + 1;
+}
+
+/*
+ * IsValidQuoteOpener
+ * -
+ */
+bool IsValidQuoteOpener(const int ch, DelimPair &dp, int type = RAKUDELIM_BRACKET) noexcept {
+	dp.closer[0] = 0;
+	dp.closer[1] = 0;
+	dp.interpol = true;
+	if (type == RAKUDELIM_QUOTE) {
+		switch (ch) {
+			//   Opener		Closer					Description
+			case '\'':		dp.closer[0] = '\'';	// APOSTROPHE
+				dp.interpol = false;
+				break;
+			case '"':		dp.closer[0] = '"';		// QUOTATION MARK
+				break;
+			case 0x2018:	dp.closer[0] = 0x2019;	// LEFT SINGLE QUOTATION MARK
+				dp.interpol = false;
+				break;
+			case 0x201C:	dp.closer[0] = 0x201D;	// LEFT DOUBLE QUOTATION MARK
+				break;
+			case 0x201D:	dp.closer[0] = 0x201C;	// RIGHT DOUBLE QUOTATION MARK
+				break;
+			case 0x201E:	dp.closer[0] = 0x201C;	// DOUBLE LOW-9 QUOTATION MARK
+							dp.closer[1] = 0x201D;
+				break;
+			case 0xFF62:	dp.closer[0] = 0xFF63;	// HALFWIDTH LEFT CORNER BRACKET
+				dp.interpol = false;
+				break;
+			default:		return false;
+		}
+	} else if (type == RAKUDELIM_BRACKET) {
+		dp.closer[0] = GetBracketCloseChar(ch);
+	}
+	dp.opener = ch;
+	dp.count = 1;
+	return dp.closer[0] > 0;
+}
+
+/*
+ * IsBracketOpenChar
+ * - true if this is a valid start bracket character
+ */
+bool IsBracketOpenChar(int ch) noexcept {
+	return GetBracketCloseChar(ch) > 0;
+}
+
+/*
+ * IsValidRegOrQAdjacent
+ * - returns true if ch is a valid character to put directly after Q / q
+ *   * ref: Q Language: https://docs.raku.org/language/quoting
+ */
+bool IsValidRegOrQAdjacent(int ch) noexcept {
+	return !(IsAlphaNumeric(ch) || ch == '_' || ch == '(' || ch == ')' || ch == '\'' );
+}
+
+/*
+ * IsValidRegOrQPrecede
+ * - returns true if ch is a valid preceeding character to put directly before Q / q
+ *   * ref: Q Language: https://docs.raku.org/language/quoting
+ */
+bool IsValidRegOrQPrecede(int ch) noexcept {
+	return !(IsAlphaNumeric(ch) || ch == '_');
+}
+
+/*
+ * MatchCharInRange
+ * - returns true if the mach character is found in range (of length)
+ * - ignoreDelim (default false)
+ */
+bool MatchCharInRange(StyleContext &sc, const Sci_Position length,
+		const int match, bool ignoreDelim = false) {
+	Sci_Position len = 0;
+	int chPrev = sc.chPrev;
+	while (++len < length) {
+		const int ch = sc.GetRelativeCharacter(len);
+		if (ch == match && (ignoreDelim || chPrev != '\\'))
+			return true;
+	}
+	return false;
+}
+
+/*
+ * PrevNonWhitespaceChar
+ * - returns the last non-whitespace char
+ */
+int PrevNonWhitespaceChar(StyleContext &sc) {
+	Sci_Position rel = 0;
+	Sci_Position max_back = 0 - sc.currentPos;
+	while (--rel > max_back) {
+		const int ch = sc.GetRelativeCharacter(rel);
+		if (!IsAWhitespace(ch))
+			return ch;
+	}
+	return 0; // no matching char
+}
+
+/*
+ * IsQLangStartAtScPos
+ * - returns true if this is a valid Q Language sc position
+ *   - ref: https://docs.raku.org/language/quoting
+ *   - Q :adverb :adverb //;
+ *   - q,qx,qw,qq,qqx,qqw,qqww :adverb /:adverb /;
+ */
+bool IsQLangStartAtScPos(StyleContext &sc, int &type, const Sci_Position length) {
+	const bool valid_adj = IsValidRegOrQAdjacent(sc.chNext);
+	const int chFw2 = sc.GetRelativeCharacter(2);
+	const int chFw3 = sc.GetRelativeCharacter(3);
+	type = -1;
+	if (IsValidRegOrQPrecede(sc.chPrev)) {
+		if (sc.ch == 'Q' && valid_adj) {
+			type = RAKUTYPE_QLANG;
+		} else if (sc.ch == 'q') {
+			switch (sc.chNext) {
+				case 'x':
+					type = RAKUTYPE_STR_QX;
+					break;
+				case 'w':
+					type = RAKUTYPE_STR_QW;
+					break;
+				case 'q':
+					if (chFw2 == 'x') {
+						type = RAKUTYPE_STR_QQX;
+					} else if (chFw2 == 'w') {
+						if (chFw3 == 'w') {
+							type = RAKUTYPE_STR_QQWW;
+						} else {
+							type = RAKUTYPE_STR_QQW;
+						}
+					} else {
+						type = RAKUTYPE_STR_QQ;
+					}
+					break;
+				default:
+					type = RAKUTYPE_STR_Q;
+			}
+		} else if (sc.ch == '<' && MatchCharInRange(sc, length, '>')) {
+			type = RAKUTYPE_STR_WQ; // < word quote >
+		}
+	}
+	return type >= 0;
+}
+
+/*
+ * IsRegexStartAtScPos
+ * - returns true if this is a valid Regex sc position
+ *   - ref: https://docs.raku.org/language/regexes
+ *   - Regex: (rx/s/m/tr/y) :adverb /:adverb /;
+ *   -              regex R :adverb //;
+ *   -                     /:adverb /;
+ */
+bool IsRegexStartAtScPos(StyleContext &sc, int &type, CharacterSet &set) {
+	const bool valid_adj = IsValidRegOrQAdjacent(sc.chNext);
+	type = -1;
+	if (IsValidRegOrQPrecede(sc.chPrev)) {
+		switch (sc.ch) {
+			case 'r':
+				if (sc.chNext == 'x')
+					type = RAKUTYPE_REGEX_RX;
+				break;
+			case 't':
+			case 'T':
+				if (sc.chNext == 'r' || sc.chNext == 'R')
+					type = RAKUTYPE_REGEX_TR;
+				break;
+			case 'm':
+				if (valid_adj)
+					type = RAKUTYPE_REGEX_M;
+				break;
+			case 's':
+			case 'S':
+				if (valid_adj)
+					type = RAKUTYPE_REGEX_S;
+				break;
+			case 'y':
+				if (valid_adj)
+					type = RAKUTYPE_REGEX_Y;
+				break;
+			case '/':
+				if (set.Contains(PrevNonWhitespaceChar(sc)))
+					type = RAKUTYPE_REGEX_NORM;
+		}
+	}
+	return type >= 0;
+}
+
+/*
+ * IsValidIdentPrecede
+ * - returns if ch is a valid preceeding char to put directly before an identifier
+ */
+bool IsValidIdentPrecede(int ch) noexcept {
+	return !(IsAlphaNumeric(ch) || ch == '_' || ch == '@' || ch == '$' || ch == '%');
+}
+
+/*
+ * IsValidDelimiter
+ * - returns if ch is a valid delimiter (most chars are valid)
+ *   * ref: Q Language: https://docs.raku.org/language/quoting
+ */
+bool IsValidDelimiter(int ch) noexcept {
+	return !(IsAlphaNumeric(ch) || ch == ':');
+}
+
+/*
+ * GetDelimiterCloseChar
+ * - returns the corrisponding close char for a given delimiter (could be the same char)
+ */
+int GetDelimiterCloseChar(int ch) noexcept {
+	int ch_end = GetBracketCloseChar(ch);
+	if (ch_end == 0 && IsValidDelimiter(ch)) {
+		ch_end = ch;
+	}
+	return ch_end;
+}
+
+/*
+ * GetRepeatCharCount
+ * - returns the occurence count of match
+ */
+Sci_Position GetRepeatCharCount(StyleContext &sc, int chMatch, Sci_Position length) {
+	Sci_Position cnt = 0;
+	while (cnt < length) {
+		if (sc.GetRelativeCharacter(cnt) != chMatch) {
+			break;
+		}
+		cnt++;
+	}
+	return cnt;
+}
+
+/*
+ * LengthToDelimiter
+ * - returns the length until the end of a delimited string section
+ *   - Ignores nested delimiters (if opener != closer)
+ *   - no trailing char after last closer (default false)
+ */
+Sci_Position LengthToDelimiter(StyleContext &sc, const DelimPair &dp,
+		Sci_Position length, bool noTrailing = false) {
+	short cnt_open = 0;			// count open bracket
+	short cnt_close = 0;		// count close bracket
+	Sci_Position len = 0;		// count characters
+	int chOpener = dp.opener;	// look for nested opener / closer
+	if (dp.opener == dp.closer[0])
+		chOpener = 0;			// no opening delimiter (no nesting possible)
+
+	while (len < length) {
+		const int chPrev = sc.GetRelativeCharacter(len - 1);
+		const int ch = sc.GetRelativeCharacter(len);
+		const int chNext = sc.GetRelativeCharacter(len+1);
+
+		if (cnt_open == 0 && cnt_close == dp.count) {
+			return len;				// end condition has been met
+		} else {
+			if (chPrev != '\\' && ch == chOpener) {			// ignore escape sequence
+				cnt_open++;			// open nested bracket
+			} else if (chPrev != '\\' && dp.isCloser(ch)) {	// ignore escape sequence
+				if ( cnt_open > 0 ) {
+					cnt_open--;		// close nested bracket
+				} else if (dp.count > 1 && cnt_close < (dp.count - 1)) {
+					if (cnt_close > 1) {
+						if (dp.isCloser(chPrev)) {
+							cnt_close++;
+						} else {	// reset if previous char was not close
+							cnt_close = 0;
+						}
+					} else {
+						cnt_close++;
+					}
+				} else if (!noTrailing || (IsAWhitespace(chNext))) {
+					cnt_close++;		// found last close
+					if (cnt_close > 1 && !dp.isCloser(chPrev)) {
+						cnt_close = 0;	// reset if previous char was not close
+					}
+				} else {
+					cnt_close = 0;		// non handled close: reset
+				}
+			} else if (IsANewLine(ch)) {
+				cnt_open = 0;			// reset after each line
+				cnt_close = 0;
+			}
+		}
+		len++;
+	}
+	return -1; // end condition has NOT been met
+}
+
+/*
+ * LengthToEndHeredoc
+ * - returns the length until the end of a heredoc section
+ *   - delimiter string MUST begin on a new line
+ */
+Sci_Position LengthToEndHeredoc(const StyleContext &sc, LexAccessor &styler,
+		const Sci_Position length, const char *delim) {
+	bool on_new_ln = false;
+	int i = 0; // str index
+	for (int n = 0; n < length; n++) {
+		const char ch = styler.SafeGetCharAt(sc.currentPos + n, 0);
+		if (on_new_ln) {
+			if (delim[i] == '\0')
+				return n;	// at end of str, match found!
+			if (ch != delim[i++])
+				i = 0;		// no char match, reset 'i'ndex
+		}
+		if (i == 0)			// detect new line
+			on_new_ln = IsANewLine(ch);
+	}
+	return -1;				// no match found
+}
+
+/*
+ * LengthToNextChar
+ * - returns the length until the next character
+ */
+Sci_Position LengthToNextChar(StyleContext &sc, const Sci_Position length) {
+	Sci_Position len = 0;
+	while (++len < length) {
+		const int ch = sc.GetRelativeCharacter(len);
+		if (!IsASpaceOrTab(ch) && !IsANewLine(ch)) {
+			break;
+		}
+	}
+	return len;
+}
+
+/*
+ * GetRelativeString
+ * - gets a relitive string and sets it in &str
+ *   - resets string before seting
+ */
+void GetRelativeString(StyleContext &sc, Sci_Position offset, Sci_Position length,
+		std::string &str) {
+	Sci_Position pos = offset;
+	str.clear();
+	while (pos < length) {
+		str += sc.GetRelativeCharacter(pos++);
+	}
+}
+
+} // end anonymous namespace
+
+/*----------------------------------------------------------------------------*
+ * --- class: LexerRaku ---
+ *----------------------------------------------------------------------------*/
+//class LexerRaku : public ILexerWithMetaData {
+class LexerRaku : public DefaultLexer {
+	CharacterSet setWord;
+	CharacterSet setSigil;
+	CharacterSet setTwigil;
+	CharacterSet setOperator;
+	CharacterSet setSpecialVar;
+	WordList regexIdent;			// identifiers that specify a regex
+	OptionsRaku options;			// Options from config
+	OptionSetRaku osRaku;
+	WordList keywords;				// Word Lists from config
+	WordList functions;
+	WordList typesBasic;
+	WordList typesComposite;
+	WordList typesDomainSpecific;
+	WordList typesExceptions;
+	WordList adverbs;
+
+public:
+	// Defined as explicit, so that constructor can not be copied
+	explicit LexerRaku() :
+		DefaultLexer("raku", SCLEX_RAKU),
+		setWord(CharacterSet::setAlphaNum, "-_", 0x80),
+		setSigil(CharacterSet::setNone, "$&%@"),
+		setTwigil(CharacterSet::setNone, "!*.:<=?^~"),
+		setOperator(CharacterSet::setNone, "^&\\()-+=|{}[]:;<>,?!.~"),
+		setSpecialVar(CharacterSet::setNone, "_/!") {
+		regexIdent.Set("regex rule token");
+	}
+	// Deleted so LexerRaku objects can not be copied.
+	LexerRaku(const LexerRaku &) = delete;
+	LexerRaku(LexerRaku &&) = delete;
+	void operator=(const LexerRaku &) = delete;
+	void operator=(LexerRaku &&) = delete;
+	virtual ~LexerRaku() {
+	}
+	void SCI_METHOD Release() noexcept override {
+		delete this;
+	}
+	int SCI_METHOD Version() const noexcept override {
+		return lvRelease5;
+	}
+	const char *SCI_METHOD PropertyNames() override {
+		return osRaku.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return osRaku.PropertyType(name);
+	}
+	const char *SCI_METHOD DescribeProperty(const char *name) override {
+		return osRaku.DescribeProperty(name);
+	}
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char *SCI_METHOD PropertyGet(const char *key) override {
+		return osRaku.PropertyGet(key);
+	}
+	const char *SCI_METHOD DescribeWordListSets() override {
+		return osRaku.DescribeWordListSets();
+	}
+	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;
+
+	static ILexer5 *LexerFactoryRaku() {
+		return new LexerRaku();
+	}
+
+protected:
+	bool IsOperatorChar(const int ch);
+	bool IsWordChar(const int ch, bool allowNumber = true);
+	bool IsWordStartChar(const int ch);
+	bool IsNumberChar(const int ch, int base = 10);
+	bool ProcessRegexTwinCapture(StyleContext &sc, const Sci_Position length,
+		int &type, const DelimPair &dp);
+	void ProcessStringVars(StyleContext &sc, const Sci_Position length, const int varState);
+	bool ProcessValidRegQlangStart(StyleContext &sc, Sci_Position length, const int type,
+		WordList &wordsAdverbs, DelimPair &dp);
+	Sci_Position LengthToNonWordChar(StyleContext &sc, Sci_Position length,
+		char *s, const int size, Sci_Position offset = 0);
+};
+
+/*----------------------------------------------------------------------------*
+ * --- METHODS: LexerRaku ---
+ *----------------------------------------------------------------------------*/
+
+/*
+ * LexerRaku::IsOperatorChar
+ * - Test for both ASCII and Unicode operators
+ *   see: https://docs.raku.org/language/unicode_entry
+ */
+bool LexerRaku::IsOperatorChar(const int ch) {
+	if (ch > 0x7F) {
+		switch (ch) {
+			//   Unicode	ASCII Equiv.
+			case 0x2208:	// (elem)
+			case 0x2209:	// !(elem)
+			case 0x220B:	// (cont)
+			case 0x220C:	// !(cont)
+			case 0x2216:	// (-)
+			case 0x2229:	// (&)
+			case 0x222A:	// (|)
+			case 0x2282:	// (<)
+			case 0x2283:	// (>)
+			case 0x2284:	// !(<)
+			case 0x2285:	// !(>)
+			case 0x2286:	// (<=)
+			case 0x2287:	// (>=)
+			case 0x2288:	// !(<=)
+			case 0x2289:	// !(>=)
+			case 0x228D:	// (.)
+			case 0x228E:	// (+)
+			case 0x2296:	// (^)
+				return true;
+		}
+	}
+	return setOperator.Contains(ch);
+}
+
+/*
+ * LexerRaku::IsWordChar
+ * - Test for both ASCII and Unicode identifier characters
+ *   see: https://docs.raku.org/language/unicode_ascii
+ *   also: ftp://ftp.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
+ *   FIXME: *still* may not contain all valid characters
+ */
+bool LexerRaku::IsWordChar(const int ch, bool allowNumber) {
+	// Unicode numbers should not apear in word identifiers
+	if (ch > 0x7F) {
+		const CharacterCategory cc = CategoriseCharacter(ch);
+		switch (cc) {
+			// Letters
+			case ccLu:
+			case ccLl:
+			case ccLt:
+			case ccLm:
+			case ccLo:
+				return true;
+			default:
+				return false;
+		}
+	} else if (allowNumber && IsADigit(ch)) {
+		return true; // an ASCII number type
+	}
+	return setWord.Contains(ch);
+}
+
+/*
+ * LexerRaku::IsWordStartChar
+ * - Test for both ASCII and Unicode identifier "start / first" characters
+ */
+bool LexerRaku::IsWordStartChar(const int ch) {
+	return ch != '-' && IsWordChar(ch, false); // no numbers allowed
+}
+
+/*
+ * LexerRaku::IsNumberChar
+ * - Test for both ASCII and Unicode identifier number characters
+ *   see: https://docs.raku.org/language/unicode_ascii
+ *   also: ftp://ftp.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
+ *   FILTERED by Unicode letters that are NUMBER
+ *     and NOT PARENTHESIZED or CIRCLED
+ *   FIXME: *still* may not contain all valid number characters
+ */
+bool LexerRaku::IsNumberChar(const int ch, int base) {
+	if (ch > 0x7F) {
+		const CharacterCategory cc = CategoriseCharacter(ch);
+		switch (cc) {
+			// Numbers
+			case ccNd:
+			case ccNl:
+			case ccNo:
+				return true;
+			default:
+				return false;
+		}
+	}
+	return IsADigit(ch, base);
+}
+
+/*
+ * LexerRaku::PropertySet
+ * -
+ */
+Sci_Position SCI_METHOD LexerRaku::PropertySet(const char *key, const char *val) {
+	if (osRaku.PropertySet(&options, key, val))
+		return 0;
+	return -1;
+}
+
+/*
+ * LexerRaku::WordListSet
+ * -
+ */
+Sci_Position SCI_METHOD LexerRaku::WordListSet(int n, const char *wl) {
+	WordList *wordListN = nullptr;
+	switch (n) {
+		case 0:
+			wordListN = &keywords;
+			break;
+		case 1:
+			wordListN = &functions;
+			break;
+		case 2:
+			wordListN = &typesBasic;
+			break;
+		case 3:
+			wordListN = &typesComposite;
+			break;
+		case 4:
+			wordListN = &typesDomainSpecific;
+			break;
+		case 5:
+			wordListN = &typesExceptions;
+			break;
+		case 6:
+			wordListN = &adverbs;
+			break;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN) {
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+		}
+	}
+	return firstModification;
+}
+
+/*
+ * LexerRaku::ProcessRegexTwinCapture
+ * - processes the transition between a regex pair (two sets of delimiters)
+ * - moves to first new delimiter, if a bracket
+ * - returns true when valid delimiter start found (if bracket)
+ */
+bool LexerRaku::ProcessRegexTwinCapture(StyleContext &sc, const Sci_Position length,
+		int &type, const DelimPair &dp) {
+
+	if (type == RAKUTYPE_REGEX_S || type == RAKUTYPE_REGEX_TR || type == RAKUTYPE_REGEX_Y) {
+		type = -1; // clear type
+
+		// move past chRegQClose if it was the previous char
+		if (dp.isCloser(sc.chPrev))
+			sc.Forward();
+
+		// no processing needed for non-bracket
+		if (dp.isCloser(dp.opener))
+			return true;
+
+		// move to next opening bracket
+		const Sci_Position len = LengthToNextChar(sc, length);
+		if (sc.GetRelativeCharacter(len) == dp.opener) {
+			sc.Forward(len);
+			return true;
+		}
+	}
+	return false;
+}
+
+/*
+ * LexerRaku::ProcessStringVars
+ * - processes a string and highlights any valid variables
+ */
+void LexerRaku::ProcessStringVars(StyleContext &sc, const Sci_Position length, const int varState) {
+	const int state = sc.state;
+	for (Sci_Position pos = 0; pos < length; pos++) {
+		if (sc.state == varState && !IsWordChar(sc.ch)) {
+			sc.SetState(state);
+		} else if (sc.chPrev != '\\'
+				&& (sc.ch == '$' || sc.ch == '@')
+				&& IsWordStartChar(sc.chNext)) {
+			sc.SetState(varState);
+		}
+		sc.Forward(); // Next character
+	}
+}
+/*
+ * LexerRaku::ProcessValidRegQlangStart
+ * - processes a section of the document range from after a Regex / Q delimiter
+ * - returns true on success
+ *   - sets: adverbs, chOpen, chClose, chCount
+ *  ref: https://docs.raku.org/language/regexes
+ */
+bool LexerRaku::ProcessValidRegQlangStart(StyleContext &sc, Sci_Position length, const int type,
+		WordList &wordsAdverbs, DelimPair &dp) {
+	Sci_Position startPos = sc.currentPos;
+	Sci_Position startLen = length;
+	const int target_state = sc.state;
+	int state = SCE_RAKU_DEFAULT;
+	std::string str;
+
+	// find our opening delimiter (and occurrences) / save any adverbs
+	dp.opener = 0;					// adverbs can be after the first delimiter
+	bool got_all_adverbs = false;	// in Regex statements
+	bool got_ident = false;			// regex can have an identifier: 'regex R'
+	sc.SetState(state);				// set state default to avoid pre-highlights
+	while ((dp.opener == 0 || !got_all_adverbs) && sc.More()) {
+
+		// move to the next non-space character
+		const bool was_space = IsAWhitespace(sc.ch);
+		if (!got_all_adverbs && was_space) {
+			sc.Forward(LengthToNextChar(sc, length));
+		}
+		length = startLen - (sc.currentPos - startPos); // update length remaining
+
+		// parse / eat an identifier (if type == RAKUTYPE_REGEX)
+		if (dp.opener == 0 && !got_ident && type == RAKUTYPE_REGEX && IsAlphabet(sc.ch)) {
+
+			// eat identifier / account for special adverb :sym<name>
+			bool got_sym = false;
+			while (sc.More()) {
+				sc.SetState(SCE_RAKU_IDENTIFIER);
+				while (sc.More() && (IsAlphaNumeric(sc.chNext)
+						|| sc.chNext == '_' || sc.chNext == '-')) {
+					sc.Forward();
+				}
+				sc.Forward();
+				if (got_sym && sc.ch == '>') {
+					sc.SetState(SCE_RAKU_OPERATOR);	// '>'
+					sc.Forward();
+					break;
+				} else if (type == RAKUTYPE_REGEX && sc.Match(":sym<")) {
+					sc.SetState(SCE_RAKU_ADVERB);	// ':sym'
+					sc.Forward(4);
+					sc.SetState(SCE_RAKU_OPERATOR);	// '<'
+					sc.Forward();
+					got_sym = true;
+				} else {
+					break;
+				}
+			}
+			sc.SetState(state);
+			got_ident = true;
+		}
+
+		// parse / save an adverb: RAKUTYPE_REGEX only has adverbs after delim
+		//                      >= RAKUTYPE_QLANG only has adverbs before delim
+		else if (!got_all_adverbs && sc.ch == ':' && (!(dp.opener == 0 && got_ident)
+				&& !(dp.opener > 0 && type >= RAKUTYPE_QLANG))) {
+			sc.SetState(SCE_RAKU_ADVERB);
+			while (IsAlphaNumeric(sc.chNext) && sc.More()) {
+				sc.Forward();
+				str += sc.ch;
+			}
+			str += ' ';
+			sc.Forward();
+			sc.SetState(state);
+		}
+
+		// find starting delimiter
+		else if (dp.opener == 0 && (was_space || IsValidRegOrQAdjacent(sc.ch))
+				&& IsValidDelimiter(sc.ch)) {	// make sure the delimiter is legal (most are)
+			sc.SetState((state = target_state));// start state here...
+			dp.opener = sc.ch;					// this is our delimiter, get count
+			if (type < RAKUTYPE_QLANG)			// type is Regex
+				dp.count = 1;					// has only one delimiter
+			else
+				dp.count = GetRepeatCharCount(sc, dp.opener, length);
+			sc.Forward(dp.count);
+		}
+
+		// we must have all the adverbs by now...
+		else {
+			if (got_all_adverbs)
+				break; // prevent infinite loop: occurs on missing open char
+			got_all_adverbs = true;
+		}
+	}
+
+	// set word list / find a valid closing delimiter (or bomb!)
+	wordsAdverbs.Set(str.c_str());
+	dp.closer[0] = GetDelimiterCloseChar(dp.opener);
+	dp.closer[1] = 0; // no other closer char
+	return dp.closer[0] > 0;
+}
+
+/*
+ * LexerRaku::LengthToNonWordChar
+ * - returns the length until the next non "word" character: AlphaNum + '_'
+ *   - also sets all the parsed chars in 's'
+ */
+Sci_Position LexerRaku::LengthToNonWordChar(StyleContext &sc, Sci_Position length,
+		char *s, const int size, Sci_Position offset) {
+	Sci_Position len = 0;
+	Sci_Position max_length = size < length ? size : length;
+	while (len <= max_length) {
+		const int ch = sc.GetRelativeCharacter(len + offset);
+		if (!IsWordChar(ch)) {
+			s[len] = '\0';
+			break;
+		}
+		s[len] = ch;
+		len++;
+	}
+	s[len + 1] = '\0';
+	return len;
+}
+
+/*
+ * LexerRaku::Lex
+ * - Main lexer method
+ */
+void SCI_METHOD LexerRaku::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	LexAccessor styler(pAccess);
+	DelimPair dpEmbeded;			// delimiter pair: embeded comments
+	DelimPair dpString;				// delimiter pair: string
+	DelimPair dpRegQ;				// delimiter pair: Regex / Q Lang
+	std::string hereDelim;			// heredoc delimiter (if in heredoc)
+	int hereState = 0;				// heredoc state to use (Q / QQ)
+	int numState = 0;				// number state / type
+	short cntDecimal = 0;			// number decinal count
+	std::string wordLast;			// last word seen
+	std::string identLast;			// last identifier seen
+	std::string adverbLast;			// last (single) adverb seen
+	WordList lastAdverbs;			// last adverbs seen
+	Sci_Position len;				// temp length value
+	char s[100];					// temp char string
+	int typeDetect;					// temp type detected (for regex and Q lang)
+	Sci_Position lengthToEnd;		// length until the end of range
+
+	// Backtrack to last SCE_RAKU_DEFAULT or 0
+	Sci_PositionU newStartPos = startPos;
+	if (initStyle != SCE_RAKU_DEFAULT) {
+		while (newStartPos > 0) {
+			newStartPos--;
+			if (styler.StyleAt(newStartPos) == SCE_RAKU_DEFAULT)
+				break;
+		}
+	}
+
+	// Backtrack to start of line before SCE_RAKU_HEREDOC_Q?
+	if (initStyle == SCE_RAKU_HEREDOC_Q || initStyle == SCE_RAKU_HEREDOC_QQ) {
+		while (newStartPos > 0) {
+			if (IsANewLine(styler.SafeGetCharAt(newStartPos - 1)))
+				break; // Stop if previous char is a new line
+			newStartPos--;
+		}
+	}
+
+	// Re-calculate (any) changed startPos, length and initStyle state
+	if (newStartPos < startPos) {
+		initStyle = SCE_RAKU_DEFAULT;
+		length += startPos - newStartPos;
+		startPos = newStartPos;
+	}
+
+	// init StyleContext
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	// StyleContext Loop
+	for (; sc.More(); sc.Forward()) {
+		lengthToEnd = (length - (sc.currentPos - startPos)); // end of range
+
+		/* *** Determine if the current state should terminate ************** *
+		 * Everything within the 'switch' statement processes characters up
+		 * until the end of a syntax highlight section / state.
+		 * ****************************************************************** */
+		switch (sc.state) {
+			case SCE_RAKU_OPERATOR:
+				sc.SetState(SCE_RAKU_DEFAULT);
+				break; // FIXME: better valid operator sequences needed?
+			case SCE_RAKU_COMMENTLINE:
+				if (IsANewLine(sc.ch)) {
+					sc.SetState(SCE_RAKU_DEFAULT);
+				}
+				break;
+			case SCE_RAKU_COMMENTEMBED:
+				if ((len = LengthToDelimiter(sc, dpEmbeded, lengthToEnd)) >= 0) {
+					sc.Forward(len);			// Move to end delimiter
+					sc.SetState(SCE_RAKU_DEFAULT);
+				} else {
+					sc.Forward(lengthToEnd);	// no end delimiter found
+				}
+				break;
+			case SCE_RAKU_POD:
+				if (sc.atLineStart && sc.Match("=end pod")) {
+					sc.Forward(8);
+					sc.SetState(SCE_RAKU_DEFAULT);
+				}
+				break;
+			case SCE_RAKU_STRING:
+
+				// Process the string for variables: move to end delimiter
+				if ((len = LengthToDelimiter(sc, dpString, lengthToEnd)) >= 0) {
+					if (dpString.interpol) {
+						ProcessStringVars(sc, len, SCE_RAKU_STRING_VAR);
+					} else {
+						sc.Forward(len);
+					}
+					sc.SetState(SCE_RAKU_DEFAULT);
+				} else {
+					sc.Forward(lengthToEnd);	// no end delimiter found
+				}
+				break;
+			case SCE_RAKU_STRING_Q:
+			case SCE_RAKU_STRING_QQ:
+			case SCE_RAKU_STRING_Q_LANG:
+
+				// No string: previous char was the delimiter
+				if (dpRegQ.count == 1 && dpRegQ.isCloser(sc.chPrev)) {
+					sc.SetState(SCE_RAKU_DEFAULT);
+				}
+
+				// Process the string for variables: move to end delimiter
+				else if ((len = LengthToDelimiter(sc, dpRegQ, lengthToEnd)) >= 0) {
+
+					// set (any) heredoc delimiter string
+					if (lastAdverbs.InList("to")) {
+						GetRelativeString(sc, -1, len - dpRegQ.count, hereDelim);
+						hereState = SCE_RAKU_HEREDOC_Q; // default heredoc state
+					}
+
+					// select variable identifiers
+					if (sc.state == SCE_RAKU_STRING_QQ || lastAdverbs.InList("qq")) {
+						ProcessStringVars(sc, len, SCE_RAKU_STRING_VAR);
+						hereState = SCE_RAKU_HEREDOC_QQ; // potential heredoc state
+					} else {
+						sc.Forward(len);
+					}
+					sc.SetState(SCE_RAKU_DEFAULT);
+				} else {
+					sc.Forward(lengthToEnd);	// no end delimiter found
+				}
+				break;
+			case SCE_RAKU_HEREDOC_Q:
+			case SCE_RAKU_HEREDOC_QQ:
+				if ((len = LengthToEndHeredoc(sc, styler, lengthToEnd, hereDelim.c_str())) >= 0) {
+					// select variable identifiers
+					if (sc.state == SCE_RAKU_HEREDOC_QQ) {
+						ProcessStringVars(sc, len, SCE_RAKU_STRING_VAR);
+					} else {
+						sc.Forward(len);
+					}
+					sc.SetState(SCE_RAKU_DEFAULT);
+				} else {
+					sc.Forward(lengthToEnd);	// no end delimiter found
+				}
+				hereDelim.clear();				// clear heredoc delimiter
+				break;
+			case SCE_RAKU_REGEX:
+				// account for typeDetect = RAKUTYPE_REGEX_S/TR/Y
+				while (sc.state == SCE_RAKU_REGEX) {
+
+					// No string: previous char was the delimiter
+					if (dpRegQ.count == 1 && dpRegQ.isCloser(sc.chPrev)) {
+						if (ProcessRegexTwinCapture(sc, lengthToEnd, typeDetect, dpRegQ))
+							continue;
+						sc.SetState(SCE_RAKU_DEFAULT);
+						break;
+					}
+
+					// Process the string for variables: move to end delimiter
+					else if ((len = LengthToDelimiter(sc, dpRegQ, lengthToEnd)) >= 0) {
+						ProcessStringVars(sc, len, SCE_RAKU_REGEX_VAR);
+						if (ProcessRegexTwinCapture(sc, lengthToEnd, typeDetect, dpRegQ))
+							continue;
+						sc.SetState(SCE_RAKU_DEFAULT);
+						break;
+					} else {
+						sc.Forward(lengthToEnd); // no end delimiter found
+						break;
+					}
+				}
+				break;
+			case SCE_RAKU_NUMBER:
+				if (sc.ch == '.') {
+					if (sc.chNext == '.') {		// '..' is an operator
+						sc.SetState(SCE_RAKU_OPERATOR);
+						sc.Forward();
+						if (sc.chNext == '.')	// '...' is also an operator
+							sc.Forward();
+						break;
+					} else if (numState > RAKUNUM_FLOAT_EXP
+							&& (cntDecimal < 1 || numState == RAKUNUM_VERSION)) {
+						cntDecimal++;
+						sc.Forward();
+					} else {
+						sc.SetState(SCE_RAKU_DEFAULT);
+						break; // too many decinal places
+					}
+				}
+				switch (numState) {
+					case RAKUNUM_BINARY:
+						if (!IsNumberChar(sc.ch, 2))
+							sc.SetState(SCE_RAKU_DEFAULT);
+						break;
+					case RAKUNUM_OCTAL:
+						if (!IsNumberChar(sc.ch, 8))
+							sc.SetState(SCE_RAKU_DEFAULT);
+						break;
+					case RAKUNUM_HEX:
+						if (!IsNumberChar(sc.ch, 16))
+							sc.SetState(SCE_RAKU_DEFAULT);
+						break;
+					case RAKUNUM_DECIMAL:
+					case RAKUNUM_VERSION:
+						if (!IsNumberChar(sc.ch))
+							sc.SetState(SCE_RAKU_DEFAULT);
+				}
+				break;
+			case SCE_RAKU_WORD:
+			case SCE_RAKU_FUNCTION:
+			case SCE_RAKU_TYPEDEF:
+			case SCE_RAKU_ADVERB:
+				sc.SetState(SCE_RAKU_DEFAULT);
+				break;
+			case SCE_RAKU_MU:
+			case SCE_RAKU_POSITIONAL:
+			case SCE_RAKU_ASSOCIATIVE:
+			case SCE_RAKU_CALLABLE:
+			case SCE_RAKU_IDENTIFIER:
+			case SCE_RAKU_GRAMMAR:
+			case SCE_RAKU_CLASS:
+				sc.SetState(SCE_RAKU_DEFAULT);
+				break;
+		}
+
+		/* *** Determine if a new state should be entered ******************* *
+		 * Everything below here identifies the beginning of a state, all or part
+		 * of the characters within this state are processed here, the rest are
+		 * completed above in the terminate state section.
+		 * ****************************************************************** */
+		if (sc.state == SCE_RAKU_DEFAULT) {
+
+			// --- Single line comment
+			if (sc.ch == '#') {
+				sc.SetState(SCE_RAKU_COMMENTLINE);
+			}
+
+			// --- POD block
+			else if (sc.atLineStart && sc.Match("=begin pod")) {
+				sc.SetState(SCE_RAKU_POD);
+				sc.Forward(10);
+			}
+
+			// --- String (normal)
+			else if (sc.chPrev != '\\' && (IsValidQuoteOpener(sc.ch, dpString, RAKUDELIM_QUOTE))) {
+				sc.SetState(SCE_RAKU_STRING);
+			}
+
+			// --- String (Q Language) ----------------------------------------
+			//   - https://docs.raku.org/language/quoting
+			//   - Q :adverb :adverb //;
+			//   - q,qx,qw,qq,qqx,qqw,qqww :adverb :adverb //;
+			else if (IsQLangStartAtScPos(sc, typeDetect, lengthToEnd)) {
+				int state = SCE_RAKU_STRING_Q_LANG;
+				Sci_Position forward = 1;	// single char ident (default)
+				if (typeDetect > RAKUTYPE_QLANG) {
+					state = SCE_RAKU_STRING_Q;
+					if (typeDetect == RAKUTYPE_STR_WQ)
+						forward = 0;		// no char ident
+				}
+				if (typeDetect > RAKUTYPE_STR_Q) {
+					if (typeDetect == RAKUTYPE_STR_QQ)
+						state = SCE_RAKU_STRING_QQ;
+					forward++;				// two char ident
+				}
+				if (typeDetect > RAKUTYPE_STR_QQ)
+					forward++;				// three char ident
+				if (typeDetect == RAKUTYPE_STR_QQWW)
+					forward++;				// four char ident
+
+				// Proceed: check for a valid character after statement
+				if (IsValidRegOrQAdjacent(sc.GetRelative(forward)) || typeDetect == RAKUTYPE_QLANG) {
+					sc.SetState(state);
+					sc.Forward(forward);
+					lastAdverbs.Clear();
+
+					// Process: adverbs / opening delimiter / adverbs after delim
+					if (ProcessValidRegQlangStart(sc, lengthToEnd, typeDetect,
+							lastAdverbs, dpRegQ))
+						sc.SetState(state);
+				}
+			}
+
+			// --- Regex (rx/s/m/tr/y) ----------------------------------------
+			//   - https://docs.raku.org/language/regexes
+			else if ((IsRegexStartAtScPos(sc, typeDetect, setOperator) || regexIdent.InList(wordLast.c_str()))) {
+				if (typeDetect == -1) { // must be a regex identifier word
+					wordLast.clear();
+					typeDetect = RAKUTYPE_REGEX;
+				}
+				Sci_Position forward = 0;	// no ident (RAKUTYPE_REGEX, RAKUTYPE_REGEX_NORM)
+				if (typeDetect > 0 && typeDetect != RAKUTYPE_REGEX)
+					forward++;				// single char ident
+				if (typeDetect > RAKUTYPE_REGEX)
+					forward++;				// two char ident
+
+				// Proceed: check for a valid character after statement
+				if (IsValidRegOrQAdjacent(sc.GetRelative(forward)) || typeDetect == RAKUTYPE_REGEX_NORM) {
+					sc.SetState(SCE_RAKU_REGEX);
+					sc.Forward(forward);
+					lastAdverbs.Clear();
+
+					// Process: adverbs / opening delimiter / adverbs after delim
+					if (ProcessValidRegQlangStart(sc, lengthToEnd, typeDetect,
+							lastAdverbs, dpRegQ))
+						sc.SetState(SCE_RAKU_REGEX);
+				}
+			}
+
+			// --- Numbers ----------------------------------------------------
+			else if (IsValidIdentPrecede(sc.chPrev) && (IsNumberChar(sc.ch)
+					|| (sc.ch == 'v' && IsNumberChar(sc.chNext) && wordLast == "use"))) {
+				numState = RAKUNUM_DECIMAL;	// default: decimal (base 10)
+				cntDecimal = 0;
+				sc.SetState(SCE_RAKU_NUMBER);
+				if (sc.ch == 'v')			// forward past 'v'
+					sc.Forward();
+				if (wordLast == "use") {	// package version number
+					numState = RAKUNUM_VERSION;
+				} else if (sc.ch == '0') {	// other type of number
+					switch (sc.chNext) {
+						case 'b':	// binary (base 2)
+							numState = RAKUNUM_BINARY;
+							break;
+						case 'o':	// octal (base 8)
+							numState = RAKUNUM_OCTAL;
+							break;
+						case 'x':	// hexadecimal (base 16)
+							numState = RAKUNUM_HEX;
+					}
+					if (numState != RAKUNUM_DECIMAL)
+						sc.Forward();		// forward to number type char
+				}
+			}
+
+			// --- Keywords / functions / types / barewords -------------------
+			else if ((sc.currentPos == 0 || sc.atLineStart || IsValidIdentPrecede(sc.chPrev))
+					&& IsWordStartChar(sc.ch)) {
+				len = LengthToNonWordChar(sc, lengthToEnd, s, sizeof(s));
+				if (keywords.InList(s)) {
+					sc.SetState(SCE_RAKU_WORD);		// Keywords
+				} else if(functions.InList(s)) {
+					sc.SetState(SCE_RAKU_FUNCTION);	// Functions
+				} else if(typesBasic.InList(s)) {
+					sc.SetState(SCE_RAKU_TYPEDEF);	// Types (basic)
+				} else if(typesComposite.InList(s)) {
+					sc.SetState(SCE_RAKU_TYPEDEF);	// Types (composite)
+				} else if(typesDomainSpecific.InList(s)) {
+					sc.SetState(SCE_RAKU_TYPEDEF);	// Types (domain-specific)
+				} else if(typesExceptions.InList(s)) {
+					sc.SetState(SCE_RAKU_TYPEDEF);	// Types (exceptions)
+				} else {
+					if (wordLast == "class")
+						sc.SetState(SCE_RAKU_CLASS);	// a Class ident
+					else if (wordLast == "grammar")
+						sc.SetState(SCE_RAKU_GRAMMAR);	// a Grammar ident
+					else
+						sc.SetState(SCE_RAKU_IDENTIFIER);	// Bareword
+					identLast = s;						// save identifier
+				}
+				if (adverbLast == "sym") {				// special adverb ":sym"
+					sc.SetState(SCE_RAKU_IDENTIFIER);	// treat as identifier
+					identLast = s;						// save identifier
+				}
+				if (sc.state != SCE_RAKU_IDENTIFIER)
+					wordLast = s;					// save word
+				sc.Forward(len - 1);				// ...forward past word
+			}
+
+			// --- Adverbs ----------------------------------------------------
+			else if (sc.ch == ':' && IsWordStartChar(sc.chNext)) {
+				len = LengthToNonWordChar(sc, lengthToEnd, s, sizeof(s), 1);
+				if (adverbs.InList(s)) {
+					sc.SetState(SCE_RAKU_ADVERB);	// Adverbs (begin with ':')
+					adverbLast = s;					// save word
+					sc.Forward(len); // ...forward past word (less offset: 1)
+				}
+			}
+
+			// --- Identifiers: $mu / @positional / %associative / &callable --
+			//     see: https://docs.raku.org/language/variables
+			else if (setSigil.Contains(sc.ch) && (setTwigil.Contains(sc.chNext)
+					|| setSpecialVar.Contains(sc.chNext)
+					|| IsWordStartChar(sc.chNext))) {
+
+				// State based on sigil
+				switch (sc.ch) {
+					case '$': sc.SetState(SCE_RAKU_MU);
+						break;
+					case '@': sc.SetState(SCE_RAKU_POSITIONAL);
+						break;
+					case '%': sc.SetState(SCE_RAKU_ASSOCIATIVE);
+						break;
+					case '&': sc.SetState(SCE_RAKU_CALLABLE);
+				}
+				const int state = sc.state;
+				sc.Forward();
+				char ch_delim = 0;
+				if (setSpecialVar.Contains(sc.ch)
+						&& !setWord.Contains(sc.chNext)) {	// Process Special Var
+					ch_delim = -1;
+				} else if (setTwigil.Contains(sc.ch)) {		// Process Twigil
+					sc.SetState(SCE_RAKU_OPERATOR);
+					if (sc.ch == '<' && setWord.Contains(sc.chNext))
+						ch_delim = '>';
+					sc.Forward();
+					sc.SetState(state);
+				}
+
+				// Process (any) identifier
+				if (ch_delim >= 0) {
+					sc.Forward(LengthToNonWordChar(sc, lengthToEnd, s, sizeof(s)) - 1);
+					if (ch_delim > 0 && sc.chNext == ch_delim) {
+						sc.Forward();
+						sc.SetState(SCE_RAKU_OPERATOR);
+					}
+					identLast = s;	// save identifier
+				}
+			}
+
+			// --- Operators --------------------------------------------------
+			else if (IsOperatorChar(sc.ch)) {
+				// FIXME: better valid operator sequences needed?
+				sc.SetState(SCE_RAKU_OPERATOR);
+			}
+
+			// --- Heredoc: begin ---------------------------------------------
+			else if (!hereDelim.empty() && sc.atLineEnd) {
+				if (IsANewLine(sc.ch))
+					sc.Forward(); // skip a possible CRLF situation
+				sc.SetState(hereState);
+			}
+
+			// Reset words: on operator simi-colon OR '}' (end of statement)
+			if (sc.state == SCE_RAKU_OPERATOR && (sc.ch == ';' || sc.ch == '}')) {
+				wordLast.clear();
+				identLast.clear();
+				adverbLast.clear();
+			}
+		}
+
+		/* *** Determine if an "embedded comment" is to be entered ********** *
+		 * This type of embedded comment section, or multi-line comment comes
+		 * after a normal comment has begun... e.g: #`[ ... ]
+		 * ****************************************************************** */
+		else if (sc.state == SCE_RAKU_COMMENTLINE && sc.chPrev == '#' && sc.ch == '`') {
+			if (IsBracketOpenChar(sc.chNext)) {
+				sc.Forward(); // Condition met for "embedded comment"
+				dpEmbeded.opener = sc.ch;
+
+				// Find the opposite (termination) closeing bracket (if any)
+				dpEmbeded.closer[0] = GetBracketCloseChar(dpEmbeded.opener);
+				if (dpEmbeded.closer[0] > 0) { // Enter "embedded comment"
+
+					// Find multiple opening character occurence
+					dpEmbeded.count = GetRepeatCharCount(sc, dpEmbeded.opener, lengthToEnd);
+					sc.SetState(SCE_RAKU_COMMENTEMBED);
+					sc.Forward(dpEmbeded.count - 1); // incremented in the next loop
+				}
+			}
+		}
+	}
+
+	// And we're done...
+	sc.Complete();
+}
+
+/*
+ * LexerRaku::Lex
+ * - Main fold method
+ *   NOTE: although Raku uses and supports UNICODE characters, we're only looking
+ *         at normal chars here, using 'SafeGetCharAt' - for folding purposes
+ *         that is all we need.
+ */
+#define RAKU_HEADFOLD_SHIFT	4
+#define RAKU_HEADFOLD_MASK	0xF0
+void SCI_METHOD LexerRaku::Fold(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, IDocument *pAccess) {
+
+	// init LexAccessor / return if fold option is off
+	if (!options.fold) return;
+	LexAccessor styler(pAccess);
+
+	// init char and line positions
+	const Sci_PositionU endPos = startPos + length;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+
+	// Backtrack to last SCE_RAKU_DEFAULT line
+	if (startPos > 0 && lineCurrent > 0) {
+		while (lineCurrent > 0 && styler.StyleAt(startPos) != SCE_RAKU_DEFAULT) {
+			lineCurrent--;
+			startPos = styler.LineStart(lineCurrent);
+		}
+		lineCurrent = styler.GetLine(startPos);
+	}
+	Sci_PositionU lineStart = startPos;
+	Sci_PositionU lineStartNext = styler.LineStart(lineCurrent + 1);
+
+	// init line folding level
+	int levelPrev = SC_FOLDLEVELBASE;
+	if (lineCurrent > 0)
+		levelPrev = styler.LevelAt(lineCurrent - 1) >> 16;
+	int levelCurrent = levelPrev;
+
+	// init char and style variables
+	char chNext = styler[startPos];
+	int stylePrev = styler.StyleAt(startPos - 1);
+	int styleNext = styler.StyleAt(startPos);
+	int styleNextStartLine = styler.StyleAt(lineStartNext);
+	int visibleChars = 0;
+	bool wasCommentMulti = false;
+
+	// main loop
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+
+		// next char, style and flags
+		const char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		const int style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		const bool atEOL = i == (lineStartNext - 1);
+		const bool atLineStart = i == lineStart;
+
+		// --- Comments / Multi-line / POD ------------------------------------
+		if (options.foldComment) {
+
+			// Multi-line
+			if (options.foldCommentMultiline) {
+				if (style == SCE_RAKU_COMMENTLINE && atLineStart && ch == '#' && chNext == '`'
+						&& styleNextStartLine == SCE_RAKU_COMMENTEMBED) {
+					levelCurrent++;
+					wasCommentMulti = true; // don't confuse line comments
+				} else if (style == SCE_RAKU_COMMENTEMBED && atLineStart
+						&& styleNextStartLine != SCE_RAKU_COMMENTEMBED) {
+					levelCurrent--;
+				}
+			}
+
+			// Line comments
+			if (!wasCommentMulti && atEOL && stylePrev == SCE_RAKU_COMMENTLINE
+					&& IsCommentLine(lineCurrent, styler)) {
+				if (!IsCommentLine(lineCurrent - 1, styler)
+						&& IsCommentLine(lineCurrent + 1, styler))
+					levelCurrent++;
+				else if (IsCommentLine(lineCurrent - 1, styler)
+						&& !IsCommentLine(lineCurrent + 1, styler))
+					levelCurrent--;
+			}
+
+			// POD
+			if (options.foldCommentPOD && atLineStart && style == SCE_RAKU_POD) {
+				if (styler.Match(i, "=begin"))
+					levelCurrent++;
+				else if (styler.Match(i, "=end"))
+					levelCurrent--;
+			}
+		}
+
+		// --- Code block -----------------------------------------------------
+		if (style == SCE_RAKU_OPERATOR) {
+			if (ch == '{') {
+				if (levelCurrent < levelPrev) levelPrev--;
+				levelCurrent++;
+			} else if (ch == '}') {
+				levelCurrent--;
+			}
+		}
+
+		// --- at end of line / range / apply fold ----------------------------
+		if (atEOL) {
+			int level = levelPrev;
+
+			// set level flags
+			level |= levelCurrent << 16;
+			if (visibleChars == 0 && options.foldCompact)
+				level |= SC_FOLDLEVELWHITEFLAG;
+			if ((levelCurrent > levelPrev) && (visibleChars > 0))
+				level |= SC_FOLDLEVELHEADERFLAG;
+			if (level != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, level);
+			}
+			lineCurrent++;
+			lineStart = lineStartNext;
+			lineStartNext = styler.LineStart(lineCurrent + 1);
+			styleNextStartLine = styler.StyleAt(lineStartNext);
+			levelPrev = levelCurrent;
+			visibleChars = 0;
+			wasCommentMulti = false;
+		}
+
+		// increment visibleChars / set previous char
+		if (!isspacechar(ch))
+			visibleChars++;
+		stylePrev = style;
+	}
+
+	// Done: set real level of the next line
+	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
+	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
+}
+
+/*----------------------------------------------------------------------------*
+ * --- Scintilla: LexerModule ---
+ *----------------------------------------------------------------------------*/
+
+LexerModule lmRaku(SCLEX_RAKU, LexerRaku::LexerFactoryRaku, "raku", rakuWordLists);
diff --git a/Pythonwin/Scintilla/src/LexRebol.cxx b/Pythonwin/Scintilla/lexers/LexRebol.cxx
similarity index 94%
rename from Pythonwin/Scintilla/src/LexRebol.cxx
rename to Pythonwin/Scintilla/lexers/LexRebol.cxx
index 7139b8dbd..d4973c0c8 100644
--- a/Pythonwin/Scintilla/src/LexRebol.cxx
+++ b/Pythonwin/Scintilla/lexers/LexRebol.cxx
@@ -13,22 +13,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
 #include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static inline bool IsAWordChar(const int ch) {
 	return (isalnum(ch) || ch == '?' || ch == '!' || ch == '.' || ch == '\'' || ch == '+' || ch == '-' || ch == '*' || ch == '&' || ch == '|' || ch == '=' || ch == '_' || ch == '~');
@@ -65,7 +66,7 @@ static inline bool IsBinaryStart(const int ch, const int ch2, const int ch3, con
 }
 
 
-static void ColouriseRebolDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[], Accessor &styler) {
+static void ColouriseRebolDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[], Accessor &styler) {
 
 	WordList &keywords = *keywordlists[0];
 	WordList &keywords2 = *keywordlists[1];
@@ -76,7 +77,7 @@ static void ColouriseRebolDoc(unsigned int startPos, int length, int initStyle,
 	WordList &keywords7 = *keywordlists[6];
 	WordList &keywords8 = *keywordlists[7];
 
-	int currentLine = styler.GetLine(startPos);
+	Sci_Position currentLine = styler.GetLine(startPos);
 	// Initialize the braced string {.. { ... } ..} nesting level, if we are inside such a string.
 	int stringLevel = 0;
 	if (initStyle == SCE_REBOL_BRACEDSTRING || initStyle == SCE_REBOL_COMMENTBLOCK) {
@@ -270,16 +271,16 @@ static void ColouriseRebolDoc(unsigned int startPos, int length, int initStyle,
 }
 
 
-static void FoldRebolDoc(unsigned int startPos, int length, int /* initStyle */, WordList *[],
+static void FoldRebolDoc(Sci_PositionU startPos, Sci_Position length, int /* initStyle */, WordList *[],
                             Accessor &styler) {
-	unsigned int lengthDoc = startPos + length;
+	Sci_PositionU lengthDoc = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
-	for (unsigned int i = startPos; i < lengthDoc; i++) {
+	for (Sci_PositionU i = startPos; i < lengthDoc; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int style = styleNext;
diff --git a/Pythonwin/Scintilla/lexers/LexRegistry.cxx b/Pythonwin/Scintilla/lexers/LexRegistry.cxx
new file mode 100644
index 000000000..acdaccebe
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexRegistry.cxx
@@ -0,0 +1,419 @@
+// Scintilla source code edit control
+/**
+ * @file LexRegistry.cxx
+ * @date July 26 2014
+ * @brief Lexer for Windows registration files(.reg)
+ * @author nkmathew
+ *
+ * The License.txt file describes the conditions under which this software may be
+ * distributed.
+ *
+ */
+
+#include <cstdlib>
+#include <cassert>
+#include <cctype>
+#include <cstdio>
+#include <string>
+#include <vector>
+#include <map>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+static const char *const RegistryWordListDesc[] = {
+	0
+};
+
+struct OptionsRegistry {
+	bool foldCompact;
+	bool fold;
+	OptionsRegistry() {
+		foldCompact = false;
+		fold = false;
+	}
+};
+
+struct OptionSetRegistry : public OptionSet<OptionsRegistry> {
+	OptionSetRegistry() {
+		DefineProperty("fold.compact", &OptionsRegistry::foldCompact);
+		DefineProperty("fold", &OptionsRegistry::fold);
+		DefineWordListSets(RegistryWordListDesc);
+	}
+};
+
+class LexerRegistry : public DefaultLexer {
+	OptionsRegistry options;
+	OptionSetRegistry optSetRegistry;
+
+	static bool IsStringState(int state) {
+		return (state == SCE_REG_VALUENAME || state == SCE_REG_STRING);
+	}
+
+	static bool IsKeyPathState(int state) {
+		return (state == SCE_REG_ADDEDKEY || state == SCE_REG_DELETEDKEY);
+	}
+
+	static bool AtValueType(LexAccessor &styler, Sci_Position start) {
+		Sci_Position i = 0;
+		while (i < 10) {
+			i++;
+			char curr = styler.SafeGetCharAt(start+i, '\0');
+			if (curr == ':') {
+				return true;
+			} else if (!curr) {
+				return false;
+			}
+		}
+		return false;
+	}
+
+	static bool IsNextNonWhitespace(LexAccessor &styler, Sci_Position start, char ch) {
+		Sci_Position i = 0;
+		while (i < 100) {
+			i++;
+			char curr = styler.SafeGetCharAt(start+i, '\0');
+			char next = styler.SafeGetCharAt(start+i+1, '\0');
+			bool atEOL = (curr == '\r' && next != '\n') || (curr == '\n');
+			if (curr == ch) {
+				return true;
+			} else if (!isspacechar(curr) || atEOL) {
+				return false;
+			}
+		}
+		return false;
+	}
+
+	// Looks for the equal sign at the end of the string
+	static bool AtValueName(LexAccessor &styler, Sci_Position start) {
+		bool atEOL = false;
+		Sci_Position i = 0;
+		bool escaped = false;
+		while (!atEOL) {
+			i++;
+			char curr = styler.SafeGetCharAt(start+i, '\0');
+			char next = styler.SafeGetCharAt(start+i+1, '\0');
+			atEOL = (curr == '\r' && next != '\n') || (curr == '\n');
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			escaped = curr == '\\';
+			if (curr == '"') {
+				return IsNextNonWhitespace(styler, start+i, '=');
+			} else if (!curr) {
+				return false;
+			}
+		}
+		return false;
+	}
+
+	static bool AtKeyPathEnd(LexAccessor &styler, Sci_Position start) {
+		bool atEOL = false;
+		Sci_Position i = 0;
+		while (!atEOL) {
+			i++;
+			char curr = styler.SafeGetCharAt(start+i, '\0');
+			char next = styler.SafeGetCharAt(start+i+1, '\0');
+			atEOL = (curr == '\r' && next != '\n') || (curr == '\n');
+			if (curr == ']' || !curr) {
+				// There's still at least one or more square brackets ahead
+				return false;
+			}
+		}
+		return true;
+	}
+
+	static bool AtGUID(LexAccessor &styler, Sci_Position start) {
+		int count = 8;
+		int portion = 0;
+		int offset = 1;
+		char digit = '\0';
+		while (portion < 5) {
+			int i = 0;
+			while (i < count) {
+				digit = styler.SafeGetCharAt(start+offset);
+				if (!(isxdigit(digit) || digit == '-')) {
+					return false;
+				}
+				offset++;
+				i++;
+			}
+			portion++;
+			count = (portion == 4) ? 13 : 5;
+		}
+		digit = styler.SafeGetCharAt(start+offset);
+		if (digit == '}') {
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+public:
+	LexerRegistry() : DefaultLexer("registry", SCLEX_REGISTRY) {}
+	virtual ~LexerRegistry() {}
+	int SCI_METHOD Version() const override {
+		return lvRelease5;
+	}
+	void SCI_METHOD Release() override {
+		delete this;
+	}
+	const char *SCI_METHOD PropertyNames() override {
+		return optSetRegistry.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return optSetRegistry.PropertyType(name);
+	}
+	const char *SCI_METHOD DescribeProperty(const char *name) override {
+		return optSetRegistry.DescribeProperty(name);
+	}
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override {
+		if (optSetRegistry.PropertySet(&options, key, val)) {
+			return 0;
+		}
+		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 ILexer5 *LexerFactoryRegistry() {
+		return new LexerRegistry;
+	}
+	const char *SCI_METHOD DescribeWordListSets() override {
+		return optSetRegistry.DescribeWordListSets();
+	}
+	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 LexerRegistry::Lex(Sci_PositionU startPos,
+								   Sci_Position length,
+								   int initStyle,
+								   IDocument *pAccess) {
+	int beforeGUID = SCE_REG_DEFAULT;
+	int beforeEscape = SCE_REG_DEFAULT;
+	CharacterSet setOperators = CharacterSet(CharacterSet::setNone, "-,.=:\\@()");
+	LexAccessor styler(pAccess);
+	StyleContext context(startPos, length, initStyle, styler);
+	bool highlight = true;
+	bool afterEqualSign = false;
+	while (context.More()) {
+		if (context.atLineStart) {
+			Sci_Position currPos = static_cast<Sci_Position>(context.currentPos);
+			bool continued = styler[currPos-3] == '\\';
+			highlight = continued ? true : false;
+		}
+		switch (context.state) {
+			case SCE_REG_COMMENT:
+				if (context.atLineEnd) {
+					context.SetState(SCE_REG_DEFAULT);
+				}
+				break;
+			case SCE_REG_VALUENAME:
+			case SCE_REG_STRING: {
+					Sci_Position currPos = static_cast<Sci_Position>(context.currentPos);
+					if (context.ch == '"') {
+						context.ForwardSetState(SCE_REG_DEFAULT);
+					} else if (context.ch == '\\') {
+						beforeEscape = context.state;
+						context.SetState(SCE_REG_ESCAPED);
+						context.Forward();
+					} else if (context.ch == '{') {
+						if (AtGUID(styler, currPos)) {
+							beforeGUID = context.state;
+							context.SetState(SCE_REG_STRING_GUID);
+						}
+					}
+					if (context.state == SCE_REG_STRING &&
+						context.ch == '%' &&
+						(isdigit(context.chNext) || context.chNext == '*')) {
+						context.SetState(SCE_REG_PARAMETER);
+					}
+				}
+				break;
+			case SCE_REG_PARAMETER:
+				context.ForwardSetState(SCE_REG_STRING);
+				if (context.ch == '"') {
+					context.ForwardSetState(SCE_REG_DEFAULT);
+				}
+				break;
+			case SCE_REG_VALUETYPE:
+				if (context.ch == ':') {
+					context.SetState(SCE_REG_DEFAULT);
+					afterEqualSign = false;
+				}
+				break;
+			case SCE_REG_HEXDIGIT:
+			case SCE_REG_OPERATOR:
+				context.SetState(SCE_REG_DEFAULT);
+				break;
+			case SCE_REG_DELETEDKEY:
+			case SCE_REG_ADDEDKEY: {
+					Sci_Position currPos = static_cast<Sci_Position>(context.currentPos);
+					if (context.ch == ']' && AtKeyPathEnd(styler, currPos)) {
+						context.ForwardSetState(SCE_REG_DEFAULT);
+					} else if (context.ch == '{') {
+						if (AtGUID(styler, currPos)) {
+							beforeGUID = context.state;
+							context.SetState(SCE_REG_KEYPATH_GUID);
+						}
+					}
+				}
+				break;
+			case SCE_REG_ESCAPED:
+				if (context.ch == '"') {
+					context.SetState(beforeEscape);
+					context.ForwardSetState(SCE_REG_DEFAULT);
+				} else if (context.ch == '\\') {
+					context.Forward();
+				} else {
+					context.SetState(beforeEscape);
+					beforeEscape = SCE_REG_DEFAULT;
+				}
+				break;
+			case SCE_REG_STRING_GUID:
+			case SCE_REG_KEYPATH_GUID: {
+					if (context.ch == '}') {
+						context.ForwardSetState(beforeGUID);
+						beforeGUID = SCE_REG_DEFAULT;
+					}
+					Sci_Position currPos = static_cast<Sci_Position>(context.currentPos);
+					if (context.ch == '"' && IsStringState(context.state)) {
+						context.ForwardSetState(SCE_REG_DEFAULT);
+					} else if (context.ch == ']' &&
+							   AtKeyPathEnd(styler, currPos) &&
+							   IsKeyPathState(context.state)) {
+						context.ForwardSetState(SCE_REG_DEFAULT);
+					} else if (context.ch == '\\' && IsStringState(context.state)) {
+						beforeEscape = context.state;
+						context.SetState(SCE_REG_ESCAPED);
+						context.Forward();
+					}
+				}
+				break;
+		}
+		// Determine if a new state should be entered.
+		if (context.state == SCE_REG_DEFAULT) {
+			Sci_Position currPos = static_cast<Sci_Position>(context.currentPos);
+			if (context.ch == ';') {
+				context.SetState(SCE_REG_COMMENT);
+			} else if (context.ch == '"') {
+				if (AtValueName(styler, currPos)) {
+					context.SetState(SCE_REG_VALUENAME);
+				} else {
+					context.SetState(SCE_REG_STRING);
+				}
+			} else if (context.ch == '[') {
+				if (IsNextNonWhitespace(styler, currPos, '-')) {
+					context.SetState(SCE_REG_DELETEDKEY);
+				} else {
+					context.SetState(SCE_REG_ADDEDKEY);
+				}
+			} else if (context.ch == '=') {
+				afterEqualSign = true;
+				highlight = true;
+			} else if (afterEqualSign) {
+				bool wordStart = isalpha(context.ch) && !isalpha(context.chPrev);
+				if (wordStart && AtValueType(styler, currPos)) {
+					context.SetState(SCE_REG_VALUETYPE);
+				}
+			} else if (isxdigit(context.ch) && highlight) {
+				context.SetState(SCE_REG_HEXDIGIT);
+			}
+			highlight = (context.ch == '@') ? true : highlight;
+			if (setOperators.Contains(context.ch) && highlight) {
+				context.SetState(SCE_REG_OPERATOR);
+			}
+		}
+		context.Forward();
+	}
+	context.Complete();
+}
+
+// Folding similar to that of FoldPropsDoc in LexOthers
+void SCI_METHOD LexerRegistry::Fold(Sci_PositionU startPos,
+									Sci_Position length,
+									int,
+									IDocument *pAccess) {
+	if (!options.fold) {
+		return;
+	}
+	LexAccessor styler(pAccess);
+	Sci_Position currLine = styler.GetLine(startPos);
+	int visibleChars = 0;
+	Sci_PositionU endPos = startPos + length;
+	bool atKeyPath = false;
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		atKeyPath = IsKeyPathState(styler.StyleAt(i)) ? true : atKeyPath;
+		char curr = styler.SafeGetCharAt(i);
+		char next = styler.SafeGetCharAt(i+1);
+		bool atEOL = (curr == '\r' && next != '\n') || (curr == '\n');
+		if (atEOL || i == (endPos-1)) {
+			int level = SC_FOLDLEVELBASE;
+			if (currLine > 0) {
+				int prevLevel = styler.LevelAt(currLine-1);
+				if (prevLevel & SC_FOLDLEVELHEADERFLAG) {
+					level += 1;
+				} else {
+					level = prevLevel;
+				}
+			}
+			if (!visibleChars && options.foldCompact) {
+				level |= SC_FOLDLEVELWHITEFLAG;
+			} else if (atKeyPath) {
+				level = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;
+			}
+			if (level != styler.LevelAt(currLine)) {
+				styler.SetLevel(currLine, level);
+			}
+			currLine++;
+			visibleChars = 0;
+			atKeyPath = false;
+		}
+		if (!isspacechar(curr)) {
+			visibleChars++;
+		}
+	}
+
+	// Make the folding reach the last line in the file
+	int level = SC_FOLDLEVELBASE;
+	if (currLine > 0) {
+		int prevLevel = styler.LevelAt(currLine-1);
+		if (prevLevel & SC_FOLDLEVELHEADERFLAG) {
+			level += 1;
+		} else {
+			level = prevLevel;
+		}
+	}
+	styler.SetLevel(currLine, level);
+}
+
+LexerModule lmRegistry(SCLEX_REGISTRY,
+					   LexerRegistry::LexerFactoryRegistry,
+					   "registry",
+					   RegistryWordListDesc);
+
diff --git a/Pythonwin/Scintilla/src/LexRuby.cxx b/Pythonwin/Scintilla/lexers/LexRuby.cxx
similarity index 64%
rename from Pythonwin/Scintilla/src/LexRuby.cxx
rename to Pythonwin/Scintilla/lexers/LexRuby.cxx
index 7cb0b95c1..6f7c34404 100644
--- a/Pythonwin/Scintilla/src/LexRuby.cxx
+++ b/Pythonwin/Scintilla/lexers/LexRuby.cxx
@@ -7,25 +7,27 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
 
-#ifdef SCI_NAMESPACE
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
 using namespace Scintilla;
-#endif
 
 //XXX Identical to Perl, put in common area
 static inline bool isEOLChar(char ch) {
-	return (ch == '\r') || (ch == '\n');
+    return (ch == '\r') || (ch == '\n');
 }
 
 #define isSafeASCII(ch) ((unsigned int)(ch) <= 127)
@@ -56,7 +58,7 @@ static inline bool isSafeWordcharOrHigh(char ch) {
 }
 
 static bool inline iswhitespace(char ch) {
-	return ch == ' ' || ch == '\t';
+    return ch == ' ' || ch == '\t';
 }
 
 #define MAX_KEYWORD_LENGTH 200
@@ -64,26 +66,26 @@ static bool inline iswhitespace(char ch) {
 #define STYLE_MASK 63
 #define actual_style(style) (style & STYLE_MASK)
 
-static bool followsDot(unsigned int pos, Accessor &styler) {
+static bool followsDot(Sci_PositionU pos, Accessor &styler) {
     styler.Flush();
     for (; pos >= 1; --pos) {
         int style = actual_style(styler.StyleAt(pos));
         char ch;
         switch (style) {
-            case SCE_RB_DEFAULT:
-                ch = styler[pos];
-                if (ch == ' ' || ch == '\t') {
-                    //continue
-                } else {
-                    return false;
-                }
-                break;
-                
-            case SCE_RB_OPERATOR:
-                return styler[pos] == '.';
-
-            default:
+        case SCE_RB_DEFAULT:
+            ch = styler[pos];
+            if (ch == ' ' || ch == '\t') {
+                //continue
+            } else {
                 return false;
+            }
+            break;
+
+        case SCE_RB_OPERATOR:
+            return styler[pos] == '.';
+
+        default:
+            return false;
         }
     }
     return false;
@@ -91,34 +93,34 @@ static bool followsDot(unsigned int pos, Accessor &styler) {
 
 // Forward declarations
 static bool keywordIsAmbiguous(const char *prevWord);
-static bool keywordDoStartsLoop(int pos,
+static bool keywordDoStartsLoop(Sci_Position pos,
                                 Accessor &styler);
 static bool keywordIsModifier(const char *word,
-                              int pos,
+                              Sci_Position pos,
                               Accessor &styler);
 
-static int ClassifyWordRb(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler, char *prevWord) {
-	char s[MAX_KEYWORD_LENGTH];
-    unsigned int i, j;
-	unsigned int lim = end - start + 1; // num chars to copy
-	if (lim >= MAX_KEYWORD_LENGTH) {
-		lim = MAX_KEYWORD_LENGTH - 1;
-	}
-	for (i = start, j = 0; j < lim; i++, j++) {
-		s[j] = styler[i];
-	}
+static int ClassifyWordRb(Sci_PositionU start, Sci_PositionU end, WordList &keywords, Accessor &styler, char *prevWord) {
+    char s[MAX_KEYWORD_LENGTH];
+    Sci_PositionU i, j;
+    Sci_PositionU lim = end - start + 1; // num chars to copy
+    if (lim >= MAX_KEYWORD_LENGTH) {
+        lim = MAX_KEYWORD_LENGTH - 1;
+    }
+    for (i = start, j = 0; j < lim; i++, j++) {
+        s[j] = styler[i];
+    }
     s[j] = '\0';
-	int chAttr;
-	if (0 == strcmp(prevWord, "class"))
-		chAttr = SCE_RB_CLASSNAME;
-	else if (0 == strcmp(prevWord, "module"))
-		chAttr = SCE_RB_MODULE_NAME;
-	else if (0 == strcmp(prevWord, "def"))
-		chAttr = SCE_RB_DEFNAME;
-    else if (keywords.InList(s) && !followsDot(start - 1, styler)) {
+    int chAttr;
+    if (0 == strcmp(prevWord, "class"))
+        chAttr = SCE_RB_CLASSNAME;
+    else if (0 == strcmp(prevWord, "module"))
+        chAttr = SCE_RB_MODULE_NAME;
+    else if (0 == strcmp(prevWord, "def"))
+        chAttr = SCE_RB_DEFNAME;
+    else if (keywords.InList(s) && ((start == 0) || !followsDot(start - 1, styler))) {
         if (keywordIsAmbiguous(s)
-            && keywordIsModifier(s, start, styler)) {
-            
+                && keywordIsModifier(s, start, styler)) {
+
             // Demoted keywords are colored as keywords,
             // but do not affect changes in indentation.
             //
@@ -127,44 +129,44 @@ static int ClassifyWordRb(unsigned int start, unsigned int end, WordList &keywor
             // 2. <<stmt if test>> : demoted
             // 3. <<lhs = if ...>> : normal: start a new indent level
             // 4. <<obj.if = 10>> : color as identifer, since it follows '.'
-            
+
             chAttr = SCE_RB_WORD_DEMOTED;
         } else {
             chAttr = SCE_RB_WORD;
         }
-	} else
+    } else
         chAttr = SCE_RB_IDENTIFIER;
-	styler.ColourTo(end, chAttr);
-	if (chAttr == SCE_RB_WORD) {
-		strcpy(prevWord, s);
-	} else {
-		prevWord[0] = 0;
-	}
+    styler.ColourTo(end, chAttr);
+    if (chAttr == SCE_RB_WORD) {
+        strcpy(prevWord, s);
+    } else {
+        prevWord[0] = 0;
+    }
     return chAttr;
 }
 
 
 //XXX Identical to Perl, put in common area
-static bool isMatch(Accessor &styler, int lengthDoc, int pos, const char *val) {
-	if ((pos + static_cast<int>(strlen(val))) >= lengthDoc) {
-		return false;
-	}
-	while (*val) {
-		if (*val != styler[pos++]) {
-			return false;
-		}
-		val++;
-	}
-	return true;
+static bool isMatch(Accessor &styler, Sci_Position lengthDoc, Sci_Position pos, const char *val) {
+    if ((pos + static_cast<int>(strlen(val))) >= lengthDoc) {
+        return false;
+    }
+    while (*val) {
+        if (*val != styler[pos++]) {
+            return false;
+        }
+        val++;
+    }
+    return true;
 }
 
 // Do Ruby better -- find the end of the line, work back,
 // and then check for leading white space
 
 // Precondition: the here-doc target can be indented
-static bool lookingAtHereDocDelim(Accessor	   &styler,
-                                  int 			pos,
-                                  int 			lengthDoc,
+static bool lookingAtHereDocDelim(Accessor   	&styler,
+                                  Sci_Position 	pos,
+                                  Sci_Position 	lengthDoc,
                                   const char   *HereDocDelim)
 {
     if (!isMatch(styler, lengthDoc, pos, HereDocDelim)) {
@@ -183,21 +185,21 @@ static bool lookingAtHereDocDelim(Accessor	   &styler,
 
 //XXX Identical to Perl, put in common area
 static char opposite(char ch) {
-	if (ch == '(')
-		return ')';
-	if (ch == '[')
-		return ']';
-	if (ch == '{')
-		return '}';
-	if (ch == '<')
-		return '>';
-	return ch;
+    if (ch == '(')
+        return ')';
+    if (ch == '[')
+        return ']';
+    if (ch == '{')
+        return '}';
+    if (ch == '<')
+        return '>';
+    return ch;
 }
 
 // Null transitions when we see we've reached the end
 // and need to relex the curr char.
 
-static void redo_char(int &i, char &ch, char &chNext, char &chNext2,
+static void redo_char(Sci_Position &i, char &ch, char &chNext, char &chNext2,
                       int &state) {
     i--;
     chNext2 = chNext;
@@ -205,26 +207,26 @@ static void redo_char(int &i, char &ch, char &chNext, char &chNext2,
     state = SCE_RB_DEFAULT;
 }
 
-static void advance_char(int &i, char &ch, char &chNext, char &chNext2) {
+static void advance_char(Sci_Position &i, char &ch, char &chNext, char &chNext2) {
     i++;
     ch = chNext;
     chNext = chNext2;
 }
 
 // precondition: startPos points to one after the EOL char
-static bool currLineContainsHereDelims(int& startPos,
+static bool currLineContainsHereDelims(Sci_Position &startPos,
                                        Accessor &styler) {
     if (startPos <= 1)
         return false;
 
-    int pos;
+    Sci_Position pos;
     for (pos = startPos - 1; pos > 0; pos--) {
         char ch = styler.SafeGetCharAt(pos);
         if (isEOLChar(ch)) {
             // Leave the pointers where they are -- there are no
             // here doc delims on the current line, even if
             // the EOL isn't default style
-            
+
             return false;
         } else {
             styler.Flush();
@@ -245,12 +247,12 @@ static bool currLineContainsHereDelims(int& startPos,
 // to be hoisted out of the function.
 
 class QuoteCls {
-    public:
+public:
     int  Count;
     char Up;
     char Down;
     QuoteCls() {
-        this->New();
+        New();
     }
     void New() {
         Count = 0;
@@ -262,32 +264,32 @@ class QuoteCls {
         Up    = u;
         Down  = opposite(Up);
     }
-    QuoteCls(const QuoteCls& q) {
+    QuoteCls(const QuoteCls &q) {
         // copy constructor -- use this for copying in
         Count = q.Count;
         Up    = q.Up;
         Down  = q.Down;
     }
-    QuoteCls& operator=(const QuoteCls& q) { // assignment constructor
+    QuoteCls &operator=(const QuoteCls &q) { // assignment constructor
         if (this != &q) {
             Count = q.Count;
             Up    = q.Up;
             Down  = q.Down;
         }
-		return *this;
+        return *this;
     }
-            
+
 };
 
 
 static void enterInnerExpression(int  *p_inner_string_types,
                                  int  *p_inner_expn_brace_counts,
                                  QuoteCls *p_inner_quotes,
-                                 int&  inner_string_count,
-                                 int&  state,
-                                 int&  brace_counts,
+                                 int  &inner_string_count,
+                                 int  &state,
+                                 int  &brace_counts,
                                  QuoteCls curr_quote
-                                 ) {
+                                ) {
     p_inner_string_types[inner_string_count] = state;
     state = SCE_RB_DEFAULT;
     p_inner_expn_brace_counts[inner_string_count] = brace_counts;
@@ -297,43 +299,43 @@ static void enterInnerExpression(int  *p_inner_string_types,
 }
 
 static void exitInnerExpression(int *p_inner_string_types,
-                                 int *p_inner_expn_brace_counts,
-                                 QuoteCls *p_inner_quotes,
-                                 int& inner_string_count,
-                                 int& state,
-                                 int&  brace_counts,
-                                 QuoteCls& curr_quote
-                                ) {
+                                int *p_inner_expn_brace_counts,
+                                QuoteCls *p_inner_quotes,
+                                int &inner_string_count,
+                                int &state,
+                                int  &brace_counts,
+                                QuoteCls &curr_quote
+                               ) {
     --inner_string_count;
     state = p_inner_string_types[inner_string_count];
     brace_counts = p_inner_expn_brace_counts[inner_string_count];
     curr_quote = p_inner_quotes[inner_string_count];
 }
 
-static bool isEmptyLine(int pos,
+static bool isEmptyLine(Sci_Position pos,
                         Accessor &styler) {
-	int spaceFlags = 0;
-	int lineCurrent = styler.GetLine(pos);
-	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, NULL);
+    int spaceFlags = 0;
+    Sci_Position lineCurrent = styler.GetLine(pos);
+    int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, NULL);
     return (indentCurrent & SC_FOLDLEVELWHITEFLAG) != 0;
 }
 
 static bool RE_CanFollowKeyword(const char *keyword) {
     if (!strcmp(keyword, "and")
-        || !strcmp(keyword, "begin")
-        || !strcmp(keyword, "break")
-        || !strcmp(keyword, "case")
-        || !strcmp(keyword, "do")
-        || !strcmp(keyword, "else")
-        || !strcmp(keyword, "elsif")
-        || !strcmp(keyword, "if")
-        || !strcmp(keyword, "next")
-        || !strcmp(keyword, "return")
-        || !strcmp(keyword, "when")
-        || !strcmp(keyword, "unless")
-        || !strcmp(keyword, "until")
-        || !strcmp(keyword, "not")
-        || !strcmp(keyword, "or")) {
+            || !strcmp(keyword, "begin")
+            || !strcmp(keyword, "break")
+            || !strcmp(keyword, "case")
+            || !strcmp(keyword, "do")
+            || !strcmp(keyword, "else")
+            || !strcmp(keyword, "elsif")
+            || !strcmp(keyword, "if")
+            || !strcmp(keyword, "next")
+            || !strcmp(keyword, "return")
+            || !strcmp(keyword, "when")
+            || !strcmp(keyword, "unless")
+            || !strcmp(keyword, "until")
+            || !strcmp(keyword, "not")
+            || !strcmp(keyword, "or")) {
         return true;
     }
     return false;
@@ -342,40 +344,40 @@ static bool RE_CanFollowKeyword(const char *keyword) {
 // Look at chars up to but not including endPos
 // Don't look at styles in case we're looking forward
 
-static int skipWhitespace(int startPos,
-                           int endPos,
-                           Accessor &styler) {
-    for (int i = startPos; i < endPos; i++) {
+static Sci_Position skipWhitespace(Sci_Position startPos,
+                          Sci_Position endPos,
+                          Accessor &styler) {
+    for (Sci_Position i = startPos; i < endPos; i++) {
         if (!iswhitespace(styler[i])) {
             return i;
         }
     }
     return endPos;
 }
-    
+
 // This routine looks for false positives like
 // undef foo, <<
 // There aren't too many.
 //
 // iPrev points to the start of <<
 
-static bool sureThisIsHeredoc(int iPrev,
+static bool sureThisIsHeredoc(Sci_Position iPrev,
                               Accessor &styler,
                               char *prevWord) {
-                    
+
     // Not so fast, since Ruby's so dynamic.  Check the context
     // to make sure we're OK.
     int prevStyle;
-    int lineStart = styler.GetLine(iPrev);
-    int lineStartPosn = styler.LineStart(lineStart);
+    Sci_Position lineStart = styler.GetLine(iPrev);
+    Sci_Position lineStartPosn = styler.LineStart(lineStart);
     styler.Flush();
 
     // Find the first word after some whitespace
-    int firstWordPosn = skipWhitespace(lineStartPosn, iPrev, styler);
+    Sci_Position firstWordPosn = skipWhitespace(lineStartPosn, iPrev, styler);
     if (firstWordPosn >= iPrev) {
         // Have something like {^     <<}
-		//XXX Look at the first previous non-comment non-white line
-		// to establish the context.  Not too likely though.
+        //XXX Look at the first previous non-comment non-white line
+        // to establish the context.  Not too likely though.
         return true;
     } else {
         switch (prevStyle = styler.StyleAt(firstWordPosn)) {
@@ -387,11 +389,11 @@ static bool sureThisIsHeredoc(int iPrev,
             return true;
         }
     }
-    int firstWordEndPosn = firstWordPosn;
+    Sci_Position firstWordEndPosn = firstWordPosn;
     char *dst = prevWord;
     for (;;) {
         if (firstWordEndPosn >= iPrev ||
-            styler.StyleAt(firstWordEndPosn) != prevStyle) {
+                styler.StyleAt(firstWordEndPosn) != prevStyle) {
             *dst = 0;
             break;
         }
@@ -400,8 +402,8 @@ static bool sureThisIsHeredoc(int iPrev,
     }
     //XXX Write a style-aware thing to regex scintilla buffer objects
     if (!strcmp(prevWord, "undef")
-        || !strcmp(prevWord, "def")
-        || !strcmp(prevWord, "alias")) {
+            || !strcmp(prevWord, "def")
+            || !strcmp(prevWord, "alias")) {
         // These keywords are what we were looking for
         return false;
     }
@@ -410,18 +412,18 @@ static bool sureThisIsHeredoc(int iPrev,
 
 // Routine that saves us from allocating a buffer for the here-doc target
 // targetEndPos points one past the end of the current target
-static bool haveTargetMatch(int currPos,
-                            int lengthDoc,
-                            int targetStartPos,
-                            int targetEndPos,
+static bool haveTargetMatch(Sci_Position currPos,
+                            Sci_Position lengthDoc,
+                            Sci_Position targetStartPos,
+                            Sci_Position targetEndPos,
                             Accessor &styler) {
     if (lengthDoc - currPos < targetEndPos - targetStartPos) {
         return false;
     }
-    int i, j;
+    Sci_Position i, j;
     for (i = targetStartPos, j = currPos;
-         i < targetEndPos && j < lengthDoc;
-         i++, j++) {
+            i < targetEndPos && j < lengthDoc;
+            i++, j++) {
         if (styler[i] != styler[j]) {
             return false;
         }
@@ -429,6 +431,32 @@ static bool haveTargetMatch(int currPos,
     return true;
 }
 
+// Finds the start position of the expression containing @p pos
+// @p min_pos should be a known expression start, e.g. the start of the line
+static Sci_Position findExpressionStart(Sci_Position pos,
+                                        Sci_Position min_pos,
+                                        Accessor &styler) {
+    int depth = 0;
+    for (; pos > min_pos; pos -= 1) {
+        int style = styler.StyleAt(pos - 1);
+        if (style == SCE_RB_OPERATOR) {
+            int ch = styler[pos - 1];
+            if (ch == '}' || ch == ')' || ch == ']') {
+                depth += 1;
+            } else if (ch == '{' || ch == '(' || ch == '[') {
+                if (depth == 0) {
+                    break;
+                } else {
+                    depth -= 1;
+                }
+            } else if (ch == ';' && depth == 0) {
+                break;
+            }
+        }
+    }
+    return pos;
+}
+
 // We need a check because the form
 // [identifier] <<[target]
 // is ambiguous.  The Ruby lexer/parser resolves it by
@@ -443,25 +471,31 @@ static bool haveTargetMatch(int currPos,
 
 // return true == yes, we have no heredocs
 
-static bool sureThisIsNotHeredoc(int lt2StartPos,
+static bool sureThisIsNotHeredoc(Sci_Position lt2StartPos,
                                  Accessor &styler) {
     int prevStyle;
-     // Use full document, not just part we're styling
-    int lengthDoc = styler.Length();
-    int lineStart = styler.GetLine(lt2StartPos);
-    int lineStartPosn = styler.LineStart(lineStart);
+    // Use full document, not just part we're styling
+    Sci_Position lengthDoc = styler.Length();
+    Sci_Position lineStart = styler.GetLine(lt2StartPos);
+    Sci_Position lineStartPosn = styler.LineStart(lineStart);
     styler.Flush();
     const bool definitely_not_a_here_doc = true;
     const bool looks_like_a_here_doc = false;
-    
+
+    // find the expression start rather than the line start
+    Sci_Position exprStartPosn = findExpressionStart(lt2StartPos, lineStartPosn, styler);
+
     // Find the first word after some whitespace
-    int firstWordPosn = skipWhitespace(lineStartPosn, lt2StartPos, styler);
+    Sci_Position firstWordPosn = skipWhitespace(exprStartPosn, lt2StartPos, styler);
     if (firstWordPosn >= lt2StartPos) {
         return definitely_not_a_here_doc;
     }
     prevStyle = styler.StyleAt(firstWordPosn);
     // If we have '<<' following a keyword, it's not a heredoc
-    if (prevStyle != SCE_RB_IDENTIFIER) {
+    if (prevStyle != SCE_RB_IDENTIFIER
+            && prevStyle != SCE_RB_SYMBOL
+            && prevStyle != SCE_RB_INSTANCE_VAR
+            && prevStyle != SCE_RB_CLASS_VAR) {
         return definitely_not_a_here_doc;
     }
     int newStyle = prevStyle;
@@ -491,20 +525,33 @@ static bool sureThisIsNotHeredoc(int lt2StartPos,
         } else {
             break;
         }
+        // on second and next passes, only identifiers may appear since
+        // class and instance variable are private
+        prevStyle = SCE_RB_IDENTIFIER;
     }
     // Skip next batch of white-space
     firstWordPosn = skipWhitespace(firstWordPosn, lt2StartPos, styler);
+    // possible symbol for an implicit hash argument
+    if (firstWordPosn < lt2StartPos && styler.StyleAt(firstWordPosn) == SCE_RB_SYMBOL) {
+        for (; firstWordPosn <= lt2StartPos; firstWordPosn += 1) {
+            if (styler.StyleAt(firstWordPosn) != SCE_RB_SYMBOL) {
+                break;
+            }
+        }
+        // Skip next batch of white-space
+        firstWordPosn = skipWhitespace(firstWordPosn, lt2StartPos, styler);
+    }
     if (firstWordPosn != lt2StartPos) {
         // Have [[^ws[identifier]ws[*something_else*]ws<<
         return definitely_not_a_here_doc;
     }
     // OK, now 'j' will point to the current spot moving ahead
-	int j = firstWordPosn + 1;
+    Sci_Position j = firstWordPosn + 1;
     if (styler.StyleAt(j) != SCE_RB_OPERATOR || styler[j] != '<') {
         // This shouldn't happen
         return definitely_not_a_here_doc;
     }
-    int nextLineStartPosn = styler.LineStart(lineStart + 1);
+    Sci_Position nextLineStartPosn = styler.LineStart(lineStart + 1);
     if (nextLineStartPosn >= lengthDoc) {
         return definitely_not_a_here_doc;
     }
@@ -513,9 +560,9 @@ static bool sureThisIsNotHeredoc(int lt2StartPos,
         return definitely_not_a_here_doc;
     }
     bool allow_indent;
-    int target_start, target_end;
+    Sci_Position target_start, target_end;
     // From this point on no more styling, since we're looking ahead
-    if (styler[j] == '-') {
+    if (styler[j] == '-' || styler[j] == '~') {
         allow_indent = true;
         j++;
     } else {
@@ -531,7 +578,7 @@ static bool sureThisIsNotHeredoc(int lt2StartPos,
         target_quote = styler[j];
         j += 1;
     }
-    
+
     if (isSafeAlnum(styler[j])) {
         // Init target_end because some compilers think it won't
         // be initialized by the time it's used
@@ -549,12 +596,12 @@ static bool sureThisIsNotHeredoc(int lt2StartPos,
 
             // And for now make sure that it's a newline
             // don't handle arbitrary expressions yet
-            
+
             target_end = j;
-			if (target_quote) {
-				// Now we can move to the character after the string delimiter.
-				j += 1;
-			}
+            if (target_quote) {
+                // Now we can move to the character after the string delimiter.
+                j += 1;
+            }
             j = skipWhitespace(j, lengthDoc, styler);
             if (j >= lengthDoc) {
                 return definitely_not_a_here_doc;
@@ -571,12 +618,12 @@ static bool sureThisIsNotHeredoc(int lt2StartPos,
     }
 
     // Just look at the start of each line
-    int last_line = styler.GetLine(lengthDoc - 1);
+    Sci_Position last_line = styler.GetLine(lengthDoc - 1);
     // But don't go too far
     if (last_line > lineStart + 50) {
         last_line = lineStart + 50;
     }
-    for (int line_num = lineStart + 1; line_num <= last_line; line_num++) {
+    for (Sci_Position line_num = lineStart + 1; line_num <= last_line; line_num++) {
         if (allow_indent) {
             j = skipWhitespace(styler.LineStart(line_num), lengthDoc, styler);
         } else {
@@ -592,11 +639,11 @@ static bool sureThisIsNotHeredoc(int lt2StartPos,
 }
 
 //todo: if we aren't looking at a stdio character,
-// move to the start of the first line that is not in a 
+// move to the start of the first line that is not in a
 // multi-line construct
 
-static void synchronizeDocStart(unsigned int& startPos,
-                                int &length,
+static void synchronizeDocStart(Sci_PositionU &startPos,
+                                Sci_Position &length,
                                 int &initStyle,
                                 Accessor &styler,
                                 bool skipWhiteSpace=false) {
@@ -604,16 +651,16 @@ static void synchronizeDocStart(unsigned int& startPos,
     styler.Flush();
     int style = actual_style(styler.StyleAt(startPos));
     switch (style) {
-        case SCE_RB_STDIN:
-        case SCE_RB_STDOUT:
-        case SCE_RB_STDERR:
-            // Don't do anything else with these.
-            return;
+    case SCE_RB_STDIN:
+    case SCE_RB_STDOUT:
+    case SCE_RB_STDERR:
+        // Don't do anything else with these.
+        return;
     }
-    
-    int pos = startPos;
+
+    Sci_Position pos = startPos;
     // Quick way to characterize each line
-    int lineStart;
+    Sci_Position lineStart;
     for (lineStart = styler.GetLine(pos); lineStart > 0; lineStart--) {
         // Now look at the style before the previous line's EOL
         pos = styler.LineStart(lineStart) - 1;
@@ -645,68 +692,68 @@ static void synchronizeDocStart(unsigned int& startPos,
     initStyle = SCE_RB_DEFAULT;
 }
 
-static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
-						   WordList *keywordlists[], Accessor &styler) {
+static void ColouriseRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+                           WordList *keywordlists[], Accessor &styler) {
 
-	// Lexer for Ruby often has to backtrack to start of current style to determine
-	// which characters are being used as quotes, how deeply nested is the
-	// start position and what the termination string is for here documents
-    
-	WordList &keywords = *keywordlists[0];
+    // Lexer for Ruby often has to backtrack to start of current style to determine
+    // which characters are being used as quotes, how deeply nested is the
+    // start position and what the termination string is for here documents
 
-	class HereDocCls {
-	public:
-		int State;
+    WordList &keywords = *keywordlists[0];
+
+    class HereDocCls {
+    public:
+        int State;
         // States
         // 0: '<<' encountered
-		// 1: collect the delimiter
+        // 1: collect the delimiter
         // 1b: text between the end of the delimiter and the EOL
-		// 2: here doc text (lines after the delimiter)
-		char Quote;		// the char after '<<'
-		bool Quoted;		// true if Quote in ('\'','"','`')
-		int DelimiterLength;	// strlen(Delimiter)
-		char Delimiter[256];	// the Delimiter, limit of 256: from Perl
+        // 2: here doc text (lines after the delimiter)
+        char Quote;		// the char after '<<'
+        bool Quoted;		// true if Quote in ('\'','"','`')
+        int DelimiterLength;	// strlen(Delimiter)
+        char Delimiter[256];	// the Delimiter, limit of 256: from Perl
         bool CanBeIndented;
-		HereDocCls() {
-			State = 0;
-			DelimiterLength = 0;
-			Delimiter[0] = '\0';
+        HereDocCls() {
+            State = 0;
+            DelimiterLength = 0;
+            Delimiter[0] = '\0';
             CanBeIndented = false;
-		}
-	};
-	HereDocCls HereDoc;	
+        }
+    };
+    HereDocCls HereDoc;
 
-	QuoteCls Quote;
+    QuoteCls Quote;
 
     int numDots = 0;  // For numbers --
-                      // Don't start lexing in the middle of a num
+    // Don't start lexing in the middle of a num
 
     synchronizeDocStart(startPos, length, initStyle, styler, // ref args
                         false);
 
-	bool preferRE = true;
+    bool preferRE = true;
     int state = initStyle;
-	int lengthDoc = startPos + length;
+    Sci_Position lengthDoc = startPos + length;
 
-	char prevWord[MAX_KEYWORD_LENGTH + 1]; // 1 byte for zero
-	prevWord[0] = '\0';
-	if (length == 0)
-		return;
+    char prevWord[MAX_KEYWORD_LENGTH + 1]; // 1 byte for zero
+    prevWord[0] = '\0';
+    if (length == 0)
+        return;
 
-	char chPrev = styler.SafeGetCharAt(startPos - 1);
-	char chNext = styler.SafeGetCharAt(startPos);
-	bool is_real_number = true;   // Differentiate between constants and ?-sequences.
-	// Ruby uses a different mask because bad indentation is marked by oring with 32
-	styler.StartAt(startPos, 127);
-	styler.StartSegment(startPos);
+    char chPrev = styler.SafeGetCharAt(startPos - 1);
+    char chNext = styler.SafeGetCharAt(startPos);
+    bool is_real_number = true;   // Differentiate between constants and ?-sequences.
+    styler.StartAt(startPos);
+    styler.StartSegment(startPos);
 
     static int q_states[] = {SCE_RB_STRING_Q,
                              SCE_RB_STRING_QQ,
                              SCE_RB_STRING_QR,
                              SCE_RB_STRING_QW,
                              SCE_RB_STRING_QW,
-                             SCE_RB_STRING_QX};
-    static const char* q_chars = "qQrwWx";
+                             SCE_RB_STRING_QX
+                            };
+    static const char *q_chars = "qQrwWx";
 
     // In most cases a value of 2 should be ample for the code in the
     // Ruby library, and the code the user is likely to enter.
@@ -722,7 +769,7 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
 
     // If anyone runs into this problem, I recommend raising this
     // value slightly higher to replacing the fixed array with a linked
-    // list.  Keep in mind this code will be called everytime the lexer
+    // list.  Keep in mind this code will be called every time the lexer
     // is invoked.
 
 #define INNER_STRINGS_MAX_COUNT 5
@@ -734,114 +781,114 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
     int inner_string_count = 0;
     int brace_counts = 0;   // Number of #{ ... } things within an expression
 
-    int i;
-	for (i = 0; i < INNER_STRINGS_MAX_COUNT; i++) {
+    Sci_Position i;
+    for (i = 0; i < INNER_STRINGS_MAX_COUNT; i++) {
         inner_string_types[i] = 0;
         inner_expn_brace_counts[i] = 0;
     }
-	for (i = startPos; i < lengthDoc; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-		char chNext2 = styler.SafeGetCharAt(i + 2);
+    for (i = startPos; i < lengthDoc; i++) {
+        char ch = chNext;
+        chNext = styler.SafeGetCharAt(i + 1);
+        char chNext2 = styler.SafeGetCharAt(i + 2);
 
         if (styler.IsLeadByte(ch)) {
-			chNext = chNext2;
-			chPrev = ' ';
-			i += 1;
-			continue;
-		}
-		
+            chNext = chNext2;
+            chPrev = ' ';
+            i += 1;
+            continue;
+        }
+
         // skip on DOS/Windows
         //No, don't, because some things will get tagged on,
         // so we won't recognize keywords, for example
 #if 0
-		if (ch == '\r' && chNext == '\n') {
-	    	continue;
+        if (ch == '\r' && chNext == '\n') {
+            continue;
         }
 #endif
-            
+
         if (HereDoc.State == 1 && isEOLChar(ch)) {
-			// Begin of here-doc (the line after the here-doc delimiter):
-			HereDoc.State = 2;
-			styler.ColourTo(i-1, state);
+            // Begin of here-doc (the line after the here-doc delimiter):
+            HereDoc.State = 2;
+            styler.ColourTo(i-1, state);
             // Don't check for a missing quote, just jump into
             // the here-doc state
             state = SCE_RB_HERE_Q;
         }
 
         // Regular transitions
-		if (state == SCE_RB_DEFAULT) {
+        if (state == SCE_RB_DEFAULT) {
             if (isSafeDigit(ch)) {
-            	styler.ColourTo(i - 1, state);
-				state = SCE_RB_NUMBER;
+                styler.ColourTo(i - 1, state);
+                state = SCE_RB_NUMBER;
                 is_real_number = true;
                 numDots = 0;
             } else if (isHighBitChar(ch) || iswordstart(ch)) {
-            	styler.ColourTo(i - 1, state);
-				state = SCE_RB_WORD;
-			} else if (ch == '#') {
-				styler.ColourTo(i - 1, state);
-				state = SCE_RB_COMMENTLINE;
-			} else if (ch == '=') {
-				// =begin indicates the start of a comment (doc) block
-                if (i == 0 || isEOLChar(chPrev)
-                    && chNext == 'b'
-                    && styler.SafeGetCharAt(i + 2) == 'e'
-                    && styler.SafeGetCharAt(i + 3) == 'g'
-                    && styler.SafeGetCharAt(i + 4) == 'i'
-                    && styler.SafeGetCharAt(i + 5) == 'n'
-                    && !isSafeWordcharOrHigh(styler.SafeGetCharAt(i + 6))) {
+                styler.ColourTo(i - 1, state);
+                state = SCE_RB_WORD;
+            } else if (ch == '#') {
+                styler.ColourTo(i - 1, state);
+                state = SCE_RB_COMMENTLINE;
+            } else if (ch == '=') {
+                // =begin indicates the start of a comment (doc) block
+                if ((i == 0 || isEOLChar(chPrev))
+                        && chNext == 'b'
+                        && styler.SafeGetCharAt(i + 2) == 'e'
+                        && styler.SafeGetCharAt(i + 3) == 'g'
+                        && styler.SafeGetCharAt(i + 4) == 'i'
+                        && styler.SafeGetCharAt(i + 5) == 'n'
+                        && !isSafeWordcharOrHigh(styler.SafeGetCharAt(i + 6))) {
                     styler.ColourTo(i - 1, state);
                     state = SCE_RB_POD;
-				} else {
-					styler.ColourTo(i - 1, state);
-					styler.ColourTo(i, SCE_RB_OPERATOR);
-					preferRE = true;
-				}
-			} else if (ch == '"') {
-				styler.ColourTo(i - 1, state);
-				state = SCE_RB_STRING;
-				Quote.New();
-				Quote.Open(ch);
-			} else if (ch == '\'') {
+                } else {
+                    styler.ColourTo(i - 1, state);
+                    styler.ColourTo(i, SCE_RB_OPERATOR);
+                    preferRE = true;
+                }
+            } else if (ch == '"') {
+                styler.ColourTo(i - 1, state);
+                state = SCE_RB_STRING;
+                Quote.New();
+                Quote.Open(ch);
+            } else if (ch == '\'') {
                 styler.ColourTo(i - 1, state);
                 state = SCE_RB_CHARACTER;
                 Quote.New();
                 Quote.Open(ch);
-			} else if (ch == '`') {
-				styler.ColourTo(i - 1, state);
-				state = SCE_RB_BACKTICKS;
-				Quote.New();
-				Quote.Open(ch);
-			} else if (ch == '@') {
+            } else if (ch == '`') {
+                styler.ColourTo(i - 1, state);
+                state = SCE_RB_BACKTICKS;
+                Quote.New();
+                Quote.Open(ch);
+            } else if (ch == '@') {
                 // Instance or class var
-				styler.ColourTo(i - 1, state);
+                styler.ColourTo(i - 1, state);
                 if (chNext == '@') {
                     state = SCE_RB_CLASS_VAR;
                     advance_char(i, ch, chNext, chNext2); // pass by ref
                 } else {
                     state = SCE_RB_INSTANCE_VAR;
                 }
-			} else if (ch == '$') {
+            } else if (ch == '$') {
                 // Check for a builtin global
-				styler.ColourTo(i - 1, state);
+                styler.ColourTo(i - 1, state);
                 // Recognize it bit by bit
                 state = SCE_RB_GLOBAL;
             } else if (ch == '/' && preferRE) {
                 // Ambigous operator
-				styler.ColourTo(i - 1, state);
-				state = SCE_RB_REGEX;
+                styler.ColourTo(i - 1, state);
+                state = SCE_RB_REGEX;
                 Quote.New();
                 Quote.Open(ch);
-			} else if (ch == '<' && chNext == '<' && chNext2 != '=') {
+            } else if (ch == '<' && chNext == '<' && chNext2 != '=') {
 
                 // Recognise the '<<' symbol - either a here document or a binary op
-				styler.ColourTo(i - 1, state);
+                styler.ColourTo(i - 1, state);
                 i++;
                 chNext = chNext2;
-				styler.ColourTo(i, SCE_RB_OPERATOR);
+                styler.ColourTo(i, SCE_RB_OPERATOR);
 
-                if (! (strchr("\"\'`_-", chNext2) || isSafeAlpha(chNext2))) {
+                if (!(strchr("\"\'`_-~", chNext2) || isSafeAlpha(chNext2))) {
                     // It's definitely not a here-doc,
                     // based on Ruby's lexer/parser in the
                     // heredoc_identifier routine.
@@ -865,22 +912,47 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
                 }
                 preferRE = (state != SCE_RB_HERE_DELIM);
             } else if (ch == ':') {
-				styler.ColourTo(i - 1, state);
+                styler.ColourTo(i - 1, state);
                 if (chNext == ':') {
                     // Mark "::" as an operator, not symbol start
                     styler.ColourTo(i + 1, SCE_RB_OPERATOR);
                     advance_char(i, ch, chNext, chNext2); // pass by ref
                     state = SCE_RB_DEFAULT;
-					preferRE = false;
+                    preferRE = false;
                 } else if (isSafeWordcharOrHigh(chNext)) {
-					state = SCE_RB_SYMBOL;
+                    state = SCE_RB_SYMBOL;
+                } else if ((chNext == '@' || chNext == '$') &&
+                           isSafeWordcharOrHigh(chNext2)) {
+                    // instance and global variable followed by an identifier
+                    advance_char(i, ch, chNext, chNext2);
+                    state = SCE_RB_SYMBOL;
+                } else if (((chNext == '@' && chNext2 == '@')  ||
+                            (chNext == '$' && chNext2 == '-')) &&
+                           isSafeWordcharOrHigh(styler.SafeGetCharAt(i+3))) {
+                    // class variables and special global variable "$-IDENTCHAR"
+                    state = SCE_RB_SYMBOL;
+                    // $-IDENTCHAR doesn't continue past the IDENTCHAR
+                    if (chNext == '$') {
+                        styler.ColourTo(i+3, SCE_RB_SYMBOL);
+                        state = SCE_RB_DEFAULT;
+                    }
+                    i += 3;
+                    ch = styler.SafeGetCharAt(i);
+                    chNext = styler.SafeGetCharAt(i+1);
+                } else if (chNext == '$' && strchr("_~*$?!@/\\;,.=:<>\"&`'+", chNext2)) {
+                    // single-character special global variables
+                    i += 2;
+                    ch = chNext2;
+                    chNext = styler.SafeGetCharAt(i+1);
+                    styler.ColourTo(i, SCE_RB_SYMBOL);
+                    state = SCE_RB_DEFAULT;
                 } else if (strchr("[*!~+-*/%=<>&^|", chNext)) {
                     // Do the operator analysis in-line, looking ahead
                     // Based on the table in pickaxe 2nd ed., page 339
                     bool doColoring = true;
                     switch (chNext) {
                     case '[':
-                        if (chNext2 == ']' ) {
+                        if (chNext2 == ']') {
                             char ch_tmp = styler.SafeGetCharAt(i + 3);
                             if (ch_tmp == '=') {
                                 i += 3;
@@ -946,11 +1018,11 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
                         styler.ColourTo(i, SCE_RB_SYMBOL);
                         state = SCE_RB_DEFAULT;
                     }
-				} else if (!preferRE) {
-					// Don't color symbol strings (yet)
-					// Just color the ":" and color rest as string
-					styler.ColourTo(i, SCE_RB_SYMBOL);
-					state = SCE_RB_DEFAULT;
+                } else if (!preferRE) {
+                    // Don't color symbol strings (yet)
+                    // Just color the ":" and color rest as string
+                    styler.ColourTo(i, SCE_RB_SYMBOL);
+                    state = SCE_RB_DEFAULT;
                 } else {
                     styler.ColourTo(i, SCE_RB_OPERATOR);
                     state = SCE_RB_DEFAULT;
@@ -967,12 +1039,21 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
                         Quote.Open(chNext2);
                         i += 2;
                         ch = chNext2;
-						chNext = styler.SafeGetCharAt(i + 1);
+                        chNext = styler.SafeGetCharAt(i + 1);
                         have_string = true;
                     }
                 } else if (preferRE && !isSafeWordcharOrHigh(chNext)) {
                     // Ruby doesn't allow high bit chars here,
                     // but the editor host might
+                    Quote.New();
+                    state = SCE_RB_STRING_QQ;
+                    Quote.Open(chNext);
+                    advance_char(i, ch, chNext, chNext2); // pass by ref
+                    have_string = true;
+                } else if (!isSafeWordcharOrHigh(chNext) && !iswhitespace(chNext) && !isEOLChar(chNext)) {
+                    // Ruby doesn't allow high bit chars here,
+                    // but the editor host might
+                    Quote.New();
                     state = SCE_RB_STRING_QQ;
                     Quote.Open(chNext);
                     advance_char(i, ch, chNext, chNext2); // pass by ref
@@ -994,8 +1075,8 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
                     is_real_number = false;
                 }
             } else if (isoperator(ch) || ch == '.') {
-				styler.ColourTo(i - 1, state);
-				styler.ColourTo(i, SCE_RB_OPERATOR);
+                styler.ColourTo(i - 1, state);
+                styler.ColourTo(i, SCE_RB_OPERATOR);
                 // If we're ending an expression or block,
                 // assume it ends an object, and the ambivalent
                 // constructs are binary operators
@@ -1003,7 +1084,7 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
                 // So if we don't have one of these chars,
                 // we aren't ending an object exp'n, and ops
                 // like : << / are unary operators.
-                
+
                 if (ch == '{') {
                     ++brace_counts;
                     preferRE = true;
@@ -1022,7 +1103,7 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
             } else if (isEOLChar(ch)) {
                 // Make sure it's a true line-end, with no backslash
                 if ((ch == '\r' || (ch == '\n' && chPrev != '\r'))
-                    && chPrev != '\\') {
+                        && chPrev != '\\') {
                     // Assume we've hit the end of the statement.
                     preferRE = true;
                 }
@@ -1035,16 +1116,20 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
 
                 // Default accessor treats '.' as word-chars,
                 // but we don't for now.
-                
+
                 if (ch == '='
-                    && isSafeWordcharOrHigh(chPrev)
-                    && (chNext == '('
-                        || strchr(" \t\n\r", chNext) != NULL)
-                    && (!strcmp(prevWord, "def")
-                        || followsDot(styler.GetStartSegment(), styler))) {
+                        && isSafeWordcharOrHigh(chPrev)
+                        && (chNext == '('
+                            || strchr(" \t\n\r", chNext) != NULL)
+                        && (!strcmp(prevWord, "def")
+                            || followsDot(styler.GetStartSegment(), styler))) {
                     // <name>= is a name only when being def'd -- Get it the next time
                     // This means that <name>=<name> is always lexed as
                     // <name>, (op, =), <name>
+                } else if (ch == ':'
+                           && isSafeWordcharOrHigh(chPrev)
+                           && strchr(" \t\n\r", chNext) != NULL) {
+                    state = SCE_RB_SYMBOL;
                 } else if ((ch == '?' || ch == '!')
                            && isSafeWordcharOrHigh(chPrev)
                            && !isSafeWordcharOrHigh(chNext)) {
@@ -1060,34 +1145,34 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
                     // No need to handle this state -- we'll just move to the end
                     preferRE = false;
                 } else {
-					int wordStartPos = styler.GetStartSegment();
+                    Sci_Position wordStartPos = styler.GetStartSegment();
                     int word_style = ClassifyWordRb(wordStartPos, i - 1, keywords, styler, prevWord);
                     switch (word_style) {
-                        case SCE_RB_WORD:
-                            preferRE = RE_CanFollowKeyword(prevWord);
-							break;
-                            
-                        case SCE_RB_WORD_DEMOTED:
+                    case SCE_RB_WORD:
+                        preferRE = RE_CanFollowKeyword(prevWord);
+                        break;
+
+                    case SCE_RB_WORD_DEMOTED:
+                        preferRE = true;
+                        break;
+
+                    case SCE_RB_IDENTIFIER:
+                        if (isMatch(styler, lengthDoc, wordStartPos, "print")) {
                             preferRE = true;
-							break;
-                            
-                        case SCE_RB_IDENTIFIER:
-                            if (isMatch(styler, lengthDoc, wordStartPos, "print")) {
-                                preferRE = true;
-                            } else if (isEOLChar(ch)) {
-                                preferRE = true;
-                            } else {
-                                preferRE = false;
-                            }
-							break;
-                        default:
+                        } else if (isEOLChar(ch)) {
+                            preferRE = true;
+                        } else {
                             preferRE = false;
+                        }
+                        break;
+                    default:
+                        preferRE = false;
                     }
                     if (ch == '.') {
                         // We might be redefining an operator-method
                         preferRE = false;
                     }
-                    // And if it's the first 
+                    // And if it's the first
                     redo_char(i, ch, chNext, chNext2, state); // pass by ref
                 }
             }
@@ -1124,6 +1209,10 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
                 }
             } else if (isSafeAlnumOrHigh(ch) || ch == '_') {
                 // Keep going
+            } else if (ch == '.' && chNext == '.') {
+                ++numDots;
+                styler.ColourTo(i - 1, state);
+                redo_char(i, ch, chNext, chNext2, state); // pass by ref
             } else if (ch == '.' && ++numDots == 1) {
                 // Keep going
             } else {
@@ -1132,7 +1221,7 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
                 preferRE = false;
             }
         } else if (state == SCE_RB_COMMENTLINE) {
-			if (isEOLChar(ch)) {
+            if (isEOLChar(ch)) {
                 styler.ColourTo(i - 1, state);
                 state = SCE_RB_DEFAULT;
                 // Use whatever setting we had going into the comment
@@ -1141,11 +1230,11 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
             // See the comment for SCE_RB_HERE_DELIM in LexPerl.cxx
             // Slightly different: if we find an immediate '-',
             // the target can appear indented.
-            
-			if (HereDoc.State == 0) { // '<<' encountered
-				HereDoc.State = 1;
+
+            if (HereDoc.State == 0) { // '<<' encountered
+                HereDoc.State = 1;
                 HereDoc.DelimiterLength = 0;
-                if (ch == '-') {
+                if (ch == '-' || ch == '~') {
                     HereDoc.CanBeIndented = true;
                     advance_char(i, ch, chNext, chNext2); // pass by ref
                 } else {
@@ -1157,7 +1246,7 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
                     preferRE = false;
                 } else {
                     HereDoc.Quote = ch;
-                
+
                     if (ch == '\'' || ch == '"' || ch == '`') {
                         HereDoc.Quoted = true;
                         HereDoc.Delimiter[0] = '\0';
@@ -1168,42 +1257,41 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
                         HereDoc.DelimiterLength = 1;
                     }
                 }
-			} else if (HereDoc.State == 1) { // collect the delimiter
+            } else if (HereDoc.State == 1) { // collect the delimiter
                 if (isEOLChar(ch)) {
                     // End the quote now, and go back for more
                     styler.ColourTo(i - 1, state);
                     state = SCE_RB_DEFAULT;
                     i--;
                     chNext = ch;
-                    chNext2 = chNext;
                     preferRE = false;
                 } else if (HereDoc.Quoted) {
-					if (ch == HereDoc.Quote) { // closing quote => end of delimiter
-						styler.ColourTo(i, state);
-						state = SCE_RB_DEFAULT;
+                    if (ch == HereDoc.Quote) { // closing quote => end of delimiter
+                        styler.ColourTo(i, state);
+                        state = SCE_RB_DEFAULT;
                         preferRE = false;
                     } else {
-						if (ch == '\\' && !isEOLChar(chNext)) {
+                        if (ch == '\\' && !isEOLChar(chNext)) {
                             advance_char(i, ch, chNext, chNext2);
-						}
-						HereDoc.Delimiter[HereDoc.DelimiterLength++] = ch;
-						HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0';
+                        }
+                        HereDoc.Delimiter[HereDoc.DelimiterLength++] = ch;
+                        HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0';
                     }
                 } else { // an unquoted here-doc delimiter
-					if (isSafeAlnumOrHigh(ch) || ch == '_') {
-						HereDoc.Delimiter[HereDoc.DelimiterLength++] = ch;
-						HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0';
-					} else {
-						styler.ColourTo(i - 1, state);
+                    if (isSafeAlnumOrHigh(ch) || ch == '_') {
+                        HereDoc.Delimiter[HereDoc.DelimiterLength++] = ch;
+                        HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0';
+                    } else {
+                        styler.ColourTo(i - 1, state);
                         redo_char(i, ch, chNext, chNext2, state);
                         preferRE = false;
-					}
+                    }
                 }
-				if (HereDoc.DelimiterLength >= static_cast<int>(sizeof(HereDoc.Delimiter)) - 1) {
-					styler.ColourTo(i - 1, state);
-					state = SCE_RB_ERROR;
+                if (HereDoc.DelimiterLength >= static_cast<int>(sizeof(HereDoc.Delimiter)) - 1) {
+                    styler.ColourTo(i - 1, state);
+                    state = SCE_RB_ERROR;
                     preferRE = false;
-				}
+                }
             }
         } else if (state == SCE_RB_HERE_Q) {
             // Not needed: HereDoc.State == 2
@@ -1214,7 +1302,7 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
 
             if (!HereDoc.CanBeIndented) {
                 if (isEOLChar(chPrev)
-                    && isMatch(styler, lengthDoc, i, HereDoc.Delimiter)) {
+                        && isMatch(styler, lengthDoc, i, HereDoc.Delimiter)) {
                     styler.ColourTo(i - 1, state);
                     i += HereDoc.DelimiterLength - 1;
                     chNext = styler.SafeGetCharAt(i + 1);
@@ -1240,7 +1328,16 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
         } else if (state == SCE_RB_CLASS_VAR
                    || state == SCE_RB_INSTANCE_VAR
                    || state == SCE_RB_SYMBOL) {
-            if (!isSafeWordcharOrHigh(ch)) {
+            if (state == SCE_RB_SYMBOL &&
+                    // FIDs suffices '?' and '!'
+                    (((ch == '!' || ch == '?') && chNext != '=') ||
+                     // identifier suffix '='
+                     (ch == '=' && (chNext != '~' && chNext != '>' &&
+                                    (chNext != '=' || chNext2 == '>'))))) {
+                styler.ColourTo(i, state);
+                state = SCE_RB_DEFAULT;
+                preferRE = false;
+            } else if (!isSafeWordcharOrHigh(ch)) {
                 styler.ColourTo(i - 1, state);
                 redo_char(i, ch, chNext, chNext2, state); // pass by ref
                 preferRE = false;
@@ -1264,9 +1361,9 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
         } else if (state == SCE_RB_POD) {
             // PODs end with ^=end\s, -- any whitespace can follow =end
             if (strchr(" \t\n\r", ch) != NULL
-                && i > 5
-                && isEOLChar(styler[i - 5])
-                && isMatch(styler, lengthDoc, i - 4, "=end")) {
+                    && i > 5
+                    && isEOLChar(styler[i - 5])
+                    && isMatch(styler, lengthDoc, i - 4, "=end")) {
                 styler.ColourTo(i - 1, state);
                 state = SCE_RB_DEFAULT;
                 preferRE = false;
@@ -1281,7 +1378,7 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
                     // Include the options
                     while (isSafeAlpha(chNext)) {
                         i++;
-						ch = chNext;
+                        ch = chNext;
                         chNext = styler.SafeGetCharAt(i + 1);
                     }
                     styler.ColourTo(i, state);
@@ -1291,10 +1388,10 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
             } else if (ch == Quote.Up) {
                 // Only if close quoter != open quoter
                 Quote.Count++;
-                
-            } else if (ch == '#' ) {
+
+            } else if (ch == '#') {
                 if (chNext == '{'
-                    && inner_string_count < INNER_STRINGS_MAX_COUNT) {
+                        && inner_string_count < INNER_STRINGS_MAX_COUNT) {
                     // process #{ ... }
                     styler.ColourTo(i - 1, state);
                     styler.ColourTo(i + 1, SCE_RB_OPERATOR);
@@ -1332,11 +1429,10 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
                         }
                     }
                     chNext = styler.SafeGetCharAt(i + 1);
-                    chNext2 = styler.SafeGetCharAt(i + 2);
                 }
             }
-        // Quotes of all kinds...
-        } else if (state == SCE_RB_STRING_Q || state == SCE_RB_STRING_QQ || 
+            // Quotes of all kinds...
+        } else if (state == SCE_RB_STRING_Q || state == SCE_RB_STRING_QQ ||
                    state == SCE_RB_STRING_QX || state == SCE_RB_STRING_QW ||
                    state == SCE_RB_STRING || state == SCE_RB_CHARACTER ||
                    state == SCE_RB_BACKTICKS) {
@@ -1373,7 +1469,7 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
                 advance_char(i, ch, chNext, chNext2);
             }
         }
-            
+
         if (state == SCE_RB_ERROR) {
             break;
         }
@@ -1389,14 +1485,14 @@ static void ColouriseRbDoc(unsigned int startPos, int length, int initStyle,
 }
 
 // Helper functions for folding, disambiguation keywords
-// Assert that there are no high-bit chars 
+// Assert that there are no high-bit chars
 
-static void getPrevWord(int pos,
+static void getPrevWord(Sci_Position pos,
                         char *prevWord,
                         Accessor &styler,
                         int word_state)
 {
-    int i;
+    Sci_Position i;
     styler.Flush();
     for (i = pos - 1; i > 0; i--) {
         if (actual_style(styler.StyleAt(i)) != word_state) {
@@ -1410,7 +1506,7 @@ static void getPrevWord(int pos,
     for (; i <= pos; i++) {
         *dst++ = styler[i];
     }
-	*dst = 0;
+    *dst = 0;
 }
 
 static bool keywordIsAmbiguous(const char *prevWord)
@@ -1418,10 +1514,11 @@ static bool keywordIsAmbiguous(const char *prevWord)
     // Order from most likely used to least likely
     // Lots of ways to do a loop in Ruby besides 'while/until'
     if (!strcmp(prevWord, "if")
-        || !strcmp(prevWord, "do")
-        || !strcmp(prevWord, "while")
-        || !strcmp(prevWord, "unless")
-        || !strcmp(prevWord, "until")) {
+            || !strcmp(prevWord, "do")
+            || !strcmp(prevWord, "while")
+            || !strcmp(prevWord, "unless")
+            || !strcmp(prevWord, "until")
+            || !strcmp(prevWord, "for")) {
         return true;
     } else {
         return false;
@@ -1430,110 +1527,146 @@ static bool keywordIsAmbiguous(const char *prevWord)
 
 // Demote keywords in the following conditions:
 // if, while, unless, until modify a statement
-// do after a while or until, as a noise word (like then after if) 
+// do after a while or until, as a noise word (like then after if)
 
 static bool keywordIsModifier(const char *word,
-                              int pos,
+                              Sci_Position pos,
                               Accessor &styler)
 {
     if (word[0] == 'd' && word[1] == 'o' && !word[2]) {
         return keywordDoStartsLoop(pos, styler);
     }
-    char ch;
+    char ch, chPrev, chPrev2;
     int style = SCE_RB_DEFAULT;
-	int lineStart = styler.GetLine(pos);
-    int lineStartPosn = styler.LineStart(lineStart);
+    Sci_Position lineStart = styler.GetLine(pos);
+    Sci_Position lineStartPosn = styler.LineStart(lineStart);
+    // We want to step backwards until we don't care about the current
+    // position. But first move lineStartPosn back behind any
+    // continuations immediately above word.
+    while (lineStartPosn > 0) {
+        ch = styler[lineStartPosn-1];
+        if (ch == '\n' || ch == '\r') {
+            chPrev  = styler.SafeGetCharAt(lineStartPosn-2);
+            chPrev2 = styler.SafeGetCharAt(lineStartPosn-3);
+            lineStart = styler.GetLine(lineStartPosn-1);
+            // If we find a continuation line, include it in our analysis.
+            if (chPrev == '\\') {
+                lineStartPosn = styler.LineStart(lineStart);
+            } else if (ch == '\n' && chPrev == '\r' && chPrev2 == '\\') {
+                lineStartPosn = styler.LineStart(lineStart);
+            } else {
+                break;
+            }
+        } else {
+            break;
+        }
+    }
+
     styler.Flush();
     while (--pos >= lineStartPosn) {
         style = actual_style(styler.StyleAt(pos));
-		if (style == SCE_RB_DEFAULT) {
-			if (iswhitespace(ch = styler[pos])) {
-				//continue
-			} else if (ch == '\r' || ch == '\n') {
-				// Scintilla's LineStart() and GetLine() routines aren't
-				// platform-independent, so if we have text prepared with
-				// a different system we can't rely on it.
-				return false;
-			}
-		} else {
+        if (style == SCE_RB_DEFAULT) {
+            if (iswhitespace(ch = styler[pos])) {
+                //continue
+            } else if (ch == '\r' || ch == '\n') {
+                // Scintilla's LineStart() and GetLine() routines aren't
+                // platform-independent, so if we have text prepared with
+                // a different system we can't rely on it.
+
+                // Also, lineStartPosn may have been moved to more than one
+                // line above word's line while pushing past continuations.
+                chPrev = styler.SafeGetCharAt(pos - 1);
+                chPrev2 = styler.SafeGetCharAt(pos - 2);
+                if (chPrev == '\\') {
+                    pos-=1;  // gloss over the "\\"
+                    //continue
+                } else if (ch == '\n' && chPrev == '\r' && chPrev2 == '\\') {
+                    pos-=2;  // gloss over the "\\\r"
+                    //continue
+                } else {
+                    return false;
+                }
+            }
+        } else {
             break;
-		}
+        }
     }
     if (pos < lineStartPosn) {
-        return false; //XXX not quite right if the prev line is a continuation
+        return false;
     }
     // First things where the action is unambiguous
     switch (style) {
-        case SCE_RB_DEFAULT:
-        case SCE_RB_COMMENTLINE:
-        case SCE_RB_POD:
-        case SCE_RB_CLASSNAME:
-        case SCE_RB_DEFNAME:
-        case SCE_RB_MODULE_NAME:
-            return false;
-        case SCE_RB_OPERATOR:
-            break;
-        case SCE_RB_WORD:
-            // Watch out for uses of 'else if'
-            //XXX: Make a list of other keywords where 'if' isn't a modifier
-            //     and can appear legitimately
-            // Formulate this to avoid warnings from most compilers
-            if (strcmp(word, "if") == 0) {
-                char prevWord[MAX_KEYWORD_LENGTH + 1];
-                getPrevWord(pos, prevWord, styler, SCE_RB_WORD);
-                return strcmp(prevWord, "else") != 0;
-            }
-            return true;
-        default:
-            return true;
+    case SCE_RB_DEFAULT:
+    case SCE_RB_COMMENTLINE:
+    case SCE_RB_POD:
+    case SCE_RB_CLASSNAME:
+    case SCE_RB_DEFNAME:
+    case SCE_RB_MODULE_NAME:
+        return false;
+    case SCE_RB_OPERATOR:
+        break;
+    case SCE_RB_WORD:
+        // Watch out for uses of 'else if'
+        //XXX: Make a list of other keywords where 'if' isn't a modifier
+        //     and can appear legitimately
+        // Formulate this to avoid warnings from most compilers
+        if (strcmp(word, "if") == 0) {
+            char prevWord[MAX_KEYWORD_LENGTH + 1];
+            getPrevWord(pos, prevWord, styler, SCE_RB_WORD);
+            return strcmp(prevWord, "else") != 0;
+        }
+        return true;
+    default:
+        return true;
     }
     // Assume that if the keyword follows an operator,
     // usually it's a block assignment, like
     // a << if x then y else z
-    
+
     ch = styler[pos];
     switch (ch) {
-        case ')':
-        case ']':
-        case '}':
-            return true;
-        default:
-            return false;
+    case ')':
+    case ']':
+    case '}':
+        return true;
+    default:
+        return false;
     }
 }
 
 #define WHILE_BACKWARDS "elihw"
 #define UNTIL_BACKWARDS "litnu"
+#define FOR_BACKWARDS "rof"
 
 // Nothing fancy -- look to see if we follow a while/until somewhere
 // on the current line
 
-static bool keywordDoStartsLoop(int pos,
+static bool keywordDoStartsLoop(Sci_Position pos,
                                 Accessor &styler)
 {
     char ch;
     int style;
-	int lineStart = styler.GetLine(pos);
-    int lineStartPosn = styler.LineStart(lineStart);
+    Sci_Position lineStart = styler.GetLine(pos);
+    Sci_Position lineStartPosn = styler.LineStart(lineStart);
     styler.Flush();
     while (--pos >= lineStartPosn) {
         style = actual_style(styler.StyleAt(pos));
-		if (style == SCE_RB_DEFAULT) {
-			if ((ch = styler[pos]) == '\r' || ch == '\n') {
-				// Scintilla's LineStart() and GetLine() routines aren't
-				// platform-independent, so if we have text prepared with
-				// a different system we can't rely on it.
-				return false;
-			}
-		} else if (style == SCE_RB_WORD) {
+        if (style == SCE_RB_DEFAULT) {
+            if ((ch = styler[pos]) == '\r' || ch == '\n') {
+                // Scintilla's LineStart() and GetLine() routines aren't
+                // platform-independent, so if we have text prepared with
+                // a different system we can't rely on it.
+                return false;
+            }
+        } else if (style == SCE_RB_WORD) {
             // Check for while or until, but write the word in backwards
             char prevWord[MAX_KEYWORD_LENGTH + 1]; // 1 byte for zero
             char *dst = prevWord;
             int wordLen = 0;
-            int start_word;
+            Sci_Position start_word;
             for (start_word = pos;
-                 start_word >= lineStartPosn && actual_style(styler.StyleAt(start_word)) == SCE_RB_WORD;
-                 start_word--) {
+                    start_word >= lineStartPosn && actual_style(styler.StyleAt(start_word)) == SCE_RB_WORD;
+                    start_word--) {
                 if (++wordLen < MAX_KEYWORD_LENGTH) {
                     *dst++ = styler[start_word];
                 }
@@ -1541,7 +1674,8 @@ static bool keywordDoStartsLoop(int pos,
             *dst = 0;
             // Did we see our keyword?
             if (!strcmp(prevWord, WHILE_BACKWARDS)
-                || !strcmp(prevWord, UNTIL_BACKWARDS)) {
+                    || !strcmp(prevWord, UNTIL_BACKWARDS)
+                    || !strcmp(prevWord, FOR_BACKWARDS)) {
                 return true;
             }
             // We can move pos to the beginning of the keyword, and then
@@ -1559,27 +1693,40 @@ static bool keywordDoStartsLoop(int pos,
     return false;
 }
 
+static bool IsCommentLine(Sci_Position line, Accessor &styler) {
+    Sci_Position pos = styler.LineStart(line);
+    Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+    for (Sci_Position i = pos; i < eol_pos; i++) {
+        char ch = styler[i];
+        if (ch == '#')
+            return true;
+        else if (ch != ' ' && ch != '\t')
+            return false;
+    }
+    return false;
+}
+
 /*
  *  Folding Ruby
- * 
+ *
  *  The language is quite complex to analyze without a full parse.
  *  For example, this line shouldn't affect fold level:
- * 
+ *
  *   print "hello" if feeling_friendly?
- * 
+ *
  *  Neither should this:
- * 
+ *
  *   print "hello" \
  *      if feeling_friendly?
- * 
- * 
+ *
+ *
  *  But this should:
- * 
+ *
  *   if feeling_friendly?  #++
  *     print "hello" \
  *     print "goodbye"
  *   end                   #--
- * 
+ *
  *  So we cheat, by actually looking at the existing indentation
  *  levels for each line, and just echoing it back.  Like Python.
  *  Then if we get better at it, we'll take braces into consideration,
@@ -1587,72 +1734,83 @@ static bool keywordDoStartsLoop(int pos,
 
  *  How the keywords should work:
  *  No effect:
- *  __FILE__ __LINE__ BEGIN END alias and 
+ *  __FILE__ __LINE__ BEGIN END alias and
  *  defined? false in nil not or self super then
  *  true undef
 
  *  Always increment:
  *  begin  class def do for module when {
- * 
+ *
  *  Always decrement:
  *  end }
- * 
+ *
  *  Increment if these start a statement
  *  if unless until while -- do nothing if they're modifiers
 
  *  These end a block if there's no modifier, but don't bother
  *  break next redo retry return yield
- * 
+ *
  *  These temporarily de-indent, but re-indent
  *  case else elsif ensure rescue
- * 
+ *
  *  This means that the folder reflects indentation rather
  *  than setting it.  The language-service updates indentation
  *  when users type return and finishes entering de-denters.
- * 
+ *
  *  Later offer to fold POD, here-docs, strings, and blocks of comments
  */
 
-static void FoldRbDoc(unsigned int startPos, int length, int initStyle,
+static void FoldRbDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                       WordList *[], Accessor &styler) {
-	const bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
-    
+    const bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+    bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+
     synchronizeDocStart(startPos, length, initStyle, styler, // ref args
                         false);
-	unsigned int endPos = startPos + length;
-	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
-	int levelPrev = startPos == 0 ? 0 : (styler.LevelAt(lineCurrent)
+    Sci_PositionU endPos = startPos + length;
+    int visibleChars = 0;
+    Sci_Position lineCurrent = styler.GetLine(startPos);
+    int levelPrev = startPos == 0 ? 0 : (styler.LevelAt(lineCurrent)
                                          & SC_FOLDLEVELNUMBERMASK
                                          & ~SC_FOLDLEVELBASE);
-	int levelCurrent = levelPrev;
-	char chNext = styler[startPos];
-	int styleNext = styler.StyleAt(startPos);
-	int stylePrev = startPos <= 1 ? SCE_RB_DEFAULT : styler.StyleAt(startPos - 1);
+    int levelCurrent = levelPrev;
+    char chNext = styler[startPos];
+    int styleNext = styler.StyleAt(startPos);
+    int stylePrev = startPos <= 1 ? SCE_RB_DEFAULT : styler.StyleAt(startPos - 1);
     bool buffer_ends_with_eol = false;
-	for (unsigned int i = startPos; i < endPos; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-		int style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
-		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+    for (Sci_PositionU i = startPos; i < endPos; i++) {
+        char ch = chNext;
+        chNext = styler.SafeGetCharAt(i + 1);
+        int style = styleNext;
+        styleNext = styler.StyleAt(i + 1);
+        bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+
+        /*Mutiline comment patch*/
+        if (foldComment && atEOL && IsCommentLine(lineCurrent, styler)) {
+            if (!IsCommentLine(lineCurrent - 1, styler)
+                    && IsCommentLine(lineCurrent + 1, styler))
+                levelCurrent++;
+            else if (IsCommentLine(lineCurrent - 1, styler)
+                     && !IsCommentLine(lineCurrent + 1, styler))
+                levelCurrent--;
+        }
+
         if (style == SCE_RB_COMMENTLINE) {
             if (foldComment && stylePrev != SCE_RB_COMMENTLINE) {
                 if (chNext == '{') {
-					levelCurrent++;
-				} else if (chNext == '}' && levelCurrent > 0) {
-					levelCurrent--;
-				}
+                    levelCurrent++;
+                } else if (chNext == '}' && levelCurrent > 0) {
+                    levelCurrent--;
+                }
             }
         } else if (style == SCE_RB_OPERATOR) {
-			if (strchr("[{(", ch)) {
-				levelCurrent++;
-			} else if (strchr(")}]", ch)) {
+            if (strchr("[{(", ch)) {
+                levelCurrent++;
+            } else if (strchr(")}]", ch)) {
                 // Don't decrement below 0
                 if (levelCurrent > 0)
                     levelCurrent--;
-			}
+            }
         } else if (style == SCE_RB_WORD && styleNext != SCE_RB_WORD) {
             // Look at the keyword on the left and decide what to do
             char prevWord[MAX_KEYWORD_LENGTH + 1]; // 1 byte for zero
@@ -1662,7 +1820,7 @@ static void FoldRbDoc(unsigned int startPos, int length, int initStyle,
                 // Don't decrement below 0
                 if (levelCurrent > 0)
                     levelCurrent--;
-            } else if (   !strcmp(prevWord, "if")
+            } else if (!strcmp(prevWord, "if")
                        || !strcmp(prevWord, "def")
                        || !strcmp(prevWord, "class")
                        || !strcmp(prevWord, "module")
@@ -1673,43 +1831,49 @@ static void FoldRbDoc(unsigned int startPos, int length, int initStyle,
                        || !strcmp(prevWord, "unless")
                        || !strcmp(prevWord, "until")
                        || !strcmp(prevWord, "for")
-                          ) {
-				levelCurrent++;
+                      ) {
+                levelCurrent++;
+            }
+        } else if (style == SCE_RB_HERE_DELIM) {
+            if (styler.SafeGetCharAt(i-2) == '<' && styler.SafeGetCharAt(i-1) == '<') {
+                levelCurrent++;
+            } else if (styleNext == SCE_RB_DEFAULT) {
+                levelCurrent--;
             }
         }
-		if (atEOL) {
-			int lev = levelPrev;
-			if (visibleChars == 0 && foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if ((levelCurrent > levelPrev) && (visibleChars > 0))
-				lev |= SC_FOLDLEVELHEADERFLAG;
+        if (atEOL) {
+            int lev = levelPrev;
+            if (visibleChars == 0 && foldCompact)
+                lev |= SC_FOLDLEVELWHITEFLAG;
+            if ((levelCurrent > levelPrev) && (visibleChars > 0))
+                lev |= SC_FOLDLEVELHEADERFLAG;
             styler.SetLevel(lineCurrent, lev|SC_FOLDLEVELBASE);
-			lineCurrent++;
-			levelPrev = levelCurrent;
-			visibleChars = 0;
+            lineCurrent++;
+            levelPrev = levelCurrent;
+            visibleChars = 0;
             buffer_ends_with_eol = true;
-		} else if (!isspacechar(ch)) {
-			visibleChars++;
+        } else if (!isspacechar(ch)) {
+            visibleChars++;
             buffer_ends_with_eol = false;
         }
-		stylePrev = style;
+        stylePrev = style;
     }
-	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
+    // Fill in the real level of the next line, keeping the current flags as they will be filled in later
     if (!buffer_ends_with_eol) {
         lineCurrent++;
         int new_lev = levelCurrent;
         if (visibleChars == 0 && foldCompact)
             new_lev |= SC_FOLDLEVELWHITEFLAG;
-			if ((levelCurrent > levelPrev) && (visibleChars > 0))
-				new_lev |= SC_FOLDLEVELHEADERFLAG;
-            levelCurrent = new_lev;
+        if ((levelCurrent > levelPrev) && (visibleChars > 0))
+            new_lev |= SC_FOLDLEVELHEADERFLAG;
+        levelCurrent = new_lev;
     }
-	styler.SetLevel(lineCurrent, levelCurrent|SC_FOLDLEVELBASE);
+    styler.SetLevel(lineCurrent, levelCurrent|SC_FOLDLEVELBASE);
 }
 
-static const char * const rubyWordListDesc[] = {
-	"Keywords",
-	0
+static const char *const rubyWordListDesc[] = {
+    "Keywords",
+    0
 };
 
 LexerModule lmRuby(SCLEX_RUBY, ColouriseRbDoc, "ruby", FoldRbDoc, rubyWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexRust.cxx b/Pythonwin/Scintilla/lexers/LexRust.cxx
new file mode 100644
index 000000000..439d2d3b0
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexRust.cxx
@@ -0,0 +1,844 @@
+/** @file LexRust.cxx
+ ** Lexer for Rust.
+ **
+ ** Copyright (c) 2013 by SiegeLord <slabode@aim.com>
+ ** Converted to lexer object and added further folding features/properties by "Udo Lechner" <dlchnr(at)gmx(dot)net>
+ **/
+// Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+#include <map>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+static const int NUM_RUST_KEYWORD_LISTS = 7;
+static const int MAX_RUST_IDENT_CHARS = 1023;
+
+static bool IsStreamCommentStyle(int style) {
+	return style == SCE_RUST_COMMENTBLOCK ||
+		   style == SCE_RUST_COMMENTBLOCKDOC;
+}
+
+// Options used for LexerRust
+struct OptionsRust {
+	bool fold;
+	bool foldSyntaxBased;
+	bool foldComment;
+	bool foldCommentMultiline;
+	bool foldCommentExplicit;
+	std::string foldExplicitStart;
+	std::string foldExplicitEnd;
+	bool foldExplicitAnywhere;
+	bool foldCompact;
+	int  foldAtElseInt;
+	bool foldAtElse;
+	OptionsRust() {
+		fold = false;
+		foldSyntaxBased = true;
+		foldComment = false;
+		foldCommentMultiline = true;
+		foldCommentExplicit = true;
+		foldExplicitStart = "";
+		foldExplicitEnd   = "";
+		foldExplicitAnywhere = false;
+		foldCompact = true;
+		foldAtElseInt = -1;
+		foldAtElse = false;
+	}
+};
+
+static const char * const rustWordLists[NUM_RUST_KEYWORD_LISTS + 1] = {
+			"Primary keywords and identifiers",
+			"Built in types",
+			"Other keywords",
+			"Keywords 4",
+			"Keywords 5",
+			"Keywords 6",
+			"Keywords 7",
+			0,
+		};
+
+struct OptionSetRust : public OptionSet<OptionsRust> {
+	OptionSetRust() {
+		DefineProperty("fold", &OptionsRust::fold);
+
+		DefineProperty("fold.comment", &OptionsRust::foldComment);
+
+		DefineProperty("fold.compact", &OptionsRust::foldCompact);
+
+		DefineProperty("fold.at.else", &OptionsRust::foldAtElse);
+
+		DefineProperty("fold.rust.syntax.based", &OptionsRust::foldSyntaxBased,
+			"Set this property to 0 to disable syntax based folding.");
+
+		DefineProperty("fold.rust.comment.multiline", &OptionsRust::foldCommentMultiline,
+			"Set this property to 0 to disable folding multi-line comments when fold.comment=1.");
+
+		DefineProperty("fold.rust.comment.explicit", &OptionsRust::foldCommentExplicit,
+			"Set this property to 0 to disable folding explicit fold points when fold.comment=1.");
+
+		DefineProperty("fold.rust.explicit.start", &OptionsRust::foldExplicitStart,
+			"The string to use for explicit fold start points, replacing the standard //{.");
+
+		DefineProperty("fold.rust.explicit.end", &OptionsRust::foldExplicitEnd,
+			"The string to use for explicit fold end points, replacing the standard //}.");
+
+		DefineProperty("fold.rust.explicit.anywhere", &OptionsRust::foldExplicitAnywhere,
+			"Set this property to 1 to enable explicit fold points anywhere, not just in line comments.");
+
+		DefineProperty("lexer.rust.fold.at.else", &OptionsRust::foldAtElseInt,
+			"This option enables Rust folding on a \"} else {\" line of an if statement.");
+
+		DefineWordListSets(rustWordLists);
+	}
+};
+
+class LexerRust : public DefaultLexer {
+	WordList keywords[NUM_RUST_KEYWORD_LISTS];
+	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 lvRelease5;
+	}
+	const char * SCI_METHOD PropertyNames() override {
+		return osRust.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char *name) override {
+		return osRust.PropertyType(name);
+	}
+	const char * SCI_METHOD DescribeProperty(const char *name) override {
+		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();
+	}
+	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 *) override {
+		return 0;
+	}
+	static ILexer5 *LexerFactoryRust() {
+		return new LexerRust();
+	}
+};
+
+Sci_Position SCI_METHOD LexerRust::PropertySet(const char *key, const char *val) {
+	if (osRust.PropertySet(&options, key, val)) {
+		return 0;
+	}
+	return -1;
+}
+
+Sci_Position SCI_METHOD LexerRust::WordListSet(int n, const char *wl) {
+	Sci_Position firstModification = -1;
+	if (n < NUM_RUST_KEYWORD_LISTS) {
+		WordList *wordListN = &keywords[n];
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+		}
+	}
+	return firstModification;
+}
+
+static bool IsWhitespace(int c) {
+    return c == ' ' || c == '\t' || c == '\r' || c == '\n';
+}
+
+/* This isn't quite right for Unicode identifiers */
+static bool IsIdentifierStart(int ch) {
+	return (IsASCII(ch) && (isalpha(ch) || ch == '_')) || !IsASCII(ch);
+}
+
+/* This isn't quite right for Unicode identifiers */
+static bool IsIdentifierContinue(int ch) {
+	return (IsASCII(ch) && (isalnum(ch) || ch == '_')) || !IsASCII(ch);
+}
+
+static void ScanWhitespace(Accessor& styler, Sci_Position& pos, Sci_Position max) {
+	while (IsWhitespace(styler.SafeGetCharAt(pos, '\0')) && pos < max) {
+		if (pos == styler.LineEnd(styler.GetLine(pos)))
+			styler.SetLineState(styler.GetLine(pos), 0);
+		pos++;
+	}
+	styler.ColourTo(pos-1, SCE_RUST_DEFAULT);
+}
+
+static void GrabString(char* s, Accessor& styler, Sci_Position start, Sci_Position len) {
+	for (Sci_Position ii = 0; ii < len; ii++)
+		s[ii] = styler[ii + start];
+	s[len] = '\0';
+}
+
+static void ScanIdentifier(Accessor& styler, Sci_Position& pos, WordList *keywords) {
+	Sci_Position start = pos;
+	while (IsIdentifierContinue(styler.SafeGetCharAt(pos, '\0')))
+		pos++;
+
+	if (styler.SafeGetCharAt(pos, '\0') == '!') {
+		pos++;
+		styler.ColourTo(pos - 1, SCE_RUST_MACRO);
+	} else {
+		char s[MAX_RUST_IDENT_CHARS + 1];
+		Sci_Position len = pos - start;
+		len = len > MAX_RUST_IDENT_CHARS ? MAX_RUST_IDENT_CHARS : len;
+		GrabString(s, styler, start, len);
+		bool keyword = false;
+		for (int ii = 0; ii < NUM_RUST_KEYWORD_LISTS; ii++) {
+			if (keywords[ii].InList(s)) {
+				styler.ColourTo(pos - 1, SCE_RUST_WORD + ii);
+				keyword = true;
+				break;
+			}
+		}
+		if (!keyword) {
+			styler.ColourTo(pos - 1, SCE_RUST_IDENTIFIER);
+		}
+	}
+}
+
+/* Scans a sequence of digits, returning true if it found any. */
+static bool ScanDigits(Accessor& styler, Sci_Position& pos, int base) {
+	Sci_Position old_pos = pos;
+	for (;;) {
+		int c = styler.SafeGetCharAt(pos, '\0');
+		if (IsADigit(c, base) || c == '_')
+			pos++;
+		else
+			break;
+	}
+	return old_pos != pos;
+}
+
+/* Scans an integer and floating point literals. */
+static void ScanNumber(Accessor& styler, Sci_Position& pos) {
+	int base = 10;
+	int c = styler.SafeGetCharAt(pos, '\0');
+	int n = styler.SafeGetCharAt(pos + 1, '\0');
+	bool error = false;
+	/* Scan the prefix, thus determining the base.
+	 * 10 is default if there's no prefix. */
+	if (c == '0' && n == 'x') {
+		pos += 2;
+		base = 16;
+	} else if (c == '0' && n == 'b') {
+		pos += 2;
+		base = 2;
+	} else if (c == '0' && n == 'o') {
+		pos += 2;
+		base = 8;
+	}
+
+	/* Scan initial digits. The literal is malformed if there are none. */
+	error |= !ScanDigits(styler, pos, base);
+	/* See if there's an integer suffix. We mimic the Rust's lexer
+	 * and munch it even if there was an error above. */
+	c = styler.SafeGetCharAt(pos, '\0');
+	if (c == 'u' || c == 'i') {
+		pos++;
+		c = styler.SafeGetCharAt(pos, '\0');
+		n = styler.SafeGetCharAt(pos + 1, '\0');
+		if (c == '8') {
+			pos++;
+		} else if (c == '1' && n == '6') {
+			pos += 2;
+		} else if (c == '3' && n == '2') {
+			pos += 2;
+		} else if (c == '6' && n == '4') {
+			pos += 2;
+		} else if (styler.Match(pos, "size")) {
+			pos += 4;
+		} else {
+			error = true;
+		}
+	/* See if it's a floating point literal. These literals have to be base 10.
+	 */
+	} else if (!error) {
+		/* If there's a period, it's a floating point literal unless it's
+		 * followed by an identifier (meaning this is a method call, e.g.
+		 * `1.foo()`) or another period, in which case it's a range (e.g. 1..2)
+		 */
+		n = styler.SafeGetCharAt(pos + 1, '\0');
+		if (c == '.' && !(IsIdentifierStart(n) || n == '.')) {
+			error |= base != 10;
+			pos++;
+			/* It's ok to have no digits after the period. */
+			ScanDigits(styler, pos, 10);
+		}
+
+		/* Look for the exponentiation. */
+		c = styler.SafeGetCharAt(pos, '\0');
+		if (c == 'e' || c == 'E') {
+			error |= base != 10;
+			pos++;
+			c = styler.SafeGetCharAt(pos, '\0');
+			if (c == '-' || c == '+')
+				pos++;
+			/* It is invalid to have no digits in the exponent. */
+			error |= !ScanDigits(styler, pos, 10);
+		}
+
+		/* Scan the floating point suffix. */
+		c = styler.SafeGetCharAt(pos, '\0');
+		if (c == 'f') {
+			error |= base != 10;
+			pos++;
+			c = styler.SafeGetCharAt(pos, '\0');
+			n = styler.SafeGetCharAt(pos + 1, '\0');
+			if (c == '3' && n == '2') {
+				pos += 2;
+			} else if (c == '6' && n == '4') {
+				pos += 2;
+			} else {
+				error = true;
+			}
+		}
+	}
+
+	if (error)
+		styler.ColourTo(pos - 1, SCE_RUST_LEXERROR);
+	else
+		styler.ColourTo(pos - 1, SCE_RUST_NUMBER);
+}
+
+static bool IsOneCharOperator(int c) {
+	return c == ';' || c == ',' || c == '(' || c == ')'
+	    || c == '{' || c == '}' || c == '[' || c == ']'
+	    || c == '@' || c == '#' || c == '~' || c == '+'
+	    || c == '*' || c == '/' || c == '^' || c == '%'
+	    || c == '.' || c == ':' || c == '!' || c == '<'
+	    || c == '>' || c == '=' || c == '-' || c == '&'
+	    || c == '|' || c == '$' || c == '?';
+}
+
+static bool IsTwoCharOperator(int c, int n) {
+	return (c == '.' && n == '.') || (c == ':' && n == ':')
+	    || (c == '!' && n == '=') || (c == '<' && n == '<')
+	    || (c == '<' && n == '=') || (c == '>' && n == '>')
+	    || (c == '>' && n == '=') || (c == '=' && n == '=')
+	    || (c == '=' && n == '>') || (c == '-' && n == '>')
+	    || (c == '&' && n == '&') || (c == '|' && n == '|')
+	    || (c == '-' && n == '=') || (c == '&' && n == '=')
+	    || (c == '|' && n == '=') || (c == '+' && n == '=')
+	    || (c == '*' && n == '=') || (c == '/' && n == '=')
+	    || (c == '^' && n == '=') || (c == '%' && n == '=');
+}
+
+static bool IsThreeCharOperator(int c, int n, int n2) {
+	return (c == '<' && n == '<' && n2 == '=')
+	    || (c == '>' && n == '>' && n2 == '=');
+}
+
+static bool IsValidCharacterEscape(int c) {
+	return c == 'n'  || c == 'r' || c == 't' || c == '\\'
+	    || c == '\'' || c == '"' || c == '0';
+}
+
+static bool IsValidStringEscape(int c) {
+	return IsValidCharacterEscape(c) || c == '\n' || c == '\r';
+}
+
+static bool ScanNumericEscape(Accessor &styler, Sci_Position& pos, Sci_Position num_digits, bool stop_asap) {
+	for (;;) {
+		int c = styler.SafeGetCharAt(pos, '\0');
+		if (!IsADigit(c, 16))
+			break;
+		num_digits--;
+		pos++;
+		if (num_digits == 0 && stop_asap)
+			return true;
+	}
+	if (num_digits == 0) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+/* This is overly permissive for character literals in order to accept UTF-8 encoded
+ * character literals. */
+static void ScanCharacterLiteralOrLifetime(Accessor &styler, Sci_Position& pos, bool ascii_only) {
+	pos++;
+	int c = styler.SafeGetCharAt(pos, '\0');
+	int n = styler.SafeGetCharAt(pos + 1, '\0');
+	bool done = false;
+	bool valid_lifetime = !ascii_only && IsIdentifierStart(c);
+	bool valid_char = true;
+	bool first = true;
+	while (!done) {
+		switch (c) {
+			case '\\':
+				done = true;
+				if (IsValidCharacterEscape(n)) {
+					pos += 2;
+				} else if (n == 'x') {
+					pos += 2;
+					valid_char = ScanNumericEscape(styler, pos, 2, false);
+				} else if (n == 'u' && !ascii_only) {
+					pos += 2;
+					if (styler.SafeGetCharAt(pos, '\0') != '{') {
+						// old-style
+						valid_char = ScanNumericEscape(styler, pos, 4, false);
+					} else {
+						int n_digits = 0;
+						while (IsADigit(styler.SafeGetCharAt(++pos, '\0'), 16) && n_digits++ < 6) {
+						}
+						if (n_digits > 0 && styler.SafeGetCharAt(pos, '\0') == '}')
+							pos++;
+						else
+							valid_char = false;
+					}
+				} else if (n == 'U' && !ascii_only) {
+					pos += 2;
+					valid_char = ScanNumericEscape(styler, pos, 8, false);
+				} else {
+					valid_char = false;
+				}
+				break;
+			case '\'':
+				valid_char = !first;
+				done = true;
+				break;
+			case '\t':
+			case '\n':
+			case '\r':
+			case '\0':
+				valid_char = false;
+				done = true;
+				break;
+			default:
+				if (ascii_only && !IsASCII((char)c)) {
+					done = true;
+					valid_char = false;
+				} else if (!IsIdentifierContinue(c) && !first) {
+					done = true;
+				} else {
+					pos++;
+				}
+				break;
+		}
+		c = styler.SafeGetCharAt(pos, '\0');
+		n = styler.SafeGetCharAt(pos + 1, '\0');
+
+		first = false;
+	}
+	if (styler.SafeGetCharAt(pos, '\0') == '\'') {
+		valid_lifetime = false;
+	} else {
+		valid_char = false;
+	}
+	if (valid_lifetime) {
+		styler.ColourTo(pos - 1, SCE_RUST_LIFETIME);
+	} else if (valid_char) {
+		pos++;
+		styler.ColourTo(pos - 1, ascii_only ? SCE_RUST_BYTECHARACTER : SCE_RUST_CHARACTER);
+	} else {
+		styler.ColourTo(pos - 1, SCE_RUST_LEXERROR);
+	}
+}
+
+enum CommentState {
+	UnknownComment,
+	DocComment,
+	NotDocComment
+};
+
+/*
+ * The rule for block-doc comments is as follows: /xxN and /x! (where x is an asterisk, N is a non-asterisk) start doc comments.
+ * Otherwise it's a regular comment.
+ */
+static void ResumeBlockComment(Accessor &styler, Sci_Position& pos, Sci_Position max, CommentState state, int level) {
+	int c = styler.SafeGetCharAt(pos, '\0');
+	bool maybe_doc_comment = false;
+	if (c == '*') {
+		int n = styler.SafeGetCharAt(pos + 1, '\0');
+		if (n != '*' && n != '/') {
+			maybe_doc_comment = true;
+		}
+	} else if (c == '!') {
+		maybe_doc_comment = true;
+	}
+
+	for (;;) {
+		int n = styler.SafeGetCharAt(pos + 1, '\0');
+		if (pos == styler.LineEnd(styler.GetLine(pos)))
+			styler.SetLineState(styler.GetLine(pos), level);
+		if (c == '*') {
+			pos++;
+			if (n == '/') {
+				pos++;
+				level--;
+				if (level == 0) {
+					styler.SetLineState(styler.GetLine(pos), 0);
+					if (state == DocComment || (state == UnknownComment && maybe_doc_comment))
+						styler.ColourTo(pos - 1, SCE_RUST_COMMENTBLOCKDOC);
+					else
+						styler.ColourTo(pos - 1, SCE_RUST_COMMENTBLOCK);
+					break;
+				}
+			}
+		} else if (c == '/') {
+			pos++;
+			if (n == '*') {
+				pos++;
+				level++;
+			}
+		}
+		else {
+			pos++;
+		}
+		if (pos >= max) {
+			if (state == DocComment || (state == UnknownComment && maybe_doc_comment))
+				styler.ColourTo(pos - 1, SCE_RUST_COMMENTBLOCKDOC);
+			else
+				styler.ColourTo(pos - 1, SCE_RUST_COMMENTBLOCK);
+			break;
+		}
+		c = styler.SafeGetCharAt(pos, '\0');
+	}
+}
+
+/*
+ * The rule for line-doc comments is as follows... ///N and //! (where N is a non slash) start doc comments.
+ * Otherwise it's a normal line comment.
+ */
+static void ResumeLineComment(Accessor &styler, Sci_Position& pos, Sci_Position max, CommentState state) {
+	bool maybe_doc_comment = false;
+	int c = styler.SafeGetCharAt(pos, '\0');
+	if (c == '/') {
+		if (pos < max) {
+			pos++;
+			c = styler.SafeGetCharAt(pos, '\0');
+			if (c != '/') {
+				maybe_doc_comment = true;
+			}
+		}
+	} else if (c == '!') {
+		maybe_doc_comment = true;
+	}
+
+	while (pos < max && c != '\n') {
+		if (pos == styler.LineEnd(styler.GetLine(pos)))
+			styler.SetLineState(styler.GetLine(pos), 0);
+		pos++;
+		c = styler.SafeGetCharAt(pos, '\0');
+	}
+
+	if (state == DocComment || (state == UnknownComment && maybe_doc_comment))
+		styler.ColourTo(pos - 1, SCE_RUST_COMMENTLINEDOC);
+	else
+		styler.ColourTo(pos - 1, SCE_RUST_COMMENTLINE);
+}
+
+static void ScanComments(Accessor &styler, Sci_Position& pos, Sci_Position max) {
+	pos++;
+	int c = styler.SafeGetCharAt(pos, '\0');
+	pos++;
+	if (c == '/')
+		ResumeLineComment(styler, pos, max, UnknownComment);
+	else if (c == '*')
+		ResumeBlockComment(styler, pos, max, UnknownComment, 1);
+}
+
+static void ResumeString(Accessor &styler, Sci_Position& pos, Sci_Position max, bool ascii_only) {
+	int c = styler.SafeGetCharAt(pos, '\0');
+	bool error = false;
+	while (c != '"' && !error) {
+		if (pos >= max) {
+			error = true;
+			break;
+		}
+		if (pos == styler.LineEnd(styler.GetLine(pos)))
+			styler.SetLineState(styler.GetLine(pos), 0);
+		if (c == '\\') {
+			int n = styler.SafeGetCharAt(pos + 1, '\0');
+			if (IsValidStringEscape(n)) {
+				pos += 2;
+			} else if (n == 'x') {
+				pos += 2;
+				error = !ScanNumericEscape(styler, pos, 2, true);
+			} else if (n == 'u' && !ascii_only) {
+				pos += 2;
+				if (styler.SafeGetCharAt(pos, '\0') != '{') {
+					// old-style
+					error = !ScanNumericEscape(styler, pos, 4, true);
+				} else {
+					int n_digits = 0;
+					while (IsADigit(styler.SafeGetCharAt(++pos, '\0'), 16) && n_digits++ < 6) {
+					}
+					if (n_digits > 0 && styler.SafeGetCharAt(pos, '\0') == '}')
+						pos++;
+					else
+						error = true;
+				}
+			} else if (n == 'U' && !ascii_only) {
+				pos += 2;
+				error = !ScanNumericEscape(styler, pos, 8, true);
+			} else {
+				pos += 1;
+				error = true;
+			}
+		} else {
+			if (ascii_only && !IsASCII((char)c))
+				error = true;
+			else
+				pos++;
+		}
+		c = styler.SafeGetCharAt(pos, '\0');
+	}
+	if (!error)
+		pos++;
+	styler.ColourTo(pos - 1, ascii_only ? SCE_RUST_BYTESTRING : SCE_RUST_STRING);
+}
+
+static void ResumeRawString(Accessor &styler, Sci_Position& pos, Sci_Position max, int num_hashes, bool ascii_only) {
+	for (;;) {
+		if (pos == styler.LineEnd(styler.GetLine(pos)))
+			styler.SetLineState(styler.GetLine(pos), num_hashes);
+
+		int c = styler.SafeGetCharAt(pos, '\0');
+		if (c == '"') {
+			pos++;
+			int trailing_num_hashes = 0;
+			while (styler.SafeGetCharAt(pos, '\0') == '#' && trailing_num_hashes < num_hashes) {
+				trailing_num_hashes++;
+				pos++;
+			}
+			if (trailing_num_hashes == num_hashes) {
+				styler.SetLineState(styler.GetLine(pos), 0);
+				break;
+			}
+		} else if (pos >= max) {
+			break;
+		} else {
+			if (ascii_only && !IsASCII((char)c))
+				break;
+			pos++;
+		}
+	}
+	styler.ColourTo(pos - 1, ascii_only ? SCE_RUST_BYTESTRINGR : SCE_RUST_STRINGR);
+}
+
+static void ScanRawString(Accessor &styler, Sci_Position& pos, Sci_Position max, bool ascii_only) {
+	pos++;
+	int num_hashes = 0;
+	while (styler.SafeGetCharAt(pos, '\0') == '#') {
+		num_hashes++;
+		pos++;
+	}
+	if (styler.SafeGetCharAt(pos, '\0') != '"') {
+		styler.ColourTo(pos - 1, SCE_RUST_LEXERROR);
+	} else {
+		pos++;
+		ResumeRawString(styler, pos, max, num_hashes, ascii_only);
+	}
+}
+
+void SCI_METHOD LexerRust::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	PropSetSimple props;
+	Accessor styler(pAccess, &props);
+	Sci_Position pos = startPos;
+	Sci_Position max = pos + length;
+
+	styler.StartAt(pos);
+	styler.StartSegment(pos);
+
+	if (initStyle == SCE_RUST_COMMENTBLOCK || initStyle == SCE_RUST_COMMENTBLOCKDOC) {
+		ResumeBlockComment(styler, pos, max, initStyle == SCE_RUST_COMMENTBLOCKDOC ? DocComment : NotDocComment, styler.GetLineState(styler.GetLine(pos) - 1));
+	} else if (initStyle == SCE_RUST_COMMENTLINE || initStyle == SCE_RUST_COMMENTLINEDOC) {
+		ResumeLineComment(styler, pos, max, initStyle == SCE_RUST_COMMENTLINEDOC ? DocComment : NotDocComment);
+	} else if (initStyle == SCE_RUST_STRING) {
+		ResumeString(styler, pos, max, false);
+	} else if (initStyle == SCE_RUST_BYTESTRING) {
+		ResumeString(styler, pos, max, true);
+	} else if (initStyle == SCE_RUST_STRINGR) {
+		ResumeRawString(styler, pos, max, styler.GetLineState(styler.GetLine(pos) - 1), false);
+	} else if (initStyle == SCE_RUST_BYTESTRINGR) {
+		ResumeRawString(styler, pos, max, styler.GetLineState(styler.GetLine(pos) - 1), true);
+	}
+
+	while (pos < max) {
+		int c = styler.SafeGetCharAt(pos, '\0');
+		int n = styler.SafeGetCharAt(pos + 1, '\0');
+		int n2 = styler.SafeGetCharAt(pos + 2, '\0');
+
+		if (pos == 0 && c == '#' && n == '!' && n2 != '[') {
+			pos += 2;
+			ResumeLineComment(styler, pos, max, NotDocComment);
+		} else if (IsWhitespace(c)) {
+			ScanWhitespace(styler, pos, max);
+		} else if (c == '/' && (n == '/' || n == '*')) {
+			ScanComments(styler, pos, max);
+		} else if (c == 'r' && (n == '#' || n == '"')) {
+			ScanRawString(styler, pos, max, false);
+		} else if (c == 'b' && n == 'r' && (n2 == '#' || n2 == '"')) {
+			pos++;
+			ScanRawString(styler, pos, max, true);
+		} else if (c == 'b' && n == '"') {
+			pos += 2;
+			ResumeString(styler, pos, max, true);
+		} else if (c == 'b' && n == '\'') {
+			pos++;
+			ScanCharacterLiteralOrLifetime(styler, pos, true);
+		} else if (IsIdentifierStart(c)) {
+			ScanIdentifier(styler, pos, keywords);
+		} else if (IsADigit(c)) {
+			ScanNumber(styler, pos);
+		} else if (IsThreeCharOperator(c, n, n2)) {
+			pos += 3;
+			styler.ColourTo(pos - 1, SCE_RUST_OPERATOR);
+		} else if (IsTwoCharOperator(c, n)) {
+			pos += 2;
+			styler.ColourTo(pos - 1, SCE_RUST_OPERATOR);
+		} else if (IsOneCharOperator(c)) {
+			pos++;
+			styler.ColourTo(pos - 1, SCE_RUST_OPERATOR);
+		} else if (c == '\'') {
+			ScanCharacterLiteralOrLifetime(styler, pos, false);
+		} else if (c == '"') {
+			pos++;
+			ResumeString(styler, pos, max, false);
+		} else {
+			pos++;
+			styler.ColourTo(pos - 1, SCE_RUST_LEXERROR);
+		}
+	}
+	styler.ColourTo(pos - 1, SCE_RUST_DEFAULT);
+	styler.Flush();
+}
+
+void SCI_METHOD LexerRust::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+
+	if (!options.fold)
+		return;
+
+	LexAccessor styler(pAccess);
+
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	bool inLineComment = false;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelCurrent = SC_FOLDLEVELBASE;
+	if (lineCurrent > 0)
+		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
+	Sci_PositionU lineStartNext = styler.LineStart(lineCurrent+1);
+	int levelMinCurrent = levelCurrent;
+	int levelNext = levelCurrent;
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+	const bool userDefinedFoldMarkers = !options.foldExplicitStart.empty() && !options.foldExplicitEnd.empty();
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int stylePrev = style;
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atEOL = i == (lineStartNext-1);
+		if ((style == SCE_RUST_COMMENTLINE) || (style == SCE_RUST_COMMENTLINEDOC))
+			inLineComment = true;
+		if (options.foldComment && options.foldCommentMultiline && IsStreamCommentStyle(style) && !inLineComment) {
+			if (!IsStreamCommentStyle(stylePrev)) {
+				levelNext++;
+			} else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
+				// Comments don't end at end of line and the next character may be unstyled.
+				levelNext--;
+			}
+		}
+		if (options.foldComment && options.foldCommentExplicit && ((style == SCE_RUST_COMMENTLINE) || options.foldExplicitAnywhere)) {
+			if (userDefinedFoldMarkers) {
+				if (styler.Match(i, options.foldExplicitStart.c_str())) {
+					levelNext++;
+				} else if (styler.Match(i, options.foldExplicitEnd.c_str())) {
+					levelNext--;
+				}
+			} else {
+				if ((ch == '/') && (chNext == '/')) {
+					char chNext2 = styler.SafeGetCharAt(i + 2);
+					if (chNext2 == '{') {
+						levelNext++;
+					} else if (chNext2 == '}') {
+						levelNext--;
+					}
+				}
+			}
+		}
+		if (options.foldSyntaxBased && (style == SCE_RUST_OPERATOR)) {
+			if (ch == '{') {
+				// Measure the minimum before a '{' to allow
+				// folding on "} else {"
+				if (levelMinCurrent > levelNext) {
+					levelMinCurrent = levelNext;
+				}
+				levelNext++;
+			} else if (ch == '}') {
+				levelNext--;
+			}
+		}
+		if (!IsASpace(ch))
+			visibleChars++;
+		if (atEOL || (i == endPos-1)) {
+			int levelUse = levelCurrent;
+			if (options.foldSyntaxBased && options.foldAtElse) {
+				levelUse = levelMinCurrent;
+			}
+			int lev = levelUse | levelNext << 16;
+			if (visibleChars == 0 && options.foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if (levelUse < levelNext)
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			lineStartNext = styler.LineStart(lineCurrent+1);
+			levelCurrent = levelNext;
+			levelMinCurrent = levelCurrent;
+			if (atEOL && (i == static_cast<Sci_PositionU>(styler.Length()-1))) {
+				// There is an empty line at end of file so give it same level and empty
+				styler.SetLevel(lineCurrent, (levelCurrent | levelCurrent << 16) | SC_FOLDLEVELWHITEFLAG);
+			}
+			visibleChars = 0;
+			inLineComment = false;
+		}
+	}
+}
+
+LexerModule lmRust(SCLEX_RUST, LexerRust::LexerFactoryRust, "rust", rustWordLists);
diff --git a/Pythonwin/Scintilla/lexers/LexSAS.cxx b/Pythonwin/Scintilla/lexers/LexSAS.cxx
new file mode 100644
index 000000000..29feba82d
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexSAS.cxx
@@ -0,0 +1,220 @@
+// Scintilla source code edit control
+/** @file LexSAS.cxx
+ ** Lexer for SAS
+ **/
+// Author: Luke Rasmussen (luke.rasmussen@gmail.com)
+//
+// The License.txt file describes the conditions under which this software may
+// be distributed.
+//
+// Developed as part of the StatTag project at Northwestern University Feinberg
+// School of Medicine with funding from Northwestern University Clinical and
+// Translational Sciences Institute through CTSA grant UL1TR001422.  This work
+// has not been reviewed or endorsed by NCATS or the NIH.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static void ColouriseSASDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+    Accessor &styler) {
+
+    WordList &keywords = *keywordlists[0];
+    WordList &blockKeywords = *keywordlists[1];
+    WordList &functionKeywords = *keywordlists[2];
+    WordList &statements = *keywordlists[3];
+
+    CharacterSet setCouldBePostOp(CharacterSet::setNone, "+-");
+    CharacterSet setMacroStart(CharacterSet::setNone, "%");
+    CharacterSet setWordStart(CharacterSet::setAlpha, "_", 0x80, true);
+    CharacterSet setWord(CharacterSet::setAlphaNum, "._", 0x80, true);
+
+    StyleContext sc(startPos, length, initStyle, styler);
+    bool lineHasNonCommentChar = false;
+    for (; sc.More(); sc.Forward()) {
+        if (sc.atLineStart) {
+            lineHasNonCommentChar = false;
+        }
+
+        // Determine if the current state should terminate.
+        switch (sc.state) {
+            case SCE_SAS_OPERATOR:
+                sc.SetState(SCE_SAS_DEFAULT);
+                break;
+            case SCE_SAS_NUMBER:
+                // We accept almost anything because of hex. and number suffixes
+                if (!setWord.Contains(sc.ch)) {
+                    sc.SetState(SCE_SAS_DEFAULT);
+                }
+                break;
+            case SCE_SAS_MACRO:
+              if (!setWord.Contains(sc.ch) || (sc.ch == '.')) {
+                char s[1000];
+                sc.GetCurrentLowered(s, sizeof(s));
+                if (keywords.InList(s)) {
+                  sc.ChangeState(SCE_SAS_MACRO_KEYWORD);
+                }
+                else if (blockKeywords.InList(s)) {
+                  sc.ChangeState(SCE_SAS_BLOCK_KEYWORD);
+                }
+                else if (functionKeywords.InList(s)) {
+                  sc.ChangeState(SCE_SAS_MACRO_FUNCTION);
+                }
+                sc.SetState(SCE_SAS_DEFAULT);
+              }
+              break;
+            case SCE_SAS_IDENTIFIER:
+                if (!setWord.Contains(sc.ch) || (sc.ch == '.')) {
+                    char s[1000];
+                    sc.GetCurrentLowered(s, sizeof(s));
+                    if (statements.InList(s)) {
+                      sc.ChangeState(SCE_SAS_STATEMENT);
+                    }
+                    else if(blockKeywords.InList(s)) {
+                      sc.ChangeState(SCE_SAS_BLOCK_KEYWORD);
+                    }
+                    sc.SetState(SCE_SAS_DEFAULT);
+                }
+                break;
+            case SCE_SAS_COMMENTBLOCK:
+                if (sc.Match('*', '/')) {
+                    sc.Forward();
+                    sc.ForwardSetState(SCE_SAS_DEFAULT);
+                }
+                break;
+            case SCE_SAS_COMMENT:
+            case SCE_SAS_COMMENTLINE:
+                if (sc.Match(';')) {
+                    sc.Forward();
+                    sc.SetState(SCE_SAS_DEFAULT);
+                }
+                break;
+            case SCE_SAS_STRING:
+                if (sc.ch == '\"') {
+                    sc.ForwardSetState(SCE_SAS_DEFAULT);
+                }
+                break;
+        }
+
+        // Determine if a new state should be entered.
+        if (sc.state == SCE_SAS_DEFAULT) {
+            if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
+                lineHasNonCommentChar = true;
+                sc.SetState(SCE_SAS_NUMBER);
+            }
+            else if (setWordStart.Contains(sc.ch)) {
+                lineHasNonCommentChar = true;
+                sc.SetState(SCE_SAS_IDENTIFIER);
+            }
+            else if (sc.Match('*') && !lineHasNonCommentChar) {
+                sc.SetState(SCE_SAS_COMMENT);
+            }
+            else if (sc.Match('/', '*')) {
+                sc.SetState(SCE_SAS_COMMENTBLOCK);
+                sc.Forward();	// Eat the * so it isn't used for the end of the comment
+            }
+            else if (sc.Match('/', '/')) {
+                sc.SetState(SCE_SAS_COMMENTLINE);
+            }
+            else if (sc.ch == '\"') {
+                lineHasNonCommentChar = true;
+                sc.SetState(SCE_SAS_STRING);
+            }
+            else if (setMacroStart.Contains(sc.ch)) {
+              lineHasNonCommentChar = true;
+              sc.SetState(SCE_SAS_MACRO);
+            }
+            else if (isoperator(static_cast<char>(sc.ch))) {
+                lineHasNonCommentChar = true;
+                sc.SetState(SCE_SAS_OPERATOR);
+            }
+        }
+    }
+
+    sc.Complete();
+}
+
+// Store both the current line's fold level and the next lines in the
+// level store to make it easy to pick up with each increment
+// and to make it possible to fiddle the current level for "} else {".
+static void FoldSASDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[],
+    Accessor &styler) {
+    bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+    bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0;
+    Sci_PositionU endPos = startPos + length;
+    int visibleChars = 0;
+    Sci_Position lineCurrent = styler.GetLine(startPos);
+    int levelCurrent = SC_FOLDLEVELBASE;
+    if (lineCurrent > 0)
+        levelCurrent = styler.LevelAt(lineCurrent - 1) >> 16;
+    int levelMinCurrent = levelCurrent;
+    int levelNext = levelCurrent;
+    char chNext = styler[startPos];
+    int styleNext = styler.StyleAt(startPos);
+    for (Sci_PositionU i = startPos; i < endPos; i++) {
+        char ch = chNext;
+        chNext = styler.SafeGetCharAt(i + 1);
+        int style = styleNext;
+        styleNext = styler.StyleAt(i + 1);
+        bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+        if (style == SCE_R_OPERATOR) {
+            if (ch == '{') {
+                // Measure the minimum before a '{' to allow
+                // folding on "} else {"
+                if (levelMinCurrent > levelNext) {
+                    levelMinCurrent = levelNext;
+                }
+                levelNext++;
+            }
+            else if (ch == '}') {
+                levelNext--;
+            }
+        }
+        if (atEOL) {
+            int levelUse = levelCurrent;
+            if (foldAtElse) {
+                levelUse = levelMinCurrent;
+            }
+            int lev = levelUse | levelNext << 16;
+            if (visibleChars == 0 && foldCompact)
+                lev |= SC_FOLDLEVELWHITEFLAG;
+            if (levelUse < levelNext)
+                lev |= SC_FOLDLEVELHEADERFLAG;
+            if (lev != styler.LevelAt(lineCurrent)) {
+                styler.SetLevel(lineCurrent, lev);
+            }
+            lineCurrent++;
+            levelCurrent = levelNext;
+            levelMinCurrent = levelCurrent;
+            visibleChars = 0;
+        }
+        if (!isspacechar(ch))
+            visibleChars++;
+    }
+}
+
+
+static const char * const SASWordLists[] = {
+    "Language Keywords",
+	  "Macro Keywords",
+    "Types",
+    0,
+};
+
+LexerModule lmSAS(SCLEX_SAS, ColouriseSASDoc, "sas", FoldSASDoc, SASWordLists);
diff --git a/Pythonwin/Scintilla/lexers/LexSML.cxx b/Pythonwin/Scintilla/lexers/LexSML.cxx
new file mode 100644
index 000000000..ed67300d2
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexSML.cxx
@@ -0,0 +1,226 @@
+// Scintilla source code edit control
+/** @file LexSML.cxx
+ ** Lexer for SML.
+ **/
+// Copyright 2009 by James Moffatt and Yuzhou Xin
+// Modified from LexCaml.cxx by Robert Roessler <robertr@rftp.com> Copyright 2005
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wcomma"
+#endif
+
+inline int  issml(int c) {return isalnum(c) || c == '_';}
+inline int issmlf(int c) {return isalpha(c) || c == '_';}
+inline int issmld(int c) {return isdigit(c) || c == '_';}
+
+
+using namespace Scintilla;
+
+static void ColouriseSMLDoc(
+	Sci_PositionU startPos, Sci_Position length,
+	int initStyle,
+	WordList *keywordlists[],
+	Accessor &styler)
+{
+	StyleContext sc(startPos, length, initStyle, styler);
+	int nesting = 0;
+	if (sc.state < SCE_SML_STRING)
+		sc.state = SCE_SML_DEFAULT;
+	if (sc.state >= SCE_SML_COMMENT)
+		nesting = (sc.state & 0x0f) - SCE_SML_COMMENT;
+
+	Sci_PositionU chToken = 0;
+	int chBase = 0, chLit = 0;
+	WordList& keywords  = *keywordlists[0];
+	WordList& keywords2 = *keywordlists[1];
+	WordList& keywords3 = *keywordlists[2];
+	const int useMagic = styler.GetPropertyInt("lexer.caml.magic", 0);
+
+	while (sc.More()) {
+		int state2 = -1;
+		Sci_Position chColor = sc.currentPos - 1;
+		bool advance = true;
+
+		switch (sc.state & 0x0f) {
+		case SCE_SML_DEFAULT:
+			chToken = sc.currentPos;
+			if (issmlf(sc.ch))
+				state2 = SCE_SML_IDENTIFIER;
+			else if (sc.Match('`') && issmlf(sc.chNext))
+				state2 = SCE_SML_TAGNAME;
+			else if (sc.Match('#')&&isdigit(sc.chNext))
+					state2 = SCE_SML_LINENUM;
+			else if (sc.Match('#','\"')){
+					state2 = SCE_SML_CHAR,chLit = 0;
+					sc.Forward();
+
+				}
+			else if (isdigit(sc.ch)) {
+				state2 = SCE_SML_NUMBER, chBase = 10;
+				if (sc.Match('0') && strchr("xX", sc.chNext))
+					chBase = 16, sc.Forward();}
+			else if (sc.Match('\"')&&sc.chPrev!='#')
+				state2 = SCE_SML_STRING;
+			else if (sc.Match('(', '*')){
+				state2 = SCE_SML_COMMENT,
+					sc.ch = ' ',
+					sc.Forward();}
+			else if (strchr("!~"
+					"=<>@^+-*/"
+					"()[];,:.#", sc.ch))
+				state2 = SCE_SML_OPERATOR;
+			break;
+
+		case SCE_SML_IDENTIFIER:
+			if (!(issml(sc.ch) || sc.Match('\''))) {
+				const Sci_Position n = sc.currentPos - chToken;
+				if (n < 24) {
+					char t[24];
+					for (Sci_Position i = -n; i < 0; i++)
+						t[n + i] = static_cast<char>(sc.GetRelative(i));
+					t[n] = '\0';
+					if ((n == 1 && sc.chPrev == '_') || keywords.InList(t))
+						sc.ChangeState(SCE_SML_KEYWORD);
+					else if (keywords2.InList(t))
+						sc.ChangeState(SCE_SML_KEYWORD2);
+					else if (keywords3.InList(t))
+						sc.ChangeState(SCE_SML_KEYWORD3);
+				}
+				state2 = SCE_SML_DEFAULT, advance = false;
+			}
+			break;
+
+		case SCE_SML_TAGNAME:
+			if (!(issml(sc.ch) || sc.Match('\'')))
+				state2 = SCE_SML_DEFAULT, advance = false;
+			break;
+
+		case SCE_SML_LINENUM:
+			if (!isdigit(sc.ch))
+				state2 = SCE_SML_DEFAULT, advance = false;
+			break;
+
+		case SCE_SML_OPERATOR: {
+			const char* o = 0;
+			if (issml(sc.ch) || isspace(sc.ch)
+				|| (o = strchr(")]};,\'\"`#", sc.ch),o)
+				|| !strchr("!$%&*+-./:<=>?@^|~", sc.ch)) {
+				if (o && strchr(")]};,", sc.ch)) {
+					if ((sc.Match(')') && sc.chPrev == '(')
+						|| (sc.Match(']') && sc.chPrev == '['))
+						sc.ChangeState(SCE_SML_KEYWORD);
+					chColor++;
+				} else
+					advance = false;
+				state2 = SCE_SML_DEFAULT;
+			}
+			break;
+		}
+
+		case SCE_SML_NUMBER:
+			if (issmld(sc.ch) || IsADigit(sc.ch, chBase))
+				break;
+			if ((sc.Match('l') || sc.Match('L') || sc.Match('n'))
+				&& (issmld(sc.chPrev) || IsADigit(sc.chPrev, chBase)))
+				break;
+			if (chBase == 10) {
+				if (sc.Match('.') && issmld(sc.chPrev))
+					break;
+				if ((sc.Match('e') || sc.Match('E'))
+					&& (issmld(sc.chPrev) || sc.chPrev == '.'))
+					break;
+				if ((sc.Match('+') || sc.Match('-'))
+					&& (sc.chPrev == 'e' || sc.chPrev == 'E'))
+					break;
+			}
+			state2 = SCE_SML_DEFAULT, advance = false;
+			break;
+
+		case SCE_SML_CHAR:
+			if (sc.Match('\\')) {
+				chLit = 1;
+				if (sc.chPrev == '\\')
+					sc.ch = ' ';
+			} else if ((sc.Match('\"') && sc.chPrev != '\\') || sc.atLineEnd) {
+				state2 = SCE_SML_DEFAULT;
+				chLit = 1;
+				if (sc.Match('\"'))
+					chColor++;
+				else
+					sc.ChangeState(SCE_SML_IDENTIFIER);
+			} else if (chLit < 1 && sc.currentPos - chToken >= 3)
+				sc.ChangeState(SCE_SML_IDENTIFIER), advance = false;
+			break;
+
+		case SCE_SML_STRING:
+			if (sc.Match('\\') && sc.chPrev == '\\')
+				sc.ch = ' ';
+			else if (sc.Match('\"') && sc.chPrev != '\\')
+				state2 = SCE_SML_DEFAULT, chColor++;
+			break;
+
+		case SCE_SML_COMMENT:
+		case SCE_SML_COMMENT1:
+		case SCE_SML_COMMENT2:
+		case SCE_SML_COMMENT3:
+			if (sc.Match('(', '*'))
+				state2 = sc.state + 1, chToken = sc.currentPos,
+					sc.ch = ' ',
+					sc.Forward(), nesting++;
+			else if (sc.Match(')') && sc.chPrev == '*') {
+				if (nesting)
+					state2 = (sc.state & 0x0f) - 1, chToken = 0, nesting--;
+				else
+					state2 = SCE_SML_DEFAULT;
+				chColor++;
+			} else if (useMagic && sc.currentPos - chToken == 4
+				&& sc.Match('c') && sc.chPrev == 'r' && sc.GetRelative(-2) == '@')
+				sc.state |= 0x10;
+			break;
+		}
+
+		if (state2 >= 0)
+			styler.ColourTo(chColor, sc.state), sc.ChangeState(state2);
+		if (advance)
+			sc.Forward();
+	}
+
+	sc.Complete();
+}
+
+static void FoldSMLDoc(
+	Sci_PositionU, Sci_Position,
+	int,
+	WordList *[],
+	Accessor &)
+{
+}
+
+static const char * const SMLWordListDesc[] = {
+	"Keywords",
+	"Keywords2",
+	"Keywords3",
+	0
+};
+
+LexerModule lmSML(SCLEX_SML, ColouriseSMLDoc, "SML", FoldSMLDoc, SMLWordListDesc);
+
diff --git a/Pythonwin/Scintilla/lexers/LexSQL.cxx b/Pythonwin/Scintilla/lexers/LexSQL.cxx
new file mode 100644
index 000000000..d45dc2098
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexSQL.cxx
@@ -0,0 +1,970 @@
+//-*- coding: utf-8 -*-
+// Scintilla source code edit control
+/** @file LexSQL.cxx
+ ** Lexer for SQL, including PL/SQL and SQL*Plus.
+ ** Improved by Jérôme LAFORGE <jerome.laforge_AT_gmail_DOT_com> from 2010 to 2012.
+ **/
+// Copyright 1998-2012 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+#include <vector>
+#include <map>
+#include <algorithm>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "SparseState.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+static inline bool IsAWordChar(int ch, bool sqlAllowDottedWord) {
+	if (!sqlAllowDottedWord)
+		return (ch < 0x80) && (isalnum(ch) || ch == '_');
+	else
+		return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.');
+}
+
+static inline bool IsAWordStart(int ch) {
+	return (ch < 0x80) && (isalpha(ch) || ch == '_');
+}
+
+static inline bool IsADoxygenChar(int ch) {
+	return (islower(ch) || ch == '$' || ch == '@' ||
+	        ch == '\\' || ch == '&' || ch == '<' ||
+	        ch == '>' || ch == '#' || ch == '{' ||
+	        ch == '}' || ch == '[' || ch == ']');
+}
+
+static inline bool IsANumberChar(int ch, int chPrev) {
+	// Not exactly following number definition (several dots are seen as OK, etc.)
+	// but probably enough in most cases.
+	return (ch < 0x80) &&
+	       (isdigit(ch) || toupper(ch) == 'E' ||
+	        ch == '.' || ((ch == '-' || ch == '+') && chPrev < 0x80 && toupper(chPrev) == 'E'));
+}
+
+typedef unsigned int sql_state_t;
+
+class SQLStates {
+public :
+	void Set(Sci_Position lineNumber, unsigned short int sqlStatesLine) {
+		sqlStatement.Set(lineNumber, sqlStatesLine);
+	}
+
+	sql_state_t IgnoreWhen (sql_state_t sqlStatesLine, bool enable) {
+		if (enable)
+			sqlStatesLine |= MASK_IGNORE_WHEN;
+		else
+			sqlStatesLine &= ~MASK_IGNORE_WHEN;
+
+		return sqlStatesLine;
+	}
+
+	sql_state_t IntoCondition (sql_state_t sqlStatesLine, bool enable) {
+		if (enable)
+			sqlStatesLine |= MASK_INTO_CONDITION;
+		else
+			sqlStatesLine &= ~MASK_INTO_CONDITION;
+
+		return sqlStatesLine;
+	}
+
+	sql_state_t IntoExceptionBlock (sql_state_t sqlStatesLine, bool enable) {
+		if (enable)
+			sqlStatesLine |= MASK_INTO_EXCEPTION;
+		else
+			sqlStatesLine &= ~MASK_INTO_EXCEPTION;
+
+		return sqlStatesLine;
+	}
+
+	sql_state_t IntoDeclareBlock (sql_state_t sqlStatesLine, bool enable) {
+		if (enable)
+			sqlStatesLine |= MASK_INTO_DECLARE;
+		else
+			sqlStatesLine &= ~MASK_INTO_DECLARE;
+
+		return sqlStatesLine;
+	}
+
+	sql_state_t IntoMergeStatement (sql_state_t sqlStatesLine, bool enable) {
+		if (enable)
+			sqlStatesLine |= MASK_MERGE_STATEMENT;
+		else
+			sqlStatesLine &= ~MASK_MERGE_STATEMENT;
+
+		return sqlStatesLine;
+	}
+
+	sql_state_t CaseMergeWithoutWhenFound (sql_state_t sqlStatesLine, bool found) {
+		if (found)
+			sqlStatesLine |= MASK_CASE_MERGE_WITHOUT_WHEN_FOUND;
+		else
+			sqlStatesLine &= ~MASK_CASE_MERGE_WITHOUT_WHEN_FOUND;
+
+		return sqlStatesLine;
+	}
+	sql_state_t IntoSelectStatementOrAssignment (sql_state_t sqlStatesLine, bool found) {
+		if (found)
+			sqlStatesLine |= MASK_INTO_SELECT_STATEMENT_OR_ASSIGNEMENT;
+		else
+			sqlStatesLine &= ~MASK_INTO_SELECT_STATEMENT_OR_ASSIGNEMENT;
+		return sqlStatesLine;
+	}
+
+	sql_state_t BeginCaseBlock (sql_state_t sqlStatesLine) {
+		if ((sqlStatesLine & MASK_NESTED_CASES) < MASK_NESTED_CASES) {
+			sqlStatesLine++;
+		}
+		return sqlStatesLine;
+	}
+
+	sql_state_t EndCaseBlock (sql_state_t sqlStatesLine) {
+		if ((sqlStatesLine & MASK_NESTED_CASES) > 0) {
+			sqlStatesLine--;
+		}
+		return sqlStatesLine;
+	}
+
+	sql_state_t IntoCreateStatement (sql_state_t sqlStatesLine, bool enable) {
+		if (enable)
+			sqlStatesLine |= MASK_INTO_CREATE;
+		else
+			sqlStatesLine &= ~MASK_INTO_CREATE;
+
+		return sqlStatesLine;
+	}
+
+	sql_state_t IntoCreateViewStatement (sql_state_t sqlStatesLine, bool enable) {
+		if (enable)
+			sqlStatesLine |= MASK_INTO_CREATE_VIEW;
+		else
+			sqlStatesLine &= ~MASK_INTO_CREATE_VIEW;
+
+		return sqlStatesLine;
+	}
+
+	sql_state_t IntoCreateViewAsStatement (sql_state_t sqlStatesLine, bool enable) {
+		if (enable)
+			sqlStatesLine |= MASK_INTO_CREATE_VIEW_AS_STATEMENT;
+		else
+			sqlStatesLine &= ~MASK_INTO_CREATE_VIEW_AS_STATEMENT;
+
+		return sqlStatesLine;
+	}
+
+	bool IsIgnoreWhen (sql_state_t sqlStatesLine) {
+		return (sqlStatesLine & MASK_IGNORE_WHEN) != 0;
+	}
+
+	bool IsIntoCondition (sql_state_t sqlStatesLine) {
+		return (sqlStatesLine & MASK_INTO_CONDITION) != 0;
+	}
+
+	bool IsIntoCaseBlock (sql_state_t sqlStatesLine) {
+		return (sqlStatesLine & MASK_NESTED_CASES) != 0;
+	}
+
+	bool IsIntoExceptionBlock (sql_state_t sqlStatesLine) {
+		return (sqlStatesLine & MASK_INTO_EXCEPTION) != 0;
+	}
+	bool IsIntoSelectStatementOrAssignment (sql_state_t sqlStatesLine) {
+		return (sqlStatesLine & MASK_INTO_SELECT_STATEMENT_OR_ASSIGNEMENT) != 0;
+	}
+	bool IsCaseMergeWithoutWhenFound (sql_state_t sqlStatesLine) {
+		return (sqlStatesLine & MASK_CASE_MERGE_WITHOUT_WHEN_FOUND) != 0;
+	}
+
+	bool IsIntoDeclareBlock (sql_state_t sqlStatesLine) {
+		return (sqlStatesLine & MASK_INTO_DECLARE) != 0;
+	}
+
+	bool IsIntoMergeStatement (sql_state_t sqlStatesLine) {
+		return (sqlStatesLine & MASK_MERGE_STATEMENT) != 0;
+	}
+
+	bool IsIntoCreateStatement (sql_state_t sqlStatesLine) {
+		return (sqlStatesLine & MASK_INTO_CREATE) != 0;
+	}
+
+	bool IsIntoCreateViewStatement (sql_state_t sqlStatesLine) {
+		return (sqlStatesLine & MASK_INTO_CREATE_VIEW) != 0;
+	}
+
+	bool IsIntoCreateViewAsStatement (sql_state_t sqlStatesLine) {
+		return (sqlStatesLine & MASK_INTO_CREATE_VIEW_AS_STATEMENT) != 0;
+	}
+
+	sql_state_t ForLine(Sci_Position lineNumber) {
+		return sqlStatement.ValueAt(lineNumber);
+	}
+
+	SQLStates() {}
+
+private :
+	SparseState <sql_state_t> sqlStatement;
+	enum {
+		MASK_NESTED_CASES                         = 0x0001FF,
+		MASK_INTO_SELECT_STATEMENT_OR_ASSIGNEMENT = 0x000200,
+		MASK_CASE_MERGE_WITHOUT_WHEN_FOUND        = 0x000400,
+		MASK_MERGE_STATEMENT                      = 0x000800,
+		MASK_INTO_DECLARE                         = 0x001000,
+		MASK_INTO_EXCEPTION                       = 0x002000,
+		MASK_INTO_CONDITION                       = 0x004000,
+		MASK_IGNORE_WHEN                          = 0x008000,
+		MASK_INTO_CREATE                          = 0x010000,
+		MASK_INTO_CREATE_VIEW                     = 0x020000,
+		MASK_INTO_CREATE_VIEW_AS_STATEMENT        = 0x040000
+	};
+};
+
+// Options used for LexerSQL
+struct OptionsSQL {
+	bool fold;
+	bool foldAtElse;
+	bool foldComment;
+	bool foldCompact;
+	bool foldOnlyBegin;
+	bool sqlBackticksIdentifier;
+	bool sqlNumbersignComment;
+	bool sqlBackslashEscapes;
+	bool sqlAllowDottedWord;
+	OptionsSQL() {
+		fold = false;
+		foldAtElse = false;
+		foldComment = false;
+		foldCompact = false;
+		foldOnlyBegin = false;
+		sqlBackticksIdentifier = false;
+		sqlNumbersignComment = false;
+		sqlBackslashEscapes = false;
+		sqlAllowDottedWord = false;
+	}
+};
+
+static const char * const sqlWordListDesc[] = {
+	"Keywords",
+	"Database Objects",
+	"PLDoc",
+	"SQL*Plus",
+	"User Keywords 1",
+	"User Keywords 2",
+	"User Keywords 3",
+	"User Keywords 4",
+	0
+};
+
+struct OptionSetSQL : public OptionSet<OptionsSQL> {
+	OptionSetSQL() {
+		DefineProperty("fold", &OptionsSQL::fold);
+
+		DefineProperty("fold.sql.at.else", &OptionsSQL::foldAtElse,
+		               "This option enables SQL folding on a \"ELSE\" and \"ELSIF\" line of an IF statement.");
+
+		DefineProperty("fold.comment", &OptionsSQL::foldComment);
+
+		DefineProperty("fold.compact", &OptionsSQL::foldCompact);
+
+		DefineProperty("fold.sql.only.begin", &OptionsSQL::foldOnlyBegin);
+
+		DefineProperty("lexer.sql.backticks.identifier", &OptionsSQL::sqlBackticksIdentifier);
+
+		DefineProperty("lexer.sql.numbersign.comment", &OptionsSQL::sqlNumbersignComment,
+		               "If \"lexer.sql.numbersign.comment\" property is set to 0 a line beginning with '#' will not be a comment.");
+
+		DefineProperty("sql.backslash.escapes", &OptionsSQL::sqlBackslashEscapes,
+		               "Enables backslash as an escape character in SQL.");
+
+		DefineProperty("lexer.sql.allow.dotted.word", &OptionsSQL::sqlAllowDottedWord,
+		               "Set to 1 to colourise recognized words with dots "
+		               "(recommended for Oracle PL/SQL objects).");
+
+		DefineWordListSets(sqlWordListDesc);
+	}
+};
+
+class LexerSQL : public DefaultLexer {
+public :
+	LexerSQL() : DefaultLexer("sql", SCLEX_SQL) {}
+
+	virtual ~LexerSQL() {}
+
+	int SCI_METHOD Version () const override {
+		return lvRelease5;
+	}
+
+	void SCI_METHOD Release() override {
+		delete this;
+	}
+
+	const char * SCI_METHOD PropertyNames() override {
+		return osSQL.PropertyNames();
+	}
+
+	int SCI_METHOD PropertyType(const char *name) override {
+		return osSQL.PropertyType(name);
+	}
+
+	const char * SCI_METHOD DescribeProperty(const char *name) override {
+		return osSQL.DescribeProperty(name);
+	}
+
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override {
+		if (osSQL.PropertySet(&options, key, val)) {
+			return 0;
+		}
+		return -1;
+	}
+
+	const char * SCI_METHOD PropertyGet(const char *key) override {
+		return osSQL.PropertyGet(key);
+	}
+
+	const char * SCI_METHOD DescribeWordListSets() override {
+		return osSQL.DescribeWordListSets();
+	}
+
+	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 *) override {
+		return 0;
+	}
+
+	static ILexer5 *LexerFactorySQL() {
+		return new LexerSQL();
+	}
+private:
+	bool IsStreamCommentStyle(int style) {
+		return style == SCE_SQL_COMMENT ||
+		       style == SCE_SQL_COMMENTDOC ||
+		       style == SCE_SQL_COMMENTDOCKEYWORD ||
+		       style == SCE_SQL_COMMENTDOCKEYWORDERROR;
+	}
+
+	bool IsCommentStyle (int style) {
+		switch (style) {
+		case SCE_SQL_COMMENT :
+		case SCE_SQL_COMMENTDOC :
+		case SCE_SQL_COMMENTLINE :
+		case SCE_SQL_COMMENTLINEDOC :
+		case SCE_SQL_COMMENTDOCKEYWORD :
+		case SCE_SQL_COMMENTDOCKEYWORDERROR :
+			return true;
+		default :
+			return false;
+		}
+	}
+
+	bool IsCommentLine (Sci_Position line, LexAccessor &styler) {
+		Sci_Position pos = styler.LineStart(line);
+		Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+		for (Sci_Position i = pos; i + 1 < eol_pos; i++) {
+			int style = styler.StyleAt(i);
+			// MySQL needs -- comments to be followed by space or control char
+			if (style == SCE_SQL_COMMENTLINE && styler.Match(i, "--"))
+				return true;
+			else if (!IsASpaceOrTab(styler[i]))
+				return false;
+		}
+		return false;
+	}
+
+	OptionsSQL options;
+	OptionSetSQL osSQL;
+	SQLStates sqlStates;
+
+	WordList keywords1;
+	WordList keywords2;
+	WordList kw_pldoc;
+	WordList kw_sqlplus;
+	WordList kw_user1;
+	WordList kw_user2;
+	WordList kw_user3;
+	WordList kw_user4;
+};
+
+Sci_Position SCI_METHOD LexerSQL::WordListSet(int n, const char *wl) {
+	WordList *wordListN = 0;
+	switch (n) {
+	case 0:
+		wordListN = &keywords1;
+		break;
+	case 1:
+		wordListN = &keywords2;
+		break;
+	case 2:
+		wordListN = &kw_pldoc;
+		break;
+	case 3:
+		wordListN = &kw_sqlplus;
+		break;
+	case 4:
+		wordListN = &kw_user1;
+		break;
+	case 5:
+		wordListN = &kw_user2;
+		break;
+	case 6:
+		wordListN = &kw_user3;
+		break;
+	case 7:
+		wordListN = &kw_user4;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN) {
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+		}
+	}
+	return firstModification;
+}
+
+void SCI_METHOD LexerSQL::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	LexAccessor styler(pAccess);
+	StyleContext sc(startPos, length, initStyle, styler);
+	int styleBeforeDCKeyword = SCE_SQL_DEFAULT;
+
+	for (; sc.More(); sc.Forward()) {
+		// Determine if the current state should terminate.
+		switch (sc.state) {
+		case SCE_SQL_OPERATOR:
+			sc.SetState(SCE_SQL_DEFAULT);
+			break;
+		case SCE_SQL_NUMBER:
+			// We stop the number definition on non-numerical non-dot non-eE non-sign char
+			if (!IsANumberChar(sc.ch, sc.chPrev)) {
+				sc.SetState(SCE_SQL_DEFAULT);
+			}
+			break;
+		case SCE_SQL_IDENTIFIER:
+			if (!IsAWordChar(sc.ch, options.sqlAllowDottedWord)) {
+				int nextState = SCE_SQL_DEFAULT;
+				char s[1000];
+				sc.GetCurrentLowered(s, sizeof(s));
+				if (keywords1.InList(s)) {
+					sc.ChangeState(SCE_SQL_WORD);
+				} else if (keywords2.InList(s)) {
+					sc.ChangeState(SCE_SQL_WORD2);
+				} else if (kw_sqlplus.InListAbbreviated(s, '~')) {
+					sc.ChangeState(SCE_SQL_SQLPLUS);
+					if (strncmp(s, "rem", 3) == 0) {
+						nextState = SCE_SQL_SQLPLUS_COMMENT;
+					} else if (strncmp(s, "pro", 3) == 0) {
+						nextState = SCE_SQL_SQLPLUS_PROMPT;
+					}
+				} else if (kw_user1.InList(s)) {
+					sc.ChangeState(SCE_SQL_USER1);
+				} else if (kw_user2.InList(s)) {
+					sc.ChangeState(SCE_SQL_USER2);
+				} else if (kw_user3.InList(s)) {
+					sc.ChangeState(SCE_SQL_USER3);
+				} else if (kw_user4.InList(s)) {
+					sc.ChangeState(SCE_SQL_USER4);
+				}
+				sc.SetState(nextState);
+			}
+			break;
+		case SCE_SQL_QUOTEDIDENTIFIER:
+			if (sc.ch == 0x60) {
+				if (sc.chNext == 0x60) {
+					sc.Forward();	// Ignore it
+				} else {
+					sc.ForwardSetState(SCE_SQL_DEFAULT);
+				}
+			}
+			break;
+		case SCE_SQL_COMMENT:
+			if (sc.Match('*', '/')) {
+				sc.Forward();
+				sc.ForwardSetState(SCE_SQL_DEFAULT);
+			}
+			break;
+		case SCE_SQL_COMMENTDOC:
+			if (sc.Match('*', '/')) {
+				sc.Forward();
+				sc.ForwardSetState(SCE_SQL_DEFAULT);
+			} else if (sc.ch == '@' || sc.ch == '\\') { // Doxygen support
+				// Verify that we have the conditions to mark a comment-doc-keyword
+				if ((IsASpace(sc.chPrev) || sc.chPrev == '*') && (!IsASpace(sc.chNext))) {
+					styleBeforeDCKeyword = SCE_SQL_COMMENTDOC;
+					sc.SetState(SCE_SQL_COMMENTDOCKEYWORD);
+				}
+			}
+			break;
+		case SCE_SQL_COMMENTLINE:
+		case SCE_SQL_COMMENTLINEDOC:
+		case SCE_SQL_SQLPLUS_COMMENT:
+		case SCE_SQL_SQLPLUS_PROMPT:
+			if (sc.atLineStart) {
+				sc.SetState(SCE_SQL_DEFAULT);
+			}
+			break;
+		case SCE_SQL_COMMENTDOCKEYWORD:
+			if ((styleBeforeDCKeyword == SCE_SQL_COMMENTDOC) && sc.Match('*', '/')) {
+				sc.ChangeState(SCE_SQL_COMMENTDOCKEYWORDERROR);
+				sc.Forward();
+				sc.ForwardSetState(SCE_SQL_DEFAULT);
+			} else if (!IsADoxygenChar(sc.ch)) {
+				char s[100];
+				sc.GetCurrentLowered(s, sizeof(s));
+				if (!isspace(sc.ch) || !kw_pldoc.InList(s + 1)) {
+					sc.ChangeState(SCE_SQL_COMMENTDOCKEYWORDERROR);
+				}
+				sc.SetState(styleBeforeDCKeyword);
+			}
+			break;
+		case SCE_SQL_CHARACTER:
+			if (options.sqlBackslashEscapes && sc.ch == '\\') {
+				sc.Forward();
+			} else if (sc.ch == '\'') {
+				if (sc.chNext == '\'') {
+					sc.Forward();
+				} else {
+					sc.ForwardSetState(SCE_SQL_DEFAULT);
+				}
+			}
+			break;
+		case SCE_SQL_STRING:
+			if (options.sqlBackslashEscapes && sc.ch == '\\') {
+				// Escape sequence
+				sc.Forward();
+			} else if (sc.ch == '\"') {
+				if (sc.chNext == '\"') {
+					sc.Forward();
+				} else {
+					sc.ForwardSetState(SCE_SQL_DEFAULT);
+				}
+			}
+			break;
+		case SCE_SQL_QOPERATOR:
+			// Locate the unique Q operator character
+			sc.Complete();
+			char qOperator = 0x00;
+			for (Sci_Position styleStartPos = sc.currentPos; styleStartPos > 0; --styleStartPos) {
+				if (styler.StyleAt(styleStartPos - 1) != SCE_SQL_QOPERATOR) {
+					qOperator = styler.SafeGetCharAt(styleStartPos + 2);
+					break;
+				}
+			}
+
+			char qComplement = 0x00;
+
+			if (qOperator == '<') {
+				qComplement = '>';
+			} else if (qOperator == '(') {
+				qComplement = ')';
+			} else if (qOperator == '{') {
+				qComplement = '}';
+			} else if (qOperator == '[') {
+				qComplement = ']';
+			} else {
+				qComplement = qOperator;
+			}
+
+			if (sc.Match(qComplement, '\'')) {
+				sc.Forward();
+				sc.ForwardSetState(SCE_SQL_DEFAULT);
+			}
+			break;
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_SQL_DEFAULT) {
+			if (sc.Match('q', '\'') || sc.Match('Q', '\'')) {
+				sc.SetState(SCE_SQL_QOPERATOR);
+				sc.Forward();
+			} else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext)) ||
+			          ((sc.ch == '-' || sc.ch == '+') && IsADigit(sc.chNext) && !IsADigit(sc.chPrev))) {
+				sc.SetState(SCE_SQL_NUMBER);
+			} else if (IsAWordStart(sc.ch)) {
+				sc.SetState(SCE_SQL_IDENTIFIER);
+			} else if (sc.ch == 0x60 && options.sqlBackticksIdentifier) {
+				sc.SetState(SCE_SQL_QUOTEDIDENTIFIER);
+			} else if (sc.Match('/', '*')) {
+				if (sc.Match("/**") || sc.Match("/*!")) {	// Support of Doxygen doc. style
+					sc.SetState(SCE_SQL_COMMENTDOC);
+				} else {
+					sc.SetState(SCE_SQL_COMMENT);
+				}
+				sc.Forward();	// Eat the * so it isn't used for the end of the comment
+			} else if (sc.Match('-', '-')) {
+				// MySQL requires a space or control char after --
+				// http://dev.mysql.com/doc/mysql/en/ansi-diff-comments.html
+				// Perhaps we should enforce that with proper property:
+				//~ 			} else if (sc.Match("-- ")) {
+				sc.SetState(SCE_SQL_COMMENTLINE);
+			} else if (sc.ch == '#' && options.sqlNumbersignComment) {
+				sc.SetState(SCE_SQL_COMMENTLINEDOC);
+			} else if (sc.ch == '\'') {
+				sc.SetState(SCE_SQL_CHARACTER);
+			} else if (sc.ch == '\"') {
+				sc.SetState(SCE_SQL_STRING);
+			} else if (isoperator(static_cast<char>(sc.ch))) {
+				sc.SetState(SCE_SQL_OPERATOR);
+			}
+		}
+	}
+	sc.Complete();
+}
+
+void SCI_METHOD LexerSQL::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+	if (!options.fold)
+		return;
+	LexAccessor styler(pAccess);
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelCurrent = SC_FOLDLEVELBASE;
+
+	if (lineCurrent > 0) {
+		// Backtrack to previous line in case need to fix its fold status for folding block of single-line comments (i.e. '--').
+		Sci_Position lastNLPos = -1;
+		// And keep going back until we find an operator ';' followed
+		// by white-space and/or comments. This will improve folding.
+		while (--startPos > 0) {
+			char ch = styler[startPos];
+			if (ch == '\n' || (ch == '\r' && styler[startPos + 1] != '\n')) {
+				lastNLPos = startPos;
+			} else if (ch == ';' &&
+				   styler.StyleAt(startPos) == SCE_SQL_OPERATOR) {
+				bool isAllClear = true;
+				for (Sci_Position tempPos = startPos + 1;
+				     tempPos < lastNLPos;
+				     ++tempPos) {
+					int tempStyle = styler.StyleAt(tempPos);
+					if (!IsCommentStyle(tempStyle)
+					    && tempStyle != SCE_SQL_DEFAULT) {
+						isAllClear = false;
+						break;
+					}
+				}
+				if (isAllClear) {
+					startPos = lastNLPos + 1;
+					break;
+				}
+			}
+		}
+		lineCurrent = styler.GetLine(startPos);
+		if (lineCurrent > 0)
+			levelCurrent = styler.LevelAt(lineCurrent - 1) >> 16;
+	}
+	// And because folding ends at ';', keep going until we find one
+	// Otherwise if create ... view ... as is split over multiple
+	// lines the folding won't always update immediately.
+	Sci_PositionU docLength = styler.Length();
+	for (; endPos < docLength; ++endPos) {
+		if (styler.SafeGetCharAt(endPos) == ';') {
+			break;
+		}
+	}
+
+	int levelNext = levelCurrent;
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+	bool endFound = false;
+	bool isUnfoldingIgnored = false;
+	// this statementFound flag avoids to fold when the statement is on only one line by ignoring ELSE or ELSIF
+	// eg. "IF condition1 THEN ... ELSIF condition2 THEN ... ELSE ... END IF;"
+	bool statementFound = false;
+	sql_state_t sqlStatesCurrentLine = 0;
+	if (!options.foldOnlyBegin) {
+		sqlStatesCurrentLine = sqlStates.ForLine(lineCurrent);
+	}
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int stylePrev = style;
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+		if (atEOL || (!IsCommentStyle(style) && ch == ';')) {
+			if (endFound) {
+				//Maybe this is the end of "EXCEPTION" BLOCK (eg. "BEGIN ... EXCEPTION ... END;")
+				sqlStatesCurrentLine = sqlStates.IntoExceptionBlock(sqlStatesCurrentLine, false);
+			}
+			// set endFound and isUnfoldingIgnored to false if EOL is reached or ';' is found
+			endFound = false;
+			isUnfoldingIgnored = false;
+		}
+		if ((!IsCommentStyle(style) && ch == ';')) {
+			if (sqlStates.IsIntoMergeStatement(sqlStatesCurrentLine)) {
+				// This is the end of "MERGE" statement.
+				if (!sqlStates.IsCaseMergeWithoutWhenFound(sqlStatesCurrentLine))
+					levelNext--;
+				sqlStatesCurrentLine = sqlStates.IntoMergeStatement(sqlStatesCurrentLine, false);
+				levelNext--;
+			}
+			if (sqlStates.IsIntoSelectStatementOrAssignment(sqlStatesCurrentLine))
+				sqlStatesCurrentLine = sqlStates.IntoSelectStatementOrAssignment(sqlStatesCurrentLine, false);
+			if (sqlStates.IsIntoCreateStatement(sqlStatesCurrentLine)) {
+				if (sqlStates.IsIntoCreateViewStatement(sqlStatesCurrentLine)) {
+					if (sqlStates.IsIntoCreateViewAsStatement(sqlStatesCurrentLine)) {
+						levelNext--;
+						sqlStatesCurrentLine = sqlStates.IntoCreateViewAsStatement(sqlStatesCurrentLine, false);
+					}
+					sqlStatesCurrentLine = sqlStates.IntoCreateViewStatement(sqlStatesCurrentLine, false);
+				}
+				sqlStatesCurrentLine = sqlStates.IntoCreateStatement(sqlStatesCurrentLine, false);
+			}
+		}
+		if (ch == ':' && chNext == '=' && !IsCommentStyle(style))
+			sqlStatesCurrentLine = sqlStates.IntoSelectStatementOrAssignment(sqlStatesCurrentLine, true);
+
+		if (options.foldComment && IsStreamCommentStyle(style)) {
+			if (!IsStreamCommentStyle(stylePrev)) {
+				levelNext++;
+			} else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
+				// Comments don't end at end of line and the next character may be unstyled.
+				levelNext--;
+			}
+		}
+		if (options.foldComment && (style == SCE_SQL_COMMENTLINE)) {
+			// MySQL needs -- comments to be followed by space or control char
+			if ((ch == '-') && (chNext == '-')) {
+				char chNext2 = styler.SafeGetCharAt(i + 2);
+				char chNext3 = styler.SafeGetCharAt(i + 3);
+				if (chNext2 == '{' || chNext3 == '{') {
+					levelNext++;
+				} else if (chNext2 == '}' || chNext3 == '}') {
+					levelNext--;
+				}
+			}
+		}
+		// Fold block of single-line comments (i.e. '--').
+		if (options.foldComment && atEOL && IsCommentLine(lineCurrent, styler)) {
+			if (!IsCommentLine(lineCurrent - 1, styler) && IsCommentLine(lineCurrent + 1, styler))
+				levelNext++;
+			else if (IsCommentLine(lineCurrent - 1, styler) && !IsCommentLine(lineCurrent + 1, styler))
+				levelNext--;
+		}
+		if (style == SCE_SQL_OPERATOR) {
+			if (ch == '(') {
+				if (levelCurrent > levelNext)
+					levelCurrent--;
+				levelNext++;
+			} else if (ch == ')') {
+				levelNext--;
+			} else if ((!options.foldOnlyBegin) && ch == ';') {
+				sqlStatesCurrentLine = sqlStates.IgnoreWhen(sqlStatesCurrentLine, false);
+			}
+		}
+		// If new keyword (cannot trigger on elseif or nullif, does less tests)
+		if (style == SCE_SQL_WORD && stylePrev != SCE_SQL_WORD) {
+			const int MAX_KW_LEN = 9;	// Maximum length of folding keywords
+			char s[MAX_KW_LEN + 2];
+			unsigned int j = 0;
+			for (; j < MAX_KW_LEN + 1; j++) {
+				if (!iswordchar(styler[i + j])) {
+					break;
+				}
+				s[j] = static_cast<char>(tolower(styler[i + j]));
+			}
+			if (j == MAX_KW_LEN + 1) {
+				// Keyword too long, don't test it
+				s[0] = '\0';
+			} else {
+				s[j] = '\0';
+			}
+			if (!options.foldOnlyBegin &&
+			        strcmp(s, "select") == 0) {
+				sqlStatesCurrentLine = sqlStates.IntoSelectStatementOrAssignment(sqlStatesCurrentLine, true);
+			} else if (strcmp(s, "if") == 0) {
+				if (endFound) {
+					endFound = false;
+					if (options.foldOnlyBegin && !isUnfoldingIgnored) {
+						// this end isn't for begin block, but for if block ("end if;")
+						// so ignore previous "end" by increment levelNext.
+						levelNext++;
+					}
+				} else {
+					if (!options.foldOnlyBegin)
+						sqlStatesCurrentLine = sqlStates.IntoCondition(sqlStatesCurrentLine, true);
+					if (levelCurrent > levelNext) {
+						// doesn't include this line into the folding block
+						// because doesn't hide IF (eg "END; IF")
+						levelCurrent = levelNext;
+					}
+				}
+			} else if (!options.foldOnlyBegin &&
+			           strcmp(s, "then") == 0 &&
+			           sqlStates.IsIntoCondition(sqlStatesCurrentLine)) {
+				sqlStatesCurrentLine = sqlStates.IntoCondition(sqlStatesCurrentLine, false);
+				if (!options.foldOnlyBegin) {
+					if (levelCurrent > levelNext) {
+						levelCurrent = levelNext;
+					}
+					if (!statementFound)
+						levelNext++;
+
+					statementFound = true;
+				} else if (levelCurrent > levelNext) {
+					// doesn't include this line into the folding block
+					// because doesn't hide LOOP or CASE (eg "END; LOOP" or "END; CASE")
+					levelCurrent = levelNext;
+				}
+			} else if (strcmp(s, "loop") == 0 ||
+			           strcmp(s, "case") == 0) {
+				if (endFound) {
+					endFound = false;
+					if (options.foldOnlyBegin && !isUnfoldingIgnored) {
+						// this end isn't for begin block, but for loop block ("end loop;") or case block ("end case;")
+						// so ignore previous "end" by increment levelNext.
+						levelNext++;
+					}
+					if ((!options.foldOnlyBegin) && strcmp(s, "case") == 0) {
+						sqlStatesCurrentLine = sqlStates.EndCaseBlock(sqlStatesCurrentLine);
+						if (!sqlStates.IsCaseMergeWithoutWhenFound(sqlStatesCurrentLine))
+							levelNext--; //again for the "end case;" and block when
+					}
+				} else if (!options.foldOnlyBegin) {
+					if (strcmp(s, "case") == 0) {
+						sqlStatesCurrentLine = sqlStates.BeginCaseBlock(sqlStatesCurrentLine);
+						sqlStatesCurrentLine = sqlStates.CaseMergeWithoutWhenFound(sqlStatesCurrentLine, true);
+					}
+
+					if (levelCurrent > levelNext)
+						levelCurrent = levelNext;
+
+					if (!statementFound)
+						levelNext++;
+
+					statementFound = true;
+				} else if (levelCurrent > levelNext) {
+					// doesn't include this line into the folding block
+					// because doesn't hide LOOP or CASE (eg "END; LOOP" or "END; CASE")
+					levelCurrent = levelNext;
+				}
+			} else if ((!options.foldOnlyBegin) && (
+			               // folding for ELSE and ELSIF block only if foldAtElse is set
+			               // and IF or CASE aren't on only one line with ELSE or ELSIF (with flag statementFound)
+			               options.foldAtElse && !statementFound) && strcmp(s, "elsif") == 0) {
+				sqlStatesCurrentLine = sqlStates.IntoCondition(sqlStatesCurrentLine, true);
+				levelCurrent--;
+				levelNext--;
+			} else if ((!options.foldOnlyBegin) && (
+			               // folding for ELSE and ELSIF block only if foldAtElse is set
+			               // and IF or CASE aren't on only one line with ELSE or ELSIF (with flag statementFound)
+			               options.foldAtElse && !statementFound) && strcmp(s, "else") == 0) {
+				// prevent also ELSE is on the same line (eg. "ELSE ... END IF;")
+				statementFound = true;
+				if (sqlStates.IsIntoCaseBlock(sqlStatesCurrentLine) && sqlStates.IsCaseMergeWithoutWhenFound(sqlStatesCurrentLine)) {
+					sqlStatesCurrentLine = sqlStates.CaseMergeWithoutWhenFound(sqlStatesCurrentLine, false);
+					levelNext++;
+				} else {
+					// we are in same case "} ELSE {" in C language
+					levelCurrent--;
+				}
+			} else if (strcmp(s, "begin") == 0) {
+				levelNext++;
+				sqlStatesCurrentLine = sqlStates.IntoDeclareBlock(sqlStatesCurrentLine, false);
+			} else if ((strcmp(s, "end") == 0) ||
+			           // SQL Anywhere permits IF ... ELSE ... ENDIF
+			           // will only be active if "endif" appears in the
+			           // keyword list.
+			           (strcmp(s, "endif") == 0)) {
+				endFound = true;
+				levelNext--;
+				if (sqlStates.IsIntoSelectStatementOrAssignment(sqlStatesCurrentLine) && !sqlStates.IsCaseMergeWithoutWhenFound(sqlStatesCurrentLine))
+					levelNext--;
+				if (levelNext < SC_FOLDLEVELBASE) {
+					levelNext = SC_FOLDLEVELBASE;
+					isUnfoldingIgnored = true;
+				}
+			} else if ((!options.foldOnlyBegin) &&
+			           strcmp(s, "when") == 0 &&
+			           !sqlStates.IsIgnoreWhen(sqlStatesCurrentLine) &&
+			           !sqlStates.IsIntoExceptionBlock(sqlStatesCurrentLine) && (
+			               sqlStates.IsIntoCaseBlock(sqlStatesCurrentLine) ||
+			               sqlStates.IsIntoMergeStatement(sqlStatesCurrentLine)
+			               )
+			           ) {
+				sqlStatesCurrentLine = sqlStates.IntoCondition(sqlStatesCurrentLine, true);
+
+				// Don't foldind when CASE and WHEN are on the same line (with flag statementFound) (eg. "CASE selector WHEN expression1 THEN sequence_of_statements1;\n")
+				// and same way for MERGE statement.
+				if (!statementFound) {
+					if (!sqlStates.IsCaseMergeWithoutWhenFound(sqlStatesCurrentLine)) {
+						levelCurrent--;
+						levelNext--;
+					}
+					sqlStatesCurrentLine = sqlStates.CaseMergeWithoutWhenFound(sqlStatesCurrentLine, false);
+				}
+			} else if ((!options.foldOnlyBegin) && strcmp(s, "exit") == 0) {
+				sqlStatesCurrentLine = sqlStates.IgnoreWhen(sqlStatesCurrentLine, true);
+			} else if ((!options.foldOnlyBegin) && !sqlStates.IsIntoDeclareBlock(sqlStatesCurrentLine) && strcmp(s, "exception") == 0) {
+				sqlStatesCurrentLine = sqlStates.IntoExceptionBlock(sqlStatesCurrentLine, true);
+			} else if ((!options.foldOnlyBegin) &&
+			           (strcmp(s, "declare") == 0 ||
+			            strcmp(s, "function") == 0 ||
+			            strcmp(s, "procedure") == 0 ||
+			            strcmp(s, "package") == 0)) {
+				sqlStatesCurrentLine = sqlStates.IntoDeclareBlock(sqlStatesCurrentLine, true);
+			} else if ((!options.foldOnlyBegin) &&
+			           strcmp(s, "merge") == 0) {
+				sqlStatesCurrentLine = sqlStates.IntoMergeStatement(sqlStatesCurrentLine, true);
+				sqlStatesCurrentLine = sqlStates.CaseMergeWithoutWhenFound(sqlStatesCurrentLine, true);
+				levelNext++;
+				statementFound = true;
+			} else if ((!options.foldOnlyBegin) &&
+				   strcmp(s, "create") == 0) {
+				sqlStatesCurrentLine = sqlStates.IntoCreateStatement(sqlStatesCurrentLine, true);
+			} else if ((!options.foldOnlyBegin) &&
+				   strcmp(s, "view") == 0 &&
+				   sqlStates.IsIntoCreateStatement(sqlStatesCurrentLine)) {
+				sqlStatesCurrentLine = sqlStates.IntoCreateViewStatement(sqlStatesCurrentLine, true);
+			} else if ((!options.foldOnlyBegin) &&
+				   strcmp(s, "as") == 0 &&
+				   sqlStates.IsIntoCreateViewStatement(sqlStatesCurrentLine) &&
+				   ! sqlStates.IsIntoCreateViewAsStatement(sqlStatesCurrentLine)) {
+				sqlStatesCurrentLine = sqlStates.IntoCreateViewAsStatement(sqlStatesCurrentLine, true);
+				levelNext++;
+			}
+		}
+		if (atEOL) {
+			int levelUse = levelCurrent;
+			int lev = levelUse | levelNext << 16;
+			if (visibleChars == 0 && options.foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if (levelUse < levelNext)
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			levelCurrent = levelNext;
+			visibleChars = 0;
+			statementFound = false;
+			if (!options.foldOnlyBegin)
+				sqlStates.Set(lineCurrent, sqlStatesCurrentLine);
+		}
+		if (!isspacechar(ch)) {
+			visibleChars++;
+		}
+	}
+}
+
+LexerModule lmSQL(SCLEX_SQL, LexerSQL::LexerFactorySQL, "sql", sqlWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexSTTXT.cxx b/Pythonwin/Scintilla/lexers/LexSTTXT.cxx
new file mode 100644
index 000000000..dd2fe5465
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexSTTXT.cxx
@@ -0,0 +1,404 @@
+// Scintilla source code edit control
+/** @file LexSTTXT.cxx
+ ** Lexer for Structured Text language.
+ ** Written by Pavel Bulochkin
+ **/
+// The License.txt file describes the conditions under which this software may be distributed.
+
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static void ClassifySTTXTWord(WordList *keywordlists[], StyleContext &sc)
+{
+	char s[256] = { 0 };
+	sc.GetCurrentLowered(s, sizeof(s));
+
+ 	if ((*keywordlists[0]).InList(s)) {
+ 		sc.ChangeState(SCE_STTXT_KEYWORD);
+ 	}
+
+	else if ((*keywordlists[1]).InList(s)) {
+		sc.ChangeState(SCE_STTXT_TYPE);
+	}
+
+	else if ((*keywordlists[2]).InList(s)) {
+		sc.ChangeState(SCE_STTXT_FUNCTION);
+	}
+
+	else if ((*keywordlists[3]).InList(s)) {
+		sc.ChangeState(SCE_STTXT_FB);
+	}
+
+	else if ((*keywordlists[4]).InList(s)) {
+		sc.ChangeState(SCE_STTXT_VARS);
+	}
+
+	else if ((*keywordlists[5]).InList(s)) {
+		sc.ChangeState(SCE_STTXT_PRAGMAS);
+	}
+
+	sc.SetState(SCE_STTXT_DEFAULT);
+}
+
+static void ColouriseSTTXTDoc (Sci_PositionU startPos, Sci_Position length, int initStyle,
+							  WordList *keywordlists[], Accessor &styler)
+{
+	StyleContext sc(startPos, length, initStyle, styler);
+
+	CharacterSet setWord(CharacterSet::setAlphaNum, "_", 0x80, true);
+	CharacterSet setWordStart(CharacterSet::setAlpha, "_", 0x80, true);
+	CharacterSet setNumber(CharacterSet::setDigits, "_.eE");
+	CharacterSet setHexNumber(CharacterSet::setDigits, "_abcdefABCDEF");
+	CharacterSet setOperator(CharacterSet::setNone,",.+-*/:;<=>[]()%&");
+	CharacterSet setDataTime(CharacterSet::setDigits,"_.-:dmshDMSH");
+
+ 	for ( ; sc.More() ; sc.Forward())
+ 	{
+		if(sc.atLineStart && sc.state != SCE_STTXT_COMMENT)
+			sc.SetState(SCE_STTXT_DEFAULT);
+
+		switch(sc.state)
+		{
+			case SCE_STTXT_NUMBER: {
+				if(!setNumber.Contains(sc.ch))
+					sc.SetState(SCE_STTXT_DEFAULT);
+				break;
+			}
+			case SCE_STTXT_HEXNUMBER: {
+				if (setHexNumber.Contains(sc.ch))
+					continue;
+				else if(setDataTime.Contains(sc.ch))
+					sc.ChangeState(SCE_STTXT_DATETIME);
+				else if(setWord.Contains(sc.ch))
+					sc.ChangeState(SCE_STTXT_DEFAULT);
+				else
+					sc.SetState(SCE_STTXT_DEFAULT);
+				break;
+			}
+			case SCE_STTXT_DATETIME: {
+				if (setDataTime.Contains(sc.ch))
+					continue;
+				else if(setWord.Contains(sc.ch))
+					sc.ChangeState(SCE_STTXT_DEFAULT);
+				else
+					sc.SetState(SCE_STTXT_DEFAULT);
+				break;
+			}
+			case SCE_STTXT_OPERATOR: {
+				sc.SetState(SCE_STTXT_DEFAULT);
+				break;
+			}
+			case SCE_STTXT_PRAGMA: {
+				if (sc.ch == '}')
+					sc.ForwardSetState(SCE_STTXT_DEFAULT);
+				break;
+			}
+			case SCE_STTXT_COMMENTLINE: {
+				if (sc.atLineStart)
+					sc.SetState(SCE_STTXT_DEFAULT);
+				break;
+			}
+			case SCE_STTXT_COMMENT: {
+				if(sc.Match('*',')'))
+				{
+					sc.Forward();
+					sc.ForwardSetState(SCE_STTXT_DEFAULT);
+				}
+				break;
+			}
+			case SCE_STTXT_STRING1: {
+				if(sc.atLineEnd)
+					sc.SetState(SCE_STTXT_STRINGEOL);
+				else if(sc.ch == '\'' && sc.chPrev != '$')
+					sc.ForwardSetState(SCE_STTXT_DEFAULT);
+				break;
+			}
+			case SCE_STTXT_STRING2: {
+				if (sc.atLineEnd)
+					sc.SetState(SCE_STTXT_STRINGEOL);
+				else if(sc.ch == '\"' && sc.chPrev != '$')
+					sc.ForwardSetState(SCE_STTXT_DEFAULT);
+				break;
+			}
+			case SCE_STTXT_STRINGEOL: {
+				if(sc.atLineStart)
+					sc.SetState(SCE_STTXT_DEFAULT);
+				break;
+			}
+			case SCE_STTXT_CHARACTER: {
+				if(setHexNumber.Contains(sc.ch))
+					sc.SetState(SCE_STTXT_HEXNUMBER);
+				else if(setDataTime.Contains(sc.ch))
+					sc.SetState(SCE_STTXT_DATETIME);
+				else sc.SetState(SCE_STTXT_DEFAULT);
+				break;
+			}
+			case SCE_STTXT_IDENTIFIER: {
+				if(!setWord.Contains(sc.ch))
+					ClassifySTTXTWord(keywordlists, sc);
+				break;
+			}
+		}
+
+		if(sc.state == SCE_STTXT_DEFAULT)
+		{
+			if(IsADigit(sc.ch))
+				sc.SetState(SCE_STTXT_NUMBER);
+			else if (setWordStart.Contains(sc.ch))
+				sc.SetState(SCE_STTXT_IDENTIFIER);
+			else if (sc.Match('/', '/'))
+				sc.SetState(SCE_STTXT_COMMENTLINE);
+			else if(sc.Match('(', '*'))
+				sc.SetState(SCE_STTXT_COMMENT);
+			else if (sc.ch == '{')
+				sc.SetState(SCE_STTXT_PRAGMA);
+			else if (sc.ch == '\'')
+				sc.SetState(SCE_STTXT_STRING1);
+			else if (sc.ch == '\"')
+				sc.SetState(SCE_STTXT_STRING2);
+			else if(sc.ch == '#')
+				sc.SetState(SCE_STTXT_CHARACTER);
+			else if (setOperator.Contains(sc.ch))
+				sc.SetState(SCE_STTXT_OPERATOR);
+		}
+ 	}
+
+	if (sc.state == SCE_STTXT_IDENTIFIER && setWord.Contains(sc.chPrev))
+		ClassifySTTXTWord(keywordlists, sc);
+
+	sc.Complete();
+}
+
+static const char * const STTXTWordListDesc[] = {
+	"Keywords",
+	"Types",
+	"Functions",
+	"FB",
+	"Local_Var",
+	"Local_Pragma",
+	0
+};
+
+static bool IsCommentLine(Sci_Position line, Accessor &styler, bool type)
+{
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eolPos = styler.LineStart(line + 1) - 1;
+
+	for (Sci_Position i = pos; i < eolPos; i++)
+	{
+		char ch = styler[i];
+		char chNext = styler.SafeGetCharAt(i + 1);
+		int style = styler.StyleAt(i);
+
+		if(type) {
+			 if (ch == '/' && chNext == '/' && style == SCE_STTXT_COMMENTLINE)
+				return true;
+		}
+		else if (ch == '(' && chNext == '*' && style == SCE_STTXT_COMMENT)
+			break;
+
+		if (!IsASpaceOrTab(ch))
+			return false;
+	}
+
+	for (Sci_Position i = eolPos-2; i>pos; i--)
+	{
+		char ch = styler[i];
+		char chPrev = styler.SafeGetCharAt(i-1);
+		int style = styler.StyleAt(i);
+
+		if(ch == ')' && chPrev == '*' && style == SCE_STTXT_COMMENT)
+			return true;
+		if(!IsASpaceOrTab(ch))
+			return false;
+	}
+
+	return false;
+}
+
+static bool IsPragmaLine(Sci_Position line, Accessor &styler)
+{
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eolPos = styler.LineStart(line+1) - 1;
+
+	for (Sci_Position i = pos ; i < eolPos ; i++)
+	{
+		char ch = styler[i];
+		int style = styler.StyleAt(i);
+
+		if(ch == '{' && style == SCE_STTXT_PRAGMA)
+			return true;
+		else if (!IsASpaceOrTab(ch))
+			return false;
+	}
+	return false;
+}
+
+static void GetRangeUpper(Sci_PositionU start,Sci_PositionU end,Accessor &styler,char *s,Sci_PositionU len)
+{
+	Sci_PositionU i = 0;
+	while ((i < end - start + 1) && (i < len-1)) {
+		s[i] = static_cast<char>(toupper(styler[start + i]));
+		i++;
+	}
+	s[i] = '\0';
+}
+
+static void ClassifySTTXTWordFoldPoint(int &levelCurrent,Sci_PositionU lastStart,
+									 Sci_PositionU currentPos, Accessor &styler)
+{
+	char s[256];
+	GetRangeUpper(lastStart, currentPos, styler, s, sizeof(s));
+
+	// See Table C.2 - Keywords
+	if (!strcmp(s, "ACTION") ||
+		!strcmp(s, "CASE") ||
+		!strcmp(s, "CONFIGURATION") ||
+		!strcmp(s, "FOR") ||
+		!strcmp(s, "FUNCTION") ||
+		!strcmp(s, "FUNCTION_BLOCK") ||
+		!strcmp(s, "IF") ||
+		!strcmp(s, "INITIAL_STEP") ||
+		!strcmp(s, "REPEAT") ||
+		!strcmp(s, "RESOURCE") ||
+		!strcmp(s, "STEP") ||
+		!strcmp(s, "STRUCT") ||
+		!strcmp(s, "TRANSITION") ||
+		!strcmp(s, "TYPE") ||
+		!strcmp(s, "VAR") ||
+		!strcmp(s, "VAR_INPUT") ||
+		!strcmp(s, "VAR_OUTPUT") ||
+		!strcmp(s, "VAR_IN_OUT") ||
+		!strcmp(s, "VAR_TEMP") ||
+		!strcmp(s, "VAR_EXTERNAL") ||
+		!strcmp(s, "VAR_ACCESS") ||
+		!strcmp(s, "VAR_CONFIG") ||
+		!strcmp(s, "VAR_GLOBAL") ||
+		!strcmp(s, "WHILE"))
+	{
+		levelCurrent++;
+	}
+	else if (!strcmp(s, "END_ACTION") ||
+		!strcmp(s, "END_CASE") ||
+		!strcmp(s, "END_CONFIGURATION") ||
+		!strcmp(s, "END_FOR") ||
+		!strcmp(s, "END_FUNCTION") ||
+		!strcmp(s, "END_FUNCTION_BLOCK") ||
+		!strcmp(s, "END_IF") ||
+		!strcmp(s, "END_REPEAT") ||
+		!strcmp(s, "END_RESOURCE") ||
+		!strcmp(s, "END_STEP") ||
+		!strcmp(s, "END_STRUCT") ||
+		!strcmp(s, "END_TRANSITION") ||
+		!strcmp(s, "END_TYPE") ||
+		!strcmp(s, "END_VAR") ||
+		!strcmp(s, "END_WHILE"))
+	{
+		levelCurrent--;
+		if (levelCurrent < SC_FOLDLEVELBASE) {
+			levelCurrent = SC_FOLDLEVELBASE;
+		}
+	}
+}
+
+static void FoldSTTXTDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[],Accessor &styler)
+{
+	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+	bool foldPreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0;
+	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
+	int levelCurrent = levelPrev;
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+	Sci_Position lastStart = 0;
+
+	CharacterSet setWord(CharacterSet::setAlphaNum, "_", 0x80, true);
+
+	for (Sci_PositionU i = startPos; i < endPos; i++)
+	{
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int stylePrev = style;
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+
+		if (foldComment && style == SCE_STTXT_COMMENT) {
+			if(stylePrev != SCE_STTXT_COMMENT)
+				levelCurrent++;
+			else if(styleNext != SCE_STTXT_COMMENT && !atEOL)
+				levelCurrent--;
+		}
+		if ( foldComment && atEOL && ( IsCommentLine(lineCurrent, styler,false)
+			|| IsCommentLine(lineCurrent,styler,true))) {
+ 			if(!IsCommentLine(lineCurrent-1, styler,true) && IsCommentLine(lineCurrent+1, styler,true))
+				levelCurrent++;
+			if (IsCommentLine(lineCurrent-1, styler,true) && !IsCommentLine(lineCurrent+1, styler,true))
+				levelCurrent--;
+			if (!IsCommentLine(lineCurrent-1, styler,false) && IsCommentLine(lineCurrent+1, styler,false))
+				levelCurrent++;
+			if (IsCommentLine(lineCurrent-1, styler,false) && !IsCommentLine(lineCurrent+1, styler,false))
+				levelCurrent--;
+		}
+		if(foldPreprocessor && atEOL && IsPragmaLine(lineCurrent, styler)) {
+			if(!IsPragmaLine(lineCurrent-1, styler) && IsPragmaLine(lineCurrent+1, styler ))
+				levelCurrent++;
+			else if(IsPragmaLine(lineCurrent-1, styler) && !IsPragmaLine(lineCurrent+1, styler))
+				levelCurrent--;
+		}
+		if (stylePrev != SCE_STTXT_KEYWORD && style == SCE_STTXT_KEYWORD) {
+				lastStart = i;
+		}
+		if(stylePrev == SCE_STTXT_KEYWORD) {
+			if(setWord.Contains(ch) && !setWord.Contains(chNext))
+				ClassifySTTXTWordFoldPoint(levelCurrent,lastStart, i, styler);
+		}
+		if (!IsASpace(ch)) {
+			visibleChars++;
+		}
+		if (atEOL) {
+			int lev = levelPrev;
+			if (visibleChars == 0 && foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if ((levelCurrent > levelPrev) && (visibleChars > 0))
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent))
+				styler.SetLevel(lineCurrent, lev);
+
+			lineCurrent++;
+			levelPrev = levelCurrent;
+			visibleChars = 0;
+		}
+
+		// If we didn't reach the EOL in previous loop, store line level and whitespace information.
+		// The rest will be filled in later...
+		int lev = levelPrev;
+		if (visibleChars == 0 && foldCompact)
+			lev |= SC_FOLDLEVELWHITEFLAG;
+		styler.SetLevel(lineCurrent, lev);
+	}
+}
+
+LexerModule lmSTTXT(SCLEX_STTXT, ColouriseSTTXTDoc, "fcST", FoldSTTXTDoc, STTXTWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexScriptol.cxx b/Pythonwin/Scintilla/lexers/LexScriptol.cxx
similarity index 84%
rename from Pythonwin/Scintilla/src/LexScriptol.cxx
rename to Pythonwin/Scintilla/lexers/LexScriptol.cxx
index 76c38e6b6..f82027aa3 100644
--- a/Pythonwin/Scintilla/src/LexScriptol.cxx
+++ b/Pythonwin/Scintilla/lexers/LexScriptol.cxx
@@ -5,27 +5,29 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
 
-#ifdef SCI_NAMESPACE
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
 using namespace Scintilla;
-#endif
 
-static void ClassifyWordSol(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler, char *prevWord)
+static void ClassifyWordSol(Sci_PositionU start, Sci_PositionU end, WordList &keywords, Accessor &styler, char *prevWord)
 {
-    char s[100];
+    char s[100] = "";
     bool wordIsNumber = isdigit(styler[start]) != 0;
-    for (unsigned int i = 0; i < end - start + 1 && i < 30; i++)
+    for (Sci_PositionU i = 0; i < end - start + 1 && i < 30; i++)
      {
            s[i] = styler[start + i];
            s[i + 1] = '\0';
@@ -34,7 +36,7 @@ static void ClassifyWordSol(unsigned int start, unsigned int end, WordList &keyw
     if (0 == strcmp(prevWord, "class"))       chAttr = SCE_SCRIPTOL_CLASSNAME;
     else if (wordIsNumber)                    chAttr = SCE_SCRIPTOL_NUMBER;
     else if (keywords.InList(s))              chAttr = SCE_SCRIPTOL_KEYWORD;
-    else for (unsigned int i = 0; i < end - start + 1; i++)  // test dotted idents
+    else for (Sci_PositionU i = 0; i < end - start + 1; i++)  // test dotted idents
     {
         if (styler[start + i] == '.')
         {
@@ -46,12 +48,11 @@ static void ClassifyWordSol(unsigned int start, unsigned int end, WordList &keyw
     strcpy(prevWord, s);
 }
 
-static bool IsSolComment(Accessor &styler, int pos, int len)
+static bool IsSolComment(Accessor &styler, Sci_Position pos, Sci_Position len)
 {
-   char c;
    if(len > 0)
    {
-     c = styler[pos];
+     char c = styler[pos];
      if(c == '`') return true;
      if(len > 1)
      {
@@ -78,7 +79,7 @@ static bool IsSolWordStart(char ch)
 }
 
 
-static int GetSolStringState(Accessor &styler, int i, int *nextIndex)
+static int GetSolStringState(Accessor &styler, Sci_Position i, Sci_Position *nextIndex)
 {
 	char ch = styler.SafeGetCharAt(i);
 	char chNext = styler.SafeGetCharAt(i + 1);
@@ -106,16 +107,16 @@ static int GetSolStringState(Accessor &styler, int i, int *nextIndex)
 }
 
 
-static void ColouriseSolDoc(unsigned int startPos, int length, int initStyle,
+static void ColouriseSolDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                             WordList *keywordlists[], Accessor &styler)
  {
 
-	int lengthDoc = startPos + length;
+	Sci_Position lengthDoc = startPos + length;
         char stringType = '\"';
 
 	if (startPos > 0)
         {
-            int lineCurrent = styler.GetLine(startPos);
+            Sci_Position lineCurrent = styler.GetLine(startPos);
             if (lineCurrent > 0)
             {
               startPos = styler.LineStart(lineCurrent-1);
@@ -124,53 +125,24 @@ static void ColouriseSolDoc(unsigned int startPos, int length, int initStyle,
             }
 	}
 
-	styler.StartAt(startPos, 127);
+	styler.StartAt(startPos);
 
 	WordList &keywords = *keywordlists[0];
 
-	int whingeLevel = styler.GetPropertyInt("tab.timmy.whinge.level");
 	char prevWord[200];
 	prevWord[0] = '\0';
         if (length == 0)  return;
 
 	int state = initStyle & 31;
 
-	int nextIndex = 0;
+	Sci_Position nextIndex = 0;
         char chPrev  = ' ';
         char chPrev2 = ' ';
         char chNext  = styler[startPos];
 	styler.StartSegment(startPos);
-	bool atStartLine = true;
-	int spaceFlags = 0;
-	for (int i = startPos; i < lengthDoc; i++)
+	for (Sci_Position i = startPos; i < lengthDoc; i++)
         {
 
-         if (atStartLine)
-         {
-         char chBad = static_cast<char>(64);
-         char chGood = static_cast<char>(0);
-         char chFlags = chGood;
-
-         if (whingeLevel == 1)
-         {
-             chFlags = (spaceFlags & wsInconsistent) ? chBad : chGood;
-         }
-         else if (whingeLevel == 2)
-         {
-             chFlags = (spaceFlags & wsSpaceTab) ? chBad : chGood;
-         }
-         else if (whingeLevel == 3)
-         {
-             chFlags = (spaceFlags & wsSpace) ? chBad : chGood;
-         }
-         else if (whingeLevel == 4)
-         {
-              chFlags = (spaceFlags & wsTab) ? chBad : chGood;
-         }
-         styler.SetFlags(chFlags, static_cast<char>(state));
-         atStartLine = false;
-       }
-
        char ch = chNext;
        chNext = styler.SafeGetCharAt(i + 1);
 
@@ -182,7 +154,6 @@ static void ColouriseSolDoc(unsigned int startPos, int length, int initStyle,
           {
               styler.ColourTo(i, state);
           }
-          atStartLine = true;
         }
 
         if (styler.IsLeadByte(ch))
@@ -328,7 +299,7 @@ static void ColouriseSolDoc(unsigned int startPos, int length, int initStyle,
                     state = SCE_SCRIPTOL_DEFAULT;
                  }
              }
-            
+
            }
           chPrev2 = chPrev;
           chPrev = ch;
@@ -344,12 +315,12 @@ static void ColouriseSolDoc(unsigned int startPos, int length, int initStyle,
 	}
 }
 
-static void FoldSolDoc(unsigned int startPos, int length, int initStyle,
+static void FoldSolDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
 						   WordList *[], Accessor &styler)
  {
-	int lengthDoc = startPos + length;
+	Sci_Position lengthDoc = startPos + length;
 
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	if (startPos > 0)
         {
           if (lineCurrent > 0)
@@ -365,10 +336,10 @@ static void FoldSolDoc(unsigned int startPos, int length, int initStyle,
 	int state = initStyle & 31;
 	int spaceFlags = 0;
         int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, IsSolComment);
-        if ((state == SCE_SCRIPTOL_TRIPLE))
+        if (state == SCE_SCRIPTOL_TRIPLE)
              indentCurrent |= SC_FOLDLEVELWHITEFLAG;
 	char chNext = styler[startPos];
-	for (int i = startPos; i < lengthDoc; i++)
+	for (Sci_Position i = startPos; i < lengthDoc; i++)
          {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
diff --git a/Pythonwin/Scintilla/src/LexSmalltalk.cxx b/Pythonwin/Scintilla/lexers/LexSmalltalk.cxx
similarity index 95%
rename from Pythonwin/Scintilla/src/LexSmalltalk.cxx
rename to Pythonwin/Scintilla/lexers/LexSmalltalk.cxx
index 265de3803..bd146d59c 100644
--- a/Pythonwin/Scintilla/src/LexSmalltalk.cxx
+++ b/Pythonwin/Scintilla/lexers/LexSmalltalk.cxx
@@ -8,20 +8,23 @@
 
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
 #include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 /*
 | lexTable classificationBlock charClasses |
@@ -39,7 +42,7 @@ classificationBlock
     value: #BinSel value: '~@%&*-+=|\/,<>?!';
     value: #Upper value: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.
 
-((String new: 500) streamContents: [ :stream |            
+((String new: 500) streamContents: [ :stream |
     stream crLf; nextPutAll: 'static int ClassificationTable[256] = {'.
     lexTable keysAndValuesDo: [ :index :value |
         ((index - 1) rem: 16) == 0 ifTrue: [
@@ -50,7 +53,7 @@ classificationBlock
         index ~= 256 ifTrue: [
             stream nextPut: $,]].
     stream crLf; nextPutAll: '};'; crLf.
-    
+
     charClasses keysAndValuesDo: [ :index :name |
         stream
             crLf;
@@ -95,7 +98,7 @@ static inline bool isDigitOfRadix(int ch, int radix)
 }
 
 static inline void skipComment(StyleContext& sc)
-{    
+{
     while (sc.More() && sc.ch != '\"')
         sc.Forward();
 }
@@ -118,7 +121,7 @@ static void handleHash(StyleContext& sc)
         sc.SetState(SCE_ST_SPECIAL);
         return;
     }
-    
+
     sc.SetState(SCE_ST_SYMBOL);
     sc.Forward();
     if (sc.ch == '\'') {
@@ -162,7 +165,7 @@ static void handleNumeric(StyleContext& sc)
     char num[256];
     int nl;
     int radix;
-    
+
     sc.SetState(SCE_ST_NUMBER);
     num[0] = static_cast<char>(sc.ch);
     nl = 1;
@@ -217,7 +220,7 @@ static void handleLetter(StyleContext& sc, WordList* specialSelectorList)
     int il;
     int state;
     bool doubleColonPresent;
-    
+
     sc.SetState(SCE_ST_DEFAULT);
 
     ident[0] = static_cast<char>(sc.ch);
@@ -237,7 +240,7 @@ static void handleLetter(StyleContext& sc, WordList* specialSelectorList)
     else
         doubleColonPresent = false;
     ident[il] = 0;
-    
+
     if (specialSelectorList->InList(ident))
             state = SCE_ST_SPEC_SEL;
     else if (doubleColonPresent)
@@ -256,11 +259,11 @@ static void handleLetter(StyleContext& sc, WordList* specialSelectorList)
         else
             state = SCE_ST_DEFAULT;
     }
-    
+
     sc.ChangeState(state);
 }
 
-static void colorizeSmalltalkDoc(unsigned int startPos, int length, int initStyle, WordList *wordLists[], Accessor &styler)
+static void colorizeSmalltalkDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *wordLists[], Accessor &styler)
 {
     StyleContext sc(startPos, length, initStyle, styler);
 
@@ -277,7 +280,7 @@ static void colorizeSmalltalkDoc(unsigned int startPos, int length, int initStyl
 
     for (; sc.More(); sc.Forward()) {
         int ch;
-        
+
         ch = sc.ch;
         if (ch == '\"') {
             sc.SetState(SCE_ST_COMMENT);
diff --git a/Pythonwin/Scintilla/lexers/LexSorcus.cxx b/Pythonwin/Scintilla/lexers/LexSorcus.cxx
new file mode 100644
index 000000000..66669dc8c
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexSorcus.cxx
@@ -0,0 +1,206 @@
+// Scintilla source code edit control
+/** @file LexSorcus.cxx
+** Lexer for SORCUS installation files
+** Written by Eugen Bitter and Christoph Baumann at SORCUS Computer, Heidelberg Germany
+** Based on the ASM Lexer by The Black Horus
+**/
+
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+
+//each character a..z and A..Z + '_' can be part of a keyword
+//additionally numbers that follow 'M' can be contained in a keyword
+static inline bool IsSWordStart(const int ch, const int prev_ch)
+{
+    if (isalpha(ch) || (ch == '_') || ((isdigit(ch)) && (prev_ch == 'M')))
+        return true;
+
+    return false;
+}
+
+
+//only digits that are not preceded by 'M' count as a number
+static inline bool IsSorcusNumber(const int ch, const int prev_ch)
+{
+    if ((isdigit(ch)) && (prev_ch != 'M'))
+        return true;
+
+    return false;
+}
+
+
+//only = is a valid operator
+static inline bool IsSorcusOperator(const int ch)
+{
+    if (ch == '=')
+        return true;
+
+    return false;
+}
+
+
+static void ColouriseSorcusDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+                               Accessor &styler)
+{
+
+    WordList &Command = *keywordlists[0];
+    WordList &Parameter = *keywordlists[1];
+    WordList &Constant = *keywordlists[2];
+
+    // Do not leak onto next line
+    if (initStyle == SCE_SORCUS_STRINGEOL)
+        initStyle = SCE_SORCUS_DEFAULT;
+
+    StyleContext sc(startPos, length, initStyle, styler);
+
+    for (; sc.More(); sc.Forward())
+    {
+
+        // Prevent SCE_SORCUS_STRINGEOL from leaking back to previous line
+        if (sc.atLineStart && (sc.state == SCE_SORCUS_STRING))
+        {
+            sc.SetState(SCE_SORCUS_STRING);
+        }
+
+        // Determine if the current state should terminate.
+        if (sc.state == SCE_SORCUS_OPERATOR)
+        {
+            if (!IsSorcusOperator(sc.ch))
+            {
+                sc.SetState(SCE_SORCUS_DEFAULT);
+            }
+        }
+        else if(sc.state == SCE_SORCUS_NUMBER)
+        {
+            if(!IsSorcusNumber(sc.ch, sc.chPrev))
+            {
+                sc.SetState(SCE_SORCUS_DEFAULT);
+            }
+        }
+        else if (sc.state == SCE_SORCUS_IDENTIFIER)
+        {
+            if (!IsSWordStart(sc.ch, sc.chPrev))
+            {
+                char s[100];
+
+                sc.GetCurrent(s, sizeof(s));
+
+                if (Command.InList(s))
+                {
+                    sc.ChangeState(SCE_SORCUS_COMMAND);
+                }
+                else if (Parameter.InList(s))
+                {
+                    sc.ChangeState(SCE_SORCUS_PARAMETER);
+                }
+                else if (Constant.InList(s))
+                {
+                    sc.ChangeState(SCE_SORCUS_CONSTANT);
+                }
+
+                sc.SetState(SCE_SORCUS_DEFAULT);
+            }
+        }
+        else if (sc.state == SCE_SORCUS_COMMENTLINE )
+        {
+            if (sc.atLineEnd)
+            {
+                sc.SetState(SCE_SORCUS_DEFAULT);
+            }
+        }
+        else if (sc.state == SCE_SORCUS_STRING)
+        {
+            if (sc.ch == '\"')
+            {
+                sc.ForwardSetState(SCE_SORCUS_DEFAULT);
+            }
+            else if (sc.atLineEnd)
+            {
+                sc.ChangeState(SCE_SORCUS_STRINGEOL);
+                sc.ForwardSetState(SCE_SORCUS_DEFAULT);
+            }
+        }
+
+        // Determine if a new state should be entered.
+        if (sc.state == SCE_SORCUS_DEFAULT)
+        {
+            if ((sc.ch == ';') || (sc.ch == '\''))
+            {
+                sc.SetState(SCE_SORCUS_COMMENTLINE);
+            }
+            else if (IsSWordStart(sc.ch, sc.chPrev))
+            {
+                sc.SetState(SCE_SORCUS_IDENTIFIER);
+            }
+            else if (sc.ch == '\"')
+            {
+                sc.SetState(SCE_SORCUS_STRING);
+            }
+            else if (IsSorcusOperator(sc.ch))
+            {
+                sc.SetState(SCE_SORCUS_OPERATOR);
+            }
+            else if (IsSorcusNumber(sc.ch, sc.chPrev))
+            {
+                sc.SetState(SCE_SORCUS_NUMBER);
+            }
+        }
+
+    }
+    sc.Complete();
+}
+
+
+static const char* const SorcusWordListDesc[] = {"Command","Parameter", "Constant", 0};
+
+LexerModule lmSorc(SCLEX_SORCUS, ColouriseSorcusDoc, "sorcins", 0, SorcusWordListDesc);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Pythonwin/Scintilla/src/LexSpecman.cxx b/Pythonwin/Scintilla/lexers/LexSpecman.cxx
similarity index 92%
rename from Pythonwin/Scintilla/src/LexSpecman.cxx
rename to Pythonwin/Scintilla/lexers/LexSpecman.cxx
index 093efae75..5a4c9105f 100644
--- a/Pythonwin/Scintilla/src/LexSpecman.cxx
+++ b/Pythonwin/Scintilla/lexers/LexSpecman.cxx
@@ -8,22 +8,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static inline bool IsAWordChar(const int ch) {
 	return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_' || ch == '\'');
@@ -37,7 +38,7 @@ static inline bool IsAWordStart(const int ch) {
 	return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '`');
 }
 
-static void ColouriseSpecmanDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
+static void ColouriseSpecmanDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
                             Accessor &styler, bool caseSensitive) {
 
 	WordList &keywords = *keywordlists[0];
@@ -197,14 +198,14 @@ static void ColouriseSpecmanDoc(unsigned int startPos, int length, int initStyle
 // Store both the current line's fold level and the next lines in the
 // level store to make it easy to pick up with each increment
 // and to make it possible to fiddle the current level for "} else {".
-static void FoldNoBoxSpecmanDoc(unsigned int startPos, int length, int,
+static void FoldNoBoxSpecmanDoc(Sci_PositionU startPos, Sci_Position length, int,
                             Accessor &styler) {
 	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
 	bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0;
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelCurrent = SC_FOLDLEVELBASE;
 	if (lineCurrent > 0)
 		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
@@ -213,7 +214,7 @@ static void FoldNoBoxSpecmanDoc(unsigned int startPos, int length, int,
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
 	int style;
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		//int stylePrev = style;
@@ -266,7 +267,7 @@ static void FoldNoBoxSpecmanDoc(unsigned int startPos, int length, int,
 	}
 }
 
-static void FoldSpecmanDoc(unsigned int startPos, int length, int initStyle, WordList *[],
+static void FoldSpecmanDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[],
                        Accessor &styler) {
 	FoldNoBoxSpecmanDoc(startPos, length, initStyle, styler);
 }
@@ -280,7 +281,7 @@ static const char * const specmanWordLists[] = {
             0,
         };
 
-static void ColouriseSpecmanDocSensitive(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
+static void ColouriseSpecmanDocSensitive(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
                                      Accessor &styler) {
 	ColouriseSpecmanDoc(startPos, length, initStyle, keywordlists, styler, true);
 }
diff --git a/Pythonwin/Scintilla/src/LexSpice.cxx b/Pythonwin/Scintilla/lexers/LexSpice.cxx
similarity index 84%
rename from Pythonwin/Scintilla/src/LexSpice.cxx
rename to Pythonwin/Scintilla/lexers/LexSpice.cxx
index b2953c001..9c21da308 100644
--- a/Pythonwin/Scintilla/src/LexSpice.cxx
+++ b/Pythonwin/Scintilla/lexers/LexSpice.cxx
@@ -6,30 +6,34 @@
 // The License.txt file describes the conditions under which this software may be distributed.
 
 #include <stdlib.h>
-#include <ctype.h>
 #include <string.h>
 #include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include <string>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "PropSet.h"
-#include "KeyWords.h"
-#include "SciLexer.h"
-#include "SString.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 /*
  * Interface
  */
 
 static void ColouriseDocument(
-    unsigned int startPos,
-    int length,
+    Sci_PositionU startPos,
+    Sci_Position length,
     int initStyle,
     WordList *keywordlists[],
     Accessor &styler);
@@ -54,11 +58,7 @@ static void ColouriseWhiteSpace(StyleContext& sc, bool& apostropheStartsAttribut
 static void ColouriseWord(StyleContext& sc, WordList& keywords, WordList& keywords2, WordList& keywords3, bool& apostropheStartsAttribute);
 
 static inline bool IsDelimiterCharacter(int ch);
-static inline bool IsNumberStartCharacter(int ch);
-static inline bool IsNumberCharacter(int ch);
 static inline bool IsSeparatorOrDelimiterCharacter(int ch);
-static inline bool IsWordStartCharacter(int ch);
-static inline bool IsWordCharacter(int ch);
 
 static void ColouriseComment(StyleContext& sc, bool&) {
     sc.SetState(SCE_SPICE_COMMENTLINE);
@@ -75,7 +75,7 @@ static void ColouriseDelimiter(StyleContext& sc, bool& apostropheStartsAttribute
 
 static void ColouriseNumber(StyleContext& sc, bool& apostropheStartsAttribute) {
     apostropheStartsAttribute = true;
-    SString number;
+    std::string number;
     sc.SetState(SCE_SPICE_NUMBER);
     // Get all characters up to a delimiter or a separator, including points, but excluding
     // double points (ranges).
@@ -104,7 +104,7 @@ static void ColouriseWhiteSpace(StyleContext& sc, bool& ) {
 static void ColouriseWord(StyleContext& sc, WordList& keywords, WordList& keywords2, WordList& keywords3, bool& apostropheStartsAttribute) {
     apostropheStartsAttribute = true;
     sc.SetState(SCE_SPICE_IDENTIFIER);
-    SString word;
+    std::string word;
     while (!sc.atLineEnd && !IsSeparatorOrDelimiterCharacter(sc.ch)) {
         word += static_cast<char>(tolower(sc.ch));
         sc.Forward();
@@ -134,8 +134,8 @@ static void ColouriseWord(StyleContext& sc, WordList& keywords, WordList& keywor
 // ColouriseDocument
 //
 static void ColouriseDocument(
-    unsigned int startPos,
-    int length,
+    Sci_PositionU startPos,
+    Sci_Position length,
     int initStyle,
     WordList *keywordlists[],
     Accessor &styler) {
@@ -143,7 +143,7 @@ static void ColouriseDocument(
     WordList &keywords2 = *keywordlists[1];
     WordList &keywords3 = *keywordlists[2];
     StyleContext sc(startPos, length, initStyle, styler);
-    int lineCurrent = styler.GetLine(startPos);
+    Sci_Position lineCurrent = styler.GetLine(startPos);
     bool apostropheStartsAttribute = (styler.GetLineState(lineCurrent) & 1) != 0;
     while (sc.More()) {
         if (sc.atLineEnd) {
@@ -199,27 +199,6 @@ static inline bool IsDelimiterCharacter(int ch) {
     }
 }
 
-static inline bool IsNumberCharacter(int ch) {
-    return IsNumberStartCharacter(ch) ||
-           ch == '_' ||
-           ch == '.' ||
-           ch == '#' ||
-           (ch >= 'a' && ch <= 'f') ||
-           (ch >= 'A' && ch <= 'F');
-}
-
-static inline bool IsNumberStartCharacter(int ch) {
-    return IsADigit(ch);
-}
-
 static inline bool IsSeparatorOrDelimiterCharacter(int ch) {
     return IsASpace(ch) || IsDelimiterCharacter(ch);
 }
-
-static inline bool IsWordCharacter(int ch) {
-    return IsWordStartCharacter(ch) || IsADigit(ch);
-}
-
-static inline bool IsWordStartCharacter(int ch) {
-    return (isascii(ch) && isalpha(ch)) || ch == '_';
-}
diff --git a/Pythonwin/Scintilla/lexers/LexStata.cxx b/Pythonwin/Scintilla/lexers/LexStata.cxx
new file mode 100644
index 000000000..78410c627
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexStata.cxx
@@ -0,0 +1,203 @@
+// Scintilla source code edit control
+/** @file LexStata.cxx
+ ** Lexer for Stata
+ **/
+// Author: Luke Rasmussen (luke.rasmussen@gmail.com)
+//
+// The License.txt file describes the conditions under which this software may
+// be distributed.
+//
+// Developed as part of the StatTag project at Northwestern University Feinberg
+// School of Medicine with funding from Northwestern University Clinical and
+// Translational Sciences Institute through CTSA grant UL1TR001422.  This work
+// has not been reviewed or endorsed by NCATS or the NIH.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+static void ColouriseStataDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+    Accessor &styler) {
+
+    WordList &keywords = *keywordlists[0];
+    WordList &types = *keywordlists[1];
+    
+    CharacterSet setCouldBePostOp(CharacterSet::setNone, "+-");
+    CharacterSet setWordStart(CharacterSet::setAlpha, "_", 0x80, true);
+    CharacterSet setWord(CharacterSet::setAlphaNum, "._", 0x80, true);
+
+    StyleContext sc(startPos, length, initStyle, styler);
+    bool lineHasNonCommentChar = false;
+    for (; sc.More(); sc.Forward()) {
+        if (sc.atLineStart) {
+          lineHasNonCommentChar = false;
+        }
+
+        // Determine if the current state should terminate.
+        switch (sc.state) {
+            case SCE_STATA_OPERATOR:
+                sc.SetState(SCE_STATA_DEFAULT);
+                break;
+            case SCE_STATA_NUMBER:
+                // We accept almost anything because of hex. and number suffixes
+                if (!setWord.Contains(sc.ch)) {
+                    sc.SetState(SCE_STATA_DEFAULT);
+                }
+                break;
+            case SCE_STATA_IDENTIFIER:
+                if (!setWord.Contains(sc.ch) || (sc.ch == '.')) {
+                    char s[1000];
+                    sc.GetCurrent(s, sizeof(s));
+                    if (keywords.InList(s)) {
+                        sc.ChangeState(SCE_STATA_WORD);
+                    }
+                    else if (types.InList(s)) {
+                        sc.ChangeState(SCE_STATA_TYPE);
+                    }
+                    sc.SetState(SCE_STATA_DEFAULT);
+                }
+                break;
+            case SCE_STATA_COMMENTBLOCK:
+                if (sc.Match('*', '/')) {
+                    sc.Forward();
+                    sc.ForwardSetState(SCE_STATA_DEFAULT);
+                }
+                break;
+            case SCE_STATA_COMMENT:
+            case SCE_STATA_COMMENTLINE:
+                if (sc.atLineStart) {
+                    sc.SetState(SCE_STATA_DEFAULT);
+                }
+                break;
+            case SCE_STATA_STRING:
+                if (sc.ch == '\\') {
+                    // Per Stata documentation, the following characters are the only ones that can
+                    // be escaped (not our typical set of quotes, etc.):
+                    // https://www.stata.com/support/faqs/programming/backslashes-and-macros/
+                    if (sc.chNext == '$' || sc.chNext == '`' || sc.chNext == '\\') {
+                        sc.Forward();
+                    }
+                }
+                else if (sc.ch == '\"') {
+                    sc.ForwardSetState(SCE_STATA_DEFAULT);
+                }
+                break;
+        }
+
+        // Determine if a new state should be entered.
+        if (sc.state == SCE_STATA_DEFAULT) {
+            if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
+                lineHasNonCommentChar = true;
+                sc.SetState(SCE_STATA_NUMBER);
+            }
+            else if (setWordStart.Contains(sc.ch)) {
+                lineHasNonCommentChar = true;
+                sc.SetState(SCE_STATA_IDENTIFIER);
+            }
+            else if (sc.Match('*') && !lineHasNonCommentChar) {
+                sc.SetState(SCE_STATA_COMMENT);
+            }
+            else if (sc.Match('/', '*')) {
+                sc.SetState(SCE_STATA_COMMENTBLOCK);
+                sc.Forward();	// Eat the * so it isn't used for the end of the comment
+            }
+            else if (sc.Match('/', '/')) {
+                sc.SetState(SCE_STATA_COMMENTLINE);
+            }
+            else if (sc.ch == '\"') {
+                lineHasNonCommentChar = true;
+                sc.SetState(SCE_STATA_STRING);
+            }
+            else if (isoperator(sc.ch)) {
+                lineHasNonCommentChar = true;
+                sc.SetState(SCE_STATA_OPERATOR);
+            }
+        }
+    }
+
+    sc.Complete();
+}
+
+// Store both the current line's fold level and the next lines in the
+// level store to make it easy to pick up with each increment
+// and to make it possible to fiddle the current level for "} else {".
+static void FoldStataDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[],
+    Accessor &styler) {
+    bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+    bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0;
+    Sci_PositionU endPos = startPos + length;
+    int visibleChars = 0;
+    Sci_Position lineCurrent = styler.GetLine(startPos);
+    int levelCurrent = SC_FOLDLEVELBASE;
+    if (lineCurrent > 0)
+        levelCurrent = styler.LevelAt(lineCurrent - 1) >> 16;
+    int levelMinCurrent = levelCurrent;
+    int levelNext = levelCurrent;
+    char chNext = styler[startPos];
+    int styleNext = styler.StyleAt(startPos);
+    for (Sci_PositionU i = startPos; i < endPos; i++) {
+        char ch = chNext;
+        chNext = styler.SafeGetCharAt(i + 1);
+        int style = styleNext;
+        styleNext = styler.StyleAt(i + 1);
+        bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+        if (style == SCE_R_OPERATOR) {
+            if (ch == '{') {
+                // Measure the minimum before a '{' to allow
+                // folding on "} else {"
+                if (levelMinCurrent > levelNext) {
+                    levelMinCurrent = levelNext;
+                }
+                levelNext++;
+            }
+            else if (ch == '}') {
+                levelNext--;
+            }
+        }
+        if (atEOL) {
+            int levelUse = levelCurrent;
+            if (foldAtElse) {
+                levelUse = levelMinCurrent;
+            }
+            int lev = levelUse | levelNext << 16;
+            if (visibleChars == 0 && foldCompact)
+                lev |= SC_FOLDLEVELWHITEFLAG;
+            if (levelUse < levelNext)
+                lev |= SC_FOLDLEVELHEADERFLAG;
+            if (lev != styler.LevelAt(lineCurrent)) {
+                styler.SetLevel(lineCurrent, lev);
+            }
+            lineCurrent++;
+            levelCurrent = levelNext;
+            levelMinCurrent = levelCurrent;
+            visibleChars = 0;
+        }
+        if (!isspacechar(ch))
+            visibleChars++;
+    }
+}
+
+
+static const char * const StataWordLists[] = {
+    "Language Keywords",
+    "Types",
+    0,
+};
+
+LexerModule lmStata(SCLEX_STATA, ColouriseStataDoc, "stata", FoldStataDoc, StataWordLists);
diff --git a/Pythonwin/Scintilla/lexers/LexTACL.cxx b/Pythonwin/Scintilla/lexers/LexTACL.cxx
new file mode 100644
index 000000000..56cd96b01
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexTACL.cxx
@@ -0,0 +1,398 @@
+// Scintilla source code edit control
+/** @file LexTACL.cxx
+ ** Lexer for TACL
+ ** Based on LexPascal.cxx
+ ** Written by Laurent le Tynevez
+ ** Updated by Simon Steele <s.steele@pnotepad.org> September 2002
+ ** Updated by Mathias Rauen <scite@madshi.net> May 2003 (Delphi adjustments)
+ ** Updated by Rod Falck, Aug 2006 Converted to TACL
+ **/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+inline bool isTACLoperator(char ch)
+	{
+	return ch == '\'' || isoperator(ch);
+	}
+
+inline bool isTACLwordchar(char ch)
+	{
+	return ch == '#' || ch == '^' || ch == '|' || ch == '_' || iswordchar(ch);
+	}
+
+inline bool isTACLwordstart(char ch)
+	{
+	return ch == '#' || ch == '|' || ch == '_' || iswordstart(ch);
+	}
+
+static void getRange(Sci_PositionU start,
+		Sci_PositionU end,
+		Accessor &styler,
+		char *s,
+		Sci_PositionU len) {
+	Sci_PositionU i = 0;
+	while ((i < end - start + 1) && (i < len-1)) {
+		s[i] = static_cast<char>(tolower(styler[start + i]));
+		i++;
+	}
+	s[i] = '\0';
+}
+
+static bool IsStreamCommentStyle(int style) {
+	return style == SCE_C_COMMENT ||
+		style == SCE_C_COMMENTDOC ||
+		style == SCE_C_COMMENTDOCKEYWORD ||
+		style == SCE_C_COMMENTDOCKEYWORDERROR;
+}
+
+static void ColourTo(Accessor &styler, Sci_PositionU end, unsigned int attr, bool bInAsm) {
+	if ((bInAsm) && (attr == SCE_C_OPERATOR || attr == SCE_C_NUMBER || attr == SCE_C_DEFAULT || attr == SCE_C_WORD || attr == SCE_C_IDENTIFIER)) {
+		styler.ColourTo(end, SCE_C_REGEX);
+	} else
+		styler.ColourTo(end, attr);
+}
+
+// returns 1 if the item starts a class definition, and -1 if the word is "end", and 2 if the word is "asm"
+static int classifyWordTACL(Sci_PositionU start, Sci_PositionU end, /*WordList &keywords*/WordList *keywordlists[], Accessor &styler, bool bInAsm) {
+	int ret = 0;
+
+	WordList& keywords = *keywordlists[0];
+	WordList& builtins = *keywordlists[1];
+	WordList& commands = *keywordlists[2];
+
+	char s[100];
+	getRange(start, end, styler, s, sizeof(s));
+
+	char chAttr = SCE_C_IDENTIFIER;
+	if (isdigit(s[0]) || (s[0] == '.')) {
+		chAttr = SCE_C_NUMBER;
+	}
+	else {
+		if (s[0] == '#' || keywords.InList(s)) {
+			chAttr = SCE_C_WORD;
+
+			if (strcmp(s, "asm") == 0) {
+				ret = 2;
+			}
+			else if (strcmp(s, "end") == 0) {
+				ret = -1;
+			}
+		}
+		else if (s[0] == '|' || builtins.InList(s)) {
+			chAttr = SCE_C_WORD2;
+		}
+		else if (commands.InList(s)) {
+			chAttr = SCE_C_UUID;
+		}
+		else if (strcmp(s, "comment") == 0) {
+			chAttr = SCE_C_COMMENTLINE;
+			ret = 3;
+		}
+	}
+	ColourTo(styler, end, chAttr, (bInAsm && ret != -1));
+	return ret;
+}
+
+static int classifyFoldPointTACL(const char* s) {
+	int lev = 0;
+	if (s[0] == '[')
+		lev=1;
+	else if (s[0] == ']')
+		lev=-1;
+	return lev;
+}
+
+static void ColouriseTACLDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
+	Accessor &styler) {
+
+	styler.StartAt(startPos);
+
+	int state = initStyle;
+	if (state == SCE_C_CHARACTER)	// Does not leak onto next line
+		state = SCE_C_DEFAULT;
+	char chPrev = ' ';
+	char chNext = styler[startPos];
+	Sci_PositionU lengthDoc = startPos + length;
+
+	bool bInClassDefinition;
+
+	Sci_Position currentLine = styler.GetLine(startPos);
+	if (currentLine > 0) {
+		styler.SetLineState(currentLine, styler.GetLineState(currentLine-1));
+		bInClassDefinition = (styler.GetLineState(currentLine) == 1);
+	} else {
+		styler.SetLineState(currentLine, 0);
+		bInClassDefinition = false;
+	}
+
+	bool bInAsm = (state == SCE_C_REGEX);
+	if (bInAsm)
+		state = SCE_C_DEFAULT;
+
+	styler.StartSegment(startPos);
+	int visibleChars = 0;
+	Sci_PositionU i;
+	for (i = startPos; i < lengthDoc; i++) {
+		char ch = chNext;
+
+		chNext = styler.SafeGetCharAt(i + 1);
+
+		if ((ch == '\r' && chNext != '\n') || (ch == '\n')) {
+			// Trigger on CR only (Mac style) or either on LF from CR+LF (Dos/Win) or on LF alone (Unix)
+			// Avoid triggering two times on Dos/Win
+			// End of line
+			if (state == SCE_C_CHARACTER) {
+				ColourTo(styler, i, state, bInAsm);
+				state = SCE_C_DEFAULT;
+			}
+			visibleChars = 0;
+			currentLine++;
+			styler.SetLineState(currentLine, (bInClassDefinition ? 1 : 0));
+		}
+
+		if (styler.IsLeadByte(ch)) {
+			chNext = styler.SafeGetCharAt(i + 2);
+			chPrev = ' ';
+			i += 1;
+			continue;
+		}
+
+		if (state == SCE_C_DEFAULT) {
+			if (isTACLwordstart(ch)) {
+				ColourTo(styler, i-1, state, bInAsm);
+				state = SCE_C_IDENTIFIER;
+			} else if (ch == '{') {
+				ColourTo(styler, i-1, state, bInAsm);
+				state = SCE_C_COMMENT;
+			} else if (ch == '{' && chNext == '*') {
+				ColourTo(styler, i-1, state, bInAsm);
+				state = SCE_C_COMMENTDOC;
+			} else if (ch == '=' && chNext == '=') {
+				ColourTo(styler, i-1, state, bInAsm);
+				state = SCE_C_COMMENTLINE;
+			} else if (ch == '"') {
+				ColourTo(styler, i-1, state, bInAsm);
+				state = SCE_C_STRING;
+			} else if (ch == '?' && visibleChars == 0) {
+				ColourTo(styler, i-1, state, bInAsm);
+				state = SCE_C_PREPROCESSOR;
+			} else if (isTACLoperator(ch)) {
+				ColourTo(styler, i-1, state, bInAsm);
+				ColourTo(styler, i, SCE_C_OPERATOR, bInAsm);
+			}
+		} else if (state == SCE_C_IDENTIFIER) {
+			if (!isTACLwordchar(ch)) {
+				int lStateChange = classifyWordTACL(styler.GetStartSegment(), i - 1, keywordlists, styler, bInAsm);
+
+				if(lStateChange == 1) {
+					styler.SetLineState(currentLine, 1);
+					bInClassDefinition = true;
+				} else if(lStateChange == 2) {
+					bInAsm = true;
+				} else if(lStateChange == -1) {
+					styler.SetLineState(currentLine, 0);
+					bInClassDefinition = false;
+					bInAsm = false;
+				}
+
+				if (lStateChange == 3) {
+					 state = SCE_C_COMMENTLINE;
+				}
+				else {
+					state = SCE_C_DEFAULT;
+					chNext = styler.SafeGetCharAt(i + 1);
+					if (ch == '{') {
+						state = SCE_C_COMMENT;
+					} else if (ch == '{' && chNext == '*') {
+						ColourTo(styler, i-1, state, bInAsm);
+						state = SCE_C_COMMENTDOC;
+					} else if (ch == '=' && chNext == '=') {
+						state = SCE_C_COMMENTLINE;
+					} else if (ch == '"') {
+						state = SCE_C_STRING;
+					} else if (isTACLoperator(ch)) {
+						ColourTo(styler, i, SCE_C_OPERATOR, bInAsm);
+					}
+				}
+			}
+		} else {
+			if (state == SCE_C_PREPROCESSOR) {
+				if ((ch == '\r' || ch == '\n') && !(chPrev == '\\' || chPrev == '\r')) {
+					ColourTo(styler, i-1, state, bInAsm);
+					state = SCE_C_DEFAULT;
+				}
+			} else if (state == SCE_C_COMMENT) {
+				if (ch == '}' || (ch == '\r' || ch == '\n') ) {
+					ColourTo(styler, i, state, bInAsm);
+					state = SCE_C_DEFAULT;
+				}
+			} else if (state == SCE_C_COMMENTDOC) {
+				if (ch == '}' || (ch == '\r' || ch == '\n')) {
+					if (((i > styler.GetStartSegment() + 2) || (
+						(initStyle == SCE_C_COMMENTDOC) &&
+						(styler.GetStartSegment() == static_cast<Sci_PositionU>(startPos))))) {
+							ColourTo(styler, i, state, bInAsm);
+							state = SCE_C_DEFAULT;
+					}
+				}
+			} else if (state == SCE_C_COMMENTLINE) {
+				if (ch == '\r' || ch == '\n') {
+					ColourTo(styler, i-1, state, bInAsm);
+					state = SCE_C_DEFAULT;
+				}
+			} else if (state == SCE_C_STRING) {
+				if (ch == '"' || ch == '\r' || ch == '\n') {
+					ColourTo(styler, i, state, bInAsm);
+					state = SCE_C_DEFAULT;
+				}
+			}
+		}
+        if (!isspacechar(ch))
+            visibleChars++;
+		chPrev = ch;
+	}
+
+	// Process to end of document
+	if (state == SCE_C_IDENTIFIER) {
+		classifyWordTACL(styler.GetStartSegment(), i - 1, keywordlists, styler, bInAsm);
+		}
+	else
+		ColourTo(styler, lengthDoc - 1, state, bInAsm);
+}
+
+static void FoldTACLDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[],
+                            Accessor &styler) {
+	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+	bool foldPreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0;
+	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
+	int levelCurrent = levelPrev;
+	char chNext = styler[startPos];
+	int styleNext = styler.StyleAt(startPos);
+	int style = initStyle;
+	bool section = false;
+
+	Sci_Position lastStart = 0;
+
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int stylePrev = style;
+		style = styleNext;
+		styleNext = styler.StyleAt(i + 1);
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+
+		if (stylePrev == SCE_C_DEFAULT && (style == SCE_C_WORD || style == SCE_C_PREPROCESSOR))
+		{
+			// Store last word start point.
+			lastStart = i;
+		}
+
+		if (stylePrev == SCE_C_WORD || stylePrev == SCE_C_PREPROCESSOR) {
+			if(isTACLwordchar(ch) && !isTACLwordchar(chNext)) {
+				char s[100];
+				getRange(lastStart, i, styler, s, sizeof(s));
+				if (stylePrev == SCE_C_PREPROCESSOR && strcmp(s, "?section") == 0)
+					{
+					section = true;
+					levelCurrent = 1;
+					levelPrev = 0;
+					}
+				else if (stylePrev == SCE_C_WORD)
+					levelCurrent += classifyFoldPointTACL(s);
+			}
+		}
+
+		if (style == SCE_C_OPERATOR) {
+			if (ch == '[') {
+				levelCurrent++;
+			} else if (ch == ']') {
+				levelCurrent--;
+			}
+		}
+		if (foldComment && (style == SCE_C_COMMENTLINE)) {
+			if ((ch == '/') && (chNext == '/')) {
+				char chNext2 = styler.SafeGetCharAt(i + 2);
+				if (chNext2 == '{') {
+					levelCurrent++;
+				} else if (chNext2 == '}') {
+					levelCurrent--;
+				}
+			}
+		}
+
+		if (foldPreprocessor && (style == SCE_C_PREPROCESSOR)) {
+			if (ch == '{' && chNext == '$') {
+				Sci_PositionU j=i+2; // skip {$
+				while ((j<endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
+					j++;
+				}
+				if (styler.Match(j, "region") || styler.Match(j, "if")) {
+					levelCurrent++;
+				} else if (styler.Match(j, "end")) {
+					levelCurrent--;
+				}
+			}
+		}
+
+		if (foldComment && IsStreamCommentStyle(style)) {
+			if (!IsStreamCommentStyle(stylePrev)) {
+				levelCurrent++;
+			} else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
+				// Comments don't end at end of line and the next character may be unstyled.
+				levelCurrent--;
+			}
+		}
+		if (atEOL) {
+			int lev = levelPrev | SC_FOLDLEVELBASE;
+			if (visibleChars == 0 && foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if ((levelCurrent > levelPrev || section) && (visibleChars > 0))
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			levelPrev = levelCurrent;
+			visibleChars = 0;
+			section = false;
+		}
+
+		if (!isspacechar(ch))
+			visibleChars++;
+	}
+
+	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
+	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
+	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
+}
+
+static const char * const TACLWordListDesc[] = {
+	"Builtins",
+	"Labels",
+	"Commands",
+	0
+};
+
+LexerModule lmTACL(SCLEX_TACL, ColouriseTACLDoc, "TACL", FoldTACLDoc, TACLWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexTADS3.cxx b/Pythonwin/Scintilla/lexers/LexTADS3.cxx
similarity index 97%
rename from Pythonwin/Scintilla/src/LexTADS3.cxx
rename to Pythonwin/Scintilla/lexers/LexTADS3.cxx
index 7cc85f1f9..e2aecbf55 100644
--- a/Pythonwin/Scintilla/src/LexTADS3.cxx
+++ b/Pythonwin/Scintilla/lexers/LexTADS3.cxx
@@ -33,22 +33,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static const int T3_SINGLE_QUOTE = 1;
 static const int T3_INT_EXPRESSION = 2;
@@ -70,7 +71,7 @@ static inline bool IsEOL(const int ch, const int chNext) {
  *   - it doesn't want to admit that there's a newline until reaching the END
  *   of the sequence.  We meet both needs by saying that there's a newline
  *   when we see the CR in a CR-LF, but skipping the CR before returning so
- *   that the caller's caller will see that we've stopped at the LF.  
+ *   that the caller's caller will see that we've stopped at the LF.
  */
 static inline bool IsEOLSkip(StyleContext &sc)
 {
@@ -82,17 +83,13 @@ static inline bool IsEOLSkip(StyleContext &sc)
         return true;
     }
 
-    /* 
+    /*
      *   in other cases, we have at most a 1-character newline, so do the
-     *   normal IsEOL test 
+     *   normal IsEOL test
      */
     return IsEOL(sc.ch, sc.chNext);
 }
 
-static inline bool IsASpaceOrTab(const int ch) {
-        return ch == ' ' || ch == '\t';
-}
-
 static inline bool IsATADS3Operator(const int ch) {
         return ch == '=' || ch == '{' || ch == '}' || ch == '(' || ch == ')'
                 || ch == '[' || ch == ']' || ch == ',' || ch == ':' || ch == ';'
@@ -156,7 +153,7 @@ static void ColouriseTADSHTMLString(StyleContext &sc, int &lineState) {
                 sc.Forward();
         }
         if (chQuote == '"')
-                lineState &= ~T3_HTML_SQUOTE; 
+                lineState &= ~T3_HTML_SQUOTE;
         else
                 lineState |= T3_HTML_SQUOTE;
 
@@ -270,7 +267,7 @@ static void ColouriseTADS3HTMLTag(StyleContext &sc, int &lineState) {
 }
 
 static void ColouriseTADS3Keyword(StyleContext &sc,
-                                                        WordList *keywordlists[],       unsigned int endPos) {
+                                                        WordList *keywordlists[],       Sci_PositionU endPos) {
         char s[250];
         WordList &keywords = *keywordlists[0];
         WordList &userwords1 = *keywordlists[1];
@@ -284,7 +281,7 @@ static void ColouriseTADS3Keyword(StyleContext &sc,
         sc.GetCurrent(s, sizeof(s));
         if ( strcmp(s, "is") == 0 || strcmp(s, "not") == 0) {
                 // have to find if "in" is next
-                int n = 1;
+                Sci_Position n = 1;
                 while (n + sc.currentPos < endPos && IsASpaceOrTab(sc.GetRelative(n)))
                         n++;
                 if (sc.GetRelative(n) == 'i' && sc.GetRelative(n+1) == 'n') {
@@ -514,13 +511,13 @@ static void ColouriseTADS3Number(StyleContext &sc) {
         sc.SetState(endState);
 }
 
-static void ColouriseTADS3Doc(unsigned int startPos, int length, int initStyle,
+static void ColouriseTADS3Doc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                                                            WordList *keywordlists[], Accessor &styler) {
         int visibleChars = 0;
         int bracketLevel = 0;
         int lineState = 0;
-        unsigned int endPos = startPos + length;
-        int lineCurrent = styler.GetLine(startPos);
+        Sci_PositionU endPos = startPos + length;
+        Sci_Position lineCurrent = styler.GetLine(startPos);
         if (lineCurrent > 0) {
                 lineState = styler.GetLineState(lineCurrent-1);
         }
@@ -679,7 +676,7 @@ static const int T3_EXPECTINGPUNCTUATION = 1 << 14;
 static inline bool IsStringTransition(int s1, int s2) {
         return s1 != s2
                 && (s1 == SCE_T3_S_STRING || s1 == SCE_T3_X_STRING
-                        || s1 == SCE_T3_D_STRING && s2 != SCE_T3_X_DEFAULT)
+                        || (s1 == SCE_T3_D_STRING && s2 != SCE_T3_X_DEFAULT))
                 && s2 != SCE_T3_LIB_DIRECTIVE
                 && s2 != SCE_T3_MSG_PARAM
                 && s2 != SCE_T3_HTML_TAG
@@ -698,7 +695,7 @@ static inline bool IsAnIdentifier(const int style) {
 }
 
 static inline bool IsAnOperator(const int style) {
-    return style == SCE_T3_OPERATOR || SCE_T3_BRACE;
+    return style == SCE_T3_OPERATOR || style == SCE_T3_BRACE;
 }
 
 static inline bool IsSpaceEquivalent(const int ch, const int style) {
@@ -708,9 +705,9 @@ static inline bool IsSpaceEquivalent(const int ch, const int style) {
                 || style == SCE_T3_PREPROCESSOR;
 }
 
-static char peekAhead(unsigned int startPos, unsigned int endPos,
+static char peekAhead(Sci_PositionU startPos, Sci_PositionU endPos,
                                           Accessor &styler) {
-        for (unsigned int i = startPos; i < endPos; i++) {
+        for (Sci_PositionU i = startPos; i < endPos; i++) {
                 int style = styler.StyleAt(i);
                 char ch = styler[i];
                 if (!IsSpaceEquivalent(ch, style)) {
@@ -729,10 +726,10 @@ static char peekAhead(unsigned int startPos, unsigned int endPos,
         return ' ';
 }
 
-static void FoldTADS3Doc(unsigned int startPos, int length, int initStyle,
+static void FoldTADS3Doc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                             WordList *[], Accessor &styler) {
-        unsigned int endPos = startPos + length;
-        int lineCurrent = styler.GetLine(startPos);
+        Sci_PositionU endPos = startPos + length;
+        Sci_Position lineCurrent = styler.GetLine(startPos);
         int levelCurrent = SC_FOLDLEVELBASE;
         if (lineCurrent > 0)
                 levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
@@ -748,7 +745,7 @@ static void FoldTADS3Doc(unsigned int startPos, int length, int initStyle,
         char ch = chNext;
         int stylePrev = style;
         bool redo = false;
-        for (unsigned int i = startPos; i < endPos; i++) {
+        for (Sci_PositionU i = startPos; i < endPos; i++) {
                 if (redo) {
                         redo = false;
                         i--;
diff --git a/Pythonwin/Scintilla/src/LexPascal.cxx b/Pythonwin/Scintilla/lexers/LexTAL.cxx
similarity index 62%
rename from Pythonwin/Scintilla/src/LexPascal.cxx
rename to Pythonwin/Scintilla/lexers/LexTAL.cxx
index 0e4576064..8d1f057a6 100644
--- a/Pythonwin/Scintilla/src/LexPascal.cxx
+++ b/Pythonwin/Scintilla/lexers/LexTAL.cxx
@@ -1,36 +1,54 @@
 // Scintilla source code edit control
-/** @file LexPascal.cxx
- ** Lexer for Pascal.
+/** @file LexTAL.cxx
+ ** Lexer for TAL
+ ** Based on LexPascal.cxx
  ** Written by Laurent le Tynevez
  ** Updated by Simon Steele <s.steele@pnotepad.org> September 2002
  ** Updated by Mathias Rauen <scite@madshi.net> May 2003 (Delphi adjustments)
+ ** Updated by Rod Falck, Aug 2006 Converted to TAL
  **/
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
 #include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-static void getRange(unsigned int start,
-		unsigned int end,
+inline bool isTALoperator(char ch)
+	{
+	return ch == '\'' || ch == '@' || ch == '#' || isoperator(ch);
+	}
+
+inline bool isTALwordchar(char ch)
+	{
+	return ch == '$' || ch == '^' || iswordchar(ch);
+	}
+
+inline bool isTALwordstart(char ch)
+	{
+	return ch == '$' || ch == '^' || iswordstart(ch);
+	}
+
+static void getRange(Sci_PositionU start,
+		Sci_PositionU end,
 		Accessor &styler,
 		char *s,
-		unsigned int len) {
-	unsigned int i = 0;
+		Sci_PositionU len) {
+	Sci_PositionU i = 0;
 	while ((i < end - start + 1) && (i < len-1)) {
 		s[i] = static_cast<char>(tolower(styler[start + i]));
 		i++;
@@ -45,7 +63,7 @@ static bool IsStreamCommentStyle(int style) {
 		style == SCE_C_COMMENTDOCKEYWORDERROR;
 }
 
-static void ColourTo(Accessor &styler, unsigned int end, unsigned int attr, bool bInAsm) {
+static void ColourTo(Accessor &styler, Sci_PositionU end, unsigned int attr, bool bInAsm) {
 	if ((bInAsm) && (attr == SCE_C_OPERATOR || attr == SCE_C_NUMBER || attr == SCE_C_DEFAULT || attr == SCE_C_WORD || attr == SCE_C_IDENTIFIER)) {
 		styler.ColourTo(end, SCE_C_REGEX);
 	} else
@@ -53,56 +71,47 @@ static void ColourTo(Accessor &styler, unsigned int end, unsigned int attr, bool
 }
 
 // returns 1 if the item starts a class definition, and -1 if the word is "end", and 2 if the word is "asm"
-static int classifyWordPascal(unsigned int start, unsigned int end, /*WordList &keywords*/WordList *keywordlists[], Accessor &styler, bool bInClass, bool bInAsm) {
+static int classifyWordTAL(Sci_PositionU start, Sci_PositionU end, /*WordList &keywords*/WordList *keywordlists[], Accessor &styler, bool bInAsm) {
 	int ret = 0;
 
 	WordList& keywords = *keywordlists[0];
-	WordList& classwords = *keywordlists[1];
+	WordList& builtins = *keywordlists[1];
+	WordList& nonreserved_keywords = *keywordlists[2];
 
 	char s[100];
 	getRange(start, end, styler, s, sizeof(s));
 
 	char chAttr = SCE_C_IDENTIFIER;
-	if (isdigit(s[0]) || (s[0] == '.') ||(s[0] == '$')) {
+	if (isdigit(s[0]) || (s[0] == '.')) {
 		chAttr = SCE_C_NUMBER;
 	}
 	else {
-		if (s[0] == '#') {
-			chAttr = SCE_C_CHARACTER;
-		}
-		else {
-			if (keywords.InList(s)) {
-				chAttr = SCE_C_WORD;
+		if (keywords.InList(s)) {
+			chAttr = SCE_C_WORD;
 
-				if(strcmp(s, "class") == 0) {
-					ret = 1;
-				}
-				else if (strcmp(s, "asm") == 0) {
-					ret = 2;
-				}
-				else if (strcmp(s, "end") == 0) {
-					ret = -1;
-				}
-			} else if (bInClass) {
-				if (classwords.InList(s)) {
-					chAttr = SCE_C_WORD;
-				}
+			if (strcmp(s, "asm") == 0) {
+				ret = 2;
 			}
+			else if (strcmp(s, "end") == 0) {
+				ret = -1;
+			}
+		}
+		else if (s[0] == '$' || builtins.InList(s)) {
+			chAttr = SCE_C_WORD2;
+		}
+		else if (nonreserved_keywords.InList(s)) {
+			chAttr = SCE_C_UUID;
 		}
 	}
 	ColourTo(styler, end, chAttr, (bInAsm && ret != -1));
 	return ret;
 }
 
-static int classifyFoldPointPascal(const char* s) {
+static int classifyFoldPointTAL(const char* s) {
 	int lev = 0;
 	if (!(isdigit(s[0]) || (s[0] == '.'))) {
 		if (strcmp(s, "begin") == 0 ||
-			strcmp(s, "object") == 0 ||
-			strcmp(s, "case") == 0 ||
-			strcmp(s, "class") == 0 ||
-			strcmp(s, "record") == 0 ||
-			strcmp(s, "try") == 0) {
+			strcmp(s, "block") == 0) {
 			lev=1;
 		} else if (strcmp(s, "end") == 0) {
 			lev=-1;
@@ -111,7 +120,7 @@ static int classifyFoldPointPascal(const char* s) {
 	return lev;
 }
 
-static void ColourisePascalDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
+static void ColouriseTALDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *keywordlists[],
 	Accessor &styler) {
 
 	styler.StartAt(startPos);
@@ -121,11 +130,11 @@ static void ColourisePascalDoc(unsigned int startPos, int length, int initStyle,
 		state = SCE_C_DEFAULT;
 	char chPrev = ' ';
 	char chNext = styler[startPos];
-	unsigned int lengthDoc = startPos + length;
+	Sci_PositionU lengthDoc = startPos + length;
 
 	bool bInClassDefinition;
 
-	int currentLine = styler.GetLine(startPos);
+	Sci_Position currentLine = styler.GetLine(startPos);
 	if (currentLine > 0) {
 		styler.SetLineState(currentLine, styler.GetLineState(currentLine-1));
 		bInClassDefinition = (styler.GetLineState(currentLine) == 1);
@@ -139,7 +148,8 @@ static void ColourisePascalDoc(unsigned int startPos, int length, int initStyle,
 		state = SCE_C_DEFAULT;
 
 	styler.StartSegment(startPos);
-	for (unsigned int i = startPos; i < lengthDoc; i++) {
+	int visibleChars = 0;
+	for (Sci_PositionU i = startPos; i < lengthDoc; i++) {
 		char ch = chNext;
 
 		chNext = styler.SafeGetCharAt(i + 1);
@@ -152,6 +162,7 @@ static void ColourisePascalDoc(unsigned int startPos, int length, int initStyle,
 				ColourTo(styler, i, state, bInAsm);
 				state = SCE_C_DEFAULT;
 			}
+			visibleChars = 0;
 			currentLine++;
 			styler.SetLineState(currentLine, (bInClassDefinition ? 1 : 0));
 		}
@@ -164,36 +175,31 @@ static void ColourisePascalDoc(unsigned int startPos, int length, int initStyle,
 		}
 
 		if (state == SCE_C_DEFAULT) {
-			if (iswordstart(ch) || ch == '#' || ch == '$' || (ch == '@' && bInAsm)) {
+			if (isTALwordstart(ch)) {
 				ColourTo(styler, i-1, state, bInAsm);
 				state = SCE_C_IDENTIFIER;
-			} else if (ch == '{' && chNext != '$' && chNext != '&') {
+			} else if (ch == '!' && chNext != '*') {
 				ColourTo(styler, i-1, state, bInAsm);
 				state = SCE_C_COMMENT;
-			} else if (ch == '(' && chNext == '*'
-						&& styler.SafeGetCharAt(i + 2) != '$'
-						&& styler.SafeGetCharAt(i + 2) != '&') {
+			} else if (ch == '!' && chNext == '*') {
 				ColourTo(styler, i-1, state, bInAsm);
 				state = SCE_C_COMMENTDOC;
-			} else if (ch == '/' && chNext == '/') {
+			} else if (ch == '-' && chNext == '-') {
 				ColourTo(styler, i-1, state, bInAsm);
 				state = SCE_C_COMMENTLINE;
-			} else if (ch == '\'') {
+			} else if (ch == '"') {
 				ColourTo(styler, i-1, state, bInAsm);
-				state = SCE_C_CHARACTER;
-			} else if (ch == '{' && (chNext == '$' || chNext=='&')) {
+				state = SCE_C_STRING;
+			} else if (ch == '?' && visibleChars == 0) {
 				ColourTo(styler, i-1, state, bInAsm);
 				state = SCE_C_PREPROCESSOR;
-			} else if (isoperator(ch)) {
+			} else if (isTALoperator(ch)) {
 				ColourTo(styler, i-1, state, bInAsm);
 				ColourTo(styler, i, SCE_C_OPERATOR, bInAsm);
-
 			}
 		} else if (state == SCE_C_IDENTIFIER) {
-			bool bDoublePoint = ((ch == '.') && (chPrev == '.'));
-			if ((!iswordchar(ch) && ch != '$' && ch != '#' && (ch != '@' || !bInAsm)) || bDoublePoint) {
-				if (bDoublePoint) i--;
-				int lStateChange = classifyWordPascal(styler.GetStartSegment(), i - 1, keywordlists, styler, bInClassDefinition, bInAsm);
+			if (!isTALwordchar(ch)) {
+				int lStateChange = classifyWordTAL(styler.GetStartSegment(), i - 1, keywordlists, styler, bInAsm);
 
 				if(lStateChange == 1) {
 					styler.SetLineState(currentLine, 1);
@@ -205,49 +211,38 @@ static void ColourisePascalDoc(unsigned int startPos, int length, int initStyle,
 					bInClassDefinition = false;
 					bInAsm = false;
 				}
-				if (bDoublePoint) {
-					i++;
-					ColourTo(styler, i-1, SCE_C_DEFAULT, bInAsm);
-				}
 
 				state = SCE_C_DEFAULT;
 				chNext = styler.SafeGetCharAt(i + 1);
-				if (ch == '{' && chNext != '$' && chNext != '&') {
+				if (ch == '!' && chNext != '*') {
 					state = SCE_C_COMMENT;
-				} else if (ch == '(' && chNext == '*'
-						&& styler.SafeGetCharAt(i + 2) != '$'
-						&& styler.SafeGetCharAt(i + 2) != '&') {
+				} else if (ch == '!' && chNext == '*') {
 					ColourTo(styler, i-1, state, bInAsm);
 					state = SCE_C_COMMENTDOC;
-				} else if (ch == '/' && chNext == '/') {
+				} else if (ch == '-' && chNext == '-') {
 					state = SCE_C_COMMENTLINE;
-				} else if (ch == '\'') {
-					state = SCE_C_CHARACTER;
-				} else if (isoperator(ch)) {
+				} else if (ch == '"') {
+					state = SCE_C_STRING;
+				} else if (isTALoperator(ch)) {
 					ColourTo(styler, i, SCE_C_OPERATOR, bInAsm);
 				}
 			}
 		} else {
 			if (state == SCE_C_PREPROCESSOR) {
-				if (ch=='}'){
-					ColourTo(styler, i, state, bInAsm);
+				if ((ch == '\r' || ch == '\n') && !(chPrev == '\\' || chPrev == '\r')) {
+					ColourTo(styler, i-1, state, bInAsm);
 					state = SCE_C_DEFAULT;
-				} else {
-					if ((ch == '\r' || ch == '\n') && !(chPrev == '\\' || chPrev == '\r')) {
-						ColourTo(styler, i-1, state, bInAsm);
-						state = SCE_C_DEFAULT;
-					}
 				}
 			} else if (state == SCE_C_COMMENT) {
-				if (ch == '}' ) {
+				if (ch == '!' || (ch == '\r' || ch == '\n') ) {
 					ColourTo(styler, i, state, bInAsm);
 					state = SCE_C_DEFAULT;
 				}
 			} else if (state == SCE_C_COMMENTDOC) {
-				if (ch == ')' && chPrev == '*') {
+				if (ch == '!' || (ch == '\r' || ch == '\n')) {
 					if (((i > styler.GetStartSegment() + 2) || (
 						(initStyle == SCE_C_COMMENTDOC) &&
-						(styler.GetStartSegment() == static_cast<unsigned int>(startPos))))) {
+						(styler.GetStartSegment() == static_cast<Sci_PositionU>(startPos))))) {
 							ColourTo(styler, i, state, bInAsm);
 							state = SCE_C_DEFAULT;
 					}
@@ -257,35 +252,39 @@ static void ColourisePascalDoc(unsigned int startPos, int length, int initStyle,
 					ColourTo(styler, i-1, state, bInAsm);
 					state = SCE_C_DEFAULT;
 				}
-			} else if (state == SCE_C_CHARACTER) {
-				if (ch == '\'') {
+			} else if (state == SCE_C_STRING) {
+				if (ch == '"') {
 					ColourTo(styler, i, state, bInAsm);
 					state = SCE_C_DEFAULT;
 				}
 			}
 		}
+        if (!isspacechar(ch))
+            visibleChars++;
 		chPrev = ch;
 	}
 	ColourTo(styler, lengthDoc - 1, state, bInAsm);
 }
 
-static void FoldPascalDoc(unsigned int startPos, int length, int initStyle, WordList *[],
+static void FoldTALDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[],
                             Accessor &styler) {
 	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
 	bool foldPreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0;
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	unsigned int endPos = startPos + length;
+	Sci_PositionU endPos = startPos + length;
 	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent = levelPrev;
 	char chNext = styler[startPos];
 	int styleNext = styler.StyleAt(startPos);
 	int style = initStyle;
+	bool was_end = false;
+	bool section = false;
 
-	int lastStart = 0;
+	Sci_Position lastStart = 0;
 
-	for (unsigned int i = startPos; i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 		int stylePrev = style;
@@ -293,17 +292,41 @@ static void FoldPascalDoc(unsigned int startPos, int length, int initStyle, Word
 		styleNext = styler.StyleAt(i + 1);
 		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
 
-		if (stylePrev != SCE_C_WORD && style == SCE_C_WORD)
+		if (stylePrev == SCE_C_DEFAULT && (style == SCE_C_WORD || style == SCE_C_UUID || style == SCE_C_PREPROCESSOR))
 		{
 			// Store last word start point.
 			lastStart = i;
 		}
 
-		if (stylePrev == SCE_C_WORD) {
-			if(iswordchar(ch) && !iswordchar(chNext)) {
+		if (stylePrev == SCE_C_WORD || style == SCE_C_UUID || stylePrev == SCE_C_PREPROCESSOR) {
+			if(isTALwordchar(ch) && !isTALwordchar(chNext)) {
 				char s[100];
 				getRange(lastStart, i, styler, s, sizeof(s));
-				levelCurrent += classifyFoldPointPascal(s);
+				if (stylePrev == SCE_C_PREPROCESSOR && strcmp(s, "?section") == 0)
+					{
+					section = true;
+					levelCurrent = 1;
+					levelPrev = 0;
+					}
+				else if (stylePrev == SCE_C_WORD || stylePrev == SCE_C_UUID)
+					{
+					if (strcmp(s, "block") == 0)
+						{
+						// block keyword is ignored immediately after end keyword
+						if (!was_end)
+							levelCurrent++;
+						}
+					else
+						levelCurrent += classifyFoldPointTAL(s);
+					if (strcmp(s, "end") == 0)
+						{
+						was_end = true;
+						}
+					else
+						{
+						was_end = false;
+						}
+					}
 			}
 		}
 
@@ -320,7 +343,7 @@ static void FoldPascalDoc(unsigned int startPos, int length, int initStyle, Word
 
 		if (foldPreprocessor && (style == SCE_C_PREPROCESSOR)) {
 			if (ch == '{' && chNext == '$') {
-				unsigned int j=i+2; // skip {$
+				Sci_PositionU j=i+2; // skip {$
 				while ((j<endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
 					j++;
 				}
@@ -342,10 +365,10 @@ static void FoldPascalDoc(unsigned int startPos, int length, int initStyle, Word
 		}
 
 		if (atEOL) {
-			int lev = levelPrev;
+			int lev = levelPrev | SC_FOLDLEVELBASE;
 			if (visibleChars == 0 && foldCompact)
 				lev |= SC_FOLDLEVELWHITEFLAG;
-			if ((levelCurrent > levelPrev) && (visibleChars > 0))
+			if ((levelCurrent > levelPrev || section) && (visibleChars > 0))
 				lev |= SC_FOLDLEVELHEADERFLAG;
 			if (lev != styler.LevelAt(lineCurrent)) {
 				styler.SetLevel(lineCurrent, lev);
@@ -353,6 +376,7 @@ static void FoldPascalDoc(unsigned int startPos, int length, int initStyle, Word
 			lineCurrent++;
 			levelPrev = levelCurrent;
 			visibleChars = 0;
+			section = false;
 		}
 
 		if (!isspacechar(ch))
@@ -364,10 +388,10 @@ static void FoldPascalDoc(unsigned int startPos, int length, int initStyle, Word
 	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
 }
 
-static const char * const pascalWordListDesc[] = {
+static const char * const TALWordListDesc[] = {
 	"Keywords",
-	"Classwords",
+	"Builtins",
 	0
 };
 
-LexerModule lmPascal(SCLEX_PASCAL, ColourisePascalDoc, "pascal", FoldPascalDoc, pascalWordListDesc);
+LexerModule lmTAL(SCLEX_TAL, ColouriseTALDoc, "TAL", FoldTALDoc, TALWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexTCL.cxx b/Pythonwin/Scintilla/lexers/LexTCL.cxx
new file mode 100644
index 000000000..5c73fb52e
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexTCL.cxx
@@ -0,0 +1,371 @@
+// Scintilla source code edit control
+/** @file LexTCL.cxx
+ ** Lexer for TCL language.
+ **/
+// Copyright 1998-2001 by Andre Arpin <arpin@kingston.net>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+// Extended to accept accented characters
+static inline bool IsAWordChar(int ch) {
+	return ch >= 0x80 ||
+	       (isalnum(ch) || ch == '_' || ch ==':' || ch=='.'); // : name space separator
+}
+
+static inline bool IsAWordStart(int ch) {
+	return ch >= 0x80 || (ch ==':' || isalpha(ch) || ch == '_');
+}
+
+static inline bool IsANumberChar(int ch) {
+	// Not exactly following number definition (several dots are seen as OK, etc.)
+	// but probably enough in most cases.
+	return (ch < 0x80) &&
+	       (IsADigit(ch, 0x10) || toupper(ch) == 'E' ||
+	        ch == '.' || ch == '-' || ch == '+');
+}
+
+static void ColouriseTCLDoc(Sci_PositionU startPos, Sci_Position length, int , WordList *keywordlists[], Accessor &styler) {
+#define  isComment(s) (s==SCE_TCL_COMMENT || s==SCE_TCL_COMMENTLINE || s==SCE_TCL_COMMENT_BOX || s==SCE_TCL_BLOCK_COMMENT)
+	const bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
+	const bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
+	bool commentLevel = false;
+	bool subBrace = false; // substitution begin with a brace ${.....}
+	enum tLineState {LS_DEFAULT, LS_OPEN_COMMENT, LS_OPEN_DOUBLE_QUOTE, LS_COMMENT_BOX, LS_MASK_STATE = 0xf,
+	                 LS_COMMAND_EXPECTED = 16, LS_BRACE_ONLY = 32
+	                } lineState = LS_DEFAULT;
+	bool prevSlash = false;
+	int currentLevel = 0;
+	bool expected = 0;
+	bool subParen = 0;
+
+	Sci_Position currentLine = styler.GetLine(startPos);
+	if (currentLine > 0)
+		currentLine--;
+	length += startPos - styler.LineStart(currentLine);
+	// make sure lines overlap
+	startPos = styler.LineStart(currentLine);
+
+	WordList &keywords = *keywordlists[0];
+	WordList &keywords2 = *keywordlists[1];
+	WordList &keywords3 = *keywordlists[2];
+	WordList &keywords4 = *keywordlists[3];
+	WordList &keywords5 = *keywordlists[4];
+	WordList &keywords6 = *keywordlists[5];
+	WordList &keywords7 = *keywordlists[6];
+	WordList &keywords8 = *keywordlists[7];
+	WordList &keywords9 = *keywordlists[8];
+
+	if (currentLine > 0) {
+		int ls = styler.GetLineState(currentLine - 1);
+		lineState = tLineState(ls & LS_MASK_STATE);
+		expected = LS_COMMAND_EXPECTED == tLineState(ls & LS_COMMAND_EXPECTED);
+		subBrace = LS_BRACE_ONLY == tLineState(ls & LS_BRACE_ONLY);
+		currentLevel = styler.LevelAt(currentLine - 1) >> 17;
+		commentLevel = (styler.LevelAt(currentLine - 1) >> 16) & 1;
+	} else
+		styler.SetLevel(0, SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG);
+	bool visibleChars = false;
+
+	int previousLevel = currentLevel;
+	StyleContext sc(startPos, length, SCE_TCL_DEFAULT, styler);
+	for (; ; sc.Forward()) {
+next:
+		if (sc.ch=='\r' && sc.chNext == '\n') // only ignore \r on PC process on the mac
+			continue;
+		bool atEnd = !sc.More();  // make sure we coloured the last word
+		if (lineState != LS_DEFAULT) {
+			sc.SetState(SCE_TCL_DEFAULT);
+			if (lineState == LS_OPEN_COMMENT)
+				sc.SetState(SCE_TCL_COMMENTLINE);
+			else if (lineState == LS_OPEN_DOUBLE_QUOTE)
+				sc.SetState(SCE_TCL_IN_QUOTE);
+			else if (lineState == LS_COMMENT_BOX && (sc.ch == '#' || (sc.ch == ' ' && sc.chNext=='#')))
+				sc.SetState(SCE_TCL_COMMENT_BOX);
+			lineState = LS_DEFAULT;
+		}
+		if (subBrace) { // ${ overrides every thing even \ except }
+			if (sc.ch == '}') {
+				subBrace = false;
+				sc.SetState(SCE_TCL_OPERATOR);
+				sc.ForwardSetState(SCE_TCL_DEFAULT);
+				goto next;
+			} else
+				sc.SetState(SCE_TCL_SUB_BRACE);
+			if (!sc.atLineEnd)
+				continue;
+		} else if (sc.state == SCE_TCL_DEFAULT || sc.state ==SCE_TCL_OPERATOR) {
+			expected &= isspacechar(static_cast<unsigned char>(sc.ch)) || IsAWordStart(sc.ch) || sc.ch =='#';
+		} else if (sc.state == SCE_TCL_SUBSTITUTION) {
+			switch (sc.ch) {
+			case '(':
+				subParen=true;
+				sc.SetState(SCE_TCL_OPERATOR);
+				sc.ForwardSetState(SCE_TCL_SUBSTITUTION);
+				continue;
+			case ')':
+				sc.SetState(SCE_TCL_OPERATOR);
+				subParen=false;
+				continue;
+			case '$':
+				continue;
+			case ',':
+				sc.SetState(SCE_TCL_OPERATOR);
+				if (subParen) {
+					sc.ForwardSetState(SCE_TCL_SUBSTITUTION);
+					goto next;	// Already forwarded so avoid loop's Forward()
+				}
+				continue;
+			default :
+				// maybe spaces should be allowed ???
+				if (!IsAWordChar(sc.ch)) { // probably the code is wrong
+					sc.SetState(SCE_TCL_DEFAULT);
+					subParen = 0;
+				}
+				break;
+			}
+		} else if (isComment(sc.state)) {
+		} else if (!IsAWordChar(sc.ch)) {
+			if ((sc.state == SCE_TCL_IDENTIFIER && expected) ||  sc.state == SCE_TCL_MODIFIER) {
+				char w[100];
+				char *s=w;
+				sc.GetCurrent(w, sizeof(w));
+				if (w[strlen(w)-1]=='\r')
+					w[strlen(w)-1]=0;
+				while (*s == ':') // ignore leading : like in ::set a 10
+					++s;
+				bool quote = sc.state == SCE_TCL_IN_QUOTE;
+				if (commentLevel  || expected) {
+					if (keywords.InList(s)) {
+						sc.ChangeState(quote ? SCE_TCL_WORD_IN_QUOTE : SCE_TCL_WORD);
+					} else if (keywords2.InList(s)) {
+						sc.ChangeState(quote ? SCE_TCL_WORD_IN_QUOTE : SCE_TCL_WORD2);
+					} else if (keywords3.InList(s)) {
+						sc.ChangeState(quote ? SCE_TCL_WORD_IN_QUOTE : SCE_TCL_WORD3);
+					} else if (keywords4.InList(s)) {
+						sc.ChangeState(quote ? SCE_TCL_WORD_IN_QUOTE : SCE_TCL_WORD4);
+					} else if (sc.GetRelative(-static_cast<int>(strlen(s))-1) == '{' &&
+					           keywords5.InList(s) && sc.ch == '}') { // {keyword} exactly no spaces
+						sc.ChangeState(SCE_TCL_EXPAND);
+					}
+					if (keywords6.InList(s)) {
+						sc.ChangeState(SCE_TCL_WORD5);
+					} else if (keywords7.InList(s)) {
+						sc.ChangeState(SCE_TCL_WORD6);
+					} else if (keywords8.InList(s)) {
+						sc.ChangeState(SCE_TCL_WORD7);
+					} else if (keywords9.InList(s)) {
+						sc.ChangeState(SCE_TCL_WORD8);
+					}
+				}
+				expected = false;
+				sc.SetState(quote ? SCE_TCL_IN_QUOTE : SCE_TCL_DEFAULT);
+			} else if (sc.state == SCE_TCL_MODIFIER || sc.state == SCE_TCL_IDENTIFIER) {
+				sc.SetState(SCE_TCL_DEFAULT);
+			}
+		}
+		if (atEnd)
+			break;
+		if (sc.atLineEnd) {
+			lineState = LS_DEFAULT;
+			currentLine = styler.GetLine(sc.currentPos);
+			if (foldComment && sc.state!=SCE_TCL_COMMENT && isComment(sc.state)) {
+				if (currentLevel == 0) {
+					++currentLevel;
+					commentLevel = true;
+				}
+			} else {
+				if (visibleChars && commentLevel) {
+					--currentLevel;
+					--previousLevel;
+					commentLevel = false;
+				}
+			}
+			int flag = 0;
+			if (!visibleChars && foldCompact)
+				flag = SC_FOLDLEVELWHITEFLAG;
+			if (currentLevel > previousLevel)
+				flag = SC_FOLDLEVELHEADERFLAG;
+			styler.SetLevel(currentLine, flag + previousLevel + SC_FOLDLEVELBASE + (currentLevel << 17) + (commentLevel << 16));
+
+			// Update the line state, so it can be seen by next line
+			if (sc.state == SCE_TCL_IN_QUOTE) {
+				lineState = LS_OPEN_DOUBLE_QUOTE;
+			} else {
+				if (prevSlash) {
+					if (isComment(sc.state))
+						lineState = LS_OPEN_COMMENT;
+				} else if (sc.state == SCE_TCL_COMMENT_BOX)
+					lineState = LS_COMMENT_BOX;
+			}
+			styler.SetLineState(currentLine,
+			                    (subBrace ? LS_BRACE_ONLY : 0) |
+			                    (expected ? LS_COMMAND_EXPECTED : 0)  | lineState);
+			if (lineState == LS_COMMENT_BOX)
+				sc.ForwardSetState(SCE_TCL_COMMENT_BOX);
+			else if (lineState == LS_OPEN_DOUBLE_QUOTE)
+				sc.ForwardSetState(SCE_TCL_IN_QUOTE);
+			else
+				sc.ForwardSetState(SCE_TCL_DEFAULT);
+			prevSlash = false;
+			previousLevel = currentLevel;
+			goto next;
+		}
+
+		if (prevSlash) {
+			prevSlash = false;
+			if (sc.ch == '#' && IsANumberChar(sc.chNext))
+				sc.ForwardSetState(SCE_TCL_NUMBER);
+			continue;
+		}
+		prevSlash = sc.ch == '\\';
+		if (isComment(sc.state))
+			continue;
+		if (sc.atLineStart) {
+			visibleChars = false;
+			if (sc.state!=SCE_TCL_IN_QUOTE && !isComment(sc.state))
+			{
+				sc.SetState(SCE_TCL_DEFAULT);
+				expected = IsAWordStart(sc.ch)|| isspacechar(static_cast<unsigned char>(sc.ch));
+			}
+		}
+
+		switch (sc.state) {
+		case SCE_TCL_NUMBER:
+			if (!IsANumberChar(sc.ch))
+				sc.SetState(SCE_TCL_DEFAULT);
+			break;
+		case SCE_TCL_IN_QUOTE:
+			if (sc.ch == '"') {
+				sc.ForwardSetState(SCE_TCL_DEFAULT);
+				visibleChars = true; // necessary if a " is the first and only character on a line
+				goto next;
+			} else if (sc.ch == '[' || sc.ch == ']' || sc.ch == '$') {
+				sc.SetState(SCE_TCL_OPERATOR);
+				expected = sc.ch == '[';
+				sc.ForwardSetState(SCE_TCL_IN_QUOTE);
+				goto next;
+			}
+			continue;
+		case SCE_TCL_OPERATOR:
+			sc.SetState(SCE_TCL_DEFAULT);
+			break;
+		}
+
+		if (sc.ch == '#') {
+			if (visibleChars) {
+				if (sc.state != SCE_TCL_IN_QUOTE && expected)
+					sc.SetState(SCE_TCL_COMMENT);
+			} else {
+				sc.SetState(SCE_TCL_COMMENTLINE);
+				if (sc.chNext == '~')
+					sc.SetState(SCE_TCL_BLOCK_COMMENT);
+				if (sc.atLineStart && (sc.chNext == '#' || sc.chNext == '-'))
+					sc.SetState(SCE_TCL_COMMENT_BOX);
+			}
+		}
+
+		if (!isspacechar(static_cast<unsigned char>(sc.ch))) {
+			visibleChars = true;
+		}
+
+		if (sc.ch == '\\') {
+			prevSlash = true;
+			continue;
+		}
+
+		// Determine if a new state should be entered.
+		if (sc.state == SCE_TCL_DEFAULT) {
+			if (IsAWordStart(sc.ch)) {
+				sc.SetState(SCE_TCL_IDENTIFIER);
+			} else if (IsADigit(sc.ch) && !IsAWordChar(sc.chPrev)) {
+				sc.SetState(SCE_TCL_NUMBER);
+			} else {
+				switch (sc.ch) {
+				case '\"':
+					sc.SetState(SCE_TCL_IN_QUOTE);
+					break;
+				case '{':
+					sc.SetState(SCE_TCL_OPERATOR);
+					expected = true;
+					++currentLevel;
+					break;
+				case '}':
+					sc.SetState(SCE_TCL_OPERATOR);
+					expected = true;
+					--currentLevel;
+					break;
+				case '[':
+					expected = true;
+					// Falls through.
+				case ']':
+				case '(':
+				case ')':
+					sc.SetState(SCE_TCL_OPERATOR);
+					break;
+				case ';':
+					expected = true;
+					break;
+				case '$':
+					subParen = 0;
+					if (sc.chNext != '{') {
+						sc.SetState(SCE_TCL_SUBSTITUTION);
+					} else {
+						sc.SetState(SCE_TCL_OPERATOR);  // $
+						sc.Forward();  // {
+						sc.ForwardSetState(SCE_TCL_SUB_BRACE);
+						subBrace = true;
+					}
+					break;
+				case '#':
+					if ((isspacechar(static_cast<unsigned char>(sc.chPrev))||
+					        isoperator(static_cast<char>(sc.chPrev))) && IsADigit(sc.chNext,0x10))
+						sc.SetState(SCE_TCL_NUMBER);
+					break;
+				case '-':
+					sc.SetState(IsADigit(sc.chNext)? SCE_TCL_NUMBER: SCE_TCL_MODIFIER);
+					break;
+				default:
+					if (isoperator(static_cast<char>(sc.ch))) {
+						sc.SetState(SCE_TCL_OPERATOR);
+					}
+				}
+			}
+		}
+	}
+	sc.Complete();
+}
+
+static const char *const tclWordListDesc[] = {
+	"TCL Keywords",
+	"TK Keywords",
+	"iTCL Keywords",
+	"tkCommands",
+	"expand",
+	"user1",
+	"user2",
+	"user3",
+	"user4",
+	0
+};
+
+// this code supports folding in the colourizer
+LexerModule lmTCL(SCLEX_TCL, ColouriseTCLDoc, "tcl", 0, tclWordListDesc);
diff --git a/Pythonwin/Scintilla/lexers/LexTCMD.cxx b/Pythonwin/Scintilla/lexers/LexTCMD.cxx
new file mode 100644
index 000000000..8050dddea
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexTCMD.cxx
@@ -0,0 +1,504 @@
+// Scintilla\ source code edit control
+/** @file LexTCMD.cxx
+ ** Lexer for Take Command / TCC batch scripts (.bat, .btm, .cmd).
+ **/
+// Written by Rex Conn (rconn [at] jpsoft [dot] com)
+// based on the CMD lexer
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+
+static bool IsAlphabetic(int ch) {
+	return IsASCII(ch) && isalpha(ch);
+}
+
+static inline bool AtEOL(Accessor &styler, Sci_PositionU i) {
+	return (styler[i] == '\n') || ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n'));
+}
+
+// Tests for BATCH Operators
+static bool IsBOperator(char ch) {
+	return (ch == '=') || (ch == '+') || (ch == '>') || (ch == '<') || (ch == '|') || (ch == '&') || (ch == '!') || (ch == '?') || (ch == '*') || (ch == '(') || (ch == ')');
+}
+
+// Tests for BATCH Separators
+static bool IsBSeparator(char ch) {
+	return (ch == '\\') || (ch == '.') || (ch == ';') || (ch == ' ') || (ch == '\t') || (ch == '[') || (ch == ']') || (ch == '\"') || (ch == '\'') || (ch == '/');
+}
+
+// Find length of CMD FOR variable with modifier (%~...) or return 0
+static unsigned int GetBatchVarLen( char *wordBuffer )
+{
+	int nLength = 0;
+	if ( wordBuffer[0] == '%' ) {
+
+		if ( wordBuffer[1] == '~' )
+			nLength = 2;
+		else if (( wordBuffer[1] == '%' ) && ( wordBuffer[2] == '~' ))
+			nLength++;
+		else
+			return 0;
+
+		for ( ; ( wordBuffer[nLength] ); nLength++ ) {
+
+			switch ( toupper(wordBuffer[nLength]) ) {
+			case 'A':
+				// file attributes
+			case 'D':
+				// drive letter only
+			case 'F':
+				// fully qualified path name
+			case 'N':
+				// filename only
+			case 'P':
+				// path only
+			case 'S':
+				// short name
+			case 'T':
+				// date / time of file
+			case 'X':
+				// file extension only
+			case 'Z':
+				// file size
+				break;
+			default:
+				return nLength;
+			}
+		}
+	}
+
+	return nLength;
+}
+
+
+static void ColouriseTCMDLine( char *lineBuffer, Sci_PositionU lengthLine, Sci_PositionU startLine, Sci_PositionU endPos, WordList *keywordlists[], Accessor &styler)
+{
+	Sci_PositionU offset = 0;	// Line Buffer Offset
+	char wordBuffer[260];		// Word Buffer - large to catch long paths
+	Sci_PositionU wbl;			// Word Buffer Length
+	Sci_PositionU wbo;			// Word Buffer Offset - also Special Keyword Buffer Length
+	WordList &keywords = *keywordlists[0];      // Internal Commands
+//	WordList &keywords2 = *keywordlists[1];     // Aliases (optional)
+	bool isDelayedExpansion = 1;				// !var!
+
+	bool continueProcessing = true;	// Used to toggle Regular Keyword Checking
+	// Special Keywords are those that allow certain characters without whitespace after the command
+	// Examples are: cd. cd\ echo: echo. path=
+	bool inString = false; // Used for processing while ""
+	// Special Keyword Buffer used to determine if the first n characters is a Keyword
+	char sKeywordBuffer[260] = "";	// Special Keyword Buffer
+	bool sKeywordFound;		// Exit Special Keyword for-loop if found
+
+	// Skip leading whitespace
+	while ((offset < lengthLine) && (isspacechar(lineBuffer[offset]))) {
+		offset++;
+	}
+	// Colorize Default Text
+	styler.ColourTo(startLine + offset - 1, SCE_TCMD_DEFAULT);
+
+	if ( offset >= lengthLine )
+		return;
+
+	// Check for Fake Label (Comment) or Real Label - return if found
+	if (lineBuffer[offset] == ':') {
+		if (lineBuffer[offset + 1] == ':') {
+			// Colorize Fake Label (Comment) - :: is the same as REM
+			styler.ColourTo(endPos, SCE_TCMD_COMMENT);
+		} else {
+			// Colorize Real Label
+			styler.ColourTo(endPos, SCE_TCMD_LABEL);
+		}
+		return;
+
+	// Check for Comment - return if found
+	} else if (( CompareNCaseInsensitive(lineBuffer+offset, "rem", 3) == 0 ) && (( lineBuffer[offset+3] == 0 ) || ( isspace(lineBuffer[offset+3] )))) {
+			styler.ColourTo(endPos, SCE_TCMD_COMMENT);
+			return;
+
+	// Check for Drive Change (Drive Change is internal command) - return if found
+	} else if ((IsAlphabetic(lineBuffer[offset])) &&
+		(lineBuffer[offset + 1] == ':') &&
+		((isspacechar(lineBuffer[offset + 2])) ||
+		(((lineBuffer[offset + 2] == '\\')) &&
+		(isspacechar(lineBuffer[offset + 3]))))) {
+		// Colorize Regular Keyword
+		styler.ColourTo(endPos, SCE_TCMD_WORD);
+		return;
+	}
+
+	// Check for Hide Command (@ECHO OFF/ON)
+	if (lineBuffer[offset] == '@') {
+		styler.ColourTo(startLine + offset, SCE_TCMD_HIDE);
+		offset++;
+	}
+	// Skip whitespace
+	while ((offset < lengthLine) && (isspacechar(lineBuffer[offset]))) {
+		offset++;
+	}
+
+	// Read remainder of line word-at-a-time or remainder-of-word-at-a-time
+	while (offset < lengthLine) {
+		if (offset > startLine) {
+			// Colorize Default Text
+			styler.ColourTo(startLine + offset - 1, SCE_TCMD_DEFAULT);
+		}
+		// Copy word from Line Buffer into Word Buffer
+		wbl = 0;
+		for (; offset < lengthLine && ( wbl < 260 ) && !isspacechar(lineBuffer[offset]); wbl++, offset++) {
+			wordBuffer[wbl] = static_cast<char>(tolower(lineBuffer[offset]));
+		}
+		wordBuffer[wbl] = '\0';
+		wbo = 0;
+
+		// Check for Separator
+		if (IsBSeparator(wordBuffer[0])) {
+
+			// Reset Offset to re-process remainder of word
+			offset -= (wbl - 1);
+			// Colorize Default Text
+			styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
+
+			if (wordBuffer[0] == '"')
+				inString = !inString;
+
+		// Check for Regular expression
+		} else if (( wordBuffer[0] == ':' ) && ( wordBuffer[1] == ':' ) && (continueProcessing)) {
+
+			// Colorize Regular exoressuin
+			styler.ColourTo(startLine + offset - 1, SCE_TCMD_DEFAULT);
+			// No need to Reset Offset
+
+		// Check for Labels in text (... :label)
+		} else if (wordBuffer[0] == ':' && isspacechar(lineBuffer[offset - wbl - 1])) {
+			// Colorize Default Text
+			styler.ColourTo(startLine + offset - 1 - wbl, SCE_TCMD_DEFAULT);
+			// Colorize Label
+			styler.ColourTo(startLine + offset - 1, SCE_TCMD_CLABEL);
+			// No need to Reset Offset
+		// Check for delayed expansion Variable (!x...!)
+		} else if (isDelayedExpansion && wordBuffer[0] == '!') {
+			// Colorize Default Text
+			styler.ColourTo(startLine + offset - 1 - wbl, SCE_TCMD_DEFAULT);
+			wbo++;
+			// Search to end of word for second !
+			while ((wbo < wbl) && (wordBuffer[wbo] != '!') && (!IsBOperator(wordBuffer[wbo])) && (!IsBSeparator(wordBuffer[wbo]))) {
+				wbo++;
+			}
+			if (wordBuffer[wbo] == '!') {
+				wbo++;
+				// Colorize Environment Variable
+				styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_TCMD_EXPANSION);
+			} else {
+				wbo = 1;
+				// Colorize Symbol
+				styler.ColourTo(startLine + offset - 1 - (wbl - 1), SCE_TCMD_DEFAULT);
+			}
+
+			// Reset Offset to re-process remainder of word
+			offset -= (wbl - wbo);
+
+		// Check for Regular Keyword in list
+		} else if ((keywords.InList(wordBuffer)) &&	(!inString) && (continueProcessing)) {
+
+			// ECHO, PATH, and PROMPT require no further Regular Keyword Checking
+			if ((CompareCaseInsensitive(wordBuffer, "echo") == 0) ||
+			  (CompareCaseInsensitive(sKeywordBuffer, "echos") == 0) ||
+			  (CompareCaseInsensitive(sKeywordBuffer, "echoerr") == 0) ||
+			  (CompareCaseInsensitive(sKeywordBuffer, "echoserr") == 0) ||
+			  (CompareCaseInsensitive(wordBuffer, "path") == 0) ||
+			  (CompareCaseInsensitive(wordBuffer, "prompt") == 0)) {
+				continueProcessing = false;
+			}
+
+			// Colorize Regular keyword
+			styler.ColourTo(startLine + offset - 1, SCE_TCMD_WORD);
+			// No need to Reset Offset
+
+		} else if ((wordBuffer[0] != '%') && (wordBuffer[0] != '!') && (!IsBOperator(wordBuffer[0])) &&	(!inString) && (continueProcessing)) {
+
+			// a few commands accept "illegal" syntax -- cd\, echo., etc.
+			sscanf( wordBuffer, "%[^.<>|&=\\/]", sKeywordBuffer );
+			sKeywordFound = false;
+
+			if ((CompareCaseInsensitive(sKeywordBuffer, "echo") == 0) ||
+			  (CompareCaseInsensitive(sKeywordBuffer, "echos") == 0) ||
+			  (CompareCaseInsensitive(sKeywordBuffer, "echoerr") == 0) ||
+			  (CompareCaseInsensitive(sKeywordBuffer, "echoserr") == 0) ||
+			  (CompareCaseInsensitive(sKeywordBuffer, "cd") == 0) ||
+			  (CompareCaseInsensitive(sKeywordBuffer, "path") == 0) ||
+			  (CompareCaseInsensitive(sKeywordBuffer, "prompt") == 0)) {
+
+				// no further Regular Keyword Checking
+				continueProcessing = false;
+				sKeywordFound = true;
+				wbo = (Sci_PositionU)strlen( sKeywordBuffer );
+
+				// Colorize Special Keyword as Regular Keyword
+				styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_TCMD_WORD);
+				// Reset Offset to re-process remainder of word
+				offset -= (wbl - wbo);
+			}
+
+			// Check for Default Text
+			if (!sKeywordFound) {
+				wbo = 0;
+				// Read up to %, Operator or Separator
+				while ((wbo < wbl) && (wordBuffer[wbo] != '%') && (!isDelayedExpansion || wordBuffer[wbo] != '!') && (!IsBOperator(wordBuffer[wbo])) &&	(!IsBSeparator(wordBuffer[wbo]))) {
+					wbo++;
+				}
+				// Colorize Default Text
+				styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_TCMD_DEFAULT);
+				// Reset Offset to re-process remainder of word
+				offset -= (wbl - wbo);
+			}
+
+		// Check for Argument  (%n), Environment Variable (%x...%) or Local Variable (%%a)
+		} else if (wordBuffer[0] == '%') {
+			unsigned int varlen;
+			unsigned int n = 1;
+			// Colorize Default Text
+			styler.ColourTo(startLine + offset - 1 - wbl, SCE_TCMD_DEFAULT);
+			wbo++;
+
+			// check for %[nn] syntax
+			if ( wordBuffer[1] == '[' ) {
+				n++;
+				while ((n < wbl) && (wordBuffer[n] != ']')) {
+					n++;
+				}
+				if ( wordBuffer[n] == ']' )
+					n++;
+				goto ColorizeArg;
+			}
+
+			// Search to end of word for second % or to the first terminator (can be a long path)
+			while ((wbo < wbl) && (wordBuffer[wbo] != '%') && (!IsBOperator(wordBuffer[wbo])) && (!IsBSeparator(wordBuffer[wbo]))) {
+				wbo++;
+			}
+
+			// Check for Argument (%n) or (%*)
+			if (((isdigit(wordBuffer[1])) || (wordBuffer[1] == '*')) && (wordBuffer[wbo] != '%')) {
+				while (( wordBuffer[n] ) && ( strchr( "%0123456789*#$", wordBuffer[n] ) != NULL ))
+					n++;
+ColorizeArg:
+				// Colorize Argument
+				styler.ColourTo(startLine + offset - 1 - (wbl - n), SCE_TCMD_IDENTIFIER);
+				// Reset Offset to re-process remainder of word
+				offset -= (wbl - n);
+
+			// Check for Variable with modifiers (%~...)
+			} else if ((varlen = GetBatchVarLen(wordBuffer)) != 0) {
+
+				// Colorize Variable
+				styler.ColourTo(startLine + offset - 1 - (wbl - varlen), SCE_TCMD_IDENTIFIER);
+				// Reset Offset to re-process remainder of word
+				offset -= (wbl - varlen);
+
+			// Check for Environment Variable (%x...%)
+			} else if (( wordBuffer[1] ) && ( wordBuffer[1] != '%')) {
+				if ( wordBuffer[wbo] == '%' )
+					wbo++;
+
+				// Colorize Environment Variable
+				styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_TCMD_ENVIRONMENT);
+				// Reset Offset to re-process remainder of word
+				offset -= (wbl - wbo);
+
+			// Check for Local Variable (%%a)
+			} else if (	(wbl > 2) && (wordBuffer[1] == '%') && (wordBuffer[2] != '%') && (!IsBOperator(wordBuffer[2])) && (!IsBSeparator(wordBuffer[2]))) {
+
+				n = 2;
+				while (( wordBuffer[n] ) && (!IsBOperator(wordBuffer[n])) && (!IsBSeparator(wordBuffer[n])))
+					n++;
+
+				// Colorize Local Variable
+				styler.ColourTo(startLine + offset - 1 - (wbl - n), SCE_TCMD_IDENTIFIER);
+				// Reset Offset to re-process remainder of word
+				offset -= (wbl - n);
+
+			// Check for %%
+			} else if ((wbl > 1) && (wordBuffer[1] == '%')) {
+
+				// Colorize Symbols
+				styler.ColourTo(startLine + offset - 1 - (wbl - 2), SCE_TCMD_DEFAULT);
+				// Reset Offset to re-process remainder of word
+				offset -= (wbl - 2);
+			} else {
+
+				// Colorize Symbol
+				styler.ColourTo(startLine + offset - 1 - (wbl - 1), SCE_TCMD_DEFAULT);
+				// Reset Offset to re-process remainder of word
+				offset -= (wbl - 1);
+			}
+
+		// Check for Operator
+		} else if (IsBOperator(wordBuffer[0])) {
+			// Colorize Default Text
+			styler.ColourTo(startLine + offset - 1 - wbl, SCE_TCMD_DEFAULT);
+
+			// Check for Pipe, compound, or conditional Operator
+			if ((wordBuffer[0] == '|') || (wordBuffer[0] == '&')) {
+
+				// Colorize Pipe Operator
+				styler.ColourTo(startLine + offset - 1 - (wbl - 1), SCE_TCMD_OPERATOR);
+				// Reset Offset to re-process remainder of word
+				offset -= (wbl - 1);
+				continueProcessing = true;
+
+			// Check for Other Operator
+			} else {
+				// Check for > Operator
+				if ((wordBuffer[0] == '>') || (wordBuffer[0] == '<')) {
+					// Turn Keyword and External Command / Program checking back on
+					continueProcessing = true;
+				}
+				// Colorize Other Operator
+				if (!inString || !(wordBuffer[0] == '(' || wordBuffer[0] == ')'))
+					styler.ColourTo(startLine + offset - 1 - (wbl - 1), SCE_TCMD_OPERATOR);
+				// Reset Offset to re-process remainder of word
+				offset -= (wbl - 1);
+			}
+
+		// Check for Default Text
+		} else {
+			// Read up to %, Operator or Separator
+			while ((wbo < wbl) && (wordBuffer[wbo] != '%') && (!isDelayedExpansion || wordBuffer[wbo] != '!') && (!IsBOperator(wordBuffer[wbo])) &&	(!IsBSeparator(wordBuffer[wbo]))) {
+				wbo++;
+			}
+			// Colorize Default Text
+			styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_TCMD_DEFAULT);
+			// Reset Offset to re-process remainder of word
+			offset -= (wbl - wbo);
+		}
+
+		// Skip whitespace - nothing happens if Offset was Reset
+		while ((offset < lengthLine) && (isspacechar(lineBuffer[offset]))) {
+			offset++;
+		}
+	}
+	// Colorize Default Text for remainder of line - currently not lexed
+	styler.ColourTo(endPos, SCE_TCMD_DEFAULT);
+}
+
+static void ColouriseTCMDDoc( Sci_PositionU startPos, Sci_Position length, int /*initStyle*/, WordList *keywordlists[], Accessor &styler )
+{
+	char lineBuffer[16384];
+
+	styler.StartAt(startPos);
+	styler.StartSegment(startPos);
+	Sci_PositionU linePos = 0;
+	Sci_PositionU startLine = startPos;
+	for (Sci_PositionU i = startPos; i < startPos + length; i++) {
+		lineBuffer[linePos++] = styler[i];
+		if (AtEOL(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
+			// End of line (or of line buffer) met, colourise it
+			lineBuffer[linePos] = '\0';
+			ColouriseTCMDLine(lineBuffer, linePos, startLine, i, keywordlists, styler);
+			linePos = 0;
+			startLine = i + 1;
+		}
+	}
+	if (linePos > 0) {	// Last line does not have ending characters
+		lineBuffer[linePos] = '\0';
+		ColouriseTCMDLine(lineBuffer, linePos, startLine, startPos + length - 1, keywordlists, styler);
+	}
+}
+
+// Convert string to upper case
+static void StrUpr(char *s) {
+	while (*s) {
+		*s = MakeUpperCase(*s);
+		s++;
+	}
+}
+
+// Folding support (for DO, IFF, SWITCH, TEXT, and command groups)
+static void FoldTCMDDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler)
+{
+	Sci_Position line = styler.GetLine(startPos);
+	int level = styler.LevelAt(line);
+	int levelIndent = 0;
+	Sci_PositionU endPos = startPos + length;
+	char s[16] = "";
+
+    char chPrev = styler.SafeGetCharAt(startPos - 1);
+
+	// Scan for ( and )
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+
+		int c = styler.SafeGetCharAt(i, '\n');
+		int style = styler.StyleAt(i);
+        bool bLineStart = ((chPrev == '\r') || (chPrev == '\n')) || i == 0;
+
+		if (style == SCE_TCMD_OPERATOR) {
+			// CheckFoldPoint
+			if (c == '(') {
+				levelIndent += 1;
+			} else if (c == ')') {
+				levelIndent -= 1;
+			}
+		}
+
+        if (( bLineStart ) && ( style == SCE_TCMD_WORD )) {
+            for (Sci_PositionU j = 0; j < 10; j++) {
+                if (!iswordchar(styler[i + j])) {
+                    break;
+                }
+                s[j] = styler[i + j];
+                s[j + 1] = '\0';
+            }
+
+			StrUpr( s );
+            if ((strcmp(s, "DO") == 0) || (strcmp(s, "IFF") == 0) || (strcmp(s, "SWITCH") == 0) || (strcmp(s, "TEXT") == 0)) {
+                levelIndent++;
+            } else if ((strcmp(s, "ENDDO") == 0) || (strcmp(s, "ENDIFF") == 0) || (strcmp(s, "ENDSWITCH") == 0) || (strcmp(s, "ENDTEXT") == 0)) {
+                levelIndent--;
+            }
+        }
+
+		if (c == '\n') { // line end
+				if (levelIndent > 0) {
+						level |= SC_FOLDLEVELHEADERFLAG;
+				}
+				if (level != styler.LevelAt(line))
+						styler.SetLevel(line, level);
+				level += levelIndent;
+				if ((level & SC_FOLDLEVELNUMBERMASK) < SC_FOLDLEVELBASE)
+						level = SC_FOLDLEVELBASE;
+				line++;
+				// reset state
+				levelIndent = 0;
+				level &= ~SC_FOLDLEVELHEADERFLAG;
+				level &= ~SC_FOLDLEVELWHITEFLAG;
+		}
+
+		chPrev = c;
+	}
+}
+
+static const char *const tcmdWordListDesc[] = {
+	"Internal Commands",
+	"Aliases",
+	0
+};
+
+LexerModule lmTCMD(SCLEX_TCMD, ColouriseTCMDDoc, "tcmd", FoldTCMDDoc, tcmdWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexTeX.cxx b/Pythonwin/Scintilla/lexers/LexTeX.cxx
similarity index 89%
rename from Pythonwin/Scintilla/src/LexTeX.cxx
rename to Pythonwin/Scintilla/lexers/LexTeX.cxx
index 18c99ab78..adb14a096 100644
--- a/Pythonwin/Scintilla/src/LexTeX.cxx
+++ b/Pythonwin/Scintilla/lexers/LexTeX.cxx
@@ -1,6 +1,6 @@
 // Scintilla source code edit control
 
-// File: LexTeX.cxx - general context conformant tex coloring scheme
+// @file LexTeX.cxx - general context conformant tex coloring scheme
 // Author: Hans Hagen - PRAGMA ADE - Hasselt NL - www.pragma-ade.com
 // Version: September 28, 2003
 
@@ -18,22 +18,23 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 #include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
 #include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 // val SCE_TEX_DEFAULT = 0
 // val SCE_TEX_SPECIAL = 1
@@ -66,7 +67,7 @@ using namespace Scintilla;
 
 // Auxiliary functions:
 
-static inline bool endOfLine(Accessor &styler, unsigned int i) {
+static inline bool endOfLine(Accessor &styler, Sci_PositionU i) {
 	return
       (styler[i] == '\n') || ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n')) ;
 }
@@ -119,18 +120,18 @@ static inline bool isTeXseven(int ch) {
 // Interface determination
 
 static int CheckTeXInterface(
-    unsigned int startPos,
-    int length,
+    Sci_PositionU startPos,
+    Sci_Position length,
     Accessor &styler,
 	int defaultInterface) {
 
     char lineBuffer[1024] ;
-	unsigned int linePos = 0 ;
+	Sci_PositionU linePos = 0 ;
 
     // some day we can make something lexer.tex.mapping=(all,0)(nl,1)(en,2)...
 
     if (styler.SafeGetCharAt(0) == '%') {
-        for (unsigned int i = 0; i < startPos + length; i++) {
+        for (Sci_PositionU i = 0; i < startPos + length; i++) {
             lineBuffer[linePos++] = styler.SafeGetCharAt(i) ;
             if (endOfLine(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
                 lineBuffer[linePos] = '\0';
@@ -167,8 +168,8 @@ static int CheckTeXInterface(
 }
 
 static void ColouriseTeXDoc(
-    unsigned int startPos,
-    int length,
+    Sci_PositionU startPos,
+    Sci_Position length,
     int,
     WordList *keywordlists[],
     Accessor &styler) {
@@ -219,7 +220,7 @@ static void ColouriseTeXDoc(
 						sc.ForwardSetState(SCE_TEX_TEXT) ;
 					} else {
 						sc.GetCurrent(key, sizeof(key)-1) ;
-						k = strlen(key) ;
+						k = static_cast<int>(strlen(key)) ;
 						memmove(key,key+1,k) ; // shift left over escape token
 						key[k] = '\0' ;
 						k-- ;
@@ -242,8 +243,11 @@ static void ColouriseTeXDoc(
 					}
 				}
 				if (isTeXzero(sc.ch)) {
-					sc.SetState(SCE_TEX_SYMBOL) ;
-					sc.ForwardSetState(SCE_TEX_DEFAULT) ;
+					sc.SetState(SCE_TEX_SYMBOL);
+
+					if (!endOfLine(styler,sc.currentPos + 1))
+						sc.ForwardSetState(SCE_TEX_DEFAULT) ;
+
 					inComment = ! processComment ;
 					newifDone = false ;
 				} else if (isTeXseven(sc.ch) && isTeXseven(sc.chNext)) {
@@ -282,8 +286,8 @@ static void ColouriseTeXDoc(
 
 static inline bool isNumber(int ch) {
 	return
-      (ch == '0') || (ch == '1') || (ch == '2') || 
-      (ch == '3') || (ch == '4') || (ch == '5') || 
+      (ch == '0') || (ch == '1') || (ch == '2') ||
+      (ch == '3') || (ch == '4') || (ch == '5') ||
       (ch == '6') || (ch == '7') || (ch == '8') || (ch == '9');
 }
 
@@ -291,11 +295,11 @@ static inline bool isWordChar(int ch) {
 	return ((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z'));
 }
 
-static int ParseTeXCommand(unsigned int pos, Accessor &styler, char *command)
+static Sci_Position ParseTeXCommand(Sci_PositionU pos, Accessor &styler, char *command)
 {
-  int length=0;
+  Sci_Position length=0;
   char ch=styler.SafeGetCharAt(pos+1);
-  
+
   if(ch==',' || ch==':' || ch==';' || ch=='%'){
       command[0]=ch;
       command[1]=0;
@@ -308,14 +312,14 @@ static int ParseTeXCommand(unsigned int pos, Accessor &styler, char *command)
           length++;
           ch=styler.SafeGetCharAt(pos+length+1);
      }
-     
-  command[length]='\0';   
+
+  command[length]='\0';
   if(!length) return 0;
   return length+1;
 }
 
 static int classifyFoldPointTeXPaired(const char* s) {
-	int lev=0; 
+	int lev=0;
 	if (!(isdigit(s[0]) || (s[0] == '.'))){
 		if (strcmp(s, "begin")==0||strcmp(s,"FoldStart")==0||
 			strcmp(s,"abstract")==0||strcmp(s,"unprotect")==0||
@@ -327,14 +331,14 @@ static int classifyFoldPointTeXPaired(const char* s) {
 			strcmp(s,"maketitle")==0||strcmp(s,"protect")==0||
 			strncmp(s,"stop",4)==0||strncmp(s,"Stop",4)==0||
 			strcmp(s,"fi")==0
-			) 
+			)
 		lev=-1;
 	}
 	return lev;
 }
 
 static int classifyFoldPointTeXUnpaired(const char* s) {
-	int lev=0; 
+	int lev=0;
 	if (!(isdigit(s[0]) || (s[0] == '.'))){
 		if (strcmp(s,"part")==0||
 			strcmp(s,"chapter")==0||
@@ -356,36 +360,36 @@ static int classifyFoldPointTeXUnpaired(const char* s) {
 	return lev;
 }
 
-static bool IsTeXCommentLine(int line, Accessor &styler) {
-	int pos = styler.LineStart(line);
-	int eol_pos = styler.LineStart(line + 1) - 1;
-	
-	int startpos = pos;
+static bool IsTeXCommentLine(Sci_Position line, Accessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+
+	Sci_Position startpos = pos;
 
 	while (startpos<eol_pos){
 		char ch = styler[startpos];
 		if (ch!='%' && ch!=' ') return false;
 		else if (ch=='%') return true;
 		startpos++;
-	}		
+	}
 
 	return false;
 }
 
 // FoldTeXDoc: borrowed from VisualTeX with modifications
 
-static void FoldTexDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) 
+static void FoldTexDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *[], Accessor &styler)
 {
 	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	unsigned int endPos = startPos+length;
+	Sci_PositionU endPos = startPos+length;
 	int visibleChars=0;
-	int lineCurrent=styler.GetLine(startPos);
+	Sci_Position lineCurrent=styler.GetLine(startPos);
 	int levelPrev=styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
 	int levelCurrent=levelPrev;
 	char chNext=styler[startPos];
 	char buffer[100]="";
-	
-	for (unsigned int i=startPos; i < endPos; i++) {
+
+	for (Sci_PositionU i=startPos; i < endPos; i++) {
 		char ch=chNext;
 		chNext=styler.SafeGetCharAt(i+1);
 		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
@@ -409,12 +413,12 @@ static void FoldTexDoc(unsigned int startPos, int length, int, WordList *[], Acc
 	chNext4=styler.SafeGetCharAt(i+4);
 	chNext5=styler.SafeGetCharAt(i+5);
 
-	bool atEOfold = (ch == '%') && 
-			(chNext == '%') && (chNext2=='}') && 
+	bool atEOfold = (ch == '%') &&
+			(chNext == '%') && (chNext2=='}') &&
 				(chNext3=='}')&& (chNext4=='-')&& (chNext5=='-');
 
-	bool atBOfold = (ch == '%') && 
-			(chNext == '%') && (chNext2=='-') && 
+	bool atBOfold = (ch == '%') &&
+			(chNext == '%') && (chNext2=='-') &&
 				(chNext3=='-')&& (chNext4=='{')&& (chNext5=='{');
 
 	if(atBOfold){
@@ -424,11 +428,11 @@ static void FoldTexDoc(unsigned int startPos, int length, int, WordList *[], Acc
 	if(atEOfold){
 		levelCurrent-=1;
 	}
-	
+
 	if(ch=='\\' && chNext=='['){
 		levelCurrent+=1;
 	}
-	
+
 	if(ch=='\\' && chNext==']'){
 		levelCurrent-=1;
 	}
@@ -449,8 +453,8 @@ static void FoldTexDoc(unsigned int startPos, int length, int, WordList *[], Acc
                 levelCurrent--;
         }
 
-//---------------------------------------------------------------------------------------------	
-		
+//---------------------------------------------------------------------------------------------
+
 		if (atEOL) {
 			int lev = levelPrev;
 			if (visibleChars == 0 && foldCompact)
diff --git a/Pythonwin/Scintilla/lexers/LexTxt2tags.cxx b/Pythonwin/Scintilla/lexers/LexTxt2tags.cxx
new file mode 100644
index 000000000..6d1a954e0
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexTxt2tags.cxx
@@ -0,0 +1,478 @@
+/******************************************************************
+ *  LexTxt2tags.cxx
+ *
+ *  A simple Txt2tags lexer for scintilla.
+ *
+ *
+ *  Adapted by Eric Forgeot
+ *  Based on the LexMarkdown.cxx by Jon Strait - jstrait@moonloop.net
+ *
+ *  What could be improved:
+ *   - Verbatim lines could be like for raw lines : when there is no space between the ``` and the following text, the first letter should be colored so the user would understand there must be a space for a valid tag.
+ *   - marks such as bold, italic, strikeout, underline should begin to be highlighted only when they are closed and valid.
+ *   - verbatim and raw area should be highlighted too.
+ *
+ *  The License.txt file describes the conditions under which this
+ *  software may be distributed.
+ *
+ *****************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+using namespace Scintilla;
+
+
+
+static inline bool IsNewline(const int ch) {
+    return (ch == '\n' || ch == '\r');
+}
+
+// True if can follow ch down to the end with possibly trailing whitespace
+static bool FollowToLineEnd(const int ch, const int state, const Sci_PositionU endPos, StyleContext &sc) {
+    Sci_PositionU i = 0;
+    while (sc.GetRelative(++i) == ch)
+        ;
+    // Skip over whitespace
+    while (IsASpaceOrTab(sc.GetRelative(i)) && sc.currentPos + i < endPos)
+        ++i;
+    if (IsNewline(sc.GetRelative(i)) || sc.currentPos + i == endPos) {
+        sc.Forward(i);
+        sc.ChangeState(state);
+        sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+        return true;
+    }
+    else return false;
+}
+
+// Does the previous line have more than spaces and tabs?
+static bool HasPrevLineContent(StyleContext &sc) {
+    Sci_Position i = 0;
+    // Go back to the previous newline
+    while ((--i + sc.currentPos) && !IsNewline(sc.GetRelative(i)))
+        ;
+    while (--i + sc.currentPos) {
+        if (IsNewline(sc.GetRelative(i)))
+            break;
+        if (!IsASpaceOrTab(sc.GetRelative(i)))
+            return true;
+    }
+    return false;
+}
+
+// Separator line
+static bool IsValidHrule(const Sci_PositionU endPos, StyleContext &sc) {
+    int count = 1;
+    Sci_PositionU i = 0;
+    for (;;) {
+        ++i;
+        int c = sc.GetRelative(i);
+        if (c == sc.ch)
+            ++count;
+        // hit a terminating character
+        else if (!IsASpaceOrTab(c) || sc.currentPos + i == endPos) {
+            // Are we a valid HRULE
+            if ((IsNewline(c) || sc.currentPos + i == endPos) &&
+                    count >= 20 && !HasPrevLineContent(sc)) {
+                sc.SetState(SCE_TXT2TAGS_HRULE);
+                sc.Forward(i);
+                sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+                return true;
+            }
+            else {
+                sc.SetState(SCE_TXT2TAGS_DEFAULT);
+		return false;
+            }
+        }
+    }
+}
+
+static void ColorizeTxt2tagsDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
+                               WordList **, Accessor &styler) {
+    Sci_PositionU endPos = startPos + length;
+    int precharCount = 0;
+    // Don't advance on a new loop iteration and retry at the same position.
+    // Useful in the corner case of having to start at the beginning file position
+    // in the default state.
+    bool freezeCursor = false;
+
+    StyleContext sc(startPos, length, initStyle, styler);
+
+    while (sc.More()) {
+        // Skip past escaped characters
+        if (sc.ch == '\\') {
+            sc.Forward();
+            continue;
+        }
+
+        // A blockquotes resets the line semantics
+        if (sc.state == SCE_TXT2TAGS_BLOCKQUOTE){
+            sc.Forward(2);
+            sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+        }
+        // An option colors the whole line
+        if (sc.state == SCE_TXT2TAGS_OPTION){
+            FollowToLineEnd('%', SCE_TXT2TAGS_OPTION, endPos, sc);
+        }
+        if (sc.state == SCE_TXT2TAGS_POSTPROC){
+            FollowToLineEnd('%', SCE_TXT2TAGS_POSTPROC, endPos, sc);
+        }
+        if (sc.state == SCE_TXT2TAGS_PREPROC){
+            FollowToLineEnd('%', SCE_TXT2TAGS_PREPROC, endPos, sc);
+        }
+        // A comment colors the whole line
+        if (sc.state == SCE_TXT2TAGS_COMMENT){
+            FollowToLineEnd('%', SCE_TXT2TAGS_COMMENT, endPos, sc);
+        }
+        // Conditional state-based actions
+        if (sc.state == SCE_TXT2TAGS_CODE2) {
+        if (IsNewline(sc.ch))
+                sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+            if (sc.Match("``") && sc.GetRelative(-2) != ' ') {
+                sc.Forward(2);
+                sc.SetState(SCE_TXT2TAGS_DEFAULT);
+            }
+        }
+        // Table
+        else if (sc.state == SCE_TXT2TAGS_CODE) {
+        if (IsNewline(sc.ch))
+                sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+            if (sc.ch == '|' && sc.chPrev != ' ')
+                sc.ForwardSetState(SCE_TXT2TAGS_DEFAULT);
+        }
+        // Strong
+        else if (sc.state == SCE_TXT2TAGS_STRONG1) {
+        if (IsNewline(sc.ch))
+                sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+            if (sc.Match("**") && sc.chPrev != ' ') {
+                sc.Forward(2);
+                sc.SetState(SCE_TXT2TAGS_DEFAULT);
+            }
+        }
+        // Emphasis
+        else if (sc.state == SCE_TXT2TAGS_EM1) {
+        if (IsNewline(sc.ch))
+                sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+            if (sc.Match("//") && sc.chPrev != ' ') {
+                sc.Forward(2);
+                sc.ForwardSetState(SCE_TXT2TAGS_DEFAULT);
+           }
+        }
+        // Underline
+        else if (sc.state == SCE_TXT2TAGS_EM2) {
+        if (IsNewline(sc.ch))
+                sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+            if (sc.Match("__") && sc.chPrev != ' ') {
+                sc.Forward(2);
+                sc.ForwardSetState(SCE_TXT2TAGS_DEFAULT);
+           }
+        }
+        // codeblock
+        else if (sc.state == SCE_TXT2TAGS_CODEBK) {
+                if (IsNewline(sc.ch))
+                sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+            if (sc.atLineStart && sc.Match("```")) {
+                Sci_Position i = 1;
+                while (!IsNewline(sc.GetRelative(i)) && sc.currentPos + i < endPos)
+                    i++;
+                sc.Forward(i);
+                sc.SetState(SCE_TXT2TAGS_DEFAULT);
+            }
+        }
+        // strikeout
+        else if (sc.state == SCE_TXT2TAGS_STRIKEOUT) {
+        if (IsNewline(sc.ch))
+                sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+            if (sc.Match("--") && sc.chPrev != ' ') {
+                sc.Forward(2);
+                sc.SetState(SCE_TXT2TAGS_DEFAULT);
+            }
+        }
+        // Headers
+        else if (sc.state == SCE_TXT2TAGS_LINE_BEGIN) {
+            if (sc.Match("======"))
+                {
+                sc.SetState(SCE_TXT2TAGS_HEADER6);
+                sc.Forward();
+                }
+            else if (sc.Match("====="))
+                {
+                sc.SetState(SCE_TXT2TAGS_HEADER5);
+                sc.Forward();
+                }
+            else if (sc.Match("===="))
+                {
+                sc.SetState(SCE_TXT2TAGS_HEADER4);
+                sc.Forward();
+                }
+            else if (sc.Match("==="))
+                {
+                sc.SetState(SCE_TXT2TAGS_HEADER3);
+                sc.Forward();
+                }
+                //SetStateAndZoom(SCE_TXT2TAGS_HEADER3, 3, '=', sc);
+            else if (sc.Match("==")) {
+                sc.SetState(SCE_TXT2TAGS_HEADER2);
+                sc.Forward();
+                }
+                //SetStateAndZoom(SCE_TXT2TAGS_HEADER2, 2, '=', sc);
+            else if (sc.Match("=")) {
+                // Catch the special case of an unordered list
+                if (sc.chNext == '.' && IsASpaceOrTab(sc.GetRelative(2))) {
+                    precharCount = 0;
+                    sc.SetState(SCE_TXT2TAGS_PRECHAR);
+                }
+                else
+                    {
+                    sc.SetState(SCE_TXT2TAGS_HEADER1);
+                    sc.Forward();
+                    }
+                    //SetStateAndZoom(SCE_TXT2TAGS_HEADER1, 1, '=', sc);
+            }
+
+            // Numbered title
+            else if (sc.Match("++++++"))
+                {
+                sc.SetState(SCE_TXT2TAGS_HEADER6);
+                sc.Forward();
+                }
+            else if (sc.Match("+++++"))
+                {
+                sc.SetState(SCE_TXT2TAGS_HEADER5);
+                sc.Forward();
+                }
+            else if (sc.Match("++++"))
+                {
+                sc.SetState(SCE_TXT2TAGS_HEADER4);
+                sc.Forward();
+                }
+            else if (sc.Match("+++"))
+                {
+                sc.SetState(SCE_TXT2TAGS_HEADER3);
+                sc.Forward();
+                }
+                //SetStateAndZoom(SCE_TXT2TAGS_HEADER3, 3, '+', sc);
+            else if (sc.Match("++")) {
+                sc.SetState(SCE_TXT2TAGS_HEADER2);
+                sc.Forward();
+                }
+                //SetStateAndZoom(SCE_TXT2TAGS_HEADER2, 2, '+', sc);
+            else if (sc.Match("+")) {
+                // Catch the special case of an unordered list
+                if (sc.chNext == ' ' && IsASpaceOrTab(sc.GetRelative(1))) {
+                 //    if (IsNewline(sc.ch)) {
+                     	//precharCount = 0;
+                //		sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+                		//sc.SetState(SCE_TXT2TAGS_PRECHAR);
+				//	}
+                //    else {
+                //    precharCount = 0;
+                    sc.SetState(SCE_TXT2TAGS_OLIST_ITEM);
+                    sc.Forward(2);
+                    sc.SetState(SCE_TXT2TAGS_DEFAULT);
+               //     sc.SetState(SCE_TXT2TAGS_PRECHAR);
+				//	}
+                }
+                else
+                    {
+                    sc.SetState(SCE_TXT2TAGS_HEADER1);
+                    sc.Forward();
+                    }
+            }
+
+
+            // Codeblock
+            else if (sc.Match("```")) {
+                if (!HasPrevLineContent(sc))
+              //  if (!FollowToLineEnd(sc))
+                    sc.SetState(SCE_TXT2TAGS_CODEBK);
+                else
+                    sc.SetState(SCE_TXT2TAGS_DEFAULT);
+            }
+
+            // Preproc
+            else if (sc.Match("%!preproc")) {
+                sc.SetState(SCE_TXT2TAGS_PREPROC);
+            }
+            // Postproc
+            else if (sc.Match("%!postproc")) {
+                sc.SetState(SCE_TXT2TAGS_POSTPROC);
+            }
+            // Option
+            else if (sc.Match("%!")) {
+                sc.SetState(SCE_TXT2TAGS_OPTION);
+            }
+
+             // Comment
+            else if (sc.ch == '%') {
+                sc.SetState(SCE_TXT2TAGS_COMMENT);
+            }
+            // list
+            else if (sc.ch == '-') {
+                    precharCount = 0;
+                    sc.SetState(SCE_TXT2TAGS_PRECHAR);
+            }
+            // def list
+            else if (sc.ch == ':') {
+                    precharCount = 0;
+                   sc.SetState(SCE_TXT2TAGS_OLIST_ITEM);
+                   sc.Forward(1);
+                   sc.SetState(SCE_TXT2TAGS_PRECHAR);
+            }
+            else if (IsNewline(sc.ch))
+                sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+            else {
+                precharCount = 0;
+                sc.SetState(SCE_TXT2TAGS_PRECHAR);
+            }
+        }
+
+        // The header lasts until the newline
+        else if (sc.state == SCE_TXT2TAGS_HEADER1 || sc.state == SCE_TXT2TAGS_HEADER2 ||
+                sc.state == SCE_TXT2TAGS_HEADER3 || sc.state == SCE_TXT2TAGS_HEADER4 ||
+                sc.state == SCE_TXT2TAGS_HEADER5 || sc.state == SCE_TXT2TAGS_HEADER6) {
+            if (IsNewline(sc.ch))
+                sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+        }
+
+        // New state only within the initial whitespace
+        if (sc.state == SCE_TXT2TAGS_PRECHAR) {
+            // Blockquote
+            if (sc.Match("\"\"\"") && precharCount < 5){
+
+                sc.SetState(SCE_TXT2TAGS_BLOCKQUOTE);
+                sc.Forward(1);
+                }
+            /*
+            // Begin of code block
+            else if (!HasPrevLineContent(sc) && (sc.chPrev == '\t' || precharCount >= 4))
+                sc.SetState(SCE_TXT2TAGS_CODEBK);
+            */
+            // HRule - Total of 20 or more hyphens, asterisks, or underscores
+            // on a line by themselves
+            else if ((sc.ch == '-' ) && IsValidHrule(endPos, sc))
+                ;
+            // Unordered list
+            else if ((sc.ch == '-') && IsASpaceOrTab(sc.chNext)) {
+                sc.SetState(SCE_TXT2TAGS_ULIST_ITEM);
+                sc.ForwardSetState(SCE_TXT2TAGS_DEFAULT);
+            }
+            // Ordered list
+            else if (IsADigit(sc.ch)) {
+                Sci_Position digitCount = 0;
+                while (IsADigit(sc.GetRelative(++digitCount)))
+                    ;
+                if (sc.GetRelative(digitCount) == '.' &&
+                        IsASpaceOrTab(sc.GetRelative(digitCount + 1))) {
+                    sc.SetState(SCE_TXT2TAGS_OLIST_ITEM);
+                    sc.Forward(digitCount + 1);
+                    sc.SetState(SCE_TXT2TAGS_DEFAULT);
+                }
+            }
+            // Alternate Ordered list
+            else if (sc.ch == '+' && sc.chNext == ' ' && IsASpaceOrTab(sc.GetRelative(2))) {
+            //    sc.SetState(SCE_TXT2TAGS_OLIST_ITEM);
+            //    sc.Forward(2);
+             //   sc.SetState(SCE_TXT2TAGS_DEFAULT);
+            }
+            else if (sc.ch != ' ' || precharCount > 2)
+                sc.SetState(SCE_TXT2TAGS_DEFAULT);
+            else
+                ++precharCount;
+        }
+
+        // New state anywhere in doc
+        if (sc.state == SCE_TXT2TAGS_DEFAULT) {
+         //   if (sc.atLineStart && sc.ch == '#') {
+         //       sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+         //       freezeCursor = true;
+         //   }
+            // Links and Images
+            if (sc.Match("![") || sc.ch == '[') {
+                Sci_Position i = 0, j = 0, k = 0;
+                Sci_Position len = endPos - sc.currentPos;
+                while (i < len && (sc.GetRelative(++i) != ']' || sc.GetRelative(i - 1) == '\\'))
+                    ;
+                if (sc.GetRelative(i) == ']') {
+                    j = i;
+                    if (sc.GetRelative(++i) == '(') {
+                        while (i < len && (sc.GetRelative(++i) != '(' || sc.GetRelative(i - 1) == '\\'))
+                            ;
+                        if (sc.GetRelative(i) == '(')
+                            k = i;
+                    }
+
+                    else if (sc.GetRelative(i) == '[' || sc.GetRelative(++i) == '[') {
+                        while (i < len && (sc.GetRelative(++i) != ']' || sc.GetRelative(i - 1) == '\\'))
+                            ;
+                        if (sc.GetRelative(i) == ']')
+                            k = i;
+                    }
+                }
+                // At least a link text
+                if (j) {
+                    sc.SetState(SCE_TXT2TAGS_LINK);
+                    sc.Forward(j);
+                    // Also has a URL or reference portion
+                    if (k)
+                        sc.Forward(k - j);
+                    sc.ForwardSetState(SCE_TXT2TAGS_DEFAULT);
+                }
+            }
+            // Code - also a special case for alternate inside spacing
+            if (sc.Match("``") && sc.GetRelative(3) != ' ') {
+                sc.SetState(SCE_TXT2TAGS_CODE2);
+                sc.Forward();
+            }
+            else if (sc.ch == '|' && sc.GetRelative(3) != ' ') {
+                sc.SetState(SCE_TXT2TAGS_CODE);
+            }
+            // Strong
+            else if (sc.Match("**") && sc.GetRelative(2) != ' ') {
+                sc.SetState(SCE_TXT2TAGS_STRONG1);
+                sc.Forward();
+           }
+            // Emphasis
+            else if (sc.Match("//") && sc.GetRelative(2) != ' ') {
+                sc.SetState(SCE_TXT2TAGS_EM1);
+                sc.Forward();
+            }
+            else if (sc.Match("__") && sc.GetRelative(2) != ' ') {
+                sc.SetState(SCE_TXT2TAGS_EM2);
+                sc.Forward();
+            }
+            // Strikeout
+            else if (sc.Match("--") && sc.GetRelative(2) != ' ') {
+                sc.SetState(SCE_TXT2TAGS_STRIKEOUT);
+                sc.Forward();
+            }
+
+            // Beginning of line
+            else if (IsNewline(sc.ch))
+                sc.SetState(SCE_TXT2TAGS_LINE_BEGIN);
+        }
+        // Advance if not holding back the cursor for this iteration.
+        if (!freezeCursor)
+            sc.Forward();
+        freezeCursor = false;
+    }
+    sc.Complete();
+}
+
+LexerModule lmTxt2tags(SCLEX_TXT2TAGS, ColorizeTxt2tagsDoc, "txt2tags");
+
+
diff --git a/Pythonwin/Scintilla/src/LexVB.cxx b/Pythonwin/Scintilla/lexers/LexVB.cxx
similarity index 81%
rename from Pythonwin/Scintilla/src/LexVB.cxx
rename to Pythonwin/Scintilla/lexers/LexVB.cxx
index a1f9ec7ae..ceac8d2fe 100644
--- a/Pythonwin/Scintilla/src/LexVB.cxx
+++ b/Pythonwin/Scintilla/lexers/LexVB.cxx
@@ -7,28 +7,29 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 // Internal state, highlighted as number
 #define SCE_B_FILENUMBER SCE_B_DEFAULT+100
 
 
-static bool IsVBComment(Accessor &styler, int pos, int len) {
+static bool IsVBComment(Accessor &styler, Sci_Position pos, Sci_Position len) {
 	return len > 0 && styler[pos] == '\'';
 }
 
@@ -52,10 +53,10 @@ static inline bool IsANumberChar(int ch) {
 	// but probably enough in most cases.
 	return (ch < 0x80) &&
 	        (isdigit(ch) || toupper(ch) == 'E' ||
-             ch == '.' || ch == '-' || ch == '+');
+             ch == '.' || ch == '-' || ch == '+' || ch == '_');
 }
 
-static void ColouriseVBDoc(unsigned int startPos, int length, int initStyle,
+static void ColouriseVBDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                            WordList *keywordlists[], Accessor &styler, bool vbScriptSyntax) {
 
 	WordList &keywords = *keywordlists[0];
@@ -198,6 +199,10 @@ static void ColouriseVBDoc(unsigned int startPos, int length, int initStyle,
 				// Octal number
 				sc.SetState(SCE_B_NUMBER);
 				sc.Forward();
+			} else if (sc.ch == '&' && tolower(sc.chNext) == 'b') {
+				// Binary number
+				sc.SetState(SCE_B_NUMBER);
+				sc.Forward();
 			} else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
 				sc.SetState(SCE_B_NUMBER);
 			} else if (IsAWordStart(sc.ch) || (sc.ch == '[')) {
@@ -214,15 +219,49 @@ static void ColouriseVBDoc(unsigned int startPos, int length, int initStyle,
 			visibleChars++;
 		}
 	}
+
+	if (sc.state == SCE_B_IDENTIFIER && !IsAWordChar(sc.ch)) {
+		// In Basic (except VBScript), a variable name or a function name
+		// can end with a special character indicating the type of the value
+		// held or returned.
+		bool skipType = false;
+		if (!vbScriptSyntax && IsTypeCharacter(sc.ch)) {
+			sc.Forward();	// Skip it
+			skipType = true;
+		}
+		if (sc.ch == ']') {
+			sc.Forward();
+		}
+		char s[100];
+		sc.GetCurrentLowered(s, sizeof(s));
+		if (skipType) {
+			s[strlen(s) - 1] = '\0';
+		}
+		if (strcmp(s, "rem") == 0) {
+			sc.ChangeState(SCE_B_COMMENT);
+		} else {
+			if (keywords.InList(s)) {
+				sc.ChangeState(SCE_B_KEYWORD);
+			} else if (keywords2.InList(s)) {
+				sc.ChangeState(SCE_B_KEYWORD2);
+			} else if (keywords3.InList(s)) {
+				sc.ChangeState(SCE_B_KEYWORD3);
+			} else if (keywords4.InList(s)) {
+				sc.ChangeState(SCE_B_KEYWORD4);
+			}	// Else, it is really an identifier...
+			sc.SetState(SCE_B_DEFAULT);
+		}
+	}
+
 	sc.Complete();
 }
 
-static void FoldVBDoc(unsigned int startPos, int length, int,
+static void FoldVBDoc(Sci_PositionU startPos, Sci_Position length, int,
 						   WordList *[], Accessor &styler) {
-	int endPos = startPos + length;
+	Sci_Position endPos = startPos + length;
 
 	// Backtrack to previous line in case need to fix its fold status
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	if (startPos > 0) {
 		if (lineCurrent > 0) {
 			lineCurrent--;
@@ -232,7 +271,7 @@ static void FoldVBDoc(unsigned int startPos, int length, int,
 	int spaceFlags = 0;
 	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, IsVBComment);
 	char chNext = styler[startPos];
-	for (int i = startPos; i < endPos; i++) {
+	for (Sci_Position i = startPos; i < endPos; i++) {
 		char ch = chNext;
 		chNext = styler.SafeGetCharAt(i + 1);
 
@@ -259,12 +298,12 @@ static void FoldVBDoc(unsigned int startPos, int length, int,
 	}
 }
 
-static void ColouriseVBNetDoc(unsigned int startPos, int length, int initStyle,
+static void ColouriseVBNetDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                            WordList *keywordlists[], Accessor &styler) {
 	ColouriseVBDoc(startPos, length, initStyle, keywordlists, styler, false);
 }
 
-static void ColouriseVBScriptDoc(unsigned int startPos, int length, int initStyle,
+static void ColouriseVBScriptDoc(Sci_PositionU startPos, Sci_Position length, int initStyle,
                            WordList *keywordlists[], Accessor &styler) {
 	ColouriseVBDoc(startPos, length, initStyle, keywordlists, styler, true);
 }
diff --git a/Pythonwin/Scintilla/src/LexVHDL.cxx b/Pythonwin/Scintilla/lexers/LexVHDL.cxx
similarity index 61%
rename from Pythonwin/Scintilla/src/LexVHDL.cxx
rename to Pythonwin/Scintilla/lexers/LexVHDL.cxx
index c082cdb92..a1426c815 100644
--- a/Pythonwin/Scintilla/src/LexVHDL.cxx
+++ b/Pythonwin/Scintilla/lexers/LexVHDL.cxx
@@ -1,9 +1,9 @@
 // Scintilla source code edit control
 /** @file LexVHDL.cxx
  ** Lexer for VHDL
- ** Written by Phil Reid, 
+ ** Written by Phil Reid,
  ** Based on:
- **  - The Verilog Lexer by Avi Yegudin 
+ **  - The Verilog Lexer by Avi Yegudin
  **  - The Fortran Lexer by Chuan-jian Shen
  **  - The C++ lexer by Neil Hodgson
  **/
@@ -12,26 +12,27 @@
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static void ColouriseVHDLDoc(
-  unsigned int startPos,
-  int length,
+  Sci_PositionU startPos,
+  Sci_Position length,
   int initStyle,
   WordList *keywordlists[],
   Accessor &styler);
@@ -48,14 +49,14 @@ static inline bool IsAWordStart(const int ch) {
 }
 
 /***************************************/
-inline bool IsABlank(unsigned int ch) {
-    return (ch == ' ') || (ch == 0x09) || (ch == 0x0b) ;
+static inline bool IsABlank(unsigned int ch) {
+  return (ch == ' ') || (ch == 0x09) || (ch == 0x0b) ;
 }
 
 /***************************************/
 static void ColouriseVHDLDoc(
-  unsigned int startPos,
-  int length,
+  Sci_PositionU startPos,
+  Sci_Position length,
   int initStyle,
   WordList *keywordlists[],
   Accessor &styler)
@@ -69,9 +70,11 @@ static void ColouriseVHDLDoc(
   WordList &User       = *keywordlists[6];
 
   StyleContext sc(startPos, length, initStyle, styler);
+  bool isExtendedId = false;    // true when parsing an extended identifier
 
-  for (; sc.More(); sc.Forward())
+  while (sc.More())
   {
+    bool advance = true;
 
     // Determine if the current state should terminate.
     if (sc.state == SCE_VHDL_OPERATOR) {
@@ -81,7 +84,7 @@ static void ColouriseVHDLDoc(
         sc.SetState(SCE_VHDL_DEFAULT);
       }
     } else if (sc.state == SCE_VHDL_IDENTIFIER) {
-      if (!IsAWordChar(sc.ch) || (sc.ch == '.')) {
+      if (!isExtendedId && (!IsAWordChar(sc.ch) || (sc.ch == '.'))) {
         char s[100];
         sc.GetCurrentLowered(s, sizeof(s));
         if (Keywords.InList(s)) {
@@ -100,20 +103,33 @@ static void ColouriseVHDLDoc(
           sc.ChangeState(SCE_VHDL_USERWORD);
         }
         sc.SetState(SCE_VHDL_DEFAULT);
+      } else if (isExtendedId && ((sc.ch == '\\') || sc.atLineEnd)) {
+        // extended identifiers are terminated by backslash, check for end of line in case we have invalid syntax
+        isExtendedId = false;
+        sc.ForwardSetState(SCE_VHDL_DEFAULT);
+        advance = false;
       }
-    } else if (sc.state == SCE_VHDL_COMMENT || sc.state == SCE_V_COMMENTLINEBANG) {
+    } else if (sc.state == SCE_VHDL_COMMENT || sc.state == SCE_VHDL_COMMENTLINEBANG) {
       if (sc.atLineEnd) {
         sc.SetState(SCE_VHDL_DEFAULT);
       }
     } else if (sc.state == SCE_VHDL_STRING) {
-      if (sc.ch == '\\') {
-        if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+      if (sc.ch == '"') {
+        advance = false;
+        sc.Forward();
+        if (sc.ch == '"')
           sc.Forward();
-        }
-      } else if (sc.ch == '\"') {
-        sc.ForwardSetState(SCE_VHDL_DEFAULT);
+        else
+          sc.SetState(SCE_VHDL_DEFAULT);
       } else if (sc.atLineEnd) {
-        sc.ChangeState(SCE_V_STRINGEOL);
+        advance = false;
+        sc.ChangeState(SCE_VHDL_STRINGEOL);
+        sc.ForwardSetState(SCE_VHDL_DEFAULT);
+      }
+    } else if (sc.state == SCE_VHDL_BLOCK_COMMENT){
+      if(sc.ch == '*' && sc.chNext == '/'){
+        advance = false;
+        sc.Forward();
         sc.ForwardSetState(SCE_VHDL_DEFAULT);
       }
     }
@@ -124,51 +140,100 @@ static void ColouriseVHDLDoc(
         sc.SetState(SCE_VHDL_NUMBER);
       } else if (IsAWordStart(sc.ch)) {
         sc.SetState(SCE_VHDL_IDENTIFIER);
-      } else if (sc.Match('-', '-')) {
-        sc.SetState(SCE_VHDL_COMMENT);
-        sc.Forward(); 
       } else if (sc.Match('-', '-')) {
         if (sc.Match("--!"))  // Nice to have a different comment style
           sc.SetState(SCE_VHDL_COMMENTLINEBANG);
         else
           sc.SetState(SCE_VHDL_COMMENT);
-      } else if (sc.ch == '\"') {
+      } else if (sc.Match('/', '*')){
+        sc.SetState(SCE_VHDL_BLOCK_COMMENT);
+      } else if (sc.ch == '"') {
         sc.SetState(SCE_VHDL_STRING);
+      } else if (sc.ch == '\'') {
+        if (sc.GetRelative(2) == '\''){
+          if (sc.chNext != '(' || sc.GetRelative(4) != '\''){
+            // Can only be a character literal
+            sc.SetState(SCE_VHDL_STRING);
+            sc.Forward();
+            sc.Forward();
+            sc.ForwardSetState(SCE_VHDL_DEFAULT);
+            advance = false;
+          } // else can be a tick or a character literal, need more context, eg.: identifier'('x')
+        } // else can only be a tick
+      } else if (sc.ch == '\\') {
+        isExtendedId = true;
+        sc.SetState(SCE_VHDL_IDENTIFIER);
       } else if (isoperator(static_cast<char>(sc.ch))) {
         sc.SetState(SCE_VHDL_OPERATOR);
       }
     }
+
+    if (advance)
+      sc.Forward();
   }
   sc.Complete();
 }
 //=============================================================================
-static bool IsCommentLine(int line, Accessor &styler) {
-	int pos = styler.LineStart(line);
-	int eol_pos = styler.LineStart(line + 1) - 1;
-	for (int i = pos; i < eol_pos; i++) {
-		char ch = styler[i];
-		char chNext = styler[i+1];
-		if ((ch == '-') && (chNext == '-'))
-			return true;
-		else if (ch != ' ' && ch != '\t')
-			return false;
-	}
-	return false;
+static bool IsCommentLine(Sci_Position line, Accessor &styler) {
+  Sci_Position pos = styler.LineStart(line);
+  Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+  for (Sci_Position i = pos; i < eol_pos; i++) {
+    char ch = styler[i];
+    char chNext = styler[i+1];
+    if ((ch == '-') && (chNext == '-'))
+      return true;
+    else if (ch != ' ' && ch != '\t')
+      return false;
+  }
+  return false;
+}
+static bool IsCommentBlockStart(Sci_Position line, Accessor &styler)
+{
+  Sci_Position pos = styler.LineStart(line);
+  Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+  for (Sci_Position i = pos; i < eol_pos; i++) {
+    char ch = styler[i];
+    char chNext = styler[i+1];
+    char style = styler.StyleAt(i);
+    if ((style == SCE_VHDL_BLOCK_COMMENT) && (ch == '/') && (chNext == '*'))
+      return true;
+  }
+  return false;
+}
+
+static bool IsCommentBlockEnd(Sci_Position line, Accessor &styler)
+{
+  Sci_Position pos = styler.LineStart(line);
+  Sci_Position eol_pos = styler.LineStart(line + 1) - 1;
+
+  for (Sci_Position i = pos; i < eol_pos; i++) {
+    char ch = styler[i];
+    char chNext = styler[i+1];
+    char style = styler.StyleAt(i);
+    if ((style == SCE_VHDL_BLOCK_COMMENT) && (ch == '*') && (chNext == '/'))
+      return true;
+  }
+  return false;
+}
+
+static bool IsCommentStyle(char style)
+{
+  return style == SCE_VHDL_BLOCK_COMMENT || style == SCE_VHDL_COMMENT || style == SCE_VHDL_COMMENTLINEBANG;
 }
 
 //=============================================================================
 // Folding the code
 static void FoldNoBoxVHDLDoc(
-  unsigned int startPos,
-  int length,
-  int initStyle,
+  Sci_PositionU startPos,
+  Sci_Position length,
+  int,
   Accessor &styler)
 {
   // Decided it would be smarter to have the lexer have all keywords included. Therefore I
   // don't check if the style for the keywords that I use to adjust the levels.
   char words[] =
-    "architecture begin case component else elsif end entity generate loop package process record then "
-    "procedure function when";
+    "architecture begin block case component else elsif end entity generate loop package process record then "
+    "procedure protected function when units";
   WordList keywords;
   keywords.Set(words);
 
@@ -180,46 +245,46 @@ static void FoldNoBoxVHDLDoc(
   //bool foldAtWhen       = styler.GetPropertyInt("fold.at.When", 1) != 0;  //< fold at when in case statements
 
   int  visibleChars     = 0;
-  unsigned int endPos   = startPos + length;
+  Sci_PositionU endPos   = startPos + length;
 
-  int lineCurrent       = styler.GetLine(startPos);
+  Sci_Position lineCurrent       = styler.GetLine(startPos);
   int levelCurrent      = SC_FOLDLEVELBASE;
   if(lineCurrent > 0)
     levelCurrent        = styler.LevelAt(lineCurrent-1) >> 16;
   //int levelMinCurrent   = levelCurrent;
-  int levelMinCurrentElse = levelCurrent;   //< Used for folding at 'else'
-  int levelMinCurrentBegin = levelCurrent;  //< Used for folding at 'begin'
+  int levelMinCurrentElse = levelCurrent;   ///< Used for folding at 'else'
+  int levelMinCurrentBegin = levelCurrent;  ///< Used for folding at 'begin'
   int levelNext         = levelCurrent;
 
   /***************************************/
-  int lastStart         = 0;
+  Sci_Position lastStart         = 0;
   char prevWord[32]     = "";
 
   /***************************************/
   // Find prev word
   // The logic for going up or down a level depends on a the previous keyword
   // This code could be cleaned up.
-  int end = 0;
-  unsigned int j;
+  Sci_Position end = 0;
+  Sci_PositionU j;
   for(j = startPos; j>0; j--)
   {
     char ch       = styler.SafeGetCharAt(j);
     char chPrev   = styler.SafeGetCharAt(j-1);
     int style     = styler.StyleAt(j);
     int stylePrev = styler.StyleAt(j-1);
-    if ((stylePrev != SCE_VHDL_COMMENT) && (stylePrev != SCE_VHDL_STRING))
+    if ((!IsCommentStyle(style)) && (stylePrev != SCE_VHDL_STRING))
     {
       if(IsAWordChar(chPrev) && !IsAWordChar(ch))
       {
         end = j-1;
       }
     }
-    if ((style != SCE_VHDL_COMMENT) && (style != SCE_VHDL_STRING))
+    if ((!IsCommentStyle(style)) && (style != SCE_VHDL_STRING))
     {
       if(!IsAWordChar(chPrev) && IsAWordStart(ch) && (end != 0))
       {
         char s[32];
-        unsigned int k;
+        Sci_PositionU k;
         for(k=0; (k<31 ) && (k<end-j+1 ); k++) {
           s[k] = static_cast<char>(tolower(styler[j+k]));
         }
@@ -232,11 +297,11 @@ static void FoldNoBoxVHDLDoc(
       }
     }
   }
-  for(j=j+strlen(prevWord); j<endPos; j++)
+  for(j=j+static_cast<Sci_PositionU>(strlen(prevWord)); j<endPos; j++)
   {
     char ch       = styler.SafeGetCharAt(j);
     int style     = styler.StyleAt(j);
-    if ((style != SCE_VHDL_COMMENT) && (style != SCE_VHDL_STRING))
+    if ((!IsCommentStyle(style)) && (style != SCE_VHDL_STRING))
     {
       if((ch == ';') && (strcmp(prevWord, "end") == 0))
       {
@@ -249,35 +314,48 @@ static void FoldNoBoxVHDLDoc(
   char  chPrev          = '\0';
   char  chNextNonBlank;
   int   styleNext       = styler.StyleAt(startPos);
-  int   style           = initStyle;
   //Platform::DebugPrintf("Line[%04d] Prev[%20s] ************************* Level[%x]\n", lineCurrent+1, prevWord, levelCurrent);
 
   /***************************************/
-  for (unsigned int i = startPos; i < endPos; i++)
+  for (Sci_PositionU i = startPos; i < endPos; i++)
   {
     char ch         = chNext;
     chNext          = styler.SafeGetCharAt(i + 1);
     chPrev          = styler.SafeGetCharAt(i - 1);
     chNextNonBlank  = chNext;
-    unsigned int j  = i+1;
+    Sci_PositionU j  = i+1;
     while(IsABlank(chNextNonBlank) && j<endPos)
     {
       j ++ ;
       chNextNonBlank = styler.SafeGetCharAt(j);
     }
-    style           = styleNext;
+    int style           = styleNext;
     styleNext       = styler.StyleAt(i + 1);
     bool atEOL      = (ch == '\r' && chNext != '\n') || (ch == '\n');
 
-		if (foldComment && atEOL && IsCommentLine(lineCurrent, styler)) 
+    if (foldComment && atEOL)
     {
-      if(!IsCommentLine(lineCurrent-1, styler) && IsCommentLine(lineCurrent+1, styler))
+      if(IsCommentLine(lineCurrent, styler))
       {
-        levelNext++;
-      } 
-      else if(IsCommentLine(lineCurrent-1, styler) && !IsCommentLine(lineCurrent+1, styler))
+        if(!IsCommentLine(lineCurrent-1, styler) && IsCommentLine(lineCurrent+1, styler))
+        {
+          levelNext++;
+        }
+        else if(IsCommentLine(lineCurrent-1, styler) && !IsCommentLine(lineCurrent+1, styler))
+        {
+          levelNext--;
+        }
+      }
+      else
       {
-        levelNext--;
+        if (IsCommentBlockStart(lineCurrent, styler) && !IsCommentBlockEnd(lineCurrent, styler))
+        {
+          levelNext++;
+        }
+        else if (IsCommentBlockEnd(lineCurrent, styler) && !IsCommentBlockStart(lineCurrent, styler))
+        {
+          levelNext--;
+        }
       }
     }
 
@@ -290,7 +368,7 @@ static void FoldNoBoxVHDLDoc(
       }
     }
 
-    if ((style != SCE_VHDL_COMMENT) && (style != SCE_VHDL_STRING))
+    if ((!IsCommentStyle(style)) && (style != SCE_VHDL_STRING))
     {
       if((ch == ';') && (strcmp(prevWord, "end") == 0))
       {
@@ -302,9 +380,9 @@ static void FoldNoBoxVHDLDoc(
         lastStart = i;
       }
 
-      if(iswordchar(ch) && !iswordchar(chNext)) {
+      if(IsAWordChar(ch) && !IsAWordChar(chNext)) {
         char s[32];
-        unsigned int k;
+        Sci_PositionU k;
         for(k=0; (k<31 ) && (k<i-lastStart+1 ); k++) {
           s[k] = static_cast<char>(tolower(styler[lastStart+k]));
         }
@@ -315,14 +393,15 @@ static void FoldNoBoxVHDLDoc(
           if (
             strcmp(s, "architecture") == 0  ||
             strcmp(s, "case") == 0          ||
-            strcmp(s, "component") == 0     ||
-            strcmp(s, "entity") == 0        ||
             strcmp(s, "generate") == 0      ||
+            strcmp(s, "block") == 0         ||
             strcmp(s, "loop") == 0          ||
             strcmp(s, "package") ==0        ||
             strcmp(s, "process") == 0       ||
+            strcmp(s, "protected") == 0     ||
             strcmp(s, "record") == 0        ||
-            strcmp(s, "then") == 0)
+            strcmp(s, "then") == 0          ||
+            strcmp(s, "units") == 0)
           {
             if (strcmp(prevWord, "end") != 0)
             {
@@ -331,6 +410,35 @@ static void FoldNoBoxVHDLDoc(
               }
               levelNext++;
             }
+          } else if (
+            strcmp(s, "component") == 0      ||
+            strcmp(s, "entity") == 0         ||
+            strcmp(s, "configuration") == 0 )
+          {
+            if (strcmp(prevWord, "end") != 0)
+            { // check for instantiated unit by backward searching for the colon.
+              Sci_PositionU pos = lastStart;
+              char chAtPos=0, styleAtPos;
+              do{// skip white spaces
+                if(!pos)
+                  break;
+                pos--;
+                styleAtPos = styler.StyleAt(pos);
+                chAtPos = styler.SafeGetCharAt(pos);
+              }while(pos &&
+                     (chAtPos == ' ' || chAtPos == '\t' ||
+                      chAtPos == '\n' || chAtPos == '\r' ||
+                      IsCommentStyle(styleAtPos)));
+
+              // check for a colon (':') before the instantiated units "entity", "component" or "configuration". Don't fold thereafter.
+              if (chAtPos != ':')
+              {
+                if (levelMinCurrentElse > levelNext) {
+                  levelMinCurrentElse = levelNext;
+                }
+                levelNext++;
+              }
+            }
           } else if (
             strcmp(s, "procedure") == 0     ||
             strcmp(s, "function") == 0)
@@ -339,19 +447,19 @@ static void FoldNoBoxVHDLDoc(
             { // This code checks to see if the procedure / function is a definition within a "package"
               // rather than the actual code in the body.
               int BracketLevel = 0;
-              for(int j=i+1; j<styler.Length(); j++)
+              for(Sci_Position pos=i+1; pos<styler.Length(); pos++)
               {
-                int LocalStyle = styler.StyleAt(j);
-                char LocalCh = styler.SafeGetCharAt(j);
-                if(LocalCh == '(') BracketLevel++;
-                if(LocalCh == ')') BracketLevel--;
+                int styleAtPos = styler.StyleAt(pos);
+                char chAtPos = styler.SafeGetCharAt(pos);
+                if(chAtPos == '(') BracketLevel++;
+                if(chAtPos == ')') BracketLevel--;
                 if(
                   (BracketLevel == 0) &&
-                  (LocalStyle != SCE_VHDL_COMMENT) &&
-                  (LocalStyle != SCE_VHDL_STRING) &&
-                  !iswordchar(styler.SafeGetCharAt(j-1)) &&
-                  styler.Match(j, "is") &&
-                  !iswordchar(styler.SafeGetCharAt(j+2)))
+                  (!IsCommentStyle(styleAtPos)) &&
+                  (styleAtPos != SCE_VHDL_STRING) &&
+                  !iswordchar(styler.SafeGetCharAt(pos-1)) &&
+                  (chAtPos|' ')=='i' && (styler.SafeGetCharAt(pos+1)|' ')=='s' &&
+                  !iswordchar(styler.SafeGetCharAt(pos+2)))
                 {
                   if (levelMinCurrentElse > levelNext) {
                     levelMinCurrentElse = levelNext;
@@ -359,7 +467,7 @@ static void FoldNoBoxVHDLDoc(
                   levelNext++;
                   break;
                 }
-                if((BracketLevel == 0) && (LocalCh == ';'))
+                if((BracketLevel == 0) && (chAtPos == ';'))
                 {
                   break;
                 }
@@ -380,7 +488,7 @@ static void FoldNoBoxVHDLDoc(
             ((strcmp(s, "begin") == 0) && (strcmp(prevWord, "function") == 0)) ||
             ((strcmp(s, "begin") == 0) && (strcmp(prevWord, "procedure") == 0)))
           {
-            levelMinCurrentBegin = levelNext - 1;  
+            levelMinCurrentBegin = levelNext - 1;
           }
           //Platform::DebugPrintf("Line[%04d] Prev[%20s] Cur[%20s] Level[%x]\n", lineCurrent+1, prevWord, s, levelCurrent);
           strcpy(prevWord, s);
@@ -422,7 +530,7 @@ static void FoldNoBoxVHDLDoc(
 }
 
 //=============================================================================
-static void FoldVHDLDoc(unsigned int startPos, int length, int initStyle, WordList *[],
+static void FoldVHDLDoc(Sci_PositionU startPos, Sci_Position length, int initStyle, WordList *[],
                        Accessor &styler) {
   FoldNoBoxVHDLDoc(startPos, length, initStyle, styler);
 }
@@ -444,34 +552,34 @@ LexerModule lmVHDL(SCLEX_VHDL, ColouriseVHDLDoc, "vhdl", FoldVHDLDoc, VHDLWordLi
 
 
 // Keyword:
-//    access after alias all architecture array assert attribute begin block body buffer bus case component 
-//    configuration constant disconnect downto else elsif end entity exit file for function generate generic 
-//    group guarded if impure in inertial inout is label library linkage literal loop map new next null of 
-//    on open others out package port postponed procedure process pure range record register reject report 
-//    return select severity shared signal subtype then to transport type unaffected units until use variable 
+//    access after alias all architecture array assert attribute begin block body buffer bus case component
+//    configuration constant disconnect downto else elsif end entity exit file for function generate generic
+//    group guarded if impure in inertial inout is label library linkage literal loop map new next null of
+//    on open others out package port postponed procedure process pure range record register reject report
+//    return select severity shared signal subtype then to transport type unaffected units until use variable
 //    wait when while with
 //
 // Operators:
 //    abs and mod nand nor not or rem rol ror sla sll sra srl xnor xor
 //
 // Attributes:
-//    left right low high ascending image value pos val succ pred leftof rightof base range reverse_range 
-//    length delayed stable quiet transaction event active last_event last_active last_value driving 
+//    left right low high ascending image value pos val succ pred leftof rightof base range reverse_range
+//    length delayed stable quiet transaction event active last_event last_active last_value driving
 //    driving_value simple_name path_name instance_name
 //
 // Std Functions:
-//    now readline read writeline write endfile resolved to_bit to_bitvector to_stdulogic to_stdlogicvector 
-//    to_stdulogicvector to_x01 to_x01z to_UX01 rising_edge falling_edge is_x shift_left shift_right rotate_left 
+//    now readline read writeline write endfile resolved to_bit to_bitvector to_stdulogic to_stdlogicvector
+//    to_stdulogicvector to_x01 to_x01z to_UX01 rising_edge falling_edge is_x shift_left shift_right rotate_left
 //    rotate_right resize to_integer to_unsigned to_signed std_match to_01
 //
 // Std Packages:
-//    std ieee work standard textio std_logic_1164 std_logic_arith std_logic_misc std_logic_signed 
-//    std_logic_textio std_logic_unsigned numeric_bit numeric_std math_complex math_real vital_primitives 
+//    std ieee work standard textio std_logic_1164 std_logic_arith std_logic_misc std_logic_signed
+//    std_logic_textio std_logic_unsigned numeric_bit numeric_std math_complex math_real vital_primitives
 //    vital_timing
 //
 // Std Types:
-//    boolean bit character severity_level integer real time delay_length natural positive string bit_vector 
-//    file_open_kind file_open_status line text side width std_ulogic std_ulogic_vector std_logic 
+//    boolean bit character severity_level integer real time delay_length natural positive string bit_vector
+//    file_open_kind file_open_status line text side width std_ulogic std_ulogic_vector std_logic
 //    std_logic_vector X01 X01Z UX01 UX01Z unsigned signed
 //
 
diff --git a/Pythonwin/Scintilla/lexers/LexVerilog.cxx b/Pythonwin/Scintilla/lexers/LexVerilog.cxx
new file mode 100644
index 000000000..ac5859e93
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexVerilog.cxx
@@ -0,0 +1,1081 @@
+// Scintilla source code edit control
+/** @file LexVerilog.cxx
+ ** Lexer for Verilog.
+ ** Written by Avi Yegudin, based on C++ lexer by Neil Hodgson
+ **/
+// Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <string>
+#include <vector>
+#include <map>
+#include <algorithm>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
+
+#include "OptionSet.h"
+#include "SubStyles.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+namespace {
+	// Use an unnamed namespace to protect the functions and classes from name conflicts
+
+struct PPDefinition {
+	Sci_Position line;
+	std::string key;
+	std::string value;
+	bool isUndef;
+	std::string arguments;
+	PPDefinition(Sci_Position line_, const std::string &key_, const std::string &value_, bool isUndef_ = false, std::string arguments_="") :
+		line(line_), key(key_), value(value_), isUndef(isUndef_), arguments(arguments_) {
+	}
+};
+
+class LinePPState {
+	int state;
+	int ifTaken;
+	int level;
+	bool ValidLevel() const {
+		return level >= 0 && level < 32;
+	}
+	int maskLevel() const {
+		if (level >= 0) {
+			return 1 << level;
+		} else {
+			return 1;
+		}
+	}
+public:
+	LinePPState() : state(0), ifTaken(0), level(-1) {
+	}
+	bool IsInactive() const {
+		return state != 0;
+	}
+	bool CurrentIfTaken() const {
+		return (ifTaken & maskLevel()) != 0;
+	}
+	void StartSection(bool on) {
+		level++;
+		if (ValidLevel()) {
+			if (on) {
+				state &= ~maskLevel();
+				ifTaken |= maskLevel();
+			} else {
+				state |= maskLevel();
+				ifTaken &= ~maskLevel();
+			}
+		}
+	}
+	void EndSection() {
+		if (ValidLevel()) {
+			state &= ~maskLevel();
+			ifTaken &= ~maskLevel();
+		}
+		level--;
+	}
+	void InvertCurrentLevel() {
+		if (ValidLevel()) {
+			state ^= maskLevel();
+			ifTaken |= maskLevel();
+		}
+	}
+};
+
+// Hold the preprocessor state for each line seen.
+// Currently one entry per line but could become sparse with just one entry per preprocessor line.
+class PPStates {
+	std::vector<LinePPState> vlls;
+public:
+	LinePPState ForLine(Sci_Position line) const {
+		if ((line > 0) && (vlls.size() > static_cast<size_t>(line))) {
+			return vlls[line];
+		} else {
+			return LinePPState();
+		}
+	}
+	void Add(Sci_Position line, LinePPState lls) {
+		vlls.resize(line+1);
+		vlls[line] = lls;
+	}
+};
+
+// Options used for LexerVerilog
+struct OptionsVerilog {
+	bool foldComment;
+	bool foldPreprocessor;
+	bool foldPreprocessorElse;
+	bool foldCompact;
+	bool foldAtElse;
+	bool foldAtModule;
+	bool trackPreprocessor;
+	bool updatePreprocessor;
+	bool portStyling;
+	bool allUppercaseDocKeyword;
+	OptionsVerilog() {
+		foldComment = false;
+		foldPreprocessor = false;
+		foldPreprocessorElse = false;
+		foldCompact = false;
+		foldAtElse = false;
+		foldAtModule = false;
+		// for backwards compatibility, preprocessor functionality is disabled by default
+		trackPreprocessor = false;
+		updatePreprocessor = false;
+		// for backwards compatibility, treat input/output/inout as regular keywords
+		portStyling = false;
+		// for backwards compatibility, don't treat all uppercase identifiers as documentation keywords
+		allUppercaseDocKeyword = false;
+	}
+};
+
+struct OptionSetVerilog : public OptionSet<OptionsVerilog> {
+	OptionSetVerilog() {
+		DefineProperty("fold.comment", &OptionsVerilog::foldComment,
+			"This option enables folding multi-line comments when using the Verilog lexer.");
+		DefineProperty("fold.preprocessor", &OptionsVerilog::foldPreprocessor,
+			"This option enables folding preprocessor directives when using the Verilog lexer.");
+		DefineProperty("fold.compact", &OptionsVerilog::foldCompact);
+		DefineProperty("fold.at.else", &OptionsVerilog::foldAtElse,
+			"This option enables folding on the else line of an if statement.");
+		DefineProperty("fold.verilog.flags", &OptionsVerilog::foldAtModule,
+			"This option enables folding module definitions. Typically source files "
+			"contain only one module definition so this option is somewhat useless.");
+		DefineProperty("lexer.verilog.track.preprocessor", &OptionsVerilog::trackPreprocessor,
+			"Set to 1 to interpret `if/`else/`endif to grey out code that is not active.");
+		DefineProperty("lexer.verilog.update.preprocessor", &OptionsVerilog::updatePreprocessor,
+			"Set to 1 to update preprocessor definitions when `define, `undef, or `undefineall found.");
+		DefineProperty("lexer.verilog.portstyling", &OptionsVerilog::portStyling,
+			"Set to 1 to style input, output, and inout ports differently from regular keywords.");
+		DefineProperty("lexer.verilog.allupperkeywords", &OptionsVerilog::allUppercaseDocKeyword,
+			"Set to 1 to style identifiers that are all uppercase as documentation keyword.");
+		DefineProperty("lexer.verilog.fold.preprocessor.else", &OptionsVerilog::foldPreprocessorElse,
+			"This option enables folding on `else and `elsif preprocessor directives.");
+	}
+};
+
+const char styleSubable[] = {0};
+
+}
+
+class LexerVerilog : public DefaultLexer {
+	CharacterSet setWord;
+	WordList keywords;
+	WordList keywords2;
+	WordList keywords3;
+	WordList keywords4;
+	WordList keywords5;
+	WordList ppDefinitions;
+	PPStates vlls;
+	std::vector<PPDefinition> ppDefineHistory;
+	struct SymbolValue {
+		std::string value;
+		std::string arguments;
+		SymbolValue(const std::string &value_="", const std::string &arguments_="") : value(value_), arguments(arguments_) {
+		}
+		SymbolValue &operator = (const std::string &value_) {
+			value = value_;
+			arguments.clear();
+			return *this;
+		}
+		bool IsMacro() const {
+			return !arguments.empty();
+		}
+	};
+	typedef std::map<std::string, SymbolValue> SymbolTable;
+	SymbolTable preprocessorDefinitionsStart;
+	OptionsVerilog options;
+	OptionSetVerilog osVerilog;
+	enum { activeFlag = 0x40 };
+	SubStyles subStyles;
+
+	// states at end of line (EOL) during fold operations:
+	//		foldExternFlag: EOL while parsing an extern function/task declaration terminated by ';'
+	//		foldWaitDisableFlag: EOL while parsing wait or disable statement, terminated by "fork" or '('
+	//		typdefFlag: EOL while parsing typedef statement, terminated by ';'
+	enum {foldExternFlag = 0x01, foldWaitDisableFlag = 0x02, typedefFlag = 0x04, protectedFlag = 0x08};
+	// map using line number as key to store fold state information
+	std::map<Sci_Position, int> foldState;
+
+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 lvRelease5;
+	}
+	void SCI_METHOD Release() override {
+		delete this;
+	}
+	const char* SCI_METHOD PropertyNames() override {
+		return osVerilog.PropertyNames();
+	}
+	int SCI_METHOD PropertyType(const char* name) override {
+		return osVerilog.PropertyType(name);
+	}
+	const char* SCI_METHOD DescribeProperty(const char* name) override {
+		return osVerilog.DescribeProperty(name);
+	}
+	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();
+	}
+	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*) override {
+		return 0;
+	}
+	int SCI_METHOD LineEndTypesSupported() override {
+		return SC_LINE_END_TYPE_UNICODE;
+	}
+	int SCI_METHOD AllocateSubStyles(int styleBase, int numberStyles) override {
+		return subStyles.Allocate(styleBase, numberStyles);
+	}
+	int SCI_METHOD SubStylesStart(int styleBase) override {
+		return subStyles.Start(styleBase);
+	}
+	int SCI_METHOD SubStylesLength(int styleBase) override {
+		return subStyles.Length(styleBase);
+	}
+	int SCI_METHOD StyleFromSubStyle(int subStyle) override {
+		int styleBase = subStyles.BaseStyle(MaskActive(subStyle));
+		int active = subStyle & activeFlag;
+		return styleBase | active;
+	}
+	int SCI_METHOD PrimaryStyleFromStyle(int style) override {
+		return MaskActive(style);
+ 	}
+	void SCI_METHOD FreeSubStyles() override {
+		subStyles.Free();
+	}
+	void SCI_METHOD SetIdentifiers(int style, const char *identifiers) override {
+		subStyles.SetIdentifiers(style, identifiers);
+	}
+	int SCI_METHOD DistanceToSecondaryStyles() override {
+		return activeFlag;
+	}
+	const char * SCI_METHOD GetSubStyleBases() override {
+		return styleSubable;
+	}
+	static ILexer5* LexerFactoryVerilog() {
+		return new LexerVerilog();
+	}
+	static int MaskActive(int style) {
+		return style & ~activeFlag;
+	}
+	std::vector<std::string> Tokenize(const std::string &expr) const;
+};
+
+Sci_Position SCI_METHOD LexerVerilog::WordListSet(int n, const char *wl) {
+	WordList *wordListN = 0;
+	switch (n) {
+	case 0:
+		wordListN = &keywords;
+		break;
+	case 1:
+		wordListN = &keywords2;
+		break;
+	case 2:
+		wordListN = &keywords3;
+		break;
+	case 3:
+		wordListN = &keywords4;
+		break;
+	case 4:
+		wordListN = &keywords5;
+		break;
+	case 5:
+		wordListN = &ppDefinitions;
+		break;
+	}
+	Sci_Position firstModification = -1;
+	if (wordListN) {
+		WordList wlNew;
+		wlNew.Set(wl);
+		if (*wordListN != wlNew) {
+			wordListN->Set(wl);
+			firstModification = 0;
+			if (n == 5) {
+				// Rebuild preprocessorDefinitions
+				preprocessorDefinitionsStart.clear();
+				for (int nDefinition = 0; nDefinition < ppDefinitions.Length(); nDefinition++) {
+					const char *cpDefinition = ppDefinitions.WordAt(nDefinition);
+					const char *cpEquals = strchr(cpDefinition, '=');
+					if (cpEquals) {
+						std::string name(cpDefinition, cpEquals - cpDefinition);
+						std::string val(cpEquals+1);
+						size_t bracket = name.find('(');
+						size_t bracketEnd = name.find(')');
+						if ((bracket != std::string::npos) && (bracketEnd != std::string::npos)) {
+							// Macro
+							std::string args = name.substr(bracket + 1, bracketEnd - bracket - 1);
+							name = name.substr(0, bracket);
+							preprocessorDefinitionsStart[name] = SymbolValue(val, args);
+						} else {
+							preprocessorDefinitionsStart[name] = val;
+						}
+					} else {
+						std::string name(cpDefinition);
+						std::string val("1");
+						preprocessorDefinitionsStart[name] = val;
+					}
+				}
+			}
+		}
+	}
+	return firstModification;
+}
+
+static inline bool IsAWordChar(const int ch) {
+	return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '\''|| ch == '$');
+}
+
+static inline bool IsAWordStart(const int ch) {
+	return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '$');
+}
+
+static inline bool AllUpperCase(const char *a) {
+	while (*a) {
+		if (*a >= 'a' && *a <= 'z') return false;
+		a++;
+	}
+	return true;
+}
+
+// Functor used to truncate history
+struct After {
+	Sci_Position line;
+	explicit After(Sci_Position line_) : line(line_) {}
+	bool operator()(PPDefinition &p) const {
+		return p.line > line;
+	}
+};
+
+static std::string GetRestOfLine(LexAccessor &styler, Sci_Position start, bool allowSpace) {
+	std::string restOfLine;
+	Sci_Position i =0;
+	char ch = styler.SafeGetCharAt(start, '\n');
+	Sci_Position endLine = styler.LineEnd(styler.GetLine(start));
+	while (((start+i) < endLine) && (ch != '\r')) {
+		char chNext = styler.SafeGetCharAt(start + i + 1, '\n');
+		if (ch == '/' && (chNext == '/' || chNext == '*'))
+			break;
+		if (allowSpace || (ch != ' '))
+			restOfLine += ch;
+		i++;
+		ch = chNext;
+	}
+	return restOfLine;
+}
+
+static bool IsSpaceOrTab(int ch) {
+	return ch == ' ' || ch == '\t';
+}
+
+void SCI_METHOD LexerVerilog::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess)
+{
+	LexAccessor styler(pAccess);
+
+	const int kwOther=0, kwDot=0x100, kwInput=0x200, kwOutput=0x300, kwInout=0x400, kwProtected=0x800;
+	int lineState = kwOther;
+	bool continuationLine = false;
+
+	Sci_Position curLine = styler.GetLine(startPos);
+	if (curLine > 0) lineState = styler.GetLineState(curLine - 1);
+
+	// Do not leak onto next line
+	if (initStyle == SCE_V_STRINGEOL)
+		initStyle = SCE_V_DEFAULT;
+
+	if ((MaskActive(initStyle) == SCE_V_PREPROCESSOR) ||
+			(MaskActive(initStyle) == SCE_V_COMMENTLINE) ||
+			(MaskActive(initStyle) == SCE_V_COMMENTLINEBANG)) {
+		// Set continuationLine if last character of previous line is '\'
+		if (curLine > 0) {
+			Sci_Position endLinePrevious = styler.LineEnd(curLine - 1);
+			if (endLinePrevious > 0) {
+				continuationLine = styler.SafeGetCharAt(endLinePrevious-1) == '\\';
+			}
+		}
+	}
+
+	StyleContext sc(startPos, length, initStyle, styler);
+	LinePPState preproc = vlls.ForLine(curLine);
+
+	bool definitionsChanged = false;
+
+	// Truncate ppDefineHistory before current line
+
+	if (!options.updatePreprocessor)
+		ppDefineHistory.clear();
+
+	std::vector<PPDefinition>::iterator itInvalid = std::find_if(ppDefineHistory.begin(), ppDefineHistory.end(), After(curLine-1));
+	if (itInvalid != ppDefineHistory.end()) {
+		ppDefineHistory.erase(itInvalid, ppDefineHistory.end());
+		definitionsChanged = true;
+	}
+
+	SymbolTable preprocessorDefinitions = preprocessorDefinitionsStart;
+	for (std::vector<PPDefinition>::iterator itDef = ppDefineHistory.begin(); itDef != ppDefineHistory.end(); ++itDef) {
+		if (itDef->isUndef)
+			preprocessorDefinitions.erase(itDef->key);
+		else
+			preprocessorDefinitions[itDef->key] = SymbolValue(itDef->value, itDef->arguments);
+	}
+
+	int activitySet = preproc.IsInactive() ? activeFlag : 0;
+	Sci_Position lineEndNext = styler.LineEnd(curLine);
+	bool isEscapedId = false;    // true when parsing an escaped Identifier
+	bool isProtected = (lineState&kwProtected) != 0;	// true when parsing a protected region
+
+	for (; sc.More(); sc.Forward()) {
+		if (sc.atLineStart) {
+			if (sc.state == SCE_V_STRING) {
+				// Prevent SCE_V_STRINGEOL from leaking back to previous line
+				sc.SetState(SCE_V_STRING);
+			}
+			if ((MaskActive(sc.state) == SCE_V_PREPROCESSOR) && (!continuationLine)) {
+				sc.SetState(SCE_V_DEFAULT|activitySet);
+			}
+			if (preproc.IsInactive()) {
+				activitySet = activeFlag;
+				sc.SetState(sc.state | activitySet);
+			}
+		}
+
+		if (sc.atLineEnd) {
+			curLine++;
+			lineEndNext = styler.LineEnd(curLine);
+			vlls.Add(curLine, preproc);
+			// Update the line state, so it can be seen by next line
+			styler.SetLineState(curLine, lineState);
+			isEscapedId = false;    // EOL terminates an escaped Identifier
+		}
+
+		// Handle line continuation generically.
+		if (sc.ch == '\\') {
+			if (static_cast<Sci_Position>((sc.currentPos+1)) >= lineEndNext) {
+				curLine++;
+				lineEndNext = styler.LineEnd(curLine);
+				vlls.Add(curLine, preproc);
+				// Update the line state, so it can be seen by next line
+				styler.SetLineState(curLine, lineState);
+				sc.Forward();
+				if (sc.ch == '\r' && sc.chNext == '\n') {
+					// Even in UTF-8, \r and \n are separate
+					sc.Forward();
+				}
+				continuationLine = true;
+				sc.Forward();
+				continue;
+			}
+		}
+
+		// for comment keyword
+		if (MaskActive(sc.state) == SCE_V_COMMENT_WORD && !IsAWordChar(sc.ch)) {
+			char s[100];
+			int state = lineState & 0xff;
+			sc.GetCurrent(s, sizeof(s));
+			if (keywords5.InList(s)) {
+				sc.ChangeState(SCE_V_COMMENT_WORD|activitySet);
+			} else {
+				sc.ChangeState(state|activitySet);
+			}
+			sc.SetState(state|activitySet);
+		}
+
+		const bool atLineEndBeforeSwitch = sc.atLineEnd;
+
+		// Determine if the current state should terminate.
+		switch (MaskActive(sc.state)) {
+			case SCE_V_OPERATOR:
+				sc.SetState(SCE_V_DEFAULT|activitySet);
+				break;
+			case SCE_V_NUMBER:
+				if (!(IsAWordChar(sc.ch) || (sc.ch == '?'))) {
+					sc.SetState(SCE_V_DEFAULT|activitySet);
+				}
+				break;
+			case SCE_V_IDENTIFIER:
+				if (!isEscapedId &&(!IsAWordChar(sc.ch) || (sc.ch == '.'))) {
+					char s[100];
+					lineState &= 0xff00;
+					sc.GetCurrent(s, sizeof(s));
+					if (options.portStyling && (strcmp(s, "input") == 0)) {
+						lineState = kwInput;
+						sc.ChangeState(SCE_V_INPUT|activitySet);
+					} else if (options.portStyling && (strcmp(s, "output") == 0)) {
+						lineState = kwOutput;
+						sc.ChangeState(SCE_V_OUTPUT|activitySet);
+					} else if (options.portStyling && (strcmp(s, "inout") == 0)) {
+						lineState = kwInout;
+						sc.ChangeState(SCE_V_INOUT|activitySet);
+					} else if (lineState == kwInput) {
+						sc.ChangeState(SCE_V_INPUT|activitySet);
+					} else if (lineState == kwOutput) {
+						sc.ChangeState(SCE_V_OUTPUT|activitySet);
+					} else if (lineState == kwInout) {
+						sc.ChangeState(SCE_V_INOUT|activitySet);
+					} else if (lineState == kwDot) {
+						lineState = kwOther;
+						if (options.portStyling)
+							sc.ChangeState(SCE_V_PORT_CONNECT|activitySet);
+					} else if (keywords.InList(s)) {
+						sc.ChangeState(SCE_V_WORD|activitySet);
+					} else if (keywords2.InList(s)) {
+						sc.ChangeState(SCE_V_WORD2|activitySet);
+					} else if (keywords3.InList(s)) {
+						sc.ChangeState(SCE_V_WORD3|activitySet);
+					} else if (keywords4.InList(s)) {
+						sc.ChangeState(SCE_V_USER|activitySet);
+					} else if (options.allUppercaseDocKeyword && AllUpperCase(s)) {
+						sc.ChangeState(SCE_V_USER|activitySet);
+					}
+					sc.SetState(SCE_V_DEFAULT|activitySet);
+				}
+				break;
+			case SCE_V_PREPROCESSOR:
+				if (!IsAWordChar(sc.ch) || sc.atLineEnd) {
+					sc.SetState(SCE_V_DEFAULT|activitySet);
+				}
+				break;
+			case SCE_V_COMMENT:
+				if (sc.Match('*', '/')) {
+					sc.Forward();
+					sc.ForwardSetState(SCE_V_DEFAULT|activitySet);
+				} else if (IsAWordStart(sc.ch)) {
+					lineState = sc.state | (lineState & 0xff00);
+					sc.SetState(SCE_V_COMMENT_WORD|activitySet);
+				}
+				break;
+			case SCE_V_COMMENTLINE:
+			case SCE_V_COMMENTLINEBANG:
+				if (sc.atLineStart) {
+					sc.SetState(SCE_V_DEFAULT|activitySet);
+				} else if (IsAWordStart(sc.ch)) {
+					lineState = sc.state | (lineState & 0xff00);
+					sc.SetState(SCE_V_COMMENT_WORD|activitySet);
+				}
+				break;
+			case SCE_V_STRING:
+				if (sc.ch == '\\') {
+					if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
+						sc.Forward();
+					}
+				} else if (sc.ch == '\"') {
+					sc.ForwardSetState(SCE_V_DEFAULT|activitySet);
+				} else if (sc.atLineEnd) {
+					sc.ChangeState(SCE_V_STRINGEOL|activitySet);
+					sc.ForwardSetState(SCE_V_DEFAULT|activitySet);
+				}
+				break;
+		}
+
+		if (sc.atLineEnd && !atLineEndBeforeSwitch) {
+			// State exit processing consumed characters up to end of line.
+			curLine++;
+			lineEndNext = styler.LineEnd(curLine);
+			vlls.Add(curLine, preproc);
+			// Update the line state, so it can be seen by next line
+			styler.SetLineState(curLine, lineState);
+			isEscapedId = false;    // EOL terminates an escaped Identifier
+		}
+
+		// Determine if a new state should be entered.
+		if (MaskActive(sc.state) == SCE_V_DEFAULT) {
+			if (sc.ch == '`') {
+				sc.SetState(SCE_V_PREPROCESSOR|activitySet);
+				// Skip whitespace between ` and preprocessor word
+				do {
+					sc.Forward();
+				} while ((sc.ch == ' ' || sc.ch == '\t') && sc.More());
+				if (sc.atLineEnd) {
+					sc.SetState(SCE_V_DEFAULT|activitySet);
+					styler.SetLineState(curLine, lineState);
+				} else {
+					if (sc.Match("protected")) {
+						isProtected = true;
+						lineState |= kwProtected;
+						styler.SetLineState(curLine, lineState);
+					} else if (sc.Match("endprotected")) {
+						isProtected = false;
+						lineState &= ~kwProtected;
+						styler.SetLineState(curLine, lineState);
+					} else if (!isProtected && options.trackPreprocessor) {
+						if (sc.Match("ifdef") || sc.Match("ifndef")) {
+							bool isIfDef = sc.Match("ifdef");
+							int i = isIfDef ? 5 : 6;
+							std::string restOfLine = GetRestOfLine(styler, sc.currentPos + i + 1, false);
+							bool foundDef = preprocessorDefinitions.find(restOfLine) != preprocessorDefinitions.end();
+							preproc.StartSection(isIfDef == foundDef);
+						} else if (sc.Match("else")) {
+							if (!preproc.CurrentIfTaken()) {
+								preproc.InvertCurrentLevel();
+								activitySet = preproc.IsInactive() ? activeFlag : 0;
+								if (!activitySet) {
+									sc.ChangeState(SCE_V_PREPROCESSOR|activitySet);
+								}
+							} else if (!preproc.IsInactive()) {
+								preproc.InvertCurrentLevel();
+								activitySet = preproc.IsInactive() ? activeFlag : 0;
+								if (!activitySet) {
+									sc.ChangeState(SCE_V_PREPROCESSOR|activitySet);
+								}
+							}
+						} else if (sc.Match("elsif")) {
+							// Ensure only one chosen out of `if .. `elsif .. `elsif .. `else .. `endif
+							if (!preproc.CurrentIfTaken()) {
+								// Similar to `ifdef
+								std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 6, true);
+								bool ifGood = preprocessorDefinitions.find(restOfLine) != preprocessorDefinitions.end();
+								if (ifGood) {
+									preproc.InvertCurrentLevel();
+									activitySet = preproc.IsInactive() ? activeFlag : 0;
+									if (!activitySet)
+										sc.ChangeState(SCE_V_PREPROCESSOR|activitySet);
+								}
+							} else if (!preproc.IsInactive()) {
+								preproc.InvertCurrentLevel();
+								activitySet = preproc.IsInactive() ? activeFlag : 0;
+								if (!activitySet)
+									sc.ChangeState(SCE_V_PREPROCESSOR|activitySet);
+							}
+						} else if (sc.Match("endif")) {
+							preproc.EndSection();
+							activitySet = preproc.IsInactive() ? activeFlag : 0;
+							sc.ChangeState(SCE_V_PREPROCESSOR|activitySet);
+						} else if (sc.Match("define")) {
+							if (options.updatePreprocessor && !preproc.IsInactive()) {
+								std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 6, true);
+								size_t startName = 0;
+								while ((startName < restOfLine.length()) && IsSpaceOrTab(restOfLine[startName]))
+									startName++;
+								size_t endName = startName;
+								while ((endName < restOfLine.length()) && setWord.Contains(static_cast<unsigned char>(restOfLine[endName])))
+									endName++;
+								std::string key = restOfLine.substr(startName, endName-startName);
+								if ((endName < restOfLine.length()) && (restOfLine.at(endName) == '(')) {
+									// Macro
+									size_t endArgs = endName;
+									while ((endArgs < restOfLine.length()) && (restOfLine[endArgs] != ')'))
+										endArgs++;
+									std::string args = restOfLine.substr(endName + 1, endArgs - endName - 1);
+									size_t startValue = endArgs+1;
+									while ((startValue < restOfLine.length()) && IsSpaceOrTab(restOfLine[startValue]))
+										startValue++;
+									std::string value;
+									if (startValue < restOfLine.length())
+										value = restOfLine.substr(startValue);
+									preprocessorDefinitions[key] = SymbolValue(value, args);
+									ppDefineHistory.push_back(PPDefinition(curLine, key, value, false, args));
+									definitionsChanged = true;
+								} else {
+									// Value
+									size_t startValue = endName;
+									while ((startValue < restOfLine.length()) && IsSpaceOrTab(restOfLine[startValue]))
+										startValue++;
+									std::string value = restOfLine.substr(startValue);
+									preprocessorDefinitions[key] = value;
+									ppDefineHistory.push_back(PPDefinition(curLine, key, value));
+									definitionsChanged = true;
+								}
+							}
+						} else if (sc.Match("undefineall")) {
+							if (options.updatePreprocessor && !preproc.IsInactive()) {
+								// remove all preprocessor definitions
+								std::map<std::string, SymbolValue>::iterator itDef;
+								for(itDef = preprocessorDefinitions.begin(); itDef != preprocessorDefinitions.end(); ++itDef) {
+									ppDefineHistory.push_back(PPDefinition(curLine, itDef->first, "", true));
+								}
+								preprocessorDefinitions.clear();
+								definitionsChanged = true;
+							}
+						} else if (sc.Match("undef")) {
+							if (options.updatePreprocessor && !preproc.IsInactive()) {
+								std::string restOfLine = GetRestOfLine(styler, sc.currentPos + 5, true);
+								std::vector<std::string> tokens = Tokenize(restOfLine);
+								std::string key;
+								if (tokens.size() >= 1) {
+									key = tokens[0];
+									preprocessorDefinitions.erase(key);
+									ppDefineHistory.push_back(PPDefinition(curLine, key, "", true));
+									definitionsChanged = true;
+								}
+							}
+						}
+					}
+				}
+			} else if (!isProtected) {
+				if (IsADigit(sc.ch) || (sc.ch == '\'') || (sc.ch == '.' && IsADigit(sc.chNext))) {
+					sc.SetState(SCE_V_NUMBER|activitySet);
+				} else if (IsAWordStart(sc.ch)) {
+					sc.SetState(SCE_V_IDENTIFIER|activitySet);
+				} else if (sc.Match('/', '*')) {
+					sc.SetState(SCE_V_COMMENT|activitySet);
+					sc.Forward();	// Eat the * so it isn't used for the end of the comment
+				} else if (sc.Match('/', '/')) {
+					if (sc.Match("//!"))	// Nice to have a different comment style
+						sc.SetState(SCE_V_COMMENTLINEBANG|activitySet);
+					else
+						sc.SetState(SCE_V_COMMENTLINE|activitySet);
+				} else if (sc.ch == '\"') {
+					sc.SetState(SCE_V_STRING|activitySet);
+				} else if (sc.ch == '\\') {
+					// escaped identifier, everything is ok up to whitespace
+					isEscapedId = true;
+					sc.SetState(SCE_V_IDENTIFIER|activitySet);
+				} else if (isoperator(static_cast<char>(sc.ch)) || sc.ch == '@' || sc.ch == '#') {
+					sc.SetState(SCE_V_OPERATOR|activitySet);
+					if (sc.ch == '.') lineState = kwDot;
+					if (sc.ch == ';') lineState = kwOther;
+				}
+			}
+		}
+		if (isEscapedId && isspacechar(sc.ch)) {
+			isEscapedId = false;
+		}
+	}
+	if (definitionsChanged) {
+		styler.ChangeLexerState(startPos, startPos + length);
+	}
+	sc.Complete();
+}
+
+static bool IsStreamCommentStyle(int style) {
+	return style == SCE_V_COMMENT;
+}
+
+static bool IsCommentLine(Sci_Position line, LexAccessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
+	Sci_Position eolPos = styler.LineStart(line + 1) - 1;
+	for (Sci_Position i = pos; i < eolPos; i++) {
+		char ch = styler[i];
+		char chNext = styler.SafeGetCharAt(i + 1);
+		int style = styler.StyleAt(i);
+		if (ch == '/' && chNext == '/' &&
+		   (style == SCE_V_COMMENTLINE || style == SCE_V_COMMENTLINEBANG)) {
+			return true;
+		} else if (!IsASpaceOrTab(ch)) {
+			return false;
+		}
+	}
+	return false;
+}
+
+// Store both the current line's fold level and the next lines in the
+// level store to make it easy to pick up with each increment
+// and to make it possible to fiddle the current level for "} else {".
+void SCI_METHOD LexerVerilog::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess)
+{
+	LexAccessor styler(pAccess);
+	bool foldAtBrace  = 1;
+	bool foldAtParenthese  = 1;
+
+	Sci_Position lineCurrent = styler.GetLine(startPos);
+	// Move back one line to be compatible with LexerModule::Fold behavior, fixes problem with foldComment behavior
+	if (lineCurrent > 0) {
+		lineCurrent--;
+		Sci_Position newStartPos = styler.LineStart(lineCurrent);
+		length += startPos - newStartPos;
+		startPos = newStartPos;
+		initStyle = 0;
+		if (startPos > 0) {
+			initStyle = styler.StyleAt(startPos - 1);
+		}
+	}
+	Sci_PositionU endPos = startPos + length;
+	int visibleChars = 0;
+	int levelCurrent = SC_FOLDLEVELBASE;
+	if (lineCurrent > 0)
+		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
+	int levelMinCurrent = levelCurrent;
+	int levelNext = levelCurrent;
+	char chNext = styler[startPos];
+	int styleNext = MaskActive(styler.StyleAt(startPos));
+	int style = MaskActive(initStyle);
+
+	// restore fold state (if it exists) for prior line
+	int stateCurrent = 0;
+	std::map<Sci_Position,int>::iterator foldStateIterator = foldState.find(lineCurrent-1);
+	if (foldStateIterator != foldState.end()) {
+		stateCurrent = foldStateIterator->second;
+	}
+
+	// remove all foldState entries after lineCurrent-1
+	foldStateIterator = foldState.upper_bound(lineCurrent-1);
+	if (foldStateIterator != foldState.end()) {
+		foldState.erase(foldStateIterator, foldState.end());
+	}
+
+	for (Sci_PositionU i = startPos; i < endPos; i++) {
+		char ch = chNext;
+		chNext = styler.SafeGetCharAt(i + 1);
+		int stylePrev = style;
+		style = styleNext;
+		styleNext = MaskActive(styler.StyleAt(i + 1));
+		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+		if (!(stateCurrent & protectedFlag)) {
+			if (options.foldComment && IsStreamCommentStyle(style)) {
+				if (!IsStreamCommentStyle(stylePrev)) {
+					levelNext++;
+				} else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
+					// Comments don't end at end of line and the next character may be unstyled.
+					levelNext--;
+				}
+			}
+			if (options.foldComment && atEOL && IsCommentLine(lineCurrent, styler))
+			{
+				if (!IsCommentLine(lineCurrent - 1, styler)
+					&& IsCommentLine(lineCurrent + 1, styler))
+					levelNext++;
+				else if (IsCommentLine(lineCurrent - 1, styler)
+						 && !IsCommentLine(lineCurrent+1, styler))
+					levelNext--;
+			}
+			if (options.foldComment && (style == SCE_V_COMMENTLINE)) {
+				if ((ch == '/') && (chNext == '/')) {
+					char chNext2 = styler.SafeGetCharAt(i + 2);
+					if (chNext2 == '{') {
+						levelNext++;
+					} else if (chNext2 == '}') {
+						levelNext--;
+					}
+				}
+			}
+		}
+		if (ch == '`') {
+			Sci_PositionU j = i + 1;
+			while ((j < endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
+				j++;
+			}
+			if (styler.Match(j, "protected")) {
+				stateCurrent |= protectedFlag;
+				levelNext++;
+			} else if (styler.Match(j, "endprotected")) {
+				stateCurrent &= ~protectedFlag;
+				levelNext--;
+			} else if (!(stateCurrent & protectedFlag) && options.foldPreprocessor && (style == SCE_V_PREPROCESSOR)) {
+				if (styler.Match(j, "if")) {
+					if (options.foldPreprocessorElse) {
+						// Measure the minimum before a begin to allow
+						// folding on "end else begin"
+						if (levelMinCurrent > levelNext) {
+							levelMinCurrent = levelNext;
+						}
+					}
+					levelNext++;
+				} else if (options.foldPreprocessorElse && styler.Match(j, "else")) {
+					levelNext--;
+					if (levelMinCurrent > levelNext) {
+						levelMinCurrent = levelNext;
+					}
+					levelNext++;
+				} else if (options.foldPreprocessorElse && styler.Match(j, "elsif")) {
+					levelNext--;
+					// Measure the minimum before a begin to allow
+					// folding on "end else begin"
+					if (levelMinCurrent > levelNext) {
+						levelMinCurrent = levelNext;
+					}
+					levelNext++;
+				} else if (styler.Match(j, "endif")) {
+					levelNext--;
+				}
+			}
+		}
+		if (style == SCE_V_OPERATOR) {
+			if (foldAtParenthese) {
+				if (ch == '(') {
+					levelNext++;
+				} else if (ch == ')') {
+					levelNext--;
+				}
+			}
+			// semicolons terminate external declarations
+			if (ch == ';') {
+				// extern and pure virtual declarations terminated by semicolon
+				if (stateCurrent & foldExternFlag) {
+					levelNext--;
+					stateCurrent &= ~foldExternFlag;
+				}
+				// wait and disable statements terminated by semicolon
+				if (stateCurrent & foldWaitDisableFlag) {
+					stateCurrent &= ~foldWaitDisableFlag;
+				}
+				// typedef statements terminated by semicolon
+				if (stateCurrent & typedefFlag) {
+					stateCurrent &= ~typedefFlag;
+				}
+			}
+			// wait and disable statements containing '(' will not contain "fork" keyword, special processing is not needed
+			if (ch == '(') {
+				if (stateCurrent & foldWaitDisableFlag) {
+					stateCurrent &= ~foldWaitDisableFlag;
+				}
+			}
+		}
+		if (style == SCE_V_OPERATOR) {
+			if (foldAtBrace) {
+				if (ch == '{') {
+					levelNext++;
+				} else if (ch == '}') {
+					levelNext--;
+				}
+			}
+		}
+		if (style == SCE_V_WORD && stylePrev != SCE_V_WORD) {
+			Sci_PositionU j = i;
+			if (styler.Match(j, "case") ||
+				styler.Match(j, "casex") ||
+				styler.Match(j, "casez") ||
+				styler.Match(j, "covergroup") ||
+				styler.Match(j, "function") ||
+				styler.Match(j, "generate") ||
+				styler.Match(j, "interface") ||
+				styler.Match(j, "package") ||
+				styler.Match(j, "primitive") ||
+				styler.Match(j, "program") ||
+				styler.Match(j, "sequence") ||
+				styler.Match(j, "specify") ||
+				styler.Match(j, "table") ||
+				styler.Match(j, "task") ||
+				(styler.Match(j, "module") && options.foldAtModule)) {
+				levelNext++;
+			} else if (styler.Match(j, "begin")) {
+				// Measure the minimum before a begin to allow
+				// folding on "end else begin"
+				if (levelMinCurrent > levelNext) {
+					levelMinCurrent = levelNext;
+				}
+				levelNext++;
+			} else if (styler.Match(j, "class")) {
+				// class does not introduce a block when used in a typedef statement
+				if (!(stateCurrent & typedefFlag))
+					levelNext++;
+			} else if (styler.Match(j, "fork")) {
+				// fork does not introduce a block when used in a wait or disable statement
+				if (stateCurrent & foldWaitDisableFlag) {
+					stateCurrent &= ~foldWaitDisableFlag;
+				} else
+					levelNext++;
+			} else if (styler.Match(j, "endcase") ||
+				styler.Match(j, "endclass") ||
+				styler.Match(j, "endfunction") ||
+				styler.Match(j, "endgenerate") ||
+				styler.Match(j, "endgroup") ||
+				styler.Match(j, "endinterface") ||
+				styler.Match(j, "endpackage") ||
+				styler.Match(j, "endprimitive") ||
+				styler.Match(j, "endprogram") ||
+				styler.Match(j, "endsequence") ||
+				styler.Match(j, "endspecify") ||
+				styler.Match(j, "endtable") ||
+				styler.Match(j, "endtask") ||
+				styler.Match(j, "join") ||
+				styler.Match(j, "join_any") ||
+				styler.Match(j, "join_none") ||
+				(styler.Match(j, "endmodule") && options.foldAtModule) ||
+				(styler.Match(j, "end") && !IsAWordChar(styler.SafeGetCharAt(j + 3)))) {
+				levelNext--;
+			} else if (styler.Match(j, "extern") ||
+				styler.Match(j, "pure")) {
+				// extern and pure virtual functions/tasks are terminated by ';' not endfunction/endtask
+				stateCurrent |= foldExternFlag;
+			} else if (styler.Match(j, "disable") ||
+				styler.Match(j, "wait")) {
+				// fork does not introduce a block when used in a wait or disable statement
+				stateCurrent |= foldWaitDisableFlag;
+			} else if (styler.Match(j, "typedef")) {
+				stateCurrent |= typedefFlag;
+			}
+		}
+		if (atEOL) {
+			int levelUse = levelCurrent;
+			if (options.foldAtElse||options.foldPreprocessorElse) {
+				levelUse = levelMinCurrent;
+			}
+			int lev = levelUse | levelNext << 16;
+			if (visibleChars == 0 && options.foldCompact)
+				lev |= SC_FOLDLEVELWHITEFLAG;
+			if (levelUse < levelNext)
+				lev |= SC_FOLDLEVELHEADERFLAG;
+			if (stateCurrent) {
+				foldState[lineCurrent] = stateCurrent;
+			}
+			if (lev != styler.LevelAt(lineCurrent)) {
+				styler.SetLevel(lineCurrent, lev);
+			}
+			lineCurrent++;
+			levelCurrent = levelNext;
+			levelMinCurrent = levelCurrent;
+			visibleChars = 0;
+		}
+		if (!isspacechar(ch))
+			visibleChars++;
+	}
+}
+
+std::vector<std::string> LexerVerilog::Tokenize(const std::string &expr) const {
+	// Break into tokens
+	std::vector<std::string> tokens;
+	const char *cp = expr.c_str();
+	while (*cp) {
+		std::string word;
+		if (setWord.Contains(static_cast<unsigned char>(*cp))) {
+			// Identifiers and numbers
+			while (setWord.Contains(static_cast<unsigned char>(*cp))) {
+				word += *cp;
+				cp++;
+			}
+		} else if (IsSpaceOrTab(*cp)) {
+			while (IsSpaceOrTab(*cp)) {
+				cp++;
+			}
+			continue;
+		} else {
+			// Should handle strings, characters, and comments here
+			word += *cp;
+			cp++;
+		}
+		tokens.push_back(word);
+	}
+	return tokens;
+}
+
+static const char * const verilogWordLists[] = {
+            "Primary keywords and identifiers",
+            "Secondary keywords and identifiers",
+            "System Tasks",
+            "User defined tasks and identifiers",
+            "Documentation comment keywords",
+            "Preprocessor definitions",
+            0,
+        };
+
+LexerModule lmVerilog(SCLEX_VERILOG, LexerVerilog::LexerFactoryVerilog, "verilog", verilogWordLists);
diff --git a/Pythonwin/Scintilla/lexers/LexVisualProlog.cxx b/Pythonwin/Scintilla/lexers/LexVisualProlog.cxx
new file mode 100644
index 000000000..ba5b222c1
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexVisualProlog.cxx
@@ -0,0 +1,513 @@
+// Scintilla source code edit control
+/** @file LexVisualProlog.cxx
+** Lexer for Visual Prolog.
+**/
+// Author Thomas Linder Puls, Prolog Development Denter A/S, http://www.visual-prolog.com
+// Based on Lexer for C++, C, Java, and JavaScript.
+// Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+// The line state contains:
+// In SCE_VISUALPROLOG_STRING_VERBATIM_EOL (i.e. multiline string literal): The closingQuote.
+// else (for SCE_VISUALPROLOG_COMMENT_BLOCK): The comment nesting level
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+
+#ifdef _MSC_VER
+#pragma warning(disable: 4786)
+#endif
+
+#include <string>
+#include <vector>
+#include <map>
+#include <algorithm>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+#include "CharacterCategory.h"
+#include "LexerModule.h"
+#include "OptionSet.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+// Options used for LexerVisualProlog
+struct OptionsVisualProlog {
+    OptionsVisualProlog() {
+    }
+};
+
+static const char *const visualPrologWordLists[] = {
+    "Major keywords (class, predicates, ...)",
+    "Minor keywords (if, then, try, ...)",
+    "Directive keywords without the '#' (include, requires, ...)",
+    "Documentation keywords without the '@' (short, detail, ...)",
+    0,
+};
+
+struct OptionSetVisualProlog : public OptionSet<OptionsVisualProlog> {
+    OptionSetVisualProlog() {
+        DefineWordListSets(visualPrologWordLists);
+    }
+};
+
+class LexerVisualProlog : public DefaultLexer {
+    WordList majorKeywords;
+    WordList minorKeywords;
+    WordList directiveKeywords;
+    WordList docKeywords;
+    OptionsVisualProlog options;
+    OptionSetVisualProlog osVisualProlog;
+public:
+    LexerVisualProlog() : DefaultLexer("visualprolog", SCLEX_VISUALPROLOG) {
+    }
+    virtual ~LexerVisualProlog() {
+    }
+    void SCI_METHOD Release() override {
+        delete this;
+    }
+    int SCI_METHOD Version() const override {
+        return lvRelease5;
+    }
+    const char * SCI_METHOD PropertyNames() override {
+        return osVisualProlog.PropertyNames();
+    }
+    int SCI_METHOD PropertyType(const char *name) override {
+        return osVisualProlog.PropertyType(name);
+    }
+    const char * SCI_METHOD DescribeProperty(const char *name) override {
+        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();
+    }
+    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 *) override {
+        return 0;
+    }
+
+    static ILexer5 *LexerFactoryVisualProlog() {
+        return new LexerVisualProlog();
+    }
+};
+
+Sci_Position SCI_METHOD LexerVisualProlog::PropertySet(const char *key, const char *val) {
+    if (osVisualProlog.PropertySet(&options, key, val)) {
+        return 0;
+    }
+    return -1;
+}
+
+Sci_Position SCI_METHOD LexerVisualProlog::WordListSet(int n, const char *wl) {
+    WordList *wordListN = 0;
+    switch (n) {
+    case 0:
+        wordListN = &majorKeywords;
+        break;
+    case 1:
+        wordListN = &minorKeywords;
+        break;
+    case 2:
+        wordListN = &directiveKeywords;
+        break;
+    case 3:
+        wordListN = &docKeywords;
+        break;
+    }
+    Sci_Position firstModification = -1;
+    if (wordListN) {
+        WordList wlNew;
+        wlNew.Set(wl);
+        if (*wordListN != wlNew) {
+            wordListN->Set(wl);
+            firstModification = 0;
+        }
+    }
+    return firstModification;
+}
+
+// Functor used to truncate history
+struct After {
+    Sci_Position line;
+    After(Sci_Position line_) : line(line_) {}
+};
+
+static bool isLowerLetter(int ch){
+    return ccLl == CategoriseCharacter(ch);
+}
+
+static bool isUpperLetter(int ch){
+    return ccLu == CategoriseCharacter(ch);
+}
+
+static bool isAlphaNum(int ch){
+    CharacterCategory cc = CategoriseCharacter(ch);
+    return (ccLu == cc || ccLl == cc || ccLt == cc || ccLm == cc || ccLo == cc || ccNd == cc || ccNl == cc || ccNo == cc);
+}
+
+static bool isStringVerbatimOpenClose(int ch){
+    CharacterCategory cc = CategoriseCharacter(ch);
+    return (ccPc <= cc && cc <= ccSo);
+}
+
+static bool isIdChar(int ch){
+    return ('_') == ch || isAlphaNum(ch);
+}
+
+static bool isOpenStringVerbatim(int next, int &closingQuote){
+    switch (next) {
+    case L'<':
+        closingQuote = L'>';
+        return true;
+    case L'>':
+        closingQuote = L'<';
+        return true;
+    case L'(':
+        closingQuote = L')';
+        return true;
+    case L')':
+        closingQuote = L'(';
+        return true;
+    case L'[':
+        closingQuote = L']';
+        return true;
+    case L']':
+        closingQuote = L'[';
+        return true;
+    case L'{':
+        closingQuote = L'}';
+        return true;
+    case L'}':
+        closingQuote = L'{';
+        return true;
+    case L'_':
+    case L'.':
+    case L',':
+    case L';':
+        return false;
+    default:
+        if (isStringVerbatimOpenClose(next)) {
+            closingQuote = next;
+            return true;
+        } else {
+			return false;
+        }
+    }
+}
+
+// Look ahead to see which colour "end" should have (takes colour after the following keyword)
+static void endLookAhead(char s[], LexAccessor &styler, Sci_Position start) {
+    char ch = styler.SafeGetCharAt(start, '\n');
+    while (' ' == ch) {
+        start++;
+        ch = styler.SafeGetCharAt(start, '\n');
+    }
+    Sci_Position i = 0;
+    while (i < 100 && isLowerLetter(ch)){
+        s[i] = ch;
+        i++;
+        ch = styler.SafeGetCharAt(start + i, '\n');
+    }
+    s[i] = '\0';
+}
+
+static void forwardEscapeLiteral(StyleContext &sc, int EscapeState) {
+    sc.Forward();
+    if (sc.Match('"') || sc.Match('\'') || sc.Match('\\') || sc.Match('n') || sc.Match('l') || sc.Match('r') || sc.Match('t')) {
+        sc.ChangeState(EscapeState);
+    } else if (sc.Match('u')) {
+        if (IsADigit(sc.chNext, 16)) {
+            sc.Forward();
+            if (IsADigit(sc.chNext, 16)) {
+                sc.Forward();
+                if (IsADigit(sc.chNext, 16)) {
+                    sc.Forward();
+                    if (IsADigit(sc.chNext, 16)) {
+                        sc.Forward();
+                        sc.ChangeState(EscapeState);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void SCI_METHOD LexerVisualProlog::Lex(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+    LexAccessor styler(pAccess);
+    CharacterSet setDoxygen(CharacterSet::setAlpha, "");
+    CharacterSet setNumber(CharacterSet::setNone, "0123456789abcdefABCDEFxoXO");
+
+    StyleContext sc(startPos, length, initStyle, styler, 0x7f);
+
+    int styleBeforeDocKeyword = SCE_VISUALPROLOG_DEFAULT;
+    Sci_Position currentLine = styler.GetLine(startPos);
+
+    int closingQuote = '"';
+    int nestLevel = 0;
+    if (currentLine >= 1)
+    {
+        nestLevel = styler.GetLineState(currentLine - 1);
+        closingQuote = nestLevel;
+    }
+
+    // Truncate ppDefineHistory before current line
+
+    for (; sc.More(); sc.Forward()) {
+
+        // Determine if the current state should terminate.
+        switch (sc.state) {
+        case SCE_VISUALPROLOG_OPERATOR:
+            sc.SetState(SCE_VISUALPROLOG_DEFAULT);
+            break;
+        case SCE_VISUALPROLOG_NUMBER:
+            // We accept almost anything because of hex. and number suffixes
+            if (!(setNumber.Contains(sc.ch)) || (sc.Match('.') && IsADigit(sc.chNext))) {
+                sc.SetState(SCE_VISUALPROLOG_DEFAULT);
+            }
+            break;
+        case SCE_VISUALPROLOG_IDENTIFIER:
+            if (!isIdChar(sc.ch)) {
+                char s[1000];
+                sc.GetCurrent(s, sizeof(s));
+                if (0 == strcmp(s, "end")) {
+                    endLookAhead(s, styler, sc.currentPos);
+                }
+                if (majorKeywords.InList(s)) {
+                    sc.ChangeState(SCE_VISUALPROLOG_KEY_MAJOR);
+                } else if (minorKeywords.InList(s)) {
+                    sc.ChangeState(SCE_VISUALPROLOG_KEY_MINOR);
+                }
+                sc.SetState(SCE_VISUALPROLOG_DEFAULT);
+            }
+            break;
+        case SCE_VISUALPROLOG_VARIABLE:
+        case SCE_VISUALPROLOG_ANONYMOUS:
+            if (!isIdChar(sc.ch)) {
+                sc.SetState(SCE_VISUALPROLOG_DEFAULT);
+            }
+            break;
+        case SCE_VISUALPROLOG_KEY_DIRECTIVE:
+            if (!isLowerLetter(sc.ch)) {
+                char s[1000];
+                sc.GetCurrent(s, sizeof(s));
+                if (!directiveKeywords.InList(s+1)) {
+                    sc.ChangeState(SCE_VISUALPROLOG_IDENTIFIER);
+                }
+                sc.SetState(SCE_VISUALPROLOG_DEFAULT);
+            }
+            break;
+        case SCE_VISUALPROLOG_COMMENT_BLOCK:
+            if (sc.Match('*', '/')) {
+                sc.Forward();
+                nestLevel--;
+                int nextState = (nestLevel == 0) ? SCE_VISUALPROLOG_DEFAULT : SCE_VISUALPROLOG_COMMENT_BLOCK;
+                sc.ForwardSetState(nextState);
+            } else if (sc.Match('/', '*')) {
+                sc.Forward();
+                nestLevel++;
+            } else if (sc.Match('@')) {
+                styleBeforeDocKeyword = sc.state;
+                sc.SetState(SCE_VISUALPROLOG_COMMENT_KEY_ERROR);
+            }
+            break;
+        case SCE_VISUALPROLOG_COMMENT_LINE:
+            if (sc.atLineEnd) {
+                int nextState = (nestLevel == 0) ? SCE_VISUALPROLOG_DEFAULT : SCE_VISUALPROLOG_COMMENT_BLOCK;
+                sc.SetState(nextState);
+            } else if (sc.Match('@')) {
+                styleBeforeDocKeyword = sc.state;
+                sc.SetState(SCE_VISUALPROLOG_COMMENT_KEY_ERROR);
+            }
+            break;
+        case SCE_VISUALPROLOG_COMMENT_KEY_ERROR:
+            if (!setDoxygen.Contains(sc.ch) || sc.atLineEnd) {
+                char s[1000];
+                sc.GetCurrent(s, sizeof(s));
+                if (docKeywords.InList(s+1)) {
+                    sc.ChangeState(SCE_VISUALPROLOG_COMMENT_KEY);
+                }
+                if (SCE_VISUALPROLOG_COMMENT_LINE == styleBeforeDocKeyword && sc.atLineEnd) {
+                    // end line comment
+                    int nextState = (nestLevel == 0) ? SCE_VISUALPROLOG_DEFAULT : SCE_VISUALPROLOG_COMMENT_BLOCK;
+                    sc.SetState(nextState);
+                } else {
+                    sc.SetState(styleBeforeDocKeyword);
+                    if (SCE_VISUALPROLOG_COMMENT_BLOCK == styleBeforeDocKeyword && sc.Match('*', '/')) {
+                        // we have consumed the '*' if it comes immediately after the docKeyword
+                        sc.Forward();
+                        sc.Forward();
+                        nestLevel--;
+                        if (0 == nestLevel) {
+                            sc.SetState(SCE_VISUALPROLOG_DEFAULT);
+                        }
+                    }
+                }
+            }
+            break;
+        case SCE_VISUALPROLOG_STRING_ESCAPE:
+        case SCE_VISUALPROLOG_STRING_ESCAPE_ERROR:
+            // return to SCE_VISUALPROLOG_STRING and treat as such (fall-through)
+            sc.SetState(SCE_VISUALPROLOG_STRING);
+            // Falls through.
+        case SCE_VISUALPROLOG_STRING:
+            if (sc.atLineEnd) {
+                sc.SetState(SCE_VISUALPROLOG_STRING_EOL_OPEN);
+            } else if (sc.Match(closingQuote)) {
+                sc.ForwardSetState(SCE_VISUALPROLOG_DEFAULT);
+            } else if (sc.Match('\\')) {
+                sc.SetState(SCE_VISUALPROLOG_STRING_ESCAPE_ERROR);
+                forwardEscapeLiteral(sc, SCE_VISUALPROLOG_STRING_ESCAPE);
+            }
+            break;
+        case SCE_VISUALPROLOG_STRING_EOL_OPEN:
+            if (sc.atLineStart) {
+                sc.SetState(SCE_VISUALPROLOG_DEFAULT);
+            }
+            break;
+        case SCE_VISUALPROLOG_STRING_VERBATIM_SPECIAL:
+        case SCE_VISUALPROLOG_STRING_VERBATIM_EOL:
+            // return to SCE_VISUALPROLOG_STRING_VERBATIM and treat as such (fall-through)
+            sc.SetState(SCE_VISUALPROLOG_STRING_VERBATIM);
+            // Falls through.
+        case SCE_VISUALPROLOG_STRING_VERBATIM:
+            if (sc.atLineEnd) {
+                sc.SetState(SCE_VISUALPROLOG_STRING_VERBATIM_EOL);
+            } else if (sc.Match(closingQuote)) {
+                if (closingQuote == sc.chNext) {
+                    sc.SetState(SCE_VISUALPROLOG_STRING_VERBATIM_SPECIAL);
+                    sc.Forward();
+                } else {
+                    sc.ForwardSetState(SCE_VISUALPROLOG_DEFAULT);
+                }
+            }
+            break;
+        }
+
+        if (sc.atLineEnd) {
+            // Update the line state, so it can be seen by next line
+            int lineState = 0;
+            if (SCE_VISUALPROLOG_STRING_VERBATIM_EOL == sc.state) {
+                lineState = closingQuote;
+            } else if (SCE_VISUALPROLOG_COMMENT_BLOCK == sc.state) {
+                lineState = nestLevel;
+            }
+            styler.SetLineState(currentLine, lineState);
+            currentLine++;
+        }
+
+        // Determine if a new state should be entered.
+        if (sc.state == SCE_VISUALPROLOG_DEFAULT) {
+            if (sc.Match('@') && isOpenStringVerbatim(sc.chNext, closingQuote)) {
+                sc.SetState(SCE_VISUALPROLOG_STRING_VERBATIM);
+                sc.Forward();
+            } else if (IsADigit(sc.ch) || (sc.Match('.') && IsADigit(sc.chNext))) {
+                sc.SetState(SCE_VISUALPROLOG_NUMBER);
+            } else if (isLowerLetter(sc.ch)) {
+                sc.SetState(SCE_VISUALPROLOG_IDENTIFIER);
+            } else if (isUpperLetter(sc.ch)) {
+                sc.SetState(SCE_VISUALPROLOG_VARIABLE);
+            } else if (sc.Match('_')) {
+                sc.SetState(SCE_VISUALPROLOG_ANONYMOUS);
+            } else if (sc.Match('/', '*')) {
+                sc.SetState(SCE_VISUALPROLOG_COMMENT_BLOCK);
+                nestLevel = 1;
+                sc.Forward();	// Eat the * so it isn't used for the end of the comment
+            } else if (sc.Match('%')) {
+                sc.SetState(SCE_VISUALPROLOG_COMMENT_LINE);
+            } else if (sc.Match('\'')) {
+                closingQuote = '\'';
+                sc.SetState(SCE_VISUALPROLOG_STRING);
+            } else if (sc.Match('"')) {
+                closingQuote = '"';
+                sc.SetState(SCE_VISUALPROLOG_STRING);
+            } else if (sc.Match('#')) {
+                sc.SetState(SCE_VISUALPROLOG_KEY_DIRECTIVE);
+            } else if (isoperator(static_cast<char>(sc.ch)) || sc.Match('\\')) {
+                sc.SetState(SCE_VISUALPROLOG_OPERATOR);
+            }
+        }
+
+    }
+    sc.Complete();
+    styler.Flush();
+}
+
+// Store both the current line's fold level and the next lines in the
+// level store to make it easy to pick up with each increment
+// and to make it possible to fiddle the current level for "} else {".
+
+void SCI_METHOD LexerVisualProlog::Fold(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess) {
+
+    LexAccessor styler(pAccess);
+
+    Sci_PositionU endPos = startPos + length;
+    int visibleChars = 0;
+    Sci_Position currentLine = styler.GetLine(startPos);
+    int levelCurrent = SC_FOLDLEVELBASE;
+    if (currentLine > 0)
+        levelCurrent = styler.LevelAt(currentLine-1) >> 16;
+    int levelMinCurrent = levelCurrent;
+    int levelNext = levelCurrent;
+    char chNext = styler[startPos];
+    int styleNext = styler.StyleAt(startPos);
+    int style = initStyle;
+    for (Sci_PositionU i = startPos; i < endPos; i++) {
+        char ch = chNext;
+        chNext = styler.SafeGetCharAt(i + 1);
+        style = styleNext;
+        styleNext = styler.StyleAt(i + 1);
+        bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
+        if (style == SCE_VISUALPROLOG_OPERATOR) {
+            if (ch == '{') {
+                // Measure the minimum before a '{' to allow
+                // folding on "} else {"
+                if (levelMinCurrent > levelNext) {
+                    levelMinCurrent = levelNext;
+                }
+                levelNext++;
+            } else if (ch == '}') {
+                levelNext--;
+            }
+        }
+        if (!IsASpace(ch))
+            visibleChars++;
+        if (atEOL || (i == endPos-1)) {
+            int levelUse = levelCurrent;
+            int lev = levelUse | levelNext << 16;
+            if (levelUse < levelNext)
+                lev |= SC_FOLDLEVELHEADERFLAG;
+            if (lev != styler.LevelAt(currentLine)) {
+                styler.SetLevel(currentLine, lev);
+            }
+            currentLine++;
+            levelCurrent = levelNext;
+            levelMinCurrent = levelCurrent;
+            if (atEOL && (i == static_cast<Sci_PositionU>(styler.Length()-1))) {
+                // There is an empty line at end of file so give it same level and empty
+                styler.SetLevel(currentLine, (levelCurrent | levelCurrent << 16) | SC_FOLDLEVELWHITEFLAG);
+            }
+            visibleChars = 0;
+        }
+    }
+}
+
+LexerModule lmVisualProlog(SCLEX_VISUALPROLOG, LexerVisualProlog::LexerFactoryVisualProlog, "visualprolog", visualPrologWordLists);
diff --git a/Pythonwin/Scintilla/lexers/LexX12.cxx b/Pythonwin/Scintilla/lexers/LexX12.cxx
new file mode 100644
index 000000000..303bcf5d2
--- /dev/null
+++ b/Pythonwin/Scintilla/lexers/LexX12.cxx
@@ -0,0 +1,345 @@
+// Scintilla Lexer for X12
+// @file LexX12.cxx
+// Written by Iain Clarke, IMCSoft & Inobiz AB.
+// X12 official documentation is behind a paywall, but there's a description of the syntax here:
+// http://www.rawlinsecconsulting.com/x12tutorial/x12syn.html
+// This code is subject to the same license terms as the rest of the scintilla project:
+// The License.txt file describes the conditions under which this software may be distributed.
+//
+
+// Header order must match order in scripts/HeaderOrder.txt
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cctype>
+
+#include <vector>
+#include <algorithm>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+#include "LexerModule.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+class LexerX12 : public DefaultLexer
+{
+public:
+	LexerX12();
+	virtual ~LexerX12() {} // virtual destructor, as we inherit from ILexer
+
+	static ILexer5 *Factory() {
+		return new LexerX12;
+	}
+
+	int SCI_METHOD Version() const override
+	{
+		return lvRelease5;
+	}
+	void SCI_METHOD Release() override
+	{
+		delete this;
+	}
+
+	const char * SCI_METHOD PropertyNames() override
+	{
+		return "fold";
+	}
+	int SCI_METHOD PropertyType(const char *) override
+	{
+		return SC_TYPE_BOOLEAN; // Only one property!
+	}
+	const char * SCI_METHOD DescribeProperty(const char *name) override
+	{
+		if (!strcmp(name, "fold"))
+			return "Whether to apply folding to document or not";
+		return NULL;
+	}
+
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override
+	{
+		if (!strcmp(key, "fold"))
+		{
+			m_bFold = strcmp(val, "0") ? true : false;
+			return 0;
+		}
+		return -1;
+	}
+	const char * SCI_METHOD PropertyGet(const char *) override {
+		return "";
+	}
+	const char * SCI_METHOD DescribeWordListSets() override
+	{
+		return NULL;
+	}
+	Sci_Position SCI_METHOD WordListSet(int, const char *) override
+	{
+		return -1;
+	}
+	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 *) override
+	{
+		return NULL;
+	}
+
+protected:
+	struct Terminator
+	{
+		int Style = SCE_X12_BAD;
+		Sci_PositionU pos = 0;
+		Sci_PositionU length = 0;
+		int FoldChange = 0;
+	};
+	Terminator InitialiseFromISA(IDocument *pAccess);
+	Sci_PositionU FindPreviousSegmentStart(IDocument *pAccess, Sci_Position startPos) const;
+	Terminator DetectSegmentHeader(IDocument *pAccess, Sci_PositionU pos) const;
+	Terminator FindNextTerminator(IDocument *pAccess, Sci_PositionU pos, bool bJustSegmentTerminator = false) const;
+
+	bool m_bFold;
+	char m_chSubElement;
+	char m_chElement;
+	char m_chSegment[3]; // might be CRLF
+};
+
+LexerModule lmX12(SCLEX_X12, LexerX12::Factory, "x12");
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+LexerX12::LexerX12() : DefaultLexer("x12", SCLEX_X12)
+{
+	m_bFold = false;
+	m_chSegment[0] = m_chSegment[1] = m_chSegment[2] = m_chElement = m_chSubElement = 0;
+}
+
+void LexerX12::Lex(Sci_PositionU startPos, Sci_Position length, int, IDocument *pAccess)
+{
+	Sci_PositionU posFinish = startPos + length;
+
+	Terminator T = InitialiseFromISA(pAccess);
+
+	if (T.Style == SCE_X12_BAD)
+	{
+		if (T.pos < startPos)
+			T.pos = startPos; // we may be colouring in batches.
+		pAccess->StartStyling(startPos);
+		pAccess->SetStyleFor(T.pos - startPos, SCE_X12_ENVELOPE);
+		pAccess->SetStyleFor(posFinish - T.pos, SCE_X12_BAD);
+		return;
+	}
+
+	// Look backwards for a segment start or a document beginning
+	Sci_PositionU posCurrent = FindPreviousSegmentStart (pAccess, startPos);
+
+	// Style buffer, so we're not issuing loads of notifications
+	pAccess->StartStyling(posCurrent);
+
+	while (posCurrent < posFinish)
+	{
+		// Look for first element marker, so we can denote segment
+		T = DetectSegmentHeader(pAccess, posCurrent);
+		if (T.Style == SCE_X12_BAD)
+			break;
+
+		pAccess->SetStyleFor(T.pos - posCurrent, T.Style);
+		pAccess->SetStyleFor(T.length, SCE_X12_SEP_ELEMENT);
+		posCurrent = T.pos + T.length;
+
+		while (T.Style != SCE_X12_BAD && T.Style != SCE_X12_SEGMENTEND) // Break on bad or segment ending
+		{
+			T = FindNextTerminator(pAccess, posCurrent);
+			if (T.Style == SCE_X12_BAD)
+				break;
+
+			int Style = T.Style;
+			if (T.Style == SCE_X12_SEGMENTEND && m_chSegment[0] == '\r') // don't style cr/crlf
+				Style = SCE_X12_DEFAULT;
+
+			pAccess->SetStyleFor(T.pos - posCurrent, SCE_X12_DEFAULT);
+			pAccess->SetStyleFor(T.length, Style);
+			posCurrent = T.pos + T.length;
+		}
+		if (T.Style == SCE_X12_BAD)
+			break;
+	}
+
+	pAccess->SetStyleFor(posFinish - posCurrent, SCE_X12_BAD);
+}
+
+void LexerX12::Fold(Sci_PositionU startPos, Sci_Position length, int, IDocument *pAccess)
+{
+	if (!m_bFold)
+		return;
+
+	// Are we even foldable?
+	if (m_chSegment[0] != '\r' && m_chSegment[0] != '\n') // check for cr,lf,cr+lf.
+		return;
+
+	Sci_PositionU posFinish = startPos + length;
+
+	// Look backwards for a segment start or a document beginning
+	startPos = FindPreviousSegmentStart(pAccess, startPos);
+	Terminator T;
+
+	Sci_PositionU currLine = pAccess->LineFromPosition(startPos);
+	int levelCurrentStyle = SC_FOLDLEVELBASE;
+	if (currLine > 0)
+		levelCurrentStyle = pAccess->GetLevel(currLine - 1); // bottom 12 bits are level
+	int indentCurrent = levelCurrentStyle & (SC_FOLDLEVELBASE - 1);
+
+	while (startPos < posFinish)
+	{
+		T = DetectSegmentHeader(pAccess, startPos);
+		int indentNext = indentCurrent + T.FoldChange;
+		if (indentNext < 0)
+			indentNext = 0;
+
+		levelCurrentStyle = (T.FoldChange > 0) ? (SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG) : SC_FOLDLEVELBASE;
+
+		currLine = pAccess->LineFromPosition(startPos);
+		pAccess->SetLevel(currLine, levelCurrentStyle | indentCurrent);
+
+		T = FindNextTerminator(pAccess, startPos, true);
+		startPos = T.pos + T.length;
+		indentCurrent = indentNext;
+	}
+}
+
+LexerX12::Terminator LexerX12::InitialiseFromISA(IDocument *pAccess)
+{
+	Sci_Position length = pAccess->Length();
+	char c;
+	if (length <= 106)
+		return { SCE_X12_BAD, 0 };
+
+	pAccess->GetCharRange(&m_chElement, 3, 1);
+	pAccess->GetCharRange(&m_chSubElement, 104, 1);
+	pAccess->GetCharRange(m_chSegment, 105, 1);
+	if (m_chSegment[0] == '\r') // are we CRLF?
+	{
+		pAccess->GetCharRange(&c, 106, 1);
+		if (c == '\n')
+			m_chSegment[1] = c;
+	}
+
+	// Validate we have an element separator, and it's not silly!
+	if (m_chElement == '\0' || m_chElement == '\n' || m_chElement == '\r')
+		return { SCE_X12_BAD, 3 };
+
+	// Validate we have an element separator, and it's not silly!
+	if (m_chSubElement == '\0' || m_chSubElement == '\n' || m_chSubElement == '\r')
+		return { SCE_X12_BAD, 103 };
+
+	if (m_chElement == m_chSubElement)
+		return { SCE_X12_BAD, 104 };
+	if (m_chElement == m_chSegment[0])
+		return { SCE_X12_BAD, 105 };
+	if (m_chSubElement == m_chSegment[0])
+		return { SCE_X12_BAD, 104 };
+
+	// Check we have element markers at all the right places! ISA element has fixed entries.
+	std::vector<Sci_PositionU> ElementMarkers = { 3, 6, 17, 20, 31, 34, 50, 53, 69, 76, 81, 83, 89, 99, 101, 103  };
+	for (auto i : ElementMarkers)
+	{
+		pAccess->GetCharRange(&c, i, 1);
+		if (c != m_chElement)
+			return { SCE_X12_BAD, i };
+	}
+	// Check we have no element markers anywhere else!
+	for (Sci_PositionU i = 0; i < 105; i++)
+	{
+		if (std::find(ElementMarkers.begin(), ElementMarkers.end(), i) != ElementMarkers.end())
+			continue;
+
+		pAccess->GetCharRange(&c, i, 1);
+		if (c == m_chElement)
+			return { SCE_X12_BAD, i };
+	}
+
+	return { SCE_X12_ENVELOPE };
+}
+
+Sci_PositionU LexerX12::FindPreviousSegmentStart(IDocument *pAccess, Sci_Position startPos) const
+{
+	char c;
+
+	for ( ; startPos > 0; startPos--)
+	{
+		pAccess->GetCharRange(&c, startPos, 1);
+		if (c != m_chSegment[0])
+			continue;
+		// we've matched one - if this is not crlf we're done.
+		if (!m_chSegment[1])
+			return startPos + 1;
+		pAccess->GetCharRange(&c, startPos+1, 1);
+		if (c == m_chSegment[1])
+			return startPos + 2;
+	}
+	// We didn't find a ', so just go with the beginning
+	return 0;
+}
+
+LexerX12::Terminator LexerX12::DetectSegmentHeader(IDocument *pAccess, Sci_PositionU pos) const
+{
+	Sci_PositionU posStart = pos;
+	Sci_Position Length = pAccess->Length();
+	char Buf[6] = { 0 };
+	while (pos - posStart < 5 && pos < (Sci_PositionU)Length)
+	{
+		pAccess->GetCharRange(Buf + pos - posStart, pos, 1);
+		if (Buf [pos - posStart] != m_chElement) // more?
+		{
+			pos++;
+			continue;
+		}
+		if (strcmp(Buf, "ISA*") == 0)
+			return { SCE_X12_ENVELOPE, pos, 1, +1 };
+		if (strcmp(Buf, "IEA*") == 0)
+			return { SCE_X12_ENVELOPE, pos, 1, -1 };
+		if (strcmp(Buf, "GS*") == 0)
+			return { SCE_X12_FUNCTIONGROUP, pos, 1, +1 };
+		if (strcmp(Buf, "GE*") == 0)
+			return { SCE_X12_FUNCTIONGROUP, pos, 1, -1 };
+		if (strcmp(Buf, "ST*") == 0)
+			return { SCE_X12_TRANSACTIONSET, pos, 1, +1 };
+		if (strcmp(Buf, "SE*") == 0)
+			return { SCE_X12_TRANSACTIONSET, pos, 1, -1 };
+		return { SCE_X12_SEGMENTHEADER, pos, 1, 0 };
+	}
+	return { SCE_X12_BAD, pos, 0, 0 };
+}
+
+LexerX12::Terminator LexerX12::FindNextTerminator(IDocument *pAccess, Sci_PositionU pos, bool bJustSegmentTerminator) const
+{
+	char c;
+	Sci_Position Length = pAccess->Length();
+
+	while (pos < (Sci_PositionU)Length)
+	{
+		pAccess->GetCharRange(&c, pos, 1);
+		if (!bJustSegmentTerminator && c == m_chElement)
+			return { SCE_X12_SEP_ELEMENT, pos, 1 };
+		else if (!bJustSegmentTerminator && c == m_chSubElement)
+			return { SCE_X12_SEP_SUBELEMENT, pos, 1 };
+		else if (c == m_chSegment[0])
+		{
+			if (!m_chSegment[1])
+				return { SCE_X12_SEGMENTEND, pos, 1 };
+			pos++;
+			if (pos >= (Sci_PositionU)Length)
+				break;
+			pAccess->GetCharRange(&c, pos, 1);
+			if (c == m_chSegment[1])
+				return { SCE_X12_SEGMENTEND, pos-1, 2 };
+		}
+		pos++;
+	}
+
+	return { SCE_X12_BAD, pos };
+}
diff --git a/Pythonwin/Scintilla/src/LexYAML.cxx b/Pythonwin/Scintilla/lexers/LexYAML.cxx
similarity index 68%
rename from Pythonwin/Scintilla/src/LexYAML.cxx
rename to Pythonwin/Scintilla/lexers/LexYAML.cxx
index a4eac3ce7..75515603e 100644
--- a/Pythonwin/Scintilla/src/LexYAML.cxx
+++ b/Pythonwin/Scintilla/lexers/LexYAML.cxx
@@ -3,33 +3,34 @@
  ** Lexer for YAML.
  **/
 // Copyright 2003- by Sean O'Dell <sean@celsoft.com>
-// Release under the same license as Scintilla/SciTE.
+// The License.txt file describes the conditions under which this software may be distributed.
 
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
 
-#include "Platform.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
 
-#include "PropSet.h"
+#include "WordList.h"
+#include "LexAccessor.h"
 #include "Accessor.h"
 #include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
+#include "CharacterSet.h"
+#include "LexerModule.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 static const char * const yamlWordListDesc[] = {
 	"Keywords",
 	0
 };
 
-static inline bool AtEOL(Accessor &styler, unsigned int i) {
+static inline bool AtEOL(Accessor &styler, Sci_PositionU i) {
 	return (styler[i] == '\n') ||
 		((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n'));
 }
@@ -43,27 +44,42 @@ static unsigned int SpaceCount(char* lineBuffer) {
 	while (*headBuffer == ' ')
 		headBuffer++;
 
-	return headBuffer - lineBuffer;
+	return static_cast<unsigned int>(headBuffer - lineBuffer);
+}
+
+static bool KeywordAtChar(char* lineBuffer, char* startComment, const WordList &keywords) {
+	if (lineBuffer == NULL || startComment <= lineBuffer)
+		return false;
+	char* endValue = startComment - 1;
+	while (endValue >= lineBuffer && *endValue == ' ')
+		endValue--;
+	Sci_PositionU len = static_cast<Sci_PositionU>(endValue - lineBuffer) + 1;
+	char s[100];
+	if (len > (sizeof(s) / sizeof(s[0]) - 1))
+		return false;
+	strncpy(s, lineBuffer, len);
+	s[len] = '\0';
+	return (keywords.InList(s));
 }
 
-#define YAML_STATE_BITSIZE 16
+#define YAML_STATE_BITSIZE		16
 #define YAML_STATE_MASK			(0xFFFF0000)
 #define YAML_STATE_DOCUMENT		(1 << YAML_STATE_BITSIZE)
-#define YAML_STATE_VALUE			(2 << YAML_STATE_BITSIZE)
+#define YAML_STATE_VALUE		(2 << YAML_STATE_BITSIZE)
 #define YAML_STATE_COMMENT		(3 << YAML_STATE_BITSIZE)
 #define YAML_STATE_TEXT_PARENT	(4 << YAML_STATE_BITSIZE)
 #define YAML_STATE_TEXT			(5 << YAML_STATE_BITSIZE)
 
 static void ColouriseYAMLLine(
 	char *lineBuffer,
-	unsigned int currentLine,
-	unsigned int lengthLine,
-	unsigned int startLine,
-	unsigned int endPos,
+	Sci_PositionU currentLine,
+	Sci_PositionU lengthLine,
+	Sci_PositionU startLine,
+	Sci_PositionU endPos,
 	WordList &keywords,
 	Accessor &styler) {
 
-	unsigned int i = 0;
+	Sci_PositionU i = 0;
 	bool bInQuotes = false;
 	unsigned int indentAmount = SpaceCount(lineBuffer);
 
@@ -80,7 +96,7 @@ static void ColouriseYAMLLine(
 		}
 	}
 	styler.SetLineState(currentLine, 0);
-	if (strncmp(lineBuffer, "---", 3) == 0) {	// Document marker
+	if (strncmp(lineBuffer, "---", 3) == 0 || strncmp(lineBuffer, "...", 3) == 0) {	// Document marker
 		styler.SetLineState(currentLine, YAML_STATE_DOCUMENT);
 		styler.ColourTo(endPos, SCE_YAML_DOCUMENT);
 		return;
@@ -101,6 +117,10 @@ static void ColouriseYAMLLine(
 	while (i < lengthLine) {
 		if (lineBuffer[i] == '\'' || lineBuffer[i] == '\"') {
 			bInQuotes = !bInQuotes;
+		} else if (lineBuffer[i] == '#' && isspacechar(lineBuffer[i - 1]) && !bInQuotes) {
+			styler.ColourTo(startLine + i - 1, SCE_YAML_DEFAULT);
+			styler.ColourTo(endPos, SCE_YAML_COMMENT);
+			return;
 		} else if (lineBuffer[i] == ':' && !bInQuotes) {
 			styler.ColourTo(startLine + i - 1, SCE_YAML_IDENTIFIER);
 			styler.ColourTo(startLine + i, SCE_YAML_OPERATOR);
@@ -108,7 +128,7 @@ static void ColouriseYAMLLine(
 			i++;
 			while ((i < lengthLine) && isspacechar(lineBuffer[i]))
 				i++;
-			unsigned int endValue = lengthLine - 1;
+			Sci_PositionU endValue = lengthLine - 1;
 			while ((endValue >= i) && isspacechar(lineBuffer[endValue]))
 				endValue--;
 			lineBuffer[endValue + 1] = '\0';
@@ -136,27 +156,44 @@ static void ColouriseYAMLLine(
 				styler.ColourTo(endPos, SCE_YAML_COMMENT);
 				return;
 			}
+			Sci_PositionU startComment = i;
+			bInQuotes = false;
+			while (startComment < lengthLine) { // Comment must be space padded
+				if (lineBuffer[startComment] == '\'' || lineBuffer[startComment] == '\"')
+					bInQuotes = !bInQuotes;
+				if (lineBuffer[startComment] == '#' && isspacechar(lineBuffer[startComment - 1]) && !bInQuotes)
+					break;
+				startComment++;
+			}
 			styler.SetLineState(currentLine, YAML_STATE_VALUE);
 			if (lineBuffer[i] == '&' || lineBuffer[i] == '*') {
-				styler.ColourTo(endPos, SCE_YAML_REFERENCE);
+				styler.ColourTo(startLine + startComment - 1, SCE_YAML_REFERENCE);
+				if (startComment < lengthLine)
+					styler.ColourTo(endPos, SCE_YAML_COMMENT);
 				return;
 			}
-			if (keywords.InList(&lineBuffer[i])) { // Convertible value (true/false, etc.)
-				styler.ColourTo(endPos, SCE_YAML_KEYWORD);
+			if (KeywordAtChar(&lineBuffer[i], &lineBuffer[startComment], keywords)) { // Convertible value (true/false, etc.)
+				styler.ColourTo(startLine + startComment - 1, SCE_YAML_KEYWORD);
+				if (startComment < lengthLine)
+					styler.ColourTo(endPos, SCE_YAML_COMMENT);
 				return;
-			} else {
-				unsigned int i2 = i;
-				while ((i < lengthLine) && lineBuffer[i]) {
-					if (!(isascii(lineBuffer[i]) && isdigit(lineBuffer[i])) && lineBuffer[i] != '-' && lineBuffer[i] != '.' && lineBuffer[i] != ',') {
-						styler.ColourTo(endPos, SCE_YAML_DEFAULT);
-						return;
-					}
-					i++;
-				}
-				if (i > i2) {
-					styler.ColourTo(endPos, SCE_YAML_NUMBER);
+			}
+			Sci_PositionU i2 = i;
+			while ((i < startComment) && lineBuffer[i]) {
+				if (!(IsASCII(lineBuffer[i]) && isdigit(lineBuffer[i])) && lineBuffer[i] != '-'
+				        && lineBuffer[i] != '.' && lineBuffer[i] != ',' && lineBuffer[i] != ' ') {
+					styler.ColourTo(startLine + startComment - 1, SCE_YAML_DEFAULT);
+					if (startComment < lengthLine)
+						styler.ColourTo(endPos, SCE_YAML_COMMENT);
 					return;
 				}
+				i++;
+			}
+			if (i > i2) {
+				styler.ColourTo(startLine + startComment - 1, SCE_YAML_NUMBER);
+				if (startComment < lengthLine)
+					styler.ColourTo(endPos, SCE_YAML_COMMENT);
+				return;
 			}
 			break; // shouldn't get here, but just in case, the rest of the line is coloured the default
 		}
@@ -165,17 +202,17 @@ static void ColouriseYAMLLine(
 	styler.ColourTo(endPos, SCE_YAML_DEFAULT);
 }
 
-static void ColouriseYAMLDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler) {
-	char lineBuffer[1024];
+static void ColouriseYAMLDoc(Sci_PositionU startPos, Sci_Position length, int, WordList *keywordLists[], Accessor &styler) {
+	char lineBuffer[1024] = "";
 	styler.StartAt(startPos);
 	styler.StartSegment(startPos);
-	unsigned int linePos = 0;
-	unsigned int startLine = startPos;
-	unsigned int endPos = startPos + length;
-	unsigned int maxPos = styler.Length();
-	unsigned int lineCurrent = styler.GetLine(startPos);
+	Sci_PositionU linePos = 0;
+	Sci_PositionU startLine = startPos;
+	Sci_PositionU endPos = startPos + length;
+	Sci_PositionU maxPos = styler.Length();
+	Sci_PositionU lineCurrent = styler.GetLine(startPos);
 
-	for (unsigned int i = startPos; i < maxPos && i < endPos; i++) {
+	for (Sci_PositionU i = startPos; i < maxPos && i < endPos; i++) {
 		lineBuffer[linePos++] = styler[i];
 		if (AtEOL(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
 			// End of line (or of line buffer) met, colourise it
@@ -191,18 +228,18 @@ static void ColouriseYAMLDoc(unsigned int startPos, int length, int, WordList *k
 	}
 }
 
-static bool IsCommentLine(int line, Accessor &styler) {
-	int pos = styler.LineStart(line);
+static bool IsCommentLine(Sci_Position line, Accessor &styler) {
+	Sci_Position pos = styler.LineStart(line);
 	if (styler[pos] == '#')
 		return true;
 	return false;
 }
 
-static void FoldYAMLDoc(unsigned int startPos, int length, int /*initStyle - unused*/,
+static void FoldYAMLDoc(Sci_PositionU startPos, Sci_Position length, int /*initStyle - unused*/,
                       WordList *[], Accessor &styler) {
-	const int maxPos = startPos + length;
-	const int maxLines = styler.GetLine(maxPos - 1);             // Requested last line
-	const int docLines = styler.GetLine(styler.Length() - 1);  // Available last line
+	const Sci_Position maxPos = startPos + length;
+	const Sci_Position maxLines = styler.GetLine(maxPos - 1);             // Requested last line
+	const Sci_Position docLines = styler.GetLine(styler.Length() - 1);  // Available last line
 	const bool foldComment = styler.GetPropertyInt("fold.comment.yaml") != 0;
 
 	// Backtrack to previous non-blank line so we can determine indent level
@@ -210,7 +247,7 @@ static void FoldYAMLDoc(unsigned int startPos, int length, int /*initStyle - unu
 	// and so we can fix any preceding fold level (which is why we go back
 	// at least one line in all cases)
 	int spaceFlags = 0;
-	int lineCurrent = styler.GetLine(startPos);
+	Sci_Position lineCurrent = styler.GetLine(startPos);
 	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, NULL);
 	while (lineCurrent > 0) {
 		lineCurrent--;
@@ -233,12 +270,12 @@ static void FoldYAMLDoc(unsigned int startPos, int length, int /*initStyle - unu
 
 		// Gather info
 		int lev = indentCurrent;
-		int lineNext = lineCurrent + 1;
+		Sci_Position lineNext = lineCurrent + 1;
 		int indentNext = indentCurrent;
 		if (lineNext <= docLines) {
 			// Information about next line is only available if not at end of document
 			indentNext = styler.IndentAmount(lineNext, &spaceFlags, NULL);
-	}
+		}
 		const int comment = foldComment && IsCommentLine(lineCurrent, styler);
 		const int comment_start = (comment && !prevComment && (lineNext <= docLines) &&
 		                           IsCommentLine(lineNext, styler) && (lev > SC_FOLDLEVELBASE));
@@ -270,14 +307,14 @@ static void FoldYAMLDoc(unsigned int startPos, int length, int /*initStyle - unu
 		}
 
 		const int levelAfterComments = indentNext & SC_FOLDLEVELNUMBERMASK;
-		const int levelBeforeComments = Platform::Maximum(indentCurrentLevel,levelAfterComments);
+		const int levelBeforeComments = Maximum(indentCurrentLevel,levelAfterComments);
 
 		// Now set all the indent levels on the lines we skipped
 		// Do this from end to start.  Once we encounter one line
 		// which is indented more than the line after the end of
 		// the comment-block, use the level of the block before
 
-		int skipLine = lineNext;
+		Sci_Position skipLine = lineNext;
 		int skipLevel = levelAfterComments;
 
 		while (--skipLine > lineCurrent) {
diff --git a/Pythonwin/Scintilla/lexlib/Accessor.cxx b/Pythonwin/Scintilla/lexlib/Accessor.cxx
new file mode 100644
index 000000000..7cce9a554
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/Accessor.cxx
@@ -0,0 +1,73 @@
+// Scintilla source code edit control
+/** @file Accessor.cxx
+ ** Interfaces between Scintilla and lexers.
+ **/
+// Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstdlib>
+#include <cassert>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+
+using namespace Scintilla;
+
+Accessor::Accessor(IDocument *pAccess_, PropSetSimple *pprops_) : LexAccessor(pAccess_), pprops(pprops_) {
+}
+
+int Accessor::GetPropertyInt(const char *key, int defaultValue) const {
+	return pprops->GetInt(key, defaultValue);
+}
+
+int Accessor::IndentAmount(Sci_Position line, int *flags, PFNIsCommentLeader pfnIsCommentLeader) {
+	const Sci_Position end = Length();
+	int spaceFlags = 0;
+
+	// Determines the indentation level of the current line and also checks for consistent
+	// indentation compared to the previous line.
+	// Indentation is judged consistent when the indentation whitespace of each line lines
+	// the same or the indentation of one line is a prefix of the other.
+
+	Sci_Position pos = LineStart(line);
+	char ch = (*this)[pos];
+	int indent = 0;
+	bool inPrevPrefix = line > 0;
+	Sci_Position posPrev = inPrevPrefix ? LineStart(line-1) : 0;
+	while ((ch == ' ' || ch == '\t') && (pos < end)) {
+		if (inPrevPrefix) {
+			const char chPrev = (*this)[posPrev++];
+			if (chPrev == ' ' || chPrev == '\t') {
+				if (chPrev != ch)
+					spaceFlags |= wsInconsistent;
+			} else {
+				inPrevPrefix = false;
+			}
+		}
+		if (ch == ' ') {
+			spaceFlags |= wsSpace;
+			indent++;
+		} else {	// Tab
+			spaceFlags |= wsTab;
+			if (spaceFlags & wsSpace)
+				spaceFlags |= wsSpaceTab;
+			indent = (indent / 8 + 1) * 8;
+		}
+		ch = (*this)[++pos];
+	}
+
+	*flags = spaceFlags;
+	indent += SC_FOLDLEVELBASE;
+	// if completely empty line or the start of a comment...
+	if ((LineStart(line) == Length()) || (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') ||
+			(pfnIsCommentLeader && (*pfnIsCommentLeader)(*this, pos, end-pos)))
+		return indent | SC_FOLDLEVELWHITEFLAG;
+	else
+		return indent;
+}
diff --git a/Pythonwin/Scintilla/lexlib/Accessor.h b/Pythonwin/Scintilla/lexlib/Accessor.h
new file mode 100644
index 000000000..8fc3f641a
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/Accessor.h
@@ -0,0 +1,31 @@
+// Scintilla source code edit control
+/** @file Accessor.h
+ ** Interfaces between Scintilla and lexers.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef ACCESSOR_H
+#define ACCESSOR_H
+
+namespace Scintilla {
+
+enum { wsSpace=1, wsTab=2, wsSpaceTab=4, wsInconsistent=8 };
+
+class Accessor;
+class WordList;
+class PropSetSimple;
+
+typedef bool (*PFNIsCommentLeader)(Accessor &styler, Sci_Position pos, Sci_Position len);
+
+class Accessor : public LexAccessor {
+public:
+	PropSetSimple *pprops;
+	Accessor(IDocument *pAccess_, PropSetSimple *pprops_);
+	int GetPropertyInt(const char *, int defaultValue=0) const;
+	int IndentAmount(Sci_Position line, int *flags, PFNIsCommentLeader pfnIsCommentLeader = 0);
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/CatalogueModules.h b/Pythonwin/Scintilla/lexlib/CatalogueModules.h
new file mode 100644
index 000000000..267a7b82b
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/CatalogueModules.h
@@ -0,0 +1,70 @@
+// Scintilla source code edit control
+/** @file CatalogueModules.h
+ ** Lexer infrastructure.
+ ** Contains a list of LexerModules which can be searched to find a module appropriate for a
+ ** particular language.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef CATALOGUEMODULES_H
+#define CATALOGUEMODULES_H
+
+namespace Scintilla {
+
+class CatalogueModules {
+	std::vector<LexerModule *> lexerCatalogue;
+public:
+	const LexerModule *Find(int language) const {
+		for (const LexerModule *lm : lexerCatalogue) {
+			if (lm->GetLanguage() == language) {
+				return lm;
+			}
+		}
+		return nullptr;
+	}
+
+	const LexerModule *Find(const char *languageName) const noexcept {
+		if (languageName) {
+			for (const LexerModule *lm : lexerCatalogue) {
+				if (lm->languageName && (0 == strcmp(lm->languageName, languageName))) {
+					return lm;
+				}
+			}
+		}
+		return nullptr;
+	}
+
+	void AddLexerModule(LexerModule *plm) {
+		lexerCatalogue.push_back(plm);
+	}
+
+	unsigned int Count() const noexcept {
+		return static_cast<unsigned int>(lexerCatalogue.size());
+	}
+
+	const char *Name(unsigned int index) const noexcept {
+		if (index < static_cast<unsigned int>(lexerCatalogue.size())) {
+			return lexerCatalogue[index]->languageName;
+		} else {
+			return "";
+		}
+	}
+
+	LexerFactoryFunction Factory(unsigned int index) const noexcept {
+		// Works for object lexers but not for function lexers
+		return lexerCatalogue[index]->fnFactory;
+	}
+
+	ILexer5 *Create(unsigned int index) const {
+		const LexerModule *plm = lexerCatalogue[index];
+		if (!plm) {
+			return nullptr;
+		}
+		return plm->Create();
+	}
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/CharacterCategory.cxx b/Pythonwin/Scintilla/lexlib/CharacterCategory.cxx
new file mode 100644
index 000000000..a2b0e0cca
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/CharacterCategory.cxx
@@ -0,0 +1,4048 @@
+// Scintilla source code edit control
+/** @file CharacterCategory.cxx
+ ** Returns the Unicode general category of a character.
+ ** Table automatically regenerated by scripts/GenerateCharacterCategory.py
+ ** Should only be rarely regenerated for new versions of Unicode.
+ **/
+// Copyright 2013 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <vector>
+#include <algorithm>
+#include <iterator>
+
+#include "CharacterCategory.h"
+
+namespace Scintilla {
+
+namespace {
+	// Use an unnamed namespace to protect the declarations from name conflicts
+
+const int catRanges[] = {
+//++Autogenerated -- start of section automatically generated
+// Created with Python 3.8.0,  Unicode 12.1.0
+25,
+1046,
+1073,
+1171,
+1201,
+1293,
+1326,
+1361,
+1394,
+1425,
+1452,
+1489,
+1544,
+1873,
+1938,
+2033,
+2080,
+2925,
+2961,
+2990,
+3028,
+3051,
+3092,
+3105,
+3949,
+3986,
+4014,
+4050,
+4089,
+5142,
+5169,
+5203,
+5333,
+5361,
+5396,
+5429,
+5444,
+5487,
+5522,
+5562,
+5589,
+5620,
+5653,
+5682,
+5706,
+5780,
+5793,
+5841,
+5908,
+5930,
+5956,
+6000,
+6026,
+6129,
+6144,
+6898,
+6912,
+7137,
+7922,
+7937,
+8192,
+8225,
+8256,
+8289,
+8320,
+8353,
+8384,
+8417,
+8448,
+8481,
+8512,
+8545,
+8576,
+8609,
+8640,
+8673,
+8704,
+8737,
+8768,
+8801,
+8832,
+8865,
+8896,
+8929,
+8960,
+8993,
+9024,
+9057,
+9088,
+9121,
+9152,
+9185,
+9216,
+9249,
+9280,
+9313,
+9344,
+9377,
+9408,
+9441,
+9472,
+9505,
+9536,
+9569,
+9600,
+9633,
+9664,
+9697,
+9728,
+9761,
+9792,
+9825,
+9856,
+9889,
+9920,
+9953,
+10016,
+10049,
+10080,
+10113,
+10144,
+10177,
+10208,
+10241,
+10272,
+10305,
+10336,
+10369,
+10400,
+10433,
+10464,
+10497,
+10560,
+10593,
+10624,
+10657,
+10688,
+10721,
+10752,
+10785,
+10816,
+10849,
+10880,
+10913,
+10944,
+10977,
+11008,
+11041,
+11072,
+11105,
+11136,
+11169,
+11200,
+11233,
+11264,
+11297,
+11328,
+11361,
+11392,
+11425,
+11456,
+11489,
+11520,
+11553,
+11584,
+11617,
+11648,
+11681,
+11712,
+11745,
+11776,
+11809,
+11840,
+11873,
+11904,
+11937,
+11968,
+12001,
+12032,
+12097,
+12128,
+12161,
+12192,
+12225,
+12320,
+12385,
+12416,
+12449,
+12480,
+12545,
+12576,
+12673,
+12736,
+12865,
+12896,
+12961,
+12992,
+13089,
+13184,
+13249,
+13280,
+13345,
+13376,
+13409,
+13440,
+13473,
+13504,
+13569,
+13600,
+13633,
+13696,
+13729,
+13760,
+13825,
+13856,
+13953,
+13984,
+14017,
+14048,
+14113,
+14180,
+14208,
+14241,
+14340,
+14464,
+14498,
+14529,
+14560,
+14594,
+14625,
+14656,
+14690,
+14721,
+14752,
+14785,
+14816,
+14849,
+14880,
+14913,
+14944,
+14977,
+15008,
+15041,
+15072,
+15105,
+15136,
+15169,
+15200,
+15233,
+15296,
+15329,
+15360,
+15393,
+15424,
+15457,
+15488,
+15521,
+15552,
+15585,
+15616,
+15649,
+15680,
+15713,
+15744,
+15777,
+15808,
+15841,
+15904,
+15938,
+15969,
+16000,
+16033,
+16064,
+16161,
+16192,
+16225,
+16256,
+16289,
+16320,
+16353,
+16384,
+16417,
+16448,
+16481,
+16512,
+16545,
+16576,
+16609,
+16640,
+16673,
+16704,
+16737,
+16768,
+16801,
+16832,
+16865,
+16896,
+16929,
+16960,
+16993,
+17024,
+17057,
+17088,
+17121,
+17152,
+17185,
+17216,
+17249,
+17280,
+17313,
+17344,
+17377,
+17408,
+17441,
+17472,
+17505,
+17536,
+17569,
+17600,
+17633,
+17664,
+17697,
+17728,
+17761,
+17792,
+17825,
+17856,
+17889,
+17920,
+17953,
+17984,
+18017,
+18240,
+18305,
+18336,
+18401,
+18464,
+18497,
+18528,
+18657,
+18688,
+18721,
+18752,
+18785,
+18816,
+18849,
+18880,
+18913,
+21124,
+21153,
+22019,
+22612,
+22723,
+23124,
+23555,
+23732,
+23939,
+23988,
+24003,
+24052,
+24581,
+28160,
+28193,
+28224,
+28257,
+28291,
+28340,
+28352,
+28385,
+28445,
+28483,
+28513,
+28625,
+28640,
+28701,
+28820,
+28864,
+28913,
+28928,
+29053,
+29056,
+29117,
+29120,
+29185,
+29216,
+29789,
+29792,
+30081,
+31200,
+31233,
+31296,
+31393,
+31488,
+31521,
+31552,
+31585,
+31616,
+31649,
+31680,
+31713,
+31744,
+31777,
+31808,
+31841,
+31872,
+31905,
+31936,
+31969,
+32000,
+32033,
+32064,
+32097,
+32128,
+32161,
+32192,
+32225,
+32384,
+32417,
+32466,
+32480,
+32513,
+32544,
+32609,
+32672,
+34305,
+35840,
+35873,
+35904,
+35937,
+35968,
+36001,
+36032,
+36065,
+36096,
+36129,
+36160,
+36193,
+36224,
+36257,
+36288,
+36321,
+36352,
+36385,
+36416,
+36449,
+36480,
+36513,
+36544,
+36577,
+36608,
+36641,
+36672,
+36705,
+36736,
+36769,
+36800,
+36833,
+36864,
+36897,
+36949,
+36965,
+37127,
+37184,
+37217,
+37248,
+37281,
+37312,
+37345,
+37376,
+37409,
+37440,
+37473,
+37504,
+37537,
+37568,
+37601,
+37632,
+37665,
+37696,
+37729,
+37760,
+37793,
+37824,
+37857,
+37888,
+37921,
+37952,
+37985,
+38016,
+38049,
+38080,
+38113,
+38144,
+38177,
+38208,
+38241,
+38272,
+38305,
+38336,
+38369,
+38400,
+38433,
+38464,
+38497,
+38528,
+38561,
+38592,
+38625,
+38656,
+38689,
+38720,
+38753,
+38784,
+38817,
+38848,
+38881,
+38912,
+38977,
+39008,
+39041,
+39072,
+39105,
+39136,
+39169,
+39200,
+39233,
+39264,
+39297,
+39328,
+39361,
+39424,
+39457,
+39488,
+39521,
+39552,
+39585,
+39616,
+39649,
+39680,
+39713,
+39744,
+39777,
+39808,
+39841,
+39872,
+39905,
+39936,
+39969,
+40000,
+40033,
+40064,
+40097,
+40128,
+40161,
+40192,
+40225,
+40256,
+40289,
+40320,
+40353,
+40384,
+40417,
+40448,
+40481,
+40512,
+40545,
+40576,
+40609,
+40640,
+40673,
+40704,
+40737,
+40768,
+40801,
+40832,
+40865,
+40896,
+40929,
+40960,
+40993,
+41024,
+41057,
+41088,
+41121,
+41152,
+41185,
+41216,
+41249,
+41280,
+41313,
+41344,
+41377,
+41408,
+41441,
+41472,
+41505,
+41536,
+41569,
+41600,
+41633,
+41664,
+41697,
+41728,
+41761,
+41792,
+41825,
+41856,
+41889,
+41920,
+41953,
+41984,
+42017,
+42048,
+42081,
+42112,
+42145,
+42176,
+42209,
+42240,
+42273,
+42304,
+42337,
+42368,
+42401,
+42432,
+42465,
+42525,
+42528,
+43773,
+43811,
+43857,
+44033,
+45361,
+45388,
+45437,
+45493,
+45555,
+45597,
+45605,
+47052,
+47077,
+47121,
+47141,
+47217,
+47237,
+47313,
+47333,
+47389,
+47620,
+48509,
+48612,
+48753,
+48829,
+49178,
+49362,
+49457,
+49523,
+49553,
+49621,
+49669,
+50033,
+50074,
+50109,
+50129,
+50180,
+51203,
+51236,
+51557,
+52232,
+52561,
+52676,
+52741,
+52772,
+55953,
+55972,
+56005,
+56250,
+56277,
+56293,
+56483,
+56549,
+56629,
+56645,
+56772,
+56840,
+57156,
+57269,
+57316,
+57361,
+57821,
+57850,
+57860,
+57893,
+57924,
+58885,
+59773,
+59812,
+62661,
+63012,
+63069,
+63496,
+63812,
+64869,
+65155,
+65237,
+65265,
+65347,
+65405,
+65445,
+65491,
+65540,
+66245,
+66371,
+66405,
+66691,
+66725,
+66819,
+66853,
+67037,
+67089,
+67581,
+67588,
+68389,
+68509,
+68561,
+68605,
+68612,
+68989,
+70660,
+71357,
+71364,
+71645,
+72293,
+72794,
+72805,
+73830,
+73860,
+75589,
+75622,
+75653,
+75684,
+75718,
+75813,
+76070,
+76197,
+76230,
+76292,
+76325,
+76548,
+76869,
+76945,
+77000,
+77329,
+77347,
+77380,
+77861,
+77894,
+77981,
+77988,
+78269,
+78308,
+78397,
+78436,
+79165,
+79172,
+79421,
+79428,
+79485,
+79556,
+79709,
+79749,
+79780,
+79814,
+79909,
+80061,
+80102,
+80189,
+80230,
+80293,
+80324,
+80381,
+80614,
+80669,
+80772,
+80861,
+80868,
+80965,
+81053,
+81096,
+81412,
+81491,
+81546,
+81749,
+81779,
+81796,
+81841,
+81861,
+81917,
+81957,
+82022,
+82077,
+82084,
+82301,
+82404,
+82493,
+82532,
+83261,
+83268,
+83517,
+83524,
+83613,
+83620,
+83709,
+83716,
+83805,
+83845,
+83901,
+83910,
+84005,
+84093,
+84197,
+84285,
+84325,
+84445,
+84517,
+84573,
+84772,
+84925,
+84932,
+84989,
+85192,
+85509,
+85572,
+85669,
+85713,
+85757,
+86053,
+86118,
+86173,
+86180,
+86493,
+86500,
+86621,
+86628,
+87357,
+87364,
+87613,
+87620,
+87709,
+87716,
+87901,
+87941,
+87972,
+88006,
+88101,
+88285,
+88293,
+88358,
+88413,
+88422,
+88485,
+88541,
+88580,
+88637,
+89092,
+89157,
+89245,
+89288,
+89617,
+89651,
+89693,
+89892,
+89925,
+90141,
+90149,
+90182,
+90269,
+90276,
+90557,
+90596,
+90685,
+90724,
+91453,
+91460,
+91709,
+91716,
+91805,
+91812,
+91997,
+92037,
+92068,
+92102,
+92133,
+92166,
+92197,
+92349,
+92390,
+92477,
+92518,
+92581,
+92637,
+92869,
+92902,
+92957,
+93060,
+93149,
+93156,
+93253,
+93341,
+93384,
+93717,
+93732,
+93770,
+93981,
+94277,
+94308,
+94365,
+94372,
+94589,
+94660,
+94781,
+94788,
+94941,
+95012,
+95101,
+95108,
+95165,
+95172,
+95261,
+95332,
+95421,
+95492,
+95613,
+95684,
+96093,
+96198,
+96261,
+96294,
+96381,
+96454,
+96573,
+96582,
+96677,
+96733,
+96772,
+96829,
+96998,
+97053,
+97480,
+97802,
+97909,
+98099,
+98133,
+98173,
+98309,
+98342,
+98437,
+98468,
+98749,
+98756,
+98877,
+98884,
+99645,
+99652,
+100189,
+100260,
+100293,
+100390,
+100541,
+100549,
+100669,
+100677,
+100829,
+101029,
+101117,
+101124,
+101245,
+101380,
+101445,
+101533,
+101576,
+101917,
+102129,
+102154,
+102389,
+102404,
+102437,
+102470,
+102545,
+102564,
+102845,
+102852,
+102973,
+102980,
+103741,
+103748,
+104093,
+104100,
+104285,
+104325,
+104356,
+104390,
+104421,
+104454,
+104637,
+104645,
+104678,
+104765,
+104774,
+104837,
+104925,
+105126,
+105213,
+105412,
+105469,
+105476,
+105541,
+105629,
+105672,
+106013,
+106020,
+106109,
+106501,
+106566,
+106653,
+106660,
+106941,
+106948,
+107069,
+107076,
+108389,
+108452,
+108486,
+108581,
+108733,
+108742,
+108861,
+108870,
+108965,
+108996,
+109045,
+109085,
+109188,
+109286,
+109322,
+109540,
+109637,
+109725,
+109768,
+110090,
+110389,
+110404,
+110621,
+110662,
+110749,
+110756,
+111357,
+111428,
+112221,
+112228,
+112541,
+112548,
+112605,
+112644,
+112893,
+112965,
+113021,
+113126,
+113221,
+113341,
+113349,
+113405,
+113414,
+113693,
+113864,
+114205,
+114246,
+114321,
+114365,
+114724,
+116261,
+116292,
+116357,
+116605,
+116723,
+116740,
+116931,
+116965,
+117233,
+117256,
+117585,
+117661,
+118820,
+118909,
+118916,
+118973,
+118980,
+119165,
+119172,
+119965,
+119972,
+120029,
+120036,
+120357,
+120388,
+120453,
+120740,
+120797,
+120836,
+121021,
+121027,
+121085,
+121093,
+121309,
+121352,
+121693,
+121732,
+121885,
+122884,
+122933,
+123025,
+123509,
+123537,
+123573,
+123653,
+123733,
+123912,
+124234,
+124565,
+124581,
+124629,
+124645,
+124693,
+124709,
+124749,
+124782,
+124813,
+124846,
+124870,
+124932,
+125213,
+125220,
+126397,
+126501,
+126950,
+126981,
+127153,
+127173,
+127236,
+127397,
+127773,
+127781,
+128957,
+128981,
+129221,
+129269,
+129469,
+129493,
+129553,
+129717,
+129841,
+129917,
+131076,
+132454,
+132517,
+132646,
+132677,
+132870,
+132901,
+132966,
+133029,
+133092,
+133128,
+133457,
+133636,
+133830,
+133893,
+133956,
+134085,
+134180,
+134214,
+134308,
+134374,
+134596,
+134693,
+134820,
+135237,
+135270,
+135333,
+135398,
+135589,
+135620,
+135654,
+135688,
+136006,
+136101,
+136149,
+136192,
+137437,
+137440,
+137501,
+137632,
+137693,
+137729,
+139121,
+139139,
+139169,
+139268,
+149821,
+149828,
+149981,
+150020,
+150269,
+150276,
+150333,
+150340,
+150493,
+150532,
+151869,
+151876,
+152029,
+152068,
+153149,
+153156,
+153309,
+153348,
+153597,
+153604,
+153661,
+153668,
+153821,
+153860,
+154365,
+154372,
+156221,
+156228,
+156381,
+156420,
+158589,
+158629,
+158737,
+159018,
+159677,
+159748,
+160277,
+160605,
+160768,
+163549,
+163585,
+163805,
+163852,
+163876,
+183733,
+183761,
+183780,
+184342,
+184356,
+185197,
+185230,
+185277,
+185348,
+187761,
+187849,
+187940,
+188221,
+188420,
+188861,
+188868,
+188997,
+189117,
+189444,
+190021,
+190129,
+190205,
+190468,
+191045,
+191133,
+191492,
+191933,
+191940,
+192061,
+192069,
+192157,
+192516,
+194181,
+194246,
+194277,
+194502,
+194757,
+194790,
+194853,
+195217,
+195299,
+195345,
+195443,
+195460,
+195493,
+195549,
+195592,
+195933,
+196106,
+196445,
+196625,
+196812,
+196849,
+196965,
+197082,
+197117,
+197128,
+197469,
+197636,
+198755,
+198788,
+200509,
+200708,
+200869,
+200932,
+202021,
+202052,
+202109,
+202244,
+204509,
+204804,
+205821,
+205829,
+205926,
+206053,
+206118,
+206237,
+206342,
+206405,
+206438,
+206629,
+206749,
+206869,
+206909,
+206993,
+207048,
+207364,
+208349,
+208388,
+208573,
+208900,
+210333,
+210436,
+211293,
+211464,
+211786,
+211837,
+211925,
+212996,
+213733,
+213798,
+213861,
+213917,
+213969,
+214020,
+215718,
+215749,
+215782,
+215813,
+216061,
+216069,
+216102,
+216133,
+216166,
+216229,
+216486,
+216677,
+217021,
+217061,
+217096,
+217437,
+217608,
+217949,
+218129,
+218339,
+218385,
+218589,
+218629,
+219079,
+219133,
+221189,
+221318,
+221348,
+222853,
+222886,
+222917,
+223078,
+223109,
+223142,
+223301,
+223334,
+223396,
+223645,
+223752,
+224081,
+224309,
+224613,
+224917,
+225213,
+225285,
+225350,
+225380,
+226342,
+226373,
+226502,
+226565,
+226630,
+226661,
+226756,
+226824,
+227140,
+228549,
+228582,
+228613,
+228678,
+228773,
+228806,
+228837,
+228934,
+229021,
+229265,
+229380,
+230534,
+230789,
+231046,
+231109,
+231197,
+231281,
+231432,
+231773,
+231844,
+231944,
+232260,
+233219,
+233425,
+233473,
+233789,
+233984,
+235389,
+235424,
+235537,
+235805,
+236037,
+236145,
+236165,
+236582,
+236613,
+236836,
+236965,
+236996,
+237189,
+237220,
+237286,
+237317,
+237380,
+237437,
+237569,
+238979,
+240993,
+241411,
+241441,
+242531,
+243717,
+245597,
+245605,
+245760,
+245793,
+245824,
+245857,
+245888,
+245921,
+245952,
+245985,
+246016,
+246049,
+246080,
+246113,
+246144,
+246177,
+246208,
+246241,
+246272,
+246305,
+246336,
+246369,
+246400,
+246433,
+246464,
+246497,
+246528,
+246561,
+246592,
+246625,
+246656,
+246689,
+246720,
+246753,
+246784,
+246817,
+246848,
+246881,
+246912,
+246945,
+246976,
+247009,
+247040,
+247073,
+247104,
+247137,
+247168,
+247201,
+247232,
+247265,
+247296,
+247329,
+247360,
+247393,
+247424,
+247457,
+247488,
+247521,
+247552,
+247585,
+247616,
+247649,
+247680,
+247713,
+247744,
+247777,
+247808,
+247841,
+247872,
+247905,
+247936,
+247969,
+248000,
+248033,
+248064,
+248097,
+248128,
+248161,
+248192,
+248225,
+248256,
+248289,
+248320,
+248353,
+248384,
+248417,
+248448,
+248481,
+248512,
+248545,
+248576,
+248609,
+248640,
+248673,
+248704,
+248737,
+248768,
+248801,
+248832,
+248865,
+248896,
+248929,
+248960,
+248993,
+249024,
+249057,
+249088,
+249121,
+249152,
+249185,
+249216,
+249249,
+249280,
+249313,
+249344,
+249377,
+249408,
+249441,
+249472,
+249505,
+249536,
+249569,
+249600,
+249633,
+249664,
+249697,
+249728,
+249761,
+249792,
+249825,
+249856,
+249889,
+249920,
+249953,
+249984,
+250017,
+250048,
+250081,
+250112,
+250145,
+250176,
+250209,
+250240,
+250273,
+250304,
+250337,
+250368,
+250401,
+250432,
+250465,
+250496,
+250529,
+250816,
+250849,
+250880,
+250913,
+250944,
+250977,
+251008,
+251041,
+251072,
+251105,
+251136,
+251169,
+251200,
+251233,
+251264,
+251297,
+251328,
+251361,
+251392,
+251425,
+251456,
+251489,
+251520,
+251553,
+251584,
+251617,
+251648,
+251681,
+251712,
+251745,
+251776,
+251809,
+251840,
+251873,
+251904,
+251937,
+251968,
+252001,
+252032,
+252065,
+252096,
+252129,
+252160,
+252193,
+252224,
+252257,
+252288,
+252321,
+252352,
+252385,
+252416,
+252449,
+252480,
+252513,
+252544,
+252577,
+252608,
+252641,
+252672,
+252705,
+252736,
+252769,
+252800,
+252833,
+252864,
+252897,
+252928,
+252961,
+252992,
+253025,
+253056,
+253089,
+253120,
+253153,
+253184,
+253217,
+253248,
+253281,
+253312,
+253345,
+253376,
+253409,
+253440,
+253473,
+253504,
+253537,
+253568,
+253601,
+253632,
+253665,
+253696,
+253729,
+253760,
+253793,
+253824,
+253857,
+253888,
+253921,
+254208,
+254465,
+254685,
+254720,
+254941,
+254977,
+255232,
+255489,
+255744,
+256001,
+256221,
+256256,
+256477,
+256513,
+256797,
+256800,
+256861,
+256864,
+256925,
+256928,
+256989,
+256992,
+257025,
+257280,
+257537,
+258013,
+258049,
+258306,
+258561,
+258818,
+259073,
+259330,
+259585,
+259773,
+259777,
+259840,
+259970,
+260020,
+260033,
+260084,
+260161,
+260285,
+260289,
+260352,
+260482,
+260532,
+260609,
+260765,
+260801,
+260864,
+261021,
+261044,
+261121,
+261376,
+261556,
+261661,
+261697,
+261821,
+261825,
+261888,
+262018,
+262068,
+262141,
+262166,
+262522,
+262668,
+262865,
+262927,
+262960,
+262989,
+263023,
+263088,
+263117,
+263151,
+263185,
+263447,
+263480,
+263514,
+263670,
+263697,
+263983,
+264016,
+264049,
+264171,
+264241,
+264338,
+264365,
+264398,
+264433,
+264786,
+264817,
+264843,
+264881,
+265206,
+265242,
+265405,
+265434,
+265738,
+265763,
+265821,
+265866,
+266066,
+266157,
+266190,
+266211,
+266250,
+266578,
+266669,
+266702,
+266749,
+266755,
+267197,
+267283,
+268317,
+268805,
+269223,
+269349,
+269383,
+269477,
+269885,
+270357,
+270400,
+270453,
+270560,
+270613,
+270657,
+270688,
+270785,
+270848,
+270945,
+270997,
+271008,
+271061,
+271122,
+271136,
+271317,
+271488,
+271541,
+271552,
+271605,
+271616,
+271669,
+271680,
+271829,
+271841,
+271872,
+272001,
+272036,
+272161,
+272213,
+272257,
+272320,
+272402,
+272544,
+272577,
+272725,
+272754,
+272789,
+272833,
+272885,
+272906,
+273417,
+274528,
+274561,
+274601,
+274730,
+274773,
+274845,
+274962,
+275125,
+275282,
+275349,
+275474,
+275509,
+275570,
+275605,
+275666,
+275701,
+275922,
+275957,
+276946,
+277013,
+277074,
+277109,
+277138,
+277173,
+278162,
+286741,
+286989,
+287022,
+287053,
+287086,
+287125,
+287762,
+287829,
+288045,
+288078,
+288117,
+290706,
+290741,
+291698,
+292501,
+293778,
+293973,
+296189,
+296981,
+297341,
+297994,
+299925,
+302410,
+303125,
+308978,
+309013,
+309298,
+309333,
+311058,
+311317,
+314866,
+314901,
+322829,
+322862,
+322893,
+322926,
+322957,
+322990,
+323021,
+323054,
+323085,
+323118,
+323149,
+323182,
+323213,
+323246,
+323274,
+324245,
+325650,
+325805,
+325838,
+325874,
+326861,
+326894,
+326925,
+326958,
+326989,
+327022,
+327053,
+327086,
+327117,
+327150,
+327186,
+327701,
+335890,
+340077,
+340110,
+340141,
+340174,
+340205,
+340238,
+340269,
+340302,
+340333,
+340366,
+340397,
+340430,
+340461,
+340494,
+340525,
+340558,
+340589,
+340622,
+340653,
+340686,
+340717,
+340750,
+340786,
+342797,
+342830,
+342861,
+342894,
+342930,
+343949,
+343982,
+344018,
+352277,
+353810,
+354485,
+354546,
+354741,
+355997,
+356053,
+357085,
+357141,
+360448,
+361981,
+361985,
+363517,
+363520,
+363553,
+363584,
+363681,
+363744,
+363777,
+363808,
+363841,
+363872,
+363905,
+363936,
+364065,
+364096,
+364129,
+364192,
+364225,
+364419,
+364480,
+364577,
+364608,
+364641,
+364672,
+364705,
+364736,
+364769,
+364800,
+364833,
+364864,
+364897,
+364928,
+364961,
+364992,
+365025,
+365056,
+365089,
+365120,
+365153,
+365184,
+365217,
+365248,
+365281,
+365312,
+365345,
+365376,
+365409,
+365440,
+365473,
+365504,
+365537,
+365568,
+365601,
+365632,
+365665,
+365696,
+365729,
+365760,
+365793,
+365824,
+365857,
+365888,
+365921,
+365952,
+365985,
+366016,
+366049,
+366080,
+366113,
+366144,
+366177,
+366208,
+366241,
+366272,
+366305,
+366336,
+366369,
+366400,
+366433,
+366464,
+366497,
+366528,
+366561,
+366592,
+366625,
+366656,
+366689,
+366720,
+366753,
+366784,
+366817,
+366848,
+366881,
+366912,
+366945,
+366976,
+367009,
+367040,
+367073,
+367104,
+367137,
+367168,
+367201,
+367232,
+367265,
+367296,
+367329,
+367360,
+367393,
+367424,
+367457,
+367488,
+367521,
+367552,
+367585,
+367616,
+367649,
+367680,
+367713,
+367797,
+367968,
+368001,
+368032,
+368065,
+368101,
+368192,
+368225,
+368285,
+368433,
+368554,
+368593,
+368641,
+369885,
+369889,
+369949,
+370081,
+370141,
+370180,
+371997,
+372195,
+372241,
+372285,
+372709,
+372740,
+373501,
+373764,
+374013,
+374020,
+374269,
+374276,
+374525,
+374532,
+374781,
+374788,
+375037,
+375044,
+375293,
+375300,
+375549,
+375556,
+375805,
+375813,
+376849,
+376911,
+376944,
+376975,
+377008,
+377041,
+377135,
+377168,
+377201,
+377231,
+377264,
+377297,
+377580,
+377617,
+377676,
+377713,
+377743,
+377776,
+377809,
+377871,
+377904,
+377933,
+377966,
+377997,
+378030,
+378061,
+378094,
+378125,
+378158,
+378193,
+378339,
+378385,
+378700,
+378769,
+378892,
+378929,
+378957,
+378993,
+379421,
+380949,
+381789,
+381813,
+384669,
+385045,
+391901,
+392725,
+393117,
+393238,
+393265,
+393365,
+393379,
+393412,
+393449,
+393485,
+393518,
+393549,
+393582,
+393613,
+393646,
+393677,
+393710,
+393741,
+393774,
+393813,
+393869,
+393902,
+393933,
+393966,
+393997,
+394030,
+394061,
+394094,
+394124,
+394157,
+394190,
+394261,
+394281,
+394565,
+394694,
+394764,
+394787,
+394965,
+395017,
+395107,
+395140,
+395185,
+395221,
+395293,
+395300,
+398077,
+398117,
+398196,
+398243,
+398308,
+398348,
+398372,
+401265,
+401283,
+401380,
+401437,
+401572,
+402973,
+402980,
+406013,
+406037,
+406090,
+406229,
+406532,
+407421,
+407573,
+408733,
+409092,
+409621,
+410621,
+410634,
+410965,
+411914,
+412181,
+412202,
+412693,
+413706,
+414037,
+415274,
+415765,
+425988,
+636637,
+636949,
+638980,
+1310237,
+1310724,
+1311395,
+1311428,
+1348029,
+1348117,
+1349885,
+1350148,
+1351427,
+1351633,
+1351684,
+1360259,
+1360305,
+1360388,
+1360904,
+1361220,
+1361309,
+1361920,
+1361953,
+1361984,
+1362017,
+1362048,
+1362081,
+1362112,
+1362145,
+1362176,
+1362209,
+1362240,
+1362273,
+1362304,
+1362337,
+1362368,
+1362401,
+1362432,
+1362465,
+1362496,
+1362529,
+1362560,
+1362593,
+1362624,
+1362657,
+1362688,
+1362721,
+1362752,
+1362785,
+1362816,
+1362849,
+1362880,
+1362913,
+1362944,
+1362977,
+1363008,
+1363041,
+1363072,
+1363105,
+1363136,
+1363169,
+1363200,
+1363233,
+1363264,
+1363297,
+1363328,
+1363361,
+1363396,
+1363429,
+1363463,
+1363569,
+1363589,
+1363921,
+1363939,
+1363968,
+1364001,
+1364032,
+1364065,
+1364096,
+1364129,
+1364160,
+1364193,
+1364224,
+1364257,
+1364288,
+1364321,
+1364352,
+1364385,
+1364416,
+1364449,
+1364480,
+1364513,
+1364544,
+1364577,
+1364608,
+1364641,
+1364672,
+1364705,
+1364736,
+1364769,
+1364800,
+1364833,
+1364867,
+1364933,
+1364996,
+1367241,
+1367557,
+1367633,
+1367837,
+1368084,
+1368803,
+1369108,
+1369152,
+1369185,
+1369216,
+1369249,
+1369280,
+1369313,
+1369344,
+1369377,
+1369408,
+1369441,
+1369472,
+1369505,
+1369536,
+1369569,
+1369664,
+1369697,
+1369728,
+1369761,
+1369792,
+1369825,
+1369856,
+1369889,
+1369920,
+1369953,
+1369984,
+1370017,
+1370048,
+1370081,
+1370112,
+1370145,
+1370176,
+1370209,
+1370240,
+1370273,
+1370304,
+1370337,
+1370368,
+1370401,
+1370432,
+1370465,
+1370496,
+1370529,
+1370560,
+1370593,
+1370624,
+1370657,
+1370688,
+1370721,
+1370752,
+1370785,
+1370816,
+1370849,
+1370880,
+1370913,
+1370944,
+1370977,
+1371008,
+1371041,
+1371072,
+1371105,
+1371136,
+1371169,
+1371200,
+1371233,
+1371264,
+1371297,
+1371328,
+1371361,
+1371392,
+1371425,
+1371456,
+1371489,
+1371520,
+1371553,
+1371584,
+1371617,
+1371651,
+1371681,
+1371936,
+1371969,
+1372000,
+1372033,
+1372064,
+1372129,
+1372160,
+1372193,
+1372224,
+1372257,
+1372288,
+1372321,
+1372352,
+1372385,
+1372419,
+1372468,
+1372512,
+1372545,
+1372576,
+1372609,
+1372644,
+1372672,
+1372705,
+1372736,
+1372769,
+1372864,
+1372897,
+1372928,
+1372961,
+1372992,
+1373025,
+1373056,
+1373089,
+1373120,
+1373153,
+1373184,
+1373217,
+1373248,
+1373281,
+1373312,
+1373345,
+1373376,
+1373409,
+1373440,
+1373473,
+1373504,
+1373665,
+1373696,
+1373857,
+1373888,
+1373921,
+1373952,
+1373985,
+1374016,
+1374049,
+1374080,
+1374113,
+1374144,
+1374177,
+1374237,
+1374272,
+1374305,
+1374336,
+1374461,
+1375972,
+1376003,
+1376065,
+1376100,
+1376325,
+1376356,
+1376453,
+1376484,
+1376613,
+1376644,
+1377382,
+1377445,
+1377510,
+1377557,
+1377693,
+1377802,
+1378005,
+1378067,
+1378101,
+1378141,
+1378308,
+1379985,
+1380125,
+1380358,
+1380420,
+1382022,
+1382533,
+1382621,
+1382865,
+1382920,
+1383261,
+1383429,
+1384004,
+1384209,
+1384292,
+1384337,
+1384356,
+1384421,
+1384456,
+1384772,
+1385669,
+1385937,
+1385988,
+1386725,
+1387078,
+1387165,
+1387505,
+1387524,
+1388477,
+1388549,
+1388646,
+1388676,
+1390181,
+1390214,
+1390277,
+1390406,
+1390469,
+1390534,
+1390641,
+1391069,
+1391075,
+1391112,
+1391453,
+1391569,
+1391620,
+1391781,
+1391811,
+1391844,
+1392136,
+1392452,
+1392637,
+1392644,
+1393957,
+1394150,
+1394213,
+1394278,
+1394341,
+1394429,
+1394692,
+1394789,
+1394820,
+1395077,
+1395110,
+1395165,
+1395208,
+1395549,
+1395601,
+1395716,
+1396227,
+1396260,
+1396469,
+1396548,
+1396582,
+1396613,
+1396646,
+1396676,
+1398277,
+1398308,
+1398341,
+1398436,
+1398501,
+1398564,
+1398725,
+1398788,
+1398821,
+1398852,
+1398909,
+1399652,
+1399715,
+1399761,
+1399812,
+1400166,
+1400197,
+1400262,
+1400337,
+1400388,
+1400419,
+1400486,
+1400517,
+1400573,
+1400868,
+1401085,
+1401124,
+1401341,
+1401380,
+1401597,
+1401860,
+1402109,
+1402116,
+1402365,
+1402369,
+1403764,
+1403779,
+1403905,
+1404189,
+1404417,
+1406980,
+1408102,
+1408165,
+1408198,
+1408261,
+1408294,
+1408369,
+1408390,
+1408421,
+1408477,
+1408520,
+1408861,
+1409028,
+1766557,
+1766916,
+1767677,
+1767780,
+1769373,
+1769499,
+1835036,
+2039812,
+2051549,
+2051588,
+2055005,
+2056193,
+2056445,
+2056801,
+2056989,
+2057124,
+2057157,
+2057188,
+2057522,
+2057540,
+2057981,
+2057988,
+2058173,
+2058180,
+2058237,
+2058244,
+2058333,
+2058340,
+2058429,
+2058436,
+2061908,
+2062429,
+2062948,
+2074574,
+2074605,
+2074653,
+2075140,
+2077213,
+2077252,
+2079005,
+2080260,
+2080659,
+2080693,
+2080733,
+2080773,
+2081297,
+2081517,
+2081550,
+2081585,
+2081629,
+2081797,
+2082321,
+2082348,
+2082411,
+2082477,
+2082510,
+2082541,
+2082574,
+2082605,
+2082638,
+2082669,
+2082702,
+2082733,
+2082766,
+2082797,
+2082830,
+2082861,
+2082894,
+2082925,
+2082958,
+2082993,
+2083053,
+2083086,
+2083121,
+2083243,
+2083345,
+2083453,
+2083473,
+2083596,
+2083629,
+2083662,
+2083693,
+2083726,
+2083757,
+2083790,
+2083825,
+2083922,
+2083948,
+2083986,
+2084093,
+2084113,
+2084147,
+2084177,
+2084253,
+2084356,
+2084541,
+2084548,
+2088893,
+2088954,
+2088989,
+2089009,
+2089107,
+2089137,
+2089229,
+2089262,
+2089297,
+2089330,
+2089361,
+2089388,
+2089425,
+2089480,
+2089809,
+2089874,
+2089969,
+2090016,
+2090861,
+2090897,
+2090926,
+2090964,
+2090987,
+2091028,
+2091041,
+2091885,
+2091922,
+2091950,
+2091986,
+2092013,
+2092046,
+2092081,
+2092109,
+2092142,
+2092177,
+2092228,
+2092547,
+2092580,
+2094019,
+2094084,
+2095101,
+2095172,
+2095389,
+2095428,
+2095645,
+2095684,
+2095901,
+2095940,
+2096061,
+2096147,
+2096210,
+2096244,
+2096277,
+2096307,
+2096381,
+2096405,
+2096434,
+2096565,
+2096637,
+2096954,
+2097045,
+2097117,
+2097156,
+2097565,
+2097572,
+2098429,
+2098436,
+2099069,
+2099076,
+2099165,
+2099172,
+2099677,
+2099716,
+2100189,
+2101252,
+2105213,
+2105361,
+2105469,
+2105578,
+2107037,
+2107125,
+2107401,
+2109098,
+2109237,
+2109770,
+2109845,
+2109949,
+2109973,
+2110365,
+2110485,
+2110525,
+2112021,
+2113445,
+2113501,
+2117636,
+2118589,
+2118660,
+2120253,
+2120709,
+2120746,
+2121629,
+2121732,
+2122762,
+2122909,
+2123172,
+2123817,
+2123844,
+2124105,
+2124157,
+2124292,
+2125509,
+2125693,
+2125828,
+2126813,
+2126833,
+2126852,
+2128029,
+2128132,
+2128401,
+2128425,
+2128605,
+2129920,
+2131201,
+2132484,
+2135005,
+2135048,
+2135389,
+2135552,
+2136733,
+2136833,
+2138013,
+2138116,
+2139421,
+2139652,
+2141341,
+2141681,
+2141725,
+2146308,
+2156285,
+2156548,
+2157277,
+2157572,
+2157853,
+2162692,
+2162909,
+2162948,
+2163005,
+2163012,
+2164445,
+2164452,
+2164541,
+2164612,
+2164669,
+2164708,
+2165469,
+2165489,
+2165514,
+2165764,
+2166517,
+2166570,
+2166788,
+2167805,
+2168042,
+2168349,
+2169860,
+2170493,
+2170500,
+2170589,
+2170730,
+2170884,
+2171594,
+2171805,
+2171889,
+2171908,
+2172765,
+2172913,
+2172957,
+2174980,
+2176797,
+2176906,
+2176964,
+2177034,
+2177565,
+2177610,
+2179076,
+2179109,
+2179229,
+2179237,
+2179325,
+2179461,
+2179588,
+2179741,
+2179748,
+2179869,
+2179876,
+2180829,
+2180869,
+2180989,
+2181093,
+2181130,
+2181437,
+2181649,
+2181949,
+2182148,
+2183082,
+2183153,
+2183172,
+2184106,
+2184221,
+2185220,
+2185493,
+2185508,
+2186405,
+2186493,
+2186602,
+2186769,
+2187005,
+2187268,
+2189021,
+2189105,
+2189316,
+2190045,
+2190090,
+2190340,
+2190973,
+2191114,
+2191364,
+2191965,
+2192177,
+2192317,
+2192682,
+2192925,
+2195460,
+2197821,
+2199552,
+2201213,
+2201601,
+2203261,
+2203466,
+2203652,
+2204805,
+2204957,
+2205192,
+2205533,
+2214922,
+2215933,
+2220036,
+2220970,
+2221284,
+2221341,
+2221572,
+2222277,
+2222634,
+2222769,
+2222941,
+2227204,
+2227965,
+2228230,
+2228261,
+2228294,
+2228324,
+2230021,
+2230513,
+2230749,
+2230858,
+2231496,
+2231837,
+2232293,
+2232390,
+2232420,
+2233862,
+2233957,
+2234086,
+2234149,
+2234225,
+2234298,
+2234321,
+2234461,
+2234810,
+2234845,
+2234884,
+2235709,
+2235912,
+2236253,
+2236421,
+2236516,
+2237669,
+2237830,
+2237861,
+2238141,
+2238152,
+2238481,
+2238596,
+2238630,
+2238717,
+2238980,
+2240101,
+2240145,
+2240196,
+2240253,
+2240517,
+2240582,
+2240612,
+2242150,
+2242245,
+2242534,
+2242596,
+2242737,
+2242853,
+2242993,
+2243037,
+2243080,
+2243396,
+2243441,
+2243460,
+2243505,
+2243613,
+2243626,
+2244285,
+2244612,
+2245213,
+2245220,
+2246022,
+2246117,
+2246214,
+2246277,
+2246310,
+2246341,
+2246417,
+2246597,
+2246653,
+2248708,
+2248957,
+2248964,
+2249021,
+2249028,
+2249181,
+2249188,
+2249693,
+2249700,
+2250033,
+2250077,
+2250244,
+2251749,
+2251782,
+2251877,
+2252157,
+2252296,
+2252637,
+2252805,
+2252870,
+2252957,
+2252964,
+2253245,
+2253284,
+2253373,
+2253412,
+2254141,
+2254148,
+2254397,
+2254404,
+2254493,
+2254500,
+2254685,
+2254693,
+2254756,
+2254790,
+2254853,
+2254886,
+2255037,
+2255078,
+2255165,
+2255206,
+2255325,
+2255364,
+2255421,
+2255590,
+2255645,
+2255780,
+2255942,
+2256029,
+2256069,
+2256317,
+2256389,
+2256573,
+2260996,
+2262694,
+2262789,
+2263046,
+2263109,
+2263206,
+2263237,
+2263268,
+2263409,
+2263560,
+2263901,
+2263921,
+2263965,
+2263985,
+2264005,
+2264036,
+2264093,
+2265092,
+2266630,
+2266725,
+2266918,
+2266949,
+2266982,
+2267109,
+2267174,
+2267205,
+2267268,
+2267345,
+2267364,
+2267421,
+2267656,
+2267997,
+2273284,
+2274790,
+2274885,
+2275037,
+2275078,
+2275205,
+2275270,
+2275301,
+2275377,
+2276100,
+2276229,
+2276317,
+2277380,
+2278918,
+2279013,
+2279270,
+2279333,
+2279366,
+2279397,
+2279473,
+2279556,
+2279613,
+2279944,
+2280285,
+2280465,
+2280893,
+2281476,
+2282853,
+2282886,
+2282917,
+2282950,
+2283013,
+2283206,
+2283237,
+2283268,
+2283325,
+2283528,
+2283869,
+2285572,
+2286461,
+2286501,
+2286598,
+2286661,
+2286790,
+2286821,
+2287005,
+2287112,
+2287434,
+2287505,
+2287605,
+2287645,
+2293764,
+2295174,
+2295269,
+2295558,
+2295589,
+2295665,
+2295709,
+2298880,
+2299905,
+2300936,
+2301258,
+2301565,
+2301924,
+2301981,
+2307076,
+2307357,
+2307396,
+2308646,
+2308741,
+2308893,
+2308933,
+2308998,
+2309125,
+2309156,
+2309201,
+2309220,
+2309254,
+2309309,
+2310148,
+2310181,
+2310500,
+2311781,
+2311974,
+2312004,
+2312037,
+2312177,
+2312421,
+2312477,
+2312708,
+2312741,
+2312934,
+2312997,
+2313092,
+2314565,
+2314982,
+2315013,
+2315089,
+2315172,
+2315217,
+2315389,
+2316292,
+2318141,
+2326532,
+2326845,
+2326852,
+2328038,
+2328069,
+2328317,
+2328325,
+2328518,
+2328549,
+2328580,
+2328625,
+2328797,
+2329096,
+2329418,
+2330045,
+2330129,
+2330180,
+2331165,
+2331205,
+2331933,
+2331942,
+2331973,
+2332198,
+2332229,
+2332294,
+2332325,
+2332413,
+2334724,
+2334973,
+2334980,
+2335069,
+2335076,
+2336293,
+2336509,
+2336581,
+2336637,
+2336645,
+2336733,
+2336741,
+2336964,
+2336997,
+2337053,
+2337288,
+2337629,
+2337796,
+2338013,
+2338020,
+2338109,
+2338116,
+2339142,
+2339325,
+2339333,
+2339421,
+2339430,
+2339493,
+2339526,
+2339557,
+2339588,
+2339645,
+2339848,
+2340189,
+2350084,
+2350693,
+2350758,
+2350833,
+2350909,
+2357258,
+2357941,
+2358195,
+2358325,
+2358877,
+2359281,
+2359300,
+2388829,
+2392073,
+2395645,
+2395665,
+2395837,
+2396164,
+2402461,
+2490372,
+2524669,
+2524698,
+2524989,
+2654212,
+2672893,
+2949124,
+2967357,
+2967556,
+2968573,
+2968584,
+2968925,
+2969041,
+2969117,
+2972164,
+2973149,
+2973189,
+2973361,
+2973405,
+2973700,
+2975237,
+2975473,
+2975637,
+2975747,
+2975889,
+2975925,
+2975965,
+2976264,
+2976605,
+2976618,
+2976861,
+2976868,
+2977565,
+2977700,
+2978333,
+3000320,
+3001345,
+3002378,
+3003121,
+3003261,
+3006468,
+3008893,
+3008997,
+3009028,
+3009062,
+3010845,
+3011045,
+3011171,
+3011613,
+3013635,
+3013713,
+3013731,
+3013789,
+3014660,
+3211037,
+3211268,
+3235453,
+3538948,
+3548157,
+3549700,
+3549821,
+3550340,
+3550493,
+3550724,
+3563421,
+3637252,
+3640701,
+3640836,
+3641277,
+3641348,
+3641661,
+3641860,
+3642205,
+3642261,
+3642277,
+3642353,
+3642394,
+3642525,
+3801109,
+3808989,
+3809301,
+3810557,
+3810613,
+3812518,
+3812581,
+3812693,
+3812774,
+3812986,
+3813221,
+3813493,
+3813541,
+3813781,
+3814725,
+3814869,
+3816765,
+3817493,
+3819589,
+3819701,
+3819741,
+3824650,
+3825309,
+3825685,
+3828477,
+3828746,
+3829565,
+3833856,
+3834689,
+3835520,
+3836353,
+3836605,
+3836609,
+3837184,
+3838017,
+3838848,
+3838909,
+3838912,
+3839005,
+3839040,
+3839101,
+3839136,
+3839229,
+3839264,
+3839421,
+3839424,
+3839681,
+3839837,
+3839841,
+3839901,
+3839905,
+3840157,
+3840161,
+3840512,
+3841345,
+3842176,
+3842269,
+3842272,
+3842429,
+3842464,
+3842749,
+3842752,
+3843005,
+3843009,
+3843840,
+3843933,
+3843936,
+3844093,
+3844096,
+3844285,
+3844288,
+3844349,
+3844416,
+3844669,
+3844673,
+3845504,
+3846337,
+3847168,
+3848001,
+3848832,
+3849665,
+3850496,
+3851329,
+3852160,
+3852993,
+3853824,
+3854657,
+3855581,
+3855616,
+3856434,
+3856449,
+3857266,
+3857281,
+3857472,
+3858290,
+3858305,
+3859122,
+3859137,
+3859328,
+3860146,
+3860161,
+3860978,
+3860993,
+3861184,
+3862002,
+3862017,
+3862834,
+3862849,
+3863040,
+3863858,
+3863873,
+3864690,
+3864705,
+3864896,
+3864929,
+3864989,
+3865032,
+3866645,
+3883013,
+3884789,
+3884901,
+3886517,
+3886757,
+3886805,
+3887237,
+3887285,
+3887345,
+3887517,
+3887973,
+3888157,
+3888165,
+3888669,
+3932165,
+3932413,
+3932421,
+3932989,
+3933029,
+3933277,
+3933285,
+3933373,
+3933381,
+3933565,
+3940356,
+3941821,
+3941893,
+3942115,
+3942365,
+3942408,
+3942749,
+3942852,
+3942901,
+3942941,
+3954692,
+3956101,
+3956232,
+3956573,
+3956723,
+3956765,
+3997700,
+4004029,
+4004074,
+4004357,
+4004605,
+4005888,
+4006977,
+4008069,
+4008291,
+4008349,
+4008456,
+4008797,
+4008913,
+4008989,
+4034090,
+4035989,
+4036010,
+4036115,
+4036138,
+4036285,
+4038698,
+4040149,
+4040170,
+4040669,
+4046852,
+4047005,
+4047012,
+4047901,
+4047908,
+4047997,
+4048004,
+4048061,
+4048100,
+4048157,
+4048164,
+4048509,
+4048516,
+4048669,
+4048676,
+4048733,
+4048740,
+4048797,
+4048964,
+4049021,
+4049124,
+4049181,
+4049188,
+4049245,
+4049252,
+4049309,
+4049316,
+4049437,
+4049444,
+4049533,
+4049540,
+4049597,
+4049636,
+4049693,
+4049700,
+4049757,
+4049764,
+4049821,
+4049828,
+4049885,
+4049892,
+4049949,
+4049956,
+4050045,
+4050052,
+4050109,
+4050148,
+4050301,
+4050308,
+4050557,
+4050564,
+4050717,
+4050724,
+4050877,
+4050884,
+4050941,
+4050948,
+4051293,
+4051300,
+4051869,
+4052004,
+4052125,
+4052132,
+4052317,
+4052324,
+4052893,
+4054546,
+4054621,
+4063253,
+4064669,
+4064789,
+4067997,
+4068373,
+4068861,
+4068917,
+4069405,
+4069429,
+4069917,
+4069941,
+4071133,
+4071434,
+4071869,
+4071957,
+4074941,
+4075029,
+4076989,
+4078805,
+4079741,
+4080149,
+4081565,
+4081685,
+4081981,
+4082197,
+4082269,
+4082709,
+4082909,
+4087829,
+4095860,
+4096021,
+4119261,
+4119573,
+4119997,
+4120085,
+4120445,
+4120597,
+4124317,
+4124693,
+4127549,
+4127765,
+4128157,
+4128789,
+4129181,
+4129301,
+4131101,
+4131349,
+4131677,
+4131861,
+4133149,
+4133397,
+4134365,
+4136981,
+4137373,
+4137397,
+4140637,
+4140661,
+4140797,
+4140885,
+4142205,
+4142261,
+4142461,
+4142549,
+4143485,
+4143541,
+4147869,
+4148245,
+4148701,
+4148757,
+4148893,
+4149013,
+4149117,
+4149269,
+4149373,
+4149781,
+4149981,
+4194308,
+5561085,
+5562372,
+5695165,
+5695492,
+5702621,
+5702660,
+5887069,
+5887492,
+6126653,
+6225924,
+6243293,
+29360186,
+29360221,
+29361178,
+29364253,
+29368325,
+29376029,
+31457308,
+33554397,
+33554460,
+35651549,
+35651613,
+//--Autogenerated -- end of section automatically generated
+};
+
+constexpr int maxUnicode = 0x10ffff;
+constexpr int maskCategory = 0x1F;
+
+}
+
+// Each element in catRanges is the start of a range of Unicode characters in
+// one general category.
+// The value is comprised of a 21-bit character value shifted 5 bits and a 5 bit
+// category matching the CharacterCategory enumeration.
+// Initial version has 3249 entries and adds about 13K to the executable.
+// The array is in ascending order so can be searched using binary search.
+// Therefore the average call takes log2(3249) = 12 comparisons.
+// For speed, it may be useful to make a linear table for the common values,
+// possibly for 0..0xff for most Western European text or 0..0xfff for most
+// alphabetic languages.
+
+CharacterCategory CategoriseCharacter(int character) {
+	if (character < 0 || character > maxUnicode)
+		return ccCn;
+	const int baseValue = character * (maskCategory+1) + maskCategory;
+	const int *placeAfter = std::lower_bound(catRanges, std::end(catRanges), baseValue);
+	return static_cast<CharacterCategory>(*(placeAfter-1) & maskCategory);
+}
+
+// Implementation of character sets recommended for identifiers in Unicode Standard Annex #31.
+// http://unicode.org/reports/tr31/
+
+namespace {
+
+enum class OtherID { oidNone, oidStart, oidContinue };
+
+// Some characters are treated as valid for identifiers even
+// though most characters from their category are not.
+// Values copied from http://www.unicode.org/Public/9.0.0/ucd/PropList.txt
+OtherID OtherIDOfCharacter(int character) noexcept {
+	if (
+		(character == 0x1885) ||	// MONGOLIAN LETTER ALI GALI BALUDA
+		(character == 0x1886) ||	// MONGOLIAN LETTER ALI GALI THREE BALUDA
+		(character == 0x2118) ||	// SCRIPT CAPITAL P
+		(character == 0x212E) ||	// ESTIMATED SYMBOL
+		(character == 0x309B) ||	// KATAKANA-HIRAGANA VOICED SOUND MARK
+		(character == 0x309C)) {	// KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+		return OtherID::oidStart;
+	} else if (
+		(character == 0x00B7) ||	// MIDDLE DOT
+		(character == 0x0387) ||	// GREEK ANO TELEIA
+		((character >= 0x1369) && (character <= 0x1371)) ||	// ETHIOPIC DIGIT ONE..ETHIOPIC DIGIT NINE
+		(character == 0x19DA)) {	// NEW TAI LUE THAM DIGIT ONE
+		return OtherID::oidContinue;
+	} else {
+		return OtherID::oidNone;
+	}
+}
+
+// Determine if a character is in  Ll|Lu|Lt|Lm|Lo|Nl|Mn|Mc|Nd|Pc and has
+// Pattern_Syntax|Pattern_White_Space.
+// As of Unicode 9, only VERTICAL TILDE which is in Lm and has Pattern_Syntax matches.
+// Should really generate from PropList.txt a list of Pattern_Syntax and Pattern_White_Space.
+constexpr bool IsIdPattern(int character) noexcept {
+	return character == 0x2E2F;
+}
+
+bool OmitXidStart(int character) noexcept {
+	switch (character) {
+	case 0x037A:	// GREEK YPOGEGRAMMENI
+	case 0x0E33:	// THAI CHARACTER SARA AM
+	case 0x0EB3:	// LAO VOWEL SIGN AM
+	case 0x309B:	// KATAKANA-HIRAGANA VOICED SOUND MARK
+	case 0x309C:	// KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+	case 0xFC5E:	// ARABIC LIGATURE SHADDA WITH DAMMATAN ISOLATED FORM
+	case 0xFC5F:	// ARABIC LIGATURE SHADDA WITH KASRATAN ISOLATED FORM
+	case 0xFC60:	// ARABIC LIGATURE SHADDA WITH FATHA ISOLATED FORM
+	case 0xFC61:	// ARABIC LIGATURE SHADDA WITH DAMMA ISOLATED FORM
+	case 0xFC62:	// ARABIC LIGATURE SHADDA WITH KASRA ISOLATED FORM
+	case 0xFC63:	// ARABIC LIGATURE SHADDA WITH SUPERSCRIPT ALEF ISOLATED FORM
+	case 0xFDFA:	// ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM
+	case 0xFDFB:	// ARABIC LIGATURE JALLAJALALOUHOU
+	case 0xFE70:	// ARABIC FATHATAN ISOLATED FORM
+	case 0xFE72:	// ARABIC DAMMATAN ISOLATED FORM
+	case 0xFE74:	// ARABIC KASRATAN ISOLATED FORM
+	case 0xFE76:	// ARABIC FATHA ISOLATED FORM
+	case 0xFE78:	// ARABIC DAMMA ISOLATED FORM
+	case 0xFE7A:	// ARABIC KASRA ISOLATED FORM
+	case 0xFE7C:	// ARABIC SHADDA ISOLATED FORM
+	case 0xFE7E:	// ARABIC SUKUN ISOLATED FORM
+	case 0xFF9E:	// HALFWIDTH KATAKANA VOICED SOUND MARK
+	case 0xFF9F:	// HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK
+		return true;
+	default:
+		return false;
+	}
+}
+
+bool OmitXidContinue(int character) noexcept {
+	switch (character) {
+	case 0x037A:	// GREEK YPOGEGRAMMENI
+	case 0x309B:	// KATAKANA-HIRAGANA VOICED SOUND MARK
+	case 0x309C:	// KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+	case 0xFC5E:	// ARABIC LIGATURE SHADDA WITH DAMMATAN ISOLATED FORM
+	case 0xFC5F:	// ARABIC LIGATURE SHADDA WITH KASRATAN ISOLATED FORM
+	case 0xFC60:	// ARABIC LIGATURE SHADDA WITH FATHA ISOLATED FORM
+	case 0xFC61:	// ARABIC LIGATURE SHADDA WITH DAMMA ISOLATED FORM
+	case 0xFC62:	// ARABIC LIGATURE SHADDA WITH KASRA ISOLATED FORM
+	case 0xFC63:	// ARABIC LIGATURE SHADDA WITH SUPERSCRIPT ALEF ISOLATED FORM
+	case 0xFDFA:	// ARABIC LIGATURE SALLALLAHOU ALAYHE WASALLAM
+	case 0xFDFB:	// ARABIC LIGATURE JALLAJALALOUHOU
+	case 0xFE70:	// ARABIC FATHATAN ISOLATED FORM
+	case 0xFE72:	// ARABIC DAMMATAN ISOLATED FORM
+	case 0xFE74:	// ARABIC KASRATAN ISOLATED FORM
+	case 0xFE76:	// ARABIC FATHA ISOLATED FORM
+	case 0xFE78:	// ARABIC DAMMA ISOLATED FORM
+	case 0xFE7A:	// ARABIC KASRA ISOLATED FORM
+	case 0xFE7C:	// ARABIC SHADDA ISOLATED FORM
+	case 0xFE7E:	// ARABIC SUKUN ISOLATED FORM
+		return true;
+	default:
+		return false;
+	}
+}
+
+}
+
+// UAX #31 defines ID_Start as
+// [[:L:][:Nl:][:Other_ID_Start:]--[:Pattern_Syntax:]--[:Pattern_White_Space:]]
+bool IsIdStart(int character) {
+	if (IsIdPattern(character)) {
+		return false;
+	}
+	const OtherID oid = OtherIDOfCharacter(character);
+	if (oid == OtherID::oidStart) {
+		return true;
+	}
+	const CharacterCategory c = CategoriseCharacter(character);
+	return (c == ccLl || c == ccLu || c == ccLt || c == ccLm || c == ccLo
+		|| c == ccNl);
+}
+
+// UAX #31 defines ID_Continue as
+// [[:ID_Start:][:Mn:][:Mc:][:Nd:][:Pc:][:Other_ID_Continue:]--[:Pattern_Syntax:]--[:Pattern_White_Space:]]
+bool IsIdContinue(int character) {
+	if (IsIdPattern(character)) {
+		return false;
+	}
+	const OtherID oid = OtherIDOfCharacter(character);
+	if (oid != OtherID::oidNone) {
+		return true;
+	}
+	const CharacterCategory c = CategoriseCharacter(character);
+	return (c == ccLl || c == ccLu || c == ccLt || c == ccLm || c == ccLo
+		|| c == ccNl || c == ccMn || c == ccMc || c == ccNd || c == ccPc);
+}
+
+// XID_Start is ID_Start modified for Normalization Form KC in UAX #31
+bool IsXidStart(int character) {
+	if (OmitXidStart(character)) {
+		return false;
+	} else {
+		return IsIdStart(character);
+	}
+}
+
+// XID_Continue is ID_Continue modified for Normalization Form KC in UAX #31
+bool IsXidContinue(int character) {
+	if (OmitXidContinue(character)) {
+		return false;
+	} else {
+		return IsIdContinue(character);
+	}
+}
+
+CharacterCategoryMap::CharacterCategoryMap() {
+	Optimize(256);
+}
+
+int CharacterCategoryMap::Size() const noexcept {
+	return static_cast<int>(dense.size());
+}
+
+void CharacterCategoryMap::Optimize(int countCharacters) {
+	const int characters = std::clamp(countCharacters, 256, maxUnicode + 1);
+	dense.resize(characters);
+
+	int end = 0;
+	int index = 0;
+	int current = catRanges[index];
+	++index;
+	do {
+		const int next = catRanges[index];
+		const unsigned char category = current & maskCategory;
+		current >>= 5;
+		end = std::min(characters, next >> 5);
+		while (current < end) {
+			dense[current++] = category;
+		}
+		current = next;
+		++index;
+	} while (characters > end);
+}
+
+}
diff --git a/Pythonwin/Scintilla/lexlib/CharacterCategory.h b/Pythonwin/Scintilla/lexlib/CharacterCategory.h
new file mode 100644
index 000000000..cd3320dd9
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/CharacterCategory.h
@@ -0,0 +1,50 @@
+// Scintilla source code edit control
+/** @file CharacterCategory.h
+ ** Returns the Unicode general category of a character.
+ **/
+// Copyright 2013 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef CHARACTERCATEGORY_H
+#define CHARACTERCATEGORY_H
+
+namespace Scintilla {
+
+enum CharacterCategory {
+	ccLu, ccLl, ccLt, ccLm, ccLo,
+	ccMn, ccMc, ccMe,
+	ccNd, ccNl, ccNo,
+	ccPc, ccPd, ccPs, ccPe, ccPi, ccPf, ccPo,
+	ccSm, ccSc, ccSk, ccSo,
+	ccZs, ccZl, ccZp,
+	ccCc, ccCf, ccCs, ccCo, ccCn
+};
+
+CharacterCategory CategoriseCharacter(int character);
+
+// Common definitions of allowable characters in identifiers from UAX #31.
+bool IsIdStart(int character);
+bool IsIdContinue(int character);
+bool IsXidStart(int character);
+bool IsXidContinue(int character);
+
+class CharacterCategoryMap {
+private:
+	std::vector<unsigned char> dense;
+public:
+	CharacterCategoryMap();
+	CharacterCategory CategoryFor(int character) const {
+		if (static_cast<size_t>(character) < dense.size()) {
+			return static_cast<CharacterCategory>(dense[character]);
+		} else {
+			// binary search through ranges
+			return CategoriseCharacter(character);
+		}
+	}
+	int Size() const noexcept;
+	void Optimize(int countCharacters);
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/CharacterSet.cxx b/Pythonwin/Scintilla/lexlib/CharacterSet.cxx
new file mode 100644
index 000000000..b934c2dd4
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/CharacterSet.cxx
@@ -0,0 +1,52 @@
+// Scintilla source code edit control
+/** @file CharacterSet.cxx
+ ** Simple case functions for ASCII.
+ ** Lexer infrastructure.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstdlib>
+#include <cassert>
+
+#include "CharacterSet.h"
+
+using namespace Scintilla;
+
+namespace Scintilla {
+
+int CompareCaseInsensitive(const char *a, const char *b) noexcept {
+	while (*a && *b) {
+		if (*a != *b) {
+			const char upperA = MakeUpperCase(*a);
+			const char upperB = MakeUpperCase(*b);
+			if (upperA != upperB)
+				return upperA - upperB;
+		}
+		a++;
+		b++;
+	}
+	// Either *a or *b is nul
+	return *a - *b;
+}
+
+int CompareNCaseInsensitive(const char *a, const char *b, size_t len) noexcept {
+	while (*a && *b && len) {
+		if (*a != *b) {
+			const char upperA = MakeUpperCase(*a);
+			const char upperB = MakeUpperCase(*b);
+			if (upperA != upperB)
+				return upperA - upperB;
+		}
+		a++;
+		b++;
+		len--;
+	}
+	if (len == 0)
+		return 0;
+	else
+		// Either *a or *b is nul
+		return *a - *b;
+}
+
+}
diff --git a/Pythonwin/Scintilla/lexlib/CharacterSet.h b/Pythonwin/Scintilla/lexlib/CharacterSet.h
new file mode 100644
index 000000000..a518c27fc
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/CharacterSet.h
@@ -0,0 +1,208 @@
+// Scintilla source code edit control
+/** @file CharacterSet.h
+ ** Encapsulates a set of characters. Used to test if a character is within a set.
+ **/
+// Copyright 2007 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef CHARACTERSET_H
+#define CHARACTERSET_H
+
+namespace Scintilla {
+
+class CharacterSet {
+	int size;
+	bool valueAfter;
+	bool *bset;
+public:
+	enum setBase {
+		setNone=0,
+		setLower=1,
+		setUpper=2,
+		setDigits=4,
+		setAlpha=setLower|setUpper,
+		setAlphaNum=setAlpha|setDigits
+	};
+	CharacterSet(setBase base=setNone, const char *initialSet="", int size_=0x80, bool valueAfter_=false) {
+		size = size_;
+		valueAfter = valueAfter_;
+		bset = new bool[size];
+		for (int i=0; i < size; i++) {
+			bset[i] = false;
+		}
+		AddString(initialSet);
+		if (base & setLower)
+			AddString("abcdefghijklmnopqrstuvwxyz");
+		if (base & setUpper)
+			AddString("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+		if (base & setDigits)
+			AddString("0123456789");
+	}
+	CharacterSet(const CharacterSet &other) {
+		size = other.size;
+		valueAfter = other.valueAfter;
+		bset = new bool[size];
+		for (int i=0; i < size; i++) {
+			bset[i] = other.bset[i];
+		}
+	}
+	CharacterSet(CharacterSet &&other) noexcept {
+		size = other.size;
+		valueAfter = other.valueAfter;
+		bset = other.bset;
+		other.size = 0;
+		other.bset = nullptr;
+	}
+	CharacterSet &operator=(const CharacterSet &other) {
+		if (this != &other) {
+			bool *bsetNew = new bool[other.size];
+			for (int i = 0; i < other.size; i++) {
+				bsetNew[i] = other.bset[i];
+			}
+			delete[]bset;
+			size = other.size;
+			valueAfter = other.valueAfter;
+			bset = bsetNew;
+		}
+		return *this;
+	}
+	CharacterSet &operator=(CharacterSet &&other) noexcept {
+		if (this != &other) {
+			delete []bset;
+			size = other.size;
+			valueAfter = other.valueAfter;
+			bset = other.bset;
+			other.size = 0;
+			other.bset = nullptr;
+		}
+		return *this;
+	}
+	~CharacterSet() {
+		delete []bset;
+		bset = nullptr;
+		size = 0;
+	}
+	void Add(int val) {
+		assert(val >= 0);
+		assert(val < size);
+		bset[val] = true;
+	}
+	void AddString(const char *setToAdd) {
+		for (const char *cp=setToAdd; *cp; cp++) {
+			const unsigned char uch = *cp;
+			assert(uch < size);
+			bset[uch] = true;
+		}
+	}
+	bool Contains(int val) const noexcept {
+		assert(val >= 0);
+		if (val < 0) return false;
+		return (val < size) ? bset[val] : valueAfter;
+	}
+	bool Contains(char ch) const noexcept {
+		// Overload char as char may be signed
+		const unsigned char uch = ch;
+		return Contains(uch);
+	}
+};
+
+// Functions for classifying characters
+
+constexpr bool IsASpace(int ch) noexcept {
+    return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d));
+}
+
+constexpr bool IsASpaceOrTab(int ch) noexcept {
+	return (ch == ' ') || (ch == '\t');
+}
+
+constexpr bool IsADigit(int ch) noexcept {
+	return (ch >= '0') && (ch <= '9');
+}
+
+constexpr bool IsADigit(int ch, int base) noexcept {
+	if (base <= 10) {
+		return (ch >= '0') && (ch < '0' + base);
+	} else {
+		return ((ch >= '0') && (ch <= '9')) ||
+		       ((ch >= 'A') && (ch < 'A' + base - 10)) ||
+		       ((ch >= 'a') && (ch < 'a' + base - 10));
+	}
+}
+
+constexpr bool IsASCII(int ch) noexcept {
+	return (ch >= 0) && (ch < 0x80);
+}
+
+constexpr bool IsLowerCase(int ch) noexcept {
+	return (ch >= 'a') && (ch <= 'z');
+}
+
+constexpr bool IsUpperCase(int ch) noexcept {
+	return (ch >= 'A') && (ch <= 'Z');
+}
+
+constexpr bool IsUpperOrLowerCase(int ch) noexcept {
+	return IsUpperCase(ch) || IsLowerCase(ch);
+}
+
+constexpr bool IsAlphaNumeric(int ch) noexcept {
+	return
+		((ch >= '0') && (ch <= '9')) ||
+		((ch >= 'a') && (ch <= 'z')) ||
+		((ch >= 'A') && (ch <= 'Z'));
+}
+
+/**
+ * Check if a character is a space.
+ * This is ASCII specific but is safe with chars >= 0x80.
+ */
+constexpr bool isspacechar(int ch) noexcept {
+    return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d));
+}
+
+constexpr bool iswordchar(int ch) noexcept {
+	return IsAlphaNumeric(ch) || ch == '.' || ch == '_';
+}
+
+constexpr bool iswordstart(int ch) noexcept {
+	return IsAlphaNumeric(ch) || ch == '_';
+}
+
+constexpr bool isoperator(int ch) noexcept {
+	if (IsAlphaNumeric(ch))
+		return false;
+	if (ch == '%' || ch == '^' || ch == '&' || ch == '*' ||
+	        ch == '(' || ch == ')' || ch == '-' || ch == '+' ||
+	        ch == '=' || ch == '|' || ch == '{' || ch == '}' ||
+	        ch == '[' || ch == ']' || ch == ':' || ch == ';' ||
+	        ch == '<' || ch == '>' || ch == ',' || ch == '/' ||
+	        ch == '?' || ch == '!' || ch == '.' || ch == '~')
+		return true;
+	return false;
+}
+
+// Simple case functions for ASCII supersets.
+
+template <typename T>
+constexpr T MakeUpperCase(T ch) noexcept {
+	if (ch < 'a' || ch > 'z')
+		return ch;
+	else
+		return ch - 'a' + 'A';
+}
+
+template <typename T>
+constexpr T MakeLowerCase(T ch) noexcept {
+	if (ch < 'A' || ch > 'Z')
+		return ch;
+	else
+		return ch - 'A' + 'a';
+}
+
+int CompareCaseInsensitive(const char *a, const char *b) noexcept;
+int CompareNCaseInsensitive(const char *a, const char *b, size_t len) noexcept;
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/DefaultLexer.cxx b/Pythonwin/Scintilla/lexlib/DefaultLexer.cxx
new file mode 100644
index 000000000..89671aa30
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/DefaultLexer.cxx
@@ -0,0 +1,139 @@
+// Scintilla source code edit control
+/** @file DefaultLexer.cxx
+ ** A lexer base class that provides reasonable default behaviour.
+ **/
+// Copyright 2017 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "LexerModule.h"
+#include "DefaultLexer.h"
+
+using namespace Scintilla;
+
+static const char styleSubable[] = { 0 };
+
+DefaultLexer::DefaultLexer(const char *languageName_, int language_,
+	const LexicalClass *lexClasses_, size_t nClasses_) :
+	languageName(languageName_),
+	language(language_),
+	lexClasses(lexClasses_),
+	nClasses(nClasses_) {
+}
+
+DefaultLexer::~DefaultLexer() {
+}
+
+void SCI_METHOD DefaultLexer::Release() {
+	delete this;
+}
+
+int SCI_METHOD DefaultLexer::Version() const {
+	return lvRelease5;
+}
+
+const char * SCI_METHOD DefaultLexer::PropertyNames() {
+	return "";
+}
+
+int SCI_METHOD DefaultLexer::PropertyType(const char *) {
+	return SC_TYPE_BOOLEAN;
+}
+
+const char * SCI_METHOD DefaultLexer::DescribeProperty(const char *) {
+	return "";
+}
+
+Sci_Position SCI_METHOD DefaultLexer::PropertySet(const char *, const char *) {
+	return -1;
+}
+
+const char * SCI_METHOD DefaultLexer::DescribeWordListSets() {
+	return "";
+}
+
+Sci_Position SCI_METHOD DefaultLexer::WordListSet(int, const char *) {
+	return -1;
+}
+
+void SCI_METHOD DefaultLexer::Fold(Sci_PositionU, Sci_Position, int, IDocument *) {
+}
+
+void * SCI_METHOD DefaultLexer::PrivateCall(int, void *) {
+	return nullptr;
+}
+
+int SCI_METHOD DefaultLexer::LineEndTypesSupported() {
+	return SC_LINE_END_TYPE_DEFAULT;
+}
+
+int SCI_METHOD DefaultLexer::AllocateSubStyles(int, int) {
+	return -1;
+}
+
+int SCI_METHOD DefaultLexer::SubStylesStart(int) {
+	return -1;
+}
+
+int SCI_METHOD DefaultLexer::SubStylesLength(int) {
+	return 0;
+}
+
+int SCI_METHOD DefaultLexer::StyleFromSubStyle(int subStyle) {
+	return subStyle;
+}
+
+int SCI_METHOD DefaultLexer::PrimaryStyleFromStyle(int style) {
+	return style;
+}
+
+void SCI_METHOD DefaultLexer::FreeSubStyles() {
+}
+
+void SCI_METHOD DefaultLexer::SetIdentifiers(int, const char *) {
+}
+
+int SCI_METHOD DefaultLexer::DistanceToSecondaryStyles() {
+	return 0;
+}
+
+const char * SCI_METHOD DefaultLexer::GetSubStyleBases() {
+	return styleSubable;
+}
+
+int SCI_METHOD DefaultLexer::NamedStyles() {
+	return static_cast<int>(nClasses);
+}
+
+const char * SCI_METHOD DefaultLexer::NameOfStyle(int style) {
+	return (style < NamedStyles()) ? lexClasses[style].name : "";
+}
+
+const char * SCI_METHOD DefaultLexer::TagsOfStyle(int style) {
+	return (style < NamedStyles()) ? lexClasses[style].tags : "";
+}
+
+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/Pythonwin/Scintilla/lexlib/DefaultLexer.h b/Pythonwin/Scintilla/lexlib/DefaultLexer.h
new file mode 100644
index 000000000..9139c4595
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/DefaultLexer.h
@@ -0,0 +1,57 @@
+// Scintilla source code edit control
+/** @file DefaultLexer.h
+ ** A lexer base class with default empty implementations of methods.
+ ** For lexers that do not support all features so do not need real implementations.
+ ** Does have real implementation for style metadata.
+ **/
+// Copyright 2017 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef DEFAULTLEXER_H
+#define DEFAULTLEXER_H
+
+namespace Scintilla {
+
+// A simple lexer with no state
+class DefaultLexer : public ILexer5 {
+	const char *languageName;
+	int language;
+	const LexicalClass *lexClasses;
+	size_t nClasses;
+public:
+	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;
+	const char * SCI_METHOD PropertyNames() override;
+	int SCI_METHOD PropertyType(const char *name) override;
+	const char * SCI_METHOD DescribeProperty(const char *name) override;
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char * SCI_METHOD DescribeWordListSets() override;
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl) override;
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) override = 0;
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) override;
+	void * SCI_METHOD PrivateCall(int operation, void *pointer) override;
+	int SCI_METHOD LineEndTypesSupported() override;
+	int SCI_METHOD AllocateSubStyles(int styleBase, int numberStyles) override;
+	int SCI_METHOD SubStylesStart(int styleBase) override;
+	int SCI_METHOD SubStylesLength(int styleBase) override;
+	int SCI_METHOD StyleFromSubStyle(int subStyle) override;
+	int SCI_METHOD PrimaryStyleFromStyle(int style) override;
+	void SCI_METHOD FreeSubStyles() override;
+	void SCI_METHOD SetIdentifiers(int style, const char *identifiers) override;
+	int SCI_METHOD DistanceToSecondaryStyles() override;
+	const char * SCI_METHOD GetSubStyleBases() override;
+	int SCI_METHOD NamedStyles() override;
+	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;
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/LexAccessor.h b/Pythonwin/Scintilla/lexlib/LexAccessor.h
new file mode 100644
index 000000000..658eb6e6d
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/LexAccessor.h
@@ -0,0 +1,195 @@
+// Scintilla source code edit control
+/** @file LexAccessor.h
+ ** Interfaces between Scintilla and lexers.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef LEXACCESSOR_H
+#define LEXACCESSOR_H
+
+namespace Scintilla {
+
+enum class EncodingType { eightBit, unicode, dbcs };
+
+class LexAccessor {
+private:
+	IDocument *pAccess;
+	enum {extremePosition=0x7FFFFFFF};
+	/** @a bufferSize is a trade off between time taken to copy the characters
+	 * and retrieval overhead.
+	 * @a slopSize positions the buffer before the desired position
+	 * in case there is some backtracking. */
+	enum {bufferSize=4000, slopSize=bufferSize/8};
+	char buf[bufferSize+1];
+	Sci_Position startPos;
+	Sci_Position endPos;
+	int codePage;
+	enum EncodingType encodingType;
+	Sci_Position lenDoc;
+	char styleBuf[bufferSize];
+	Sci_Position validLen;
+	Sci_PositionU startSeg;
+	Sci_Position startPosStyling;
+	int documentVersion;
+
+	void Fill(Sci_Position position) {
+		startPos = position - slopSize;
+		if (startPos + bufferSize > lenDoc)
+			startPos = lenDoc - bufferSize;
+		if (startPos < 0)
+			startPos = 0;
+		endPos = startPos + bufferSize;
+		if (endPos > lenDoc)
+			endPos = lenDoc;
+
+		pAccess->GetCharRange(buf, startPos, endPos-startPos);
+		buf[endPos-startPos] = '\0';
+	}
+
+public:
+	explicit LexAccessor(IDocument *pAccess_) :
+		pAccess(pAccess_), startPos(extremePosition), endPos(0),
+		codePage(pAccess->CodePage()),
+		encodingType(EncodingType::eightBit),
+		lenDoc(pAccess->Length()),
+		validLen(0),
+		startSeg(0), startPosStyling(0),
+		documentVersion(pAccess->Version()) {
+		// Prevent warnings by static analyzers about uninitialized buf and styleBuf.
+		buf[0] = 0;
+		styleBuf[0] = 0;
+		switch (codePage) {
+		case 65001:
+			encodingType = EncodingType::unicode;
+			break;
+		case 932:
+		case 936:
+		case 949:
+		case 950:
+		case 1361:
+			encodingType = EncodingType::dbcs;
+		}
+	}
+	char operator[](Sci_Position position) {
+		if (position < startPos || position >= endPos) {
+			Fill(position);
+		}
+		return buf[position - startPos];
+	}
+	IDocument *MultiByteAccess() const noexcept {
+		return pAccess;
+	}
+	/** Safe version of operator[], returning a defined value for invalid position. */
+	char SafeGetCharAt(Sci_Position position, char chDefault=' ') {
+		if (position < startPos || position >= endPos) {
+			Fill(position);
+			if (position < startPos || position >= endPos) {
+				// Position is outside range of document
+				return chDefault;
+			}
+		}
+		return buf[position - startPos];
+	}
+	bool IsLeadByte(char ch) const {
+		return pAccess->IsDBCSLeadByte(ch);
+	}
+	EncodingType Encoding() const noexcept {
+		return encodingType;
+	}
+	bool Match(Sci_Position pos, const char *s) {
+		for (int i=0; *s; i++) {
+			if (*s != SafeGetCharAt(pos+i))
+				return false;
+			s++;
+		}
+		return true;
+	}
+	char StyleAt(Sci_Position position) const {
+		return pAccess->StyleAt(position);
+	}
+	Sci_Position GetLine(Sci_Position position) const {
+		return pAccess->LineFromPosition(position);
+	}
+	Sci_Position LineStart(Sci_Position line) const {
+		return pAccess->LineStart(line);
+	}
+	Sci_Position LineEnd(Sci_Position line) const {
+		return pAccess->LineEnd(line);
+	}
+	int LevelAt(Sci_Position line) const {
+		return pAccess->GetLevel(line);
+	}
+	Sci_Position Length() const {
+		return lenDoc;
+	}
+	void Flush() {
+		if (validLen > 0) {
+			pAccess->SetStyles(validLen, styleBuf);
+			startPosStyling += validLen;
+			validLen = 0;
+		}
+	}
+	int GetLineState(Sci_Position line) const {
+		return pAccess->GetLineState(line);
+	}
+	int SetLineState(Sci_Position line, int state) {
+		return pAccess->SetLineState(line, state);
+	}
+	// Style setting
+	void StartAt(Sci_PositionU start) {
+		pAccess->StartStyling(start);
+		startPosStyling = start;
+	}
+	Sci_PositionU GetStartSegment() const {
+		return startSeg;
+	}
+	void StartSegment(Sci_PositionU pos) {
+		startSeg = pos;
+	}
+	void ColourTo(Sci_PositionU pos, int chAttr) {
+		// Only perform styling if non empty range
+		if (pos != startSeg - 1) {
+			assert(pos >= startSeg);
+			if (pos < startSeg) {
+				return;
+			}
+
+			if (validLen + (pos - startSeg + 1) >= bufferSize)
+				Flush();
+			const char attr = static_cast<char>(chAttr);
+			if (validLen + (pos - startSeg + 1) >= bufferSize) {
+				// Too big for buffer so send directly
+				pAccess->SetStyleFor(pos - startSeg + 1, attr);
+			} else {
+				for (Sci_PositionU i = startSeg; i <= pos; i++) {
+					assert((startPosStyling + validLen) < Length());
+					styleBuf[validLen++] = attr;
+				}
+			}
+		}
+		startSeg = pos+1;
+	}
+	void SetLevel(Sci_Position line, int level) {
+		pAccess->SetLevel(line, level);
+	}
+	void IndicatorFill(Sci_Position start, Sci_Position end, int indicator, int value) {
+		pAccess->DecorationSetCurrentIndicator(indicator);
+		pAccess->DecorationFillRange(start, value, end - start);
+	}
+
+	void ChangeLexerState(Sci_Position start, Sci_Position end) {
+		pAccess->ChangeLexerState(start, end);
+	}
+};
+
+struct LexicalClass {
+	int value;
+	const char *name;
+	const char *tags;
+	const char *description;
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/LexerBase.cxx b/Pythonwin/Scintilla/lexlib/LexerBase.cxx
new file mode 100644
index 000000000..bf195d824
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/LexerBase.cxx
@@ -0,0 +1,155 @@
+// Scintilla source code edit control
+/** @file LexerBase.cxx
+ ** A simple lexer with no state.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "LexerModule.h"
+#include "LexerBase.h"
+
+using namespace Scintilla;
+
+static const char styleSubable[] = { 0 };
+
+LexerBase::LexerBase(const LexicalClass *lexClasses_, size_t nClasses_) :
+	lexClasses(lexClasses_), nClasses(nClasses_) {
+	for (int wl = 0; wl < numWordLists; wl++)
+		keyWordLists[wl] = new WordList;
+	keyWordLists[numWordLists] = 0;
+}
+
+LexerBase::~LexerBase() {
+	for (int wl = 0; wl < numWordLists; wl++) {
+		delete keyWordLists[wl];
+		keyWordLists[wl] = 0;
+	}
+	keyWordLists[numWordLists] = 0;
+}
+
+void SCI_METHOD LexerBase::Release() {
+	delete this;
+}
+
+int SCI_METHOD LexerBase::Version() const {
+	return lvRelease5;
+}
+
+const char * SCI_METHOD LexerBase::PropertyNames() {
+	return "";
+}
+
+int SCI_METHOD LexerBase::PropertyType(const char *) {
+	return SC_TYPE_BOOLEAN;
+}
+
+const char * SCI_METHOD LexerBase::DescribeProperty(const char *) {
+	return "";
+}
+
+Sci_Position SCI_METHOD LexerBase::PropertySet(const char *key, const char *val) {
+	const char *valOld = props.Get(key);
+	if (strcmp(val, valOld) != 0) {
+		props.Set(key, val, strlen(key), strlen(val));
+		return 0;
+	} else {
+		return -1;
+	}
+}
+
+const char *SCI_METHOD LexerBase::PropertyGet(const char *key) {
+	return props.Get(key);
+}
+
+const char * SCI_METHOD LexerBase::DescribeWordListSets() {
+	return "";
+}
+
+Sci_Position SCI_METHOD LexerBase::WordListSet(int n, const char *wl) {
+	if (n < numWordLists) {
+		if (keyWordLists[n]->Set(wl)) {
+			return 0;
+		}
+	}
+	return -1;
+}
+
+void * SCI_METHOD LexerBase::PrivateCall(int, void *) {
+	return nullptr;
+}
+
+int SCI_METHOD LexerBase::LineEndTypesSupported() {
+	return SC_LINE_END_TYPE_DEFAULT;
+}
+
+int SCI_METHOD LexerBase::AllocateSubStyles(int, int) {
+	return -1;
+}
+
+int SCI_METHOD LexerBase::SubStylesStart(int) {
+	return -1;
+}
+
+int SCI_METHOD LexerBase::SubStylesLength(int) {
+	return 0;
+}
+
+int SCI_METHOD LexerBase::StyleFromSubStyle(int subStyle) {
+	return subStyle;
+}
+
+int SCI_METHOD LexerBase::PrimaryStyleFromStyle(int style) {
+	return style;
+}
+
+void SCI_METHOD LexerBase::FreeSubStyles() {
+}
+
+void SCI_METHOD LexerBase::SetIdentifiers(int, const char *) {
+}
+
+int SCI_METHOD LexerBase::DistanceToSecondaryStyles() {
+	return 0;
+}
+
+const char * SCI_METHOD LexerBase::GetSubStyleBases() {
+	return styleSubable;
+}
+
+int SCI_METHOD LexerBase::NamedStyles() {
+	return static_cast<int>(nClasses);
+}
+
+const char * SCI_METHOD LexerBase::NameOfStyle(int style) {
+	return (style < NamedStyles()) ? lexClasses[style].name : "";
+}
+
+const char * SCI_METHOD LexerBase::TagsOfStyle(int style) {
+	return (style < NamedStyles()) ? lexClasses[style].tags : "";
+}
+
+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/Pythonwin/Scintilla/lexlib/LexerBase.h b/Pythonwin/Scintilla/lexlib/LexerBase.h
new file mode 100644
index 000000000..22d17fea1
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/LexerBase.h
@@ -0,0 +1,57 @@
+// Scintilla source code edit control
+/** @file LexerBase.h
+ ** A simple lexer with no state.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef LEXERBASE_H
+#define LEXERBASE_H
+
+namespace Scintilla {
+
+// A simple lexer with no state
+class LexerBase : public ILexer5 {
+protected:
+	const LexicalClass *lexClasses;
+	size_t nClasses;
+	PropSetSimple props;
+	enum {numWordLists=KEYWORDSET_MAX+1};
+	WordList *keyWordLists[numWordLists+1];
+public:
+	LexerBase(const LexicalClass *lexClasses_=nullptr, size_t nClasses_=0);
+	virtual ~LexerBase();
+	void SCI_METHOD Release() override;
+	int SCI_METHOD Version() const override;
+	const char * SCI_METHOD PropertyNames() override;
+	int SCI_METHOD PropertyType(const char *name) override;
+	const char * SCI_METHOD DescribeProperty(const char *name) override;
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	const char * SCI_METHOD DescribeWordListSets() override;
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl) override;
+	void SCI_METHOD Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) override = 0;
+	void SCI_METHOD Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) override = 0;
+	void * SCI_METHOD PrivateCall(int operation, void *pointer) override;
+	int SCI_METHOD LineEndTypesSupported() override;
+	int SCI_METHOD AllocateSubStyles(int styleBase, int numberStyles) override;
+	int SCI_METHOD SubStylesStart(int styleBase) override;
+	int SCI_METHOD SubStylesLength(int styleBase) override;
+	int SCI_METHOD StyleFromSubStyle(int subStyle) override;
+	int SCI_METHOD PrimaryStyleFromStyle(int style) override;
+	void SCI_METHOD FreeSubStyles() override;
+	void SCI_METHOD SetIdentifiers(int style, const char *identifiers) override;
+	int SCI_METHOD DistanceToSecondaryStyles() override;
+	const char * SCI_METHOD GetSubStyleBases() override;
+	int SCI_METHOD NamedStyles() override;
+	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;
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/LexerModule.cxx b/Pythonwin/Scintilla/lexlib/LexerModule.cxx
new file mode 100644
index 000000000..0f1498bf2
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/LexerModule.cxx
@@ -0,0 +1,123 @@
+// Scintilla source code edit control
+/** @file LexerModule.cxx
+ ** Colourise for particular languages.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstdlib>
+#include <cassert>
+
+#include <string>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "LexerModule.h"
+#include "LexerBase.h"
+#include "LexerSimple.h"
+
+using namespace Scintilla;
+
+LexerModule::LexerModule(int language_,
+	LexerFunction fnLexer_,
+	const char *languageName_,
+	LexerFunction fnFolder_,
+	const char *const wordListDescriptions_[],
+	const LexicalClass *lexClasses_,
+	size_t nClasses_) noexcept :
+	language(language_),
+	fnLexer(fnLexer_),
+	fnFolder(fnFolder_),
+	fnFactory(nullptr),
+	wordListDescriptions(wordListDescriptions_),
+	lexClasses(lexClasses_),
+	nClasses(nClasses_),
+	languageName(languageName_) {
+}
+
+LexerModule::LexerModule(int language_,
+	LexerFactoryFunction fnFactory_,
+	const char *languageName_,
+	const char * const wordListDescriptions_[]) noexcept :
+	language(language_),
+	fnLexer(nullptr),
+	fnFolder(nullptr),
+	fnFactory(fnFactory_),
+	wordListDescriptions(wordListDescriptions_),
+	lexClasses(nullptr),
+	nClasses(0),
+	languageName(languageName_) {
+}
+
+int LexerModule::GetLanguage() const noexcept {
+	return language;
+}
+
+int LexerModule::GetNumWordLists() const noexcept {
+	if (!wordListDescriptions) {
+		return -1;
+	} else {
+		int numWordLists = 0;
+
+		while (wordListDescriptions[numWordLists]) {
+			++numWordLists;
+		}
+
+		return numWordLists;
+	}
+}
+
+const char *LexerModule::GetWordListDescription(int index) const noexcept {
+	assert(index < GetNumWordLists());
+	if (!wordListDescriptions || (index >= GetNumWordLists())) {
+		return "";
+	} else {
+		return wordListDescriptions[index];
+	}
+}
+
+const LexicalClass *LexerModule::LexClasses() const noexcept {
+	return lexClasses;
+}
+
+size_t LexerModule::NamedStyles() const noexcept {
+	return nClasses;
+}
+
+ILexer5 *LexerModule::Create() const {
+	if (fnFactory)
+		return fnFactory();
+	else
+		return new LexerSimple(this);
+}
+
+void LexerModule::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle,
+	  WordList *keywordlists[], Accessor &styler) const {
+	if (fnLexer)
+		fnLexer(startPos, lengthDoc, initStyle, keywordlists, styler);
+}
+
+void LexerModule::Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle,
+	  WordList *keywordlists[], Accessor &styler) const {
+	if (fnFolder) {
+		Sci_Position lineCurrent = styler.GetLine(startPos);
+		// Move back one line in case deletion wrecked current line fold state
+		if (lineCurrent > 0) {
+			lineCurrent--;
+			const Sci_Position newStartPos = styler.LineStart(lineCurrent);
+			lengthDoc += startPos - newStartPos;
+			startPos = newStartPos;
+			initStyle = 0;
+			if (startPos > 0) {
+				initStyle = styler.StyleAt(startPos - 1);
+			}
+		}
+		fnFolder(startPos, lengthDoc, initStyle, keywordlists, styler);
+	}
+}
diff --git a/Pythonwin/Scintilla/lexlib/LexerModule.h b/Pythonwin/Scintilla/lexlib/LexerModule.h
new file mode 100644
index 000000000..83bdf237d
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/LexerModule.h
@@ -0,0 +1,92 @@
+// Scintilla source code edit control
+/** @file LexerModule.h
+ ** Colourise for particular languages.
+ **/
+// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef LEXERMODULE_H
+#define LEXERMODULE_H
+
+namespace Scintilla {
+
+class Accessor;
+class WordList;
+struct LexicalClass;
+
+typedef void (*LexerFunction)(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle,
+                  WordList *keywordlists[], Accessor &styler);
+typedef ILexer5 *(*LexerFactoryFunction)();
+
+/**
+ * A LexerModule is responsible for lexing and folding a particular language.
+ * The Catalogue class maintains a list of LexerModules which can be searched to find a
+ * module appropriate to a particular language.
+ * The ExternalLexerModule subclass holds lexers loaded from DLLs or shared libraries.
+ */
+class LexerModule {
+protected:
+	int language;
+	LexerFunction fnLexer;
+	LexerFunction fnFolder;
+	LexerFactoryFunction fnFactory;
+	const char * const * wordListDescriptions;
+	const LexicalClass *lexClasses;
+	size_t nClasses;
+
+public:
+	const char *languageName;
+	LexerModule(
+		int language_,
+		LexerFunction fnLexer_,
+		const char *languageName_=nullptr,
+		LexerFunction fnFolder_= nullptr,
+		const char * const wordListDescriptions_[]=nullptr,
+		const LexicalClass *lexClasses_=nullptr,
+		size_t nClasses_=0) noexcept;
+	LexerModule(
+		int language_,
+		LexerFactoryFunction fnFactory_,
+		const char *languageName_,
+		const char * const wordListDescriptions_[]=nullptr) noexcept;
+	int GetLanguage() const noexcept;
+
+	// -1 is returned if no WordList information is available
+	int GetNumWordLists() const noexcept;
+	const char *GetWordListDescription(int index) const noexcept;
+	const LexicalClass *LexClasses() const noexcept;
+	size_t NamedStyles() const noexcept;
+
+	ILexer5 *Create() const;
+
+	void Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle,
+                  WordList *keywordlists[], Accessor &styler) const;
+	void Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle,
+                  WordList *keywordlists[], Accessor &styler) const;
+
+	friend class CatalogueModules;
+};
+
+inline int Maximum(int a, int b) noexcept {
+	return (a > b) ? a : b;
+}
+
+// Shut up annoying Visual C++ warnings:
+#ifdef _MSC_VER
+#pragma warning(disable: 4244 4456 4457)
+#endif
+
+// Turn off shadow warnings for lexers as may be maintained by others
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
+// Clang doesn't like omitting braces in array initialization but they just add
+// noise to LexicalClass arrays in lexers
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wmissing-braces"
+#endif
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/LexerNoExceptions.cxx b/Pythonwin/Scintilla/lexlib/LexerNoExceptions.cxx
new file mode 100644
index 000000000..3627e188a
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/LexerNoExceptions.cxx
@@ -0,0 +1,62 @@
+// Scintilla source code edit control
+/** @file LexerNoExceptions.cxx
+ ** A simple lexer with no state which does not throw exceptions so can be used in an external lexer.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstdlib>
+#include <cassert>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "LexerModule.h"
+#include "LexerBase.h"
+#include "LexerNoExceptions.h"
+
+using namespace Scintilla;
+
+Sci_Position SCI_METHOD LexerNoExceptions::PropertySet(const char *key, const char *val) {
+	try {
+		return LexerBase::PropertySet(key, val);
+	} catch (...) {
+		// Should not throw into caller as may be compiled with different compiler or options
+	}
+	return -1;
+}
+
+Sci_Position SCI_METHOD LexerNoExceptions::WordListSet(int n, const char *wl) {
+	try {
+		return LexerBase::WordListSet(n, wl);
+	} catch (...) {
+		// Should not throw into caller as may be compiled with different compiler or options
+	}
+	return -1;
+}
+
+void SCI_METHOD LexerNoExceptions::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) {
+	try {
+		Accessor astyler(pAccess, &props);
+		Lexer(startPos, lengthDoc, initStyle, pAccess, astyler);
+		astyler.Flush();
+	} catch (...) {
+		// Should not throw into caller as may be compiled with different compiler or options
+		pAccess->SetErrorStatus(SC_STATUS_FAILURE);
+	}
+}
+void SCI_METHOD LexerNoExceptions::Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) {
+	try {
+		Accessor astyler(pAccess, &props);
+		Folder(startPos, lengthDoc, initStyle, pAccess, astyler);
+		astyler.Flush();
+	} catch (...) {
+		// Should not throw into caller as may be compiled with different compiler or options
+		pAccess->SetErrorStatus(SC_STATUS_FAILURE);
+	}
+}
diff --git a/Pythonwin/Scintilla/lexlib/LexerNoExceptions.h b/Pythonwin/Scintilla/lexlib/LexerNoExceptions.h
new file mode 100644
index 000000000..5bcb090f0
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/LexerNoExceptions.h
@@ -0,0 +1,28 @@
+// Scintilla source code edit control
+/** @file LexerNoExceptions.h
+ ** A simple lexer with no state.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef LEXERNOEXCEPTIONS_H
+#define LEXERNOEXCEPTIONS_H
+
+namespace Scintilla {
+
+// A simple lexer with no state
+class LexerNoExceptions : public LexerBase {
+public:
+	// TODO Also need to prevent exceptions in constructor and destructor
+	Sci_Position SCI_METHOD PropertySet(const char *key, const char *val) override;
+	Sci_Position SCI_METHOD WordListSet(int n, const char *wl) 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 *) override;
+
+	virtual void Lexer(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess, Accessor &styler) = 0;
+	virtual void Folder(Sci_PositionU startPos, Sci_Position length, int initStyle, IDocument *pAccess, Accessor &styler) = 0;
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/LexerSimple.cxx b/Pythonwin/Scintilla/lexlib/LexerSimple.cxx
new file mode 100644
index 000000000..e69c44ad6
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/LexerSimple.cxx
@@ -0,0 +1,61 @@
+// Scintilla source code edit control
+/** @file LexerSimple.cxx
+ ** A simple lexer with no state.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstdlib>
+#include <cassert>
+
+#include <string>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "PropSetSimple.h"
+#include "WordList.h"
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "LexerModule.h"
+#include "LexerBase.h"
+#include "LexerSimple.h"
+
+using namespace Scintilla;
+
+LexerSimple::LexerSimple(const LexerModule *module_) :
+	LexerBase(module_->LexClasses(), module_->NamedStyles()),
+	module(module_) {
+	for (int wl = 0; wl < module->GetNumWordLists(); wl++) {
+		if (!wordLists.empty())
+			wordLists += "\n";
+		wordLists += module->GetWordListDescription(wl);
+	}
+}
+
+const char * SCI_METHOD LexerSimple::DescribeWordListSets() {
+	return wordLists.c_str();
+}
+
+void SCI_METHOD LexerSimple::Lex(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) {
+	Accessor astyler(pAccess, &props);
+	module->Lex(startPos, lengthDoc, initStyle, keyWordLists, astyler);
+	astyler.Flush();
+}
+
+void SCI_METHOD LexerSimple::Fold(Sci_PositionU startPos, Sci_Position lengthDoc, int initStyle, IDocument *pAccess) {
+	if (props.GetInt("fold")) {
+		Accessor astyler(pAccess, &props);
+		module->Fold(startPos, lengthDoc, initStyle, keyWordLists, astyler);
+		astyler.Flush();
+	}
+}
+
+const char * SCI_METHOD LexerSimple::GetName() {
+	return module->languageName;
+}
+
+int SCI_METHOD LexerSimple::GetIdentifier() {
+	return module->GetLanguage();
+}
diff --git a/Pythonwin/Scintilla/lexlib/LexerSimple.h b/Pythonwin/Scintilla/lexlib/LexerSimple.h
new file mode 100644
index 000000000..ae4177769
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/LexerSimple.h
@@ -0,0 +1,29 @@
+// Scintilla source code edit control
+/** @file LexerSimple.h
+ ** A simple lexer with no state.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef LEXERSIMPLE_H
+#define LEXERSIMPLE_H
+
+namespace Scintilla {
+
+// A simple lexer with no state
+class LexerSimple : public LexerBase {
+	const LexerModule *module;
+	std::string wordLists;
+public:
+	explicit LexerSimple(const LexerModule *module_);
+	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;
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/OptionSet.h b/Pythonwin/Scintilla/lexlib/OptionSet.h
new file mode 100644
index 000000000..3c282e49b
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/OptionSet.h
@@ -0,0 +1,149 @@
+// Scintilla source code edit control
+/** @file OptionSet.h
+ ** Manage descriptive information about an options struct for a lexer.
+ ** Hold the names, positions, and descriptions of boolean, integer and string options and
+ ** allow setting options and retrieving metadata about the options.
+ **/
+// Copyright 2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef OPTIONSET_H
+#define OPTIONSET_H
+
+namespace Scintilla {
+
+template <typename T>
+class OptionSet {
+	typedef T Target;
+	typedef bool T::*plcob;
+	typedef int T::*plcoi;
+	typedef std::string T::*plcos;
+	struct Option {
+		int opType;
+		union {
+			plcob pb;
+			plcoi pi;
+			plcos ps;
+		};
+		std::string value;
+		std::string description;
+		Option() :
+			opType(SC_TYPE_BOOLEAN), pb(0), description("") {
+		}
+		Option(plcob pb_, std::string description_="") :
+			opType(SC_TYPE_BOOLEAN), pb(pb_), description(description_) {
+		}
+		Option(plcoi pi_, std::string description_) :
+			opType(SC_TYPE_INTEGER), pi(pi_), description(description_) {
+		}
+		Option(plcos ps_, std::string description_) :
+			opType(SC_TYPE_STRING), ps(ps_), description(description_) {
+		}
+		bool Set(T *base, const char *val) {
+			value = val;
+			switch (opType) {
+			case SC_TYPE_BOOLEAN: {
+					bool option = atoi(val) != 0;
+					if ((*base).*pb != option) {
+						(*base).*pb = option;
+						return true;
+					}
+					break;
+				}
+			case SC_TYPE_INTEGER: {
+					int option = atoi(val);
+					if ((*base).*pi != option) {
+						(*base).*pi = option;
+						return true;
+					}
+					break;
+				}
+			case SC_TYPE_STRING: {
+					if ((*base).*ps != val) {
+						(*base).*ps = val;
+						return true;
+					}
+					break;
+				}
+			}
+			return false;
+		}
+		const char *Get() const noexcept {
+			return value.c_str();
+		}
+	};
+	typedef std::map<std::string, Option> OptionMap;
+	OptionMap nameToDef;
+	std::string names;
+	std::string wordLists;
+
+	void AppendName(const char *name) {
+		if (!names.empty())
+			names += "\n";
+		names += name;
+	}
+public:
+	void DefineProperty(const char *name, plcob pb, std::string description="") {
+		nameToDef[name] = Option(pb, description);
+		AppendName(name);
+	}
+	void DefineProperty(const char *name, plcoi pi, std::string description="") {
+		nameToDef[name] = Option(pi, description);
+		AppendName(name);
+	}
+	void DefineProperty(const char *name, plcos ps, std::string description="") {
+		nameToDef[name] = Option(ps, description);
+		AppendName(name);
+	}
+	const char *PropertyNames() const noexcept {
+		return names.c_str();
+	}
+	int PropertyType(const char *name) {
+		typename OptionMap::iterator it = nameToDef.find(name);
+		if (it != nameToDef.end()) {
+			return it->second.opType;
+		}
+		return SC_TYPE_BOOLEAN;
+	}
+	const char *DescribeProperty(const char *name) {
+		typename OptionMap::iterator it = nameToDef.find(name);
+		if (it != nameToDef.end()) {
+			return it->second.description.c_str();
+		}
+		return "";
+	}
+
+	bool PropertySet(T *base, const char *name, const char *val) {
+		typename OptionMap::iterator it = nameToDef.find(name);
+		if (it != nameToDef.end()) {
+			return it->second.Set(base, val);
+		}
+		return false;
+	}
+
+	const char *PropertyGet(const char *name) {
+		typename OptionMap::iterator it = nameToDef.find(name);
+		if (it != nameToDef.end()) {
+			return it->second.Get();
+		}
+		return nullptr;
+	}
+
+	void DefineWordListSets(const char * const wordListDescriptions[]) {
+		if (wordListDescriptions) {
+			for (size_t wl = 0; wordListDescriptions[wl]; wl++) {
+				if (!wordLists.empty())
+					wordLists += "\n";
+				wordLists += wordListDescriptions[wl];
+			}
+		}
+	}
+
+	const char *DescribeWordListSets() const noexcept {
+		return wordLists.c_str();
+	}
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/PropSetSimple.cxx b/Pythonwin/Scintilla/lexlib/PropSetSimple.cxx
new file mode 100644
index 000000000..6ee57d667
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/PropSetSimple.cxx
@@ -0,0 +1,157 @@
+// Scintilla source code edit control
+/** @file PropSetSimple.cxx
+ ** A basic string to string map.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+// Maintain a dictionary of properties
+
+#include <cstdlib>
+#include <cstring>
+
+#include <string>
+#include <map>
+
+#include "PropSetSimple.h"
+
+using namespace Scintilla;
+
+namespace {
+
+typedef std::map<std::string, std::string> mapss;
+
+mapss *PropsFromPointer(void *impl) noexcept {
+	return static_cast<mapss *>(impl);
+}
+
+constexpr bool IsASpaceCharacter(int ch) noexcept {
+	return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d));
+}
+
+}
+
+PropSetSimple::PropSetSimple() {
+	mapss *props = new mapss;
+	impl = static_cast<void *>(props);
+}
+
+PropSetSimple::~PropSetSimple() {
+	mapss *props = PropsFromPointer(impl);
+	delete props;
+	impl = nullptr;
+}
+
+void PropSetSimple::Set(const char *key, const char *val, size_t lenKey, size_t lenVal) {
+	mapss *props = PropsFromPointer(impl);
+	if (!*key)	// Empty keys are not supported
+		return;
+	(*props)[std::string(key, lenKey)] = std::string(val, lenVal);
+}
+
+void PropSetSimple::Set(const char *keyVal) {
+	while (IsASpaceCharacter(*keyVal))
+		keyVal++;
+	const char *endVal = keyVal;
+	while (*endVal && (*endVal != '\n'))
+		endVal++;
+	const char *eqAt = strchr(keyVal, '=');
+	if (eqAt) {
+		Set(keyVal, eqAt + 1, eqAt-keyVal,
+			endVal - eqAt - 1);
+	} else if (*keyVal) {	// No '=' so assume '=1'
+		Set(keyVal, "1", endVal-keyVal, 1);
+	}
+}
+
+void PropSetSimple::SetMultiple(const char *s) {
+	const char *eol = strchr(s, '\n');
+	while (eol) {
+		Set(s);
+		s = eol + 1;
+		eol = strchr(s, '\n');
+	}
+	Set(s);
+}
+
+const char *PropSetSimple::Get(const char *key) const {
+	mapss *props = PropsFromPointer(impl);
+	mapss::const_iterator keyPos = props->find(std::string(key));
+	if (keyPos != props->end()) {
+		return keyPos->second.c_str();
+	} else {
+		return "";
+	}
+}
+
+// There is some inconsistency between GetExpanded("foo") and Expand("$(foo)").
+// A solution is to keep a stack of variables that have been expanded, so that
+// recursive expansions can be skipped.  For now I'll just use the C++ stack
+// for that, through a recursive function and a simple chain of pointers.
+
+struct VarChain {
+	VarChain(const char *var_=nullptr, const VarChain *link_= nullptr) noexcept : var(var_), link(link_) {}
+
+	bool contains(const char *testVar) const {
+		return (var && (0 == strcmp(var, testVar)))
+			|| (link && link->contains(testVar));
+	}
+
+	const char *var;
+	const VarChain *link;
+};
+
+static int ExpandAllInPlace(const PropSetSimple &props, std::string &withVars, int maxExpands, const VarChain &blankVars) {
+	size_t varStart = withVars.find("$(");
+	while ((varStart != std::string::npos) && (maxExpands > 0)) {
+		const size_t varEnd = withVars.find(')', varStart+2);
+		if (varEnd == std::string::npos) {
+			break;
+		}
+
+		// For consistency, when we see '$(ab$(cde))', expand the inner variable first,
+		// regardless whether there is actually a degenerate variable named 'ab$(cde'.
+		size_t innerVarStart = withVars.find("$(", varStart+2);
+		while ((innerVarStart != std::string::npos) && (innerVarStart > varStart) && (innerVarStart < varEnd)) {
+			varStart = innerVarStart;
+			innerVarStart = withVars.find("$(", varStart+2);
+		}
+
+		std::string var(withVars, varStart + 2, varEnd - varStart - 2);
+		std::string val = props.Get(var.c_str());
+
+		if (blankVars.contains(var.c_str())) {
+			val = ""; // treat blankVar as an empty string (e.g. to block self-reference)
+		}
+
+		if (--maxExpands >= 0) {
+			maxExpands = ExpandAllInPlace(props, val, maxExpands, VarChain(var.c_str(), &blankVars));
+		}
+
+		withVars.erase(varStart, varEnd-varStart+1);
+		withVars.insert(varStart, val.c_str(), val.length());
+
+		varStart = withVars.find("$(");
+	}
+
+	return maxExpands;
+}
+
+size_t PropSetSimple::GetExpanded(const char *key, char *result) const {
+	std::string val = Get(key);
+	ExpandAllInPlace(*this, val, 100, VarChain(key));
+	const size_t n = val.size();
+	if (result) {
+		memcpy(result, val.c_str(), n+1);
+	}
+	return n;	// Not including NUL
+}
+
+int PropSetSimple::GetInt(const char *key, int defaultValue) const {
+	std::string val = Get(key);
+	ExpandAllInPlace(*this, val, 100, VarChain(key));
+	if (!val.empty()) {
+		return atoi(val.c_str());
+	}
+	return defaultValue;
+}
diff --git a/Pythonwin/Scintilla/lexlib/PropSetSimple.h b/Pythonwin/Scintilla/lexlib/PropSetSimple.h
new file mode 100644
index 000000000..d4a5b2243
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/PropSetSimple.h
@@ -0,0 +1,28 @@
+// Scintilla source code edit control
+/** @file PropSetSimple.h
+ ** A basic string to string map.
+ **/
+// Copyright 1998-2009 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef PROPSETSIMPLE_H
+#define PROPSETSIMPLE_H
+
+namespace Scintilla {
+
+class PropSetSimple {
+	void *impl;
+	void Set(const char *keyVal);
+public:
+	PropSetSimple();
+	virtual ~PropSetSimple();
+	void Set(const char *key, const char *val, size_t lenKey, size_t lenVal);
+	void SetMultiple(const char *);
+	const char *Get(const char *key) const;
+	size_t GetExpanded(const char *key, char *result) const;
+	int GetInt(const char *key, int defaultValue=0) const;
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/SparseState.h b/Pythonwin/Scintilla/lexlib/SparseState.h
new file mode 100644
index 000000000..6286c76af
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/SparseState.h
@@ -0,0 +1,106 @@
+// Scintilla source code edit control
+/** @file SparseState.h
+ ** Hold lexer state that may change rarely.
+ ** This is often per-line state such as whether a particular type of section has been entered.
+ ** A state continues until it is changed.
+ **/
+// Copyright 2011 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef SPARSESTATE_H
+#define SPARSESTATE_H
+
+namespace Scintilla {
+
+template <typename T>
+class SparseState {
+	struct State {
+		Sci_Position position;
+		T value;
+		constexpr State(Sci_Position position_, T value_) noexcept : position(position_), value(value_) {
+		}
+		inline bool operator<(const State &other) const noexcept {
+			return position < other.position;
+		}
+		inline bool operator==(const State &other) const noexcept {
+			return (position == other.position) && (value == other.value);
+		}
+	};
+	Sci_Position positionFirst;
+	typedef std::vector<State> stateVector;
+	stateVector states;
+
+	typename stateVector::iterator Find(Sci_Position position) {
+		const State searchValue(position, T());
+		return std::lower_bound(states.begin(), states.end(), searchValue);
+	}
+
+public:
+	explicit SparseState(Sci_Position positionFirst_=-1) {
+		positionFirst = positionFirst_;
+	}
+	void Set(Sci_Position position, T value) {
+		Delete(position);
+		if (states.empty() || (value != states[states.size()-1].value)) {
+			states.push_back(State(position, value));
+		}
+	}
+	T ValueAt(Sci_Position position) {
+		if (states.empty())
+			return T();
+		if (position < states[0].position)
+			return T();
+		typename stateVector::iterator low = Find(position);
+		if (low == states.end()) {
+			return states[states.size()-1].value;
+		} else {
+			if (low->position > position) {
+				--low;
+			}
+			return low->value;
+		}
+	}
+	bool Delete(Sci_Position position) {
+		typename stateVector::iterator low = Find(position);
+		if (low != states.end()) {
+			states.erase(low, states.end());
+			return true;
+		}
+		return false;
+	}
+	size_t size() const {
+		return states.size();
+	}
+
+	// Returns true if Merge caused a significant change
+	bool Merge(const SparseState<T> &other, Sci_Position ignoreAfter) {
+		// Changes caused beyond ignoreAfter are not significant
+		Delete(ignoreAfter+1);
+
+		bool different = true;
+		bool changed = false;
+		typename stateVector::iterator low = Find(other.positionFirst);
+		if (static_cast<size_t>(states.end() - low) == other.states.size()) {
+			// Same number in other as after positionFirst in this
+			different = !std::equal(low, states.end(), other.states.begin());
+		}
+		if (different) {
+			if (low != states.end()) {
+				states.erase(low, states.end());
+				changed = true;
+			}
+			typename stateVector::const_iterator startOther = other.states.begin();
+			if (!states.empty() && !other.states.empty() && states.back().value == startOther->value)
+				++startOther;
+			if (startOther != other.states.end()) {
+				states.insert(states.end(), startOther, other.states.end());
+				changed = true;
+			}
+		}
+		return changed;
+	}
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/StringCopy.h b/Pythonwin/Scintilla/lexlib/StringCopy.h
new file mode 100644
index 000000000..1c5442e65
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/StringCopy.h
@@ -0,0 +1,32 @@
+// Scintilla source code edit control
+/** @file StringCopy.h
+ ** Safe string copy function which always NUL terminates.
+ ** ELEMENTS macro for determining array sizes.
+ **/
+// Copyright 2013 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef STRINGCOPY_H
+#define STRINGCOPY_H
+
+namespace Scintilla {
+
+// Safer version of string copy functions like strcpy, wcsncpy, etc.
+// Instantiate over fixed length strings of both char and wchar_t.
+// May truncate if source doesn't fit into dest with room for NUL.
+
+template <typename T, size_t count>
+void StringCopy(T (&dest)[count], const T* source) {
+	for (size_t i=0; i<count; i++) {
+		dest[i] = source[i];
+		if (!source[i])
+			break;
+	}
+	dest[count-1] = 0;
+}
+
+#define ELEMENTS(a) (sizeof(a) / sizeof(a[0]))
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/StyleContext.cxx b/Pythonwin/Scintilla/lexlib/StyleContext.cxx
new file mode 100644
index 000000000..fe56e53d7
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/StyleContext.cxx
@@ -0,0 +1,68 @@
+// Scintilla source code edit control
+/** @file StyleContext.cxx
+ ** Lexer infrastructure.
+ **/
+// Copyright 1998-2004 by Neil Hodgson <neilh@scintilla.org>
+// This file is in the public domain.
+
+#include <cstdlib>
+#include <cassert>
+
+#include "ILexer.h"
+
+#include "LexAccessor.h"
+#include "Accessor.h"
+#include "StyleContext.h"
+#include "CharacterSet.h"
+
+using namespace Scintilla;
+
+bool StyleContext::MatchIgnoreCase(const char *s) {
+	if (MakeLowerCase(ch) != static_cast<unsigned char>(*s))
+		return false;
+	s++;
+	if (MakeLowerCase(chNext) != static_cast<unsigned char>(*s))
+		return false;
+	s++;
+	for (int n = 2; *s; n++) {
+		if (*s !=
+			MakeLowerCase(styler.SafeGetCharAt(currentPos + n, 0)))
+			return false;
+		s++;
+	}
+	return true;
+}
+
+static void getRange(Sci_PositionU start,
+		Sci_PositionU end,
+		LexAccessor &styler,
+		char *s,
+		Sci_PositionU len) {
+	Sci_PositionU i = 0;
+	while ((i < end - start + 1) && (i < len-1)) {
+		s[i] = styler[start + i];
+		i++;
+	}
+	s[i] = '\0';
+}
+
+void StyleContext::GetCurrent(char *s, Sci_PositionU len) {
+	getRange(styler.GetStartSegment(), currentPos - 1, styler, s, len);
+}
+
+static void getRangeLowered(Sci_PositionU start,
+		Sci_PositionU end,
+		LexAccessor &styler,
+		char *s,
+		Sci_PositionU len) {
+	Sci_PositionU i = 0;
+	while ((i < end - start + 1) && (i < len-1)) {
+		s[i] = MakeLowerCase(styler[start + i]);
+		i++;
+	}
+	s[i] = '\0';
+}
+
+void StyleContext::GetCurrentLowered(char *s, Sci_PositionU len) {
+	getRangeLowered(styler.GetStartSegment(), currentPos - 1, styler, s, len);
+}
diff --git a/Pythonwin/Scintilla/lexlib/StyleContext.h b/Pythonwin/Scintilla/lexlib/StyleContext.h
new file mode 100644
index 000000000..c9ff4efbb
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/StyleContext.h
@@ -0,0 +1,212 @@
+// Scintilla source code edit control
+/** @file StyleContext.h
+ ** Lexer infrastructure.
+ **/
+// Copyright 1998-2004 by Neil Hodgson <neilh@scintilla.org>
+// This file is in the public domain.
+
+#ifndef STYLECONTEXT_H
+#define STYLECONTEXT_H
+
+namespace Scintilla {
+
+// All languages handled so far can treat all characters >= 0x80 as one class
+// which just continues the current token or starts an identifier if in default.
+// DBCS treated specially as the second character can be < 0x80 and hence
+// syntactically significant. UTF-8 avoids this as all trail bytes are >= 0x80
+class StyleContext {
+	LexAccessor &styler;
+	IDocument *multiByteAccess;
+	Sci_PositionU endPos;
+	Sci_PositionU lengthDocument;
+
+	// Used for optimizing GetRelativeCharacter
+	Sci_PositionU posRelative;
+	Sci_PositionU currentPosLastRelative;
+	Sci_Position offsetRelative;
+
+	void GetNextChar() {
+		if (multiByteAccess) {
+			chNext = multiByteAccess->GetCharacterAndWidth(currentPos+width, &widthNext);
+		} else {
+			chNext = static_cast<unsigned char>(styler.SafeGetCharAt(currentPos+width, 0));
+			widthNext = 1;
+		}
+		// End of line determined from line end position, allowing CR, LF,
+		// CRLF and Unicode line ends as set by document.
+		if (currentLine < lineDocEnd)
+			atLineEnd = static_cast<Sci_Position>(currentPos) >= (lineStartNext-1);
+		else // Last line
+			atLineEnd = static_cast<Sci_Position>(currentPos) >= lineStartNext;
+	}
+
+public:
+	Sci_PositionU currentPos;
+	Sci_Position currentLine;
+	Sci_Position lineDocEnd;
+	Sci_Position lineStartNext;
+	bool atLineStart;
+	bool atLineEnd;
+	int state;
+	int chPrev;
+	int ch;
+	Sci_Position width;
+	int chNext;
+	Sci_Position widthNext;
+
+	StyleContext(Sci_PositionU startPos, Sci_PositionU length,
+                        int initStyle, LexAccessor &styler_, char chMask='\377') :
+		styler(styler_),
+		multiByteAccess(nullptr),
+		endPos(startPos + length),
+		posRelative(0),
+		currentPosLastRelative(0x7FFFFFFF),
+		offsetRelative(0),
+		currentPos(startPos),
+		currentLine(-1),
+		lineStartNext(-1),
+		atLineEnd(false),
+		state(initStyle & chMask), // Mask off all bits which aren't in the chMask.
+		chPrev(0),
+		ch(0),
+		width(0),
+		chNext(0),
+		widthNext(1) {
+		if (styler.Encoding() != EncodingType::eightBit) {
+			multiByteAccess = styler.MultiByteAccess();
+		}
+		styler.StartAt(startPos /*, chMask*/);
+		styler.StartSegment(startPos);
+		currentLine = styler.GetLine(startPos);
+		lineStartNext = styler.LineStart(currentLine+1);
+		lengthDocument = static_cast<Sci_PositionU>(styler.Length());
+		if (endPos == lengthDocument)
+			endPos++;
+		lineDocEnd = styler.GetLine(lengthDocument);
+		atLineStart = static_cast<Sci_PositionU>(styler.LineStart(currentLine)) == startPos;
+
+		// Variable width is now 0 so GetNextChar gets the char at currentPos into chNext/widthNext
+		width = 0;
+		GetNextChar();
+		ch = chNext;
+		width = widthNext;
+
+		GetNextChar();
+	}
+	// Deleted so StyleContext objects can not be copied.
+	StyleContext(const StyleContext &) = delete;
+	StyleContext &operator=(const StyleContext &) = delete;
+	void Complete() {
+		styler.ColourTo(currentPos - ((currentPos > lengthDocument) ? 2 : 1), state);
+		styler.Flush();
+	}
+	bool More() const noexcept {
+		return currentPos < endPos;
+	}
+	void Forward() {
+		if (currentPos < endPos) {
+			atLineStart = atLineEnd;
+			if (atLineStart) {
+				currentLine++;
+				lineStartNext = styler.LineStart(currentLine+1);
+			}
+			chPrev = ch;
+			currentPos += width;
+			ch = chNext;
+			width = widthNext;
+			GetNextChar();
+		} else {
+			atLineStart = false;
+			chPrev = ' ';
+			ch = ' ';
+			chNext = ' ';
+			atLineEnd = true;
+		}
+	}
+	void Forward(Sci_Position nb) {
+		for (Sci_Position i = 0; i < nb; i++) {
+			Forward();
+		}
+	}
+	void ForwardBytes(Sci_Position nb) {
+		const Sci_PositionU forwardPos = currentPos + nb;
+		while (forwardPos > currentPos) {
+			const Sci_PositionU currentPosStart = currentPos;
+			Forward();
+			if (currentPos == currentPosStart) {
+				// Reached end
+				return;
+			}
+		}
+	}
+	void ChangeState(int state_) noexcept {
+		state = state_;
+	}
+	void SetState(int state_) {
+		styler.ColourTo(currentPos - ((currentPos > lengthDocument) ? 2 : 1), state);
+		state = state_;
+	}
+	void ForwardSetState(int state_) {
+		Forward();
+		styler.ColourTo(currentPos - ((currentPos > lengthDocument) ? 2 : 1), state);
+		state = state_;
+	}
+	Sci_Position LengthCurrent() const {
+		return currentPos - styler.GetStartSegment();
+	}
+	int GetRelative(Sci_Position n, char chDefault='\0') {
+		return static_cast<unsigned char>(styler.SafeGetCharAt(currentPos+n, chDefault));
+	}
+	int GetRelativeCharacter(Sci_Position n) {
+		if (n == 0)
+			return ch;
+		if (multiByteAccess) {
+			if ((currentPosLastRelative != currentPos) ||
+				((n > 0) && ((offsetRelative < 0) || (n < offsetRelative))) ||
+				((n < 0) && ((offsetRelative > 0) || (n > offsetRelative)))) {
+				posRelative = currentPos;
+				offsetRelative = 0;
+			}
+			const Sci_Position diffRelative = n - offsetRelative;
+			const Sci_Position posNew = multiByteAccess->GetRelativePosition(posRelative, diffRelative);
+			const int chReturn = multiByteAccess->GetCharacterAndWidth(posNew, nullptr);
+			posRelative = posNew;
+			currentPosLastRelative = currentPos;
+			offsetRelative = n;
+			return chReturn;
+		} else {
+			// fast version for single byte encodings
+			return static_cast<unsigned char>(styler.SafeGetCharAt(currentPos + n, 0));
+		}
+	}
+	bool Match(char ch0) const {
+		return ch == static_cast<unsigned char>(ch0);
+	}
+	bool Match(char ch0, char ch1) const {
+		return (ch == static_cast<unsigned char>(ch0)) && (chNext == static_cast<unsigned char>(ch1));
+	}
+	bool Match(const char *s) {
+		if (ch != static_cast<unsigned char>(*s))
+			return false;
+		s++;
+		if (!*s)
+			return true;
+		if (chNext != static_cast<unsigned char>(*s))
+			return false;
+		s++;
+		for (int n=2; *s; n++) {
+			if (*s != styler.SafeGetCharAt(currentPos+n, 0))
+				return false;
+			s++;
+		}
+		return true;
+	}
+	// Non-inline
+	bool MatchIgnoreCase(const char *s);
+	void GetCurrent(char *s, Sci_PositionU len);
+	void GetCurrentLowered(char *s, Sci_PositionU len);
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/SubStyles.h b/Pythonwin/Scintilla/lexlib/SubStyles.h
new file mode 100644
index 000000000..4bfe7ebfc
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/SubStyles.h
@@ -0,0 +1,208 @@
+// Scintilla source code edit control
+/** @file SubStyles.h
+ ** Manage substyles for a lexer.
+ **/
+// Copyright 2012 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef SUBSTYLES_H
+#define SUBSTYLES_H
+
+namespace Scintilla {
+
+class WordClassifier {
+	int baseStyle;
+	int firstStyle;
+	int lenStyles;
+	std::map<std::string, int> wordToStyle;
+
+public:
+
+	explicit WordClassifier(int baseStyle_) : baseStyle(baseStyle_), firstStyle(0), lenStyles(0) {
+	}
+
+	void Allocate(int firstStyle_, int lenStyles_) {
+		firstStyle = firstStyle_;
+		lenStyles = lenStyles_;
+		wordToStyle.clear();
+	}
+
+	int Base() const noexcept {
+		return baseStyle;
+	}
+
+	int Start() const noexcept {
+		return firstStyle;
+	}
+
+	int Last() const noexcept {
+		return firstStyle + lenStyles - 1;
+	}
+
+	int Length() const noexcept {
+		return lenStyles;
+	}
+
+	void Clear() noexcept {
+		firstStyle = 0;
+		lenStyles = 0;
+		wordToStyle.clear();
+	}
+
+	int ValueFor(const std::string &s) const {
+		std::map<std::string, int>::const_iterator it = wordToStyle.find(s);
+		if (it != wordToStyle.end())
+			return it->second;
+		else
+			return -1;
+	}
+
+	bool IncludesStyle(int style) const noexcept {
+		return (style >= firstStyle) && (style < (firstStyle + lenStyles));
+	}
+
+	void RemoveStyle(int style) {
+		std::map<std::string, int>::iterator it = wordToStyle.begin();
+		while (it != wordToStyle.end()) {
+			if (it->second == style) {
+				it = wordToStyle.erase(it);
+			} else {
+				++it;
+			}
+		}
+	}
+
+	void SetIdentifiers(int style, const char *identifiers) {
+		RemoveStyle(style);
+		while (*identifiers) {
+			const char *cpSpace = identifiers;
+			while (*cpSpace && !(*cpSpace == ' ' || *cpSpace == '\t' || *cpSpace == '\r' || *cpSpace == '\n'))
+				cpSpace++;
+			if (cpSpace > identifiers) {
+				std::string word(identifiers, cpSpace - identifiers);
+				wordToStyle[word] = style;
+			}
+			identifiers = cpSpace;
+			if (*identifiers)
+				identifiers++;
+		}
+	}
+};
+
+class SubStyles {
+	int classifications;
+	const char *baseStyles;
+	int styleFirst;
+	int stylesAvailable;
+	int secondaryDistance;
+	int allocated;
+	std::vector<WordClassifier> classifiers;
+
+	int BlockFromBaseStyle(int baseStyle) const noexcept {
+		for (int b=0; b < classifications; b++) {
+			if (baseStyle == baseStyles[b])
+				return b;
+		}
+		return -1;
+	}
+
+	int BlockFromStyle(int style) const {
+		int b = 0;
+		for (std::vector<WordClassifier>::const_iterator it=classifiers.begin(); it != classifiers.end(); ++it) {
+			if (it->IncludesStyle(style))
+				return b;
+			b++;
+		}
+		return -1;
+	}
+
+public:
+
+	SubStyles(const char *baseStyles_, int styleFirst_, int stylesAvailable_, int secondaryDistance_) :
+		classifications(0),
+		baseStyles(baseStyles_),
+		styleFirst(styleFirst_),
+		stylesAvailable(stylesAvailable_),
+		secondaryDistance(secondaryDistance_),
+		allocated(0) {
+		while (baseStyles[classifications]) {
+			classifiers.push_back(WordClassifier(baseStyles[classifications]));
+			classifications++;
+		}
+	}
+
+	int Allocate(int styleBase, int numberStyles) {
+		const int block = BlockFromBaseStyle(styleBase);
+		if (block >= 0) {
+			if ((allocated + numberStyles) > stylesAvailable)
+				return -1;
+			const int startBlock = styleFirst + allocated;
+			allocated += numberStyles;
+			classifiers[block].Allocate(startBlock, numberStyles);
+			return startBlock;
+		} else {
+			return -1;
+		}
+	}
+
+	int Start(int styleBase) noexcept {
+		const int block = BlockFromBaseStyle(styleBase);
+		return (block >= 0) ? classifiers[block].Start() : -1;
+	}
+
+	int Length(int styleBase) noexcept {
+		const int block = BlockFromBaseStyle(styleBase);
+		return (block >= 0) ? classifiers[block].Length() : 0;
+	}
+
+	int BaseStyle(int subStyle) const {
+		const int block = BlockFromStyle(subStyle);
+		if (block >= 0)
+			return classifiers[block].Base();
+		else
+			return subStyle;
+	}
+
+	int DistanceToSecondaryStyles() const noexcept {
+		return secondaryDistance;
+	}
+
+	int FirstAllocated() const {
+		int start = 257;
+		for (std::vector<WordClassifier>::const_iterator it = classifiers.begin(); it != classifiers.end(); ++it) {
+			if (start > it->Start())
+				start = it->Start();
+		}
+		return (start < 256) ? start : -1;
+	}
+
+	int LastAllocated() const {
+		int last = -1;
+		for (std::vector<WordClassifier>::const_iterator it = classifiers.begin(); it != classifiers.end(); ++it) {
+			if (last < it->Last())
+				last = it->Last();
+		}
+		return last;
+	}
+
+	void SetIdentifiers(int style, const char *identifiers) {
+		const int block = BlockFromStyle(style);
+		if (block >= 0)
+			classifiers[block].SetIdentifiers(style, identifiers);
+	}
+
+	void Free() {
+		allocated = 0;
+		for (std::vector<WordClassifier>::iterator it=classifiers.begin(); it != classifiers.end(); ++it)
+			it->Clear();
+	}
+
+	const WordClassifier &Classifier(int baseStyle) const noexcept {
+		const int block = BlockFromBaseStyle(baseStyle);
+		return classifiers[block >= 0 ? block : 0];
+	}
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/lexlib/WordList.cxx b/Pythonwin/Scintilla/lexlib/WordList.cxx
new file mode 100644
index 000000000..460995daa
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/WordList.cxx
@@ -0,0 +1,315 @@
+// Scintilla source code edit control
+/** @file WordList.cxx
+ ** Hold a list of words.
+ **/
+// Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+
+#include <algorithm>
+#include <iterator>
+
+#include "WordList.h"
+
+using namespace Scintilla;
+
+/**
+ * Creates an array that points into each word in the string and puts \0 terminators
+ * after each word.
+ */
+static char **ArrayFromWordList(char *wordlist, size_t slen, int *len, bool onlyLineEnds = false) {
+	int prev = '\n';
+	int words = 0;
+	// For rapid determination of whether a character is a separator, build
+	// a look up table.
+	bool wordSeparator[256] = {};	// Initialise all to false.
+	wordSeparator[static_cast<unsigned int>('\r')] = true;
+	wordSeparator[static_cast<unsigned int>('\n')] = true;
+	if (!onlyLineEnds) {
+		wordSeparator[static_cast<unsigned int>(' ')] = true;
+		wordSeparator[static_cast<unsigned int>('\t')] = true;
+	}
+	for (int j = 0; wordlist[j]; j++) {
+		const int curr = static_cast<unsigned char>(wordlist[j]);
+		if (!wordSeparator[curr] && wordSeparator[prev])
+			words++;
+		prev = curr;
+	}
+	char **keywords = new char *[words + 1];
+	int wordsStore = 0;
+	if (words) {
+		prev = '\0';
+		for (size_t k = 0; k < slen; k++) {
+			if (!wordSeparator[static_cast<unsigned char>(wordlist[k])]) {
+				if (!prev) {
+					keywords[wordsStore] = &wordlist[k];
+					wordsStore++;
+				}
+			} else {
+				wordlist[k] = '\0';
+			}
+			prev = wordlist[k];
+		}
+	}
+	assert(wordsStore < (words + 1));
+	keywords[wordsStore] = &wordlist[slen];
+	*len = wordsStore;
+	return keywords;
+}
+
+WordList::WordList(bool onlyLineEnds_) :
+	words(0), list(0), len(0), onlyLineEnds(onlyLineEnds_) {
+	// Prevent warnings by static analyzers about uninitialized starts.
+	starts[0] = -1;
+}
+
+WordList::~WordList() {
+	Clear();
+}
+
+WordList::operator bool() const noexcept {
+	return len ? true : false;
+}
+
+bool WordList::operator!=(const WordList &other) const noexcept {
+	if (len != other.len)
+		return true;
+	for (int i=0; i<len; i++) {
+		if (strcmp(words[i], other.words[i]) != 0)
+			return true;
+	}
+	return false;
+}
+
+int WordList::Length() const noexcept {
+	return len;
+}
+
+void WordList::Clear() noexcept {
+	if (words) {
+		delete []list;
+		delete []words;
+	}
+	words = nullptr;
+	list = nullptr;
+	len = 0;
+}
+
+#ifdef _MSC_VER
+
+static bool cmpWords(const char *a, const char *b) {
+	return strcmp(a, b) < 0;
+}
+
+#else
+
+static int cmpWords(const void *a, const void *b) {
+	return strcmp(*static_cast<const char * const *>(a), *static_cast<const char * const *>(b));
+}
+
+static void SortWordList(char **words, unsigned int len) {
+	qsort(words, len, sizeof(*words), cmpWords);
+}
+
+#endif
+
+bool WordList::Set(const char *s) {
+	const size_t lenS = strlen(s) + 1;
+	char *listTemp = new char[lenS];
+	memcpy(listTemp, s, lenS);
+	int lenTemp = 0;
+	char **wordsTemp = ArrayFromWordList(listTemp, lenS - 1, &lenTemp, onlyLineEnds);
+#ifdef _MSC_VER
+	std::sort(wordsTemp, wordsTemp + lenTemp, cmpWords);
+#else
+	SortWordList(wordsTemp, lenTemp);
+#endif
+
+	if (lenTemp == len) {
+		bool changed = false;
+		for (int i = 0; i < lenTemp; i++) {
+			if (strcmp(words[i], wordsTemp[i]) != 0) {
+				changed = true;
+				break;
+			}
+		}
+		if (!changed) {
+			delete []listTemp;
+			delete []wordsTemp;
+			return false;
+		}
+	}
+
+	Clear();
+	words = wordsTemp;
+	list = listTemp;
+	len = lenTemp;
+	std::fill(starts, std::end(starts), -1);
+	for (int l = len - 1; l >= 0; l--) {
+		unsigned char indexChar = words[l][0];
+		starts[indexChar] = l;
+	}
+	return true;
+}
+
+/** Check whether a string is in the list.
+ * List elements are either exact matches or prefixes.
+ * Prefix elements start with '^' and match all strings that start with the rest of the element
+ * so '^GTK_' matches 'GTK_X', 'GTK_MAJOR_VERSION', and 'GTK_'.
+ */
+bool WordList::InList(const char *s) const noexcept {
+	if (0 == words)
+		return false;
+	const unsigned char firstChar = s[0];
+	int j = starts[firstChar];
+	if (j >= 0) {
+		while (words[j][0] == firstChar) {
+			if (s[1] == words[j][1]) {
+				const char *a = words[j] + 1;
+				const char *b = s + 1;
+				while (*a && *a == *b) {
+					a++;
+					b++;
+				}
+				if (!*a && !*b)
+					return true;
+			}
+			j++;
+		}
+	}
+	j = starts[static_cast<unsigned int>('^')];
+	if (j >= 0) {
+		while (words[j][0] == '^') {
+			const char *a = words[j] + 1;
+			const char *b = s;
+			while (*a && *a == *b) {
+				a++;
+				b++;
+			}
+			if (!*a)
+				return true;
+			j++;
+		}
+	}
+	return false;
+}
+
+/** similar to InList, but word s can be a substring of keyword.
+ * eg. the keyword define is defined as def~ine. This means the word must start
+ * with def to be a keyword, but also defi, defin and define are valid.
+ * The marker is ~ in this case.
+ */
+bool WordList::InListAbbreviated(const char *s, const char marker) const noexcept {
+	if (0 == words)
+		return false;
+	const unsigned char firstChar = s[0];
+	int j = starts[firstChar];
+	if (j >= 0) {
+		while (words[j][0] == firstChar) {
+			bool isSubword = false;
+			int start = 1;
+			if (words[j][1] == marker) {
+				isSubword = true;
+				start++;
+			}
+			if (s[1] == words[j][start]) {
+				const char *a = words[j] + start;
+				const char *b = s + 1;
+				while (*a && *a == *b) {
+					a++;
+					if (*a == marker) {
+						isSubword = true;
+						a++;
+					}
+					b++;
+				}
+				if ((!*a || isSubword) && !*b)
+					return true;
+			}
+			j++;
+		}
+	}
+	j = starts[static_cast<unsigned int>('^')];
+	if (j >= 0) {
+		while (words[j][0] == '^') {
+			const char *a = words[j] + 1;
+			const char *b = s;
+			while (*a && *a == *b) {
+				a++;
+				b++;
+			}
+			if (!*a)
+				return true;
+			j++;
+		}
+	}
+	return false;
+}
+
+/** similar to InListAbbreviated, but word s can be a abridged version of a keyword.
+* eg. the keyword is defined as "after.~:". This means the word must have a prefix (begins with) of
+* "after." and suffix (ends with) of ":" to be a keyword, Hence "after.field:" , "after.form.item:" are valid.
+* Similarly "~.is.valid" keyword is suffix only... hence "field.is.valid" , "form.is.valid" are valid.
+* The marker is ~ in this case.
+* No multiple markers check is done and wont work.
+*/
+bool WordList::InListAbridged(const char *s, const char marker) const noexcept {
+	if (0 == words)
+		return false;
+	const unsigned char firstChar = s[0];
+	int j = starts[firstChar];
+	if (j >= 0) {
+		while (words[j][0] == firstChar) {
+			const char *a = words[j];
+			const char *b = s;
+			while (*a && *a == *b) {
+				a++;
+				if (*a == marker) {
+					a++;
+					const size_t suffixLengthA = strlen(a);
+					const size_t suffixLengthB = strlen(b);
+					if (suffixLengthA >= suffixLengthB)
+						break;
+					b = b + suffixLengthB - suffixLengthA - 1;
+				}
+				b++;
+			}
+			if (!*a  && !*b)
+				return true;
+			j++;
+		}
+	}
+
+	j = starts[static_cast<unsigned int>(marker)];
+	if (j >= 0) {
+		while (words[j][0] == marker) {
+			const char *a = words[j] + 1;
+			const char *b = s;
+			const size_t suffixLengthA = strlen(a);
+			const size_t suffixLengthB = strlen(b);
+			if (suffixLengthA > suffixLengthB) {
+				j++;
+				continue;
+			}
+			b = b + suffixLengthB - suffixLengthA;
+
+			while (*a && *a == *b) {
+				a++;
+				b++;
+			}
+			if (!*a && !*b)
+				return true;
+			j++;
+		}
+	}
+
+	return false;
+}
+
+const char *WordList::WordAt(int n) const noexcept {
+	return words[n];
+}
+
diff --git a/Pythonwin/Scintilla/lexlib/WordList.h b/Pythonwin/Scintilla/lexlib/WordList.h
new file mode 100644
index 000000000..127f00e68
--- /dev/null
+++ b/Pythonwin/Scintilla/lexlib/WordList.h
@@ -0,0 +1,38 @@
+// Scintilla source code edit control
+/** @file WordList.h
+ ** Hold a list of words.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef WORDLIST_H
+#define WORDLIST_H
+
+namespace Scintilla {
+
+/**
+ */
+class WordList {
+	// Each word contains at least one character - a empty word acts as sentinel at the end.
+	char **words;
+	char *list;
+	int len;
+	bool onlyLineEnds;	///< Delimited by any white space or only line ends
+	int starts[256];
+public:
+	explicit WordList(bool onlyLineEnds_ = false);
+	~WordList();
+	operator bool() const noexcept;
+	bool operator!=(const WordList &other) const noexcept;
+	int Length() const noexcept;
+	void Clear() noexcept;
+	bool Set(const char *s);
+	bool InList(const char *s) const noexcept;
+	bool InListAbbreviated(const char *s, const char marker) const noexcept;
+	bool InListAbridged(const char *s, const char marker) const noexcept;
+	const char *WordAt(int n) const noexcept;
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/AutoComplete.cxx b/Pythonwin/Scintilla/src/AutoComplete.cxx
index af6154ea1..7a8b6b201 100644
--- a/Pythonwin/Scintilla/src/AutoComplete.cxx
+++ b/Pythonwin/Scintilla/src/AutoComplete.cxx
@@ -5,18 +5,27 @@
 // Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cstdio>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <algorithm>
+#include <memory>
 
 #include "Platform.h"
 
-#include "PropSet.h"
+#include "Scintilla.h"
+#include "CharacterSet.h"
+#include "Position.h"
 #include "AutoComplete.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 AutoComplete::AutoComplete() :
 	active(false),
@@ -24,36 +33,35 @@ AutoComplete::AutoComplete() :
 	typesep('?'),
 	ignoreCase(false),
 	chooseSingle(false),
-	lb(0),
 	posStart(0),
 	startLen(0),
 	cancelAtStartPos(true),
 	autoHide(true),
-	dropRestOfWord(false)	{
-	lb = ListBox::Allocate();
-	stopChars[0] = '\0';
-	fillUpChars[0] = '\0';
+	dropRestOfWord(false),
+	ignoreCaseBehaviour(SC_CASEINSENSITIVEBEHAVIOUR_RESPECTCASE),
+	widthLBDefault(100),
+	heightLBDefault(100),
+	autoSort(SC_ORDER_PRESORTED) {
+	lb.reset(ListBox::Allocate());
 }
 
 AutoComplete::~AutoComplete() {
 	if (lb) {
 		lb->Destroy();
-		delete lb;
-		lb = 0;
 	}
 }
 
-bool AutoComplete::Active() {
+bool AutoComplete::Active() const noexcept {
 	return active;
 }
 
-void AutoComplete::Start(Window &parent, int ctrlID, 
-	int position, Point location, int startLen_, 
-	int lineHeight, bool unicodeMode) {
+void AutoComplete::Start(Window &parent, int ctrlID,
+	Sci::Position position, Point location, Sci::Position startLen_,
+	int lineHeight, bool unicodeMode, int technology) {
 	if (active) {
 		Cancel();
 	}
-	lb->Create(parent, ctrlID, location, lineHeight, unicodeMode);
+	lb->Create(parent, ctrlID, location, lineHeight, unicodeMode, technology);
 	lb->Clear();
 	active = true;
 	startLen = startLen_;
@@ -61,28 +69,26 @@ void AutoComplete::Start(Window &parent, int ctrlID,
 }
 
 void AutoComplete::SetStopChars(const char *stopChars_) {
-	strncpy(stopChars, stopChars_, sizeof(stopChars));
-	stopChars[sizeof(stopChars) - 1] = '\0';
+	stopChars = stopChars_;
 }
 
-bool AutoComplete::IsStopChar(char ch) {
-	return ch && strchr(stopChars, ch);
+bool AutoComplete::IsStopChar(char ch) const noexcept {
+	return ch && (stopChars.find(ch) != std::string::npos);
 }
 
 void AutoComplete::SetFillUpChars(const char *fillUpChars_) {
-	strncpy(fillUpChars, fillUpChars_, sizeof(fillUpChars));
-	fillUpChars[sizeof(fillUpChars) - 1] = '\0';
+	fillUpChars = fillUpChars_;
 }
 
-bool AutoComplete::IsFillUpChar(char ch) {
-	return ch && strchr(fillUpChars, ch);
+bool AutoComplete::IsFillUpChar(char ch) const noexcept {
+	return ch && (fillUpChars.find(ch) != std::string::npos);
 }
 
 void AutoComplete::SetSeparator(char separator_) {
 	separator = separator_;
 }
 
-char AutoComplete::GetSeparator() {
+char AutoComplete::GetSeparator() const noexcept {
 	return separator;
 }
 
@@ -90,12 +96,107 @@ void AutoComplete::SetTypesep(char separator_) {
 	typesep = separator_;
 }
 
-char AutoComplete::GetTypesep() {
+char AutoComplete::GetTypesep() const noexcept {
 	return typesep;
 }
 
+struct Sorter {
+	AutoComplete *ac;
+	const char *list;
+	std::vector<int> indices;
+
+	Sorter(AutoComplete *ac_, const char *list_) : ac(ac_), list(list_) {
+		int i = 0;
+		while (list[i]) {
+			indices.push_back(i); // word start
+			while (list[i] != ac->GetTypesep() && list[i] != ac->GetSeparator() && list[i])
+				++i;
+			indices.push_back(i); // word end
+			if (list[i] == ac->GetTypesep()) {
+				while (list[i] != ac->GetSeparator() && list[i])
+					++i;
+			}
+			if (list[i] == ac->GetSeparator()) {
+				++i;
+				// preserve trailing separator as blank entry
+				if (!list[i]) {
+					indices.push_back(i);
+					indices.push_back(i);
+				}
+			}
+		}
+		indices.push_back(i); // index of last position
+	}
+
+	bool operator()(int a, int b) {
+		const int lenA = indices[a * 2 + 1] - indices[a * 2];
+		const int lenB = indices[b * 2 + 1] - indices[b * 2];
+		const int len  = std::min(lenA, lenB);
+		int cmp;
+		if (ac->ignoreCase)
+			cmp = CompareNCaseInsensitive(list + indices[a * 2], list + indices[b * 2], len);
+		else
+			cmp = strncmp(list + indices[a * 2], list + indices[b * 2], len);
+		if (cmp == 0)
+			cmp = lenA - lenB;
+		return cmp < 0;
+	}
+};
+
 void AutoComplete::SetList(const char *list) {
-	lb->SetList(list, separator, typesep);
+	if (autoSort == SC_ORDER_PRESORTED) {
+		lb->SetList(list, separator, typesep);
+		sortMatrix.clear();
+		for (int i = 0; i < lb->Length(); ++i)
+			sortMatrix.push_back(i);
+		return;
+	}
+
+	Sorter IndexSort(this, list);
+	sortMatrix.clear();
+	for (int i = 0; i < static_cast<int>(IndexSort.indices.size()) / 2; ++i)
+		sortMatrix.push_back(i);
+	std::sort(sortMatrix.begin(), sortMatrix.end(), IndexSort);
+	if (autoSort == SC_ORDER_CUSTOM || sortMatrix.size() < 2) {
+		lb->SetList(list, separator, typesep);
+		PLATFORM_ASSERT(lb->Length() == static_cast<int>(sortMatrix.size()));
+		return;
+	}
+
+	std::string sortedList;
+	char item[maxItemLen];
+	for (size_t i = 0; i < sortMatrix.size(); ++i) {
+		int wordLen = IndexSort.indices[sortMatrix[i] * 2 + 2] - IndexSort.indices[sortMatrix[i] * 2];
+		if (wordLen > maxItemLen-2)
+			wordLen = maxItemLen - 2;
+		memcpy(item, list + IndexSort.indices[sortMatrix[i] * 2], wordLen);
+		if ((i+1) == sortMatrix.size()) {
+			// Last item so remove separator if present
+			if ((wordLen > 0) && (item[wordLen-1] == separator))
+				wordLen--;
+		} else {
+			// Item before last needs a separator
+			if ((wordLen == 0) || (item[wordLen-1] != separator)) {
+				item[wordLen] = separator;
+				wordLen++;
+			}
+		}
+		item[wordLen] = '\0';
+		sortedList += item;
+	}
+	for (int i = 0; i < static_cast<int>(sortMatrix.size()); ++i)
+		sortMatrix[i] = i;
+	lb->SetList(sortedList.c_str(), separator, typesep);
+}
+
+int AutoComplete::GetSelection() const {
+	return lb->GetSelection();
+}
+
+std::string AutoComplete::GetValue(int item) const {
+	char value[maxItemLen];
+	lb->GetValue(item, value, sizeof(value));
+	return std::string(value);
 }
 
 void AutoComplete::Show(bool show) {
@@ -114,7 +215,7 @@ void AutoComplete::Cancel() {
 
 
 void AutoComplete::Move(int delta) {
-	int count = lb->Length();
+	const int count = lb->Length();
 	int current = lb->GetSelection();
 	current += delta;
 	if (current >= count)
@@ -125,15 +226,14 @@ void AutoComplete::Move(int delta) {
 }
 
 void AutoComplete::Select(const char *word) {
-	size_t lenWord = strlen(word);
+	const size_t lenWord = strlen(word);
 	int location = -1;
-	const int maxItemLen=1000;
-	char item[maxItemLen];
 	int start = 0; // lower bound of the api array block to search
 	int end = lb->Length() - 1; // upper bound of the api array block to search
 	while ((start <= end) && (location == -1)) { // Binary searching loop
 		int pivot = (start + end) / 2;
-		lb->GetValue(pivot, item, maxItemLen);
+		char item[maxItemLen];
+		lb->GetValue(sortMatrix[pivot], item, maxItemLen);
 		int cond;
 		if (ignoreCase)
 			cond = CompareNCaseInsensitive(word, item, lenWord);
@@ -142,7 +242,7 @@ void AutoComplete::Select(const char *word) {
 		if (!cond) {
 			// Find first match
 			while (pivot > start) {
-				lb->GetValue(pivot-1, item, maxItemLen);
+				lb->GetValue(sortMatrix[pivot-1], item, maxItemLen);
 				if (ignoreCase)
 					cond = CompareNCaseInsensitive(word, item, lenWord);
 				else
@@ -152,10 +252,11 @@ void AutoComplete::Select(const char *word) {
 				--pivot;
 			}
 			location = pivot;
-			if (ignoreCase) {
+			if (ignoreCase
+				&& ignoreCaseBehaviour == SC_CASEINSENSITIVEBEHAVIOUR_RESPECTCASE) {
 				// Check for exact-case match
 				for (; pivot <= end; pivot++) {
-					lb->GetValue(pivot, item, maxItemLen);
+					lb->GetValue(sortMatrix[pivot], item, maxItemLen);
 					if (!strncmp(word, item, lenWord)) {
 						location = pivot;
 						break;
@@ -170,9 +271,24 @@ void AutoComplete::Select(const char *word) {
 			start = pivot + 1;
 		}
 	}
-	if (location == -1 && autoHide)
-		Cancel();
-	else
-		lb->Select(location);
+	if (location == -1) {
+		if (autoHide)
+			Cancel();
+		else
+			lb->Select(-1);
+	} else {
+		if (autoSort == SC_ORDER_CUSTOM) {
+			// Check for a logically earlier match
+			char item[maxItemLen];
+			for (int i = location + 1; i <= end; ++i) {
+				lb->GetValue(sortMatrix[i], item, maxItemLen);
+				if (CompareNCaseInsensitive(word, item, lenWord))
+					break;
+				if (sortMatrix[i] < sortMatrix[location] && !strncmp(word, item, lenWord))
+					location = i;
+			}
+		}
+		lb->Select(sortMatrix[location]);
+	}
 }
 
diff --git a/Pythonwin/Scintilla/src/AutoComplete.h b/Pythonwin/Scintilla/src/AutoComplete.h
index b10cdce82..c5b40ad14 100644
--- a/Pythonwin/Scintilla/src/AutoComplete.h
+++ b/Pythonwin/Scintilla/src/AutoComplete.h
@@ -8,59 +8,74 @@
 #ifndef AUTOCOMPLETE_H
 #define AUTOCOMPLETE_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
 
 /**
  */
 class AutoComplete {
 	bool active;
-	char stopChars[256];
-	char fillUpChars[256];
+	std::string stopChars;
+	std::string fillUpChars;
 	char separator;
-	char typesep; // Type seperator
+	char typesep; // Type separator
+	enum { maxItemLen=1000 };
+	std::vector<int> sortMatrix;
 
 public:
+
 	bool ignoreCase;
 	bool chooseSingle;
-	ListBox *lb;
-	int posStart;
-	int startLen;
-	/// Should autocompletion be canceled if editor's currentPos <= startPos?
+	std::unique_ptr<ListBox> lb;
+	Sci::Position posStart;
+	Sci::Position startLen;
+	/// Should autocompletion be cancelled if editor's currentPos <= startPos?
 	bool cancelAtStartPos;
 	bool autoHide;
 	bool dropRestOfWord;
+	unsigned int ignoreCaseBehaviour;
+	int widthLBDefault;
+	int heightLBDefault;
+	/** SC_ORDER_PRESORTED:   Assume the list is presorted; selection will fail if it is not alphabetical<br />
+	 *  SC_ORDER_PERFORMSORT: Sort the list alphabetically; start up performance cost for sorting<br />
+	 *  SC_ORDER_CUSTOM:      Handle non-alphabetical entries; start up performance cost for generating a sorted lookup table
+	 */
+	int autoSort;
 
 	AutoComplete();
 	~AutoComplete();
 
 	/// Is the auto completion list displayed?
-	bool Active();
+	bool Active() const noexcept;
 
 	/// Display the auto completion list positioned to be near a character position
-	void Start(Window &parent, int ctrlID, int position, Point location,
-		int startLen_, int lineHeight, bool unicodeMode);
+	void Start(Window &parent, int ctrlID, Sci::Position position, Point location,
+		Sci::Position startLen_, int lineHeight, bool unicodeMode, int technology);
 
 	/// The stop chars are characters which, when typed, cause the auto completion list to disappear
 	void SetStopChars(const char *stopChars_);
-	bool IsStopChar(char ch);
+	bool IsStopChar(char ch) const noexcept;
 
 	/// The fillup chars are characters which, when typed, fill up the selected word
 	void SetFillUpChars(const char *fillUpChars_);
-	bool IsFillUpChar(char ch);
+	bool IsFillUpChar(char ch) const noexcept;
 
 	/// The separator character is used when interpreting the list in SetList
 	void SetSeparator(char separator_);
-	char GetSeparator();
+	char GetSeparator() const noexcept;
 
-	/// The typesep character is used for seperating the word from the type
+	/// The typesep character is used for separating the word from the type
 	void SetTypesep(char separator_);
-	char GetTypesep();
+	char GetTypesep() const noexcept;
 
 	/// The list string contains a sequence of words separated by the separator character
 	void SetList(const char *list);
 
+	/// Return the position of the currently selected list item
+	int GetSelection() const;
+
+	/// Return the value of an item in the list
+	std::string GetValue(int item) const;
+
 	void Show(bool show);
 	void Cancel();
 
@@ -71,8 +86,6 @@ class AutoComplete {
 	void Select(const char *word);
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/CallTip.cxx b/Pythonwin/Scintilla/src/CallTip.cxx
index 9f5f88476..d9c6bc9b5 100644
--- a/Pythonwin/Scintilla/src/CallTip.cxx
+++ b/Pythonwin/Scintilla/src/CallTip.cxx
@@ -5,74 +5,77 @@
 // Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <stdlib.h>
-#include <string.h>
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cstdio>
+#include <cmath>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <algorithm>
+#include <memory>
 
 #include "Platform.h"
 
 #include "Scintilla.h"
+
+#include "Position.h"
+#include "IntegerRectangle.h"
 #include "CallTip.h"
-#include <stdio.h>
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-static const int insetX = 5;    // text inset in x from calltip border
-static const int widthArrow = 14;
+size_t Chunk::Length() const noexcept {
+	return end - start;
+}
 
-CallTip::CallTip() {
-	wCallTip = 0;
+CallTip::CallTip() noexcept {
+	wCallTip = {};
 	inCallTipMode = false;
 	posStartCallTip = 0;
-	val = 0;
 	rectUp = PRectangle(0,0,0,0);
 	rectDown = PRectangle(0,0,0,0);
 	lineHeight = 1;
-	startHighlight = 0;
-	endHighlight = 0;
+	offsetMain = 0;
 	tabSize = 0;
+	above = false;
 	useStyleCallTip = false;    // for backwards compatibility
 
+	insetX = 5;
+	widthArrow = 14;
+	borderHeight = 2; // Extra line for border and an empty line at top and bottom.
+	verticalOffset = 1;
+
 #ifdef __APPLE__
 	// proper apple colours for the default
-	colourBG.desired = ColourDesired(0xff, 0xff, 0xc6);
-	colourUnSel.desired = ColourDesired(0, 0, 0);
+	colourBG = ColourDesired(0xff, 0xff, 0xc6);
+	colourUnSel = ColourDesired(0, 0, 0);
 #else
-	colourBG.desired = ColourDesired(0xff, 0xff, 0xff);
-	colourUnSel.desired = ColourDesired(0x80, 0x80, 0x80);
+	colourBG = ColourDesired(0xff, 0xff, 0xff);
+	colourUnSel = ColourDesired(0x80, 0x80, 0x80);
 #endif
-	colourSel.desired = ColourDesired(0, 0, 0x80);
-	colourShade.desired = ColourDesired(0, 0, 0);
-	colourLight.desired = ColourDesired(0xc0, 0xc0, 0xc0);
+	colourSel = ColourDesired(0, 0, 0x80);
+	colourShade = ColourDesired(0, 0, 0);
+	colourLight = ColourDesired(0xc0, 0xc0, 0xc0);
+	codePage = 0;
+	clickPlace = 0;
 }
 
 CallTip::~CallTip() {
 	font.Release();
 	wCallTip.Destroy();
-	delete []val;
-	val = 0;
-}
-
-void CallTip::RefreshColourPalette(Palette &pal, bool want) {
-	pal.WantFind(colourBG, want);
-	pal.WantFind(colourUnSel, want);
-	pal.WantFind(colourSel, want);
-	pal.WantFind(colourShade, want);
-	pal.WantFind(colourLight, want);
-}
-
-// Although this test includes 0, we should never see a \0 character.
-static bool IsArrowCharacter(char ch) {
-	return (ch == 0) || (ch == '\001') || (ch == '\002');
 }
 
 // We ignore tabs unless a tab width has been set.
-bool CallTip::IsTabCharacter(char ch) {
+bool CallTip::IsTabCharacter(char ch) const noexcept {
 	return (tabSize > 0) && (ch == '\t');
 }
 
-int CallTip::NextTabPos(int x) {
+int CallTip::NextTabPos(int x) const noexcept {
 	if (tabSize > 0) {              // paranoia... not called unless this is true
 		x -= insetX;                // position relative to text
 		x = (x + tabSize) / tabSize;  // tab "number"
@@ -82,149 +85,164 @@ int CallTip::NextTabPos(int x) {
 	}
 }
 
+namespace {
+
+// Although this test includes 0, we should never see a \0 character.
+constexpr bool IsArrowCharacter(char ch) noexcept {
+	return (ch == 0) || (ch == '\001') || (ch == '\002');
+}
+
+void DrawArrow(Scintilla::Surface *surface, const PRectangle &rc, bool upArrow, ColourDesired colourBG, ColourDesired colourUnSel) {
+	surface->FillRectangle(rc, colourBG);
+	const int width = static_cast<int>(rc.Width());
+	const int halfWidth = width / 2 - 3;
+	const int quarterWidth = halfWidth / 2;
+	const int centreX = static_cast<int>(rc.left) + width / 2 - 1;
+	const int centreY = static_cast<int>(rc.top + rc.bottom) / 2;
+	const PRectangle rcClientInner(rc.left + 1, rc.top + 1, rc.right - 2, rc.bottom - 1);
+	surface->FillRectangle(rcClientInner, colourUnSel);
+
+	if (upArrow) {      // Up arrow
+		Point pts[] = {
+			Point::FromInts(centreX - halfWidth, centreY + quarterWidth),
+			Point::FromInts(centreX + halfWidth, centreY + quarterWidth),
+			Point::FromInts(centreX, centreY - halfWidth + quarterWidth),
+		};
+		surface->Polygon(pts, std::size(pts), colourBG, colourBG);
+	} else {            // Down arrow
+		Point pts[] = {
+			Point::FromInts(centreX - halfWidth, centreY - quarterWidth),
+			Point::FromInts(centreX + halfWidth, centreY - quarterWidth),
+			Point::FromInts(centreX, centreY + halfWidth - quarterWidth),
+		};
+		surface->Polygon(pts, std::size(pts), colourBG, colourBG);
+	}
+}
+
+}
+
 // Draw a section of the call tip that does not include \n in one colour.
-// The text may include up to numEnds tabs or arrow characters.
-void CallTip::DrawChunk(Surface *surface, int &x, const char *s,
-	int posStart, int posEnd, int ytext, PRectangle rcClient,
-	bool highlight, bool draw) {
-	s += posStart;
-	int len = posEnd - posStart;
+// The text may include tabs or arrow characters.
+int CallTip::DrawChunk(Surface *surface, int x, std::string_view sv,
+	int ytext, PRectangle rcClient, bool asHighlight, bool draw) {
+
+	if (sv.empty()) {
+		return x;
+	}
 
 	// Divide the text into sections that are all text, or that are
 	// single arrows or single tab characters (if tabSize > 0).
-	int maxEnd = 0;
-	const int numEnds = 10;
-	int ends[numEnds + 2];
-	for (int i=0;i<len;i++) {
-		if ((maxEnd < numEnds) &&
-		        (IsArrowCharacter(s[i]) || IsTabCharacter(s[i])) ) {
-			if (i > 0)
-				ends[maxEnd++] = i;
-			ends[maxEnd++] = i+1;
+	// Start with single element 0 to simplify append checks.
+	std::vector<size_t> ends(1);
+	for (size_t i=0; i<sv.length(); i++) {
+		if (IsArrowCharacter(sv[i]) || IsTabCharacter(sv[i])) {
+			if (ends.back() != i)
+				ends.push_back(i);
+			ends.push_back(i+1);
 		}
 	}
-	ends[maxEnd++] = len;
-	int startSeg = 0;
-	int xEnd;
-	for (int seg = 0; seg<maxEnd; seg++) {
-		int endSeg = ends[seg];
-		if (endSeg > startSeg) {
-			if (IsArrowCharacter(s[startSeg])) {
-				bool upArrow = s[startSeg] == '\001';
-				rcClient.left = x;
-				rcClient.right = rcClient.left + widthArrow;
-				if (draw) {
-					const int halfWidth = widthArrow / 2 - 3;
-					const int centreX = rcClient.left + widthArrow / 2 - 1;
-					const int centreY = (rcClient.top + rcClient.bottom) / 2;
-					surface->FillRectangle(rcClient, colourBG.allocated);
-					PRectangle rcClientInner(rcClient.left + 1, rcClient.top + 1,
-					                         rcClient.right - 2, rcClient.bottom - 1);
-					surface->FillRectangle(rcClientInner, colourUnSel.allocated);
-
-					if (upArrow) {      // Up arrow
-						Point pts[] = {
-    						Point(centreX - halfWidth, centreY + halfWidth / 2),
-    						Point(centreX + halfWidth, centreY + halfWidth / 2),
-    						Point(centreX, centreY - halfWidth + halfWidth / 2),
-						};
-						surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]),
-                 						colourBG.allocated, colourBG.allocated);
-					} else {            // Down arrow
-						Point pts[] = {
-    						Point(centreX - halfWidth, centreY - halfWidth / 2),
-    						Point(centreX + halfWidth, centreY - halfWidth / 2),
-    						Point(centreX, centreY + halfWidth - halfWidth / 2),
-						};
-						surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]),
-                 						colourBG.allocated, colourBG.allocated);
-					}
-				}
-				xEnd = rcClient.right;
-				offsetMain = xEnd;
-				if (upArrow) {
-					rectUp = rcClient;
-				} else {
-					rectDown = rcClient;
-				}
-			} else if (IsTabCharacter(s[startSeg])) {
-				xEnd = NextTabPos(x);
+	if (ends.back() != sv.length())
+		ends.push_back(sv.length());
+	ends.erase(ends.begin());	// Remove initial 0.
+
+	size_t startSeg = 0;
+	for (const size_t endSeg : ends) {
+		assert(endSeg > 0);
+		int xEnd;
+		if (IsArrowCharacter(sv[startSeg])) {
+			xEnd = x + widthArrow;
+			const bool upArrow = sv[startSeg] == '\001';
+			rcClient.left = static_cast<XYPOSITION>(x);
+			rcClient.right = static_cast<XYPOSITION>(xEnd);
+			if (draw) {
+				DrawArrow(surface, rcClient, upArrow, colourBG, colourUnSel);
+			}
+			offsetMain = xEnd;
+			if (upArrow) {
+				rectUp = rcClient;
 			} else {
-				xEnd = x + surface->WidthText(font, s + startSeg, endSeg - startSeg);
-				if (draw) {
-					rcClient.left = x;
-					rcClient.right = xEnd;
-					surface->DrawTextTransparent(rcClient, font, ytext,
-										s+startSeg, endSeg - startSeg,
-					                             highlight ? colourSel.allocated : colourUnSel.allocated);
-				}
+				rectDown = rcClient;
+			}
+		} else if (IsTabCharacter(sv[startSeg])) {
+			xEnd = NextTabPos(x);
+		} else {
+			const std::string_view segText = sv.substr(startSeg, endSeg - startSeg);
+			xEnd = x + static_cast<int>(std::lround(surface->WidthText(font, segText)));
+			if (draw) {
+				rcClient.left = static_cast<XYPOSITION>(x);
+				rcClient.right = static_cast<XYPOSITION>(xEnd);
+				surface->DrawTextTransparent(rcClient, font, static_cast<XYPOSITION>(ytext),
+									segText, asHighlight ? colourSel : colourUnSel);
 			}
-			x = xEnd;
-			startSeg = endSeg;
 		}
+		x = xEnd;
+		startSeg = endSeg;
 	}
+	return x;
 }
 
 int CallTip::PaintContents(Surface *surfaceWindow, bool draw) {
-	PRectangle rcClientPos = wCallTip.GetClientPosition();
-	PRectangle rcClientSize(0, 0, rcClientPos.right - rcClientPos.left,
+	const PRectangle rcClientPos = wCallTip.GetClientPosition();
+	const PRectangle rcClientSize(0.0f, 0.0f, rcClientPos.right - rcClientPos.left,
 	                        rcClientPos.bottom - rcClientPos.top);
-	PRectangle rcClient(1, 1, rcClientSize.right - 1, rcClientSize.bottom - 1);
+	PRectangle rcClient(1.0f, 1.0f, rcClientSize.right - 1, rcClientSize.bottom - 1);
 
 	// To make a nice small call tip window, it is only sized to fit most normal characters without accents
-	int ascent = surfaceWindow->Ascent(font) - surfaceWindow->InternalLeading(font);
+	const int ascent = static_cast<int>(std::round(surfaceWindow->Ascent(font) - surfaceWindow->InternalLeading(font)));
 
 	// For each line...
 	// Draw the definition in three parts: before highlight, highlighted, after highlight
-	int ytext = rcClient.top + ascent + 1;
+	int ytext = static_cast<int>(rcClient.top) + ascent + 1;
 	rcClient.bottom = ytext + surfaceWindow->Descent(font) + 1;
-	char *chunkVal = val;
-	bool moreChunks = true;
+	std::string_view remaining(val);
 	int maxWidth = 0;
-
-	while (moreChunks) {
-		char *chunkEnd = strchr(chunkVal, '\n');
-		if (chunkEnd == NULL) {
-			chunkEnd = chunkVal + strlen(chunkVal);
-			moreChunks = false;
+	size_t lineStart = 0;
+	while (!remaining.empty()) {
+		const std::string_view chunkVal = remaining.substr(0, remaining.find_first_of('\n'));
+		remaining.remove_prefix(chunkVal.length());
+		if (!remaining.empty()) {
+			remaining.remove_prefix(1);	// Skip \n
 		}
-		int chunkOffset = chunkVal - val;
-		int chunkLength = chunkEnd - chunkVal;
-		int chunkEndOffset = chunkOffset + chunkLength;
-		int thisStartHighlight = Platform::Maximum(startHighlight, chunkOffset);
-		thisStartHighlight = Platform::Minimum(thisStartHighlight, chunkEndOffset);
-		thisStartHighlight -= chunkOffset;
-		int thisEndHighlight = Platform::Maximum(endHighlight, chunkOffset);
-		thisEndHighlight = Platform::Minimum(thisEndHighlight, chunkEndOffset);
-		thisEndHighlight -= chunkOffset;
-		rcClient.top = ytext - ascent - 1;
+
+		const Chunk chunkLine(lineStart, lineStart + chunkVal.length());
+		Chunk chunkHighlight(
+			std::clamp(highlight.start, chunkLine.start, chunkLine.end),
+			std::clamp(highlight.end, chunkLine.start, chunkLine.end)
+		);
+		chunkHighlight.start -= lineStart;
+		chunkHighlight.end -= lineStart;
+
+		rcClient.top = static_cast<XYPOSITION>(ytext - ascent - 1);
 
 		int x = insetX;     // start each line at this inset
 
-		DrawChunk(surfaceWindow, x, chunkVal, 0, thisStartHighlight,
+		x = DrawChunk(surfaceWindow, x,
+			chunkVal.substr(0, chunkHighlight.start),
 			ytext, rcClient, false, draw);
-		DrawChunk(surfaceWindow, x, chunkVal, thisStartHighlight, thisEndHighlight,
+		x = DrawChunk(surfaceWindow, x,
+			chunkVal.substr(chunkHighlight.start, chunkHighlight.Length()),
 			ytext, rcClient, true, draw);
-		DrawChunk(surfaceWindow, x, chunkVal, thisEndHighlight, chunkLength,
+		x = DrawChunk(surfaceWindow, x,
+			chunkVal.substr(chunkHighlight.end),
 			ytext, rcClient, false, draw);
 
-		chunkVal = chunkEnd + 1;
 		ytext += lineHeight;
 		rcClient.bottom += lineHeight;
-		maxWidth = Platform::Maximum(maxWidth, x);
+		maxWidth = std::max(maxWidth, x);
+		lineStart += chunkVal.length() + 1;
 	}
 	return maxWidth;
 }
 
 void CallTip::PaintCT(Surface *surfaceWindow) {
-	if (!val)
+	if (val.empty())
 		return;
-	PRectangle rcClientPos = wCallTip.GetClientPosition();
-	PRectangle rcClientSize(0, 0, rcClientPos.right - rcClientPos.left,
+	const PRectangle rcClientPos = wCallTip.GetClientPosition();
+	const PRectangle rcClientSize(0.0f, 0.0f, rcClientPos.right - rcClientPos.left,
 	                        rcClientPos.bottom - rcClientPos.top);
-	PRectangle rcClient(1, 1, rcClientSize.right - 1, rcClientSize.bottom - 1);
+	const PRectangle rcClient(1.0f, 1.0f, rcClientSize.right - 1, rcClientSize.bottom - 1);
 
-	surfaceWindow->FillRectangle(rcClient, colourBG.allocated);
+	surfaceWindow->FillRectangle(rcClient, colourBG);
 
 	offsetMain = insetX;    // initial alignment assuming no arrows
 	PaintContents(surfaceWindow, true);
@@ -232,17 +250,18 @@ void CallTip::PaintCT(Surface *surfaceWindow) {
 #ifndef __APPLE__
 	// OSX doesn't put borders on "help tags"
 	// Draw a raised border around the edges of the window
-	surfaceWindow->MoveTo(0, rcClientSize.bottom - 1);
-	surfaceWindow->PenColour(colourShade.allocated);
-	surfaceWindow->LineTo(rcClientSize.right - 1, rcClientSize.bottom - 1);
-	surfaceWindow->LineTo(rcClientSize.right - 1, 0);
-	surfaceWindow->PenColour(colourLight.allocated);
+	const IntegerRectangle ircClientSize(rcClientSize);
+	surfaceWindow->MoveTo(0, ircClientSize.bottom - 1);
+	surfaceWindow->PenColour(colourShade);
+	surfaceWindow->LineTo(ircClientSize.right - 1, ircClientSize.bottom - 1);
+	surfaceWindow->LineTo(ircClientSize.right - 1, 0);
+	surfaceWindow->PenColour(colourLight);
 	surfaceWindow->LineTo(0, 0);
-	surfaceWindow->LineTo(0, rcClientSize.bottom - 1);
+	surfaceWindow->LineTo(0, ircClientSize.bottom - 1);
 #endif
 }
 
-void CallTip::MouseClick(Point pt) {
+void CallTip::MouseClick(Point pt) noexcept {
 	clickPlace = 0;
 	if (rectUp.Contains(pt))
 		clickPlace = 1;
@@ -250,50 +269,41 @@ void CallTip::MouseClick(Point pt) {
 		clickPlace = 2;
 }
 
-PRectangle CallTip::CallTipStart(int pos, Point pt, const char *defn,
+PRectangle CallTip::CallTipStart(Sci::Position pos, Point pt, int textHeight, const char *defn,
                                  const char *faceName, int size,
-                                 int codePage_, int characterSet, Window &wParent) {
+                                 int codePage_, int characterSet,
+								 int technology, const Window &wParent) {
 	clickPlace = 0;
-	if (val)
-		delete []val;
-	val = new char[strlen(defn) + 1];
-	if (!val)
-		return PRectangle();
-	strcpy(val, defn);
+	val = defn;
 	codePage = codePage_;
-	Surface *surfaceMeasure = Surface::Allocate();
-	if (!surfaceMeasure)
-		return PRectangle();
+	std::unique_ptr<Surface> surfaceMeasure(Surface::Allocate(technology));
 	surfaceMeasure->Init(wParent.GetID());
 	surfaceMeasure->SetUnicodeMode(SC_CP_UTF8 == codePage);
 	surfaceMeasure->SetDBCSMode(codePage);
-	startHighlight = 0;
-	endHighlight = 0;
+	highlight = Chunk();
 	inCallTipMode = true;
 	posStartCallTip = pos;
-	int deviceHeight = surfaceMeasure->DeviceHeightFont(size);
-	font.Create(faceName, characterSet, deviceHeight, false, false);
+	const XYPOSITION deviceHeight = static_cast<XYPOSITION>(surfaceMeasure->DeviceHeightFont(size));
+	const FontParameters fp(faceName, deviceHeight / SC_FONT_SIZE_MULTIPLIER, SC_WEIGHT_NORMAL, false, 0, technology, characterSet);
+	font.Create(fp);
 	// Look for multiple lines in the text
 	// Only support \n here - simply means container must avoid \r!
-	int numLines = 1;
-	const char *newline;
-	const char *look = val;
+	const int numLines = 1 + static_cast<int>(std::count(val.begin(), val.end(), '\n'));
 	rectUp = PRectangle(0,0,0,0);
 	rectDown = PRectangle(0,0,0,0);
 	offsetMain = insetX;            // changed to right edge of any arrows
-	int width = PaintContents(surfaceMeasure, false) + insetX;
-	while ((newline = strchr(look, '\n')) != NULL) {
-		look = newline + 1;
-		numLines++;
-	}
-	lineHeight = surfaceMeasure->Height(font);
+	const int width = PaintContents(surfaceMeasure.get(), false) + insetX;
+	lineHeight = static_cast<int>(std::lround(surfaceMeasure->Height(font)));
 
-	// Extra line for border and an empty line at top and bottom. The returned
+	// The returned
 	// rectangle is aligned to the right edge of the last arrow encountered in
 	// the tip text, else to the tip text left edge.
-	int height = lineHeight * numLines - surfaceMeasure->InternalLeading(font) + 2 + 2;
-	delete surfaceMeasure;
-	return PRectangle(pt.x - offsetMain, pt.y + 1, pt.x + width - offsetMain, pt.y + 1 + height);
+	const int height = lineHeight * numLines - static_cast<int>(surfaceMeasure->InternalLeading(font)) + borderHeight * 2;
+	if (above) {
+		return PRectangle(pt.x - offsetMain, pt.y - verticalOffset - height, pt.x + width - offsetMain, pt.y - verticalOffset);
+	} else {
+		return PRectangle(pt.x - offsetMain, pt.y + verticalOffset + textHeight, pt.x + width - offsetMain, pt.y + verticalOffset + textHeight + height);
+	}
 }
 
 void CallTip::CallTipCancel() {
@@ -303,11 +313,11 @@ void CallTip::CallTipCancel() {
 	}
 }
 
-void CallTip::SetHighlight(int start, int end) {
+void CallTip::SetHighlight(size_t start, size_t end) {
 	// Avoid flashing by checking something has really changed
-	if ((start != startHighlight) || (end != endHighlight)) {
-		startHighlight = start;
-		endHighlight = end;
+	if ((start != highlight.start) || (end != highlight.end)) {
+		highlight.start = start;
+		highlight.end = (end > start) ? end : start;
 		if (wCallTip.Created()) {
 			wCallTip.InvalidateAll();
 		}
@@ -316,14 +326,24 @@ void CallTip::SetHighlight(int start, int end) {
 
 // Set the tab size (sizes > 0 enable the use of tabs). This also enables the
 // use of the STYLE_CALLTIP.
-void CallTip::SetTabSize(int tabSz) {
+void CallTip::SetTabSize(int tabSz) noexcept {
 	tabSize = tabSz;
 	useStyleCallTip = true;
 }
 
+// Set the calltip position, below the text by default or if above is false
+// else above the text.
+void CallTip::SetPosition(bool aboveText) noexcept {
+	above = aboveText;
+}
+
+bool CallTip::UseStyleCallTip() const noexcept {
+	return useStyleCallTip; 
+}
+
 // It might be better to have two access functions for this and to use
 // them for all settings of colours.
-void CallTip::SetForeBack(const ColourPair &fore, const ColourPair &back) {
+void CallTip::SetForeBack(const ColourDesired &fore, const ColourDesired &back) noexcept {
 	colourBG = back;
 	colourUnSel = fore;
 }
diff --git a/Pythonwin/Scintilla/src/CallTip.h b/Pythonwin/Scintilla/src/CallTip.h
index bdf1123c7..562b24f9d 100644
--- a/Pythonwin/Scintilla/src/CallTip.h
+++ b/Pythonwin/Scintilla/src/CallTip.h
@@ -8,16 +8,22 @@
 #ifndef CALLTIP_H
 #define CALLTIP_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
+
+struct Chunk {
+	size_t start;
+	size_t end;
+	constexpr Chunk(size_t start_=0, size_t end_=0) noexcept : start(start_), end(end_) {
+		assert(start <= end);
+	}
+	size_t Length() const noexcept;
+};
 
 /**
  */
 class CallTip {
-	int startHighlight;    // character offset to start and...
-	int endHighlight;      // ...end of highlighted text
-	char *val;
+	Chunk highlight;    // character offset to start and end of highlighted text
+	std::string val;
 	Font font;
 	PRectangle rectUp;      // rectangle of last up angle in the tip
 	PRectangle rectDown;    // rectangle of last down arrow in the tip
@@ -25,63 +31,68 @@ class CallTip {
 	int offsetMain;         // The alignment point of the call tip
 	int tabSize;            // Tab size in pixels, <=0 no TAB expand
 	bool useStyleCallTip;   // if true, STYLE_CALLTIP should be used
+	bool above;		// if true, display calltip above text
 
-	// Private so CallTip objects can not be copied
-	CallTip(const CallTip &) {}
-	CallTip &operator=(const CallTip &) { return *this; }
-	void DrawChunk(Surface *surface, int &x, const char *s,
-		int posStart, int posEnd, int ytext, PRectangle rcClient,
-		bool highlight, bool draw);
+	int DrawChunk(Surface *surface, int x, std::string_view sv,
+		int ytext, PRectangle rcClient, bool asHighlight, bool draw);
 	int PaintContents(Surface *surfaceWindow, bool draw);
-	bool IsTabCharacter(char c);
-	int NextTabPos(int x);
+	bool IsTabCharacter(char ch) const noexcept;
+	int NextTabPos(int x) const noexcept;
 
 public:
 	Window wCallTip;
 	Window wDraw;
 	bool inCallTipMode;
-	int posStartCallTip;
-	ColourPair colourBG;
-	ColourPair colourUnSel;
-	ColourPair colourSel;
-	ColourPair colourShade;
-	ColourPair colourLight;
+	Sci::Position posStartCallTip;
+	ColourDesired colourBG;
+	ColourDesired colourUnSel;
+	ColourDesired colourSel;
+	ColourDesired colourShade;
+	ColourDesired colourLight;
 	int codePage;
 	int clickPlace;
 
-	CallTip();
+	int insetX; // text inset in x from calltip border
+	int widthArrow;
+	int borderHeight;
+	int verticalOffset; // pixel offset up or down of the calltip with respect to the line
+
+	CallTip() noexcept;
+	// Deleted so CallTip objects can not be copied.
+	CallTip(const CallTip &) = delete;
+	CallTip(CallTip &&) = delete;
+	CallTip &operator=(const CallTip &) = delete;
+	CallTip &operator=(CallTip &&) = delete;
 	~CallTip();
 
-	/// Claim or accept palette entries for the colours required to paint a calltip.
-	void RefreshColourPalette(Palette &pal, bool want);
-
 	void PaintCT(Surface *surfaceWindow);
 
-	void MouseClick(Point pt);
+	void MouseClick(Point pt) noexcept;
 
 	/// Setup the calltip and return a rectangle of the area required.
-	PRectangle CallTipStart(int pos, Point pt, const char *defn,
-		const char *faceName, int size, int codePage_, 
-		int characterSet, Window &wParent);
+	PRectangle CallTipStart(Sci::Position pos, Point pt, int textHeight, const char *defn,
+		const char *faceName, int size, int codePage_,
+		int characterSet, int technology, const Window &wParent);
 
 	void CallTipCancel();
 
 	/// Set a range of characters to be displayed in a highlight style.
 	/// Commonly used to highlight the current parameter.
-	void SetHighlight(int start, int end);
+	void SetHighlight(size_t start, size_t end);
 
 	/// Set the tab size in pixels for the call tip. 0 or -ve means no tab expand.
-	void SetTabSize(int tabSz);
+	void SetTabSize(int tabSz) noexcept;
+
+	/// Set calltip position.
+	void SetPosition(bool aboveText) noexcept;
 
 	/// Used to determine which STYLE_xxxx to use for call tip information
-	bool UseStyleCallTip() const { return useStyleCallTip;}
+	bool UseStyleCallTip() const noexcept;
 
 	// Modify foreground and background colours
-	void SetForeBack(const ColourPair &fore, const ColourPair &back);
+	void SetForeBack(const ColourDesired &fore, const ColourDesired &back) noexcept;
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/CaseConvert.cxx b/Pythonwin/Scintilla/src/CaseConvert.cxx
new file mode 100644
index 000000000..9d8c9c9f3
--- /dev/null
+++ b/Pythonwin/Scintilla/src/CaseConvert.cxx
@@ -0,0 +1,826 @@
+// Scintilla source code edit control
+// Encoding: UTF-8
+/** @file CaseConvert.cxx
+ ** Case fold characters and convert them to upper or lower case.
+ ** Tables automatically regenerated by scripts/GenerateCaseConvert.py
+ ** Should only be rarely regenerated for new versions of Unicode.
+ **/
+// Copyright 2013 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cassert>
+#include <cstring>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <algorithm>
+
+#include "CaseConvert.h"
+#include "UniConversion.h"
+
+using namespace Scintilla;
+
+namespace {
+	// Use an unnamed namespace to protect the declarations from name conflicts
+
+// Unicode code points are ordered by groups and follow patterns.
+// Most characters (pitch==1) are in ranges for a particular alphabet and their
+// upper case forms are a fixed distance away.
+// Another pattern (pitch==2) is where each lower case letter is preceded by
+// the upper case form. These are also grouped into ranges.
+
+int symmetricCaseConversionRanges[] = {
+//lower, upper, range length, range pitch
+//++Autogenerated -- start of section automatically generated
+//**\(\*\n\)
+97,65,26,1,
+224,192,23,1,
+248,216,7,1,
+257,256,24,2,
+314,313,8,2,
+331,330,23,2,
+462,461,8,2,
+479,478,9,2,
+505,504,20,2,
+547,546,9,2,
+583,582,5,2,
+945,913,17,1,
+963,931,9,1,
+985,984,12,2,
+1072,1040,32,1,
+1104,1024,16,1,
+1121,1120,17,2,
+1163,1162,27,2,
+1218,1217,7,2,
+1233,1232,48,2,
+1377,1329,38,1,
+4304,7312,43,1,
+7681,7680,75,2,
+7841,7840,48,2,
+7936,7944,8,1,
+7952,7960,6,1,
+7968,7976,8,1,
+7984,7992,8,1,
+8000,8008,6,1,
+8032,8040,8,1,
+8560,8544,16,1,
+9424,9398,26,1,
+11312,11264,47,1,
+11393,11392,50,2,
+11520,4256,38,1,
+42561,42560,23,2,
+42625,42624,14,2,
+42787,42786,7,2,
+42803,42802,31,2,
+42879,42878,5,2,
+42903,42902,10,2,
+42933,42932,6,2,
+65345,65313,26,1,
+66600,66560,40,1,
+66776,66736,36,1,
+68800,68736,51,1,
+71872,71840,32,1,
+93792,93760,32,1,
+125218,125184,34,1,
+
+//--Autogenerated -- end of section automatically generated
+};
+
+// Code points that are symmetric but don't fit into a range of similar characters
+// are listed here.
+
+int symmetricCaseConversions[] = {
+//lower, upper
+//++Autogenerated -- start of section automatically generated
+//**1 \(\*\n\)
+255,376,
+307,306,
+309,308,
+311,310,
+378,377,
+380,379,
+382,381,
+384,579,
+387,386,
+389,388,
+392,391,
+396,395,
+402,401,
+405,502,
+409,408,
+410,573,
+414,544,
+417,416,
+419,418,
+421,420,
+424,423,
+429,428,
+432,431,
+436,435,
+438,437,
+441,440,
+445,444,
+447,503,
+454,452,
+457,455,
+460,458,
+477,398,
+499,497,
+501,500,
+572,571,
+575,11390,
+576,11391,
+578,577,
+592,11375,
+593,11373,
+594,11376,
+595,385,
+596,390,
+598,393,
+599,394,
+601,399,
+603,400,
+604,42923,
+608,403,
+609,42924,
+611,404,
+613,42893,
+614,42922,
+616,407,
+617,406,
+618,42926,
+619,11362,
+620,42925,
+623,412,
+625,11374,
+626,413,
+629,415,
+637,11364,
+640,422,
+642,42949,
+643,425,
+647,42929,
+648,430,
+649,580,
+650,433,
+651,434,
+652,581,
+658,439,
+669,42930,
+670,42928,
+881,880,
+883,882,
+887,886,
+891,1021,
+892,1022,
+893,1023,
+940,902,
+941,904,
+942,905,
+943,906,
+972,908,
+973,910,
+974,911,
+983,975,
+1010,1017,
+1011,895,
+1016,1015,
+1019,1018,
+1231,1216,
+4349,7357,
+4350,7358,
+4351,7359,
+7545,42877,
+7549,11363,
+7566,42950,
+8017,8025,
+8019,8027,
+8021,8029,
+8023,8031,
+8048,8122,
+8049,8123,
+8050,8136,
+8051,8137,
+8052,8138,
+8053,8139,
+8054,8154,
+8055,8155,
+8056,8184,
+8057,8185,
+8058,8170,
+8059,8171,
+8060,8186,
+8061,8187,
+8112,8120,
+8113,8121,
+8144,8152,
+8145,8153,
+8160,8168,
+8161,8169,
+8165,8172,
+8526,8498,
+8580,8579,
+11361,11360,
+11365,570,
+11366,574,
+11368,11367,
+11370,11369,
+11372,11371,
+11379,11378,
+11382,11381,
+11500,11499,
+11502,11501,
+11507,11506,
+11559,4295,
+11565,4301,
+42874,42873,
+42876,42875,
+42892,42891,
+42897,42896,
+42899,42898,
+42900,42948,
+42947,42946,
+43859,42931,
+
+//--Autogenerated -- end of section automatically generated
+};
+
+// Characters that have complex case conversions are listed here.
+// This includes cases where more than one character is needed for a conversion,
+// folding is different to lowering, or (as appropriate) upper(lower(x)) != x or
+// lower(upper(x)) != x.
+
+const char *complexCaseConversions =
+// Original | Folded | Upper | Lower |
+//++Autogenerated -- start of section automatically generated
+//**2 \(\*\n\)
+"\xc2\xb5|\xce\xbc|\xce\x9c||"
+"\xc3\x9f|ss|SS||"
+"\xc4\xb0|i\xcc\x87||i\xcc\x87|"
+"\xc4\xb1||I||"
+"\xc5\x89|\xca\xbcn|\xca\xbcN||"
+"\xc5\xbf|s|S||"
+"\xc7\x85|\xc7\x86|\xc7\x84|\xc7\x86|"
+"\xc7\x88|\xc7\x89|\xc7\x87|\xc7\x89|"
+"\xc7\x8b|\xc7\x8c|\xc7\x8a|\xc7\x8c|"
+"\xc7\xb0|j\xcc\x8c|J\xcc\x8c||"
+"\xc7\xb2|\xc7\xb3|\xc7\xb1|\xc7\xb3|"
+"\xcd\x85|\xce\xb9|\xce\x99||"
+"\xce\x90|\xce\xb9\xcc\x88\xcc\x81|\xce\x99\xcc\x88\xcc\x81||"
+"\xce\xb0|\xcf\x85\xcc\x88\xcc\x81|\xce\xa5\xcc\x88\xcc\x81||"
+"\xcf\x82|\xcf\x83|\xce\xa3||"
+"\xcf\x90|\xce\xb2|\xce\x92||"
+"\xcf\x91|\xce\xb8|\xce\x98||"
+"\xcf\x95|\xcf\x86|\xce\xa6||"
+"\xcf\x96|\xcf\x80|\xce\xa0||"
+"\xcf\xb0|\xce\xba|\xce\x9a||"
+"\xcf\xb1|\xcf\x81|\xce\xa1||"
+"\xcf\xb4|\xce\xb8||\xce\xb8|"
+"\xcf\xb5|\xce\xb5|\xce\x95||"
+"\xd6\x87|\xd5\xa5\xd6\x82|\xd4\xb5\xd5\x92||"
+"\xe1\x8e\xa0|||\xea\xad\xb0|"
+"\xe1\x8e\xa1|||\xea\xad\xb1|"
+"\xe1\x8e\xa2|||\xea\xad\xb2|"
+"\xe1\x8e\xa3|||\xea\xad\xb3|"
+"\xe1\x8e\xa4|||\xea\xad\xb4|"
+"\xe1\x8e\xa5|||\xea\xad\xb5|"
+"\xe1\x8e\xa6|||\xea\xad\xb6|"
+"\xe1\x8e\xa7|||\xea\xad\xb7|"
+"\xe1\x8e\xa8|||\xea\xad\xb8|"
+"\xe1\x8e\xa9|||\xea\xad\xb9|"
+"\xe1\x8e\xaa|||\xea\xad\xba|"
+"\xe1\x8e\xab|||\xea\xad\xbb|"
+"\xe1\x8e\xac|||\xea\xad\xbc|"
+"\xe1\x8e\xad|||\xea\xad\xbd|"
+"\xe1\x8e\xae|||\xea\xad\xbe|"
+"\xe1\x8e\xaf|||\xea\xad\xbf|"
+"\xe1\x8e\xb0|||\xea\xae\x80|"
+"\xe1\x8e\xb1|||\xea\xae\x81|"
+"\xe1\x8e\xb2|||\xea\xae\x82|"
+"\xe1\x8e\xb3|||\xea\xae\x83|"
+"\xe1\x8e\xb4|||\xea\xae\x84|"
+"\xe1\x8e\xb5|||\xea\xae\x85|"
+"\xe1\x8e\xb6|||\xea\xae\x86|"
+"\xe1\x8e\xb7|||\xea\xae\x87|"
+"\xe1\x8e\xb8|||\xea\xae\x88|"
+"\xe1\x8e\xb9|||\xea\xae\x89|"
+"\xe1\x8e\xba|||\xea\xae\x8a|"
+"\xe1\x8e\xbb|||\xea\xae\x8b|"
+"\xe1\x8e\xbc|||\xea\xae\x8c|"
+"\xe1\x8e\xbd|||\xea\xae\x8d|"
+"\xe1\x8e\xbe|||\xea\xae\x8e|"
+"\xe1\x8e\xbf|||\xea\xae\x8f|"
+"\xe1\x8f\x80|||\xea\xae\x90|"
+"\xe1\x8f\x81|||\xea\xae\x91|"
+"\xe1\x8f\x82|||\xea\xae\x92|"
+"\xe1\x8f\x83|||\xea\xae\x93|"
+"\xe1\x8f\x84|||\xea\xae\x94|"
+"\xe1\x8f\x85|||\xea\xae\x95|"
+"\xe1\x8f\x86|||\xea\xae\x96|"
+"\xe1\x8f\x87|||\xea\xae\x97|"
+"\xe1\x8f\x88|||\xea\xae\x98|"
+"\xe1\x8f\x89|||\xea\xae\x99|"
+"\xe1\x8f\x8a|||\xea\xae\x9a|"
+"\xe1\x8f\x8b|||\xea\xae\x9b|"
+"\xe1\x8f\x8c|||\xea\xae\x9c|"
+"\xe1\x8f\x8d|||\xea\xae\x9d|"
+"\xe1\x8f\x8e|||\xea\xae\x9e|"
+"\xe1\x8f\x8f|||\xea\xae\x9f|"
+"\xe1\x8f\x90|||\xea\xae\xa0|"
+"\xe1\x8f\x91|||\xea\xae\xa1|"
+"\xe1\x8f\x92|||\xea\xae\xa2|"
+"\xe1\x8f\x93|||\xea\xae\xa3|"
+"\xe1\x8f\x94|||\xea\xae\xa4|"
+"\xe1\x8f\x95|||\xea\xae\xa5|"
+"\xe1\x8f\x96|||\xea\xae\xa6|"
+"\xe1\x8f\x97|||\xea\xae\xa7|"
+"\xe1\x8f\x98|||\xea\xae\xa8|"
+"\xe1\x8f\x99|||\xea\xae\xa9|"
+"\xe1\x8f\x9a|||\xea\xae\xaa|"
+"\xe1\x8f\x9b|||\xea\xae\xab|"
+"\xe1\x8f\x9c|||\xea\xae\xac|"
+"\xe1\x8f\x9d|||\xea\xae\xad|"
+"\xe1\x8f\x9e|||\xea\xae\xae|"
+"\xe1\x8f\x9f|||\xea\xae\xaf|"
+"\xe1\x8f\xa0|||\xea\xae\xb0|"
+"\xe1\x8f\xa1|||\xea\xae\xb1|"
+"\xe1\x8f\xa2|||\xea\xae\xb2|"
+"\xe1\x8f\xa3|||\xea\xae\xb3|"
+"\xe1\x8f\xa4|||\xea\xae\xb4|"
+"\xe1\x8f\xa5|||\xea\xae\xb5|"
+"\xe1\x8f\xa6|||\xea\xae\xb6|"
+"\xe1\x8f\xa7|||\xea\xae\xb7|"
+"\xe1\x8f\xa8|||\xea\xae\xb8|"
+"\xe1\x8f\xa9|||\xea\xae\xb9|"
+"\xe1\x8f\xaa|||\xea\xae\xba|"
+"\xe1\x8f\xab|||\xea\xae\xbb|"
+"\xe1\x8f\xac|||\xea\xae\xbc|"
+"\xe1\x8f\xad|||\xea\xae\xbd|"
+"\xe1\x8f\xae|||\xea\xae\xbe|"
+"\xe1\x8f\xaf|||\xea\xae\xbf|"
+"\xe1\x8f\xb0|||\xe1\x8f\xb8|"
+"\xe1\x8f\xb1|||\xe1\x8f\xb9|"
+"\xe1\x8f\xb2|||\xe1\x8f\xba|"
+"\xe1\x8f\xb3|||\xe1\x8f\xbb|"
+"\xe1\x8f\xb4|||\xe1\x8f\xbc|"
+"\xe1\x8f\xb5|||\xe1\x8f\xbd|"
+"\xe1\x8f\xb8|\xe1\x8f\xb0|\xe1\x8f\xb0||"
+"\xe1\x8f\xb9|\xe1\x8f\xb1|\xe1\x8f\xb1||"
+"\xe1\x8f\xba|\xe1\x8f\xb2|\xe1\x8f\xb2||"
+"\xe1\x8f\xbb|\xe1\x8f\xb3|\xe1\x8f\xb3||"
+"\xe1\x8f\xbc|\xe1\x8f\xb4|\xe1\x8f\xb4||"
+"\xe1\x8f\xbd|\xe1\x8f\xb5|\xe1\x8f\xb5||"
+"\xe1\xb2\x80|\xd0\xb2|\xd0\x92||"
+"\xe1\xb2\x81|\xd0\xb4|\xd0\x94||"
+"\xe1\xb2\x82|\xd0\xbe|\xd0\x9e||"
+"\xe1\xb2\x83|\xd1\x81|\xd0\xa1||"
+"\xe1\xb2\x84|\xd1\x82|\xd0\xa2||"
+"\xe1\xb2\x85|\xd1\x82|\xd0\xa2||"
+"\xe1\xb2\x86|\xd1\x8a|\xd0\xaa||"
+"\xe1\xb2\x87|\xd1\xa3|\xd1\xa2||"
+"\xe1\xb2\x88|\xea\x99\x8b|\xea\x99\x8a||"
+"\xe1\xba\x96|h\xcc\xb1|H\xcc\xb1||"
+"\xe1\xba\x97|t\xcc\x88|T\xcc\x88||"
+"\xe1\xba\x98|w\xcc\x8a|W\xcc\x8a||"
+"\xe1\xba\x99|y\xcc\x8a|Y\xcc\x8a||"
+"\xe1\xba\x9a|a\xca\xbe|A\xca\xbe||"
+"\xe1\xba\x9b|\xe1\xb9\xa1|\xe1\xb9\xa0||"
+"\xe1\xba\x9e|ss||\xc3\x9f|"
+"\xe1\xbd\x90|\xcf\x85\xcc\x93|\xce\xa5\xcc\x93||"
+"\xe1\xbd\x92|\xcf\x85\xcc\x93\xcc\x80|\xce\xa5\xcc\x93\xcc\x80||"
+"\xe1\xbd\x94|\xcf\x85\xcc\x93\xcc\x81|\xce\xa5\xcc\x93\xcc\x81||"
+"\xe1\xbd\x96|\xcf\x85\xcc\x93\xcd\x82|\xce\xa5\xcc\x93\xcd\x82||"
+"\xe1\xbe\x80|\xe1\xbc\x80\xce\xb9|\xe1\xbc\x88\xce\x99||"
+"\xe1\xbe\x81|\xe1\xbc\x81\xce\xb9|\xe1\xbc\x89\xce\x99||"
+"\xe1\xbe\x82|\xe1\xbc\x82\xce\xb9|\xe1\xbc\x8a\xce\x99||"
+"\xe1\xbe\x83|\xe1\xbc\x83\xce\xb9|\xe1\xbc\x8b\xce\x99||"
+"\xe1\xbe\x84|\xe1\xbc\x84\xce\xb9|\xe1\xbc\x8c\xce\x99||"
+"\xe1\xbe\x85|\xe1\xbc\x85\xce\xb9|\xe1\xbc\x8d\xce\x99||"
+"\xe1\xbe\x86|\xe1\xbc\x86\xce\xb9|\xe1\xbc\x8e\xce\x99||"
+"\xe1\xbe\x87|\xe1\xbc\x87\xce\xb9|\xe1\xbc\x8f\xce\x99||"
+"\xe1\xbe\x88|\xe1\xbc\x80\xce\xb9|\xe1\xbc\x88\xce\x99|\xe1\xbe\x80|"
+"\xe1\xbe\x89|\xe1\xbc\x81\xce\xb9|\xe1\xbc\x89\xce\x99|\xe1\xbe\x81|"
+"\xe1\xbe\x8a|\xe1\xbc\x82\xce\xb9|\xe1\xbc\x8a\xce\x99|\xe1\xbe\x82|"
+"\xe1\xbe\x8b|\xe1\xbc\x83\xce\xb9|\xe1\xbc\x8b\xce\x99|\xe1\xbe\x83|"
+"\xe1\xbe\x8c|\xe1\xbc\x84\xce\xb9|\xe1\xbc\x8c\xce\x99|\xe1\xbe\x84|"
+"\xe1\xbe\x8d|\xe1\xbc\x85\xce\xb9|\xe1\xbc\x8d\xce\x99|\xe1\xbe\x85|"
+"\xe1\xbe\x8e|\xe1\xbc\x86\xce\xb9|\xe1\xbc\x8e\xce\x99|\xe1\xbe\x86|"
+"\xe1\xbe\x8f|\xe1\xbc\x87\xce\xb9|\xe1\xbc\x8f\xce\x99|\xe1\xbe\x87|"
+"\xe1\xbe\x90|\xe1\xbc\xa0\xce\xb9|\xe1\xbc\xa8\xce\x99||"
+"\xe1\xbe\x91|\xe1\xbc\xa1\xce\xb9|\xe1\xbc\xa9\xce\x99||"
+"\xe1\xbe\x92|\xe1\xbc\xa2\xce\xb9|\xe1\xbc\xaa\xce\x99||"
+"\xe1\xbe\x93|\xe1\xbc\xa3\xce\xb9|\xe1\xbc\xab\xce\x99||"
+"\xe1\xbe\x94|\xe1\xbc\xa4\xce\xb9|\xe1\xbc\xac\xce\x99||"
+"\xe1\xbe\x95|\xe1\xbc\xa5\xce\xb9|\xe1\xbc\xad\xce\x99||"
+"\xe1\xbe\x96|\xe1\xbc\xa6\xce\xb9|\xe1\xbc\xae\xce\x99||"
+"\xe1\xbe\x97|\xe1\xbc\xa7\xce\xb9|\xe1\xbc\xaf\xce\x99||"
+"\xe1\xbe\x98|\xe1\xbc\xa0\xce\xb9|\xe1\xbc\xa8\xce\x99|\xe1\xbe\x90|"
+"\xe1\xbe\x99|\xe1\xbc\xa1\xce\xb9|\xe1\xbc\xa9\xce\x99|\xe1\xbe\x91|"
+"\xe1\xbe\x9a|\xe1\xbc\xa2\xce\xb9|\xe1\xbc\xaa\xce\x99|\xe1\xbe\x92|"
+"\xe1\xbe\x9b|\xe1\xbc\xa3\xce\xb9|\xe1\xbc\xab\xce\x99|\xe1\xbe\x93|"
+"\xe1\xbe\x9c|\xe1\xbc\xa4\xce\xb9|\xe1\xbc\xac\xce\x99|\xe1\xbe\x94|"
+"\xe1\xbe\x9d|\xe1\xbc\xa5\xce\xb9|\xe1\xbc\xad\xce\x99|\xe1\xbe\x95|"
+"\xe1\xbe\x9e|\xe1\xbc\xa6\xce\xb9|\xe1\xbc\xae\xce\x99|\xe1\xbe\x96|"
+"\xe1\xbe\x9f|\xe1\xbc\xa7\xce\xb9|\xe1\xbc\xaf\xce\x99|\xe1\xbe\x97|"
+"\xe1\xbe\xa0|\xe1\xbd\xa0\xce\xb9|\xe1\xbd\xa8\xce\x99||"
+"\xe1\xbe\xa1|\xe1\xbd\xa1\xce\xb9|\xe1\xbd\xa9\xce\x99||"
+"\xe1\xbe\xa2|\xe1\xbd\xa2\xce\xb9|\xe1\xbd\xaa\xce\x99||"
+"\xe1\xbe\xa3|\xe1\xbd\xa3\xce\xb9|\xe1\xbd\xab\xce\x99||"
+"\xe1\xbe\xa4|\xe1\xbd\xa4\xce\xb9|\xe1\xbd\xac\xce\x99||"
+"\xe1\xbe\xa5|\xe1\xbd\xa5\xce\xb9|\xe1\xbd\xad\xce\x99||"
+"\xe1\xbe\xa6|\xe1\xbd\xa6\xce\xb9|\xe1\xbd\xae\xce\x99||"
+"\xe1\xbe\xa7|\xe1\xbd\xa7\xce\xb9|\xe1\xbd\xaf\xce\x99||"
+"\xe1\xbe\xa8|\xe1\xbd\xa0\xce\xb9|\xe1\xbd\xa8\xce\x99|\xe1\xbe\xa0|"
+"\xe1\xbe\xa9|\xe1\xbd\xa1\xce\xb9|\xe1\xbd\xa9\xce\x99|\xe1\xbe\xa1|"
+"\xe1\xbe\xaa|\xe1\xbd\xa2\xce\xb9|\xe1\xbd\xaa\xce\x99|\xe1\xbe\xa2|"
+"\xe1\xbe\xab|\xe1\xbd\xa3\xce\xb9|\xe1\xbd\xab\xce\x99|\xe1\xbe\xa3|"
+"\xe1\xbe\xac|\xe1\xbd\xa4\xce\xb9|\xe1\xbd\xac\xce\x99|\xe1\xbe\xa4|"
+"\xe1\xbe\xad|\xe1\xbd\xa5\xce\xb9|\xe1\xbd\xad\xce\x99|\xe1\xbe\xa5|"
+"\xe1\xbe\xae|\xe1\xbd\xa6\xce\xb9|\xe1\xbd\xae\xce\x99|\xe1\xbe\xa6|"
+"\xe1\xbe\xaf|\xe1\xbd\xa7\xce\xb9|\xe1\xbd\xaf\xce\x99|\xe1\xbe\xa7|"
+"\xe1\xbe\xb2|\xe1\xbd\xb0\xce\xb9|\xe1\xbe\xba\xce\x99||"
+"\xe1\xbe\xb3|\xce\xb1\xce\xb9|\xce\x91\xce\x99||"
+"\xe1\xbe\xb4|\xce\xac\xce\xb9|\xce\x86\xce\x99||"
+"\xe1\xbe\xb6|\xce\xb1\xcd\x82|\xce\x91\xcd\x82||"
+"\xe1\xbe\xb7|\xce\xb1\xcd\x82\xce\xb9|\xce\x91\xcd\x82\xce\x99||"
+"\xe1\xbe\xbc|\xce\xb1\xce\xb9|\xce\x91\xce\x99|\xe1\xbe\xb3|"
+"\xe1\xbe\xbe|\xce\xb9|\xce\x99||"
+"\xe1\xbf\x82|\xe1\xbd\xb4\xce\xb9|\xe1\xbf\x8a\xce\x99||"
+"\xe1\xbf\x83|\xce\xb7\xce\xb9|\xce\x97\xce\x99||"
+"\xe1\xbf\x84|\xce\xae\xce\xb9|\xce\x89\xce\x99||"
+"\xe1\xbf\x86|\xce\xb7\xcd\x82|\xce\x97\xcd\x82||"
+"\xe1\xbf\x87|\xce\xb7\xcd\x82\xce\xb9|\xce\x97\xcd\x82\xce\x99||"
+"\xe1\xbf\x8c|\xce\xb7\xce\xb9|\xce\x97\xce\x99|\xe1\xbf\x83|"
+"\xe1\xbf\x92|\xce\xb9\xcc\x88\xcc\x80|\xce\x99\xcc\x88\xcc\x80||"
+"\xe1\xbf\x93|\xce\xb9\xcc\x88\xcc\x81|\xce\x99\xcc\x88\xcc\x81||"
+"\xe1\xbf\x96|\xce\xb9\xcd\x82|\xce\x99\xcd\x82||"
+"\xe1\xbf\x97|\xce\xb9\xcc\x88\xcd\x82|\xce\x99\xcc\x88\xcd\x82||"
+"\xe1\xbf\xa2|\xcf\x85\xcc\x88\xcc\x80|\xce\xa5\xcc\x88\xcc\x80||"
+"\xe1\xbf\xa3|\xcf\x85\xcc\x88\xcc\x81|\xce\xa5\xcc\x88\xcc\x81||"
+"\xe1\xbf\xa4|\xcf\x81\xcc\x93|\xce\xa1\xcc\x93||"
+"\xe1\xbf\xa6|\xcf\x85\xcd\x82|\xce\xa5\xcd\x82||"
+"\xe1\xbf\xa7|\xcf\x85\xcc\x88\xcd\x82|\xce\xa5\xcc\x88\xcd\x82||"
+"\xe1\xbf\xb2|\xe1\xbd\xbc\xce\xb9|\xe1\xbf\xba\xce\x99||"
+"\xe1\xbf\xb3|\xcf\x89\xce\xb9|\xce\xa9\xce\x99||"
+"\xe1\xbf\xb4|\xcf\x8e\xce\xb9|\xce\x8f\xce\x99||"
+"\xe1\xbf\xb6|\xcf\x89\xcd\x82|\xce\xa9\xcd\x82||"
+"\xe1\xbf\xb7|\xcf\x89\xcd\x82\xce\xb9|\xce\xa9\xcd\x82\xce\x99||"
+"\xe1\xbf\xbc|\xcf\x89\xce\xb9|\xce\xa9\xce\x99|\xe1\xbf\xb3|"
+"\xe2\x84\xa6|\xcf\x89||\xcf\x89|"
+"\xe2\x84\xaa|k||k|"
+"\xe2\x84\xab|\xc3\xa5||\xc3\xa5|"
+"\xea\xad\xb0|\xe1\x8e\xa0|\xe1\x8e\xa0||"
+"\xea\xad\xb1|\xe1\x8e\xa1|\xe1\x8e\xa1||"
+"\xea\xad\xb2|\xe1\x8e\xa2|\xe1\x8e\xa2||"
+"\xea\xad\xb3|\xe1\x8e\xa3|\xe1\x8e\xa3||"
+"\xea\xad\xb4|\xe1\x8e\xa4|\xe1\x8e\xa4||"
+"\xea\xad\xb5|\xe1\x8e\xa5|\xe1\x8e\xa5||"
+"\xea\xad\xb6|\xe1\x8e\xa6|\xe1\x8e\xa6||"
+"\xea\xad\xb7|\xe1\x8e\xa7|\xe1\x8e\xa7||"
+"\xea\xad\xb8|\xe1\x8e\xa8|\xe1\x8e\xa8||"
+"\xea\xad\xb9|\xe1\x8e\xa9|\xe1\x8e\xa9||"
+"\xea\xad\xba|\xe1\x8e\xaa|\xe1\x8e\xaa||"
+"\xea\xad\xbb|\xe1\x8e\xab|\xe1\x8e\xab||"
+"\xea\xad\xbc|\xe1\x8e\xac|\xe1\x8e\xac||"
+"\xea\xad\xbd|\xe1\x8e\xad|\xe1\x8e\xad||"
+"\xea\xad\xbe|\xe1\x8e\xae|\xe1\x8e\xae||"
+"\xea\xad\xbf|\xe1\x8e\xaf|\xe1\x8e\xaf||"
+"\xea\xae\x80|\xe1\x8e\xb0|\xe1\x8e\xb0||"
+"\xea\xae\x81|\xe1\x8e\xb1|\xe1\x8e\xb1||"
+"\xea\xae\x82|\xe1\x8e\xb2|\xe1\x8e\xb2||"
+"\xea\xae\x83|\xe1\x8e\xb3|\xe1\x8e\xb3||"
+"\xea\xae\x84|\xe1\x8e\xb4|\xe1\x8e\xb4||"
+"\xea\xae\x85|\xe1\x8e\xb5|\xe1\x8e\xb5||"
+"\xea\xae\x86|\xe1\x8e\xb6|\xe1\x8e\xb6||"
+"\xea\xae\x87|\xe1\x8e\xb7|\xe1\x8e\xb7||"
+"\xea\xae\x88|\xe1\x8e\xb8|\xe1\x8e\xb8||"
+"\xea\xae\x89|\xe1\x8e\xb9|\xe1\x8e\xb9||"
+"\xea\xae\x8a|\xe1\x8e\xba|\xe1\x8e\xba||"
+"\xea\xae\x8b|\xe1\x8e\xbb|\xe1\x8e\xbb||"
+"\xea\xae\x8c|\xe1\x8e\xbc|\xe1\x8e\xbc||"
+"\xea\xae\x8d|\xe1\x8e\xbd|\xe1\x8e\xbd||"
+"\xea\xae\x8e|\xe1\x8e\xbe|\xe1\x8e\xbe||"
+"\xea\xae\x8f|\xe1\x8e\xbf|\xe1\x8e\xbf||"
+"\xea\xae\x90|\xe1\x8f\x80|\xe1\x8f\x80||"
+"\xea\xae\x91|\xe1\x8f\x81|\xe1\x8f\x81||"
+"\xea\xae\x92|\xe1\x8f\x82|\xe1\x8f\x82||"
+"\xea\xae\x93|\xe1\x8f\x83|\xe1\x8f\x83||"
+"\xea\xae\x94|\xe1\x8f\x84|\xe1\x8f\x84||"
+"\xea\xae\x95|\xe1\x8f\x85|\xe1\x8f\x85||"
+"\xea\xae\x96|\xe1\x8f\x86|\xe1\x8f\x86||"
+"\xea\xae\x97|\xe1\x8f\x87|\xe1\x8f\x87||"
+"\xea\xae\x98|\xe1\x8f\x88|\xe1\x8f\x88||"
+"\xea\xae\x99|\xe1\x8f\x89|\xe1\x8f\x89||"
+"\xea\xae\x9a|\xe1\x8f\x8a|\xe1\x8f\x8a||"
+"\xea\xae\x9b|\xe1\x8f\x8b|\xe1\x8f\x8b||"
+"\xea\xae\x9c|\xe1\x8f\x8c|\xe1\x8f\x8c||"
+"\xea\xae\x9d|\xe1\x8f\x8d|\xe1\x8f\x8d||"
+"\xea\xae\x9e|\xe1\x8f\x8e|\xe1\x8f\x8e||"
+"\xea\xae\x9f|\xe1\x8f\x8f|\xe1\x8f\x8f||"
+"\xea\xae\xa0|\xe1\x8f\x90|\xe1\x8f\x90||"
+"\xea\xae\xa1|\xe1\x8f\x91|\xe1\x8f\x91||"
+"\xea\xae\xa2|\xe1\x8f\x92|\xe1\x8f\x92||"
+"\xea\xae\xa3|\xe1\x8f\x93|\xe1\x8f\x93||"
+"\xea\xae\xa4|\xe1\x8f\x94|\xe1\x8f\x94||"
+"\xea\xae\xa5|\xe1\x8f\x95|\xe1\x8f\x95||"
+"\xea\xae\xa6|\xe1\x8f\x96|\xe1\x8f\x96||"
+"\xea\xae\xa7|\xe1\x8f\x97|\xe1\x8f\x97||"
+"\xea\xae\xa8|\xe1\x8f\x98|\xe1\x8f\x98||"
+"\xea\xae\xa9|\xe1\x8f\x99|\xe1\x8f\x99||"
+"\xea\xae\xaa|\xe1\x8f\x9a|\xe1\x8f\x9a||"
+"\xea\xae\xab|\xe1\x8f\x9b|\xe1\x8f\x9b||"
+"\xea\xae\xac|\xe1\x8f\x9c|\xe1\x8f\x9c||"
+"\xea\xae\xad|\xe1\x8f\x9d|\xe1\x8f\x9d||"
+"\xea\xae\xae|\xe1\x8f\x9e|\xe1\x8f\x9e||"
+"\xea\xae\xaf|\xe1\x8f\x9f|\xe1\x8f\x9f||"
+"\xea\xae\xb0|\xe1\x8f\xa0|\xe1\x8f\xa0||"
+"\xea\xae\xb1|\xe1\x8f\xa1|\xe1\x8f\xa1||"
+"\xea\xae\xb2|\xe1\x8f\xa2|\xe1\x8f\xa2||"
+"\xea\xae\xb3|\xe1\x8f\xa3|\xe1\x8f\xa3||"
+"\xea\xae\xb4|\xe1\x8f\xa4|\xe1\x8f\xa4||"
+"\xea\xae\xb5|\xe1\x8f\xa5|\xe1\x8f\xa5||"
+"\xea\xae\xb6|\xe1\x8f\xa6|\xe1\x8f\xa6||"
+"\xea\xae\xb7|\xe1\x8f\xa7|\xe1\x8f\xa7||"
+"\xea\xae\xb8|\xe1\x8f\xa8|\xe1\x8f\xa8||"
+"\xea\xae\xb9|\xe1\x8f\xa9|\xe1\x8f\xa9||"
+"\xea\xae\xba|\xe1\x8f\xaa|\xe1\x8f\xaa||"
+"\xea\xae\xbb|\xe1\x8f\xab|\xe1\x8f\xab||"
+"\xea\xae\xbc|\xe1\x8f\xac|\xe1\x8f\xac||"
+"\xea\xae\xbd|\xe1\x8f\xad|\xe1\x8f\xad||"
+"\xea\xae\xbe|\xe1\x8f\xae|\xe1\x8f\xae||"
+"\xea\xae\xbf|\xe1\x8f\xaf|\xe1\x8f\xaf||"
+"\xef\xac\x80|ff|FF||"
+"\xef\xac\x81|fi|FI||"
+"\xef\xac\x82|fl|FL||"
+"\xef\xac\x83|ffi|FFI||"
+"\xef\xac\x84|ffl|FFL||"
+"\xef\xac\x85|st|ST||"
+"\xef\xac\x86|st|ST||"
+"\xef\xac\x93|\xd5\xb4\xd5\xb6|\xd5\x84\xd5\x86||"
+"\xef\xac\x94|\xd5\xb4\xd5\xa5|\xd5\x84\xd4\xb5||"
+"\xef\xac\x95|\xd5\xb4\xd5\xab|\xd5\x84\xd4\xbb||"
+"\xef\xac\x96|\xd5\xbe\xd5\xb6|\xd5\x8e\xd5\x86||"
+"\xef\xac\x97|\xd5\xb4\xd5\xad|\xd5\x84\xd4\xbd||"
+
+//--Autogenerated -- end of section automatically generated
+;
+
+class CaseConverter : public ICaseConverter {
+	// Maximum length of a case conversion result is 6 bytes in UTF-8
+	enum { maxConversionLength=6 };
+	struct ConversionString {
+		char conversion[maxConversionLength+1];
+		ConversionString() noexcept : conversion{} {
+		}
+	};
+	// Conversions are initially store in a vector of structs but then decomposed into
+	// parallel arrays as that is about 10% faster to search.
+	struct CharacterConversion {
+		int character;
+		ConversionString conversion;
+		CharacterConversion() noexcept : character(0) {
+			// Empty case: NUL -> "".
+		}
+		CharacterConversion(int character_, std::string_view conversion_) noexcept : character(character_) {
+			assert(conversion_.length() <= maxConversionLength);
+			conversion_.copy(conversion.conversion, conversion_.length());
+		}
+		bool operator<(const CharacterConversion &other) const noexcept {
+			return character < other.character;
+		}
+	};
+	typedef std::vector<CharacterConversion> CharacterToConversion;
+	CharacterToConversion characterToConversion;
+	// The parallel arrays
+	std::vector<int> characters;
+	std::vector<ConversionString> conversions;
+
+public:
+	CaseConverter() noexcept {
+	}
+	virtual ~CaseConverter() = default;
+	bool Initialised() const noexcept {
+		return !characters.empty();
+	}
+	void Add(int character, const char *conversion) {
+		characterToConversion.emplace_back(character, conversion);
+	}
+	const char *Find(int character) {
+		const std::vector<int>::iterator it = std::lower_bound(characters.begin(), characters.end(), character);
+		if (it == characters.end())
+			return nullptr;
+		else if (*it == character)
+			return conversions[it - characters.begin()].conversion;
+		else
+			return nullptr;
+	}
+	size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed) override {
+		size_t lenConverted = 0;
+		size_t mixedPos = 0;
+		unsigned char bytes[UTF8MaxBytes + 1]{};
+		while (mixedPos < lenMixed) {
+			const unsigned char leadByte = mixed[mixedPos];
+			const char *caseConverted = nullptr;
+			size_t lenMixedChar = 1;
+			if (UTF8IsAscii(leadByte)) {
+				caseConverted = Find(leadByte);
+			} else {
+				bytes[0] = leadByte;
+				const int widthCharBytes = UTF8BytesOfLead[leadByte];
+				for (int b=1; b<widthCharBytes; b++) {
+					bytes[b] = (mixedPos+b < lenMixed) ? mixed[mixedPos+b] : 0;
+				}
+				const int classified = UTF8Classify(bytes, widthCharBytes);
+				if (!(classified & UTF8MaskInvalid)) {
+					// valid UTF-8
+					lenMixedChar = classified & UTF8MaskWidth;
+					const int character = UnicodeFromUTF8(bytes);
+					caseConverted = Find(character);
+				}
+			}
+			if (caseConverted) {
+				// Character has a conversion so copy that conversion in
+				while (*caseConverted) {
+					converted[lenConverted++] = *caseConverted++;
+					if (lenConverted >= sizeConverted)
+						return 0;
+				}
+			} else {
+				// Character has no conversion so copy the input to output
+				for (size_t i=0; i<lenMixedChar; i++) {
+					converted[lenConverted++] = mixed[mixedPos+i];
+					if (lenConverted >= sizeConverted)
+						return 0;
+				}
+			}
+			mixedPos += lenMixedChar;
+		}
+		return lenConverted;
+	}
+	void FinishedAdding() {
+		std::sort(characterToConversion.begin(), characterToConversion.end());
+		characters.reserve(characterToConversion.size());
+		conversions.reserve(characterToConversion.size());
+		for (const CharacterConversion &chConv : characterToConversion) {
+			characters.push_back(chConv.character);
+			conversions.push_back(chConv.conversion);
+		}
+		// Empty the original calculated data completely
+		CharacterToConversion().swap(characterToConversion);
+	}
+};
+
+CaseConverter caseConvFold;
+CaseConverter caseConvUp;
+CaseConverter caseConvLow;
+
+void AddSymmetric(enum CaseConversion conversion, int lower,int upper) {
+	char lowerUTF8[UTF8MaxBytes+1];
+	UTF8FromUTF32Character(lower, lowerUTF8);
+	char upperUTF8[UTF8MaxBytes+1];
+	UTF8FromUTF32Character(upper, upperUTF8);
+
+	switch (conversion) {
+	case CaseConversionFold:
+		caseConvFold.Add(upper, lowerUTF8);
+		break;
+	case CaseConversionUpper:
+		caseConvUp.Add(lower, upperUTF8);
+		break;
+	case CaseConversionLower:
+		caseConvLow.Add(upper, lowerUTF8);
+		break;
+	}
+}
+
+void SetupConversions(enum CaseConversion conversion) {
+	// First initialize for the symmetric ranges
+	for (size_t i=0; i<std::size(symmetricCaseConversionRanges);) {
+		const int lower = symmetricCaseConversionRanges[i++];
+		const int upper = symmetricCaseConversionRanges[i++];
+		const int length = symmetricCaseConversionRanges[i++];
+		const int pitch = symmetricCaseConversionRanges[i++];
+		for (int j=0; j<length*pitch; j+=pitch) {
+			AddSymmetric(conversion, lower+j, upper+j);
+		}
+	}
+	// Add the symmetric singletons
+	for (size_t i=0; i<std::size(symmetricCaseConversions);) {
+		const int lower = symmetricCaseConversions[i++];
+		const int upper = symmetricCaseConversions[i++];
+		AddSymmetric(conversion, lower, upper);
+	}
+	// Add the complex cases
+	const char *sComplex = complexCaseConversions;
+	while (*sComplex) {
+		// Longest ligature is 3 character so 5 for safety
+		constexpr size_t lenUTF8 = 5*UTF8MaxBytes+1;
+		unsigned char originUTF8[lenUTF8]{};
+		char foldedUTF8[lenUTF8]{};
+		char lowerUTF8[lenUTF8]{};
+		char upperUTF8[lenUTF8]{};
+		size_t i = 0;
+		while (*sComplex && *sComplex != '|') {
+			originUTF8[i++] = *sComplex;
+			sComplex++;
+		}
+		sComplex++;
+		originUTF8[i] = 0;
+		i = 0;
+		while (*sComplex && *sComplex != '|') {
+			foldedUTF8[i++] = *sComplex;
+			sComplex++;
+		}
+		sComplex++;
+		foldedUTF8[i] = 0;
+		i = 0;
+		while (*sComplex && *sComplex != '|') {
+			upperUTF8[i++] = *sComplex;
+			sComplex++;
+		}
+		sComplex++;
+		upperUTF8[i] = 0;
+		i = 0;
+		while (*sComplex && *sComplex != '|') {
+			lowerUTF8[i++] = *sComplex;
+			sComplex++;
+		}
+		sComplex++;
+		lowerUTF8[i] = 0;
+
+		const int character = UnicodeFromUTF8(originUTF8);
+
+		if (conversion == CaseConversionFold && foldedUTF8[0]) {
+			caseConvFold.Add(character, foldedUTF8);
+		}
+
+		if (conversion == CaseConversionUpper && upperUTF8[0]) {
+			caseConvUp.Add(character, upperUTF8);
+		}
+
+		if (conversion == CaseConversionLower && lowerUTF8[0]) {
+			caseConvLow.Add(character, lowerUTF8);
+		}
+	}
+
+	switch (conversion) {
+	case CaseConversionFold:
+		caseConvFold.FinishedAdding();
+		break;
+	case CaseConversionUpper:
+		caseConvUp.FinishedAdding();
+		break;
+	case CaseConversionLower:
+		caseConvLow.FinishedAdding();
+		break;
+	}
+}
+
+CaseConverter *ConverterForConversion(enum CaseConversion conversion) noexcept {
+	switch (conversion) {
+	case CaseConversionFold:
+		return &caseConvFold;
+	case CaseConversionUpper:
+		return &caseConvUp;
+	case CaseConversionLower:
+		return &caseConvLow;
+	}
+	return nullptr;
+}
+
+}
+
+namespace Scintilla {
+
+ICaseConverter *ConverterFor(enum CaseConversion conversion) {
+	CaseConverter *pCaseConv = ConverterForConversion(conversion);
+	if (!pCaseConv->Initialised())
+		SetupConversions(conversion);
+	return pCaseConv;
+}
+
+const char *CaseConvert(int character, enum CaseConversion conversion) {
+	CaseConverter *pCaseConv = ConverterForConversion(conversion);
+	if (!pCaseConv->Initialised())
+		SetupConversions(conversion);
+	return pCaseConv->Find(character);
+}
+
+size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed, enum CaseConversion conversion) {
+	CaseConverter *pCaseConv = ConverterForConversion(conversion);
+	if (!pCaseConv->Initialised())
+		SetupConversions(conversion);
+	return pCaseConv->CaseConvertString(converted, sizeConverted, mixed, lenMixed);
+}
+
+std::string CaseConvertString(const std::string &s, enum CaseConversion conversion) {
+	std::string retMapped(s.length() * maxExpansionCaseConversion, 0);
+	const size_t lenMapped = CaseConvertString(&retMapped[0], retMapped.length(), s.c_str(), s.length(),
+		conversion);
+	retMapped.resize(lenMapped);
+	return retMapped;
+}
+
+}
diff --git a/Pythonwin/Scintilla/src/CaseConvert.h b/Pythonwin/Scintilla/src/CaseConvert.h
new file mode 100644
index 000000000..e3057c841
--- /dev/null
+++ b/Pythonwin/Scintilla/src/CaseConvert.h
@@ -0,0 +1,46 @@
+// Scintilla source code edit control
+// Encoding: UTF-8
+/** @file CaseConvert.h
+ ** Performs Unicode case conversions.
+ ** Does not handle locale-sensitive case conversion.
+ **/
+// Copyright 2013 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef CASECONVERT_H
+#define CASECONVERT_H
+
+namespace Scintilla {
+
+enum CaseConversion {
+	CaseConversionFold,
+	CaseConversionUpper,
+	CaseConversionLower
+};
+
+class ICaseConverter {
+public:
+	virtual size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed) = 0;
+};
+
+ICaseConverter *ConverterFor(enum CaseConversion conversion);
+
+// Returns a UTF-8 string. Empty when no conversion
+const char *CaseConvert(int character, enum CaseConversion conversion);
+
+// When performing CaseConvertString, the converted value may be up to 3 times longer than the input.
+// Ligatures are often decomposed into multiple characters and long cases include:
+// � "\xce\x90" folds to ϊ� "\xce\xb9\xcc\x88\xcc\x81"
+constexpr size_t maxExpansionCaseConversion = 3;
+
+// Converts a mixed case string using a particular conversion.
+// Result may be a different length to input and the length is the return value.
+// If there is not enough space then 0 is returned.
+size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed, enum CaseConversion conversion);
+
+// Converts a mixed case string using a particular conversion.
+std::string CaseConvertString(const std::string &s, enum CaseConversion conversion);
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/CaseFolder.cxx b/Pythonwin/Scintilla/src/CaseFolder.cxx
new file mode 100644
index 000000000..bce593a98
--- /dev/null
+++ b/Pythonwin/Scintilla/src/CaseFolder.cxx
@@ -0,0 +1,66 @@
+// Scintilla source code edit control
+/** @file CaseFolder.cxx
+ ** Classes for case folding.
+ **/
+// Copyright 1998-2013 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <stdexcept>
+#include <vector>
+#include <algorithm>
+
+#include "CaseFolder.h"
+#include "CaseConvert.h"
+
+using namespace Scintilla;
+
+CaseFolder::~CaseFolder() {
+}
+
+CaseFolderTable::CaseFolderTable() noexcept : mapping{}  {
+	for (size_t iChar=0; iChar<sizeof(mapping); iChar++) {
+		mapping[iChar] = static_cast<char>(iChar);
+	}
+}
+
+CaseFolderTable::~CaseFolderTable() {
+}
+
+size_t CaseFolderTable::Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) {
+	if (lenMixed > sizeFolded) {
+		return 0;
+	} else {
+		for (size_t i=0; i<lenMixed; i++) {
+			folded[i] = mapping[static_cast<unsigned char>(mixed[i])];
+		}
+		return lenMixed;
+	}
+}
+
+void CaseFolderTable::SetTranslation(char ch, char chTranslation) noexcept {
+	mapping[static_cast<unsigned char>(ch)] = chTranslation;
+}
+
+void CaseFolderTable::StandardASCII() noexcept {
+	for (size_t iChar=0; iChar<sizeof(mapping); iChar++) {
+		if (iChar >= 'A' && iChar <= 'Z') {
+			mapping[iChar] = static_cast<char>(iChar - 'A' + 'a');
+		} else {
+			mapping[iChar] = static_cast<char>(iChar);
+		}
+	}
+}
+
+CaseFolderUnicode::CaseFolderUnicode() {
+	StandardASCII();
+	converter = ConverterFor(CaseConversionFold);
+}
+
+size_t CaseFolderUnicode::Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) {
+	if ((lenMixed == 1) && (sizeFolded > 0)) {
+		folded[0] = mapping[static_cast<unsigned char>(mixed[0])];
+		return 1;
+	} else {
+		return converter->CaseConvertString(folded, sizeFolded, mixed, lenMixed);
+	}
+}
diff --git a/Pythonwin/Scintilla/src/CaseFolder.h b/Pythonwin/Scintilla/src/CaseFolder.h
new file mode 100644
index 000000000..966069bc4
--- /dev/null
+++ b/Pythonwin/Scintilla/src/CaseFolder.h
@@ -0,0 +1,41 @@
+// Scintilla source code edit control
+/** @file CaseFolder.h
+ ** Classes for case folding.
+ **/
+// Copyright 1998-2013 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef CASEFOLDER_H
+#define CASEFOLDER_H
+
+namespace Scintilla {
+
+class CaseFolder {
+public:
+	virtual ~CaseFolder();
+	virtual size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) = 0;
+};
+
+class CaseFolderTable : public CaseFolder {
+protected:
+	char mapping[256];
+public:
+	CaseFolderTable() noexcept;
+	~CaseFolderTable() override;
+	size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) override;
+	void SetTranslation(char ch, char chTranslation) noexcept;
+	void StandardASCII() noexcept;
+};
+
+class ICaseConverter;
+
+class CaseFolderUnicode : public CaseFolderTable {
+	ICaseConverter *converter;
+public:
+	CaseFolderUnicode();
+	size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) override;
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/Catalogue.cxx b/Pythonwin/Scintilla/src/Catalogue.cxx
new file mode 100644
index 000000000..7f2415e0b
--- /dev/null
+++ b/Pythonwin/Scintilla/src/Catalogue.cxx
@@ -0,0 +1,197 @@
+// Scintilla source code edit control
+/** @file Catalogue.cxx
+ ** Lexer infrastructure.
+ ** Contains a list of LexerModules which can be searched to find a module appropriate for a
+ ** particular language.
+ **/
+// Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+
+#include <stdexcept>
+#include <vector>
+
+#include "ILexer.h"
+#include "Scintilla.h"
+#include "SciLexer.h"
+
+#include "LexerModule.h"
+#include "CatalogueModules.h"
+#include "Catalogue.h"
+
+using namespace Scintilla;
+
+namespace {
+
+CatalogueModules catalogueDefault;
+
+}
+
+const LexerModule *Catalogue::Find(int language) {
+	return catalogueDefault.Find(language);
+}
+
+const LexerModule *Catalogue::Find(const char *languageName) noexcept {
+	return catalogueDefault.Find(languageName);
+}
+
+void Catalogue::AddLexerModule(LexerModule *plm) {
+	catalogueDefault.AddLexerModule(plm);
+}
+
+// To add or remove a lexer, add or remove its file and run LexGen.py.
+
+// Force a reference to all of the Scintilla lexers so that the linker will
+// not remove the code of the lexers.
+int Scintilla_LinkLexers() {
+
+	static int initialised = 0;
+	if (initialised)
+		return 0;
+	initialised = 1;
+
+#if !defined(SCI_EMPTYCATALOGUE)
+
+// Shorten the code that declares a lexer and ensures it is linked in by calling a method.
+#define LINK_LEXER(lexer) extern LexerModule lexer; catalogueDefault.AddLexerModule(&lexer);
+
+//++Autogenerated -- run scripts/LexGen.py to regenerate
+//**\(\tLINK_LEXER(\*);\n\)
+	LINK_LEXER(lmA68k);
+	LINK_LEXER(lmAbaqus);
+	LINK_LEXER(lmAda);
+	LINK_LEXER(lmAPDL);
+	LINK_LEXER(lmAs);
+	LINK_LEXER(lmAsm);
+	LINK_LEXER(lmAsn1);
+	LINK_LEXER(lmASY);
+	LINK_LEXER(lmAU3);
+	LINK_LEXER(lmAVE);
+	LINK_LEXER(lmAVS);
+	LINK_LEXER(lmBaan);
+	LINK_LEXER(lmBash);
+	LINK_LEXER(lmBatch);
+	LINK_LEXER(lmBibTeX);
+	LINK_LEXER(lmBlitzBasic);
+	LINK_LEXER(lmBullant);
+	LINK_LEXER(lmCaml);
+	LINK_LEXER(lmCIL);
+	LINK_LEXER(lmClw);
+	LINK_LEXER(lmClwNoCase);
+	LINK_LEXER(lmCmake);
+	LINK_LEXER(lmCOBOL);
+	LINK_LEXER(lmCoffeeScript);
+	LINK_LEXER(lmConf);
+	LINK_LEXER(lmCPP);
+	LINK_LEXER(lmCPPNoCase);
+	LINK_LEXER(lmCsound);
+	LINK_LEXER(lmCss);
+	LINK_LEXER(lmD);
+	LINK_LEXER(lmDataflex);
+	LINK_LEXER(lmDiff);
+	LINK_LEXER(lmDMAP);
+	LINK_LEXER(lmDMIS);
+	LINK_LEXER(lmECL);
+	LINK_LEXER(lmEDIFACT);
+	LINK_LEXER(lmEiffel);
+	LINK_LEXER(lmEiffelkw);
+	LINK_LEXER(lmErlang);
+	LINK_LEXER(lmErrorList);
+	LINK_LEXER(lmESCRIPT);
+	LINK_LEXER(lmF77);
+	LINK_LEXER(lmFlagShip);
+	LINK_LEXER(lmForth);
+	LINK_LEXER(lmFortran);
+	LINK_LEXER(lmFreeBasic);
+	LINK_LEXER(lmGAP);
+	LINK_LEXER(lmGui4Cli);
+	LINK_LEXER(lmHaskell);
+	LINK_LEXER(lmHollywood);
+	LINK_LEXER(lmHTML);
+	LINK_LEXER(lmIHex);
+	LINK_LEXER(lmIndent);
+	LINK_LEXER(lmInno);
+	LINK_LEXER(lmJSON);
+	LINK_LEXER(lmKix);
+	LINK_LEXER(lmKVIrc);
+	LINK_LEXER(lmLatex);
+	LINK_LEXER(lmLISP);
+	LINK_LEXER(lmLiterateHaskell);
+	LINK_LEXER(lmLot);
+	LINK_LEXER(lmLout);
+	LINK_LEXER(lmLua);
+	LINK_LEXER(lmMagikSF);
+	LINK_LEXER(lmMake);
+	LINK_LEXER(lmMarkdown);
+	LINK_LEXER(lmMatlab);
+	LINK_LEXER(lmMaxima);
+	LINK_LEXER(lmMETAPOST);
+	LINK_LEXER(lmMMIXAL);
+	LINK_LEXER(lmModula);
+	LINK_LEXER(lmMSSQL);
+	LINK_LEXER(lmMySQL);
+	LINK_LEXER(lmNim);
+	LINK_LEXER(lmNimrod);
+	LINK_LEXER(lmNncrontab);
+	LINK_LEXER(lmNsis);
+	LINK_LEXER(lmNull);
+	LINK_LEXER(lmOctave);
+	LINK_LEXER(lmOpal);
+	LINK_LEXER(lmOScript);
+	LINK_LEXER(lmPascal);
+	LINK_LEXER(lmPB);
+	LINK_LEXER(lmPerl);
+	LINK_LEXER(lmPHPSCRIPT);
+	LINK_LEXER(lmPLM);
+	LINK_LEXER(lmPO);
+	LINK_LEXER(lmPOV);
+	LINK_LEXER(lmPowerPro);
+	LINK_LEXER(lmPowerShell);
+	LINK_LEXER(lmProgress);
+	LINK_LEXER(lmProps);
+	LINK_LEXER(lmPS);
+	LINK_LEXER(lmPureBasic);
+	LINK_LEXER(lmPython);
+	LINK_LEXER(lmR);
+	LINK_LEXER(lmRaku);
+	LINK_LEXER(lmREBOL);
+	LINK_LEXER(lmRegistry);
+	LINK_LEXER(lmRuby);
+	LINK_LEXER(lmRust);
+	LINK_LEXER(lmSAS);
+	LINK_LEXER(lmScriptol);
+	LINK_LEXER(lmSmalltalk);
+	LINK_LEXER(lmSML);
+	LINK_LEXER(lmSorc);
+	LINK_LEXER(lmSpecman);
+	LINK_LEXER(lmSpice);
+	LINK_LEXER(lmSQL);
+	LINK_LEXER(lmSrec);
+	LINK_LEXER(lmStata);
+	LINK_LEXER(lmSTTXT);
+	LINK_LEXER(lmTACL);
+	LINK_LEXER(lmTADS3);
+	LINK_LEXER(lmTAL);
+	LINK_LEXER(lmTCL);
+	LINK_LEXER(lmTCMD);
+	LINK_LEXER(lmTEHex);
+	LINK_LEXER(lmTeX);
+	LINK_LEXER(lmTxt2tags);
+	LINK_LEXER(lmVB);
+	LINK_LEXER(lmVBScript);
+	LINK_LEXER(lmVerilog);
+	LINK_LEXER(lmVHDL);
+	LINK_LEXER(lmVisualProlog);
+	LINK_LEXER(lmX12);
+	LINK_LEXER(lmXML);
+	LINK_LEXER(lmYAML);
+
+//--Autogenerated -- end of automatically generated section
+
+#endif
+
+	return 1;
+}
diff --git a/Pythonwin/Scintilla/src/Catalogue.h b/Pythonwin/Scintilla/src/Catalogue.h
new file mode 100644
index 000000000..05a1f1d29
--- /dev/null
+++ b/Pythonwin/Scintilla/src/Catalogue.h
@@ -0,0 +1,24 @@
+// Scintilla source code edit control
+/** @file Catalogue.h
+ ** Lexer infrastructure.
+ ** Contains a list of LexerModules which can be searched to find a module appropriate for a
+ ** particular language.
+ **/
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef CATALOGUE_H
+#define CATALOGUE_H
+
+namespace Scintilla {
+
+class Catalogue {
+public:
+	static const LexerModule *Find(int language);
+	static const LexerModule *Find(const char *languageName) noexcept;
+	static void AddLexerModule(LexerModule *plm);
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/CellBuffer.cxx b/Pythonwin/Scintilla/src/CellBuffer.cxx
index 0e9ae6950..636f9d2a7 100644
--- a/Pythonwin/Scintilla/src/CellBuffer.cxx
+++ b/Pythonwin/Scintilla/src/CellBuffer.cxx
@@ -5,344 +5,327 @@
 // Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <stdarg.h>
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cstdio>
+#include <cstdarg>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <algorithm>
+#include <memory>
 
 #include "Platform.h"
 
 #include "Scintilla.h"
+#include "Position.h"
 #include "SplitVector.h"
 #include "Partitioning.h"
 #include "CellBuffer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-MarkerHandleSet::MarkerHandleSet() {
-	root = 0;
-}
-
-MarkerHandleSet::~MarkerHandleSet() {
-	MarkerHandleNumber *mhn = root;
-	while (mhn) {
-		MarkerHandleNumber *mhnToFree = mhn;
-		mhn = mhn->next;
-		delete mhnToFree;
+#include "UniConversion.h"
+
+namespace Scintilla {
+
+struct CountWidths {
+	// Measures the number of characters in a string divided into those
+	// from the Base Multilingual Plane and those from other planes.
+	Sci::Position countBasePlane;
+	Sci::Position countOtherPlanes;
+	CountWidths(Sci::Position countBasePlane_=0, Sci::Position countOtherPlanes_=0) noexcept :
+		countBasePlane(countBasePlane_),
+		countOtherPlanes(countOtherPlanes_) {
 	}
-	root = 0;
-}
-
-int MarkerHandleSet::Length() const {
-	int c = 0;
-	MarkerHandleNumber *mhn = root;
-	while (mhn) {
-		c++;
-		mhn = mhn->next;
+	CountWidths operator-() const noexcept {
+		return CountWidths(-countBasePlane , -countOtherPlanes);
 	}
-	return c;
-}
-
-int MarkerHandleSet::NumberFromHandle(int handle) const {
-	MarkerHandleNumber *mhn = root;
-	while (mhn) {
-		if (mhn->handle == handle) {
-			return mhn->number;
-		}
-		mhn = mhn->next;
+	Sci::Position WidthUTF32() const noexcept {
+		// All code points take one code unit in UTF-32.
+		return countBasePlane + countOtherPlanes;
 	}
-	return - 1;
-}
-
-int MarkerHandleSet::MarkValue() const {
-	unsigned int m = 0;
-	MarkerHandleNumber *mhn = root;
-	while (mhn) {
-		m |= (1 << mhn->number);
-		mhn = mhn->next;
+	Sci::Position WidthUTF16() const noexcept {
+		// UTF-16 takes 2 code units for other planes
+		return countBasePlane + 2 * countOtherPlanes;
 	}
-	return m;
-}
-
-bool MarkerHandleSet::Contains(int handle) const {
-	MarkerHandleNumber *mhn = root;
-	while (mhn) {
-		if (mhn->handle == handle) {
-			return true;
-		}
-		mhn = mhn->next;
-	}
-	return false;
-}
-
-bool MarkerHandleSet::InsertHandle(int handle, int markerNum) {
-	MarkerHandleNumber *mhn = new MarkerHandleNumber;
-	if (!mhn)
-		return false;
-	mhn->handle = handle;
-	mhn->number = markerNum;
-	mhn->next = root;
-	root = mhn;
-	return true;
-}
-
-void MarkerHandleSet::RemoveHandle(int handle) {
-	MarkerHandleNumber **pmhn = &root;
-	while (*pmhn) {
-		MarkerHandleNumber *mhn = *pmhn;
-		if (mhn->handle == handle) {
-			*pmhn = mhn->next;
-			delete mhn;
-			return;
-		}
-		pmhn = &((*pmhn)->next);
-	}
-}
-
-bool MarkerHandleSet::RemoveNumber(int markerNum) {
-	bool performedDeletion = false;
-	MarkerHandleNumber **pmhn = &root;
-	while (*pmhn) {
-		MarkerHandleNumber *mhn = *pmhn;
-		if (mhn->number == markerNum) {
-			*pmhn = mhn->next;
-			delete mhn;
-			performedDeletion = true;
+	void CountChar(int lenChar) noexcept {
+		if (lenChar == 4) {
+			countOtherPlanes++;
 		} else {
-			pmhn = &((*pmhn)->next);
+			countBasePlane++;
 		}
 	}
-	return performedDeletion;
-}
+};
+
+class ILineVector {
+public:
+	virtual void Init() = 0;
+	virtual void SetPerLine(PerLine *pl) noexcept = 0;
+	virtual void InsertText(Sci::Line line, Sci::Position delta) noexcept = 0;
+	virtual void InsertLine(Sci::Line line, Sci::Position position, bool lineStart) = 0;
+	virtual void InsertLines(Sci::Line line, const Sci::Position *positions, size_t lines, bool lineStart) = 0;
+	virtual void SetLineStart(Sci::Line line, Sci::Position position) noexcept = 0;
+	virtual void RemoveLine(Sci::Line line) = 0;
+	virtual Sci::Line Lines() const noexcept = 0;
+	virtual Sci::Line LineFromPosition(Sci::Position pos) const noexcept = 0;
+	virtual Sci::Position LineStart(Sci::Line line) const noexcept = 0;
+	virtual void InsertCharacters(Sci::Line line, CountWidths delta) noexcept = 0;
+	virtual void SetLineCharactersWidth(Sci::Line line, CountWidths width) noexcept = 0;
+	virtual int LineCharacterIndex() const noexcept = 0;
+	virtual bool AllocateLineCharacterIndex(int lineCharacterIndex, Sci::Line lines) = 0;
+	virtual bool ReleaseLineCharacterIndex(int lineCharacterIndex) = 0;
+	virtual Sci::Position IndexLineStart(Sci::Line line, int lineCharacterIndex) const noexcept = 0;
+	virtual Sci::Line LineFromPositionIndex(Sci::Position pos, int lineCharacterIndex) const noexcept = 0;
+	virtual ~ILineVector() {}
+};
 
-void MarkerHandleSet::CombineWith(MarkerHandleSet *other) {
-	MarkerHandleNumber **pmhn = &root;
-	while (*pmhn) {
-		pmhn = &((*pmhn)->next);
-	}
-	*pmhn = other->root;
-	other->root = 0;
 }
 
-LineVector::LineVector() : starts(256) {
-	handleCurrent = 1;
+using namespace Scintilla;
 
-	Init();
-}
+template <typename POS>
+class LineStartIndex {
+public:
+	int refCount;
+	Partitioning<POS> starts;
 
-LineVector::~LineVector() {
-	starts.DeleteAll();
-	for (int line = 0; line < markers.Length(); line++) {
-		delete markers[line];
-		markers[line] = 0;
+	LineStartIndex() : refCount(0), starts(4) {
+		// Minimal initial allocation
 	}
-	markers.DeleteAll();
-	levels.DeleteAll();
-}
-
-void LineVector::Init() {
-	starts.DeleteAll();
-	for (int line = 0; line < markers.Length(); line++) {
-		delete markers[line];
-		markers[line] = 0;
+	// Deleted so LineStartIndex objects can not be copied.
+	LineStartIndex(const LineStartIndex &) = delete;
+	LineStartIndex(LineStartIndex &&) = delete;
+	void operator=(const LineStartIndex &) = delete;
+	void operator=(LineStartIndex &&) = delete;
+	virtual ~LineStartIndex() {
 	}
-	markers.DeleteAll();
-	levels.DeleteAll();
-}
-
-void LineVector::ExpandLevels(int sizeNew) {
-	levels.InsertValue(levels.Length(), sizeNew - levels.Length(), SC_FOLDLEVELBASE);
-}
-
-void LineVector::ClearLevels() {
-	levels.DeleteAll();
-}
-
-int LineVector::SetLevel(int line, int level) {
-	int prev = 0;
-	if ((line >= 0) && (line < Lines())) {
-		if (!levels.Length()) {
-			ExpandLevels(Lines() + 1);
+	bool Allocate(Sci::Line lines) {
+		refCount++;
+		Sci::Position length = starts.PositionFromPartition(starts.Partitions());
+		for (Sci::Line line = starts.Partitions(); line < lines; line++) {
+			// Produce an ascending sequence that will be filled in with correct widths later
+			length++;
+			starts.InsertPartition(static_cast<POS>(line), static_cast<POS>(length));
 		}
-		prev = levels[line];
-		if (prev != level) {
-			levels[line] = level;
+		return refCount == 1;
+	}
+	bool Release() {
+		if (refCount == 1) {
+			starts.DeleteAll();
 		}
+		refCount--;
+		return refCount == 0;
 	}
-	return prev;
-}
-
-int LineVector::GetLevel(int line) {
-	if (levels.Length() && (line >= 0) && (line < Lines())) {
-		return levels[line];
-	} else {
-		return SC_FOLDLEVELBASE;
+	bool Active() const noexcept {
+		return refCount > 0;
 	}
-}
-
-void LineVector::InsertText(int line, int delta) {
-	starts.InsertText(line, delta);
-}
-
-void LineVector::InsertLine(int line, int position) {
-	starts.InsertPartition(line, position);
-	if (markers.Length()) {
-		markers.Insert(line, 0);
+	Sci::Position LineWidth(Sci::Line line) const noexcept {
+		return starts.PositionFromPartition(static_cast<POS>(line) + 1) -
+			starts.PositionFromPartition(static_cast<POS>(line));
 	}
-	if (levels.Length()) {
-		int level = SC_FOLDLEVELBASE;
-		if ((line > 0) && (line < Lines())) {
-			level = levels[line-1] & ~SC_FOLDLEVELWHITEFLAG;
-		}
-		levels.InsertValue(line, 1, level);
+	void SetLineWidth(Sci::Line line, Sci::Position width) noexcept {
+		const Sci::Position widthCurrent = LineWidth(line);
+		starts.InsertText(static_cast<POS>(line), static_cast<POS>(width - widthCurrent));
 	}
-}
-
-void LineVector::SetLineStart(int line, int position) {
-	starts.SetPartitionStartPosition(line, position);
-}
-
-void LineVector::RemoveLine(int line) {
-	starts.RemovePartition(line);
-	// Retain the markers from the deleted line by oring them into the previous line
-	if (markers.Length()) {
-		if (line > 0) {
-			MergeMarkers(line - 1);
+	void InsertLines(Sci::Line line, Sci::Line lines) {
+		// Insert multiple lines with each temporarily 1 character wide.
+		// The line widths will be fixed up by later measuring code.
+		const POS lineAsPos = static_cast<POS>(line);
+		const POS lineStart = starts.PositionFromPartition(lineAsPos - 1) + 1;
+		for (POS l = 0; l < static_cast<POS>(lines); l++) {
+			starts.InsertPartition(lineAsPos + l, lineStart + l);
 		}
-		markers.Delete(line);
 	}
-	if (levels.Length()) {
-		// Move up following lines but merge header flag from this line
-		// to line before to avoid a temporary disappearence causing expansion.
-		int firstHeader = levels[line] & SC_FOLDLEVELHEADERFLAG;
-		levels.Delete(line);
-		if (line > 0)
-			levels[line-1] |= firstHeader;
+};
+
+template <typename POS>
+class LineVector : public ILineVector {
+	Partitioning<POS> starts;
+	PerLine *perLine;
+	LineStartIndex<POS> startsUTF16;
+	LineStartIndex<POS> startsUTF32;
+	int activeIndices;
+
+	void SetActiveIndices() noexcept {
+		activeIndices = (startsUTF32.Active() ? SC_LINECHARACTERINDEX_UTF32 : 0)
+			| (startsUTF16.Active() ? SC_LINECHARACTERINDEX_UTF16 : 0);
 	}
-}
-
-int LineVector::LineFromPosition(int pos) {
-	return starts.PartitionFromPosition(pos);
-}
 
-int LineVector::MarkValue(int line) {
-	if (markers.Length() && markers[line])
-		return markers[line]->MarkValue();
-	else
-		return 0;
-}
-
-int LineVector::AddMark(int line, int markerNum) {
-	handleCurrent++;
-	if (!markers.Length()) {
-		// No existing markers so allocate one element per line
-		markers.InsertValue(0, Lines(), 0);
+public:
+	LineVector() : starts(256), perLine(nullptr), activeIndices(0) {
 	}
-	if (!markers[line]) {
-		// Need new structure to hold marker handle
-		markers[line] = new MarkerHandleSet();
-		if (!markers[line])
-			return - 1;
+	// Deleted so LineVector objects can not be copied.
+	LineVector(const LineVector &) = delete;
+	LineVector(LineVector &&) = delete;
+	LineVector &operator=(const LineVector &) = delete;
+	LineVector &operator=(LineVector &&) = delete;
+	~LineVector() override {
 	}
-	markers[line]->InsertHandle(handleCurrent, markerNum);
-
-	return handleCurrent;
-}
-
-void LineVector::MergeMarkers(int pos) {
-	if (markers[pos + 1] != NULL) {
-		if (markers[pos] == NULL)
-			markers[pos] = new MarkerHandleSet;
-		markers[pos]->CombineWith(markers[pos + 1]);
-		delete markers[pos + 1];
-		markers[pos + 1] = NULL;
+	void Init() override {
+		starts.DeleteAll();
+		if (perLine) {
+			perLine->Init();
+		}
+		startsUTF32.starts.DeleteAll();
+		startsUTF16.starts.DeleteAll();
 	}
-}
-
-void LineVector::DeleteMark(int line, int markerNum, bool all) {
-	if (markers.Length() && markers[line]) {
-		if (markerNum == -1) {
-			delete markers[line];
-			markers[line] = NULL;
+	void SetPerLine(PerLine *pl) noexcept override {
+		perLine = pl;
+	}
+	void InsertText(Sci::Line line, Sci::Position delta) noexcept override {
+		starts.InsertText(static_cast<POS>(line), static_cast<POS>(delta));
+	}
+	void InsertLine(Sci::Line line, Sci::Position position, bool lineStart) override {
+		const POS lineAsPos = static_cast<POS>(line);
+		starts.InsertPartition(lineAsPos, static_cast<POS>(position));
+		if (activeIndices) {
+			if (activeIndices & SC_LINECHARACTERINDEX_UTF32) {
+				startsUTF32.InsertLines(line, 1);
+			}
+			if (activeIndices & SC_LINECHARACTERINDEX_UTF16) {
+				startsUTF16.InsertLines(line, 1);
+			}
+		}
+		if (perLine) {
+			if ((line > 0) && lineStart)
+				line--;
+			perLine->InsertLine(line);
+		}
+	}
+	void InsertLines(Sci::Line line, const Sci::Position *positions, size_t lines, bool lineStart) override {
+		const POS lineAsPos = static_cast<POS>(line);
+		if constexpr (sizeof(Sci::Position) == sizeof(POS)) {
+			starts.InsertPartitions(lineAsPos, positions, lines);
 		} else {
-			bool performedDeletion = markers[line]->RemoveNumber(markerNum);
-			while (all && performedDeletion) {
-				performedDeletion = markers[line]->RemoveNumber(markerNum);
+			starts.InsertPartitionsWithCast(lineAsPos, positions, lines);
+		}
+		if (activeIndices) {
+			if (activeIndices & SC_LINECHARACTERINDEX_UTF32) {
+				startsUTF32.InsertLines(line, lines);
 			}
-			if (markers[line]->Length() == 0) {
-				delete markers[line];
-				markers[line] = NULL;
+			if (activeIndices & SC_LINECHARACTERINDEX_UTF16) {
+				startsUTF16.InsertLines(line, lines);
 			}
 		}
+		if (perLine) {
+			if ((line > 0) && lineStart)
+				line--;
+			perLine->InsertLines(line, lines);
+		}
 	}
-}
-
-void LineVector::DeleteMarkFromHandle(int markerHandle) {
-	int line = LineFromHandle(markerHandle);
-	if (line >= 0) {
-		markers[line]->RemoveHandle(markerHandle);
-		if (markers[line]->Length() == 0) {
-			delete markers[line];
-			markers[line] = NULL;
+	void SetLineStart(Sci::Line line, Sci::Position position) noexcept override {
+		starts.SetPartitionStartPosition(static_cast<POS>(line), static_cast<POS>(position));
+	}
+	void RemoveLine(Sci::Line line) override {
+		starts.RemovePartition(static_cast<POS>(line));
+		if (activeIndices & SC_LINECHARACTERINDEX_UTF32) {
+			startsUTF32.starts.RemovePartition(static_cast<POS>(line));
+		}
+		if (activeIndices & SC_LINECHARACTERINDEX_UTF16) {
+			startsUTF16.starts.RemovePartition(static_cast<POS>(line));
+		}
+		if (perLine) {
+			perLine->RemoveLine(line);
+		}
+	}
+	Sci::Line Lines() const noexcept override {
+		return static_cast<Sci::Line>(starts.Partitions());
+	}
+	Sci::Line LineFromPosition(Sci::Position pos) const noexcept override {
+		return static_cast<Sci::Line>(starts.PartitionFromPosition(static_cast<POS>(pos)));
+	}
+	Sci::Position LineStart(Sci::Line line) const noexcept override {
+		return starts.PositionFromPartition(static_cast<POS>(line));
+	}
+	void InsertCharacters(Sci::Line line, CountWidths delta) noexcept override {
+		if (activeIndices & SC_LINECHARACTERINDEX_UTF32) {
+			startsUTF32.starts.InsertText(static_cast<POS>(line), static_cast<POS>(delta.WidthUTF32()));
+		}
+		if (activeIndices & SC_LINECHARACTERINDEX_UTF16) {
+			startsUTF16.starts.InsertText(static_cast<POS>(line), static_cast<POS>(delta.WidthUTF16()));
+		}
+	}
+	void SetLineCharactersWidth(Sci::Line line, CountWidths width) noexcept override {
+		if (activeIndices & SC_LINECHARACTERINDEX_UTF32) {
+			assert(startsUTF32.starts.Partitions() == starts.Partitions());
+			startsUTF32.SetLineWidth(line, width.WidthUTF32());
+		}
+		if (activeIndices & SC_LINECHARACTERINDEX_UTF16) {
+			assert(startsUTF16.starts.Partitions() == starts.Partitions());
+			startsUTF16.SetLineWidth(line, width.WidthUTF16());
 		}
 	}
-}
 
-int LineVector::LineFromHandle(int markerHandle) {
-	if (markers.Length()) {
-		for (int line = 0; line < Lines(); line++) {
-			if (markers[line]) {
-				if (markers[line]->Contains(markerHandle)) {
-					return line;
-				}
-			}
+	int LineCharacterIndex() const noexcept override {
+		return activeIndices;
+	}
+	bool AllocateLineCharacterIndex(int lineCharacterIndex, Sci::Line lines) override {
+		const int activeIndicesStart = activeIndices;
+		if ((lineCharacterIndex & SC_LINECHARACTERINDEX_UTF32) != 0) {
+			startsUTF32.Allocate(lines);
+			assert(startsUTF32.starts.Partitions() == starts.Partitions());
 		}
+		if ((lineCharacterIndex & SC_LINECHARACTERINDEX_UTF16) != 0) {
+			startsUTF16.Allocate(lines);
+			assert(startsUTF16.starts.Partitions() == starts.Partitions());
+		}
+		SetActiveIndices();
+		return activeIndicesStart != activeIndices;
 	}
-	return -1;
-}
+	bool ReleaseLineCharacterIndex(int lineCharacterIndex) override {
+		const int activeIndicesStart = activeIndices;
+		if ((lineCharacterIndex & SC_LINECHARACTERINDEX_UTF32) != 0) {
+			startsUTF32.Release();
+		}
+		if ((lineCharacterIndex & SC_LINECHARACTERINDEX_UTF16) != 0) {
+			startsUTF16.Release();
+		}
+		SetActiveIndices();
+		return activeIndicesStart != activeIndices;
+	}
+	Sci::Position IndexLineStart(Sci::Line line, int lineCharacterIndex) const noexcept override {
+		if (lineCharacterIndex == SC_LINECHARACTERINDEX_UTF32) {
+			return startsUTF32.starts.PositionFromPartition(static_cast<POS>(line));
+		} else {
+			return startsUTF16.starts.PositionFromPartition(static_cast<POS>(line));
+		}
+	}
+	Sci::Line LineFromPositionIndex(Sci::Position pos, int lineCharacterIndex) const noexcept override {
+		if (lineCharacterIndex == SC_LINECHARACTERINDEX_UTF32) {
+			return static_cast<Sci::Line>(startsUTF32.starts.PartitionFromPosition(static_cast<POS>(pos)));
+		} else {
+			return static_cast<Sci::Line>(startsUTF16.starts.PartitionFromPosition(static_cast<POS>(pos)));
+		}
+	}
+};
 
-Action::Action() {
+Action::Action() noexcept {
 	at = startAction;
 	position = 0;
-	data = 0;
 	lenData = 0;
+	mayCoalesce = false;
 }
 
 Action::~Action() {
-	Destroy();
 }
 
-void Action::Create(actionType at_, int position_, char *data_, int lenData_, bool mayCoalesce_) {
-	delete []data;
+void Action::Create(actionType at_, Sci::Position position_, const char *data_, Sci::Position lenData_, bool mayCoalesce_) {
+	data = nullptr;
 	position = position_;
 	at = at_;
-	data = data_;
+	if (lenData_) {
+		data = std::make_unique<char[]>(lenData_);
+		memcpy(&data[0], data_, lenData_);
+	}
 	lenData = lenData_;
 	mayCoalesce = mayCoalesce_;
 }
 
-void Action::Destroy() {
-	delete []data;
-	data = 0;
-}
-
-void Action::Grab(Action *source) {
-	delete []data;
-
-	position = source->position;
-	at = source->at;
-	data = source->data;
-	lenData = source->lenData;
-	mayCoalesce = source->mayCoalesce;
-
-	// Ownership of source data transferred to this
-	source->position = 0;
-	source->at = startAction;
-	source->data = 0;
-	source->lenData = 0;
-	source->mayCoalesce = true;
+void Action::Clear() noexcept {
+	data = nullptr;
+	lenData = 0;
 }
 
 // The undo history stores a sequence of user operations that represent the user's view of the
@@ -365,40 +348,30 @@ void Action::Grab(Action *source) {
 
 UndoHistory::UndoHistory() {
 
-	lenActions = 100;
-	actions = new Action[lenActions];
+	actions.resize(3);
 	maxAction = 0;
 	currentAction = 0;
 	undoSequenceDepth = 0;
 	savePoint = 0;
+	tentativePoint = -1;
 
 	actions[currentAction].Create(startAction);
 }
 
 UndoHistory::~UndoHistory() {
-	delete []actions;
-	actions = 0;
 }
 
 void UndoHistory::EnsureUndoRoom() {
 	// Have to test that there is room for 2 more actions in the array
 	// as two actions may be created by the calling function
-	if (currentAction >= (lenActions - 2)) {
+	if (static_cast<size_t>(currentAction) >= (actions.size() - 2)) {
 		// Run out of undo nodes so extend the array
-		int lenActionsNew = lenActions * 2;
-		Action *actionsNew = new Action[lenActionsNew];
-		if (!actionsNew)
-			return;
-		for (int act = 0; act <= currentAction; act++)
-			actionsNew[act].Grab(&actions[act]);
-		delete []actions;
-		lenActions = lenActionsNew;
-		actions = actionsNew;
+		actions.resize(actions.size() * 2);
 	}
 }
 
-void UndoHistory::AppendAction(actionType at, int position, char *data, int lengthData,
-	bool &startSequence) {
+const char *UndoHistory::AppendAction(actionType at, Sci::Position position, const char *data, Sci::Position lengthData,
+	bool &startSequence, bool mayCoalesce) {
 	EnsureUndoRoom();
 	//Platform::DebugPrintf("%% %d action %d %d %d\n", at, position, lengthData, currentAction);
 	//Platform::DebugPrintf("^ %d action %d %d\n", actions[currentAction - 1].at,
@@ -410,25 +383,35 @@ void UndoHistory::AppendAction(actionType at, int position, char *data, int leng
 	if (currentAction >= 1) {
 		if (0 == undoSequenceDepth) {
 			// Top level actions may not always be coalesced
-			Action &actPrevious = actions[currentAction - 1];
+			int targetAct = -1;
+			const Action *actPrevious = &(actions[currentAction + targetAct]);
+			// Container actions may forward the coalesce state of Scintilla Actions.
+			while ((actPrevious->at == containerAction) && actPrevious->mayCoalesce) {
+				targetAct--;
+				actPrevious = &(actions[currentAction + targetAct]);
+			}
 			// See if current action can be coalesced into previous action
 			// Will work if both are inserts or deletes and position is same
-			if (at != actPrevious.at) {
+			if ((currentAction == savePoint) || (currentAction == tentativePoint)) {
 				currentAction++;
-			} else if (currentAction == savePoint) {
+			} else if (!actions[currentAction].mayCoalesce) {
+				// Not allowed to coalesce if this set
+				currentAction++;
+			} else if (!mayCoalesce || !actPrevious->mayCoalesce) {
+				currentAction++;
+			} else if (at == containerAction || actions[currentAction].at == containerAction) {
+				;	// A coalescible containerAction
+			} else if ((at != actPrevious->at) && (actPrevious->at != startAction)) {
 				currentAction++;
 			} else if ((at == insertAction) &&
-			           (position != (actPrevious.position + actPrevious.lenData))) {
+			           (position != (actPrevious->position + actPrevious->lenData))) {
 				// Insertions must be immediately after to coalesce
 				currentAction++;
-			} else if (!actions[currentAction].mayCoalesce) {
-				// Not allowed to coalesce if this set
-				currentAction++;
 			} else if (at == removeAction) {
-				if ((lengthData == 1) || (lengthData == 2)){
-					if ((position + lengthData) == actPrevious.position) {
+				if ((lengthData == 1) || (lengthData == 2)) {
+					if ((position + lengthData) == actPrevious->position) {
 						; // Backspace -> OK
-					} else if (position == actPrevious.position) {
+					} else if (position == actPrevious->position) {
 						; // Delete -> OK
 					} else {
 						// Removals must be at same position to coalesce
@@ -451,10 +434,12 @@ void UndoHistory::AppendAction(actionType at, int position, char *data, int leng
 		currentAction++;
 	}
 	startSequence = oldCurrentAction != currentAction;
-	actions[currentAction].Create(at, position, data, lengthData);
+	const int actionWithData = currentAction;
+	actions[currentAction].Create(at, position, data, lengthData, mayCoalesce);
 	currentAction++;
 	actions[currentAction].Create(startAction);
 	maxAction = currentAction;
+	return actions[actionWithData].data.get();
 }
 
 void UndoHistory::BeginUndoAction() {
@@ -490,22 +475,47 @@ void UndoHistory::DropUndoSequence() {
 
 void UndoHistory::DeleteUndoHistory() {
 	for (int i = 1; i < maxAction; i++)
-		actions[i].Destroy();
+		actions[i].Clear();
 	maxAction = 0;
 	currentAction = 0;
 	actions[currentAction].Create(startAction);
 	savePoint = 0;
+	tentativePoint = -1;
 }
 
-void UndoHistory::SetSavePoint() {
+void UndoHistory::SetSavePoint() noexcept {
 	savePoint = currentAction;
 }
 
-bool UndoHistory::IsSavePoint() const {
+bool UndoHistory::IsSavePoint() const noexcept {
 	return savePoint == currentAction;
 }
 
-bool UndoHistory::CanUndo() const {
+void UndoHistory::TentativeStart() {
+	tentativePoint = currentAction;
+}
+
+void UndoHistory::TentativeCommit() {
+	tentativePoint = -1;
+	// Truncate undo history
+	maxAction = currentAction;
+}
+
+bool UndoHistory::TentativeActive() const noexcept {
+	return tentativePoint >= 0; 
+}
+
+int UndoHistory::TentativeSteps() noexcept {
+	// Drop any trailing startAction
+	if (actions[currentAction].at == startAction && currentAction > 0)
+		currentAction--;
+	if (tentativePoint >= 0)
+		return currentAction - tentativePoint;
+	else
+		return -1;
+}
+
+bool UndoHistory::CanUndo() const noexcept {
 	return (currentAction > 0) && (maxAction > 0);
 }
 
@@ -530,18 +540,18 @@ void UndoHistory::CompletedUndoStep() {
 	currentAction--;
 }
 
-bool UndoHistory::CanRedo() const {
+bool UndoHistory::CanRedo() const noexcept {
 	return maxAction > currentAction;
 }
 
 int UndoHistory::StartRedo() {
 	// Drop any leading startAction
-	if (actions[currentAction].at == startAction && currentAction < maxAction)
+	if (currentAction < maxAction && actions[currentAction].at == startAction)
 		currentAction++;
 
 	// Count the steps in this action
 	int act = currentAction;
-	while (actions[act].at != startAction && act < maxAction) {
+	while (act < maxAction && actions[act].at != startAction) {
 		act++;
 	}
 	return act - currentAction;
@@ -555,55 +565,88 @@ void UndoHistory::CompletedRedoStep() {
 	currentAction++;
 }
 
-CellBuffer::CellBuffer() {
+CellBuffer::CellBuffer(bool hasStyles_, bool largeDocument_) :
+	hasStyles(hasStyles_), largeDocument(largeDocument_) {
 	readOnly = false;
+	utf8Substance = false;
+	utf8LineEnds = 0;
 	collectingUndo = true;
+	if (largeDocument)
+		plv = std::make_unique<LineVector<Sci::Position>>();
+	else
+		plv = std::make_unique<LineVector<int>>();
 }
 
 CellBuffer::~CellBuffer() {
 }
 
-char CellBuffer::CharAt(int position) const {
+char CellBuffer::CharAt(Sci::Position position) const noexcept {
 	return substance.ValueAt(position);
 }
 
-void CellBuffer::GetCharRange(char *buffer, int position, int lengthRetrieve) {
-	if (lengthRetrieve < 0)
+unsigned char CellBuffer::UCharAt(Sci::Position position) const noexcept {
+	return substance.ValueAt(position);
+}
+
+void CellBuffer::GetCharRange(char *buffer, Sci::Position position, Sci::Position lengthRetrieve) const {
+	if (lengthRetrieve <= 0)
 		return;
 	if (position < 0)
 		return;
 	if ((position + lengthRetrieve) > substance.Length()) {
-		Platform::DebugPrintf("Bad GetCharRange %d for %d of %d\n", position,
-		                      lengthRetrieve, substance.Length());
+		Platform::DebugPrintf("Bad GetCharRange %.0f for %.0f of %.0f\n",
+				      static_cast<double>(position),
+				      static_cast<double>(lengthRetrieve),
+				      static_cast<double>(substance.Length()));
 		return;
 	}
-	
-	for (int i=0; i<lengthRetrieve; i++) {
-		*buffer++ = substance.ValueAt(position + i);
-	}
+	substance.GetRange(buffer, position, lengthRetrieve);
+}
+
+char CellBuffer::StyleAt(Sci::Position position) const noexcept {
+	return hasStyles ? style.ValueAt(position) : 0;
 }
 
-char CellBuffer::StyleAt(int position) {
-	return style.ValueAt(position);
+void CellBuffer::GetStyleRange(unsigned char *buffer, Sci::Position position, Sci::Position lengthRetrieve) const {
+	if (lengthRetrieve < 0)
+		return;
+	if (position < 0)
+		return;
+	if (!hasStyles) {
+		std::fill(buffer, buffer + lengthRetrieve, static_cast<unsigned char>(0));
+		return;
+	}
+	if ((position + lengthRetrieve) > style.Length()) {
+		Platform::DebugPrintf("Bad GetStyleRange %.0f for %.0f of %.0f\n",
+				      static_cast<double>(position),
+				      static_cast<double>(lengthRetrieve),
+				      static_cast<double>(style.Length()));
+		return;
+	}
+	style.GetRange(reinterpret_cast<char *>(buffer), position, lengthRetrieve);
 }
 
-const char *CellBuffer::BufferPointer() { 
+const char *CellBuffer::BufferPointer() {
 	return substance.BufferPointer();
 }
 
+const char *CellBuffer::RangePointer(Sci::Position position, Sci::Position rangeLength) noexcept {
+	return substance.RangePointer(position, rangeLength);
+}
+
+Sci::Position CellBuffer::GapPosition() const noexcept {
+	return substance.GapPosition();
+}
+
 // The char* returned is to an allocation owned by the undo history
-const char *CellBuffer::InsertString(int position, const char *s, int insertLength, bool &startSequence) {
-	char *data = 0;
+const char *CellBuffer::InsertString(Sci::Position position, const char *s, Sci::Position insertLength, bool &startSequence) {
 	// InsertString and DeleteChars are the bottleneck though which all changes occur
+	const char *data = s;
 	if (!readOnly) {
 		if (collectingUndo) {
 			// Save into the undo/redo stack, but only the characters - not the formatting
 			// This takes up about half load time
-			data = new char[insertLength];
-			for (int i = 0; i < insertLength; i++) {
-				data[i] = s[i];
-			}
-			uh.AppendAction(insertAction, position, data, insertLength, startSequence);
+			data = uh.AppendAction(insertAction, position, s, insertLength, startSequence);
 		}
 
 		BasicInsertString(position, s, insertLength);
@@ -611,25 +654,30 @@ const char *CellBuffer::InsertString(int position, const char *s, int insertLeng
 	return data;
 }
 
-bool CellBuffer::SetStyleAt(int position, char styleValue, char mask) {
-	styleValue &= mask;
-	char curVal = style.ValueAt(position);
-	if ((curVal & mask) != styleValue) {
-		style.SetValueAt(position, static_cast<char>((curVal & ~mask) | styleValue));
+bool CellBuffer::SetStyleAt(Sci::Position position, char styleValue) noexcept {
+	if (!hasStyles) {
+		return false;
+	}
+	const char curVal = style.ValueAt(position);
+	if (curVal != styleValue) {
+		style.SetValueAt(position, styleValue);
 		return true;
 	} else {
 		return false;
 	}
 }
 
-bool CellBuffer::SetStyleFor(int position, int lengthStyle, char styleValue, char mask) {
+bool CellBuffer::SetStyleFor(Sci::Position position, Sci::Position lengthStyle, char styleValue) noexcept {
+	if (!hasStyles) {
+		return false;
+	}
 	bool changed = false;
 	PLATFORM_ASSERT(lengthStyle == 0 ||
 		(lengthStyle > 0 && lengthStyle + position <= style.Length()));
 	while (lengthStyle--) {
-		char curVal = style.ValueAt(position);
-		if ((curVal & mask) != styleValue) {
-			style.SetValueAt(position, static_cast<char>((curVal & ~mask) | styleValue));
+		const char curVal = style.ValueAt(position);
+		if (curVal != styleValue) {
+			style.SetValueAt(position, styleValue);
 			changed = true;
 		}
 		position++;
@@ -638,18 +686,16 @@ bool CellBuffer::SetStyleFor(int position, int lengthStyle, char styleValue, cha
 }
 
 // The char* returned is to an allocation owned by the undo history
-const char *CellBuffer::DeleteChars(int position, int deleteLength, bool &startSequence) {
+const char *CellBuffer::DeleteChars(Sci::Position position, Sci::Position deleteLength, bool &startSequence) {
 	// InsertString and DeleteChars are the bottleneck though which all changes occur
 	PLATFORM_ASSERT(deleteLength > 0);
-	char *data = 0;
+	const char *data = nullptr;
 	if (!readOnly) {
 		if (collectingUndo) {
 			// Save into the undo/redo stack, but only the characters - not the formatting
-			data = new char[deleteLength];
-			for (int i = 0; i < deleteLength; i++) {
-				data[i] = substance.ValueAt(position + i);
-			}
-			uh.AppendAction(removeAction, position, data, deleteLength, startSequence);
+			// The gap would be moved to position anyway for the deletion so this doesn't cost extra
+			data = substance.RangePointer(position, deleteLength);
+			data = uh.AppendAction(removeAction, position, data, deleteLength, startSequence);
 		}
 
 		BasicDeleteChars(position, deleteLength);
@@ -657,165 +703,487 @@ const char *CellBuffer::DeleteChars(int position, int deleteLength, bool &startS
 	return data;
 }
 
-int CellBuffer::Length() const {
+Sci::Position CellBuffer::Length() const noexcept {
 	return substance.Length();
 }
 
-void CellBuffer::Allocate(int newSize) {
+void CellBuffer::Allocate(Sci::Position newSize) {
 	substance.ReAllocate(newSize);
-	style.ReAllocate(newSize);
+	if (hasStyles) {
+		style.ReAllocate(newSize);
+	}
 }
 
-int CellBuffer::Lines() const {
-	return lv.Lines();
+void CellBuffer::SetUTF8Substance(bool utf8Substance_) noexcept {
+	utf8Substance = utf8Substance_;
 }
 
-int CellBuffer::LineStart(int line) const {
+void CellBuffer::SetLineEndTypes(int utf8LineEnds_) {
+	if (utf8LineEnds != utf8LineEnds_) {
+		const int indexes = plv->LineCharacterIndex();
+		utf8LineEnds = utf8LineEnds_;
+		ResetLineEnds();
+		AllocateLineCharacterIndex(indexes);
+	}
+}
+
+bool CellBuffer::ContainsLineEnd(const char *s, Sci::Position length) const noexcept {
+	unsigned char chBeforePrev = 0;
+	unsigned char chPrev = 0;
+	for (Sci::Position i = 0; i < length; i++) {
+		const unsigned char ch = s[i];
+		if ((ch == '\r') || (ch == '\n')) {
+			return true;
+		} else if (utf8LineEnds) {
+			if (UTF8IsMultibyteLineEnd(chBeforePrev, chPrev, ch)) {
+				return true;
+			}
+		}
+		chBeforePrev = chPrev;
+		chPrev = ch;
+	}
+	return false;
+}
+
+void CellBuffer::SetPerLine(PerLine *pl) noexcept {
+	plv->SetPerLine(pl);
+}
+
+int CellBuffer::LineCharacterIndex() const noexcept {
+	return plv->LineCharacterIndex();
+}
+
+void CellBuffer::AllocateLineCharacterIndex(int lineCharacterIndex) {
+	if (utf8Substance) {
+		if (plv->AllocateLineCharacterIndex(lineCharacterIndex, Lines())) {
+			// Changed so recalculate whole file
+			RecalculateIndexLineStarts(0, Lines() - 1);
+		}
+	}
+}
+
+void CellBuffer::ReleaseLineCharacterIndex(int lineCharacterIndex) {
+	plv->ReleaseLineCharacterIndex(lineCharacterIndex);
+}
+
+Sci::Line CellBuffer::Lines() const noexcept {
+	return plv->Lines();
+}
+
+Sci::Position CellBuffer::LineStart(Sci::Line line) const noexcept {
 	if (line < 0)
 		return 0;
 	else if (line >= Lines())
 		return Length();
 	else
-		return lv.LineStart(line);
+		return plv->LineStart(line);
+}
+
+Sci::Line CellBuffer::LineFromPosition(Sci::Position pos) const noexcept {
+	return plv->LineFromPosition(pos);
+}
+
+Sci::Position CellBuffer::IndexLineStart(Sci::Line line, int lineCharacterIndex) const noexcept {
+	return plv->IndexLineStart(line, lineCharacterIndex);
 }
 
-bool CellBuffer::IsReadOnly() {
+Sci::Line CellBuffer::LineFromPositionIndex(Sci::Position pos, int lineCharacterIndex) const noexcept {
+	return plv->LineFromPositionIndex(pos, lineCharacterIndex);
+}
+
+bool CellBuffer::IsReadOnly() const noexcept {
 	return readOnly;
 }
 
-void CellBuffer::SetReadOnly(bool set) {
+void CellBuffer::SetReadOnly(bool set) noexcept {
 	readOnly = set;
 }
 
+bool CellBuffer::IsLarge() const noexcept {
+	return largeDocument;
+}
+
+bool CellBuffer::HasStyles() const noexcept {
+	return hasStyles;
+}
+
 void CellBuffer::SetSavePoint() {
 	uh.SetSavePoint();
 }
 
-bool CellBuffer::IsSavePoint() {
+bool CellBuffer::IsSavePoint() const noexcept {
 	return uh.IsSavePoint();
 }
 
-int CellBuffer::AddMark(int line, int markerNum) {
-	if ((line >= 0) && (line < Lines())) {
-		return lv.AddMark(line, markerNum);
-	}
-	return - 1;
+void CellBuffer::TentativeStart() {
+	uh.TentativeStart();
 }
 
-void CellBuffer::DeleteMark(int line, int markerNum) {
-	if ((line >= 0) && (line < Lines())) {
-		lv.DeleteMark(line, markerNum, false);
-	}
+void CellBuffer::TentativeCommit() {
+	uh.TentativeCommit();
 }
 
-void CellBuffer::DeleteMarkFromHandle(int markerHandle) {
-	lv.DeleteMarkFromHandle(markerHandle);
+int CellBuffer::TentativeSteps() noexcept {
+	return uh.TentativeSteps();
 }
 
-int CellBuffer::GetMark(int line) {
-	if ((line >= 0) && (line < Lines()))
-		return lv.MarkValue(line);
-	return 0;
+bool CellBuffer::TentativeActive() const noexcept {
+	return uh.TentativeActive();
 }
 
-void CellBuffer::DeleteAllMarks(int markerNum) {
-	for (int line = 0; line < Lines(); line++) {
-		lv.DeleteMark(line, markerNum, true);
+// Without undo
+
+void CellBuffer::InsertLine(Sci::Line line, Sci::Position position, bool lineStart) {
+	plv->InsertLine(line, position, lineStart);
+}
+
+void CellBuffer::RemoveLine(Sci::Line line) {
+	plv->RemoveLine(line);
+}
+
+bool CellBuffer::UTF8LineEndOverlaps(Sci::Position position) const noexcept {
+	const unsigned char bytes[] = {
+		static_cast<unsigned char>(substance.ValueAt(position-2)),
+		static_cast<unsigned char>(substance.ValueAt(position-1)),
+		static_cast<unsigned char>(substance.ValueAt(position)),
+		static_cast<unsigned char>(substance.ValueAt(position+1)),
+	};
+	return UTF8IsSeparator(bytes) || UTF8IsSeparator(bytes+1) || UTF8IsNEL(bytes+1);
+}
+
+bool CellBuffer::UTF8IsCharacterBoundary(Sci::Position position) const {
+	assert(position >= 0 && position <= Length());
+	if (position > 0) {
+		std::string back;
+		for (int i = 0; i < UTF8MaxBytes; i++) {
+			const Sci::Position posBack = position - i;
+			if (posBack < 0) {
+				return false;
+			}
+			back.insert(0, 1, substance.ValueAt(posBack));
+			if (!UTF8IsTrailByte(back.front())) {
+				if (i > 0) {
+					// Have reached a non-trail
+					const int cla = UTF8Classify(back);
+					if ((cla & UTF8MaskInvalid) || (cla != i)) {
+						return false;
+					}
+				}
+				break;
+			}
+		}
 	}
+	if (position < Length()) {
+		const unsigned char fore = substance.ValueAt(position);
+		if (UTF8IsTrailByte(fore)) {
+			return false;
+		}
+	}
+	return true;
 }
 
-int CellBuffer::LineFromHandle(int markerHandle) {
-	return lv.LineFromHandle(markerHandle);
+void CellBuffer::ResetLineEnds() {
+	// Reinitialize line data -- too much work to preserve
+	plv->Init();
+
+	const Sci::Position position = 0;
+	const Sci::Position length = Length();
+	Sci::Line lineInsert = 1;
+	const bool atLineStart = true;
+	plv->InsertText(lineInsert-1, length);
+	unsigned char chBeforePrev = 0;
+	unsigned char chPrev = 0;
+	for (Sci::Position i = 0; i < length; i++) {
+		const unsigned char ch = substance.ValueAt(position + i);
+		if (ch == '\r') {
+			InsertLine(lineInsert, (position + i) + 1, atLineStart);
+			lineInsert++;
+		} else if (ch == '\n') {
+			if (chPrev == '\r') {
+				// Patch up what was end of line
+				plv->SetLineStart(lineInsert - 1, (position + i) + 1);
+			} else {
+				InsertLine(lineInsert, (position + i) + 1, atLineStart);
+				lineInsert++;
+			}
+		} else if (utf8LineEnds) {
+			if (UTF8IsMultibyteLineEnd(chBeforePrev, chPrev, ch)) {
+				InsertLine(lineInsert, (position + i) + 1, atLineStart);
+				lineInsert++;
+			}
+		}
+		chBeforePrev = chPrev;
+		chPrev = ch;
+	}
 }
 
-// Without undo
+namespace {
 
-void CellBuffer::InsertLine(int line, int position) {
-	lv.InsertLine(line, position);
-	if (lineStates.Length()) {
-		lineStates.EnsureLength(line);
-		lineStates.Insert(line, 0);
+CountWidths CountCharacterWidthsUTF8(std::string_view sv) noexcept {
+	CountWidths cw;
+	size_t remaining = sv.length();
+	while (remaining > 0) {
+		const int utf8Status = UTF8Classify(sv);
+		const int lenChar = utf8Status & UTF8MaskWidth;
+		cw.CountChar(lenChar);
+		sv.remove_prefix(lenChar);
+		remaining -= lenChar;
 	}
+	return cw;
+}
+
+}
+
+bool CellBuffer::MaintainingLineCharacterIndex() const noexcept {
+	return plv->LineCharacterIndex() != SC_LINECHARACTERINDEX_NONE;
 }
 
-void CellBuffer::RemoveLine(int line) {
-	lv.RemoveLine(line);
-	if (lineStates.Length() > line) {
-		lineStates.Delete(line);
+void CellBuffer::RecalculateIndexLineStarts(Sci::Line lineFirst, Sci::Line lineLast) {
+	std::string text;
+	Sci::Position posLineEnd = LineStart(lineFirst);
+	for (Sci::Line line = lineFirst; line <= lineLast; line++) {
+		// Find line start and end, retrieve text of line, count characters and update line width
+		const Sci::Position posLineStart = posLineEnd;
+		posLineEnd = LineStart(line+1);
+		const Sci::Position width = posLineEnd - posLineStart;
+		text.resize(width);
+		GetCharRange(text.data(), posLineStart, width);
+		const CountWidths cw = CountCharacterWidthsUTF8(text);
+		plv->SetLineCharactersWidth(line, cw);
 	}
 }
 
-void CellBuffer::BasicInsertString(int position, const char *s, int insertLength) {
+void CellBuffer::BasicInsertString(Sci::Position position, const char *s, Sci::Position insertLength) {
 	if (insertLength == 0)
 		return;
 	PLATFORM_ASSERT(insertLength > 0);
 
+	const unsigned char chAfter = substance.ValueAt(position);
+	bool breakingUTF8LineEnd = false;
+	if (utf8LineEnds && UTF8IsTrailByte(chAfter)) {
+		breakingUTF8LineEnd = UTF8LineEndOverlaps(position);
+	}
+
+	const Sci::Line linePosition = plv->LineFromPosition(position);
+	Sci::Line lineInsert = linePosition + 1;
+
+	// A simple insertion is one that inserts valid text on a single line at a character boundary
+	bool simpleInsertion = false;
+
+	const bool maintainingIndex = MaintainingLineCharacterIndex();
+
+	// Check for breaking apart a UTF-8 sequence and inserting invalid UTF-8
+	if (utf8Substance && maintainingIndex) {
+		// Actually, don't need to check that whole insertion is valid just that there
+		// are no potential fragments at ends.
+		simpleInsertion = UTF8IsCharacterBoundary(position) &&
+			UTF8IsValid(std::string_view(s, insertLength));
+	}
+
 	substance.InsertFromArray(position, s, 0, insertLength);
-	style.InsertValue(position, insertLength, 0);
+	if (hasStyles) {
+		style.InsertValue(position, insertLength, 0);
+	}
 
-	int lineInsert = lv.LineFromPosition(position) + 1;
+	const bool atLineStart = plv->LineStart(lineInsert-1) == position;
 	// Point all the lines after the insertion point further along in the buffer
-	lv.InsertText(lineInsert-1, insertLength);
-	char chPrev = substance.ValueAt(position - 1);
-	char chAfter = substance.ValueAt(position + insertLength);
+	plv->InsertText(lineInsert-1, insertLength);
+	unsigned char chBeforePrev = substance.ValueAt(position - 2);
+	unsigned char chPrev = substance.ValueAt(position - 1);
 	if (chPrev == '\r' && chAfter == '\n') {
 		// Splitting up a crlf pair at position
-		InsertLine(lineInsert, position);
+		InsertLine(lineInsert, position, false);
 		lineInsert++;
 	}
-	char ch = ' ';
-	for (int i = 0; i < insertLength; i++) {
-		ch = s[i];
-		if (ch == '\r') {
-			InsertLine(lineInsert, (position + i) + 1);
+	if (breakingUTF8LineEnd) {
+		RemoveLine(lineInsert);
+	}
+
+	constexpr size_t PositionBlockSize = 128;
+	Sci::Position positions[PositionBlockSize]{};
+	size_t nPositions = 0;
+	const Sci::Line lineStart = lineInsert;
+
+	// s may not NULL-terminated, ensure *ptr == '\n' or *next == '\n' is valid.
+	const char * const end = s + insertLength - 1;
+	const char *ptr = s;
+	unsigned char ch = 0;
+
+	if (chPrev == '\r' && *ptr == '\n') {
+		++ptr;
+		// Patch up what was end of line
+		plv->SetLineStart(lineInsert - 1, (position + ptr - s));
+		simpleInsertion = false;
+	}
+
+	if (ptr < end) {
+		uint8_t eolTable[256]{};
+		eolTable[static_cast<uint8_t>('\n')] = 1;
+		eolTable[static_cast<uint8_t>('\r')] = 2;
+		if (utf8LineEnds) {
+			// see UniConversion.h for LS, PS and NEL
+			eolTable[0x85] = 4;
+			eolTable[0xa8] = 3;
+			eolTable[0xa9] = 3;
+		}
+
+		do {
+			// skip to line end
+			ch = *ptr++;
+			uint8_t type;
+			while ((type = eolTable[ch]) == 0 && ptr < end) {
+				chBeforePrev = chPrev;
+				chPrev = ch;
+				ch = *ptr++;
+			}
+			switch (type) {
+			case 2: // '\r'
+				if (*ptr == '\n') {
+					++ptr;
+				}
+				[[fallthrough]];
+			case 1: // '\n'
+				positions[nPositions++] = position + ptr - s;
+				if (nPositions == PositionBlockSize) {
+					plv->InsertLines(lineInsert, positions, nPositions, atLineStart);
+					lineInsert += nPositions;
+					nPositions = 0;
+				}
+				break;
+			case 3:
+			case 4:
+				// LS, PS and NEL
+				if ((type == 3 && chPrev == 0x80 && chBeforePrev == 0xe2) || (type == 4 && chPrev == 0xc2)) {
+					positions[nPositions++] = position + ptr - s;
+					if (nPositions == PositionBlockSize) {
+						plv->InsertLines(lineInsert, positions, nPositions, atLineStart);
+						lineInsert += nPositions;
+						nPositions = 0;
+					}
+				}
+				break;
+			}
+
+			chBeforePrev = chPrev;
+			chPrev = ch;
+		} while (ptr < end);
+	}
+
+	if (nPositions != 0) {
+		plv->InsertLines(lineInsert, positions, nPositions, atLineStart);
+		lineInsert += nPositions;
+	}
+
+	ch = *end;
+	if (ptr == end) {
+		++ptr;
+		if (ch == '\r' || ch == '\n') {
+			InsertLine(lineInsert, (position + ptr - s), atLineStart);
 			lineInsert++;
-		} else if (ch == '\n') {
-			if (chPrev == '\r') {
-				// Patch up what was end of line
-				lv.SetLineStart(lineInsert - 1, (position + i) + 1);
-			} else {
-				InsertLine(lineInsert, (position + i) + 1);
+		} else if (utf8LineEnds && !UTF8IsAscii(ch)) {
+			if (UTF8IsMultibyteLineEnd(chBeforePrev, chPrev, ch)) {
+				InsertLine(lineInsert, (position + ptr - s), atLineStart);
 				lineInsert++;
 			}
 		}
-		chPrev = ch;
 	}
+
 	// Joining two lines where last insertion is cr and following substance starts with lf
 	if (chAfter == '\n') {
 		if (ch == '\r') {
 			// End of line already in buffer so drop the newly created one
 			RemoveLine(lineInsert - 1);
+			simpleInsertion = false;
+		}
+	} else if (utf8LineEnds && !UTF8IsAscii(chAfter)) {
+		chBeforePrev = chPrev;
+		chPrev = ch;
+		// May have end of UTF-8 line end in buffer and start in insertion
+		for (int j = 0; j < UTF8SeparatorLength-1; j++) {
+			const unsigned char chAt = substance.ValueAt(position + insertLength + j);
+			const unsigned char back3[3] = {chBeforePrev, chPrev, chAt};
+			if (UTF8IsSeparator(back3)) {
+				InsertLine(lineInsert, (position + insertLength + j) + 1, atLineStart);
+				lineInsert++;
+			}
+			if ((j == 0) && UTF8IsNEL(back3+1)) {
+				InsertLine(lineInsert, (position + insertLength + j) + 1, atLineStart);
+				lineInsert++;
+			}
+			chBeforePrev = chPrev;
+			chPrev = chAt;
+		}
+	}
+	if (maintainingIndex) {
+		if (simpleInsertion && (lineInsert == lineStart)) {
+			const CountWidths cw = CountCharacterWidthsUTF8(std::string_view(s, insertLength));
+			plv->InsertCharacters(linePosition, cw);
+		} else {
+			RecalculateIndexLineStarts(linePosition, lineInsert - 1);
 		}
 	}
 }
 
-void CellBuffer::BasicDeleteChars(int position, int deleteLength) {
+void CellBuffer::BasicDeleteChars(Sci::Position position, Sci::Position deleteLength) {
 	if (deleteLength == 0)
 		return;
 
+	Sci::Line lineRecalculateStart = INVALID_POSITION;
+
 	if ((position == 0) && (deleteLength == substance.Length())) {
 		// If whole buffer is being deleted, faster to reinitialise lines data
 		// than to delete each line.
-		lv.Init();
+		plv->Init();
 	} else {
 		// Have to fix up line positions before doing deletion as looking at text in buffer
 		// to work out which lines have been removed
 
-		int lineRemove = lv.LineFromPosition(position) + 1;
-		lv.InsertText(lineRemove-1, - (deleteLength));
-		char chPrev = substance.ValueAt(position - 1);
-		char chBefore = chPrev;
-		char chNext = substance.ValueAt(position);
+		const Sci::Line linePosition = plv->LineFromPosition(position);
+		Sci::Line lineRemove = linePosition + 1;
+
+		plv->InsertText(lineRemove-1, - (deleteLength));
+		const unsigned char chPrev = substance.ValueAt(position - 1);
+		const unsigned char chBefore = chPrev;
+		unsigned char chNext = substance.ValueAt(position);
+
+		// Check for breaking apart a UTF-8 sequence
+		// Needs further checks that text is UTF-8 or that some other break apart is occurring
+		if (utf8Substance && MaintainingLineCharacterIndex()) {
+			const Sci::Position posEnd = position + deleteLength;
+			const Sci::Line lineEndRemove = plv->LineFromPosition(posEnd);
+			const bool simpleDeletion =
+				(linePosition == lineEndRemove) &&
+				UTF8IsCharacterBoundary(position) && UTF8IsCharacterBoundary(posEnd);
+			if (simpleDeletion) {
+				std::string text(deleteLength, '\0');
+				GetCharRange(text.data(), position, deleteLength);
+				if (UTF8IsValid(text)) {
+					// Everything is good
+					const CountWidths cw = CountCharacterWidthsUTF8(text);
+					plv->InsertCharacters(linePosition, -cw);
+				} else {
+					lineRecalculateStart = linePosition;
+				}
+			} else {
+				lineRecalculateStart = linePosition;
+			}
+		}
+
 		bool ignoreNL = false;
 		if (chPrev == '\r' && chNext == '\n') {
 			// Move back one
-			lv.SetLineStart(lineRemove, position);
+			plv->SetLineStart(lineRemove, position);
 			lineRemove++;
 			ignoreNL = true; 	// First \n is not real deletion
 		}
+		if (utf8LineEnds && UTF8IsTrailByte(chNext)) {
+			if (UTF8LineEndOverlaps(position)) {
+				RemoveLine(lineRemove);
+			}
+		}
 
-		char ch = chNext;
-		for (int i = 0; i < deleteLength; i++) {
+		unsigned char ch = chNext;
+		for (Sci::Position i = 0; i < deleteLength; i++) {
 			chNext = substance.ValueAt(position + i + 1);
 			if (ch == '\r') {
 				if (chNext != '\n') {
@@ -827,21 +1195,34 @@ void CellBuffer::BasicDeleteChars(int position, int deleteLength) {
 				} else {
 					RemoveLine(lineRemove);
 				}
+			} else if (utf8LineEnds) {
+				if (!UTF8IsAscii(ch)) {
+					const unsigned char next3[3] = {ch, chNext,
+						static_cast<unsigned char>(substance.ValueAt(position + i + 2))};
+					if (UTF8IsSeparator(next3) || UTF8IsNEL(next3)) {
+						RemoveLine(lineRemove);
+					}
+				}
 			}
 
 			ch = chNext;
 		}
 		// May have to fix up end if last deletion causes cr to be next to lf
 		// or removes one of a crlf pair
-		char chAfter = substance.ValueAt(position + deleteLength);
+		const char chAfter = substance.ValueAt(position + deleteLength);
 		if (chBefore == '\r' && chAfter == '\n') {
 			// Using lineRemove-1 as cr ended line before start of deletion
 			RemoveLine(lineRemove - 1);
-			lv.SetLineStart(lineRemove - 1, position + 1);
+			plv->SetLineStart(lineRemove - 1, position + 1);
 		}
 	}
 	substance.DeleteRange(position, deleteLength);
-	style.DeleteRange(position, deleteLength);
+	if (lineRecalculateStart >= 0) {
+		RecalculateIndexLineStarts(lineRecalculateStart, lineRecalculateStart);
+	}
+	if (hasStyles) {
+		style.DeleteRange(position, deleteLength);
+	}
 }
 
 bool CellBuffer::SetUndoCollection(bool collectUndo) {
@@ -850,7 +1231,7 @@ bool CellBuffer::SetUndoCollection(bool collectUndo) {
 	return collectingUndo;
 }
 
-bool CellBuffer::IsCollectingUndo() {
+bool CellBuffer::IsCollectingUndo() const noexcept {
 	return collectingUndo;
 }
 
@@ -862,11 +1243,16 @@ void CellBuffer::EndUndoAction() {
 	uh.EndUndoAction();
 }
 
+void CellBuffer::AddUndoAction(Sci::Position token, bool mayCoalesce) {
+	bool startSequence;
+	uh.AppendAction(containerAction, token, nullptr, 0, startSequence, mayCoalesce);
+}
+
 void CellBuffer::DeleteUndoHistory() {
 	uh.DeleteUndoHistory();
 }
 
-bool CellBuffer::CanUndo() {
+bool CellBuffer::CanUndo() const noexcept {
 	return uh.CanUndo();
 }
 
@@ -881,14 +1267,18 @@ const Action &CellBuffer::GetUndoStep() const {
 void CellBuffer::PerformUndoStep() {
 	const Action &actionStep = uh.GetUndoStep();
 	if (actionStep.at == insertAction) {
+		if (substance.Length() < actionStep.lenData) {
+			throw std::runtime_error(
+				"CellBuffer::PerformUndoStep: deletion must be less than document length.");
+		}
 		BasicDeleteChars(actionStep.position, actionStep.lenData);
 	} else if (actionStep.at == removeAction) {
-		BasicInsertString(actionStep.position, actionStep.data, actionStep.lenData);
+		BasicInsertString(actionStep.position, actionStep.data.get(), actionStep.lenData);
 	}
 	uh.CompletedUndoStep();
 }
 
-bool CellBuffer::CanRedo() {
+bool CellBuffer::CanRedo() const noexcept {
 	return uh.CanRedo();
 }
 
@@ -903,37 +1293,10 @@ const Action &CellBuffer::GetRedoStep() const {
 void CellBuffer::PerformRedoStep() {
 	const Action &actionStep = uh.GetRedoStep();
 	if (actionStep.at == insertAction) {
-		BasicInsertString(actionStep.position, actionStep.data, actionStep.lenData);
+		BasicInsertString(actionStep.position, actionStep.data.get(), actionStep.lenData);
 	} else if (actionStep.at == removeAction) {
 		BasicDeleteChars(actionStep.position, actionStep.lenData);
 	}
 	uh.CompletedRedoStep();
 }
 
-int CellBuffer::SetLineState(int line, int state) {
-	lineStates.EnsureLength(line + 1);
-	int stateOld = lineStates[line];
-	lineStates[line] = state;
-	return stateOld;
-}
-
-int CellBuffer::GetLineState(int line) {
-	lineStates.EnsureLength(line + 1);
-	return lineStates[line];
-}
-
-int CellBuffer::GetMaxLineState() {
-	return lineStates.Length();
-}
-
-int CellBuffer::SetLevel(int line, int level) {
-	return lv.SetLevel(line, level);
-}
-
-int CellBuffer::GetLevel(int line) {
-	return lv.GetLevel(line);
-}
-
-void CellBuffer::ClearLevels() {
-	lv.ClearLevels();
-}
diff --git a/Pythonwin/Scintilla/src/CellBuffer.h b/Pythonwin/Scintilla/src/CellBuffer.h
index 4b83f48e0..599b6062f 100644
--- a/Pythonwin/Scintilla/src/CellBuffer.h
+++ b/Pythonwin/Scintilla/src/CellBuffer.h
@@ -8,82 +8,24 @@
 #ifndef CELLBUFFER_H
 #define CELLBUFFER_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
-
-/**
- * This holds the marker identifier and the marker type to display.
- * MarkerHandleNumbers are members of lists.
- */
-struct MarkerHandleNumber {
-	int handle;
-	int number;
-	MarkerHandleNumber *next;
-};
-
-/**
- * A marker handle set contains any number of MarkerHandleNumbers.
- */
-class MarkerHandleSet {
-	MarkerHandleNumber *root;
 
+// Interface to per-line data that wants to see each line insertion and deletion
+class PerLine {
 public:
-	MarkerHandleSet();
-	~MarkerHandleSet();
-	int Length() const;
-	int NumberFromHandle(int handle) const;
-	int MarkValue() const;	///< Bit set of marker numbers.
-	bool Contains(int handle) const;
-	bool InsertHandle(int handle, int markerNum);
-	void RemoveHandle(int handle);
-	bool RemoveNumber(int markerNum);
-	void CombineWith(MarkerHandleSet *other);
+	virtual ~PerLine() {}
+	virtual void Init()=0;
+	virtual void InsertLine(Sci::Line line)=0;
+	virtual void InsertLines(Sci::Line line, Sci::Line lines) = 0;
+	virtual void RemoveLine(Sci::Line line)=0;
 };
 
 /**
  * The line vector contains information about each of the lines in a cell buffer.
  */
-class LineVector {
-
-	Partitioning starts;
-	SplitVector<MarkerHandleSet *> markers;
-	SplitVector<int> levels;
-	/// Handles are allocated sequentially and should never have to be reused as 32 bit ints are very big.
-	int handleCurrent;
-
-public:
+class ILineVector;
 
-	LineVector();
-	~LineVector();
-	void Init();
-
-	void ExpandLevels(int sizeNew=-1);
-	void ClearLevels();
-	int SetLevel(int line, int level);
-	int GetLevel(int line);
-
-	void InsertText(int line, int delta);
-	void InsertLine(int line, int position);
-	void SetLineStart(int line, int position);
-	void RemoveLine(int line);
-	int Lines() const {
-		return starts.Partitions();
-	}
-	int LineFromPosition(int pos);
-	int LineStart(int line) const {
-		return starts.PositionFromPartition(line);
-	}
-
-	int MarkValue(int line);
-	int AddMark(int line, int marker);
-	void MergeMarkers(int pos);
-	void DeleteMark(int line, int markerNum, bool all);
-	void DeleteMarkFromHandle(int markerHandle);
-	int LineFromHandle(int markerHandle);
-};
-
-enum actionType { insertAction, removeAction, startAction };
+enum actionType { insertAction, removeAction, startAction, containerAction };
 
 /**
  * Actions are used to store all the information required to perform one undo/redo step.
@@ -91,36 +33,46 @@ enum actionType { insertAction, removeAction, startAction };
 class Action {
 public:
 	actionType at;
-	int position;
-	char *data;
-	int lenData;
+	Sci::Position position;
+	std::unique_ptr<char[]> data;
+	Sci::Position lenData;
 	bool mayCoalesce;
 
-	Action();
+	Action() noexcept;
+	// Deleted so Action objects can not be copied.
+	Action(const Action &other) = delete;
+	Action &operator=(const Action &other) = delete;
+	Action &operator=(const Action &&other) = delete;
+	// Move constructor allows vector to be resized without reallocating.
+	Action(Action &&other) noexcept = default;
 	~Action();
-	void Create(actionType at_, int position_=0, char *data_=0, int lenData_=0, bool mayCoalesce_=true);
-	void Destroy();
-	void Grab(Action *source);
+	void Create(actionType at_, Sci::Position position_=0, const char *data_=nullptr, Sci::Position lenData_=0, bool mayCoalesce_=true);
+	void Clear() noexcept;
 };
 
 /**
  *
  */
 class UndoHistory {
-	Action *actions;
-	int lenActions;
+	std::vector<Action> actions;
 	int maxAction;
 	int currentAction;
 	int undoSequenceDepth;
 	int savePoint;
+	int tentativePoint;
 
 	void EnsureUndoRoom();
 
 public:
 	UndoHistory();
+	// Deleted so UndoHistory objects can not be copied.
+	UndoHistory(const UndoHistory &) = delete;
+	UndoHistory(UndoHistory &&) = delete;
+	void operator=(const UndoHistory &) = delete;
+	void operator=(UndoHistory &&) = delete;
 	~UndoHistory();
 
-	void AppendAction(actionType at, int position, char *data, int length, bool &startSequence);
+	const char *AppendAction(actionType at, Sci::Position position, const char *data, Sci::Position lengthData, bool &startSequence, bool mayCoalesce=true);
 
 	void BeginUndoAction();
 	void EndUndoAction();
@@ -129,16 +81,22 @@ class UndoHistory {
 
 	/// The save point is a marker in the undo stack where the container has stated that
 	/// the buffer was saved. Undo and redo can move over the save point.
-	void SetSavePoint();
-	bool IsSavePoint() const;
+	void SetSavePoint() noexcept;
+	bool IsSavePoint() const noexcept;
+
+	// Tentative actions are used for input composition so that it can be undone cleanly
+	void TentativeStart();
+	void TentativeCommit();
+	bool TentativeActive() const noexcept;
+	int TentativeSteps() noexcept;
 
 	/// To perform an undo, StartUndo is called to retrieve the number of steps, then UndoStep is
 	/// called that many times. Similarly for redo.
-	bool CanUndo() const;
+	bool CanUndo() const noexcept;
 	int StartUndo();
 	const Action &GetUndoStep() const;
 	void CompletedUndoStep();
-	bool CanRedo() const;
+	bool CanRedo() const noexcept;
 	int StartRedo();
 	const Action &GetRedoStep() const;
 	void CompletedRedoStep();
@@ -151,92 +109,108 @@ class UndoHistory {
  */
 class CellBuffer {
 private:
+	bool hasStyles;
+	bool largeDocument;
 	SplitVector<char> substance;
 	SplitVector<char> style;
 	bool readOnly;
+	bool utf8Substance;
+	int utf8LineEnds;
 
 	bool collectingUndo;
 	UndoHistory uh;
 
-	LineVector lv;
+	std::unique_ptr<ILineVector> plv;
 
-	SplitVector<int> lineStates;
+	bool UTF8LineEndOverlaps(Sci::Position position) const noexcept;
+	bool UTF8IsCharacterBoundary(Sci::Position position) const;
+	void ResetLineEnds();
+	void RecalculateIndexLineStarts(Sci::Line lineFirst, Sci::Line lineLast);
+	bool MaintainingLineCharacterIndex() const noexcept;
+	/// Actions without undo
+	void BasicInsertString(Sci::Position position, const char *s, Sci::Position insertLength);
+	void BasicDeleteChars(Sci::Position position, Sci::Position deleteLength);
 
 public:
 
-	CellBuffer();
+	CellBuffer(bool hasStyles_, bool largeDocument_);
+	// Deleted so CellBuffer objects can not be copied.
+	CellBuffer(const CellBuffer &) = delete;
+	CellBuffer(CellBuffer &&) = delete;
+	void operator=(const CellBuffer &) = delete;
+	void operator=(CellBuffer &&) = delete;
 	~CellBuffer();
 
 	/// Retrieving positions outside the range of the buffer works and returns 0
-	char CharAt(int position) const;
-	void GetCharRange(char *buffer, int position, int lengthRetrieve);
-	char StyleAt(int position);
+	char CharAt(Sci::Position position) const noexcept;
+	unsigned char UCharAt(Sci::Position position) const noexcept;
+	void GetCharRange(char *buffer, Sci::Position position, Sci::Position lengthRetrieve) const;
+	char StyleAt(Sci::Position position) const noexcept;
+	void GetStyleRange(unsigned char *buffer, Sci::Position position, Sci::Position lengthRetrieve) const;
 	const char *BufferPointer();
-
-	int Length() const;
-	void Allocate(int newSize);
-	int Lines() const;
-	int LineStart(int line) const;
-	int LineFromPosition(int pos) { return lv.LineFromPosition(pos); }
-	void InsertLine(int line, int position);
-	void RemoveLine(int line);
-	const char *InsertString(int position, const char *s, int insertLength, bool &startSequence);
+	const char *RangePointer(Sci::Position position, Sci::Position rangeLength) noexcept;
+	Sci::Position GapPosition() const noexcept;
+
+	Sci::Position Length() const noexcept;
+	void Allocate(Sci::Position newSize);
+	void SetUTF8Substance(bool utf8Substance_) noexcept;
+	int GetLineEndTypes() const noexcept { return utf8LineEnds; }
+	void SetLineEndTypes(int utf8LineEnds_);
+	bool ContainsLineEnd(const char *s, Sci::Position length) const noexcept;
+	void SetPerLine(PerLine *pl) noexcept;
+	int LineCharacterIndex() const noexcept;
+	void AllocateLineCharacterIndex(int lineCharacterIndex);
+	void ReleaseLineCharacterIndex(int lineCharacterIndex);
+	Sci::Line Lines() const noexcept;
+	Sci::Position LineStart(Sci::Line line) const noexcept;
+	Sci::Position IndexLineStart(Sci::Line line, int lineCharacterIndex) const noexcept;
+	Sci::Line LineFromPosition(Sci::Position pos) const noexcept;
+	Sci::Line LineFromPositionIndex(Sci::Position pos, int lineCharacterIndex) const noexcept;
+	void InsertLine(Sci::Line line, Sci::Position position, bool lineStart);
+	void RemoveLine(Sci::Line line);
+	const char *InsertString(Sci::Position position, const char *s, Sci::Position insertLength, bool &startSequence);
 
 	/// Setting styles for positions outside the range of the buffer is safe and has no effect.
 	/// @return true if the style of a character is changed.
-	bool SetStyleAt(int position, char styleValue, char mask='\377');
-	bool SetStyleFor(int position, int length, char styleValue, char mask);
+	bool SetStyleAt(Sci::Position position, char styleValue) noexcept;
+	bool SetStyleFor(Sci::Position position, Sci::Position lengthStyle, char styleValue) noexcept;
 
-	const char *DeleteChars(int position, int deleteLength, bool &startSequence);
+	const char *DeleteChars(Sci::Position position, Sci::Position deleteLength, bool &startSequence);
 
-	bool IsReadOnly();
-	void SetReadOnly(bool set);
+	bool IsReadOnly() const noexcept;
+	void SetReadOnly(bool set) noexcept;
+	bool IsLarge() const noexcept;
+	bool HasStyles() const noexcept;
 
 	/// The save point is a marker in the undo stack where the container has stated that
 	/// the buffer was saved. Undo and redo can move over the save point.
 	void SetSavePoint();
-	bool IsSavePoint();
+	bool IsSavePoint() const noexcept;
 
-	/// Line marker functions
-	int AddMark(int line, int markerNum);
-	void DeleteMark(int line, int markerNum);
-	void DeleteMarkFromHandle(int markerHandle);
-	int GetMark(int line);
-	void DeleteAllMarks(int markerNum);
-	int LineFromHandle(int markerHandle);
-
-	/// Actions without undo
-	void BasicInsertString(int position, const char *s, int insertLength);
-	void BasicDeleteChars(int position, int deleteLength);
+	void TentativeStart();
+	void TentativeCommit();
+	bool TentativeActive() const noexcept;
+	int TentativeSteps() noexcept;
 
 	bool SetUndoCollection(bool collectUndo);
-	bool IsCollectingUndo();
+	bool IsCollectingUndo() const noexcept;
 	void BeginUndoAction();
 	void EndUndoAction();
+	void AddUndoAction(Sci::Position token, bool mayCoalesce);
 	void DeleteUndoHistory();
 
 	/// To perform an undo, StartUndo is called to retrieve the number of steps, then UndoStep is
 	/// called that many times. Similarly for redo.
-	bool CanUndo();
+	bool CanUndo() const noexcept;
 	int StartUndo();
 	const Action &GetUndoStep() const;
 	void PerformUndoStep();
-	bool CanRedo();
+	bool CanRedo() const noexcept;
 	int StartRedo();
 	const Action &GetRedoStep() const;
 	void PerformRedoStep();
-
-	int SetLineState(int line, int state);
-	int GetLineState(int line);
-	int GetMaxLineState();
-
-	int SetLevel(int line, int level);
-	int GetLevel(int line);
-	void ClearLevels();
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/CharClassify.cxx b/Pythonwin/Scintilla/src/CharClassify.cxx
index acab4b229..b5e2870f3 100644
--- a/Pythonwin/Scintilla/src/CharClassify.cxx
+++ b/Pythonwin/Scintilla/src/CharClassify.cxx
@@ -5,16 +5,17 @@
 // Copyright 2006 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <ctype.h>
+#include <cstdlib>
+#include <cassert>
 
+#include <stdexcept>
+
+#include "CharacterSet.h"
 #include "CharClassify.h"
 
-// Shut up annoying Visual C++ warnings:
-#ifdef _MSC_VER
-#pragma warning(disable: 4514)
-#endif
+using namespace Scintilla;
 
-CharClassify::CharClassify() {
+CharClassify::CharClassify() : charClass{} {
 	SetDefaultCharClasses(true);
 }
 
@@ -25,7 +26,7 @@ void CharClassify::SetDefaultCharClasses(bool includeWordClass) {
 			charClass[ch] = ccNewLine;
 		else if (ch < 0x20 || ch == ' ')
 			charClass[ch] = ccSpace;
-		else if (includeWordClass && (ch >= 0x80 || isalnum(ch) || ch == '_'))
+		else if (includeWordClass && (ch >= 0x80 || IsAlphaNumeric(ch) || ch == '_'))
 			charClass[ch] = ccWord;
 		else
 			charClass[ch] = ccPunctuation;
@@ -33,7 +34,7 @@ void CharClassify::SetDefaultCharClasses(bool includeWordClass) {
 }
 
 void CharClassify::SetCharClasses(const unsigned char *chars, cc newCharClass) {
-	// Apply the newCharClass to the specifed chars
+	// Apply the newCharClass to the specified chars
 	if (chars) {
 		while (*chars) {
 			charClass[*chars] = static_cast<unsigned char>(newCharClass);
@@ -41,3 +42,19 @@ void CharClassify::SetCharClasses(const unsigned char *chars, cc newCharClass) {
 		}
 	}
 }
+
+int CharClassify::GetCharsOfClass(cc characterClass, unsigned char *buffer) const noexcept {
+	// Get characters belonging to the given char class; return the number
+	// of characters (if the buffer is NULL, don't write to it).
+	int count = 0;
+	for (int ch = maxChar - 1; ch >= 0; --ch) {
+		if (charClass[ch] == characterClass) {
+			++count;
+			if (buffer) {
+				*buffer = static_cast<unsigned char>(ch);
+				buffer++;
+			}
+		}
+	}
+	return count;
+}
diff --git a/Pythonwin/Scintilla/src/CharClassify.h b/Pythonwin/Scintilla/src/CharClassify.h
index 881d3a114..36cc34558 100644
--- a/Pythonwin/Scintilla/src/CharClassify.h
+++ b/Pythonwin/Scintilla/src/CharClassify.h
@@ -2,12 +2,14 @@
 /** @file CharClassify.h
  ** Character classifications used by Document and RESearch.
  **/
-// Copyright 2006 by Neil Hodgson <neilh@scintilla.org>
+// Copyright 2006-2009 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
 #ifndef CHARCLASSIFY_H
 #define CHARCLASSIFY_H
 
+namespace Scintilla {
+
 class CharClassify {
 public:
 	CharClassify();
@@ -15,11 +17,15 @@ class CharClassify {
 	enum cc { ccSpace, ccNewLine, ccWord, ccPunctuation };
 	void SetDefaultCharClasses(bool includeWordClass);
 	void SetCharClasses(const unsigned char *chars, cc newCharClass);
-	cc GetClass(unsigned char ch) const { return static_cast<cc>(charClass[ch]);}
-	bool IsWord(unsigned char ch) const { return static_cast<cc>(charClass[ch]) == ccWord;}
+	int GetCharsOfClass(cc characterClass, unsigned char *buffer) const noexcept;
+	cc GetClass(unsigned char ch) const noexcept { return static_cast<cc>(charClass[ch]);}
+	bool IsWord(unsigned char ch) const noexcept { return static_cast<cc>(charClass[ch]) == ccWord;}
 
 private:
 	enum { maxChar=256 };
 	unsigned char charClass[maxChar];    // not type cc to save space
 };
+
+}
+
 #endif
diff --git a/Pythonwin/Scintilla/src/CharacterSet.h b/Pythonwin/Scintilla/src/CharacterSet.h
deleted file mode 100644
index 4e8ffbdf6..000000000
--- a/Pythonwin/Scintilla/src/CharacterSet.h
+++ /dev/null
@@ -1,58 +0,0 @@
-// Scintilla source code edit control
-/** @file CharacterSet.h
- ** Encapsulates a set of characters. Used to test if a character is within a set.
- **/
-// Copyright 2007 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-class CharacterSet {
-	int size;
-	bool valueAfter;
-	bool *bset;
-public:
-	enum setBase {
-		setNone=0,
-		setLower=1,
-		setUpper=2,
-		setDigits=4,
-		setAlpha=setLower|setUpper,
-		setAlphaNum=setAlpha|setDigits
-	};
-	CharacterSet(setBase base=setNone, const char *initialSet="", int size_=0x80, bool valueAfter_=false) {
-		size = size_;
-		valueAfter = valueAfter_;
-		bset = new bool[size];
-		for (int i=0; i < size; i++) {
-			bset[i] = false;
-		}
-		AddString(initialSet);
-		if (base & setLower)
-			AddString("abcdefghijklmnopqrstuvwxyz");
-		if (base & setUpper)
-			AddString("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
-		if (base & setDigits)
-			AddString("0123456789");
-	}
-	~CharacterSet() {
-		delete []bset;
-		bset = 0;
-		size = 0;
-	}
-	void Add(int val) {
-		PLATFORM_ASSERT(val >= 0);
-		PLATFORM_ASSERT(val < size);
-		bset[val] = true;
-	}
-	void AddString(const char *CharacterSet) {
-		for (const char *cp=CharacterSet; *cp; cp++) {
-			int val = static_cast<unsigned char>(*cp);
-			PLATFORM_ASSERT(val >= 0);
-			PLATFORM_ASSERT(val < size);
-			bset[val] = true;
-		}
-	}
-	bool Contains(int val) const {
-		PLATFORM_ASSERT(val >= 0);
-		return (val < size) ? bset[val] : valueAfter;
-	}
-};
diff --git a/Pythonwin/Scintilla/src/ContractionState.cxx b/Pythonwin/Scintilla/src/ContractionState.cxx
index 08de5cf1f..81fefdfeb 100644
--- a/Pythonwin/Scintilla/src/ContractionState.cxx
+++ b/Pythonwin/Scintilla/src/ContractionState.cxx
@@ -5,50 +5,160 @@
 // Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <string.h>
+#include <cstddef>
+#include <cassert>
+#include <cstring>
+
+#include <stdexcept>
+#include <string_view>
+#include <vector>
+#include <algorithm>
+#include <memory>
 
 #include "Platform.h"
 
+#include "Position.h"
+#include "UniqueString.h"
 #include "SplitVector.h"
 #include "Partitioning.h"
 #include "RunStyles.h"
+#include "SparseVector.h"
 #include "ContractionState.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-ContractionState::ContractionState() : visible(0), expanded(0), heights(0), displayLines(0), linesInDocument(1) {
-	//InsertLine(0);
+namespace {
+
+template <typename LINE>
+class ContractionState final : public IContractionState {
+	// These contain 1 element for every document line.
+	std::unique_ptr<RunStyles<LINE, char>> visible;
+	std::unique_ptr<RunStyles<LINE, char>> expanded;
+	std::unique_ptr<RunStyles<LINE, int>> heights;
+	std::unique_ptr<SparseVector<UniqueString>> foldDisplayTexts;
+	std::unique_ptr<Partitioning<LINE>> displayLines;
+	LINE linesInDocument;
+
+	void EnsureData();
+
+	bool OneToOne() const noexcept {
+		// True when each document line is exactly one display line so need for
+		// complex data structures.
+		return visible == nullptr;
+	}
+
+	void InsertLine(Sci::Line lineDoc);
+	void DeleteLine(Sci::Line lineDoc);
+
+public:
+	ContractionState() noexcept;
+	// Deleted so ContractionState objects can not be copied.
+	ContractionState(const ContractionState &) = delete;
+	void operator=(const ContractionState &) = delete;
+	ContractionState(ContractionState &&) = delete;
+	void operator=(ContractionState &&) = delete;
+	~ContractionState() override;
+
+	void Clear() noexcept override;
+
+	Sci::Line LinesInDoc() const noexcept override;
+	Sci::Line LinesDisplayed() const noexcept override;
+	Sci::Line DisplayFromDoc(Sci::Line lineDoc) const noexcept override;
+	Sci::Line DisplayLastFromDoc(Sci::Line lineDoc) const noexcept override;
+	Sci::Line DocFromDisplay(Sci::Line lineDisplay) const noexcept override;
+
+	void InsertLines(Sci::Line lineDoc, Sci::Line lineCount) override;
+	void DeleteLines(Sci::Line lineDoc, Sci::Line lineCount) override;
+
+	bool GetVisible(Sci::Line lineDoc) const noexcept override;
+	bool SetVisible(Sci::Line lineDocStart, Sci::Line lineDocEnd, bool isVisible) override;
+	bool HiddenLines() const noexcept override;
+
+	const char *GetFoldDisplayText(Sci::Line lineDoc) const noexcept override;
+	bool SetFoldDisplayText(Sci::Line lineDoc, const char *text) override;
+
+	bool GetExpanded(Sci::Line lineDoc) const noexcept override;
+	bool SetExpanded(Sci::Line lineDoc, bool isExpanded) override;
+	Sci::Line ContractedNext(Sci::Line lineDocStart) const noexcept override;
+
+	int GetHeight(Sci::Line lineDoc) const noexcept override;
+	bool SetHeight(Sci::Line lineDoc, int height) override;
+
+	void ShowAll() noexcept override;
+
+	void Check() const noexcept;
+};
+
+template <typename LINE>
+ContractionState<LINE>::ContractionState() noexcept : linesInDocument(1) {
 }
 
-ContractionState::~ContractionState() {
+template <typename LINE>
+ContractionState<LINE>::~ContractionState() {
 	Clear();
 }
 
-void ContractionState::EnsureData() {
+template <typename LINE>
+void ContractionState<LINE>::EnsureData() {
 	if (OneToOne()) {
-		visible = new RunStyles();
-		expanded = new RunStyles();
-		heights = new RunStyles();
-		displayLines = new Partitioning(4);
+		visible = std::make_unique<RunStyles<LINE, char>>();
+		expanded = std::make_unique<RunStyles<LINE, char>>();
+		heights = std::make_unique<RunStyles<LINE, int>>();
+		foldDisplayTexts = std::make_unique<SparseVector<UniqueString>>();
+		displayLines = std::make_unique<Partitioning<LINE>>(4);
 		InsertLines(0, linesInDocument);
 	}
 }
 
-void ContractionState::Clear() {
-	delete visible;
-	visible = 0;
-	delete expanded;
-	expanded = 0;
-	delete heights;
-	heights = 0;
-	delete displayLines;
-	displayLines = 0;
+template <typename LINE>
+void ContractionState<LINE>::InsertLine(Sci::Line lineDoc) {
+	if (OneToOne()) {
+		linesInDocument++;
+	} else {
+		const LINE lineDocCast = static_cast<LINE>(lineDoc);
+		visible->InsertSpace(lineDocCast, 1);
+		visible->SetValueAt(lineDocCast, 1);
+		expanded->InsertSpace(lineDocCast, 1);
+		expanded->SetValueAt(lineDocCast, 1);
+		heights->InsertSpace(lineDocCast, 1);
+		heights->SetValueAt(lineDocCast, 1);
+		foldDisplayTexts->InsertSpace(lineDocCast, 1);
+		foldDisplayTexts->SetValueAt(lineDocCast, nullptr);
+		const Sci::Line lineDisplay = DisplayFromDoc(lineDoc);
+		displayLines->InsertPartition(lineDocCast, static_cast<LINE>(lineDisplay));
+		displayLines->InsertText(lineDocCast, 1);
+	}
+}
+
+template <typename LINE>
+void ContractionState<LINE>::DeleteLine(Sci::Line lineDoc) {
+	if (OneToOne()) {
+		linesInDocument--;
+	} else {
+		const LINE lineDocCast = static_cast<LINE>(lineDoc);
+		if (GetVisible(lineDoc)) {
+			displayLines->InsertText(lineDocCast, -heights->ValueAt(lineDocCast));
+		}
+		displayLines->RemovePartition(lineDocCast);
+		visible->DeleteRange(lineDocCast, 1);
+		expanded->DeleteRange(lineDocCast, 1);
+		heights->DeleteRange(lineDocCast, 1);
+		foldDisplayTexts->DeletePosition(lineDocCast);
+	}
+}
+
+template <typename LINE>
+void ContractionState<LINE>::Clear() noexcept {
+	visible.reset();
+	expanded.reset();
+	heights.reset();
+	foldDisplayTexts.reset();
+	displayLines.reset();
 	linesInDocument = 1;
 }
 
-int ContractionState::LinesInDoc() const {
+template <typename LINE>
+Sci::Line ContractionState<LINE>::LinesInDoc() const noexcept {
 	if (OneToOne()) {
 		return linesInDocument;
 	} else {
@@ -56,25 +166,33 @@ int ContractionState::LinesInDoc() const {
 	}
 }
 
-int ContractionState::LinesDisplayed() const {
+template <typename LINE>
+Sci::Line ContractionState<LINE>::LinesDisplayed() const noexcept {
 	if (OneToOne()) {
 		return linesInDocument;
 	} else {
-		return displayLines->PositionFromPartition(LinesInDoc());
+		return displayLines->PositionFromPartition(static_cast<LINE>(LinesInDoc()));
 	}
 }
 
-int ContractionState::DisplayFromDoc(int lineDoc) const {
+template <typename LINE>
+Sci::Line ContractionState<LINE>::DisplayFromDoc(Sci::Line lineDoc) const noexcept {
 	if (OneToOne()) {
-		return lineDoc;
+		return (lineDoc <= linesInDocument) ? lineDoc : linesInDocument;
 	} else {
 		if (lineDoc > displayLines->Partitions())
 			lineDoc = displayLines->Partitions();
-		return displayLines->PositionFromPartition(lineDoc);
+		return displayLines->PositionFromPartition(static_cast<LINE>(lineDoc));
 	}
 }
 
-int ContractionState::DocFromDisplay(int lineDisplay) const {
+template <typename LINE>
+Sci::Line ContractionState<LINE>::DisplayLastFromDoc(Sci::Line lineDoc) const noexcept {
+	return DisplayFromDoc(lineDoc) + GetHeight(lineDoc) - 1;
+}
+
+template <typename LINE>
+Sci::Line ContractionState<LINE>::DocFromDisplay(Sci::Line lineDisplay) const noexcept {
 	if (OneToOne()) {
 		return lineDisplay;
 	} else {
@@ -82,81 +200,64 @@ int ContractionState::DocFromDisplay(int lineDisplay) const {
 			return 0;
 		}
 		if (lineDisplay > LinesDisplayed()) {
-			return displayLines->PartitionFromPosition(LinesDisplayed());
+			return displayLines->PartitionFromPosition(static_cast<LINE>(LinesDisplayed()));
 		}
-		int lineDoc = displayLines->PartitionFromPosition(lineDisplay);
+		const Sci::Line lineDoc = displayLines->PartitionFromPosition(static_cast<LINE>(lineDisplay));
 		PLATFORM_ASSERT(GetVisible(lineDoc));
 		return lineDoc;
 	}
 }
 
-void ContractionState::InsertLine(int lineDoc) {
+template <typename LINE>
+void ContractionState<LINE>::InsertLines(Sci::Line lineDoc, Sci::Line lineCount) {
 	if (OneToOne()) {
-		linesInDocument++;
+		linesInDocument += static_cast<LINE>(lineCount);
 	} else {
-		visible->InsertSpace(lineDoc, 1);
-		visible->SetValueAt(lineDoc, 1);
-		expanded->InsertSpace(lineDoc, 1);
-		expanded->SetValueAt(lineDoc, 1);
-		heights->InsertSpace(lineDoc, 1);
-		heights->SetValueAt(lineDoc, 1);
-		int lineDisplay = DisplayFromDoc(lineDoc);
-		displayLines->InsertPartition(lineDoc, lineDisplay);
-		displayLines->InsertText(lineDoc, 1);
-	}
-}
-
-void ContractionState::InsertLines(int lineDoc, int lineCount) {
-	for (int l = 0; l < lineCount; l++) {
-		InsertLine(lineDoc + l);
+		for (Sci::Line l = 0; l < lineCount; l++) {
+			InsertLine(lineDoc + l);
+		}
 	}
 	Check();
 }
 
-void ContractionState::DeleteLine(int lineDoc) {
+template <typename LINE>
+void ContractionState<LINE>::DeleteLines(Sci::Line lineDoc, Sci::Line lineCount) {
 	if (OneToOne()) {
-		linesInDocument--;
+		linesInDocument -= static_cast<LINE>(lineCount);
 	} else {
-		if (GetVisible(lineDoc)) {
-			displayLines->InsertText(lineDoc, -heights->ValueAt(lineDoc));
+		for (Sci::Line l = 0; l < lineCount; l++) {
+			DeleteLine(lineDoc);
 		}
-		displayLines->RemovePartition(lineDoc);
-		visible->DeleteRange(lineDoc, 1);
-		expanded->DeleteRange(lineDoc, 1);
-		heights->DeleteRange(lineDoc, 1);
-	}
-}
-
-void ContractionState::DeleteLines(int lineDoc, int lineCount) {
-	for (int l = 0; l < lineCount; l++) {
-		DeleteLine(lineDoc);
 	}
 	Check();
 }
 
-bool ContractionState::GetVisible(int lineDoc) const {
+template <typename LINE>
+bool ContractionState<LINE>::GetVisible(Sci::Line lineDoc) const noexcept {
 	if (OneToOne()) {
 		return true;
 	} else {
 		if (lineDoc >= visible->Length())
 			return true;
-		return visible->ValueAt(lineDoc) == 1;
+		return visible->ValueAt(static_cast<LINE>(lineDoc)) == 1;
 	}
 }
 
-bool ContractionState::SetVisible(int lineDocStart, int lineDocEnd, bool visible_) {
-	if (OneToOne() && visible_) {
+template <typename LINE>
+bool ContractionState<LINE>::SetVisible(Sci::Line lineDocStart, Sci::Line lineDocEnd, bool isVisible) {
+	if (OneToOne() && isVisible) {
 		return false;
 	} else {
 		EnsureData();
-		int delta = 0;
+		Sci::Line delta = 0;
 		Check();
 		if ((lineDocStart <= lineDocEnd) && (lineDocStart >= 0) && (lineDocEnd < LinesInDoc())) {
-			for (int line = lineDocStart; line <= lineDocEnd; line++) {
-				if (GetVisible(line) != visible_) {
-					int difference = visible_ ? heights->ValueAt(line) : -heights->ValueAt(line);
-					visible->SetValueAt(line, visible_ ? 1 : 0);
-					displayLines->InsertText(line, difference);
+			for (Sci::Line line = lineDocStart; line <= lineDocEnd; line++) {
+				if (GetVisible(line) != isVisible) {
+					const int heightLine = heights->ValueAt(static_cast<LINE>(line));
+					const int difference = isVisible ? heightLine : -heightLine;
+					visible->SetValueAt(static_cast<LINE>(line), isVisible ? 1 : 0);
+					displayLines->InsertText(static_cast<LINE>(line), difference);
 					delta += difference;
 				}
 			}
@@ -168,22 +269,54 @@ bool ContractionState::SetVisible(int lineDocStart, int lineDocEnd, bool visible
 	}
 }
 
-bool ContractionState::GetExpanded(int lineDoc) const {
+template <typename LINE>
+bool ContractionState<LINE>::HiddenLines() const noexcept {
+	if (OneToOne()) {
+		return false;
+	} else {
+		return !visible->AllSameAs(1);
+	}
+}
+
+template <typename LINE>
+const char *ContractionState<LINE>::GetFoldDisplayText(Sci::Line lineDoc) const noexcept {
+	Check();
+	return foldDisplayTexts->ValueAt(lineDoc).get();
+}
+
+template <typename LINE>
+bool ContractionState<LINE>::SetFoldDisplayText(Sci::Line lineDoc, const char *text) {
+	EnsureData();
+	const char *foldText = foldDisplayTexts->ValueAt(lineDoc).get();
+	if (!foldText || !text || 0 != strcmp(text, foldText)) {
+		UniqueString uns = IsNullOrEmpty(text) ? UniqueString() : UniqueStringCopy(text);
+		foldDisplayTexts->SetValueAt(lineDoc, std::move(uns));
+		Check();
+		return true;
+	} else {
+		Check();
+		return false;
+	}
+}
+
+template <typename LINE>
+bool ContractionState<LINE>::GetExpanded(Sci::Line lineDoc) const noexcept {
 	if (OneToOne()) {
 		return true;
 	} else {
 		Check();
-		return expanded->ValueAt(lineDoc) == 1;
+		return expanded->ValueAt(static_cast<LINE>(lineDoc)) == 1;
 	}
 }
 
-bool ContractionState::SetExpanded(int lineDoc, bool expanded_) {
-	if (OneToOne() && expanded_) {
+template <typename LINE>
+bool ContractionState<LINE>::SetExpanded(Sci::Line lineDoc, bool isExpanded) {
+	if (OneToOne() && isExpanded) {
 		return false;
 	} else {
 		EnsureData();
-		if (expanded_ != (expanded->ValueAt(lineDoc) == 1)) {
-			expanded->SetValueAt(lineDoc, expanded_ ? 1 : 0);
+		if (isExpanded != (expanded->ValueAt(static_cast<LINE>(lineDoc)) == 1)) {
+			expanded->SetValueAt(static_cast<LINE>(lineDoc), isExpanded ? 1 : 0);
 			Check();
 			return true;
 		} else {
@@ -193,53 +326,77 @@ bool ContractionState::SetExpanded(int lineDoc, bool expanded_) {
 	}
 }
 
-int ContractionState::GetHeight(int lineDoc) const {
+template <typename LINE>
+Sci::Line ContractionState<LINE>::ContractedNext(Sci::Line lineDocStart) const noexcept {
+	if (OneToOne()) {
+		return -1;
+	} else {
+		Check();
+		if (!expanded->ValueAt(static_cast<LINE>(lineDocStart))) {
+			return lineDocStart;
+		} else {
+			const Sci::Line lineDocNextChange = expanded->EndRun(static_cast<LINE>(lineDocStart));
+			if (lineDocNextChange < LinesInDoc())
+				return lineDocNextChange;
+			else
+				return -1;
+		}
+	}
+}
+
+template <typename LINE>
+int ContractionState<LINE>::GetHeight(Sci::Line lineDoc) const noexcept {
 	if (OneToOne()) {
 		return 1;
 	} else {
-		return heights->ValueAt(lineDoc);
+		return heights->ValueAt(static_cast<LINE>(lineDoc));
 	}
 }
 
 // Set the number of display lines needed for this line.
 // Return true if this is a change.
-bool ContractionState::SetHeight(int lineDoc, int height) {
+template <typename LINE>
+bool ContractionState<LINE>::SetHeight(Sci::Line lineDoc, int height) {
 	if (OneToOne() && (height == 1)) {
 		return false;
-	} else {
+	} else if (lineDoc < LinesInDoc()) {
 		EnsureData();
 		if (GetHeight(lineDoc) != height) {
 			if (GetVisible(lineDoc)) {
-				displayLines->InsertText(lineDoc, height - GetHeight(lineDoc));
+				displayLines->InsertText(static_cast<LINE>(lineDoc), height - GetHeight(lineDoc));
 			}
-			heights->SetValueAt(lineDoc, height);
+			heights->SetValueAt(static_cast<LINE>(lineDoc), height);
 			Check();
 			return true;
 		} else {
 			Check();
 			return false;
 		}
+	} else {
+		return false;
 	}
 }
 
-void ContractionState::ShowAll() {
-	int lines = LinesInDoc();
+template <typename LINE>
+void ContractionState<LINE>::ShowAll() noexcept {
+	const LINE lines = static_cast<LINE>(LinesInDoc());
 	Clear();
 	linesInDocument = lines;
 }
 
 // Debugging checks
 
-void ContractionState::Check() const {
+template <typename LINE>
+void ContractionState<LINE>::Check() const noexcept {
 #ifdef CHECK_CORRECTNESS
-	for (int vline = 0;vline < LinesDisplayed(); vline++) {
-		const int lineDoc = DocFromDisplay(vline);
+	for (Sci::Line vline = 0; vline < LinesDisplayed(); vline++) {
+		const Sci::Line lineDoc = DocFromDisplay(vline);
 		PLATFORM_ASSERT(GetVisible(lineDoc));
 	}
-	for (int lineDoc = 0;lineDoc < LinesInDoc(); lineDoc++) {
-		const int displayThis = DisplayFromDoc(lineDoc);
-		const int displayNext = DisplayFromDoc(lineDoc + 1);
-		const int height = displayNext - displayThis;
+	for (Sci::Line lineDoc = 0; lineDoc < LinesInDoc(); lineDoc++) {
+		const Sci::Line displayThis = DisplayFromDoc(lineDoc);
+		const Sci::Line displayNext = DisplayFromDoc(lineDoc + 1);
+		const Sci::Line height = displayNext - displayThis;
 		PLATFORM_ASSERT(height >= 0);
 		if (GetVisible(lineDoc)) {
 			PLATFORM_ASSERT(GetHeight(lineDoc) == height);
@@ -249,3 +406,16 @@ void ContractionState::Check() const {
 	}
 #endif
 }
+
+}
+
+namespace Scintilla {
+
+std::unique_ptr<IContractionState> ContractionStateCreate(bool largeDocument) {
+	if (largeDocument)
+		return std::make_unique<ContractionState<Sci::Line>>();
+	else
+		return std::make_unique<ContractionState<int>>();
+}
+
+}
diff --git a/Pythonwin/Scintilla/src/ContractionState.h b/Pythonwin/Scintilla/src/ContractionState.h
index ba6297512..b30d071b4 100644
--- a/Pythonwin/Scintilla/src/ContractionState.h
+++ b/Pythonwin/Scintilla/src/ContractionState.h
@@ -8,59 +8,44 @@
 #ifndef CONTRACTIONSTATE_H
 #define CONTRACTIONSTATE_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
 
 /**
- */
-class ContractionState {
-	// These contain 1 element for every document line.
-	RunStyles *visible;
-	RunStyles *expanded;
-	RunStyles *heights;
-	Partitioning *displayLines;
-	int linesInDocument;
-
-	void EnsureData();
-
-	bool OneToOne() const {
-		// True when each document line is exactly one display line so need for
-		// complex data structures.
-		return visible == 0;
-	}
-
+*/
+class IContractionState {
 public:
-	ContractionState();
-	virtual ~ContractionState();
+	virtual ~IContractionState() {};
 
-	void Clear();
+	virtual void Clear()=0;
 
-	int LinesInDoc() const;
-	int LinesDisplayed() const;
-	int DisplayFromDoc(int lineDoc) const;
-	int DocFromDisplay(int lineDisplay) const;
+	virtual Sci::Line LinesInDoc() const noexcept=0;
+	virtual Sci::Line LinesDisplayed() const noexcept=0;
+	virtual Sci::Line DisplayFromDoc(Sci::Line lineDoc) const noexcept=0;
+	virtual Sci::Line DisplayLastFromDoc(Sci::Line lineDoc) const noexcept=0;
+	virtual Sci::Line DocFromDisplay(Sci::Line lineDisplay) const noexcept=0;
 
-	void InsertLine(int lineDoc);
-	void InsertLines(int lineDoc, int lineCount);
-	void DeleteLine(int lineDoc);
-	void DeleteLines(int lineDoc, int lineCount);
+	virtual void InsertLines(Sci::Line lineDoc, Sci::Line lineCount)=0;
+	virtual void DeleteLines(Sci::Line lineDoc, Sci::Line lineCount)=0;
 
-	bool GetVisible(int lineDoc) const;
-	bool SetVisible(int lineDocStart, int lineDocEnd, bool visible);
+	virtual bool GetVisible(Sci::Line lineDoc) const noexcept=0;
+	virtual bool SetVisible(Sci::Line lineDocStart, Sci::Line lineDocEnd, bool isVisible)=0;
+	virtual bool HiddenLines() const noexcept=0;
 
-	bool GetExpanded(int lineDoc) const;
-	bool SetExpanded(int lineDoc, bool expanded);
+	virtual const char *GetFoldDisplayText(Sci::Line lineDoc) const noexcept=0;
+	virtual bool SetFoldDisplayText(Sci::Line lineDoc, const char *text)=0;
 
-	int GetHeight(int lineDoc) const;
-	bool SetHeight(int lineDoc, int height);
+	virtual bool GetExpanded(Sci::Line lineDoc) const noexcept=0;
+	virtual bool SetExpanded(Sci::Line lineDoc, bool isExpanded)=0;
+	virtual Sci::Line ContractedNext(Sci::Line lineDocStart) const noexcept =0;
 
-	void ShowAll();
-	void Check() const;
+	virtual int GetHeight(Sci::Line lineDoc) const noexcept=0;
+	virtual bool SetHeight(Sci::Line lineDoc, int height)=0;
+
+	virtual void ShowAll() noexcept=0;
 };
 
-#ifdef SCI_NAMESPACE
+std::unique_ptr<IContractionState> ContractionStateCreate(bool largeDocument);
+
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/DBCS.cxx b/Pythonwin/Scintilla/src/DBCS.cxx
new file mode 100644
index 000000000..148c9818e
--- /dev/null
+++ b/Pythonwin/Scintilla/src/DBCS.cxx
@@ -0,0 +1,42 @@
+// Scintilla source code edit control
+/** @file DBCS.cxx
+ ** Functions to handle DBCS double byte encodings like Shift-JIS.
+ **/
+// Copyright 2017 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include "DBCS.h"
+
+using namespace Scintilla;
+
+namespace Scintilla {
+
+bool DBCSIsLeadByte(int codePage, char ch) noexcept {
+	// Byte ranges found in Wikipedia articles with relevant search strings in each case
+	const unsigned char uch = ch;
+	switch (codePage) {
+	case 932:
+		// Shift_jis
+		return ((uch >= 0x81) && (uch <= 0x9F)) ||
+			((uch >= 0xE0) && (uch <= 0xFC));
+		// Lead bytes F0 to FC may be a Microsoft addition.
+	case 936:
+		// GBK
+		return (uch >= 0x81) && (uch <= 0xFE);
+	case 949:
+		// Korean Wansung KS C-5601-1987
+		return (uch >= 0x81) && (uch <= 0xFE);
+	case 950:
+		// Big5
+		return (uch >= 0x81) && (uch <= 0xFE);
+	case 1361:
+		// Korean Johab KS C-5601-1992
+		return
+			((uch >= 0x84) && (uch <= 0xD3)) ||
+			((uch >= 0xD8) && (uch <= 0xDE)) ||
+			((uch >= 0xE0) && (uch <= 0xF9));
+	}
+	return false;
+}
+
+}
diff --git a/Pythonwin/Scintilla/src/DBCS.h b/Pythonwin/Scintilla/src/DBCS.h
new file mode 100644
index 000000000..58659ee3e
--- /dev/null
+++ b/Pythonwin/Scintilla/src/DBCS.h
@@ -0,0 +1,25 @@
+// Scintilla source code edit control
+/** @file DBCS.h
+ ** Functions to handle DBCS double byte encodings like Shift-JIS.
+ **/
+// Copyright 2017 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef DBCS_H
+#define DBCS_H
+
+namespace Scintilla {
+
+constexpr bool IsDBCSCodePage(int codePage) noexcept {
+	return codePage == 932
+	       || codePage == 936
+	       || codePage == 949
+	       || codePage == 950
+	       || codePage == 1361;
+}
+
+bool DBCSIsLeadByte(int codePage, char ch) noexcept;
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/Decoration.cxx b/Pythonwin/Scintilla/src/Decoration.cxx
index e4ac0e07c..ff6493f67 100644
--- a/Pythonwin/Scintilla/src/Decoration.cxx
+++ b/Pythonwin/Scintilla/src/Decoration.cxx
@@ -4,185 +4,314 @@
 // Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <stdarg.h>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <cstdio>
+#include <cstdarg>
+
+#include <stdexcept>
+#include <string_view>
+#include <vector>
+#include <algorithm>
+#include <memory>
 
 #include "Platform.h"
 
 #include "Scintilla.h"
+#include "Position.h"
 #include "SplitVector.h"
 #include "Partitioning.h"
 #include "RunStyles.h"
 #include "Decoration.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-Decoration::Decoration(int indicator_) : next(0), indicator(indicator_) {
-}
+namespace {
 
-Decoration::~Decoration() {
-}
+template <typename POS>
+class Decoration : public IDecoration {
+	int indicator;
+public:
+	RunStyles<POS, int> rs;
 
-bool Decoration::Empty() {
-	return rs.starts->Partitions() == 1;
-}
+	explicit Decoration(int indicator_) : indicator(indicator_) {
+	}
+	~Decoration() override {
+	}
 
-DecorationList::DecorationList() : currentIndicator(0), currentValue(1), current(0),
-	lengthDocument(0), root(0), clickNotified(false) {
-}
+	bool Empty() const noexcept override {
+		return (rs.Runs() == 1) && (rs.AllSameAs(0));
+	}
+	int Indicator() const noexcept override {
+		return indicator;
+	}
+	Sci::Position Length() const noexcept override {
+		return rs.Length();
+	}
+	int ValueAt(Sci::Position position) const noexcept override {
+		return rs.ValueAt(static_cast<POS>(position));
+	}
+	Sci::Position StartRun(Sci::Position position) const noexcept override {
+		return rs.StartRun(static_cast<POS>(position));
+	}
+	Sci::Position EndRun(Sci::Position position) const noexcept override {
+		return rs.EndRun(static_cast<POS>(position));
+	}
+	void SetValueAt(Sci::Position position, int value) override {
+		rs.SetValueAt(static_cast<POS>(position), value);
+	}
+	void InsertSpace(Sci::Position position, Sci::Position insertLength) override {
+		rs.InsertSpace(static_cast<POS>(position), static_cast<POS>(insertLength));
+	}
+	Sci::Position Runs() const noexcept override {
+		return rs.Runs();
+	}
+};
 
-DecorationList::~DecorationList() {
-	Decoration *deco = root;
-	while (deco) {
-		Decoration *decoNext = deco->next;
-		delete deco;
-		deco = decoNext;
+template <typename POS>
+class DecorationList : public IDecorationList {
+	int currentIndicator;
+	int currentValue;
+	Decoration<POS> *current;	// Cached so FillRange doesn't have to search for each call.
+	Sci::Position lengthDocument;
+	// Ordered by indicator
+	std::vector<std::unique_ptr<Decoration<POS>>> decorationList;
+	std::vector<const IDecoration*> decorationView;	// Read-only view of decorationList
+	bool clickNotified;
+
+	Decoration<POS> *DecorationFromIndicator(int indicator) noexcept;
+	Decoration<POS> *Create(int indicator, Sci::Position length);
+	void Delete(int indicator);
+	void DeleteAnyEmpty();
+	void SetView();
+public:
+
+	DecorationList();
+	~DecorationList() override;
+
+	const std::vector<const IDecoration*> &View() const noexcept override {
+		return decorationView;
 	}
-	root = 0;
-	current = 0;
+
+	void SetCurrentIndicator(int indicator) override;
+	int GetCurrentIndicator() const noexcept override { return currentIndicator; }
+
+	void SetCurrentValue(int value) override;
+	int GetCurrentValue() const noexcept override { return currentValue; }
+
+	// Returns changed=true if some values may have changed
+	FillResult<Sci::Position> FillRange(Sci::Position position, int value, Sci::Position fillLength) override;
+
+	void InsertSpace(Sci::Position position, Sci::Position insertLength) override;
+	void DeleteRange(Sci::Position position, Sci::Position deleteLength) override;
+
+	void DeleteLexerDecorations() override;
+
+	int AllOnFor(Sci::Position position) const noexcept override;
+	int ValueAt(int indicator, Sci::Position position) noexcept override;
+	Sci::Position Start(int indicator, Sci::Position position) noexcept override;
+	Sci::Position End(int indicator, Sci::Position position) noexcept override;
+
+	bool ClickNotified() const noexcept override {
+		return clickNotified;
+	}
+	void SetClickNotified(bool notified) noexcept override {
+		clickNotified = notified;
+	}
+};
+
+template <typename POS>
+DecorationList<POS>::DecorationList() : currentIndicator(0), currentValue(1), current(nullptr),
+	lengthDocument(0), clickNotified(false) {
+}
+
+template <typename POS>
+DecorationList<POS>::~DecorationList() {
+	current = nullptr;
 }
 
-Decoration *DecorationList::DecorationFromIndicator(int indicator) {
-	for (Decoration *deco=root; deco; deco = deco->next) {
-		if (deco->indicator == indicator) {
-			return deco;
+template <typename POS>
+Decoration<POS> *DecorationList<POS>::DecorationFromIndicator(int indicator) noexcept {
+	for (const std::unique_ptr<Decoration<POS>> &deco : decorationList) {
+		if (deco->Indicator() == indicator) {
+			return deco.get();
 		}
 	}
-	return 0;
+	return nullptr;
 }
 
-Decoration *DecorationList::Create(int indicator, int length) {
+template <typename POS>
+Decoration<POS> *DecorationList<POS>::Create(int indicator, Sci::Position length) {
 	currentIndicator = indicator;
-	Decoration *decoNew = new Decoration(indicator);
-	decoNew->rs.InsertSpace(0, length);
+	std::unique_ptr<Decoration<POS>> decoNew = std::make_unique<Decoration<POS>>(indicator);
+	decoNew->rs.InsertSpace(0, static_cast<POS>(length));
 
-	Decoration *decoPrev = 0;
-	Decoration *deco = root;
+	typename std::vector<std::unique_ptr<Decoration<POS>>>::iterator it = std::lower_bound(
+		decorationList.begin(), decorationList.end(), decoNew,
+		[](const std::unique_ptr<Decoration<POS>> &a, const std::unique_ptr<Decoration<POS>> &b) noexcept {
+		return a->Indicator() < b->Indicator();
+	});
+	typename std::vector<std::unique_ptr<Decoration<POS>>>::iterator itAdded =
+		decorationList.insert(it, std::move(decoNew));
 
-	while (deco && (deco->indicator < indicator)) {
-		decoPrev = deco;
-		deco = deco->next;
-	}
-	if (decoPrev == 0) {
-		decoNew->next = root;
-		root = decoNew;
-	} else {
-		decoNew->next = deco;
-		decoPrev->next = decoNew;
-	}
-	return decoNew;
-}
-
-void DecorationList::Delete(int indicator) {
-	Decoration *decoToDelete = 0;
-	if (root) {
-		if (root->indicator == indicator) {
-			decoToDelete = root;
-			root = root->next;
-		} else {
-			Decoration *deco=root;
-			while (deco->next && !decoToDelete) {
-				if (deco->next && deco->next->indicator == indicator) {
-					decoToDelete = deco->next;
-					deco->next = decoToDelete->next;
-				} else {
-					deco = deco->next;
-				}
-			}
-		}
-	}
-	if (decoToDelete) {
-		delete decoToDelete;
-		current = 0;
-	}
+	SetView();
+
+	return itAdded->get();
 }
 
-void DecorationList::SetCurrentIndicator(int indicator) {
+template <typename POS>
+void DecorationList<POS>::Delete(int indicator) {
+	decorationList.erase(std::remove_if(decorationList.begin(), decorationList.end(),
+		[indicator](const std::unique_ptr<Decoration<POS>> &deco) noexcept {
+		return deco->Indicator() == indicator;
+	}), decorationList.end());
+	current = nullptr;
+	SetView();
+}
+
+template <typename POS>
+void DecorationList<POS>::SetCurrentIndicator(int indicator) {
 	currentIndicator = indicator;
 	current = DecorationFromIndicator(indicator);
 	currentValue = 1;
 }
 
-void DecorationList::SetCurrentValue(int value) {
+template <typename POS>
+void DecorationList<POS>::SetCurrentValue(int value) {
 	currentValue = value ? value : 1;
 }
 
-bool DecorationList::FillRange(int &position, int value, int &fillLength) {
+template <typename POS>
+FillResult<Sci::Position> DecorationList<POS>::FillRange(Sci::Position position, int value, Sci::Position fillLength) {
 	if (!current) {
 		current = DecorationFromIndicator(currentIndicator);
 		if (!current) {
 			current = Create(currentIndicator, lengthDocument);
 		}
 	}
-	bool changed = current->rs.FillRange(position, value, fillLength);
-	if (current->Empty()) {
+	// Converting result from POS to Sci::Position as callers not polymorphic.
+	const FillResult<POS> frInPOS = current->rs.FillRange(static_cast<POS>(position), value, static_cast<POS>(fillLength));
+	const FillResult<Sci::Position> fr { frInPOS.changed, frInPOS.position, frInPOS.fillLength };
+		if (current->Empty()) {
 		Delete(currentIndicator);
 	}
-	return changed;
+	return fr;
 }
 
-void DecorationList::InsertSpace(int position, int insertLength) {
+template <typename POS>
+void DecorationList<POS>::InsertSpace(Sci::Position position, Sci::Position insertLength) {
+	const bool atEnd = position == lengthDocument;
 	lengthDocument += insertLength;
-	for (Decoration *deco=root; deco; deco = deco->next) {
-		deco->rs.InsertSpace(position, insertLength);
+	for (const std::unique_ptr<Decoration<POS>> &deco : decorationList) {
+		deco->rs.InsertSpace(static_cast<POS>(position), static_cast<POS>(insertLength));
+		if (atEnd) {
+			deco->rs.FillRange(static_cast<POS>(position), 0, static_cast<POS>(insertLength));
+		}
 	}
 }
 
-void DecorationList::DeleteRange(int position, int deleteLength) {
+template <typename POS>
+void DecorationList<POS>::DeleteRange(Sci::Position position, Sci::Position deleteLength) {
 	lengthDocument -= deleteLength;
-	Decoration *deco;
-	for (deco=root; deco; deco = deco->next) {
-		deco->rs.DeleteRange(position, deleteLength);
+	for (const std::unique_ptr<Decoration<POS>> &deco : decorationList) {
+		deco->rs.DeleteRange(static_cast<POS>(position), static_cast<POS>(deleteLength));
 	}
 	DeleteAnyEmpty();
+	if (decorationList.size() != decorationView.size()) {
+		// One or more empty decorations deleted so update view.
+		current = nullptr;
+		SetView();
+	}
 }
 
-void DecorationList::DeleteAnyEmpty() {
-	Decoration *deco = root;
-	while (deco) {
-		if (deco->Empty()) {
-			Delete(deco->indicator);
-			deco = root;
-		} else {
-			deco = deco->next;
-		}
+template <typename POS>
+void DecorationList<POS>::DeleteLexerDecorations() {
+	decorationList.erase(std::remove_if(decorationList.begin(), decorationList.end(),
+		[](const std::unique_ptr<Decoration<POS>> &deco) noexcept {
+		return deco->Indicator() < INDICATOR_CONTAINER ;
+	}), decorationList.end());
+	current = nullptr;
+	SetView();
+}
+
+template <typename POS>
+void DecorationList<POS>::DeleteAnyEmpty() {
+	if (lengthDocument == 0) {
+		decorationList.clear();
+	} else {
+		decorationList.erase(std::remove_if(decorationList.begin(), decorationList.end(),
+			[](const std::unique_ptr<Decoration<POS>> &deco) noexcept {
+			return deco->Empty();
+		}), decorationList.end());
+	}
+}
+
+template <typename POS>
+void DecorationList<POS>::SetView() {
+	decorationView.clear();
+	for (const std::unique_ptr<Decoration<POS>> &deco : decorationList) {
+		decorationView.push_back(deco.get());
 	}
 }
 
-int DecorationList::AllOnFor(int position) {
+template <typename POS>
+int DecorationList<POS>::AllOnFor(Sci::Position position) const noexcept {
 	int mask = 0;
-	for (Decoration *deco=root; deco; deco = deco->next) {
-		if (deco->rs.ValueAt(position)) {
-			mask |= 1 << deco->indicator;
+	for (const std::unique_ptr<Decoration<POS>> &deco : decorationList) {
+		if (deco->rs.ValueAt(static_cast<POS>(position))) {
+			if (deco->Indicator() < INDICATOR_IME) {
+				mask |= 1 << deco->Indicator();
+			}
 		}
 	}
 	return mask;
 }
 
-int DecorationList::ValueAt(int indicator, int position) {
-	Decoration *deco = DecorationFromIndicator(indicator);
+template <typename POS>
+int DecorationList<POS>::ValueAt(int indicator, Sci::Position position) noexcept {
+	const Decoration<POS> *deco = DecorationFromIndicator(indicator);
 	if (deco) {
-		return deco->rs.ValueAt(position);
+		return deco->rs.ValueAt(static_cast<POS>(position));
 	}
 	return 0;
 }
 
-int DecorationList::Start(int indicator, int position) {
-	Decoration *deco = DecorationFromIndicator(indicator);
+template <typename POS>
+Sci::Position DecorationList<POS>::Start(int indicator, Sci::Position position) noexcept {
+	const Decoration<POS> *deco = DecorationFromIndicator(indicator);
 	if (deco) {
-		return deco->rs.StartRun(position);
+		return deco->rs.StartRun(static_cast<POS>(position));
 	}
 	return 0;
 }
 
-int DecorationList::End(int indicator, int position) {
-	Decoration *deco = DecorationFromIndicator(indicator);
+template <typename POS>
+Sci::Position DecorationList<POS>::End(int indicator, Sci::Position position) noexcept {
+	const Decoration<POS> *deco = DecorationFromIndicator(indicator);
 	if (deco) {
-		return deco->rs.EndRun(position);
+		return deco->rs.EndRun(static_cast<POS>(position));
 	}
 	return 0;
 }
+
+}
+
+namespace Scintilla {
+
+std::unique_ptr<IDecoration> DecorationCreate(bool largeDocument, int indicator) {
+	if (largeDocument)
+		return std::make_unique<Decoration<Sci::Position>>(indicator);
+	else
+		return std::make_unique<Decoration<int>>(indicator);
+}
+
+std::unique_ptr<IDecorationList> DecorationListCreate(bool largeDocument) {
+	if (largeDocument)
+		return std::make_unique<DecorationList<Sci::Position>>();
+	else
+		return std::make_unique<DecorationList<int>>();
+}
+
+}
+
diff --git a/Pythonwin/Scintilla/src/Decoration.h b/Pythonwin/Scintilla/src/Decoration.h
index 2809641af..bab8e2500 100644
--- a/Pythonwin/Scintilla/src/Decoration.h
+++ b/Pythonwin/Scintilla/src/Decoration.h
@@ -7,58 +7,53 @@
 #ifndef DECORATION_H
 #define DECORATION_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
 
-class Decoration {
+class IDecoration {
 public:
-	Decoration *next;
-	RunStyles rs;
-	int indicator;
-
-	Decoration(int indicator_);
-	~Decoration();
-
-	bool Empty();
+	virtual ~IDecoration() {}
+	virtual bool Empty() const noexcept = 0;
+	virtual int Indicator() const noexcept = 0;
+	virtual Sci::Position Length() const noexcept = 0;
+	virtual int ValueAt(Sci::Position position) const noexcept = 0;
+	virtual Sci::Position StartRun(Sci::Position position) const noexcept = 0;
+	virtual Sci::Position EndRun(Sci::Position position) const noexcept = 0;
+	virtual void SetValueAt(Sci::Position position, int value) = 0;
+	virtual void InsertSpace(Sci::Position position, Sci::Position insertLength) = 0;
+	virtual Sci::Position Runs() const noexcept = 0;
 };
 
-class DecorationList {
-	int currentIndicator;
-	int currentValue;
-	Decoration *current;
-	int lengthDocument;
-	Decoration *DecorationFromIndicator(int indicator);
-	Decoration *Create(int indicator, int length);
-	void Delete(int indicator);
-	void DeleteAnyEmpty();
+class IDecorationList {
 public:
-	Decoration *root;
-	bool clickNotified;
+	virtual ~IDecorationList() {}
 
-	DecorationList();
-	~DecorationList();
+	virtual const std::vector<const IDecoration*> &View() const noexcept = 0;
 
-	void SetCurrentIndicator(int indicator);
-	int GetCurrentIndicator() { return currentIndicator; }
+	virtual void SetCurrentIndicator(int indicator) = 0;
+	virtual int GetCurrentIndicator() const noexcept = 0;
 
-	void SetCurrentValue(int value);
-	int GetCurrentValue() { return currentValue; }
+	virtual void SetCurrentValue(int value) = 0;
+	virtual int GetCurrentValue() const noexcept = 0;
 
-	// Returns true if some values may have changed
-	bool FillRange(int &position, int value, int &fillLength);
+	// Returns with changed=true if some values may have changed
+	virtual FillResult<Sci::Position> FillRange(Sci::Position position, int value, Sci::Position fillLength) = 0;
+	virtual void InsertSpace(Sci::Position position, Sci::Position insertLength) = 0;
+	virtual void DeleteRange(Sci::Position position, Sci::Position deleteLength) = 0;
+	virtual void DeleteLexerDecorations() = 0;
 
-	void InsertSpace(int position, int insertLength);
-	void DeleteRange(int position, int deleteLength);
+	virtual int AllOnFor(Sci::Position position) const noexcept = 0;
+	virtual int ValueAt(int indicator, Sci::Position position) noexcept = 0;
+	virtual Sci::Position Start(int indicator, Sci::Position position) noexcept = 0;
+	virtual Sci::Position End(int indicator, Sci::Position position) noexcept = 0;
 
-	int AllOnFor(int position);
-	int ValueAt(int indicator, int position);
-	int Start(int indicator, int position);
-	int End(int indicator, int position);
+	virtual bool ClickNotified() const noexcept = 0;
+	virtual void SetClickNotified(bool notified) noexcept = 0;
 };
 
-#ifdef SCI_NAMESPACE
+std::unique_ptr<IDecoration> DecorationCreate(bool largeDocument, int indicator);
+
+std::unique_ptr<IDecorationList> DecorationListCreate(bool largeDocument);
+
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/Document.cxx b/Pythonwin/Scintilla/src/Document.cxx
index bded3a32a..f4f124887 100644
--- a/Pythonwin/Scintilla/src/Document.cxx
+++ b/Pythonwin/Scintilla/src/Document.cxx
@@ -2,89 +2,153 @@
 /** @file Document.cxx
  ** Text document that handles notifications, DBCS, styling, words and end of line.
  **/
-// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cstdio>
+#include <cmath>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <forward_list>
+#include <algorithm>
+#include <memory>
+#include <chrono>
+
+#ifndef NO_CXX11_REGEX
+#include <regex>
+#endif
 
 #include "Platform.h"
 
+#include "ILoader.h"
+#include "ILexer.h"
 #include "Scintilla.h"
+
+#include "CharacterSet.h"
+#include "CharacterCategory.h"
+#include "Position.h"
 #include "SplitVector.h"
 #include "Partitioning.h"
 #include "RunStyles.h"
 #include "CellBuffer.h"
+#include "PerLine.h"
 #include "CharClassify.h"
 #include "Decoration.h"
+#include "CaseFolder.h"
 #include "Document.h"
 #include "RESearch.h"
+#include "UniConversion.h"
+#include "ElapsedPeriod.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-// This is ASCII specific but is safe with chars >= 0x80
-static inline bool isspacechar(unsigned char ch) {
-	return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d));
+void LexInterface::Colourise(Sci::Position start, Sci::Position end) {
+	if (pdoc && instance && !performingStyle) {
+		// Protect against reentrance, which may occur, for example, when
+		// fold points are discovered while performing styling and the folding
+		// code looks for child lines which may trigger styling.
+		performingStyle = true;
+
+		const Sci::Position lengthDoc = pdoc->Length();
+		if (end == -1)
+			end = lengthDoc;
+		const Sci::Position len = end - start;
+
+		PLATFORM_ASSERT(len >= 0);
+		PLATFORM_ASSERT(start + len <= lengthDoc);
+
+		int styleStart = 0;
+		if (start > 0)
+			styleStart = pdoc->StyleAt(start - 1);
+
+		if (len > 0) {
+			instance->Lex(start, len, styleStart, pdoc);
+			instance->Fold(start, len, styleStart, pdoc);
+		}
+
+		performingStyle = false;
+	}
 }
 
-static inline bool IsPunctuation(char ch) {
-	return isascii(ch) && ispunct(ch);
+int LexInterface::LineEndTypesSupported() {
+	if (instance) {
+		return instance->LineEndTypesSupported();
+	}
+	return 0;
 }
 
-static inline bool IsADigit(char ch) {
-	return isascii(ch) && isdigit(ch);
+ActionDuration::ActionDuration(double duration_, double minDuration_, double maxDuration_) noexcept :
+	duration(duration_), minDuration(minDuration_), maxDuration(maxDuration_) {
 }
 
-static inline bool IsLowerCase(char ch) {
-	return isascii(ch) && islower(ch);
+void ActionDuration::AddSample(size_t numberActions, double durationOfActions) noexcept {
+	// Only adjust for multiple actions to avoid instability
+	if (numberActions < 8)
+		return;
+
+	// Alpha value for exponential smoothing.
+	// Most recent value contributes 25% to smoothed value.
+	constexpr double alpha = 0.25;
+
+	const double durationOne = durationOfActions / numberActions;
+	duration = std::clamp(alpha * durationOne + (1.0 - alpha) * duration,
+		minDuration, maxDuration);
 }
 
-static inline bool IsUpperCase(char ch) {
-	return isascii(ch) && isupper(ch);
+double ActionDuration::Duration() const noexcept {
+	return duration;
 }
 
-Document::Document() {
+Document::Document(int options) :
+	cb((options & SC_DOCUMENTOPTION_STYLES_NONE) == 0, (options & SC_DOCUMENTOPTION_TEXT_LARGE) != 0),
+	durationStyleOneLine(0.00001, 0.000001, 0.0001) {
 	refCount = 0;
-#ifdef unix
-	eolMode = SC_EOL_LF;
-#else
+#ifdef _WIN32
 	eolMode = SC_EOL_CRLF;
+#else
+	eolMode = SC_EOL_LF;
 #endif
-	dbcsCodePage = 0;
-	stylingBits = 5;
-	stylingBitsMask = 0x1F;
-	stylingMask = 0;
+	dbcsCodePage = SC_CP_UTF8;
+	lineEndBitSet = SC_LINE_END_TYPE_DEFAULT;
 	endStyled = 0;
 	styleClock = 0;
 	enteredModification = 0;
 	enteredStyling = 0;
 	enteredReadOnlyCount = 0;
+	insertionSet = false;
 	tabInChars = 8;
 	indentInChars = 0;
 	actualIndentInChars = 8;
 	useTabs = true;
 	tabIndents = true;
 	backspaceUnindents = false;
-	watchers = 0;
-	lenWatchers = 0;
 
 	matchesValid = false;
-	regex = 0;
+
+	perLineData[ldMarkers] = std::make_unique<LineMarkers>();
+	perLineData[ldLevels] = std::make_unique<LineLevels>();
+	perLineData[ldState] = std::make_unique<LineState>();
+	perLineData[ldMargin] = std::make_unique<LineAnnotation>();
+	perLineData[ldAnnotation] = std::make_unique<LineAnnotation>();
+	perLineData[ldEOLAnnotation] = std::make_unique<LineAnnotation>();
+
+	decorations = DecorationListCreate(IsLarge());
+
+	cb.SetPerLine(this);
+	cb.SetUTF8Substance(SC_CP_UTF8 == dbcsCodePage);
 }
 
 Document::~Document() {
-	for (int i = 0; i < lenWatchers; i++) {
-		watchers[i].watcher->NotifyDeleted(this, watchers[i].userData);
+	for (const WatcherWithUserData &watcher : watchers) {
+		watcher.watcher->NotifyDeleted(this, watcher.userData);
 	}
-	delete []watchers;
-	watchers = 0;
-	lenWatchers = 0;
-	delete regex;
-	regex = 0;
 }
 
 // Increase reference count and return its previous value.
@@ -94,63 +158,264 @@ int Document::AddRef() {
 
 // Decrease reference count and return its previous value.
 // Delete the document if reference count reaches zero.
-int Document::Release() {
-	int curRefCount = --refCount;
+int SCI_METHOD Document::Release() {
+	const int curRefCount = --refCount;
 	if (curRefCount == 0)
 		delete this;
 	return curRefCount;
 }
 
+void Document::Init() {
+	for (const std::unique_ptr<PerLine> &pl : perLineData) {
+		if (pl)
+			pl->Init();
+	}
+}
+
+void Document::InsertLine(Sci::Line line) {
+	for (const std::unique_ptr<PerLine> &pl : perLineData) {
+		if (pl)
+			pl->InsertLine(line);
+	}
+}
+
+void Document::InsertLines(Sci::Line line, Sci::Line lines) {
+	for (const auto &pl : perLineData) {
+		if (pl)
+			pl->InsertLines(line, lines);
+	}
+}
+
+void Document::RemoveLine(Sci::Line line) {
+	for (const std::unique_ptr<PerLine> &pl : perLineData) {
+		if (pl)
+			pl->RemoveLine(line);
+	}
+}
+
+LineMarkers *Document::Markers() const noexcept {
+	return dynamic_cast<LineMarkers *>(perLineData[ldMarkers].get());
+}
+
+LineLevels *Document::Levels() const noexcept {
+	return dynamic_cast<LineLevels *>(perLineData[ldLevels].get());
+}
+
+LineState *Document::States() const noexcept {
+	return dynamic_cast<LineState *>(perLineData[ldState].get());
+}
+
+LineAnnotation *Document::Margins() const noexcept {
+	return dynamic_cast<LineAnnotation *>(perLineData[ldMargin].get());
+}
+
+LineAnnotation *Document::Annotations() const noexcept {
+	return dynamic_cast<LineAnnotation *>(perLineData[ldAnnotation].get());
+}
+
+LineAnnotation *Document::EOLAnnotations() const noexcept {
+	return dynamic_cast<LineAnnotation *>(perLineData[ldEOLAnnotation].get());
+}
+
+int Document::LineEndTypesSupported() const {
+	if ((SC_CP_UTF8 == dbcsCodePage) && pli)
+		return pli->LineEndTypesSupported();
+	else
+		return 0;
+}
+
+bool Document::SetDBCSCodePage(int dbcsCodePage_) {
+	if (dbcsCodePage != dbcsCodePage_) {
+		dbcsCodePage = dbcsCodePage_;
+		SetCaseFolder(nullptr);
+		cb.SetLineEndTypes(lineEndBitSet & LineEndTypesSupported());
+		cb.SetUTF8Substance(SC_CP_UTF8 == dbcsCodePage);
+		ModifiedAt(0);	// Need to restyle whole document
+		return true;
+	} else {
+		return false;
+	}
+}
+
+bool Document::SetLineEndTypesAllowed(int lineEndBitSet_) {
+	if (lineEndBitSet != lineEndBitSet_) {
+		lineEndBitSet = lineEndBitSet_;
+		const int lineEndBitSetActive = lineEndBitSet & LineEndTypesSupported();
+		if (lineEndBitSetActive != cb.GetLineEndTypes()) {
+			ModifiedAt(0);
+			cb.SetLineEndTypes(lineEndBitSetActive);
+			return true;
+		} else {
+			return false;
+		}
+	} else {
+		return false;
+	}
+}
+
 void Document::SetSavePoint() {
 	cb.SetSavePoint();
 	NotifySavePoint(true);
 }
 
-int Document::AddMark(int line, int markerNum) {
-	int prev = cb.AddMark(line, markerNum);
-	DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, 0, line);
-	NotifyModified(mh);
-	return prev;
+void Document::TentativeUndo() {
+	if (!TentativeActive())
+		return;
+	CheckReadOnly();
+	if (enteredModification == 0) {
+		enteredModification++;
+		if (!cb.IsReadOnly()) {
+			const bool startSavePoint = cb.IsSavePoint();
+			bool multiLine = false;
+			const int steps = cb.TentativeSteps();
+			//Platform::DebugPrintf("Steps=%d\n", steps);
+			for (int step = 0; step < steps; step++) {
+				const Sci::Line prevLinesTotal = LinesTotal();
+				const Action &action = cb.GetUndoStep();
+				if (action.at == removeAction) {
+					NotifyModified(DocModification(
+									SC_MOD_BEFOREINSERT | SC_PERFORMED_UNDO, action));
+				} else if (action.at == containerAction) {
+					DocModification dm(SC_MOD_CONTAINER | SC_PERFORMED_UNDO);
+					dm.token = action.position;
+					NotifyModified(dm);
+				} else {
+					NotifyModified(DocModification(
+									SC_MOD_BEFOREDELETE | SC_PERFORMED_UNDO, action));
+				}
+				cb.PerformUndoStep();
+				if (action.at != containerAction) {
+					ModifiedAt(action.position);
+				}
+
+				int modFlags = SC_PERFORMED_UNDO;
+				// With undo, an insertion action becomes a deletion notification
+				if (action.at == removeAction) {
+					modFlags |= SC_MOD_INSERTTEXT;
+				} else if (action.at == insertAction) {
+					modFlags |= SC_MOD_DELETETEXT;
+				}
+				if (steps > 1)
+					modFlags |= SC_MULTISTEPUNDOREDO;
+				const Sci::Line linesAdded = LinesTotal() - prevLinesTotal;
+				if (linesAdded != 0)
+					multiLine = true;
+				if (step == steps - 1) {
+					modFlags |= SC_LASTSTEPINUNDOREDO;
+					if (multiLine)
+						modFlags |= SC_MULTILINEUNDOREDO;
+				}
+				NotifyModified(DocModification(modFlags, action.position, action.lenData,
+											   linesAdded, action.data.get()));
+			}
+
+			const bool endSavePoint = cb.IsSavePoint();
+			if (startSavePoint != endSavePoint)
+				NotifySavePoint(endSavePoint);
+
+			cb.TentativeCommit();
+		}
+		enteredModification--;
+	}
+}
+
+int Document::GetMark(Sci::Line line) const noexcept {
+	return Markers()->MarkValue(line);
+}
+
+Sci::Line Document::MarkerNext(Sci::Line lineStart, int mask) const noexcept {
+	return Markers()->MarkerNext(lineStart, mask);
+}
+
+int Document::AddMark(Sci::Line line, int markerNum) {
+	if (line >= 0 && line <= LinesTotal()) {
+		const int prev = Markers()->AddMark(line, markerNum, LinesTotal());
+		const DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, nullptr, line);
+		NotifyModified(mh);
+		return prev;
+	} else {
+		return -1;
+	}
 }
 
-void Document::AddMarkSet(int line, int valueSet) {
+void Document::AddMarkSet(Sci::Line line, int valueSet) {
+	if (line < 0 || line > LinesTotal()) {
+		return;
+	}
 	unsigned int m = valueSet;
-	for (int i = 0; m; i++, m >>= 1)
+	for (int i = 0; m; i++, m >>= 1) {
 		if (m & 1)
-			cb.AddMark(line, i);
-	DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, 0, line);
+			Markers()->AddMark(line, i, LinesTotal());
+	}
+	const DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, nullptr, line);
 	NotifyModified(mh);
 }
 
-void Document::DeleteMark(int line, int markerNum) {
-	cb.DeleteMark(line, markerNum);
-	DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, 0, line);
+void Document::DeleteMark(Sci::Line line, int markerNum) {
+	Markers()->DeleteMark(line, markerNum, false);
+	const DocModification mh(SC_MOD_CHANGEMARKER, LineStart(line), 0, 0, nullptr, line);
 	NotifyModified(mh);
 }
 
 void Document::DeleteMarkFromHandle(int markerHandle) {
-	cb.DeleteMarkFromHandle(markerHandle);
-	DocModification mh(SC_MOD_CHANGEMARKER, 0, 0, 0, 0);
+	Markers()->DeleteMarkFromHandle(markerHandle);
+	DocModification mh(SC_MOD_CHANGEMARKER);
 	mh.line = -1;
 	NotifyModified(mh);
 }
 
 void Document::DeleteAllMarks(int markerNum) {
-	cb.DeleteAllMarks(markerNum);
-	DocModification mh(SC_MOD_CHANGEMARKER, 0, 0, 0, 0);
-	mh.line = -1;
-	NotifyModified(mh);
+	bool someChanges = false;
+	for (Sci::Line line = 0; line < LinesTotal(); line++) {
+		if (Markers()->DeleteMark(line, markerNum, true))
+			someChanges = true;
+	}
+	if (someChanges) {
+		DocModification mh(SC_MOD_CHANGEMARKER);
+		mh.line = -1;
+		NotifyModified(mh);
+	}
+}
+
+Sci::Line Document::LineFromHandle(int markerHandle) const noexcept {
+	return Markers()->LineFromHandle(markerHandle);
 }
 
-int Document::LineStart(int line) const {
+int Document::MarkerNumberFromLine(Sci::Line line, int which) const noexcept {
+	return Markers()->NumberFromLine(line, which);
+}
+
+int Document::MarkerHandleFromLine(Sci::Line line, int which) const noexcept {
+	return Markers()->HandleFromLine(line, which);
+}
+
+Sci_Position SCI_METHOD Document::LineStart(Sci_Position line) const {
 	return cb.LineStart(line);
 }
 
-int Document::LineEnd(int line) const {
-	if (line == LinesTotal() - 1) {
+bool Document::IsLineStartPosition(Sci::Position position) const {
+	return LineStart(LineFromPosition(position)) == position;
+}
+
+Sci_Position SCI_METHOD Document::LineEnd(Sci_Position line) const {
+	if (line >= LinesTotal() - 1) {
 		return LineStart(line + 1);
 	} else {
-		int position = LineStart(line + 1) - 1;
+		Sci::Position position = LineStart(line + 1);
+		if (SC_LINE_END_TYPE_UNICODE == cb.GetLineEndTypes()) {
+			const unsigned char bytes[] = {
+				cb.UCharAt(position-3),
+				cb.UCharAt(position-2),
+				cb.UCharAt(position-1),
+			};
+			if (UTF8IsSeparator(bytes)) {
+				return position - UTF8SeparatorLength;
+			}
+			if (UTF8IsNEL(bytes+1)) {
+				return position - UTF8NELLength;
+			}
+		}
+		position--; // Back over CR or LF
 		// When line terminator is CR+LF, may need to go back one more
 		if ((position > LineStart(line)) && (cb.CharAt(position - 1) == '\r')) {
 			position--;
@@ -159,20 +424,40 @@ int Document::LineEnd(int line) const {
 	}
 }
 
-int Document::LineFromPosition(int pos) {
+void SCI_METHOD Document::SetErrorStatus(int status) {
+	// Tell the watchers an error has occurred.
+	for (const WatcherWithUserData &watcher : watchers) {
+		watcher.watcher->NotifyErrorOccurred(this, watcher.userData, status);
+	}
+}
+
+Sci_Position SCI_METHOD Document::LineFromPosition(Sci_Position pos) const {
 	return cb.LineFromPosition(pos);
 }
 
-int Document::LineEndPosition(int position) {
+Sci::Line Document::SciLineFromPosition(Sci::Position pos) const noexcept {
+	// Avoids casting in callers for this very common function
+	return cb.LineFromPosition(pos);
+}
+
+Sci::Position Document::LineEndPosition(Sci::Position position) const {
 	return LineEnd(LineFromPosition(position));
 }
 
-int Document::VCHomePosition(int position) {
-	int line = LineFromPosition(position);
-	int startPosition = LineStart(line);
-	int endLine = LineEnd(line);
-	int startText = startPosition;
-	while (startText < endLine && (cb.CharAt(startText) == ' ' || cb.CharAt(startText) == '\t' ) )
+bool Document::IsLineEndPosition(Sci::Position position) const {
+	return LineEnd(LineFromPosition(position)) == position;
+}
+
+bool Document::IsPositionInLineEnd(Sci::Position position) const {
+	return position >= LineEnd(LineFromPosition(position));
+}
+
+Sci::Position Document::VCHomePosition(Sci::Position position) const {
+	const Sci::Line line = SciLineFromPosition(position);
+	const Sci::Position startPosition = LineStart(line);
+	const Sci::Position endLine = LineEnd(line);
+	Sci::Position startText = startPosition;
+	while (startText < endLine && (cb.CharAt(startText) == ' ' || cb.CharAt(startText) == '\t'))
 		startText++;
 	if (position == startText)
 		return startPosition;
@@ -180,11 +465,19 @@ int Document::VCHomePosition(int position) {
 		return startText;
 }
 
-int Document::SetLevel(int line, int level) {
-	int prev = cb.SetLevel(line, level);
+Sci::Position Document::IndexLineStart(Sci::Line line, int lineCharacterIndex) const noexcept {
+	return cb.IndexLineStart(line, lineCharacterIndex);
+}
+
+Sci::Line Document::LineFromPositionIndex(Sci::Position pos, int lineCharacterIndex) const noexcept {
+	return cb.LineFromPositionIndex(pos, lineCharacterIndex);
+}
+
+int SCI_METHOD Document::SetLevel(Sci_Position line, int level) {
+	const int prev = Levels()->SetLevel(line, level, LinesTotal());
 	if (prev != level) {
 		DocModification mh(SC_MOD_CHANGEFOLD | SC_MOD_CHANGEMARKER,
-		                   LineStart(line), 0, 0, 0, line);
+		                   LineStart(line), 0, 0, nullptr, line);
 		mh.foldLevelNow = level;
 		mh.foldLevelPrev = prev;
 		NotifyModified(mh);
@@ -192,26 +485,37 @@ int Document::SetLevel(int line, int level) {
 	return prev;
 }
 
-static bool IsSubordinate(int levelStart, int levelTry) {
+int SCI_METHOD Document::GetLevel(Sci_Position line) const {
+	return Levels()->GetLevel(line);
+}
+
+void Document::ClearLevels() {
+	Levels()->ClearLevels();
+}
+
+static bool IsSubordinate(int levelStart, int levelTry) noexcept {
 	if (levelTry & SC_FOLDLEVELWHITEFLAG)
 		return true;
 	else
-		return (levelStart & SC_FOLDLEVELNUMBERMASK) < (levelTry & SC_FOLDLEVELNUMBERMASK);
+		return LevelNumber(levelStart) < LevelNumber(levelTry);
 }
 
-int Document::GetLastChild(int lineParent, int level) {
+Sci::Line Document::GetLastChild(Sci::Line lineParent, int level, Sci::Line lastLine) {
 	if (level == -1)
-		level = GetLevel(lineParent) & SC_FOLDLEVELNUMBERMASK;
-	int maxLine = LinesTotal();
-	int lineMaxSubord = lineParent;
+		level = LevelNumber(GetLevel(lineParent));
+	const Sci::Line maxLine = LinesTotal();
+	const Sci::Line lookLastLine = (lastLine != -1) ? std::min(LinesTotal() - 1, lastLine) : -1;
+	Sci::Line lineMaxSubord = lineParent;
 	while (lineMaxSubord < maxLine - 1) {
 		EnsureStyledTo(LineStart(lineMaxSubord + 2));
 		if (!IsSubordinate(level, GetLevel(lineMaxSubord + 1)))
 			break;
+		if ((lookLastLine != -1) && (lineMaxSubord >= lookLastLine) && !(GetLevel(lineMaxSubord) & SC_FOLDLEVELWHITEFLAG))
+			break;
 		lineMaxSubord++;
 	}
 	if (lineMaxSubord > lineParent) {
-		if (level > (GetLevel(lineMaxSubord + 1) & SC_FOLDLEVELNUMBERMASK)) {
+		if (level > LevelNumber(GetLevel(lineMaxSubord + 1))) {
 			// Have chewed up some whitespace that belongs to a parent so seek back
 			if (GetLevel(lineMaxSubord) & SC_FOLDLEVELWHITEFLAG) {
 				lineMaxSubord--;
@@ -221,114 +525,163 @@ int Document::GetLastChild(int lineParent, int level) {
 	return lineMaxSubord;
 }
 
-int Document::GetFoldParent(int line) {
-	int level = GetLevel(line) & SC_FOLDLEVELNUMBERMASK;
-	int lineLook = line - 1;
+Sci::Line Document::GetFoldParent(Sci::Line line) const {
+	const int level = LevelNumber(GetLevel(line));
+	Sci::Line lineLook = line - 1;
 	while ((lineLook > 0) && (
 	            (!(GetLevel(lineLook) & SC_FOLDLEVELHEADERFLAG)) ||
-	            ((GetLevel(lineLook) & SC_FOLDLEVELNUMBERMASK) >= level))
+	            (LevelNumber(GetLevel(lineLook)) >= level))
 	      ) {
 		lineLook--;
 	}
 	if ((GetLevel(lineLook) & SC_FOLDLEVELHEADERFLAG) &&
-	        ((GetLevel(lineLook) & SC_FOLDLEVELNUMBERMASK) < level)) {
+	        (LevelNumber(GetLevel(lineLook)) < level)) {
 		return lineLook;
 	} else {
 		return -1;
 	}
 }
 
-int Document::ClampPositionIntoDocument(int pos) {
-	return Platform::Clamp(pos, 0, Length());
+void Document::GetHighlightDelimiters(HighlightDelimiter &highlightDelimiter, Sci::Line line, Sci::Line lastLine) {
+	const int level = GetLevel(line);
+	const Sci::Line lookLastLine = std::max(line, lastLine) + 1;
+
+	Sci::Line lookLine = line;
+	int lookLineLevel = level;
+	int lookLineLevelNum = LevelNumber(lookLineLevel);
+	while ((lookLine > 0) && ((lookLineLevel & SC_FOLDLEVELWHITEFLAG) ||
+		((lookLineLevel & SC_FOLDLEVELHEADERFLAG) && (lookLineLevelNum >= LevelNumber(GetLevel(lookLine + 1)))))) {
+		lookLineLevel = GetLevel(--lookLine);
+		lookLineLevelNum = LevelNumber(lookLineLevel);
+	}
+
+	Sci::Line beginFoldBlock = (lookLineLevel & SC_FOLDLEVELHEADERFLAG) ? lookLine : GetFoldParent(lookLine);
+	if (beginFoldBlock == -1) {
+		highlightDelimiter.Clear();
+		return;
+	}
+
+	Sci::Line endFoldBlock = GetLastChild(beginFoldBlock, -1, lookLastLine);
+	Sci::Line firstChangeableLineBefore = -1;
+	if (endFoldBlock < line) {
+		lookLine = beginFoldBlock - 1;
+		lookLineLevel = GetLevel(lookLine);
+		lookLineLevelNum = LevelNumber(lookLineLevel);
+		while ((lookLine >= 0) && (lookLineLevelNum >= SC_FOLDLEVELBASE)) {
+			if (lookLineLevel & SC_FOLDLEVELHEADERFLAG) {
+				if (GetLastChild(lookLine, -1, lookLastLine) == line) {
+					beginFoldBlock = lookLine;
+					endFoldBlock = line;
+					firstChangeableLineBefore = line - 1;
+				}
+			}
+			if ((lookLine > 0) && (lookLineLevelNum == SC_FOLDLEVELBASE) && (LevelNumber(GetLevel(lookLine - 1)) > lookLineLevelNum))
+				break;
+			lookLineLevel = GetLevel(--lookLine);
+			lookLineLevelNum = LevelNumber(lookLineLevel);
+		}
+	}
+	if (firstChangeableLineBefore == -1) {
+		for (lookLine = line - 1, lookLineLevel = GetLevel(lookLine), lookLineLevelNum = LevelNumber(lookLineLevel);
+			lookLine >= beginFoldBlock;
+			lookLineLevel = GetLevel(--lookLine), lookLineLevelNum = LevelNumber(lookLineLevel)) {
+			if ((lookLineLevel & SC_FOLDLEVELWHITEFLAG) || (lookLineLevelNum > LevelNumber(level))) {
+				firstChangeableLineBefore = lookLine;
+				break;
+			}
+		}
+	}
+	if (firstChangeableLineBefore == -1)
+		firstChangeableLineBefore = beginFoldBlock - 1;
+
+	Sci::Line firstChangeableLineAfter = -1;
+	for (lookLine = line + 1, lookLineLevel = GetLevel(lookLine), lookLineLevelNum = LevelNumber(lookLineLevel);
+		lookLine <= endFoldBlock;
+		lookLineLevel = GetLevel(++lookLine), lookLineLevelNum = LevelNumber(lookLineLevel)) {
+		if ((lookLineLevel & SC_FOLDLEVELHEADERFLAG) && (lookLineLevelNum < LevelNumber(GetLevel(lookLine + 1)))) {
+			firstChangeableLineAfter = lookLine;
+			break;
+		}
+	}
+	if (firstChangeableLineAfter == -1)
+		firstChangeableLineAfter = endFoldBlock + 1;
+
+	highlightDelimiter.beginFoldBlock = beginFoldBlock;
+	highlightDelimiter.endFoldBlock = endFoldBlock;
+	highlightDelimiter.firstChangeableLineBefore = firstChangeableLineBefore;
+	highlightDelimiter.firstChangeableLineAfter = firstChangeableLineAfter;
+}
+
+Sci::Position Document::ClampPositionIntoDocument(Sci::Position pos) const noexcept {
+	return std::clamp<Sci::Position>(pos, 0, LengthNoExcept());
 }
 
-bool Document::IsCrLf(int pos) {
+bool Document::IsCrLf(Sci::Position pos) const noexcept {
 	if (pos < 0)
 		return false;
-	if (pos >= (Length() - 1))
+	if (pos >= (LengthNoExcept() - 1))
 		return false;
 	return (cb.CharAt(pos) == '\r') && (cb.CharAt(pos + 1) == '\n');
 }
 
-static const int maxBytesInDBCSCharacter=5;
-
-int Document::LenChar(int pos) {
-	if (pos < 0) {
+int Document::LenChar(Sci::Position pos) const noexcept {
+	if (pos < 0 || pos >= LengthNoExcept()) {
+		// Returning 1 instead of 0 to defend against hanging with a loop that goes (or starts) out of bounds.
 		return 1;
 	} else if (IsCrLf(pos)) {
 		return 2;
-	} else if (SC_CP_UTF8 == dbcsCodePage) {
-		unsigned char ch = static_cast<unsigned char>(cb.CharAt(pos));
-		if (ch < 0x80)
+	}
+
+	const unsigned char leadByte = cb.UCharAt(pos);
+	if (!dbcsCodePage || UTF8IsAscii(leadByte)) {
+		// Common case: ASCII character
+		return 1;
+	}
+	if (SC_CP_UTF8 == dbcsCodePage) {
+		const int widthCharBytes = UTF8BytesOfLead[leadByte];
+		unsigned char charBytes[UTF8MaxBytes] = { leadByte, 0, 0, 0 };
+		for (int b = 1; b < widthCharBytes; b++) {
+			charBytes[b] = cb.UCharAt(pos + b);
+		}
+		const int utf8status = UTF8Classify(charBytes, widthCharBytes);
+		if (utf8status & UTF8MaskInvalid) {
+			// Treat as invalid and use up just one byte
 			return 1;
-		int len = 2;
-		if (ch >= (0x80 + 0x40 + 0x20 + 0x10))
-			len = 4;
-		else if (ch >= (0x80 + 0x40 + 0x20))
-			len = 3;
-		int lengthDoc = Length();
-		if ((pos + len) > lengthDoc)
-			return lengthDoc -pos;
-		else
-			return len;
-	} else if (dbcsCodePage) {
-		char mbstr[maxBytesInDBCSCharacter+1];
-		int i;
-		for (i=0; i<Platform::DBCSCharMaxLength(); i++) {
-			mbstr[i] = cb.CharAt(pos+i);
+		} else {
+			return utf8status & UTF8MaskWidth;
 		}
-		mbstr[i] = '\0';
-		return Platform::DBCSCharLength(dbcsCodePage, mbstr);
 	} else {
-		return 1;
+		if (IsDBCSLeadByteNoExcept(leadByte) && ((pos + 1) < LengthNoExcept())) {
+			return 2;
+		} else {
+			return 1;
+		}
 	}
 }
 
-static bool IsTrailByte(int ch) {
-	return (ch >= 0x80) && (ch < (0x80 + 0x40));
-}
+bool Document::InGoodUTF8(Sci::Position pos, Sci::Position &start, Sci::Position &end) const noexcept {
+	Sci::Position trail = pos;
+	while ((trail>0) && (pos-trail < UTF8MaxBytes) && UTF8IsTrailByte(cb.UCharAt(trail-1)))
+		trail--;
+	start = (trail > 0) ? trail-1 : trail;
 
-static int BytesFromLead(int leadByte) {
-	if (leadByte > 0xF4) {
-		// Characters longer than 4 bytes not possible in current UTF-8
-		return 0;
-	} else if (leadByte >= 0xF0) {
-		return 4;
-	} else if (leadByte >= 0xE0) {
-		return 3;
-	} else if (leadByte >= 0xC2) {
-		return 2;
-	}
-	return 0;
-}
-
-bool Document::InGoodUTF8(int pos, int &start, int &end) {
-	int lead = pos;
-	while ((lead>0) && (pos-lead < 4) && IsTrailByte(static_cast<unsigned char>(cb.CharAt(lead-1))))
-		lead--;
-	start = 0;
-	if (lead > 0) {
-		start = lead-1;
-	}
-	int leadByte = static_cast<unsigned char>(cb.CharAt(start));
-	int bytes = BytesFromLead(leadByte);
-	if (bytes == 0) {
+	const unsigned char leadByte = cb.UCharAt(start);
+	const int widthCharBytes = UTF8BytesOfLead[leadByte];
+	if (widthCharBytes == 1) {
 		return false;
 	} else {
-		int trailBytes = bytes - 1;
-		int len = pos - lead + 1;
+		const int trailBytes = widthCharBytes - 1;
+		const Sci::Position len = pos - start;
 		if (len > trailBytes)
 			// pos too far from lead
 			return false;
-		// Check that there are enough trails for this lead
-		int trail = pos + 1;
-		while ((trail-lead<trailBytes) && (trail < Length())) {
-			if (!IsTrailByte(static_cast<unsigned char>(cb.CharAt(trail)))) {
-				return false;
-			}
-			trail++;
-		}
-		end = start + bytes;
+		unsigned char charBytes[UTF8MaxBytes] = {leadByte,0,0,0};
+		for (Sci::Position b=1; b<widthCharBytes && ((start+b) < cb.Length()); b++)
+			charBytes[b] = cb.CharAt(start+b);
+		const int utf8status = UTF8Classify(charBytes, widthCharBytes);
+		if (utf8status & UTF8MaskInvalid)
+			return false;
+		end = start + widthCharBytes;
 		return true;
 	}
 }
@@ -338,15 +691,15 @@ bool Document::InGoodUTF8(int pos, int &start, int &end) {
 // When lines are terminated with \r\n pairs which should be treated as one character.
 // When displaying DBCS text such as Japanese.
 // If moving, move the position in the indicated direction.
-int Document::MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd) {
+Sci::Position Document::MovePositionOutsideChar(Sci::Position pos, Sci::Position moveDir, bool checkLineEnd) const noexcept {
 	//Platform::DebugPrintf("NoCRLF %d %d\n", pos, moveDir);
 	// If out of range, just return minimum/maximum value.
 	if (pos <= 0)
 		return 0;
-	if (pos >= Length())
-		return Length();
+	if (pos >= LengthNoExcept())
+		return LengthNoExcept();
 
-	// PLATFORM_ASSERT(pos > 0 && pos < Length());
+	// PLATFORM_ASSERT(pos > 0 && pos < LengthNoExcept());
 	if (checkLineEnd && IsCrLf(pos - 1)) {
 		if (moveDir > 0)
 			return pos + 1;
@@ -354,33 +707,37 @@ int Document::MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd) {
 			return pos - 1;
 	}
 
-	// Not between CR and LF
-
 	if (dbcsCodePage) {
 		if (SC_CP_UTF8 == dbcsCodePage) {
-			unsigned char ch = static_cast<unsigned char>(cb.CharAt(pos));
-			int startUTF = pos;
-			int endUTF = pos;
-			if (IsTrailByte(ch) && InGoodUTF8(pos, startUTF, endUTF)) {
-				// ch is a trail byte within a UTF-8 character
-				if (moveDir > 0)
-					pos = endUTF;
-				else
-					pos = startUTF;
+			const unsigned char ch = cb.UCharAt(pos);
+			// If ch is not a trail byte then pos is valid intercharacter position
+			if (UTF8IsTrailByte(ch)) {
+				Sci::Position startUTF = pos;
+				Sci::Position endUTF = pos;
+				if (InGoodUTF8(pos, startUTF, endUTF)) {
+					// ch is a trail byte within a UTF-8 character
+					if (moveDir > 0)
+						pos = endUTF;
+					else
+						pos = startUTF;
+				}
+				// Else invalid UTF-8 so return position of isolated trail byte
 			}
 		} else {
 			// Anchor DBCS calculations at start of line because start of line can
 			// not be a DBCS trail byte.
-			int posCheck = LineStart(LineFromPosition(pos));
-			while (posCheck < pos) {
-				char mbstr[maxBytesInDBCSCharacter+1];
-				int i;
-				for(i=0;i<Platform::DBCSCharMaxLength();i++) {
-					mbstr[i] = cb.CharAt(posCheck+i);
-				}
-				mbstr[i] = '\0';
+			const Sci::Position posStartLine = cb.LineStart(cb.LineFromPosition(pos));
+			if (pos == posStartLine)
+				return pos;
 
-				int mbsize = Platform::DBCSCharLength(dbcsCodePage, mbstr);
+			// Step back until a non-lead-byte is found.
+			Sci::Position posCheck = pos;
+			while ((posCheck > posStartLine) && IsDBCSLeadByteNoExcept(cb.CharAt(posCheck-1)))
+				posCheck--;
+
+			// Check from known start of character.
+			while (posCheck < pos) {
+				const int mbsize = IsDBCSLeadByteNoExcept(cb.CharAt(posCheck)) ? 2 : 1;
 				if (posCheck + mbsize == pos) {
 					return pos;
 				} else if (posCheck + mbsize > pos) {
@@ -398,7 +755,434 @@ int Document::MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd) {
 	return pos;
 }
 
-void Document::ModifiedAt(int pos) {
+// NextPosition moves between valid positions - it can not handle a position in the middle of a
+// multi-byte character. It is used to iterate through text more efficiently than MovePositionOutsideChar.
+// A \r\n pair is treated as two characters.
+Sci::Position Document::NextPosition(Sci::Position pos, int moveDir) const noexcept {
+	// If out of range, just return minimum/maximum value.
+	const int increment = (moveDir > 0) ? 1 : -1;
+	if (pos + increment <= 0)
+		return 0;
+	if (pos + increment >= cb.Length())
+		return cb.Length();
+
+	if (dbcsCodePage) {
+		if (SC_CP_UTF8 == dbcsCodePage) {
+			if (increment == 1) {
+				// Simple forward movement case so can avoid some checks
+				const unsigned char leadByte = cb.UCharAt(pos);
+				if (UTF8IsAscii(leadByte)) {
+					// Single byte character or invalid
+					pos++;
+				} else {
+					const int widthCharBytes = UTF8BytesOfLead[leadByte];
+					unsigned char charBytes[UTF8MaxBytes] = {leadByte,0,0,0};
+					for (int b=1; b<widthCharBytes; b++)
+						charBytes[b] = cb.CharAt(pos+b);
+					const int utf8status = UTF8Classify(charBytes, widthCharBytes);
+					if (utf8status & UTF8MaskInvalid)
+						pos++;
+					else
+						pos += utf8status & UTF8MaskWidth;
+				}
+			} else {
+				// Examine byte before position
+				pos--;
+				const unsigned char ch = cb.UCharAt(pos);
+				// If ch is not a trail byte then pos is valid intercharacter position
+				if (UTF8IsTrailByte(ch)) {
+					// If ch is a trail byte in a valid UTF-8 character then return start of character
+					Sci::Position startUTF = pos;
+					Sci::Position endUTF = pos;
+					if (InGoodUTF8(pos, startUTF, endUTF)) {
+						pos = startUTF;
+					}
+					// Else invalid UTF-8 so return position of isolated trail byte
+				}
+			}
+		} else {
+			if (moveDir > 0) {
+				const int mbsize = IsDBCSLeadByteNoExcept(cb.CharAt(pos)) ? 2 : 1;
+				pos += mbsize;
+				if (pos > cb.Length())
+					pos = cb.Length();
+			} else {
+				// Anchor DBCS calculations at start of line because start of line can
+				// not be a DBCS trail byte.
+				const Sci::Position posStartLine = cb.LineStart(cb.LineFromPosition(pos));
+				// See http://msdn.microsoft.com/en-us/library/cc194792%28v=MSDN.10%29.aspx
+				// http://msdn.microsoft.com/en-us/library/cc194790.aspx
+				if ((pos - 1) <= posStartLine) {
+					return pos - 1;
+				} else if (IsDBCSLeadByteNoExcept(cb.CharAt(pos - 1))) {
+					// Must actually be trail byte
+					return pos - 2;
+				} else {
+					// Otherwise, step back until a non-lead-byte is found.
+					Sci::Position posTemp = pos - 1;
+					while (posStartLine <= --posTemp && IsDBCSLeadByteNoExcept(cb.CharAt(posTemp)))
+						;
+					// Now posTemp+1 must point to the beginning of a character,
+					// so figure out whether we went back an even or an odd
+					// number of bytes and go back 1 or 2 bytes, respectively.
+					return (pos - 1 - ((pos - posTemp) & 1));
+				}
+			}
+		}
+	} else {
+		pos += increment;
+	}
+
+	return pos;
+}
+
+bool Document::NextCharacter(Sci::Position &pos, int moveDir) const noexcept {
+	// Returns true if pos changed
+	Sci::Position posNext = NextPosition(pos, moveDir);
+	if (posNext == pos) {
+		return false;
+	} else {
+		pos = posNext;
+		return true;
+	}
+}
+
+Document::CharacterExtracted Document::CharacterAfter(Sci::Position position) const noexcept {
+	if (position >= LengthNoExcept()) {
+		return CharacterExtracted(unicodeReplacementChar, 0);
+	}
+	const unsigned char leadByte = cb.UCharAt(position);
+	if (!dbcsCodePage || UTF8IsAscii(leadByte)) {
+		// Common case: ASCII character
+		return CharacterExtracted(leadByte, 1);
+	}
+	if (SC_CP_UTF8 == dbcsCodePage) {
+		const int widthCharBytes = UTF8BytesOfLead[leadByte];
+		unsigned char charBytes[UTF8MaxBytes] = { leadByte, 0, 0, 0 };
+		for (int b = 1; b<widthCharBytes; b++)
+			charBytes[b] = cb.UCharAt(position + b);
+		const int utf8status = UTF8Classify(charBytes, widthCharBytes);
+		if (utf8status & UTF8MaskInvalid) {
+			// Treat as invalid and use up just one byte
+			return CharacterExtracted(unicodeReplacementChar, 1);
+		} else {
+			return CharacterExtracted(UnicodeFromUTF8(charBytes), utf8status & UTF8MaskWidth);
+		}
+	} else {
+		if (IsDBCSLeadByteNoExcept(leadByte) && ((position + 1) < LengthNoExcept())) {
+			return CharacterExtracted::DBCS(leadByte, cb.UCharAt(position + 1));
+		} else {
+			return CharacterExtracted(leadByte, 1);
+		}
+	}
+}
+
+Document::CharacterExtracted Document::CharacterBefore(Sci::Position position) const noexcept {
+	if (position <= 0) {
+		return CharacterExtracted(unicodeReplacementChar, 0);
+	}
+	const unsigned char previousByte = cb.UCharAt(position - 1);
+	if (0 == dbcsCodePage) {
+		return CharacterExtracted(previousByte, 1);
+	}
+	if (SC_CP_UTF8 == dbcsCodePage) {
+		if (UTF8IsAscii(previousByte)) {
+			return CharacterExtracted(previousByte, 1);
+		}
+		position--;
+		// If previousByte is not a trail byte then its invalid
+		if (UTF8IsTrailByte(previousByte)) {
+			// If previousByte is a trail byte in a valid UTF-8 character then find start of character
+			Sci::Position startUTF = position;
+			Sci::Position endUTF = position;
+			if (InGoodUTF8(position, startUTF, endUTF)) {
+				const Sci::Position widthCharBytes = endUTF - startUTF;
+				unsigned char charBytes[UTF8MaxBytes] = { 0, 0, 0, 0 };
+				for (Sci::Position b = 0; b<widthCharBytes; b++)
+					charBytes[b] = cb.UCharAt(startUTF + b);
+				const int utf8status = UTF8Classify(charBytes, widthCharBytes);
+				if (utf8status & UTF8MaskInvalid) {
+					// Treat as invalid and use up just one byte
+					return CharacterExtracted(unicodeReplacementChar, 1);
+				} else {
+					return CharacterExtracted(UnicodeFromUTF8(charBytes), utf8status & UTF8MaskWidth);
+				}
+			}
+			// Else invalid UTF-8 so return position of isolated trail byte
+		}
+		return CharacterExtracted(unicodeReplacementChar, 1);
+	} else {
+		// Moving backwards in DBCS is complex so use NextPosition
+		const Sci::Position posStartCharacter = NextPosition(position, -1);
+		return CharacterAfter(posStartCharacter);
+	}
+}
+
+// Return -1  on out-of-bounds
+Sci_Position SCI_METHOD Document::GetRelativePosition(Sci_Position positionStart, Sci_Position characterOffset) const {
+	Sci::Position pos = positionStart;
+	if (dbcsCodePage) {
+		const int increment = (characterOffset > 0) ? 1 : -1;
+		while (characterOffset != 0) {
+			const Sci::Position posNext = NextPosition(pos, increment);
+			if (posNext == pos)
+				return INVALID_POSITION;
+			pos = posNext;
+			characterOffset -= increment;
+		}
+	} else {
+		pos = positionStart + characterOffset;
+		if ((pos < 0) || (pos > Length()))
+			return INVALID_POSITION;
+	}
+	return pos;
+}
+
+Sci::Position Document::GetRelativePositionUTF16(Sci::Position positionStart, Sci::Position characterOffset) const noexcept {
+	Sci::Position pos = positionStart;
+	if (dbcsCodePage) {
+		const int increment = (characterOffset > 0) ? 1 : -1;
+		while (characterOffset != 0) {
+			const Sci::Position posNext = NextPosition(pos, increment);
+			if (posNext == pos)
+				return INVALID_POSITION;
+			if (std::abs(pos-posNext) > 3)	// 4 byte character = 2*UTF16.
+				characterOffset -= increment;
+			pos = posNext;
+			characterOffset -= increment;
+		}
+	} else {
+		pos = positionStart + characterOffset;
+		if ((pos < 0) || (pos > LengthNoExcept()))
+			return INVALID_POSITION;
+	}
+	return pos;
+}
+
+int SCI_METHOD Document::GetCharacterAndWidth(Sci_Position position, Sci_Position *pWidth) const {
+	int character;
+	int bytesInCharacter = 1;
+	const unsigned char leadByte = cb.UCharAt(position);
+	if (dbcsCodePage) {
+		if (SC_CP_UTF8 == dbcsCodePage) {
+			if (UTF8IsAscii(leadByte)) {
+				// Single byte character or invalid
+				character =  leadByte;
+			} else {
+				const int widthCharBytes = UTF8BytesOfLead[leadByte];
+				unsigned char charBytes[UTF8MaxBytes] = {leadByte,0,0,0};
+				for (int b=1; b<widthCharBytes; b++)
+					charBytes[b] = cb.UCharAt(position+b);
+				const int utf8status = UTF8Classify(charBytes, widthCharBytes);
+				if (utf8status & UTF8MaskInvalid) {
+					// Report as singleton surrogate values which are invalid Unicode
+					character =  0xDC80 + leadByte;
+				} else {
+					bytesInCharacter = utf8status & UTF8MaskWidth;
+					character = UnicodeFromUTF8(charBytes);
+				}
+			}
+		} else {
+			if (IsDBCSLeadByteNoExcept(leadByte)) {
+				bytesInCharacter = 2;
+				character = (leadByte << 8) | cb.UCharAt(position+1);
+			} else {
+				character = leadByte;
+			}
+		}
+	} else {
+		character = leadByte;
+	}
+	if (pWidth) {
+		*pWidth = bytesInCharacter;
+	}
+	return character;
+}
+
+int SCI_METHOD Document::CodePage() const {
+	return dbcsCodePage;
+}
+
+bool SCI_METHOD Document::IsDBCSLeadByte(char ch) const {
+	// Used by lexers so must match IDocument method exactly
+	return IsDBCSLeadByteNoExcept(ch);
+}
+
+bool Document::IsDBCSLeadByteNoExcept(char ch) const noexcept {
+	// Used inside core Scintilla
+	// Byte ranges found in Wikipedia articles with relevant search strings in each case
+	const unsigned char uch = ch;
+	switch (dbcsCodePage) {
+		case 932:
+			// Shift_jis
+			return ((uch >= 0x81) && (uch <= 0x9F)) ||
+				((uch >= 0xE0) && (uch <= 0xFC));
+				// Lead bytes F0 to FC may be a Microsoft addition.
+		case 936:
+			// GBK
+			return (uch >= 0x81) && (uch <= 0xFE);
+		case 949:
+			// Korean Wansung KS C-5601-1987
+			return (uch >= 0x81) && (uch <= 0xFE);
+		case 950:
+			// Big5
+			return (uch >= 0x81) && (uch <= 0xFE);
+		case 1361:
+			// Korean Johab KS C-5601-1992
+			return
+				((uch >= 0x84) && (uch <= 0xD3)) ||
+				((uch >= 0xD8) && (uch <= 0xDE)) ||
+				((uch >= 0xE0) && (uch <= 0xF9));
+	}
+	return false;
+}
+
+bool Document::IsDBCSLeadByteInvalid(char ch) const noexcept {
+	const unsigned char lead = ch;
+	switch (dbcsCodePage) {
+	case 932:
+		// Shift_jis
+		return
+			(lead == 0x85) ||
+			(lead == 0x86) ||
+			(lead == 0xEB) ||
+			(lead == 0xEC) ||
+			(lead == 0xEF) ||
+			(lead == 0xFA) ||
+			(lead == 0xFB) ||
+			(lead == 0xFC);
+	case 936:
+		// GBK
+		return (lead == 0x80) || (lead == 0xFF);
+	case 949:
+		// Korean Wansung KS C-5601-1987
+		return (lead == 0x80) || (lead == 0xC9) || (lead >= 0xFE);
+	case 950:
+		// Big5
+		return
+			((lead >= 0x80) && (lead <= 0xA0)) ||
+			(lead == 0xC8) ||
+			(lead >= 0xFA);
+	case 1361:
+		// Korean Johab KS C-5601-1992
+		return
+			((lead >= 0x80) && (lead <= 0x83)) ||
+			((lead >= 0xD4) && (lead <= 0xD8)) ||
+			(lead == 0xDF) ||
+			(lead >= 0xFA);
+	}
+	return false;
+}
+
+bool Document::IsDBCSTrailByteInvalid(char ch) const noexcept {
+	const unsigned char trail = ch;
+	switch (dbcsCodePage) {
+	case 932:
+		// Shift_jis
+		return
+			(trail <= 0x3F) ||
+			(trail == 0x7F) ||
+			(trail >= 0xFD);
+	case 936:
+		// GBK
+		return
+			(trail <= 0x3F) ||
+			(trail == 0x7F) ||
+			(trail == 0xFF);
+	case 949:
+		// Korean Wansung KS C-5601-1987
+		return
+			(trail <= 0x40) ||
+			((trail >= 0x5B) && (trail <= 0x60)) ||
+			((trail >= 0x7B) && (trail <= 0x80)) ||
+			(trail == 0xFF);
+	case 950:
+		// Big5
+		return
+			(trail <= 0x3F) ||
+			((trail >= 0x7F) && (trail <= 0xA0)) ||
+			(trail == 0xFF);
+	case 1361:
+		// Korean Johab KS C-5601-1992
+		return
+			(trail <= 0x30) ||
+			(trail == 0x7F) ||
+			(trail == 0x80) ||
+			(trail == 0xFF);
+	}
+	return false;
+}
+
+int Document::DBCSDrawBytes(std::string_view text) const noexcept {
+	if (text.length() <= 1) {
+		return static_cast<int>(text.length());
+	}
+	if (IsDBCSLeadByteNoExcept(text[0])) {
+		return IsDBCSTrailByteInvalid(text[1]) ? 1 : 2;
+	} else {
+		return 1;
+	}
+}
+
+static constexpr bool IsSpaceOrTab(int ch) noexcept {
+	return ch == ' ' || ch == '\t';
+}
+
+// Need to break text into segments near lengthSegment but taking into
+// account the encoding to not break inside a UTF-8 or DBCS character
+// and also trying to avoid breaking inside a pair of combining characters.
+// The segment length must always be long enough (more than 4 bytes)
+// so that there will be at least one whole character to make a segment.
+// For UTF-8, text must consist only of valid whole characters.
+// In preference order from best to worst:
+//   1) Break after space
+//   2) Break before punctuation
+//   3) Break after whole character
+
+int Document::SafeSegment(const char *text, int length, int lengthSegment) const noexcept {
+	if (length <= lengthSegment)
+		return length;
+	int lastSpaceBreak = -1;
+	int lastPunctuationBreak = -1;
+	int lastEncodingAllowedBreak = 0;
+	for (int j=0; j < lengthSegment;) {
+		const unsigned char ch = text[j];
+		if (j > 0) {
+			if (IsSpaceOrTab(text[j - 1]) && !IsSpaceOrTab(text[j])) {
+				lastSpaceBreak = j;
+			}
+			if (ch < 'A') {
+				lastPunctuationBreak = j;
+			}
+		}
+		lastEncodingAllowedBreak = j;
+
+		if (dbcsCodePage == SC_CP_UTF8) {
+			j += UTF8BytesOfLead[ch];
+		} else if (dbcsCodePage) {
+			j += IsDBCSLeadByteNoExcept(ch) ? 2 : 1;
+		} else {
+			j++;
+		}
+	}
+	if (lastSpaceBreak >= 0) {
+		return lastSpaceBreak;
+	} else if (lastPunctuationBreak >= 0) {
+		return lastPunctuationBreak;
+	}
+	return lastEncodingAllowedBreak;
+}
+
+EncodingFamily Document::CodePageFamily() const noexcept {
+	if (SC_CP_UTF8 == dbcsCodePage)
+		return EncodingFamily::unicode;
+	else if (dbcsCodePage)
+		return EncodingFamily::dbcs;
+	else
+		return EncodingFamily::eightBit;
+}
+
+void Document::ModifiedAt(Sci::Position pos) noexcept {
 	if (endStyled > pos)
 		endStyled = pos;
 }
@@ -414,10 +1198,12 @@ void Document::CheckReadOnly() {
 // Document only modified by gateways DeleteChars, InsertString, Undo, Redo, and SetStyleAt.
 // SetStyleAt does not change the persistent state of a document
 
-bool Document::DeleteChars(int pos, int len) {
-	if (len == 0)
+bool Document::DeleteChars(Sci::Position pos, Sci::Position len) {
+	if (pos < 0)
+		return false;
+	if (len <= 0)
 		return false;
-	if ((pos + len) > Length())
+	if ((pos + len) > LengthNoExcept())
 		return false;
 	CheckReadOnly();
 	if (enteredModification != 0) {
@@ -430,13 +1216,13 @@ bool Document::DeleteChars(int pos, int len) {
 			        SC_MOD_BEFOREDELETE | SC_PERFORMED_USER,
 			        pos, len,
 			        0, 0));
-			int prevLinesTotal = LinesTotal();
-			bool startSavePoint = cb.IsSavePoint();
+			const Sci::Line prevLinesTotal = LinesTotal();
+			const bool startSavePoint = cb.IsSavePoint();
 			bool startSequence = false;
 			const char *text = cb.DeleteChars(pos, len, startSequence);
 			if (startSavePoint && cb.IsCollectingUndo())
-				NotifySavePoint(!startSavePoint);
-			if ((pos < Length()) || (pos == 0))
+				NotifySavePoint(false);
+			if ((pos < LengthNoExcept()) || (pos == 0))
 				ModifiedAt(pos);
 			else
 				ModifiedAt(pos-1);
@@ -454,75 +1240,139 @@ bool Document::DeleteChars(int pos, int len) {
 /**
  * Insert a string with a length.
  */
-bool Document::InsertString(int position, const char *s, int insertLength) {
+Sci::Position Document::InsertString(Sci::Position position, const char *s, Sci::Position insertLength) {
 	if (insertLength <= 0) {
-		return false;
+		return 0;
+	}
+	CheckReadOnly();	// Application may change read only state here
+	if (cb.IsReadOnly()) {
+		return 0;
 	}
-	CheckReadOnly();
 	if (enteredModification != 0) {
-		return false;
-	} else {
-		enteredModification++;
-		if (!cb.IsReadOnly()) {
-			NotifyModified(
-			    DocModification(
-			        SC_MOD_BEFOREINSERT | SC_PERFORMED_USER,
-			        position, insertLength,
-			        0, s));
-			int prevLinesTotal = LinesTotal();
-			bool startSavePoint = cb.IsSavePoint();
-			bool startSequence = false;
-			const char *text = cb.InsertString(position, s, insertLength, startSequence);
-			if (startSavePoint && cb.IsCollectingUndo())
-				NotifySavePoint(!startSavePoint);
-			ModifiedAt(position);
-			NotifyModified(
-			    DocModification(
-			        SC_MOD_INSERTTEXT | SC_PERFORMED_USER | (startSequence?SC_STARTACTION:0),
-			        position, insertLength,
-			        LinesTotal() - prevLinesTotal, text));
-		}
-		enteredModification--;
+		return 0;
 	}
-	return !cb.IsReadOnly();
+	enteredModification++;
+	insertionSet = false;
+	insertion.clear();
+	NotifyModified(
+		DocModification(
+			SC_MOD_INSERTCHECK,
+			position, insertLength,
+			0, s));
+	if (insertionSet) {
+		s = insertion.c_str();
+		insertLength = insertion.length();
+	}
+	NotifyModified(
+		DocModification(
+			SC_MOD_BEFOREINSERT | SC_PERFORMED_USER,
+			position, insertLength,
+			0, s));
+	const Sci::Line prevLinesTotal = LinesTotal();
+	const bool startSavePoint = cb.IsSavePoint();
+	bool startSequence = false;
+	const char *text = cb.InsertString(position, s, insertLength, startSequence);
+	if (startSavePoint && cb.IsCollectingUndo())
+		NotifySavePoint(false);
+	ModifiedAt(position);
+	NotifyModified(
+		DocModification(
+			SC_MOD_INSERTTEXT | SC_PERFORMED_USER | (startSequence?SC_STARTACTION:0),
+			position, insertLength,
+			LinesTotal() - prevLinesTotal, text));
+	if (insertionSet) {	// Free memory as could be large
+		std::string().swap(insertion);
+	}
+	enteredModification--;
+	return insertLength;
+}
+
+void Document::ChangeInsertion(const char *s, Sci::Position length) {
+	insertionSet = true;
+	insertion.assign(s, length);
+}
+
+int SCI_METHOD Document::AddData(const char *data, Sci_Position length) {
+	try {
+		const Sci::Position position = Length();
+		InsertString(position, data, length);
+	} catch (std::bad_alloc &) {
+		return SC_STATUS_BADALLOC;
+	} catch (...) {
+		return SC_STATUS_FAILURE;
+	}
+	return 0;
 }
 
-int Document::Undo() {
-	int newPos = -1;
+void * SCI_METHOD Document::ConvertToDocument() {
+	return this;
+}
+
+Sci::Position Document::Undo() {
+	Sci::Position newPos = -1;
 	CheckReadOnly();
-	if (enteredModification == 0) {
+	if ((enteredModification == 0) && (cb.IsCollectingUndo())) {
 		enteredModification++;
 		if (!cb.IsReadOnly()) {
-			bool startSavePoint = cb.IsSavePoint();
+			const bool startSavePoint = cb.IsSavePoint();
 			bool multiLine = false;
-			int steps = cb.StartUndo();
+			const int steps = cb.StartUndo();
 			//Platform::DebugPrintf("Steps=%d\n", steps);
+			Sci::Position coalescedRemovePos = -1;
+			Sci::Position coalescedRemoveLen = 0;
+			Sci::Position prevRemoveActionPos = -1;
+			Sci::Position prevRemoveActionLen = 0;
 			for (int step = 0; step < steps; step++) {
-				const int prevLinesTotal = LinesTotal();
+				const Sci::Line prevLinesTotal = LinesTotal();
 				const Action &action = cb.GetUndoStep();
 				if (action.at == removeAction) {
 					NotifyModified(DocModification(
 									SC_MOD_BEFOREINSERT | SC_PERFORMED_UNDO, action));
+				} else if (action.at == containerAction) {
+					DocModification dm(SC_MOD_CONTAINER | SC_PERFORMED_UNDO);
+					dm.token = action.position;
+					NotifyModified(dm);
+					if (!action.mayCoalesce) {
+						coalescedRemovePos = -1;
+						coalescedRemoveLen = 0;
+						prevRemoveActionPos = -1;
+						prevRemoveActionLen = 0;
+					}
 				} else {
 					NotifyModified(DocModification(
 									SC_MOD_BEFOREDELETE | SC_PERFORMED_UNDO, action));
 				}
 				cb.PerformUndoStep();
-				int cellPosition = action.position;
-				ModifiedAt(cellPosition);
-				newPos = cellPosition;
+				if (action.at != containerAction) {
+					ModifiedAt(action.position);
+					newPos = action.position;
+				}
 
 				int modFlags = SC_PERFORMED_UNDO;
 				// With undo, an insertion action becomes a deletion notification
 				if (action.at == removeAction) {
 					newPos += action.lenData;
 					modFlags |= SC_MOD_INSERTTEXT;
-				} else {
+					if ((coalescedRemoveLen > 0) &&
+						(action.position == prevRemoveActionPos || action.position == (prevRemoveActionPos + prevRemoveActionLen))) {
+						coalescedRemoveLen += action.lenData;
+						newPos = coalescedRemovePos + coalescedRemoveLen;
+					} else {
+						coalescedRemovePos = action.position;
+						coalescedRemoveLen = action.lenData;
+					}
+					prevRemoveActionPos = action.position;
+					prevRemoveActionLen = action.lenData;
+				} else if (action.at == insertAction) {
 					modFlags |= SC_MOD_DELETETEXT;
+					coalescedRemovePos = -1;
+					coalescedRemoveLen = 0;
+					prevRemoveActionPos = -1;
+					prevRemoveActionLen = 0;
 				}
 				if (steps > 1)
 					modFlags |= SC_MULTISTEPUNDOREDO;
-				const int linesAdded = LinesTotal() - prevLinesTotal;
+				const Sci::Line linesAdded = LinesTotal() - prevLinesTotal;
 				if (linesAdded != 0)
 					multiLine = true;
 				if (step == steps - 1) {
@@ -530,11 +1380,11 @@ int Document::Undo() {
 					if (multiLine)
 						modFlags |= SC_MULTILINEUNDOREDO;
 				}
-				NotifyModified(DocModification(modFlags, cellPosition, action.lenData,
-											   linesAdded, action.data));
+				NotifyModified(DocModification(modFlags, action.position, action.lenData,
+											   linesAdded, action.data.get()));
 			}
 
-			bool endSavePoint = cb.IsSavePoint();
+			const bool endSavePoint = cb.IsSavePoint();
 			if (startSavePoint != endSavePoint)
 				NotifySavePoint(endSavePoint);
 		}
@@ -543,39 +1393,45 @@ int Document::Undo() {
 	return newPos;
 }
 
-int Document::Redo() {
-	int newPos = -1;
+Sci::Position Document::Redo() {
+	Sci::Position newPos = -1;
 	CheckReadOnly();
-	if (enteredModification == 0) {
+	if ((enteredModification == 0) && (cb.IsCollectingUndo())) {
 		enteredModification++;
 		if (!cb.IsReadOnly()) {
-			bool startSavePoint = cb.IsSavePoint();
+			const bool startSavePoint = cb.IsSavePoint();
 			bool multiLine = false;
-			int steps = cb.StartRedo();
+			const int steps = cb.StartRedo();
 			for (int step = 0; step < steps; step++) {
-				const int prevLinesTotal = LinesTotal();
+				const Sci::Line prevLinesTotal = LinesTotal();
 				const Action &action = cb.GetRedoStep();
 				if (action.at == insertAction) {
 					NotifyModified(DocModification(
 									SC_MOD_BEFOREINSERT | SC_PERFORMED_REDO, action));
+				} else if (action.at == containerAction) {
+					DocModification dm(SC_MOD_CONTAINER | SC_PERFORMED_REDO);
+					dm.token = action.position;
+					NotifyModified(dm);
 				} else {
 					NotifyModified(DocModification(
 									SC_MOD_BEFOREDELETE | SC_PERFORMED_REDO, action));
 				}
 				cb.PerformRedoStep();
-				ModifiedAt(action.position);
-				newPos = action.position;
+				if (action.at != containerAction) {
+					ModifiedAt(action.position);
+					newPos = action.position;
+				}
 
 				int modFlags = SC_PERFORMED_REDO;
 				if (action.at == insertAction) {
 					newPos += action.lenData;
 					modFlags |= SC_MOD_INSERTTEXT;
-				} else {
+				} else if (action.at == removeAction) {
 					modFlags |= SC_MOD_DELETETEXT;
 				}
 				if (steps > 1)
 					modFlags |= SC_MULTISTEPUNDOREDO;
-				const int linesAdded = LinesTotal() - prevLinesTotal;
+				const Sci::Line linesAdded = LinesTotal() - prevLinesTotal;
 				if (linesAdded != 0)
 					multiLine = true;
 				if (step == steps - 1) {
@@ -585,10 +1441,10 @@ int Document::Redo() {
 				}
 				NotifyModified(
 					DocModification(modFlags, action.position, action.lenData,
-									linesAdded, action.data));
+									linesAdded, action.data.get()));
 			}
 
-			bool endSavePoint = cb.IsSavePoint();
+			const bool endSavePoint = cb.IsSavePoint();
 			if (startSavePoint != endSavePoint)
 				NotifySavePoint(endSavePoint);
 		}
@@ -597,80 +1453,53 @@ int Document::Redo() {
 	return newPos;
 }
 
-/**
- * Insert a single character.
- */
-bool Document::InsertChar(int pos, char ch) {
-	char chs[1];
-	chs[0] = ch;
-	return InsertString(pos, chs, 1);
-}
-
-/**
- * Insert a null terminated string.
- */
-bool Document::InsertCString(int position, const char *s) {
-	return InsertString(position, s, strlen(s));
-}
-
-void Document::ChangeChar(int pos, char ch) {
-	DeleteChars(pos, 1);
-	InsertChar(pos, ch);
-}
-
-void Document::DelChar(int pos) {
+void Document::DelChar(Sci::Position pos) {
 	DeleteChars(pos, LenChar(pos));
 }
 
-void Document::DelCharBack(int pos) {
+void Document::DelCharBack(Sci::Position pos) {
 	if (pos <= 0) {
 		return;
 	} else if (IsCrLf(pos - 2)) {
 		DeleteChars(pos - 2, 2);
 	} else if (dbcsCodePage) {
-		int startChar = MovePositionOutsideChar(pos - 1, -1, false);
+		const Sci::Position startChar = NextPosition(pos, -1);
 		DeleteChars(startChar, pos - startChar);
 	} else {
 		DeleteChars(pos - 1, 1);
 	}
 }
 
-static bool isindentchar(char ch) {
-	return (ch == ' ') || (ch == '\t');
-}
-
-static int NextTab(int pos, int tabSize) {
+static constexpr Sci::Position NextTab(Sci::Position pos, Sci::Position tabSize) noexcept {
 	return ((pos / tabSize) + 1) * tabSize;
 }
 
-static void CreateIndentation(char *linebuf, int length, int indent, int tabSize, bool insertSpaces) {
-	length--;	// ensure space for \0
+static std::string CreateIndentation(Sci::Position indent, int tabSize, bool insertSpaces) {
+	std::string indentation;
 	if (!insertSpaces) {
-		while ((indent >= tabSize) && (length > 0)) {
-			*linebuf++ = '\t';
+		while (indent >= tabSize) {
+			indentation += '\t';
 			indent -= tabSize;
-			length--;
 		}
 	}
-	while ((indent > 0) && (length > 0)) {
-		*linebuf++ = ' ';
+	while (indent > 0) {
+		indentation += ' ';
 		indent--;
-		length--;
 	}
-	*linebuf = '\0';
+	return indentation;
 }
 
-int Document::GetLineIndentation(int line) {
+int SCI_METHOD Document::GetLineIndentation(Sci_Position line) {
 	int indent = 0;
 	if ((line >= 0) && (line < LinesTotal())) {
-		int lineStart = LineStart(line);
-		int length = Length();
-		for (int i = lineStart;i < length;i++) {
-			char ch = cb.CharAt(i);
+		const Sci::Position lineStart = LineStart(line);
+		const Sci::Position length = Length();
+		for (Sci::Position i = lineStart; i < length; i++) {
+			const char ch = cb.CharAt(i);
 			if (ch == ' ')
 				indent++;
 			else if (ch == '\t')
-				indent = NextTab(indent, tabInChars);
+				indent = static_cast<int>(NextTab(indent, tabInChars));
 			else
 				return indent;
 		}
@@ -678,39 +1507,40 @@ int Document::GetLineIndentation(int line) {
 	return indent;
 }
 
-void Document::SetLineIndentation(int line, int indent) {
-	int indentOfLine = GetLineIndentation(line);
+Sci::Position Document::SetLineIndentation(Sci::Line line, Sci::Position indent) {
+	const int indentOfLine = GetLineIndentation(line);
 	if (indent < 0)
 		indent = 0;
 	if (indent != indentOfLine) {
-		char linebuf[1000];
-		CreateIndentation(linebuf, sizeof(linebuf), indent, tabInChars, !useTabs);
-		int thisLineStart = LineStart(line);
-		int indentPos = GetLineIndentPosition(line);
-		BeginUndoAction();
+		std::string linebuf = CreateIndentation(indent, tabInChars, !useTabs);
+		const Sci::Position thisLineStart = LineStart(line);
+		const Sci::Position indentPos = GetLineIndentPosition(line);
+		UndoGroup ug(this);
 		DeleteChars(thisLineStart, indentPos - thisLineStart);
-		InsertCString(thisLineStart, linebuf);
-		EndUndoAction();
+		return thisLineStart + InsertString(thisLineStart, linebuf.c_str(),
+			linebuf.length());
+	} else {
+		return GetLineIndentPosition(line);
 	}
 }
 
-int Document::GetLineIndentPosition(int line) const {
+Sci::Position Document::GetLineIndentPosition(Sci::Line line) const {
 	if (line < 0)
 		return 0;
-	int pos = LineStart(line);
-	int length = Length();
-	while ((pos < length) && isindentchar(cb.CharAt(pos))) {
+	Sci::Position pos = LineStart(line);
+	const Sci::Position length = Length();
+	while ((pos < length) && IsSpaceOrTab(cb.CharAt(pos))) {
 		pos++;
 	}
 	return pos;
 }
 
-int Document::GetColumn(int pos) {
-	int column = 0;
-	int line = LineFromPosition(pos);
+Sci::Position Document::GetColumn(Sci::Position pos) {
+	Sci::Position column = 0;
+	const Sci::Line line = SciLineFromPosition(pos);
 	if ((line >= 0) && (line < LinesTotal())) {
-		for (int i = LineStart(line);i < pos;) {
-			char ch = cb.CharAt(i);
+		for (Sci::Position i = LineStart(line); i < pos;) {
+			const char ch = cb.CharAt(i);
 			if (ch == '\t') {
 				column = NextTab(column, tabInChars);
 				i++;
@@ -722,21 +1552,50 @@ int Document::GetColumn(int pos) {
 				return column;
 			} else {
 				column++;
-				i = MovePositionOutsideChar(i + 1, 1, false);
+				i = NextPosition(i, 1);
 			}
 		}
 	}
 	return column;
 }
 
-int Document::FindColumn(int line, int column) {
-	int position = LineStart(line);
-	int columnCurrent = 0;
+Sci::Position Document::CountCharacters(Sci::Position startPos, Sci::Position endPos) const noexcept {
+	startPos = MovePositionOutsideChar(startPos, 1, false);
+	endPos = MovePositionOutsideChar(endPos, -1, false);
+	Sci::Position count = 0;
+	Sci::Position i = startPos;
+	while (i < endPos) {
+		count++;
+		i = NextPosition(i, 1);
+	}
+	return count;
+}
+
+Sci::Position Document::CountUTF16(Sci::Position startPos, Sci::Position endPos) const noexcept {
+	startPos = MovePositionOutsideChar(startPos, 1, false);
+	endPos = MovePositionOutsideChar(endPos, -1, false);
+	Sci::Position count = 0;
+	Sci::Position i = startPos;
+	while (i < endPos) {
+		count++;
+		const Sci::Position next = NextPosition(i, 1);
+		if ((next - i) > 3)
+			count++;
+		i = next;
+	}
+	return count;
+}
+
+Sci::Position Document::FindColumn(Sci::Line line, Sci::Position column) {
+	Sci::Position position = LineStart(line);
 	if ((line >= 0) && (line < LinesTotal())) {
+		Sci::Position columnCurrent = 0;
 		while ((columnCurrent < column) && (position < Length())) {
-			char ch = cb.CharAt(position);
+			const char ch = cb.CharAt(position);
 			if (ch == '\t') {
 				columnCurrent = NextTab(columnCurrent, tabInChars);
+				if (columnCurrent > column)
+					return position;
 				position++;
 			} else if (ch == '\r') {
 				return position;
@@ -744,17 +1603,17 @@ int Document::FindColumn(int line, int column) {
 				return position;
 			} else {
 				columnCurrent++;
-				position = MovePositionOutsideChar(position + 1, 1, false);
+				position = NextPosition(position, 1);
 			}
 		}
 	}
 	return position;
 }
 
-void Document::Indent(bool forwards, int lineBottom, int lineTop) {
+void Document::Indent(bool forwards, Sci::Line lineBottom, Sci::Line lineTop) {
 	// Dedent - suck white space off the front of the line to dedent by equivalent of a tab
-	for (int line = lineBottom; line >= lineTop; line--) {
-		int indentOfLine = GetLineIndentation(line);
+	for (Sci::Line line = lineBottom; line >= lineTop; line--) {
+		const Sci::Position indentOfLine = GetLineIndentation(line);
 		if (forwards) {
 			if (LineStart(line) < LineEnd(line)) {
 				SetLineIndentation(line, indentOfLine + IndentSize());
@@ -767,39 +1626,32 @@ void Document::Indent(bool forwards, int lineBottom, int lineTop) {
 
 // Convert line endings for a piece of text to a particular mode.
 // Stop at len or when a NUL is found.
-// Caller must delete the returned pointer.
-char *Document::TransformLineEnds(int *pLenOut, const char *s, size_t len, int eolMode) {
-	char *dest = new char[2 * len + 1];
-	const char *sptr = s;
-	char *dptr = dest;
-	for (size_t i = 0; (i < len) && (*sptr != '\0'); i++) {
-		if (*sptr == '\n' || *sptr == '\r') {
-			if (eolMode == SC_EOL_CR) {
-				*dptr++ = '\r';
-			} else if (eolMode == SC_EOL_LF) {
-				*dptr++ = '\n';
-			} else { // eolMode == SC_EOL_CRLF
-				*dptr++ = '\r';
-				*dptr++ = '\n';
+std::string Document::TransformLineEnds(const char *s, size_t len, int eolModeWanted) {
+	std::string dest;
+	for (size_t i = 0; (i < len) && (s[i]); i++) {
+		if (s[i] == '\n' || s[i] == '\r') {
+			if (eolModeWanted == SC_EOL_CR) {
+				dest.push_back('\r');
+			} else if (eolModeWanted == SC_EOL_LF) {
+				dest.push_back('\n');
+			} else { // eolModeWanted == SC_EOL_CRLF
+				dest.push_back('\r');
+				dest.push_back('\n');
 			}
-			if ((*sptr == '\r') && (i+1 < len) && (*(sptr+1) == '\n')) {
+			if ((s[i] == '\r') && (i+1 < len) && (s[i+1] == '\n')) {
 				i++;
-				sptr++;
 			}
-			sptr++;
 		} else {
-			*dptr++ = *sptr++;
+			dest.push_back(s[i]);
 		}
 	}
-	*dptr++ = '\0';
-	*pLenOut = (dptr - dest) - 1;
 	return dest;
 }
 
 void Document::ConvertLineEnds(int eolModeSet) {
-	BeginUndoAction();
+	UndoGroup ug(this);
 
-	for (int pos = 0; pos < Length(); pos++) {
+	for (Sci::Position pos = 0; pos < Length(); pos++) {
 		if (cb.CharAt(pos) == '\r') {
 			if (cb.CharAt(pos + 1) == '\n') {
 				// CRLF
@@ -813,33 +1665,37 @@ void Document::ConvertLineEnds(int eolModeSet) {
 			} else {
 				// CR
 				if (eolModeSet == SC_EOL_CRLF) {
-					InsertString(pos + 1, "\n", 1); // Insert LF
-					pos++;
+					pos += InsertString(pos + 1, "\n", 1); // Insert LF
 				} else if (eolModeSet == SC_EOL_LF) {
-					InsertString(pos, "\n", 1); // Insert LF
-					DeleteChars(pos + 1, 1); // Delete CR
+					pos += InsertString(pos, "\n", 1); // Insert LF
+					DeleteChars(pos, 1); // Delete CR
+					pos--;
 				}
 			}
 		} else if (cb.CharAt(pos) == '\n') {
 			// LF
 			if (eolModeSet == SC_EOL_CRLF) {
-				InsertString(pos, "\r", 1); // Insert CR
-				pos++;
+				pos += InsertString(pos, "\r", 1); // Insert CR
 			} else if (eolModeSet == SC_EOL_CR) {
-				InsertString(pos, "\r", 1); // Insert CR
-				DeleteChars(pos + 1, 1); // Delete LF
+				pos += InsertString(pos, "\r", 1); // Insert CR
+				DeleteChars(pos, 1); // Delete LF
+				pos--;
 			}
 		}
 	}
 
-	EndUndoAction();
 }
 
-bool Document::IsWhiteLine(int line) const {
-	int currentChar = LineStart(line);
-	int endLine = LineEnd(line);
+int Document::Options() const noexcept {
+	return (IsLarge() ? SC_DOCUMENTOPTION_TEXT_LARGE : 0) |
+		(cb.HasStyles() ? 0 : SC_DOCUMENTOPTION_STYLES_NONE);
+}
+
+bool Document::IsWhiteLine(Sci::Line line) const {
+	Sci::Position currentChar = LineStart(line);
+	const Sci::Position endLine = LineEnd(line);
 	while (currentChar < endLine) {
-		if (cb.CharAt(currentChar) != ' ' && cb.CharAt(currentChar) != '\t') {
+		if (!IsSpaceOrTab(cb.CharAt(currentChar))) {
 			return false;
 		}
 		++currentChar;
@@ -847,8 +1703,8 @@ bool Document::IsWhiteLine(int line) const {
 	return true;
 }
 
-int Document::ParaUp(int pos) {
-	int line = LineFromPosition(pos);
+Sci::Position Document::ParaUp(Sci::Position pos) const {
+	Sci::Line line = SciLineFromPosition(pos);
 	line--;
 	while (line >= 0 && IsWhiteLine(line)) { // skip empty lines
 		line--;
@@ -860,8 +1716,8 @@ int Document::ParaUp(int pos) {
 	return LineStart(line);
 }
 
-int Document::ParaDown(int pos) {
-	int line = LineFromPosition(pos);
+Sci::Position Document::ParaDown(Sci::Position pos) const {
+	Sci::Line line = SciLineFromPosition(pos);
 	while (line < LinesTotal() && !IsWhiteLine(line)) { // skip non-empty lines
 		line++;
 	}
@@ -874,30 +1730,98 @@ int Document::ParaDown(int pos) {
 		return LineEnd(line-1);
 }
 
-CharClassify::cc Document::WordCharClass(unsigned char ch) {
-	if ((SC_CP_UTF8 == dbcsCodePage) && (ch >= 0x80))
-		return CharClassify::ccWord;
-	return charClass.GetClass(ch);
+CharClassify::cc Document::WordCharacterClass(unsigned int ch) const {
+	if (dbcsCodePage && (!UTF8IsAscii(ch))) {
+		if (SC_CP_UTF8 == dbcsCodePage) {
+			// Use hard coded Unicode class
+			const CharacterCategory cc = charMap.CategoryFor(ch);
+			switch (cc) {
+
+				// Separator, Line/Paragraph
+			case ccZl:
+			case ccZp:
+				return CharClassify::ccNewLine;
+
+				// Separator, Space
+			case ccZs:
+				// Other
+			case ccCc:
+			case ccCf:
+			case ccCs:
+			case ccCo:
+			case ccCn:
+				return CharClassify::ccSpace;
+
+				// Letter
+			case ccLu:
+			case ccLl:
+			case ccLt:
+			case ccLm:
+			case ccLo:
+				// Number
+			case ccNd:
+			case ccNl:
+			case ccNo:
+				// Mark - includes combining diacritics
+			case ccMn:
+			case ccMc:
+			case ccMe:
+				return CharClassify::ccWord;
+
+				// Punctuation
+			case ccPc:
+			case ccPd:
+			case ccPs:
+			case ccPe:
+			case ccPi:
+			case ccPf:
+			case ccPo:
+				// Symbol
+			case ccSm:
+			case ccSc:
+			case ccSk:
+			case ccSo:
+				return CharClassify::ccPunctuation;
+
+			}
+		} else {
+			// Asian DBCS
+			return CharClassify::ccWord;
+		}
+	}
+	return charClass.GetClass(static_cast<unsigned char>(ch));
 }
 
 /**
- * Used by commmands that want to select whole words.
+ * Used by commands that want to select whole words.
  * Finds the start of word at pos when delta < 0 or the end of the word when delta >= 0.
  */
-int Document::ExtendWordSelect(int pos, int delta, bool onlyWordCharacters) {
+Sci::Position Document::ExtendWordSelect(Sci::Position pos, int delta, bool onlyWordCharacters) const {
 	CharClassify::cc ccStart = CharClassify::ccWord;
 	if (delta < 0) {
-		if (!onlyWordCharacters)
-			ccStart = WordCharClass(cb.CharAt(pos-1));
-		while (pos > 0 && (WordCharClass(cb.CharAt(pos - 1)) == ccStart))
-			pos--;
+		if (!onlyWordCharacters) {
+			const CharacterExtracted ce = CharacterBefore(pos);
+			ccStart = WordCharacterClass(ce.character);
+		}
+		while (pos > 0) {
+			const CharacterExtracted ce = CharacterBefore(pos);
+			if (WordCharacterClass(ce.character) != ccStart)
+				break;
+			pos -= ce.widthBytes;
+		}
 	} else {
-		if (!onlyWordCharacters && pos < Length())
-			ccStart = WordCharClass(cb.CharAt(pos));
-		while (pos < (Length()) && (WordCharClass(cb.CharAt(pos)) == ccStart))
-			pos++;
+		if (!onlyWordCharacters && pos < LengthNoExcept()) {
+			const CharacterExtracted ce = CharacterAfter(pos);
+			ccStart = WordCharacterClass(ce.character);
+		}
+		while (pos < LengthNoExcept()) {
+			const CharacterExtracted ce = CharacterAfter(pos);
+			if (WordCharacterClass(ce.character) != ccStart)
+				break;
+			pos += ce.widthBytes;
+		}
 	}
-	return MovePositionOutsideChar(pos, delta);
+	return MovePositionOutsideChar(pos, delta, true);
 }
 
 /**
@@ -907,22 +1831,39 @@ int Document::ExtendWordSelect(int pos, int delta, bool onlyWordCharacters) {
  * additional movement to transit white space.
  * Used by cursor movement by word commands.
  */
-int Document::NextWordStart(int pos, int delta) {
+Sci::Position Document::NextWordStart(Sci::Position pos, int delta) const {
 	if (delta < 0) {
-		while (pos > 0 && (WordCharClass(cb.CharAt(pos - 1)) == CharClassify::ccSpace))
-			pos--;
+		while (pos > 0) {
+			const CharacterExtracted ce = CharacterBefore(pos);
+			if (WordCharacterClass(ce.character) != CharClassify::ccSpace)
+				break;
+			pos -= ce.widthBytes;
+		}
 		if (pos > 0) {
-			CharClassify::cc ccStart = WordCharClass(cb.CharAt(pos-1));
-			while (pos > 0 && (WordCharClass(cb.CharAt(pos - 1)) == ccStart)) {
-				pos--;
+			CharacterExtracted ce = CharacterBefore(pos);
+			const CharClassify::cc ccStart = WordCharacterClass(ce.character);
+			while (pos > 0) {
+				ce = CharacterBefore(pos);
+				if (WordCharacterClass(ce.character) != ccStart)
+					break;
+				pos -= ce.widthBytes;
 			}
 		}
 	} else {
-		CharClassify::cc ccStart = WordCharClass(cb.CharAt(pos));
-		while (pos < (Length()) && (WordCharClass(cb.CharAt(pos)) == ccStart))
-			pos++;
-		while (pos < (Length()) && (WordCharClass(cb.CharAt(pos)) == CharClassify::ccSpace))
-			pos++;
+		CharacterExtracted ce = CharacterAfter(pos);
+		const CharClassify::cc ccStart = WordCharacterClass(ce.character);
+		while (pos < LengthNoExcept()) {
+			ce = CharacterAfter(pos);
+			if (WordCharacterClass(ce.character) != ccStart)
+				break;
+			pos += ce.widthBytes;
+		}
+		while (pos < LengthNoExcept()) {
+			ce = CharacterAfter(pos);
+			if (WordCharacterClass(ce.character) != CharClassify::ccSpace)
+				break;
+			pos += ce.widthBytes;
+		}
 	}
 	return pos;
 }
@@ -934,27 +1875,41 @@ int Document::NextWordStart(int pos, int delta) {
  * additional movement to transit white space.
  * Used by cursor movement by word commands.
  */
-int Document::NextWordEnd(int pos, int delta) {
+Sci::Position Document::NextWordEnd(Sci::Position pos, int delta) const {
 	if (delta < 0) {
 		if (pos > 0) {
-			CharClassify::cc ccStart = WordCharClass(cb.CharAt(pos-1));
+			CharacterExtracted ce = CharacterBefore(pos);
+			const CharClassify::cc ccStart = WordCharacterClass(ce.character);
 			if (ccStart != CharClassify::ccSpace) {
-				while (pos > 0 && WordCharClass(cb.CharAt(pos - 1)) == ccStart) {
-					pos--;
+				while (pos > 0) {
+					ce = CharacterBefore(pos);
+					if (WordCharacterClass(ce.character) != ccStart)
+						break;
+					pos -= ce.widthBytes;
 				}
 			}
-			while (pos > 0 && WordCharClass(cb.CharAt(pos - 1)) == CharClassify::ccSpace) {
-				pos--;
+			while (pos > 0) {
+				ce = CharacterBefore(pos);
+				if (WordCharacterClass(ce.character) != CharClassify::ccSpace)
+					break;
+				pos -= ce.widthBytes;
 			}
 		}
 	} else {
-		while (pos < Length() && WordCharClass(cb.CharAt(pos)) == CharClassify::ccSpace) {
-			pos++;
+		while (pos < LengthNoExcept()) {
+			const CharacterExtracted ce = CharacterAfter(pos);
+			if (WordCharacterClass(ce.character) != CharClassify::ccSpace)
+				break;
+			pos += ce.widthBytes;
 		}
-		if (pos < Length()) {
-			CharClassify::cc ccStart = WordCharClass(cb.CharAt(pos));
-			while (pos < Length() && WordCharClass(cb.CharAt(pos)) == ccStart) {
-				pos++;
+		if (pos < LengthNoExcept()) {
+			CharacterExtracted ce = CharacterAfter(pos);
+			const CharClassify::cc ccStart = WordCharacterClass(ce.character);
+			while (pos < LengthNoExcept()) {
+				ce = CharacterAfter(pos);
+				if (WordCharacterClass(ce.character) != ccStart)
+					break;
+				pos += ce.widthBytes;
 			}
 		}
 	}
@@ -965,11 +1920,16 @@ int Document::NextWordEnd(int pos, int delta) {
  * Check that the character at the given position is a word or punctuation character and that
  * the previous character is of a different character class.
  */
-bool Document::IsWordStartAt(int pos) {
+bool Document::IsWordStartAt(Sci::Position pos) const {
+	if (pos >= LengthNoExcept())
+		return false;
 	if (pos > 0) {
-		CharClassify::cc ccPos = WordCharClass(CharAt(pos));
+		const CharacterExtracted cePos = CharacterAfter(pos);
+		const CharClassify::cc ccPos = WordCharacterClass(cePos.character);
+		const CharacterExtracted cePrev = CharacterBefore(pos);
+		const CharClassify::cc ccPrev = WordCharacterClass(cePrev.character);
 		return (ccPos == CharClassify::ccWord || ccPos == CharClassify::ccPunctuation) &&
-			(ccPos != WordCharClass(CharAt(pos - 1)));
+			(ccPos != ccPrev);
 	}
 	return true;
 }
@@ -978,11 +1938,16 @@ bool Document::IsWordStartAt(int pos) {
  * Check that the character at the given position is a word or punctuation character and that
  * the next character is of a different character class.
  */
-bool Document::IsWordEndAt(int pos) {
-	if (pos < Length()) {
-		CharClassify::cc ccPrev = WordCharClass(CharAt(pos-1));
+bool Document::IsWordEndAt(Sci::Position pos) const {
+	if (pos <= 0)
+		return false;
+	if (pos < LengthNoExcept()) {
+		const CharacterExtracted cePos = CharacterAfter(pos);
+		const CharClassify::cc ccPos = WordCharacterClass(cePos.character);
+		const CharacterExtracted cePrev = CharacterBefore(pos);
+		const CharClassify::cc ccPrev = WordCharacterClass(cePrev.character);
 		return (ccPrev == CharClassify::ccWord || ccPrev == CharClassify::ccPunctuation) &&
-			(ccPrev != WordCharClass(CharAt(pos)));
+			(ccPrev != ccPos);
 	}
 	return true;
 }
@@ -991,25 +1956,41 @@ bool Document::IsWordEndAt(int pos) {
  * Check that the given range is has transitions between character classes at both
  * ends and where the characters on the inside are word or punctuation characters.
  */
-bool Document::IsWordAt(int start, int end) {
-	return IsWordStartAt(start) && IsWordEndAt(end);
+bool Document::IsWordAt(Sci::Position start, Sci::Position end) const {
+	return (start < end) && IsWordStartAt(start) && IsWordEndAt(end);
+}
+
+bool Document::MatchesWordOptions(bool word, bool wordStart, Sci::Position pos, Sci::Position length) const {
+	return (!word && !wordStart) ||
+			(word && IsWordAt(pos, pos + length)) ||
+			(wordStart && IsWordStartAt(pos));
 }
 
-// The comparison and case changing functions here assume ASCII
-// or extended ASCII such as the normal Windows code page.
+bool Document::HasCaseFolder() const noexcept {
+	return pcf != nullptr;
+}
 
-static inline char MakeUpperCase(char ch) {
-	if (ch < 'a' || ch > 'z')
-		return ch;
-	else
-		return static_cast<char>(ch - 'a' + 'A');
+void Document::SetCaseFolder(CaseFolder *pcf_) noexcept {
+	pcf.reset(pcf_);
 }
 
-static inline char MakeLowerCase(char ch) {
-	if (ch < 'A' || ch > 'Z')
-		return ch;
-	else
-		return static_cast<char>(ch - 'A' + 'a');
+Document::CharacterExtracted Document::ExtractCharacter(Sci::Position position) const noexcept {
+	const unsigned char leadByte = cb.UCharAt(position);
+	if (UTF8IsAscii(leadByte)) {
+		// Common case: ASCII character
+		return CharacterExtracted(leadByte, 1);
+	}
+	const int widthCharBytes = UTF8BytesOfLead[leadByte];
+	unsigned char charBytes[UTF8MaxBytes] = { leadByte, 0, 0, 0 };
+	for (int b=1; b<widthCharBytes; b++)
+		charBytes[b] = cb.UCharAt(position + b);
+	const int utf8status = UTF8Classify(charBytes, widthCharBytes);
+	if (utf8status & UTF8MaskInvalid) {
+		// Treat as invalid and use up just one byte
+		return CharacterExtracted(unicodeReplacementChar, 1);
+	} else {
+		return CharacterExtracted(UnicodeFromUTF8(charBytes), utf8status & UTF8MaskWidth);
+	}
 }
 
 /**
@@ -1017,74 +1998,159 @@ static inline char MakeLowerCase(char ch) {
  * searches (just pass minPos > maxPos to do a backward search)
  * Has not been tested with backwards DBCS searches yet.
  */
-long Document::FindText(int minPos, int maxPos, const char *s,
-                        bool caseSensitive, bool word, bool wordStart, bool regExp, int flags,
-                        int *length) {
+Sci::Position Document::FindText(Sci::Position minPos, Sci::Position maxPos, const char *search,
+                        int flags, Sci::Position *length) {
+	if (*length <= 0)
+		return minPos;
+	const bool caseSensitive = (flags & SCFIND_MATCHCASE) != 0;
+	const bool word = (flags & SCFIND_WHOLEWORD) != 0;
+	const bool wordStart = (flags & SCFIND_WORDSTART) != 0;
+	const bool regExp = (flags & SCFIND_REGEXP) != 0;
 	if (regExp) {
 		if (!regex)
-			regex = CreateRegexSearch(&charClass);
-		return regex->FindText(this, minPos, maxPos, s, caseSensitive, word, wordStart, flags, length);
+			regex = std::unique_ptr<RegexSearchBase>(CreateRegexSearch(&charClass));
+		return regex->FindText(this, minPos, maxPos, search, caseSensitive, word, wordStart, flags, length);
 	} else {
 
-		bool forward = minPos <= maxPos;
-		int increment = forward ? 1 : -1;
+		const bool forward = minPos <= maxPos;
+		const int increment = forward ? 1 : -1;
 
 		// Range endpoints should not be inside DBCS characters, but just in case, move them.
-		int startPos = MovePositionOutsideChar(minPos, increment, false);
-		int endPos = MovePositionOutsideChar(maxPos, increment, false);
+		const Sci::Position startPos = MovePositionOutsideChar(minPos, increment, false);
+		const Sci::Position endPos = MovePositionOutsideChar(maxPos, increment, false);
 
 		// Compute actual search ranges needed
-		int lengthFind = *length;
-		if (lengthFind == -1)
-			lengthFind = static_cast<int>(strlen(s));
-		int endSearch = endPos;
-		if (startPos <= endPos) {
-			endSearch = endPos - lengthFind + 1;
-		}
+		const Sci::Position lengthFind = *length;
+
 		//Platform::DebugPrintf("Find %d %d %s %d\n", startPos, endPos, ft->lpstrText, lengthFind);
-		char firstChar = s[0];
-		if (!caseSensitive)
-			firstChar = static_cast<char>(MakeUpperCase(firstChar));
-		int pos = forward ? startPos : (startPos - 1);
-		while (forward ? (pos < endSearch) : (pos >= endSearch)) {
-			char ch = CharAt(pos);
-			if (caseSensitive) {
-				if (ch == firstChar) {
-					bool found = true;
-					if (pos + lengthFind > Platform::Maximum(startPos, endPos)) found = false;
-					for (int posMatch = 1; posMatch < lengthFind && found; posMatch++) {
-						ch = CharAt(pos + posMatch);
-						if (ch != s[posMatch])
-							found = false;
+		const Sci::Position limitPos = std::max(startPos, endPos);
+		Sci::Position pos = startPos;
+		if (!forward) {
+			// Back all of a character
+			pos = NextPosition(pos, increment);
+		}
+		if (caseSensitive) {
+			const Sci::Position endSearch = (startPos <= endPos) ? endPos - lengthFind + 1 : endPos;
+			const char charStartSearch =  search[0];
+			while (forward ? (pos < endSearch) : (pos >= endSearch)) {
+				if (CharAt(pos) == charStartSearch) {
+					bool found = (pos + lengthFind) <= limitPos;
+					for (int indexSearch = 1; (indexSearch < lengthFind) && found; indexSearch++) {
+						found = CharAt(pos + indexSearch) == search[indexSearch];
 					}
-					if (found) {
-						if ((!word && !wordStart) ||
-						        word && IsWordAt(pos, pos + lengthFind) ||
-						        wordStart && IsWordStartAt(pos))
-							return pos;
+					if (found && MatchesWordOptions(word, wordStart, pos, lengthFind)) {
+						return pos;
 					}
 				}
-			} else {
-				if (MakeUpperCase(ch) == firstChar) {
-					bool found = true;
-					if (pos + lengthFind > Platform::Maximum(startPos, endPos)) found = false;
-					for (int posMatch = 1; posMatch < lengthFind && found; posMatch++) {
-						ch = CharAt(pos + posMatch);
-						if (MakeUpperCase(ch) != MakeUpperCase(s[posMatch]))
-							found = false;
+				if (!NextCharacter(pos, increment))
+					break;
+			}
+		} else if (SC_CP_UTF8 == dbcsCodePage) {
+			constexpr size_t maxFoldingExpansion = 4;
+			std::vector<char> searchThing((lengthFind+1) * UTF8MaxBytes * maxFoldingExpansion + 1);
+			const size_t lenSearch =
+				pcf->Fold(&searchThing[0], searchThing.size(), search, lengthFind);
+			char bytes[UTF8MaxBytes + 1] = "";
+			char folded[UTF8MaxBytes * maxFoldingExpansion + 1] = "";
+			while (forward ? (pos < endPos) : (pos >= endPos)) {
+				int widthFirstCharacter = 0;
+				Sci::Position posIndexDocument = pos;
+				size_t indexSearch = 0;
+				bool characterMatches = true;
+				for (;;) {
+					const unsigned char leadByte = cb.UCharAt(posIndexDocument);
+					bytes[0] = leadByte;
+					int widthChar = 1;
+					if (!UTF8IsAscii(leadByte)) {
+						const int widthCharBytes = UTF8BytesOfLead[leadByte];
+						for (int b=1; b<widthCharBytes; b++) {
+							bytes[b] = cb.CharAt(posIndexDocument+b);
+						}
+						widthChar = UTF8Classify(reinterpret_cast<const unsigned char *>(bytes), widthCharBytes) & UTF8MaskWidth;
+					}
+					if (!widthFirstCharacter)
+						widthFirstCharacter = widthChar;
+					if ((posIndexDocument + widthChar) > limitPos)
+						break;
+					const size_t lenFlat = pcf->Fold(folded, sizeof(folded), bytes, widthChar);
+					// memcmp may examine lenFlat bytes in both arguments so assert it doesn't read past end of searchThing
+					assert((indexSearch + lenFlat) <= searchThing.size());
+					// Does folded match the buffer
+					characterMatches = 0 == memcmp(folded, &searchThing[0] + indexSearch, lenFlat);
+					if (!characterMatches)
+						break;
+					posIndexDocument += widthChar;
+					indexSearch += lenFlat;
+					if (indexSearch >= lenSearch)
+						break;
+				}
+				if (characterMatches && (indexSearch == lenSearch)) {
+					if (MatchesWordOptions(word, wordStart, pos, posIndexDocument - pos)) {
+						*length = posIndexDocument - pos;
+						return pos;
 					}
-					if (found) {
-						if ((!word && !wordStart) ||
-						        word && IsWordAt(pos, pos + lengthFind) ||
-						        wordStart && IsWordStartAt(pos))
-							return pos;
+				}
+				if (forward) {
+					pos += widthFirstCharacter;
+				} else {
+					if (!NextCharacter(pos, increment))
+						break;
+				}
+			}
+		} else if (dbcsCodePage) {
+			constexpr size_t maxBytesCharacter = 2;
+			constexpr size_t maxFoldingExpansion = 4;
+			std::vector<char> searchThing((lengthFind+1) * maxBytesCharacter * maxFoldingExpansion + 1);
+			const size_t lenSearch = pcf->Fold(&searchThing[0], searchThing.size(), search, lengthFind);
+			while (forward ? (pos < endPos) : (pos >= endPos)) {
+				Sci::Position indexDocument = 0;
+				size_t indexSearch = 0;
+				bool characterMatches = true;
+				while (characterMatches &&
+					((pos + indexDocument) < limitPos) &&
+					(indexSearch < lenSearch)) {
+					char bytes[maxBytesCharacter + 1];
+					bytes[0] = cb.CharAt(pos + indexDocument);
+					const Sci::Position widthChar = IsDBCSLeadByteNoExcept(bytes[0]) ? 2 : 1;
+					if (widthChar == 2)
+						bytes[1] = cb.CharAt(pos + indexDocument + 1);
+					if ((pos + indexDocument + widthChar) > limitPos)
+						break;
+					char folded[maxBytesCharacter * maxFoldingExpansion + 1];
+					const size_t lenFlat = pcf->Fold(folded, sizeof(folded), bytes, widthChar);
+					// memcmp may examine lenFlat bytes in both arguments so assert it doesn't read past end of searchThing
+					assert((indexSearch + lenFlat) <= searchThing.size());
+					// Does folded match the buffer
+					characterMatches = 0 == memcmp(folded, &searchThing[0] + indexSearch, lenFlat);
+					indexDocument += widthChar;
+					indexSearch += lenFlat;
+				}
+				if (characterMatches && (indexSearch == lenSearch)) {
+					if (MatchesWordOptions(word, wordStart, pos, indexDocument)) {
+						*length = indexDocument;
+						return pos;
 					}
 				}
+				if (!NextCharacter(pos, increment))
+					break;
 			}
-			pos += increment;
-			if (dbcsCodePage && (pos >= 0)) {
-				// Ensure trying to match from start of character
-				pos = MovePositionOutsideChar(pos, increment, false);
+		} else {
+			const Sci::Position endSearch = (startPos <= endPos) ? endPos - lengthFind + 1 : endPos;
+			std::vector<char> searchThing(lengthFind + 1);
+			pcf->Fold(&searchThing[0], searchThing.size(), search, lengthFind);
+			while (forward ? (pos < endSearch) : (pos >= endSearch)) {
+				bool found = (pos + lengthFind) <= limitPos;
+				for (int indexSearch = 0; (indexSearch < lengthFind) && found; indexSearch++) {
+					const char ch = CharAt(pos + indexSearch);
+					char folded[2];
+					pcf->Fold(folded, sizeof(folded), &ch, 1);
+					found = folded[0] == searchThing[indexSearch];
+				}
+				if (found && MatchesWordOptions(word, wordStart, pos, lengthFind)) {
+					return pos;
+				}
+				if (!NextCharacter(pos, increment))
+					break;
 			}
 		}
 	}
@@ -1092,31 +2158,27 @@ long Document::FindText(int minPos, int maxPos, const char *s,
 	return -1;
 }
 
-const char *Document::SubstituteByPosition(const char *text, int *length) {
-	return regex->SubstituteByPosition(this, text, length);
+const char *Document::SubstituteByPosition(const char *text, Sci::Position *length) {
+	if (regex)
+		return regex->SubstituteByPosition(this, text, length);
+	else
+		return nullptr;
 }
 
-int Document::LinesTotal() const {
-	return cb.Lines();
+int Document::LineCharacterIndex() const noexcept {
+	return cb.LineCharacterIndex();
 }
 
-void Document::ChangeCase(Range r, bool makeUpperCase) {
-	for (int pos = r.start; pos < r.end;) {
-		int len = LenChar(pos);
-		if (len == 1) {
-			char ch = CharAt(pos);
-			if (makeUpperCase) {
-				if (IsLowerCase(ch)) {
-					ChangeChar(pos, static_cast<char>(MakeUpperCase(ch)));
-				}
-			} else {
-				if (IsUpperCase(ch)) {
-					ChangeChar(pos, static_cast<char>(MakeLowerCase(ch)));
-				}
-			}
-		}
-		pos += len;
-	}
+void Document::AllocateLineCharacterIndex(int lineCharacterIndex) {
+	return cb.AllocateLineCharacterIndex(lineCharacterIndex);
+}
+
+void Document::ReleaseLineCharacterIndex(int lineCharacterIndex) {
+	return cb.ReleaseLineCharacterIndex(lineCharacterIndex);
+}
+
+Sci::Line Document::LinesTotal() const noexcept {
+	return cb.Lines();
 }
 
 void Document::SetDefaultCharClasses(bool includeWordClass) {
@@ -1127,25 +2189,30 @@ void Document::SetCharClasses(const unsigned char *chars, CharClassify::cc newCh
     charClass.SetCharClasses(chars, newCharClass);
 }
 
-void Document::SetStylingBits(int bits) {
-	stylingBits = bits;
-	stylingBitsMask = (1 << stylingBits) - 1;
+int Document::GetCharsOfClass(CharClassify::cc characterClass, unsigned char *buffer) const {
+    return charClass.GetCharsOfClass(characterClass, buffer);
+}
+
+void Document::SetCharacterCategoryOptimization(int countCharacters) {
+	charMap.Optimize(countCharacters);
+}
+
+int Document::CharacterCategoryOptimization() const noexcept {
+	return charMap.Size();
 }
 
-void Document::StartStyling(int position, char mask) {
-	stylingMask = mask;
+void SCI_METHOD Document::StartStyling(Sci_Position position) {
 	endStyled = position;
 }
 
-bool Document::SetStyleFor(int length, char style) {
+bool SCI_METHOD Document::SetStyleFor(Sci_Position length, char style) {
 	if (enteredStyling != 0) {
 		return false;
 	} else {
 		enteredStyling++;
-		style &= stylingMask;
-		int prevEndStyled = endStyled;
-		if (cb.SetStyleFor(endStyled, length, style, stylingMask)) {
-			DocModification mh(SC_MOD_CHANGESTYLE | SC_PERFORMED_USER,
+		const Sci::Position prevEndStyled = endStyled;
+		if (cb.SetStyleFor(endStyled, length, style)) {
+			const DocModification mh(SC_MOD_CHANGESTYLE | SC_PERFORMED_USER,
 			                   prevEndStyled, length);
 			NotifyModified(mh);
 		}
@@ -1155,17 +2222,17 @@ bool Document::SetStyleFor(int length, char style) {
 	}
 }
 
-bool Document::SetStyles(int length, char *styles) {
+bool SCI_METHOD Document::SetStyles(Sci_Position length, const char *styles) {
 	if (enteredStyling != 0) {
 		return false;
 	} else {
 		enteredStyling++;
 		bool didChange = false;
-		int startMod = 0;
-		int endMod = 0;
+		Sci::Position startMod = 0;
+		Sci::Position endMod = 0;
 		for (int iPos = 0; iPos < length; iPos++, endStyled++) {
 			PLATFORM_ASSERT(endStyled < Length());
-			if (cb.SetStyleAt(endStyled, styles[iPos], stylingMask)) {
+			if (cb.SetStyleAt(endStyled, styles[iPos])) {
 				if (!didChange) {
 					startMod = endStyled;
 				}
@@ -1174,7 +2241,7 @@ bool Document::SetStyles(int length, char *styles) {
 			}
 		}
 		if (didChange) {
-			DocModification mh(SC_MOD_CHANGESTYLE | SC_PERFORMED_USER,
+			const DocModification mh(SC_MOD_CHANGESTYLE | SC_PERFORMED_USER,
 			                   startMod, endMod - startMod + 1);
 			NotifyModified(mh);
 		}
@@ -1183,216 +2250,394 @@ bool Document::SetStyles(int length, char *styles) {
 	}
 }
 
-void Document::EnsureStyledTo(int pos) {
+void Document::EnsureStyledTo(Sci::Position pos) {
 	if ((enteredStyling == 0) && (pos > GetEndStyled())) {
 		IncrementStyleClock();
-		// Ask the watchers to style, and stop as soon as one responds.
-		for (int i = 0; pos > GetEndStyled() && i < lenWatchers; i++) {
-			watchers[i].watcher->NotifyStyleNeeded(this, watchers[i].userData, pos);
+		if (pli && !pli->UseContainerLexing()) {
+			const Sci::Line lineEndStyled = SciLineFromPosition(GetEndStyled());
+			const Sci::Position endStyledTo = LineStart(lineEndStyled);
+			pli->Colourise(endStyledTo, pos);
+		} else {
+			// Ask the watchers to style, and stop as soon as one responds.
+			for (std::vector<WatcherWithUserData>::iterator it = watchers.begin();
+				(pos > GetEndStyled()) && (it != watchers.end()); ++it) {
+				it->watcher->NotifyStyleNeeded(this, it->userData, pos);
+			}
 		}
 	}
 }
 
-int Document::SetLineState(int line, int state) {
-	int statePrevious = cb.SetLineState(line, state);
+void Document::StyleToAdjustingLineDuration(Sci::Position pos) {
+	const Sci::Line lineFirst = SciLineFromPosition(GetEndStyled());
+	ElapsedPeriod epStyling;
+	EnsureStyledTo(pos);
+	const Sci::Line lineLast = SciLineFromPosition(GetEndStyled());
+	durationStyleOneLine.AddSample(lineLast - lineFirst, epStyling.Duration());
+}
+
+void Document::LexerChanged() {
+	// Tell the watchers the lexer has changed.
+	for (const WatcherWithUserData &watcher : watchers) {
+		watcher.watcher->NotifyLexerChanged(this, watcher.userData);
+	}
+}
+
+LexInterface *Document::GetLexInterface() const noexcept {
+	return pli.get();
+}
+
+void Document::SetLexInterface(std::unique_ptr<LexInterface> pLexInterface) noexcept {
+	pli = std::move(pLexInterface);
+}
+
+int SCI_METHOD Document::SetLineState(Sci_Position line, int state) {
+	const int statePrevious = States()->SetLineState(line, state);
 	if (state != statePrevious) {
-		DocModification mh(SC_MOD_CHANGELINESTATE, 0, 0, 0, 0, line);
+		const DocModification mh(SC_MOD_CHANGELINESTATE, LineStart(line), 0, 0, nullptr,
+			static_cast<Sci::Line>(line));
 		NotifyModified(mh);
 	}
 	return statePrevious;
 }
 
-void Document::IncrementStyleClock() {
+int SCI_METHOD Document::GetLineState(Sci_Position line) const {
+	return States()->GetLineState(line);
+}
+
+Sci::Line Document::GetMaxLineState() const noexcept {
+	return States()->GetMaxLineState();
+}
+
+void SCI_METHOD Document::ChangeLexerState(Sci_Position start, Sci_Position end) {
+	const DocModification mh(SC_MOD_LEXERSTATE, start,
+		end-start, 0, 0, 0);
+	NotifyModified(mh);
+}
+
+StyledText Document::MarginStyledText(Sci::Line line) const noexcept {
+	const LineAnnotation *pla = Margins();
+	return StyledText(pla->Length(line), pla->Text(line),
+		pla->MultipleStyles(line), pla->Style(line), pla->Styles(line));
+}
+
+void Document::MarginSetText(Sci::Line line, const char *text) {
+	Margins()->SetText(line, text);
+	const DocModification mh(SC_MOD_CHANGEMARGIN, LineStart(line),
+		0, 0, 0, line);
+	NotifyModified(mh);
+}
+
+void Document::MarginSetStyle(Sci::Line line, int style) {
+	Margins()->SetStyle(line, style);
+	NotifyModified(DocModification(SC_MOD_CHANGEMARGIN, LineStart(line),
+		0, 0, 0, line));
+}
+
+void Document::MarginSetStyles(Sci::Line line, const unsigned char *styles) {
+	Margins()->SetStyles(line, styles);
+	NotifyModified(DocModification(SC_MOD_CHANGEMARGIN, LineStart(line),
+		0, 0, 0, line));
+}
+
+void Document::MarginClearAll() {
+	const Sci::Line maxEditorLine = LinesTotal();
+	for (Sci::Line l=0; l<maxEditorLine; l++)
+		MarginSetText(l, nullptr);
+	// Free remaining data
+	Margins()->ClearAll();
+}
+
+StyledText Document::AnnotationStyledText(Sci::Line line) const noexcept {
+	const LineAnnotation *pla = Annotations();
+	return StyledText(pla->Length(line), pla->Text(line),
+		pla->MultipleStyles(line), pla->Style(line), pla->Styles(line));
+}
+
+void Document::AnnotationSetText(Sci::Line line, const char *text) {
+	if (line >= 0 && line < LinesTotal()) {
+		const Sci::Line linesBefore = AnnotationLines(line);
+		Annotations()->SetText(line, text);
+		const int linesAfter = AnnotationLines(line);
+		DocModification mh(SC_MOD_CHANGEANNOTATION, LineStart(line),
+			0, 0, 0, line);
+		mh.annotationLinesAdded = linesAfter - linesBefore;
+		NotifyModified(mh);
+	}
+}
+
+void Document::AnnotationSetStyle(Sci::Line line, int style) {
+	if (line >= 0 && line < LinesTotal()) {
+		Annotations()->SetStyle(line, style);
+		const DocModification mh(SC_MOD_CHANGEANNOTATION, LineStart(line),
+			0, 0, 0, line);
+		NotifyModified(mh);
+	}
+}
+
+void Document::AnnotationSetStyles(Sci::Line line, const unsigned char *styles) {
+	if (line >= 0 && line < LinesTotal()) {
+		Annotations()->SetStyles(line, styles);
+	}
+}
+
+int Document::AnnotationLines(Sci::Line line) const noexcept {
+	return Annotations()->Lines(line);
+}
+
+void Document::AnnotationClearAll() {
+	const Sci::Line maxEditorLine = LinesTotal();
+	for (Sci::Line l=0; l<maxEditorLine; l++)
+		AnnotationSetText(l, nullptr);
+	// Free remaining data
+	Annotations()->ClearAll();
+}
+
+StyledText Document::EOLAnnotationStyledText(Sci::Line line) const noexcept {
+	const LineAnnotation *pla = EOLAnnotations();
+	return StyledText(pla->Length(line), pla->Text(line),
+		pla->MultipleStyles(line), pla->Style(line), pla->Styles(line));
+}
+
+void Document::EOLAnnotationSetText(Sci::Line line, const char *text) {
+	if (line >= 0 && line < LinesTotal()) {
+		EOLAnnotations()->SetText(line, text);
+		const DocModification mh(SC_MOD_CHANGEEOLANNOTATION, LineStart(line),
+			0, 0, 0, line);
+		NotifyModified(mh);
+	}
+}
+
+void Document::EOLAnnotationSetStyle(Sci::Line line, int style) {
+	if (line >= 0 && line < LinesTotal()) {
+		EOLAnnotations()->SetStyle(line, style);
+		const DocModification mh(SC_MOD_CHANGEEOLANNOTATION, LineStart(line),
+			0, 0, 0, line);
+		NotifyModified(mh);
+	}
+}
+
+void Document::EOLAnnotationClearAll() {
+	const Sci::Line maxEditorLine = LinesTotal();
+	for (Sci::Line l=0; l<maxEditorLine; l++)
+		EOLAnnotationSetText(l, nullptr);
+	// Free remaining data
+	EOLAnnotations()->ClearAll();
+}
+
+void Document::IncrementStyleClock() noexcept {
 	styleClock = (styleClock + 1) % 0x100000;
 }
 
-void Document::DecorationFillRange(int position, int value, int fillLength) {
-	if (decorations.FillRange(position, value, fillLength)) {
-		DocModification mh(SC_MOD_CHANGEINDICATOR | SC_PERFORMED_USER,
-							position, fillLength);
+void SCI_METHOD Document::DecorationSetCurrentIndicator(int indicator) {
+	decorations->SetCurrentIndicator(indicator);
+}
+
+void SCI_METHOD Document::DecorationFillRange(Sci_Position position, int value, Sci_Position fillLength) {
+	const FillResult<Sci::Position> fr = decorations->FillRange(
+		position, value, fillLength);
+	if (fr.changed) {
+		const DocModification mh(SC_MOD_CHANGEINDICATOR | SC_PERFORMED_USER,
+							fr.position, fr.fillLength);
 		NotifyModified(mh);
 	}
 }
 
 bool Document::AddWatcher(DocWatcher *watcher, void *userData) {
-	for (int i = 0; i < lenWatchers; i++) {
-		if ((watchers[i].watcher == watcher) &&
-		        (watchers[i].userData == userData))
-			return false;
-	}
-	WatcherWithUserData *pwNew = new WatcherWithUserData[lenWatchers + 1];
-	if (!pwNew)
+	const WatcherWithUserData wwud(watcher, userData);
+	std::vector<WatcherWithUserData>::iterator it =
+		std::find(watchers.begin(), watchers.end(), wwud);
+	if (it != watchers.end())
 		return false;
-	for (int j = 0; j < lenWatchers; j++)
-		pwNew[j] = watchers[j];
-	pwNew[lenWatchers].watcher = watcher;
-	pwNew[lenWatchers].userData = userData;
-	delete []watchers;
-	watchers = pwNew;
-	lenWatchers++;
+	watchers.push_back(wwud);
 	return true;
 }
 
 bool Document::RemoveWatcher(DocWatcher *watcher, void *userData) {
-	for (int i = 0; i < lenWatchers; i++) {
-		if ((watchers[i].watcher == watcher) &&
-		        (watchers[i].userData == userData)) {
-			if (lenWatchers == 1) {
-				delete []watchers;
-				watchers = 0;
-				lenWatchers = 0;
-			} else {
-				WatcherWithUserData *pwNew = new WatcherWithUserData[lenWatchers];
-				if (!pwNew)
-					return false;
-				for (int j = 0; j < lenWatchers - 1; j++) {
-					pwNew[j] = (j < i) ? watchers[j] : watchers[j + 1];
-				}
-				delete []watchers;
-				watchers = pwNew;
-				lenWatchers--;
-			}
-			return true;
-		}
+	std::vector<WatcherWithUserData>::iterator it =
+		std::find(watchers.begin(), watchers.end(), WatcherWithUserData(watcher, userData));
+	if (it != watchers.end()) {
+		watchers.erase(it);
+		return true;
 	}
 	return false;
 }
 
 void Document::NotifyModifyAttempt() {
-	for (int i = 0; i < lenWatchers; i++) {
-		watchers[i].watcher->NotifyModifyAttempt(this, watchers[i].userData);
+	for (const WatcherWithUserData &watcher : watchers) {
+		watcher.watcher->NotifyModifyAttempt(this, watcher.userData);
 	}
 }
 
 void Document::NotifySavePoint(bool atSavePoint) {
-	for (int i = 0; i < lenWatchers; i++) {
-		watchers[i].watcher->NotifySavePoint(this, watchers[i].userData, atSavePoint);
+	for (const WatcherWithUserData &watcher : watchers) {
+		watcher.watcher->NotifySavePoint(this, watcher.userData, atSavePoint);
 	}
 }
 
 void Document::NotifyModified(DocModification mh) {
 	if (mh.modificationType & SC_MOD_INSERTTEXT) {
-		decorations.InsertSpace(mh.position, mh.length);
+		decorations->InsertSpace(mh.position, mh.length);
 	} else if (mh.modificationType & SC_MOD_DELETETEXT) {
-		decorations.DeleteRange(mh.position, mh.length);
+		decorations->DeleteRange(mh.position, mh.length);
+	}
+	for (const WatcherWithUserData &watcher : watchers) {
+		watcher.watcher->NotifyModified(this, mh, watcher.userData);
 	}
-	for (int i = 0; i < lenWatchers; i++) {
-		watchers[i].watcher->NotifyModified(this, mh, watchers[i].userData);
+}
+
+// Used for word part navigation.
+static bool IsASCIIPunctuationCharacter(unsigned int ch) noexcept {
+	switch (ch) {
+	case '!':
+	case '"':
+	case '#':
+	case '$':
+	case '%':
+	case '&':
+	case '\'':
+	case '(':
+	case ')':
+	case '*':
+	case '+':
+	case ',':
+	case '-':
+	case '.':
+	case '/':
+	case ':':
+	case ';':
+	case '<':
+	case '=':
+	case '>':
+	case '?':
+	case '@':
+	case '[':
+	case '\\':
+	case ']':
+	case '^':
+	case '_':
+	case '`':
+	case '{':
+	case '|':
+	case '}':
+	case '~':
+		return true;
+	default:
+		return false;
 	}
 }
 
-bool Document::IsWordPartSeparator(char ch) {
-	return (WordCharClass(ch) == CharClassify::ccWord) && IsPunctuation(ch);
+bool Document::IsWordPartSeparator(unsigned int ch) const {
+	return (WordCharacterClass(ch) == CharClassify::ccWord) && IsASCIIPunctuationCharacter(ch);
 }
 
-int Document::WordPartLeft(int pos) {
+Sci::Position Document::WordPartLeft(Sci::Position pos) const {
 	if (pos > 0) {
-		--pos;
-		char startChar = cb.CharAt(pos);
-		if (IsWordPartSeparator(startChar)) {
-			while (pos > 0 && IsWordPartSeparator(cb.CharAt(pos))) {
-				--pos;
+		pos -= CharacterBefore(pos).widthBytes;
+		CharacterExtracted ceStart = CharacterAfter(pos);
+		if (IsWordPartSeparator(ceStart.character)) {
+			while (pos > 0 && IsWordPartSeparator(CharacterAfter(pos).character)) {
+				pos -= CharacterBefore(pos).widthBytes;
 			}
 		}
 		if (pos > 0) {
-			startChar = cb.CharAt(pos);
-			--pos;
-			if (IsLowerCase(startChar)) {
-				while (pos > 0 && IsLowerCase(cb.CharAt(pos)))
-					--pos;
-				if (!IsUpperCase(cb.CharAt(pos)) && !IsLowerCase(cb.CharAt(pos)))
-					++pos;
-			} else if (IsUpperCase(startChar)) {
-				while (pos > 0 && IsUpperCase(cb.CharAt(pos)))
-					--pos;
-				if (!IsUpperCase(cb.CharAt(pos)))
-					++pos;
-			} else if (IsADigit(startChar)) {
-				while (pos > 0 && IsADigit(cb.CharAt(pos)))
-					--pos;
-				if (!IsADigit(cb.CharAt(pos)))
-					++pos;
-			} else if (IsPunctuation(startChar)) {
-				while (pos > 0 && IsPunctuation(cb.CharAt(pos)))
-					--pos;
-				if (!IsPunctuation(cb.CharAt(pos)))
-					++pos;
-			} else if (isspacechar(startChar)) {
-				while (pos > 0 && isspacechar(cb.CharAt(pos)))
-					--pos;
-				if (!isspacechar(cb.CharAt(pos)))
-					++pos;
-			} else if (!isascii(startChar)) {
-				while (pos > 0 && !isascii(cb.CharAt(pos)))
-					--pos;
-				if (isascii(cb.CharAt(pos)))
-					++pos;
+			ceStart = CharacterAfter(pos);
+			pos -= CharacterBefore(pos).widthBytes;
+			if (IsLowerCase(ceStart.character)) {
+				while (pos > 0 && IsLowerCase(CharacterAfter(pos).character))
+					pos -= CharacterBefore(pos).widthBytes;
+				if (!IsUpperCase(CharacterAfter(pos).character) && !IsLowerCase(CharacterAfter(pos).character))
+					pos += CharacterAfter(pos).widthBytes;
+			} else if (IsUpperCase(ceStart.character)) {
+				while (pos > 0 && IsUpperCase(CharacterAfter(pos).character))
+					pos -= CharacterBefore(pos).widthBytes;
+				if (!IsUpperCase(CharacterAfter(pos).character))
+					pos += CharacterAfter(pos).widthBytes;
+			} else if (IsADigit(ceStart.character)) {
+				while (pos > 0 && IsADigit(CharacterAfter(pos).character))
+					pos -= CharacterBefore(pos).widthBytes;
+				if (!IsADigit(CharacterAfter(pos).character))
+					pos += CharacterAfter(pos).widthBytes;
+			} else if (IsASCIIPunctuationCharacter(ceStart.character)) {
+				while (pos > 0 && IsASCIIPunctuationCharacter(CharacterAfter(pos).character))
+					pos -= CharacterBefore(pos).widthBytes;
+				if (!IsASCIIPunctuationCharacter(CharacterAfter(pos).character))
+					pos += CharacterAfter(pos).widthBytes;
+			} else if (isspacechar(ceStart.character)) {
+				while (pos > 0 && isspacechar(CharacterAfter(pos).character))
+					pos -= CharacterBefore(pos).widthBytes;
+				if (!isspacechar(CharacterAfter(pos).character))
+					pos += CharacterAfter(pos).widthBytes;
+			} else if (!IsASCII(ceStart.character)) {
+				while (pos > 0 && !IsASCII(CharacterAfter(pos).character))
+					pos -= CharacterBefore(pos).widthBytes;
+				if (IsASCII(CharacterAfter(pos).character))
+					pos += CharacterAfter(pos).widthBytes;
 			} else {
-				++pos;
+				pos += CharacterAfter(pos).widthBytes;
 			}
 		}
 	}
 	return pos;
 }
 
-int Document::WordPartRight(int pos) {
-	char startChar = cb.CharAt(pos);
-	int length = Length();
-	if (IsWordPartSeparator(startChar)) {
-		while (pos < length && IsWordPartSeparator(cb.CharAt(pos)))
-			++pos;
-		startChar = cb.CharAt(pos);
-	}
-	if (!isascii(startChar)) {
-		while (pos < length && !isascii(cb.CharAt(pos)))
-			++pos;
-	} else if (IsLowerCase(startChar)) {
-		while (pos < length && IsLowerCase(cb.CharAt(pos)))
-			++pos;
-	} else if (IsUpperCase(startChar)) {
-		if (IsLowerCase(cb.CharAt(pos + 1))) {
-			++pos;
-			while (pos < length && IsLowerCase(cb.CharAt(pos)))
-				++pos;
+Sci::Position Document::WordPartRight(Sci::Position pos) const {
+	CharacterExtracted ceStart = CharacterAfter(pos);
+	const Sci::Position length = LengthNoExcept();
+	if (IsWordPartSeparator(ceStart.character)) {
+		while (pos < length && IsWordPartSeparator(CharacterAfter(pos).character))
+			pos += CharacterAfter(pos).widthBytes;
+		ceStart = CharacterAfter(pos);
+	}
+	if (!IsASCII(ceStart.character)) {
+		while (pos < length && !IsASCII(CharacterAfter(pos).character))
+			pos += CharacterAfter(pos).widthBytes;
+	} else if (IsLowerCase(ceStart.character)) {
+		while (pos < length && IsLowerCase(CharacterAfter(pos).character))
+			pos += CharacterAfter(pos).widthBytes;
+	} else if (IsUpperCase(ceStart.character)) {
+		if (IsLowerCase(CharacterAfter(pos + ceStart.widthBytes).character)) {
+			pos += CharacterAfter(pos).widthBytes;
+			while (pos < length && IsLowerCase(CharacterAfter(pos).character))
+				pos += CharacterAfter(pos).widthBytes;
 		} else {
-			while (pos < length && IsUpperCase(cb.CharAt(pos)))
-				++pos;
-		}
-		if (IsLowerCase(cb.CharAt(pos)) && IsUpperCase(cb.CharAt(pos - 1)))
-			--pos;
-	} else if (IsADigit(startChar)) {
-		while (pos < length && IsADigit(cb.CharAt(pos)))
-			++pos;
-	} else if (IsPunctuation(startChar)) {
-		while (pos < length && IsPunctuation(cb.CharAt(pos)))
-			++pos;
-	} else if (isspacechar(startChar)) {
-		while (pos < length && isspacechar(cb.CharAt(pos)))
-			++pos;
+			while (pos < length && IsUpperCase(CharacterAfter(pos).character))
+				pos += CharacterAfter(pos).widthBytes;
+		}
+		if (IsLowerCase(CharacterAfter(pos).character) && IsUpperCase(CharacterBefore(pos).character))
+			pos -= CharacterBefore(pos).widthBytes;
+	} else if (IsADigit(ceStart.character)) {
+		while (pos < length && IsADigit(CharacterAfter(pos).character))
+			pos += CharacterAfter(pos).widthBytes;
+	} else if (IsASCIIPunctuationCharacter(ceStart.character)) {
+		while (pos < length && IsASCIIPunctuationCharacter(CharacterAfter(pos).character))
+			pos += CharacterAfter(pos).widthBytes;
+	} else if (isspacechar(ceStart.character)) {
+		while (pos < length && isspacechar(CharacterAfter(pos).character))
+			pos += CharacterAfter(pos).widthBytes;
 	} else {
-		++pos;
+		pos += CharacterAfter(pos).widthBytes;
 	}
 	return pos;
 }
 
-bool IsLineEndChar(char c) {
+static constexpr bool IsLineEndChar(char c) noexcept {
 	return (c == '\n' || c == '\r');
 }
 
-int Document::ExtendStyleRange(int pos, int delta, bool singleLine) {
-	int sStart = cb.StyleAt(pos);
+Sci::Position Document::ExtendStyleRange(Sci::Position pos, int delta, bool singleLine) noexcept {
+	const int sStart = cb.StyleAt(pos);
 	if (delta < 0) {
-		while (pos > 0 && (cb.StyleAt(pos) == sStart) && (!singleLine || !IsLineEndChar(cb.CharAt(pos))) )
+		while (pos > 0 && (cb.StyleAt(pos) == sStart) && (!singleLine || !IsLineEndChar(cb.CharAt(pos))))
 			pos--;
 		pos++;
 	} else {
-		while (pos < (Length()) && (cb.StyleAt(pos) == sStart) && (!singleLine || !IsLineEndChar(cb.CharAt(pos))) )
+		while (pos < (LengthNoExcept()) && (cb.StyleAt(pos) == sStart) && (!singleLine || !IsLineEndChar(cb.CharAt(pos))))
 			pos++;
 	}
 	return pos;
 }
 
-static char BraceOpposite(char ch) {
+static char BraceOpposite(char ch) noexcept {
 	switch (ch) {
 	case '(':
 		return ')';
@@ -1416,21 +2661,20 @@ static char BraceOpposite(char ch) {
 }
 
 // TODO: should be able to extend styled region to find matching brace
-int Document::BraceMatch(int position, int /*maxReStyle*/) {
-	char chBrace = CharAt(position);
-	char chSeek = BraceOpposite(chBrace);
+Sci::Position Document::BraceMatch(Sci::Position position, Sci::Position /*maxReStyle*/, Sci::Position startPos, bool useStartPos) noexcept {
+	const char chBrace = CharAt(position);
+	const char chSeek = BraceOpposite(chBrace);
 	if (chSeek == '\0')
 		return - 1;
-	char styBrace = static_cast<char>(StyleAt(position) & stylingBitsMask);
+	const int styBrace = StyleIndexAt(position);
 	int direction = -1;
 	if (chBrace == '(' || chBrace == '[' || chBrace == '{' || chBrace == '<')
 		direction = 1;
 	int depth = 1;
-	position = position + direction;
-	while ((position >= 0) && (position < Length())) {
-		position = MovePositionOutsideChar(position, direction);
-		char chAtPos = CharAt(position);
-		char styAtPos = static_cast<char>(StyleAt(position) & stylingBitsMask);
+	position = useStartPos ? startPos : NextPosition(position, direction);
+	while ((position >= 0) && (position < LengthNoExcept())) {
+		const char chAtPos = CharAt(position);
+		const int styAtPos = StyleIndexAt(position);
 		if ((position > GetEndStyled()) || (styAtPos == styBrace)) {
 			if (chAtPos == chBrace)
 				depth++;
@@ -1439,7 +2683,10 @@ int Document::BraceMatch(int position, int /*maxReStyle*/) {
 			if (depth == 0)
 				return position;
 		}
-		position = position + direction;
+		const Sci::Position positionBeforeMove = position;
+		position = NextPosition(position, direction);
+		if (position == positionBeforeMove)
+			break;
 	}
 	return - 1;
 }
@@ -1449,36 +2696,84 @@ int Document::BraceMatch(int position, int /*maxReStyle*/) {
  */
 class BuiltinRegex : public RegexSearchBase {
 public:
-	BuiltinRegex(CharClassify *charClassTable) : search(charClassTable), substituted(NULL) {}
-
-	virtual ~BuiltinRegex() {
-		delete substituted;
-	}
-
-	virtual long FindText(Document *doc, int minPos, int maxPos, const char *s,
+	explicit BuiltinRegex(CharClassify *charClassTable) : search(charClassTable) {}
+	BuiltinRegex(const BuiltinRegex &) = delete;
+	BuiltinRegex(BuiltinRegex &&) = delete;
+	BuiltinRegex &operator=(const BuiltinRegex &) = delete;
+	BuiltinRegex &operator=(BuiltinRegex &&) = delete;
+	~BuiltinRegex() override = default;
+
+	Sci::Position FindText(Document *doc, Sci::Position minPos, Sci::Position maxPos, const char *s,
                         bool caseSensitive, bool word, bool wordStart, int flags,
-                        int *length);
+                        Sci::Position *length) override;
 
-	virtual const char *SubstituteByPosition(Document* doc, const char *text, int *length);
+	const char *SubstituteByPosition(Document *doc, const char *text, Sci::Position *length) override;
 
 private:
 	RESearch search;
-	char *substituted;
+	std::string substituted;
+};
+
+namespace {
+
+/**
+* RESearchRange keeps track of search range.
+*/
+class RESearchRange {
+public:
+	const Document *doc;
+	int increment;
+	Sci::Position startPos;
+	Sci::Position endPos;
+	Sci::Line lineRangeStart;
+	Sci::Line lineRangeEnd;
+	Sci::Line lineRangeBreak;
+	RESearchRange(const Document *doc_, Sci::Position minPos, Sci::Position maxPos) noexcept : doc(doc_) {
+		increment = (minPos <= maxPos) ? 1 : -1;
+
+		// Range endpoints should not be inside DBCS characters or between a CR and LF,
+		// but just in case, move them.
+		startPos = doc->MovePositionOutsideChar(minPos, 1, true);
+		endPos = doc->MovePositionOutsideChar(maxPos, 1, true);
+
+		lineRangeStart = doc->SciLineFromPosition(startPos);
+		lineRangeEnd = doc->SciLineFromPosition(endPos);
+		lineRangeBreak = lineRangeEnd + increment;
+	}
+	Range LineRange(Sci::Line line) const {
+		Range range(doc->LineStart(line), doc->LineEnd(line));
+		if (increment == 1) {
+			if (line == lineRangeStart)
+				range.start = startPos;
+			if (line == lineRangeEnd)
+				range.end = endPos;
+		} else {
+			if (line == lineRangeEnd)
+				range.start = endPos;
+			if (line == lineRangeStart)
+				range.end = startPos;
+		}
+		return range;
+	}
 };
 
 // Define a way for the Regular Expression code to access the document
 class DocumentIndexer : public CharacterIndexer {
 	Document *pdoc;
-	int end;
+	Sci::Position end;
 public:
-	DocumentIndexer(Document *pdoc_, int end_) :
+	DocumentIndexer(Document *pdoc_, Sci::Position end_) noexcept :
 		pdoc(pdoc_), end(end_) {
 	}
 
-	virtual ~DocumentIndexer() {
-	}
+	DocumentIndexer(const DocumentIndexer &) = delete;
+	DocumentIndexer(DocumentIndexer &&) = delete;
+	DocumentIndexer &operator=(const DocumentIndexer &) = delete;
+	DocumentIndexer &operator=(DocumentIndexer &&) = delete;
+
+	~DocumentIndexer() override = default;
 
-	virtual char CharAt(int index) {
+	char CharAt(Sci::Position index) const noexcept override {
 		if (index < 0 || index >= end)
 			return 0;
 		else
@@ -1486,18 +2781,401 @@ class DocumentIndexer : public CharacterIndexer {
 	}
 };
 
-long BuiltinRegex::FindText(Document *doc, int minPos, int maxPos, const char *s,
+#ifndef NO_CXX11_REGEX
+
+class ByteIterator {
+public:
+	typedef std::bidirectional_iterator_tag iterator_category;
+	typedef char value_type;
+	typedef ptrdiff_t difference_type;
+	typedef char* pointer;
+	typedef char& reference;
+
+	const Document *doc;
+	Sci::Position position;
+
+	ByteIterator(const Document *doc_=nullptr, Sci::Position position_=0) noexcept :
+		doc(doc_), position(position_) {
+	}
+	ByteIterator(const ByteIterator &other) noexcept {
+		doc = other.doc;
+		position = other.position;
+	}
+	ByteIterator(ByteIterator &&other) noexcept {
+		doc = other.doc;
+		position = other.position;
+	}
+	ByteIterator &operator=(const ByteIterator &other) noexcept {
+		if (this != &other) {
+			doc = other.doc;
+			position = other.position;
+		}
+		return *this;
+	}
+	ByteIterator &operator=(ByteIterator &&) noexcept = default;
+	~ByteIterator() = default;
+	char operator*() const noexcept {
+		return doc->CharAt(position);
+	}
+	ByteIterator &operator++() noexcept {
+		position++;
+		return *this;
+	}
+	ByteIterator operator++(int) noexcept {
+		ByteIterator retVal(*this);
+		position++;
+		return retVal;
+	}
+	ByteIterator &operator--() noexcept {
+		position--;
+		return *this;
+	}
+	bool operator==(const ByteIterator &other) const noexcept {
+		return doc == other.doc && position == other.position;
+	}
+	bool operator!=(const ByteIterator &other) const noexcept {
+		return doc != other.doc || position != other.position;
+	}
+	Sci::Position Pos() const noexcept {
+		return position;
+	}
+	Sci::Position PosRoundUp() const noexcept {
+		return position;
+	}
+};
+
+// On Windows, wchar_t is 16 bits wide and on Unix it is 32 bits wide.
+// Would be better to use sizeof(wchar_t) or similar to differentiate
+// but easier for now to hard-code platforms.
+// C++11 has char16_t and char32_t but neither Clang nor Visual C++
+// appear to allow specializing basic_regex over these.
+
+#ifdef _WIN32
+#define WCHAR_T_IS_16 1
+#else
+#define WCHAR_T_IS_16 0
+#endif
+
+#if WCHAR_T_IS_16
+
+// On Windows, report non-BMP characters as 2 separate surrogates as that
+// matches wregex since it is based on wchar_t.
+class UTF8Iterator {
+	// These 3 fields determine the iterator position and are used for comparisons
+	const Document *doc;
+	Sci::Position position;
+	size_t characterIndex;
+	// Remaining fields are derived from the determining fields so are excluded in comparisons
+	unsigned int lenBytes;
+	size_t lenCharacters;
+	wchar_t buffered[2];
+public:
+	typedef std::bidirectional_iterator_tag iterator_category;
+	typedef wchar_t value_type;
+	typedef ptrdiff_t difference_type;
+	typedef wchar_t* pointer;
+	typedef wchar_t& reference;
+
+	UTF8Iterator(const Document *doc_=nullptr, Sci::Position position_=0) noexcept :
+		doc(doc_), position(position_), characterIndex(0), lenBytes(0), lenCharacters(0), buffered{} {
+		buffered[0] = 0;
+		buffered[1] = 0;
+		if (doc) {
+			ReadCharacter();
+		}
+	}
+	UTF8Iterator(const UTF8Iterator &other) noexcept : buffered{} {
+		doc = other.doc;
+		position = other.position;
+		characterIndex = other.characterIndex;
+		lenBytes = other.lenBytes;
+		lenCharacters = other.lenCharacters;
+		buffered[0] = other.buffered[0];
+		buffered[1] = other.buffered[1];
+	}
+	UTF8Iterator(UTF8Iterator &&other) noexcept = default;
+	UTF8Iterator &operator=(const UTF8Iterator &other) noexcept {
+		if (this != &other) {
+			doc = other.doc;
+			position = other.position;
+			characterIndex = other.characterIndex;
+			lenBytes = other.lenBytes;
+			lenCharacters = other.lenCharacters;
+			buffered[0] = other.buffered[0];
+			buffered[1] = other.buffered[1];
+		}
+		return *this;
+	}
+	UTF8Iterator &operator=(UTF8Iterator &&) noexcept = default;
+	~UTF8Iterator() = default;
+	wchar_t operator*() const noexcept {
+		assert(lenCharacters != 0);
+		return buffered[characterIndex];
+	}
+	UTF8Iterator &operator++() noexcept {
+		if ((characterIndex + 1) < (lenCharacters)) {
+			characterIndex++;
+		} else {
+			position += lenBytes;
+			ReadCharacter();
+			characterIndex = 0;
+		}
+		return *this;
+	}
+	UTF8Iterator operator++(int) noexcept {
+		UTF8Iterator retVal(*this);
+		if ((characterIndex + 1) < (lenCharacters)) {
+			characterIndex++;
+		} else {
+			position += lenBytes;
+			ReadCharacter();
+			characterIndex = 0;
+		}
+		return retVal;
+	}
+	UTF8Iterator &operator--() noexcept {
+		if (characterIndex) {
+			characterIndex--;
+		} else {
+			position = doc->NextPosition(position, -1);
+			ReadCharacter();
+			characterIndex = lenCharacters - 1;
+		}
+		return *this;
+	}
+	bool operator==(const UTF8Iterator &other) const noexcept {
+		// Only test the determining fields, not the character widths and values derived from this
+		return doc == other.doc &&
+			position == other.position &&
+			characterIndex == other.characterIndex;
+	}
+	bool operator!=(const UTF8Iterator &other) const noexcept {
+		// Only test the determining fields, not the character widths and values derived from this
+		return doc != other.doc ||
+			position != other.position ||
+			characterIndex != other.characterIndex;
+	}
+	Sci::Position Pos() const noexcept {
+		return position;
+	}
+	Sci::Position PosRoundUp() const noexcept {
+		if (characterIndex)
+			return position + lenBytes;	// Force to end of character
+		else
+			return position;
+	}
+private:
+	void ReadCharacter() noexcept {
+		const Document::CharacterExtracted charExtracted = doc->ExtractCharacter(position);
+		lenBytes = charExtracted.widthBytes;
+		if (charExtracted.character == unicodeReplacementChar) {
+			lenCharacters = 1;
+			buffered[0] = static_cast<wchar_t>(charExtracted.character);
+		} else {
+			lenCharacters = UTF16FromUTF32Character(charExtracted.character, buffered);
+		}
+	}
+};
+
+#else
+
+// On Unix, report non-BMP characters as single characters
+
+class UTF8Iterator {
+	const Document *doc;
+	Sci::Position position;
+public:
+	typedef std::bidirectional_iterator_tag iterator_category;
+	typedef wchar_t value_type;
+	typedef ptrdiff_t difference_type;
+	typedef wchar_t* pointer;
+	typedef wchar_t& reference;
+
+	UTF8Iterator(const Document *doc_=nullptr, Sci::Position position_=0) noexcept :
+		doc(doc_), position(position_) {
+	}
+	UTF8Iterator(const UTF8Iterator &other) noexcept {
+		doc = other.doc;
+		position = other.position;
+	}
+	UTF8Iterator(UTF8Iterator &&other) noexcept = default;
+	UTF8Iterator &operator=(const UTF8Iterator &other) noexcept {
+		if (this != &other) {
+			doc = other.doc;
+			position = other.position;
+		}
+		return *this;
+	}
+	UTF8Iterator &operator=(UTF8Iterator &&) noexcept = default;
+	~UTF8Iterator() = default;
+	wchar_t operator*() const noexcept {
+		const Document::CharacterExtracted charExtracted = doc->ExtractCharacter(position);
+		return charExtracted.character;
+	}
+	UTF8Iterator &operator++() noexcept {
+		position = doc->NextPosition(position, 1);
+		return *this;
+	}
+	UTF8Iterator operator++(int) noexcept {
+		UTF8Iterator retVal(*this);
+		position = doc->NextPosition(position, 1);
+		return retVal;
+	}
+	UTF8Iterator &operator--() noexcept {
+		position = doc->NextPosition(position, -1);
+		return *this;
+	}
+	bool operator==(const UTF8Iterator &other) const noexcept {
+		return doc == other.doc && position == other.position;
+	}
+	bool operator!=(const UTF8Iterator &other) const noexcept {
+		return doc != other.doc || position != other.position;
+	}
+	Sci::Position Pos() const noexcept {
+		return position;
+	}
+	Sci::Position PosRoundUp() const noexcept {
+		return position;
+	}
+};
+
+#endif
+
+std::regex_constants::match_flag_type MatchFlags(const Document *doc, Sci::Position startPos, Sci::Position endPos) {
+	std::regex_constants::match_flag_type flagsMatch = std::regex_constants::match_default;
+	if (!doc->IsLineStartPosition(startPos))
+		flagsMatch |= std::regex_constants::match_not_bol;
+	if (!doc->IsLineEndPosition(endPos))
+		flagsMatch |= std::regex_constants::match_not_eol;
+	return flagsMatch;
+}
+
+template<typename Iterator, typename Regex>
+bool MatchOnLines(const Document *doc, const Regex &regexp, const RESearchRange &resr, RESearch &search) {
+	std::match_results<Iterator> match;
+
+	// MSVC and libc++ have problems with ^ and $ matching line ends inside a range.
+	// CRLF line ends are also a problem as ^ and $ only treat LF as a line end.
+	// The std::regex::multiline option was added to C++17 to improve behaviour but
+	// has not been implemented by compiler runtimes with MSVC always in multiline
+	// mode and libc++ and libstdc++ always in single-line mode.
+	// If multiline regex worked well then the line by line iteration could be removed
+	// for the forwards case and replaced with the following 4 lines:
+#ifdef REGEX_MULTILINE
+	Iterator itStart(doc, resr.startPos);
+	Iterator itEnd(doc, resr.endPos);
+	const std::regex_constants::match_flag_type flagsMatch = MatchFlags(doc, resr.startPos, resr.endPos);
+	const bool matched = std::regex_search(itStart, itEnd, match, regexp, flagsMatch);
+#else
+	// Line by line.
+	bool matched = false;
+	for (Sci::Line line = resr.lineRangeStart; line != resr.lineRangeBreak; line += resr.increment) {
+		const Range lineRange = resr.LineRange(line);
+		Iterator itStart(doc, lineRange.start);
+		Iterator itEnd(doc, lineRange.end);
+		std::regex_constants::match_flag_type flagsMatch = MatchFlags(doc, lineRange.start, lineRange.end);
+		matched = std::regex_search(itStart, itEnd, match, regexp, flagsMatch);
+		// Check for the last match on this line.
+		if (matched) {
+			if (resr.increment == -1) {
+				while (matched) {
+					Iterator itNext(doc, match[0].second.PosRoundUp());
+					flagsMatch = MatchFlags(doc, itNext.Pos(), lineRange.end);
+					std::match_results<Iterator> matchNext;
+					matched = std::regex_search(itNext, itEnd, matchNext, regexp, flagsMatch);
+					if (matched) {
+						if (match[0].first == match[0].second) {
+							// Empty match means failure so exit
+							return false;
+						}
+						match = matchNext;
+					}
+				}
+				matched = true;
+			}
+			break;
+		}
+	}
+#endif
+	if (matched) {
+		for (size_t co = 0; co < match.size(); co++) {
+			search.bopat[co] = match[co].first.Pos();
+			search.eopat[co] = match[co].second.PosRoundUp();
+			const Sci::Position lenMatch = search.eopat[co] - search.bopat[co];
+			search.pat[co].resize(lenMatch);
+			for (Sci::Position iPos = 0; iPos < lenMatch; iPos++) {
+				search.pat[co][iPos] = doc->CharAt(iPos + search.bopat[co]);
+			}
+		}
+	}
+	return matched;
+}
+
+Sci::Position Cxx11RegexFindText(const Document *doc, Sci::Position minPos, Sci::Position maxPos, const char *s,
+	bool caseSensitive, Sci::Position *length, RESearch &search) {
+	const RESearchRange resr(doc, minPos, maxPos);
+	try {
+		//ElapsedPeriod ep;
+		std::regex::flag_type flagsRe = std::regex::ECMAScript;
+		// Flags that appear to have no effect:
+		// | std::regex::collate | std::regex::extended;
+		if (!caseSensitive)
+			flagsRe = flagsRe | std::regex::icase;
+
+		// Clear the RESearch so can fill in matches
+		search.Clear();
+
+		bool matched = false;
+		if (SC_CP_UTF8 == doc->dbcsCodePage) {
+			const std::wstring ws = WStringFromUTF8(s);
+			std::wregex regexp;
+			regexp.assign(ws, flagsRe);
+			matched = MatchOnLines<UTF8Iterator>(doc, regexp, resr, search);
+
+		} else {
+			std::regex regexp;
+			regexp.assign(s, flagsRe);
+			matched = MatchOnLines<ByteIterator>(doc, regexp, resr, search);
+		}
+
+		Sci::Position posMatch = -1;
+		if (matched) {
+			posMatch = search.bopat[0];
+			*length = search.eopat[0] - search.bopat[0];
+		}
+		// Example - search in doc/ScintillaHistory.html for
+		// [[:upper:]]eta[[:space:]]
+		// On MacBook, normally around 1 second but with locale imbued -> 14 seconds.
+		//const double durSearch = ep.Duration(true);
+		//Platform::DebugPrintf("Search:%9.6g \n", durSearch);
+		return posMatch;
+	} catch (std::regex_error &) {
+		// Failed to create regular expression
+		throw RegexError();
+	} catch (...) {
+		// Failed in some other way
+		return -1;
+	}
+}
+
+#endif
+
+}
+
+Sci::Position BuiltinRegex::FindText(Document *doc, Sci::Position minPos, Sci::Position maxPos, const char *s,
                         bool caseSensitive, bool, bool, int flags,
-                        int *length) {
-	bool posix = (flags & SCFIND_POSIX) != 0;
-	int increment = (minPos <= maxPos) ? 1 : -1;
+                        Sci::Position *length) {
+
+#ifndef NO_CXX11_REGEX
+	if (flags & SCFIND_CXX11REGEX) {
+			return Cxx11RegexFindText(doc, minPos, maxPos, s,
+			caseSensitive, length, search);
+	}
+#endif
 
-	int startPos = minPos;
-	int endPos = maxPos;
+	const RESearchRange resr(doc, minPos, maxPos);
 
-	// Range endpoints should not be inside DBCS characters, but just in case, move them.
-	startPos = doc->MovePositionOutsideChar(startPos, 1, false);
-	endPos = doc->MovePositionOutsideChar(endPos, 1, false);
+	const bool posix = (flags & SCFIND_POSIX) != 0;
 
 	const char *errmsg = search.Compile(s, *length, caseSensitive, posix);
 	if (errmsg) {
@@ -1507,52 +3185,48 @@ long BuiltinRegex::FindText(Document *doc, int minPos, int maxPos, const char *s
 	// Replace first '.' with '-' in each property file variable reference:
 	//     Search: \$(\([A-Za-z0-9_-]+\)\.\([A-Za-z0-9_.]+\))
 	//     Replace: $(\1-\2)
-	int lineRangeStart = doc->LineFromPosition(startPos);
-	int lineRangeEnd = doc->LineFromPosition(endPos);
-	if ((increment == 1) &&
-		(startPos >= doc->LineEnd(lineRangeStart)) &&
-		(lineRangeStart < lineRangeEnd)) {
-		// the start position is at end of line or between line end characters.
-		lineRangeStart++;
-		startPos = doc->LineStart(lineRangeStart);
-	}
-	int pos = -1;
-	int lenRet = 0;
-	char searchEnd = s[*length - 1];
-	int lineRangeBreak = lineRangeEnd + increment;
-	for (int line = lineRangeStart; line != lineRangeBreak; line += increment) {
-		int startOfLine = doc->LineStart(line);
-		int endOfLine = doc->LineEnd(line);
-		if (increment == 1) {
-			if (line == lineRangeStart) {
-				if ((startPos != startOfLine) && (s[0] == '^'))
+	Sci::Position pos = -1;
+	Sci::Position lenRet = 0;
+	const bool searchforLineStart = s[0] == '^';
+	const char searchEnd = s[*length - 1];
+	const char searchEndPrev = (*length > 1) ? s[*length - 2] : '\0';
+	const bool searchforLineEnd = (searchEnd == '$') && (searchEndPrev != '\\');
+	for (Sci::Line line = resr.lineRangeStart; line != resr.lineRangeBreak; line += resr.increment) {
+		Sci::Position startOfLine = doc->LineStart(line);
+		Sci::Position endOfLine = doc->LineEnd(line);
+		if (resr.increment == 1) {
+			if (line == resr.lineRangeStart) {
+				if ((resr.startPos != startOfLine) && searchforLineStart)
 					continue;	// Can't match start of line if start position after start of line
-				startOfLine = startPos;
+				startOfLine = resr.startPos;
 			}
-			if (line == lineRangeEnd) {
-				if ((endPos != endOfLine) && (searchEnd == '$'))
+			if (line == resr.lineRangeEnd) {
+				if ((resr.endPos != endOfLine) && searchforLineEnd)
 					continue;	// Can't match end of line if end position before end of line
-				endOfLine = endPos;
+				endOfLine = resr.endPos;
 			}
 		} else {
-			if (line == lineRangeEnd) {
-				if ((endPos != startOfLine) && (s[0] == '^'))
+			if (line == resr.lineRangeEnd) {
+				if ((resr.endPos != startOfLine) && searchforLineStart)
 					continue;	// Can't match start of line if end position after start of line
-				startOfLine = endPos;
+				startOfLine = resr.endPos;
 			}
-			if (line == lineRangeStart) {
-				if ((startPos != endOfLine) && (searchEnd == '$'))
+			if (line == resr.lineRangeStart) {
+				if ((resr.startPos != endOfLine) && searchforLineEnd)
 					continue;	// Can't match end of line if start position before end of line
-				endOfLine = startPos;
+				endOfLine = resr.startPos;
 			}
 		}
 
-		DocumentIndexer di(doc, endOfLine);
+		const DocumentIndexer di(doc, endOfLine);
 		int success = search.Execute(di, startOfLine, endOfLine);
 		if (success) {
 			pos = search.bopat[0];
+			// Ensure only whole characters selected
+			search.eopat[0] = doc->MovePositionOutsideChar(search.eopat[0], 1, false);
 			lenRet = search.eopat[0] - search.bopat[0];
-			if (increment == -1) {
+			// There can be only one start of a line, so no need to look for last match in line
+			if ((resr.increment == -1) && !searchforLineStart) {
 				// Check for the last match on this line.
 				int repetitions = 1000;	// Break out of infinite loop
 				while (success && (search.eopat[0] <= endOfLine) && (repetitions--)) {
@@ -1574,90 +3248,61 @@ long BuiltinRegex::FindText(Document *doc, int minPos, int maxPos, const char *s
 	return pos;
 }
 
-const char *BuiltinRegex::SubstituteByPosition(Document* doc, const char *text, int *length) {
-	delete []substituted;
-	substituted = 0;
-	DocumentIndexer di(doc, doc->Length());
-	if (!search.GrabMatches(di))
-		return 0;
-	unsigned int lenResult = 0;
-	for (int i = 0; i < *length; i++) {
-		if (text[i] == '\\') {
-			if (text[i + 1] >= '1' && text[i + 1] <= '9') {
-				unsigned int patNum = text[i + 1] - '0';
-				lenResult += search.eopat[patNum] - search.bopat[patNum];
-				i++;
-			} else {
-				switch (text[i + 1]) {
-				case 'a':
-				case 'b':
-				case 'f':
-				case 'n':
-				case 'r':
-				case 't':
-				case 'v':
-					i++;
-				}
-				lenResult++;
-			}
-		} else {
-			lenResult++;
-		}
-	}
-	substituted = new char[lenResult + 1];
-	if (!substituted)
-		return 0;
-	char *o = substituted;
-	for (int j = 0; j < *length; j++) {
+const char *BuiltinRegex::SubstituteByPosition(Document *doc, const char *text, Sci::Position *length) {
+	substituted.clear();
+	const DocumentIndexer di(doc, doc->Length());
+	search.GrabMatches(di);
+	for (Sci::Position j = 0; j < *length; j++) {
 		if (text[j] == '\\') {
-			if (text[j + 1] >= '1' && text[j + 1] <= '9') {
-				unsigned int patNum = text[j + 1] - '0';
-				unsigned int len = search.eopat[patNum] - search.bopat[patNum];
-				if (search.pat[patNum])	// Will be null if try for a match that did not occur
-					memcpy(o, search.pat[patNum], len);
-				o += len;
+			if (text[j + 1] >= '0' && text[j + 1] <= '9') {
+				const unsigned int patNum = text[j + 1] - '0';
+				const Sci::Position len = search.eopat[patNum] - search.bopat[patNum];
+				if (!search.pat[patNum].empty())	// Will be null if try for a match that did not occur
+					substituted.append(search.pat[patNum].c_str(), len);
 				j++;
 			} else {
 				j++;
 				switch (text[j]) {
 				case 'a':
-					*o++ = '\a';
+					substituted.push_back('\a');
 					break;
 				case 'b':
-					*o++ = '\b';
+					substituted.push_back('\b');
 					break;
 				case 'f':
-					*o++ = '\f';
+					substituted.push_back('\f');
 					break;
 				case 'n':
-					*o++ = '\n';
+					substituted.push_back('\n');
 					break;
 				case 'r':
-					*o++ = '\r';
+					substituted.push_back('\r');
 					break;
 				case 't':
-					*o++ = '\t';
+					substituted.push_back('\t');
 					break;
 				case 'v':
-					*o++ = '\v';
+					substituted.push_back('\v');
+					break;
+				case '\\':
+					substituted.push_back('\\');
 					break;
 				default:
-					*o++ = '\\';
+					substituted.push_back('\\');
 					j--;
 				}
 			}
 		} else {
-			*o++ = text[j];
+			substituted.push_back(text[j]);
 		}
 	}
-	*o = '\0';
-	*length = lenResult;
-	return substituted;
+	*length = substituted.length();
+	return substituted.c_str();
 }
 
 #ifndef SCI_OWNREGEX
 
-RegexSearchBase *CreateRegexSearch(CharClassify *charClassTable) {
+RegexSearchBase *Scintilla::CreateRegexSearch(CharClassify *charClassTable) {
 	return new BuiltinRegex(charClassTable);
 }
 
diff --git a/Pythonwin/Scintilla/src/Document.h b/Pythonwin/Scintilla/src/Document.h
index 0457b475b..ce0178695 100644
--- a/Pythonwin/Scintilla/src/Document.h
+++ b/Pythonwin/Scintilla/src/Document.h
@@ -2,22 +2,23 @@
 /** @file Document.h
  ** Text document that handles notifications, DBCS, styling, words and end of line.
  **/
-// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
 #ifndef DOCUMENT_H
 #define DOCUMENT_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
 
-/**
- * A Position is a position within a document between two characters or at the beginning or end.
- * Sometimes used as a character index where it identifies the character after the position.
- */
-typedef int Position;
-const Position invalidPosition = -1;
+class DocWatcher;
+class DocModification;
+class Document;
+class LineMarkers;
+class LineLevels;
+class LineState;
+class LineAnnotation;
+
+enum class EncodingFamily { eightBit, unicode, dbcs };
 
 /**
  * The range class represents a range of text in a document.
@@ -27,22 +28,34 @@ const Position invalidPosition = -1;
  */
 class Range {
 public:
-	Position start;
-	Position end;
+	Sci::Position start;
+	Sci::Position end;
 
-	Range(Position pos=0) :
+	explicit Range(Sci::Position pos=0) noexcept :
 		start(pos), end(pos) {
-	};
-	Range(Position start_, Position end_) :
+	}
+	Range(Sci::Position start_, Sci::Position end_) noexcept :
 		start(start_), end(end_) {
-	};
+	}
+
+	bool operator==(const Range &other) const noexcept {
+		return (start == other.start) && (end == other.end);
+	}
+
+	bool Valid() const noexcept {
+		return (start != Sci::invalidPosition) && (end != Sci::invalidPosition);
+	}
 
-	bool Valid() const {
-		return (start != invalidPosition) && (end != invalidPosition);
+	Sci::Position First() const noexcept {
+		return (start <= end) ? start : end;
+	}
+
+	Sci::Position Last() const noexcept {
+		return (start > end) ? start : end;
 	}
 
 	// Is the position within the range?
-	bool Contains(Position pos) const {
+	bool Contains(Sci::Position pos) const noexcept {
 		if (start < end) {
 			return (pos >= start && pos <= end);
 		} else {
@@ -51,7 +64,7 @@ class Range {
 	}
 
 	// Is the character after pos within the range?
-	bool ContainsCharacter(Position pos) const {
+	bool ContainsCharacter(Sci::Position pos) const noexcept {
 		if (start < end) {
 			return (pos >= start && pos < end);
 		} else {
@@ -59,11 +72,11 @@ class Range {
 		}
 	}
 
-	bool Contains(Range other) const {
+	bool Contains(Range other) const noexcept {
 		return Contains(other.start) && Contains(other.end);
 	}
 
-	bool Overlaps(Range other) const {
+	bool Overlaps(Range other) const noexcept {
 		return
 		Contains(other.start) ||
 		Contains(other.end) ||
@@ -72,207 +85,456 @@ class Range {
 	}
 };
 
-class DocWatcher;
-class DocModification;
-class Document;
-
 /**
  * Interface class for regular expression searching
  */
 class RegexSearchBase {
 public:
-	virtual ~RegexSearchBase(){}
+	virtual ~RegexSearchBase() {}
 
-	virtual long FindText(Document* doc, int minPos, int maxPos, const char *s,
-                        bool caseSensitive, bool word, bool wordStart, int flags, int *length) = 0;
+	virtual Sci::Position FindText(Document *doc, Sci::Position minPos, Sci::Position maxPos, const char *s,
+                        bool caseSensitive, bool word, bool wordStart, int flags, Sci::Position *length) = 0;
 
 	///@return String with the substitutions, must remain valid until the next call or destruction
-	virtual const char *SubstituteByPosition(Document* doc, const char *text, int *length) = 0;
+	virtual const char *SubstituteByPosition(Document *doc, const char *text, Sci::Position *length) = 0;
 };
 
 /// Factory function for RegexSearchBase
-extern RegexSearchBase* CreateRegexSearch(CharClassify *charClassTable);
+extern RegexSearchBase *CreateRegexSearch(CharClassify *charClassTable);
+
+struct StyledText {
+	size_t length;
+	const char *text;
+	bool multipleStyles;
+	size_t style;
+	const unsigned char *styles;
+	StyledText(size_t length_, const char *text_, bool multipleStyles_, int style_, const unsigned char *styles_) noexcept :
+		length(length_), text(text_), multipleStyles(multipleStyles_), style(style_), styles(styles_) {
+	}
+	// Return number of bytes from start to before '\n' or end of text.
+	// Return 1 when start is outside text
+	size_t LineLength(size_t start) const noexcept {
+		size_t cur = start;
+		while ((cur < length) && (text[cur] != '\n'))
+			cur++;
+		return cur-start;
+	}
+	size_t StyleAt(size_t i) const noexcept {
+		return multipleStyles ? styles[i] : style;
+	}
+};
+
+class HighlightDelimiter {
+public:
+	HighlightDelimiter() noexcept : isEnabled(false) {
+		Clear();
+	}
+
+	void Clear() noexcept {
+		beginFoldBlock = -1;
+		endFoldBlock = -1;
+		firstChangeableLineBefore = -1;
+		firstChangeableLineAfter = -1;
+	}
+
+	bool NeedsDrawing(Sci::Line line) const noexcept {
+		return isEnabled && (line <= firstChangeableLineBefore || line >= firstChangeableLineAfter);
+	}
+
+	bool IsFoldBlockHighlighted(Sci::Line line) const noexcept {
+		return isEnabled && beginFoldBlock != -1 && beginFoldBlock <= line && line <= endFoldBlock;
+	}
+
+	bool IsHeadOfFoldBlock(Sci::Line line) const noexcept {
+		return beginFoldBlock == line && line < endFoldBlock;
+	}
+
+	bool IsBodyOfFoldBlock(Sci::Line line) const noexcept {
+		return beginFoldBlock != -1 && beginFoldBlock < line && line < endFoldBlock;
+	}
+
+	bool IsTailOfFoldBlock(Sci::Line line) const noexcept {
+		return beginFoldBlock != -1 && beginFoldBlock < line && line == endFoldBlock;
+	}
+
+	Sci::Line beginFoldBlock;	// Begin of current fold block
+	Sci::Line endFoldBlock;	// End of current fold block
+	Sci::Line firstChangeableLineBefore;	// First line that triggers repaint before starting line that determined current fold block
+	Sci::Line firstChangeableLineAfter;	// First line that triggers repaint after starting line that determined current fold block
+	bool isEnabled;
+};
+
+constexpr int LevelNumber(int level) noexcept {
+	return level & SC_FOLDLEVELNUMBERMASK;
+}
+
+class LexInterface {
+protected:
+	Document *pdoc;
+	ILexer5 *instance;
+	bool performingStyle;	///< Prevent reentrance
+public:
+	explicit LexInterface(Document *pdoc_) noexcept : pdoc(pdoc_), instance(nullptr), performingStyle(false) {
+	}
+	virtual ~LexInterface() {
+	}
+	void Colourise(Sci::Position start, Sci::Position end);
+	virtual int LineEndTypesSupported();
+	bool UseContainerLexing() const noexcept {
+		return instance == nullptr;
+	}
+};
+
+struct RegexError : public std::runtime_error {
+	RegexError() : std::runtime_error("regex failure") {}
+};
+
+/**
+ * The ActionDuration class stores the average time taken for some action such as styling or
+ * wrapping a line. It is used to decide how many repetitions of that action can be performed
+ * on idle to maximize efficiency without affecting application responsiveness.
+ * The duration changes if the time for the action changes. For example, if a simple lexer is
+ * changed to a complex lexer. Changes are damped and clamped to avoid short periods of easy
+ * or difficult processing moving the value too far leading to inefficiency or poor user
+ * experience.
+ */
+
+class ActionDuration {
+	double duration;
+	const double minDuration;
+	const double maxDuration;
+public:
+	ActionDuration(double duration_, double minDuration_, double maxDuration_) noexcept;
+	void AddSample(size_t numberActions, double durationOfActions) noexcept;
+	double Duration() const noexcept;
+};
 
 /**
  */
-class Document {
+class Document : PerLine, public IDocument, public ILoader {
 
 public:
 	/** Used to pair watcher pointer with user data. */
-	class WatcherWithUserData {
-	public:
+	struct WatcherWithUserData {
 		DocWatcher *watcher;
 		void *userData;
-		WatcherWithUserData() {
-			watcher = 0;
-			userData = 0;
+		WatcherWithUserData(DocWatcher *watcher_=nullptr, void *userData_=nullptr) noexcept :
+			watcher(watcher_), userData(userData_) {
+		}
+		bool operator==(const WatcherWithUserData &other) const noexcept {
+			return (watcher == other.watcher) && (userData == other.userData);
 		}
 	};
 
-	enum charClassification { ccSpace, ccNewLine, ccWord, ccPunctuation };
-
 private:
 	int refCount;
 	CellBuffer cb;
 	CharClassify charClass;
-	char stylingMask;
-	int endStyled;
+	CharacterCategoryMap charMap;
+	std::unique_ptr<CaseFolder> pcf;
+	Sci::Position endStyled;
 	int styleClock;
 	int enteredModification;
 	int enteredStyling;
 	int enteredReadOnlyCount;
 
-	WatcherWithUserData *watchers;
-	int lenWatchers;
+	bool insertionSet;
+	std::string insertion;
+
+	std::vector<WatcherWithUserData> watchers;
+
+	// ldSize is not real data - it is for dimensions and loops
+	enum lineData { ldMarkers, ldLevels, ldState, ldMargin, ldAnnotation, ldEOLAnnotation, ldSize };
+	std::unique_ptr<PerLine> perLineData[ldSize];
+	LineMarkers *Markers() const noexcept;
+	LineLevels *Levels() const noexcept;
+	LineState *States() const noexcept;
+	LineAnnotation *Margins() const noexcept;
+	LineAnnotation *Annotations() const noexcept;
+	LineAnnotation *EOLAnnotations() const noexcept;
 
 	bool matchesValid;
-	RegexSearchBase* regex;
+	std::unique_ptr<RegexSearchBase> regex;
+	std::unique_ptr<LexInterface> pli;
 
 public:
-	int stylingBits;
-	int stylingBitsMask;
+
+	struct CharacterExtracted {
+		unsigned int character;
+		unsigned int widthBytes;
+		CharacterExtracted(unsigned int character_, unsigned int widthBytes_) noexcept :
+			character(character_), widthBytes(widthBytes_) {
+		}
+		// For DBCS characters turn 2 bytes into an int
+		static CharacterExtracted DBCS(unsigned char lead, unsigned char trail) noexcept {
+			return CharacterExtracted((lead << 8) | trail, 2);
+		}
+	};
 
 	int eolMode;
 	/// Can also be SC_CP_UTF8 to enable UTF-8 mode
 	int dbcsCodePage;
+	int lineEndBitSet;
 	int tabInChars;
 	int indentInChars;
 	int actualIndentInChars;
 	bool useTabs;
 	bool tabIndents;
 	bool backspaceUnindents;
+	ActionDuration durationStyleOneLine;
 
-	DecorationList decorations;
+	std::unique_ptr<IDecorationList> decorations;
 
-	Document();
-	virtual ~Document();
+	Document(int options);
+	// Deleted so Document objects can not be copied.
+	Document(const Document &) = delete;
+	Document(Document &&) = delete;
+	void operator=(const Document &) = delete;
+	Document &operator=(Document &&) = delete;
+	~Document() override;
 
 	int AddRef();
-	int Release();
+	int SCI_METHOD Release() override;
+
+	// From PerLine
+	void Init() override;
+	void InsertLine(Sci::Line line) override;
+	void InsertLines(Sci::Line line, Sci::Line lines) override;
+	void RemoveLine(Sci::Line line) override;
+
+	int LineEndTypesSupported() const;
+	bool SetDBCSCodePage(int dbcsCodePage_);
+	int GetLineEndTypesAllowed() const noexcept { return cb.GetLineEndTypes(); }
+	bool SetLineEndTypesAllowed(int lineEndBitSet_);
+	int GetLineEndTypesActive() const noexcept { return cb.GetLineEndTypes(); }
+
+	int SCI_METHOD Version() const override {
+		return dvRelease4;
+	}
 
-	int LineFromPosition(int pos);
-	int ClampPositionIntoDocument(int pos);
-	bool IsCrLf(int pos);
-	int LenChar(int pos);
-	bool InGoodUTF8(int pos, int &start, int &end);
-	int MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd=true);
+	void SCI_METHOD SetErrorStatus(int status) override;
+
+	Sci_Position SCI_METHOD LineFromPosition(Sci_Position pos) const override;
+	Sci::Line SciLineFromPosition(Sci::Position pos) const noexcept;	// Avoids casting LineFromPosition
+	Sci::Position ClampPositionIntoDocument(Sci::Position pos) const noexcept;
+	bool ContainsLineEnd(const char *s, Sci::Position length) const noexcept { return cb.ContainsLineEnd(s, length); }
+	bool IsCrLf(Sci::Position pos) const noexcept;
+	int LenChar(Sci::Position pos) const noexcept;
+	bool InGoodUTF8(Sci::Position pos, Sci::Position &start, Sci::Position &end) const noexcept;
+	Sci::Position MovePositionOutsideChar(Sci::Position pos, Sci::Position moveDir, bool checkLineEnd=true) const noexcept;
+	Sci::Position NextPosition(Sci::Position pos, int moveDir) const noexcept;
+	bool NextCharacter(Sci::Position &pos, int moveDir) const noexcept;	// Returns true if pos changed
+	Document::CharacterExtracted CharacterAfter(Sci::Position position) const noexcept;
+	Document::CharacterExtracted CharacterBefore(Sci::Position position) const noexcept;
+	Sci_Position SCI_METHOD GetRelativePosition(Sci_Position positionStart, Sci_Position characterOffset) const override;
+	Sci::Position GetRelativePositionUTF16(Sci::Position positionStart, Sci::Position characterOffset) const noexcept;
+	int SCI_METHOD GetCharacterAndWidth(Sci_Position position, Sci_Position *pWidth) const override;
+	int SCI_METHOD CodePage() const override;
+	bool SCI_METHOD IsDBCSLeadByte(char ch) const override;
+	bool IsDBCSLeadByteNoExcept(char ch) const noexcept;
+	bool IsDBCSLeadByteInvalid(char ch) const noexcept;
+	bool IsDBCSTrailByteInvalid(char ch) const noexcept;
+	int DBCSDrawBytes(std::string_view text) const noexcept;
+	int SafeSegment(const char *text, int length, int lengthSegment) const noexcept;
+	EncodingFamily CodePageFamily() const noexcept;
 
 	// Gateways to modifying document
-	void ModifiedAt(int pos);
+	void ModifiedAt(Sci::Position pos) noexcept;
 	void CheckReadOnly();
-	bool DeleteChars(int pos, int len);
-	bool InsertString(int position, const char *s, int insertLength);
-	int Undo();
-	int Redo();
-	bool CanUndo() { return cb.CanUndo(); }
-	bool CanRedo() { return cb.CanRedo(); }
+	bool DeleteChars(Sci::Position pos, Sci::Position len);
+	Sci::Position InsertString(Sci::Position position, const char *s, Sci::Position insertLength);
+	void ChangeInsertion(const char *s, Sci::Position length);
+	int SCI_METHOD AddData(const char *data, Sci_Position length) override;
+	void * SCI_METHOD ConvertToDocument() override;
+	Sci::Position Undo();
+	Sci::Position Redo();
+	bool CanUndo() const noexcept { return cb.CanUndo(); }
+	bool CanRedo() const noexcept { return cb.CanRedo(); }
 	void DeleteUndoHistory() { cb.DeleteUndoHistory(); }
 	bool SetUndoCollection(bool collectUndo) {
 		return cb.SetUndoCollection(collectUndo);
 	}
-	bool IsCollectingUndo() { return cb.IsCollectingUndo(); }
+	bool IsCollectingUndo() const noexcept { return cb.IsCollectingUndo(); }
 	void BeginUndoAction() { cb.BeginUndoAction(); }
 	void EndUndoAction() { cb.EndUndoAction(); }
+	void AddUndoAction(Sci::Position token, bool mayCoalesce) { cb.AddUndoAction(token, mayCoalesce); }
 	void SetSavePoint();
-	bool IsSavePoint() { return cb.IsSavePoint(); }
-	const char *BufferPointer() { return cb.BufferPointer(); }
-
-	int GetLineIndentation(int line);
-	void SetLineIndentation(int line, int indent);
-	int GetLineIndentPosition(int line) const;
-	int GetColumn(int position);
-	int FindColumn(int line, int column);
-	void Indent(bool forwards, int lineBottom, int lineTop);
-	static char *TransformLineEnds(int *pLenOut, const char *s, size_t len, int eolMode);
+	bool IsSavePoint() const noexcept { return cb.IsSavePoint(); }
+
+	void TentativeStart() { cb.TentativeStart(); }
+	void TentativeCommit() { cb.TentativeCommit(); }
+	void TentativeUndo();
+	bool TentativeActive() const noexcept { return cb.TentativeActive(); }
+
+	const char * SCI_METHOD BufferPointer() override { return cb.BufferPointer(); }
+	const char *RangePointer(Sci::Position position, Sci::Position rangeLength) noexcept { return cb.RangePointer(position, rangeLength); }
+	Sci::Position GapPosition() const noexcept { return cb.GapPosition(); }
+
+	int SCI_METHOD GetLineIndentation(Sci_Position line) override;
+	Sci::Position SetLineIndentation(Sci::Line line, Sci::Position indent);
+	Sci::Position GetLineIndentPosition(Sci::Line line) const;
+	Sci::Position GetColumn(Sci::Position pos);
+	Sci::Position CountCharacters(Sci::Position startPos, Sci::Position endPos) const noexcept;
+	Sci::Position CountUTF16(Sci::Position startPos, Sci::Position endPos) const noexcept;
+	Sci::Position FindColumn(Sci::Line line, Sci::Position column);
+	void Indent(bool forwards, Sci::Line lineBottom, Sci::Line lineTop);
+	static std::string TransformLineEnds(const char *s, size_t len, int eolModeWanted);
 	void ConvertLineEnds(int eolModeSet);
 	void SetReadOnly(bool set) { cb.SetReadOnly(set); }
-	bool IsReadOnly() { return cb.IsReadOnly(); }
+	bool IsReadOnly() const noexcept { return cb.IsReadOnly(); }
+	bool IsLarge() const noexcept { return cb.IsLarge(); }
+	int Options() const noexcept;
 
-	bool InsertChar(int pos, char ch);
-	bool InsertCString(int position, const char *s);
-	void ChangeChar(int pos, char ch);
-	void DelChar(int pos);
-	void DelCharBack(int pos);
+	void DelChar(Sci::Position pos);
+	void DelCharBack(Sci::Position pos);
 
-	char CharAt(int position) { return cb.CharAt(position); }
-	void GetCharRange(char *buffer, int position, int lengthRetrieve) {
+	char CharAt(Sci::Position position) const noexcept { return cb.CharAt(position); }
+	void SCI_METHOD GetCharRange(char *buffer, Sci_Position position, Sci_Position lengthRetrieve) const override {
 		cb.GetCharRange(buffer, position, lengthRetrieve);
 	}
-	char StyleAt(int position) { return cb.StyleAt(position); }
-	int GetMark(int line) { return cb.GetMark(line); }
-	int AddMark(int line, int markerNum);
-	void AddMarkSet(int line, int valueSet);
-	void DeleteMark(int line, int markerNum);
+	char SCI_METHOD StyleAt(Sci_Position position) const override { return cb.StyleAt(position); }
+	int StyleIndexAt(Sci_Position position) const noexcept { return static_cast<unsigned char>(cb.StyleAt(position)); }
+	void GetStyleRange(unsigned char *buffer, Sci::Position position, Sci::Position lengthRetrieve) const {
+		cb.GetStyleRange(buffer, position, lengthRetrieve);
+	}
+	int GetMark(Sci::Line line) const noexcept;
+	Sci::Line MarkerNext(Sci::Line lineStart, int mask) const noexcept;
+	int AddMark(Sci::Line line, int markerNum);
+	void AddMarkSet(Sci::Line line, int valueSet);
+	void DeleteMark(Sci::Line line, int markerNum);
 	void DeleteMarkFromHandle(int markerHandle);
 	void DeleteAllMarks(int markerNum);
-	int LineFromHandle(int markerHandle) { return cb.LineFromHandle(markerHandle); }
-	int LineStart(int line) const;
-	int LineEnd(int line) const;
-	int LineEndPosition(int position);
-	int VCHomePosition(int position);
-
-	int SetLevel(int line, int level);
-	int GetLevel(int line) { return cb.GetLevel(line); }
-	void ClearLevels() { cb.ClearLevels(); }
-	int GetLastChild(int lineParent, int level=-1);
-	int GetFoldParent(int line);
-
-	void Indent(bool forwards);
-	int ExtendWordSelect(int pos, int delta, bool onlyWordCharacters=false);
-	int NextWordStart(int pos, int delta);
-	int NextWordEnd(int pos, int delta);
-	int Length() const { return cb.Length(); }
-	void Allocate(int newSize) { cb.Allocate(newSize); }
-	long FindText(int minPos, int maxPos, const char *s,
-		bool caseSensitive, bool word, bool wordStart, bool regExp, int flags, int *length);
-	long FindText(int iMessage, unsigned long wParam, long lParam);
-	const char *SubstituteByPosition(const char *text, int *length);
-	int LinesTotal() const;
-
-	void ChangeCase(Range r, bool makeUpperCase);
+	Sci::Line LineFromHandle(int markerHandle) const noexcept;
+	int MarkerNumberFromLine(Sci::Line line, int which) const noexcept;
+	int MarkerHandleFromLine(Sci::Line line, int which) const noexcept;
+	Sci_Position SCI_METHOD LineStart(Sci_Position line) const override;
+	bool IsLineStartPosition(Sci::Position position) const;
+	Sci_Position SCI_METHOD LineEnd(Sci_Position line) const override;
+	Sci::Position LineEndPosition(Sci::Position position) const;
+	bool IsLineEndPosition(Sci::Position position) const;
+	bool IsPositionInLineEnd(Sci::Position position) const;
+	Sci::Position VCHomePosition(Sci::Position position) const;
+	Sci::Position IndexLineStart(Sci::Line line, int lineCharacterIndex) const noexcept;
+	Sci::Line LineFromPositionIndex(Sci::Position pos, int lineCharacterIndex) const noexcept;
+
+	int SCI_METHOD SetLevel(Sci_Position line, int level) override;
+	int SCI_METHOD GetLevel(Sci_Position line) const override;
+	void ClearLevels();
+	Sci::Line GetLastChild(Sci::Line lineParent, int level=-1, Sci::Line lastLine=-1);
+	Sci::Line GetFoldParent(Sci::Line line) const;
+	void GetHighlightDelimiters(HighlightDelimiter &highlightDelimiter, Sci::Line line, Sci::Line lastLine);
+
+	Sci::Position ExtendWordSelect(Sci::Position pos, int delta, bool onlyWordCharacters=false) const;
+	Sci::Position NextWordStart(Sci::Position pos, int delta) const;
+	Sci::Position NextWordEnd(Sci::Position pos, int delta) const;
+	Sci_Position SCI_METHOD Length() const override { return cb.Length(); }
+	Sci::Position LengthNoExcept() const noexcept { return cb.Length(); }
+	void Allocate(Sci::Position newSize) { cb.Allocate(newSize); }
+
+	CharacterExtracted ExtractCharacter(Sci::Position position) const noexcept;
+
+	bool IsWordStartAt(Sci::Position pos) const;
+	bool IsWordEndAt(Sci::Position pos) const;
+	bool IsWordAt(Sci::Position start, Sci::Position end) const;
+
+	bool MatchesWordOptions(bool word, bool wordStart, Sci::Position pos, Sci::Position length) const;
+	bool HasCaseFolder() const noexcept;
+	void SetCaseFolder(CaseFolder *pcf_) noexcept;
+	Sci::Position FindText(Sci::Position minPos, Sci::Position maxPos, const char *search, int flags, Sci::Position *length);
+	const char *SubstituteByPosition(const char *text, Sci::Position *length);
+	int LineCharacterIndex() const noexcept;
+	void AllocateLineCharacterIndex(int lineCharacterIndex);
+	void ReleaseLineCharacterIndex(int lineCharacterIndex);
+	Sci::Line LinesTotal() const noexcept;
 
 	void SetDefaultCharClasses(bool includeWordClass);
 	void SetCharClasses(const unsigned char *chars, CharClassify::cc newCharClass);
-	void SetStylingBits(int bits);
-	void StartStyling(int position, char mask);
-	bool SetStyleFor(int length, char style);
-	bool SetStyles(int length, char *styles);
-	int GetEndStyled() { return endStyled; }
-	void EnsureStyledTo(int pos);
-	int GetStyleClock() { return styleClock; }
-	void IncrementStyleClock();
-	void DecorationFillRange(int position, int value, int fillLength);
-
-	int SetLineState(int line, int state);
-	int GetLineState(int line) { return cb.GetLineState(line); }
-	int GetMaxLineState() { return cb.GetMaxLineState(); }
+	int GetCharsOfClass(CharClassify::cc characterClass, unsigned char *buffer) const;
+	void SetCharacterCategoryOptimization(int countCharacters);
+	int CharacterCategoryOptimization() const noexcept;
+	void SCI_METHOD StartStyling(Sci_Position position) override;
+	bool SCI_METHOD SetStyleFor(Sci_Position length, char style) override;
+	bool SCI_METHOD SetStyles(Sci_Position length, const char *styles) override;
+	Sci::Position GetEndStyled() const noexcept { return endStyled; }
+	void EnsureStyledTo(Sci::Position pos);
+	void StyleToAdjustingLineDuration(Sci::Position pos);
+	void LexerChanged();
+	int GetStyleClock() const noexcept { return styleClock; }
+	void IncrementStyleClock() noexcept;
+	void SCI_METHOD DecorationSetCurrentIndicator(int indicator) override;
+	void SCI_METHOD DecorationFillRange(Sci_Position position, int value, Sci_Position fillLength) override;
+	LexInterface *GetLexInterface() const noexcept;
+	void SetLexInterface(std::unique_ptr<LexInterface> pLexInterface) noexcept;
+
+	int SCI_METHOD SetLineState(Sci_Position line, int state) override;
+	int SCI_METHOD GetLineState(Sci_Position line) const override;
+	Sci::Line GetMaxLineState() const noexcept;
+	void SCI_METHOD ChangeLexerState(Sci_Position start, Sci_Position end) override;
+
+	StyledText MarginStyledText(Sci::Line line) const noexcept;
+	void MarginSetStyle(Sci::Line line, int style);
+	void MarginSetStyles(Sci::Line line, const unsigned char *styles);
+	void MarginSetText(Sci::Line line, const char *text);
+	void MarginClearAll();
+
+	StyledText AnnotationStyledText(Sci::Line line) const noexcept;
+	void AnnotationSetText(Sci::Line line, const char *text);
+	void AnnotationSetStyle(Sci::Line line, int style);
+	void AnnotationSetStyles(Sci::Line line, const unsigned char *styles);
+	int AnnotationLines(Sci::Line line) const noexcept;
+	void AnnotationClearAll();
+
+	StyledText EOLAnnotationStyledText(Sci::Line line) const noexcept;
+	void EOLAnnotationSetStyle(Sci::Line line, int style);
+	void EOLAnnotationSetText(Sci::Line line, const char *text);
+	void EOLAnnotationClearAll();
 
 	bool AddWatcher(DocWatcher *watcher, void *userData);
 	bool RemoveWatcher(DocWatcher *watcher, void *userData);
-	const WatcherWithUserData *GetWatchers() const { return watchers; }
-	int GetLenWatchers() const { return lenWatchers; }
-
-	bool IsWordPartSeparator(char ch);
-	int WordPartLeft(int pos);
-	int WordPartRight(int pos);
-	int ExtendStyleRange(int pos, int delta, bool singleLine = false);
-	bool IsWhiteLine(int line) const;
-	int ParaUp(int pos);
-	int ParaDown(int pos);
-	int IndentSize() { return actualIndentInChars; }
-	int BraceMatch(int position, int maxReStyle);
 
-private:
-	CharClassify::cc WordCharClass(unsigned char ch);
-	bool IsWordStartAt(int pos);
-	bool IsWordEndAt(int pos);
-	bool IsWordAt(int start, int end);
+	CharClassify::cc WordCharacterClass(unsigned int ch) const;
+	bool IsWordPartSeparator(unsigned int ch) const;
+	Sci::Position WordPartLeft(Sci::Position pos) const;
+	Sci::Position WordPartRight(Sci::Position pos) const;
+	Sci::Position ExtendStyleRange(Sci::Position pos, int delta, bool singleLine) noexcept;
+	bool IsWhiteLine(Sci::Line line) const;
+	Sci::Position ParaUp(Sci::Position pos) const;
+	Sci::Position ParaDown(Sci::Position pos) const;
+	int IndentSize() const noexcept { return actualIndentInChars; }
+	Sci::Position BraceMatch(Sci::Position position, Sci::Position maxReStyle, Sci::Position startPos, bool useStartPos) noexcept;
 
+private:
 	void NotifyModifyAttempt();
 	void NotifySavePoint(bool atSavePoint);
 	void NotifyModified(DocModification mh);
 };
 
+class UndoGroup {
+	Document *pdoc;
+	bool groupNeeded;
+public:
+	UndoGroup(Document *pdoc_, bool groupNeeded_=true) :
+		pdoc(pdoc_), groupNeeded(groupNeeded_) {
+		if (groupNeeded) {
+			pdoc->BeginUndoAction();
+		}
+	}
+	// Deleted so UndoGroup objects can not be copied.
+	UndoGroup(const UndoGroup &) = delete;
+	UndoGroup(UndoGroup &&) = delete;
+	void operator=(const UndoGroup &) = delete;
+	UndoGroup &operator=(UndoGroup &&) = delete;
+	~UndoGroup() {
+		if (groupNeeded) {
+			pdoc->EndUndoAction();
+		}
+	}
+	bool Needed() const noexcept {
+		return groupNeeded;
+	}
+};
+
+
 /**
  * To optimise processing of document modifications by DocWatchers, a hint is passed indicating the
  * scope of the change.
@@ -280,17 +542,19 @@ class Document {
  */
 class DocModification {
 public:
-  	int modificationType;
-	int position;
- 	int length;
- 	int linesAdded;	/**< Negative if lines deleted. */
- 	const char *text;	/**< Only valid for changes to text, not for changes to style. */
- 	int line;
+	int modificationType;
+	Sci::Position position;
+	Sci::Position length;
+	Sci::Line linesAdded;	/**< Negative if lines deleted. */
+	const char *text;	/**< Only valid for changes to text, not for changes to style. */
+	Sci::Line line;
 	int foldLevelNow;
 	int foldLevelPrev;
+	Sci::Line annotationLinesAdded;
+	Sci::Position token;
 
-	DocModification(int modificationType_, int position_=0, int length_=0,
-		int linesAdded_=0, const char *text_=0, int line_=0) :
+	DocModification(int modificationType_, Sci::Position position_=0, Sci::Position length_=0,
+		Sci::Line linesAdded_=0, const char *text_=nullptr, Sci::Line line_=0) noexcept :
 		modificationType(modificationType_),
 		position(position_),
 		length(length_),
@@ -298,17 +562,21 @@ class DocModification {
 		text(text_),
 		line(line_),
 		foldLevelNow(0),
-		foldLevelPrev(0) {}
+		foldLevelPrev(0),
+		annotationLinesAdded(0),
+		token(0) {}
 
-	DocModification(int modificationType_, const Action &act, int linesAdded_=0) :
+	DocModification(int modificationType_, const Action &act, Sci::Line linesAdded_=0) noexcept :
 		modificationType(modificationType_),
 		position(act.position),
 		length(act.lenData),
 		linesAdded(linesAdded_),
-		text(act.data),
+		text(act.data.get()),
 		line(0),
 		foldLevelNow(0),
-		foldLevelPrev(0) {}
+		foldLevelPrev(0),
+		annotationLinesAdded(0),
+		token(0) {}
 };
 
 /**
@@ -322,12 +590,12 @@ class DocWatcher {
 	virtual void NotifyModifyAttempt(Document *doc, void *userData) = 0;
 	virtual void NotifySavePoint(Document *doc, void *userData, bool atSavePoint) = 0;
 	virtual void NotifyModified(Document *doc, DocModification mh, void *userData) = 0;
-	virtual void NotifyDeleted(Document *doc, void *userData) = 0;
-	virtual void NotifyStyleNeeded(Document *doc, void *userData, int endPos) = 0;
+	virtual void NotifyDeleted(Document *doc, void *userData) noexcept = 0;
+	virtual void NotifyStyleNeeded(Document *doc, void *userData, Sci::Position endPos) = 0;
+	virtual void NotifyLexerChanged(Document *doc, void *userData) = 0;
+	virtual void NotifyErrorOccurred(Document *doc, void *userData, int status) = 0;
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/DocumentAccessor.cxx b/Pythonwin/Scintilla/src/DocumentAccessor.cxx
deleted file mode 100644
index a25979dc2..000000000
--- a/Pythonwin/Scintilla/src/DocumentAccessor.cxx
+++ /dev/null
@@ -1,199 +0,0 @@
-// Scintilla source code edit control
-/** @file DocumentAccessor.cxx
- ** Rapid easy access to contents of a Scintilla.
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "DocumentAccessor.h"
-#include "SplitVector.h"
-#include "Partitioning.h"
-#include "RunStyles.h"
-#include "CellBuffer.h"
-#include "Scintilla.h"
-#include "CharClassify.h"
-#include "Decoration.h"
-#include "Document.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-DocumentAccessor::~DocumentAccessor() {
-}
-
-bool DocumentAccessor::InternalIsLeadByte(char ch) {
-	if (SC_CP_UTF8 == codePage)
-		// For lexing, all characters >= 0x80 are treated the
-		// same so none is considered a lead byte.
-		return false;
-	else
-		return Platform::IsDBCSLeadByte(codePage, ch);
-}
-
-void DocumentAccessor::Fill(int position) {
-	if (lenDoc == -1)
-		lenDoc = pdoc->Length();
-	startPos = position - slopSize;
-	if (startPos + bufferSize > lenDoc)
-		startPos = lenDoc - bufferSize;
-	if (startPos < 0)
-		startPos = 0;
-	endPos = startPos + bufferSize;
-	if (endPos > lenDoc)
-		endPos = lenDoc;
-
-	pdoc->GetCharRange(buf, startPos, endPos-startPos);
-	buf[endPos-startPos] = '\0';
-}
-
-bool DocumentAccessor::Match(int pos, const char *s) {
-	for (int i=0; *s; i++) {
-		if (*s != SafeGetCharAt(pos+i))
-			return false;
-		s++;
-	}
-	return true;
-}
-
-char DocumentAccessor::StyleAt(int position) {
-	// Mask off all bits which aren't in the 'mask'.
-	return static_cast<char>(pdoc->StyleAt(position) & mask);
-}
-
-int DocumentAccessor::GetLine(int position) {
-	return pdoc->LineFromPosition(position);
-}
-
-int DocumentAccessor::LineStart(int line) {
-	return pdoc->LineStart(line);
-}
-
-int DocumentAccessor::LevelAt(int line) {
-	return pdoc->GetLevel(line);
-}
-
-int DocumentAccessor::Length() {
-	if (lenDoc == -1)
-		lenDoc = pdoc->Length();
-	return lenDoc;
-}
-
-int DocumentAccessor::GetLineState(int line) {
-	return pdoc->GetLineState(line);
-}
-
-int DocumentAccessor::SetLineState(int line, int state) {
-	return pdoc->SetLineState(line, state);
-}
-
-void DocumentAccessor::StartAt(unsigned int start, char chMask) {
-	// Store the mask specified for use with StyleAt.
-	mask = chMask;
-	pdoc->StartStyling(start, chMask);
-	startPosStyling = start;
-}
-
-void DocumentAccessor::StartSegment(unsigned int pos) {
-	startSeg = pos;
-}
-
-void DocumentAccessor::ColourTo(unsigned int pos, int chAttr) {
-	// Only perform styling if non empty range
-	if (pos != startSeg - 1) {
-		PLATFORM_ASSERT(pos >= startSeg);
-		if (pos < startSeg) {
-			return;
-		}
-
-		if (validLen + (pos - startSeg + 1) >= bufferSize)
-			Flush();
-		if (validLen + (pos - startSeg + 1) >= bufferSize) {
-			// Too big for buffer so send directly
-			pdoc->SetStyleFor(pos - startSeg + 1, static_cast<char>(chAttr));
-		} else {
-			if (chAttr != chWhile)
-				chFlags = 0;
-			chAttr |= chFlags;
-			for (unsigned int i = startSeg; i <= pos; i++) {
-				PLATFORM_ASSERT((startPosStyling + validLen) < Length());
-				styleBuf[validLen++] = static_cast<char>(chAttr);
-			}
-		}
-	}
-	startSeg = pos+1;
-}
-
-void DocumentAccessor::SetLevel(int line, int level) {
-	pdoc->SetLevel(line, level);
-}
-
-void DocumentAccessor::Flush() {
-	startPos = extremePosition;
-	lenDoc = -1;
-	if (validLen > 0) {
-		pdoc->SetStyles(validLen, styleBuf);
-		startPosStyling += validLen;
-		validLen = 0;
-	}
-}
-
-int DocumentAccessor::IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader) {
-	int end = Length();
-	int spaceFlags = 0;
-
-	// Determines the indentation level of the current line and also checks for consistent
-	// indentation compared to the previous line.
-	// Indentation is judged consistent when the indentation whitespace of each line lines
-	// the same or the indentation of one line is a prefix of the other.
-
-	int pos = LineStart(line);
-	char ch = (*this)[pos];
-	int indent = 0;
-	bool inPrevPrefix = line > 0;
-	int posPrev = inPrevPrefix ? LineStart(line-1) : 0;
-	while ((ch == ' ' || ch == '\t') && (pos < end)) {
-		if (inPrevPrefix) {
-			char chPrev = (*this)[posPrev++];
-			if (chPrev == ' ' || chPrev == '\t') {
-				if (chPrev != ch)
-					spaceFlags |= wsInconsistent;
-			} else {
-				inPrevPrefix = false;
-			}
-		}
-		if (ch == ' ') {
-			spaceFlags |= wsSpace;
-			indent++;
-		} else {	// Tab
-			spaceFlags |= wsTab;
-			if (spaceFlags & wsSpace)
-				spaceFlags |= wsSpaceTab;
-			indent = (indent / 8 + 1) * 8;
-		}
-		ch = (*this)[++pos];
-	}
-
-	*flags = spaceFlags;
-	indent += SC_FOLDLEVELBASE;
-	// if completely empty line or the start of a comment...
-	if ((ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r') ||
-		(pfnIsCommentLeader && (*pfnIsCommentLeader)(*this, pos, end-pos)) )
-		return indent | SC_FOLDLEVELWHITEFLAG;
-	else
-		return indent;
-}
-
-void DocumentAccessor::IndicatorFill(int start, int end, int indicator, int value) {
-	pdoc->decorations.SetCurrentIndicator(indicator);
-	pdoc->DecorationFillRange(start, value, end - start);
-}
diff --git a/Pythonwin/Scintilla/src/DocumentAccessor.h b/Pythonwin/Scintilla/src/DocumentAccessor.h
deleted file mode 100644
index a3a939d0d..000000000
--- a/Pythonwin/Scintilla/src/DocumentAccessor.h
+++ /dev/null
@@ -1,76 +0,0 @@
-// Scintilla source code edit control
-/** @file DocumentAccessor.h
- ** Implementation of BufferAccess and StylingAccess on a Scintilla
- ** rapid easy access to contents of a Scintilla.
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#ifdef SCI_NAMESPACE
-namespace Scintilla {
-#endif
-
-class Document;
-
-/**
- */
-class DocumentAccessor : public Accessor {
-	// Private so DocumentAccessor objects can not be copied
-	DocumentAccessor(const DocumentAccessor &source) : Accessor(), props(source.props) {}
-	DocumentAccessor &operator=(const DocumentAccessor &) { return *this; }
-
-protected:
-	Document *pdoc;
-	PropSet &props;
-	WindowID id;
-	int lenDoc;
-
-	char styleBuf[bufferSize];
-	int validLen;
-	char chFlags;
-	char chWhile;
-	unsigned int startSeg;
-	int startPosStyling;
-	int mask;
-
-	bool InternalIsLeadByte(char ch);
-	void Fill(int position);
-
-public:
-	DocumentAccessor(Document *pdoc_, PropSet &props_, WindowID id_=0) : 
-		Accessor(), pdoc(pdoc_), props(props_), id(id_),
-		lenDoc(-1), validLen(0), chFlags(0), chWhile(0), 
-		startSeg(0), startPosStyling(0),
-		mask(127) { // Initialize the mask to be big enough for any lexer.
-	}
-	~DocumentAccessor();
-	bool Match(int pos, const char *s);
-	char StyleAt(int position);
-	int GetLine(int position);
-	int LineStart(int line);
-	int LevelAt(int line);
-	int Length();
-	void Flush();
-	int GetLineState(int line);
-	int SetLineState(int line, int state);
-	int GetPropertyInt(const char *key, int defaultValue=0) { 
-		return props.GetInt(key, defaultValue); 
-	}
-	char *GetProperties() {
-		return props.ToString();
-	}
-	WindowID GetWindow() { return id; }
-
-	void StartAt(unsigned int start, char chMask=31);
-	void SetFlags(char chFlags_, char chWhile_) {chFlags = chFlags_; chWhile = chWhile_; };
-	unsigned int GetStartSegment() { return startSeg; }
-	void StartSegment(unsigned int pos);
-	void ColourTo(unsigned int pos, int chAttr);
-	void SetLevel(int line, int level);
-	int IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader = 0);
-	void IndicatorFill(int start, int end, int indicator, int value);
-};
-
-#ifdef SCI_NAMESPACE
-}
-#endif
diff --git a/Pythonwin/Scintilla/src/EditModel.cxx b/Pythonwin/Scintilla/src/EditModel.cxx
new file mode 100644
index 000000000..3f9874358
--- /dev/null
+++ b/Pythonwin/Scintilla/src/EditModel.cxx
@@ -0,0 +1,107 @@
+// Scintilla source code edit control
+/** @file EditModel.cxx
+ ** Defines the editor state that must be visible to EditorView.
+ **/
+// Copyright 1998-2014 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cmath>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <memory>
+
+#include "Platform.h"
+
+#include "ILoader.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+
+#include "CharacterCategory.h"
+
+#include "Position.h"
+#include "UniqueString.h"
+#include "SplitVector.h"
+#include "Partitioning.h"
+#include "RunStyles.h"
+#include "ContractionState.h"
+#include "CellBuffer.h"
+#include "KeyMap.h"
+#include "Indicator.h"
+#include "LineMarker.h"
+#include "Style.h"
+#include "ViewStyle.h"
+#include "CharClassify.h"
+#include "Decoration.h"
+#include "CaseFolder.h"
+#include "Document.h"
+#include "UniConversion.h"
+#include "Selection.h"
+#include "PositionCache.h"
+#include "EditModel.h"
+
+using namespace Scintilla;
+
+Caret::Caret() noexcept :
+	active(false), on(false), period(500) {}
+
+EditModel::EditModel() : braces{} {
+	inOverstrike = false;
+	xOffset = 0;
+	trackLineWidth = false;
+	posDrag = SelectionPosition(Sci::invalidPosition);
+	braces[0] = Sci::invalidPosition;
+	braces[1] = Sci::invalidPosition;
+	bracesMatchStyle = STYLE_BRACEBAD;
+	highlightGuideColumn = 0;
+	primarySelection = true;
+	imeInteraction = imeWindowed;
+	bidirectional = Bidirectional::bidiDisabled;
+	foldFlags = 0;
+	foldDisplayTextStyle = SC_FOLDDISPLAYTEXT_HIDDEN;
+	hotspot = Range(Sci::invalidPosition);
+	hoverIndicatorPos = Sci::invalidPosition;
+	wrapWidth = LineLayout::wrapWidthInfinite;
+	pdoc = new Document(SC_DOCUMENTOPTION_DEFAULT);
+	pdoc->AddRef();
+	pcs = ContractionStateCreate(pdoc->IsLarge());
+}
+
+EditModel::~EditModel() {
+	pdoc->Release();
+	pdoc = nullptr;
+}
+
+bool EditModel::BidirectionalEnabled() const noexcept {
+	return (bidirectional != Bidirectional::bidiDisabled) &&
+		(SC_CP_UTF8 == pdoc->dbcsCodePage);
+}
+
+bool EditModel::BidirectionalR2L() const noexcept {
+	return bidirectional == Bidirectional::bidiR2L;
+}
+
+void EditModel::SetDefaultFoldDisplayText(const char *text) {
+	defaultFoldDisplayText = IsNullOrEmpty(text) ? UniqueString() : UniqueStringCopy(text);
+}
+
+const char *EditModel::GetDefaultFoldDisplayText() const noexcept {
+	return defaultFoldDisplayText.get();
+}
+
+const char *EditModel::GetFoldDisplayText(Sci::Line lineDoc) const noexcept {
+	if (foldDisplayTextStyle == SC_FOLDDISPLAYTEXT_HIDDEN || pcs->GetExpanded(lineDoc)) {
+		return nullptr;
+	}
+
+	const char *text = pcs->GetFoldDisplayText(lineDoc);
+	return text ? text : defaultFoldDisplayText.get();
+}
diff --git a/Pythonwin/Scintilla/src/EditModel.h b/Pythonwin/Scintilla/src/EditModel.h
new file mode 100644
index 000000000..56d341abb
--- /dev/null
+++ b/Pythonwin/Scintilla/src/EditModel.h
@@ -0,0 +1,76 @@
+// Scintilla source code edit control
+/** @file EditModel.h
+ ** Defines the editor state that must be visible to EditorView.
+ **/
+// Copyright 1998-2014 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef EDITMODEL_H
+#define EDITMODEL_H
+
+namespace Scintilla {
+
+/**
+*/
+class Caret {
+public:
+	bool active;
+	bool on;
+	int period;
+
+	Caret() noexcept;
+};
+
+class EditModel {
+public:
+	bool inOverstrike;
+	int xOffset;		///< Horizontal scrolled amount in pixels
+	bool trackLineWidth;
+
+	SpecialRepresentations reprs;
+	Caret caret;
+	SelectionPosition posDrag;
+	Sci::Position braces[2];
+	int bracesMatchStyle;
+	int highlightGuideColumn;
+	Selection sel;
+	bool primarySelection;
+
+	enum IMEInteraction { imeWindowed, imeInline } imeInteraction;
+	enum class CharacterSource { directInput, tentativeInput, imeResult };
+	enum class Bidirectional { bidiDisabled, bidiL2R, bidiR2L  } bidirectional;
+
+	int foldFlags;
+	int foldDisplayTextStyle;
+	UniqueString defaultFoldDisplayText;
+	std::unique_ptr<IContractionState> pcs;
+	// Hotspot support
+	Range hotspot;
+	Sci::Position hoverIndicatorPos;
+
+	// Wrapping support
+	int wrapWidth;
+
+	Document *pdoc;
+
+	EditModel();
+	// Deleted so EditModel objects can not be copied.
+	EditModel(const EditModel &) = delete;
+	EditModel(EditModel &&) = delete;
+	EditModel &operator=(const EditModel &) = delete;
+	EditModel &operator=(EditModel &&) = delete;
+	virtual ~EditModel();
+	virtual Sci::Line TopLineOfMain() const = 0;
+	virtual Point GetVisibleOriginInMain() const = 0;
+	virtual Sci::Line LinesOnScreen() const = 0;
+	virtual Range GetHotSpotRange() const noexcept = 0;
+	bool BidirectionalEnabled() const noexcept;
+	bool BidirectionalR2L() const noexcept;
+	void SetDefaultFoldDisplayText(const char *text);
+	const char *GetDefaultFoldDisplayText() const noexcept;
+	const char *GetFoldDisplayText(Sci::Line lineDoc) const noexcept;
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/EditView.cxx b/Pythonwin/Scintilla/src/EditView.cxx
new file mode 100644
index 000000000..0bc950d69
--- /dev/null
+++ b/Pythonwin/Scintilla/src/EditView.cxx
@@ -0,0 +1,2627 @@
+// Scintilla source code edit control
+/** @file EditView.cxx
+ ** Defines the appearance of the main text area of the editor window.
+ **/
+// Copyright 1998-2014 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cstdio>
+#include <cmath>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <map>
+#include <forward_list>
+#include <algorithm>
+#include <iterator>
+#include <memory>
+#include <chrono>
+
+#include "Platform.h"
+
+#include "ILoader.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+
+#include "CharacterSet.h"
+#include "CharacterCategory.h"
+#include "Position.h"
+#include "IntegerRectangle.h"
+#include "UniqueString.h"
+#include "SplitVector.h"
+#include "Partitioning.h"
+#include "RunStyles.h"
+#include "ContractionState.h"
+#include "CellBuffer.h"
+#include "PerLine.h"
+#include "KeyMap.h"
+#include "Indicator.h"
+#include "LineMarker.h"
+#include "Style.h"
+#include "ViewStyle.h"
+#include "CharClassify.h"
+#include "Decoration.h"
+#include "CaseFolder.h"
+#include "Document.h"
+#include "UniConversion.h"
+#include "Selection.h"
+#include "PositionCache.h"
+#include "EditModel.h"
+#include "MarginView.h"
+#include "EditView.h"
+#include "ElapsedPeriod.h"
+
+using namespace Scintilla;
+
+PrintParameters::PrintParameters() noexcept {
+	magnification = 0;
+	colourMode = SC_PRINT_NORMAL;
+	wrapState = WrapMode::word;
+}
+
+namespace Scintilla {
+
+bool ValidStyledText(const ViewStyle &vs, size_t styleOffset, const StyledText &st) noexcept {
+	if (st.multipleStyles) {
+		for (size_t iStyle = 0; iStyle<st.length; iStyle++) {
+			if (!vs.ValidStyle(styleOffset + st.styles[iStyle]))
+				return false;
+		}
+	} else {
+		if (!vs.ValidStyle(styleOffset + st.style))
+			return false;
+	}
+	return true;
+}
+
+static int WidthStyledText(Surface *surface, const ViewStyle &vs, int styleOffset,
+	const char *text, const unsigned char *styles, size_t len) {
+	int width = 0;
+	size_t start = 0;
+	while (start < len) {
+		const unsigned char style = styles[start];
+		size_t endSegment = start;
+		while ((endSegment + 1 < len) && (styles[endSegment + 1] == style))
+			endSegment++;
+		FontAlias fontText = vs.styles[style + styleOffset].font;
+		const std::string_view sv(text + start, endSegment - start + 1);
+		width += static_cast<int>(surface->WidthText(fontText, sv));
+		start = endSegment + 1;
+	}
+	return width;
+}
+
+int WidestLineWidth(Surface *surface, const ViewStyle &vs, int styleOffset, const StyledText &st) {
+	int widthMax = 0;
+	size_t start = 0;
+	while (start < st.length) {
+		const size_t lenLine = st.LineLength(start);
+		int widthSubLine;
+		if (st.multipleStyles) {
+			widthSubLine = WidthStyledText(surface, vs, styleOffset, st.text + start, st.styles + start, lenLine);
+		} else {
+			FontAlias fontText = vs.styles[styleOffset + st.style].font;
+			const std::string_view text(st.text + start, lenLine);
+			widthSubLine = static_cast<int>(surface->WidthText(fontText, text));
+		}
+		if (widthSubLine > widthMax)
+			widthMax = widthSubLine;
+		start += lenLine + 1;
+	}
+	return widthMax;
+}
+
+void DrawTextNoClipPhase(Surface *surface, PRectangle rc, const Style &style, XYPOSITION ybase,
+	std::string_view text, DrawPhase phase) {
+	FontAlias fontText = style.font;
+	if (phase & drawBack) {
+		if (phase & drawText) {
+			// Drawing both
+			surface->DrawTextNoClip(rc, fontText, ybase, text,
+				style.fore, style.back);
+		} else {
+			surface->FillRectangle(rc, style.back);
+		}
+	} else if (phase & drawText) {
+		surface->DrawTextTransparent(rc, fontText, ybase, text, style.fore);
+	}
+}
+
+void DrawStyledText(Surface *surface, const ViewStyle &vs, int styleOffset, PRectangle rcText,
+	const StyledText &st, size_t start, size_t length, DrawPhase phase) {
+
+	if (st.multipleStyles) {
+		int x = static_cast<int>(rcText.left);
+		size_t i = 0;
+		while (i < length) {
+			size_t end = i;
+			size_t style = st.styles[i + start];
+			while (end < length - 1 && st.styles[start + end + 1] == style)
+				end++;
+			style += styleOffset;
+			FontAlias fontText = vs.styles[style].font;
+			const std::string_view text(st.text + start + i, end - i + 1);
+			const int width = static_cast<int>(surface->WidthText(fontText, text));
+			PRectangle rcSegment = rcText;
+			rcSegment.left = static_cast<XYPOSITION>(x);
+			rcSegment.right = static_cast<XYPOSITION>(x + width + 1);
+			DrawTextNoClipPhase(surface, rcSegment, vs.styles[style],
+				rcText.top + vs.maxAscent, text, phase);
+			x += width;
+			i = end + 1;
+		}
+	} else {
+		const size_t style = st.style + styleOffset;
+		DrawTextNoClipPhase(surface, rcText, vs.styles[style],
+			rcText.top + vs.maxAscent,
+			std::string_view(st.text + start, length), phase);
+	}
+}
+
+}
+
+EditView::EditView() {
+	tabWidthMinimumPixels = 2; // needed for calculating tab stops for fractional proportional fonts
+	hideSelection = false;
+	drawOverstrikeCaret = true;
+	bufferedDraw = true;
+	phasesDraw = phasesTwo;
+	lineWidthMaxSeen = 0;
+	additionalCaretsBlink = true;
+	additionalCaretsVisible = true;
+	imeCaretBlockOverride = false;
+	llc.SetLevel(LineLayoutCache::llcCaret);
+	posCache.SetSize(0x400);
+	tabArrowHeight = 4;
+	customDrawTabArrow = nullptr;
+	customDrawWrapMarker = nullptr;
+}
+
+EditView::~EditView() {
+}
+
+bool EditView::SetTwoPhaseDraw(bool twoPhaseDraw) noexcept {
+	const PhasesDraw phasesDrawNew = twoPhaseDraw ? phasesTwo : phasesOne;
+	const bool redraw = phasesDraw != phasesDrawNew;
+	phasesDraw = phasesDrawNew;
+	return redraw;
+}
+
+bool EditView::SetPhasesDraw(int phases) noexcept {
+	const PhasesDraw phasesDrawNew = static_cast<PhasesDraw>(phases);
+	const bool redraw = phasesDraw != phasesDrawNew;
+	phasesDraw = phasesDrawNew;
+	return redraw;
+}
+
+bool EditView::LinesOverlap() const noexcept {
+	return phasesDraw == phasesMultiple;
+}
+
+void EditView::ClearAllTabstops() noexcept {
+	ldTabstops.reset();
+}
+
+XYPOSITION EditView::NextTabstopPos(Sci::Line line, XYPOSITION x, XYPOSITION tabWidth) const noexcept {
+	const int next = GetNextTabstop(line, static_cast<int>(x + tabWidthMinimumPixels));
+	if (next > 0)
+		return static_cast<XYPOSITION>(next);
+	return (static_cast<int>((x + tabWidthMinimumPixels) / tabWidth) + 1) * tabWidth;
+}
+
+bool EditView::ClearTabstops(Sci::Line line) noexcept {
+	return ldTabstops && ldTabstops->ClearTabstops(line);
+}
+
+bool EditView::AddTabstop(Sci::Line line, int x) {
+	if (!ldTabstops) {
+		ldTabstops = std::make_unique<LineTabstops>();
+	}
+	return ldTabstops && ldTabstops->AddTabstop(line, x);
+}
+
+int EditView::GetNextTabstop(Sci::Line line, int x) const noexcept {
+	if (ldTabstops) {
+		return ldTabstops->GetNextTabstop(line, x);
+	} else {
+		return 0;
+	}
+}
+
+void EditView::LinesAddedOrRemoved(Sci::Line lineOfPos, Sci::Line linesAdded) {
+	if (ldTabstops) {
+		if (linesAdded > 0) {
+			for (Sci::Line line = lineOfPos; line < lineOfPos + linesAdded; line++) {
+				ldTabstops->InsertLine(line);
+			}
+		} else {
+			for (Sci::Line line = (lineOfPos + -linesAdded) - 1; line >= lineOfPos; line--) {
+				ldTabstops->RemoveLine(line);
+			}
+		}
+	}
+}
+
+void EditView::DropGraphics(bool freeObjects) {
+	if (freeObjects) {
+		pixmapLine.reset();
+		pixmapIndentGuide.reset();
+		pixmapIndentGuideHighlight.reset();
+	} else {
+		if (pixmapLine)
+			pixmapLine->Release();
+		if (pixmapIndentGuide)
+			pixmapIndentGuide->Release();
+		if (pixmapIndentGuideHighlight)
+			pixmapIndentGuideHighlight->Release();
+	}
+}
+
+void EditView::AllocateGraphics(const ViewStyle &vsDraw) {
+	if (!pixmapLine)
+		pixmapLine.reset(Surface::Allocate(vsDraw.technology));
+	if (!pixmapIndentGuide)
+		pixmapIndentGuide.reset(Surface::Allocate(vsDraw.technology));
+	if (!pixmapIndentGuideHighlight)
+		pixmapIndentGuideHighlight.reset(Surface::Allocate(vsDraw.technology));
+}
+
+static const char *ControlCharacterString(unsigned char ch) noexcept {
+	const char * const reps[] = {
+		"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL",
+		"BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI",
+		"DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB",
+		"CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US"
+	};
+	if (ch < std::size(reps)) {
+		return reps[ch];
+	} else {
+		return "BAD";
+	}
+}
+
+static void DrawTabArrow(Surface *surface, PRectangle rcTab, int ymid, const ViewStyle &vsDraw) {
+	const IntegerRectangle ircTab(rcTab);
+	if ((rcTab.left + 2) < (rcTab.right - 1))
+		surface->MoveTo(ircTab.left + 2, ymid);
+	else
+		surface->MoveTo(ircTab.right - 1, ymid);
+	surface->LineTo(ircTab.right - 1, ymid);
+
+	// Draw the arrow head if needed
+	if (vsDraw.tabDrawMode == tdLongArrow) {
+		int ydiff = (ircTab.bottom - ircTab.top) / 2;
+		int xhead = ircTab.right - 1 - ydiff;
+		if (xhead <= rcTab.left) {
+			ydiff -= ircTab.left - xhead - 1;
+			xhead = ircTab.left - 1;
+		}
+		surface->LineTo(xhead, ymid - ydiff);
+		surface->MoveTo(ircTab.right - 1, ymid);
+		surface->LineTo(xhead, ymid + ydiff);
+	}
+}
+
+void EditView::RefreshPixMaps(Surface *surfaceWindow, WindowID wid, const ViewStyle &vsDraw) {
+	if (!pixmapIndentGuide->Initialised()) {
+		// 1 extra pixel in height so can handle odd/even positions and so produce a continuous line
+		pixmapIndentGuide->InitPixMap(1, vsDraw.lineHeight + 1, surfaceWindow, wid);
+		pixmapIndentGuideHighlight->InitPixMap(1, vsDraw.lineHeight + 1, surfaceWindow, wid);
+		const PRectangle rcIG = PRectangle::FromInts(0, 0, 1, vsDraw.lineHeight);
+		pixmapIndentGuide->FillRectangle(rcIG, vsDraw.styles[STYLE_INDENTGUIDE].back);
+		pixmapIndentGuideHighlight->FillRectangle(rcIG, vsDraw.styles[STYLE_BRACELIGHT].back);
+		for (int stripe = 1; stripe < vsDraw.lineHeight + 1; stripe += 2) {
+			const PRectangle rcPixel = PRectangle::FromInts(0, stripe, 1, stripe + 1);
+			pixmapIndentGuide->FillRectangle(rcPixel, vsDraw.styles[STYLE_INDENTGUIDE].fore);
+			pixmapIndentGuideHighlight->FillRectangle(rcPixel, vsDraw.styles[STYLE_BRACELIGHT].fore);
+		}
+	}
+}
+
+LineLayout *EditView::RetrieveLineLayout(Sci::Line lineNumber, const EditModel &model) {
+	const Sci::Position posLineStart = model.pdoc->LineStart(lineNumber);
+	const Sci::Position posLineEnd = model.pdoc->LineStart(lineNumber + 1);
+	PLATFORM_ASSERT(posLineEnd >= posLineStart);
+	const Sci::Line lineCaret = model.pdoc->SciLineFromPosition(model.sel.MainCaret());
+	return llc.Retrieve(lineNumber, lineCaret,
+		static_cast<int>(posLineEnd - posLineStart), model.pdoc->GetStyleClock(),
+		model.LinesOnScreen() + 1, model.pdoc->LinesTotal());
+}
+
+namespace {
+
+constexpr XYPOSITION epsilon = 0.0001f;	// A small nudge to avoid floating point precision issues
+
+/**
+* Return the chDoc argument with case transformed as indicated by the caseForce argument.
+* chPrevious is needed for camel casing.
+* This only affects ASCII characters and is provided for languages with case-insensitive
+* ASCII keywords where the user wishes to view keywords in a preferred case.
+*/
+inline char CaseForce(Style::ecaseForced caseForce, char chDoc, char chPrevious) {
+	switch (caseForce) {
+	case Style::caseMixed:
+		return chDoc;
+	case Style::caseLower:
+		return MakeLowerCase(chDoc);
+	case Style::caseUpper:
+		return MakeUpperCase(chDoc);
+	case Style::caseCamel:
+	default:	// default should not occur, included to avoid warnings
+		if (IsUpperOrLowerCase(chDoc) && !IsUpperOrLowerCase(chPrevious)) {
+			return MakeUpperCase(chDoc);
+		} else {
+			return MakeLowerCase(chDoc);
+		}
+	}
+}
+
+constexpr bool IsControlCharacter(int ch) noexcept {
+	// iscntrl returns true for lots of chars > 127 which are displayable,
+	// currently only check C0 control characters.
+	return (ch >= 0 && ch < ' ') || (ch == 127);
+}
+
+}
+
+/**
+* Fill in the LineLayout data for the given line.
+* Copy the given @a line and its styles from the document into local arrays.
+* Also determine the x position at which each character starts.
+*/
+void EditView::LayoutLine(const EditModel &model, Sci::Line line, Surface *surface, const ViewStyle &vstyle, LineLayout *ll, int width) {
+	if (!ll)
+		return;
+
+	PLATFORM_ASSERT(line < model.pdoc->LinesTotal());
+	PLATFORM_ASSERT(ll->chars != NULL);
+	const Sci::Position posLineStart = model.pdoc->LineStart(line);
+	Sci::Position posLineEnd = model.pdoc->LineStart(line + 1);
+	// If the line is very long, limit the treatment to a length that should fit in the viewport
+	if (posLineEnd >(posLineStart + ll->maxLineLength)) {
+		posLineEnd = posLineStart + ll->maxLineLength;
+	}
+	// Hard to cope when too narrow, so just assume there is space
+	width = std::max(width, 20);
+
+	if (ll->validity == LineLayout::ValidLevel::checkTextAndStyle) {
+		Sci::Position lineLength = posLineEnd - posLineStart;
+		if (!vstyle.viewEOL) {
+			lineLength = model.pdoc->LineEnd(line) - posLineStart;
+		}
+		if (lineLength == ll->numCharsInLine) {
+			// See if chars, styles, indicators, are all the same
+			bool allSame = true;
+			// Check base line layout
+			char chPrevious = 0;
+			for (Sci::Position numCharsInLine = 0; numCharsInLine < lineLength; numCharsInLine++) {
+				const Sci::Position charInDoc = numCharsInLine + posLineStart;
+				const char chDoc = model.pdoc->CharAt(charInDoc);
+				const int styleByte = model.pdoc->StyleIndexAt(charInDoc);
+				allSame = allSame &&
+					(ll->styles[numCharsInLine] == styleByte);
+				allSame = allSame &&
+					(ll->chars[numCharsInLine] == CaseForce(vstyle.styles[styleByte].caseForce, chDoc, chPrevious));
+				chPrevious = chDoc;
+			}
+			const int styleByteLast = (posLineEnd > posLineStart) ? model.pdoc->StyleIndexAt(posLineEnd - 1) : 0;
+			allSame = allSame && (ll->styles[lineLength] == styleByteLast);	// For eolFilled
+			if (allSame) {
+				ll->validity = (ll->widthLine != width) ? LineLayout::ValidLevel::positions : LineLayout::ValidLevel::lines;
+			} else {
+				ll->validity = LineLayout::ValidLevel::invalid;
+			}
+		} else {
+			ll->validity = LineLayout::ValidLevel::invalid;
+		}
+	}
+	if (ll->validity == LineLayout::ValidLevel::invalid) {
+		ll->widthLine = LineLayout::wrapWidthInfinite;
+		ll->lines = 1;
+		if (vstyle.edgeState == EDGE_BACKGROUND) {
+			Sci::Position edgePosition = model.pdoc->FindColumn(line, vstyle.theEdge.column);
+			if (edgePosition >= posLineStart) {
+				edgePosition -= posLineStart;
+			}
+			ll->edgeColumn = static_cast<int>(edgePosition);
+		} else {
+			ll->edgeColumn = -1;
+		}
+
+		// Fill base line layout
+		const int lineLength = static_cast<int>(posLineEnd - posLineStart);
+		model.pdoc->GetCharRange(ll->chars.get(), posLineStart, lineLength);
+		model.pdoc->GetStyleRange(ll->styles.get(), posLineStart, lineLength);
+		const int numCharsBeforeEOL = static_cast<int>(model.pdoc->LineEnd(line) - posLineStart);
+		const int numCharsInLine = (vstyle.viewEOL) ? lineLength : numCharsBeforeEOL;
+		const unsigned char styleByteLast = (lineLength > 0) ? ll->styles[lineLength - 1] : 0;
+		if (vstyle.someStylesForceCase) {
+			char chPrevious = 0;
+			for (int charInLine = 0; charInLine<lineLength; charInLine++) {
+				const char chDoc = ll->chars[charInLine];
+				ll->chars[charInLine] = CaseForce(vstyle.styles[ll->styles[charInLine]].caseForce, chDoc, chPrevious);
+				chPrevious = chDoc;
+			}
+		}
+		ll->xHighlightGuide = 0;
+		// Extra element at the end of the line to hold end x position and act as
+		ll->chars[numCharsInLine] = 0;   // Also triggers processing in the loops as this is a control character
+		ll->styles[numCharsInLine] = styleByteLast;	// For eolFilled
+
+		// Layout the line, determining the position of each character,
+		// with an extra element at the end for the end of the line.
+		ll->positions[0] = 0;
+		bool lastSegItalics = false;
+
+		BreakFinder bfLayout(ll, nullptr, Range(0, numCharsInLine), posLineStart, 0, false, model.pdoc, &model.reprs, nullptr);
+		while (bfLayout.More()) {
+
+			const TextSegment ts = bfLayout.Next();
+
+			std::fill(&ll->positions[ts.start + 1], &ll->positions[ts.end() + 1], 0.0f);
+			if (vstyle.styles[ll->styles[ts.start]].visible) {
+				if (ts.representation) {
+					XYPOSITION representationWidth = vstyle.controlCharWidth;
+					if (ll->chars[ts.start] == '\t') {
+						// Tab is a special case of representation, taking a variable amount of space
+						const XYPOSITION x = ll->positions[ts.start];
+						representationWidth = NextTabstopPos(line, x, vstyle.tabWidth) - ll->positions[ts.start];
+					} else {
+						if (representationWidth <= 0.0) {
+							XYPOSITION positionsRepr[256];	// Should expand when needed
+							posCache.MeasureWidths(surface, vstyle, STYLE_CONTROLCHAR, ts.representation->stringRep.c_str(),
+								static_cast<unsigned int>(ts.representation->stringRep.length()), positionsRepr, model.pdoc);
+							representationWidth = positionsRepr[ts.representation->stringRep.length() - 1] + vstyle.ctrlCharPadding;
+						}
+					}
+					for (int ii = 0; ii < ts.length; ii++)
+						ll->positions[ts.start + 1 + ii] = representationWidth;
+				} else {
+					if ((ts.length == 1) && (' ' == ll->chars[ts.start])) {
+						// Over half the segments are single characters and of these about half are space characters.
+						ll->positions[ts.start + 1] = vstyle.styles[ll->styles[ts.start]].spaceWidth;
+					} else {
+						posCache.MeasureWidths(surface, vstyle, ll->styles[ts.start], &ll->chars[ts.start],
+							ts.length, &ll->positions[ts.start + 1], model.pdoc);
+					}
+				}
+				lastSegItalics = (!ts.representation) && ((ll->chars[ts.end() - 1] != ' ') && vstyle.styles[ll->styles[ts.start]].italic);
+			}
+
+			for (Sci::Position posToIncrease = ts.start + 1; posToIncrease <= ts.end(); posToIncrease++) {
+				ll->positions[posToIncrease] += ll->positions[ts.start];
+			}
+		}
+
+		// Small hack to make lines that end with italics not cut off the edge of the last character
+		if (lastSegItalics) {
+			ll->positions[numCharsInLine] += vstyle.lastSegItalicsOffset;
+		}
+		ll->numCharsInLine = numCharsInLine;
+		ll->numCharsBeforeEOL = numCharsBeforeEOL;
+		ll->validity = LineLayout::ValidLevel::positions;
+	}
+	if ((ll->validity == LineLayout::ValidLevel::positions) || (ll->widthLine != width)) {
+		ll->widthLine = width;
+		if (width == LineLayout::wrapWidthInfinite) {
+			ll->lines = 1;
+		} else if (width > ll->positions[ll->numCharsInLine]) {
+			// Simple common case where line does not need wrapping.
+			ll->lines = 1;
+		} else {
+			if (vstyle.wrapVisualFlags & SC_WRAPVISUALFLAG_END) {
+				width -= static_cast<int>(vstyle.aveCharWidth); // take into account the space for end wrap mark
+			}
+			XYPOSITION wrapAddIndent = 0; // This will be added to initial indent of line
+			switch (vstyle.wrapIndentMode) {
+			case SC_WRAPINDENT_FIXED:
+				wrapAddIndent = vstyle.wrapVisualStartIndent * vstyle.aveCharWidth;
+				break;
+			case SC_WRAPINDENT_INDENT:
+				wrapAddIndent = model.pdoc->IndentSize() * vstyle.spaceWidth;
+				break;
+			case SC_WRAPINDENT_DEEPINDENT:
+				wrapAddIndent = model.pdoc->IndentSize() * 2 * vstyle.spaceWidth;
+				break;
+			}
+			ll->wrapIndent = wrapAddIndent;
+			if (vstyle.wrapIndentMode != SC_WRAPINDENT_FIXED) {
+				for (int i = 0; i < ll->numCharsInLine; i++) {
+					if (!IsSpaceOrTab(ll->chars[i])) {
+						ll->wrapIndent += ll->positions[i]; // Add line indent
+						break;
+					}
+				}
+			}
+			// Check for text width minimum
+			if (ll->wrapIndent > width - static_cast<int>(vstyle.aveCharWidth) * 15)
+				ll->wrapIndent = wrapAddIndent;
+			// Check for wrapIndent minimum
+			if ((vstyle.wrapVisualFlags & SC_WRAPVISUALFLAG_START) && (ll->wrapIndent < vstyle.aveCharWidth))
+				ll->wrapIndent = vstyle.aveCharWidth; // Indent to show start visual
+			ll->lines = 0;
+			// Calculate line start positions based upon width.
+			Sci::Position lastGoodBreak = 0;
+			Sci::Position lastLineStart = 0;
+			XYACCUMULATOR startOffset = 0;
+			Sci::Position p = 0;
+			while (p < ll->numCharsInLine) {
+				if ((ll->positions[p + 1] - startOffset) >= width) {
+					if (lastGoodBreak == lastLineStart) {
+						// Try moving to start of last character
+						if (p > 0) {
+							lastGoodBreak = model.pdoc->MovePositionOutsideChar(p + posLineStart, -1)
+								- posLineStart;
+						}
+						if (lastGoodBreak == lastLineStart) {
+							// Ensure at least one character on line.
+							lastGoodBreak = model.pdoc->MovePositionOutsideChar(lastGoodBreak + posLineStart + 1, 1)
+								- posLineStart;
+						}
+					}
+					lastLineStart = lastGoodBreak;
+					ll->lines++;
+					ll->SetLineStart(ll->lines, static_cast<int>(lastGoodBreak));
+					startOffset = ll->positions[lastGoodBreak];
+					// take into account the space for start wrap mark and indent
+					startOffset -= ll->wrapIndent;
+					p = lastGoodBreak + 1;
+					continue;
+				}
+				if (p > 0) {
+					if (vstyle.wrapState == WrapMode::character) {
+						lastGoodBreak = model.pdoc->MovePositionOutsideChar(p + posLineStart, -1)
+							- posLineStart;
+						p = model.pdoc->MovePositionOutsideChar(p + 1 + posLineStart, 1) - posLineStart;
+						continue;
+					} else if ((vstyle.wrapState == WrapMode::word) && (ll->styles[p] != ll->styles[p - 1])) {
+						lastGoodBreak = p;
+					} else if (IsSpaceOrTab(ll->chars[p - 1]) && !IsSpaceOrTab(ll->chars[p])) {
+						lastGoodBreak = p;
+					}
+				}
+				p++;
+			}
+			ll->lines++;
+		}
+		ll->validity = LineLayout::ValidLevel::lines;
+	}
+}
+
+// Fill the LineLayout bidirectional data fields according to each char style
+
+void EditView::UpdateBidiData(const EditModel &model, const ViewStyle &vstyle, LineLayout *ll) {
+	if (model.BidirectionalEnabled()) {
+		ll->EnsureBidiData();
+		for (int stylesInLine = 0; stylesInLine < ll->numCharsInLine; stylesInLine++) {
+			ll->bidiData->stylesFonts[stylesInLine].MakeAlias(vstyle.styles[ll->styles[stylesInLine]].font);
+		}
+		ll->bidiData->stylesFonts[ll->numCharsInLine].ClearFont();
+
+		for (int charsInLine = 0; charsInLine < ll->numCharsInLine; charsInLine++) {
+			const int charWidth = UTF8DrawBytes(reinterpret_cast<unsigned char *>(&ll->chars[charsInLine]), ll->numCharsInLine - charsInLine);
+			const Representation *repr = model.reprs.RepresentationFromCharacter(&ll->chars[charsInLine], charWidth);
+
+			ll->bidiData->widthReprs[charsInLine] = 0.0f;
+			if (repr && ll->chars[charsInLine] != '\t') {
+				ll->bidiData->widthReprs[charsInLine] = ll->positions[charsInLine + charWidth] - ll->positions[charsInLine];
+			}
+			if (charWidth > 1) {
+				for (int c = 1; c < charWidth; c++) {
+					charsInLine++;
+					ll->bidiData->widthReprs[charsInLine] = 0.0f;
+				}
+			}
+		}
+		ll->bidiData->widthReprs[ll->numCharsInLine] = 0.0f;
+	} else {
+		ll->bidiData.reset();
+	}
+}
+
+Point EditView::LocationFromPosition(Surface *surface, const EditModel &model, SelectionPosition pos, Sci::Line topLine,
+				     const ViewStyle &vs, PointEnd pe, const PRectangle rcClient) {
+	Point pt;
+	if (pos.Position() == INVALID_POSITION)
+		return pt;
+	Sci::Line lineDoc = model.pdoc->SciLineFromPosition(pos.Position());
+	Sci::Position posLineStart = model.pdoc->LineStart(lineDoc);
+	if ((pe & peLineEnd) && (lineDoc > 0) && (pos.Position() == posLineStart)) {
+		// Want point at end of first line
+		lineDoc--;
+		posLineStart = model.pdoc->LineStart(lineDoc);
+	}
+	const Sci::Line lineVisible = model.pcs->DisplayFromDoc(lineDoc);
+	AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc, model));
+	if (surface && ll) {
+		LayoutLine(model, lineDoc, surface, vs, ll, model.wrapWidth);
+		const int posInLine = static_cast<int>(pos.Position() - posLineStart);
+		pt = ll->PointFromPosition(posInLine, vs.lineHeight, pe);
+		pt.x += vs.textStart - model.xOffset;
+
+		if (model.BidirectionalEnabled()) {
+			// Fill the line bidi data
+			UpdateBidiData(model, vs, ll);
+
+			// Find subLine
+			const int subLine = ll->SubLineFromPosition(posInLine, pe);
+			const int caretPosition = posInLine - ll->LineStart(subLine);
+
+			// Get the point from current position
+			const ScreenLine screenLine(ll, subLine, vs, rcClient.right, tabWidthMinimumPixels);
+			std::unique_ptr<IScreenLineLayout> slLayout = surface->Layout(&screenLine);
+			pt.x = slLayout->XFromPosition(caretPosition);
+
+			pt.x += vs.textStart - model.xOffset;
+
+			pt.y = 0;
+			if (posInLine >= ll->LineStart(subLine)) {
+				pt.y = static_cast<XYPOSITION>(subLine*vs.lineHeight);
+			}
+		}
+		pt.y += (lineVisible - topLine) * vs.lineHeight;
+	}
+	pt.x += pos.VirtualSpace() * vs.styles[ll->EndLineStyle()].spaceWidth;
+	return pt;
+}
+
+Range EditView::RangeDisplayLine(Surface *surface, const EditModel &model, Sci::Line lineVisible, const ViewStyle &vs) {
+	Range rangeSubLine = Range(0, 0);
+	if (lineVisible < 0) {
+		return rangeSubLine;
+	}
+	const Sci::Line lineDoc = model.pcs->DocFromDisplay(lineVisible);
+	const Sci::Position positionLineStart = model.pdoc->LineStart(lineDoc);
+	AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc, model));
+	if (surface && ll) {
+		LayoutLine(model, lineDoc, surface, vs, ll, model.wrapWidth);
+		const Sci::Line lineStartSet = model.pcs->DisplayFromDoc(lineDoc);
+		const int subLine = static_cast<int>(lineVisible - lineStartSet);
+		if (subLine < ll->lines) {
+			rangeSubLine = ll->SubLineRange(subLine, LineLayout::Scope::visibleOnly);
+			if (subLine == ll->lines-1) {
+				rangeSubLine.end = model.pdoc->LineStart(lineDoc + 1) -
+					positionLineStart;
+			}
+		}
+	}
+	rangeSubLine.start += positionLineStart;
+	rangeSubLine.end += positionLineStart;
+	return rangeSubLine;
+}
+
+SelectionPosition EditView::SPositionFromLocation(Surface *surface, const EditModel &model, PointDocument pt, bool canReturnInvalid,
+	bool charPosition, bool virtualSpace, const ViewStyle &vs, const PRectangle rcClient) {
+	pt.x = pt.x - vs.textStart;
+	Sci::Line visibleLine = static_cast<int>(std::floor(pt.y / vs.lineHeight));
+	if (!canReturnInvalid && (visibleLine < 0))
+		visibleLine = 0;
+	const Sci::Line lineDoc = model.pcs->DocFromDisplay(visibleLine);
+	if (canReturnInvalid && (lineDoc < 0))
+		return SelectionPosition(INVALID_POSITION);
+	if (lineDoc >= model.pdoc->LinesTotal())
+		return SelectionPosition(canReturnInvalid ? INVALID_POSITION :
+			model.pdoc->Length());
+	const Sci::Position posLineStart = model.pdoc->LineStart(lineDoc);
+	AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc, model));
+	if (surface && ll) {
+		LayoutLine(model, lineDoc, surface, vs, ll, model.wrapWidth);
+		const Sci::Line lineStartSet = model.pcs->DisplayFromDoc(lineDoc);
+		const int subLine = static_cast<int>(visibleLine - lineStartSet);
+		if (subLine < ll->lines) {
+			const Range rangeSubLine = ll->SubLineRange(subLine, LineLayout::Scope::visibleOnly);
+			const XYPOSITION subLineStart = ll->positions[rangeSubLine.start];
+			if (subLine > 0)	// Wrapped
+				pt.x -= ll->wrapIndent;
+			Sci::Position positionInLine = 0;
+			if (model.BidirectionalEnabled()) {
+				// Fill the line bidi data
+				UpdateBidiData(model, vs, ll);
+
+				const ScreenLine screenLine(ll, subLine, vs, rcClient.right, tabWidthMinimumPixels);
+				std::unique_ptr<IScreenLineLayout> slLayout = surface->Layout(&screenLine);
+				positionInLine = slLayout->PositionFromX(static_cast<XYPOSITION>(pt.x), charPosition) +
+					rangeSubLine.start;
+			} else {
+				positionInLine = ll->FindPositionFromX(static_cast<XYPOSITION>(pt.x + subLineStart),
+					rangeSubLine, charPosition);
+			}
+			if (positionInLine < rangeSubLine.end) {
+				return SelectionPosition(model.pdoc->MovePositionOutsideChar(positionInLine + posLineStart, 1));
+			}
+			if (virtualSpace) {
+				const XYPOSITION spaceWidth = vs.styles[ll->EndLineStyle()].spaceWidth;
+				const int spaceOffset = static_cast<int>(
+					(pt.x + subLineStart - ll->positions[rangeSubLine.end] + spaceWidth / 2) / spaceWidth);
+				return SelectionPosition(rangeSubLine.end + posLineStart, spaceOffset);
+			} else if (canReturnInvalid) {
+				if (pt.x < (ll->positions[rangeSubLine.end] - subLineStart)) {
+					return SelectionPosition(model.pdoc->MovePositionOutsideChar(rangeSubLine.end + posLineStart, 1));
+				}
+			} else {
+				return SelectionPosition(rangeSubLine.end + posLineStart);
+			}
+		}
+		if (!canReturnInvalid)
+			return SelectionPosition(ll->numCharsInLine + posLineStart);
+	}
+	return SelectionPosition(canReturnInvalid ? INVALID_POSITION : posLineStart);
+}
+
+/**
+* Find the document position corresponding to an x coordinate on a particular document line.
+* Ensure is between whole characters when document is in multi-byte or UTF-8 mode.
+* This method is used for rectangular selections and does not work on wrapped lines.
+*/
+SelectionPosition EditView::SPositionFromLineX(Surface *surface, const EditModel &model, Sci::Line lineDoc, int x, const ViewStyle &vs) {
+	AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc, model));
+	if (surface && ll) {
+		const Sci::Position posLineStart = model.pdoc->LineStart(lineDoc);
+		LayoutLine(model, lineDoc, surface, vs, ll, model.wrapWidth);
+		const Range rangeSubLine = ll->SubLineRange(0, LineLayout::Scope::visibleOnly);
+		const XYPOSITION subLineStart = ll->positions[rangeSubLine.start];
+		const Sci::Position positionInLine = ll->FindPositionFromX(x + subLineStart, rangeSubLine, false);
+		if (positionInLine < rangeSubLine.end) {
+			return SelectionPosition(model.pdoc->MovePositionOutsideChar(positionInLine + posLineStart, 1));
+		}
+		const XYPOSITION spaceWidth = vs.styles[ll->EndLineStyle()].spaceWidth;
+		const int spaceOffset = static_cast<int>(
+			(x + subLineStart - ll->positions[rangeSubLine.end] + spaceWidth / 2) / spaceWidth);
+		return SelectionPosition(rangeSubLine.end + posLineStart, spaceOffset);
+	}
+	return SelectionPosition(0);
+}
+
+Sci::Line EditView::DisplayFromPosition(Surface *surface, const EditModel &model, Sci::Position pos, const ViewStyle &vs) {
+	const Sci::Line lineDoc = model.pdoc->SciLineFromPosition(pos);
+	Sci::Line lineDisplay = model.pcs->DisplayFromDoc(lineDoc);
+	AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc, model));
+	if (surface && ll) {
+		LayoutLine(model, lineDoc, surface, vs, ll, model.wrapWidth);
+		const Sci::Position posLineStart = model.pdoc->LineStart(lineDoc);
+		const Sci::Position posInLine = pos - posLineStart;
+		lineDisplay--; // To make up for first increment ahead.
+		for (int subLine = 0; subLine < ll->lines; subLine++) {
+			if (posInLine >= ll->LineStart(subLine)) {
+				lineDisplay++;
+			}
+		}
+	}
+	return lineDisplay;
+}
+
+Sci::Position EditView::StartEndDisplayLine(Surface *surface, const EditModel &model, Sci::Position pos, bool start, const ViewStyle &vs) {
+	const Sci::Line line = model.pdoc->SciLineFromPosition(pos);
+	AutoLineLayout ll(llc, RetrieveLineLayout(line, model));
+	Sci::Position posRet = INVALID_POSITION;
+	if (surface && ll) {
+		const Sci::Position posLineStart = model.pdoc->LineStart(line);
+		LayoutLine(model, line, surface, vs, ll, model.wrapWidth);
+		const Sci::Position posInLine = pos - posLineStart;
+		if (posInLine <= ll->maxLineLength) {
+			for (int subLine = 0; subLine < ll->lines; subLine++) {
+				if ((posInLine >= ll->LineStart(subLine)) &&
+				    (posInLine <= ll->LineStart(subLine + 1)) &&
+				    (posInLine <= ll->numCharsBeforeEOL)) {
+					if (start) {
+						posRet = ll->LineStart(subLine) + posLineStart;
+					} else {
+						if (subLine == ll->lines - 1)
+							posRet = ll->numCharsBeforeEOL + posLineStart;
+						else
+							posRet = ll->LineStart(subLine + 1) + posLineStart - 1;
+					}
+				}
+			}
+		}
+	}
+	return posRet;
+}
+
+static ColourDesired SelectionBackground(const ViewStyle &vsDraw, bool main, bool primarySelection) noexcept {
+	return main ?
+		(primarySelection ? vsDraw.selColours.back : vsDraw.selBackground2) :
+		vsDraw.selAdditionalBackground;
+}
+
+static ColourDesired TextBackground(const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+	ColourOptional background, int inSelection, bool inHotspot, int styleMain, Sci::Position i) noexcept {
+	if (inSelection == 1) {
+		if (vsDraw.selColours.back.isSet && (vsDraw.selAlpha == SC_ALPHA_NOALPHA)) {
+			return SelectionBackground(vsDraw, true, model.primarySelection);
+		}
+	} else if (inSelection == 2) {
+		if (vsDraw.selColours.back.isSet && (vsDraw.selAdditionalAlpha == SC_ALPHA_NOALPHA)) {
+			return SelectionBackground(vsDraw, false, model.primarySelection);
+		}
+	} else {
+		if ((vsDraw.edgeState == EDGE_BACKGROUND) &&
+			(i >= ll->edgeColumn) &&
+			(i < ll->numCharsBeforeEOL))
+			return vsDraw.theEdge.colour;
+		if (inHotspot && vsDraw.hotspotColours.back.isSet)
+			return vsDraw.hotspotColours.back;
+	}
+	if (background.isSet && (styleMain != STYLE_BRACELIGHT) && (styleMain != STYLE_BRACEBAD)) {
+		return background;
+	} else {
+		return vsDraw.styles[styleMain].back;
+	}
+}
+
+void EditView::DrawIndentGuide(Surface *surface, Sci::Line lineVisible, int lineHeight, XYPOSITION start, PRectangle rcSegment, bool highlight) {
+	const Point from = Point::FromInts(0, ((lineVisible & 1) && (lineHeight & 1)) ? 1 : 0);
+	const PRectangle rcCopyArea(start + 1, rcSegment.top,
+		start + 2, rcSegment.bottom);
+	surface->Copy(rcCopyArea, from,
+		highlight ? *pixmapIndentGuideHighlight : *pixmapIndentGuide);
+}
+
+static void SimpleAlphaRectangle(Surface *surface, PRectangle rc, ColourDesired fill, int alpha) {
+	if (alpha != SC_ALPHA_NOALPHA) {
+		surface->AlphaRectangle(rc, 0, fill, alpha, fill, alpha, 0);
+	}
+}
+
+static void DrawTextBlob(Surface *surface, const ViewStyle &vsDraw, PRectangle rcSegment,
+	std::string_view text, ColourDesired textBack, ColourDesired textFore, bool fillBackground) {
+	if (rcSegment.Empty())
+		return;
+	if (fillBackground) {
+		surface->FillRectangle(rcSegment, textBack);
+	}
+	FontAlias ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font;
+	const int normalCharHeight = static_cast<int>(std::ceil(vsDraw.styles[STYLE_CONTROLCHAR].capitalHeight));
+	PRectangle rcCChar = rcSegment;
+	rcCChar.left = rcCChar.left + 1;
+	rcCChar.top = rcSegment.top + vsDraw.maxAscent - normalCharHeight;
+	rcCChar.bottom = rcSegment.top + vsDraw.maxAscent + 1;
+	PRectangle rcCentral = rcCChar;
+	rcCentral.top++;
+	rcCentral.bottom--;
+	surface->FillRectangle(rcCentral, textFore);
+	PRectangle rcChar = rcCChar;
+	rcChar.left++;
+	rcChar.right--;
+	surface->DrawTextClipped(rcChar, ctrlCharsFont,
+		rcSegment.top + vsDraw.maxAscent, text,
+		textBack, textFore);
+}
+
+static void DrawFrame(Surface *surface, ColourDesired colour, int alpha, PRectangle rcFrame) {
+	if (alpha != SC_ALPHA_NOALPHA)
+		surface->AlphaRectangle(rcFrame, 0, colour, alpha, colour, alpha, 0);
+	else
+		surface->FillRectangle(rcFrame, colour);
+}
+
+static void DrawCaretLineFramed(Surface *surface, const ViewStyle &vsDraw, const LineLayout *ll, PRectangle rcLine, int subLine) {
+	const int width = vsDraw.GetFrameWidth();
+	if (subLine == 0 || ll->wrapIndent == 0 || vsDraw.caretLineAlpha != SC_ALPHA_NOALPHA) {
+		// Left
+		DrawFrame(surface, vsDraw.caretLineBackground, vsDraw.caretLineAlpha,
+			PRectangle(rcLine.left, rcLine.top, rcLine.left + width, rcLine.bottom));
+	}
+	if (subLine == 0) {
+		// Top
+		DrawFrame(surface, vsDraw.caretLineBackground, vsDraw.caretLineAlpha,
+			PRectangle(rcLine.left + width, rcLine.top, rcLine.right - width, rcLine.top + width));
+	}
+	if (subLine == ll->lines - 1 || vsDraw.caretLineAlpha != SC_ALPHA_NOALPHA) {
+		// Right
+		DrawFrame(surface, vsDraw.caretLineBackground, vsDraw.caretLineAlpha,
+			PRectangle(rcLine.right - width, rcLine.top, rcLine.right, rcLine.bottom));
+	}
+	if (subLine == ll->lines - 1) {
+		// Bottom
+		DrawFrame(surface, vsDraw.caretLineBackground, vsDraw.caretLineAlpha,
+			PRectangle(rcLine.left + width, rcLine.bottom - width, rcLine.right - width, rcLine.bottom));
+	}
+}
+
+void EditView::DrawEOL(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+	PRectangle rcLine, Sci::Line line, Sci::Position lineEnd, int xStart, int subLine, XYACCUMULATOR subLineStart,
+	ColourOptional background) {
+
+	const Sci::Position posLineStart = model.pdoc->LineStart(line);
+	PRectangle rcSegment = rcLine;
+
+	const bool lastSubLine = subLine == (ll->lines - 1);
+	XYPOSITION virtualSpace = 0;
+	if (lastSubLine) {
+		const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
+		virtualSpace = model.sel.VirtualSpaceFor(model.pdoc->LineEnd(line)) * spaceWidth;
+	}
+	const XYPOSITION xEol = static_cast<XYPOSITION>(ll->positions[lineEnd] - subLineStart);
+
+	// Fill the virtual space and show selections within it
+	if (virtualSpace > 0.0f) {
+		rcSegment.left = xEol + xStart;
+		rcSegment.right = xEol + xStart + virtualSpace;
+		surface->FillRectangle(rcSegment, background.isSet ? background : vsDraw.styles[ll->styles[ll->numCharsInLine]].back);
+		if (!hideSelection && ((vsDraw.selAlpha == SC_ALPHA_NOALPHA) || (vsDraw.selAdditionalAlpha == SC_ALPHA_NOALPHA))) {
+			const SelectionSegment virtualSpaceRange(SelectionPosition(model.pdoc->LineEnd(line)),
+				SelectionPosition(model.pdoc->LineEnd(line),
+					model.sel.VirtualSpaceFor(model.pdoc->LineEnd(line))));
+			for (size_t r = 0; r<model.sel.Count(); r++) {
+				const int alpha = (r == model.sel.Main()) ? vsDraw.selAlpha : vsDraw.selAdditionalAlpha;
+				if (alpha == SC_ALPHA_NOALPHA) {
+					const SelectionSegment portion = model.sel.Range(r).Intersect(virtualSpaceRange);
+					if (!portion.Empty()) {
+						const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
+						rcSegment.left = xStart + ll->positions[portion.start.Position() - posLineStart] -
+							static_cast<XYPOSITION>(subLineStart)+portion.start.VirtualSpace() * spaceWidth;
+						rcSegment.right = xStart + ll->positions[portion.end.Position() - posLineStart] -
+							static_cast<XYPOSITION>(subLineStart)+portion.end.VirtualSpace() * spaceWidth;
+						rcSegment.left = (rcSegment.left > rcLine.left) ? rcSegment.left : rcLine.left;
+						rcSegment.right = (rcSegment.right < rcLine.right) ? rcSegment.right : rcLine.right;
+						surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, r == model.sel.Main(), model.primarySelection));
+					}
+				}
+			}
+		}
+	}
+
+	int eolInSelection = 0;
+	int alpha = SC_ALPHA_NOALPHA;
+	if (!hideSelection) {
+		const Sci::Position posAfterLineEnd = model.pdoc->LineStart(line + 1);
+		eolInSelection = lastSubLine ? model.sel.InSelectionForEOL(posAfterLineEnd) : 0;
+		alpha = (eolInSelection == 1) ? vsDraw.selAlpha : vsDraw.selAdditionalAlpha;
+	}
+
+	// Draw the [CR], [LF], or [CR][LF] blobs if visible line ends are on
+	XYPOSITION blobsWidth = 0;
+	if (lastSubLine) {
+		for (Sci::Position eolPos = ll->numCharsBeforeEOL; eolPos<ll->numCharsInLine; eolPos++) {
+			rcSegment.left = xStart + ll->positions[eolPos] - static_cast<XYPOSITION>(subLineStart)+virtualSpace;
+			rcSegment.right = xStart + ll->positions[eolPos + 1] - static_cast<XYPOSITION>(subLineStart)+virtualSpace;
+			blobsWidth += rcSegment.Width();
+			char hexits[4] = "";
+			const char *ctrlChar;
+			const unsigned char chEOL = ll->chars[eolPos];
+			const int styleMain = ll->styles[eolPos];
+			const ColourDesired textBack = TextBackground(model, vsDraw, ll, background, eolInSelection, false, styleMain, eolPos);
+			if (UTF8IsAscii(chEOL)) {
+				ctrlChar = ControlCharacterString(chEOL);
+			} else {
+				const Representation *repr = model.reprs.RepresentationFromCharacter(&ll->chars[eolPos], ll->numCharsInLine - eolPos);
+				if (repr) {
+					ctrlChar = repr->stringRep.c_str();
+					eolPos = ll->numCharsInLine;
+				} else {
+					sprintf(hexits, "x%2X", chEOL);
+					ctrlChar = hexits;
+				}
+			}
+			ColourDesired textFore = vsDraw.styles[styleMain].fore;
+			if (eolInSelection && vsDraw.selColours.fore.isSet) {
+				textFore = (eolInSelection == 1) ? vsDraw.selColours.fore : vsDraw.selAdditionalForeground;
+			}
+			if (eolInSelection && vsDraw.selColours.back.isSet && (line < model.pdoc->LinesTotal() - 1)) {
+				if (alpha == SC_ALPHA_NOALPHA) {
+					surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, eolInSelection == 1, model.primarySelection));
+				} else {
+					surface->FillRectangle(rcSegment, textBack);
+				}
+			} else {
+				surface->FillRectangle(rcSegment, textBack);
+			}
+			DrawTextBlob(surface, vsDraw, rcSegment, ctrlChar, textBack, textFore, phasesDraw == phasesOne);
+			if (eolInSelection && vsDraw.selColours.back.isSet && (line < model.pdoc->LinesTotal() - 1) && (alpha != SC_ALPHA_NOALPHA)) {
+				SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, eolInSelection == 1, model.primarySelection), alpha);
+			}
+		}
+	}
+
+	// Draw the eol-is-selected rectangle
+	rcSegment.left = xEol + xStart + virtualSpace + blobsWidth;
+	rcSegment.right = rcSegment.left + vsDraw.aveCharWidth;
+
+	if (eolInSelection && vsDraw.selColours.back.isSet && (line < model.pdoc->LinesTotal() - 1) && (alpha == SC_ALPHA_NOALPHA)) {
+		surface->FillRectangle(rcSegment, SelectionBackground(vsDraw, eolInSelection == 1, model.primarySelection));
+	} else {
+		if (background.isSet) {
+			surface->FillRectangle(rcSegment, background);
+		} else if (line < model.pdoc->LinesTotal() - 1) {
+			surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine]].back);
+		} else if (vsDraw.styles[ll->styles[ll->numCharsInLine]].eolFilled) {
+			surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine]].back);
+		} else {
+			surface->FillRectangle(rcSegment, vsDraw.styles[STYLE_DEFAULT].back);
+		}
+		if (eolInSelection && vsDraw.selColours.back.isSet && (line < model.pdoc->LinesTotal() - 1) && (alpha != SC_ALPHA_NOALPHA)) {
+			SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, eolInSelection == 1, model.primarySelection), alpha);
+		}
+	}
+
+	rcSegment.left = rcSegment.right;
+	if (rcSegment.left < rcLine.left)
+		rcSegment.left = rcLine.left;
+	rcSegment.right = rcLine.right;
+
+	const bool drawEOLAnnotationStyledText = (vsDraw.eolAnnotationVisible != EOLANNOTATION_HIDDEN) && model.pdoc->EOLAnnotationStyledText(line).text;
+	const bool fillRemainder = (!lastSubLine || (!model.GetFoldDisplayText(line) && !drawEOLAnnotationStyledText));
+	if (fillRemainder) {
+		// Fill the remainder of the line
+		FillLineRemainder(surface, model, vsDraw, ll, line, rcSegment, subLine);
+	}
+
+	bool drawWrapMarkEnd = false;
+
+	if (subLine + 1 < ll->lines) {
+		if (vsDraw.wrapVisualFlags & SC_WRAPVISUALFLAG_END) {
+			drawWrapMarkEnd = ll->LineStart(subLine + 1) != 0;
+		}
+		if (vsDraw.IsLineFrameOpaque(model.caret.active, ll->containsCaret)) {
+			const int width = vsDraw.GetFrameWidth();
+			// Draw right of frame under marker
+			DrawFrame(surface, vsDraw.caretLineBackground, vsDraw.caretLineAlpha,
+				PRectangle(rcLine.right - width, rcLine.top, rcLine.right, rcLine.bottom));
+		}
+	}
+
+	if (drawWrapMarkEnd) {
+		PRectangle rcPlace = rcSegment;
+
+		if (vsDraw.wrapVisualFlagsLocation & SC_WRAPVISUALFLAGLOC_END_BY_TEXT) {
+			rcPlace.left = xEol + xStart + virtualSpace;
+			rcPlace.right = rcPlace.left + vsDraw.aveCharWidth;
+		} else {
+			// rcLine is clipped to text area
+			rcPlace.right = rcLine.right;
+			rcPlace.left = rcPlace.right - vsDraw.aveCharWidth;
+		}
+		if (!customDrawWrapMarker) {
+			DrawWrapMarker(surface, rcPlace, true, vsDraw.WrapColour());
+		} else {
+			customDrawWrapMarker(surface, rcPlace, true, vsDraw.WrapColour());
+		}
+	}
+}
+
+static void DrawIndicator(int indicNum, Sci::Position startPos, Sci::Position endPos, Surface *surface, const ViewStyle &vsDraw,
+	const LineLayout *ll, int xStart, PRectangle rcLine, Sci::Position secondCharacter, int subLine, Indicator::State state,
+	int value, bool bidiEnabled, int tabWidthMinimumPixels) {
+
+	const XYPOSITION subLineStart = ll->positions[ll->LineStart(subLine)];
+
+	std::vector<PRectangle> rectangles;
+
+	const PRectangle rcIndic(
+		ll->positions[startPos] + xStart - subLineStart,
+		rcLine.top + vsDraw.maxAscent,
+		ll->positions[endPos] + xStart - subLineStart,
+		rcLine.top + vsDraw.maxAscent + 3);
+
+	if (bidiEnabled) {
+		ScreenLine screenLine(ll, subLine, vsDraw, rcLine.right - xStart, tabWidthMinimumPixels);
+		const Range lineRange = ll->SubLineRange(subLine, LineLayout::Scope::visibleOnly);
+
+		std::unique_ptr<IScreenLineLayout> slLayout = surface->Layout(&screenLine);
+		std::vector<Interval> intervals = slLayout->FindRangeIntervals(
+			startPos - lineRange.start, endPos - lineRange.start);
+		for (const Interval &interval : intervals) {
+			PRectangle rcInterval = rcIndic;
+			rcInterval.left = interval.left + xStart;
+			rcInterval.right = interval.right + xStart;
+			rectangles.push_back(rcInterval);
+		}
+	} else {
+		rectangles.push_back(rcIndic);
+	}
+
+	for (const PRectangle &rc : rectangles) {
+		PRectangle rcFirstCharacter = rc;
+		// Allow full descent space for character indicators
+		rcFirstCharacter.bottom = rcLine.top + vsDraw.maxAscent + vsDraw.maxDescent;
+		if (secondCharacter >= 0) {
+			rcFirstCharacter.right = ll->positions[secondCharacter] + xStart - subLineStart;
+		} else {
+			// Indicator continued from earlier line so make an empty box and don't draw
+			rcFirstCharacter.right = rcFirstCharacter.left;
+		}
+		vsDraw.indicators[indicNum].Draw(surface, rc, rcLine, rcFirstCharacter, state, value);
+	}
+}
+
+static void DrawIndicators(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+	Sci::Line line, int xStart, PRectangle rcLine, int subLine, Sci::Position lineEnd, bool under, int tabWidthMinimumPixels) {
+	// Draw decorators
+	const Sci::Position posLineStart = model.pdoc->LineStart(line);
+	const Sci::Position lineStart = ll->LineStart(subLine);
+	const Sci::Position posLineEnd = posLineStart + lineEnd;
+
+	for (const IDecoration *deco : model.pdoc->decorations->View()) {
+		if (under == vsDraw.indicators[deco->Indicator()].under) {
+			Sci::Position startPos = posLineStart + lineStart;
+			if (!deco->ValueAt(startPos)) {
+				startPos = deco->EndRun(startPos);
+			}
+			while ((startPos < posLineEnd) && (deco->ValueAt(startPos))) {
+				const Range rangeRun(deco->StartRun(startPos), deco->EndRun(startPos));
+				const Sci::Position endPos = std::min(rangeRun.end, posLineEnd);
+				const bool hover = vsDraw.indicators[deco->Indicator()].IsDynamic() &&
+					rangeRun.ContainsCharacter(model.hoverIndicatorPos);
+				const int value = deco->ValueAt(startPos);
+				const Indicator::State state = hover ? Indicator::State::hover : Indicator::State::normal;
+				const Sci::Position posSecond = model.pdoc->MovePositionOutsideChar(rangeRun.First() + 1, 1);
+				DrawIndicator(deco->Indicator(), startPos - posLineStart, endPos - posLineStart,
+					surface, vsDraw, ll, xStart, rcLine, posSecond - posLineStart, subLine, state,
+					value, model.BidirectionalEnabled(), tabWidthMinimumPixels);
+				startPos = endPos;
+				if (!deco->ValueAt(startPos)) {
+					startPos = deco->EndRun(startPos);
+				}
+			}
+		}
+	}
+
+	// Use indicators to highlight matching braces
+	if ((vsDraw.braceHighlightIndicatorSet && (model.bracesMatchStyle == STYLE_BRACELIGHT)) ||
+		(vsDraw.braceBadLightIndicatorSet && (model.bracesMatchStyle == STYLE_BRACEBAD))) {
+		const int braceIndicator = (model.bracesMatchStyle == STYLE_BRACELIGHT) ? vsDraw.braceHighlightIndicator : vsDraw.braceBadLightIndicator;
+		if (under == vsDraw.indicators[braceIndicator].under) {
+			const Range rangeLine(posLineStart + lineStart, posLineEnd);
+			if (rangeLine.ContainsCharacter(model.braces[0])) {
+				const Sci::Position braceOffset = model.braces[0] - posLineStart;
+				if (braceOffset < ll->numCharsInLine) {
+					const Sci::Position secondOffset = model.pdoc->MovePositionOutsideChar(model.braces[0] + 1, 1) - posLineStart;
+					DrawIndicator(braceIndicator, braceOffset, braceOffset + 1, surface, vsDraw, ll, xStart, rcLine, secondOffset,
+						subLine, Indicator::State::normal, 1, model.BidirectionalEnabled(), tabWidthMinimumPixels);
+				}
+			}
+			if (rangeLine.ContainsCharacter(model.braces[1])) {
+				const Sci::Position braceOffset = model.braces[1] - posLineStart;
+				if (braceOffset < ll->numCharsInLine) {
+					const Sci::Position secondOffset = model.pdoc->MovePositionOutsideChar(model.braces[1] + 1, 1) - posLineStart;
+					DrawIndicator(braceIndicator, braceOffset, braceOffset + 1, surface, vsDraw, ll, xStart, rcLine, secondOffset,
+						subLine, Indicator::State::normal, 1, model.BidirectionalEnabled(), tabWidthMinimumPixels);
+				}
+			}
+		}
+	}
+}
+
+void EditView::DrawFoldDisplayText(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+							  Sci::Line line, int xStart, PRectangle rcLine, int subLine, XYACCUMULATOR subLineStart, DrawPhase phase) {
+	const bool lastSubLine = subLine == (ll->lines - 1);
+	if (!lastSubLine)
+		return;
+
+	const char *text = model.GetFoldDisplayText(line);
+	if (!text)
+		return;
+
+	PRectangle rcSegment = rcLine;
+	const std::string_view foldDisplayText(text);
+	FontAlias fontText = vsDraw.styles[STYLE_FOLDDISPLAYTEXT].font;
+	const int widthFoldDisplayText = static_cast<int>(surface->WidthText(fontText, foldDisplayText));
+
+	int eolInSelection = 0;
+	int alpha = SC_ALPHA_NOALPHA;
+	if (!hideSelection) {
+		const Sci::Position posAfterLineEnd = model.pdoc->LineStart(line + 1);
+		eolInSelection = (subLine == (ll->lines - 1)) ? model.sel.InSelectionForEOL(posAfterLineEnd) : 0;
+		alpha = (eolInSelection == 1) ? vsDraw.selAlpha : vsDraw.selAdditionalAlpha;
+	}
+
+	const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
+	const XYPOSITION virtualSpace = model.sel.VirtualSpaceFor(
+		model.pdoc->LineEnd(line)) * spaceWidth;
+	rcSegment.left = xStart + static_cast<XYPOSITION>(ll->positions[ll->numCharsInLine] - subLineStart) + virtualSpace + vsDraw.aveCharWidth;
+	rcSegment.right = rcSegment.left + static_cast<XYPOSITION>(widthFoldDisplayText);
+
+	const ColourOptional background = vsDraw.Background(model.pdoc->GetMark(line), model.caret.active, ll->containsCaret);
+	ColourDesired textFore = vsDraw.styles[STYLE_FOLDDISPLAYTEXT].fore;
+	if (eolInSelection && (vsDraw.selColours.fore.isSet)) {
+		textFore = (eolInSelection == 1) ? vsDraw.selColours.fore : vsDraw.selAdditionalForeground;
+	}
+	const ColourDesired textBack = TextBackground(model, vsDraw, ll, background, eolInSelection,
+											false, STYLE_FOLDDISPLAYTEXT, -1);
+
+	if (model.trackLineWidth) {
+		if (rcSegment.right + 1> lineWidthMaxSeen) {
+			// Fold display text border drawn on rcSegment.right with width 1 is the last visible object of the line
+			lineWidthMaxSeen = static_cast<int>(rcSegment.right + 1);
+		}
+	}
+
+	if (phase & drawBack) {
+		surface->FillRectangle(rcSegment, textBack);
+
+		// Fill Remainder of the line
+		PRectangle rcRemainder = rcSegment;
+		rcRemainder.left = rcRemainder.right;
+		if (rcRemainder.left < rcLine.left)
+			rcRemainder.left = rcLine.left;
+		rcRemainder.right = rcLine.right;
+		FillLineRemainder(surface, model, vsDraw, ll, line, rcRemainder, subLine);
+	}
+
+	if (phase & drawText) {
+		if (phasesDraw != phasesOne) {
+			surface->DrawTextTransparent(rcSegment, fontText,
+				rcSegment.top + vsDraw.maxAscent, foldDisplayText,
+				textFore);
+		} else {
+			surface->DrawTextNoClip(rcSegment, fontText,
+				rcSegment.top + vsDraw.maxAscent, foldDisplayText,
+				textFore, textBack);
+		}
+	}
+
+	if (phase & drawIndicatorsFore) {
+		if (model.foldDisplayTextStyle == SC_FOLDDISPLAYTEXT_BOXED) {
+			surface->PenColour(textFore);
+			PRectangle rcBox = rcSegment;
+			rcBox.left = std::round(rcSegment.left);
+			rcBox.right = std::round(rcSegment.right);
+			const IntegerRectangle ircBox(rcBox);
+			surface->MoveTo(ircBox.left, ircBox.top);
+			surface->LineTo(ircBox.left, ircBox.bottom);
+			surface->MoveTo(ircBox.right, ircBox.top);
+			surface->LineTo(ircBox.right, ircBox.bottom);
+			surface->MoveTo(ircBox.left, ircBox.top);
+			surface->LineTo(ircBox.right, ircBox.top);
+			surface->MoveTo(ircBox.left, ircBox.bottom - 1);
+			surface->LineTo(ircBox.right, ircBox.bottom - 1);
+		}
+	}
+
+	if (phase & drawSelectionTranslucent) {
+		if (eolInSelection && vsDraw.selColours.back.isSet && (line < model.pdoc->LinesTotal() - 1) && alpha != SC_ALPHA_NOALPHA) {
+			SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, eolInSelection == 1, model.primarySelection), alpha);
+		}
+	}
+}
+
+void EditView::DrawEOLAnnotationText(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll, Sci::Line line, int xStart, PRectangle rcLine, int subLine, XYACCUMULATOR subLineStart, DrawPhase phase) {
+
+	const bool lastSubLine = subLine == (ll->lines - 1);
+	if (!lastSubLine)
+		return;
+
+	if (vsDraw.eolAnnotationVisible == EOLANNOTATION_HIDDEN) {
+		return;
+	}
+	const StyledText stEOLAnnotation = model.pdoc->EOLAnnotationStyledText(line);
+	if (!stEOLAnnotation.text || !ValidStyledText(vsDraw, vsDraw.eolAnnotationStyleOffset, stEOLAnnotation)) {
+		return;
+	}
+	const std::string_view eolAnnotationText(stEOLAnnotation.text, stEOLAnnotation.length);
+	const size_t style = stEOLAnnotation.style + vsDraw.eolAnnotationStyleOffset;
+
+	PRectangle rcSegment = rcLine;
+	FontAlias fontText = vsDraw.styles[style].font;
+	const int widthEOLAnnotationText = static_cast<int>(surface->WidthText(fontText, eolAnnotationText));
+
+	const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
+	const XYPOSITION virtualSpace = model.sel.VirtualSpaceFor(
+		model.pdoc->LineEnd(line)) * spaceWidth;
+	rcSegment.left = xStart +
+		static_cast<XYPOSITION>(ll->positions[ll->numCharsInLine] - subLineStart)
+		+ virtualSpace + vsDraw.aveCharWidth;
+
+	const char *textFoldDisplay = model.GetFoldDisplayText(line);
+	if (textFoldDisplay) {
+		const std::string_view foldDisplayText(textFoldDisplay);
+		rcSegment.left += (static_cast<int>(surface->WidthText(fontText, foldDisplayText)) + vsDraw.aveCharWidth);
+	}
+	rcSegment.right = rcSegment.left + static_cast<XYPOSITION>(widthEOLAnnotationText);
+
+	const ColourOptional background = vsDraw.Background(model.pdoc->GetMark(line), model.caret.active, ll->containsCaret);
+	ColourDesired textFore = vsDraw.styles[style].fore;
+	const ColourDesired textBack = TextBackground(model, vsDraw, ll, background, false,
+											false, static_cast<int>(style), -1);
+
+	if (model.trackLineWidth) {
+		if (rcSegment.right + 1> lineWidthMaxSeen) {
+			// EOL Annotation text border drawn on rcSegment.right with width 1 is the last visible object of the line
+			lineWidthMaxSeen = static_cast<int>(rcSegment.right + 1);
+		}
+	}
+
+	if (phase & drawBack) {
+		surface->FillRectangle(rcSegment, textBack);
+
+		// Fill Remainder of the line
+		PRectangle rcRemainder = rcSegment;
+		rcRemainder.left = rcRemainder.right;
+		if (rcRemainder.left < rcLine.left)
+			rcRemainder.left = rcLine.left;
+		rcRemainder.right = rcLine.right;
+		FillLineRemainder(surface, model, vsDraw, ll, line, rcRemainder, subLine);
+	}
+
+	if (phase & drawText) {
+		if (phasesDraw != phasesOne) {
+			surface->DrawTextTransparent(rcSegment, fontText,
+			rcSegment.top + vsDraw.maxAscent, eolAnnotationText,
+			textFore);
+		} else {
+			surface->DrawTextNoClip(rcSegment, fontText,
+			rcSegment.top + vsDraw.maxAscent, eolAnnotationText,
+			textFore, textBack);
+		}
+	}
+
+	if (phase & drawIndicatorsFore) {
+		if (vsDraw.eolAnnotationVisible == EOLANNOTATION_BOXED ) {
+			surface->PenColour(textFore);
+			PRectangle rcBox = rcSegment;
+			rcBox.left = std::round(rcSegment.left);
+			rcBox.right = std::round(rcSegment.right);
+			const IntegerRectangle ircBox(rcBox);
+			surface->MoveTo(ircBox.left, ircBox.top);
+			surface->LineTo(ircBox.left, ircBox.bottom);
+			surface->MoveTo(ircBox.right, ircBox.top);
+			surface->LineTo(ircBox.right, ircBox.bottom);
+			surface->MoveTo(ircBox.left, ircBox.top);
+			surface->LineTo(ircBox.right, ircBox.top);
+			surface->MoveTo(ircBox.left, ircBox.bottom - 1);
+			surface->LineTo(ircBox.right, ircBox.bottom - 1);
+		}
+	}
+}
+
+static constexpr bool AnnotationBoxedOrIndented(int annotationVisible) noexcept {
+	return annotationVisible == ANNOTATION_BOXED || annotationVisible == ANNOTATION_INDENTED;
+}
+
+void EditView::DrawAnnotation(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+	Sci::Line line, int xStart, PRectangle rcLine, int subLine, DrawPhase phase) {
+	const int indent = static_cast<int>(model.pdoc->GetLineIndentation(line) * vsDraw.spaceWidth);
+	PRectangle rcSegment = rcLine;
+	const int annotationLine = subLine - ll->lines;
+	const StyledText stAnnotation = model.pdoc->AnnotationStyledText(line);
+	if (stAnnotation.text && ValidStyledText(vsDraw, vsDraw.annotationStyleOffset, stAnnotation)) {
+		if (phase & drawBack) {
+			surface->FillRectangle(rcSegment, vsDraw.styles[0].back);
+		}
+		rcSegment.left = static_cast<XYPOSITION>(xStart);
+		if (model.trackLineWidth || AnnotationBoxedOrIndented(vsDraw.annotationVisible)) {
+			// Only care about calculating width if tracking or need to draw indented box
+			int widthAnnotation = WidestLineWidth(surface, vsDraw, vsDraw.annotationStyleOffset, stAnnotation);
+			if (AnnotationBoxedOrIndented(vsDraw.annotationVisible)) {
+				widthAnnotation += static_cast<int>(vsDraw.spaceWidth * 2); // Margins
+				rcSegment.left = static_cast<XYPOSITION>(xStart + indent);
+				rcSegment.right = rcSegment.left + widthAnnotation;
+			}
+			if (widthAnnotation > lineWidthMaxSeen)
+				lineWidthMaxSeen = widthAnnotation;
+		}
+		const int annotationLines = model.pdoc->AnnotationLines(line);
+		size_t start = 0;
+		size_t lengthAnnotation = stAnnotation.LineLength(start);
+		int lineInAnnotation = 0;
+		while ((lineInAnnotation < annotationLine) && (start < stAnnotation.length)) {
+			start += lengthAnnotation + 1;
+			lengthAnnotation = stAnnotation.LineLength(start);
+			lineInAnnotation++;
+		}
+		PRectangle rcText = rcSegment;
+		if ((phase & drawBack) && AnnotationBoxedOrIndented(vsDraw.annotationVisible)) {
+			surface->FillRectangle(rcText,
+				vsDraw.styles[stAnnotation.StyleAt(start) + vsDraw.annotationStyleOffset].back);
+			rcText.left += vsDraw.spaceWidth;
+		}
+		DrawStyledText(surface, vsDraw, vsDraw.annotationStyleOffset, rcText,
+			stAnnotation, start, lengthAnnotation, phase);
+		if ((phase & drawBack) && (vsDraw.annotationVisible == ANNOTATION_BOXED)) {
+			surface->PenColour(vsDraw.styles[vsDraw.annotationStyleOffset].fore);
+			const IntegerRectangle ircSegment(rcSegment);
+			surface->MoveTo(ircSegment.left, ircSegment.top);
+			surface->LineTo(ircSegment.left, ircSegment.bottom);
+			surface->MoveTo(ircSegment.right, ircSegment.top);
+			surface->LineTo(ircSegment.right, ircSegment.bottom);
+			if (subLine == ll->lines) {
+				surface->MoveTo(ircSegment.left, ircSegment.top);
+				surface->LineTo(ircSegment.right, ircSegment.top);
+			}
+			if (subLine == ll->lines + annotationLines - 1) {
+				surface->MoveTo(ircSegment.left, ircSegment.bottom - 1);
+				surface->LineTo(ircSegment.right, ircSegment.bottom - 1);
+			}
+		}
+	}
+}
+
+static void DrawBlockCaret(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+	int subLine, int xStart, Sci::Position offset, Sci::Position posCaret, PRectangle rcCaret, ColourDesired caretColour) {
+
+	const Sci::Position lineStart = ll->LineStart(subLine);
+	Sci::Position posBefore = posCaret;
+	Sci::Position posAfter = model.pdoc->MovePositionOutsideChar(posCaret + 1, 1);
+	Sci::Position numCharsToDraw = posAfter - posCaret;
+
+	// Work out where the starting and ending offsets are. We need to
+	// see if the previous character shares horizontal space, such as a
+	// glyph / combining character. If so we'll need to draw that too.
+	Sci::Position offsetFirstChar = offset;
+	Sci::Position offsetLastChar = offset + (posAfter - posCaret);
+	while ((posBefore > 0) && ((offsetLastChar - numCharsToDraw) >= lineStart)) {
+		if ((ll->positions[offsetLastChar] - ll->positions[offsetLastChar - numCharsToDraw]) > 0) {
+			// The char does not share horizontal space
+			break;
+		}
+		// Char shares horizontal space, update the numChars to draw
+		// Update posBefore to point to the prev char
+		posBefore = model.pdoc->MovePositionOutsideChar(posBefore - 1, -1);
+		numCharsToDraw = posAfter - posBefore;
+		offsetFirstChar = offset - (posCaret - posBefore);
+	}
+
+	// See if the next character shares horizontal space, if so we'll
+	// need to draw that too.
+	if (offsetFirstChar < 0)
+		offsetFirstChar = 0;
+	numCharsToDraw = offsetLastChar - offsetFirstChar;
+	while ((offsetLastChar < ll->LineStart(subLine + 1)) && (offsetLastChar <= ll->numCharsInLine)) {
+		// Update posAfter to point to the 2nd next char, this is where
+		// the next character ends, and 2nd next begins. We'll need
+		// to compare these two
+		posBefore = posAfter;
+		posAfter = model.pdoc->MovePositionOutsideChar(posAfter + 1, 1);
+		offsetLastChar = offset + (posAfter - posCaret);
+		if ((ll->positions[offsetLastChar] - ll->positions[offsetLastChar - (posAfter - posBefore)]) > 0) {
+			// The char does not share horizontal space
+			break;
+		}
+		// Char shares horizontal space, update the numChars to draw
+		numCharsToDraw = offsetLastChar - offsetFirstChar;
+	}
+
+	// We now know what to draw, update the caret drawing rectangle
+	rcCaret.left = ll->positions[offsetFirstChar] - ll->positions[lineStart] + xStart;
+	rcCaret.right = ll->positions[offsetFirstChar + numCharsToDraw] - ll->positions[lineStart] + xStart;
+
+	// Adjust caret position to take into account any word wrapping symbols.
+	if ((ll->wrapIndent != 0) && (lineStart != 0)) {
+		const XYPOSITION wordWrapCharWidth = ll->wrapIndent;
+		rcCaret.left += wordWrapCharWidth;
+		rcCaret.right += wordWrapCharWidth;
+	}
+
+	// This character is where the caret block is, we override the colours
+	// (inversed) for drawing the caret here.
+	const int styleMain = ll->styles[offsetFirstChar];
+	FontAlias fontText = vsDraw.styles[styleMain].font;
+	const std::string_view text(&ll->chars[offsetFirstChar], numCharsToDraw);
+	surface->DrawTextClipped(rcCaret, fontText,
+		rcCaret.top + vsDraw.maxAscent, text, vsDraw.styles[styleMain].back,
+		caretColour);
+}
+
+void EditView::DrawCarets(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+	Sci::Line lineDoc, int xStart, PRectangle rcLine, int subLine) const {
+	// When drag is active it is the only caret drawn
+	const bool drawDrag = model.posDrag.IsValid();
+	if (hideSelection && !drawDrag)
+		return;
+	const Sci::Position posLineStart = model.pdoc->LineStart(lineDoc);
+	// For each selection draw
+	for (size_t r = 0; (r<model.sel.Count()) || drawDrag; r++) {
+		const bool mainCaret = r == model.sel.Main();
+		SelectionPosition posCaret = (drawDrag ? model.posDrag : model.sel.Range(r).caret);
+		if ((vsDraw.DrawCaretInsideSelection(model.inOverstrike, imeCaretBlockOverride)) && 
+			!drawDrag &&
+			posCaret > model.sel.Range(r).anchor) {
+			if (posCaret.VirtualSpace() > 0)
+				posCaret.SetVirtualSpace(posCaret.VirtualSpace() - 1);
+			else
+				posCaret.SetPosition(model.pdoc->MovePositionOutsideChar(posCaret.Position()-1, -1));
+		}
+		const int offset = static_cast<int>(posCaret.Position() - posLineStart);
+		const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
+		const XYPOSITION virtualOffset = posCaret.VirtualSpace() * spaceWidth;
+		if (ll->InLine(offset, subLine) && offset <= ll->numCharsBeforeEOL) {
+			XYPOSITION xposCaret = ll->positions[offset] + virtualOffset - ll->positions[ll->LineStart(subLine)];
+			if (model.BidirectionalEnabled() && (posCaret.VirtualSpace() == 0)) {
+				// Get caret point
+				const ScreenLine screenLine(ll, subLine, vsDraw, rcLine.right, tabWidthMinimumPixels);
+
+				const int caretPosition = offset - ll->LineStart(subLine);
+
+				std::unique_ptr<IScreenLineLayout> slLayout = surface->Layout(&screenLine);
+				const XYPOSITION caretLeft = slLayout->XFromPosition(caretPosition);
+
+				// In case of start of line, the cursor should be at the right
+				xposCaret = caretLeft + virtualOffset;
+			}
+			if (ll->wrapIndent != 0) {
+				const Sci::Position lineStart = ll->LineStart(subLine);
+				if (lineStart != 0)	// Wrapped
+					xposCaret += ll->wrapIndent;
+			}
+			const bool caretBlinkState = (model.caret.active && model.caret.on) || (!additionalCaretsBlink && !mainCaret);
+			const bool caretVisibleState = additionalCaretsVisible || mainCaret;
+			if ((xposCaret >= 0) && vsDraw.IsCaretVisible() &&
+				(drawDrag || (caretBlinkState && caretVisibleState))) {
+				bool canDrawBlockCaret = true;
+				bool drawBlockCaret = false;
+				XYPOSITION widthOverstrikeCaret;
+				XYPOSITION caretWidthOffset = 0;
+				PRectangle rcCaret = rcLine;
+
+				if (posCaret.Position() == model.pdoc->Length()) {   // At end of document
+					canDrawBlockCaret = false;
+					widthOverstrikeCaret = vsDraw.aveCharWidth;
+				} else if ((posCaret.Position() - posLineStart) >= ll->numCharsInLine) {	// At end of line
+					canDrawBlockCaret = false;
+					widthOverstrikeCaret = vsDraw.aveCharWidth;
+				} else {
+					const int widthChar = model.pdoc->LenChar(posCaret.Position());
+					widthOverstrikeCaret = ll->positions[offset + widthChar] - ll->positions[offset];
+				}
+				if (widthOverstrikeCaret < 3)	// Make sure its visible
+					widthOverstrikeCaret = 3;
+
+				if (xposCaret > 0)
+					caretWidthOffset = 0.51f;	// Move back so overlaps both character cells.
+				xposCaret += xStart;
+				const ViewStyle::CaretShape caretShape = drawDrag ? ViewStyle::CaretShape::line : vsDraw.CaretShapeForMode(model.inOverstrike);
+				if (drawDrag) {
+					/* Dragging text, use a line caret */
+					rcCaret.left = std::round(xposCaret - caretWidthOffset);
+					rcCaret.right = rcCaret.left + vsDraw.caretWidth;
+				} else if ((caretShape == ViewStyle::CaretShape::bar) && drawOverstrikeCaret) {
+					/* Overstrike (insert mode), use a modified bar caret */
+					rcCaret.top = rcCaret.bottom - 2;
+					rcCaret.left = xposCaret + 1;
+					rcCaret.right = rcCaret.left + widthOverstrikeCaret - 1;
+				} else if ((caretShape == ViewStyle::CaretShape::block) || imeCaretBlockOverride) {
+					/* Block caret */
+					rcCaret.left = xposCaret;
+					if (canDrawBlockCaret && !(IsControlCharacter(ll->chars[offset]))) {
+						drawBlockCaret = true;
+						rcCaret.right = xposCaret + widthOverstrikeCaret;
+					} else {
+						rcCaret.right = xposCaret + vsDraw.aveCharWidth;
+					}
+				} else {
+					/* Line caret */
+					rcCaret.left = std::round(xposCaret - caretWidthOffset);
+					rcCaret.right = rcCaret.left + vsDraw.caretWidth;
+				}
+				const ColourDesired caretColour = mainCaret ? vsDraw.caretcolour : vsDraw.additionalCaretColour;
+				if (drawBlockCaret) {
+					DrawBlockCaret(surface, model, vsDraw, ll, subLine, xStart, offset, posCaret.Position(), rcCaret, caretColour);
+				} else {
+					surface->FillRectangle(rcCaret, caretColour);
+				}
+			}
+		}
+		if (drawDrag)
+			break;
+	}
+}
+
+static void DrawWrapIndentAndMarker(Surface *surface, const ViewStyle &vsDraw, const LineLayout *ll,
+	int xStart, PRectangle rcLine, ColourOptional background, DrawWrapMarkerFn customDrawWrapMarker,
+	bool caretActive) {
+	// default bgnd here..
+	surface->FillRectangle(rcLine, background.isSet ? background :
+		vsDraw.styles[STYLE_DEFAULT].back);
+
+	if (vsDraw.IsLineFrameOpaque(caretActive, ll->containsCaret)) {
+		const int width = vsDraw.GetFrameWidth();
+		// Draw left of frame under marker
+		DrawFrame(surface, vsDraw.caretLineBackground, vsDraw.caretLineAlpha,
+			PRectangle(rcLine.left, rcLine.top, rcLine.left + width, rcLine.bottom));
+	}
+
+	if (vsDraw.wrapVisualFlags & SC_WRAPVISUALFLAG_START) {
+
+		// draw continuation rect
+		PRectangle rcPlace = rcLine;
+
+		rcPlace.left = static_cast<XYPOSITION>(xStart);
+		rcPlace.right = rcPlace.left + ll->wrapIndent;
+
+		if (vsDraw.wrapVisualFlagsLocation & SC_WRAPVISUALFLAGLOC_START_BY_TEXT)
+			rcPlace.left = rcPlace.right - vsDraw.aveCharWidth;
+		else
+			rcPlace.right = rcPlace.left + vsDraw.aveCharWidth;
+
+		if (!customDrawWrapMarker) {
+			DrawWrapMarker(surface, rcPlace, false, vsDraw.WrapColour());
+		} else {
+			customDrawWrapMarker(surface, rcPlace, false, vsDraw.WrapColour());
+		}
+	}
+}
+
+void EditView::DrawBackground(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+	PRectangle rcLine, Range lineRange, Sci::Position posLineStart, int xStart,
+	int subLine, ColourOptional background) const {
+
+	const bool selBackDrawn = vsDraw.SelectionBackgroundDrawn();
+	bool inIndentation = subLine == 0;	// Do not handle indentation except on first subline.
+	const XYACCUMULATOR subLineStart = ll->positions[lineRange.start];
+	// Does not take margin into account but not significant
+	const int xStartVisible = static_cast<int>(subLineStart)-xStart;
+
+	BreakFinder bfBack(ll, &model.sel, lineRange, posLineStart, xStartVisible, selBackDrawn, model.pdoc, &model.reprs, nullptr);
+
+	const bool drawWhitespaceBackground = vsDraw.WhitespaceBackgroundDrawn() && !background.isSet;
+
+	// Background drawing loop
+	while (bfBack.More()) {
+
+		const TextSegment ts = bfBack.Next();
+		const Sci::Position i = ts.end() - 1;
+		const Sci::Position iDoc = i + posLineStart;
+
+		PRectangle rcSegment = rcLine;
+		rcSegment.left = ll->positions[ts.start] + xStart - static_cast<XYPOSITION>(subLineStart);
+		rcSegment.right = ll->positions[ts.end()] + xStart - static_cast<XYPOSITION>(subLineStart);
+		// Only try to draw if really visible - enhances performance by not calling environment to
+		// draw strings that are completely past the right side of the window.
+		if (!rcSegment.Empty() && rcSegment.Intersects(rcLine)) {
+			// Clip to line rectangle, since may have a huge position which will not work with some platforms
+			if (rcSegment.left < rcLine.left)
+				rcSegment.left = rcLine.left;
+			if (rcSegment.right > rcLine.right)
+				rcSegment.right = rcLine.right;
+
+			const int inSelection = hideSelection ? 0 : model.sel.CharacterInSelection(iDoc);
+			const bool inHotspot = (ll->hotspot.Valid()) && ll->hotspot.ContainsCharacter(iDoc);
+			ColourDesired textBack = TextBackground(model, vsDraw, ll, background, inSelection,
+				inHotspot, ll->styles[i], i);
+			if (ts.representation) {
+				if (ll->chars[i] == '\t') {
+					// Tab display
+					if (drawWhitespaceBackground && vsDraw.WhiteSpaceVisible(inIndentation))
+						textBack = vsDraw.whitespaceColours.back;
+				} else {
+					// Blob display
+					inIndentation = false;
+				}
+				surface->FillRectangle(rcSegment, textBack);
+			} else {
+				// Normal text display
+				surface->FillRectangle(rcSegment, textBack);
+				if (vsDraw.viewWhitespace != wsInvisible) {
+					for (int cpos = 0; cpos <= i - ts.start; cpos++) {
+						if (ll->chars[cpos + ts.start] == ' ') {
+							if (drawWhitespaceBackground && vsDraw.WhiteSpaceVisible(inIndentation)) {
+								const PRectangle rcSpace(
+									ll->positions[cpos + ts.start] + xStart - static_cast<XYPOSITION>(subLineStart),
+									rcSegment.top,
+									ll->positions[cpos + ts.start + 1] + xStart - static_cast<XYPOSITION>(subLineStart),
+									rcSegment.bottom);
+								surface->FillRectangle(rcSpace, vsDraw.whitespaceColours.back);
+							}
+						} else {
+							inIndentation = false;
+						}
+					}
+				}
+			}
+		} else if (rcSegment.left > rcLine.right) {
+			break;
+		}
+	}
+}
+
+static void DrawEdgeLine(Surface *surface, const ViewStyle &vsDraw, const LineLayout *ll, PRectangle rcLine,
+	Range lineRange, int xStart) {
+	if (vsDraw.edgeState == EDGE_LINE) {
+		PRectangle rcSegment = rcLine;
+		const int edgeX = static_cast<int>(vsDraw.theEdge.column * vsDraw.spaceWidth);
+		rcSegment.left = static_cast<XYPOSITION>(edgeX + xStart);
+		if ((ll->wrapIndent != 0) && (lineRange.start != 0))
+			rcSegment.left -= ll->wrapIndent;
+		rcSegment.right = rcSegment.left + 1;
+		surface->FillRectangle(rcSegment, vsDraw.theEdge.colour);
+	} else if (vsDraw.edgeState == EDGE_MULTILINE) {
+		for (size_t edge = 0; edge < vsDraw.theMultiEdge.size(); edge++) {
+			if (vsDraw.theMultiEdge[edge].column >= 0) {
+				PRectangle rcSegment = rcLine;
+				const int edgeX = static_cast<int>(vsDraw.theMultiEdge[edge].column * vsDraw.spaceWidth);
+				rcSegment.left = static_cast<XYPOSITION>(edgeX + xStart);
+				if ((ll->wrapIndent != 0) && (lineRange.start != 0))
+					rcSegment.left -= ll->wrapIndent;
+				rcSegment.right = rcSegment.left + 1;
+				surface->FillRectangle(rcSegment, vsDraw.theMultiEdge[edge].colour);
+			}
+		}
+	}
+}
+
+// Draw underline mark as part of background if not transparent
+static void DrawMarkUnderline(Surface *surface, const EditModel &model, const ViewStyle &vsDraw,
+	Sci::Line line, PRectangle rcLine) {
+	int marks = model.pdoc->GetMark(line);
+	for (int markBit = 0; (markBit < 32) && marks; markBit++) {
+		if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_UNDERLINE) &&
+			(vsDraw.markers[markBit].alpha == SC_ALPHA_NOALPHA)) {
+			PRectangle rcUnderline = rcLine;
+			rcUnderline.top = rcUnderline.bottom - 2;
+			surface->FillRectangle(rcUnderline, vsDraw.markers[markBit].back);
+		}
+		marks >>= 1;
+	}
+}
+
+static void DrawTranslucentSelection(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+	Sci::Line line, PRectangle rcLine, int subLine, Range lineRange, int xStart, int tabWidthMinimumPixels) {
+	if ((vsDraw.selAlpha != SC_ALPHA_NOALPHA) || (vsDraw.selAdditionalAlpha != SC_ALPHA_NOALPHA)) {
+		const Sci::Position posLineStart = model.pdoc->LineStart(line);
+		const XYACCUMULATOR subLineStart = ll->positions[lineRange.start];
+		// For each selection draw
+		Sci::Position virtualSpaces = 0;
+		if (subLine == (ll->lines - 1)) {
+			virtualSpaces = model.sel.VirtualSpaceFor(model.pdoc->LineEnd(line));
+		}
+		const SelectionPosition posStart(posLineStart + lineRange.start);
+		const SelectionPosition posEnd(posLineStart + lineRange.end, virtualSpaces);
+		const SelectionSegment virtualSpaceRange(posStart, posEnd);
+		for (size_t r = 0; r < model.sel.Count(); r++) {
+			const int alpha = (r == model.sel.Main()) ? vsDraw.selAlpha : vsDraw.selAdditionalAlpha;
+			if (alpha != SC_ALPHA_NOALPHA) {
+				const SelectionSegment portion = model.sel.Range(r).Intersect(virtualSpaceRange);
+				if (!portion.Empty()) {
+					const XYPOSITION spaceWidth = vsDraw.styles[ll->EndLineStyle()].spaceWidth;
+					if (model.BidirectionalEnabled()) {
+						const int selectionStart = static_cast<int>(portion.start.Position() - posLineStart - lineRange.start);
+						const int selectionEnd = static_cast<int>(portion.end.Position() - posLineStart - lineRange.start);
+
+						const ColourDesired background = SelectionBackground(vsDraw, r == model.sel.Main(), model.primarySelection);
+
+						const ScreenLine screenLine(ll, subLine, vsDraw, rcLine.right, tabWidthMinimumPixels);
+						std::unique_ptr<IScreenLineLayout> slLayout = surface->Layout(&screenLine);
+
+						const std::vector<Interval> intervals = slLayout->FindRangeIntervals(selectionStart, selectionEnd);
+						for (const Interval &interval : intervals) {
+							const XYPOSITION rcRight = interval.right + xStart;
+							const XYPOSITION rcLeft = interval.left + xStart;
+							const PRectangle rcSelection(rcLeft, rcLine.top, rcRight, rcLine.bottom);
+							SimpleAlphaRectangle(surface, rcSelection, background, alpha);
+						}
+
+						if (portion.end.VirtualSpace()) {
+							const XYPOSITION xStartVirtual = ll->positions[lineRange.end] -
+								static_cast<XYPOSITION>(subLineStart) + xStart;
+							PRectangle rcSegment = rcLine;
+							rcSegment.left = xStartVirtual + portion.start.VirtualSpace() * spaceWidth;
+							rcSegment.right = xStartVirtual + portion.end.VirtualSpace() * spaceWidth;
+							SimpleAlphaRectangle(surface, rcSegment, background, alpha);
+						}
+					} else {
+						PRectangle rcSegment = rcLine;
+						rcSegment.left = xStart + ll->positions[portion.start.Position() - posLineStart] -
+							static_cast<XYPOSITION>(subLineStart) + portion.start.VirtualSpace() * spaceWidth;
+						rcSegment.right = xStart + ll->positions[portion.end.Position() - posLineStart] -
+							static_cast<XYPOSITION>(subLineStart) + portion.end.VirtualSpace() * spaceWidth;
+						if ((ll->wrapIndent != 0) && (lineRange.start != 0)) {
+							if ((portion.start.Position() - posLineStart) == lineRange.start && model.sel.Range(r).ContainsCharacter(portion.start.Position() - 1))
+								rcSegment.left -= static_cast<int>(ll->wrapIndent); // indentation added to xStart was truncated to int, so we do the same here
+						}
+						rcSegment.left = (rcSegment.left > rcLine.left) ? rcSegment.left : rcLine.left;
+						rcSegment.right = (rcSegment.right < rcLine.right) ? rcSegment.right : rcLine.right;
+						if (rcSegment.right > rcLine.left)
+							SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw, r == model.sel.Main(), model.primarySelection), alpha);
+					}
+				}
+			}
+		}
+	}
+}
+
+// Draw any translucent whole line states
+static void DrawTranslucentLineState(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+	Sci::Line line, PRectangle rcLine, int subLine) {
+	if ((model.caret.active || vsDraw.alwaysShowCaretLineBackground) && vsDraw.showCaretLineBackground && ll->containsCaret &&
+		vsDraw.caretLineAlpha != SC_ALPHA_NOALPHA) {
+		if (vsDraw.caretLineFrame) {
+			DrawCaretLineFramed(surface, vsDraw, ll, rcLine, subLine);
+		} else {
+			SimpleAlphaRectangle(surface, rcLine, vsDraw.caretLineBackground, vsDraw.caretLineAlpha);
+		}
+	}
+	const int marksOfLine = model.pdoc->GetMark(line);
+	int marksDrawnInText = marksOfLine & vsDraw.maskDrawInText;
+	for (int markBit = 0; (markBit < 32) && marksDrawnInText; markBit++) {
+		if (marksDrawnInText & 1) {
+			if (vsDraw.markers[markBit].markType == SC_MARK_BACKGROUND) {
+				SimpleAlphaRectangle(surface, rcLine, vsDraw.markers[markBit].back, vsDraw.markers[markBit].alpha);
+			} else if (vsDraw.markers[markBit].markType == SC_MARK_UNDERLINE) {
+				PRectangle rcUnderline = rcLine;
+				rcUnderline.top = rcUnderline.bottom - 2;
+				SimpleAlphaRectangle(surface, rcUnderline, vsDraw.markers[markBit].back, vsDraw.markers[markBit].alpha);
+			}
+		}
+		marksDrawnInText >>= 1;
+	}
+	int marksDrawnInLine = marksOfLine & vsDraw.maskInLine;
+	for (int markBit = 0; (markBit < 32) && marksDrawnInLine; markBit++) {
+		if (marksDrawnInLine & 1) {
+			SimpleAlphaRectangle(surface, rcLine, vsDraw.markers[markBit].back, vsDraw.markers[markBit].alpha);
+		}
+		marksDrawnInLine >>= 1;
+	}
+}
+
+void EditView::DrawForeground(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+	Sci::Line lineVisible, PRectangle rcLine, Range lineRange, Sci::Position posLineStart, int xStart,
+	int subLine, ColourOptional background) {
+
+	const bool selBackDrawn = vsDraw.SelectionBackgroundDrawn();
+	const bool drawWhitespaceBackground = vsDraw.WhitespaceBackgroundDrawn() && !background.isSet;
+	bool inIndentation = subLine == 0;	// Do not handle indentation except on first subline.
+
+	const XYACCUMULATOR subLineStart = ll->positions[lineRange.start];
+	const XYPOSITION indentWidth = model.pdoc->IndentSize() * vsDraw.spaceWidth;
+
+	// Does not take margin into account but not significant
+	const int xStartVisible = static_cast<int>(subLineStart)-xStart;
+
+	// Foreground drawing loop
+	BreakFinder bfFore(ll, &model.sel, lineRange, posLineStart, xStartVisible,
+		(((phasesDraw == phasesOne) && selBackDrawn) || vsDraw.selColours.fore.isSet), model.pdoc, &model.reprs, &vsDraw);
+
+	while (bfFore.More()) {
+
+		const TextSegment ts = bfFore.Next();
+		const Sci::Position i = ts.end() - 1;
+		const Sci::Position iDoc = i + posLineStart;
+
+		PRectangle rcSegment = rcLine;
+		rcSegment.left = ll->positions[ts.start] + xStart - static_cast<XYPOSITION>(subLineStart);
+		rcSegment.right = ll->positions[ts.end()] + xStart - static_cast<XYPOSITION>(subLineStart);
+		// Only try to draw if really visible - enhances performance by not calling environment to
+		// draw strings that are completely past the right side of the window.
+		if (rcSegment.Intersects(rcLine)) {
+			const int styleMain = ll->styles[i];
+			ColourDesired textFore = vsDraw.styles[styleMain].fore;
+			FontAlias textFont = vsDraw.styles[styleMain].font;
+			//hotspot foreground
+			const bool inHotspot = (ll->hotspot.Valid()) && ll->hotspot.ContainsCharacter(iDoc);
+			if (inHotspot) {
+				if (vsDraw.hotspotColours.fore.isSet)
+					textFore = vsDraw.hotspotColours.fore;
+			}
+			if (vsDraw.indicatorsSetFore) {
+				// At least one indicator sets the text colour so see if it applies to this segment
+				for (const IDecoration *deco : model.pdoc->decorations->View()) {
+					const int indicatorValue = deco->ValueAt(ts.start + posLineStart);
+					if (indicatorValue) {
+						const Indicator &indicator = vsDraw.indicators[deco->Indicator()];
+						bool hover = false;
+						if (indicator.IsDynamic()) {
+							const Sci::Position startPos = ts.start + posLineStart;
+							const Range rangeRun(deco->StartRun(startPos), deco->EndRun(startPos));
+							hover =	rangeRun.ContainsCharacter(model.hoverIndicatorPos);
+						}
+						if (hover) {
+							if (indicator.sacHover.style == INDIC_TEXTFORE) {
+								textFore = indicator.sacHover.fore;
+							}
+						} else {
+							if (indicator.sacNormal.style == INDIC_TEXTFORE) {
+								if (indicator.Flags() & SC_INDICFLAG_VALUEFORE)
+									textFore = ColourDesired(indicatorValue & SC_INDICVALUEMASK);
+								else
+									textFore = indicator.sacNormal.fore;
+							}
+						}
+					}
+				}
+			}
+			const int inSelection = hideSelection ? 0 : model.sel.CharacterInSelection(iDoc);
+			if (inSelection && (vsDraw.selColours.fore.isSet)) {
+				textFore = (inSelection == 1) ? vsDraw.selColours.fore : vsDraw.selAdditionalForeground;
+			}
+			ColourDesired textBack = TextBackground(model, vsDraw, ll, background, inSelection, inHotspot, styleMain, i);
+			if (ts.representation) {
+				if (ll->chars[i] == '\t') {
+					// Tab display
+					if (phasesDraw == phasesOne) {
+						if (drawWhitespaceBackground && vsDraw.WhiteSpaceVisible(inIndentation))
+							textBack = vsDraw.whitespaceColours.back;
+						surface->FillRectangle(rcSegment, textBack);
+					}
+					if (inIndentation && vsDraw.viewIndentationGuides == ivReal) {
+						for (int indentCount = static_cast<int>((ll->positions[i] + epsilon) / indentWidth);
+							indentCount <= (ll->positions[i + 1] - epsilon) / indentWidth;
+							indentCount++) {
+							if (indentCount > 0) {
+								const XYPOSITION xIndent = std::floor(indentCount * indentWidth);
+								DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIndent + xStart, rcSegment,
+									(ll->xHighlightGuide == xIndent));
+							}
+						}
+					}
+					if (vsDraw.viewWhitespace != wsInvisible) {
+						if (vsDraw.WhiteSpaceVisible(inIndentation)) {
+							if (vsDraw.whitespaceColours.fore.isSet)
+								textFore = vsDraw.whitespaceColours.fore;
+							surface->PenColour(textFore);
+							const PRectangle rcTab(rcSegment.left + 1, rcSegment.top + tabArrowHeight,
+								rcSegment.right - 1, rcSegment.bottom - vsDraw.maxDescent);
+							const int segmentTop = static_cast<int>(rcSegment.top + vsDraw.lineHeight / 2);
+							if (!customDrawTabArrow)
+								DrawTabArrow(surface, rcTab, segmentTop, vsDraw);
+							else
+								customDrawTabArrow(surface, rcTab, segmentTop);
+						}
+					}
+				} else {
+					inIndentation = false;
+					if (vsDraw.controlCharSymbol >= 32) {
+						// Using one font for all control characters so it can be controlled independently to ensure
+						// the box goes around the characters tightly. Seems to be no way to work out what height
+						// is taken by an individual character - internal leading gives varying results.
+						FontAlias ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font;
+						const char cc[2] = { static_cast<char>(vsDraw.controlCharSymbol), '\0' };
+						surface->DrawTextNoClip(rcSegment, ctrlCharsFont,
+							rcSegment.top + vsDraw.maxAscent,
+							cc, textBack, textFore);
+					} else {
+						DrawTextBlob(surface, vsDraw, rcSegment, ts.representation->stringRep,
+							textBack, textFore, phasesDraw == phasesOne);
+					}
+				}
+			} else {
+				// Normal text display
+				if (vsDraw.styles[styleMain].visible) {
+					const std::string_view text(&ll->chars[ts.start], i - ts.start + 1);
+					if (phasesDraw != phasesOne) {
+						surface->DrawTextTransparent(rcSegment, textFont,
+							rcSegment.top + vsDraw.maxAscent, text, textFore);
+					} else {
+						surface->DrawTextNoClip(rcSegment, textFont,
+							rcSegment.top + vsDraw.maxAscent, text, textFore, textBack);
+					}
+				}
+				if (vsDraw.viewWhitespace != wsInvisible ||
+					(inIndentation && vsDraw.viewIndentationGuides != ivNone)) {
+					for (int cpos = 0; cpos <= i - ts.start; cpos++) {
+						if (ll->chars[cpos + ts.start] == ' ') {
+							if (vsDraw.viewWhitespace != wsInvisible) {
+								if (vsDraw.whitespaceColours.fore.isSet)
+									textFore = vsDraw.whitespaceColours.fore;
+								if (vsDraw.WhiteSpaceVisible(inIndentation)) {
+									const XYPOSITION xmid = (ll->positions[cpos + ts.start] + ll->positions[cpos + ts.start + 1]) / 2;
+									if ((phasesDraw == phasesOne) && drawWhitespaceBackground) {
+										textBack = vsDraw.whitespaceColours.back;
+										const PRectangle rcSpace(
+											ll->positions[cpos + ts.start] + xStart - static_cast<XYPOSITION>(subLineStart),
+											rcSegment.top,
+											ll->positions[cpos + ts.start + 1] + xStart - static_cast<XYPOSITION>(subLineStart),
+											rcSegment.bottom);
+										surface->FillRectangle(rcSpace, textBack);
+									}
+									const int halfDotWidth = vsDraw.whitespaceSize / 2;
+									PRectangle rcDot(xmid + xStart - halfDotWidth - static_cast<XYPOSITION>(subLineStart),
+										rcSegment.top + vsDraw.lineHeight / 2, 0.0f, 0.0f);
+									rcDot.right = rcDot.left + vsDraw.whitespaceSize;
+									rcDot.bottom = rcDot.top + vsDraw.whitespaceSize;
+									surface->FillRectangle(rcDot, textFore);
+								}
+							}
+							if (inIndentation && vsDraw.viewIndentationGuides == ivReal) {
+								for (int indentCount = static_cast<int>((ll->positions[cpos + ts.start] + epsilon) / indentWidth);
+									indentCount <= (ll->positions[cpos + ts.start + 1] - epsilon) / indentWidth;
+									indentCount++) {
+									if (indentCount > 0) {
+										const XYPOSITION xIndent = std::floor(indentCount * indentWidth);
+										DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIndent + xStart, rcSegment,
+											(ll->xHighlightGuide == xIndent));
+									}
+								}
+							}
+						} else {
+							inIndentation = false;
+						}
+					}
+				}
+			}
+			if (ll->hotspot.Valid() && vsDraw.hotspotUnderline && ll->hotspot.ContainsCharacter(iDoc)) {
+				PRectangle rcUL = rcSegment;
+				rcUL.top = rcUL.top + vsDraw.maxAscent + 1;
+				rcUL.bottom = rcUL.top + 1;
+				if (vsDraw.hotspotColours.fore.isSet)
+					surface->FillRectangle(rcUL, vsDraw.hotspotColours.fore);
+				else
+					surface->FillRectangle(rcUL, textFore);
+			} else if (vsDraw.styles[styleMain].underline) {
+				PRectangle rcUL = rcSegment;
+				rcUL.top = rcUL.top + vsDraw.maxAscent + 1;
+				rcUL.bottom = rcUL.top + 1;
+				surface->FillRectangle(rcUL, textFore);
+			}
+		} else if (rcSegment.left > rcLine.right) {
+			break;
+		}
+	}
+}
+
+void EditView::DrawIndentGuidesOverEmpty(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+	Sci::Line line, Sci::Line lineVisible, PRectangle rcLine, int xStart, int subLine) {
+	if ((vsDraw.viewIndentationGuides == ivLookForward || vsDraw.viewIndentationGuides == ivLookBoth)
+		&& (subLine == 0)) {
+		const Sci::Position posLineStart = model.pdoc->LineStart(line);
+		int indentSpace = model.pdoc->GetLineIndentation(line);
+		int xStartText = static_cast<int>(ll->positions[model.pdoc->GetLineIndentPosition(line) - posLineStart]);
+
+		// Find the most recent line with some text
+
+		Sci::Line lineLastWithText = line;
+		while (lineLastWithText > std::max(line - 20, static_cast<Sci::Line>(0)) && model.pdoc->IsWhiteLine(lineLastWithText)) {
+			lineLastWithText--;
+		}
+		if (lineLastWithText < line) {
+			xStartText = 100000;	// Don't limit to visible indentation on empty line
+			// This line is empty, so use indentation of last line with text
+			int indentLastWithText = model.pdoc->GetLineIndentation(lineLastWithText);
+			const int isFoldHeader = model.pdoc->GetLevel(lineLastWithText) & SC_FOLDLEVELHEADERFLAG;
+			if (isFoldHeader) {
+				// Level is one more level than parent
+				indentLastWithText += model.pdoc->IndentSize();
+			}
+			if (vsDraw.viewIndentationGuides == ivLookForward) {
+				// In viLookForward mode, previous line only used if it is a fold header
+				if (isFoldHeader) {
+					indentSpace = std::max(indentSpace, indentLastWithText);
+				}
+			} else {	// viLookBoth
+				indentSpace = std::max(indentSpace, indentLastWithText);
+			}
+		}
+
+		Sci::Line lineNextWithText = line;
+		while (lineNextWithText < std::min(line + 20, model.pdoc->LinesTotal()) && model.pdoc->IsWhiteLine(lineNextWithText)) {
+			lineNextWithText++;
+		}
+		if (lineNextWithText > line) {
+			xStartText = 100000;	// Don't limit to visible indentation on empty line
+			// This line is empty, so use indentation of first next line with text
+			indentSpace = std::max(indentSpace,
+				model.pdoc->GetLineIndentation(lineNextWithText));
+		}
+
+		for (int indentPos = model.pdoc->IndentSize(); indentPos < indentSpace; indentPos += model.pdoc->IndentSize()) {
+			const XYPOSITION xIndent = std::floor(indentPos * vsDraw.spaceWidth);
+			if (xIndent < xStartText) {
+				DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIndent + xStart, rcLine,
+					(ll->xHighlightGuide == xIndent));
+			}
+		}
+	}
+}
+
+void EditView::DrawLine(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+	Sci::Line line, Sci::Line lineVisible, int xStart, PRectangle rcLine, int subLine, DrawPhase phase) {
+
+	if (subLine >= ll->lines) {
+		DrawAnnotation(surface, model, vsDraw, ll, line, xStart, rcLine, subLine, phase);
+		return; // No further drawing
+	}
+
+	// See if something overrides the line background colour.
+	const ColourOptional background = vsDraw.Background(model.pdoc->GetMark(line), model.caret.active, ll->containsCaret);
+
+	const Sci::Position posLineStart = model.pdoc->LineStart(line);
+
+	const Range lineRange = ll->SubLineRange(subLine, LineLayout::Scope::visibleOnly);
+	const Range lineRangeIncludingEnd = ll->SubLineRange(subLine, LineLayout::Scope::includeEnd);
+	const XYACCUMULATOR subLineStart = ll->positions[lineRange.start];
+
+	if ((ll->wrapIndent != 0) && (subLine > 0)) {
+		if (phase & drawBack) {
+			DrawWrapIndentAndMarker(surface, vsDraw, ll, xStart, rcLine, background, customDrawWrapMarker, model.caret.active);
+		}
+		xStart += static_cast<int>(ll->wrapIndent);
+	}
+
+	if (phasesDraw != phasesOne) {
+		if (phase & drawBack) {
+			DrawBackground(surface, model, vsDraw, ll, rcLine, lineRange, posLineStart, xStart,
+				subLine, background);
+			DrawFoldDisplayText(surface, model, vsDraw, ll, line, xStart, rcLine, subLine, subLineStart, drawBack);
+			DrawEOLAnnotationText(surface, model, vsDraw, ll, line, xStart, rcLine, subLine, subLineStart, drawBack);
+			phase = static_cast<DrawPhase>(phase & ~drawBack);	// Remove drawBack to not draw again in DrawFoldDisplayText
+			DrawEOL(surface, model, vsDraw, ll, rcLine, line, lineRange.end,
+				xStart, subLine, subLineStart, background);
+			if (vsDraw.IsLineFrameOpaque(model.caret.active, ll->containsCaret))
+				DrawCaretLineFramed(surface, vsDraw, ll, rcLine, subLine);
+		}
+
+		if (phase & drawIndicatorsBack) {
+			DrawIndicators(surface, model, vsDraw, ll, line, xStart, rcLine, subLine,
+				lineRangeIncludingEnd.end, true, tabWidthMinimumPixels);
+			DrawEdgeLine(surface, vsDraw, ll, rcLine, lineRange, xStart);
+			DrawMarkUnderline(surface, model, vsDraw, line, rcLine);
+		}
+	}
+
+	if (phase & drawText) {
+		DrawForeground(surface, model, vsDraw, ll, lineVisible, rcLine, lineRange, posLineStart, xStart,
+			subLine, background);
+	}
+
+	if (phase & drawIndentationGuides) {
+		DrawIndentGuidesOverEmpty(surface, model, vsDraw, ll, line, lineVisible, rcLine, xStart, subLine);
+	}
+
+	if (phase & drawIndicatorsFore) {
+		DrawIndicators(surface, model, vsDraw, ll, line, xStart, rcLine, subLine,
+			lineRangeIncludingEnd.end, false, tabWidthMinimumPixels);
+	}
+
+	DrawFoldDisplayText(surface, model, vsDraw, ll, line, xStart, rcLine, subLine, subLineStart, phase);
+	DrawEOLAnnotationText(surface, model, vsDraw, ll, line, xStart, rcLine, subLine, subLineStart, phase);
+
+	if (phasesDraw == phasesOne) {
+		DrawEOL(surface, model, vsDraw, ll, rcLine, line, lineRange.end,
+			xStart, subLine, subLineStart, background);
+		if (vsDraw.IsLineFrameOpaque(model.caret.active, ll->containsCaret))
+			DrawCaretLineFramed(surface, vsDraw, ll, rcLine, subLine);
+		DrawEdgeLine(surface, vsDraw, ll, rcLine, lineRange, xStart);
+		DrawMarkUnderline(surface, model, vsDraw, line, rcLine);
+	}
+
+	if (!hideSelection && (phase & drawSelectionTranslucent)) {
+		DrawTranslucentSelection(surface, model, vsDraw, ll, line, rcLine, subLine, lineRange, xStart, tabWidthMinimumPixels);
+	}
+
+	if (phase & drawLineTranslucent) {
+		DrawTranslucentLineState(surface, model, vsDraw, ll, line, rcLine, subLine);
+	}
+}
+
+static void DrawFoldLines(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, Sci::Line line, PRectangle rcLine) {
+	const bool expanded = model.pcs->GetExpanded(line);
+	const int level = model.pdoc->GetLevel(line);
+	const int levelNext = model.pdoc->GetLevel(line + 1);
+	if ((level & SC_FOLDLEVELHEADERFLAG) &&
+		(LevelNumber(level) < LevelNumber(levelNext))) {
+		// Paint the line above the fold
+		if ((expanded && (model.foldFlags & SC_FOLDFLAG_LINEBEFORE_EXPANDED))
+			||
+			(!expanded && (model.foldFlags & SC_FOLDFLAG_LINEBEFORE_CONTRACTED))) {
+			PRectangle rcFoldLine = rcLine;
+			rcFoldLine.bottom = rcFoldLine.top + 1;
+			surface->FillRectangle(rcFoldLine, vsDraw.styles[STYLE_DEFAULT].fore);
+		}
+		// Paint the line below the fold
+		if ((expanded && (model.foldFlags & SC_FOLDFLAG_LINEAFTER_EXPANDED))
+			||
+			(!expanded && (model.foldFlags & SC_FOLDFLAG_LINEAFTER_CONTRACTED))) {
+			PRectangle rcFoldLine = rcLine;
+			rcFoldLine.top = rcFoldLine.bottom - 1;
+			surface->FillRectangle(rcFoldLine, vsDraw.styles[STYLE_DEFAULT].fore);
+		}
+	}
+}
+
+void EditView::PaintText(Surface *surfaceWindow, const EditModel &model, PRectangle rcArea,
+	PRectangle rcClient, const ViewStyle &vsDraw) {
+	// Allow text at start of line to overlap 1 pixel into the margin as this displays
+	// serifs and italic stems for aliased text.
+	const int leftTextOverlap = ((model.xOffset == 0) && (vsDraw.leftMarginWidth > 0)) ? 1 : 0;
+
+	// Do the painting
+	if (rcArea.right > vsDraw.textStart - leftTextOverlap) {
+
+		Surface *surface = surfaceWindow;
+		if (bufferedDraw) {
+			surface = pixmapLine.get();
+			PLATFORM_ASSERT(pixmapLine->Initialised());
+		}
+		surface->SetUnicodeMode(SC_CP_UTF8 == model.pdoc->dbcsCodePage);
+		surface->SetDBCSMode(model.pdoc->dbcsCodePage);
+		surface->SetBidiR2L(model.BidirectionalR2L());
+
+		const Point ptOrigin = model.GetVisibleOriginInMain();
+
+		const int screenLinePaintFirst = static_cast<int>(rcArea.top) / vsDraw.lineHeight;
+		const int xStart = vsDraw.textStart - model.xOffset + static_cast<int>(ptOrigin.x);
+
+		SelectionPosition posCaret = model.sel.RangeMain().caret;
+		if (model.posDrag.IsValid())
+			posCaret = model.posDrag;
+		const Sci::Line lineCaret = model.pdoc->SciLineFromPosition(posCaret.Position());
+
+		PRectangle rcTextArea = rcClient;
+		if (vsDraw.marginInside) {
+			rcTextArea.left += vsDraw.textStart;
+			rcTextArea.right -= vsDraw.rightMarginWidth;
+		} else {
+			rcTextArea = rcArea;
+		}
+
+		// Remove selection margin from drawing area so text will not be drawn
+		// on it in unbuffered mode.
+		if (!bufferedDraw && vsDraw.marginInside) {
+			PRectangle rcClipText = rcTextArea;
+			rcClipText.left -= leftTextOverlap;
+			surfaceWindow->SetClip(rcClipText);
+		}
+
+		// Loop on visible lines
+#if defined(TIME_PAINTING)
+		double durLayout = 0.0;
+		double durPaint = 0.0;
+		double durCopy = 0.0;
+		ElapsedPeriod epWhole;
+#endif
+		const bool bracesIgnoreStyle = ((vsDraw.braceHighlightIndicatorSet && (model.bracesMatchStyle == STYLE_BRACELIGHT)) ||
+			(vsDraw.braceBadLightIndicatorSet && (model.bracesMatchStyle == STYLE_BRACEBAD)));
+
+		Sci::Line lineDocPrevious = -1;	// Used to avoid laying out one document line multiple times
+		AutoLineLayout ll(llc, nullptr);
+		std::vector<DrawPhase> phases;
+		if ((phasesDraw == phasesMultiple) && !bufferedDraw) {
+			for (DrawPhase phase = drawBack; phase <= drawCarets; phase = static_cast<DrawPhase>(phase * 2)) {
+				phases.push_back(phase);
+			}
+		} else {
+			phases.push_back(drawAll);
+		}
+		for (const DrawPhase &phase : phases) {
+			int ypos = 0;
+			if (!bufferedDraw)
+				ypos += screenLinePaintFirst * vsDraw.lineHeight;
+			int yposScreen = screenLinePaintFirst * vsDraw.lineHeight;
+			Sci::Line visibleLine = model.TopLineOfMain() + screenLinePaintFirst;
+			while (visibleLine < model.pcs->LinesDisplayed() && yposScreen < rcArea.bottom) {
+
+				const Sci::Line lineDoc = model.pcs->DocFromDisplay(visibleLine);
+				// Only visible lines should be handled by the code within the loop
+				PLATFORM_ASSERT(model.pcs->GetVisible(lineDoc));
+				const Sci::Line lineStartSet = model.pcs->DisplayFromDoc(lineDoc);
+				const int subLine = static_cast<int>(visibleLine - lineStartSet);
+
+				// Copy this line and its styles from the document into local arrays
+				// and determine the x position at which each character starts.
+#if defined(TIME_PAINTING)
+				ElapsedPeriod ep;
+#endif
+				if (lineDoc != lineDocPrevious) {
+					ll.Set(nullptr);
+					ll.Set(RetrieveLineLayout(lineDoc, model));
+					LayoutLine(model, lineDoc, surface, vsDraw, ll, model.wrapWidth);
+					lineDocPrevious = lineDoc;
+				}
+#if defined(TIME_PAINTING)
+				durLayout += ep.Duration(true);
+#endif
+				if (ll) {
+					ll->containsCaret = !hideSelection && (lineDoc == lineCaret);
+					ll->hotspot = model.GetHotSpotRange();
+
+					PRectangle rcLine = rcTextArea;
+					rcLine.top = static_cast<XYPOSITION>(ypos);
+					rcLine.bottom = static_cast<XYPOSITION>(ypos + vsDraw.lineHeight);
+
+					const Range rangeLine(model.pdoc->LineStart(lineDoc),
+						model.pdoc->LineStart(lineDoc + 1));
+
+					// Highlight the current braces if any
+					ll->SetBracesHighlight(rangeLine, model.braces, static_cast<char>(model.bracesMatchStyle),
+						static_cast<int>(model.highlightGuideColumn * vsDraw.spaceWidth), bracesIgnoreStyle);
+
+					if (leftTextOverlap && (bufferedDraw || ((phasesDraw < phasesMultiple) && (phase & drawBack)))) {
+						// Clear the left margin
+						PRectangle rcSpacer = rcLine;
+						rcSpacer.right = rcSpacer.left;
+						rcSpacer.left -= 1;
+						surface->FillRectangle(rcSpacer, vsDraw.styles[STYLE_DEFAULT].back);
+					}
+
+					if (model.BidirectionalEnabled()) {
+						// Fill the line bidi data
+						UpdateBidiData(model, vsDraw, ll);
+					}
+
+					DrawLine(surface, model, vsDraw, ll, lineDoc, visibleLine, xStart, rcLine, subLine, phase);
+#if defined(TIME_PAINTING)
+					durPaint += ep.Duration(true);
+#endif
+					// Restore the previous styles for the brace highlights in case layout is in cache.
+					ll->RestoreBracesHighlight(rangeLine, model.braces, bracesIgnoreStyle);
+
+					if (phase & drawFoldLines) {
+						DrawFoldLines(surface, model, vsDraw, lineDoc, rcLine);
+					}
+
+					if (phase & drawCarets) {
+						DrawCarets(surface, model, vsDraw, ll, lineDoc, xStart, rcLine, subLine);
+					}
+
+					if (bufferedDraw) {
+						const Point from = Point::FromInts(vsDraw.textStart - leftTextOverlap, 0);
+						const PRectangle rcCopyArea = PRectangle::FromInts(vsDraw.textStart - leftTextOverlap, yposScreen,
+							static_cast<int>(rcClient.right - vsDraw.rightMarginWidth),
+							yposScreen + vsDraw.lineHeight);
+						surfaceWindow->Copy(rcCopyArea, from, *pixmapLine);
+					}
+
+					lineWidthMaxSeen = std::max(
+						lineWidthMaxSeen, static_cast<int>(ll->positions[ll->numCharsInLine]));
+#if defined(TIME_PAINTING)
+					durCopy += ep.Duration(true);
+#endif
+				}
+
+				if (!bufferedDraw) {
+					ypos += vsDraw.lineHeight;
+				}
+
+				yposScreen += vsDraw.lineHeight;
+				visibleLine++;
+			}
+		}
+		ll.Set(nullptr);
+#if defined(TIME_PAINTING)
+		if (durPaint < 0.00000001)
+			durPaint = 0.00000001;
+#endif
+		// Right column limit indicator
+		PRectangle rcBeyondEOF = (vsDraw.marginInside) ? rcClient : rcArea;
+		rcBeyondEOF.left = static_cast<XYPOSITION>(vsDraw.textStart);
+		rcBeyondEOF.right = rcBeyondEOF.right - ((vsDraw.marginInside) ? vsDraw.rightMarginWidth : 0);
+		rcBeyondEOF.top = static_cast<XYPOSITION>((model.pcs->LinesDisplayed() - model.TopLineOfMain()) * vsDraw.lineHeight);
+		if (rcBeyondEOF.top < rcBeyondEOF.bottom) {
+			surfaceWindow->FillRectangle(rcBeyondEOF, vsDraw.styles[STYLE_DEFAULT].back);
+			if (vsDraw.edgeState == EDGE_LINE) {
+				const int edgeX = static_cast<int>(vsDraw.theEdge.column * vsDraw.spaceWidth);
+				rcBeyondEOF.left = static_cast<XYPOSITION>(edgeX + xStart);
+				rcBeyondEOF.right = rcBeyondEOF.left + 1;
+				surfaceWindow->FillRectangle(rcBeyondEOF, vsDraw.theEdge.colour);
+			} else if (vsDraw.edgeState == EDGE_MULTILINE) {
+				for (size_t edge = 0; edge < vsDraw.theMultiEdge.size(); edge++) {
+					if (vsDraw.theMultiEdge[edge].column >= 0) {
+						const int edgeX = static_cast<int>(vsDraw.theMultiEdge[edge].column * vsDraw.spaceWidth);
+						rcBeyondEOF.left = static_cast<XYPOSITION>(edgeX + xStart);
+						rcBeyondEOF.right = rcBeyondEOF.left + 1;
+						surfaceWindow->FillRectangle(rcBeyondEOF, vsDraw.theMultiEdge[edge].colour);
+					}
+				}
+			}
+		}
+		//Platform::DebugPrintf("start display %d, offset = %d\n", model.pdoc->Length(), model.xOffset);
+#if defined(TIME_PAINTING)
+		Platform::DebugPrintf(
+		"Layout:%9.6g    Paint:%9.6g    Ratio:%9.6g   Copy:%9.6g   Total:%9.6g\n",
+		durLayout, durPaint, durLayout / durPaint, durCopy, epWhole.Duration());
+#endif
+	}
+}
+
+void EditView::FillLineRemainder(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+	Sci::Line line, PRectangle rcArea, int subLine) const {
+		int eolInSelection = 0;
+		int alpha = SC_ALPHA_NOALPHA;
+		if (!hideSelection) {
+			const Sci::Position posAfterLineEnd = model.pdoc->LineStart(line + 1);
+			eolInSelection = (subLine == (ll->lines - 1)) ? model.sel.InSelectionForEOL(posAfterLineEnd) : 0;
+			alpha = (eolInSelection == 1) ? vsDraw.selAlpha : vsDraw.selAdditionalAlpha;
+		}
+
+		const ColourOptional background = vsDraw.Background(model.pdoc->GetMark(line), model.caret.active, ll->containsCaret);
+
+		if (eolInSelection && vsDraw.selEOLFilled && vsDraw.selColours.back.isSet && (line < model.pdoc->LinesTotal() - 1) && (alpha == SC_ALPHA_NOALPHA)) {
+			surface->FillRectangle(rcArea, SelectionBackground(vsDraw, eolInSelection == 1, model.primarySelection));
+		} else {
+			if (background.isSet) {
+				surface->FillRectangle(rcArea, background);
+			} else if (vsDraw.styles[ll->styles[ll->numCharsInLine]].eolFilled) {
+				surface->FillRectangle(rcArea, vsDraw.styles[ll->styles[ll->numCharsInLine]].back);
+			} else {
+				surface->FillRectangle(rcArea, vsDraw.styles[STYLE_DEFAULT].back);
+			}
+			if (eolInSelection && vsDraw.selEOLFilled && vsDraw.selColours.back.isSet && (line < model.pdoc->LinesTotal() - 1) && (alpha != SC_ALPHA_NOALPHA)) {
+				SimpleAlphaRectangle(surface, rcArea, SelectionBackground(vsDraw, eolInSelection == 1, model.primarySelection), alpha);
+			}
+		}
+}
+
+// Space (3 space characters) between line numbers and text when printing.
+#define lineNumberPrintSpace "   "
+
+static ColourDesired InvertedLight(ColourDesired orig) noexcept {
+	unsigned int r = orig.GetRed();
+	unsigned int g = orig.GetGreen();
+	unsigned int b = orig.GetBlue();
+	const unsigned int l = (r + g + b) / 3; 	// There is a better calculation for this that matches human eye
+	const unsigned int il = 0xff - l;
+	if (l == 0)
+		return ColourDesired(0xff, 0xff, 0xff);
+	r = r * il / l;
+	g = g * il / l;
+	b = b * il / l;
+	return ColourDesired(std::min(r, 0xffu), std::min(g, 0xffu), std::min(b, 0xffu));
+}
+
+Sci::Position EditView::FormatRange(bool draw, const Sci_RangeToFormat *pfr, Surface *surface, Surface *surfaceMeasure,
+	const EditModel &model, const ViewStyle &vs) {
+	// Can't use measurements cached for screen
+	posCache.Clear();
+
+	ViewStyle vsPrint(vs);
+	vsPrint.technology = SC_TECHNOLOGY_DEFAULT;
+
+	// Modify the view style for printing as do not normally want any of the transient features to be printed
+	// Printing supports only the line number margin.
+	int lineNumberIndex = -1;
+	for (size_t margin = 0; margin < vs.ms.size(); margin++) {
+		if ((vsPrint.ms[margin].style == SC_MARGIN_NUMBER) && (vsPrint.ms[margin].width > 0)) {
+			lineNumberIndex = static_cast<int>(margin);
+		} else {
+			vsPrint.ms[margin].width = 0;
+		}
+	}
+	vsPrint.fixedColumnWidth = 0;
+	vsPrint.zoomLevel = printParameters.magnification;
+	// Don't show indentation guides
+	// If this ever gets changed, cached pixmap would need to be recreated if technology != SC_TECHNOLOGY_DEFAULT
+	vsPrint.viewIndentationGuides = ivNone;
+	// Don't show the selection when printing
+	vsPrint.selColours.back.isSet = false;
+	vsPrint.selColours.fore.isSet = false;
+	vsPrint.selAlpha = SC_ALPHA_NOALPHA;
+	vsPrint.selAdditionalAlpha = SC_ALPHA_NOALPHA;
+	vsPrint.whitespaceColours.back.isSet = false;
+	vsPrint.whitespaceColours.fore.isSet = false;
+	vsPrint.showCaretLineBackground = false;
+	vsPrint.alwaysShowCaretLineBackground = false;
+	// Don't highlight matching braces using indicators
+	vsPrint.braceHighlightIndicatorSet = false;
+	vsPrint.braceBadLightIndicatorSet = false;
+
+	// Set colours for printing according to users settings
+	for (size_t sty = 0; sty < vsPrint.styles.size(); sty++) {
+		if (printParameters.colourMode == SC_PRINT_INVERTLIGHT) {
+			vsPrint.styles[sty].fore = InvertedLight(vsPrint.styles[sty].fore);
+			vsPrint.styles[sty].back = InvertedLight(vsPrint.styles[sty].back);
+		} else if (printParameters.colourMode == SC_PRINT_BLACKONWHITE) {
+			vsPrint.styles[sty].fore = ColourDesired(0, 0, 0);
+			vsPrint.styles[sty].back = ColourDesired(0xff, 0xff, 0xff);
+		} else if (printParameters.colourMode == SC_PRINT_COLOURONWHITE) {
+			vsPrint.styles[sty].back = ColourDesired(0xff, 0xff, 0xff);
+		} else if (printParameters.colourMode == SC_PRINT_COLOURONWHITEDEFAULTBG) {
+			if (sty <= STYLE_DEFAULT) {
+				vsPrint.styles[sty].back = ColourDesired(0xff, 0xff, 0xff);
+			}
+		}
+	}
+	// White background for the line numbers if SC_PRINT_SCREENCOLOURS isn't used
+	if (printParameters.colourMode != SC_PRINT_SCREENCOLOURS)
+		vsPrint.styles[STYLE_LINENUMBER].back = ColourDesired(0xff, 0xff, 0xff);
+
+	// Printing uses different margins, so reset screen margins
+	vsPrint.leftMarginWidth = 0;
+	vsPrint.rightMarginWidth = 0;
+
+	vsPrint.Refresh(*surfaceMeasure, model.pdoc->tabInChars);
+	// Determining width must happen after fonts have been realised in Refresh
+	int lineNumberWidth = 0;
+	if (lineNumberIndex >= 0) {
+		lineNumberWidth = static_cast<int>(surfaceMeasure->WidthText(vsPrint.styles[STYLE_LINENUMBER].font,
+			"99999" lineNumberPrintSpace));
+		vsPrint.ms[lineNumberIndex].width = lineNumberWidth;
+		vsPrint.Refresh(*surfaceMeasure, model.pdoc->tabInChars);	// Recalculate fixedColumnWidth
+	}
+
+	const Sci::Line linePrintStart = model.pdoc->SciLineFromPosition(pfr->chrg.cpMin);
+	Sci::Line linePrintLast = linePrintStart + (pfr->rc.bottom - pfr->rc.top) / vsPrint.lineHeight - 1;
+	if (linePrintLast < linePrintStart)
+		linePrintLast = linePrintStart;
+	const Sci::Line linePrintMax = model.pdoc->SciLineFromPosition(pfr->chrg.cpMax);
+	if (linePrintLast > linePrintMax)
+		linePrintLast = linePrintMax;
+	//Platform::DebugPrintf("Formatting lines=[%0d,%0d,%0d] top=%0d bottom=%0d line=%0d %0d\n",
+	//      linePrintStart, linePrintLast, linePrintMax, pfr->rc.top, pfr->rc.bottom, vsPrint.lineHeight,
+	//      surfaceMeasure->Height(vsPrint.styles[STYLE_LINENUMBER].font));
+	Sci::Position endPosPrint = model.pdoc->Length();
+	if (linePrintLast < model.pdoc->LinesTotal())
+		endPosPrint = model.pdoc->LineStart(linePrintLast + 1);
+
+	// Ensure we are styled to where we are formatting.
+	model.pdoc->EnsureStyledTo(endPosPrint);
+
+	const int xStart = vsPrint.fixedColumnWidth + pfr->rc.left;
+	int ypos = pfr->rc.top;
+
+	Sci::Line lineDoc = linePrintStart;
+
+	Sci::Position nPrintPos = pfr->chrg.cpMin;
+	int visibleLine = 0;
+	int widthPrint = pfr->rc.right - pfr->rc.left - vsPrint.fixedColumnWidth;
+	if (printParameters.wrapState == WrapMode::none)
+		widthPrint = LineLayout::wrapWidthInfinite;
+
+	while (lineDoc <= linePrintLast && ypos < pfr->rc.bottom) {
+
+		// When printing, the hdc and hdcTarget may be the same, so
+		// changing the state of surfaceMeasure may change the underlying
+		// state of surface. Therefore, any cached state is discarded before
+		// using each surface.
+		surfaceMeasure->FlushCachedState();
+
+		// Copy this line and its styles from the document into local arrays
+		// and determine the x position at which each character starts.
+		LineLayout ll(static_cast<int>(model.pdoc->LineStart(lineDoc + 1) - model.pdoc->LineStart(lineDoc) + 1));
+		LayoutLine(model, lineDoc, surfaceMeasure, vsPrint, &ll, widthPrint);
+
+		ll.containsCaret = false;
+
+		PRectangle rcLine = PRectangle::FromInts(
+			pfr->rc.left,
+			ypos,
+			pfr->rc.right - 1,
+			ypos + vsPrint.lineHeight);
+
+		// When document line is wrapped over multiple display lines, find where
+		// to start printing from to ensure a particular position is on the first
+		// line of the page.
+		if (visibleLine == 0) {
+			const Sci::Position startWithinLine = nPrintPos -
+				model.pdoc->LineStart(lineDoc);
+			for (int iwl = 0; iwl < ll.lines - 1; iwl++) {
+				if (ll.LineStart(iwl) <= startWithinLine && ll.LineStart(iwl + 1) >= startWithinLine) {
+					visibleLine = -iwl;
+				}
+			}
+
+			if (ll.lines > 1 && startWithinLine >= ll.LineStart(ll.lines - 1)) {
+				visibleLine = -(ll.lines - 1);
+			}
+		}
+
+		if (draw && lineNumberWidth &&
+			(ypos + vsPrint.lineHeight <= pfr->rc.bottom) &&
+			(visibleLine >= 0)) {
+			const std::string number = std::to_string(lineDoc + 1) + lineNumberPrintSpace;
+			PRectangle rcNumber = rcLine;
+			rcNumber.right = rcNumber.left + lineNumberWidth;
+			// Right justify
+			rcNumber.left = rcNumber.right - surfaceMeasure->WidthText(
+				vsPrint.styles[STYLE_LINENUMBER].font, number);
+			surface->FlushCachedState();
+			surface->DrawTextNoClip(rcNumber, vsPrint.styles[STYLE_LINENUMBER].font,
+				static_cast<XYPOSITION>(ypos + vsPrint.maxAscent), number,
+				vsPrint.styles[STYLE_LINENUMBER].fore,
+				vsPrint.styles[STYLE_LINENUMBER].back);
+		}
+
+		// Draw the line
+		surface->FlushCachedState();
+
+		for (int iwl = 0; iwl < ll.lines; iwl++) {
+			if (ypos + vsPrint.lineHeight <= pfr->rc.bottom) {
+				if (visibleLine >= 0) {
+					if (draw) {
+						rcLine.top = static_cast<XYPOSITION>(ypos);
+						rcLine.bottom = static_cast<XYPOSITION>(ypos + vsPrint.lineHeight);
+						DrawLine(surface, model, vsPrint, &ll, lineDoc, visibleLine, xStart, rcLine, iwl, drawAll);
+					}
+					ypos += vsPrint.lineHeight;
+				}
+				visibleLine++;
+				if (iwl == ll.lines - 1)
+					nPrintPos = model.pdoc->LineStart(lineDoc + 1);
+				else
+					nPrintPos += ll.LineStart(iwl + 1) - ll.LineStart(iwl);
+			}
+		}
+
+		++lineDoc;
+	}
+
+	// Clear cache so measurements are not used for screen
+	posCache.Clear();
+
+	return nPrintPos;
+}
diff --git a/Pythonwin/Scintilla/src/EditView.h b/Pythonwin/Scintilla/src/EditView.h
new file mode 100644
index 000000000..8f544f280
--- /dev/null
+++ b/Pythonwin/Scintilla/src/EditView.h
@@ -0,0 +1,190 @@
+// Scintilla source code edit control
+/** @file EditView.h
+ ** Defines the appearance of the main text area of the editor window.
+ **/
+// Copyright 1998-2014 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef EDITVIEW_H
+#define EDITVIEW_H
+
+namespace Scintilla {
+
+struct PrintParameters {
+	int magnification;
+	int colourMode;
+	WrapMode wrapState;
+	PrintParameters() noexcept;
+};
+
+/**
+* The view may be drawn in separate phases.
+*/
+enum DrawPhase {
+	drawBack = 0x1,
+	drawIndicatorsBack = 0x2,
+	drawText = 0x4,
+	drawIndentationGuides = 0x8,
+	drawIndicatorsFore = 0x10,
+	drawSelectionTranslucent = 0x20,
+	drawLineTranslucent = 0x40,
+	drawFoldLines = 0x80,
+	drawCarets = 0x100,
+	drawAll = 0x1FF
+};
+
+bool ValidStyledText(const ViewStyle &vs, size_t styleOffset, const StyledText &st) noexcept;
+int WidestLineWidth(Surface *surface, const ViewStyle &vs, int styleOffset, const StyledText &st);
+void DrawTextNoClipPhase(Surface *surface, PRectangle rc, const Style &style, XYPOSITION ybase,
+	std::string_view text, DrawPhase phase);
+void DrawStyledText(Surface *surface, const ViewStyle &vs, int styleOffset, PRectangle rcText,
+	const StyledText &st, size_t start, size_t length, DrawPhase phase);
+
+typedef void (*DrawTabArrowFn)(Surface *surface, PRectangle rcTab, int ymid);
+
+class LineTabstops;
+
+/**
+* EditView draws the main text area.
+*/
+class EditView {
+public:
+	PrintParameters printParameters;
+	std::unique_ptr<LineTabstops> ldTabstops;
+	int tabWidthMinimumPixels;
+
+	bool hideSelection;
+	bool drawOverstrikeCaret; // used by the curses platform
+
+	/** In bufferedDraw mode, graphics operations are drawn to a pixmap and then copied to
+	* the screen. This avoids flashing but is about 30% slower. */
+	bool bufferedDraw;
+	/** In phasesTwo mode, drawing is performed in two phases, first the background
+	* and then the foreground. This avoids chopping off characters that overlap the next run.
+	* In multiPhaseDraw mode, drawing is performed in multiple phases with each phase drawing
+	* one feature over the whole drawing area, instead of within one line. This allows text to
+	* overlap from one line to the next. */
+	enum PhasesDraw { phasesOne, phasesTwo, phasesMultiple };
+	PhasesDraw phasesDraw;
+
+	int lineWidthMaxSeen;
+
+	bool additionalCaretsBlink;
+	bool additionalCaretsVisible;
+
+	bool imeCaretBlockOverride;
+
+	std::unique_ptr<Surface> pixmapLine;
+	std::unique_ptr<Surface> pixmapIndentGuide;
+	std::unique_ptr<Surface> pixmapIndentGuideHighlight;
+
+	LineLayoutCache llc;
+	PositionCache posCache;
+
+	int tabArrowHeight; // draw arrow heads this many pixels above/below line midpoint
+	/** Some platforms, notably PLAT_CURSES, do not support Scintilla's native
+	 * DrawTabArrow function for drawing tab characters. Allow those platforms to
+	 * override it instead of creating a new method in the Surface class that
+	 * existing platforms must implement as empty. */
+	DrawTabArrowFn customDrawTabArrow;
+	DrawWrapMarkerFn customDrawWrapMarker;
+
+	EditView();
+	// Deleted so EditView objects can not be copied.
+	EditView(const EditView &) = delete;
+	EditView(EditView &&) = delete;
+	void operator=(const EditView &) = delete;
+	void operator=(EditView &&) = delete;
+	virtual ~EditView();
+
+	bool SetTwoPhaseDraw(bool twoPhaseDraw) noexcept;
+	bool SetPhasesDraw(int phases) noexcept;
+	bool LinesOverlap() const noexcept;
+
+	void ClearAllTabstops() noexcept;
+	XYPOSITION NextTabstopPos(Sci::Line line, XYPOSITION x, XYPOSITION tabWidth) const noexcept;
+	bool ClearTabstops(Sci::Line line) noexcept;
+	bool AddTabstop(Sci::Line line, int x);
+	int GetNextTabstop(Sci::Line line, int x) const noexcept;
+	void LinesAddedOrRemoved(Sci::Line lineOfPos, Sci::Line linesAdded);
+
+	void DropGraphics(bool freeObjects);
+	void AllocateGraphics(const ViewStyle &vsDraw);
+	void RefreshPixMaps(Surface *surfaceWindow, WindowID wid, const ViewStyle &vsDraw);
+
+	LineLayout *RetrieveLineLayout(Sci::Line lineNumber, const EditModel &model);
+	void LayoutLine(const EditModel &model, Sci::Line line, Surface *surface, const ViewStyle &vstyle,
+		LineLayout *ll, int width = LineLayout::wrapWidthInfinite);
+
+	static void UpdateBidiData(const EditModel &model, const ViewStyle &vstyle, LineLayout *ll);
+
+	Point LocationFromPosition(Surface *surface, const EditModel &model, SelectionPosition pos, Sci::Line topLine,
+		const ViewStyle &vs, PointEnd pe, const PRectangle rcClient);
+	Range RangeDisplayLine(Surface *surface, const EditModel &model, Sci::Line lineVisible, const ViewStyle &vs);
+	SelectionPosition SPositionFromLocation(Surface *surface, const EditModel &model, PointDocument pt, bool canReturnInvalid,
+		bool charPosition, bool virtualSpace, const ViewStyle &vs, const PRectangle rcClient);
+	SelectionPosition SPositionFromLineX(Surface *surface, const EditModel &model, Sci::Line lineDoc, int x, const ViewStyle &vs);
+	Sci::Line DisplayFromPosition(Surface *surface, const EditModel &model, Sci::Position pos, const ViewStyle &vs);
+	Sci::Position StartEndDisplayLine(Surface *surface, const EditModel &model, Sci::Position pos, bool start, const ViewStyle &vs);
+
+	void DrawIndentGuide(Surface *surface, Sci::Line lineVisible, int lineHeight, XYPOSITION start, PRectangle rcSegment, bool highlight);
+	void DrawEOL(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll, PRectangle rcLine,
+		Sci::Line line, Sci::Position lineEnd, int xStart, int subLine, XYACCUMULATOR subLineStart,
+		ColourOptional background);
+	void DrawFoldDisplayText(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+		Sci::Line line, int xStart, PRectangle rcLine, int subLine, XYACCUMULATOR subLineStart, DrawPhase phase);
+	void DrawEOLAnnotationText(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+		Sci::Line line, int xStart, PRectangle rcLine, int subLine, XYACCUMULATOR subLineStart, DrawPhase phase);
+	void DrawAnnotation(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+		Sci::Line line, int xStart, PRectangle rcLine, int subLine, DrawPhase phase);
+	void DrawCarets(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll, Sci::Line lineDoc,
+		int xStart, PRectangle rcLine, int subLine) const;
+	void DrawBackground(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll, PRectangle rcLine,
+		Range lineRange, Sci::Position posLineStart, int xStart,
+		int subLine, ColourOptional background) const;
+	void DrawForeground(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll, Sci::Line lineVisible,
+		PRectangle rcLine, Range lineRange, Sci::Position posLineStart, int xStart,
+		int subLine, ColourOptional background);
+	void DrawIndentGuidesOverEmpty(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+		Sci::Line line, Sci::Line lineVisible, PRectangle rcLine, int xStart, int subLine);
+	void DrawLine(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll, Sci::Line line,
+		Sci::Line lineVisible, int xStart, PRectangle rcLine, int subLine, DrawPhase phase);
+	void PaintText(Surface *surfaceWindow, const EditModel &model, PRectangle rcArea, PRectangle rcClient,
+		const ViewStyle &vsDraw);
+	void FillLineRemainder(Surface *surface, const EditModel &model, const ViewStyle &vsDraw, const LineLayout *ll,
+		Sci::Line line, PRectangle rcArea, int subLine) const;
+	Sci::Position FormatRange(bool draw, const Sci_RangeToFormat *pfr, Surface *surface, Surface *surfaceMeasure,
+		const EditModel &model, const ViewStyle &vs);
+};
+
+/**
+* Convenience class to ensure LineLayout objects are always disposed.
+*/
+class AutoLineLayout {
+	LineLayoutCache &llc;
+	LineLayout *ll;
+public:
+	AutoLineLayout(LineLayoutCache &llc_, LineLayout *ll_) noexcept : llc(llc_), ll(ll_) {}
+	AutoLineLayout(const AutoLineLayout &) = delete;
+	AutoLineLayout(AutoLineLayout &&) = delete;
+	AutoLineLayout &operator=(const AutoLineLayout &) = delete;
+	AutoLineLayout &operator=(AutoLineLayout &&) = delete;
+	~AutoLineLayout() noexcept {
+		llc.Dispose(ll);
+		ll = nullptr;
+	}
+	LineLayout *operator->() const noexcept {
+		return ll;
+	}
+	operator LineLayout *() const noexcept {
+		return ll;
+	}
+	void Set(LineLayout *ll_) noexcept {
+		llc.Dispose(ll);
+		ll = ll_;
+	}
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/Editor.cxx b/Pythonwin/Scintilla/src/Editor.cxx
index ffc2dee22..01ab6f0a5 100644
--- a/Pythonwin/Scintilla/src/Editor.cxx
+++ b/Pythonwin/Scintilla/src/Editor.cxx
@@ -2,47 +2,70 @@
 /** @file Editor.cxx
  ** Main code for the edit control.
  **/
-// Copyright 1998-2004 by Neil Hodgson <neilh@scintilla.org>
+// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cstdio>
+#include <cmath>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <map>
+#include <forward_list>
+#include <algorithm>
+#include <iterator>
+#include <memory>
+#include <chrono>
 
 #include "Platform.h"
 
-#ifndef PLAT_QT
-#define INCLUDE_DEPRECATED_FEATURES
-#endif
+#include "ILoader.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 
+#include "CharacterSet.h"
+#include "CharacterCategory.h"
+#include "Position.h"
+#include "UniqueString.h"
 #include "SplitVector.h"
 #include "Partitioning.h"
 #include "RunStyles.h"
 #include "ContractionState.h"
 #include "CellBuffer.h"
+#include "PerLine.h"
 #include "KeyMap.h"
 #include "Indicator.h"
-#include "XPM.h"
 #include "LineMarker.h"
 #include "Style.h"
 #include "ViewStyle.h"
 #include "CharClassify.h"
 #include "Decoration.h"
+#include "CaseFolder.h"
 #include "Document.h"
+#include "UniConversion.h"
+#include "Selection.h"
 #include "PositionCache.h"
+#include "EditModel.h"
+#include "MarginView.h"
+#include "EditView.h"
 #include "Editor.h"
+#include "ElapsedPeriod.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
+
+namespace {
 
 /*
 	return whether this modification represents an operation that
 	may reasonably be deferred (not done now OR [possibly] at all)
 */
-static bool CanDeferToLastStep(const DocModification& mh) {
+constexpr bool CanDeferToLastStep(const DocModification &mh) noexcept {
 	if (mh.modificationType & (SC_MOD_BEFOREINSERT | SC_MOD_BEFOREDELETE))
 		return true;	// CAN skip
 	if (!(mh.modificationType & (SC_PERFORMED_UNDO | SC_PERFORMED_REDO)))
@@ -52,7 +75,7 @@ static bool CanDeferToLastStep(const DocModification& mh) {
 	return false;		// PRESUMABLY must do
 }
 
-static bool CanEliminate(const DocModification& mh) {
+constexpr bool CanEliminate(const DocModification &mh) noexcept {
 	return
 	    (mh.modificationType & (SC_MOD_BEFOREINSERT | SC_MOD_BEFOREDELETE)) != 0;
 }
@@ -61,7 +84,7 @@ static bool CanEliminate(const DocModification& mh) {
 	return whether this modification represents the FINAL step
 	in a [possibly lengthy] multi-step Undo/Redo sequence
 */
-static bool IsLastStep(const DocModification& mh) {
+constexpr bool IsLastStep(const DocModification &mh) noexcept {
 	return
 	    (mh.modificationType & (SC_PERFORMED_UNDO | SC_PERFORMED_REDO)) != 0
 	    && (mh.modificationType & SC_MULTISTEPUNDOREDO) != 0
@@ -69,41 +92,39 @@ static bool IsLastStep(const DocModification& mh) {
 	    && (mh.modificationType & SC_MULTILINEUNDOREDO) != 0;
 }
 
-Caret::Caret() :
-		active(false), on(false), period(500) {}
+}
 
-Timer::Timer() :
-		ticking(false), ticksToWait(0), tickerID(0) {}
+Timer::Timer() noexcept :
+		ticking(false), ticksToWait(0), tickerID{} {}
 
-Idler::Idler() :
+Idler::Idler() noexcept :
 		state(false), idlerID(0) {}
 
-static inline bool IsControlCharacter(int ch) {
-	// iscntrl returns true for lots of chars > 127 which are displayable
-	return ch >= 0 && ch < ' ';
+static constexpr bool IsAllSpacesOrTabs(std::string_view sv) noexcept {
+	for (const char ch : sv) {
+		// This is safe because IsSpaceOrTab() will return false for null terminators
+		if (!IsSpaceOrTab(ch))
+			return false;
+	}
+	return true;
 }
 
-Editor::Editor() {
+Editor::Editor() : durationWrapOneLine(0.00001, 0.000001, 0.0001) {
 	ctrlID = 0;
 
 	stylesValid = false;
+	technology = SC_TECHNOLOGY_DEFAULT;
+	scaleRGBAImage = 100.0f;
 
-	printMagnification = 0;
-	printColourMode = SC_PRINT_NORMAL;
-	printWrapState = eWrapWord;
 	cursorMode = SC_CURSORNORMAL;
-	controlCharSymbol = 0;	/* Draw the control characters */
 
 	hasFocus = false;
-	hideSelection = false;
-	inOverstrike = false;
 	errorStatus = 0;
 	mouseDownCaptures = true;
-
-	bufferedDraw = true;
-	twoPhaseDraw = true;
+	mouseWheelCaptures = true;
 
 	lastClickTime = 0;
+	doubleClickCloseThreshold = Point(3, 3);
 	dwellDelay = SC_TIME_FOREVER;
 	ticksToDwell = SC_TIME_FOREVER;
 	dwelling = false;
@@ -111,49 +132,38 @@ Editor::Editor() {
 	ptMouseLast.y = 0;
 	inDragDrop = ddNone;
 	dropWentOutside = false;
-	posDrag = invalidPosition;
-	posDrop = invalidPosition;
-	selectionType = selChar;
+	posDrop = SelectionPosition(Sci::invalidPosition);
+	hotSpotClickPos = INVALID_POSITION;
+	selectionUnit = TextUnit::character;
 
 	lastXChosen = 0;
-	lineAnchor = 0;
+	lineAnchorPos = 0;
 	originalAnchorPos = 0;
+	wordSelectAnchorStartPos = 0;
+	wordSelectAnchorEndPos = 0;
+	wordSelectInitialCaretPos = -1;
 
-	selType = selStream;
-	moveExtendsSelection = false;
-	xStartSelect = 0;
-	xEndSelect = 0;
-	primarySelection = true;
+	caretPolicies.x = { CARET_SLOP | CARET_EVEN, 50 };
+	caretPolicies.y = { CARET_EVEN, 0 };
 
-	caretXPolicy = CARET_SLOP | CARET_EVEN;
-	caretXSlop = 50;
-
-	caretYPolicy = CARET_EVEN;
-	caretYSlop = 0;
+	visiblePolicy = { 0, 0 };
 
 	searchAnchor = 0;
 
-	xOffset = 0;
 	xCaretMargin = 50;
 	horizontalScrollBarVisible = true;
 	scrollWidth = 2000;
-	trackLineWidth = false;
-	lineWidthMaxSeen = 0;
 	verticalScrollBarVisible = true;
 	endAtLastLine = true;
-	caretSticky = false;
-
-	pixmapLine = Surface::Allocate();
-	pixmapSelMargin = Surface::Allocate();
-	pixmapSelPattern = Surface::Allocate();
-	pixmapIndentGuide = Surface::Allocate();
-	pixmapIndentGuideHighlight = Surface::Allocate();
-
-	currentPos = 0;
-	anchor = 0;
-
-	targetStart = 0;
-	targetEnd = 0;
+	caretSticky = SC_CARETSTICKY_OFF;
+	marginOptions = SC_MARGINOPTION_NONE;
+	mouseSelectionRectangularSwitch = false;
+	multipleSelection = false;
+	additionalSelectionTyping = false;
+	multiPasteMode = SC_MULTIPASTE_ONCE;
+	virtualSpaceOptions = SCVS_NONE;
+
+	targetRange = SelectionSegment();
 	searchFlags = 0;
 
 	topLine = 0;
@@ -161,53 +171,32 @@ Editor::Editor() {
 
 	lengthForEncode = -1;
 
-	needUpdateUI = true;
-	braces[0] = invalidPosition;
-	braces[1] = invalidPosition;
-	bracesMatchStyle = STYLE_BRACEBAD;
-	highlightGuideColumn = 0;
-
-	theEdge = 0;
+	needUpdateUI = 0;
+	ContainerNeedsUpdate(SC_UPDATE_CONTENT);
 
 	paintState = notPainting;
+	paintAbandonedByStyling = false;
+	paintingAllText = false;
+	willRedrawAll = false;
+	idleStyling = SC_IDLESTYLING_NONE;
+	needIdleStyling = false;
 
 	modEventMask = SC_MODEVENTMASKALL;
+	commandEvents = true;
 
-	pdoc = new Document();
-	pdoc->AddRef();
 	pdoc->AddWatcher(this, 0);
 
 	recordingMacro = false;
-	foldFlags = 0;
-
-	wrapState = eWrapNone;
-	wrapWidth = LineLayout::wrapWidthInfinite;
-	wrapStart = wrapLineLarge;
-	wrapEnd = wrapLineLarge;
-	wrapVisualFlags = 0;
-	wrapVisualFlagsLocation = 0;
-	wrapVisualStartIndent = 0;
-	actualWrapVisualStartIndent = 0;
+	foldAutomatic = 0;
 
 	convertPastes = true;
 
-	hsStart = -1;
-	hsEnd = -1;
-
-	llc.SetLevel(LineLayoutCache::llcCaret);
-	posCache.SetSize(0x400);
+	SetRepresentations();
 }
 
 Editor::~Editor() {
 	pdoc->RemoveWatcher(this, 0);
-	pdoc->Release();
-	pdoc = 0;
-	DropGraphics();
-	delete pixmapLine;
-	delete pixmapSelMargin;
-	delete pixmapSelPattern;
-	delete pixmapIndentGuide;
-	delete pixmapIndentGuideHighlight;
+	DropGraphics(true);
 }
 
 void Editor::Finalise() {
@@ -215,24 +204,78 @@ void Editor::Finalise() {
 	CancelModes();
 }
 
-void Editor::DropGraphics() {
-	pixmapLine->Release();
-	pixmapSelMargin->Release();
-	pixmapSelPattern->Release();
-	pixmapIndentGuide->Release();
-	pixmapIndentGuideHighlight->Release();
+void Editor::SetRepresentations() {
+	reprs.Clear();
+
+	// C0 control set
+	const char *const reps[] = {
+		"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL",
+		"BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI",
+		"DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB",
+		"CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US"
+	};
+	for (size_t j=0; j < std::size(reps); j++) {
+		const char c[2] = { static_cast<char>(j), 0 };
+		reprs.SetRepresentation(c, reps[j]);
+	}
+	reprs.SetRepresentation("\x7f", "DEL");
+
+	// C1 control set
+	// As well as Unicode mode, ISO-8859-1 should use these
+	if (IsUnicodeMode()) {
+		const char *const repsC1[] = {
+			"PAD", "HOP", "BPH", "NBH", "IND", "NEL", "SSA", "ESA",
+			"HTS", "HTJ", "VTS", "PLD", "PLU", "RI", "SS2", "SS3",
+			"DCS", "PU1", "PU2", "STS", "CCH", "MW", "SPA", "EPA",
+			"SOS", "SGCI", "SCI", "CSI", "ST", "OSC", "PM", "APC"
+		};
+		for (size_t j=0; j < std::size(repsC1); j++) {
+			const char c1[3] = { '\xc2',  static_cast<char>(0x80+j), 0 };
+			reprs.SetRepresentation(c1, repsC1[j]);
+		}
+		reprs.SetRepresentation("\xe2\x80\xa8", "LS");
+		reprs.SetRepresentation("\xe2\x80\xa9", "PS");
+	}
+
+	// UTF-8 invalid bytes
+	if (IsUnicodeMode()) {
+		for (int k=0x80; k < 0x100; k++) {
+			const char hiByte[2] = {  static_cast<char>(k), 0 };
+			char hexits[5];	// Really only needs 4 but that causes warning from gcc 7.1
+			sprintf(hexits, "x%2X", k);
+			reprs.SetRepresentation(hiByte, hexits);
+		}
+	} else if (pdoc->dbcsCodePage) {
+		// DBCS invalid single lead bytes
+		for (int k = 0x80; k < 0x100; k++) {
+			const char ch = static_cast<char>(k);
+			if (pdoc->IsDBCSLeadByteNoExcept(ch)  || pdoc->IsDBCSLeadByteInvalid(ch)) {
+				const char hiByte[2] = { ch, 0 };
+				char hexits[5];	// Really only needs 4 but that causes warning from gcc 7.1
+				sprintf(hexits, "x%2X", k);
+				reprs.SetRepresentation(hiByte, hexits);
+			}
+		}
+	}
+}
+
+void Editor::DropGraphics(bool freeObjects) {
+	marginView.DropGraphics(freeObjects);
+	view.DropGraphics(freeObjects);
+}
+
+void Editor::AllocateGraphics() {
+	marginView.AllocateGraphics(vs);
+	view.AllocateGraphics(vs);
 }
 
 void Editor::InvalidateStyleData() {
 	stylesValid = false;
-	DropGraphics();
-	palette.Release();
-	llc.Invalidate(LineLayout::llInvalid);
-	posCache.Clear();
-	if (selType == selRectangle) {
-		xStartSelect = XFromPosition(anchor);
-		xEndSelect = XFromPosition(currentPos);
-	}
+	vs.technology = technology;
+	DropGraphics(false);
+	AllocateGraphics();
+	view.llc.Invalidate(LineLayout::ValidLevel::invalid);
+	view.posCache.Clear();
 }
 
 void Editor::InvalidateStyleRedraw() {
@@ -241,54 +284,76 @@ void Editor::InvalidateStyleRedraw() {
 	Redraw();
 }
 
-void Editor::RefreshColourPalette(Palette &pal, bool want) {
-	vs.RefreshColourPalette(pal, want);
-}
-
 void Editor::RefreshStyleData() {
 	if (!stylesValid) {
 		stylesValid = true;
 		AutoSurface surface(this);
 		if (surface) {
-			vs.Refresh(*surface);
-			RefreshColourPalette(palette, true);
-			palette.Allocate(wMain);
-			RefreshColourPalette(palette, false);
+			vs.Refresh(*surface, pdoc->tabInChars);
 		}
 		SetScrollBars();
+		SetRectangularRange();
+	}
+}
+
+Point Editor::GetVisibleOriginInMain() const {
+	return Point(0, 0);
+}
+
+PointDocument Editor::DocumentPointFromView(Point ptView) const {
+	PointDocument ptDocument(ptView);
+	if (wMargin.GetID()) {
+		const Point ptOrigin = GetVisibleOriginInMain();
+		ptDocument.x += ptOrigin.x;
+		ptDocument.y += ptOrigin.y;
+	} else {
+		ptDocument.x += xOffset;
+		ptDocument.y += topLine * vs.lineHeight;
 	}
+	return ptDocument;
+}
+
+Sci::Line Editor::TopLineOfMain() const {
+	if (wMargin.GetID())
+		return 0;
+	else
+		return topLine;
 }
 
-PRectangle Editor::GetClientRectangle() {
+PRectangle Editor::GetClientRectangle() const {
 	return wMain.GetClientPosition();
 }
 
-PRectangle Editor::GetTextRectangle() {
+PRectangle Editor::GetClientDrawingRectangle() {
+	return GetClientRectangle();
+}
+
+PRectangle Editor::GetTextRectangle() const {
 	PRectangle rc = GetClientRectangle();
-	rc.left += vs.fixedColumnWidth;
+	rc.left += vs.textStart;
 	rc.right -= vs.rightMarginWidth;
 	return rc;
 }
 
-int Editor::LinesOnScreen() {
-	PRectangle rcClient = GetClientRectangle();
-	int htClient = rcClient.bottom - rcClient.top;
+Sci::Line Editor::LinesOnScreen() const {
+	const PRectangle rcClient = GetClientRectangle();
+	const int htClient = static_cast<int>(rcClient.bottom - rcClient.top);
 	//Platform::DebugPrintf("lines on screen = %d\n", htClient / lineHeight + 1);
 	return htClient / vs.lineHeight;
 }
 
-int Editor::LinesToScroll() {
-	int retVal = LinesOnScreen() - 1;
+Sci::Line Editor::LinesToScroll() const {
+	const Sci::Line retVal = LinesOnScreen() - 1;
 	if (retVal < 1)
 		return 1;
 	else
 		return retVal;
 }
 
-int Editor::MaxScrollPos() {
+Sci::Line Editor::MaxScrollPos() const {
 	//Platform::DebugPrintf("Lines %d screen = %d maxScroll = %d\n",
 	//LinesTotal(), LinesOnScreen(), LinesTotal() - LinesOnScreen() + 1);
-	int retVal = cs.LinesDisplayed();
+	Sci::Line retVal = pcs->LinesDisplayed();
 	if (endAtLastLine) {
 		retVal -= LinesOnScreen();
 	} else {
@@ -301,315 +366,89 @@ int Editor::MaxScrollPos() {
 	}
 }
 
-const char *ControlCharacterString(unsigned char ch) {
-	const char *reps[] = {
-		"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL",
-		"BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI",
-		"DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB",
-		"CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US"
-	};
-	if (ch < (sizeof(reps) / sizeof(reps[0]))) {
-		return reps[ch];
+SelectionPosition Editor::ClampPositionIntoDocument(SelectionPosition sp) const {
+	if (sp.Position() < 0) {
+		return SelectionPosition(0);
+	} else if (sp.Position() > pdoc->Length()) {
+		return SelectionPosition(pdoc->Length());
 	} else {
-		return "BAD";
-	}
-}
-
-/**
- * Convenience class to ensure LineLayout objects are always disposed.
- */
-class AutoLineLayout {
-	LineLayoutCache &llc;
-	LineLayout *ll;
-	AutoLineLayout &operator=(const AutoLineLayout &) { return * this; }
-public:
-	AutoLineLayout(LineLayoutCache &llc_, LineLayout *ll_) : llc(llc_), ll(ll_) {}
-	~AutoLineLayout() {
-		llc.Dispose(ll);
-		ll = 0;
-	}
-	LineLayout *operator->() const {
-		return ll;
-	}
-	operator LineLayout *() const {
-		return ll;
-	}
-	void Set(LineLayout *ll_) {
-		llc.Dispose(ll);
-		ll = ll_;
-	}
-};
-
-#ifdef SCI_NAMESPACE
-namespace Scintilla {
-#endif
-
-/**
- * Allows to iterate through the lines of a selection.
- * Althought it can be called for a stream selection, in most cases
- * it is inefficient and it should be used only for
- * a rectangular or a line selection.
- */
-class SelectionLineIterator {
-private:
-	Editor *ed;
-	int line;	///< Current line within the iteration.
-	bool forward;	///< True if iterating by increasing line number, false otherwise.
-	int selStart, selEnd;	///< Positions of the start and end of the selection relative to the start of the document.
-	int minX, maxX;	///< Left and right of selection rectangle.
-
-public:
-	int lineStart, lineEnd;	///< Line numbers, first and last lines of the selection.
-	int startPos, endPos;	///< Positions of the beginning and end of the selection on the current line.
-
-	void Reset() {
-		if (forward) {
-			line = lineStart;
-		} else {
-			line = lineEnd;
-		}
-	}
-
-	SelectionLineIterator(Editor *ed_, bool forward_ = true) : line(0), startPos(0), endPos(0) {
-		ed = ed_;
-		forward = forward_;
-		selStart = ed->SelectionStart();
-		selEnd = ed->SelectionEnd();
-		lineStart = ed->pdoc->LineFromPosition(selStart);
-		lineEnd = ed->pdoc->LineFromPosition(selEnd);
-		// Left of rectangle
-		minX = Platform::Minimum(ed->xStartSelect, ed->xEndSelect);
-		// Right of rectangle
-		maxX = Platform::Maximum(ed->xStartSelect, ed->xEndSelect);
-		Reset();
-	}
-	~SelectionLineIterator() {}
-
-	void SetAt(int line) {
-		if (line < lineStart || line > lineEnd) {
-			startPos = endPos = INVALID_POSITION;
-		} else {
-			if (ed->selType == ed->selRectangle) {
-				// Measure line and return character closest to minX
-				startPos = ed->PositionFromLineX(line, minX);
-				// Measure line and return character closest to maxX
-				endPos = ed->PositionFromLineX(line, maxX);
-			} else if (ed->selType == ed->selLines) {
-				startPos = ed->pdoc->LineStart(line);
-				endPos = ed->pdoc->LineStart(line + 1);
-			} else {	// Stream selection, here only for completion
-				if (line == lineStart) {
-					startPos = selStart;
-				} else {
-					startPos = ed->pdoc->LineStart(line);
-				}
-				if (line == lineEnd) {
-					endPos = selEnd;
-				} else {
-					endPos = ed->pdoc->LineStart(line + 1);
-				}
-			}
-		}
-	}
-	bool Iterate() {
-		SetAt(line);
-		if (forward) {
-			line++;
-		} else {
-			line--;
-		}
-		return startPos != INVALID_POSITION;
+		// If not at end of line then set offset to 0
+		if (!pdoc->IsLineEndPosition(sp.Position()))
+			sp.SetVirtualSpace(0);
+		return sp;
 	}
-};
-
-#ifdef SCI_NAMESPACE
 }
-#endif
 
-Point Editor::LocationFromPosition(int pos) {
-	Point pt;
+Point Editor::LocationFromPosition(SelectionPosition pos, PointEnd pe) {
+	const PRectangle rcClient = GetTextRectangle();
 	RefreshStyleData();
-	if (pos == INVALID_POSITION)
-		return pt;
-	int line = pdoc->LineFromPosition(pos);
-	int lineVisible = cs.DisplayFromDoc(line);
-	//Platform::DebugPrintf("line=%d\n", line);
 	AutoSurface surface(this);
-	AutoLineLayout ll(llc, RetrieveLineLayout(line));
-	if (surface && ll) {
-		// -1 because of adding in for visible lines in following loop.
-		pt.y = (lineVisible - topLine - 1) * vs.lineHeight;
-		pt.x = 0;
-		unsigned int posLineStart = pdoc->LineStart(line);
-		LayoutLine(line, surface, vs, ll, wrapWidth);
-		int posInLine = pos - posLineStart;
-		// In case of very long line put x at arbitrary large position
-		if (posInLine > ll->maxLineLength) {
-			pt.x = ll->positions[ll->maxLineLength] - ll->positions[ll->LineStart(ll->lines)];
-		}
-
-		for (int subLine = 0; subLine < ll->lines; subLine++) {
-			if ((posInLine >= ll->LineStart(subLine)) && (posInLine <= ll->LineStart(subLine + 1))) {
-				pt.x = ll->positions[posInLine] - ll->positions[ll->LineStart(subLine)];
-				if (actualWrapVisualStartIndent != 0) {
-					int lineStart = ll->LineStart(subLine);
-					if (lineStart != 0)	// Wrapped
-						pt.x += actualWrapVisualStartIndent * vs.aveCharWidth;
-				}
-			}
-			if (posInLine >= ll->LineStart(subLine)) {
-				pt.y += vs.lineHeight;
-			}
-		}
-		pt.x += vs.fixedColumnWidth - xOffset;
-	}
-	return pt;
-}
-
-int Editor::XFromPosition(int pos) {
-	Point pt = LocationFromPosition(pos);
-	return pt.x - vs.fixedColumnWidth + xOffset;
+	return view.LocationFromPosition(surface, *this, pos, topLine, vs, pe, rcClient);
 }
 
-int Editor::LineFromLocation(Point pt) {
-	return cs.DocFromDisplay(pt.y / vs.lineHeight + topLine);
+Point Editor::LocationFromPosition(Sci::Position pos, PointEnd pe) {
+	return LocationFromPosition(SelectionPosition(pos), pe);
 }
 
-void Editor::SetTopLine(int topLineNew) {
-	topLine = topLineNew;
-	posTopLine = pdoc->LineStart(cs.DocFromDisplay(topLine));
+int Editor::XFromPosition(SelectionPosition sp) {
+	const Point pt = LocationFromPosition(sp);
+	return static_cast<int>(pt.x) - vs.textStart + xOffset;
 }
 
-int Editor::PositionFromLocation(Point pt) {
+SelectionPosition Editor::SPositionFromLocation(Point pt, bool canReturnInvalid, bool charPosition, bool virtualSpace) {
 	RefreshStyleData();
-	pt.x = pt.x - vs.fixedColumnWidth + xOffset;
-	int visibleLine = pt.y / vs.lineHeight + topLine;
-	if (pt.y < 0) {	// Division rounds towards 0
-		visibleLine = (pt.y - (vs.lineHeight - 1)) / vs.lineHeight + topLine;
-	}
-	if (visibleLine < 0)
-		visibleLine = 0;
-	int lineDoc = cs.DocFromDisplay(visibleLine);
-	if (lineDoc >= pdoc->LinesTotal())
-		return pdoc->Length();
-	unsigned int posLineStart = pdoc->LineStart(lineDoc);
-	int retVal = posLineStart;
 	AutoSurface surface(this);
-	AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc));
-	if (surface && ll) {
-		LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
-		int lineStartSet = cs.DisplayFromDoc(lineDoc);
-		int subLine = visibleLine - lineStartSet;
-		if (subLine < ll->lines) {
-			int lineStart = ll->LineStart(subLine);
-			int lineEnd = ll->LineLastVisible(subLine);
-			int subLineStart = ll->positions[lineStart];
-
-			if (actualWrapVisualStartIndent != 0) {
-				if (lineStart != 0)	// Wrapped
-					pt.x -= actualWrapVisualStartIndent * vs.aveCharWidth;
-			}
-			int i = ll->FindBefore(pt.x + subLineStart, lineStart, lineEnd);
-			while (i < lineEnd) {
-				if ((pt.x + subLineStart) < ((ll->positions[i] + ll->positions[i + 1]) / 2)) {
-					return pdoc->MovePositionOutsideChar(i + posLineStart, 1);
-				}
-				i++;
-			}
-			return lineEnd + posLineStart;
-		}
-		retVal = ll->numCharsInLine + posLineStart;
-	}
-	return retVal;
-}
 
-// Like PositionFromLocation but INVALID_POSITION returned when not near any text.
-int Editor::PositionFromLocationClose(Point pt) {
-	RefreshStyleData();
 	PRectangle rcClient = GetTextRectangle();
-	if (!rcClient.Contains(pt))
-		return INVALID_POSITION;
-	if (pt.x < vs.fixedColumnWidth)
-		return INVALID_POSITION;
-	if (pt.y < 0)
-		return INVALID_POSITION;
-	pt.x = pt.x - vs.fixedColumnWidth + xOffset;
-	int visibleLine = pt.y / vs.lineHeight + topLine;
-	if (pt.y < 0) {	// Division rounds towards 0
-		visibleLine = (pt.y - (vs.lineHeight - 1)) / vs.lineHeight + topLine;
-	}
-	int lineDoc = cs.DocFromDisplay(visibleLine);
-	if (lineDoc < 0)
-		return INVALID_POSITION;
-	if (lineDoc >= pdoc->LinesTotal())
-		return INVALID_POSITION;
-	AutoSurface surface(this);
-	AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc));
-	if (surface && ll) {
-		LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
-		unsigned int posLineStart = pdoc->LineStart(lineDoc);
-		int lineStartSet = cs.DisplayFromDoc(lineDoc);
-		int subLine = visibleLine - lineStartSet;
-		if (subLine < ll->lines) {
-			int lineStart = ll->LineStart(subLine);
-			int lineEnd = ll->LineLastVisible(subLine);
-			int subLineStart = ll->positions[lineStart];
-
-			if (actualWrapVisualStartIndent != 0) {
-				if (lineStart != 0)	// Wrapped
-					pt.x -= actualWrapVisualStartIndent * vs.aveCharWidth;
-			}
-			int i = ll->FindBefore(pt.x + subLineStart, lineStart, lineEnd);
-			while (i < lineEnd) {
-				if ((pt.x + subLineStart) < ((ll->positions[i] + ll->positions[i + 1]) / 2)) {
-					return pdoc->MovePositionOutsideChar(i + posLineStart, 1);
-				}
-				i++;
-			}
-			if (pt.x < (ll->positions[lineEnd] - subLineStart)) {
-				return pdoc->MovePositionOutsideChar(lineEnd + posLineStart, 1);
-			}
-		}
+	// May be in scroll view coordinates so translate back to main view
+	const Point ptOrigin = GetVisibleOriginInMain();
+	rcClient.Move(-ptOrigin.x, -ptOrigin.y);
+
+	if (canReturnInvalid) {
+		if (!rcClient.Contains(pt))
+			return SelectionPosition(INVALID_POSITION);
+		if (pt.x < vs.textStart)
+			return SelectionPosition(INVALID_POSITION);
+		if (pt.y < 0)
+			return SelectionPosition(INVALID_POSITION);
 	}
+	const PointDocument ptdoc = DocumentPointFromView(pt);
+	return view.SPositionFromLocation(surface, *this, ptdoc, canReturnInvalid,
+		charPosition, virtualSpace, vs, rcClient);
+}
 
-	return INVALID_POSITION;
+Sci::Position Editor::PositionFromLocation(Point pt, bool canReturnInvalid, bool charPosition) {
+	return SPositionFromLocation(pt, canReturnInvalid, charPosition, false).Position();
 }
 
 /**
- * Find the document position corresponding to an x coordinate on a particular document line.
- * Ensure is between whole characters when document is in multi-byte or UTF-8 mode.
- */
-int Editor::PositionFromLineX(int lineDoc, int x) {
+* Find the document position corresponding to an x coordinate on a particular document line.
+* Ensure is between whole characters when document is in multi-byte or UTF-8 mode.
+* This method is used for rectangular selections and does not work on wrapped lines.
+*/
+SelectionPosition Editor::SPositionFromLineX(Sci::Line lineDoc, int x) {
 	RefreshStyleData();
 	if (lineDoc >= pdoc->LinesTotal())
-		return pdoc->Length();
+		return SelectionPosition(pdoc->Length());
 	//Platform::DebugPrintf("Position of (%d,%d) line = %d top=%d\n", pt.x, pt.y, line, topLine);
 	AutoSurface surface(this);
-	AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc));
-	int retVal = 0;
-	if (surface && ll) {
-		unsigned int posLineStart = pdoc->LineStart(lineDoc);
-		LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
-		retVal = ll->numCharsInLine + posLineStart;
-		int subLine = 0;
-		int lineStart = ll->LineStart(subLine);
-		int lineEnd = ll->LineLastVisible(subLine);
-		int subLineStart = ll->positions[lineStart];
-
-		if (actualWrapVisualStartIndent != 0) {
-			if (lineStart != 0)	// Wrapped
-				x -= actualWrapVisualStartIndent * vs.aveCharWidth;
-		}
-		int i = ll->FindBefore(x + subLineStart, lineStart, lineEnd);
-		while (i < lineEnd) {
-			if ((x + subLineStart) < ((ll->positions[i] + ll->positions[i + 1]) / 2)) {
-				retVal = pdoc->MovePositionOutsideChar(i + posLineStart, 1);
-				break;
-			}
-			i++;
-		}
+	return view.SPositionFromLineX(surface, *this, lineDoc, x, vs);
+}
+
+Sci::Position Editor::PositionFromLineX(Sci::Line lineDoc, int x) {
+	return SPositionFromLineX(lineDoc, x).Position();
+}
+
+Sci::Line Editor::LineFromLocation(Point pt) const {
+	return pcs->DocFromDisplay(static_cast<int>(pt.y) / vs.lineHeight + topLine);
+}
+
+void Editor::SetTopLine(Sci::Line topLineNew) {
+	if ((topLine != topLineNew) && (topLineNew >= 0)) {
+		topLine = topLineNew;
+		ContainerNeedsUpdate(SC_UPDATE_V_SCROLL);
 	}
-	return retVal;
+	posTopLine = pdoc->LineStart(pcs->DocFromDisplay(topLine));
 }
 
 /**
@@ -627,7 +466,7 @@ void Editor::RedrawRect(PRectangle rc) {
 	//Platform::DebugPrintf("Redraw %0d,%0d - %0d,%0d\n", rc.left, rc.top, rc.right, rc.bottom);
 
 	// Clip the redraw rectangle into the client area
-	PRectangle rcClient = GetClientRectangle();
+	const PRectangle rcClient = GetClientRectangle();
 	if (rc.top < rcClient.top)
 		rc.top = rcClient.top;
 	if (rc.bottom > rcClient.bottom)
@@ -642,256 +481,496 @@ void Editor::RedrawRect(PRectangle rc) {
 	}
 }
 
+void Editor::DiscardOverdraw() {
+	// Overridden on platforms that may draw outside visible area.
+}
+
 void Editor::Redraw() {
 	//Platform::DebugPrintf("Redraw all\n");
-	PRectangle rcClient = GetClientRectangle();
+	const PRectangle rcClient = GetClientRectangle();
 	wMain.InvalidateRectangle(rcClient);
+	if (wMargin.GetID())
+		wMargin.InvalidateAll();
 	//wMain.InvalidateAll();
 }
 
-void Editor::RedrawSelMargin(int line) {
-	if (!AbandonPaint()) {
-		if (vs.maskInLine) {
-			Redraw();
-		} else {
-			PRectangle rcSelMargin = GetClientRectangle();
-			rcSelMargin.right = vs.fixedColumnWidth;
-			if (line != -1) {
-				int position = pdoc->LineStart(line);
-				PRectangle rcLine = RectangleFromRange(position, position);
-				rcSelMargin.top = rcLine.top;
-				rcSelMargin.bottom = rcLine.bottom;
-			}
-			wMain.InvalidateRectangle(rcSelMargin);
+void Editor::RedrawSelMargin(Sci::Line line, bool allAfter) {
+	const bool markersInText = vs.maskInLine || vs.maskDrawInText;
+	if (!wMargin.GetID() || markersInText) {	// May affect text area so may need to abandon and retry
+		if (AbandonPaint()) {
+			return;
 		}
 	}
+	if (wMargin.GetID() && markersInText) {
+		Redraw();
+		return;
+	}
+	PRectangle rcMarkers = GetClientRectangle();
+	if (!markersInText) {
+		// Normal case: just draw the margin
+		rcMarkers.right = rcMarkers.left + vs.fixedColumnWidth;
+	}
+	if (line != -1) {
+		PRectangle rcLine = RectangleFromRange(Range(pdoc->LineStart(line)), 0);
+
+		// Inflate line rectangle if there are image markers with height larger than line height
+		if (vs.largestMarkerHeight > vs.lineHeight) {
+			const int delta = (vs.largestMarkerHeight - vs.lineHeight + 1) / 2;
+			rcLine.top -= delta;
+			rcLine.bottom += delta;
+			if (rcLine.top < rcMarkers.top)
+				rcLine.top = rcMarkers.top;
+			if (rcLine.bottom > rcMarkers.bottom)
+				rcLine.bottom = rcMarkers.bottom;
+		}
+
+		rcMarkers.top = rcLine.top;
+		if (!allAfter)
+			rcMarkers.bottom = rcLine.bottom;
+		if (rcMarkers.Empty())
+			return;
+	}
+	if (wMargin.GetID()) {
+		const Point ptOrigin = GetVisibleOriginInMain();
+		rcMarkers.Move(-ptOrigin.x, -ptOrigin.y);
+		wMargin.InvalidateRectangle(rcMarkers);
+	} else {
+		wMain.InvalidateRectangle(rcMarkers);
+	}
 }
 
-PRectangle Editor::RectangleFromRange(int start, int end) {
-	int minPos = start;
-	if (minPos > end)
-		minPos = end;
-	int maxPos = start;
-	if (maxPos < end)
-		maxPos = end;
-	int minLine = cs.DisplayFromDoc(pdoc->LineFromPosition(minPos));
-	int lineDocMax = pdoc->LineFromPosition(maxPos);
-	int maxLine = cs.DisplayFromDoc(lineDocMax) + cs.GetHeight(lineDocMax) - 1;
-	PRectangle rcClient = GetTextRectangle();
+PRectangle Editor::RectangleFromRange(Range r, int overlap) {
+	const Sci::Line minLine = pcs->DisplayFromDoc(
+		pdoc->SciLineFromPosition(r.First()));
+	const Sci::Line maxLine = pcs->DisplayLastFromDoc(
+		pdoc->SciLineFromPosition(r.Last()));
+	const PRectangle rcClientDrawing = GetClientDrawingRectangle();
 	PRectangle rc;
-	rc.left = vs.fixedColumnWidth;
-	rc.top = (minLine - topLine) * vs.lineHeight;
-	if (rc.top < 0)
-		rc.top = 0;
-	rc.right = rcClient.right;
-	rc.bottom = (maxLine - topLine + 1) * vs.lineHeight;
-	// Ensure PRectangle is within 16 bit space
-	rc.top = Platform::Clamp(rc.top, -32000, 32000);
-	rc.bottom = Platform::Clamp(rc.bottom, -32000, 32000);
+	const int leftTextOverlap = ((xOffset == 0) && (vs.leftMarginWidth > 0)) ? 1 : 0;
+	rc.left = static_cast<XYPOSITION>(vs.textStart - leftTextOverlap);
+	rc.top = static_cast<XYPOSITION>((minLine - TopLineOfMain()) * vs.lineHeight - overlap);
+	if (rc.top < rcClientDrawing.top)
+		rc.top = rcClientDrawing.top;
+	// Extend to right of prepared area if any to prevent artifacts from caret line highlight
+	rc.right = rcClientDrawing.right;
+	rc.bottom = static_cast<XYPOSITION>((maxLine - TopLineOfMain() + 1) * vs.lineHeight + overlap);
 
 	return rc;
 }
 
-void Editor::InvalidateRange(int start, int end) {
-	RedrawRect(RectangleFromRange(start, end));
+void Editor::InvalidateRange(Sci::Position start, Sci::Position end) {
+	RedrawRect(RectangleFromRange(Range(start, end), view.LinesOverlap() ? vs.lineOverlap : 0));
 }
 
-int Editor::CurrentPosition() {
-	return currentPos;
+Sci::Position Editor::CurrentPosition() const {
+	return sel.MainCaret();
 }
 
-bool Editor::SelectionEmpty() {
-	return anchor == currentPos;
+bool Editor::SelectionEmpty() const noexcept {
+	return sel.Empty();
 }
 
-int Editor::SelectionStart() {
-	return Platform::Minimum(currentPos, anchor);
+SelectionPosition Editor::SelectionStart() {
+	return sel.RangeMain().Start();
 }
 
-int Editor::SelectionEnd() {
-	return Platform::Maximum(currentPos, anchor);
+SelectionPosition Editor::SelectionEnd() {
+	return sel.RangeMain().End();
 }
 
 void Editor::SetRectangularRange() {
-	if (selType == selRectangle) {
-		xStartSelect = XFromPosition(anchor);
-		xEndSelect = XFromPosition(currentPos);
+	if (sel.IsRectangular()) {
+		const int xAnchor = XFromPosition(sel.Rectangular().anchor);
+		int xCaret = XFromPosition(sel.Rectangular().caret);
+		if (sel.selType == Selection::selThin) {
+			xCaret = xAnchor;
+		}
+		const Sci::Line lineAnchorRect =
+			pdoc->SciLineFromPosition(sel.Rectangular().anchor.Position());
+		const Sci::Line lineCaret =
+			pdoc->SciLineFromPosition(sel.Rectangular().caret.Position());
+		const int increment = (lineCaret > lineAnchorRect) ? 1 : -1;
+		AutoSurface surface(this);
+		for (Sci::Line line=lineAnchorRect; line != lineCaret+increment; line += increment) {
+			SelectionRange range(
+				view.SPositionFromLineX(surface, *this, line, xCaret, vs),
+				view.SPositionFromLineX(surface, *this, line, xAnchor, vs));
+			if ((virtualSpaceOptions & SCVS_RECTANGULARSELECTION) == 0)
+				range.ClearVirtualSpace();
+			if (line == lineAnchorRect)
+				sel.SetSelection(range);
+			else
+				sel.AddSelectionWithoutTrim(range);
+		}
 	}
 }
 
-void Editor::InvalidateSelection(int currentPos_, int anchor_, bool invalidateWholeSelection) {
-	if (anchor != anchor_ || selType == selRectangle) {
+void Editor::ThinRectangularRange() {
+	if (sel.IsRectangular()) {
+		sel.selType = Selection::selThin;
+		if (sel.Rectangular().caret < sel.Rectangular().anchor) {
+			sel.Rectangular() = SelectionRange(sel.Range(sel.Count()-1).caret, sel.Range(0).anchor);
+		} else {
+			sel.Rectangular() = SelectionRange(sel.Range(sel.Count()-1).anchor, sel.Range(0).caret);
+		}
+		SetRectangularRange();
+	}
+}
+
+void Editor::InvalidateSelection(SelectionRange newMain, bool invalidateWholeSelection) {
+	if (sel.Count() > 1 || !(sel.RangeMain().anchor == newMain.anchor) || sel.IsRectangular()) {
 		invalidateWholeSelection = true;
 	}
-	int firstAffected = currentPos;
+	Sci::Position firstAffected = std::min(sel.RangeMain().Start().Position(), newMain.Start().Position());
+	// +1 for lastAffected ensures caret repainted
+	Sci::Position lastAffected = std::max(newMain.caret.Position()+1, newMain.anchor.Position());
+	lastAffected = std::max(lastAffected, sel.RangeMain().End().Position());
 	if (invalidateWholeSelection) {
-		if (firstAffected > anchor)
-			firstAffected = anchor;
-		if (firstAffected > anchor_)
-			firstAffected = anchor_;
-	}
-	if (firstAffected > currentPos_)
-		firstAffected = currentPos_;
-	int lastAffected = currentPos;
-	if (invalidateWholeSelection) {
-		if (lastAffected < anchor)
-			lastAffected = anchor;
-		if (lastAffected < anchor_)
-			lastAffected = anchor_;
-	}
-	if (lastAffected < (currentPos_ + 1))	// +1 ensures caret repainted
-		lastAffected = (currentPos_ + 1);
-	needUpdateUI = true;
+		for (size_t r=0; r<sel.Count(); r++) {
+			firstAffected = std::min(firstAffected, sel.Range(r).caret.Position());
+			firstAffected = std::min(firstAffected, sel.Range(r).anchor.Position());
+			lastAffected = std::max(lastAffected, sel.Range(r).caret.Position()+1);
+			lastAffected = std::max(lastAffected, sel.Range(r).anchor.Position());
+		}
+	}
+	ContainerNeedsUpdate(SC_UPDATE_SELECTION);
 	InvalidateRange(firstAffected, lastAffected);
 }
 
-void Editor::SetSelection(int currentPos_, int anchor_) {
-	currentPos_ = pdoc->ClampPositionIntoDocument(currentPos_);
-	anchor_ = pdoc->ClampPositionIntoDocument(anchor_);
-	if ((currentPos != currentPos_) || (anchor != anchor_)) {
-		InvalidateSelection(currentPos_, anchor_, true);
-		currentPos = currentPos_;
-		anchor = anchor_;
+void Editor::InvalidateWholeSelection() {
+	InvalidateSelection(sel.RangeMain(), true);
+}
+
+/* For Line selection - the anchor and caret are always
+   at the beginning and end of the region lines. */
+SelectionRange Editor::LineSelectionRange(SelectionPosition currentPos_, SelectionPosition anchor_) const {
+	if (currentPos_ > anchor_) {
+		anchor_ = SelectionPosition(
+			pdoc->LineStart(pdoc->LineFromPosition(anchor_.Position())));
+		currentPos_ = SelectionPosition(
+			pdoc->LineEnd(pdoc->LineFromPosition(currentPos_.Position())));
+	} else {
+		currentPos_ = SelectionPosition(
+			pdoc->LineStart(pdoc->LineFromPosition(currentPos_.Position())));
+		anchor_ = SelectionPosition(
+			pdoc->LineEnd(pdoc->LineFromPosition(anchor_.Position())));
+	}
+	return SelectionRange(currentPos_, anchor_);
+}
+
+void Editor::SetSelection(SelectionPosition currentPos_, SelectionPosition anchor_) {
+	currentPos_ = ClampPositionIntoDocument(currentPos_);
+	anchor_ = ClampPositionIntoDocument(anchor_);
+	const Sci::Line currentLine = pdoc->SciLineFromPosition(currentPos_.Position());
+	SelectionRange rangeNew(currentPos_, anchor_);
+	if (sel.selType == Selection::selLines) {
+		rangeNew = LineSelectionRange(currentPos_, anchor_);
+	}
+	if (sel.Count() > 1 || !(sel.RangeMain() == rangeNew)) {
+		InvalidateSelection(rangeNew);
 	}
+	sel.RangeMain() = rangeNew;
 	SetRectangularRange();
 	ClaimSelection();
+	SetHoverIndicatorPosition(sel.MainCaret());
+
+	if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
+		RedrawSelMargin();
+	}
+	QueueIdleWork(WorkNeeded::workUpdateUI);
+}
+
+void Editor::SetSelection(Sci::Position currentPos_, Sci::Position anchor_) {
+	SetSelection(SelectionPosition(currentPos_), SelectionPosition(anchor_));
+}
+
+// Just move the caret on the main selection
+void Editor::SetSelection(SelectionPosition currentPos_) {
+	currentPos_ = ClampPositionIntoDocument(currentPos_);
+	const Sci::Line currentLine = pdoc->SciLineFromPosition(currentPos_.Position());
+	if (sel.Count() > 1 || !(sel.RangeMain().caret == currentPos_)) {
+		InvalidateSelection(SelectionRange(currentPos_));
+	}
+	if (sel.IsRectangular()) {
+		sel.Rectangular() =
+			SelectionRange(SelectionPosition(currentPos_), sel.Rectangular().anchor);
+		SetRectangularRange();
+	} else if (sel.selType == Selection::selLines) {
+		sel.RangeMain() = LineSelectionRange(currentPos_, sel.RangeMain().anchor);
+	} else {
+		sel.RangeMain() =
+			SelectionRange(SelectionPosition(currentPos_), sel.RangeMain().anchor);
+	}
+	ClaimSelection();
+	SetHoverIndicatorPosition(sel.MainCaret());
+
+	if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
+		RedrawSelMargin();
+	}
+	QueueIdleWork(WorkNeeded::workUpdateUI);
 }
 
 void Editor::SetSelection(int currentPos_) {
-	currentPos_ = pdoc->ClampPositionIntoDocument(currentPos_);
-	if (currentPos != currentPos_) {
-		InvalidateSelection(currentPos_, anchor, false);
-		currentPos = currentPos_;
+	SetSelection(SelectionPosition(currentPos_));
+}
+
+void Editor::SetEmptySelection(SelectionPosition currentPos_) {
+	const Sci::Line currentLine = pdoc->SciLineFromPosition(currentPos_.Position());
+	SelectionRange rangeNew(ClampPositionIntoDocument(currentPos_));
+	if (sel.Count() > 1 || !(sel.RangeMain() == rangeNew)) {
+		InvalidateSelection(rangeNew);
 	}
+	sel.Clear();
+	sel.RangeMain() = rangeNew;
 	SetRectangularRange();
 	ClaimSelection();
+	SetHoverIndicatorPosition(sel.MainCaret());
+
+	if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
+		RedrawSelMargin();
+	}
+	QueueIdleWork(WorkNeeded::workUpdateUI);
 }
 
-void Editor::SetEmptySelection(int currentPos_) {
-	selType = selStream;
-	moveExtendsSelection = false;
-	SetSelection(currentPos_, currentPos_);
+void Editor::SetEmptySelection(Sci::Position currentPos_) {
+	SetEmptySelection(SelectionPosition(currentPos_));
+}
+
+void Editor::MultipleSelectAdd(AddNumber addNumber) {
+	if (SelectionEmpty() || !multipleSelection) {
+		// Select word at caret
+		const Sci::Position startWord = pdoc->ExtendWordSelect(sel.MainCaret(), -1, true);
+		const Sci::Position endWord = pdoc->ExtendWordSelect(startWord, 1, true);
+		TrimAndSetSelection(endWord, startWord);
+
+	} else {
+
+		if (!pdoc->HasCaseFolder())
+			pdoc->SetCaseFolder(CaseFolderForEncoding());
+
+		const Range rangeMainSelection(sel.RangeMain().Start().Position(), sel.RangeMain().End().Position());
+		const std::string selectedText = RangeText(rangeMainSelection.start, rangeMainSelection.end);
+
+		const Range rangeTarget(targetRange.start.Position(), targetRange.end.Position());
+		std::vector<Range> searchRanges;
+		// Search should be over the target range excluding the current selection so
+		// may need to search 2 ranges, after the selection then before the selection.
+		if (rangeTarget.Overlaps(rangeMainSelection)) {
+			// Common case is that the selection is completely within the target but
+			// may also have overlap at start or end.
+			if (rangeMainSelection.end < rangeTarget.end)
+				searchRanges.push_back(Range(rangeMainSelection.end, rangeTarget.end));
+			if (rangeTarget.start < rangeMainSelection.start)
+				searchRanges.push_back(Range(rangeTarget.start, rangeMainSelection.start));
+		} else {
+			// No overlap
+			searchRanges.push_back(rangeTarget);
+		}
+
+		for (std::vector<Range>::const_iterator it = searchRanges.begin(); it != searchRanges.end(); ++it) {
+			Sci::Position searchStart = it->start;
+			const Sci::Position searchEnd = it->end;
+			for (;;) {
+				Sci::Position lengthFound = selectedText.length();
+				const Sci::Position pos = pdoc->FindText(searchStart, searchEnd,
+					selectedText.c_str(), searchFlags, &lengthFound);
+				if (pos >= 0) {
+					sel.AddSelection(SelectionRange(pos + lengthFound, pos));
+					ContainerNeedsUpdate(SC_UPDATE_SELECTION);
+					ScrollRange(sel.RangeMain());
+					Redraw();
+					if (addNumber == AddNumber::one)
+						return;
+					searchStart = pos + lengthFound;
+				} else {
+					break;
+				}
+			}
+		}
+	}
 }
 
-bool Editor::RangeContainsProtected(int start, int end) const {
+bool Editor::RangeContainsProtected(Sci::Position start, Sci::Position end) const noexcept {
 	if (vs.ProtectionActive()) {
 		if (start > end) {
-			int t = start;
+			const Sci::Position t = start;
 			start = end;
 			end = t;
 		}
-		int mask = pdoc->stylingBitsMask;
-		for (int pos = start; pos < end; pos++) {
-			if (vs.styles[pdoc->StyleAt(pos) & mask].IsProtected())
+		for (Sci::Position pos = start; pos < end; pos++) {
+			if (vs.styles[pdoc->StyleIndexAt(pos)].IsProtected())
 				return true;
 		}
 	}
 	return false;
 }
 
-bool Editor::SelectionContainsProtected() {
-	// DONE, but untested...: make support rectangular selection
-	bool scp = false;
-	if (selType == selStream) {
-		scp = RangeContainsProtected(anchor, currentPos);
-	} else {
-		SelectionLineIterator lineIterator(this);
-		while (lineIterator.Iterate()) {
-			if (RangeContainsProtected(lineIterator.startPos, lineIterator.endPos)) {
-				scp = true;
-				break;
-			}
+bool Editor::SelectionContainsProtected() const {
+	for (size_t r=0; r<sel.Count(); r++) {
+		if (RangeContainsProtected(sel.Range(r).Start().Position(),
+			sel.Range(r).End().Position())) {
+			return true;
 		}
 	}
-	return scp;
+	return false;
 }
 
 /**
  * Asks document to find a good position and then moves out of any invisible positions.
  */
-int Editor::MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd) {
-	pos = pdoc->MovePositionOutsideChar(pos, moveDir, checkLineEnd);
+Sci::Position Editor::MovePositionOutsideChar(Sci::Position pos, Sci::Position moveDir, bool checkLineEnd) const {
+	return MovePositionOutsideChar(SelectionPosition(pos), moveDir, checkLineEnd).Position();
+}
+
+SelectionPosition Editor::MovePositionOutsideChar(SelectionPosition pos, Sci::Position moveDir, bool checkLineEnd) const {
+	const Sci::Position posMoved = pdoc->MovePositionOutsideChar(pos.Position(), moveDir, checkLineEnd);
+	if (posMoved != pos.Position())
+		pos.SetPosition(posMoved);
 	if (vs.ProtectionActive()) {
-		int mask = pdoc->stylingBitsMask;
 		if (moveDir > 0) {
-			if ((pos > 0) && vs.styles[pdoc->StyleAt(pos - 1) & mask].IsProtected()) {
-				while ((pos < pdoc->Length()) &&
-				        (vs.styles[pdoc->StyleAt(pos) & mask].IsProtected()))
-					pos++;
+			if ((pos.Position() > 0) && vs.styles[pdoc->StyleIndexAt(pos.Position() - 1)].IsProtected()) {
+				while ((pos.Position() < pdoc->Length()) &&
+				        (vs.styles[pdoc->StyleIndexAt(pos.Position())].IsProtected()))
+					pos.Add(1);
 			}
 		} else if (moveDir < 0) {
-			if (vs.styles[pdoc->StyleAt(pos) & mask].IsProtected()) {
-				while ((pos > 0) &&
-				        (vs.styles[pdoc->StyleAt(pos - 1) & mask].IsProtected()))
-					pos--;
+			if (vs.styles[pdoc->StyleIndexAt(pos.Position())].IsProtected()) {
+				while ((pos.Position() > 0) &&
+				        (vs.styles[pdoc->StyleIndexAt(pos.Position() - 1)].IsProtected()))
+					pos.Add(-1);
 			}
 		}
 	}
 	return pos;
 }
 
-int Editor::MovePositionTo(int newPos, selTypes sel, bool ensureVisible) {
-	int delta = newPos - currentPos;
-	newPos = pdoc->ClampPositionIntoDocument(newPos);
-	newPos = MovePositionOutsideChar(newPos, delta);
-	if (sel != noSel) {
-		selType = sel;
+void Editor::MovedCaret(SelectionPosition newPos, SelectionPosition previousPos,
+	bool ensureVisible, CaretPolicies policies) {
+	const Sci::Line currentLine = pdoc->SciLineFromPosition(newPos.Position());
+	if (ensureVisible) {
+		// In case in need of wrapping to ensure DisplayFromDoc works.
+		if (currentLine >= wrapPending.start) {
+			if (WrapLines(WrapScope::wsAll)) {
+				Redraw();
+			}
+		}
+		const XYScrollPosition newXY = XYScrollToMakeVisible(
+			SelectionRange(posDrag.IsValid() ? posDrag : newPos), xysDefault, policies);
+		if (previousPos.IsValid() && (newXY.xOffset == xOffset)) {
+			// simple vertical scroll then invalidate
+			ScrollTo(newXY.topLine);
+			InvalidateSelection(SelectionRange(previousPos), true);
+		} else {
+			SetXYScroll(newXY);
+		}
+	}
+
+	ShowCaretAtCurrentPosition();
+	NotifyCaretMove();
+
+	ClaimSelection();
+	SetHoverIndicatorPosition(sel.MainCaret());
+	QueueIdleWork(WorkNeeded::workUpdateUI);
+
+	if (marginView.highlightDelimiter.NeedsDrawing(currentLine)) {
+		RedrawSelMargin();
 	}
-	if (sel != noSel || moveExtendsSelection) {
+}
+
+void Editor::MovePositionTo(SelectionPosition newPos, Selection::selTypes selt, bool ensureVisible) {
+	const SelectionPosition spCaret = ((sel.Count() == 1) && sel.Empty()) ?
+		sel.Last() : SelectionPosition(INVALID_POSITION);
+
+	const Sci::Position delta = newPos.Position() - sel.MainCaret();
+	newPos = ClampPositionIntoDocument(newPos);
+	newPos = MovePositionOutsideChar(newPos, delta);
+	if (!multipleSelection && sel.IsRectangular() && (selt == Selection::selStream)) {
+		// Can't turn into multiple selection so clear additional selections
+		InvalidateSelection(SelectionRange(newPos), true);
+		sel.DropAdditionalRanges();
+	}
+	if (!sel.IsRectangular() && (selt == Selection::selRectangle)) {
+		// Switching to rectangular
+		InvalidateSelection(sel.RangeMain(), false);
+		SelectionRange rangeMain = sel.RangeMain();
+		sel.Clear();
+		sel.Rectangular() = rangeMain;
+	}
+	if (selt != Selection::noSel) {
+		sel.selType = selt;
+	}
+	if (selt != Selection::noSel || sel.MoveExtends()) {
 		SetSelection(newPos);
 	} else {
 		SetEmptySelection(newPos);
 	}
-	ShowCaretAtCurrentPosition();
-	if (ensureVisible) {
-		EnsureCaretVisible();
-	}
-	NotifyMove(newPos);
-	return 0;
+
+	MovedCaret(newPos, spCaret, ensureVisible, caretPolicies);
+}
+
+void Editor::MovePositionTo(Sci::Position newPos, Selection::selTypes selt, bool ensureVisible) {
+	MovePositionTo(SelectionPosition(newPos), selt, ensureVisible);
 }
 
-int Editor::MovePositionSoVisible(int pos, int moveDir) {
-	pos = pdoc->ClampPositionIntoDocument(pos);
+SelectionPosition Editor::MovePositionSoVisible(SelectionPosition pos, int moveDir) {
+	pos = ClampPositionIntoDocument(pos);
 	pos = MovePositionOutsideChar(pos, moveDir);
-	int lineDoc = pdoc->LineFromPosition(pos);
-	if (cs.GetVisible(lineDoc)) {
+	const Sci::Line lineDoc = pdoc->SciLineFromPosition(pos.Position());
+	if (pcs->GetVisible(lineDoc)) {
 		return pos;
 	} else {
-		int lineDisplay = cs.DisplayFromDoc(lineDoc);
+		Sci::Line lineDisplay = pcs->DisplayFromDoc(lineDoc);
 		if (moveDir > 0) {
 			// lineDisplay is already line before fold as lines in fold use display line of line after fold
-			lineDisplay = Platform::Clamp(lineDisplay, 0, cs.LinesDisplayed());
-			return pdoc->LineStart(cs.DocFromDisplay(lineDisplay));
+			lineDisplay = std::clamp<Sci::Line>(lineDisplay, 0, pcs->LinesDisplayed());
+			return SelectionPosition(
+				pdoc->LineStart(pcs->DocFromDisplay(lineDisplay)));
 		} else {
-			lineDisplay = Platform::Clamp(lineDisplay - 1, 0, cs.LinesDisplayed());
-			return pdoc->LineEnd(cs.DocFromDisplay(lineDisplay));
+			lineDisplay = std::clamp<Sci::Line>(lineDisplay - 1, 0, pcs->LinesDisplayed());
+			return SelectionPosition(
+				pdoc->LineEnd(pcs->DocFromDisplay(lineDisplay)));
 		}
 	}
 }
 
+SelectionPosition Editor::MovePositionSoVisible(Sci::Position pos, int moveDir) {
+	return MovePositionSoVisible(SelectionPosition(pos), moveDir);
+}
+
+Point Editor::PointMainCaret() {
+	return LocationFromPosition(sel.Range(sel.Main()).caret);
+}
+
 /**
  * Choose the x position that the caret will try to stick to
  * as it moves up and down.
  */
 void Editor::SetLastXChosen() {
-	Point pt = LocationFromPosition(currentPos);
-	lastXChosen = pt.x;
+	const Point pt = PointMainCaret();
+	lastXChosen = static_cast<int>(pt.x) + xOffset;
 }
 
-void Editor::ScrollTo(int line, bool moveThumb) {
-	int topLineNew = Platform::Clamp(line, 0, MaxScrollPos());
+void Editor::ScrollTo(Sci::Line line, bool moveThumb) {
+	const Sci::Line topLineNew = std::clamp<Sci::Line>(line, 0, MaxScrollPos());
 	if (topLineNew != topLine) {
 		// Try to optimise small scrolls
-		int linesToMove = topLine - topLineNew;
+#ifndef UNDER_CE
+		const Sci::Line linesToMove = topLine - topLineNew;
+		const bool performBlit = (std::abs(linesToMove) <= 10) && (paintState == notPainting);
+		willRedrawAll = !performBlit;
+#endif
 		SetTopLine(topLineNew);
-		ShowCaretAtCurrentPosition();
-		// Perform redraw rather than scroll if many lines would be redrawn anyway.
+		// Optimize by styling the view as this will invalidate any needed area
+		// which could abort the initial paint if discovered later.
+		StyleAreaBounded(GetClientRectangle(), true);
 #ifndef UNDER_CE
-		if ((abs(linesToMove) <= 10) && (paintState == notPainting)) {
+		// Perform redraw rather than scroll if many lines would be redrawn anyway.
+		if (performBlit) {
 			ScrollText(linesToMove);
 		} else {
 			Redraw();
 		}
+		willRedrawAll = false;
 #else
 		Redraw();
 #endif
@@ -901,7 +980,7 @@ void Editor::ScrollTo(int line, bool moveThumb) {
 	}
 }
 
-void Editor::ScrollText(int /* linesToMove */) {
+void Editor::ScrollText(Sci::Line /* linesToMove */) {
 	//Platform::DebugPrintf("Editor::ScrollText %d\n", linesToMove);
 	Redraw();
 }
@@ -910,51 +989,124 @@ void Editor::HorizontalScrollTo(int xPos) {
 	//Platform::DebugPrintf("HorizontalScroll %d\n", xPos);
 	if (xPos < 0)
 		xPos = 0;
-	if ((wrapState == eWrapNone) && (xOffset != xPos)) {
+	if (!Wrapping() && (xOffset != xPos)) {
 		xOffset = xPos;
+		ContainerNeedsUpdate(SC_UPDATE_H_SCROLL);
 		SetHorizontalScrollPos();
 		RedrawRect(GetClientRectangle());
 	}
 }
 
-void Editor::MoveCaretInsideView(bool ensureVisible) {
-	PRectangle rcClient = GetTextRectangle();
-	Point pt = LocationFromPosition(currentPos);
-	if (pt.y < rcClient.top) {
-		MovePositionTo(PositionFromLocation(
-		            Point(lastXChosen, rcClient.top)),
-		        noSel, ensureVisible);
-	} else if ((pt.y + vs.lineHeight - 1) > rcClient.bottom) {
-		int yOfLastLineFullyDisplayed = rcClient.top + (LinesOnScreen() - 1) * vs.lineHeight;
-		MovePositionTo(PositionFromLocation(
-		            Point(lastXChosen, rcClient.top + yOfLastLineFullyDisplayed)),
-		        noSel, ensureVisible);
+void Editor::VerticalCentreCaret() {
+	const Sci::Line lineDoc =
+		pdoc->SciLineFromPosition(sel.IsRectangular() ? sel.Rectangular().caret.Position() : sel.MainCaret());
+	const Sci::Line lineDisplay = pcs->DisplayFromDoc(lineDoc);
+	const Sci::Line newTop = lineDisplay - (LinesOnScreen() / 2);
+	if (topLine != newTop) {
+		SetTopLine(newTop > 0 ? newTop : 0);
+		RedrawRect(GetClientRectangle());
 	}
 }
 
-int Editor::DisplayFromPosition(int pos) {
-	int lineDoc = pdoc->LineFromPosition(pos);
-	int lineDisplay = cs.DisplayFromDoc(lineDoc);
-	AutoSurface surface(this);
-	AutoLineLayout ll(llc, RetrieveLineLayout(lineDoc));
-	if (surface && ll) {
-		LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
-		unsigned int posLineStart = pdoc->LineStart(lineDoc);
-		int posInLine = pos - posLineStart;
-		lineDisplay--; // To make up for first increment ahead.
-		for (int subLine = 0; subLine < ll->lines; subLine++) {
-			if (posInLine >= ll->LineStart(subLine)) {
-				lineDisplay++;
-			}
-		}
+void Editor::MoveSelectedLines(int lineDelta) {
+
+	if (sel.IsRectangular()) {
+		return;
+	}
+
+	// if selection doesn't start at the beginning of the line, set the new start
+	Sci::Position selectionStart = SelectionStart().Position();
+	const Sci::Line startLine = pdoc->SciLineFromPosition(selectionStart);
+	const Sci::Position beginningOfStartLine = pdoc->LineStart(startLine);
+	selectionStart = beginningOfStartLine;
+
+	// if selection doesn't end at the beginning of a line greater than that of the start,
+	// then set it at the beginning of the next one
+	Sci::Position selectionEnd = SelectionEnd().Position();
+	const Sci::Line endLine = pdoc->SciLineFromPosition(selectionEnd);
+	const Sci::Position beginningOfEndLine = pdoc->LineStart(endLine);
+	bool appendEol = false;
+	if (selectionEnd > beginningOfEndLine
+		|| selectionStart == selectionEnd) {
+		selectionEnd = pdoc->LineStart(endLine + 1);
+		appendEol = (selectionEnd == pdoc->Length() && pdoc->SciLineFromPosition(selectionEnd) == endLine);
+	}
+
+	// if there's nowhere for the selection to move
+	// (i.e. at the beginning going up or at the end going down),
+	// stop it right there!
+	if ((selectionStart == 0 && lineDelta < 0)
+		|| (selectionEnd == pdoc->Length() && lineDelta > 0)
+	        || selectionStart == selectionEnd) {
+		return;
+	}
+
+	UndoGroup ug(pdoc);
+
+	if (lineDelta > 0 && selectionEnd == pdoc->LineStart(pdoc->LinesTotal() - 1)) {
+		SetSelection(pdoc->MovePositionOutsideChar(selectionEnd - 1, -1), selectionEnd);
+		ClearSelection();
+		selectionEnd = CurrentPosition();
+	}
+	SetSelection(selectionStart, selectionEnd);
+
+	SelectionText selectedText;
+	CopySelectionRange(&selectedText);
+
+	const Point currentLocation = LocationFromPosition(CurrentPosition());
+	const Sci::Line currentLine = LineFromLocation(currentLocation);
+
+	if (appendEol)
+		SetSelection(pdoc->MovePositionOutsideChar(selectionStart - 1, -1), selectionEnd);
+	ClearSelection();
+
+	const char *eol = StringFromEOLMode(pdoc->eolMode);
+	if (currentLine + lineDelta >= pdoc->LinesTotal())
+		pdoc->InsertString(pdoc->Length(), eol, strlen(eol));
+	GoToLine(currentLine + lineDelta);
+
+	Sci::Position selectionLength = pdoc->InsertString(CurrentPosition(), selectedText.Data(), selectedText.Length());
+	if (appendEol) {
+		const Sci::Position lengthInserted = pdoc->InsertString(CurrentPosition() + selectionLength, eol, strlen(eol));
+		selectionLength += lengthInserted;
+	}
+	SetSelection(CurrentPosition(), CurrentPosition() + selectionLength);
+}
+
+void Editor::MoveSelectedLinesUp() {
+	MoveSelectedLines(-1);
+}
+
+void Editor::MoveSelectedLinesDown() {
+	MoveSelectedLines(1);
+}
+
+void Editor::MoveCaretInsideView(bool ensureVisible) {
+	const PRectangle rcClient = GetTextRectangle();
+	const Point pt = PointMainCaret();
+	if (pt.y < rcClient.top) {
+		MovePositionTo(SPositionFromLocation(
+		            Point::FromInts(lastXChosen - xOffset, static_cast<int>(rcClient.top)),
+					false, false, UserVirtualSpace()),
+					Selection::noSel, ensureVisible);
+	} else if ((pt.y + vs.lineHeight - 1) > rcClient.bottom) {
+		const ptrdiff_t yOfLastLineFullyDisplayed = static_cast<ptrdiff_t>(rcClient.top) + (LinesOnScreen() - 1) * vs.lineHeight;
+		MovePositionTo(SPositionFromLocation(
+		            Point::FromInts(lastXChosen - xOffset, static_cast<int>(rcClient.top + yOfLastLineFullyDisplayed)),
+					false, false, UserVirtualSpace()),
+		        Selection::noSel, ensureVisible);
 	}
-	return lineDisplay;
+}
+
+Sci::Line Editor::DisplayFromPosition(Sci::Position pos) {
+	AutoSurface surface(this);
+	return view.DisplayFromPosition(surface, *this, pos, vs);
 }
 
 /**
  * Ensure the caret is reasonably visible in context.
  *
-Caret policy in SciTE
+Caret policy in Scintilla
 
 If slop is set, we can define a slop value.
 This value defines an unwanted zone (UZ) where the caret is... unwanted.
@@ -975,11 +1127,11 @@ so the caret can move in the same direction longer before the policy is applied
 
 If even is not set, instead of having symmetrical UZs,
 the left and bottom UZs are extended up to right and top UZs respectively.
-This way, we favour the displaying of useful information: the begining of lines,
+This way, we favour the displaying of useful information: the beginning of lines,
 where most code reside, and the lines after the caret, eg. the body of a function.
 
      |        |       |      |                                            |
-slop | strict | jumps | even | Caret can go to the margin                 | When reaching limitÝ(caret going out of
+slop | strict | jumps | even | Caret can go to the margin                 | When reaching limit (caret going out of
      |        |       |      |                                            | visibility or going into the UZ) display is...
 -----+--------+-------+------+--------------------------------------------+--------------------------------------------------------------
   0  |   0    |   0   |   0  | Yes                                        | moved to put caret on top/on right
@@ -996,44 +1148,44 @@ where most code reside, and the lines after the caret, eg. the body of a functio
   1  |   1    |   0   |   1  | No, kept out of UZ                         | moved by one position
   1  |   1    |   1   |   1  | No, kept out of UZ                         | moved to put caret at 3UZ of the margin
 */
-void Editor::EnsureCaretVisible(bool useMargin, bool vert, bool horiz) {
-	//Platform::DebugPrintf("EnsureCaretVisible %d %s\n", xOffset, useMargin ? " margin" : " ");
-	PRectangle rcClient = GetTextRectangle();
-	//int rcClientFullWidth = rcClient.Width();
-	int posCaret = currentPos;
-	if (posDrag >= 0) {
-		posCaret = posDrag;
+
+Editor::XYScrollPosition Editor::XYScrollToMakeVisible(const SelectionRange &range,
+	const XYScrollOptions options, CaretPolicies policies) {
+	const PRectangle rcClient = GetTextRectangle();
+	const Point ptOrigin = GetVisibleOriginInMain();
+	const Point pt = LocationFromPosition(range.caret) + ptOrigin;
+	const Point ptAnchor = LocationFromPosition(range.anchor) + ptOrigin;
+	const Point ptBottomCaret(pt.x, pt.y + vs.lineHeight - 1);
+
+	XYScrollPosition newXY(xOffset, topLine);
+	if (rcClient.Empty()) {
+		return newXY;
 	}
-	Point pt = LocationFromPosition(posCaret);
-	Point ptBottomCaret = pt;
-	ptBottomCaret.y += vs.lineHeight - 1;
-	int lineCaret = DisplayFromPosition(posCaret);
-	bool bSlop, bStrict, bJump, bEven;
 
 	// Vertical positioning
-	if (vert && (pt.y < rcClient.top || ptBottomCaret.y > rcClient.bottom || (caretYPolicy & CARET_STRICT) != 0)) {
-		int linesOnScreen = LinesOnScreen();
-		int halfScreen = Platform::Maximum(linesOnScreen - 1, 2) / 2;
-		int newTopLine = topLine;
-		bSlop = (caretYPolicy & CARET_SLOP) != 0;
-		bStrict = (caretYPolicy & CARET_STRICT) != 0;
-		bJump = (caretYPolicy & CARET_JUMPS) != 0;
-		bEven = (caretYPolicy & CARET_EVEN) != 0;
+	if ((options & xysVertical) && (pt.y < rcClient.top || ptBottomCaret.y >= rcClient.bottom || (policies.y.policy & CARET_STRICT) != 0)) {
+		const Sci::Line lineCaret = DisplayFromPosition(range.caret.Position());
+		const Sci::Line linesOnScreen = LinesOnScreen();
+		const Sci::Line halfScreen = std::max(linesOnScreen - 1, static_cast<Sci::Line>(2)) / 2;
+		const bool bSlop = (policies.y.policy & CARET_SLOP) != 0;
+		const bool bStrict = (policies.y.policy & CARET_STRICT) != 0;
+		const bool bJump = (policies.y.policy & CARET_JUMPS) != 0;
+		const bool bEven = (policies.y.policy & CARET_EVEN) != 0;
 
 		// It should be possible to scroll the window to show the caret,
 		// but this fails to remove the caret on GTK+
 		if (bSlop) {	// A margin is defined
-			int yMoveT, yMoveB;
+			Sci::Line yMoveT, yMoveB;
 			if (bStrict) {
-				int yMarginT, yMarginB;
-				if (!useMargin) {
+				Sci::Line yMarginT, yMarginB;
+				if (!(options & xysUseMargin)) {
 					// In drag mode, avoid moves
 					// otherwise, a double click will select several lines.
 					yMarginT = yMarginB = 0;
 				} else {
 					// yMarginT must equal to caretYSlop, with a minimum of 1 and
-					// a maximum of slightly less than half the heigth of the text area.
-					yMarginT = Platform::Clamp(caretYSlop, 1, halfScreen);
+					// a maximum of slightly less than half the height of the text area.
+					yMarginT = std::clamp<Sci::Line>(policies.y.slop, 1, halfScreen);
 					if (bEven) {
 						yMarginB = yMarginT;
 					} else {
@@ -1043,7 +1195,7 @@ void Editor::EnsureCaretVisible(bool useMargin, bool vert, bool horiz) {
 				yMoveT = yMarginT;
 				if (bEven) {
 					if (bJump) {
-						yMoveT = Platform::Clamp(caretYSlop * 3, 1, halfScreen);
+						yMoveT = std::clamp<Sci::Line>(policies.y.slop * 3, 1, halfScreen);
 					}
 					yMoveB = yMoveT;
 				} else {
@@ -1051,14 +1203,14 @@ void Editor::EnsureCaretVisible(bool useMargin, bool vert, bool horiz) {
 				}
 				if (lineCaret < topLine + yMarginT) {
 					// Caret goes too high
-					newTopLine = lineCaret - yMoveT;
+					newXY.topLine = lineCaret - yMoveT;
 				} else if (lineCaret > topLine + linesOnScreen - 1 - yMarginB) {
 					// Caret goes too low
-					newTopLine = lineCaret - linesOnScreen + 1 + yMoveB;
+					newXY.topLine = lineCaret - linesOnScreen + 1 + yMoveB;
 				}
 			} else {	// Not strict
-				yMoveT = bJump ? caretYSlop * 3 : caretYSlop;
-				yMoveT = Platform::Clamp(yMoveT, 1, halfScreen);
+				yMoveT = bJump ? policies.y.slop * 3 : policies.y.slop;
+				yMoveT = std::clamp<Sci::Line>(yMoveT, 1, halfScreen);
 				if (bEven) {
 					yMoveB = yMoveT;
 				} else {
@@ -1066,10 +1218,10 @@ void Editor::EnsureCaretVisible(bool useMargin, bool vert, bool horiz) {
 				}
 				if (lineCaret < topLine) {
 					// Caret goes too high
-					newTopLine = lineCaret - yMoveT;
+					newXY.topLine = lineCaret - yMoveT;
 				} else if (lineCaret > topLine + linesOnScreen - 1) {
 					// Caret goes too low
-					newTopLine = lineCaret - linesOnScreen + 1 + yMoveB;
+					newXY.topLine = lineCaret - linesOnScreen + 1 + yMoveB;
 				}
 			}
 		} else {	// No slop
@@ -1077,97 +1229,103 @@ void Editor::EnsureCaretVisible(bool useMargin, bool vert, bool horiz) {
 				// Minimal move
 				if (lineCaret < topLine) {
 					// Caret goes too high
-					newTopLine = lineCaret;
+					newXY.topLine = lineCaret;
 				} else if (lineCaret > topLine + linesOnScreen - 1) {
 					// Caret goes too low
 					if (bEven) {
-						newTopLine = lineCaret - linesOnScreen + 1;
+						newXY.topLine = lineCaret - linesOnScreen + 1;
 					} else {
-						newTopLine = lineCaret;
+						newXY.topLine = lineCaret;
 					}
 				}
 			} else {	// Strict or going out of display
 				if (bEven) {
-					// Always center caret
-					newTopLine = lineCaret - halfScreen;
+					// Always centre caret
+					newXY.topLine = lineCaret - halfScreen;
 				} else {
 					// Always put caret on top of display
-					newTopLine = lineCaret;
+					newXY.topLine = lineCaret;
 				}
 			}
 		}
-		newTopLine = Platform::Clamp(newTopLine, 0, MaxScrollPos());
-		if (newTopLine != topLine) {
-			Redraw();
-			SetTopLine(newTopLine);
-			SetVerticalScrollPos();
+		if (!(range.caret == range.anchor)) {
+			const Sci::Line lineAnchor = DisplayFromPosition(range.anchor.Position());
+			if (lineAnchor < lineCaret) {
+				// Shift up to show anchor or as much of range as possible
+				newXY.topLine = std::min(newXY.topLine, lineAnchor);
+				newXY.topLine = std::max(newXY.topLine, lineCaret - LinesOnScreen());
+			} else {
+				// Shift down to show anchor or as much of range as possible
+				newXY.topLine = std::max(newXY.topLine, lineAnchor - LinesOnScreen());
+				newXY.topLine = std::min(newXY.topLine, lineCaret);
+			}
 		}
+		newXY.topLine = std::clamp<Sci::Line>(newXY.topLine, 0, MaxScrollPos());
 	}
 
 	// Horizontal positioning
-	if (horiz && (wrapState == eWrapNone)) {
-		int halfScreen = Platform::Maximum(rcClient.Width() - 4, 4) / 2;
-		int xOffsetNew = xOffset;
-		bSlop = (caretXPolicy & CARET_SLOP) != 0;
-		bStrict = (caretXPolicy & CARET_STRICT) != 0;
-		bJump = (caretXPolicy & CARET_JUMPS) != 0;
-		bEven = (caretXPolicy & CARET_EVEN) != 0;
+	if ((options & xysHorizontal) && !Wrapping()) {
+		const int halfScreen = std::max(static_cast<int>(rcClient.Width()) - 4, 4) / 2;
+		const bool bSlop = (policies.x.policy & CARET_SLOP) != 0;
+		const bool bStrict = (policies.x.policy & CARET_STRICT) != 0;
+		const bool bJump = (policies.x.policy & CARET_JUMPS) != 0;
+		const bool bEven = (policies.x.policy & CARET_EVEN) != 0;
 
 		if (bSlop) {	// A margin is defined
 			int xMoveL, xMoveR;
 			if (bStrict) {
 				int xMarginL, xMarginR;
-				if (!useMargin) {
+				if (!(options & xysUseMargin)) {
 					// In drag mode, avoid moves unless very near of the margin
 					// otherwise, a simple click will select text.
 					xMarginL = xMarginR = 2;
 				} else {
 					// xMargin must equal to caretXSlop, with a minimum of 2 and
 					// a maximum of slightly less than half the width of the text area.
-					xMarginR = Platform::Clamp(caretXSlop, 2, halfScreen);
+					xMarginR = std::clamp(policies.x.slop, 2, halfScreen);
 					if (bEven) {
 						xMarginL = xMarginR;
 					} else {
-						xMarginL = rcClient.Width() - xMarginR - 4;
+						xMarginL = static_cast<int>(rcClient.Width()) - xMarginR - 4;
 					}
 				}
 				if (bJump && bEven) {
 					// Jump is used only in even mode
-					xMoveL = xMoveR = Platform::Clamp(caretXSlop * 3, 1, halfScreen);
+					xMoveL = xMoveR = std::clamp(policies.x.slop * 3, 1, halfScreen);
 				} else {
 					xMoveL = xMoveR = 0;	// Not used, avoid a warning
 				}
 				if (pt.x < rcClient.left + xMarginL) {
 					// Caret is on the left of the display
 					if (bJump && bEven) {
-						xOffsetNew -= xMoveL;
+						newXY.xOffset -= xMoveL;
 					} else {
 						// Move just enough to allow to display the caret
-						xOffsetNew -= (rcClient.left + xMarginL) - pt.x;
+						newXY.xOffset -= static_cast<int>((rcClient.left + xMarginL) - pt.x);
 					}
 				} else if (pt.x >= rcClient.right - xMarginR) {
 					// Caret is on the right of the display
 					if (bJump && bEven) {
-						xOffsetNew += xMoveR;
+						newXY.xOffset += xMoveR;
 					} else {
 						// Move just enough to allow to display the caret
-						xOffsetNew += pt.x - (rcClient.right - xMarginR) + 1;
+						newXY.xOffset += static_cast<int>(pt.x - (rcClient.right - xMarginR) + 1);
 					}
 				}
 			} else {	// Not strict
-				xMoveR = bJump ? caretXSlop * 3 : caretXSlop;
-				xMoveR = Platform::Clamp(xMoveR, 1, halfScreen);
+				xMoveR = bJump ? policies.x.slop * 3 : policies.x.slop;
+				xMoveR = std::clamp(xMoveR, 1, halfScreen);
 				if (bEven) {
 					xMoveL = xMoveR;
 				} else {
-					xMoveL = rcClient.Width() - xMoveR - 4;
+					xMoveL = static_cast<int>(rcClient.Width()) - xMoveR - 4;
 				}
 				if (pt.x < rcClient.left) {
 					// Caret is on the left of the display
-					xOffsetNew -= xMoveL;
+					newXY.xOffset -= xMoveL;
 				} else if (pt.x >= rcClient.right) {
 					// Caret is on the right of the display
-					xOffsetNew += xMoveR;
+					newXY.xOffset += xMoveR;
 				}
 			}
 		} else {	// No slop
@@ -1175,239 +1333,293 @@ void Editor::EnsureCaretVisible(bool useMargin, bool vert, bool horiz) {
 			        (bJump && (pt.x < rcClient.left || pt.x >= rcClient.right))) {
 				// Strict or going out of display
 				if (bEven) {
-					// Center caret
-					xOffsetNew += pt.x - rcClient.left - halfScreen;
+					// Centre caret
+					newXY.xOffset += static_cast<int>(pt.x - rcClient.left - halfScreen);
 				} else {
 					// Put caret on right
-					xOffsetNew += pt.x - rcClient.right + 1;
+					newXY.xOffset += static_cast<int>(pt.x - rcClient.right + 1);
 				}
 			} else {
 				// Move just enough to allow to display the caret
 				if (pt.x < rcClient.left) {
 					// Caret is on the left of the display
 					if (bEven) {
-						xOffsetNew -= rcClient.left - pt.x;
+						newXY.xOffset -= static_cast<int>(rcClient.left - pt.x);
 					} else {
-						xOffsetNew += pt.x - rcClient.right + 1;
+						newXY.xOffset += static_cast<int>(pt.x - rcClient.right) + 1;
 					}
 				} else if (pt.x >= rcClient.right) {
 					// Caret is on the right of the display
-					xOffsetNew += pt.x - rcClient.right + 1;
+					newXY.xOffset += static_cast<int>(pt.x - rcClient.right) + 1;
 				}
 			}
 		}
 		// In case of a jump (find result) largely out of display, adjust the offset to display the caret
-		if (pt.x + xOffset < rcClient.left + xOffsetNew) {
-			xOffsetNew = pt.x + xOffset - rcClient.left;
-		} else if (pt.x + xOffset >= rcClient.right + xOffsetNew) {
-			xOffsetNew = pt.x + xOffset - rcClient.right + 1;
-			if (vs.caretStyle == CARETSTYLE_BLOCK) {
+		if (pt.x + xOffset < rcClient.left + newXY.xOffset) {
+			newXY.xOffset = static_cast<int>(pt.x + xOffset - rcClient.left) - 2;
+		} else if (pt.x + xOffset >= rcClient.right + newXY.xOffset) {
+			newXY.xOffset = static_cast<int>(pt.x + xOffset - rcClient.right) + 2;
+			if (vs.IsBlockCaretStyle() || view.imeCaretBlockOverride) {
 				// Ensure we can see a good portion of the block caret
-				xOffsetNew += vs.aveCharWidth;
+				newXY.xOffset += static_cast<int>(vs.aveCharWidth);
 			}
 		}
-		if (xOffsetNew < 0) {
-			xOffsetNew = 0;
+		if (!(range.caret == range.anchor)) {
+			if (ptAnchor.x < pt.x) {
+				// Shift to left to show anchor or as much of range as possible
+				const int maxOffset = static_cast<int>(ptAnchor.x + xOffset - rcClient.left) - 1;
+				const int minOffset = static_cast<int>(pt.x + xOffset - rcClient.right) + 1;
+				newXY.xOffset = std::min(newXY.xOffset, maxOffset);
+				newXY.xOffset = std::max(newXY.xOffset, minOffset);
+			} else {
+				// Shift to right to show anchor or as much of range as possible
+				const int minOffset = static_cast<int>(ptAnchor.x + xOffset - rcClient.right) + 1;
+				const int maxOffset = static_cast<int>(pt.x + xOffset - rcClient.left) - 1;
+				newXY.xOffset = std::max(newXY.xOffset, minOffset);
+				newXY.xOffset = std::min(newXY.xOffset, maxOffset);
+			}
+		}
+		if (newXY.xOffset < 0) {
+			newXY.xOffset = 0;
+		}
+	}
+
+	return newXY;
+}
+
+void Editor::SetXYScroll(XYScrollPosition newXY) {
+	if ((newXY.topLine != topLine) || (newXY.xOffset != xOffset)) {
+		if (newXY.topLine != topLine) {
+			SetTopLine(newXY.topLine);
+			SetVerticalScrollPos();
 		}
-		if (xOffset != xOffsetNew) {
-			xOffset = xOffsetNew;
-			if (xOffsetNew > 0) {
-				PRectangle rcText = GetTextRectangle();
+		if (newXY.xOffset != xOffset) {
+			xOffset = newXY.xOffset;
+			ContainerNeedsUpdate(SC_UPDATE_H_SCROLL);
+			if (newXY.xOffset > 0) {
+				const PRectangle rcText = GetTextRectangle();
 				if (horizontalScrollBarVisible &&
-				        rcText.Width() + xOffset > scrollWidth) {
-					scrollWidth = xOffset + rcText.Width();
+					rcText.Width() + xOffset > scrollWidth) {
+					scrollWidth = xOffset + static_cast<int>(rcText.Width());
 					SetScrollBars();
 				}
 			}
 			SetHorizontalScrollPos();
-			Redraw();
 		}
+		Redraw();
+		UpdateSystemCaret();
 	}
-	UpdateSystemCaret();
+}
+
+void Editor::ScrollRange(SelectionRange range) {
+	SetXYScroll(XYScrollToMakeVisible(range, xysDefault, caretPolicies));
+}
+
+void Editor::EnsureCaretVisible(bool useMargin, bool vert, bool horiz) {
+	SetXYScroll(XYScrollToMakeVisible(SelectionRange(posDrag.IsValid() ? posDrag : sel.RangeMain().caret),
+		static_cast<XYScrollOptions>((useMargin?xysUseMargin:0)|(vert?xysVertical:0)|(horiz?xysHorizontal:0)),
+		caretPolicies));
 }
 
 void Editor::ShowCaretAtCurrentPosition() {
 	if (hasFocus) {
 		caret.active = true;
 		caret.on = true;
-		SetTicking(true);
+		FineTickerCancel(tickCaret);
+		if (caret.period > 0)
+			FineTickerStart(tickCaret, caret.period, caret.period/10);
 	} else {
 		caret.active = false;
 		caret.on = false;
+		FineTickerCancel(tickCaret);
 	}
 	InvalidateCaret();
 }
 
 void Editor::DropCaret() {
 	caret.active = false;
+	FineTickerCancel(tickCaret);
 	InvalidateCaret();
 }
 
+void Editor::CaretSetPeriod(int period) {
+	if (caret.period != period) {
+		caret.period = period;
+		caret.on = true;
+		FineTickerCancel(tickCaret);
+		if ((caret.active) && (caret.period > 0))
+			FineTickerStart(tickCaret, caret.period, caret.period/10);
+		InvalidateCaret();
+	}
+}
+
 void Editor::InvalidateCaret() {
-	if (posDrag >= 0)
-		InvalidateRange(posDrag, posDrag + 1);
-	else
-		InvalidateRange(currentPos, currentPos + 1);
+	if (posDrag.IsValid()) {
+		InvalidateRange(posDrag.Position(), posDrag.Position() + 1);
+	} else {
+		for (size_t r=0; r<sel.Count(); r++) {
+			InvalidateRange(sel.Range(r).caret.Position(), sel.Range(r).caret.Position() + 1);
+		}
+	}
 	UpdateSystemCaret();
 }
 
+void Editor::NotifyCaretMove() {
+}
+
 void Editor::UpdateSystemCaret() {
 }
 
-void Editor::NeedWrapping(int docLineStart, int docLineEnd) {
-	docLineStart = Platform::Clamp(docLineStart, 0, pdoc->LinesTotal());
-	if (wrapStart > docLineStart) {
-		wrapStart = docLineStart;
-		llc.Invalidate(LineLayout::llPositions);
-	}
-	if (wrapEnd < docLineEnd) {
-		wrapEnd = docLineEnd;
+bool Editor::Wrapping() const noexcept {
+	return vs.wrapState != WrapMode::none;
+}
+
+void Editor::NeedWrapping(Sci::Line docLineStart, Sci::Line docLineEnd) {
+//Platform::DebugPrintf("\nNeedWrapping: %0d..%0d\n", docLineStart, docLineEnd);
+	if (wrapPending.AddRange(docLineStart, docLineEnd)) {
+		view.llc.Invalidate(LineLayout::ValidLevel::positions);
 	}
-	wrapEnd = Platform::Clamp(wrapEnd, 0, pdoc->LinesTotal());
 	// Wrap lines during idle.
-	if ((wrapState != eWrapNone) && (wrapEnd != wrapStart)) {
+	if (Wrapping() && wrapPending.NeedsWrap()) {
 		SetIdle(true);
 	}
 }
 
-bool Editor::WrapOneLine(Surface *surface, int lineToWrap) {
-	AutoLineLayout ll(llc, RetrieveLineLayout(lineToWrap));
+bool Editor::WrapOneLine(Surface *surface, Sci::Line lineToWrap) {
+	AutoLineLayout ll(view.llc, view.RetrieveLineLayout(lineToWrap, *this));
 	int linesWrapped = 1;
 	if (ll) {
-		LayoutLine(lineToWrap, surface, vs, ll, wrapWidth);
+		view.LayoutLine(*this, lineToWrap, surface, vs, ll, wrapWidth);
 		linesWrapped = ll->lines;
 	}
-	return cs.SetHeight(lineToWrap, linesWrapped);
+	return pcs->SetHeight(lineToWrap, linesWrapped +
+		(vs.annotationVisible ? pdoc->AnnotationLines(lineToWrap) : 0));
 }
 
-// Check if wrapping needed and perform any needed wrapping.
-// fullwrap: if true, all lines which need wrapping will be done,
-//           in this single call.
-// priorityWrapLineStart: If greater than zero, all lines starting from
-//           here to 1 page + 100 lines past will be wrapped (even if there are
-//           more lines under wrapping process in idle).
-// If it is neither fullwrap, nor priorityWrap, then 1 page + 100 lines will be
-// wrapped, if there are any wrapping going on in idle. (Generally this
-// condition is called only from idler).
+// Perform  wrapping for a subset of the lines needing wrapping.
+// wsAll: wrap all lines which need wrapping in this single call
+// wsVisible: wrap currently visible lines
+// wsIdle: wrap one page + 100 lines
 // Return true if wrapping occurred.
-bool Editor::WrapLines(bool fullWrap, int priorityWrapLineStart) {
-	// If there are any pending wraps, do them during idle if possible.
-	int linesInOneCall = LinesOnScreen() + 100;
-	if (wrapState != eWrapNone) {
-		if (wrapStart < wrapEnd) {
-			if (!SetIdle(true)) {
-				// Idle processing not supported so full wrap required.
-				fullWrap = true;
-			}
-		}
-		if (!fullWrap && priorityWrapLineStart >= 0 &&
-		        // .. and if the paint window is outside pending wraps
-		        (((priorityWrapLineStart + linesInOneCall) < wrapStart) ||
-		         (priorityWrapLineStart > wrapEnd))) {
-			// No priority wrap pending
-			return false;
-		}
-	}
-	int goodTopLine = topLine;
+bool Editor::WrapLines(WrapScope ws) {
+	Sci::Line goodTopLine = topLine;
 	bool wrapOccurred = false;
-	if (wrapStart <= pdoc->LinesTotal()) {
-		if (wrapState == eWrapNone) {
-			if (wrapWidth != LineLayout::wrapWidthInfinite) {
-				wrapWidth = LineLayout::wrapWidthInfinite;
-				for (int lineDoc = 0; lineDoc < pdoc->LinesTotal(); lineDoc++) {
-					cs.SetHeight(lineDoc, 1);
-				}
-				wrapOccurred = true;
+	if (!Wrapping()) {
+		if (wrapWidth != LineLayout::wrapWidthInfinite) {
+			wrapWidth = LineLayout::wrapWidthInfinite;
+			for (Sci::Line lineDoc = 0; lineDoc < pdoc->LinesTotal(); lineDoc++) {
+				pcs->SetHeight(lineDoc, 1 +
+					(vs.annotationVisible ? pdoc->AnnotationLines(lineDoc) : 0));
 			}
-			wrapStart = wrapLineLarge;
-			wrapEnd = wrapLineLarge;
-		} else {
-			if (wrapEnd >= pdoc->LinesTotal())
-				wrapEnd = pdoc->LinesTotal();
-			//ElapsedTime et;
-			int lineDocTop = cs.DocFromDisplay(topLine);
-			int subLineTop = topLine - cs.DisplayFromDoc(lineDocTop);
+			wrapOccurred = true;
+		}
+		wrapPending.Reset();
+
+	} else if (wrapPending.NeedsWrap()) {
+		wrapPending.start = std::min(wrapPending.start, pdoc->LinesTotal());
+		if (!SetIdle(true)) {
+			// Idle processing not supported so full wrap required.
+			ws = WrapScope::wsAll;
+		}
+		// Decide where to start wrapping
+		Sci::Line lineToWrap = wrapPending.start;
+		Sci::Line lineToWrapEnd = std::min(wrapPending.end, pdoc->LinesTotal());
+		const Sci::Line lineDocTop = pcs->DocFromDisplay(topLine);
+		const Sci::Line subLineTop = topLine - pcs->DisplayFromDoc(lineDocTop);
+		if (ws == WrapScope::wsVisible) {
+			lineToWrap = std::clamp(lineDocTop-5, wrapPending.start, pdoc->LinesTotal());
+			// Priority wrap to just after visible area.
+			// Since wrapping could reduce display lines, treat each
+			// as taking only one display line.
+			lineToWrapEnd = lineDocTop;
+			Sci::Line lines = LinesOnScreen() + 1;
+			while ((lineToWrapEnd < pcs->LinesInDoc()) && (lines>0)) {
+				if (pcs->GetVisible(lineToWrapEnd))
+					lines--;
+				lineToWrapEnd++;
+			}
+			// .. and if the paint window is outside pending wraps
+			if ((lineToWrap > wrapPending.end) || (lineToWrapEnd < wrapPending.start)) {
+				// Currently visible text does not need wrapping
+				return false;
+			}
+		} else if (ws == WrapScope::wsIdle) {
+			// Try to keep time taken by wrapping reasonable so interaction remains smooth.
+			constexpr double secondsAllowed = 0.01;
+			const Sci::Line linesInAllowedTime = std::clamp<Sci::Line>(
+				static_cast<Sci::Line>(secondsAllowed / durationWrapOneLine.Duration()),
+				LinesOnScreen() + 50, 0x10000);
+			lineToWrapEnd = lineToWrap + linesInAllowedTime;
+		}
+		const Sci::Line lineEndNeedWrap = std::min(wrapPending.end, pdoc->LinesTotal());
+		lineToWrapEnd = std::min(lineToWrapEnd, lineEndNeedWrap);
+
+		// Ensure all lines being wrapped are styled.
+		pdoc->EnsureStyledTo(pdoc->LineStart(lineToWrapEnd));
+
+		if (lineToWrap < lineToWrapEnd) {
+
 			PRectangle rcTextArea = GetClientRectangle();
-			rcTextArea.left = vs.fixedColumnWidth;
+			rcTextArea.left = static_cast<XYPOSITION>(vs.textStart);
 			rcTextArea.right -= vs.rightMarginWidth;
-			wrapWidth = rcTextArea.Width();
-			// Ensure all of the document is styled.
-			pdoc->EnsureStyledTo(pdoc->Length());
+			wrapWidth = static_cast<int>(rcTextArea.Width());
 			RefreshStyleData();
 			AutoSurface surface(this);
 			if (surface) {
-				bool priorityWrap = false;
-				int lastLineToWrap = wrapEnd;
-				int lineToWrap = wrapStart;
-				if (!fullWrap) {
-					if (priorityWrapLineStart >= 0) {
-						// This is a priority wrap.
-						lineToWrap = priorityWrapLineStart;
-						lastLineToWrap = priorityWrapLineStart + linesInOneCall;
-						priorityWrap = true;
-					} else {
-						// This is idle wrap.
-						lastLineToWrap = wrapStart + linesInOneCall;
-					}
-					if (lastLineToWrap >= wrapEnd)
-						lastLineToWrap = wrapEnd;
-				} // else do a fullWrap.
+//Platform::DebugPrintf("Wraplines: scope=%0d need=%0d..%0d perform=%0d..%0d\n", ws, wrapPending.start, wrapPending.end, lineToWrap, lineToWrapEnd);
 
-				// Platform::DebugPrintf("Wraplines: full = %d, priorityStart = %d (wrapping: %d to %d)\n", fullWrap, priorityWrapLineStart, lineToWrap, lastLineToWrap);
-				// Platform::DebugPrintf("Pending wraps: %d to %d\n", wrapStart, wrapEnd);
-				while (lineToWrap < lastLineToWrap) {
+				const Sci::Line linesBeingWrapped = lineToWrapEnd - lineToWrap;
+				ElapsedPeriod epWrapping;
+				while (lineToWrap < lineToWrapEnd) {
 					if (WrapOneLine(surface, lineToWrap)) {
 						wrapOccurred = true;
 					}
+					wrapPending.Wrapped(lineToWrap);
 					lineToWrap++;
 				}
-				if (!priorityWrap)
-					wrapStart = lineToWrap;
-				// If wrapping is done, bring it to resting position
-				if (wrapStart >= wrapEnd) {
-					wrapStart = wrapLineLarge;
-					wrapEnd = wrapLineLarge;
-				}
+				durationWrapOneLine.AddSample(linesBeingWrapped, epWrapping.Duration());
+
+				goodTopLine = pcs->DisplayFromDoc(lineDocTop) + std::min(
+					subLineTop, static_cast<Sci::Line>(pcs->GetHeight(lineDocTop)-1));
 			}
-			goodTopLine = cs.DisplayFromDoc(lineDocTop);
-			if (subLineTop < cs.GetHeight(lineDocTop))
-				goodTopLine += subLineTop;
-			else
-				goodTopLine += cs.GetHeight(lineDocTop);
-			//double durWrap = et.Duration(true);
-			//Platform::DebugPrintf("Wrap:%9.6g \n", durWrap);
+		}
+
+		// If wrapping is done, bring it to resting position
+		if (wrapPending.start >= lineEndNeedWrap) {
+			wrapPending.Reset();
 		}
 	}
+
 	if (wrapOccurred) {
 		SetScrollBars();
-		SetTopLine(Platform::Clamp(goodTopLine, 0, MaxScrollPos()));
+		SetTopLine(std::clamp<Sci::Line>(goodTopLine, 0, MaxScrollPos()));
 		SetVerticalScrollPos();
 	}
+
 	return wrapOccurred;
 }
 
 void Editor::LinesJoin() {
-	if (!RangeContainsProtected(targetStart, targetEnd)) {
-		pdoc->BeginUndoAction();
+	if (!RangeContainsProtected(targetRange.start.Position(), targetRange.end.Position())) {
+		UndoGroup ug(pdoc);
 		bool prevNonWS = true;
-		for (int pos = targetStart; pos < targetEnd; pos++) {
-			if (IsEOLChar(pdoc->CharAt(pos))) {
-				targetEnd -= pdoc->LenChar(pos);
+		for (Sci::Position pos = targetRange.start.Position(); pos < targetRange.end.Position(); pos++) {
+			if (pdoc->IsPositionInLineEnd(pos)) {
+				targetRange.end.Add(-pdoc->LenChar(pos));
 				pdoc->DelChar(pos);
 				if (prevNonWS) {
 					// Ensure at least one space separating previous lines
-					pdoc->InsertChar(pos, ' ');
-					targetEnd++;
+					const Sci::Position lengthInserted = pdoc->InsertString(pos, " ", 1);
+					targetRange.end.Add(lengthInserted);
 				}
 			} else {
 				prevNonWS = pdoc->CharAt(pos) != ' ';
 			}
 		}
-		pdoc->EndUndoAction();
 	}
 }
 
-const char *Editor::StringFromEOLMode(int eolMode) {
+const char *Editor::StringFromEOLMode(int eolMode) noexcept {
 	if (eolMode == SC_EOL_CRLF) {
 		return "\r\n";
 	} else if (eolMode == SC_EOL_CR) {
@@ -1418,2094 +1630,522 @@ const char *Editor::StringFromEOLMode(int eolMode) {
 }
 
 void Editor::LinesSplit(int pixelWidth) {
-	if (!RangeContainsProtected(targetStart, targetEnd)) {
+	if (!RangeContainsProtected(targetRange.start.Position(), targetRange.end.Position())) {
 		if (pixelWidth == 0) {
-			PRectangle rcText = GetTextRectangle();
-			pixelWidth = rcText.Width();
+			const PRectangle rcText = GetTextRectangle();
+			pixelWidth = static_cast<int>(rcText.Width());
 		}
-		int lineStart = pdoc->LineFromPosition(targetStart);
-		int lineEnd = pdoc->LineFromPosition(targetEnd);
+		const Sci::Line lineStart = pdoc->SciLineFromPosition(targetRange.start.Position());
+		Sci::Line lineEnd = pdoc->SciLineFromPosition(targetRange.end.Position());
 		const char *eol = StringFromEOLMode(pdoc->eolMode);
-		pdoc->BeginUndoAction();
-		for (int line = lineStart; line <= lineEnd; line++) {
+		UndoGroup ug(pdoc);
+		for (Sci::Line line = lineStart; line <= lineEnd; line++) {
 			AutoSurface surface(this);
-			AutoLineLayout ll(llc, RetrieveLineLayout(line));
+			AutoLineLayout ll(view.llc, view.RetrieveLineLayout(line, *this));
 			if (surface && ll) {
-				unsigned int posLineStart = pdoc->LineStart(line);
-				LayoutLine(line, surface, vs, ll, pixelWidth);
+				const Sci::Position posLineStart = pdoc->LineStart(line);
+				view.LayoutLine(*this, line, surface, vs, ll, pixelWidth);
+				Sci::Position lengthInsertedTotal = 0;
 				for (int subLine = 1; subLine < ll->lines; subLine++) {
-					pdoc->InsertCString(posLineStart + (subLine - 1) * strlen(eol) +
-					        ll->LineStart(subLine), eol);
-					targetEnd += static_cast<int>(strlen(eol));
+					const Sci::Position lengthInserted = pdoc->InsertString(
+						posLineStart + lengthInsertedTotal + ll->LineStart(subLine),
+						eol, strlen(eol));
+					targetRange.end.Add(lengthInserted);
+					lengthInsertedTotal += lengthInserted;
 				}
 			}
-			lineEnd = pdoc->LineFromPosition(targetEnd);
+			lineEnd = pdoc->SciLineFromPosition(targetRange.end.Position());
 		}
-		pdoc->EndUndoAction();
 	}
 }
 
-int Editor::SubstituteMarkerIfEmpty(int markerCheck, int markerDefault) {
-	if (vs.markers[markerCheck].markType == SC_MARK_EMPTY)
-		return markerDefault;
-	return markerCheck;
-}
+void Editor::PaintSelMargin(Surface *surfaceWindow, const PRectangle &rc) {
+	if (vs.fixedColumnWidth == 0)
+		return;
 
-// Avoid 64 bit compiler warnings.
-// Scintilla does not support text buffers larger than 2**31
-static int istrlen(const char *s) {
-	return static_cast<int>(strlen(s));
-}
+	AllocateGraphics();
+	RefreshStyleData();
+	RefreshPixMaps(surfaceWindow);
 
-void Editor::PaintSelMargin(Surface *surfWindow, PRectangle &rc) {
-	if (vs.fixedColumnWidth == 0)
+	// On GTK+ with Ubuntu overlay scroll bars, the surface may have been finished
+	// at this point. The Initialised call checks for this case and sets the status
+	// to be bad which avoids crashes in following calls.
+	if (!surfaceWindow->Initialised()) {
 		return;
+	}
 
 	PRectangle rcMargin = GetClientRectangle();
-	rcMargin.right = vs.fixedColumnWidth;
+	const Point ptOrigin = GetVisibleOriginInMain();
+	rcMargin.Move(0, -ptOrigin.y);
+	rcMargin.left = 0;
+	rcMargin.right = static_cast<XYPOSITION>(vs.fixedColumnWidth);
 
 	if (!rc.Intersects(rcMargin))
 		return;
 
 	Surface *surface;
-	if (bufferedDraw) {
-		surface = pixmapSelMargin;
+	if (view.bufferedDraw) {
+		surface = marginView.pixmapSelMargin.get();
 	} else {
-		surface = surfWindow;
+		surface = surfaceWindow;
 	}
 
-	PRectangle rcSelMargin = rcMargin;
-	rcSelMargin.right = rcMargin.left;
-
-	for (int margin = 0; margin < vs.margins; margin++) {
-		if (vs.ms[margin].width > 0) {
-
-			rcSelMargin.left = rcSelMargin.right;
-			rcSelMargin.right = rcSelMargin.left + vs.ms[margin].width;
-
-			if (vs.ms[margin].style != SC_MARGIN_NUMBER) {
-				/* alternate scheme:
-				if (vs.ms[margin].mask & SC_MASK_FOLDERS)
-					surface->FillRectangle(rcSelMargin, vs.styles[STYLE_DEFAULT].back.allocated);
-				else
-					// Required because of special way brush is created for selection margin
-					surface->FillRectangle(rcSelMargin, pixmapSelPattern);
-				*/
-				if (vs.ms[margin].mask & SC_MASK_FOLDERS)
-					// Required because of special way brush is created for selection margin
-					surface->FillRectangle(rcSelMargin, *pixmapSelPattern);
-				else {
-					ColourAllocated colour;
-					switch (vs.ms[margin].style) {
-					case SC_MARGIN_BACK:
-						colour = vs.styles[STYLE_DEFAULT].back.allocated;
-						break;
-					case SC_MARGIN_FORE:
-						colour = vs.styles[STYLE_DEFAULT].fore.allocated;
-						break;
-					default:
-						colour = vs.styles[STYLE_LINENUMBER].back.allocated;
-						break;
-					}
-					surface->FillRectangle(rcSelMargin, colour);
-				}
-			} else {
-				surface->FillRectangle(rcSelMargin, vs.styles[STYLE_LINENUMBER].back.allocated);
-			}
-
-			int visibleLine = topLine;
-			int yposScreen = 0;
-
-			// Work out whether the top line is whitespace located after a
-			// lessening of fold level which implies a 'fold tail' but which should not
-			// be displayed until the last of a sequence of whitespace.
-			bool needWhiteClosure = false;
-			int level = pdoc->GetLevel(cs.DocFromDisplay(topLine));
-			if (level & SC_FOLDLEVELWHITEFLAG) {
-				int lineBack = cs.DocFromDisplay(topLine);
-				int levelPrev = level;
-				while ((lineBack > 0) && (levelPrev & SC_FOLDLEVELWHITEFLAG)) {
-					lineBack--;
-					levelPrev = pdoc->GetLevel(lineBack);
-				}
-				if (!(levelPrev & SC_FOLDLEVELHEADERFLAG)) {
-					if ((level & SC_FOLDLEVELNUMBERMASK) < (levelPrev & SC_FOLDLEVELNUMBERMASK))
-						needWhiteClosure = true;
-				}
-			}
+	// Clip vertically to paint area to avoid drawing line numbers
+	if (rcMargin.bottom > rc.bottom)
+		rcMargin.bottom = rc.bottom;
+	if (rcMargin.top < rc.top)
+		rcMargin.top = rc.top;
 
-			// Old code does not know about new markers needed to distinguish all cases
-			int folderOpenMid = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEROPENMID,
-			        SC_MARKNUM_FOLDEROPEN);
-			int folderEnd = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEREND,
-			        SC_MARKNUM_FOLDER);
-
-			while ((visibleLine < cs.LinesDisplayed()) && yposScreen < rcMargin.bottom) {
-
-				PLATFORM_ASSERT(visibleLine < cs.LinesDisplayed());
-
-				int lineDoc = cs.DocFromDisplay(visibleLine);
-				PLATFORM_ASSERT(cs.GetVisible(lineDoc));
-				bool firstSubLine = visibleLine == cs.DisplayFromDoc(lineDoc);
-
-				// Decide which fold indicator should be displayed
-				level = pdoc->GetLevel(lineDoc);
-				int levelNext = pdoc->GetLevel(lineDoc + 1);
-				int marks = pdoc->GetMark(lineDoc);
-				if (!firstSubLine)
-					marks = 0;
-				int levelNum = level & SC_FOLDLEVELNUMBERMASK;
-				int levelNextNum = levelNext & SC_FOLDLEVELNUMBERMASK;
-				if (level & SC_FOLDLEVELHEADERFLAG) {
-					if (firstSubLine) {
-						if (cs.GetExpanded(lineDoc)) {
-							if (levelNum == SC_FOLDLEVELBASE)
-								marks |= 1 << SC_MARKNUM_FOLDEROPEN;
-							else
-								marks |= 1 << folderOpenMid;
-						} else {
-							if (levelNum == SC_FOLDLEVELBASE)
-								marks |= 1 << SC_MARKNUM_FOLDER;
-							else
-								marks |= 1 << folderEnd;
-						}
-					} else {
-						marks |= 1 << SC_MARKNUM_FOLDERSUB;
-					}
-					needWhiteClosure = false;
-				} else if (level & SC_FOLDLEVELWHITEFLAG) {
-					if (needWhiteClosure) {
-						if (levelNext & SC_FOLDLEVELWHITEFLAG) {
-							marks |= 1 << SC_MARKNUM_FOLDERSUB;
-						} else if (levelNum > SC_FOLDLEVELBASE) {
-							marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
-							needWhiteClosure = false;
-						} else {
-							marks |= 1 << SC_MARKNUM_FOLDERTAIL;
-							needWhiteClosure = false;
-						}
-					} else if (levelNum > SC_FOLDLEVELBASE) {
-						if (levelNextNum < levelNum) {
-							if (levelNextNum > SC_FOLDLEVELBASE) {
-								marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
-							} else {
-								marks |= 1 << SC_MARKNUM_FOLDERTAIL;
-							}
-						} else {
-							marks |= 1 << SC_MARKNUM_FOLDERSUB;
-						}
-					}
-				} else if (levelNum > SC_FOLDLEVELBASE) {
-					if (levelNextNum < levelNum) {
-						needWhiteClosure = false;
-						if (levelNext & SC_FOLDLEVELWHITEFLAG) {
-							marks |= 1 << SC_MARKNUM_FOLDERSUB;
-							needWhiteClosure = true;
-						} else if (levelNextNum > SC_FOLDLEVELBASE) {
-							marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
-						} else {
-							marks |= 1 << SC_MARKNUM_FOLDERTAIL;
-						}
-					} else {
-						marks |= 1 << SC_MARKNUM_FOLDERSUB;
-					}
-				}
+	marginView.PaintMargin(surface, topLine, rc, rcMargin, *this, vs);
 
-				marks &= vs.ms[margin].mask;
-				PRectangle rcMarker = rcSelMargin;
-				rcMarker.top = yposScreen;
-				rcMarker.bottom = yposScreen + vs.lineHeight;
-				if (vs.ms[margin].style == SC_MARGIN_NUMBER) {
-					char number[100];
-					number[0] = '\0';
-					if (firstSubLine)
-						sprintf(number, "%d", lineDoc + 1);
-					if (foldFlags & SC_FOLDFLAG_LEVELNUMBERS) {
-						int lev = pdoc->GetLevel(lineDoc);
-						sprintf(number, "%c%c %03X %03X",
-						        (lev & SC_FOLDLEVELHEADERFLAG) ? 'H' : '_',
-						        (lev & SC_FOLDLEVELWHITEFLAG) ? 'W' : '_',
-						        lev & SC_FOLDLEVELNUMBERMASK,
-						        lev >> 16
-						       );
-					}
-					PRectangle rcNumber = rcMarker;
-					// Right justify
-					int width = surface->WidthText(vs.styles[STYLE_LINENUMBER].font, number, istrlen(number));
-					int xpos = rcNumber.right - width - 3;
-					rcNumber.left = xpos;
-					surface->DrawTextNoClip(rcNumber, vs.styles[STYLE_LINENUMBER].font,
-					        rcNumber.top + vs.maxAscent, number, istrlen(number),
-					        vs.styles[STYLE_LINENUMBER].fore.allocated,
-					        vs.styles[STYLE_LINENUMBER].back.allocated);
-				}
+	if (view.bufferedDraw) {
+		surfaceWindow->Copy(rcMargin, Point(rcMargin.left, rcMargin.top), *marginView.pixmapSelMargin);
+	}
+}
 
-				if (marks) {
-					for (int markBit = 0; (markBit < 32) && marks; markBit++) {
-						if (marks & 1) {
-							vs.markers[markBit].Draw(surface, rcMarker, vs.styles[STYLE_LINENUMBER].font);
-						}
-						marks >>= 1;
-					}
-				}
+void Editor::RefreshPixMaps(Surface *surfaceWindow) {
+	view.RefreshPixMaps(surfaceWindow, wMain.GetID(), vs);
+	marginView.RefreshPixMaps(surfaceWindow, wMain.GetID(), vs);
+	if (view.bufferedDraw) {
+		const PRectangle rcClient = GetClientRectangle();
+		if (!view.pixmapLine->Initialised()) {
 
-				visibleLine++;
-				yposScreen += vs.lineHeight;
-			}
+			view.pixmapLine->InitPixMap(static_cast<int>(rcClient.Width()), vs.lineHeight,
+			        surfaceWindow, wMain.GetID());
+		}
+		if (!marginView.pixmapSelMargin->Initialised()) {
+			marginView.pixmapSelMargin->InitPixMap(vs.fixedColumnWidth,
+				static_cast<int>(rcClient.Height()), surfaceWindow, wMain.GetID());
 		}
 	}
+}
 
-	PRectangle rcBlankMargin = rcMargin;
-	rcBlankMargin.left = rcSelMargin.right;
-	surface->FillRectangle(rcBlankMargin, vs.styles[STYLE_DEFAULT].back.allocated);
+void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) {
+	//Platform::DebugPrintf("Paint:%1d (%3d,%3d) ... (%3d,%3d)\n",
+	//	paintingAllText, rcArea.left, rcArea.top, rcArea.right, rcArea.bottom);
+	AllocateGraphics();
 
-	if (bufferedDraw) {
-		surfWindow->Copy(rcMargin, Point(), *pixmapSelMargin);
-	}
-}
+	RefreshStyleData();
+	if (paintState == paintAbandoned)
+		return;	// Scroll bars may have changed so need redraw
+	RefreshPixMaps(surfaceWindow);
 
-void DrawTabArrow(Surface *surface, PRectangle rcTab, int ymid) {
-	int ydiff = (rcTab.bottom - rcTab.top) / 2;
-	int xhead = rcTab.right - 1 - ydiff;
-	if (xhead <= rcTab.left) {
-		ydiff -= rcTab.left - xhead - 1;
-		xhead = rcTab.left - 1;
-	}
-	if ((rcTab.left + 2) < (rcTab.right - 1))
-		surface->MoveTo(rcTab.left + 2, ymid);
-	else
-		surface->MoveTo(rcTab.right - 1, ymid);
-	surface->LineTo(rcTab.right - 1, ymid);
-	surface->LineTo(xhead, ymid - ydiff);
-	surface->MoveTo(rcTab.right - 1, ymid);
-	surface->LineTo(xhead, ymid + ydiff);
-}
+	paintAbandonedByStyling = false;
 
-LineLayout *Editor::RetrieveLineLayout(int lineNumber) {
-	int posLineStart = pdoc->LineStart(lineNumber);
-	int posLineEnd = pdoc->LineStart(lineNumber + 1);
-	PLATFORM_ASSERT(posLineEnd >= posLineStart);
-	int lineCaret = pdoc->LineFromPosition(currentPos);
-	return llc.Retrieve(lineNumber, lineCaret,
-	        posLineEnd - posLineStart, pdoc->GetStyleClock(),
-	        LinesOnScreen() + 1, pdoc->LinesTotal());
-}
+	StyleAreaBounded(rcArea, false);
 
-static bool GoodTrailByte(int v) {
-	return (v >= 0x80) && (v < 0xc0);
-}
+	const PRectangle rcClient = GetClientRectangle();
+	//Platform::DebugPrintf("Client: (%3d,%3d) ... (%3d,%3d)   %d\n",
+	//	rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
 
-bool BadUTF(const char *s, int len, int &trailBytes) {
-	if (trailBytes) {
-		trailBytes--;
-		return false;
+	if (NotifyUpdateUI()) {
+		RefreshStyleData();
+		RefreshPixMaps(surfaceWindow);
 	}
-	const unsigned char *us = reinterpret_cast<const unsigned char *>(s);
-	if (*us < 0x80) {
-		// Single bytes easy
-		return false;
-	} else if (*us > 0xF4) {
-		// Characters longer than 4 bytes not possible in current UTF-8
-		return true;
-	} else if (*us >= 0xF0) {
-		// 4 bytes
-		if (len < 4)
-			return true;
-		if (GoodTrailByte(us[1]) && GoodTrailByte(us[2]) && GoodTrailByte(us[3])) {
-			trailBytes = 3;
-			return false;
-		} else {
-			return true;
-		}
-	} else if (*us >= 0xE0) {
-		// 3 bytes
-		if (len < 3)
-			return true;
-		if (GoodTrailByte(us[1]) && GoodTrailByte(us[2])) {
-			trailBytes = 2;
-			return false;
-		} else {
-			return true;
-		}
-	} else if (*us >= 0xC2) {
-		// 2 bytes
-		if (len < 2)
-			return true;
-		if (GoodTrailByte(us[1])) {
-			trailBytes = 1;
-			return false;
-		} else {
-			return true;
+
+	// Wrap the visible lines if needed.
+	if (WrapLines(WrapScope::wsVisible)) {
+		// The wrapping process has changed the height of some lines so
+		// abandon this paint for a complete repaint.
+		if (AbandonPaint()) {
+			return;
 		}
-	} else if (*us >= 0xC0) {
-		// Overlong encoding
-		return true;
-	} else {
-		// Trail byte
-		return true;
+		RefreshPixMaps(surfaceWindow);	// In case pixmaps invalidated by scrollbar change
 	}
-}
 
-/**
- * Fill in the LineLayout data for the given line.
- * Copy the given @a line and its styles from the document into local arrays.
- * Also determine the x position at which each character starts.
- */
-void Editor::LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayout *ll, int width) {
-	if (!ll)
+	if (!marginView.pixmapSelPattern->Initialised()) {
+		// When Direct2D is used, pixmap creation may fail with D2DERR_RECREATE_TARGET so
+		// abandon this paint to avoid further failures.
+		// Main drawing surface and pixmaps should be recreated by next paint.
 		return;
+	}
 
-	PLATFORM_ASSERT(line < pdoc->LinesTotal());
-	PLATFORM_ASSERT(ll->chars != NULL);
-	int posLineStart = pdoc->LineStart(line);
-	int posLineEnd = pdoc->LineStart(line + 1);
-	// If the line is very long, limit the treatment to a length that should fit in the viewport
-	if (posLineEnd > (posLineStart + ll->maxLineLength)) {
-		posLineEnd = posLineStart + ll->maxLineLength;
-	}
-	if (ll->validity == LineLayout::llCheckTextAndStyle) {
-		int lineLength = posLineEnd - posLineStart;
-		if (!vstyle.viewEOL) {
-			int cid = posLineEnd - 1;
-			while ((cid > posLineStart) && IsEOLChar(pdoc->CharAt(cid))) {
-				cid--;
-				lineLength--;
-			}
-		}
-		if (lineLength == ll->numCharsInLine) {
-			// See if chars, styles, indicators, are all the same
-			bool allSame = true;
-			const int styleMask = pdoc->stylingBitsMask;
-			// Check base line layout
-			char styleByte = 0;
-			int numCharsInLine = 0;
-			while (numCharsInLine < lineLength) {
-				int charInDoc = numCharsInLine + posLineStart;
-				char chDoc = pdoc->CharAt(charInDoc);
-				styleByte = pdoc->StyleAt(charInDoc);
-				allSame = allSame &&
-				        (ll->styles[numCharsInLine] == static_cast<unsigned char>(styleByte & styleMask));
-				allSame = allSame &&
-				        (ll->indicators[numCharsInLine] == static_cast<char>(styleByte & ~styleMask));
-				if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseMixed)
-					allSame = allSame &&
-					        (ll->chars[numCharsInLine] == chDoc);
-				else if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseLower)
-					allSame = allSame &&
-					        (ll->chars[numCharsInLine] == static_cast<char>(tolower(chDoc)));
-				else	// Style::caseUpper
-					allSame = allSame &&
-					        (ll->chars[numCharsInLine] == static_cast<char>(toupper(chDoc)));
-				numCharsInLine++;
+	if (!view.bufferedDraw)
+		surfaceWindow->SetClip(rcArea);
+
+	if (paintState != paintAbandoned) {
+		if (vs.marginInside) {
+			PaintSelMargin(surfaceWindow, rcArea);
+			PRectangle rcRightMargin = rcClient;
+			rcRightMargin.left = rcRightMargin.right - vs.rightMarginWidth;
+			if (rcArea.Intersects(rcRightMargin)) {
+				surfaceWindow->FillRectangle(rcRightMargin, vs.styles[STYLE_DEFAULT].back);
 			}
-			allSame = allSame && (ll->styles[numCharsInLine] == styleByte);	// For eolFilled
-			if (allSame) {
-				ll->validity = LineLayout::llPositions;
-			} else {
-				ll->validity = LineLayout::llInvalid;
+		} else { // Else separate view so separate paint event but leftMargin included to allow overlap
+			PRectangle rcLeftMargin = rcArea;
+			rcLeftMargin.left = 0;
+			rcLeftMargin.right = rcLeftMargin.left + vs.leftMarginWidth;
+			if (rcArea.Intersects(rcLeftMargin)) {
+				surfaceWindow->FillRectangle(rcLeftMargin, vs.styles[STYLE_DEFAULT].back);
 			}
-		} else {
-			ll->validity = LineLayout::llInvalid;
 		}
 	}
-	if (ll->validity == LineLayout::llInvalid) {
-		ll->widthLine = LineLayout::wrapWidthInfinite;
-		ll->lines = 1;
-		int numCharsInLine = 0;
-		if (vstyle.edgeState == EDGE_BACKGROUND) {
-			ll->edgeColumn = pdoc->FindColumn(line, theEdge);
-			if (ll->edgeColumn >= posLineStart) {
-				ll->edgeColumn -= posLineStart;
-			}
-		} else {
-			ll->edgeColumn = -1;
-		}
-
-		char styleByte = 0;
-		int styleMask = pdoc->stylingBitsMask;
-		ll->styleBitsSet = 0;
-		// Fill base line layout
-		for (int charInDoc = posLineStart; charInDoc < posLineEnd; charInDoc++) {
-			char chDoc = pdoc->CharAt(charInDoc);
-			styleByte = pdoc->StyleAt(charInDoc);
-			ll->styleBitsSet |= styleByte;
-			if (vstyle.viewEOL || (!IsEOLChar(chDoc))) {
-				ll->chars[numCharsInLine] = chDoc;
-				ll->styles[numCharsInLine] = static_cast<char>(styleByte & styleMask);
-				ll->indicators[numCharsInLine] = static_cast<char>(styleByte & ~styleMask);
-				if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseUpper)
-					ll->chars[numCharsInLine] = static_cast<char>(toupper(chDoc));
-				else if (vstyle.styles[ll->styles[numCharsInLine]].caseForce == Style::caseLower)
-					ll->chars[numCharsInLine] = static_cast<char>(tolower(chDoc));
-				numCharsInLine++;
-			}
-		}
-		ll->xHighlightGuide = 0;
-		// Extra element at the end of the line to hold end x position and act as
-		ll->chars[numCharsInLine] = 0;   // Also triggers processing in the loops as this is a control character
-		ll->styles[numCharsInLine] = styleByte;	// For eolFilled
-		ll->indicators[numCharsInLine] = 0;
-
-		// Layout the line, determining the position of each character,
-		// with an extra element at the end for the end of the line.
-		int startseg = 0;	// Start of the current segment, in char. number
-		int startsegx = 0;	// Start of the current segment, in pixels
-		ll->positions[0] = 0;
-		unsigned int tabWidth = vstyle.spaceWidth * pdoc->tabInChars;
-		bool lastSegItalics = false;
-		Font &ctrlCharsFont = vstyle.styles[STYLE_CONTROLCHAR].font;
-
-		int ctrlCharWidth[32] = {0};
-		bool isControlNext = IsControlCharacter(ll->chars[0]);
-		int trailBytes = 0;
-		bool isBadUTFNext = IsUnicodeMode() && BadUTF(ll->chars, numCharsInLine, trailBytes);
-		for (int charInLine = 0; charInLine < numCharsInLine; charInLine++) {
-			bool isControl = isControlNext;
-			isControlNext = IsControlCharacter(ll->chars[charInLine + 1]);
-			bool isBadUTF = isBadUTFNext;
-			isBadUTFNext = IsUnicodeMode() && BadUTF(ll->chars + charInLine + 1, numCharsInLine - charInLine - 1, trailBytes);
-			if ((ll->styles[charInLine] != ll->styles[charInLine + 1]) ||
-			        isControl || isControlNext || isBadUTF || isBadUTFNext) {
-				ll->positions[startseg] = 0;
-				if (vstyle.styles[ll->styles[charInLine]].visible) {
-					if (isControl) {
-						if (ll->chars[charInLine] == '\t') {
-							ll->positions[charInLine + 1] = ((((startsegx + 2) /
-							        tabWidth) + 1) * tabWidth) - startsegx;
-						} else if (controlCharSymbol < 32) {
-							if (ctrlCharWidth[ll->chars[charInLine]] == 0) {
-								const char *ctrlChar = ControlCharacterString(ll->chars[charInLine]);
-								// +3 For a blank on front and rounded edge each side:
-								ctrlCharWidth[ll->chars[charInLine]] =
-								    surface->WidthText(ctrlCharsFont, ctrlChar, istrlen(ctrlChar)) + 3;
-							}
-							ll->positions[charInLine + 1] = ctrlCharWidth[ll->chars[charInLine]];
-						} else {
-							char cc[2] = { static_cast<char>(controlCharSymbol), '\0' };
-							surface->MeasureWidths(ctrlCharsFont, cc, 1,
-							        ll->positions + startseg + 1);
-						}
-						lastSegItalics = false;
-					} else if (isBadUTF) {
-						char hexits[3];
-						sprintf(hexits, "%2X", ll->chars[charInLine] & 0xff);
-						ll->positions[charInLine + 1] =
-						    surface->WidthText(ctrlCharsFont, hexits, istrlen(hexits)) + 3;
-					} else {	// Regular character
-						int lenSeg = charInLine - startseg + 1;
-						if ((lenSeg == 1) && (' ' == ll->chars[startseg])) {
-							lastSegItalics = false;
-							// Over half the segments are single characters and of these about half are space characters.
-							ll->positions[charInLine + 1] = vstyle.styles[ll->styles[charInLine]].spaceWidth;
-						} else {
-							lastSegItalics = vstyle.styles[ll->styles[charInLine]].italic;
-							posCache.MeasureWidths(surface, vstyle, ll->styles[charInLine], ll->chars + startseg,
-							        lenSeg, ll->positions + startseg + 1);
-						}
-					}
-				} else {    // invisible
-					for (int posToZero = startseg; posToZero <= (charInLine + 1); posToZero++) {
-						ll->positions[posToZero] = 0;
-					}
-				}
-				for (int posToIncrease = startseg; posToIncrease <= (charInLine + 1); posToIncrease++) {
-					ll->positions[posToIncrease] += startsegx;
-				}
-				startsegx = ll->positions[charInLine + 1];
-				startseg = charInLine + 1;
+
+	if (paintState == paintAbandoned) {
+		// Either styling or NotifyUpdateUI noticed that painting is needed
+		// outside the current painting rectangle
+		//Platform::DebugPrintf("Abandoning paint\n");
+		if (Wrapping()) {
+			if (paintAbandonedByStyling) {
+				// Styling has spilled over a line end, such as occurs by starting a multiline
+				// comment. The width of subsequent text may have changed, so rewrap.
+				NeedWrapping(pcs->DocFromDisplay(topLine));
 			}
 		}
-		// Small hack to make lines that end with italics not cut off the edge of the last character
-		if ((startseg > 0) && lastSegItalics) {
-			ll->positions[startseg] += 2;
-		}
-		ll->numCharsInLine = numCharsInLine;
-		ll->validity = LineLayout::llPositions;
-	}
-	// Hard to cope when too narrow, so just assume there is space
-	if (width < 20) {
-		width = 20;
+		return;
 	}
-	if ((ll->validity == LineLayout::llPositions) || (ll->widthLine != width)) {
-		ll->widthLine = width;
-		if (width == LineLayout::wrapWidthInfinite) {
-			ll->lines = 1;
-		} else if (width > ll->positions[ll->numCharsInLine]) {
-			// Simple common case where line does not need wrapping.
-			ll->lines = 1;
-		} else {
-			if (wrapVisualFlags & SC_WRAPVISUALFLAG_END) {
-				width -= vstyle.aveCharWidth; // take into account the space for end wrap mark
-			}
-			ll->lines = 0;
-			// Calculate line start positions based upon width.
-			int lastGoodBreak = 0;
-			int lastLineStart = 0;
-			int startOffset = 0;
-			int p = 0;
-			while (p < ll->numCharsInLine) {
-				if ((ll->positions[p + 1] - startOffset) >= width) {
-					if (lastGoodBreak == lastLineStart) {
-						// Try moving to start of last character
-						if (p > 0) {
-							lastGoodBreak = pdoc->MovePositionOutsideChar(p + posLineStart, -1)
-							        - posLineStart;
-						}
-						if (lastGoodBreak == lastLineStart) {
-							// Ensure at least one character on line.
-							lastGoodBreak = pdoc->MovePositionOutsideChar(lastGoodBreak + posLineStart + 1, 1)
-							        - posLineStart;
-						}
-					}
-					lastLineStart = lastGoodBreak;
-					ll->lines++;
-					ll->SetLineStart(ll->lines, lastGoodBreak);
-					startOffset = ll->positions[lastGoodBreak];
-					// take into account the space for start wrap mark and indent
-					startOffset -= actualWrapVisualStartIndent * vstyle.aveCharWidth;
-					p = lastGoodBreak + 1;
-					continue;
-				}
-				if (p > 0) {
-					if (wrapState == eWrapChar) {
-						lastGoodBreak = pdoc->MovePositionOutsideChar(p + posLineStart, -1)
-						        - posLineStart;
-						p = pdoc->MovePositionOutsideChar(p + 1 + posLineStart, 1) - posLineStart;
-						continue;
-					} else if (ll->styles[p] != ll->styles[p - 1]) {
-						lastGoodBreak = p;
-					} else if (IsSpaceOrTab(ll->chars[p - 1]) && !IsSpaceOrTab(ll->chars[p])) {
-						lastGoodBreak = p;
-					}
-				}
-				p++;
-			}
-			ll->lines++;
+
+	view.PaintText(surfaceWindow, *this, rcArea, rcClient, vs);
+
+	if (horizontalScrollBarVisible && trackLineWidth && (view.lineWidthMaxSeen > scrollWidth)) {
+		scrollWidth = view.lineWidthMaxSeen;
+		if (!FineTickerRunning(tickWiden)) {
+			FineTickerStart(tickWiden, 50, 5);
 		}
-		ll->validity = LineLayout::llLines;
 	}
-}
 
-ColourAllocated Editor::SelectionBackground(ViewStyle &vsDraw) {
-	return primarySelection ? vsDraw.selbackground.allocated : vsDraw.selbackground2.allocated;
+	NotifyPainted();
 }
 
-ColourAllocated Editor::TextBackground(ViewStyle &vsDraw, bool overrideBackground,
-        ColourAllocated background, bool inSelection, bool inHotspot, int styleMain, int i, LineLayout *ll) {
-	if (inSelection) {
-		if (vsDraw.selbackset && (vsDraw.selAlpha == SC_ALPHA_NOALPHA)) {
-			return SelectionBackground(vsDraw);
-		}
-	} else {
-		if ((vsDraw.edgeState == EDGE_BACKGROUND) &&
-		        (i >= ll->edgeColumn) &&
-		        !IsEOLChar(ll->chars[i]))
-			return vsDraw.edgecolour.allocated;
-		if (inHotspot && vsDraw.hotspotBackgroundSet)
-			return vsDraw.hotspotBackground.allocated;
-		if (overrideBackground && (styleMain != STYLE_BRACELIGHT) && (styleMain != STYLE_BRACEBAD))
-			return background;
+// This is mostly copied from the Paint method but with some things omitted
+// such as the margin markers, line numbers, selection and caret
+// Should be merged back into a combined Draw method.
+Sci::Position Editor::FormatRange(bool draw, const Sci_RangeToFormat *pfr) {
+	if (!pfr)
+		return 0;
+
+	AutoSurface surface(pfr->hdc, this, SC_TECHNOLOGY_DEFAULT);
+	if (!surface)
+		return 0;
+	AutoSurface surfaceMeasure(pfr->hdcTarget, this, SC_TECHNOLOGY_DEFAULT);
+	if (!surfaceMeasure) {
+		return 0;
 	}
-	return vsDraw.styles[styleMain].back.allocated;
+	return view.FormatRange(draw, pfr, surface, surfaceMeasure, *this, vs);
 }
 
-void Editor::DrawIndentGuide(Surface *surface, int lineVisible, int lineHeight, int start, PRectangle rcSegment, bool highlight) {
-	Point from(0, ((lineVisible & 1) && (lineHeight & 1)) ? 1 : 0);
-	PRectangle rcCopyArea(start + 1, rcSegment.top, start + 2, rcSegment.bottom);
-	surface->Copy(rcCopyArea, from,
-	        highlight ? *pixmapIndentGuideHighlight : *pixmapIndentGuide);
+long Editor::TextWidth(uptr_t style, const char *text) {
+	RefreshStyleData();
+	AutoSurface surface(this);
+	if (surface) {
+		return std::lround(surface->WidthText(vs.styles[style].font, text));
+	} else {
+		return 1;
+	}
 }
 
-void Editor::DrawWrapMarker(Surface *surface, PRectangle rcPlace,
-        bool isEndMarker, ColourAllocated wrapColour) {
-	surface->PenColour(wrapColour);
-
-	enum { xa = 1 }; // gap before start
-	int w = rcPlace.right - rcPlace.left - xa - 1;
+// Empty method is overridden on GTK+ to show / hide scrollbars
+void Editor::ReconfigureScrollBars() {}
 
-	bool xStraight = isEndMarker;  // x-mirrored symbol for start marker
-	bool yStraight = true;
-	//bool yStraight= isEndMarker; // comment in for start marker y-mirrowed
+void Editor::SetScrollBars() {
+	RefreshStyleData();
 
-	int x0 = xStraight ? rcPlace.left : rcPlace.right - 1;
-	int y0 = yStraight ? rcPlace.top : rcPlace.bottom - 1;
+	const Sci::Line nMax = MaxScrollPos();
+	const Sci::Line nPage = LinesOnScreen();
+	const bool modified = ModifyScrollBars(nMax + nPage - 1, nPage);
+	if (modified) {
+		DwellEnd(true);
+	}
 
-	int dy = (rcPlace.bottom - rcPlace.top) / 5;
-	int y = (rcPlace.bottom - rcPlace.top) / 2 + dy;
-
-	struct Relative {
-		Surface *surface;
-		int xBase;
-		int xDir;
-		int yBase;
-		int yDir;
-		void MoveTo(int xRelative, int yRelative) {
-			surface->MoveTo(xBase + xDir * xRelative, yBase + yDir * yRelative);
-		}
-		void LineTo(int xRelative, int yRelative) {
-			surface->LineTo(xBase + xDir * xRelative, yBase + yDir * yRelative);
-		}
-	};
-	Relative rel = {surface, x0, xStraight ? 1 : -1, y0, yStraight ? 1 : -1};
-
-	// arrow head
-	rel.MoveTo(xa, y);
-	rel.LineTo(xa + 2*w / 3, y - dy);
-	rel.MoveTo(xa, y);
-	rel.LineTo(xa + 2*w / 3, y + dy);
-
-	// arrow body
-	rel.MoveTo(xa, y);
-	rel.LineTo(xa + w, y);
-	rel.LineTo(xa + w, y - 2 * dy);
-	rel.LineTo(xa - 1,   // on windows lineto is exclusive endpoint, perhaps GTK not...
-	        y - 2 * dy);
-}
-
-static void SimpleAlphaRectangle(Surface *surface, PRectangle rc, ColourAllocated fill, int alpha) {
-	if (alpha != SC_ALPHA_NOALPHA) {
-		surface->AlphaRectangle(rc, 0, fill, alpha, fill, alpha, 0);
+	// TODO: ensure always showing as many lines as possible
+	// May not be, if, for example, window made larger
+	if (topLine > MaxScrollPos()) {
+		SetTopLine(std::clamp<Sci::Line>(topLine, 0, MaxScrollPos()));
+		SetVerticalScrollPos();
+		Redraw();
 	}
-}
-
-void Editor::DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,
-        int line, int lineEnd, int xStart, int subLine, int subLineStart,
-        bool overrideBackground, ColourAllocated background,
-        bool drawWrapMarkEnd, ColourAllocated wrapColour) {
-
-	int styleMask = pdoc->stylingBitsMask;
-	PRectangle rcSegment = rcLine;
-
-	// Fill in a PRectangle representing the end of line characters
-	int xEol = ll->positions[lineEnd] - subLineStart;
-	rcSegment.left = xEol + xStart;
-	rcSegment.right = xEol + vsDraw.aveCharWidth + xStart;
-	int posLineEnd = pdoc->LineStart(line + 1);
-	bool eolInSelection = (subLine == (ll->lines - 1)) &&
-	        (posLineEnd > ll->selStart) && (posLineEnd <= ll->selEnd) && (ll->selStart != ll->selEnd);
-
-	if (eolInSelection && vsDraw.selbackset && (line < pdoc->LinesTotal() - 1) && (vsDraw.selAlpha == SC_ALPHA_NOALPHA)) {
-		surface->FillRectangle(rcSegment, SelectionBackground(vsDraw));
-	} else {
-		if (overrideBackground) {
-			surface->FillRectangle(rcSegment, background);
-		} else {
-			surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].back.allocated);
-		}
-		if (eolInSelection && vsDraw.selbackset && (line < pdoc->LinesTotal() - 1) && (vsDraw.selAlpha != SC_ALPHA_NOALPHA)) {
-			SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw), vsDraw.selAlpha);
-		}
+	if (modified) {
+		if (!AbandonPaint())
+			Redraw();
 	}
+	//Platform::DebugPrintf("end max = %d page = %d\n", nMax, nPage);
+}
 
-	rcSegment.left = xEol + vsDraw.aveCharWidth + xStart;
-	rcSegment.right = rcLine.right;
-
-	if (vsDraw.selEOLFilled && eolInSelection && vsDraw.selbackset && (line < pdoc->LinesTotal() - 1) && (vsDraw.selAlpha == SC_ALPHA_NOALPHA)) {
-		surface->FillRectangle(rcSegment, SelectionBackground(vsDraw));
-	} else {
-		if (overrideBackground) {
-			surface->FillRectangle(rcSegment, background);
-		} else if (vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].eolFilled) {
-			surface->FillRectangle(rcSegment, vsDraw.styles[ll->styles[ll->numCharsInLine] & styleMask].back.allocated);
-		} else {
-			surface->FillRectangle(rcSegment, vsDraw.styles[STYLE_DEFAULT].back.allocated);
-		}
-		if (vsDraw.selEOLFilled && eolInSelection && vsDraw.selbackset && (line < pdoc->LinesTotal() - 1) && (vsDraw.selAlpha != SC_ALPHA_NOALPHA)) {
-			SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw), vsDraw.selAlpha);
+void Editor::ChangeSize() {
+	DropGraphics(false);
+	SetScrollBars();
+	if (Wrapping()) {
+		PRectangle rcTextArea = GetClientRectangle();
+		rcTextArea.left = static_cast<XYPOSITION>(vs.textStart);
+		rcTextArea.right -= vs.rightMarginWidth;
+		if (wrapWidth != rcTextArea.Width()) {
+			NeedWrapping();
+			Redraw();
 		}
 	}
+}
 
-	if (drawWrapMarkEnd) {
-		PRectangle rcPlace = rcSegment;
-
-		if (wrapVisualFlagsLocation & SC_WRAPVISUALFLAGLOC_END_BY_TEXT) {
-			rcPlace.left = xEol + xStart;
-			rcPlace.right = rcPlace.left + vsDraw.aveCharWidth;
+Sci::Position Editor::RealizeVirtualSpace(Sci::Position position, Sci::Position virtualSpace) {
+	if (virtualSpace > 0) {
+		const Sci::Line line = pdoc->SciLineFromPosition(position);
+		const Sci::Position indent = pdoc->GetLineIndentPosition(line);
+		if (indent == position) {
+			return pdoc->SetLineIndentation(line, pdoc->GetLineIndentation(line) + virtualSpace);
 		} else {
-			// draw left of the right text margin, to avoid clipping by the current clip rect
-			rcPlace.right = rcLine.right - vs.rightMarginWidth;
-			rcPlace.left = rcPlace.right - vsDraw.aveCharWidth;
+			std::string spaceText(virtualSpace, ' ');
+			const Sci::Position lengthInserted = pdoc->InsertString(position, spaceText.c_str(), virtualSpace);
+			position += lengthInserted;
 		}
-		DrawWrapMarker(surface, rcPlace, true, wrapColour);
 	}
+	return position;
 }
 
-void Editor::DrawIndicators(Surface *surface, ViewStyle &vsDraw, int line, int xStart,
-        PRectangle rcLine, LineLayout *ll, int subLine, int lineEnd, bool under) {
-	// Draw decorators
-	const int posLineStart = pdoc->LineStart(line);
-	const int lineStart = ll->LineStart(subLine);
-	const int subLineStart = ll->positions[lineStart];
-	const int posLineEnd = posLineStart + lineEnd;
-
-	if (!under) {
-		// Draw indicators
-		// foreach indicator...
-		for (int indicnum = 0, mask = 1 << pdoc->stylingBits; mask < 0x100; indicnum++) {
-			if (!(mask & ll->styleBitsSet)) {
-				mask <<= 1;
-				continue;
-			}
-			int startPos = -1;
-			// foreach style pos in line...
-			for (int indicPos = lineStart; indicPos <= lineEnd; indicPos++) {
-				// look for starts...
-				if (startPos < 0) {
-					// NOT in indicator run, looking for START
-					if (indicPos < lineEnd && (ll->indicators[indicPos] & mask))
-						startPos = indicPos;
-				}
-				// ... or ends
-				if (startPos >= 0) {
-					// IN indicator run, looking for END
-					if (indicPos >= lineEnd || !(ll->indicators[indicPos] & mask)) {
-						// AT end of indicator run, DRAW it!
-						PRectangle rcIndic(
-						    ll->positions[startPos] + xStart - subLineStart,
-						    rcLine.top + vsDraw.maxAscent,
-						    ll->positions[indicPos] + xStart - subLineStart,
-						    rcLine.top + vsDraw.maxAscent + 3);
-						vsDraw.indicators[indicnum].Draw(surface, rcIndic, rcLine);
-						// RESET control var
-						startPos = -1;
-					}
-				}
-			}
-			mask <<= 1;
-		}
-	}
-
-	for (Decoration *deco = pdoc->decorations.root; deco; deco = deco->next) {
-		if (under == vsDraw.indicators[deco->indicator].under) {
-			int startPos = posLineStart + lineStart;
-			if (!deco->rs.ValueAt(startPos)) {
-				startPos = deco->rs.EndRun(startPos);
-			}
-			while ((startPos < posLineEnd) && (deco->rs.ValueAt(startPos))) {
-				int endPos = deco->rs.EndRun(startPos);
-				if (endPos > posLineEnd)
-					endPos = posLineEnd;
-				PRectangle rcIndic(
-				    ll->positions[startPos - posLineStart] + xStart - subLineStart,
-				    rcLine.top + vsDraw.maxAscent,
-				    ll->positions[endPos - posLineStart] + xStart - subLineStart,
-				    rcLine.top + vsDraw.maxAscent + 3);
-				vsDraw.indicators[deco->indicator].Draw(surface, rcIndic, rcLine);
-				startPos = deco->rs.EndRun(endPos);
-			}
-		}
-	}
+SelectionPosition Editor::RealizeVirtualSpace(const SelectionPosition &position) {
+	// Return the new position with no virtual space
+	return SelectionPosition(RealizeVirtualSpace(position.Position(), position.VirtualSpace()));
 }
 
-void DrawTextBlob(Surface *surface, ViewStyle &vsDraw, PRectangle rcSegment,
-				  const char *s, ColourAllocated textBack, ColourAllocated textFore, bool twoPhaseDraw) {
-	if (!twoPhaseDraw) {
-		surface->FillRectangle(rcSegment, textBack);
-	}
-	Font &ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font;
-	int normalCharHeight = surface->Ascent(ctrlCharsFont) -
-	        surface->InternalLeading(ctrlCharsFont);
-	PRectangle rcCChar = rcSegment;
-	rcCChar.left = rcCChar.left + 1;
-	rcCChar.top = rcSegment.top + vsDraw.maxAscent - normalCharHeight;
-	rcCChar.bottom = rcSegment.top + vsDraw.maxAscent + 1;
-	PRectangle rcCentral = rcCChar;
-	rcCentral.top++;
-	rcCentral.bottom--;
-	surface->FillRectangle(rcCentral, textFore);
-	PRectangle rcChar = rcCChar;
-	rcChar.left++;
-	rcChar.right--;
-	surface->DrawTextClipped(rcChar, ctrlCharsFont,
-	        rcSegment.top + vsDraw.maxAscent, s, istrlen(s),
-	        textBack, textFore);
-}
-
-void Editor::DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVisible, int xStart,
-        PRectangle rcLine, LineLayout *ll, int subLine) {
-
-	PRectangle rcSegment = rcLine;
-
-	// Using one font for all control characters so it can be controlled independently to ensure
-	// the box goes around the characters tightly. Seems to be no way to work out what height
-	// is taken by an individual character - internal leading gives varying results.
-	Font &ctrlCharsFont = vsDraw.styles[STYLE_CONTROLCHAR].font;
-
-	// See if something overrides the line background color:  Either if caret is on the line
-	// and background color is set for that, or if a marker is defined that forces its background
-	// color onto the line, or if a marker is defined but has no selection margin in which to
-	// display itself (as long as it's not an SC_MARK_EMPTY marker).  These are checked in order
-	// with the earlier taking precedence.  When multiple markers cause background override,
-	// the color for the highest numbered one is used.
-	bool overrideBackground = false;
-	ColourAllocated background;
-	if (caret.active && vsDraw.showCaretLineBackground && (vsDraw.caretLineAlpha == SC_ALPHA_NOALPHA) && ll->containsCaret) {
-		overrideBackground = true;
-		background = vsDraw.caretLineBackground.allocated;
-	}
-	if (!overrideBackground) {
-		int marks = pdoc->GetMark(line);
-		for (int markBit = 0; (markBit < 32) && marks; markBit++) {
-			if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_BACKGROUND) &&
-			        (vsDraw.markers[markBit].alpha == SC_ALPHA_NOALPHA)) {
-				background = vsDraw.markers[markBit].back.allocated;
-				overrideBackground = true;
-			}
-			marks >>= 1;
-		}
-	}
-	if (!overrideBackground) {
-		if (vsDraw.maskInLine) {
-			int marksMasked = pdoc->GetMark(line) & vsDraw.maskInLine;
-			if (marksMasked) {
-				for (int markBit = 0; (markBit < 32) && marksMasked; markBit++) {
-					if ((marksMasked & 1) && (vsDraw.markers[markBit].markType != SC_MARK_EMPTY) &&
-					        (vsDraw.markers[markBit].alpha == SC_ALPHA_NOALPHA)) {
-						overrideBackground = true;
-						background = vsDraw.markers[markBit].back.allocated;
-					}
-					marksMasked >>= 1;
-				}
-			}
-		}
-	}
-
-	bool drawWhitespaceBackground = (vsDraw.viewWhitespace != wsInvisible) &&
-	        (!overrideBackground) && (vsDraw.whitespaceBackgroundSet);
-
-	bool inIndentation = subLine == 0;	// Do not handle indentation except on first subline.
-	int indentWidth = pdoc->IndentSize() * vsDraw.spaceWidth;
-
-	int posLineStart = pdoc->LineStart(line);
+void Editor::AddChar(char ch) {
+	char s[2];
+	s[0] = ch;
+	s[1] = '\0';
+	InsertCharacter(std::string_view(s, 1), CharacterSource::directInput);
+}
 
-	int startseg = ll->LineStart(subLine);
-	int subLineStart = ll->positions[startseg];
-	int lineStart = 0;
-	int lineEnd = 0;
-	if (subLine < ll->lines) {
-		lineStart = ll->LineStart(subLine);
-		lineEnd = ll->LineStart(subLine + 1);
+void Editor::FilterSelections() {
+	if (!additionalSelectionTyping && (sel.Count() > 1)) {
+		InvalidateWholeSelection();
+		sel.DropAdditionalRanges();
 	}
+}
 
-	ColourAllocated wrapColour = vsDraw.styles[STYLE_DEFAULT].fore.allocated;
-	if (vsDraw.whitespaceForegroundSet)
-		wrapColour = vsDraw.whitespaceForeground.allocated;
-
-	bool drawWrapMarkEnd = false;
-
-	if (wrapVisualFlags & SC_WRAPVISUALFLAG_END) {
-		if (subLine + 1 < ll->lines) {
-			drawWrapMarkEnd = ll->LineStart(subLine + 1) != 0;
-		}
+// InsertCharacter inserts a character encoded in document code page.
+void Editor::InsertCharacter(std::string_view sv, CharacterSource charSource) {
+	if (sv.empty()) {
+		return;
 	}
-
-	if (actualWrapVisualStartIndent != 0) {
-
-		bool continuedWrapLine = false;
-		if (subLine < ll->lines) {
-			continuedWrapLine = ll->LineStart(subLine) != 0;
-		}
-
-		if (continuedWrapLine) {
-			// draw continuation rect
-			PRectangle rcPlace = rcSegment;
-
-			rcPlace.left = ll->positions[startseg] + xStart - subLineStart;
-			rcPlace.right = rcPlace.left + actualWrapVisualStartIndent * vsDraw.aveCharWidth;
-
-			// default bgnd here..
-			surface->FillRectangle(rcSegment, overrideBackground ? background :
-			        vsDraw.styles[STYLE_DEFAULT].back.allocated);
-
-			// main line style would be below but this would be inconsistent with end markers
-			// also would possibly not be the style at wrap point
-			//int styleMain = ll->styles[lineStart];
-			//surface->FillRectangle(rcPlace, vsDraw.styles[styleMain].back.allocated);
-
-			if (wrapVisualFlags & SC_WRAPVISUALFLAG_START) {
-
-				if (wrapVisualFlagsLocation & SC_WRAPVISUALFLAGLOC_START_BY_TEXT)
-					rcPlace.left = rcPlace.right - vsDraw.aveCharWidth;
-				else
-					rcPlace.right = rcPlace.left + vsDraw.aveCharWidth;
-
-				DrawWrapMarker(surface, rcPlace, false, wrapColour);
-			}
-
-			xStart += actualWrapVisualStartIndent * vsDraw.aveCharWidth;
-		}
-	}
-
-	// Does not take margin into account but not significant
-	int xStartVisible = subLineStart - xStart;
-
-	BreakFinder bfBack(ll, lineStart, lineEnd, posLineStart, IsUnicodeMode(), xStartVisible);
-	int next = bfBack.First();
-
-	// Background drawing loop
-	while (twoPhaseDraw && (next < lineEnd)) {
-
-		startseg = next;
-		next = bfBack.Next();
-		int i = next - 1;
-		int iDoc = i + posLineStart;
-
-		rcSegment.left = ll->positions[startseg] + xStart - subLineStart;
-		rcSegment.right = ll->positions[i + 1] + xStart - subLineStart;
-		// Only try to draw if really visible - enhances performance by not calling environment to
-		// draw strings that are completely past the right side of the window.
-		if ((rcSegment.left <= rcLine.right) && (rcSegment.right >= rcLine.left)) {
-			// Clip to line rectangle, since may have a huge position which will not work with some platforms
-			rcSegment.left = Platform::Maximum(rcSegment.left, rcLine.left);
-			rcSegment.right = Platform::Minimum(rcSegment.right, rcLine.right);
-
-			int styleMain = ll->styles[i];
-			bool inSelection = (iDoc >= ll->selStart) && (iDoc < ll->selEnd) && (ll->selStart != ll->selEnd);
-			bool inHotspot = (ll->hsStart != -1) && (iDoc >= ll->hsStart) && (iDoc < ll->hsEnd);
-			ColourAllocated textBack = TextBackground(vsDraw, overrideBackground, background, inSelection, inHotspot, styleMain, i, ll);
-			if (ll->chars[i] == '\t') {
-				// Tab display
-				if (drawWhitespaceBackground &&
-				        (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways))
-					textBack = vsDraw.whitespaceBackground.allocated;
-				surface->FillRectangle(rcSegment, textBack);
-			} else if (IsControlCharacter(ll->chars[i])) {
-				// Control character display
-				inIndentation = false;
-				surface->FillRectangle(rcSegment, textBack);
-			} else {
-				// Normal text display
-				surface->FillRectangle(rcSegment, textBack);
-				if (vsDraw.viewWhitespace != wsInvisible ||
-				        (inIndentation && vsDraw.viewIndentationGuides == ivReal)) {
-					for (int cpos = 0; cpos <= i - startseg; cpos++) {
-						if (ll->chars[cpos + startseg] == ' ') {
-							if (drawWhitespaceBackground &&
-							        (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways)) {
-								PRectangle rcSpace(ll->positions[cpos + startseg] + xStart - subLineStart,
-									rcSegment.top,
-									ll->positions[cpos + startseg + 1] + xStart - subLineStart,
-									rcSegment.bottom);
-								surface->FillRectangle(rcSpace, vsDraw.whitespaceBackground.allocated);
-							}
-						} else {
-							inIndentation = false;
-						}
+	FilterSelections();
+	{
+		UndoGroup ug(pdoc, (sel.Count() > 1) || !sel.Empty() || inOverstrike);
+
+		// Vector elements point into selection in order to change selection.
+		std::vector<SelectionRange *> selPtrs;
+		for (size_t r = 0; r < sel.Count(); r++) {
+			selPtrs.push_back(&sel.Range(r));
+		}
+		// Order selections by position in document.
+		std::sort(selPtrs.begin(), selPtrs.end(),
+			[](const SelectionRange *a, const SelectionRange *b) noexcept {return *a < *b;});
+
+		// Loop in reverse to avoid disturbing positions of selections yet to be processed.
+		for (std::vector<SelectionRange *>::reverse_iterator rit = selPtrs.rbegin();
+			rit != selPtrs.rend(); ++rit) {
+			SelectionRange *currentSel = *rit;
+			if (!RangeContainsProtected(currentSel->Start().Position(),
+				currentSel->End().Position())) {
+				Sci::Position positionInsert = currentSel->Start().Position();
+				if (!currentSel->Empty()) {
+					if (currentSel->Length()) {
+						pdoc->DeleteChars(positionInsert, currentSel->Length());
+						currentSel->ClearVirtualSpace();
+					} else {
+						// Range is all virtual so collapse to start of virtual space
+						currentSel->MinimizeVirtualSpace();
 					}
-				}
-			}
-		} else if (rcSegment.left > rcLine.right) {
-			break;
-		}
-	}
-
-	if (twoPhaseDraw) {
-		DrawEOL(surface, vsDraw, rcLine, ll, line, lineEnd,
-		        xStart, subLine, subLineStart, overrideBackground, background,
-		        drawWrapMarkEnd, wrapColour);
-	}
-
-	DrawIndicators(surface, vsDraw, line, xStart, rcLine, ll, subLine, lineEnd, true);
-
-	if (vsDraw.edgeState == EDGE_LINE) {
-		int edgeX = theEdge * vsDraw.spaceWidth;
-		rcSegment.left = edgeX + xStart;
-		rcSegment.right = rcSegment.left + 1;
-		surface->FillRectangle(rcSegment, vsDraw.edgecolour.allocated);
-	}
-
-	inIndentation = subLine == 0;	// Do not handle indentation except on first subline.
-	// Foreground drawing loop
-	BreakFinder bfFore(ll, lineStart, lineEnd, posLineStart, IsUnicodeMode(), xStartVisible);
-	next = bfFore.First();
-
-	while (next < lineEnd) {
-
-		startseg = next;
-		next = bfFore.Next();
-		int i = next - 1;
-
-		int iDoc = i + posLineStart;
-
-		rcSegment.left = ll->positions[startseg] + xStart - subLineStart;
-		rcSegment.right = ll->positions[i + 1] + xStart - subLineStart;
-		// Only try to draw if really visible - enhances performance by not calling environment to
-		// draw strings that are completely past the right side of the window.
-		if ((rcSegment.left <= rcLine.right) && (rcSegment.right >= rcLine.left)) {
-			int styleMain = ll->styles[i];
-			ColourAllocated textFore = vsDraw.styles[styleMain].fore.allocated;
-			Font &textFont = vsDraw.styles[styleMain].font;
-			//hotspot foreground
-			if (ll->hsStart != -1 && iDoc >= ll->hsStart && iDoc < hsEnd) {
-				if (vsDraw.hotspotForegroundSet)
-					textFore = vsDraw.hotspotForeground.allocated;
-			}
-			bool inSelection = (iDoc >= ll->selStart) && (iDoc < ll->selEnd) && (ll->selStart != ll->selEnd);
-			if (inSelection && (vsDraw.selforeset)) {
-				textFore = vsDraw.selforeground.allocated;
-			}
-			bool inHotspot = (ll->hsStart != -1) && (iDoc >= ll->hsStart) && (iDoc < ll->hsEnd);
-			ColourAllocated textBack = TextBackground(vsDraw, overrideBackground, background, inSelection, inHotspot, styleMain, i, ll);
-			if (ll->chars[i] == '\t') {
-				// Tab display
-				if (!twoPhaseDraw) {
-					if (drawWhitespaceBackground &&
-					        (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways))
-						textBack = vsDraw.whitespaceBackground.allocated;
-					surface->FillRectangle(rcSegment, textBack);
-				}
-				if ((vsDraw.viewWhitespace != wsInvisible) ||
-				        (inIndentation && vsDraw.viewIndentationGuides != ivNone)) {
-					if (vsDraw.whitespaceForegroundSet)
-						textFore = vsDraw.whitespaceForeground.allocated;
-					surface->PenColour(textFore);
-				}
-				if (inIndentation && vsDraw.viewIndentationGuides == ivReal) {
-					for (int xIG = ll->positions[i] / indentWidth * indentWidth; xIG < ll->positions[i + 1]; xIG += indentWidth) {
-						if (xIG >= ll->positions[i] && xIG > 0) {
-							DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIG + xStart, rcSegment,
-							        (ll->xHighlightGuide == xIG));
+				} else if (inOverstrike) {
+					if (positionInsert < pdoc->Length()) {
+						if (!pdoc->IsPositionInLineEnd(positionInsert)) {
+							pdoc->DelChar(positionInsert);
+							currentSel->ClearVirtualSpace();
 						}
 					}
 				}
-				if (vsDraw.viewWhitespace != wsInvisible) {
-					if (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways) {
-						PRectangle rcTab(rcSegment.left + 1, rcSegment.top + 4,
-						        rcSegment.right - 1, rcSegment.bottom - vsDraw.maxDescent);
-						DrawTabArrow(surface, rcTab, rcSegment.top + vsDraw.lineHeight / 2);
-					}
-				}
-			} else if (IsControlCharacter(ll->chars[i])) {
-				// Control character display
-				inIndentation = false;
-				if (controlCharSymbol < 32) {
-					// Draw the character
-					const char *ctrlChar = ControlCharacterString(ll->chars[i]);
-					DrawTextBlob(surface, vsDraw, rcSegment, ctrlChar, textBack, textFore, twoPhaseDraw);
-				} else {
-					char cc[2] = { static_cast<char>(controlCharSymbol), '\0' };
-					surface->DrawTextNoClip(rcSegment, ctrlCharsFont,
-					        rcSegment.top + vsDraw.maxAscent,
-					        cc, 1, textBack, textFore);
-				}
-			} else if ((i == startseg) && (static_cast<unsigned char>(ll->chars[i]) >= 0x80) && IsUnicodeMode()) {
-				char hexits[3];
-				sprintf(hexits, "%2X", ll->chars[i] & 0xff);
-				DrawTextBlob(surface, vsDraw, rcSegment, hexits, textBack, textFore, twoPhaseDraw);
-			} else {
-				// Normal text display
-				if (vsDraw.styles[styleMain].visible) {
-					if (twoPhaseDraw) {
-						surface->DrawTextTransparent(rcSegment, textFont,
-						        rcSegment.top + vsDraw.maxAscent, ll->chars + startseg,
-						        i - startseg + 1, textFore);
-					} else {
-						surface->DrawTextNoClip(rcSegment, textFont,
-						        rcSegment.top + vsDraw.maxAscent, ll->chars + startseg,
-						        i - startseg + 1, textFore, textBack);
-					}
+				positionInsert = RealizeVirtualSpace(positionInsert, currentSel->caret.VirtualSpace());
+				const Sci::Position lengthInserted = pdoc->InsertString(positionInsert, sv.data(), sv.length());
+				if (lengthInserted > 0) {
+					currentSel->caret.SetPosition(positionInsert + lengthInserted);
+					currentSel->anchor.SetPosition(positionInsert + lengthInserted);
 				}
-				if (vsDraw.viewWhitespace != wsInvisible ||
-				        (inIndentation && vsDraw.viewIndentationGuides != ivNone)) {
-					for (int cpos = 0; cpos <= i - startseg; cpos++) {
-						if (ll->chars[cpos + startseg] == ' ') {
-							if (vsDraw.viewWhitespace != wsInvisible) {
-								if (vsDraw.whitespaceForegroundSet)
-									textFore = vsDraw.whitespaceForeground.allocated;
-								if (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways) {
-									int xmid = (ll->positions[cpos + startseg] + ll->positions[cpos + startseg + 1]) / 2;
-									if (!twoPhaseDraw && drawWhitespaceBackground &&
-									        (!inIndentation || vsDraw.viewWhitespace == wsVisibleAlways)) {
-										textBack = vsDraw.whitespaceBackground.allocated;
-										PRectangle rcSpace(ll->positions[cpos + startseg] + xStart - subLineStart,
-											rcSegment.top,
-											ll->positions[cpos + startseg + 1] + xStart - subLineStart,
-											rcSegment.bottom);
-										surface->FillRectangle(rcSpace, textBack);
-									}
-									PRectangle rcDot(xmid + xStart - subLineStart, rcSegment.top + vsDraw.lineHeight / 2, 0, 0);
-									rcDot.right = rcDot.left + 1;
-									rcDot.bottom = rcDot.top + 1;
-									surface->FillRectangle(rcDot, textFore);
-								}
-							}
-							if (inIndentation && vsDraw.viewIndentationGuides == ivReal) {
-								int startSpace = ll->positions[cpos + startseg];
-								if (startSpace > 0 && (startSpace % indentWidth == 0)) {
-									DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, startSpace + xStart, rcSegment,
-									        (ll->xHighlightGuide == ll->positions[cpos + startseg]));
-								}
-							}
-						} else {
-							inIndentation = false;
+				currentSel->ClearVirtualSpace();
+				// If in wrap mode rewrap current line so EnsureCaretVisible has accurate information
+				if (Wrapping()) {
+					AutoSurface surface(this);
+					if (surface) {
+						if (WrapOneLine(surface, pdoc->SciLineFromPosition(positionInsert))) {
+							SetScrollBars();
+							SetVerticalScrollPos();
+							Redraw();
 						}
 					}
 				}
 			}
-			if (ll->hsStart != -1 && vsDraw.hotspotUnderline && iDoc >= ll->hsStart && iDoc < ll->hsEnd ) {
-				PRectangle rcUL = rcSegment;
-				rcUL.top = rcUL.top + vsDraw.maxAscent + 1;
-				rcUL.bottom = rcUL.top + 1;
-				if (vsDraw.hotspotForegroundSet)
-					surface->FillRectangle(rcUL, vsDraw.hotspotForeground.allocated);
-				else
-					surface->FillRectangle(rcUL, textFore);
-			} else if (vsDraw.styles[styleMain].underline) {
-				PRectangle rcUL = rcSegment;
-				rcUL.top = rcUL.top + vsDraw.maxAscent + 1;
-				rcUL.bottom = rcUL.top + 1;
-				surface->FillRectangle(rcUL, textFore);
-			}
-		} else if (rcSegment.left > rcLine.right) {
-			break;
 		}
 	}
-	if ((vsDraw.viewIndentationGuides == ivLookForward || vsDraw.viewIndentationGuides == ivLookBoth)
-	        && (subLine == 0)) {
-		int indentSpace = pdoc->GetLineIndentation(line);
-		// Find the most recent line with some text
-
-		int lineLastWithText = line;
-		while (lineLastWithText > Platform::Maximum(line-20, 0) && pdoc->IsWhiteLine(lineLastWithText)) {
-			lineLastWithText--;
-		}
-		if (lineLastWithText < line) {
-			// This line is empty, so use indentation of last line with text
-			int indentLastWithText = pdoc->GetLineIndentation(lineLastWithText);
-			int isFoldHeader = pdoc->GetLevel(lineLastWithText) & SC_FOLDLEVELHEADERFLAG;
-			if (isFoldHeader) {
-				// Level is one more level than parent
-				indentLastWithText += pdoc->IndentSize();
-			}
-			if (vsDraw.viewIndentationGuides == ivLookForward) {
-				// In viLookForward mode, previous line only used if it is a fold header
-				if (isFoldHeader) {
-					indentSpace = Platform::Maximum(indentSpace, indentLastWithText);
-				}
-			} else {	// viLookBoth
-				indentSpace = Platform::Maximum(indentSpace, indentLastWithText);
-			}
-		}
-
-		int lineNextWithText = line;
-		while (lineNextWithText < Platform::Minimum(line+20, pdoc->LinesTotal()) && pdoc->IsWhiteLine(lineNextWithText)) {
-			lineNextWithText++;
-		}
-		if (lineNextWithText > line) {
-			// This line is empty, so use indentation of last line with text
-			indentSpace = Platform::Maximum(indentSpace,
-			        pdoc->GetLineIndentation(lineNextWithText));
-		}
-
-		for (int indentPos = pdoc->IndentSize(); indentPos < indentSpace; indentPos += pdoc->IndentSize()) {
-			int xIndent = indentPos * vsDraw.spaceWidth;
-			DrawIndentGuide(surface, lineVisible, vsDraw.lineHeight, xIndent + xStart, rcSegment,
-			        (ll->xHighlightGuide == xIndent));
-		}
-	}
-
-	DrawIndicators(surface, vsDraw, line, xStart, rcLine, ll, subLine, lineEnd, false);
-
-	// End of the drawing of the current line
-	if (!twoPhaseDraw) {
-		DrawEOL(surface, vsDraw, rcLine, ll, line, lineEnd,
-		        xStart, subLine, subLineStart, overrideBackground, background,
-		        drawWrapMarkEnd, wrapColour);
-	}
-	if ((vsDraw.selAlpha != SC_ALPHA_NOALPHA) && (ll->selStart >= 0) && (ll->selEnd >= 0)) {
-		int startPosSel = (ll->selStart < posLineStart) ? posLineStart : ll->selStart;
-		int endPosSel = (ll->selEnd < (lineEnd + posLineStart)) ? ll->selEnd : (lineEnd + posLineStart);
-		if (startPosSel < endPosSel) {
-			rcSegment.left = xStart + ll->positions[startPosSel - posLineStart] - subLineStart;
-			rcSegment.right = xStart + ll->positions[endPosSel - posLineStart] - subLineStart;
-			rcSegment.left = Platform::Maximum(rcSegment.left, rcLine.left);
-			rcSegment.right = Platform::Minimum(rcSegment.right, rcLine.right);
-			SimpleAlphaRectangle(surface, rcSegment, SelectionBackground(vsDraw), vsDraw.selAlpha);
-		}
-	}
-
-	// Draw any translucent whole line states
-	rcSegment.left = xStart;
-	rcSegment.right = rcLine.right - 1;
-	if (caret.active && vsDraw.showCaretLineBackground && ll->containsCaret) {
-		SimpleAlphaRectangle(surface, rcSegment, vsDraw.caretLineBackground.allocated, vsDraw.caretLineAlpha);
-	}
-	int marks = pdoc->GetMark(line);
-	for (int markBit = 0; (markBit < 32) && marks; markBit++) {
-		if ((marks & 1) && (vsDraw.markers[markBit].markType == SC_MARK_BACKGROUND)) {
-			SimpleAlphaRectangle(surface, rcSegment, vsDraw.markers[markBit].back.allocated, vsDraw.markers[markBit].alpha);
-		}
-		marks >>= 1;
+	if (Wrapping()) {
+		SetScrollBars();
 	}
-	if (vsDraw.maskInLine) {
-		int marksMasked = pdoc->GetMark(line) & vsDraw.maskInLine;
-		if (marksMasked) {
-			for (int markBit = 0; (markBit < 32) && marksMasked; markBit++) {
-				if ((marksMasked & 1) && (vsDraw.markers[markBit].markType != SC_MARK_EMPTY)) {
-					SimpleAlphaRectangle(surface, rcSegment, vsDraw.markers[markBit].back.allocated, vsDraw.markers[markBit].alpha);
-				}
-				marksMasked >>= 1;
-			}
-		}
+	ThinRectangularRange();
+	// If in wrap mode rewrap current line so EnsureCaretVisible has accurate information
+	EnsureCaretVisible();
+	// Avoid blinking during rapid typing:
+	ShowCaretAtCurrentPosition();
+	if ((caretSticky == SC_CARETSTICKY_OFF) ||
+		((caretSticky == SC_CARETSTICKY_WHITESPACE) && !IsAllSpacesOrTabs(sv))) {
+		SetLastXChosen();
 	}
-}
-
-void Editor::DrawBlockCaret(Surface *surface, ViewStyle &vsDraw, LineLayout *ll, int subLine, int xStart, int offset, int posCaret, PRectangle rcCaret) {
 
-	int lineStart = ll->LineStart(subLine);
-	int posBefore = posCaret;
-	int posAfter = MovePositionOutsideChar(posCaret + 1, 1);
-	int numCharsToDraw = posAfter - posCaret;
-
-	// Work out where the starting and ending offsets are. We need to
-	// see if the previous character shares horizontal space, such as a
-	// glyph / combining character. If so we'll need to draw that too.
-	int offsetFirstChar = offset;
-	int offsetLastChar = offset + (posAfter - posCaret);
-	while ((offsetLastChar - numCharsToDraw) >= lineStart) {
-		if ((ll->positions[offsetLastChar] - ll->positions[offsetLastChar - numCharsToDraw]) > 0) {
-			// The char does not share horizontal space
-			break;
+	int ch = static_cast<unsigned char>(sv[0]);
+	if (pdoc->dbcsCodePage != SC_CP_UTF8) {
+		if (sv.length() > 1) {
+			// DBCS code page or DBCS font character set.
+			ch = (ch << 8) | static_cast<unsigned char>(sv[1]);
 		}
-		// Char shares horizontal space, update the numChars to draw
-		// Update posBefore to point to the prev char
-		posBefore = MovePositionOutsideChar(posBefore - 1, -1);
-		numCharsToDraw = posAfter - posBefore;
-		offsetFirstChar = offset - (posCaret - posBefore);
-	}
-
-	// See if the next character shares horizontal space, if so we'll
-	// need to draw that too.
-	numCharsToDraw = offsetLastChar - offsetFirstChar;
-	while ((offsetLastChar < ll->LineStart(subLine + 1)) && (offsetLastChar <= ll->numCharsInLine)) {
-		// Update posAfter to point to the 2nd next char, this is where
-		// the next character ends, and 2nd next begins. We'll need
-		// to compare these two
-		posBefore = posAfter;
-		posAfter = MovePositionOutsideChar(posAfter + 1, 1);
-		offsetLastChar = offset + (posAfter - posCaret);
-		if ((ll->positions[offsetLastChar] - ll->positions[offsetLastChar - (posAfter - posBefore)]) > 0) {
-			// The char does not share horizontal space
-			break;
+	} else {
+		if ((ch < 0xC0) || (1 == sv.length())) {
+			// Handles UTF-8 characters between 0x01 and 0x7F and single byte
+			// characters when not in UTF-8 mode.
+			// Also treats \0 and naked trail bytes 0x80 to 0xBF as valid
+			// characters representing themselves.
+		} else {
+			unsigned int utf32[1] = { 0 };
+			UTF32FromUTF8(sv, utf32, std::size(utf32));
+			ch = utf32[0];
 		}
-		// Char shares horizontal space, update the numChars to draw
-		numCharsToDraw = offsetLastChar - offsetFirstChar;
 	}
+	NotifyChar(ch, charSource);
 
-	// We now know what to draw, update the caret drawing rectangle
-	rcCaret.left = ll->positions[offsetFirstChar] - ll->positions[ll->LineStart(subLine)] + xStart;
-	rcCaret.right = ll->positions[offsetFirstChar+numCharsToDraw] - ll->positions[ll->LineStart(subLine)] + xStart;
-
-	// This character is where the caret block is, we override the colours
-	// (inversed) for drawing the caret here.
-	int styleMain = ll->styles[offsetFirstChar];
-	surface->DrawTextClipped(rcCaret, vsDraw.styles[styleMain].font,
-	        rcCaret.top + vsDraw.maxAscent, ll->chars + offsetFirstChar,
-	        numCharsToDraw, vsDraw.styles[styleMain].back.allocated,
-	        vsDraw.caretcolour.allocated);
-}
-
-void Editor::RefreshPixMaps(Surface *surfaceWindow) {
-	if (!pixmapSelPattern->Initialised()) {
-		const int patternSize = 8;
-		pixmapSelPattern->InitPixMap(patternSize, patternSize, surfaceWindow, wMain.GetID());
-		// This complex procedure is to reproduce the checkerboard dithered pattern used by windows
-		// for scroll bars and Visual Studio for its selection margin. The colour of this pattern is half
-		// way between the chrome colour and the chrome highlight colour making a nice transition
-		// between the window chrome and the content area. And it works in low colour depths.
-		PRectangle rcPattern(0, 0, patternSize, patternSize);
-
-		// Initialize default colours based on the chrome colour scheme.  Typically the highlight is white.
-		ColourAllocated colourFMFill = vs.selbar.allocated;
-		ColourAllocated colourFMStripes = vs.selbarlight.allocated;
-
-		if (!(vs.selbarlight.desired == ColourDesired(0xff, 0xff, 0xff))) {
-			// User has chosen an unusual chrome colour scheme so just use the highlight edge colour.
-			// (Typically, the highlight colour is white.)
-			colourFMFill = vs.selbarlight.allocated;
-		}
-
-		if (vs.foldmarginColourSet) {
-			// override default fold margin colour
-			colourFMFill = vs.foldmarginColour.allocated;
-		}
-		if (vs.foldmarginHighlightColourSet) {
-			// override default fold margin highlight colour
-			colourFMStripes = vs.foldmarginHighlightColour.allocated;
-		}
-
-		pixmapSelPattern->FillRectangle(rcPattern, colourFMFill);
-		pixmapSelPattern->PenColour(colourFMStripes);
-		for (int stripe = 0; stripe < patternSize; stripe++) {
-			// Alternating 1 pixel stripes is same as checkerboard.
-			pixmapSelPattern->MoveTo(0, stripe * 2);
-			pixmapSelPattern->LineTo(patternSize, stripe * 2 - patternSize);
-		}
-	}
-
-	if (!pixmapIndentGuide->Initialised()) {
-		// 1 extra pixel in height so can handle odd/even positions and so produce a continuous line
-		pixmapIndentGuide->InitPixMap(1, vs.lineHeight + 1, surfaceWindow, wMain.GetID());
-		pixmapIndentGuideHighlight->InitPixMap(1, vs.lineHeight + 1, surfaceWindow, wMain.GetID());
-		PRectangle rcIG(0, 0, 1, vs.lineHeight);
-		pixmapIndentGuide->FillRectangle(rcIG, vs.styles[STYLE_INDENTGUIDE].back.allocated);
-		pixmapIndentGuide->PenColour(vs.styles[STYLE_INDENTGUIDE].fore.allocated);
-		pixmapIndentGuideHighlight->FillRectangle(rcIG, vs.styles[STYLE_BRACELIGHT].back.allocated);
-		pixmapIndentGuideHighlight->PenColour(vs.styles[STYLE_BRACELIGHT].fore.allocated);
-		for (int stripe = 1; stripe < vs.lineHeight + 1; stripe += 2) {
-			pixmapIndentGuide->MoveTo(0, stripe);
-			pixmapIndentGuide->LineTo(2, stripe);
-			pixmapIndentGuideHighlight->MoveTo(0, stripe);
-			pixmapIndentGuideHighlight->LineTo(2, stripe);
-		}
-	}
-
-	if (bufferedDraw) {
-		if (!pixmapLine->Initialised()) {
-			PRectangle rcClient = GetClientRectangle();
-			pixmapLine->InitPixMap(rcClient.Width(), vs.lineHeight,
-			        surfaceWindow, wMain.GetID());
-			pixmapSelMargin->InitPixMap(vs.fixedColumnWidth,
-			        rcClient.Height(), surfaceWindow, wMain.GetID());
-		}
+	if (recordingMacro && charSource != CharacterSource::tentativeInput) {
+		std::string copy(sv); // ensure NUL-terminated
+		NotifyMacroRecord(SCI_REPLACESEL, 0, reinterpret_cast<sptr_t>(copy.data()));
 	}
 }
 
-void Editor::Paint(Surface *surfaceWindow, PRectangle rcArea) {
-	//Platform::DebugPrintf("Paint:%1d (%3d,%3d) ... (%3d,%3d)\n",
-	//	paintingAllText, rcArea.left, rcArea.top, rcArea.right, rcArea.bottom);
-
-	pixmapLine->Release();
-	RefreshStyleData();
-	RefreshPixMaps(surfaceWindow);
-
-	PRectangle rcClient = GetClientRectangle();
-	//Platform::DebugPrintf("Client: (%3d,%3d) ... (%3d,%3d)   %d\n",
-	//	rcClient.left, rcClient.top, rcClient.right, rcClient.bottom);
-
-	surfaceWindow->SetPalette(&palette, true);
-	pixmapLine->SetPalette(&palette, !hasFocus);
-
-	int screenLinePaintFirst = rcArea.top / vs.lineHeight;
-	// The area to be painted plus one extra line is styled.
-	// The extra line is to determine when a style change, such as starting a comment flows on to other lines.
-	int lineStyleLast = topLine + (rcArea.bottom - 1) / vs.lineHeight + 1;
-	//Platform::DebugPrintf("Paint lines = %d .. %d\n", topLine + screenLinePaintFirst, lineStyleLast);
-	int endPosPaint = pdoc->Length();
-	if (lineStyleLast < cs.LinesDisplayed())
-		endPosPaint = pdoc->LineStart(cs.DocFromDisplay(lineStyleLast + 1));
-
-	int xStart = vs.fixedColumnWidth - xOffset;
-	int ypos = 0;
-	if (!bufferedDraw)
-		ypos += screenLinePaintFirst * vs.lineHeight;
-	int yposScreen = screenLinePaintFirst * vs.lineHeight;
-
-	// Ensure we are styled as far as we are painting.
-	pdoc->EnsureStyledTo(endPosPaint);
-	bool paintAbandonedByStyling = paintState == paintAbandoned;
-	if (needUpdateUI) {
-		// Deselect palette by selecting a temporary palette
-		Palette palTemp;
-		surfaceWindow->SetPalette(&palTemp, true);
-
-		NotifyUpdateUI();
-		needUpdateUI = false;
-
-		RefreshStyleData();
-		RefreshPixMaps(surfaceWindow);
-		surfaceWindow->SetPalette(&palette, true);
-		pixmapLine->SetPalette(&palette, !hasFocus);
-	}
-
-	// Call priority lines wrap on a window of lines which are likely
-	// to rendered with the following paint (that is wrap the visible
-	// 	lines first).
-	int startLineToWrap = cs.DocFromDisplay(topLine) - 5;
-	if (startLineToWrap < 0)
-		startLineToWrap = -1;
-	if (WrapLines(false, startLineToWrap)) {
-		// The wrapping process has changed the height of some lines so
-		// abandon this paint for a complete repaint.
-		if (AbandonPaint()) {
-			return;
-		}
-		RefreshPixMaps(surfaceWindow);	// In case pixmaps invalidated by scrollbar change
-	}
-	PLATFORM_ASSERT(pixmapSelPattern->Initialised());
-
-	PaintSelMargin(surfaceWindow, rcArea);
-
-	PRectangle rcRightMargin = rcClient;
-	rcRightMargin.left = rcRightMargin.right - vs.rightMarginWidth;
-	if (rcArea.Intersects(rcRightMargin)) {
-		surfaceWindow->FillRectangle(rcRightMargin, vs.styles[STYLE_DEFAULT].back.allocated);
-	}
-
-	if (paintState == paintAbandoned) {
-		// Either styling or NotifyUpdateUI noticed that painting is needed
-		// outside the current painting rectangle
-		//Platform::DebugPrintf("Abandoning paint\n");
-		if (wrapState != eWrapNone) {
-			if (paintAbandonedByStyling) {
-				// Styling has spilled over a line end, such as occurs by starting a multiline
-				// comment. The width of subsequent text may have changed, so rewrap.
-				NeedWrapping(cs.DocFromDisplay(topLine));
-			}
-		}
-		return;
-	}
-	//Platform::DebugPrintf("start display %d, offset = %d\n", pdoc->Length(), xOffset);
-
-	// Do the painting
-	if (rcArea.right > vs.fixedColumnWidth) {
-
-		Surface *surface = surfaceWindow;
-		if (bufferedDraw) {
-			surface = pixmapLine;
-			PLATFORM_ASSERT(pixmapLine->Initialised());
-		}
-		surface->SetUnicodeMode(IsUnicodeMode());
-		surface->SetDBCSMode(CodePage());
-
-		int visibleLine = topLine + screenLinePaintFirst;
-
-		int posCaret = currentPos;
-		if (posDrag >= 0)
-			posCaret = posDrag;
-		int lineCaret = pdoc->LineFromPosition(posCaret);
-
-		// Remove selection margin from drawing area so text will not be drawn
-		// on it in unbuffered mode.
-		PRectangle rcTextArea = rcClient;
-		rcTextArea.left = vs.fixedColumnWidth;
-		rcTextArea.right -= vs.rightMarginWidth;
-		surfaceWindow->SetClip(rcTextArea);
-
-		// Loop on visible lines
-		//double durLayout = 0.0;
-		//double durPaint = 0.0;
-		//double durCopy = 0.0;
-		//ElapsedTime etWhole;
-		int lineDocPrevious = -1;	// Used to avoid laying out one document line multiple times
-		AutoLineLayout ll(llc, 0);
-		SelectionLineIterator lineIterator(this);
-		while (visibleLine < cs.LinesDisplayed() && yposScreen < rcArea.bottom) {
-
-			int lineDoc = cs.DocFromDisplay(visibleLine);
-			// Only visible lines should be handled by the code within the loop
-			PLATFORM_ASSERT(cs.GetVisible(lineDoc));
-			int lineStartSet = cs.DisplayFromDoc(lineDoc);
-			int subLine = visibleLine - lineStartSet;
-
-			// Copy this line and its styles from the document into local arrays
-			// and determine the x position at which each character starts.
-			//ElapsedTime et;
-			if (lineDoc != lineDocPrevious) {
-				ll.Set(0);
-				// For rectangular selection this accesses the layout cache so should be after layout returned.
-				lineIterator.SetAt(lineDoc);
-				ll.Set(RetrieveLineLayout(lineDoc));
-				LayoutLine(lineDoc, surface, vs, ll, wrapWidth);
-				lineDocPrevious = lineDoc;
-			}
-			//durLayout += et.Duration(true);
-
-			if (ll) {
-				if (selType == selStream) {
-					ll->selStart = SelectionStart();
-					ll->selEnd = SelectionEnd();
-				} else {
-					ll->selStart = lineIterator.startPos;
-					ll->selEnd = lineIterator.endPos;
-				}
-				ll->containsCaret = lineDoc == lineCaret;
-				if (hideSelection) {
-					ll->selStart = -1;
-					ll->selEnd = -1;
-					ll->containsCaret = false;
-				}
-
-				GetHotSpotRange(ll->hsStart, ll->hsEnd);
-
-				PRectangle rcLine = rcClient;
-				rcLine.top = ypos;
-				rcLine.bottom = ypos + vs.lineHeight;
-
-				Range rangeLine(pdoc->LineStart(lineDoc), pdoc->LineStart(lineDoc + 1));
-				// Highlight the current braces if any
-				ll->SetBracesHighlight(rangeLine, braces, static_cast<char>(bracesMatchStyle),
-				        highlightGuideColumn * vs.spaceWidth);
-
-				// Draw the line
-				DrawLine(surface, vs, lineDoc, visibleLine, xStart, rcLine, ll, subLine);
-				//durPaint += et.Duration(true);
-
-				// Restore the previous styles for the brace highlights in case layout is in cache.
-				ll->RestoreBracesHighlight(rangeLine, braces);
-
-				bool expanded = cs.GetExpanded(lineDoc);
-				if ((foldFlags & SC_FOLDFLAG_BOX) == 0) {
-					// Paint the line above the fold
-					if ((expanded && (foldFlags & SC_FOLDFLAG_LINEBEFORE_EXPANDED))
-					        ||
-					        (!expanded && (foldFlags & SC_FOLDFLAG_LINEBEFORE_CONTRACTED))) {
-						if (pdoc->GetLevel(lineDoc) & SC_FOLDLEVELHEADERFLAG) {
-							PRectangle rcFoldLine = rcLine;
-							rcFoldLine.bottom = rcFoldLine.top + 1;
-							surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore.allocated);
-						}
-					}
-					// Paint the line below the fold
-					if ((expanded && (foldFlags & SC_FOLDFLAG_LINEAFTER_EXPANDED))
-					        ||
-					        (!expanded && (foldFlags & SC_FOLDFLAG_LINEAFTER_CONTRACTED))) {
-						if (pdoc->GetLevel(lineDoc) & SC_FOLDLEVELHEADERFLAG) {
-							PRectangle rcFoldLine = rcLine;
-							rcFoldLine.top = rcFoldLine.bottom - 1;
-							surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore.allocated);
-						}
-					}
+void Editor::ClearBeforeTentativeStart() {
+	// Make positions for the first composition string.
+	FilterSelections();
+	UndoGroup ug(pdoc, (sel.Count() > 1) || !sel.Empty() || inOverstrike);
+	for (size_t r = 0; r<sel.Count(); r++) {
+		if (!RangeContainsProtected(sel.Range(r).Start().Position(),
+			sel.Range(r).End().Position())) {
+			const Sci::Position positionInsert = sel.Range(r).Start().Position();
+			if (!sel.Range(r).Empty()) {
+				if (sel.Range(r).Length()) {
+					pdoc->DeleteChars(positionInsert, sel.Range(r).Length());
+					sel.Range(r).ClearVirtualSpace();
 				} else {
-					int FoldLevelCurr = (pdoc->GetLevel(lineDoc) & SC_FOLDLEVELNUMBERMASK) - SC_FOLDLEVELBASE;
-					int FoldLevelPrev = (pdoc->GetLevel(lineDoc - 1) & SC_FOLDLEVELNUMBERMASK) - SC_FOLDLEVELBASE;
-					int FoldLevelFlags = (pdoc->GetLevel(lineDoc) & ~SC_FOLDLEVELNUMBERMASK) & ~(0xFFF0000);
-					int indentationStep = pdoc->IndentSize();
-					// Draw line above fold
-					if ((FoldLevelPrev < FoldLevelCurr)
-					        ||
-					        (FoldLevelFlags & SC_FOLDLEVELBOXHEADERFLAG
-					         &&
-					         (pdoc->GetLevel(lineDoc - 1) & SC_FOLDLEVELBOXFOOTERFLAG) == 0)) {
-						PRectangle rcFoldLine = rcLine;
-						rcFoldLine.bottom = rcFoldLine.top + 1;
-						rcFoldLine.left += xStart + FoldLevelCurr * vs.spaceWidth * indentationStep - 1;
-						surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore.allocated);
-					}
-
-					// Line below the fold (or below a contracted fold)
-					if (FoldLevelFlags & SC_FOLDLEVELBOXFOOTERFLAG
-					        ||
-					        (!expanded && (foldFlags & SC_FOLDFLAG_LINEAFTER_CONTRACTED))) {
-						PRectangle rcFoldLine = rcLine;
-						rcFoldLine.top = rcFoldLine.bottom - 1;
-						rcFoldLine.left += xStart + (FoldLevelCurr) * vs.spaceWidth * indentationStep - 1;
-						surface->FillRectangle(rcFoldLine, vs.styles[STYLE_DEFAULT].fore.allocated);
-					}
-
-					PRectangle rcBoxLine = rcLine;
-					// Draw vertical line for every fold level
-					for (int i = 0; i <= FoldLevelCurr; i++) {
-						rcBoxLine.left = xStart + i * vs.spaceWidth * indentationStep - 1;
-						rcBoxLine.right = rcBoxLine.left + 1;
-						surface->FillRectangle(rcBoxLine, vs.styles[STYLE_DEFAULT].fore.allocated);
-					}
-				}
-
-				// Draw the Caret
-				if (lineDoc == lineCaret) {
-					int offset = Platform::Minimum(posCaret - rangeLine.start, ll->maxLineLength);
-					if (ll->InLine(offset, subLine)) {
-						int xposCaret = ll->positions[offset] - ll->positions[ll->LineStart(subLine)] + xStart;
-
-						if (actualWrapVisualStartIndent != 0) {
-							int lineStart = ll->LineStart(subLine);
-							if (lineStart != 0)	// Wrapped
-								xposCaret += actualWrapVisualStartIndent * vs.aveCharWidth;
-						}
-						if ((xposCaret >= 0) && (vs.caretWidth > 0) && (vs.caretStyle != CARETSTYLE_INVISIBLE) &&
-						        ((posDrag >= 0) || (caret.active && caret.on))) {
-							bool caretAtEOF = false;
-							bool caretAtEOL = false;
-							bool drawBlockCaret = false;
-							int widthOverstrikeCaret;
-							int caretWidthOffset = 0;
-							PRectangle rcCaret = rcLine;
-
-							if (posCaret == pdoc->Length())	{   // At end of document
-								caretAtEOF = true;
-								widthOverstrikeCaret = vs.aveCharWidth;
-							} else if ((posCaret - rangeLine.start) >= ll->numCharsInLine) {	// At end of line
-								caretAtEOL = true;
-								widthOverstrikeCaret = vs.aveCharWidth;
-							} else {
-								widthOverstrikeCaret = ll->positions[offset + 1] - ll->positions[offset];
-							}
-							if (widthOverstrikeCaret < 3)	// Make sure its visible
-								widthOverstrikeCaret = 3;
-
-							if (offset > ll->LineStart(subLine))
-								caretWidthOffset = 1;	// Move back so overlaps both character cells.
-							if (posDrag >= 0) {
-								/* Dragging text, use a line caret */
-								rcCaret.left = xposCaret - caretWidthOffset;
-								rcCaret.right = rcCaret.left + vs.caretWidth;
-							} else if (inOverstrike) {
-								/* Overstrike (insert mode), use a modified bar caret */
-								rcCaret.top = rcCaret.bottom - 2;
-								rcCaret.left = xposCaret + 1;
-								rcCaret.right = rcCaret.left + widthOverstrikeCaret - 1;
-							} else if (vs.caretStyle == CARETSTYLE_BLOCK) {
-								/* Block caret */
-								rcCaret.left = xposCaret;
-								if (!caretAtEOL && !caretAtEOF && (ll->chars[offset] != '\t') && !(IsControlCharacter(ll->chars[offset]))) {
-									drawBlockCaret = true;
-									rcCaret.right = xposCaret + widthOverstrikeCaret;
-								} else {
-									rcCaret.right = xposCaret + vs.aveCharWidth;
-								}
-							} else {
-								/* Line caret */
-								rcCaret.left = xposCaret - caretWidthOffset;
-								rcCaret.right = rcCaret.left + vs.caretWidth;
-							}
-							if (drawBlockCaret) {
-								DrawBlockCaret(surface, vs, ll, subLine, xStart, offset, posCaret, rcCaret);
-							} else {
-								surface->FillRectangle(rcCaret, vs.caretcolour.allocated);
-							}
-						}
-					}
+					// Range is all virtual so collapse to start of virtual space
+					sel.Range(r).MinimizeVirtualSpace();
 				}
-
-				if (bufferedDraw) {
-					Point from(vs.fixedColumnWidth, 0);
-					PRectangle rcCopyArea(vs.fixedColumnWidth, yposScreen,
-					        rcClient.right, yposScreen + vs.lineHeight);
-					surfaceWindow->Copy(rcCopyArea, from, *pixmapLine);
-				}
-				//durCopy += et.Duration(true);
-			}
-
-			if (!bufferedDraw) {
-				ypos += vs.lineHeight;
-			}
-
-			yposScreen += vs.lineHeight;
-			visibleLine++;
-
-			lineWidthMaxSeen = Platform::Maximum(
-			            lineWidthMaxSeen, ll->positions[ll->numCharsInLine]);
-			//gdk_flush();
-		}
-		ll.Set(0);
-		//if (durPaint < 0.00000001)
-		//	durPaint = 0.00000001;
-
-		// Right column limit indicator
-		PRectangle rcBeyondEOF = rcClient;
-		rcBeyondEOF.left = vs.fixedColumnWidth;
-		rcBeyondEOF.right = rcBeyondEOF.right;
-		rcBeyondEOF.top = (cs.LinesDisplayed() - topLine) * vs.lineHeight;
-		if (rcBeyondEOF.top < rcBeyondEOF.bottom) {
-			surfaceWindow->FillRectangle(rcBeyondEOF, vs.styles[STYLE_DEFAULT].back.allocated);
-			if (vs.edgeState == EDGE_LINE) {
-				int edgeX = theEdge * vs.spaceWidth;
-				rcBeyondEOF.left = edgeX + xStart;
-				rcBeyondEOF.right = rcBeyondEOF.left + 1;
-				surfaceWindow->FillRectangle(rcBeyondEOF, vs.edgecolour.allocated);
 			}
+			RealizeVirtualSpace(positionInsert, sel.Range(r).caret.VirtualSpace());
+			sel.Range(r).ClearVirtualSpace();
 		}
-		//Platform::DebugPrintf(
-		//"Layout:%9.6g    Paint:%9.6g    Ratio:%9.6g   Copy:%9.6g   Total:%9.6g\n",
-		//durLayout, durPaint, durLayout / durPaint, durCopy, etWhole.Duration());
-		NotifyPainted();
 	}
 }
 
-// Space (3 space characters) between line numbers and text when printing.
-#define lineNumberPrintSpace "   "
-
-ColourDesired InvertedLight(ColourDesired orig) {
-	unsigned int r = orig.GetRed();
-	unsigned int g = orig.GetGreen();
-	unsigned int b = orig.GetBlue();
-	unsigned int l = (r + g + b) / 3; 	// There is a better calculation for this that matches human eye
-	unsigned int il = 0xff - l;
-	if (l == 0)
-		return ColourDesired(0xff, 0xff, 0xff);
-	r = r * il / l;
-	g = g * il / l;
-	b = b * il / l;
-	return ColourDesired(Platform::Minimum(r, 0xff), Platform::Minimum(g, 0xff), Platform::Minimum(b, 0xff));
-}
-
-// This is mostly copied from the Paint method but with some things omitted
-// such as the margin markers, line numbers, selection and caret
-// Should be merged back into a combined Draw method.
-long Editor::FormatRange(bool draw, RangeToFormat *pfr) {
-	if (!pfr)
-		return 0;
-
-	AutoSurface surface(pfr->hdc, this);
-	if (!surface)
-		return 0;
-	AutoSurface surfaceMeasure(pfr->hdcTarget, this);
-	if (!surfaceMeasure) {
-		return 0;
-	}
-
-	// Can't use measurements cached for screen
-	posCache.Clear();
-
-	ViewStyle vsPrint(vs);
-
-	// Modify the view style for printing as do not normally want any of the transient features to be printed
-	// Printing supports only the line number margin.
-	int lineNumberIndex = -1;
-	for (int margin = 0; margin < ViewStyle::margins; margin++) {
-		if ((vsPrint.ms[margin].style == SC_MARGIN_NUMBER) && (vsPrint.ms[margin].width > 0)) {
-			lineNumberIndex = margin;
-		} else {
-			vsPrint.ms[margin].width = 0;
-		}
-	}
-	vsPrint.showMarkedLines = false;
-	vsPrint.fixedColumnWidth = 0;
-	vsPrint.zoomLevel = printMagnification;
-	vsPrint.viewIndentationGuides = ivNone;
-	// Don't show the selection when printing
-	vsPrint.selbackset = false;
-	vsPrint.selforeset = false;
-	vsPrint.selAlpha = SC_ALPHA_NOALPHA;
-	vsPrint.whitespaceBackgroundSet = false;
-	vsPrint.whitespaceForegroundSet = false;
-	vsPrint.showCaretLineBackground = false;
-
-	// Set colours for printing according to users settings
-	for (size_t sty = 0;sty < vsPrint.stylesSize;sty++) {
-		if (printColourMode == SC_PRINT_INVERTLIGHT) {
-			vsPrint.styles[sty].fore.desired = InvertedLight(vsPrint.styles[sty].fore.desired);
-			vsPrint.styles[sty].back.desired = InvertedLight(vsPrint.styles[sty].back.desired);
-		} else if (printColourMode == SC_PRINT_BLACKONWHITE) {
-			vsPrint.styles[sty].fore.desired = ColourDesired(0, 0, 0);
-			vsPrint.styles[sty].back.desired = ColourDesired(0xff, 0xff, 0xff);
-		} else if (printColourMode == SC_PRINT_COLOURONWHITE) {
-			vsPrint.styles[sty].back.desired = ColourDesired(0xff, 0xff, 0xff);
-		} else if (printColourMode == SC_PRINT_COLOURONWHITEDEFAULTBG) {
-			if (sty <= STYLE_DEFAULT) {
-				vsPrint.styles[sty].back.desired = ColourDesired(0xff, 0xff, 0xff);
-			}
+void Editor::InsertPaste(const char *text, Sci::Position len) {
+	if (multiPasteMode == SC_MULTIPASTE_ONCE) {
+		SelectionPosition selStart = sel.Start();
+		selStart = RealizeVirtualSpace(selStart);
+		const Sci::Position lengthInserted = pdoc->InsertString(selStart.Position(), text, len);
+		if (lengthInserted > 0) {
+			SetEmptySelection(selStart.Position() + lengthInserted);
 		}
-	}
-	// White background for the line numbers
-	vsPrint.styles[STYLE_LINENUMBER].back.desired = ColourDesired(0xff, 0xff, 0xff);
-
-	vsPrint.Refresh(*surfaceMeasure);
-	// Determining width must hapen after fonts have been realised in Refresh
-	int lineNumberWidth = 0;
-	if (lineNumberIndex >= 0) {
-		lineNumberWidth = surfaceMeasure->WidthText(vsPrint.styles[STYLE_LINENUMBER].font,
-		        "99999" lineNumberPrintSpace, 5 + istrlen(lineNumberPrintSpace));
-		vsPrint.ms[lineNumberIndex].width = lineNumberWidth;
-		vsPrint.Refresh(*surfaceMeasure);	// Recalculate fixedColumnWidth
-	}
-	// Ensure colours are set up
-	vsPrint.RefreshColourPalette(palette, true);
-	vsPrint.RefreshColourPalette(palette, false);
-
-	int linePrintStart = pdoc->LineFromPosition(pfr->chrg.cpMin);
-	int linePrintLast = linePrintStart + (pfr->rc.bottom - pfr->rc.top) / vsPrint.lineHeight - 1;
-	if (linePrintLast < linePrintStart)
-		linePrintLast = linePrintStart;
-	int linePrintMax = pdoc->LineFromPosition(pfr->chrg.cpMax);
-	if (linePrintLast > linePrintMax)
-		linePrintLast = linePrintMax;
-	//Platform::DebugPrintf("Formatting lines=[%0d,%0d,%0d] top=%0d bottom=%0d line=%0d %0d\n",
-	//      linePrintStart, linePrintLast, linePrintMax, pfr->rc.top, pfr->rc.bottom, vsPrint.lineHeight,
-	//      surfaceMeasure->Height(vsPrint.styles[STYLE_LINENUMBER].font));
-	int endPosPrint = pdoc->Length();
-	if (linePrintLast < pdoc->LinesTotal())
-		endPosPrint = pdoc->LineStart(linePrintLast + 1);
-
-	// Ensure we are styled to where we are formatting.
-	pdoc->EnsureStyledTo(endPosPrint);
-
-	int xStart = vsPrint.fixedColumnWidth + pfr->rc.left;
-	int ypos = pfr->rc.top;
-
-	int lineDoc = linePrintStart;
-
-	int nPrintPos = pfr->chrg.cpMin;
-	int visibleLine = 0;
-	int widthPrint = pfr->rc.Width() - vsPrint.fixedColumnWidth;
-	if (printWrapState == eWrapNone)
-		widthPrint = LineLayout::wrapWidthInfinite;
-
-	while (lineDoc <= linePrintLast && ypos < pfr->rc.bottom) {
-
-		// When printing, the hdc and hdcTarget may be the same, so
-		// changing the state of surfaceMeasure may change the underlying
-		// state of surface. Therefore, any cached state is discarded before
-		// using each surface.
-		surfaceMeasure->FlushCachedState();
-
-		// Copy this line and its styles from the document into local arrays
-		// and determine the x position at which each character starts.
-		LineLayout ll(8000);
-		LayoutLine(lineDoc, surfaceMeasure, vsPrint, &ll, widthPrint);
-
-		ll.selStart = -1;
-		ll.selEnd = -1;
-		ll.containsCaret = false;
-
-		PRectangle rcLine;
-		rcLine.left = pfr->rc.left;
-		rcLine.top = ypos;
-		rcLine.right = pfr->rc.right - 1;
-		rcLine.bottom = ypos + vsPrint.lineHeight;
-
-		// When document line is wrapped over multiple display lines, find where
-		// to start printing from to ensure a particular position is on the first
-		// line of the page.
-		if (visibleLine == 0) {
-			int startWithinLine = nPrintPos - pdoc->LineStart(lineDoc);
-			for (int iwl = 0; iwl < ll.lines - 1; iwl++) {
-				if (ll.LineStart(iwl) <= startWithinLine && ll.LineStart(iwl + 1) >= startWithinLine) {
-					visibleLine = -iwl;
-				}
-			}
-
-			if (ll.lines > 1 && startWithinLine >= ll.LineStart(ll.lines - 1)) {
-				visibleLine = -(ll.lines - 1);
-			}
-		}
-
-		if (draw && lineNumberWidth &&
-		        (ypos + vsPrint.lineHeight <= pfr->rc.bottom) &&
-		        (visibleLine >= 0)) {
-			char number[100];
-			sprintf(number, "%d" lineNumberPrintSpace, lineDoc + 1);
-			PRectangle rcNumber = rcLine;
-			rcNumber.right = rcNumber.left + lineNumberWidth;
-			// Right justify
-			rcNumber.left = rcNumber.right - surfaceMeasure->WidthText(
-			            vsPrint.styles[STYLE_LINENUMBER].font, number, istrlen(number));
-			surface->FlushCachedState();
-			surface->DrawTextNoClip(rcNumber, vsPrint.styles[STYLE_LINENUMBER].font,
-			        ypos + vsPrint.maxAscent, number, istrlen(number),
-			        vsPrint.styles[STYLE_LINENUMBER].fore.allocated,
-			        vsPrint.styles[STYLE_LINENUMBER].back.allocated);
-		}
-
-		// Draw the line
-		surface->FlushCachedState();
-
-		for (int iwl = 0; iwl < ll.lines; iwl++) {
-			if (ypos + vsPrint.lineHeight <= pfr->rc.bottom) {
-				if (visibleLine >= 0) {
-					if (draw) {
-						rcLine.top = ypos;
-						rcLine.bottom = ypos + vsPrint.lineHeight;
-						DrawLine(surface, vsPrint, lineDoc, visibleLine, xStart, rcLine, &ll, iwl);
+	} else {
+		// SC_MULTIPASTE_EACH
+		for (size_t r=0; r<sel.Count(); r++) {
+			if (!RangeContainsProtected(sel.Range(r).Start().Position(),
+				sel.Range(r).End().Position())) {
+				Sci::Position positionInsert = sel.Range(r).Start().Position();
+				if (!sel.Range(r).Empty()) {
+					if (sel.Range(r).Length()) {
+						pdoc->DeleteChars(positionInsert, sel.Range(r).Length());
+						sel.Range(r).ClearVirtualSpace();
+					} else {
+						// Range is all virtual so collapse to start of virtual space
+						sel.Range(r).MinimizeVirtualSpace();
 					}
-					ypos += vsPrint.lineHeight;
 				}
-				visibleLine++;
-				if (iwl == ll.lines - 1)
-					nPrintPos = pdoc->LineStart(lineDoc + 1);
-				else
-					nPrintPos += ll.LineStart(iwl + 1) - ll.LineStart(iwl);
+				positionInsert = RealizeVirtualSpace(positionInsert, sel.Range(r).caret.VirtualSpace());
+				const Sci::Position lengthInserted = pdoc->InsertString(positionInsert, text, len);
+				if (lengthInserted > 0) {
+					sel.Range(r).caret.SetPosition(positionInsert + lengthInserted);
+					sel.Range(r).anchor.SetPosition(positionInsert + lengthInserted);
+				}
+				sel.Range(r).ClearVirtualSpace();
 			}
 		}
-
-		++lineDoc;
 	}
-
-	// Clear cache so measurements are not used for screen
-	posCache.Clear();
-
-	return nPrintPos;
 }
 
-int Editor::TextWidth(int style, const char *text) {
-	RefreshStyleData();
-	AutoSurface surface(this);
-	if (surface) {
-		return surface->WidthText(vs.styles[style].font, text, istrlen(text));
-	} else {
-		return 1;
+void Editor::InsertPasteShape(const char *text, Sci::Position len, PasteShape shape) {
+	std::string convertedText;
+	if (convertPastes) {
+		// Convert line endings of the paste into our local line-endings mode
+		convertedText = Document::TransformLineEnds(text, len, pdoc->eolMode);
+		len = convertedText.length();
+		text = convertedText.c_str();
 	}
-}
-
-// Empty method is overridden on GTK+ to show / hide scrollbars
-void Editor::ReconfigureScrollBars() {}
-
-void Editor::SetScrollBars() {
-	RefreshStyleData();
-
-	int nMax = MaxScrollPos();
-	int nPage = LinesOnScreen();
-	bool modified = ModifyScrollBars(nMax + nPage - 1, nPage);
-	if (modified) {
-		DwellEnd(true);
-	}
-
-	// TODO: ensure always showing as many lines as possible
-	// May not be, if, for example, window made larger
-	if (topLine > MaxScrollPos()) {
-		SetTopLine(Platform::Clamp(topLine, 0, MaxScrollPos()));
-		SetVerticalScrollPos();
-		Redraw();
-	}
-	if (modified) {
-		if (!AbandonPaint())
-			Redraw();
-	}
-	//Platform::DebugPrintf("end max = %d page = %d\n", nMax, nPage);
-}
-
-void Editor::ChangeSize() {
-	DropGraphics();
-	SetScrollBars();
-	if (wrapState != eWrapNone) {
-		PRectangle rcTextArea = GetClientRectangle();
-		rcTextArea.left = vs.fixedColumnWidth;
-		rcTextArea.right -= vs.rightMarginWidth;
-		if (wrapWidth != rcTextArea.Width()) {
-			NeedWrapping();
-			Redraw();
-		}
-	}
-}
-
-void Editor::AddChar(char ch) {
-	char s[2];
-	s[0] = ch;
-	s[1] = '\0';
-	AddCharUTF(s, 1);
-}
-
-// AddCharUTF inserts an array of bytes which may or may not be in UTF-8.
-void Editor::AddCharUTF(char *s, unsigned int len, bool treatAsDBCS) {
-	bool wasSelection = currentPos != anchor;
-	ClearSelection();
-	bool charReplaceAction = false;
-	if (inOverstrike && !wasSelection && !RangeContainsProtected(currentPos, currentPos + 1)) {
-		if (currentPos < (pdoc->Length())) {
-			if (!IsEOLChar(pdoc->CharAt(currentPos))) {
-				charReplaceAction = true;
-				pdoc->BeginUndoAction();
-				pdoc->DelChar(currentPos);
-			}
-		}
-	}
-	if (pdoc->InsertString(currentPos, s, len)) {
-		SetEmptySelection(currentPos + len);
-	}
-	if (charReplaceAction) {
-		pdoc->EndUndoAction();
-	}
-	// If in wrap mode rewrap current line so EnsureCaretVisible has accurate information
-	if (wrapState != eWrapNone) {
-		AutoSurface surface(this);
-		if (surface) {
-			WrapOneLine(surface, pdoc->LineFromPosition(currentPos));
-		}
-		SetScrollBars();
-	}
-	EnsureCaretVisible();
-	// Avoid blinking during rapid typing:
-	ShowCaretAtCurrentPosition();
-	if (!caretSticky) {
-		SetLastXChosen();
-	}
-
-	if (treatAsDBCS) {
-		NotifyChar((static_cast<unsigned char>(s[0]) << 8) |
-		        static_cast<unsigned char>(s[1]));
+	if (shape == pasteRectangular) {
+		PasteRectangular(sel.Start(), text, len);
 	} else {
-		int byte = static_cast<unsigned char>(s[0]);
-		if ((byte < 0xC0) || (1 == len)) {
-			// Handles UTF-8 characters between 0x01 and 0x7F and single byte
-			// characters when not in UTF-8 mode.
-			// Also treats \0 and naked trail bytes 0x80 to 0xBF as valid
-			// characters representing themselves.
-		} else {
-			// Unroll 1 to 3 byte UTF-8 sequences.  See reference data at:
-			// http://www.cl.cam.ac.uk/~mgk25/unicode.html
-			// http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
-			if (byte < 0xE0) {
-				int byte2 = static_cast<unsigned char>(s[1]);
-				if ((byte2 & 0xC0) == 0x80) {
-					// Two-byte-character lead-byte followed by a trail-byte.
-					byte = (((byte & 0x1F) << 6) | (byte2 & 0x3F));
-				}
-				// A two-byte-character lead-byte not followed by trail-byte
-				// represents itself.
-			} else if (byte < 0xF0) {
-				int byte2 = static_cast<unsigned char>(s[1]);
-				int byte3 = static_cast<unsigned char>(s[2]);
-				if (((byte2 & 0xC0) == 0x80) && ((byte3 & 0xC0) == 0x80)) {
-					// Three-byte-character lead byte followed by two trail bytes.
-					byte = (((byte & 0x0F) << 12) | ((byte2 & 0x3F) << 6) |
-					        (byte3 & 0x3F));
-				}
-				// A three-byte-character lead-byte not followed by two trail-bytes
-				// represents itself.
+		if (shape == pasteLine) {
+			const Sci::Position insertPos =
+				pdoc->LineStart(pdoc->LineFromPosition(sel.MainCaret()));
+			Sci::Position lengthInserted = pdoc->InsertString(insertPos, text, len);
+			// add the newline if necessary
+			if ((len > 0) && (text[len - 1] != '\n' && text[len - 1] != '\r')) {
+				const char *endline = StringFromEOLMode(pdoc->eolMode);
+				const Sci::Position length = strlen(endline);
+				lengthInserted += pdoc->InsertString(insertPos + lengthInserted, endline, length);
+			}
+			if (sel.MainCaret() == insertPos) {
+				SetEmptySelection(sel.MainCaret() + lengthInserted);
 			}
+		} else {
+			InsertPaste(text, len);
 		}
-		NotifyChar(byte);
 	}
 }
 
-void Editor::ClearSelection() {
-	if (!SelectionContainsProtected()) {
-		int startPos = SelectionStart();
-		if (selType == selStream) {
-			unsigned int chars = SelectionEnd() - startPos;
-			if (0 != chars) {
-				pdoc->BeginUndoAction();
-				pdoc->DeleteChars(startPos, chars);
-				pdoc->EndUndoAction();
-			}
-		} else {
-			pdoc->BeginUndoAction();
-			SelectionLineIterator lineIterator(this, false);
-			while (lineIterator.Iterate()) {
-				startPos = lineIterator.startPos;
-				unsigned int chars = lineIterator.endPos - startPos;
-				if (0 != chars) {
-					pdoc->DeleteChars(startPos, chars);
-				}
+void Editor::ClearSelection(bool retainMultipleSelections) {
+	if (!sel.IsRectangular() && !retainMultipleSelections)
+		FilterSelections();
+	UndoGroup ug(pdoc);
+	for (size_t r=0; r<sel.Count(); r++) {
+		if (!sel.Range(r).Empty()) {
+			if (!RangeContainsProtected(sel.Range(r).Start().Position(),
+				sel.Range(r).End().Position())) {
+				pdoc->DeleteChars(sel.Range(r).Start().Position(),
+					sel.Range(r).Length());
+				sel.Range(r) = SelectionRange(sel.Range(r).Start());
 			}
-			pdoc->EndUndoAction();
-			selType = selStream;
 		}
-		SetEmptySelection(startPos);
 	}
+	ThinRectangularRange();
+	sel.RemoveDuplicates();
+	ClaimSelection();
+	SetHoverIndicatorPosition(sel.MainCaret());
 }
 
 void Editor::ClearAll() {
-	pdoc->BeginUndoAction();
-	if (0 != pdoc->Length()) {
-		pdoc->DeleteChars(0, pdoc->Length());
-	}
-	if (!pdoc->IsReadOnly()) {
-		cs.Clear();
+	{
+		UndoGroup ug(pdoc);
+		if (0 != pdoc->Length()) {
+			pdoc->DeleteChars(0, pdoc->Length());
+		}
+		if (!pdoc->IsReadOnly()) {
+			pcs->Clear();
+			pdoc->AnnotationClearAll();
+			pdoc->EOLAnnotationClearAll();
+			pdoc->MarginClearAll();
+		}
 	}
-	pdoc->EndUndoAction();
-	anchor = 0;
-	currentPos = 0;
+
+	view.ClearAllTabstops();
+
+	sel.Clear();
 	SetTopLine(0);
 	SetVerticalScrollPos();
 	InvalidateStyleRedraw();
 }
 
 void Editor::ClearDocumentStyle() {
-	Decoration *deco = pdoc->decorations.root;
-	while (deco) {
-		// Save next in case deco deleted
-		Decoration *decoNext = deco->next;
-		if (deco->indicator < INDIC_CONTAINER) {
-			pdoc->decorations.SetCurrentIndicator(deco->indicator);
-			pdoc->DecorationFillRange(0, 0, pdoc->Length());
-		}
-		deco = decoNext;
-	}
-	pdoc->StartStyling(0, '\377');
+	pdoc->decorations->DeleteLexerDecorations();
+	pdoc->StartStyling(0);
 	pdoc->SetStyleFor(pdoc->Length(), 0);
-	cs.ShowAll();
+	pcs->ShowAll();
+	SetAnnotationHeights(0, pdoc->LinesTotal());
 	pdoc->ClearLevels();
 }
 
@@ -3523,41 +2163,45 @@ void Editor::Cut() {
 	}
 }
 
-void Editor::PasteRectangular(int pos, const char *ptr, int len) {
+void Editor::PasteRectangular(SelectionPosition pos, const char *ptr, Sci::Position len) {
 	if (pdoc->IsReadOnly() || SelectionContainsProtected()) {
 		return;
 	}
-	currentPos = pos;
-	int xInsert = XFromPosition(currentPos);
-	int line = pdoc->LineFromPosition(currentPos);
+	sel.Clear();
+	sel.RangeMain() = SelectionRange(pos);
+	Sci::Line line = pdoc->SciLineFromPosition(sel.MainCaret());
+	UndoGroup ug(pdoc);
+	sel.RangeMain().caret = RealizeVirtualSpace(sel.RangeMain().caret);
+	const int xInsert = XFromPosition(sel.RangeMain().caret);
 	bool prevCr = false;
-	pdoc->BeginUndoAction();
-	for (int i = 0; i < len; i++) {
+	while ((len > 0) && IsEOLChar(ptr[len-1]))
+		len--;
+	for (Sci::Position i = 0; i < len; i++) {
 		if (IsEOLChar(ptr[i])) {
 			if ((ptr[i] == '\r') || (!prevCr))
 				line++;
 			if (line >= pdoc->LinesTotal()) {
 				if (pdoc->eolMode != SC_EOL_LF)
-					pdoc->InsertChar(pdoc->Length(), '\r');
+					pdoc->InsertString(pdoc->Length(), "\r", 1);
 				if (pdoc->eolMode != SC_EOL_CR)
-					pdoc->InsertChar(pdoc->Length(), '\n');
+					pdoc->InsertString(pdoc->Length(), "\n", 1);
 			}
 			// Pad the end of lines with spaces if required
-			currentPos = PositionFromLineX(line, xInsert);
-			if ((XFromPosition(currentPos) < xInsert) && (i + 1 < len)) {
-				for (int i = 0; i < xInsert - XFromPosition(currentPos); i++) {
-					pdoc->InsertChar(currentPos, ' ');
-					currentPos++;
+			sel.RangeMain().caret.SetPosition(PositionFromLineX(line, xInsert));
+			if ((XFromPosition(sel.RangeMain().caret) < xInsert) && (i + 1 < len)) {
+				while (XFromPosition(sel.RangeMain().caret) < xInsert) {
+					assert(pdoc);
+					const Sci::Position lengthInserted = pdoc->InsertString(sel.MainCaret(), " ", 1);
+					sel.RangeMain().caret.Add(lengthInserted);
 				}
 			}
 			prevCr = ptr[i] == '\r';
 		} else {
-			pdoc->InsertString(currentPos, ptr + i, 1);
-			currentPos++;
+			const Sci::Position lengthInserted = pdoc->InsertString(sel.MainCaret(), ptr + i, 1);
+			sel.RangeMain().caret.Add(lengthInserted);
 			prevCr = false;
 		}
 	}
-	pdoc->EndUndoAction();
 	SetEmptySelection(pos);
 }
 
@@ -3566,17 +2210,40 @@ bool Editor::CanPaste() {
 }
 
 void Editor::Clear() {
-	if (currentPos == anchor) {
-		if (!RangeContainsProtected(currentPos, currentPos + 1)) {
-			DelChar();
+	// If multiple selections, don't delete EOLS
+	if (sel.Empty()) {
+		bool singleVirtual = false;
+		if ((sel.Count() == 1) &&
+			!RangeContainsProtected(sel.MainCaret(), sel.MainCaret() + 1) &&
+			sel.RangeMain().Start().VirtualSpace()) {
+			singleVirtual = true;
+		}
+		UndoGroup ug(pdoc, (sel.Count() > 1) || singleVirtual);
+		for (size_t r=0; r<sel.Count(); r++) {
+			if (!RangeContainsProtected(sel.Range(r).caret.Position(), sel.Range(r).caret.Position() + 1)) {
+				if (sel.Range(r).Start().VirtualSpace()) {
+					if (sel.Range(r).anchor < sel.Range(r).caret)
+						sel.Range(r) = SelectionRange(RealizeVirtualSpace(sel.Range(r).anchor.Position(), sel.Range(r).anchor.VirtualSpace()));
+					else
+						sel.Range(r) = SelectionRange(RealizeVirtualSpace(sel.Range(r).caret.Position(), sel.Range(r).caret.VirtualSpace()));
+				}
+				if ((sel.Count() == 1) || !pdoc->IsPositionInLineEnd(sel.Range(r).caret.Position())) {
+					pdoc->DelChar(sel.Range(r).caret.Position());
+					sel.Range(r).ClearVirtualSpace();
+				}  // else multiple selection so don't eat line ends
+			} else {
+				sel.Range(r).ClearVirtualSpace();
+			}
 		}
 	} else {
 		ClearSelection();
 	}
-	SetEmptySelection(currentPos);
+	sel.RemoveDuplicates();
+	ShowCaretAtCurrentPosition();		// Avoid blinking
 }
 
 void Editor::SelectAll() {
+	sel.Clear();
 	SetSelection(0, pdoc->Length());
 	Redraw();
 }
@@ -3584,7 +2251,7 @@ void Editor::SelectAll() {
 void Editor::Undo() {
 	if (pdoc->CanUndo()) {
 		InvalidateCaret();
-		int newPos = pdoc->Undo();
+		const Sci::Position newPos = pdoc->Undo();
 		if (newPos >= 0)
 			SetEmptySelection(newPos);
 		EnsureCaretVisible();
@@ -3593,79 +2260,107 @@ void Editor::Undo() {
 
 void Editor::Redo() {
 	if (pdoc->CanRedo()) {
-		int newPos = pdoc->Redo();
+		const Sci::Position newPos = pdoc->Redo();
 		if (newPos >= 0)
 			SetEmptySelection(newPos);
 		EnsureCaretVisible();
 	}
 }
 
-void Editor::DelChar() {
-	if (!RangeContainsProtected(currentPos, currentPos + 1)) {
-		pdoc->DelChar(currentPos);
-	}
-	// Avoid blinking during rapid typing:
-	ShowCaretAtCurrentPosition();
-}
-
 void Editor::DelCharBack(bool allowLineStartDeletion) {
-	if (currentPos == anchor) {
-		if (!RangeContainsProtected(currentPos - 1, currentPos)) {
-			int lineCurrentPos = pdoc->LineFromPosition(currentPos);
-			if (allowLineStartDeletion || (pdoc->LineStart(lineCurrentPos) != currentPos)) {
-				if (pdoc->GetColumn(currentPos) <= pdoc->GetLineIndentation(lineCurrentPos) &&
-				        pdoc->GetColumn(currentPos) > 0 && pdoc->backspaceUnindents) {
-					pdoc->BeginUndoAction();
-					int indentation = pdoc->GetLineIndentation(lineCurrentPos);
-					int indentationStep = pdoc->IndentSize();
-					if (indentation % indentationStep == 0) {
-						pdoc->SetLineIndentation(lineCurrentPos, indentation - indentationStep);
-					} else {
-						pdoc->SetLineIndentation(lineCurrentPos, indentation - (indentation % indentationStep));
-					}
-					SetEmptySelection(pdoc->GetLineIndentPosition(lineCurrentPos));
-					pdoc->EndUndoAction();
+	RefreshStyleData();
+	if (!sel.IsRectangular())
+		FilterSelections();
+	if (sel.IsRectangular())
+		allowLineStartDeletion = false;
+	UndoGroup ug(pdoc, (sel.Count() > 1) || !sel.Empty());
+	if (sel.Empty()) {
+		for (size_t r=0; r<sel.Count(); r++) {
+			if (!RangeContainsProtected(sel.Range(r).caret.Position() - 1, sel.Range(r).caret.Position())) {
+				if (sel.Range(r).caret.VirtualSpace()) {
+					sel.Range(r).caret.SetVirtualSpace(sel.Range(r).caret.VirtualSpace() - 1);
+					sel.Range(r).anchor.SetVirtualSpace(sel.Range(r).caret.VirtualSpace());
 				} else {
-					pdoc->DelCharBack(currentPos);
+					const Sci::Line lineCurrentPos =
+						pdoc->SciLineFromPosition(sel.Range(r).caret.Position());
+					if (allowLineStartDeletion || (pdoc->LineStart(lineCurrentPos) != sel.Range(r).caret.Position())) {
+						if (pdoc->GetColumn(sel.Range(r).caret.Position()) <= pdoc->GetLineIndentation(lineCurrentPos) &&
+								pdoc->GetColumn(sel.Range(r).caret.Position()) > 0 && pdoc->backspaceUnindents) {
+							UndoGroup ugInner(pdoc, !ug.Needed());
+							const int indentation = pdoc->GetLineIndentation(lineCurrentPos);
+							const int indentationStep = pdoc->IndentSize();
+							int indentationChange = indentation % indentationStep;
+							if (indentationChange == 0)
+								indentationChange = indentationStep;
+							const Sci::Position posSelect = pdoc->SetLineIndentation(lineCurrentPos, indentation - indentationChange);
+							// SetEmptySelection
+							sel.Range(r) = SelectionRange(posSelect);
+						} else {
+							pdoc->DelCharBack(sel.Range(r).caret.Position());
+						}
+					}
 				}
+			} else {
+				sel.Range(r).ClearVirtualSpace();
 			}
 		}
+		ThinRectangularRange();
 	} else {
 		ClearSelection();
-		SetEmptySelection(currentPos);
 	}
+	sel.RemoveDuplicates();
+	ContainerNeedsUpdate(SC_UPDATE_SELECTION);
 	// Avoid blinking during rapid typing:
 	ShowCaretAtCurrentPosition();
 }
 
-void Editor::NotifyFocus(bool) {}
+int Editor::ModifierFlags(bool shift, bool ctrl, bool alt, bool meta, bool super) noexcept {
+	return
+		(shift ? SCI_SHIFT : 0) |
+		(ctrl ? SCI_CTRL : 0) |
+		(alt ? SCI_ALT : 0) |
+		(meta ? SCI_META : 0) |
+		(super ? SCI_SUPER : 0);
+}
 
-void Editor::NotifyStyleToNeeded(int endStyleNeeded) {
-	SCNotification scn = {0};
+void Editor::NotifyFocus(bool focus) {
+	SCNotification scn = {};
+	scn.nmhdr.code = focus ? SCN_FOCUSIN : SCN_FOCUSOUT;
+	NotifyParent(scn);
+}
+
+void Editor::SetCtrlID(int identifier) {
+	ctrlID = identifier;
+}
+
+void Editor::NotifyStyleToNeeded(Sci::Position endStyleNeeded) {
+	SCNotification scn = {};
 	scn.nmhdr.code = SCN_STYLENEEDED;
 	scn.position = endStyleNeeded;
 	NotifyParent(scn);
 }
 
-void Editor::NotifyStyleNeeded(Document*, void *, int endStyleNeeded) {
+void Editor::NotifyStyleNeeded(Document *, void *, Sci::Position endStyleNeeded) {
 	NotifyStyleToNeeded(endStyleNeeded);
 }
 
-void Editor::NotifyChar(int ch) {
-	SCNotification scn = {0};
+void Editor::NotifyLexerChanged(Document *, void *) {
+}
+
+void Editor::NotifyErrorOccurred(Document *, void *, int status) {
+	errorStatus = status;
+}
+
+void Editor::NotifyChar(int ch, CharacterSource charSource) {
+	SCNotification scn = {};
 	scn.nmhdr.code = SCN_CHARADDED;
 	scn.ch = ch;
+	scn.characterSource = static_cast<int>(charSource);
 	NotifyParent(scn);
-	if (recordingMacro) {
-		char txt[2];
-		txt[0] = static_cast<char>(ch);
-		txt[1] = '\0';
-		NotifyMacroRecord(SCI_REPLACESEL, 0, reinterpret_cast<sptr_t>(txt));
-	}
 }
 
 void Editor::NotifySavePoint(bool isSavePoint) {
-	SCNotification scn = {0};
+	SCNotification scn = {};
 	if (isSavePoint) {
 		scn.nmhdr.code = SCN_SAVEPOINTREACHED;
 	} else {
@@ -3675,78 +2370,121 @@ void Editor::NotifySavePoint(bool isSavePoint) {
 }
 
 void Editor::NotifyModifyAttempt() {
-	SCNotification scn = {0};
+	SCNotification scn = {};
 	scn.nmhdr.code = SCN_MODIFYATTEMPTRO;
 	NotifyParent(scn);
 }
 
-void Editor::NotifyDoubleClick(Point pt, bool shift, bool ctrl, bool alt) {
-	SCNotification scn = {0};
+void Editor::NotifyDoubleClick(Point pt, int modifiers) {
+	SCNotification scn = {};
 	scn.nmhdr.code = SCN_DOUBLECLICK;
 	scn.line = LineFromLocation(pt);
-	scn.position = PositionFromLocationClose(pt);
-	scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) |
-	        (alt ? SCI_ALT : 0);
+	scn.position = PositionFromLocation(pt, true);
+	scn.modifiers = modifiers;
 	NotifyParent(scn);
 }
 
-void Editor::NotifyHotSpotDoubleClicked(int position, bool shift, bool ctrl, bool alt) {
-	SCNotification scn = {0};
+void Editor::NotifyHotSpotDoubleClicked(Sci::Position position, int modifiers) {
+	SCNotification scn = {};
 	scn.nmhdr.code = SCN_HOTSPOTDOUBLECLICK;
 	scn.position = position;
-	scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) |
-	        (alt ? SCI_ALT : 0);
+	scn.modifiers = modifiers;
 	NotifyParent(scn);
 }
 
-void Editor::NotifyHotSpotClicked(int position, bool shift, bool ctrl, bool alt) {
-	SCNotification scn = {0};
+void Editor::NotifyHotSpotClicked(Sci::Position position, int modifiers) {
+	SCNotification scn = {};
 	scn.nmhdr.code = SCN_HOTSPOTCLICK;
 	scn.position = position;
-	scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) |
-	        (alt ? SCI_ALT : 0);
+	scn.modifiers = modifiers;
 	NotifyParent(scn);
 }
 
-void Editor::NotifyUpdateUI() {
-	SCNotification scn = {0};
-	scn.nmhdr.code = SCN_UPDATEUI;
+void Editor::NotifyHotSpotReleaseClick(Sci::Position position, int modifiers) {
+	SCNotification scn = {};
+	scn.nmhdr.code = SCN_HOTSPOTRELEASECLICK;
+	scn.position = position;
+	scn.modifiers = modifiers;
 	NotifyParent(scn);
 }
 
+bool Editor::NotifyUpdateUI() {
+	if (needUpdateUI) {
+		SCNotification scn = {};
+		scn.nmhdr.code = SCN_UPDATEUI;
+		scn.updated = needUpdateUI;
+		NotifyParent(scn);
+		needUpdateUI = 0;
+		return true;
+	}
+	return false;
+}
+
 void Editor::NotifyPainted() {
-	SCNotification scn = {0};
+	SCNotification scn = {};
 	scn.nmhdr.code = SCN_PAINTED;
 	NotifyParent(scn);
 }
 
-void Editor::NotifyIndicatorClick(bool click, int position, bool shift, bool ctrl, bool alt) {
-	int mask = pdoc->decorations.AllOnFor(position);
-	if ((click && mask) || pdoc->decorations.clickNotified) {
-		SCNotification scn = {0};
-		pdoc->decorations.clickNotified = click;
+void Editor::NotifyIndicatorClick(bool click, Sci::Position position, int modifiers) {
+	const int mask = pdoc->decorations->AllOnFor(position);
+	if ((click && mask) || pdoc->decorations->ClickNotified()) {
+		SCNotification scn = {};
+		pdoc->decorations->SetClickNotified(click);
 		scn.nmhdr.code = click ? SCN_INDICATORCLICK : SCN_INDICATORRELEASE;
-		scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) | (alt ? SCI_ALT : 0);
+		scn.modifiers = modifiers;
 		scn.position = position;
 		NotifyParent(scn);
 	}
 }
 
-bool Editor::NotifyMarginClick(Point pt, bool shift, bool ctrl, bool alt) {
-	int marginClicked = -1;
-	int x = 0;
-	for (int margin = 0; margin < ViewStyle::margins; margin++) {
-		if ((pt.x > x) && (pt.x < x + vs.ms[margin].width))
-			marginClicked = margin;
-		x += vs.ms[margin].width;
-	}
-	if ((marginClicked >= 0) && vs.ms[marginClicked].sensitive) {
-		SCNotification scn = {0};
-		scn.nmhdr.code = SCN_MARGINCLICK;
-		scn.modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) |
-		        (alt ? SCI_ALT : 0);
-		scn.position = pdoc->LineStart(LineFromLocation(pt));
-		scn.margin = marginClicked;
+bool Editor::NotifyMarginClick(Point pt, int modifiers) {
+	const int marginClicked = vs.MarginFromLocation(pt);
+	if ((marginClicked >= 0) && vs.ms[marginClicked].sensitive) {
+		const Sci::Position position = pdoc->LineStart(LineFromLocation(pt));
+		if ((vs.ms[marginClicked].mask & SC_MASK_FOLDERS) && (foldAutomatic & SC_AUTOMATICFOLD_CLICK)) {
+			const bool ctrl = (modifiers & SCI_CTRL) != 0;
+			const bool shift = (modifiers & SCI_SHIFT) != 0;
+			const Sci::Line lineClick = pdoc->SciLineFromPosition(position);
+			if (shift && ctrl) {
+				FoldAll(SC_FOLDACTION_TOGGLE);
+			} else {
+				const int levelClick = pdoc->GetLevel(lineClick);
+				if (levelClick & SC_FOLDLEVELHEADERFLAG) {
+					if (shift) {
+						// Ensure all children visible
+						FoldExpand(lineClick, SC_FOLDACTION_EXPAND, levelClick);
+					} else if (ctrl) {
+						FoldExpand(lineClick, SC_FOLDACTION_TOGGLE, levelClick);
+					} else {
+						// Toggle this line
+						FoldLine(lineClick, SC_FOLDACTION_TOGGLE);
+					}
+				}
+			}
+			return true;
+		}
+		SCNotification scn = {};
+		scn.nmhdr.code = SCN_MARGINCLICK;
+		scn.modifiers = modifiers;
+		scn.position = position;
+		scn.margin = marginClicked;
+		NotifyParent(scn);
+		return true;
+	} else {
+		return false;
+	}
+}
+
+bool Editor::NotifyMarginRightClick(Point pt, int modifiers) {
+	const int marginRightClicked = vs.MarginFromLocation(pt);
+	if ((marginRightClicked >= 0) && vs.ms[marginRightClicked].sensitive) {
+		const Sci::Position position = pdoc->LineStart(LineFromLocation(pt));
+		SCNotification scn = {};
+		scn.nmhdr.code = SCN_MARGINRIGHTCLICK;
+		scn.modifiers = modifiers;
+		scn.position = position;
+		scn.margin = marginRightClicked;
 		NotifyParent(scn);
 		return true;
 	} else {
@@ -3754,8 +2492,8 @@ bool Editor::NotifyMarginClick(Point pt, bool shift, bool ctrl, bool alt) {
 	}
 }
 
-void Editor::NotifyNeedShown(int pos, int len) {
-	SCNotification scn = {0};
+void Editor::NotifyNeedShown(Sci::Position pos, Sci::Position len) {
+	SCNotification scn = {};
 	scn.nmhdr.code = SCN_NEEDSHOWN;
 	scn.position = pos;
 	scn.length = len;
@@ -3763,51 +2501,49 @@ void Editor::NotifyNeedShown(int pos, int len) {
 }
 
 void Editor::NotifyDwelling(Point pt, bool state) {
-	SCNotification scn = {0};
+	SCNotification scn = {};
 	scn.nmhdr.code = state ? SCN_DWELLSTART : SCN_DWELLEND;
-	scn.position = PositionFromLocationClose(pt);
-	scn.x = pt.x;
-	scn.y = pt.y;
+	scn.position = PositionFromLocation(pt, true);
+	scn.x = static_cast<int>(pt.x + vs.ExternalMarginWidth());
+	scn.y = static_cast<int>(pt.y);
 	NotifyParent(scn);
 }
 
 void Editor::NotifyZoom() {
-	SCNotification scn = {0};
+	SCNotification scn = {};
 	scn.nmhdr.code = SCN_ZOOM;
 	NotifyParent(scn);
 }
 
 // Notifications from document
-void Editor::NotifyModifyAttempt(Document*, void *) {
+void Editor::NotifyModifyAttempt(Document *, void *) {
 	//Platform::DebugPrintf("** Modify Attempt\n");
 	NotifyModifyAttempt();
 }
 
-void Editor::NotifyMove(int position) {
-	SCNotification scn = {0};
-	scn.nmhdr.code = SCN_POSCHANGED;
-	scn.position = position;
-	NotifyParent(scn);
-}
-
-void Editor::NotifySavePoint(Document*, void *, bool atSavePoint) {
+void Editor::NotifySavePoint(Document *, void *, bool atSavePoint) {
 	//Platform::DebugPrintf("** Save Point %s\n", atSavePoint ? "On" : "Off");
 	NotifySavePoint(atSavePoint);
 }
 
 void Editor::CheckModificationForWrap(DocModification mh) {
 	if (mh.modificationType & (SC_MOD_INSERTTEXT | SC_MOD_DELETETEXT)) {
-		llc.Invalidate(LineLayout::llCheckTextAndStyle);
-		if (wrapState != eWrapNone) {
-			int lineDoc = pdoc->LineFromPosition(mh.position);
-			int lines = Platform::Maximum(0, mh.linesAdded);
+		view.llc.Invalidate(LineLayout::ValidLevel::checkTextAndStyle);
+		const Sci::Line lineDoc = pdoc->SciLineFromPosition(mh.position);
+		const Sci::Line lines = std::max(static_cast<Sci::Line>(0), mh.linesAdded);
+		if (Wrapping()) {
 			NeedWrapping(lineDoc, lineDoc + lines + 1);
 		}
+		RefreshStyleData();
+		// Fix up annotation heights
+		SetAnnotationHeights(lineDoc, lineDoc + lines + 2);
 	}
 }
 
+namespace {
+
 // Move a position so it is still after the same character as before the insertion.
-static inline int MovePositionForInsertion(int position, int startInsertion, int length) {
+constexpr Sci::Position MovePositionForInsertion(Sci::Position position, Sci::Position startInsertion, Sci::Position length) noexcept {
 	if (position > startInsertion) {
 		return position + length;
 	}
@@ -3816,9 +2552,9 @@ static inline int MovePositionForInsertion(int position, int startInsertion, int
 
 // Move a position so it is still after the same character as before the deletion if that
 // character is still present else after the previous surviving character.
-static inline int MovePositionForDeletion(int position, int startDeletion, int length) {
+constexpr Sci::Position MovePositionForDeletion(Sci::Position position, Sci::Position startDeletion, Sci::Position length) noexcept {
 	if (position > startDeletion) {
-		int endDeletion = startDeletion + length;
+		const Sci::Position endDeletion = startDeletion + length;
 		if (position > endDeletion) {
 			return position - length;
 		} else {
@@ -3829,26 +2565,41 @@ static inline int MovePositionForDeletion(int position, int startDeletion, int l
 	}
 }
 
-void Editor::NotifyModified(Document*, DocModification mh, void *) {
-	needUpdateUI = true;
+}
+
+void Editor::NotifyModified(Document *, DocModification mh, void *) {
+	ContainerNeedsUpdate(SC_UPDATE_CONTENT);
 	if (paintState == painting) {
 		CheckForChangeOutsidePaint(Range(mh.position, mh.position + mh.length));
 	}
 	if (mh.modificationType & SC_MOD_CHANGELINESTATE) {
 		if (paintState == painting) {
 			CheckForChangeOutsidePaint(
-			    Range(pdoc->LineStart(mh.line), pdoc->LineStart(mh.line + 1)));
+			    Range(pdoc->LineStart(mh.line),
+					pdoc->LineStart(mh.line + 1)));
 		} else {
 			// Could check that change is before last visible line.
 			Redraw();
 		}
 	}
+	if (mh.modificationType & SC_MOD_CHANGETABSTOPS) {
+		Redraw();
+	}
+	if (mh.modificationType & SC_MOD_LEXERSTATE) {
+		if (paintState == painting) {
+			CheckForChangeOutsidePaint(
+			    Range(mh.position, mh.position + mh.length));
+		} else {
+			Redraw();
+		}
+	}
 	if (mh.modificationType & (SC_MOD_CHANGESTYLE | SC_MOD_CHANGEINDICATOR)) {
 		if (mh.modificationType & SC_MOD_CHANGESTYLE) {
 			pdoc->IncrementStyleClock();
 		}
 		if (paintState == notPainting) {
-			if (mh.position < pdoc->LineStart(topLine)) {
+			const Sci::Line lineDocTop = pcs->DocFromDisplay(topLine);
+			if (mh.position < pdoc->LineStart(lineDocTop)) {
 				// Styling performed before this view
 				Redraw();
 			} else {
@@ -3856,61 +2607,89 @@ void Editor::NotifyModified(Document*, DocModification mh, void *) {
 			}
 		}
 		if (mh.modificationType & SC_MOD_CHANGESTYLE) {
-			llc.Invalidate(LineLayout::llCheckTextAndStyle);
+			view.llc.Invalidate(LineLayout::ValidLevel::checkTextAndStyle);
 		}
 	} else {
 		// Move selection and brace highlights
 		if (mh.modificationType & SC_MOD_INSERTTEXT) {
-			currentPos = MovePositionForInsertion(currentPos, mh.position, mh.length);
-			anchor = MovePositionForInsertion(anchor, mh.position, mh.length);
+			sel.MovePositions(true, mh.position, mh.length);
 			braces[0] = MovePositionForInsertion(braces[0], mh.position, mh.length);
 			braces[1] = MovePositionForInsertion(braces[1], mh.position, mh.length);
 		} else if (mh.modificationType & SC_MOD_DELETETEXT) {
-			currentPos = MovePositionForDeletion(currentPos, mh.position, mh.length);
-			anchor = MovePositionForDeletion(anchor, mh.position, mh.length);
+			sel.MovePositions(false, mh.position, mh.length);
 			braces[0] = MovePositionForDeletion(braces[0], mh.position, mh.length);
 			braces[1] = MovePositionForDeletion(braces[1], mh.position, mh.length);
 		}
-		if (cs.LinesDisplayed() < cs.LinesInDoc()) {
+		if ((mh.modificationType & (SC_MOD_BEFOREINSERT | SC_MOD_BEFOREDELETE)) && pcs->HiddenLines()) {
 			// Some lines are hidden so may need shown.
-			// TODO: check if the modified area is hidden.
+			const Sci::Line lineOfPos = pdoc->SciLineFromPosition(mh.position);
+			Sci::Position endNeedShown = mh.position;
 			if (mh.modificationType & SC_MOD_BEFOREINSERT) {
-				NotifyNeedShown(mh.position, 0);
+				if (pdoc->ContainsLineEnd(mh.text, mh.length) && (mh.position != pdoc->LineStart(lineOfPos)))
+					endNeedShown = pdoc->LineStart(lineOfPos+1);
 			} else if (mh.modificationType & SC_MOD_BEFOREDELETE) {
-				NotifyNeedShown(mh.position, mh.length);
+				// If the deletion includes any EOL then we extend the need shown area.
+				endNeedShown = mh.position + mh.length;
+				Sci::Line lineLast = pdoc->SciLineFromPosition(mh.position+mh.length);
+				for (Sci::Line line = lineOfPos + 1; line <= lineLast; line++) {
+					const Sci::Line lineMaxSubord = pdoc->GetLastChild(line, -1, -1);
+					if (lineLast < lineMaxSubord) {
+						lineLast = lineMaxSubord;
+						endNeedShown = pdoc->LineEnd(lineLast);
+					}
+				}
 			}
+			NeedShown(mh.position, endNeedShown - mh.position);
 		}
 		if (mh.linesAdded != 0) {
 			// Update contraction state for inserted and removed lines
 			// lineOfPos should be calculated in context of state before modification, shouldn't it
-			int lineOfPos = pdoc->LineFromPosition(mh.position);
+			Sci::Line lineOfPos = pdoc->SciLineFromPosition(mh.position);
+			if (mh.position > pdoc->LineStart(lineOfPos))
+				lineOfPos++;	// Affecting subsequent lines
 			if (mh.linesAdded > 0) {
-				cs.InsertLines(lineOfPos, mh.linesAdded);
+				pcs->InsertLines(lineOfPos, mh.linesAdded);
 			} else {
-				cs.DeleteLines(lineOfPos, -mh.linesAdded);
+				pcs->DeleteLines(lineOfPos, -mh.linesAdded);
+			}
+			view.LinesAddedOrRemoved(lineOfPos, mh.linesAdded);
+		}
+		if (mh.modificationType & SC_MOD_CHANGEANNOTATION) {
+			const Sci::Line lineDoc = pdoc->SciLineFromPosition(mh.position);
+			if (vs.annotationVisible) {
+				if (pcs->SetHeight(lineDoc, pcs->GetHeight(lineDoc) + static_cast<int>(mh.annotationLinesAdded))) {
+					SetScrollBars();
+				}
+				Redraw();
+			}
+		}
+		if (mh.modificationType & SC_MOD_CHANGEEOLANNOTATION) {
+			if (vs.eolAnnotationVisible) {
+				Redraw();
 			}
 		}
 		CheckModificationForWrap(mh);
 		if (mh.linesAdded != 0) {
 			// Avoid scrolling of display if change before current display
 			if (mh.position < posTopLine && !CanDeferToLastStep(mh)) {
-				int newTop = Platform::Clamp(topLine + mh.linesAdded, 0, MaxScrollPos());
+				const Sci::Line newTop = std::clamp<Sci::Line>(topLine + mh.linesAdded, 0, MaxScrollPos());
 				if (newTop != topLine) {
 					SetTopLine(newTop);
 					SetVerticalScrollPos();
 				}
 			}
 
-			//Platform::DebugPrintf("** %x Doc Changed\n", this);
-			// TODO: could invalidate from mh.startModification to end of screen
-			//InvalidateRange(mh.position, mh.position + mh.length);
 			if (paintState == notPainting && !CanDeferToLastStep(mh)) {
+				if (SynchronousStylingToVisible()) {
+					QueueIdleWork(WorkNeeded::workStyle, pdoc->Length());
+				}
 				Redraw();
 			}
 		} else {
-			//Platform::DebugPrintf("** %x Line Changed %d .. %d\n", this,
-			//	mh.position, mh.position + mh.length);
 			if (paintState == notPainting && mh.length && !CanEliminate(mh)) {
+				if (SynchronousStylingToVisible()) {
+					QueueIdleWork(WorkNeeded::workStyle, mh.position + mh.length);
+				}
 				InvalidateRange(mh.position, mh.position + mh.length);
 			}
 		}
@@ -3920,16 +2699,19 @@ void Editor::NotifyModified(Document*, DocModification mh, void *) {
 		SetScrollBars();
 	}
 
-	if (mh.modificationType & SC_MOD_CHANGEMARKER) {
-		if ((paintState == notPainting) || !PaintContainsMargin()) {
+	if ((mh.modificationType & SC_MOD_CHANGEMARKER) || (mh.modificationType & SC_MOD_CHANGEMARGIN)) {
+		if ((!willRedrawAll) && ((paintState == notPainting) || !PaintContainsMargin())) {
 			if (mh.modificationType & SC_MOD_CHANGEFOLD) {
 				// Fold changes can affect the drawing of following lines so redraw whole margin
-				RedrawSelMargin();
+				RedrawSelMargin(marginView.highlightDelimiter.isEnabled ? -1 : mh.line - 1, true);
 			} else {
 				RedrawSelMargin(mh.line);
 			}
 		}
 	}
+	if ((mh.modificationType & SC_MOD_CHANGEFOLD) && (foldAutomatic & SC_AUTOMATICFOLD_CHANGE)) {
+		FoldChanged(mh.line, mh.foldLevelNow, mh.foldLevelPrev);
+	}
 
 	// NOW pay the piper WRT "deferred" visual updates
 	if (IsLastStep(mh)) {
@@ -3939,12 +2721,14 @@ void Editor::NotifyModified(Document*, DocModification mh, void *) {
 
 	// If client wants to see this modification
 	if (mh.modificationType & modEventMask) {
-		if ((mh.modificationType & (SC_MOD_CHANGESTYLE | SC_MOD_CHANGEINDICATOR)) == 0) {
-			// Real modification made to text of document.
-			NotifyChange();	// Send EN_CHANGE
+		if (commandEvents) {
+			if ((mh.modificationType & (SC_MOD_CHANGESTYLE | SC_MOD_CHANGEINDICATOR)) == 0) {
+				// Real modification made to text of document.
+				NotifyChange();	// Send EN_CHANGE
+			}
 		}
 
-		SCNotification scn = {0};
+		SCNotification scn = {};
 		scn.nmhdr.code = SCN_MODIFIED;
 		scn.position = mh.position;
 		scn.modificationType = mh.modificationType;
@@ -3954,11 +2738,13 @@ void Editor::NotifyModified(Document*, DocModification mh, void *) {
 		scn.line = mh.line;
 		scn.foldLevelNow = mh.foldLevelNow;
 		scn.foldLevelPrev = mh.foldLevelPrev;
+		scn.token = static_cast<int>(mh.token);
+		scn.annotationLinesAdded = mh.annotationLinesAdded;
 		NotifyParent(scn);
 	}
 }
 
-void Editor::NotifyDeleted(Document *, void *) {
+void Editor::NotifyDeleted(Document *, void *) noexcept {
 	/* Do nothing */
 }
 
@@ -4035,6 +2821,8 @@ void Editor::NotifyMacroRecord(unsigned int iMessage, uptr_t wParam, sptr_t lPar
 	case SCI_VCHOMEEXTEND:
 	case SCI_VCHOMEWRAP:
 	case SCI_VCHOMEWRAPEXTEND:
+	case SCI_VCHOMEDISPLAY:
+	case SCI_VCHOMEDISPLAYEXTEND:
 	case SCI_DELWORDLEFT:
 	case SCI_DELWORDRIGHT:
 	case SCI_DELWORDRIGHTEND:
@@ -4044,6 +2832,7 @@ void Editor::NotifyMacroRecord(unsigned int iMessage, uptr_t wParam, sptr_t lPar
 	case SCI_LINECUT:
 	case SCI_LINEDELETE:
 	case SCI_LINETRANSPOSE:
+	case SCI_LINEREVERSE:
 	case SCI_LINEDUPLICATE:
 	case SCI_LOWERCASE:
 	case SCI_UPPERCASE:
@@ -4066,6 +2855,11 @@ void Editor::NotifyMacroRecord(unsigned int iMessage, uptr_t wParam, sptr_t lPar
 	case SCI_PAGEDOWNRECTEXTEND:
 	case SCI_SELECTIONDUPLICATE:
 	case SCI_COPYALLOWLINE:
+	case SCI_VERTICALCENTRECARET:
+	case SCI_MOVESELECTEDLINESUP:
+	case SCI_MOVESELECTEDLINESDOWN:
+	case SCI_SCROLLTOSTART:
+	case SCI_SCROLLTOEND:
 		break;
 
 		// Filter out all others like display changes. Also, newlines are redundant
@@ -4073,11 +2867,11 @@ void Editor::NotifyMacroRecord(unsigned int iMessage, uptr_t wParam, sptr_t lPar
 	case SCI_NEWLINE:
 	default:
 		//		printf("Filtered out %ld of macro recording\n", iMessage);
-		return ;
+		return;
 	}
 
 	// Send notification
-	SCNotification scn = {0};
+	SCNotification scn = {};
 	scn.nmhdr.code = SCN_MACRORECORD;
 	scn.message = iMessage;
 	scn.wParam = wParam;
@@ -4085,135 +2879,244 @@ void Editor::NotifyMacroRecord(unsigned int iMessage, uptr_t wParam, sptr_t lPar
 	NotifyParent(scn);
 }
 
+// Something has changed that the container should know about
+void Editor::ContainerNeedsUpdate(int flags) noexcept {
+	needUpdateUI |= flags;
+}
+
 /**
  * Force scroll and keep position relative to top of window.
  *
  * If stuttered = true and not already at first/last row, move to first/last row of window.
  * If stuttered = true and already at first/last row, scroll as normal.
  */
-void Editor::PageMove(int direction, selTypes sel, bool stuttered) {
-	int topLineNew, newPos;
+void Editor::PageMove(int direction, Selection::selTypes selt, bool stuttered) {
+	Sci::Line topLineNew;
+	SelectionPosition newPos;
 
-	// I consider only the caretYSlop, and ignore the caretYPolicy-- is that a problem?
-	int currentLine = pdoc->LineFromPosition(currentPos);
-	int topStutterLine = topLine + caretYSlop;
-	int bottomStutterLine =
-	    pdoc->LineFromPosition(PositionFromLocation(
-	                Point(lastXChosen, direction * vs.lineHeight * LinesToScroll())))
-	    - caretYSlop - 1;
+	const Sci::Line currentLine = pdoc->SciLineFromPosition(sel.MainCaret());
+	const Sci::Line topStutterLine = topLine + caretPolicies.y.slop;
+	const Sci::Line bottomStutterLine =
+	    pdoc->SciLineFromPosition(PositionFromLocation(
+	                Point::FromInts(lastXChosen - xOffset, direction * vs.lineHeight * static_cast<int>(LinesToScroll()))))
+	    - caretPolicies.y.slop - 1;
 
 	if (stuttered && (direction < 0 && currentLine > topStutterLine)) {
 		topLineNew = topLine;
-		newPos = PositionFromLocation(Point(lastXChosen, vs.lineHeight * caretYSlop));
+		newPos = SPositionFromLocation(Point::FromInts(lastXChosen - xOffset, vs.lineHeight * caretPolicies.y.slop),
+			false, false, UserVirtualSpace());
 
 	} else if (stuttered && (direction > 0 && currentLine < bottomStutterLine)) {
 		topLineNew = topLine;
-		newPos = PositionFromLocation(Point(lastXChosen, vs.lineHeight * (LinesToScroll() - caretYSlop)));
+		newPos = SPositionFromLocation(Point::FromInts(lastXChosen - xOffset, vs.lineHeight * static_cast<int>(LinesToScroll() - caretPolicies.y.slop)),
+			false, false, UserVirtualSpace());
 
 	} else {
-		Point pt = LocationFromPosition(currentPos);
+		const Point pt = LocationFromPosition(sel.MainCaret());
 
-		topLineNew = Platform::Clamp(
+		topLineNew = std::clamp<Sci::Line>(
 		            topLine + direction * LinesToScroll(), 0, MaxScrollPos());
-		newPos = PositionFromLocation(
-		            Point(lastXChosen, pt.y + direction * (vs.lineHeight * LinesToScroll())));
+		newPos = SPositionFromLocation(
+			Point::FromInts(lastXChosen - xOffset, static_cast<int>(pt.y) +
+				direction * (vs.lineHeight * static_cast<int>(LinesToScroll()))),
+			false, false, UserVirtualSpace());
 	}
 
 	if (topLineNew != topLine) {
 		SetTopLine(topLineNew);
-		MovePositionTo(newPos, sel);
+		MovePositionTo(newPos, selt);
 		Redraw();
 		SetVerticalScrollPos();
 	} else {
-		MovePositionTo(newPos, sel);
-	}
-}
-
-void Editor::ChangeCaseOfSelection(bool makeUpperCase) {
-	pdoc->BeginUndoAction();
-	int startCurrent = currentPos;
-	int startAnchor = anchor;
-	if (selType == selStream) {
-		pdoc->ChangeCase(Range(SelectionStart(), SelectionEnd()),
-		        makeUpperCase);
-		SetSelection(startCurrent, startAnchor);
-	} else {
-		SelectionLineIterator lineIterator(this, false);
-		while (lineIterator.Iterate()) {
-			pdoc->ChangeCase(
-			    Range(lineIterator.startPos, lineIterator.endPos),
-			    makeUpperCase);
+		MovePositionTo(newPos, selt);
+	}
+}
+
+void Editor::ChangeCaseOfSelection(int caseMapping) {
+	UndoGroup ug(pdoc);
+	for (size_t r=0; r<sel.Count(); r++) {
+		SelectionRange current = sel.Range(r);
+		SelectionRange currentNoVS = current;
+		currentNoVS.ClearVirtualSpace();
+		const size_t rangeBytes = currentNoVS.Length();
+		if (rangeBytes > 0) {
+			std::string sText = RangeText(currentNoVS.Start().Position(), currentNoVS.End().Position());
+
+			std::string sMapped = CaseMapString(sText, caseMapping);
+
+			if (sMapped != sText) {
+				size_t firstDifference = 0;
+				while (sMapped[firstDifference] == sText[firstDifference])
+					firstDifference++;
+				size_t lastDifferenceText = sText.size() - 1;
+				size_t lastDifferenceMapped = sMapped.size() - 1;
+				while (sMapped[lastDifferenceMapped] == sText[lastDifferenceText]) {
+					lastDifferenceText--;
+					lastDifferenceMapped--;
+				}
+				const size_t endDifferenceText = sText.size() - 1 - lastDifferenceText;
+				pdoc->DeleteChars(
+					currentNoVS.Start().Position() + firstDifference,
+					rangeBytes - firstDifference - endDifferenceText);
+				const Sci::Position lengthChange = lastDifferenceMapped - firstDifference + 1;
+				const Sci::Position lengthInserted = pdoc->InsertString(
+					currentNoVS.Start().Position() + firstDifference,
+					sMapped.c_str() + firstDifference,
+					lengthChange);
+				// Automatic movement changes selection so reset to exactly the same as it was.
+				const Sci::Position diffSizes = sMapped.size() - sText.size() + lengthInserted - lengthChange;
+				if (diffSizes != 0) {
+					if (current.anchor > current.caret)
+						current.anchor.Add(diffSizes);
+					else
+						current.caret.Add(diffSizes);
+				}
+				sel.Range(r) = current;
+			}
 		}
-		// Would be nicer to keep the rectangular selection but this is complex
-		SetEmptySelection(startCurrent);
 	}
-	pdoc->EndUndoAction();
 }
 
 void Editor::LineTranspose() {
-	int line = pdoc->LineFromPosition(currentPos);
+	const Sci::Line line = pdoc->SciLineFromPosition(sel.MainCaret());
 	if (line > 0) {
-		pdoc->BeginUndoAction();
-		int startPrev = pdoc->LineStart(line - 1);
-		int endPrev = pdoc->LineEnd(line - 1);
-		int start = pdoc->LineStart(line);
-		int end = pdoc->LineEnd(line);
-		char *line1 = CopyRange(startPrev, endPrev);
-		int len1 = endPrev - startPrev;
-		char *line2 = CopyRange(start, end);
-		int len2 = end - start;
-		pdoc->DeleteChars(start, len2);
-		pdoc->DeleteChars(startPrev, len1);
-		pdoc->InsertString(startPrev, line2, len2);
-		pdoc->InsertString(start - len1 + len2, line1, len1);
-		MovePositionTo(start - len1 + len2);
-		delete []line1;
-		delete []line2;
-		pdoc->EndUndoAction();
+		UndoGroup ug(pdoc);
+
+		const Sci::Position startPrevious = pdoc->LineStart(line - 1);
+		const std::string linePrevious = RangeText(startPrevious, pdoc->LineEnd(line - 1));
+
+		Sci::Position startCurrent = pdoc->LineStart(line);
+		const std::string lineCurrent = RangeText(startCurrent, pdoc->LineEnd(line));
+
+		pdoc->DeleteChars(startCurrent, lineCurrent.length());
+		pdoc->DeleteChars(startPrevious, linePrevious.length());
+		startCurrent -= linePrevious.length();
+
+		startCurrent += pdoc->InsertString(startPrevious, lineCurrent.c_str(),
+			lineCurrent.length());
+		pdoc->InsertString(startCurrent, linePrevious.c_str(),
+			linePrevious.length());
+		// Move caret to start of current line
+		MovePositionTo(SelectionPosition(startCurrent));
 	}
 }
 
+void Editor::LineReverse() {
+	const Sci::Line lineStart =
+		pdoc->SciLineFromPosition(sel.RangeMain().Start().Position());
+	const Sci::Line lineEnd =
+		pdoc->SciLineFromPosition(sel.RangeMain().End().Position()-1);
+	const Sci::Line lineDiff = lineEnd - lineStart;
+	if (lineDiff <= 0)
+		return;
+	UndoGroup ug(pdoc);
+	for (Sci::Line i=(lineDiff+1)/2-1; i>=0; --i) {
+		const Sci::Line lineNum2 = lineEnd - i;
+		const Sci::Line lineNum1 = lineStart + i;
+		Sci::Position lineStart2 = pdoc->LineStart(lineNum2);
+		const Sci::Position lineStart1 = pdoc->LineStart(lineNum1);
+		const std::string line2 = RangeText(lineStart2, pdoc->LineEnd(lineNum2));
+		const std::string line1 = RangeText(lineStart1, pdoc->LineEnd(lineNum1));
+		const Sci::Position lineLen2 = line2.length();
+		const Sci::Position lineLen1 = line1.length();
+		pdoc->DeleteChars(lineStart2, lineLen2);
+		pdoc->DeleteChars(lineStart1, lineLen1);
+		lineStart2 -= lineLen1;
+		pdoc->InsertString(lineStart2, line1.c_str(), lineLen1);
+		pdoc->InsertString(lineStart1, line2.c_str(), lineLen2);
+	}
+	// Wholly select all affected lines
+	sel.RangeMain() = SelectionRange(pdoc->LineStart(lineStart),
+		pdoc->LineStart(lineEnd+1));
+}
+
 void Editor::Duplicate(bool forLine) {
-	int start = SelectionStart();
-	int end = SelectionEnd();
-	if (start == end) {
+	if (sel.Empty()) {
 		forLine = true;
 	}
+	UndoGroup ug(pdoc);
+	const char *eol = "";
+	Sci::Position eolLen = 0;
 	if (forLine) {
-		int line = pdoc->LineFromPosition(currentPos);
-		start = pdoc->LineStart(line);
-		end = pdoc->LineEnd(line);
-	}
-	char *text = CopyRange(start, end);
-	if (forLine) {
-		const char *eol = StringFromEOLMode(pdoc->eolMode);
-		pdoc->InsertCString(end, eol);
-		pdoc->InsertString(end + istrlen(eol), text, end - start);
-	} else {
-		pdoc->InsertString(end, text, end - start);
+		eol = StringFromEOLMode(pdoc->eolMode);
+		eolLen = strlen(eol);
+	}
+	for (size_t r=0; r<sel.Count(); r++) {
+		SelectionPosition start = sel.Range(r).Start();
+		SelectionPosition end = sel.Range(r).End();
+		if (forLine) {
+			const Sci::Line line = pdoc->SciLineFromPosition(sel.Range(r).caret.Position());
+			start = SelectionPosition(pdoc->LineStart(line));
+			end = SelectionPosition(pdoc->LineEnd(line));
+		}
+		std::string text = RangeText(start.Position(), end.Position());
+		Sci::Position lengthInserted = eolLen;
+		if (forLine)
+			lengthInserted = pdoc->InsertString(end.Position(), eol, eolLen);
+		pdoc->InsertString(end.Position() + lengthInserted, text.c_str(), text.length());
+	}
+	if (sel.Count() && sel.IsRectangular()) {
+		SelectionPosition last = sel.Last();
+		if (forLine) {
+			const Sci::Line line = pdoc->SciLineFromPosition(last.Position());
+			last = SelectionPosition(last.Position() +
+				pdoc->LineStart(line+1) - pdoc->LineStart(line));
+		}
+		if (sel.Rectangular().anchor > sel.Rectangular().caret)
+			sel.Rectangular().anchor = last;
+		else
+			sel.Rectangular().caret = last;
+		SetRectangularRange();
 	}
-	delete []text;
 }
 
 void Editor::CancelModes() {
-	moveExtendsSelection = false;
+	sel.SetMoveExtends(false);
 }
 
 void Editor::NewLine() {
-	ClearSelection();
-	const char *eol = "\n";
-	if (pdoc->eolMode == SC_EOL_CRLF) {
-		eol = "\r\n";
-	} else if (pdoc->eolMode == SC_EOL_CR) {
-		eol = "\r";
-	} // else SC_EOL_LF -> "\n" already set
-	if (pdoc->InsertCString(currentPos, eol)) {
-		SetEmptySelection(currentPos + istrlen(eol));
+	InvalidateWholeSelection();
+	if (sel.IsRectangular() || !additionalSelectionTyping) {
+		// Remove non-main ranges
+		sel.DropAdditionalRanges();
+	}
+
+	UndoGroup ug(pdoc, !sel.Empty() || (sel.Count() > 1));
+
+	// Clear each range
+	if (!sel.Empty()) {
+		ClearSelection();
+	}
+
+	// Insert each line end
+	size_t countInsertions = 0;
+	for (size_t r = 0; r < sel.Count(); r++) {
+		sel.Range(r).ClearVirtualSpace();
+		const char *eol = StringFromEOLMode(pdoc->eolMode);
+		const Sci::Position positionInsert = sel.Range(r).caret.Position();
+		const Sci::Position insertLength = pdoc->InsertString(positionInsert, eol, strlen(eol));
+		if (insertLength > 0) {
+			sel.Range(r) = SelectionRange(positionInsert + insertLength);
+			countInsertions++;
+		}
+	}
+
+	// Perform notifications after all the changes as the application may change the
+	// selections in response to the characters.
+	for (size_t i = 0; i < countInsertions; i++) {
+		const char *eol = StringFromEOLMode(pdoc->eolMode);
 		while (*eol) {
-			NotifyChar(*eol);
+			NotifyChar(*eol, CharacterSource::directInput);
+			if (recordingMacro) {
+				char txt[2];
+				txt[0] = *eol;
+				txt[1] = '\0';
+				NotifyMacroRecord(SCI_REPLACESEL, 0, reinterpret_cast<sptr_t>(txt));
+			}
 			eol++;
 		}
 	}
+
 	SetLastXChosen();
 	SetScrollBars();
 	EnsureCaretVisible();
@@ -4221,244 +3124,663 @@ void Editor::NewLine() {
 	ShowCaretAtCurrentPosition();
 }
 
-void Editor::CursorUpOrDown(int direction, selTypes sel) {
-	Point pt = LocationFromPosition(currentPos);
-	int posNew = PositionFromLocation(
-	            Point(lastXChosen, pt.y + direction * vs.lineHeight));
+SelectionPosition Editor::PositionUpOrDown(SelectionPosition spStart, int direction, int lastX) {
+	const Point pt = LocationFromPosition(spStart);
+	int skipLines = 0;
+
+	if (vs.annotationVisible) {
+		const Sci::Line lineDoc = pdoc->SciLineFromPosition(spStart.Position());
+		const Point ptStartLine = LocationFromPosition(pdoc->LineStart(lineDoc));
+		const int subLine = static_cast<int>(pt.y - ptStartLine.y) / vs.lineHeight;
+
+		if (direction < 0 && subLine == 0) {
+			const Sci::Line lineDisplay = pcs->DisplayFromDoc(lineDoc);
+			if (lineDisplay > 0) {
+				skipLines = pdoc->AnnotationLines(pcs->DocFromDisplay(lineDisplay - 1));
+			}
+		} else if (direction > 0 && subLine >= (pcs->GetHeight(lineDoc) - 1 - pdoc->AnnotationLines(lineDoc))) {
+			skipLines = pdoc->AnnotationLines(lineDoc);
+		}
+	}
+
+	const Sci::Line newY = static_cast<Sci::Line>(pt.y) + (1 + skipLines) * direction * vs.lineHeight;
+	if (lastX < 0) {
+		lastX = static_cast<int>(pt.x) + xOffset;
+	}
+	SelectionPosition posNew = SPositionFromLocation(
+		Point::FromInts(lastX - xOffset, static_cast<int>(newY)), false, false, UserVirtualSpace());
+
 	if (direction < 0) {
 		// Line wrapping may lead to a location on the same line, so
 		// seek back if that is the case.
+		Point ptNew = LocationFromPosition(posNew.Position());
+		while ((posNew.Position() > 0) && (pt.y == ptNew.y)) {
+			posNew.Add(-1);
+			posNew.SetVirtualSpace(0);
+			ptNew = LocationFromPosition(posNew.Position());
+		}
+	} else if (direction > 0 && posNew.Position() != pdoc->Length()) {
 		// There is an equivalent case when moving down which skips
-		// over a line but as that does not trap the user it is fine.
-		Point ptNew = LocationFromPosition(posNew);
-		while ((posNew > 0) && (pt.y == ptNew.y)) {
-			posNew--;
-			ptNew = LocationFromPosition(posNew);
+		// over a line.
+		Point ptNew = LocationFromPosition(posNew.Position());
+		while ((posNew.Position() > spStart.Position()) && (ptNew.y > newY)) {
+			posNew.Add(-1);
+			posNew.SetVirtualSpace(0);
+			ptNew = LocationFromPosition(posNew.Position());
+		}
+	}
+	return posNew;
+}
+
+void Editor::CursorUpOrDown(int direction, Selection::selTypes selt) {
+	if ((selt == Selection::noSel) && sel.MoveExtends()) {
+		selt = !sel.IsRectangular() ? Selection::selStream : Selection::selRectangle;
+	}
+	SelectionPosition caretToUse = sel.Range(sel.Main()).caret;
+	if (sel.IsRectangular()) {
+		if (selt ==  Selection::noSel) {
+			caretToUse = (direction > 0) ? sel.Limits().end : sel.Limits().start;
+		} else {
+			caretToUse = sel.Rectangular().caret;
+		}
+	}
+	if (selt == Selection::selRectangle) {
+		const SelectionRange rangeBase = sel.IsRectangular() ? sel.Rectangular() : sel.RangeMain();
+		if (!sel.IsRectangular()) {
+			InvalidateWholeSelection();
+			sel.DropAdditionalRanges();
 		}
+		const SelectionPosition posNew = MovePositionSoVisible(
+			PositionUpOrDown(caretToUse, direction, lastXChosen), direction);
+		sel.selType = Selection::selRectangle;
+		sel.Rectangular() = SelectionRange(posNew, rangeBase.anchor);
+		SetRectangularRange();
+		MovedCaret(posNew, caretToUse, true, caretPolicies);
+	} else if (sel.selType == Selection::selLines && sel.MoveExtends()) {
+		// Calculate new caret position and call SetSelection(), which will ensure whole lines are selected.
+		const SelectionPosition posNew = MovePositionSoVisible(
+			PositionUpOrDown(caretToUse, direction, -1), direction);
+		SetSelection(posNew, sel.Range(sel.Main()).anchor);
+	} else {
+		InvalidateWholeSelection();
+		if (!additionalSelectionTyping || (sel.IsRectangular())) {
+			sel.DropAdditionalRanges();
+		}
+		sel.selType = Selection::selStream;
+		for (size_t r = 0; r < sel.Count(); r++) {
+			const int lastX = (r == sel.Main()) ? lastXChosen : -1;
+			const SelectionPosition spCaretNow = sel.Range(r).caret;
+			const SelectionPosition posNew = MovePositionSoVisible(
+				PositionUpOrDown(spCaretNow, direction, lastX), direction);
+			sel.Range(r) = selt == Selection::selStream ?
+				SelectionRange(posNew, sel.Range(r).anchor) : SelectionRange(posNew);
+		}
+		sel.RemoveDuplicates();
+		MovedCaret(sel.RangeMain().caret, caretToUse, true, caretPolicies);
 	}
-	MovePositionTo(posNew, sel);
 }
 
-void Editor::ParaUpOrDown(int direction, selTypes sel) {
-	int lineDoc, savedPos = currentPos;
+void Editor::ParaUpOrDown(int direction, Selection::selTypes selt) {
+	Sci::Line lineDoc;
+	const Sci::Position savedPos = sel.MainCaret();
 	do {
-		MovePositionTo(direction > 0 ? pdoc->ParaDown(currentPos) : pdoc->ParaUp(currentPos), sel);
-		lineDoc = pdoc->LineFromPosition(currentPos);
+		MovePositionTo(SelectionPosition(direction > 0 ? pdoc->ParaDown(sel.MainCaret()) : pdoc->ParaUp(sel.MainCaret())), selt);
+		lineDoc = pdoc->SciLineFromPosition(sel.MainCaret());
 		if (direction > 0) {
-			if (currentPos >= pdoc->Length() && !cs.GetVisible(lineDoc)) {
-				if (sel == noSel) {
-					MovePositionTo(pdoc->LineEndPosition(savedPos));
+			if (sel.MainCaret() >= pdoc->Length() && !pcs->GetVisible(lineDoc)) {
+				if (selt == Selection::noSel) {
+					MovePositionTo(SelectionPosition(pdoc->LineEndPosition(savedPos)));
 				}
 				break;
 			}
 		}
-	} while (!cs.GetVisible(lineDoc));
+	} while (!pcs->GetVisible(lineDoc));
 }
 
-int Editor::StartEndDisplayLine(int pos, bool start) {
+Range Editor::RangeDisplayLine(Sci::Line lineVisible) {
 	RefreshStyleData();
-	int line = pdoc->LineFromPosition(pos);
 	AutoSurface surface(this);
-	AutoLineLayout ll(llc, RetrieveLineLayout(line));
-	int posRet = INVALID_POSITION;
-	if (surface && ll) {
-		unsigned int posLineStart = pdoc->LineStart(line);
-		LayoutLine(line, surface, vs, ll, wrapWidth);
-		int posInLine = pos - posLineStart;
-		if (posInLine <= ll->maxLineLength) {
-			for (int subLine = 0; subLine < ll->lines; subLine++) {
-				if ((posInLine >= ll->LineStart(subLine)) && (posInLine <= ll->LineStart(subLine + 1))) {
-					if (start) {
-						posRet = ll->LineStart(subLine) + posLineStart;
-					} else {
-						if (subLine == ll->lines - 1)
-							posRet = ll->LineStart(subLine + 1) + posLineStart;
-						else
-							posRet = ll->LineStart(subLine + 1) + posLineStart - 1;
-					}
+	return view.RangeDisplayLine(surface, *this, lineVisible, vs);
+}
+
+Sci::Position Editor::StartEndDisplayLine(Sci::Position pos, bool start) {
+	RefreshStyleData();
+	AutoSurface surface(this);
+	const Sci::Position posRet = view.StartEndDisplayLine(surface, *this, pos, start, vs);
+	if (posRet == INVALID_POSITION) {
+		return pos;
+	} else {
+		return posRet;
+	}
+}
+
+namespace {
+
+constexpr short HighShortFromWParam(uptr_t x) {
+	return static_cast<short>(x >> 16);
+}
+
+constexpr short LowShortFromWParam(uptr_t x) {
+	return static_cast<short>(x & 0xffff);
+}
+
+constexpr unsigned int WithExtends(unsigned int iMessage) noexcept {
+	switch (iMessage) {
+	case SCI_CHARLEFT: return SCI_CHARLEFTEXTEND;
+	case SCI_CHARRIGHT: return SCI_CHARRIGHTEXTEND;
+
+	case SCI_WORDLEFT: return SCI_WORDLEFTEXTEND;
+	case SCI_WORDRIGHT: return SCI_WORDRIGHTEXTEND;
+	case SCI_WORDLEFTEND: return SCI_WORDLEFTENDEXTEND;
+	case SCI_WORDRIGHTEND: return SCI_WORDRIGHTENDEXTEND;
+	case SCI_WORDPARTLEFT: return SCI_WORDPARTLEFTEXTEND;
+	case SCI_WORDPARTRIGHT: return SCI_WORDPARTRIGHTEXTEND;
+
+	case SCI_HOME: return SCI_HOMEEXTEND;
+	case SCI_HOMEDISPLAY: return SCI_HOMEDISPLAYEXTEND;
+	case SCI_HOMEWRAP: return SCI_HOMEWRAPEXTEND;
+	case SCI_VCHOME: return SCI_VCHOMEEXTEND;
+	case SCI_VCHOMEDISPLAY: return SCI_VCHOMEDISPLAYEXTEND;
+	case SCI_VCHOMEWRAP: return SCI_VCHOMEWRAPEXTEND;
+
+	case SCI_LINEEND: return SCI_LINEENDEXTEND;
+	case SCI_LINEENDDISPLAY: return SCI_LINEENDDISPLAYEXTEND;
+	case SCI_LINEENDWRAP: return SCI_LINEENDWRAPEXTEND;
+
+	default:	return iMessage;
+	}
+}
+
+constexpr int NaturalDirection(unsigned int iMessage) noexcept {
+	switch (iMessage) {
+	case SCI_CHARLEFT:
+	case SCI_CHARLEFTEXTEND:
+	case SCI_CHARLEFTRECTEXTEND:
+	case SCI_WORDLEFT:
+	case SCI_WORDLEFTEXTEND:
+	case SCI_WORDLEFTEND:
+	case SCI_WORDLEFTENDEXTEND:
+	case SCI_WORDPARTLEFT:
+	case SCI_WORDPARTLEFTEXTEND:
+	case SCI_HOME:
+	case SCI_HOMEEXTEND:
+	case SCI_HOMEDISPLAY:
+	case SCI_HOMEDISPLAYEXTEND:
+	case SCI_HOMEWRAP:
+	case SCI_HOMEWRAPEXTEND:
+		// VC_HOME* mostly goes back
+	case SCI_VCHOME:
+	case SCI_VCHOMEEXTEND:
+	case SCI_VCHOMEDISPLAY:
+	case SCI_VCHOMEDISPLAYEXTEND:
+	case SCI_VCHOMEWRAP:
+	case SCI_VCHOMEWRAPEXTEND:
+		return -1;
+
+	default:
+		return 1;
+	}
+}
+
+constexpr bool IsRectExtend(unsigned int iMessage, bool isRectMoveExtends) noexcept {
+	switch (iMessage) {
+	case SCI_CHARLEFTRECTEXTEND:
+	case SCI_CHARRIGHTRECTEXTEND:
+	case SCI_HOMERECTEXTEND:
+	case SCI_VCHOMERECTEXTEND:
+	case SCI_LINEENDRECTEXTEND:
+		return true;
+	default:
+		if (isRectMoveExtends) {
+			// Handle SCI_SETSELECTIONMODE(SC_SEL_RECTANGLE) and subsequent movements.
+			switch (iMessage) {
+			case SCI_CHARLEFTEXTEND:
+			case SCI_CHARRIGHTEXTEND:
+			case SCI_HOMEEXTEND:
+			case SCI_VCHOMEEXTEND:
+			case SCI_LINEENDEXTEND:
+				return true;
+			default:
+				return false;
+			}
+		}
+		return false;
+	}
+}
+
+}
+
+Sci::Position Editor::VCHomeDisplayPosition(Sci::Position position) {
+	const Sci::Position homePos = pdoc->VCHomePosition(position);
+	const Sci::Position viewLineStart = StartEndDisplayLine(position, true);
+	if (viewLineStart > homePos)
+		return viewLineStart;
+	else
+		return homePos;
+}
+
+Sci::Position Editor::VCHomeWrapPosition(Sci::Position position) {
+	const Sci::Position homePos = pdoc->VCHomePosition(position);
+	const Sci::Position viewLineStart = StartEndDisplayLine(position, true);
+	if ((viewLineStart < position) && (viewLineStart > homePos))
+		return viewLineStart;
+	else
+		return homePos;
+}
+
+Sci::Position Editor::LineEndWrapPosition(Sci::Position position) {
+	const Sci::Position endPos = StartEndDisplayLine(position, false);
+	const Sci::Position realEndPos = pdoc->LineEndPosition(position);
+	if (endPos > realEndPos      // if moved past visible EOLs
+		|| position >= endPos) // if at end of display line already
+		return realEndPos;
+	else
+		return endPos;
+}
+
+int Editor::HorizontalMove(unsigned int iMessage) {
+	if (sel.selType == Selection::selLines) {
+		return 0; // horizontal moves with line selection have no effect
+	}
+	if (sel.MoveExtends()) {
+		iMessage = WithExtends(iMessage);
+	}
+
+	if (!multipleSelection && !sel.IsRectangular()) {
+		// Simplify selection down to 1
+		sel.SetSelection(sel.RangeMain());
+	}
+
+	// Invalidate each of the current selections
+	InvalidateWholeSelection();
+
+	if (IsRectExtend(iMessage, sel.IsRectangular() && sel.MoveExtends())) {
+		const SelectionRange rangeBase = sel.IsRectangular() ? sel.Rectangular() : sel.RangeMain();
+		if (!sel.IsRectangular()) {
+			sel.DropAdditionalRanges();
+		}
+		// Will change to rectangular if not currently rectangular
+		SelectionPosition spCaret = rangeBase.caret;
+		switch (iMessage) {
+		case SCI_CHARLEFTRECTEXTEND:
+		case SCI_CHARLEFTEXTEND: // only when sel.IsRectangular() && sel.MoveExtends()
+			if (pdoc->IsLineEndPosition(spCaret.Position()) && spCaret.VirtualSpace()) {
+				spCaret.SetVirtualSpace(spCaret.VirtualSpace() - 1);
+			} else if ((virtualSpaceOptions & SCVS_NOWRAPLINESTART) == 0 || pdoc->GetColumn(spCaret.Position()) > 0) {
+				spCaret = SelectionPosition(spCaret.Position() - 1);
+			}
+			break;
+		case SCI_CHARRIGHTRECTEXTEND:
+		case SCI_CHARRIGHTEXTEND: // only when sel.IsRectangular() && sel.MoveExtends()
+			if ((virtualSpaceOptions & SCVS_RECTANGULARSELECTION) && pdoc->IsLineEndPosition(sel.MainCaret())) {
+				spCaret.SetVirtualSpace(spCaret.VirtualSpace() + 1);
+			} else {
+				spCaret = SelectionPosition(spCaret.Position() + 1);
+			}
+			break;
+		case SCI_HOMERECTEXTEND:
+		case SCI_HOMEEXTEND: // only when sel.IsRectangular() && sel.MoveExtends()
+			spCaret = SelectionPosition(
+				pdoc->LineStart(pdoc->LineFromPosition(spCaret.Position())));
+			break;
+		case SCI_VCHOMERECTEXTEND:
+		case SCI_VCHOMEEXTEND: // only when sel.IsRectangular() && sel.MoveExtends()
+			spCaret = SelectionPosition(pdoc->VCHomePosition(spCaret.Position()));
+			break;
+		case SCI_LINEENDRECTEXTEND:
+		case SCI_LINEENDEXTEND: // only when sel.IsRectangular() && sel.MoveExtends()
+			spCaret = SelectionPosition(pdoc->LineEndPosition(spCaret.Position()));
+			break;
+		}
+		const int directionMove = (spCaret < rangeBase.caret) ? -1 : 1;
+		spCaret = MovePositionSoVisible(spCaret, directionMove);
+		sel.selType = Selection::selRectangle;
+		sel.Rectangular() = SelectionRange(spCaret, rangeBase.anchor);
+		SetRectangularRange();
+	} else if (sel.IsRectangular()) {
+		// Not a rectangular extension so switch to stream.
+		SelectionPosition selAtLimit = (NaturalDirection(iMessage) > 0) ? sel.Limits().end : sel.Limits().start;
+		switch (iMessage) {
+		case SCI_HOME:
+			selAtLimit = SelectionPosition(
+				pdoc->LineStart(pdoc->LineFromPosition(selAtLimit.Position())));
+			break;
+		case SCI_VCHOME:
+			selAtLimit = SelectionPosition(pdoc->VCHomePosition(selAtLimit.Position()));
+			break;
+		case SCI_LINEEND:
+			selAtLimit = SelectionPosition(pdoc->LineEndPosition(selAtLimit.Position()));
+			break;
+		}
+		sel.selType = Selection::selStream;
+		sel.SetSelection(SelectionRange(selAtLimit));
+	} else {
+		if (!additionalSelectionTyping) {
+			InvalidateWholeSelection();
+			sel.DropAdditionalRanges();
+		}
+		for (size_t r = 0; r < sel.Count(); r++) {
+			const SelectionPosition spCaretNow = sel.Range(r).caret;
+			SelectionPosition spCaret = spCaretNow;
+			switch (iMessage) {
+			case SCI_CHARLEFT:
+			case SCI_CHARLEFTEXTEND:
+				if (spCaret.VirtualSpace()) {
+					spCaret.SetVirtualSpace(spCaret.VirtualSpace() - 1);
+				} else if ((virtualSpaceOptions & SCVS_NOWRAPLINESTART) == 0 || pdoc->GetColumn(spCaret.Position()) > 0) {
+					spCaret = SelectionPosition(spCaret.Position() - 1);
+				}
+				break;
+			case SCI_CHARRIGHT:
+			case SCI_CHARRIGHTEXTEND:
+				if ((virtualSpaceOptions & SCVS_USERACCESSIBLE) && pdoc->IsLineEndPosition(spCaret.Position())) {
+					spCaret.SetVirtualSpace(spCaret.VirtualSpace() + 1);
+				} else {
+					spCaret = SelectionPosition(spCaret.Position() + 1);
+				}
+				break;
+			case SCI_WORDLEFT:
+			case SCI_WORDLEFTEXTEND:
+				spCaret = SelectionPosition(pdoc->NextWordStart(spCaret.Position(), -1));
+				break;
+			case SCI_WORDRIGHT:
+			case SCI_WORDRIGHTEXTEND:
+				spCaret = SelectionPosition(pdoc->NextWordStart(spCaret.Position(), 1));
+				break;
+			case SCI_WORDLEFTEND:
+			case SCI_WORDLEFTENDEXTEND:
+				spCaret = SelectionPosition(pdoc->NextWordEnd(spCaret.Position(), -1));
+				break;
+			case SCI_WORDRIGHTEND:
+			case SCI_WORDRIGHTENDEXTEND:
+				spCaret = SelectionPosition(pdoc->NextWordEnd(spCaret.Position(), 1));
+				break;
+			case SCI_WORDPARTLEFT:
+			case SCI_WORDPARTLEFTEXTEND:
+				spCaret = SelectionPosition(pdoc->WordPartLeft(spCaret.Position()));
+				break;
+			case SCI_WORDPARTRIGHT:
+			case SCI_WORDPARTRIGHTEXTEND:
+				spCaret = SelectionPosition(pdoc->WordPartRight(spCaret.Position()));
+				break;
+			case SCI_HOME:
+			case SCI_HOMEEXTEND:
+				spCaret = SelectionPosition(
+					pdoc->LineStart(pdoc->LineFromPosition(spCaret.Position())));
+				break;
+			case SCI_HOMEDISPLAY:
+			case SCI_HOMEDISPLAYEXTEND:
+				spCaret = SelectionPosition(StartEndDisplayLine(spCaret.Position(), true));
+				break;
+			case SCI_HOMEWRAP:
+			case SCI_HOMEWRAPEXTEND:
+				spCaret = MovePositionSoVisible(StartEndDisplayLine(spCaret.Position(), true), -1);
+				if (spCaretNow <= spCaret)
+					spCaret = SelectionPosition(
+						pdoc->LineStart(pdoc->LineFromPosition(spCaret.Position())));
+				break;
+			case SCI_VCHOME:
+			case SCI_VCHOMEEXTEND:
+				// VCHome alternates between beginning of line and beginning of text so may move back or forwards
+				spCaret = SelectionPosition(pdoc->VCHomePosition(spCaret.Position()));
+				break;
+			case SCI_VCHOMEDISPLAY:
+			case SCI_VCHOMEDISPLAYEXTEND:
+				spCaret = SelectionPosition(VCHomeDisplayPosition(spCaret.Position()));
+				break;
+			case SCI_VCHOMEWRAP:
+			case SCI_VCHOMEWRAPEXTEND:
+				spCaret = SelectionPosition(VCHomeWrapPosition(spCaret.Position()));
+				break;
+			case SCI_LINEEND:
+			case SCI_LINEENDEXTEND:
+				spCaret = SelectionPosition(pdoc->LineEndPosition(spCaret.Position()));
+				break;
+			case SCI_LINEENDDISPLAY:
+			case SCI_LINEENDDISPLAYEXTEND:
+				spCaret = SelectionPosition(StartEndDisplayLine(spCaret.Position(), false));
+				break;
+			case SCI_LINEENDWRAP:
+			case SCI_LINEENDWRAPEXTEND:
+				spCaret = SelectionPosition(LineEndWrapPosition(spCaret.Position()));
+				break;
+
+			default:
+				PLATFORM_ASSERT(false);
+			}
+
+			const int directionMove = (spCaret < spCaretNow) ? -1 : 1;
+			spCaret = MovePositionSoVisible(spCaret, directionMove);
+
+			// Handle move versus extend, and special behaviour for non-empty left/right
+			switch (iMessage) {
+			case SCI_CHARLEFT:
+			case SCI_CHARRIGHT:
+				if (sel.Range(r).Empty()) {
+					sel.Range(r) = SelectionRange(spCaret);
+				} else {
+					sel.Range(r) = SelectionRange(
+						(iMessage == SCI_CHARLEFT) ? sel.Range(r).Start() : sel.Range(r).End());
+				}
+				break;
+
+			case SCI_WORDLEFT:
+			case SCI_WORDRIGHT:
+			case SCI_WORDLEFTEND:
+			case SCI_WORDRIGHTEND:
+			case SCI_WORDPARTLEFT:
+			case SCI_WORDPARTRIGHT:
+			case SCI_HOME:
+			case SCI_HOMEDISPLAY:
+			case SCI_HOMEWRAP:
+			case SCI_VCHOME:
+			case SCI_VCHOMEDISPLAY:
+			case SCI_VCHOMEWRAP:
+			case SCI_LINEEND:
+			case SCI_LINEENDDISPLAY:
+			case SCI_LINEENDWRAP:
+				sel.Range(r) = SelectionRange(spCaret);
+				break;
+
+			case SCI_CHARLEFTEXTEND:
+			case SCI_CHARRIGHTEXTEND:
+			case SCI_WORDLEFTEXTEND:
+			case SCI_WORDRIGHTEXTEND:
+			case SCI_WORDLEFTENDEXTEND:
+			case SCI_WORDRIGHTENDEXTEND:
+			case SCI_WORDPARTLEFTEXTEND:
+			case SCI_WORDPARTRIGHTEXTEND:
+			case SCI_HOMEEXTEND:
+			case SCI_HOMEDISPLAYEXTEND:
+			case SCI_HOMEWRAPEXTEND:
+			case SCI_VCHOMEEXTEND:
+			case SCI_VCHOMEDISPLAYEXTEND:
+			case SCI_VCHOMEWRAPEXTEND:
+			case SCI_LINEENDEXTEND:
+			case SCI_LINEENDDISPLAYEXTEND:
+			case SCI_LINEENDWRAPEXTEND: {
+				SelectionRange rangeNew = SelectionRange(spCaret, sel.Range(r).anchor);
+				sel.TrimOtherSelections(r, SelectionRange(rangeNew));
+				sel.Range(r) = rangeNew;
 				}
+				break;
+
+			default:
+				PLATFORM_ASSERT(false);
 			}
 		}
 	}
-	if (posRet == INVALID_POSITION) {
-		return pos;
-	} else {
-		return posRet;
-	}
+
+	sel.RemoveDuplicates();
+
+	MovedCaret(sel.RangeMain().caret, SelectionPosition(INVALID_POSITION), true, caretPolicies);
+
+	// Invalidate the new state of the selection
+	InvalidateWholeSelection();
+
+	SetLastXChosen();
+	// Need the line moving and so forth from MovePositionTo
+	return 0;
+}
+
+int Editor::DelWordOrLine(unsigned int iMessage) {
+	// Virtual space may be realised for SCI_DELWORDRIGHT or SCI_DELWORDRIGHTEND
+	// which means 2 actions so wrap in an undo group.
+
+	// Rightwards and leftwards deletions differ in treatment of virtual space.
+	// Clear virtual space for leftwards, realise for rightwards.
+	const bool leftwards = (iMessage == SCI_DELWORDLEFT) || (iMessage == SCI_DELLINELEFT);
+
+	if (!additionalSelectionTyping) {
+		InvalidateWholeSelection();
+		sel.DropAdditionalRanges();
+	}
+
+	UndoGroup ug0(pdoc, (sel.Count() > 1) || !leftwards);
+
+	for (size_t r = 0; r < sel.Count(); r++) {
+		if (leftwards) {
+			// Delete to the left so first clear the virtual space.
+			sel.Range(r).ClearVirtualSpace();
+		} else {
+			// Delete to the right so first realise the virtual space.
+			sel.Range(r) = SelectionRange(
+				RealizeVirtualSpace(sel.Range(r).caret));
+		}
+
+		Range rangeDelete;
+		switch (iMessage) {
+		case SCI_DELWORDLEFT:
+			rangeDelete = Range(
+				pdoc->NextWordStart(sel.Range(r).caret.Position(), -1),
+				sel.Range(r).caret.Position());
+			break;
+		case SCI_DELWORDRIGHT:
+			rangeDelete = Range(
+				sel.Range(r).caret.Position(),
+				pdoc->NextWordStart(sel.Range(r).caret.Position(), 1));
+			break;
+		case SCI_DELWORDRIGHTEND:
+			rangeDelete = Range(
+				sel.Range(r).caret.Position(),
+				pdoc->NextWordEnd(sel.Range(r).caret.Position(), 1));
+			break;
+		case SCI_DELLINELEFT:
+			rangeDelete = Range(
+				pdoc->LineStart(pdoc->LineFromPosition(sel.Range(r).caret.Position())),
+				sel.Range(r).caret.Position());
+			break;
+		case SCI_DELLINERIGHT:
+			rangeDelete = Range(
+				sel.Range(r).caret.Position(),
+				pdoc->LineEnd(pdoc->LineFromPosition(sel.Range(r).caret.Position())));
+			break;
+		}
+		if (!RangeContainsProtected(rangeDelete.start, rangeDelete.end)) {
+			pdoc->DeleteChars(rangeDelete.start, rangeDelete.end - rangeDelete.start);
+		}
+	}
+
+	// May need something stronger here: can selections overlap at this point?
+	sel.RemoveDuplicates();
+
+	MovedCaret(sel.RangeMain().caret, SelectionPosition(INVALID_POSITION), true, caretPolicies);
+
+	// Invalidate the new state of the selection
+	InvalidateWholeSelection();
+
+	SetLastXChosen();
+	return 0;
 }
 
 int Editor::KeyCommand(unsigned int iMessage) {
 	switch (iMessage) {
 	case SCI_LINEDOWN:
-		CursorUpOrDown(1);
+		CursorUpOrDown(1, Selection::noSel);
 		break;
 	case SCI_LINEDOWNEXTEND:
-		CursorUpOrDown(1, selStream);
+		CursorUpOrDown(1, Selection::selStream);
 		break;
 	case SCI_LINEDOWNRECTEXTEND:
-		CursorUpOrDown(1, selRectangle);
+		CursorUpOrDown(1, Selection::selRectangle);
 		break;
 	case SCI_PARADOWN:
-		ParaUpOrDown(1);
+		ParaUpOrDown(1, Selection::noSel);
 		break;
 	case SCI_PARADOWNEXTEND:
-		ParaUpOrDown(1, selStream);
+		ParaUpOrDown(1, Selection::selStream);
 		break;
 	case SCI_LINESCROLLDOWN:
 		ScrollTo(topLine + 1);
 		MoveCaretInsideView(false);
 		break;
 	case SCI_LINEUP:
-		CursorUpOrDown(-1);
+		CursorUpOrDown(-1, Selection::noSel);
 		break;
 	case SCI_LINEUPEXTEND:
-		CursorUpOrDown(-1, selStream);
+		CursorUpOrDown(-1, Selection::selStream);
 		break;
 	case SCI_LINEUPRECTEXTEND:
-		CursorUpOrDown(-1, selRectangle);
+		CursorUpOrDown(-1, Selection::selRectangle);
 		break;
 	case SCI_PARAUP:
-		ParaUpOrDown(-1);
+		ParaUpOrDown(-1, Selection::noSel);
 		break;
 	case SCI_PARAUPEXTEND:
-		ParaUpOrDown(-1, selStream);
+		ParaUpOrDown(-1, Selection::selStream);
 		break;
 	case SCI_LINESCROLLUP:
 		ScrollTo(topLine - 1);
 		MoveCaretInsideView(false);
 		break;
+
 	case SCI_CHARLEFT:
-		if (SelectionEmpty() || moveExtendsSelection) {
-			MovePositionTo(MovePositionSoVisible(currentPos - 1, -1));
-		} else {
-			MovePositionTo(SelectionStart());
-		}
-		SetLastXChosen();
-		break;
 	case SCI_CHARLEFTEXTEND:
-		MovePositionTo(MovePositionSoVisible(currentPos - 1, -1), selStream);
-		SetLastXChosen();
-		break;
 	case SCI_CHARLEFTRECTEXTEND:
-		MovePositionTo(MovePositionSoVisible(currentPos - 1, -1), selRectangle);
-		SetLastXChosen();
-		break;
 	case SCI_CHARRIGHT:
-		if (SelectionEmpty() || moveExtendsSelection) {
-			MovePositionTo(MovePositionSoVisible(currentPos + 1, 1));
-		} else {
-			MovePositionTo(SelectionEnd());
-		}
-		SetLastXChosen();
-		break;
 	case SCI_CHARRIGHTEXTEND:
-		MovePositionTo(MovePositionSoVisible(currentPos + 1, 1), selStream);
-		SetLastXChosen();
-		break;
 	case SCI_CHARRIGHTRECTEXTEND:
-		MovePositionTo(MovePositionSoVisible(currentPos + 1, 1), selRectangle);
-		SetLastXChosen();
-		break;
 	case SCI_WORDLEFT:
-		MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(currentPos, -1), -1));
-		SetLastXChosen();
-		break;
 	case SCI_WORDLEFTEXTEND:
-		MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(currentPos, -1), -1), selStream);
-		SetLastXChosen();
-		break;
 	case SCI_WORDRIGHT:
-		MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(currentPos, 1), 1));
-		SetLastXChosen();
-		break;
 	case SCI_WORDRIGHTEXTEND:
-		MovePositionTo(MovePositionSoVisible(pdoc->NextWordStart(currentPos, 1), 1), selStream);
-		SetLastXChosen();
-		break;
-
 	case SCI_WORDLEFTEND:
-		MovePositionTo(MovePositionSoVisible(pdoc->NextWordEnd(currentPos, -1), -1));
-		SetLastXChosen();
-		break;
 	case SCI_WORDLEFTENDEXTEND:
-		MovePositionTo(MovePositionSoVisible(pdoc->NextWordEnd(currentPos, -1), -1), selStream);
-		SetLastXChosen();
-		break;
 	case SCI_WORDRIGHTEND:
-		MovePositionTo(MovePositionSoVisible(pdoc->NextWordEnd(currentPos, 1), 1));
-		SetLastXChosen();
-		break;
 	case SCI_WORDRIGHTENDEXTEND:
-		MovePositionTo(MovePositionSoVisible(pdoc->NextWordEnd(currentPos, 1), 1), selStream);
-		SetLastXChosen();
-		break;
-
+	case SCI_WORDPARTLEFT:
+	case SCI_WORDPARTLEFTEXTEND:
+	case SCI_WORDPARTRIGHT:
+	case SCI_WORDPARTRIGHTEXTEND:
 	case SCI_HOME:
-		MovePositionTo(pdoc->LineStart(pdoc->LineFromPosition(currentPos)));
-		SetLastXChosen();
-		break;
 	case SCI_HOMEEXTEND:
-		MovePositionTo(pdoc->LineStart(pdoc->LineFromPosition(currentPos)), selStream);
-		SetLastXChosen();
-		break;
 	case SCI_HOMERECTEXTEND:
-		MovePositionTo(pdoc->LineStart(pdoc->LineFromPosition(currentPos)), selRectangle);
-		SetLastXChosen();
-		break;
+	case SCI_HOMEDISPLAY:
+	case SCI_HOMEDISPLAYEXTEND:
+	case SCI_HOMEWRAP:
+	case SCI_HOMEWRAPEXTEND:
+	case SCI_VCHOME:
+	case SCI_VCHOMEEXTEND:
+	case SCI_VCHOMERECTEXTEND:
+	case SCI_VCHOMEDISPLAY:
+	case SCI_VCHOMEDISPLAYEXTEND:
+	case SCI_VCHOMEWRAP:
+	case SCI_VCHOMEWRAPEXTEND:
 	case SCI_LINEEND:
-		MovePositionTo(pdoc->LineEndPosition(currentPos));
-		SetLastXChosen();
-		break;
 	case SCI_LINEENDEXTEND:
-		MovePositionTo(pdoc->LineEndPosition(currentPos), selStream);
-		SetLastXChosen();
-		break;
 	case SCI_LINEENDRECTEXTEND:
-		MovePositionTo(pdoc->LineEndPosition(currentPos), selRectangle);
-		SetLastXChosen();
-		break;
-	case SCI_HOMEWRAP: {
-			int homePos = MovePositionSoVisible(StartEndDisplayLine(currentPos, true), -1);
-			if (currentPos <= homePos)
-				homePos = pdoc->LineStart(pdoc->LineFromPosition(currentPos));
-			MovePositionTo(homePos);
-			SetLastXChosen();
-		}
-		break;
-	case SCI_HOMEWRAPEXTEND: {
-			int homePos = MovePositionSoVisible(StartEndDisplayLine(currentPos, true), -1);
-			if (currentPos <= homePos)
-				homePos = pdoc->LineStart(pdoc->LineFromPosition(currentPos));
-			MovePositionTo(homePos, selStream);
-			SetLastXChosen();
-		}
-		break;
-	case SCI_LINEENDWRAP: {
-			int endPos = MovePositionSoVisible(StartEndDisplayLine(currentPos, false), 1);
-			int realEndPos = pdoc->LineEndPosition(currentPos);
-			if (endPos > realEndPos      // if moved past visible EOLs
-			        || currentPos >= endPos) // if at end of display line already
-				endPos = realEndPos;
-			MovePositionTo(endPos);
-			SetLastXChosen();
-		}
-		break;
-	case SCI_LINEENDWRAPEXTEND: {
-			int endPos = MovePositionSoVisible(StartEndDisplayLine(currentPos, false), 1);
-			int realEndPos = pdoc->LineEndPosition(currentPos);
-			if (endPos > realEndPos      // if moved past visible EOLs
-			        || currentPos >= endPos) // if at end of display line already
-				endPos = realEndPos;
-			MovePositionTo(endPos, selStream);
-			SetLastXChosen();
-		}
-		break;
+	case SCI_LINEENDDISPLAY:
+	case SCI_LINEENDDISPLAYEXTEND:
+	case SCI_LINEENDWRAP:
+	case SCI_LINEENDWRAPEXTEND:
+		return HorizontalMove(iMessage);
+
 	case SCI_DOCUMENTSTART:
 		MovePositionTo(0);
 		SetLastXChosen();
 		break;
 	case SCI_DOCUMENTSTARTEXTEND:
-		MovePositionTo(0, selStream);
+		MovePositionTo(0, Selection::selStream);
 		SetLastXChosen();
 		break;
 	case SCI_DOCUMENTEND:
@@ -4466,76 +3788,83 @@ int Editor::KeyCommand(unsigned int iMessage) {
 		SetLastXChosen();
 		break;
 	case SCI_DOCUMENTENDEXTEND:
-		MovePositionTo(pdoc->Length(), selStream);
+		MovePositionTo(pdoc->Length(), Selection::selStream);
 		SetLastXChosen();
 		break;
 	case SCI_STUTTEREDPAGEUP:
-		PageMove(-1, noSel, true);
+		PageMove(-1, Selection::noSel, true);
 		break;
 	case SCI_STUTTEREDPAGEUPEXTEND:
-		PageMove(-1, selStream, true);
+		PageMove(-1, Selection::selStream, true);
 		break;
 	case SCI_STUTTEREDPAGEDOWN:
-		PageMove(1, noSel, true);
+		PageMove(1, Selection::noSel, true);
 		break;
 	case SCI_STUTTEREDPAGEDOWNEXTEND:
-		PageMove(1, selStream, true);
+		PageMove(1, Selection::selStream, true);
 		break;
 	case SCI_PAGEUP:
 		PageMove(-1);
 		break;
 	case SCI_PAGEUPEXTEND:
-		PageMove(-1, selStream);
+		PageMove(-1, Selection::selStream);
 		break;
 	case SCI_PAGEUPRECTEXTEND:
-		PageMove(-1, selRectangle);
+		PageMove(-1, Selection::selRectangle);
 		break;
 	case SCI_PAGEDOWN:
 		PageMove(1);
 		break;
 	case SCI_PAGEDOWNEXTEND:
-		PageMove(1, selStream);
+		PageMove(1, Selection::selStream);
 		break;
 	case SCI_PAGEDOWNRECTEXTEND:
-		PageMove(1, selRectangle);
+		PageMove(1, Selection::selRectangle);
 		break;
 	case SCI_EDITTOGGLEOVERTYPE:
 		inOverstrike = !inOverstrike;
-		DropCaret();
+		ContainerNeedsUpdate(SC_UPDATE_SELECTION);
 		ShowCaretAtCurrentPosition();
-		NotifyUpdateUI();
+		SetIdle(true);
 		break;
 	case SCI_CANCEL:            	// Cancel any modes - handled in subclass
 		// Also unselect text
 		CancelModes();
+		if ((sel.Count() > 1) && !sel.IsRectangular()) {
+			// Drop additional selections
+			InvalidateWholeSelection();
+			sel.DropAdditionalRanges();
+		}
 		break;
 	case SCI_DELETEBACK:
 		DelCharBack(true);
-		if (!caretSticky) {
+		if ((caretSticky == SC_CARETSTICKY_OFF) || (caretSticky == SC_CARETSTICKY_WHITESPACE)) {
 			SetLastXChosen();
 		}
 		EnsureCaretVisible();
 		break;
 	case SCI_DELETEBACKNOTLINE:
 		DelCharBack(false);
-		if (!caretSticky) {
+		if ((caretSticky == SC_CARETSTICKY_OFF) || (caretSticky == SC_CARETSTICKY_WHITESPACE)) {
 			SetLastXChosen();
 		}
 		EnsureCaretVisible();
 		break;
 	case SCI_TAB:
 		Indent(true);
-		if (!caretSticky) {
+		if (caretSticky == SC_CARETSTICKY_OFF) {
 			SetLastXChosen();
 		}
 		EnsureCaretVisible();
+		ShowCaretAtCurrentPosition();		// Avoid blinking
 		break;
 	case SCI_BACKTAB:
 		Indent(false);
-		if (!caretSticky) {
+		if ((caretSticky == SC_CARETSTICKY_OFF) || (caretSticky == SC_CARETSTICKY_WHITESPACE)) {
 			SetLastXChosen();
 		}
 		EnsureCaretVisible();
+		ShowCaretAtCurrentPosition();		// Avoid blinking
 		break;
 	case SCI_NEWLINE:
 		NewLine();
@@ -4543,38 +3872,6 @@ int Editor::KeyCommand(unsigned int iMessage) {
 	case SCI_FORMFEED:
 		AddChar('\f');
 		break;
-	case SCI_VCHOME:
-		MovePositionTo(pdoc->VCHomePosition(currentPos));
-		SetLastXChosen();
-		break;
-	case SCI_VCHOMEEXTEND:
-		MovePositionTo(pdoc->VCHomePosition(currentPos), selStream);
-		SetLastXChosen();
-		break;
-	case SCI_VCHOMERECTEXTEND:
-		MovePositionTo(pdoc->VCHomePosition(currentPos), selRectangle);
-		SetLastXChosen();
-		break;
-	case SCI_VCHOMEWRAP: {
-			int homePos = pdoc->VCHomePosition(currentPos);
-			int viewLineStart = MovePositionSoVisible(StartEndDisplayLine(currentPos, true), -1);
-			if ((viewLineStart < currentPos) && (viewLineStart > homePos))
-				homePos = viewLineStart;
-
-			MovePositionTo(homePos);
-			SetLastXChosen();
-		}
-		break;
-	case SCI_VCHOMEWRAPEXTEND: {
-			int homePos = pdoc->VCHomePosition(currentPos);
-			int viewLineStart = MovePositionSoVisible(StartEndDisplayLine(currentPos, true), -1);
-			if ((viewLineStart < currentPos) && (viewLineStart > homePos))
-				homePos = viewLineStart;
-
-			MovePositionTo(homePos, selStream);
-			SetLastXChosen();
-		}
-		break;
 	case SCI_ZOOMIN:
 		if (vs.zoomLevel < 20) {
 			vs.zoomLevel++;
@@ -4589,62 +3886,44 @@ int Editor::KeyCommand(unsigned int iMessage) {
 			NotifyZoom();
 		}
 		break;
-	case SCI_DELWORDLEFT: {
-			int startWord = pdoc->NextWordStart(currentPos, -1);
-			pdoc->DeleteChars(startWord, currentPos - startWord);
-			SetLastXChosen();
-		}
-		break;
-	case SCI_DELWORDRIGHT: {
-			int endWord = pdoc->NextWordStart(currentPos, 1);
-			pdoc->DeleteChars(currentPos, endWord - currentPos);
-		}
-		break;
-	case SCI_DELWORDRIGHTEND: {
-			int endWord = pdoc->NextWordEnd(currentPos, 1);
-			pdoc->DeleteChars(currentPos, endWord - currentPos);
-		}
-		break;
-	case SCI_DELLINELEFT: {
-			int line = pdoc->LineFromPosition(currentPos);
-			int start = pdoc->LineStart(line);
-			pdoc->DeleteChars(start, currentPos - start);
-			SetLastXChosen();
-		}
-		break;
-	case SCI_DELLINERIGHT: {
-			int line = pdoc->LineFromPosition(currentPos);
-			int end = pdoc->LineEnd(line);
-			pdoc->DeleteChars(currentPos, end - currentPos);
-		}
-		break;
+
+	case SCI_DELWORDLEFT:
+	case SCI_DELWORDRIGHT:
+	case SCI_DELWORDRIGHTEND:
+	case SCI_DELLINELEFT:
+	case SCI_DELLINERIGHT:
+		return DelWordOrLine(iMessage);
+
 	case SCI_LINECOPY: {
-			int lineStart = pdoc->LineFromPosition(SelectionStart());
-			int lineEnd = pdoc->LineFromPosition(SelectionEnd());
+			const Sci::Line lineStart = pdoc->SciLineFromPosition(SelectionStart().Position());
+			const Sci::Line lineEnd = pdoc->SciLineFromPosition(SelectionEnd().Position());
 			CopyRangeToClipboard(pdoc->LineStart(lineStart),
-			        pdoc->LineStart(lineEnd + 1));
+				pdoc->LineStart(lineEnd + 1));
 		}
 		break;
 	case SCI_LINECUT: {
-			int lineStart = pdoc->LineFromPosition(SelectionStart());
-			int lineEnd = pdoc->LineFromPosition(SelectionEnd());
-			int start = pdoc->LineStart(lineStart);
-			int end = pdoc->LineStart(lineEnd + 1);
+			const Sci::Line lineStart = pdoc->SciLineFromPosition(SelectionStart().Position());
+			const Sci::Line lineEnd = pdoc->SciLineFromPosition(SelectionEnd().Position());
+			const Sci::Position start = pdoc->LineStart(lineStart);
+			const Sci::Position end = pdoc->LineStart(lineEnd + 1);
 			SetSelection(start, end);
 			Cut();
 			SetLastXChosen();
 		}
 		break;
 	case SCI_LINEDELETE: {
-			int line = pdoc->LineFromPosition(currentPos);
-			int start = pdoc->LineStart(line);
-			int end = pdoc->LineStart(line + 1);
+			const Sci::Line line = pdoc->SciLineFromPosition(sel.MainCaret());
+			const Sci::Position start = pdoc->LineStart(line);
+			const Sci::Position end = pdoc->LineStart(line + 1);
 			pdoc->DeleteChars(start, end - start);
 		}
 		break;
 	case SCI_LINETRANSPOSE:
 		LineTranspose();
 		break;
+	case SCI_LINEREVERSE:
+		LineReverse();
+		break;
 	case SCI_LINEDUPLICATE:
 		Duplicate(true);
 		break;
@@ -4652,46 +3931,16 @@ int Editor::KeyCommand(unsigned int iMessage) {
 		Duplicate(false);
 		break;
 	case SCI_LOWERCASE:
-		ChangeCaseOfSelection(false);
+		ChangeCaseOfSelection(cmLower);
 		break;
 	case SCI_UPPERCASE:
-		ChangeCaseOfSelection(true);
-		break;
-	case SCI_WORDPARTLEFT:
-		MovePositionTo(MovePositionSoVisible(pdoc->WordPartLeft(currentPos), -1));
-		SetLastXChosen();
-		break;
-	case SCI_WORDPARTLEFTEXTEND:
-		MovePositionTo(MovePositionSoVisible(pdoc->WordPartLeft(currentPos), -1), selStream);
-		SetLastXChosen();
-		break;
-	case SCI_WORDPARTRIGHT:
-		MovePositionTo(MovePositionSoVisible(pdoc->WordPartRight(currentPos), 1));
-		SetLastXChosen();
-		break;
-	case SCI_WORDPARTRIGHTEXTEND:
-		MovePositionTo(MovePositionSoVisible(pdoc->WordPartRight(currentPos), 1), selStream);
-		SetLastXChosen();
-		break;
-	case SCI_HOMEDISPLAY:
-		MovePositionTo(MovePositionSoVisible(
-		            StartEndDisplayLine(currentPos, true), -1));
-		SetLastXChosen();
+		ChangeCaseOfSelection(cmUpper);
 		break;
-	case SCI_HOMEDISPLAYEXTEND:
-		MovePositionTo(MovePositionSoVisible(
-		            StartEndDisplayLine(currentPos, true), -1), selStream);
-		SetLastXChosen();
-		break;
-	case SCI_LINEENDDISPLAY:
-		MovePositionTo(MovePositionSoVisible(
-		            StartEndDisplayLine(currentPos, false), 1));
-		SetLastXChosen();
+	case SCI_SCROLLTOSTART:
+		ScrollTo(0);
 		break;
-	case SCI_LINEENDDISPLAYEXTEND:
-		MovePositionTo(MovePositionSoVisible(
-		            StartEndDisplayLine(currentPos, false), 1), selStream);
-		SetLastXChosen();
+	case SCI_SCROLLTOEND:
+		ScrollTo(MaxScrollPos());
 		break;
 	}
 	return 0;
@@ -4701,15 +3950,13 @@ int Editor::KeyDefault(int, int) {
 	return 0;
 }
 
-int Editor::KeyDown(int key, bool shift, bool ctrl, bool alt, bool *consumed) {
+int Editor::KeyDownWithModifiers(int key, int modifiers, bool *consumed) {
 	DwellEnd(false);
-	int modifiers = (shift ? SCI_SHIFT : 0) | (ctrl ? SCI_CTRL : 0) |
-	        (alt ? SCI_ALT : 0);
-	int msg = kmap.Find(key, modifiers);
+	const int msg = kmap.Find(key, modifiers);
 	if (msg) {
 		if (consumed)
 			*consumed = true;
-		return WndProc(msg, 0, 0);
+		return static_cast<int>(WndProc(msg, 0, 0));
 	} else {
 		if (consumed)
 			*consumed = false;
@@ -4717,112 +3964,130 @@ int Editor::KeyDown(int key, bool shift, bool ctrl, bool alt, bool *consumed) {
 	}
 }
 
-void Editor::SetWhitespaceVisible(int view) {
-	vs.viewWhitespace = static_cast<WhiteSpaceVisibility>(view);
-}
-
-int Editor::GetWhitespaceVisible() {
-	return vs.viewWhitespace;
-}
-
 void Editor::Indent(bool forwards) {
-	//Platform::DebugPrintf("INdent %d\n", forwards);
-	int lineOfAnchor = pdoc->LineFromPosition(anchor);
-	int lineCurrentPos = pdoc->LineFromPosition(currentPos);
-	if (lineOfAnchor == lineCurrentPos) {
-		if (forwards) {
-			pdoc->BeginUndoAction();
-			ClearSelection();
-			if (pdoc->GetColumn(currentPos) <= pdoc->GetColumn(pdoc->GetLineIndentPosition(lineCurrentPos)) &&
-			        pdoc->tabIndents) {
-				int indentation = pdoc->GetLineIndentation(lineCurrentPos);
-				int indentationStep = pdoc->IndentSize();
-				pdoc->SetLineIndentation(lineCurrentPos, indentation + indentationStep - indentation % indentationStep);
-				SetEmptySelection(pdoc->GetLineIndentPosition(lineCurrentPos));
-			} else {
-				if (pdoc->useTabs) {
-					pdoc->InsertChar(currentPos, '\t');
-					SetEmptySelection(currentPos + 1);
+	UndoGroup ug(pdoc);
+	for (size_t r=0; r<sel.Count(); r++) {
+		const Sci::Line lineOfAnchor =
+			pdoc->SciLineFromPosition(sel.Range(r).anchor.Position());
+		Sci::Position caretPosition = sel.Range(r).caret.Position();
+		const Sci::Line lineCurrentPos = pdoc->SciLineFromPosition(caretPosition);
+		if (lineOfAnchor == lineCurrentPos) {
+			if (forwards) {
+				pdoc->DeleteChars(sel.Range(r).Start().Position(), sel.Range(r).Length());
+				caretPosition = sel.Range(r).caret.Position();
+				if (pdoc->GetColumn(caretPosition) <= pdoc->GetColumn(pdoc->GetLineIndentPosition(lineCurrentPos)) &&
+						pdoc->tabIndents) {
+					const int indentation = pdoc->GetLineIndentation(lineCurrentPos);
+					const int indentationStep = pdoc->IndentSize();
+					const Sci::Position posSelect = pdoc->SetLineIndentation(
+						lineCurrentPos, indentation + indentationStep - indentation % indentationStep);
+					sel.Range(r) = SelectionRange(posSelect);
 				} else {
-					int numSpaces = (pdoc->tabInChars) -
-					        (pdoc->GetColumn(currentPos) % (pdoc->tabInChars));
-					if (numSpaces < 1)
-						numSpaces = pdoc->tabInChars;
-					for (int i = 0; i < numSpaces; i++) {
-						pdoc->InsertChar(currentPos + i, ' ');
+					if (pdoc->useTabs) {
+						const Sci::Position lengthInserted = pdoc->InsertString(caretPosition, "\t", 1);
+						sel.Range(r) = SelectionRange(caretPosition + lengthInserted);
+					} else {
+						int numSpaces = (pdoc->tabInChars) -
+								(pdoc->GetColumn(caretPosition) % (pdoc->tabInChars));
+						if (numSpaces < 1)
+							numSpaces = pdoc->tabInChars;
+						const std::string spaceText(numSpaces, ' ');
+						const Sci::Position lengthInserted = pdoc->InsertString(caretPosition, spaceText.c_str(),
+							spaceText.length());
+						sel.Range(r) = SelectionRange(caretPosition + lengthInserted);
 					}
-					SetEmptySelection(currentPos + numSpaces);
+				}
+			} else {
+				if (pdoc->GetColumn(caretPosition) <= pdoc->GetLineIndentation(lineCurrentPos) &&
+						pdoc->tabIndents) {
+					const int indentation = pdoc->GetLineIndentation(lineCurrentPos);
+					const int indentationStep = pdoc->IndentSize();
+					const Sci::Position posSelect = pdoc->SetLineIndentation(lineCurrentPos, indentation - indentationStep);
+					sel.Range(r) = SelectionRange(posSelect);
+				} else {
+					Sci::Position newColumn = ((pdoc->GetColumn(caretPosition) - 1) / pdoc->tabInChars) *
+							pdoc->tabInChars;
+					if (newColumn < 0)
+						newColumn = 0;
+					Sci::Position newPos = caretPosition;
+					while (pdoc->GetColumn(newPos) > newColumn)
+						newPos--;
+					sel.Range(r) = SelectionRange(newPos);
 				}
 			}
-			pdoc->EndUndoAction();
-		} else {
-			if (pdoc->GetColumn(currentPos) <= pdoc->GetLineIndentation(lineCurrentPos) &&
-			        pdoc->tabIndents) {
-				pdoc->BeginUndoAction();
-				int indentation = pdoc->GetLineIndentation(lineCurrentPos);
-				int indentationStep = pdoc->IndentSize();
-				pdoc->SetLineIndentation(lineCurrentPos, indentation - indentationStep);
-				SetEmptySelection(pdoc->GetLineIndentPosition(lineCurrentPos));
-				pdoc->EndUndoAction();
+		} else {	// Multiline
+			const Sci::Position anchorPosOnLine = sel.Range(r).anchor.Position() -
+				pdoc->LineStart(lineOfAnchor);
+			const Sci::Position currentPosPosOnLine = caretPosition -
+				pdoc->LineStart(lineCurrentPos);
+			// Multiple lines selected so indent / dedent
+			const Sci::Line lineTopSel = std::min(lineOfAnchor, lineCurrentPos);
+			Sci::Line lineBottomSel = std::max(lineOfAnchor, lineCurrentPos);
+			if (pdoc->LineStart(lineBottomSel) == sel.Range(r).anchor.Position() || pdoc->LineStart(lineBottomSel) == caretPosition)
+				lineBottomSel--;  	// If not selecting any characters on a line, do not indent
+			pdoc->Indent(forwards, lineBottomSel, lineTopSel);
+			if (lineOfAnchor < lineCurrentPos) {
+				if (currentPosPosOnLine == 0)
+					sel.Range(r) = SelectionRange(pdoc->LineStart(lineCurrentPos),
+						pdoc->LineStart(lineOfAnchor));
+				else
+					sel.Range(r) = SelectionRange(pdoc->LineStart(lineCurrentPos + 1),
+						pdoc->LineStart(lineOfAnchor));
 			} else {
-				int newColumn = ((pdoc->GetColumn(currentPos) - 1) / pdoc->tabInChars) *
-				        pdoc->tabInChars;
-				if (newColumn < 0)
-					newColumn = 0;
-				int newPos = currentPos;
-				while (pdoc->GetColumn(newPos) > newColumn)
-					newPos--;
-				SetEmptySelection(newPos);
+				if (anchorPosOnLine == 0)
+					sel.Range(r) = SelectionRange(pdoc->LineStart(lineCurrentPos),
+						pdoc->LineStart(lineOfAnchor));
+				else
+					sel.Range(r) = SelectionRange(pdoc->LineStart(lineCurrentPos),
+						pdoc->LineStart(lineOfAnchor + 1));
 			}
 		}
-	} else {
-		int anchorPosOnLine = anchor - pdoc->LineStart(lineOfAnchor);
-		int currentPosPosOnLine = currentPos - pdoc->LineStart(lineCurrentPos);
-		// Multiple lines selected so indent / dedent
-		int lineTopSel = Platform::Minimum(lineOfAnchor, lineCurrentPos);
-		int lineBottomSel = Platform::Maximum(lineOfAnchor, lineCurrentPos);
-		if (pdoc->LineStart(lineBottomSel) == anchor || pdoc->LineStart(lineBottomSel) == currentPos)
-			lineBottomSel--;  	// If not selecting any characters on a line, do not indent
-		pdoc->BeginUndoAction();
-		pdoc->Indent(forwards, lineBottomSel, lineTopSel);
-		pdoc->EndUndoAction();
-		if (lineOfAnchor < lineCurrentPos) {
-			if (currentPosPosOnLine == 0)
-				SetSelection(pdoc->LineStart(lineCurrentPos), pdoc->LineStart(lineOfAnchor));
-			else
-				SetSelection(pdoc->LineStart(lineCurrentPos + 1), pdoc->LineStart(lineOfAnchor));
-		} else {
-			if (anchorPosOnLine == 0)
-				SetSelection(pdoc->LineStart(lineCurrentPos), pdoc->LineStart(lineOfAnchor));
-			else
-				SetSelection(pdoc->LineStart(lineCurrentPos), pdoc->LineStart(lineOfAnchor + 1));
-		}
 	}
+	ContainerNeedsUpdate(SC_UPDATE_SELECTION);
+}
+
+class CaseFolderASCII : public CaseFolderTable {
+public:
+	CaseFolderASCII() noexcept {
+		StandardASCII();
+	}
+};
+
+
+CaseFolder *Editor::CaseFolderForEncoding() {
+	// Simple default that only maps ASCII upper case to lower case.
+	return new CaseFolderASCII();
 }
 
 /**
  * Search of a text in the document, in the given range.
  * @return The position of the found text, -1 if not found.
  */
-long Editor::FindText(
+Sci::Position Editor::FindText(
     uptr_t wParam,		///< Search modes : @c SCFIND_MATCHCASE, @c SCFIND_WHOLEWORD,
     ///< @c SCFIND_WORDSTART, @c SCFIND_REGEXP or @c SCFIND_POSIX.
-    sptr_t lParam) {	///< @c TextToFind structure: The text to search for in the given range.
-
-	TextToFind *ft = reinterpret_cast<TextToFind *>(lParam);
-	int lengthFound = istrlen(ft->lpstrText);
-	int pos = pdoc->FindText(ft->chrg.cpMin, ft->chrg.cpMax, ft->lpstrText,
-	        (wParam & SCFIND_MATCHCASE) != 0,
-	        (wParam & SCFIND_WHOLEWORD) != 0,
-	        (wParam & SCFIND_WORDSTART) != 0,
-	        (wParam & SCFIND_REGEXP) != 0,
-	        wParam,
-	        &lengthFound);
-	if (pos != -1) {
-		ft->chrgText.cpMin = pos;
-		ft->chrgText.cpMax = pos + lengthFound;
+    sptr_t lParam) {	///< @c Sci_TextToFind structure: The text to search for in the given range.
+
+	Sci_TextToFind *ft = static_cast<Sci_TextToFind *>(PtrFromSPtr(lParam));
+	Sci::Position lengthFound = strlen(ft->lpstrText);
+	if (!pdoc->HasCaseFolder())
+		pdoc->SetCaseFolder(CaseFolderForEncoding());
+	try {
+		const Sci::Position pos = pdoc->FindText(
+			static_cast<Sci::Position>(ft->chrg.cpMin),
+			static_cast<Sci::Position>(ft->chrg.cpMax),
+			ft->lpstrText,
+			static_cast<int>(wParam),
+			&lengthFound);
+		if (pos != -1) {
+			ft->chrgText.cpMin = static_cast<Sci_PositionCR>(pos);
+			ft->chrgText.cpMax = static_cast<Sci_PositionCR>(pos + lengthFound);
+		}
+		return pos;
+	} catch (RegexError &) {
+		errorStatus = SC_STATUS_WARN_REGEX;
+		return -1;
 	}
-	return pos;
 }
 
 /**
@@ -4837,7 +4102,7 @@ long Editor::FindText(
  * operation is self-contained.
  */
 void Editor::SearchAnchor() {
-	searchAnchor = SelectionStart();
+	searchAnchor = SelectionStart().Position();
 }
 
 /**
@@ -4845,61 +4110,78 @@ void Editor::SearchAnchor() {
  * Used for next text and previous text requests.
  * @return The position of the found text, -1 if not found.
  */
-long Editor::SearchText(
+Sci::Position Editor::SearchText(
     unsigned int iMessage,		///< Accepts both @c SCI_SEARCHNEXT and @c SCI_SEARCHPREV.
     uptr_t wParam,				///< Search modes : @c SCFIND_MATCHCASE, @c SCFIND_WHOLEWORD,
     ///< @c SCFIND_WORDSTART, @c SCFIND_REGEXP or @c SCFIND_POSIX.
     sptr_t lParam) {			///< The text to search for.
 
-	const char *txt = reinterpret_cast<char *>(lParam);
-	int pos;
-	int lengthFound = istrlen(txt);
-	if (iMessage == SCI_SEARCHNEXT) {
-		pos = pdoc->FindText(searchAnchor, pdoc->Length(), txt,
-		        (wParam & SCFIND_MATCHCASE) != 0,
-		        (wParam & SCFIND_WHOLEWORD) != 0,
-		        (wParam & SCFIND_WORDSTART) != 0,
-		        (wParam & SCFIND_REGEXP) != 0,
-		        wParam,
-		        &lengthFound);
-	} else {
-		pos = pdoc->FindText(searchAnchor, 0, txt,
-		        (wParam & SCFIND_MATCHCASE) != 0,
-		        (wParam & SCFIND_WHOLEWORD) != 0,
-		        (wParam & SCFIND_WORDSTART) != 0,
-		        (wParam & SCFIND_REGEXP) != 0,
-		        wParam,
-		        &lengthFound);
+	const char *txt = CharPtrFromSPtr(lParam);
+	Sci::Position pos = INVALID_POSITION;
+	Sci::Position lengthFound = strlen(txt);
+	if (!pdoc->HasCaseFolder())
+		pdoc->SetCaseFolder(CaseFolderForEncoding());
+	try {
+		if (iMessage == SCI_SEARCHNEXT) {
+			pos = pdoc->FindText(searchAnchor, pdoc->Length(), txt,
+					static_cast<int>(wParam),
+					&lengthFound);
+		} else {
+			pos = pdoc->FindText(searchAnchor, 0, txt,
+					static_cast<int>(wParam),
+					&lengthFound);
+		}
+	} catch (RegexError &) {
+		errorStatus = SC_STATUS_WARN_REGEX;
+		return INVALID_POSITION;
 	}
-
-	if (pos != -1) {
+	if (pos != INVALID_POSITION) {
 		SetSelection(pos, pos + lengthFound);
 	}
 
 	return pos;
 }
 
+std::string Editor::CaseMapString(const std::string &s, int caseMapping) {
+	std::string ret(s);
+	for (char &ch : ret) {
+		switch (caseMapping) {
+			case cmUpper:
+				ch = MakeUpperCase(ch);
+				break;
+			case cmLower:
+				ch = MakeLowerCase(ch);
+				break;
+		}
+	}
+	return ret;
+}
+
 /**
  * Search for text in the target range of the document.
  * @return The position of the found text, -1 if not found.
  */
-long Editor::SearchInTarget(const char *text, int length) {
-	int lengthFound = length;
-	int pos = pdoc->FindText(targetStart, targetEnd, text,
-	        (searchFlags & SCFIND_MATCHCASE) != 0,
-	        (searchFlags & SCFIND_WHOLEWORD) != 0,
-	        (searchFlags & SCFIND_WORDSTART) != 0,
-	        (searchFlags & SCFIND_REGEXP) != 0,
-	        searchFlags,
-	        &lengthFound);
-	if (pos != -1) {
-		targetStart = pos;
-		targetEnd = pos + lengthFound;
+Sci::Position Editor::SearchInTarget(const char *text, Sci::Position length) {
+	Sci::Position lengthFound = length;
+
+	if (!pdoc->HasCaseFolder())
+		pdoc->SetCaseFolder(CaseFolderForEncoding());
+	try {
+		const Sci::Position pos = pdoc->FindText(targetRange.start.Position(), targetRange.end.Position(), text,
+				searchFlags,
+				&lengthFound);
+		if (pos != -1) {
+			targetRange.start.SetPosition(pos);
+			targetRange.end.SetPosition(pos + lengthFound);
+		}
+		return pos;
+	} catch (RegexError &) {
+		errorStatus = SC_STATUS_WARN_REGEX;
+		return -1;
 	}
-	return pos;
 }
 
-void Editor::GoToLine(int lineNo) {
+void Editor::GoToLine(Sci::Line lineNo) {
 	if (lineNo > pdoc->LinesTotal())
 		lineNo = pdoc->LinesTotal();
 	if (lineNo < 0)
@@ -4909,125 +4191,92 @@ void Editor::GoToLine(int lineNo) {
 	EnsureCaretVisible();
 }
 
-static bool Close(Point pt1, Point pt2) {
-	if (abs(pt1.x - pt2.x) > 3)
+static bool Close(Point pt1, Point pt2, Point threshold) noexcept {
+	const Point ptDifference = pt2 - pt1;
+	if (std::abs(ptDifference.x) > threshold.x)
 		return false;
-	if (abs(pt1.y - pt2.y) > 3)
+	if (std::abs(ptDifference.y) > threshold.y)
 		return false;
 	return true;
 }
 
-char *Editor::CopyRange(int start, int end) {
-	char *text = 0;
+std::string Editor::RangeText(Sci::Position start, Sci::Position end) const {
 	if (start < end) {
-		int len = end - start;
-		text = new char[len + 1];
-		if (text) {
-			for (int i = 0; i < len; i++) {
-				text[i] = pdoc->CharAt(start + i);
-			}
-			text[len] = '\0';
-		}
-	}
-	return text;
-}
-
-void Editor::CopySelectionFromRange(SelectionText *ss, bool allowLineCopy, int start, int end) {
-	bool isLine = allowLineCopy && (start == end);
-	if (isLine) {
-		int currentLine = pdoc->LineFromPosition(currentPos);
-		start = pdoc->LineStart(currentLine);
-		end = pdoc->LineEnd(currentLine);
-
-		char *text = CopyRange(start, end);
-		int textLen = text ? strlen(text) : 0;
-		// include room for \r\n\0
-		textLen += 3;
-		char *textWithEndl = new char[textLen];
-		textWithEndl[0] = '\0';
-		if (text)
-			strncat(textWithEndl, text, textLen);
-		if (pdoc->eolMode != SC_EOL_LF)
-			strncat(textWithEndl, "\r", textLen);
-		if (pdoc->eolMode != SC_EOL_CR)
-			strncat(textWithEndl, "\n", textLen);
-		ss->Set(textWithEndl, strlen(textWithEndl),
-			pdoc->dbcsCodePage, vs.styles[STYLE_DEFAULT].characterSet, false, true);
-		delete []text;
-	} else {
-		ss->Set(CopyRange(start, end), end - start + 1,
-			pdoc->dbcsCodePage, vs.styles[STYLE_DEFAULT].characterSet, false, false);
+		const Sci::Position len = end - start;
+		std::string ret(len, '\0');
+		pdoc->GetCharRange(ret.data(), start, len);
+		return ret;
 	}
+	return std::string();
 }
 
 void Editor::CopySelectionRange(SelectionText *ss, bool allowLineCopy) {
-	if (selType == selStream) {
-		CopySelectionFromRange(ss, allowLineCopy, SelectionStart(), SelectionEnd());
-	} else {
-		char *text = 0;
-		int size = 0;
-		SelectionLineIterator lineIterator(this);
-		while (lineIterator.Iterate()) {
-			size += lineIterator.endPos - lineIterator.startPos;
-			if (selType != selLines) {
-				size++;
-				if (pdoc->eolMode == SC_EOL_CRLF) {
-					size++;
-				}
-			}
+	if (sel.Empty()) {
+		if (allowLineCopy) {
+			const Sci::Line currentLine = pdoc->SciLineFromPosition(sel.MainCaret());
+			const Sci::Position start = pdoc->LineStart(currentLine);
+			const Sci::Position end = pdoc->LineEnd(currentLine);
+
+			std::string text = RangeText(start, end);
+			if (pdoc->eolMode != SC_EOL_LF)
+				text.push_back('\r');
+			if (pdoc->eolMode != SC_EOL_CR)
+				text.push_back('\n');
+			ss->Copy(text, pdoc->dbcsCodePage,
+				vs.styles[STYLE_DEFAULT].characterSet, false, true);
 		}
-		if (size > 0) {
-			text = new char[size + 1];
-			if (text) {
-				int j = 0;
-				lineIterator.Reset();
-				while (lineIterator.Iterate()) {
-					for (int i = lineIterator.startPos;
-					        i < lineIterator.endPos;
-					        i++) {
-						text[j++] = pdoc->CharAt(i);
-					}
-					if (selType != selLines) {
-						if (pdoc->eolMode != SC_EOL_LF) {
-							text[j++] = '\r';
-						}
-						if (pdoc->eolMode != SC_EOL_CR) {
-							text[j++] = '\n';
-						}
-					}
-				}
-				text[size] = '\0';
+	} else {
+		std::string text;
+		std::vector<SelectionRange> rangesInOrder = sel.RangesCopy();
+		if (sel.selType == Selection::selRectangle)
+			std::sort(rangesInOrder.begin(), rangesInOrder.end());
+		for (const SelectionRange &current : rangesInOrder) {
+				text.append(RangeText(current.Start().Position(), current.End().Position()));
+			if (sel.selType == Selection::selRectangle) {
+				if (pdoc->eolMode != SC_EOL_LF)
+					text.push_back('\r');
+				if (pdoc->eolMode != SC_EOL_CR)
+					text.push_back('\n');
 			}
 		}
-		ss->Set(text, size + 1, pdoc->dbcsCodePage,
-			vs.styles[STYLE_DEFAULT].characterSet, selType == selRectangle, selType == selLines);
+		ss->Copy(text, pdoc->dbcsCodePage,
+			vs.styles[STYLE_DEFAULT].characterSet, sel.IsRectangular(), sel.selType == Selection::selLines);
 	}
 }
 
-void Editor::CopyRangeToClipboard(int start, int end) {
+void Editor::CopyRangeToClipboard(Sci::Position start, Sci::Position end) {
 	start = pdoc->ClampPositionIntoDocument(start);
 	end = pdoc->ClampPositionIntoDocument(end);
 	SelectionText selectedText;
-	selectedText.Set(CopyRange(start, end), end - start + 1,
+	std::string text = RangeText(start, end);
+	selectedText.Copy(text,
 		pdoc->dbcsCodePage, vs.styles[STYLE_DEFAULT].characterSet, false, false);
 	CopyToClipboard(selectedText);
 }
 
-void Editor::CopyText(int length, const char *text) {
+void Editor::CopyText(size_t length, const char *text) {
 	SelectionText selectedText;
-	selectedText.Copy(text, length + 1,
+	selectedText.Copy(std::string(text, length),
 		pdoc->dbcsCodePage, vs.styles[STYLE_DEFAULT].characterSet, false, false);
 	CopyToClipboard(selectedText);
 }
 
-void Editor::SetDragPosition(int newPos) {
-	if (newPos >= 0) {
+void Editor::SetDragPosition(SelectionPosition newPos) {
+	if (newPos.Position() >= 0) {
 		newPos = MovePositionOutsideChar(newPos, 1);
 		posDrop = newPos;
 	}
-	if (posDrag != newPos) {
+	if (!(posDrag == newPos)) {
+		const CaretPolicies dragCaretPolicies = {
+			CaretPolicy(CARET_SLOP | CARET_STRICT | CARET_EVEN, 50),
+			CaretPolicy(CARET_SLOP | CARET_STRICT | CARET_EVEN, 2)
+		};
+		MovedCaret(newPos, posDrag, true, dragCaretPolicies);
+
 		caret.on = true;
-		SetTicking(true);
+		FineTickerCancel(tickCaret);
+		if ((caret.active) && (caret.period > 0) && (newPos.Position() < 0))
+			FineTickerStart(tickCaret, caret.period, caret.period/10);
 		InvalidateCaret();
 		posDrag = newPos;
 		InvalidateCaret();
@@ -5042,10 +4291,9 @@ void Editor::DisplayCursor(Window::Cursor c) {
 }
 
 bool Editor::DragThreshold(Point ptStart, Point ptNow) {
-	int xMove = ptStart.x - ptNow.x;
-	int yMove = ptStart.y - ptNow.y;
-	int distanceSquared = xMove * xMove + yMove * yMove;
-	return distanceSquared > 16;
+	const Point ptDiff = ptStart - ptNow;
+	const XYPOSITION distanceSquared = ptDiff.x * ptDiff.x + ptDiff.y * ptDiff.y;
+	return distanceSquared > 16.0f;
 }
 
 void Editor::StartDrag() {
@@ -5054,146 +4302,194 @@ void Editor::StartDrag() {
 	//DisplayCursor(Window::cursorArrow);
 }
 
-void Editor::DropAt(int position, const char *value, bool moving, bool rectangular) {
+void Editor::DropAt(SelectionPosition position, const char *value, size_t lengthValue, bool moving, bool rectangular) {
 	//Platform::DebugPrintf("DropAt %d %d\n", inDragDrop, position);
 	if (inDragDrop == ddDragging)
 		dropWentOutside = false;
 
-	int positionWasInSelection = PositionInSelection(position);
+	const bool positionWasInSelection = PositionInSelection(position.Position());
 
-	bool positionOnEdgeOfSelection =
+	const bool positionOnEdgeOfSelection =
 	    (position == SelectionStart()) || (position == SelectionEnd());
 
-	if ((inDragDrop != ddDragging) || !(0 == positionWasInSelection) ||
+	if ((inDragDrop != ddDragging) || !(positionWasInSelection) ||
 	        (positionOnEdgeOfSelection && !moving)) {
 
-		int selStart = SelectionStart();
-		int selEnd = SelectionEnd();
+		const SelectionPosition selStart = SelectionStart();
+		const SelectionPosition selEnd = SelectionEnd();
 
-		pdoc->BeginUndoAction();
+		UndoGroup ug(pdoc);
 
-		int positionAfterDeletion = position;
+		SelectionPosition positionAfterDeletion = position;
 		if ((inDragDrop == ddDragging) && moving) {
 			// Remove dragged out text
-			if (rectangular || selType == selLines) {
-				SelectionLineIterator lineIterator(this);
-				while (lineIterator.Iterate()) {
-					if (position >= lineIterator.startPos) {
-						if (position > lineIterator.endPos) {
-							positionAfterDeletion -= lineIterator.endPos - lineIterator.startPos;
+			if (rectangular || sel.selType == Selection::selLines) {
+				for (size_t r=0; r<sel.Count(); r++) {
+					if (position >= sel.Range(r).Start()) {
+						if (position > sel.Range(r).End()) {
+							positionAfterDeletion.Add(-sel.Range(r).Length());
 						} else {
-							positionAfterDeletion -= position - lineIterator.startPos;
+							positionAfterDeletion.Add(-SelectionRange(position, sel.Range(r).Start()).Length());
 						}
 					}
 				}
 			} else {
 				if (position > selStart) {
-					positionAfterDeletion -= selEnd - selStart;
+					positionAfterDeletion.Add(-SelectionRange(selEnd, selStart).Length());
 				}
 			}
 			ClearSelection();
 		}
 		position = positionAfterDeletion;
 
+		std::string convertedText = Document::TransformLineEnds(value, lengthValue, pdoc->eolMode);
+
 		if (rectangular) {
-			PasteRectangular(position, value, istrlen(value));
-			pdoc->EndUndoAction();
+			PasteRectangular(position, convertedText.c_str(), convertedText.length());
 			// Should try to select new rectangle but it may not be a rectangle now so just select the drop position
 			SetEmptySelection(position);
 		} else {
-			position = MovePositionOutsideChar(position, currentPos - position);
-			if (pdoc->InsertCString(position, value)) {
-				SetSelection(position + istrlen(value), position);
+			position = MovePositionOutsideChar(position, sel.MainCaret() - position.Position());
+			position = RealizeVirtualSpace(position);
+			const Sci::Position lengthInserted = pdoc->InsertString(
+				position.Position(), convertedText.c_str(), convertedText.length());
+			if (lengthInserted > 0) {
+				SelectionPosition posAfterInsertion = position;
+				posAfterInsertion.Add(lengthInserted);
+				SetSelection(posAfterInsertion, position);
 			}
-			pdoc->EndUndoAction();
 		}
 	} else if (inDragDrop == ddDragging) {
 		SetEmptySelection(position);
 	}
 }
 
+void Editor::DropAt(SelectionPosition position, const char *value, bool moving, bool rectangular) {
+	DropAt(position, value, strlen(value), moving, rectangular);
+}
+
 /**
- * @return -1 if given position is before the selection,
- *          1 if position is after the selection,
- *          0 if position is inside the selection,
+ * @return true if given position is inside the selection,
  */
-int Editor::PositionInSelection(int pos) {
-	pos = MovePositionOutsideChar(pos, currentPos - pos);
-	if (pos < SelectionStart()) {
-		return -1;
-	}
-	if (pos > SelectionEnd()) {
-		return 1;
-	}
-	if (selType == selStream) {
-		return 0;
-	} else {
-		SelectionLineIterator lineIterator(this);
-		lineIterator.SetAt(pdoc->LineFromPosition(pos));
-		if (pos < lineIterator.startPos) {
-			return -1;
-		} else if (pos > lineIterator.endPos) {
-			return 1;
-		} else {
-			return 0;
-		}
+bool Editor::PositionInSelection(Sci::Position pos) {
+	pos = MovePositionOutsideChar(pos, sel.MainCaret() - pos);
+	for (size_t r=0; r<sel.Count(); r++) {
+		if (sel.Range(r).Contains(pos))
+			return true;
 	}
+	return false;
 }
 
 bool Editor::PointInSelection(Point pt) {
-	int pos = PositionFromLocation(pt);
-	if (0 == PositionInSelection(pos)) {
-		// Probably inside, but we must make a finer test
-		int selStart, selEnd;
-		if (selType == selStream) {
-			selStart = SelectionStart();
-			selEnd = SelectionEnd();
-		} else {
-			SelectionLineIterator lineIterator(this);
-			lineIterator.SetAt(pdoc->LineFromPosition(pos));
-			selStart = lineIterator.startPos;
-			selEnd = lineIterator.endPos;
-		}
-		if (pos == selStart) {
-			// see if just before selection
-			Point locStart = LocationFromPosition(pos);
-			if (pt.x < locStart.x) {
-				return false;
+	const SelectionPosition pos = SPositionFromLocation(pt, false, true);
+	const Point ptPos = LocationFromPosition(pos);
+	for (size_t r=0; r<sel.Count(); r++) {
+		const SelectionRange &range = sel.Range(r);
+		if (range.Contains(pos)) {
+			bool hit = true;
+			if (pos == range.Start()) {
+				// see if just before selection
+				if (pt.x < ptPos.x) {
+					hit = false;
+				}
 			}
-		}
-		if (pos == selEnd) {
-			// see if just after selection
-			Point locEnd = LocationFromPosition(pos);
-			if (pt.x > locEnd.x) {
-				return false;
+			if (pos == range.End()) {
+				// see if just after selection
+				if (pt.x > ptPos.x) {
+					hit = false;
+				}
 			}
+			if (hit)
+				return true;
 		}
-		return true;
 	}
 	return false;
 }
 
-bool Editor::PointInSelMargin(Point pt) {
+bool Editor::PointInSelMargin(Point pt) const {
 	// Really means: "Point in a margin"
 	if (vs.fixedColumnWidth > 0) {	// There is a margin
 		PRectangle rcSelMargin = GetClientRectangle();
-		rcSelMargin.right = vs.fixedColumnWidth - vs.leftMarginWidth;
-		return rcSelMargin.Contains(pt);
+		rcSelMargin.right = static_cast<XYPOSITION>(vs.textStart - vs.leftMarginWidth);
+		rcSelMargin.left = static_cast<XYPOSITION>(vs.textStart - vs.fixedColumnWidth);
+		const Point ptOrigin = GetVisibleOriginInMain();
+		rcSelMargin.Move(0, -ptOrigin.y);
+		return rcSelMargin.ContainsWholePixel(pt);
 	} else {
 		return false;
 	}
 }
 
-void Editor::LineSelection(int lineCurrent_, int lineAnchor_) {
-	if (lineAnchor_ < lineCurrent_) {
-		SetSelection(pdoc->LineStart(lineCurrent_ + 1),
-		        pdoc->LineStart(lineAnchor_));
-	} else if (lineAnchor_ > lineCurrent_) {
-		SetSelection(pdoc->LineStart(lineCurrent_),
-		        pdoc->LineStart(lineAnchor_ + 1));
-	} else { // Same line, select it
-		SetSelection(pdoc->LineStart(lineAnchor_ + 1),
-		        pdoc->LineStart(lineAnchor_));
+Window::Cursor Editor::GetMarginCursor(Point pt) const noexcept {
+	int x = 0;
+	for (const MarginStyle &m : vs.ms) {
+		if ((pt.x >= x) && (pt.x < x + m.width))
+			return static_cast<Window::Cursor>(m.cursor);
+		x += m.width;
+	}
+	return Window::cursorReverseArrow;
+}
+
+void Editor::TrimAndSetSelection(Sci::Position currentPos_, Sci::Position anchor_) {
+	sel.TrimSelection(SelectionRange(currentPos_, anchor_));
+	SetSelection(currentPos_, anchor_);
+}
+
+void Editor::LineSelection(Sci::Position lineCurrentPos_, Sci::Position lineAnchorPos_, bool wholeLine) {
+	Sci::Position selCurrentPos;
+	Sci::Position selAnchorPos;
+	if (wholeLine) {
+		const Sci::Line lineCurrent_ = pdoc->SciLineFromPosition(lineCurrentPos_);
+		const Sci::Line lineAnchor_ = pdoc->SciLineFromPosition(lineAnchorPos_);
+		if (lineAnchorPos_ < lineCurrentPos_) {
+			selCurrentPos = pdoc->LineStart(lineCurrent_ + 1);
+			selAnchorPos = pdoc->LineStart(lineAnchor_);
+		} else if (lineAnchorPos_ > lineCurrentPos_) {
+			selCurrentPos = pdoc->LineStart(lineCurrent_);
+			selAnchorPos = pdoc->LineStart(lineAnchor_ + 1);
+		} else { // Same line, select it
+			selCurrentPos = pdoc->LineStart(lineAnchor_ + 1);
+			selAnchorPos = pdoc->LineStart(lineAnchor_);
+		}
+	} else {
+		if (lineAnchorPos_ < lineCurrentPos_) {
+			selCurrentPos = StartEndDisplayLine(lineCurrentPos_, false) + 1;
+			selCurrentPos = pdoc->MovePositionOutsideChar(selCurrentPos, 1);
+			selAnchorPos = StartEndDisplayLine(lineAnchorPos_, true);
+		} else if (lineAnchorPos_ > lineCurrentPos_) {
+			selCurrentPos = StartEndDisplayLine(lineCurrentPos_, true);
+			selAnchorPos = StartEndDisplayLine(lineAnchorPos_, false) + 1;
+			selAnchorPos = pdoc->MovePositionOutsideChar(selAnchorPos, 1);
+		} else { // Same line, select it
+			selCurrentPos = StartEndDisplayLine(lineAnchorPos_, false) + 1;
+			selCurrentPos = pdoc->MovePositionOutsideChar(selCurrentPos, 1);
+			selAnchorPos = StartEndDisplayLine(lineAnchorPos_, true);
+		}
+	}
+	TrimAndSetSelection(selCurrentPos, selAnchorPos);
+}
+
+void Editor::WordSelection(Sci::Position pos) {
+	if (pos < wordSelectAnchorStartPos) {
+		// Extend backward to the word containing pos.
+		// Skip ExtendWordSelect if the line is empty or if pos is after the last character.
+		// This ensures that a series of empty lines isn't counted as a single "word".
+		if (!pdoc->IsLineEndPosition(pos))
+			pos = pdoc->ExtendWordSelect(pdoc->MovePositionOutsideChar(pos + 1, 1), -1);
+		TrimAndSetSelection(pos, wordSelectAnchorEndPos);
+	} else if (pos > wordSelectAnchorEndPos) {
+		// Extend forward to the word containing the character to the left of pos.
+		// Skip ExtendWordSelect if the line is empty or if pos is the first position on the line.
+		// This ensures that a series of empty lines isn't counted as a single "word".
+		if (pos > pdoc->LineStart(pdoc->LineFromPosition(pos)))
+			pos = pdoc->ExtendWordSelect(pdoc->MovePositionOutsideChar(pos - 1, -1), 1);
+		TrimAndSetSelection(pos, wordSelectAnchorStartPos);
+	} else {
+		// Select only the anchored word
+		if (pos >= originalAnchorPos)
+			TrimAndSetSelection(wordSelectAnchorEndPos, wordSelectAnchorStartPos);
+		else
+			TrimAndSetSelection(wordSelectAnchorStartPos, wordSelectAnchorEndPos);
 	}
 }
 
@@ -5206,96 +4502,160 @@ void Editor::DwellEnd(bool mouseMoved) {
 		dwelling = false;
 		NotifyDwelling(ptMouseLast, dwelling);
 	}
+	FineTickerCancel(tickDwell);
+}
+
+void Editor::MouseLeave() {
+	SetHotSpotRange(nullptr);
+	SetHoverIndicatorPosition(Sci::invalidPosition);
+	if (!HaveMouseCapture()) {
+		ptMouseLast = Point(-1, -1);
+		DwellEnd(true);
+	}
 }
 
-void Editor::ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt) {
+static constexpr bool AllowVirtualSpace(int virtualSpaceOptions, bool rectangular) noexcept {
+	return (!rectangular && ((virtualSpaceOptions & SCVS_USERACCESSIBLE) != 0))
+		|| (rectangular && ((virtualSpaceOptions & SCVS_RECTANGULARSELECTION) != 0));
+}
+
+void Editor::ButtonDownWithModifiers(Point pt, unsigned int curTime, int modifiers) {
+	SetHoverIndicatorPoint(pt);
 	//Platform::DebugPrintf("ButtonDown %d %d = %d alt=%d %d\n", curTime, lastClickTime, curTime - lastClickTime, alt, inDragDrop);
 	ptMouseLast = pt;
-	int newPos = PositionFromLocation(pt);
-	newPos = MovePositionOutsideChar(newPos, currentPos - newPos);
+	const bool ctrl = (modifiers & SCI_CTRL) != 0;
+	const bool shift = (modifiers & SCI_SHIFT) != 0;
+	const bool alt = (modifiers & SCI_ALT) != 0;
+	SelectionPosition newPos = SPositionFromLocation(pt, false, false, AllowVirtualSpace(virtualSpaceOptions, alt));
+	newPos = MovePositionOutsideChar(newPos, sel.MainCaret() - newPos.Position());
+	SelectionPosition newCharPos = SPositionFromLocation(pt, false, true, false);
+	newCharPos = MovePositionOutsideChar(newCharPos, -1);
 	inDragDrop = ddNone;
-	moveExtendsSelection = false;
+	sel.SetMoveExtends(false);
 
-	bool processed = NotifyMarginClick(pt, shift, ctrl, alt);
-	if (processed)
+	if (NotifyMarginClick(pt, modifiers))
 		return;
 
-	NotifyIndicatorClick(true, newPos, shift, ctrl, alt);
+	NotifyIndicatorClick(true, newPos.Position(), modifiers);
 
-	bool inSelMargin = PointInSelMargin(pt);
-	if (shift & !inSelMargin) {
+	const bool inSelMargin = PointInSelMargin(pt);
+	// In margin ctrl+(double)click should always select everything
+	if (ctrl && inSelMargin) {
+		SelectAll();
+		lastClickTime = curTime;
+		lastClick = pt;
+		return;
+	}
+	if (shift && !inSelMargin) {
 		SetSelection(newPos);
 	}
-	if (((curTime - lastClickTime) < Platform::DoubleClickTime()) && Close(pt, lastClick)) {
+	if ((curTime < (lastClickTime+Platform::DoubleClickTime())) && Close(pt, lastClick, doubleClickCloseThreshold)) {
 		//Platform::DebugPrintf("Double click %d %d = %d\n", curTime, lastClickTime, curTime - lastClickTime);
 		SetMouseCapture(true);
-		SetEmptySelection(newPos);
+		FineTickerStart(tickScroll, 100, 10);
+		if (!ctrl || !multipleSelection || (selectionUnit != TextUnit::character && selectionUnit != TextUnit::word))
+			SetEmptySelection(newPos.Position());
 		bool doubleClick = false;
-		// Stop mouse button bounce changing selection type
-		if (!Platform::MouseButtonBounce() || curTime != lastClickTime) {
-			if (selectionType == selChar) {
-				selectionType = selWord;
+		if (inSelMargin) {
+			// Inside margin selection type should be either subLine or wholeLine.
+			if (selectionUnit == TextUnit::subLine) {
+				// If it is subLine, we're inside a *double* click and word wrap is enabled,
+				// so we switch to wholeLine in order to select whole line.
+				selectionUnit = TextUnit::wholeLine;
+			} else if (selectionUnit != TextUnit::subLine && selectionUnit != TextUnit::wholeLine) {
+				// If it is neither, reset selection type to line selection.
+				selectionUnit = (Wrapping() && (marginOptions & SC_MARGINOPTION_SUBLINESELECT)) ? TextUnit::subLine : TextUnit::wholeLine;
+			}
+		} else {
+			if (selectionUnit == TextUnit::character) {
+				selectionUnit = TextUnit::word;
 				doubleClick = true;
-			} else if (selectionType == selWord) {
-				selectionType = selLine;
+			} else if (selectionUnit == TextUnit::word) {
+				// Since we ended up here, we're inside a *triple* click, which should always select
+				// whole line regardless of word wrap being enabled or not.
+				selectionUnit = TextUnit::wholeLine;
 			} else {
-				selectionType = selChar;
-				originalAnchorPos = currentPos;
+				selectionUnit = TextUnit::character;
+				originalAnchorPos = sel.MainCaret();
 			}
 		}
 
-		if (selectionType == selWord) {
-			if (currentPos >= originalAnchorPos) {	// Moved forward
-				SetSelection(pdoc->ExtendWordSelect(currentPos, 1),
-				        pdoc->ExtendWordSelect(originalAnchorPos, -1));
-			} else {	// Moved backward
-				SetSelection(pdoc->ExtendWordSelect(currentPos, -1),
-				        pdoc->ExtendWordSelect(originalAnchorPos, 1));
+		if (selectionUnit == TextUnit::word) {
+			Sci::Position charPos = originalAnchorPos;
+			if (sel.MainCaret() == originalAnchorPos) {
+				charPos = PositionFromLocation(pt, false, true);
+				charPos = MovePositionOutsideChar(charPos, -1);
+			}
+
+			Sci::Position startWord;
+			Sci::Position endWord;
+			if ((sel.MainCaret() >= originalAnchorPos) && !pdoc->IsLineEndPosition(charPos)) {
+				startWord = pdoc->ExtendWordSelect(pdoc->MovePositionOutsideChar(charPos + 1, 1), -1);
+				endWord = pdoc->ExtendWordSelect(charPos, 1);
+			} else {
+				// Selecting backwards, or anchor beyond last character on line. In these cases,
+				// we select the word containing the character to the *left* of the anchor.
+				if (charPos > pdoc->LineStart(pdoc->LineFromPosition(charPos))) {
+					startWord = pdoc->ExtendWordSelect(charPos, -1);
+					endWord = pdoc->ExtendWordSelect(startWord, 1);
+				} else {
+					// Anchor at start of line; select nothing to begin with.
+					startWord = charPos;
+					endWord = charPos;
+				}
 			}
-		} else if (selectionType == selLine) {
-			lineAnchor = LineFromLocation(pt);
-			SetSelection(pdoc->LineStart(lineAnchor + 1), pdoc->LineStart(lineAnchor));
+
+			wordSelectAnchorStartPos = startWord;
+			wordSelectAnchorEndPos = endWord;
+			wordSelectInitialCaretPos = sel.MainCaret();
+			WordSelection(wordSelectInitialCaretPos);
+		} else if (selectionUnit == TextUnit::subLine || selectionUnit == TextUnit::wholeLine) {
+			lineAnchorPos = newPos.Position();
+			LineSelection(lineAnchorPos, lineAnchorPos, selectionUnit == TextUnit::wholeLine);
 			//Platform::DebugPrintf("Triple click: %d - %d\n", anchor, currentPos);
 		} else {
-			SetEmptySelection(currentPos);
+			SetEmptySelection(sel.MainCaret());
 		}
 		//Platform::DebugPrintf("Double click: %d - %d\n", anchor, currentPos);
 		if (doubleClick) {
-			NotifyDoubleClick(pt, shift, ctrl, alt);
-			if (PositionIsHotspot(newPos))
-				NotifyHotSpotDoubleClicked(newPos, shift, ctrl, alt);
+			NotifyDoubleClick(pt, modifiers);
+			if (PositionIsHotspot(newCharPos.Position()))
+				NotifyHotSpotDoubleClicked(newCharPos.Position(), modifiers);
 		}
 	} else {	// Single click
 		if (inSelMargin) {
-			selType = selStream;
-			if (ctrl) {
-				SelectAll();
-				lastClickTime = curTime;
-				return;
+			if (sel.IsRectangular() || (sel.Count() > 1)) {
+				InvalidateWholeSelection();
+				sel.Clear();
 			}
+			sel.selType = Selection::selStream;
 			if (!shift) {
-				lineAnchor = LineFromLocation(pt);
-				// Single click in margin: select whole line
-				LineSelection(lineAnchor, lineAnchor);
-				SetSelection(pdoc->LineStart(lineAnchor + 1),
-				        pdoc->LineStart(lineAnchor));
+				// Single click in margin: select wholeLine or only subLine if word wrap is enabled
+				lineAnchorPos = newPos.Position();
+				selectionUnit = (Wrapping() && (marginOptions & SC_MARGINOPTION_SUBLINESELECT)) ? TextUnit::subLine : TextUnit::wholeLine;
+				LineSelection(lineAnchorPos, lineAnchorPos, selectionUnit == TextUnit::wholeLine);
 			} else {
 				// Single shift+click in margin: select from line anchor to clicked line
-				if (anchor > currentPos)
-					lineAnchor = pdoc->LineFromPosition(anchor - 1);
+				if (sel.MainAnchor() > sel.MainCaret())
+					lineAnchorPos = sel.MainAnchor() - 1;
 				else
-					lineAnchor = pdoc->LineFromPosition(anchor);
-				int lineStart = LineFromLocation(pt);
-				LineSelection(lineStart, lineAnchor);
-				//lineAnchor = lineStart; // Keep the same anchor for ButtonMove
+					lineAnchorPos = sel.MainAnchor();
+				// Reset selection type if there is an empty selection.
+				// This ensures that we don't end up stuck in previous selection mode, which is no longer valid.
+				// Otherwise, if there's a non empty selection, reset selection type only if it differs from subLine and wholeLine.
+				// This ensures that we continue selecting in the same selection mode.
+				if (sel.Empty() || (selectionUnit != TextUnit::subLine && selectionUnit != TextUnit::wholeLine))
+					selectionUnit = (Wrapping() && (marginOptions & SC_MARGINOPTION_SUBLINESELECT)) ? TextUnit::subLine : TextUnit::wholeLine;
+				LineSelection(newPos.Position(), lineAnchorPos, selectionUnit == TextUnit::wholeLine);
 			}
 
-			SetDragPosition(invalidPosition);
+			SetDragPosition(SelectionPosition(Sci::invalidPosition));
 			SetMouseCapture(true);
-			selectionType = selLine;
+			FineTickerStart(tickScroll, 100, 10);
 		} else {
 			if (PointIsHotspot(pt)) {
-				NotifyHotSpotClicked(newPos, shift, ctrl, alt);
+				NotifyHotSpotClicked(newCharPos.Position(), modifiers);
+				hotSpotClickPos = newCharPos.Position();
 			}
 			if (!shift) {
 				if (PointInSelection(pt) && !SelectionEmpty())
@@ -5304,83 +4664,129 @@ void Editor::ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, b
 					inDragDrop = ddNone;
 			}
 			SetMouseCapture(true);
+			FineTickerStart(tickScroll, 100, 10);
 			if (inDragDrop != ddInitial) {
-				SetDragPosition(invalidPosition);
+				SetDragPosition(SelectionPosition(Sci::invalidPosition));
 				if (!shift) {
-					SetEmptySelection(newPos);
+					if (ctrl && multipleSelection) {
+						const SelectionRange range(newPos);
+						sel.TentativeSelection(range);
+						InvalidateSelection(range, true);
+					} else {
+						InvalidateSelection(SelectionRange(newPos), true);
+						if (sel.Count() > 1)
+							Redraw();
+						if ((sel.Count() > 1) || (sel.selType != Selection::selStream))
+							sel.Clear();
+						sel.selType = alt ? Selection::selRectangle : Selection::selStream;
+						SetSelection(newPos, newPos);
+					}
 				}
-				selType = alt ? selRectangle : selStream;
-				selectionType = selChar;
-				originalAnchorPos = currentPos;
+				SelectionPosition anchorCurrent = newPos;
+				if (shift)
+					anchorCurrent = sel.IsRectangular() ?
+						sel.Rectangular().anchor : sel.RangeMain().anchor;
+				sel.selType = alt ? Selection::selRectangle : Selection::selStream;
+				selectionUnit = TextUnit::character;
+				originalAnchorPos = sel.MainCaret();
+				sel.Rectangular() = SelectionRange(newPos, anchorCurrent);
 				SetRectangularRange();
 			}
 		}
 	}
 	lastClickTime = curTime;
-	lastXChosen = pt.x;
+	lastClick = pt;
+	lastXChosen = static_cast<int>(pt.x) + xOffset;
 	ShowCaretAtCurrentPosition();
 }
 
-bool Editor::PositionIsHotspot(int position) {
-	return vs.styles[pdoc->StyleAt(position) & pdoc->stylingBitsMask].hotspot;
+void Editor::RightButtonDownWithModifiers(Point pt, unsigned int, int modifiers) {
+	if (NotifyMarginRightClick(pt, modifiers))
+		return;
+}
+
+bool Editor::PositionIsHotspot(Sci::Position position) const {
+	return vs.styles[pdoc->StyleIndexAt(position)].hotspot;
 }
 
 bool Editor::PointIsHotspot(Point pt) {
-	int pos = PositionFromLocationClose(pt);
+	const Sci::Position pos = PositionFromLocation(pt, true, true);
 	if (pos == INVALID_POSITION)
 		return false;
 	return PositionIsHotspot(pos);
 }
 
-void Editor::SetHotSpotRange(Point *pt) {
+void Editor::SetHoverIndicatorPosition(Sci::Position position) {
+	const Sci::Position hoverIndicatorPosPrev = hoverIndicatorPos;
+	hoverIndicatorPos = INVALID_POSITION;
+	if (!vs.indicatorsDynamic)
+		return;
+	if (position != INVALID_POSITION) {
+		for (const IDecoration *deco : pdoc->decorations->View()) {
+			if (vs.indicators[deco->Indicator()].IsDynamic()) {
+				if (pdoc->decorations->ValueAt(deco->Indicator(), position)) {
+					hoverIndicatorPos = position;
+				}
+			}
+		}
+	}
+	if (hoverIndicatorPosPrev != hoverIndicatorPos) {
+		Redraw();
+	}
+}
+
+void Editor::SetHoverIndicatorPoint(Point pt) {
+	if (!vs.indicatorsDynamic) {
+		SetHoverIndicatorPosition(INVALID_POSITION);
+	} else {
+		SetHoverIndicatorPosition(PositionFromLocation(pt, true, true));
+	}
+}
+
+void Editor::SetHotSpotRange(const Point *pt) {
 	if (pt) {
-		int pos = PositionFromLocation(*pt);
+		const Sci::Position pos = PositionFromLocation(*pt, false, true);
 
 		// If we don't limit this to word characters then the
 		// range can encompass more than the run range and then
 		// the underline will not be drawn properly.
-		int hsStart_ = pdoc->ExtendStyleRange(pos, -1, vs.hotspotSingleLine);
-		int hsEnd_ = pdoc->ExtendStyleRange(pos, 1, vs.hotspotSingleLine);
+		Range hsNew;
+		hsNew.start = pdoc->ExtendStyleRange(pos, -1, vs.hotspotSingleLine);
+		hsNew.end = pdoc->ExtendStyleRange(pos, 1, vs.hotspotSingleLine);
 
 		// Only invalidate the range if the hotspot range has changed...
-		if (hsStart_ != hsStart || hsEnd_ != hsEnd) {
-			if (hsStart != -1) {
-				InvalidateRange(hsStart, hsEnd);
+		if (!(hsNew == hotspot)) {
+			if (hotspot.Valid()) {
+				InvalidateRange(hotspot.start, hotspot.end);
 			}
-			hsStart = hsStart_;
-			hsEnd = hsEnd_;
-			InvalidateRange(hsStart, hsEnd);
+			hotspot = hsNew;
+			InvalidateRange(hotspot.start, hotspot.end);
 		}
 	} else {
-		if (hsStart != -1) {
-			int hsStart_ = hsStart;
-			int hsEnd_ = hsEnd;
-			hsStart = -1;
-			hsEnd = -1;
-			InvalidateRange(hsStart_, hsEnd_);
-		} else {
-			hsStart = -1;
-			hsEnd = -1;
+		if (hotspot.Valid()) {
+			InvalidateRange(hotspot.start, hotspot.end);
 		}
+		hotspot = Range(Sci::invalidPosition);
 	}
 }
 
-void Editor::GetHotSpotRange(int& hsStart_, int& hsEnd_) {
-	hsStart_ = hsStart;
-	hsEnd_ = hsEnd;
+Range Editor::GetHotSpotRange() const noexcept {
+	return hotspot;
 }
 
-void Editor::ButtonMove(Point pt) {
-	if ((ptMouseLast.x != pt.x) || (ptMouseLast.y != pt.y)) {
+void Editor::ButtonMoveWithModifiers(Point pt, unsigned int, int modifiers) {
+	if (ptMouseLast != pt) {
 		DwellEnd(true);
 	}
 
-	int movePos = PositionFromLocation(pt);
-	movePos = MovePositionOutsideChar(movePos, currentPos - movePos);
+	SelectionPosition movePos = SPositionFromLocation(pt, false, false,
+		AllowVirtualSpace(virtualSpaceOptions, sel.IsRectangular()));
+	movePos = MovePositionOutsideChar(movePos, sel.MainCaret() - movePos.Position());
 
 	if (inDragDrop == ddInitial) {
 		if (DragThreshold(ptMouseLast, pt)) {
 			SetMouseCapture(false);
+			FineTickerCancel(tickScroll);
 			SetDragPosition(movePos);
 			CopySelectionRange(&drag);
 			StartDrag();
@@ -5389,6 +4795,12 @@ void Editor::ButtonMove(Point pt) {
 	}
 
 	ptMouseLast = pt;
+	PRectangle rcClient = GetClientRectangle();
+	const Point ptOrigin = GetVisibleOriginInMain();
+	rcClient.Move(0, -ptOrigin.y);
+	if ((dwellDelay < SC_TIME_FOREVER) && rcClient.Contains(pt)) {
+		FineTickerStart(tickDwell, dwellDelay, dwellDelay/10);
+	}
 	//Platform::DebugPrintf("Move %d %d\n", pt.x, pt.y);
 	if (HaveMouseCapture()) {
 
@@ -5399,137 +4811,177 @@ void Editor::ButtonMove(Point pt) {
 		autoScrollTimer.ticksToWait = autoScrollDelay;
 
 		// Adjust selection
-		if (posDrag >= 0) {
+		if (posDrag.IsValid()) {
 			SetDragPosition(movePos);
 		} else {
-			if (selectionType == selChar) {
-				SetSelection(movePos);
-			} else if (selectionType == selWord) {
+			if (selectionUnit == TextUnit::character) {
+				if (sel.selType == Selection::selStream && (modifiers & SCI_ALT) && mouseSelectionRectangularSwitch) {
+					sel.selType = Selection::selRectangle;
+				}
+				if (sel.IsRectangular()) {
+					sel.Rectangular() = SelectionRange(movePos, sel.Rectangular().anchor);
+					SetSelection(movePos, sel.RangeMain().anchor);
+				} else if (sel.Count() > 1) {
+					InvalidateSelection(sel.RangeMain(), false);
+					const SelectionRange range(movePos, sel.RangeMain().anchor);
+					sel.TentativeSelection(range);
+					InvalidateSelection(range, true);
+				} else {
+					SetSelection(movePos, sel.RangeMain().anchor);
+				}
+			} else if (selectionUnit == TextUnit::word) {
 				// Continue selecting by word
-				if (movePos == originalAnchorPos) {	// Didn't move
+				if (movePos.Position() == wordSelectInitialCaretPos) {  // Didn't move
 					// No need to do anything. Previously this case was lumped
 					// in with "Moved forward", but that can be harmful in this
 					// case: a handler for the NotifyDoubleClick re-adjusts
 					// the selection for a fancier definition of "word" (for
 					// example, in Perl it is useful to include the leading
 					// '$', '%' or '@' on variables for word selection). In this
-					// the ButtonMove() called via Tick() for auto-scrolling
+					// the ButtonMove() called via TickFor() for auto-scrolling
 					// could result in the fancier word selection adjustment
 					// being unmade.
-				} else if (movePos > originalAnchorPos) {	// Moved forward
-					SetSelection(pdoc->ExtendWordSelect(movePos, 1),
-					        pdoc->ExtendWordSelect(originalAnchorPos, -1));
-				} else {	// Moved backward
-					SetSelection(pdoc->ExtendWordSelect(movePos, -1),
-					        pdoc->ExtendWordSelect(originalAnchorPos, 1));
+				} else {
+					wordSelectInitialCaretPos = -1;
+					WordSelection(movePos.Position());
 				}
 			} else {
 				// Continue selecting by line
-				int lineMove = LineFromLocation(pt);
-				LineSelection(lineMove, lineAnchor);
+				LineSelection(movePos.Position(), lineAnchorPos, selectionUnit == TextUnit::wholeLine);
 			}
 		}
-		// While dragging to make rectangular selection, we don't want the current
-		// position to jump to the end of smaller or empty lines.
-		//xEndSelect = pt.x - vs.fixedColumnWidth + xOffset;
-		xEndSelect = XFromPosition(movePos);
 
 		// Autoscroll
-		PRectangle rcClient = GetClientRectangle();
-		if (pt.y > rcClient.bottom) {
-			int lineMove = cs.DisplayFromDoc(LineFromLocation(pt));
-			if (lineMove < 0) {
-				lineMove = cs.DisplayFromDoc(pdoc->LinesTotal() - 1);
-			}
+		const Sci::Line lineMove = DisplayFromPosition(movePos.Position());
+		if (pt.y >= rcClient.bottom) {
 			ScrollTo(lineMove - LinesOnScreen() + 1);
 			Redraw();
 		} else if (pt.y < rcClient.top) {
-			int lineMove = cs.DisplayFromDoc(LineFromLocation(pt));
-			ScrollTo(lineMove - 1);
+			ScrollTo(lineMove);
 			Redraw();
 		}
 		EnsureCaretVisible(false, false, true);
 
-		if (hsStart != -1 && !PositionIsHotspot(movePos))
-			SetHotSpotRange(NULL);
+		if (hotspot.Valid() && !PointIsHotspot(pt))
+			SetHotSpotRange(nullptr);
+
+		if (hotSpotClickPos != INVALID_POSITION && PositionFromLocation(pt, true, true) != hotSpotClickPos) {
+			if (inDragDrop == ddNone) {
+				DisplayCursor(Window::cursorText);
+			}
+			hotSpotClickPos = INVALID_POSITION;
+		}
 
 	} else {
 		if (vs.fixedColumnWidth > 0) {	// There is a margin
 			if (PointInSelMargin(pt)) {
-				DisplayCursor(Window::cursorReverseArrow);
+				DisplayCursor(GetMarginCursor(pt));
+				SetHotSpotRange(nullptr);
+				SetHoverIndicatorPosition(Sci::invalidPosition);
 				return; 	// No need to test for selection
 			}
 		}
 		// Display regular (drag) cursor over selection
 		if (PointInSelection(pt) && !SelectionEmpty()) {
 			DisplayCursor(Window::cursorArrow);
-		} else if (PointIsHotspot(pt)) {
-			DisplayCursor(Window::cursorHand);
-			SetHotSpotRange(&pt);
+			SetHoverIndicatorPosition(Sci::invalidPosition);
 		} else {
-			DisplayCursor(Window::cursorText);
-			SetHotSpotRange(NULL);
+			SetHoverIndicatorPoint(pt);
+			if (PointIsHotspot(pt)) {
+				DisplayCursor(Window::cursorHand);
+				SetHotSpotRange(&pt);
+			} else {
+				if (hoverIndicatorPos != Sci::invalidPosition)
+					DisplayCursor(Window::cursorHand);
+				else
+					DisplayCursor(Window::cursorText);
+				SetHotSpotRange(nullptr);
+			}
 		}
 	}
 }
 
-void Editor::ButtonUp(Point pt, unsigned int curTime, bool ctrl) {
+void Editor::ButtonUpWithModifiers(Point pt, unsigned int curTime, int modifiers) {
 	//Platform::DebugPrintf("ButtonUp %d %d\n", HaveMouseCapture(), inDragDrop);
-	int newPos = PositionFromLocation(pt);
-	newPos = MovePositionOutsideChar(newPos, currentPos - newPos);
+	SelectionPosition newPos = SPositionFromLocation(pt, false, false,
+		AllowVirtualSpace(virtualSpaceOptions, sel.IsRectangular()));
+	if (hoverIndicatorPos != INVALID_POSITION)
+		InvalidateRange(newPos.Position(), newPos.Position() + 1);
+	newPos = MovePositionOutsideChar(newPos, sel.MainCaret() - newPos.Position());
 	if (inDragDrop == ddInitial) {
 		inDragDrop = ddNone;
 		SetEmptySelection(newPos);
+		selectionUnit = TextUnit::character;
+		originalAnchorPos = sel.MainCaret();
+	}
+	if (hotSpotClickPos != INVALID_POSITION && PointIsHotspot(pt)) {
+		hotSpotClickPos = INVALID_POSITION;
+		SelectionPosition newCharPos = SPositionFromLocation(pt, false, true, false);
+		newCharPos = MovePositionOutsideChar(newCharPos, -1);
+		NotifyHotSpotReleaseClick(newCharPos.Position(), modifiers & SCI_CTRL);
 	}
 	if (HaveMouseCapture()) {
 		if (PointInSelMargin(pt)) {
-			DisplayCursor(Window::cursorReverseArrow);
+			DisplayCursor(GetMarginCursor(pt));
 		} else {
 			DisplayCursor(Window::cursorText);
-			SetHotSpotRange(NULL);
+			SetHotSpotRange(nullptr);
 		}
 		ptMouseLast = pt;
 		SetMouseCapture(false);
-		int newPos = PositionFromLocation(pt);
-		newPos = MovePositionOutsideChar(newPos, currentPos - newPos);
-		NotifyIndicatorClick(false, newPos, false, false, false);
+		FineTickerCancel(tickScroll);
+		NotifyIndicatorClick(false, newPos.Position(), 0);
 		if (inDragDrop == ddDragging) {
-			int selStart = SelectionStart();
-			int selEnd = SelectionEnd();
+			const SelectionPosition selStart = SelectionStart();
+			const SelectionPosition selEnd = SelectionEnd();
 			if (selStart < selEnd) {
-				if (drag.len) {
-					if (ctrl) {
-						if (pdoc->InsertString(newPos, drag.s, drag.len)) {
-							SetSelection(newPos, newPos + drag.len);
+				if (drag.Length()) {
+					const Sci::Position length = drag.Length();
+					if (modifiers & SCI_CTRL) {
+						const Sci::Position lengthInserted = pdoc->InsertString(
+							newPos.Position(), drag.Data(), length);
+						if (lengthInserted > 0) {
+							SetSelection(newPos.Position(), newPos.Position() + lengthInserted);
 						}
 					} else if (newPos < selStart) {
-						pdoc->DeleteChars(selStart, drag.len);
-						if (pdoc->InsertString(newPos, drag.s, drag.len)) {
-							SetSelection(newPos, newPos + drag.len);
+						pdoc->DeleteChars(selStart.Position(), drag.Length());
+						const Sci::Position lengthInserted = pdoc->InsertString(
+							newPos.Position(), drag.Data(), length);
+						if (lengthInserted > 0) {
+							SetSelection(newPos.Position(), newPos.Position() + lengthInserted);
 						}
 					} else if (newPos > selEnd) {
-						pdoc->DeleteChars(selStart, drag.len);
-						newPos -= drag.len;
-						if (pdoc->InsertString(newPos, drag.s, drag.len)) {
-							SetSelection(newPos, newPos + drag.len);
+						pdoc->DeleteChars(selStart.Position(), drag.Length());
+						newPos.Add(-static_cast<Sci::Position>(drag.Length()));
+						const Sci::Position lengthInserted = pdoc->InsertString(
+							newPos.Position(), drag.Data(), length);
+						if (lengthInserted > 0) {
+							SetSelection(newPos.Position(), newPos.Position() + lengthInserted);
 						}
 					} else {
-						SetEmptySelection(newPos);
+						SetEmptySelection(newPos.Position());
 					}
-					drag.Free();
+					drag.Clear();
 				}
-				selectionType = selChar;
+				selectionUnit = TextUnit::character;
 			}
 		} else {
-			if (selectionType == selChar) {
-				SetSelection(newPos);
+			if (selectionUnit == TextUnit::character) {
+				if (sel.Count() > 1) {
+					sel.RangeMain() =
+						SelectionRange(newPos, sel.Range(sel.Count() - 1).anchor);
+					InvalidateWholeSelection();
+				} else {
+					SetSelection(newPos, sel.RangeMain().anchor);
+				}
 			}
+			sel.CommitTentative();
 		}
 		SetRectangularRange();
 		lastClickTime = curTime;
 		lastClick = pt;
-		lastXChosen = pt.x;
-		if (selType == selStream) {
+		lastXChosen = static_cast<int>(pt.x) + xOffset;
+		if (sel.selType == Selection::selStream) {
 			SetLastXChosen();
 		}
 		inDragDrop = ddNone;
@@ -5537,71 +4989,189 @@ void Editor::ButtonUp(Point pt, unsigned int curTime, bool ctrl) {
 	}
 }
 
-// Called frequently to perform background UI including
-// caret blinking and automatic scrolling.
-void Editor::Tick() {
-	if (HaveMouseCapture()) {
-		// Auto scroll
-		ButtonMove(ptMouseLast);
-	}
-	if (caret.period > 0) {
-		timer.ticksToWait -= timer.tickSize;
-		if (timer.ticksToWait <= 0) {
-			caret.on = !caret.on;
-			timer.ticksToWait = caret.period;
-			if (caret.active) {
-				InvalidateCaret();
-			}
-		}
-	}
-	if (horizontalScrollBarVisible && trackLineWidth && (lineWidthMaxSeen > scrollWidth)) {
-		scrollWidth = lineWidthMaxSeen;
-		SetScrollBars();
-	}
-	if ((dwellDelay < SC_TIME_FOREVER) &&
-	        (ticksToDwell > 0) &&
-	        (!HaveMouseCapture())) {
-		ticksToDwell -= timer.tickSize;
-		if (ticksToDwell <= 0) {
-			dwelling = true;
-			NotifyDwelling(ptMouseLast, dwelling);
-		}
-	}
-}
-
 bool Editor::Idle() {
+	NotifyUpdateUI();
 
-	bool idleDone;
+	bool needWrap = Wrapping() && wrapPending.NeedsWrap();
 
-	bool wrappingDone = wrapState == eWrapNone;
-
-	if (!wrappingDone) {
+	if (needWrap) {
 		// Wrap lines during idle.
-		WrapLines(false, -1);
+		WrapLines(WrapScope::wsIdle);
 		// No more wrapping
-		if (wrapStart == wrapEnd)
-			wrappingDone = true;
+		needWrap = wrapPending.NeedsWrap();
+	} else if (needIdleStyling) {
+		IdleStyling();
 	}
 
 	// Add more idle things to do here, but make sure idleDone is
 	// set correctly before the function returns. returning
-	// false will stop calling this idle funtion until SetIdle() is
+	// false will stop calling this idle function until SetIdle() is
 	// called again.
 
-	idleDone = wrappingDone; // && thatDone && theOtherThingDone...
+	const bool idleDone = !needWrap && !needIdleStyling; // && thatDone && theOtherThingDone...
 
 	return !idleDone;
 }
 
+void Editor::TickFor(TickReason reason) {
+	switch (reason) {
+		case tickCaret:
+			caret.on = !caret.on;
+			if (caret.active) {
+				InvalidateCaret();
+			}
+			break;
+		case tickScroll:
+			// Auto scroll
+			ButtonMoveWithModifiers(ptMouseLast, 0, 0);
+			break;
+		case tickWiden:
+			SetScrollBars();
+			FineTickerCancel(tickWiden);
+			break;
+		case tickDwell:
+			if ((!HaveMouseCapture()) &&
+				(ptMouseLast.y >= 0)) {
+				dwelling = true;
+				NotifyDwelling(ptMouseLast, dwelling);
+			}
+			FineTickerCancel(tickDwell);
+			break;
+		default:
+			// tickPlatform handled by subclass
+			break;
+	}
+}
+
+// FineTickerStart is be overridden by subclasses that support fine ticking so
+// this method should never be called.
+bool Editor::FineTickerRunning(TickReason) {
+	assert(false);
+	return false;
+}
+
+// FineTickerStart is be overridden by subclasses that support fine ticking so
+// this method should never be called.
+void Editor::FineTickerStart(TickReason, int, int) {
+	assert(false);
+}
+
+// FineTickerCancel is be overridden by subclasses that support fine ticking so
+// this method should never be called.
+void Editor::FineTickerCancel(TickReason) {
+	assert(false);
+}
+
 void Editor::SetFocusState(bool focusState) {
 	hasFocus = focusState;
 	NotifyFocus(hasFocus);
-	if (hasFocus) {
-		ShowCaretAtCurrentPosition();
-	} else {
+	if (!hasFocus) {
 		CancelModes();
-		DropCaret();
 	}
+	ShowCaretAtCurrentPosition();
+}
+
+Sci::Position Editor::PositionAfterArea(PRectangle rcArea) const {
+	// The start of the document line after the display line after the area
+	// This often means that the line after a modification is restyled which helps
+	// detect multiline comment additions and heals single line comments
+	const Sci::Line lineAfter = TopLineOfMain() + static_cast<Sci::Line>(rcArea.bottom - 1) / vs.lineHeight + 1;
+	if (lineAfter < pcs->LinesDisplayed())
+		return pdoc->LineStart(pcs->DocFromDisplay(lineAfter) + 1);
+	else
+		return pdoc->Length();
+}
+
+// Style to a position within the view. If this causes a change at end of last line then
+// affects later lines so style all the viewed text.
+void Editor::StyleToPositionInView(Sci::Position pos) {
+	Sci::Position endWindow = PositionAfterArea(GetClientDrawingRectangle());
+	if (pos > endWindow)
+		pos = endWindow;
+	const int styleAtEnd = pdoc->StyleIndexAt(pos-1);
+	pdoc->EnsureStyledTo(pos);
+	if ((endWindow > pos) && (styleAtEnd != pdoc->StyleIndexAt(pos-1))) {
+		// Style at end of line changed so is multi-line change like starting a comment
+		// so require rest of window to be styled.
+		DiscardOverdraw();	// Prepared bitmaps may be invalid
+		// DiscardOverdraw may have truncated client drawing area so recalculate endWindow
+		endWindow = PositionAfterArea(GetClientDrawingRectangle());
+		pdoc->EnsureStyledTo(endWindow);
+	}
+}
+
+Sci::Position Editor::PositionAfterMaxStyling(Sci::Position posMax, bool scrolling) const {
+	if (SynchronousStylingToVisible()) {
+		// Both states do not limit styling
+		return posMax;
+	}
+
+	// Try to keep time taken by styling reasonable so interaction remains smooth.
+	// When scrolling, allow less time to ensure responsive
+	const double secondsAllowed = scrolling ? 0.005 : 0.02;
+
+	const Sci::Line linesToStyle = std::clamp(
+		static_cast<int>(secondsAllowed / pdoc->durationStyleOneLine.Duration()),
+		10, 0x10000);
+	const Sci::Line stylingMaxLine = std::min(
+		pdoc->SciLineFromPosition(pdoc->GetEndStyled()) + linesToStyle,
+		pdoc->LinesTotal());
+	return std::min(pdoc->LineStart(stylingMaxLine), posMax);
+}
+
+void Editor::StartIdleStyling(bool truncatedLastStyling) {
+	if ((idleStyling == SC_IDLESTYLING_ALL) || (idleStyling == SC_IDLESTYLING_AFTERVISIBLE)) {
+		if (pdoc->GetEndStyled() < pdoc->Length()) {
+			// Style remainder of document in idle time
+			needIdleStyling = true;
+		}
+	} else if (truncatedLastStyling) {
+		needIdleStyling = true;
+	}
+
+	if (needIdleStyling) {
+		SetIdle(true);
+	}
+}
+
+// Style for an area but bound the amount of styling to remain responsive
+void Editor::StyleAreaBounded(PRectangle rcArea, bool scrolling) {
+	const Sci::Position posAfterArea = PositionAfterArea(rcArea);
+	const Sci::Position posAfterMax = PositionAfterMaxStyling(posAfterArea, scrolling);
+	if (posAfterMax < posAfterArea) {
+		// Idle styling may be performed before current visible area
+		// Style a bit now then style further in idle time
+		pdoc->StyleToAdjustingLineDuration(posAfterMax);
+	} else {
+		// Can style all wanted now.
+		StyleToPositionInView(posAfterArea);
+	}
+	StartIdleStyling(posAfterMax < posAfterArea);
+}
+
+void Editor::IdleStyling() {
+	const Sci::Position posAfterArea = PositionAfterArea(GetClientRectangle());
+	const Sci::Position endGoal = (idleStyling >= SC_IDLESTYLING_AFTERVISIBLE) ?
+		pdoc->Length() : posAfterArea;
+	const Sci::Position posAfterMax = PositionAfterMaxStyling(endGoal, false);
+	pdoc->StyleToAdjustingLineDuration(posAfterMax);
+	if (pdoc->GetEndStyled() >= endGoal) {
+		needIdleStyling = false;
+	}
+}
+
+void Editor::IdleWork() {
+	// Style the line after the modification as this allows modifications that change just the
+	// line of the modification to heal instead of propagating to the rest of the window.
+	if (workNeeded.items & WorkNeeded::workStyle) {
+		StyleToPositionInView(pdoc->LineStart(pdoc->LineFromPosition(workNeeded.upTo) + 2));
+	}
+	NotifyUpdateUI();
+	workNeeded.Reset();
+}
+
+void Editor::QueueIdleWork(WorkNeeded::workItems items, Sci::Position upTo) {
+	workNeeded.Need(items, upTo);
 }
 
 bool Editor::PaintContains(PRectangle rc) {
@@ -5613,8 +5183,13 @@ bool Editor::PaintContains(PRectangle rc) {
 }
 
 bool Editor::PaintContainsMargin() {
+	if (wMargin.GetID()) {
+		// With separate margin view, paint of text view
+		// never contains margin.
+		return false;
+	}
 	PRectangle rcSelMargin = GetClientRectangle();
-	rcSelMargin.right = vs.fixedColumnWidth;
+	rcSelMargin.right = static_cast<XYPOSITION>(vs.textStart);
 	return PaintContains(rcSelMargin);
 }
 
@@ -5624,8 +5199,8 @@ void Editor::CheckForChangeOutsidePaint(Range r) {
 		if (!r.Valid())
 			return;
 
-		PRectangle rcRange = RectangleFromRange(r.start, r.end);
-		PRectangle rcText = GetTextRectangle();
+		PRectangle rcRange = RectangleFromRange(r, 0);
+		const PRectangle rcText = GetTextRectangle();
 		if (rcRange.top < rcText.top) {
 			rcRange.top = rcText.top;
 		}
@@ -5635,11 +5210,12 @@ void Editor::CheckForChangeOutsidePaint(Range r) {
 
 		if (!PaintContains(rcRange)) {
 			AbandonPaint();
+			paintAbandonedByStyling = true;
 		}
 	}
 }
 
-void Editor::SetBraceHighlight(Position pos0, Position pos1, int matchStyle) {
+void Editor::SetBraceHighlight(Sci::Position pos0, Sci::Position pos1, int matchStyle) {
 	if ((pos0 != braces[0]) || (pos1 != braces[1]) || (matchStyle != bracesMatchStyle)) {
 		if ((braces[0] != pos0) || (matchStyle != bracesMatchStyle)) {
 			CheckForChangeOutsidePaint(Range(braces[0]));
@@ -5658,135 +5234,250 @@ void Editor::SetBraceHighlight(Position pos0, Position pos1, int matchStyle) {
 	}
 }
 
+void Editor::SetAnnotationHeights(Sci::Line start, Sci::Line end) {
+	if (vs.annotationVisible) {
+		RefreshStyleData();
+		bool changedHeight = false;
+		for (Sci::Line line=start; line<end && line<pdoc->LinesTotal(); line++) {
+			int linesWrapped = 1;
+			if (Wrapping()) {
+				AutoSurface surface(this);
+				AutoLineLayout ll(view.llc, view.RetrieveLineLayout(line, *this));
+				if (surface && ll) {
+					view.LayoutLine(*this, line, surface, vs, ll, wrapWidth);
+					linesWrapped = ll->lines;
+				}
+			}
+			if (pcs->SetHeight(line, pdoc->AnnotationLines(line) + linesWrapped))
+				changedHeight = true;
+		}
+		if (changedHeight) {
+			Redraw();
+		}
+	}
+}
+
 void Editor::SetDocPointer(Document *document) {
 	//Platform::DebugPrintf("** %x setdoc to %x\n", pdoc, document);
 	pdoc->RemoveWatcher(this, 0);
 	pdoc->Release();
-	if (document == NULL) {
-		pdoc = new Document();
+	if (!document) {
+		pdoc = new Document(SC_DOCUMENTOPTION_DEFAULT);
 	} else {
 		pdoc = document;
 	}
 	pdoc->AddRef();
+	pcs = ContractionStateCreate(pdoc->IsLarge());
 
 	// Ensure all positions within document
-	selType = selStream;
-	currentPos = 0;
-	anchor = 0;
-	targetStart = 0;
-	targetEnd = 0;
+	sel.Clear();
+	targetRange = SelectionSegment();
+
+	braces[0] = Sci::invalidPosition;
+	braces[1] = Sci::invalidPosition;
 
-	braces[0] = invalidPosition;
-	braces[1] = invalidPosition;
+	vs.ReleaseAllExtendedStyles();
+
+	SetRepresentations();
 
 	// Reset the contraction state to fully shown.
-	cs.Clear();
-	cs.InsertLines(0, pdoc->LinesTotal() - 1);
-	llc.Deallocate();
+	pcs->Clear();
+	pcs->InsertLines(0, pdoc->LinesTotal() - 1);
+	SetAnnotationHeights(0, pdoc->LinesTotal());
+	view.llc.Deallocate();
 	NeedWrapping();
 
+	hotspot = Range(Sci::invalidPosition);
+	hoverIndicatorPos = Sci::invalidPosition;
+
+	view.ClearAllTabstops();
+
 	pdoc->AddWatcher(this, 0);
 	SetScrollBars();
 	Redraw();
 }
 
+void Editor::SetAnnotationVisible(int visible) {
+	if (vs.annotationVisible != visible) {
+		const bool changedFromOrToHidden = ((vs.annotationVisible != 0) != (visible != 0));
+		vs.annotationVisible = visible;
+		if (changedFromOrToHidden) {
+			const int dir = vs.annotationVisible ? 1 : -1;
+			for (Sci::Line line=0; line<pdoc->LinesTotal(); line++) {
+				const int annotationLines = pdoc->AnnotationLines(line);
+				if (annotationLines > 0) {
+					pcs->SetHeight(line, pcs->GetHeight(line) + annotationLines * dir);
+				}
+			}
+			SetScrollBars();
+		}
+		Redraw();
+	}
+}
+
+void Editor::SetEOLAnnotationVisible(int visible) {
+	if (vs.eolAnnotationVisible != visible) {
+		vs.eolAnnotationVisible = visible;
+		Redraw();
+	}
+}
+
 /**
  * Recursively expand a fold, making lines visible except where they have an unexpanded parent.
  */
-void Editor::Expand(int &line, bool doExpand) {
-	int lineMaxSubord = pdoc->GetLastChild(line);
+Sci::Line Editor::ExpandLine(Sci::Line line) {
+	const Sci::Line lineMaxSubord = pdoc->GetLastChild(line);
 	line++;
 	while (line <= lineMaxSubord) {
-		if (doExpand)
-			cs.SetVisible(line, line, true);
-		int level = pdoc->GetLevel(line);
+		pcs->SetVisible(line, line, true);
+		const int level = pdoc->GetLevel(line);
 		if (level & SC_FOLDLEVELHEADERFLAG) {
-			if (doExpand && cs.GetExpanded(line)) {
-				Expand(line, true);
+			if (pcs->GetExpanded(line)) {
+				line = ExpandLine(line);
 			} else {
-				Expand(line, false);
+				line = pdoc->GetLastChild(line);
 			}
-		} else {
-			line++;
 		}
+		line++;
+	}
+	return lineMaxSubord;
+}
+
+void Editor::SetFoldExpanded(Sci::Line lineDoc, bool expanded) {
+	if (pcs->SetExpanded(lineDoc, expanded)) {
+		RedrawSelMargin();
 	}
 }
 
-void Editor::ToggleContraction(int line) {
+void Editor::FoldLine(Sci::Line line, int action) {
 	if (line >= 0) {
-		if ((pdoc->GetLevel(line) & SC_FOLDLEVELHEADERFLAG) == 0) {
-			line = pdoc->GetFoldParent(line);
-			if (line < 0)
-				return;
+		if (action == SC_FOLDACTION_TOGGLE) {
+			if ((pdoc->GetLevel(line) & SC_FOLDLEVELHEADERFLAG) == 0) {
+				line = pdoc->GetFoldParent(line);
+				if (line < 0)
+					return;
+			}
+			action = (pcs->GetExpanded(line)) ? SC_FOLDACTION_CONTRACT : SC_FOLDACTION_EXPAND;
 		}
 
-		if (cs.GetExpanded(line)) {
-			int lineMaxSubord = pdoc->GetLastChild(line);
-			cs.SetExpanded(line, 0);
+		if (action == SC_FOLDACTION_CONTRACT) {
+			const Sci::Line lineMaxSubord = pdoc->GetLastChild(line);
 			if (lineMaxSubord > line) {
-				cs.SetVisible(line + 1, lineMaxSubord, false);
+				pcs->SetExpanded(line, false);
+				pcs->SetVisible(line + 1, lineMaxSubord, false);
 
-				int lineCurrent = pdoc->LineFromPosition(currentPos);
+				const Sci::Line lineCurrent =
+					pdoc->SciLineFromPosition(sel.MainCaret());
 				if (lineCurrent > line && lineCurrent <= lineMaxSubord) {
 					// This does not re-expand the fold
 					EnsureCaretVisible();
 				}
-
-				SetScrollBars();
-				Redraw();
 			}
 
 		} else {
-			if (!(cs.GetVisible(line))) {
+			if (!(pcs->GetVisible(line))) {
 				EnsureLineVisible(line, false);
 				GoToLine(line);
 			}
-			cs.SetExpanded(line, 1);
-			Expand(line, true);
-			SetScrollBars();
-			Redraw();
+			pcs->SetExpanded(line, true);
+			ExpandLine(line);
+		}
+
+		SetScrollBars();
+		Redraw();
+	}
+}
+
+void Editor::FoldExpand(Sci::Line line, int action, int level) {
+	bool expanding = action == SC_FOLDACTION_EXPAND;
+	if (action == SC_FOLDACTION_TOGGLE) {
+		expanding = !pcs->GetExpanded(line);
+	}
+	// Ensure child lines lexed and fold information extracted before
+	// flipping the state.
+	pdoc->GetLastChild(line, LevelNumber(level));
+	SetFoldExpanded(line, expanding);
+	if (expanding && (pcs->HiddenLines() == 0))
+		// Nothing to do
+		return;
+	const Sci::Line lineMaxSubord = pdoc->GetLastChild(line, LevelNumber(level));
+	line++;
+	pcs->SetVisible(line, lineMaxSubord, expanding);
+	while (line <= lineMaxSubord) {
+		const int levelLine = pdoc->GetLevel(line);
+		if (levelLine & SC_FOLDLEVELHEADERFLAG) {
+			SetFoldExpanded(line, expanding);
 		}
+		line++;
+	}
+	SetScrollBars();
+	Redraw();
+}
+
+Sci::Line Editor::ContractedFoldNext(Sci::Line lineStart) const {
+	for (Sci::Line line = lineStart; line<pdoc->LinesTotal();) {
+		if (!pcs->GetExpanded(line) && (pdoc->GetLevel(line) & SC_FOLDLEVELHEADERFLAG))
+			return line;
+		line = pcs->ContractedNext(line+1);
+		if (line < 0)
+			return -1;
 	}
+
+	return -1;
 }
 
 /**
  * Recurse up from this line to find any folds that prevent this line from being visible
  * and unfold them all.
  */
-void Editor::EnsureLineVisible(int lineDoc, bool enforcePolicy) {
+void Editor::EnsureLineVisible(Sci::Line lineDoc, bool enforcePolicy) {
 
 	// In case in need of wrapping to ensure DisplayFromDoc works.
-	WrapLines(true, -1);
+	if (lineDoc >= wrapPending.start) {
+		if (WrapLines(WrapScope::wsAll)) {
+			Redraw();
+		}
+	}
 
-	if (!cs.GetVisible(lineDoc)) {
-		int lineParent = pdoc->GetFoldParent(lineDoc);
+	if (!pcs->GetVisible(lineDoc)) {
+		// Back up to find a non-blank line
+		Sci::Line lookLine = lineDoc;
+		int lookLineLevel = pdoc->GetLevel(lookLine);
+		while ((lookLine > 0) && (lookLineLevel & SC_FOLDLEVELWHITEFLAG)) {
+			lookLineLevel = pdoc->GetLevel(--lookLine);
+		}
+		Sci::Line lineParent = pdoc->GetFoldParent(lookLine);
+		if (lineParent < 0) {
+			// Backed up to a top level line, so try to find parent of initial line
+			lineParent = pdoc->GetFoldParent(lineDoc);
+		}
 		if (lineParent >= 0) {
 			if (lineDoc != lineParent)
 				EnsureLineVisible(lineParent, enforcePolicy);
-			if (!cs.GetExpanded(lineParent)) {
-				cs.SetExpanded(lineParent, 1);
-				Expand(lineParent, true);
+			if (!pcs->GetExpanded(lineParent)) {
+				pcs->SetExpanded(lineParent, true);
+				ExpandLine(lineParent);
 			}
 		}
 		SetScrollBars();
 		Redraw();
 	}
 	if (enforcePolicy) {
-		int lineDisplay = cs.DisplayFromDoc(lineDoc);
-		if (visiblePolicy & VISIBLE_SLOP) {
-			if ((topLine > lineDisplay) || ((visiblePolicy & VISIBLE_STRICT) && (topLine + visibleSlop > lineDisplay))) {
-				SetTopLine(Platform::Clamp(lineDisplay - visibleSlop, 0, MaxScrollPos()));
+		const Sci::Line lineDisplay = pcs->DisplayFromDoc(lineDoc);
+		if (visiblePolicy.policy & VISIBLE_SLOP) {
+			if ((topLine > lineDisplay) || ((visiblePolicy.policy & VISIBLE_STRICT) && (topLine + visiblePolicy.slop > lineDisplay))) {
+				SetTopLine(std::clamp<Sci::Line>(lineDisplay - visiblePolicy.slop, 0, MaxScrollPos()));
 				SetVerticalScrollPos();
 				Redraw();
 			} else if ((lineDisplay > topLine + LinesOnScreen() - 1) ||
-			        ((visiblePolicy & VISIBLE_STRICT) && (lineDisplay > topLine + LinesOnScreen() - 1 - visibleSlop))) {
-				SetTopLine(Platform::Clamp(lineDisplay - LinesOnScreen() + 1 + visibleSlop, 0, MaxScrollPos()));
+			        ((visiblePolicy.policy & VISIBLE_STRICT) && (lineDisplay > topLine + LinesOnScreen() - 1 - visiblePolicy.slop))) {
+				SetTopLine(std::clamp<Sci::Line>(lineDisplay - LinesOnScreen() + 1 + visiblePolicy.slop, 0, MaxScrollPos()));
 				SetVerticalScrollPos();
 				Redraw();
 			}
 		} else {
-			if ((topLine > lineDisplay) || (lineDisplay > topLine + LinesOnScreen() - 1) || (visiblePolicy & VISIBLE_STRICT)) {
-				SetTopLine(Platform::Clamp(lineDisplay - LinesOnScreen() / 2 + 1, 0, MaxScrollPos()));
+			if ((topLine > lineDisplay) || (lineDisplay > topLine + LinesOnScreen() - 1) || (visiblePolicy.policy & VISIBLE_STRICT)) {
+				SetTopLine(std::clamp<Sci::Line>(lineDisplay - LinesOnScreen() / 2 + 1, 0, MaxScrollPos()));
 				SetVerticalScrollPos();
 				Redraw();
 			}
@@ -5794,88 +5485,209 @@ void Editor::EnsureLineVisible(int lineDoc, bool enforcePolicy) {
 	}
 }
 
-int Editor::ReplaceTarget(bool replacePatterns, const char *text, int length) {
-	pdoc->BeginUndoAction();
+void Editor::FoldAll(int action) {
+	pdoc->EnsureStyledTo(pdoc->Length());
+	const Sci::Line maxLine = pdoc->LinesTotal();
+	bool expanding = action == SC_FOLDACTION_EXPAND;
+	if (action == SC_FOLDACTION_TOGGLE) {
+		// Discover current state
+		for (int lineSeek = 0; lineSeek < maxLine; lineSeek++) {
+			if (pdoc->GetLevel(lineSeek) & SC_FOLDLEVELHEADERFLAG) {
+				expanding = !pcs->GetExpanded(lineSeek);
+				break;
+			}
+		}
+	}
+	if (expanding) {
+		pcs->SetVisible(0, maxLine-1, true);
+		for (int line = 0; line < maxLine; line++) {
+			const int levelLine = pdoc->GetLevel(line);
+			if (levelLine & SC_FOLDLEVELHEADERFLAG) {
+				SetFoldExpanded(line, true);
+			}
+		}
+	} else {
+		for (Sci::Line line = 0; line < maxLine; line++) {
+			const int level = pdoc->GetLevel(line);
+			if ((level & SC_FOLDLEVELHEADERFLAG) &&
+					(SC_FOLDLEVELBASE == LevelNumber(level))) {
+				SetFoldExpanded(line, false);
+				const Sci::Line lineMaxSubord = pdoc->GetLastChild(line, -1);
+				if (lineMaxSubord > line) {
+					pcs->SetVisible(line + 1, lineMaxSubord, false);
+				}
+			}
+		}
+	}
+	SetScrollBars();
+	Redraw();
+}
+
+void Editor::FoldChanged(Sci::Line line, int levelNow, int levelPrev) {
+	if (levelNow & SC_FOLDLEVELHEADERFLAG) {
+		if (!(levelPrev & SC_FOLDLEVELHEADERFLAG)) {
+			// Adding a fold point.
+			if (pcs->SetExpanded(line, true)) {
+				RedrawSelMargin();
+			}
+			FoldExpand(line, SC_FOLDACTION_EXPAND, levelPrev);
+		}
+	} else if (levelPrev & SC_FOLDLEVELHEADERFLAG) {
+		const Sci::Line prevLine = line - 1;
+		const int prevLineLevel = pdoc->GetLevel(prevLine);
+
+		// Combining two blocks where the first block is collapsed (e.g. by deleting the line(s) which separate(s) the two blocks)
+		if ((LevelNumber(prevLineLevel) == LevelNumber(levelNow)) && !pcs->GetVisible(prevLine))
+			FoldLine(pdoc->GetFoldParent(prevLine), SC_FOLDACTION_EXPAND);
+
+		if (!pcs->GetExpanded(line)) {
+			// Removing the fold from one that has been contracted so should expand
+			// otherwise lines are left invisible with no way to make them visible
+			if (pcs->SetExpanded(line, true)) {
+				RedrawSelMargin();
+			}
+			// Combining two blocks where the second one is collapsed (e.g. by adding characters in the line which separates the two blocks)
+			FoldExpand(line, SC_FOLDACTION_EXPAND, levelPrev);
+		}
+	}
+	if (!(levelNow & SC_FOLDLEVELWHITEFLAG) &&
+	        (LevelNumber(levelPrev) > LevelNumber(levelNow))) {
+		if (pcs->HiddenLines()) {
+			// See if should still be hidden
+			const Sci::Line parentLine = pdoc->GetFoldParent(line);
+			if ((parentLine < 0) || (pcs->GetExpanded(parentLine) && pcs->GetVisible(parentLine))) {
+				pcs->SetVisible(line, line, true);
+				SetScrollBars();
+				Redraw();
+			}
+		}
+	}
+
+	// Combining two blocks where the first one is collapsed (e.g. by adding characters in the line which separates the two blocks)
+	if (!(levelNow & SC_FOLDLEVELWHITEFLAG) && (LevelNumber(levelPrev) < LevelNumber(levelNow))) {
+		if (pcs->HiddenLines()) {
+			const Sci::Line parentLine = pdoc->GetFoldParent(line);
+			if (!pcs->GetExpanded(parentLine) && pcs->GetVisible(line))
+				FoldLine(parentLine, SC_FOLDACTION_EXPAND);
+		}
+	}
+}
+
+void Editor::NeedShown(Sci::Position pos, Sci::Position len) {
+	if (foldAutomatic & SC_AUTOMATICFOLD_SHOW) {
+		const Sci::Line lineStart = pdoc->SciLineFromPosition(pos);
+		const Sci::Line lineEnd = pdoc->SciLineFromPosition(pos+len);
+		for (Sci::Line line = lineStart; line <= lineEnd; line++) {
+			EnsureLineVisible(line, false);
+		}
+	} else {
+		NotifyNeedShown(pos, len);
+	}
+}
+
+Sci::Position Editor::GetTag(char *tagValue, int tagNumber) {
+	const char *text = nullptr;
+	Sci::Position length = 0;
+	if ((tagNumber >= 1) && (tagNumber <= 9)) {
+		char name[3] = "\\?";
+		name[1] = static_cast<char>(tagNumber + '0');
+		length = 2;
+		text = pdoc->SubstituteByPosition(name, &length);
+	}
+	if (tagValue) {
+		if (text)
+			memcpy(tagValue, text, length + 1);
+		else
+			*tagValue = '\0';
+	}
+	return length;
+}
+
+Sci::Position Editor::ReplaceTarget(bool replacePatterns, const char *text, Sci::Position length) {
+	UndoGroup ug(pdoc);
 	if (length == -1)
-		length = istrlen(text);
+		length = strlen(text);
 	if (replacePatterns) {
 		text = pdoc->SubstituteByPosition(text, &length);
 		if (!text) {
-			pdoc->EndUndoAction();
 			return 0;
 		}
 	}
-	if (targetStart != targetEnd)
-		pdoc->DeleteChars(targetStart, targetEnd - targetStart);
-	targetEnd = targetStart;
-	pdoc->InsertString(targetStart, text, length);
-	targetEnd = targetStart + length;
-	pdoc->EndUndoAction();
+
+	// Remove the text inside the range
+	if (targetRange.Length() > 0)
+		pdoc->DeleteChars(targetRange.start.Position(), targetRange.Length());
+	targetRange.end = targetRange.start;
+
+	// Realize virtual space of target start
+	const Sci::Position startAfterSpaceInsertion = RealizeVirtualSpace(targetRange.start.Position(), targetRange.start.VirtualSpace());
+	targetRange.start.SetPosition(startAfterSpaceInsertion);
+	targetRange.end = targetRange.start;
+
+	// Insert the new text
+	const Sci::Position lengthInserted = pdoc->InsertString(targetRange.start.Position(), text, length);
+	targetRange.end.SetPosition(targetRange.start.Position() + lengthInserted);
 	return length;
 }
 
-bool Editor::IsUnicodeMode() const {
+bool Editor::IsUnicodeMode() const noexcept {
 	return pdoc && (SC_CP_UTF8 == pdoc->dbcsCodePage);
 }
 
-int Editor::CodePage() const {
+int Editor::CodePage() const noexcept {
 	if (pdoc)
 		return pdoc->dbcsCodePage;
 	else
 		return 0;
 }
 
-int Editor::WrapCount(int line) {
+Sci::Line Editor::WrapCount(Sci::Line line) {
 	AutoSurface surface(this);
-	AutoLineLayout ll(llc, RetrieveLineLayout(line));
+	AutoLineLayout ll(view.llc, view.RetrieveLineLayout(line, *this));
 
 	if (surface && ll) {
-		LayoutLine(line, surface, vs, ll, wrapWidth);
+		view.LayoutLine(*this, line, surface, vs, ll, wrapWidth);
 		return ll->lines;
 	} else {
 		return 1;
 	}
 }
 
-void Editor::AddStyledText(char *buffer, int appendLength) {
+void Editor::AddStyledText(const char *buffer, Sci::Position appendLength) {
 	// The buffer consists of alternating character bytes and style bytes
-	size_t textLength = appendLength / 2;
-	char *text = new char[textLength];
-	if (text) {
-		size_t i;
-		for (i = 0;i < textLength;i++) {
-			text[i] = buffer[i*2];
-		}
-		pdoc->InsertString(CurrentPosition(), text, textLength);
-		for (i = 0;i < textLength;i++) {
-			text[i] = buffer[i*2+1];
-		}
-		pdoc->StartStyling(CurrentPosition(), static_cast<char>(0xff));
-		pdoc->SetStyles(textLength, text);
-		delete []text;
+	const Sci::Position textLength = appendLength / 2;
+	std::string text(textLength, '\0');
+	Sci::Position i;
+	for (i = 0; i < textLength; i++) {
+		text[i] = buffer[i*2];
 	}
-	SetEmptySelection(currentPos + textLength);
-}
-
-static bool ValidMargin(unsigned long wParam) {
-	return wParam < ViewStyle::margins;
+	const Sci::Position lengthInserted = pdoc->InsertString(CurrentPosition(), text.c_str(), textLength);
+	for (i = 0; i < textLength; i++) {
+		text[i] = buffer[i*2+1];
+	}
+	pdoc->StartStyling(CurrentPosition());
+	pdoc->SetStyles(textLength, text.c_str());
+	SetEmptySelection(sel.MainCaret() + lengthInserted);
 }
 
-static char *CharPtrFromSPtr(sptr_t lParam) {
-	return reinterpret_cast<char *>(lParam);
+bool Editor::ValidMargin(uptr_t wParam) const noexcept {
+	return wParam < vs.ms.size();
 }
 
 void Editor::StyleSetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	vs.EnsureStyle(wParam);
 	switch (iMessage) {
 	case SCI_STYLESETFORE:
-		vs.styles[wParam].fore.desired = ColourDesired(lParam);
+		vs.styles[wParam].fore = ColourDesired(static_cast<int>(lParam));
 		break;
 	case SCI_STYLESETBACK:
-		vs.styles[wParam].back.desired = ColourDesired(lParam);
+		vs.styles[wParam].back = ColourDesired(static_cast<int>(lParam));
 		break;
 	case SCI_STYLESETBOLD:
-		vs.styles[wParam].bold = lParam != 0;
+		vs.styles[wParam].weight = lParam != 0 ? SC_WEIGHT_BOLD : SC_WEIGHT_NORMAL;
+		break;
+	case SCI_STYLESETWEIGHT:
+		vs.styles[wParam].weight = static_cast<int>(lParam);
 		break;
 	case SCI_STYLESETITALIC:
 		vs.styles[wParam].italic = lParam != 0;
@@ -5884,11 +5696,14 @@ void Editor::StyleSetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam
 		vs.styles[wParam].eolFilled = lParam != 0;
 		break;
 	case SCI_STYLESETSIZE:
-		vs.styles[wParam].size = lParam;
+		vs.styles[wParam].size = static_cast<int>(lParam * SC_FONT_SIZE_MULTIPLIER);
+		break;
+	case SCI_STYLESETSIZEFRACTIONAL:
+		vs.styles[wParam].size = static_cast<int>(lParam);
 		break;
 	case SCI_STYLESETFONT:
 		if (lParam != 0) {
-			vs.SetStyleFontName(wParam, CharPtrFromSPtr(lParam));
+			vs.SetStyleFontName(static_cast<int>(wParam), CharPtrFromSPtr(lParam));
 		}
 		break;
 	case SCI_STYLESETUNDERLINE:
@@ -5898,7 +5713,8 @@ void Editor::StyleSetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam
 		vs.styles[wParam].caseForce = static_cast<Style::ecaseForced>(lParam);
 		break;
 	case SCI_STYLESETCHARACTERSET:
-		vs.styles[wParam].characterSet = lParam;
+		vs.styles[wParam].characterSet = static_cast<int>(lParam);
+		pdoc->SetCaseFolder(nullptr);
 		break;
 	case SCI_STYLESETVISIBLE:
 		vs.styles[wParam].visible = lParam != 0;
@@ -5917,21 +5733,23 @@ sptr_t Editor::StyleGetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lPar
 	vs.EnsureStyle(wParam);
 	switch (iMessage) {
 	case SCI_STYLEGETFORE:
-		return vs.styles[wParam].fore.desired.AsLong();
+		return vs.styles[wParam].fore.AsInteger();
 	case SCI_STYLEGETBACK:
-		return vs.styles[wParam].back.desired.AsLong();
+		return vs.styles[wParam].back.AsInteger();
 	case SCI_STYLEGETBOLD:
-		return vs.styles[wParam].bold ? 1 : 0;
+		return vs.styles[wParam].weight > SC_WEIGHT_NORMAL;
+	case SCI_STYLEGETWEIGHT:
+		return vs.styles[wParam].weight;
 	case SCI_STYLEGETITALIC:
 		return vs.styles[wParam].italic ? 1 : 0;
 	case SCI_STYLEGETEOLFILLED:
 		return vs.styles[wParam].eolFilled ? 1 : 0;
 	case SCI_STYLEGETSIZE:
+		return vs.styles[wParam].size / SC_FONT_SIZE_MULTIPLIER;
+	case SCI_STYLEGETSIZEFRACTIONAL:
 		return vs.styles[wParam].size;
 	case SCI_STYLEGETFONT:
-		if (lParam != 0)
-			strcpy(CharPtrFromSPtr(lParam), vs.styles[wParam].fontName);
-		return strlen(vs.styles[wParam].fontName);
+		return StringResult(lParam, vs.styles[wParam].fontName);
 	case SCI_STYLEGETUNDERLINE:
 		return vs.styles[wParam].underline ? 1 : 0;
 	case SCI_STYLEGETCASE:
@@ -5945,7 +5763,67 @@ sptr_t Editor::StyleGetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lPar
 	case SCI_STYLEGETHOTSPOT:
 		return vs.styles[wParam].hotspot ? 1 : 0;
 	}
-	return 0;
+	return 0;
+}
+
+void Editor::SetSelectionNMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
+	if (wParam >= sel.Count()) {
+		return;
+	}
+	InvalidateRange(sel.Range(wParam).Start().Position(), sel.Range(wParam).End().Position());
+
+	switch (iMessage) {
+	case SCI_SETSELECTIONNCARET:
+		sel.Range(wParam).caret.SetPosition(lParam);
+		break;
+
+	case SCI_SETSELECTIONNANCHOR:
+		sel.Range(wParam).anchor.SetPosition(lParam);
+		break;
+
+	case SCI_SETSELECTIONNCARETVIRTUALSPACE:
+		sel.Range(wParam).caret.SetVirtualSpace(lParam);
+		break;
+
+	case SCI_SETSELECTIONNANCHORVIRTUALSPACE:
+		sel.Range(wParam).anchor.SetVirtualSpace(lParam);
+		break;
+
+	case SCI_SETSELECTIONNSTART:
+		sel.Range(wParam).anchor.SetPosition(lParam);
+		break;
+
+	case SCI_SETSELECTIONNEND:
+		sel.Range(wParam).caret.SetPosition(lParam);
+		break;
+	}
+
+	InvalidateRange(sel.Range(wParam).Start().Position(), sel.Range(wParam).End().Position());
+	ContainerNeedsUpdate(SC_UPDATE_SELECTION);
+}
+
+sptr_t Editor::StringResult(sptr_t lParam, const char *val) noexcept {
+	const size_t len = val ? strlen(val) : 0;
+	if (lParam) {
+		char *ptr = CharPtrFromSPtr(lParam);
+		if (val)
+			memcpy(ptr, val, len+1);
+		else
+			*ptr = 0;
+	}
+	return len;	// Not including NUL
+}
+
+sptr_t Editor::BytesResult(sptr_t lParam, const unsigned char *val, size_t len) noexcept {
+	// No NUL termination: len is number of valid/displayed bytes
+	if ((lParam) && (len > 0)) {
+		char *ptr = CharPtrFromSPtr(lParam);
+		if (val)
+			memcpy(ptr, val, len);
+		else
+			*ptr = 0;
+	}
+	return val ? len : 0;
 }
 
 sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
@@ -5963,21 +5841,20 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 			if (wParam == 0)
 				return 0;
 			char *ptr = CharPtrFromSPtr(lParam);
-			unsigned int iChar = 0;
-			for (; iChar < wParam - 1; iChar++)
-				ptr[iChar] = pdoc->CharAt(iChar);
-			ptr[iChar] = '\0';
-			return iChar;
+			const Sci_Position len = std::min<Sci_Position>(wParam - 1, pdoc->Length());
+			pdoc->GetCharRange(ptr, 0, len);
+			ptr[len] = '\0';
+			return len;
 		}
 
 	case SCI_SETTEXT: {
 			if (lParam == 0)
 				return 0;
-			pdoc->BeginUndoAction();
+			UndoGroup ug(pdoc);
 			pdoc->DeleteChars(0, pdoc->Length());
 			SetEmptySelection(0);
-			pdoc->InsertCString(0, CharPtrFromSPtr(lParam));
-			pdoc->EndUndoAction();
+			const char *text = CharPtrFromSPtr(lParam);
+			pdoc->InsertString(0, text, strlen(text));
 			return 1;
 		}
 
@@ -5997,8 +5874,20 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		CopyAllowLine();
 		break;
 
+	case SCI_VERTICALCENTRECARET:
+		VerticalCentreCaret();
+		break;
+
+	case SCI_MOVESELECTEDLINESUP:
+		MoveSelectedLinesUp();
+		break;
+
+	case SCI_MOVESELECTEDLINESDOWN:
+		MoveSelectedLinesDown();
+		break;
+
 	case SCI_COPYRANGE:
-		CopyRangeToClipboard(wParam, lParam);
+		CopyRangeToClipboard(static_cast<Sci::Position>(wParam), lParam);
 		break;
 
 	case SCI_COPYTEXT:
@@ -6007,7 +5896,7 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 
 	case SCI_PASTE:
 		Paste();
-		if (!caretSticky) {
+		if ((caretSticky == SC_CARETSTICKY_OFF) || (caretSticky == SC_CARETSTICKY_WHITESPACE)) {
 			SetLastXChosen();
 		}
 		EnsureCaretVisible();
@@ -6034,18 +5923,23 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	case SCI_GETFIRSTVISIBLELINE:
 		return topLine;
 
+	case SCI_SETFIRSTVISIBLELINE:
+		ScrollTo(static_cast<Sci::Line>(wParam));
+		break;
+
 	case SCI_GETLINE: {	// Risk of overwriting the end of the buffer
-			int lineStart = pdoc->LineStart(wParam);
-			int lineEnd = pdoc->LineStart(wParam + 1);
+			const Sci::Position lineStart =
+				pdoc->LineStart(static_cast<Sci::Line>(wParam));
+			const Sci::Position lineEnd =
+				pdoc->LineStart(static_cast<Sci::Line>(wParam + 1));
+			// not NUL terminated
+			const Sci::Position len = lineEnd - lineStart;
 			if (lParam == 0) {
-				return lineEnd - lineStart;
+				return len;
 			}
 			char *ptr = CharPtrFromSPtr(lParam);
-			int iPlace = 0;
-			for (int iChar = lineStart; iChar < lineEnd; iChar++) {
-				ptr[iPlace++] = pdoc->CharAt(iChar);
-			}
-			return iPlace;
+			pdoc->GetCharRange(ptr, lineStart, len);
+			return len;
 		}
 
 	case SCI_GETLINECOUNT:
@@ -6058,141 +5952,169 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return !pdoc->IsSavePoint();
 
 	case SCI_SETSEL: {
-			int nStart = static_cast<int>(wParam);
-			int nEnd = static_cast<int>(lParam);
+			Sci::Position nStart = static_cast<Sci::Position>(wParam);
+			Sci::Position nEnd = lParam;
 			if (nEnd < 0)
 				nEnd = pdoc->Length();
 			if (nStart < 0)
 				nStart = nEnd; 	// Remove selection
-			selType = selStream;
+			InvalidateSelection(SelectionRange(nStart, nEnd));
+			sel.Clear();
+			sel.selType = Selection::selStream;
 			SetSelection(nEnd, nStart);
 			EnsureCaretVisible();
 		}
 		break;
 
 	case SCI_GETSELTEXT: {
-			if (lParam == 0) {
-				if (selType == selStream) {
-					return 1 + SelectionEnd() - SelectionStart();
-				} else {
-					// TODO: why is selLines handled the slow way?
-					int size = 0;
-					int extraCharsPerLine = 0;
-					if (selType != selLines)
-						extraCharsPerLine = (pdoc->eolMode == SC_EOL_CRLF) ? 2 : 1;
-					SelectionLineIterator lineIterator(this);
-					while (lineIterator.Iterate()) {
-						size += lineIterator.endPos + extraCharsPerLine - lineIterator.startPos;
-					}
-
-					return 1 + size;
-				}
-			}
 			SelectionText selectedText;
 			CopySelectionRange(&selectedText);
-			char *ptr = CharPtrFromSPtr(lParam);
-			int iChar = 0;
-			if (selectedText.len) {
-				for (; iChar < selectedText.len; iChar++)
-					ptr[iChar] = selectedText.s[iChar];
+			if (lParam == 0) {
+				return selectedText.LengthWithTerminator();
 			} else {
-				ptr[0] = '\0';
+				char *ptr = CharPtrFromSPtr(lParam);
+				size_t iChar = selectedText.Length();
+				if (iChar) {
+					memcpy(ptr, selectedText.Data(), iChar);
+					ptr[iChar++] = '\0';
+				} else {
+					ptr[0] = '\0';
+				}
+				return iChar;
 			}
-			return iChar;
 		}
 
 	case SCI_LINEFROMPOSITION:
-		if (static_cast<int>(wParam) < 0)
+		if (static_cast<Sci::Position>(wParam) < 0)
 			return 0;
-		return pdoc->LineFromPosition(wParam);
+		return pdoc->LineFromPosition(static_cast<Sci::Position>(wParam));
 
 	case SCI_POSITIONFROMLINE:
-		if (static_cast<int>(wParam) < 0)
-			wParam = pdoc->LineFromPosition(SelectionStart());
+		if (static_cast<Sci::Position>(wParam) < 0)
+			wParam = pdoc->LineFromPosition(SelectionStart().Position());
 		if (wParam == 0)
 			return 0; 	// Even if there is no text, there is a first line that starts at 0
-		if (static_cast<int>(wParam) > pdoc->LinesTotal())
+		if (static_cast<Sci::Line>(wParam) > pdoc->LinesTotal())
 			return -1;
 		//if (wParam > pdoc->LineFromPosition(pdoc->Length()))	// Useful test, anyway...
 		//	return -1;
-		return pdoc->LineStart(wParam);
+		return pdoc->LineStart(static_cast<Sci::Position>(wParam));
 
 		// Replacement of the old Scintilla interpretation of EM_LINELENGTH
 	case SCI_LINELENGTH:
-		if ((static_cast<int>(wParam) < 0) ||
-		        (static_cast<int>(wParam) > pdoc->LineFromPosition(pdoc->Length())))
+		if ((static_cast<Sci::Position>(wParam) < 0) ||
+		        (static_cast<Sci::Position>(wParam) > pdoc->LineFromPosition(pdoc->Length())))
 			return 0;
-		return pdoc->LineStart(wParam + 1) - pdoc->LineStart(wParam);
+		return pdoc->LineStart(static_cast<Sci::Position>(wParam) + 1) - pdoc->LineStart(static_cast<Sci::Position>(wParam));
 
 	case SCI_REPLACESEL: {
 			if (lParam == 0)
 				return 0;
-			pdoc->BeginUndoAction();
+			UndoGroup ug(pdoc);
 			ClearSelection();
-			char *replacement = CharPtrFromSPtr(lParam);
-			pdoc->InsertCString(currentPos, replacement);
-			pdoc->EndUndoAction();
-			SetEmptySelection(currentPos + istrlen(replacement));
+			const char *replacement = CharPtrFromSPtr(lParam);
+			const Sci::Position lengthInserted = pdoc->InsertString(
+				sel.MainCaret(), replacement, strlen(replacement));
+			SetEmptySelection(sel.MainCaret() + lengthInserted);
+			SetLastXChosen();
 			EnsureCaretVisible();
 		}
 		break;
 
 	case SCI_SETTARGETSTART:
-		targetStart = wParam;
+		targetRange.start.SetPosition(static_cast<Sci::Position>(wParam));
 		break;
 
 	case SCI_GETTARGETSTART:
-		return targetStart;
+		return targetRange.start.Position();
+
+	case SCI_SETTARGETSTARTVIRTUALSPACE:
+		targetRange.start.SetVirtualSpace(static_cast<Sci::Position>(wParam));
+		break;
+
+	case SCI_GETTARGETSTARTVIRTUALSPACE:
+		return targetRange.start.VirtualSpace();
 
 	case SCI_SETTARGETEND:
-		targetEnd = wParam;
+		targetRange.end.SetPosition(static_cast<Sci::Position>(wParam));
 		break;
 
 	case SCI_GETTARGETEND:
-		return targetEnd;
+		return targetRange.end.Position();
+
+	case SCI_SETTARGETENDVIRTUALSPACE:
+		targetRange.end.SetVirtualSpace(static_cast<Sci::Position>(wParam));
+		break;
+
+	case SCI_GETTARGETENDVIRTUALSPACE:
+		return targetRange.end.VirtualSpace();
+
+	case SCI_SETTARGETRANGE:
+		targetRange.start.SetPosition(static_cast<Sci::Position>(wParam));
+		targetRange.end.SetPosition(lParam);
+		break;
+
+	case SCI_TARGETWHOLEDOCUMENT:
+		targetRange.start.SetPosition(0);
+		targetRange.end.SetPosition(pdoc->Length());
+		break;
 
 	case SCI_TARGETFROMSELECTION:
-		if (currentPos < anchor) {
-			targetStart = currentPos;
-			targetEnd = anchor;
-		} else {
-			targetStart = anchor;
-			targetEnd = currentPos;
-		}
+		targetRange.start = sel.RangeMain().Start();
+		targetRange.end = sel.RangeMain().End();
 		break;
 
+	case SCI_GETTARGETTEXT: {
+			std::string text = RangeText(targetRange.start.Position(), targetRange.end.Position());
+			return BytesResult(lParam, reinterpret_cast<const unsigned char *>(text.c_str()), text.length());
+		}
+
 	case SCI_REPLACETARGET:
 		PLATFORM_ASSERT(lParam);
-		return ReplaceTarget(false, CharPtrFromSPtr(lParam), wParam);
+		return ReplaceTarget(false, CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
 
 	case SCI_REPLACETARGETRE:
 		PLATFORM_ASSERT(lParam);
-		return ReplaceTarget(true, CharPtrFromSPtr(lParam), wParam);
+		return ReplaceTarget(true, CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
 
 	case SCI_SEARCHINTARGET:
 		PLATFORM_ASSERT(lParam);
-		return SearchInTarget(CharPtrFromSPtr(lParam), wParam);
+		return SearchInTarget(CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
 
 	case SCI_SETSEARCHFLAGS:
-		searchFlags = wParam;
+		searchFlags = static_cast<int>(wParam);
 		break;
 
 	case SCI_GETSEARCHFLAGS:
 		return searchFlags;
 
+	case SCI_GETTAG:
+		return GetTag(CharPtrFromSPtr(lParam), static_cast<int>(wParam));
+
 	case SCI_POSITIONBEFORE:
-		return pdoc->MovePositionOutsideChar(wParam - 1, -1, true);
+		return pdoc->MovePositionOutsideChar(static_cast<Sci::Position>(wParam) - 1, -1, true);
 
 	case SCI_POSITIONAFTER:
-		return pdoc->MovePositionOutsideChar(wParam + 1, 1, true);
+		return pdoc->MovePositionOutsideChar(static_cast<Sci::Position>(wParam) + 1, 1, true);
+
+	case SCI_POSITIONRELATIVE:
+		return std::clamp<Sci::Position>(pdoc->GetRelativePosition(
+			static_cast<Sci::Position>(wParam), lParam),
+			0, pdoc->Length());
+
+	case SCI_POSITIONRELATIVECODEUNITS:
+		return std::clamp<Sci::Position>(pdoc->GetRelativePositionUTF16(
+			static_cast<Sci::Position>(wParam), lParam),
+			0, pdoc->Length());
 
 	case SCI_LINESCROLL:
-		ScrollTo(topLine + lParam);
-		HorizontalScrollTo(xOffset + wParam * vs.spaceWidth);
+		ScrollTo(topLine + static_cast<Sci::Line>(lParam));
+		HorizontalScrollTo(xOffset + static_cast<int>(wParam) * static_cast<int>(vs.spaceWidth));
 		return 1;
 
 	case SCI_SETXOFFSET:
-		xOffset = wParam;
+		xOffset = static_cast<int>(wParam);
+		ContainerNeedsUpdate(SC_UPDATE_H_SCROLL);
 		SetHorizontalScrollPos();
 		Redraw();
 		break;
@@ -6222,16 +6144,17 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		if (lParam < 0) {
 			return 0;
 		} else {
-			Point pt = LocationFromPosition(lParam);
-			return pt.x;
+			const Point pt = LocationFromPosition(lParam);
+			// Convert to view-relative
+			return static_cast<int>(pt.x) - vs.textStart + vs.fixedColumnWidth;
 		}
 
 	case SCI_POINTYFROMPOSITION:
 		if (lParam < 0) {
 			return 0;
 		} else {
-			Point pt = LocationFromPosition(lParam);
-			return pt.y;
+			const Point pt = LocationFromPosition(lParam);
+			return static_cast<int>(pt.y);
 		}
 
 	case SCI_FINDTEXT:
@@ -6240,12 +6163,12 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	case SCI_GETTEXTRANGE: {
 			if (lParam == 0)
 				return 0;
-			TextRange *tr = reinterpret_cast<TextRange *>(lParam);
-			int cpMax = tr->chrg.cpMax;
+			Sci_TextRange *tr = static_cast<Sci_TextRange *>(PtrFromSPtr(lParam));
+			Sci::Position cpMax = static_cast<Sci::Position>(tr->chrg.cpMax);
 			if (cpMax == -1)
 				cpMax = pdoc->Length();
 			PLATFORM_ASSERT(cpMax <= pdoc->Length());
-			int len = cpMax - tr->chrg.cpMin; 	// No -1 as cpMin and cpMax are referring to inter character positions
+			Sci::Position len = cpMax - tr->chrg.cpMin; 	// No -1 as cpMin and cpMax are referring to inter character positions
 			pdoc->GetCharRange(tr->lpstrText, tr->chrg.cpMin, len);
 			// Spec says copied text is terminated with a NUL
 			tr->lpstrText[len] = '\0';
@@ -6253,12 +6176,12 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		}
 
 	case SCI_HIDESELECTION:
-		hideSelection = wParam != 0;
+		view.hideSelection = wParam != 0;
 		Redraw();
 		break;
 
 	case SCI_FORMATRANGE:
-		return FormatRange(wParam != 0, reinterpret_cast<RangeToFormat *>(lParam));
+		return FormatRange(wParam != 0, static_cast<Sci_RangeToFormat *>(PtrFromSPtr(lParam)));
 
 	case SCI_GETMARGINLEFT:
 		return vs.leftMarginWidth;
@@ -6267,53 +6190,65 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return vs.rightMarginWidth;
 
 	case SCI_SETMARGINLEFT:
-		vs.leftMarginWidth = lParam;
+		lastXChosen += static_cast<int>(lParam) - vs.leftMarginWidth;
+		vs.leftMarginWidth = static_cast<int>(lParam);
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_SETMARGINRIGHT:
-		vs.rightMarginWidth = lParam;
+		vs.rightMarginWidth = static_cast<int>(lParam);
 		InvalidateStyleRedraw();
 		break;
 
-		// Control specific mesages
+		// Control specific messages
 
 	case SCI_ADDTEXT: {
 			if (lParam == 0)
 				return 0;
-			pdoc->InsertString(CurrentPosition(), CharPtrFromSPtr(lParam), wParam);
-			SetEmptySelection(currentPos + wParam);
+			const Sci::Position lengthInserted = pdoc->InsertString(
+				CurrentPosition(), CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
+			SetEmptySelection(sel.MainCaret() + lengthInserted);
 			return 0;
 		}
 
 	case SCI_ADDSTYLEDTEXT:
 		if (lParam)
-			AddStyledText(CharPtrFromSPtr(lParam), wParam);
+			AddStyledText(CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
 		return 0;
 
 	case SCI_INSERTTEXT: {
 			if (lParam == 0)
 				return 0;
-			int insertPos = wParam;
-			if (static_cast<int>(wParam) == -1)
+			Sci::Position insertPos = static_cast<Sci::Position>(wParam);
+			if (insertPos == -1)
 				insertPos = CurrentPosition();
-			int newCurrent = CurrentPosition();
-			char *sz = CharPtrFromSPtr(lParam);
-			pdoc->InsertCString(insertPos, sz);
+			Sci::Position newCurrent = CurrentPosition();
+			const char *sz = CharPtrFromSPtr(lParam);
+			const Sci::Position lengthInserted = pdoc->InsertString(insertPos, sz, strlen(sz));
 			if (newCurrent > insertPos)
-				newCurrent += istrlen(sz);
+				newCurrent += lengthInserted;
 			SetEmptySelection(newCurrent);
 			return 0;
 		}
 
+	case SCI_CHANGEINSERTION:
+		PLATFORM_ASSERT(lParam);
+		pdoc->ChangeInsertion(CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
+		return 0;
+
 	case SCI_APPENDTEXT:
-		pdoc->InsertString(pdoc->Length(), CharPtrFromSPtr(lParam), wParam);
+		pdoc->InsertString(pdoc->Length(),
+			CharPtrFromSPtr(lParam), static_cast<Sci::Position>(wParam));
 		return 0;
 
 	case SCI_CLEARALL:
 		ClearAll();
 		return 0;
 
+	case SCI_DELETERANGE:
+		pdoc->DeleteChars(static_cast<Sci::Position>(wParam), lParam);
+		return 0;
+
 	case SCI_CLEARDOCUMENTSTYLE:
 		ClearDocumentStyle();
 		return 0;
@@ -6337,21 +6272,37 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return caret.period;
 
 	case SCI_SETCARETPERIOD:
-		caret.period = wParam;
+		CaretSetPeriod(static_cast<int>(wParam));
 		break;
 
+	case SCI_GETWORDCHARS:
+		return pdoc->GetCharsOfClass(CharClassify::ccWord, UCharPtrFromSPtr(lParam));
+
 	case SCI_SETWORDCHARS: {
 			pdoc->SetDefaultCharClasses(false);
 			if (lParam == 0)
 				return 0;
-			pdoc->SetCharClasses(reinterpret_cast<unsigned char *>(lParam), CharClassify::ccWord);
+			pdoc->SetCharClasses(ConstUCharPtrFromSPtr(lParam), CharClassify::ccWord);
 		}
 		break;
 
+	case SCI_GETWHITESPACECHARS:
+		return pdoc->GetCharsOfClass(CharClassify::ccSpace, UCharPtrFromSPtr(lParam));
+
 	case SCI_SETWHITESPACECHARS: {
 			if (lParam == 0)
 				return 0;
-			pdoc->SetCharClasses(reinterpret_cast<unsigned char *>(lParam), CharClassify::ccSpace);
+			pdoc->SetCharClasses(ConstUCharPtrFromSPtr(lParam), CharClassify::ccSpace);
+		}
+		break;
+
+	case SCI_GETPUNCTUATIONCHARS:
+		return pdoc->GetCharsOfClass(CharClassify::ccPunctuation, UCharPtrFromSPtr(lParam));
+
+	case SCI_SETPUNCTUATIONCHARS: {
+			if (lParam == 0)
+				return 0;
+			pdoc->SetCharClasses(ConstUCharPtrFromSPtr(lParam), CharClassify::ccPunctuation);
 		}
 		break;
 
@@ -6359,70 +6310,93 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		pdoc->SetDefaultCharClasses(true);
 		break;
 
+	case SCI_SETCHARACTERCATEGORYOPTIMIZATION:
+		pdoc->SetCharacterCategoryOptimization(static_cast<int>(wParam));
+		break;
+
+	case SCI_GETCHARACTERCATEGORYOPTIMIZATION:
+		return pdoc->CharacterCategoryOptimization();
+
 	case SCI_GETLENGTH:
 		return pdoc->Length();
 
 	case SCI_ALLOCATE:
-		pdoc->Allocate(wParam);
+		pdoc->Allocate(static_cast<Sci::Position>(wParam));
 		break;
 
 	case SCI_GETCHARAT:
-		return pdoc->CharAt(wParam);
+		return pdoc->CharAt(static_cast<Sci::Position>(wParam));
 
 	case SCI_SETCURRENTPOS:
-		SetSelection(wParam, anchor);
+		if (sel.IsRectangular()) {
+			sel.Rectangular().caret.SetPosition(static_cast<Sci::Position>(wParam));
+			SetRectangularRange();
+			Redraw();
+		} else {
+			SetSelection(static_cast<Sci::Position>(wParam), sel.MainAnchor());
+		}
 		break;
 
 	case SCI_GETCURRENTPOS:
-		return currentPos;
+		return sel.IsRectangular() ? sel.Rectangular().caret.Position() : sel.MainCaret();
 
 	case SCI_SETANCHOR:
-		SetSelection(currentPos, wParam);
+		if (sel.IsRectangular()) {
+			sel.Rectangular().anchor.SetPosition(static_cast<Sci::Position>(wParam));
+			SetRectangularRange();
+			Redraw();
+		} else {
+			SetSelection(sel.MainCaret(), static_cast<Sci::Position>(wParam));
+		}
 		break;
 
 	case SCI_GETANCHOR:
-		return anchor;
+		return sel.IsRectangular() ? sel.Rectangular().anchor.Position() : sel.MainAnchor();
 
 	case SCI_SETSELECTIONSTART:
-		SetSelection(Platform::Maximum(currentPos, wParam), wParam);
+		SetSelection(std::max(sel.MainCaret(), static_cast<Sci::Position>(wParam)), static_cast<Sci::Position>(wParam));
 		break;
 
 	case SCI_GETSELECTIONSTART:
-		return Platform::Minimum(anchor, currentPos);
+		return sel.LimitsForRectangularElseMain().start.Position();
 
 	case SCI_SETSELECTIONEND:
-		SetSelection(wParam, Platform::Minimum(anchor, wParam));
+		SetSelection(static_cast<Sci::Position>(wParam), std::min(sel.MainAnchor(), static_cast<Sci::Position>(wParam)));
 		break;
 
 	case SCI_GETSELECTIONEND:
-		return Platform::Maximum(anchor, currentPos);
+		return sel.LimitsForRectangularElseMain().end.Position();
+
+	case SCI_SETEMPTYSELECTION:
+		SetEmptySelection(static_cast<Sci::Position>(wParam));
+		break;
 
 	case SCI_SETPRINTMAGNIFICATION:
-		printMagnification = wParam;
+		view.printParameters.magnification = static_cast<int>(wParam);
 		break;
 
 	case SCI_GETPRINTMAGNIFICATION:
-		return printMagnification;
+		return view.printParameters.magnification;
 
 	case SCI_SETPRINTCOLOURMODE:
-		printColourMode = wParam;
+		view.printParameters.colourMode = static_cast<int>(wParam);
 		break;
 
 	case SCI_GETPRINTCOLOURMODE:
-		return printColourMode;
+		return view.printParameters.colourMode;
 
 	case SCI_SETPRINTWRAPMODE:
-		printWrapState = (wParam == SC_WRAP_WORD) ? eWrapWord : eWrapNone;
+		view.printParameters.wrapState = (wParam == SC_WRAP_WORD) ? WrapMode::word : WrapMode::none;
 		break;
 
 	case SCI_GETPRINTWRAPMODE:
-		return printWrapState;
+		return static_cast<sptr_t>(view.printParameters.wrapState);
 
 	case SCI_GETSTYLEAT:
-		if (static_cast<int>(wParam) >= pdoc->Length())
+		if (static_cast<Sci::Position>(wParam) >= pdoc->Length())
 			return 0;
 		else
-			return pdoc->StyleAt(wParam);
+			return pdoc->StyleAt(static_cast<Sci::Position>(wParam));
 
 	case SCI_REDO:
 		Redo();
@@ -6439,9 +6413,9 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	case SCI_GETSTYLEDTEXT: {
 			if (lParam == 0)
 				return 0;
-			TextRange *tr = reinterpret_cast<TextRange *>(lParam);
-			int iPlace = 0;
-			for (int iChar = tr->chrg.cpMin; iChar < tr->chrg.cpMax; iChar++) {
+			Sci_TextRange *tr = static_cast<Sci_TextRange *>(PtrFromSPtr(lParam));
+			Sci::Position iPlace = 0;
+			for (Sci::Position iChar = tr->chrg.cpMin; iChar < tr->chrg.cpMax; iChar++) {
 				tr->lpstrText[iPlace++] = pdoc->CharAt(iChar);
 				tr->lpstrText[iPlace++] = pdoc->StyleAt(iChar);
 			}
@@ -6454,12 +6428,18 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return (pdoc->CanRedo() && !pdoc->IsReadOnly()) ? 1 : 0;
 
 	case SCI_MARKERLINEFROMHANDLE:
-		return pdoc->LineFromHandle(wParam);
+		return pdoc->LineFromHandle(static_cast<int>(wParam));
 
 	case SCI_MARKERDELETEHANDLE:
-		pdoc->DeleteMarkFromHandle(wParam);
+		pdoc->DeleteMarkFromHandle(static_cast<int>(wParam));
 		break;
 
+	case SCI_MARKERHANDLEFROMLINE:
+		return pdoc->MarkerHandleFromLine(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+
+	case SCI_MARKERNUMBERFROMLINE:
+		return pdoc->MarkerNumberFromLine(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+
 	case SCI_GETVIEWWS:
 		return vs.viewWhitespace;
 
@@ -6468,37 +6448,60 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		Redraw();
 		break;
 
+	case SCI_GETTABDRAWMODE:
+		return vs.tabDrawMode;
+
+	case SCI_SETTABDRAWMODE:
+		vs.tabDrawMode = static_cast<TabDrawMode>(wParam);
+		Redraw();
+		break;
+
+	case SCI_GETWHITESPACESIZE:
+		return vs.whitespaceSize;
+
+	case SCI_SETWHITESPACESIZE:
+		vs.whitespaceSize = static_cast<int>(wParam);
+		Redraw();
+		break;
+
 	case SCI_POSITIONFROMPOINT:
-		return PositionFromLocation(Point(wParam, lParam));
+		return PositionFromLocation(Point::FromInts(static_cast<int>(wParam) - vs.ExternalMarginWidth(), static_cast<int>(lParam)),
+					    false, false);
 
 	case SCI_POSITIONFROMPOINTCLOSE:
-		return PositionFromLocationClose(Point(wParam, lParam));
+		return PositionFromLocation(Point::FromInts(static_cast<int>(wParam) - vs.ExternalMarginWidth(), static_cast<int>(lParam)),
+					    true, false);
+
+	case SCI_CHARPOSITIONFROMPOINT:
+		return PositionFromLocation(Point::FromInts(static_cast<int>(wParam) - vs.ExternalMarginWidth(), static_cast<int>(lParam)),
+					    false, true);
+
+	case SCI_CHARPOSITIONFROMPOINTCLOSE:
+		return PositionFromLocation(Point::FromInts(static_cast<int>(wParam) - vs.ExternalMarginWidth(), static_cast<int>(lParam)),
+					    true, true);
 
 	case SCI_GOTOLINE:
-		GoToLine(wParam);
+		GoToLine(static_cast<Sci::Line>(wParam));
 		break;
 
 	case SCI_GOTOPOS:
-		SetEmptySelection(wParam);
+		SetEmptySelection(static_cast<Sci::Position>(wParam));
 		EnsureCaretVisible();
-		Redraw();
 		break;
 
 	case SCI_GETCURLINE: {
-			int lineCurrentPos = pdoc->LineFromPosition(currentPos);
-			int lineStart = pdoc->LineStart(lineCurrentPos);
-			unsigned int lineEnd = pdoc->LineStart(lineCurrentPos + 1);
+			const Sci::Line lineCurrentPos = pdoc->SciLineFromPosition(sel.MainCaret());
+			const Sci::Position lineStart = pdoc->LineStart(lineCurrentPos);
+			const Sci::Position lineEnd = pdoc->LineStart(lineCurrentPos + 1);
 			if (lParam == 0) {
 				return 1 + lineEnd - lineStart;
 			}
 			PLATFORM_ASSERT(wParam > 0);
 			char *ptr = CharPtrFromSPtr(lParam);
-			unsigned int iPlace = 0;
-			for (unsigned int iChar = lineStart; iChar < lineEnd && iPlace < wParam - 1; iChar++) {
-				ptr[iPlace++] = pdoc->CharAt(iChar);
-			}
-			ptr[iPlace] = '\0';
-			return currentPos - lineStart;
+			const Sci::Position len = std::min<uptr_t>(lineEnd - lineStart, wParam - 1);
+			pdoc->GetCharRange(ptr, lineStart, len);
+			ptr[len] = '\0';
+			return sel.MainCaret() - lineStart;
 		}
 
 	case SCI_GETENDSTYLED:
@@ -6508,41 +6511,78 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return pdoc->eolMode;
 
 	case SCI_SETEOLMODE:
-		pdoc->eolMode = wParam;
+		pdoc->eolMode = static_cast<int>(wParam);
+		break;
+
+	case SCI_SETLINEENDTYPESALLOWED:
+		if (pdoc->SetLineEndTypesAllowed(static_cast<int>(wParam))) {
+			pcs->Clear();
+			pcs->InsertLines(0, pdoc->LinesTotal() - 1);
+			SetAnnotationHeights(0, pdoc->LinesTotal());
+			InvalidateStyleRedraw();
+		}
 		break;
 
+	case SCI_GETLINEENDTYPESALLOWED:
+		return pdoc->GetLineEndTypesAllowed();
+
+	case SCI_GETLINEENDTYPESACTIVE:
+		return pdoc->GetLineEndTypesActive();
+
 	case SCI_STARTSTYLING:
-		pdoc->StartStyling(wParam, static_cast<char>(lParam));
+		pdoc->StartStyling(static_cast<Sci::Position>(wParam));
 		break;
 
 	case SCI_SETSTYLING:
-		pdoc->SetStyleFor(wParam, static_cast<char>(lParam));
+		if (static_cast<Sci::Position>(wParam) < 0)
+			errorStatus = SC_STATUS_FAILURE;
+		else
+			pdoc->SetStyleFor(static_cast<Sci::Position>(wParam), static_cast<char>(lParam));
 		break;
 
 	case SCI_SETSTYLINGEX:             // Specify a complete styling buffer
 		if (lParam == 0)
 			return 0;
-		pdoc->SetStyles(wParam, CharPtrFromSPtr(lParam));
+		pdoc->SetStyles(static_cast<Sci::Position>(wParam), CharPtrFromSPtr(lParam));
 		break;
 
 	case SCI_SETBUFFEREDDRAW:
-		bufferedDraw = wParam != 0;
+		view.bufferedDraw = wParam != 0;
 		break;
 
 	case SCI_GETBUFFEREDDRAW:
-		return bufferedDraw;
+		return view.bufferedDraw;
 
+#ifdef INCLUDE_DEPRECATED_FEATURES
 	case SCI_GETTWOPHASEDRAW:
-		return twoPhaseDraw;
+		return view.phasesDraw == EditView::phasesTwo;
 
 	case SCI_SETTWOPHASEDRAW:
-		twoPhaseDraw = wParam != 0;
+		if (view.SetTwoPhaseDraw(wParam != 0))
+			InvalidateStyleRedraw();
+		break;
+#endif
+
+	case SCI_GETPHASESDRAW:
+		return view.phasesDraw;
+
+	case SCI_SETPHASESDRAW:
+		if (view.SetPhasesDraw(static_cast<int>(wParam)))
+			InvalidateStyleRedraw();
+		break;
+
+	case SCI_SETFONTQUALITY:
+		vs.extraFontFlag &= ~SC_EFF_QUALITY_MASK;
+		vs.extraFontFlag |= (wParam & SC_EFF_QUALITY_MASK);
 		InvalidateStyleRedraw();
 		break;
 
+	case SCI_GETFONTQUALITY:
+		return (vs.extraFontFlag & SC_EFF_QUALITY_MASK);
+
 	case SCI_SETTABWIDTH:
 		if (wParam > 0) {
-			pdoc->tabInChars = wParam;
+			pdoc->tabInChars = static_cast<int>(wParam);
 			if (pdoc->indentInChars == 0)
 				pdoc->actualIndentInChars = pdoc->tabInChars;
 		}
@@ -6552,8 +6592,32 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	case SCI_GETTABWIDTH:
 		return pdoc->tabInChars;
 
+	case SCI_SETTABMINIMUMWIDTH:
+		SetAppearance(view.tabWidthMinimumPixels, static_cast<int>(wParam));
+		break;
+
+	case SCI_GETTABMINIMUMWIDTH:
+		return view.tabWidthMinimumPixels;
+
+	case SCI_CLEARTABSTOPS:
+		if (view.ClearTabstops(static_cast<Sci::Line>(wParam))) {
+			const DocModification mh(SC_MOD_CHANGETABSTOPS, 0, 0, 0, nullptr, static_cast<Sci::Line>(wParam));
+			NotifyModified(pdoc, mh, nullptr);
+		}
+		break;
+
+	case SCI_ADDTABSTOP:
+		if (view.AddTabstop(static_cast<Sci::Line>(wParam), static_cast<int>(lParam))) {
+			const DocModification mh(SC_MOD_CHANGETABSTOPS, 0, 0, 0, nullptr, static_cast<Sci::Line>(wParam));
+			NotifyModified(pdoc, mh, nullptr);
+		}
+		break;
+
+	case SCI_GETNEXTTABSTOP:
+		return view.GetNextTabstop(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+
 	case SCI_SETINDENT:
-		pdoc->indentInChars = wParam;
+		pdoc->indentInChars = static_cast<int>(wParam);
 		if (pdoc->indentInChars != 0)
 			pdoc->actualIndentInChars = pdoc->indentInChars;
 		else
@@ -6573,14 +6637,14 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return pdoc->useTabs;
 
 	case SCI_SETLINEINDENTATION:
-		pdoc->SetLineIndentation(wParam, lParam);
+		pdoc->SetLineIndentation(static_cast<Sci::Line>(wParam), lParam);
 		break;
 
 	case SCI_GETLINEINDENTATION:
-		return pdoc->GetLineIndentation(wParam);
+		return pdoc->GetLineIndentation(static_cast<Sci::Line>(wParam));
 
 	case SCI_GETLINEINDENTPOSITION:
-		return pdoc->GetLineIndentPosition(wParam);
+		return pdoc->GetLineIndentPosition(static_cast<Sci::Line>(wParam));
 
 	case SCI_SETTABINDENTS:
 		pdoc->tabIndents = wParam != 0;
@@ -6597,7 +6661,7 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return pdoc->backspaceUnindents;
 
 	case SCI_SETMOUSEDWELLTIME:
-		dwellDelay = wParam;
+		dwellDelay = static_cast<int>(wParam);
 		ticksToDwell = dwellDelay;
 		break;
 
@@ -6605,82 +6669,91 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return dwellDelay;
 
 	case SCI_WORDSTARTPOSITION:
-		return pdoc->ExtendWordSelect(wParam, -1, lParam != 0);
+		return pdoc->ExtendWordSelect(static_cast<Sci::Position>(wParam), -1, lParam != 0);
 
 	case SCI_WORDENDPOSITION:
-		return pdoc->ExtendWordSelect(wParam, 1, lParam != 0);
+		return pdoc->ExtendWordSelect(static_cast<Sci::Position>(wParam), 1, lParam != 0);
+
+	case SCI_ISRANGEWORD:
+		return pdoc->IsWordAt(static_cast<Sci::Position>(wParam), lParam);
+
+	case SCI_SETIDLESTYLING:
+		idleStyling = static_cast<int>(wParam);
+		break;
+
+	case SCI_GETIDLESTYLING:
+		return idleStyling;
 
 	case SCI_SETWRAPMODE:
-		switch (wParam) {
-		case SC_WRAP_WORD:
-			wrapState = eWrapWord;
-			break;
-		case SC_WRAP_CHAR:
-			wrapState = eWrapChar;
-			break;
-		default:
-			wrapState = eWrapNone;
-			break;
+		if (vs.SetWrapState(static_cast<int>(wParam))) {
+			xOffset = 0;
+			ContainerNeedsUpdate(SC_UPDATE_H_SCROLL);
+			InvalidateStyleRedraw();
+			ReconfigureScrollBars();
 		}
-		xOffset = 0;
-		InvalidateStyleRedraw();
-		ReconfigureScrollBars();
 		break;
 
 	case SCI_GETWRAPMODE:
-		return wrapState;
+		return static_cast<sptr_t>(vs.wrapState);
 
 	case SCI_SETWRAPVISUALFLAGS:
-		wrapVisualFlags = wParam;
-		actualWrapVisualStartIndent = wrapVisualStartIndent;
-		if ((wrapVisualFlags & SC_WRAPVISUALFLAG_START) && (actualWrapVisualStartIndent == 0))
-			actualWrapVisualStartIndent = 1; // must indent to show start visual
-		InvalidateStyleRedraw();
-		ReconfigureScrollBars();
+		if (vs.SetWrapVisualFlags(static_cast<int>(wParam))) {
+			InvalidateStyleRedraw();
+			ReconfigureScrollBars();
+		}
 		break;
 
 	case SCI_GETWRAPVISUALFLAGS:
-		return wrapVisualFlags;
+		return vs.wrapVisualFlags;
 
 	case SCI_SETWRAPVISUALFLAGSLOCATION:
-		wrapVisualFlagsLocation = wParam;
-		InvalidateStyleRedraw();
+		if (vs.SetWrapVisualFlagsLocation(static_cast<int>(wParam))) {
+			InvalidateStyleRedraw();
+		}
 		break;
 
 	case SCI_GETWRAPVISUALFLAGSLOCATION:
-		return wrapVisualFlagsLocation;
+		return vs.wrapVisualFlagsLocation;
 
 	case SCI_SETWRAPSTARTINDENT:
-		wrapVisualStartIndent = wParam;
-		actualWrapVisualStartIndent = wrapVisualStartIndent;
-		if ((wrapVisualFlags & SC_WRAPVISUALFLAG_START) && (actualWrapVisualStartIndent == 0))
-			actualWrapVisualStartIndent = 1; // must indent to show start visual
-		InvalidateStyleRedraw();
-		ReconfigureScrollBars();
+		if (vs.SetWrapVisualStartIndent(static_cast<int>(wParam))) {
+			InvalidateStyleRedraw();
+			ReconfigureScrollBars();
+		}
 		break;
 
 	case SCI_GETWRAPSTARTINDENT:
-		return wrapVisualStartIndent;
+		return vs.wrapVisualStartIndent;
+
+	case SCI_SETWRAPINDENTMODE:
+		if (vs.SetWrapIndentMode(static_cast<int>(wParam))) {
+			InvalidateStyleRedraw();
+			ReconfigureScrollBars();
+		}
+		break;
+
+	case SCI_GETWRAPINDENTMODE:
+		return vs.wrapIndentMode;
 
 	case SCI_SETLAYOUTCACHE:
-		llc.SetLevel(wParam);
+		view.llc.SetLevel(static_cast<int>(wParam));
 		break;
 
 	case SCI_GETLAYOUTCACHE:
-		return llc.GetLevel();
+		return view.llc.GetLevel();
 
 	case SCI_SETPOSITIONCACHE:
-		posCache.SetSize(wParam);
+		view.posCache.SetSize(wParam);
 		break;
 
 	case SCI_GETPOSITIONCACHE:
-		return posCache.GetSize();
+		return view.posCache.GetSize();
 
 	case SCI_SETSCROLLWIDTH:
 		PLATFORM_ASSERT(wParam > 0);
-		if ((wParam > 0) && (wParam != static_cast<unsigned int >(scrollWidth))) {
-			lineWidthMaxSeen = 0;
-			scrollWidth = wParam;
+		if ((wParam > 0) && (wParam != static_cast<unsigned int>(scrollWidth))) {
+			view.lineWidthMaxSeen = 0;
+			scrollWidth = static_cast<int>(wParam);
 			SetScrollBars();
 		}
 		break;
@@ -6700,15 +6773,16 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case SCI_LINESSPLIT:
-		LinesSplit(wParam);
+		LinesSplit(static_cast<int>(wParam));
 		break;
 
 	case SCI_TEXTWIDTH:
-		PLATFORM_ASSERT(wParam < vs.stylesSize);
+		PLATFORM_ASSERT(wParam < vs.styles.size());
 		PLATFORM_ASSERT(lParam);
 		return TextWidth(wParam, CharPtrFromSPtr(lParam));
 
 	case SCI_TEXTHEIGHT:
+		RefreshStyleData();
 		return vs.lineHeight;
 
 	case SCI_SETENDATLASTLINE:
@@ -6723,9 +6797,9 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return endAtLastLine;
 
 	case SCI_SETCARETSTICKY:
-		PLATFORM_ASSERT((wParam == 0) || (wParam == 1));
-		if (caretSticky != (wParam != 0)) {
-			caretSticky = wParam != 0;
+		PLATFORM_ASSERT(wParam <= SC_CARETSTICKY_WHITESPACE);
+		if (wParam <= SC_CARETSTICKY_WHITESPACE) {
+			caretSticky = static_cast<int>(wParam);
 		}
 		break;
 
@@ -6737,10 +6811,10 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case SCI_GETCOLUMN:
-		return pdoc->GetColumn(wParam);
+		return pdoc->GetColumn(static_cast<Sci::Position>(wParam));
 
 	case SCI_FINDCOLUMN:
-		return pdoc->FindColumn(wParam, lParam);
+		return pdoc->FindColumn(static_cast<Sci::Line>(wParam), lParam);
 
 	case SCI_SETHSCROLLBAR :
 		if (horizontalScrollBarVisible != (wParam != 0)) {
@@ -6758,6 +6832,8 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 			verticalScrollBarVisible = wParam != 0;
 			SetScrollBars();
 			ReconfigureScrollBars();
+			if (verticalScrollBarVisible)
+				SetVerticalScrollPos();
 		}
 		break;
 
@@ -6765,7 +6841,7 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return verticalScrollBarVisible;
 
 	case SCI_SETINDENTATIONGUIDES:
-		vs.viewIndentationGuides = IndentView(wParam);
+		vs.viewIndentationGuides = static_cast<IndentView>(wParam);
 		Redraw();
 		break;
 
@@ -6774,7 +6850,7 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 
 	case SCI_SETHIGHLIGHTGUIDE:
 		if ((highlightGuideColumn != static_cast<int>(wParam)) || (wParam > 0)) {
-			highlightGuideColumn = wParam;
+			highlightGuideColumn = static_cast<int>(wParam);
 			Redraw();
 		}
 		break;
@@ -6783,61 +6859,108 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return highlightGuideColumn;
 
 	case SCI_GETLINEENDPOSITION:
-		return pdoc->LineEnd(wParam);
+		return pdoc->LineEnd(static_cast<Sci::Line>(wParam));
 
 	case SCI_SETCODEPAGE:
-		if (ValidCodePage(wParam)) {
-			pdoc->dbcsCodePage = wParam;
-			InvalidateStyleRedraw();
+		if (ValidCodePage(static_cast<int>(wParam))) {
+			if (pdoc->SetDBCSCodePage(static_cast<int>(wParam))) {
+				pcs->Clear();
+				pcs->InsertLines(0, pdoc->LinesTotal() - 1);
+				SetAnnotationHeights(0, pdoc->LinesTotal());
+				InvalidateStyleRedraw();
+				SetRepresentations();
+			}
 		}
 		break;
 
 	case SCI_GETCODEPAGE:
 		return pdoc->dbcsCodePage;
 
-	case SCI_SETUSEPALETTE:
-		palette.allowRealization = wParam != 0;
-		InvalidateStyleRedraw();
+	case SCI_SETIMEINTERACTION:
+		imeInteraction = static_cast<EditModel::IMEInteraction>(wParam);
+		break;
+
+	case SCI_GETIMEINTERACTION:
+		return imeInteraction;
+
+	case SCI_SETBIDIRECTIONAL:
+		// SCI_SETBIDIRECTIONAL is implemented on platform subclasses if they support bidirectional text.
+		break;
+
+	case SCI_GETBIDIRECTIONAL:
+		return static_cast<sptr_t>(bidirectional);
+
+	case SCI_GETLINECHARACTERINDEX:
+		return pdoc->LineCharacterIndex();
+
+	case SCI_ALLOCATELINECHARACTERINDEX:
+		pdoc->AllocateLineCharacterIndex(static_cast<int>(wParam));
+		break;
+
+	case SCI_RELEASELINECHARACTERINDEX:
+		pdoc->ReleaseLineCharacterIndex(static_cast<int>(wParam));
 		break;
 
-	case SCI_GETUSEPALETTE:
-		return palette.allowRealization;
+	case SCI_LINEFROMINDEXPOSITION:
+		return pdoc->LineFromPositionIndex(static_cast<Sci::Position>(wParam), static_cast<int>(lParam));
+
+	case SCI_INDEXPOSITIONFROMLINE:
+		return pdoc->IndexLineStart(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
 
 		// Marker definition and setting
 	case SCI_MARKERDEFINE:
-		if (wParam <= MARKER_MAX)
-			vs.markers[wParam].markType = lParam;
+		if (wParam <= MARKER_MAX) {
+			vs.markers[wParam].markType = static_cast<int>(lParam);
+			vs.CalcLargestMarkerHeight();
+		}
 		InvalidateStyleData();
 		RedrawSelMargin();
 		break;
+
+	case SCI_MARKERSYMBOLDEFINED:
+		if (wParam <= MARKER_MAX)
+			return vs.markers[wParam].markType;
+		else
+			return 0;
+
 	case SCI_MARKERSETFORE:
 		if (wParam <= MARKER_MAX)
-			vs.markers[wParam].fore.desired = ColourDesired(lParam);
+			vs.markers[wParam].fore = ColourDesired(static_cast<int>(lParam));
+		InvalidateStyleData();
+		RedrawSelMargin();
+		break;
+	case SCI_MARKERSETBACKSELECTED:
+		if (wParam <= MARKER_MAX)
+			vs.markers[wParam].backSelected = ColourDesired(static_cast<int>(lParam));
 		InvalidateStyleData();
 		RedrawSelMargin();
 		break;
+	case SCI_MARKERENABLEHIGHLIGHT:
+		marginView.highlightDelimiter.isEnabled = wParam == 1;
+		RedrawSelMargin();
+		break;
 	case SCI_MARKERSETBACK:
 		if (wParam <= MARKER_MAX)
-			vs.markers[wParam].back.desired = ColourDesired(lParam);
+			vs.markers[wParam].back = ColourDesired(static_cast<int>(lParam));
 		InvalidateStyleData();
 		RedrawSelMargin();
 		break;
 	case SCI_MARKERSETALPHA:
 		if (wParam <= MARKER_MAX)
-			vs.markers[wParam].alpha = lParam;
+			vs.markers[wParam].alpha = static_cast<int>(lParam);
 		InvalidateStyleRedraw();
 		break;
 	case SCI_MARKERADD: {
-			int markerID = pdoc->AddMark(wParam, lParam);
+			const int markerID = pdoc->AddMark(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
 			return markerID;
 		}
 	case SCI_MARKERADDSET:
 		if (lParam != 0)
-			pdoc->AddMarkSet(wParam, lParam);
+			pdoc->AddMarkSet(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
 		break;
 
 	case SCI_MARKERDELETE:
-		pdoc->DeleteMark(wParam, lParam);
+		pdoc->DeleteMark(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
 		break;
 
 	case SCI_MARKERDELETEALL:
@@ -6845,19 +6968,13 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case SCI_MARKERGET:
-		return pdoc->GetMark(wParam);
+		return pdoc->GetMark(static_cast<Sci::Line>(wParam));
 
-	case SCI_MARKERNEXT: {
-			int lt = pdoc->LinesTotal();
-			for (int iLine = wParam; iLine < lt; iLine++) {
-				if ((pdoc->GetMark(iLine) & lParam) != 0)
-					return iLine;
-			}
-		}
-		return -1;
+	case SCI_MARKERNEXT:
+		return pdoc->MarkerNext(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
 
 	case SCI_MARKERPREVIOUS: {
-			for (int iLine = wParam; iLine >= 0; iLine--) {
+			for (Sci::Line iLine = static_cast<Sci::Line>(wParam); iLine >= 0; iLine--) {
 				if ((pdoc->GetMark(iLine) & lParam) != 0)
 					return iLine;
 			}
@@ -6867,14 +6984,36 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	case SCI_MARKERDEFINEPIXMAP:
 		if (wParam <= MARKER_MAX) {
 			vs.markers[wParam].SetXPM(CharPtrFromSPtr(lParam));
-		};
+			vs.CalcLargestMarkerHeight();
+		}
+		InvalidateStyleData();
+		RedrawSelMargin();
+		break;
+
+	case SCI_RGBAIMAGESETWIDTH:
+		sizeRGBAImage.x = static_cast<XYPOSITION>(wParam);
+		break;
+
+	case SCI_RGBAIMAGESETHEIGHT:
+		sizeRGBAImage.y = static_cast<XYPOSITION>(wParam);
+		break;
+
+	case SCI_RGBAIMAGESETSCALE:
+		scaleRGBAImage = static_cast<float>(wParam);
+		break;
+
+	case SCI_MARKERDEFINERGBAIMAGE:
+		if (wParam <= MARKER_MAX) {
+			vs.markers[wParam].SetRGBAImage(sizeRGBAImage, scaleRGBAImage / 100.0f, ConstUCharPtrFromSPtr(lParam));
+			vs.CalcLargestMarkerHeight();
+		}
 		InvalidateStyleData();
 		RedrawSelMargin();
 		break;
 
 	case SCI_SETMARGINTYPEN:
 		if (ValidMargin(wParam)) {
-			vs.ms[wParam].style = lParam;
+			vs.ms[wParam].style = static_cast<int>(lParam);
 			InvalidateStyleRedraw();
 		}
 		break;
@@ -6889,7 +7028,8 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		if (ValidMargin(wParam)) {
 			// Short-circuit if the width is unchanged, to avoid unnecessary redraw.
 			if (vs.ms[wParam].width != lParam) {
-				vs.ms[wParam].width = lParam;
+				lastXChosen += static_cast<int>(lParam) - vs.ms[wParam].width;
+				vs.ms[wParam].width = static_cast<int>(lParam);
 				InvalidateStyleRedraw();
 			}
 		}
@@ -6903,7 +7043,7 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 
 	case SCI_SETMARGINMASKN:
 		if (ValidMargin(wParam)) {
-			vs.ms[wParam].mask = lParam;
+			vs.ms[wParam].mask = static_cast<int>(lParam);
 			InvalidateStyleRedraw();
 		}
 		break;
@@ -6927,6 +7067,38 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		else
 			return 0;
 
+	case SCI_SETMARGINCURSORN:
+		if (ValidMargin(wParam))
+			vs.ms[wParam].cursor = static_cast<int>(lParam);
+		break;
+
+	case SCI_GETMARGINCURSORN:
+		if (ValidMargin(wParam))
+			return vs.ms[wParam].cursor;
+		else
+			return 0;
+
+	case SCI_SETMARGINBACKN:
+		if (ValidMargin(wParam)) {
+			vs.ms[wParam].back = ColourDesired(static_cast<int>(lParam));
+			InvalidateStyleRedraw();
+		}
+		break;
+
+	case SCI_GETMARGINBACKN:
+		if (ValidMargin(wParam))
+			return vs.ms[wParam].back.AsInteger();
+		else
+			return 0;
+
+	case SCI_SETMARGINS:
+		if (wParam < 1000)
+			vs.ms.resize(wParam);
+		break;
+
+	case SCI_GETMARGINS:
+		return vs.ms.size();
+
 	case SCI_STYLECLEARALL:
 		vs.ClearStyles();
 		InvalidateStyleRedraw();
@@ -6935,9 +7107,11 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	case SCI_STYLESETFORE:
 	case SCI_STYLESETBACK:
 	case SCI_STYLESETBOLD:
+	case SCI_STYLESETWEIGHT:
 	case SCI_STYLESETITALIC:
 	case SCI_STYLESETEOLFILLED:
 	case SCI_STYLESETSIZE:
+	case SCI_STYLESETSIZEFRACTIONAL:
 	case SCI_STYLESETFONT:
 	case SCI_STYLESETUNDERLINE:
 	case SCI_STYLESETCASE:
@@ -6951,9 +7125,11 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	case SCI_STYLEGETFORE:
 	case SCI_STYLEGETBACK:
 	case SCI_STYLEGETBOLD:
+	case SCI_STYLEGETWEIGHT:
 	case SCI_STYLEGETITALIC:
 	case SCI_STYLEGETEOLFILLED:
 	case SCI_STYLEGETSIZE:
+	case SCI_STYLEGETSIZEFRACTIONAL:
 	case SCI_STYLEGETFONT:
 	case SCI_STYLEGETUNDERLINE:
 	case SCI_STYLEGETCASE:
@@ -6967,19 +7143,21 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		vs.ResetDefaultStyle();
 		InvalidateStyleRedraw();
 		break;
+
+#ifdef INCLUDE_DEPRECATED_FEATURES
 	case SCI_SETSTYLEBITS:
-		vs.EnsureStyle((1 << wParam) - 1);
-		pdoc->SetStylingBits(wParam);
+		vs.EnsureStyle(0xff);
 		break;
 
 	case SCI_GETSTYLEBITS:
-		return pdoc->stylingBits;
+		return 8;
+#endif
 
 	case SCI_SETLINESTATE:
-		return pdoc->SetLineState(wParam, lParam);
+		return pdoc->SetLineState(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
 
 	case SCI_GETLINESTATE:
-		return pdoc->GetLineState(wParam);
+		return pdoc->GetLineState(static_cast<Sci::Line>(wParam));
 
 	case SCI_GETMAXLINESTATE:
 		return pdoc->GetMaxLineState();
@@ -6990,86 +7168,151 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		vs.showCaretLineBackground = wParam != 0;
 		InvalidateStyleRedraw();
 		break;
+	case SCI_GETCARETLINEVISIBLEALWAYS:
+		return vs.alwaysShowCaretLineBackground;
+	case SCI_SETCARETLINEVISIBLEALWAYS:
+		vs.alwaysShowCaretLineBackground = wParam != 0;
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_GETCARETLINEFRAME:
+		return vs.caretLineFrame;
+	case SCI_SETCARETLINEFRAME:
+		vs.caretLineFrame = static_cast<int>(wParam);
+		InvalidateStyleRedraw();
+		break;
 	case SCI_GETCARETLINEBACK:
-		return vs.caretLineBackground.desired.AsLong();
+		return vs.caretLineBackground.AsInteger();
 	case SCI_SETCARETLINEBACK:
-		vs.caretLineBackground.desired = wParam;
+		vs.caretLineBackground = ColourDesired(static_cast<int>(wParam));
 		InvalidateStyleRedraw();
 		break;
 	case SCI_GETCARETLINEBACKALPHA:
 		return vs.caretLineAlpha;
 	case SCI_SETCARETLINEBACKALPHA:
-		vs.caretLineAlpha = wParam;
+		vs.caretLineAlpha = static_cast<int>(wParam);
 		InvalidateStyleRedraw();
 		break;
 
 		// Folding messages
 
 	case SCI_VISIBLEFROMDOCLINE:
-		return cs.DisplayFromDoc(wParam);
+		return pcs->DisplayFromDoc(static_cast<Sci::Line>(wParam));
 
 	case SCI_DOCLINEFROMVISIBLE:
-		return cs.DocFromDisplay(wParam);
+		return pcs->DocFromDisplay(static_cast<Sci::Line>(wParam));
 
 	case SCI_WRAPCOUNT:
-		return WrapCount(wParam);
+		return WrapCount(static_cast<Sci::Line>(wParam));
 
 	case SCI_SETFOLDLEVEL: {
-			int prev = pdoc->SetLevel(wParam, lParam);
-			if (prev != lParam)
+			const int prev = pdoc->SetLevel(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+			if (prev != static_cast<int>(lParam))
 				RedrawSelMargin();
 			return prev;
 		}
 
 	case SCI_GETFOLDLEVEL:
-		return pdoc->GetLevel(wParam);
+		return pdoc->GetLevel(static_cast<Sci::Line>(wParam));
 
 	case SCI_GETLASTCHILD:
-		return pdoc->GetLastChild(wParam, lParam);
+		return pdoc->GetLastChild(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
 
 	case SCI_GETFOLDPARENT:
-		return pdoc->GetFoldParent(wParam);
+		return pdoc->GetFoldParent(static_cast<Sci::Line>(wParam));
 
 	case SCI_SHOWLINES:
-		cs.SetVisible(wParam, lParam, true);
+		pcs->SetVisible(static_cast<Sci::Line>(wParam), static_cast<Sci::Line>(lParam), true);
 		SetScrollBars();
 		Redraw();
 		break;
 
 	case SCI_HIDELINES:
 		if (wParam > 0)
-			cs.SetVisible(wParam, lParam, false);
+			pcs->SetVisible(static_cast<Sci::Line>(wParam), static_cast<Sci::Line>(lParam), false);
 		SetScrollBars();
 		Redraw();
 		break;
 
 	case SCI_GETLINEVISIBLE:
-		return cs.GetVisible(wParam);
+		return pcs->GetVisible(static_cast<Sci::Line>(wParam));
+
+	case SCI_GETALLLINESVISIBLE:
+		return pcs->HiddenLines() ? 0 : 1;
 
 	case SCI_SETFOLDEXPANDED:
-		if (cs.SetExpanded(wParam, lParam != 0)) {
-			RedrawSelMargin();
-		}
+		SetFoldExpanded(static_cast<Sci::Line>(wParam), lParam != 0);
 		break;
 
 	case SCI_GETFOLDEXPANDED:
-		return cs.GetExpanded(wParam);
+		return pcs->GetExpanded(static_cast<Sci::Line>(wParam));
+
+	case SCI_SETAUTOMATICFOLD:
+		foldAutomatic = static_cast<int>(wParam);
+		break;
+
+	case SCI_GETAUTOMATICFOLD:
+		return foldAutomatic;
 
 	case SCI_SETFOLDFLAGS:
-		foldFlags = wParam;
+		foldFlags = static_cast<int>(wParam);
+		Redraw();
+		break;
+
+	case SCI_TOGGLEFOLDSHOWTEXT:
+		pcs->SetFoldDisplayText(static_cast<Sci::Line>(wParam), CharPtrFromSPtr(lParam));
+		FoldLine(static_cast<Sci::Line>(wParam), SC_FOLDACTION_TOGGLE);
+		break;
+
+	case SCI_FOLDDISPLAYTEXTSETSTYLE:
+		foldDisplayTextStyle = static_cast<int>(wParam);
+		Redraw();
+		break;
+
+	case SCI_FOLDDISPLAYTEXTGETSTYLE:
+		return foldDisplayTextStyle;
+
+	case SCI_SETDEFAULTFOLDDISPLAYTEXT:
+		SetDefaultFoldDisplayText(CharPtrFromSPtr(lParam));
 		Redraw();
 		break;
 
+	case SCI_GETDEFAULTFOLDDISPLAYTEXT:
+		return StringResult(lParam, GetDefaultFoldDisplayText());
+
 	case SCI_TOGGLEFOLD:
-		ToggleContraction(wParam);
+		FoldLine(static_cast<Sci::Line>(wParam), SC_FOLDACTION_TOGGLE);
 		break;
 
+	case SCI_FOLDLINE:
+		FoldLine(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+		break;
+
+	case SCI_FOLDCHILDREN:
+		FoldExpand(static_cast<Sci::Line>(wParam), static_cast<int>(lParam), pdoc->GetLevel(static_cast<int>(wParam)));
+		break;
+
+	case SCI_FOLDALL:
+		FoldAll(static_cast<int>(wParam));
+		break;
+
+	case SCI_EXPANDCHILDREN:
+		FoldExpand(static_cast<Sci::Line>(wParam), SC_FOLDACTION_EXPAND, static_cast<int>(lParam));
+		break;
+
+	case SCI_CONTRACTEDFOLDNEXT:
+		return ContractedFoldNext(static_cast<Sci::Line>(wParam));
+
 	case SCI_ENSUREVISIBLE:
-		EnsureLineVisible(wParam, false);
+		EnsureLineVisible(static_cast<Sci::Line>(wParam), false);
 		break;
 
 	case SCI_ENSUREVISIBLEENFORCEPOLICY:
-		EnsureLineVisible(wParam, true);
+		EnsureLineVisible(static_cast<Sci::Line>(wParam), true);
+		break;
+
+	case SCI_SCROLLRANGE:
+		ScrollRange(SelectionRange(static_cast<Sci::Position>(wParam), lParam));
 		break;
 
 	case SCI_SEARCHANCHOR:
@@ -7080,45 +7323,36 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	case SCI_SEARCHPREV:
 		return SearchText(iMessage, wParam, lParam);
 
-#ifdef INCLUDE_DEPRECATED_FEATURES
-	case SCI_SETCARETPOLICY:  	// Deprecated
-		caretXPolicy = caretYPolicy = wParam;
-		caretXSlop = caretYSlop = lParam;
-		break;
-#endif
-
 	case SCI_SETXCARETPOLICY:
-		caretXPolicy = wParam;
-		caretXSlop = lParam;
+		caretPolicies.x = CaretPolicy(wParam, lParam);
 		break;
 
 	case SCI_SETYCARETPOLICY:
-		caretYPolicy = wParam;
-		caretYSlop = lParam;
+		caretPolicies.y = CaretPolicy(wParam, lParam);
 		break;
 
 	case SCI_SETVISIBLEPOLICY:
-		visiblePolicy = wParam;
-		visibleSlop = lParam;
+		visiblePolicy = CaretPolicy(wParam, lParam);
 		break;
 
 	case SCI_LINESONSCREEN:
 		return LinesOnScreen();
 
 	case SCI_SETSELFORE:
-		vs.selforeset = wParam != 0;
-		vs.selforeground.desired = ColourDesired(lParam);
+		vs.selColours.fore = ColourOptional(wParam, lParam);
+		vs.selAdditionalForeground = ColourDesired(static_cast<int>(lParam));
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_SETSELBACK:
-		vs.selbackset = wParam != 0;
-		vs.selbackground.desired = ColourDesired(lParam);
+		vs.selColours.back = ColourOptional(wParam, lParam);
+		vs.selAdditionalBackground = ColourDesired(static_cast<int>(lParam));
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_SETSELALPHA:
-		vs.selAlpha = wParam;
+		vs.selAlpha = static_cast<int>(wParam);
+		vs.selAdditionalAlpha = static_cast<int>(wParam);
 		InvalidateStyleRedraw();
 		break;
 
@@ -7134,28 +7368,26 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case SCI_SETWHITESPACEFORE:
-		vs.whitespaceForegroundSet = wParam != 0;
-		vs.whitespaceForeground.desired = ColourDesired(lParam);
+		vs.whitespaceColours.fore = ColourOptional(wParam, lParam);
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_SETWHITESPACEBACK:
-		vs.whitespaceBackgroundSet = wParam != 0;
-		vs.whitespaceBackground.desired = ColourDesired(lParam);
+		vs.whitespaceColours.back = ColourOptional(wParam, lParam);
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_SETCARETFORE:
-		vs.caretcolour.desired = ColourDesired(wParam);
+		vs.caretcolour = ColourDesired(static_cast<int>(wParam));
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_GETCARETFORE:
-		return vs.caretcolour.desired.AsLong();
+		return vs.caretcolour.AsInteger();
 
 	case SCI_SETCARETSTYLE:
-		if (wParam >= CARETSTYLE_INVISIBLE && wParam <= CARETSTYLE_BLOCK)
-			vs.caretStyle = wParam;
+		if (wParam <= (CARETSTYLE_BLOCK | CARETSTYLE_OVERSTRIKE_BLOCK | CARETSTYLE_BLOCK_AFTER))
+			vs.caretStyle = static_cast<int>(wParam);
 		else
 			/* Default to the line caret */
 			vs.caretStyle = CARETSTYLE_LINE;
@@ -7166,12 +7398,7 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return vs.caretStyle;
 
 	case SCI_SETCARETWIDTH:
-		if (wParam <= 0)
-			vs.caretWidth = 0;
-		else if (wParam >= 3)
-			vs.caretWidth = 3;
-		else
-			vs.caretWidth = wParam;
+		vs.caretWidth = std::clamp(static_cast<int>(wParam), 0, 20);
 		InvalidateStyleRedraw();
 		break;
 
@@ -7179,13 +7406,13 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return vs.caretWidth;
 
 	case SCI_ASSIGNCMDKEY:
-		kmap.AssignCmdKey(Platform::LowShortFromLong(wParam),
-		        Platform::HighShortFromLong(wParam), lParam);
+		kmap.AssignCmdKey(LowShortFromWParam(wParam),
+			HighShortFromWParam(wParam), static_cast<unsigned int>(lParam));
 		break;
 
 	case SCI_CLEARCMDKEY:
-		kmap.AssignCmdKey(Platform::LowShortFromLong(wParam),
-		        Platform::HighShortFromLong(wParam), SCI_NULL);
+		kmap.AssignCmdKey(LowShortFromWParam(wParam),
+			HighShortFromWParam(wParam), SCI_NULL);
 		break;
 
 	case SCI_CLEARALLCMDKEYS:
@@ -7193,65 +7420,119 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case SCI_INDICSETSTYLE:
-		if (wParam <= INDIC_MAX) {
-			vs.indicators[wParam].style = lParam;
+		if (wParam <= INDICATOR_MAX) {
+			vs.indicators[wParam].sacNormal.style = static_cast<int>(lParam);
+			vs.indicators[wParam].sacHover.style = static_cast<int>(lParam);
 			InvalidateStyleRedraw();
 		}
 		break;
 
 	case SCI_INDICGETSTYLE:
-		return (wParam <= INDIC_MAX) ? vs.indicators[wParam].style : 0;
+		return (wParam <= INDICATOR_MAX) ? vs.indicators[wParam].sacNormal.style : 0;
 
 	case SCI_INDICSETFORE:
-		if (wParam <= INDIC_MAX) {
-			vs.indicators[wParam].fore.desired = ColourDesired(lParam);
+		if (wParam <= INDICATOR_MAX) {
+			vs.indicators[wParam].sacNormal.fore = ColourDesired(static_cast<int>(lParam));
+			vs.indicators[wParam].sacHover.fore = ColourDesired(static_cast<int>(lParam));
 			InvalidateStyleRedraw();
 		}
 		break;
 
 	case SCI_INDICGETFORE:
-		return (wParam <= INDIC_MAX) ? vs.indicators[wParam].fore.desired.AsLong() : 0;
+		return (wParam <= INDICATOR_MAX) ? vs.indicators[wParam].sacNormal.fore.AsInteger() : 0;
+
+	case SCI_INDICSETHOVERSTYLE:
+		if (wParam <= INDICATOR_MAX) {
+			vs.indicators[wParam].sacHover.style = static_cast<int>(lParam);
+			InvalidateStyleRedraw();
+		}
+		break;
+
+	case SCI_INDICGETHOVERSTYLE:
+		return (wParam <= INDICATOR_MAX) ? vs.indicators[wParam].sacHover.style : 0;
+
+	case SCI_INDICSETHOVERFORE:
+		if (wParam <= INDICATOR_MAX) {
+			vs.indicators[wParam].sacHover.fore = ColourDesired(static_cast<int>(lParam));
+			InvalidateStyleRedraw();
+		}
+		break;
+
+	case SCI_INDICGETHOVERFORE:
+		return (wParam <= INDICATOR_MAX) ? vs.indicators[wParam].sacHover.fore.AsInteger() : 0;
+
+	case SCI_INDICSETFLAGS:
+		if (wParam <= INDICATOR_MAX) {
+			vs.indicators[wParam].SetFlags(static_cast<int>(lParam));
+			InvalidateStyleRedraw();
+		}
+		break;
+
+	case SCI_INDICGETFLAGS:
+		return (wParam <= INDICATOR_MAX) ? vs.indicators[wParam].Flags() : 0;
 
 	case SCI_INDICSETUNDER:
-		if (wParam <= INDIC_MAX) {
+		if (wParam <= INDICATOR_MAX) {
 			vs.indicators[wParam].under = lParam != 0;
 			InvalidateStyleRedraw();
 		}
 		break;
 
 	case SCI_INDICGETUNDER:
-		return (wParam <= INDIC_MAX) ? vs.indicators[wParam].under : 0;
+		return (wParam <= INDICATOR_MAX) ? vs.indicators[wParam].under : 0;
+
+	case SCI_INDICSETALPHA:
+		if (wParam <= INDICATOR_MAX && lParam >=0 && lParam <= 255) {
+			vs.indicators[wParam].fillAlpha = static_cast<int>(lParam);
+			InvalidateStyleRedraw();
+		}
+		break;
+
+	case SCI_INDICGETALPHA:
+		return (wParam <= INDICATOR_MAX) ? vs.indicators[wParam].fillAlpha : 0;
+
+	case SCI_INDICSETOUTLINEALPHA:
+		if (wParam <= INDICATOR_MAX && lParam >=0 && lParam <= 255) {
+			vs.indicators[wParam].outlineAlpha = static_cast<int>(lParam);
+			InvalidateStyleRedraw();
+		}
+		break;
+
+	case SCI_INDICGETOUTLINEALPHA:
+		return (wParam <= INDICATOR_MAX) ? vs.indicators[wParam].outlineAlpha : 0;
 
 	case SCI_SETINDICATORCURRENT:
-		pdoc->decorations.SetCurrentIndicator(wParam);
+		pdoc->DecorationSetCurrentIndicator(static_cast<int>(wParam));
 		break;
 	case SCI_GETINDICATORCURRENT:
-		return pdoc->decorations.GetCurrentIndicator();
+		return pdoc->decorations->GetCurrentIndicator();
 	case SCI_SETINDICATORVALUE:
-		pdoc->decorations.SetCurrentValue(wParam);
+		pdoc->decorations->SetCurrentValue(static_cast<int>(wParam));
 		break;
 	case SCI_GETINDICATORVALUE:
-		return pdoc->decorations.GetCurrentValue();
+		return pdoc->decorations->GetCurrentValue();
 
 	case SCI_INDICATORFILLRANGE:
-		pdoc->DecorationFillRange(wParam, pdoc->decorations.GetCurrentValue(), lParam);
+		pdoc->DecorationFillRange(static_cast<Sci::Position>(wParam),
+			pdoc->decorations->GetCurrentValue(), lParam);
 		break;
 
 	case SCI_INDICATORCLEARRANGE:
-		pdoc->DecorationFillRange(wParam, 0, lParam);
+		pdoc->DecorationFillRange(static_cast<Sci::Position>(wParam), 0,
+			lParam);
 		break;
 
 	case SCI_INDICATORALLONFOR:
-		return pdoc->decorations.AllOnFor(wParam);
+		return pdoc->decorations->AllOnFor(static_cast<Sci::Position>(wParam));
 
 	case SCI_INDICATORVALUEAT:
-		return pdoc->decorations.ValueAt(wParam, lParam);
+		return pdoc->decorations->ValueAt(static_cast<int>(wParam), lParam);
 
 	case SCI_INDICATORSTART:
-		return pdoc->decorations.Start(wParam, lParam);
+		return pdoc->decorations->Start(static_cast<int>(wParam), lParam);
 
 	case SCI_INDICATOREND:
-		return pdoc->decorations.End(wParam, lParam);
+		return pdoc->decorations->End(static_cast<int>(wParam), lParam);
 
 	case SCI_LINEDOWN:
 	case SCI_LINEDOWNEXTEND:
@@ -7285,6 +7566,8 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	case SCI_DOCUMENTSTARTEXTEND:
 	case SCI_DOCUMENTEND:
 	case SCI_DOCUMENTENDEXTEND:
+	case SCI_SCROLLTOSTART:
+	case SCI_SCROLLTOEND:
 
 	case SCI_STUTTEREDPAGEUP:
 	case SCI_STUTTEREDPAGEUPEXTEND:
@@ -7306,6 +7589,8 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	case SCI_VCHOMEEXTEND:
 	case SCI_VCHOMEWRAP:
 	case SCI_VCHOMEWRAPEXTEND:
+	case SCI_VCHOMEDISPLAY:
+	case SCI_VCHOMEDISPLAYEXTEND:
 	case SCI_ZOOMIN:
 	case SCI_ZOOMOUT:
 	case SCI_DELWORDLEFT:
@@ -7317,6 +7602,7 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	case SCI_LINECUT:
 	case SCI_LINEDELETE:
 	case SCI_LINETRANSPOSE:
+	case SCI_LINEREVERSE:
 	case SCI_LINEDUPLICATE:
 	case SCI_LOWERCASE:
 	case SCI_UPPERCASE:
@@ -7344,17 +7630,34 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return KeyCommand(iMessage);
 
 	case SCI_BRACEHIGHLIGHT:
-		SetBraceHighlight(static_cast<int>(wParam), lParam, STYLE_BRACELIGHT);
+		SetBraceHighlight(static_cast<Sci::Position>(wParam), lParam, STYLE_BRACELIGHT);
+		break;
+
+	case SCI_BRACEHIGHLIGHTINDICATOR:
+		if (lParam >= 0 && lParam <= INDICATOR_MAX) {
+			vs.braceHighlightIndicatorSet = wParam != 0;
+			vs.braceHighlightIndicator = static_cast<int>(lParam);
+		}
 		break;
 
 	case SCI_BRACEBADLIGHT:
-		SetBraceHighlight(static_cast<int>(wParam), -1, STYLE_BRACEBAD);
+		SetBraceHighlight(static_cast<Sci::Position>(wParam), -1, STYLE_BRACEBAD);
+		break;
+
+	case SCI_BRACEBADLIGHTINDICATOR:
+		if (lParam >= 0 && lParam <= INDICATOR_MAX) {
+			vs.braceBadLightIndicatorSet = wParam != 0;
+			vs.braceBadLightIndicator = static_cast<int>(lParam);
+		}
 		break;
 
 	case SCI_BRACEMATCH:
 		// wParam is position of char to find brace for,
 		// lParam is maximum amount of text to restyle to find it
-		return pdoc->BraceMatch(wParam, lParam);
+		return pdoc->BraceMatch(static_cast<Sci::Position>(wParam), lParam, 0, false);
+
+	case SCI_BRACEMATCHNEXT:
+		return pdoc->BraceMatch(static_cast<Sci::Position>(wParam), 0, lParam, true);
 
 	case SCI_GETVIEWEOL:
 		return vs.viewEOL;
@@ -7364,20 +7667,24 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		InvalidateStyleRedraw();
 		break;
 
-	case SCI_SETZOOM:
-		vs.zoomLevel = wParam;
-		InvalidateStyleRedraw();
-		NotifyZoom();
-		break;
+	case SCI_SETZOOM: {
+			const int zoomLevel = static_cast<int>(wParam);
+			if (zoomLevel != vs.zoomLevel) {
+				vs.zoomLevel = zoomLevel;
+				InvalidateStyleRedraw();
+				NotifyZoom();
+			}
+			break;
+		}
 
 	case SCI_GETZOOM:
 		return vs.zoomLevel;
 
 	case SCI_GETEDGECOLUMN:
-		return theEdge;
+		return vs.theEdge.column;
 
 	case SCI_SETEDGECOLUMN:
-		theEdge = wParam;
+		vs.theEdge.column = static_cast<int>(wParam);
 		InvalidateStyleRedraw();
 		break;
 
@@ -7385,105 +7692,169 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return vs.edgeState;
 
 	case SCI_SETEDGEMODE:
-		vs.edgeState = wParam;
+		vs.edgeState = static_cast<int>(wParam);
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_GETEDGECOLOUR:
-		return vs.edgecolour.desired.AsLong();
+		return vs.theEdge.colour.AsInteger();
 
 	case SCI_SETEDGECOLOUR:
-		vs.edgecolour.desired = ColourDesired(wParam);
+		vs.theEdge.colour = ColourDesired(static_cast<int>(wParam));
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_MULTIEDGEADDLINE:
+		vs.AddMultiEdge(wParam, lParam);
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_MULTIEDGECLEARALL:
+		std::vector<EdgeProperties>().swap(vs.theMultiEdge); // Free vector and memory, C++03 compatible
 		InvalidateStyleRedraw();
 		break;
 
+	case SCI_GETMULTIEDGECOLUMN: {
+			const size_t which = wParam;
+			// size_t is unsigned so this also handles negative inputs.
+			if (which >= vs.theMultiEdge.size()) {
+				return -1;
+			}
+			return vs.theMultiEdge[which].column;
+		}
+
+	case SCI_GETACCESSIBILITY:
+		return SC_ACCESSIBILITY_DISABLED;
+
+	case SCI_SETACCESSIBILITY:
+		// May be implemented by platform code.
+		break;
+
 	case SCI_GETDOCPOINTER:
 		return reinterpret_cast<sptr_t>(pdoc);
 
 	case SCI_SETDOCPOINTER:
 		CancelModes();
-		SetDocPointer(reinterpret_cast<Document *>(lParam));
+		SetDocPointer(static_cast<Document *>(PtrFromSPtr(lParam)));
 		return 0;
 
 	case SCI_CREATEDOCUMENT: {
-			Document *doc = new Document();
-			if (doc) {
-				doc->AddRef();
-			}
+			Document *doc = new Document(static_cast<int>(lParam));
+			doc->AddRef();
+			doc->Allocate(static_cast<Sci::Position>(wParam));
+			pcs = ContractionStateCreate(pdoc->IsLarge());
 			return reinterpret_cast<sptr_t>(doc);
 		}
 
 	case SCI_ADDREFDOCUMENT:
-		(reinterpret_cast<Document *>(lParam))->AddRef();
+		(static_cast<Document *>(PtrFromSPtr(lParam)))->AddRef();
 		break;
 
 	case SCI_RELEASEDOCUMENT:
-		(reinterpret_cast<Document *>(lParam))->Release();
+		(static_cast<Document *>(PtrFromSPtr(lParam)))->Release();
 		break;
 
+	case SCI_GETDOCUMENTOPTIONS:
+		return pdoc->Options();
+
+	case SCI_CREATELOADER: {
+			Document *doc = new Document(static_cast<int>(lParam));
+			doc->AddRef();
+			doc->Allocate(static_cast<Sci::Position>(wParam));
+			doc->SetUndoCollection(false);
+			pcs = ContractionStateCreate(pdoc->IsLarge());
+			return reinterpret_cast<sptr_t>(static_cast<ILoader *>(doc));
+		}
+
 	case SCI_SETMODEVENTMASK:
-		modEventMask = wParam;
+		modEventMask = static_cast<int>(wParam);
 		return 0;
 
 	case SCI_GETMODEVENTMASK:
 		return modEventMask;
 
+	case SCI_SETCOMMANDEVENTS:
+		commandEvents = static_cast<bool>(wParam);
+		return 0;
+
+	case SCI_GETCOMMANDEVENTS:
+		return commandEvents;
+
 	case SCI_CONVERTEOLS:
-		pdoc->ConvertLineEnds(wParam);
-		SetSelection(currentPos, anchor);	// Ensure selection inside document
+		pdoc->ConvertLineEnds(static_cast<int>(wParam));
+		SetSelection(sel.MainCaret(), sel.MainAnchor());	// Ensure selection inside document
 		return 0;
 
 	case SCI_SETLENGTHFORENCODE:
-		lengthForEncode = wParam;
+		lengthForEncode = static_cast<Sci::Position>(wParam);
 		return 0;
 
 	case SCI_SELECTIONISRECTANGLE:
-		return selType == selRectangle ? 1 : 0;
+		return sel.selType == Selection::selRectangle ? 1 : 0;
 
 	case SCI_SETSELECTIONMODE: {
 			switch (wParam) {
 			case SC_SEL_STREAM:
-				moveExtendsSelection = !moveExtendsSelection || (selType != selStream);
-				selType = selStream;
+				sel.SetMoveExtends(!sel.MoveExtends() || (sel.selType != Selection::selStream));
+				sel.selType = Selection::selStream;
 				break;
 			case SC_SEL_RECTANGLE:
-				moveExtendsSelection = !moveExtendsSelection || (selType != selRectangle);
-				selType = selRectangle;
+				sel.SetMoveExtends(!sel.MoveExtends() || (sel.selType != Selection::selRectangle));
+				sel.selType = Selection::selRectangle;
+				sel.Rectangular() = sel.RangeMain(); // adjust current selection
 				break;
 			case SC_SEL_LINES:
-				moveExtendsSelection = !moveExtendsSelection || (selType != selLines);
-				selType = selLines;
+				sel.SetMoveExtends(!sel.MoveExtends() || (sel.selType != Selection::selLines));
+				sel.selType = Selection::selLines;
+				SetSelection(sel.RangeMain().caret, sel.RangeMain().anchor); // adjust current selection
+				break;
+			case SC_SEL_THIN:
+				sel.SetMoveExtends(!sel.MoveExtends() || (sel.selType != Selection::selThin));
+				sel.selType = Selection::selThin;
 				break;
 			default:
-				moveExtendsSelection = !moveExtendsSelection || (selType != selStream);
-				selType = selStream;
+				sel.SetMoveExtends(!sel.MoveExtends() || (sel.selType != Selection::selStream));
+				sel.selType = Selection::selStream;
 			}
-			InvalidateSelection(currentPos, anchor, true);
+			InvalidateWholeSelection();
+			break;
 		}
 	case SCI_GETSELECTIONMODE:
-		switch (selType) {
-		case selStream:
+		switch (sel.selType) {
+		case Selection::selStream:
 			return SC_SEL_STREAM;
-		case selRectangle:
+		case Selection::selRectangle:
 			return SC_SEL_RECTANGLE;
-		case selLines:
+		case Selection::selLines:
 			return SC_SEL_LINES;
+		case Selection::selThin:
+			return SC_SEL_THIN;
 		default:	// ?!
 			return SC_SEL_STREAM;
 		}
-	case SCI_GETLINESELSTARTPOSITION: {
-			SelectionLineIterator lineIterator(this);
-			lineIterator.SetAt(wParam);
-			return lineIterator.startPos;
-		}
+	case SCI_GETMOVEEXTENDSSELECTION:
+		return sel.MoveExtends();
+	case SCI_GETLINESELSTARTPOSITION:
 	case SCI_GETLINESELENDPOSITION: {
-			SelectionLineIterator lineIterator(this);
-			lineIterator.SetAt(wParam);
-			return lineIterator.endPos;
+			const SelectionSegment segmentLine(
+				SelectionPosition(pdoc->LineStart(static_cast<Sci::Position>(wParam))),
+				SelectionPosition(pdoc->LineEnd(static_cast<Sci::Position>(wParam))));
+			for (size_t r=0; r<sel.Count(); r++) {
+				const SelectionSegment portion = sel.Range(r).Intersect(segmentLine);
+				if (portion.start.IsValid()) {
+					return (iMessage == SCI_GETLINESELSTARTPOSITION) ? portion.start.Position() : portion.end.Position();
+				}
+			}
+			return INVALID_POSITION;
 		}
 
 	case SCI_SETOVERTYPE:
-		inOverstrike = wParam != 0;
+		if (inOverstrike != (wParam != 0)) {
+			inOverstrike = wParam != 0;
+			ContainerNeedsUpdate(SC_UPDATE_SELECTION);
+			ShowCaretAtCurrentPosition();
+			SetIdle(true);
+		}
 		break;
 
 	case SCI_GETOVERTYPE:
@@ -7497,7 +7868,7 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return hasFocus;
 
 	case SCI_SETSTATUS:
-		errorStatus = wParam;
+		errorStatus = static_cast<int>(wParam);
 		break;
 
 	case SCI_GETSTATUS:
@@ -7510,8 +7881,15 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	case SCI_GETMOUSEDOWNCAPTURES:
 		return mouseDownCaptures;
 
+	case SCI_SETMOUSEWHEELCAPTURES:
+		mouseWheelCaptures = wParam != 0;
+		break;
+
+	case SCI_GETMOUSEWHEELCAPTURES:
+		return mouseWheelCaptures;
+
 	case SCI_SETCURSOR:
-		cursorMode = wParam;
+		cursorMode = static_cast<int>(wParam);
 		DisplayCursor(Window::cursorText);
 		break;
 
@@ -7519,11 +7897,29 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		return cursorMode;
 
 	case SCI_SETCONTROLCHARSYMBOL:
-		controlCharSymbol = wParam;
+		vs.controlCharSymbol = static_cast<int>(wParam);
+		InvalidateStyleRedraw();
 		break;
 
 	case SCI_GETCONTROLCHARSYMBOL:
-		return controlCharSymbol;
+		return vs.controlCharSymbol;
+
+	case SCI_SETREPRESENTATION:
+		reprs.SetRepresentation(ConstCharPtrFromUPtr(wParam), ConstCharPtrFromSPtr(lParam));
+		break;
+
+	case SCI_GETREPRESENTATION: {
+			const Representation *repr = reprs.RepresentationFromCharacter(
+				ConstCharPtrFromUPtr(wParam), UTF8MaxBytes);
+			if (repr) {
+				return StringResult(lParam, repr->stringRep.c_str());
+			}
+			return 0;
+		}
+
+	case SCI_CLEARREPRESENTATION:
+		reprs.ClearRepresentation(ConstCharPtrFromUPtr(wParam));
+		break;
 
 	case SCI_STARTRECORD:
 		recordingMacro = true;
@@ -7538,34 +7934,30 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 		break;
 
 	case SCI_SETFOLDMARGINCOLOUR:
-		vs.foldmarginColourSet = wParam != 0;
-		vs.foldmarginColour.desired = ColourDesired(lParam);
+		vs.foldmarginColour = ColourOptional(wParam, lParam);
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_SETFOLDMARGINHICOLOUR:
-		vs.foldmarginHighlightColourSet = wParam != 0;
-		vs.foldmarginHighlightColour.desired = ColourDesired(lParam);
+		vs.foldmarginHighlightColour = ColourOptional(wParam, lParam);
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_SETHOTSPOTACTIVEFORE:
-		vs.hotspotForegroundSet = wParam != 0;
-		vs.hotspotForeground.desired = ColourDesired(lParam);
+		vs.hotspotColours.fore = ColourOptional(wParam, lParam);
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_GETHOTSPOTACTIVEFORE:
-		return vs.hotspotForeground.desired.AsLong();
+		return vs.hotspotColours.fore.AsInteger();
 
 	case SCI_SETHOTSPOTACTIVEBACK:
-		vs.hotspotBackgroundSet = wParam != 0;
-		vs.hotspotBackground.desired = ColourDesired(lParam);
+		vs.hotspotColours.back = ColourOptional(wParam, lParam);
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_GETHOTSPOTACTIVEBACK:
-		return vs.hotspotBackground.desired.AsLong();
+		return vs.hotspotColours.back.AsInteger();
 
 	case SCI_SETHOTSPOTACTIVEUNDERLINE:
 		vs.hotspotUnderline = wParam != 0;
@@ -7593,9 +7985,415 @@ sptr_t Editor::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	case SCI_GETCHARACTERPOINTER:
 		return reinterpret_cast<sptr_t>(pdoc->BufferPointer());
 
+	case SCI_GETRANGEPOINTER:
+		return reinterpret_cast<sptr_t>(pdoc->RangePointer(
+			static_cast<Sci::Position>(wParam), lParam));
+
+	case SCI_GETGAPPOSITION:
+		return pdoc->GapPosition();
+
+	case SCI_SETEXTRAASCENT:
+		vs.extraAscent = static_cast<int>(wParam);
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_GETEXTRAASCENT:
+		return vs.extraAscent;
+
+	case SCI_SETEXTRADESCENT:
+		vs.extraDescent = static_cast<int>(wParam);
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_GETEXTRADESCENT:
+		return vs.extraDescent;
+
+	case SCI_MARGINSETSTYLEOFFSET:
+		vs.marginStyleOffset = static_cast<int>(wParam);
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_MARGINGETSTYLEOFFSET:
+		return vs.marginStyleOffset;
+
+	case SCI_SETMARGINOPTIONS:
+		marginOptions = static_cast<int>(wParam);
+		break;
+
+	case SCI_GETMARGINOPTIONS:
+		return marginOptions;
+
+	case SCI_MARGINSETTEXT:
+		pdoc->MarginSetText(static_cast<Sci::Line>(wParam), CharPtrFromSPtr(lParam));
+		break;
+
+	case SCI_MARGINGETTEXT: {
+			const StyledText st = pdoc->MarginStyledText(static_cast<Sci::Line>(wParam));
+			return BytesResult(lParam, reinterpret_cast<const unsigned char *>(st.text), st.length);
+		}
+
+	case SCI_MARGINSETSTYLE:
+		pdoc->MarginSetStyle(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+		break;
+
+	case SCI_MARGINGETSTYLE: {
+			const StyledText st = pdoc->MarginStyledText(static_cast<Sci::Line>(wParam));
+			return st.style;
+		}
+
+	case SCI_MARGINSETSTYLES:
+		pdoc->MarginSetStyles(static_cast<Sci::Line>(wParam), ConstUCharPtrFromSPtr(lParam));
+		break;
+
+	case SCI_MARGINGETSTYLES: {
+			const StyledText st = pdoc->MarginStyledText(static_cast<Sci::Line>(wParam));
+			return BytesResult(lParam, st.styles, st.length);
+		}
+
+	case SCI_MARGINTEXTCLEARALL:
+		pdoc->MarginClearAll();
+		break;
+
+	case SCI_ANNOTATIONSETTEXT:
+		pdoc->AnnotationSetText(static_cast<Sci::Line>(wParam), CharPtrFromSPtr(lParam));
+		break;
+
+	case SCI_ANNOTATIONGETTEXT: {
+			const StyledText st = pdoc->AnnotationStyledText(static_cast<Sci::Line>(wParam));
+			return BytesResult(lParam, reinterpret_cast<const unsigned char *>(st.text), st.length);
+		}
+
+	case SCI_ANNOTATIONGETSTYLE: {
+			const StyledText st = pdoc->AnnotationStyledText(static_cast<Sci::Line>(wParam));
+			return st.style;
+		}
+
+	case SCI_ANNOTATIONSETSTYLE:
+		pdoc->AnnotationSetStyle(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+		break;
+
+	case SCI_ANNOTATIONSETSTYLES:
+		pdoc->AnnotationSetStyles(static_cast<Sci::Line>(wParam), ConstUCharPtrFromSPtr(lParam));
+		break;
+
+	case SCI_ANNOTATIONGETSTYLES: {
+			const StyledText st = pdoc->AnnotationStyledText(static_cast<Sci::Line>(wParam));
+			return BytesResult(lParam, st.styles, st.length);
+		}
+
+	case SCI_ANNOTATIONGETLINES:
+		return pdoc->AnnotationLines(static_cast<Sci::Line>(wParam));
+
+	case SCI_ANNOTATIONCLEARALL:
+		pdoc->AnnotationClearAll();
+		break;
+
+	case SCI_ANNOTATIONSETVISIBLE:
+		SetAnnotationVisible(static_cast<int>(wParam));
+		break;
+
+	case SCI_ANNOTATIONGETVISIBLE:
+		return vs.annotationVisible;
+
+	case SCI_ANNOTATIONSETSTYLEOFFSET:
+		vs.annotationStyleOffset = static_cast<int>(wParam);
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_ANNOTATIONGETSTYLEOFFSET:
+		return vs.annotationStyleOffset;
+
+	case SCI_EOLANNOTATIONSETTEXT:
+		pdoc->EOLAnnotationSetText(static_cast<Sci::Line>(wParam), CharPtrFromSPtr(lParam));
+		break;
+
+	case SCI_EOLANNOTATIONGETTEXT: {
+			const StyledText st = pdoc->EOLAnnotationStyledText(static_cast<Sci::Line>(wParam));
+			return BytesResult(lParam, reinterpret_cast<const unsigned char *>(st.text), st.length);
+		}
+
+	case SCI_EOLANNOTATIONGETSTYLE: {
+			const StyledText st = pdoc->EOLAnnotationStyledText(static_cast<Sci::Line>(wParam));
+			return st.style;
+		}
+
+	case SCI_EOLANNOTATIONSETSTYLE:
+		pdoc->EOLAnnotationSetStyle(static_cast<Sci::Line>(wParam), static_cast<int>(lParam));
+		break;
+
+	case SCI_EOLANNOTATIONCLEARALL:
+		pdoc->EOLAnnotationClearAll();
+		break;
+
+	case SCI_EOLANNOTATIONSETVISIBLE:
+		SetEOLAnnotationVisible(static_cast<int>(wParam));
+		break;
+
+	case SCI_EOLANNOTATIONGETVISIBLE:
+		return vs.eolAnnotationVisible;
+
+	case SCI_EOLANNOTATIONSETSTYLEOFFSET:
+		vs.eolAnnotationStyleOffset = static_cast<int>(wParam);
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_EOLANNOTATIONGETSTYLEOFFSET:
+		return vs.eolAnnotationStyleOffset;
+
+	case SCI_RELEASEALLEXTENDEDSTYLES:
+		vs.ReleaseAllExtendedStyles();
+		break;
+
+	case SCI_ALLOCATEEXTENDEDSTYLES:
+		return vs.AllocateExtendedStyles(static_cast<int>(wParam));
+
+	case SCI_ADDUNDOACTION:
+		pdoc->AddUndoAction(static_cast<Sci::Position>(wParam), lParam & UNDO_MAY_COALESCE);
+		break;
+
+	case SCI_SETMOUSESELECTIONRECTANGULARSWITCH:
+		mouseSelectionRectangularSwitch = wParam != 0;
+		break;
+
+	case SCI_GETMOUSESELECTIONRECTANGULARSWITCH:
+		return mouseSelectionRectangularSwitch;
+
+	case SCI_SETMULTIPLESELECTION:
+		multipleSelection = wParam != 0;
+		InvalidateCaret();
+		break;
+
+	case SCI_GETMULTIPLESELECTION:
+		return multipleSelection;
+
+	case SCI_SETADDITIONALSELECTIONTYPING:
+		additionalSelectionTyping = wParam != 0;
+		InvalidateCaret();
+		break;
+
+	case SCI_GETADDITIONALSELECTIONTYPING:
+		return additionalSelectionTyping;
+
+	case SCI_SETMULTIPASTE:
+		multiPasteMode = static_cast<int>(wParam);
+		break;
+
+	case SCI_GETMULTIPASTE:
+		return multiPasteMode;
+
+	case SCI_SETADDITIONALCARETSBLINK:
+		view.additionalCaretsBlink = wParam != 0;
+		InvalidateCaret();
+		break;
+
+	case SCI_GETADDITIONALCARETSBLINK:
+		return view.additionalCaretsBlink;
+
+	case SCI_SETADDITIONALCARETSVISIBLE:
+		view.additionalCaretsVisible = wParam != 0;
+		InvalidateCaret();
+		break;
+
+	case SCI_GETADDITIONALCARETSVISIBLE:
+		return view.additionalCaretsVisible;
+
+	case SCI_GETSELECTIONS:
+		return sel.Count();
+
+	case SCI_GETSELECTIONEMPTY:
+		return sel.Empty();
+
+	case SCI_CLEARSELECTIONS:
+		sel.Clear();
+		ContainerNeedsUpdate(SC_UPDATE_SELECTION);
+		Redraw();
+		break;
+
+	case SCI_SETSELECTION:
+		sel.SetSelection(SelectionRange(static_cast<Sci::Position>(wParam), lParam));
+		Redraw();
+		break;
+
+	case SCI_ADDSELECTION:
+		sel.AddSelection(SelectionRange(static_cast<Sci::Position>(wParam), lParam));
+		ContainerNeedsUpdate(SC_UPDATE_SELECTION);
+		Redraw();
+		break;
+
+	case SCI_DROPSELECTIONN:
+		sel.DropSelection(static_cast<size_t>(wParam));
+		ContainerNeedsUpdate(SC_UPDATE_SELECTION);
+		Redraw();
+		break;
+
+	case SCI_SETMAINSELECTION:
+		sel.SetMain(static_cast<size_t>(wParam));
+		ContainerNeedsUpdate(SC_UPDATE_SELECTION);
+		Redraw();
+		break;
+
+	case SCI_GETMAINSELECTION:
+		return sel.Main();
+
+	case SCI_SETSELECTIONNCARET:
+	case SCI_SETSELECTIONNANCHOR:
+	case SCI_SETSELECTIONNCARETVIRTUALSPACE:
+	case SCI_SETSELECTIONNANCHORVIRTUALSPACE:
+	case SCI_SETSELECTIONNSTART:
+	case SCI_SETSELECTIONNEND:
+		SetSelectionNMessage(iMessage, wParam, lParam);
+		break;
+
+	case SCI_GETSELECTIONNCARET:
+		return sel.Range(wParam).caret.Position();
+
+	case SCI_GETSELECTIONNANCHOR:
+		return sel.Range(wParam).anchor.Position();
+
+	case SCI_GETSELECTIONNCARETVIRTUALSPACE:
+		return sel.Range(wParam).caret.VirtualSpace();
+
+	case SCI_GETSELECTIONNANCHORVIRTUALSPACE:
+		return sel.Range(wParam).anchor.VirtualSpace();
+
+	case SCI_GETSELECTIONNSTART:
+		return sel.Range(wParam).Start().Position();
+
+	case SCI_GETSELECTIONNSTARTVIRTUALSPACE:
+		return sel.Range(wParam).Start().VirtualSpace();
+
+	case SCI_GETSELECTIONNEND:
+		return sel.Range(wParam).End().Position();
+
+	case SCI_GETSELECTIONNENDVIRTUALSPACE:
+		return sel.Range(wParam).End().VirtualSpace();
+
+	case SCI_SETRECTANGULARSELECTIONCARET:
+		if (!sel.IsRectangular())
+			sel.Clear();
+		sel.selType = Selection::selRectangle;
+		sel.Rectangular().caret.SetPosition(static_cast<Sci::Position>(wParam));
+		SetRectangularRange();
+		Redraw();
+		break;
+
+	case SCI_GETRECTANGULARSELECTIONCARET:
+		return sel.Rectangular().caret.Position();
+
+	case SCI_SETRECTANGULARSELECTIONANCHOR:
+		if (!sel.IsRectangular())
+			sel.Clear();
+		sel.selType = Selection::selRectangle;
+		sel.Rectangular().anchor.SetPosition(static_cast<Sci::Position>(wParam));
+		SetRectangularRange();
+		Redraw();
+		break;
+
+	case SCI_GETRECTANGULARSELECTIONANCHOR:
+		return sel.Rectangular().anchor.Position();
+
+	case SCI_SETRECTANGULARSELECTIONCARETVIRTUALSPACE:
+		if (!sel.IsRectangular())
+			sel.Clear();
+		sel.selType = Selection::selRectangle;
+		sel.Rectangular().caret.SetVirtualSpace(static_cast<Sci::Position>(wParam));
+		SetRectangularRange();
+		Redraw();
+		break;
+
+	case SCI_GETRECTANGULARSELECTIONCARETVIRTUALSPACE:
+		return sel.Rectangular().caret.VirtualSpace();
+
+	case SCI_SETRECTANGULARSELECTIONANCHORVIRTUALSPACE:
+		if (!sel.IsRectangular())
+			sel.Clear();
+		sel.selType = Selection::selRectangle;
+		sel.Rectangular().anchor.SetVirtualSpace(static_cast<Sci::Position>(wParam));
+		SetRectangularRange();
+		Redraw();
+		break;
+
+	case SCI_GETRECTANGULARSELECTIONANCHORVIRTUALSPACE:
+		return sel.Rectangular().anchor.VirtualSpace();
+
+	case SCI_SETVIRTUALSPACEOPTIONS:
+		virtualSpaceOptions = static_cast<int>(wParam);
+		break;
+
+	case SCI_GETVIRTUALSPACEOPTIONS:
+		return virtualSpaceOptions;
+
+	case SCI_SETADDITIONALSELFORE:
+		vs.selAdditionalForeground = ColourDesired(static_cast<int>(wParam));
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_SETADDITIONALSELBACK:
+		vs.selAdditionalBackground = ColourDesired(static_cast<int>(wParam));
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_SETADDITIONALSELALPHA:
+		vs.selAdditionalAlpha = static_cast<int>(wParam);
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_GETADDITIONALSELALPHA:
+		return vs.selAdditionalAlpha;
+
+	case SCI_SETADDITIONALCARETFORE:
+		vs.additionalCaretColour = ColourDesired(static_cast<int>(wParam));
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_GETADDITIONALCARETFORE:
+		return vs.additionalCaretColour.AsInteger();
+
+	case SCI_ROTATESELECTION:
+		sel.RotateMain();
+		InvalidateWholeSelection();
+		break;
+
+	case SCI_SWAPMAINANCHORCARET:
+		InvalidateSelection(sel.RangeMain());
+		sel.RangeMain().Swap();
+		break;
+
+	case SCI_MULTIPLESELECTADDNEXT:
+		MultipleSelectAdd(AddNumber::one);
+		break;
+
+	case SCI_MULTIPLESELECTADDEACH:
+		MultipleSelectAdd(AddNumber::each);
+		break;
+
+	case SCI_CHANGELEXERSTATE:
+		pdoc->ChangeLexerState(static_cast<Sci::Position>(wParam), lParam);
+		break;
+
+	case SCI_SETIDENTIFIER:
+		SetCtrlID(static_cast<int>(wParam));
+		break;
+
+	case SCI_GETIDENTIFIER:
+		return GetCtrlID();
+
+	case SCI_SETTECHNOLOGY:
+		// No action by default
+		break;
+
+	case SCI_GETTECHNOLOGY:
+		return technology;
+
+	case SCI_COUNTCHARACTERS:
+		return pdoc->CountCharacters(static_cast<Sci::Position>(wParam), lParam);
+
+	case SCI_COUNTCODEUNITS:
+		return pdoc->CountUTF16(static_cast<Sci::Position>(wParam), lParam);
+
 	default:
 		return DefWndProc(iMessage, wParam, lParam);
 	}
 	//Platform::DebugPrintf("end wnd proc\n");
-	return 0l;
+	return 0;
 }
diff --git a/Pythonwin/Scintilla/src/Editor.h b/Pythonwin/Scintilla/src/Editor.h
index 0d0b8ac9c..9a86d12e1 100644
--- a/Pythonwin/Scintilla/src/Editor.h
+++ b/Pythonwin/Scintilla/src/Editor.h
@@ -2,26 +2,13 @@
 /** @file Editor.h
  ** Defines the main editor class.
  **/
-// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
 #ifndef EDITOR_H
 #define EDITOR_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
-
-/**
- */
-class Caret {
-public:
-	bool active;
-	bool on;
-	int period;
-
-	Caret();
-};
 
 /**
  */
@@ -32,7 +19,7 @@ class Timer {
 	enum {tickSize = 100};
 	TickerID tickerID;
 
-	Timer();
+	Timer() noexcept;
 };
 
 /**
@@ -42,121 +29,175 @@ class Idler {
 	bool state;
 	IdlerID idlerID;
 
-	Idler();
+	Idler() noexcept;
+};
+
+/**
+ * When platform has a way to generate an event before painting,
+ * accumulate needed styling range and other work items in
+ * WorkNeeded to avoid unnecessary work inside paint handler
+ */
+class WorkNeeded {
+public:
+	enum workItems {
+		workNone=0,
+		workStyle=1,
+		workUpdateUI=2
+	};
+	enum workItems items;
+	Sci::Position upTo;
+
+	WorkNeeded() noexcept : items(workNone), upTo(0) {}
+	void Reset() noexcept {
+		items = workNone;
+		upTo = 0;
+	}
+	void Need(workItems items_, Sci::Position pos) noexcept {
+		if ((items_ & workStyle) && (upTo < pos))
+			upTo = pos;
+		items = static_cast<workItems>(items | items_);
+	}
 };
 
 /**
- * Hold a piece of text selected for copying or dragging.
- * The text is expected to hold a terminating '\0' and this is counted in len.
+ * Hold a piece of text selected for copying or dragging, along with encoding and selection format information.
  */
 class SelectionText {
+	std::string s;
 public:
-	char *s;
-	int len;
 	bool rectangular;
 	bool lineCopy;
 	int codePage;
 	int characterSet;
-	SelectionText() : s(0), len(0), rectangular(false), lineCopy(false), codePage(0), characterSet(0) {}
-	~SelectionText() {
-		Free();
+	SelectionText() noexcept : rectangular(false), lineCopy(false), codePage(0), characterSet(0) {}
+	void Clear() noexcept {
+		s.clear();
+		rectangular = false;
+		lineCopy = false;
+		codePage = 0;
+		characterSet = 0;
 	}
-	void Free() {
-		Set(0, 0, 0, 0, false, false);
-	}
-	void Set(char *s_, int len_, int codePage_, int characterSet_, bool rectangular_, bool lineCopy_) {
-		delete []s;
+	void Copy(const std::string &s_, int codePage_, int characterSet_, bool rectangular_, bool lineCopy_) {
 		s = s_;
-		if (s)
-			len = len_;
-		else
-			len = 0;
-		codePage = codePage_;
-		characterSet = characterSet_;
-		rectangular = rectangular_;
-		lineCopy = lineCopy_;
-	}
-	void Copy(const char *s_, int len_, int codePage_, int characterSet_, bool rectangular_, bool lineCopy_) {
-		delete []s;
-		s = new char[len_];
-		if (s) {
-			len = len_;
-			for (int i = 0; i < len_; i++) {
-				s[i] = s_[i];
-			}
-		} else {
-			len = 0;
-		}
 		codePage = codePage_;
 		characterSet = characterSet_;
 		rectangular = rectangular_;
 		lineCopy = lineCopy_;
+		FixSelectionForClipboard();
 	}
 	void Copy(const SelectionText &other) {
-		Copy(other.s, other.len, other.codePage, other.characterSet, other.rectangular, other.lineCopy);
+		Copy(other.s, other.codePage, other.characterSet, other.rectangular, other.lineCopy);
+	}
+	const char *Data() const noexcept {
+		return s.c_str();
+	}
+	size_t Length() const noexcept {
+		return s.length();
+	}
+	size_t LengthWithTerminator() const noexcept {
+		return s.length() + 1;
+	}
+	bool Empty() const noexcept {
+		return s.empty();
+	}
+private:
+	void FixSelectionForClipboard() {
+		// To avoid truncating the contents of the clipboard when pasted where the
+		// clipboard contains NUL characters, replace NUL characters by spaces.
+		std::replace(s.begin(), s.end(), '\0', ' ');
+	}
+};
+
+struct WrapPending {
+	// The range of lines that need to be wrapped
+	enum { lineLarge = 0x7ffffff };
+	Sci::Line start;	// When there are wraps pending, will be in document range
+	Sci::Line end;	// May be lineLarge to indicate all of document after start
+	WrapPending() noexcept {
+		start = lineLarge;
+		end = lineLarge;
+	}
+	void Reset() noexcept {
+		start = lineLarge;
+		end = lineLarge;
+	}
+	void Wrapped(Sci::Line line) noexcept {
+		if (start == line)
+			start++;
+	}
+	bool NeedsWrap() const noexcept {
+		return start < end;
+	}
+	bool AddRange(Sci::Line lineStart, Sci::Line lineEnd) noexcept {
+		const bool neededWrap = NeedsWrap();
+		bool changed = false;
+		if (start > lineStart) {
+			start = lineStart;
+			changed = true;
+		}
+		if ((end < lineEnd) || !neededWrap) {
+			end = lineEnd;
+			changed = true;
+		}
+		return changed;
 	}
 };
 
+struct CaretPolicy {
+	int policy;	// Combination from CARET_SLOP, CARET_STRICT, CARET_JUMPS, CARET_EVEN
+	int slop;	// Pixels for X, lines for Y
+	CaretPolicy(uptr_t policy_=0, sptr_t slop_=0) noexcept :
+		policy(static_cast<int>(policy_)), slop(static_cast<int>(slop_)) {}
+};
+
+struct CaretPolicies {
+	CaretPolicy x;
+	CaretPolicy y;
+};
+
 /**
  */
-class Editor : public DocWatcher {
-	// Private so Editor objects can not be copied
-	Editor(const Editor &) : DocWatcher() {}
-	Editor &operator=(const Editor &) { return *this; }
-
+class Editor : public EditModel, public DocWatcher {
 protected:	// ScintillaBase subclass needs access to much of Editor
 
 	/** On GTK+, Scintilla is a container widget holding two scroll bars
 	 * whereas on Windows there is just one window with both scroll bars turned on. */
 	Window wMain;	///< The Scintilla parent window
+	Window wMargin;	///< May be separate when using a scroll view for wMain
 
 	/** Style resources may be expensive to allocate so are cached between uses.
 	 * When a style attribute is changed, this cache is flushed. */
 	bool stylesValid;
 	ViewStyle vs;
-	Palette palette;
+	int technology;
+	Point sizeRGBAImage;
+	float scaleRGBAImage;
+
+	MarginView marginView;
+	EditView view;
 
-	int printMagnification;
-	int printColourMode;
-	int printWrapState;
 	int cursorMode;
-	int controlCharSymbol;
 
 	bool hasFocus;
-	bool hideSelection;
-	bool inOverstrike;
-	int errorStatus;
 	bool mouseDownCaptures;
+	bool mouseWheelCaptures;
 
-	/** In bufferedDraw mode, graphics operations are drawn to a pixmap and then copied to
-	 * the screen. This avoids flashing but is about 30% slower. */
-	bool bufferedDraw;
-	/** In twoPhaseDraw mode, drawing is performed in two phases, first the background
-	* and then the foreground. This avoids chopping off characters that overlap the next run. */
-	bool twoPhaseDraw;
-
-	int xOffset;		///< Horizontal scrolled amount in pixels
 	int xCaretMargin;	///< Ensure this many pixels visible on both sides of caret
 	bool horizontalScrollBarVisible;
 	int scrollWidth;
-	bool trackLineWidth;
-	int lineWidthMaxSeen;
 	bool verticalScrollBarVisible;
 	bool endAtLastLine;
-	bool caretSticky;
+	int caretSticky;
+	int marginOptions;
+	bool mouseSelectionRectangularSwitch;
+	bool multipleSelection;
+	bool additionalSelectionTyping;
+	int multiPasteMode;
 
-	Surface *pixmapLine;
-	Surface *pixmapSelMargin;
-	Surface *pixmapSelPattern;
-	Surface *pixmapIndentGuide;
-	Surface *pixmapIndentGuideHighlight;
-
-	LineLayoutCache llc;
-	PositionCache posCache;
+	int virtualSpaceOptions;
 
 	KeyMap kmap;
 
-	Caret caret;
 	Timer timer;
 	Timer autoScrollTimer;
 	enum { autoScrollDelay = 200 };
@@ -165,316 +206,432 @@ class Editor : public DocWatcher {
 
 	Point lastClick;
 	unsigned int lastClickTime;
+	Point doubleClickCloseThreshold;
 	int dwellDelay;
 	int ticksToDwell;
 	bool dwelling;
-	enum { selChar, selWord, selLine } selectionType;
+	enum class TextUnit { character, word, subLine, wholeLine } selectionUnit;
 	Point ptMouseLast;
 	enum { ddNone, ddInitial, ddDragging } inDragDrop;
 	bool dropWentOutside;
-	int posDrag;
-	int posDrop;
+	SelectionPosition posDrop;
+	Sci::Position hotSpotClickPos;
 	int lastXChosen;
-	int lineAnchor;
-	int originalAnchorPos;
-	int currentPos;
-	int anchor;
-	int targetStart;
-	int targetEnd;
+	Sci::Position lineAnchorPos;
+	Sci::Position originalAnchorPos;
+	Sci::Position wordSelectAnchorStartPos;
+	Sci::Position wordSelectAnchorEndPos;
+	Sci::Position wordSelectInitialCaretPos;
+	SelectionSegment targetRange;
 	int searchFlags;
-	int topLine;
-	int posTopLine;
-	int lengthForEncode;
-
-	bool needUpdateUI;
-	Position braces[2];
-	int bracesMatchStyle;
-	int highlightGuideColumn;
+	Sci::Line topLine;
+	Sci::Position posTopLine;
+	Sci::Position lengthForEncode;
 
-	int theEdge;
+	int needUpdateUI;
 
 	enum { notPainting, painting, paintAbandoned } paintState;
+	bool paintAbandonedByStyling;
 	PRectangle rcPaint;
 	bool paintingAllText;
+	bool willRedrawAll;
+	WorkNeeded workNeeded;
+	int idleStyling;
+	bool needIdleStyling;
 
 	int modEventMask;
+	bool commandEvents;
 
 	SelectionText drag;
-	enum selTypes { noSel, selStream, selRectangle, selLines };
-	selTypes selType;
-	bool moveExtendsSelection;
-	int xStartSelect;	///< x position of start of rectangular selection
-	int xEndSelect;		///< x position of end of rectangular selection
-	bool primarySelection;
-
-	int caretXPolicy;
-	int caretXSlop;	///< Ensure this many pixels visible on both sides of caret
 
-	int caretYPolicy;
-	int caretYSlop;	///< Ensure this many lines visible on both sides of caret
+	CaretPolicies caretPolicies;
 
-	int visiblePolicy;
-	int visibleSlop;
+	CaretPolicy visiblePolicy;
 
-	int searchAnchor;
+	Sci::Position searchAnchor;
 
 	bool recordingMacro;
 
-	int foldFlags;
-	ContractionState cs;
-
-	// Hotspot support
-	int hsStart;
-	int hsEnd;
+	int foldAutomatic;
 
 	// Wrapping support
-	enum { eWrapNone, eWrapWord, eWrapChar } wrapState;
-	enum { wrapLineLarge = 0x7ffffff };
-	int wrapWidth;
-	int wrapStart;
-	int wrapEnd;
-	int wrapVisualFlags;
-	int wrapVisualFlagsLocation;
-	int wrapVisualStartIndent;
-	int actualWrapVisualStartIndent;
+	WrapPending wrapPending;
+	ActionDuration durationWrapOneLine;
 
 	bool convertPastes;
 
-	Document *pdoc;
-
 	Editor();
-	virtual ~Editor();
+	// Deleted so Editor objects can not be copied.
+	Editor(const Editor &) = delete;
+	Editor(Editor &&) = delete;
+	Editor &operator=(const Editor &) = delete;
+	Editor &operator=(Editor &&) = delete;
+	// ~Editor() in public section
 	virtual void Initialise() = 0;
 	virtual void Finalise();
 
 	void InvalidateStyleData();
 	void InvalidateStyleRedraw();
-	virtual void RefreshColourPalette(Palette &pal, bool want);
 	void RefreshStyleData();
-	void DropGraphics();
-
-	virtual PRectangle GetClientRectangle();
-	PRectangle GetTextRectangle();
-
-	int LinesOnScreen();
-	int LinesToScroll();
-	int MaxScrollPos();
-	Point LocationFromPosition(int pos);
-	int XFromPosition(int pos);
-	int PositionFromLocation(Point pt);
-	int PositionFromLocationClose(Point pt);
-	int PositionFromLineX(int line, int x);
-	int LineFromLocation(Point pt);
-	void SetTopLine(int topLineNew);
-
-	bool AbandonPaint();
-	void RedrawRect(PRectangle rc);
-	void Redraw();
-	void RedrawSelMargin(int line=-1);
-	PRectangle RectangleFromRange(int start, int end);
-	void InvalidateRange(int start, int end);
-
-	int CurrentPosition();
-	bool SelectionEmpty();
-	int SelectionStart();
-	int SelectionEnd();
+	void SetRepresentations();
+	void DropGraphics(bool freeObjects);
+	void AllocateGraphics();
+
+	// The top left visible point in main window coordinates. Will be 0,0 except for
+	// scroll views where it will be equivalent to the current scroll position.
+	Point GetVisibleOriginInMain() const override;
+	PointDocument DocumentPointFromView(Point ptView) const;  // Convert a point from view space to document
+	Sci::Line TopLineOfMain() const override;   // Return the line at Main's y coordinate 0
+	virtual PRectangle GetClientRectangle() const;
+	virtual PRectangle GetClientDrawingRectangle();
+	PRectangle GetTextRectangle() const;
+
+	Sci::Line LinesOnScreen() const override;
+	Sci::Line LinesToScroll() const;
+	Sci::Line MaxScrollPos() const;
+	SelectionPosition ClampPositionIntoDocument(SelectionPosition sp) const;
+	Point LocationFromPosition(SelectionPosition pos, PointEnd pe=peDefault);
+	Point LocationFromPosition(Sci::Position pos, PointEnd pe=peDefault);
+	int XFromPosition(SelectionPosition sp);
+	SelectionPosition SPositionFromLocation(Point pt, bool canReturnInvalid=false, bool charPosition=false, bool virtualSpace=true);
+	Sci::Position PositionFromLocation(Point pt, bool canReturnInvalid = false, bool charPosition = false);
+	SelectionPosition SPositionFromLineX(Sci::Line lineDoc, int x);
+	Sci::Position PositionFromLineX(Sci::Line lineDoc, int x);
+	Sci::Line LineFromLocation(Point pt) const;
+	void SetTopLine(Sci::Line topLineNew);
+
+	virtual bool AbandonPaint();
+	virtual void RedrawRect(PRectangle rc);
+	virtual void DiscardOverdraw();
+	virtual void Redraw();
+	void RedrawSelMargin(Sci::Line line=-1, bool allAfter=false);
+	PRectangle RectangleFromRange(Range r, int overlap);
+	void InvalidateRange(Sci::Position start, Sci::Position end);
+
+	bool UserVirtualSpace() const noexcept {
+		return ((virtualSpaceOptions & SCVS_USERACCESSIBLE) != 0);
+	}
+	Sci::Position CurrentPosition() const;
+	bool SelectionEmpty() const noexcept;
+	SelectionPosition SelectionStart();
+	SelectionPosition SelectionEnd();
 	void SetRectangularRange();
-	void InvalidateSelection(int currentPos_, int anchor_, bool invalidateWholeSelection);
-	void SetSelection(int currentPos_, int anchor_);
+	void ThinRectangularRange();
+	void InvalidateSelection(SelectionRange newMain, bool invalidateWholeSelection=false);
+	void InvalidateWholeSelection();
+	SelectionRange LineSelectionRange(SelectionPosition currentPos_, SelectionPosition anchor_) const;
+	void SetSelection(SelectionPosition currentPos_, SelectionPosition anchor_);
+	void SetSelection(Sci::Position currentPos_, Sci::Position anchor_);
+	void SetSelection(SelectionPosition currentPos_);
 	void SetSelection(int currentPos_);
-	void SetEmptySelection(int currentPos_);
-	bool RangeContainsProtected(int start, int end) const;
-	bool SelectionContainsProtected();
-	int MovePositionOutsideChar(int pos, int moveDir, bool checkLineEnd=true);
-	int MovePositionTo(int newPos, selTypes sel=noSel, bool ensureVisible=true);
-	int MovePositionSoVisible(int pos, int moveDir);
+	void SetEmptySelection(SelectionPosition currentPos_);
+	void SetEmptySelection(Sci::Position currentPos_);
+	enum class AddNumber { one, each };
+	void MultipleSelectAdd(AddNumber addNumber);
+	bool RangeContainsProtected(Sci::Position start, Sci::Position end) const noexcept;
+	bool SelectionContainsProtected() const;
+	Sci::Position MovePositionOutsideChar(Sci::Position pos, Sci::Position moveDir, bool checkLineEnd=true) const;
+	SelectionPosition MovePositionOutsideChar(SelectionPosition pos, Sci::Position moveDir, bool checkLineEnd=true) const;
+	void MovedCaret(SelectionPosition newPos, SelectionPosition previousPos,
+		bool ensureVisible, CaretPolicies policies);
+	void MovePositionTo(SelectionPosition newPos, Selection::selTypes selt=Selection::noSel, bool ensureVisible=true);
+	void MovePositionTo(Sci::Position newPos, Selection::selTypes selt=Selection::noSel, bool ensureVisible=true);
+	SelectionPosition MovePositionSoVisible(SelectionPosition pos, int moveDir);
+	SelectionPosition MovePositionSoVisible(Sci::Position pos, int moveDir);
+	Point PointMainCaret();
 	void SetLastXChosen();
 
-	void ScrollTo(int line, bool moveThumb=true);
-	virtual void ScrollText(int linesToMove);
+	void ScrollTo(Sci::Line line, bool moveThumb=true);
+	virtual void ScrollText(Sci::Line linesToMove);
 	void HorizontalScrollTo(int xPos);
+	void VerticalCentreCaret();
+	void MoveSelectedLines(int lineDelta);
+	void MoveSelectedLinesUp();
+	void MoveSelectedLinesDown();
 	void MoveCaretInsideView(bool ensureVisible=true);
-	int DisplayFromPosition(int pos);
+	Sci::Line DisplayFromPosition(Sci::Position pos);
+
+	struct XYScrollPosition {
+		int xOffset;
+		Sci::Line topLine;
+		XYScrollPosition(int xOffset_, Sci::Line topLine_) noexcept : xOffset(xOffset_), topLine(topLine_) {}
+		bool operator==(const XYScrollPosition &other) const noexcept {
+			return (xOffset == other.xOffset) && (topLine == other.topLine);
+		}
+	};
+	enum XYScrollOptions {
+		xysUseMargin=0x1,
+		xysVertical=0x2,
+		xysHorizontal=0x4,
+		xysDefault=xysUseMargin|xysVertical|xysHorizontal};
+	XYScrollPosition XYScrollToMakeVisible(const SelectionRange &range,
+		const XYScrollOptions options, CaretPolicies policies);
+	void SetXYScroll(XYScrollPosition newXY);
 	void EnsureCaretVisible(bool useMargin=true, bool vert=true, bool horiz=true);
+	void ScrollRange(SelectionRange range);
 	void ShowCaretAtCurrentPosition();
 	void DropCaret();
+	void CaretSetPeriod(int period);
 	void InvalidateCaret();
+	virtual void NotifyCaretMove();
 	virtual void UpdateSystemCaret();
 
-	void NeedWrapping(int docLineStart = 0, int docLineEnd = wrapLineLarge);
-	bool WrapOneLine(Surface *surface, int lineToWrap);
-	bool WrapLines(bool fullWrap, int priorityWrapLineStart);
+	bool Wrapping() const noexcept;
+	void NeedWrapping(Sci::Line docLineStart=0, Sci::Line docLineEnd=WrapPending::lineLarge);
+	bool WrapOneLine(Surface *surface, Sci::Line lineToWrap);
+	enum class WrapScope {wsAll, wsVisible, wsIdle};
+	bool WrapLines(WrapScope ws);
 	void LinesJoin();
 	void LinesSplit(int pixelWidth);
 
-	int SubstituteMarkerIfEmpty(int markerCheck, int markerDefault);
-	void PaintSelMargin(Surface *surface, PRectangle &rc);
-	LineLayout *RetrieveLineLayout(int lineNumber);
-	void LayoutLine(int line, Surface *surface, ViewStyle &vstyle, LineLayout *ll,
-		int width=LineLayout::wrapWidthInfinite);
-	ColourAllocated SelectionBackground(ViewStyle &vsDraw);
-	ColourAllocated TextBackground(ViewStyle &vsDraw, bool overrideBackground, ColourAllocated background, bool inSelection, bool inHotspot, int styleMain, int i, LineLayout *ll);
-	void DrawIndentGuide(Surface *surface, int lineVisible, int lineHeight, int start, PRectangle rcSegment, bool highlight);
-	void DrawWrapMarker(Surface *surface, PRectangle rcPlace, bool isEndMarker, ColourAllocated wrapColour);
-	void DrawEOL(Surface *surface, ViewStyle &vsDraw, PRectangle rcLine, LineLayout *ll,
-		int line, int lineEnd, int xStart, int subLine, int subLineStart,
-		bool overrideBackground, ColourAllocated background,
-		bool drawWrapMark, ColourAllocated wrapColour);
-	void DrawIndicators(Surface *surface, ViewStyle &vsDraw, int line, int xStart,
-		PRectangle rcLine, LineLayout *ll, int subLine, int lineEnd, bool under);
-	void DrawLine(Surface *surface, ViewStyle &vsDraw, int line, int lineVisible, int xStart,
-		PRectangle rcLine, LineLayout *ll, int subLine=0);
-	void DrawBlockCaret(Surface *surface, ViewStyle &vsDraw, LineLayout *ll, int subLine, int xStart, int offset, int posCaret, PRectangle rcCaret);
+	void PaintSelMargin(Surface *surfaceWindow, const PRectangle &rc);
 	void RefreshPixMaps(Surface *surfaceWindow);
 	void Paint(Surface *surfaceWindow, PRectangle rcArea);
-	long FormatRange(bool draw, RangeToFormat *pfr);
-	int TextWidth(int style, const char *text);
+	Sci::Position FormatRange(bool draw, const Sci_RangeToFormat *pfr);
+	long TextWidth(uptr_t style, const char *text);
 
 	virtual void SetVerticalScrollPos() = 0;
 	virtual void SetHorizontalScrollPos() = 0;
-	virtual bool ModifyScrollBars(int nMax, int nPage) = 0;
+	virtual bool ModifyScrollBars(Sci::Line nMax, Sci::Line nPage) = 0;
 	virtual void ReconfigureScrollBars();
 	void SetScrollBars();
 	void ChangeSize();
 
+	void FilterSelections();
+	Sci::Position RealizeVirtualSpace(Sci::Position position, Sci::Position virtualSpace);
+	SelectionPosition RealizeVirtualSpace(const SelectionPosition &position);
 	void AddChar(char ch);
-	virtual void AddCharUTF(char *s, unsigned int len, bool treatAsDBCS=false);
-	void ClearSelection();
+	virtual void InsertCharacter(std::string_view sv, CharacterSource charSource);
+	void ClearBeforeTentativeStart();
+	void InsertPaste(const char *text, Sci::Position len);
+	enum PasteShape { pasteStream=0, pasteRectangular = 1, pasteLine = 2 };
+	void InsertPasteShape(const char *text, Sci::Position len, PasteShape shape);
+	void ClearSelection(bool retainMultipleSelections = false);
 	void ClearAll();
 	void ClearDocumentStyle();
-	void Cut();
-	void PasteRectangular(int pos, const char *ptr, int len);
+	virtual void Cut();
+	void PasteRectangular(SelectionPosition pos, const char *ptr, Sci::Position len);
 	virtual void Copy() = 0;
-	virtual void CopyAllowLine();
+	void CopyAllowLine();
 	virtual bool CanPaste();
 	virtual void Paste() = 0;
 	void Clear();
-	void SelectAll();
-	void Undo();
-	void Redo();
-	void DelChar();
+	virtual void SelectAll();
+	virtual void Undo();
+	virtual void Redo();
 	void DelCharBack(bool allowLineStartDeletion);
 	virtual void ClaimSelection() = 0;
 
+	static int ModifierFlags(bool shift, bool ctrl, bool alt, bool meta=false, bool super=false) noexcept;
 	virtual void NotifyChange() = 0;
 	virtual void NotifyFocus(bool focus);
+	virtual void SetCtrlID(int identifier);
 	virtual int GetCtrlID() { return ctrlID; }
 	virtual void NotifyParent(SCNotification scn) = 0;
-	virtual void NotifyStyleToNeeded(int endStyleNeeded);
-	void NotifyChar(int ch);
-	void NotifyMove(int position);
+	virtual void NotifyStyleToNeeded(Sci::Position endStyleNeeded);
+	void NotifyChar(int ch, CharacterSource charSource);
 	void NotifySavePoint(bool isSavePoint);
 	void NotifyModifyAttempt();
-	virtual void NotifyDoubleClick(Point pt, bool shift, bool ctrl, bool alt);
-	void NotifyHotSpotClicked(int position, bool shift, bool ctrl, bool alt);
-	void NotifyHotSpotDoubleClicked(int position, bool shift, bool ctrl, bool alt);
-	void NotifyUpdateUI();
+	virtual void NotifyDoubleClick(Point pt, int modifiers);
+	void NotifyHotSpotClicked(Sci::Position position, int modifiers);
+	void NotifyHotSpotDoubleClicked(Sci::Position position, int modifiers);
+	void NotifyHotSpotReleaseClick(Sci::Position position, int modifiers);
+	bool NotifyUpdateUI();
 	void NotifyPainted();
-	void NotifyIndicatorClick(bool click, int position, bool shift, bool ctrl, bool alt);
-	bool NotifyMarginClick(Point pt, bool shift, bool ctrl, bool alt);
-	void NotifyNeedShown(int pos, int len);
+	void NotifyIndicatorClick(bool click, Sci::Position position, int modifiers);
+	bool NotifyMarginClick(Point pt, int modifiers);
+	bool NotifyMarginRightClick(Point pt, int modifiers);
+	void NotifyNeedShown(Sci::Position pos, Sci::Position len);
 	void NotifyDwelling(Point pt, bool state);
 	void NotifyZoom();
 
-	void NotifyModifyAttempt(Document *document, void *userData);
-	void NotifySavePoint(Document *document, void *userData, bool atSavePoint);
+	void NotifyModifyAttempt(Document *document, void *userData) override;
+	void NotifySavePoint(Document *document, void *userData, bool atSavePoint) override;
 	void CheckModificationForWrap(DocModification mh);
-	void NotifyModified(Document *document, DocModification mh, void *userData);
-	void NotifyDeleted(Document *document, void *userData);
-	void NotifyStyleNeeded(Document *doc, void *userData, int endPos);
+	void NotifyModified(Document *document, DocModification mh, void *userData) override;
+	void NotifyDeleted(Document *document, void *userData) noexcept override;
+	void NotifyStyleNeeded(Document *doc, void *userData, Sci::Position endStyleNeeded) override;
+	void NotifyLexerChanged(Document *doc, void *userData) override;
+	void NotifyErrorOccurred(Document *doc, void *userData, int status) override;
 	void NotifyMacroRecord(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
 
-	void PageMove(int direction, selTypes sel=noSel, bool stuttered = false);
-	void ChangeCaseOfSelection(bool makeUpperCase);
+	void ContainerNeedsUpdate(int flags) noexcept;
+	void PageMove(int direction, Selection::selTypes selt=Selection::noSel, bool stuttered = false);
+	enum { cmSame, cmUpper, cmLower };
+	virtual std::string CaseMapString(const std::string &s, int caseMapping);
+	void ChangeCaseOfSelection(int caseMapping);
 	void LineTranspose();
+	void LineReverse();
 	void Duplicate(bool forLine);
 	virtual void CancelModes();
 	void NewLine();
-	void CursorUpOrDown(int direction, selTypes sel=noSel);
-	void ParaUpOrDown(int direction, selTypes sel=noSel);
-	int StartEndDisplayLine(int pos, bool start);
+	SelectionPosition PositionUpOrDown(SelectionPosition spStart, int direction, int lastX);
+	void CursorUpOrDown(int direction, Selection::selTypes selt);
+	void ParaUpOrDown(int direction, Selection::selTypes selt);
+	Range RangeDisplayLine(Sci::Line lineVisible);
+	Sci::Position StartEndDisplayLine(Sci::Position pos, bool start);
+	Sci::Position VCHomeDisplayPosition(Sci::Position position);
+	Sci::Position VCHomeWrapPosition(Sci::Position position);
+	Sci::Position LineEndWrapPosition(Sci::Position position);
+	int HorizontalMove(unsigned int iMessage);
+	int DelWordOrLine(unsigned int iMessage);
 	virtual int KeyCommand(unsigned int iMessage);
 	virtual int KeyDefault(int /* key */, int /*modifiers*/);
-	int KeyDown(int key, bool shift, bool ctrl, bool alt, bool *consumed=0);
-
-	int GetWhitespaceVisible();
-	void SetWhitespaceVisible(int view);
+	int KeyDownWithModifiers(int key, int modifiers, bool *consumed);
 
 	void Indent(bool forwards);
 
-	long FindText(uptr_t wParam, sptr_t lParam);
+	virtual CaseFolder *CaseFolderForEncoding();
+	Sci::Position FindText(uptr_t wParam, sptr_t lParam);
 	void SearchAnchor();
-	long SearchText(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
-	long SearchInTarget(const char *text, int length);
-	void GoToLine(int lineNo);
+	Sci::Position SearchText(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+	Sci::Position SearchInTarget(const char *text, Sci::Position length);
+	void GoToLine(Sci::Line lineNo);
 
 	virtual void CopyToClipboard(const SelectionText &selectedText) = 0;
-	char *CopyRange(int start, int end);
-	void CopySelectionFromRange(SelectionText *ss, bool allowLineCopy, int start, int end);
+	std::string RangeText(Sci::Position start, Sci::Position end) const;
 	void CopySelectionRange(SelectionText *ss, bool allowLineCopy=false);
-	void CopyRangeToClipboard(int start, int end);
-	void CopyText(int length, const char *text);
-	void SetDragPosition(int newPos);
+	void CopyRangeToClipboard(Sci::Position start, Sci::Position end);
+	void CopyText(size_t length, const char *text);
+	void SetDragPosition(SelectionPosition newPos);
 	virtual void DisplayCursor(Window::Cursor c);
 	virtual bool DragThreshold(Point ptStart, Point ptNow);
 	virtual void StartDrag();
-	void DropAt(int position, const char *value, bool moving, bool rectangular);
-	/** PositionInSelection returns 0 if position in selection, -1 if position before selection, and 1 if after.
-	 * Before means either before any line of selection or before selection on its line, with a similar meaning to after. */
-	int PositionInSelection(int pos);
+	void DropAt(SelectionPosition position, const char *value, size_t lengthValue, bool moving, bool rectangular);
+	void DropAt(SelectionPosition position, const char *value, bool moving, bool rectangular);
+	/** PositionInSelection returns true if position in selection. */
+	bool PositionInSelection(Sci::Position pos);
 	bool PointInSelection(Point pt);
-	bool PointInSelMargin(Point pt);
-	void LineSelection(int lineCurrent_, int lineAnchor_);
+	bool PointInSelMargin(Point pt) const;
+	Window::Cursor GetMarginCursor(Point pt) const noexcept;
+	void TrimAndSetSelection(Sci::Position currentPos_, Sci::Position anchor_);
+	void LineSelection(Sci::Position lineCurrentPos_, Sci::Position lineAnchorPos_, bool wholeLine);
+	void WordSelection(Sci::Position pos);
 	void DwellEnd(bool mouseMoved);
-	virtual void ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt);
-	void ButtonMove(Point pt);
-	void ButtonUp(Point pt, unsigned int curTime, bool ctrl);
+	void MouseLeave();
+	virtual void ButtonDownWithModifiers(Point pt, unsigned int curTime, int modifiers);
+	virtual void RightButtonDownWithModifiers(Point pt, unsigned int curTime, int modifiers);
+	void ButtonMoveWithModifiers(Point pt, unsigned int curTime, int modifiers);
+	void ButtonUpWithModifiers(Point pt, unsigned int curTime, int modifiers);
 
-	void Tick();
 	bool Idle();
-	virtual void SetTicking(bool on) = 0;
+	enum TickReason { tickCaret, tickScroll, tickWiden, tickDwell, tickPlatform };
+	virtual void TickFor(TickReason reason);
+	virtual bool FineTickerRunning(TickReason reason);
+	virtual void FineTickerStart(TickReason reason, int millis, int tolerance);
+	virtual void FineTickerCancel(TickReason reason);
 	virtual bool SetIdle(bool) { return false; }
 	virtual void SetMouseCapture(bool on) = 0;
 	virtual bool HaveMouseCapture() = 0;
 	void SetFocusState(bool focusState);
 
+	Sci::Position PositionAfterArea(PRectangle rcArea) const;
+	void StyleToPositionInView(Sci::Position pos);
+	Sci::Position PositionAfterMaxStyling(Sci::Position posMax, bool scrolling) const;
+	void StartIdleStyling(bool truncatedLastStyling);
+	void StyleAreaBounded(PRectangle rcArea, bool scrolling);
+	constexpr bool SynchronousStylingToVisible() const noexcept {
+		return (idleStyling == SC_IDLESTYLING_NONE) || (idleStyling == SC_IDLESTYLING_AFTERVISIBLE);
+	}
+	void IdleStyling();
+	virtual void IdleWork();
+	virtual void QueueIdleWork(WorkNeeded::workItems items, Sci::Position upTo=0);
+
 	virtual bool PaintContains(PRectangle rc);
 	bool PaintContainsMargin();
 	void CheckForChangeOutsidePaint(Range r);
-	void SetBraceHighlight(Position pos0, Position pos1, int matchStyle);
+	void SetBraceHighlight(Sci::Position pos0, Sci::Position pos1, int matchStyle);
+
+	void SetAnnotationHeights(Sci::Line start, Sci::Line end);
+	virtual void SetDocPointer(Document *document);
+
+	void SetAnnotationVisible(int visible);
+	void SetEOLAnnotationVisible(int visible);
 
-	void SetDocPointer(Document *document);
+	Sci::Line ExpandLine(Sci::Line line);
+	void SetFoldExpanded(Sci::Line lineDoc, bool expanded);
+	void FoldLine(Sci::Line line, int action);
+	void FoldExpand(Sci::Line line, int action, int level);
+	Sci::Line ContractedFoldNext(Sci::Line lineStart) const;
+	void EnsureLineVisible(Sci::Line lineDoc, bool enforcePolicy);
+	void FoldChanged(Sci::Line line, int levelNow, int levelPrev);
+	void NeedShown(Sci::Position pos, Sci::Position len);
+	void FoldAll(int action);
 
-	void Expand(int &line, bool doExpand);
-	void ToggleContraction(int line);
-	void EnsureLineVisible(int lineDoc, bool enforcePolicy);
-	int ReplaceTarget(bool replacePatterns, const char *text, int length=-1);
+	Sci::Position GetTag(char *tagValue, int tagNumber);
+	Sci::Position ReplaceTarget(bool replacePatterns, const char *text, Sci::Position length=-1);
 
-	bool PositionIsHotspot(int position);
+	bool PositionIsHotspot(Sci::Position position) const;
 	bool PointIsHotspot(Point pt);
-	void SetHotSpotRange(Point *pt);
-	void GetHotSpotRange(int& hsStart, int& hsEnd);
+	void SetHotSpotRange(const Point *pt);
+	Range GetHotSpotRange() const noexcept override;
+	void SetHoverIndicatorPosition(Sci::Position position);
+	void SetHoverIndicatorPoint(Point pt);
 
-	int CodePage() const;
+	int CodePage() const noexcept;
 	virtual bool ValidCodePage(int /* codePage */) const { return true; }
-	int WrapCount(int line);
-	void AddStyledText(char *buffer, int appendLength);
+	Sci::Line WrapCount(Sci::Line line);
+	void AddStyledText(const char *buffer, Sci::Position appendLength);
 
 	virtual sptr_t DefWndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) = 0;
+	bool ValidMargin(uptr_t wParam) const noexcept;
 	void StyleSetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
 	sptr_t StyleGetMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+	void SetSelectionNMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
 
-	static const char *StringFromEOLMode(int eolMode);
+	static const char *StringFromEOLMode(int eolMode) noexcept;
+
+	// Coercion functions for transforming WndProc parameters into pointers
+	static void *PtrFromSPtr(sptr_t lParam) noexcept {
+		return reinterpret_cast<void *>(lParam);
+	}
+	static const char *ConstCharPtrFromSPtr(sptr_t lParam) noexcept {
+		return static_cast<const char *>(PtrFromSPtr(lParam));
+	}
+	static const unsigned char *ConstUCharPtrFromSPtr(sptr_t lParam) noexcept {
+		return static_cast<const unsigned char *>(PtrFromSPtr(lParam));
+	}
+	static char *CharPtrFromSPtr(sptr_t lParam) noexcept {
+		return static_cast<char *>(PtrFromSPtr(lParam));
+	}
+	static unsigned char *UCharPtrFromSPtr(sptr_t lParam) noexcept {
+		return static_cast<unsigned char *>(PtrFromSPtr(lParam));
+	}
+	static void *PtrFromUPtr(uptr_t wParam) noexcept {
+		return reinterpret_cast<void *>(wParam);
+	}
+	static const char *ConstCharPtrFromUPtr(uptr_t wParam) noexcept {
+		return static_cast<const char *>(PtrFromUPtr(wParam));
+	}
+
+	static sptr_t StringResult(sptr_t lParam, const char *val) noexcept;
+	static sptr_t BytesResult(sptr_t lParam, const unsigned char *val, size_t len) noexcept;
+
+	// Set a variable controlling appearance to a value and invalidates the display
+	// if a change was made. Avoids extra text and the possibility of mistyping.
+	template <typename T>
+	bool SetAppearance(T &variable, T value) {
+		// Using ! and == as more types have == defined than !=.
+		const bool changed = !(variable == value);
+		if (changed) {
+			variable = value;
+			InvalidateStyleRedraw();
+		}
+		return changed;
+	}
 
 public:
+	~Editor() override;
+
 	// Public so the COM thunks can access it.
-	bool IsUnicodeMode() const;
+	bool IsUnicodeMode() const noexcept;
 	// Public so scintilla_send_message can use it.
 	virtual sptr_t WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
 	// Public so scintilla_set_id can use it.
 	int ctrlID;
+	// Public so COM methods for drag and drop can set it.
+	int errorStatus;
 	friend class AutoSurface;
-	friend class SelectionLineIterator;
 };
 
 /**
@@ -482,41 +639,41 @@ class Editor : public DocWatcher {
  */
 class AutoSurface {
 private:
-	Surface *surf;
+	std::unique_ptr<Surface> surf;
 public:
-	AutoSurface(Editor *ed) : surf(0) {
+	AutoSurface(const Editor *ed, int technology = -1) {
 		if (ed->wMain.GetID()) {
-			surf = Surface::Allocate();
-			if (surf) {
-				surf->Init(ed->wMain.GetID());
-				surf->SetUnicodeMode(SC_CP_UTF8 == ed->CodePage());
-				surf->SetDBCSMode(ed->CodePage());
-			}
+			surf.reset(Surface::Allocate(technology != -1 ? technology : ed->technology));
+			surf->Init(ed->wMain.GetID());
+			surf->SetUnicodeMode(SC_CP_UTF8 == ed->CodePage());
+			surf->SetDBCSMode(ed->CodePage());
+			surf->SetBidiR2L(ed->BidirectionalR2L());
 		}
 	}
-	AutoSurface(SurfaceID sid, Editor *ed) : surf(0) {
+	AutoSurface(SurfaceID sid, Editor *ed, int technology = -1) {
 		if (ed->wMain.GetID()) {
-			surf = Surface::Allocate();
-			if (surf) {
-				surf->Init(sid, ed->wMain.GetID());
-				surf->SetUnicodeMode(SC_CP_UTF8 == ed->CodePage());
-				surf->SetDBCSMode(ed->CodePage());
-			}
+			surf.reset(Surface::Allocate(technology != -1 ? technology : ed->technology));
+			surf->Init(sid, ed->wMain.GetID());
+			surf->SetUnicodeMode(SC_CP_UTF8 == ed->CodePage());
+			surf->SetDBCSMode(ed->CodePage());
+			surf->SetBidiR2L(ed->BidirectionalR2L());
 		}
 	}
+	// Deleted so AutoSurface objects can not be copied.
+	AutoSurface(const AutoSurface &) = delete;
+	AutoSurface(AutoSurface &&) = delete;
+	void operator=(const AutoSurface &) = delete;
+	void operator=(AutoSurface &&) = delete;
 	~AutoSurface() {
-		delete surf;
 	}
-	Surface *operator->() const {
-		return surf;
+	Surface *operator->() const noexcept {
+		return surf.get();
 	}
-	operator Surface *() const {
-		return surf;
+	operator Surface *() const noexcept {
+		return surf.get();
 	}
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/ElapsedPeriod.h b/Pythonwin/Scintilla/src/ElapsedPeriod.h
new file mode 100644
index 000000000..e083c0dda
--- /dev/null
+++ b/Pythonwin/Scintilla/src/ElapsedPeriod.h
@@ -0,0 +1,35 @@
+// Scintilla source code edit control
+/** @file ElapsedPeriod.h
+ ** Encapsulate C++ <chrono> to simplify use.
+ **/
+// Copyright 2018 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef ELAPSEDPERIOD_H
+#define ELAPSEDPERIOD_H
+
+namespace Scintilla {
+
+// Simplified access to high precision timing.
+class ElapsedPeriod {
+	std::chrono::high_resolution_clock::time_point tp;
+public:
+	/// Capture the moment
+	ElapsedPeriod() noexcept : tp(std::chrono::high_resolution_clock::now()) {
+	}
+	/// Return duration as floating point seconds
+	double Duration(bool reset=false) noexcept {
+		const std::chrono::high_resolution_clock::time_point tpNow =
+			std::chrono::high_resolution_clock::now();
+		const std::chrono::duration<double> stylingDuration =
+			std::chrono::duration_cast<std::chrono::duration<double>>(tpNow - tp);
+		if (reset) {
+			tp = tpNow;
+		}
+		return stylingDuration.count();
+	}
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/ExternalLexer.cxx b/Pythonwin/Scintilla/src/ExternalLexer.cxx
index a4e29e314..1609b676e 100644
--- a/Pythonwin/Scintilla/src/ExternalLexer.cxx
+++ b/Pythonwin/Scintilla/src/ExternalLexer.cxx
@@ -1,109 +1,115 @@
 // Scintilla source code edit control
 /** @file ExternalLexer.cxx
- ** Support external lexers in DLLs.
+ ** Support external lexers in DLLs or shared libraries.
  **/
 // Copyright 2001 Simon Steele <ss@pnotepad.org>, portions copyright Neil Hodgson.
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <ctype.h>
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <memory>
 
 #include "Platform.h"
 
+#include "ILexer.h"
 #include "Scintilla.h"
-
 #include "SciLexer.h"
-#include "PropSet.h"
-#include "Accessor.h"
-#include "DocumentAccessor.h"
-#include "KeyWords.h"
+
+#include "LexerModule.h"
+#include "Catalogue.h"
 #include "ExternalLexer.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
-
-LexerManager *LexerManager::theInstance = NULL;
-
-//------------------------------------------
-//
-// ExternalLexerModule
-//
-//------------------------------------------
 
-char **WordListsToStrings(WordList *val[]) {
-	int dim = 0;
-	while (val[dim])
-		dim++;
-	char **wls = new char * [dim + 1];
-	for (int i = 0;i < dim;i++) {
-		SString words;
-		words = "";
-		for (int n = 0; n < val[i]->len; n++) {
-			words += val[i]->words[n];
-			if (n != val[i]->len - 1)
-				words += " ";
-		}
-		wls[i] = new char[words.length() + 1];
-		strcpy(wls[i], words.c_str());
-	}
-	wls[dim] = 0;
-	return wls;
-}
+#if PLAT_WIN
+#define EXT_LEXER_DECL __stdcall
+#else
+#define EXT_LEXER_DECL
+#endif
 
-void DeleteWLStrings(char *strs[]) {
-	int dim = 0;
-	while (strs[dim]) {
-		delete strs[dim];
-		dim++;
+namespace {
+
+int nextLanguage = SCLEX_AUTOMATIC + 1;
+
+typedef int (EXT_LEXER_DECL *GetLexerCountFn)();
+typedef void (EXT_LEXER_DECL *GetLexerNameFn)(unsigned int Index, char *name, int buflength);
+typedef LexerFactoryFunction(EXT_LEXER_DECL *GetLexerFactoryFunction)(unsigned int Index);
+
+/// Generic function to convert from a void* to a function pointer.
+/// This avoids undefined and conditionally defined behaviour.
+template<typename T>
+T FunctionPointer(void *function) noexcept {
+	static_assert(sizeof(T) == sizeof(function));
+	T fp;
+	memcpy(&fp, &function, sizeof(T));
+	return fp;
+}
+
+/// Sub-class of LexerModule to use an external lexer.
+class ExternalLexerModule : public LexerModule {
+protected:
+	GetLexerFactoryFunction fneFactory;
+	std::string name;
+public:
+	ExternalLexerModule(int language_, LexerFunction fnLexer_,
+		const char *languageName_=nullptr, LexerFunction fnFolder_=nullptr) :
+		LexerModule(language_, fnLexer_, nullptr, fnFolder_),
+		fneFactory(nullptr), name(languageName_){
+		languageName = name.c_str();
 	}
-	delete [] strs;
-}
-
-void ExternalLexerModule::Lex(unsigned int startPos, int lengthDoc, int initStyle,
-                              WordList *keywordlists[], Accessor &styler) const {
-	if (!fneLexer)
-		return ;
+	void SetExternal(GetLexerFactoryFunction fFactory, int index) noexcept;
+};
 
-	char **kwds = WordListsToStrings(keywordlists);
-	char *ps = styler.GetProperties();
+/// LexerLibrary exists for every External Lexer DLL, contains ExternalLexerModules.
+class LexerLibrary {
+	std::unique_ptr<DynamicLibrary> lib;
+	std::vector<std::unique_ptr<ExternalLexerModule>> modules;
+public:
+	explicit LexerLibrary(const char *moduleName_);
+	~LexerLibrary();
 
-	// The accessor passed in is always a DocumentAccessor so this cast and the subsequent
-	// access will work. Can not use the stricter dynamic_cast as that requires RTTI.
-	DocumentAccessor &da = static_cast<DocumentAccessor &>(styler);
-	WindowID wID = da.GetWindow();
+	std::string moduleName;
+};
 
-	fneLexer(externalLanguage, startPos, lengthDoc, initStyle, kwds, wID, ps);
+/// LexerManager manages external lexers, contains LexerLibrarys.
+class LexerManager {
+public:
+	~LexerManager();
 
-	delete ps;
-	DeleteWLStrings(kwds);
-}
+	static LexerManager *GetInstance();
+	static void DeleteInstance() noexcept;
 
-void ExternalLexerModule::Fold(unsigned int startPos, int lengthDoc, int initStyle,
-                               WordList *keywordlists[], Accessor &styler) const {
-	if (!fneFolder)
-		return ;
+	void Load(const char *path);
+	void Clear() noexcept;
 
-	char **kwds = WordListsToStrings(keywordlists);
-	char *ps = styler.GetProperties();
+private:
+	LexerManager();
+	static std::unique_ptr<LexerManager> theInstance;
+	std::vector<std::unique_ptr<LexerLibrary>> libraries;
+};
 
-	// The accessor passed in is always a DocumentAccessor so this cast and the subsequent
-	// access will work. Can not use the stricter dynamic_cast as that requires RTTI.
-	DocumentAccessor &da = static_cast<DocumentAccessor &>(styler);
-	WindowID wID = da.GetWindow();
+class LMMinder {
+public:
+	~LMMinder();
+};
 
-	fneFolder(externalLanguage, startPos, lengthDoc, initStyle, kwds, wID, ps);
+std::unique_ptr<LexerManager> LexerManager::theInstance;
 
-	delete ps;
-	DeleteWLStrings(kwds);
-}
+//------------------------------------------
+//
+// ExternalLexerModule
+//
+//------------------------------------------
 
-void ExternalLexerModule::SetExternal(ExtLexerFunction fLexer, ExtFoldFunction fFolder, int index) {
-	fneLexer = fLexer;
-	fneFolder = fFolder;
-	externalLanguage = index;
+void ExternalLexerModule::SetExternal(GetLexerFactoryFunction fFactory, int index) noexcept {
+	fneFactory = fFactory;
+	fnFactory = fFactory(index);
 }
 
 //------------------------------------------
@@ -112,77 +118,47 @@ void ExternalLexerModule::SetExternal(ExtLexerFunction fLexer, ExtFoldFunction f
 //
 //------------------------------------------
 
-LexerLibrary::LexerLibrary(const char* ModuleName) {
-	// Initialise some members...
-	first = NULL;
-	last = NULL;
-
+LexerLibrary::LexerLibrary(const char *moduleName_) {
 	// Load the DLL
-	lib = DynamicLibrary::Load(ModuleName);
+	lib.reset(DynamicLibrary::Load(moduleName_));
 	if (lib->IsValid()) {
-		m_sModuleName = ModuleName;
-		//Cannot use reinterpret_cast because: ANSI C++ forbids casting between pointers to functions and objects
-		GetLexerCountFn GetLexerCount = (GetLexerCountFn)(sptr_t)lib->FindFunction("GetLexerCount");
+		moduleName = moduleName_;
+		GetLexerCountFn GetLexerCount = FunctionPointer<GetLexerCountFn>(lib->FindFunction("GetLexerCount"));
 
 		if (GetLexerCount) {
-			ExternalLexerModule *lex;
-			LexerMinder *lm;
-
 			// Find functions in the DLL
-			GetLexerNameFn GetLexerName = (GetLexerNameFn)(sptr_t)lib->FindFunction("GetLexerName");
-			ExtLexerFunction Lexer = (ExtLexerFunction)(sptr_t)lib->FindFunction("Lex");
-			ExtFoldFunction Folder = (ExtFoldFunction)(sptr_t)lib->FindFunction("Fold");
+			GetLexerNameFn GetLexerName = FunctionPointer<GetLexerNameFn>(lib->FindFunction("GetLexerName"));
+			GetLexerFactoryFunction fnFactory = FunctionPointer<GetLexerFactoryFunction>(lib->FindFunction("GetLexerFactory"));
 
-			// Assign a buffer for the lexer name.
-			char lexname[100];
-			strcpy(lexname, "");
+			if (!GetLexerName || !fnFactory) {
+				return;
+			}
 
-			int nl = GetLexerCount();
+			const int nl = GetLexerCount();
 
 			for (int i = 0; i < nl; i++) {
-				GetLexerName(i, lexname, 100);
-				lex = new ExternalLexerModule(SCLEX_AUTOMATIC, NULL, lexname, NULL);
-
-				// Create a LexerMinder so we don't leak the ExternalLexerModule...
-				lm = new LexerMinder;
-				lm->self = lex;
-				lm->next = NULL;
-				if (first != NULL) {
-					last->next = lm;
-					last = lm;
-				} else {
-					first = lm;
-					last = lm;
-				}
+				// Assign a buffer for the lexer name.
+				char lexname[100] = "";
+				GetLexerName(i, lexname, sizeof(lexname));
+				ExternalLexerModule *lex = new ExternalLexerModule(nextLanguage, nullptr, lexname, nullptr);
+				nextLanguage++;
+
+				// This is storing a second reference to lex in the Catalogue as well as in modules.
+				// TODO: Should use std::shared_ptr or similar to ensure allocation safety.
+				Catalogue::AddLexerModule(lex);
+
+				// Remember ExternalLexerModule so we don't leak it
+				modules.push_back(std::unique_ptr<ExternalLexerModule>(lex));
 
 				// The external lexer needs to know how to call into its DLL to
-				// do its lexing and folding, we tell it here. Folder may be null.
-				lex->SetExternal(Lexer, Folder, i);
+				// do its lexing and folding, we tell it here.
+				lex->SetExternal(fnFactory, i);
 			}
 		}
 	}
-	next = NULL;
 }
 
 LexerLibrary::~LexerLibrary() {
-	Release();
-	delete lib;
-}
-
-void LexerLibrary::Release() {
-	//TODO maintain a list of lexers created, and delete them!
-	LexerMinder *lm;
-	LexerMinder *lmNext;
-	lm = first;
-	while (NULL != lm) {
-		lmNext = lm->next;
-		delete lm->self;
-		delete lm;
-		lm = lmNext;
-	}
-
-	first = NULL;
-	last = NULL;
 }
 
 //------------------------------------------
@@ -193,71 +169,54 @@ void LexerLibrary::Release() {
 
 /// Return the single LexerManager instance...
 LexerManager *LexerManager::GetInstance() {
-	if(!theInstance)
-		theInstance = new LexerManager;
-	return theInstance;
+	if (!theInstance)
+		theInstance.reset(new LexerManager);
+	return theInstance.get();
 }
 
 /// Delete any LexerManager instance...
-void LexerManager::DeleteInstance()
-{
-	if(theInstance) {
-		delete theInstance;
-		theInstance = NULL;
-	}
+void LexerManager::DeleteInstance() noexcept {
+	theInstance.reset();
 }
 
 /// protected constructor - this is a singleton...
 LexerManager::LexerManager() {
-	first = NULL;
-	last = NULL;
 }
 
 LexerManager::~LexerManager() {
 	Clear();
 }
 
-void LexerManager::Load(const char* path)
-{
-	LoadLexerLibrary(path);
-}
-
-void LexerManager::LoadLexerLibrary(const char* module)
-{
-	LexerLibrary *lib = new LexerLibrary(module);
-	if (NULL != first) {
-		last->next = lib;
-		last = lib;
-	} else {
-		first = lib;
-		last = lib;
+void LexerManager::Load(const char *path) {
+	for (const std::unique_ptr<LexerLibrary> &ll : libraries) {
+		if (ll->moduleName == path)
+			return;
 	}
+	libraries.push_back(std::make_unique<LexerLibrary>(path));
 }
 
-void LexerManager::Clear()
-{
-	if (NULL != first) {
-		LexerLibrary *cur = first;
-		LexerLibrary *next;
-		while (cur) {
-			next = cur->next;
-			delete cur;
-			cur = next;
-		}
-		first = NULL;
-		last = NULL;
-	}
+void LexerManager::Clear() noexcept {
+	libraries.clear();
 }
 
 //------------------------------------------
 //
-// LexerManager
+// LMMinder	-- trigger to clean up at exit.
 //
 //------------------------------------------
 
-LMMinder::~LMMinder()
-{
+LMMinder::~LMMinder() {
 	LexerManager::DeleteInstance();
 }
 
 LMMinder minder;
+
+}
+
+namespace Scintilla {
+
+void ExternalLexerLoad(const char *path) {
+	LexerManager::GetInstance()->Load(path);
+}
+
+}
diff --git a/Pythonwin/Scintilla/src/ExternalLexer.h b/Pythonwin/Scintilla/src/ExternalLexer.h
index 55e127b40..d0a615e31 100644
--- a/Pythonwin/Scintilla/src/ExternalLexer.h
+++ b/Pythonwin/Scintilla/src/ExternalLexer.h
@@ -1,6 +1,6 @@
 // Scintilla source code edit control
 /** @file ExternalLexer.h
- ** Support external lexers in DLLs.
+ ** Support external lexers in DLLs or shared libraries.
  **/
 // Copyright 2001 Simon Steele <ss@pnotepad.org>, portions copyright Neil Hodgson.
 // The License.txt file describes the conditions under which this software may be distributed.
@@ -8,96 +8,10 @@
 #ifndef EXTERNALLEXER_H
 #define EXTERNALLEXER_H
 
-#if PLAT_WIN
-#define EXT_LEXER_DECL __stdcall
-#else
-#define EXT_LEXER_DECL
-#endif
-
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
-
-// External Lexer function definitions...
-typedef void (EXT_LEXER_DECL *ExtLexerFunction)(unsigned int lexer, unsigned int startPos, int length, int initStyle,
-                  char *words[], WindowID window, char *props);
-typedef void (EXT_LEXER_DECL *ExtFoldFunction)(unsigned int lexer, unsigned int startPos, int length, int initStyle,
-                  char *words[], WindowID window, char *props);
-typedef void* (EXT_LEXER_DECL *GetLexerFunction)(unsigned int Index);
-typedef int (EXT_LEXER_DECL *GetLexerCountFn)();
-typedef void (EXT_LEXER_DECL *GetLexerNameFn)(unsigned int Index, char *name, int buflength);
-
-//class DynamicLibrary;
-
-/// Sub-class of LexerModule to use an external lexer.
-class ExternalLexerModule : protected LexerModule {
-protected:
-	ExtLexerFunction fneLexer;
-	ExtFoldFunction fneFolder;
-	int externalLanguage;
-	char name[100];
-public:
-	ExternalLexerModule(int language_, LexerFunction fnLexer_, 
-		const char *languageName_=0, LexerFunction fnFolder_=0) : LexerModule(language_, fnLexer_, 0, fnFolder_){
-		strncpy(name, languageName_, sizeof(name));
-		languageName = name;
-	};
-	virtual void Lex(unsigned int startPos, int lengthDoc, int initStyle,
-					WordList *keywordlists[], Accessor &styler) const;
-	virtual void Fold(unsigned int startPos, int lengthDoc, int initStyle,
-					WordList *keywordlists[], Accessor &styler) const;
-	virtual void SetExternal(ExtLexerFunction fLexer, ExtFoldFunction fFolder, int index);
-};
-
-/// LexerMinder points to an ExternalLexerModule - so we don't leak them.
-class LexerMinder {
-public:
-	ExternalLexerModule *self;
-	LexerMinder *next;
-};
 
-/// LexerLibrary exists for every External Lexer DLL, contains LexerMinders.
-class LexerLibrary {
-	DynamicLibrary	*lib;
-	LexerMinder		*first;
-	LexerMinder		*last;
+void ExternalLexerLoad(const char *path);
 
-public:
-	LexerLibrary(const char* ModuleName);
-	~LexerLibrary();
-	void Release();
-	
-	LexerLibrary	*next;
-	SString			m_sModuleName;
-};
-
-/// LexerManager manages external lexers, contains LexerLibrarys.
-class LexerManager {
-public:
-	~LexerManager();
-	
-	static LexerManager *GetInstance();
-	static void DeleteInstance();
-	
-	void Load(const char* path);
-	void Clear();
-
-private:
-	LexerManager();
-	static LexerManager *theInstance;
-
-	void LoadLexerLibrary(const char* module);
-	LexerLibrary *first;
-	LexerLibrary *last;
-};
-
-class LMMinder {
-public:
-	~LMMinder();
-};
-
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/FontQuality.h b/Pythonwin/Scintilla/src/FontQuality.h
new file mode 100644
index 000000000..85dca1e16
--- /dev/null
+++ b/Pythonwin/Scintilla/src/FontQuality.h
@@ -0,0 +1,27 @@
+// Scintilla source code edit control
+/** @file FontQuality.h
+ ** Definitions to control font anti-aliasing.
+ ** Redefine constants from Scintilla.h to avoid including Scintilla.h in PlatWin.cxx.
+ **/
+// Copyright 1998-2009 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef FONTQUALITY_H
+#define FONTQUALITY_H
+
+namespace Scintilla {
+
+// These definitions match Scintilla.h
+#define SC_EFF_QUALITY_MASK            0xF
+#define SC_EFF_QUALITY_DEFAULT           0
+#define SC_EFF_QUALITY_NON_ANTIALIASED   1
+#define SC_EFF_QUALITY_ANTIALIASED       2
+#define SC_EFF_QUALITY_LCD_OPTIMIZED     3
+
+// These definitions must match SC_TECHNOLOGY_* in Scintilla.h
+#define SCWIN_TECH_GDI 0
+#define SCWIN_TECH_DIRECTWRITE 1
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/Indicator.cxx b/Pythonwin/Scintilla/src/Indicator.cxx
index 139e2b0ea..fda979242 100644
--- a/Pythonwin/Scintilla/src/Indicator.cxx
+++ b/Pythonwin/Scintilla/src/Indicator.cxx
@@ -5,77 +5,270 @@
 // Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
+#include <cmath>
+
+#include <stdexcept>
+#include <string_view>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <memory>
+
 #include "Platform.h"
 
 #include "Scintilla.h"
+#include "IntegerRectangle.h"
 #include "Indicator.h"
+#include "XPM.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
-
-void Indicator::Draw(Surface *surface, const PRectangle &rc, const PRectangle &rcLine) {
-	surface->PenColour(fore.allocated);
-	int ymid = (rc.bottom + rc.top) / 2;
-	if (style == INDIC_SQUIGGLE) {
-		surface->MoveTo(rc.left, rc.top);
-		int x = rc.left + 2;
-		int y = 2;
-		while (x < rc.right) {
-			surface->LineTo(x, rc.top + y);
-			x += 2;
-			y = 2 - y;
+
+static PRectangle PixelGridAlign(const PRectangle &rc) noexcept {
+	// Move left and right side to nearest pixel to avoid blurry visuals
+	return PRectangle(std::round(rc.left), std::floor(rc.top),
+		std::round(rc.right), std::floor(rc.bottom));
+}
+
+void Indicator::Draw(Surface *surface, const PRectangle &rc, const PRectangle &rcLine, const PRectangle &rcCharacter, State state, int value) const {
+	StyleAndColour sacDraw = sacNormal;
+	if (Flags() & SC_INDICFLAG_VALUEFORE) {
+		sacDraw.fore = ColourDesired(value & SC_INDICVALUEMASK);
+	}
+	if (state == State::hover) {
+		sacDraw = sacHover;
+	}
+	const IntegerRectangle irc(rc);
+	surface->PenColour(sacDraw.fore);
+	const int ymid = (irc.bottom + irc.top) / 2;
+
+	switch (sacDraw.style) {
+	case INDIC_SQUIGGLE: {
+			const IntegerRectangle ircSquiggle(PixelGridAlign(rc));
+			int x = ircSquiggle.left;
+			const int xLast = ircSquiggle.right;
+			int y = 0;
+			surface->MoveTo(x, irc.top + y);
+			while (x < xLast) {
+				if ((x + 2) > xLast) {
+					y = 1;
+					x = xLast;
+				} else {
+					x += 2;
+					y = 2 - y;
+				}
+				surface->LineTo(x, irc.top + y);
+			}
+		}
+		break;
+
+	case INDIC_SQUIGGLEPIXMAP: {
+			const PRectangle rcSquiggle = PixelGridAlign(rc);
+
+			const int width = std::min(4000, static_cast<int>(rcSquiggle.Width()));
+			RGBAImage image(width, 3, 1.0, nullptr);
+			enum { alphaFull = 0xff, alphaSide = 0x2f, alphaSide2=0x5f };
+			for (int x = 0; x < width; x++) {
+				if (x%2) {
+					// Two halfway columns have a full pixel in middle flanked by light pixels
+					image.SetPixel(x, 0, sacDraw.fore, alphaSide);
+					image.SetPixel(x, 1, sacDraw.fore, alphaFull);
+					image.SetPixel(x, 2, sacDraw.fore, alphaSide);
+				} else {
+					// Extreme columns have a full pixel at bottom or top and a mid-tone pixel in centre
+					image.SetPixel(x, (x % 4) ? 0 : 2, sacDraw.fore, alphaFull);
+					image.SetPixel(x, 1, sacDraw.fore, alphaSide2);
+				}
+			}
+			surface->DrawRGBAImage(rcSquiggle, image.GetWidth(), image.GetHeight(), image.Pixels());
 		}
-		surface->LineTo(rc.right, rc.top + y);	// Finish the line
-	} else if (style == INDIC_TT) {
-		surface->MoveTo(rc.left, ymid);
-		int x = rc.left + 5;
-		while (x < rc.right) {
-			surface->LineTo(x, ymid);
-			surface->MoveTo(x-3, ymid);
-			surface->LineTo(x-3, ymid+2);
-			x++;
-			surface->MoveTo(x, ymid);
-			x += 5;
+		break;
+
+	case INDIC_SQUIGGLELOW: {
+			surface->MoveTo(irc.left, irc.top);
+			int x = irc.left + 3;
+			int y = 0;
+			while (x < rc.right) {
+				surface->LineTo(x - 1, irc.top + y);
+				y = 1 - y;
+				surface->LineTo(x, irc.top + y);
+				x += 3;
+			}
+			surface->LineTo(irc.right, irc.top + y);	// Finish the line
 		}
-		surface->LineTo(rc.right, ymid);	// Finish the line
-		if (x - 3 <= rc.right) {
-			surface->MoveTo(x-3, ymid);
-			surface->LineTo(x-3, ymid+2);
+		break;
+
+	case INDIC_TT: {
+			surface->MoveTo(irc.left, ymid);
+			int x = irc.left + 5;
+			while (x < rc.right) {
+				surface->LineTo(x, ymid);
+				surface->MoveTo(x-3, ymid);
+				surface->LineTo(x-3, ymid+2);
+				x++;
+				surface->MoveTo(x, ymid);
+				x += 5;
+			}
+			surface->LineTo(irc.right, ymid);	// Finish the line
+			if (x - 3 <= rc.right) {
+				surface->MoveTo(x-3, ymid);
+				surface->LineTo(x-3, ymid+2);
+			}
 		}
-	} else if (style == INDIC_DIAGONAL) {
-		int x = rc.left;
-		while (x < rc.right) {
-			surface->MoveTo(x, rc.top+2);
-			int endX = x+3;
-			int endY = rc.top - 1;
-			if (endX > rc.right) {
-				endY += endX - rc.right;
-				endX = rc.right;
+		break;
+
+	case INDIC_DIAGONAL: {
+			int x = irc.left;
+			while (x < rc.right) {
+				surface->MoveTo(x, irc.top + 2);
+				int endX = x+3;
+				int endY = irc.top - 1;
+				if (endX > rc.right) {
+					endY += endX - irc.right;
+					endX = irc.right;
+				}
+				surface->LineTo(endX, endY);
+				x += 4;
 			}
-			surface->LineTo(endX, endY);
-			x += 4;
 		}
-	} else if (style == INDIC_STRIKE) {
-		surface->MoveTo(rc.left, rc.top - 4);
-		surface->LineTo(rc.right, rc.top - 4);
-	} else if (style == INDIC_HIDDEN) {
+		break;
+
+	case INDIC_STRIKE: {
+			surface->MoveTo(irc.left, irc.top - 4);
+			surface->LineTo(irc.right, irc.top - 4);
+		}
+		break;
+
+	case INDIC_HIDDEN:
+	case INDIC_TEXTFORE:
 		// Draw nothing
-	} else if (style == INDIC_BOX) {
-		surface->MoveTo(rc.left, ymid+1);
-		surface->LineTo(rc.right, ymid+1);
-		surface->LineTo(rc.right, rcLine.top+1);
-		surface->LineTo(rc.left, rcLine.top+1);
-		surface->LineTo(rc.left, ymid+1);
-	} else if (style == INDIC_ROUNDBOX) {
-		PRectangle rcBox = rcLine;
-		rcBox.top = rcLine.top + 1;
-		rcBox.left = rc.left;
-		rcBox.right = rc.right;
-		surface->AlphaRectangle(rcBox, 1, fore.allocated, 30, fore.allocated, 50, 0);
-	} else {	// Either INDIC_PLAIN or unknown
-		surface->MoveTo(rc.left, ymid);
-		surface->LineTo(rc.right, ymid);
+		break;
+
+	case INDIC_BOX: {
+			surface->MoveTo(irc.left, ymid + 1);
+			surface->LineTo(irc.right, ymid + 1);
+			const int lineTop = static_cast<int>(rcLine.top) + 1;
+			surface->LineTo(irc.right, lineTop);
+			surface->LineTo(irc.left, lineTop);
+			surface->LineTo(irc.left, ymid + 1);
+		}
+		break;
+
+	case INDIC_ROUNDBOX:
+	case INDIC_STRAIGHTBOX:
+	case INDIC_FULLBOX: {
+			PRectangle rcBox = rcLine;
+			if (sacDraw.style != INDIC_FULLBOX)
+				rcBox.top = rcLine.top + 1;
+			rcBox.left = rc.left;
+			rcBox.right = rc.right;
+			surface->AlphaRectangle(rcBox, (sacDraw.style == INDIC_ROUNDBOX) ? 1 : 0,
+						sacDraw.fore, fillAlpha, sacDraw.fore, outlineAlpha, 0);
+		}
+		break;
+
+	case INDIC_GRADIENT:
+	case INDIC_GRADIENTCENTRE: {
+			PRectangle rcBox = rc;
+			rcBox.top = rcLine.top + 1;
+			rcBox.bottom = rcLine.bottom;
+			const Surface::GradientOptions options = Surface::GradientOptions::topToBottom;
+			const ColourAlpha start(sacDraw.fore, fillAlpha);
+			const ColourAlpha end(sacDraw.fore, 0);
+			std::vector<ColourStop> stops;
+			switch (sacDraw.style) {
+			case INDIC_GRADIENT:
+				stops.push_back(ColourStop(0.0, start));
+				stops.push_back(ColourStop(1.0, end));
+				break;
+			case INDIC_GRADIENTCENTRE:
+				stops.push_back(ColourStop(0.0, end));
+				stops.push_back(ColourStop(0.5, start));
+				stops.push_back(ColourStop(1.0, end));
+				break;
+			}
+			surface->GradientRectangle(rcBox, stops, options);
+		}
+		break;
+
+	case INDIC_DOTBOX: {
+			PRectangle rcBox = PixelGridAlign(rc);
+			rcBox.top = rcLine.top + 1;
+			rcBox.bottom = rcLine.bottom;
+			const IntegerRectangle ircBox(rcBox);
+			// Cap width at 4000 to avoid large allocations when mistakes made
+			const int width = std::min(ircBox.Width(), 4000);
+			RGBAImage image(width, ircBox.Height(), 1.0, nullptr);
+			// Draw horizontal lines top and bottom
+			for (int x=0; x<width; x++) {
+				for (int y = 0; y<ircBox.Height(); y += ircBox.Height() - 1) {
+					image.SetPixel(x, y, sacDraw.fore, ((x + y) % 2) ? outlineAlpha : fillAlpha);
+				}
+			}
+			// Draw vertical lines left and right
+			for (int y = 1; y<ircBox.Height(); y++) {
+				for (int x=0; x<width; x += width-1) {
+					image.SetPixel(x, y, sacDraw.fore, ((x + y) % 2) ? outlineAlpha : fillAlpha);
+				}
+			}
+			surface->DrawRGBAImage(rcBox, image.GetWidth(), image.GetHeight(), image.Pixels());
+		}
+		break;
+
+	case INDIC_DASH: {
+			int x = irc.left;
+			while (x < rc.right) {
+				surface->MoveTo(x, ymid);
+				surface->LineTo(std::min(x + 4, irc.right), ymid);
+				x += 7;
+			}
+		}
+		break;
+
+	case INDIC_DOTS: {
+			int x = irc.left;
+			while (x < irc.right) {
+				const PRectangle rcDot = PRectangle::FromInts(x, ymid, x + 1, ymid + 1);
+				surface->FillRectangle(rcDot, sacDraw.fore);
+				x += 2;
+			}
+		}
+		break;
+
+	case INDIC_COMPOSITIONTHICK: {
+			const PRectangle rcComposition(rc.left+1, rcLine.bottom-2, rc.right-1, rcLine.bottom);
+			surface->FillRectangle(rcComposition, sacDraw.fore);
+		}
+		break;
+
+	case INDIC_COMPOSITIONTHIN: {
+			const PRectangle rcComposition(rc.left+1, rcLine.bottom-2, rc.right-1, rcLine.bottom-1);
+			surface->FillRectangle(rcComposition, sacDraw.fore);
+		}
+		break;
+
+	case INDIC_POINT:
+	case INDIC_POINTCHARACTER:
+		if (rcCharacter.Width() >= 0.1) {
+			const XYPOSITION pixelHeight = std::floor(rc.Height() - 1.0f);	// 1 pixel onto next line if multiphase
+			const XYPOSITION x = (sacDraw.style == INDIC_POINT) ? (rcCharacter.left) : ((rcCharacter.right + rcCharacter.left) / 2);
+			const XYPOSITION ix = std::round(x);
+			const XYPOSITION iy = std::floor(rc.top + 1.0f);
+			Point pts[] = {
+				Point(ix - pixelHeight, iy + pixelHeight),	// Left
+				Point(ix + pixelHeight, iy + pixelHeight),	// Right
+				Point(ix, iy)								// Top
+			};
+			surface->Polygon(pts, std::size(pts), sacDraw.fore, sacDraw.fore);
+		}
+		break;
+
+	default:
+		// Either INDIC_PLAIN or unknown
+		surface->MoveTo(irc.left, ymid);
+		surface->LineTo(irc.right, ymid);
 	}
 }
 
+void Indicator::SetFlags(int attributes_) noexcept {
+	attributes = attributes_;
+}
diff --git a/Pythonwin/Scintilla/src/Indicator.h b/Pythonwin/Scintilla/src/Indicator.h
index 2081db544..669d9a2d8 100644
--- a/Pythonwin/Scintilla/src/Indicator.h
+++ b/Pythonwin/Scintilla/src/Indicator.h
@@ -8,24 +8,49 @@
 #ifndef INDICATOR_H
 #define INDICATOR_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
+
+struct StyleAndColour {
+	int style;
+	ColourDesired fore;
+	StyleAndColour() noexcept : style(INDIC_PLAIN), fore(0, 0, 0) {
+	}
+	StyleAndColour(int style_, ColourDesired fore_ = ColourDesired(0, 0, 0)) noexcept : style(style_), fore(fore_) {
+	}
+	bool operator==(const StyleAndColour &other) const noexcept {
+		return (style == other.style) && (fore == other.fore);
+	}
+};
 
 /**
  */
 class Indicator {
 public:
-	int style;
+	enum class State { normal, hover };
+	StyleAndColour sacNormal;
+	StyleAndColour sacHover;
 	bool under;
-	ColourPair fore;
-	Indicator() : style(INDIC_PLAIN), under(false), fore(ColourDesired(0,0,0)) {
+	int fillAlpha;
+	int outlineAlpha;
+	int attributes;
+	Indicator() noexcept : under(false), fillAlpha(30), outlineAlpha(50), attributes(0) {
+	}
+	Indicator(int style_, ColourDesired fore_=ColourDesired(0,0,0), bool under_=false, int fillAlpha_=30, int outlineAlpha_=50) noexcept :
+		sacNormal(style_, fore_), sacHover(style_, fore_), under(under_), fillAlpha(fillAlpha_), outlineAlpha(outlineAlpha_), attributes(0) {
+	}
+	void Draw(Surface *surface, const PRectangle &rc, const PRectangle &rcLine, const PRectangle &rcCharacter, State drawState, int value) const;
+	bool IsDynamic() const noexcept {
+		return !(sacNormal == sacHover);
 	}
-	void Draw(Surface *surface, const PRectangle &rc, const PRectangle &rcLine);
+	bool OverridesTextFore() const noexcept {
+		return sacNormal.style == INDIC_TEXTFORE || sacHover.style == INDIC_TEXTFORE;
+	}
+	int Flags() const noexcept {
+		return attributes;
+	}
+	void SetFlags(int attributes_) noexcept;
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/IntegerRectangle.h b/Pythonwin/Scintilla/src/IntegerRectangle.h
new file mode 100644
index 000000000..4eaf39c43
--- /dev/null
+++ b/Pythonwin/Scintilla/src/IntegerRectangle.h
@@ -0,0 +1,29 @@
+// Scintilla source code edit control
+/** @file IntegerRectangle.h
+ ** A rectangle with integer coordinates.
+ **/
+// Copyright 2018 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef INTEGERRECTANGLE_H
+#define INTEGERRECTANGLE_H
+
+namespace Scintilla {
+
+struct IntegerRectangle {
+	int left;
+	int top;
+	int right;
+	int bottom;
+
+	explicit IntegerRectangle(PRectangle rc) noexcept :
+		left(static_cast<int>(rc.left)), top(static_cast<int>(rc.top)),
+		right(static_cast<int>(rc.right)), bottom(static_cast<int>(rc.bottom)) {
+	}
+	int Width() const noexcept { return right - left; }
+	int Height() const noexcept { return bottom - top; }
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/KeyMap.cxx b/Pythonwin/Scintilla/src/KeyMap.cxx
index c223d5b59..1e873dbfc 100644
--- a/Pythonwin/Scintilla/src/KeyMap.cxx
+++ b/Pythonwin/Scintilla/src/KeyMap.cxx
@@ -5,17 +5,23 @@
 // Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
+#include <cstdlib>
+
+#include <stdexcept>
+#include <string_view>
+#include <vector>
+#include <map>
+#include <memory>
+
 #include "Platform.h"
 
 #include "Scintilla.h"
 
 #include "KeyMap.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-KeyMap::KeyMap() : kmap(0), len(0), alloc(0) {
+KeyMap::KeyMap() {
 	for (int i = 0; MapDefault[i].key; i++) {
 		AssignCmdKey(MapDefault[i].key,
 			MapDefault[i].modifiers,
@@ -27,53 +33,59 @@ KeyMap::~KeyMap() {
 	Clear();
 }
 
-void KeyMap::Clear() {
-	delete []kmap;
-	kmap = 0;
-	len = 0;
-	alloc = 0;
+void KeyMap::Clear() noexcept {
+	kmap.clear();
 }
 
 void KeyMap::AssignCmdKey(int key, int modifiers, unsigned int msg) {
-	if ((len+1) >= alloc) {
-		KeyToCommand *ktcNew = new KeyToCommand[alloc + 5];
-		if (!ktcNew)
-			return;
-		for (int k = 0; k < len; k++)
-			ktcNew[k] = kmap[k];
-		alloc += 5;
-		delete []kmap;
-		kmap = ktcNew;
-	}
-	for (int keyIndex = 0; keyIndex < len; keyIndex++) {
-		if ((key == kmap[keyIndex].key) && (modifiers == kmap[keyIndex].modifiers)) {
-			kmap[keyIndex].msg = msg;
-			return;
-		}
-	}
-	kmap[len].key = key;
-	kmap[len].modifiers = modifiers;
-	kmap[len].msg = msg;
-	len++;
+	kmap[KeyModifiers(key, modifiers)] = msg;
 }
 
-unsigned int KeyMap::Find(int key, int modifiers) {
-	for (int i = 0; i < len; i++) {
-		if ((key == kmap[i].key) && (modifiers == kmap[i].modifiers)) {
-			return kmap[i].msg;
-		}
-	}
-	return 0;
+unsigned int KeyMap::Find(int key, int modifiers) const {
+	std::map<KeyModifiers, unsigned int>::const_iterator it = kmap.find(KeyModifiers(key, modifiers));
+	return (it == kmap.end()) ? 0 : it->second;
+}
+
+const std::map<KeyModifiers, unsigned int> &KeyMap::GetKeyMap() const noexcept {
+	return kmap;
 }
 
+#if PLAT_GTK_MACOSX
+#define OS_X_KEYS 1
+#else
+#define OS_X_KEYS 0
+#endif
+
+// Define a modifier that is exactly Ctrl key on all platforms
+// Most uses of Ctrl map to Cmd on OS X but some can't so use SCI_[S]CTRL_META
+#if OS_X_KEYS
+#define SCI_CTRL_META SCI_META
+#define SCI_SCTRL_META (SCI_META | SCI_SHIFT)
+#else
+#define SCI_CTRL_META SCI_CTRL
+#define SCI_SCTRL_META (SCI_CTRL | SCI_SHIFT)
+#endif
+
 const KeyToCommand KeyMap::MapDefault[] = {
+
+#if OS_X_KEYS
+    {SCK_DOWN,		SCI_CTRL,	SCI_DOCUMENTEND},
+    {SCK_DOWN,		SCI_CSHIFT,	SCI_DOCUMENTENDEXTEND},
+    {SCK_UP,		SCI_CTRL,	SCI_DOCUMENTSTART},
+    {SCK_UP,		SCI_CSHIFT,	SCI_DOCUMENTSTARTEXTEND},
+    {SCK_LEFT,		SCI_CTRL,	SCI_VCHOME},
+    {SCK_LEFT,		SCI_CSHIFT,	SCI_VCHOMEEXTEND},
+    {SCK_RIGHT,		SCI_CTRL,	SCI_LINEEND},
+    {SCK_RIGHT,		SCI_CSHIFT,	SCI_LINEENDEXTEND},
+#endif
+
     {SCK_DOWN,		SCI_NORM,	SCI_LINEDOWN},
     {SCK_DOWN,		SCI_SHIFT,	SCI_LINEDOWNEXTEND},
-    {SCK_DOWN,		SCI_CTRL,	SCI_LINESCROLLDOWN},
+    {SCK_DOWN,		SCI_CTRL_META,	SCI_LINESCROLLDOWN},
     {SCK_DOWN,		SCI_ASHIFT,	SCI_LINEDOWNRECTEXTEND},
     {SCK_UP,		SCI_NORM,	SCI_LINEUP},
     {SCK_UP,			SCI_SHIFT,	SCI_LINEUPEXTEND},
-    {SCK_UP,			SCI_CTRL,	SCI_LINESCROLLUP},
+    {SCK_UP,			SCI_CTRL_META,	SCI_LINESCROLLUP},
     {SCK_UP,		SCI_ASHIFT,	SCI_LINEUPRECTEXTEND},
     {'[',			SCI_CTRL,		SCI_PARAUP},
     {'[',			SCI_CSHIFT,	SCI_PARAUPEXTEND},
@@ -81,13 +93,13 @@ const KeyToCommand KeyMap::MapDefault[] = {
     {']',			SCI_CSHIFT,	SCI_PARADOWNEXTEND},
     {SCK_LEFT,		SCI_NORM,	SCI_CHARLEFT},
     {SCK_LEFT,		SCI_SHIFT,	SCI_CHARLEFTEXTEND},
-    {SCK_LEFT,		SCI_CTRL,	SCI_WORDLEFT},
-    {SCK_LEFT,		SCI_CSHIFT,	SCI_WORDLEFTEXTEND},
+    {SCK_LEFT,		SCI_CTRL_META,	SCI_WORDLEFT},
+    {SCK_LEFT,		SCI_SCTRL_META,	SCI_WORDLEFTEXTEND},
     {SCK_LEFT,		SCI_ASHIFT,	SCI_CHARLEFTRECTEXTEND},
     {SCK_RIGHT,		SCI_NORM,	SCI_CHARRIGHT},
     {SCK_RIGHT,		SCI_SHIFT,	SCI_CHARRIGHTEXTEND},
-    {SCK_RIGHT,		SCI_CTRL,	SCI_WORDRIGHT},
-    {SCK_RIGHT,		SCI_CSHIFT,	SCI_WORDRIGHTEXTEND},
+    {SCK_RIGHT,		SCI_CTRL_META,	SCI_WORDRIGHT},
+    {SCK_RIGHT,		SCI_SCTRL_META,	SCI_WORDRIGHTEXTEND},
     {SCK_RIGHT,		SCI_ASHIFT,	SCI_CHARRIGHTRECTEXTEND},
     {'/',		SCI_CTRL,		SCI_WORDPARTLEFT},
     {'/',		SCI_CSHIFT,	SCI_WORDPARTLEFTEXTEND},
@@ -98,14 +110,12 @@ const KeyToCommand KeyMap::MapDefault[] = {
     {SCK_HOME, 		SCI_CTRL, 	SCI_DOCUMENTSTART},
     {SCK_HOME, 		SCI_CSHIFT, 	SCI_DOCUMENTSTARTEXTEND},
     {SCK_HOME, 		SCI_ALT, 	SCI_HOMEDISPLAY},
-//    {SCK_HOME,		SCI_ASHIFT,	SCI_HOMEDISPLAYEXTEND},
     {SCK_HOME,		SCI_ASHIFT,	SCI_VCHOMERECTEXTEND},
     {SCK_END,	 	SCI_NORM,	SCI_LINEEND},
     {SCK_END,	 	SCI_SHIFT, 	SCI_LINEENDEXTEND},
     {SCK_END, 		SCI_CTRL, 	SCI_DOCUMENTEND},
     {SCK_END, 		SCI_CSHIFT, 	SCI_DOCUMENTENDEXTEND},
     {SCK_END, 		SCI_ALT, 	SCI_LINEENDDISPLAY},
-//    {SCK_END,		SCI_ASHIFT,	SCI_LINEENDDISPLAYEXTEND},
     {SCK_END,		SCI_ASHIFT,	SCI_LINEENDRECTEXTEND},
     {SCK_PRIOR,		SCI_NORM,	SCI_PAGEUP},
     {SCK_PRIOR,		SCI_SHIFT, 	SCI_PAGEUPEXTEND},
@@ -127,7 +137,11 @@ const KeyToCommand KeyMap::MapDefault[] = {
     {SCK_BACK, 		SCI_ALT,	SCI_UNDO},
     {SCK_BACK,		SCI_CSHIFT,	SCI_DELLINELEFT},
     {'Z', 			SCI_CTRL,	SCI_UNDO},
+#if OS_X_KEYS
+    {'Z', 			SCI_CSHIFT,	SCI_REDO},
+#else
     {'Y', 			SCI_CTRL,	SCI_REDO},
+#endif
     {'X', 			SCI_CTRL,	SCI_CUT},
     {'C', 			SCI_CTRL,	SCI_COPY},
     {'V', 			SCI_CTRL,	SCI_PASTE},
@@ -139,7 +153,6 @@ const KeyToCommand KeyMap::MapDefault[] = {
     {SCK_ADD, 		SCI_CTRL,	SCI_ZOOMIN},
     {SCK_SUBTRACT,	SCI_CTRL,	SCI_ZOOMOUT},
     {SCK_DIVIDE,	SCI_CTRL,	SCI_SETZOOM},
-    //'L', 			SCI_CTRL,		SCI_FORMFEED,
     {'L', 			SCI_CTRL,	SCI_LINECUT},
     {'L', 			SCI_CSHIFT,	SCI_LINEDELETE},
     {'T', 			SCI_CSHIFT,	SCI_LINECOPY},
diff --git a/Pythonwin/Scintilla/src/KeyMap.h b/Pythonwin/Scintilla/src/KeyMap.h
index fd9005de8..245b6daaa 100644
--- a/Pythonwin/Scintilla/src/KeyMap.h
+++ b/Pythonwin/Scintilla/src/KeyMap.h
@@ -5,20 +5,36 @@
 // Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#ifndef KEYTOCOMMAND_H
-#define KEYTOCOMMAND_H
+#ifndef KEYMAP_H
+#define KEYMAP_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
 
 #define SCI_NORM 0
 #define SCI_SHIFT SCMOD_SHIFT
 #define SCI_CTRL SCMOD_CTRL
 #define SCI_ALT SCMOD_ALT
+#define SCI_META SCMOD_META
+#define SCI_SUPER SCMOD_SUPER
 #define SCI_CSHIFT (SCI_CTRL | SCI_SHIFT)
 #define SCI_ASHIFT (SCI_ALT | SCI_SHIFT)
 
+/**
+ */
+class KeyModifiers {
+public:
+	int key;
+	int modifiers;
+	KeyModifiers(int key_, int modifiers_) noexcept : key(key_), modifiers(modifiers_) {
+	}
+	bool operator<(const KeyModifiers &other) const noexcept {
+		if (key == other.key)
+			return modifiers < other.modifiers;
+		else
+			return key < other.key;
+	}
+};
+
 /**
  */
 class KeyToCommand {
@@ -31,21 +47,18 @@ class KeyToCommand {
 /**
  */
 class KeyMap {
-	KeyToCommand *kmap;
-	int len;
-	int alloc;
+	std::map<KeyModifiers, unsigned int> kmap;
 	static const KeyToCommand MapDefault[];
 
 public:
 	KeyMap();
 	~KeyMap();
-	void Clear();
+	void Clear() noexcept;
 	void AssignCmdKey(int key, int modifiers, unsigned int msg);
-	unsigned int Find(int key, int modifiers);	// 0 returned on failure
+	unsigned int Find(int key, int modifiers) const;	// 0 returned on failure
+	const std::map<KeyModifiers, unsigned int> &GetKeyMap() const noexcept;
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/KeyWords.cxx b/Pythonwin/Scintilla/src/KeyWords.cxx
deleted file mode 100644
index b38e515a0..000000000
--- a/Pythonwin/Scintilla/src/KeyWords.cxx
+++ /dev/null
@@ -1,237 +0,0 @@
-// Scintilla source code edit control
-/** @file KeyWords.cxx
- ** Colourise for particular languages.
- **/
-// Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-const LexerModule *LexerModule::base = 0;
-int LexerModule::nextLanguage = SCLEX_AUTOMATIC+1;
-
-LexerModule::LexerModule(int language_,
-	LexerFunction fnLexer_,
-	const char *languageName_,
-	LexerFunction fnFolder_,
-	const char * const wordListDescriptions_[],
-	int styleBits_) :
-	language(language_),
-	fnLexer(fnLexer_),
-	fnFolder(fnFolder_),
-	wordListDescriptions(wordListDescriptions_),
-	styleBits(styleBits_),
-	languageName(languageName_) {
-	next = base;
-	base = this;
-	if (language == SCLEX_AUTOMATIC) {
-		language = nextLanguage;
-		nextLanguage++;
-	}
-}
-
-int LexerModule::GetNumWordLists() const {
-	if (wordListDescriptions == NULL) {
-		return -1;
-	} else {
-		int numWordLists = 0;
-
-		while (wordListDescriptions[numWordLists]) {
-			++numWordLists;
-		}
-
-		return numWordLists;
-	}
-}
-
-const char *LexerModule::GetWordListDescription(int index) const {
-	static const char *emptyStr = "";
-
-	PLATFORM_ASSERT(index < GetNumWordLists());
-	if (index >= GetNumWordLists()) {
-		return emptyStr;
-	} else {
-		return wordListDescriptions[index];
- 	}
-}
-
-int LexerModule::GetStyleBitsNeeded() const {
-	return styleBits;
-}
-
-const LexerModule *LexerModule::Find(int language) {
-	const LexerModule *lm = base;
-	while (lm) {
-		if (lm->language == language) {
-			return lm;
-		}
-		lm = lm->next;
-	}
-	return 0;
-}
-
-const LexerModule *LexerModule::Find(const char *languageName) {
-	if (languageName) {
-		const LexerModule *lm = base;
-		while (lm) {
-			if (lm->languageName && 0 == strcmp(lm->languageName, languageName)) {
-				return lm;
-			}
-			lm = lm->next;
-		}
-	}
-	return 0;
-}
-
-void LexerModule::Lex(unsigned int startPos, int lengthDoc, int initStyle,
-	  WordList *keywordlists[], Accessor &styler) const {
-	if (fnLexer)
-		fnLexer(startPos, lengthDoc, initStyle, keywordlists, styler);
-}
-
-void LexerModule::Fold(unsigned int startPos, int lengthDoc, int initStyle,
-	  WordList *keywordlists[], Accessor &styler) const {
-	if (fnFolder) {
-		int lineCurrent = styler.GetLine(startPos);
-		// Move back one line in case deletion wrecked current line fold state
-		if (lineCurrent > 0) {
-			lineCurrent--;
-			int newStartPos = styler.LineStart(lineCurrent);
-			lengthDoc += startPos - newStartPos;
-			startPos = newStartPos;
-			initStyle = 0;
-			if (startPos > 0) {
-				initStyle = styler.StyleAt(startPos - 1);
-			}
-		}
-		fnFolder(startPos, lengthDoc, initStyle, keywordlists, styler);
-	}
-}
-
-// Alternative historical name for Scintilla_LinkLexers
-int wxForceScintillaLexers(void) {
-	return Scintilla_LinkLexers();
-}
-
-// To add or remove a lexer, add or remove its file and run LexGen.py.
-
-// Force a reference to all of the Scintilla lexers so that the linker will
-// not remove the code of the lexers.
-int Scintilla_LinkLexers() {
-	static int forcer = 0;
-
-// Shorten the code that declares a lexer and ensures it is linked in by calling a method.
-#define LINK_LEXER(lexer) extern LexerModule lexer; forcer += lexer.GetLanguage();
-
-//++Autogenerated -- run src/LexGen.py to regenerate
-//**\(\tLINK_LEXER(\*);\n\)
-	LINK_LEXER(lmAbaqus);
-	LINK_LEXER(lmAda);
-	LINK_LEXER(lmAns1);
-	LINK_LEXER(lmAPDL);
-	LINK_LEXER(lmAsm);
-	LINK_LEXER(lmASP);
-	LINK_LEXER(lmASY);
-	LINK_LEXER(lmAU3);
-	LINK_LEXER(lmAVE);
-	LINK_LEXER(lmBaan);
-	LINK_LEXER(lmBash);
-	LINK_LEXER(lmBatch);
-	LINK_LEXER(lmBlitzBasic);
-	LINK_LEXER(lmBullant);
-	LINK_LEXER(lmCaml);
-	LINK_LEXER(lmClw);
-	LINK_LEXER(lmClwNoCase);
-	LINK_LEXER(lmCmake);
-	LINK_LEXER(lmConf);
-	LINK_LEXER(lmCPP);
-	LINK_LEXER(lmCPPNoCase);
-	LINK_LEXER(lmCsound);
-	LINK_LEXER(lmCss);
-	LINK_LEXER(lmD);
-	LINK_LEXER(lmDiff);
-	LINK_LEXER(lmEiffel);
-	LINK_LEXER(lmEiffelkw);
-	LINK_LEXER(lmErlang);
-	LINK_LEXER(lmErrorList);
-	LINK_LEXER(lmESCRIPT);
-	LINK_LEXER(lmF77);
-	LINK_LEXER(lmFlagShip);
-	LINK_LEXER(lmForth);
-	LINK_LEXER(lmFortran);
-	LINK_LEXER(lmFreeBasic);
-	LINK_LEXER(lmGAP);
-	LINK_LEXER(lmGui4Cli);
-	LINK_LEXER(lmHaskell);
-	LINK_LEXER(lmHTML);
-	LINK_LEXER(lmInno);
-	LINK_LEXER(lmKix);
-	LINK_LEXER(lmLatex);
-	LINK_LEXER(lmLISP);
-	LINK_LEXER(lmLot);
-	LINK_LEXER(lmLout);
-	LINK_LEXER(lmLua);
-	LINK_LEXER(lmMagikSF);
-	LINK_LEXER(lmMake);
-	LINK_LEXER(lmMatlab);
-	LINK_LEXER(lmMETAPOST);
-	LINK_LEXER(lmMMIXAL);
-	LINK_LEXER(lmMSSQL);
-	LINK_LEXER(lmMySQL);
-	LINK_LEXER(lmNncrontab);
-	LINK_LEXER(lmNsis);
-	LINK_LEXER(lmNull);
-	LINK_LEXER(lmOctave);
-	LINK_LEXER(lmOpal);
-	LINK_LEXER(lmPascal);
-	LINK_LEXER(lmPB);
-	LINK_LEXER(lmPerl);
-	LINK_LEXER(lmPHP);
-	LINK_LEXER(lmPHPSCRIPT);
-	LINK_LEXER(lmPLM);
-	LINK_LEXER(lmPo);
-	LINK_LEXER(lmPOV);
-	LINK_LEXER(lmPowerShell);
-	LINK_LEXER(lmProgress);
-	LINK_LEXER(lmProps);
-	LINK_LEXER(lmPS);
-	LINK_LEXER(lmPureBasic);
-	LINK_LEXER(lmPython);
-	LINK_LEXER(lmR);
-	LINK_LEXER(lmREBOL);
-	LINK_LEXER(lmRuby);
-	LINK_LEXER(lmScriptol);
-	LINK_LEXER(lmSmalltalk);
-	LINK_LEXER(lmSpecman);
-	LINK_LEXER(lmSpice);
-	LINK_LEXER(lmSQL);
-	LINK_LEXER(lmTADS3);
-	LINK_LEXER(lmTCL);
-	LINK_LEXER(lmTeX);
-	LINK_LEXER(lmVB);
-	LINK_LEXER(lmVBScript);
-	LINK_LEXER(lmVerilog);
-	LINK_LEXER(lmVHDL);
-	LINK_LEXER(lmXML);
-	LINK_LEXER(lmYAML);
-
-//--Autogenerated -- end of automatically generated section
-
-	return 1;
-}
diff --git a/Pythonwin/Scintilla/src/LexAsm.cxx b/Pythonwin/Scintilla/src/LexAsm.cxx
deleted file mode 100644
index 17c938420..000000000
--- a/Pythonwin/Scintilla/src/LexAsm.cxx
+++ /dev/null
@@ -1,180 +0,0 @@
-// Scintilla source code edit control
-/** @file LexAsm.cxx
- ** Lexer for Assembler, just for the MASM syntax
- ** Written by The Black Horus
- ** Enhancements and NASM stuff by Kein-Hong Man, 2003-10
- ** SCE_ASM_COMMENTBLOCK and SCE_ASM_CHARACTER are for future GNU as colouring
- **/
-// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-static inline bool IsAWordChar(const int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '.' ||
-		ch == '_' || ch == '?');
-}
-
-static inline bool IsAWordStart(const int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '.' ||
-		ch == '%' || ch == '@' || ch == '$' || ch == '?');
-}
-
-static inline bool IsAsmOperator(const int ch) {
-	if ((ch < 0x80) && (isalnum(ch)))
-		return false;
-	// '.' left out as it is used to make up numbers
-	if (ch == '*' || ch == '/' || ch == '-' || ch == '+' ||
-		ch == '(' || ch == ')' || ch == '=' || ch == '^' ||
-		ch == '[' || ch == ']' || ch == '<' || ch == '&' ||
-		ch == '>' || ch == ',' || ch == '|' || ch == '~' ||
-		ch == '%' || ch == ':')
-		return true;
-	return false;
-}
-
-static void ColouriseAsmDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                            Accessor &styler) {
-
-	WordList &cpuInstruction = *keywordlists[0];
-	WordList &mathInstruction = *keywordlists[1];
-	WordList &registers = *keywordlists[2];
-	WordList &directive = *keywordlists[3];
-	WordList &directiveOperand = *keywordlists[4];
-	WordList &extInstruction = *keywordlists[5];
-
-	// Do not leak onto next line
-	if (initStyle == SCE_ASM_STRINGEOL)
-		initStyle = SCE_ASM_DEFAULT;
-
-	StyleContext sc(startPos, length, initStyle, styler);
-
-	for (; sc.More(); sc.Forward())
-	{
-
-		// Prevent SCE_ASM_STRINGEOL from leaking back to previous line
-		if (sc.atLineStart && (sc.state == SCE_ASM_STRING)) {
-			sc.SetState(SCE_ASM_STRING);
-		} else if (sc.atLineStart && (sc.state == SCE_ASM_CHARACTER)) {
-			sc.SetState(SCE_ASM_CHARACTER);
-		}
-
-		// Handle line continuation generically.
-		if (sc.ch == '\\') {
-			if (sc.chNext == '\n' || sc.chNext == '\r') {
-				sc.Forward();
-				if (sc.ch == '\r' && sc.chNext == '\n') {
-					sc.Forward();
-				}
-				continue;
-			}
-		}
-
-		// Determine if the current state should terminate.
-		if (sc.state == SCE_ASM_OPERATOR) {
-			if (!IsAsmOperator(sc.ch)) {
-			    sc.SetState(SCE_ASM_DEFAULT);
-			}
-		}else if (sc.state == SCE_ASM_NUMBER) {
-			if (!IsAWordChar(sc.ch)) {
-				sc.SetState(SCE_ASM_DEFAULT);
-			}
-		} else if (sc.state == SCE_ASM_IDENTIFIER) {
-			if (!IsAWordChar(sc.ch) ) {
-				char s[100];
-				sc.GetCurrentLowered(s, sizeof(s));
-
-				if (cpuInstruction.InList(s)) {
-					sc.ChangeState(SCE_ASM_CPUINSTRUCTION);
-				} else if (mathInstruction.InList(s)) {
-					sc.ChangeState(SCE_ASM_MATHINSTRUCTION);
-				} else if (registers.InList(s)) {
-					sc.ChangeState(SCE_ASM_REGISTER);
-				}  else if (directive.InList(s)) {
-					sc.ChangeState(SCE_ASM_DIRECTIVE);
-				} else if (directiveOperand.InList(s)) {
-					sc.ChangeState(SCE_ASM_DIRECTIVEOPERAND);
-				} else if (extInstruction.InList(s)) {
-					sc.ChangeState(SCE_ASM_EXTINSTRUCTION);
-				}
-				sc.SetState(SCE_ASM_DEFAULT);
-			}
-		}
-		else if (sc.state == SCE_ASM_COMMENT ) {
-			if (sc.atLineEnd) {
-				sc.SetState(SCE_ASM_DEFAULT);
-			}
-		} else if (sc.state == SCE_ASM_STRING) {
-			if (sc.ch == '\\') {
-				if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
-					sc.Forward();
-				}
-			} else if (sc.ch == '\"') {
-				sc.ForwardSetState(SCE_ASM_DEFAULT);
-			} else if (sc.atLineEnd) {
-				sc.ChangeState(SCE_ASM_STRINGEOL);
-				sc.ForwardSetState(SCE_ASM_DEFAULT);
-			}
-		} else if (sc.state == SCE_ASM_CHARACTER) {
-			if (sc.ch == '\\') {
-				if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
-					sc.Forward();
-				}
-			} else if (sc.ch == '\'') {
-				sc.ForwardSetState(SCE_ASM_DEFAULT);
-			} else if (sc.atLineEnd) {
-				sc.ChangeState(SCE_ASM_STRINGEOL);
-				sc.ForwardSetState(SCE_ASM_DEFAULT);
-			}
-		}
-
-		// Determine if a new state should be entered.
-		if (sc.state == SCE_ASM_DEFAULT) {
-			if (sc.ch == ';'){
-				sc.SetState(SCE_ASM_COMMENT);
-			} else if (isascii(sc.ch) && (isdigit(sc.ch) || (sc.ch == '.' && isascii(sc.chNext) && isdigit(sc.chNext)))) {
-				sc.SetState(SCE_ASM_NUMBER);
-			} else if (IsAWordStart(sc.ch)) {
-				sc.SetState(SCE_ASM_IDENTIFIER);
-			} else if (sc.ch == '\"') {
-				sc.SetState(SCE_ASM_STRING);
-			} else if (sc.ch == '\'') {
-				sc.SetState(SCE_ASM_CHARACTER);
-			} else if (IsAsmOperator(sc.ch)) {
-				sc.SetState(SCE_ASM_OPERATOR);
-			}
-		}
-
-	}
-	sc.Complete();
-}
-
-static const char * const asmWordListDesc[] = {
-	"CPU instructions",
-	"FPU instructions",
-	"Registers",
-	"Directives",
-	"Directive operands",
-	"Extended instructions",
-	0
-};
-
-LexerModule lmAsm(SCLEX_ASM, ColouriseAsmDoc, "asm", 0, asmWordListDesc);
-
diff --git a/Pythonwin/Scintilla/src/LexBaan.cxx b/Pythonwin/Scintilla/src/LexBaan.cxx
deleted file mode 100644
index a6847db71..000000000
--- a/Pythonwin/Scintilla/src/LexBaan.cxx
+++ /dev/null
@@ -1,193 +0,0 @@
-// Scintilla source code edit control
-/** @file LexBaan.cxx
- ** Lexer for Baan.
- ** Based heavily on LexCPP.cxx
- **/
-// Copyright 2001- by Vamsi Potluru <vamsi@who.net> & Praveen Ambekar <ambekarpraveen@yahoo.com>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-static inline bool IsAWordChar(const int  ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_' || ch == '$' || ch == ':');
-}
-
-static inline bool IsAWordStart(const int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '_');
-}
-
-static void ColouriseBaanDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                            Accessor &styler) {
-
-	WordList &keywords = *keywordlists[0];
-	WordList &keywords2 = *keywordlists[1];
-	bool stylingWithinPreprocessor = styler.GetPropertyInt("styling.within.preprocessor") != 0;
-
-	if (initStyle == SCE_BAAN_STRINGEOL)	// Does not leak onto next line
-		initStyle = SCE_BAAN_DEFAULT;
-
-	int visibleChars = 0;
-
-	StyleContext sc(startPos, length, initStyle, styler);
-
-	for (; sc.More(); sc.Forward()) {
-
-		if (sc.state == SCE_BAAN_OPERATOR) {
-			sc.SetState(SCE_BAAN_DEFAULT);
-		} else if (sc.state == SCE_BAAN_NUMBER) {
-			if (!IsAWordChar(sc.ch)) {
-				sc.SetState(SCE_BAAN_DEFAULT);
-			}
-		} else if (sc.state == SCE_BAAN_IDENTIFIER) {
-			if (!IsAWordChar(sc.ch)) {
-				char s[100];
-				sc.GetCurrentLowered(s, sizeof(s));
-				if (keywords.InList(s)) {
-					sc.ChangeState(SCE_BAAN_WORD);
-				} else if (keywords2.InList(s)) {
-					sc.ChangeState(SCE_BAAN_WORD2);
-				}
-				sc.SetState(SCE_BAAN_DEFAULT);
-			}
-		} else if (sc.state == SCE_BAAN_PREPROCESSOR) {
-			if (stylingWithinPreprocessor) {
-				if (IsASpace(sc.ch)) {
-					sc.SetState(SCE_BAAN_DEFAULT);
-				}
-			} else {
-				if (sc.atLineEnd && (sc.chNext != '^')) {
-					sc.SetState(SCE_BAAN_DEFAULT);
-				}
-			}
-		} else if (sc.state == SCE_BAAN_COMMENT) {
-			if (sc.atLineEnd) {
-				sc.SetState(SCE_BAAN_DEFAULT);
-			}
-		} else if (sc.state == SCE_BAAN_COMMENTDOC) {
-			if (sc.MatchIgnoreCase("enddllusage")) {
-				for (unsigned int i = 0; i < 10; i++){
-					sc.Forward();
-				}
-				sc.ForwardSetState(SCE_BAAN_DEFAULT);
-			}
-		} else if (sc.state == SCE_BAAN_STRING) {
-			if (sc.ch == '\"') {
-				sc.ForwardSetState(SCE_BAAN_DEFAULT);
-			} else if ((sc.atLineEnd) && (sc.chNext != '^')) {
-				sc.ChangeState(SCE_BAAN_STRINGEOL);
-				sc.ForwardSetState(SCE_C_DEFAULT);
-				visibleChars = 0;
-			}
-		}
-
-		if (sc.state == SCE_BAAN_DEFAULT) {
-			if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
-				sc.SetState(SCE_BAAN_NUMBER);
-			} else if (sc.MatchIgnoreCase("dllusage")){
-					sc.SetState(SCE_BAAN_COMMENTDOC);
-					do {
-						sc.Forward();
-					} while ((!sc.atLineEnd) && sc.More());
-			} else if (IsAWordStart(sc.ch)) {
-					sc.SetState(SCE_BAAN_IDENTIFIER);
-			} else if (sc.Match('|')){
-					sc.SetState(SCE_BAAN_COMMENT);
-			} else if (sc.ch == '\"') {
-				sc.SetState(SCE_BAAN_STRING);
-			} else if (sc.ch == '#' && visibleChars == 0) {
-				// Preprocessor commands are alone on their line
-				sc.SetState(SCE_BAAN_PREPROCESSOR);
-				// Skip whitespace between # and preprocessor word
-				do {
-					sc.Forward();
-				} while (IsASpace(sc.ch) && sc.More());
-			} else if (isoperator(static_cast<char>(sc.ch))) {
-				sc.SetState(SCE_BAAN_OPERATOR);
-			}
-		}
-		if (sc.atLineEnd) {
-			// Reset states to begining of colourise so no surprises
-			// if different sets of lines lexed.
-			visibleChars = 0;
-		}
-		if (!IsASpace(sc.ch)) {
-			visibleChars++;
-		}
-	}
-	sc.Complete();
-}
-
-static void FoldBaanDoc(unsigned int startPos, int length, int initStyle, WordList *[],
-                            Accessor &styler) {
-	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
-	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	unsigned int endPos = startPos + length;
-	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
-	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
-	int levelCurrent = levelPrev;
-	char chNext = styler[startPos];
-	int styleNext = styler.StyleAt(startPos);
-	int style = initStyle;
-	for (unsigned int i = startPos; i < endPos; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-		int stylePrev = style;
-		style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
-		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
-		if (foldComment &&
-			(style == SCE_BAAN_COMMENT || style == SCE_BAAN_COMMENTDOC)) {
-			if (style != stylePrev) {
-				levelCurrent++;
-			} else if ((style != styleNext) && !atEOL) {
-				// Comments don't end at end of line and the next character may be unstyled.
-				levelCurrent--;
-			}
-		}
-		if (style == SCE_BAAN_OPERATOR) {
-			if (ch == '{') {
-				levelCurrent++;
-			} else if (ch == '}') {
-				levelCurrent--;
-			}
-		}
-		if (atEOL) {
-			int lev = levelPrev;
-			if (visibleChars == 0 && foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if ((levelCurrent > levelPrev) && (visibleChars > 0))
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
-			lineCurrent++;
-			levelPrev = levelCurrent;
-			visibleChars = 0;
-		}
-		if (!isspacechar(ch))
-			visibleChars++;
-	}
-	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
-	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
-	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
-}
-
-LexerModule lmBaan(SCLEX_BAAN, ColouriseBaanDoc, "baan", FoldBaanDoc);
diff --git a/Pythonwin/Scintilla/src/LexBash.cxx b/Pythonwin/Scintilla/src/LexBash.cxx
deleted file mode 100644
index 7b475a7de..000000000
--- a/Pythonwin/Scintilla/src/LexBash.cxx
+++ /dev/null
@@ -1,532 +0,0 @@
-// Scintilla source code edit control
-/** @file LexBash.cxx
- ** Lexer for Bash.
- **/
-// Copyright 2004-2008 by Neil Hodgson <neilh@scintilla.org>
-// Adapted from LexPerl by Kein-Hong Man 2004
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-#include "CharacterSet.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-#define HERE_DELIM_MAX 256
-
-// define this if you want 'invalid octals' to be marked as errors
-// usually, this is not a good idea, permissive lexing is better
-#undef PEDANTIC_OCTAL
-
-#define BASH_BASE_ERROR		65
-#define BASH_BASE_DECIMAL	66
-#define BASH_BASE_HEX		67
-#ifdef PEDANTIC_OCTAL
-#define BASH_BASE_OCTAL		68
-#define BASH_BASE_OCTAL_ERROR	69
-#endif
-
-static inline int translateBashDigit(int ch) {
-	if (ch >= '0' && ch <= '9') {
-		return ch - '0';
-	} else if (ch >= 'a' && ch <= 'z') {
-		return ch - 'a' + 10;
-	} else if (ch >= 'A' && ch <= 'Z') {
-		return ch - 'A' + 36;
-	} else if (ch == '@') {
-		return 62;
-	} else if (ch == '_') {
-		return 63;
-	}
-	return BASH_BASE_ERROR;
-}
-
-static inline int getBashNumberBase(char *s) {
-	int i = 0;
-	int base = 0;
-	while (*s) {
-		base = base * 10 + (*s++ - '0');
-		i++;
-	}
-	if (base > 64 || i > 2) {
-		return BASH_BASE_ERROR;
-	}
-	return base;
-}
-
-static int opposite(int ch) {
-	if (ch == '(') return ')';
-	if (ch == '[') return ']';
-	if (ch == '{') return '}';
-	if (ch == '<') return '>';
-	return ch;
-}
-
-static void ColouriseBashDoc(unsigned int startPos, int length, int initStyle,
-							 WordList *keywordlists[], Accessor &styler) {
-
-	WordList &keywords = *keywordlists[0];
-
-	CharacterSet setWordStart(CharacterSet::setAlpha, "_");
-	// note that [+-] are often parts of identifiers in shell scripts
-	CharacterSet setWord(CharacterSet::setAlphaNum, "._+-");
-	CharacterSet setBashOperator(CharacterSet::setNone, "^&\\%()-+=|{}[]:;>,*/<?!.~@");
-	CharacterSet setSingleCharOp(CharacterSet::setNone, "rwxoRWXOezsfdlpSbctugkTBMACahGLNn");
-	CharacterSet setParam(CharacterSet::setAlphaNum, "$_");
-	CharacterSet setHereDoc(CharacterSet::setAlpha, "_\\-+!");
-	CharacterSet setHereDoc2(CharacterSet::setAlphaNum, "_-+!");
-	CharacterSet setLeftShift(CharacterSet::setDigits, "=$");
-
-	class HereDocCls {	// Class to manage HERE document elements
-	public:
-		int State;		// 0: '<<' encountered
-		// 1: collect the delimiter
-		// 2: here doc text (lines after the delimiter)
-		int Quote;		// the char after '<<'
-		bool Quoted;		// true if Quote in ('\'','"','`')
-		bool Indent;		// indented delimiter (for <<-)
-		int DelimiterLength;	// strlen(Delimiter)
-		char *Delimiter;	// the Delimiter, 256: sizeof PL_tokenbuf
-		HereDocCls() {
-			State = 0;
-			Quote = 0;
-			Quoted = false;
-			Indent = 0;
-			DelimiterLength = 0;
-			Delimiter = new char[HERE_DELIM_MAX];
-			Delimiter[0] = '\0';
-		}
-		void Append(int ch) {
-			Delimiter[DelimiterLength++] = static_cast<char>(ch);
-			Delimiter[DelimiterLength] = '\0';
-		}
-		~HereDocCls() {
-			delete []Delimiter;
-		}
-	};
-	HereDocCls HereDoc;
-
-	class QuoteCls {	// Class to manage quote pairs (simplified vs LexPerl)
-		public:
-		int Count;
-		int Up, Down;
-		QuoteCls() {
-			Count = 0;
-			Up    = '\0';
-			Down  = '\0';
-		}
-		void Open(int u) {
-			Count++;
-			Up    = u;
-			Down  = opposite(Up);
-		}
-		void Start(int u) {
-			Count = 0;
-			Open(u);
-		}
-	};
-	QuoteCls Quote;
-
-	int numBase = 0;
-	int digit;
-	unsigned int endPos = startPos + length;
-
-	// Backtrack to beginning of style if required...
-	// If in a long distance lexical state, backtrack to find quote characters
-	if (initStyle == SCE_SH_HERE_Q) {
-		while ((startPos > 1) && (styler.StyleAt(startPos) != SCE_SH_HERE_DELIM)) {
-			startPos--;
-		}
-		startPos = styler.LineStart(styler.GetLine(startPos));
-		initStyle = styler.StyleAt(startPos - 1);
-	}
-	// Bash strings can be multi-line with embedded newlines, so backtrack.
-	// Bash numbers have additional state during lexing, so backtrack too.
-	if (initStyle == SCE_SH_STRING
-	 || initStyle == SCE_SH_BACKTICKS
-	 || initStyle == SCE_SH_CHARACTER
-	 || initStyle == SCE_SH_NUMBER
-	 || initStyle == SCE_SH_IDENTIFIER
-	 || initStyle == SCE_SH_COMMENTLINE) {
-		while ((startPos > 1) && (styler.StyleAt(startPos - 1) == initStyle)) {
-			startPos--;
-		}
-		initStyle = SCE_SH_DEFAULT;
-	}
-
-	StyleContext sc(startPos, endPos - startPos, initStyle, styler);
-
-	for (; sc.More(); sc.Forward()) {
-
-		// Determine if the current state should terminate.
-		switch (sc.state) {
-			case SCE_SH_OPERATOR:
-				sc.SetState(SCE_SH_DEFAULT);
-				break;
-			case SCE_SH_WORD:
-				// "." never used in Bash variable names but used in file names
-				if (!setWord.Contains(sc.ch)) {
-					char s[1000];
-					sc.GetCurrent(s, sizeof(s));
-					if (s[0] != '-' &&	// for file operators
-						!keywords.InList(s)) {
-						sc.ChangeState(SCE_SH_IDENTIFIER);
-					}
-					sc.SetState(SCE_SH_DEFAULT);
-				}
-				break;
-			case SCE_SH_IDENTIFIER:
-				if (sc.chPrev == '\\') {	// for escaped chars
-					sc.ForwardSetState(SCE_SH_DEFAULT);
-				} else if (!setWord.Contains(sc.ch)) {
-					sc.SetState(SCE_SH_DEFAULT);
-				}
-				break;
-			case SCE_SH_NUMBER:
-				digit = translateBashDigit(sc.ch);
-				if (numBase == BASH_BASE_DECIMAL) {
-					if (sc.ch == '#') {
-						char s[10];
-						sc.GetCurrent(s, sizeof(s));
-						numBase = getBashNumberBase(s);
-						if (numBase != BASH_BASE_ERROR)
-							break;
-					} else if (IsADigit(sc.ch))
-						break;
-				} else if (numBase == BASH_BASE_HEX) {
-					if (IsADigit(sc.ch, 16))
-						break;
-#ifdef PEDANTIC_OCTAL
-				} else if (numBase == BASH_BASE_OCTAL ||
-						   numBase == BASH_BASE_OCTAL_ERROR) {
-					if (digit <= 7)
-						break;
-					if (digit <= 9) {
-						numBase = BASH_BASE_OCTAL_ERROR;
-						break;
-					}
-#endif
-				} else if (numBase == BASH_BASE_ERROR) {
-					if (digit <= 9)
-						break;
-				} else {	// DD#DDDD number style handling
-					if (digit != BASH_BASE_ERROR) {
-						if (numBase <= 36) {
-							// case-insensitive if base<=36
-							if (digit >= 36) digit -= 26;
-						}
-						if (digit < numBase)
-							break;
-						if (digit <= 9) {
-							numBase = BASH_BASE_ERROR;
-							break;
-						}
-					}
-				}
-				// fallthrough when number is at an end or error
-				if (numBase == BASH_BASE_ERROR
-#ifdef PEDANTIC_OCTAL
-					|| numBase == BASH_BASE_OCTAL_ERROR
-#endif
-				) {
-					sc.ChangeState(SCE_SH_ERROR);
-				}
-				sc.SetState(SCE_SH_DEFAULT);
-				break;
-			case SCE_SH_COMMENTLINE:
-				if (sc.ch == '\\' && (sc.chNext == '\r' || sc.chNext == '\n')) {
-					// comment continuation
-					sc.Forward();
-					if (sc.ch == '\r' && sc.chNext == '\n') {
-						sc.Forward();
-					}
-				} else if (sc.atLineEnd) {
-					sc.ForwardSetState(SCE_SH_DEFAULT);
-				}
-				break;
-			case SCE_SH_HERE_DELIM:
-				// From Bash info:
-				// ---------------
-				// Specifier format is: <<[-]WORD
-				// Optional '-' is for removal of leading tabs from here-doc.
-				// Whitespace acceptable after <<[-] operator
-				//
-				if (HereDoc.State == 0) { // '<<' encountered
-					HereDoc.Quote = sc.chNext;
-					HereDoc.Quoted = false;
-					HereDoc.DelimiterLength = 0;
-					HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0';
-					if (sc.chNext == '\'' || sc.chNext == '\"') {	// a quoted here-doc delimiter (' or ")
-						sc.Forward();
-						HereDoc.Quoted = true;
-						HereDoc.State = 1;
-					} else if (!HereDoc.Indent && sc.chNext == '-') {	// <<- indent case
-						HereDoc.Indent = true;
-					} else if (setHereDoc.Contains(sc.chNext)) {
-						// an unquoted here-doc delimiter, no special handling
-						// TODO check what exactly bash considers part of the delim
-						HereDoc.State = 1;
-					} else if (sc.chNext == '<') {	// HERE string <<<
-						sc.Forward();
-						sc.ForwardSetState(SCE_SH_DEFAULT);
-					} else if (IsASpace(sc.chNext)) {
-						// eat whitespace
-					} else if (setLeftShift.Contains(sc.chNext)) {
-						// left shift << or <<= operator cases
-						sc.ChangeState(SCE_SH_OPERATOR);
-						sc.ForwardSetState(SCE_SH_DEFAULT);
-					} else {
-						// symbols terminates; deprecated zero-length delimiter
-						HereDoc.State = 1;
-					}
-				} else if (HereDoc.State == 1) { // collect the delimiter
-					if (HereDoc.Quoted) { // a quoted here-doc delimiter
-						if (sc.ch == HereDoc.Quote) { // closing quote => end of delimiter
-							sc.ForwardSetState(SCE_SH_DEFAULT);
-						} else {
-							if (sc.ch == '\\' && sc.chNext == HereDoc.Quote) { // escaped quote
-								sc.Forward();
-							}
-							HereDoc.Append(sc.ch);
-						}
-					} else { // an unquoted here-doc delimiter
-						if (setHereDoc2.Contains(sc.ch)) {
-							HereDoc.Append(sc.ch);
-						} else if (sc.ch == '\\') {
-							// skip escape prefix
-						} else {
-							sc.SetState(SCE_SH_DEFAULT);
-						}
-					}
-					if (HereDoc.DelimiterLength >= HERE_DELIM_MAX - 1) {	// force blowup
-						sc.SetState(SCE_SH_ERROR);
-						HereDoc.State = 0;
-					}
-				}
-				break;
-			case SCE_SH_HERE_Q:
-				// HereDoc.State == 2
-				if (sc.atLineStart) {
-					sc.SetState(SCE_SH_HERE_Q);
-					int prefixws = 0;
-					while (IsASpace(sc.ch) && !sc.atLineEnd) {	// whitespace prefix
-						sc.Forward();
-						prefixws++;
-					}
-					if (prefixws > 0)
-						sc.SetState(SCE_SH_HERE_Q);
-					while (!sc.atLineEnd) {
-						sc.Forward();
-					}
-					char s[HERE_DELIM_MAX];
-					sc.GetCurrent(s, sizeof(s));
-					if (strcmp(HereDoc.Delimiter, s) == 0) {
-						if ((prefixws > 0 && HereDoc.Indent) ||	// indentation rule
-							(prefixws == 0 && !HereDoc.Indent)) {
-							sc.SetState(SCE_SH_DEFAULT);
-							break;
-						}
-					}
-				}
-				break;
-			case SCE_SH_SCALAR:	// variable names
-				if (!setParam.Contains(sc.ch)) {
-					if (sc.LengthCurrent() == 1) {
-						// Special variable: $(, $_ etc.
-						sc.ForwardSetState(SCE_SH_DEFAULT);
-					} else {
-						sc.SetState(SCE_SH_DEFAULT);
-					}
-				}
-				break;
-			case SCE_SH_STRING:	// delimited styles
-			case SCE_SH_CHARACTER:
-			case SCE_SH_BACKTICKS:
-			case SCE_SH_PARAM:
-				if (sc.ch == '\\' && Quote.Up != '\\') {
-					sc.Forward();
-				} else if (sc.ch == Quote.Down) {
-					Quote.Count--;
-					if (Quote.Count == 0) {
-						sc.ForwardSetState(SCE_SH_DEFAULT);
-					}
-				} else if (sc.ch == Quote.Up) {
-					Quote.Count++;
-				}
-				break;
-		}
-
-		// Must check end of HereDoc state 1 before default state is handled
-		if (HereDoc.State == 1 && sc.atLineEnd) {
-			// Begin of here-doc (the line after the here-doc delimiter):
-			// Lexically, the here-doc starts from the next line after the >>, but the
-			// first line of here-doc seem to follow the style of the last EOL sequence
-			HereDoc.State = 2;
-			if (HereDoc.Quoted) {
-				if (sc.state == SCE_SH_HERE_DELIM) {
-					// Missing quote at end of string! We are stricter than bash.
-					// Colour here-doc anyway while marking this bit as an error.
-					sc.ChangeState(SCE_SH_ERROR);
-				}
-				// HereDoc.Quote always == '\''
-			}
-			sc.SetState(SCE_SH_HERE_Q);
-		}
-
-		// Determine if a new state should be entered.
-		if (sc.state == SCE_SH_DEFAULT) {
-			if (sc.ch == '\\') {	// escaped character
-				sc.SetState(SCE_SH_IDENTIFIER);
-			} else if (IsADigit(sc.ch)) {
-				sc.SetState(SCE_SH_NUMBER);
-				numBase = BASH_BASE_DECIMAL;
-				if (sc.ch == '0') {	// hex,octal
-					if (sc.chNext == 'x' || sc.chNext == 'X') {
-						numBase = BASH_BASE_HEX;
-						sc.Forward();
-					} else if (IsADigit(sc.chNext)) {
-#ifdef PEDANTIC_OCTAL
-						numBase = BASH_BASE_OCTAL;
-#else
-						numBase = BASH_BASE_HEX;
-#endif
-					}
-				}
-			} else if (setWordStart.Contains(sc.ch)) {
-				sc.SetState(SCE_SH_WORD);
-			} else if (sc.ch == '#') {
-				sc.SetState(SCE_SH_COMMENTLINE);
-			} else if (sc.ch == '\"') {
-				sc.SetState(SCE_SH_STRING);
-				Quote.Start(sc.ch);
-			} else if (sc.ch == '\'') {
-				sc.SetState(SCE_SH_CHARACTER);
-				Quote.Start(sc.ch);
-			} else if (sc.ch == '`') {
-				sc.SetState(SCE_SH_BACKTICKS);
-				Quote.Start(sc.ch);
-			} else if (sc.ch == '$') {
-				sc.SetState(SCE_SH_SCALAR);
-				sc.Forward();
-				if (sc.ch == '{') {
-					sc.ChangeState(SCE_SH_PARAM);
-				} else if (sc.ch == '\'') {
-					sc.ChangeState(SCE_SH_CHARACTER);
-				} else if (sc.ch == '"') {
-					sc.ChangeState(SCE_SH_STRING);
-				} else if (sc.ch == '(' || sc.ch == '`') {
-					sc.ChangeState(SCE_SH_BACKTICKS);
-					if (sc.chNext == '(') {	// $(( is lexed as operator
-						sc.ChangeState(SCE_SH_OPERATOR);
-					}
-				} else {
-					continue;	// scalar has no delimiter pair
-				}
-				// fallthrough, open delim for $[{'"(`]
-				Quote.Start(sc.ch);
-			} else if (sc.Match('<', '<')) {
-				sc.SetState(SCE_SH_HERE_DELIM);
-				HereDoc.State = 0;
-				HereDoc.Indent = false;
-			} else if (sc.ch == '-'	&&	// one-char file test operators
-					   setSingleCharOp.Contains(sc.chNext) &&
-					   !setWord.Contains(sc.GetRelative(2)) &&
-					   IsASpace(sc.chPrev)) {
-				sc.SetState(SCE_SH_WORD);
-				sc.Forward();
-			} else if (setBashOperator.Contains(sc.ch)) {
-				sc.SetState(SCE_SH_OPERATOR);
-			}
-		}
-	}
-	sc.Complete();
-}
-
-static bool IsCommentLine(int line, Accessor &styler) {
-	int pos = styler.LineStart(line);
-	int eol_pos = styler.LineStart(line + 1) - 1;
-	for (int i = pos; i < eol_pos; i++) {
-		char ch = styler[i];
-		if (ch == '#')
-			return true;
-		else if (ch != ' ' && ch != '\t')
-			return false;
-	}
-	return false;
-}
-
-static void FoldBashDoc(unsigned int startPos, int length, int, WordList *[],
-						Accessor &styler) {
-	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
-	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	unsigned int endPos = startPos + length;
-	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
-	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
-	int levelCurrent = levelPrev;
-	char chNext = styler[startPos];
-	int styleNext = styler.StyleAt(startPos);
-	for (unsigned int i = startPos; i < endPos; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-		int style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
-		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
-		// Comment folding
-		if (foldComment && atEOL && IsCommentLine(lineCurrent, styler))
-		{
-			if (!IsCommentLine(lineCurrent - 1, styler)
-				&& IsCommentLine(lineCurrent + 1, styler))
-				levelCurrent++;
-			else if (IsCommentLine(lineCurrent - 1, styler)
-					 && !IsCommentLine(lineCurrent + 1, styler))
-				levelCurrent--;
-		}
-		if (style == SCE_SH_OPERATOR) {
-			if (ch == '{') {
-				levelCurrent++;
-			} else if (ch == '}') {
-				levelCurrent--;
-			}
-		}
-		if (atEOL) {
-			int lev = levelPrev;
-			if (visibleChars == 0 && foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if ((levelCurrent > levelPrev) && (visibleChars > 0))
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
-			lineCurrent++;
-			levelPrev = levelCurrent;
-			visibleChars = 0;
-		}
-		if (!isspacechar(ch))
-			visibleChars++;
-	}
-	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
-	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
-	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
-}
-
-static const char * const bashWordListDesc[] = {
-	"Keywords",
-	0
-};
-
-LexerModule lmBash(SCLEX_BASH, ColouriseBashDoc, "bash", FoldBashDoc, bashWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexBasic.cxx b/Pythonwin/Scintilla/src/LexBasic.cxx
deleted file mode 100644
index 1c5d7b425..000000000
--- a/Pythonwin/Scintilla/src/LexBasic.cxx
+++ /dev/null
@@ -1,373 +0,0 @@
-// Scintilla source code edit control
-/** @file LexBasic.cxx
- ** Lexer for BlitzBasic and PureBasic.
- **/
-// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-// This tries to be a unified Lexer/Folder for all the BlitzBasic/BlitzMax/PurBasic basics
-// and derivatives. Once they diverge enough, might want to split it into multiple
-// lexers for more code clearity.
-//
-// Mail me (elias <at> users <dot> sf <dot> net) for any bugs.
-
-// Folding only works for simple things like functions or types.
-
-// You may want to have a look at my ctags lexer as well, if you additionally to coloring
-// and folding need to extract things like label tags in your editor.
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-/* Bits:
- * 1  - whitespace
- * 2  - operator
- * 4  - identifier
- * 8  - decimal digit
- * 16 - hex digit
- * 32 - bin digit
- */
-static int character_classification[128] =
-{
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  1,  0,  0,  1,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
-    1,  2,  0,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  10, 2,
-    60, 60, 28, 28, 28, 28, 28, 28, 28, 28, 2,  2,  2,  2,  2,  2,
-    2,  20, 20, 20, 20, 20, 20, 4,  4,  4,  4,  4,  4,  4,  4,  4,
-    4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  4,
-    2,  20, 20, 20, 20, 20, 20, 4,  4,  4,  4,  4,  4,  4,  4,  4,
-    4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  2,  2,  2,  2,  0
-};
-
-static bool IsSpace(int c) {
-	return c < 128 && (character_classification[c] & 1);
-}
-
-static bool IsOperator(int c) {
-	return c < 128 && (character_classification[c] & 2);
-}
-
-static bool IsIdentifier(int c) {
-	return c < 128 && (character_classification[c] & 4);
-}
-
-static bool IsDigit(int c) {
-	return c < 128 && (character_classification[c] & 8);
-}
-
-static bool IsHexDigit(int c) {
-	return c < 128 && (character_classification[c] & 16);
-}
-
-static bool IsBinDigit(int c) {
-	return c < 128 && (character_classification[c] & 32);
-}
-
-static int LowerCase(int c)
-{
-	if (c >= 'A' && c <= 'Z')
-		return 'a' + c - 'A';
-	return c;
-}
-
-static void ColouriseBasicDoc(unsigned int startPos, int length, int initStyle,
-                           WordList *keywordlists[], Accessor &styler, char comment_char) {
-	bool wasfirst = true, isfirst = true; // true if first token in a line
-	styler.StartAt(startPos);
-
-	StyleContext sc(startPos, length, initStyle, styler);
-
-	// Can't use sc.More() here else we miss the last character
-	for (; ; sc.Forward()) {
-		if (sc.state == SCE_B_IDENTIFIER) {
-			if (!IsIdentifier(sc.ch)) {
-				// Labels
-				if (wasfirst && sc.Match(':')) {
-					sc.ChangeState(SCE_B_LABEL);
-					sc.ForwardSetState(SCE_B_DEFAULT);
-				} else {
-					char s[100];
-					int kstates[4] = {
-						SCE_B_KEYWORD,
-						SCE_B_KEYWORD2,
-						SCE_B_KEYWORD3,
-						SCE_B_KEYWORD4,
-					};
-					sc.GetCurrentLowered(s, sizeof(s));
-					for (int i = 0; i < 4; i++) {
-						if (keywordlists[i]->InList(s)) {
-							sc.ChangeState(kstates[i]);
-						}
-					}
-					// Types, must set them as operator else they will be
-					// matched as number/constant
-					if (sc.Match('.') || sc.Match('$') || sc.Match('%') ||
-						sc.Match('#')) {
-						sc.SetState(SCE_B_OPERATOR);
-					} else {
-						sc.SetState(SCE_B_DEFAULT);
-					}
-				}
-			}
-		} else if (sc.state == SCE_B_OPERATOR) {
-			if (!IsOperator(sc.ch) || sc.Match('#'))
-				sc.SetState(SCE_B_DEFAULT);
-		} else if (sc.state == SCE_B_LABEL) {
-			if (!IsIdentifier(sc.ch))
-				sc.SetState(SCE_B_DEFAULT);
-		} else if (sc.state == SCE_B_CONSTANT) {
-			if (!IsIdentifier(sc.ch))
-				sc.SetState(SCE_B_DEFAULT);
-		} else if (sc.state == SCE_B_NUMBER) {
-			if (!IsDigit(sc.ch))
-				sc.SetState(SCE_B_DEFAULT);
-		} else if (sc.state == SCE_B_HEXNUMBER) {
-			if (!IsHexDigit(sc.ch))
-				sc.SetState(SCE_B_DEFAULT);
-		} else if (sc.state == SCE_B_BINNUMBER) {
-			if (!IsBinDigit(sc.ch))
-				sc.SetState(SCE_B_DEFAULT);
-		} else if (sc.state == SCE_B_STRING) {
-			if (sc.ch == '"') {
-				sc.ForwardSetState(SCE_B_DEFAULT);
-			}
-			if (sc.atLineEnd) {
-				sc.ChangeState(SCE_B_ERROR);
-				sc.SetState(SCE_B_DEFAULT);
-			}
-		} else if (sc.state == SCE_B_COMMENT || sc.state == SCE_B_PREPROCESSOR) {
-			if (sc.atLineEnd) {
-				sc.SetState(SCE_B_DEFAULT);
-			}
-		}
-
-		if (sc.atLineStart)
-			isfirst = true;
-
-		if (sc.state == SCE_B_DEFAULT || sc.state == SCE_B_ERROR) {
-			if (isfirst && sc.Match('.')) {
-				sc.SetState(SCE_B_LABEL);
-			} else if (isfirst && sc.Match('#')) {
-				wasfirst = isfirst;
-				sc.SetState(SCE_B_IDENTIFIER);
-			} else if (sc.Match(comment_char)) {
-				// Hack to make deprecated QBASIC '$Include show
-				// up in freebasic with SCE_B_PREPROCESSOR.
-				if (comment_char == '\'' && sc.Match(comment_char, '$'))
-					sc.SetState(SCE_B_PREPROCESSOR);
-				else
-					sc.SetState(SCE_B_COMMENT);
-			} else if (sc.Match('"')) {
-				sc.SetState(SCE_B_STRING);
-			} else if (IsDigit(sc.ch)) {
-				sc.SetState(SCE_B_NUMBER);
-			} else if (sc.Match('$')) {
-				sc.SetState(SCE_B_HEXNUMBER);
-			} else if (sc.Match('%')) {
-				sc.SetState(SCE_B_BINNUMBER);
-			} else if (sc.Match('#')) {
-				sc.SetState(SCE_B_CONSTANT);
-			} else if (IsOperator(sc.ch)) {
-				sc.SetState(SCE_B_OPERATOR);
-			} else if (IsIdentifier(sc.ch)) {
-				wasfirst = isfirst;
-				sc.SetState(SCE_B_IDENTIFIER);
-			} else if (!IsSpace(sc.ch)) {
-				sc.SetState(SCE_B_ERROR);
-			}
-		}
-
-		if (!IsSpace(sc.ch))
-			isfirst = false;
-
-		if (!sc.More())
-			break;
-	}
-	sc.Complete();
-}
-
-static int CheckBlitzFoldPoint(char const *token, int &level) {
-	if (!strcmp(token, "function") ||
-		!strcmp(token, "type")) {
-		level |= SC_FOLDLEVELHEADERFLAG;
-		return 1;
-	}
-	if (!strcmp(token, "end function") ||
-		!strcmp(token, "end type")) {
-		return -1;
-	}
-	return 0;
-}
-
-static int CheckPureFoldPoint(char const *token, int &level) {
-	if (!strcmp(token, "procedure") ||
-		!strcmp(token, "enumeration") ||
-		!strcmp(token, "interface") ||
-		!strcmp(token, "structure")) {
-		level |= SC_FOLDLEVELHEADERFLAG;
-		return 1;
-	}
-	if (!strcmp(token, "endprocedure") ||
-		!strcmp(token, "endenumeration") ||
-		!strcmp(token, "endinterface") ||
-		!strcmp(token, "endstructure")) {
-		return -1;
-	}
-	return 0;
-}
-
-static int CheckFreeFoldPoint(char const *token, int &level) {
-	if (!strcmp(token, "function") ||
-		!strcmp(token, "sub") ||
-		!strcmp(token, "type")) {
-		level |= SC_FOLDLEVELHEADERFLAG;
-		return 1;
-	}
-	if (!strcmp(token, "end function") ||
-		!strcmp(token, "end sub") ||
-		!strcmp(token, "end type")) {
-		return -1;
-	}
-	return 0;
-}
-
-static void FoldBasicDoc(unsigned int startPos, int length,
-	Accessor &styler, int (*CheckFoldPoint)(char const *, int &)) {
-	int line = styler.GetLine(startPos);
-	int level = styler.LevelAt(line);
-	int go = 0, done = 0;
-	int endPos = startPos + length;
-	char word[256];
-	int wordlen = 0;
-	int i;
-        bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	// Scan for tokens at the start of the line (they may include
-	// whitespace, for tokens like "End Function"
-	for (i = startPos; i < endPos; i++) {
-		int c = styler.SafeGetCharAt(i);
-		if (!done && !go) {
-			if (wordlen) { // are we scanning a token already?
-				word[wordlen] = static_cast<char>(LowerCase(c));
-				if (!IsIdentifier(c)) { // done with token
-					word[wordlen] = '\0';
-					go = CheckFoldPoint(word, level);
-					if (!go) {
-						// Treat any whitespace as single blank, for
-						// things like "End   Function".
-						if (IsSpace(c) && IsIdentifier(word[wordlen - 1])) {
-							word[wordlen] = ' ';
-							if (wordlen < 255)
-								wordlen++;
-						}
-						else // done with this line
-							done = 1;
-					}
-				} else if (wordlen < 255) {
-					wordlen++;
-				}
-			} else { // start scanning at first non-whitespace character
-				if (!IsSpace(c)) {
-					if (IsIdentifier(c)) {
-						word[0] = static_cast<char>(LowerCase(c));
-						wordlen = 1;
-					} else // done with this line
-						done = 1;
-				}
-			}
-		}
-		if (c == '\n') { // line end
-			if (!done && wordlen == 0 && foldCompact) // line was only space
-				level |= SC_FOLDLEVELWHITEFLAG;
-			if (level != styler.LevelAt(line))
-				styler.SetLevel(line, level);
-			level += go;
-			line++;
-			// reset state
-			wordlen = 0;
-			level &= ~SC_FOLDLEVELHEADERFLAG;
-			level &= ~SC_FOLDLEVELWHITEFLAG;
-			go = 0;
-			done = 0;
-		}
-	}
-}
-
-static void ColouriseBlitzBasicDoc(unsigned int startPos, int length, int initStyle,
-                           WordList *keywordlists[], Accessor &styler) {
-	ColouriseBasicDoc(startPos, length, initStyle, keywordlists, styler, ';');
-}
-
-static void ColourisePureBasicDoc(unsigned int startPos, int length, int initStyle,
-                           WordList *keywordlists[], Accessor &styler) {
-	ColouriseBasicDoc(startPos, length, initStyle, keywordlists, styler, ';');
-}
-
-static void ColouriseFreeBasicDoc(unsigned int startPos, int length, int initStyle,
-                           WordList *keywordlists[], Accessor &styler) {
-	ColouriseBasicDoc(startPos, length, initStyle, keywordlists, styler, '\'');
-}
-
-static void FoldBlitzBasicDoc(unsigned int startPos, int length, int,
-	WordList *[], Accessor &styler) {
-	FoldBasicDoc(startPos, length, styler, CheckBlitzFoldPoint);
-}
-
-static void FoldPureBasicDoc(unsigned int startPos, int length, int,
-	WordList *[], Accessor &styler) {
-	FoldBasicDoc(startPos, length, styler, CheckPureFoldPoint);
-}
-
-static void FoldFreeBasicDoc(unsigned int startPos, int length, int,
-	WordList *[], Accessor &styler) {
-	FoldBasicDoc(startPos, length, styler, CheckFreeFoldPoint);
-}
-
-static const char * const blitzbasicWordListDesc[] = {
-	"BlitzBasic Keywords",
-	"user1",
-	"user2",
-	"user3",
-	0
-};
-
-static const char * const purebasicWordListDesc[] = {
-	"PureBasic Keywords",
-	"PureBasic PreProcessor Keywords",
-	"user defined 1",
-	"user defined 2",
-	0
-};
-
-static const char * const freebasicWordListDesc[] = {
-	"FreeBasic Keywords",
-	"FreeBasic PreProcessor Keywords",
-	"user defined 1",
-	"user defined 2",
-	0
-};
-
-LexerModule lmBlitzBasic(SCLEX_BLITZBASIC, ColouriseBlitzBasicDoc, "blitzbasic",
-	FoldBlitzBasicDoc, blitzbasicWordListDesc);
-
-LexerModule lmPureBasic(SCLEX_PUREBASIC, ColourisePureBasicDoc, "purebasic",
-	FoldPureBasicDoc, purebasicWordListDesc);
-
-LexerModule lmFreeBasic(SCLEX_FREEBASIC, ColouriseFreeBasicDoc, "freebasic",
-	FoldFreeBasicDoc, freebasicWordListDesc);
-
diff --git a/Pythonwin/Scintilla/src/LexD.cxx b/Pythonwin/Scintilla/src/LexD.cxx
deleted file mode 100644
index 95be129d5..000000000
--- a/Pythonwin/Scintilla/src/LexD.cxx
+++ /dev/null
@@ -1,358 +0,0 @@
-/** @file LexD.cxx
- ** Lexer for D.
- **
- ** Copyright (c) 2006 by Waldemar Augustyn <waldemar@wdmsys.com>
- **/
-// Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-/*/ Nested comments require keeping the value of the nesting level for every
-    position in the document.  But since scintilla always styles line by line,
-    we only need to store one value per line. The non-negative number indicates
-    nesting level at the end of the line.
-/*/
-
-// We use custom qualifiers since it is not clear what D allows.
-
-static bool IsWordStart(int ch) {
-	return isascii(ch) && (isalpha(ch) || ch == '_');
-}
-
-static bool IsWord(int ch) {
-	return isascii(ch) && (isalnum(ch) || ch == '_');
-}
-
-static bool IsDoxygen(int ch) {
-	if (isascii(ch) && islower(ch))
-		return true;
-	if (ch == '$' || ch == '@' || ch == '\\' ||
-		ch == '&' || ch == '#' || ch == '<' || ch == '>' ||
-		ch == '{' || ch == '}' || ch == '[' || ch == ']')
-		return true;
-	return false;
-}
-
-
-static void ColouriseDoc(unsigned int startPos, int length, int initStyle, 
-    WordList *keywordlists[], Accessor &styler, bool caseSensitive) {
-
-    WordList &keywords = *keywordlists[0];
-    WordList &keywords2 = *keywordlists[1];
-    WordList &keywords3 = *keywordlists[2];
-    WordList &keywords4 = *keywordlists[3];
-
-    int styleBeforeDCKeyword = SCE_D_DEFAULT;
-
-    StyleContext sc(startPos, length, initStyle, styler);
-
-    int curLine = styler.GetLine(startPos);
-    int curNcLevel = curLine > 0? styler.GetLineState(curLine-1): 0;
-
-    for (; sc.More(); sc.Forward()) {
-
-        if (sc.atLineStart) {
-            if (sc.state == SCE_D_STRING) {
-                // Prevent SCE_D_STRINGEOL from leaking back to previous line which
-                // ends with a line continuation by locking in the state upto this position.
-                sc.SetState(SCE_D_STRING);
-            }
-            curLine = styler.GetLine(sc.currentPos);
-            styler.SetLineState(curLine, curNcLevel);
-        }
-
-        // Handle line continuation generically.
-        if (sc.ch == '\\') {
-            if (sc.chNext == '\n' || sc.chNext == '\r') {
-                sc.Forward();
-                if (sc.ch == '\r' && sc.chNext == '\n') {
-                    sc.Forward();
-                }
-                continue;
-            }
-        }
-
-        // Determine if the current state should terminate.
-        switch (sc.state) {
-            case SCE_D_OPERATOR:
-                sc.SetState(SCE_D_DEFAULT);
-                break;
-            case SCE_D_NUMBER:
-                // We accept almost anything because of hex. and number suffixes
-                if (!IsWord(sc.ch) && sc.ch != '.') {
-                    sc.SetState(SCE_D_DEFAULT);
-                }
-                break;
-            case SCE_D_IDENTIFIER:
-                if (!IsWord(sc.ch)) {
-                    char s[1000];
-                    if (caseSensitive) {
-                        sc.GetCurrent(s, sizeof(s));
-                    } else {
-                        sc.GetCurrentLowered(s, sizeof(s));
-                    }
-                    if (keywords.InList(s)) {
-                        sc.ChangeState(SCE_D_WORD);
-                    } else if (keywords2.InList(s)) {
-                        sc.ChangeState(SCE_D_WORD2);
-                    } else if (keywords4.InList(s)) {
-                        sc.ChangeState(SCE_D_TYPEDEF);
-                    }
-                    sc.SetState(SCE_D_DEFAULT);
-                }
-                break;
-            case SCE_D_COMMENT:
-                if (sc.Match('*', '/')) {
-                    sc.Forward();
-                    sc.ForwardSetState(SCE_D_DEFAULT);
-                }
-                break;
-            case SCE_D_COMMENTDOC:
-                if (sc.Match('*', '/')) {
-                    sc.Forward();
-                    sc.ForwardSetState(SCE_D_DEFAULT);
-                } else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support
-                    // Verify that we have the conditions to mark a comment-doc-keyword
-                    if ((IsASpace(sc.chPrev) || sc.chPrev == '*') && (!IsASpace(sc.chNext))) {
-                        styleBeforeDCKeyword = SCE_D_COMMENTDOC;
-                        sc.SetState(SCE_D_COMMENTDOCKEYWORD);
-                    }
-                }
-                break;
-            case SCE_D_COMMENTLINE:
-                if (sc.atLineStart) {
-                    sc.SetState(SCE_D_DEFAULT);
-                }
-                break;
-            case SCE_D_COMMENTLINEDOC:
-                if (sc.atLineStart) {
-                    sc.SetState(SCE_D_DEFAULT);
-                } else if (sc.ch == '@' || sc.ch == '\\') { // JavaDoc and Doxygen support
-                    // Verify that we have the conditions to mark a comment-doc-keyword
-                    if ((IsASpace(sc.chPrev) || sc.chPrev == '/' || sc.chPrev == '!') && (!IsASpace(sc.chNext))) {
-                        styleBeforeDCKeyword = SCE_D_COMMENTLINEDOC;
-                        sc.SetState(SCE_D_COMMENTDOCKEYWORD);
-                    }
-                }
-                break;
-            case SCE_D_COMMENTDOCKEYWORD:
-                if ((styleBeforeDCKeyword == SCE_D_COMMENTDOC) && sc.Match('*', '/')) {
-                    sc.ChangeState(SCE_D_COMMENTDOCKEYWORDERROR);
-                    sc.Forward();
-                    sc.ForwardSetState(SCE_D_DEFAULT);
-                } else if (!IsDoxygen(sc.ch)) {
-                    char s[100];
-                    if (caseSensitive) {
-                        sc.GetCurrent(s, sizeof(s));
-                    } else {
-                        sc.GetCurrentLowered(s, sizeof(s));
-                    }
-                    if (!IsASpace(sc.ch) || !keywords3.InList(s + 1)) {
-                        sc.ChangeState(SCE_D_COMMENTDOCKEYWORDERROR);
-                    }
-                    sc.SetState(styleBeforeDCKeyword);
-                }
-                break;
-            case SCE_D_COMMENTNESTED:
-                if (sc.Match('+', '/')) {
-                    if (curNcLevel > 0)
-                        curNcLevel -= 1;
-                    curLine = styler.GetLine(sc.currentPos);
-                    styler.SetLineState(curLine, curNcLevel);
-                    sc.Forward();
-                    if (curNcLevel == 0) {
-                        sc.ForwardSetState(SCE_D_DEFAULT);
-		    }
-                }
-                else if (sc.Match('/','+')) {
-                    curNcLevel += 1;
-                    curLine = styler.GetLine(sc.currentPos);
-                    styler.SetLineState(curLine, curNcLevel);
-                    sc.Forward();
-                }
-                break;
-            case SCE_D_STRING:
-                if (sc.atLineEnd) {
-                    sc.ChangeState(SCE_D_STRINGEOL);
-                } else if (sc.ch == '\\') {
-                    if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
-                        sc.Forward();
-                    }
-                } else if (sc.ch == '\"') {
-                    sc.ForwardSetState(SCE_D_DEFAULT);
-                }
-                break;
-            case SCE_D_CHARACTER:
-                if (sc.atLineEnd) {
-                    sc.ChangeState(SCE_D_STRINGEOL);
-                } else if (sc.ch == '\\') {
-                    if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
-                        sc.Forward();
-                    }
-                } else if (sc.ch == '\'') {
-                    sc.ForwardSetState(SCE_D_DEFAULT);
-                }
-                break;
-            case SCE_D_STRINGEOL:
-                if (sc.atLineStart) {
-                    sc.SetState(SCE_D_DEFAULT);
-                }
-                break;
-        }
-
-        // Determine if a new state should be entered.
-        if (sc.state == SCE_D_DEFAULT) {
-            if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
-                    sc.SetState(SCE_D_NUMBER);
-            } else if (IsWordStart(sc.ch)) {
-                    sc.SetState(SCE_D_IDENTIFIER);
-            } else if (sc.Match('/','+')) {
-                curNcLevel += 1;
-		curLine = styler.GetLine(sc.currentPos);
-                styler.SetLineState(curLine, curNcLevel);
-                sc.SetState(SCE_D_COMMENTNESTED);
-                sc.Forward();
-            } else if (sc.Match('/', '*')) {
-                if (sc.Match("/**") || sc.Match("/*!")) {   // Support of Qt/Doxygen doc. style
-                    sc.SetState(SCE_D_COMMENTDOC);
-                } else {
-                    sc.SetState(SCE_D_COMMENT);
-                }
-                sc.Forward();   // Eat the * so it isn't used for the end of the comment
-            } else if (sc.Match('/', '/')) {
-                if ((sc.Match("///") && !sc.Match("////")) || sc.Match("//!"))
-                    // Support of Qt/Doxygen doc. style
-                    sc.SetState(SCE_D_COMMENTLINEDOC);
-                else
-                    sc.SetState(SCE_D_COMMENTLINE);
-            } else if (sc.ch == '\"') {
-                sc.SetState(SCE_D_STRING);
-            } else if (sc.ch == '\'') {
-                sc.SetState(SCE_D_CHARACTER);
-            } else if (isoperator(static_cast<char>(sc.ch))) {
-                sc.SetState(SCE_D_OPERATOR);
-            }
-        }
-    }
-    sc.Complete();
-}
-
-static bool IsStreamCommentStyle(int style) {
-    return style == SCE_D_COMMENT ||
-        style == SCE_D_COMMENTDOC ||
-        style == SCE_D_COMMENTDOCKEYWORD ||
-        style == SCE_D_COMMENTDOCKEYWORDERROR;
-}
-
-// Store both the current line's fold level and the next lines in the
-// level store to make it easy to pick up with each increment
-// and to make it possible to fiddle the current level for "} else {".
-static void FoldDoc(unsigned int startPos, int length, int initStyle, Accessor &styler) {
-    bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
-    bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-    bool foldAtElse = styler.GetPropertyInt("lexer.d.fold.at.else",
-		styler.GetPropertyInt("fold.at.else", 0)) != 0;
-    unsigned int endPos = startPos + length;
-    int visibleChars = 0;
-    int lineCurrent = styler.GetLine(startPos);
-    int levelCurrent = SC_FOLDLEVELBASE;
-    if (lineCurrent > 0)
-        levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
-    int levelMinCurrent = levelCurrent;
-    int levelNext = levelCurrent;
-    char chNext = styler[startPos];
-    int styleNext = styler.StyleAt(startPos);
-    int style = initStyle;
-    for (unsigned int i = startPos; i < endPos; i++) {
-        char ch = chNext;
-        chNext = styler.SafeGetCharAt(i + 1);
-        int stylePrev = style;
-        style = styleNext;
-        styleNext = styler.StyleAt(i + 1);
-        bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
-        if (foldComment && IsStreamCommentStyle(style)) {
-            if (!IsStreamCommentStyle(stylePrev)) {
-                levelNext++;
-            } else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
-                // Comments don't end at end of line and the next character may be unstyled.
-                levelNext--;
-            }
-        }
-        if (style == SCE_D_OPERATOR) {
-            if (ch == '{') {
-                // Measure the minimum before a '{' to allow
-                // folding on "} else {"
-                if (levelMinCurrent > levelNext) {
-                    levelMinCurrent = levelNext;
-                }
-                levelNext++;
-            } else if (ch == '}') {
-                levelNext--;
-            }
-        }
-        if (atEOL) {
-            if (foldComment) {	// Handle nested comments
-		int nc;
-                nc =  styler.GetLineState(lineCurrent);
-                nc -= lineCurrent>0? styler.GetLineState(lineCurrent-1): 0;
-                levelNext += nc;
-	    }
-            int levelUse = levelCurrent;
-            if (foldAtElse) {
-                levelUse = levelMinCurrent;
-            }
-            int lev = levelUse | levelNext << 16;
-            if (visibleChars == 0 && foldCompact)
-                lev |= SC_FOLDLEVELWHITEFLAG;
-            if (levelUse < levelNext)
-                lev |= SC_FOLDLEVELHEADERFLAG;
-            if (lev != styler.LevelAt(lineCurrent)) {
-                styler.SetLevel(lineCurrent, lev);
-            }
-            lineCurrent++;
-            levelCurrent = levelNext;
-            levelMinCurrent = levelCurrent;
-            visibleChars = 0;
-        }
-        if (!IsASpace(ch))
-            visibleChars++;
-    }
-}
-
-static void FoldDDoc(unsigned int startPos, int length, int initStyle,
-    WordList *[], Accessor &styler) {
-        FoldDoc(startPos, length, initStyle, styler);
-}
-
-static const char * const dWordLists[] = {
-            "Primary keywords and identifiers",
-            "Secondary keywords and identifiers",
-            "Documentation comment keywords",
-            "Type definitions and aliases",
-            0,
-        };
-
-static void ColouriseDDoc(unsigned int startPos, int length, 
-    int initStyle, WordList *keywordlists[], Accessor &styler) {
-        ColouriseDoc(startPos, length, initStyle, keywordlists, styler, true);
-}
-
-LexerModule lmD(SCLEX_D, ColouriseDDoc, "d", FoldDDoc, dWordLists);
diff --git a/Pythonwin/Scintilla/src/LexErlang.cxx b/Pythonwin/Scintilla/src/LexErlang.cxx
deleted file mode 100644
index 809dcefe9..000000000
--- a/Pythonwin/Scintilla/src/LexErlang.cxx
+++ /dev/null
@@ -1,526 +0,0 @@
-// Scintilla source code edit control
-/** @file LexErlang.cxx
- ** Lexer for Erlang.
- ** Written by Peter-Henry Mander, based on Matlab lexer by José Fonseca
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-/*
-   TODO:
-   o  _Param should be a new lexical type
-*/
-
-static int is_radix(int radix, int ch) {
-   int digit;
-   if ( 16 < radix || 2 > radix ) {
-      return 0;
-   }
-   if ( isdigit(ch) ) {
-      digit = ch - '0';
-   } else if ( isxdigit(ch) ) {
-      digit = toupper(ch) - 'A' + 10;
-   } else {
-      return 0;
-   }
-   if ( digit < radix ) {
-      return 1;
-   } else {
-      return 0;
-   }
-}
-
-typedef enum {
-   STATE_NULL,
-   ATOM_UNQUOTED,
-   ATOM_QUOTED,
-   ATOM_FUN_NAME,
-   NODE_NAME_UNQUOTED,
-   NODE_NAME_QUOTED,
-   MACRO_START,
-   MACRO_UNQUOTED,
-   MACRO_QUOTED,
-   RECORD_START,
-   RECORD_UNQUOTED,
-   RECORD_QUOTED,
-   NUMERAL_START,
-   NUMERAL_SIGNED,
-   NUMERAL_RADIX_LITERAL,
-   NUMERAL_SPECULATIVE_MANTISSA,
-   NUMERAL_FLOAT_MANTISSA,
-   NUMERAL_FLOAT_EXPONENT,
-   NUMERAL_FLOAT_SIGNED_EXPONENT,
-   PARSE_ERROR
-} atom_parse_state_t;
-
-static void ColouriseErlangDoc(unsigned int startPos, int length, int initStyle,
-                               WordList *keywordlists[], Accessor &styler) {
-
-	WordList &keywords = *keywordlists[0];
-
-	styler.StartAt(startPos);
-
-	StyleContext sc(startPos, length, initStyle, styler);
-   atom_parse_state_t parse_state = STATE_NULL;
-   int radix_digits = 0;
-   int exponent_digits = 0;
-	for (; sc.More(); sc.Forward()) {
-      if ( STATE_NULL != parse_state ) {
-         switch (parse_state) {
-         case STATE_NULL:
-				sc.SetState(SCE_ERLANG_DEFAULT);
-            break;
-         case ATOM_UNQUOTED:
-            if ( '@' == sc.ch ){
-               parse_state = NODE_NAME_UNQUOTED;
-            } else if ( !isalnum(sc.ch) && sc.ch != '_' ) {
-               char s[100];
-               sc.GetCurrent(s, sizeof(s));
-               if (keywords.InList(s)) {
-                  sc.ChangeState(SCE_ERLANG_KEYWORD);
-                  sc.SetState(SCE_ERLANG_DEFAULT);
-                  parse_state = STATE_NULL;
-               } else {
-                  if ( '/' == sc.ch ) {
-                     parse_state = ATOM_FUN_NAME;
-                  } else {
-                     sc.ChangeState(SCE_ERLANG_ATOM);
-                     sc.SetState(SCE_ERLANG_DEFAULT);
-                     parse_state = STATE_NULL;
-                  }
-               }
-            }
-            break;
-         case ATOM_QUOTED:
-            if ( '@' == sc.ch ){
-               parse_state = NODE_NAME_QUOTED;
-            } else if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
-               sc.ChangeState(SCE_ERLANG_ATOM);
-               sc.ForwardSetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            }
-            break;
-         case ATOM_FUN_NAME:
-            if ( !isdigit(sc.ch) ) {
-               sc.ChangeState(SCE_ERLANG_FUNCTION_NAME);
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            }
-            break;
-         case NODE_NAME_QUOTED:
-            if ( '@' == sc.ch ) {
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            } else if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
-               sc.ChangeState(SCE_ERLANG_NODE_NAME);
-               sc.ForwardSetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            }
-            break;
-         case NODE_NAME_UNQUOTED:
-            if ( '@' == sc.ch ) {
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            } else if ( !isalnum(sc.ch) && sc.ch != '_' ) {
-               sc.ChangeState(SCE_ERLANG_NODE_NAME);
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            }
-            break;
-         case RECORD_START:
-            if ( '\'' == sc.ch ) {
-               parse_state = RECORD_QUOTED;
-            } else if (isalpha(sc.ch) && islower(sc.ch)) {
-               parse_state = RECORD_UNQUOTED;
-            } else { // error
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            }
-            break;
-         case RECORD_QUOTED:
-            if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
-               sc.ChangeState(SCE_ERLANG_RECORD);
-               sc.ForwardSetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            }
-            break;
-         case RECORD_UNQUOTED:
-            if ( !isalpha(sc.ch) && '_' != sc.ch ) {
-               sc.ChangeState(SCE_ERLANG_RECORD);
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            }
-            break;
-         case MACRO_START:
-            if ( '\'' == sc.ch ) {
-               parse_state = MACRO_QUOTED;
-            } else if (isalpha(sc.ch)) {
-               parse_state = MACRO_UNQUOTED;
-            } else { // error
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            }
-            break;
-         case MACRO_UNQUOTED:
-            if ( !isalpha(sc.ch) && '_' != sc.ch ) {
-               sc.ChangeState(SCE_ERLANG_MACRO);
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            }
-            break;
-         case MACRO_QUOTED:
-            if ( '\'' == sc.ch && '\\' != sc.chPrev ) {
-               sc.ChangeState(SCE_ERLANG_MACRO);
-               sc.ForwardSetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            }
-            break;
-         case NUMERAL_START:
-            if ( isdigit(sc.ch) ) {
-               radix_digits *= 10;
-               radix_digits += sc.ch - '0'; // Assuming ASCII here!
-            } else if ( '#' == sc.ch ) {
-               if ( 2 > radix_digits || 16 < radix_digits) {
-                  sc.SetState(SCE_ERLANG_DEFAULT);
-                  parse_state = STATE_NULL;
-               } else {
-                  parse_state = NUMERAL_RADIX_LITERAL;
-               }
-            } else if ( '.' == sc.ch && isdigit(sc.chNext)) {
-               radix_digits = 0;
-               parse_state = NUMERAL_FLOAT_MANTISSA;
-            } else if ( 'e' == sc.ch || 'E' == sc.ch ) {
-               exponent_digits = 0;
-               parse_state = NUMERAL_FLOAT_EXPONENT;
-            } else {
-               radix_digits = 0;
-               sc.ChangeState(SCE_ERLANG_NUMBER);
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            }
-            break;
-         case NUMERAL_RADIX_LITERAL:
-            if ( !is_radix(radix_digits,sc.ch) ) {
-               radix_digits = 0;
-               if ( !isalnum(sc.ch) ) {
-                  sc.ChangeState(SCE_ERLANG_NUMBER);
-               }
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            }
-            break;
-         case NUMERAL_FLOAT_MANTISSA:
-            if ( 'e' == sc.ch || 'E' == sc.ch ) {
-               exponent_digits = 0;
-               parse_state = NUMERAL_FLOAT_EXPONENT;
-            } else if ( !isdigit(sc.ch) ) {
-               sc.ChangeState(SCE_ERLANG_NUMBER);
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            }
-            break;
-         case NUMERAL_FLOAT_EXPONENT:
-            if ( '-' == sc.ch || '+' == sc.ch ) {
-               parse_state = NUMERAL_FLOAT_SIGNED_EXPONENT;
-            } else if ( !isdigit(sc.ch) ) {
-               if ( 0 < exponent_digits ) {
-                  sc.ChangeState(SCE_ERLANG_NUMBER);
-               }
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            } else {
-               ++exponent_digits;
-            }
-            break;
-         case NUMERAL_FLOAT_SIGNED_EXPONENT:
-            if ( !isdigit(sc.ch) ) {
-               if ( 0 < exponent_digits ) {
-                  sc.ChangeState(SCE_ERLANG_NUMBER);
-               }
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            } else {
-               ++exponent_digits;
-            }
-            break;
-         case NUMERAL_SIGNED:
-            if ( !isdigit(sc.ch) ) {
-               sc.ChangeState(SCE_ERLANG_NUMBER);
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            } else if ( '.' == sc.ch ) {
-               parse_state = NUMERAL_FLOAT_MANTISSA;
-            }
-            break;
-         case NUMERAL_SPECULATIVE_MANTISSA:
-            if ( !isdigit(sc.ch) ) {
-               sc.ChangeState(SCE_ERLANG_OPERATOR);
-               sc.SetState(SCE_ERLANG_DEFAULT);
-               parse_state = STATE_NULL;
-            } else {
-               parse_state = NUMERAL_FLOAT_MANTISSA;
-            }
-            break;
-         case PARSE_ERROR:
-				sc.SetState(SCE_ERLANG_DEFAULT);
-            parse_state = STATE_NULL;
-            break;
-         }
-      } else if (sc.state == SCE_ERLANG_OPERATOR) {
-			if (sc.chPrev == '.') {
-				if (sc.ch == '*' || sc.ch == '/' || sc.ch == '\\' || sc.ch == '^') {
-					sc.ForwardSetState(SCE_ERLANG_DEFAULT);
-				} else if (sc.ch == '\'') {
-					sc.ForwardSetState(SCE_ERLANG_DEFAULT);
-				} else {
-					sc.SetState(SCE_ERLANG_DEFAULT);
-				}
-			} else {
-				sc.SetState(SCE_ERLANG_DEFAULT);
-			}
-		} else if (sc.state == SCE_ERLANG_VARIABLE) {
-			if (!isalnum(sc.ch) && sc.ch != '_') {
-            sc.SetState(SCE_ERLANG_DEFAULT);
-			}
-		} else if (sc.state == SCE_ERLANG_STRING) {
-			if (sc.ch == '\"' && sc.chPrev != '\\') {
-				sc.ForwardSetState(SCE_ERLANG_DEFAULT);
-			}
-		} else if (sc.state == SCE_ERLANG_COMMENT ) {
-			if (sc.atLineEnd) {
-				sc.SetState(SCE_ERLANG_DEFAULT);
-			}
-      } else if (sc.state == SCE_ERLANG_CHARACTER ) {
-         if ( sc.chPrev == '\\' ) {
-            sc.ForwardSetState(SCE_ERLANG_DEFAULT);
-         } else if ( sc.ch != '\\' ) {
-            sc.ForwardSetState(SCE_ERLANG_DEFAULT);
-         }
-      }
-
-		if (sc.state == SCE_ERLANG_DEFAULT) {
-			if (sc.ch == '%') {
-				sc.SetState(SCE_ERLANG_COMMENT);
-			} else if (sc.ch == '\"') {
-            sc.SetState(SCE_ERLANG_STRING);
-         } else if (sc.ch == '#') {
-            parse_state = RECORD_START;
-				sc.SetState(SCE_ERLANG_UNKNOWN);
-         } else if (sc.ch == '?') {
-            parse_state = MACRO_START;
-				sc.SetState(SCE_ERLANG_UNKNOWN);
-         } else if (sc.ch == '$') {
-				sc.SetState(SCE_ERLANG_CHARACTER);
-         } else if (sc.ch == '\'') {
-            parse_state = ATOM_QUOTED;
-				sc.SetState(SCE_ERLANG_UNKNOWN);
-			} else if ( isdigit(sc.ch) ) {
-            parse_state = NUMERAL_START;
-            radix_digits = sc.ch - '0';
-				sc.SetState(SCE_ERLANG_UNKNOWN);
-         } else if ( '.' == sc.ch ) {
-            parse_state = NUMERAL_SPECULATIVE_MANTISSA;
-				sc.SetState(SCE_ERLANG_UNKNOWN);
-			} else if (isalpha(sc.ch) && isupper(sc.ch)) {
-				sc.SetState(SCE_ERLANG_VARIABLE);
-			} else if (isalpha(sc.ch)) {
-            parse_state = ATOM_UNQUOTED;
-				sc.SetState(SCE_ERLANG_UNKNOWN);
-			} else if (isoperator(static_cast<char>(sc.ch)) || sc.ch == '\\') {
-				sc.SetState(SCE_ERLANG_OPERATOR);
-			}
-		}
-	}
-	sc.Complete();
-}
-
-static int ClassifyFoldPointErlang(
-   Accessor &styler,
-   int styleNext,
-   int keyword_start
-) {
-	int lev = 0;
-   if ( styler.Match(keyword_start,"case")
-      || (
-            styler.Match(keyword_start,"fun")
-         && SCE_ERLANG_FUNCTION_NAME != styleNext)
-      || styler.Match(keyword_start,"if")
-      || styler.Match(keyword_start,"query")
-      || styler.Match(keyword_start,"receive")
-   ) {
-      ++lev;
-   } else if ( styler.Match(keyword_start,"end") ) {
-      --lev;
-   }
-	return lev;
-}
-
-
-static void FoldErlangDoc(
-   unsigned int startPos, int length, int initStyle,
-   WordList** /*keywordlists*/, Accessor &styler
-) {
-	unsigned int endPos = startPos + length;
-	//~ int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
-	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
-	int levelCurrent = levelPrev;
-	char chNext = styler.SafeGetCharAt(startPos);
-	int styleNext = styler.StyleAt(startPos);
-	int style = initStyle;
-	int keyword_start = 0;
-
-   bool fold_keywords = true;
-   bool fold_comments = true;
-   bool fold_braces = true;
-   bool fold_function_clauses = false;
-   bool fold_clauses = false;
-
-   //int clause_level = 0;
-
-	for (unsigned int i = startPos; i < endPos; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-		int stylePrev = style;
-		style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
-		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
-
-      if ( (stylePrev != SCE_ERLANG_KEYWORD) && (style == SCE_ERLANG_KEYWORD) ) {
-         keyword_start = i;
-      }
-      if ( fold_keywords ) {
-         if ( (stylePrev == SCE_ERLANG_KEYWORD)
-            && (style != SCE_ERLANG_KEYWORD)
-            && (style != SCE_ERLANG_ATOM)
-         ) {
-            levelCurrent += ClassifyFoldPointErlang(styler,styleNext,keyword_start);
-         }
-      }
-
-      if ( fold_comments ) {
-         if (style == SCE_ERLANG_COMMENT) {
-            if ((ch == '%') && (chNext == '{')) {
-               levelCurrent++;
-            } else if ((ch == '%') && (chNext == '}')) {
-               levelCurrent--;
-            }
-         }
-      }
-
-      if ( fold_function_clauses ) {
-         if ( (SC_FOLDLEVELBASE == levelCurrent) /*&& (style == SCE_ERLANG_OPERATOR)*/ ) {
-            if ( (ch == '-') && (chNext == '>')) {
-               //~ fprintf(stderr,"levelCurrent=%d\n", levelCurrent);
-               //++clause_level;
-               //~ if ( 0 < clause_level )
-                  ++levelCurrent;
-            }
-         }
-         //~ if (  (stylePrev != SCE_ERLANG_RECORD)
-            //~ && (style != SCE_ERLANG_NUMBER)
-            //~ && (style != SCE_ERLANG_STRING)
-            //~ && (style != SCE_ERLANG_COMMENT)
-         //~ ) {
-            if ( (SC_FOLDLEVELBASE+1 == levelCurrent) && (ch == '.') ) {
-               //--clause_level;
-               //~ if ( 0 == clause_level )
-                  --levelCurrent;
-            }
-         //~ }
-      }
-
-      if ( fold_clauses ) {
-         if ( (0 < levelCurrent) && (style == SCE_ERLANG_OPERATOR) ) {
-            if ((ch == '-') && (chNext == '>')) {
-               levelCurrent++;
-            }
-            if ( (ch == ';') ) {
-               levelCurrent--;
-            }
-         }
-         if ( (stylePrev != SCE_ERLANG_RECORD)
-            && (style != SCE_ERLANG_NUMBER)
-            && (style != SCE_ERLANG_STRING)
-            && (style != SCE_ERLANG_COMMENT)
-         ) {
-            if ( (ch == '.') ) {
-               levelCurrent--;
-            }
-         }
-         if (  (stylePrev == SCE_ERLANG_KEYWORD)
-            && (style != SCE_ERLANG_KEYWORD)
-            && (style != SCE_ERLANG_ATOM)
-            && (
-               styler.Match(keyword_start,"end") // 'end' counted twice if fold_keywords too
-               || styler.Match(keyword_start,"after") )
-         ) {
-            levelCurrent--;
-         }
-      }
-
-      if ( fold_braces ) {
-         if (style == SCE_ERLANG_OPERATOR) {
-            if ( (ch == '{') || (ch == '(') || (ch == '[') ) {
-               levelCurrent++;
-            } else if ( (ch == '}') || (ch == ')') || (ch == ']') ) {
-               levelCurrent--;
-            }
-         }
-      }
-
-		if (atEOL) {
-			int lev = levelPrev;
-			//~ if (visibleChars == 0 && foldCompact)
-				//~ lev |= SC_FOLDLEVELWHITEFLAG;
-			//~ if ((levelCurrent > levelPrev) && (visibleChars > 0))
-			if ((levelCurrent > levelPrev)) {
-				lev |= SC_FOLDLEVELHEADERFLAG;
-         }
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
-			lineCurrent++;
-			levelPrev = levelCurrent;
-			//~ visibleChars = 0;
-		}
-		//~ if (!isspacechar(ch))
-			//~ visibleChars++;
-
-	}
-	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
-	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
-	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
-}
-
-static const char * const erlangWordListDesc[] = {
-	"Keywords",
-	0
-};
-
-LexerModule lmErlang(
-   SCLEX_ERLANG,
-   ColouriseErlangDoc,
-   "erlang",
-   FoldErlangDoc,
-   erlangWordListDesc);
-
diff --git a/Pythonwin/Scintilla/src/LexFlagship.cxx b/Pythonwin/Scintilla/src/LexFlagship.cxx
deleted file mode 100644
index baf2941a8..000000000
--- a/Pythonwin/Scintilla/src/LexFlagship.cxx
+++ /dev/null
@@ -1,230 +0,0 @@
-// Scintilla source code edit control
-/** @file LexFlagShip.cxx
- ** Lexer for FlagShip 
- ** (Syntactically compatible to other XBase dialects, like dBase, Clipper, Fox etc.)
- **/
-// Copyright 2005 by Randy Butler
-// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-static bool IsFlagShipComment(Accessor &styler, int pos, int len) {
-	return len>0 && styler[pos]=='\'';
-}
-
-static inline bool IsTypeCharacter(int ch) {
-	return ch == '%' || ch == '&' || ch == '@' || ch == '!' || ch == '#' || ch == '$';
-}
-
-// Extended to accept accented characters
-static inline bool IsAWordChar(int ch) {
-	return ch >= 0x80 ||
-	       (isalnum(ch) || ch == '.' || ch == '_');
-}
-
-static inline bool IsAWordStart(int ch) {
-	return ch >= 0x80 ||
-	       (isalnum(ch) || ch == '_');
-}
-
-static inline bool IsADateCharacter(const int ch) {
-	return (ch < 0x80) &&
-		(isalnum(ch) || ch == '|' || ch == '-' || ch == '/' || ch == ':' || ch == ' ' || ch == '\t');
-}
-
-
-static void ColouriseFlagShipDoc(unsigned int startPos, int length, int initStyle,
-                           WordList *keywordlists[], Accessor &styler) {
-
-	//bool FSScriptSyntax = true;
-	WordList &keywords = *keywordlists[0];
-	WordList &keywords2 = *keywordlists[1];
-	WordList &keywords3 = *keywordlists[2];
-	WordList &keywords4 = *keywordlists[3];
-
-	styler.StartAt(startPos);
-
-	int visibleChars = 0;
-
-	StyleContext sc(startPos, length, initStyle, styler);
-
-	for (; sc.More(); sc.Forward()) {
-
-		if (sc.state == SCE_FS_OPERATOR) {
-			sc.SetState(SCE_FS_DEFAULT);
-		} else if (sc.state == SCE_FS_IDENTIFIER) {
-			if (!IsAWordChar(sc.ch)) {
-				char s[100];
-				sc.GetCurrentLowered(s, sizeof(s));
-				if (keywords.InList(s)) {
-					sc.ChangeState(SCE_FS_KEYWORD);
-				} else if (keywords2.InList(s)) {
-					sc.ChangeState(SCE_FS_KEYWORD2);
-				} else if (keywords3.InList(s)) {
-					sc.ChangeState(SCE_FS_KEYWORD3);
-				} else if (keywords4.InList(s)) {
-					sc.ChangeState(SCE_FS_KEYWORD4);
-				}// Else, it is really an identifier...
-				sc.SetState(SCE_FS_DEFAULT);
-			}
-		} else if (sc.state == SCE_FS_NUMBER) {
-			if (!IsAWordChar(sc.ch)) {
-				sc.SetState(SCE_FS_DEFAULT);
-			}
-		} else if (sc.state == SCE_FS_STRING) {
-			// VB doubles quotes to preserve them, so just end this string
-			// state now as a following quote will start again
-			if (sc.ch == '\"') {
-				if (tolower(sc.chNext) == 'c') {
-					sc.Forward();
-				}
-				sc.ForwardSetState(SCE_FS_DEFAULT);
-			} else if (sc.atLineEnd) {
-				sc.ChangeState(SCE_FS_STRINGEOL);
-				sc.ForwardSetState(SCE_FS_DEFAULT);
-			}
-		} else if (sc.state == SCE_FS_COMMENT) {
-			if (sc.Match('*', '/')) {   // new code
-				sc.Forward();
-				sc.ForwardSetState(SCE_FS_DEFAULT);
-			//if (sc.atLineEnd) {       // old code
-			//	sc.SetState(SCE_FS_DEFAULT);
-			}
-		} else if (sc.state == SCE_FS_COMMENTLINE) {  //new code
-			if (sc.ch == '\r' || sc.ch == '\n') {
-				sc.SetState(SCE_FS_DEFAULT);
-				visibleChars = 0;
-			}
-		} else if (sc.state == SCE_FS_PREPROCESSOR) {
-			if (sc.atLineEnd) {
-				sc.SetState(SCE_FS_DEFAULT);
-			}
-		} else if (sc.state == SCE_FS_DATE) {
-			if (sc.ch == '#' || !IsADateCharacter(sc.chNext)) {
-				sc.ForwardSetState(SCE_FS_DEFAULT);
-			}
-		}
-
-		// Determine if a new state should be entered.
-		if (sc.state == SCE_FS_DEFAULT) {
-			if (sc.Match('/', '*')) {  // New code
-				sc.SetState(SCE_FS_COMMENT);
-				sc.Forward();	// Eat the * so it isn't used for the end of the comment
-			//if (sc.ch == '\'') {  // Old code
-			//	sc.SetState(SCE_FS_COMMENT); // old code
-			} else if (sc.Match('/', '/')) { // New code
-				sc.SetState(SCE_FS_COMMENTLINE);
-			} else if (sc.ch == '\"') {
-				sc.SetState(SCE_FS_STRING);
-			} else if (sc.ch == '#' && visibleChars == 0) {
-				// Preprocessor commands are alone on their line
-				sc.SetState(SCE_FS_PREPROCESSOR);
-			} else if (sc.ch == '#') {
-				int n = 1;
-				int chSeek = ' ';
-				while ((n < 100) && (chSeek == ' ' || chSeek == '\t')) {
-					chSeek = sc.GetRelative(n);
-					n++;
-				}
-				if (IsADigit(chSeek)) {
-					sc.SetState(SCE_FS_DATE);
-				} else {
-					sc.SetState(SCE_FS_OPERATOR);
-				}
-			} else if (sc.ch == '&' && tolower(sc.chNext) == 'h') {
-				sc.SetState(SCE_FS_NUMBER);
-			} else if (sc.ch == '&' && tolower(sc.chNext) == 'o') {
-				sc.SetState(SCE_FS_NUMBER);
-			} else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
-				sc.SetState(SCE_FS_NUMBER);
-			} else if (IsAWordStart(sc.ch) || (sc.ch == '[')) {
-				sc.SetState(SCE_FS_IDENTIFIER);
-			} else if (isoperator(static_cast<char>(sc.ch)) || (sc.ch == '\\')) {
-				sc.SetState(SCE_FS_OPERATOR);
-			}
-		}
-
-		if (sc.atLineEnd) {
-			visibleChars = 0;
-		}
-		if (!IsASpace(sc.ch)) {
-			visibleChars++;
-		}
-	}
-	sc.Complete();
-}
-
-static void FoldFlagShipDoc(unsigned int startPos, int length, int,
-						   WordList *[], Accessor &styler) {
-
-	int endPos = startPos + length;
-
-	// Backtrack to previous line in case need to fix its fold status
-	int lineCurrent = styler.GetLine(startPos);
-	if (startPos > 0) {
-		if (lineCurrent > 0) {
-			lineCurrent--;
-			startPos = styler.LineStart(lineCurrent);
-		}
-	}
-	int spaceFlags = 0;
-	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, IsFlagShipComment);
-	char chNext = styler[startPos];
-	for (int i = startPos; i < endPos; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-
-		if ((ch == '\r' && chNext != '\n') || (ch == '\n') || (i == endPos)) {
-			int lev = indentCurrent;
-			int indentNext = styler.IndentAmount(lineCurrent + 1, &spaceFlags, IsFlagShipComment);
-			if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) {
-				// Only non whitespace lines can be headers
-				if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK)) {
-					lev |= SC_FOLDLEVELHEADERFLAG;
-				} else if (indentNext & SC_FOLDLEVELWHITEFLAG) {
-					// Line after is blank so check the next - maybe should continue further?
-					int spaceFlags2 = 0;
-					int indentNext2 = styler.IndentAmount(lineCurrent + 2, &spaceFlags2, IsFlagShipComment);
-					if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext2 & SC_FOLDLEVELNUMBERMASK)) {
-						lev |= SC_FOLDLEVELHEADERFLAG;
-					}
-				}
-			}
-			indentCurrent = indentNext;
-			styler.SetLevel(lineCurrent, lev);
-			lineCurrent++;
-		}
-	}
-}
-
-
-static const char * const FSWordListDesc[] = {
-	"Keywords",
-	"functions",
-	"user2",
-	"user3",
-	0
-};
-
-LexerModule lmFlagShip(SCLEX_FLAGSHIP, ColouriseFlagShipDoc, "flagship", FoldFlagShipDoc, FSWordListDesc);
-
-
-
diff --git a/Pythonwin/Scintilla/src/LexForth.cxx b/Pythonwin/Scintilla/src/LexForth.cxx
deleted file mode 100644
index f097b0e00..000000000
--- a/Pythonwin/Scintilla/src/LexForth.cxx
+++ /dev/null
@@ -1,352 +0,0 @@
-// Scintilla source code edit control
-/** @file LexCrontab.cxx
- ** Lexer to use with extended crontab files used by a powerful
- ** Windows scheduler/event monitor/automation manager nnCron.
- ** (http://nemtsev.eserv.ru/)
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-bool is_whitespace(int ch){
-    return ch == '\n' || ch == '\r' || ch == '\t' || ch == ' ';
-}
-
-bool is_blank(int ch){
-    return ch == '\t' || ch == ' ';
-}
-//#define FORTH_DEBUG
-#ifdef FORTH_DEBUG
-static FILE *f_debug;
-#define log(x)  fputs(f_debug,x);
-#else
-#define log(x)
-#endif
-
-#define STATE_LOCALE
-#define BL ' '
-
-static Accessor *st;
-static int cur_pos,pos1,pos2,pos0,lengthDoc;
-char *buffer;
-
-char getChar(bool is_bl){
-    char ch=st->SafeGetCharAt(cur_pos);
-    if(is_bl) if(is_whitespace(ch)) ch=BL;
-    return ch;
-}
-
-char getCharBL(){
-    char ch=st->SafeGetCharAt(cur_pos);
-    return ch;
-}
-bool is_eol(char ch){
-    return ch=='\n' || ch=='\r';
-}
-
-int parse(char ch, bool skip_eol){
-// pos1 - start pos of word
-// pos2 - pos after of word
-// pos0 - start pos
-    char c=0;
-    int len;
-    bool is_bl=ch==BL;
-    pos0=pos1=pos2=cur_pos;
-    for(;cur_pos<lengthDoc && (c=getChar(is_bl))==ch; cur_pos++){
-        if(is_eol(c) && !skip_eol){
-            pos2=pos1;
-            return 0;
-        }
-    }
-    pos1=cur_pos;
-    pos2=pos1;
-    if(cur_pos==lengthDoc) return 0;
-    for(len=0;cur_pos<lengthDoc && (c=getChar(is_bl))!=ch; cur_pos++){
-        if(is_eol(c) && !skip_eol) break;
-        pos2++;
-        buffer[len++]=c;
-    }
-    if(c==ch) pos2--;
-    buffer[len]='\0';
-#ifdef FORTH_DEBUG
-    fprintf(f_debug,"parse: %c %s\n",ch,buffer);
-#endif
-    return len;
-}
-
-bool _is_number(char *s,int base){
-    for(;*s;s++){
-        int digit=((int)*s)-(int)'0';
-#ifdef FORTH_DEBUG
-    fprintf(f_debug,"digit: %c %d\n",*s,digit);
-#endif
-        if(digit>9 && base>10) digit-=7;
-        if(digit<0) return false;
-        if(digit>=base) return false;
-    }
-    return true;
-}
-
-bool is_number(char *s){
-    if(strncmp(s,"0x",2)==0) return _is_number(s+2,16);
-    return _is_number(s,10);
-}
-
-static void ColouriseForthDoc(unsigned int startPos, int length, int, WordList *keywordLists[], Accessor &styler)
-{
-    st=&styler;
-    cur_pos=startPos;
-    lengthDoc = startPos + length;
-    buffer = new char[length];
-
-#ifdef FORTH_DEBUG
-    f_debug=fopen("c:\\sci.log","at");
-#endif
-
-    WordList &control = *keywordLists[0];
-    WordList &keyword = *keywordLists[1];
-    WordList &defword = *keywordLists[2];
-    WordList &preword1 = *keywordLists[3];
-    WordList &preword2 = *keywordLists[4];
-    WordList &strings = *keywordLists[5];
-
-    // go through all provided text segment
-    // using the hand-written state machine shown below
-    styler.StartAt(startPos);
-    styler.StartSegment(startPos);
-    while(parse(BL,true)!=0){
-        if(pos0!=pos1){
-            styler.ColourTo(pos0,SCE_FORTH_DEFAULT);
-            styler.ColourTo(pos1-1,SCE_FORTH_DEFAULT);
-        }
-        if(strcmp("\\",buffer)==0){
-            styler.ColourTo(pos1,SCE_FORTH_COMMENT);
-            parse(1,false);
-            styler.ColourTo(pos2,SCE_FORTH_COMMENT);
-        }else if(strcmp("(",buffer)==0){
-            styler.ColourTo(pos1,SCE_FORTH_COMMENT);
-            parse(')',true);
-            if(cur_pos<lengthDoc) cur_pos++;
-            styler.ColourTo(cur_pos,SCE_FORTH_COMMENT);
-        }else if(strcmp("[",buffer)==0){
-            styler.ColourTo(pos1,SCE_FORTH_STRING);
-            parse(']',true);
-            if(cur_pos<lengthDoc) cur_pos++;
-            styler.ColourTo(cur_pos,SCE_FORTH_STRING);
-        }else if(strcmp("{",buffer)==0){
-            styler.ColourTo(pos1,SCE_FORTH_LOCALE);
-            parse('}',false);
-            if(cur_pos<lengthDoc) cur_pos++;
-            styler.ColourTo(cur_pos,SCE_FORTH_LOCALE);
-        }else if(strings.InList(buffer)) {
-            styler.ColourTo(pos1,SCE_FORTH_STRING);
-            parse('"',false);
-            if(cur_pos<lengthDoc) cur_pos++;
-            styler.ColourTo(cur_pos,SCE_FORTH_STRING);
-        }else if(control.InList(buffer)) {
-            styler.ColourTo(pos1,SCE_FORTH_CONTROL);
-            styler.ColourTo(pos2,SCE_FORTH_CONTROL);
-        }else if(keyword.InList(buffer)) {
-            styler.ColourTo(pos1,SCE_FORTH_KEYWORD);
-            styler.ColourTo(pos2,SCE_FORTH_KEYWORD);
-        }else if(defword.InList(buffer)) {
-            styler.ColourTo(pos1,SCE_FORTH_KEYWORD);
-            styler.ColourTo(pos2,SCE_FORTH_KEYWORD);
-            parse(BL,false);
-            styler.ColourTo(pos1-1,SCE_FORTH_DEFAULT);
-            styler.ColourTo(pos1,SCE_FORTH_DEFWORD);
-            styler.ColourTo(pos2,SCE_FORTH_DEFWORD);
-        }else if(preword1.InList(buffer)) {
-            styler.ColourTo(pos1,SCE_FORTH_PREWORD1);
-            parse(BL,false);
-            styler.ColourTo(pos2,SCE_FORTH_PREWORD1);
-        }else if(preword2.InList(buffer)) {
-            styler.ColourTo(pos1,SCE_FORTH_PREWORD2);
-            parse(BL,false);
-            styler.ColourTo(pos2,SCE_FORTH_PREWORD2);
-            parse(BL,false);
-            styler.ColourTo(pos1,SCE_FORTH_STRING);
-            styler.ColourTo(pos2,SCE_FORTH_STRING);
-        }else if(is_number(buffer)){
-            styler.ColourTo(pos1,SCE_FORTH_NUMBER);
-            styler.ColourTo(pos2,SCE_FORTH_NUMBER);
-        }
-    }
-#ifdef FORTH_DEBUG
-    fclose(f_debug);
-#endif
-    delete []buffer;
-    return;
-/*
-                        if(control.InList(buffer)) {
-                            styler.ColourTo(i,SCE_FORTH_CONTROL);
-                        } else if(keyword.InList(buffer)) {
-                            styler.ColourTo(i-1,SCE_FORTH_KEYWORD );
-                        } else if(defword.InList(buffer)) {
-                            styler.ColourTo(i-1,SCE_FORTH_DEFWORD );
-//                            prev_state=SCE_FORTH_DEFWORD
-                        } else if(preword1.InList(buffer)) {
-                            styler.ColourTo(i-1,SCE_FORTH_PREWORD1 );
-//                            state=SCE_FORTH_PREWORD1;
-                        } else if(preword2.InList(buffer)) {
-                            styler.ColourTo(i-1,SCE_FORTH_PREWORD2 );
-                         } else {
-                            styler.ColourTo(i-1,SCE_FORTH_DEFAULT);
-                        }
-*/
-/*
-    chPrev=' ';
-    for (int i = startPos; i < lengthDoc; i++) {
-        char ch = chNext;
-        chNext = styler.SafeGetCharAt(i + 1);
-        if(i!=startPos) chPrev=styler.SafeGetCharAt(i - 1);
-
-        if (styler.IsLeadByte(ch)) {
-            chNext = styler.SafeGetCharAt(i + 2);
-            i++;
-            continue;
-        }
-#ifdef FORTH_DEBUG
-        fprintf(f_debug,"%c %d ",ch,state);
-#endif
-        switch(state) {
-            case SCE_FORTH_DEFAULT:
-                if(is_whitespace(ch)) {
-                    // whitespace is simply ignored here...
-                    styler.ColourTo(i,SCE_FORTH_DEFAULT);
-                    break;
-                } else if( ch == '\\' && is_blank(chNext)) {
-                    // signals the start of an one line comment...
-                    state = SCE_FORTH_COMMENT;
-                    styler.ColourTo(i,SCE_FORTH_COMMENT);
-                } else if( is_whitespace(chPrev) &&  ch == '(' &&  is_whitespace(chNext)) {
-                    // signals the start of a plain comment...
-                    state = SCE_FORTH_COMMENT_ML;
-                    styler.ColourTo(i,SCE_FORTH_COMMENT_ML);
-                } else if( isdigit(ch) ) {
-                    // signals the start of a number
-                    bufferCount = 0;
-                    buffer[bufferCount++] = ch;
-                    state = SCE_FORTH_NUMBER;
-                } else if( !is_whitespace(ch)) {
-                    // signals the start of an identifier
-                    bufferCount = 0;
-                    buffer[bufferCount++] = ch;
-                    state = SCE_FORTH_IDENTIFIER;
-                } else {
-                    // style it the default style..
-                    styler.ColourTo(i,SCE_FORTH_DEFAULT);
-                }
-                break;
-
-            case SCE_FORTH_COMMENT:
-                // if we find a newline here,
-                // we simply go to default state
-                // else continue to work on it...
-                if( ch == '\n' || ch == '\r' ) {
-                    state = SCE_FORTH_DEFAULT;
-                } else {
-                    styler.ColourTo(i,SCE_FORTH_COMMENT);
-                }
-                break;
-
-            case SCE_FORTH_COMMENT_ML:
-                if( ch == ')') {
-                    state = SCE_FORTH_DEFAULT;
-                } else {
-                    styler.ColourTo(i+1,SCE_FORTH_COMMENT_ML);
-                }
-                break;
-
-            case SCE_FORTH_IDENTIFIER:
-                // stay  in CONF_IDENTIFIER state until we find a non-alphanumeric
-                if( !is_whitespace(ch) ) {
-                    buffer[bufferCount++] = ch;
-                } else {
-                    state = SCE_FORTH_DEFAULT;
-                    buffer[bufferCount] = '\0';
-#ifdef FORTH_DEBUG
-        fprintf(f_debug,"\nid %s\n",buffer);
-#endif
-
-                    // check if the buffer contains a keyword,
-                    // and highlight it if it is a keyword...
-//                    switch(prev_state)
-//                    case SCE_FORTH_DEFAULT:
-                        if(control.InList(buffer)) {
-                            styler.ColourTo(i,SCE_FORTH_CONTROL);
-                        } else if(keyword.InList(buffer)) {
-                            styler.ColourTo(i-1,SCE_FORTH_KEYWORD );
-                        } else if(defword.InList(buffer)) {
-                            styler.ColourTo(i-1,SCE_FORTH_DEFWORD );
-//                            prev_state=SCE_FORTH_DEFWORD
-                        } else if(preword1.InList(buffer)) {
-                            styler.ColourTo(i-1,SCE_FORTH_PREWORD1 );
-//                            state=SCE_FORTH_PREWORD1;
-                        } else if(preword2.InList(buffer)) {
-                            styler.ColourTo(i-1,SCE_FORTH_PREWORD2 );
-                         } else {
-                            styler.ColourTo(i-1,SCE_FORTH_DEFAULT);
-                        }
-//                        break;
-//                    case
-
-                    // push back the faulty character
-                    chNext = styler[i--];
-                }
-                break;
-
-            case SCE_FORTH_NUMBER:
-                // stay  in CONF_NUMBER state until we find a non-numeric
-                if( isdigit(ch) ) {
-                    buffer[bufferCount++] = ch;
-                } else {
-                    state = SCE_FORTH_DEFAULT;
-                    buffer[bufferCount] = '\0';
-                    // Colourize here... (normal number)
-                    styler.ColourTo(i-1,SCE_FORTH_NUMBER);
-                    // push back a character
-                    chNext = styler[i--];
-                }
-                break;
-        }
-    }
-#ifdef FORTH_DEBUG
-    fclose(f_debug);
-#endif
-    delete []buffer;
-*/
-}
-
-static void FoldForthDoc(unsigned int, int, int, WordList *[],
-                       Accessor &) {
-}
-
-static const char * const forthWordLists[] = {
-            "control keywords",
-            "keywords",
-            "definition words",
-            "prewords with one argument",
-            "prewords with two arguments",
-            "string definition keywords",
-            0,
-        };
-
-LexerModule lmForth(SCLEX_FORTH, ColouriseForthDoc, "forth",FoldForthDoc,forthWordLists);
diff --git a/Pythonwin/Scintilla/src/LexFortran.cxx b/Pythonwin/Scintilla/src/LexFortran.cxx
deleted file mode 100644
index e66b37ebe..000000000
--- a/Pythonwin/Scintilla/src/LexFortran.cxx
+++ /dev/null
@@ -1,466 +0,0 @@
-// Scintilla source code edit control
-/** @file LexFortran.cxx
- ** Lexer for Fortran.
- ** Writen by Chuan-jian Shen, Last changed Sep. 2003
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-/***************************************/
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-/***************************************/
-#include "Platform.h"
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-/***********************************************/
-static inline bool IsAWordChar(const int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '%');
-}
-/**********************************************/
-static inline bool IsAWordStart(const int ch) {
-	return (ch < 0x80) && (isalnum(ch));
-}
-/***************************************/
-inline bool IsABlank(unsigned int ch) {
-    return (ch == ' ') || (ch == 0x09) || (ch == 0x0b) ;
-}
-/***************************************/
-inline bool IsALineEnd(char ch) {
-    return ((ch == '\n') || (ch == '\r')) ;
-}
-/***************************************/
-unsigned int GetContinuedPos(unsigned int pos, Accessor &styler) {
-	while (!IsALineEnd(styler.SafeGetCharAt(pos++))) continue;
-	if (styler.SafeGetCharAt(pos) == '\n') pos++;
-	while (IsABlank(styler.SafeGetCharAt(pos++))) continue;
-	char chCur = styler.SafeGetCharAt(pos);
-	if (chCur == '&') {
-		while (IsABlank(styler.SafeGetCharAt(++pos))) continue;
-		return pos;
-	} else {
-		return pos;
-	}
-}
-/***************************************/
-static void ColouriseFortranDoc(unsigned int startPos, int length, int initStyle,
-			WordList *keywordlists[], Accessor &styler, bool isFixFormat) {
-	WordList &keywords = *keywordlists[0];
-	WordList &keywords2 = *keywordlists[1];
-	WordList &keywords3 = *keywordlists[2];
-	/***************************************/
-	int posLineStart = 0, numNonBlank = 0, prevState = 0;
-	int endPos = startPos + length;
-	/***************************************/
-	// backtrack to the nearest keyword
-	while ((startPos > 1) && (styler.StyleAt(startPos) != SCE_F_WORD)) {
-		startPos--;
-	}
-	startPos = styler.LineStart(styler.GetLine(startPos));
-	initStyle = styler.StyleAt(startPos - 1);
-	StyleContext sc(startPos, endPos-startPos, initStyle, styler);
-	/***************************************/
-	for (; sc.More(); sc.Forward()) {
-		// remember the start position of the line
-		if (sc.atLineStart) {
-			posLineStart = sc.currentPos;
-			numNonBlank = 0;
-			sc.SetState(SCE_F_DEFAULT);
-		}
-		if (!IsASpaceOrTab(sc.ch)) numNonBlank ++;
-		/***********************************************/
-		// Handle the fix format generically
-		int toLineStart = sc.currentPos - posLineStart;
-		if (isFixFormat && (toLineStart < 6 || toLineStart > 72)) {
-			if (toLineStart == 0 && (tolower(sc.ch) == 'c' || sc.ch == '*') || sc.ch == '!') {
-                if (sc.MatchIgnoreCase("cdec$") || sc.MatchIgnoreCase("*dec$") || sc.MatchIgnoreCase("!dec$") ||
-                    sc.MatchIgnoreCase("cdir$") || sc.MatchIgnoreCase("*dir$") || sc.MatchIgnoreCase("!dir$") ||
-                    sc.MatchIgnoreCase("cms$")  || sc.MatchIgnoreCase("*ms$")  || sc.MatchIgnoreCase("!ms$")  ||
-                    sc.chNext == '$') {
-                    sc.SetState(SCE_F_PREPROCESSOR);
-				} else {
-					sc.SetState(SCE_F_COMMENT);
-				}
-
-				while (!sc.atLineEnd && sc.More()) sc.Forward(); // Until line end
-			} else if (toLineStart > 72) {
-				sc.SetState(SCE_F_COMMENT);
-				while (!sc.atLineEnd && sc.More()) sc.Forward(); // Until line end
-			} else if (toLineStart < 5) {
-				if (IsADigit(sc.ch))
-					sc.SetState(SCE_F_LABEL);
-				else
-					sc.SetState(SCE_F_DEFAULT);
-			} else if (toLineStart == 5) {
-				if (!IsASpace(sc.ch) && sc.ch != '0') {
-					sc.SetState(SCE_F_CONTINUATION);
-					sc.ForwardSetState(prevState);
-				} else
-					sc.SetState(SCE_F_DEFAULT);
-			}
-			continue;
-		}
-		/***************************************/
-		// Handle line continuation generically.
-		if (!isFixFormat && sc.ch == '&') {
-			char chTemp = ' ';
-			int j = 1;
-			while (IsABlank(chTemp) && j<132) {
-				chTemp = static_cast<char>(sc.GetRelative(j));
-				j++;
-			}
-			if (chTemp == '!') {
-				sc.SetState(SCE_F_CONTINUATION);
-				if (sc.chNext == '!') sc.ForwardSetState(SCE_F_COMMENT);
-			} else if (chTemp == '\r' || chTemp == '\n') {
-				int currentState = sc.state;
-				sc.SetState(SCE_F_CONTINUATION);
-				sc.ForwardSetState(SCE_F_DEFAULT);
-				while (IsASpace(sc.ch) && sc.More()) sc.Forward();
-				if (sc.ch == '&') {
-					sc.SetState(SCE_F_CONTINUATION);
-					sc.Forward();
-				}
-				sc.SetState(currentState);
-			}
-		}
-		/***************************************/
-		// Determine if the current state should terminate.
-		if (sc.state == SCE_F_OPERATOR) {
-			sc.SetState(SCE_F_DEFAULT);
-		} else if (sc.state == SCE_F_NUMBER) {
-			if (!(IsAWordChar(sc.ch) || sc.ch=='\'' || sc.ch=='\"' || sc.ch=='.')) {
-				sc.SetState(SCE_F_DEFAULT);
-			}
-		} else if (sc.state == SCE_F_IDENTIFIER) {
-			if (!IsAWordChar(sc.ch) || (sc.ch == '%')) {
-				char s[100];
-				sc.GetCurrentLowered(s, sizeof(s));
-				if (keywords.InList(s)) {
-					sc.ChangeState(SCE_F_WORD);
-				} else if (keywords2.InList(s)) {
-					sc.ChangeState(SCE_F_WORD2);
-				} else if (keywords3.InList(s)) {
-					sc.ChangeState(SCE_F_WORD3);
-				}
-				sc.SetState(SCE_F_DEFAULT);
-			}
-		} else if (sc.state == SCE_F_COMMENT || sc.state == SCE_F_PREPROCESSOR) {
-			if (sc.ch == '\r' || sc.ch == '\n') {
-				sc.SetState(SCE_F_DEFAULT);
-			}
-		} else if (sc.state == SCE_F_STRING1) {
-			prevState = sc.state;
-			if (sc.ch == '\'') {
-				if (sc.chNext == '\'') {
-					sc.Forward();
-				} else {
-					sc.ForwardSetState(SCE_F_DEFAULT);
-					prevState = SCE_F_DEFAULT;
-				}
-			} else if (sc.atLineEnd) {
-				sc.ChangeState(SCE_F_STRINGEOL);
-				sc.ForwardSetState(SCE_F_DEFAULT);
-			}
-		} else if (sc.state == SCE_F_STRING2) {
-			prevState = sc.state;
-			if (sc.atLineEnd) {
-				sc.ChangeState(SCE_F_STRINGEOL);
-				sc.ForwardSetState(SCE_F_DEFAULT);
-			} else if (sc.ch == '\"') {
-				if (sc.chNext == '\"') {
-					sc.Forward();
-				} else {
-					sc.ForwardSetState(SCE_F_DEFAULT);
-					prevState = SCE_F_DEFAULT;
-				}
-			}
-		} else if (sc.state == SCE_F_OPERATOR2) {
-			if (sc.ch == '.') {
-				sc.ForwardSetState(SCE_F_DEFAULT);
-			}
-		} else if (sc.state == SCE_F_CONTINUATION) {
-			sc.SetState(SCE_F_DEFAULT);
-		} else if (sc.state == SCE_F_LABEL) {
-			if (!IsADigit(sc.ch)) {
-				sc.SetState(SCE_F_DEFAULT);
-			} else {
-				if (isFixFormat && sc.currentPos-posLineStart > 4)
-					sc.SetState(SCE_F_DEFAULT);
-				else if (numNonBlank > 5)
-					sc.SetState(SCE_F_DEFAULT);
-			}
-		}
-		/***************************************/
-		// Determine if a new state should be entered.
-		if (sc.state == SCE_F_DEFAULT) {
-			if (sc.ch == '!') {
-                if (sc.MatchIgnoreCase("!dec$") || sc.MatchIgnoreCase("!dir$") ||
-                    sc.MatchIgnoreCase("!ms$") || sc.chNext == '$') {
-					sc.SetState(SCE_F_PREPROCESSOR);
-				} else {
-					sc.SetState(SCE_F_COMMENT);
-				}
-			} else if ((!isFixFormat) && IsADigit(sc.ch) && numNonBlank == 1) {
-				sc.SetState(SCE_F_LABEL);
-			} else if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
-				sc.SetState(SCE_F_NUMBER);
-			} else if ((tolower(sc.ch) == 'b' || tolower(sc.ch) == 'o' ||
-					    tolower(sc.ch) == 'z') && (sc.chNext == '\"' || sc.chNext == '\'')) {
-				sc.SetState(SCE_F_NUMBER);
-				sc.Forward();
-			} else if (sc.ch == '.' && isalpha(sc.chNext)) {
-				sc.SetState(SCE_F_OPERATOR2);
-			} else if (IsAWordStart(sc.ch)) {
-				sc.SetState(SCE_F_IDENTIFIER);
-			} else if (sc.ch == '\"') {
-				sc.SetState(SCE_F_STRING2);
-			} else if (sc.ch == '\'') {
-				sc.SetState(SCE_F_STRING1);
-			} else if (isoperator(static_cast<char>(sc.ch))) {
-				sc.SetState(SCE_F_OPERATOR);
-			}
-		}
-	}
-	sc.Complete();
-}
-/***************************************/
-// To determine the folding level depending on keywords
-static int classifyFoldPointFortran(const char* s, const char* prevWord, const char chNextNonBlank) {
-	int lev = 0;
-	if ((strcmp(prevWord, "else") == 0 && strcmp(s, "if") == 0) || strcmp(s, "elseif") == 0)
-		return -1;
-	if (strcmp(s, "associate") == 0 || strcmp(s, "block") == 0
-	    || strcmp(s, "blockdata") == 0 || strcmp(s, "select") == 0
-	    || strcmp(s, "do") == 0 || strcmp(s, "enum") ==0
-	    || strcmp(s, "function") == 0 || strcmp(s, "interface") == 0
-		|| strcmp(s, "module") == 0 || strcmp(s, "program") == 0
-		|| strcmp(s, "subroutine") == 0 || strcmp(s, "then") == 0
-		|| (strcmp(s, "type") == 0 && chNextNonBlank != '(') ){
-			if (strcmp(prevWord, "end") == 0)
-				lev = 0;
-			else
-				lev = 1;
-	} else if (strcmp(s, "end") == 0 && chNextNonBlank != '='
-		|| strcmp(s, "endassociate") == 0 || strcmp(s, "endblock") == 0
-		|| strcmp(s, "endblockdata") == 0 || strcmp(s, "endselect") == 0
-		|| strcmp(s, "enddo") == 0 || strcmp(s, "endenum") ==0
-		|| strcmp(s, "endif") == 0 || strcmp(s, "endforall") == 0
-		|| strcmp(s, "endfunction") == 0 || strcmp(s, "endinterface") == 0
-		|| strcmp(s, "endmodule") == 0 || strcmp(s, "endprogram") == 0
-		|| strcmp(s, "endsubroutine") == 0 || strcmp(s, "endtype") == 0
-		|| strcmp(s, "endwhere") == 0
-		|| strcmp(s, "procedure") == 0 ) { // Take care of the module procedure statement
-			lev = -1;
-	} else if (strcmp(prevWord, "end") == 0 && strcmp(s, "if") == 0){ // end if
-			lev = 0;
-	}
-	return lev;
-}
-// Folding the code
-static void FoldFortranDoc(unsigned int startPos, int length, int initStyle,
-						   Accessor &styler, bool isFixFormat) {
-	//
-	// bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
-	// Do not know how to fold the comment at the moment.
-	//
-	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	unsigned int endPos = startPos + length;
-	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
-	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
-	int levelCurrent = levelPrev;
-	char chNext = styler[startPos];
-	char chNextNonBlank;
-	int styleNext = styler.StyleAt(startPos);
-	int style = initStyle;
-	/***************************************/
-	int lastStart = 0;
-	char prevWord[32] = "";
-	char Label[6] = "";
-	// Variables for do label folding.
-	static int doLabels[100];
-	static int posLabel=-1;
-	/***************************************/
-	for (unsigned int i = startPos; i < endPos; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-		chNextNonBlank = chNext;
-		unsigned int j=i+1;
-		while(IsABlank(chNextNonBlank) && j<endPos) {
-			j ++ ;
-			chNextNonBlank = styler.SafeGetCharAt(j);
-		}
-		int stylePrev = style;
-		style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
-		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
-		//
-		if (stylePrev == SCE_F_DEFAULT && (style == SCE_F_WORD || style == SCE_F_LABEL)) {
-			// Store last word and label start point.
-			lastStart = i;
-		}
-		/***************************************/
-		if (style == SCE_F_WORD) {
-			if(iswordchar(ch) && !iswordchar(chNext)) {
-				char s[32];
-				unsigned int k;
-				for(k=0; (k<31 ) && (k<i-lastStart+1 ); k++) {
-					s[k] = static_cast<char>(tolower(styler[lastStart+k]));
-				}
-				s[k] = '\0';
-				// Handle the forall and where statement and structure.
-				if (strcmp(s, "forall") == 0 || strcmp(s, "where") == 0) {
-					if (strcmp(prevWord, "end") != 0) {
-						j = i + 1;
-						char chBrace = '(', chSeek = ')', ch1 = styler.SafeGetCharAt(j);
-						// Find the position of the first (
-						while (ch1 != chBrace && j<endPos) {
-							j++;
-							ch1 = styler.SafeGetCharAt(j);
-						}
-						char styBrace = styler.StyleAt(j);
-						int depth = 1;
-						char chAtPos;
-						char styAtPos;
-						while (j<endPos) {
-							j++;
-							chAtPos = styler.SafeGetCharAt(j);
-							styAtPos = styler.StyleAt(j);
-							if (styAtPos == styBrace) {
-								if (chAtPos == chBrace) depth++;
-								if (chAtPos == chSeek) depth--;
-								if (depth == 0) break;
-							}
-						}
-						while (j<endPos) {
-							j++;
-							chAtPos = styler.SafeGetCharAt(j);
-							styAtPos = styler.StyleAt(j);
-							if (styAtPos == SCE_F_COMMENT || IsABlank(chAtPos)) continue;
-							if (isFixFormat) {
-								if (!IsALineEnd(chAtPos)) {
-									break;
-								} else {
-									if (lineCurrent < styler.GetLine(styler.Length()-1)) {
-										j = styler.LineStart(lineCurrent+1);
-										if (styler.StyleAt(j+5) == SCE_F_CONTINUATION) {
-											j += 5;
-											continue;
-										} else {
-											levelCurrent++;
-											break;
-										}
-									}
-								}
-							} else {
-								if (chAtPos == '&' && styler.StyleAt(j) == SCE_F_CONTINUATION) {
-									j = GetContinuedPos(j+1, styler);
-									continue;
-								} else if (IsALineEnd(chAtPos)) {
-									levelCurrent ++;
-									break;
-								} else {
-									break;
-								}
-							}
-						}
-					}
-				} else {
-					levelCurrent += classifyFoldPointFortran(s, prevWord, chNextNonBlank);
-					// Store the do Labels into array
-					if (strcmp(s, "do") == 0 && IsADigit(chNextNonBlank)) {
-						unsigned int k = 0;
-						for (i=j; (i<j+5 && i<endPos); i++) {
-							ch = styler.SafeGetCharAt(i);
-							if (IsADigit(ch))
-								Label[k++] = ch;
-							else
-								break;
-						}
-						Label[k] = '\0';
-						posLabel ++;
-						doLabels[posLabel] = atoi(Label);
-					}
-				}
-				strcpy(prevWord, s);
-			}
-		} else if (style == SCE_F_LABEL) {
-			if(IsADigit(ch) && !IsADigit(chNext)) {
-				for(j = 0; ( j < 5 ) && ( j < i-lastStart+1 ); j++) {
-					ch = styler.SafeGetCharAt(lastStart + j);
-					if (IsADigit(ch) && styler.StyleAt(lastStart+j) == SCE_F_LABEL)
-						Label[j] = ch;
-					else
-						break;
-				}
-				Label[j] = '\0';
-				while (doLabels[posLabel] == atoi(Label) && posLabel > -1) {
-					levelCurrent--;
-					posLabel--;
-				}
-			}
-		}
-		if (atEOL) {
-			int lev = levelPrev;
-			if (visibleChars == 0 && foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if ((levelCurrent > levelPrev) && (visibleChars > 0))
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
-			lineCurrent++;
-			levelPrev = levelCurrent;
-			visibleChars = 0;
-			strcpy(prevWord, "");
-		}
-		/***************************************/
-		if (!isspacechar(ch)) visibleChars++;
-	}
-	/***************************************/
-	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
-	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
-	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
-}
-/***************************************/
-static const char * const FortranWordLists[] = {
-	"Primary keywords and identifiers",
-	"Intrinsic functions",
-	"Extended and user defined functions",
-	0,
-};
-/***************************************/
-static void ColouriseFortranDocFreeFormat(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                            Accessor &styler) {
-	ColouriseFortranDoc(startPos, length, initStyle, keywordlists, styler, false);
-}
-/***************************************/
-static void ColouriseFortranDocFixFormat(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                            Accessor &styler) {
-	ColouriseFortranDoc(startPos, length, initStyle, keywordlists, styler, true);
-}
-/***************************************/
-static void FoldFortranDocFreeFormat(unsigned int startPos, int length, int initStyle,
-		WordList *[], Accessor &styler) {
-	FoldFortranDoc(startPos, length, initStyle,styler, false);
-}
-/***************************************/
-static void FoldFortranDocFixFormat(unsigned int startPos, int length, int initStyle,
-		WordList *[], Accessor &styler) {
-	FoldFortranDoc(startPos, length, initStyle,styler, true);
-}
-/***************************************/
-LexerModule lmFortran(SCLEX_FORTRAN, ColouriseFortranDocFreeFormat, "fortran", FoldFortranDocFreeFormat, FortranWordLists);
-LexerModule lmF77(SCLEX_F77, ColouriseFortranDocFixFormat, "f77", FoldFortranDocFixFormat, FortranWordLists);
diff --git a/Pythonwin/Scintilla/src/LexGen.py b/Pythonwin/Scintilla/src/LexGen.py
deleted file mode 100644
index 7c1d9eb0b..000000000
--- a/Pythonwin/Scintilla/src/LexGen.py
+++ /dev/null
@@ -1,264 +0,0 @@
-# LexGen.py - implemented 2002 by Neil Hodgson neilh@scintilla.org
-# Released to the public domain.
-
-# Regenerate the Scintilla and SciTE source files that list
-# all the lexers and all the properties files.
-# Should be run whenever a new lexer is added or removed.
-# Requires Python 2.4 or later
-# Most files are regenerated in place with templates stored in comments.
-# The VS .NET project file is generated into a different file as the
-# VS .NET environment will not retain comments when modifying the file.
-# The files are copied to a string apart from sections between a
-# ++Autogenerated comment and a --Autogenerated comment which is
-# generated by the CopyWithInsertion function. After the whole
-# string is instantiated, it is compared with the target file and
-# if different the file is rewritten.
-# Does not regenerate the Visual C++ 6 project files but does the VS .NET
-# project file.
-
-import glob
-import os
-import string
-import sys
-
-# EOL constants
-CR = "\r"
-LF = "\n"
-CRLF = "\r\n"
-if sys.platform == "win32":
-    NATIVE = CRLF
-else:
-    # Yes, LF is the native EOL even on Mac OS X. CR is just for
-    # Mac OS <=9 (a.k.a. "Mac Classic")
-    NATIVE = LF
-
-
-# Automatically generated sections contain start and end comments,
-# a definition line and the results.
-# The results are replaced by regenerating based on the definition line.
-# The definition line is a comment prefix followed by "**".
-# If there is a digit after the ** then this indicates which list to use
-# and the digit and next character are not part of the definition
-# Backslash is used as an escape within the definition line.
-# The part between \( and \) is repeated for each item in the list.
-# \* is replaced by each list item. \t, and \n are tab and newline.
-def CopyWithInsertion(input, commentPrefix, retainDefs, eolType, *lists):
-    copying = 1
-    listid = 0
-    output = []
-    for line in input.splitlines(0):
-        isStartGenerated = line.startswith(commentPrefix + "++Autogenerated")
-        if copying and not isStartGenerated:
-            output.append(line)
-        if isStartGenerated:
-            if retainDefs:
-                output.append(line)
-            copying = 0
-            definition = ""
-        elif not copying and line.startswith(commentPrefix + "**"):
-            if retainDefs:
-                output.append(line)
-            definition = line[len(commentPrefix + "**") :]
-            listid = 0
-            if definition[0] in string.digits:
-                listid = int(definition[:1])
-                definition = definition[2:]
-            # Hide double slashes as a control character
-            definition = definition.replace("\\\\", "\001")
-            # Do some normal C style transforms
-            definition = definition.replace("\\n", "\n")
-            definition = definition.replace("\\t", "\t")
-            # Get the doubled backslashes back as single backslashes
-            definition = definition.replace("\001", "\\")
-            startRepeat = definition.find("\\(")
-            endRepeat = definition.find("\\)")
-            intro = definition[:startRepeat]
-            out = ""
-            if intro.endswith("\n"):
-                pos = 0
-            else:
-                pos = len(intro)
-            out += intro
-            middle = definition[startRepeat + 2 : endRepeat]
-            for i in lists[listid]:
-                item = middle.replace("\\*", i)
-                if pos and (pos + len(item) >= 80):
-                    out += "\\\n"
-                    pos = 0
-                out += item
-                pos += len(item)
-                if item.endswith("\n"):
-                    pos = 0
-            outro = definition[endRepeat + 2 :]
-            out += outro
-            out = out.replace("\n", eolType)  # correct EOLs in generated content
-            output.append(out)
-        elif line.startswith(commentPrefix + "--Autogenerated"):
-            copying = 1
-            if retainDefs:
-                output.append(line)
-    output = [line.rstrip(" \t") for line in output]  # trim trailing whitespace
-    return eolType.join(output) + eolType
-
-
-def UpdateFile(filename, updated):
-    """If the file is different to updated then copy updated
-    into the file else leave alone so CVS and make don't treat
-    it as modified."""
-    try:
-        infile = open(filename, "rb")
-    except OSError:  # File is not there yet
-        out = open(filename, "wb")
-        out.write(updated)
-        out.close()
-        print("New", filename)
-        return
-    original = infile.read()
-    infile.close()
-    if updated != original:
-        os.unlink(filename)
-        out = open(filename, "wb")
-        out.write(updated)
-        out.close()
-        print("Changed", filename)
-    # ~ else:
-    # ~ print "Unchanged", filename
-
-
-def Generate(inpath, outpath, commentPrefix, eolType, *lists):
-    """Generate 'outpath' from 'inpath'.
-
-    "eolType" indicates the type of EOLs to use in the generated
-        file. It should be one of following constants: LF, CRLF,
-        CR, or NATIVE.
-    """
-    # print "generate '%s' -> '%s' (comment prefix: %r, eols: %r)"\
-    #      % (inpath, outpath, commentPrefix, eolType)
-    try:
-        infile = open(inpath, "r")
-    except OSError:
-        print("Can not open", inpath)
-        return
-    original = infile.read()
-    infile.close()
-    updated = CopyWithInsertion(
-        original, commentPrefix, inpath == outpath, eolType, *lists
-    )
-    UpdateFile(outpath, updated)
-
-
-def Regenerate(filename, commentPrefix, eolType, *lists):
-    """Regenerate the given file.
-
-    "eolType" indicates the type of EOLs to use in the generated
-        file. It should be one of following constants: LF, CRLF,
-        CR, or NATIVE.
-    """
-    Generate(filename, filename, commentPrefix, eolType, *lists)
-
-
-def FindModules(lexFile):
-    modules = []
-    f = open(lexFile)
-    for l in f.readlines():
-        if l.startswith("LexerModule"):
-            l = l.replace("(", " ")
-            modules.append(l.split()[1])
-    return modules
-
-
-knownIrregularProperties = [
-    "fold",
-    "styling.within.preprocessor",
-    "tab.timmy.whinge.level",
-    "asp.default.language",
-    "html.tags.case.sensitive",
-    "ps.level",
-    "ps.tokenize",
-    "sql.backslash.escapes",
-    "nsis.uservars",
-    "nsis.ignorecase",
-]
-
-
-def FindProperties(lexFile):
-    properties = set()
-    f = open(lexFile)
-    for l in f.readlines():
-        if "GetProperty" in l:
-            l = l.strip()
-            if not l.startswith("//"):  # Drop comments
-                propertyName = l.split('"')[1]
-                if propertyName.lower() == propertyName:
-                    # Only allow lower case property names
-                    if (
-                        propertyName in knownIrregularProperties
-                        or propertyName.startswith("fold.")
-                        or propertyName.startswith("lexer.")
-                    ):
-                        properties.add(propertyName)
-    return properties
-
-
-def ciCompare(a, b):
-    return cmp(a.lower(), b.lower())
-
-
-def RegenerateAll():
-    root = "../../"
-
-    # Find all the lexer source code files
-    lexFilePaths = glob.glob(root + "scintilla/src/Lex*.cxx")
-    lexFiles = [os.path.basename(f)[:-4] for f in lexFilePaths]
-    print(lexFiles)
-    lexerModules = []
-    lexerProperties = set()
-    for lexFile in lexFilePaths:
-        lexerModules.extend(FindModules(lexFile))
-        lexerProperties.update(FindProperties(lexFile))
-    lexerModules.sort(ciCompare)
-    lexerProperties.remove("fold.comment.python")
-    lexerProperties = list(lexerProperties)
-    lexerProperties.sort(ciCompare)
-
-    # Find all the SciTE properties files
-    otherProps = [
-        "abbrev.properties",
-        "Embedded.properties",
-        "SciTEGlobal.properties",
-        "SciTE.properties",
-    ]
-    if os.path.exists(root + "scite"):
-        propFilePaths = glob.glob(root + "scite/src/*.properties")
-        propFiles = [
-            os.path.basename(f)
-            for f in propFilePaths
-            if os.path.basename(f) not in otherProps
-        ]
-        propFiles.sort(ciCompare)
-        print(propFiles)
-
-    Regenerate(root + "scintilla/src/KeyWords.cxx", "//", NATIVE, lexerModules)
-    Regenerate(root + "scintilla/win32/makefile", "#", NATIVE, lexFiles)
-    Regenerate(root + "scintilla/win32/scintilla.mak", "#", NATIVE, lexFiles)
-    Regenerate(root + "scintilla/win32/scintilla_vc6.mak", "#", NATIVE, lexFiles)
-    # Use Unix EOLs for gtk Makefiles so they work for Linux users when
-    # extracted from the Scintilla source ZIP (typically created on
-    # Windows).
-    Regenerate(root + "scintilla/gtk/makefile", "#", LF, lexFiles)
-    Regenerate(root + "scintilla/gtk/scintilla.mak", "#", NATIVE, lexFiles)
-    Regenerate(root + "scintilla/macosx/makefile", "#", LF, lexFiles)
-    if os.path.exists(root + "scite"):
-        Regenerate(root + "scite/win32/makefile", "#", NATIVE, lexFiles, propFiles)
-        Regenerate(root + "scite/win32/scite.mak", "#", NATIVE, lexFiles, propFiles)
-        Regenerate(root + "scite/src/SciTEProps.cxx", "//", NATIVE, lexerProperties)
-        Generate(
-            root + "scite/boundscheck/vcproj.gen",
-            root + "scite/boundscheck/SciTE.vcproj",
-            "#",
-            NATIVE,
-            lexFiles,
-        )
-
-
-RegenerateAll()
diff --git a/Pythonwin/Scintilla/src/LexHaskell.cxx b/Pythonwin/Scintilla/src/LexHaskell.cxx
deleted file mode 100644
index 3213bd520..000000000
--- a/Pythonwin/Scintilla/src/LexHaskell.cxx
+++ /dev/null
@@ -1,274 +0,0 @@
-/******************************************************************
- *    LexHaskell.cxx
- *
- *    A haskell lexer for the scintilla code control.
- *    Some stuff "lended" from LexPython.cxx and LexCPP.cxx.
- *    External lexer stuff inspired from the caml external lexer.
- *
- *    Written by Tobias Engvall - tumm at dtek dot chalmers dot se
- *
- *
- *    TODO:
- *    * Implement a folder :)
- *    * Nice Character-lexing (stuff inside '\''), LexPython has
- *      this.
- *
- *
- *****************************************************************/
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-#ifdef BUILD_AS_EXTERNAL_LEXER
-
-#include "ExternalLexer.h"
-#include "WindowAccessor.h"
-
-#define BUILD_EXTERNAL_LEXER 0
-
-#endif
-
-// Max level of nested comments
-#define SCE_HA_COMMENTMAX SCE_HA_COMMENTBLOCK3
-
-
-enum kwType { kwOther, kwClass, kwData, kwInstance, kwImport, kwModule, kwType};
-
-static inline bool IsNewline(const int ch) {
-   return (ch == '\n' || ch == '\r');
-}
-
-static inline bool IsWhitespace(const int ch) {
-   return (  ch == ' '
-          || ch == '\t'
-          || IsNewline(ch) );
-}
-
-static inline bool IsAWordStart(const int ch) {
-   return (ch < 0x80) && (isalnum(ch) || ch == '_');
-}
-
-static inline bool IsAWordChar(const int ch) {
-   return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_' || ch == '\'');
-}
-
-static void ColorizeHaskellDoc(unsigned int startPos, int length, int initStyle,
-                               WordList *keywordlists[], Accessor &styler) {
-
-   WordList &keywords = *keywordlists[0];
-
-   int kwLast = kwOther;
-
-   StyleContext sc(startPos, length, initStyle, styler);
-
-   for (; sc.More(); sc.Forward()) {
-
-      // Check for state end
-         // Operator
-      if (sc.state == SCE_HA_OPERATOR) {
-         kwLast = kwOther;
-         sc.SetState(SCE_HA_DEFAULT);
-      }
-         // String
-      else if (sc.state == SCE_HA_STRING) {
-         if (sc.ch == '\"') {
-            sc.ForwardSetState(SCE_HA_DEFAULT);
-         } else if (sc.ch == '\\') {
-            sc.Forward();
-         }
-      }
-         // Char
-      else if (sc.state == SCE_HA_CHARACTER) {
-         if (sc.ch == '\'') {
-            sc.ForwardSetState(SCE_HA_DEFAULT);
-         } else if (sc.ch == '\\') {
-            sc.Forward();
-         }
-      }
-         // Number
-      else if (sc.state == SCE_HA_NUMBER) {
-         if (!IsADigit(sc.ch)) {
-            sc.SetState(SCE_HA_DEFAULT);
-         }
-      }
-         // Types, constructors, etc.
-      else if (sc.state == SCE_HA_CAPITAL) {
-         if (!IsAWordChar(sc.ch) || sc.ch == '.') {
-            sc.SetState(SCE_HA_DEFAULT);
-         }
-      }
-         // Identifier
-      else if (sc.state == SCE_HA_IDENTIFIER) {
-         if (!IsAWordChar(sc.ch)) {
-            char s[100];
-            sc.GetCurrent(s, sizeof(s));
-            int style = SCE_HA_IDENTIFIER;
-            if ((kwLast == kwImport) || (strcmp(s,"qualified") == 0) || (strcmp(s,"as") == 0)) {
-               style = SCE_HA_IMPORT;
-            } else if (keywords.InList(s)) {
-               style = SCE_HA_KEYWORD;
-            } else if (kwLast == kwData) {
-               style = SCE_HA_DATA;
-            } else if (kwLast == kwClass) {
-               style = SCE_HA_CLASS;
-            } else if (kwLast == kwModule) {
-               style = SCE_HA_MODULE;
-            } else if (isupper(s[0])) {
-               style = SCE_HA_CAPITAL;
-            }
-            sc.ChangeState(style);
-            sc.SetState(SCE_HA_DEFAULT);
-            if (style == SCE_HA_KEYWORD) {
-               if (0 == strcmp(s, "class"))
-                  kwLast = kwClass;
-               else if (0 == strcmp(s, "data"))
-                  kwLast = kwData;
-               else if (0 == strcmp(s, "instance"))
-                  kwLast = kwInstance;
-               else if (0 == strcmp(s, "import"))
-                  kwLast = kwImport;
-               else if (0 == strcmp(s, "module"))
-                  kwLast = kwModule;
-               else
-                  kwLast = kwOther;
-            } else if (style == SCE_HA_CLASS || style == SCE_HA_IMPORT ||
-                       style == SCE_HA_MODULE || style == SCE_HA_CAPITAL ||
-                       style == SCE_HA_DATA || style == SCE_HA_INSTANCE) {
-               kwLast = kwOther;
-            }
-         }
-      }
-         // Comments
-            // Oneliner
-      else if (sc.state == SCE_HA_COMMENTLINE) {
-         if (IsNewline(sc.ch))
-            sc.SetState(SCE_HA_DEFAULT);
-      }
-            // Nested
-      else if (sc.state >= SCE_HA_COMMENTBLOCK) {
-         if (sc.Match("{-")) {
-            if (sc.state < SCE_HA_COMMENTMAX)
-               sc.SetState(sc.state + 1);
-         }
-         else if (sc.Match("-}")) {
-            sc.Forward();
-            if (sc.state == SCE_HA_COMMENTBLOCK)
-               sc.ForwardSetState(SCE_HA_DEFAULT);
-            else
-               sc.ForwardSetState(sc.state - 1);
-         }
-      }
-      // New state?
-      if (sc.state == SCE_HA_DEFAULT) {
-         // Digit
-         if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
-            sc.SetState(SCE_HA_NUMBER);
-            if (sc.ch == '0' && (sc.chNext == 'X' || sc.chNext == 'x')) { // Match anything starting with "0x" or "0X", too
-               sc.Forward(1);
-            }
-         }
-         // Comment line
-         else if (sc.Match("--")) {
-            sc.SetState(SCE_HA_COMMENTLINE);
-         // Comment block
-         }
-         else if (sc.Match("{-")) {
-            sc.SetState(SCE_HA_COMMENTBLOCK);
-         }
-         // String
-         else if (sc.Match('\"')) {
-            sc.SetState(SCE_HA_STRING);
-         }
-         // Character
-         else if (sc.Match('\'')) {
-            sc.SetState(SCE_HA_CHARACTER);
-         }
-         // Stringstart
-         else if (sc.Match('\"')) {
-            sc.SetState(SCE_HA_STRING);
-         }
-         // Operator
-         else if (isascii(sc.ch) && isoperator(static_cast<char>(sc.ch))) {
-            sc.SetState(SCE_HA_OPERATOR);
-         }
-         // Keyword
-         else if (IsAWordStart(sc.ch)) {
-               sc.SetState(SCE_HA_IDENTIFIER);
-         }
-
-      }
-   }
-   sc.Complete();
-}
-
-// External stuff - used for dynamic-loading, not implemented in wxStyledTextCtrl yet.
-// Inspired by the caml external lexer - Credits to Robert Roessler - http://www.rftp.com
-#ifdef BUILD_EXTERNAL_LEXER
-static const char* LexerName = "haskell";
-
-void EXT_LEXER_DECL Lex(unsigned int lexer, unsigned int startPos, int length, int initStyle,
-                        char *words[], WindowID window, char *props)
-{
-   PropSet ps;
-   ps.SetMultiple(props);
-   WindowAccessor wa(window, ps);
-
-   int nWL = 0;
-   for (; words[nWL]; nWL++) ;
-   WordList** wl = new WordList* [nWL + 1];
-   int i = 0;
-   for (; i<nWL; i++)
-   {
-      wl[i] = new WordList();
-      wl[i]->Set(words[i]);
-   }
-   wl[i] = 0;
-
-   ColorizeHaskellDoc(startPos, length, initStyle, wl, wa);
-   wa.Flush();
-   for (i=nWL-1;i>=0;i--)
-      delete wl[i];
-   delete [] wl;
-}
-
-void EXT_LEXER_DECL Fold (unsigned int lexer, unsigned int startPos, int length, int initStyle,
-                        char *words[], WindowID window, char *props)
-{
-
-}
-
-int EXT_LEXER_DECL GetLexerCount()
-{
-   return 1;
-}
-
-void EXT_LEXER_DECL GetLexerName(unsigned int Index, char *name, int buflength)
-{
-   if (buflength > 0) {
-      buflength--;
-      int n = strlen(LexerName);
-      if (n > buflength)
-         n = buflength;
-      memcpy(name, LexerName, n), name[n] = '\0';
-   }
-}
-#endif
-
-LexerModule lmHaskell(SCLEX_HASKELL, ColorizeHaskellDoc, "haskell");
-
diff --git a/Pythonwin/Scintilla/src/LexLua.cxx b/Pythonwin/Scintilla/src/LexLua.cxx
deleted file mode 100644
index a1e579f26..000000000
--- a/Pythonwin/Scintilla/src/LexLua.cxx
+++ /dev/null
@@ -1,358 +0,0 @@
-// Scintilla source code edit control
-/** @file LexLua.cxx
- ** Lexer for Lua language.
- **
- ** Written by Paul Winwood.
- ** Folder by Alexey Yutkin.
- ** Modified by Marcos E. Wurzius & Philippe Lhoste
- **/
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdarg.h>
-#include <stdio.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-#include "CharacterSet.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-// Test for [=[ ... ]=] delimiters, returns 0 if it's only a [ or ],
-// return 1 for [[ or ]], returns >=2 for [=[ or ]=] and so on.
-// The maximum number of '=' characters allowed is 254.
-static int LongDelimCheck(StyleContext &sc) {
-	int sep = 1;
-	while (sc.GetRelative(sep) == '=' && sep < 0xFF)
-		sep++;
-	if (sc.GetRelative(sep) == sc.ch)
-		return sep;
-	return 0;
-}
-
-static void ColouriseLuaDoc(
-	unsigned int startPos,
-	int length,
-	int initStyle,
-	WordList *keywordlists[],
-	Accessor &styler) {
-
-	WordList &keywords = *keywordlists[0];
-	WordList &keywords2 = *keywordlists[1];
-	WordList &keywords3 = *keywordlists[2];
-	WordList &keywords4 = *keywordlists[3];
-	WordList &keywords5 = *keywordlists[4];
-	WordList &keywords6 = *keywordlists[5];
-	WordList &keywords7 = *keywordlists[6];
-	WordList &keywords8 = *keywordlists[7];
-
-	// Accepts accented characters
-	CharacterSet setWordStart(CharacterSet::setAlpha, "_", 0x80, true);
-	CharacterSet setWord(CharacterSet::setAlphaNum, "._", 0x80, true);
-	// Not exactly following number definition (several dots are seen as OK, etc.)
-	// but probably enough in most cases.
-	CharacterSet setNumber(CharacterSet::setDigits, ".-+abcdefABCDEF");
-	CharacterSet setLuaOperator(CharacterSet::setNone, "*/-+()={}~[];<>,.^%:#");
-	CharacterSet setEscapeSkip(CharacterSet::setNone, "\"'\\");
-
-	int currentLine = styler.GetLine(startPos);
-	// Initialize long string [[ ... ]] or block comment --[[ ... ]] nesting level,
-	// if we are inside such a string. Block comment was introduced in Lua 5.0,
-	// blocks with separators [=[ ... ]=] in Lua 5.1.
-	int nestLevel = 0;
-	int sepCount = 0;
-	if (initStyle == SCE_LUA_LITERALSTRING || initStyle == SCE_LUA_COMMENT) {
-		int lineState = styler.GetLineState(currentLine - 1);
-		nestLevel = lineState >> 8;
-		sepCount = lineState & 0xFF;
-	}
-
-	// Do not leak onto next line
-	if (initStyle == SCE_LUA_STRINGEOL || initStyle == SCE_LUA_COMMENTLINE || initStyle == SCE_LUA_PREPROCESSOR) {
-		initStyle = SCE_LUA_DEFAULT;
-	}
-
-	StyleContext sc(startPos, length, initStyle, styler);
-	if (startPos == 0 && sc.ch == '#') {
-		// shbang line: # is a comment only if first char of the script
-		sc.SetState(SCE_LUA_COMMENTLINE);
-	}
-	for (; sc.More(); sc.Forward()) {
-		if (sc.atLineEnd) {
-			// Update the line state, so it can be seen by next line
-			currentLine = styler.GetLine(sc.currentPos);
-			switch (sc.state) {
-			case SCE_LUA_LITERALSTRING:
-			case SCE_LUA_COMMENT:
-				// Inside a literal string or block comment, we set the line state
-				styler.SetLineState(currentLine, (nestLevel << 8) | sepCount);
-				break;
-			default:
-				// Reset the line state
-				styler.SetLineState(currentLine, 0);
-				break;
-			}
-		}
-		if (sc.atLineStart && (sc.state == SCE_LUA_STRING)) {
-			// Prevent SCE_LUA_STRINGEOL from leaking back to previous line
-			sc.SetState(SCE_LUA_STRING);
-		}
-
-		// Handle string line continuation
-		if ((sc.state == SCE_LUA_STRING || sc.state == SCE_LUA_CHARACTER) &&
-				sc.ch == '\\') {
-			if (sc.chNext == '\n' || sc.chNext == '\r') {
-				sc.Forward();
-				if (sc.ch == '\r' && sc.chNext == '\n') {
-					sc.Forward();
-				}
-				continue;
-			}
-		}
-
-		// Determine if the current state should terminate.
-		if (sc.state == SCE_LUA_OPERATOR) {
-			sc.SetState(SCE_LUA_DEFAULT);
-		} else if (sc.state == SCE_LUA_NUMBER) {
-			// We stop the number definition on non-numerical non-dot non-eE non-sign non-hexdigit char
-			if (!setNumber.Contains(sc.ch)) {
-				sc.SetState(SCE_LUA_DEFAULT);
-			} else if (sc.ch == '-' || sc.ch == '+') {
-				if (sc.chPrev != 'E' && sc.chPrev != 'e')
-					sc.SetState(SCE_LUA_DEFAULT);
-			}
-		} else if (sc.state == SCE_LUA_IDENTIFIER) {
-			if (!setWord.Contains(sc.ch) || sc.Match('.', '.')) {
-				char s[100];
-				sc.GetCurrent(s, sizeof(s));
-				if (keywords.InList(s)) {
-					sc.ChangeState(SCE_LUA_WORD);
-				} else if (keywords2.InList(s)) {
-					sc.ChangeState(SCE_LUA_WORD2);
-				} else if (keywords3.InList(s)) {
-					sc.ChangeState(SCE_LUA_WORD3);
-				} else if (keywords4.InList(s)) {
-					sc.ChangeState(SCE_LUA_WORD4);
-				} else if (keywords5.InList(s)) {
-					sc.ChangeState(SCE_LUA_WORD5);
-				} else if (keywords6.InList(s)) {
-					sc.ChangeState(SCE_LUA_WORD6);
-				} else if (keywords7.InList(s)) {
-					sc.ChangeState(SCE_LUA_WORD7);
-				} else if (keywords8.InList(s)) {
-					sc.ChangeState(SCE_LUA_WORD8);
-				}
-				sc.SetState(SCE_LUA_DEFAULT);
-			}
-		} else if (sc.state == SCE_LUA_COMMENTLINE || sc.state == SCE_LUA_PREPROCESSOR) {
-			if (sc.atLineEnd) {
-				sc.ForwardSetState(SCE_LUA_DEFAULT);
-			}
-		} else if (sc.state == SCE_LUA_STRING) {
-			if (sc.ch == '\\') {
-				if (setEscapeSkip.Contains(sc.chNext)) {
-					sc.Forward();
-				}
-			} else if (sc.ch == '\"') {
-				sc.ForwardSetState(SCE_LUA_DEFAULT);
-			} else if (sc.atLineEnd) {
-				sc.ChangeState(SCE_LUA_STRINGEOL);
-				sc.ForwardSetState(SCE_LUA_DEFAULT);
-			}
-		} else if (sc.state == SCE_LUA_CHARACTER) {
-			if (sc.ch == '\\') {
-				if (setEscapeSkip.Contains(sc.chNext)) {
-					sc.Forward();
-				}
-			} else if (sc.ch == '\'') {
-				sc.ForwardSetState(SCE_LUA_DEFAULT);
-			} else if (sc.atLineEnd) {
-				sc.ChangeState(SCE_LUA_STRINGEOL);
-				sc.ForwardSetState(SCE_LUA_DEFAULT);
-			}
-		} else if (sc.state == SCE_LUA_LITERALSTRING || sc.state == SCE_LUA_COMMENT) {
-			if (sc.ch == '[') {
-				int sep = LongDelimCheck(sc);
-				if (sep == 1 && sepCount == 1) {    // [[-only allowed to nest
-					nestLevel++;
-					sc.Forward();
-				}
-			} else if (sc.ch == ']') {
-				int sep = LongDelimCheck(sc);
-				if (sep == 1 && sepCount == 1) {    // un-nest with ]]-only
-					nestLevel--;
-					sc.Forward();
-					if (nestLevel == 0) {
-						sc.ForwardSetState(SCE_LUA_DEFAULT);
-					}
-				} else if (sep > 1 && sep == sepCount) {   // ]=]-style delim
-					sc.Forward(sep);
-					sc.ForwardSetState(SCE_LUA_DEFAULT);
-				}
-			}
-		}
-
-		// Determine if a new state should be entered.
-		if (sc.state == SCE_LUA_DEFAULT) {
-			if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
-				sc.SetState(SCE_LUA_NUMBER);
-				if (sc.ch == '0' && toupper(sc.chNext) == 'X') {
-					sc.Forward();
-				}
-			} else if (setWordStart.Contains(sc.ch)) {
-				sc.SetState(SCE_LUA_IDENTIFIER);
-			} else if (sc.ch == '\"') {
-				sc.SetState(SCE_LUA_STRING);
-			} else if (sc.ch == '\'') {
-				sc.SetState(SCE_LUA_CHARACTER);
-			} else if (sc.ch == '[') {
-				sepCount = LongDelimCheck(sc);
-				if (sepCount == 0) {
-					sc.SetState(SCE_LUA_OPERATOR);
-				} else {
-					nestLevel = 1;
-					sc.SetState(SCE_LUA_LITERALSTRING);
-					sc.Forward(sepCount);
-				}
-			} else if (sc.Match('-', '-')) {
-				sc.SetState(SCE_LUA_COMMENTLINE);
-				if (sc.Match("--[")) {
-					sc.Forward(2);
-					sepCount = LongDelimCheck(sc);
-					if (sepCount > 0) {
-						nestLevel = 1;
-						sc.ChangeState(SCE_LUA_COMMENT);
-						sc.Forward(sepCount);
-					}
-				} else {
-					sc.Forward();
-				}
-			} else if (sc.atLineStart && sc.Match('$')) {
-				sc.SetState(SCE_LUA_PREPROCESSOR);	// Obsolete since Lua 4.0, but still in old code
-			} else if (setLuaOperator.Contains(sc.ch)) {
-				sc.SetState(SCE_LUA_OPERATOR);
-			}
-		}
-	}
-
-	if (setWord.Contains(sc.chPrev)) {
-		char s[100];
-		sc.GetCurrent(s, sizeof(s));
-		if (keywords.InList(s)) {
-			sc.ChangeState(SCE_LUA_WORD);
-		} else if (keywords2.InList(s)) {
-			sc.ChangeState(SCE_LUA_WORD2);
-		} else if (keywords3.InList(s)) {
-			sc.ChangeState(SCE_LUA_WORD3);
-		} else if (keywords4.InList(s)) {
-			sc.ChangeState(SCE_LUA_WORD4);
-		} else if (keywords5.InList(s)) {
-			sc.ChangeState(SCE_LUA_WORD5);
-		} else if (keywords6.InList(s)) {
-			sc.ChangeState(SCE_LUA_WORD6);
-		} else if (keywords7.InList(s)) {
-			sc.ChangeState(SCE_LUA_WORD7);
-		} else if (keywords8.InList(s)) {
-			sc.ChangeState(SCE_LUA_WORD8);
-		}
-	}
-
-	sc.Complete();
-}
-
-static void FoldLuaDoc(unsigned int startPos, int length, int /* initStyle */, WordList *[],
-                       Accessor &styler) {
-	unsigned int lengthDoc = startPos + length;
-	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
-	int levelPrev = styler.LevelAt(lineCurrent) & SC_FOLDLEVELNUMBERMASK;
-	int levelCurrent = levelPrev;
-	char chNext = styler[startPos];
-	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	int styleNext = styler.StyleAt(startPos);
-	char s[10];
-
-	for (unsigned int i = startPos; i < lengthDoc; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-		int style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
-		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
-		if (style == SCE_LUA_WORD) {
-			if (ch == 'i' || ch == 'd' || ch == 'f' || ch == 'e' || ch == 'r' || ch == 'u') {
-				for (unsigned int j = 0; j < 8; j++) {
-					if (!iswordchar(styler[i + j])) {
-						break;
-					}
-					s[j] = styler[i + j];
-					s[j + 1] = '\0';
-				}
-
-				if ((strcmp(s, "if") == 0) || (strcmp(s, "do") == 0) || (strcmp(s, "function") == 0) || (strcmp(s, "repeat") == 0)) {
-					levelCurrent++;
-				}
-				if ((strcmp(s, "end") == 0) || (strcmp(s, "elseif") == 0) || (strcmp(s, "until") == 0)) {
-					levelCurrent--;
-				}
-			}
-		} else if (style == SCE_LUA_OPERATOR) {
-			if (ch == '{' || ch == '(') {
-				levelCurrent++;
-			} else if (ch == '}' || ch == ')') {
-				levelCurrent--;
-			}
-		} else if (style == SCE_LUA_LITERALSTRING || style == SCE_LUA_COMMENT) {
-			if (ch == '[') {
-				levelCurrent++;
-			} else if (ch == ']') {
-				levelCurrent--;
-			}
-		}
-
-		if (atEOL) {
-			int lev = levelPrev;
-			if (visibleChars == 0 && foldCompact) {
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			}
-			if ((levelCurrent > levelPrev) && (visibleChars > 0)) {
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			}
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
-			lineCurrent++;
-			levelPrev = levelCurrent;
-			visibleChars = 0;
-		}
-		if (!isspacechar(ch)) {
-			visibleChars++;
-		}
-	}
-	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
-
-	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
-	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
-}
-
-static const char * const luaWordListDesc[] = {
-	"Keywords",
-	"Basic functions",
-	"String, (table) & math functions",
-	"(coroutines), I/O & system facilities",
-	"user1",
-	"user2",
-	"user3",
-	"user4",
-	0
-};
-
-LexerModule lmLua(SCLEX_LUA, ColouriseLuaDoc, "lua", FoldLuaDoc, luaWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexMatlab.cxx b/Pythonwin/Scintilla/src/LexMatlab.cxx
deleted file mode 100644
index 4e467bd2f..000000000
--- a/Pythonwin/Scintilla/src/LexMatlab.cxx
+++ /dev/null
@@ -1,236 +0,0 @@
-// Scintilla source code edit control
-/** @file LexMatlab.cxx
- ** Lexer for Matlab.
- ** Written by José Fonseca
- **
- ** Changes by Christoph Dalitz 2003/12/04:
- **   - added support for Octave
- **   - Strings can now be included both in single or double quotes
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-static bool IsMatlabCommentChar(int c) {
-	return (c == '%') ;
-}
-
-static bool IsOctaveCommentChar(int c) {
-	return (c == '%' || c == '#') ;
-}
-
-static bool IsMatlabComment(Accessor &styler, int pos, int len) {
-	return len > 0 && IsMatlabCommentChar(styler[pos]) ;
-}
-
-static bool IsOctaveComment(Accessor &styler, int pos, int len) {
-	return len > 0 && IsOctaveCommentChar(styler[pos]) ;
-}
-
-static inline bool IsAWordChar(const int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '_');
-}
-
-static inline bool IsAWordStart(const int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '_');
-}
-
-static void ColouriseMatlabOctaveDoc(
-            unsigned int startPos, int length, int initStyle,
-            WordList *keywordlists[], Accessor &styler,
-            bool (*IsCommentChar)(int)) {
-
-	WordList &keywords = *keywordlists[0];
-
-	styler.StartAt(startPos);
-
-	bool transpose = false;
-
-	StyleContext sc(startPos, length, initStyle, styler);
-
-	for (; sc.More(); sc.Forward()) {
-
-		if (sc.state == SCE_MATLAB_OPERATOR) {
-			if (sc.chPrev == '.') {
-				if (sc.ch == '*' || sc.ch == '/' || sc.ch == '\\' || sc.ch == '^') {
-					sc.ForwardSetState(SCE_MATLAB_DEFAULT);
-					transpose = false;
-				} else if (sc.ch == '\'') {
-					sc.ForwardSetState(SCE_MATLAB_DEFAULT);
-					transpose = true;
-				} else {
-					sc.SetState(SCE_MATLAB_DEFAULT);
-				}
-			} else {
-				sc.SetState(SCE_MATLAB_DEFAULT);
-			}
-		} else if (sc.state == SCE_MATLAB_KEYWORD) {
-			if (!isalnum(sc.ch) && sc.ch != '_') {
-				char s[100];
-				sc.GetCurrentLowered(s, sizeof(s));
-				if (keywords.InList(s)) {
-					sc.SetState(SCE_MATLAB_DEFAULT);
-					transpose = false;
-				} else {
-					sc.ChangeState(SCE_MATLAB_IDENTIFIER);
-					sc.SetState(SCE_MATLAB_DEFAULT);
-					transpose = true;
-				}
-			}
-		} else if (sc.state == SCE_MATLAB_NUMBER) {
-			if (!isdigit(sc.ch) && sc.ch != '.'
-			        && !(sc.ch == 'e' || sc.ch == 'E')
-			        && !((sc.ch == '+' || sc.ch == '-') && (sc.chPrev == 'e' || sc.chPrev == 'E'))) {
-				sc.SetState(SCE_MATLAB_DEFAULT);
-				transpose = true;
-			}
-		} else if (sc.state == SCE_MATLAB_STRING) {
-			if (sc.ch == '\\') {
-				if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
-					sc.Forward();
-				}
-			} else if (sc.ch == '\'') {
-				sc.ForwardSetState(SCE_MATLAB_DEFAULT);
-			}
-		} else if (sc.state == SCE_MATLAB_DOUBLEQUOTESTRING) {
-			if (sc.ch == '\\') {
-				if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
-					sc.Forward();
-				}
-			} else if (sc.ch == '\"') {
-				sc.ForwardSetState(SCE_MATLAB_DEFAULT);
-			}
-		} else if (sc.state == SCE_MATLAB_COMMENT || sc.state == SCE_MATLAB_COMMAND) {
-			if (sc.atLineEnd) {
-				sc.SetState(SCE_MATLAB_DEFAULT);
-				transpose = false;
-			}
-		}
-
-		if (sc.state == SCE_MATLAB_DEFAULT) {
-			if (IsCommentChar(sc.ch)) {
-				sc.SetState(SCE_MATLAB_COMMENT);
-			} else if (sc.ch == '!' && sc.chNext != '=' ) {
-				sc.SetState(SCE_MATLAB_COMMAND);
-			} else if (sc.ch == '\'') {
-				if (transpose) {
-					sc.SetState(SCE_MATLAB_OPERATOR);
-				} else {
-					sc.SetState(SCE_MATLAB_STRING);
-				}
-			} else if (sc.ch == '"') {
-				sc.SetState(SCE_MATLAB_DOUBLEQUOTESTRING);
-			} else if (isdigit(sc.ch) || (sc.ch == '.' && isdigit(sc.chNext))) {
-				sc.SetState(SCE_MATLAB_NUMBER);
-			} else if (isalpha(sc.ch)) {
-				sc.SetState(SCE_MATLAB_KEYWORD);
-			} else if (isoperator(static_cast<char>(sc.ch)) || sc.ch == '@' || sc.ch == '\\') {
-				if (sc.ch == ')' || sc.ch == ']') {
-					transpose = true;
-				} else {
-					transpose = false;
-				}
-				sc.SetState(SCE_MATLAB_OPERATOR);
-			} else {
-				transpose = false;
-			}
-		}
-	}
-	sc.Complete();
-}
-
-static void ColouriseMatlabDoc(unsigned int startPos, int length, int initStyle,
-                               WordList *keywordlists[], Accessor &styler) {
-	ColouriseMatlabOctaveDoc(startPos, length, initStyle, keywordlists, styler, IsMatlabCommentChar);
-}
-
-static void ColouriseOctaveDoc(unsigned int startPos, int length, int initStyle,
-                               WordList *keywordlists[], Accessor &styler) {
-	ColouriseMatlabOctaveDoc(startPos, length, initStyle, keywordlists, styler, IsOctaveCommentChar);
-}
-
-static void FoldMatlabOctaveDoc(unsigned int startPos, int length, int,
-                                WordList *[], Accessor &styler,
-                                bool (*IsComment)(Accessor&, int, int)) {
-
-	int endPos = startPos + length;
-
-	// Backtrack to previous line in case need to fix its fold status
-	int lineCurrent = styler.GetLine(startPos);
-	if (startPos > 0) {
-		if (lineCurrent > 0) {
-			lineCurrent--;
-			startPos = styler.LineStart(lineCurrent);
-		}
-	}
-	int spaceFlags = 0;
-	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, IsComment);
-	char chNext = styler[startPos];
-	for (int i = startPos; i < endPos; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-
-		if ((ch == '\r' && chNext != '\n') || (ch == '\n') || (i == endPos)) {
-			int lev = indentCurrent;
-			int indentNext = styler.IndentAmount(lineCurrent + 1, &spaceFlags, IsComment);
-			if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG)) {
-				// Only non whitespace lines can be headers
-				if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK)) {
-					lev |= SC_FOLDLEVELHEADERFLAG;
-				} else if (indentNext & SC_FOLDLEVELWHITEFLAG) {
-					// Line after is blank so check the next - maybe should continue further?
-					int spaceFlags2 = 0;
-					int indentNext2 = styler.IndentAmount(lineCurrent + 2, &spaceFlags2, IsComment);
-					if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext2 & SC_FOLDLEVELNUMBERMASK)) {
-						lev |= SC_FOLDLEVELHEADERFLAG;
-					}
-				}
-			}
-			indentCurrent = indentNext;
-			styler.SetLevel(lineCurrent, lev);
-			lineCurrent++;
-		}
-	}
-}
-
-static void FoldMatlabDoc(unsigned int startPos, int length, int initStyle,
-                          WordList *keywordlists[], Accessor &styler) {
-	FoldMatlabOctaveDoc(startPos, length, initStyle, keywordlists, styler, IsMatlabComment);
-}
-
-static void FoldOctaveDoc(unsigned int startPos, int length, int initStyle,
-                          WordList *keywordlists[], Accessor &styler) {
-	FoldMatlabOctaveDoc(startPos, length, initStyle, keywordlists, styler, IsOctaveComment);
-}
-
-static const char * const matlabWordListDesc[] = {
-	"Keywords",
-	0
-};
-
-static const char * const octaveWordListDesc[] = {
-	"Keywords",
-	0
-};
-
-LexerModule lmMatlab(SCLEX_MATLAB, ColouriseMatlabDoc, "matlab", FoldMatlabDoc, matlabWordListDesc);
-
-LexerModule lmOctave(SCLEX_OCTAVE, ColouriseOctaveDoc, "octave", FoldOctaveDoc, octaveWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexMySQL.cxx b/Pythonwin/Scintilla/src/LexMySQL.cxx
deleted file mode 100644
index 742ff4339..000000000
--- a/Pythonwin/Scintilla/src/LexMySQL.cxx
+++ /dev/null
@@ -1,367 +0,0 @@
-// Scintilla source code edit control
-/** @file LexMySQL.cxx
- ** Lexer for MySQL
- **/
-// Adopted from LexSQL.cxx by Anders Karlsson <anders@mysql.com>
-// Original work by Neil Hodgson <neilh@scintilla.org>
-// Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-static inline bool IsAWordChar(int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '_');
-}
-
-static inline bool IsAWordStart(int ch) {
-	return (ch < 0x80) && (isalpha(ch) || ch == '_');
-}
-
-static inline bool IsADoxygenChar(int ch) {
-	return (islower(ch) || ch == '$' || ch == '@' ||
-	        ch == '\\' || ch == '&' || ch == '<' ||
-	        ch == '>' || ch == '#' || ch == '{' ||
-	        ch == '}' || ch == '[' || ch == ']');
-}
-
-static inline bool IsANumberChar(int ch) {
-	// Not exactly following number definition (several dots are seen as OK, etc.)
-	// but probably enough in most cases.
-	return (ch < 0x80) &&
-	        (isdigit(ch) || toupper(ch) == 'E' ||
-             ch == '.' || ch == '-' || ch == '+');
-}
-
-static void ColouriseMySQLDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                            Accessor &styler) {
-
-	WordList &major_keywords = *keywordlists[0];
-	WordList &keywords = *keywordlists[1];
-	WordList &database_objects = *keywordlists[2];
-	WordList &functions = *keywordlists[3];
-	WordList &system_variables = *keywordlists[4];
-	WordList &procedure_keywords = *keywordlists[5];
-	WordList &kw_user1 = *keywordlists[6];
-	WordList &kw_user2 = *keywordlists[7];
-	WordList &kw_user3 = *keywordlists[8];
-
-	StyleContext sc(startPos, length, initStyle, styler);
-
-	for (; sc.More(); sc.Forward()) {
-		// Determine if the current state should terminate.
-		switch (sc.state) {
-		case SCE_MYSQL_OPERATOR:
-			sc.SetState(SCE_MYSQL_DEFAULT);
-			break;
-		case SCE_MYSQL_NUMBER:
-			// We stop the number definition on non-numerical non-dot non-eE non-sign char
-			if (!IsANumberChar(sc.ch)) {
-				sc.SetState(SCE_MYSQL_DEFAULT);
-			}
-			break;
-		case SCE_MYSQL_IDENTIFIER:
-			if (!IsAWordChar(sc.ch)) {
-				int nextState = SCE_MYSQL_DEFAULT;
-				char s[1000];
-				sc.GetCurrentLowered(s, sizeof(s));
-				if (major_keywords.InList(s)) {
-					sc.ChangeState(SCE_MYSQL_MAJORKEYWORD);
-				} else if (keywords.InList(s)) {
-					sc.ChangeState(SCE_MYSQL_KEYWORD);
-				} else if (database_objects.InList(s)) {
-					sc.ChangeState(SCE_MYSQL_DATABASEOBJECT);
-				} else if (functions.InList(s)) {
-					sc.ChangeState(SCE_MYSQL_FUNCTION);
-				} else if (procedure_keywords.InList(s)) {
-					sc.ChangeState(SCE_MYSQL_PROCEDUREKEYWORD);
-				} else if (kw_user1.InList(s)) {
-					sc.ChangeState(SCE_MYSQL_USER1);
-				} else if (kw_user2.InList(s)) {
-					sc.ChangeState(SCE_MYSQL_USER2);
-				} else if (kw_user3.InList(s)) {
-					sc.ChangeState(SCE_MYSQL_USER3);
-				}
-				sc.SetState(nextState);
-			}
-			break;
-		case SCE_MYSQL_VARIABLE:
-			if (!IsAWordChar(sc.ch)) {
-				sc.SetState(SCE_MYSQL_DEFAULT);
-			}
-			break;
-		case SCE_MYSQL_SYSTEMVARIABLE:
-			if (!IsAWordChar(sc.ch)) {
-				char s[1000];
-				sc.GetCurrentLowered(s, sizeof(s));
-// Check for known system variables here.
-				if (system_variables.InList(&s[2])) {
-					sc.ChangeState(SCE_MYSQL_KNOWNSYSTEMVARIABLE);
-				}
-				sc.SetState(SCE_MYSQL_DEFAULT);
-			}
-			break;
-		case SCE_MYSQL_QUOTEDIDENTIFIER:
-			if (sc.ch == 0x60) {
-				if (sc.chNext == 0x60) {
-					sc.Forward();	// Ignore it
-				} else {
-					sc.ForwardSetState(SCE_MYSQL_DEFAULT);
-				}
-			}
-			break;
-		case SCE_MYSQL_COMMENT:
-			if (sc.Match('*', '/')) {
-				sc.Forward();
-				sc.ForwardSetState(SCE_MYSQL_DEFAULT);
-			}
-			break;
-		case SCE_MYSQL_COMMENTLINE:
-			if (sc.atLineStart) {
-				sc.SetState(SCE_MYSQL_DEFAULT);
-			}
-			break;
-		case SCE_MYSQL_SQSTRING:
-			if (sc.ch == '\\') {
-				// Escape sequence
-				sc.Forward();
-			} else if (sc.ch == '\'') {
-				if (sc.chNext == '\'') {
-					sc.Forward();
-				} else {
-					sc.ChangeState(SCE_MYSQL_STRING);
-					sc.ForwardSetState(SCE_MYSQL_DEFAULT);
-				}
-			}
-			break;
-		case SCE_MYSQL_DQSTRING:
-			if (sc.ch == '\\') {
-				// Escape sequence
-				sc.Forward();
-			} else if (sc.ch == '\"') {
-				if (sc.chNext == '\"') {
-					sc.Forward();
-				} else {
-					sc.ChangeState(SCE_MYSQL_STRING);
-					sc.ForwardSetState(SCE_MYSQL_DEFAULT);
-				}
-			}
-			break;
-		}
-
-		// Determine if a new state should be entered.
-		if (sc.state == SCE_MYSQL_DEFAULT) {
-			if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
-				sc.SetState(SCE_MYSQL_NUMBER);
-			} else if (IsAWordStart(sc.ch)) {
-				sc.SetState(SCE_MYSQL_IDENTIFIER);
-// Note that the order of SYSTEMVARIABLE and VARIABLE is important here.
-			} else if (sc.ch == 0x40 && sc.chNext == 0x40) {
-				sc.SetState(SCE_MYSQL_SYSTEMVARIABLE);
-				sc.Forward(); // Skip past the second at-sign.
-			} else if (sc.ch == 0x40) {
-				sc.SetState(SCE_MYSQL_VARIABLE);
-			} else if (sc.ch == 0x60) {
-				sc.SetState(SCE_MYSQL_QUOTEDIDENTIFIER);
-			} else if (sc.Match('/', '*')) {
-				sc.SetState(SCE_MYSQL_COMMENT);
-				sc.Forward();	// Eat the * so it isn't used for the end of the comment
-			} else if (sc.Match('-', '-') || sc.Match('#')) {
-				sc.SetState(SCE_MYSQL_COMMENTLINE);
-			} else if (sc.ch == '\'') {
-				sc.SetState(SCE_MYSQL_SQSTRING);
-			} else if (sc.ch == '\"') {
-				sc.SetState(SCE_MYSQL_DQSTRING);
-			} else if (isoperator(static_cast<char>(sc.ch))) {
-				sc.SetState(SCE_MYSQL_OPERATOR);
-			}
-		}
-	}
-	sc.Complete();
-}
-
-static bool IsStreamCommentStyle(int style) {
-	return style == SCE_MYSQL_COMMENT;
-}
-
-// Store both the current line's fold level and the next lines in the
-// level store to make it easy to pick up with each increment.
-static void FoldMySQLDoc(unsigned int startPos, int length, int initStyle,
-                            WordList *[], Accessor &styler) {
-	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
-	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	bool foldOnlyBegin = styler.GetPropertyInt("fold.sql.only.begin", 0) != 0;
-
-	unsigned int endPos = startPos + length;
-	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
-	int levelCurrent = SC_FOLDLEVELBASE;
-	if (lineCurrent > 0) {
-		levelCurrent = styler.LevelAt(lineCurrent - 1) >> 16;
-	}
-	int levelNext = levelCurrent;
-	char chNext = styler[startPos];
-	int styleNext = styler.StyleAt(startPos);
-	int style = initStyle;
-	bool endFound = false;
-	bool whenFound = false;
-	bool elseFound = false;
-	for (unsigned int i = startPos; i < endPos; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-		int stylePrev = style;
-		style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
-		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
-		if (foldComment && IsStreamCommentStyle(style)) {
-			if (!IsStreamCommentStyle(stylePrev)) {
-				levelNext++;
-			} else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
-				// Comments don't end at end of line and the next character may be unstyled.
-				levelNext--;
-			}
-		}
-		if (foldComment && (style == SCE_MYSQL_COMMENTLINE)) {
-			// MySQL needs -- comments to be followed by space or control char
-			if ((ch == '-') && (chNext == '-')) {
-				char chNext2 = styler.SafeGetCharAt(i + 2);
-				char chNext3 = styler.SafeGetCharAt(i + 3);
-				if (chNext2 == '{' || chNext3 == '{') {
-					levelNext++;
-				} else if (chNext2 == '}' || chNext3 == '}') {
-					levelNext--;
-				}
-			}
-		}
-		if (style == SCE_MYSQL_OPERATOR) {
-			if (ch == '(') {
-				levelNext++;
-			} else if (ch == ')') {
-				levelNext--;
-			}
-		}
-
-// Style new keywords here.
-		if ((style == SCE_MYSQL_MAJORKEYWORD && stylePrev != SCE_MYSQL_MAJORKEYWORD)
-		  || (style == SCE_MYSQL_KEYWORD && stylePrev != SCE_MYSQL_KEYWORD)
-		  || (style == SCE_MYSQL_PROCEDUREKEYWORD && stylePrev != SCE_MYSQL_PROCEDUREKEYWORD)) {
-			const int MAX_KW_LEN = 6;	// Maximum length of folding keywords
-			char s[MAX_KW_LEN + 2];
-			unsigned int j = 0;
-			for (; j < MAX_KW_LEN + 1; j++) {
-				if (!iswordchar(styler[i + j])) {
-					break;
-				}
-				s[j] = static_cast<char>(tolower(styler[i + j]));
-			}
-			if (j == MAX_KW_LEN + 1) {
-				// Keyword too long, don't test it
-				s[0] = '\0';
-			} else {
-				s[j] = '\0';
-			}
-			if (!foldOnlyBegin && endFound && (strcmp(s, "if") == 0 || strcmp(s, "while") == 0 || strcmp(s, "loop") == 0)) {
-				endFound = false;
-				levelNext--;
-				if (levelNext < SC_FOLDLEVELBASE) {
-					levelNext = SC_FOLDLEVELBASE;
-				}
-// Note that else is special here. It may or may be followed by an if then, but in aly case the level stays the
-// same. When followed by a if .. then, the level will be increased later, if not, at eol.
-			} else if (!foldOnlyBegin && strcmp(s, "else") == 0) {
-				levelNext--;
-				elseFound = true;
-			} else if (!foldOnlyBegin && strcmp(s, "then") == 0) {
-				if(whenFound) {
-					whenFound = false;
-				} else {
-					levelNext++;
-				}
-			} else if (strcmp(s, "if") == 0) {
-				elseFound = false;
-			} else if (strcmp(s, "when") == 0) {
-				whenFound = true;
-			} else if (strcmp(s, "begin") == 0) {
-				levelNext++;
-			} else if (!foldOnlyBegin && (strcmp(s, "loop") == 0 || strcmp(s, "repeat") == 0
-			  || strcmp(s, "while") == 0)) {
-				if(endFound) {
-					endFound = false;
-				} else {
-					levelNext++;
-				}
-			} else if (strcmp(s, "end") == 0) {
-// Multiple END in a row are counted multiple times!
-				if (endFound) {
-					levelNext--;
-					if (levelNext < SC_FOLDLEVELBASE) {
-						levelNext = SC_FOLDLEVELBASE;
-					}
-				}
-				endFound = true;
-				whenFound = false;
-			}
-		}
-// Handle this for a trailing end withiut an if / while etc, as in the case of a begin.
-		if (endFound) {
-			endFound = false;
-			levelNext--;
-			if (levelNext < SC_FOLDLEVELBASE) {
-				levelNext = SC_FOLDLEVELBASE;
-			}
-		}
-		if (atEOL) {
-			if(elseFound)
-				levelNext++;
-			elseFound = false;
-
-			int levelUse = levelCurrent;
-			int lev = levelUse | levelNext << 16;
-			if (visibleChars == 0 && foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if (levelUse < levelNext)
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
-			lineCurrent++;
-			levelCurrent = levelNext;
-			visibleChars = 0;
-			endFound = false;
-			whenFound = false;
-		}
-		if (!isspacechar(ch)) {
-			visibleChars++;
-		}
-	}
-}
-
-static const char * const mysqlWordListDesc[] = {
-	"Major Keywords",
-	"Keywords",
-	"Database Objects",
-	"Functions",
-	"System Variables",
-	"Procedure keywords",
-	"User Keywords 1",
-	"User Keywords 2",
-	"User Keywords 3"
-};
-
-LexerModule lmMySQL(SCLEX_MYSQL, ColouriseMySQLDoc, "mysql", FoldMySQLDoc, mysqlWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexOthers.cxx b/Pythonwin/Scintilla/src/LexOthers.cxx
deleted file mode 100644
index 24eee96a3..000000000
--- a/Pythonwin/Scintilla/src/LexOthers.cxx
+++ /dev/null
@@ -1,1231 +0,0 @@
-// Scintilla source code edit control
-/** @file LexOthers.cxx
- ** Lexers for batch files, diff results, properties files, make files and error lists.
- ** Also lexer for LaTeX documents.
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-static bool strstart(const char *haystack, const char *needle) {
-	return strncmp(haystack, needle, strlen(needle)) == 0;
-}
-
-static bool Is0To9(char ch) {
-	return (ch >= '0') && (ch <= '9');
-}
-
-static bool Is1To9(char ch) {
-	return (ch >= '1') && (ch <= '9');
-}
-
-static inline bool AtEOL(Accessor &styler, unsigned int i) {
-	return (styler[i] == '\n') ||
-	       ((styler[i] == '\r') && (styler.SafeGetCharAt(i + 1) != '\n'));
-}
-
-// Tests for BATCH Operators
-static bool IsBOperator(char ch) {
-	return (ch == '=') || (ch == '+') || (ch == '>') || (ch == '<') ||
-		(ch == '|') || (ch == '?') || (ch == '*');
-}
-
-// Tests for BATCH Separators
-static bool IsBSeparator(char ch) {
-	return (ch == '\\') || (ch == '.') || (ch == ';') ||
-		(ch == '\"') || (ch == '\'') || (ch == '/') || (ch == ')');
-}
-
-static void ColouriseBatchLine(
-    char *lineBuffer,
-    unsigned int lengthLine,
-    unsigned int startLine,
-    unsigned int endPos,
-    WordList *keywordlists[],
-    Accessor &styler) {
-
-	unsigned int offset = 0;	// Line Buffer Offset
-	unsigned int cmdLoc;		// External Command / Program Location
-	char wordBuffer[81];		// Word Buffer - large to catch long paths
-	unsigned int wbl;		// Word Buffer Length
-	unsigned int wbo;		// Word Buffer Offset - also Special Keyword Buffer Length
-	WordList &keywords = *keywordlists[0];      // Internal Commands
-	WordList &keywords2 = *keywordlists[1];     // External Commands (optional)
-
-	// CHOICE, ECHO, GOTO, PROMPT and SET have Default Text that may contain Regular Keywords
-	//   Toggling Regular Keyword Checking off improves readability
-	// Other Regular Keywords and External Commands / Programs might also benefit from toggling
-	//   Need a more robust algorithm to properly toggle Regular Keyword Checking
-	bool continueProcessing = true;	// Used to toggle Regular Keyword Checking
-	// Special Keywords are those that allow certain characters without whitespace after the command
-	// Examples are: cd. cd\ md. rd. dir| dir> echo: echo. path=
-	// Special Keyword Buffer used to determine if the first n characters is a Keyword
-	char sKeywordBuffer[10];	// Special Keyword Buffer
-	bool sKeywordFound;		// Exit Special Keyword for-loop if found
-
-	// Skip initial spaces
-	while ((offset < lengthLine) && (isspacechar(lineBuffer[offset]))) {
-		offset++;
-	}
-	// Colorize Default Text
-	styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
-	// Set External Command / Program Location
-	cmdLoc = offset;
-
-	// Check for Fake Label (Comment) or Real Label - return if found
-	if (lineBuffer[offset] == ':') {
-		if (lineBuffer[offset + 1] == ':') {
-			// Colorize Fake Label (Comment) - :: is similar to REM, see http://content.techweb.com/winmag/columns/explorer/2000/21.htm
-			styler.ColourTo(endPos, SCE_BAT_COMMENT);
-		} else {
-			// Colorize Real Label
-			styler.ColourTo(endPos, SCE_BAT_LABEL);
-		}
-		return;
-	// Check for Drive Change (Drive Change is internal command) - return if found
-	} else if ((isalpha(lineBuffer[offset])) &&
-		(lineBuffer[offset + 1] == ':') &&
-		((isspacechar(lineBuffer[offset + 2])) ||
-		(((lineBuffer[offset + 2] == '\\')) &&
-		(isspacechar(lineBuffer[offset + 3]))))) {
-		// Colorize Regular Keyword
-		styler.ColourTo(endPos, SCE_BAT_WORD);
-		return;
-	}
-
-	// Check for Hide Command (@ECHO OFF/ON)
-	if (lineBuffer[offset] == '@') {
-		styler.ColourTo(startLine + offset, SCE_BAT_HIDE);
-		offset++;
-	}
-	// Skip next spaces
-	while ((offset < lengthLine) && (isspacechar(lineBuffer[offset]))) {
-		offset++;
-	}
-
-	// Read remainder of line word-at-a-time or remainder-of-word-at-a-time
-	while (offset < lengthLine) {
-		if (offset > startLine) {
-			// Colorize Default Text
-			styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
-		}
-		// Copy word from Line Buffer into Word Buffer
-		wbl = 0;
-		for (; offset < lengthLine && wbl < 80 &&
-		        !isspacechar(lineBuffer[offset]); wbl++, offset++) {
-			wordBuffer[wbl] = static_cast<char>(tolower(lineBuffer[offset]));
-		}
-		wordBuffer[wbl] = '\0';
-		wbo = 0;
-
-		// Check for Comment - return if found
-		if (CompareCaseInsensitive(wordBuffer, "rem") == 0) {
-			styler.ColourTo(endPos, SCE_BAT_COMMENT);
-			return;
-		}
-		// Check for Separator
-		if (IsBSeparator(wordBuffer[0])) {
-			// Check for External Command / Program
-			if ((cmdLoc == offset - wbl) &&
-				((wordBuffer[0] == ':') ||
-				(wordBuffer[0] == '\\') ||
-				(wordBuffer[0] == '.'))) {
-				// Reset Offset to re-process remainder of word
-				offset -= (wbl - 1);
-				// Colorize External Command / Program
-				if (!keywords2) {
-					styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
-				} else if (keywords2.InList(wordBuffer)) {
-					styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
-				} else {
-					styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
-				}
-				// Reset External Command / Program Location
-				cmdLoc = offset;
-			} else {
-				// Reset Offset to re-process remainder of word
-				offset -= (wbl - 1);
-				// Colorize Default Text
-				styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
-			}
-		// Check for Regular Keyword in list
-		} else if ((keywords.InList(wordBuffer)) &&
-			(continueProcessing)) {
-			// ECHO, GOTO, PROMPT and SET require no further Regular Keyword Checking
-			if ((CompareCaseInsensitive(wordBuffer, "echo") == 0) ||
-				(CompareCaseInsensitive(wordBuffer, "goto") == 0) ||
-				(CompareCaseInsensitive(wordBuffer, "prompt") == 0) ||
-				(CompareCaseInsensitive(wordBuffer, "set") == 0)) {
-				continueProcessing = false;
-			}
-			// Identify External Command / Program Location for ERRORLEVEL, and EXIST
-			if ((CompareCaseInsensitive(wordBuffer, "errorlevel") == 0) ||
-				(CompareCaseInsensitive(wordBuffer, "exist") == 0)) {
-				// Reset External Command / Program Location
-				cmdLoc = offset;
-				// Skip next spaces
-				while ((cmdLoc < lengthLine) &&
-					(isspacechar(lineBuffer[cmdLoc]))) {
-					cmdLoc++;
-				}
-				// Skip comparison
-				while ((cmdLoc < lengthLine) &&
-					(!isspacechar(lineBuffer[cmdLoc]))) {
-					cmdLoc++;
-				}
-				// Skip next spaces
-				while ((cmdLoc < lengthLine) &&
-					(isspacechar(lineBuffer[cmdLoc]))) {
-					cmdLoc++;
-				}
-			// Identify External Command / Program Location for CALL, DO, LOADHIGH and LH
-			} else if ((CompareCaseInsensitive(wordBuffer, "call") == 0) ||
-				(CompareCaseInsensitive(wordBuffer, "do") == 0) ||
-				(CompareCaseInsensitive(wordBuffer, "loadhigh") == 0) ||
-				(CompareCaseInsensitive(wordBuffer, "lh") == 0)) {
-				// Reset External Command / Program Location
-				cmdLoc = offset;
-				// Skip next spaces
-				while ((cmdLoc < lengthLine) &&
-					(isspacechar(lineBuffer[cmdLoc]))) {
-					cmdLoc++;
-				}
-			}
-			// Colorize Regular keyword
-			styler.ColourTo(startLine + offset - 1, SCE_BAT_WORD);
-			// No need to Reset Offset
-		// Check for Special Keyword in list, External Command / Program, or Default Text
-		} else if ((wordBuffer[0] != '%') &&
-			(!IsBOperator(wordBuffer[0])) &&
-			(continueProcessing)) {
-			// Check for Special Keyword
-			//     Affected Commands are in Length range 2-6
-			//     Good that ERRORLEVEL, EXIST, CALL, DO, LOADHIGH, and LH are unaffected
-			sKeywordFound = false;
-			for (unsigned int keywordLength = 2; keywordLength < wbl && keywordLength < 7 && !sKeywordFound; keywordLength++) {
-				wbo = 0;
-				// Copy Keyword Length from Word Buffer into Special Keyword Buffer
-				for (; wbo < keywordLength; wbo++) {
-					sKeywordBuffer[wbo] = static_cast<char>(wordBuffer[wbo]);
-				}
-				sKeywordBuffer[wbo] = '\0';
-				// Check for Special Keyword in list
-				if ((keywords.InList(sKeywordBuffer)) &&
-					((IsBOperator(wordBuffer[wbo])) ||
-					(IsBSeparator(wordBuffer[wbo])))) {
-					sKeywordFound = true;
-					// ECHO requires no further Regular Keyword Checking
-					if (CompareCaseInsensitive(sKeywordBuffer, "echo") == 0) {
-						continueProcessing = false;
-					}
-					// Colorize Special Keyword as Regular Keyword
-					styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_WORD);
-					// Reset Offset to re-process remainder of word
-					offset -= (wbl - wbo);
-				}
-			}
-			// Check for External Command / Program or Default Text
-			if (!sKeywordFound) {
-				wbo = 0;
-				// Check for External Command / Program
-				if (cmdLoc == offset - wbl) {
-					// Read up to %, Operator or Separator
-					while ((wbo < wbl) &&
-						(wordBuffer[wbo] != '%') &&
-						(!IsBOperator(wordBuffer[wbo])) &&
-						(!IsBSeparator(wordBuffer[wbo]))) {
-						wbo++;
-					}
-					// Reset External Command / Program Location
-					cmdLoc = offset - (wbl - wbo);
-					// Reset Offset to re-process remainder of word
-					offset -= (wbl - wbo);
-					// CHOICE requires no further Regular Keyword Checking
-					if (CompareCaseInsensitive(wordBuffer, "choice") == 0) {
-						continueProcessing = false;
-					}
-					// Check for START (and its switches) - What follows is External Command \ Program
-					if (CompareCaseInsensitive(wordBuffer, "start") == 0) {
-						// Reset External Command / Program Location
-						cmdLoc = offset;
-						// Skip next spaces
-						while ((cmdLoc < lengthLine) &&
-							(isspacechar(lineBuffer[cmdLoc]))) {
-							cmdLoc++;
-						}
-						// Reset External Command / Program Location if command switch detected
-						if (lineBuffer[cmdLoc] == '/') {
-							// Skip command switch
-							while ((cmdLoc < lengthLine) &&
-								(!isspacechar(lineBuffer[cmdLoc]))) {
-								cmdLoc++;
-							}
-							// Skip next spaces
-							while ((cmdLoc < lengthLine) &&
-								(isspacechar(lineBuffer[cmdLoc]))) {
-								cmdLoc++;
-							}
-						}
-					}
-					// Colorize External Command / Program
-					if (!keywords2) {
-						styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
-					} else if (keywords2.InList(wordBuffer)) {
-						styler.ColourTo(startLine + offset - 1, SCE_BAT_COMMAND);
-					} else {
-						styler.ColourTo(startLine + offset - 1, SCE_BAT_DEFAULT);
-					}
-					// No need to Reset Offset
-				// Check for Default Text
-				} else {
-					// Read up to %, Operator or Separator
-					while ((wbo < wbl) &&
-						(wordBuffer[wbo] != '%') &&
-						(!IsBOperator(wordBuffer[wbo])) &&
-						(!IsBSeparator(wordBuffer[wbo]))) {
-						wbo++;
-					}
-					// Colorize Default Text
-					styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_DEFAULT);
-					// Reset Offset to re-process remainder of word
-					offset -= (wbl - wbo);
-				}
-			}
-		// Check for Argument  (%n), Environment Variable (%x...%) or Local Variable (%%a)
-		} else if (wordBuffer[0] == '%') {
-			// Colorize Default Text
-			styler.ColourTo(startLine + offset - 1 - wbl, SCE_BAT_DEFAULT);
-			wbo++;
-			// Search to end of word for second % (can be a long path)
-			while ((wbo < wbl) &&
-				(wordBuffer[wbo] != '%') &&
-				(!IsBOperator(wordBuffer[wbo])) &&
-				(!IsBSeparator(wordBuffer[wbo]))) {
-				wbo++;
-			}
-			// Check for Argument (%n) or (%*)
-			if (((Is0To9(wordBuffer[1])) || (wordBuffer[1] == '*')) &&
-				(wordBuffer[wbo] != '%')) {
-				// Check for External Command / Program
-				if (cmdLoc == offset - wbl) {
-					cmdLoc = offset - (wbl - 2);
-				}
-				// Colorize Argument
-				styler.ColourTo(startLine + offset - 1 - (wbl - 2), SCE_BAT_IDENTIFIER);
-				// Reset Offset to re-process remainder of word
-				offset -= (wbl - 2);
-			// Check for Expanded Argument (%~...) / Variable (%%~...)
-			} else if (((wbl > 1) && (wordBuffer[1] == '~')) ||
-				((wbl > 2) && (wordBuffer[1] == '%') && (wordBuffer[2] == '~'))) {
-				// Check for External Command / Program
-				if (cmdLoc == offset - wbl) {
-					cmdLoc = offset - (wbl - wbo);
-				}
-				// Colorize Expanded Argument / Variable
-				styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_IDENTIFIER);
-				// Reset Offset to re-process remainder of word
-				offset -= (wbl - wbo);
-			// Check for Environment Variable (%x...%)
-			} else if ((wordBuffer[1] != '%') &&
-				(wordBuffer[wbo] == '%')) {
-				wbo++;
-				// Check for External Command / Program
-				if (cmdLoc == offset - wbl) {
-					cmdLoc = offset - (wbl - wbo);
-				}
-				// Colorize Environment Variable
-				styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_IDENTIFIER);
-				// Reset Offset to re-process remainder of word
-				offset -= (wbl - wbo);
-			// Check for Local Variable (%%a)
-			} else if (
-				(wbl > 2) &&
-				(wordBuffer[1] == '%') &&
-				(wordBuffer[2] != '%') &&
-				(!IsBOperator(wordBuffer[2])) &&
-				(!IsBSeparator(wordBuffer[2]))) {
-				// Check for External Command / Program
-				if (cmdLoc == offset - wbl) {
-					cmdLoc = offset - (wbl - 3);
-				}
-				// Colorize Local Variable
-				styler.ColourTo(startLine + offset - 1 - (wbl - 3), SCE_BAT_IDENTIFIER);
-				// Reset Offset to re-process remainder of word
-				offset -= (wbl - 3);
-			}
-		// Check for Operator
-		} else if (IsBOperator(wordBuffer[0])) {
-			// Colorize Default Text
-			styler.ColourTo(startLine + offset - 1 - wbl, SCE_BAT_DEFAULT);
-			// Check for Comparison Operator
-			if ((wordBuffer[0] == '=') && (wordBuffer[1] == '=')) {
-				// Identify External Command / Program Location for IF
-				cmdLoc = offset;
-				// Skip next spaces
-				while ((cmdLoc < lengthLine) &&
-					(isspacechar(lineBuffer[cmdLoc]))) {
-					cmdLoc++;
-				}
-				// Colorize Comparison Operator
-				styler.ColourTo(startLine + offset - 1 - (wbl - 2), SCE_BAT_OPERATOR);
-				// Reset Offset to re-process remainder of word
-				offset -= (wbl - 2);
-			// Check for Pipe Operator
-			} else if (wordBuffer[0] == '|') {
-				// Reset External Command / Program Location
-				cmdLoc = offset - wbl + 1;
-				// Skip next spaces
-				while ((cmdLoc < lengthLine) &&
-					(isspacechar(lineBuffer[cmdLoc]))) {
-					cmdLoc++;
-				}
-				// Colorize Pipe Operator
-				styler.ColourTo(startLine + offset - 1 - (wbl - 1), SCE_BAT_OPERATOR);
-				// Reset Offset to re-process remainder of word
-				offset -= (wbl - 1);
-			// Check for Other Operator
-			} else {
-				// Check for > Operator
-				if (wordBuffer[0] == '>') {
-					// Turn Keyword and External Command / Program checking back on
-					continueProcessing = true;
-				}
-				// Colorize Other Operator
-				styler.ColourTo(startLine + offset - 1 - (wbl - 1), SCE_BAT_OPERATOR);
-				// Reset Offset to re-process remainder of word
-				offset -= (wbl - 1);
-			}
-		// Check for Default Text
-		} else {
-			// Read up to %, Operator or Separator
-			while ((wbo < wbl) &&
-				(wordBuffer[wbo] != '%') &&
-				(!IsBOperator(wordBuffer[wbo])) &&
-				(!IsBSeparator(wordBuffer[wbo]))) {
-				wbo++;
-			}
-			// Colorize Default Text
-			styler.ColourTo(startLine + offset - 1 - (wbl - wbo), SCE_BAT_DEFAULT);
-			// Reset Offset to re-process remainder of word
-			offset -= (wbl - wbo);
-		}
-		// Skip next spaces - nothing happens if Offset was Reset
-		while ((offset < lengthLine) && (isspacechar(lineBuffer[offset]))) {
-			offset++;
-		}
-	}
-	// Colorize Default Text for remainder of line - currently not lexed
-	styler.ColourTo(endPos, SCE_BAT_DEFAULT);
-}
-
-static void ColouriseBatchDoc(
-    unsigned int startPos,
-    int length,
-    int /*initStyle*/,
-    WordList *keywordlists[],
-    Accessor &styler) {
-
-	char lineBuffer[1024];
-
-	styler.StartAt(startPos);
-	styler.StartSegment(startPos);
-	unsigned int linePos = 0;
-	unsigned int startLine = startPos;
-	for (unsigned int i = startPos; i < startPos + length; i++) {
-		lineBuffer[linePos++] = styler[i];
-		if (AtEOL(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
-			// End of line (or of line buffer) met, colourise it
-			lineBuffer[linePos] = '\0';
-			ColouriseBatchLine(lineBuffer, linePos, startLine, i, keywordlists, styler);
-			linePos = 0;
-			startLine = i + 1;
-		}
-	}
-	if (linePos > 0) {	// Last line does not have ending characters
-		lineBuffer[linePos] = '\0';
-		ColouriseBatchLine(lineBuffer, linePos, startLine, startPos + length - 1,
-		                   keywordlists, styler);
-	}
-}
-
-static void ColouriseDiffLine(char *lineBuffer, int endLine, Accessor &styler) {
-	// It is needed to remember the current state to recognize starting
-	// comment lines before the first "diff " or "--- ". If a real
-	// difference starts then each line starting with ' ' is a whitespace
-	// otherwise it is considered a comment (Only in..., Binary file...)
-	if (0 == strncmp(lineBuffer, "diff ", 5)) {
-		styler.ColourTo(endLine, SCE_DIFF_COMMAND);
-	} else if (0 == strncmp(lineBuffer, "Index: ", 7)) {  // For subversion's diff
-		styler.ColourTo(endLine, SCE_DIFF_COMMAND);
-	} else if (0 == strncmp(lineBuffer, "---", 3)) {
-		// In a context diff, --- appears in both the header and the position markers
-		if (lineBuffer[3] == ' ' && atoi(lineBuffer + 4) && !strchr(lineBuffer, '/'))
-			styler.ColourTo(endLine, SCE_DIFF_POSITION);
-		else if (lineBuffer[3] == '\r' || lineBuffer[3] == '\n')
-			styler.ColourTo(endLine, SCE_DIFF_POSITION);
-		else
-			styler.ColourTo(endLine, SCE_DIFF_HEADER);
-	} else if (0 == strncmp(lineBuffer, "+++ ", 4)) {
-		// I don't know of any diff where "+++ " is a position marker, but for
-		// consistency, do the same as with "--- " and "*** ".
-		if (atoi(lineBuffer+4) && !strchr(lineBuffer, '/'))
-			styler.ColourTo(endLine, SCE_DIFF_POSITION);
-		else
-			styler.ColourTo(endLine, SCE_DIFF_HEADER);
-	} else if (0 == strncmp(lineBuffer, "====", 4)) {  // For p4's diff
-		styler.ColourTo(endLine, SCE_DIFF_HEADER);
-	} else if (0 == strncmp(lineBuffer, "***", 3)) {
-		// In a context diff, *** appears in both the header and the position markers.
-		// Also ******** is a chunk header, but here it's treated as part of the
-		// position marker since there is no separate style for a chunk header.
-		if (lineBuffer[3] == ' ' && atoi(lineBuffer+4) && !strchr(lineBuffer, '/'))
-			styler.ColourTo(endLine, SCE_DIFF_POSITION);
-		else if (lineBuffer[3] == '*')
-			styler.ColourTo(endLine, SCE_DIFF_POSITION);
-		else
-			styler.ColourTo(endLine, SCE_DIFF_HEADER);
-	} else if (0 == strncmp(lineBuffer, "? ", 2)) {    // For difflib
-		styler.ColourTo(endLine, SCE_DIFF_HEADER);
-	} else if (lineBuffer[0] == '@') {
-		styler.ColourTo(endLine, SCE_DIFF_POSITION);
-	} else if (lineBuffer[0] >= '0' && lineBuffer[0] <= '9') {
-		styler.ColourTo(endLine, SCE_DIFF_POSITION);
-	} else if (lineBuffer[0] == '-' || lineBuffer[0] == '<') {
-		styler.ColourTo(endLine, SCE_DIFF_DELETED);
-	} else if (lineBuffer[0] == '+' || lineBuffer[0] == '>') {
-		styler.ColourTo(endLine, SCE_DIFF_ADDED);
-	} else if (lineBuffer[0] == '!') {
-		styler.ColourTo(endLine, SCE_DIFF_CHANGED);
-	} else if (lineBuffer[0] != ' ') {
-		styler.ColourTo(endLine, SCE_DIFF_COMMENT);
-	} else {
-		styler.ColourTo(endLine, SCE_DIFF_DEFAULT);
-	}
-}
-
-static void ColouriseDiffDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
-	char lineBuffer[1024];
-	styler.StartAt(startPos);
-	styler.StartSegment(startPos);
-	unsigned int linePos = 0;
-	for (unsigned int i = startPos; i < startPos + length; i++) {
-		lineBuffer[linePos++] = styler[i];
-		if (AtEOL(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
-			// End of line (or of line buffer) met, colourise it
-			lineBuffer[linePos] = '\0';
-			ColouriseDiffLine(lineBuffer, i, styler);
-			linePos = 0;
-		}
-	}
-	if (linePos > 0) {	// Last line does not have ending characters
-		ColouriseDiffLine(lineBuffer, startPos + length - 1, styler);
-	}
-}
-
-static void FoldDiffDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
-	int curLine = styler.GetLine(startPos);
-	int curLineStart = styler.LineStart(curLine);
-	int prevLevel = curLine > 0 ? styler.LevelAt(curLine - 1) : SC_FOLDLEVELBASE;
-	int nextLevel;
-
-	do {
-		int lineType = styler.StyleAt(curLineStart);
-		if (lineType == SCE_DIFF_COMMAND)
-			nextLevel = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;
-		else if (lineType == SCE_DIFF_HEADER)
-			nextLevel = (SC_FOLDLEVELBASE + 1) | SC_FOLDLEVELHEADERFLAG;
-		else if (lineType == SCE_DIFF_POSITION && styler[curLineStart] != '-')
-			nextLevel = (SC_FOLDLEVELBASE + 2) | SC_FOLDLEVELHEADERFLAG;
-		else if (prevLevel & SC_FOLDLEVELHEADERFLAG)
-			nextLevel = (prevLevel & SC_FOLDLEVELNUMBERMASK) + 1;
-		else
-			nextLevel = prevLevel;
-
-		if ((nextLevel & SC_FOLDLEVELHEADERFLAG) && (nextLevel == prevLevel))
-			styler.SetLevel(curLine-1, prevLevel & ~SC_FOLDLEVELHEADERFLAG);
-
-		styler.SetLevel(curLine, nextLevel);
-		prevLevel = nextLevel;
-
-		curLineStart = styler.LineStart(++curLine);
-	} while (static_cast<int>(startPos) + length > curLineStart);
-}
-
-static void ColourisePoLine(
-    char *lineBuffer,
-    unsigned int lengthLine,
-    unsigned int startLine,
-    unsigned int endPos,
-    Accessor &styler) {
-
-	unsigned int i = 0;
-	static unsigned int state = SCE_PO_DEFAULT;
-	unsigned int state_start = SCE_PO_DEFAULT;
-
-	while ((i < lengthLine) && isspacechar(lineBuffer[i]))	// Skip initial spaces
-		i++;
-	if (i < lengthLine) {
-		if (lineBuffer[i] == '#') {
-			// check if the comment contains any flags ("#, ") and
-			// then whether the flags contain "fuzzy"
-			if (strstart(lineBuffer, "#, ") && strstr(lineBuffer, "fuzzy"))
-				styler.ColourTo(endPos, SCE_PO_FUZZY);
-			else
-				styler.ColourTo(endPos, SCE_PO_COMMENT);
-		} else {
-			if (lineBuffer[0] == '"') {
-				// line continuation, use previous style
-				styler.ColourTo(endPos, state);
-				return;
-			// this implicitly also matches "msgid_plural"
-			} else if (strstart(lineBuffer, "msgid")) {
-				state_start = SCE_PO_MSGID;
-				state = SCE_PO_MSGID_TEXT;
-			} else if (strstart(lineBuffer, "msgstr")) {
-				state_start = SCE_PO_MSGSTR;
-				state = SCE_PO_MSGSTR_TEXT;
-			} else if (strstart(lineBuffer, "msgctxt")) {
-				state_start = SCE_PO_MSGCTXT;
-				state = SCE_PO_MSGCTXT_TEXT;
-			}
-			if (state_start != SCE_PO_DEFAULT) {
-				// find the next space
-				while ((i < lengthLine) && ! isspacechar(lineBuffer[i]))
-					i++;
-				styler.ColourTo(startLine + i - 1, state_start);
-				styler.ColourTo(startLine + i, SCE_PO_DEFAULT);
-				styler.ColourTo(endPos, state);
-			}
-		}
-	} else {
-		styler.ColourTo(endPos, SCE_PO_DEFAULT);
-	}
-}
-
-static void ColourisePoDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
-	char lineBuffer[1024];
-	styler.StartAt(startPos);
-	styler.StartSegment(startPos);
-	unsigned int linePos = 0;
-	unsigned int startLine = startPos;
-	for (unsigned int i = startPos; i < startPos + length; i++) {
-		lineBuffer[linePos++] = styler[i];
-		if (AtEOL(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
-			// End of line (or of line buffer) met, colourise it
-			lineBuffer[linePos] = '\0';
-			ColourisePoLine(lineBuffer, linePos, startLine, i, styler);
-			linePos = 0;
-			startLine = i + 1;
-		}
-	}
-	if (linePos > 0) {	// Last line does not have ending characters
-		ColourisePoLine(lineBuffer, linePos, startLine, startPos + length - 1, styler);
-	}
-}
-
-
-static void ColourisePropsLine(
-    char *lineBuffer,
-    unsigned int lengthLine,
-    unsigned int startLine,
-    unsigned int endPos,
-    Accessor &styler) {
-
-	unsigned int i = 0;
-	while ((i < lengthLine) && isspacechar(lineBuffer[i]))	// Skip initial spaces
-		i++;
-	if (i < lengthLine) {
-		if (lineBuffer[i] == '#' || lineBuffer[i] == '!' || lineBuffer[i] == ';') {
-			styler.ColourTo(endPos, SCE_PROPS_COMMENT);
-		} else if (lineBuffer[i] == '[') {
-			styler.ColourTo(endPos, SCE_PROPS_SECTION);
-		} else if (lineBuffer[i] == '@') {
-			styler.ColourTo(startLine + i, SCE_PROPS_DEFVAL);
-			if (lineBuffer[++i] == '=')
-				styler.ColourTo(startLine + i, SCE_PROPS_ASSIGNMENT);
-			styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
-		} else {
-			// Search for the '=' character
-			while ((i < lengthLine) && (lineBuffer[i] != '='))
-				i++;
-			if ((i < lengthLine) && (lineBuffer[i] == '=')) {
-				styler.ColourTo(startLine + i - 1, SCE_PROPS_KEY);
-				styler.ColourTo(startLine + i, SCE_PROPS_ASSIGNMENT);
-				styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
-			} else {
-				styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
-			}
-		}
-	} else {
-		styler.ColourTo(endPos, SCE_PROPS_DEFAULT);
-	}
-}
-
-static void ColourisePropsDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
-	char lineBuffer[1024];
-	styler.StartAt(startPos);
-	styler.StartSegment(startPos);
-	unsigned int linePos = 0;
-	unsigned int startLine = startPos;
-	for (unsigned int i = startPos; i < startPos + length; i++) {
-		lineBuffer[linePos++] = styler[i];
-		if (AtEOL(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
-			// End of line (or of line buffer) met, colourise it
-			lineBuffer[linePos] = '\0';
-			ColourisePropsLine(lineBuffer, linePos, startLine, i, styler);
-			linePos = 0;
-			startLine = i + 1;
-		}
-	}
-	if (linePos > 0) {	// Last line does not have ending characters
-		ColourisePropsLine(lineBuffer, linePos, startLine, startPos + length - 1, styler);
-	}
-}
-
-// adaption by ksc, using the "} else {" trick of 1.53
-// 030721
-static void FoldPropsDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
-	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-
-	unsigned int endPos = startPos + length;
-	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
-
-	char chNext = styler[startPos];
-	int styleNext = styler.StyleAt(startPos);
-	bool headerPoint = false;
-	int lev;
-
-	for (unsigned int i = startPos; i < endPos; i++) {
-		char ch = chNext;
-		chNext = styler[i+1];
-
-		int style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
-		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
-
-		if (style == SCE_PROPS_SECTION) {
-			headerPoint = true;
-		}
-
-		if (atEOL) {
-			lev = SC_FOLDLEVELBASE;
-
-			if (lineCurrent > 0) {
-				int levelPrevious = styler.LevelAt(lineCurrent - 1);
-
-				if (levelPrevious & SC_FOLDLEVELHEADERFLAG) {
-					lev = SC_FOLDLEVELBASE + 1;
-				} else {
-					lev = levelPrevious & SC_FOLDLEVELNUMBERMASK;
-				}
-			}
-
-			if (headerPoint) {
-				lev = SC_FOLDLEVELBASE;
-			}
-			if (visibleChars == 0 && foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-
-			if (headerPoint) {
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			}
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
-
-			lineCurrent++;
-			visibleChars = 0;
-			headerPoint = false;
-		}
-		if (!isspacechar(ch))
-			visibleChars++;
-	}
-
-	if (lineCurrent > 0) {
-		int levelPrevious = styler.LevelAt(lineCurrent - 1);
-		if (levelPrevious & SC_FOLDLEVELHEADERFLAG) {
-			lev = SC_FOLDLEVELBASE + 1;
-		} else {
-			lev = levelPrevious & SC_FOLDLEVELNUMBERMASK;
-		}
-	} else {
-		lev = SC_FOLDLEVELBASE;
-	}
-	int flagsNext = styler.LevelAt(lineCurrent);
-	styler.SetLevel(lineCurrent, lev | flagsNext & ~SC_FOLDLEVELNUMBERMASK);
-}
-
-static void ColouriseMakeLine(
-    char *lineBuffer,
-    unsigned int lengthLine,
-    unsigned int startLine,
-    unsigned int endPos,
-    Accessor &styler) {
-
-	unsigned int i = 0;
-	int lastNonSpace = -1;
-	unsigned int state = SCE_MAKE_DEFAULT;
-	bool bSpecial = false;
-
-	// check for a tab character in column 0 indicating a command
-	bool bCommand = false;
-	if ((lengthLine > 0) && (lineBuffer[0] == '\t'))
-		bCommand = true;
-
-	// Skip initial spaces
-	while ((i < lengthLine) && isspacechar(lineBuffer[i])) {
-		i++;
-	}
-	if (lineBuffer[i] == '#') {	// Comment
-		styler.ColourTo(endPos, SCE_MAKE_COMMENT);
-		return;
-	}
-	if (lineBuffer[i] == '!') {	// Special directive
-		styler.ColourTo(endPos, SCE_MAKE_PREPROCESSOR);
-		return;
-	}
-	while (i < lengthLine) {
-		if (lineBuffer[i] == '$' && lineBuffer[i + 1] == '(') {
-			styler.ColourTo(startLine + i - 1, state);
-			state = SCE_MAKE_IDENTIFIER;
-		} else if (state == SCE_MAKE_IDENTIFIER && lineBuffer[i] == ')') {
-			styler.ColourTo(startLine + i, state);
-			state = SCE_MAKE_DEFAULT;
-		}
-
-		// skip identifier and target styling if this is a command line
-		if (!bSpecial && !bCommand) {
-			if (lineBuffer[i] == ':') {
-				if (((i + 1) < lengthLine) && (lineBuffer[i + 1] == '=')) {
-					// it's a ':=', so style as an identifier
-					if (lastNonSpace >= 0)
-						styler.ColourTo(startLine + lastNonSpace, SCE_MAKE_IDENTIFIER);
-					styler.ColourTo(startLine + i - 1, SCE_MAKE_DEFAULT);
-					styler.ColourTo(startLine + i + 1, SCE_MAKE_OPERATOR);
-				} else {
-					// We should check that no colouring was made since the beginning of the line,
-					// to avoid colouring stuff like /OUT:file
-					if (lastNonSpace >= 0)
-						styler.ColourTo(startLine + lastNonSpace, SCE_MAKE_TARGET);
-					styler.ColourTo(startLine + i - 1, SCE_MAKE_DEFAULT);
-					styler.ColourTo(startLine + i, SCE_MAKE_OPERATOR);
-				}
-				bSpecial = true;	// Only react to the first ':' of the line
-				state = SCE_MAKE_DEFAULT;
-			} else if (lineBuffer[i] == '=') {
-				if (lastNonSpace >= 0)
-					styler.ColourTo(startLine + lastNonSpace, SCE_MAKE_IDENTIFIER);
-				styler.ColourTo(startLine + i - 1, SCE_MAKE_DEFAULT);
-				styler.ColourTo(startLine + i, SCE_MAKE_OPERATOR);
-				bSpecial = true;	// Only react to the first '=' of the line
-				state = SCE_MAKE_DEFAULT;
-			}
-		}
-		if (!isspacechar(lineBuffer[i])) {
-			lastNonSpace = i;
-		}
-		i++;
-	}
-	if (state == SCE_MAKE_IDENTIFIER) {
-		styler.ColourTo(endPos, SCE_MAKE_IDEOL);	// Error, variable reference not ended
-	} else {
-		styler.ColourTo(endPos, SCE_MAKE_DEFAULT);
-	}
-}
-
-static void ColouriseMakeDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
-	char lineBuffer[1024];
-	styler.StartAt(startPos);
-	styler.StartSegment(startPos);
-	unsigned int linePos = 0;
-	unsigned int startLine = startPos;
-	for (unsigned int i = startPos; i < startPos + length; i++) {
-		lineBuffer[linePos++] = styler[i];
-		if (AtEOL(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
-			// End of line (or of line buffer) met, colourise it
-			lineBuffer[linePos] = '\0';
-			ColouriseMakeLine(lineBuffer, linePos, startLine, i, styler);
-			linePos = 0;
-			startLine = i + 1;
-		}
-	}
-	if (linePos > 0) {	// Last line does not have ending characters
-		ColouriseMakeLine(lineBuffer, linePos, startLine, startPos + length - 1, styler);
-	}
-}
-
-static int RecogniseErrorListLine(const char *lineBuffer, unsigned int lengthLine, int &startValue) {
-	if (lineBuffer[0] == '>') {
-		// Command or return status
-		return SCE_ERR_CMD;
-	} else if (lineBuffer[0] == '<') {
-		// Diff removal, but not interested. Trapped to avoid hitting CTAG cases.
-		return SCE_ERR_DEFAULT;
-	} else if (lineBuffer[0] == '!') {
-		return SCE_ERR_DIFF_CHANGED;
-	} else if (lineBuffer[0] == '+') {
-		if (strstart(lineBuffer, "+++ ")) {
-			return SCE_ERR_DIFF_MESSAGE;
-		} else {
-			return SCE_ERR_DIFF_ADDITION;
-		}
-	} else if (lineBuffer[0] == '-') {
-		if (strstart(lineBuffer, "--- ")) {
-			return SCE_ERR_DIFF_MESSAGE;
-		} else {
-			return SCE_ERR_DIFF_DELETION;
-		}
-	} else if (strstart(lineBuffer, "cf90-")) {
-		// Absoft Pro Fortran 90/95 v8.2 error and/or warning message
-		return SCE_ERR_ABSF;
-	} else if (strstart(lineBuffer, "fortcom:")) {
-		// Intel Fortran Compiler v8.0 error/warning message
-		return SCE_ERR_IFORT;
-	} else if (strstr(lineBuffer, "File \"") && strstr(lineBuffer, ", line ")) {
-		return SCE_ERR_PYTHON;
-	} else if (strstr(lineBuffer, " in ") && strstr(lineBuffer, " on line ")) {
-		return SCE_ERR_PHP;
-	} else if ((strstart(lineBuffer, "Error ") ||
-	            strstart(lineBuffer, "Warning ")) &&
-	           strstr(lineBuffer, " at (") &&
-	           strstr(lineBuffer, ") : ") &&
-	           (strstr(lineBuffer, " at (") < strstr(lineBuffer, ") : "))) {
-		// Intel Fortran Compiler error/warning message
-		return SCE_ERR_IFC;
-	} else if (strstart(lineBuffer, "Error ")) {
-		// Borland error message
-		return SCE_ERR_BORLAND;
-	} else if (strstart(lineBuffer, "Warning ")) {
-		// Borland warning message
-		return SCE_ERR_BORLAND;
-	} else if (strstr(lineBuffer, "at line " ) &&
-	           (strstr(lineBuffer, "at line " ) < (lineBuffer + lengthLine)) &&
-	           strstr(lineBuffer, "file ") &&
-	           (strstr(lineBuffer, "file ") < (lineBuffer + lengthLine))) {
-		// Lua 4 error message
-		return SCE_ERR_LUA;
-	} else if (strstr(lineBuffer, " at " ) &&
-	           (strstr(lineBuffer, " at " ) < (lineBuffer + lengthLine)) &&
-	           strstr(lineBuffer, " line ") &&
-	           (strstr(lineBuffer, " line ") < (lineBuffer + lengthLine)) &&
-	           (strstr(lineBuffer, " at " ) < (strstr(lineBuffer, " line ")))) {
-		// perl error message
-		return SCE_ERR_PERL;
-	} else if ((memcmp(lineBuffer, "   at ", 6) == 0) &&
-	           strstr(lineBuffer, ":line ")) {
-		// A .NET traceback
-		return SCE_ERR_NET;
-	} else if (strstart(lineBuffer, "Line ") &&
-	           strstr(lineBuffer, ", file ")) {
-		// Essential Lahey Fortran error message
-		return SCE_ERR_ELF;
-	} else if (strstart(lineBuffer, "line ") &&
-	           strstr(lineBuffer, " column ")) {
-		// HTML tidy style: line 42 column 1
-		return SCE_ERR_TIDY;
-	} else if (strstart(lineBuffer, "\tat ") &&
-	           strstr(lineBuffer, "(") &&
-	           strstr(lineBuffer, ".java:")) {
-		// Java stack back trace
-		return SCE_ERR_JAVA_STACK;
-	} else {
-		// Look for one of the following formats:
-		// GCC: <filename>:<line>:<message>
-		// Microsoft: <filename>(<line>) :<message>
-		// Common: <filename>(<line>): warning|error|note|remark|catastrophic|fatal
-		// Common: <filename>(<line>) warning|error|note|remark|catastrophic|fatal
-		// Microsoft: <filename>(<line>,<column>)<message>
-		// CTags: \t<message>
-		// Lua 5 traceback: \t<filename>:<line>:<message>
-		// Lua 5.1: <exe>: <filename>:<line>:<message>
-		bool initialTab = (lineBuffer[0] == '\t');
-		bool initialColonPart = false;
-		enum { stInitial,
-			stGccStart, stGccDigit, stGcc,
-			stMsStart, stMsDigit, stMsBracket, stMsVc, stMsDigitComma, stMsDotNet,
-			stCtagsStart, stCtagsStartString, stCtagsStringDollar, stCtags,
-			stUnrecognized
-		} state = stInitial;
-		for (unsigned int i = 0; i < lengthLine; i++) {
-			char ch = lineBuffer[i];
-			char chNext = ' ';
-			if ((i + 1) < lengthLine)
-				chNext = lineBuffer[i + 1];
-			if (state == stInitial) {
-				if (ch == ':') {
-					// May be GCC, or might be Lua 5 (Lua traceback same but with tab prefix)
-					if ((chNext != '\\') && (chNext != '/') && (chNext != ' ')) {
-						// This check is not completely accurate as may be on
-						// GTK+ with a file name that includes ':'.
-						state = stGccStart;
-					} else if (chNext == ' ') { // indicates a Lua 5.1 error message
-						initialColonPart = true;
-					}
-				} else if ((ch == '(') && Is1To9(chNext) && (!initialTab)) {
-					// May be Microsoft
-					// Check against '0' often removes phone numbers
-					state = stMsStart;
-				} else if ((ch == '\t') && (!initialTab)) {
-					// May be CTags
-					state = stCtagsStart;
-				}
-			} else if (state == stGccStart) {	// <filename>:
-				state = Is1To9(ch) ? stGccDigit : stUnrecognized;
-			} else if (state == stGccDigit) {	// <filename>:<line>
-				if (ch == ':') {
-					state = stGcc;	// :9.*: is GCC
-					startValue = i + 1;
-					break;
-				} else if (!Is0To9(ch)) {
-					state = stUnrecognized;
-				}
-			} else if (state == stMsStart) {	// <filename>(
-				state = Is0To9(ch) ? stMsDigit : stUnrecognized;
-			} else if (state == stMsDigit) {	// <filename>(<line>
-				if (ch == ',') {
-					state = stMsDigitComma;
-				} else if (ch == ')') {
-					state = stMsBracket;
-				} else if ((ch != ' ') && !Is0To9(ch)) {
-					state = stUnrecognized;
-				}
-			} else if (state == stMsBracket) {	// <filename>(<line>)
-				if ((ch == ' ') && (chNext == ':')) {
-					state = stMsVc;
-				} else if ((ch == ':' && chNext == ' ') || (ch == ' ')) {
-					// Possibly Delphi.. don't test against chNext as it's one of the strings below.
-					char word[512];
-					unsigned int j, chPos;
-					unsigned numstep;
-					chPos = 0;
-					if (ch == ' ')
-						numstep = 1; // ch was ' ', handle as if it's a delphi errorline, only add 1 to i.
-					else
-						numstep = 2; // otherwise add 2.
-					for (j = i + numstep; j < lengthLine && isalpha(lineBuffer[j]) && chPos < sizeof(word) - 1; j++)
-						word[chPos++] = lineBuffer[j];
-					word[chPos] = 0;
-					if (!CompareCaseInsensitive(word, "error") || !CompareCaseInsensitive(word, "warning") ||
-						!CompareCaseInsensitive(word, "fatal") || !CompareCaseInsensitive(word, "catastrophic") ||
-						!CompareCaseInsensitive(word, "note") || !CompareCaseInsensitive(word, "remark")) {
-						state = stMsVc;
-					} else
-						state = stUnrecognized;
-				} else {
-					state = stUnrecognized;
-				}
-			} else if (state == stMsDigitComma) {	// <filename>(<line>,
-				if (ch == ')') {
-					state = stMsDotNet;
-					break;
-				} else if ((ch != ' ') && !Is0To9(ch)) {
-					state = stUnrecognized;
-				}
-			} else if (state == stCtagsStart) {
-				if ((lineBuffer[i - 1] == '\t') &&
-				        ((ch == '/' && lineBuffer[i + 1] == '^') || Is0To9(ch))) {
-					state = stCtags;
-					break;
-				} else if ((ch == '/') && (lineBuffer[i + 1] == '^')) {
-					state = stCtagsStartString;
-				}
-			} else if ((state == stCtagsStartString) && ((lineBuffer[i] == '$') && (lineBuffer[i + 1] == '/'))) {
-				state = stCtagsStringDollar;
-				break;
-			}
-		}
-		if (state == stGcc) {
-			return initialColonPart ? SCE_ERR_LUA : SCE_ERR_GCC;
-		} else if ((state == stMsVc) || (state == stMsDotNet)) {
-			return SCE_ERR_MS;
-		} else if ((state == stCtagsStringDollar) || (state == stCtags)) {
-			return SCE_ERR_CTAG;
-		} else {
-			return SCE_ERR_DEFAULT;
-		}
-	}
-}
-
-static void ColouriseErrorListLine(
-    char *lineBuffer,
-    unsigned int lengthLine,
-    unsigned int endPos,
-    Accessor &styler,
-	bool valueSeparate) {
-	int startValue = -1;
-	int style = RecogniseErrorListLine(lineBuffer, lengthLine, startValue);
-	if (valueSeparate && (startValue >= 0)) {
-		styler.ColourTo(endPos - (lengthLine - startValue), style);
-		styler.ColourTo(endPos, SCE_ERR_VALUE);
-	} else {
-		styler.ColourTo(endPos, style);
-	}
-}
-
-static void ColouriseErrorListDoc(unsigned int startPos, int length, int, WordList *[], Accessor &styler) {
-	char lineBuffer[10000];
-	styler.StartAt(startPos);
-	styler.StartSegment(startPos);
-	unsigned int linePos = 0;
-	bool valueSeparate = styler.GetPropertyInt("lexer.errorlist.value.separate", 0) != 0;
-	for (unsigned int i = startPos; i < startPos + length; i++) {
-		lineBuffer[linePos++] = styler[i];
-		if (AtEOL(styler, i) || (linePos >= sizeof(lineBuffer) - 1)) {
-			// End of line (or of line buffer) met, colourise it
-			lineBuffer[linePos] = '\0';
-			ColouriseErrorListLine(lineBuffer, linePos, i, styler, valueSeparate);
-			linePos = 0;
-		}
-	}
-	if (linePos > 0) {	// Last line does not have ending characters
-		ColouriseErrorListLine(lineBuffer, linePos, startPos + length - 1, styler, valueSeparate);
-	}
-}
-
-static int isSpecial(char s) {
-	return (s == '\\') || (s == ',') || (s == ';') || (s == '\'') || (s == ' ') ||
-	       (s == '\"') || (s == '`') || (s == '^') || (s == '~');
-}
-
-static int isTag(int start, Accessor &styler) {
-	char s[6];
-	unsigned int i = 0, e = 1;
-	while (i < 5 && e) {
-		s[i] = styler[start + i];
-		i++;
-		e = styler[start + i] != '{';
-	}
-	s[i] = '\0';
-	return (strcmp(s, "begin") == 0) || (strcmp(s, "end") == 0);
-}
-
-static void ColouriseLatexDoc(unsigned int startPos, int length, int initStyle,
-                              WordList *[], Accessor &styler) {
-
-	styler.StartAt(startPos);
-
-	int state = initStyle;
-	char chNext = styler[startPos];
-	styler.StartSegment(startPos);
-	int lengthDoc = startPos + length;
-
-	for (int i = startPos; i < lengthDoc; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-
-		if (styler.IsLeadByte(ch)) {
-			chNext = styler.SafeGetCharAt(i + 2);
-			i++;
-			continue;
-		}
-		switch (state) {
-		case SCE_L_DEFAULT :
-			switch (ch) {
-			case '\\' :
-				styler.ColourTo(i - 1, state);
-				if (isSpecial(styler[i + 1])) {
-					styler.ColourTo(i + 1, SCE_L_COMMAND);
-					i++;
-					chNext = styler.SafeGetCharAt(i + 1);
-				} else {
-					if (isTag(i + 1, styler))
-						state = SCE_L_TAG;
-					else
-						state = SCE_L_COMMAND;
-				}
-				break;
-			case '$' :
-				styler.ColourTo(i - 1, state);
-				state = SCE_L_MATH;
-				if (chNext == '$') {
-					i++;
-					chNext = styler.SafeGetCharAt(i + 1);
-				}
-				break;
-			case '%' :
-				styler.ColourTo(i - 1, state);
-				state = SCE_L_COMMENT;
-				break;
-			}
-			break;
-		case SCE_L_COMMAND :
-			if (chNext == '[' || chNext == '{' || chNext == '}' ||
-			        chNext == ' ' || chNext == '\r' || chNext == '\n') {
-				styler.ColourTo(i, state);
-				state = SCE_L_DEFAULT;
-				i++;
-				chNext = styler.SafeGetCharAt(i + 1);
-			}
-			break;
-		case SCE_L_TAG :
-			if (ch == '}') {
-				styler.ColourTo(i, state);
-				state = SCE_L_DEFAULT;
-			}
-			break;
-		case SCE_L_MATH :
-			if (ch == '$') {
-				if (chNext == '$') {
-					i++;
-					chNext = styler.SafeGetCharAt(i + 1);
-				}
-				styler.ColourTo(i, state);
-				state = SCE_L_DEFAULT;
-			}
-			break;
-		case SCE_L_COMMENT :
-			if (ch == '\r' || ch == '\n') {
-				styler.ColourTo(i - 1, state);
-				state = SCE_L_DEFAULT;
-			}
-		}
-	}
-	styler.ColourTo(lengthDoc-1, state);
-}
-
-static const char * const batchWordListDesc[] = {
-	"Internal Commands",
-	"External Commands",
-	0
-};
-
-static const char * const emptyWordListDesc[] = {
-	0
-};
-
-static void ColouriseNullDoc(unsigned int startPos, int length, int, WordList *[],
-                            Accessor &styler) {
-	// Null language means all style bytes are 0 so just mark the end - no need to fill in.
-	if (length > 0) {
-		styler.StartAt(startPos + length - 1);
-		styler.StartSegment(startPos + length - 1);
-		styler.ColourTo(startPos + length - 1, 0);
-	}
-}
-
-LexerModule lmBatch(SCLEX_BATCH, ColouriseBatchDoc, "batch", 0, batchWordListDesc);
-LexerModule lmDiff(SCLEX_DIFF, ColouriseDiffDoc, "diff", FoldDiffDoc, emptyWordListDesc);
-LexerModule lmPo(SCLEX_PO, ColourisePoDoc, "po", 0, emptyWordListDesc);
-LexerModule lmProps(SCLEX_PROPERTIES, ColourisePropsDoc, "props", FoldPropsDoc, emptyWordListDesc);
-LexerModule lmMake(SCLEX_MAKEFILE, ColouriseMakeDoc, "makefile", 0, emptyWordListDesc);
-LexerModule lmErrorList(SCLEX_ERRORLIST, ColouriseErrorListDoc, "errorlist", 0, emptyWordListDesc);
-LexerModule lmLatex(SCLEX_LATEX, ColouriseLatexDoc, "latex", 0, emptyWordListDesc);
-LexerModule lmNull(SCLEX_NULL, ColouriseNullDoc, "null");
diff --git a/Pythonwin/Scintilla/src/LexPerl.cxx b/Pythonwin/Scintilla/src/LexPerl.cxx
deleted file mode 100644
index f57f73c29..000000000
--- a/Pythonwin/Scintilla/src/LexPerl.cxx
+++ /dev/null
@@ -1,1295 +0,0 @@
-// Scintilla source code edit control
-/** @file LexPerl.cxx
- ** Lexer for Perl.
- **/
-// Copyright 1998-2008 by Neil Hodgson <neilh@scintilla.org>
-// Lexical analysis fixes by Kein-Hong Man <mkh@pl.jaring.my>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-#include "CharacterSet.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-// Info for HERE document handling from perldata.pod (reformatted):
-// ----------------------------------------------------------------
-// A line-oriented form of quoting is based on the shell ``here-doc'' syntax.
-// Following a << you specify a string to terminate the quoted material, and
-// all lines following the current line down to the terminating string are
-// the value of the item.
-// * The terminating string may be either an identifier (a word), or some
-//   quoted text.
-// * If quoted, the type of quotes you use determines the treatment of the
-//   text, just as in regular quoting.
-// * An unquoted identifier works like double quotes.
-// * There must be no space between the << and the identifier.
-//   (If you put a space it will be treated as a null identifier,
-//    which is valid, and matches the first empty line.)
-//   (This is deprecated, -w warns of this syntax)
-// * The terminating string must appear by itself (unquoted and
-//   with no surrounding whitespace) on the terminating line.
-
-#define HERE_DELIM_MAX 256		// maximum length of HERE doc delimiter
-
-#define PERLNUM_BINARY		1	// order is significant: 1-4 cannot have a dot
-#define PERLNUM_HEX			2
-#define PERLNUM_OCTAL		3
-#define PERLNUM_FLOAT_EXP	4	// exponent part only
-#define PERLNUM_DECIMAL		5	// 1-5 are numbers; 6-7 are strings
-#define PERLNUM_VECTOR		6
-#define PERLNUM_V_VECTOR	7
-#define PERLNUM_BAD			8
-
-#define BACK_NONE		0	// lookback state for bareword disambiguation:
-#define BACK_OPERATOR	1	// whitespace/comments are insignificant
-#define BACK_KEYWORD	2	// operators/keywords are needed for disambiguation
-
-static bool isPerlKeyword(unsigned int start, unsigned int end, WordList &keywords, Accessor &styler)
-{
-	// old-style keyword matcher; needed because GetCurrent() needs
-	// current segment to be committed, but we may abandon early...
-	char s[100];
-	unsigned int i, len = end - start;
-	if (len > 30) { len = 30; }
-	for (i = 0; i < len; i++, start++) s[i] = styler[start];
-	s[i] = '\0';
-	return keywords.InList(s);
-}
-
-static int disambiguateBareword(Accessor &styler, unsigned int bk, unsigned int fw,
-                                int backFlag, unsigned int backPos, unsigned int endPos)
-{
-	// identifiers are recognized by Perl as barewords under some
-	// conditions, the following attempts to do the disambiguation
-	// by looking backward and forward; result in 2 LSB
-	int result = 0;
-	bool moreback = false;		// true if passed newline/comments
-	bool brace = false;			// true if opening brace found
-	// if BACK_NONE, neither operator nor keyword, so skip test
-	if (backFlag == BACK_NONE)
-		return result;
-	// first look backwards past whitespace/comments to set EOL flag
-	// (some disambiguation patterns must be on a single line)
-	if (backPos <= static_cast<unsigned int>(styler.LineStart(styler.GetLine(bk))))
-		moreback = true;
-	// look backwards at last significant lexed item for disambiguation
-	bk = backPos - 1;
-	int ch = static_cast<unsigned char>(styler.SafeGetCharAt(bk));
-	if (ch == '{' && !moreback) {
-		// {bareword: possible variable spec
-		brace = true;
-	} else if ((ch == '&' && styler.SafeGetCharAt(bk - 1) != '&')
-			// &bareword: subroutine call
-			   || styler.Match(bk - 1, "->")
-			// ->bareword: part of variable spec
-			   || styler.Match(bk - 2, "sub")) {
-			// sub bareword: subroutine declaration
-			// (implied BACK_KEYWORD, no keywords end in 'sub'!)
-		result |= 1;
-	}
-	// next, scan forward after word past tab/spaces only;
-	// if ch isn't one of '[{(,' we can skip the test
-	if ((ch == '{' || ch == '(' || ch == '['|| ch == ',')
-		&& fw < endPos) {
-		while (ch = static_cast<unsigned char>(styler.SafeGetCharAt(fw)),
-			   IsASpaceOrTab(ch) && fw < endPos) {
-			fw++;
-		}
-		if ((ch == '}' && brace)
-			// {bareword}: variable spec
-			|| styler.Match(fw, "=>")) {
-			// [{(, bareword=>: hash literal
-			result |= 2;
-		}
-	}
-	return result;
-}
-
-static void skipWhitespaceComment(Accessor &styler, unsigned int &p)
-{
-	// when backtracking, we need to skip whitespace and comments
-	int style;
-	while ((p > 0) && (style = styler.StyleAt(p),
-		   style == SCE_PL_DEFAULT || style == SCE_PL_COMMENTLINE))
-		p--;
-}
-
-static int styleBeforeBracePair(Accessor &styler, unsigned int bk)
-{
-	// backtrack to find open '{' corresponding to a '}', balanced
-	// return significant style to be tested for '/' disambiguation
-	int braceCount = 1;
-	if (bk == 0)
-		return SCE_PL_DEFAULT;
-	while (--bk > 0) {
-		if (styler.StyleAt(bk) == SCE_PL_OPERATOR) {
-			int bkch = static_cast<unsigned char>(styler.SafeGetCharAt(bk));
-			if (bkch == ';') {	// early out
-				break;
-			} else if (bkch == '}') {
-				braceCount++;
-			} else if (bkch == '{') {
-				if (--braceCount == 0) break;
-			}
-		}
-	}
-	if (bk > 0 && braceCount == 0) {
-		// balanced { found, bk > 0, skip more whitespace/comments
-		bk--;
-		skipWhitespaceComment(styler, bk);
-		return styler.StyleAt(bk);
-	}
-	return SCE_PL_DEFAULT;
-}
-
-static int styleCheckIdentifier(Accessor &styler, unsigned int bk)
-{
-	// backtrack to classify sub-styles of identifier under test
-	// return sub-style to be tested for '/' disambiguation
-	if (styler.SafeGetCharAt(bk) == '>')	// inputsymbol, like <foo>
-		return 1;
-	// backtrack to check for possible "->" or "::" before identifier
-	while (bk > 0 && styler.StyleAt(bk) == SCE_PL_IDENTIFIER) {
-		bk--;
-	}
-	while (bk > 0) {
-		int bkstyle = styler.StyleAt(bk);
-		if (bkstyle == SCE_PL_DEFAULT
-			|| bkstyle == SCE_PL_COMMENTLINE) {
-			// skip whitespace, comments
-		} else if (bkstyle == SCE_PL_OPERATOR) {
-			// test for "->" and "::"
-			if (styler.Match(bk - 1, "->") || styler.Match(bk - 1, "::"))
-				return 2;
-		} else
-			return 3;	// bare identifier
-		bk--;
-	}
-	return 0;
-}
-
-static int inputsymbolScan(Accessor &styler, unsigned int pos, unsigned int endPos)
-{
-	// looks forward for matching > on same line; a bit ugly
-	unsigned int fw = pos;
-	while (++fw < endPos) {
-		int fwch = static_cast<unsigned char>(styler.SafeGetCharAt(fw));
-		if (fwch == '\r' || fwch == '\n') {
-			return 0;
-		} else if (fwch == '>') {
-			if (styler.Match(fw - 2, "<=>"))	// '<=>' case
-				return 0;
-			return fw - pos;
-		}
-	}
-	return 0;
-}
-
-static int podLineScan(Accessor &styler, unsigned int &pos, unsigned int endPos)
-{
-	// forward scan the current line to classify line for POD style
-	int state = -1;
-	while (pos <= endPos) {
-		int ch = static_cast<unsigned char>(styler.SafeGetCharAt(pos));
-		if (ch == '\n' || ch == '\r' || pos >= endPos) {
-			if (ch == '\r' && styler.SafeGetCharAt(pos + 1) == '\n') pos++;
-			break;
-		}
-		if (IsASpaceOrTab(ch)) {	// whitespace, take note
-			if (state == -1)
-				state = SCE_PL_DEFAULT;
-		} else if (state == SCE_PL_DEFAULT) {	// verbatim POD line
-			state = SCE_PL_POD_VERB;
-		} else if (state != SCE_PL_POD_VERB) {	// regular POD line
-			state = SCE_PL_POD;
-		}
-		pos++;
-	}
-	if (state == -1)
-		state = SCE_PL_DEFAULT;
-	return state;
-}
-
-static bool styleCheckSubPrototype(Accessor &styler, unsigned int bk)
-{
-	// backtrack to identify if we're starting a subroutine prototype
-	// we also need to ignore whitespace/comments:
-	// 'sub' [whitespace|comment] <identifier> [whitespace|comment]
-	styler.Flush();
-	skipWhitespaceComment(styler, bk);
-	if (bk == 0 || styler.StyleAt(bk) != SCE_PL_IDENTIFIER)	// check identifier
-		return false;
-	while (bk > 0 && (styler.StyleAt(bk) == SCE_PL_IDENTIFIER)) {
-		bk--;
-	}
-	skipWhitespaceComment(styler, bk);
-	if (bk < 2 || styler.StyleAt(bk) != SCE_PL_WORD	// check "sub" keyword
-		|| !styler.Match(bk - 2, "sub"))	// assume suffix is unique!
-		return false;
-	return true;
-}
-
-static bool isMatch(const char *sref, char *s)
-{
-	// match per-line delimiter - must kill trailing CR if CRLF
-	if (s[strlen(s) - 1] == '\r')
-		s[strlen(s) - 1] = '\0';
-	return (strcmp(sref, s) == 0);
-}
-
-static int actualNumStyle(int numberStyle) {
-	if (numberStyle == PERLNUM_VECTOR || numberStyle == PERLNUM_V_VECTOR) {
-		return SCE_PL_STRING;
-	} else if (numberStyle == PERLNUM_BAD) {
-		return SCE_PL_ERROR;
-	}
-	return SCE_PL_NUMBER;
-}
-
-static int opposite(int ch) {
-	if (ch == '(') return ')';
-	if (ch == '[') return ']';
-	if (ch == '{') return '}';
-	if (ch == '<') return '>';
-	return ch;
-}
-
-static void ColourisePerlDoc(unsigned int startPos, int length, int initStyle,
-                             WordList *keywordlists[], Accessor &styler) {
-
-	WordList &keywords = *keywordlists[0];
-
-	// keywords that forces /PATTERN/ at all times; should track vim's behaviour
-	WordList reWords;
-	reWords.Set("elsif if split while");
-
-	// charset classes
-	CharacterSet setWordStart(CharacterSet::setAlpha, "_", 0x80, true);
-	CharacterSet setWord(CharacterSet::setAlphaNum, "_", 0x80, true);
-	CharacterSet setSingleCharOp(CharacterSet::setNone, "rwxoRWXOezsfdlpSbctugkTBMAC");
-	// lexing of "%*</" operators is non-trivial; these are missing in the set below
-	CharacterSet setPerlOperator(CharacterSet::setNone, "^&\\()-+=|{}[]:;>,?!.~");
-	CharacterSet setQDelim(CharacterSet::setNone, "qrwx");
-	CharacterSet setModifiers(CharacterSet::setAlpha);
-	CharacterSet setPreferRE(CharacterSet::setNone, "*/<%");
-	// setArray and setHash also accepts chars for special vars like $_,
-	// which are then truncated when the next char does not match setVar
-	CharacterSet setVar(CharacterSet::setAlphaNum, "#$_'", 0x80, true);
-	CharacterSet setArray(CharacterSet::setAlpha, "#$_+-", 0x80, true);
-	CharacterSet setHash(CharacterSet::setAlpha, "#$_!^+-", 0x80, true);
-	CharacterSet &setPOD = setModifiers;
-	CharacterSet setNonHereDoc(CharacterSet::setDigits, "=$@");
-	CharacterSet setHereDocDelim(CharacterSet::setAlphaNum, "_");
-	CharacterSet setSubPrototype(CharacterSet::setNone, "\\[$@%&*];");
-	// for format identifiers
-	CharacterSet setFormatStart(CharacterSet::setAlpha, "_=");
-	CharacterSet &setFormat = setHereDocDelim;
-
-	// Lexer for perl often has to backtrack to start of current style to determine
-	// which characters are being used as quotes, how deeply nested is the
-	// start position and what the termination string is for HERE documents.
-
-	class HereDocCls {	// Class to manage HERE doc sequence
-	public:
-		int State;		// 0: '<<' encountered
-						// 1: collect the delimiter
-						// 2: here doc text (lines after the delimiter)
-		int Quote;		// the char after '<<'
-		bool Quoted;		// true if Quote in ('\'','"','`')
-		int DelimiterLength;	// strlen(Delimiter)
-		char *Delimiter;	// the Delimiter, 256: sizeof PL_tokenbuf
-		HereDocCls() {
-			State = 0;
-			Quote = 0;
-			Quoted = false;
-			DelimiterLength = 0;
-			Delimiter = new char[HERE_DELIM_MAX];
-			Delimiter[0] = '\0';
-		}
-		void Append(int ch) {
-			Delimiter[DelimiterLength++] = static_cast<char>(ch);
-			Delimiter[DelimiterLength] = '\0';
-		}
-		~HereDocCls() {
-			delete []Delimiter;
-		}
-	};
-	HereDocCls HereDoc;		// TODO: FIFO for stacked here-docs
-
-	class QuoteCls {	// Class to manage quote pairs
-		public:
-		int Rep;
-		int Count;
-		int Up, Down;
-		QuoteCls() {
-			this->New(1);
-		}
-		void New(int r = 1) {
-			Rep   = r;
-			Count = 0;
-			Up    = '\0';
-			Down  = '\0';
-		}
-		void Open(int u) {
-			Count++;
-			Up    = u;
-			Down  = opposite(Up);
-		}
-	};
-	QuoteCls Quote;
-
-	// additional state for number lexing
-	int numState = PERLNUM_DECIMAL;
-	int dotCount = 0;
-
-	unsigned int endPos = startPos + length;
-
-	// Backtrack to beginning of style if required...
-	// If in a long distance lexical state, backtrack to find quote characters.
-	// Includes strings (may be multi-line), numbers (additional state), format
-	// bodies, as well as POD sections.
-	if (initStyle == SCE_PL_HERE_Q
-		|| initStyle == SCE_PL_HERE_QQ
-		|| initStyle == SCE_PL_HERE_QX
-		|| initStyle == SCE_PL_FORMAT
-	) {
-		int delim = (initStyle == SCE_PL_FORMAT) ? SCE_PL_FORMAT_IDENT:SCE_PL_HERE_DELIM;
-		while ((startPos > 1) && (styler.StyleAt(startPos) != delim)) {
-			startPos--;
-		}
-		startPos = styler.LineStart(styler.GetLine(startPos));
-		initStyle = styler.StyleAt(startPos - 1);
-	}
-	if (initStyle == SCE_PL_STRING_Q
-		|| initStyle == SCE_PL_STRING_QQ
-		|| initStyle == SCE_PL_STRING_QX
-		|| initStyle == SCE_PL_STRING_QR
-		|| initStyle == SCE_PL_STRING_QW
-		|| initStyle == SCE_PL_REGEX
-		|| initStyle == SCE_PL_REGSUBST
-		|| initStyle == SCE_PL_STRING
-		|| initStyle == SCE_PL_BACKTICKS
-		|| initStyle == SCE_PL_CHARACTER
-		|| initStyle == SCE_PL_NUMBER
-		|| initStyle == SCE_PL_IDENTIFIER
-		|| initStyle == SCE_PL_ERROR
-		|| initStyle == SCE_PL_SUB_PROTOTYPE
-	) {
-		while ((startPos > 1) && (styler.StyleAt(startPos - 1) == initStyle)) {
-			startPos--;
-		}
-		initStyle = SCE_PL_DEFAULT;
-	} else if (initStyle == SCE_PL_POD
-			   || initStyle == SCE_PL_POD_VERB
-	) {
-		// POD backtracking finds preceeding blank lines and goes back past them
-		int ln = styler.GetLine(startPos);
-		if (ln > 0) {
-			initStyle = styler.StyleAt(styler.LineStart(--ln));
-			if (initStyle == SCE_PL_POD || initStyle == SCE_PL_POD_VERB) {
-				while (ln > 0 && styler.GetLineState(ln) == SCE_PL_DEFAULT)
-					ln--;
-			}
-			startPos = styler.LineStart(++ln);
-			initStyle = styler.StyleAt(startPos - 1);
-		} else {
-			startPos = 0;
-			initStyle = SCE_PL_DEFAULT;
-		}
-	}
-
-	// backFlag, backPos are additional state to aid identifier corner cases.
-	// Look backwards past whitespace and comments in order to detect either
-	// operator or keyword. Later updated as we go along.
-	int backFlag = BACK_NONE;
-	unsigned int backPos = startPos;
-	if (backPos > 0) {
-		backPos--;
-		skipWhitespaceComment(styler, backPos);
-		if (styler.StyleAt(backPos) == SCE_PL_OPERATOR)
-			backFlag = BACK_OPERATOR;
-		else if (styler.StyleAt(backPos) == SCE_PL_WORD)
-			backFlag = BACK_KEYWORD;
-		backPos++;
-	}
-
-	StyleContext sc(startPos, endPos - startPos, initStyle, styler, static_cast<char>(STYLE_MAX));
-
-	for (; sc.More(); sc.Forward()) {
-
-		// Determine if the current state should terminate.
-		switch (sc.state) {
-			case SCE_PL_OPERATOR:
-				sc.SetState(SCE_PL_DEFAULT);
-				backFlag = BACK_OPERATOR;
-				backPos = sc.currentPos;
-				break;
-			case SCE_PL_IDENTIFIER:		// identifier, bareword, inputsymbol
-				if ((!setWord.Contains(sc.ch) && sc.ch != '\'')
-					|| sc.Match('.', '.')
-					|| sc.chPrev == '>') {	// end of inputsymbol
-					sc.SetState(SCE_PL_DEFAULT);
-				}
-				break;
-			case SCE_PL_WORD:		// keyword, plus special cases
-				if (!setWord.Contains(sc.ch)) {
-					char s[100];
-					sc.GetCurrent(s, sizeof(s));
-					if ((strcmp(s, "__DATA__") == 0) || (strcmp(s, "__END__") == 0)) {
-						sc.ChangeState(SCE_PL_DATASECTION);
-					} else {
-						if ((strcmp(s, "format") == 0)) {
-							sc.SetState(SCE_PL_FORMAT_IDENT);
-							HereDoc.State = 0;
-						} else {
-							sc.SetState(SCE_PL_DEFAULT);
-						}
-						backFlag = BACK_KEYWORD;
-						backPos = sc.currentPos;
-					}
-				}
-				break;
-			case SCE_PL_SCALAR:
-			case SCE_PL_ARRAY:
-			case SCE_PL_HASH:
-			case SCE_PL_SYMBOLTABLE:
-				if (sc.Match(':', ':')) {	// skip ::
-					sc.Forward();
-				} else if (!setVar.Contains(sc.ch)) {
-					if (sc.LengthCurrent() == 1) {
-						// Special variable: $(, $_ etc.
-						sc.Forward();
-					}
-					sc.SetState(SCE_PL_DEFAULT);
-				}
-				break;
-			case SCE_PL_NUMBER:
-				// if no early break, number style is terminated at "(go through)"
-				if (sc.ch == '.') {
-					if (sc.chNext == '.') {
-						// double dot is always an operator (go through)
-					} else if (numState <= PERLNUM_FLOAT_EXP) {
-						// non-decimal number or float exponent, consume next dot
-						sc.SetState(SCE_PL_OPERATOR);
-						break;
-					} else {	// decimal or vectors allows dots
-						dotCount++;
-						if (numState == PERLNUM_DECIMAL) {
-							if (dotCount <= 1)	// number with one dot in it
-								break;
-							if (IsADigit(sc.chNext)) {	// really a vector
-								numState = PERLNUM_VECTOR;
-								break;
-							}
-							// number then dot (go through)
-						} else if (IsADigit(sc.chNext))	// vectors
-							break;
-						// vector then dot (go through)
-					}
-				} else if (sc.ch == '_') {
-					// permissive underscoring for number and vector literals
-					break;
-				} else if (numState == PERLNUM_DECIMAL) {
-					if (sc.ch == 'E' || sc.ch == 'e') {	// exponent, sign
-						numState = PERLNUM_FLOAT_EXP;
-						if (sc.chNext == '+' || sc.chNext == '-') {
-							sc.Forward();
-						}
-						break;
-					} else if (IsADigit(sc.ch))
-						break;
-					// number then word (go through)
-				} else if (numState == PERLNUM_HEX) {
-					if (IsADigit(sc.ch, 16))
-						break;
-				} else if (numState == PERLNUM_VECTOR || numState == PERLNUM_V_VECTOR) {
-					if (IsADigit(sc.ch))	// vector
-						break;
-					if (setWord.Contains(sc.ch) && dotCount == 0) {	// change to word
-						sc.ChangeState(SCE_PL_IDENTIFIER);
-						break;
-					}
-					// vector then word (go through)
-				} else if (IsADigit(sc.ch)) {
-					if (numState == PERLNUM_FLOAT_EXP) {
-						break;
-					} else if (numState == PERLNUM_OCTAL) {
-						if (sc.ch <= '7') break;
-					} else if (numState == PERLNUM_BINARY) {
-						if (sc.ch <= '1') break;
-					}
-					// mark invalid octal, binary numbers (go through)
-					numState = PERLNUM_BAD;
-					break;
-				}
-				// complete current number or vector
-				sc.ChangeState(actualNumStyle(numState));
-				sc.SetState(SCE_PL_DEFAULT);
-				break;
-			case SCE_PL_COMMENTLINE:
-				if (sc.atLineEnd) {
-					sc.SetState(SCE_PL_DEFAULT);
-				}
-				break;
-			case SCE_PL_HERE_DELIM:
-				if (HereDoc.State == 0) { // '<<' encountered
-					int delim_ch = sc.chNext;
-					int ws_skip = 0;
-					HereDoc.State = 1;	// pre-init HERE doc class
-					HereDoc.Quote = sc.chNext;
-					HereDoc.Quoted = false;
-					HereDoc.DelimiterLength = 0;
-					HereDoc.Delimiter[HereDoc.DelimiterLength] = '\0';
-					if (IsASpaceOrTab(delim_ch)) {
-						// skip whitespace; legal only for quoted delimiters
-						unsigned int i = sc.currentPos + 1;
-						while ((i < endPos) && IsASpaceOrTab(delim_ch)) {
-							i++;
-							delim_ch = static_cast<unsigned char>(styler.SafeGetCharAt(i));
-						}
-						ws_skip = i - sc.currentPos - 1;
-					}
-					if (delim_ch == '\'' || delim_ch == '"' || delim_ch == '`') {
-						// a quoted here-doc delimiter; skip any whitespace
-						sc.Forward(ws_skip + 1);
-						HereDoc.Quote = delim_ch;
-						HereDoc.Quoted = true;
-					} else if (ws_skip == 0 && setNonHereDoc.Contains(sc.chNext)
-							   || ws_skip > 0) {
-						// left shift << or <<= operator cases
-						// restore position if operator
-						sc.ChangeState(SCE_PL_OPERATOR);
-						sc.ForwardSetState(SCE_PL_DEFAULT);
-						backFlag = BACK_OPERATOR;
-						backPos = sc.currentPos;
-						HereDoc.State = 0;
-					} else {
-						// specially handle initial '\' for identifier
-						if (ws_skip == 0 && HereDoc.Quote == '\\')
-							sc.Forward();
-						// an unquoted here-doc delimiter, no special handling
-						// (cannot be prefixed by spaces/tabs), or
-						// symbols terminates; deprecated zero-length delimiter
-					}
-				} else if (HereDoc.State == 1) { // collect the delimiter
-					backFlag = BACK_NONE;
-					if (HereDoc.Quoted) { // a quoted here-doc delimiter
-						if (sc.ch == HereDoc.Quote) { // closing quote => end of delimiter
-							sc.ForwardSetState(SCE_PL_DEFAULT);
-						} else if (!sc.atLineEnd) {
-							if (sc.Match('\\', static_cast<char>(HereDoc.Quote))) { // escaped quote
-								sc.Forward();
-							}
-							if (sc.ch != '\r') {	// skip CR if CRLF
-								HereDoc.Append(sc.ch);
-							}
-						}
-					} else { // an unquoted here-doc delimiter
-						if (setHereDocDelim.Contains(sc.ch)) {
-							HereDoc.Append(sc.ch);
-						} else {
-							sc.SetState(SCE_PL_DEFAULT);
-						}
-					}
-					if (HereDoc.DelimiterLength >= HERE_DELIM_MAX - 1) {
-						sc.SetState(SCE_PL_ERROR);
-						HereDoc.State = 0;
-					}
-				}
-				break;
-			case SCE_PL_HERE_Q:
-			case SCE_PL_HERE_QQ:
-			case SCE_PL_HERE_QX: {
-				// also implies HereDoc.State == 2
-				sc.Complete();
-				while (!sc.atLineEnd)
-					sc.Forward();
-				char s[HERE_DELIM_MAX];
-				sc.GetCurrent(s, sizeof(s));
-				if (isMatch(HereDoc.Delimiter, s)) {
-					sc.SetState(SCE_PL_DEFAULT);
-					backFlag = BACK_NONE;
-					HereDoc.State = 0;
-				}
-				} break;
-			case SCE_PL_POD:
-			case SCE_PL_POD_VERB: {
-				unsigned int fw = sc.currentPos;
-				int ln = styler.GetLine(fw);
-				if (sc.atLineStart && sc.Match("=cut")) {	// end of POD
-					sc.SetState(SCE_PL_POD);
-					sc.Forward(4);
-					sc.SetState(SCE_PL_DEFAULT);
-					styler.SetLineState(ln, SCE_PL_POD);
-					break;
-				}
-				int pod = podLineScan(styler, fw, endPos);	// classify POD line
-				styler.SetLineState(ln, pod);
-				if (pod == SCE_PL_DEFAULT) {
-					if (sc.state == SCE_PL_POD_VERB) {
-						unsigned int fw2 = fw;
-						while (fw2 <= endPos && pod == SCE_PL_DEFAULT) {
-							fw = fw2++;	// penultimate line (last blank line)
-							pod = podLineScan(styler, fw2, endPos);
-							styler.SetLineState(styler.GetLine(fw2), pod);
-						}
-						if (pod == SCE_PL_POD) {	// truncate verbatim POD early
-							sc.SetState(SCE_PL_POD);
-						} else
-							fw = fw2;
-					} else
-						pod = SCE_PL_POD;
-				} else {
-					if (pod == SCE_PL_POD_VERB	// still part of current paragraph
-					    && (styler.GetLineState(ln - 1) == SCE_PL_POD)) {
-						pod = SCE_PL_POD;
-						styler.SetLineState(ln, pod);
-					} else if (pod == SCE_PL_POD
-							   && (styler.GetLineState(ln - 1) == SCE_PL_POD_VERB)) {
-						pod = SCE_PL_POD_VERB;
-						styler.SetLineState(ln, pod);
-					}
-					sc.SetState(pod);
-				}
-				sc.Forward(fw - sc.currentPos);	// commit style
-				} break;
-			case SCE_PL_REGEX:
-			case SCE_PL_STRING_QR:
-				if (Quote.Rep <= 0) {
-					if (!setModifiers.Contains(sc.ch))
-						sc.SetState(SCE_PL_DEFAULT);
-				} else if (!Quote.Up && !IsASpace(sc.ch)) {
-					Quote.Open(sc.ch);
-				} else if (sc.ch == '\\' && Quote.Up != '\\') {
-					sc.Forward();
-				} else if (sc.ch == Quote.Down) {
-					Quote.Count--;
-					if (Quote.Count == 0)
-						Quote.Rep--;
-				} else if (sc.ch == Quote.Up) {
-					Quote.Count++;
-				}
-				break;
-			case SCE_PL_REGSUBST:
-				if (Quote.Rep <= 0) {
-					if (!setModifiers.Contains(sc.ch))
-						sc.SetState(SCE_PL_DEFAULT);
-				} else if (!Quote.Up && !IsASpace(sc.ch)) {
-					Quote.Open(sc.ch);
-				} else if (sc.ch == '\\' && Quote.Up != '\\') {
-					sc.Forward();
-				} else if (Quote.Count == 0 && Quote.Rep == 1) {
-					// We matched something like s(...) or tr{...}, Perl 5.10
-					// appears to allow almost any character for use as the
-					// next delimiters. Whitespace and comments are accepted in
-					// between, but we'll limit to whitespace here.
-					// For '#', if no whitespace in between, it's a delimiter.
-					if (IsASpace(sc.ch)) {
-						// Keep going
-					} else if (sc.ch == '#' && IsASpaceOrTab(sc.chPrev)) {
-						sc.SetState(SCE_PL_DEFAULT);
-					} else {
-						Quote.Open(sc.ch);
-					}
-				} else if (sc.ch == Quote.Down) {
-					Quote.Count--;
-					if (Quote.Count == 0)
-						Quote.Rep--;
-					if (Quote.Up == Quote.Down)
-						Quote.Count++;
-				} else if (sc.ch == Quote.Up) {
-					Quote.Count++;
-				}
-				break;
-			case SCE_PL_STRING_Q:
-			case SCE_PL_STRING_QQ:
-			case SCE_PL_STRING_QX:
-			case SCE_PL_STRING_QW:
-			case SCE_PL_STRING:
-			case SCE_PL_CHARACTER:
-			case SCE_PL_BACKTICKS:
-				if (!Quote.Down && !IsASpace(sc.ch)) {
-					Quote.Open(sc.ch);
-				} else if (sc.ch == '\\' && Quote.Up != '\\') {
-					sc.Forward();
-				} else if (sc.ch == Quote.Down) {
-					Quote.Count--;
-					if (Quote.Count == 0)
-						sc.ForwardSetState(SCE_PL_DEFAULT);
-				} else if (sc.ch == Quote.Up) {
-					Quote.Count++;
-				}
-				break;
-			case SCE_PL_SUB_PROTOTYPE: {
-				int i = 0;
-				// forward scan; must all be valid proto characters
-				while (setSubPrototype.Contains(sc.GetRelative(i)))
-					i++;
-				if (sc.GetRelative(i) == ')') {	// valid sub prototype
-					sc.Forward(i);
-					sc.ForwardSetState(SCE_PL_DEFAULT);
-				} else {
-					// abandon prototype, restart from '('
-					sc.ChangeState(SCE_PL_OPERATOR);
-					sc.SetState(SCE_PL_DEFAULT);
-				}
-				} break;
-			case SCE_PL_FORMAT: {
-				sc.Complete();
-				while (!sc.atLineEnd)
-					sc.Forward();
-				char s[10];
-				sc.GetCurrent(s, sizeof(s));
-				if (isMatch(".", s))
-					sc.SetState(SCE_PL_DEFAULT);
-				} break;
-			case SCE_PL_ERROR:
-				break;
-		}
-		// Needed for specific continuation styles (one follows the other)
-		switch (sc.state) {
-			// continued from SCE_PL_WORD
-			case SCE_PL_FORMAT_IDENT:
-				// occupies HereDoc state 3 to avoid clashing with HERE docs
-				if (IsASpaceOrTab(sc.ch)) {		// skip whitespace
-					sc.ChangeState(SCE_PL_DEFAULT);
-					while (IsASpaceOrTab(sc.ch) && !sc.atLineEnd)
-						sc.Forward();
-					sc.SetState(SCE_PL_FORMAT_IDENT);
-				}
-				if (setFormatStart.Contains(sc.ch)) {	// identifier or '='
-					if (sc.ch != '=') {
-						do {
-							sc.Forward();
-						} while (setFormat.Contains(sc.ch));
-					}
-					while (IsASpaceOrTab(sc.ch) && !sc.atLineEnd)
-						sc.Forward();
-					if (sc.ch == '=') {
-						sc.ForwardSetState(SCE_PL_DEFAULT);
-						HereDoc.State = 3;
-					} else {
-						// invalid indentifier; inexact fallback, but hey
-						sc.ChangeState(SCE_PL_IDENTIFIER);
-						sc.SetState(SCE_PL_DEFAULT);
-					}
-				} else {
-					sc.ChangeState(SCE_PL_DEFAULT);	// invalid indentifier
-				}
-				backFlag = BACK_NONE;
-				break;
-		}
-
-		// Must check end of HereDoc states here before default state is handled
-		if (HereDoc.State == 1 && sc.atLineEnd) {
-			// Begin of here-doc (the line after the here-doc delimiter):
-			// Lexically, the here-doc starts from the next line after the >>, but the
-			// first line of here-doc seem to follow the style of the last EOL sequence
-			int st_new = SCE_PL_HERE_QQ;
-			HereDoc.State = 2;
-			if (HereDoc.Quoted) {
-				if (sc.state == SCE_PL_HERE_DELIM) {
-					// Missing quote at end of string! We are stricter than perl.
-					// Colour here-doc anyway while marking this bit as an error.
-					sc.ChangeState(SCE_PL_ERROR);
-				}
-				switch (HereDoc.Quote) {
-					case '\'': st_new = SCE_PL_HERE_Q ; break;
-					case '"' : st_new = SCE_PL_HERE_QQ; break;
-					case '`' : st_new = SCE_PL_HERE_QX; break;
-				}
-			} else {
-				if (HereDoc.Quote == '\\')
-					st_new = SCE_PL_HERE_Q;
-			}
-			sc.SetState(st_new);
-		}
-		if (HereDoc.State == 3 && sc.atLineEnd) {
-			// Start of format body.
-			HereDoc.State = 0;
-			sc.SetState(SCE_PL_FORMAT);
-		}
-
-		// Determine if a new state should be entered.
-		if (sc.state == SCE_PL_DEFAULT) {
-			if (IsADigit(sc.ch) ||
-				(IsADigit(sc.chNext) && (sc.ch == '.' || sc.ch == 'v'))) {
-				sc.SetState(SCE_PL_NUMBER);
-				backFlag = BACK_NONE;
-				numState = PERLNUM_DECIMAL;
-				dotCount = 0;
-				if (sc.ch == '0') {		// hex,bin,octal
-					if (sc.chNext == 'x') {
-						numState = PERLNUM_HEX;
-					} else if (sc.chNext == 'b') {
-						numState = PERLNUM_BINARY;
-					} else if (IsADigit(sc.chNext)) {
-						numState = PERLNUM_OCTAL;
-					}
-					if (numState != PERLNUM_DECIMAL) {
-						sc.Forward();
-					}
-				} else if (sc.ch == 'v') {		// vector
-					numState = PERLNUM_V_VECTOR;
-				}
-			} else if (setWord.Contains(sc.ch)) {
-				// if immediately prefixed by '::', always a bareword
-				sc.SetState(SCE_PL_WORD);
-				if (sc.chPrev == ':' && sc.GetRelative(-2) == ':') {
-					sc.ChangeState(SCE_PL_IDENTIFIER);
-				}
-				unsigned int bk = sc.currentPos;
-				unsigned int fw = sc.currentPos + 1;
-				// first check for possible quote-like delimiter
-				if (sc.ch == 's' && !setWord.Contains(sc.chNext)) {
-					sc.ChangeState(SCE_PL_REGSUBST);
-					Quote.New(2);
-				} else if (sc.ch == 'm' && !setWord.Contains(sc.chNext)) {
-					sc.ChangeState(SCE_PL_REGEX);
-					Quote.New();
-				} else if (sc.ch == 'q' && !setWord.Contains(sc.chNext)) {
-					sc.ChangeState(SCE_PL_STRING_Q);
-					Quote.New();
-				} else if (sc.ch == 'y' && !setWord.Contains(sc.chNext)) {
-					sc.ChangeState(SCE_PL_REGSUBST);
-					Quote.New(2);
-				} else if (sc.Match('t', 'r') && !setWord.Contains(sc.GetRelative(2))) {
-					sc.ChangeState(SCE_PL_REGSUBST);
-					Quote.New(2);
-					sc.Forward();
-					fw++;
-				} else if (sc.ch == 'q' && setQDelim.Contains(sc.chNext)
-						   && !setWord.Contains(sc.GetRelative(2))) {
-					if      (sc.chNext == 'q') sc.ChangeState(SCE_PL_STRING_QQ);
-					else if (sc.chNext == 'x') sc.ChangeState(SCE_PL_STRING_QX);
-					else if (sc.chNext == 'r') sc.ChangeState(SCE_PL_STRING_QR);
-					else sc.ChangeState(SCE_PL_STRING_QW);	// sc.chNext == 'w'
-					Quote.New();
-					sc.Forward();
-					fw++;
-				} else if (sc.ch == 'x' && (sc.chNext == '=' ||	// repetition
-						   !setWord.Contains(sc.chNext) ||
-						   (IsADigit(sc.chPrev) && IsADigit(sc.chNext)))) {
-					sc.ChangeState(SCE_PL_OPERATOR);
-				}
-				// if potentially a keyword, scan forward and grab word, then check
-				// if it's really one; if yes, disambiguation test is performed
-				// otherwise it is always a bareword and we skip a lot of scanning
-				if (sc.state == SCE_PL_WORD) {
-					while (setWord.Contains(static_cast<unsigned char>(styler.SafeGetCharAt(fw))))
-						fw++;
-					if (!isPerlKeyword(styler.GetStartSegment(), fw, keywords, styler)) {
-						sc.ChangeState(SCE_PL_IDENTIFIER);
-					}
-				}
-				// if already SCE_PL_IDENTIFIER, then no ambiguity, skip this
-				// for quote-like delimiters/keywords, attempt to disambiguate
-				// to select for bareword, change state -> SCE_PL_IDENTIFIER
-				if (sc.state != SCE_PL_IDENTIFIER && bk > 0) {
-					if (disambiguateBareword(styler, bk, fw, backFlag, backPos, endPos))
-						sc.ChangeState(SCE_PL_IDENTIFIER);
-				}
-				backFlag = BACK_NONE;
-			} else if (sc.ch == '#') {
-				sc.SetState(SCE_PL_COMMENTLINE);
-			} else if (sc.ch == '\"') {
-				sc.SetState(SCE_PL_STRING);
-				Quote.New();
-				Quote.Open(sc.ch);
-				backFlag = BACK_NONE;
-			} else if (sc.ch == '\'') {
-				if (sc.chPrev == '&' && setWordStart.Contains(sc.chNext)) {
-					// Archaic call
-					sc.SetState(SCE_PL_IDENTIFIER);
-				} else {
-					sc.SetState(SCE_PL_CHARACTER);
-					Quote.New();
-					Quote.Open(sc.ch);
-				}
-				backFlag = BACK_NONE;
-			} else if (sc.ch == '`') {
-				sc.SetState(SCE_PL_BACKTICKS);
-				Quote.New();
-				Quote.Open(sc.ch);
-				backFlag = BACK_NONE;
-			} else if (sc.ch == '$') {
-				sc.SetState(SCE_PL_SCALAR);
-				if (sc.chNext == '{') {
-					sc.ForwardSetState(SCE_PL_OPERATOR);
-				} else if (IsASpace(sc.chNext)) {
-					sc.ForwardSetState(SCE_PL_DEFAULT);
-				} else {
-					sc.Forward();
-					if (sc.Match('`', '`') || sc.Match(':', ':')) {
-						sc.Forward();
-					}
-				}
-				backFlag = BACK_NONE;
-			} else if (sc.ch == '@') {
-				sc.SetState(SCE_PL_ARRAY);
-				if (setArray.Contains(sc.chNext)) {
-					// no special treatment
-				} else if (sc.chNext == ':' && sc.GetRelative(2) == ':') {
-					sc.Forward(2);
-				} else if (sc.chNext == '{' || sc.chNext == '[') {
-					sc.ForwardSetState(SCE_PL_OPERATOR);
-				} else {
-					sc.ChangeState(SCE_PL_OPERATOR);
-				}
-				backFlag = BACK_NONE;
-			} else if (setPreferRE.Contains(sc.ch)) {
-				// Explicit backward peeking to set a consistent preferRE for
-				// any slash found, so no longer need to track preferRE state.
-				// Find first previous significant lexed element and interpret.
-				// A few symbols shares this code for disambiguation.
-				bool preferRE = false;
-				bool isHereDoc = sc.Match('<', '<');
-				bool hereDocSpace = false;		// for: SCALAR [whitespace] '<<'
-				unsigned int bk = (sc.currentPos > 0) ? sc.currentPos - 1: 0;
-				unsigned int bkend;
-				styler.Flush();
-				if (styler.StyleAt(bk) == SCE_PL_DEFAULT)
-					hereDocSpace = true;
-				skipWhitespaceComment(styler, bk);
-				if (bk == 0) {
-					// avoid backward scanning breakage
-					preferRE = true;
-				} else {
-					int bkstyle = styler.StyleAt(bk);
-					int bkch = static_cast<unsigned char>(styler.SafeGetCharAt(bk));
-					switch(bkstyle) {
-					case SCE_PL_OPERATOR:
-						preferRE = true;
-						if (bkch == ')' || bkch == ']') {
-							preferRE = false;
-						} else if (bkch == '}') {
-							// backtrack by counting balanced brace pairs
-							// needed to test for variables like ${}, @{} etc.
-							bkstyle = styleBeforeBracePair(styler, bk);
-							if (bkstyle == SCE_PL_SCALAR
-								|| bkstyle == SCE_PL_ARRAY
-								|| bkstyle == SCE_PL_HASH
-								|| bkstyle == SCE_PL_SYMBOLTABLE
-								|| bkstyle == SCE_PL_OPERATOR) {
-								preferRE = false;
-							}
-						} else if (bkch == '+' || bkch == '-') {
-							if (bkch == static_cast<unsigned char>(styler.SafeGetCharAt(bk - 1))
-								&& bkch != static_cast<unsigned char>(styler.SafeGetCharAt(bk - 2)))
-							// exceptions for operators: unary suffixes ++, --
-							preferRE = false;
-						}
-						break;
-					case SCE_PL_IDENTIFIER:
-						preferRE = true;
-						bkstyle = styleCheckIdentifier(styler, bk);
-						if ((bkstyle == 1) || (bkstyle == 2)) {
-							// inputsymbol or var with "->" or "::" before identifier
-							preferRE = false;
-						} else if (bkstyle == 3) {
-							// bare identifier, test cases follows:
-							if (sc.ch == '/') {
-								// if '/', /PATTERN/ unless digit/space immediately after '/'
-								// if '//', always expect defined-or operator to follow identifier
-								if (IsASpace(sc.chNext) || IsADigit(sc.chNext) || sc.chNext == '/')
-									preferRE = false;
-							} else if (sc.ch == '*' || sc.ch == '%') {
-								if (IsASpace(sc.chNext) || IsADigit(sc.chNext) || sc.Match('*', '*'))
-									preferRE = false;
-							} else if (sc.ch == '<') {
-								if (IsASpace(sc.chNext) || sc.chNext == '=')
-									preferRE = false;
-							}
-						}
-						break;
-					case SCE_PL_SCALAR:		// for $var<< case:
-						if (isHereDoc && hereDocSpace)	// if SCALAR whitespace '<<', *always* a HERE doc
-							preferRE = true;
-						break;
-					case SCE_PL_WORD:
-						preferRE = true;
-						// for HERE docs, always true
-						if (sc.ch == '/') {
-							// adopt heuristics similar to vim-style rules:
-							// keywords always forced as /PATTERN/: split, if, elsif, while
-							// everything else /PATTERN/ unless digit/space immediately after '/'
-							// for '//', defined-or favoured unless special keywords
-							bkend = bk + 1;
-							while (bk > 0 && styler.StyleAt(bk - 1) == SCE_PL_WORD) {
-								bk--;
-							}
-							if (isPerlKeyword(bk, bkend, reWords, styler))
-								break;
-							if (IsASpace(sc.chNext) || IsADigit(sc.chNext) || sc.chNext == '/')
-								preferRE = false;
-						} else if (sc.ch == '*' || sc.ch == '%') {
-							if (IsASpace(sc.chNext) || IsADigit(sc.chNext) || sc.Match('*', '*'))
-								preferRE = false;
-						} else if (sc.ch == '<') {
-							if (IsASpace(sc.chNext) || sc.chNext == '=')
-								preferRE = false;
-						}
-						break;
-					// other styles uses the default, preferRE=false
-					case SCE_PL_POD:
-					case SCE_PL_HERE_Q:
-					case SCE_PL_HERE_QQ:
-					case SCE_PL_HERE_QX:
-						preferRE = true;
-						break;
-					}
-				}
-				backFlag = BACK_NONE;
-				if (isHereDoc) {	// handle '<<', HERE doc
-					if (preferRE) {
-						sc.SetState(SCE_PL_HERE_DELIM);
-						HereDoc.State = 0;
-					} else {		// << operator
-						sc.SetState(SCE_PL_OPERATOR);
-						sc.Forward();
-					}
-				} else if (sc.ch == '*') {	// handle '*', typeglob
-					if (preferRE) {
-						sc.SetState(SCE_PL_SYMBOLTABLE);
-						if (sc.chNext == ':' && sc.GetRelative(2) == ':') {
-							sc.Forward(2);
-						} else if (sc.chNext == '{') {
-							sc.ForwardSetState(SCE_PL_OPERATOR);
-						} else {
-							sc.Forward();
-						}
-					} else {
-						sc.SetState(SCE_PL_OPERATOR);
-						if (sc.chNext == '*') 	// exponentiation
-							sc.Forward();
-					}
-				} else if (sc.ch == '%') {	// handle '%', hash
-					if (preferRE) {
-						sc.SetState(SCE_PL_HASH);
-						if (setHash.Contains(sc.chNext)) {
-							sc.Forward();
-						} else if (sc.chNext == ':' && sc.GetRelative(2) == ':') {
-							sc.Forward(2);
-						} else if (sc.chNext == '{') {
-							sc.ForwardSetState(SCE_PL_OPERATOR);
-						} else {
-							sc.ChangeState(SCE_PL_OPERATOR);
-						}
-					} else {
-						sc.SetState(SCE_PL_OPERATOR);
-					}
-				} else if (sc.ch == '<') {	// handle '<', inputsymbol
-					if (preferRE) {
-						// forward scan
-						int i = inputsymbolScan(styler, sc.currentPos, endPos);
-						if (i > 0) {
-							sc.SetState(SCE_PL_IDENTIFIER);
-							sc.Forward(i);
-						} else {
-							sc.SetState(SCE_PL_OPERATOR);
-						}
-					} else {
-						sc.SetState(SCE_PL_OPERATOR);
-					}
-				} else {			// handle '/', regexp
-					if (preferRE) {
-						sc.SetState(SCE_PL_REGEX);
-						Quote.New();
-						Quote.Open(sc.ch);
-					} else {		// / and // operators
-						sc.SetState(SCE_PL_OPERATOR);
-						if (sc.chNext == '/') {
-							sc.Forward();
-						}
-					}
-				}
-			} else if (sc.ch == '='		// POD
-					   && setPOD.Contains(sc.chNext)
-					   && sc.atLineStart) {
-				sc.SetState(SCE_PL_POD);
-				backFlag = BACK_NONE;
-			} else if (sc.ch == '-' && setWordStart.Contains(sc.chNext)) {	// extended '-' cases
-				unsigned int bk = sc.currentPos;
-				unsigned int fw = 2;
-				if (setSingleCharOp.Contains(sc.chNext) &&	// file test operators
-					!setWord.Contains(sc.GetRelative(2))) {
-					sc.SetState(SCE_PL_WORD);
-				} else {
-					// nominally a minus and bareword; find extent of bareword
-					while (setWord.Contains(sc.GetRelative(fw)))
-						fw++;
-					sc.SetState(SCE_PL_OPERATOR);
-				}
-				// force to bareword for hash key => or {variable literal} cases
-				if (disambiguateBareword(styler, bk, bk + fw, backFlag, backPos, endPos) & 2) {
-					sc.ChangeState(SCE_PL_IDENTIFIER);
-				}
-				backFlag = BACK_NONE;
-			} else if (sc.ch == '(' && sc.currentPos > 0) {	// '(' or subroutine prototype
-				if (styleCheckSubPrototype(styler, sc.currentPos - 1)) {
-					sc.SetState(SCE_PL_SUB_PROTOTYPE);
-					backFlag = BACK_NONE;
-				} else {
-					sc.SetState(SCE_PL_OPERATOR);
-				}
-			} else if (setPerlOperator.Contains(sc.ch)) {	// operators
-				sc.SetState(SCE_PL_OPERATOR);
-				if (sc.Match('.', '.')) {	// .. and ...
-					sc.Forward();
-					if (sc.chNext == '.') sc.Forward();
-				}
-			} else if (sc.ch == 4 || sc.ch == 26) {		// ^D and ^Z ends valid perl source
-				sc.SetState(SCE_PL_DATASECTION);
-			} else {
-				// keep colouring defaults
-				sc.Complete();
-			}
-		}
-	}
-	sc.Complete();
-}
-
-static bool IsCommentLine(int line, Accessor &styler) {
-	int pos = styler.LineStart(line);
-	int eol_pos = styler.LineStart(line + 1) - 1;
-	for (int i = pos; i < eol_pos; i++) {
-		char ch = styler[i];
-		int style = styler.StyleAt(i);
-		if (ch == '#' && style == SCE_PL_COMMENTLINE)
-			return true;
-		else if (!IsASpaceOrTab(ch))
-			return false;
-	}
-	return false;
-}
-
-static void FoldPerlDoc(unsigned int startPos, int length, int, WordList *[],
-                        Accessor &styler) {
-	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
-	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	// Custom folding of POD and packages
-	bool foldPOD = styler.GetPropertyInt("fold.perl.pod", 1) != 0;
-	bool foldPackage = styler.GetPropertyInt("fold.perl.package", 1) != 0;
-	unsigned int endPos = startPos + length;
-	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
-	int levelPrev = SC_FOLDLEVELBASE;
-	if (lineCurrent > 0)
-		levelPrev = styler.LevelAt(lineCurrent - 1) >> 16;
-	int levelCurrent = levelPrev;
-	char chNext = styler[startPos];
-	char chPrev = styler.SafeGetCharAt(startPos - 1);
-	int styleNext = styler.StyleAt(startPos);
-	// Used at end of line to determine if the line was a package definition
-	bool isPackageLine = false;
-	bool isPodHeading = false;
-	for (unsigned int i = startPos; i < endPos; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-		int style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
-		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
-		bool atLineStart = ((chPrev == '\r') || (chPrev == '\n')) || i == 0;
-		// Comment folding
-		if (foldComment && atEOL && IsCommentLine(lineCurrent, styler))
-		{
-			if (!IsCommentLine(lineCurrent - 1, styler)
-				&& IsCommentLine(lineCurrent + 1, styler))
-				levelCurrent++;
-			else if (IsCommentLine(lineCurrent - 1, styler)
-					 && !IsCommentLine(lineCurrent+1, styler))
-				levelCurrent--;
-		}
-		if (style == SCE_PL_OPERATOR) {
-			if (ch == '{') {
-				levelCurrent++;
-			} else if (ch == '}') {
-				levelCurrent--;
-			}
-		}
-		// Custom POD folding
-		if (foldPOD && atLineStart) {
-			int stylePrevCh = (i) ? styler.StyleAt(i - 1):SCE_PL_DEFAULT;
-			if (style == SCE_PL_POD) {
-				if (stylePrevCh != SCE_PL_POD && stylePrevCh != SCE_PL_POD_VERB)
-					levelCurrent++;
-				else if (styler.Match(i, "=cut"))
-					levelCurrent--;
-				else if (styler.Match(i, "=head"))
-					isPodHeading = true;
-			} else if (style == SCE_PL_DATASECTION) {
-				if (ch == '=' && isalpha(chNext) && levelCurrent == SC_FOLDLEVELBASE)
-					levelCurrent++;
-				else if (styler.Match(i, "=cut") && levelCurrent > SC_FOLDLEVELBASE)
-					levelCurrent--;
-				else if (styler.Match(i, "=head"))
-					isPodHeading = true;
-				// if package used or unclosed brace, level > SC_FOLDLEVELBASE!
-				// reset needed as level test is vs. SC_FOLDLEVELBASE
-				else if (styler.Match(i, "__END__"))
-					levelCurrent = SC_FOLDLEVELBASE;
-			}
-		}
-		// Custom package folding
-		if (foldPackage && atLineStart) {
-			if (style == SCE_PL_WORD && styler.Match(i, "package")) {
-				isPackageLine = true;
-			}
-		}
-
-		if (atEOL) {
-			int lev = levelPrev;
-			if (isPodHeading) {
-				lev = levelPrev - 1;
-				lev |= SC_FOLDLEVELHEADERFLAG;
-				isPodHeading = false;
-			}
-			// Check if line was a package declaration
-			// because packages need "special" treatment
-			if (isPackageLine) {
-				lev = SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG;
-				levelCurrent = SC_FOLDLEVELBASE + 1;
-				isPackageLine = false;
-			}
-			lev |= levelCurrent << 16;
-			if (visibleChars == 0 && foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if ((levelCurrent > levelPrev) && (visibleChars > 0))
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
-			lineCurrent++;
-			levelPrev = levelCurrent;
-			visibleChars = 0;
-		}
-		if (!isspacechar(ch))
-			visibleChars++;
-		chPrev = ch;
-	}
-	// Fill in the real level of the next line, keeping the current flags as they will be filled in later
-	int flagsNext = styler.LevelAt(lineCurrent) & ~SC_FOLDLEVELNUMBERMASK;
-	styler.SetLevel(lineCurrent, levelPrev | flagsNext);
-}
-
-static const char * const perlWordListDesc[] = {
-	"Keywords",
-	0
-};
-
-LexerModule lmPerl(SCLEX_PERL, ColourisePerlDoc, "perl", FoldPerlDoc, perlWordListDesc, 8);
diff --git a/Pythonwin/Scintilla/src/LexProgress.cxx b/Pythonwin/Scintilla/src/LexProgress.cxx
deleted file mode 100644
index c21356960..000000000
--- a/Pythonwin/Scintilla/src/LexProgress.cxx
+++ /dev/null
@@ -1,276 +0,0 @@
-// Scintilla source code edit control
-/** @file LexProgress.cxx
- **  Lexer for Progress 4GL.
- ** Based on LexCPP.cxx of Neil Hodgson <neilh@scintilla.org>
-  **/
-// Copyright 2006-2007 by Yuval Papish <Yuval@YuvCom.com>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-/** TODO:
-WebSpeed support in html lexer
-Support "end triggers" expression of the triggers phrase
-change lmPS to lmProgress
-Support more than 6 comments levels
-**/
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-static inline bool IsAWordChar(int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '_');
-}
-
-static inline bool IsAWordStart(int ch) {
-	return (ch < 0x80) && (isalpha(ch) || ch == '_');
-}
-
-enum SentenceStart { SetSentenceStart = 0xf, ResetSentenceStart = 0x10}; // true -> bit = 0
-
-static void Colourise4glDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                            Accessor &styler) {
-
-    WordList &keywords1 = *keywordlists[0];
-    WordList &keywords2 = *keywordlists[1];
-    WordList &keywords3 = *keywordlists[2];
-    //WordList &keywords4 = *keywordlists[3];
-    //WordList &keywords5 = *keywordlists[4];
-
-	int visibleChars = 0;
-	int mask;
-
-	StyleContext sc(startPos, length, initStyle, styler);
-
-	for (; sc.More(); sc.Forward()) {
-
-		if (sc.atLineStart) {
-			// Reset states to begining of colourise so no surprises
-			// if different sets of lines lexed.
-			visibleChars = 0;
-		}
-
-		// Handle line continuation generically.
-		if (sc.ch == '~') {
-			if (sc.chNext > ' ') {
-				// skip special char after ~
-				sc.Forward();
-				continue;
-			}
-			else {
-				// Skip whitespace between ~ and EOL
-				while (sc.More() && (sc.chNext == ' ' || sc.chNext == '\t') ) {
-					sc.Forward();
-				}
-				if (sc.chNext == '\n' || sc.chNext == '\r') {
-					sc.Forward();
-					if (sc.ch == '\r' && sc.chNext == '\n') {
-						sc.Forward();
-					}
-					sc.Forward();
-					continue;
-				}
-			}
-		}
-		// Determine if a new state should be terminated.
-		mask = sc.state & 0x10;
-		switch (sc.state & 0xf) {
-			case SCE_4GL_OPERATOR:
-				sc.SetState(SCE_4GL_DEFAULT | mask);
-				break;
-			case SCE_4GL_NUMBER:
-				if (!(IsADigit(sc.ch))) {
-					sc.SetState(SCE_4GL_DEFAULT | mask);
-				}
-				break;
-			case SCE_4GL_IDENTIFIER:
-				if (!IsAWordChar(sc.ch) && sc.ch != '-') {
-					char s[1000];
-					sc.GetCurrentLowered(s, sizeof(s));
-					if (((sc.state & 0x10) == 0) && keywords2.InList(s) || keywords3.InList(s)) {
-						sc.ChangeState(SCE_4GL_BLOCK | ResetSentenceStart);
-					}
-					else if (keywords1.InList(s)) {
-						if ((s[0] == 'e' && s[1] =='n' && s[2] == 'd' && !isalnum(s[3]) && s[3] != '-') ||
-							(s[0] == 'f' && s[1] =='o' && s[2] == 'r' && s[3] == 'w' && s[4] =='a' && s[5] == 'r' && s[6] == 'd'&& !isalnum(s[7]))) {
-							sc.ChangeState(SCE_4GL_END | ResetSentenceStart);
-						}
-						else if	((s[0] == 'e' && s[1] =='l' && s[2] == 's' && s[3] == 'e') ||
-								 (s[0] == 't' && s[1] =='h' && s[2] == 'e' && s[3] == 'n')) {
-							sc.ChangeState(SCE_4GL_WORD & SetSentenceStart);
-						}
-						else {
-							sc.ChangeState(SCE_4GL_WORD | ResetSentenceStart);
-						}
-					}
-					sc.SetState(SCE_4GL_DEFAULT | (sc.state & 0x10));
-				}
-				break;
-			case SCE_4GL_PREPROCESSOR:
-				if (sc.atLineStart) {
-					sc.SetState(SCE_4GL_DEFAULT & SetSentenceStart);
-				} else if (sc.ch == '*' && sc.chNext == '/') {
-					sc.ForwardSetState(SCE_4GL_DEFAULT | mask);
-				}
-				break;
-			case SCE_4GL_STRING:
-				if (sc.ch == '\"') {
-					sc.ForwardSetState(SCE_4GL_DEFAULT | mask);
-				}
-				break;
-			case SCE_4GL_CHARACTER:
-				if (sc.ch == '\'') {
-					sc.ForwardSetState(SCE_4GL_DEFAULT | mask);
-				}
-				break;
-			default:
-				if ((sc.state & 0xf) >= SCE_4GL_COMMENT1) {
-					if (sc.ch == '*' && sc.chNext == '/') {
-						sc.Forward();
-						if ((sc.state & 0xf) == SCE_4GL_COMMENT1) {
-							sc.ForwardSetState(SCE_4GL_DEFAULT | mask);
-						}
-						else
-							sc.SetState((sc.state & 0x1f) - 1);
-					} else if (sc.ch == '/' && sc.chNext == '*') {
-						sc.Forward();
-						sc.SetState((sc.state & 0x1f) + 1);
-					}
-				}
-		}
-
-		// Determine if a new state should be entered.
-		mask = sc.state & 0x10;
-		if ((sc.state & 0xf) == SCE_4GL_DEFAULT) {
-			if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
-				sc.SetState(SCE_4GL_NUMBER | ResetSentenceStart);
-			} else if (IsAWordStart(sc.ch) || (sc.ch == '@')) {
-				sc.SetState(SCE_4GL_IDENTIFIER | mask);
-			} else if (sc.ch == '/' && sc.chNext == '*') {
-				sc.SetState(SCE_4GL_COMMENT1 | mask);
-				sc.Forward();
-			} else if (sc.ch == '\"') {
-				sc.SetState(SCE_4GL_STRING | ResetSentenceStart);
-			} else if (sc.ch == '\'') {
-				sc.SetState(SCE_4GL_CHARACTER | ResetSentenceStart);
-			} else if (sc.ch == '&' && visibleChars == 0 && ((sc.state & 0x10) == 0)) {
-				sc.SetState(SCE_4GL_PREPROCESSOR | ResetSentenceStart);
-				// Skip whitespace between & and preprocessor word
-				do {
-					sc.Forward();
-				} while ((sc.ch == ' ' || sc.ch == '\t') && sc.More());
-			// Handle syntactical line termination
-			} else if ((sc.ch == '.' || sc.ch == ':' || sc.ch == '}') && (sc.chNext == ' ' || sc.chNext == '\t' || sc.chNext == '\n' || sc.chNext == '\r')) {
-				sc.SetState(sc.state & SetSentenceStart);
-			} else if (isoperator(static_cast<char>(sc.ch))) {
-				if (sc.ch == ':')
-					sc.SetState(SCE_4GL_OPERATOR & SetSentenceStart);
-				else
-					sc.SetState(SCE_4GL_OPERATOR | ResetSentenceStart);
-			}
-		}
-
-		if (!IsASpace(sc.ch)) {
-			visibleChars++;
-		}
-	}
-	sc.Complete();
-}
-
-static bool IsStreamCommentStyle(int style) {
-	return (style & 0xf) >= SCE_4GL_COMMENT1 ;
-}
-
-// Store both the current line's fold level and the next lines in the
-// level store to make it easy to pick up with each increment
-// and to make it possible to fiddle the current level for "} else {".
-static void FoldNoBox4glDoc(unsigned int startPos, int length, int initStyle,
-                            Accessor &styler) {
-	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
-	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0;
-	unsigned int endPos = startPos + length;
-	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
-	int levelCurrent = SC_FOLDLEVELBASE;
-	if (lineCurrent > 0)
-		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
-	int levelMinCurrent = levelCurrent;
-	int levelNext = levelCurrent;
-	char chNext = static_cast<char>(tolower(styler[startPos]));
-	int styleNext = styler.StyleAt(startPos);
-	int style = initStyle;
-	for (unsigned int i = startPos; i < endPos; i++) {
-		char ch = chNext;
-		chNext = static_cast<char>(tolower(styler.SafeGetCharAt(i + 1)));
-		int stylePrev = style;
-		style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
-		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
-		if (foldComment && IsStreamCommentStyle(style)) {
-			if (!IsStreamCommentStyle(stylePrev)) {
-				levelNext++;
-			} else if (!IsStreamCommentStyle(styleNext)) { // && !atEOL) {
-				// Comments don't end at end of line and the next character may be unstyled.
-				levelNext--;
-			}
-		}
-		else if ((style & 0xf) == SCE_4GL_BLOCK && !isalnum(chNext)) {
-			levelNext++;
-		}
-		else if ((style & 0xf) == SCE_4GL_END  && (ch == 'e' || ch == 'f')) {
-			levelNext--;
-		}
-		if (atEOL) {
-			int levelUse = levelCurrent;
-			if (foldAtElse) {
-				levelUse = levelMinCurrent;
-			}
-			int lev = levelUse | levelNext << 16;
-			if (visibleChars == 0 && foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if (levelUse < levelNext)
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
-			lineCurrent++;
-			levelCurrent = levelNext;
-			levelMinCurrent = levelCurrent;
-			visibleChars = 0;
-		}
-		if (!isspacechar(ch))
-			visibleChars++;
-	}
-}
-
-static void Fold4glDoc(unsigned int startPos, int length, int initStyle, WordList *[],
-                       Accessor &styler) {
-	FoldNoBox4glDoc(startPos, length, initStyle, styler);
-}
-
-static const char * const FglWordLists[] = {
-            "Primary keywords and identifiers",
-            "Secondary keywords and identifiers",
-            "Documentation comment keywords",
-            "Unused",
-            "Global classes and typedefs",
-            0,
-        };
-
-LexerModule lmProgress(SCLEX_PS, Colourise4glDoc, "progress", Fold4glDoc, FglWordLists);
-
-
diff --git a/Pythonwin/Scintilla/src/LexPython.cxx b/Pythonwin/Scintilla/src/LexPython.cxx
deleted file mode 100644
index 01d406d0d..000000000
--- a/Pythonwin/Scintilla/src/LexPython.cxx
+++ /dev/null
@@ -1,461 +0,0 @@
-// Scintilla source code edit control
-/** @file LexPython.cxx
- ** Lexer for Python.
- **/
-// Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-enum kwType { kwOther, kwClass, kwDef, kwImport };
-static const int indicatorWhitespace = 1;
-
-static bool IsPyComment(Accessor &styler, int pos, int len) {
-	return len > 0 && styler[pos] == '#';
-}
-
-static bool IsPyStringStart(int ch, int chNext, int chNext2) {
-	if (ch == '\'' || ch == '"')
-		return true;
-	if (ch == 'u' || ch == 'U') {
-		if (chNext == '"' || chNext == '\'')
-			return true;
-		if ((chNext == 'r' || chNext == 'R') && (chNext2 == '"' || chNext2 == '\''))
-			return true;
-	}
-	if ((ch == 'r' || ch == 'R') && (chNext == '"' || chNext == '\''))
-		return true;
-
-	return false;
-}
-
-/* Return the state to use for the string starting at i; *nextIndex will be set to the first index following the quote(s) */
-static int GetPyStringState(Accessor &styler, int i, unsigned int *nextIndex) {
-	char ch = styler.SafeGetCharAt(i);
-	char chNext = styler.SafeGetCharAt(i + 1);
-
-	// Advance beyond r, u, or ur prefix, but bail if there are any unexpected chars
-	if (ch == 'r' || ch == 'R') {
-		i++;
-		ch = styler.SafeGetCharAt(i);
-		chNext = styler.SafeGetCharAt(i + 1);
-	} else if (ch == 'u' || ch == 'U') {
-		if (chNext == 'r' || chNext == 'R')
-			i += 2;
-		else
-			i += 1;
-		ch = styler.SafeGetCharAt(i);
-		chNext = styler.SafeGetCharAt(i + 1);
-	}
-
-	if (ch != '"' && ch != '\'') {
-		*nextIndex = i + 1;
-		return SCE_P_DEFAULT;
-	}
-
-	if (ch == chNext && ch == styler.SafeGetCharAt(i + 2)) {
-		*nextIndex = i + 3;
-
-		if (ch == '"')
-			return SCE_P_TRIPLEDOUBLE;
-		else
-			return SCE_P_TRIPLE;
-	} else {
-		*nextIndex = i + 1;
-
-		if (ch == '"')
-			return SCE_P_STRING;
-		else
-			return SCE_P_CHARACTER;
-	}
-}
-
-static inline bool IsAWordChar(int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_');
-}
-
-static inline bool IsAWordStart(int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '_');
-}
-
-static void ColourisePyDoc(unsigned int startPos, int length, int initStyle,
-                           WordList *keywordlists[], Accessor &styler) {
-
-	int endPos = startPos + length;
-
-	// Backtrack to previous line in case need to fix its tab whinging
-	int lineCurrent = styler.GetLine(startPos);
-	if (startPos > 0) {
-		if (lineCurrent > 0) {
-			lineCurrent--;
-			startPos = styler.LineStart(lineCurrent);
-			if (startPos == 0)
-				initStyle = SCE_P_DEFAULT;
-			else
-				initStyle = styler.StyleAt(startPos - 1);
-		}
-	}
-
-	WordList &keywords = *keywordlists[0];
-	WordList &keywords2 = *keywordlists[1];
-
-	const int whingeLevel = styler.GetPropertyInt("tab.timmy.whinge.level");
-
-	initStyle = initStyle & 31;
-	if (initStyle == SCE_P_STRINGEOL) {
-		initStyle = SCE_P_DEFAULT;
-	}
-
-	kwType kwLast = kwOther;
-	int spaceFlags = 0;
-	styler.IndentAmount(lineCurrent, &spaceFlags, IsPyComment);
-	bool hexadecimal = false;
-
-	StyleContext sc(startPos, endPos - startPos, initStyle, styler);
-
-	bool indentGood = true;
-	int startIndicator = sc.currentPos;
-
-	for (; sc.More(); sc.Forward()) {
-
-		if (sc.atLineStart) {
-			styler.IndentAmount(lineCurrent, &spaceFlags, IsPyComment);
-			indentGood = true;
-			if (whingeLevel == 1) {
-				indentGood = (spaceFlags & wsInconsistent) == 0;
-			} else if (whingeLevel == 2) {
-				indentGood = (spaceFlags & wsSpaceTab) == 0;
-			} else if (whingeLevel == 3) {
-				indentGood = (spaceFlags & wsSpace) == 0;
-			} else if (whingeLevel == 4) {
-				indentGood = (spaceFlags & wsTab) == 0;
-			}
-			if (!indentGood) {
-				styler.IndicatorFill(startIndicator, sc.currentPos, indicatorWhitespace, 0);
-				startIndicator = sc.currentPos;
-			}
-		}
-
-		if (sc.atLineEnd) {
-			if ((sc.state == SCE_P_DEFAULT) ||
-			        (sc.state == SCE_P_TRIPLE) ||
-			        (sc.state == SCE_P_TRIPLEDOUBLE)) {
-				// Perform colourisation of white space and triple quoted strings at end of each line to allow
-				// tab marking to work inside white space and triple quoted strings
-				sc.SetState(sc.state);
-			}
-			lineCurrent++;
-			if ((sc.state == SCE_P_STRING) || (sc.state == SCE_P_CHARACTER)) {
-				sc.ChangeState(SCE_P_STRINGEOL);
-				sc.ForwardSetState(SCE_P_DEFAULT);
-			}
-			if (!sc.More())
-				break;
-		}
-
-		bool needEOLCheck = false;
-
-		// Check for a state end
-		if (sc.state == SCE_P_OPERATOR) {
-			kwLast = kwOther;
-			sc.SetState(SCE_P_DEFAULT);
-		} else if (sc.state == SCE_P_NUMBER) {
-			if (!IsAWordChar(sc.ch) &&
-			        !(!hexadecimal && ((sc.ch == '+' || sc.ch == '-') && (sc.chPrev == 'e' || sc.chPrev == 'E')))) {
-				sc.SetState(SCE_P_DEFAULT);
-			}
-		} else if (sc.state == SCE_P_IDENTIFIER) {
-			if ((sc.ch == '.') || (!IsAWordChar(sc.ch))) {
-				char s[100];
-				sc.GetCurrent(s, sizeof(s));
-				int style = SCE_P_IDENTIFIER;
-				if ((kwLast == kwImport) && (strcmp(s, "as") == 0)) {
-					style = SCE_P_WORD;
-				} else if (keywords.InList(s)) {
-					style = SCE_P_WORD;
-				} else if (kwLast == kwClass) {
-					style = SCE_P_CLASSNAME;
-				} else if (kwLast == kwDef) {
-					style = SCE_P_DEFNAME;
-				} else if (keywords2.InList(s)) {
-					style = SCE_P_WORD2;
-				}
-				sc.ChangeState(style);
-				sc.SetState(SCE_P_DEFAULT);
-				if (style == SCE_P_WORD) {
-					if (0 == strcmp(s, "class"))
-						kwLast = kwClass;
-					else if (0 == strcmp(s, "def"))
-						kwLast = kwDef;
-					else if (0 == strcmp(s, "import"))
-						kwLast = kwImport;
-					else
-						kwLast = kwOther;
-				} else {
-					kwLast = kwOther;
-				}
-			}
-		} else if ((sc.state == SCE_P_COMMENTLINE) || (sc.state == SCE_P_COMMENTBLOCK)) {
-			if (sc.ch == '\r' || sc.ch == '\n') {
-				sc.SetState(SCE_P_DEFAULT);
-			}
-		} else if (sc.state == SCE_P_DECORATOR) {
-			if (!IsAWordChar(sc.ch)) {
-				sc.SetState(SCE_P_DEFAULT);
-			}
-		} else if ((sc.state == SCE_P_STRING) || (sc.state == SCE_P_CHARACTER)) {
-			if (sc.ch == '\\') {
-				if ((sc.chNext == '\r') && (sc.GetRelative(2) == '\n')) {
-					sc.Forward();
-				}
-				sc.Forward();
-			} else if ((sc.state == SCE_P_STRING) && (sc.ch == '\"')) {
-				sc.ForwardSetState(SCE_P_DEFAULT);
-				needEOLCheck = true;
-			} else if ((sc.state == SCE_P_CHARACTER) && (sc.ch == '\'')) {
-				sc.ForwardSetState(SCE_P_DEFAULT);
-				needEOLCheck = true;
-			}
-		} else if (sc.state == SCE_P_TRIPLE) {
-			if (sc.ch == '\\') {
-				sc.Forward();
-			} else if (sc.Match("\'\'\'")) {
-				sc.Forward();
-				sc.Forward();
-				sc.ForwardSetState(SCE_P_DEFAULT);
-				needEOLCheck = true;
-			}
-		} else if (sc.state == SCE_P_TRIPLEDOUBLE) {
-			if (sc.ch == '\\') {
-				sc.Forward();
-			} else if (sc.Match("\"\"\"")) {
-				sc.Forward();
-				sc.Forward();
-				sc.ForwardSetState(SCE_P_DEFAULT);
-				needEOLCheck = true;
-			}
-		}
-
-		if (!indentGood && !IsASpaceOrTab(sc.ch)) {
-			styler.IndicatorFill(startIndicator, sc.currentPos, indicatorWhitespace, 1);
-			startIndicator = sc.currentPos;
-			indentGood = true;
-		}
-
-		// State exit code may have moved on to end of line
-		if (needEOLCheck && sc.atLineEnd) {
-			lineCurrent++;
-			styler.IndentAmount(lineCurrent, &spaceFlags, IsPyComment);
-			if (!sc.More())
-				break;
-		}
-
-		// Check for a new state starting character
-		if (sc.state == SCE_P_DEFAULT) {
-			if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
-				if (sc.ch == '0' && (sc.chNext == 'x' || sc.chNext == 'X')) {
-					hexadecimal = true;
-				} else {
-					hexadecimal = false;
-				}
-				sc.SetState(SCE_P_NUMBER);
-			} else if (isascii(sc.ch) && isoperator(static_cast<char>(sc.ch)) || sc.ch == '`') {
-				sc.SetState(SCE_P_OPERATOR);
-			} else if (sc.ch == '#') {
-				sc.SetState(sc.chNext == '#' ? SCE_P_COMMENTBLOCK : SCE_P_COMMENTLINE);
-			} else if (sc.ch == '@') {
-				sc.SetState(SCE_P_DECORATOR);
-			} else if (IsPyStringStart(sc.ch, sc.chNext, sc.GetRelative(2))) {
-				unsigned int nextIndex = 0;
-				sc.SetState(GetPyStringState(styler, sc.currentPos, &nextIndex));
-				while (nextIndex > (sc.currentPos + 1) && sc.More()) {
-					sc.Forward();
-				}
-			} else if (IsAWordStart(sc.ch)) {
-				sc.SetState(SCE_P_IDENTIFIER);
-			}
-		}
-	}
-	styler.IndicatorFill(startIndicator, sc.currentPos, indicatorWhitespace, 0);
-	sc.Complete();
-}
-
-static bool IsCommentLine(int line, Accessor &styler) {
-	int pos = styler.LineStart(line);
-	int eol_pos = styler.LineStart(line + 1) - 1;
-	for (int i = pos; i < eol_pos; i++) {
-		char ch = styler[i];
-		if (ch == '#')
-			return true;
-		else if (ch != ' ' && ch != '\t')
-			return false;
-	}
-	return false;
-}
-
-static bool IsQuoteLine(int line, Accessor &styler) {
-	int style = styler.StyleAt(styler.LineStart(line)) & 31;
-	return ((style == SCE_P_TRIPLE) || (style == SCE_P_TRIPLEDOUBLE));
-}
-
-
-static void FoldPyDoc(unsigned int startPos, int length, int /*initStyle - unused*/,
-                      WordList *[], Accessor &styler) {
-	const int maxPos = startPos + length;
-	const int maxLines = styler.GetLine(maxPos - 1);             // Requested last line
-	const int docLines = styler.GetLine(styler.Length() - 1);  // Available last line
-	const bool foldComment = styler.GetPropertyInt("fold.comment.python") != 0;
-	const bool foldQuotes = styler.GetPropertyInt("fold.quotes.python") != 0;
-
-	// Backtrack to previous non-blank line so we can determine indent level
-	// for any white space lines (needed esp. within triple quoted strings)
-	// and so we can fix any preceding fold level (which is why we go back
-	// at least one line in all cases)
-	int spaceFlags = 0;
-	int lineCurrent = styler.GetLine(startPos);
-	int indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, NULL);
-	while (lineCurrent > 0) {
-		lineCurrent--;
-		indentCurrent = styler.IndentAmount(lineCurrent, &spaceFlags, NULL);
-		if (!(indentCurrent & SC_FOLDLEVELWHITEFLAG) &&
-		        (!IsCommentLine(lineCurrent, styler)) &&
-		        (!IsQuoteLine(lineCurrent, styler)))
-			break;
-	}
-	int indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
-
-	// Set up initial loop state
-	startPos = styler.LineStart(lineCurrent);
-	int prev_state = SCE_P_DEFAULT & 31;
-	if (lineCurrent >= 1)
-		prev_state = styler.StyleAt(startPos - 1) & 31;
-	int prevQuote = foldQuotes && ((prev_state == SCE_P_TRIPLE) || (prev_state == SCE_P_TRIPLEDOUBLE));
-	int prevComment = 0;
-	if (lineCurrent >= 1)
-		prevComment = foldComment && IsCommentLine(lineCurrent - 1, styler);
-
-	// Process all characters to end of requested range or end of any triple quote
-	// or comment that hangs over the end of the range.  Cap processing in all cases
-	// to end of document (in case of unclosed quote or comment at end).
-	while ((lineCurrent <= docLines) && ((lineCurrent <= maxLines) || prevQuote || prevComment)) {
-
-		// Gather info
-		int lev = indentCurrent;
-		int lineNext = lineCurrent + 1;
-		int indentNext = indentCurrent;
-		int quote = false;
-		if (lineNext <= docLines) {
-			// Information about next line is only available if not at end of document
-			indentNext = styler.IndentAmount(lineNext, &spaceFlags, NULL);
-			int style = styler.StyleAt(styler.LineStart(lineNext)) & 31;
-			quote = foldQuotes && ((style == SCE_P_TRIPLE) || (style == SCE_P_TRIPLEDOUBLE));
-		}
-		const int quote_start = (quote && !prevQuote);
-		const int quote_continue = (quote && prevQuote);
-		const int comment = foldComment && IsCommentLine(lineCurrent, styler);
-		const int comment_start = (comment && !prevComment && (lineNext <= docLines) &&
-		                           IsCommentLine(lineNext, styler) && (lev > SC_FOLDLEVELBASE));
-		const int comment_continue = (comment && prevComment);
-		if ((!quote || !prevQuote) && !comment)
-			indentCurrentLevel = indentCurrent & SC_FOLDLEVELNUMBERMASK;
-		if (quote)
-			indentNext = indentCurrentLevel;
-		if (indentNext & SC_FOLDLEVELWHITEFLAG)
-			indentNext = SC_FOLDLEVELWHITEFLAG | indentCurrentLevel;
-
-		if (quote_start) {
-			// Place fold point at start of triple quoted string
-			lev |= SC_FOLDLEVELHEADERFLAG;
-		} else if (quote_continue || prevQuote) {
-			// Add level to rest of lines in the string
-			lev = lev + 1;
-		} else if (comment_start) {
-			// Place fold point at start of a block of comments
-			lev |= SC_FOLDLEVELHEADERFLAG;
-		} else if (comment_continue) {
-			// Add level to rest of lines in the block
-			lev = lev + 1;
-		}
-
-		// Skip past any blank lines for next indent level info; we skip also
-		// comments (all comments, not just those starting in column 0)
-		// which effectively folds them into surrounding code rather
-		// than screwing up folding.
-
-		while (!quote &&
-		        (lineNext < docLines) &&
-		        ((indentNext & SC_FOLDLEVELWHITEFLAG) ||
-		         (lineNext <= docLines && IsCommentLine(lineNext, styler)))) {
-
-			lineNext++;
-			indentNext = styler.IndentAmount(lineNext, &spaceFlags, NULL);
-		}
-
-		const int levelAfterComments = indentNext & SC_FOLDLEVELNUMBERMASK;
-		const int levelBeforeComments = Platform::Maximum(indentCurrentLevel,levelAfterComments);
-
-		// Now set all the indent levels on the lines we skipped
-		// Do this from end to start.  Once we encounter one line
-		// which is indented more than the line after the end of
-		// the comment-block, use the level of the block before
-
-		int skipLine = lineNext;
-		int skipLevel = levelAfterComments;
-
-		while (--skipLine > lineCurrent) {
-			int skipLineIndent = styler.IndentAmount(skipLine, &spaceFlags, NULL);
-
-			if ((skipLineIndent & SC_FOLDLEVELNUMBERMASK) > levelAfterComments)
-				skipLevel = levelBeforeComments;
-
-			int whiteFlag = skipLineIndent & SC_FOLDLEVELWHITEFLAG;
-
-			styler.SetLevel(skipLine, skipLevel | whiteFlag);
-		}
-
-		// Set fold header on non-quote/non-comment line
-		if (!quote && !comment && !(indentCurrent & SC_FOLDLEVELWHITEFLAG) ) {
-			if ((indentCurrent & SC_FOLDLEVELNUMBERMASK) < (indentNext & SC_FOLDLEVELNUMBERMASK))
-				lev |= SC_FOLDLEVELHEADERFLAG;
-		}
-
-		// Keep track of triple quote and block comment state of previous line
-		prevQuote = quote;
-		prevComment = comment_start || comment_continue;
-
-		// Set fold level for this line and move to next line
-		styler.SetLevel(lineCurrent, lev);
-		indentCurrent = indentNext;
-		lineCurrent = lineNext;
-	}
-
-	// NOTE: Cannot set level of last line here because indentCurrent doesn't have
-	// header flag set; the loop above is crafted to take care of this case!
-	//styler.SetLevel(lineCurrent, indentCurrent);
-}
-
-static const char * const pythonWordListDesc[] = {
-	"Keywords",
-	"Highlighted identifiers",
-	0
-};
-
-LexerModule lmPython(SCLEX_PYTHON, ColourisePyDoc, "python", FoldPyDoc,
-					 pythonWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexSQL.cxx b/Pythonwin/Scintilla/src/LexSQL.cxx
deleted file mode 100644
index eb1cddbdf..000000000
--- a/Pythonwin/Scintilla/src/LexSQL.cxx
+++ /dev/null
@@ -1,346 +0,0 @@
-// Scintilla source code edit control
-/** @file LexSQL.cxx
- ** Lexer for SQL, including PL/SQL and SQL*Plus.
- **/
-// Copyright 1998-2005 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-static inline bool IsAWordChar(int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '_');
-}
-
-static inline bool IsAWordStart(int ch) {
-	return (ch < 0x80) && (isalpha(ch) || ch == '_');
-}
-
-static inline bool IsADoxygenChar(int ch) {
-	return (islower(ch) || ch == '$' || ch == '@' ||
-	        ch == '\\' || ch == '&' || ch == '<' ||
-	        ch == '>' || ch == '#' || ch == '{' ||
-	        ch == '}' || ch == '[' || ch == ']');
-}
-
-static inline bool IsANumberChar(int ch) {
-	// Not exactly following number definition (several dots are seen as OK, etc.)
-	// but probably enough in most cases.
-	return (ch < 0x80) &&
-	        (isdigit(ch) || toupper(ch) == 'E' ||
-             ch == '.' || ch == '-' || ch == '+');
-}
-
-static void ColouriseSQLDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                            Accessor &styler) {
-
-	WordList &keywords1 = *keywordlists[0];
-	WordList &keywords2 = *keywordlists[1];
-	WordList &kw_pldoc = *keywordlists[2];
-	WordList &kw_sqlplus = *keywordlists[3];
-	WordList &kw_user1 = *keywordlists[4];
-	WordList &kw_user2 = *keywordlists[5];
-	WordList &kw_user3 = *keywordlists[6];
-	WordList &kw_user4 = *keywordlists[7];
-
-	StyleContext sc(startPos, length, initStyle, styler);
-
-	bool sqlBackslashEscapes = styler.GetPropertyInt("sql.backslash.escapes", 0) != 0;
-	bool sqlBackticksIdentifier = styler.GetPropertyInt("lexer.sql.backticks.identifier", 0) != 0;
-	int styleBeforeDCKeyword = SCE_SQL_DEFAULT;
-	for (; sc.More(); sc.Forward()) {
-		// Determine if the current state should terminate.
-		switch (sc.state) {
-		case SCE_SQL_OPERATOR:
-			sc.SetState(SCE_SQL_DEFAULT);
-			break;
-		case SCE_SQL_NUMBER:
-			// We stop the number definition on non-numerical non-dot non-eE non-sign char
-			if (!IsANumberChar(sc.ch)) {
-				sc.SetState(SCE_SQL_DEFAULT);
-			}
-			break;
-		case SCE_SQL_IDENTIFIER:
-			if (!IsAWordChar(sc.ch)) {
-				int nextState = SCE_SQL_DEFAULT;
-				char s[1000];
-				sc.GetCurrentLowered(s, sizeof(s));
-				if (keywords1.InList(s)) {
-					sc.ChangeState(SCE_SQL_WORD);
-				} else if (keywords2.InList(s)) {
-					sc.ChangeState(SCE_SQL_WORD2);
-				} else if (kw_sqlplus.InListAbbreviated(s, '~')) {
-					sc.ChangeState(SCE_SQL_SQLPLUS);
-					if (strncmp(s, "rem", 3) == 0) {
-						nextState = SCE_SQL_SQLPLUS_COMMENT;
-					} else if (strncmp(s, "pro", 3) == 0) {
-						nextState = SCE_SQL_SQLPLUS_PROMPT;
-					}
-				} else if (kw_user1.InList(s)) {
-					sc.ChangeState(SCE_SQL_USER1);
-				} else if (kw_user2.InList(s)) {
-					sc.ChangeState(SCE_SQL_USER2);
-				} else if (kw_user3.InList(s)) {
-					sc.ChangeState(SCE_SQL_USER3);
-				} else if (kw_user4.InList(s)) {
-					sc.ChangeState(SCE_SQL_USER4);
-				}
-				sc.SetState(nextState);
-			}
-			break;
-		case SCE_SQL_QUOTEDIDENTIFIER:
-			if (sc.ch == 0x60) {
-				if (sc.chNext == 0x60) {
-					sc.Forward();	// Ignore it
-				} else {
-					sc.ForwardSetState(SCE_SQL_DEFAULT);
-				}
-			}
-			break;
-		case SCE_SQL_COMMENT:
-			if (sc.Match('*', '/')) {
-				sc.Forward();
-				sc.ForwardSetState(SCE_SQL_DEFAULT);
-			}
-			break;
-		case SCE_SQL_COMMENTDOC:
-			if (sc.Match('*', '/')) {
-				sc.Forward();
-				sc.ForwardSetState(SCE_SQL_DEFAULT);
-			} else if (sc.ch == '@' || sc.ch == '\\') { // Doxygen support
-				// Verify that we have the conditions to mark a comment-doc-keyword
-				if ((IsASpace(sc.chPrev) || sc.chPrev == '*') && (!IsASpace(sc.chNext))) {
-					styleBeforeDCKeyword = SCE_SQL_COMMENTDOC;
-					sc.SetState(SCE_SQL_COMMENTDOCKEYWORD);
-				}
-			}
-			break;
-		case SCE_SQL_COMMENTLINE:
-		case SCE_SQL_COMMENTLINEDOC:
-		case SCE_SQL_SQLPLUS_COMMENT:
-		case SCE_SQL_SQLPLUS_PROMPT:
-			if (sc.atLineStart) {
-				sc.SetState(SCE_SQL_DEFAULT);
-			}
-			break;
-		case SCE_SQL_COMMENTDOCKEYWORD:
-			if ((styleBeforeDCKeyword == SCE_SQL_COMMENTDOC) && sc.Match('*', '/')) {
-				sc.ChangeState(SCE_SQL_COMMENTDOCKEYWORDERROR);
-				sc.Forward();
-				sc.ForwardSetState(SCE_SQL_DEFAULT);
-			} else if (!IsADoxygenChar(sc.ch)) {
-				char s[100];
-				sc.GetCurrentLowered(s, sizeof(s));
-				if (!isspace(sc.ch) || !kw_pldoc.InList(s + 1)) {
-					sc.ChangeState(SCE_SQL_COMMENTDOCKEYWORDERROR);
-				}
-				sc.SetState(styleBeforeDCKeyword);
-			}
-			break;
-		case SCE_SQL_CHARACTER:
-			if (sqlBackslashEscapes && sc.ch == '\\') {
-				sc.Forward();
-			} else if (sc.ch == '\'') {
-				if (sc.chNext == '\"') {
-					sc.Forward();
-				} else {
-					sc.ForwardSetState(SCE_SQL_DEFAULT);
-				}
-			}
-			break;
-		case SCE_SQL_STRING:
-			if (sc.ch == '\\') {
-				// Escape sequence
-				sc.Forward();
-			} else if (sc.ch == '\"') {
-				if (sc.chNext == '\"') {
-					sc.Forward();
-				} else {
-					sc.ForwardSetState(SCE_SQL_DEFAULT);
-				}
-			}
-			break;
-		}
-
-		// Determine if a new state should be entered.
-		if (sc.state == SCE_SQL_DEFAULT) {
-			if (IsADigit(sc.ch) || (sc.ch == '.' && IsADigit(sc.chNext))) {
-				sc.SetState(SCE_SQL_NUMBER);
-			} else if (IsAWordStart(sc.ch)) {
-				sc.SetState(SCE_SQL_IDENTIFIER);
-			} else if (sc.ch == 0x60 && sqlBackticksIdentifier) {
-				sc.SetState(SCE_SQL_QUOTEDIDENTIFIER);
-			} else if (sc.Match('/', '*')) {
-				if (sc.Match("/**") || sc.Match("/*!")) {	// Support of Doxygen doc. style
-					sc.SetState(SCE_SQL_COMMENTDOC);
-				} else {
-					sc.SetState(SCE_SQL_COMMENT);
-				}
-				sc.Forward();	// Eat the * so it isn't used for the end of the comment
-			} else if (sc.Match('-', '-')) {
-				// MySQL requires a space or control char after --
-				// http://dev.mysql.com/doc/mysql/en/ansi-diff-comments.html
-				// Perhaps we should enforce that with proper property:
-//~ 			} else if (sc.Match("-- ")) {
-				sc.SetState(SCE_SQL_COMMENTLINE);
-			} else if (sc.ch == '#') {
-				sc.SetState(SCE_SQL_COMMENTLINEDOC);
-			} else if (sc.ch == '\'') {
-				sc.SetState(SCE_SQL_CHARACTER);
-			} else if (sc.ch == '\"') {
-				sc.SetState(SCE_SQL_STRING);
-			} else if (isoperator(static_cast<char>(sc.ch))) {
-				sc.SetState(SCE_SQL_OPERATOR);
-			}
-		}
-	}
-	sc.Complete();
-}
-
-static bool IsStreamCommentStyle(int style) {
-	return style == SCE_SQL_COMMENT ||
-	       style == SCE_SQL_COMMENTDOC ||
-	       style == SCE_SQL_COMMENTDOCKEYWORD ||
-	       style == SCE_SQL_COMMENTDOCKEYWORDERROR;
-}
-
-// Store both the current line's fold level and the next lines in the
-// level store to make it easy to pick up with each increment.
-static void FoldSQLDoc(unsigned int startPos, int length, int initStyle,
-                            WordList *[], Accessor &styler) {
-	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
-	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	bool foldOnlyBegin = styler.GetPropertyInt("fold.sql.only.begin", 0) != 0;
-
-	unsigned int endPos = startPos + length;
-	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
-	int levelCurrent = SC_FOLDLEVELBASE;
-	if (lineCurrent > 0) {
-		levelCurrent = styler.LevelAt(lineCurrent - 1) >> 16;
-	}
-	int levelNext = levelCurrent;
-	char chNext = styler[startPos];
-	int styleNext = styler.StyleAt(startPos);
-	int style = initStyle;
-	bool endFound = false;
-	for (unsigned int i = startPos; i < endPos; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-		int stylePrev = style;
-		style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
-		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
-		if (foldComment && IsStreamCommentStyle(style)) {
-			if (!IsStreamCommentStyle(stylePrev)) {
-				levelNext++;
-			} else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
-				// Comments don't end at end of line and the next character may be unstyled.
-				levelNext--;
-			}
-		}
-		if (foldComment && (style == SCE_SQL_COMMENTLINE)) {
-			// MySQL needs -- comments to be followed by space or control char
-			if ((ch == '-') && (chNext == '-')) {
-				char chNext2 = styler.SafeGetCharAt(i + 2);
-				char chNext3 = styler.SafeGetCharAt(i + 3);
-				if (chNext2 == '{' || chNext3 == '{') {
-					levelNext++;
-				} else if (chNext2 == '}' || chNext3 == '}') {
-					levelNext--;
-				}
-			}
-		}
-		if (style == SCE_SQL_OPERATOR) {
-			if (ch == '(') {
-				levelNext++;
-			} else if (ch == ')') {
-				levelNext--;
-			}
-		}
-		// If new keyword (cannot trigger on elseif or nullif, does less tests)
-		if (style == SCE_SQL_WORD && stylePrev != SCE_SQL_WORD) {
-			const int MAX_KW_LEN = 6;	// Maximum length of folding keywords
-			char s[MAX_KW_LEN + 2];
-			unsigned int j = 0;
-			for (; j < MAX_KW_LEN + 1; j++) {
-				if (!iswordchar(styler[i + j])) {
-					break;
-				}
-				s[j] = static_cast<char>(tolower(styler[i + j]));
-			}
-			if (j == MAX_KW_LEN + 1) {
-				// Keyword too long, don't test it
-				s[0] = '\0';
-			} else {
-				s[j] = '\0';
-			}
-			if ((!foldOnlyBegin) && (strcmp(s, "if") == 0 || strcmp(s, "loop") == 0)) {
-				if (endFound) {
-					// ignore
-					endFound = false;
-				} else {
-					levelNext++;
-				}
-			} else if (strcmp(s, "begin") == 0) {
-				levelNext++;
-			} else if (strcmp(s, "end") == 0 ||
-						// DROP TABLE IF EXISTS or CREATE TABLE IF NOT EXISTS
-						strcmp(s, "exists") == 0) {
-				endFound = true;
-				levelNext--;
-				if (levelNext < SC_FOLDLEVELBASE) {
-					levelNext = SC_FOLDLEVELBASE;
-				}
-			}
-		}
-		if (atEOL) {
-			int levelUse = levelCurrent;
-			int lev = levelUse | levelNext << 16;
-			if (visibleChars == 0 && foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if (levelUse < levelNext)
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
-			lineCurrent++;
-			levelCurrent = levelNext;
-			visibleChars = 0;
-			endFound = false;
-		}
-		if (!isspacechar(ch)) {
-			visibleChars++;
-		}
-	}
-}
-
-static const char * const sqlWordListDesc[] = {
-	"Keywords",
-	"Database Objects",
-	"PLDoc",
-	"SQL*Plus",
-	"User Keywords 1",
-	"User Keywords 2",
-	"User Keywords 3",
-	"User Keywords 4",
-	0
-};
-
-LexerModule lmSQL(SCLEX_SQL, ColouriseSQLDoc, "sql", FoldSQLDoc, sqlWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexTCL.cxx b/Pythonwin/Scintilla/src/LexTCL.cxx
deleted file mode 100644
index 3c175de2a..000000000
--- a/Pythonwin/Scintilla/src/LexTCL.cxx
+++ /dev/null
@@ -1,366 +0,0 @@
-// Scintilla source code edit control
-/** @file LexTCL.cxx
- ** Lexer for TCL language.
- **/
-// Copyright 1998-2001 by Andre Arpin <arpin@kingston.net>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdarg.h>
-#include <stdio.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-// Extended to accept accented characters
-static inline bool IsAWordChar(int ch) {
-	return ch >= 0x80 ||
-        (isalnum(ch) || ch == '_' || ch ==':' || ch=='.'); // : name space separator
-}
-
-static inline bool IsAWordStart(int ch) {
-	return ch >= 0x80 || (ch ==':' || isalpha(ch) || ch == '_');
-}
-
-static inline bool IsANumberChar(int ch) {
-	// Not exactly following number definition (several dots are seen as OK, etc.)
-	// but probably enough in most cases.
-	return (ch < 0x80) &&
-	       (IsADigit(ch, 0x10) || toupper(ch) == 'E' ||
-	        ch == '.' || ch == '-' || ch == '+');
-}
-
-static void ColouriseTCLDoc(unsigned int startPos, int length, int , WordList *keywordlists[], Accessor &styler) {
-#define  isComment(s) (s==SCE_TCL_COMMENT || s==SCE_TCL_COMMENTLINE || s==SCE_TCL_COMMENT_BOX || s==SCE_TCL_BLOCK_COMMENT)
-	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
-	bool commentLevel = false;
-    bool subBrace = false; // substitution begin with a brace ${.....}
-	enum tLineState {LS_DEFAULT, LS_OPEN_COMMENT, LS_OPEN_DOUBLE_QUOTE, LS_COMMENT_BOX, LS_MASK_STATE = 0xf, 
-        LS_COMMAND_EXPECTED = 16, LS_BRACE_ONLY = 32 } lineState = LS_DEFAULT;
-	bool prevSlash = false;
-	int currentLevel = 0;
-    bool expected = 0;
-    bool subParen = 0;
-
-	int currentLine = styler.GetLine(startPos);
-    if (currentLine > 0)
-        currentLine--;
-	length += startPos - styler.LineStart(currentLine);
-	// make sure lines overlap
-	startPos = styler.LineStart(currentLine);
-
-	WordList &keywords = *keywordlists[0];
-	WordList &keywords2 = *keywordlists[1];
-	WordList &keywords3 = *keywordlists[2];
-	WordList &keywords4 = *keywordlists[3];
-	WordList &keywords5 = *keywordlists[4];
-	WordList &keywords6 = *keywordlists[5];
-	WordList &keywords7 = *keywordlists[6];
-    WordList &keywords8 = *keywordlists[7];
-    WordList &keywords9 = *keywordlists[8];
-
-	if (currentLine > 0) {
-        int ls = styler.GetLineState(currentLine - 1);
-		lineState = tLineState(ls & LS_MASK_STATE);
-		expected = LS_COMMAND_EXPECTED == tLineState(ls & LS_COMMAND_EXPECTED);
-        subBrace = LS_BRACE_ONLY == tLineState(ls & LS_BRACE_ONLY);
-		currentLevel = styler.LevelAt(currentLine - 1) >> 17;
-		commentLevel = (styler.LevelAt(currentLine - 1) >> 16) & 1;
-	} else
-		styler.SetLevel(0, SC_FOLDLEVELBASE | SC_FOLDLEVELHEADERFLAG);
-	bool visibleChars = false;
-
-	int previousLevel = currentLevel;
-    StyleContext sc(startPos, length, SCE_TCL_DEFAULT, styler);
-	for (; ; sc.Forward()) {
-next:
-        if (sc.ch=='\r' && sc.chNext == '\n') // only ignore \r on PC process on the mac 
-            continue;
-        bool atEnd = !sc.More();  // make sure we coloured the last word
-        if (lineState != LS_DEFAULT) {
-            sc.SetState(SCE_TCL_DEFAULT);
-            if (lineState == LS_OPEN_COMMENT)
-                sc.SetState(SCE_TCL_COMMENTLINE);
-            else if (lineState == LS_OPEN_DOUBLE_QUOTE)
-                sc.SetState(SCE_TCL_IN_QUOTE);
-            else if (lineState == LS_COMMENT_BOX && (sc.ch == '#' || (sc.ch == ' ' && sc.chNext=='#')))
-                sc.SetState(SCE_TCL_COMMENT_BOX);
-            lineState = LS_DEFAULT;
-        }
-        if (subBrace) { // ${ overrides every thing even \ except }
-            if (sc.ch == '}') {
-                subBrace = false;
-                sc.SetState(SCE_TCL_OPERATOR);
-                sc.ForwardSetState(SCE_TCL_DEFAULT);
-                goto next;
-            }
-            else
-                sc.SetState(SCE_TCL_SUB_BRACE);
-            if (!sc.atLineEnd)
-                continue;
-        } else if (sc.state == SCE_TCL_DEFAULT || sc.state ==SCE_TCL_OPERATOR) {
-            expected &= isspacechar(static_cast<unsigned char>(sc.ch)) || IsAWordStart(sc.ch) || sc.ch =='#';
-        } else if (sc.state == SCE_TCL_SUBSTITUTION) {
-            switch(sc.ch) {
-            case '(':
-                subParen=true;
-                sc.SetState(SCE_TCL_OPERATOR);
-                sc.ForwardSetState(SCE_TCL_SUBSTITUTION);
-                continue;
-            case ')':
-                sc.SetState(SCE_TCL_OPERATOR);
-                subParen=false;
-                continue;
-            case '$':
-                continue;
-            case ',':
-                sc.SetState(SCE_TCL_OPERATOR);
-                if (subParen)
-                    sc.ForwardSetState(SCE_TCL_SUBSTITUTION);
-                continue;
-            default :
-                // maybe spaces should be allowed ???
-                if (!IsAWordChar(sc.ch)) { // probably the code is wrong
-                    sc.SetState(SCE_TCL_DEFAULT);
-                    subParen = 0;
-                }
-                break;
-            }
-        } else if (isComment(sc.state)) {
-        } else if (!IsAWordChar(sc.ch)) {
-            if ((sc.state == SCE_TCL_IDENTIFIER && expected) ||  sc.state == SCE_TCL_MODIFIER) {
-                char w[100];
-                char *s=w;
-                sc.GetCurrent(w, sizeof(w));
-                if (w[strlen(w)-1]=='\r')
-                    w[strlen(w)-1]=0;
-                while(*s == ':') // ignore leading : like in ::set a 10
-                    ++s;
-                bool quote = sc.state == SCE_TCL_IN_QUOTE;
-                if (commentLevel  || expected) {
-                    if (keywords.InList(s)) {
-                        sc.ChangeState(quote ? SCE_TCL_WORD_IN_QUOTE : SCE_TCL_WORD);
-                    } else if (keywords2.InList(s)) {
-                        sc.ChangeState(quote ? SCE_TCL_WORD_IN_QUOTE : SCE_TCL_WORD2);
-                    } else if (keywords3.InList(s)) {
-                        sc.ChangeState(quote ? SCE_TCL_WORD_IN_QUOTE : SCE_TCL_WORD3);
-                    } else if (keywords4.InList(s)) {
-                        sc.ChangeState(quote ? SCE_TCL_WORD_IN_QUOTE : SCE_TCL_WORD4);
-                    } else if (sc.GetRelative(-static_cast<int>(strlen(s))-1) == '{' &&
-                        keywords5.InList(s) && sc.ch == '}') { // {keyword} exactly no spaces
-                            sc.ChangeState(SCE_TCL_EXPAND);
-                    }
-                    if (keywords6.InList(s)) {
-                        sc.ChangeState(SCE_TCL_WORD5);
-                    } else if (keywords7.InList(s)) {
-                        sc.ChangeState(SCE_TCL_WORD6);
-                    } else if (keywords8.InList(s)) {
-                        sc.ChangeState(SCE_TCL_WORD7);
-                    } else if (keywords9.InList(s)) {
-                        sc.ChangeState(SCE_TCL_WORD8);
-                    } 
-                }
-                expected = false;
-                sc.SetState(quote ? SCE_TCL_IN_QUOTE : SCE_TCL_DEFAULT);
-            } else if (sc.state == SCE_TCL_MODIFIER || sc.state == SCE_TCL_IDENTIFIER) {
-                sc.SetState(SCE_TCL_DEFAULT);
-            }
-        }
-		if (atEnd)
-			break;
-        if (sc.atLineEnd) {
-            lineState = LS_DEFAULT;
-			currentLine = styler.GetLine(sc.currentPos);
-			if (foldComment && sc.state!=SCE_TCL_COMMENT && isComment(sc.state)) {
-				if (currentLevel == 0) {
-					++currentLevel;
-					commentLevel = true;
-				}
-			} else {
-				if (visibleChars && commentLevel) {
-					--currentLevel;
-					--previousLevel;
-					commentLevel = false;
-				}
-			}
-			int flag = 0;
-			if (!visibleChars)
-				flag = SC_FOLDLEVELWHITEFLAG;
-			if (currentLevel > previousLevel)
-				flag = SC_FOLDLEVELHEADERFLAG;
-			styler.SetLevel(currentLine, flag + previousLevel + SC_FOLDLEVELBASE + (currentLevel << 17) + (commentLevel << 16));
-
-			// Update the line state, so it can be seen by next line
-			if (sc.state == SCE_TCL_IN_QUOTE)
-				lineState = LS_OPEN_DOUBLE_QUOTE;
-			else {
-			     if (prevSlash) {
-				    if (isComment(sc.state))
-					    lineState = LS_OPEN_COMMENT;
-                } else if (sc.state == SCE_TCL_COMMENT_BOX)
-                    lineState = LS_COMMENT_BOX;
-			}
-            styler.SetLineState(currentLine, 
-                (subBrace ? LS_BRACE_ONLY : 0) |
-                (expected ? LS_COMMAND_EXPECTED : 0)  | lineState);
-            if (lineState == LS_COMMENT_BOX)
-                sc.ForwardSetState(SCE_TCL_COMMENT_BOX);
-            else if (lineState == LS_OPEN_DOUBLE_QUOTE)
-                sc.ForwardSetState(SCE_TCL_IN_QUOTE);
-            else
-                sc.ForwardSetState(SCE_TCL_DEFAULT);
-			prevSlash = false;
-			previousLevel = currentLevel;
-			goto next;
-		}
-
-		if (prevSlash) {
-            prevSlash = false;
-            if (sc.ch == '#' && IsANumberChar(sc.chNext))
-                sc.ForwardSetState(SCE_TCL_NUMBER);
-            continue;
-		}
-        prevSlash = sc.ch == '\\';
-        if (isComment(sc.state))
-            continue;
-		if (sc.atLineStart) {
-			visibleChars = false;
-			if (sc.state!=SCE_TCL_IN_QUOTE && !isComment(sc.state))
-            {
-				sc.SetState(SCE_TCL_DEFAULT);
-                expected = IsAWordStart(sc.ch)|| isspacechar(static_cast<unsigned char>(sc.ch));
-            }
-		}
-
-		switch (sc.state) {
-		case SCE_TCL_NUMBER:
-			if (!IsANumberChar(sc.ch))
-				sc.SetState(SCE_TCL_DEFAULT);
-			break;
-		case SCE_TCL_IN_QUOTE:
-			if (sc.ch == '"') {
-				sc.ForwardSetState(SCE_TCL_DEFAULT);
-				visibleChars = true; // necessary if a " is the first and only character on a line
-				goto next;
-			} else if (sc.ch == '[' || sc.ch == ']' || sc.ch == '$') {
-				sc.SetState(SCE_TCL_OPERATOR);
-                expected = sc.ch == '[';
-                sc.ForwardSetState(SCE_TCL_IN_QUOTE);
-				goto next;
-			}
-            continue;
-        case SCE_TCL_OPERATOR:
-			sc.SetState(SCE_TCL_DEFAULT);
-			break;
-		}
-
-		if (sc.ch == '#') {
-			if (visibleChars) {
-                if (sc.state != SCE_TCL_IN_QUOTE && expected)
-					sc.SetState(SCE_TCL_COMMENT);
-			} else {
-                sc.SetState(SCE_TCL_COMMENTLINE);
-                if (sc.chNext == '~')
-                    sc.SetState(SCE_TCL_BLOCK_COMMENT);
-                if (sc.atLineStart && (sc.chNext == '#' || sc.chNext == '-'))
-                        sc.SetState(SCE_TCL_COMMENT_BOX);
-            }
-        }
-
-		if (!isspacechar(static_cast<unsigned char>(sc.ch))) {
-			visibleChars = true;
-		}
-
-		if (sc.ch == '\\') {
-			prevSlash = true;
-			continue;		
-		}
-
-		// Determine if a new state should be entered.
-		if (sc.state == SCE_TCL_DEFAULT) {
-            if (IsAWordStart(sc.ch)) {
-				sc.SetState(SCE_TCL_IDENTIFIER);
-			} else if (IsADigit(sc.ch) && !IsAWordChar(sc.chPrev)) {
-				sc.SetState(SCE_TCL_NUMBER);
-			} else {
-				switch (sc.ch) {
-				case '\"':
-					sc.SetState(SCE_TCL_IN_QUOTE);
-					break;
-				case '{':
-					sc.SetState(SCE_TCL_OPERATOR);
-					expected = true;
-					++currentLevel;
-					break;
-				case '}':
-					sc.SetState(SCE_TCL_OPERATOR);
-					--currentLevel;
-					break;
-				case '[':
-                    expected = true;
-				case ']':
-				case '(':
-				case ')':
-					sc.SetState(SCE_TCL_OPERATOR);
-					break;
-				case ';':
-                    expected = true;
-					break;
-                case '$':
-                    subParen = 0;
-                    if (sc.chNext != '{') {
-                        sc.SetState(SCE_TCL_SUBSTITUTION);
-                    } 
-                    else {
-                        sc.SetState(SCE_TCL_OPERATOR);  // $
-                        sc.Forward();  // {
-                        sc.ForwardSetState(SCE_TCL_SUB_BRACE);
-                        subBrace = true;
-                    }
-                    break;
-                case '#':
-                    if ((isspacechar(static_cast<unsigned char>(sc.chPrev))||
-                            isoperator(static_cast<char>(sc.chPrev))) && IsADigit(sc.chNext,0x10))
-                        sc.SetState(SCE_TCL_NUMBER);
-                    break;
-                case '-':
-                    sc.SetState(IsADigit(sc.chNext)? SCE_TCL_NUMBER: SCE_TCL_MODIFIER);
-                    break;
-                default:
-                    if (isoperator(static_cast<char>(sc.ch))) {
-                        sc.SetState(SCE_TCL_OPERATOR);
-                    }
-				}
-			}
-		}
-	}
-	sc.Complete();
-}
-
-static const char * const tclWordListDesc[] = {
-            "TCL Keywords",
-            "TK Keywords",
-            "iTCL Keywords",
-            "tkCommands",
-            "expand"
-            "user1",
-            "user2",
-            "user3",
-            "user4",
-            0
-        };
-
-// this code supports folding in the colourizer
-LexerModule lmTCL(SCLEX_TCL, ColouriseTCLDoc, "tcl", 0, tclWordListDesc);
diff --git a/Pythonwin/Scintilla/src/LexVerilog.cxx b/Pythonwin/Scintilla/src/LexVerilog.cxx
deleted file mode 100644
index 52183fe8e..000000000
--- a/Pythonwin/Scintilla/src/LexVerilog.cxx
+++ /dev/null
@@ -1,305 +0,0 @@
-// Scintilla source code edit control
-/** @file LexVerilog.cxx
- ** Lexer for Verilog.
- ** Written by Avi Yegudin, based on C++ lexer by Neil Hodgson
- **/
-// Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-#include "KeyWords.h"
-#include "Scintilla.h"
-#include "SciLexer.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-static inline bool IsAWordChar(const int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '.' || ch == '_' || ch == '\'');
-}
-
-static inline bool IsAWordStart(const int ch) {
-	return (ch < 0x80) && (isalnum(ch) || ch == '_' || ch == '$');
-}
-
-static void ColouriseVerilogDoc(unsigned int startPos, int length, int initStyle, WordList *keywordlists[],
-                            Accessor &styler) {
-
-	WordList &keywords = *keywordlists[0];
-	WordList &keywords2 = *keywordlists[1];
-	WordList &keywords3 = *keywordlists[2];
-	WordList &keywords4 = *keywordlists[3];
-
-	// Do not leak onto next line
-	if (initStyle == SCE_V_STRINGEOL)
-		initStyle = SCE_V_DEFAULT;
-
-	StyleContext sc(startPos, length, initStyle, styler);
-
-	for (; sc.More(); sc.Forward()) {
-
-		if (sc.atLineStart && (sc.state == SCE_V_STRING)) {
-			// Prevent SCE_V_STRINGEOL from leaking back to previous line
-			sc.SetState(SCE_V_STRING);
-		}
-
-		// Handle line continuation generically.
-		if (sc.ch == '\\') {
-			if (sc.chNext == '\n' || sc.chNext == '\r') {
-				sc.Forward();
-				if (sc.ch == '\r' && sc.chNext == '\n') {
-					sc.Forward();
-				}
-				continue;
-			}
-		}
-
-		// Determine if the current state should terminate.
-		if (sc.state == SCE_V_OPERATOR) {
-			sc.SetState(SCE_V_DEFAULT);
-		} else if (sc.state == SCE_V_NUMBER) {
-			if (!IsAWordChar(sc.ch)) {
-				sc.SetState(SCE_V_DEFAULT);
-			}
-		} else if (sc.state == SCE_V_IDENTIFIER) {
-			if (!IsAWordChar(sc.ch) || (sc.ch == '.')) {
-				char s[100];
-                                sc.GetCurrent(s, sizeof(s));
-				if (keywords.InList(s)) {
-					sc.ChangeState(SCE_V_WORD);
-				} else if (keywords2.InList(s)) {
-					sc.ChangeState(SCE_V_WORD2);
-				} else if (keywords3.InList(s)) {
-					sc.ChangeState(SCE_V_WORD3);
-                                } else if (keywords4.InList(s)) {
-					sc.ChangeState(SCE_V_USER);
-				}
-				sc.SetState(SCE_V_DEFAULT);
-			}
-		} else if (sc.state == SCE_V_PREPROCESSOR) {
-                        if (!IsAWordChar(sc.ch)) {
-                                sc.SetState(SCE_V_DEFAULT);
-                        }
-		} else if (sc.state == SCE_V_COMMENT) {
-			if (sc.Match('*', '/')) {
-				sc.Forward();
-				sc.ForwardSetState(SCE_V_DEFAULT);
-			}
-		} else if (sc.state == SCE_V_COMMENTLINE || sc.state == SCE_V_COMMENTLINEBANG) {
-			if (sc.atLineStart) {
-				sc.SetState(SCE_V_DEFAULT);
-			}
-                } else if (sc.state == SCE_V_STRING) {
-			if (sc.ch == '\\') {
-				if (sc.chNext == '\"' || sc.chNext == '\'' || sc.chNext == '\\') {
-					sc.Forward();
-				}
-			} else if (sc.ch == '\"') {
-				sc.ForwardSetState(SCE_V_DEFAULT);
-			} else if (sc.atLineEnd) {
-				sc.ChangeState(SCE_V_STRINGEOL);
-				sc.ForwardSetState(SCE_V_DEFAULT);
-			}
-		}
-
-		// Determine if a new state should be entered.
-		if (sc.state == SCE_V_DEFAULT) {
-			if (IsADigit(sc.ch) || (sc.ch == '\'') || (sc.ch == '.' && IsADigit(sc.chNext))) {
-				sc.SetState(SCE_V_NUMBER);
-			} else if (IsAWordStart(sc.ch)) {
-				sc.SetState(SCE_V_IDENTIFIER);
-			} else if (sc.Match('/', '*')) {
-                                sc.SetState(SCE_V_COMMENT);
-				sc.Forward();	// Eat the * so it isn't used for the end of the comment
-			} else if (sc.Match('/', '/')) {
-				if (sc.Match("//!"))	// Nice to have a different comment style
-					sc.SetState(SCE_V_COMMENTLINEBANG);
-				else
-					sc.SetState(SCE_V_COMMENTLINE);
-			} else if (sc.ch == '\"') {
-				sc.SetState(SCE_V_STRING);
-			} else if (sc.ch == '`') {
-				sc.SetState(SCE_V_PREPROCESSOR);
-				// Skip whitespace between ` and preprocessor word
-				do {
-					sc.Forward();
-				} while ((sc.ch == ' ' || sc.ch == '\t') && sc.More());
-				if (sc.atLineEnd) {
-					sc.SetState(SCE_V_DEFAULT);
-				}
-			} else if (isoperator(static_cast<char>(sc.ch)) || sc.ch == '@' || sc.ch == '#') {
-				sc.SetState(SCE_V_OPERATOR);
-			}
-		}
-	}
-	sc.Complete();
-}
-
-static bool IsStreamCommentStyle(int style) {
-	return style == SCE_V_COMMENT;
-}
-
-// Store both the current line's fold level and the next lines in the
-// level store to make it easy to pick up with each increment
-// and to make it possible to fiddle the current level for "} else {".
-static void FoldNoBoxVerilogDoc(unsigned int startPos, int length, int initStyle,
-                            Accessor &styler) {
-	bool foldComment = styler.GetPropertyInt("fold.comment") != 0;
-	bool foldPreprocessor = styler.GetPropertyInt("fold.preprocessor") != 0;
-	bool foldCompact = styler.GetPropertyInt("fold.compact", 1) != 0;
-	bool foldAtElse = styler.GetPropertyInt("fold.at.else", 0) != 0;
-        // Verilog specific folding options:
-        // fold_at_module -
-        //      Generally used methodology in verilog code is
-        //      one module per file, so folding at module definition is useless.
-        // fold_at_brace/parenthese -
-        //      Folding of long port lists can be convenient.
-	bool foldAtModule = styler.GetPropertyInt("fold.verilog.flags", 0) != 0;
-	bool foldAtBrace  = 1;
-	bool foldAtParenthese  = 1;
-
-	unsigned int endPos = startPos + length;
-	int visibleChars = 0;
-	int lineCurrent = styler.GetLine(startPos);
-	int levelCurrent = SC_FOLDLEVELBASE;
-	if (lineCurrent > 0)
-		levelCurrent = styler.LevelAt(lineCurrent-1) >> 16;
-	int levelMinCurrent = levelCurrent;
-	int levelNext = levelCurrent;
-	char chNext = styler[startPos];
-	int styleNext = styler.StyleAt(startPos);
-	int style = initStyle;
-	for (unsigned int i = startPos; i < endPos; i++) {
-		char ch = chNext;
-		chNext = styler.SafeGetCharAt(i + 1);
-		int stylePrev = style;
-		style = styleNext;
-		styleNext = styler.StyleAt(i + 1);
-		bool atEOL = (ch == '\r' && chNext != '\n') || (ch == '\n');
-		if (foldComment && IsStreamCommentStyle(style)) {
-			if (!IsStreamCommentStyle(stylePrev)) {
-				levelNext++;
-			} else if (!IsStreamCommentStyle(styleNext) && !atEOL) {
-				// Comments don't end at end of line and the next character may be unstyled.
-				levelNext--;
-			}
-		}
-		if (foldComment && (style == SCE_V_COMMENTLINE)) {
-			if ((ch == '/') && (chNext == '/')) {
-				char chNext2 = styler.SafeGetCharAt(i + 2);
-				if (chNext2 == '{') {
-					levelNext++;
-				} else if (chNext2 == '}') {
-					levelNext--;
-				}
-			}
-		}
-		if (foldPreprocessor && (style == SCE_V_PREPROCESSOR)) {
-			if (ch == '`') {
-				unsigned int j = i + 1;
-				while ((j < endPos) && IsASpaceOrTab(styler.SafeGetCharAt(j))) {
-					j++;
-				}
-				if (styler.Match(j, "if")) {
-					levelNext++;
-				} else if (styler.Match(j, "end")) {
-					levelNext--;
-				}
-			}
-		}
-                if (style == SCE_V_OPERATOR) {
-                    if (foldAtParenthese) {
-			if (ch == '(') {
-				levelNext++;
-			} else if (ch == ')') {
-				levelNext--;
-			}
-                    }
-		}
-                if (style == SCE_V_OPERATOR) {
-                    if (foldAtBrace) {
-			if (ch == '{') {
-				levelNext++;
-			} else if (ch == '}') {
-				levelNext--;
-			}
-                    }
-		}
-                if (style == SCE_V_WORD && stylePrev != SCE_V_WORD) {
-                        unsigned int j = i;
-                        if (styler.Match(j, "case") ||
-                            styler.Match(j, "casex") ||
-                            styler.Match(j, "casez") ||
-                            styler.Match(j, "function") ||
-                            styler.Match(j, "fork") ||
-                            styler.Match(j, "table") ||
-                            styler.Match(j, "task") ||
-                            styler.Match(j, "generate") ||
-                            styler.Match(j, "specify") ||
-                            styler.Match(j, "primitive") ||
-                            styler.Match(j, "module") && foldAtModule ||
-                            styler.Match(j, "begin")) {
-                                levelNext++;
-                        } else if (styler.Match(j, "endcase") ||
-                                   styler.Match(j, "endfunction") ||
-                                   styler.Match(j, "join") ||
-                                   styler.Match(j, "endtask") ||
-                                   styler.Match(j, "endgenerate") ||
-                                   styler.Match(j, "endtable") ||
-                                   styler.Match(j, "endspecify") ||
-                                   styler.Match(j, "endprimitive") ||
-                                   styler.Match(j, "endmodule") && foldAtModule ||
-                                   styler.Match(j, "end") && !IsAWordChar(styler.SafeGetCharAt(j+3))) {
-                                levelNext--;
-                        }
-		}
-		if (atEOL) {
-			int levelUse = levelCurrent;
-			if (foldAtElse) {
-				levelUse = levelMinCurrent;
-			}
-			int lev = levelUse | levelNext << 16;
-			if (visibleChars == 0 && foldCompact)
-				lev |= SC_FOLDLEVELWHITEFLAG;
-			if (levelUse < levelNext)
-				lev |= SC_FOLDLEVELHEADERFLAG;
-			if (lev != styler.LevelAt(lineCurrent)) {
-				styler.SetLevel(lineCurrent, lev);
-			}
-			lineCurrent++;
-			levelCurrent = levelNext;
-			levelMinCurrent = levelCurrent;
-			visibleChars = 0;
-		}
-		if (!isspacechar(ch))
-			visibleChars++;
-	}
-}
-
-static void FoldVerilogDoc(unsigned int startPos, int length, int initStyle, WordList *[],
-                       Accessor &styler) {
-	FoldNoBoxVerilogDoc(startPos, length, initStyle, styler);
-}
-
-static const char * const verilogWordLists[] = {
-            "Primary keywords and identifiers",
-            "Secondary keywords and identifiers",
-            "System Tasks",
-            "User defined tasks and identifiers",
-            "Unused",
-            0,
-        };
-
-
-LexerModule lmVerilog(SCLEX_VERILOG, ColouriseVerilogDoc, "verilog", FoldVerilogDoc, verilogWordLists);
diff --git a/Pythonwin/Scintilla/src/LineMarker.cxx b/Pythonwin/Scintilla/src/LineMarker.cxx
index f79c3c085..6c61d6d51 100644
--- a/Pythonwin/Scintilla/src/LineMarker.cxx
+++ b/Pythonwin/Scintilla/src/LineMarker.cxx
@@ -1,309 +1,521 @@
 // Scintilla source code edit control
 /** @file LineMarker.cxx
- ** Defines the look of a line marker in the margin .
+ ** Defines the look of a line marker in the margin.
  **/
-// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <string.h>
+#include <cstring>
+#include <cmath>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <memory>
 
 #include "Platform.h"
 
 #include "Scintilla.h"
+
+#include "IntegerRectangle.h"
 #include "XPM.h"
 #include "LineMarker.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-void LineMarker::RefreshColourPalette(Palette &pal, bool want) {
-	pal.WantFind(fore, want);
-	pal.WantFind(back, want);
-	if (pxpm) {
-		pxpm->RefreshColourPalette(pal, want);
+LineMarker::LineMarker(const LineMarker &other) {
+	// Defined to avoid pxpm and image being blindly copied, not as a complete copy constructor.
+	markType = other.markType;
+	fore = other.fore;
+	back = other.back;
+	backSelected = other.backSelected;
+	alpha = other.alpha;
+	if (other.pxpm)
+		pxpm = std::make_unique<XPM>(*other.pxpm);
+	else
+		pxpm = nullptr;
+	if (other.image)
+		image = std::make_unique<RGBAImage>(*other.image);
+	else
+		image = nullptr;
+	customDraw = other.customDraw;
+}
+
+LineMarker &LineMarker::operator=(const LineMarker &other) {
+	// Defined to avoid pxpm and image being blindly copied, not as a complete assignment operator.
+	if (this != &other) {
+		markType = other.markType;
+		fore = other.fore;
+		back = other.back;
+		backSelected = other.backSelected;
+		alpha = other.alpha;
+		if (other.pxpm)
+			pxpm = std::make_unique<XPM>(*other.pxpm);
+		else
+			pxpm = nullptr;
+		if (other.image)
+			image = std::make_unique<RGBAImage>(*other.image);
+		else
+			image = nullptr;
+		customDraw = other.customDraw;
 	}
+	return *this;
 }
 
 void LineMarker::SetXPM(const char *textForm) {
-	delete pxpm;
-	pxpm = new XPM(textForm);
+	pxpm = std::make_unique<XPM>(textForm);
 	markType = SC_MARK_PIXMAP;
 }
 
-void LineMarker::SetXPM(const char * const *linesForm) {
-	delete pxpm;
-	pxpm = new XPM(linesForm);
+void LineMarker::SetXPM(const char *const *linesForm) {
+	pxpm = std::make_unique<XPM>(linesForm);
 	markType = SC_MARK_PIXMAP;
 }
 
-static void DrawBox(Surface *surface, int centreX, int centreY, int armSize, ColourAllocated fore, ColourAllocated back) {
-	PRectangle rc;
-	rc.left = centreX - armSize;
-	rc.top = centreY - armSize;
-	rc.right = centreX + armSize + 1;
-	rc.bottom = centreY + armSize + 1;
+void LineMarker::SetRGBAImage(Point sizeRGBAImage, float scale, const unsigned char *pixelsRGBAImage) {
+	image = std::make_unique<RGBAImage>(static_cast<int>(sizeRGBAImage.x), static_cast<int>(sizeRGBAImage.y), scale, pixelsRGBAImage);
+	markType = SC_MARK_RGBAIMAGE;
+}
+
+static void DrawBox(Surface *surface, int centreX, int centreY, int armSize, ColourDesired fore, ColourDesired back) {
+	const PRectangle rc = PRectangle::FromInts(
+				      centreX - armSize,
+				      centreY - armSize,
+				      centreX + armSize + 1,
+				      centreY + armSize + 1);
 	surface->RectangleDraw(rc, back, fore);
 }
 
-static void DrawCircle(Surface *surface, int centreX, int centreY, int armSize, ColourAllocated fore, ColourAllocated back) {
-	PRectangle rcCircle;
-	rcCircle.left = centreX - armSize;
-	rcCircle.top = centreY - armSize;
-	rcCircle.right = centreX + armSize + 1;
-	rcCircle.bottom = centreY + armSize + 1;
+static void DrawCircle(Surface *surface, int centreX, int centreY, int armSize, ColourDesired fore, ColourDesired back) {
+	const PRectangle rcCircle = PRectangle::FromInts(
+					    centreX - armSize,
+					    centreY - armSize,
+					    centreX + armSize + 1,
+					    centreY + armSize + 1);
 	surface->Ellipse(rcCircle, back, fore);
 }
 
-static void DrawPlus(Surface *surface, int centreX, int centreY, int armSize, ColourAllocated fore) {
-	PRectangle rcV(centreX, centreY - armSize + 2, centreX + 1, centreY + armSize - 2 + 1);
+static void DrawPlus(Surface *surface, int centreX, int centreY, int armSize, ColourDesired fore) {
+	const PRectangle rcV = PRectangle::FromInts(centreX, centreY - armSize + 2, centreX + 1, centreY + armSize - 2 + 1);
 	surface->FillRectangle(rcV, fore);
-	PRectangle rcH(centreX - armSize + 2, centreY, centreX + armSize - 2 + 1, centreY+1);
+	const PRectangle rcH = PRectangle::FromInts(centreX - armSize + 2, centreY, centreX + armSize - 2 + 1, centreY + 1);
 	surface->FillRectangle(rcH, fore);
 }
 
-static void DrawMinus(Surface *surface, int centreX, int centreY, int armSize, ColourAllocated fore) {
-	PRectangle rcH(centreX - armSize + 2, centreY, centreX + armSize - 2 + 1, centreY+1);
+static void DrawMinus(Surface *surface, int centreX, int centreY, int armSize, ColourDesired fore) {
+	const PRectangle rcH = PRectangle::FromInts(centreX - armSize + 2, centreY, centreX + armSize - 2 + 1, centreY + 1);
 	surface->FillRectangle(rcH, fore);
 }
 
-void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharacter) {
+void LineMarker::Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharacter, FoldPart part, int marginStyle) const {
+	if (customDraw) {
+		customDraw(surface, rcWhole, fontForCharacter, static_cast<int>(part), marginStyle, this);
+		return;
+	}
+
+	ColourDesired colourHead = back;
+	ColourDesired colourBody = back;
+	ColourDesired colourTail = back;
+
+	switch (part) {
+	case FoldPart::head:
+	case FoldPart::headWithTail:
+		colourHead = backSelected;
+		colourTail = backSelected;
+		break;
+	case FoldPart::body:
+		colourHead = backSelected;
+		colourBody = backSelected;
+		break;
+	case FoldPart::tail:
+		colourBody = backSelected;
+		colourTail = backSelected;
+		break;
+	default:
+		// FoldPart::undefined
+		break;
+	}
+
 	if ((markType == SC_MARK_PIXMAP) && (pxpm)) {
 		pxpm->Draw(surface, rcWhole);
 		return;
 	}
+	if ((markType == SC_MARK_RGBAIMAGE) && (image)) {
+		// Make rectangle just large enough to fit image centred on centre of rcWhole
+		PRectangle rcImage;
+		rcImage.top = ((rcWhole.top + rcWhole.bottom) - image->GetScaledHeight()) / 2;
+		rcImage.bottom = rcImage.top + image->GetScaledHeight();
+		rcImage.left = ((rcWhole.left + rcWhole.right) - image->GetScaledWidth()) / 2;
+		rcImage.right = rcImage.left + image->GetScaledWidth();
+		surface->DrawRGBAImage(rcImage, image->GetWidth(), image->GetHeight(), image->Pixels());
+		return;
+	}
+
+	const IntegerRectangle ircWhole(rcWhole);
 	// Restrict most shapes a bit
-	PRectangle rc = rcWhole;
-	rc.top++;
-	rc.bottom--;
-	int minDim = Platform::Minimum(rc.Width(), rc.Height());
-	minDim--;	// Ensure does not go beyond edge
-	int centreX = (rc.right + rc.left) / 2;
-	int centreY = (rc.bottom + rc.top) / 2;
-	int dimOn2 = minDim / 2;
-	int dimOn4 = minDim / 4;
-	int blobSize = dimOn2-1;
-	int armSize = dimOn2-2;
-	if (rc.Width() > (rc.Height() * 2)) {
-		// Wide column is line number so move to left to try to avoid overlapping number
-		centreX = rc.left + dimOn2 + 1;
+	const PRectangle rc(rcWhole.left, rcWhole.top + 1, rcWhole.right, rcWhole.bottom - 1);
+	// Ensure does not go beyond edge
+	const int minDim = std::min(ircWhole.Width(), ircWhole.Height() - 2) - 1;
+	int centreX = (ircWhole.right + ircWhole.left) / 2;
+	const int centreY = (ircWhole.bottom + ircWhole.top) / 2;
+	const int dimOn2 = minDim / 2;
+	const int dimOn4 = minDim / 4;
+	const int blobSize = dimOn2 - 1;
+	const int armSize = dimOn2 - 2;
+	if (marginStyle == SC_MARGIN_NUMBER || marginStyle == SC_MARGIN_TEXT || marginStyle == SC_MARGIN_RTEXT) {
+		// On textual margins move marker to the left to try to avoid overlapping the text
+		centreX = ircWhole.left + dimOn2 + 1;
 	}
-	if (markType == SC_MARK_ROUNDRECT) {
-		PRectangle rcRounded = rc;
-		rcRounded.left = rc.left + 1;
-		rcRounded.right = rc.right - 1;
-		surface->RoundedRectangle(rcRounded, fore.allocated, back.allocated);
-	} else if (markType == SC_MARK_CIRCLE) {
-		PRectangle rcCircle;
-		rcCircle.left = centreX - dimOn2;
-		rcCircle.top = centreY - dimOn2;
-		rcCircle.right = centreX + dimOn2;
-		rcCircle.bottom = centreY + dimOn2;
-		surface->Ellipse(rcCircle, fore.allocated, back.allocated);
-	} else if (markType == SC_MARK_ARROW) {
-		Point pts[] = {
-    		Point(centreX - dimOn4, centreY - dimOn2),
-    		Point(centreX - dimOn4, centreY + dimOn2),
-    		Point(centreX + dimOn2 - dimOn4, centreY),
-		};
-		surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]),
-                 		fore.allocated, back.allocated);
-
-	} else if (markType == SC_MARK_ARROWDOWN) {
-		Point pts[] = {
-    		Point(centreX - dimOn2, centreY - dimOn4),
-    		Point(centreX + dimOn2, centreY - dimOn4),
-    		Point(centreX, centreY + dimOn2 - dimOn4),
-		};
-		surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]),
-                 		fore.allocated, back.allocated);
-
-	} else if (markType == SC_MARK_PLUS) {
-		Point pts[] = {
-    		Point(centreX - armSize, centreY - 1),
-    		Point(centreX - 1, centreY - 1),
-    		Point(centreX - 1, centreY - armSize),
-    		Point(centreX + 1, centreY - armSize),
-    		Point(centreX + 1, centreY - 1),
-    		Point(centreX + armSize, centreY -1),
-    		Point(centreX + armSize, centreY +1),
-    		Point(centreX + 1, centreY + 1),
-    		Point(centreX + 1, centreY + armSize),
-    		Point(centreX - 1, centreY + armSize),
-    		Point(centreX - 1, centreY + 1),
-    		Point(centreX - armSize, centreY + 1),
-		};
-		surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]),
-                 		fore.allocated, back.allocated);
-
-	} else if (markType == SC_MARK_MINUS) {
-		Point pts[] = {
-    		Point(centreX - armSize, centreY - 1),
-    		Point(centreX + armSize, centreY -1),
-    		Point(centreX + armSize, centreY +1),
-    		Point(centreX - armSize, centreY + 1),
-		};
-		surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]),
-                 		fore.allocated, back.allocated);
-
-	} else if (markType == SC_MARK_SMALLRECT) {
-		PRectangle rcSmall;
-		rcSmall.left = rc.left + 1;
-		rcSmall.top = rc.top + 2;
-		rcSmall.right = rc.right - 1;
-		rcSmall.bottom = rc.bottom - 2;
-		surface->RectangleDraw(rcSmall, fore.allocated, back.allocated);
-
-	} else if (markType == SC_MARK_EMPTY || markType == SC_MARK_BACKGROUND) {
+
+	switch (markType) {
+	case SC_MARK_ROUNDRECT: {
+			PRectangle rcRounded = rc;
+			rcRounded.left = rc.left + 1;
+			rcRounded.right = rc.right - 1;
+			surface->RoundedRectangle(rcRounded, fore, back);
+		}
+		break;
+
+	case SC_MARK_CIRCLE: {
+			const PRectangle rcCircle = PRectangle::FromInts(
+							    centreX - dimOn2,
+							    centreY - dimOn2,
+							    centreX + dimOn2,
+							    centreY + dimOn2);
+			surface->Ellipse(rcCircle, fore, back);
+		}
+		break;
+
+	case SC_MARK_ARROW: {
+			Point pts[] = {
+				Point::FromInts(centreX - dimOn4, centreY - dimOn2),
+				Point::FromInts(centreX - dimOn4, centreY + dimOn2),
+				Point::FromInts(centreX + dimOn2 - dimOn4, centreY),
+			};
+			surface->Polygon(pts, std::size(pts), fore, back);
+		}
+		break;
+
+	case SC_MARK_ARROWDOWN: {
+			Point pts[] = {
+				Point::FromInts(centreX - dimOn2, centreY - dimOn4),
+				Point::FromInts(centreX + dimOn2, centreY - dimOn4),
+				Point::FromInts(centreX, centreY + dimOn2 - dimOn4),
+			};
+			surface->Polygon(pts, std::size(pts), fore, back);
+		}
+		break;
+
+	case SC_MARK_PLUS: {
+			Point pts[] = {
+				Point::FromInts(centreX - armSize, centreY - 1),
+				Point::FromInts(centreX - 1, centreY - 1),
+				Point::FromInts(centreX - 1, centreY - armSize),
+				Point::FromInts(centreX + 1, centreY - armSize),
+				Point::FromInts(centreX + 1, centreY - 1),
+				Point::FromInts(centreX + armSize, centreY - 1),
+				Point::FromInts(centreX + armSize, centreY + 1),
+				Point::FromInts(centreX + 1, centreY + 1),
+				Point::FromInts(centreX + 1, centreY + armSize),
+				Point::FromInts(centreX - 1, centreY + armSize),
+				Point::FromInts(centreX - 1, centreY + 1),
+				Point::FromInts(centreX - armSize, centreY + 1),
+			};
+			surface->Polygon(pts, std::size(pts), fore, back);
+		}
+		break;
+
+	case SC_MARK_MINUS: {
+			Point pts[] = {
+				Point::FromInts(centreX - armSize, centreY - 1),
+				Point::FromInts(centreX + armSize, centreY - 1),
+				Point::FromInts(centreX + armSize, centreY + 1),
+				Point::FromInts(centreX - armSize, centreY + 1),
+			};
+			surface->Polygon(pts, std::size(pts), fore, back);
+		}
+		break;
+
+	case SC_MARK_SMALLRECT: {
+			PRectangle rcSmall;
+			rcSmall.left = rc.left + 1;
+			rcSmall.top = rc.top + 2;
+			rcSmall.right = rc.right - 1;
+			rcSmall.bottom = rc.bottom - 2;
+			surface->RectangleDraw(rcSmall, fore, back);
+		}
+		break;
+
+	case SC_MARK_EMPTY:
+	case SC_MARK_BACKGROUND:
+	case SC_MARK_UNDERLINE:
+	case SC_MARK_AVAILABLE:
 		// An invisible marker so don't draw anything
+		break;
+
+	case SC_MARK_VLINE: {
+			surface->PenColour(colourBody);
+			surface->MoveTo(centreX, ircWhole.top);
+			surface->LineTo(centreX, ircWhole.bottom);
+		}
+		break;
+
+	case SC_MARK_LCORNER: {
+			surface->PenColour(colourTail);
+			surface->MoveTo(centreX, ircWhole.top);
+			surface->LineTo(centreX, centreY);
+			surface->LineTo(ircWhole.right - 1, centreY);
+		}
+		break;
+
+	case SC_MARK_TCORNER: {
+			surface->PenColour(colourTail);
+			surface->MoveTo(centreX, centreY);
+			surface->LineTo(ircWhole.right - 1, centreY);
+
+			surface->PenColour(colourBody);
+			surface->MoveTo(centreX, ircWhole.top);
+			surface->LineTo(centreX, centreY + 1);
+
+			surface->PenColour(colourHead);
+			surface->LineTo(centreX, ircWhole.bottom);
+		}
+		break;
+
+	case SC_MARK_LCORNERCURVE: {
+			surface->PenColour(colourTail);
+			surface->MoveTo(centreX, ircWhole.top);
+			surface->LineTo(centreX, centreY - 3);
+			surface->LineTo(centreX + 3, centreY);
+			surface->LineTo(ircWhole.right - 1, centreY);
+		}
+		break;
+
+	case SC_MARK_TCORNERCURVE: {
+			surface->PenColour(colourTail);
+			surface->MoveTo(centreX, centreY - 3);
+			surface->LineTo(centreX + 3, centreY);
+			surface->LineTo(ircWhole.right - 1, centreY);
 
-	} else if (markType == SC_MARK_VLINE) {
-		surface->PenColour(back.allocated);
-		surface->MoveTo(centreX, rcWhole.top);
-		surface->LineTo(centreX, rcWhole.bottom);
-
-	} else if (markType == SC_MARK_LCORNER) {
-		surface->PenColour(back.allocated);
-		surface->MoveTo(centreX, rcWhole.top);
-		surface->LineTo(centreX, rc.top + dimOn2);
-		surface->LineTo(rc.right - 2, rc.top + dimOn2);
-
-	} else if (markType == SC_MARK_TCORNER) {
-		surface->PenColour(back.allocated);
-		surface->MoveTo(centreX, rcWhole.top);
-		surface->LineTo(centreX, rcWhole.bottom);
-		surface->MoveTo(centreX, rc.top + dimOn2);
-		surface->LineTo(rc.right - 2, rc.top + dimOn2);
-
-	} else if (markType == SC_MARK_LCORNERCURVE) {
-		surface->PenColour(back.allocated);
-		surface->MoveTo(centreX, rcWhole.top);
-		surface->LineTo(centreX, rc.top + dimOn2-3);
-		surface->LineTo(centreX+3, rc.top + dimOn2);
-		surface->LineTo(rc.right - 1, rc.top + dimOn2);
-
-	} else if (markType == SC_MARK_TCORNERCURVE) {
-		surface->PenColour(back.allocated);
-		surface->MoveTo(centreX, rcWhole.top);
-		surface->LineTo(centreX, rcWhole.bottom);
-
-		surface->MoveTo(centreX, rc.top + dimOn2-3);
-		surface->LineTo(centreX+3, rc.top + dimOn2);
-		surface->LineTo(rc.right - 1, rc.top + dimOn2);
-
-	} else if (markType == SC_MARK_BOXPLUS) {
-		surface->PenColour(back.allocated);
-		DrawBox(surface, centreX, centreY, blobSize, fore.allocated, back.allocated);
-		DrawPlus(surface, centreX, centreY, blobSize, back.allocated);
-
-	} else if (markType == SC_MARK_BOXPLUSCONNECTED) {
-		surface->PenColour(back.allocated);
-		DrawBox(surface, centreX, centreY, blobSize, fore.allocated, back.allocated);
-		DrawPlus(surface, centreX, centreY, blobSize, back.allocated);
-
-		surface->MoveTo(centreX, centreY + blobSize);
-		surface->LineTo(centreX, rcWhole.bottom);
-
-		surface->MoveTo(centreX, rcWhole.top);
-		surface->LineTo(centreX, centreY - blobSize);
-
-	} else if (markType == SC_MARK_BOXMINUS) {
-		surface->PenColour(back.allocated);
-		DrawBox(surface, centreX, centreY, blobSize, fore.allocated, back.allocated);
-		DrawMinus(surface, centreX, centreY, blobSize, back.allocated);
-
-		surface->MoveTo(centreX, centreY + blobSize);
-		surface->LineTo(centreX, rcWhole.bottom);
-
-	} else if (markType == SC_MARK_BOXMINUSCONNECTED) {
-		surface->PenColour(back.allocated);
-		DrawBox(surface, centreX, centreY, blobSize, fore.allocated, back.allocated);
-		DrawMinus(surface, centreX, centreY, blobSize, back.allocated);
-
-		surface->MoveTo(centreX, centreY + blobSize);
-		surface->LineTo(centreX, rcWhole.bottom);
-
-		surface->MoveTo(centreX, rcWhole.top);
-		surface->LineTo(centreX, centreY - blobSize);
-
-	} else if (markType == SC_MARK_CIRCLEPLUS) {
-		DrawCircle(surface, centreX, centreY, blobSize, fore.allocated, back.allocated);
-		surface->PenColour(back.allocated);
-		DrawPlus(surface, centreX, centreY, blobSize, back.allocated);
-
-	} else if (markType == SC_MARK_CIRCLEPLUSCONNECTED) {
-		DrawCircle(surface, centreX, centreY, blobSize, fore.allocated, back.allocated);
-		surface->PenColour(back.allocated);
-		DrawPlus(surface, centreX, centreY, blobSize, back.allocated);
-
-		surface->MoveTo(centreX, centreY + blobSize);
-		surface->LineTo(centreX, rcWhole.bottom);
-
-		surface->MoveTo(centreX, rcWhole.top);
-		surface->LineTo(centreX, centreY - blobSize);
-
-	} else if (markType == SC_MARK_CIRCLEMINUS) {
-		DrawCircle(surface, centreX, centreY, blobSize, fore.allocated, back.allocated);
-		surface->PenColour(back.allocated);
-		DrawMinus(surface, centreX, centreY, blobSize, back.allocated);
-
-		surface->MoveTo(centreX, centreY + blobSize);
-		surface->LineTo(centreX, rcWhole.bottom);
-
-	} else if (markType == SC_MARK_CIRCLEMINUSCONNECTED) {
-		DrawCircle(surface, centreX, centreY, blobSize, fore.allocated, back.allocated);
-		surface->PenColour(back.allocated);
-		DrawMinus(surface, centreX, centreY, blobSize, back.allocated);
-
-		surface->MoveTo(centreX, centreY + blobSize);
-		surface->LineTo(centreX, rcWhole.bottom);
-
-		surface->MoveTo(centreX, rcWhole.top);
-		surface->LineTo(centreX, centreY - blobSize);
-
-	} else if (markType >= SC_MARK_CHARACTER) {
-		char character[1];
-		character[0] = static_cast<char>(markType - SC_MARK_CHARACTER);
-		int width = surface->WidthText(fontForCharacter, character, 1);
-		rc.left += (rc.Width() - width) / 2;
-		rc.right = rc.left + width;
-		surface->DrawTextClipped(rc, fontForCharacter, rc.bottom - 2,
-			character, 1, fore.allocated, back.allocated);
-
-	} else if (markType == SC_MARK_DOTDOTDOT) {
-		int right = centreX - 6;
-		for (int b=0; b<3; b++) {
-			PRectangle rcBlob(right, rc.bottom - 4, right + 2, rc.bottom-2);
-			surface->FillRectangle(rcBlob, fore.allocated);
-			right += 5;
+			surface->PenColour(colourBody);
+			surface->MoveTo(centreX, ircWhole.top);
+			surface->LineTo(centreX, centreY - 2);
+
+			surface->PenColour(colourHead);
+			surface->LineTo(centreX, ircWhole.bottom);
+		}
+		break;
+
+	case SC_MARK_BOXPLUS: {
+			DrawBox(surface, centreX, centreY, blobSize, fore, colourHead);
+			DrawPlus(surface, centreX, centreY, blobSize, colourTail);
+		}
+		break;
+
+	case SC_MARK_BOXPLUSCONNECTED: {
+			if (part == FoldPart::headWithTail)
+				surface->PenColour(colourTail);
+			else
+				surface->PenColour(colourBody);
+			surface->MoveTo(centreX, centreY + blobSize);
+			surface->LineTo(centreX, ircWhole.bottom);
+
+			surface->PenColour(colourBody);
+			surface->MoveTo(centreX, ircWhole.top);
+			surface->LineTo(centreX, centreY - blobSize);
+
+			DrawBox(surface, centreX, centreY, blobSize, fore, colourHead);
+			DrawPlus(surface, centreX, centreY, blobSize, colourTail);
+
+			if (part == FoldPart::body) {
+				surface->PenColour(colourTail);
+				surface->MoveTo(centreX + 1, centreY + blobSize);
+				surface->LineTo(centreX + blobSize + 1, centreY + blobSize);
+
+				surface->MoveTo(centreX + blobSize, centreY + blobSize);
+				surface->LineTo(centreX + blobSize, centreY - blobSize);
+
+				surface->MoveTo(centreX + 1, centreY - blobSize);
+				surface->LineTo(centreX + blobSize + 1, centreY - blobSize);
+			}
+		}
+		break;
+
+	case SC_MARK_BOXMINUS: {
+			DrawBox(surface, centreX, centreY, blobSize, fore, colourHead);
+			DrawMinus(surface, centreX, centreY, blobSize, colourTail);
+
+			surface->PenColour(colourHead);
+			surface->MoveTo(centreX, centreY + blobSize);
+			surface->LineTo(centreX, ircWhole.bottom);
+		}
+		break;
+
+	case SC_MARK_BOXMINUSCONNECTED: {
+			DrawBox(surface, centreX, centreY, blobSize, fore, colourHead);
+			DrawMinus(surface, centreX, centreY, blobSize, colourTail);
+
+			surface->PenColour(colourHead);
+			surface->MoveTo(centreX, centreY + blobSize);
+			surface->LineTo(centreX, ircWhole.bottom);
+
+			surface->PenColour(colourBody);
+			surface->MoveTo(centreX, ircWhole.top);
+			surface->LineTo(centreX, centreY - blobSize);
+
+			if (part == FoldPart::body) {
+				surface->PenColour(colourTail);
+				surface->MoveTo(centreX + 1, centreY + blobSize);
+				surface->LineTo(centreX + blobSize + 1, centreY + blobSize);
+
+				surface->MoveTo(centreX + blobSize, centreY + blobSize);
+				surface->LineTo(centreX + blobSize, centreY - blobSize);
+
+				surface->MoveTo(centreX + 1, centreY - blobSize);
+				surface->LineTo(centreX + blobSize + 1, centreY - blobSize);
+			}
+		}
+		break;
+
+	case SC_MARK_CIRCLEPLUS: {
+			DrawCircle(surface, centreX, centreY, blobSize, fore, colourHead);
+			DrawPlus(surface, centreX, centreY, blobSize, colourTail);
+		}
+		break;
+
+	case SC_MARK_CIRCLEPLUSCONNECTED: {
+			if (part == FoldPart::headWithTail)
+				surface->PenColour(colourTail);
+			else
+				surface->PenColour(colourBody);
+			surface->MoveTo(centreX, centreY + blobSize);
+			surface->LineTo(centreX, ircWhole.bottom);
+
+			surface->PenColour(colourBody);
+			surface->MoveTo(centreX, ircWhole.top);
+			surface->LineTo(centreX, centreY - blobSize);
+
+			DrawCircle(surface, centreX, centreY, blobSize, fore, colourHead);
+			DrawPlus(surface, centreX, centreY, blobSize, colourTail);
+		}
+		break;
+
+	case SC_MARK_CIRCLEMINUS: {
+			surface->PenColour(colourHead);
+			surface->MoveTo(centreX, centreY + blobSize);
+			surface->LineTo(centreX, ircWhole.bottom);
+
+			DrawCircle(surface, centreX, centreY, blobSize, fore, colourHead);
+			DrawMinus(surface, centreX, centreY, blobSize, colourTail);
+		}
+		break;
+
+	case SC_MARK_CIRCLEMINUSCONNECTED: {
+			surface->PenColour(colourHead);
+			surface->MoveTo(centreX, centreY + blobSize);
+			surface->LineTo(centreX, ircWhole.bottom);
+
+			surface->PenColour(colourBody);
+			surface->MoveTo(centreX, ircWhole.top);
+			surface->LineTo(centreX, centreY - blobSize);
+
+			DrawCircle(surface, centreX, centreY, blobSize, fore, colourHead);
+			DrawMinus(surface, centreX, centreY, blobSize, colourTail);
+		}
+		break;
+
+	case SC_MARK_DOTDOTDOT: {
+			XYPOSITION right = static_cast<XYPOSITION>(centreX - 6);
+			for (int b = 0; b < 3; b++) {
+				const PRectangle rcBlob(right, rc.bottom - 4, right + 2, rc.bottom - 2);
+				surface->FillRectangle(rcBlob, fore);
+				right += 5.0f;
+			}
+		}
+		break;
+
+	case SC_MARK_ARROWS: {
+			surface->PenColour(fore);
+			int right = centreX - 2;
+			const int armLength = dimOn2 - 1;
+			for (int b = 0; b < 3; b++) {
+				surface->MoveTo(right, centreY);
+				surface->LineTo(right - armLength, centreY - armLength);
+				surface->MoveTo(right, centreY);
+				surface->LineTo(right - armLength, centreY + armLength);
+				right += 4;
+			}
+		}
+		break;
+
+	case SC_MARK_SHORTARROW: {
+			Point pts[] = {
+				Point::FromInts(centreX, centreY + dimOn2),
+				Point::FromInts(centreX + dimOn2, centreY),
+				Point::FromInts(centreX, centreY - dimOn2),
+				Point::FromInts(centreX, centreY - dimOn4),
+				Point::FromInts(centreX - dimOn4, centreY - dimOn4),
+				Point::FromInts(centreX - dimOn4, centreY + dimOn4),
+				Point::FromInts(centreX, centreY + dimOn4),
+				Point::FromInts(centreX, centreY + dimOn2),
+			};
+			surface->Polygon(pts, std::size(pts), fore, back);
+		}
+		break;
+
+	case SC_MARK_FULLRECT:
+		surface->FillRectangle(rcWhole, back);
+		break;
+
+	case SC_MARK_LEFTRECT: {
+			PRectangle rcLeft = rcWhole;
+			rcLeft.right = rcLeft.left + 4;
+			surface->FillRectangle(rcLeft, back);
+		}
+		break;
+
+	case SC_MARK_BOOKMARK: {
+			const int halfHeight = minDim / 3;
+			Point pts[] = {
+				Point::FromInts(ircWhole.left, centreY - halfHeight),
+				Point::FromInts(ircWhole.right - 3, centreY - halfHeight),
+				Point::FromInts(ircWhole.right - 3 - halfHeight, centreY),
+				Point::FromInts(ircWhole.right - 3, centreY + halfHeight),
+				Point::FromInts(ircWhole.left, centreY + halfHeight),
+			};
+			surface->Polygon(pts, std::size(pts), fore, back);
+		}
+		break;
+
+	case SC_MARK_VERTICALBOOKMARK: {
+			const int halfWidth = minDim / 3;
+			Point pts[] = {
+				Point::FromInts(centreX - halfWidth, centreY - dimOn2),
+				Point::FromInts(centreX + halfWidth, centreY - dimOn2),
+				Point::FromInts(centreX + halfWidth, centreY + dimOn2),
+				Point::FromInts(centreX, centreY + dimOn2 - halfWidth),
+				Point::FromInts(centreX - halfWidth, centreY + dimOn2),
+			};
+			surface->Polygon(pts, std::size(pts), fore, back);
 		}
-	} else if (markType == SC_MARK_ARROWS) {
-		surface->PenColour(fore.allocated);
-		int right = centreX - 2;
-		for (int b=0; b<3; b++) {
-			surface->MoveTo(right - 4, centreY - 4);
-			surface->LineTo(right, centreY);
-			surface->LineTo(right - 5, centreY + 5);
-			right += 4;
+		break;
+
+	default:
+		if (markType >= SC_MARK_CHARACTER) {
+			std::string character(1, static_cast<char>(markType - SC_MARK_CHARACTER));
+			const XYPOSITION width = surface->WidthText(fontForCharacter, character);
+			PRectangle rcText = rc;
+			rcText.left += (rc.Width() - width) / 2;
+			rcText.right = rc.left + width;
+			surface->DrawTextClipped(rcText, fontForCharacter, rcText.bottom - 2,
+						 character, fore, back);
+		} else {
+			// treat as SC_MARK_FULLRECT
+			surface->FillRectangle(rcWhole, back);
 		}
-	} else if (markType == SC_MARK_SHORTARROW) {
-		Point pts[] = {
-			Point(centreX, centreY + dimOn2),
-			Point(centreX + dimOn2, centreY),
-			Point(centreX, centreY - dimOn2),
-			Point(centreX, centreY - dimOn4),
-			Point(centreX - dimOn4, centreY - dimOn4),
-			Point(centreX - dimOn4, centreY + dimOn4),
-			Point(centreX, centreY + dimOn4),
-			Point(centreX, centreY + dimOn2),
-		};
-		surface->Polygon(pts, sizeof(pts) / sizeof(pts[0]),
-				fore.allocated, back.allocated);
-	} else if (markType == SC_MARK_LEFTRECT) {
-		PRectangle rcLeft = rcWhole;
-		rcLeft.right = rcLeft.left + 4;
-		surface->FillRectangle(rcLeft, back.allocated);
-	} else { // SC_MARK_FULLRECT
-		surface->FillRectangle(rcWhole, back.allocated);
+		break;
 	}
 }
diff --git a/Pythonwin/Scintilla/src/LineMarker.h b/Pythonwin/Scintilla/src/LineMarker.h
index 3cb4139f0..4173f065e 100644
--- a/Pythonwin/Scintilla/src/LineMarker.h
+++ b/Pythonwin/Scintilla/src/LineMarker.h
@@ -2,61 +2,51 @@
 /** @file LineMarker.h
  ** Defines the look of a line marker in the margin .
  **/
-// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
 #ifndef LINEMARKER_H
 #define LINEMARKER_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
+
+class XPM;
+class RGBAImage;
+
+typedef void (*DrawLineMarkerFn)(Surface *surface, PRectangle &rcWhole, Font &fontForCharacter, int tFold, int marginStyle, const void *lineMarker);
 
 /**
  */
 class LineMarker {
 public:
-	int markType;
-	ColourPair fore;
-	ColourPair back;
-	int alpha;
-	XPM *pxpm;
-	LineMarker() {
-		markType = SC_MARK_CIRCLE;
-		fore = ColourDesired(0,0,0);
-		back = ColourDesired(0xff,0xff,0xff);
-		alpha = SC_ALPHA_NOALPHA;
-		pxpm = NULL;
-	}
-	LineMarker(const LineMarker &) {
-		// Defined to avoid pxpm being blindly copied, not as real copy constructor
-		markType = SC_MARK_CIRCLE;
-		fore = ColourDesired(0,0,0);
-		back = ColourDesired(0xff,0xff,0xff);
-		alpha = SC_ALPHA_NOALPHA;
-		pxpm = NULL;
-	}
-	~LineMarker() {
-		delete pxpm;
-	}
-	LineMarker &operator=(const LineMarker &) {
-		// Defined to avoid pxpm being blindly copied, not as real assignment operator
-		markType = SC_MARK_CIRCLE;
-		fore = ColourDesired(0,0,0);
-		back = ColourDesired(0xff,0xff,0xff);
-		alpha = SC_ALPHA_NOALPHA;
-		delete pxpm;
-		pxpm = NULL;
-		return *this;
-	}
-	void RefreshColourPalette(Palette &pal, bool want);
+	enum class FoldPart { undefined, head, body, tail, headWithTail };
+
+	int markType = SC_MARK_CIRCLE;
+	ColourDesired fore = ColourDesired(0, 0, 0);
+	ColourDesired back = ColourDesired(0xff, 0xff, 0xff);
+	ColourDesired backSelected = ColourDesired(0xff, 0x00, 0x00);
+	int alpha = SC_ALPHA_NOALPHA;
+	std::unique_ptr<XPM> pxpm;
+	std::unique_ptr<RGBAImage> image;
+	/** Some platforms, notably PLAT_CURSES, do not support Scintilla's native
+	 * Draw function for drawing line markers. Allow those platforms to override
+	 * it instead of creating a new method(s) in the Surface class that existing
+	 * platforms must implement as empty. */
+	DrawLineMarkerFn customDraw = nullptr;
+
+	LineMarker() noexcept = default;
+	LineMarker(const LineMarker &other);
+	LineMarker(LineMarker &&) noexcept = default;
+	LineMarker &operator=(const LineMarker& other);
+	LineMarker &operator=(LineMarker&&) noexcept = default;
+	virtual ~LineMarker() = default;
+
 	void SetXPM(const char *textForm);
-	void SetXPM(const char * const *linesForm);
-	void Draw(Surface *surface, PRectangle &rc, Font &fontForCharacter);
+	void SetXPM(const char *const *linesForm);
+	void SetRGBAImage(Point sizeRGBAImage, float scale, const unsigned char *pixelsRGBAImage);
+	void Draw(Surface *surface, PRectangle &rcWhole, Font &fontForCharacter, FoldPart part, int marginStyle) const;
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/MarginView.cxx b/Pythonwin/Scintilla/src/MarginView.cxx
new file mode 100644
index 000000000..8fc24496f
--- /dev/null
+++ b/Pythonwin/Scintilla/src/MarginView.cxx
@@ -0,0 +1,474 @@
+// Scintilla source code edit control
+/** @file MarginView.cxx
+ ** Defines the appearance of the editor margin.
+ **/
+// Copyright 1998-2014 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cstdio>
+#include <cmath>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <memory>
+
+#include "Platform.h"
+
+#include "ILoader.h"
+#include "ILexer.h"
+#include "Scintilla.h"
+
+#include "CharacterCategory.h"
+#include "Position.h"
+#include "IntegerRectangle.h"
+#include "UniqueString.h"
+#include "SplitVector.h"
+#include "Partitioning.h"
+#include "RunStyles.h"
+#include "ContractionState.h"
+#include "CellBuffer.h"
+#include "KeyMap.h"
+#include "Indicator.h"
+#include "LineMarker.h"
+#include "Style.h"
+#include "ViewStyle.h"
+#include "CharClassify.h"
+#include "Decoration.h"
+#include "CaseFolder.h"
+#include "Document.h"
+#include "UniConversion.h"
+#include "Selection.h"
+#include "PositionCache.h"
+#include "EditModel.h"
+#include "MarginView.h"
+#include "EditView.h"
+
+using namespace Scintilla;
+
+namespace Scintilla {
+
+void DrawWrapMarker(Surface *surface, PRectangle rcPlace,
+	bool isEndMarker, ColourDesired wrapColour) {
+	surface->PenColour(wrapColour);
+
+	const IntegerRectangle ircPlace(rcPlace);
+
+	enum { xa = 1 }; // gap before start
+	const int w = ircPlace.Width() - xa - 1;
+
+	const bool xStraight = isEndMarker;  // x-mirrored symbol for start marker
+
+	const int x0 = xStraight ? ircPlace.left : ircPlace.right - 1;
+	const int y0 = ircPlace.top;
+
+	const int dy = ircPlace.Height() / 5;
+	const int y = ircPlace.Height() / 2 + dy;
+
+	struct Relative {
+		Surface *surface;
+		int xBase;
+		int xDir;
+		int yBase;
+		int yDir;
+		void MoveTo(int xRelative, int yRelative) {
+			surface->MoveTo(xBase + xDir * xRelative, yBase + yDir * yRelative);
+		}
+		void LineTo(int xRelative, int yRelative) {
+			surface->LineTo(xBase + xDir * xRelative, yBase + yDir * yRelative);
+		}
+	};
+	Relative rel = { surface, x0, xStraight ? 1 : -1, y0, 1 };
+
+	// arrow head
+	rel.MoveTo(xa, y);
+	rel.LineTo(xa + 2 * w / 3, y - dy);
+	rel.MoveTo(xa, y);
+	rel.LineTo(xa + 2 * w / 3, y + dy);
+
+	// arrow body
+	rel.MoveTo(xa, y);
+	rel.LineTo(xa + w, y);
+	rel.LineTo(xa + w, y - 2 * dy);
+	rel.LineTo(xa - 1,   // on windows lineto is exclusive endpoint, perhaps GTK not...
+		y - 2 * dy);
+}
+
+MarginView::MarginView() noexcept {
+	wrapMarkerPaddingRight = 3;
+	customDrawWrapMarker = nullptr;
+}
+
+void MarginView::DropGraphics(bool freeObjects) {
+	if (freeObjects) {
+		pixmapSelMargin.reset();
+		pixmapSelPattern.reset();
+		pixmapSelPatternOffset1.reset();
+	} else {
+		if (pixmapSelMargin)
+			pixmapSelMargin->Release();
+		if (pixmapSelPattern)
+			pixmapSelPattern->Release();
+		if (pixmapSelPatternOffset1)
+			pixmapSelPatternOffset1->Release();
+	}
+}
+
+void MarginView::AllocateGraphics(const ViewStyle &vsDraw) {
+	if (!pixmapSelMargin)
+		pixmapSelMargin.reset(Surface::Allocate(vsDraw.technology));
+	if (!pixmapSelPattern)
+		pixmapSelPattern.reset(Surface::Allocate(vsDraw.technology));
+	if (!pixmapSelPatternOffset1)
+		pixmapSelPatternOffset1.reset(Surface::Allocate(vsDraw.technology));
+}
+
+void MarginView::RefreshPixMaps(Surface *surfaceWindow, WindowID wid, const ViewStyle &vsDraw) {
+	if (!pixmapSelPattern->Initialised()) {
+		const int patternSize = 8;
+		pixmapSelPattern->InitPixMap(patternSize, patternSize, surfaceWindow, wid);
+		pixmapSelPatternOffset1->InitPixMap(patternSize, patternSize, surfaceWindow, wid);
+		// This complex procedure is to reproduce the checkerboard dithered pattern used by windows
+		// for scroll bars and Visual Studio for its selection margin. The colour of this pattern is half
+		// way between the chrome colour and the chrome highlight colour making a nice transition
+		// between the window chrome and the content area. And it works in low colour depths.
+		const PRectangle rcPattern = PRectangle::FromInts(0, 0, patternSize, patternSize);
+
+		// Initialize default colours based on the chrome colour scheme.  Typically the highlight is white.
+		ColourDesired colourFMFill = vsDraw.selbar;
+		ColourDesired colourFMStripes = vsDraw.selbarlight;
+
+		if (!(vsDraw.selbarlight == ColourDesired(0xff, 0xff, 0xff))) {
+			// User has chosen an unusual chrome colour scheme so just use the highlight edge colour.
+			// (Typically, the highlight colour is white.)
+			colourFMFill = vsDraw.selbarlight;
+		}
+
+		if (vsDraw.foldmarginColour.isSet) {
+			// override default fold margin colour
+			colourFMFill = vsDraw.foldmarginColour;
+		}
+		if (vsDraw.foldmarginHighlightColour.isSet) {
+			// override default fold margin highlight colour
+			colourFMStripes = vsDraw.foldmarginHighlightColour;
+		}
+
+		pixmapSelPattern->FillRectangle(rcPattern, colourFMFill);
+		pixmapSelPatternOffset1->FillRectangle(rcPattern, colourFMStripes);
+		for (int y = 0; y < patternSize; y++) {
+			for (int x = y % 2; x < patternSize; x += 2) {
+				const PRectangle rcPixel = PRectangle::FromInts(x, y, x + 1, y + 1);
+				pixmapSelPattern->FillRectangle(rcPixel, colourFMStripes);
+				pixmapSelPatternOffset1->FillRectangle(rcPixel, colourFMFill);
+			}
+		}
+	}
+}
+
+static int SubstituteMarkerIfEmpty(int markerCheck, int markerDefault, const ViewStyle &vs) noexcept {
+	if (vs.markers[markerCheck].markType == SC_MARK_EMPTY)
+		return markerDefault;
+	return markerCheck;
+}
+
+void MarginView::PaintMargin(Surface *surface, Sci::Line topLine, PRectangle rc, PRectangle rcMargin,
+	const EditModel &model, const ViewStyle &vs) {
+
+	PRectangle rcSelMargin = rcMargin;
+	rcSelMargin.right = rcMargin.left;
+	if (rcSelMargin.bottom < rc.bottom)
+		rcSelMargin.bottom = rc.bottom;
+
+	const Point ptOrigin = model.GetVisibleOriginInMain();
+	FontAlias fontLineNumber = vs.styles[STYLE_LINENUMBER].font;
+	for (size_t margin = 0; margin < vs.ms.size(); margin++) {
+		if (vs.ms[margin].width > 0) {
+
+			rcSelMargin.left = rcSelMargin.right;
+			rcSelMargin.right = rcSelMargin.left + vs.ms[margin].width;
+
+			if (vs.ms[margin].style != SC_MARGIN_NUMBER) {
+				if (vs.ms[margin].mask & SC_MASK_FOLDERS) {
+					// Required because of special way brush is created for selection margin
+					// Ensure patterns line up when scrolling with separate margin view
+					// by choosing correctly aligned variant.
+					const bool invertPhase = static_cast<int>(ptOrigin.y) & 1;
+					surface->FillRectangle(rcSelMargin,
+						invertPhase ? *pixmapSelPattern : *pixmapSelPatternOffset1);
+				} else {
+					ColourDesired colour;
+					switch (vs.ms[margin].style) {
+					case SC_MARGIN_BACK:
+						colour = vs.styles[STYLE_DEFAULT].back;
+						break;
+					case SC_MARGIN_FORE:
+						colour = vs.styles[STYLE_DEFAULT].fore;
+						break;
+					case SC_MARGIN_COLOUR:
+						colour = vs.ms[margin].back;
+						break;
+					default:
+						colour = vs.styles[STYLE_LINENUMBER].back;
+						break;
+					}
+					surface->FillRectangle(rcSelMargin, colour);
+				}
+			} else {
+				surface->FillRectangle(rcSelMargin, vs.styles[STYLE_LINENUMBER].back);
+			}
+
+			const int lineStartPaint = static_cast<int>(rcMargin.top + ptOrigin.y) / vs.lineHeight;
+			Sci::Line visibleLine = model.TopLineOfMain() + lineStartPaint;
+			Sci::Position yposScreen = lineStartPaint * vs.lineHeight - static_cast<Sci::Position>(ptOrigin.y);
+			// Work out whether the top line is whitespace located after a
+			// lessening of fold level which implies a 'fold tail' but which should not
+			// be displayed until the last of a sequence of whitespace.
+			bool needWhiteClosure = false;
+			if (vs.ms[margin].mask & SC_MASK_FOLDERS) {
+				const int level = model.pdoc->GetLevel(model.pcs->DocFromDisplay(visibleLine));
+				if (level & SC_FOLDLEVELWHITEFLAG) {
+					Sci::Line lineBack = model.pcs->DocFromDisplay(visibleLine);
+					int levelPrev = level;
+					while ((lineBack > 0) && (levelPrev & SC_FOLDLEVELWHITEFLAG)) {
+						lineBack--;
+						levelPrev = model.pdoc->GetLevel(lineBack);
+					}
+					if (!(levelPrev & SC_FOLDLEVELHEADERFLAG)) {
+						if (LevelNumber(level) < LevelNumber(levelPrev))
+							needWhiteClosure = true;
+					}
+				}
+				if (highlightDelimiter.isEnabled) {
+					const Sci::Line lastLine = model.pcs->DocFromDisplay(topLine + model.LinesOnScreen()) + 1;
+					model.pdoc->GetHighlightDelimiters(highlightDelimiter,
+						model.pdoc->SciLineFromPosition(model.sel.MainCaret()), lastLine);
+				}
+			}
+
+			// Old code does not know about new markers needed to distinguish all cases
+			const int folderOpenMid = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEROPENMID,
+				SC_MARKNUM_FOLDEROPEN, vs);
+			const int folderEnd = SubstituteMarkerIfEmpty(SC_MARKNUM_FOLDEREND,
+				SC_MARKNUM_FOLDER, vs);
+
+			while ((visibleLine < model.pcs->LinesDisplayed()) && yposScreen < rc.bottom) {
+
+				PLATFORM_ASSERT(visibleLine < model.pcs->LinesDisplayed());
+				const Sci::Line lineDoc = model.pcs->DocFromDisplay(visibleLine);
+				PLATFORM_ASSERT(model.pcs->GetVisible(lineDoc));
+				const Sci::Line firstVisibleLine = model.pcs->DisplayFromDoc(lineDoc);
+				const Sci::Line lastVisibleLine = model.pcs->DisplayLastFromDoc(lineDoc);
+				const bool firstSubLine = visibleLine == firstVisibleLine;
+				const bool lastSubLine = visibleLine == lastVisibleLine;
+
+				int marks = model.pdoc->GetMark(lineDoc);
+				if (!firstSubLine)
+					marks = 0;
+
+				bool headWithTail = false;
+
+				if (vs.ms[margin].mask & SC_MASK_FOLDERS) {
+					// Decide which fold indicator should be displayed
+					const int level = model.pdoc->GetLevel(lineDoc);
+					const int levelNext = model.pdoc->GetLevel(lineDoc + 1);
+					const int levelNum = LevelNumber(level);
+					const int levelNextNum = LevelNumber(levelNext);
+					if (level & SC_FOLDLEVELHEADERFLAG) {
+						if (firstSubLine) {
+							if (levelNum < levelNextNum) {
+								if (model.pcs->GetExpanded(lineDoc)) {
+									if (levelNum == SC_FOLDLEVELBASE)
+										marks |= 1 << SC_MARKNUM_FOLDEROPEN;
+									else
+										marks |= 1 << folderOpenMid;
+								} else {
+									if (levelNum == SC_FOLDLEVELBASE)
+										marks |= 1 << SC_MARKNUM_FOLDER;
+									else
+										marks |= 1 << folderEnd;
+								}
+							} else if (levelNum > SC_FOLDLEVELBASE) {
+								marks |= 1 << SC_MARKNUM_FOLDERSUB;
+							}
+						} else {
+							if (levelNum < levelNextNum) {
+								if (model.pcs->GetExpanded(lineDoc)) {
+									marks |= 1 << SC_MARKNUM_FOLDERSUB;
+								} else if (levelNum > SC_FOLDLEVELBASE) {
+									marks |= 1 << SC_MARKNUM_FOLDERSUB;
+								}
+							} else if (levelNum > SC_FOLDLEVELBASE) {
+								marks |= 1 << SC_MARKNUM_FOLDERSUB;
+							}
+						}
+						needWhiteClosure = false;
+						const Sci::Line firstFollowupLine = model.pcs->DocFromDisplay(model.pcs->DisplayFromDoc(lineDoc + 1));
+						const int firstFollowupLineLevel = model.pdoc->GetLevel(firstFollowupLine);
+						const int secondFollowupLineLevelNum = LevelNumber(model.pdoc->GetLevel(firstFollowupLine + 1));
+						if (!model.pcs->GetExpanded(lineDoc)) {
+							if ((firstFollowupLineLevel & SC_FOLDLEVELWHITEFLAG) &&
+								(levelNum > secondFollowupLineLevelNum))
+								needWhiteClosure = true;
+
+							if (highlightDelimiter.IsFoldBlockHighlighted(firstFollowupLine))
+								headWithTail = true;
+						}
+					} else if (level & SC_FOLDLEVELWHITEFLAG) {
+						if (needWhiteClosure) {
+							if (levelNext & SC_FOLDLEVELWHITEFLAG) {
+								marks |= 1 << SC_MARKNUM_FOLDERSUB;
+							} else if (levelNextNum > SC_FOLDLEVELBASE) {
+								marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
+								needWhiteClosure = false;
+							} else {
+								marks |= 1 << SC_MARKNUM_FOLDERTAIL;
+								needWhiteClosure = false;
+							}
+						} else if (levelNum > SC_FOLDLEVELBASE) {
+							if (levelNextNum < levelNum) {
+								if (levelNextNum > SC_FOLDLEVELBASE) {
+									marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
+								} else {
+									marks |= 1 << SC_MARKNUM_FOLDERTAIL;
+								}
+							} else {
+								marks |= 1 << SC_MARKNUM_FOLDERSUB;
+							}
+						}
+					} else if (levelNum > SC_FOLDLEVELBASE) {
+						if (levelNextNum < levelNum) {
+							needWhiteClosure = false;
+							if (levelNext & SC_FOLDLEVELWHITEFLAG) {
+								marks |= 1 << SC_MARKNUM_FOLDERSUB;
+								needWhiteClosure = true;
+							} else if (lastSubLine) {
+								if (levelNextNum > SC_FOLDLEVELBASE) {
+									marks |= 1 << SC_MARKNUM_FOLDERMIDTAIL;
+								} else {
+									marks |= 1 << SC_MARKNUM_FOLDERTAIL;
+								}
+							} else {
+								marks |= 1 << SC_MARKNUM_FOLDERSUB;
+							}
+						} else {
+							marks |= 1 << SC_MARKNUM_FOLDERSUB;
+						}
+					}
+				}
+
+				marks &= vs.ms[margin].mask;
+
+				PRectangle rcMarker(
+					rcSelMargin.left,
+					static_cast<XYPOSITION>(yposScreen),
+					rcSelMargin.right,
+					static_cast<XYPOSITION>(yposScreen + vs.lineHeight));
+				if (vs.ms[margin].style == SC_MARGIN_NUMBER) {
+					if (firstSubLine) {
+						std::string sNumber;
+						if (lineDoc >= 0) {
+							sNumber = std::to_string(lineDoc + 1);
+						}
+						if (model.foldFlags & (SC_FOLDFLAG_LEVELNUMBERS | SC_FOLDFLAG_LINESTATE)) {
+							char number[100] = "";
+							if (model.foldFlags & SC_FOLDFLAG_LEVELNUMBERS) {
+								const int lev = model.pdoc->GetLevel(lineDoc);
+								sprintf(number, "%c%c %03X %03X",
+									(lev & SC_FOLDLEVELHEADERFLAG) ? 'H' : '_',
+									(lev & SC_FOLDLEVELWHITEFLAG) ? 'W' : '_',
+									LevelNumber(lev),
+									lev >> 16
+									);
+							} else {
+								const int state = model.pdoc->GetLineState(lineDoc);
+								sprintf(number, "%0X", state);
+							}
+							sNumber = number;
+						}
+						PRectangle rcNumber = rcMarker;
+						// Right justify
+						const XYPOSITION width = surface->WidthText(fontLineNumber, sNumber);
+						const XYPOSITION xpos = rcNumber.right - width - vs.marginNumberPadding;
+						rcNumber.left = xpos;
+						DrawTextNoClipPhase(surface, rcNumber, vs.styles[STYLE_LINENUMBER],
+							rcNumber.top + vs.maxAscent, sNumber, drawAll);
+					} else if (vs.wrapVisualFlags & SC_WRAPVISUALFLAG_MARGIN) {
+						PRectangle rcWrapMarker = rcMarker;
+						rcWrapMarker.right -= wrapMarkerPaddingRight;
+						rcWrapMarker.left = rcWrapMarker.right - vs.styles[STYLE_LINENUMBER].aveCharWidth;
+						if (!customDrawWrapMarker) {
+							DrawWrapMarker(surface, rcWrapMarker, false, vs.styles[STYLE_LINENUMBER].fore);
+						} else {
+							customDrawWrapMarker(surface, rcWrapMarker, false, vs.styles[STYLE_LINENUMBER].fore);
+						}
+					}
+				} else if (vs.ms[margin].style == SC_MARGIN_TEXT || vs.ms[margin].style == SC_MARGIN_RTEXT) {
+					const StyledText stMargin = model.pdoc->MarginStyledText(lineDoc);
+					if (stMargin.text && ValidStyledText(vs, vs.marginStyleOffset, stMargin)) {
+						if (firstSubLine) {
+							surface->FillRectangle(rcMarker,
+								vs.styles[stMargin.StyleAt(0) + vs.marginStyleOffset].back);
+							PRectangle rcText = rcMarker;
+							if (vs.ms[margin].style == SC_MARGIN_RTEXT) {
+								const int width = WidestLineWidth(surface, vs, vs.marginStyleOffset, stMargin);
+								rcText.left = rcText.right - width - 3;
+							}
+							DrawStyledText(surface, vs, vs.marginStyleOffset, rcText,
+								stMargin, 0, stMargin.length, drawAll);
+						} else {
+							// if we're displaying annotation lines, colour the margin to match the associated document line
+							const int annotationLines = model.pdoc->AnnotationLines(lineDoc);
+							if (annotationLines && (visibleLine > lastVisibleLine - annotationLines)) {
+								surface->FillRectangle(rcMarker, vs.styles[stMargin.StyleAt(0) + vs.marginStyleOffset].back);
+							}
+						}
+					}
+				}
+
+				if (marks) {
+					for (int markBit = 0; (markBit < 32) && marks; markBit++) {
+						if (marks & 1) {
+							LineMarker::FoldPart part = LineMarker::FoldPart::undefined;
+							if ((vs.ms[margin].mask & SC_MASK_FOLDERS) && highlightDelimiter.IsFoldBlockHighlighted(lineDoc)) {
+								if (highlightDelimiter.IsBodyOfFoldBlock(lineDoc)) {
+									part = LineMarker::FoldPart::body;
+								} else if (highlightDelimiter.IsHeadOfFoldBlock(lineDoc)) {
+									if (firstSubLine) {
+										part = headWithTail ? LineMarker::FoldPart::headWithTail : LineMarker::FoldPart::head;
+									} else {
+										if (model.pcs->GetExpanded(lineDoc) || headWithTail) {
+											part = LineMarker::FoldPart::body;
+										} else {
+											part = LineMarker::FoldPart::undefined;
+										}
+									}
+								} else if (highlightDelimiter.IsTailOfFoldBlock(lineDoc)) {
+									part = LineMarker::FoldPart::tail;
+								}
+							}
+							vs.markers[markBit].Draw(surface, rcMarker, fontLineNumber, part, vs.ms[margin].style);
+						}
+						marks >>= 1;
+					}
+				}
+
+				visibleLine++;
+				yposScreen += vs.lineHeight;
+			}
+		}
+	}
+
+	PRectangle rcBlankMargin = rcMargin;
+	rcBlankMargin.left = rcSelMargin.right;
+	surface->FillRectangle(rcBlankMargin, vs.styles[STYLE_DEFAULT].back);
+}
+
+}
+
diff --git a/Pythonwin/Scintilla/src/MarginView.h b/Pythonwin/Scintilla/src/MarginView.h
new file mode 100644
index 000000000..4468afa1b
--- /dev/null
+++ b/Pythonwin/Scintilla/src/MarginView.h
@@ -0,0 +1,46 @@
+// Scintilla source code edit control
+/** @file MarginView.h
+ ** Defines the appearance of the editor margin.
+ **/
+// Copyright 1998-2014 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef MARGINVIEW_H
+#define MARGINVIEW_H
+
+namespace Scintilla {
+
+void DrawWrapMarker(Surface *surface, PRectangle rcPlace, bool isEndMarker, ColourDesired wrapColour);
+
+typedef void (*DrawWrapMarkerFn)(Surface *surface, PRectangle rcPlace, bool isEndMarker, ColourDesired wrapColour);
+
+/**
+* MarginView draws the margins.
+*/
+class MarginView {
+public:
+	std::unique_ptr<Surface> pixmapSelMargin;
+	std::unique_ptr<Surface> pixmapSelPattern;
+	std::unique_ptr<Surface> pixmapSelPatternOffset1;
+	// Highlight current folding block
+	HighlightDelimiter highlightDelimiter;
+
+	int wrapMarkerPaddingRight; // right-most pixel padding of wrap markers
+	/** Some platforms, notably PLAT_CURSES, do not support Scintilla's native
+	 * DrawWrapMarker function for drawing wrap markers. Allow those platforms to
+	 * override it instead of creating a new method in the Surface class that
+	 * existing platforms must implement as empty. */
+	DrawWrapMarkerFn customDrawWrapMarker;
+
+	MarginView() noexcept;
+
+	void DropGraphics(bool freeObjects);
+	void AllocateGraphics(const ViewStyle &vsDraw);
+	void RefreshPixMaps(Surface *surfaceWindow, WindowID wid, const ViewStyle &vsDraw);
+	void PaintMargin(Surface *surface, Sci::Line topLine, PRectangle rc, PRectangle rcMargin,
+		const EditModel &model, const ViewStyle &vs);
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/Partitioning.h b/Pythonwin/Scintilla/src/Partitioning.h
index 752e69614..195daae9b 100644
--- a/Pythonwin/Scintilla/src/Partitioning.h
+++ b/Pythonwin/Scintilla/src/Partitioning.h
@@ -8,33 +8,41 @@
 #ifndef PARTITIONING_H
 #define PARTITIONING_H
 
-/// A split vector of integers with a method for adding a value to all elements 
+namespace Scintilla {
+
+/// A split vector of integers with a method for adding a value to all elements
 /// in a range.
 /// Used by the Partitioning class.
 
-class SplitVectorWithRangeAdd : public SplitVector<int> {
+template <typename T>
+class SplitVectorWithRangeAdd : public SplitVector<T> {
 public:
-	SplitVectorWithRangeAdd(int growSize_) {
-		SetGrowSize(growSize_);
-		ReAllocate(growSize_);
+	explicit SplitVectorWithRangeAdd(ptrdiff_t growSize_) {
+		this->SetGrowSize(growSize_);
+		this->ReAllocate(growSize_);
 	}
+	// Deleted so SplitVectorWithRangeAdd objects can not be copied.
+	SplitVectorWithRangeAdd(const SplitVectorWithRangeAdd &) = delete;
+	SplitVectorWithRangeAdd(SplitVectorWithRangeAdd &&) = delete;
+	void operator=(const SplitVectorWithRangeAdd &) = delete;
+	void operator=(SplitVectorWithRangeAdd &&) = delete;
 	~SplitVectorWithRangeAdd() {
 	}
-	void RangeAddDelta(int start, int end, int delta) {
+	void RangeAddDelta(ptrdiff_t start, ptrdiff_t end, T delta) noexcept {
 		// end is 1 past end, so end-start is number of elements to change
-		int i = 0;
-		int rangeLength = end - start;
-		int range1Length = rangeLength;
-		int part1Left = part1Length - start;
+		ptrdiff_t i = 0;
+		const ptrdiff_t rangeLength = end - start;
+		ptrdiff_t range1Length = rangeLength;
+		const ptrdiff_t part1Left = this->part1Length - start;
 		if (range1Length > part1Left)
 			range1Length = part1Left;
 		while (i < range1Length) {
-			body[start++] += delta;
+			this->body[start++] += delta;
 			i++;
 		}
-		start += gapLength;
+		start += this->gapLength;
 		while (i < rangeLength) {
-			body[start++] += delta;
+			this->body[start++] += delta;
 			i++;
 		}
 	}
@@ -42,37 +50,42 @@ class SplitVectorWithRangeAdd : public SplitVector<int> {
 
 /// Divide an interval into multiple partitions.
 /// Useful for breaking a document down into sections such as lines.
+/// A 0 length interval has a single 0 length partition, numbered 0
+/// If interval not 0 length then each partition non-zero length
+/// When needed, positions after the interval are considered part of the last partition
+/// but the end of the last partition can be found with PositionFromPartition(last+1).
 
+template <typename T>
 class Partitioning {
 private:
 	// To avoid calculating all the partition positions whenever any text is inserted
 	// there may be a step somewhere in the list.
-	int stepPartition;
-	int stepLength;
-	SplitVectorWithRangeAdd *body;
+	T stepPartition;
+	T stepLength;
+	std::unique_ptr<SplitVectorWithRangeAdd<T>> body;
 
 	// Move step forward
-	void ApplyStep(int partitionUpTo) {
+	void ApplyStep(T partitionUpTo) noexcept {
 		if (stepLength != 0) {
 			body->RangeAddDelta(stepPartition+1, partitionUpTo + 1, stepLength);
 		}
 		stepPartition = partitionUpTo;
 		if (stepPartition >= body->Length()-1) {
-			stepPartition = body->Length()-1;
+			stepPartition = Partitions();
 			stepLength = 0;
 		}
 	}
 
 	// Move step backward
-	void BackStep(int partitionDownTo) {
+	void BackStep(T partitionDownTo) noexcept {
 		if (stepLength != 0) {
 			body->RangeAddDelta(partitionDownTo+1, stepPartition+1, -stepLength);
 		}
 		stepPartition = partitionDownTo;
 	}
 
-	void Allocate(int growSize) {
-		body = new SplitVectorWithRangeAdd(growSize);
+	void Allocate(ptrdiff_t growSize) {
+		body = std::make_unique<SplitVectorWithRangeAdd<T>>(growSize);
 		stepPartition = 0;
 		stepLength = 0;
 		body->Insert(0, 0);	// This value stays 0 for ever
@@ -80,20 +93,28 @@ class Partitioning {
 	}
 
 public:
-	Partitioning(int growSize) {
+	explicit Partitioning(int growSize) : stepPartition(0), stepLength(0) {
 		Allocate(growSize);
 	}
 
+	// Deleted so Partitioning objects can not be copied.
+	Partitioning(const Partitioning &) = delete;
+	Partitioning(Partitioning &&) = delete;
+	void operator=(const Partitioning &) = delete;
+	void operator=(Partitioning &&) = delete;
+
 	~Partitioning() {
-		delete body;
-		body = 0;
 	}
 
-	int Partitions() const {
-		return body->Length()-1;
+	T Partitions() const noexcept {
+		return static_cast<T>(body->Length())-1;
+	}
+
+	T Length() const noexcept {
+		return PositionFromPartition(Partitions());
 	}
 
-	void InsertPartition(int partition, int pos) {
+	void InsertPartition(T partition, T pos) {
 		if (stepPartition < partition) {
 			ApplyStep(partition);
 		}
@@ -101,7 +122,27 @@ class Partitioning {
 		stepPartition++;
 	}
 
-	void SetPartitionStartPosition(int partition, int pos) {
+	void InsertPartitions(T partition, const T *positions, size_t length) {
+		if (stepPartition < partition) {
+			ApplyStep(partition);
+		}
+		body->InsertFromArray(partition, positions, 0, length);
+		stepPartition += static_cast<T>(length);
+	}
+
+	void InsertPartitionsWithCast(T partition, const ptrdiff_t *positions, size_t length) {
+		// Used for 64-bit builds when T is 32-bits
+		if (stepPartition < partition) {
+			ApplyStep(partition);
+		}
+		T *pInsertion = body->InsertEmpty(partition, length);
+		for (size_t i = 0; i < length; i++) {
+			pInsertion[i] = static_cast<T>(positions[i]);
+		}
+		stepPartition += static_cast<T>(length);
+	}
+
+	void SetPartitionStartPosition(T partition, T pos) noexcept {
 		ApplyStep(partition+1);
 		if ((partition < 0) || (partition > body->Length())) {
 			return;
@@ -109,7 +150,7 @@ class Partitioning {
 		body->SetValueAt(partition, pos);
 	}
 
-	void InsertText(int partitionInsert, int delta) {
+	void InsertText(T partitionInsert, T delta) noexcept {
 		// Point all the partitions after the insertion point further along in the buffer
 		if (stepLength != 0) {
 			if (partitionInsert >= stepPartition) {
@@ -121,7 +162,7 @@ class Partitioning {
 				BackStep(partitionInsert);
 				stepLength += delta;
 			} else {
-				ApplyStep(body->Length()-1);
+				ApplyStep(Partitions());
 				stepPartition = partitionInsert;
 				stepLength = delta;
 			}
@@ -131,7 +172,7 @@ class Partitioning {
 		}
 	}
 
-	void RemovePartition(int partition) {
+	void RemovePartition(T partition) {
 		if (partition > stepPartition) {
 			ApplyStep(partition);
 			stepPartition--;
@@ -141,28 +182,30 @@ class Partitioning {
 		body->Delete(partition);
 	}
 
-	int PositionFromPartition(int partition) const {
+	T PositionFromPartition(T partition) const noexcept {
 		PLATFORM_ASSERT(partition >= 0);
 		PLATFORM_ASSERT(partition < body->Length());
-		if ((partition < 0) || (partition >= body->Length())) {
+		const ptrdiff_t lengthBody = body->Length();
+		if ((partition < 0) || (partition >= lengthBody)) {
 			return 0;
 		}
-		int pos = body->ValueAt(partition);
+		T pos = body->ValueAt(partition);
 		if (partition > stepPartition)
 			pos += stepLength;
 		return pos;
 	}
 
-	int PartitionFromPosition(int pos) {
+	/// Return value in range [0 .. Partitions() - 1] even for arguments outside interval
+	T PartitionFromPosition(T pos) const noexcept {
 		if (body->Length() <= 1)
 			return 0;
-		if (pos >= (PositionFromPartition(body->Length()-1)))
-			return body->Length() - 1 - 1;
-		int lower = 0;
-		int upper = body->Length()-1;
+		if (pos >= (PositionFromPartition(Partitions())))
+			return Partitions() - 1;
+		T lower = 0;
+		T upper = Partitions();
 		do {
-			int middle = (upper + lower + 1) / 2; 	// Round high
-			int posMiddle = body->ValueAt(middle);
+			const T middle = (upper + lower + 1) / 2; 	// Round high
+			T posMiddle = body->ValueAt(middle);
 			if (middle > stepPartition)
 				posMiddle += stepLength;
 			if (pos < posMiddle) {
@@ -175,10 +218,39 @@ class Partitioning {
 	}
 
 	void DeleteAll() {
-		int growSize = body->GetGrowSize();
-		delete body;
-		Allocate(growSize);
+		Allocate(body->GetGrowSize());
+	}
+
+	void Check() const {
+#ifdef CHECK_CORRECTNESS
+		if (Length() < 0) {
+			throw std::runtime_error("Partitioning: Length can not be negative.");
+		}
+		if (Partitions() < 1) {
+			throw std::runtime_error("Partitioning: Must always have 1 or more partitions.");
+		}
+		if (Length() == 0) {
+			if ((PositionFromPartition(0) != 0) || (PositionFromPartition(1) != 0)) {
+				throw std::runtime_error("Partitioning: Invalid empty partitioning.");
+			}
+		} else {
+			// Positions should be a strictly ascending sequence
+			for (T i = 0; i < Partitions(); i++) {
+				const T pos = PositionFromPartition(i);
+				const T posNext = PositionFromPartition(i+1);
+				if (pos > posNext) {
+					throw std::runtime_error("Partitioning: Negative partition.");
+				} else if (pos == posNext) {
+					throw std::runtime_error("Partitioning: Empty partition.");
+				}
+			}
+		}
+#endif
 	}
+
 };
 
+
+}
+
 #endif
diff --git a/Pythonwin/Scintilla/src/PerLine.cxx b/Pythonwin/Scintilla/src/PerLine.cxx
new file mode 100644
index 000000000..c7204e31a
--- /dev/null
+++ b/Pythonwin/Scintilla/src/PerLine.cxx
@@ -0,0 +1,546 @@
+// Scintilla source code edit control
+/** @file PerLine.cxx
+ ** Manages data associated with each line of the document
+ **/
+// Copyright 1998-2009 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstddef>
+#include <cassert>
+#include <cstring>
+
+#include <stdexcept>
+#include <string_view>
+#include <vector>
+#include <forward_list>
+#include <algorithm>
+#include <memory>
+
+#include "Platform.h"
+
+#include "Scintilla.h"
+#include "Position.h"
+#include "SplitVector.h"
+#include "Partitioning.h"
+#include "CellBuffer.h"
+#include "PerLine.h"
+
+using namespace Scintilla;
+
+MarkerHandleSet::MarkerHandleSet() {
+}
+
+MarkerHandleSet::~MarkerHandleSet() {
+	mhList.clear();
+}
+
+bool MarkerHandleSet::Empty() const noexcept {
+	return mhList.empty();
+}
+
+int MarkerHandleSet::MarkValue() const noexcept {
+	unsigned int m = 0;
+	for (const MarkerHandleNumber &mhn : mhList) {
+		m |= (1 << mhn.number);
+	}
+	return m;
+}
+
+bool MarkerHandleSet::Contains(int handle) const noexcept {
+	for (const MarkerHandleNumber &mhn : mhList) {
+		if (mhn.handle == handle) {
+			return true;
+		}
+	}
+	return false;
+}
+
+MarkerHandleNumber const *MarkerHandleSet::GetMarkerHandleNumber(int which) const noexcept {
+	for (const MarkerHandleNumber &mhn : mhList) {
+		if (which == 0)
+			return &mhn;
+		which--;
+	}
+	return nullptr;
+}
+
+bool MarkerHandleSet::InsertHandle(int handle, int markerNum) {
+	mhList.push_front(MarkerHandleNumber(handle, markerNum));
+	return true;
+}
+
+void MarkerHandleSet::RemoveHandle(int handle) {
+	mhList.remove_if([handle](const MarkerHandleNumber &mhn) noexcept { return mhn.handle == handle; });
+}
+
+bool MarkerHandleSet::RemoveNumber(int markerNum, bool all) {
+	bool performedDeletion = false;
+	mhList.remove_if([&](const MarkerHandleNumber &mhn) noexcept {
+		if ((all || !performedDeletion) && (mhn.number == markerNum)) {
+			performedDeletion = true;
+			return true;
+		}
+		return false;
+	});
+	return performedDeletion;
+}
+
+void MarkerHandleSet::CombineWith(MarkerHandleSet *other) noexcept {
+	mhList.splice_after(mhList.before_begin(), other->mhList);
+}
+
+LineMarkers::~LineMarkers() {
+}
+
+void LineMarkers::Init() {
+	markers.DeleteAll();
+}
+
+void LineMarkers::InsertLine(Sci::Line line) {
+	if (markers.Length()) {
+		markers.Insert(line, 0);
+	}
+}
+
+void LineMarkers::InsertLines(Sci::Line line, Sci::Line lines) {
+	if (markers.Length()) {
+		markers.InsertEmpty(line, lines);
+	}
+}
+
+void LineMarkers::RemoveLine(Sci::Line line) {
+	// Retain the markers from the deleted line by oring them into the previous line
+	if (markers.Length()) {
+		if (line > 0) {
+			MergeMarkers(line - 1);
+		}
+		markers.Delete(line);
+	}
+}
+
+Sci::Line LineMarkers::LineFromHandle(int markerHandle) const noexcept {
+	for (Sci::Line line = 0; line < markers.Length(); line++) {
+		if (markers[line] && markers[line]->Contains(markerHandle)) {
+			return line;
+		}
+	}
+	return -1;
+}
+
+int LineMarkers::HandleFromLine(Sci::Line line, int which) const noexcept {
+	if (markers.Length() && (line >= 0) && (line < markers.Length()) && markers[line]) {
+		MarkerHandleNumber const *pnmh = markers[line]->GetMarkerHandleNumber(which);
+		return pnmh ? pnmh->handle : -1;
+	}
+	return -1;
+}
+
+int LineMarkers::NumberFromLine(Sci::Line line, int which) const noexcept {
+	if (markers.Length() && (line >= 0) && (line < markers.Length()) && markers[line]) {
+		MarkerHandleNumber const *pnmh = markers[line]->GetMarkerHandleNumber(which);
+		return pnmh ? pnmh->number : -1;
+	}
+	return -1;
+}
+
+void LineMarkers::MergeMarkers(Sci::Line line) {
+	if (markers[line + 1]) {
+		if (!markers[line])
+			markers[line] = std::make_unique<MarkerHandleSet>();
+		markers[line]->CombineWith(markers[line + 1].get());
+		markers[line + 1].reset();
+	}
+}
+
+int LineMarkers::MarkValue(Sci::Line line) const noexcept {
+	if (markers.Length() && (line >= 0) && (line < markers.Length()) && markers[line])
+		return markers[line]->MarkValue();
+	else
+		return 0;
+}
+
+Sci::Line LineMarkers::MarkerNext(Sci::Line lineStart, int mask) const noexcept {
+	if (lineStart < 0)
+		lineStart = 0;
+	const Sci::Line length = markers.Length();
+	for (Sci::Line iLine = lineStart; iLine < length; iLine++) {
+		const MarkerHandleSet *onLine = markers[iLine].get();
+		if (onLine && ((onLine->MarkValue() & mask) != 0))
+			return iLine;
+	}
+	return -1;
+}
+
+int LineMarkers::AddMark(Sci::Line line, int markerNum, Sci::Line lines) {
+	handleCurrent++;
+	if (!markers.Length()) {
+		// No existing markers so allocate one element per line
+		markers.InsertEmpty(0, lines);
+	}
+	if (line >= markers.Length()) {
+		return -1;
+	}
+	if (!markers[line]) {
+		// Need new structure to hold marker handle
+		markers[line] = std::make_unique<MarkerHandleSet>();
+	}
+	markers[line]->InsertHandle(handleCurrent, markerNum);
+
+	return handleCurrent;
+}
+
+bool LineMarkers::DeleteMark(Sci::Line line, int markerNum, bool all) {
+	bool someChanges = false;
+	if (markers.Length() && (line >= 0) && (line < markers.Length()) && markers[line]) {
+		if (markerNum == -1) {
+			someChanges = true;
+			markers[line].reset();
+		} else {
+			someChanges = markers[line]->RemoveNumber(markerNum, all);
+			if (markers[line]->Empty()) {
+				markers[line].reset();
+			}
+		}
+	}
+	return someChanges;
+}
+
+void LineMarkers::DeleteMarkFromHandle(int markerHandle) {
+	const Sci::Line line = LineFromHandle(markerHandle);
+	if (line >= 0) {
+		markers[line]->RemoveHandle(markerHandle);
+		if (markers[line]->Empty()) {
+			markers[line].reset();
+		}
+	}
+}
+
+LineLevels::~LineLevels() {
+}
+
+void LineLevels::Init() {
+	levels.DeleteAll();
+}
+
+void LineLevels::InsertLine(Sci::Line line) {
+	if (levels.Length()) {
+		const int level = (line < levels.Length()) ? levels[line] : SC_FOLDLEVELBASE;
+		levels.Insert(line, level);
+	}
+}
+
+void LineLevels::InsertLines(Sci::Line line, Sci::Line lines) {
+	if (levels.Length()) {
+		const int level = (line < levels.Length()) ? levels[line] : SC_FOLDLEVELBASE;
+		levels.InsertValue(line, lines, level);
+	}
+}
+
+void LineLevels::RemoveLine(Sci::Line line) {
+	if (levels.Length()) {
+		// Move up following lines but merge header flag from this line
+		// to line before to avoid a temporary disappearance causing expansion.
+		int firstHeader = levels[line] & SC_FOLDLEVELHEADERFLAG;
+		levels.Delete(line);
+		if (line == levels.Length()-1) // Last line loses the header flag
+			levels[line-1] &= ~SC_FOLDLEVELHEADERFLAG;
+		else if (line > 0)
+			levels[line-1] |= firstHeader;
+	}
+}
+
+void LineLevels::ExpandLevels(Sci::Line sizeNew) {
+	levels.InsertValue(levels.Length(), sizeNew - levels.Length(), SC_FOLDLEVELBASE);
+}
+
+void LineLevels::ClearLevels() {
+	levels.DeleteAll();
+}
+
+int LineLevels::SetLevel(Sci::Line line, int level, Sci::Line lines) {
+	int prev = 0;
+	if ((line >= 0) && (line < lines)) {
+		if (!levels.Length()) {
+			ExpandLevels(lines + 1);
+		}
+		prev = levels[line];
+		if (prev != level) {
+			levels[line] = level;
+		}
+	}
+	return prev;
+}
+
+int LineLevels::GetLevel(Sci::Line line) const noexcept {
+	if (levels.Length() && (line >= 0) && (line < levels.Length())) {
+		return levels[line];
+	} else {
+		return SC_FOLDLEVELBASE;
+	}
+}
+
+LineState::~LineState() {
+}
+
+void LineState::Init() {
+	lineStates.DeleteAll();
+}
+
+void LineState::InsertLine(Sci::Line line) {
+	if (lineStates.Length()) {
+		lineStates.EnsureLength(line);
+		const int val = (line < lineStates.Length()) ? lineStates[line] : 0;
+		lineStates.Insert(line, val);
+	}
+}
+
+void LineState::InsertLines(Sci::Line line, Sci::Line lines) {
+	if (lineStates.Length()) {
+		lineStates.EnsureLength(line);
+		const int val = (line < lineStates.Length()) ? lineStates[line] : 0;
+		lineStates.InsertValue(line, lines, val);
+	}
+}
+
+void LineState::RemoveLine(Sci::Line line) {
+	if (lineStates.Length() > line) {
+		lineStates.Delete(line);
+	}
+}
+
+int LineState::SetLineState(Sci::Line line, int state) {
+	lineStates.EnsureLength(line + 1);
+	const int stateOld = lineStates[line];
+	lineStates[line] = state;
+	return stateOld;
+}
+
+int LineState::GetLineState(Sci::Line line) {
+	if (line < 0)
+		return 0;
+	lineStates.EnsureLength(line + 1);
+	return lineStates[line];
+}
+
+Sci::Line LineState::GetMaxLineState() const noexcept {
+	return lineStates.Length();
+}
+
+// Each allocated LineAnnotation is a char array which starts with an AnnotationHeader
+// and then has text and optional styles.
+
+struct AnnotationHeader {
+	short style;	// Style IndividualStyles implies array of styles
+	short lines;
+	int length;
+};
+
+namespace {
+
+constexpr int IndividualStyles = 0x100;
+
+size_t NumberLines(std::string_view sv) {
+	return std::count(sv.begin(), sv.end(), '\n') + 1;
+}
+
+std::unique_ptr<char[]>AllocateAnnotation(size_t length, int style) {
+	const size_t len = sizeof(AnnotationHeader) + length + ((style == IndividualStyles) ? length : 0);
+	return std::make_unique<char[]>(len);
+}
+
+}
+
+LineAnnotation::~LineAnnotation() {
+}
+
+void LineAnnotation::Init() {
+	ClearAll();
+}
+
+void LineAnnotation::InsertLine(Sci::Line line) {
+	if (annotations.Length()) {
+		annotations.EnsureLength(line);
+		annotations.Insert(line, std::unique_ptr<char []>());
+	}
+}
+
+void LineAnnotation::InsertLines(Sci::Line line, Sci::Line lines) {
+	if (annotations.Length()) {
+		annotations.EnsureLength(line);
+		annotations.InsertEmpty(line, lines);
+	}
+}
+
+void LineAnnotation::RemoveLine(Sci::Line line) {
+	if (annotations.Length() && (line > 0) && (line <= annotations.Length())) {
+		annotations[line-1].reset();
+		annotations.Delete(line-1);
+	}
+}
+
+bool LineAnnotation::MultipleStyles(Sci::Line line) const noexcept {
+	if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line])
+		return reinterpret_cast<AnnotationHeader *>(annotations[line].get())->style == IndividualStyles;
+	else
+		return false;
+}
+
+int LineAnnotation::Style(Sci::Line line) const noexcept {
+	if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line])
+		return reinterpret_cast<AnnotationHeader *>(annotations[line].get())->style;
+	else
+		return 0;
+}
+
+const char *LineAnnotation::Text(Sci::Line line) const noexcept {
+	if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line])
+		return annotations[line].get()+sizeof(AnnotationHeader);
+	else
+		return nullptr;
+}
+
+const unsigned char *LineAnnotation::Styles(Sci::Line line) const noexcept {
+	if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line] && MultipleStyles(line))
+		return reinterpret_cast<unsigned char *>(annotations[line].get() + sizeof(AnnotationHeader) + Length(line));
+	else
+		return nullptr;
+}
+
+void LineAnnotation::SetText(Sci::Line line, const char *text) {
+	if (text && (line >= 0)) {
+		annotations.EnsureLength(line+1);
+		const int style = Style(line);
+		annotations[line] = AllocateAnnotation(strlen(text), style);
+		char *pa = annotations[line].get();
+		assert(pa);
+		AnnotationHeader *pah = reinterpret_cast<AnnotationHeader *>(pa);
+		pah->style = static_cast<short>(style);
+		pah->length = static_cast<int>(strlen(text));
+		pah->lines = static_cast<short>(NumberLines(text));
+		memcpy(pa+sizeof(AnnotationHeader), text, pah->length);
+	} else {
+		if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line]) {
+			annotations[line].reset();
+		}
+	}
+}
+
+void LineAnnotation::ClearAll() {
+	annotations.DeleteAll();
+}
+
+void LineAnnotation::SetStyle(Sci::Line line, int style) {
+	annotations.EnsureLength(line+1);
+	if (!annotations[line]) {
+		annotations[line] = AllocateAnnotation(0, style);
+	}
+	reinterpret_cast<AnnotationHeader *>(annotations[line].get())->style = static_cast<short>(style);
+}
+
+void LineAnnotation::SetStyles(Sci::Line line, const unsigned char *styles) {
+	if (line >= 0) {
+		annotations.EnsureLength(line+1);
+		if (!annotations[line]) {
+			annotations[line] = AllocateAnnotation(0, IndividualStyles);
+		} else {
+			const AnnotationHeader *pahSource = reinterpret_cast<AnnotationHeader *>(annotations[line].get());
+			if (pahSource->style != IndividualStyles) {
+				std::unique_ptr<char[]>allocation = AllocateAnnotation(pahSource->length, IndividualStyles);
+				AnnotationHeader *pahAlloc = reinterpret_cast<AnnotationHeader *>(allocation.get());
+				pahAlloc->length = pahSource->length;
+				pahAlloc->lines = pahSource->lines;
+				memcpy(allocation.get() + sizeof(AnnotationHeader), annotations[line].get() + sizeof(AnnotationHeader), pahSource->length);
+				annotations[line] = std::move(allocation);
+			}
+		}
+		AnnotationHeader *pah = reinterpret_cast<AnnotationHeader *>(annotations[line].get());
+		pah->style = IndividualStyles;
+		memcpy(annotations[line].get() + sizeof(AnnotationHeader) + pah->length, styles, pah->length);
+	}
+}
+
+int LineAnnotation::Length(Sci::Line line) const noexcept {
+	if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line])
+		return reinterpret_cast<AnnotationHeader *>(annotations[line].get())->length;
+	else
+		return 0;
+}
+
+int LineAnnotation::Lines(Sci::Line line) const noexcept {
+	if (annotations.Length() && (line >= 0) && (line < annotations.Length()) && annotations[line])
+		return reinterpret_cast<AnnotationHeader *>(annotations[line].get())->lines;
+	else
+		return 0;
+}
+
+LineTabstops::~LineTabstops() {
+}
+
+void LineTabstops::Init() {
+	tabstops.DeleteAll();
+}
+
+void LineTabstops::InsertLine(Sci::Line line) {
+	if (tabstops.Length()) {
+		tabstops.EnsureLength(line);
+		tabstops.Insert(line, nullptr);
+	}
+}
+
+void LineTabstops::InsertLines(Sci::Line line, Sci::Line lines) {
+	if (tabstops.Length()) {
+		tabstops.EnsureLength(line);
+		tabstops.InsertEmpty(line, lines);
+	}
+}
+
+void LineTabstops::RemoveLine(Sci::Line line) {
+	if (tabstops.Length() > line) {
+		tabstops[line].reset();
+		tabstops.Delete(line);
+	}
+}
+
+bool LineTabstops::ClearTabstops(Sci::Line line) noexcept {
+	if (line < tabstops.Length()) {
+		TabstopList *tl = tabstops[line].get();
+		if (tl) {
+			tl->clear();
+			return true;
+		}
+	}
+	return false;
+}
+
+bool LineTabstops::AddTabstop(Sci::Line line, int x) {
+	tabstops.EnsureLength(line + 1);
+	if (!tabstops[line]) {
+		tabstops[line] = std::make_unique<TabstopList>();
+	}
+
+	TabstopList *tl = tabstops[line].get();
+	if (tl) {
+		// tabstop positions are kept in order - insert in the right place
+		std::vector<int>::iterator it = std::lower_bound(tl->begin(), tl->end(), x);
+		// don't insert duplicates
+		if (it == tl->end() || *it != x) {
+			tl->insert(it, x);
+			return true;
+		}
+	}
+	return false;
+}
+
+int LineTabstops::GetNextTabstop(Sci::Line line, int x) const noexcept {
+	if (line < tabstops.Length()) {
+		TabstopList *tl = tabstops[line].get();
+		if (tl) {
+			for (const int i : *tl) {
+				if (i > x) {
+					return i;
+				}
+			}
+		}
+	}
+	return 0;
+}
diff --git a/Pythonwin/Scintilla/src/PerLine.h b/Pythonwin/Scintilla/src/PerLine.h
new file mode 100644
index 000000000..b43b0a18b
--- /dev/null
+++ b/Pythonwin/Scintilla/src/PerLine.h
@@ -0,0 +1,172 @@
+// Scintilla source code edit control
+/** @file PerLine.h
+ ** Manages data associated with each line of the document
+ **/
+// Copyright 1998-2009 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef PERLINE_H
+#define PERLINE_H
+
+namespace Scintilla {
+
+/**
+ * This holds the marker identifier and the marker type to display.
+ * MarkerHandleNumbers are members of lists.
+ */
+struct MarkerHandleNumber {
+	int handle;
+	int number;
+	MarkerHandleNumber(int handle_, int number_) noexcept : handle(handle_), number(number_) {}
+};
+
+/**
+ * A marker handle set contains any number of MarkerHandleNumbers.
+ */
+class MarkerHandleSet {
+	std::forward_list<MarkerHandleNumber> mhList;
+
+public:
+	MarkerHandleSet();
+	// Deleted so MarkerHandleSet objects can not be copied.
+	MarkerHandleSet(const MarkerHandleSet &) = delete;
+	MarkerHandleSet(MarkerHandleSet &&) = delete;
+	void operator=(const MarkerHandleSet &) = delete;
+	void operator=(MarkerHandleSet &&) = delete;
+	~MarkerHandleSet();
+	bool Empty() const noexcept;
+	int MarkValue() const noexcept;	///< Bit set of marker numbers.
+	bool Contains(int handle) const noexcept;
+	bool InsertHandle(int handle, int markerNum);
+	void RemoveHandle(int handle);
+	bool RemoveNumber(int markerNum, bool all);
+	void CombineWith(MarkerHandleSet *other) noexcept;
+	MarkerHandleNumber const *GetMarkerHandleNumber(int which) const noexcept;
+};
+
+class LineMarkers : public PerLine {
+	SplitVector<std::unique_ptr<MarkerHandleSet>> markers;
+	/// Handles are allocated sequentially and should never have to be reused as 32 bit ints are very big.
+	int handleCurrent;
+public:
+	LineMarkers() : handleCurrent(0) {
+	}
+	// Deleted so LineMarkers objects can not be copied.
+	LineMarkers(const LineMarkers &) = delete;
+	LineMarkers(LineMarkers &&) = delete;
+	void operator=(const LineMarkers &) = delete;
+	void operator=(LineMarkers &&) = delete;
+	~LineMarkers() override;
+	void Init() override;
+	void InsertLine(Sci::Line line) override;
+	void InsertLines(Sci::Line line, Sci::Line lines) override;
+	void RemoveLine(Sci::Line line) override;
+
+	int MarkValue(Sci::Line line) const noexcept;
+	Sci::Line MarkerNext(Sci::Line lineStart, int mask) const noexcept;
+	int AddMark(Sci::Line line, int markerNum, Sci::Line lines);
+	void MergeMarkers(Sci::Line line);
+	bool DeleteMark(Sci::Line line, int markerNum, bool all);
+	void DeleteMarkFromHandle(int markerHandle);
+	Sci::Line LineFromHandle(int markerHandle) const noexcept;
+	int HandleFromLine(Sci::Line line, int which) const noexcept;
+	int NumberFromLine(Sci::Line line, int which) const noexcept;
+};
+
+class LineLevels : public PerLine {
+	SplitVector<int> levels;
+public:
+	LineLevels() {
+	}
+	// Deleted so LineLevels objects can not be copied.
+	LineLevels(const LineLevels &) = delete;
+	LineLevels(LineLevels &&) = delete;
+	void operator=(const LineLevels &) = delete;
+	void operator=(LineLevels &&) = delete;
+	~LineLevels() override;
+	void Init() override;
+	void InsertLine(Sci::Line line) override;
+	void InsertLines(Sci::Line line, Sci::Line lines) override;
+	void RemoveLine(Sci::Line line) override;
+
+	void ExpandLevels(Sci::Line sizeNew=-1);
+	void ClearLevels();
+	int SetLevel(Sci::Line line, int level, Sci::Line lines);
+	int GetLevel(Sci::Line line) const noexcept;
+};
+
+class LineState : public PerLine {
+	SplitVector<int> lineStates;
+public:
+	LineState() {
+	}
+	// Deleted so LineState objects can not be copied.
+	LineState(const LineState &) = delete;
+	LineState(LineState &&) = delete;
+	void operator=(const LineState &) = delete;
+	void operator=(LineState &&) = delete;
+	~LineState() override;
+	void Init() override;
+	void InsertLine(Sci::Line line) override;
+	void InsertLines(Sci::Line line, Sci::Line lines) override;
+	void RemoveLine(Sci::Line line) override;
+
+	int SetLineState(Sci::Line line, int state);
+	int GetLineState(Sci::Line line);
+	Sci::Line GetMaxLineState() const noexcept;
+};
+
+class LineAnnotation : public PerLine {
+	SplitVector<std::unique_ptr<char []>> annotations;
+public:
+	LineAnnotation() {
+	}
+	// Deleted so LineAnnotation objects can not be copied.
+	LineAnnotation(const LineAnnotation &) = delete;
+	LineAnnotation(LineAnnotation &&) = delete;
+	void operator=(const LineAnnotation &) = delete;
+	void operator=(LineAnnotation &&) = delete;
+	~LineAnnotation() override;
+	void Init() override;
+	void InsertLine(Sci::Line line) override;
+	void InsertLines(Sci::Line line, Sci::Line lines) override;
+	void RemoveLine(Sci::Line line) override;
+
+	bool MultipleStyles(Sci::Line line) const noexcept;
+	int Style(Sci::Line line) const noexcept;
+	const char *Text(Sci::Line line) const noexcept;
+	const unsigned char *Styles(Sci::Line line) const noexcept;
+	void SetText(Sci::Line line, const char *text);
+	void ClearAll();
+	void SetStyle(Sci::Line line, int style);
+	void SetStyles(Sci::Line line, const unsigned char *styles);
+	int Length(Sci::Line line) const noexcept;
+	int Lines(Sci::Line line) const noexcept;
+};
+
+typedef std::vector<int> TabstopList;
+
+class LineTabstops : public PerLine {
+	SplitVector<std::unique_ptr<TabstopList>> tabstops;
+public:
+	LineTabstops() {
+	}
+	// Deleted so LineTabstops objects can not be copied.
+	LineTabstops(const LineTabstops &) = delete;
+	LineTabstops(LineTabstops &&) = delete;
+	void operator=(const LineTabstops &) = delete;
+	void operator=(LineTabstops &&) = delete;
+	~LineTabstops() override;
+	void Init() override;
+	void InsertLine(Sci::Line line) override;
+	void InsertLines(Sci::Line line, Sci::Line lines) override;
+	void RemoveLine(Sci::Line line) override;
+
+	bool ClearTabstops(Sci::Line line) noexcept;
+	bool AddTabstop(Sci::Line line, int x);
+	int GetNextTabstop(Sci::Line line, int x) const noexcept;
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/Position.h b/Pythonwin/Scintilla/src/Position.h
new file mode 100644
index 000000000..e0bbcb53f
--- /dev/null
+++ b/Pythonwin/Scintilla/src/Position.h
@@ -0,0 +1,26 @@
+// Scintilla source code edit control
+/** @file Position.h
+ ** Defines global type name Position in the Sci internal namespace.
+ **/
+// Copyright 2015 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef POSITION_H
+#define POSITION_H
+
+/**
+ * A Position is a position within a document between two characters or at the beginning or end.
+ * Sometimes used as a character index where it identifies the character after the position.
+ * A Line is a document or screen line.
+ */
+
+namespace Sci {
+
+typedef ptrdiff_t Position;
+typedef ptrdiff_t Line;
+
+const Position invalidPosition = -1;
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/PositionCache.cxx b/Pythonwin/Scintilla/src/PositionCache.cxx
index f40a15378..ca676ef6e 100644
--- a/Pythonwin/Scintilla/src/PositionCache.cxx
+++ b/Pythonwin/Scintilla/src/PositionCache.cxx
@@ -5,15 +5,29 @@
 // Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <cmath>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <iterator>
+#include <memory>
 
 #include "Platform.h"
 
+#include "ILoader.h"
+#include "ILexer.h"
 #include "Scintilla.h"
 
+#include "CharacterCategory.h"
+#include "Position.h"
+#include "UniqueString.h"
 #include "SplitVector.h"
 #include "Partitioning.h"
 #include "RunStyles.h"
@@ -21,47 +35,41 @@
 #include "CellBuffer.h"
 #include "KeyMap.h"
 #include "Indicator.h"
-#include "XPM.h"
 #include "LineMarker.h"
 #include "Style.h"
 #include "ViewStyle.h"
 #include "CharClassify.h"
 #include "Decoration.h"
+#include "CaseFolder.h"
 #include "Document.h"
+#include "UniConversion.h"
+#include "Selection.h"
 #include "PositionCache.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-static inline bool IsControlCharacter(int ch) {
-	// iscntrl returns true for lots of chars > 127 which are displayable
-	return ch >= 0 && ch < ' ';
+void BidiData::Resize(size_t maxLineLength_) {
+	stylesFonts.resize(maxLineLength_ + 1);
+	widthReprs.resize(maxLineLength_ + 1);
 }
 
 LineLayout::LineLayout(int maxLineLength_) :
-	lineStarts(0),
 	lenLineStarts(0),
 	lineNumber(-1),
 	inCache(false),
 	maxLineLength(-1),
 	numCharsInLine(0),
-	validity(llInvalid),
+	numCharsBeforeEOL(0),
+	validity(ValidLevel::invalid),
 	xHighlightGuide(0),
-	highlightColumn(0),
-	selStart(0),
-	selEnd(0),
+	highlightColumn(false),
 	containsCaret(false),
 	edgeColumn(0),
-	chars(0),
-	styles(0),
-	styleBitsSet(0),
-	indicators(0),
-	positions(0),
-	hsStart(0),
-	hsEnd(0),
+	bracePreviousStyles{},
+	hotspot(0,0),
 	widthLine(wrapWidthInfinite),
-	lines(1) {
+	lines(1),
+	wrapIndent(0) {
 	Resize(maxLineLength_);
 }
 
@@ -72,35 +80,40 @@ LineLayout::~LineLayout() {
 void LineLayout::Resize(int maxLineLength_) {
 	if (maxLineLength_ > maxLineLength) {
 		Free();
-		chars = new char[maxLineLength_ + 1];
-		styles = new unsigned char[maxLineLength_ + 1];
-		indicators = new char[maxLineLength_ + 1];
+		chars = std::make_unique<char[]>(maxLineLength_ + 1);
+		styles = std::make_unique<unsigned char []>(maxLineLength_ + 1);
 		// Extra position allocated as sometimes the Windows
 		// GetTextExtentExPoint API writes an extra element.
-		positions = new int[maxLineLength_ + 1 + 1];
+		positions = std::make_unique<XYPOSITION []>(maxLineLength_ + 1 + 1);
+		if (bidiData) {
+			bidiData->Resize(maxLineLength_);
+		}
+
 		maxLineLength = maxLineLength_;
 	}
 }
 
-void LineLayout::Free() {
-	delete []chars;
-	chars = 0;
-	delete []styles;
-	styles = 0;
-	delete []indicators;
-	indicators = 0;
-	delete []positions;
-	positions = 0;
-	delete []lineStarts;
-	lineStarts = 0;
+void LineLayout::EnsureBidiData() {
+	if (!bidiData) {
+		bidiData = std::make_unique<BidiData>();
+		bidiData->Resize(maxLineLength);
+	}
 }
 
-void LineLayout::Invalidate(validLevel validity_) {
+void LineLayout::Free() noexcept {
+	chars.reset();
+	styles.reset();
+	positions.reset();
+	lineStarts.reset();
+	bidiData.reset();
+}
+
+void LineLayout::Invalidate(ValidLevel validity_) noexcept {
 	if (validity > validity_)
 		validity = validity_;
 }
 
-int LineLayout::LineStart(int line) const {
+int LineLayout::LineStart(int line) const noexcept {
 	if (line <= 0) {
 		return 0;
 	} else if ((line >= lines) || !lineStarts) {
@@ -110,56 +123,81 @@ int LineLayout::LineStart(int line) const {
 	}
 }
 
-int LineLayout::LineLastVisible(int line) const {
+int Scintilla::LineLayout::LineLength(int line) const noexcept {
+	if (!lineStarts) {
+		return numCharsInLine;
+	} if (line >= lines - 1) {
+		return numCharsInLine - lineStarts[line];
+	} else {
+		return lineStarts[line + 1] - lineStarts[line];
+	}
+}
+
+int LineLayout::LineLastVisible(int line, Scope scope) const noexcept {
 	if (line < 0) {
 		return 0;
 	} else if ((line >= lines-1) || !lineStarts) {
-		int startLine = LineStart(line);
-		int endLine = numCharsInLine;
-		while ((endLine > startLine) && IsEOLChar(chars[endLine-1])) {
-			endLine--;
-		}
-		return endLine;
+		return scope == Scope::visibleOnly ? numCharsBeforeEOL : numCharsInLine;
 	} else {
 		return lineStarts[line+1];
 	}
 }
 
-bool LineLayout::InLine(int offset, int line) const {
-	return ((offset >= LineStart(line)) && (offset < LineStart(line + 1)) ||
-		((offset == numCharsInLine) && (line == (lines-1))));
+Range LineLayout::SubLineRange(int subLine, Scope scope) const noexcept {
+	return Range(LineStart(subLine), LineLastVisible(subLine, scope));
+}
+
+bool LineLayout::InLine(int offset, int line) const noexcept {
+	return ((offset >= LineStart(line)) && (offset < LineStart(line + 1))) ||
+		((offset == numCharsInLine) && (line == (lines-1)));
+}
+
+int LineLayout::SubLineFromPosition(int posInLine, PointEnd pe) const noexcept {
+	if (!lineStarts || (posInLine > maxLineLength)) {
+		return lines - 1;
+	}
+
+	for (int line = 0; line < lines; line++) {
+		if (pe & peSubLineEnd) {
+			// Return subline not start of next
+			if (lineStarts[line + 1] <= posInLine + 1)
+				return line;
+		} else {
+			if (lineStarts[line + 1] <= posInLine)
+				return line;
+		}
+	}
+
+	return lines - 1;
 }
 
 void LineLayout::SetLineStart(int line, int start) {
 	if ((line >= lenLineStarts) && (line != 0)) {
-		int newMaxLines = line + 20;
-		int *newLineStarts = new int[newMaxLines];
-		if (!newLineStarts)
-			return;
+		const int newMaxLines = line + 20;
+		std::unique_ptr<int[]> newLineStarts = std::make_unique<int[]>(newMaxLines);
 		for (int i = 0; i < newMaxLines; i++) {
 			if (i < lenLineStarts)
 				newLineStarts[i] = lineStarts[i];
 			else
 				newLineStarts[i] = 0;
 		}
-		delete []lineStarts;
-		lineStarts = newLineStarts;
+		lineStarts = std::move(newLineStarts);
 		lenLineStarts = newMaxLines;
 	}
 	lineStarts[line] = start;
 }
 
-void LineLayout::SetBracesHighlight(Range rangeLine, Position braces[],
-                                    char bracesMatchStyle, int xHighlight) {
-	if (rangeLine.ContainsCharacter(braces[0])) {
-		int braceOffset = braces[0] - rangeLine.start;
+void LineLayout::SetBracesHighlight(Range rangeLine, const Sci::Position braces[],
+                                    char bracesMatchStyle, int xHighlight, bool ignoreStyle) {
+	if (!ignoreStyle && rangeLine.ContainsCharacter(braces[0])) {
+		const Sci::Position braceOffset = braces[0] - rangeLine.start;
 		if (braceOffset < numCharsInLine) {
 			bracePreviousStyles[0] = styles[braceOffset];
 			styles[braceOffset] = bracesMatchStyle;
 		}
 	}
-	if (rangeLine.ContainsCharacter(braces[1])) {
-		int braceOffset = braces[1] - rangeLine.start;
+	if (!ignoreStyle && rangeLine.ContainsCharacter(braces[1])) {
+		const Sci::Position braceOffset = braces[1] - rangeLine.start;
 		if (braceOffset < numCharsInLine) {
 			bracePreviousStyles[1] = styles[braceOffset];
 			styles[braceOffset] = bracesMatchStyle;
@@ -171,15 +209,15 @@ void LineLayout::SetBracesHighlight(Range rangeLine, Position braces[],
 	}
 }
 
-void LineLayout::RestoreBracesHighlight(Range rangeLine, Position braces[]) {
-	if (rangeLine.ContainsCharacter(braces[0])) {
-		int braceOffset = braces[0] - rangeLine.start;
+void LineLayout::RestoreBracesHighlight(Range rangeLine, const Sci::Position braces[], bool ignoreStyle) {
+	if (!ignoreStyle && rangeLine.ContainsCharacter(braces[0])) {
+		const Sci::Position braceOffset = braces[0] - rangeLine.start;
 		if (braceOffset < numCharsInLine) {
 			styles[braceOffset] = bracePreviousStyles[0];
 		}
 	}
-	if (rangeLine.ContainsCharacter(braces[1])) {
-		int braceOffset = braces[1] - rangeLine.start;
+	if (!ignoreStyle && rangeLine.ContainsCharacter(braces[1])) {
+		const Sci::Position braceOffset = braces[1] - rangeLine.start;
 		if (braceOffset < numCharsInLine) {
 			styles[braceOffset] = bracePreviousStyles[1];
 		}
@@ -187,21 +225,135 @@ void LineLayout::RestoreBracesHighlight(Range rangeLine, Position braces[]) {
 	xHighlightGuide = 0;
 }
 
-int LineLayout::FindBefore(int x, int lower, int upper) const {
+int LineLayout::FindBefore(XYPOSITION x, Range range) const noexcept {
+	Sci::Position lower = range.start;
+	Sci::Position upper = range.end;
 	do {
-		int middle = (upper + lower + 1) / 2; 	// Round high
-		int posMiddle = positions[middle];
+		const Sci::Position middle = (upper + lower + 1) / 2; 	// Round high
+		const XYPOSITION posMiddle = positions[middle];
 		if (x < posMiddle) {
 			upper = middle - 1;
 		} else {
 			lower = middle;
 		}
 	} while (lower < upper);
-	return lower;
+	return static_cast<int>(lower);
+}
+
+
+int LineLayout::FindPositionFromX(XYPOSITION x, Range range, bool charPosition) const noexcept {
+	int pos = FindBefore(x, range);
+	while (pos < range.end) {
+		if (charPosition) {
+			if (x < (positions[pos + 1])) {
+				return pos;
+			}
+		} else {
+			if (x < ((positions[pos] + positions[pos + 1]) / 2)) {
+				return pos;
+			}
+		}
+		pos++;
+	}
+	return static_cast<int>(range.end);
+}
+
+Point LineLayout::PointFromPosition(int posInLine, int lineHeight, PointEnd pe) const noexcept {
+	Point pt;
+	// In case of very long line put x at arbitrary large position
+	if (posInLine > maxLineLength) {
+		pt.x = positions[maxLineLength] - positions[LineStart(lines)];
+	}
+
+	for (int subLine = 0; subLine < lines; subLine++) {
+		const Range rangeSubLine = SubLineRange(subLine, Scope::visibleOnly);
+		if (posInLine >= rangeSubLine.start) {
+			pt.y = static_cast<XYPOSITION>(subLine*lineHeight);
+			if (posInLine <= rangeSubLine.end) {
+				pt.x = positions[posInLine] - positions[rangeSubLine.start];
+				if (rangeSubLine.start != 0)	// Wrapped lines may be indented
+					pt.x += wrapIndent;
+				if (pe & peSubLineEnd)	// Return end of first subline not start of next
+					break;
+			} else if ((pe & peLineEnd) && (subLine == (lines-1))) {
+				pt.x = positions[numCharsInLine] - positions[rangeSubLine.start];
+				if (rangeSubLine.start != 0)	// Wrapped lines may be indented
+					pt.x += wrapIndent;
+			}
+		} else {
+			break;
+		}
+	}
+	return pt;
+}
+
+int LineLayout::EndLineStyle() const noexcept {
+	return styles[numCharsBeforeEOL > 0 ? numCharsBeforeEOL-1 : 0];
+}
+
+ScreenLine::ScreenLine(
+	const LineLayout *ll_,
+	int subLine,
+	const ViewStyle &vs,
+	XYPOSITION width_,
+	int tabWidthMinimumPixels_) :
+	ll(ll_),
+	start(ll->LineStart(subLine)),
+	len(ll->LineLength(subLine)),
+	width(width_),
+	height(static_cast<float>(vs.lineHeight)),
+	ctrlCharPadding(vs.ctrlCharPadding),
+	tabWidth(vs.tabWidth),
+	tabWidthMinimumPixels(tabWidthMinimumPixels_) {
+}
+
+ScreenLine::~ScreenLine() {
+}
+
+std::string_view ScreenLine::Text() const {
+	return std::string_view(&ll->chars[start], len);
+}
+
+size_t ScreenLine::Length() const {
+	return len;
+}
+
+size_t ScreenLine::RepresentationCount() const {
+	return std::count_if(&ll->bidiData->widthReprs[start],
+		&ll->bidiData->widthReprs[start + len],
+		[](XYPOSITION w) noexcept { return w > 0.0f; });
+}
+
+XYPOSITION ScreenLine::Width() const {
+	return width;
+}
+
+XYPOSITION ScreenLine::Height() const {
+	return height;
+}
+
+XYPOSITION ScreenLine::TabWidth() const {
+	return tabWidth;
+}
+
+XYPOSITION ScreenLine::TabWidthMinimumPixels() const {
+	return static_cast<XYPOSITION>(tabWidthMinimumPixels);
+}
+
+const Font *ScreenLine::FontOfPosition(size_t position) const {
+	return &ll->bidiData->stylesFonts[start + position];
+}
+
+XYPOSITION ScreenLine::RepresentationWidth(size_t position) const {
+	return ll->bidiData->widthReprs[start + position];
+}
+
+XYPOSITION ScreenLine::TabPositionAfter(XYPOSITION xPosition) const {
+	return (std::floor((xPosition + TabWidthMinimumPixels()) / TabWidth()) + 1) * TabWidth();
 }
 
 LineLayoutCache::LineLayoutCache() :
-	level(0), length(0), size(0), cache(0),
+	level(0),
 	allInvalidated(false), styleClock(-1), useCount(0) {
 	Allocate(0);
 }
@@ -210,24 +362,15 @@ LineLayoutCache::~LineLayoutCache() {
 	Deallocate();
 }
 
-void LineLayoutCache::Allocate(int length_) {
-	PLATFORM_ASSERT(cache == NULL);
+void LineLayoutCache::Allocate(size_t length_) {
+	PLATFORM_ASSERT(cache.empty());
 	allInvalidated = false;
-	length = length_;
-	size = length;
-	if (size > 1) {
-		size = (size / 16 + 1) * 16;
-	}
-	if (size > 0) {
-		cache = new LineLayout * [size];
-	}
-	for (int i = 0; i < size; i++)
-		cache[i] = 0;
+	cache.resize(length_);
 }
 
-void LineLayoutCache::AllocateForLevel(int linesOnScreen, int linesInDoc) {
+void LineLayoutCache::AllocateForLevel(Sci::Line linesOnScreen, Sci::Line linesInDoc) {
 	PLATFORM_ASSERT(useCount == 0);
-	int lengthForLevel = 0;
+	size_t lengthForLevel = 0;
 	if (level == llcCaret) {
 		lengthForLevel = 1;
 	} else if (level == llcPage) {
@@ -235,46 +378,39 @@ void LineLayoutCache::AllocateForLevel(int linesOnScreen, int linesInDoc) {
 	} else if (level == llcDocument) {
 		lengthForLevel = linesInDoc;
 	}
-	if (lengthForLevel > size) {
+	if (lengthForLevel > cache.size()) {
 		Deallocate();
 		Allocate(lengthForLevel);
 	} else {
-		if (lengthForLevel < length) {
-			for (int i = lengthForLevel; i < length; i++) {
-				delete cache[i];
-				cache[i] = 0;
+		if (lengthForLevel < cache.size()) {
+			for (size_t i = lengthForLevel; i < cache.size(); i++) {
+				cache[i].reset();
 			}
 		}
-		length = lengthForLevel;
+		cache.resize(lengthForLevel);
 	}
-	PLATFORM_ASSERT(length == lengthForLevel);
-	PLATFORM_ASSERT(cache != NULL || length == 0);
+	PLATFORM_ASSERT(cache.size() == lengthForLevel);
 }
 
-void LineLayoutCache::Deallocate() {
+void LineLayoutCache::Deallocate() noexcept {
 	PLATFORM_ASSERT(useCount == 0);
-	for (int i = 0; i < length; i++)
-		delete cache[i];
-	delete []cache;
-	cache = 0;
-	length = 0;
-	size = 0;
-}
-
-void LineLayoutCache::Invalidate(LineLayout::validLevel validity_) {
-	if (cache && !allInvalidated) {
-		for (int i = 0; i < length; i++) {
-			if (cache[i]) {
-				cache[i]->Invalidate(validity_);
+	cache.clear();
+}
+
+void LineLayoutCache::Invalidate(LineLayout::ValidLevel validity_) noexcept {
+	if (!cache.empty() && !allInvalidated) {
+		for (const std::unique_ptr<LineLayout> &ll : cache) {
+			if (ll) {
+				ll->Invalidate(validity_);
 			}
 		}
-		if (validity_ == LineLayout::llInvalid) {
+		if (validity_ == LineLayout::ValidLevel::invalid) {
 			allInvalidated = true;
 		}
 	}
 }
 
-void LineLayoutCache::SetLevel(int level_) {
+void LineLayoutCache::SetLevel(int level_) noexcept {
 	allInvalidated = false;
 	if ((level_ != -1) && (level != level_)) {
 		level = level_;
@@ -282,46 +418,43 @@ void LineLayoutCache::SetLevel(int level_) {
 	}
 }
 
-LineLayout *LineLayoutCache::Retrieve(int lineNumber, int lineCaret, int maxChars, int styleClock_,
-                                      int linesOnScreen, int linesInDoc) {
+LineLayout *LineLayoutCache::Retrieve(Sci::Line lineNumber, Sci::Line lineCaret, int maxChars, int styleClock_,
+                                      Sci::Line linesOnScreen, Sci::Line linesInDoc) {
 	AllocateForLevel(linesOnScreen, linesInDoc);
 	if (styleClock != styleClock_) {
-		Invalidate(LineLayout::llCheckTextAndStyle);
+		Invalidate(LineLayout::ValidLevel::checkTextAndStyle);
 		styleClock = styleClock_;
 	}
 	allInvalidated = false;
-	int pos = -1;
-	LineLayout *ret = 0;
+	Sci::Position pos = -1;
+	LineLayout *ret = nullptr;
 	if (level == llcCaret) {
 		pos = 0;
 	} else if (level == llcPage) {
 		if (lineNumber == lineCaret) {
 			pos = 0;
-		} else if (length > 1) {
-			pos = 1 + (lineNumber % (length - 1));
+		} else if (cache.size() > 1) {
+			pos = 1 + (lineNumber % (cache.size() - 1));
 		}
 	} else if (level == llcDocument) {
 		pos = lineNumber;
 	}
 	if (pos >= 0) {
 		PLATFORM_ASSERT(useCount == 0);
-		if (cache && (pos < length)) {
+		if (!cache.empty() && (pos < static_cast<int>(cache.size()))) {
 			if (cache[pos]) {
 				if ((cache[pos]->lineNumber != lineNumber) ||
 				        (cache[pos]->maxLineLength < maxChars)) {
-					delete cache[pos];
-					cache[pos] = 0;
+					cache[pos].reset();
 				}
 			}
 			if (!cache[pos]) {
-				cache[pos] = new LineLayout(maxChars);
-			}
-			if (cache[pos]) {
-				cache[pos]->lineNumber = lineNumber;
-				cache[pos]->inCache = true;
-				ret = cache[pos];
-				useCount++;
+				cache[pos] = std::make_unique<LineLayout>(maxChars);
 			}
+			cache[pos]->lineNumber = lineNumber;
+			cache[pos]->inCache = true;
+			ret = cache[pos].get();
+			useCount++;
 		}
 	}
 
@@ -333,7 +466,7 @@ LineLayout *LineLayoutCache::Retrieve(int lineNumber, int lineCaret, int maxChar
 	return ret;
 }
 
-void LineLayoutCache::Dispose(LineLayout *ll) {
+void LineLayoutCache::Dispose(LineLayout *ll) noexcept {
 	allInvalidated = false;
 	if (ll) {
 		if (!ll->inCache) {
@@ -344,178 +477,224 @@ void LineLayoutCache::Dispose(LineLayout *ll) {
 	}
 }
 
-void BreakFinder::Insert(int val) {
-	// Expand if needed
-	if (saeLen >= saeSize) {
-		saeSize *= 2;
-		int *selAndEdgeNew = new int[saeSize];
-		for (unsigned int j = 0; j<saeLen; j++) {
-			selAndEdgeNew[j] = selAndEdge[j];
-		}
-		delete []selAndEdge;
-		selAndEdge = selAndEdgeNew;
+// Simply pack the (maximum 4) character bytes into an int
+static unsigned int KeyFromString(const char *charBytes, size_t len) noexcept {
+	PLATFORM_ASSERT(len <= 4);
+	unsigned int k=0;
+	for (size_t i=0; i<len && charBytes[i]; i++) {
+		k = k * 0x100;
+		const unsigned char uc = charBytes[i];
+		k += uc;
 	}
+	return k;
+}
 
-	if (val >= nextBreak) {
-		for (unsigned int j = 0; j<saeLen; j++) {
-			if (val == selAndEdge[j]) {
-				return;
-			} if (val < selAndEdge[j]) {
-				for (unsigned int k = saeLen; k>j; k--) {
-					selAndEdge[k] = selAndEdge[k-1];
-				}
-				saeLen++;
-				selAndEdge[j] = val;
-				return;
-			}
-		}
-		// Not less than any so append
-		selAndEdge[saeLen++] = val;
+SpecialRepresentations::SpecialRepresentations() {
+	const short none = 0;
+	std::fill(startByteHasReprs, std::end(startByteHasReprs), none);
+}
+
+void SpecialRepresentations::SetRepresentation(const char *charBytes, const char *value) {
+	const unsigned int key = KeyFromString(charBytes, UTF8MaxBytes);
+	MapRepresentation::iterator it = mapReprs.find(key);
+	if (it == mapReprs.end()) {
+		// New entry so increment for first byte
+		const unsigned char ucStart = charBytes[0];
+		startByteHasReprs[ucStart]++;
+	}
+	mapReprs[key] = Representation(value);
+}
+
+void SpecialRepresentations::ClearRepresentation(const char *charBytes) {
+	MapRepresentation::iterator it = mapReprs.find(KeyFromString(charBytes, UTF8MaxBytes));
+	if (it != mapReprs.end()) {
+		mapReprs.erase(it);
+		const unsigned char ucStart = charBytes[0];
+		startByteHasReprs[ucStart]--;
 	}
 }
 
-extern bool BadUTF(const char *s, int len, int &trailBytes);
+const Representation *SpecialRepresentations::RepresentationFromCharacter(const char *charBytes, size_t len) const {
+	PLATFORM_ASSERT(len <= 4);
+	const unsigned char ucStart = charBytes[0];
+	if (!startByteHasReprs[ucStart])
+		return nullptr;
+	MapRepresentation::const_iterator it = mapReprs.find(KeyFromString(charBytes, len));
+	if (it != mapReprs.end()) {
+		return &(it->second);
+	}
+	return nullptr;
+}
+
+bool SpecialRepresentations::Contains(const char *charBytes, size_t len) const {
+	PLATFORM_ASSERT(len <= 4);
+	const unsigned char ucStart = charBytes[0];
+	if (!startByteHasReprs[ucStart])
+		return false;
+	MapRepresentation::const_iterator it = mapReprs.find(KeyFromString(charBytes, len));
+	return it != mapReprs.end();
+}
+
+void SpecialRepresentations::Clear() {
+	mapReprs.clear();
+	const short none = 0;
+	std::fill(startByteHasReprs, std::end(startByteHasReprs), none);
+}
 
-static int NextBadU(const char *s, int p, int len, int &trailBytes) {
-	while (p < len) {
-		p++;
-		if (BadUTF(s + p, len - p, trailBytes))
-			return p;
+void BreakFinder::Insert(Sci::Position val) {
+	const int posInLine = static_cast<int>(val);
+	if (posInLine > nextBreak) {
+		const std::vector<int>::iterator it = std::lower_bound(selAndEdge.begin(), selAndEdge.end(), posInLine);
+		if (it == selAndEdge.end()) {
+			selAndEdge.push_back(posInLine);
+		} else if (*it != posInLine) {
+			selAndEdge.insert(it, 1, posInLine);
+		}
 	}
-	return -1;
 }
 
-BreakFinder::BreakFinder(LineLayout *ll_, int lineStart_, int lineEnd_, int posLineStart_, bool utf8_, int xStart) :
+BreakFinder::BreakFinder(const LineLayout *ll_, const Selection *psel, Range lineRange_, Sci::Position posLineStart_,
+	int xStart, bool breakForSelection, const Document *pdoc_, const SpecialRepresentations *preprs_, const ViewStyle *pvsDraw) :
 	ll(ll_),
-	lineStart(lineStart_),
-	lineEnd(lineEnd_),
+	lineRange(lineRange_),
 	posLineStart(posLineStart_),
-	utf8(utf8_),
-	nextBreak(lineStart_),
-	saeSize(0),
-	saeLen(0),
+	nextBreak(static_cast<int>(lineRange_.start)),
 	saeCurrentPos(0),
 	saeNext(0),
-	subBreak(-1) {
-	saeSize = 8;
-	selAndEdge = new int[saeSize];
-	for (unsigned int j=0; j < saeSize; j++) {
-		selAndEdge[j] = 0;
-	}
+	subBreak(-1),
+	pdoc(pdoc_),
+	encodingFamily(pdoc_->CodePageFamily()),
+	preprs(preprs_) {
 
 	// Search for first visible break
 	// First find the first visible character
-	nextBreak = ll->FindBefore(xStart, lineStart, lineEnd);
+	if (xStart > 0.0f)
+		nextBreak = ll->FindBefore(static_cast<XYPOSITION>(xStart), lineRange);
 	// Now back to a style break
-	while ((nextBreak > lineStart) && (ll->styles[nextBreak] == ll->styles[nextBreak - 1])) {
+	while ((nextBreak > lineRange.start) && (ll->styles[nextBreak] == ll->styles[nextBreak - 1])) {
 		nextBreak--;
 	}
 
-	if (ll->selStart != ll->selEnd) {
-		Insert(ll->selStart - posLineStart - 1);
-		Insert(ll->selEnd - posLineStart - 1);
+	if (breakForSelection) {
+		const SelectionPosition posStart(posLineStart);
+		const SelectionPosition posEnd(posLineStart + lineRange.end);
+		const SelectionSegment segmentLine(posStart, posEnd);
+		for (size_t r=0; r<psel->Count(); r++) {
+			const SelectionSegment portion = psel->Range(r).Intersect(segmentLine);
+			if (!(portion.start == portion.end)) {
+				if (portion.start.IsValid())
+					Insert(portion.start.Position() - posLineStart);
+				if (portion.end.IsValid())
+					Insert(portion.end.Position() - posLineStart);
+			}
+		}
 	}
-
-	Insert(ll->edgeColumn - 1);
-	Insert(lineEnd - 1);
-
-	if (utf8) {
-		int trailBytes=0;
-		for (int pos = -1;;) {
-			pos = NextBadU(ll->chars, pos, lineEnd, trailBytes);
-			if (pos < 0)
-				break;
-			Insert(pos-1);
-			Insert(pos);
+	if (pvsDraw && pvsDraw->indicatorsSetFore) {
+		for (const IDecoration *deco : pdoc->decorations->View()) {
+			if (pvsDraw->indicators[deco->Indicator()].OverridesTextFore()) {
+				Sci::Position startPos = deco->EndRun(posLineStart);
+				while (startPos < (posLineStart + lineRange.end)) {
+					Insert(startPos - posLineStart);
+					startPos = deco->EndRun(startPos);
+				}
+			}
 		}
 	}
-	saeNext = (saeLen > 0) ? selAndEdge[0] : -1;
+	Insert(ll->edgeColumn);
+	Insert(lineRange.end);
+	saeNext = (!selAndEdge.empty()) ? selAndEdge[0] : -1;
 }
 
 BreakFinder::~BreakFinder() {
-	delete []selAndEdge;
-}
-
-int BreakFinder::First() {
-	return nextBreak;
 }
 
-int BreakFinder::Next() {
+TextSegment BreakFinder::Next() {
 	if (subBreak == -1) {
-		int prev = nextBreak;
-		while (nextBreak < lineEnd) {
-			if ((ll->styles[nextBreak] != ll->styles[nextBreak + 1]) ||
-					(nextBreak == saeNext) ||
-					IsControlCharacter(ll->chars[nextBreak]) || IsControlCharacter(ll->chars[nextBreak + 1])) {
-				if (nextBreak == saeNext) {
+		const int prev = nextBreak;
+		while (nextBreak < lineRange.end) {
+			int charWidth = 1;
+			if (encodingFamily == EncodingFamily::unicode)
+				charWidth = UTF8DrawBytes(reinterpret_cast<unsigned char *>(&ll->chars[nextBreak]),
+					static_cast<int>(lineRange.end - nextBreak));
+			else if (encodingFamily == EncodingFamily::dbcs)
+				charWidth = pdoc->DBCSDrawBytes(
+					std::string_view(&ll->chars[nextBreak], lineRange.end - nextBreak));
+			const Representation *repr = preprs->RepresentationFromCharacter(&ll->chars[nextBreak], charWidth);
+			if (((nextBreak > 0) && (ll->styles[nextBreak] != ll->styles[nextBreak - 1])) ||
+					repr ||
+					(nextBreak == saeNext)) {
+				while ((nextBreak >= saeNext) && (saeNext < lineRange.end)) {
 					saeCurrentPos++;
-					saeNext = (saeLen > saeCurrentPos) ? selAndEdge[saeCurrentPos] : -1;
+					saeNext = static_cast<int>((saeCurrentPos < selAndEdge.size()) ? selAndEdge[saeCurrentPos] : lineRange.end);
 				}
-				nextBreak++;
-				if ((nextBreak - prev) < lengthStartSubdivision) {
-					return nextBreak;
+				if ((nextBreak > prev) || repr) {
+					// Have a segment to report
+					if (nextBreak == prev) {
+						nextBreak += charWidth;
+					} else {
+						repr = nullptr;	// Optimize -> should remember repr
+					}
+					if ((nextBreak - prev) < lengthStartSubdivision) {
+						return TextSegment(prev, nextBreak - prev, repr);
+					} else {
+						break;
+					}
 				}
-				break;
 			}
-			nextBreak++;
+			nextBreak += charWidth;
 		}
 		if ((nextBreak - prev) < lengthStartSubdivision) {
-			return nextBreak;
+			return TextSegment(prev, nextBreak - prev);
 		}
 		subBreak = prev;
 	}
 	// Splitting up a long run from prev to nextBreak in lots of approximately lengthEachSubdivision.
 	// For very long runs add extra breaks after spaces or if no spaces before low punctuation.
+	const int startSegment = subBreak;
 	if ((nextBreak - subBreak) <= lengthEachSubdivision) {
 		subBreak = -1;
-		return nextBreak;
+		return TextSegment(startSegment, nextBreak - startSegment);
 	} else {
-		int lastGoodBreak = -1;
-		int lastOKBreak = -1;
-		int j;
-		for (j = subBreak + 1; j <= nextBreak; j++) {
-			if (IsSpaceOrTab(ll->chars[j - 1]) && !IsSpaceOrTab(ll->chars[j])) {
-				lastGoodBreak = j;
-			}
-			if (ll->chars[j] < 'A') {
-				lastOKBreak = j;
-			}
-			if (((j - subBreak) >= lengthEachSubdivision) && ((lastGoodBreak >= 0) || (lastOKBreak >= 0))) {
-				break;
-			}
-		}
-		if (lastGoodBreak >= 0) {
-			subBreak = lastGoodBreak;
-		} else if (lastOKBreak >= 0) {
-			subBreak = lastOKBreak;
-		} else {
-			subBreak = nextBreak;
-		}
+		subBreak += pdoc->SafeSegment(&ll->chars[subBreak], nextBreak-subBreak, lengthEachSubdivision);
 		if (subBreak >= nextBreak) {
 			subBreak = -1;
-			return nextBreak;
+			return TextSegment(startSegment, nextBreak - startSegment);
 		} else {
-			return subBreak;
+			return TextSegment(startSegment, subBreak - startSegment);
 		}
 	}
 }
 
-PositionCacheEntry::PositionCacheEntry() :
-	styleNumber(0), len(0), clock(0), positions(0) {
+bool BreakFinder::More() const noexcept {
+	return (subBreak >= 0) || (nextBreak < lineRange.end);
+}
+
+PositionCacheEntry::PositionCacheEntry() noexcept :
+	styleNumber(0), len(0), clock(0), positions(nullptr) {
+}
+
+// Copy constructor not currently used, but needed for being element in std::vector.
+PositionCacheEntry::PositionCacheEntry(const PositionCacheEntry &other) :
+	styleNumber(other.styleNumber), len(other.styleNumber), clock(other.styleNumber), positions(nullptr) {
+	if (other.positions) {
+		const size_t lenData = len + (len / sizeof(XYPOSITION)) + 1;
+		positions = std::make_unique<XYPOSITION[]>(lenData);
+		memcpy(positions.get(), other.positions.get(), lenData * sizeof(XYPOSITION));
+	}
 }
 
 void PositionCacheEntry::Set(unsigned int styleNumber_, const char *s_,
-	unsigned int len_, int *positions_, unsigned int clock_) {
+	unsigned int len_, const XYPOSITION *positions_, unsigned int clock_) {
 	Clear();
 	styleNumber = styleNumber_;
 	len = len_;
 	clock = clock_;
 	if (s_ && positions_) {
-		positions = new short[len + (len + 1) / 2];
-		for (unsigned int i=0;i<len;i++) {
-			positions[i] = static_cast<short>(positions_[i]);
+		positions = std::make_unique<XYPOSITION[]>(len + (len / sizeof(XYPOSITION)) + 1);
+		for (unsigned int i=0; i<len; i++) {
+			positions[i] = positions_[i];
 		}
-		memcpy(reinterpret_cast<char *>(positions + len), s_, len);
+		memcpy(&positions[len], s_, len);
 	}
 }
 
@@ -523,19 +702,18 @@ PositionCacheEntry::~PositionCacheEntry() {
 	Clear();
 }
 
-void PositionCacheEntry::Clear() {
-	delete []positions;
-	positions = 0;
+void PositionCacheEntry::Clear() noexcept {
+	positions.reset();
 	styleNumber = 0;
 	len = 0;
 	clock = 0;
 }
 
 bool PositionCacheEntry::Retrieve(unsigned int styleNumber_, const char *s_,
-	unsigned int len_, int *positions_) const {
+	unsigned int len_, XYPOSITION *positions_) const noexcept {
 	if ((styleNumber == styleNumber_) && (len == len_) &&
-		(memcmp(reinterpret_cast<char *>(positions + len), s_, len)== 0)) {
-		for (unsigned int i=0;i<len;i++) {
+		(memcmp(&positions[len], s_, len)== 0)) {
+		for (unsigned int i=0; i<len; i++) {
 			positions_[i] = positions[i];
 		}
 		return true;
@@ -544,45 +722,43 @@ bool PositionCacheEntry::Retrieve(unsigned int styleNumber_, const char *s_,
 	}
 }
 
-int PositionCacheEntry::Hash(unsigned int styleNumber, const char *s, unsigned int len) {
+unsigned int PositionCacheEntry::Hash(unsigned int styleNumber_, const char *s, unsigned int len_) noexcept {
 	unsigned int ret = s[0] << 7;
-	for (unsigned int i=0; i<len; i++) {
+	for (unsigned int i=0; i<len_; i++) {
 		ret *= 1000003;
 		ret ^= s[i];
 	}
 	ret *= 1000003;
-	ret ^= len;
+	ret ^= len_;
 	ret *= 1000003;
-	ret ^= styleNumber;
+	ret ^= styleNumber_;
 	return ret;
 }
 
-bool PositionCacheEntry::NewerThan(const PositionCacheEntry &other) {
+bool PositionCacheEntry::NewerThan(const PositionCacheEntry &other) const noexcept {
 	return clock > other.clock;
 }
 
-void PositionCacheEntry::ResetClock() {
+void PositionCacheEntry::ResetClock() noexcept {
 	if (clock > 0) {
 		clock = 1;
 	}
 }
 
 PositionCache::PositionCache() {
-	size = 0x400;
 	clock = 1;
-	pces = new PositionCacheEntry[size];
+	pces.resize(0x400);
 	allClear = true;
 }
 
 PositionCache::~PositionCache() {
 	Clear();
-	delete []pces;
 }
 
-void PositionCache::Clear() {
+void PositionCache::Clear() noexcept {
 	if (!allClear) {
-		for (size_t i=0;i<size;i++) {
-			pces[i].Clear();
+		for (PositionCacheEntry &pce : pces) {
+			pce.Clear();
 		}
 	}
 	clock = 1;
@@ -591,26 +767,25 @@ void PositionCache::Clear() {
 
 void PositionCache::SetSize(size_t size_) {
 	Clear();
-	delete []pces;
-	size = size_;
-	pces = new PositionCacheEntry[size];
+	pces.resize(size_);
 }
 
-void PositionCache::MeasureWidths(Surface *surface, ViewStyle &vstyle, unsigned int styleNumber,
-	const char *s, unsigned int len, int *positions) {
+void PositionCache::MeasureWidths(Surface *surface, const ViewStyle &vstyle, unsigned int styleNumber,
+	const char *s, unsigned int len, XYPOSITION *positions, const Document *pdoc) {
+
 	allClear = false;
-	int probe = -1;
-	if ((size > 0) && (len < 30)) {
+	size_t probe = pces.size();	// Out of bounds
+	if ((!pces.empty()) && (len < 30)) {
 		// Only store short strings in the cache so it doesn't churn with
 		// long comments with only a single comment.
 
 		// Two way associative: try two probe positions.
-		int hashValue = PositionCacheEntry::Hash(styleNumber, s, len);
-		probe = hashValue % size;
+		const unsigned int hashValue = PositionCacheEntry::Hash(styleNumber, s, len);
+		probe = hashValue % pces.size();
 		if (pces[probe].Retrieve(styleNumber, s, len, positions)) {
 			return;
 		}
-		int probe2 = (hashValue * 37) % size;
+		const unsigned int probe2 = (hashValue * 37) % pces.size();
 		if (pces[probe2].Retrieve(styleNumber, s, len, positions)) {
 			return;
 		}
@@ -619,14 +794,31 @@ void PositionCache::MeasureWidths(Surface *surface, ViewStyle &vstyle, unsigned
 			probe = probe2;
 		}
 	}
-	surface->MeasureWidths(vstyle.styles[styleNumber].font, s, len, positions);
-	if (probe >= 0) {
+	FontAlias fontStyle = vstyle.styles[styleNumber].font;
+	if (len > BreakFinder::lengthStartSubdivision) {
+		// Break up into segments
+		unsigned int startSegment = 0;
+		XYPOSITION xStartSegment = 0;
+		while (startSegment < len) {
+			const unsigned int lenSegment = pdoc->SafeSegment(s + startSegment, len - startSegment, BreakFinder::lengthEachSubdivision);
+			surface->MeasureWidths(fontStyle, std::string_view(s + startSegment, lenSegment), positions + startSegment);
+			for (unsigned int inSeg = 0; inSeg < lenSegment; inSeg++) {
+				positions[startSegment + inSeg] += xStartSegment;
+			}
+			xStartSegment = positions[startSegment + lenSegment - 1];
+			startSegment += lenSegment;
+		}
+	} else {
+		surface->MeasureWidths(fontStyle, std::string_view(s, len), positions);
+	}
+	if (probe < pces.size()) {
+		// Store into cache
 		clock++;
 		if (clock > 60000) {
 			// Since there are only 16 bits for the clock, wrap it round and
 			// reset all cache entries so none get stuck with a high clock.
-			for (size_t i=0;i<size;i++) {
-				pces[i].ResetClock();
+			for (PositionCacheEntry &pce : pces) {
+				pce.ResetClock();
 			}
 			clock = 2;
 		}
diff --git a/Pythonwin/Scintilla/src/PositionCache.h b/Pythonwin/Scintilla/src/PositionCache.h
index 5d486cb60..7573a2dc3 100644
--- a/Pythonwin/Scintilla/src/PositionCache.h
+++ b/Pythonwin/Scintilla/src/PositionCache.h
@@ -2,165 +2,288 @@
 /** @file PositionCache.h
  ** Classes for caching layout information.
  **/
-// Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
+// Copyright 1998-2009 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
 #ifndef POSITIONCACHE_H
 #define POSITIONCACHE_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
 
-static inline bool IsEOLChar(char ch) {
+inline constexpr bool IsEOLChar(int ch) noexcept {
 	return (ch == '\r') || (ch == '\n');
 }
 
+inline constexpr bool IsSpaceOrTab(int ch) noexcept {
+	return ch == ' ' || ch == '\t';
+}
+
+/**
+* A point in document space.
+* Uses double for sufficient resolution in large (>20,000,000 line) documents.
+*/
+class PointDocument {
+public:
+	double x;
+	double y;
+
+	explicit PointDocument(double x_ = 0, double y_ = 0) noexcept : x(x_), y(y_) {
+	}
+
+	// Conversion from Point.
+	explicit PointDocument(Point pt) noexcept : x(pt.x), y(pt.y) {
+	}
+};
+
+// There are two points for some positions and this enumeration
+// can choose between the end of the first line or subline
+// and the start of the next line or subline.
+enum PointEnd {
+	peDefault = 0x0,
+	peLineEnd = 0x1,
+	peSubLineEnd = 0x2
+};
+
+class BidiData {
+public:
+	std::vector<FontAlias> stylesFonts;
+	std::vector<XYPOSITION> widthReprs;
+	void Resize(size_t maxLineLength_);
+};
+
 /**
  */
 class LineLayout {
 private:
 	friend class LineLayoutCache;
-	int *lineStarts;
+	std::unique_ptr<int []>lineStarts;
 	int lenLineStarts;
 	/// Drawing is only performed for @a maxLineLength characters on each line.
-	int lineNumber;
+	Sci::Line lineNumber;
 	bool inCache;
 public:
 	enum { wrapWidthInfinite = 0x7ffffff };
+
 	int maxLineLength;
 	int numCharsInLine;
-	enum validLevel { llInvalid, llCheckTextAndStyle, llPositions, llLines } validity;
+	int numCharsBeforeEOL;
+	enum class ValidLevel { invalid, checkTextAndStyle, positions, lines } validity;
 	int xHighlightGuide;
 	bool highlightColumn;
-	int selStart;
-	int selEnd;
 	bool containsCaret;
 	int edgeColumn;
-	char *chars;
-	unsigned char *styles;
-	int styleBitsSet;
-	char *indicators;
-	int *positions;
+	std::unique_ptr<char[]> chars;
+	std::unique_ptr<unsigned char[]> styles;
+	std::unique_ptr<XYPOSITION[]> positions;
 	char bracePreviousStyles[2];
 
+	std::unique_ptr<BidiData> bidiData;
+
 	// Hotspot support
-	int hsStart;
-	int hsEnd;
+	Range hotspot;
 
 	// Wrapped line support
 	int widthLine;
 	int lines;
+	XYPOSITION wrapIndent; // In pixels
 
-	LineLayout(int maxLineLength_);
+	explicit LineLayout(int maxLineLength_);
+	// Deleted so LineLayout objects can not be copied.
+	LineLayout(const LineLayout &) = delete;
+	LineLayout(LineLayout &&) = delete;
+	void operator=(const LineLayout &) = delete;
+	void operator=(LineLayout &&) = delete;
 	virtual ~LineLayout();
 	void Resize(int maxLineLength_);
-	void Free();
-	void Invalidate(validLevel validity_);
-	int LineStart(int line) const;
-	int LineLastVisible(int line) const;
-	bool InLine(int offset, int line) const;
+	void EnsureBidiData();
+	void Free() noexcept;
+	void Invalidate(ValidLevel validity_) noexcept;
+	int LineStart(int line) const noexcept;
+	int LineLength(int line) const noexcept;
+	enum class Scope { visibleOnly, includeEnd };
+	int LineLastVisible(int line, Scope scope) const noexcept;
+	Range SubLineRange(int subLine, Scope scope) const noexcept;
+	bool InLine(int offset, int line) const noexcept;
+	int SubLineFromPosition(int posInLine, PointEnd pe) const noexcept;
 	void SetLineStart(int line, int start);
-	void SetBracesHighlight(Range rangeLine, Position braces[],
-		char bracesMatchStyle, int xHighlight);
-	void RestoreBracesHighlight(Range rangeLine, Position braces[]);
-	int FindBefore(int x, int lower, int upper) const;
+	void SetBracesHighlight(Range rangeLine, const Sci::Position braces[],
+		char bracesMatchStyle, int xHighlight, bool ignoreStyle);
+	void RestoreBracesHighlight(Range rangeLine, const Sci::Position braces[], bool ignoreStyle);
+	int FindBefore(XYPOSITION x, Range range) const noexcept;
+	int FindPositionFromX(XYPOSITION x, Range range, bool charPosition) const noexcept;
+	Point PointFromPosition(int posInLine, int lineHeight, PointEnd pe) const noexcept;
+	int EndLineStyle() const noexcept;
+};
+
+struct ScreenLine : public IScreenLine {
+	const LineLayout *ll;
+	size_t start;
+	size_t len;
+	XYPOSITION width;
+	XYPOSITION height;
+	int ctrlCharPadding;
+	XYPOSITION tabWidth;
+	int tabWidthMinimumPixels;
+
+	ScreenLine(const LineLayout *ll_, int subLine, const ViewStyle &vs, XYPOSITION width_, int tabWidthMinimumPixels_);
+	// Deleted so ScreenLine objects can not be copied.
+	ScreenLine(const ScreenLine &) = delete;
+	ScreenLine(ScreenLine &&) = delete;
+	void operator=(const ScreenLine &) = delete;
+	void operator=(ScreenLine &&) = delete;
+	virtual ~ScreenLine();
+
+	std::string_view Text() const override;
+	size_t Length() const override;
+	size_t RepresentationCount() const override;
+	XYPOSITION Width() const override;
+	XYPOSITION Height() const override;
+	XYPOSITION TabWidth() const override;
+	XYPOSITION TabWidthMinimumPixels() const override;
+	const Font *FontOfPosition(size_t position) const override;
+	XYPOSITION RepresentationWidth(size_t position) const override;
+	XYPOSITION TabPositionAfter(XYPOSITION xPosition) const override;
 };
 
 /**
  */
 class LineLayoutCache {
 	int level;
-	int length;
-	int size;
-	LineLayout **cache;
+	std::vector<std::unique_ptr<LineLayout>>cache;
 	bool allInvalidated;
 	int styleClock;
 	int useCount;
-	void Allocate(int length_);
-	void AllocateForLevel(int linesOnScreen, int linesInDoc);
+	void Allocate(size_t length_);
+	void AllocateForLevel(Sci::Line linesOnScreen, Sci::Line linesInDoc);
 public:
 	LineLayoutCache();
+	// Deleted so LineLayoutCache objects can not be copied.
+	LineLayoutCache(const LineLayoutCache &) = delete;
+	LineLayoutCache(LineLayoutCache &&) = delete;
+	void operator=(const LineLayoutCache &) = delete;
+	void operator=(LineLayoutCache &&) = delete;
 	virtual ~LineLayoutCache();
-	void Deallocate();
+	void Deallocate() noexcept;
 	enum {
 		llcNone=SC_CACHE_NONE,
 		llcCaret=SC_CACHE_CARET,
 		llcPage=SC_CACHE_PAGE,
 		llcDocument=SC_CACHE_DOCUMENT
 	};
-	void Invalidate(LineLayout::validLevel validity_);
-	void SetLevel(int level_);
-	int GetLevel() { return level; }
-	LineLayout *Retrieve(int lineNumber, int lineCaret, int maxChars, int styleClock_,
-		int linesOnScreen, int linesInDoc);
-	void Dispose(LineLayout *ll);
+	void Invalidate(LineLayout::ValidLevel validity_) noexcept;
+	void SetLevel(int level_) noexcept;
+	int GetLevel() const noexcept { return level; }
+	LineLayout *Retrieve(Sci::Line lineNumber, Sci::Line lineCaret, int maxChars, int styleClock_,
+		Sci::Line linesOnScreen, Sci::Line linesInDoc);
+	void Dispose(LineLayout *ll) noexcept;
 };
 
 class PositionCacheEntry {
 	unsigned int styleNumber:8;
 	unsigned int len:8;
 	unsigned int clock:16;
-	short *positions;
+	std::unique_ptr<XYPOSITION []> positions;
 public:
-	PositionCacheEntry();
+	PositionCacheEntry() noexcept;
+	// Copy constructor not currently used, but needed for being element in std::vector.
+	PositionCacheEntry(const PositionCacheEntry &);
+	PositionCacheEntry(PositionCacheEntry &&) noexcept = default;
+	// Deleted so PositionCacheEntry objects can not be assigned.
+	void operator=(const PositionCacheEntry &) = delete;
+	void operator=(PositionCacheEntry &&) = delete;
 	~PositionCacheEntry();
-	void Set(unsigned int styleNumber_, const char *s_, unsigned int len_, int *positions_, unsigned int clock);
+	void Set(unsigned int styleNumber_, const char *s_, unsigned int len_, const XYPOSITION *positions_, unsigned int clock_);
+	void Clear() noexcept;
+	bool Retrieve(unsigned int styleNumber_, const char *s_, unsigned int len_, XYPOSITION *positions_) const noexcept;
+	static unsigned int Hash(unsigned int styleNumber_, const char *s, unsigned int len_) noexcept;
+	bool NewerThan(const PositionCacheEntry &other) const noexcept;
+	void ResetClock() noexcept;
+};
+
+class Representation {
+public:
+	std::string stringRep;
+	explicit Representation(const char *value="") : stringRep(value) {
+	}
+};
+
+typedef std::map<unsigned int, Representation> MapRepresentation;
+
+class SpecialRepresentations {
+	MapRepresentation mapReprs;
+	short startByteHasReprs[0x100];
+public:
+	SpecialRepresentations();
+	void SetRepresentation(const char *charBytes, const char *value);
+	void ClearRepresentation(const char *charBytes);
+	const Representation *RepresentationFromCharacter(const char *charBytes, size_t len) const;
+	bool Contains(const char *charBytes, size_t len) const;
 	void Clear();
-	bool Retrieve(unsigned int styleNumber_, const char *s_, unsigned int len_, int *positions_) const;
-	static int Hash(unsigned int styleNumber, const char *s, unsigned int len);
-	bool NewerThan(const PositionCacheEntry &other);
-	void ResetClock();
+};
+
+struct TextSegment {
+	int start;
+	int length;
+	const Representation *representation;
+	TextSegment(int start_=0, int length_=0, const Representation *representation_=nullptr) noexcept :
+		start(start_), length(length_), representation(representation_) {
+	}
+	int end() const noexcept {
+		return start + length;
+	}
 };
 
 // Class to break a line of text into shorter runs at sensible places.
 class BreakFinder {
-	// If a whole run is longer than lengthStartSubdivision then subdivide
-	// into smaller runs at spaces or punctuation.
-	enum { lengthStartSubdivision = 300 };
-	// Try to make each subdivided run lengthEachSubdivision or shorter.
-	enum { lengthEachSubdivision = 100 };
-	LineLayout *ll;
-	int lineStart;
-	int lineEnd;
-	int posLineStart;
-	bool utf8;
+	const LineLayout *ll;
+	Range lineRange;
+	Sci::Position posLineStart;
 	int nextBreak;
-	int *selAndEdge;
-	unsigned int saeSize;
-	unsigned int saeLen;
+	std::vector<int> selAndEdge;
 	unsigned int saeCurrentPos;
 	int saeNext;
 	int subBreak;
-	void Insert(int val);
+	const Document *pdoc;
+	EncodingFamily encodingFamily;
+	const SpecialRepresentations *preprs;
+	void Insert(Sci::Position val);
 public:
-	BreakFinder(LineLayout *ll_, int lineStart_, int lineEnd_, int posLineStart_, bool utf8_, int xStart);
+	// If a whole run is longer than lengthStartSubdivision then subdivide
+	// into smaller runs at spaces or punctuation.
+	enum { lengthStartSubdivision = 300 };
+	// Try to make each subdivided run lengthEachSubdivision or shorter.
+	enum { lengthEachSubdivision = 100 };
+	BreakFinder(const LineLayout *ll_, const Selection *psel, Range lineRange_, Sci::Position posLineStart_,
+		int xStart, bool breakForSelection, const Document *pdoc_, const SpecialRepresentations *preprs_, const ViewStyle *pvsDraw);
+	// Deleted so BreakFinder objects can not be copied.
+	BreakFinder(const BreakFinder &) = delete;
+	BreakFinder(BreakFinder &&) = delete;
+	void operator=(const BreakFinder &) = delete;
+	void operator=(BreakFinder &&) = delete;
 	~BreakFinder();
-	int First();
-	int Next();
+	TextSegment Next();
+	bool More() const noexcept;
 };
 
 class PositionCache {
-	PositionCacheEntry *pces;
-	size_t size;
+	std::vector<PositionCacheEntry> pces;
 	unsigned int clock;
 	bool allClear;
 public:
 	PositionCache();
+	// Deleted so PositionCache objects can not be copied.
+	PositionCache(const PositionCache &) = delete;
+	PositionCache(PositionCache &&) = delete;
+	void operator=(const PositionCache &) = delete;
+	void operator=(PositionCache &&) = delete;
 	~PositionCache();
-	void Clear();
+	void Clear() noexcept;
 	void SetSize(size_t size_);
-	int GetSize() { return size; }
-	void MeasureWidths(Surface *surface, ViewStyle &vstyle, unsigned int styleNumber,
-		const char *s, unsigned int len, int *positions);
+	size_t GetSize() const noexcept { return pces.size(); }
+	void MeasureWidths(Surface *surface, const ViewStyle &vstyle, unsigned int styleNumber,
+		const char *s, unsigned int len, XYPOSITION *positions, const Document *pdoc);
 };
 
-inline bool IsSpaceOrTab(int ch) {
-	return ch == ' ' || ch == '\t';
 }
 
-#ifdef SCI_NAMESPACE
-}
-#endif
-
 #endif
diff --git a/Pythonwin/Scintilla/src/PropSet.cxx b/Pythonwin/Scintilla/src/PropSet.cxx
deleted file mode 100644
index a1c366c3b..000000000
--- a/Pythonwin/Scintilla/src/PropSet.cxx
+++ /dev/null
@@ -1,755 +0,0 @@
-// SciTE - Scintilla based Text Editor
-/** @file PropSet.cxx
- ** A Java style properties file module.
- **/
-// Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-// Maintain a dictionary of properties
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-// The comparison and case changing functions here assume ASCII
-// or extended ASCII such as the normal Windows code page.
-
-static inline char MakeUpperCase(char ch) {
-	if (ch < 'a' || ch > 'z')
-		return ch;
-	else
-		return static_cast<char>(ch - 'a' + 'A');
-}
-
-static inline bool IsLetter(char ch) {
-	return ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'));
-}
-
-inline bool IsASpace(unsigned int ch) {
-    return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d));
-}
-
-int CompareCaseInsensitive(const char *a, const char *b) {
-	while (*a && *b) {
-		if (*a != *b) {
-			char upperA = MakeUpperCase(*a);
-			char upperB = MakeUpperCase(*b);
-			if (upperA != upperB)
-				return upperA - upperB;
-		}
-		a++;
-		b++;
-	}
-	// Either *a or *b is nul
-	return *a - *b;
-}
-
-int CompareNCaseInsensitive(const char *a, const char *b, size_t len) {
-	while (*a && *b && len) {
-		if (*a != *b) {
-			char upperA = MakeUpperCase(*a);
-			char upperB = MakeUpperCase(*b);
-			if (upperA != upperB)
-				return upperA - upperB;
-		}
-		a++;
-		b++;
-		len--;
-	}
-	if (len == 0)
-		return 0;
-	else
-		// Either *a or *b is nul
-		return *a - *b;
-}
-
-bool EqualCaseInsensitive(const char *a, const char *b) {
-	return 0 == CompareCaseInsensitive(a, b);
-}
-
-// Since the CaseInsensitive functions declared in SString
-// are implemented here, I will for now put the non-inline
-// implementations of the SString members here as well, so
-// that I can quickly see what effect this has.
-
-SString::SString(int i) : sizeGrowth(sizeGrowthDefault) {
-	char number[32];
-	sprintf(number, "%0d", i);
-	s = StringAllocate(number);
-	sSize = sLen = (s) ? strlen(s) : 0;
-}
-
-SString::SString(double d, int precision) : sizeGrowth(sizeGrowthDefault) {
-	char number[32];
-	sprintf(number, "%.*f", precision, d);
-	s = StringAllocate(number);
-	sSize = sLen = (s) ? strlen(s) : 0;
-}
-
-bool SString::grow(lenpos_t lenNew) {
-	while (sizeGrowth * 6 < lenNew) {
-		sizeGrowth *= 2;
-	}
-	char *sNew = new char[lenNew + sizeGrowth + 1];
-	if (sNew) {
-		if (s) {
-			memcpy(sNew, s, sLen);
-			delete []s;
-		}
-		s = sNew;
-		s[sLen] = '\0';
-		sSize = lenNew + sizeGrowth;
-	}
-	return sNew != 0;
-}
-
-SString &SString::assign(const char *sOther, lenpos_t sSize_) {
-	if (!sOther) {
-		sSize_ = 0;
-	} else if (sSize_ == measure_length) {
-		sSize_ = strlen(sOther);
-	}
-	if (sSize > 0 && sSize_ <= sSize) {	// Does not allocate new buffer if the current is big enough
-		if (s && sSize_) {
-			memcpy(s, sOther, sSize_);
-		}
-		s[sSize_] = '\0';
-		sLen = sSize_;
-	} else {
-		delete []s;
-		s = StringAllocate(sOther, sSize_);
-		if (s) {
-			sSize = sSize_;	// Allow buffer bigger than real string, thus providing space to grow
-			sLen = sSize_;
-		} else {
-			sSize = sLen = 0;
-		}
-	}
-	return *this;
-}
-
-bool SString::operator==(const SString &sOther) const {
-	if ((s == 0) && (sOther.s == 0))
-		return true;
-	if ((s == 0) || (sOther.s == 0))
-		return false;
-	return strcmp(s, sOther.s) == 0;
-}
-
-bool SString::operator==(const char *sOther) const {
-	if ((s == 0) && (sOther == 0))
-		return true;
-	if ((s == 0) || (sOther == 0))
-		return false;
-	return strcmp(s, sOther) == 0;
-}
-
-SString SString::substr(lenpos_t subPos, lenpos_t subLen) const {
-	if (subPos >= sLen) {
-		return SString();					// return a null string if start index is out of bounds
-	}
-	if ((subLen == measure_length) || (subPos + subLen > sLen)) {
-		subLen = sLen - subPos;		// can't substr past end of source string
-	}
-	return SString(s, subPos, subPos + subLen);
-}
-
-SString &SString::lowercase(lenpos_t subPos, lenpos_t subLen) {
-	if ((subLen == measure_length) || (subPos + subLen > sLen)) {
-		subLen = sLen - subPos;		// don't apply past end of string
-	}
-	for (lenpos_t i = subPos; i < subPos + subLen; i++) {
-		if (s[i] < 'A' || s[i] > 'Z')
-			continue;
-		else
-			s[i] = static_cast<char>(s[i] - 'A' + 'a');
-	}
-	return *this;
-}
-
-SString &SString::uppercase(lenpos_t subPos, lenpos_t subLen) {
-	if ((subLen == measure_length) || (subPos + subLen > sLen)) {
-		subLen = sLen - subPos;		// don't apply past end of string
-	}
-	for (lenpos_t i = subPos; i < subPos + subLen; i++) {
-		if (s[i] < 'a' || s[i] > 'z')
-			continue;
-		else
-			s[i] = static_cast<char>(s[i] - 'a' + 'A');
-	}
-	return *this;
-}
-
-SString &SString::append(const char *sOther, lenpos_t sLenOther, char sep) {
-	if (!sOther) {
-		return *this;
-	}
-	if (sLenOther == measure_length) {
-		sLenOther = strlen(sOther);
-	}
-	int lenSep = 0;
-	if (sLen && sep) {	// Only add a separator if not empty
-		lenSep = 1;
-	}
-	lenpos_t lenNew = sLen + sLenOther + lenSep;
-	// Conservative about growing the buffer: don't do it, unless really needed
-	if ((lenNew < sSize) || (grow(lenNew))) {
-		if (lenSep) {
-			s[sLen] = sep;
-			sLen++;
-		}
-		memcpy(&s[sLen], sOther, sLenOther);
-		sLen += sLenOther;
-		s[sLen] = '\0';
-	}
-	return *this;
-}
-
-SString &SString::insert(lenpos_t pos, const char *sOther, lenpos_t sLenOther) {
-	if (!sOther || pos > sLen) {
-		return *this;
-	}
-	if (sLenOther == measure_length) {
-		sLenOther = strlen(sOther);
-	}
-	lenpos_t lenNew = sLen + sLenOther;
-	// Conservative about growing the buffer: don't do it, unless really needed
-	if ((lenNew < sSize) || grow(lenNew)) {
-		lenpos_t moveChars = sLen - pos + 1;
-		for (lenpos_t i = moveChars; i > 0; i--) {
-			s[pos + sLenOther + i - 1] = s[pos + i - 1];
-		}
-		memcpy(s + pos, sOther, sLenOther);
-		sLen = lenNew;
-	}
-	return *this;
-}
-
-/**
- * Remove @a len characters from the @a pos position, included.
- * Characters at pos + len and beyond replace characters at pos.
- * If @a len is 0, or greater than the length of the string
- * starting at @a pos, the string is just truncated at @a pos.
- */
-void SString::remove(lenpos_t pos, lenpos_t len) {
-	if (pos >= sLen) {
-		return;
-	}
-	if (len < 1 || pos + len >= sLen) {
-		s[pos] = '\0';
-		sLen = pos;
-	} else {
-		for (lenpos_t i = pos; i < sLen - len + 1; i++) {
-			s[i] = s[i+len];
-		}
-		sLen -= len;
-	}
-}
-
-bool SString::startswith(const char *prefix) {
-	lenpos_t lenPrefix = strlen(prefix);
-	if (lenPrefix > sLen) {
-		return false;
-	}
-	return strncmp(s, prefix, lenPrefix) == 0;
-}
-
-bool SString::endswith(const char *suffix) {
-	lenpos_t lenSuffix = strlen(suffix);
-	if (lenSuffix > sLen) {
-		return false;
-	}
-	return strncmp(s + sLen - lenSuffix, suffix, lenSuffix) == 0;
-}
-
-int SString::search(const char *sFind, lenpos_t start) const {
-	if (start < sLen) {
-		const char *sFound = strstr(s + start, sFind);
-		if (sFound) {
-			return sFound - s;
-		}
-	}
-	return -1;
-}
-
-int SString::substitute(char chFind, char chReplace) {
-	int c = 0;
-	char *t = s;
-	while (t) {
-		t = strchr(t, chFind);
-		if (t) {
-			*t = chReplace;
-			t++;
-			c++;
-		}
-	}
-	return c;
-}
-
-int SString::substitute(const char *sFind, const char *sReplace) {
-	int c = 0;
-	lenpos_t lenFind = strlen(sFind);
-	lenpos_t lenReplace = strlen(sReplace);
-	int posFound = search(sFind);
-	while (posFound >= 0) {
-		remove(posFound, lenFind);
-		insert(posFound, sReplace, lenReplace);
-		posFound = search(sFind, posFound + lenReplace);
-		c++;
-	}
-	return c;
-}
-
-char *SContainer::StringAllocate(lenpos_t len) {
-	if (len != measure_length) {
-		return new char[len + 1];
-	} else {
-		return 0;
-	}
-}
-
-char *SContainer::StringAllocate(const char *s, lenpos_t len) {
-	if (s == 0) {
-		return 0;
-	}
-	if (len == measure_length) {
-		len = strlen(s);
-	}
-	char *sNew = new char[len + 1];
-	if (sNew) {
-		memcpy(sNew, s, len);
-		sNew[len] = '\0';
-	}
-	return sNew;
-}
-
-// End SString functions
-
-PropSet::PropSet() {
-	superPS = 0;
-	for (int root = 0; root < hashRoots; root++)
-		props[root] = 0;
-}
-
-PropSet::~PropSet() {
-	superPS = 0;
-	Clear();
-}
-
-void PropSet::Set(const char *key, const char *val, int lenKey, int lenVal) {
-	if (!*key)	// Empty keys are not supported
-		return;
-	if (lenKey == -1)
-		lenKey = static_cast<int>(strlen(key));
-	if (lenVal == -1)
-		lenVal = static_cast<int>(strlen(val));
-	unsigned int hash = HashString(key, lenKey);
-	for (Property *p = props[hash % hashRoots]; p; p = p->next) {
-		if ((hash == p->hash) &&
-			((strlen(p->key) == static_cast<unsigned int>(lenKey)) &&
-				(0 == strncmp(p->key, key, lenKey)))) {
-			// Replace current value
-			delete [](p->val);
-			p->val = StringDup(val, lenVal);
-			return;
-		}
-	}
-	// Not found
-	Property *pNew = new Property;
-	if (pNew) {
-		pNew->hash = hash;
-		pNew->key = StringDup(key, lenKey);
-		pNew->val = StringDup(val, lenVal);
-		pNew->next = props[hash % hashRoots];
-		props[hash % hashRoots] = pNew;
-	}
-}
-
-void PropSet::Set(const char *keyVal) {
-	while (IsASpace(*keyVal))
-		keyVal++;
-	const char *endVal = keyVal;
-	while (*endVal && (*endVal != '\n'))
-		endVal++;
-	const char *eqAt = strchr(keyVal, '=');
-	if (eqAt) {
-		Set(keyVal, eqAt + 1, eqAt-keyVal, endVal - eqAt - 1);
-	} else if (*keyVal) {	// No '=' so assume '=1'
-		Set(keyVal, "1", endVal-keyVal, 1);
-	}
-}
-
-void PropSet::Unset(const char *key, int lenKey) {
-	if (!*key)	// Empty keys are not supported
-		return;
-	if (lenKey == -1)
-		lenKey = static_cast<int>(strlen(key));
-	unsigned int hash = HashString(key, lenKey);
-	Property *pPrev = NULL;
-	for (Property *p = props[hash % hashRoots]; p; p = p->next) {
-		if ((hash == p->hash) &&
-			((strlen(p->key) == static_cast<unsigned int>(lenKey)) &&
-				(0 == strncmp(p->key, key, lenKey)))) {
-			if (pPrev)
-				pPrev->next = p->next;
-			else
-				props[hash % hashRoots] = p->next;
-			if (p == enumnext)
-				enumnext = p->next; // Not that anyone should mix enum and Set / Unset.
-			delete [](p->key);
-			delete [](p->val);
-			delete p;
-			return;
-		} else {
-			pPrev = p;
-		}
-	}
-}
-
-void PropSet::SetMultiple(const char *s) {
-	const char *eol = strchr(s, '\n');
-	while (eol) {
-		Set(s);
-		s = eol + 1;
-		eol = strchr(s, '\n');
-	}
-	Set(s);
-}
-
-SString PropSet::Get(const char *key) const {
-	unsigned int hash = HashString(key, strlen(key));
-	for (Property *p = props[hash % hashRoots]; p; p = p->next) {
-		if ((hash == p->hash) && (0 == strcmp(p->key, key))) {
-			return p->val;
-		}
-	}
-	if (superPS) {
-		// Failed here, so try in base property set
-		return superPS->Get(key);
-	} else {
-		return "";
-	}
-}
-
-// There is some inconsistency between GetExpanded("foo") and Expand("$(foo)").
-// A solution is to keep a stack of variables that have been expanded, so that
-// recursive expansions can be skipped.  For now I'll just use the C++ stack
-// for that, through a recursive function and a simple chain of pointers.
-
-struct VarChain {
-	VarChain(const char*var_=NULL, const VarChain *link_=NULL): var(var_), link(link_) {}
-
-	bool contains(const char *testVar) const {
-		return (var && (0 == strcmp(var, testVar)))
-			|| (link && link->contains(testVar));
-	}
-
-	const char *var;
-	const VarChain *link;
-};
-
-static int ExpandAllInPlace(const PropSet &props, SString &withVars, int maxExpands, const VarChain &blankVars = VarChain()) {
-	int varStart = withVars.search("$(");
-	while ((varStart >= 0) && (maxExpands > 0)) {
-		int varEnd = withVars.search(")", varStart+2);
-		if (varEnd < 0) {
-			break;
-		}
-
-		// For consistency, when we see '$(ab$(cde))', expand the inner variable first,
-		// regardless whether there is actually a degenerate variable named 'ab$(cde'.
-		int innerVarStart = withVars.search("$(", varStart+2);
-		while ((innerVarStart > varStart) && (innerVarStart < varEnd)) {
-			varStart = innerVarStart;
-			innerVarStart = withVars.search("$(", varStart+2);
-		}
-
-		SString var(withVars.c_str(), varStart + 2, varEnd);
-		SString val = props.Get(var.c_str());
-
-		if (blankVars.contains(var.c_str())) {
-			val.clear(); // treat blankVar as an empty string (e.g. to block self-reference)
-		}
-
-		if (--maxExpands >= 0) {
-			maxExpands = ExpandAllInPlace(props, val, maxExpands, VarChain(var.c_str(), &blankVars));
-		}
-
-		withVars.remove(varStart, varEnd-varStart+1);
-		withVars.insert(varStart, val.c_str(), val.length());
-
-		varStart = withVars.search("$(");
-	}
-
-	return maxExpands;
-}
-
-SString PropSet::GetExpanded(const char *key) const {
-	SString val = Get(key);
-	ExpandAllInPlace(*this, val, 100, VarChain(key));
-	return val;
-}
-
-SString PropSet::Expand(const char *withVars, int maxExpands) const {
-	SString val = withVars;
-	ExpandAllInPlace(*this, val, maxExpands);
-	return val;
-}
-
-int PropSet::GetInt(const char *key, int defaultValue) const {
-	SString val = GetExpanded(key);
-	if (val.length())
-		return val.value();
-	return defaultValue;
-}
-
-bool isprefix(const char *target, const char *prefix) {
-	while (*target && *prefix) {
-		if (*target != *prefix)
-			return false;
-		target++;
-		prefix++;
-	}
-	if (*prefix)
-		return false;
-	else
-		return true;
-}
-
-void PropSet::Clear() {
-	for (int root = 0; root < hashRoots; root++) {
-		Property *p = props[root];
-		while (p) {
-			Property *pNext = p->next;
-			p->hash = 0;
-			delete []p->key;
-			p->key = 0;
-			delete []p->val;
-			p->val = 0;
-			delete p;
-			p = pNext;
-		}
-		props[root] = 0;
-	}
-}
-
-char *PropSet::ToString() const {
-	size_t len=0;
-	for (int r = 0; r < hashRoots; r++) {
-		for (Property *p = props[r]; p; p = p->next) {
-			len += strlen(p->key) + 1;
-			len += strlen(p->val) + 1;
-		}
-	}
-	if (len == 0)
-		len = 1;	// Return as empty string
-	char *ret = new char [len];
-	if (ret) {
-		char *w = ret;
-		for (int root = 0; root < hashRoots; root++) {
-			for (Property *p = props[root]; p; p = p->next) {
-				strcpy(w, p->key);
-				w += strlen(p->key);
-				*w++ = '=';
-				strcpy(w, p->val);
-				w += strlen(p->val);
-				*w++ = '\n';
-			}
-		}
-		ret[len-1] = '\0';
-	}
-	return ret;
-}
-
-/**
- * Creates an array that points into each word in the string and puts \0 terminators
- * after each word.
- */
-static char **ArrayFromWordList(char *wordlist, int *len, bool onlyLineEnds = false) {
-	int prev = '\n';
-	int words = 0;
-	// For rapid determination of whether a character is a separator, build
-	// a look up table.
-	bool wordSeparator[256];
-	for (int i=0;i<256; i++) {
-		wordSeparator[i] = false;
-	}
-	wordSeparator['\r'] = true;
-	wordSeparator['\n'] = true;
-	if (!onlyLineEnds) {
-		wordSeparator[' '] = true;
-		wordSeparator['\t'] = true;
-	}
-	for (int j = 0; wordlist[j]; j++) {
-		int curr = static_cast<unsigned char>(wordlist[j]);
-		if (!wordSeparator[curr] && wordSeparator[prev])
-			words++;
-		prev = curr;
-	}
-	char **keywords = new char *[words + 1];
-	if (keywords) {
-		words = 0;
-		prev = '\0';
-		size_t slen = strlen(wordlist);
-		for (size_t k = 0; k < slen; k++) {
-			if (!wordSeparator[static_cast<unsigned char>(wordlist[k])]) {
-				if (!prev) {
-					keywords[words] = &wordlist[k];
-					words++;
-				}
-			} else {
-				wordlist[k] = '\0';
-			}
-			prev = wordlist[k];
-		}
-		keywords[words] = &wordlist[slen];
-		*len = words;
-	} else {
-		*len = 0;
-	}
-	return keywords;
-}
-
-void WordList::Clear() {
-	if (words) {
-		delete []list;
-		delete []words;
-	}
-	words = 0;
-	list = 0;
-	len = 0;
-	sorted = false;
-}
-
-void WordList::Set(const char *s) {
-	list = StringDup(s);
-	sorted = false;
-	words = ArrayFromWordList(list, &len, onlyLineEnds);
-}
-
-extern "C" int cmpString(const void *a1, const void *a2) {
-	// Can't work out the correct incantation to use modern casts here
-	return strcmp(*(char**)(a1), *(char**)(a2));
-}
-
-static void SortWordList(char **words, unsigned int len) {
-	qsort(reinterpret_cast<void*>(words), len, sizeof(*words),
-	      cmpString);
-}
-
-bool WordList::InList(const char *s) {
-	if (0 == words)
-		return false;
-	if (!sorted) {
-		sorted = true;
-		SortWordList(words, len);
-		for (unsigned int k = 0; k < (sizeof(starts) / sizeof(starts[0])); k++)
-			starts[k] = -1;
-		for (int l = len - 1; l >= 0; l--) {
-			unsigned char indexChar = words[l][0];
-			starts[indexChar] = l;
-		}
-	}
-	unsigned char firstChar = s[0];
-	int j = starts[firstChar];
-	if (j >= 0) {
-		while ((unsigned char)words[j][0] == firstChar) {
-			if (s[1] == words[j][1]) {
-				const char *a = words[j] + 1;
-				const char *b = s + 1;
-				while (*a && *a == *b) {
-					a++;
-					b++;
-				}
-				if (!*a && !*b)
-					return true;
-			}
-			j++;
-		}
-	}
-	j = starts['^'];
-	if (j >= 0) {
-		while (words[j][0] == '^') {
-			const char *a = words[j] + 1;
-			const char *b = s;
-			while (*a && *a == *b) {
-				a++;
-				b++;
-			}
-			if (!*a)
-				return true;
-			j++;
-		}
-	}
-	return false;
-}
-
-/** similar to InList, but word s can be a substring of keyword.
- * eg. the keyword define is defined as def~ine. This means the word must start
- * with def to be a keyword, but also defi, defin and define are valid.
- * The marker is ~ in this case.
- */
-bool WordList::InListAbbreviated(const char *s, const char marker) {
-	if (0 == words)
-		return false;
-	if (!sorted) {
-		sorted = true;
-		SortWordList(words, len);
-		for (unsigned int k = 0; k < (sizeof(starts) / sizeof(starts[0])); k++)
-			starts[k] = -1;
-		for (int l = len - 1; l >= 0; l--) {
-			unsigned char indexChar = words[l][0];
-			starts[indexChar] = l;
-		}
-	}
-	unsigned char firstChar = s[0];
-	int j = starts[firstChar];
-	if (j >= 0) {
-		while (words[j][0] == firstChar) {
-			bool isSubword = false;
-			int start = 1;
-			if (words[j][1] == marker) {
-				isSubword = true;
-				start++;
-			}
-			if (s[1] == words[j][start]) {
-				const char *a = words[j] + start;
-				const char *b = s + 1;
-				while (*a && *a == *b) {
-					a++;
-					if (*a == marker) {
-						isSubword = true;
-						a++;
-					}
-					b++;
-				}
-				if ((!*a || isSubword) && !*b)
-					return true;
-			}
-			j++;
-		}
-	}
-	j = starts['^'];
-	if (j >= 0) {
-		while (words[j][0] == '^') {
-			const char *a = words[j] + 1;
-			const char *b = s;
-			while (*a && *a == *b) {
-				a++;
-				b++;
-			}
-			if (!*a)
-				return true;
-			j++;
-		}
-	}
-	return false;
-}
diff --git a/Pythonwin/Scintilla/src/RESearch.cxx b/Pythonwin/Scintilla/src/RESearch.cxx
index 57c745e2d..262483d88 100644
--- a/Pythonwin/Scintilla/src/RESearch.cxx
+++ b/Pythonwin/Scintilla/src/RESearch.cxx
@@ -17,6 +17,7 @@
  * Put all global/static variables into an object so this code can be
  * used from multiple threads, etc.
  * Some extensions by Philippe Lhoste PhiLho(a)GMX.net
+ * '?' extensions by Michael Mullin masmullin@gmail.com
  *
  * These routines are the PUBLIC DOMAIN equivalents of regex
  * routines as found in 4.nBSD UN*X, with minor extensions.
@@ -42,10 +43,6 @@
  *
  *          int RESearch::Execute(characterIndexer &ci, int lp, int endp)
  *
- *  RESearch::Substitute:   substitute the matched portions in a new string.
- *
- *          int RESearch::Substitute(CharacterIndexer &ci, char *src, char *dst)
- *
  *  re_fail:                failure routine for RESearch::Execute. (no longer used)
  *
  *          void re_fail(char *msg, char op)
@@ -53,7 +50,7 @@
  * Regular Expressions:
  *
  *      [1]     char    matches itself, unless it is a special
- *                      character (metachar): . \ [ ] * + ^ $
+ *                      character (metachar): . \ [ ] * + ? ^ $
  *                      and ( ) if posix option.
  *
  *      [2]     .       matches any character.
@@ -65,12 +62,12 @@
  *                      regex searches are made line per line
  *                      (stripped of end-of-line chars).
  *                      - if not in posix mode, when followed by a
- *                      left or right round bracket (see [7]);
- *                      - when followed by a digit 1 to 9 (see [8]);
+ *                      left or right round bracket (see [8]);
+ *                      - when followed by a digit 1 to 9 (see [9]);
  *                      - when followed by a left or right angle bracket
- *                      (see [9]);
- *                      - when followed by d, D, s, S, w or W (see [10]);
- *                      - when followed by x and two hexa digits (see [11].
+ *                      (see [10]);
+ *                      - when followed by d, D, s, S, w or W (see [11]);
+ *                      - when followed by x and two hexa digits (see [12].
  *                      Backslash is used as an escape character for all
  *                      other meta-characters, and itself.
  *
@@ -101,23 +98,28 @@
  *                              [a-zA-Z] any alpha
  *
  *      [5]     *       any regular expression form [1] to [4]
- *                      (except [7], [8] and [9] forms of [3]),
+ *                      (except [8], [9] and [10] forms of [3]),
  *                      followed by closure char (*)
  *                      matches zero or more matches of that form.
  *
  *      [6]     +       same as [5], except it matches one or more.
- *                      Both [5] and [6] are greedy (they match as much as possible).
  *
- *      [7]             a regular expression in the form [1] to [12], enclosed
+ *      [5-6]           Both [5] and [6] are greedy (they match as much as possible).
+ *                      Unless they are followed by the 'lazy' quantifier (?)
+ *                      In which case both [5] and [6] try to match as little as possible
+ *
+ *      [7]     ?       same as [5] except it matches zero or one.
+ *
+ *      [8]             a regular expression in the form [1] to [13], enclosed
  *                      as \(form\) (or (form) with posix flag) matches what
  *                      form matches. The enclosure creates a set of tags,
- *                      used for [8] and for pattern substitution.
+ *                      used for [9] and for pattern substitution.
  *                      The tagged forms are numbered starting from 1.
  *
- *      [8]             a \ followed by a digit 1 to 9 matches whatever a
- *                      previously tagged regular expression ([7]) matched.
+ *      [9]             a \ followed by a digit 1 to 9 matches whatever a
+ *                      previously tagged regular expression ([8]) matched.
  *
- *      [9]     \<      a regular expression starting with a \< construct
+ *      [10]    \<      a regular expression starting with a \< construct
  *              \>      and/or ending with a \> construct, restricts the
  *                      pattern matching to the beginning of a word, and/or
  *                      the end of a word. A word is defined to be a character
@@ -126,7 +128,7 @@
  *                      by user setting. The word must also be preceded and/or
  *                      followed by any character outside those mentioned.
  *
- *      [10]    \l      a backslash followed by d, D, s, S, w or W,
+ *      [11]    \l      a backslash followed by d, D, s, S, w or W,
  *                      becomes a character class (both inside and
  *                      outside sets []).
  *                        d: decimal digits
@@ -136,16 +138,16 @@
  *                        w: alphanumeric & underscore (changed by user setting)
  *                        W: any char except alphanumeric & underscore (see above)
  *
- *      [11]    \xHH    a backslash followed by x and two hexa digits,
- *                      becomes the character whose Ascii code is equal
+ *      [12]    \xHH    a backslash followed by x and two hexa digits,
+ *                      becomes the character whose ASCII code is equal
  *                      to these digits. If not followed by two digits,
  *                      it is 'x' char itself.
  *
- *      [12]            a composite regular expression xy where x and y
- *                      are in the form [1] to [11] matches the longest
+ *      [13]            a composite regular expression xy where x and y
+ *                      are in the form [1] to [12] matches the longest
  *                      match of x followed by a match for y.
  *
- *      [13]    ^       a regular expression starting with a ^ character
+ *      [14]    ^       a regular expression starting with a ^ character
  *              $       and/or ending with a $ character, restricts the
  *                      pattern matching to the beginning of the line,
  *                      or the end of line. [anchors] Elsewhere in the
@@ -198,17 +200,19 @@
  *  matches:    foo-foo fo-fo fob-fob foobar-foobar ...
  */
 
+#include <cstddef>
+#include <cstdlib>
+
+#include <stdexcept>
+#include <string>
+#include <algorithm>
+#include <iterator>
+
+#include "Position.h"
 #include "CharClassify.h"
 #include "RESearch.h"
 
-// Shut up annoying Visual C++ warnings:
-#ifdef _MSC_VER
-#pragma warning(disable: 4514)
-#endif
-
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 #define OKP     1
 #define NOP     0
@@ -224,6 +228,8 @@ using namespace Scintilla;
 #define EOW     9
 #define REF     10
 #define CLO     11
+#define CLQ     12 /* 0 to 1 closure */
+#define LCLO    13 /* lazy closure */
 
 #define END     0
 
@@ -234,7 +240,7 @@ using namespace Scintilla;
 #define BLKIND  0370
 #define BITIND  07
 
-const char bitarr[] = { 1, 2, 4, 8, 16, 32, 64, '\200' };
+static const char bitarr[] = { 1, 2, 4, 8, 16, 32, 64, '\200' };
 
 #define badpat(x)	(*nfa = END, x)
 
@@ -246,71 +252,56 @@ const char bitarr[] = { 1, 2, 4, 8, 16, 32, 64, '\200' };
  */
 
 RESearch::RESearch(CharClassify *charClassTable) {
+	failure = 0;
 	charClass = charClassTable;
-	Init();
+	sta = NOP;                  /* status of lastpat */
+	bol = 0;
+	constexpr unsigned char nul = 0;
+	std::fill(bittab, std::end(bittab), nul);
+	std::fill(tagstk, std::end(tagstk), 0);
+	std::fill(nfa, std::end(nfa), '\0');
+	Clear();
 }
 
 RESearch::~RESearch() {
 	Clear();
 }
 
-void RESearch::Init() {
-	sta = NOP;                  /* status of lastpat */
-	bol = 0;
-	for (int i = 0; i < MAXTAG; i++)
-		pat[i] = 0;
-	for (int j = 0; j < BITBLK; j++)
-		bittab[j] = 0;
-}
-
-void RESearch::Clear() {
+void RESearch::Clear() noexcept {
 	for (int i = 0; i < MAXTAG; i++) {
-		delete []pat[i];
-		pat[i] = 0;
+		pat[i].clear();
 		bopat[i] = NOTFOUND;
 		eopat[i] = NOTFOUND;
 	}
 }
 
-bool RESearch::GrabMatches(CharacterIndexer &ci) {
-	bool success = true;
+void RESearch::GrabMatches(const CharacterIndexer &ci) {
 	for (unsigned int i = 0; i < MAXTAG; i++) {
 		if ((bopat[i] != NOTFOUND) && (eopat[i] != NOTFOUND)) {
-			unsigned int len = eopat[i] - bopat[i];
-			pat[i] = new char[len + 1];
-			if (pat[i]) {
-				for (unsigned int j = 0; j < len; j++)
-					pat[i][j] = ci.CharAt(bopat[i] + j);
-				pat[i][len] = '\0';
-			} else {
-				success = false;
-			}
+			const Sci::Position len = eopat[i] - bopat[i];
+			pat[i].resize(len);
+			for (Sci::Position j = 0; j < len; j++)
+				pat[i][j] = ci.CharAt(bopat[i] + j);
 		}
 	}
-	return success;
 }
 
-void RESearch::ChSet(unsigned char c) {
+void RESearch::ChSet(unsigned char c) noexcept {
 	bittab[((c) & BLKIND) >> 3] |= bitarr[(c) & BITIND];
 }
 
-void RESearch::ChSetWithCase(unsigned char c, bool caseSensitive) {
-	if (caseSensitive) {
-		ChSet(c);
-	} else {
+void RESearch::ChSetWithCase(unsigned char c, bool caseSensitive) noexcept {
+	ChSet(c);
+	if (!caseSensitive) {
 		if ((c >= 'a') && (c <= 'z')) {
-			ChSet(c);
-			ChSet(static_cast<unsigned char>(c - 'a' + 'A'));
+			ChSet(c - 'a' + 'A');
 		} else if ((c >= 'A') && (c <= 'Z')) {
-			ChSet(c);
-			ChSet(static_cast<unsigned char>(c - 'A' + 'a'));
-		} else {
-			ChSet(c);
+			ChSet(c - 'A' + 'a');
 		}
 	}
 }
 
-const unsigned char escapeValue(unsigned char ch) {
+static unsigned char escapeValue(unsigned char ch) noexcept {
 	switch (ch) {
 	case 'a':	return '\a';
 	case 'b':	return '\b';
@@ -323,7 +314,7 @@ const unsigned char escapeValue(unsigned char ch) {
 	return 0;
 }
 
-static int GetHexaChar(unsigned char hd1, unsigned char hd2) {
+static int GetHexaChar(unsigned char hd1, unsigned char hd2) noexcept {
 	int hexValue = 0;
 	if (hd1 >= '0' && hd1 <= '9') {
 		hexValue += 16 * (hd1 - '0');
@@ -331,37 +322,39 @@ static int GetHexaChar(unsigned char hd1, unsigned char hd2) {
 		hexValue += 16 * (hd1 - 'A' + 10);
 	} else if (hd1 >= 'a' && hd1 <= 'f') {
 		hexValue += 16 * (hd1 - 'a' + 10);
-	} else
+	} else {
 		return -1;
+	}
 	if (hd2 >= '0' && hd2 <= '9') {
 		hexValue += hd2 - '0';
 	} else if (hd2 >= 'A' && hd2 <= 'F') {
 		hexValue += hd2 - 'A' + 10;
 	} else if (hd2 >= 'a' && hd2 <= 'f') {
 		hexValue += hd2 - 'a' + 10;
-	} else
+	} else {
 		return -1;
+	}
 	return hexValue;
 }
 
 /**
  * Called when the parser finds a backslash not followed
  * by a valid expression (like \( in non-Posix mode).
- * @param pattern: pointer on the char after the backslash.
- * @param incr: (out) number of chars to skip after expression evaluation.
+ * @param pattern : pointer on the char after the backslash.
+ * @param incr : (out) number of chars to skip after expression evaluation.
  * @return the char if it resolves to a simple char,
  * or -1 for a char class. In this case, bittab is changed.
  */
 int RESearch::GetBackslashExpression(
-		const char *pattern,
-		int &incr) {
+    const char *pattern,
+    int &incr) noexcept {
 	// Since error reporting is primitive and messages are not used anyway,
 	// I choose to interpret unexpected syntax in a logical way instead
-	// of reporting errors. Otherwise, we can stick on, eg., PCRE behavior.
+	// of reporting errors. Otherwise, we can stick on, eg., PCRE behaviour.
 	incr = 0;	// Most of the time, will skip the char "naturally".
 	int c;
 	int result = -1;
-	unsigned char bsc = *pattern;
+	const unsigned char bsc = *pattern;
 	if (!bsc) {
 		// Avoid overrun
 		result = '\\';	// \ at end of pattern, take it literally
@@ -379,9 +372,9 @@ int RESearch::GetBackslashExpression(
 		result = escapeValue(bsc);
 		break;
 	case 'x': {
-			unsigned char hd1 = *(pattern + 1);
-			unsigned char hd2 = *(pattern + 2);
-			int hexValue = GetHexaChar(hd1, hd2);
+			const unsigned char hd1 = *(pattern + 1);
+			const unsigned char hd2 = *(pattern + 2);
+			const int hexValue = GetHexaChar(hd1, hd2);
 			if (hexValue >= 0) {
 				result = hexValue;
 				incr = 2;	// Must skip the digits
@@ -416,6 +409,7 @@ int RESearch::GetBackslashExpression(
 				ChSet(static_cast<unsigned char>(c));
 			}
 		}
+		break;
 	case 'w':
 		for (c = 0; c < MAXCHR; c++) {
 			if (iswordc(static_cast<unsigned char>(c))) {
@@ -436,7 +430,7 @@ int RESearch::GetBackslashExpression(
 	return result;
 }
 
-const char *RESearch::Compile(const char *pattern, int length, bool caseSensitive, bool posix) {
+const char *RESearch::Compile(const char *pattern, Sci::Position length, bool caseSensitive, bool posix) noexcept {
 	char *mp=nfa;          /* nfa pointer       */
 	char *lp;              /* saved pointer     */
 	char *sp=nfa;          /* another one       */
@@ -449,11 +443,12 @@ const char *RESearch::Compile(const char *pattern, int length, bool caseSensitiv
 	char mask;             /* xor mask -CCL/NCL */
 	int c1, c2, prevChar;
 
-	if (!pattern || !length)
+	if (!pattern || !length) {
 		if (sta)
-			return 0;
+			return nullptr;
 		else
 			return badpat("No previous regular expression");
+	}
 	sta = NOP;
 
 	const char *p=pattern;     /* pattern pointer   */
@@ -468,18 +463,18 @@ const char *RESearch::Compile(const char *pattern, int length, bool caseSensitiv
 			break;
 
 		case '^':               /* match beginning */
-			if (p == pattern)
+			if (p == pattern) {
 				*mp++ = BOL;
-			else {
+			} else {
 				*mp++ = CHR;
 				*mp++ = *p;
 			}
 			break;
 
 		case '$':               /* match endofline */
-			if (!*(p+1))
+			if (!*(p+1)) {
 				*mp++ = EOL;
-			else {
+			} else {
 				*mp++ = CHR;
 				*mp++ = *p;
 			}
@@ -494,8 +489,9 @@ const char *RESearch::Compile(const char *pattern, int length, bool caseSensitiv
 				mask = '\377';
 				i++;
 				p++;
-			} else
+			} else {
 				mask = 0;
+			}
 
 			if (*p == '-') {	/* real dash */
 				i++;
@@ -517,11 +513,11 @@ const char *RESearch::Compile(const char *pattern, int length, bool caseSensitiv
 						if (*(p+1) != ']') {
 							c1 = prevChar + 1;
 							i++;
-							c2 = *++p;
+							c2 = static_cast<unsigned char>(*++p);
 							if (c2 == '\\') {
-								if (!*(p+1))	// End of RE
+								if (!*(p+1)) {	// End of RE
 									return badpat("Missing ]");
-								else {
+								} else {
 									i++;
 									p++;
 									int incr;
@@ -560,7 +556,7 @@ const char *RESearch::Compile(const char *pattern, int length, bool caseSensitiv
 					i++;
 					p++;
 					int incr;
-					int c = GetBackslashExpression(p, incr);
+					const int c = GetBackslashExpression(p, incr);
 					i += incr;
 					p += incr;
 					if (c >= 0) {
@@ -572,7 +568,7 @@ const char *RESearch::Compile(const char *pattern, int length, bool caseSensitiv
 						prevChar = -1;
 					}
 				} else {
-					prevChar = *p;
+					prevChar = static_cast<unsigned char>(*p);
 					ChSetWithCase(*p, caseSensitive);
 				}
 				i++;
@@ -588,10 +584,11 @@ const char *RESearch::Compile(const char *pattern, int length, bool caseSensitiv
 
 		case '*':               /* match 0 or more... */
 		case '+':               /* match 1 or more... */
+		case '?':
 			if (p == pattern)
 				return badpat("Empty closure");
 			lp = sp;		/* previous opcode */
-			if (*lp == CLO)		/* equivalence... */
+			if (*lp == CLO || *lp == LCLO)		/* equivalence... */
 				break;
 			switch (*lp) {
 
@@ -613,9 +610,13 @@ const char *RESearch::Compile(const char *pattern, int length, bool caseSensitiv
 			*mp++ = END;
 			*mp++ = END;
 			sp = mp;
+
 			while (--mp > lp)
 				*mp = mp[-1];
-			*mp = CLO;
+			if (*p == '?')          *mp = CLQ;
+			else if (*(p+1) == '?') *mp = LCLO;
+			else                    *mp = CLO;
+
 			mp = sp;
 			break;
 
@@ -643,10 +644,11 @@ const char *RESearch::Compile(const char *pattern, int length, bool caseSensitiv
 				if (tagi > 0 && tagstk[tagi] == n)
 					return badpat("Cyclical reference");
 				if (tagc > n) {
-					*mp++ = static_cast<char>(REF);
+					*mp++ = REF;
 					*mp++ = static_cast<char>(n);
-				} else
+				} else {
 					return badpat("Undetermined reference");
+				}
 				break;
 			default:
 				if (!posix && *p == '(') {
@@ -654,16 +656,18 @@ const char *RESearch::Compile(const char *pattern, int length, bool caseSensitiv
 						tagstk[++tagi] = tagc;
 						*mp++ = BOT;
 						*mp++ = static_cast<char>(tagc++);
-					} else
+					} else {
 						return badpat("Too many \\(\\) pairs");
+					}
 				} else if (!posix && *p == ')') {
 					if (*sp == BOT)
 						return badpat("Null pattern inside \\(\\)");
 					if (tagi > 0) {
-						*mp++ = static_cast<char>(EOT);
+						*mp++ = EOT;
 						*mp++ = static_cast<char>(tagstk[tagi--]);
-					} else
+					} else {
 						return badpat("Unmatched \\)");
+					}
 				} else {
 					int incr;
 					int c = GetBackslashExpression(p, incr);
@@ -688,16 +692,18 @@ const char *RESearch::Compile(const char *pattern, int length, bool caseSensitiv
 					tagstk[++tagi] = tagc;
 					*mp++ = BOT;
 					*mp++ = static_cast<char>(tagc++);
-				} else
+				} else {
 					return badpat("Too many () pairs");
+				}
 			} else if (posix && *p == ')') {
 				if (*sp == BOT)
 					return badpat("Null pattern inside ()");
 				if (tagi > 0) {
-					*mp++ = static_cast<char>(EOT);
+					*mp++ = EOT;
 					*mp++ = static_cast<char>(tagstk[tagi--]);
-				} else
+				} else {
 					return badpat("Unmatched )");
+				}
 			} else {
 				unsigned char c = *p;
 				if (!c)	// End of RE
@@ -721,7 +727,7 @@ const char *RESearch::Compile(const char *pattern, int length, bool caseSensitiv
 		return badpat((posix ? "Unmatched (" : "Unmatched \\("));
 	*mp = END;
 	sta = OKP;
-	return 0;
+	return nullptr;
 }
 
 /*
@@ -745,9 +751,9 @@ const char *RESearch::Compile(const char *pattern, int length, bool caseSensitiv
  *  respectively.
  *
  */
-int RESearch::Execute(CharacterIndexer &ci, int lp, int endp) {
+int RESearch::Execute(const CharacterIndexer &ci, Sci::Position lp, Sci::Position endp) {
 	unsigned char c;
-	int ep = NOTFOUND;
+	Sci::Position ep = NOTFOUND;
 	char *ap = nfa;
 
 	bol = lp;
@@ -770,10 +776,11 @@ int RESearch::Execute(CharacterIndexer &ci, int lp, int endp) {
 		}
 	case CHR:			/* ordinary char: locate it fast */
 		c = *(ap+1);
-		while ((lp < endp) && (ci.CharAt(lp) != c))
+		while ((lp < endp) && (static_cast<unsigned char>(ci.CharAt(lp)) != c))
 			lp++;
-		if (lp >= endp)	/* if EOS, fail, else fall thru. */
+		if (lp >= endp)	/* if EOS, fail, else fall through. */
 			return 0;
+		[[fallthrough]];
 	default:			/* regular matching all the way. */
 		while (lp < endp) {
 			ep = PMatch(ci, lp, endp, ap);
@@ -802,7 +809,7 @@ int RESearch::Execute(CharacterIndexer &ci, int lp, int endp) {
  *
  *  special case optimizations: (nfa[n], nfa[n+1])
  *      CLO ANY
- *          We KNOW .* will match everything upto the
+ *          We KNOW .* will match everything up to the
  *          end of line. Thus, directly go to the end of
  *          line, without recursive PMatch calls. As in
  *          the other closure cases, the remaining pattern
@@ -824,7 +831,9 @@ int RESearch::Execute(CharacterIndexer &ci, int lp, int endp) {
 
 extern void re_fail(char *,char);
 
-#define isinset(x,y)	((x)[((y)&BLKIND)>>3] & bitarr[(y)&BITIND])
+static inline int isinset(const char *ap, unsigned char c) noexcept {
+	return ap[(c & BLKIND) >> 3] & bitarr[c & BITIND];
+}
 
 /*
  * skip values for CLO XXX to skip past the closure
@@ -834,12 +843,13 @@ extern void re_fail(char *,char);
 #define CHRSKIP 3	/* [CLO] CHR chr END      */
 #define CCLSKIP 34	/* [CLO] CCL 32 bytes END */
 
-int RESearch::PMatch(CharacterIndexer &ci, int lp, int endp, char *ap) {
+Sci::Position RESearch::PMatch(const CharacterIndexer &ci, Sci::Position lp, Sci::Position endp, char *ap) {
 	int op, c, n;
-	int e;		/* extra pointer for CLO  */
-	int bp;		/* beginning of subpat... */
-	int ep;		/* ending of subpat...    */
-	int are;	/* to save the line ptr.  */
+	Sci::Position e;		/* extra pointer for CLO  */
+	Sci::Position bp;		/* beginning of subpat... */
+	Sci::Position ep;		/* ending of subpat...    */
+	Sci::Position are;	/* to save the line ptr.  */
+	Sci::Position llp;	/* lazy lp for LCLO       */
 
 	while ((op = *ap++) != END)
 		switch (op) {
@@ -855,8 +865,7 @@ int RESearch::PMatch(CharacterIndexer &ci, int lp, int endp, char *ap) {
 		case CCL:
 			if (lp >= endp)
 				return NOTFOUND;
-			c = ci.CharAt(lp++);
-			if (!isinset(ap,c))
+			if (!isinset(ap, ci.CharAt(lp++)))
 				return NOTFOUND;
 			ap += BITBLK;
 			break;
@@ -869,13 +878,13 @@ int RESearch::PMatch(CharacterIndexer &ci, int lp, int endp, char *ap) {
 				return NOTFOUND;
 			break;
 		case BOT:
-			bopat[*ap++] = lp;
+			bopat[static_cast<int>(*ap++)] = lp;
 			break;
 		case EOT:
-			eopat[*ap++] = lp;
+			eopat[static_cast<int>(*ap++)] = lp;
 			break;
- 		case BOW:
-			if (lp!=bol && iswordc(ci.CharAt(lp-1)) || !iswordc(ci.CharAt(lp)))
+		case BOW:
+			if ((lp!=bol && iswordc(ci.CharAt(lp-1))) || !iswordc(ci.CharAt(lp)))
 				return NOTFOUND;
 			break;
 		case EOW:
@@ -890,23 +899,32 @@ int RESearch::PMatch(CharacterIndexer &ci, int lp, int endp, char *ap) {
 				if (ci.CharAt(bp++) != ci.CharAt(lp++))
 					return NOTFOUND;
 			break;
+		case LCLO:
+		case CLQ:
 		case CLO:
 			are = lp;
 			switch (*ap) {
 
 			case ANY:
-				while (lp < endp)
+				if (op == CLO || op == LCLO)
+					while (lp < endp)
+						lp++;
+				else if (lp < endp)
 					lp++;
+
 				n = ANYSKIP;
 				break;
 			case CHR:
 				c = *(ap+1);
-				while ((lp < endp) && (c == ci.CharAt(lp)))
+				if (op == CLO || op == LCLO)
+					while ((lp < endp) && (c == ci.CharAt(lp)))
+						lp++;
+				else if ((lp < endp) && (c == ci.CharAt(lp)))
 					lp++;
 				n = CHRSKIP;
 				break;
 			case CCL:
-				while ((lp < endp) && isinset(ap+1,ci.CharAt(lp)))
+				while ((lp < endp) && isinset(ap+1, ci.CharAt(lp)))
 					lp++;
 				n = CCLSKIP;
 				break;
@@ -915,15 +933,23 @@ int RESearch::PMatch(CharacterIndexer &ci, int lp, int endp, char *ap) {
 				//re_fail("closure: bad nfa.", *ap);
 				return NOTFOUND;
 			}
-
 			ap += n;
 
-			while (lp >= are) {
-				if ((e = PMatch(ci, lp, endp, ap)) != NOTFOUND)
-					return e;
-				--lp;
+			llp = lp;
+			e = NOTFOUND;
+			while (llp >= are) {
+				Sci::Position q;
+				if ((q = PMatch(ci, llp, endp, ap)) != NOTFOUND) {
+					e = q;
+					lp = llp;
+					if (op != LCLO) return e;
+				}
+				if (*ap == END) return e;
+				--llp;
 			}
-			return NOTFOUND;
+			if (*ap == EOT)
+				PMatch(ci, lp, endp, ap);
+			return e;
 		default:
 			//re_fail("RESearch::Execute: bad nfa.", static_cast<char>(op));
 			return NOTFOUND;
@@ -931,52 +957,4 @@ int RESearch::PMatch(CharacterIndexer &ci, int lp, int endp, char *ap) {
 	return lp;
 }
 
-/*
- * RESearch::Substitute:
- *  substitute the matched portions of the src in dst.
- *
- *  &    substitute the entire matched pattern.
- *
- *  \digit  substitute a subpattern, with the given tag number.
- *      Tags are numbered from 1 to 9. If the particular
- *      tagged subpattern does not exist, null is substituted.
- */
-int RESearch::Substitute(CharacterIndexer &ci, char *src, char *dst) {
-	unsigned char c;
-	int  pin;
-	int bp;
-	int ep;
-
-	if (!*src || !bopat[0])
-		return 0;
-
-	while ((c = *src++) != 0) {
-		switch (c) {
-
-		case '&':
-			pin = 0;
-			break;
-
-		case '\\':
-			c = *src++;
-			if (c >= '0' && c <= '9') {
-				pin = c - '0';
-				break;
-			}
-
-		default:
-			*dst++ = c;
-			continue;
-		}
-
-		if ((bp = bopat[pin]) != 0 && (ep = eopat[pin]) != 0) {
-			while (ci.CharAt(bp) && bp < ep)
-				*dst++ = ci.CharAt(bp++);
-			if (bp < ep)
-				return 0;
-		}
-	}
-	*dst = '\0';
-	return 1;
-}
 
diff --git a/Pythonwin/Scintilla/src/RESearch.h b/Pythonwin/Scintilla/src/RESearch.h
index ef8c3e11b..49bfc0541 100644
--- a/Pythonwin/Scintilla/src/RESearch.h
+++ b/Pythonwin/Scintilla/src/RESearch.h
@@ -9,21 +9,11 @@
 #ifndef RESEARCH_H
 #define RESEARCH_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
-
-/*
- * The following defines are not meant to be changeable.
- * They are for readability only.
- */
-#define MAXCHR	256
-#define CHRBIT	8
-#define BITBLK	MAXCHR/CHRBIT
 
 class CharacterIndexer {
 public:
-	virtual char CharAt(int index)=0;
+	virtual char CharAt(Sci::Position index) const=0;
 	virtual ~CharacterIndexer() {
 	}
 };
@@ -31,45 +21,49 @@ class CharacterIndexer {
 class RESearch {
 
 public:
-	RESearch(CharClassify *charClassTable);
+	explicit RESearch(CharClassify *charClassTable);
+	// No dynamic allocation so default copy constructor and assignment operator are OK.
 	~RESearch();
-	bool GrabMatches(CharacterIndexer &ci);
-	const char *Compile(const char *pattern, int length, bool caseSensitive, bool posix);
-	int Execute(CharacterIndexer &ci, int lp, int endp);
-	int Substitute(CharacterIndexer &ci, char *src, char *dst);
+	void Clear() noexcept;
+	void GrabMatches(const CharacterIndexer &ci);
+	const char *Compile(const char *pattern, Sci::Position length, bool caseSensitive, bool posix) noexcept;
+	int Execute(const CharacterIndexer &ci, Sci::Position lp, Sci::Position endp);
 
-	enum { MAXTAG=10 };
-	enum { MAXNFA=2048 };
-	enum { NOTFOUND=-1 };
+	static constexpr int MAXTAG = 10;
+	static constexpr int NOTFOUND = -1;
 
-	int bopat[MAXTAG];
-	int eopat[MAXTAG];
-	char *pat[MAXTAG];
+	Sci::Position bopat[MAXTAG];
+	Sci::Position eopat[MAXTAG];
+	std::string pat[MAXTAG];
 
 private:
-	void Init();
-	void Clear();
-	void ChSet(unsigned char c);
-	void ChSetWithCase(unsigned char c, bool caseSensitive);
-	int GetBackslashExpression(const char *pattern, int &incr);
 
-	int PMatch(CharacterIndexer &ci, int lp, int endp, char *ap);
+	static constexpr int MAXNFA = 4096;
+	// The following constants are not meant to be changeable.
+	// They are for readability only.
+	static constexpr int MAXCHR = 256;
+	static constexpr int CHRBIT = 8;
+	static constexpr int BITBLK = MAXCHR / CHRBIT;
+
+	void ChSet(unsigned char c) noexcept;
+	void ChSetWithCase(unsigned char c, bool caseSensitive) noexcept;
+	int GetBackslashExpression(const char *pattern, int &incr) noexcept;
 
-	int bol;
-	int tagstk[MAXTAG];  /* subpat tag stack */
+	Sci::Position PMatch(const CharacterIndexer &ci, Sci::Position lp, Sci::Position endp, char *ap);
+
+	Sci::Position bol;
+	Sci::Position tagstk[MAXTAG];  /* subpat tag stack */
 	char nfa[MAXNFA];    /* automaton */
 	int sta;
 	unsigned char bittab[BITBLK]; /* bit table for CCL pre-set bits */
 	int failure;
 	CharClassify *charClass;
-	bool iswordc(unsigned char x) {
+	bool iswordc(unsigned char x) const noexcept {
 		return charClass->IsWord(x);
 	}
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
 
diff --git a/Pythonwin/Scintilla/src/RunStyles.cxx b/Pythonwin/Scintilla/src/RunStyles.cxx
index ae32c7380..2bcf20892 100644
--- a/Pythonwin/Scintilla/src/RunStyles.cxx
+++ b/Pythonwin/Scintilla/src/RunStyles.cxx
@@ -4,25 +4,34 @@
 // Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <stdarg.h>
+#include <cstddef>
+#include <cstdlib>
+#include <cstdint>
+#include <cstring>
+#include <cstdio>
+#include <cstdarg>
+#include <climits>
+
+#include <stdexcept>
+#include <string_view>
+#include <vector>
+#include <algorithm>
+#include <memory>
 
 #include "Platform.h"
 
 #include "Scintilla.h"
+#include "Position.h"
 #include "SplitVector.h"
 #include "Partitioning.h"
 #include "RunStyles.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
 // Find the first run at a position
-int RunStyles::RunFromPosition(int position) {
-	int run = starts->PartitionFromPosition(position);
+template <typename DISTANCE, typename STYLE>
+DISTANCE RunStyles<DISTANCE, STYLE>::RunFromPosition(DISTANCE position) const noexcept {
+	DISTANCE run = starts->PartitionFromPosition(position);
 	// Go to first element with this position
 	while ((run > 0) && (position == starts->PositionFromPartition(run-1))) {
 		run--;
@@ -31,11 +40,12 @@ int RunStyles::RunFromPosition(int position) {
 }
 
 // If there is no run boundary at position, insert one continuing style.
-int RunStyles::SplitRun(int position) {
-	int run = RunFromPosition(position);
-	int posRun = starts->PositionFromPartition(run);
+template <typename DISTANCE, typename STYLE>
+DISTANCE RunStyles<DISTANCE, STYLE>::SplitRun(DISTANCE position) {
+	DISTANCE run = RunFromPosition(position);
+	const DISTANCE posRun = starts->PositionFromPartition(run);
 	if (posRun < position) {
-		int runStyle = ValueAt(position);
+		STYLE runStyle = ValueAt(position);
 		run++;
 		starts->InsertPartition(run, position);
 		styles->InsertValue(run, 1, runStyle);
@@ -43,12 +53,14 @@ int RunStyles::SplitRun(int position) {
 	return run;
 }
 
-void RunStyles::RemoveRun(int run) {
+template <typename DISTANCE, typename STYLE>
+void RunStyles<DISTANCE, STYLE>::RemoveRun(DISTANCE run) {
 	starts->RemovePartition(run);
 	styles->DeleteRange(run, 1);
 }
 
-void RunStyles::RemoveRunIfEmpty(int run) {
+template <typename DISTANCE, typename STYLE>
+void RunStyles<DISTANCE, STYLE>::RemoveRunIfEmpty(DISTANCE run) {
 	if ((run < starts->Partitions()) && (starts->Partitions() > 1)) {
 		if (starts->PositionFromPartition(run) == starts->PositionFromPartition(run+1)) {
 			RemoveRun(run);
@@ -56,7 +68,8 @@ void RunStyles::RemoveRunIfEmpty(int run) {
 	}
 }
 
-void RunStyles::RemoveRunIfSameAsPrevious(int run) {
+template <typename DISTANCE, typename STYLE>
+void RunStyles<DISTANCE, STYLE>::RemoveRunIfSameAsPrevious(DISTANCE run) {
 	if ((run > 0) && (run < starts->Partitions())) {
 		if (styles->ValueAt(run-1) == styles->ValueAt(run)) {
 			RemoveRun(run);
@@ -64,34 +77,35 @@ void RunStyles::RemoveRunIfSameAsPrevious(int run) {
 	}
 }
 
-RunStyles::RunStyles() {
-	starts = new Partitioning(8);
-	styles = new SplitVector<int>();
+template <typename DISTANCE, typename STYLE>
+RunStyles<DISTANCE, STYLE>::RunStyles() {
+	starts = std::make_unique<Partitioning<DISTANCE>>(8);
+	styles = std::make_unique<SplitVector<STYLE>>();
 	styles->InsertValue(0, 2, 0);
 }
 
-RunStyles::~RunStyles() {
-	delete starts;
-	starts = NULL;
-	delete styles;
-	styles = NULL;
+template <typename DISTANCE, typename STYLE>
+RunStyles<DISTANCE, STYLE>::~RunStyles() {
 }
 
-int RunStyles::Length() const {
+template <typename DISTANCE, typename STYLE>
+DISTANCE RunStyles<DISTANCE, STYLE>::Length() const noexcept {
 	return starts->PositionFromPartition(starts->Partitions());
 }
 
-int RunStyles::ValueAt(int position) const {
+template <typename DISTANCE, typename STYLE>
+STYLE RunStyles<DISTANCE, STYLE>::ValueAt(DISTANCE position) const noexcept {
 	return styles->ValueAt(starts->PartitionFromPosition(position));
 }
 
-int RunStyles::FindNextChange(int position, int end) {
-	int run = starts->PartitionFromPosition(position);
+template <typename DISTANCE, typename STYLE>
+DISTANCE RunStyles<DISTANCE, STYLE>::FindNextChange(DISTANCE position, DISTANCE end) const noexcept {
+	const DISTANCE run = starts->PartitionFromPosition(position);
 	if (run < starts->Partitions()) {
-		int runChange = starts->PositionFromPartition(run);
+		const DISTANCE runChange = starts->PositionFromPartition(run);
 		if (runChange > position)
 			return runChange;
-		int nextChange = starts->PositionFromPartition(run + 1);
+		const DISTANCE nextChange = starts->PositionFromPartition(run + 1);
 		if (nextChange > position) {
 			return nextChange;
 		} else if (position < end) {
@@ -104,29 +118,39 @@ int RunStyles::FindNextChange(int position, int end) {
 	}
 }
 
-int RunStyles::StartRun(int position) {
+template <typename DISTANCE, typename STYLE>
+DISTANCE RunStyles<DISTANCE, STYLE>::StartRun(DISTANCE position) const noexcept {
 	return starts->PositionFromPartition(starts->PartitionFromPosition(position));
 }
 
-int RunStyles::EndRun(int position) {
+template <typename DISTANCE, typename STYLE>
+DISTANCE RunStyles<DISTANCE, STYLE>::EndRun(DISTANCE position) const noexcept {
 	return starts->PositionFromPartition(starts->PartitionFromPosition(position) + 1);
 }
 
-bool RunStyles::FillRange(int &position, int value, int &fillLength) {
-	int end = position + fillLength;
-	int runEnd = RunFromPosition(end);
+template <typename DISTANCE, typename STYLE>
+FillResult<DISTANCE> RunStyles<DISTANCE, STYLE>::FillRange(DISTANCE position, STYLE value, DISTANCE fillLength) {
+	const FillResult<DISTANCE> resultNoChange{false, position, fillLength};
+	if (fillLength <= 0) {
+		return resultNoChange;
+	}
+	DISTANCE end = position + fillLength;
+	if (end > Length()) {
+		return resultNoChange;
+	}
+	DISTANCE runEnd = RunFromPosition(end);
 	if (styles->ValueAt(runEnd) == value) {
 		// End already has value so trim range.
 		end = starts->PositionFromPartition(runEnd);
 		if (position >= end) {
 			// Whole range is already same as value so no action
-			return false;
+			return resultNoChange;
 		}
 		fillLength = end - position;
 	} else {
 		runEnd = SplitRun(end);
 	}
-	int runStart = RunFromPosition(position);
+	DISTANCE runStart = RunFromPosition(position);
 	if (styles->ValueAt(runStart) == value) {
 		// Start is in expected value so trim range.
 		runStart++;
@@ -139,32 +163,38 @@ bool RunStyles::FillRange(int &position, int value, int &fillLength) {
 		}
 	}
 	if (runStart < runEnd) {
+		const FillResult<DISTANCE> result{ true, position, fillLength };
 		styles->SetValueAt(runStart, value);
 		// Remove each old run over the range
-		for (int run=runStart+1; run<runEnd; run++) {
+		for (DISTANCE run=runStart+1; run<runEnd; run++) {
 			RemoveRun(runStart+1);
 		}
 		runEnd = RunFromPosition(end);
 		RemoveRunIfSameAsPrevious(runEnd);
 		RemoveRunIfSameAsPrevious(runStart);
+		runEnd = RunFromPosition(end);
+		RemoveRunIfEmpty(runEnd);
+		return result;
+	} else {
+		return resultNoChange;
 	}
-	return true;
 }
 
-void RunStyles::SetValueAt(int position, int value) {
-	int len = 1;
-	FillRange(position, value, len);
+template <typename DISTANCE, typename STYLE>
+void RunStyles<DISTANCE, STYLE>::SetValueAt(DISTANCE position, STYLE value) {
+	FillRange(position, value, 1);
 }
 
-void RunStyles::InsertSpace(int position, int insertLength) {
-	int runStart = RunFromPosition(position);
+template <typename DISTANCE, typename STYLE>
+void RunStyles<DISTANCE, STYLE>::InsertSpace(DISTANCE position, DISTANCE insertLength) {
+	DISTANCE runStart = RunFromPosition(position);
 	if (starts->PositionFromPartition(runStart) == position) {
-		int runStyle = ValueAt(position);
+		STYLE runStyle = ValueAt(position);
 		// Inserting at start of run so make previous longer
 		if (runStart == 0) {
 			// Inserting at start of document so ensure 0
 			if (runStyle) {
-				styles->SetValueAt(0, 0);
+				styles->SetValueAt(0, STYLE());
 				starts->InsertPartition(1, 0);
 				styles->InsertValue(1, 1, runStyle);
 				starts->InsertText(0, insertLength);
@@ -184,29 +214,28 @@ void RunStyles::InsertSpace(int position, int insertLength) {
 	}
 }
 
-void RunStyles::DeleteAll() {
-	delete starts;
-	starts = NULL;
-	delete styles;
-	styles = NULL;
-	starts = new Partitioning(8);
-	styles = new SplitVector<int>();
+template <typename DISTANCE, typename STYLE>
+void RunStyles<DISTANCE, STYLE>::DeleteAll() {
+	starts = std::make_unique<Partitioning<DISTANCE>>(8);
+	styles = std::make_unique<SplitVector<STYLE>>();
 	styles->InsertValue(0, 2, 0);
 }
 
-void RunStyles::DeleteRange(int position, int deleteLength) {
-	int end = position + deleteLength;
-	int runStart = RunFromPosition(position);
-	int runEnd = RunFromPosition(end);
+template <typename DISTANCE, typename STYLE>
+void RunStyles<DISTANCE, STYLE>::DeleteRange(DISTANCE position, DISTANCE deleteLength) {
+	DISTANCE end = position + deleteLength;
+	DISTANCE runStart = RunFromPosition(position);
+	DISTANCE runEnd = RunFromPosition(end);
 	if (runStart == runEnd) {
 		// Deleting from inside one run
 		starts->InsertText(runStart, -deleteLength);
+		RemoveRunIfEmpty(runStart);
 	} else {
 		runStart = SplitRun(position);
 		runEnd = SplitRun(end);
 		starts->InsertText(runStart, -deleteLength);
 		// Remove each old run over the range
-		for (int run=runStart; run<runEnd; run++) {
+		for (DISTANCE run=runStart; run<runEnd; run++) {
 			RemoveRun(runStart);
 		}
 		RemoveRunIfEmpty(runStart);
@@ -214,3 +243,73 @@ void RunStyles::DeleteRange(int position, int deleteLength) {
 	}
 }
 
+template <typename DISTANCE, typename STYLE>
+DISTANCE RunStyles<DISTANCE, STYLE>::Runs() const noexcept {
+	return starts->Partitions();
+}
+
+template <typename DISTANCE, typename STYLE>
+bool RunStyles<DISTANCE, STYLE>::AllSame() const noexcept {
+	for (DISTANCE run = 1; run < starts->Partitions(); run++) {
+		if (styles->ValueAt(run) != styles->ValueAt(run - 1))
+			return false;
+	}
+	return true;
+}
+
+template <typename DISTANCE, typename STYLE>
+bool RunStyles<DISTANCE, STYLE>::AllSameAs(STYLE value) const noexcept {
+	return AllSame() && (styles->ValueAt(0) == value);
+}
+
+template <typename DISTANCE, typename STYLE>
+DISTANCE RunStyles<DISTANCE, STYLE>::Find(STYLE value, DISTANCE start) const noexcept {
+	if (start < Length()) {
+		DISTANCE run = start ? RunFromPosition(start) : 0;
+		if (styles->ValueAt(run) == value)
+			return start;
+		run++;
+		while (run < starts->Partitions()) {
+			if (styles->ValueAt(run) == value)
+				return starts->PositionFromPartition(run);
+			run++;
+		}
+	}
+	return -1;
+}
+
+template <typename DISTANCE, typename STYLE>
+void RunStyles<DISTANCE, STYLE>::Check() const {
+	if (Length() < 0) {
+		throw std::runtime_error("RunStyles: Length can not be negative.");
+	}
+	if (starts->Partitions() < 1) {
+		throw std::runtime_error("RunStyles: Must always have 1 or more partitions.");
+	}
+	if (starts->Partitions() != styles->Length()-1) {
+		throw std::runtime_error("RunStyles: Partitions and styles different lengths.");
+	}
+	DISTANCE start=0;
+	while (start < Length()) {
+		const DISTANCE end = EndRun(start);
+		if (start >= end) {
+			throw std::runtime_error("RunStyles: Partition is 0 length.");
+		}
+		start = end;
+	}
+	if (styles->ValueAt(styles->Length()-1) != 0) {
+		throw std::runtime_error("RunStyles: Unused style at end changed.");
+	}
+	for (ptrdiff_t j=1; j<styles->Length()-1; j++) {
+		if (styles->ValueAt(j) == styles->ValueAt(j-1)) {
+			throw std::runtime_error("RunStyles: Style of a partition same as previous.");
+		}
+	}
+}
+
+template class Scintilla::RunStyles<int, int>;
+template class Scintilla::RunStyles<int, char>;
+#if (PTRDIFF_MAX != INT_MAX) || PLAT_HAIKU
+template class Scintilla::RunStyles<ptrdiff_t, int>;
+template class Scintilla::RunStyles<ptrdiff_t, char>;
+#endif
diff --git a/Pythonwin/Scintilla/src/RunStyles.h b/Pythonwin/Scintilla/src/RunStyles.h
index 0a333ca2a..97673d04b 100644
--- a/Pythonwin/Scintilla/src/RunStyles.h
+++ b/Pythonwin/Scintilla/src/RunStyles.h
@@ -10,37 +10,55 @@
 #ifndef RUNSTYLES_H
 #define RUNSTYLES_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
 
+// Return for RunStyles::FillRange reports if anything was changed and the
+// range that was changed. This may be trimmed from the requested range
+// when some of the requested range already had the requested value.
+template <typename DISTANCE>
+struct FillResult {
+	bool changed;
+	DISTANCE position;
+	DISTANCE fillLength;
+};
+
+template <typename DISTANCE, typename STYLE>
 class RunStyles {
-public:
-	Partitioning *starts;
-	SplitVector<int> *styles;
-	int RunFromPosition(int position);
-	int SplitRun(int position);
-	void RemoveRun(int run);
-	void RemoveRunIfEmpty(int run);
-	void RemoveRunIfSameAsPrevious(int run);
+private:
+	std::unique_ptr<Partitioning<DISTANCE>> starts;
+	std::unique_ptr<SplitVector<STYLE>> styles;
+	DISTANCE RunFromPosition(DISTANCE position) const noexcept;
+	DISTANCE SplitRun(DISTANCE position);
+	void RemoveRun(DISTANCE run);
+	void RemoveRunIfEmpty(DISTANCE run);
+	void RemoveRunIfSameAsPrevious(DISTANCE run);
 public:
 	RunStyles();
+	// Deleted so RunStyles objects can not be copied.
+	RunStyles(const RunStyles &) = delete;
+	RunStyles(RunStyles &&) = delete;
+	void operator=(const RunStyles &) = delete;
+	void operator=(RunStyles &&) = delete;
 	~RunStyles();
-	int Length() const;
-	int ValueAt(int position) const;
-	int FindNextChange(int position, int end);
-	int StartRun(int position);
-	int EndRun(int position);
-	// Returns true if some values may have changed
-	bool FillRange(int &position, int value, int &fillLength);
-	void SetValueAt(int position, int value);
-	void InsertSpace(int position, int insertLength);
+	DISTANCE Length() const noexcept;
+	STYLE ValueAt(DISTANCE position) const noexcept;
+	DISTANCE FindNextChange(DISTANCE position, DISTANCE end) const noexcept;
+	DISTANCE StartRun(DISTANCE position) const noexcept;
+	DISTANCE EndRun(DISTANCE position) const noexcept;
+	// Returns changed=true if some values may have changed
+	FillResult<DISTANCE> FillRange(DISTANCE position, STYLE value, DISTANCE fillLength);
+	void SetValueAt(DISTANCE position, STYLE value);
+	void InsertSpace(DISTANCE position, DISTANCE insertLength);
 	void DeleteAll();
-	void DeleteRange(int position, int deleteLength);
+	void DeleteRange(DISTANCE position, DISTANCE deleteLength);
+	DISTANCE Runs() const noexcept;
+	bool AllSame() const noexcept;
+	bool AllSameAs(STYLE value) const noexcept;
+	DISTANCE Find(STYLE value, DISTANCE start) const noexcept;
+
+	void Check() const;
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/SVector.h b/Pythonwin/Scintilla/src/SVector.h
deleted file mode 100644
index 9f56da528..000000000
--- a/Pythonwin/Scintilla/src/SVector.h
+++ /dev/null
@@ -1,135 +0,0 @@
-// Scintilla source code edit control
-/** @file SVector.h
- ** A simple expandable vector.
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@hare.net.au>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#ifndef SVECTOR_H
-#define SVECTOR_H
-
-#ifdef SCI_NAMESPACE
-namespace Scintilla {
-#endif
-
-/**
- * A simple expandable integer vector.
- * Storage not allocated for elements until an element is used.
- * This makes it very lightweight unless used so is a good match for optional features.
- */
-class SVector {
-	enum { allocSize = 4000 };
-	
-	int *v;				///< The vector
-	unsigned int size;	///< Number of elements allocated
-	unsigned int len;	///< Number of elements used in vector
-	bool allocFailure;	///< A memory allocation call has failed
-	
-	/** Internally allocate more elements than the user wants
-	 * to avoid thrashing the memory allocator. */
-	void SizeTo(int newSize) {
-		if (newSize < allocSize)
-			newSize += allocSize;
-		else 
-			newSize = (newSize * 3) / 2;
-		int* newv = new int[newSize];
-		if (!newv) {
-			allocFailure = true;
-			return;
-		}
-		size = newSize;
-        	unsigned int i=0;
-		for (; i<len; i++) {
-			newv[i] = v[i];
-		}
-		for (; i<size; i++) {
-			newv[i] = 0;
-		}
-		delete []v;
-		v = newv;
-	}
-	
-public:
-	SVector() {
-		allocFailure = false;
-		v = 0;
-		len = 0;
-		size = 0;
-	}
-	~SVector() {
-		Free();
-	}
-	/// Constructor from another vector.
-	SVector(const SVector &other) {
-		allocFailure = false;
-		v = 0;
-		len = 0;
-		size = 0;
-		if (other.Length() > 0) {
-			SizeTo(other.Length());
-			if (!allocFailure) {
-				for (int i=0;i<other.Length();i++)
-					v[i] = other.v[i];
-				len = other.Length();
-			}
-		}
-	}
-	/// Copy constructor.
-	SVector &operator=(const SVector &other) {
-		if (this != &other) {
-			delete []v;
-			allocFailure = false;
-			v = 0;
-			len = 0;
-			size = 0;
-			if (other.Length() > 0) {
-				SizeTo(other.Length());
-				if (!allocFailure) {
-					for (int i=0;i<other.Length();i++)
-						v[i] = other.v[i];
-				}
-				len = other.Length();
-			}
-		}
-		return *this;
-	}
-	/** @brief Accessor.
-	 * Allows to access values from the list, and grows it if accessing
-	 * outside the current bounds. The returned value in this case is 0. */
-	int &operator[](unsigned int i) {
-		if (i >= len) {
-			if (i >= size) {
-				SizeTo(i);
-			}
-			len = i+1;
-		}
-		return v[i];
-	}
-	/// Reset vector.
-	void Free() {
-		delete []v;
-		v = 0;
-		size = 0;
-		len = 0;
-	}
-	/** @brief Grow vector size.
-	 * Doesn't allow a vector to be shrinked. */
-	void SetLength(unsigned int newLength) {
-		if (newLength > len) {
-			if (newLength >= size) {
-				SizeTo(newLength);
-			}
-		}
-		len = newLength;
-	}
-	/// Get the current length (number of used elements) of the vector.
-	int Length() const {
-		return len;
-	}
-};
-
-#ifdef SCI_NAMESPACE
-}
-#endif
-
-#endif
diff --git a/Pythonwin/Scintilla/src/SciTE.properties b/Pythonwin/Scintilla/src/SciTE.properties
new file mode 100644
index 000000000..1eda9fae4
--- /dev/null
+++ b/Pythonwin/Scintilla/src/SciTE.properties
@@ -0,0 +1,6 @@
+# SciTE.properties is the per directory local options file and can be used to override
+# settings made in SciTEGlobal.properties
+command.build.directory.*.cxx=..\win32
+command.build.directory.*.h=..\win32
+command.build.*.cxx=nmake -f scintilla.mak QUIET=1
+command.build.*.h=nmake -f scintilla.mak QUIET=1
diff --git a/Pythonwin/Scintilla/src/ScintillaBase.cxx b/Pythonwin/Scintilla/src/ScintillaBase.cxx
index d1d9ad4cb..9180b3796 100644
--- a/Pythonwin/Scintilla/src/ScintillaBase.cxx
+++ b/Pythonwin/Scintilla/src/ScintillaBase.cxx
@@ -5,21 +5,35 @@
 // Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <memory>
 
 #include "Platform.h"
 
+#include "ILoader.h"
+#include "ILexer.h"
 #include "Scintilla.h"
-#include "PropSet.h"
-#ifdef SCI_LEXER
+
 #include "SciLexer.h"
-#include "Accessor.h"
-#include "DocumentAccessor.h"
-#include "KeyWords.h"
-#endif
+
+#include "PropSetSimple.h"
+#include "CharacterCategory.h"
+
+#include "LexerModule.h"
+#include "Catalogue.h"
+
+#include "Position.h"
+#include "UniqueString.h"
 #include "SplitVector.h"
 #include "Partitioning.h"
 #include "RunStyles.h"
@@ -28,41 +42,37 @@
 #include "CallTip.h"
 #include "KeyMap.h"
 #include "Indicator.h"
-#include "XPM.h"
 #include "LineMarker.h"
 #include "Style.h"
 #include "ViewStyle.h"
-#include "AutoComplete.h"
 #include "CharClassify.h"
 #include "Decoration.h"
+#include "CaseFolder.h"
 #include "Document.h"
+#include "Selection.h"
 #include "PositionCache.h"
+#include "EditModel.h"
+#include "MarginView.h"
+#include "EditView.h"
 #include "Editor.h"
+#include "AutoComplete.h"
 #include "ScintillaBase.h"
 
-#ifdef SCI_NAMESPACE
+#include "ExternalLexer.h"
+
 using namespace Scintilla;
-#endif
 
 ScintillaBase::ScintillaBase() {
-	displayPopupMenu = true;
+	displayPopupMenu = SC_POPUP_ALL;
 	listType = 0;
 	maxListWidth = 0;
+	multiAutoCMode = SC_MULTIAUTOC_ONCE;
 #ifdef SCI_LEXER
-	lexLanguage = SCLEX_CONTAINER;
-	performingStyle = false;
-	lexCurrent = 0;
-	for (int wl = 0;wl < numWordLists;wl++)
-		keyWordLists[wl] = new WordList;
-	keyWordLists[numWordLists] = 0;
+	Scintilla_LinkLexers();
 #endif
 }
 
 ScintillaBase::~ScintillaBase() {
-#ifdef SCI_LEXER
-	for (int wl = 0;wl < numWordLists;wl++)
-		delete keyWordLists[wl];
-#endif
 }
 
 void ScintillaBase::Finalise() {
@@ -70,22 +80,21 @@ void ScintillaBase::Finalise() {
 	popup.Destroy();
 }
 
-void ScintillaBase::RefreshColourPalette(Palette &pal, bool want) {
-	Editor::RefreshColourPalette(pal, want);
-	ct.RefreshColourPalette(pal, want);
+void ScintillaBase::AddCharUTF(const char *s, unsigned int len, bool /*treatAsDBCS*/) {
+	InsertCharacter(std::string_view(s, len), CharacterSource::directInput);
 }
 
-void ScintillaBase::AddCharUTF(char *s, unsigned int len, bool treatAsDBCS) {
-	bool isFillUp = ac.Active() && ac.IsFillUpChar(*s);
+void ScintillaBase::InsertCharacter(std::string_view sv, CharacterSource charSource) {
+	const bool isFillUp = ac.Active() && ac.IsFillUpChar(sv[0]);
 	if (!isFillUp) {
-		Editor::AddCharUTF(s, len, treatAsDBCS);
+		Editor::InsertCharacter(sv, charSource);
 	}
 	if (ac.Active()) {
-		AutoCompleteCharacterAdded(s[0]);
+		AutoCompleteCharacterAdded(sv[0]);
 		// For fill ups add the character after the autocompletion has
 		// triggered so containers see the key so can display a calltip.
 		if (isFillUp) {
-			Editor::AddCharUTF(s, len, treatAsDBCS);
+			Editor::InsertCharacter(sv, charSource);
 		}
 	}
 }
@@ -141,16 +150,16 @@ int ScintillaBase::KeyCommand(unsigned int iMessage) {
 			AutoCompleteMove(1);
 			return 0;
 		case SCI_LINEUP:
-			AutoCompleteMove( -1);
+			AutoCompleteMove(-1);
 			return 0;
 		case SCI_PAGEDOWN:
-			AutoCompleteMove(5);
+			AutoCompleteMove(ac.lb->GetVisibleRows());
 			return 0;
 		case SCI_PAGEUP:
-			AutoCompleteMove( -5);
+			AutoCompleteMove(-ac.lb->GetVisibleRows());
 			return 0;
 		case SCI_VCHOME:
-			AutoCompleteMove( -5000);
+			AutoCompleteMove(-5000);
 			return 0;
 		case SCI_LINEEND:
 			AutoCompleteMove(5000);
@@ -166,10 +175,10 @@ int ScintillaBase::KeyCommand(unsigned int iMessage) {
 			EnsureCaretVisible();
 			return 0;
 		case SCI_TAB:
-			AutoCompleteCompleted();
+			AutoCompleteCompleted(0, SC_AC_TAB);
 			return 0;
 		case SCI_NEWLINE:
-			AutoCompleteCompleted();
+			AutoCompleteCompleted(0, SC_AC_NEWLINE);
 			return 0;
 
 		default:
@@ -190,7 +199,7 @@ int ScintillaBase::KeyCommand(unsigned int iMessage) {
 			ct.CallTipCancel();
 		}
 		if ((iMessage == SCI_DELETEBACK) || (iMessage == SCI_DELETEBACKNOTLINE)) {
-			if (currentPos <= ct.posStartCallTip) {
+			if (sel.MainCaret() <= ct.posStartCallTip) {
 				ct.CallTipCancel();
 			}
 		}
@@ -198,88 +207,122 @@ int ScintillaBase::KeyCommand(unsigned int iMessage) {
 	return Editor::KeyCommand(iMessage);
 }
 
-void ScintillaBase::AutoCompleteDoubleClick(void* p) {
-	ScintillaBase* sci = reinterpret_cast<ScintillaBase*>(p);
-	sci->AutoCompleteCompleted();
+void ScintillaBase::ListNotify(ListBoxEvent *plbe) {
+	switch (plbe->event) {
+	case ListBoxEvent::EventType::selectionChange:
+		AutoCompleteSelection();
+		break;
+	case ListBoxEvent::EventType::doubleClick:
+		AutoCompleteCompleted(0, SC_AC_DOUBLECLICK);
+		break;
+	}
+}
+
+void ScintillaBase::AutoCompleteInsert(Sci::Position startPos, Sci::Position removeLen, const char *text, Sci::Position textLen) {
+	UndoGroup ug(pdoc);
+	if (multiAutoCMode == SC_MULTIAUTOC_ONCE) {
+		pdoc->DeleteChars(startPos, removeLen);
+		const Sci::Position lengthInserted = pdoc->InsertString(startPos, text, textLen);
+		SetEmptySelection(startPos + lengthInserted);
+	} else {
+		// SC_MULTIAUTOC_EACH
+		for (size_t r=0; r<sel.Count(); r++) {
+			if (!RangeContainsProtected(sel.Range(r).Start().Position(),
+				sel.Range(r).End().Position())) {
+				Sci::Position positionInsert = sel.Range(r).Start().Position();
+				positionInsert = RealizeVirtualSpace(positionInsert, sel.Range(r).caret.VirtualSpace());
+				if (positionInsert - removeLen >= 0) {
+					positionInsert -= removeLen;
+					pdoc->DeleteChars(positionInsert, removeLen);
+				}
+				const Sci::Position lengthInserted = pdoc->InsertString(positionInsert, text, textLen);
+				if (lengthInserted > 0) {
+					sel.Range(r).caret.SetPosition(positionInsert + lengthInserted);
+					sel.Range(r).anchor.SetPosition(positionInsert + lengthInserted);
+				}
+				sel.Range(r).ClearVirtualSpace();
+			}
+		}
+	}
 }
 
-void ScintillaBase::AutoCompleteStart(int lenEntered, const char *list) {
+void ScintillaBase::AutoCompleteStart(Sci::Position lenEntered, const char *list) {
 	//Platform::DebugPrintf("AutoComplete %s\n", list);
 	ct.CallTipCancel();
 
 	if (ac.chooseSingle && (listType == 0)) {
 		if (list && !strchr(list, ac.GetSeparator())) {
 			const char *typeSep = strchr(list, ac.GetTypesep());
-			size_t lenInsert = (typeSep) ? (typeSep-list) : strlen(list);
+			const Sci::Position lenInsert = typeSep ?
+				(typeSep-list) : strlen(list);
 			if (ac.ignoreCase) {
-				SetEmptySelection(currentPos - lenEntered);
-				pdoc->DeleteChars(currentPos, lenEntered);
-				SetEmptySelection(currentPos);
-				pdoc->InsertString(currentPos, list, lenInsert);
-				SetEmptySelection(currentPos + lenInsert);
+				// May need to convert the case before invocation, so remove lenEntered characters
+				AutoCompleteInsert(sel.MainCaret() - lenEntered, lenEntered, list, lenInsert);
 			} else {
-				SetEmptySelection(currentPos);
-				pdoc->InsertString(currentPos, list + lenEntered, lenInsert - lenEntered);
-				SetEmptySelection(currentPos + lenInsert - lenEntered);
+				AutoCompleteInsert(sel.MainCaret(), 0, list + lenEntered, lenInsert - lenEntered);
 			}
+			ac.Cancel();
 			return;
 		}
 	}
-	ac.Start(wMain, idAutoComplete, currentPos, LocationFromPosition(currentPos),
-				lenEntered, vs.lineHeight, IsUnicodeMode());
+	ac.Start(wMain, idAutoComplete, sel.MainCaret(), PointMainCaret(),
+				lenEntered, vs.lineHeight, IsUnicodeMode(), technology);
 
-	PRectangle rcClient = GetClientRectangle();
-	Point pt = LocationFromPosition(currentPos - lenEntered);
+	const PRectangle rcClient = GetClientRectangle();
+	Point pt = LocationFromPosition(sel.MainCaret() - lenEntered);
 	PRectangle rcPopupBounds = wMain.GetMonitorRect(pt);
 	if (rcPopupBounds.Height() == 0)
 		rcPopupBounds = rcClient;
 
-	int heightLB = 100;
-	int widthLB = 100;
+	int heightLB = ac.heightLBDefault;
+	int widthLB = ac.widthLBDefault;
 	if (pt.x >= rcClient.right - widthLB) {
-		HorizontalScrollTo(xOffset + pt.x - rcClient.right + widthLB);
+		HorizontalScrollTo(static_cast<int>(xOffset + pt.x - rcClient.right + widthLB));
 		Redraw();
-		pt = LocationFromPosition(currentPos);
+		pt = PointMainCaret();
+	}
+	if (wMargin.Created()) {
+		pt = pt + GetVisibleOriginInMain();
 	}
 	PRectangle rcac;
 	rcac.left = pt.x - ac.lb->CaretFromEdge();
-	if (pt.y >= rcPopupBounds.bottom - heightLB &&  // Wont fit below.
+	if (pt.y >= rcPopupBounds.bottom - heightLB &&  // Won't fit below.
 	        pt.y >= (rcPopupBounds.bottom + rcPopupBounds.top) / 2) { // and there is more room above.
 		rcac.top = pt.y - heightLB;
 		if (rcac.top < rcPopupBounds.top) {
-			heightLB -= (rcPopupBounds.top - rcac.top);
+			heightLB -= static_cast<int>(rcPopupBounds.top - rcac.top);
 			rcac.top = rcPopupBounds.top;
 		}
 	} else {
 		rcac.top = pt.y + vs.lineHeight;
 	}
 	rcac.right = rcac.left + widthLB;
-	rcac.bottom = Platform::Minimum(rcac.top + heightLB, rcPopupBounds.bottom);
-	ac.lb->SetPositionRelative(rcac, wMain);
+	rcac.bottom = static_cast<XYPOSITION>(std::min(static_cast<int>(rcac.top) + heightLB, static_cast<int>(rcPopupBounds.bottom)));
+	ac.lb->SetPositionRelative(rcac, &wMain);
 	ac.lb->SetFont(vs.styles[STYLE_DEFAULT].font);
-	unsigned int aveCharWidth = vs.styles[STYLE_DEFAULT].aveCharWidth;
+	const unsigned int aveCharWidth = static_cast<unsigned int>(vs.styles[STYLE_DEFAULT].aveCharWidth);
 	ac.lb->SetAverageCharWidth(aveCharWidth);
-	ac.lb->SetDoubleClickAction(AutoCompleteDoubleClick, this);
+	ac.lb->SetDelegate(this);
 
-	ac.SetList(list);
+	ac.SetList(list ? list : "");
 
 	// Fiddle the position of the list so it is right next to the target and wide enough for all its strings
 	PRectangle rcList = ac.lb->GetDesiredRect();
-	int heightAlloced = rcList.bottom - rcList.top;
-	widthLB = Platform::Maximum(widthLB, rcList.right - rcList.left);
+	const int heightAlloced = static_cast<int>(rcList.bottom - rcList.top);
+	widthLB = std::max(widthLB, static_cast<int>(rcList.right - rcList.left));
 	if (maxListWidth != 0)
-		widthLB = Platform::Minimum(widthLB, aveCharWidth*maxListWidth);
+		widthLB = std::min(widthLB, static_cast<int>(aveCharWidth)*maxListWidth);
 	// Make an allowance for large strings in list
 	rcList.left = pt.x - ac.lb->CaretFromEdge();
 	rcList.right = rcList.left + widthLB;
-	if (((pt.y + vs.lineHeight) >= (rcPopupBounds.bottom - heightAlloced)) &&  // Wont fit below.
+	if (((pt.y + vs.lineHeight) >= (rcPopupBounds.bottom - heightAlloced)) &&  // Won't fit below.
 	        ((pt.y + vs.lineHeight / 2) >= (rcPopupBounds.bottom + rcPopupBounds.top) / 2)) { // and there is more room above.
 		rcList.top = pt.y - heightAlloced;
 	} else {
 		rcList.top = pt.y + vs.lineHeight;
 	}
 	rcList.bottom = rcList.top + heightAlloced;
-	ac.lb->SetPositionRelative(rcList, wMain);
+	ac.lb->SetPositionRelative(rcList, &wMain);
 	ac.Show(true);
 	if (lenEntered != 0) {
 		AutoCompleteMoveToCurrentWord();
@@ -288,7 +331,7 @@ void ScintillaBase::AutoCompleteStart(int lenEntered, const char *list) {
 
 void ScintillaBase::AutoCompleteCancel() {
 	if (ac.Active()) {
-		SCNotification scn = {0};
+		SCNotification scn = {};
 		scn.nmhdr.code = SCN_AUTOCCANCELLED;
 		scn.wParam = 0;
 		scn.listType = 0;
@@ -302,18 +345,32 @@ void ScintillaBase::AutoCompleteMove(int delta) {
 }
 
 void ScintillaBase::AutoCompleteMoveToCurrentWord() {
-	char wordCurrent[1000];
-	int i;
-	int startWord = ac.posStart - ac.startLen;
-	for (i = startWord; i < currentPos && i - startWord < 1000; i++)
-		wordCurrent[i - startWord] = pdoc->CharAt(i);
-	wordCurrent[Platform::Minimum(i - startWord, 999)] = '\0';
-	ac.Select(wordCurrent);
+	std::string wordCurrent = RangeText(ac.posStart - ac.startLen, sel.MainCaret());
+	ac.Select(wordCurrent.c_str());
+}
+
+void ScintillaBase::AutoCompleteSelection() {
+	const int item = ac.GetSelection();
+	std::string selected;
+	if (item != -1) {
+		selected = ac.GetValue(item);
+	}
+
+	SCNotification scn = {};
+	scn.nmhdr.code = SCN_AUTOCSELECTIONCHANGE;
+	scn.message = 0;
+	scn.wParam = listType;
+	scn.listType = listType;
+	const Sci::Position firstPos = ac.posStart - ac.startLen;
+	scn.position = firstPos;
+	scn.lParam = firstPos;
+	scn.text = selected.c_str();
+	NotifyParent(scn);
 }
 
 void ScintillaBase::AutoCompleteCharacterAdded(char ch) {
 	if (ac.IsFillUpChar(ch)) {
-		AutoCompleteCompleted();
+		AutoCompleteCompleted(ch, SC_AC_FILLUP);
 	} else if (ac.IsStopChar(ch)) {
 		AutoCompleteCancel();
 	} else {
@@ -322,37 +379,41 @@ void ScintillaBase::AutoCompleteCharacterAdded(char ch) {
 }
 
 void ScintillaBase::AutoCompleteCharacterDeleted() {
-	if (currentPos < ac.posStart - ac.startLen) {
+	if (sel.MainCaret() < ac.posStart - ac.startLen) {
 		AutoCompleteCancel();
-	} else if (ac.cancelAtStartPos && (currentPos <= ac.posStart)) {
+	} else if (ac.cancelAtStartPos && (sel.MainCaret() <= ac.posStart)) {
 		AutoCompleteCancel();
 	} else {
 		AutoCompleteMoveToCurrentWord();
 	}
+	SCNotification scn = {};
+	scn.nmhdr.code = SCN_AUTOCCHARDELETED;
+	scn.wParam = 0;
+	scn.listType = 0;
+	NotifyParent(scn);
 }
 
-void ScintillaBase::AutoCompleteCompleted() {
-	int item = ac.lb->GetSelection();
-	char selected[1000];
-	selected[0] = '\0';
-	if (item != -1) {
-		ac.lb->GetValue(item, selected, sizeof(selected));
-	} else {
+void ScintillaBase::AutoCompleteCompleted(char ch, unsigned int completionMethod) {
+	const int item = ac.GetSelection();
+	if (item == -1) {
 		AutoCompleteCancel();
 		return;
 	}
+	const std::string selected = ac.GetValue(item);
 
 	ac.Show(false);
 
-	listSelected = selected;
-	SCNotification scn = {0};
+	SCNotification scn = {};
 	scn.nmhdr.code = listType > 0 ? SCN_USERLISTSELECTION : SCN_AUTOCSELECTION;
 	scn.message = 0;
+	scn.ch = ch;
+	scn.listCompletionMethod = completionMethod;
 	scn.wParam = listType;
 	scn.listType = listType;
-	Position firstPos = ac.posStart - ac.startLen;
+	const Sci::Position firstPos = ac.posStart - ac.startLen;
+	scn.position = firstPos;
 	scn.lParam = firstPos;
-	scn.text = listSelected.c_str();
+	scn.text = selected.c_str();
 	NotifyParent(scn);
 
 	if (!ac.Active())
@@ -362,77 +423,104 @@ void ScintillaBase::AutoCompleteCompleted() {
 	if (listType > 0)
 		return;
 
-	Position endPos = currentPos;
+	Sci::Position endPos = sel.MainCaret();
 	if (ac.dropRestOfWord)
 		endPos = pdoc->ExtendWordSelect(endPos, 1, true);
 	if (endPos < firstPos)
 		return;
-	pdoc->BeginUndoAction();
-	if (endPos != firstPos) {
-		pdoc->DeleteChars(firstPos, endPos - firstPos);
-	}
-	SetEmptySelection(ac.posStart);
-	if (item != -1) {
-		SString piece = selected;
-		pdoc->InsertCString(firstPos, piece.c_str());
-		SetEmptySelection(firstPos + static_cast<int>(piece.length()));
-	}
-	pdoc->EndUndoAction();
+	AutoCompleteInsert(firstPos, endPos - firstPos, selected.c_str(), selected.length());
+	SetLastXChosen();
+
+	scn.nmhdr.code = SCN_AUTOCCOMPLETED;
+	NotifyParent(scn);
+
+}
+
+int ScintillaBase::AutoCompleteGetCurrent() const {
+	if (!ac.Active())
+		return -1;
+	return ac.GetSelection();
 }
 
-int ScintillaBase::AutoCompleteGetCurrent() {
-	return ac.lb->GetSelection();
+int ScintillaBase::AutoCompleteGetCurrentText(char *buffer) const {
+	if (ac.Active()) {
+		const int item = ac.GetSelection();
+		if (item != -1) {
+			const std::string selected = ac.GetValue(item);
+			if (buffer)
+				memcpy(buffer, selected.c_str(), selected.length()+1);
+			return static_cast<int>(selected.length());
+		}
+	}
+	if (buffer)
+		*buffer = '\0';
+	return 0;
 }
 
 void ScintillaBase::CallTipShow(Point pt, const char *defn) {
 	ac.Cancel();
-	pt.y += vs.lineHeight;
 	// If container knows about STYLE_CALLTIP then use it in place of the
 	// STYLE_DEFAULT for the face name, size and character set. Also use it
 	// for the foreground and background colour.
-	int ctStyle = ct.UseStyleCallTip() ? STYLE_CALLTIP : STYLE_DEFAULT;
+	const int ctStyle = ct.UseStyleCallTip() ? STYLE_CALLTIP : STYLE_DEFAULT;
 	if (ct.UseStyleCallTip()) {
 		ct.SetForeBack(vs.styles[STYLE_CALLTIP].fore, vs.styles[STYLE_CALLTIP].back);
 	}
-	PRectangle rc = ct.CallTipStart(currentPos, pt,
+	if (wMargin.Created()) {
+		pt = pt + GetVisibleOriginInMain();
+	}
+	PRectangle rc = ct.CallTipStart(sel.MainCaret(), pt,
+		vs.lineHeight,
 		defn,
 		vs.styles[ctStyle].fontName,
 		vs.styles[ctStyle].sizeZoomed,
 		CodePage(),
 		vs.styles[ctStyle].characterSet,
+		vs.technology,
 		wMain);
 	// If the call-tip window would be out of the client
-	// space, adjust so it displays above the text.
-	PRectangle rcClient = GetClientRectangle();
-	if (rc.bottom > rcClient.bottom) {
-		int offset = vs.lineHeight + rc.Height();
+	// space
+	const PRectangle rcClient = GetClientRectangle();
+	const int offset = vs.lineHeight + static_cast<int>(rc.Height());
+	// adjust so it displays above the text.
+	if (rc.bottom > rcClient.bottom && rc.Height() < rcClient.Height()) {
 		rc.top -= offset;
 		rc.bottom -= offset;
 	}
+	// adjust so it displays below the text.
+	if (rc.top < rcClient.top && rc.Height() < rcClient.Height()) {
+		rc.top += offset;
+		rc.bottom += offset;
+	}
 	// Now display the window.
 	CreateCallTipWindow(rc);
-	ct.wCallTip.SetPositionRelative(rc, wMain);
+	ct.wCallTip.SetPositionRelative(rc, &wMain);
 	ct.wCallTip.Show();
 }
 
 void ScintillaBase::CallTipClick() {
-	SCNotification scn = {0};
+	SCNotification scn = {};
 	scn.nmhdr.code = SCN_CALLTIPCLICK;
 	scn.position = ct.clickPlace;
 	NotifyParent(scn);
 }
 
+bool ScintillaBase::ShouldDisplayPopup(Point ptInWindowCoordinates) const {
+	return (displayPopupMenu == SC_POPUP_ALL ||
+		(displayPopupMenu == SC_POPUP_TEXT && !PointInSelMargin(ptInWindowCoordinates)));
+}
+
 void ScintillaBase::ContextMenu(Point pt) {
 	if (displayPopupMenu) {
-		bool writable = !WndProc(SCI_GETREADONLY, 0, 0);
+		const bool writable = !WndProc(SCI_GETREADONLY, 0, 0);
 		popup.CreatePopUp();
 		AddToPopUp("Undo", idcmdUndo, writable && pdoc->CanUndo());
 		AddToPopUp("Redo", idcmdRedo, writable && pdoc->CanRedo());
 		AddToPopUp("");
-		AddToPopUp("Cut", idcmdCut, writable && currentPos != anchor);
-		AddToPopUp("Copy", idcmdCopy, currentPos != anchor);
+		AddToPopUp("Cut", idcmdCut, writable && !sel.Empty());
+		AddToPopUp("Copy", idcmdCopy, !sel.Empty());
 		AddToPopUp("Paste", idcmdPaste, writable && WndProc(SCI_CANPASTE, 0, 0));
-		AddToPopUp("Delete", idcmdDelete, writable && currentPos != anchor);
+		AddToPopUp("Delete", idcmdDelete, writable && !sel.Empty());
 		AddToPopUp("");
 		AddToPopUp("Select All", idcmdSelectAll);
 		popup.Show(pt, wMain);
@@ -445,83 +533,352 @@ void ScintillaBase::CancelModes() {
 	Editor::CancelModes();
 }
 
-void ScintillaBase::ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt) {
+void ScintillaBase::ButtonDownWithModifiers(Point pt, unsigned int curTime, int modifiers) {
 	CancelModes();
-	Editor::ButtonDown(pt, curTime, shift, ctrl, alt);
+	Editor::ButtonDownWithModifiers(pt, curTime, modifiers);
 }
 
-#ifdef SCI_LEXER
-void ScintillaBase::SetLexer(uptr_t wParam) {
-	lexLanguage = wParam;
-	lexCurrent = LexerModule::Find(lexLanguage);
-	if (!lexCurrent)
-		lexCurrent = LexerModule::Find(SCLEX_NULL);
+void ScintillaBase::RightButtonDownWithModifiers(Point pt, unsigned int curTime, int modifiers) {
+	CancelModes();
+	Editor::RightButtonDownWithModifiers(pt, curTime, modifiers);
 }
 
-void ScintillaBase::SetLexerLanguage(const char *languageName) {
+namespace Scintilla {
+
+class LexState : public LexInterface {
+	const LexerModule *lexCurrent;
+	void SetLexerModule(const LexerModule *lex);
+	PropSetSimple props;
+	int interfaceVersion;
+public:
+	int lexLanguage;
+
+	explicit LexState(Document *pdoc_);
+	void SetInstance(ILexer5 *instance_);
+	// Deleted so LexState objects can not be copied.
+	LexState(const LexState &) = delete;
+	LexState(LexState &&) = delete;
+	LexState &operator=(const LexState &) = delete;
+	LexState &operator=(LexState &&) = delete;
+	~LexState() override;
+	void SetLexer(uptr_t wParam);
+	void SetLexerLanguage(const char *languageName);
+
+	const char *DescribeWordListSets();
+	void SetWordList(int n, const char *wl);
+	int GetIdentifier() const;
+	const char *GetName() const;
+	void *PrivateCall(int operation, void *pointer);
+	const char *PropertyNames();
+	int PropertyType(const char *name);
+	const char *DescribeProperty(const char *name);
+	void PropSet(const char *key, const char *val);
+	const char *PropGet(const char *key) const;
+	int PropGetInt(const char *key, int defaultValue=0) const;
+	size_t PropGetExpanded(const char *key, char *result) const;
+
+	int LineEndTypesSupported() override;
+	int AllocateSubStyles(int styleBase, int numberStyles);
+	int SubStylesStart(int styleBase);
+	int SubStylesLength(int styleBase);
+	int StyleFromSubStyle(int subStyle);
+	int PrimaryStyleFromStyle(int style);
+	void FreeSubStyles();
+	void SetIdentifiers(int style, const char *identifiers);
+	int DistanceToSecondaryStyles();
+	const char *GetSubStyleBases();
+	int NamedStyles();
+	const char *NameOfStyle(int style);
+	const char *TagsOfStyle(int style);
+	const char *DescriptionOfStyle(int style);
+};
+
+}
+
+LexState::LexState(Document *pdoc_) : LexInterface(pdoc_) {
+	lexCurrent = nullptr;
+	performingStyle = false;
+	interfaceVersion = lvRelease4;
 	lexLanguage = SCLEX_CONTAINER;
-	lexCurrent = LexerModule::Find(languageName);
-	if (!lexCurrent)
-		lexCurrent = LexerModule::Find(SCLEX_NULL);
-	if (lexCurrent)
-		lexLanguage = lexCurrent->GetLanguage();
-}
-
-void ScintillaBase::Colourise(int start, int end) {
-	if (!performingStyle) {
-		// Protect against reentrance, which may occur, for example, when
-		// fold points are discovered while performing styling and the folding
-		// code looks for child lines which may trigger styling.
-		performingStyle = true;
-
-		int lengthDoc = pdoc->Length();
-		if (end == -1)
-			end = lengthDoc;
-		int len = end - start;
-
-		PLATFORM_ASSERT(len >= 0);
-		PLATFORM_ASSERT(start + len <= lengthDoc);
-
-		//WindowAccessor styler(wMain.GetID(), props);
-		DocumentAccessor styler(pdoc, props, wMain.GetID());
-
-		int styleStart = 0;
-		if (start > 0)
-			styleStart = styler.StyleAt(start - 1) & pdoc->stylingBitsMask;
-		styler.SetCodePage(pdoc->dbcsCodePage);
-
-		if (lexCurrent && (len > 0)) {	// Should always succeed as null lexer should always be available
-			lexCurrent->Lex(start, len, styleStart, keyWordLists, styler);
-			styler.Flush();
-			if (styler.GetPropertyInt("fold")) {
-				lexCurrent->Fold(start, len, styleStart, keyWordLists, styler);
-				styler.Flush();
-			}
+}
+
+LexState::~LexState() {
+	if (instance) {
+		instance->Release();
+		instance = nullptr;
+	}
+}
+
+void LexState::SetInstance(ILexer5 *instance_) {
+	if (instance) {
+		instance->Release();
+		instance = nullptr;
+	}
+	instance = instance_;
+	pdoc->LexerChanged();
+}
+
+LexState *ScintillaBase::DocumentLexState() {
+	if (!pdoc->GetLexInterface()) {
+		pdoc->SetLexInterface(std::make_unique<LexState>(pdoc));
+	}
+	return dynamic_cast<LexState *>(pdoc->GetLexInterface());
+}
+
+void LexState::SetLexerModule(const LexerModule *lex) {
+	if (lex != lexCurrent) {
+		if (instance) {
+			instance->Release();
+			instance = nullptr;
+		}
+		interfaceVersion = lvRelease4;
+		lexCurrent = lex;
+		if (lexCurrent) {
+			instance = lexCurrent->Create();
+			interfaceVersion = instance->Version();
 		}
+		pdoc->LexerChanged();
+	}
+}
 
-		performingStyle = false;
+void LexState::SetLexer(uptr_t wParam) {
+	lexLanguage = static_cast<int>(wParam);
+	if (lexLanguage == SCLEX_CONTAINER) {
+		SetLexerModule(nullptr);
+	} else {
+		const LexerModule *lex = Catalogue::Find(lexLanguage);
+		if (!lex)
+			lex = Catalogue::Find(SCLEX_NULL);
+		SetLexerModule(lex);
 	}
 }
-#endif
 
-void ScintillaBase::NotifyStyleToNeeded(int endStyleNeeded) {
-#ifdef SCI_LEXER
-	if (lexLanguage != SCLEX_CONTAINER) {
-		int endStyled = WndProc(SCI_GETENDSTYLED, 0, 0);
-		int lineEndStyled = WndProc(SCI_LINEFROMPOSITION, endStyled, 0);
-		endStyled = WndProc(SCI_POSITIONFROMLINE, lineEndStyled, 0);
-		Colourise(endStyled, endStyleNeeded);
+void LexState::SetLexerLanguage(const char *languageName) {
+	const LexerModule *lex = Catalogue::Find(languageName);
+	if (!lex)
+		lex = Catalogue::Find(SCLEX_NULL);
+	if (lex)
+		lexLanguage = lex->GetLanguage();
+	SetLexerModule(lex);
+}
+
+const char *LexState::DescribeWordListSets() {
+	if (instance) {
+		return instance->DescribeWordListSets();
+	} else {
+		return nullptr;
+	}
+}
+
+void LexState::SetWordList(int n, const char *wl) {
+	if (instance) {
+		const Sci_Position firstModification = instance->WordListSet(n, wl);
+		if (firstModification >= 0) {
+			pdoc->ModifiedAt(firstModification);
+		}
+	}
+}
+
+int LexState::GetIdentifier() const {
+	if (lexCurrent) {
+		return lexCurrent->GetLanguage();
+	}
+	if (instance) {
+		if (instance->Version() >= lvRelease5) {
+			return instance->GetIdentifier();
+		}
+	}
+	return SCLEX_CONTAINER;
+}
+
+const char *LexState::GetName() const {
+	if (lexCurrent) {
+		return lexCurrent->languageName;
+	}
+	if (instance) {
+		if (instance->Version() >= lvRelease5) {
+			return instance->GetName();
+		}
+	}
+	return "";
+}
+
+void *LexState::PrivateCall(int operation, void *pointer) {
+	if (pdoc && instance) {
+		return instance->PrivateCall(operation, pointer);
+	} else {
+		return nullptr;
+	}
+}
+
+const char *LexState::PropertyNames() {
+	if (instance) {
+		return instance->PropertyNames();
+	} else {
+		return nullptr;
+	}
+}
+
+int LexState::PropertyType(const char *name) {
+	if (instance) {
+		return instance->PropertyType(name);
+	} else {
+		return SC_TYPE_BOOLEAN;
+	}
+}
+
+const char *LexState::DescribeProperty(const char *name) {
+	if (instance) {
+		return instance->DescribeProperty(name);
+	} else {
+		return nullptr;
+	}
+}
+
+void LexState::PropSet(const char *key, const char *val) {
+	props.Set(key, val, strlen(key), strlen(val));
+	if (instance) {
+		const Sci_Position firstModification = instance->PropertySet(key, val);
+		if (firstModification >= 0) {
+			pdoc->ModifiedAt(firstModification);
+		}
+	}
+}
+
+const char *LexState::PropGet(const char *key) const {
+	return props.Get(key);
+}
+
+int LexState::PropGetInt(const char *key, int defaultValue) const {
+	return props.GetInt(key, defaultValue);
+}
+
+size_t LexState::PropGetExpanded(const char *key, char *result) const {
+	return props.GetExpanded(key, result);
+}
+
+int LexState::LineEndTypesSupported() {
+	if (instance) {
+		return instance->LineEndTypesSupported();
+	}
+	return 0;
+}
+
+int LexState::AllocateSubStyles(int styleBase, int numberStyles) {
+	if (instance) {
+		return instance->AllocateSubStyles(styleBase, numberStyles);
+	}
+	return -1;
+}
+
+int LexState::SubStylesStart(int styleBase) {
+	if (instance) {
+		return instance->SubStylesStart(styleBase);
+	}
+	return -1;
+}
+
+int LexState::SubStylesLength(int styleBase) {
+	if (instance) {
+		return instance->SubStylesLength(styleBase);
+	}
+	return 0;
+}
+
+int LexState::StyleFromSubStyle(int subStyle) {
+	if (instance) {
+		return instance->StyleFromSubStyle(subStyle);
+	}
+	return 0;
+}
+
+int LexState::PrimaryStyleFromStyle(int style) {
+	if (instance) {
+		return instance->PrimaryStyleFromStyle(style);
+	}
+	return 0;
+}
+
+void LexState::FreeSubStyles() {
+	if (instance) {
+		instance->FreeSubStyles();
+	}
+}
+
+void LexState::SetIdentifiers(int style, const char *identifiers) {
+	if (instance) {
+		instance->SetIdentifiers(style, identifiers);
+		pdoc->ModifiedAt(0);
+	}
+}
+
+int LexState::DistanceToSecondaryStyles() {
+	if (instance) {
+		return instance->DistanceToSecondaryStyles();
+	}
+	return 0;
+}
+
+const char *LexState::GetSubStyleBases() {
+	if (instance) {
+		return instance->GetSubStyleBases();
+	}
+	return "";
+}
+
+int LexState::NamedStyles() {
+	if (instance) {
+		return instance->NamedStyles();
+	} else {
+		return -1;
+	}
+}
+
+const char *LexState::NameOfStyle(int style) {
+	if (instance) {
+		return instance->NameOfStyle(style);
+	} else {
+		return nullptr;
+	}
+}
+
+const char *LexState::TagsOfStyle(int style) {
+	if (instance) {
+		return instance->TagsOfStyle(style);
+	} else {
+		return nullptr;
+	}
+}
+
+const char *LexState::DescriptionOfStyle(int style) {
+	if (instance) {
+		return instance->DescriptionOfStyle(style);
+	} else {
+		return nullptr;
+	}
+}
+
+void ScintillaBase::NotifyStyleToNeeded(Sci::Position endStyleNeeded) {
+	if (DocumentLexState()->GetIdentifier() != SCLEX_CONTAINER) {
+		const Sci::Line lineEndStyled =
+			pdoc->SciLineFromPosition(pdoc->GetEndStyled());
+		const Sci::Position endStyled =
+			pdoc->LineStart(lineEndStyled);
+		DocumentLexState()->Colourise(endStyled, endStyleNeeded);
 		return;
 	}
-#endif
 	Editor::NotifyStyleToNeeded(endStyleNeeded);
 }
 
+void ScintillaBase::NotifyLexerChanged(Document *, void *) {
+	vs.EnsureStyle(0xff);
+}
+
 sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
 	switch (iMessage) {
 	case SCI_AUTOCSHOW:
 		listType = 0;
-		AutoCompleteStart(wParam, reinterpret_cast<const char *>(lParam));
+		AutoCompleteStart(static_cast<Sci::Position>(wParam), ConstCharPtrFromSPtr(lParam));
 		break;
 
 	case SCI_AUTOCCANCEL:
@@ -535,7 +892,7 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara
 		return ac.posStart;
 
 	case SCI_AUTOCCOMPLETE:
-		AutoCompleteCompleted();
+		AutoCompleteCompleted(0, SC_AC_COMMAND);
 		break;
 
 	case SCI_AUTOCSETSEPARATOR:
@@ -546,16 +903,19 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara
 		return ac.GetSeparator();
 
 	case SCI_AUTOCSTOPS:
-		ac.SetStopChars(reinterpret_cast<char *>(lParam));
+		ac.SetStopChars(ConstCharPtrFromSPtr(lParam));
 		break;
 
 	case SCI_AUTOCSELECT:
-		ac.Select(reinterpret_cast<char *>(lParam));
+		ac.Select(ConstCharPtrFromSPtr(lParam));
 		break;
 
 	case SCI_AUTOCGETCURRENT:
 		return AutoCompleteGetCurrent();
 
+	case SCI_AUTOCGETCURRENTTEXT:
+		return AutoCompleteGetCurrentText(CharPtrFromSPtr(lParam));
+
 	case SCI_AUTOCSETCANCELATSTART:
 		ac.cancelAtStartPos = wParam != 0;
 		break;
@@ -564,7 +924,7 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara
 		return ac.cancelAtStartPos;
 
 	case SCI_AUTOCSETFILLUPS:
-		ac.SetFillUpChars(reinterpret_cast<char *>(lParam));
+		ac.SetFillUpChars(ConstCharPtrFromSPtr(lParam));
 		break;
 
 	case SCI_AUTOCSETCHOOSESINGLE:
@@ -581,9 +941,30 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara
 	case SCI_AUTOCGETIGNORECASE:
 		return ac.ignoreCase;
 
+	case SCI_AUTOCSETCASEINSENSITIVEBEHAVIOUR:
+		ac.ignoreCaseBehaviour = static_cast<unsigned int>(wParam);
+		break;
+
+	case SCI_AUTOCGETCASEINSENSITIVEBEHAVIOUR:
+		return ac.ignoreCaseBehaviour;
+
+	case SCI_AUTOCSETMULTI:
+		multiAutoCMode = static_cast<int>(wParam);
+		break;
+
+	case SCI_AUTOCGETMULTI:
+		return multiAutoCMode;
+
+	case SCI_AUTOCSETORDER:
+		ac.autoSort = static_cast<int>(wParam);
+		break;
+
+	case SCI_AUTOCGETORDER:
+		return ac.autoSort;
+
 	case SCI_USERLISTSHOW:
-		listType = wParam;
-		AutoCompleteStart(0, reinterpret_cast<const char *>(lParam));
+		listType = static_cast<int>(wParam);
+		AutoCompleteStart(0, ConstCharPtrFromSPtr(lParam));
 		break;
 
 	case SCI_AUTOCSETAUTOHIDE:
@@ -601,21 +982,26 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara
 		return ac.dropRestOfWord;
 
 	case SCI_AUTOCSETMAXHEIGHT:
-		ac.lb->SetVisibleRows(wParam);
+		ac.lb->SetVisibleRows(static_cast<int>(wParam));
 		break;
 
 	case SCI_AUTOCGETMAXHEIGHT:
 		return ac.lb->GetVisibleRows();
 
 	case SCI_AUTOCSETMAXWIDTH:
-		maxListWidth = wParam;
+		maxListWidth = static_cast<int>(wParam);
 		break;
 
 	case SCI_AUTOCGETMAXWIDTH:
 		return maxListWidth;
 
 	case SCI_REGISTERIMAGE:
-		ac.lb->RegisterImage(wParam, reinterpret_cast<const char *>(lParam));
+		ac.lb->RegisterImage(static_cast<int>(wParam), ConstCharPtrFromSPtr(lParam));
+		break;
+
+	case SCI_REGISTERRGBAIMAGE:
+		ac.lb->RegisterRGBAImage(static_cast<int>(wParam), static_cast<int>(sizeRGBAImage.x), static_cast<int>(sizeRGBAImage.y),
+			ConstUCharPtrFromSPtr(lParam));
 		break;
 
 	case SCI_CLEARREGISTEREDIMAGES:
@@ -631,7 +1017,7 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara
 
 	case SCI_CALLTIPSHOW:
 		CallTipShow(LocationFromPosition(wParam),
-			reinterpret_cast<const char *>(lParam));
+			ConstCharPtrFromSPtr(lParam));
 		break;
 
 	case SCI_CALLTIPCANCEL:
@@ -644,102 +1030,170 @@ sptr_t ScintillaBase::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPara
 	case SCI_CALLTIPPOSSTART:
 		return ct.posStartCallTip;
 
+	case SCI_CALLTIPSETPOSSTART:
+		ct.posStartCallTip = wParam;
+		break;
+
 	case SCI_CALLTIPSETHLT:
 		ct.SetHighlight(wParam, lParam);
 		break;
 
 	case SCI_CALLTIPSETBACK:
-		ct.colourBG = ColourDesired(wParam);
+		ct.colourBG = ColourDesired(static_cast<int>(wParam));
 		vs.styles[STYLE_CALLTIP].back = ct.colourBG;
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_CALLTIPSETFORE:
-		ct.colourUnSel = ColourDesired(wParam);
+		ct.colourUnSel = ColourDesired(static_cast<int>(wParam));
 		vs.styles[STYLE_CALLTIP].fore = ct.colourUnSel;
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_CALLTIPSETFOREHLT:
-		ct.colourSel = ColourDesired(wParam);
+		ct.colourSel = ColourDesired(static_cast<int>(wParam));
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_CALLTIPUSESTYLE:
-		ct.SetTabSize((int)wParam);
+		ct.SetTabSize(static_cast<int>(wParam));
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_CALLTIPSETPOSITION:
+		ct.SetPosition(wParam != 0);
 		InvalidateStyleRedraw();
 		break;
 
 	case SCI_USEPOPUP:
-		displayPopupMenu = wParam != 0;
+		displayPopupMenu = static_cast<int>(wParam);
 		break;
 
-#ifdef SCI_LEXER
 	case SCI_SETLEXER:
-		SetLexer(wParam);
-		lexLanguage = wParam;
+		DocumentLexState()->SetLexer(static_cast<int>(wParam));
 		break;
 
 	case SCI_GETLEXER:
-		return lexLanguage;
+		return DocumentLexState()->GetIdentifier();
+
+	case SCI_SETILEXER:
+		DocumentLexState()->SetInstance(reinterpret_cast<ILexer5 *>(lParam));
+		return 0;
 
 	case SCI_COLOURISE:
-		if (lexLanguage == SCLEX_CONTAINER) {
-			pdoc->ModifiedAt(wParam);
+		if (DocumentLexState()->lexLanguage == SCLEX_CONTAINER) {
+			pdoc->ModifiedAt(static_cast<Sci::Position>(wParam));
 			NotifyStyleToNeeded((lParam == -1) ? pdoc->Length() : lParam);
 		} else {
-			Colourise(wParam, lParam);
+			DocumentLexState()->Colourise(static_cast<Sci::Position>(wParam), lParam);
 		}
 		Redraw();
 		break;
 
 	case SCI_SETPROPERTY:
-		props.Set(reinterpret_cast<const char *>(wParam),
-		          reinterpret_cast<const char *>(lParam));
+		DocumentLexState()->PropSet(ConstCharPtrFromUPtr(wParam),
+		          ConstCharPtrFromSPtr(lParam));
 		break;
 
-	case SCI_GETPROPERTY: {
-			SString val = props.Get(reinterpret_cast<const char *>(wParam));
-			const int n = val.length();
-			if (lParam != 0) {
-				char *ptr = reinterpret_cast<char *>(lParam);
-				memcpy(ptr, val.c_str(), n);
-				ptr[n] = '\0';	// terminate
-			}
-			return n;	// Not including NUL
-		}
+	case SCI_GETPROPERTY:
+		return StringResult(lParam, DocumentLexState()->PropGet(ConstCharPtrFromUPtr(wParam)));
 
-	case SCI_GETPROPERTYEXPANDED: {
-			SString val = props.GetExpanded(reinterpret_cast<const char *>(wParam));
-			const int n = val.length();
-			if (lParam != 0) {
-				char *ptr = reinterpret_cast<char *>(lParam);
-				memcpy(ptr, val.c_str(), n);
-				ptr[n] = '\0';	// terminate
-			}
-			return n;	// Not including NUL
-		}
+	case SCI_GETPROPERTYEXPANDED:
+		return DocumentLexState()->PropGetExpanded(ConstCharPtrFromUPtr(wParam),
+			CharPtrFromSPtr(lParam));
 
 	case SCI_GETPROPERTYINT:
-		return props.GetInt(reinterpret_cast<const char *>(wParam), lParam);
+		return DocumentLexState()->PropGetInt(ConstCharPtrFromUPtr(wParam), static_cast<int>(lParam));
 
 	case SCI_SETKEYWORDS:
-		if (wParam < numWordLists) {
-			keyWordLists[wParam]->Clear();
-			keyWordLists[wParam]->Set(reinterpret_cast<const char *>(lParam));
-		}
+		DocumentLexState()->SetWordList(static_cast<int>(wParam), ConstCharPtrFromSPtr(lParam));
 		break;
 
 	case SCI_SETLEXERLANGUAGE:
-		SetLexerLanguage(reinterpret_cast<const char *>(lParam));
+		DocumentLexState()->SetLexerLanguage(ConstCharPtrFromSPtr(lParam));
 		break;
 
+	case SCI_GETLEXERLANGUAGE:
+		return StringResult(lParam, DocumentLexState()->GetName());
+
+#ifdef SCI_LEXER
+	case SCI_LOADLEXERLIBRARY:
+		ExternalLexerLoad(ConstCharPtrFromSPtr(lParam));
+		break;
+#endif
+
+	case SCI_PRIVATELEXERCALL:
+		return reinterpret_cast<sptr_t>(
+			DocumentLexState()->PrivateCall(static_cast<int>(wParam), reinterpret_cast<void *>(lParam)));
+
+#ifdef INCLUDE_DEPRECATED_FEATURES
 	case SCI_GETSTYLEBITSNEEDED:
-		return lexCurrent ? lexCurrent->GetStyleBitsNeeded() : 5;
+		return 8;
 #endif
 
+	case SCI_PROPERTYNAMES:
+		return StringResult(lParam, DocumentLexState()->PropertyNames());
+
+	case SCI_PROPERTYTYPE:
+		return DocumentLexState()->PropertyType(ConstCharPtrFromUPtr(wParam));
+
+	case SCI_DESCRIBEPROPERTY:
+		return StringResult(lParam,
+				    DocumentLexState()->DescribeProperty(ConstCharPtrFromUPtr(wParam)));
+
+	case SCI_DESCRIBEKEYWORDSETS:
+		return StringResult(lParam, DocumentLexState()->DescribeWordListSets());
+
+	case SCI_GETLINEENDTYPESSUPPORTED:
+		return DocumentLexState()->LineEndTypesSupported();
+
+	case SCI_ALLOCATESUBSTYLES:
+		return DocumentLexState()->AllocateSubStyles(static_cast<int>(wParam), static_cast<int>(lParam));
+
+	case SCI_GETSUBSTYLESSTART:
+		return DocumentLexState()->SubStylesStart(static_cast<int>(wParam));
+
+	case SCI_GETSUBSTYLESLENGTH:
+		return DocumentLexState()->SubStylesLength(static_cast<int>(wParam));
+
+	case SCI_GETSTYLEFROMSUBSTYLE:
+		return DocumentLexState()->StyleFromSubStyle(static_cast<int>(wParam));
+
+	case SCI_GETPRIMARYSTYLEFROMSTYLE:
+		return DocumentLexState()->PrimaryStyleFromStyle(static_cast<int>(wParam));
+
+	case SCI_FREESUBSTYLES:
+		DocumentLexState()->FreeSubStyles();
+		break;
+
+	case SCI_SETIDENTIFIERS:
+		DocumentLexState()->SetIdentifiers(static_cast<int>(wParam),
+						   ConstCharPtrFromSPtr(lParam));
+		break;
+
+	case SCI_DISTANCETOSECONDARYSTYLES:
+		return DocumentLexState()->DistanceToSecondaryStyles();
+
+	case SCI_GETSUBSTYLEBASES:
+		return StringResult(lParam, DocumentLexState()->GetSubStyleBases());
+
+	case SCI_GETNAMEDSTYLES:
+		return DocumentLexState()->NamedStyles();
+
+	case SCI_NAMEOFSTYLE:
+		return StringResult(lParam, DocumentLexState()->
+				    NameOfStyle(static_cast<int>(wParam)));
+
+	case SCI_TAGSOFSTYLE:
+		return StringResult(lParam, DocumentLexState()->
+				    TagsOfStyle(static_cast<int>(wParam)));
+
+	case SCI_DESCRIPTIONOFSTYLE:
+		return StringResult(lParam, DocumentLexState()->
+				    DescriptionOfStyle(static_cast<int>(wParam)));
+
 	default:
 		return Editor::WndProc(iMessage, wParam, lParam);
 	}
-	return 0l;
+	return 0;
 }
diff --git a/Pythonwin/Scintilla/src/ScintillaBase.h b/Pythonwin/Scintilla/src/ScintillaBase.h
index 0554d9457..b7a4acf1f 100644
--- a/Pythonwin/Scintilla/src/ScintillaBase.h
+++ b/Pythonwin/Scintilla/src/ScintillaBase.h
@@ -8,17 +8,12 @@
 #ifndef SCINTILLABASE_H
 #define SCINTILLABASE_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
 
+class LexState;
 /**
  */
-class ScintillaBase : public Editor {
-	// Private so ScintillaBase objects can not be copied
-	ScintillaBase(const ScintillaBase &) : Editor() {}
-	ScintillaBase &operator=(const ScintillaBase &) { return *this; }
-
+class ScintillaBase : public Editor, IListBoxDelegate {
 protected:
 	/** Enumeration of commands and child windows. */
 	enum {
@@ -34,68 +29,74 @@ class ScintillaBase : public Editor {
 		idcmdSelectAll=16
 	};
 
-	bool displayPopupMenu;
+	int displayPopupMenu;
 	Menu popup;
 	AutoComplete ac;
 
 	CallTip ct;
 
 	int listType;			///< 0 is an autocomplete list
-	SString listSelected;	///< Receives listbox selected string
 	int maxListWidth;		/// Maximum width of list, in average character widths
+	int multiAutoCMode; /// Mode for autocompleting when multiple selections are present
 
-	bool performingStyle;	///< Prevent reentrance
-
-#ifdef SCI_LEXER
-	int lexLanguage;
-	const LexerModule *lexCurrent;
-	PropSet props;
-	enum {numWordLists=KEYWORDSET_MAX+1};
-	WordList *keyWordLists[numWordLists+1];
+	LexState *DocumentLexState();
 	void SetLexer(uptr_t wParam);
 	void SetLexerLanguage(const char *languageName);
 	void Colourise(int start, int end);
-#endif
 
 	ScintillaBase();
-	virtual ~ScintillaBase();
-	virtual void Initialise() = 0;
-	virtual void Finalise() = 0;
-
-	virtual void RefreshColourPalette(Palette &pal, bool want);
-
-	virtual void AddCharUTF(char *s, unsigned int len, bool treatAsDBCS=false);
+	// Deleted so ScintillaBase objects can not be copied.
+	ScintillaBase(const ScintillaBase &) = delete;
+	ScintillaBase(ScintillaBase &&) = delete;
+	ScintillaBase &operator=(const ScintillaBase &) = delete;
+	ScintillaBase &operator=(ScintillaBase &&) = delete;
+	// ~ScintillaBase() in public section
+	void Initialise() override {}
+	void Finalise() override;
+
+	[[deprecated]]
+	// This method is deprecated, use InsertCharacter instead. The treatAsDBCS parameter is no longer used.
+	virtual void AddCharUTF(const char *s, unsigned int len, bool treatAsDBCS=false);
+
+	void InsertCharacter(std::string_view sv, CharacterSource charSource) override;
 	void Command(int cmdId);
-	virtual void CancelModes();
-	virtual int KeyCommand(unsigned int iMessage);
+	void CancelModes() override;
+	int KeyCommand(unsigned int iMessage) override;
 
-	void AutoCompleteStart(int lenEntered, const char *list);
+	void AutoCompleteInsert(Sci::Position startPos, Sci::Position removeLen, const char *text, Sci::Position textLen);
+	void AutoCompleteStart(Sci::Position lenEntered, const char *list);
 	void AutoCompleteCancel();
 	void AutoCompleteMove(int delta);
-	int AutoCompleteGetCurrent();
+	int AutoCompleteGetCurrent() const;
+	int AutoCompleteGetCurrentText(char *buffer) const;
 	void AutoCompleteCharacterAdded(char ch);
 	void AutoCompleteCharacterDeleted();
-	void AutoCompleteCompleted();
+	void AutoCompleteCompleted(char ch, unsigned int completionMethod);
 	void AutoCompleteMoveToCurrentWord();
-	static void AutoCompleteDoubleClick(void* p);
+	void AutoCompleteSelection();
+	void ListNotify(ListBoxEvent *plbe) override;
 
 	void CallTipClick();
 	void CallTipShow(Point pt, const char *defn);
 	virtual void CreateCallTipWindow(PRectangle rc) = 0;
 
 	virtual void AddToPopUp(const char *label, int cmd=0, bool enabled=true) = 0;
+	bool ShouldDisplayPopup(Point ptInWindowCoordinates) const;
 	void ContextMenu(Point pt);
 
-	virtual void ButtonDown(Point pt, unsigned int curTime, bool shift, bool ctrl, bool alt);
+	void ButtonDownWithModifiers(Point pt, unsigned int curTime, int modifiers) override;
+	void RightButtonDownWithModifiers(Point pt, unsigned int curTime, int modifiers) override;
+
+	void NotifyStyleToNeeded(Sci::Position endStyleNeeded) override;
+	void NotifyLexerChanged(Document *doc, void *userData) override;
 
-	virtual void NotifyStyleToNeeded(int endStyleNeeded);
 public:
+	~ScintillaBase() override;
+
 	// Public so scintilla_send_message can use it
-	virtual sptr_t WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+	sptr_t WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) override;
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/Selection.cxx b/Pythonwin/Scintilla/src/Selection.cxx
new file mode 100644
index 000000000..4274b190c
--- /dev/null
+++ b/Pythonwin/Scintilla/src/Selection.cxx
@@ -0,0 +1,451 @@
+// Scintilla source code edit control
+/** @file Selection.cxx
+ ** Classes maintaining the selection.
+ **/
+// Copyright 2009 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <cstddef>
+#include <cstdlib>
+
+#include <stdexcept>
+#include <string_view>
+#include <vector>
+#include <algorithm>
+#include <memory>
+
+#include "Platform.h"
+
+#include "Scintilla.h"
+
+#include "Position.h"
+#include "Selection.h"
+
+using namespace Scintilla;
+
+void SelectionPosition::MoveForInsertDelete(bool insertion, Sci::Position startChange, Sci::Position length, bool moveForEqual) noexcept {
+	if (insertion) {
+		if (position == startChange) {
+			// Always consume virtual space
+			const Sci::Position virtualLengthRemove = std::min(length, virtualSpace);
+			virtualSpace -= virtualLengthRemove;
+			position += virtualLengthRemove;
+			if (moveForEqual) {
+				const Sci::Position lengthAfterVirtualRemove = length - virtualLengthRemove;
+				position += lengthAfterVirtualRemove;
+			}
+		} else if (position > startChange) {
+			position += length;
+		}
+	} else {
+		if (position == startChange) {
+			virtualSpace = 0;
+		}
+		if (position > startChange) {
+			const Sci::Position endDeletion = startChange + length;
+			if (position > endDeletion) {
+				position -= length;
+			} else {
+				position = startChange;
+				virtualSpace = 0;
+			}
+		}
+	}
+}
+
+bool SelectionPosition::operator <(const SelectionPosition &other) const noexcept {
+	if (position == other.position)
+		return virtualSpace < other.virtualSpace;
+	else
+		return position < other.position;
+}
+
+bool SelectionPosition::operator >(const SelectionPosition &other) const noexcept {
+	if (position == other.position)
+		return virtualSpace > other.virtualSpace;
+	else
+		return position > other.position;
+}
+
+bool SelectionPosition::operator <=(const SelectionPosition &other) const noexcept {
+	if (position == other.position && virtualSpace == other.virtualSpace)
+		return true;
+	else
+		return other > *this;
+}
+
+bool SelectionPosition::operator >=(const SelectionPosition &other) const noexcept {
+	if (position == other.position && virtualSpace == other.virtualSpace)
+		return true;
+	else
+		return *this > other;
+}
+
+Sci::Position SelectionRange::Length() const noexcept {
+	if (anchor > caret) {
+		return anchor.Position() - caret.Position();
+	} else {
+		return caret.Position() - anchor.Position();
+	}
+}
+
+void SelectionRange::MoveForInsertDelete(bool insertion, Sci::Position startChange, Sci::Position length) noexcept {
+	// For insertions that occur at the start of the selection move both the start
+	// and end of the selection to preserve the selected length.
+	// The end will automatically move since it is after the insertion, so determine
+	// which position is the start and pass this into
+	// SelectionPosition::MoveForInsertDelete.
+	// There isn't any reason to move an empty selection so don't move it.
+	const bool caretStart = caret.Position() < anchor.Position();
+	const bool anchorStart = anchor.Position() < caret.Position();
+
+	caret.MoveForInsertDelete(insertion, startChange, length, caretStart);
+	anchor.MoveForInsertDelete(insertion, startChange, length, anchorStart);
+}
+
+bool SelectionRange::Contains(Sci::Position pos) const noexcept {
+	if (anchor > caret)
+		return (pos >= caret.Position()) && (pos <= anchor.Position());
+	else
+		return (pos >= anchor.Position()) && (pos <= caret.Position());
+}
+
+bool SelectionRange::Contains(SelectionPosition sp) const noexcept {
+	if (anchor > caret)
+		return (sp >= caret) && (sp <= anchor);
+	else
+		return (sp >= anchor) && (sp <= caret);
+}
+
+bool SelectionRange::ContainsCharacter(Sci::Position posCharacter) const noexcept {
+	if (anchor > caret)
+		return (posCharacter >= caret.Position()) && (posCharacter < anchor.Position());
+	else
+		return (posCharacter >= anchor.Position()) && (posCharacter < caret.Position());
+}
+
+SelectionSegment SelectionRange::Intersect(SelectionSegment check) const noexcept {
+	const SelectionSegment inOrder(caret, anchor);
+	if ((inOrder.start <= check.end) || (inOrder.end >= check.start)) {
+		SelectionSegment portion = check;
+		if (portion.start < inOrder.start)
+			portion.start = inOrder.start;
+		if (portion.end > inOrder.end)
+			portion.end = inOrder.end;
+		if (portion.start > portion.end)
+			return SelectionSegment();
+		else
+			return portion;
+	} else {
+		return SelectionSegment();
+	}
+}
+
+void SelectionRange::Swap() noexcept {
+	std::swap(caret, anchor);
+}
+
+bool SelectionRange::Trim(SelectionRange range) noexcept {
+	const SelectionPosition startRange = range.Start();
+	const SelectionPosition endRange = range.End();
+	SelectionPosition start = Start();
+	SelectionPosition end = End();
+	PLATFORM_ASSERT(start <= end);
+	PLATFORM_ASSERT(startRange <= endRange);
+	if ((startRange <= end) && (endRange >= start)) {
+		if ((start > startRange) && (end < endRange)) {
+			// Completely covered by range -> empty at start
+			end = start;
+		} else if ((start < startRange) && (end > endRange)) {
+			// Completely covers range -> empty at start
+			end = start;
+		} else if (start <= startRange) {
+			// Trim end
+			end = startRange;
+		} else { //
+			PLATFORM_ASSERT(end >= endRange);
+			// Trim start
+			start = endRange;
+		}
+		if (anchor > caret) {
+			caret = start;
+			anchor = end;
+		} else {
+			anchor = start;
+			caret = end;
+		}
+		return Empty();
+	} else {
+		return false;
+	}
+}
+
+// If range is all virtual collapse to start of virtual space
+void SelectionRange::MinimizeVirtualSpace() noexcept {
+	if (caret.Position() == anchor.Position()) {
+		Sci::Position virtualSpace = caret.VirtualSpace();
+		if (virtualSpace > anchor.VirtualSpace())
+			virtualSpace = anchor.VirtualSpace();
+		caret.SetVirtualSpace(virtualSpace);
+		anchor.SetVirtualSpace(virtualSpace);
+	}
+}
+
+Selection::Selection() : mainRange(0), moveExtends(false), tentativeMain(false), selType(selStream) {
+	AddSelection(SelectionRange(SelectionPosition(0)));
+}
+
+Selection::~Selection() {
+}
+
+bool Selection::IsRectangular() const noexcept {
+	return (selType == selRectangle) || (selType == selThin);
+}
+
+Sci::Position Selection::MainCaret() const noexcept {
+	return ranges[mainRange].caret.Position();
+}
+
+Sci::Position Selection::MainAnchor() const noexcept {
+	return ranges[mainRange].anchor.Position();
+}
+
+SelectionRange &Selection::Rectangular() noexcept {
+	return rangeRectangular;
+}
+
+SelectionSegment Selection::Limits() const noexcept {
+	if (ranges.empty()) {
+		return SelectionSegment();
+	} else {
+		SelectionSegment sr(ranges[0].anchor, ranges[0].caret);
+		for (size_t i=1; i<ranges.size(); i++) {
+			sr.Extend(ranges[i].anchor);
+			sr.Extend(ranges[i].caret);
+		}
+		return sr;
+	}
+}
+
+SelectionSegment Selection::LimitsForRectangularElseMain() const {
+	if (IsRectangular()) {
+		return Limits();
+	} else {
+		return SelectionSegment(ranges[mainRange].caret, ranges[mainRange].anchor);
+	}
+}
+
+size_t Selection::Count() const noexcept {
+	return ranges.size();
+}
+
+size_t Selection::Main() const noexcept {
+	return mainRange;
+}
+
+void Selection::SetMain(size_t r) noexcept {
+	PLATFORM_ASSERT(r < ranges.size());
+	mainRange = r;
+}
+
+SelectionRange &Selection::Range(size_t r) noexcept {
+	return ranges[r];
+}
+
+const SelectionRange &Selection::Range(size_t r) const noexcept {
+	return ranges[r];
+}
+
+SelectionRange &Selection::RangeMain() noexcept {
+	return ranges[mainRange];
+}
+
+const SelectionRange &Selection::RangeMain() const noexcept {
+	return ranges[mainRange];
+}
+
+SelectionPosition Selection::Start() const noexcept {
+	if (IsRectangular()) {
+		return rangeRectangular.Start();
+	} else {
+		return ranges[mainRange].Start();
+	}
+}
+
+bool Selection::MoveExtends() const noexcept {
+	return moveExtends;
+}
+
+void Selection::SetMoveExtends(bool moveExtends_) noexcept {
+	moveExtends = moveExtends_;
+}
+
+bool Selection::Empty() const noexcept {
+	for (const SelectionRange &range : ranges) {
+		if (!range.Empty())
+			return false;
+	}
+	return true;
+}
+
+SelectionPosition Selection::Last() const noexcept {
+	SelectionPosition lastPosition;
+	for (const SelectionRange &range : ranges) {
+		if (lastPosition < range.caret)
+			lastPosition = range.caret;
+		if (lastPosition < range.anchor)
+			lastPosition = range.anchor;
+	}
+	return lastPosition;
+}
+
+Sci::Position Selection::Length() const noexcept {
+	Sci::Position len = 0;
+	for (const SelectionRange &range : ranges) {
+		len += range.Length();
+	}
+	return len;
+}
+
+void Selection::MovePositions(bool insertion, Sci::Position startChange, Sci::Position length) noexcept {
+	for (SelectionRange &range : ranges) {
+		range.MoveForInsertDelete(insertion, startChange, length);
+	}
+	if (selType == selRectangle) {
+		rangeRectangular.MoveForInsertDelete(insertion, startChange, length);
+	}
+}
+
+void Selection::TrimSelection(SelectionRange range) noexcept {
+	for (size_t i=0; i<ranges.size();) {
+		if ((i != mainRange) && (ranges[i].Trim(range))) {
+			// Trimmed to empty so remove
+			for (size_t j=i; j<ranges.size()-1; j++) {
+				ranges[j] = ranges[j+1];
+				if (j == mainRange-1)
+					mainRange--;
+			}
+			ranges.pop_back();
+		} else {
+			i++;
+		}
+	}
+}
+
+void Selection::TrimOtherSelections(size_t r, SelectionRange range) noexcept {
+	for (size_t i = 0; i<ranges.size(); ++i) {
+		if (i != r) {
+			ranges[i].Trim(range);
+		}
+	}
+}
+
+void Selection::SetSelection(SelectionRange range) {
+	ranges.clear();
+	ranges.push_back(range);
+	mainRange = ranges.size() - 1;
+}
+
+void Selection::AddSelection(SelectionRange range) {
+	TrimSelection(range);
+	ranges.push_back(range);
+	mainRange = ranges.size() - 1;
+}
+
+void Selection::AddSelectionWithoutTrim(SelectionRange range) {
+	ranges.push_back(range);
+	mainRange = ranges.size() - 1;
+}
+
+void Selection::DropSelection(size_t r) {
+	if ((ranges.size() > 1) && (r < ranges.size())) {
+		size_t mainNew = mainRange;
+		if (mainNew >= r) {
+			if (mainNew == 0) {
+				mainNew = ranges.size() - 2;
+			} else {
+				mainNew--;
+			}
+		}
+		ranges.erase(ranges.begin() + r);
+		mainRange = mainNew;
+	}
+}
+
+void Selection::DropAdditionalRanges() {
+	SetSelection(RangeMain());
+}
+
+void Selection::TentativeSelection(SelectionRange range) {
+	if (!tentativeMain) {
+		rangesSaved = ranges;
+	}
+	ranges = rangesSaved;
+	AddSelection(range);
+	TrimSelection(ranges[mainRange]);
+	tentativeMain = true;
+}
+
+void Selection::CommitTentative() noexcept {
+	rangesSaved.clear();
+	tentativeMain = false;
+}
+
+int Selection::CharacterInSelection(Sci::Position posCharacter) const noexcept {
+	for (size_t i=0; i<ranges.size(); i++) {
+		if (ranges[i].ContainsCharacter(posCharacter))
+			return i == mainRange ? 1 : 2;
+	}
+	return 0;
+}
+
+int Selection::InSelectionForEOL(Sci::Position pos) const noexcept {
+	for (size_t i=0; i<ranges.size(); i++) {
+		if (!ranges[i].Empty() && (pos > ranges[i].Start().Position()) && (pos <= ranges[i].End().Position()))
+			return i == mainRange ? 1 : 2;
+	}
+	return 0;
+}
+
+Sci::Position Selection::VirtualSpaceFor(Sci::Position pos) const noexcept {
+	Sci::Position virtualSpace = 0;
+	for (const SelectionRange &range : ranges) {
+		if ((range.caret.Position() == pos) && (virtualSpace < range.caret.VirtualSpace()))
+			virtualSpace = range.caret.VirtualSpace();
+		if ((range.anchor.Position() == pos) && (virtualSpace < range.anchor.VirtualSpace()))
+			virtualSpace = range.anchor.VirtualSpace();
+	}
+	return virtualSpace;
+}
+
+void Selection::Clear() {
+	ranges.clear();
+	ranges.emplace_back();
+	mainRange = ranges.size() - 1;
+	selType = selStream;
+	moveExtends = false;
+	ranges[mainRange].Reset();
+	rangeRectangular.Reset();
+}
+
+void Selection::RemoveDuplicates() {
+	for (size_t i=0; i<ranges.size()-1; i++) {
+		if (ranges[i].Empty()) {
+			size_t j=i+1;
+			while (j<ranges.size()) {
+				if (ranges[i] == ranges[j]) {
+					ranges.erase(ranges.begin() + j);
+					if (mainRange >= j)
+						mainRange--;
+				} else {
+					j++;
+				}
+			}
+		}
+	}
+}
+
+void Selection::RotateMain() noexcept {
+	mainRange = (mainRange + 1) % ranges.size();
+}
+
diff --git a/Pythonwin/Scintilla/src/Selection.h b/Pythonwin/Scintilla/src/Selection.h
new file mode 100644
index 000000000..c5c7993cf
--- /dev/null
+++ b/Pythonwin/Scintilla/src/Selection.h
@@ -0,0 +1,195 @@
+// Scintilla source code edit control
+/** @file Selection.h
+ ** Classes maintaining the selection.
+ **/
+// Copyright 2009 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef SELECTION_H
+#define SELECTION_H
+
+namespace Scintilla {
+
+class SelectionPosition {
+	Sci::Position position;
+	Sci::Position virtualSpace;
+public:
+	explicit SelectionPosition(Sci::Position position_=INVALID_POSITION, Sci::Position virtualSpace_=0) noexcept : position(position_), virtualSpace(virtualSpace_) {
+		PLATFORM_ASSERT(virtualSpace < 800000);
+		if (virtualSpace < 0)
+			virtualSpace = 0;
+	}
+	void Reset() noexcept {
+		position = 0;
+		virtualSpace = 0;
+	}
+	void MoveForInsertDelete(bool insertion, Sci::Position startChange, Sci::Position length, bool moveForEqual) noexcept;
+	bool operator ==(const SelectionPosition &other) const noexcept {
+		return position == other.position && virtualSpace == other.virtualSpace;
+	}
+	bool operator <(const SelectionPosition &other) const noexcept;
+	bool operator >(const SelectionPosition &other) const noexcept;
+	bool operator <=(const SelectionPosition &other) const noexcept;
+	bool operator >=(const SelectionPosition &other) const noexcept;
+	Sci::Position Position() const noexcept {
+		return position;
+	}
+	void SetPosition(Sci::Position position_) noexcept {
+		position = position_;
+		virtualSpace = 0;
+	}
+	Sci::Position VirtualSpace() const noexcept {
+		return virtualSpace;
+	}
+	void SetVirtualSpace(Sci::Position virtualSpace_) noexcept {
+		PLATFORM_ASSERT(virtualSpace_ < 800000);
+		if (virtualSpace_ >= 0)
+			virtualSpace = virtualSpace_;
+	}
+	void Add(Sci::Position increment) noexcept {
+		position = position + increment;
+	}
+	bool IsValid() const noexcept {
+		return position >= 0;
+	}
+};
+
+// Ordered range to make drawing simpler
+struct SelectionSegment {
+	SelectionPosition start;
+	SelectionPosition end;
+	SelectionSegment() noexcept : start(), end() {
+	}
+	SelectionSegment(SelectionPosition a, SelectionPosition b) noexcept {
+		if (a < b) {
+			start = a;
+			end = b;
+		} else {
+			start = b;
+			end = a;
+		}
+	}
+	bool Empty() const noexcept {
+		return start == end;
+	}
+	Sci::Position Length() const noexcept {
+		return end.Position() - start.Position();
+	}
+	void Extend(SelectionPosition p) noexcept {
+		if (start > p)
+			start = p;
+		if (end < p)
+			end = p;
+	}
+};
+
+struct SelectionRange {
+	SelectionPosition caret;
+	SelectionPosition anchor;
+
+	SelectionRange() noexcept : caret(), anchor() {
+	}
+	explicit SelectionRange(SelectionPosition single) noexcept : caret(single), anchor(single) {
+	}
+	explicit SelectionRange(Sci::Position single) noexcept : caret(single), anchor(single) {
+	}
+	SelectionRange(SelectionPosition caret_, SelectionPosition anchor_) noexcept : caret(caret_), anchor(anchor_) {
+	}
+	SelectionRange(Sci::Position caret_, Sci::Position anchor_) noexcept : caret(caret_), anchor(anchor_) {
+	}
+	bool Empty() const noexcept {
+		return anchor == caret;
+	}
+	Sci::Position Length() const noexcept;
+	// Sci::Position Width() const;	// Like Length but takes virtual space into account
+	bool operator ==(const SelectionRange &other) const noexcept {
+		return caret == other.caret && anchor == other.anchor;
+	}
+	bool operator <(const SelectionRange &other) const noexcept {
+		return caret < other.caret || ((caret == other.caret) && (anchor < other.anchor));
+	}
+	void Reset() noexcept {
+		anchor.Reset();
+		caret.Reset();
+	}
+	void ClearVirtualSpace() noexcept {
+		anchor.SetVirtualSpace(0);
+		caret.SetVirtualSpace(0);
+	}
+	void MoveForInsertDelete(bool insertion, Sci::Position startChange, Sci::Position length) noexcept;
+	bool Contains(Sci::Position pos) const noexcept;
+	bool Contains(SelectionPosition sp) const noexcept;
+	bool ContainsCharacter(Sci::Position posCharacter) const noexcept;
+	SelectionSegment Intersect(SelectionSegment check) const noexcept;
+	SelectionPosition Start() const noexcept {
+		return (anchor < caret) ? anchor : caret;
+	}
+	SelectionPosition End() const noexcept {
+		return (anchor < caret) ? caret : anchor;
+	}
+	void Swap() noexcept;
+	bool Trim(SelectionRange range) noexcept;
+	// If range is all virtual collapse to start of virtual space
+	void MinimizeVirtualSpace() noexcept;
+};
+
+class Selection {
+	std::vector<SelectionRange> ranges;
+	std::vector<SelectionRange> rangesSaved;
+	SelectionRange rangeRectangular;
+	size_t mainRange;
+	bool moveExtends;
+	bool tentativeMain;
+public:
+	enum selTypes { noSel, selStream, selRectangle, selLines, selThin };
+	selTypes selType;
+
+	Selection();
+	~Selection();
+	bool IsRectangular() const noexcept;
+	Sci::Position MainCaret() const noexcept;
+	Sci::Position MainAnchor() const noexcept;
+	SelectionRange &Rectangular() noexcept;
+	SelectionSegment Limits() const noexcept;
+	// This is for when you want to move the caret in response to a
+	// user direction command - for rectangular selections, use the range
+	// that covers all selected text otherwise return the main selection.
+	SelectionSegment LimitsForRectangularElseMain() const;
+	size_t Count() const noexcept;
+	size_t Main() const noexcept;
+	void SetMain(size_t r) noexcept;
+	SelectionRange &Range(size_t r) noexcept;
+	const SelectionRange &Range(size_t r) const noexcept;
+	SelectionRange &RangeMain() noexcept;
+	const SelectionRange &RangeMain() const noexcept;
+	SelectionPosition Start() const noexcept;
+	bool MoveExtends() const noexcept;
+	void SetMoveExtends(bool moveExtends_) noexcept;
+	bool Empty() const noexcept;
+	SelectionPosition Last() const noexcept;
+	Sci::Position Length() const noexcept;
+	void MovePositions(bool insertion, Sci::Position startChange, Sci::Position length) noexcept;
+	void TrimSelection(SelectionRange range) noexcept;
+	void TrimOtherSelections(size_t r, SelectionRange range) noexcept;
+	void SetSelection(SelectionRange range);
+	void AddSelection(SelectionRange range);
+	void AddSelectionWithoutTrim(SelectionRange range);
+	void DropSelection(size_t r);
+	void DropAdditionalRanges();
+	void TentativeSelection(SelectionRange range);
+	void CommitTentative() noexcept;
+	int CharacterInSelection(Sci::Position posCharacter) const noexcept;
+	int InSelectionForEOL(Sci::Position pos) const noexcept;
+	Sci::Position VirtualSpaceFor(Sci::Position pos) const noexcept;
+	void Clear();
+	void RemoveDuplicates();
+	void RotateMain() noexcept;
+	bool Tentative() const noexcept { return tentativeMain; }
+	std::vector<SelectionRange> RangesCopy() const {
+		return ranges;
+	}
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/SparseVector.h b/Pythonwin/Scintilla/src/SparseVector.h
new file mode 100644
index 000000000..b0cfe2ded
--- /dev/null
+++ b/Pythonwin/Scintilla/src/SparseVector.h
@@ -0,0 +1,213 @@
+// Scintilla source code edit control
+/** @file SparseVector.h
+ ** Hold data sparsely associated with elements in a range.
+ **/
+// Copyright 2016 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef SPARSEVECTOR_H
+#define SPARSEVECTOR_H
+
+namespace Scintilla {
+
+// SparseVector is similar to RunStyles but is more efficient for cases where values occur
+// for one position instead of over a range of positions.
+// There are always elements at the start and end, so the element type should have
+// a reasonable empty value that will cause no problems.
+// The element type should have a noexcept default constructor as that allows methods to
+// be noexcept.
+template <typename T>
+class SparseVector {
+private:
+	std::unique_ptr<Partitioning<Sci::Position>> starts;
+	std::unique_ptr<SplitVector<T>> values;
+	T empty;	// Return from ValueAt when no element at a position.
+	void ClearValue(Sci::Position partition) noexcept {
+		values->SetValueAt(partition, T());
+	}
+public:
+	SparseVector() : empty() {
+		starts = std::make_unique<Partitioning<Sci::Position>>(8);
+		values = std::make_unique<SplitVector<T>>();
+		values->InsertEmpty(0, 2);
+	}
+	// Deleted so SparseVector objects can not be copied.
+	SparseVector(const SparseVector &) = delete;
+	SparseVector(SparseVector &&) = delete;
+	void operator=(const SparseVector &) = delete;
+	void operator=(SparseVector &&) = delete;
+	~SparseVector() {
+		starts.reset();
+		// starts dead here but not used by ClearValue.
+		for (Sci::Position part = 0; part < values->Length(); part++) {
+			ClearValue(part);
+		}
+		values.reset();
+	}
+	Sci::Position Length() const noexcept {
+		return starts->Length();
+	}
+	Sci::Position Elements() const noexcept {
+		return starts->Partitions();
+	}
+	Sci::Position PositionOfElement(Sci::Position element) const noexcept {
+		return starts->PositionFromPartition(element);
+	}
+	Sci::Position ElementFromPosition(Sci::Position position) const noexcept {
+		if (position < Length()) {
+			return starts->PartitionFromPosition(position);
+		} else {
+			return starts->Partitions();
+		}
+	}
+	const T& ValueAt(Sci::Position position) const noexcept {
+		assert(position <= Length());
+		const Sci::Position partition = ElementFromPosition(position);
+		const Sci::Position startPartition = starts->PositionFromPartition(partition);
+		if (startPartition == position) {
+			return values->ValueAt(partition);
+		} else {
+			return empty;
+		}
+	}
+	template <typename ParamType>
+	void SetValueAt(Sci::Position position, ParamType &&value) {
+		assert(position <= Length());
+		const Sci::Position partition = ElementFromPosition(position);
+		const Sci::Position startPartition = starts->PositionFromPartition(partition);
+		if (value == T()) {
+			// Setting the empty value is equivalent to deleting the position
+			if (position == 0) {
+				ClearValue(partition);
+			} else if (position == startPartition) {
+				// Currently an element at this position, so remove
+				ClearValue(partition);
+				starts->RemovePartition(partition);
+				values->Delete(partition);
+			}
+			// Else element remains empty
+		} else {
+			if (position == startPartition) {
+				// Already a value at this position, so replace
+				ClearValue(partition);
+				values->SetValueAt(partition, std::forward<ParamType>(value));
+			} else {
+				// Insert a new element
+				starts->InsertPartition(partition + 1, position);
+				values->Insert(partition + 1, std::forward<ParamType>(value));
+			}
+		}
+	}
+	void InsertSpace(Sci::Position position, Sci::Position insertLength) {
+		assert(position <= Length());
+		const Sci::Position partition = starts->PartitionFromPosition(position);
+		const Sci::Position startPartition = starts->PositionFromPartition(partition);
+		if (startPartition == position) {
+			const bool positionOccupied = values->ValueAt(partition) != T();
+			// Inserting at start of run so make previous longer
+			if (partition == 0) {
+				// Inserting at start of document so ensure start empty
+				if (positionOccupied) {
+					starts->InsertPartition(1, 0);
+					values->InsertEmpty(0, 1);
+				}
+				starts->InsertText(partition, insertLength);
+			} else {
+				if (positionOccupied) {
+					starts->InsertText(partition - 1, insertLength);
+				} else {
+					// Insert at end of run so do not extend style
+					starts->InsertText(partition, insertLength);
+				}
+			}
+		} else {
+			starts->InsertText(partition, insertLength);
+		}
+	}
+	void DeletePosition(Sci::Position position) {
+		assert(position < Length());
+		Sci::Position partition = starts->PartitionFromPosition(position);
+		const Sci::Position startPartition = starts->PositionFromPartition(partition);
+		if (startPartition == position) {
+			if (partition == 0) {
+				ClearValue(0);
+				if (starts->PositionFromPartition(1) == 1) {
+					// Removing all space of first partition, so remove next partition
+					// and move value if not last
+					if (Elements() > 1) {
+						starts->RemovePartition(partition + 1);
+						values->Delete(partition);
+					}
+				}
+			} else if (partition == starts->Partitions()) {
+				// This should not be possible
+				ClearValue(partition);
+				throw std::runtime_error("SparseVector: deleting end partition.");
+			} else {
+				ClearValue(partition);
+				starts->RemovePartition(partition);
+				values->Delete(partition);
+				// Its the previous partition now that gets smaller
+				partition--;
+			}
+		}
+		starts->InsertText(partition, -1);
+		Check();
+	}
+	void DeleteRange(Sci::Position position, Sci::Position deleteLength) {
+		// For now, delete elements in range - may want to leave value at start
+		// or combine onto position.
+		if (position > Length() || (deleteLength == 0)) {
+			return;
+		}
+		const Sci::Position positionEnd = position + deleteLength;
+		assert(positionEnd <= Length());
+		if (position == 0) {
+			// Remove all partitions in range, moving values to start
+			while ((Elements() > 1) && (starts->PositionFromPartition(1) <= deleteLength)) {
+				starts->RemovePartition(1);
+				values->Delete(0);
+			}
+			starts->InsertText(0, -deleteLength);
+			if (Length() == 0) {
+				ClearValue(0);
+			}
+		} else {
+			const Sci::Position partition = starts->PartitionFromPosition(position);
+			const bool atPartitionStart = position == starts->PositionFromPartition(partition);
+			const Sci::Position partitionDelete = partition + (atPartitionStart ? 0 : 1);
+			assert(partitionDelete > 0);
+			for (;;) {
+				const Sci::Position positionAtIndex = starts->PositionFromPartition(partitionDelete);
+				assert(position <= positionAtIndex);
+				if (positionAtIndex >= positionEnd) {
+					break;
+				}
+				assert(partitionDelete <= Elements());
+				starts->RemovePartition(partitionDelete);
+				values->Delete(partitionDelete);
+			}
+			starts->InsertText(partition - (atPartitionStart ? 1 : 0), -deleteLength);
+		}
+		Check();
+	}
+	Sci::Position IndexAfter(Sci::Position position) const noexcept {
+		assert(position < Length());
+		if (position < 0)
+			return 0;
+		const Sci::Position partition = starts->PartitionFromPosition(position);
+		return partition + 1;
+	}
+	void Check() const {
+#ifdef CHECK_CORRECTNESS
+		starts->Check();
+		if (starts->Partitions() != values->Length() - 1) {
+			throw std::runtime_error("SparseVector: Partitions and values different lengths.");
+		}
+#endif
+	}
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/SplitVector.h b/Pythonwin/Scintilla/src/SplitVector.h
index 76f9a8f36..e805c50dc 100644
--- a/Pythonwin/Scintilla/src/SplitVector.h
+++ b/Pythonwin/Scintilla/src/SplitVector.h
@@ -1,6 +1,6 @@
 // Scintilla source code edit control
 /** @file SplitVector.h
- ** Main data structure for holding arrays that handle insertions 
+ ** Main data structure for holding arrays that handle insertions
  ** and deletions efficiently.
  **/
 // Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
@@ -9,31 +9,35 @@
 #ifndef SPLITVECTOR_H
 #define SPLITVECTOR_H
 
+namespace Scintilla {
+
 template <typename T>
 class SplitVector {
 protected:
-	T *body;
-	int size;
-	int lengthBody;
-	int part1Length;
-	int gapLength;	/// invariant: gapLength == size - lengthBody
-	int growSize;
+	std::vector<T> body;
+	T empty;	/// Returned as the result of out-of-bounds access.
+	ptrdiff_t lengthBody;
+	ptrdiff_t part1Length;
+	ptrdiff_t gapLength;	/// invariant: gapLength == body.size() - lengthBody
+	ptrdiff_t growSize;
 
 	/// Move the gap to a particular position so that insertion and
 	/// deletion at that point will not require much copying and
 	/// hence be fast.
-	void GapTo(int position) {
+	void GapTo(ptrdiff_t position) noexcept {
 		if (position != part1Length) {
 			if (position < part1Length) {
-				memmove(
-					body + position + gapLength,
-					body + position,
-					sizeof(T) * (part1Length - position));
+				// Moving the gap towards start so moving elements towards end
+				std::move_backward(
+					body.data() + position,
+					body.data() + part1Length,
+					body.data() + gapLength + part1Length);
 			} else {	// position > part1Length
-				memmove(
-					body + part1Length,
-					body + part1Length + gapLength,
-					sizeof(T) * (position - part1Length));
+				// Moving the gap towards end so moving elements towards start
+				std::move(
+					body.data() + part1Length + gapLength,
+					body.data() + gapLength + position,
+					body.data() + part1Length);
 			}
 			part1Length = position;
 		}
@@ -41,101 +45,119 @@ class SplitVector {
 
 	/// Check that there is room in the buffer for an insertion,
 	/// reallocating if more space needed.
-	void RoomFor(int insertionLength) {
+	void RoomFor(ptrdiff_t insertionLength) {
 		if (gapLength <= insertionLength) {
-			if (growSize * 6 < size)
+			while (growSize < static_cast<ptrdiff_t>(body.size() / 6))
 				growSize *= 2;
-			ReAllocate(size + insertionLength + growSize);
+			ReAllocate(body.size() + insertionLength + growSize);
 		}
 	}
 
 	void Init() {
-		body = NULL;
-		growSize = 8;
-		size = 0;
+		body.clear();
+		body.shrink_to_fit();
 		lengthBody = 0;
 		part1Length = 0;
 		gapLength = 0;
+		growSize = 8;
 	}
 
 public:
 	/// Construct a split buffer.
-	SplitVector() {
-		Init();
+	SplitVector() : empty(), lengthBody(0), part1Length(0), gapLength(0), growSize(8) {
 	}
 
+	// Deleted so SplitVector objects can not be copied.
+	SplitVector(const SplitVector &) = delete;
+	SplitVector(SplitVector &&) = delete;
+	void operator=(const SplitVector &) = delete;
+	void operator=(SplitVector &&) = delete;
+
 	~SplitVector() {
-		delete []body;
-		body = 0;
 	}
 
-	int GetGrowSize() const {
+	ptrdiff_t GetGrowSize() const noexcept {
 		return growSize;
 	}
 
-	void SetGrowSize(int growSize_) {
+	void SetGrowSize(ptrdiff_t growSize_) noexcept {
 		growSize = growSize_;
 	}
 
 	/// Reallocate the storage for the buffer to be newSize and
-	/// copy exisiting contents to the new buffer.
+	/// copy existing contents to the new buffer.
 	/// Must not be used to decrease the size of the buffer.
-	void ReAllocate(int newSize) {
-		if (newSize > size) {
+	void ReAllocate(ptrdiff_t newSize) {
+		if (newSize < 0)
+			throw std::runtime_error("SplitVector::ReAllocate: negative size.");
+
+		if (newSize > static_cast<ptrdiff_t>(body.size())) {
 			// Move the gap to the end
 			GapTo(lengthBody);
-			T *newBody = new T[newSize];
-			if ((size != 0) && (body != 0)) {
-				memmove(newBody, body, sizeof(T) * lengthBody);
-				delete []body;
-			}
-			body = newBody;
-			gapLength += newSize - size;
-			size = newSize;
+			gapLength += newSize - static_cast<ptrdiff_t>(body.size());
+			// RoomFor implements a growth strategy but so does vector::resize so
+			// ensure vector::resize allocates exactly the amount wanted by
+			// calling reserve first.
+			body.reserve(newSize);
+			body.resize(newSize);
 		}
 	}
 
-	/// Retrieve the character at a particular position.
-	/// Retrieving positions outside the range of the buffer returns 0.
-	/// The assertions here are disabled since calling code can be 
-	/// simpler if out of range access works and returns 0.
-	T ValueAt(int position) const {
+	/// Retrieve the element at a particular position.
+	/// Retrieving positions outside the range of the buffer returns empty or 0.
+	const T& ValueAt(ptrdiff_t position) const noexcept {
 		if (position < part1Length) {
-			//PLATFORM_ASSERT(position >= 0);
 			if (position < 0) {
-				return 0;
+				return empty;
 			} else {
 				return body[position];
 			}
 		} else {
-			//PLATFORM_ASSERT(position < lengthBody);
 			if (position >= lengthBody) {
-				return 0;
+				return empty;
 			} else {
 				return body[gapLength + position];
 			}
 		}
 	}
 
-	void SetValueAt(int position, T v) {
+	/// Set the element at a particular position.
+	/// Setting positions outside the range of the buffer performs no assignment
+	/// but asserts in debug builds.
+	template <typename ParamType>
+	void SetValueAt(ptrdiff_t position, ParamType&& v) noexcept {
 		if (position < part1Length) {
 			PLATFORM_ASSERT(position >= 0);
 			if (position < 0) {
 				;
 			} else {
-				body[position] = v;
+				body[position] = std::forward<ParamType>(v);
 			}
 		} else {
 			PLATFORM_ASSERT(position < lengthBody);
 			if (position >= lengthBody) {
 				;
 			} else {
-				body[gapLength + position] = v;
+				body[gapLength + position] = std::forward<ParamType>(v);
 			}
 		}
 	}
 
-	T& operator[](int position) const {
+	/// Retrieve the element at a particular position.
+	/// The position must be within bounds or an assertion is triggered.
+	const T &operator[](ptrdiff_t position) const noexcept {
+		PLATFORM_ASSERT(position >= 0 && position < lengthBody);
+		if (position < part1Length) {
+			return body[position];
+		} else {
+			return body[gapLength + position];
+		}
+	}
+
+	/// Retrieve reference to the element at a particular position.
+	/// This, instead of the const variant, can be used to mutate in-place.
+	/// The position must be within bounds or an assertion is triggered.
+	T &operator[](ptrdiff_t position) noexcept {
 		PLATFORM_ASSERT(position >= 0 && position < lengthBody);
 		if (position < part1Length) {
 			return body[position];
@@ -145,20 +167,20 @@ class SplitVector {
 	}
 
 	/// Retrieve the length of the buffer.
-	int Length() const {
+	ptrdiff_t Length() const noexcept {
 		return lengthBody;
 	}
 
 	/// Insert a single value into the buffer.
 	/// Inserting at positions outside the current range fails.
-	void Insert(int position, T v) {
+	void Insert(ptrdiff_t position, T v) {
 		PLATFORM_ASSERT((position >= 0) && (position <= lengthBody));
 		if ((position < 0) || (position > lengthBody)) {
 			return;
 		}
 		RoomFor(1);
 		GapTo(position);
-		body[part1Length] = v;
+		body[part1Length] = std::move(v);
 		lengthBody++;
 		part1Length++;
 		gapLength--;
@@ -166,7 +188,7 @@ class SplitVector {
 
 	/// Insert a number of elements into the buffer setting their value.
 	/// Inserting at positions outside the current range fails.
-	void InsertValue(int position, int insertLength, T v) {
+	void InsertValue(ptrdiff_t position, ptrdiff_t insertLength, T v) {
 		PLATFORM_ASSERT((position >= 0) && (position <= lengthBody));
 		if (insertLength > 0) {
 			if ((position < 0) || (position > lengthBody)) {
@@ -174,24 +196,46 @@ class SplitVector {
 			}
 			RoomFor(insertLength);
 			GapTo(position);
-			for (int i = 0; i < insertLength; i++)
-				body[part1Length + i] = v;
+			std::fill(body.data() + part1Length, body.data() + part1Length + insertLength, v);
+			lengthBody += insertLength;
+			part1Length += insertLength;
+			gapLength -= insertLength;
+		}
+	}
+
+	/// Add some new empty elements.
+	/// InsertValue is good for value objects but not for unique_ptr objects
+	/// since they can only be moved from once.
+	/// Callers can write to the returned pointer to transform inputs without copies.
+	T *InsertEmpty(ptrdiff_t position, ptrdiff_t insertLength) {
+		PLATFORM_ASSERT((position >= 0) && (position <= lengthBody));
+		if (insertLength > 0) {
+			if ((position < 0) || (position > lengthBody)) {
+				return nullptr;
+			}
+			RoomFor(insertLength);
+			GapTo(position);
+			for (ptrdiff_t elem = part1Length; elem < part1Length + insertLength; elem++) {
+				T emptyOne = {};
+				body[elem] = std::move(emptyOne);
+			}
 			lengthBody += insertLength;
 			part1Length += insertLength;
 			gapLength -= insertLength;
 		}
+		return body.data() + position;
 	}
 
-	/// Ensure at least length elements allocated, 
+	/// Ensure at least length elements allocated,
 	/// appending zero valued elements if needed.
-	void EnsureLength(int wantedLength) {
+	void EnsureLength(ptrdiff_t wantedLength) {
 		if (Length() < wantedLength) {
-			InsertValue(Length(), wantedLength - Length(), 0);
+			InsertEmpty(Length(), wantedLength - Length());
 		}
 	}
-	
+
 	/// Insert text into the buffer from an array.
-	void InsertFromArray(int positionToInsert, const T s[], int positionFrom, int insertLength) {
+	void InsertFromArray(ptrdiff_t positionToInsert, const T s[], ptrdiff_t positionFrom, ptrdiff_t insertLength) {
 		PLATFORM_ASSERT((positionToInsert >= 0) && (positionToInsert <= lengthBody));
 		if (insertLength > 0) {
 			if ((positionToInsert < 0) || (positionToInsert > lengthBody)) {
@@ -199,7 +243,7 @@ class SplitVector {
 			}
 			RoomFor(insertLength);
 			GapTo(positionToInsert);
-			memmove(body + part1Length, s + positionFrom, sizeof(T) * insertLength);
+			std::copy(s + positionFrom, s + positionFrom + insertLength, body.data() + part1Length);
 			lengthBody += insertLength;
 			part1Length += insertLength;
 			gapLength -= insertLength;
@@ -207,24 +251,21 @@ class SplitVector {
 	}
 
 	/// Delete one element from the buffer.
-	void Delete(int position) {
+	void Delete(ptrdiff_t position) {
 		PLATFORM_ASSERT((position >= 0) && (position < lengthBody));
-		if ((position < 0) || (position >= lengthBody)) {
-			return;
-		}
 		DeleteRange(position, 1);
 	}
 
 	/// Delete a range from the buffer.
 	/// Deleting positions outside the current range fails.
-	void DeleteRange(int position, int deleteLength) {
+	/// Cannot be noexcept as vector::shrink_to_fit may be called and it may throw.
+	void DeleteRange(ptrdiff_t position, ptrdiff_t deleteLength) {
 		PLATFORM_ASSERT((position >= 0) && (position + deleteLength <= lengthBody));
 		if ((position < 0) || ((position + deleteLength) > lengthBody)) {
 			return;
 		}
 		if ((position == 0) && (deleteLength == lengthBody)) {
 			// Full deallocation returns storage and is faster
-			delete []body;
 			Init();
 		} else if (deleteLength > 0) {
 			GapTo(position);
@@ -238,12 +279,56 @@ class SplitVector {
 		DeleteRange(0, lengthBody);
 	}
 
-	T* BufferPointer() {
+	/// Retrieve a range of elements into an array
+	void GetRange(T *buffer, ptrdiff_t position, ptrdiff_t retrieveLength) const noexcept {
+		// Split into up to 2 ranges, before and after the split then use memcpy on each.
+		ptrdiff_t range1Length = 0;
+		if (position < part1Length) {
+			const ptrdiff_t part1AfterPosition = part1Length - position;
+			range1Length = retrieveLength;
+			if (range1Length > part1AfterPosition)
+				range1Length = part1AfterPosition;
+		}
+		std::copy(body.data() + position, body.data() + position + range1Length, buffer);
+		buffer += range1Length;
+		position = position + range1Length + gapLength;
+		const ptrdiff_t range2Length = retrieveLength - range1Length;
+		std::copy(body.data() + position, body.data() + position + range2Length, buffer);
+	}
+
+	/// Compact the buffer and return a pointer to the first element.
+	/// Also ensures there is an empty element beyond logical end in case its
+	/// passed to a function expecting a NUL terminated string.
+	T *BufferPointer() {
 		RoomFor(1);
 		GapTo(lengthBody);
-		body[lengthBody] = 0;
-		return body;
+		T emptyOne = {};
+		body[lengthBody] = std::move(emptyOne);
+		return body.data();
+	}
+
+	/// Return a pointer to a range of elements, first rearranging the buffer if
+	/// needed to make that range contiguous.
+	T *RangePointer(ptrdiff_t position, ptrdiff_t rangeLength) noexcept {
+		if (position < part1Length) {
+			if ((position + rangeLength) > part1Length) {
+				// Range overlaps gap, so move gap to start of range.
+				GapTo(position);
+				return body.data() + position + gapLength;
+			} else {
+				return body.data() + position;
+			}
+		} else {
+			return body.data() + position + gapLength;
+		}
+	}
+
+	/// Return the position of the gap within the buffer.
+	ptrdiff_t GapPosition() const noexcept {
+		return part1Length;
 	}
 };
 
+}
+
 #endif
diff --git a/Pythonwin/Scintilla/src/Style.cxx b/Pythonwin/Scintilla/src/Style.cxx
index ad081a66d..ff2b49bc2 100644
--- a/Pythonwin/Scintilla/src/Style.cxx
+++ b/Pythonwin/Scintilla/src/Style.cxx
@@ -5,34 +5,98 @@
 // Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <string.h>
+#include <stdexcept>
+#include <string_view>
+#include <vector>
+#include <memory>
 
 #include "Platform.h"
 
 #include "Scintilla.h"
 #include "Style.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-Style::Style() {
-	aliasOfDefaultFont = true;
+FontAlias::FontAlias() noexcept {
+}
+
+FontAlias::FontAlias(const FontAlias &other) noexcept : Font() {
+	SetID(other.fid);
+}
+
+FontAlias::FontAlias(FontAlias &&other) noexcept : Font() {
+	SetID(other.fid);
+	other.ClearFont();
+}
+
+FontAlias::~FontAlias() {
+	SetID(FontID{});
+	// ~Font will not release the actual font resource since it is now 0
+}
+
+void FontAlias::MakeAlias(const Font &fontOrigin) noexcept {
+	SetID(fontOrigin.GetID());
+}
+
+void FontAlias::ClearFont() noexcept {
+	SetID(FontID{});
+}
+
+bool FontSpecification::operator==(const FontSpecification &other) const noexcept {
+	return fontName == other.fontName &&
+	       weight == other.weight &&
+	       italic == other.italic &&
+	       size == other.size &&
+	       characterSet == other.characterSet &&
+	       extraFontFlag == other.extraFontFlag;
+}
+
+bool FontSpecification::operator<(const FontSpecification &other) const noexcept {
+	if (fontName != other.fontName)
+		return fontName < other.fontName;
+	if (weight != other.weight)
+		return weight < other.weight;
+	if (italic != other.italic)
+		return italic == false;
+	if (size != other.size)
+		return size < other.size;
+	if (characterSet != other.characterSet)
+		return characterSet < other.characterSet;
+	if (extraFontFlag != other.extraFontFlag)
+		return extraFontFlag < other.extraFontFlag;
+	return false;
+}
+
+FontMeasurements::FontMeasurements() noexcept {
+	ClearMeasurements();
+}
+
+void FontMeasurements::ClearMeasurements() noexcept {
+	ascent = 1;
+	descent = 1;
+	capitalHeight = 1;
+	aveCharWidth = 1;
+	spaceWidth = 1;
+	sizeZoomed = 2;
+}
+
+Style::Style() : FontSpecification() {
 	Clear(ColourDesired(0, 0, 0), ColourDesired(0xff, 0xff, 0xff),
-	      Platform::DefaultFontSize(), 0, SC_CHARSET_DEFAULT,
-	      false, false, false, false, caseMixed, true, true, false);
+	      Platform::DefaultFontSize() * SC_FONT_SIZE_MULTIPLIER, nullptr, SC_CHARSET_DEFAULT,
+	      SC_WEIGHT_NORMAL, false, false, false, caseMixed, true, true, false);
 }
 
-Style::Style(const Style &source) {
+Style::Style(const Style &source) noexcept : FontSpecification(), FontMeasurements() {
 	Clear(ColourDesired(0, 0, 0), ColourDesired(0xff, 0xff, 0xff),
-	      0, 0, 0,
-	      false, false, false, false, caseMixed, true, true, false);
-	fore.desired = source.fore.desired;
-	back.desired = source.back.desired;
+	      0, nullptr, 0,
+	      SC_WEIGHT_NORMAL, false, false, false, caseMixed, true, true, false);
+	fore = source.fore;
+	back = source.back;
 	characterSet = source.characterSet;
-	bold = source.bold;
+	weight = source.weight;
 	italic = source.italic;
 	size = source.size;
+	fontName = source.fontName;
 	eolFilled = source.eolFilled;
 	underline = source.underline;
 	caseForce = source.caseForce;
@@ -42,25 +106,21 @@ Style::Style(const Style &source) {
 }
 
 Style::~Style() {
-	if (aliasOfDefaultFont)
-		font.SetID(0);
-	else
-		font.Release();
-	aliasOfDefaultFont = false;
 }
 
-Style &Style::operator=(const Style &source) {
+Style &Style::operator=(const Style &source) noexcept {
 	if (this == &source)
 		return * this;
 	Clear(ColourDesired(0, 0, 0), ColourDesired(0xff, 0xff, 0xff),
-	      0, 0, SC_CHARSET_DEFAULT,
-	      false, false, false, false, caseMixed, true, true, false);
-	fore.desired = source.fore.desired;
-	back.desired = source.back.desired;
+	      0, nullptr, SC_CHARSET_DEFAULT,
+	      SC_WEIGHT_NORMAL, false, false, false, caseMixed, true, true, false);
+	fore = source.fore;
+	back = source.back;
 	characterSet = source.characterSet;
-	bold = source.bold;
+	weight = source.weight;
 	italic = source.italic;
 	size = source.size;
+	fontName = source.fontName;
 	eolFilled = source.eolFilled;
 	underline = source.underline;
 	caseForce = source.caseForce;
@@ -70,14 +130,14 @@ Style &Style::operator=(const Style &source) {
 }
 
 void Style::Clear(ColourDesired fore_, ColourDesired back_, int size_,
-                  const char *fontName_, int characterSet_,
-                  bool bold_, bool italic_, bool eolFilled_,
-                  bool underline_, ecaseForced caseForce_,
-		  bool visible_, bool changeable_, bool hotspot_) {
-	fore.desired = fore_;
-	back.desired = back_;
+        const char *fontName_, int characterSet_,
+        int weight_, bool italic_, bool eolFilled_,
+        bool underline_, ecaseForced caseForce_,
+        bool visible_, bool changeable_, bool hotspot_) noexcept {
+	fore = fore_;
+	back = back_;
 	characterSet = characterSet_;
-	bold = bold_;
+	weight = weight_;
 	italic = italic_;
 	size = size_;
 	fontName = fontName_;
@@ -87,72 +147,28 @@ void Style::Clear(ColourDesired fore_, ColourDesired back_, int size_,
 	visible = visible_;
 	changeable = changeable_;
 	hotspot = hotspot_;
-	if (aliasOfDefaultFont)
-		font.SetID(0);
-	else
-		font.Release();
-	aliasOfDefaultFont = false;
+	font.ClearFont();
+	FontMeasurements::ClearMeasurements();
 }
 
-void Style::ClearTo(const Style &source) {
+void Style::ClearTo(const Style &source) noexcept {
 	Clear(
-		source.fore.desired,
-		source.back.desired,
-		source.size,
-		source.fontName,
-		source.characterSet,
-		source.bold,
-		source.italic,
-		source.eolFilled,
-		source.underline,
-		source.caseForce,
-		source.visible,
-		source.changeable,
-		source.hotspot);
-}
-
-bool Style::EquivalentFontTo(const Style *other) const {
-	if (bold != other->bold ||
-	        italic != other->italic ||
-	        size != other->size ||
-	        characterSet != other->characterSet)
-		return false;
-	if (fontName == other->fontName)
-		return true;
-	if (!fontName)
-		return false;
-	if (!other->fontName)
-		return false;
-	return strcmp(fontName, other->fontName) == 0;
-}
-
-void Style::Realise(Surface &surface, int zoomLevel, Style *defaultStyle, bool extraFontFlag) {
-	sizeZoomed = size + zoomLevel;
-	if (sizeZoomed <= 2)	// Hangs if sizeZoomed <= 1
-		sizeZoomed = 2;
-
-	if (aliasOfDefaultFont)
-		font.SetID(0);
-	else
-		font.Release();
-	int deviceHeight = surface.DeviceHeightFont(sizeZoomed);
-	aliasOfDefaultFont = defaultStyle &&
-	                     (EquivalentFontTo(defaultStyle) || !fontName);
-	if (aliasOfDefaultFont) {
-		font.SetID(defaultStyle->font.GetID());
-	} else if (fontName) {
-		font.Create(fontName, characterSet, deviceHeight, bold, italic, extraFontFlag);
-	} else {
-		font.SetID(0);
-	}
-
-	ascent = surface.Ascent(font);
-	descent = surface.Descent(font);
-	// Probably more typographically correct to include leading
-	// but that means more complex drawing as leading must be erased
-	//lineHeight = surface.ExternalLeading() + surface.Height();
-	externalLeading = surface.ExternalLeading(font);
-	lineHeight = surface.Height(font);
-	aveCharWidth = surface.AverageCharWidth(font);
-	spaceWidth = surface.WidthChar(font, ' ');
+	    source.fore,
+	    source.back,
+	    source.size,
+	    source.fontName,
+	    source.characterSet,
+	    source.weight,
+	    source.italic,
+	    source.eolFilled,
+	    source.underline,
+	    source.caseForce,
+	    source.visible,
+	    source.changeable,
+	    source.hotspot);
+}
+
+void Style::Copy(const Font &font_, const FontMeasurements &fm_) noexcept {
+	font.MakeAlias(font_);
+	(FontMeasurements &)(*this) = fm_;
 }
diff --git a/Pythonwin/Scintilla/src/Style.h b/Pythonwin/Scintilla/src/Style.h
index 1caecaee7..071d752ca 100644
--- a/Pythonwin/Scintilla/src/Style.h
+++ b/Pythonwin/Scintilla/src/Style.h
@@ -8,57 +8,85 @@
 #ifndef STYLE_H
 #define STYLE_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
 
-/**
- */
-class Style {
-public:
-	ColourPair fore;
-	ColourPair back;
-	bool aliasOfDefaultFont;
-	bool bold;
+struct FontSpecification {
+	const char *fontName;
+	int weight;
 	bool italic;
 	int size;
-	const char *fontName;
 	int characterSet;
+	int extraFontFlag;
+	FontSpecification() noexcept :
+		fontName(nullptr),
+		weight(SC_WEIGHT_NORMAL),
+		italic(false),
+		size(10 * SC_FONT_SIZE_MULTIPLIER),
+		characterSet(0),
+		extraFontFlag(0) {
+	}
+	bool operator==(const FontSpecification &other) const noexcept;
+	bool operator<(const FontSpecification &other) const noexcept;
+};
+
+// Just like Font but only has a copy of the FontID so should not delete it
+class FontAlias : public Font {
+public:
+	FontAlias() noexcept;
+	// FontAlias objects can be copy or move constructed but not be assigned
+	FontAlias(const FontAlias &) noexcept;
+	FontAlias(FontAlias &&) noexcept;
+	FontAlias &operator=(const FontAlias &) = delete;
+	FontAlias &operator=(FontAlias &&) = delete;
+	~FontAlias() override;
+	void MakeAlias(const Font &fontOrigin) noexcept;
+	void ClearFont() noexcept;
+};
+
+struct FontMeasurements {
+	unsigned int ascent;
+	unsigned int descent;
+	XYPOSITION capitalHeight;	// Top of capital letter to baseline: ascent - internal leading
+	XYPOSITION aveCharWidth;
+	XYPOSITION spaceWidth;
+	int sizeZoomed;
+	FontMeasurements() noexcept;
+	void ClearMeasurements() noexcept;
+};
+
+/**
+ */
+class Style : public FontSpecification, public FontMeasurements {
+public:
+	ColourDesired fore;
+	ColourDesired back;
 	bool eolFilled;
 	bool underline;
-	enum ecaseForced {caseMixed, caseUpper, caseLower};
+	enum ecaseForced {caseMixed, caseUpper, caseLower, caseCamel};
 	ecaseForced caseForce;
 	bool visible;
 	bool changeable;
 	bool hotspot;
 
-	Font font;
-	int sizeZoomed;
-	unsigned int lineHeight;
-	unsigned int ascent;
-	unsigned int descent;
-	unsigned int externalLeading;
-	unsigned int aveCharWidth;
-	unsigned int spaceWidth;
+	FontAlias font;
 
 	Style();
-	Style(const Style &source);
+	Style(const Style &source) noexcept;
+	Style(Style &&) noexcept = default;
 	~Style();
-	Style &operator=(const Style &source);
+	Style &operator=(const Style &source) noexcept;
+	Style &operator=(Style &&) = delete;
 	void Clear(ColourDesired fore_, ColourDesired back_,
 	           int size_,
 	           const char *fontName_, int characterSet_,
-	           bool bold_, bool italic_, bool eolFilled_,
+	           int weight_, bool italic_, bool eolFilled_,
 	           bool underline_, ecaseForced caseForce_,
-		   bool visible_, bool changeable_, bool hotspot_);
-	void ClearTo(const Style &source);
-	bool EquivalentFontTo(const Style *other) const;
-	void Realise(Surface &surface, int zoomLevel, Style *defaultStyle = 0, bool extraFontFlag = false);
-	bool IsProtected() const { return !(changeable && visible);};
+	           bool visible_, bool changeable_, bool hotspot_) noexcept;
+	void ClearTo(const Style &source) noexcept;
+	void Copy(const Font &font_, const FontMeasurements &fm_) noexcept;
+	bool IsProtected() const noexcept { return !(changeable && visible);}
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/StyleContext.cxx b/Pythonwin/Scintilla/src/StyleContext.cxx
deleted file mode 100644
index 4a1f71622..000000000
--- a/Pythonwin/Scintilla/src/StyleContext.cxx
+++ /dev/null
@@ -1,55 +0,0 @@
-// Scintilla source code edit control
-/** @file StyleContext.cxx
- ** Lexer infrastructure.
- **/
-// Copyright 1998-2004 by Neil Hodgson <neilh@scintilla.org>
-// This file is in the public domain.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdio.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "StyleContext.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-static void getRange(unsigned int start,
-		unsigned int end,
-		Accessor &styler,
-		char *s,
-		unsigned int len) {
-	unsigned int i = 0;
-	while ((i < end - start + 1) && (i < len-1)) {
-		s[i] = styler[start + i];
-		i++;
-	}
-	s[i] = '\0';
-}
-
-void StyleContext::GetCurrent(char *s, unsigned int len) {
-	getRange(styler.GetStartSegment(), currentPos - 1, styler, s, len);
-}
-
-static void getRangeLowered(unsigned int start,
-		unsigned int end,
-		Accessor &styler,
-		char *s,
-		unsigned int len) {
-	unsigned int i = 0;
-	while ((i < end - start + 1) && (i < len-1)) {
-		s[i] = static_cast<char>(tolower(styler[start + i]));
-		i++;
-	}
-	s[i] = '\0';
-}
-
-void StyleContext::GetCurrentLowered(char *s, unsigned int len) {
-	getRangeLowered(styler.GetStartSegment(), currentPos - 1, styler, s, len);
-}
diff --git a/Pythonwin/Scintilla/src/StyleContext.h b/Pythonwin/Scintilla/src/StyleContext.h
deleted file mode 100644
index 463aab462..000000000
--- a/Pythonwin/Scintilla/src/StyleContext.h
+++ /dev/null
@@ -1,179 +0,0 @@
-// Scintilla source code edit control
-/** @file StyleContext.cxx
- ** Lexer infrastructure.
- **/
-// Copyright 1998-2004 by Neil Hodgson <neilh@scintilla.org>
-// This file is in the public domain.
-
-#ifdef SCI_NAMESPACE
-namespace Scintilla {
-#endif
-
-// All languages handled so far can treat all characters >= 0x80 as one class
-// which just continues the current token or starts an identifier if in default.
-// DBCS treated specially as the second character can be < 0x80 and hence
-// syntactically significant. UTF-8 avoids this as all trail bytes are >= 0x80
-class StyleContext {
-	Accessor &styler;
-	unsigned int endPos;
-	StyleContext& operator=(const StyleContext&) {
-		return *this;
-	}
-	void GetNextChar(unsigned int pos) {
-		chNext = static_cast<unsigned char>(styler.SafeGetCharAt(pos+1));
-		if (styler.IsLeadByte(static_cast<char>(chNext))) {
-			chNext = chNext << 8;
-			chNext |= static_cast<unsigned char>(styler.SafeGetCharAt(pos+2));
-		}
-		// End of line?
-		// Trigger on CR only (Mac style) or either on LF from CR+LF (Dos/Win)
-		// or on LF alone (Unix). Avoid triggering two times on Dos/Win.
-		atLineEnd = (ch == '\r' && chNext != '\n') ||
-					(ch == '\n') ||
-					(currentPos >= endPos);
-	}
-
-public:
-	unsigned int currentPos;
-	bool atLineStart;
-	bool atLineEnd;
-	int state;
-	int chPrev;
-	int ch;
-	int chNext;
-
-	StyleContext(unsigned int startPos, unsigned int length,
-                        int initStyle, Accessor &styler_, char chMask=31) :
-		styler(styler_),
-		endPos(startPos + length),
-		currentPos(startPos),
-		atLineStart(true),
-		atLineEnd(false),
-		state(initStyle & chMask), // Mask off all bits which aren't in the chMask.
-		chPrev(0),
-		ch(0),
-		chNext(0) {
-		styler.StartAt(startPos, chMask);
-		styler.StartSegment(startPos);
-		unsigned int pos = currentPos;
-		ch = static_cast<unsigned char>(styler.SafeGetCharAt(pos));
-		if (styler.IsLeadByte(static_cast<char>(ch))) {
-			pos++;
-			ch = ch << 8;
-			ch |= static_cast<unsigned char>(styler.SafeGetCharAt(pos));
-		}
-		GetNextChar(pos);
-	}
-	void Complete() {
-		styler.ColourTo(currentPos - 1, state);
-	}
-	bool More() {
-		return currentPos < endPos;
-	}
-	void Forward() {
-		if (currentPos < endPos) {
-			atLineStart = atLineEnd;
-			chPrev = ch;
-			currentPos++;
-			if (ch >= 0x100)
-				currentPos++;
-			ch = chNext;
-			GetNextChar(currentPos + ((ch >= 0x100) ? 1 : 0));
-		} else {
-			atLineStart = false;
-			chPrev = ' ';
-			ch = ' ';
-			chNext = ' ';
-			atLineEnd = true;
-		}
-	}
-	void Forward(int nb) {
-		for (int i = 0; i < nb; i++) {
-			Forward();
-		}
-	}
-	void ChangeState(int state_) {
-		state = state_;
-	}
-	void SetState(int state_) {
-		styler.ColourTo(currentPos - 1, state);
-		state = state_;
-	}
-	void ForwardSetState(int state_) {
-		Forward();
-		styler.ColourTo(currentPos - 1, state);
-		state = state_;
-	}
-	int LengthCurrent() {
-		return currentPos - styler.GetStartSegment();
-	}
-	int GetRelative(int n) {
-		return static_cast<unsigned char>(styler.SafeGetCharAt(currentPos+n));
-	}
-	bool Match(char ch0) {
-		return ch == static_cast<unsigned char>(ch0);
-	}
-	bool Match(char ch0, char ch1) {
-		return (ch == static_cast<unsigned char>(ch0)) && (chNext == static_cast<unsigned char>(ch1));
-	}
-	bool Match(const char *s) {
-		if (ch != static_cast<unsigned char>(*s))
-			return false;
-		s++;
-		if (!*s)
-			return true;
-		if (chNext != static_cast<unsigned char>(*s))
-			return false;
-		s++;
-		for (int n=2; *s; n++) {
-			if (*s != styler.SafeGetCharAt(currentPos+n))
-				return false;
-			s++;
-		}
-		return true;
-	}
-	bool MatchIgnoreCase(const char *s) {
-		if (tolower(ch) != static_cast<unsigned char>(*s))
-			return false;
-		s++;
-		if (tolower(chNext) != static_cast<unsigned char>(*s))
-			return false;
-		s++;
-		for (int n=2; *s; n++) {
-			if (static_cast<unsigned char>(*s) !=
-				tolower(static_cast<unsigned char>(styler.SafeGetCharAt(currentPos+n))))
-				return false;
-			s++;
-		}
-		return true;
-	}
-	// Non-inline
-	void GetCurrent(char *s, unsigned int len);
-	void GetCurrentLowered(char *s, unsigned int len);
-};
-
-#ifdef SCI_NAMESPACE
-}
-#endif
-
-inline bool IsASpace(unsigned int ch) {
-    return (ch == ' ') || ((ch >= 0x09) && (ch <= 0x0d));
-}
-
-inline bool IsASpaceOrTab(unsigned int ch) {
-	return (ch == ' ') || (ch == '\t');
-}
-
-inline bool IsADigit(unsigned int ch) {
-	return (ch >= '0') && (ch <= '9');
-}
-
-inline bool IsADigit(unsigned int ch, unsigned int base) {
-	if (base <= 10) {
-		return (ch >= '0') && (ch < '0' + base);
-	} else {
-		return ((ch >= '0') && (ch <= '9')) ||
-		       ((ch >= 'A') && (ch < 'A' + base - 10)) ||
-		       ((ch >= 'a') && (ch < 'a' + base - 10));
-	}
-}
diff --git a/Pythonwin/Scintilla/src/UniConversion.cxx b/Pythonwin/Scintilla/src/UniConversion.cxx
index 863eb82cd..06de6b8cf 100644
--- a/Pythonwin/Scintilla/src/UniConversion.cxx
+++ b/Pythonwin/Scintilla/src/UniConversion.cxx
@@ -1,22 +1,26 @@
 // Scintilla source code edit control
 /** @file UniConversion.cxx
- ** Functions to handle UFT-8 and UCS-2 strings.
+ ** Functions to handle UTF-8 and UTF-16 strings.
  **/
 // Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <stdlib.h>
+#include <cstdlib>
+
+#include <stdexcept>
+#include <string>
+#include <string_view>
 
 #include "UniConversion.h"
 
-enum { SURROGATE_LEAD_FIRST = 0xD800 };
-enum { SURROGATE_TRAIL_FIRST = 0xDC00 };
-enum { SURROGATE_TRAIL_LAST = 0xDFFF };
+using namespace Scintilla;
+
+namespace Scintilla {
 
-unsigned int UTF8Length(const wchar_t *uptr, unsigned int tlen) {
-	unsigned int len = 0;
-	for (unsigned int i = 0; i < tlen && uptr[i];) {
-		unsigned int uch = uptr[i];
+size_t UTF8Length(std::wstring_view wsv) noexcept {
+	size_t len = 0;
+	for (size_t i = 0; i < wsv.length() && wsv[i];) {
+		const unsigned int uch = wsv[i];
 		if (uch < 0x80) {
 			len++;
 		} else if (uch < 0x800) {
@@ -33,10 +37,22 @@ unsigned int UTF8Length(const wchar_t *uptr, unsigned int tlen) {
 	return len;
 }
 
-void UTF8FromUTF16(const wchar_t *uptr, unsigned int tlen, char *putf, unsigned int len) {
-	int k = 0;
-	for (unsigned int i = 0; i < tlen && uptr[i];) {
-		unsigned int uch = uptr[i];
+size_t UTF8PositionFromUTF16Position(std::string_view u8Text, size_t positionUTF16) noexcept {
+	size_t positionUTF8 = 0;
+	for (size_t lengthUTF16 = 0; (positionUTF8 < u8Text.length()) && (lengthUTF16 < positionUTF16);) {
+		const unsigned char uch = u8Text[positionUTF8];
+		const unsigned int byteCount = UTF8BytesOfLead[uch];
+		lengthUTF16 += UTF16LengthFromUTF8ByteCount(byteCount);
+		positionUTF8 += byteCount;
+	}
+
+	return positionUTF8;
+}
+
+void UTF8FromUTF16(std::wstring_view wsv, char *putf, size_t len) noexcept {
+	size_t k = 0;
+	for (size_t i = 0; i < wsv.length() && wsv[i];) {
+		const unsigned int uch = wsv[i];
 		if (uch < 0x80) {
 			putf[k++] = static_cast<char>(uch);
 		} else if (uch < 0x800) {
@@ -46,9 +62,9 @@ void UTF8FromUTF16(const wchar_t *uptr, unsigned int tlen, char *putf, unsigned
 			(uch <= SURROGATE_TRAIL_LAST)) {
 			// Half a surrogate pair
 			i++;
-			unsigned int xch = 0x10000 + ((uch & 0x3ff) << 10) + (uptr[i] & 0x3ff);
+			const unsigned int xch = 0x10000 + ((uch & 0x3ff) << 10) + (wsv[i] & 0x3ff);
 			putf[k++] = static_cast<char>(0xF0 | (xch >> 18));
-			putf[k++] = static_cast<char>(0x80 | (xch >> 12) & 0x3f);
+			putf[k++] = static_cast<char>(0x80 | ((xch >> 12) & 0x3f));
 			putf[k++] = static_cast<char>(0x80 | ((xch >> 6) & 0x3f));
 			putf[k++] = static_cast<char>(0x80 | (xch & 0x3f));
 		} else {
@@ -58,62 +74,333 @@ void UTF8FromUTF16(const wchar_t *uptr, unsigned int tlen, char *putf, unsigned
 		}
 		i++;
 	}
-	putf[len] = '\0';
+	if (k < len)
+		putf[k] = '\0';
 }
 
-unsigned int UTF16Length(const char *s, unsigned int len) {
-	unsigned int ulen = 0;
-	unsigned int charLen;
-	for (unsigned int i=0;i<len;) {
-		unsigned char ch = static_cast<unsigned char>(s[i]);
-		if (ch < 0x80) {
-			charLen = 1;
-		} else if (ch < 0x80 + 0x40 + 0x20) {
-			charLen = 2;
-		} else if (ch < 0x80 + 0x40 + 0x20 + 0x10) {
-			charLen = 3;
-		} else {
-			charLen = 4;
-			ulen++;
-		}
-		i += charLen;
-		ulen++;
+void UTF8FromUTF32Character(int uch, char *putf) noexcept {
+	size_t k = 0;
+	if (uch < 0x80) {
+		putf[k++] = static_cast<char>(uch);
+	} else if (uch < 0x800) {
+		putf[k++] = static_cast<char>(0xC0 | (uch >> 6));
+		putf[k++] = static_cast<char>(0x80 | (uch & 0x3f));
+	} else if (uch < 0x10000) {
+		putf[k++] = static_cast<char>(0xE0 | (uch >> 12));
+		putf[k++] = static_cast<char>(0x80 | ((uch >> 6) & 0x3f));
+		putf[k++] = static_cast<char>(0x80 | (uch & 0x3f));
+	} else {
+		putf[k++] = static_cast<char>(0xF0 | (uch >> 18));
+		putf[k++] = static_cast<char>(0x80 | ((uch >> 12) & 0x3f));
+		putf[k++] = static_cast<char>(0x80 | ((uch >> 6) & 0x3f));
+		putf[k++] = static_cast<char>(0x80 | (uch & 0x3f));
+	}
+	putf[k] = '\0';
+}
+
+size_t UTF16Length(std::string_view svu8) noexcept {
+	size_t ulen = 0;
+	for (size_t i = 0; i< svu8.length();) {
+		const unsigned char ch = svu8[i];
+		const unsigned int byteCount = UTF8BytesOfLead[ch];
+		const unsigned int utf16Len = UTF16LengthFromUTF8ByteCount(byteCount);
+		i += byteCount;
+		ulen += (i > svu8.length()) ? 1 : utf16Len;
 	}
 	return ulen;
 }
 
-unsigned int UTF16FromUTF8(const char *s, unsigned int len, wchar_t *tbuf, unsigned int tlen) {
-	unsigned int ui=0;
-	const unsigned char *us = reinterpret_cast<const unsigned char *>(s);
-	unsigned int i=0;
-	while ((i<len) && (ui<tlen)) {
-		unsigned char ch = us[i++];
-		if (ch < 0x80) {
+constexpr unsigned char TrailByteValue(unsigned char c) {
+	// The top 2 bits are 0b10 to indicate a trail byte.
+	// The lower 6 bits contain the value.
+	return c & 0b0011'1111;
+}
+
+size_t UTF16FromUTF8(std::string_view svu8, wchar_t *tbuf, size_t tlen) {
+	size_t ui = 0;
+	for (size_t i = 0; i < svu8.length();) {
+		unsigned char ch = svu8[i];
+		const unsigned int byteCount = UTF8BytesOfLead[ch];
+		unsigned int value;
+
+		if (i + byteCount > svu8.length()) {
+			// Trying to read past end but still have space to write
+			if (ui < tlen) {
+				tbuf[ui] = ch;
+				ui++;
+			}
+			break;
+		}
+
+		const size_t outLen = UTF16LengthFromUTF8ByteCount(byteCount);
+		if (ui + outLen > tlen) {
+			throw std::runtime_error("UTF16FromUTF8: attempted write beyond end");
+		}
+
+		i++;
+		switch (byteCount) {
+		case 1:
 			tbuf[ui] = ch;
-		} else if (ch < 0x80 + 0x40 + 0x20) {
-			tbuf[ui] = static_cast<wchar_t>((ch & 0x1F) << 6);
-			ch = us[i++];
-			tbuf[ui] = static_cast<wchar_t>(tbuf[ui] + (ch & 0x7F));
-		} else if (ch < 0x80 + 0x40 + 0x20 + 0x10) {
-			tbuf[ui] = static_cast<wchar_t>((ch & 0xF) << 12);
-			ch = us[i++];
-			tbuf[ui] = static_cast<wchar_t>(tbuf[ui] + ((ch & 0x7F) << 6));
-			ch = us[i++];
-			tbuf[ui] = static_cast<wchar_t>(tbuf[ui] + (ch & 0x7F));
-		} else {
+			break;
+		case 2:
+			value = (ch & 0x1F) << 6;
+			ch = svu8[i++];
+			value += TrailByteValue(ch);
+			tbuf[ui] = static_cast<wchar_t>(value);
+			break;
+		case 3:
+			value = (ch & 0xF) << 12;
+			ch = svu8[i++];
+			value += (TrailByteValue(ch) << 6);
+			ch = svu8[i++];
+			value += TrailByteValue(ch);
+			tbuf[ui] = static_cast<wchar_t>(value);
+			break;
+		default:
 			// Outside the BMP so need two surrogates
-			int val = (ch & 0x7) << 18;
-			ch = us[i++];
-			val += (ch & 0x3F) << 12;
-			ch = us[i++];
-			val += (ch & 0x3F) << 6;
-			ch = us[i++];
-			val += (ch & 0x3F);
-			tbuf[ui] = static_cast<wchar_t>(((val - 0x10000) >> 10) + SURROGATE_LEAD_FIRST);
+			value = (ch & 0x7) << 18;
+			ch = svu8[i++];
+			value += TrailByteValue(ch) << 12;
+			ch = svu8[i++];
+			value += TrailByteValue(ch) << 6;
+			ch = svu8[i++];
+			value += TrailByteValue(ch);
+			tbuf[ui] = static_cast<wchar_t>(((value - 0x10000) >> 10) + SURROGATE_LEAD_FIRST);
 			ui++;
-			tbuf[ui] = static_cast<wchar_t>((val & 0x3ff) + SURROGATE_TRAIL_FIRST);
+			tbuf[ui] = static_cast<wchar_t>((value & 0x3ff) + SURROGATE_TRAIL_FIRST);
+			break;
 		}
 		ui++;
 	}
 	return ui;
 }
+
+size_t UTF32Length(std::string_view svu8) noexcept {
+	size_t ulen = 0;
+	for (size_t i = 0; i < svu8.length();) {
+		const unsigned char ch = svu8[i];
+		const unsigned int byteCount = UTF8BytesOfLead[ch];
+		i += byteCount;
+		ulen++;
+	}
+	return ulen;
+}
+
+size_t UTF32FromUTF8(std::string_view svu8, unsigned int *tbuf, size_t tlen) {
+	size_t ui = 0;
+	for (size_t i = 0; i < svu8.length();) {
+		unsigned char ch = svu8[i];
+		const unsigned int byteCount = UTF8BytesOfLead[ch];
+		unsigned int value;
+
+		if (i + byteCount > svu8.length()) {
+			// Trying to read past end but still have space to write
+			if (ui < tlen) {
+				tbuf[ui] = ch;
+				ui++;
+			}
+			break;
+		}
+
+		if (ui == tlen) {
+			throw std::runtime_error("UTF32FromUTF8: attempted write beyond end");
+		}
+
+		i++;
+		switch (byteCount) {
+		case 1:
+			value = ch;
+			break;
+		case 2:
+			value = (ch & 0x1F) << 6;
+			ch = svu8[i++];
+			value += TrailByteValue(ch);
+			break;
+		case 3:
+			value = (ch & 0xF) << 12;
+			ch = svu8[i++];
+			value += TrailByteValue(ch) << 6;
+			ch = svu8[i++];
+			value += TrailByteValue(ch);
+			break;
+		default:
+			value = (ch & 0x7) << 18;
+			ch = svu8[i++];
+			value += TrailByteValue(ch) << 12;
+			ch = svu8[i++];
+			value += TrailByteValue(ch) << 6;
+			ch = svu8[i++];
+			value += TrailByteValue(ch);
+			break;
+		}
+		tbuf[ui] = value;
+		ui++;
+	}
+	return ui;
+}
+
+std::wstring WStringFromUTF8(std::string_view svu8) {
+	if constexpr (sizeof(wchar_t) == 2) {
+		const size_t len16 = UTF16Length(svu8);
+		std::wstring ws(len16, 0);
+		UTF16FromUTF8(svu8, &ws[0], len16);
+		return ws;
+	} else {
+		const size_t len32 = UTF32Length(svu8);
+		std::wstring ws(len32, 0);
+		UTF32FromUTF8(svu8, reinterpret_cast<unsigned int *>(&ws[0]), len32);
+		return ws;
+	}
+}
+
+unsigned int UTF16FromUTF32Character(unsigned int val, wchar_t *tbuf) noexcept {
+	if (val < SUPPLEMENTAL_PLANE_FIRST) {
+		tbuf[0] = static_cast<wchar_t>(val);
+		return 1;
+	} else {
+		tbuf[0] = static_cast<wchar_t>(((val - SUPPLEMENTAL_PLANE_FIRST) >> 10) + SURROGATE_LEAD_FIRST);
+		tbuf[1] = static_cast<wchar_t>((val & 0x3ff) + SURROGATE_TRAIL_FIRST);
+		return 2;
+	}
+}
+
+const unsigned char UTF8BytesOfLead[256] = {
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 00 - 0F
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 10 - 1F
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 20 - 2F
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 30 - 3F
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 40 - 4F
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 50 - 5F
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 60 - 6F
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 70 - 7F
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 80 - 8F
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 90 - 9F
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // A0 - AF
+1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // B0 - BF
+1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0 - CF
+2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // D0 - DF
+3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // E0 - EF
+4, 4, 4, 4, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // F0 - FF
+};
+
+// Return both the width of the first character in the string and a status
+// saying whether it is valid or invalid.
+// Most invalid sequences return a width of 1 so are treated as isolated bytes but
+// the non-characters *FFFE, *FFFF and FDD0 .. FDEF return 3 or 4 as they can be
+// reasonably treated as code points in some circumstances. They will, however,
+// not have associated glyphs.
+int UTF8Classify(const unsigned char *us, size_t len) noexcept {
+	// For the rules: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
+	if (us[0] < 0x80) {
+		// ASCII
+		return 1;
+	}
+
+	const size_t byteCount = UTF8BytesOfLead[us[0]];
+	if (byteCount == 1 || byteCount > len) {
+		// Invalid lead byte
+		return UTF8MaskInvalid | 1;
+	}
+
+	if (!UTF8IsTrailByte(us[1])) {
+		// Invalid trail byte
+		return UTF8MaskInvalid | 1;
+	}
+
+	switch (byteCount) {
+	case 2:
+		return 2;
+
+	case 3:
+		if (UTF8IsTrailByte(us[2])) {
+			if ((*us == 0xe0) && ((us[1] & 0xe0) == 0x80)) {
+				// Overlong
+				return UTF8MaskInvalid | 1;
+			}
+			if ((*us == 0xed) && ((us[1] & 0xe0) == 0xa0)) {
+				// Surrogate
+				return UTF8MaskInvalid | 1;
+			}
+			if ((*us == 0xef) && (us[1] == 0xbf) && (us[2] == 0xbe)) {
+				// U+FFFE non-character - 3 bytes long
+				return UTF8MaskInvalid | 3;
+			}
+			if ((*us == 0xef) && (us[1] == 0xbf) && (us[2] == 0xbf)) {
+				// U+FFFF non-character - 3 bytes long
+				return UTF8MaskInvalid | 3;
+			}
+			if ((*us == 0xef) && (us[1] == 0xb7) && (((us[2] & 0xf0) == 0x90) || ((us[2] & 0xf0) == 0xa0))) {
+				// U+FDD0 .. U+FDEF
+				return UTF8MaskInvalid | 3;
+			}
+			return 3;
+		}
+		break;
+
+	default:
+		if (UTF8IsTrailByte(us[2]) && UTF8IsTrailByte(us[3])) {
+			if (((us[1] & 0xf) == 0xf) && (us[2] == 0xbf) && ((us[3] == 0xbe) || (us[3] == 0xbf))) {
+				// *FFFE or *FFFF non-character
+				return UTF8MaskInvalid | 4;
+			}
+			if (*us == 0xf4) {
+				// Check if encoding a value beyond the last Unicode character 10FFFF
+				if (us[1] > 0x8f) {
+					return UTF8MaskInvalid | 1;
+				}
+			} else if ((*us == 0xf0) && ((us[1] & 0xf0) == 0x80)) {
+				// Overlong
+				return UTF8MaskInvalid | 1;
+			}
+			return 4;
+		}
+		break;
+	}
+
+	return UTF8MaskInvalid | 1;
+}
+
+int UTF8DrawBytes(const unsigned char *us, int len) noexcept {
+	const int utf8StatusNext = UTF8Classify(us, len);
+	return (utf8StatusNext & UTF8MaskInvalid) ? 1 : (utf8StatusNext & UTF8MaskWidth);
+}
+
+bool UTF8IsValid(std::string_view svu8) noexcept {
+	const unsigned char *us = reinterpret_cast<const unsigned char *>(svu8.data());
+	size_t remaining = svu8.length();
+	while (remaining > 0) {
+		const int utf8Status = UTF8Classify(us, remaining);
+		if (utf8Status & UTF8MaskInvalid) {
+			return false;
+		} else {
+			const int lenChar = utf8Status & UTF8MaskWidth;
+			us += lenChar;
+			remaining -= lenChar;
+		}
+	}
+	return remaining == 0;
+}
+
+// Replace invalid bytes in UTF-8 with the replacement character
+std::string FixInvalidUTF8(const std::string &text) {
+	std::string result;
+	const char *s = text.c_str();
+	size_t remaining = text.size();
+	while (remaining > 0) {
+		const int utf8Status = UTF8Classify(reinterpret_cast<const unsigned char *>(s), remaining);
+		if (utf8Status & UTF8MaskInvalid) {
+			// Replacement character 0xFFFD = UTF8:"efbfbd".
+			result.append("\xef\xbf\xbd");
+			s++;
+			remaining--;
+		} else {
+			const size_t len = utf8Status & UTF8MaskWidth;
+			result.append(s, len);
+			s += len;
+			remaining -= len;
+		}
+	}
+	return result;
+}
+
+}
diff --git a/Pythonwin/Scintilla/src/UniConversion.h b/Pythonwin/Scintilla/src/UniConversion.h
index fd420a688..4568e2dea 100644
--- a/Pythonwin/Scintilla/src/UniConversion.h
+++ b/Pythonwin/Scintilla/src/UniConversion.h
@@ -1,12 +1,101 @@
 // Scintilla source code edit control
 /** @file UniConversion.h
- ** Functions to handle UFT-8 and UCS-2 strings.
+ ** Functions to handle UTF-8 and UTF-16 strings.
  **/
 // Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-unsigned int UTF8Length(const wchar_t *uptr, unsigned int tlen);
-void UTF8FromUTF16(const wchar_t *uptr, unsigned int tlen, char *putf, unsigned int len);
-unsigned int UTF16Length(const char *s, unsigned int len);
-unsigned int UTF16FromUTF8(const char *s, unsigned int len, wchar_t *tbuf, unsigned int tlen);
+#ifndef UNICONVERSION_H
+#define UNICONVERSION_H
 
+namespace Scintilla {
+
+constexpr int UTF8MaxBytes = 4;
+
+constexpr int unicodeReplacementChar = 0xFFFD;
+
+size_t UTF8Length(std::wstring_view wsv) noexcept;
+size_t UTF8PositionFromUTF16Position(std::string_view u8Text, size_t positionUTF16) noexcept;
+void UTF8FromUTF16(std::wstring_view wsv, char *putf, size_t len) noexcept;
+void UTF8FromUTF32Character(int uch, char *putf) noexcept;
+size_t UTF16Length(std::string_view svu8) noexcept;
+size_t UTF16FromUTF8(std::string_view svu8, wchar_t *tbuf, size_t tlen);
+size_t UTF32Length(std::string_view svu8) noexcept;
+size_t UTF32FromUTF8(std::string_view svu8, unsigned int *tbuf, size_t tlen);
+// WStringFromUTF8 does the right thing when wchar_t is 2 or 4 bytes so
+// works on both Windows and Unix.
+std::wstring WStringFromUTF8(std::string_view svu8);
+unsigned int UTF16FromUTF32Character(unsigned int val, wchar_t *tbuf) noexcept;
+bool UTF8IsValid(std::string_view svu8) noexcept;
+std::string FixInvalidUTF8(const std::string &text);
+
+extern const unsigned char UTF8BytesOfLead[256];
+
+inline int UnicodeFromUTF8(const unsigned char *us) noexcept {
+	switch (UTF8BytesOfLead[us[0]]) {
+	case 1:
+		return us[0];
+	case 2:
+		return ((us[0] & 0x1F) << 6) + (us[1] & 0x3F);
+	case 3:
+		return ((us[0] & 0xF) << 12) + ((us[1] & 0x3F) << 6) + (us[2] & 0x3F);
+	default:
+		return ((us[0] & 0x7) << 18) + ((us[1] & 0x3F) << 12) + ((us[2] & 0x3F) << 6) + (us[3] & 0x3F);
+	}
+}
+
+inline constexpr bool UTF8IsTrailByte(unsigned char ch) noexcept {
+	return (ch >= 0x80) && (ch < 0xc0);
+}
+
+inline constexpr bool UTF8IsAscii(int ch) noexcept {
+	return ch < 0x80;
+}
+
+enum { UTF8MaskWidth=0x7, UTF8MaskInvalid=0x8 };
+int UTF8Classify(const unsigned char *us, size_t len) noexcept;
+inline int UTF8Classify(std::string_view sv) noexcept {
+	return UTF8Classify(reinterpret_cast<const unsigned char *>(sv.data()), sv.length());
+}
+
+// Similar to UTF8Classify but returns a length of 1 for invalid bytes
+// instead of setting the invalid flag
+int UTF8DrawBytes(const unsigned char *us, int len) noexcept;
+
+// Line separator is U+2028 \xe2\x80\xa8
+// Paragraph separator is U+2029 \xe2\x80\xa9
+constexpr int UTF8SeparatorLength = 3;
+inline bool UTF8IsSeparator(const unsigned char *us) noexcept {
+	return (us[0] == 0xe2) && (us[1] == 0x80) && ((us[2] == 0xa8) || (us[2] == 0xa9));
+}
+
+// NEL is U+0085 \xc2\x85
+constexpr int UTF8NELLength = 2;
+inline bool UTF8IsNEL(const unsigned char *us) noexcept {
+	return (us[0] == 0xc2) && (us[1] == 0x85);
+}
+
+// Is the sequence of 3 char a UTF-8 line end? Only the last two char are tested for a NEL. 
+constexpr bool UTF8IsMultibyteLineEnd(unsigned char ch0, unsigned char ch1, unsigned char ch2) noexcept {
+	return
+		((ch0 == 0xe2) && (ch1 == 0x80) && ((ch2 == 0xa8) || (ch2 == 0xa9))) ||
+		((ch1 == 0xc2) && (ch2 == 0x85));
+}
+
+enum { SURROGATE_LEAD_FIRST = 0xD800 };
+enum { SURROGATE_LEAD_LAST = 0xDBFF };
+enum { SURROGATE_TRAIL_FIRST = 0xDC00 };
+enum { SURROGATE_TRAIL_LAST = 0xDFFF };
+enum { SUPPLEMENTAL_PLANE_FIRST = 0x10000 };
+
+inline constexpr unsigned int UTF16CharLength(wchar_t uch) noexcept {
+	return ((uch >= SURROGATE_LEAD_FIRST) && (uch <= SURROGATE_LEAD_LAST)) ? 2 : 1;
+}
+
+inline constexpr unsigned int UTF16LengthFromUTF8ByteCount(unsigned int byteCount) noexcept {
+	return (byteCount < 4) ? 1 : 2;
+}
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/UniqueString.cxx b/Pythonwin/Scintilla/src/UniqueString.cxx
new file mode 100644
index 000000000..322599672
--- /dev/null
+++ b/Pythonwin/Scintilla/src/UniqueString.cxx
@@ -0,0 +1,56 @@
+// Scintilla source code edit control
+/** @file UniqueString.cxx
+ ** Define an allocator for UniqueString.
+ **/
+// Copyright 2017 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <string_view>
+#include <vector>
+#include <algorithm>
+#include <memory>
+
+#include "UniqueString.h"
+
+namespace Scintilla {
+
+/// Equivalent to strdup but produces a std::unique_ptr<const char[]> allocation to go
+/// into collections.
+UniqueString UniqueStringCopy(const char *text) {
+	if (!text) {
+		return UniqueString();
+	}
+	const std::string_view sv(text);
+	std::unique_ptr<char[]> upcNew = std::make_unique<char[]>(sv.length() + 1);
+	sv.copy(upcNew.get(), sv.length());
+	return UniqueString(upcNew.release());
+}
+
+// A set of strings that always returns the same pointer for each string.
+
+UniqueStringSet::UniqueStringSet() noexcept = default;
+
+UniqueStringSet::~UniqueStringSet() {
+	strings.clear();
+}
+
+void UniqueStringSet::Clear() noexcept {
+	strings.clear();
+}
+
+const char *UniqueStringSet::Save(const char *text) {
+	if (!text)
+		return nullptr;
+
+	const std::string_view sv(text);
+	for (const UniqueString &us : strings) {
+		if (sv == us.get()) {
+			return us.get();
+		}
+	}
+
+	strings.push_back(UniqueStringCopy(text));
+	return strings.back().get();
+}
+
+}
diff --git a/Pythonwin/Scintilla/src/UniqueString.h b/Pythonwin/Scintilla/src/UniqueString.h
new file mode 100644
index 000000000..f7f7ebbdc
--- /dev/null
+++ b/Pythonwin/Scintilla/src/UniqueString.h
@@ -0,0 +1,46 @@
+// Scintilla source code edit control
+/** @file UniqueString.h
+ ** Define UniqueString, a unique_ptr based string type for storage in containers
+ ** and an allocator for UniqueString.
+ ** Define UniqueStringSet which holds a set of strings, used to avoid holding many copies
+ ** of font names.
+ **/
+// Copyright 2017 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef UNIQUESTRING_H
+#define UNIQUESTRING_H
+
+namespace Scintilla {
+
+constexpr bool IsNullOrEmpty(const char *text) noexcept {
+	return text == nullptr || *text == '\0';
+}
+
+using UniqueString = std::unique_ptr<const char[]>;
+
+/// Equivalent to strdup but produces a std::unique_ptr<const char[]> allocation to go
+/// into collections.
+UniqueString UniqueStringCopy(const char *text);
+
+// A set of strings that always returns the same pointer for each string.
+
+class UniqueStringSet {
+private:
+	std::vector<UniqueString> strings;
+public:
+	UniqueStringSet() noexcept;
+	// UniqueStringSet objects can not be copied.
+	UniqueStringSet(const UniqueStringSet &) = delete;
+	UniqueStringSet &operator=(const UniqueStringSet &) = delete;
+	// UniqueStringSet objects can be moved.
+	UniqueStringSet(UniqueStringSet &&) = default;
+	UniqueStringSet &operator=(UniqueStringSet &&) = default;
+	~UniqueStringSet();
+	void Clear() noexcept;
+	const char *Save(const char *text);
+};
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/src/ViewStyle.cxx b/Pythonwin/Scintilla/src/ViewStyle.cxx
index 15efea8cc..f34eb13e8 100644
--- a/Pythonwin/Scintilla/src/ViewStyle.cxx
+++ b/Pythonwin/Scintilla/src/ViewStyle.cxx
@@ -5,355 +5,624 @@
 // Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <string.h>
+#include <cstddef>
+#include <cassert>
+#include <cstring>
+
+#include <stdexcept>
+#include <string_view>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <memory>
 
 #include "Platform.h"
 
 #include "Scintilla.h"
-#include "SplitVector.h"
-#include "Partitioning.h"
-#include "RunStyles.h"
+#include "Position.h"
+#include "UniqueString.h"
 #include "Indicator.h"
 #include "XPM.h"
 #include "LineMarker.h"
 #include "Style.h"
 #include "ViewStyle.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-MarginStyle::MarginStyle() :
-	style(SC_MARGIN_SYMBOL), width(0), mask(0), sensitive(false) {
+MarginStyle::MarginStyle(int style_, int width_, int mask_) noexcept :
+	style(style_), width(width_), mask(mask_), sensitive(false), cursor(SC_CURSORREVERSEARROW) {
 }
 
-// A list of the fontnames - avoids wasting space in each style
-FontNames::FontNames() {
-	size = 8;
-	names = new char *[size];
-	max = 0;
-}
+FontRealised::FontRealised() noexcept = default;
 
-FontNames::~FontNames() {
-	Clear();
-	delete []names;
-	names = 0;
-}
-
-void FontNames::Clear() {
-	for (int i=0;i<max;i++) {
-		delete []names[i];
-	}
-	max = 0;
+FontRealised::~FontRealised() {
+	font.Release();
 }
 
-const char *FontNames::Save(const char *name) {
-	if (!name)
-		return 0;
-	for (int i=0;i<max;i++) {
-		if (strcmp(names[i], name) == 0) {
-			return names[i];
-		}
-	}
-	if (max >= size) {
-		// Grow array
-		int sizeNew = size * 2;
-		char **namesNew = new char *[sizeNew];
-		for (int j=0;j<max;j++) {
-			namesNew[j] = names[j];
-		}
-		delete []names;
-		names = namesNew;
-		size = sizeNew;
-	}
-	names[max] = new char[strlen(name) + 1];
-	strcpy(names[max], name);
-	max++;
-	return names[max-1];
+void FontRealised::Realise(Surface &surface, int zoomLevel, int technology, const FontSpecification &fs) {
+	PLATFORM_ASSERT(fs.fontName);
+	sizeZoomed = fs.size + zoomLevel * SC_FONT_SIZE_MULTIPLIER;
+	if (sizeZoomed <= 2 * SC_FONT_SIZE_MULTIPLIER)	// Hangs if sizeZoomed <= 1
+		sizeZoomed = 2 * SC_FONT_SIZE_MULTIPLIER;
+
+	const float deviceHeight = static_cast<float>(surface.DeviceHeightFont(sizeZoomed));
+	const FontParameters fp(fs.fontName, deviceHeight / SC_FONT_SIZE_MULTIPLIER, fs.weight, fs.italic, fs.extraFontFlag, technology, fs.characterSet);
+	font.Create(fp);
+
+	ascent = static_cast<unsigned int>(surface.Ascent(font));
+	descent = static_cast<unsigned int>(surface.Descent(font));
+	capitalHeight = surface.Ascent(font) - surface.InternalLeading(font);
+	aveCharWidth = surface.AverageCharWidth(font);
+	spaceWidth = surface.WidthText(font, " ");
 }
 
-ViewStyle::ViewStyle() {
+ViewStyle::ViewStyle() : markers(MARKER_MAX + 1), indicators(INDICATOR_MAX + 1) {
 	Init();
 }
 
-ViewStyle::ViewStyle(const ViewStyle &source) {
-	Init(source.stylesSize);
-	for (unsigned int sty=0;sty<source.stylesSize;sty++) {
-		styles[sty] = source.styles[sty];
-		// Can't just copy fontname as its lifetime is relative to its owning ViewStyle
+// Copy constructor only called when printing copies the screen ViewStyle so it can be
+// modified for printing styles.
+ViewStyle::ViewStyle(const ViewStyle &source) : markers(MARKER_MAX + 1), indicators(INDICATOR_MAX + 1) {
+	Init(source.styles.size());
+	styles = source.styles;
+	for (size_t sty=0; sty<source.styles.size(); sty++) {
+		// Can't just copy fontName as its lifetime is relative to its owning ViewStyle
 		styles[sty].fontName = fontNames.Save(source.styles[sty].fontName);
 	}
-	for (int mrk=0;mrk<=MARKER_MAX;mrk++) {
-		markers[mrk] = source.markers[mrk];
-	}
-	for (int ind=0;ind<=INDIC_MAX;ind++) {
-		indicators[ind] = source.indicators[ind];
-	}
+	nextExtendedStyle = source.nextExtendedStyle;
+	markers = source.markers;
+	CalcLargestMarkerHeight();
+
+	indicators = source.indicators;
+
+	indicatorsDynamic = source.indicatorsDynamic;
+	indicatorsSetFore = source.indicatorsSetFore;
 
-	selforeset = source.selforeset;
-	selforeground.desired = source.selforeground.desired;
-	selbackset = source.selbackset;
-	selbackground.desired = source.selbackground.desired;
-	selbackground2.desired = source.selbackground2.desired;
+	selColours = source.selColours;
+	selAdditionalForeground = source.selAdditionalForeground;
+	selAdditionalBackground = source.selAdditionalBackground;
+	selBackground2 = source.selBackground2;
 	selAlpha = source.selAlpha;
+	selAdditionalAlpha = source.selAdditionalAlpha;
 	selEOLFilled = source.selEOLFilled;
 
-	foldmarginColourSet = source.foldmarginColourSet;
-	foldmarginColour.desired = source.foldmarginColour.desired;
-	foldmarginHighlightColourSet = source.foldmarginHighlightColourSet;
-	foldmarginHighlightColour.desired = source.foldmarginHighlightColour.desired;
+	foldmarginColour = source.foldmarginColour;
+	foldmarginHighlightColour = source.foldmarginHighlightColour;
 
-	hotspotForegroundSet = source.hotspotForegroundSet;
-	hotspotForeground.desired = source.hotspotForeground.desired;
-	hotspotBackgroundSet = source.hotspotBackgroundSet;
-	hotspotBackground.desired = source.hotspotBackground.desired;
+	hotspotColours = source.hotspotColours;
 	hotspotUnderline = source.hotspotUnderline;
 	hotspotSingleLine = source.hotspotSingleLine;
 
-	whitespaceForegroundSet = source.whitespaceForegroundSet;
-	whitespaceForeground.desired = source.whitespaceForeground.desired;
-	whitespaceBackgroundSet = source.whitespaceBackgroundSet;
-	whitespaceBackground.desired = source.whitespaceBackground.desired;
-	selbar.desired = source.selbar.desired;
-	selbarlight.desired = source.selbarlight.desired;
-	caretcolour.desired = source.caretcolour.desired;
+	whitespaceColours = source.whitespaceColours;
+	controlCharSymbol = source.controlCharSymbol;
+	controlCharWidth = source.controlCharWidth;
+	selbar = source.selbar;
+	selbarlight = source.selbarlight;
+	caretcolour = source.caretcolour;
+	additionalCaretColour = source.additionalCaretColour;
+	caretLineFrame = source.caretLineFrame;
 	showCaretLineBackground = source.showCaretLineBackground;
-	caretLineBackground.desired = source.caretLineBackground.desired;
+	alwaysShowCaretLineBackground = source.alwaysShowCaretLineBackground;
+	caretLineBackground = source.caretLineBackground;
 	caretLineAlpha = source.caretLineAlpha;
-	edgecolour.desired = source.edgecolour.desired;
-	edgeState = source.edgeState;
 	caretStyle = source.caretStyle;
 	caretWidth = source.caretWidth;
 	someStylesProtected = false;
+	someStylesForceCase = false;
 	leftMarginWidth = source.leftMarginWidth;
 	rightMarginWidth = source.rightMarginWidth;
-	for (int i=0;i < margins; i++) {
-		ms[i] = source.ms[i];
-	}
-	symbolMargin = source.symbolMargin;
+	ms = source.ms;
 	maskInLine = source.maskInLine;
+	maskDrawInText = source.maskDrawInText;
 	fixedColumnWidth = source.fixedColumnWidth;
+	marginInside = source.marginInside;
+	textStart = source.textStart;
 	zoomLevel = source.zoomLevel;
 	viewWhitespace = source.viewWhitespace;
+	tabDrawMode = source.tabDrawMode;
+	whitespaceSize = source.whitespaceSize;
 	viewIndentationGuides = source.viewIndentationGuides;
 	viewEOL = source.viewEOL;
-	showMarkedLines = source.showMarkedLines;
 	extraFontFlag = source.extraFontFlag;
+	extraAscent = source.extraAscent;
+	extraDescent = source.extraDescent;
+	marginStyleOffset = source.marginStyleOffset;
+	annotationVisible = source.annotationVisible;
+	annotationStyleOffset = source.annotationStyleOffset;
+	eolAnnotationVisible = source.eolAnnotationVisible;
+	eolAnnotationStyleOffset = source.eolAnnotationStyleOffset;
+	braceHighlightIndicatorSet = source.braceHighlightIndicatorSet;
+	braceHighlightIndicator = source.braceHighlightIndicator;
+	braceBadLightIndicatorSet = source.braceBadLightIndicatorSet;
+	braceBadLightIndicator = source.braceBadLightIndicator;
+
+	edgeState = source.edgeState;
+	theEdge = source.theEdge;
+	theMultiEdge = source.theMultiEdge;
+
+	marginNumberPadding = source.marginNumberPadding;
+	ctrlCharPadding = source.ctrlCharPadding;
+	lastSegItalicsOffset = source.lastSegItalicsOffset;
+
+	wrapState = source.wrapState;
+	wrapVisualFlags = source.wrapVisualFlags;
+	wrapVisualFlagsLocation = source.wrapVisualFlagsLocation;
+	wrapVisualStartIndent = source.wrapVisualStartIndent;
+	wrapIndentMode = source.wrapIndentMode;
 }
 
 ViewStyle::~ViewStyle() {
-	delete []styles;
-	styles = NULL;
+	styles.clear();
+	fonts.clear();
+}
+
+void ViewStyle::CalculateMarginWidthAndMask() noexcept {
+	fixedColumnWidth = marginInside ? leftMarginWidth : 0;
+	maskInLine = 0xffffffff;
+	int maskDefinedMarkers = 0;
+	for (const MarginStyle &m : ms) {
+		fixedColumnWidth += m.width;
+		if (m.width > 0)
+			maskInLine &= ~m.mask;
+		maskDefinedMarkers |= m.mask;
+	}
+	maskDrawInText = 0;
+	for (int markBit = 0; markBit < 32; markBit++) {
+		const int maskBit = 1U << markBit;
+		switch (markers[markBit].markType) {
+		case SC_MARK_EMPTY:
+			maskInLine &= ~maskBit;
+			break;
+		case SC_MARK_BACKGROUND:
+		case SC_MARK_UNDERLINE:
+			maskInLine &= ~maskBit;
+			maskDrawInText |= maskDefinedMarkers & maskBit;
+			break;
+		}
+	}
 }
 
 void ViewStyle::Init(size_t stylesSize_) {
-	stylesSize = 0;
-	styles = NULL;
 	AllocStyles(stylesSize_);
+	nextExtendedStyle = 256;
 	fontNames.Clear();
 	ResetDefaultStyle();
 
-	indicators[0].style = INDIC_SQUIGGLE;
-	indicators[0].under = false;
-	indicators[0].fore = ColourDesired(0, 0x7f, 0);
-	indicators[1].style = INDIC_TT;
-	indicators[1].under = false;
-	indicators[1].fore = ColourDesired(0, 0, 0xff);
-	indicators[2].style = INDIC_PLAIN;
-	indicators[2].under = false;
-	indicators[2].fore = ColourDesired(0xff, 0, 0);
+	// There are no image markers by default, so no need for calling CalcLargestMarkerHeight()
+	largestMarkerHeight = 0;
 
+	indicators[0] = Indicator(INDIC_SQUIGGLE, ColourDesired(0, 0x7f, 0));
+	indicators[1] = Indicator(INDIC_TT, ColourDesired(0, 0, 0xff));
+	indicators[2] = Indicator(INDIC_PLAIN, ColourDesired(0xff, 0, 0));
+
+	technology = SC_TECHNOLOGY_DEFAULT;
+	indicatorsDynamic = false;
+	indicatorsSetFore = false;
 	lineHeight = 1;
+	lineOverlap = 0;
 	maxAscent = 1;
 	maxDescent = 1;
 	aveCharWidth = 8;
 	spaceWidth = 8;
+	tabWidth = spaceWidth * 8;
 
-	selforeset = false;
-	selforeground.desired = ColourDesired(0xff, 0, 0);
-	selbackset = true;
-	selbackground.desired = ColourDesired(0xc0, 0xc0, 0xc0);
-	selbackground2.desired = ColourDesired(0xb0, 0xb0, 0xb0);
+	selColours.fore = ColourOptional(ColourDesired(0xff, 0, 0));
+	selColours.back = ColourOptional(ColourDesired(0xc0, 0xc0, 0xc0), true);
+	selAdditionalForeground = ColourDesired(0xff, 0, 0);
+	selAdditionalBackground = ColourDesired(0xd7, 0xd7, 0xd7);
+	selBackground2 = ColourDesired(0xb0, 0xb0, 0xb0);
 	selAlpha = SC_ALPHA_NOALPHA;
+	selAdditionalAlpha = SC_ALPHA_NOALPHA;
 	selEOLFilled = false;
 
-	foldmarginColourSet = false;
-	foldmarginColour.desired = ColourDesired(0xff, 0, 0);
-	foldmarginHighlightColourSet = false;
-	foldmarginHighlightColour.desired = ColourDesired(0xc0, 0xc0, 0xc0);
-
-	whitespaceForegroundSet = false;
-	whitespaceForeground.desired = ColourDesired(0, 0, 0);
-	whitespaceBackgroundSet = false;
-	whitespaceBackground.desired = ColourDesired(0xff, 0xff, 0xff);
-	selbar.desired = Platform::Chrome();
-	selbarlight.desired = Platform::ChromeHighlight();
-	styles[STYLE_LINENUMBER].fore.desired = ColourDesired(0, 0, 0);
-	styles[STYLE_LINENUMBER].back.desired = Platform::Chrome();
-	caretcolour.desired = ColourDesired(0, 0, 0);
+	foldmarginColour = ColourOptional(ColourDesired(0xff, 0, 0));
+	foldmarginHighlightColour = ColourOptional(ColourDesired(0xc0, 0xc0, 0xc0));
+
+	whitespaceColours.fore = ColourOptional();
+	whitespaceColours.back = ColourOptional(ColourDesired(0xff, 0xff, 0xff));
+	controlCharSymbol = 0;	/* Draw the control characters */
+	controlCharWidth = 0;
+	selbar = Platform::Chrome();
+	selbarlight = Platform::ChromeHighlight();
+	styles[STYLE_LINENUMBER].fore = ColourDesired(0, 0, 0);
+	styles[STYLE_LINENUMBER].back = Platform::Chrome();
+	caretcolour = ColourDesired(0, 0, 0);
+	additionalCaretColour = ColourDesired(0x7f, 0x7f, 0x7f);
+	caretLineFrame = 0;
 	showCaretLineBackground = false;
-	caretLineBackground.desired = ColourDesired(0xff, 0xff, 0);
+	alwaysShowCaretLineBackground = false;
+	caretLineBackground = ColourDesired(0xff, 0xff, 0);
 	caretLineAlpha = SC_ALPHA_NOALPHA;
-	edgecolour.desired = ColourDesired(0xc0, 0xc0, 0xc0);
-	edgeState = EDGE_NONE;
 	caretStyle = CARETSTYLE_LINE;
 	caretWidth = 1;
 	someStylesProtected = false;
+	someStylesForceCase = false;
 
-	hotspotForegroundSet = false;
-	hotspotForeground.desired = ColourDesired(0, 0, 0xff);
-	hotspotBackgroundSet = false;
-	hotspotBackground.desired = ColourDesired(0xff, 0xff, 0xff);
+	hotspotColours.fore = ColourOptional(ColourDesired(0, 0, 0xff));
+	hotspotColours.back = ColourOptional(ColourDesired(0xff, 0xff, 0xff));
 	hotspotUnderline = true;
 	hotspotSingleLine = true;
 
 	leftMarginWidth = 1;
 	rightMarginWidth = 1;
-	ms[0].style = SC_MARGIN_NUMBER;
-	ms[0].width = 0;
-	ms[0].mask = 0;
-	ms[1].style = SC_MARGIN_SYMBOL;
-	ms[1].width = 16;
-	ms[1].mask = ~SC_MASK_FOLDERS;
-	ms[2].style = SC_MARGIN_SYMBOL;
-	ms[2].width = 0;
-	ms[2].mask = 0;
-	fixedColumnWidth = leftMarginWidth;
-	symbolMargin = false;
-	maskInLine = 0xffffffff;
-	for (int margin=0; margin < margins; margin++) {
-		fixedColumnWidth += ms[margin].width;
-		symbolMargin = symbolMargin || (ms[margin].style != SC_MARGIN_NUMBER);
-		if (ms[margin].width > 0)
-			maskInLine &= ~ms[margin].mask;
-	}
+	ms.resize(SC_MAX_MARGIN + 1);
+	ms[0] = MarginStyle(SC_MARGIN_NUMBER);
+	ms[1] = MarginStyle(SC_MARGIN_SYMBOL, 16, ~SC_MASK_FOLDERS);
+	ms[2] = MarginStyle(SC_MARGIN_SYMBOL);
+	marginInside = true;
+	CalculateMarginWidthAndMask();
+	textStart = marginInside ? fixedColumnWidth : leftMarginWidth;
 	zoomLevel = 0;
 	viewWhitespace = wsInvisible;
+	tabDrawMode = tdLongArrow;
+	whitespaceSize = 1;
 	viewIndentationGuides = ivNone;
 	viewEOL = false;
-	showMarkedLines = true;
-	extraFontFlag = false;
+	extraFontFlag = 0;
+	extraAscent = 0;
+	extraDescent = 0;
+	marginStyleOffset = 0;
+	annotationVisible = ANNOTATION_HIDDEN;
+	annotationStyleOffset = 0;
+	eolAnnotationVisible = EOLANNOTATION_HIDDEN;
+	eolAnnotationStyleOffset = 0;
+	braceHighlightIndicatorSet = false;
+	braceHighlightIndicator = 0;
+	braceBadLightIndicatorSet = false;
+	braceBadLightIndicator = 0;
+
+	edgeState = EDGE_NONE;
+	theEdge = EdgeProperties(0, ColourDesired(0xc0, 0xc0, 0xc0));
+
+	marginNumberPadding = 3;
+	ctrlCharPadding = 3; // +3 For a blank on front and rounded edge each side
+	lastSegItalicsOffset = 2;
+
+	wrapState = WrapMode::none;
+	wrapVisualFlags = 0;
+	wrapVisualFlagsLocation = 0;
+	wrapVisualStartIndent = 0;
+	wrapIndentMode = SC_WRAPINDENT_FIXED;
 }
 
-void ViewStyle::RefreshColourPalette(Palette &pal, bool want) {
-	unsigned int i;
-	for (i=0;i<stylesSize;i++) {
-		pal.WantFind(styles[i].fore, want);
-		pal.WantFind(styles[i].back, want);
+void ViewStyle::Refresh(Surface &surface, int tabInChars) {
+	fonts.clear();
+
+	selbar = Platform::Chrome();
+	selbarlight = Platform::ChromeHighlight();
+
+	// Apply the extra font flag which controls text drawing quality to each style.
+	for (Style &style : styles) {
+		style.extraFontFlag = extraFontFlag;
 	}
-	for (i=0;i<(sizeof(indicators)/sizeof(indicators[0]));i++) {
-		pal.WantFind(indicators[i].fore, want);
+
+	// Create a FontRealised object for each unique font in the styles.
+	CreateAndAddFont(styles[STYLE_DEFAULT]);
+	for (const Style &style : styles) {
+		CreateAndAddFont(style);
 	}
-	for (i=0;i<(sizeof(markers)/sizeof(markers[0]));i++) {
-		markers[i].RefreshColourPalette(pal, want);
+
+	// Ask platform to allocate each unique font.
+	for (std::pair<const FontSpecification, std::unique_ptr<FontRealised>> &font : fonts) {
+		font.second->Realise(surface, zoomLevel, technology, font.first);
 	}
-	pal.WantFind(selforeground, want);
-	pal.WantFind(selbackground, want);
-	pal.WantFind(selbackground2, want);
-
-	pal.WantFind(foldmarginColour, want);
-	pal.WantFind(foldmarginHighlightColour, want);
-
-	pal.WantFind(whitespaceForeground, want);
-	pal.WantFind(whitespaceBackground, want);
-	pal.WantFind(selbar, want);
-	pal.WantFind(selbarlight, want);
-	pal.WantFind(caretcolour, want);
-	pal.WantFind(caretLineBackground, want);
-	pal.WantFind(edgecolour, want);
-	pal.WantFind(hotspotForeground, want);
-	pal.WantFind(hotspotBackground, want);
-}
-
-void ViewStyle::Refresh(Surface &surface) {
-	selbar.desired = Platform::Chrome();
-	selbarlight.desired = Platform::ChromeHighlight();
-	styles[STYLE_DEFAULT].Realise(surface, zoomLevel, NULL, extraFontFlag);
-	maxAscent = styles[STYLE_DEFAULT].ascent;
-	maxDescent = styles[STYLE_DEFAULT].descent;
-	someStylesProtected = false;
-	for (unsigned int i=0; i<stylesSize; i++) {
-		if (i != STYLE_DEFAULT) {
-			styles[i].Realise(surface, zoomLevel, &styles[STYLE_DEFAULT], extraFontFlag);
-			if (maxAscent < styles[i].ascent)
-				maxAscent = styles[i].ascent;
-			if (maxDescent < styles[i].descent)
-				maxDescent = styles[i].descent;
-		}
-		if (styles[i].IsProtected()) {
-			someStylesProtected = true;
-		}
+
+	// Set the platform font handle and measurements for each style.
+	for (Style &style : styles) {
+		FontRealised *fr = Find(style);
+		style.Copy(fr->font, *fr);
 	}
 
+	indicatorsDynamic = std::any_of(indicators.cbegin(), indicators.cend(),
+		[](const Indicator &indicator) noexcept { return indicator.IsDynamic(); });
+
+	indicatorsSetFore = std::any_of(indicators.cbegin(), indicators.cend(),
+		[](const Indicator &indicator) noexcept { return indicator.OverridesTextFore(); });
+
+	maxAscent = 1;
+	maxDescent = 1;
+	FindMaxAscentDescent();
+	maxAscent += extraAscent;
+	maxDescent += extraDescent;
 	lineHeight = maxAscent + maxDescent;
+	lineOverlap = lineHeight / 10;
+	if (lineOverlap < 2)
+		lineOverlap = 2;
+	if (lineOverlap > lineHeight)
+		lineOverlap = lineHeight;
+
+	someStylesProtected = std::any_of(styles.cbegin(), styles.cend(),
+		[](const Style &style) noexcept { return style.IsProtected(); });
+
+	someStylesForceCase = std::any_of(styles.cbegin(), styles.cend(),
+		[](const Style &style) noexcept { return style.caseForce != Style::caseMixed; });
+
 	aveCharWidth = styles[STYLE_DEFAULT].aveCharWidth;
 	spaceWidth = styles[STYLE_DEFAULT].spaceWidth;
+	tabWidth = spaceWidth * tabInChars;
 
-	fixedColumnWidth = leftMarginWidth;
-	symbolMargin = false;
-	maskInLine = 0xffffffff;
-	for (int margin=0; margin < margins; margin++) {
-		fixedColumnWidth += ms[margin].width;
-		symbolMargin = symbolMargin || (ms[margin].style != SC_MARGIN_NUMBER);
-		if (ms[margin].width > 0)
-			maskInLine &= ~ms[margin].mask;
+	controlCharWidth = 0.0;
+	if (controlCharSymbol >= 32) {
+		const char cc[2] = { static_cast<char>(controlCharSymbol), '\0' };
+		controlCharWidth = surface.WidthText(styles[STYLE_CONTROLCHAR].font, cc);
 	}
+
+	CalculateMarginWidthAndMask();
+	textStart = marginInside ? fixedColumnWidth : leftMarginWidth;
 }
 
-void ViewStyle::AllocStyles(size_t sizeNew) {
-	Style *stylesNew = new Style[sizeNew];
-	size_t i=0;
-	for (; i<stylesSize; i++) {
-		stylesNew[i] = styles[i];
-		stylesNew[i].fontName = styles[i].fontName;
-	}
-	if (stylesSize > STYLE_DEFAULT) {
-		for (; i<sizeNew; i++) {
-			if (i != STYLE_DEFAULT) {
-				stylesNew[i].ClearTo(styles[STYLE_DEFAULT]);
-			}
-		}
+void ViewStyle::ReleaseAllExtendedStyles() noexcept {
+	nextExtendedStyle = 256;
+}
+
+int ViewStyle::AllocateExtendedStyles(int numberStyles) {
+	const int startRange = nextExtendedStyle;
+	nextExtendedStyle += numberStyles;
+	EnsureStyle(nextExtendedStyle);
+	for (int i=startRange; i<nextExtendedStyle; i++) {
+		styles[i].ClearTo(styles[STYLE_DEFAULT]);
 	}
-	delete []styles;
-	styles = stylesNew;
-	stylesSize = sizeNew;
+	return startRange;
 }
 
 void ViewStyle::EnsureStyle(size_t index) {
-	if (index >= stylesSize) {
-		size_t sizeNew = stylesSize * 2;
-		while (sizeNew < index)
-			sizeNew *= 2;
-		AllocStyles(sizeNew);
+	if (index >= styles.size()) {
+		AllocStyles(index+1);
 	}
 }
 
 void ViewStyle::ResetDefaultStyle() {
 	styles[STYLE_DEFAULT].Clear(ColourDesired(0,0,0),
-		ColourDesired(0xff,0xff,0xff),
-		Platform::DefaultFontSize(), fontNames.Save(Platform::DefaultFont()),
-		SC_CHARSET_DEFAULT,
-		false, false, false, false, Style::caseMixed, true, true, false);
+	        ColourDesired(0xff,0xff,0xff),
+	        Platform::DefaultFontSize() * SC_FONT_SIZE_MULTIPLIER, fontNames.Save(Platform::DefaultFont()),
+	        SC_CHARSET_DEFAULT,
+	        SC_WEIGHT_NORMAL, false, false, false, Style::caseMixed, true, true, false);
 }
 
 void ViewStyle::ClearStyles() {
 	// Reset all styles to be like the default style
-	for (unsigned int i=0; i<stylesSize; i++) {
+	for (size_t i=0; i<styles.size(); i++) {
 		if (i != STYLE_DEFAULT) {
 			styles[i].ClearTo(styles[STYLE_DEFAULT]);
 		}
 	}
-	styles[STYLE_LINENUMBER].back.desired = Platform::Chrome();
+	styles[STYLE_LINENUMBER].back = Platform::Chrome();
 
 	// Set call tip fore/back to match the values previously set for call tips
-	styles[STYLE_CALLTIP].back.desired = ColourDesired(0xff, 0xff, 0xff);
-	styles[STYLE_CALLTIP].fore.desired = ColourDesired(0x80, 0x80, 0x80);
+	styles[STYLE_CALLTIP].back = ColourDesired(0xff, 0xff, 0xff);
+	styles[STYLE_CALLTIP].fore = ColourDesired(0x80, 0x80, 0x80);
 }
 
 void ViewStyle::SetStyleFontName(int styleIndex, const char *name) {
 	styles[styleIndex].fontName = fontNames.Save(name);
 }
 
-bool ViewStyle::ProtectionActive() const {
+bool ViewStyle::ProtectionActive() const noexcept {
 	return someStylesProtected;
 }
+
+int ViewStyle::ExternalMarginWidth() const noexcept {
+	return marginInside ? 0 : fixedColumnWidth;
+}
+
+int ViewStyle::MarginFromLocation(Point pt) const noexcept {
+	int margin = -1;
+	int x = marginInside ? 0 : -fixedColumnWidth;
+	for (size_t i = 0; i < ms.size(); i++) {
+		if ((pt.x >= x) && (pt.x < x + ms[i].width))
+			margin = static_cast<int>(i);
+		x += ms[i].width;
+	}
+	return margin;
+}
+
+bool ViewStyle::ValidStyle(size_t styleIndex) const noexcept {
+	return styleIndex < styles.size();
+}
+
+void ViewStyle::CalcLargestMarkerHeight() noexcept {
+	largestMarkerHeight = 0;
+	for (const LineMarker &marker : markers) {
+		switch (marker.markType) {
+		case SC_MARK_PIXMAP:
+			if (marker.pxpm && marker.pxpm->GetHeight() > largestMarkerHeight)
+				largestMarkerHeight = marker.pxpm->GetHeight();
+			break;
+		case SC_MARK_RGBAIMAGE:
+			if (marker.image && marker.image->GetHeight() > largestMarkerHeight)
+				largestMarkerHeight = marker.image->GetHeight();
+			break;
+		}
+	}
+}
+
+int ViewStyle::GetFrameWidth() const noexcept {
+	return std::clamp(caretLineFrame, 1, lineHeight / 3);
+}
+
+bool ViewStyle::IsLineFrameOpaque(bool caretActive, bool lineContainsCaret) const noexcept {
+	return caretLineFrame && (caretActive || alwaysShowCaretLineBackground) && showCaretLineBackground &&
+		(caretLineAlpha == SC_ALPHA_NOALPHA) && lineContainsCaret;
+}
+
+// See if something overrides the line background colour:  Either if caret is on the line
+// and background colour is set for that, or if a marker is defined that forces its background
+// colour onto the line, or if a marker is defined but has no selection margin in which to
+// display itself (as long as it's not an SC_MARK_EMPTY marker).  These are checked in order
+// with the earlier taking precedence.  When multiple markers cause background override,
+// the colour for the highest numbered one is used.
+ColourOptional ViewStyle::Background(int marksOfLine, bool caretActive, bool lineContainsCaret) const noexcept {
+	ColourOptional background;
+	if (!caretLineFrame && (caretActive || alwaysShowCaretLineBackground) && showCaretLineBackground &&
+		(caretLineAlpha == SC_ALPHA_NOALPHA) && lineContainsCaret) {
+		background = ColourOptional(caretLineBackground, true);
+	}
+	if (!background.isSet && marksOfLine) {
+		int marks = marksOfLine;
+		for (int markBit = 0; (markBit < 32) && marks; markBit++) {
+			if ((marks & 1) && (markers[markBit].markType == SC_MARK_BACKGROUND) &&
+				(markers[markBit].alpha == SC_ALPHA_NOALPHA)) {
+				background = ColourOptional(markers[markBit].back, true);
+			}
+			marks >>= 1;
+		}
+	}
+	if (!background.isSet && maskInLine) {
+		int marksMasked = marksOfLine & maskInLine;
+		if (marksMasked) {
+			for (int markBit = 0; (markBit < 32) && marksMasked; markBit++) {
+				if ((marksMasked & 1) &&
+					(markers[markBit].alpha == SC_ALPHA_NOALPHA)) {
+					background = ColourOptional(markers[markBit].back, true);
+				}
+				marksMasked >>= 1;
+			}
+		}
+	}
+	return background;
+}
+
+bool ViewStyle::SelectionBackgroundDrawn() const noexcept {
+	return selColours.back.isSet &&
+		((selAlpha == SC_ALPHA_NOALPHA) || (selAdditionalAlpha == SC_ALPHA_NOALPHA));
+}
+
+bool ViewStyle::WhitespaceBackgroundDrawn() const noexcept {
+	return (viewWhitespace != wsInvisible) && (whitespaceColours.back.isSet);
+}
+
+bool ViewStyle::WhiteSpaceVisible(bool inIndent) const noexcept {
+	return (!inIndent && viewWhitespace == wsVisibleAfterIndent) ||
+		(inIndent && viewWhitespace == wsVisibleOnlyInIndent) ||
+		viewWhitespace == wsVisibleAlways;
+}
+
+ColourDesired ViewStyle::WrapColour() const noexcept {
+	if (whitespaceColours.fore.isSet)
+		return whitespaceColours.fore;
+	else
+		return styles[STYLE_DEFAULT].fore;
+}
+
+// Insert new edge in sorted order.
+void ViewStyle::AddMultiEdge(uptr_t wParam, sptr_t lParam) {
+	const int column = static_cast<int>(wParam);
+	theMultiEdge.insert(
+		std::upper_bound(theMultiEdge.begin(), theMultiEdge.end(), column,
+			[](const EdgeProperties &a, const EdgeProperties &b) {
+				return a.column < b.column;
+			}),
+		EdgeProperties(column, lParam));
+}
+
+bool ViewStyle::SetWrapState(int wrapState_) noexcept {
+	WrapMode wrapStateWanted;
+	switch (wrapState_) {
+	case SC_WRAP_WORD:
+		wrapStateWanted = WrapMode::word;
+		break;
+	case SC_WRAP_CHAR:
+		wrapStateWanted = WrapMode::character;
+		break;
+	case SC_WRAP_WHITESPACE:
+		wrapStateWanted = WrapMode::whitespace;
+		break;
+	default:
+		wrapStateWanted = WrapMode::none;
+		break;
+	}
+	const bool changed = wrapState != wrapStateWanted;
+	wrapState = wrapStateWanted;
+	return changed;
+}
+
+bool ViewStyle::SetWrapVisualFlags(int wrapVisualFlags_) noexcept {
+	const bool changed = wrapVisualFlags != wrapVisualFlags_;
+	wrapVisualFlags = wrapVisualFlags_;
+	return changed;
+}
+
+bool ViewStyle::SetWrapVisualFlagsLocation(int wrapVisualFlagsLocation_) noexcept {
+	const bool changed = wrapVisualFlagsLocation != wrapVisualFlagsLocation_;
+	wrapVisualFlagsLocation = wrapVisualFlagsLocation_;
+	return changed;
+}
+
+bool ViewStyle::SetWrapVisualStartIndent(int wrapVisualStartIndent_) noexcept {
+	const bool changed = wrapVisualStartIndent != wrapVisualStartIndent_;
+	wrapVisualStartIndent = wrapVisualStartIndent_;
+	return changed;
+}
+
+bool ViewStyle::SetWrapIndentMode(int wrapIndentMode_) noexcept {
+	const bool changed = wrapIndentMode != wrapIndentMode_;
+	wrapIndentMode = wrapIndentMode_;
+	return changed;
+}
+
+bool ViewStyle::IsBlockCaretStyle() const noexcept {
+	return ((caretStyle & CARETSTYLE_INS_MASK) == CARETSTYLE_BLOCK) ||
+		(caretStyle & CARETSTYLE_OVERSTRIKE_BLOCK) != 0;
+}
+
+bool ViewStyle::IsCaretVisible() const noexcept {
+	return caretWidth > 0 && caretStyle != CARETSTYLE_INVISIBLE;
+}
+
+bool ViewStyle::DrawCaretInsideSelection(bool inOverstrike, bool imeCaretBlockOverride) const noexcept {
+	if (caretStyle & CARETSTYLE_BLOCK_AFTER)
+		return false;
+	return ((caretStyle & CARETSTYLE_INS_MASK) == CARETSTYLE_BLOCK) ||
+		(inOverstrike && (caretStyle & CARETSTYLE_OVERSTRIKE_BLOCK) != 0) ||
+		imeCaretBlockOverride;
+}
+
+ViewStyle::CaretShape ViewStyle::CaretShapeForMode(bool inOverstrike) const noexcept {
+	if (inOverstrike) {
+		return (caretStyle & CARETSTYLE_OVERSTRIKE_BLOCK) ? CaretShape::block : CaretShape::bar;
+	}
+
+	const int caret = caretStyle & CARETSTYLE_INS_MASK;
+	return (caret <= CARETSTYLE_BLOCK) ? static_cast<CaretShape>(caret) : CaretShape::line;
+}
+
+void ViewStyle::AllocStyles(size_t sizeNew) {
+	size_t i=styles.size();
+	styles.resize(sizeNew);
+	if (styles.size() > STYLE_DEFAULT) {
+		for (; i<sizeNew; i++) {
+			if (i != STYLE_DEFAULT) {
+				styles[i].ClearTo(styles[STYLE_DEFAULT]);
+			}
+		}
+	}
+}
+
+void ViewStyle::CreateAndAddFont(const FontSpecification &fs) {
+	if (fs.fontName) {
+		FontMap::iterator it = fonts.find(fs);
+		if (it == fonts.end()) {
+			fonts[fs] = std::make_unique<FontRealised>();
+		}
+	}
+}
+
+FontRealised *ViewStyle::Find(const FontSpecification &fs) {
+	if (!fs.fontName)	// Invalid specification so return arbitrary object
+		return fonts.begin()->second.get();
+	FontMap::iterator it = fonts.find(fs);
+	if (it != fonts.end()) {
+		// Should always reach here since map was just set for all styles
+		return it->second.get();
+	}
+	return nullptr;
+}
+
+void ViewStyle::FindMaxAscentDescent() {
+	for (FontMap::const_iterator it = fonts.cbegin(); it != fonts.cend(); ++it) {
+		if (maxAscent < it->second->ascent)
+			maxAscent = it->second->ascent;
+		if (maxDescent < it->second->descent)
+			maxDescent = it->second->descent;
+	}
+}
diff --git a/Pythonwin/Scintilla/src/ViewStyle.h b/Pythonwin/Scintilla/src/ViewStyle.h
index 2f2d52461..dc47ed380 100644
--- a/Pythonwin/Scintilla/src/ViewStyle.h
+++ b/Pythonwin/Scintilla/src/ViewStyle.h
@@ -8,117 +8,214 @@
 #ifndef VIEWSTYLE_H
 #define VIEWSTYLE_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
 
 /**
  */
 class MarginStyle {
 public:
 	int style;
+	ColourDesired back;
 	int width;
 	int mask;
 	bool sensitive;
-	MarginStyle();
+	int cursor;
+	MarginStyle(int style_= SC_MARGIN_SYMBOL, int width_=0, int mask_=0) noexcept;
 };
 
 /**
  */
-class FontNames {
-private:
-	char **names;
-	int size;
-	int max;
 
+
+class FontRealised : public FontMeasurements {
 public:
-	FontNames();
-	~FontNames();
-	void Clear();
-	const char *Save(const char *name);
+	Font font;
+	FontRealised() noexcept;
+	// FontRealised objects can not be copied.
+	FontRealised(const FontRealised &) = delete;
+	FontRealised(FontRealised &&) = delete;
+	FontRealised &operator=(const FontRealised &) = delete;
+	FontRealised &operator=(FontRealised &&) = delete;
+	virtual ~FontRealised();
+	void Realise(Surface &surface, int zoomLevel, int technology, const FontSpecification &fs);
 };
 
 enum IndentView {ivNone, ivReal, ivLookForward, ivLookBoth};
 
-enum WhiteSpaceVisibility {wsInvisible=0, wsVisibleAlways=1, wsVisibleAfterIndent=2};
+enum WhiteSpaceVisibility {wsInvisible=0, wsVisibleAlways=1, wsVisibleAfterIndent=2, wsVisibleOnlyInIndent=3};
+
+enum TabDrawMode {tdLongArrow=0, tdStrikeOut=1};
+
+typedef std::map<FontSpecification, std::unique_ptr<FontRealised>> FontMap;
+
+enum class WrapMode { none, word, character, whitespace };
+
+class ColourOptional : public ColourDesired {
+public:
+	bool isSet;
+	ColourOptional(ColourDesired colour_=ColourDesired(0,0,0), bool isSet_=false) noexcept : ColourDesired(colour_), isSet(isSet_) {
+	}
+	ColourOptional(uptr_t wParam, sptr_t lParam) noexcept : ColourDesired(static_cast<int>(lParam)), isSet(wParam != 0) {
+	}
+};
+
+struct ForeBackColours {
+	ColourOptional fore;
+	ColourOptional back;
+};
+
+struct EdgeProperties {
+	int column;
+	ColourDesired colour;
+	EdgeProperties(int column_ = 0, ColourDesired colour_ = ColourDesired(0)) noexcept :
+		column(column_), colour(colour_) {
+	}
+	EdgeProperties(uptr_t wParam, sptr_t lParam) noexcept :
+		column(static_cast<int>(wParam)), colour(static_cast<int>(lParam)) {
+	}
+};
 
 /**
  */
 class ViewStyle {
+	UniqueStringSet fontNames;
+	FontMap fonts;
 public:
-	FontNames fontNames;
-	size_t stylesSize;
-	Style *styles;
-	LineMarker markers[MARKER_MAX + 1];
-	Indicator indicators[INDIC_MAX + 1];
+	std::vector<Style> styles;
+	int nextExtendedStyle;
+	std::vector<LineMarker> markers;
+	int largestMarkerHeight;
+	std::vector<Indicator> indicators;
+	bool indicatorsDynamic;
+	bool indicatorsSetFore;
+	int technology;
 	int lineHeight;
+	int lineOverlap;
 	unsigned int maxAscent;
 	unsigned int maxDescent;
-	unsigned int aveCharWidth;
-	unsigned int spaceWidth;
-	bool selforeset;
-	ColourPair selforeground;
-	bool selbackset;
-	ColourPair selbackground;
-	ColourPair selbackground2;
+	XYPOSITION aveCharWidth;
+	XYPOSITION spaceWidth;
+	XYPOSITION tabWidth;
+	ForeBackColours selColours;
+	ColourDesired selAdditionalForeground;
+	ColourDesired selAdditionalBackground;
+	ColourDesired selBackground2;
 	int selAlpha;
+	int selAdditionalAlpha;
 	bool selEOLFilled;
-	bool whitespaceForegroundSet;
-	ColourPair whitespaceForeground;
-	bool whitespaceBackgroundSet;
-	ColourPair whitespaceBackground;
-	ColourPair selbar;
-	ColourPair selbarlight;
-	bool foldmarginColourSet;
-	ColourPair foldmarginColour;
-	bool foldmarginHighlightColourSet;
-	ColourPair foldmarginHighlightColour;
-	bool hotspotForegroundSet;
-	ColourPair hotspotForeground;
-	bool hotspotBackgroundSet;
-	ColourPair hotspotBackground;
+	ForeBackColours whitespaceColours;
+	int controlCharSymbol;
+	XYPOSITION controlCharWidth;
+	ColourDesired selbar;
+	ColourDesired selbarlight;
+	ColourOptional foldmarginColour;
+	ColourOptional foldmarginHighlightColour;
+	ForeBackColours hotspotColours;
 	bool hotspotUnderline;
 	bool hotspotSingleLine;
 	/// Margins are ordered: Line Numbers, Selection Margin, Spacing Margin
-	enum { margins=5 };
 	int leftMarginWidth;	///< Spacing margin on left of text
-	int rightMarginWidth;	///< Spacing margin on left of text
-	bool symbolMargin;
+	int rightMarginWidth;	///< Spacing margin on right of text
 	int maskInLine;	///< Mask for markers to be put into text because there is nowhere for them to go in margin
-	MarginStyle ms[margins];
-	int fixedColumnWidth;
+	int maskDrawInText;	///< Mask for markers that always draw in text
+	std::vector<MarginStyle> ms;
+	int fixedColumnWidth;	///< Total width of margins
+	bool marginInside;	///< true: margin included in text view, false: separate views
+	int textStart;	///< Starting x position of text within the view
 	int zoomLevel;
 	WhiteSpaceVisibility viewWhitespace;
+	TabDrawMode tabDrawMode;
+	int whitespaceSize;
 	IndentView viewIndentationGuides;
 	bool viewEOL;
-	bool showMarkedLines;
-	ColourPair caretcolour;
+	ColourDesired caretcolour;
+	ColourDesired additionalCaretColour;
+	int caretLineFrame;
 	bool showCaretLineBackground;
-	ColourPair caretLineBackground;
+	bool alwaysShowCaretLineBackground;
+	ColourDesired caretLineBackground;
 	int caretLineAlpha;
-	ColourPair edgecolour;
-	int edgeState;
 	int caretStyle;
 	int caretWidth;
 	bool someStylesProtected;
-	bool extraFontFlag;
+	bool someStylesForceCase;
+	int extraFontFlag;
+	int extraAscent;
+	int extraDescent;
+	int marginStyleOffset;
+	int annotationVisible;
+	int annotationStyleOffset;
+	int eolAnnotationVisible;
+	int eolAnnotationStyleOffset;
+	bool braceHighlightIndicatorSet;
+	int braceHighlightIndicator;
+	bool braceBadLightIndicatorSet;
+	int braceBadLightIndicator;
+	int edgeState;
+	EdgeProperties theEdge;
+	std::vector<EdgeProperties> theMultiEdge;
+	int marginNumberPadding; // the right-side padding of the number margin
+	int ctrlCharPadding; // the padding around control character text blobs
+	int lastSegItalicsOffset; // the offset so as not to clip italic characters at EOLs
+
+	// Wrapping support
+	WrapMode wrapState;
+	int wrapVisualFlags;
+	int wrapVisualFlagsLocation;
+	int wrapVisualStartIndent;
+	int wrapIndentMode; // SC_WRAPINDENT_FIXED, _SAME, _INDENT
 
 	ViewStyle();
 	ViewStyle(const ViewStyle &source);
+	ViewStyle(ViewStyle &&) = delete;
+	// Can only be copied through copy constructor which ensures font names initialised correctly
+	ViewStyle &operator=(const ViewStyle &) = delete;
+	ViewStyle &operator=(ViewStyle &&) = delete;
 	~ViewStyle();
-	void Init(size_t stylesSize_=64);
-	void RefreshColourPalette(Palette &pal, bool want);
-	void Refresh(Surface &surface);
-	void AllocStyles(size_t sizeNew);
+	void CalculateMarginWidthAndMask() noexcept;
+	void Init(size_t stylesSize_=256);
+	void Refresh(Surface &surface, int tabInChars);
+	void ReleaseAllExtendedStyles() noexcept;
+	int AllocateExtendedStyles(int numberStyles);
 	void EnsureStyle(size_t index);
 	void ResetDefaultStyle();
 	void ClearStyles();
 	void SetStyleFontName(int styleIndex, const char *name);
-	bool ProtectionActive() const;
+	bool ProtectionActive() const noexcept;
+	int ExternalMarginWidth() const noexcept;
+	int MarginFromLocation(Point pt) const noexcept;
+	bool ValidStyle(size_t styleIndex) const noexcept;
+	void CalcLargestMarkerHeight() noexcept;
+	int GetFrameWidth() const noexcept;
+	bool IsLineFrameOpaque(bool caretActive, bool lineContainsCaret) const noexcept;
+	ColourOptional Background(int marksOfLine, bool caretActive, bool lineContainsCaret) const noexcept;
+	bool SelectionBackgroundDrawn() const noexcept;
+	bool WhitespaceBackgroundDrawn() const noexcept;
+	ColourDesired WrapColour() const noexcept;
+
+	void AddMultiEdge(uptr_t wParam, sptr_t lParam);
+
+	bool SetWrapState(int wrapState_) noexcept;
+	bool SetWrapVisualFlags(int wrapVisualFlags_) noexcept;
+	bool SetWrapVisualFlagsLocation(int wrapVisualFlagsLocation_) noexcept;
+	bool SetWrapVisualStartIndent(int wrapVisualStartIndent_) noexcept;
+	bool SetWrapIndentMode(int wrapIndentMode_) noexcept;
+
+	bool WhiteSpaceVisible(bool inIndent) const noexcept;
+
+	enum class CaretShape { invisible, line, block, bar };
+	bool IsBlockCaretStyle() const noexcept;
+	bool IsCaretVisible() const noexcept;
+	bool DrawCaretInsideSelection(bool inOverstrike, bool imeCaretBlockOverride) const noexcept;
+	CaretShape CaretShapeForMode(bool inOverstrike) const noexcept;
+
+private:
+	void AllocStyles(size_t sizeNew);
+	void CreateAndAddFont(const FontSpecification &fs);
+	FontRealised *Find(const FontSpecification &fs);
+	void FindMaxAscentDescent();
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/src/WindowAccessor.cxx b/Pythonwin/Scintilla/src/WindowAccessor.cxx
deleted file mode 100644
index 8093300bc..000000000
--- a/Pythonwin/Scintilla/src/WindowAccessor.cxx
+++ /dev/null
@@ -1,191 +0,0 @@
-// Scintilla source code edit control
-/** @file WindowAccessor.cxx
- ** Rapid easy access to contents of a Scintilla.
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h> 
-#include <stdio.h>
-
-#include "Platform.h"
-
-#include "PropSet.h"
-#include "Accessor.h"
-#include "WindowAccessor.h"
-#include "Scintilla.h"
-
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
-
-WindowAccessor::~WindowAccessor() {
-}
-
-bool WindowAccessor::InternalIsLeadByte(char ch) {
-	if (SC_CP_UTF8 == codePage)
-		// For lexing, all characters >= 0x80 are treated the
-		// same so none is considered a lead byte.
-		return false;	
-	else
-		return Platform::IsDBCSLeadByte(codePage, ch);
-}
-
-void WindowAccessor::Fill(int position) {
-	if (lenDoc == -1)
-		lenDoc = Platform::SendScintilla(id, SCI_GETTEXTLENGTH, 0, 0);
-	startPos = position - slopSize;
-	if (startPos + bufferSize > lenDoc)
-		startPos = lenDoc - bufferSize;
-	if (startPos < 0)
-		startPos = 0;
-	endPos = startPos + bufferSize;
-	if (endPos > lenDoc)
-		endPos = lenDoc;
-
-	TextRange tr = {{startPos, endPos}, buf};
-	Platform::SendScintillaPointer(id, SCI_GETTEXTRANGE, 0, &tr);
-}
-
-bool WindowAccessor::Match(int pos, const char *s) {
-	for (int i=0; *s; i++) {
-		if (*s != SafeGetCharAt(pos+i))
-			return false;
-		s++;
-	}
-	return true;
-}
-
-char WindowAccessor::StyleAt(int position) {
-	return static_cast<char>(Platform::SendScintilla(
-		id, SCI_GETSTYLEAT, position, 0));
-}
-
-int WindowAccessor::GetLine(int position) {
-	return Platform::SendScintilla(id, SCI_LINEFROMPOSITION, position, 0);
-}
-
-int WindowAccessor::LineStart(int line) {
-	return Platform::SendScintilla(id, SCI_POSITIONFROMLINE, line, 0);
-}
-
-int WindowAccessor::LevelAt(int line) {
-	return Platform::SendScintilla(id, SCI_GETFOLDLEVEL, line, 0);
-}
-
-int WindowAccessor::Length() { 
-	if (lenDoc == -1) 
-		lenDoc = Platform::SendScintilla(id, SCI_GETTEXTLENGTH, 0, 0);
-	return lenDoc; 
-}
-
-int WindowAccessor::GetLineState(int line) {
-	return Platform::SendScintilla(id, SCI_GETLINESTATE, line);
-}
-
-int WindowAccessor::SetLineState(int line, int state) {
-	return Platform::SendScintilla(id, SCI_SETLINESTATE, line, state);
-}
-
-void WindowAccessor::StartAt(unsigned int start, char chMask) {
-	Platform::SendScintilla(id, SCI_STARTSTYLING, start, chMask);
-}
-
-void WindowAccessor::StartSegment(unsigned int pos) {
-	startSeg = pos;
-}
-
-void WindowAccessor::ColourTo(unsigned int pos, int chAttr) {
-	// Only perform styling if non empty range
-	if (pos != startSeg - 1) {
-		if (pos < startSeg) {
-			Platform::DebugPrintf("Bad colour positions %d - %d\n", startSeg, pos);
-		}
-
-		if (validLen + (pos - startSeg + 1) >= bufferSize)
-			Flush();
-		if (validLen + (pos - startSeg + 1) >= bufferSize) {
-			// Too big for buffer so send directly
-			Platform::SendScintilla(id, SCI_SETSTYLING, pos - startSeg + 1, chAttr);
-		} else {
-			if (chAttr != chWhile)
-				chFlags = 0;
-			chAttr |= chFlags;
-			for (unsigned int i = startSeg; i <= pos; i++) {
-				styleBuf[validLen++] = static_cast<char>(chAttr);
-			}
-		}
-	}
-	startSeg = pos+1;
-}
-
-void WindowAccessor::SetLevel(int line, int level) {
-	Platform::SendScintilla(id, SCI_SETFOLDLEVEL, line, level);
-}
-
-void WindowAccessor::Flush() {
-	startPos = extremePosition;
-	lenDoc = -1;
-	if (validLen > 0) {
-		Platform::SendScintillaPointer(id, SCI_SETSTYLINGEX, validLen, 
-			styleBuf);
-		validLen = 0;
-	}
-}
-
-int WindowAccessor::IndentAmount(int line, int *flags, PFNIsCommentLeader pfnIsCommentLeader) {
-	int end = Length();
-	int spaceFlags = 0;
-	
-	// Determines the indentation level of the current line and also checks for consistent 
-	// indentation compared to the previous line.
-	// Indentation is judged consistent when the indentation whitespace of each line lines 
-	// the same or the indentation of one line is a prefix of the other.
-	
-	int pos = LineStart(line);
-	char ch = (*this)[pos];
-	int indent = 0;
-	bool inPrevPrefix = line > 0;
-	int posPrev = inPrevPrefix ? LineStart(line-1) : 0;
-	while ((ch == ' ' || ch == '\t') && (pos < end)) {
-		if (inPrevPrefix) {
-			char chPrev = (*this)[posPrev++];
-			if (chPrev == ' ' || chPrev == '\t') {
-				if (chPrev != ch)
-					spaceFlags |= wsInconsistent;
-			} else {
-				inPrevPrefix = false;
-			}
-		}
-		if (ch == ' ') {
-			spaceFlags |= wsSpace;
-			indent++;
-		} else {	// Tab
-			spaceFlags |= wsTab;
-			if (spaceFlags & wsSpace)
-				spaceFlags |= wsSpaceTab;
-			indent = (indent / 8 + 1) * 8;
-		}
-		ch = (*this)[++pos];
-	}
-	
-	*flags = spaceFlags;
-	indent += SC_FOLDLEVELBASE;
-	// if completely empty line or the start of a comment...
-	if (isspace(ch) || (pfnIsCommentLeader && (*pfnIsCommentLeader)(*this, pos, end-pos)) )
-		return indent | SC_FOLDLEVELWHITEFLAG;
-	else
-		return indent;
-}
-
-void WindowAccessor::IndicatorFill(int start, int end, int indicator, int value) {
-	Platform::SendScintilla(id, SCI_SETINDICATORCURRENT, indicator);
-	if (value) {
-		Platform::SendScintilla(id, SCI_SETINDICATORVALUE, value);
-		Platform::SendScintilla(id, SCI_INDICATORFILLRANGE, start, end - start);
-	} else {
-		Platform::SendScintilla(id, SCI_INDICATORCLEARRANGE, start, end - start);
-	}
-}
diff --git a/Pythonwin/Scintilla/src/XPM.cxx b/Pythonwin/Scintilla/src/XPM.cxx
index 7fc05bb9b..364523dd8 100644
--- a/Pythonwin/Scintilla/src/XPM.cxx
+++ b/Pythonwin/Scintilla/src/XPM.cxx
@@ -5,82 +5,98 @@
 // Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <string.h>
-#include <stdlib.h>
+#include <cstdlib>
+#include <cstring>
+
+#include <stdexcept>
+#include <string_view>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <iterator>
+#include <memory>
 
 #include "Platform.h"
 
 #include "XPM.h"
 
-#ifdef SCI_NAMESPACE
 using namespace Scintilla;
-#endif
 
-static const char *NextField(const char *s) {
+namespace {
+
+const char *NextField(const char *s) noexcept {
 	// In case there are leading spaces in the string
-	while (*s && *s == ' ') {
+	while (*s == ' ') {
 		s++;
 	}
 	while (*s && *s != ' ') {
 		s++;
 	}
-	while (*s && *s == ' ') {
+	while (*s == ' ') {
 		s++;
 	}
 	return s;
 }
 
 // Data lines in XPM can be terminated either with NUL or "
-static size_t MeasureLength(const char *s) {
+size_t MeasureLength(const char *s) noexcept {
 	size_t i = 0;
 	while (s[i] && (s[i] != '\"'))
 		i++;
 	return i;
 }
 
-ColourAllocated XPM::ColourFromCode(int ch) {
-	return colourCodeTable[ch]->allocated;
-#ifdef SLOW
-	for (int i=0; i<nColours; i++) {
-		if (codes[i] == ch) {
-			return colours[i].allocated;
-		}
-	}
-	return colours[0].allocated;
-#endif
+unsigned int ValueOfHex(const char ch) noexcept {
+	if (ch >= '0' && ch <= '9')
+		return ch - '0';
+	else if (ch >= 'A' && ch <= 'F')
+		return ch - 'A' + 10;
+	else if (ch >= 'a' && ch <= 'f')
+		return ch - 'a' + 10;
+	else
+		return 0;
+}
+
+ColourDesired ColourFromHex(const char *val) noexcept {
+	const unsigned int r = ValueOfHex(val[0]) * 16 + ValueOfHex(val[1]);
+	const unsigned int g = ValueOfHex(val[2]) * 16 + ValueOfHex(val[3]);
+	const unsigned int b = ValueOfHex(val[4]) * 16 + ValueOfHex(val[5]);
+	return ColourDesired(r, g, b);
+}
+
 }
 
-void XPM::FillRun(Surface *surface, int code, int startX, int y, int x) {
+
+ColourDesired XPM::ColourFromCode(int ch) const noexcept {
+	return colourCodeTable[ch];
+}
+
+void XPM::FillRun(Surface *surface, int code, int startX, int y, int x) const {
 	if ((code != codeTransparent) && (startX != x)) {
-		PRectangle rc(startX, y, x, y+1);
+		const PRectangle rc = PRectangle::FromInts(startX, y, x, y + 1);
 		surface->FillRectangle(rc, ColourFromCode(code));
 	}
 }
 
-XPM::XPM(const char *textForm) :
-	data(0), codes(0), colours(0), lines(0) {
+XPM::XPM(const char *textForm) {
 	Init(textForm);
 }
 
-XPM::XPM(const char * const *linesForm) :
-	data(0), codes(0), colours(0), lines(0) {
+XPM::XPM(const char *const *linesForm) {
 	Init(linesForm);
 }
 
 XPM::~XPM() {
-	Clear();
 }
 
 void XPM::Init(const char *textForm) {
-	Clear();
 	// Test done is two parts to avoid possibility of overstepping the memory
 	// if memcmp implemented strangely. Must be 4 bytes at least at destination.
 	if ((0 == memcmp(textForm, "/* X", 4)) && (0 == memcmp(textForm, "/* XPM */", 9))) {
 		// Build the lines form out of the text form
-		const char **linesForm = LinesFormFromTextForm(textForm);
-		if (linesForm != 0) {
-			Init(linesForm);
-			delete []linesForm;
+		std::vector<const char *> linesForm = LinesFormFromTextForm(textForm);
+		if (!linesForm.empty()) {
+			Init(&linesForm[0]);
 		}
 	} else {
 		// It is really in line form
@@ -88,23 +104,21 @@ void XPM::Init(const char *textForm) {
 	}
 }
 
-void XPM::Init(const char * const *linesForm) {
-	Clear();
+void XPM::Init(const char *const *linesForm) {
 	height = 1;
 	width = 1;
 	nColours = 1;
-	data = NULL;
+	pixels.clear();
 	codeTransparent = ' ';
-	codes = NULL;
-	colours = NULL;
-	lines = NULL;
 	if (!linesForm)
 		return;
 
+	std::fill(colourCodeTable, std::end(colourCodeTable), ColourDesired(0));
 	const char *line0 = linesForm[0];
 	width = atoi(line0);
 	line0 = NextField(line0);
 	height = atoi(line0);
+	pixels.resize(width*height);
 	line0 = NextField(line0);
 	nColours = atoi(line0);
 	line0 = NextField(line0);
@@ -112,84 +126,40 @@ void XPM::Init(const char * const *linesForm) {
 		// Only one char per pixel is supported
 		return;
 	}
-	codes = new char[nColours];
-	colours = new ColourPair[nColours];
-
-	int strings = 1+height+nColours;
-	lines = new char *[strings];
-	size_t allocation = 0;
-	for (int i=0; i<strings; i++) {
-		allocation += MeasureLength(linesForm[i]) + 1;
-	}
-	data = new char[allocation];
-	char *nextBit = data;
-	for (int j=0; j<strings; j++) {
-		lines[j] = nextBit;
-		size_t len = MeasureLength(linesForm[j]);
-		memcpy(nextBit, linesForm[j], len);
-		nextBit += len;
-		*nextBit++ = '\0';
-	}
-
-	for (int code=0; code<256; code++) {
-		colourCodeTable[code] = 0;
-	}
 
 	for (int c=0; c<nColours; c++) {
 		const char *colourDef = linesForm[c+1];
-		codes[c] = colourDef[0];
+		const char code = colourDef[0];
 		colourDef += 4;
+		ColourDesired colour(0xff, 0xff, 0xff);
 		if (*colourDef == '#') {
-			colours[c].desired.Set(colourDef);
+			colour = ColourFromHex(colourDef+1);
 		} else {
-			colours[c].desired = ColourDesired(0xff, 0xff, 0xff);
-			codeTransparent = codes[c];
+			codeTransparent = code;
 		}
-		colourCodeTable[static_cast<unsigned char>(codes[c])] = &(colours[c]);
-	}
-}
-
-void XPM::Clear() {
-	delete []data;
-	data = 0;
-	delete []codes;
-	codes = 0;
-	delete []colours;
-	colours = 0;
-	delete []lines;
-	lines = 0;
-}
-
-void XPM::RefreshColourPalette(Palette &pal, bool want) {
-	if (!data || !codes || !colours || !lines) {
-		return;
+		colourCodeTable[static_cast<unsigned char>(code)] = colour;
 	}
-	for (int i=0; i<nColours; i++) {
-		pal.WantFind(colours[i], want);
-	}
-}
 
-void XPM::CopyDesiredColours() {
-	if (!data || !codes || !colours || !lines) {
-		return;
-	}
-	for (int i=0; i<nColours; i++) {
-		colours[i].Copy();
+	for (int y=0; y<height; y++) {
+		const char *lform = linesForm[y+nColours+1];
+		const size_t len = MeasureLength(lform);
+		for (size_t x = 0; x<len; x++)
+			pixels[y * width + x] = lform[x];
 	}
 }
 
-void XPM::Draw(Surface *surface, PRectangle &rc) {
-	if (!data || !codes || !colours || !lines) {
+void XPM::Draw(Surface *surface, const PRectangle &rc) {
+	if (pixels.empty()) {
 		return;
 	}
 	// Centre the pixmap
-	int startY = rc.top + (rc.Height() - height) / 2;
-	int startX = rc.left + (rc.Width() - width) / 2;
-	for (int y=0;y<height;y++) {
+	const int startY = static_cast<int>(rc.top + (rc.Height() - height) / 2);
+	const int startX = static_cast<int>(rc.left + (rc.Width() - width) / 2);
+	for (int y=0; y<height; y++) {
 		int prevCode = 0;
 		int xStartRun = 0;
 		for (int x=0; x<width; x++) {
-			int code = lines[y+nColours+1][x];
+			const int code = pixels[y * width + x];
 			if (code != prevCode) {
 				FillRun(surface, prevCode, startX + xStartRun, startY + y, startX + x);
 				xStartRun = x;
@@ -200,16 +170,31 @@ void XPM::Draw(Surface *surface, PRectangle &rc) {
 	}
 }
 
-const char **XPM::LinesFormFromTextForm(const char *textForm) {
+void XPM::PixelAt(int x, int y, ColourDesired &colour, bool &transparent) const noexcept {
+	if (pixels.empty() || (x<0) || (x >= width) || (y<0) || (y >= height)) {
+		colour = ColourDesired(0);
+		transparent = true;
+		return;
+	}
+	const int code = pixels[y * width + x];
+	transparent = code == codeTransparent;
+	if (transparent) {
+		colour = ColourDesired(0);
+	} else {
+		colour = ColourFromCode(code);
+	}
+}
+
+std::vector<const char *> XPM::LinesFormFromTextForm(const char *textForm) {
 	// Build the lines form out of the text form
-	const char **linesForm = 0;
+	std::vector<const char *> linesForm;
 	int countQuotes = 0;
 	int strings=1;
 	int j=0;
 	for (; countQuotes < (2*strings) && textForm[j] != '\0'; j++) {
 		if (textForm[j] == '\"') {
 			if (countQuotes == 0) {
-				// First field: width, height, number of colors, chars per pixel
+				// First field: width, height, number of colours, chars per pixel
 				const char *line0 = textForm + j + 1;
 				// Skip width
 				line0 = NextField(line0);
@@ -218,107 +203,135 @@ const char **XPM::LinesFormFromTextForm(const char *textForm) {
 				line0 = NextField(line0);
 				// Add 1 line for each colour
 				strings += atoi(line0);
-				linesForm = new const char *[strings];
-				if (linesForm == 0) {
-					break;	// Memory error!
-				}
 			}
 			if (countQuotes / 2 >= strings) {
-				break;	// Bad height or number of colors!
+				break;	// Bad height or number of colours!
 			}
 			if ((countQuotes & 1) == 0) {
-				linesForm[countQuotes / 2] = textForm + j + 1;
+				linesForm.push_back(textForm + j + 1);
 			}
 			countQuotes++;
 		}
 	}
 	if (textForm[j] == '\0' || countQuotes / 2 > strings) {
-		// Malformed XPM! Height + number of colors too high or too low
-		delete []linesForm;
-		linesForm = 0;
+		// Malformed XPM! Height + number of colours too high or too low
+		linesForm.clear();
 	}
 	return linesForm;
 }
 
-// In future, may want to minimize search time by sorting and using a binary search.
+RGBAImage::RGBAImage(int width_, int height_, float scale_, const unsigned char *pixels_) :
+	height(height_), width(width_), scale(scale_) {
+	if (pixels_) {
+		pixelBytes.assign(pixels_, pixels_ + CountBytes());
+	} else {
+		pixelBytes.resize(CountBytes());
+	}
+}
+
+RGBAImage::RGBAImage(const XPM &xpm) {
+	height = xpm.GetHeight();
+	width = xpm.GetWidth();
+	scale = 1;
+	pixelBytes.resize(CountBytes());
+	for (int y=0; y<height; y++) {
+		for (int x=0; x<width; x++) {
+			ColourDesired colour;
+			bool transparent = false;
+			xpm.PixelAt(x, y, colour, transparent);
+			SetPixel(x, y, colour, transparent ? 0 : 255);
+		}
+	}
+}
+
+RGBAImage::~RGBAImage() {
+}
+
+int RGBAImage::CountBytes() const noexcept {
+	return width * height * 4;
+}
 
-XPMSet::XPMSet() : set(0), len(0), maximum(0), height(-1), width(-1) {
+const unsigned char *RGBAImage::Pixels() const noexcept {
+	return &pixelBytes[0];
 }
 
-XPMSet::~XPMSet() {
-	Clear();
+void RGBAImage::SetPixel(int x, int y, ColourDesired colour, int alpha) noexcept {
+	unsigned char *pixel = &pixelBytes[0] + (y*width+x) * 4;
+	// RGBA
+	pixel[0] = colour.GetRed();
+	pixel[1] = colour.GetGreen();
+	pixel[2] = colour.GetBlue();
+	pixel[3] = static_cast<unsigned char>(alpha);
 }
 
-void XPMSet::Clear() {
-	for (int i = 0; i < len; i++) {
-		delete set[i];
+// Transform a block of pixels from RGBA to BGRA with premultiplied alpha.
+// Used for DrawRGBAImage on some platforms.
+void RGBAImage::BGRAFromRGBA(unsigned char *pixelsBGRA, const unsigned char *pixelsRGBA, size_t count) noexcept {
+	for (size_t i = 0; i < count; i++) {
+		const unsigned char alpha = pixelsRGBA[3];
+		// Input is RGBA, output is BGRA with premultiplied alpha
+		pixelsBGRA[2] = pixelsRGBA[0] * alpha / 255;
+		pixelsBGRA[1] = pixelsRGBA[1] * alpha / 255;
+		pixelsBGRA[0] = pixelsRGBA[2] * alpha / 255;
+		pixelsBGRA[3] = alpha;
+		pixelsRGBA += bytesPerPixel;
+		pixelsBGRA += bytesPerPixel;
 	}
-	delete []set;
-	set = 0;
-	len = 0;
-	maximum = 0;
-	height = -1;
-	width = -1;
 }
 
-void XPMSet::Add(int id, const char *textForm) {
-	// Invalidate cached dimensions
+RGBAImageSet::RGBAImageSet() : height(-1), width(-1) {
+}
+
+RGBAImageSet::~RGBAImageSet() {
+	Clear();
+}
+
+/// Remove all images.
+void RGBAImageSet::Clear() noexcept {
+	images.clear();
 	height = -1;
 	width = -1;
+}
 
-	// Replace if this id already present
-	for (int i = 0; i < len; i++) {
-		if (set[i]->GetId() == id) {
-			set[i]->Init(textForm);
-			set[i]->CopyDesiredColours();
-			return;
-		}
-	}
-
-	// Not present, so add to end
-	XPM *pxpm = new XPM(textForm);
-	if (pxpm) {
-		pxpm->SetId(id);
-		pxpm->CopyDesiredColours();
-		if (len == maximum) {
-			maximum += 64;
-			XPM **setNew = new XPM *[maximum];
-			for (int i = 0; i < len; i++) {
-				setNew[i] = set[i];
-			}
-			delete []set;
-			set = setNew;
-		}
-		set[len] = pxpm;
-		len++;
+/// Add an image.
+void RGBAImageSet::Add(int ident, RGBAImage *image) {
+	ImageMap::iterator it=images.find(ident);
+	if (it == images.end()) {
+		images[ident] = std::unique_ptr<RGBAImage>(image);
+	} else {
+		it->second.reset(image);
 	}
+	height = -1;
+	width = -1;
 }
 
-XPM *XPMSet::Get(int id) {
-	for (int i = 0; i < len; i++) {
-		if (set[i]->GetId() == id) {
-			return set[i];
-		}
+/// Get image by id.
+RGBAImage *RGBAImageSet::Get(int ident) {
+	ImageMap::iterator it = images.find(ident);
+	if (it != images.end()) {
+		return it->second.get();
 	}
-	return 0;
+	return nullptr;
 }
 
-int XPMSet::GetHeight() {
+/// Give the largest height of the set.
+int RGBAImageSet::GetHeight() const {
 	if (height < 0) {
-		for (int i = 0; i < len; i++) {
-			if (height < set[i]->GetHeight()) {
-				height = set[i]->GetHeight();
+		for (const std::pair<const int, std::unique_ptr<RGBAImage>> &image : images) {
+			if (height < image.second->GetHeight()) {
+				height = image.second->GetHeight();
 			}
 		}
 	}
 	return (height > 0) ? height : 0;
 }
 
-int XPMSet::GetWidth() {
+/// Give the largest width of the set.
+int RGBAImageSet::GetWidth() const {
 	if (width < 0) {
-		for (int i = 0; i < len; i++) {
-			if (width < set[i]->GetWidth()) {
-				width = set[i]->GetWidth();
+		for (const std::pair<const int, std::unique_ptr<RGBAImage>> &image : images) {
+			if (width < image.second->GetWidth()) {
+				width = image.second->GetWidth();
 			}
 		}
 	}
diff --git a/Pythonwin/Scintilla/src/XPM.h b/Pythonwin/Scintilla/src/XPM.h
index 0ee68c072..1f72ba738 100644
--- a/Pythonwin/Scintilla/src/XPM.h
+++ b/Pythonwin/Scintilla/src/XPM.h
@@ -1,6 +1,6 @@
 // Scintilla source code edit control
 /** @file XPM.h
- ** Define a class that holds data in the X Pixmap (XPM) format.
+ ** Define a classes to hold image data in the X Pixmap (XPM) and RGBA formats.
  **/
 // Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
@@ -8,73 +8,95 @@
 #ifndef XPM_H
 #define XPM_H
 
-#ifdef SCI_NAMESPACE
 namespace Scintilla {
-#endif
 
 /**
  * Hold a pixmap in XPM format.
  */
 class XPM {
-	int id;		// Assigned by container
-	int height;
-	int width;
-	int nColours;
-	char *data;
-	char codeTransparent;
-	char *codes;
-	ColourPair *colours;
-	ColourAllocated ColourFromCode(int ch);
-	void FillRun(Surface *surface, int code, int startX, int y, int x);
-	char **lines;
-	ColourPair *colourCodeTable[256];
+	int height=1;
+	int width=1;
+	int nColours=1;
+	std::vector<unsigned char> pixels;
+	ColourDesired colourCodeTable[256];
+	char codeTransparent=' ';
+	ColourDesired ColourFromCode(int ch) const noexcept;
+	void FillRun(Surface *surface, int code, int startX, int y, int x) const;
 public:
-	XPM(const char *textForm);
-	XPM(const char * const *linesForm);
+	explicit XPM(const char *textForm);
+	explicit XPM(const char *const *linesForm);
+	XPM(const XPM &) = default;
+	XPM(XPM &&) noexcept = default;
+	XPM &operator=(const XPM &) = default;
+	XPM &operator=(XPM &&) noexcept = default;
 	~XPM();
 	void Init(const char *textForm);
-	void Init(const char * const *linesForm);
-	void Clear();
-	/// Similar to same named method in ViewStyle:
-	void RefreshColourPalette(Palette &pal, bool want);
-	/// No palette used, so just copy the desired colours to the allocated colours
-	void CopyDesiredColours();
+	void Init(const char *const *linesForm);
 	/// Decompose image into runs and use FillRectangle for each run
-	void Draw(Surface *surface, PRectangle &rc);
-	char **InLinesForm() { return lines; }
-	void SetId(int id_) { id = id_; }
-	int GetId() { return id; }
-	int GetHeight() { return height; }
-	int GetWidth() { return width; }
-	static const char **LinesFormFromTextForm(const char *textForm);
+	void Draw(Surface *surface, const PRectangle &rc);
+	int GetHeight() const noexcept { return height; }
+	int GetWidth() const noexcept { return width; }
+	void PixelAt(int x, int y, ColourDesired &colour, bool &transparent) const noexcept;
+private:
+	static std::vector<const char *>LinesFormFromTextForm(const char *textForm);
 };
 
 /**
- * A collection of pixmaps indexed by integer id.
+ * A translucent image stored as a sequence of RGBA bytes.
  */
-class XPMSet {
-	XPM **set;	///< The stored XPMs.
-	int len;	///< Current number of XPMs.
-	int maximum;	///< Current maximum number of XPMs, increased by steps if reached.
-	int height;	///< Memorize largest height of the set.
-	int width;	///< Memorize largest width of the set.
+class RGBAImage {
+	int height;
+	int width;
+	float scale;
+	std::vector<unsigned char> pixelBytes;
 public:
-	XPMSet();
-	~XPMSet();
-	/// Remove all XPMs.
-	void Clear();
-	/// Add a XPM.
-	void Add(int id, const char *textForm);
-	/// Get XPM by id.
-	XPM *Get(int id);
+	static constexpr size_t bytesPerPixel = 4;
+	RGBAImage(int width_, int height_, float scale_, const unsigned char *pixels_);
+	explicit RGBAImage(const XPM &xpm);
+	RGBAImage(const RGBAImage &) = default;
+	RGBAImage(RGBAImage &&) noexcept = default;
+	RGBAImage &operator=(const RGBAImage &) = default;
+	RGBAImage &operator=(RGBAImage &&) noexcept = default;
+	virtual ~RGBAImage();
+	int GetHeight() const noexcept { return height; }
+	int GetWidth() const noexcept { return width; }
+	float GetScale() const noexcept { return scale; }
+	float GetScaledHeight() const noexcept { return height / scale; }
+	float GetScaledWidth() const noexcept { return width / scale; }
+	int CountBytes() const noexcept;
+	const unsigned char *Pixels() const noexcept;
+	void SetPixel(int x, int y, ColourDesired colour, int alpha) noexcept;
+	static void BGRAFromRGBA(unsigned char *pixelsBGRA, const unsigned char *pixelsRGBA, size_t count) noexcept;
+};
+
+/**
+ * A collection of RGBAImage pixmaps indexed by integer id.
+ */
+class RGBAImageSet {
+	typedef std::map<int, std::unique_ptr<RGBAImage>> ImageMap;
+	ImageMap images;
+	mutable int height;	///< Memorize largest height of the set.
+	mutable int width;	///< Memorize largest width of the set.
+public:
+	RGBAImageSet();
+	// Deleted so RGBAImageSet objects can not be copied.
+	RGBAImageSet(const RGBAImageSet &) = delete;
+	RGBAImageSet(RGBAImageSet &&) = delete;
+	RGBAImageSet &operator=(const RGBAImageSet &) = delete;
+	RGBAImageSet &operator=(RGBAImageSet &&) = delete;
+	~RGBAImageSet();
+	/// Remove all images.
+	void Clear() noexcept;
+	/// Add an image.
+	void Add(int ident, RGBAImage *image);
+	/// Get image by id.
+	RGBAImage *Get(int ident);
 	/// Give the largest height of the set.
-	int GetHeight();
+	int GetHeight() const;
 	/// Give the largest width of the set.
-	int GetWidth();
+	int GetWidth() const;
 };
 
-#ifdef SCI_NAMESPACE
 }
-#endif
 
 #endif
diff --git a/Pythonwin/Scintilla/update.bat b/Pythonwin/Scintilla/update.bat
deleted file mode 100755
index dac9b850c..000000000
--- a/Pythonwin/Scintilla/update.bat
+++ /dev/null
@@ -1,4 +0,0 @@
-xcopy /Y /U \src\scintilla\* . 
-xcopy /Y /U \src\scintilla\src\* src\. 
-xcopy /Y /U \src\scintilla\include\* include\. 
-xcopy /Y /U \src\scintilla\win32\* win32\. 
diff --git a/Pythonwin/Scintilla/win32/DepGen.py b/Pythonwin/Scintilla/win32/DepGen.py
new file mode 100644
index 000000000..4ab6f6f31
--- /dev/null
+++ b/Pythonwin/Scintilla/win32/DepGen.py
@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+# DepGen.py - produce a make dependencies file for Scintilla
+# Copyright 2019 by Neil Hodgson <neilh@scintilla.org>
+# The License.txt file describes the conditions under which this software may be distributed.
+# Requires Python 3.6 or later
+
+import sys
+
+sys.path.append("..")
+
+from scripts import Dependencies
+
+topComment = "# Created by DepGen.py. To recreate, run DepGen.py.\n"
+
+
+def Generate():
+    sources = ["../src/*.cxx", "../lexlib/*.cxx", "../lexers/*.cxx"]
+    includes = ["../include", "../src", "../lexlib"]
+
+    # Create the dependencies file for g++
+    deps = Dependencies.FindDependencies(
+        ["../win32/*.cxx"] + sources, ["../win32"] + includes, ".o", "../win32/"
+    )
+
+    # Add ScintillaBaseL as the same as ScintillaBase
+    deps = Dependencies.InsertSynonym(deps, "ScintillaBase.o", "ScintillaBaseL.o")
+
+    # Add CatalogueL as the same as Catalogue
+    deps = Dependencies.InsertSynonym(deps, "Catalogue.o", "CatalogueL.o")
+
+    Dependencies.UpdateDependencies("../win32/deps.mak", deps, topComment)
+
+    # Create the dependencies file for MSVC
+
+    # Place the objects in $(DIR_O) and change extension from ".o" to ".obj"
+    deps = [
+        ["$(DIR_O)/" + Dependencies.PathStem(obj) + ".obj", headers]
+        for obj, headers in deps
+    ]
+
+    Dependencies.UpdateDependencies("../win32/nmdeps.mak", deps, topComment)
+
+
+if __name__ == "__main__":
+    Generate()
diff --git a/Pythonwin/Scintilla/win32/HanjaDic.cxx b/Pythonwin/Scintilla/win32/HanjaDic.cxx
new file mode 100644
index 000000000..805fc3641
--- /dev/null
+++ b/Pythonwin/Scintilla/win32/HanjaDic.cxx
@@ -0,0 +1,128 @@
+// Scintilla source code edit control
+/** @file HanjaDic.cxx
+ ** Korean Hanja Dictionary
+ ** Convert between Korean Hanja and Hangul by COM interface.
+ **/
+// Copyright 2015 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#include <string>
+#include <string_view>
+
+#include <windows.h>
+
+#include "UniConversion.h"
+#include "HanjaDic.h"
+
+namespace Scintilla {
+
+namespace HanjaDict {
+
+interface IRadical;
+interface IHanja;
+interface IStrokes;
+
+typedef enum { HANJA_UNKNOWN = 0, HANJA_K0 = 1, HANJA_K1 = 2, HANJA_OTHER = 3 } HANJA_TYPE;
+
+interface IHanjaDic : IUnknown {
+	STDMETHOD(OpenMainDic)();
+	STDMETHOD(CloseMainDic)();
+	STDMETHOD(GetHanjaWords)(BSTR bstrHangul, SAFEARRAY* ppsaHanja, VARIANT_BOOL* pfFound);
+	STDMETHOD(GetHanjaChars)(unsigned short wchHangul, BSTR* pbstrHanjaChars, VARIANT_BOOL* pfFound);
+	STDMETHOD(HanjaToHangul)(BSTR bstrHanja, BSTR* pbstrHangul);
+	STDMETHOD(GetHanjaType)(unsigned short wchHanja, HANJA_TYPE* pHanjaType);
+	STDMETHOD(GetHanjaSense)(unsigned short wchHanja, BSTR* pbstrSense);
+	STDMETHOD(GetRadicalID)(short SeqNumOfRadical, short* pRadicalID, unsigned short* pwchRadical);
+	STDMETHOD(GetRadical)(short nRadicalID, IRadical** ppIRadical);
+	STDMETHOD(RadicalIDToHanja)(short nRadicalID, unsigned short* pwchRadical);
+	STDMETHOD(GetHanja)(unsigned short wchHanja, IHanja** ppIHanja);
+	STDMETHOD(GetStrokes)(short nStrokes, IStrokes** ppIStrokes);
+	STDMETHOD(OpenDefaultCustomDic)();
+	STDMETHOD(OpenCustomDic)(BSTR bstrPath, long* plUdr);
+	STDMETHOD(CloseDefaultCustomDic)();
+	STDMETHOD(CloseCustomDic)(long lUdr);
+	STDMETHOD(CloseAllCustomDics)();
+	STDMETHOD(GetDefaultCustomHanjaWords)(BSTR bstrHangul, SAFEARRAY** ppsaHanja, VARIANT_BOOL* pfFound);
+	STDMETHOD(GetCustomHanjaWords)(long lUdr, BSTR bstrHangul, SAFEARRAY** ppsaHanja, VARIANT_BOOL* pfFound);
+	STDMETHOD(PutDefaultCustomHanjaWord)(BSTR bstrHangul, BSTR bstrHanja);
+	STDMETHOD(PutCustomHanjaWord)(long lUdr, BSTR bstrHangul, BSTR bstrHanja);
+	STDMETHOD(MaxNumOfRadicals)(short* pVal);
+	STDMETHOD(MaxNumOfStrokes)(short* pVal);
+	STDMETHOD(DefaultCustomDic)(long* pVal);
+	STDMETHOD(DefaultCustomDic)(long pVal);
+	STDMETHOD(MaxHanjaType)(HANJA_TYPE* pHanjaType);
+	STDMETHOD(MaxHanjaType)(HANJA_TYPE pHanjaType);
+};
+
+extern "C" const GUID __declspec(selectany) IID_IHanjaDic =
+{ 0xad75f3ac, 0x18cd, 0x48c6, { 0xa2, 0x7d, 0xf1, 0xe9, 0xa7, 0xdc, 0xe4, 0x32 } };
+
+class HanjaDic {
+private:
+	HRESULT hr;
+	CLSID CLSID_HanjaDic;
+
+public:
+	IHanjaDic *HJinterface;
+
+	HanjaDic() : HJinterface(nullptr) {
+		hr = CLSIDFromProgID(OLESTR("mshjdic.hanjadic"), &CLSID_HanjaDic);
+		if (SUCCEEDED(hr)) {
+			hr = CoCreateInstance(CLSID_HanjaDic, nullptr,
+					CLSCTX_INPROC_SERVER, IID_IHanjaDic,
+					(LPVOID *)& HJinterface);
+			if (SUCCEEDED(hr)) {
+				hr = HJinterface->OpenMainDic();
+			}
+		}
+	}
+
+	~HanjaDic() {
+		if (SUCCEEDED(hr)) {
+			hr = HJinterface->CloseMainDic();
+			HJinterface->Release();
+		}
+	}
+
+	bool HJdictAvailable() {
+		return SUCCEEDED(hr);
+	}
+
+	bool IsHanja(int hanja) {
+		HANJA_TYPE hanjaType;
+		hr = HJinterface->GetHanjaType(static_cast<unsigned short>(hanja), &hanjaType);
+		if (SUCCEEDED(hr)) {
+			return (hanjaType > 0);
+		}
+		return false;
+	}
+};
+
+int GetHangulOfHanja(wchar_t *inout) {
+	// Convert every hanja to hangul.
+	// Return the number of characters converted.
+	int changed = 0;
+	HanjaDic dict;
+	if (dict.HJdictAvailable()) {
+		const size_t len = wcslen(inout);
+		wchar_t conv[UTF8MaxBytes] = {0};
+		BSTR bstrHangul = SysAllocString(conv);
+		for (size_t i=0; i<len; i++) {
+			if (dict.IsHanja(static_cast<int>(inout[i]))) { // Pass hanja only!
+				conv[0] = inout[i];
+				BSTR bstrHanja = SysAllocString(conv);
+				const HRESULT hr = dict.HJinterface->HanjaToHangul(bstrHanja, &bstrHangul);
+				if (SUCCEEDED(hr)) {
+					inout[i] = static_cast<wchar_t>(bstrHangul[0]);
+					changed += 1;
+				}
+				SysFreeString(bstrHanja);
+			}
+		}
+		SysFreeString(bstrHangul);
+	}
+	return changed;
+}
+
+}
+}
diff --git a/Pythonwin/Scintilla/win32/HanjaDic.h b/Pythonwin/Scintilla/win32/HanjaDic.h
new file mode 100644
index 000000000..3aafdf8ed
--- /dev/null
+++ b/Pythonwin/Scintilla/win32/HanjaDic.h
@@ -0,0 +1,22 @@
+// Scintilla source code edit control
+/** @file HanjaDic.h
+ ** Korean Hanja Dictionary
+ ** Convert between Korean Hanja and Hangul by COM interface.
+ **/
+// Copyright 2015 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef HANJADIC_H
+#define HANJADIC_H
+
+namespace Scintilla {
+
+namespace HanjaDict {
+
+int GetHangulOfHanja(wchar_t *inout);
+
+}
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/win32/Margin.cur b/Pythonwin/Scintilla/win32/Margin.cur
deleted file mode 100644
index 9e0e79066..000000000
Binary files a/Pythonwin/Scintilla/win32/Margin.cur and /dev/null differ
diff --git a/Pythonwin/Scintilla/win32/PlatWin.cxx b/Pythonwin/Scintilla/win32/PlatWin.cxx
index 7345fc8f2..1cae686a2 100644
--- a/Pythonwin/Scintilla/win32/PlatWin.cxx
+++ b/Pythonwin/Scintilla/win32/PlatWin.cxx
@@ -5,871 +5,2208 @@
 // Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <time.h>
-
-#define _WIN32_WINNT  0x0400
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <cstdio>
+#include <cstdarg>
+#include <ctime>
+#include <cmath>
+#include <climits>
+
+#include <string_view>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <iterator>
+#include <memory>
+#include <mutex>
+
+// Want to use std::min and std::max so don't want Windows.h version of min and max
+#if !defined(NOMINMAX)
+#define NOMINMAX
+#endif
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0500
+#undef WINVER
+#define WINVER 0x0500
 #include <windows.h>
 #include <commctrl.h>
 #include <richedit.h>
 #include <windowsx.h>
 
-#include "Platform.h"
-#include "PlatformRes.h"
-#include "UniConversion.h"
-#include "XPM.h"
+#if !defined(DISABLE_D2D)
+#define USE_D2D 1
+#endif
 
-#ifndef IDC_HAND
-#define IDC_HAND MAKEINTRESOURCE(32649)
+#if defined(USE_D2D)
+#include <d2d1.h>
+#include <dwrite.h>
 #endif
 
-// Take care of 32/64 bit pointers
-#ifdef GetWindowLongPtr
-static void *PointerFromWindow(HWND hWnd) {
-	return reinterpret_cast<void *>(::GetWindowLongPtr(hWnd, 0));
-}
-static void SetWindowPointer(HWND hWnd, void *ptr) {
-	::SetWindowLongPtr(hWnd, 0, reinterpret_cast<LONG_PTR>(ptr));
-}
-#else
-static void *PointerFromWindow(HWND hWnd) {
-	return reinterpret_cast<void *>(::GetWindowLong(hWnd, 0));
-}
-static void SetWindowPointer(HWND hWnd, void *ptr) {
-	::SetWindowLong(hWnd, 0, reinterpret_cast<LONG>(ptr));
-}
+#include "Platform.h"
+#include "XPM.h"
+#include "UniConversion.h"
+#include "DBCS.h"
+#include "FontQuality.h"
+
+#include "PlatWin.h"
 
-#ifndef GWLP_USERDATA
-#define GWLP_USERDATA GWL_USERDATA
+#ifndef SPI_GETFONTSMOOTHINGCONTRAST
+#define SPI_GETFONTSMOOTHINGCONTRAST	0x200C
 #endif
 
-#ifndef GWLP_WNDPROC
-#define GWLP_WNDPROC GWL_WNDPROC
+#ifndef LOAD_LIBRARY_SEARCH_SYSTEM32
+#define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800
 #endif
 
-#ifndef LONG_PTR
-#define LONG_PTR LONG
+// __uuidof is a Microsoft extension but makes COM code neater, so disable warning
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wlanguage-extension-token"
 #endif
 
-static LONG_PTR SetWindowLongPtr(HWND hWnd, int nIndex, LONG_PTR dwNewLong) {
-	return ::SetWindowLong(hWnd, nIndex, dwNewLong);
-}
+namespace Scintilla {
 
-static LONG_PTR GetWindowLongPtr(HWND hWnd, int nIndex) {
-	return ::GetWindowLong(hWnd, nIndex);
-}
-#endif
+UINT CodePageFromCharSet(DWORD characterSet, UINT documentCodePage) noexcept;
+
+#if defined(USE_D2D)
+IDWriteFactory *pIDWriteFactory = nullptr;
+ID2D1Factory *pD2DFactory = nullptr;
+IDWriteRenderingParams *defaultRenderingParams = nullptr;
+IDWriteRenderingParams *customClearTypeRenderingParams = nullptr;
+D2D1_DRAW_TEXT_OPTIONS d2dDrawTextOptions = D2D1_DRAW_TEXT_OPTIONS_NONE;
+
+static HMODULE hDLLD2D {};
+static HMODULE hDLLDWrite {};
+
+void LoadD2DOnce() noexcept {
+	DWORD loadLibraryFlags = 0;
+	HMODULE kernel32 = ::GetModuleHandleW(L"kernel32.dll");
+	if (kernel32) {
+		if (::GetProcAddress(kernel32, "SetDefaultDllDirectories")) {
+			// Availability of SetDefaultDllDirectories implies Windows 8+ or
+			// that KB2533623 has been installed so LoadLibraryEx can be called
+			// with LOAD_LIBRARY_SEARCH_SYSTEM32.
+			loadLibraryFlags = LOAD_LIBRARY_SEARCH_SYSTEM32;
+		}
+	}
+
+	typedef HRESULT (WINAPI *D2D1CFSig)(D2D1_FACTORY_TYPE factoryType, REFIID riid,
+		CONST D2D1_FACTORY_OPTIONS *pFactoryOptions, IUnknown **factory);
+	typedef HRESULT (WINAPI *DWriteCFSig)(DWRITE_FACTORY_TYPE factoryType, REFIID iid,
+		IUnknown **factory);
+
+	hDLLD2D = ::LoadLibraryEx(TEXT("D2D1.DLL"), 0, loadLibraryFlags);
+	D2D1CFSig fnD2DCF = DLLFunction<D2D1CFSig>(hDLLD2D, "D2D1CreateFactory");
+	if (fnD2DCF) {
+		// A single threaded factory as Scintilla always draw on the GUI thread
+		fnD2DCF(D2D1_FACTORY_TYPE_SINGLE_THREADED,
+			__uuidof(ID2D1Factory),
+			nullptr,
+			reinterpret_cast<IUnknown**>(&pD2DFactory));
+	}
+	hDLLDWrite = ::LoadLibraryEx(TEXT("DWRITE.DLL"), 0, loadLibraryFlags);
+	DWriteCFSig fnDWCF = DLLFunction<DWriteCFSig>(hDLLDWrite, "DWriteCreateFactory");
+	if (fnDWCF) {
+		const GUID IID_IDWriteFactory2 = // 0439fc60-ca44-4994-8dee-3a9af7b732ec
+		{ 0x0439fc60, 0xca44, 0x4994, { 0x8d, 0xee, 0x3a, 0x9a, 0xf7, 0xb7, 0x32, 0xec } };
+
+		const HRESULT hr = fnDWCF(DWRITE_FACTORY_TYPE_SHARED,
+			IID_IDWriteFactory2,
+			reinterpret_cast<IUnknown**>(&pIDWriteFactory));
+		if (SUCCEEDED(hr)) {
+			// D2D1_DRAW_TEXT_OPTIONS_ENABLE_COLOR_FONT
+			d2dDrawTextOptions = static_cast<D2D1_DRAW_TEXT_OPTIONS>(0x00000004);
+		} else {
+			fnDWCF(DWRITE_FACTORY_TYPE_SHARED,
+				__uuidof(IDWriteFactory),
+				reinterpret_cast<IUnknown**>(&pIDWriteFactory));
+		}
+	}
 
-typedef BOOL (WINAPI *AlphaBlendSig)(HDC, int, int, int, int, HDC, int, int, int, int, BLENDFUNCTION);
+	if (pIDWriteFactory) {
+		const HRESULT hr = pIDWriteFactory->CreateRenderingParams(&defaultRenderingParams);
+		if (SUCCEEDED(hr)) {
+			unsigned int clearTypeContrast;
+			if (::SystemParametersInfo(SPI_GETFONTSMOOTHINGCONTRAST, 0, &clearTypeContrast, 0)) {
 
-static CRITICAL_SECTION crPlatformLock;
-static HINSTANCE hinstPlatformRes = 0;
-static bool onNT = false;
-static HMODULE hDLLImage = 0;
-static AlphaBlendSig AlphaBlendFn = 0;
+				FLOAT gamma;
+				if (clearTypeContrast >= 1000 && clearTypeContrast <= 2200)
+					gamma = static_cast<FLOAT>(clearTypeContrast) / 1000.0f;
+				else
+					gamma = defaultRenderingParams->GetGamma();
 
+				pIDWriteFactory->CreateCustomRenderingParams(gamma, defaultRenderingParams->GetEnhancedContrast(), defaultRenderingParams->GetClearTypeLevel(),
+					defaultRenderingParams->GetPixelGeometry(), defaultRenderingParams->GetRenderingMode(), &customClearTypeRenderingParams);
+			}
+		}
+	}
+}
 
-bool IsNT() {
-	return onNT;
+bool LoadD2D() {
+	static std::once_flag once;
+	std::call_once(once, LoadD2DOnce);
+	return pIDWriteFactory && pD2DFactory;
 }
 
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
 #endif
 
-Point Point::FromLong(long lpoint) {
-	return Point(static_cast<short>(LOWORD(lpoint)), static_cast<short>(HIWORD(lpoint)));
+struct FormatAndMetrics {
+	int technology;
+	HFONT hfont;
+#if defined(USE_D2D)
+	IDWriteTextFormat *pTextFormat;
+#endif
+	int extraFontFlag;
+	int characterSet;
+	FLOAT yAscent;
+	FLOAT yDescent;
+	FLOAT yInternalLeading;
+	FormatAndMetrics(HFONT hfont_, int extraFontFlag_, int characterSet_) noexcept :
+		technology(SCWIN_TECH_GDI), hfont(hfont_),
+#if defined(USE_D2D)
+		pTextFormat(nullptr),
+#endif
+		extraFontFlag(extraFontFlag_), characterSet(characterSet_), yAscent(2), yDescent(1), yInternalLeading(0) {
+	}
+#if defined(USE_D2D)
+	FormatAndMetrics(IDWriteTextFormat *pTextFormat_,
+	        int extraFontFlag_,
+	        int characterSet_,
+	        FLOAT yAscent_,
+	        FLOAT yDescent_,
+	        FLOAT yInternalLeading_) noexcept :
+		technology(SCWIN_TECH_DIRECTWRITE),
+		hfont{},
+		pTextFormat(pTextFormat_),
+		extraFontFlag(extraFontFlag_),
+		characterSet(characterSet_),
+		yAscent(yAscent_),
+		yDescent(yDescent_),
+		yInternalLeading(yInternalLeading_) {
+	}
+#endif
+	FormatAndMetrics(const FormatAndMetrics &) = delete;
+	FormatAndMetrics(FormatAndMetrics &&) = delete;
+	FormatAndMetrics &operator=(const FormatAndMetrics &) = delete;
+	FormatAndMetrics &operator=(FormatAndMetrics &&) = delete;
+
+	~FormatAndMetrics() {
+		if (hfont)
+			::DeleteObject(hfont);
+#if defined(USE_D2D)
+		ReleaseUnknown(pTextFormat);
+#endif
+		extraFontFlag = 0;
+		characterSet = 0;
+		yAscent = 2;
+		yDescent = 1;
+		yInternalLeading = 0;
+	}
+	HFONT HFont() noexcept;
+};
+
+HFONT FormatAndMetrics::HFont() noexcept {
+	LOGFONTW lf = {};
+#if defined(USE_D2D)
+	if (technology == SCWIN_TECH_GDI) {
+		if (0 == ::GetObjectW(hfont, sizeof(lf), &lf)) {
+			return {};
+		}
+	} else {
+		const HRESULT hr = pTextFormat->GetFontFamilyName(lf.lfFaceName, LF_FACESIZE);
+		if (!SUCCEEDED(hr)) {
+			return {};
+		}
+		lf.lfWeight = pTextFormat->GetFontWeight();
+		lf.lfItalic = pTextFormat->GetFontStyle() == DWRITE_FONT_STYLE_ITALIC;
+		lf.lfHeight = -static_cast<int>(pTextFormat->GetFontSize());
+	}
+#else
+	if (0 == ::GetObjectW(hfont, sizeof(lf), &lf)) {
+		return {};
+	}
+#endif
+	return ::CreateFontIndirectW(&lf);
 }
 
-static RECT RectFromPRectangle(PRectangle prc) {
-	RECT rc = {prc.left, prc.top, prc.right, prc.bottom};
-	return rc;
+#ifndef CLEARTYPE_QUALITY
+#define CLEARTYPE_QUALITY 5
+#endif
+
+void *PointerFromWindow(HWND hWnd) noexcept {
+	return reinterpret_cast<void *>(::GetWindowLongPtr(hWnd, 0));
 }
 
-Palette::Palette() {
-	used = 0;
-	allowRealization = false;
-	hpal = 0;
-	size = 100;
-	entries = new ColourPair[size];
+void SetWindowPointer(HWND hWnd, void *ptr) noexcept {
+	::SetWindowLongPtr(hWnd, 0, reinterpret_cast<LONG_PTR>(ptr));
 }
 
-Palette::~Palette() {
-	Release();
-	delete []entries;
-	entries = 0;
-}
-
-void Palette::Release() {
-	used = 0;
-	if (hpal)
-		::DeleteObject(hpal);
-	hpal = 0;
-	delete []entries;
-	size = 100;
-	entries = new ColourPair[size];
-}
-
-/**
- * This method either adds a colour to the list of wanted colours (want==true)
- * or retrieves the allocated colour back to the ColourPair.
- * This is one method to make it easier to keep the code for wanting and retrieving in sync.
- */
-void Palette::WantFind(ColourPair &cp, bool want) {
-	if (want) {
-		for (int i=0; i < used; i++) {
-			if (entries[i].desired == cp.desired)
-				return;
-		}
-
-		if (used >= size) {
-			int sizeNew = size * 2;
-			ColourPair *entriesNew = new ColourPair[sizeNew];
-			for (int j=0; j<size; j++) {
-				entriesNew[j] = entries[j];
-			}
-			delete []entries;
-			entries = entriesNew;
-			size = sizeNew;
-		}
+namespace {
+
+// system DPI, same for all monitor.
+UINT uSystemDPI = USER_DEFAULT_SCREEN_DPI;
+
+using GetDpiForWindowSig = UINT(WINAPI *)(HWND hwnd);
+GetDpiForWindowSig fnGetDpiForWindow = nullptr;
+
+HMODULE hDLLShcore {};
+using GetDpiForMonitorSig = HRESULT (WINAPI *)(HMONITOR hmonitor, /*MONITOR_DPI_TYPE*/int dpiType, UINT *dpiX, UINT *dpiY);
+GetDpiForMonitorSig fnGetDpiForMonitor = nullptr;
 
-		entries[used].desired = cp.desired;
-		entries[used].allocated.Set(cp.desired.AsLong());
-		used++;
+using GetSystemMetricsForDpiSig = int(WINAPI *)(int nIndex, UINT dpi);
+GetSystemMetricsForDpiSig fnGetSystemMetricsForDpi = nullptr;
+
+using AdjustWindowRectExForDpiSig = BOOL(WINAPI *)(LPRECT lpRect, DWORD dwStyle, BOOL bMenu, DWORD dwExStyle, UINT dpi);
+AdjustWindowRectExForDpiSig fnAdjustWindowRectExForDpi = nullptr;
+
+void LoadDpiForWindow() noexcept {
+	HMODULE user32 = ::GetModuleHandleW(L"user32.dll");
+	fnGetDpiForWindow = DLLFunction<GetDpiForWindowSig>(user32, "GetDpiForWindow");
+	fnGetSystemMetricsForDpi = DLLFunction<GetSystemMetricsForDpiSig>(user32, "GetSystemMetricsForDpi");
+	fnAdjustWindowRectExForDpi = DLLFunction<AdjustWindowRectExForDpiSig>(user32, "AdjustWindowRectExForDpi");
+
+	using GetDpiForSystemSig = UINT(WINAPI *)(void);
+	GetDpiForSystemSig fnGetDpiForSystem = DLLFunction<GetDpiForSystemSig>(user32, "GetDpiForSystem");
+	if (fnGetDpiForSystem) {
+		uSystemDPI = fnGetDpiForSystem();
 	} else {
-		for (int i=0; i < used; i++) {
-			if (entries[i].desired == cp.desired) {
-				cp.allocated = entries[i].allocated;
-				return;
-			}
+		HDC hdcMeasure = ::CreateCompatibleDC({});
+		uSystemDPI = ::GetDeviceCaps(hdcMeasure, LOGPIXELSY);
+		::DeleteDC(hdcMeasure);
+	}
+
+	if (!fnGetDpiForWindow) {
+		hDLLShcore = ::LoadLibraryExW(L"shcore.dll", {}, LOAD_LIBRARY_SEARCH_SYSTEM32);
+		if (hDLLShcore) {
+			fnGetDpiForMonitor = DLLFunction<GetDpiForMonitorSig>(hDLLShcore, "GetDpiForMonitor");
 		}
-		cp.allocated.Set(cp.desired.AsLong());
 	}
 }
 
-void Palette::Allocate(Window &) {
-	if (hpal)
-		::DeleteObject(hpal);
-	hpal = 0;
+HINSTANCE hinstPlatformRes {};
 
-	if (allowRealization) {
-		char *pal = new char[sizeof(LOGPALETTE) + (used-1) * sizeof(PALETTEENTRY)];
-		LOGPALETTE *logpal = reinterpret_cast<LOGPALETTE *>(pal);
-		logpal->palVersion = 0x300;
-		logpal->palNumEntries = static_cast<WORD>(used);
-		for (int iPal=0;iPal<used;iPal++) {
-			ColourDesired desired = entries[iPal].desired;
-			logpal->palPalEntry[iPal].peRed   = static_cast<BYTE>(desired.GetRed());
-			logpal->palPalEntry[iPal].peGreen = static_cast<BYTE>(desired.GetGreen());
-			logpal->palPalEntry[iPal].peBlue  = static_cast<BYTE>(desired.GetBlue());
-			entries[iPal].allocated.Set(
-				PALETTERGB(desired.GetRed(), desired.GetGreen(), desired.GetBlue()));
-			// PC_NOCOLLAPSE means exact colours allocated even when in background this means other windows
-			// are less likely to get their colours and also flashes more when switching windows
-			logpal->palPalEntry[iPal].peFlags = PC_NOCOLLAPSE;
-			// 0 allows approximate colours when in background, yielding moe colours to other windows
-			//logpal->palPalEntry[iPal].peFlags = 0;
-		}
-		hpal = ::CreatePalette(logpal);
-		delete []pal;
-	}
+FormatAndMetrics *FamFromFontID(void *fid) noexcept {
+	return static_cast<FormatAndMetrics *>(fid);
 }
 
-static void SetLogFont(LOGFONTA &lf, const char *faceName, int characterSet, int size, bool bold, bool italic) {
-	memset(&lf, 0, sizeof(lf));
-	// The negative is to allow for leading
-	lf.lfHeight = -(abs(size));
-	lf.lfWeight = bold ? FW_BOLD : FW_NORMAL;
-	lf.lfItalic = static_cast<BYTE>(italic ? 1 : 0);
-	lf.lfCharSet = static_cast<BYTE>(characterSet);
-	strncpy(lf.lfFaceName, faceName, sizeof(lf.lfFaceName));
-}
-
-/**
- * Create a hash from the parameters for a font to allow easy checking for identity.
- * If one font is the same as another, its hash will be the same, but if the hash is the
- * same then they may still be different.
- */
-static int HashFont(const char *faceName, int characterSet, int size, bool bold, bool italic) {
-	return
-		size ^
-		(characterSet << 10) ^
-		(bold ? 0x10000000 : 0) ^
-		(italic ? 0x20000000 : 0) ^
-		faceName[0];
-}
-
-class FontCached : Font {
-	FontCached *next;
-	int usage;
-	LOGFONTA lf;
-	int hash;
-	FontCached(const char *faceName_, int characterSet_, int size_, bool bold_, bool italic_);
-	~FontCached() {}
-	bool SameAs(const char *faceName_, int characterSet_, int size_, bool bold_, bool italic_);
-	virtual void Release();
-
-	static FontCached *first;
-public:
-	static FontID FindOrCreate(const char *faceName_, int characterSet_, int size_, bool bold_, bool italic_);
-	static void ReleaseId(FontID id_);
-};
+constexpr BYTE Win32MapFontQuality(int extraFontFlag) noexcept {
+	switch (extraFontFlag & SC_EFF_QUALITY_MASK) {
 
-FontCached *FontCached::first = 0;
+		case SC_EFF_QUALITY_NON_ANTIALIASED:
+			return NONANTIALIASED_QUALITY;
 
-FontCached::FontCached(const char *faceName_, int characterSet_, int size_, bool bold_, bool italic_) :
-	next(0), usage(0), hash(0) {
-	SetLogFont(lf, faceName_, characterSet_, size_, bold_, italic_);
-	hash = HashFont(faceName_, characterSet_, size_, bold_, italic_);
-	id = ::CreateFontIndirectA(&lf);
-	usage = 1;
-}
+		case SC_EFF_QUALITY_ANTIALIASED:
+			return ANTIALIASED_QUALITY;
 
-bool FontCached::SameAs(const char *faceName_, int characterSet_, int size_, bool bold_, bool italic_) {
-	return
-		(lf.lfHeight == -(abs(size_))) &&
-		(lf.lfWeight == (bold_ ? FW_BOLD : FW_NORMAL)) &&
-		(lf.lfItalic == static_cast<BYTE>(italic_ ? 1 : 0)) &&
-		(lf.lfCharSet == characterSet_) &&
-		0 == strcmp(lf.lfFaceName,faceName_);
-}
+		case SC_EFF_QUALITY_LCD_OPTIMIZED:
+			return CLEARTYPE_QUALITY;
 
-void FontCached::Release() {
-	if (id)
-		::DeleteObject(id);
-	id = 0;
+		default:
+			return SC_EFF_QUALITY_DEFAULT;
+	}
 }
 
-FontID FontCached::FindOrCreate(const char *faceName_, int characterSet_, int size_, bool bold_, bool italic_) {
-	FontID ret = 0;
-	::EnterCriticalSection(&crPlatformLock);
-	int hashFind = HashFont(faceName_, characterSet_, size_, bold_, italic_);
-	for (FontCached *cur=first; cur; cur=cur->next) {
-		if ((cur->hash == hashFind) &&
-			cur->SameAs(faceName_, characterSet_, size_, bold_, italic_)) {
-			cur->usage++;
-			ret = cur->id;
-		}
-	}
-	if (ret == 0) {
-		FontCached *fc = new FontCached(faceName_, characterSet_, size_, bold_, italic_);
-		if (fc) {
-			fc->next = first;
-			first = fc;
-			ret = fc->id;
-		}
+#if defined(USE_D2D)
+constexpr D2D1_TEXT_ANTIALIAS_MODE DWriteMapFontQuality(int extraFontFlag) noexcept {
+	switch (extraFontFlag & SC_EFF_QUALITY_MASK) {
+
+		case SC_EFF_QUALITY_NON_ANTIALIASED:
+			return D2D1_TEXT_ANTIALIAS_MODE_ALIASED;
+
+		case SC_EFF_QUALITY_ANTIALIASED:
+			return D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE;
+
+		case SC_EFF_QUALITY_LCD_OPTIMIZED:
+			return D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE;
+
+		default:
+			return D2D1_TEXT_ANTIALIAS_MODE_DEFAULT;
 	}
-	::LeaveCriticalSection(&crPlatformLock);
-	return ret;
+}
+#endif
+
+void SetLogFont(LOGFONTW &lf, const char *faceName, int characterSet, float size, int weight, bool italic, int extraFontFlag) {
+	lf = LOGFONTW();
+	// The negative is to allow for leading
+	lf.lfHeight = -(std::abs(std::lround(size)));
+	lf.lfWeight = weight;
+	lf.lfItalic = italic ? 1 : 0;
+	lf.lfCharSet = static_cast<BYTE>(characterSet);
+	lf.lfQuality = Win32MapFontQuality(extraFontFlag);
+	UTF16FromUTF8(faceName, lf.lfFaceName, LF_FACESIZE);
 }
 
-void FontCached::ReleaseId(FontID id_) {
-	::EnterCriticalSection(&crPlatformLock);
-	FontCached **pcur=&first;
-	for (FontCached *cur=first; cur; cur=cur->next) {
-		if (cur->id == id_) {
-			cur->usage--;
-			if (cur->usage == 0) {
-				*pcur = cur->next;
-				cur->Release();
-				cur->next = 0;
-				delete cur;
+FontID CreateFontFromParameters(const FontParameters &fp) {
+	LOGFONTW lf;
+	SetLogFont(lf, fp.faceName, fp.characterSet, fp.size, fp.weight, fp.italic, fp.extraFontFlag);
+	FontID fid = nullptr;
+	if (fp.technology == SCWIN_TECH_GDI) {
+		HFONT hfont = ::CreateFontIndirectW(&lf);
+		fid = new FormatAndMetrics(hfont, fp.extraFontFlag, fp.characterSet);
+	} else {
+#if defined(USE_D2D)
+		IDWriteTextFormat *pTextFormat = nullptr;
+		const std::wstring wsFace = WStringFromUTF8(fp.faceName);
+		const FLOAT fHeight = fp.size;
+		const DWRITE_FONT_STYLE style = fp.italic ? DWRITE_FONT_STYLE_ITALIC : DWRITE_FONT_STYLE_NORMAL;
+		HRESULT hr = pIDWriteFactory->CreateTextFormat(wsFace.c_str(), nullptr,
+			static_cast<DWRITE_FONT_WEIGHT>(fp.weight),
+			style,
+			DWRITE_FONT_STRETCH_NORMAL, fHeight, L"en-us", &pTextFormat);
+		if (SUCCEEDED(hr)) {
+			pTextFormat->SetWordWrapping(DWRITE_WORD_WRAPPING_NO_WRAP);
+
+			FLOAT yAscent = 1.0f;
+			FLOAT yDescent = 1.0f;
+			FLOAT yInternalLeading = 0.0f;
+			IDWriteTextLayout *pTextLayout = nullptr;
+			hr = pIDWriteFactory->CreateTextLayout(L"X", 1, pTextFormat,
+					100.0f, 100.0f, &pTextLayout);
+			if (SUCCEEDED(hr) && pTextLayout) {
+				constexpr int maxLines = 2;
+				DWRITE_LINE_METRICS lineMetrics[maxLines]{};
+				UINT32 lineCount = 0;
+				hr = pTextLayout->GetLineMetrics(lineMetrics, maxLines, &lineCount);
+				if (SUCCEEDED(hr)) {
+					yAscent = lineMetrics[0].baseline;
+					yDescent = lineMetrics[0].height - lineMetrics[0].baseline;
+
+					FLOAT emHeight;
+					hr = pTextLayout->GetFontSize(0, &emHeight);
+					if (SUCCEEDED(hr)) {
+						yInternalLeading = lineMetrics[0].height - emHeight;
+					}
+				}
+				ReleaseUnknown(pTextLayout);
+				pTextFormat->SetLineSpacing(DWRITE_LINE_SPACING_METHOD_UNIFORM, lineMetrics[0].height, lineMetrics[0].baseline);
 			}
-			break;
+			fid = new FormatAndMetrics(pTextFormat, fp.extraFontFlag, fp.characterSet, yAscent, yDescent, yInternalLeading);
 		}
-		pcur=&cur->next;
+#endif
 	}
-	::LeaveCriticalSection(&crPlatformLock);
+	return fid;
 }
 
-Font::Font() {
-	id = 0;
 }
 
-Font::~Font() {
+Font::Font() noexcept : fid{} {
 }
 
-#define FONTS_CACHED
+Font::~Font() {
+}
 
-void Font::Create(const char *faceName, int characterSet, int size,
-	bool bold, bool italic, bool) {
+void Font::Create(const FontParameters &fp) {
 	Release();
-#ifndef FONTS_CACHED
-	LOGFONT lf;
-	SetLogFont(lf, faceName, characterSet, size, bold, italic);
-	id = ::CreateFontIndirect(&lf);
-#else
-	id = FontCached::FindOrCreate(faceName, characterSet, size, bold, italic);
-#endif
+	if (fp.faceName)
+		fid = CreateFontFromParameters(fp);
 }
 
 void Font::Release() {
-#ifndef FONTS_CACHED
-	if (id)
-		::DeleteObject(id);
-#else
-	if (id)
-		FontCached::ReleaseId(id);
-#endif
-	id = 0;
+	if (fid)
+		delete FamFromFontID(fid);
+	fid = nullptr;
 }
 
-#ifdef SCI_NAMESPACE
-namespace Scintilla {
-#endif
-
-class SurfaceImpl : public Surface {
-	bool unicodeMode;
-	HDC hdc;
-	bool hdcOwned;
-	HPEN pen;
-	HPEN penOld;
-	HBRUSH brush;
-	HBRUSH brushOld;
-	HFONT font;
-	HFONT fontOld;
-	HBITMAP bitmap;
-	HBITMAP bitmapOld;
-	HPALETTE paletteOld;
-	int maxWidthMeasure;
-	int maxLenText;
-
-	int codePage;
-	// If 9x OS and current code page is same as ANSI code page.
-	bool win9xACPSame;
+// Buffer to hold strings and string position arrays without always allocating on heap.
+// May sometimes have string too long to allocate on stack. So use a fixed stack-allocated buffer
+// when less than safe size otherwise allocate on heap and free automatically.
+template<typename T, int lengthStandard>
+class VarBuffer {
+	T bufferStandard[lengthStandard];
+public:
+	T *buffer;
+	explicit VarBuffer(size_t length) : buffer(nullptr) {
+		if (length > lengthStandard) {
+			buffer = new T[length];
+		} else {
+			buffer = bufferStandard;
+		}
+	}
+	// Deleted so VarBuffer objects can not be copied.
+	VarBuffer(const VarBuffer &) = delete;
+	VarBuffer(VarBuffer &&) = delete;
+	VarBuffer &operator=(const VarBuffer &) = delete;
+	VarBuffer &operator=(VarBuffer &&) = delete;
 
-	void BrushColor(ColourAllocated back);
-	void SetFont(Font &font_);
+	~VarBuffer() {
+		if (buffer != bufferStandard) {
+			delete []buffer;
+			buffer = nullptr;
+		}
+	}
+};
 
-	// Private so SurfaceImpl objects can not be copied
-	SurfaceImpl(const SurfaceImpl &) : Surface() {}
-	SurfaceImpl &operator=(const SurfaceImpl &) { return *this; }
+constexpr int stackBufferLength = 1000;
+class TextWide : public VarBuffer<wchar_t, stackBufferLength> {
 public:
-	SurfaceImpl();
-	virtual ~SurfaceImpl();
-
-	void Init(WindowID wid);
-	void Init(SurfaceID sid, WindowID wid);
-	void InitPixMap(int width, int height, Surface *surface_, WindowID wid);
-
-	void Release();
-	bool Initialised();
-	void PenColour(ColourAllocated fore);
-	int LogPixelsY();
-	int DeviceHeightFont(int points);
-	void MoveTo(int x_, int y_);
-	void LineTo(int x_, int y_);
-	void Polygon(Point *pts, int npts, ColourAllocated fore, ColourAllocated back);
-	void RectangleDraw(PRectangle rc, ColourAllocated fore, ColourAllocated back);
-	void FillRectangle(PRectangle rc, ColourAllocated back);
-	void FillRectangle(PRectangle rc, Surface &surfacePattern);
-	void RoundedRectangle(PRectangle rc, ColourAllocated fore, ColourAllocated back);
-	void AlphaRectangle(PRectangle rc, int cornerSize, ColourAllocated fill, int alphaFill,
-		ColourAllocated outline, int alphaOutline, int flags);
-	void Ellipse(PRectangle rc, ColourAllocated fore, ColourAllocated back);
-	void Copy(PRectangle rc, Point from, Surface &surfaceSource);
-
-	void DrawTextCommon(PRectangle rc, Font &font_, int ybase, const char *s, int len, UINT fuOptions);
-	void DrawTextNoClip(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore, ColourAllocated back);
-	void DrawTextClipped(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore, ColourAllocated back);
-	void DrawTextTransparent(PRectangle rc, Font &font_, int ybase, const char *s, int len, ColourAllocated fore);
-	void MeasureWidths(Font &font_, const char *s, int len, int *positions);
-	int WidthText(Font &font_, const char *s, int len);
-	int WidthChar(Font &font_, char ch);
-	int Ascent(Font &font_);
-	int Descent(Font &font_);
-	int InternalLeading(Font &font_);
-	int ExternalLeading(Font &font_);
-	int Height(Font &font_);
-	int AverageCharWidth(Font &font_);
-
-	int SetPalette(Palette *pal, bool inBackGround);
-	void SetClip(PRectangle rc);
-	void FlushCachedState();
-
-	void SetUnicodeMode(bool unicodeMode_);
-	void SetDBCSMode(int codePage_);
+	int tlen;	// Using int instead of size_t as most Win32 APIs take int.
+	TextWide(std::string_view text, bool unicodeMode, int codePage=0) :
+		VarBuffer<wchar_t, stackBufferLength>(text.length()) {
+		if (unicodeMode) {
+			tlen = static_cast<int>(UTF16FromUTF8(text, buffer, text.length()));
+		} else {
+			// Support Asian string display in 9x English
+			tlen = ::MultiByteToWideChar(codePage, 0, text.data(), static_cast<int>(text.length()),
+				buffer, static_cast<int>(text.length()));
+		}
+	}
 };
+typedef VarBuffer<XYPOSITION, stackBufferLength> TextPositions;
+
+UINT DpiForWindow(WindowID wid) noexcept {
+	if (fnGetDpiForWindow) {
+		return fnGetDpiForWindow(HwndFromWindowID(wid));
+	}
+	if (fnGetDpiForMonitor) {
+		HMONITOR hMonitor = ::MonitorFromWindow(HwndFromWindowID(wid), MONITOR_DEFAULTTONEAREST);
+		UINT dpiX = 0;
+		UINT dpiY = 0;
+		if (fnGetDpiForMonitor(hMonitor, 0 /*MDT_EFFECTIVE_DPI*/, &dpiX, &dpiY) == S_OK) {
+			return dpiY;
+		}
+	}
+	return uSystemDPI;
+}
 
-#ifdef SCI_NAMESPACE
-} //namespace Scintilla
-#endif
+int SystemMetricsForDpi(int nIndex, UINT dpi) noexcept {
+	if (fnGetSystemMetricsForDpi) {
+		return fnGetSystemMetricsForDpi(nIndex, dpi);
+	}
 
-SurfaceImpl::SurfaceImpl() :
-	unicodeMode(false),
-	hdc(0), 	hdcOwned(false),
-	pen(0), 	penOld(0),
-	brush(0), brushOld(0),
-	font(0), 	fontOld(0),
-	bitmap(0), bitmapOld(0),
-	paletteOld(0) {
-	// Windows 9x has only a 16 bit coordinate system so break after 30000 pixels
-	maxWidthMeasure = IsNT() ? 1000000 : 30000;
-	// There appears to be a 16 bit string length limit in GDI on NT and a limit of
-	// 8192 characters on Windows 95.
-	maxLenText = IsNT() ? 65535 : 8192;
+	int value = ::GetSystemMetrics(nIndex);
+	value = (dpi == uSystemDPI) ? value : ::MulDiv(value, dpi, uSystemDPI);
+	return value;
+}
 
-	codePage = 0;
-	win9xACPSame = false;
+class SurfaceGDI : public Surface {
+	bool unicodeMode=false;
+	HDC hdc{};
+	bool hdcOwned=false;
+	HPEN pen{};
+	HPEN penOld{};
+	HBRUSH brush{};
+	HBRUSH brushOld{};
+	HFONT fontOld{};
+	HBITMAP bitmap{};
+	HBITMAP bitmapOld{};
+
+	int logPixelsY = USER_DEFAULT_SCREEN_DPI;
+
+	int maxWidthMeasure = INT_MAX;
+	// There appears to be a 16 bit string length limit in GDI on NT.
+	int maxLenText = 65535;
+
+	int codePage = 0;
+
+	void BrushColour(ColourDesired back) noexcept;
+	void SetFont(const Font &font_) noexcept;
+	void Clear() noexcept;
+
+public:
+	SurfaceGDI() noexcept;
+	// Deleted so SurfaceGDI objects can not be copied.
+	SurfaceGDI(const SurfaceGDI &) = delete;
+	SurfaceGDI(SurfaceGDI &&) = delete;
+	SurfaceGDI &operator=(const SurfaceGDI &) = delete;
+	SurfaceGDI &operator=(SurfaceGDI &&) = delete;
+
+	~SurfaceGDI() noexcept override;
+
+	void Init(WindowID wid) override;
+	void Init(SurfaceID sid, WindowID wid) override;
+	void InitPixMap(int width, int height, Surface *surface_, WindowID wid) override;
+
+	void Release() override;
+	bool Initialised() override;
+	void PenColour(ColourDesired fore) override;
+	int LogPixelsY() override;
+	int DeviceHeightFont(int points) override;
+	void MoveTo(int x_, int y_) override;
+	void LineTo(int x_, int y_) override;
+	void Polygon(Point *pts, size_t npts, ColourDesired fore, ColourDesired back) override;
+	void RectangleDraw(PRectangle rc, ColourDesired fore, ColourDesired back) override;
+	void FillRectangle(PRectangle rc, ColourDesired back) override;
+	void FillRectangle(PRectangle rc, Surface &surfacePattern) override;
+	void RoundedRectangle(PRectangle rc, ColourDesired fore, ColourDesired back) override;
+	void AlphaRectangle(PRectangle rc, int cornerSize, ColourDesired fill, int alphaFill,
+		ColourDesired outline, int alphaOutline, int flags) override;
+	void GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) override;
+	void DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) override;
+	void Ellipse(PRectangle rc, ColourDesired fore, ColourDesired back) override;
+	void Copy(PRectangle rc, Point from, Surface &surfaceSource) override;
+
+	std::unique_ptr<IScreenLineLayout> Layout(const IScreenLine *screenLine) override;
+
+	void DrawTextCommon(PRectangle rc, const Font &font_, XYPOSITION ybase, std::string_view text, UINT fuOptions);
+	void DrawTextNoClip(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text, ColourDesired fore, ColourDesired back) override;
+	void DrawTextClipped(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text, ColourDesired fore, ColourDesired back) override;
+	void DrawTextTransparent(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text, ColourDesired fore) override;
+	void MeasureWidths(Font &font_, std::string_view text, XYPOSITION *positions) override;
+	XYPOSITION WidthText(Font &font_, std::string_view text) override;
+	XYPOSITION Ascent(Font &font_) override;
+	XYPOSITION Descent(Font &font_) override;
+	XYPOSITION InternalLeading(Font &font_) override;
+	XYPOSITION Height(Font &font_) override;
+	XYPOSITION AverageCharWidth(Font &font_) override;
+
+	void SetClip(PRectangle rc) override;
+	void FlushCachedState() override;
+
+	void SetUnicodeMode(bool unicodeMode_) override;
+	void SetDBCSMode(int codePage_) override;
+	void SetBidiR2L(bool bidiR2L_) override;
+};
+
+SurfaceGDI::SurfaceGDI() noexcept {
 }
 
-SurfaceImpl::~SurfaceImpl() {
-	Release();
+SurfaceGDI::~SurfaceGDI() noexcept {
+	Clear();
 }
 
-void SurfaceImpl::Release() {
+void SurfaceGDI::Clear() noexcept {
 	if (penOld) {
-		::SelectObject(reinterpret_cast<HDC>(hdc), penOld);
+		::SelectObject(hdc, penOld);
 		::DeleteObject(pen);
-		penOld = 0;
+		penOld = {};
 	}
-	pen = 0;
+	pen = {};
 	if (brushOld) {
-		::SelectObject(reinterpret_cast<HDC>(hdc), brushOld);
+		::SelectObject(hdc, brushOld);
 		::DeleteObject(brush);
-		brushOld = 0;
+		brushOld = {};
 	}
-	brush = 0;
+	brush = {};
 	if (fontOld) {
 		// Fonts are not deleted as they are owned by a Font object
-		::SelectObject(reinterpret_cast<HDC>(hdc), fontOld);
-		fontOld = 0;
+		::SelectObject(hdc, fontOld);
+		fontOld = {};
 	}
-	font = 0;
 	if (bitmapOld) {
-		::SelectObject(reinterpret_cast<HDC>(hdc), bitmapOld);
+		::SelectObject(hdc, bitmapOld);
 		::DeleteObject(bitmap);
-		bitmapOld = 0;
-	}
-	bitmap = 0;
-	if (paletteOld) {
-		// Palettes are not deleted as they are owned by a Palette object
-		::SelectPalette(reinterpret_cast<HDC>(hdc),
-			reinterpret_cast<HPALETTE>(paletteOld), TRUE);
-		paletteOld = 0;
+		bitmapOld = {};
 	}
+	bitmap = {};
 	if (hdcOwned) {
-		::DeleteDC(reinterpret_cast<HDC>(hdc));
-		hdc = 0;
+		::DeleteDC(hdc);
+		hdc = {};
 		hdcOwned = false;
 	}
 }
 
-bool SurfaceImpl::Initialised() {
+void SurfaceGDI::Release() {
+	Clear();
+}
+
+bool SurfaceGDI::Initialised() {
 	return hdc != 0;
 }
 
-void SurfaceImpl::Init(WindowID) {
+void SurfaceGDI::Init(WindowID wid) {
 	Release();
-	hdc = ::CreateCompatibleDC(NULL);
+	hdc = ::CreateCompatibleDC({});
 	hdcOwned = true;
-	::SetTextAlign(reinterpret_cast<HDC>(hdc), TA_BASELINE);
+	::SetTextAlign(hdc, TA_BASELINE);
+	logPixelsY = DpiForWindow(wid);
 }
 
-void SurfaceImpl::Init(SurfaceID sid, WindowID) {
+void SurfaceGDI::Init(SurfaceID sid, WindowID wid) {
 	Release();
-	hdc = reinterpret_cast<HDC>(sid);
-	::SetTextAlign(reinterpret_cast<HDC>(hdc), TA_BASELINE);
+	hdc = static_cast<HDC>(sid);
+	::SetTextAlign(hdc, TA_BASELINE);
+	// Windows on screen are scaled but printers are not.
+	const bool printing = ::GetDeviceCaps(hdc, TECHNOLOGY) != DT_RASDISPLAY;
+	logPixelsY = printing ? ::GetDeviceCaps(hdc, LOGPIXELSY) : DpiForWindow(wid);
 }
 
-void SurfaceImpl::InitPixMap(int width, int height, Surface *surface_, WindowID) {
+void SurfaceGDI::InitPixMap(int width, int height, Surface *surface_, WindowID wid) {
 	Release();
-	hdc = ::CreateCompatibleDC(static_cast<SurfaceImpl *>(surface_)->hdc);
+	SurfaceGDI *psurfOther = dynamic_cast<SurfaceGDI *>(surface_);
+	// Should only ever be called with a SurfaceGDI, not a SurfaceD2D
+	PLATFORM_ASSERT(psurfOther);
+	hdc = ::CreateCompatibleDC(psurfOther->hdc);
 	hdcOwned = true;
-	bitmap = ::CreateCompatibleBitmap(static_cast<SurfaceImpl *>(surface_)->hdc, width, height);
-	bitmapOld = static_cast<HBITMAP>(::SelectObject(hdc, bitmap));
-	::SetTextAlign(reinterpret_cast<HDC>(hdc), TA_BASELINE);
+	bitmap = ::CreateCompatibleBitmap(psurfOther->hdc, width, height);
+	bitmapOld = SelectBitmap(hdc, bitmap);
+	::SetTextAlign(hdc, TA_BASELINE);
+	SetUnicodeMode(psurfOther->unicodeMode);
+	SetDBCSMode(psurfOther->codePage);
+	logPixelsY = DpiForWindow(wid);
 }
 
-void SurfaceImpl::PenColour(ColourAllocated fore) {
+void SurfaceGDI::PenColour(ColourDesired fore) {
 	if (pen) {
 		::SelectObject(hdc, penOld);
 		::DeleteObject(pen);
-		pen = 0;
-		penOld = 0;
+		pen = {};
+		penOld = {};
 	}
-	pen = ::CreatePen(0,1,fore.AsLong());
-	penOld = static_cast<HPEN>(::SelectObject(reinterpret_cast<HDC>(hdc), pen));
+	pen = ::CreatePen(0,1,fore.AsInteger());
+	penOld = SelectPen(hdc, pen);
 }
 
-void SurfaceImpl::BrushColor(ColourAllocated back) {
+void SurfaceGDI::BrushColour(ColourDesired back) noexcept {
 	if (brush) {
 		::SelectObject(hdc, brushOld);
 		::DeleteObject(brush);
-		brush = 0;
-		brushOld = 0;
+		brush = {};
+		brushOld = {};
 	}
-	// Only ever want pure, non-dithered brushes
-	ColourAllocated colourNearest = ::GetNearestColor(hdc, back.AsLong());
-	brush = ::CreateSolidBrush(colourNearest.AsLong());
-	brushOld = static_cast<HBRUSH>(::SelectObject(hdc, brush));
+	brush = ::CreateSolidBrush(back.AsInteger());
+	brushOld = SelectBrush(hdc, brush);
 }
 
-void SurfaceImpl::SetFont(Font &font_) {
-	if (font_.GetID() != font) {
-		if (fontOld) {
-			::SelectObject(hdc, font_.GetID());
-		} else {
-			fontOld = static_cast<HFONT>(::SelectObject(hdc, font_.GetID()));
-		}
-		font = reinterpret_cast<HFONT>(font_.GetID());
+void SurfaceGDI::SetFont(const Font &font_) noexcept {
+	const FormatAndMetrics *pfm = FamFromFontID(font_.GetID());
+	PLATFORM_ASSERT(pfm->technology == SCWIN_TECH_GDI);
+	if (fontOld) {
+		SelectFont(hdc, pfm->hfont);
+	} else {
+		fontOld = SelectFont(hdc, pfm->hfont);
 	}
 }
 
-int SurfaceImpl::LogPixelsY() {
-	return ::GetDeviceCaps(hdc, LOGPIXELSY);
+int SurfaceGDI::LogPixelsY() {
+	return logPixelsY;
 }
 
-int SurfaceImpl::DeviceHeightFont(int points) {
+int SurfaceGDI::DeviceHeightFont(int points) {
 	return ::MulDiv(points, LogPixelsY(), 72);
 }
 
-void SurfaceImpl::MoveTo(int x_, int y_) {
-	::MoveToEx(hdc, x_, y_, 0);
+void SurfaceGDI::MoveTo(int x_, int y_) {
+	::MoveToEx(hdc, x_, y_, nullptr);
 }
 
-void SurfaceImpl::LineTo(int x_, int y_) {
+void SurfaceGDI::LineTo(int x_, int y_) {
 	::LineTo(hdc, x_, y_);
 }
 
-void SurfaceImpl::Polygon(Point *pts, int npts, ColourAllocated fore, ColourAllocated back) {
+void SurfaceGDI::Polygon(Point *pts, size_t npts, ColourDesired fore, ColourDesired back) {
 	PenColour(fore);
-	BrushColor(back);
-	::Polygon(hdc, reinterpret_cast<POINT *>(pts), npts);
+	BrushColour(back);
+	std::vector<POINT> outline;
+	std::transform(pts, pts + npts, std::back_inserter(outline), POINTFromPoint);
+	::Polygon(hdc, outline.data(), static_cast<int>(npts));
 }
 
-void SurfaceImpl::RectangleDraw(PRectangle rc, ColourAllocated fore, ColourAllocated back) {
+void SurfaceGDI::RectangleDraw(PRectangle rc, ColourDesired fore, ColourDesired back) {
 	PenColour(fore);
-	BrushColor(back);
-	::Rectangle(hdc, rc.left, rc.top, rc.right, rc.bottom);
+	BrushColour(back);
+	const RECT rcw = RectFromPRectangle(rc);
+	::Rectangle(hdc, rcw.left, rcw.top, rcw.right, rcw.bottom);
 }
 
-void SurfaceImpl::FillRectangle(PRectangle rc, ColourAllocated back) {
+void SurfaceGDI::FillRectangle(PRectangle rc, ColourDesired back) {
 	// Using ExtTextOut rather than a FillRect ensures that no dithering occurs.
 	// There is no need to allocate a brush either.
-	RECT rcw = RectFromPRectangle(rc);
-	::SetBkColor(hdc, back.AsLong());
-	::ExtTextOut(hdc, rc.left, rc.top, ETO_OPAQUE, &rcw, TEXT(""), 0, NULL);
+	const RECT rcw = RectFromPRectangle(rc);
+	::SetBkColor(hdc, back.AsInteger());
+	::ExtTextOut(hdc, rcw.left, rcw.top, ETO_OPAQUE, &rcw, TEXT(""), 0, nullptr);
 }
 
-void SurfaceImpl::FillRectangle(PRectangle rc, Surface &surfacePattern) {
+void SurfaceGDI::FillRectangle(PRectangle rc, Surface &surfacePattern) {
 	HBRUSH br;
-	if (static_cast<SurfaceImpl &>(surfacePattern).bitmap)
-		br = ::CreatePatternBrush(static_cast<SurfaceImpl &>(surfacePattern).bitmap);
-	else	// Something is wrong so display in red
+	if (SurfaceGDI *psgdi = dynamic_cast<SurfaceGDI *>(&surfacePattern); psgdi && psgdi->bitmap) {
+		br = ::CreatePatternBrush(psgdi->bitmap);
+	} else {	// Something is wrong so display in red
 		br = ::CreateSolidBrush(RGB(0xff, 0, 0));
-	RECT rcw = RectFromPRectangle(rc);
+	}
+	const RECT rcw = RectFromPRectangle(rc);
 	::FillRect(hdc, &rcw, br);
 	::DeleteObject(br);
 }
 
-void SurfaceImpl::RoundedRectangle(PRectangle rc, ColourAllocated fore, ColourAllocated back) {
+void SurfaceGDI::RoundedRectangle(PRectangle rc, ColourDesired fore, ColourDesired back) {
 	PenColour(fore);
-	BrushColor(back);
+	BrushColour(back);
+	const RECT rcw = RectFromPRectangle(rc);
 	::RoundRect(hdc,
-		rc.left + 1, rc.top,
-		rc.right - 1, rc.bottom,
+		rcw.left + 1, rcw.top,
+		rcw.right - 1, rcw.bottom,
 		8, 8);
 }
 
-// Plot a point into a DWORD buffer symetrically to all 4 qudrants
-static void AllFour(DWORD *pixels, int width, int height, int x, int y, DWORD val) {
-	pixels[y*width+x] = val;
-	pixels[y*width+width-1-x] = val;
-	pixels[(height-1-y)*width+x] = val;
-	pixels[(height-1-y)*width+width-1-x] = val;
+namespace {
+
+constexpr DWORD dwordFromBGRA(byte b, byte g, byte r, byte a) noexcept {
+	return (a << 24) | (r << 16) | (g << 8) | b;
 }
 
-#ifndef AC_SRC_OVER
-#define AC_SRC_OVER                 0x00
-#endif
-#ifndef AC_SRC_ALPHA
-#define AC_SRC_ALPHA		0x01
-#endif
+constexpr byte AlphaScaled(unsigned char component, unsigned int alpha) noexcept {
+	return static_cast<byte>(component * alpha / 255);
+}
 
-void SurfaceImpl::AlphaRectangle(PRectangle rc, int cornerSize, ColourAllocated fill, int alphaFill,
-		ColourAllocated outline, int alphaOutline, int /* flags*/ ) {
-	if (AlphaBlendFn && rc.Width() > 0) {
-		HDC hMemDC = ::CreateCompatibleDC(reinterpret_cast<HDC>(hdc));
-		int width = rc.Width();
-		int height = rc.Height();
-		// Ensure not distorted too much by corners when small
-		cornerSize = Platform::Minimum(cornerSize, (Platform::Minimum(width, height) / 2) - 2);
-		BITMAPINFO bpih = {sizeof(BITMAPINFOHEADER), width, height, 1, 32, BI_RGB, 0, 0, 0, 0, 0};
-		void *image = 0;
-		HBITMAP hbmMem = CreateDIBSection(reinterpret_cast<HDC>(hMemDC), &bpih,
-			DIB_RGB_COLORS, &image, NULL, 0);
-
-		HBITMAP hbmOld = SelectBitmap(hMemDC, hbmMem);
-
-		byte pixVal[4] = {0};
-		DWORD valEmpty = *(reinterpret_cast<DWORD *>(pixVal));
-		pixVal[0] = static_cast<byte>(GetBValue(fill.AsLong()) * alphaFill / 255);
-		pixVal[1] = static_cast<byte>(GetGValue(fill.AsLong()) * alphaFill / 255);
-		pixVal[2] = static_cast<byte>(GetRValue(fill.AsLong()) * alphaFill / 255);
-		pixVal[3] = static_cast<byte>(alphaFill);
-		DWORD valFill = *(reinterpret_cast<DWORD *>(pixVal));
-		pixVal[0] = static_cast<byte>(GetBValue(outline.AsLong()) * alphaOutline / 255);
-		pixVal[1] = static_cast<byte>(GetGValue(outline.AsLong()) * alphaOutline / 255);
-		pixVal[2] = static_cast<byte>(GetRValue(outline.AsLong()) * alphaOutline / 255);
-		pixVal[3] = static_cast<byte>(alphaOutline);
-		DWORD valOutline = *(reinterpret_cast<DWORD *>(pixVal));
-		DWORD *pixels = reinterpret_cast<DWORD *>(image);
-		for (int y=0; y<height; y++) {
-			for (int x=0; x<width; x++) {
-				if ((x==0) || (x==width-1) || (y == 0) || (y == height-1)) {
-					pixels[y*width+x] = valOutline;
-				} else {
-					pixels[y*width+x] = valFill;
-				}
-			}
-		}
-		for (int c=0;c<cornerSize; c++) {
-			for (int x=0;x<c+1; x++) {
-				AllFour(pixels, width, height, x, c-x, valEmpty);
-			}
-		}
-		for (int x=1;x<cornerSize; x++) {
-			AllFour(pixels, width, height, x, cornerSize-x, valOutline);
-		}
+constexpr DWORD dwordMultiplied(ColourDesired colour, unsigned int alpha) noexcept {
+	return dwordFromBGRA(
+		AlphaScaled(colour.GetBlue(), alpha),
+		AlphaScaled(colour.GetGreen(), alpha),
+		AlphaScaled(colour.GetRed(), alpha),
+		static_cast<byte>(alpha));
+}
+
+class DIBSection {
+	HDC hMemDC {};
+	HBITMAP hbmMem {};
+	HBITMAP hbmOld {};
+	SIZE size {};
+	DWORD *pixels = nullptr;
+public:
+	DIBSection(HDC hdc, SIZE size_) noexcept;
+	// Deleted so DIBSection objects can not be copied.
+	DIBSection(const DIBSection&) = delete;
+	DIBSection(DIBSection&&) = delete;
+	DIBSection &operator=(const DIBSection&) = delete;
+	DIBSection &operator=(DIBSection&&) = delete;
+	~DIBSection() noexcept;
+	operator bool() const noexcept {
+		return hMemDC && hbmMem && pixels;
+	}
+	DWORD *Pixels() const noexcept {
+		return pixels;
+	}
+	unsigned char *Bytes() const noexcept {
+		return reinterpret_cast<unsigned char *>(pixels);
+	}
+	HDC DC() const noexcept {
+		return hMemDC;
+	}
+	void SetPixel(LONG x, LONG y, DWORD value) noexcept {
+		PLATFORM_ASSERT(x >= 0);
+		PLATFORM_ASSERT(y >= 0);
+		PLATFORM_ASSERT(x < size.cx);
+		PLATFORM_ASSERT(y < size.cy);
+		pixels[y * size.cx + x] = value;
+	}
+	void SetSymmetric(LONG x, LONG y, DWORD value) noexcept;
+};
 
-		BLENDFUNCTION merge = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
+DIBSection::DIBSection(HDC hdc, SIZE size_) noexcept {
+	hMemDC = ::CreateCompatibleDC(hdc);
+	if (!hMemDC) {
+		return;
+	}
 
-		AlphaBlendFn(reinterpret_cast<HDC>(hdc), rc.left, rc.top, width, height, hMemDC, 0, 0, width, height, merge);
+	size = size_;
+
+	// -size.y makes bitmap start from top
+	const BITMAPINFO bpih = { {sizeof(BITMAPINFOHEADER), size.cx, -size.cy, 1, 32, BI_RGB, 0, 0, 0, 0, 0},
+		{{0, 0, 0, 0}} };
+	void *image = nullptr;
+	hbmMem = CreateDIBSection(hMemDC, &bpih, DIB_RGB_COLORS, &image, {}, 0);
+	if (!hbmMem || !image) {
+		return;
+	}
+	pixels = static_cast<DWORD *>(image);
+	hbmOld = SelectBitmap(hMemDC, hbmMem);
+}
 
+DIBSection::~DIBSection() noexcept {
+	if (hbmOld) {
 		SelectBitmap(hMemDC, hbmOld);
+		hbmOld = {};
+	}
+	if (hbmMem) {
 		::DeleteObject(hbmMem);
+		hbmMem = {};
+	}
+	if (hMemDC) {
 		::DeleteDC(hMemDC);
+		hMemDC = {};
+	}
+}
+
+void DIBSection::SetSymmetric(LONG x, LONG y, DWORD value) noexcept {
+	// Plot a point symmetrically to all 4 quadrants
+	const LONG xSymmetric = size.cx - 1 - x;
+	const LONG ySymmetric = size.cy - 1 - y;
+	SetPixel(x, y, value);
+	SetPixel(xSymmetric, y, value);
+	SetPixel(x, ySymmetric, value);
+	SetPixel(xSymmetric, ySymmetric, value);
+}
+
+constexpr unsigned int Proportional(unsigned char a, unsigned char b, float t) noexcept {
+	return static_cast<unsigned int>(a + t * (b - a));
+}
+
+ColourAlpha Proportional(ColourAlpha a, ColourAlpha b, float t) noexcept {
+	return ColourAlpha(
+		Proportional(a.GetRed(), b.GetRed(), t),
+		Proportional(a.GetGreen(), b.GetGreen(), t),
+		Proportional(a.GetBlue(), b.GetBlue(), t),
+		Proportional(a.GetAlpha(), b.GetAlpha(), t));
+}
+
+ColourAlpha GradientValue(const std::vector<ColourStop> &stops, float proportion) noexcept {
+	for (size_t stop = 0; stop < stops.size() - 1; stop++) {
+		// Loop through each pair of stops
+		const float positionStart = stops[stop].position;
+		const float positionEnd = stops[stop + 1].position;
+		if ((proportion >= positionStart) && (proportion <= positionEnd)) {
+			const float proportionInPair = (proportion - positionStart) /
+				(positionEnd - positionStart);
+			return Proportional(stops[stop].colour, stops[stop + 1].colour, proportionInPair);
+		}
+	}
+	// Loop should always find a value
+	return ColourAlpha();
+}
+
+constexpr SIZE SizeOfRect(RECT rc) noexcept {
+	return { rc.right - rc.left, rc.bottom - rc.top };
+}
+
+constexpr BLENDFUNCTION mergeAlpha = { AC_SRC_OVER, 0, 255, AC_SRC_ALPHA };
+
+}
+
+void SurfaceGDI::AlphaRectangle(PRectangle rc, int cornerSize, ColourDesired fill, int alphaFill,
+		ColourDesired outline, int alphaOutline, int /* flags*/ ) {
+	const RECT rcw = RectFromPRectangle(rc);
+	const SIZE size = SizeOfRect(rcw);
+
+	if (size.cx > 0) {
+
+		DIBSection section(hdc, size);
+
+		if (section) {
+
+			// Ensure not distorted too much by corners when small
+			const LONG corner = std::min<LONG>(cornerSize, (std::min(size.cx, size.cy) / 2) - 2);
+
+			constexpr DWORD valEmpty = dwordFromBGRA(0,0,0,0);
+			const DWORD valFill = dwordMultiplied(fill, alphaFill);
+			const DWORD valOutline = dwordMultiplied(outline, alphaOutline);
+
+			// Draw a framed rectangle
+			for (int y=0; y<size.cy; y++) {
+				for (int x=0; x<size.cx; x++) {
+					if ((x==0) || (x==size.cx-1) || (y == 0) || (y == size.cy -1)) {
+						section.SetPixel(x, y, valOutline);
+					} else {
+						section.SetPixel(x, y, valFill);
+					}
+				}
+			}
+
+			// Make the corners transparent
+			for (LONG c=0; c<corner; c++) {
+				for (LONG x=0; x<c+1; x++) {
+					section.SetSymmetric(x, c - x, valEmpty);
+				}
+			}
+
+			// Draw the corner frame pieces
+			for (LONG x=1; x<corner; x++) {
+				section.SetSymmetric(x, corner - x, valOutline);
+			}
+
+			AlphaBlend(hdc, rcw.left, rcw.top, size.cx, size.cy, section.DC(), 0, 0, size.cx, size.cy, mergeAlpha);
+		}
 	} else {
-		BrushColor(outline);
-		RECT rcw = RectFromPRectangle(rc);
+		BrushColour(outline);
 		FrameRect(hdc, &rcw, brush);
 	}
 }
 
-void SurfaceImpl::Ellipse(PRectangle rc, ColourAllocated fore, ColourAllocated back) {
+void SurfaceGDI::GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) {
+
+	const RECT rcw = RectFromPRectangle(rc);
+	const SIZE size = SizeOfRect(rcw);
+
+	DIBSection section(hdc, size);
+
+	if (section) {
+
+		if (options == GradientOptions::topToBottom) {
+			for (LONG y = 0; y < size.cy; y++) {
+				// Find y/height proportional colour
+				const float proportion = y / (rc.Height() - 1.0f);
+				const ColourAlpha mixed = GradientValue(stops, proportion);
+				const DWORD valFill = dwordMultiplied(mixed, mixed.GetAlpha());
+				for (LONG x = 0; x < size.cx; x++) {
+					section.SetPixel(x, y, valFill);
+				}
+			}
+		} else {
+			for (LONG x = 0; x < size.cx; x++) {
+				// Find x/width proportional colour
+				const float proportion = x / (rc.Width() - 1.0f);
+				const ColourAlpha mixed = GradientValue(stops, proportion);
+				const DWORD valFill = dwordMultiplied(mixed, mixed.GetAlpha());
+				for (LONG y = 0; y < size.cy; y++) {
+					section.SetPixel(x, y, valFill);
+				}
+			}
+		}
+
+		AlphaBlend(hdc, rcw.left, rcw.top, size.cx, size.cy, section.DC(), 0, 0, size.cx, size.cy, mergeAlpha);
+	}
+}
+
+void SurfaceGDI::DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) {
+	if (rc.Width() > 0) {
+		if (rc.Width() > width)
+			rc.left += std::floor((rc.Width() - width) / 2);
+		rc.right = rc.left + width;
+		if (rc.Height() > height)
+			rc.top += std::floor((rc.Height() - height) / 2);
+		rc.bottom = rc.top + height;
+
+		const SIZE size { width, height };
+		DIBSection section(hdc, size);
+		if (section) {
+			RGBAImage::BGRAFromRGBA(section.Bytes(), pixelsImage, width * height);
+			AlphaBlend(hdc, static_cast<int>(rc.left), static_cast<int>(rc.top),
+				static_cast<int>(rc.Width()), static_cast<int>(rc.Height()), section.DC(),
+				0, 0, width, height, mergeAlpha);
+		}
+	}
+}
+
+void SurfaceGDI::Ellipse(PRectangle rc, ColourDesired fore, ColourDesired back) {
 	PenColour(fore);
-	BrushColor(back);
-	::Ellipse(hdc, rc.left, rc.top, rc.right, rc.bottom);
+	BrushColour(back);
+	const RECT rcw = RectFromPRectangle(rc);
+	::Ellipse(hdc, rcw.left, rcw.top, rcw.right, rcw.bottom);
 }
 
-void SurfaceImpl::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
+void SurfaceGDI::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
 	::BitBlt(hdc,
-		rc.left, rc.top, rc.Width(), rc.Height(),
-		static_cast<SurfaceImpl &>(surfaceSource).hdc, from.x, from.y, SRCCOPY);
+		static_cast<int>(rc.left), static_cast<int>(rc.top),
+		static_cast<int>(rc.Width()), static_cast<int>(rc.Height()),
+		dynamic_cast<SurfaceGDI &>(surfaceSource).hdc,
+		static_cast<int>(from.x), static_cast<int>(from.y), SRCCOPY);
 }
 
-// Buffer to hold strings and string position arrays without always allocating on heap.
-// May sometimes have string too long to allocate on stack. So use a fixed stack-allocated buffer
-// when less than safe size otherwise allocate on heap and free automatically.
-template<typename T, int lengthStandard>
-class VarBuffer {
-	T bufferStandard[lengthStandard];
-public:
-	T *buffer;
-	VarBuffer(size_t length) : buffer(0) {
-		if (length > lengthStandard) {
-			buffer = new T[length];
-		} else {
-			buffer = bufferStandard;
-		}
+std::unique_ptr<IScreenLineLayout> SurfaceGDI::Layout(const IScreenLine *) {
+	return {};
+}
+
+typedef VarBuffer<int, stackBufferLength> TextPositionsI;
+
+void SurfaceGDI::DrawTextCommon(PRectangle rc, const Font &font_, XYPOSITION ybase, std::string_view text, UINT fuOptions) {
+	SetFont(font_);
+	const RECT rcw = RectFromPRectangle(rc);
+	const int x = static_cast<int>(rc.left);
+	const int yBaseInt = static_cast<int>(ybase);
+
+	if (unicodeMode) {
+		const TextWide tbuf(text, unicodeMode, codePage);
+		::ExtTextOutW(hdc, x, yBaseInt, fuOptions, &rcw, tbuf.buffer, tbuf.tlen, nullptr);
+	} else {
+		::ExtTextOutA(hdc, x, yBaseInt, fuOptions, &rcw, text.data(), static_cast<UINT>(text.length()), nullptr);
+	}
+}
+
+void SurfaceGDI::DrawTextNoClip(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text,
+	ColourDesired fore, ColourDesired back) {
+	::SetTextColor(hdc, fore.AsInteger());
+	::SetBkColor(hdc, back.AsInteger());
+	DrawTextCommon(rc, font_, ybase, text, ETO_OPAQUE);
+}
+
+void SurfaceGDI::DrawTextClipped(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text,
+	ColourDesired fore, ColourDesired back) {
+	::SetTextColor(hdc, fore.AsInteger());
+	::SetBkColor(hdc, back.AsInteger());
+	DrawTextCommon(rc, font_, ybase, text, ETO_OPAQUE | ETO_CLIPPED);
+}
+
+void SurfaceGDI::DrawTextTransparent(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text,
+	ColourDesired fore) {
+	// Avoid drawing spaces in transparent mode
+	for (const char ch : text) {
+		if (ch != ' ') {
+			::SetTextColor(hdc, fore.AsInteger());
+			::SetBkMode(hdc, TRANSPARENT);
+			DrawTextCommon(rc, font_, ybase, text, 0);
+			::SetBkMode(hdc, OPAQUE);
+			return;
+		}
+	}
+}
+
+XYPOSITION SurfaceGDI::WidthText(Font &font_, std::string_view text) {
+	SetFont(font_);
+	SIZE sz={0,0};
+	if (!unicodeMode) {
+		::GetTextExtentPoint32A(hdc, text.data(), std::min(static_cast<int>(text.length()), maxLenText), &sz);
+	} else {
+		const TextWide tbuf(text, unicodeMode, codePage);
+		::GetTextExtentPoint32W(hdc, tbuf.buffer, tbuf.tlen, &sz);
+	}
+	return static_cast<XYPOSITION>(sz.cx);
+}
+
+void SurfaceGDI::MeasureWidths(Font &font_, std::string_view text, XYPOSITION *positions) {
+	// Zero positions to avoid random behaviour on failure.
+	std::fill(positions, positions + text.length(), 0.0f);
+	SetFont(font_);
+	SIZE sz={0,0};
+	int fit = 0;
+	int i = 0;
+	const int len = static_cast<int>(text.length());
+	if (unicodeMode) {
+		const TextWide tbuf(text, unicodeMode, codePage);
+		TextPositionsI poses(tbuf.tlen);
+		if (!::GetTextExtentExPointW(hdc, tbuf.buffer, tbuf.tlen, maxWidthMeasure, &fit, poses.buffer, &sz)) {
+			// Failure
+			return;
+		}
+		// Map the widths given for UTF-16 characters back onto the UTF-8 input string
+		for (int ui = 0; ui < fit; ui++) {
+			const unsigned char uch = text[i];
+			const unsigned int byteCount = UTF8BytesOfLead[uch];
+			if (byteCount == 4) {	// Non-BMP
+				ui++;
+			}
+			for (unsigned int bytePos=0; (bytePos<byteCount) && (i<len); bytePos++) {
+				positions[i++] = static_cast<XYPOSITION>(poses.buffer[ui]);
+			}
+		}
+	} else {
+		TextPositionsI poses(len);
+		if (!::GetTextExtentExPointA(hdc, text.data(), len, maxWidthMeasure, &fit, poses.buffer, &sz)) {
+			// Eeek - a NULL DC or other foolishness could cause this.
+			return;
+		}
+		while (i<fit) {
+			positions[i] = static_cast<XYPOSITION>(poses.buffer[i]);
+			i++;
+		}
+	}
+	// If any positions not filled in then use the last position for them
+	const XYPOSITION lastPos = (fit > 0) ? positions[fit - 1] : 0.0f;
+	std::fill(positions+i, positions + text.length(), lastPos);
+}
+
+XYPOSITION SurfaceGDI::Ascent(Font &font_) {
+	SetFont(font_);
+	TEXTMETRIC tm;
+	::GetTextMetrics(hdc, &tm);
+	return static_cast<XYPOSITION>(tm.tmAscent);
+}
+
+XYPOSITION SurfaceGDI::Descent(Font &font_) {
+	SetFont(font_);
+	TEXTMETRIC tm;
+	::GetTextMetrics(hdc, &tm);
+	return static_cast<XYPOSITION>(tm.tmDescent);
+}
+
+XYPOSITION SurfaceGDI::InternalLeading(Font &font_) {
+	SetFont(font_);
+	TEXTMETRIC tm;
+	::GetTextMetrics(hdc, &tm);
+	return static_cast<XYPOSITION>(tm.tmInternalLeading);
+}
+
+XYPOSITION SurfaceGDI::Height(Font &font_) {
+	SetFont(font_);
+	TEXTMETRIC tm;
+	::GetTextMetrics(hdc, &tm);
+	return static_cast<XYPOSITION>(tm.tmHeight);
+}
+
+XYPOSITION SurfaceGDI::AverageCharWidth(Font &font_) {
+	SetFont(font_);
+	TEXTMETRIC tm;
+	::GetTextMetrics(hdc, &tm);
+	return static_cast<XYPOSITION>(tm.tmAveCharWidth);
+}
+
+void SurfaceGDI::SetClip(PRectangle rc) {
+	::IntersectClipRect(hdc, static_cast<int>(rc.left), static_cast<int>(rc.top),
+		static_cast<int>(rc.right), static_cast<int>(rc.bottom));
+}
+
+void SurfaceGDI::FlushCachedState() {
+	pen = {};
+	brush = {};
+}
+
+void SurfaceGDI::SetUnicodeMode(bool unicodeMode_) {
+	unicodeMode=unicodeMode_;
+}
+
+void SurfaceGDI::SetDBCSMode(int codePage_) {
+	// No action on window as automatically handled by system.
+	codePage = codePage_;
+}
+
+void SurfaceGDI::SetBidiR2L(bool) {
+}
+
+#if defined(USE_D2D)
+
+namespace {
+
+constexpr D2D1_RECT_F RectangleFromPRectangle(PRectangle rc) noexcept {
+	return { rc.left, rc.top, rc.right, rc.bottom };
+}
+
+}
+
+class BlobInline;
+
+class SurfaceD2D : public Surface {
+	bool unicodeMode;
+	int x, y;
+
+	int codePage;
+	int codePageText;
+
+	ID2D1RenderTarget *pRenderTarget;
+	ID2D1BitmapRenderTarget *pBitmapRenderTarget;
+	bool ownRenderTarget;
+	int clipsActive;
+
+	IDWriteTextFormat *pTextFormat;
+	FLOAT yAscent;
+	FLOAT yDescent;
+	FLOAT yInternalLeading;
+
+	ID2D1SolidColorBrush *pBrush;
+
+	int logPixelsY;
+
+	void Clear() noexcept;
+	void SetFont(const Font &font_) noexcept;
+	HRESULT GetBitmap(ID2D1Bitmap **ppBitmap);
+
+public:
+	SurfaceD2D() noexcept;
+	// Deleted so SurfaceD2D objects can not be copied.
+	SurfaceD2D(const SurfaceD2D &) = delete;
+	SurfaceD2D(SurfaceD2D &&) = delete;
+	SurfaceD2D &operator=(const SurfaceD2D &) = delete;
+	SurfaceD2D &operator=(SurfaceD2D &&) = delete;
+	~SurfaceD2D() override;
+
+	void SetScale(WindowID wid) noexcept;
+	void Init(WindowID wid) override;
+	void Init(SurfaceID sid, WindowID wid) override;
+	void InitPixMap(int width, int height, Surface *surface_, WindowID wid) override;
+
+	void Release() override;
+	bool Initialised() override;
+
+	HRESULT FlushDrawing();
+
+	void PenColour(ColourDesired fore) override;
+	void D2DPenColour(ColourDesired fore, int alpha=255);
+	int LogPixelsY() override;
+	int DeviceHeightFont(int points) override;
+	void MoveTo(int x_, int y_) override;
+	void LineTo(int x_, int y_) override;
+	void Polygon(Point *pts, size_t npts, ColourDesired fore, ColourDesired back) override;
+	void RectangleDraw(PRectangle rc, ColourDesired fore, ColourDesired back) override;
+	void FillRectangle(PRectangle rc, ColourDesired back) override;
+	void FillRectangle(PRectangle rc, Surface &surfacePattern) override;
+	void RoundedRectangle(PRectangle rc, ColourDesired fore, ColourDesired back) override;
+	void AlphaRectangle(PRectangle rc, int cornerSize, ColourDesired fill, int alphaFill,
+		ColourDesired outline, int alphaOutline, int flags) override;
+	void GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) override;
+	void DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) override;
+	void Ellipse(PRectangle rc, ColourDesired fore, ColourDesired back) override;
+	void Copy(PRectangle rc, Point from, Surface &surfaceSource) override;
+
+	std::unique_ptr<IScreenLineLayout> Layout(const IScreenLine *screenLine) override;
+
+	void DrawTextCommon(PRectangle rc, const Font &font_, XYPOSITION ybase, std::string_view text, UINT fuOptions);
+	void DrawTextNoClip(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text, ColourDesired fore, ColourDesired back) override;
+	void DrawTextClipped(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text, ColourDesired fore, ColourDesired back) override;
+	void DrawTextTransparent(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text, ColourDesired fore) override;
+	void MeasureWidths(Font &font_, std::string_view text, XYPOSITION *positions) override;
+	XYPOSITION WidthText(Font &font_, std::string_view text) override;
+	XYPOSITION Ascent(Font &font_) override;
+	XYPOSITION Descent(Font &font_) override;
+	XYPOSITION InternalLeading(Font &font_) override;
+	XYPOSITION Height(Font &font_) override;
+	XYPOSITION AverageCharWidth(Font &font_) override;
+
+	void SetClip(PRectangle rc) override;
+	void FlushCachedState() override;
+
+	void SetUnicodeMode(bool unicodeMode_) override;
+	void SetDBCSMode(int codePage_) override;
+	void SetBidiR2L(bool bidiR2L_) override;
+};
+
+SurfaceD2D::SurfaceD2D() noexcept :
+	unicodeMode(false),
+	x(0), y(0) {
+
+	codePage = 0;
+	codePageText = 0;
+
+	pRenderTarget = nullptr;
+	pBitmapRenderTarget = nullptr;
+	ownRenderTarget = false;
+	clipsActive = 0;
+
+	// From selected font
+	pTextFormat = nullptr;
+	yAscent = 2;
+	yDescent = 1;
+	yInternalLeading = 0;
+
+	pBrush = nullptr;
+
+	logPixelsY = USER_DEFAULT_SCREEN_DPI;
+}
+
+SurfaceD2D::~SurfaceD2D() {
+	Clear();
+}
+
+void SurfaceD2D::Clear() noexcept {
+	ReleaseUnknown(pBrush);
+	if (pRenderTarget) {
+		while (clipsActive) {
+			pRenderTarget->PopAxisAlignedClip();
+			clipsActive--;
+		}
+		if (ownRenderTarget) {
+			pRenderTarget->EndDraw();
+			ReleaseUnknown(pRenderTarget);
+			ownRenderTarget = false;
+		}
+		pRenderTarget = nullptr;
+	}
+	pBitmapRenderTarget = nullptr;
+}
+
+void SurfaceD2D::Release() {
+	Clear();
+}
+
+void SurfaceD2D::SetScale(WindowID wid) noexcept {
+	logPixelsY = DpiForWindow(wid);
+}
+
+bool SurfaceD2D::Initialised() {
+	return pRenderTarget != nullptr;
+}
+
+HRESULT SurfaceD2D::FlushDrawing() {
+	return pRenderTarget->Flush();
+}
+
+void SurfaceD2D::Init(WindowID wid) {
+	Release();
+	SetScale(wid);
+}
+
+void SurfaceD2D::Init(SurfaceID sid, WindowID wid) {
+	Release();
+	SetScale(wid);
+	pRenderTarget = static_cast<ID2D1RenderTarget *>(sid);
+}
+
+void SurfaceD2D::InitPixMap(int width, int height, Surface *surface_, WindowID wid) {
+	Release();
+	SetScale(wid);
+	SurfaceD2D *psurfOther = dynamic_cast<SurfaceD2D *>(surface_);
+	// Should only ever be called with a SurfaceD2D, not a SurfaceGDI
+	PLATFORM_ASSERT(psurfOther);
+	const D2D1_SIZE_F desiredSize = D2D1::SizeF(static_cast<float>(width), static_cast<float>(height));
+	D2D1_PIXEL_FORMAT desiredFormat;
+#ifdef __MINGW32__
+	desiredFormat.format = DXGI_FORMAT_UNKNOWN;
+#else
+	desiredFormat = psurfOther->pRenderTarget->GetPixelFormat();
+#endif
+	desiredFormat.alphaMode = D2D1_ALPHA_MODE_IGNORE;
+	const HRESULT hr = psurfOther->pRenderTarget->CreateCompatibleRenderTarget(
+		&desiredSize, nullptr, &desiredFormat, D2D1_COMPATIBLE_RENDER_TARGET_OPTIONS_NONE, &pBitmapRenderTarget);
+	if (SUCCEEDED(hr)) {
+		pRenderTarget = pBitmapRenderTarget;
+		pRenderTarget->BeginDraw();
+		ownRenderTarget = true;
+	}
+	SetUnicodeMode(psurfOther->unicodeMode);
+	SetDBCSMode(psurfOther->codePage);
+}
+
+HRESULT SurfaceD2D::GetBitmap(ID2D1Bitmap **ppBitmap) {
+	PLATFORM_ASSERT(pBitmapRenderTarget);
+	return pBitmapRenderTarget->GetBitmap(ppBitmap);
+}
+
+void SurfaceD2D::PenColour(ColourDesired fore) {
+	D2DPenColour(fore);
+}
+
+void SurfaceD2D::D2DPenColour(ColourDesired fore, int alpha) {
+	if (pRenderTarget) {
+		D2D_COLOR_F col;
+		col.r = fore.GetRedComponent();
+		col.g = fore.GetGreenComponent();
+		col.b = fore.GetBlueComponent();
+		col.a = alpha / 255.0f;
+		if (pBrush) {
+			pBrush->SetColor(col);
+		} else {
+			const HRESULT hr = pRenderTarget->CreateSolidColorBrush(col, &pBrush);
+			if (!SUCCEEDED(hr)) {
+				ReleaseUnknown(pBrush);
+			}
+		}
+	}
+}
+
+void SurfaceD2D::SetFont(const Font &font_) noexcept {
+	const FormatAndMetrics *pfm = FamFromFontID(font_.GetID());
+	PLATFORM_ASSERT(pfm->technology == SCWIN_TECH_DIRECTWRITE);
+	pTextFormat = pfm->pTextFormat;
+	yAscent = pfm->yAscent;
+	yDescent = pfm->yDescent;
+	yInternalLeading = pfm->yInternalLeading;
+	codePageText = codePage;
+	if (!unicodeMode && pfm->characterSet) {
+		codePageText = Scintilla::CodePageFromCharSet(pfm->characterSet, codePage);
+	}
+	if (pRenderTarget) {
+		D2D1_TEXT_ANTIALIAS_MODE aaMode;
+		aaMode = DWriteMapFontQuality(pfm->extraFontFlag);
+
+		if (aaMode == D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE && customClearTypeRenderingParams)
+			pRenderTarget->SetTextRenderingParams(customClearTypeRenderingParams);
+		else if (defaultRenderingParams)
+			pRenderTarget->SetTextRenderingParams(defaultRenderingParams);
+
+		pRenderTarget->SetTextAntialiasMode(aaMode);
+	}
+}
+
+int SurfaceD2D::LogPixelsY() {
+	return logPixelsY;
+}
+
+int SurfaceD2D::DeviceHeightFont(int points) {
+	return ::MulDiv(points, LogPixelsY(), 72);
+}
+
+void SurfaceD2D::MoveTo(int x_, int y_) {
+	x = x_;
+	y = y_;
+}
+
+static constexpr int Delta(int difference) noexcept {
+	if (difference < 0)
+		return -1;
+	else if (difference > 0)
+		return 1;
+	else
+		return 0;
+}
+
+void SurfaceD2D::LineTo(int x_, int y_) {
+	if (pRenderTarget) {
+		const int xDiff = x_ - x;
+		const int xDelta = Delta(xDiff);
+		const int yDiff = y_ - y;
+		const int yDelta = Delta(yDiff);
+		if ((xDiff == 0) || (yDiff == 0)) {
+			// Horizontal or vertical lines can be more precisely drawn as a filled rectangle
+			const int xEnd = x_ - xDelta;
+			const int left = std::min(x, xEnd);
+			const int width = std::abs(x - xEnd) + 1;
+			const int yEnd = y_ - yDelta;
+			const int top = std::min(y, yEnd);
+			const int height = std::abs(y - yEnd) + 1;
+			const D2D1_RECT_F rectangle1 = D2D1::RectF(static_cast<float>(left), static_cast<float>(top),
+				static_cast<float>(left+width), static_cast<float>(top+height));
+			pRenderTarget->FillRectangle(&rectangle1, pBrush);
+		} else if ((std::abs(xDiff) == std::abs(yDiff))) {
+			// 45 degree slope
+			pRenderTarget->DrawLine(D2D1::Point2F(x + 0.5f, y + 0.5f),
+				D2D1::Point2F(x_ + 0.5f - xDelta, y_ + 0.5f - yDelta), pBrush);
+		} else {
+			// Line has a different slope so difficult to avoid last pixel
+			pRenderTarget->DrawLine(D2D1::Point2F(x + 0.5f, y + 0.5f),
+				D2D1::Point2F(x_ + 0.5f, y_ + 0.5f), pBrush);
+		}
+		x = x_;
+		y = y_;
+	}
+}
+
+void SurfaceD2D::Polygon(Point *pts, size_t npts, ColourDesired fore, ColourDesired back) {
+	PLATFORM_ASSERT(pRenderTarget && (npts > 2));
+	if (pRenderTarget) {
+		ID2D1PathGeometry *geometry = nullptr;
+		HRESULT hr = pD2DFactory->CreatePathGeometry(&geometry);
+		PLATFORM_ASSERT(geometry);
+		if (SUCCEEDED(hr) && geometry) {
+			ID2D1GeometrySink *sink = nullptr;
+			hr = geometry->Open(&sink);
+			PLATFORM_ASSERT(sink);
+			if (SUCCEEDED(hr) && sink) {
+				sink->BeginFigure(D2D1::Point2F(pts[0].x + 0.5f, pts[0].y + 0.5f), D2D1_FIGURE_BEGIN_FILLED);
+				for (size_t i=1; i<npts; i++) {
+					sink->AddLine(D2D1::Point2F(pts[i].x + 0.5f, pts[i].y + 0.5f));
+				}
+				sink->EndFigure(D2D1_FIGURE_END_CLOSED);
+				sink->Close();
+				ReleaseUnknown(sink);
+
+				D2DPenColour(back);
+				pRenderTarget->FillGeometry(geometry,pBrush);
+				D2DPenColour(fore);
+				pRenderTarget->DrawGeometry(geometry,pBrush);
+			}
+			ReleaseUnknown(geometry);
+		}
+	}
+}
+
+void SurfaceD2D::RectangleDraw(PRectangle rc, ColourDesired fore, ColourDesired back) {
+	if (pRenderTarget) {
+		const D2D1_RECT_F rectangle1 = D2D1::RectF(std::round(rc.left) + 0.5f, rc.top+0.5f, std::round(rc.right) - 0.5f, rc.bottom-0.5f);
+		D2DPenColour(back);
+		pRenderTarget->FillRectangle(&rectangle1, pBrush);
+		D2DPenColour(fore);
+		pRenderTarget->DrawRectangle(&rectangle1, pBrush);
+	}
+}
+
+void SurfaceD2D::FillRectangle(PRectangle rc, ColourDesired back) {
+	if (pRenderTarget) {
+		D2DPenColour(back);
+		const D2D1_RECT_F rectangle1 = D2D1::RectF(std::round(rc.left), rc.top, std::round(rc.right), rc.bottom);
+		pRenderTarget->FillRectangle(&rectangle1, pBrush);
+	}
+}
+
+void SurfaceD2D::FillRectangle(PRectangle rc, Surface &surfacePattern) {
+	SurfaceD2D *psurfOther = dynamic_cast<SurfaceD2D *>(&surfacePattern);
+	PLATFORM_ASSERT(psurfOther);
+	psurfOther->FlushDrawing();
+	ID2D1Bitmap *pBitmap = nullptr;
+	HRESULT hr = psurfOther->GetBitmap(&pBitmap);
+	if (SUCCEEDED(hr) && pBitmap) {
+		ID2D1BitmapBrush *pBitmapBrush = nullptr;
+		const D2D1_BITMAP_BRUSH_PROPERTIES brushProperties =
+	        D2D1::BitmapBrushProperties(D2D1_EXTEND_MODE_WRAP, D2D1_EXTEND_MODE_WRAP,
+			D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR);
+		// Create the bitmap brush.
+		hr = pRenderTarget->CreateBitmapBrush(pBitmap, brushProperties, &pBitmapBrush);
+		ReleaseUnknown(pBitmap);
+		if (SUCCEEDED(hr) && pBitmapBrush) {
+			pRenderTarget->FillRectangle(
+				D2D1::RectF(rc.left, rc.top, rc.right, rc.bottom),
+				pBitmapBrush);
+			ReleaseUnknown(pBitmapBrush);
+		}
+	}
+}
+
+void SurfaceD2D::RoundedRectangle(PRectangle rc, ColourDesired fore, ColourDesired back) {
+	if (pRenderTarget) {
+		D2D1_ROUNDED_RECT roundedRectFill = {
+			D2D1::RectF(rc.left+1.0f, rc.top+1.0f, rc.right-1.0f, rc.bottom-1.0f),
+			4, 4};
+		D2DPenColour(back);
+		pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush);
+
+		D2D1_ROUNDED_RECT roundedRect = {
+			D2D1::RectF(rc.left + 0.5f, rc.top+0.5f, rc.right - 0.5f, rc.bottom-0.5f),
+			4, 4};
+		D2DPenColour(fore);
+		pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush);
+	}
+}
+
+void SurfaceD2D::AlphaRectangle(PRectangle rc, int cornerSize, ColourDesired fill, int alphaFill,
+		ColourDesired outline, int alphaOutline, int /* flags*/ ) {
+	if (pRenderTarget) {
+		if (cornerSize == 0) {
+			// When corner size is zero, draw square rectangle to prevent blurry pixels at corners
+			const D2D1_RECT_F rectFill = D2D1::RectF(std::round(rc.left) + 1.0f, rc.top + 1.0f, std::round(rc.right) - 1.0f, rc.bottom - 1.0f);
+			D2DPenColour(fill, alphaFill);
+			pRenderTarget->FillRectangle(rectFill, pBrush);
+
+			const D2D1_RECT_F rectOutline = D2D1::RectF(std::round(rc.left) + 0.5f, rc.top + 0.5f, std::round(rc.right) - 0.5f, rc.bottom - 0.5f);
+			D2DPenColour(outline, alphaOutline);
+			pRenderTarget->DrawRectangle(rectOutline, pBrush);
+		} else {
+			const float cornerSizeF = static_cast<float>(cornerSize);
+			D2D1_ROUNDED_RECT roundedRectFill = {
+				D2D1::RectF(std::round(rc.left) + 1.0f, rc.top + 1.0f, std::round(rc.right) - 1.0f, rc.bottom - 1.0f),
+				cornerSizeF - 1.0f, cornerSizeF - 1.0f };
+			D2DPenColour(fill, alphaFill);
+			pRenderTarget->FillRoundedRectangle(roundedRectFill, pBrush);
+
+			D2D1_ROUNDED_RECT roundedRect = {
+				D2D1::RectF(std::round(rc.left) + 0.5f, rc.top + 0.5f, std::round(rc.right) - 0.5f, rc.bottom - 0.5f),
+				cornerSizeF, cornerSizeF};
+			D2DPenColour(outline, alphaOutline);
+			pRenderTarget->DrawRoundedRectangle(roundedRect, pBrush);
+		}
+	}
+}
+
+namespace {
+
+D2D_COLOR_F ColorFromColourAlpha(ColourAlpha colour) noexcept {
+	D2D_COLOR_F col;
+	col.r = colour.GetRedComponent();
+	col.g = colour.GetGreenComponent();
+	col.b = colour.GetBlueComponent();
+	col.a = colour.GetAlphaComponent();
+	return col;
+}
+
+}
+
+void SurfaceD2D::GradientRectangle(PRectangle rc, const std::vector<ColourStop> &stops, GradientOptions options) {
+	if (pRenderTarget) {
+		D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES lgbp;
+		lgbp.startPoint = D2D1::Point2F(rc.left, rc.top);
+		switch (options) {
+		case GradientOptions::leftToRight:
+			lgbp.endPoint = D2D1::Point2F(rc.right, rc.top);
+			break;
+		case GradientOptions::topToBottom:
+		default:
+			lgbp.endPoint = D2D1::Point2F(rc.left, rc.bottom);
+			break;
+		}
+
+		std::vector<D2D1_GRADIENT_STOP> gradientStops;
+		for (const ColourStop &stop : stops) {
+			gradientStops.push_back({ stop.position, ColorFromColourAlpha(stop.colour) });
+		}
+		ID2D1GradientStopCollection *pGradientStops = nullptr;
+		HRESULT hr = pRenderTarget->CreateGradientStopCollection(
+			gradientStops.data(), static_cast<UINT32>(gradientStops.size()), &pGradientStops);
+		if (FAILED(hr) || !pGradientStops) {
+			return;
+		}
+		ID2D1LinearGradientBrush *pBrushLinear = nullptr;
+		hr = pRenderTarget->CreateLinearGradientBrush(
+			lgbp, pGradientStops, &pBrushLinear);
+		if (SUCCEEDED(hr) && pBrushLinear) {
+			const D2D1_RECT_F rectangle = D2D1::RectF(std::round(rc.left), rc.top, std::round(rc.right), rc.bottom);
+			pRenderTarget->FillRectangle(&rectangle, pBrushLinear);
+			ReleaseUnknown(pBrushLinear);
+		}
+		ReleaseUnknown(pGradientStops);
+	}
+}
+
+void SurfaceD2D::DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage) {
+	if (pRenderTarget) {
+		if (rc.Width() > width)
+			rc.left += std::floor((rc.Width() - width) / 2);
+		rc.right = rc.left + width;
+		if (rc.Height() > height)
+			rc.top += std::floor((rc.Height() - height) / 2);
+		rc.bottom = rc.top + height;
+
+		std::vector<unsigned char> image(RGBAImage::bytesPerPixel * height * width);
+		RGBAImage::BGRAFromRGBA(image.data(), pixelsImage, static_cast<ptrdiff_t>(height) * width);
+
+		ID2D1Bitmap *bitmap = nullptr;
+		const D2D1_SIZE_U size = D2D1::SizeU(width, height);
+		D2D1_BITMAP_PROPERTIES props = {{DXGI_FORMAT_B8G8R8A8_UNORM,
+		    D2D1_ALPHA_MODE_PREMULTIPLIED}, 72.0, 72.0};
+		const HRESULT hr = pRenderTarget->CreateBitmap(size, image.data(),
+                  width * 4, &props, &bitmap);
+		if (SUCCEEDED(hr)) {
+			const D2D1_RECT_F rcDestination = RectangleFromPRectangle(rc);
+			pRenderTarget->DrawBitmap(bitmap, rcDestination);
+			ReleaseUnknown(bitmap);
+		}
+	}
+}
+
+void SurfaceD2D::Ellipse(PRectangle rc, ColourDesired fore, ColourDesired back) {
+	if (pRenderTarget) {
+		const FLOAT radius = rc.Width() / 2.0f;
+		D2D1_ELLIPSE ellipse = {
+			D2D1::Point2F((rc.left + rc.right) / 2.0f, (rc.top + rc.bottom) / 2.0f),
+			radius,radius};
+
+		PenColour(back);
+		pRenderTarget->FillEllipse(ellipse, pBrush);
+		PenColour(fore);
+		pRenderTarget->DrawEllipse(ellipse, pBrush);
+	}
+}
+
+void SurfaceD2D::Copy(PRectangle rc, Point from, Surface &surfaceSource) {
+	SurfaceD2D &surfOther = dynamic_cast<SurfaceD2D &>(surfaceSource);
+	surfOther.FlushDrawing();
+	ID2D1Bitmap *pBitmap = nullptr;
+	HRESULT hr = surfOther.GetBitmap(&pBitmap);
+	if (SUCCEEDED(hr) && pBitmap) {
+		const D2D1_RECT_F rcDestination = RectangleFromPRectangle(rc);
+		D2D1_RECT_F rcSource = {from.x, from.y, from.x + rc.Width(), from.y + rc.Height()};
+		pRenderTarget->DrawBitmap(pBitmap, rcDestination, 1.0f,
+			D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, rcSource);
+		hr = pRenderTarget->Flush();
+		if (FAILED(hr)) {
+			Platform::DebugPrintf("Failed Flush 0x%lx\n", hr);
+		}
+		ReleaseUnknown(pBitmap);
+	}
+}
+
+class BlobInline : public IDWriteInlineObject {
+	XYPOSITION width;
+
+	// IUnknown
+	STDMETHODIMP QueryInterface(REFIID riid, PVOID *ppv) override;
+	STDMETHODIMP_(ULONG)AddRef() override;
+	STDMETHODIMP_(ULONG)Release() override;
+
+	// IDWriteInlineObject
+	COM_DECLSPEC_NOTHROW STDMETHODIMP Draw(
+		void *clientDrawingContext,
+		IDWriteTextRenderer *renderer,
+		FLOAT originX,
+		FLOAT originY,
+		BOOL isSideways,
+		BOOL isRightToLeft,
+		IUnknown *clientDrawingEffect
+		) override;
+	COM_DECLSPEC_NOTHROW STDMETHODIMP GetMetrics(DWRITE_INLINE_OBJECT_METRICS *metrics) override;
+	COM_DECLSPEC_NOTHROW STDMETHODIMP GetOverhangMetrics(DWRITE_OVERHANG_METRICS *overhangs) override;
+	COM_DECLSPEC_NOTHROW STDMETHODIMP GetBreakConditions(
+		DWRITE_BREAK_CONDITION *breakConditionBefore,
+		DWRITE_BREAK_CONDITION *breakConditionAfter) override;
+public:
+	BlobInline(XYPOSITION width_=0.0f) noexcept : width(width_) {
+	}
+	// Defaulted so BlobInline objects can be copied.
+	BlobInline(const BlobInline &) = default;
+	BlobInline(BlobInline &&) = default;
+	BlobInline &operator=(const BlobInline &) = default;
+	BlobInline &operator=(BlobInline &&) = default;
+	virtual ~BlobInline() {
+	}
+};
+
+/// Implement IUnknown
+STDMETHODIMP BlobInline::QueryInterface(REFIID riid, PVOID *ppv) {
+	if (!ppv)
+		return E_POINTER;
+	// Never called so not checked.
+	*ppv = nullptr;
+	if (riid == IID_IUnknown)
+		*ppv = static_cast<IUnknown *>(this);
+	if (riid == __uuidof(IDWriteInlineObject))
+		*ppv = static_cast<IDWriteInlineObject *>(this);
+	if (!*ppv)
+		return E_NOINTERFACE;
+	return S_OK;
+}
+
+STDMETHODIMP_(ULONG) BlobInline::AddRef() {
+	// Lifetime tied to Platform methods so ignore any reference operations.
+	return 1;
+}
+
+STDMETHODIMP_(ULONG) BlobInline::Release() {
+	// Lifetime tied to Platform methods so ignore any reference operations.
+	return 1;
+}
+
+/// Implement IDWriteInlineObject
+COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::Draw(
+	void*,
+	IDWriteTextRenderer*,
+	FLOAT,
+	FLOAT,
+	BOOL,
+	BOOL,
+	IUnknown*) {
+	// Since not performing drawing, not necessary to implement
+	// Could be implemented by calling back into platform-independent code.
+	// This would allow more of the drawing to be mediated through DirectWrite.
+	return S_OK;
+}
+
+COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::GetMetrics(
+	DWRITE_INLINE_OBJECT_METRICS *metrics
+) {
+	if (!metrics)
+		return E_POINTER;
+	metrics->width = width;
+	metrics->height = 2;
+	metrics->baseline = 1;
+	metrics->supportsSideways = FALSE;
+	return S_OK;
+}
+
+COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::GetOverhangMetrics(
+	DWRITE_OVERHANG_METRICS *overhangs
+) {
+	if (!overhangs)
+		return E_POINTER;
+	overhangs->left = 0;
+	overhangs->top = 0;
+	overhangs->right = 0;
+	overhangs->bottom = 0;
+	return S_OK;
+}
+
+COM_DECLSPEC_NOTHROW HRESULT STDMETHODCALLTYPE BlobInline::GetBreakConditions(
+	DWRITE_BREAK_CONDITION *breakConditionBefore,
+	DWRITE_BREAK_CONDITION *breakConditionAfter
+) {
+	if (!breakConditionBefore || !breakConditionAfter)
+		return E_POINTER;
+	// Since not performing 2D layout, not necessary to implement
+	*breakConditionBefore = DWRITE_BREAK_CONDITION_NEUTRAL;
+	*breakConditionAfter = DWRITE_BREAK_CONDITION_NEUTRAL;
+	return S_OK;
+}
+
+class ScreenLineLayout : public IScreenLineLayout {
+	IDWriteTextLayout *textLayout = nullptr;
+	std::string text;
+	std::wstring buffer;
+	std::vector<BlobInline> blobs;
+	static void FillTextLayoutFormats(const IScreenLine *screenLine, IDWriteTextLayout *textLayout, std::vector<BlobInline> &blobs);
+	static std::wstring ReplaceRepresentation(std::string_view text);
+	static size_t GetPositionInLayout(std::string_view text, size_t position);
+public:
+	ScreenLineLayout(const IScreenLine *screenLine);
+	// Deleted so ScreenLineLayout objects can not be copied
+	ScreenLineLayout(const ScreenLineLayout &) = delete;
+	ScreenLineLayout(ScreenLineLayout &&) = delete;
+	ScreenLineLayout &operator=(const ScreenLineLayout &) = delete;
+	ScreenLineLayout &operator=(ScreenLineLayout &&) = delete;
+	~ScreenLineLayout() override;
+	size_t PositionFromX(XYPOSITION xDistance, bool charPosition) override;
+	XYPOSITION XFromPosition(size_t caretPosition) override;
+	std::vector<Interval> FindRangeIntervals(size_t start, size_t end) override;
+};
+
+// Each char can have its own style, so we fill the textLayout with the textFormat of each char
+
+void ScreenLineLayout::FillTextLayoutFormats(const IScreenLine *screenLine, IDWriteTextLayout *textLayout, std::vector<BlobInline> &blobs) {
+	// Reserve enough entries up front so they are not moved and the pointers handed
+	// to textLayout remain valid.
+	const ptrdiff_t numRepresentations = screenLine->RepresentationCount();
+	std::string_view text = screenLine->Text();
+	const ptrdiff_t numTabs = std::count(std::begin(text), std::end(text), '\t');
+	blobs.reserve(numRepresentations + numTabs);
+
+	UINT32 layoutPosition = 0;
+
+	for (size_t bytePosition = 0; bytePosition < screenLine->Length();) {
+		const unsigned char uch = screenLine->Text()[bytePosition];
+		const unsigned int byteCount = UTF8BytesOfLead[uch];
+		const UINT32 codeUnits = UTF16LengthFromUTF8ByteCount(byteCount);
+		const DWRITE_TEXT_RANGE textRange = { layoutPosition, codeUnits };
+
+		XYPOSITION representationWidth = screenLine->RepresentationWidth(bytePosition);
+		if ((representationWidth == 0.0f) && (screenLine->Text()[bytePosition] == '\t')) {
+			Point realPt;
+			DWRITE_HIT_TEST_METRICS realCaretMetrics {};
+			textLayout->HitTestTextPosition(
+				layoutPosition,
+				false, // trailing if false, else leading edge
+				&realPt.x,
+				&realPt.y,
+				&realCaretMetrics
+			);
+
+			const XYPOSITION nextTab = screenLine->TabPositionAfter(realPt.x);
+			representationWidth = nextTab - realPt.x;
+		}
+		if (representationWidth > 0.0f) {
+			blobs.push_back(BlobInline(representationWidth));
+			textLayout->SetInlineObject(&blobs.back(), textRange);
+		};
+
+		FormatAndMetrics *pfm =
+			static_cast<FormatAndMetrics *>(screenLine->FontOfPosition(bytePosition)->GetID());
+
+		const unsigned int fontFamilyNameSize = pfm->pTextFormat->GetFontFamilyNameLength();
+		std::wstring fontFamilyName(fontFamilyNameSize, 0);
+		const HRESULT hrFamily = pfm->pTextFormat->GetFontFamilyName(fontFamilyName.data(), fontFamilyNameSize + 1);
+		if (SUCCEEDED(hrFamily)) {
+			textLayout->SetFontFamilyName(fontFamilyName.c_str(), textRange);
+		}
+
+		textLayout->SetFontSize(pfm->pTextFormat->GetFontSize(), textRange);
+		textLayout->SetFontWeight(pfm->pTextFormat->GetFontWeight(), textRange);
+		textLayout->SetFontStyle(pfm->pTextFormat->GetFontStyle(), textRange);
+
+		const unsigned int localeNameSize = pfm->pTextFormat->GetLocaleNameLength();
+		std::wstring localeName(localeNameSize, 0);
+		const HRESULT hrLocale = pfm->pTextFormat->GetLocaleName(localeName.data(), localeNameSize + 1);
+		if (SUCCEEDED(hrLocale)) {
+			textLayout->SetLocaleName(localeName.c_str(), textRange);
+		}
+
+		textLayout->SetFontStretch(pfm->pTextFormat->GetFontStretch(), textRange);
+
+		IDWriteFontCollection *fontCollection = nullptr;
+		if (SUCCEEDED(pfm->pTextFormat->GetFontCollection(&fontCollection))) {
+			textLayout->SetFontCollection(fontCollection, textRange);
+		}
+
+		bytePosition += byteCount;
+		layoutPosition += codeUnits;
+	}
+
+}
+
+/* Convert to a wide character string and replace tabs with X to stop DirectWrite tab expansion */
+
+std::wstring ScreenLineLayout::ReplaceRepresentation(std::string_view text) {
+	const TextWide wideText(text, true);
+	std::wstring ws(wideText.buffer, wideText.tlen);
+	std::replace(ws.begin(), ws.end(), L'\t', L'X');
+	return ws;
+}
+
+// Finds the position in the wide character version of the text.
+
+size_t ScreenLineLayout::GetPositionInLayout(std::string_view text, size_t position) {
+	const std::string_view textUptoPosition = text.substr(0, position);
+	return UTF16Length(textUptoPosition);
+}
+
+ScreenLineLayout::ScreenLineLayout(const IScreenLine *screenLine) {
+	// If the text is empty, then no need to go through this function
+	if (!screenLine || !screenLine->Length())
+		return;
+
+	text = screenLine->Text();
+
+	// Get textFormat
+	FormatAndMetrics *pfm = static_cast<FormatAndMetrics *>(screenLine->FontOfPosition(0)->GetID());
+
+	if (!pIDWriteFactory || !pfm->pTextFormat) {
+		return;
+	}
+
+	// Convert the string to wstring and replace the original control characters with their representative chars.
+	buffer = ReplaceRepresentation(screenLine->Text());
+
+	// Create a text layout
+	const HRESULT hrCreate = pIDWriteFactory->CreateTextLayout(buffer.c_str(), static_cast<UINT32>(buffer.length()),
+		pfm->pTextFormat, screenLine->Width(), screenLine->Height(), &textLayout);
+	if (!SUCCEEDED(hrCreate)) {
+		return;
+	}
+
+	// Fill the textLayout chars with their own formats
+	FillTextLayoutFormats(screenLine, textLayout, blobs);
+}
+
+ScreenLineLayout::~ScreenLineLayout() {
+	ReleaseUnknown(textLayout);
+}
+
+// Get the position from the provided x
+
+size_t ScreenLineLayout::PositionFromX(XYPOSITION xDistance, bool charPosition) {
+	if (!textLayout) {
+		return 0;
+	}
+
+	// Returns the text position corresponding to the mouse x,y.
+	// If hitting the trailing side of a cluster, return the
+	// leading edge of the following text position.
+
+	BOOL isTrailingHit = FALSE;
+	BOOL isInside = FALSE;
+	DWRITE_HIT_TEST_METRICS caretMetrics {};
+
+	textLayout->HitTestPoint(
+		xDistance,
+		0.0f,
+		&isTrailingHit,
+		&isInside,
+		&caretMetrics
+	);
+
+	DWRITE_HIT_TEST_METRICS hitTestMetrics {};
+	if (isTrailingHit) {
+		FLOAT caretX = 0.0f;
+		FLOAT caretY = 0.0f;
+
+		// Uses hit-testing to align the current caret position to a whole cluster,
+		// rather than residing in the middle of a base character + diacritic,
+		// surrogate pair, or character + UVS.
+
+		// Align the caret to the nearest whole cluster.
+		textLayout->HitTestTextPosition(
+			caretMetrics.textPosition,
+			false,
+			&caretX,
+			&caretY,
+			&hitTestMetrics
+		);
+	}
+
+	size_t pos;
+	if (charPosition) {
+		pos = isTrailingHit ? hitTestMetrics.textPosition : caretMetrics.textPosition;
+	} else {
+		pos = isTrailingHit ? hitTestMetrics.textPosition + hitTestMetrics.length : caretMetrics.textPosition;
+	}
+
+	// Get the character position in original string
+	return UTF8PositionFromUTF16Position(text, pos);
+}
+
+// Finds the point of the caret position
+
+XYPOSITION ScreenLineLayout::XFromPosition(size_t caretPosition) {
+	if (!textLayout) {
+		return 0.0;
+	}
+	// Convert byte positions to wchar_t positions
+	const size_t position = GetPositionInLayout(text, caretPosition);
+
+	// Translate text character offset to point x,y.
+	DWRITE_HIT_TEST_METRICS caretMetrics {};
+	Point pt;
+
+	textLayout->HitTestTextPosition(
+		static_cast<UINT32>(position),
+		false, // trailing if false, else leading edge
+		&pt.x,
+		&pt.y,
+		&caretMetrics
+	);
+
+	return pt.x;
+}
+
+// Find the selection range rectangles
+
+std::vector<Interval> ScreenLineLayout::FindRangeIntervals(size_t start, size_t end) {
+	std::vector<Interval> ret;
+
+	if (!textLayout || (start == end)) {
+		return ret;
+	}
+
+	// Convert byte positions to wchar_t positions
+	const size_t startPos = GetPositionInLayout(text, start);
+	const size_t endPos = GetPositionInLayout(text, end);
+
+	// Find selection range length
+	const size_t rangeLength = (endPos > startPos) ? (endPos - startPos) : (startPos - endPos);
+
+	// Determine actual number of hit-test ranges
+	UINT32 actualHitTestCount = 0;
+
+	// First try with 2 elements and if more needed, allocate.
+	std::vector<DWRITE_HIT_TEST_METRICS> hitTestMetrics(2);
+	textLayout->HitTestTextRange(
+		static_cast<UINT32>(startPos),
+		static_cast<UINT32>(rangeLength),
+		0, // x
+		0, // y
+		hitTestMetrics.data(),
+		static_cast<UINT32>(hitTestMetrics.size()),
+		&actualHitTestCount
+	);
+
+	if (actualHitTestCount == 0) {
+		return ret;
 	}
-	~VarBuffer() {
-		if (buffer != bufferStandard) {
-			delete []buffer;
-			buffer = 0;
-		}
+
+	if (hitTestMetrics.size() < actualHitTestCount) {
+		// Allocate enough room to return all hit-test metrics.
+		hitTestMetrics.resize(actualHitTestCount);
+		textLayout->HitTestTextRange(
+			static_cast<UINT32>(startPos),
+			static_cast<UINT32>(rangeLength),
+			0, // x
+			0, // y
+			hitTestMetrics.data(),
+			static_cast<UINT32>(hitTestMetrics.size()),
+			&actualHitTestCount
+		);
 	}
-};
 
-const int stackBufferLength = 10000;
-class TextWide : public VarBuffer<wchar_t, stackBufferLength> {
-public:
-	int tlen;
-	TextWide(const char *s, int len, bool unicodeMode, int codePage=0) :
-		VarBuffer<wchar_t, stackBufferLength>(len) {
-		if (unicodeMode) {
-			tlen = UTF16FromUTF8(s, len, buffer, len);
-		} else {
-			// Support Asian string display in 9x English
-			tlen = ::MultiByteToWideChar(codePage, 0, s, len, buffer, len);
-		}
+	// Get the selection ranges behind the text.
+
+	for (size_t i = 0; i < actualHitTestCount; ++i) {
+		// Store selection rectangle
+		const DWRITE_HIT_TEST_METRICS &htm = hitTestMetrics[i];
+		Interval selectionInterval;
+
+		selectionInterval.left = htm.left;
+		selectionInterval.right = htm.left + htm.width;
+
+		ret.push_back(selectionInterval);
 	}
-};
-typedef VarBuffer<int, stackBufferLength> TextPositions;
 
-void SurfaceImpl::DrawTextCommon(PRectangle rc, Font &font_, int ybase, const char *s, int len, UINT fuOptions) {
+	return ret;
+}
+
+std::unique_ptr<IScreenLineLayout> SurfaceD2D::Layout(const IScreenLine *screenLine) {
+	return std::make_unique<ScreenLineLayout>(screenLine);
+}
+
+void SurfaceD2D::DrawTextCommon(PRectangle rc, const Font &font_, XYPOSITION ybase, std::string_view text, UINT fuOptions) {
 	SetFont(font_);
-	RECT rcw = RectFromPRectangle(rc);
-	SIZE sz={0,0};
-	int pos = 0;
-	int x = rc.left;
-
-	// Text drawing may fail if the text is too big.
-	// If it does fail, slice up into segments and draw each segment.
-	const int maxSegmentLength = 0x200;
-
-	if ((!unicodeMode) && (IsNT() || (codePage==0) || win9xACPSame)) {
-		// Use ANSI calls
-		int lenDraw = Platform::Minimum(len, maxLenText);
-		if (!::ExtTextOutA(hdc, x, ybase, fuOptions, &rcw, s, lenDraw, NULL)) {
-			while (lenDraw > pos) {
-				int seglen = Platform::Minimum(maxSegmentLength, lenDraw - pos);
-				if (!::ExtTextOutA(hdc, x, ybase, fuOptions, &rcw, s+pos, seglen, NULL)) {
-					PLATFORM_ASSERT(false);
-					return;
-				}
-				::GetTextExtentPoint32A(hdc, s+pos, seglen, &sz);
-				x += sz.cx;
-				pos += seglen;
-			}
+
+	// Use Unicode calls
+	const TextWide tbuf(text, unicodeMode, codePageText);
+	if (pRenderTarget && pTextFormat && pBrush) {
+		if (fuOptions & ETO_CLIPPED) {
+			const D2D1_RECT_F rcClip = RectangleFromPRectangle(rc);
+			pRenderTarget->PushAxisAlignedClip(rcClip, D2D1_ANTIALIAS_MODE_ALIASED);
 		}
-	} else {
-		// Use Unicode calls
-		const TextWide tbuf(s, len, unicodeMode, codePage);
-		if (!::ExtTextOutW(hdc, x, ybase, fuOptions, &rcw, tbuf.buffer, tbuf.tlen, NULL)) {
-			while (tbuf.tlen > pos) {
-				int seglen = Platform::Minimum(maxSegmentLength, tbuf.tlen - pos);
-				if (!::ExtTextOutW(hdc, x, ybase, fuOptions, &rcw, tbuf.buffer+pos, seglen, NULL)) {
-					PLATFORM_ASSERT(false);
-					return;
-				}
-				::GetTextExtentPoint32W(hdc, tbuf.buffer+pos, seglen, &sz);
-				x += sz.cx;
-				pos += seglen;
-			}
+
+		// Explicitly creating a text layout appears a little faster
+		IDWriteTextLayout *pTextLayout = nullptr;
+		const HRESULT hr = pIDWriteFactory->CreateTextLayout(tbuf.buffer, tbuf.tlen, pTextFormat,
+				rc.Width(), rc.Height(), &pTextLayout);
+		if (SUCCEEDED(hr)) {
+			D2D1_POINT_2F origin = {rc.left, ybase-yAscent};
+			pRenderTarget->DrawTextLayout(origin, pTextLayout, pBrush, d2dDrawTextOptions);
+			ReleaseUnknown(pTextLayout);
+		}
+
+		if (fuOptions & ETO_CLIPPED) {
+			pRenderTarget->PopAxisAlignedClip();
 		}
 	}
 }
 
-void SurfaceImpl::DrawTextNoClip(PRectangle rc, Font &font_, int ybase, const char *s, int len,
-	ColourAllocated fore, ColourAllocated back) {
-	::SetTextColor(hdc, fore.AsLong());
-	::SetBkColor(hdc, back.AsLong());
-	DrawTextCommon(rc, font_, ybase, s, len, ETO_OPAQUE);
+void SurfaceD2D::DrawTextNoClip(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text,
+	ColourDesired fore, ColourDesired back) {
+	if (pRenderTarget) {
+		FillRectangle(rc, back);
+		D2DPenColour(fore);
+		DrawTextCommon(rc, font_, ybase, text, ETO_OPAQUE);
+	}
 }
 
-void SurfaceImpl::DrawTextClipped(PRectangle rc, Font &font_, int ybase, const char *s, int len,
-	ColourAllocated fore, ColourAllocated back) {
-	::SetTextColor(hdc, fore.AsLong());
-	::SetBkColor(hdc, back.AsLong());
-	DrawTextCommon(rc, font_, ybase, s, len, ETO_OPAQUE | ETO_CLIPPED);
+void SurfaceD2D::DrawTextClipped(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text,
+	ColourDesired fore, ColourDesired back) {
+	if (pRenderTarget) {
+		FillRectangle(rc, back);
+		D2DPenColour(fore);
+		DrawTextCommon(rc, font_, ybase, text, ETO_OPAQUE | ETO_CLIPPED);
+	}
 }
 
-void SurfaceImpl::DrawTextTransparent(PRectangle rc, Font &font_, int ybase, const char *s, int len,
-	ColourAllocated fore) {
+void SurfaceD2D::DrawTextTransparent(PRectangle rc, Font &font_, XYPOSITION ybase, std::string_view text,
+	ColourDesired fore) {
 	// Avoid drawing spaces in transparent mode
-	for (int i=0;i<len;i++) {
-		if (s[i] != ' ') {
-			::SetTextColor(hdc, fore.AsLong());
-			::SetBkMode(hdc, TRANSPARENT);
-			DrawTextCommon(rc, font_, ybase, s, len, 0);
-			::SetBkMode(hdc, OPAQUE);
+	for (const char ch : text) {
+		if (ch != ' ') {
+			if (pRenderTarget) {
+				D2DPenColour(fore);
+				DrawTextCommon(rc, font_, ybase, text, 0);
+			}
 			return;
 		}
 	}
 }
 
-int SurfaceImpl::WidthText(Font &font_, const char *s, int len) {
+XYPOSITION SurfaceD2D::WidthText(Font &font_, std::string_view text) {
+	FLOAT width = 1.0;
 	SetFont(font_);
-	SIZE sz={0,0};
-	if ((!unicodeMode) && (IsNT() || (codePage==0) || win9xACPSame)) {
-		::GetTextExtentPoint32A(hdc, s, Platform::Minimum(len, maxLenText), &sz);
-	} else {
-		const TextWide tbuf(s, len, unicodeMode, codePage);
-		::GetTextExtentPoint32W(hdc, tbuf.buffer, tbuf.tlen, &sz);
+	const TextWide tbuf(text, unicodeMode, codePageText);
+	if (pIDWriteFactory && pTextFormat) {
+		// Create a layout
+		IDWriteTextLayout *pTextLayout = nullptr;
+		const HRESULT hr = pIDWriteFactory->CreateTextLayout(tbuf.buffer, tbuf.tlen, pTextFormat, 1000.0, 1000.0, &pTextLayout);
+		if (SUCCEEDED(hr) && pTextLayout) {
+			DWRITE_TEXT_METRICS textMetrics;
+			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
+				width = textMetrics.widthIncludingTrailingWhitespace;
+			ReleaseUnknown(pTextLayout);
+		}
 	}
-	return sz.cx;
+	return width;
 }
 
-void SurfaceImpl::MeasureWidths(Font &font_, const char *s, int len, int *positions) {
+void SurfaceD2D::MeasureWidths(Font &font_, std::string_view text, XYPOSITION *positions) {
 	SetFont(font_);
-	SIZE sz={0,0};
-	int fit = 0;
-	if (unicodeMode) {
-		const TextWide tbuf(s, len, unicodeMode, codePage);
-		TextPositions poses(tbuf.tlen);
-		fit = tbuf.tlen;
-		if (!::GetTextExtentExPointW(hdc, tbuf.buffer, tbuf.tlen, maxWidthMeasure, &fit, poses.buffer, &sz)) {
-			// Likely to have failed because on Windows 9x where function not available
-			// So measure the character widths by measuring each initial substring
-			// Turns a linear operation into a qudratic but seems fast enough on test files
-			for (int widthSS=0; widthSS < tbuf.tlen; widthSS++) {
-				::GetTextExtentPoint32W(hdc, tbuf.buffer, widthSS+1, &sz);
-				poses.buffer[widthSS] = sz.cx;
-			}
+	if (!pIDWriteFactory || !pTextFormat) {
+		// SetFont failed or no access to DirectWrite so give up.
+		return;
+	}
+	const TextWide tbuf(text, unicodeMode, codePageText);
+	TextPositions poses(tbuf.tlen);
+	// Initialize poses for safety.
+	std::fill(poses.buffer, poses.buffer + tbuf.tlen, 0.0f);
+	// Create a layout
+	IDWriteTextLayout *pTextLayout = nullptr;
+	const HRESULT hrCreate = pIDWriteFactory->CreateTextLayout(tbuf.buffer, tbuf.tlen, pTextFormat, 10000.0, 1000.0, &pTextLayout);
+	if (!SUCCEEDED(hrCreate) || !pTextLayout) {
+		return;
+	}
+	constexpr int clusters = stackBufferLength;
+	DWRITE_CLUSTER_METRICS clusterMetrics[clusters];
+	UINT32 count = 0;
+	const HRESULT hrGetCluster = pTextLayout->GetClusterMetrics(clusterMetrics, clusters, &count);
+	ReleaseUnknown(pTextLayout);
+	if (!SUCCEEDED(hrGetCluster)) {
+		return;
+	}
+	// A cluster may be more than one WCHAR, such as for "ffi" which is a ligature in the Candara font
+	FLOAT position = 0.0f;
+	int ti=0;
+	for (unsigned int ci=0; ci<count; ci++) {
+		for (unsigned int inCluster=0; inCluster<clusterMetrics[ci].length; inCluster++) {
+			poses.buffer[ti++] = position + clusterMetrics[ci].width * (inCluster + 1) / clusterMetrics[ci].length;
 		}
+		position += clusterMetrics[ci].width;
+	}
+	PLATFORM_ASSERT(ti == tbuf.tlen);
+	if (unicodeMode) {
 		// Map the widths given for UTF-16 characters back onto the UTF-8 input string
 		int ui=0;
-		const unsigned char *us = reinterpret_cast<const unsigned char *>(s);
-		int i=0;
-		while (ui<fit) {
-			unsigned char uch = us[i];
-			unsigned int lenChar = 1;
-			if (uch >= (0x80 + 0x40 + 0x20 + 0x10)) {
-				lenChar = 4;
+		size_t i=0;
+		while (ui<tbuf.tlen) {
+			const unsigned char uch = text[i];
+			const unsigned int byteCount = UTF8BytesOfLead[uch];
+			if (byteCount == 4) {	// Non-BMP
 				ui++;
-			} else if (uch >= (0x80 + 0x40 + 0x20)) {
-				lenChar = 3;
-			} else if (uch >= (0x80)) {
-				lenChar = 2;
 			}
-			for (unsigned int bytePos=0; (bytePos<lenChar) && (i<len); bytePos++) {
+			for (unsigned int bytePos=0; (bytePos<byteCount) && (i<text.length()) && (ui<tbuf.tlen); bytePos++) {
 				positions[i++] = poses.buffer[ui];
 			}
 			ui++;
 		}
-		int lastPos = 0;
+		XYPOSITION lastPos = 0.0f;
 		if (i > 0)
 			lastPos = positions[i-1];
-		while (i<len) {
+		while (i<text.length()) {
 			positions[i++] = lastPos;
 		}
-	} else if (IsNT() || (codePage==0) || win9xACPSame) {
-		// Zero positions to avoid random behaviour on failure.
-		memset(positions, 0, len * sizeof(*positions));
-		// len may be larger than platform supports so loop over segments small enough for platform
-		int startOffset = 0;
-		while (len > 0) {
-			int lenBlock = Platform::Minimum(len, maxLenText);
-			if (!::GetTextExtentExPointA(hdc, s, lenBlock, maxWidthMeasure, &fit, positions, &sz)) {
-				// Eeek - a NULL DC or other foolishness could cause this.
-				return;
-			} else if (fit < lenBlock) {
-				// For some reason, such as an incomplete DBCS character
-				// Not all the positions are filled in so make them equal to end.
-				for (int i=fit;i<lenBlock;i++)
-					positions[i] = positions[fit-1];
-			} else if (startOffset > 0) {
-				for (int i=0;i<lenBlock;i++)
-					positions[i] += startOffset;
-			}
-			startOffset = positions[lenBlock-1];
-			len -= lenBlock;
-			positions += lenBlock;
-			s += lenBlock;
+	} else if (!IsDBCSCodePage(codePageText)) {
+
+		// One char per position
+		PLATFORM_ASSERT(text.length() == static_cast<size_t>(tbuf.tlen));
+		for (int kk=0; kk<tbuf.tlen; kk++) {
+			positions[kk] = poses.buffer[kk];
 		}
+
 	} else {
-		// Support Asian string display in 9x English
-		const TextWide tbuf(s, len, unicodeMode, codePage);
-		TextPositions poses(tbuf.tlen);
-		for (int widthSS=0; widthSS<tbuf.tlen; widthSS++) {
-			::GetTextExtentPoint32W(hdc, tbuf.buffer, widthSS+1, &sz);
-			poses.buffer[widthSS] = sz.cx;
-		}
 
+		// May be one or two bytes per position
 		int ui = 0;
-		for (int i=0;i<len;) {
-			if (::IsDBCSLeadByteEx(codePage, s[i])) {
-				positions[i] = poses.buffer[ui];
+		for (size_t i=0; i<text.length() && ui<tbuf.tlen;) {
+			positions[i] = poses.buffer[ui];
+			if (DBCSIsLeadByte(codePageText, text[i])) {
 				positions[i+1] = poses.buffer[ui];
 				i += 2;
 			} else {
-				positions[i] = poses.buffer[ui];
 				i++;
 			}
 
@@ -878,173 +2215,231 @@ void SurfaceImpl::MeasureWidths(Font &font_, const char *s, int len, int *positi
 	}
 }
 
-int SurfaceImpl::WidthChar(Font &font_, char ch) {
-	SetFont(font_);
-	SIZE sz;
-	::GetTextExtentPoint32A(hdc, &ch, 1, &sz);
-	return sz.cx;
-}
-
-int SurfaceImpl::Ascent(Font &font_) {
-	SetFont(font_);
-	TEXTMETRIC tm;
-	::GetTextMetrics(hdc, &tm);
-	return tm.tmAscent;
-}
-
-int SurfaceImpl::Descent(Font &font_) {
+XYPOSITION SurfaceD2D::Ascent(Font &font_) {
 	SetFont(font_);
-	TEXTMETRIC tm;
-	::GetTextMetrics(hdc, &tm);
-	return tm.tmDescent;
+	return std::ceil(yAscent);
 }
 
-int SurfaceImpl::InternalLeading(Font &font_) {
+XYPOSITION SurfaceD2D::Descent(Font &font_) {
 	SetFont(font_);
-	TEXTMETRIC tm;
-	::GetTextMetrics(hdc, &tm);
-	return tm.tmInternalLeading;
+	return std::ceil(yDescent);
 }
 
-int SurfaceImpl::ExternalLeading(Font &font_) {
+XYPOSITION SurfaceD2D::InternalLeading(Font &font_) {
 	SetFont(font_);
-	TEXTMETRIC tm;
-	::GetTextMetrics(hdc, &tm);
-	return tm.tmExternalLeading;
+	return std::floor(yInternalLeading);
 }
 
-int SurfaceImpl::Height(Font &font_) {
-	SetFont(font_);
-	TEXTMETRIC tm;
-	::GetTextMetrics(hdc, &tm);
-	return tm.tmHeight;
+XYPOSITION SurfaceD2D::Height(Font &font_) {
+	return Ascent(font_) + Descent(font_);
 }
 
-int SurfaceImpl::AverageCharWidth(Font &font_) {
+XYPOSITION SurfaceD2D::AverageCharWidth(Font &font_) {
+	FLOAT width = 1.0;
 	SetFont(font_);
-	TEXTMETRIC tm;
-	::GetTextMetrics(hdc, &tm);
-	return tm.tmAveCharWidth;
-}
-
-int SurfaceImpl::SetPalette(Palette *pal, bool inBackGround) {
-	if (paletteOld) {
-		::SelectPalette(hdc, paletteOld, TRUE);
-	}
-	paletteOld = 0;
-	int changes = 0;
-	if (pal->allowRealization) {
-		paletteOld = ::SelectPalette(hdc,
-			reinterpret_cast<HPALETTE>(pal->hpal), inBackGround);
-		changes = ::RealizePalette(hdc);
+	if (pIDWriteFactory && pTextFormat) {
+		// Create a layout
+		IDWriteTextLayout *pTextLayout = nullptr;
+		const WCHAR wszAllAlpha[] = L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+		const size_t lenAllAlpha = wcslen(wszAllAlpha);
+		const HRESULT hr = pIDWriteFactory->CreateTextLayout(wszAllAlpha, static_cast<UINT32>(lenAllAlpha),
+			pTextFormat, 1000.0, 1000.0, &pTextLayout);
+		if (SUCCEEDED(hr) && pTextLayout) {
+			DWRITE_TEXT_METRICS textMetrics;
+			if (SUCCEEDED(pTextLayout->GetMetrics(&textMetrics)))
+				width = textMetrics.width / lenAllAlpha;
+			ReleaseUnknown(pTextLayout);
+		}
 	}
-	return changes;
+	return width;
 }
 
-void SurfaceImpl::SetClip(PRectangle rc) {
-	::IntersectClipRect(hdc, rc.left, rc.top, rc.right, rc.bottom);
+void SurfaceD2D::SetClip(PRectangle rc) {
+	if (pRenderTarget) {
+		const D2D1_RECT_F rcClip = RectangleFromPRectangle(rc);
+		pRenderTarget->PushAxisAlignedClip(rcClip, D2D1_ANTIALIAS_MODE_ALIASED);
+		clipsActive++;
+	}
 }
 
-void SurfaceImpl::FlushCachedState() {
-	pen = 0;
-	brush = 0;
-	font = 0;
+void SurfaceD2D::FlushCachedState() {
 }
 
-void SurfaceImpl::SetUnicodeMode(bool unicodeMode_) {
+void SurfaceD2D::SetUnicodeMode(bool unicodeMode_) {
 	unicodeMode=unicodeMode_;
 }
 
-void SurfaceImpl::SetDBCSMode(int codePage_) {
+void SurfaceD2D::SetDBCSMode(int codePage_) {
 	// No action on window as automatically handled by system.
 	codePage = codePage_;
-	win9xACPSame = !IsNT() && ((unsigned int)codePage == ::GetACP());
 }
 
-Surface *Surface::Allocate() {
-	return new SurfaceImpl;
+void SurfaceD2D::SetBidiR2L(bool) {
 }
 
-Window::~Window() {
+#endif
+
+Surface *Surface::Allocate(int technology) {
+#if defined(USE_D2D)
+	if (technology == SCWIN_TECH_GDI)
+		return new SurfaceGDI;
+	else
+		return new SurfaceD2D;
+#else
+	return new SurfaceGDI;
+#endif
 }
 
-void Window::Destroy() {
-	if (id)
-		::DestroyWindow(reinterpret_cast<HWND>(id));
-	id = 0;
+Window::~Window() {
 }
 
-bool Window::HasFocus() {
-	return ::GetFocus() == id;
+void Window::Destroy() {
+	if (wid)
+		::DestroyWindow(HwndFromWindowID(wid));
+	wid = nullptr;
 }
 
-PRectangle Window::GetPosition() {
+PRectangle Window::GetPosition() const {
 	RECT rc;
-	::GetWindowRect(reinterpret_cast<HWND>(id), &rc);
-	return PRectangle(rc.left, rc.top, rc.right, rc.bottom);
+	::GetWindowRect(HwndFromWindowID(wid), &rc);
+	return PRectangle::FromInts(rc.left, rc.top, rc.right, rc.bottom);
 }
 
 void Window::SetPosition(PRectangle rc) {
-	::SetWindowPos(reinterpret_cast<HWND>(id),
-		0, rc.left, rc.top, rc.Width(), rc.Height(), SWP_NOZORDER|SWP_NOACTIVATE);
+	::SetWindowPos(HwndFromWindowID(wid),
+		0, static_cast<int>(rc.left), static_cast<int>(rc.top),
+		static_cast<int>(rc.Width()), static_cast<int>(rc.Height()), SWP_NOZORDER | SWP_NOACTIVATE);
 }
 
-void Window::SetPositionRelative(PRectangle rc, Window w) {
-	LONG style = ::GetWindowLong(reinterpret_cast<HWND>(id), GWL_STYLE);
-	if (style & WS_POPUP) {
-		RECT rcOther;
-		::GetWindowRect(reinterpret_cast<HWND>(w.GetID()), &rcOther);
-		rc.Move(rcOther.left, rcOther.top);
-
-		// Retrieve desktop bounds and make sure window popup's origin isn't left-top of the screen.
-		RECT rcDesktop = {0, 0, 0, 0};
-#ifdef SM_XVIRTUALSCREEN
-		rcDesktop.left = ::GetSystemMetrics(SM_XVIRTUALSCREEN);
-		rcDesktop.top = ::GetSystemMetrics(SM_YVIRTUALSCREEN);
-		rcDesktop.right = rcDesktop.left + ::GetSystemMetrics(SM_CXVIRTUALSCREEN);
-		rcDesktop.bottom = rcDesktop.top + ::GetSystemMetrics(SM_CYVIRTUALSCREEN);
-#endif
+namespace {
 
-		if (rc.left < rcDesktop.left) {
-			rc.Move(rcDesktop.left - rc.left,0);
-		}
-		if (rc.top < rcDesktop.top) {
-			rc.Move(0,rcDesktop.top - rc.top);
+static RECT RectFromMonitor(HMONITOR hMonitor) noexcept {
+	MONITORINFO mi = {};
+	mi.cbSize = sizeof(mi);
+	if (GetMonitorInfo(hMonitor, &mi)) {
+		return mi.rcWork;
+	}
+	RECT rc = {0, 0, 0, 0};
+	if (::SystemParametersInfoA(SPI_GETWORKAREA, 0, &rc, 0) == 0) {
+		rc.left = 0;
+		rc.top = 0;
+		rc.right = 0;
+		rc.bottom = 0;
+	}
+	return rc;
+}
+
+}
+
+void Window::SetPositionRelative(PRectangle rc, const Window *relativeTo) {
+	const DWORD style = GetWindowStyle(HwndFromWindowID(wid));
+	if (style & WS_POPUP) {
+		POINT ptOther = {0, 0};
+		::ClientToScreen(HwndFromWindow(*relativeTo), &ptOther);
+		rc.Move(static_cast<XYPOSITION>(ptOther.x), static_cast<XYPOSITION>(ptOther.y));
+
+		const RECT rcMonitor = RectFromPRectangle(rc);
+
+		HMONITOR hMonitor = MonitorFromRect(&rcMonitor, MONITOR_DEFAULTTONEAREST);
+		// If hMonitor is NULL, that's just the main screen anyways.
+		const RECT rcWork = RectFromMonitor(hMonitor);
+
+		if (rcWork.left < rcWork.right) {
+			// Now clamp our desired rectangle to fit inside the work area
+			// This way, the menu will fit wholly on one screen. An improvement even
+			// if you don't have a second monitor on the left... Menu's appears half on
+			// one screen and half on the other are just U.G.L.Y.!
+			if (rc.right > rcWork.right)
+				rc.Move(rcWork.right - rc.right, 0);
+			if (rc.bottom > rcWork.bottom)
+				rc.Move(0, rcWork.bottom - rc.bottom);
+			if (rc.left < rcWork.left)
+				rc.Move(rcWork.left - rc.left, 0);
+			if (rc.top < rcWork.top)
+				rc.Move(0, rcWork.top - rc.top);
 		}
 	}
 	SetPosition(rc);
 }
 
-PRectangle Window::GetClientPosition() {
+PRectangle Window::GetClientPosition() const {
 	RECT rc={0,0,0,0};
-	if (id)
-		::GetClientRect(reinterpret_cast<HWND>(id), &rc);
-	return  PRectangle(rc.left, rc.top, rc.right, rc.bottom);
+	if (wid)
+		::GetClientRect(HwndFromWindowID(wid), &rc);
+	return PRectangle::FromInts(rc.left, rc.top, rc.right, rc.bottom);
 }
 
 void Window::Show(bool show) {
 	if (show)
-		::ShowWindow(reinterpret_cast<HWND>(id), SW_SHOWNOACTIVATE);
+		::ShowWindow(HwndFromWindowID(wid), SW_SHOWNOACTIVATE);
 	else
-		::ShowWindow(reinterpret_cast<HWND>(id), SW_HIDE);
+		::ShowWindow(HwndFromWindowID(wid), SW_HIDE);
 }
 
 void Window::InvalidateAll() {
-	::InvalidateRect(reinterpret_cast<HWND>(id), NULL, FALSE);
+	::InvalidateRect(HwndFromWindowID(wid), nullptr, FALSE);
 }
 
 void Window::InvalidateRectangle(PRectangle rc) {
-	RECT rcw = RectFromPRectangle(rc);
-	::InvalidateRect(reinterpret_cast<HWND>(id), &rcw, FALSE);
+	const RECT rcw = RectFromPRectangle(rc);
+	::InvalidateRect(HwndFromWindowID(wid), &rcw, FALSE);
 }
 
-static LRESULT Window_SendMessage(Window *w, UINT msg, WPARAM wParam=0, LPARAM lParam=0) {
-	return ::SendMessage(reinterpret_cast<HWND>(w->GetID()), msg, wParam, lParam);
+void Window::SetFont(Font &font) {
+	SetWindowFont(HwndFromWindowID(wid), font.GetID(), 0);
 }
 
-void Window::SetFont(Font &font) {
-	Window_SendMessage(this, WM_SETFONT,
-		reinterpret_cast<WPARAM>(font.GetID()), 0);
+namespace {
+
+void FlipBitmap(HBITMAP bitmap, int width, int height) noexcept {
+	HDC hdc = ::CreateCompatibleDC({});
+	if (hdc) {
+		HBITMAP prevBmp = SelectBitmap(hdc, bitmap);
+		::StretchBlt(hdc, width - 1, 0, -width, height, hdc, 0, 0, width, height, SRCCOPY);
+		SelectBitmap(hdc, prevBmp);
+		::DeleteDC(hdc);
+	}
+}
+
+}
+
+HCURSOR LoadReverseArrowCursor(UINT dpi) noexcept {
+	HCURSOR reverseArrowCursor {};
+
+	bool created = false;
+	HCURSOR cursor = ::LoadCursor({}, IDC_ARROW);
+
+	if (dpi != uSystemDPI) {
+		const int width = SystemMetricsForDpi(SM_CXCURSOR, dpi);
+		const int height = SystemMetricsForDpi(SM_CYCURSOR, dpi);
+		HCURSOR copy = static_cast<HCURSOR>(::CopyImage(cursor, IMAGE_CURSOR, width, height, LR_COPYFROMRESOURCE | LR_COPYRETURNORG));
+		if (copy) {
+			created = copy != cursor;
+			cursor = copy;
+		}
+	}
+
+	ICONINFO info;
+	if (::GetIconInfo(cursor, &info)) {
+		BITMAP bmp;
+		if (::GetObject(info.hbmMask, sizeof(bmp), &bmp)) {
+			FlipBitmap(info.hbmMask, bmp.bmWidth, bmp.bmHeight);
+			if (info.hbmColor)
+				FlipBitmap(info.hbmColor, bmp.bmWidth, bmp.bmHeight);
+			info.xHotspot = bmp.bmWidth - 1 - info.xHotspot;
+
+			reverseArrowCursor = ::CreateIconIndirect(&info);
+		}
+
+		::DeleteObject(info.hbmMask);
+		if (info.hbmColor)
+			::DeleteObject(info.hbmColor);
+	}
+
+	if (created) {
+		::DestroyCursor(cursor);
+	}
+	return reverseArrowCursor;
 }
 
 void Window::SetCursor(Cursor curs) {
@@ -1067,20 +2462,7 @@ void Window::SetCursor(Cursor curs) {
 	case cursorHand:
 		::SetCursor(::LoadCursor(NULL,IDC_HAND));
 		break;
-	case cursorReverseArrow: {
-			if (!hinstPlatformRes)
-				hinstPlatformRes = ::GetModuleHandle(TEXT("Scintilla"));
-			if (!hinstPlatformRes)
-				hinstPlatformRes = ::GetModuleHandle(TEXT("SciLexer"));
-			if (!hinstPlatformRes)
-				hinstPlatformRes = ::GetModuleHandle(NULL);
-			HCURSOR hcursor = ::LoadCursor(hinstPlatformRes, MAKEINTRESOURCE(IDC_MARGIN));
-			if (hcursor)
-				::SetCursor(hcursor);
-			else
-				::SetCursor(::LoadCursor(NULL,IDC_ARROW));
-		}
-		break;
+	case cursorReverseArrow:
 	case cursorArrow:
 	case cursorInvalid:	// Should not occur, but just in case.
 		::SetCursor(::LoadCursor(NULL,IDC_ARROW));
@@ -1088,142 +2470,69 @@ void Window::SetCursor(Cursor curs) {
 	}
 }
 
-void Window::SetTitle(const char *s) {
-	::SetWindowTextA(reinterpret_cast<HWND>(id), s);
-}
-
 /* Returns rectangle of monitor pt is on, both rect and pt are in Window's
    coordinates */
-#ifdef MULTIPLE_MONITOR_SUPPORT
 PRectangle Window::GetMonitorRect(Point pt) {
-	// MonitorFromPoint and GetMonitorInfo are not available on Windows 95 so are not used.
-	// There could be conditional code and dynamic loading in a future version
-	// so this would work on those platforms where they are available.
-	PRectangle rcPosition = GetPosition();
-	POINT ptDesktop = {pt.x + rcPosition.left, pt.y + rcPosition.top};
-	HMONITOR hMonitor = ::MonitorFromPoint(ptDesktop, MONITOR_DEFAULTTONEAREST);
-	MONITORINFOEX mi;
-	memset(&mi, 0, sizeof(mi));
-	mi.cbSize = sizeof(mi);
-	if (::GetMonitorInfo(hMonitor, &mi)) {
+	const PRectangle rcPosition = GetPosition();
+	POINT ptDesktop = {static_cast<LONG>(pt.x + rcPosition.left),
+		static_cast<LONG>(pt.y + rcPosition.top)};
+	HMONITOR hMonitor = MonitorFromPoint(ptDesktop, MONITOR_DEFAULTTONEAREST);
+
+	const RECT rcWork = RectFromMonitor(hMonitor);
+	if (rcWork.left < rcWork.right) {
 		PRectangle rcMonitor(
-			mi.rcWork.left - rcPosition.left,
-			mi.rcWork.top - rcPosition.top,
-			mi.rcWork.right - rcPosition.left,
-			mi.rcWork.bottom - rcPosition.top);
+			rcWork.left - rcPosition.left,
+			rcWork.top - rcPosition.top,
+			rcWork.right - rcPosition.left,
+			rcWork.bottom - rcPosition.top);
 		return rcMonitor;
+	} else {
+		return PRectangle();
 	}
 }
-#else
-PRectangle Window::GetMonitorRect(Point) {
-	return PRectangle();
-}
-#endif
 
 struct ListItemData {
 	const char *text;
 	int pixId;
 };
 
-#define _ROUND2(n,pow2) \
-	( ( (n) + (pow2) - 1) & ~((pow2) - 1) )
-
 class LineToItem {
-	char *words;
-	int wordsCount;
-	int wordsSize;
-
-	ListItemData *data;
-	int len;
-	int count;
+	std::vector<char> words;
 
-private:
-	void FreeWords() {
-		delete []words;
-		words = NULL;
-		wordsCount = 0;
-		wordsSize = 0;
-	}
-	char *AllocWord(const char *word);
+	std::vector<ListItemData> data;
 
 public:
-	LineToItem() : words(NULL), wordsCount(0), wordsSize(0), data(NULL), len(0), count(0) {
-	}
-	~LineToItem() {
-		Clear();
+	void Clear() noexcept {
+		words.clear();
+		data.clear();
 	}
-	void Clear() {
-		FreeWords();
-		delete []data;
-		data = NULL;
-		len = 0;
-		count = 0;
-	}
-
-	ListItemData *Append(const char *text, int value);
 
-	ListItemData Get(int index) const {
-		if (index >= 0 && index < count) {
+	ListItemData Get(size_t index) const noexcept {
+		if (index < data.size()) {
 			return data[index];
 		} else {
 			ListItemData missing = {"", -1};
 			return missing;
 		}
 	}
-	int Count() const {
-		return count;
+	int Count() const noexcept {
+		return static_cast<int>(data.size());
 	}
 
-	ListItemData *AllocItem();
+	void AllocItem(const char *text, int pixId) {
+		ListItemData lid = { text, pixId };
+		data.push_back(lid);
+	}
 
-	void SetWords(char *s) {
-		words = s;	// N.B. will be deleted on destruction
+	char *SetWords(const char *s) {
+		words = std::vector<char>(s, s+strlen(s)+1);
+		return &words[0];
 	}
 };
 
-char *LineToItem::AllocWord(const char *text) {
-	int chars = strlen(text) + 1;
-	int newCount = wordsCount + chars;
-	if (newCount > wordsSize) {
-		wordsSize = _ROUND2(newCount * 2, 8192);
-		char *wordsNew = new char[wordsSize];
-		memcpy(wordsNew, words, wordsCount);
-		int offset = wordsNew - words;
-		for (int i=0; i<count; i++)
-			data[i].text += offset;
-		delete []words;
-		words = wordsNew;
-	}
-	char *s = &words[wordsCount];
-	wordsCount = newCount;
-	strncpy(s, text, chars);
-	return s;
-}
-
-ListItemData *LineToItem::AllocItem() {
-	if (count >= len) {
-		int lenNew = _ROUND2((count+1) * 2, 1024);
-		ListItemData *dataNew = new ListItemData[lenNew];
-		memcpy(dataNew, data, count * sizeof(ListItemData));
-		delete []data;
-		data = dataNew;
-		len = lenNew;
-	}
-	ListItemData *item = &data[count];
-	count++;
-	return item;
-}
-
-ListItemData *LineToItem::Append(const char *text, int imageIndex) {
-	ListItemData *item = AllocItem();
-	item->text = AllocWord(text);
-	item->pixId = imageIndex;
-	return item;
-}
-
 const TCHAR ListBoxX_ClassName[] = TEXT("ListBoxX");
 
-ListBox::ListBox() {
+ListBox::ListBox() noexcept {
 }
 
 ListBox::~ListBox() {
@@ -1232,7 +2541,8 @@ ListBox::~ListBox() {
 class ListBoxX : public ListBox {
 	int lineHeight;
 	FontID fontCopy;
-	XPMSet xset;
+	int technology;
+	RGBAImageSet images;
 	LineToItem lti;
 	HWND lb;
 	bool unicodeMode;
@@ -1241,95 +2551,92 @@ class ListBoxX : public ListBox {
 	unsigned int aveCharWidth;
 	Window *parent;
 	int ctrlID;
-	CallBackAction doubleClickAction;
-	void *doubleClickActionData;
+	UINT dpi;
+	IListBoxDelegate *delegate;
 	const char *widestItem;
 	unsigned int maxCharWidth;
-	int resizeHit;
+	WPARAM resizeHit;
 	PRectangle rcPreSize;
 	Point dragOffset;
 	Point location;	// Caret location at which the list is opened
+	int wheelDelta; // mouse wheel residue
 
-	HWND GetHWND() const;
-	void AppendListItem(const char *startword, const char *numword);
-	void AdjustWindowRect(PRectangle *rc) const;
+	HWND GetHWND() const noexcept;
+	void AppendListItem(const char *text, const char *numword);
+	static void AdjustWindowRect(PRectangle *rc, UINT dpi) noexcept;
 	int ItemHeight() const;
-	int MinClientWidth() const;
+	int MinClientWidth() const noexcept;
 	int TextOffset() const;
-	Point GetClientExtent() const;
-	Point MinTrackSize() const;
-	Point MaxTrackSize() const;
-	void SetRedraw(bool on);
+	POINT GetClientExtent() const noexcept;
+	POINT MinTrackSize() const;
+	POINT MaxTrackSize() const;
+	void SetRedraw(bool on) noexcept;
 	void OnDoubleClick();
+	void OnSelChange();
 	void ResizeToCursor();
 	void StartResize(WPARAM);
-	int NcHitTest(WPARAM, LPARAM) const;
-	void CentreItem(int);
-	void Paint(HDC);
-	void Erase(HDC);
+	LRESULT NcHitTest(WPARAM, LPARAM) const;
+	void CentreItem(int n);
+	void Paint(HDC) noexcept;
 	static LRESULT PASCAL ControlWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
 
-	static const Point ItemInset;	// Padding around whole item
-	static const Point TextInset;	// Padding around text
-	static const Point ImageInset;	// Padding around image
+	static constexpr Point ItemInset {0, 0};	// Padding around whole item
+	static constexpr Point TextInset {2, 0};	// Padding around text
+	static constexpr Point ImageInset {1, 0};	// Padding around image
 
 public:
-	ListBoxX() : lineHeight(10), fontCopy(0), lb(0), unicodeMode(false),
-		desiredVisibleRows(5), maxItemCharacters(0), aveCharWidth(8),
-		parent(NULL), ctrlID(0), doubleClickAction(NULL), doubleClickActionData(NULL),
-		widestItem(NULL), maxCharWidth(1), resizeHit(0) {
+	ListBoxX() : lineHeight(10), fontCopy{}, technology(0), lb{}, unicodeMode(false),
+		desiredVisibleRows(9), maxItemCharacters(0), aveCharWidth(8),
+		parent(nullptr), ctrlID(0), dpi(USER_DEFAULT_SCREEN_DPI),
+		delegate(nullptr),
+		widestItem(nullptr), maxCharWidth(1), resizeHit(0), wheelDelta(0) {
 	}
-	virtual ~ListBoxX() {
+	~ListBoxX() override {
 		if (fontCopy) {
 			::DeleteObject(fontCopy);
 			fontCopy = 0;
 		}
 	}
-	virtual void SetFont(Font &font);
-	virtual void Create(Window &parent, int ctrlID, Point location_, int lineHeight_, bool unicodeMode_);
-	virtual void SetAverageCharWidth(int width);
-	virtual void SetVisibleRows(int rows);
-	virtual int GetVisibleRows() const;
-	virtual PRectangle GetDesiredRect();
-	virtual int CaretFromEdge();
-	virtual void Clear();
-	virtual void Append(char *s, int type = -1);
-	virtual int Length();
-	virtual void Select(int n);
-	virtual int GetSelection();
-	virtual int Find(const char *prefix);
-	virtual void GetValue(int n, char *value, int len);
-	virtual void RegisterImage(int type, const char *xpm_data);
-	virtual void ClearRegisteredImages();
-	virtual void SetDoubleClickAction(CallBackAction action, void *data) {
-		doubleClickAction = action;
-		doubleClickActionData = data;
-	}
-	virtual void SetList(const char *list, char separator, char typesep);
+	void SetFont(Font &font) override;
+	void Create(Window &parent_, int ctrlID_, Point location_, int lineHeight_, bool unicodeMode_, int technology_) override;
+	void SetAverageCharWidth(int width) override;
+	void SetVisibleRows(int rows) override;
+	int GetVisibleRows() const override;
+	PRectangle GetDesiredRect() override;
+	int CaretFromEdge() override;
+	void Clear() override;
+	void Append(char *s, int type = -1) override;
+	int Length() override;
+	void Select(int n) override;
+	int GetSelection() override;
+	int Find(const char *prefix) override;
+	void GetValue(int n, char *value, int len) override;
+	void RegisterImage(int type, const char *xpm_data) override;
+	void RegisterRGBAImage(int type, int width, int height, const unsigned char *pixelsImage) override;
+	void ClearRegisteredImages() override;
+	void SetDelegate(IListBoxDelegate *lbDelegate) override;
+	void SetList(const char *list, char separator, char typesep) override;
 	void Draw(DRAWITEMSTRUCT *pDrawItem);
 	LRESULT WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
 	static LRESULT PASCAL StaticWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
 };
 
-const Point ListBoxX::ItemInset(0, 0);
-const Point ListBoxX::TextInset(2, 0);
-const Point ListBoxX::ImageInset(1, 0);
-
 ListBox *ListBox::Allocate() {
 	ListBoxX *lb = new ListBoxX();
 	return lb;
 }
 
-void ListBoxX::Create(Window &parent_, int ctrlID_, Point location_, int lineHeight_, bool unicodeMode_) {
+void ListBoxX::Create(Window &parent_, int ctrlID_, Point location_, int lineHeight_, bool unicodeMode_, int technology_) {
 	parent = &parent_;
 	ctrlID = ctrlID_;
 	location = location_;
 	lineHeight = lineHeight_;
 	unicodeMode = unicodeMode_;
-	HWND hwndParent = reinterpret_cast<HWND>(parent->GetID());
+	technology = technology_;
+	HWND hwndParent = HwndFromWindow(*parent);
 	HINSTANCE hinstanceParent = GetWindowInstance(hwndParent);
 	// Window created as popup so not clipped within parent client area
-	id = ::CreateWindowEx(
+	wid = ::CreateWindowEx(
 		WS_EX_WINDOWEDGE, ListBoxX_ClassName, TEXT(""),
 		WS_POPUP | WS_THICKFRAME,
 		100,100, 150,80, hwndParent,
@@ -1337,18 +2644,21 @@ void ListBoxX::Create(Window &parent_, int ctrlID_, Point location_, int lineHei
 		hinstanceParent,
 		this);
 
-	::MapWindowPoints(hwndParent, NULL, reinterpret_cast<POINT*>(&location), 1);
+	dpi = DpiForWindow(hwndParent);
+	POINT locationw = POINTFromPoint(location);
+	::MapWindowPoints(hwndParent, NULL, &locationw, 1);
+	location = PointFromPOINT(locationw);
 }
 
 void ListBoxX::SetFont(Font &font) {
-	LOGFONT lf;
-	if (0 != ::GetObject(font.GetID(), sizeof(lf), &lf)) {
+	if (font.GetID()) {
 		if (fontCopy) {
 			::DeleteObject(fontCopy);
 			fontCopy = 0;
 		}
-		fontCopy = ::CreateFontIndirect(&lf);
-		::SendMessage(lb, WM_SETFONT, reinterpret_cast<WPARAM>(fontCopy), 0);
+		FormatAndMetrics *pfm = static_cast<FormatAndMetrics *>(font.GetID());
+		fontCopy = pfm->HFont();
+		SetWindowFont(lb, fontCopy, 0);
 	}
 }
 
@@ -1364,8 +2674,8 @@ int ListBoxX::GetVisibleRows() const {
 	return desiredVisibleRows;
 }
 
-HWND ListBoxX::GetHWND() const {
-	return reinterpret_cast<HWND>(GetID());
+HWND ListBoxX::GetHWND() const noexcept {
+	return HwndFromWindowID(GetID());
 }
 
 PRectangle ListBoxX::GetDesiredRect() {
@@ -1380,12 +2690,15 @@ PRectangle ListBoxX::GetDesiredRect() {
 	HDC hdc = ::GetDC(lb);
 	HFONT oldFont = SelectFont(hdc, fontCopy);
 	SIZE textSize = {0, 0};
-	int len = widestItem ? strlen(widestItem) : 0;
-	if (unicodeMode) {
-		const TextWide tbuf(widestItem, len, unicodeMode);
-		::GetTextExtentPoint32W(hdc, tbuf.buffer, tbuf.tlen, &textSize);
-	} else {
-		::GetTextExtentPoint32A(hdc, widestItem, len, &textSize);
+	int len = 0;
+	if (widestItem) {
+		len = static_cast<int>(strlen(widestItem));
+		if (unicodeMode) {
+			const TextWide tbuf(widestItem, unicodeMode);
+			::GetTextExtentPoint32W(hdc, tbuf.buffer, tbuf.tlen, &textSize);
+		} else {
+			::GetTextExtentPoint32A(hdc, widestItem, len, &textSize);
+		}
 	}
 	TEXTMETRIC tm;
 	::GetTextMetrics(hdc, &tm);
@@ -1393,46 +2706,39 @@ PRectangle ListBoxX::GetDesiredRect() {
 	SelectFont(hdc, oldFont);
 	::ReleaseDC(lb, hdc);
 
-	int widthDesired = Platform::Maximum(textSize.cx, (len + 1) * tm.tmAveCharWidth);
+	const int widthDesired = std::max(textSize.cx, (len + 1) * tm.tmAveCharWidth);
 	if (width < widthDesired)
 		width = widthDesired;
 
 	rcDesired.right = rcDesired.left + TextOffset() + width + (TextInset.x * 2);
 	if (Length() > rows)
-		rcDesired.right += ::GetSystemMetrics(SM_CXVSCROLL);
+		rcDesired.right += SystemMetricsForDpi(SM_CXVSCROLL, dpi);
 
-	AdjustWindowRect(&rcDesired);
+	AdjustWindowRect(&rcDesired, dpi);
 	return rcDesired;
 }
 
 int ListBoxX::TextOffset() const {
-	int pixWidth = const_cast<XPMSet*>(&xset)->GetWidth();
-	return pixWidth == 0 ? ItemInset.x : ItemInset.x + pixWidth + (ImageInset.x * 2);
+	const int pixWidth = images.GetWidth();
+	return static_cast<int>(pixWidth == 0 ? ItemInset.x : ItemInset.x + pixWidth + (ImageInset.x * 2));
 }
 
 int ListBoxX::CaretFromEdge() {
 	PRectangle rc;
-	AdjustWindowRect(&rc);
-	return TextOffset() + TextInset.x + (0 - rc.left) - 1;
+	AdjustWindowRect(&rc, dpi);
+	return TextOffset() + static_cast<int>(TextInset.x + (0 - rc.left) - 1);
 }
 
 void ListBoxX::Clear() {
-	::SendMessage(lb, LB_RESETCONTENT, 0, 0);
+	ListBox_ResetContent(lb);
 	maxItemCharacters = 0;
-	widestItem = NULL;
+	widestItem = nullptr;
 	lti.Clear();
 }
 
-void ListBoxX::Append(char *s, int type) {
-	int index = ::SendMessage(lb, LB_ADDSTRING, 0, reinterpret_cast<LPARAM>(s));
-	if (index < 0)
-		return;
-	ListItemData *newItem = lti.Append(s, type);
-	unsigned int len = static_cast<unsigned int>(strlen(s));
-	if (maxItemCharacters < len) {
-		maxItemCharacters = len;
-		widestItem = newItem->text;
-	}
+void ListBoxX::Append(char *, int) {
+	// This method is no longer called in Scintilla
+	PLATFORM_ASSERT(false);
 }
 
 int ListBoxX::Length() {
@@ -1445,12 +2751,13 @@ void ListBoxX::Select(int n) {
 	// selected states
 	SetRedraw(false);
 	CentreItem(n);
-	::SendMessage(lb, LB_SETCURSEL, n, 0);
+	ListBox_SetCurSel(lb, n);
+	OnSelChange();
 	SetRedraw(true);
 }
 
 int ListBoxX::GetSelection() {
-	return ::SendMessage(lb, LB_GETCURSEL, 0, 0);
+	return ListBox_GetCurSel(lb);
 }
 
 // This is not actually called at present
@@ -1459,17 +2766,22 @@ int ListBoxX::Find(const char *) {
 }
 
 void ListBoxX::GetValue(int n, char *value, int len) {
-	ListItemData item = lti.Get(n);
+	const ListItemData item = lti.Get(n);
 	strncpy(value, item.text, len);
 	value[len-1] = '\0';
 }
 
 void ListBoxX::RegisterImage(int type, const char *xpm_data) {
-	xset.Add(type, xpm_data);
+	XPM xpmImage(xpm_data);
+	images.Add(type, new RGBAImage(xpmImage));
+}
+
+void ListBoxX::RegisterRGBAImage(int type, int width, int height, const unsigned char *pixelsImage) {
+	images.Add(type, new RGBAImage(width, height, 1.0, pixelsImage));
 }
 
 void ListBoxX::ClearRegisteredImages() {
-	xset.Clear();
+	images.Clear();
 }
 
 void ListBoxX::Draw(DRAWITEMSTRUCT *pDrawItem) {
@@ -1490,149 +2802,179 @@ void ListBoxX::Draw(DRAWITEMSTRUCT *pDrawItem) {
 			::SetTextColor(pDrawItem->hDC, ::GetSysColor(COLOR_WINDOWTEXT));
 		}
 
-		ListItemData item = lti.Get(pDrawItem->itemID);
-		int pixId = item.pixId;
+		const ListItemData item = lti.Get(pDrawItem->itemID);
+		const int pixId = item.pixId;
 		const char *text = item.text;
-		int len = strlen(text);
+		const int len = static_cast<int>(strlen(text));
 
 		RECT rcText = rcBox;
-		::InsetRect(&rcText, TextInset.x, TextInset.y);
+		::InsetRect(&rcText, static_cast<int>(TextInset.x), static_cast<int>(TextInset.y));
 
 		if (unicodeMode) {
-			const TextWide tbuf(text, len, unicodeMode);
+			const TextWide tbuf(text, unicodeMode);
 			::DrawTextW(pDrawItem->hDC, tbuf.buffer, tbuf.tlen, &rcText, DT_NOPREFIX|DT_END_ELLIPSIS|DT_SINGLELINE|DT_NOCLIP);
 		} else {
 			::DrawTextA(pDrawItem->hDC, text, len, &rcText, DT_NOPREFIX|DT_END_ELLIPSIS|DT_SINGLELINE|DT_NOCLIP);
 		}
-		if (pDrawItem->itemState & ODS_SELECTED) {
-			::DrawFocusRect(pDrawItem->hDC, &rcBox);
-		}
 
 		// Draw the image, if any
-		XPM *pxpm = xset.Get(pixId);
-		if (pxpm) {
-			Surface *surfaceItem = Surface::Allocate();
-			if (surfaceItem) {
+		const RGBAImage *pimage = images.Get(pixId);
+		if (pimage) {
+			std::unique_ptr<Surface> surfaceItem(Surface::Allocate(technology));
+			if (technology == SCWIN_TECH_GDI) {
 				surfaceItem->Init(pDrawItem->hDC, pDrawItem->hwndItem);
-				//surfaceItem->SetUnicodeMode(unicodeMode);
-				//surfaceItem->SetDBCSMode(codePage);
-				int left = pDrawItem->rcItem.left + ItemInset.x + ImageInset.x;
-				PRectangle rcImage(left, pDrawItem->rcItem.top,
-					left + xset.GetWidth(), pDrawItem->rcItem.bottom);
-				pxpm->Draw(surfaceItem, rcImage);
-				delete surfaceItem;
+				const long left = pDrawItem->rcItem.left + static_cast<int>(ItemInset.x + ImageInset.x);
+				const PRectangle rcImage = PRectangle::FromInts(left, pDrawItem->rcItem.top,
+					left + images.GetWidth(), pDrawItem->rcItem.bottom);
+				surfaceItem->DrawRGBAImage(rcImage,
+					pimage->GetWidth(), pimage->GetHeight(), pimage->Pixels());
 				::SetTextAlign(pDrawItem->hDC, TA_TOP);
+			} else {
+#if defined(USE_D2D)
+				const D2D1_RENDER_TARGET_PROPERTIES props = D2D1::RenderTargetProperties(
+					D2D1_RENDER_TARGET_TYPE_DEFAULT,
+					D2D1::PixelFormat(
+						DXGI_FORMAT_B8G8R8A8_UNORM,
+						D2D1_ALPHA_MODE_IGNORE),
+					0,
+					0,
+					D2D1_RENDER_TARGET_USAGE_NONE,
+					D2D1_FEATURE_LEVEL_DEFAULT
+					);
+				ID2D1DCRenderTarget *pDCRT = nullptr;
+				HRESULT hr = pD2DFactory->CreateDCRenderTarget(&props, &pDCRT);
+				if (SUCCEEDED(hr) && pDCRT) {
+					RECT rcWindow;
+					GetClientRect(pDrawItem->hwndItem, &rcWindow);
+					hr = pDCRT->BindDC(pDrawItem->hDC, &rcWindow);
+					if (SUCCEEDED(hr)) {
+						surfaceItem->Init(pDCRT, pDrawItem->hwndItem);
+						pDCRT->BeginDraw();
+						const long left = pDrawItem->rcItem.left + static_cast<long>(ItemInset.x + ImageInset.x);
+						const PRectangle rcImage = PRectangle::FromInts(left, pDrawItem->rcItem.top,
+							left + images.GetWidth(), pDrawItem->rcItem.bottom);
+						surfaceItem->DrawRGBAImage(rcImage,
+							pimage->GetWidth(), pimage->GetHeight(), pimage->Pixels());
+						pDCRT->EndDraw();
+						ReleaseUnknown(pDCRT);
+					}
+				}
+#endif
 			}
 		}
 	}
 }
 
-void ListBoxX::AppendListItem(const char *startword, const char *numword) {
-	ListItemData *item = lti.AllocItem();
-	item->text = startword;
+void ListBoxX::AppendListItem(const char *text, const char *numword) {
+	int pixId = -1;
 	if (numword) {
-		int pixId = 0;
+		pixId = 0;
 		char ch;
 		while ((ch = *++numword) != '\0') {
 			pixId = 10 * pixId + (ch - '0');
 		}
-		item->pixId = pixId;
-	} else {
-		item->pixId = -1;
 	}
 
-	unsigned int len = static_cast<unsigned int>(strlen(item->text));
+	lti.AllocItem(text, pixId);
+	const unsigned int len = static_cast<unsigned int>(strlen(text));
 	if (maxItemCharacters < len) {
 		maxItemCharacters = len;
-		widestItem = item->text;
+		widestItem = text;
 	}
 }
 
+void ListBoxX::SetDelegate(IListBoxDelegate *lbDelegate) {
+	delegate = lbDelegate;
+}
+
 void ListBoxX::SetList(const char *list, char separator, char typesep) {
 	// Turn off redraw while populating the list - this has a significant effect, even if
 	// the listbox is not visible.
 	SetRedraw(false);
 	Clear();
-	int size = strlen(list) + 1;
-	char *words = new char[size];
-	if (words) {
-		lti.SetWords(words);
-		memcpy(words, list, size);
-		char *startword = words;
-		char *numword = NULL;
-		int i = 0;
-		for (; words[i]; i++) {
-			if (words[i] == separator) {
-				words[i] = '\0';
-				if (numword)
-					*numword = '\0';
-				AppendListItem(startword, numword);
-				startword = words + i + 1;
-				numword = NULL;
-			} else if (words[i] == typesep) {
-				numword = words + i;
-			}
-		}
-		if (startword) {
+	const size_t size = strlen(list);
+	char *words = lti.SetWords(list);
+	char *startword = words;
+	char *numword = nullptr;
+	for (size_t i=0; i < size; i++) {
+		if (words[i] == separator) {
+			words[i] = '\0';
 			if (numword)
 				*numword = '\0';
 			AppendListItem(startword, numword);
+			startword = words + i + 1;
+			numword = nullptr;
+		} else if (words[i] == typesep) {
+			numword = words + i;
 		}
+	}
+	if (startword) {
+		if (numword)
+			*numword = '\0';
+		AppendListItem(startword, numword);
+	}
 
-		// Finally populate the listbox itself with the correct number of items
-		int count = lti.Count();
-		::SendMessage(lb, LB_INITSTORAGE, count, 0);
-		for (int j=0; j<count; j++) {
-			::SendMessage(lb, LB_ADDSTRING, 0, j+1);
-		}
+	// Finally populate the listbox itself with the correct number of items
+	const int count = lti.Count();
+	::SendMessage(lb, LB_INITSTORAGE, count, 0);
+	for (intptr_t j=0; j<count; j++) {
+		ListBox_AddItemData(lb, j+1);
 	}
 	SetRedraw(true);
 }
 
-void ListBoxX::AdjustWindowRect(PRectangle *rc) const {
-	::AdjustWindowRectEx(reinterpret_cast<RECT*>(rc), WS_THICKFRAME, false, WS_EX_WINDOWEDGE);
+void ListBoxX::AdjustWindowRect(PRectangle *rc, UINT dpi) noexcept {
+	RECT rcw = RectFromPRectangle(*rc);
+	if (fnAdjustWindowRectExForDpi) {
+		fnAdjustWindowRectExForDpi(&rcw, WS_THICKFRAME, false, WS_EX_WINDOWEDGE, dpi);
+	} else {
+		::AdjustWindowRectEx(&rcw, WS_THICKFRAME, false, WS_EX_WINDOWEDGE);
+	}
+	*rc = PRectangle::FromInts(rcw.left, rcw.top, rcw.right, rcw.bottom);
 }
 
 int ListBoxX::ItemHeight() const {
-	int itemHeight = lineHeight + (TextInset.y * 2);
-	int pixHeight = const_cast<XPMSet*>(&xset)->GetHeight() + (ImageInset.y * 2);
+	int itemHeight = lineHeight + (static_cast<int>(TextInset.y) * 2);
+	const int pixHeight = images.GetHeight() + (static_cast<int>(ImageInset.y) * 2);
 	if (itemHeight < pixHeight) {
 		itemHeight = pixHeight;
 	}
 	return itemHeight;
 }
 
-int ListBoxX::MinClientWidth() const {
+int ListBoxX::MinClientWidth() const noexcept {
 	return 12 * (aveCharWidth+aveCharWidth/3);
 }
 
-Point ListBoxX::MinTrackSize() const {
-	PRectangle rc(0, 0, MinClientWidth(), ItemHeight());
-	AdjustWindowRect(&rc);
-	return Point(rc.Width(), rc.Height());
+POINT ListBoxX::MinTrackSize() const {
+	PRectangle rc = PRectangle::FromInts(0, 0, MinClientWidth(), ItemHeight());
+	AdjustWindowRect(&rc, dpi);
+	POINT ret = {static_cast<LONG>(rc.Width()), static_cast<LONG>(rc.Height())};
+	return ret;
 }
 
-Point ListBoxX::MaxTrackSize() const {
-	PRectangle rc(0, 0,
-		maxCharWidth * maxItemCharacters + TextInset.x * 2 +
-		 TextOffset() + ::GetSystemMetrics(SM_CXVSCROLL),
+POINT ListBoxX::MaxTrackSize() const {
+	PRectangle rc = PRectangle::FromInts(0, 0,
+		std::max(static_cast<unsigned int>(MinClientWidth()),
+		maxCharWidth * maxItemCharacters + static_cast<int>(TextInset.x) * 2 +
+		 TextOffset() + SystemMetricsForDpi(SM_CXVSCROLL, dpi)),
 		ItemHeight() * lti.Count());
-	AdjustWindowRect(&rc);
-	return Point(rc.Width(), rc.Height());
+	AdjustWindowRect(&rc, dpi);
+	POINT ret = {static_cast<LONG>(rc.Width()), static_cast<LONG>(rc.Height())};
+	return ret;
 }
 
-void ListBoxX::SetRedraw(bool on) {
-	::SendMessage(lb, WM_SETREDRAW, static_cast<BOOL>(on), 0);
+void ListBoxX::SetRedraw(bool on) noexcept {
+	::SendMessage(lb, WM_SETREDRAW, on, 0);
 	if (on)
-		::InvalidateRect(lb, NULL, TRUE);
+		::InvalidateRect(lb, nullptr, TRUE);
 }
 
 void ListBoxX::ResizeToCursor() {
 	PRectangle rc = GetPosition();
-	Point pt;
-	::GetCursorPos(reinterpret_cast<POINT*>(&pt));
-	pt.x += dragOffset.x;
-	pt.y += dragOffset.y;
+	POINT ptw;
+	::GetCursorPos(&ptw);
+	const Point pt = PointFromPOINT(ptw) + dragOffset;
 
 	switch (resizeHit) {
 		case HTLEFT:
@@ -1665,13 +3007,13 @@ void ListBoxX::ResizeToCursor() {
 			break;
 	}
 
-	Point ptMin = MinTrackSize();
-	Point ptMax = MaxTrackSize();
+	const POINT ptMin = MinTrackSize();
+	const POINT ptMax = MaxTrackSize();
 	// We don't allow the left edge to move at present, but just in case
-	rc.left = Platform::Maximum(Platform::Minimum(rc.left, rcPreSize.right - ptMin.x), rcPreSize.right - ptMax.x);
-	rc.top = Platform::Maximum(Platform::Minimum(rc.top, rcPreSize.bottom - ptMin.y), rcPreSize.bottom - ptMax.y);
-	rc.right = Platform::Maximum(Platform::Minimum(rc.right, rcPreSize.left + ptMax.x), rcPreSize.left + ptMin.x);
-	rc.bottom = Platform::Maximum(Platform::Minimum(rc.bottom, rcPreSize.top + ptMax.y), rcPreSize.top + ptMin.y);
+	rc.left = std::clamp(rc.left, rcPreSize.right - ptMax.x, rcPreSize.right - ptMin.x);
+	rc.top = std::clamp(rc.top, rcPreSize.bottom - ptMax.y, rcPreSize.bottom - ptMin.y);
+	rc.right = std::clamp(rc.right, rcPreSize.left + ptMin.x, rcPreSize.left + ptMax.x);
+	rc.bottom = std::clamp(rc.bottom, rcPreSize.top + ptMin.y, rcPreSize.top + ptMax.y);
 
 	SetPosition(rc);
 }
@@ -1695,7 +3037,7 @@ void ListBoxX::StartResize(WPARAM hitCode) {
 			break;
 
 		// Note that the current hit test code prevents the left edge cases ever firing
-		// as we don't want the left edge to be moveable
+		// as we don't want the left edge to be movable
 		case HTLEFT:
 		case HTTOP:
 		case HTTOPLEFT:
@@ -1715,22 +3057,23 @@ void ListBoxX::StartResize(WPARAM hitCode) {
 	resizeHit = hitCode;
 }
 
-int ListBoxX::NcHitTest(WPARAM wParam, LPARAM lParam) const {
-	int hit = ::DefWindowProc(GetHWND(), WM_NCHITTEST, wParam, lParam);
+LRESULT ListBoxX::NcHitTest(WPARAM wParam, LPARAM lParam) const {
+	const PRectangle rc = GetPosition();
+
+	LRESULT hit = ::DefWindowProc(GetHWND(), WM_NCHITTEST, wParam, lParam);
 	// There is an apparent bug in the DefWindowProc hit test code whereby it will
 	// return HTTOPXXX if the window in question is shorter than the default
 	// window caption height + frame, even if one is hovering over the bottom edge of
 	// the frame, so workaround that here
 	if (hit >= HTTOP && hit <= HTTOPRIGHT) {
-		int minHeight = GetSystemMetrics(SM_CYMINTRACK);
-		PRectangle rc = const_cast<ListBoxX*>(this)->GetPosition();
-		int yPos = GET_Y_LPARAM(lParam);
+		const int minHeight = SystemMetricsForDpi(SM_CYMINTRACK, dpi);
+		const int yPos = GET_Y_LPARAM(lParam);
 		if ((rc.Height() < minHeight) && (yPos > ((rc.top + rc.bottom)/2))) {
 			hit += HTBOTTOM - HTTOP;
 		}
 	}
 
-	// Nerver permit resizing that moves the left edge. Allow movement of top or bottom edge
+	// Never permit resizing that moves the left edge. Allow movement of top or bottom edge
 	// depending on whether the list is above or below the caret
 	switch (hit) {
 		case HTLEFT:
@@ -1741,7 +3084,6 @@ int ListBoxX::NcHitTest(WPARAM wParam, LPARAM lParam) const {
 
 		case HTTOP:
 		case HTTOPRIGHT: {
-				PRectangle rc = const_cast<ListBoxX*>(this)->GetPosition();
 				// Valid only if caret below list
 				if (location.y < rc.top)
 					hit = HTERROR;
@@ -1750,9 +3092,8 @@ int ListBoxX::NcHitTest(WPARAM wParam, LPARAM lParam) const {
 
 		case HTBOTTOM:
 		case HTBOTTOMRIGHT: {
-				PRectangle rc = const_cast<ListBoxX*>(this)->GetPosition();
 				// Valid only if caret above list
-				if (rc.bottom < location.y)
+				if (rc.bottom <= location.y)
 					hit = HTERROR;
 			}
 			break;
@@ -1762,106 +3103,126 @@ int ListBoxX::NcHitTest(WPARAM wParam, LPARAM lParam) const {
 }
 
 void ListBoxX::OnDoubleClick() {
+	if (delegate) {
+		ListBoxEvent event(ListBoxEvent::EventType::doubleClick);
+		delegate->ListNotify(&event);
+	}
+}
 
-	if (doubleClickAction != NULL) {
-		doubleClickAction(doubleClickActionData);
+void ListBoxX::OnSelChange() {
+	if (delegate) {
+		ListBoxEvent event(ListBoxEvent::EventType::selectionChange);
+		delegate->ListNotify(&event);
 	}
 }
 
-Point ListBoxX::GetClientExtent() const {
-	PRectangle rc = const_cast<ListBoxX*>(this)->GetClientPosition();
-	return Point(rc.Width(), rc.Height());
+POINT ListBoxX::GetClientExtent() const noexcept {
+	RECT rc;
+	::GetWindowRect(HwndFromWindowID(wid), &rc);
+	POINT ret { rc.right - rc.left, rc.bottom - rc.top };
+	return ret;
 }
 
 void ListBoxX::CentreItem(int n) {
 	// If below mid point, scroll up to centre, but with more items below if uneven
 	if (n >= 0) {
-		Point extent = GetClientExtent();
-		int visible = extent.y/ItemHeight();
+		const POINT extent = GetClientExtent();
+		const int visible = extent.y/ItemHeight();
 		if (visible < Length()) {
-			int top = ::SendMessage(lb, LB_GETTOPINDEX, 0, 0);
-			int half = (visible - 1) / 2;
+			const int top = ListBox_GetTopIndex(lb);
+			const int half = (visible - 1) / 2;
 			if (n > (top + half))
-				::SendMessage(lb, LB_SETTOPINDEX, n - half , 0);
+				ListBox_SetTopIndex(lb, n - half);
 		}
 	}
 }
 
 // Performs a double-buffered paint operation to avoid flicker
-void ListBoxX::Paint(HDC hDC) {
-	Point extent = GetClientExtent();
+void ListBoxX::Paint(HDC hDC) noexcept {
+	const POINT extent = GetClientExtent();
 	HBITMAP hBitmap = ::CreateCompatibleBitmap(hDC, extent.x, extent.y);
 	HDC bitmapDC = ::CreateCompatibleDC(hDC);
 	HBITMAP hBitmapOld = SelectBitmap(bitmapDC, hBitmap);
 	// The list background is mainly erased during painting, but can be a small
 	// unpainted area when at the end of a non-integrally sized list with a
 	// vertical scroll bar
-	RECT rc = { 0, 0, extent.x, extent.y };
+	const RECT rc = { 0, 0, extent.x, extent.y };
 	::FillRect(bitmapDC, &rc, reinterpret_cast<HBRUSH>(COLOR_WINDOW+1));
 	// Paint the entire client area and vertical scrollbar
 	::SendMessage(lb, WM_PRINT, reinterpret_cast<WPARAM>(bitmapDC), PRF_CLIENT|PRF_NONCLIENT);
 	::BitBlt(hDC, 0, 0, extent.x, extent.y, bitmapDC, 0, 0, SRCCOPY);
 	// Select a stock brush to prevent warnings from BoundsChecker
-	::SelectObject(bitmapDC, GetStockFont(WHITE_BRUSH));
+	SelectBrush(bitmapDC, GetStockBrush(WHITE_BRUSH));
 	SelectBitmap(bitmapDC, hBitmapOld);
 	::DeleteDC(bitmapDC);
 	::DeleteObject(hBitmap);
 }
 
-LRESULT PASCAL ListBoxX::ControlWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
-	switch (uMsg) {
-	case WM_ERASEBKGND:
-		return TRUE;
-
-	case WM_PAINT: {
-			PAINTSTRUCT ps;
-			HDC hDC = ::BeginPaint(hWnd, &ps);
-			ListBoxX *lbx = reinterpret_cast<ListBoxX *>(PointerFromWindow(::GetParent(hWnd)));
-			if (lbx)
-				lbx->Paint(hDC);
-			::EndPaint(hWnd, &ps);
-		}
-		return 0;
-
-	case WM_MOUSEACTIVATE:
-		// This prevents the view activating when the scrollbar is clicked
-		return MA_NOACTIVATE;
+LRESULT PASCAL ListBoxX::ControlWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
+	try {
+		ListBoxX *lbx = static_cast<ListBoxX *>(PointerFromWindow(::GetParent(hWnd)));
+		switch (iMessage) {
+		case WM_ERASEBKGND:
+			return TRUE;
 
-	case WM_LBUTTONDOWN: {
-			// We must take control of selection to prevent the ListBox activating
-			// the popup
-			LRESULT lResult = ::SendMessage(hWnd, LB_ITEMFROMPOINT, 0, lParam);
-			int item = LOWORD(lResult);
-			if (HIWORD(lResult) == 0 && item >= 0) {
-				::SendMessage(hWnd, LB_SETCURSEL, item, 0);
+		case WM_PAINT: {
+				PAINTSTRUCT ps;
+				HDC hDC = ::BeginPaint(hWnd, &ps);
+				if (lbx) {
+					lbx->Paint(hDC);
+				}
+				::EndPaint(hWnd, &ps);
 			}
-		}
-		return 0;
+			return 0;
+
+		case WM_MOUSEACTIVATE:
+			// This prevents the view activating when the scrollbar is clicked
+			return MA_NOACTIVATE;
+
+		case WM_LBUTTONDOWN: {
+				// We must take control of selection to prevent the ListBox activating
+				// the popup
+				const LRESULT lResult = ::SendMessage(hWnd, LB_ITEMFROMPOINT, 0, lParam);
+				const int item = LOWORD(lResult);
+				if (HIWORD(lResult) == 0 && item >= 0) {
+					ListBox_SetCurSel(hWnd, item);
+					if (lbx) {
+						lbx->OnSelChange();
+					}
+				}
+			}
+			return 0;
 
-	case WM_LBUTTONUP:
-		return 0;
+		case WM_LBUTTONUP:
+			return 0;
 
-	case WM_LBUTTONDBLCLK: {
-			ListBoxX *lbx = reinterpret_cast<ListBoxX *>(PointerFromWindow(::GetParent(hWnd)));
-			if (lbx) {
-				lbx->OnDoubleClick();
+		case WM_LBUTTONDBLCLK: {
+				if (lbx) {
+					lbx->OnDoubleClick();
+				}
 			}
+			return 0;
+
+		case WM_MBUTTONDOWN:
+			// disable the scroll wheel button click action
+			return 0;
 		}
-		return 0;
-	}
 
-	WNDPROC prevWndProc = reinterpret_cast<WNDPROC>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
-	if (prevWndProc) {
-		return ::CallWindowProc(prevWndProc, hWnd, uMsg, wParam, lParam);
-	} else {
-		return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
+		WNDPROC prevWndProc = reinterpret_cast<WNDPROC>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
+		if (prevWndProc) {
+			return ::CallWindowProc(prevWndProc, hWnd, iMessage, wParam, lParam);
+		} else {
+			return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+		}
+	} catch (...) {
 	}
+	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 }
 
 LRESULT ListBoxX::WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
 	switch (iMessage) {
 	case WM_CREATE: {
-			HINSTANCE hinstanceParent = GetWindowInstance(reinterpret_cast<HWND>(parent->GetID()));
+			HINSTANCE hinstanceParent = GetWindowInstance(HwndFromWindow(*parent));
 			// Note that LBS_NOINTEGRALHEIGHT is specified to fix cosmetic issue when resizing the list
 			// but has useful side effect of speeding up list population significantly
 			lb = ::CreateWindowEx(
@@ -1869,10 +3230,10 @@ LRESULT ListBoxX::WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam
 				WS_CHILD | WS_VSCROLL | WS_VISIBLE |
 				LBS_OWNERDRAWFIXED | LBS_NODATA | LBS_NOINTEGRALHEIGHT,
 				0, 0, 150,80, hWnd,
-				reinterpret_cast<HMENU>(ctrlID),
+				reinterpret_cast<HMENU>(static_cast<ptrdiff_t>(ctrlID)),
 				hinstanceParent,
 				0);
-			WNDPROC prevWndProc = reinterpret_cast<WNDPROC>(::SetWindowLongPtr(lb, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(ControlWndProc)));
+			WNDPROC prevWndProc = SubclassWindow(lb, ControlWndProc);
 			::SetWindowLongPtr(lb, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(prevWndProc));
 		}
 		break;
@@ -1897,12 +3258,12 @@ LRESULT ListBoxX::WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam
 	case WM_COMMAND:
 		// This is not actually needed now - the registered double click action is used
 		// directly to action a choice from the list.
-		::SendMessage(reinterpret_cast<HWND>(parent->GetID()), iMessage, wParam, lParam);
+		::SendMessage(HwndFromWindow(*parent), iMessage, wParam, lParam);
 		break;
 
 	case WM_MEASUREITEM: {
 			MEASUREITEMSTRUCT *pMeasureItem = reinterpret_cast<MEASUREITEMSTRUCT *>(lParam);
-			pMeasureItem->itemHeight = static_cast<unsigned int>(ItemHeight());
+			pMeasureItem->itemHeight = ItemHeight();
 		}
 		break;
 
@@ -1912,7 +3273,7 @@ LRESULT ListBoxX::WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam
 
 	case WM_DESTROY:
 		lb = 0;
-		::SetWindowLong(hWnd, 0, 0);
+		SetWindowPointer(hWnd, nullptr);
 		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 
 	case WM_ERASEBKGND:
@@ -1922,8 +3283,8 @@ LRESULT ListBoxX::WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam
 
 	case WM_GETMINMAXINFO: {
 			MINMAXINFO *minMax = reinterpret_cast<MINMAXINFO*>(lParam);
-			*reinterpret_cast<Point*>(&minMax->ptMaxTrackSize) = MaxTrackSize();
-			*reinterpret_cast<Point*>(&minMax->ptMinTrackSize) = MinTrackSize();
+			minMax->ptMaxTrackSize = MaxTrackSize();
+			minMax->ptMinTrackSize = MinTrackSize();
 		}
 		break;
 
@@ -1955,6 +3316,30 @@ LRESULT ListBoxX::WndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam
 			::ReleaseCapture();
 		}
 		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+	case WM_MOUSEWHEEL:
+		wheelDelta -= GET_WHEEL_DELTA_WPARAM(wParam);
+		if (std::abs(wheelDelta) >= WHEEL_DELTA) {
+			const int nRows = GetVisibleRows();
+			int linesToScroll = 1;
+			if (nRows > 1) {
+				linesToScroll = nRows - 1;
+			}
+			if (linesToScroll > 3) {
+				linesToScroll = 3;
+			}
+			linesToScroll *= (wheelDelta / WHEEL_DELTA);
+			int top = ListBox_GetTopIndex(lb) + linesToScroll;
+			if (top < 0) {
+				top = 0;
+			}
+			ListBox_SetTopIndex(lb, top);
+			// update wheel delta residue
+			if (wheelDelta >= 0)
+				wheelDelta = wheelDelta % WHEEL_DELTA;
+			else
+				wheelDelta = - (-wheelDelta % WHEEL_DELTA);
+		}
+		break;
 
 	default:
 		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
@@ -1970,7 +3355,7 @@ LRESULT PASCAL ListBoxX::StaticWndProc(
 		SetWindowPointer(hWnd, pCreate->lpCreateParams);
 	}
 	// Find C++ object associated with window.
-	ListBoxX *lbx = reinterpret_cast<ListBoxX *>(PointerFromWindow(hWnd));
+	ListBoxX *lbx = static_cast<ListBoxX *>(PointerFromWindow(hWnd));
 	if (lbx) {
 		return lbx->WndProc(hWnd, iMessage, wParam, lParam);
 	} else {
@@ -1978,122 +3363,81 @@ LRESULT PASCAL ListBoxX::StaticWndProc(
 	}
 }
 
-static bool ListBoxX_Register() {
-	WNDCLASSEX wndclassc;
+namespace {
+
+bool ListBoxX_Register() noexcept {
+	WNDCLASSEX wndclassc {};
 	wndclassc.cbSize = sizeof(wndclassc);
 	// We need CS_HREDRAW and CS_VREDRAW because of the ellipsis that might be drawn for
 	// truncated items in the list and the appearance/disappearance of the vertical scroll bar.
 	// The list repaint is double-buffered to avoid the flicker this would otherwise cause.
 	wndclassc.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
-	wndclassc.cbClsExtra = 0;
 	wndclassc.cbWndExtra = sizeof(ListBoxX *);
 	wndclassc.hInstance = hinstPlatformRes;
-	wndclassc.hIcon = NULL;
-	wndclassc.hbrBackground = NULL;
-	wndclassc.lpszMenuName = NULL;
 	wndclassc.lpfnWndProc = ListBoxX::StaticWndProc;
 	wndclassc.hCursor = ::LoadCursor(NULL, IDC_ARROW);
 	wndclassc.lpszClassName = ListBoxX_ClassName;
-	wndclassc.hIconSm = 0;
 
 	return ::RegisterClassEx(&wndclassc) != 0;
 }
 
-bool ListBoxX_Unregister() {
-	return ::UnregisterClass(ListBoxX_ClassName, hinstPlatformRes) != 0;
+void ListBoxX_Unregister() noexcept {
+	if (hinstPlatformRes) {
+		::UnregisterClass(ListBoxX_ClassName, hinstPlatformRes);
+	}
+}
+
 }
 
-Menu::Menu() : id(0) {
+Menu::Menu() noexcept : mid{} {
 }
 
 void Menu::CreatePopUp() {
 	Destroy();
-	id = ::CreatePopupMenu();
+	mid = ::CreatePopupMenu();
 }
 
 void Menu::Destroy() {
-	if (id)
-		::DestroyMenu(reinterpret_cast<HMENU>(id));
-	id = 0;
+	if (mid)
+		::DestroyMenu(static_cast<HMENU>(mid));
+	mid = 0;
 }
 
 void Menu::Show(Point pt, Window &w) {
-	::TrackPopupMenu(reinterpret_cast<HMENU>(id),
-		0, pt.x - 4, pt.y, 0,
-		reinterpret_cast<HWND>(w.GetID()), NULL);
+	::TrackPopupMenu(static_cast<HMENU>(mid),
+		TPM_RIGHTBUTTON, static_cast<int>(pt.x - 4), static_cast<int>(pt.y), 0,
+		HwndFromWindow(w), nullptr);
 	Destroy();
 }
 
-static bool initialisedET = false;
-static bool usePerformanceCounter = false;
-static LARGE_INTEGER frequency;
-
-ElapsedTime::ElapsedTime() {
-	if (!initialisedET) {
-		usePerformanceCounter = ::QueryPerformanceFrequency(&frequency) != 0;
-		initialisedET = true;
-	}
-	if (usePerformanceCounter) {
-		LARGE_INTEGER timeVal;
-		::QueryPerformanceCounter(&timeVal);
-		bigBit = timeVal.HighPart;
-		littleBit = timeVal.LowPart;
-	} else {
-		bigBit = clock();
-	}
-}
-
-double ElapsedTime::Duration(bool reset) {
-	double result;
-	long endBigBit;
-	long endLittleBit;
-
-	if (usePerformanceCounter) {
-		LARGE_INTEGER lEnd;
-		::QueryPerformanceCounter(&lEnd);
-		endBigBit = lEnd.HighPart;
-		endLittleBit = lEnd.LowPart;
-		LARGE_INTEGER lBegin;
-		lBegin.HighPart = bigBit;
-		lBegin.LowPart = littleBit;
-		double elapsed = lEnd.QuadPart - lBegin.QuadPart;
-		result = elapsed / static_cast<double>(frequency.QuadPart);
-	} else {
-		endBigBit = clock();
-		endLittleBit = 0;
-		double elapsed = endBigBit - bigBit;
-		result = elapsed / CLOCKS_PER_SEC;
-	}
-	if (reset) {
-		bigBit = endBigBit;
-		littleBit = endLittleBit;
-	}
-	return result;
-}
-
 class DynamicLibraryImpl : public DynamicLibrary {
 protected:
 	HMODULE h;
 public:
-	DynamicLibraryImpl(const char *modulePath) {
+	explicit DynamicLibraryImpl(const char *modulePath) noexcept {
 		h = ::LoadLibraryA(modulePath);
 	}
 
-	virtual ~DynamicLibraryImpl() {
-		if (h != NULL)
+	~DynamicLibraryImpl() override {
+		if (h)
 			::FreeLibrary(h);
 	}
 
 	// Use GetProcAddress to get a pointer to the relevant function.
-	virtual Function FindFunction(const char *name) {
-		if (h != NULL) {
-			return static_cast<Function>(
-				(void *)(::GetProcAddress(h, name)));
-		} else
-			return NULL;
+	Function FindFunction(const char *name) noexcept override {
+		if (h) {
+			// Use memcpy as it doesn't invoke undefined or conditionally defined behaviour.
+			FARPROC fp = ::GetProcAddress(h, name);
+			Function f = nullptr;
+			static_assert(sizeof(f) == sizeof(fp));
+			memcpy(&f, &fp, sizeof(f));
+			return f;
+		} else {
+			return nullptr;
+		}
 	}
 
-	virtual bool IsValid() {
+	bool IsValid() noexcept override {
 		return h != NULL;
 	}
 };
@@ -2103,11 +3447,11 @@ DynamicLibrary *DynamicLibrary::Load(const char *modulePath) {
 }
 
 ColourDesired Platform::Chrome() {
-	return ::GetSysColor(COLOR_3DFACE);
+	return ColourDesired(::GetSysColor(COLOR_3DFACE));
 }
 
 ColourDesired Platform::ChromeHighlight() {
-	return ::GetSysColor(COLOR_3DHIGHLIGHT);
+	return ColourDesired(::GetSysColor(COLOR_3DHIGHLIGHT));
 }
 
 const char *Platform::DefaultFont() {
@@ -2122,55 +3466,10 @@ unsigned int Platform::DoubleClickTime() {
 	return ::GetDoubleClickTime();
 }
 
-bool Platform::MouseButtonBounce() {
-	return false;
-}
-
 void Platform::DebugDisplay(const char *s) {
 	::OutputDebugStringA(s);
 }
 
-bool Platform::IsKeyDown(int key) {
-	return (::GetKeyState(key) & 0x80000000) != 0;
-}
-
-long Platform::SendScintilla(WindowID w, unsigned int msg, unsigned long wParam, long lParam) {
-	return ::SendMessage(reinterpret_cast<HWND>(w), msg, wParam, lParam);
-}
-
-long Platform::SendScintillaPointer(WindowID w, unsigned int msg, unsigned long wParam, void *lParam) {
-	return ::SendMessage(reinterpret_cast<HWND>(w), msg, wParam,
-		reinterpret_cast<LPARAM>(lParam));
-}
-
-bool Platform::IsDBCSLeadByte(int codePage, char ch) {
-	return ::IsDBCSLeadByteEx(codePage, ch) != 0;
-}
-
-int Platform::DBCSCharLength(int codePage, const char *s) {
-	return (::IsDBCSLeadByteEx(codePage, s[0]) != 0) ? 2 : 1;
-}
-
-int Platform::DBCSCharMaxLength() {
-	return 2;
-}
-
-// These are utility functions not really tied to a platform
-
-int Platform::Minimum(int a, int b) {
-	if (a < b)
-		return a;
-	else
-		return b;
-}
-
-int Platform::Maximum(int a, int b) {
-	if (a > b)
-		return a;
-	else
-		return b;
-}
-
 //#define TRACE
 
 #ifdef TRACE
@@ -2190,16 +3489,16 @@ void Platform::DebugPrintf(const char *, ...) {
 static bool assertionPopUps = true;
 
 bool Platform::ShowAssertionPopUps(bool assertionPopUps_) {
-	bool ret = assertionPopUps;
+	const bool ret = assertionPopUps;
 	assertionPopUps = assertionPopUps_;
 	return ret;
 }
 
 void Platform::Assert(const char *c, const char *file, int line) {
-	char buffer[2000];
-	sprintf(buffer, "Assertion [%s] failed at %s %d", c, file, line);
+	char buffer[2000] {};
+	sprintf(buffer, "Assertion [%s] failed at %s %d%s", c, file, line, assertionPopUps ? "" : "\r\n");
 	if (assertionPopUps) {
-		int idButton = ::MessageBoxA(0, buffer, "Assertion failure",
+		const int idButton = ::MessageBoxA(0, buffer, "Assertion failure",
 			MB_ABORTRETRYIGNORE|MB_ICONHAND|MB_SETFOREGROUND|MB_TASKMODAL);
 		if (idButton == IDRETRY) {
 			::DebugBreak();
@@ -2209,39 +3508,40 @@ void Platform::Assert(const char *c, const char *file, int line) {
 			abort();
 		}
 	} else {
-		strcat(buffer, "\r\n");
 		Platform::DebugDisplay(buffer);
 		::DebugBreak();
 		abort();
 	}
 }
 
-int Platform::Clamp(int val, int minVal, int maxVal) {
-	if (val > maxVal)
-		val = maxVal;
-	if (val < minVal)
-		val = minVal;
-	return val;
+void Platform_Initialise(void *hInstance) noexcept {
+	hinstPlatformRes = static_cast<HINSTANCE>(hInstance);
+	LoadDpiForWindow();
+	ListBoxX_Register();
 }
 
-void Platform_Initialise(void *hInstance) {
-	OSVERSIONINFO osv = {sizeof(OSVERSIONINFO),0,0,0,0,TEXT("")};
-	::GetVersionEx(&osv);
-	onNT = osv.dwPlatformId == VER_PLATFORM_WIN32_NT;
-	::InitializeCriticalSection(&crPlatformLock);
-	hinstPlatformRes = reinterpret_cast<HINSTANCE>(hInstance);
-	// This may be called from DllMain, in which case the call to LoadLibrary
-	// is bad because it can upset the DLL load order.
-	if (!hDLLImage) {
-		hDLLImage = ::LoadLibrary(TEXT("Msimg32"));
+void Platform_Finalise(bool fromDllMain) noexcept {
+#if defined(USE_D2D)
+	if (!fromDllMain) {
+		ReleaseUnknown(defaultRenderingParams);
+		ReleaseUnknown(customClearTypeRenderingParams);
+		ReleaseUnknown(pIDWriteFactory);
+		ReleaseUnknown(pD2DFactory);
+		if (hDLLDWrite) {
+			FreeLibrary(hDLLDWrite);
+			hDLLDWrite = {};
+		}
+		if (hDLLD2D) {
+			FreeLibrary(hDLLD2D);
+			hDLLD2D = {};
+		}
 	}
-	if (hDLLImage) {
-		AlphaBlendFn = (AlphaBlendSig)::GetProcAddress(hDLLImage, "AlphaBlend");
+#endif
+	if (!fromDllMain && hDLLShcore) {
+		FreeLibrary(hDLLShcore);
+		hDLLShcore = {};
 	}
-	ListBoxX_Register();
+	ListBoxX_Unregister();
 }
 
-void Platform_Finalise() {
-	ListBoxX_Unregister();
-	::DeleteCriticalSection(&crPlatformLock);
 }
diff --git a/Pythonwin/Scintilla/win32/PlatWin.h b/Pythonwin/Scintilla/win32/PlatWin.h
new file mode 100644
index 000000000..eb4bfb556
--- /dev/null
+++ b/Pythonwin/Scintilla/win32/PlatWin.h
@@ -0,0 +1,91 @@
+// Scintilla source code edit control
+/** @file PlatWin.h
+ ** Implementation of platform facilities on Windows.
+ **/
+// Copyright 1998-2011 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef PLATWIN_H
+#define PLATWIN_H
+
+namespace Scintilla {
+
+#ifndef USER_DEFAULT_SCREEN_DPI
+#define USER_DEFAULT_SCREEN_DPI		96
+#endif
+
+extern void Platform_Initialise(void *hInstance) noexcept;
+
+extern void Platform_Finalise(bool fromDllMain) noexcept;
+
+constexpr RECT RectFromPRectangle(PRectangle prc) noexcept {
+	RECT rc = { static_cast<LONG>(prc.left), static_cast<LONG>(prc.top),
+		static_cast<LONG>(prc.right), static_cast<LONG>(prc.bottom) };
+	return rc;
+}
+
+constexpr POINT POINTFromPoint(Point pt) noexcept {
+	return POINT{ static_cast<LONG>(pt.x), static_cast<LONG>(pt.y) };
+}
+
+constexpr Point PointFromPOINT(POINT pt) noexcept {
+	return Point::FromInts(pt.x, pt.y);
+}
+
+constexpr HWND HwndFromWindowID(WindowID wid) noexcept {
+	return static_cast<HWND>(wid);
+}
+
+inline HWND HwndFromWindow(const Window &w) noexcept {
+	return HwndFromWindowID(w.GetID());
+}
+
+void *PointerFromWindow(HWND hWnd) noexcept;
+void SetWindowPointer(HWND hWnd, void *ptr) noexcept;
+
+/// Find a function in a DLL and convert to a function pointer.
+/// This avoids undefined and conditionally defined behaviour.
+template<typename T>
+T DLLFunction(HMODULE hModule, LPCSTR lpProcName) noexcept {
+	if (!hModule) {
+		return nullptr;
+	}
+	FARPROC function = ::GetProcAddress(hModule, lpProcName);
+	static_assert(sizeof(T) == sizeof(function));
+	T fp;
+	memcpy(&fp, &function, sizeof(T));
+	return fp;
+}
+
+// Release an IUnknown* and set to nullptr.
+// While IUnknown::Release must be noexcept, it isn't marked as such so produces
+// warnings which are avoided by the catch.
+template <class T>
+void ReleaseUnknown(T *&ppUnknown) noexcept {
+	if (ppUnknown) {
+		try {
+			ppUnknown->Release();
+		}
+		catch (...) {
+			// Never occurs
+		}
+		ppUnknown = nullptr;
+	}
+}
+
+
+UINT DpiForWindow(WindowID wid) noexcept;
+
+int SystemMetricsForDpi(int nIndex, UINT dpi) noexcept;
+
+HCURSOR LoadReverseArrowCursor(UINT dpi) noexcept;
+
+#if defined(USE_D2D)
+extern bool LoadD2D();
+extern ID2D1Factory *pD2DFactory;
+extern IDWriteFactory *pIDWriteFactory;
+#endif
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/win32/PlatformRes.h b/Pythonwin/Scintilla/win32/PlatformRes.h
deleted file mode 100644
index bbffcbac7..000000000
--- a/Pythonwin/Scintilla/win32/PlatformRes.h
+++ /dev/null
@@ -1,8 +0,0 @@
-// Scintilla source code edit control
-/** @file PlatformRes.h
- ** Defines IDs of resources used by Scintilla on Windows platform.
- **/
-// Copyright 1998-2001 by Neil Hodgson <neilh@scintilla.org>
-// The License.txt file describes the conditions under which this software may be distributed.
-
-#define IDC_MARGIN                 400
diff --git a/Pythonwin/Scintilla/win32/SciLexer.vcxproj b/Pythonwin/Scintilla/win32/SciLexer.vcxproj
new file mode 100644
index 000000000..b2e993c0c
--- /dev/null
+++ b/Pythonwin/Scintilla/win32/SciLexer.vcxproj
@@ -0,0 +1,171 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{FBE04237-9C7B-4973-9C60-505975998B39}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>SciLexer</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
+      <PreprocessorDefinitions>WIN32;SCI_LEXER;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_WARNINGS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>..\include;..\src;..\lexlib;</AdditionalIncludeDirectories>
+      <BrowseInformation>true</BrowseInformation>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <MinimalRebuild>false</MinimalRebuild>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>gdi32.lib;imm32.lib;ole32.lib;oleaut32.lib;msimg32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <ClCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <ClCompile>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\lexers\*.cxx" />
+    <ClCompile Include="..\lexlib\*.cxx" />
+    <ClCompile Include="..\src\*.cxx" />
+    <ClCompile Include="..\win32\HanjaDic.cxx" />
+    <ClCompile Include="..\win32\PlatWin.cxx" />
+    <ClCompile Include="..\win32\ScintillaWin.cxx" />
+    <ClCompile Include="..\win32\ScintillaDLL.cxx" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\include\*.h" />
+    <ClInclude Include="..\src\*.h" />
+    <ClInclude Include="..\lexlib\*.h" />
+    <ClInclude Include="..\win32\*.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="..\win32\ScintRes.rc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/Pythonwin/Scintilla/win32/SciTE.properties b/Pythonwin/Scintilla/win32/SciTE.properties
new file mode 100644
index 000000000..5856b8de1
--- /dev/null
+++ b/Pythonwin/Scintilla/win32/SciTE.properties
@@ -0,0 +1,21 @@
+command.build.SConstruct=scons.bat .
+command.name.1.SConstruct=scons clean
+command.1.SConstruct=scons.bat --clean .
+
+command.build.*.mak=nmake -f $(FileNameExt) DEBUG=1 QUIET=1
+command.name.1.*.mak=nmake clean
+command.1.*.mak=nmake -f $(FileNameExt) clean
+command.name.2.*.mak=Borland Make
+command.2.*.mak=make -f $(FileNameExt)
+command.subsystem.2.*.mak=0
+command.name.3.*.mak=make clean
+command.3.*.mak=make -f $(FileNameExt) clean
+command.name.4.*.mak=make debug
+command.4.*.mak=make DEBUG=1 -f $(FileNameExt)
+command.name.5.*.mak=nmake debug
+command.5.*.mak=nmake DEBUG=1 -f $(FileNameExt)
+# SciTE.properties is the per directory local options file and can be used to override
+# settings made in SciTEGlobal.properties
+command.build.*.cxx=nmake -f scintilla.mak DEBUG=1 QUIET=1
+command.build.*.h=nmake -f scintilla.mak DEBUG=1 QUIET=1
+command.build.*.rc=nmake -f scintilla.mak DEBUG=1 QUIET=1
diff --git a/Pythonwin/Scintilla/win32/ScintRes.rc b/Pythonwin/Scintilla/win32/ScintRes.rc
index 9d773e595..71b1b9960 100644
--- a/Pythonwin/Scintilla/win32/ScintRes.rc
+++ b/Pythonwin/Scintilla/win32/ScintRes.rc
@@ -1,16 +1,15 @@
 // Resource file for Scintilla
-// Copyright 1998-2007 by Neil Hodgson <neilh@scintilla.org>
+// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#ifndef __BORLANDC__
 #include <windows.h>
-#endif
 
-#include "PlatformRes.h"
+#define VERSION_SCINTILLA "4.4.6"
+#define VERSION_WORDS 4, 4, 6, 0
 
 VS_VERSION_INFO VERSIONINFO
-FILEVERSION	1, 7, 7, 0
-PRODUCTVERSION	1, 7, 7, 0
+FILEVERSION	VERSION_WORDS
+PRODUCTVERSION	VERSION_WORDS
 FILEFLAGSMASK	0x3fL
 FILEFLAGS 0
 FILEOS VOS_NT_WINDOWS32
@@ -27,14 +26,12 @@ BEGIN
 		BEGIN
 			VALUE	"CompanyName",	"Neil Hodgson neilh@scintilla.org\0"
 			VALUE	"FileDescription",	"Scintilla.DLL - a Source Editing Component\0"
-			VALUE	"FileVersion",	"1.77\0"
+			VALUE	"FileVersion",	VERSION_SCINTILLA "\0"
 			VALUE	"InternalName",	"Scintilla\0"
-			VALUE	"LegalCopyright",	"Copyright 1998-2008 by Neil Hodgson\0"
+			VALUE	"LegalCopyright",	"Copyright 1998-2012 by Neil Hodgson\0"
 			VALUE	"OriginalFilename",	"Scintilla.DLL\0"
 			VALUE	"ProductName",	"Scintilla\0"
-			VALUE	"ProductVersion",	"1.77\0"
+			VALUE	"ProductVersion",	VERSION_SCINTILLA "\0"
 		END
 	END
 END
-
-IDC_MARGIN         CURSOR  DISCARDABLE     "Margin.cur"
diff --git a/Pythonwin/Scintilla/win32/Scintilla.vcxproj b/Pythonwin/Scintilla/win32/Scintilla.vcxproj
new file mode 100644
index 000000000..a41075fda
--- /dev/null
+++ b/Pythonwin/Scintilla/win32/Scintilla.vcxproj
@@ -0,0 +1,182 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{19CCA8B8-46B9-4609-B7CE-198DA19F07BD}</ProjectGuid>
+    <Keyword>Win32Proj</Keyword>
+    <RootNamespace>Scintilla</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup>
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v141</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
+    <UseDebugLibraries>true</UseDebugLibraries>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <IntDir>Intermediates\$(Platform)\$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <IntDir>Intermediates\$(Platform)\$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <IntDir>Intermediates\$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <IntDir>Intermediates\$(Configuration)\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <WarningLevel>Level4</WarningLevel>
+      <PreprocessorDefinitions>SCI_EMPTYCATALOGUE;SCI_LEXER;_CRT_SECURE_NO_DEPRECATE;_SCL_SECURE_NO_WARNINGS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>..\include;..\src;..\lexlib;</AdditionalIncludeDirectories>
+      <BrowseInformation>true</BrowseInformation>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <MinimalRebuild>false</MinimalRebuild>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <SubSystem>Windows</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>gdi32.lib;imm32.lib;ole32.lib;oleaut32.lib;msimg32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <ClCompile>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <ClCompile>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\lexlib\*.cxx" />
+    <ClCompile Include="..\src\*.cxx" />
+    <ClCompile Include="..\win32\HanjaDic.cxx" />
+    <ClCompile Include="..\win32\PlatWin.cxx" />
+    <ClCompile Include="..\win32\ScintillaWin.cxx" />
+    <ClCompile Include="..\win32\ScintillaDLL.cxx" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\include\*.h" />
+    <ClInclude Include="..\src\*.h" />
+    <ClInclude Include="..\lexlib\*.h" />
+    <ClInclude Include="..\win32\*.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="..\win32\ScintRes.rc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/Pythonwin/Scintilla/win32/ScintillaDLL.cxx b/Pythonwin/Scintilla/win32/ScintillaDLL.cxx
new file mode 100644
index 000000000..1ecf1c16e
--- /dev/null
+++ b/Pythonwin/Scintilla/win32/ScintillaDLL.cxx
@@ -0,0 +1,35 @@
+// Scintilla source code edit control
+/** @file ScintillaDLL.cxx
+ ** DLL entry point for Scintilla.
+ **/
+// Copyright 1998-2018 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0500
+#undef WINVER
+#define WINVER 0x0500
+#include <windows.h>
+
+#include "Scintilla.h"
+#include "ScintillaWin.h"
+
+extern "C"
+__declspec(dllexport)
+sptr_t __stdcall Scintilla_DirectFunction(
+    ScintillaWin *sci, UINT iMessage, uptr_t wParam, sptr_t lParam) {
+	return Scintilla::DirectFunction(sci, iMessage, wParam, lParam);
+}
+
+extern "C" int APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpvReserved) {
+	//Platform::DebugPrintf("Scintilla::DllMain %d %d\n", hInstance, dwReason);
+	if (dwReason == DLL_PROCESS_ATTACH) {
+		if (!Scintilla_RegisterClasses(hInstance))
+			return FALSE;
+	} else if (dwReason == DLL_PROCESS_DETACH) {
+		if (lpvReserved == NULL) {
+			Scintilla::ResourcesRelease(true);
+		}
+	}
+	return TRUE;
+}
diff --git a/Pythonwin/Scintilla/win32/ScintillaWin.cxx b/Pythonwin/Scintilla/win32/ScintillaWin.cxx
index b4c5a825f..ef219ddce 100644
--- a/Pythonwin/Scintilla/win32/ScintillaWin.cxx
+++ b/Pythonwin/Scintilla/win32/ScintillaWin.cxx
@@ -5,29 +5,58 @@
 // Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
 // The License.txt file describes the conditions under which this software may be distributed.
 
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <assert.h>
-#include <limits.h>
-
-#define _WIN32_WINNT  0x0500
+#include <cstddef>
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+#include <cstdio>
+#include <cmath>
+#include <climits>
+
+#include <stdexcept>
+#include <new>
+#include <string>
+#include <string_view>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <memory>
+#include <chrono>
+#include <mutex>
+
+// Want to use std::min and std::max so don't want Windows.h version of min and max
+#if !defined(NOMINMAX)
+#define NOMINMAX
+#endif
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0500
+#undef WINVER
+#define WINVER 0x0500
 #include <windows.h>
 #include <commctrl.h>
 #include <richedit.h>
 #include <windowsx.h>
+#include <zmouse.h>
+#include <ole2.h>
+
+#if !defined(DISABLE_D2D)
+#define USE_D2D 1
+#endif
+
+#if defined(USE_D2D)
+#include <d2d1.h>
+#include <dwrite.h>
+#endif
 
 #include "Platform.h"
 
+#include "ILoader.h"
+#include "ILexer.h"
 #include "Scintilla.h"
-#include "SString.h"
-#ifdef SCI_LEXER
-#include "SciLexer.h"
-#include "PropSet.h"
-#include "Accessor.h"
-#include "KeyWords.h"
-#endif
+
+#include "CharacterCategory.h"
+#include "Position.h"
+#include "UniqueString.h"
 #include "SplitVector.h"
 #include "Partitioning.h"
 #include "RunStyles.h"
@@ -36,22 +65,29 @@
 #include "CallTip.h"
 #include "KeyMap.h"
 #include "Indicator.h"
-#include "XPM.h"
 #include "LineMarker.h"
 #include "Style.h"
-#include "AutoComplete.h"
 #include "ViewStyle.h"
 #include "CharClassify.h"
 #include "Decoration.h"
+#include "CaseFolder.h"
 #include "Document.h"
+#include "CaseConvert.h"
+#include "UniConversion.h"
+#include "Selection.h"
 #include "PositionCache.h"
+#include "EditModel.h"
+#include "MarginView.h"
+#include "EditView.h"
 #include "Editor.h"
+#include "ElapsedPeriod.h"
+
+#include "AutoComplete.h"
 #include "ScintillaBase.h"
-#include "UniConversion.h"
 
-#ifdef SCI_LEXER
-#include "ExternalLexer.h"
-#endif
+#include "PlatWin.h"
+#include "HanjaDic.h"
+#include "ScintillaWin.h"
 
 #ifndef SPI_GETWHEELSCROLLLINES
 #define SPI_GETWHEELSCROLLLINES   104
@@ -61,107 +97,241 @@
 #define WM_UNICHAR                      0x0109
 #endif
 
+#ifndef WM_DPICHANGED
+#define WM_DPICHANGED 0x02E0
+#endif
+#ifndef WM_DPICHANGED_AFTERPARENT
+#define WM_DPICHANGED_AFTERPARENT 0x02E3
+#endif
+
 #ifndef UNICODE_NOCHAR
 #define UNICODE_NOCHAR                  0xFFFF
 #endif
 
-#ifndef WM_IME_STARTCOMPOSITION
-#include <imm.h>
+#ifndef IS_HIGH_SURROGATE
+#define IS_HIGH_SURROGATE(x)            ((x) >= SURROGATE_LEAD_FIRST && (x) <= SURROGATE_LEAD_LAST)
 #endif
 
-#include <commctrl.h>
-#ifndef __BORLANDC__
-#ifndef __DMC__
-#include <zmouse.h>
+#ifndef IS_LOW_SURROGATE
+#define IS_LOW_SURROGATE(x)             ((x) >= SURROGATE_TRAIL_FIRST && (x) <= SURROGATE_TRAIL_LAST)
 #endif
-#endif
-#include <ole2.h>
 
 #ifndef MK_ALT
 #define MK_ALT 32
 #endif
 
-#define SC_WIN_IDLE 5001
-
-// Functions imported from PlatWin
-extern bool IsNT();
-extern void Platform_Initialise(void *hInstance);
-extern void Platform_Finalise();
+// Two idle messages SC_WIN_IDLE and SC_WORK_IDLE.
+
+// SC_WIN_IDLE is low priority so should occur after the next WM_PAINT
+// It is for lengthy actions like wrapping and background styling
+constexpr UINT SC_WIN_IDLE = 5001;
+// SC_WORK_IDLE is high priority and should occur before the next WM_PAINT
+// It is for shorter actions like restyling the text just inserted
+// and delivering SCN_UPDATEUI
+constexpr UINT SC_WORK_IDLE = 5002;
+
+#define SC_INDICATOR_INPUT INDICATOR_IME
+#define SC_INDICATOR_TARGET INDICATOR_IME+1
+#define SC_INDICATOR_CONVERTED INDICATOR_IME+2
+#define SC_INDICATOR_UNKNOWN INDICATOR_IME_MAX
+
+#ifndef SCS_CAP_SETRECONVERTSTRING
+#define SCS_CAP_SETRECONVERTSTRING 0x00000004
+#define SCS_QUERYRECONVERTSTRING 0x00020000
+#define SCS_SETRECONVERTSTRING 0x00010000
+#endif
 
-/** TOTAL_CONTROL ifdef surrounds code that will only work when ScintillaWin
- * is derived from ScintillaBase (all features) rather than directly from Editor
- * (lightweight editor).
- */
-#define TOTAL_CONTROL
+typedef UINT_PTR (WINAPI *SetCoalescableTimerSig)(HWND hwnd, UINT_PTR nIDEvent,
+	UINT uElapse, TIMERPROC lpTimerFunc, ULONG uToleranceDelay);
 
 // GCC has trouble with the standard COM ABI so do it the old C way with explicit vtables.
 
-const TCHAR scintillaClassName[] = TEXT("Scintilla");
+using namespace Scintilla;
+
+namespace {
+
 const TCHAR callClassName[] = TEXT("CallTip");
 
-#ifdef SCI_NAMESPACE
-using namespace Scintilla;
-#endif
+void SetWindowID(HWND hWnd, int identifier) noexcept {
+	::SetWindowLongPtr(hWnd, GWLP_ID, identifier);
+}
+
+Point PointFromLParam(sptr_t lpoint) noexcept {
+	return Point::FromInts(GET_X_LPARAM(lpoint), GET_Y_LPARAM(lpoint));
+}
+
+bool KeyboardIsKeyDown(int key) noexcept {
+	return (::GetKeyState(key) & 0x80000000) != 0;
+}
+
+constexpr bool KeyboardIsNumericKeypadFunction(uptr_t wParam, sptr_t lParam) {
+	// Bit 24 is the extended keyboard flag and the numeric keypad is non-extended
+	if ((lParam & (1 << 24)) != 0) {
+		// Not from the numeric keypad
+		return false;
+	}
+
+	switch (wParam) {
+	case VK_INSERT:	// 0
+	case VK_END:	// 1
+	case VK_DOWN:	// 2
+	case VK_NEXT:	// 3
+	case VK_LEFT:	// 4
+	case VK_CLEAR:	// 5
+	case VK_RIGHT:	// 6
+	case VK_HOME:	// 7
+	case VK_UP:		// 8
+	case VK_PRIOR:	// 9
+		return true;
+	default:
+		return false;
+	}
+}
+
+}
 
 class ScintillaWin; 	// Forward declaration for COM interface subobjects
 
+typedef void VFunction(void);
+
+
 /**
  */
 class FormatEnumerator {
 public:
-	void **vtbl;
-	int ref;
-	int pos;
-	CLIPFORMAT formats[2];
-	int formatsLen;
-	FormatEnumerator(int pos_, CLIPFORMAT formats_[], int formatsLen_);
+	VFunction **vtbl;
+	ULONG ref;
+	ULONG pos;
+	std::vector<CLIPFORMAT> formats;
+	FormatEnumerator(ULONG pos_, const CLIPFORMAT formats_[], size_t formatsLen_);
 };
 
 /**
  */
 class DropSource {
 public:
-	void **vtbl;
+	VFunction **vtbl;
 	ScintillaWin *sci;
-	DropSource();
+	DropSource() noexcept;
 };
 
 /**
  */
 class DataObject {
 public:
-	void **vtbl;
+	VFunction **vtbl;
 	ScintillaWin *sci;
-	DataObject();
+	DataObject() noexcept;
 };
 
 /**
  */
 class DropTarget {
 public:
-	void **vtbl;
+	VFunction **vtbl;
 	ScintillaWin *sci;
-	DropTarget();
+	DropTarget() noexcept;
+};
+
+namespace {
+
+class IMContext {
+	HWND hwnd;
+public:
+	HIMC hIMC;
+	IMContext(HWND hwnd_) noexcept :
+		hwnd(hwnd_), hIMC(::ImmGetContext(hwnd_)) {
+	}
+	// Deleted so IMContext objects can not be copied.
+	IMContext(const IMContext &) = delete;
+	IMContext(IMContext &&) = delete;
+	IMContext &operator=(const IMContext &) = delete;
+	IMContext &operator=(IMContext &&) = delete;
+	~IMContext() {
+		if (hIMC)
+			::ImmReleaseContext(hwnd, hIMC);
+	}
+
+	unsigned int GetImeCaretPos() const noexcept {
+		return ImmGetCompositionStringW(hIMC, GCS_CURSORPOS, nullptr, 0);
+	}
+
+	std::vector<BYTE> GetImeAttributes() {
+		const int attrLen = ::ImmGetCompositionStringW(hIMC, GCS_COMPATTR, nullptr, 0);
+		std::vector<BYTE> attr(attrLen, 0);
+		::ImmGetCompositionStringW(hIMC, GCS_COMPATTR, &attr[0], static_cast<DWORD>(attr.size()));
+		return attr;
+	}
+
+	std::wstring GetCompositionString(DWORD dwIndex) {
+		const LONG byteLen = ::ImmGetCompositionStringW(hIMC, dwIndex, nullptr, 0);
+		std::wstring wcs(byteLen / 2, 0);
+		::ImmGetCompositionStringW(hIMC, dwIndex, &wcs[0], byteLen);
+		return wcs;
+	}
+};
+
+class GlobalMemory;
+
+class ReverseArrowCursor {
+	UINT dpi = USER_DEFAULT_SCREEN_DPI;
+	HCURSOR cursor {};
+
+public:
+	ReverseArrowCursor() noexcept {}
+	// Deleted so ReverseArrowCursor objects can not be copied.
+	ReverseArrowCursor(const ReverseArrowCursor &) = delete;
+	ReverseArrowCursor(ReverseArrowCursor &&) = delete;
+	ReverseArrowCursor &operator=(const ReverseArrowCursor &) = delete;
+	ReverseArrowCursor &operator=(ReverseArrowCursor &&) = delete;
+	~ReverseArrowCursor() {
+		if (cursor) {
+			::DestroyCursor(cursor);
+		}
+	}
+
+	HCURSOR Load(UINT dpi_) noexcept {
+		if (cursor)	 {
+			if (dpi == dpi_) {
+				return cursor;
+			}
+			::DestroyCursor(cursor);
+		}
+
+		dpi = dpi_;
+		cursor = LoadReverseArrowCursor(dpi_);
+		return cursor ? cursor : ::LoadCursor({}, IDC_ARROW);
+	}
 };
 
+}
+
 /**
  */
 class ScintillaWin :
 	public ScintillaBase {
 
 	bool lastKeyDownConsumed;
+	wchar_t lastHighSurrogateChar;
 
 	bool capturedMouse;
+	bool trackedMouseLeave;
+	SetCoalescableTimerSig SetCoalescableTimerFn;
 
 	unsigned int linesPerScroll;	///< Intellimouse support
 	int wheelDelta; ///< Wheel delta from roll
 
+	UINT dpi = USER_DEFAULT_SCREEN_DPI;
+	ReverseArrowCursor reverseArrowCursor;
+
 	HRGN hRgnUpdate;
 
 	bool hasOKText;
 
 	CLIPFORMAT cfColumnSelect;
+	CLIPFORMAT cfBorlandIDEBlockType;
 	CLIPFORMAT cfLineSelect;
+	CLIPFORMAT cfVSLineTag;
 
 	HRESULT hrOle;
 	DropSource ds;
@@ -169,79 +339,132 @@ class ScintillaWin :
 	DropTarget dt;
 
 	static HINSTANCE hInstance;
+	static ATOM scintillaClassAtom;
+	static ATOM callClassAtom;
 
-	ScintillaWin(HWND hwnd);
-	ScintillaWin(const ScintillaWin &) : ScintillaBase() {}
-	virtual ~ScintillaWin();
-	ScintillaWin &operator=(const ScintillaWin &) { return *this; }
+#if defined(USE_D2D)
+	ID2D1RenderTarget *pRenderTarget;
+	bool renderTargetValid;
+#endif
 
-	virtual void Initialise();
-	virtual void Finalise();
-	HWND MainHWND();
+	explicit ScintillaWin(HWND hwnd);
+	// Deleted so ScintillaWin objects can not be copied.
+	ScintillaWin(const ScintillaWin &) = delete;
+	ScintillaWin(ScintillaWin &&) = delete;
+	ScintillaWin &operator=(const ScintillaWin &) = delete;
+	ScintillaWin &operator=(ScintillaWin &&) = delete;
+	// ~ScintillaWin() in public section
+
+	void Init();
+	void Finalise() override;
+#if defined(USE_D2D)
+	void EnsureRenderTarget(HDC hdc);
+	void DropRenderTarget();
+#endif
+	HWND MainHWND() const noexcept;
 
 	static sptr_t DirectFunction(
-		    ScintillaWin *sci, UINT iMessage, uptr_t wParam, sptr_t lParam);
-	static sptr_t PASCAL SWndProc(
-		    HWND hWnd, UINT iMessage, WPARAM wParam, sptr_t lParam);
-	static sptr_t PASCAL CTWndProc(
-		    HWND hWnd, UINT iMessage, WPARAM wParam, sptr_t lParam);
-
-	enum { invalidTimerID, standardTimerID, idleTimerID };
-
-	virtual bool DragThreshold(Point ptStart, Point ptNow);
-	virtual void StartDrag();
-	sptr_t WndPaint(uptr_t wParam);
-	sptr_t HandleComposition(uptr_t wParam, sptr_t lParam);
-	virtual bool ValidCodePage(int codePage) const;
-	virtual sptr_t DefWndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
-	virtual bool SetIdle(bool on);
-	virtual void SetTicking(bool on);
-	virtual void SetMouseCapture(bool on);
-	virtual bool HaveMouseCapture();
-	virtual bool PaintContains(PRectangle rc);
-	virtual void ScrollText(int linesToMove);
-	virtual void UpdateSystemCaret();
-	virtual void SetVerticalScrollPos();
-	virtual void SetHorizontalScrollPos();
-	virtual bool ModifyScrollBars(int nMax, int nPage);
-	virtual void NotifyChange();
-	virtual void NotifyFocus(bool focus);
-	virtual int GetCtrlID();
-	virtual void NotifyParent(SCNotification scn);
-	virtual void NotifyDoubleClick(Point pt, bool shift, bool ctrl, bool alt);
-	virtual void Copy();
-	virtual void CopyAllowLine();
-	virtual bool CanPaste();
-	virtual void Paste();
-	virtual void CreateCallTipWindow(PRectangle rc);
-	virtual void AddToPopUp(const char *label, int cmd = 0, bool enabled = true);
-	virtual void ClaimSelection();
+		    sptr_t ptr, UINT iMessage, uptr_t wParam, sptr_t lParam);
+	static LRESULT PASCAL SWndProc(
+		    HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
+	static LRESULT PASCAL CTWndProc(
+		    HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam);
+
+	enum : UINT_PTR { invalidTimerID, standardTimerID, idleTimerID, fineTimerStart };
+
+	void DisplayCursor(Window::Cursor c) override;
+	bool DragThreshold(Point ptStart, Point ptNow) override;
+	void StartDrag() override;
+	static int MouseModifiers(uptr_t wParam) noexcept;
+
+	Sci::Position TargetAsUTF8(char *text) const;
+	Sci::Position EncodedFromUTF8(const char *utf8, char *encoded) const;
+
+	bool PaintDC(HDC hdc);
+	sptr_t WndPaint();
 
 	// DBCS
 	void ImeStartComposition();
 	void ImeEndComposition();
-
-	void AddCharBytes(char b0, char b1);
-
-	void GetIntelliMouseParameters();
-	virtual void CopyToClipboard(const SelectionText &selectedText);
+	LRESULT ImeOnReconvert(LPARAM lParam);
+	sptr_t HandleCompositionWindowed(uptr_t wParam, sptr_t lParam);
+	sptr_t HandleCompositionInline(uptr_t wParam, sptr_t lParam);
+	static bool KoreanIME() noexcept;
+	void MoveImeCarets(Sci::Position offset);
+	void DrawImeIndicator(int indicator, Sci::Position len);
+	void SetCandidateWindowPos();
+	void SelectionToHangul();
+	void EscapeHanja();
+	void ToggleHanja();
+	void AddWString(std::wstring_view wsv, CharacterSource charSource);
+
+	UINT CodePageOfDocument() const noexcept;
+	bool ValidCodePage(int codePage) const override;
+	std::string EncodeWString(std::wstring_view wsv);
+	sptr_t DefWndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) override;
+	void IdleWork() override;
+	void QueueIdleWork(WorkNeeded::workItems items, Sci::Position upTo) override;
+	bool SetIdle(bool on) override;
+	UINT_PTR timers[tickDwell+1] {};
+	bool FineTickerRunning(TickReason reason) override;
+	void FineTickerStart(TickReason reason, int millis, int tolerance) override;
+	void FineTickerCancel(TickReason reason) override;
+	void SetMouseCapture(bool on) override;
+	bool HaveMouseCapture() override;
+	void SetTrackMouseLeaveEvent(bool on) noexcept;
+	bool PaintContains(PRectangle rc) override;
+	void ScrollText(Sci::Line linesToMove) override;
+	void NotifyCaretMove() override;
+	void UpdateSystemCaret() override;
+	void SetVerticalScrollPos() override;
+	void SetHorizontalScrollPos() override;
+	bool ModifyScrollBars(Sci::Line nMax, Sci::Line nPage) override;
+	void NotifyChange() override;
+	void NotifyFocus(bool focus) override;
+	void SetCtrlID(int identifier) override;
+	int GetCtrlID() override;
+	void NotifyParent(SCNotification scn) override;
+	void NotifyDoubleClick(Point pt, int modifiers) override;
+	CaseFolder *CaseFolderForEncoding() override;
+	std::string CaseMapString(const std::string &s, int caseMapping) override;
+	void Copy() override;
+	bool CanPaste() override;
+	void Paste() override;
+	void CreateCallTipWindow(PRectangle rc) override;
+	void AddToPopUp(const char *label, int cmd = 0, bool enabled = true) override;
+	void ClaimSelection() override;
+
+	void GetIntelliMouseParameters() noexcept;
+	void CopyToGlobal(GlobalMemory &gmUnicode, const SelectionText &selectedText);
+	void CopyToClipboard(const SelectionText &selectedText) override;
 	void ScrollMessage(WPARAM wParam);
 	void HorizontalScrollMessage(WPARAM wParam);
-	void RealizeWindowPalette(bool inBackGround);
 	void FullPaint();
-	void FullPaintDC(HDC dc);
-	bool IsCompatibleDC(HDC dc);
-	DWORD EffectFromState(DWORD grfKeyState);
-
-	virtual int SetScrollInfo(int nBar, LPCSCROLLINFO lpsi, BOOL bRedraw);
-	virtual bool GetScrollInfo(int nBar, LPSCROLLINFO lpsi);
-	void ChangeScrollPos(int barType, int pos);
-
-	void InsertPasteText(const char *text, int len, int selStart, bool isRectangular, bool isLine);
+	void FullPaintDC(HDC hdc);
+	bool IsCompatibleDC(HDC hOtherDC) noexcept;
+	DWORD EffectFromState(DWORD grfKeyState) const noexcept;
+
+	int SetScrollInfo(int nBar, LPCSCROLLINFO lpsi, BOOL bRedraw) noexcept;
+	bool GetScrollInfo(int nBar, LPSCROLLINFO lpsi) noexcept;
+	void ChangeScrollPos(int barType, Sci::Position pos);
+	sptr_t GetTextLength();
+	sptr_t GetText(uptr_t wParam, sptr_t lParam);
+	Window::Cursor ContextCursor(Point pt);
+	sptr_t ShowContextMenu(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+	void SizeWindow();
+	sptr_t MouseMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+	sptr_t KeyMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+	sptr_t FocusMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+	sptr_t IMEMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+	sptr_t EditMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+	sptr_t IdleMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+	sptr_t SciMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
 
 public:
+	~ScintillaWin() override;
+
 	// Public for benefit of Scintilla_DirectFunction
-	virtual sptr_t WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+	sptr_t WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) override;
 
 	/// Implement IUnknown
 	STDMETHODIMP QueryInterface(REFIID riid, PVOID *ppv);
@@ -259,56 +482,62 @@ class ScintillaWin :
 	/// Implement important part of IDataObject
 	STDMETHODIMP GetData(FORMATETC *pFEIn, STGMEDIUM *pSTM);
 
-	// External Lexers
-#ifdef SCI_LEXER
-	void SetLexerLanguage(const char *languageName);
-	void SetLexer(uptr_t wParam);
-#endif
-
-	static bool Register(HINSTANCE hInstance_);
-	static bool Unregister();
+	static void Prepare() noexcept;
+	static bool Register(HINSTANCE hInstance_) noexcept;
+	static bool Unregister() noexcept;
 
 	friend class DropSource;
 	friend class DataObject;
 	friend class DropTarget;
-	bool DragIsRectangularOK(CLIPFORMAT fmt) {
+	bool DragIsRectangularOK(CLIPFORMAT fmt) const noexcept {
 		return drag.rectangular && (fmt == cfColumnSelect);
 	}
 
 private:
 	// For use in creating a system caret
-	bool HasCaretSizeChanged();
+	bool HasCaretSizeChanged() const noexcept;
 	BOOL CreateSystemCaret();
-	BOOL DestroySystemCaret();
+	BOOL DestroySystemCaret() noexcept;
 	HBITMAP sysCaretBitmap;
 	int sysCaretWidth;
 	int sysCaretHeight;
-	bool keysAlwaysUnicode;
+	bool styleIdleInQueue;
 };
 
-HINSTANCE ScintillaWin::hInstance = 0;
+HINSTANCE ScintillaWin::hInstance {};
+ATOM ScintillaWin::scintillaClassAtom = 0;
+ATOM ScintillaWin::callClassAtom = 0;
 
 ScintillaWin::ScintillaWin(HWND hwnd) {
 
 	lastKeyDownConsumed = false;
+	lastHighSurrogateChar = 0;
 
 	capturedMouse = false;
+	trackedMouseLeave = false;
+	SetCoalescableTimerFn = nullptr;
+
 	linesPerScroll = 0;
 	wheelDelta = 0;   // Wheel delta from roll
 
-	hRgnUpdate = 0;
+	dpi = DpiForWindow(hwnd);
+
+	hRgnUpdate = {};
 
 	hasOKText = false;
 
 	// There does not seem to be a real standard for indicating that the clipboard
-	// contains a rectangular selection, so copy Developer Studio.
+	// contains a rectangular selection, so copy Developer Studio and Borland Delphi.
 	cfColumnSelect = static_cast<CLIPFORMAT>(
 		::RegisterClipboardFormat(TEXT("MSDEVColumnSelect")));
+	cfBorlandIDEBlockType = static_cast<CLIPFORMAT>(
+		::RegisterClipboardFormat(TEXT("Borland IDE Block Type")));
 
 	// Likewise for line-copy (copies a full line when no text is selected)
 	cfLineSelect = static_cast<CLIPFORMAT>(
 		::RegisterClipboardFormat(TEXT("MSDEVLineSelect")));
-
+	cfVSLineTag = static_cast<CLIPFORMAT>(
+		::RegisterClipboardFormat(TEXT("VisualStudioEditorOperationsLineCutCopyClipboardTag")));
 	hrOle = E_FAIL;
 
 	wMain = hwnd;
@@ -317,44 +546,164 @@ ScintillaWin::ScintillaWin(HWND hwnd) {
 	ds.sci = this;
 	dt.sci = this;
 
-	sysCaretBitmap = 0;
+	sysCaretBitmap = {};
 	sysCaretWidth = 0;
 	sysCaretHeight = 0;
 
-	keysAlwaysUnicode = false;
+	styleIdleInQueue = false;
+
+#if defined(USE_D2D)
+	pRenderTarget = nullptr;
+	renderTargetValid = true;
+#endif
+
+	caret.period = ::GetCaretBlinkTime();
+	if (caret.period < 0)
+		caret.period = 0;
 
-	Initialise();
+	Init();
 }
 
 ScintillaWin::~ScintillaWin() {}
 
-void ScintillaWin::Initialise() {
+void ScintillaWin::Init() {
 	// Initialize COM.  If the app has already done this it will have
-	// no effect.  If the app hasnt, we really shouldnt ask them to call
+	// no effect.  If the app hasn't, we really shouldn't ask them to call
 	// it just so this internal feature works.
-	hrOle = ::OleInitialize(NULL);
+	hrOle = ::OleInitialize(nullptr);
+
+	// Find SetCoalescableTimer which is only available from Windows 8+
+	HMODULE user32 = ::GetModuleHandleW(L"user32.dll");
+	SetCoalescableTimerFn = DLLFunction<SetCoalescableTimerSig>(user32, "SetCoalescableTimer");
+
+	vs.indicators[SC_INDICATOR_UNKNOWN] = Indicator(INDIC_HIDDEN, ColourDesired(0, 0, 0xff));
+	vs.indicators[SC_INDICATOR_INPUT] = Indicator(INDIC_DOTS, ColourDesired(0, 0, 0xff));
+	vs.indicators[SC_INDICATOR_CONVERTED] = Indicator(INDIC_COMPOSITIONTHICK, ColourDesired(0, 0, 0xff));
+	vs.indicators[SC_INDICATOR_TARGET] = Indicator(INDIC_STRAIGHTBOX, ColourDesired(0, 0, 0xff));
 }
 
 void ScintillaWin::Finalise() {
 	ScintillaBase::Finalise();
-	SetTicking(false);
+	for (TickReason tr = tickCaret; tr <= tickDwell; tr = static_cast<TickReason>(tr + 1)) {
+		FineTickerCancel(tr);
+	}
 	SetIdle(false);
-	DestroySystemCaret();
+#if defined(USE_D2D)
+	DropRenderTarget();
+#endif
 	::RevokeDragDrop(MainHWND());
 	if (SUCCEEDED(hrOle)) {
 		::OleUninitialize();
 	}
 }
 
-HWND ScintillaWin::MainHWND() {
-	return reinterpret_cast<HWND>(wMain.GetID());
+#if defined(USE_D2D)
+
+void ScintillaWin::EnsureRenderTarget(HDC hdc) {
+	if (!renderTargetValid) {
+		DropRenderTarget();
+		renderTargetValid = true;
+	}
+	if (pD2DFactory && !pRenderTarget) {
+		HWND hw = MainHWND();
+		RECT rc;
+		GetClientRect(hw, &rc);
+
+		const D2D1_SIZE_U size = D2D1::SizeU(rc.right - rc.left, rc.bottom - rc.top);
+
+		// Create a Direct2D render target.
+#if 1
+		D2D1_RENDER_TARGET_PROPERTIES drtp;
+		drtp.type = D2D1_RENDER_TARGET_TYPE_DEFAULT;
+		drtp.pixelFormat.format = DXGI_FORMAT_UNKNOWN;
+		drtp.pixelFormat.alphaMode = D2D1_ALPHA_MODE_UNKNOWN;
+		drtp.dpiX = 96.0;
+		drtp.dpiY = 96.0;
+		drtp.usage = D2D1_RENDER_TARGET_USAGE_NONE;
+		drtp.minLevel = D2D1_FEATURE_LEVEL_DEFAULT;
+
+		if (technology == SC_TECHNOLOGY_DIRECTWRITEDC) {
+			// Explicit pixel format needed.
+			drtp.pixelFormat = D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM,
+				D2D1_ALPHA_MODE_IGNORE);
+
+			ID2D1DCRenderTarget *pDCRT = nullptr;
+			const HRESULT hr = pD2DFactory->CreateDCRenderTarget(&drtp, &pDCRT);
+			if (SUCCEEDED(hr)) {
+				pRenderTarget = pDCRT;
+			} else {
+				Platform::DebugPrintf("Failed CreateDCRenderTarget 0x%lx\n", hr);
+				pRenderTarget = nullptr;
+			}
+
+		} else {
+			D2D1_HWND_RENDER_TARGET_PROPERTIES dhrtp;
+			dhrtp.hwnd = hw;
+			dhrtp.pixelSize = size;
+			dhrtp.presentOptions = (technology == SC_TECHNOLOGY_DIRECTWRITERETAIN) ?
+			D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS : D2D1_PRESENT_OPTIONS_NONE;
+
+			ID2D1HwndRenderTarget *pHwndRenderTarget = nullptr;
+			const HRESULT hr = pD2DFactory->CreateHwndRenderTarget(drtp, dhrtp, &pHwndRenderTarget);
+			if (SUCCEEDED(hr)) {
+				pRenderTarget = pHwndRenderTarget;
+			} else {
+				Platform::DebugPrintf("Failed CreateHwndRenderTarget 0x%lx\n", hr);
+				pRenderTarget = nullptr;
+			}
+		}
+#else
+		pD2DFactory->CreateHwndRenderTarget(
+			D2D1::RenderTargetProperties(
+				D2D1_RENDER_TARGET_TYPE_DEFAULT ,
+				D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_PREMULTIPLIED),
+				96.0f, 96.0f, D2D1_RENDER_TARGET_USAGE_NONE, D2D1_FEATURE_LEVEL_DEFAULT),
+			D2D1::HwndRenderTargetProperties(hw, size),
+			&pRenderTarget);
+#endif
+		// Pixmaps were created to be compatible with previous render target so
+		// need to be recreated.
+		DropGraphics(false);
+	}
+
+	if ((technology == SC_TECHNOLOGY_DIRECTWRITEDC) && pRenderTarget) {
+		RECT rcWindow;
+		GetClientRect(MainHWND(), &rcWindow);
+		const HRESULT hr = static_cast<ID2D1DCRenderTarget*>(pRenderTarget)->BindDC(hdc, &rcWindow);
+		if (FAILED(hr)) {
+			Platform::DebugPrintf("BindDC failed 0x%lx\n", hr);
+			DropRenderTarget();
+		}
+	}
+}
+
+void ScintillaWin::DropRenderTarget() {
+	ReleaseUnknown(pRenderTarget);
+}
+
+#endif
+
+HWND ScintillaWin::MainHWND() const noexcept {
+	return HwndFromWindow(wMain);
+}
+
+void ScintillaWin::DisplayCursor(Window::Cursor c) {
+	if (cursorMode != SC_CURSORNORMAL) {
+		c = static_cast<Window::Cursor>(cursorMode);
+	}
+	if (c == Window::cursorReverseArrow) {
+		::SetCursor(reverseArrowCursor.Load(dpi));
+	} else {
+		wMain.SetCursor(c);
+	}
 }
 
 bool ScintillaWin::DragThreshold(Point ptStart, Point ptNow) {
-	int xMove = abs(ptStart.x - ptNow.x);
-	int yMove = abs(ptStart.y - ptNow.y);
-	return (xMove > ::GetSystemMetrics(SM_CXDRAG)) ||
-		(yMove > ::GetSystemMetrics(SM_CYDRAG));
+	const Point ptDifference = ptStart - ptNow;
+	const XYPOSITION xMove = std::trunc(std::abs(ptDifference.x));
+	const XYPOSITION yMove = std::trunc(std::abs(ptDifference.y));
+	return (xMove > SystemMetricsForDpi(SM_CXDRAG, dpi)) ||
+		(yMove > SystemMetricsForDpi(SM_CYDRAG, dpi));
 }
 
 void ScintillaWin::StartDrag() {
@@ -364,7 +713,7 @@ void ScintillaWin::StartDrag() {
 	IDataObject *pDataObject = reinterpret_cast<IDataObject *>(&dob);
 	IDropSource *pDropSource = reinterpret_cast<IDropSource *>(&ds);
 	//Platform::DebugPrintf("About to DoDragDrop %x %x\n", pDataObject, pDropSource);
-	HRESULT hr = ::DoDragDrop(
+	const HRESULT hr = ::DoDragDrop(
 	                 pDataObject,
 	                 pDropSource,
 	                 DROPEFFECT_COPY | DROPEFFECT_MOVE, &dwEffect);
@@ -376,39 +725,30 @@ void ScintillaWin::StartDrag() {
 		}
 	}
 	inDragDrop = ddNone;
-	SetDragPosition(invalidPosition);
+	SetDragPosition(SelectionPosition(Sci::invalidPosition));
 }
 
-// Avoid warnings everywhere for old style casts by concentrating them here
-static WORD LoWord(DWORD l) {
-	return LOWORD(l);
+int ScintillaWin::MouseModifiers(uptr_t wParam) noexcept {
+	return ModifierFlags((wParam & MK_SHIFT) != 0,
+		(wParam & MK_CONTROL) != 0,
+		KeyboardIsKeyDown(VK_MENU));
 }
 
-static WORD HiWord(DWORD l) {
-	return HIWORD(l);
-}
+namespace {
 
-static int InputCodePage() {
+int InputCodePage() noexcept {
 	HKL inputLocale = ::GetKeyboardLayout(0);
-	LANGID inputLang = LOWORD(inputLocale);
+	const LANGID inputLang = LOWORD(inputLocale);
 	char sCodePage[10];
-	int res = ::GetLocaleInfoA(MAKELCID(inputLang, SORT_DEFAULT),
+	const int res = ::GetLocaleInfoA(MAKELCID(inputLang, SORT_DEFAULT),
 	  LOCALE_IDEFAULTANSICODEPAGE, sCodePage, sizeof(sCodePage));
 	if (!res)
 		return 0;
 	return atoi(sCodePage);
 }
 
-#ifndef VK_OEM_2
-static const int VK_OEM_2=0xbf;
-static const int VK_OEM_3=0xc0;
-static const int VK_OEM_4=0xdb;
-static const int VK_OEM_5=0xdc;
-static const int VK_OEM_6=0xdd;
-#endif
-
 /** Map the key codes to their equivalent SCK_ form. */
-static int KeyTranslate(int keyIn) {
+int KeyTranslate(int keyIn) noexcept {
 //PLATFORM_ASSERT(!keyIn);
 	switch (keyIn) {
 		case VK_DOWN:		return SCK_DOWN;
@@ -440,512 +780,912 @@ static int KeyTranslate(int keyIn) {
 	}
 }
 
-LRESULT ScintillaWin::WndPaint(uptr_t wParam) {
-	//ElapsedTime et;
+bool BoundsContains(PRectangle rcBounds, HRGN hRgnBounds, PRectangle rcCheck) noexcept {
+	bool contains = true;
+	if (!rcCheck.Empty()) {
+		if (!rcBounds.Contains(rcCheck)) {
+			contains = false;
+		} else if (hRgnBounds) {
+			// In bounding rectangle so check more accurately using region
+			const RECT rcw = RectFromPRectangle(rcCheck);
+			HRGN hRgnCheck = ::CreateRectRgnIndirect(&rcw);
+			if (hRgnCheck) {
+				HRGN hRgnDifference = ::CreateRectRgn(0, 0, 0, 0);
+				if (hRgnDifference) {
+					const int combination = ::CombineRgn(hRgnDifference, hRgnCheck, hRgnBounds, RGN_DIFF);
+					if (combination != NULLREGION) {
+						contains = false;
+					}
+					::DeleteRgn(hRgnDifference);
+				}
+				::DeleteRgn(hRgnCheck);
+			}
+		}
+	}
+	return contains;
+}
+
+// Simplify calling WideCharToMultiByte and MultiByteToWideChar by providing default parameters and using string view.
+
+int MultiByteFromWideChar(UINT codePage, std::wstring_view wsv, LPSTR lpMultiByteStr, ptrdiff_t cbMultiByte) noexcept {
+	return ::WideCharToMultiByte(codePage, 0, wsv.data(), static_cast<int>(wsv.length()), lpMultiByteStr, static_cast<int>(cbMultiByte), nullptr, nullptr);
+}
+
+int MultiByteLenFromWideChar(UINT codePage, std::wstring_view wsv) noexcept {
+	return MultiByteFromWideChar(codePage, wsv, nullptr, 0);
+}
+
+int WideCharFromMultiByte(UINT codePage, std::string_view sv, LPWSTR lpWideCharStr, ptrdiff_t cchWideChar) noexcept {
+	return ::MultiByteToWideChar(codePage, 0, sv.data(), static_cast<int>(sv.length()), lpWideCharStr, static_cast<int>(cchWideChar));
+}
+
+int WideCharLenFromMultiByte(UINT codePage, std::string_view sv) noexcept {
+	return WideCharFromMultiByte(codePage, sv, nullptr, 0);
+}
+
+std::string StringEncode(std::wstring_view wsv, int codePage) {
+	const int cchMulti = wsv.length() ? MultiByteLenFromWideChar(codePage, wsv) : 0;
+	std::string sMulti(cchMulti, 0);
+	if (cchMulti) {
+		MultiByteFromWideChar(codePage, wsv, sMulti.data(), cchMulti);
+	}
+	return sMulti;
+}
+
+std::wstring StringDecode(std::string_view sv, int codePage) {
+	const int cchWide = sv.length() ? WideCharLenFromMultiByte(codePage, sv) : 0;
+	std::wstring sWide(cchWide, 0);
+	if (cchWide) {
+		WideCharFromMultiByte(codePage, sv, sWide.data(), cchWide);
+	}
+	return sWide;
+}
+
+std::wstring StringMapCase(std::wstring_view wsv, DWORD mapFlags) {
+	const int charsConverted = ::LCMapStringW(LOCALE_SYSTEM_DEFAULT, mapFlags,
+		wsv.data(), static_cast<int>(wsv.length()), nullptr, 0);
+	std::wstring wsConverted(charsConverted, 0);
+	if (charsConverted) {
+		::LCMapStringW(LOCALE_SYSTEM_DEFAULT, mapFlags,
+			wsv.data(), static_cast<int>(wsv.length()), wsConverted.data(), charsConverted);
+	}
+	return wsConverted;
+}
+
+}
+
+// Returns the target converted to UTF8.
+// Return the length in bytes.
+Sci::Position ScintillaWin::TargetAsUTF8(char *text) const {
+	const Sci::Position targetLength = targetRange.Length();
+	if (IsUnicodeMode()) {
+		if (text) {
+			pdoc->GetCharRange(text, targetRange.start.Position(), targetLength);
+		}
+	} else {
+		// Need to convert
+		const std::string s = RangeText(targetRange.start.Position(), targetRange.end.Position());
+		const std::wstring characters = StringDecode(s, CodePageOfDocument());
+		const int utf8Len = MultiByteLenFromWideChar(CP_UTF8, characters);
+		if (text) {
+			MultiByteFromWideChar(CP_UTF8, characters, text, utf8Len);
+			text[utf8Len] = '\0';
+		}
+		return utf8Len;
+	}
+	return targetLength;
+}
+
+// Translates a nul terminated UTF8 string into the document encoding.
+// Return the length of the result in bytes.
+Sci::Position ScintillaWin::EncodedFromUTF8(const char *utf8, char *encoded) const {
+	const Sci::Position inputLength = (lengthForEncode >= 0) ? lengthForEncode : strlen(utf8);
+	if (IsUnicodeMode()) {
+		if (encoded) {
+			memcpy(encoded, utf8, inputLength);
+		}
+		return inputLength;
+	} else {
+		// Need to convert
+		const std::string_view utf8Input(utf8, inputLength);
+		const int charsLen = WideCharLenFromMultiByte(CP_UTF8, utf8Input);
+		std::wstring characters(charsLen, L'\0');
+		WideCharFromMultiByte(CP_UTF8, utf8Input, &characters[0], charsLen);
+
+		const int encodedLen = MultiByteLenFromWideChar(CodePageOfDocument(), characters);
+		if (encoded) {
+			MultiByteFromWideChar(CodePageOfDocument(), characters, encoded, encodedLen);
+			encoded[encodedLen] = '\0';
+		}
+		return encodedLen;
+	}
+}
+
+bool ScintillaWin::PaintDC(HDC hdc) {
+	if (technology == SC_TECHNOLOGY_DEFAULT) {
+		AutoSurface surfaceWindow(hdc, this);
+		if (surfaceWindow) {
+			Paint(surfaceWindow, rcPaint);
+			surfaceWindow->Release();
+		}
+	} else {
+#if defined(USE_D2D)
+		EnsureRenderTarget(hdc);
+		if (pRenderTarget) {
+			AutoSurface surfaceWindow(pRenderTarget, this);
+			if (surfaceWindow) {
+				pRenderTarget->BeginDraw();
+				Paint(surfaceWindow, rcPaint);
+				surfaceWindow->Release();
+				const HRESULT hr = pRenderTarget->EndDraw();
+				if (hr == static_cast<HRESULT>(D2DERR_RECREATE_TARGET)) {
+					DropRenderTarget();
+					return false;
+				}
+			}
+		}
+#endif
+	}
+
+	return true;
+}
+
+sptr_t ScintillaWin::WndPaint() {
+	//ElapsedPeriod ep;
 
 	// Redirect assertions to debug output and save current state
-	bool assertsPopup = Platform::ShowAssertionPopUps(false);
+	const bool assertsPopup = Platform::ShowAssertionPopUps(false);
 	paintState = painting;
-	PAINTSTRUCT ps;
-	PAINTSTRUCT *pps;
+	PAINTSTRUCT ps = {};
 
-	bool IsOcxCtrl = (wParam != 0); // if wParam != 0, it contains
-								   // a PAINSTRUCT* from the OCX
 	// Removed since this interferes with reporting other assertions as it occurs repeatedly
 	//PLATFORM_ASSERT(hRgnUpdate == NULL);
 	hRgnUpdate = ::CreateRectRgn(0, 0, 0, 0);
-	if (IsOcxCtrl) {
-		pps = reinterpret_cast<PAINTSTRUCT*>(wParam);
-	} else {
-		::GetUpdateRgn(MainHWND(), hRgnUpdate, FALSE);
-		pps = &ps;
-		::BeginPaint(MainHWND(), pps);
-	}
-	AutoSurface surfaceWindow(pps->hdc, this);
-	if (surfaceWindow) {
-		rcPaint = PRectangle(pps->rcPaint.left, pps->rcPaint.top, pps->rcPaint.right, pps->rcPaint.bottom);
-		PRectangle rcClient = GetClientRectangle();
-		paintingAllText = rcPaint.Contains(rcClient);
-		if (paintingAllText) {
-			//Platform::DebugPrintf("Performing full text paint\n");
-		} else {
-			//Platform::DebugPrintf("Performing partial paint %d .. %d\n", rcPaint.top, rcPaint.bottom);
-		}
-		Paint(surfaceWindow, rcPaint);
-		surfaceWindow->Release();
+	::GetUpdateRgn(MainHWND(), hRgnUpdate, FALSE);
+	::BeginPaint(MainHWND(), &ps);
+	rcPaint = PRectangle::FromInts(ps.rcPaint.left, ps.rcPaint.top, ps.rcPaint.right, ps.rcPaint.bottom);
+	const PRectangle rcClient = GetClientRectangle();
+	paintingAllText = BoundsContains(rcPaint, hRgnUpdate, rcClient);
+	if (!PaintDC(ps.hdc)) {
+		paintState = paintAbandoned;
 	}
 	if (hRgnUpdate) {
 		::DeleteRgn(hRgnUpdate);
-		hRgnUpdate = 0;
+		hRgnUpdate = {};
 	}
 
-	if(!IsOcxCtrl)
-		::EndPaint(MainHWND(), pps);
+	::EndPaint(MainHWND(), &ps);
 	if (paintState == paintAbandoned) {
 		// Painting area was insufficient to cover new styling or brace highlight positions
 		FullPaint();
+		::ValidateRect(MainHWND(), nullptr);
 	}
 	paintState = notPainting;
 
 	// Restore debug output state
 	Platform::ShowAssertionPopUps(assertsPopup);
 
-	//Platform::DebugPrintf("Paint took %g\n", et.Duration());
-	return 0l;
+	//Platform::DebugPrintf("Paint took %g\n", ep.Duration());
+	return 0;
 }
 
-sptr_t ScintillaWin::HandleComposition(uptr_t wParam, sptr_t lParam) {
-#ifdef __DMC__
-	// Digital Mars compiler does not include Imm library
-	return 0;
-#else
+sptr_t ScintillaWin::HandleCompositionWindowed(uptr_t wParam, sptr_t lParam) {
 	if (lParam & GCS_RESULTSTR) {
-		HIMC hIMC = ::ImmGetContext(MainHWND());
-		if (hIMC) {
-			const int maxLenInputIME = 200;
-			wchar_t wcs[maxLenInputIME];
-			LONG bytes = ::ImmGetCompositionStringW(hIMC,
-				GCS_RESULTSTR, wcs, (maxLenInputIME-1)*2);
-			int wides = bytes / 2;
-			if (IsUnicodeMode()) {
-				char utfval[maxLenInputIME * 3];
-				unsigned int len = UTF8Length(wcs, wides);
-				UTF8FromUTF16(wcs, wides, utfval, len);
-				utfval[len] = '\0';
-				AddCharUTF(utfval, len);
-			} else {
-				char dbcsval[maxLenInputIME * 2];
-				int size = ::WideCharToMultiByte(InputCodePage(),
-					0, wcs, wides, dbcsval, sizeof(dbcsval) - 1, 0, 0);
-				for (int i=0; i<size; i++) {
-					AddChar(dbcsval[i]);
-				}
-			}
+		IMContext imc(MainHWND());
+		if (imc.hIMC) {
+			AddWString(imc.GetCompositionString(GCS_RESULTSTR), CharacterSource::imeResult);
+
 			// Set new position after converted
-			Point pos = LocationFromPosition(currentPos);
+			const Point pos = PointMainCaret();
 			COMPOSITIONFORM CompForm;
 			CompForm.dwStyle = CFS_POINT;
-			CompForm.ptCurrentPos.x = pos.x;
-			CompForm.ptCurrentPos.y = pos.y;
-			::ImmSetCompositionWindow(hIMC, &CompForm);
-			::ImmReleaseContext(MainHWND(), hIMC);
+			CompForm.ptCurrentPos = POINTFromPoint(pos);
+			::ImmSetCompositionWindow(imc.hIMC, &CompForm);
 		}
 		return 0;
 	}
 	return ::DefWindowProc(MainHWND(), WM_IME_COMPOSITION, wParam, lParam);
-#endif
 }
 
-// Translate message IDs from WM_* and EM_* to SCI_* so can partly emulate Windows Edit control
-static unsigned int SciMessageFromEM(unsigned int iMessage) {
-	switch (iMessage) {
-	case EM_CANPASTE: return SCI_CANPASTE;
-	case EM_CANUNDO: return SCI_CANUNDO;
-	case EM_EMPTYUNDOBUFFER: return SCI_EMPTYUNDOBUFFER;
-	case EM_FINDTEXTEX: return SCI_FINDTEXT;
-	case EM_FORMATRANGE: return SCI_FORMATRANGE;
-	case EM_GETFIRSTVISIBLELINE: return SCI_GETFIRSTVISIBLELINE;
-	case EM_GETLINECOUNT: return SCI_GETLINECOUNT;
-	case EM_GETSELTEXT: return SCI_GETSELTEXT;
-	case EM_GETTEXTRANGE: return SCI_GETTEXTRANGE;
-	case EM_HIDESELECTION: return SCI_HIDESELECTION;
-	case EM_LINEINDEX: return SCI_POSITIONFROMLINE;
-	case EM_LINESCROLL: return SCI_LINESCROLL;
-	case EM_REPLACESEL: return SCI_REPLACESEL;
-	case EM_SCROLLCARET: return SCI_SCROLLCARET;
-	case EM_SETREADONLY: return SCI_SETREADONLY;
-	case WM_CLEAR: return SCI_CLEAR;
-	case WM_COPY: return SCI_COPY;
-	case WM_CUT: return SCI_CUT;
-	case WM_GETTEXT: return SCI_GETTEXT;
-	case WM_SETTEXT: return SCI_SETTEXT;
-	case WM_GETTEXTLENGTH: return SCI_GETTEXTLENGTH;
-	case WM_PASTE: return SCI_PASTE;
-	case WM_UNDO: return SCI_UNDO;
-	}
-	return iMessage;
+bool ScintillaWin::KoreanIME() noexcept {
+	const int codePage = InputCodePage();
+	return codePage == 949 || codePage == 1361;
 }
 
-static UINT CodePageFromCharSet(DWORD characterSet, UINT documentCodePage) {
-	CHARSETINFO ci = { 0, 0, { { 0, 0, 0, 0 }, { 0, 0 } } };
-	BOOL bci = ::TranslateCharsetInfo((DWORD*)characterSet,
-		&ci, TCI_SRCCHARSET);
-
-	UINT cp;
-	if (bci)
-		cp = ci.ciACP;
-	else
-		cp = documentCodePage;
-
-	CPINFO cpi;
-	if (!IsValidCodePage(cp) && !GetCPInfo(cp, &cpi))
-		cp = CP_ACP;
+void ScintillaWin::MoveImeCarets(Sci::Position offset) {
+	// Move carets relatively by bytes.
+	for (size_t r=0; r<sel.Count(); r++) {
+		const Sci::Position positionInsert = sel.Range(r).Start().Position();
+		sel.Range(r).caret.SetPosition(positionInsert + offset);
+		sel.Range(r).anchor.SetPosition(positionInsert + offset);
+	}
+}
 
-	return cp;
+void ScintillaWin::DrawImeIndicator(int indicator, Sci::Position len) {
+	// Emulate the visual style of IME characters with indicators.
+	// Draw an indicator on the character before caret by the character bytes of len
+	// so it should be called after InsertCharacter().
+	// It does not affect caret positions.
+	if (indicator < 8 || indicator > INDICATOR_MAX) {
+		return;
+	}
+	pdoc->DecorationSetCurrentIndicator(indicator);
+	for (size_t r=0; r<sel.Count(); r++) {
+		const Sci::Position positionInsert = sel.Range(r).Start().Position();
+		pdoc->DecorationFillRange(positionInsert - len, 1, len);
+	}
 }
 
-sptr_t ScintillaWin::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
-	//Platform::DebugPrintf("S M:%x WP:%x L:%x\n", iMessage, wParam, lParam);
-	iMessage = SciMessageFromEM(iMessage);
-	switch (iMessage) {
+void ScintillaWin::SetCandidateWindowPos() {
+	IMContext imc(MainHWND());
+	if (imc.hIMC) {
+		const Point pos = PointMainCaret();
+		const PRectangle rcClient = GetTextRectangle();
+		CANDIDATEFORM CandForm{};
+		CandForm.dwIndex = 0;
+		CandForm.dwStyle = CFS_EXCLUDE;
+		CandForm.ptCurrentPos.x = static_cast<int>(pos.x);
+		CandForm.ptCurrentPos.y = static_cast<int>(pos.y + std::max(4, vs.lineHeight/4));
+		// Exclude the area of the whole caret line
+		CandForm.rcArea.top = static_cast<int>(pos.y);
+		CandForm.rcArea.bottom = static_cast<int>(pos.y + vs.lineHeight);
+		CandForm.rcArea.left = static_cast<int>(rcClient.left);
+		CandForm.rcArea.right = static_cast<int>(rcClient.right);
+		::ImmSetCandidateWindow(imc.hIMC, &CandForm);
+	}
+}
 
-	case WM_CREATE:
-		ctrlID = ::GetDlgCtrlID(reinterpret_cast<HWND>(wMain.GetID()));
-		// Get Intellimouse scroll line parameters
-		GetIntelliMouseParameters();
-		::RegisterDragDrop(MainHWND(), reinterpret_cast<IDropTarget *>(&dt));
-		break;
+void ScintillaWin::SelectionToHangul() {
+	// Convert every hanja to hangul within the main range.
+	const Sci::Position selStart = sel.RangeMain().Start().Position();
+	const Sci::Position documentStrLen = sel.RangeMain().Length();
+	const Sci::Position selEnd = selStart + documentStrLen;
+	const Sci::Position utf16Len = pdoc->CountUTF16(selStart, selEnd);
 
-	case WM_COMMAND:
-#ifdef TOTAL_CONTROL
-		Command(LoWord(wParam));
-#endif
-		break;
+	if (utf16Len > 0) {
+		std::string documentStr(documentStrLen, '\0');
+		pdoc->GetCharRange(&documentStr[0], selStart, documentStrLen);
 
-	case WM_PAINT:
-		return WndPaint(wParam);
+		std::wstring uniStr = StringDecode(documentStr, CodePageOfDocument());
+		const int converted = HanjaDict::GetHangulOfHanja(&uniStr[0]);
+		documentStr = StringEncode(uniStr, CodePageOfDocument());
 
-	case WM_PRINTCLIENT: {
-			HDC hdc = reinterpret_cast<HDC>(wParam);
-			if (!IsCompatibleDC(hdc)) {
-				return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
-			}
-			FullPaintDC(hdc);
+		if (converted > 0) {
+			pdoc->BeginUndoAction();
+			ClearSelection();
+			InsertPaste(&documentStr[0], documentStr.size());
+			pdoc->EndUndoAction();
 		}
-		break;
+	}
+}
 
-	case WM_VSCROLL:
-		ScrollMessage(wParam);
-		break;
+void ScintillaWin::EscapeHanja() {
+	// The candidate box pops up to user to select a hanja.
+	// It comes into WM_IME_COMPOSITION with GCS_RESULTSTR.
+	// The existing hangul or hanja is replaced with it.
+	if (sel.Count() > 1) {
+		return; // Do not allow multi carets.
+	}
+	const Sci::Position currentPos = CurrentPosition();
+	const int oneCharLen = pdoc->LenChar(currentPos);
 
-	case WM_HSCROLL:
-		HorizontalScrollMessage(wParam);
-		break;
+	if (oneCharLen < 2) {
+		return; // No need to handle SBCS.
+	}
 
-	case WM_SIZE: {
-			//Platform::DebugPrintf("Scintilla WM_SIZE %d %d\n", LoWord(lParam), HiWord(lParam));
-			ChangeSize();
+	// ImmEscapeW() may overwrite uniChar[] with a null terminated string.
+	// So enlarge it enough to Maximum 4 as in UTF-8.
+	constexpr size_t safeLength = UTF8MaxBytes + 1;
+	std::string oneChar(safeLength, '\0');
+	pdoc->GetCharRange(&oneChar[0], currentPos, oneCharLen);
+
+	std::wstring uniChar = StringDecode(oneChar, CodePageOfDocument());
+
+	IMContext imc(MainHWND());
+	if (imc.hIMC) {
+		// Set the candidate box position since IME may show it.
+		SetCandidateWindowPos();
+		// IME_ESC_HANJA_MODE appears to receive the first character only.
+		if (::ImmEscapeW(GetKeyboardLayout(0), imc.hIMC, IME_ESC_HANJA_MODE, &uniChar[0])) {
+			SetSelection(currentPos, currentPos + oneCharLen);
 		}
-		break;
+	}
+}
 
-	case WM_MOUSEWHEEL:
-		// Don't handle datazoom.
-		// (A good idea for datazoom would be to "fold" or "unfold" details.
-		// i.e. if datazoomed out only class structures are visible, when datazooming in the control
-		// structures appear, then eventually the individual statements...)
-		if (wParam & MK_SHIFT) {
-			return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+void ScintillaWin::ToggleHanja() {
+	// If selection, convert every hanja to hangul within the main range.
+	// If no selection, commit to IME.
+	if (sel.Count() > 1) {
+		return; // Do not allow multi carets.
+	}
+
+	if (sel.Empty()) {
+		EscapeHanja();
+	} else {
+		SelectionToHangul();
+	}
+}
+
+namespace {
+
+std::vector<int> MapImeIndicators(std::vector<BYTE> inputStyle) {
+	std::vector<int> imeIndicator(inputStyle.size(), SC_INDICATOR_UNKNOWN);
+	for (size_t i = 0; i < inputStyle.size(); i++) {
+		switch (static_cast<int>(inputStyle.at(i))) {
+		case ATTR_INPUT:
+			imeIndicator[i] = SC_INDICATOR_INPUT;
+			break;
+		case ATTR_TARGET_NOTCONVERTED:
+		case ATTR_TARGET_CONVERTED:
+			imeIndicator[i] = SC_INDICATOR_TARGET;
+			break;
+		case ATTR_CONVERTED:
+			imeIndicator[i] = SC_INDICATOR_CONVERTED;
+			break;
+		default:
+			imeIndicator[i] = SC_INDICATOR_UNKNOWN;
+			break;
 		}
+	}
+	return imeIndicator;
+}
 
-		// Either SCROLL or ZOOM. We handle the wheel steppings calculation
-		wheelDelta -= static_cast<short>(HiWord(wParam));
-		if (abs(wheelDelta) >= WHEEL_DELTA && linesPerScroll > 0) {
-			int linesToScroll = linesPerScroll;
-			if (linesPerScroll == WHEEL_PAGESCROLL)
-				linesToScroll = LinesOnScreen() - 1;
-			if (linesToScroll == 0) {
-				linesToScroll = 1;
+}
+
+void ScintillaWin::AddWString(std::wstring_view wsv, CharacterSource charSource) {
+	if (wsv.empty())
+		return;
+
+	const int codePage = CodePageOfDocument();
+	for (size_t i = 0; i < wsv.size(); ) {
+		const size_t ucWidth = UTF16CharLength(wsv[i]);
+		const std::string docChar = StringEncode(wsv.substr(i, ucWidth), codePage);
+
+		InsertCharacter(docChar, charSource);
+		i += ucWidth;
+	}
+}
+
+sptr_t ScintillaWin::HandleCompositionInline(uptr_t, sptr_t lParam) {
+	// Copy & paste by johnsonj with a lot of helps of Neil.
+	// Great thanks for my foreruners, jiniya and BLUEnLIVE.
+
+	IMContext imc(MainHWND());
+	if (!imc.hIMC)
+		return 0;
+	if (pdoc->IsReadOnly() || SelectionContainsProtected()) {
+		::ImmNotifyIME(imc.hIMC, NI_COMPOSITIONSTR, CPS_CANCEL, 0);
+		return 0;
+	}
+
+	bool initialCompose = false;
+	if (pdoc->TentativeActive()) {
+		pdoc->TentativeUndo();
+	} else {
+		// No tentative undo means start of this composition so
+		// fill in any virtual spaces.
+		initialCompose = true;
+	}
+
+	view.imeCaretBlockOverride = false;
+
+	if (lParam & GCS_RESULTSTR) {
+		AddWString(imc.GetCompositionString(GCS_RESULTSTR), CharacterSource::imeResult);
+	}
+
+	if (lParam & GCS_COMPSTR) {
+		const std::wstring wcs = imc.GetCompositionString(GCS_COMPSTR);
+		if (wcs.empty()) {
+			ShowCaretAtCurrentPosition();
+			return 0;
+		}
+
+		if (initialCompose) {
+			ClearBeforeTentativeStart();
+		}
+
+		// Set candidate window left aligned to beginning of preedit string.
+		SetCandidateWindowPos();
+		pdoc->TentativeStart(); // TentativeActive from now on.
+
+		std::vector<int> imeIndicator = MapImeIndicators(imc.GetImeAttributes());
+
+		const int codePage = CodePageOfDocument();
+		const std::wstring_view wsv = wcs;
+		for (size_t i = 0; i < wsv.size(); ) {
+			const size_t ucWidth = UTF16CharLength(wsv[i]);
+			const std::string docChar = StringEncode(wsv.substr(i, ucWidth), codePage);
+
+			InsertCharacter(docChar, CharacterSource::tentativeInput);
+
+			DrawImeIndicator(imeIndicator[i], docChar.size());
+			i += ucWidth;
+		}
+
+		// Japanese IME after pressing Tab replaces input string with first candidate item (target string);
+		// when selecting other candidate item, previous item will be replaced with current one.
+		// After candidate item been added, it's looks like been full selected, it's better to keep caret
+		// at end of "selection" (end of input) instead of jump to beginning of input ("selection").
+		const bool onlyTarget = std::all_of(imeIndicator.begin(), imeIndicator.end(), [](int i) noexcept {
+			return i == SC_INDICATOR_TARGET;
+		});
+		if (!onlyTarget) {
+			// CS_NOMOVECARET: keep caret at beginning of composition string which already moved in InsertCharacter().
+			// GCS_CURSORPOS: current caret position is provided by IME.
+			Sci::Position imeEndToImeCaretU16 = -static_cast<Sci::Position>(wcs.size());
+			if (!(lParam & CS_NOMOVECARET) && (lParam & GCS_CURSORPOS)) {
+				imeEndToImeCaretU16 += imc.GetImeCaretPos();
 			}
-			linesToScroll *= (wheelDelta / WHEEL_DELTA);
-			if (wheelDelta >= 0)
-				wheelDelta = wheelDelta % WHEEL_DELTA;
-			else
-				wheelDelta = - (-wheelDelta % WHEEL_DELTA);
+			if (imeEndToImeCaretU16 != 0) {
+				// Move back IME caret from current last position to imeCaretPos.
+				const Sci::Position currentPos = CurrentPosition();
+				const Sci::Position imeCaretPosDoc = pdoc->GetRelativePositionUTF16(currentPos, imeEndToImeCaretU16);
 
-			if (wParam & MK_CONTROL) {
-				// Zoom! We play with the font sizes in the styles.
-				// Number of steps/line is ignored, we just care if sizing up or down
-				if (linesToScroll < 0) {
-					KeyCommand(SCI_ZOOMIN);
-				} else {
-					KeyCommand(SCI_ZOOMOUT);
+				MoveImeCarets(-currentPos + imeCaretPosDoc);
+
+				if (std::find(imeIndicator.begin(), imeIndicator.end(), SC_INDICATOR_TARGET) != imeIndicator.end()) {
+					// set candidate window left aligned to beginning of target string.
+					SetCandidateWindowPos();
 				}
-			} else {
-				// Scroll
-				ScrollTo(topLine + linesToScroll);
 			}
 		}
-		return 0;
 
-	case WM_TIMER:
-		if (wParam == standardTimerID && timer.ticking) {
-			Tick();
-		} else if (wParam == idleTimerID && idler.state) {
-			SendMessage(MainHWND(), SC_WIN_IDLE, 0, 1);
-		} else {
-			return 1;
+		if (KoreanIME()) {
+			view.imeCaretBlockOverride = true;
 		}
-		break;
+	}
+	EnsureCaretVisible();
+	ShowCaretAtCurrentPosition();
+	return 0;
+}
 
-	case SC_WIN_IDLE:
-		// wParam=dwTickCountInitial, or 0 to initialize.  lParam=bSkipUserInputTest
-		if (idler.state) {
-			if (lParam || (WAIT_TIMEOUT==MsgWaitForMultipleObjects(0,0,0,0, QS_INPUT|QS_HOTKEY))) {
-				if (Idle()) {
-					// User input was given priority above, but all events do get a turn.  Other
-					// messages, notifications, etc. will get interleaved with the idle messages.
+namespace {
 
-					// However, some things like WM_PAINT are a lower priority, and will not fire
-					// when there's a message posted.  So, several times a second, we stop and let
-					// the low priority events have a turn (after which the timer will fire again).
+// Translate message IDs from WM_* and EM_* to SCI_* so can partly emulate Windows Edit control
+unsigned int SciMessageFromEM(unsigned int iMessage) noexcept {
+	switch (iMessage) {
+	case EM_CANPASTE: return SCI_CANPASTE;
+	case EM_CANUNDO: return SCI_CANUNDO;
+	case EM_EMPTYUNDOBUFFER: return SCI_EMPTYUNDOBUFFER;
+	case EM_FINDTEXTEX: return SCI_FINDTEXT;
+	case EM_FORMATRANGE: return SCI_FORMATRANGE;
+	case EM_GETFIRSTVISIBLELINE: return SCI_GETFIRSTVISIBLELINE;
+	case EM_GETLINECOUNT: return SCI_GETLINECOUNT;
+	case EM_GETSELTEXT: return SCI_GETSELTEXT;
+	case EM_GETTEXTRANGE: return SCI_GETTEXTRANGE;
+	case EM_HIDESELECTION: return SCI_HIDESELECTION;
+	case EM_LINEINDEX: return SCI_POSITIONFROMLINE;
+	case EM_LINESCROLL: return SCI_LINESCROLL;
+	case EM_REPLACESEL: return SCI_REPLACESEL;
+	case EM_SCROLLCARET: return SCI_SCROLLCARET;
+	case EM_SETREADONLY: return SCI_SETREADONLY;
+	case WM_CLEAR: return SCI_CLEAR;
+	case WM_COPY: return SCI_COPY;
+	case WM_CUT: return SCI_CUT;
+	case WM_SETTEXT: return SCI_SETTEXT;
+	case WM_PASTE: return SCI_PASTE;
+	case WM_UNDO: return SCI_UNDO;
+	}
+	return iMessage;
+}
 
-					DWORD dwCurrent = GetTickCount();
-					DWORD dwStart = wParam ? wParam : dwCurrent;
+}
 
-					if (dwCurrent >= dwStart && dwCurrent > 200 && dwCurrent - 200 < dwStart)
-						PostMessage(MainHWND(), SC_WIN_IDLE, dwStart, 0);
-				} else {
-					SetIdle(false);
-				}
+namespace Scintilla {
+
+UINT CodePageFromCharSet(DWORD characterSet, UINT documentCodePage) noexcept {
+	if (documentCodePage == SC_CP_UTF8) {
+		return SC_CP_UTF8;
+	}
+	switch (characterSet) {
+	case SC_CHARSET_ANSI: return 1252;
+	case SC_CHARSET_DEFAULT: return documentCodePage ? documentCodePage : 1252;
+	case SC_CHARSET_BALTIC: return 1257;
+	case SC_CHARSET_CHINESEBIG5: return 950;
+	case SC_CHARSET_EASTEUROPE: return 1250;
+	case SC_CHARSET_GB2312: return 936;
+	case SC_CHARSET_GREEK: return 1253;
+	case SC_CHARSET_HANGUL: return 949;
+	case SC_CHARSET_MAC: return 10000;
+	case SC_CHARSET_OEM: return 437;
+	case SC_CHARSET_RUSSIAN: return 1251;
+	case SC_CHARSET_SHIFTJIS: return 932;
+	case SC_CHARSET_TURKISH: return 1254;
+	case SC_CHARSET_JOHAB: return 1361;
+	case SC_CHARSET_HEBREW: return 1255;
+	case SC_CHARSET_ARABIC: return 1256;
+	case SC_CHARSET_VIETNAMESE: return 1258;
+	case SC_CHARSET_THAI: return 874;
+	case SC_CHARSET_8859_15: return 28605;
+	// Not supported
+	case SC_CHARSET_CYRILLIC: return documentCodePage;
+	case SC_CHARSET_SYMBOL: return documentCodePage;
+	}
+	return documentCodePage;
+}
+
+}
+
+UINT ScintillaWin::CodePageOfDocument() const noexcept {
+	return CodePageFromCharSet(vs.styles[STYLE_DEFAULT].characterSet, pdoc->dbcsCodePage);
+}
+
+std::string ScintillaWin::EncodeWString(std::wstring_view wsv) {
+	if (IsUnicodeMode()) {
+		const size_t len = UTF8Length(wsv);
+		std::string putf(len, 0);
+		UTF8FromUTF16(wsv, putf.data(), len);
+		return putf;
+	} else {
+		// Not in Unicode mode so convert from Unicode to current Scintilla code page
+		return StringEncode(wsv, CodePageOfDocument());
+	}
+}
+
+sptr_t ScintillaWin::GetTextLength() {
+	return pdoc->CountUTF16(0, pdoc->Length());
+}
+
+sptr_t ScintillaWin::GetText(uptr_t wParam, sptr_t lParam) {
+	if (lParam == 0) {
+		return pdoc->CountUTF16(0, pdoc->Length());
+	}
+	if (wParam == 0) {
+		return 0;
+	}
+	wchar_t *ptr = static_cast<wchar_t *>(PtrFromSPtr(lParam));
+	if (pdoc->Length() == 0) {
+		*ptr = L'\0';
+		return 0;
+	}
+	const Sci::Position lengthWanted = wParam - 1;
+	Sci::Position sizeRequestedRange = pdoc->GetRelativePositionUTF16(0, lengthWanted);
+	if (sizeRequestedRange < 0) {
+		// Requested more text than there is in the document.
+		sizeRequestedRange = pdoc->Length();
+	}
+	std::string docBytes(sizeRequestedRange, '\0');
+	pdoc->GetCharRange(&docBytes[0], 0, sizeRequestedRange);
+	if (IsUnicodeMode()) {
+		const size_t uLen = UTF16FromUTF8(docBytes, ptr, lengthWanted);
+		ptr[uLen] = L'\0';
+		return uLen;
+	} else {
+		// Not Unicode mode
+		// Convert to Unicode using the current Scintilla code page
+		const UINT cpSrc = CodePageOfDocument();
+		int lengthUTF16 = WideCharLenFromMultiByte(cpSrc, docBytes);
+		if (lengthUTF16 > lengthWanted)
+			lengthUTF16 = static_cast<int>(lengthWanted);
+		WideCharFromMultiByte(cpSrc, docBytes, ptr, lengthUTF16);
+		ptr[lengthUTF16] = L'\0';
+		return lengthUTF16;
+	}
+}
+
+Window::Cursor ScintillaWin::ContextCursor(Point pt) {
+	if (inDragDrop == ddDragging) {
+		return Window::cursorUp;
+	} else {
+		// Display regular (drag) cursor over selection
+		if (PointInSelMargin(pt)) {
+			return GetMarginCursor(pt);
+		} else if (!SelectionEmpty() && PointInSelection(pt)) {
+			return Window::cursorArrow;
+		} else if (PointIsHotspot(pt)) {
+			return Window::cursorHand;
+		} else if (hoverIndicatorPos != Sci::invalidPosition) {
+			const Sci::Position pos = PositionFromLocation(pt, true, true);
+			if (pos != Sci::invalidPosition) {
+				return Window::cursorHand;
 			}
 		}
-		break;
+	}
+	return Window::cursorText;
+}
 
-	case WM_GETMINMAXINFO:
-		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+sptr_t ScintillaWin::ShowContextMenu(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
+	Point pt = PointFromLParam(lParam);
+	POINT rpt = POINTFromPoint(pt);
+	::ScreenToClient(MainHWND(), &rpt);
+	const Point ptClient = PointFromPOINT(rpt);
+	if (ShouldDisplayPopup(ptClient)) {
+		if ((pt.x == -1) && (pt.y == -1)) {
+			// Caused by keyboard so display menu near caret
+			pt = PointMainCaret();
+			POINT spt = POINTFromPoint(pt);
+			::ClientToScreen(MainHWND(), &spt);
+			pt = PointFromPOINT(spt);
+		}
+		ContextMenu(pt);
+		return 0;
+	}
+	return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+}
 
-	case WM_LBUTTONDOWN: {
-#ifndef __DMC__
-		// Digital Mars compiler does not include Imm library
-		// For IME, set the composition string as the result string.
-		HIMC hIMC = ::ImmGetContext(MainHWND());
-		::ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
-		::ImmReleaseContext(MainHWND(), hIMC);
+void ScintillaWin::SizeWindow() {
+#if defined(USE_D2D)
+	if (paintState == notPainting) {
+		DropRenderTarget();
+	} else {
+		renderTargetValid = false;
+	}
 #endif
-		//
-		//Platform::DebugPrintf("Buttdown %d %x %x %x %x %x\n",iMessage, wParam, lParam,
-		//	Platform::IsKeyDown(VK_SHIFT),
-		//	Platform::IsKeyDown(VK_CONTROL),
-		//	Platform::IsKeyDown(VK_MENU));
-		ButtonDown(Point::FromLong(lParam), ::GetMessageTime(),
-			(wParam & MK_SHIFT) != 0,
-			(wParam & MK_CONTROL) != 0,
-			Platform::IsKeyDown(VK_MENU));
-		::SetFocus(MainHWND());
-		}
-		break;
+	//Platform::DebugPrintf("Scintilla WM_SIZE %d %d\n", LOWORD(lParam), HIWORD(lParam));
+	ChangeSize();
+}
 
-	case WM_MOUSEMOVE:
-		ButtonMove(Point::FromLong(lParam));
+sptr_t ScintillaWin::MouseMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
+	switch (iMessage) {
+	case WM_LBUTTONDOWN: {
+			// For IME, set the composition string as the result string.
+			IMContext imc(MainHWND());
+			if (imc.hIMC) {
+				::ImmNotifyIME(imc.hIMC, NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
+			}
+			//
+			//Platform::DebugPrintf("Buttdown %d %x %x %x %x %x\n",iMessage, wParam, lParam,
+			//	KeyboardIsKeyDown(VK_SHIFT),
+			//	KeyboardIsKeyDown(VK_CONTROL),
+			//	KeyboardIsKeyDown(VK_MENU));
+			::SetFocus(MainHWND());
+			ButtonDownWithModifiers(PointFromLParam(lParam), ::GetMessageTime(),
+						MouseModifiers(wParam));
+		}
 		break;
 
 	case WM_LBUTTONUP:
-		ButtonUp(Point::FromLong(lParam),
-			::GetMessageTime(),
-			(wParam & MK_CONTROL) != 0);
+		ButtonUpWithModifiers(PointFromLParam(lParam),
+				      ::GetMessageTime(), MouseModifiers(wParam));
 		break;
 
-	case WM_RBUTTONDOWN:
-		if (!PointInSelection(Point::FromLong(lParam)))
-			SetEmptySelection(PositionFromLocation(Point::FromLong(lParam)));
+	case WM_RBUTTONDOWN: {
+			::SetFocus(MainHWND());
+			const Point pt = PointFromLParam(lParam);
+			if (!PointInSelection(pt)) {
+				CancelModes();
+				SetEmptySelection(PositionFromLocation(PointFromLParam(lParam)));
+			}
+
+			RightButtonDownWithModifiers(pt, ::GetMessageTime(), MouseModifiers(wParam));
+		}
 		break;
 
-	case WM_SETCURSOR:
-		if (LoWord(lParam) == HTCLIENT) {
-			if (inDragDrop == ddDragging) {
-				DisplayCursor(Window::cursorUp);
-			} else {
-				// Display regular (drag) cursor over selection
-				POINT pt;
-				::GetCursorPos(&pt);
-				::ScreenToClient(MainHWND(), &pt);
-				if (PointInSelMargin(Point(pt.x, pt.y))) {
-					DisplayCursor(Window::cursorReverseArrow);
-				} else if (PointInSelection(Point(pt.x, pt.y)) && !SelectionEmpty()) {
-					DisplayCursor(Window::cursorArrow);
-				} else if (PointIsHotspot(Point(pt.x, pt.y))) {
-					DisplayCursor(Window::cursorHand);
-				} else {
-					DisplayCursor(Window::cursorText);
-				}
+	case WM_MOUSEMOVE: {
+			const Point pt = PointFromLParam(lParam);
+
+			// Windows might send WM_MOUSEMOVE even though the mouse has not been moved:
+			// http://blogs.msdn.com/b/oldnewthing/archive/2003/10/01/55108.aspx
+			if (ptMouseLast != pt) {
+				SetTrackMouseLeaveEvent(true);
+				ButtonMoveWithModifiers(pt, ::GetMessageTime(), MouseModifiers(wParam));
 			}
-			return TRUE;
-		} else {
+		}
+		break;
+
+	case WM_MOUSELEAVE:
+		SetTrackMouseLeaveEvent(false);
+		MouseLeave();
+		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+
+	case WM_MOUSEWHEEL:
+		if (!mouseWheelCaptures) {
+			// if the mouse wheel is not captured, test if the mouse
+			// pointer is over the editor window and if not, don't
+			// handle the message but pass it on.
+			RECT rc;
+			GetWindowRect(MainHWND(), &rc);
+			const POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
+			if (!PtInRect(&rc, pt))
+				return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+		}
+		// if autocomplete list active then send mousewheel message to it
+		if (ac.Active()) {
+			HWND hWnd = HwndFromWindow(*(ac.lb));
+			::SendMessage(hWnd, iMessage, wParam, lParam);
+			break;
+		}
+
+		// Don't handle datazoom.
+		// (A good idea for datazoom would be to "fold" or "unfold" details.
+		// i.e. if datazoomed out only class structures are visible, when datazooming in the control
+		// structures appear, then eventually the individual statements...)
+		if (wParam & MK_SHIFT) {
 			return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
 		}
+		// Either SCROLL or ZOOM. We handle the wheel steppings calculation
+		wheelDelta -= GET_WHEEL_DELTA_WPARAM(wParam);
+		if (std::abs(wheelDelta) >= WHEEL_DELTA && linesPerScroll > 0) {
+			Sci::Line linesToScroll = linesPerScroll;
+			if (linesPerScroll == WHEEL_PAGESCROLL)
+				linesToScroll = LinesOnScreen() - 1;
+			if (linesToScroll == 0) {
+				linesToScroll = 1;
+			}
+			linesToScroll *= (wheelDelta / WHEEL_DELTA);
+			if (wheelDelta >= 0)
+				wheelDelta = wheelDelta % WHEEL_DELTA;
+			else
+				wheelDelta = -(-wheelDelta % WHEEL_DELTA);
 
-	case WM_CHAR:
-		if (((wParam >= 128) || !iscntrl(wParam)) || !lastKeyDownConsumed) {
-			if (::IsWindowUnicode(MainHWND()) || keysAlwaysUnicode) {
-				wchar_t wcs[2] = {wParam, 0};
-				if (IsUnicodeMode()) {
-					// For a wide character version of the window:
-					char utfval[4];
-					unsigned int len = UTF8Length(wcs, 1);
-					UTF8FromUTF16(wcs, 1, utfval, len);
-					AddCharUTF(utfval, len);
+			if (wParam & MK_CONTROL) {
+				// Zoom! We play with the font sizes in the styles.
+				// Number of steps/line is ignored, we just care if sizing up or down
+				if (linesToScroll < 0) {
+					KeyCommand(SCI_ZOOMIN);
 				} else {
-					UINT cpDest = CodePageFromCharSet(
-						vs.styles[STYLE_DEFAULT].characterSet, pdoc->dbcsCodePage);
-					char inBufferCP[20];
-					int size = ::WideCharToMultiByte(cpDest,
-						0, wcs, 1, inBufferCP, sizeof(inBufferCP) - 1, 0, 0);
-					AddCharUTF(inBufferCP, size);
+					KeyCommand(SCI_ZOOMOUT);
 				}
 			} else {
-				if (IsUnicodeMode()) {
-					AddCharBytes('\0', LOBYTE(wParam));
-				} else {
-					AddChar(LOBYTE(wParam));
-				}
+				// Scroll
+				ScrollTo(topLine + linesToScroll);
 			}
 		}
 		return 0;
+	}
+	return 0;
+}
 
-	case WM_UNICHAR:
-		if (wParam == UNICODE_NOCHAR) {
-			return IsUnicodeMode() ? 1 : 0;
-		} else if (lastKeyDownConsumed) {
-			return 1;
-		} else {
-			if (IsUnicodeMode()) {
-				char utfval[4];
-				wchar_t wcs[2] = {static_cast<wchar_t>(wParam), 0};
-				unsigned int len = UTF8Length(wcs, 1);
-				UTF8FromUTF16(wcs, 1, utfval, len);
-				AddCharUTF(utfval, len);
-				return 1;
-			} else {
-				return 0;
-			}
-		}
+sptr_t ScintillaWin::KeyMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
+	switch (iMessage) {
 
 	case WM_SYSKEYDOWN:
 	case WM_KEYDOWN: {
-		//Platform::DebugPrintf("S keydown %d %x %x %x %x\n",iMessage, wParam, lParam, ::IsKeyDown(VK_SHIFT), ::IsKeyDown(VK_CONTROL));
+			// Platform::DebugPrintf("Keydown %c %c%c%c%c %x %x\n",
+			// iMessage == WM_KEYDOWN ? 'K' : 'S',
+			// (lParam & (1 << 24)) ? 'E' : '-',
+			// KeyboardIsKeyDown(VK_SHIFT) ? 'S' : '-',
+			// KeyboardIsKeyDown(VK_CONTROL) ? 'C' : '-',
+			// KeyboardIsKeyDown(VK_MENU) ? 'A' : '-',
+			// wParam, lParam);
 			lastKeyDownConsumed = false;
-			int ret = KeyDown(KeyTranslate(wParam),
-				Platform::IsKeyDown(VK_SHIFT),
-				Platform::IsKeyDown(VK_CONTROL),
-				Platform::IsKeyDown(VK_MENU),
-				&lastKeyDownConsumed);
+			const bool altDown = KeyboardIsKeyDown(VK_MENU);
+			if (altDown && KeyboardIsNumericKeypadFunction(wParam, lParam)) {
+				// Don't interpret these as they may be characters entered by number.
+				return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+			}
+			const int ret = KeyDownWithModifiers(KeyTranslate(static_cast<int>(wParam)),
+							     ModifierFlags(KeyboardIsKeyDown(VK_SHIFT),
+									     KeyboardIsKeyDown(VK_CONTROL),
+									     altDown),
+							     &lastKeyDownConsumed);
 			if (!ret && !lastKeyDownConsumed) {
 				return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
 			}
 			break;
 		}
 
-	case WM_IME_KEYDOWN:
-		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
-
 	case WM_KEYUP:
 		//Platform::DebugPrintf("S keyup %d %x %x\n",iMessage, wParam, lParam);
 		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
 
-	case WM_SETTINGCHANGE:
-		//Platform::DebugPrintf("Setting Changed\n");
-		InvalidateStyleData();
-		// Get Intellimouse scroll line parameters
-		GetIntelliMouseParameters();
-		break;
+	case WM_CHAR:
+		if (((wParam >= 128) || !iscntrl(static_cast<int>(wParam))) || !lastKeyDownConsumed) {
+			wchar_t wcs[3] = { static_cast<wchar_t>(wParam), 0 };
+			unsigned int wclen = 1;
+			if (IS_HIGH_SURROGATE(wcs[0])) {
+				// If this is a high surrogate character, we need a second one
+				lastHighSurrogateChar = wcs[0];
+				return 0;
+			} else if (IS_LOW_SURROGATE(wcs[0])) {
+				wcs[1] = wcs[0];
+				wcs[0] = lastHighSurrogateChar;
+				lastHighSurrogateChar = 0;
+				wclen = 2;
+			}
+			AddWString(std::wstring_view(wcs, wclen), CharacterSource::directInput);
+		}
+		return 0;
 
-	case WM_GETDLGCODE:
-		return DLGC_HASSETSEL | DLGC_WANTALLKEYS;
+	case WM_UNICHAR:
+		if (wParam == UNICODE_NOCHAR) {
+			return TRUE;
+		} else if (lastKeyDownConsumed) {
+			return 1;
+		} else {
+			wchar_t wcs[3] = { 0 };
+			const size_t wclen = UTF16FromUTF32Character(static_cast<unsigned int>(wParam), wcs);
+			AddWString(std::wstring_view(wcs, wclen), CharacterSource::directInput);
+			return FALSE;
+		}
+	}
+
+	return 0;
+}
 
+sptr_t ScintillaWin::FocusMessage(unsigned int iMessage, uptr_t wParam, sptr_t) {
+	switch (iMessage) {
 	case WM_KILLFOCUS: {
-			HWND wOther = reinterpret_cast<HWND>(wParam);
-			HWND wThis = MainHWND();
-			HWND wCT = reinterpret_cast<HWND>(ct.wCallTip.GetID());
-			if (!wParam ||
-				!(::IsChild(wThis,wOther) || (wOther == wCT))) {
-				SetFocusState(false);
-				DestroySystemCaret();
-			}
+		HWND wOther = reinterpret_cast<HWND>(wParam);
+		HWND wThis = MainHWND();
+		const HWND wCT = HwndFromWindow(ct.wCallTip);
+		if (!wParam ||
+			!(::IsChild(wThis, wOther) || (wOther == wCT))) {
+			SetFocusState(false);
+			DestroySystemCaret();
+		}
+		// Explicitly complete any IME composition
+		IMContext imc(MainHWND());
+		if (imc.hIMC) {
+			::ImmNotifyIME(imc.hIMC, NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
 		}
-		//RealizeWindowPalette(true);
 		break;
+	}
 
 	case WM_SETFOCUS:
 		SetFocusState(true);
-		RealizeWindowPalette(false);
 		DestroySystemCaret();
 		CreateSystemCaret();
 		break;
+	}
+	return 0;
+}
 
-	case WM_SYSCOLORCHANGE:
-		//Platform::DebugPrintf("Setting Changed\n");
-		InvalidateStyleData();
-		break;
+sptr_t ScintillaWin::IMEMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
+	switch (iMessage) {
+
+	case WM_INPUTLANGCHANGE:
+		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+
+	case WM_INPUTLANGCHANGEREQUEST:
+		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
 
-	case WM_PALETTECHANGED:
-		if (wParam != reinterpret_cast<uptr_t>(MainHWND())) {
-			//Platform::DebugPrintf("** Palette Changed\n");
-			RealizeWindowPalette(true);
+	case WM_IME_KEYDOWN: {
+			if (wParam == VK_HANJA) {
+				ToggleHanja();
+			}
+			return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
 		}
-		break;
 
-	case WM_QUERYNEWPALETTE:
-		//Platform::DebugPrintf("** Query palette\n");
-		RealizeWindowPalette(false);
-		break;
+	case WM_IME_REQUEST: {
+			if (wParam == IMR_RECONVERTSTRING) {
+				return ImeOnReconvert(lParam);
+			}
+			return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+		}
 
-	case WM_IME_STARTCOMPOSITION: 	// dbcs
-		ImeStartComposition();
-		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+	case WM_IME_STARTCOMPOSITION:
+		if (KoreanIME() || imeInteraction == imeInline) {
+			return 0;
+		} else {
+			ImeStartComposition();
+			return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+		}
 
-	case WM_IME_ENDCOMPOSITION: 	// dbcs
+	case WM_IME_ENDCOMPOSITION:
 		ImeEndComposition();
 		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
 
 	case WM_IME_COMPOSITION:
-		return HandleComposition(wParam, lParam);
-
-	case WM_IME_CHAR: {
-			AddCharBytes(HIBYTE(wParam), LOBYTE(wParam));
-			return 0;
+		if (KoreanIME() || imeInteraction == imeInline) {
+			return HandleCompositionInline(wParam, lParam);
+		} else {
+			return HandleCompositionWindowed(wParam, lParam);
 		}
 
-	case WM_CONTEXTMENU:
-#ifdef TOTAL_CONTROL
-		if (displayPopupMenu) {
-			Point pt = Point::FromLong(lParam);
-			if ((pt.x == -1) && (pt.y == -1)) {
-				// Caused by keyboard so display menu near caret
-				pt = LocationFromPosition(currentPos);
-				POINT spt = {pt.x, pt.y};
-				::ClientToScreen(MainHWND(), &spt);
-				pt = Point(spt.x, spt.y);
+	case WM_IME_SETCONTEXT:
+		if (KoreanIME() || imeInteraction == imeInline) {
+			if (wParam) {
+				LPARAM NoImeWin = lParam;
+				NoImeWin = NoImeWin & (~ISC_SHOWUICOMPOSITIONWINDOW);
+				return ::DefWindowProc(MainHWND(), iMessage, wParam, NoImeWin);
 			}
-			ContextMenu(pt);
-			return 0;
 		}
-#endif
-		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
-
-	case WM_INPUTLANGCHANGE:
-		//::SetThreadLocale(LOWORD(lParam));
 		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
 
-	case WM_INPUTLANGCHANGEREQUEST:
+	case WM_IME_NOTIFY:
 		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
 
-	case WM_ERASEBKGND:
-		return 1;   // Avoid any background erasure as whole window painted.
-
-	case WM_CAPTURECHANGED:
-		capturedMouse = false;
-		return 0;
-
-	// These are not handled in Scintilla and its faster to dispatch them here.
-	// Also moves time out to here so profile doesn't count lots of empty message calls.
+	}
+	return 0;
+}
 
-	case WM_MOVE:
-	case WM_MOUSEACTIVATE:
-	case WM_NCHITTEST:
-	case WM_NCCALCSIZE:
-	case WM_NCPAINT:
-	case WM_NCMOUSEMOVE:
-	case WM_NCLBUTTONDOWN:
-	case WM_IME_SETCONTEXT:
-	case WM_IME_NOTIFY:
-	case WM_SYSCOMMAND:
-	case WM_WINDOWPOSCHANGING:
-	case WM_WINDOWPOSCHANGED:
-		return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+sptr_t ScintillaWin::EditMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
+	switch (iMessage) {
 
 	case EM_LINEFROMCHAR:
-		if (static_cast<int>(wParam) < 0) {
-			wParam = SelectionStart();
+		if (static_cast<Sci::Position>(wParam) < 0) {
+			wParam = SelectionStart().Position();
 		}
 		return pdoc->LineFromPosition(wParam);
 
@@ -954,37 +1694,33 @@ sptr_t ScintillaWin::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam
 
 	case EM_GETSEL:
 		if (wParam) {
-			*reinterpret_cast<int *>(wParam) = SelectionStart();
+			*reinterpret_cast<DWORD *>(wParam) = static_cast<DWORD>(SelectionStart().Position());
 		}
 		if (lParam) {
-			*reinterpret_cast<int *>(lParam) = SelectionEnd();
+			*reinterpret_cast<DWORD *>(lParam) = static_cast<DWORD>(SelectionEnd().Position());
 		}
-		return MAKELONG(SelectionStart(), SelectionEnd());
+		return MAKELRESULT(SelectionStart().Position(), SelectionEnd().Position());
 
 	case EM_EXGETSEL: {
 			if (lParam == 0) {
 				return 0;
 			}
-			CharacterRange *pCR = reinterpret_cast<CharacterRange *>(lParam);
-			pCR->cpMin = SelectionStart();
-			pCR->cpMax = SelectionEnd();
+			CHARRANGE *pCR = reinterpret_cast<CHARRANGE *>(lParam);
+			pCR->cpMin = static_cast<LONG>(SelectionStart().Position());
+			pCR->cpMax = static_cast<LONG>(SelectionEnd().Position());
 		}
 		break;
 
 	case EM_SETSEL: {
-			int nStart = static_cast<int>(wParam);
-			int nEnd = static_cast<int>(lParam);
+			Sci::Position nStart = wParam;
+			Sci::Position nEnd = lParam;
 			if (nStart == 0 && nEnd == -1) {
 				nEnd = pdoc->Length();
 			}
 			if (nStart == -1) {
 				nStart = nEnd;	// Remove selection
 			}
-			if (nStart > nEnd) {
-				SetSelection(nEnd, nStart);
-			} else {
-				SetSelection(nStart, nEnd);
-			}
+			SetSelection(nEnd, nStart);
 			EnsureCaretVisible();
 		}
 		break;
@@ -993,17 +1729,62 @@ sptr_t ScintillaWin::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam
 			if (lParam == 0) {
 				return 0;
 			}
-			CharacterRange *pCR = reinterpret_cast<CharacterRange *>(lParam);
-			selType = selStream;
+			const CHARRANGE *pCR = reinterpret_cast<const CHARRANGE *>(lParam);
+			sel.selType = Selection::selStream;
 			if (pCR->cpMin == 0 && pCR->cpMax == -1) {
 				SetSelection(pCR->cpMin, pdoc->Length());
 			} else {
 				SetSelection(pCR->cpMin, pCR->cpMax);
 			}
 			EnsureCaretVisible();
-			return pdoc->LineFromPosition(SelectionStart());
+			return pdoc->LineFromPosition(SelectionStart().Position());
 		}
+	}
+	return 0;
+}
 
+sptr_t ScintillaWin::IdleMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
+	switch (iMessage) {
+	case SC_WIN_IDLE:
+		// wParam=dwTickCountInitial, or 0 to initialize.  lParam=bSkipUserInputTest
+		if (idler.state) {
+			if (lParam || (WAIT_TIMEOUT == MsgWaitForMultipleObjects(0, nullptr, 0, 0, QS_INPUT | QS_HOTKEY))) {
+				if (Idle()) {
+					// User input was given priority above, but all events do get a turn.  Other
+					// messages, notifications, etc. will get interleaved with the idle messages.
+
+					// However, some things like WM_PAINT are a lower priority, and will not fire
+					// when there's a message posted.  So, several times a second, we stop and let
+					// the low priority events have a turn (after which the timer will fire again).
+
+					// Suppress a warning from Code Analysis that the GetTickCount function
+					// wraps after 49 days. The WM_TIMER will kick off another SC_WIN_IDLE
+					// after the wrap.
+#ifdef _MSC_VER
+#pragma warning(suppress: 28159)
+#endif
+					const DWORD dwCurrent = GetTickCount();
+					const DWORD dwStart = wParam ? static_cast<DWORD>(wParam) : dwCurrent;
+					constexpr DWORD maxWorkTime = 50;
+
+					if (dwCurrent >= dwStart && dwCurrent > maxWorkTime &&dwCurrent - maxWorkTime < dwStart)
+						PostMessage(MainHWND(), SC_WIN_IDLE, dwStart, 0);
+				} else {
+					SetIdle(false);
+				}
+			}
+		}
+		break;
+
+	case SC_WORK_IDLE:
+		IdleWork();
+		break;
+	}
+	return 0;
+}
+
+sptr_t ScintillaWin::SciMessage(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
+	switch (iMessage) {
 	case SCI_GETDIRECTFUNCTION:
 		return reinterpret_cast<sptr_t>(DirectFunction);
 
@@ -1014,23 +1795,253 @@ sptr_t ScintillaWin::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam
 		::SetFocus(MainHWND());
 		break;
 
+#ifdef INCLUDE_DEPRECATED_FEATURES
 	case SCI_SETKEYSUNICODE:
-		keysAlwaysUnicode = wParam != 0;
 		break;
 
 	case SCI_GETKEYSUNICODE:
-		return keysAlwaysUnicode;
+		return true;
+#endif
 
-#ifdef SCI_LEXER
-	case SCI_LOADLEXERLIBRARY:
-		LexerManager::GetInstance()->Load(reinterpret_cast<const char*>(lParam));
-		break;
+	case SCI_SETTECHNOLOGY:
+		if ((wParam == SC_TECHNOLOGY_DEFAULT) ||
+			(wParam == SC_TECHNOLOGY_DIRECTWRITERETAIN) ||
+			(wParam == SC_TECHNOLOGY_DIRECTWRITEDC) ||
+			(wParam == SC_TECHNOLOGY_DIRECTWRITE)) {
+			const int technologyNew = static_cast<int>(wParam);
+			if (technology != technologyNew) {
+				if (technologyNew > SC_TECHNOLOGY_DEFAULT) {
+#if defined(USE_D2D)
+					if (!LoadD2D())
+						// Failed to load Direct2D or DirectWrite so no effect
+						return 0;
+#else
+					return 0;
 #endif
+				} else {
+					bidirectional = EditModel::Bidirectional::bidiDisabled;
+				}
+#if defined(USE_D2D)
+				DropRenderTarget();
+#endif
+				technology = technologyNew;
+				// Invalidate all cached information including layout.
+				DropGraphics(true);
+				InvalidateStyleRedraw();
+			}
+		}
+		break;
 
-	default:
-		return ScintillaBase::WndProc(iMessage, wParam, lParam);
+	case SCI_SETBIDIRECTIONAL:
+		if (technology == SC_TECHNOLOGY_DEFAULT) {
+			bidirectional = EditModel::Bidirectional::bidiDisabled;
+		} else if (wParam <= SC_BIDIRECTIONAL_R2L) {
+			bidirectional = static_cast<EditModel::Bidirectional>(wParam);
+		}
+		// Invalidate all cached information including layout.
+		DropGraphics(true);
+		InvalidateStyleRedraw();
+		break;
+
+	case SCI_TARGETASUTF8:
+		return TargetAsUTF8(CharPtrFromSPtr(lParam));
+
+	case SCI_ENCODEDFROMUTF8:
+		return EncodedFromUTF8(ConstCharPtrFromUPtr(wParam),
+			CharPtrFromSPtr(lParam));
+
+	}
+	return 0;
+}
+
+sptr_t ScintillaWin::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
+	try {
+		//Platform::DebugPrintf("S M:%x WP:%x L:%x\n", iMessage, wParam, lParam);
+		iMessage = SciMessageFromEM(iMessage);
+		switch (iMessage) {
+
+		case WM_CREATE:
+			ctrlID = ::GetDlgCtrlID(HwndFromWindow(wMain));
+			// Get Intellimouse scroll line parameters
+			GetIntelliMouseParameters();
+			::RegisterDragDrop(MainHWND(), reinterpret_cast<IDropTarget *>(&dt));
+			break;
+
+		case WM_COMMAND:
+			Command(LOWORD(wParam));
+			break;
+
+		case WM_PAINT:
+			return WndPaint();
+
+		case WM_PRINTCLIENT: {
+				HDC hdc = reinterpret_cast<HDC>(wParam);
+				if (!IsCompatibleDC(hdc)) {
+					return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+				}
+				FullPaintDC(hdc);
+			}
+			break;
+
+		case WM_VSCROLL:
+			ScrollMessage(wParam);
+			break;
+
+		case WM_HSCROLL:
+			HorizontalScrollMessage(wParam);
+			break;
+
+		case WM_SIZE:
+			SizeWindow();
+			break;
+
+		case WM_TIMER:
+			if (wParam == idleTimerID && idler.state) {
+				SendMessage(MainHWND(), SC_WIN_IDLE, 0, 1);
+			} else {
+				TickFor(static_cast<TickReason>(wParam - fineTimerStart));
+			}
+			break;
+
+		case SC_WIN_IDLE:
+		case SC_WORK_IDLE:
+			return IdleMessage(iMessage, wParam, lParam);
+
+		case WM_GETMINMAXINFO:
+			return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+
+		case WM_LBUTTONDOWN:
+		case WM_LBUTTONUP:
+		case WM_RBUTTONDOWN:
+		case WM_MOUSEMOVE:
+		case WM_MOUSELEAVE:
+		case WM_MOUSEWHEEL:
+			return MouseMessage(iMessage, wParam, lParam);
+
+		case WM_SETCURSOR:
+			if (LOWORD(lParam) == HTCLIENT) {
+				POINT pt;
+				if (::GetCursorPos(&pt)) {
+					::ScreenToClient(MainHWND(), &pt);
+					DisplayCursor(ContextCursor(PointFromPOINT(pt)));
+				}
+				return TRUE;
+			} else {
+				return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+			}
+
+		case WM_SYSKEYDOWN:
+		case WM_KEYDOWN:
+		case WM_KEYUP:
+		case WM_CHAR:
+		case WM_UNICHAR:
+			return KeyMessage(iMessage, wParam, lParam);
+
+		case WM_SETTINGCHANGE:
+			//Platform::DebugPrintf("Setting Changed\n");
+			InvalidateStyleData();
+			// Get Intellimouse scroll line parameters
+			GetIntelliMouseParameters();
+			break;
+
+		case WM_GETDLGCODE:
+			return DLGC_HASSETSEL | DLGC_WANTALLKEYS;
+
+		case WM_KILLFOCUS:
+		case WM_SETFOCUS:
+			return FocusMessage(iMessage, wParam, lParam);
+
+		case WM_SYSCOLORCHANGE:
+			//Platform::DebugPrintf("Setting Changed\n");
+			InvalidateStyleData();
+			break;
+
+		case WM_DPICHANGED:
+			dpi = HIWORD(wParam);
+			InvalidateStyleRedraw();
+			break;
+
+		case WM_DPICHANGED_AFTERPARENT: {
+				const UINT dpiNow = DpiForWindow(wMain.GetID());
+				if (dpi != dpiNow) {
+					dpi = dpiNow;
+					InvalidateStyleRedraw();
+				}
+			}
+			break;
+
+		case WM_CONTEXTMENU:
+			return ShowContextMenu(iMessage, wParam, lParam);
+
+		case WM_ERASEBKGND:
+			return 1;   // Avoid any background erasure as whole window painted.
+
+		case WM_CAPTURECHANGED:
+			capturedMouse = false;
+			return 0;
+
+		// These are not handled in Scintilla and its faster to dispatch them here.
+		// Also moves time out to here so profile doesn't count lots of empty message calls.
+
+		case WM_MOVE:
+		case WM_MOUSEACTIVATE:
+		case WM_NCHITTEST:
+		case WM_NCCALCSIZE:
+		case WM_NCPAINT:
+		case WM_NCMOUSEMOVE:
+		case WM_NCLBUTTONDOWN:
+		case WM_SYSCOMMAND:
+		case WM_WINDOWPOSCHANGING:
+		case WM_WINDOWPOSCHANGED:
+			return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
+
+		case WM_GETTEXTLENGTH:
+			return GetTextLength();
+
+		case WM_GETTEXT:
+			return GetText(wParam, lParam);
+
+		case WM_INPUTLANGCHANGE:
+		case WM_INPUTLANGCHANGEREQUEST:
+		case WM_IME_KEYDOWN:
+		case WM_IME_REQUEST:
+		case WM_IME_STARTCOMPOSITION:
+		case WM_IME_ENDCOMPOSITION:
+		case WM_IME_COMPOSITION:
+		case WM_IME_SETCONTEXT:
+		case WM_IME_NOTIFY:
+			return IMEMessage(iMessage, wParam, lParam);
+
+		case EM_LINEFROMCHAR:
+		case EM_EXLINEFROMCHAR:
+		case EM_GETSEL:
+		case EM_EXGETSEL:
+		case EM_SETSEL:
+		case EM_EXSETSEL:
+			return EditMessage(iMessage, wParam, lParam);
+
+		case SCI_GETDIRECTFUNCTION:
+		case SCI_GETDIRECTPOINTER:
+		case SCI_GRABFOCUS:
+#ifdef INCLUDE_DEPRECATED_FEATURES
+		case SCI_SETKEYSUNICODE:
+		case SCI_GETKEYSUNICODE:
+#endif
+		case SCI_SETTECHNOLOGY:
+		case SCI_SETBIDIRECTIONAL:
+		case SCI_TARGETASUTF8:
+		case SCI_ENCODEDFROMUTF8:
+			return SciMessage(iMessage, wParam, lParam);
+
+		default:
+			return ScintillaBase::WndProc(iMessage, wParam, lParam);
+		}
+	} catch (std::bad_alloc &) {
+		errorStatus = SC_STATUS_BADALLOC;
+	} catch (...) {
+		errorStatus = SC_STATUS_FAILURE;
 	}
-	return 0l;
+	return 0;
 }
 
 bool ScintillaWin::ValidCodePage(int codePage) const {
@@ -1043,27 +2054,35 @@ sptr_t ScintillaWin::DefWndProc(unsigned int iMessage, uptr_t wParam, sptr_t lPa
 	return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
 }
 
-void ScintillaWin::SetTicking(bool on) {
-	if (timer.ticking != on) {
-		timer.ticking = on;
-		if (timer.ticking) {
-			timer.tickerID = ::SetTimer(MainHWND(), standardTimerID, timer.tickSize, NULL)
-				? reinterpret_cast<TickerID>(standardTimerID) : 0;
-		} else {
-			::KillTimer(MainHWND(), reinterpret_cast<uptr_t>(timer.tickerID));
-			timer.tickerID = 0;
-		}
+bool ScintillaWin::FineTickerRunning(TickReason reason) {
+	return timers[reason] != 0;
+}
+
+void ScintillaWin::FineTickerStart(TickReason reason, int millis, int tolerance) {
+	FineTickerCancel(reason);
+	const UINT_PTR eventID = static_cast<UINT_PTR>(fineTimerStart) + reason;
+	if (SetCoalescableTimerFn && tolerance) {
+		timers[reason] = SetCoalescableTimerFn(MainHWND(), eventID, millis, nullptr, tolerance);
+	} else {
+		timers[reason] = ::SetTimer(MainHWND(), eventID, millis, nullptr);
+	}
+}
+
+void ScintillaWin::FineTickerCancel(TickReason reason) {
+	if (timers[reason]) {
+		::KillTimer(MainHWND(), timers[reason]);
+		timers[reason] = 0;
 	}
-	timer.ticksToWait = caret.period;
 }
 
+
 bool ScintillaWin::SetIdle(bool on) {
 	// On Win32 the Idler is implemented as a Timer on the Scintilla window.  This
 	// takes advantage of the fact that WM_TIMER messages are very low priority,
 	// and are only posted when the message queue is empty, i.e. during idle time.
 	if (idler.state != on) {
 		if (on) {
-			idler.idlerID = ::SetTimer(MainHWND(), idleTimerID, 10, NULL)
+			idler.idlerID = ::SetTimer(MainHWND(), idleTimerID, 10, nullptr)
 				? reinterpret_cast<IdlerID>(idleTimerID) : 0;
 		} else {
 			::KillTimer(MainHWND(), reinterpret_cast<uptr_t>(idler.idlerID));
@@ -1074,6 +2093,20 @@ bool ScintillaWin::SetIdle(bool on) {
 	return idler.state;
 }
 
+void ScintillaWin::IdleWork() {
+	styleIdleInQueue = false;
+	Editor::IdleWork();
+}
+
+void ScintillaWin::QueueIdleWork(WorkNeeded::workItems items, Sci::Position upTo) {
+	Editor::QueueIdleWork(items, upTo);
+	if (!styleIdleInQueue) {
+		if (PostMessage(MainHWND(), SC_WORK_IDLE, 0, 0)) {
+			styleIdleInQueue = true;
+		}
+	}
+}
+
 void ScintillaWin::SetMouseCapture(bool on) {
 	if (mouseDownCaptures) {
 		if (on) {
@@ -1091,66 +2124,72 @@ bool ScintillaWin::HaveMouseCapture() {
 	//return capturedMouse && (::GetCapture() == MainHWND());
 }
 
+void ScintillaWin::SetTrackMouseLeaveEvent(bool on) noexcept {
+	if (on && !trackedMouseLeave) {
+		TRACKMOUSEEVENT tme;
+		tme.cbSize = sizeof(tme);
+		tme.dwFlags = TME_LEAVE;
+		tme.hwndTrack = MainHWND();
+		tme.dwHoverTime = HOVER_DEFAULT;	// Unused but triggers Dr. Memory if not initialized
+		TrackMouseEvent(&tme);
+	}
+	trackedMouseLeave = on;
+}
+
 bool ScintillaWin::PaintContains(PRectangle rc) {
-	bool contains = true;
-	if ((paintState == painting) && (!rc.Empty())) {
-		if (!rcPaint.Contains(rc)) {
-			contains = false;
-		} else {
-			// In bounding rectangle so check more accurately using region
-			HRGN hRgnRange = ::CreateRectRgn(rc.left, rc.top, rc.right, rc.bottom);
-			if (hRgnRange) {
-				HRGN hRgnDest = ::CreateRectRgn(0, 0, 0, 0);
-				if (hRgnDest) {
-					int combination = ::CombineRgn(hRgnDest, hRgnRange, hRgnUpdate, RGN_DIFF);
-					if (combination != NULLREGION) {
-						contains = false;
-					}
-					::DeleteRgn(hRgnDest);
-				}
-				::DeleteRgn(hRgnRange);
-			}
-		}
+	if (paintState == painting) {
+		return BoundsContains(rcPaint, hRgnUpdate, rc);
 	}
-	return contains;
+	return true;
 }
 
-void ScintillaWin::ScrollText(int linesToMove) {
+void ScintillaWin::ScrollText(Sci::Line /* linesToMove */) {
 	//Platform::DebugPrintf("ScintillaWin::ScrollText %d\n", linesToMove);
-	::ScrollWindow(MainHWND(), 0,
-		vs.lineHeight * linesToMove, 0, 0);
-	::UpdateWindow(MainHWND());
+	//::ScrollWindow(MainHWND(), 0,
+	//	vs.lineHeight * linesToMove, 0, 0);
+	//::UpdateWindow(MainHWND());
+	Redraw();
+	UpdateSystemCaret();
+}
+
+void ScintillaWin::NotifyCaretMove() {
+	NotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, MainHWND(), OBJID_CARET, CHILDID_SELF);
 }
 
 void ScintillaWin::UpdateSystemCaret() {
 	if (hasFocus) {
+		if (pdoc->TentativeActive()) {
+			// ongoing inline mode IME composition, don't inform IME of system caret position.
+			// fix candidate window for Google Japanese IME moved on typing on Win7.
+			return;
+		}
 		if (HasCaretSizeChanged()) {
 			DestroySystemCaret();
 			CreateSystemCaret();
 		}
-		Point pos = LocationFromPosition(currentPos);
-		::SetCaretPos(pos.x, pos.y);
+		const Point pos = PointMainCaret();
+		::SetCaretPos(static_cast<int>(pos.x), static_cast<int>(pos.y));
 	}
 }
 
-int ScintillaWin::SetScrollInfo(int nBar, LPCSCROLLINFO lpsi, BOOL bRedraw) {
+int ScintillaWin::SetScrollInfo(int nBar, LPCSCROLLINFO lpsi, BOOL bRedraw) noexcept {
 	return ::SetScrollInfo(MainHWND(), nBar, lpsi, bRedraw);
 }
 
-bool ScintillaWin::GetScrollInfo(int nBar, LPSCROLLINFO lpsi) {
+bool ScintillaWin::GetScrollInfo(int nBar, LPSCROLLINFO lpsi) noexcept {
 	return ::GetScrollInfo(MainHWND(), nBar, lpsi) ? true : false;
 }
 
 // Change the scroll position but avoid repaint if changing to same value
-void ScintillaWin::ChangeScrollPos(int barType, int pos) {
+void ScintillaWin::ChangeScrollPos(int barType, Sci::Position pos) {
 	SCROLLINFO sci = {
-		sizeof(sci),0,0,0,0,0,0
+		sizeof(sci), 0, 0, 0, 0, 0, 0
 	};
 	sci.fMask = SIF_POS;
 	GetScrollInfo(barType, &sci);
 	if (sci.nPos != pos) {
 		DwellEnd(true);
-		sci.nPos = pos;
+		sci.nPos = static_cast<int>(pos);
 		SetScrollInfo(barType, &sci, TRUE);
 	}
 }
@@ -1163,44 +2202,42 @@ void ScintillaWin::SetHorizontalScrollPos() {
 	ChangeScrollPos(SB_HORZ, xOffset);
 }
 
-bool ScintillaWin::ModifyScrollBars(int nMax, int nPage) {
+bool ScintillaWin::ModifyScrollBars(Sci::Line nMax, Sci::Line nPage) {
 	bool modified = false;
 	SCROLLINFO sci = {
-		sizeof(sci),0,0,0,0,0,0
+		sizeof(sci), 0, 0, 0, 0, 0, 0
 	};
 	sci.fMask = SIF_PAGE | SIF_RANGE;
 	GetScrollInfo(SB_VERT, &sci);
-	int vertEndPreferred = nMax;
+	const Sci::Line vertEndPreferred = nMax;
 	if (!verticalScrollBarVisible)
-		vertEndPreferred = 0;
+		nPage = vertEndPreferred + 1;
 	if ((sci.nMin != 0) ||
 		(sci.nMax != vertEndPreferred) ||
 	        (sci.nPage != static_cast<unsigned int>(nPage)) ||
 	        (sci.nPos != 0)) {
-		//Platform::DebugPrintf("Scroll info changed %d %d %d %d %d\n",
-		//	sci.nMin, sci.nMax, sci.nPage, sci.nPos, sci.nTrackPos);
 		sci.fMask = SIF_PAGE | SIF_RANGE;
 		sci.nMin = 0;
-		sci.nMax = vertEndPreferred;
-		sci.nPage = nPage;
+		sci.nMax = static_cast<int>(vertEndPreferred);
+		sci.nPage = static_cast<UINT>(nPage);
 		sci.nPos = 0;
 		sci.nTrackPos = 1;
 		SetScrollInfo(SB_VERT, &sci, TRUE);
 		modified = true;
 	}
 
-	PRectangle rcText = GetTextRectangle();
+	const PRectangle rcText = GetTextRectangle();
 	int horizEndPreferred = scrollWidth;
 	if (horizEndPreferred < 0)
 		horizEndPreferred = 0;
-	if (!horizontalScrollBarVisible || (wrapState != eWrapNone))
-		horizEndPreferred = 0;
-	unsigned int pageWidth = rcText.Width();
+	int pageWidth = static_cast<int>(rcText.Width());
+	if (!horizontalScrollBarVisible || Wrapping())
+		pageWidth = horizEndPreferred + 1;
 	sci.fMask = SIF_PAGE | SIF_RANGE;
 	GetScrollInfo(SB_HORZ, &sci);
 	if ((sci.nMin != 0) ||
 		(sci.nMax != horizEndPreferred) ||
-		(sci.nPage != pageWidth) ||
+		(sci.nPage != static_cast<unsigned int>(pageWidth)) ||
 	        (sci.nPos != 0)) {
 		sci.fMask = SIF_PAGE | SIF_RANGE;
 		sci.nMin = 0;
@@ -1210,293 +2247,331 @@ bool ScintillaWin::ModifyScrollBars(int nMax, int nPage) {
 		sci.nTrackPos = 1;
 		SetScrollInfo(SB_HORZ, &sci, TRUE);
 		modified = true;
-		if (scrollWidth < static_cast<int>(pageWidth)) {
+		if (scrollWidth < pageWidth) {
 			HorizontalScrollTo(0);
 		}
 	}
-	return modified;
-}
+	return modified;
+}
+
+void ScintillaWin::NotifyChange() {
+	::SendMessage(::GetParent(MainHWND()), WM_COMMAND,
+	        MAKEWPARAM(GetCtrlID(), SCEN_CHANGE),
+		reinterpret_cast<LPARAM>(MainHWND()));
+}
+
+void ScintillaWin::NotifyFocus(bool focus) {
+	if (commandEvents) {
+		::SendMessage(::GetParent(MainHWND()), WM_COMMAND,
+			MAKEWPARAM(GetCtrlID(), focus ? SCEN_SETFOCUS : SCEN_KILLFOCUS),
+			reinterpret_cast<LPARAM>(MainHWND()));
+	}
+	Editor::NotifyFocus(focus);
+}
+
+void ScintillaWin::SetCtrlID(int identifier) {
+	::SetWindowID(HwndFromWindow(wMain), identifier);
+}
+
+int ScintillaWin::GetCtrlID() {
+	return ::GetDlgCtrlID(HwndFromWindow(wMain));
+}
+
+void ScintillaWin::NotifyParent(SCNotification scn) {
+	scn.nmhdr.hwndFrom = MainHWND();
+	scn.nmhdr.idFrom = GetCtrlID();
+	::SendMessage(::GetParent(MainHWND()), WM_NOTIFY,
+	              GetCtrlID(), reinterpret_cast<LPARAM>(&scn));
+}
+
+void ScintillaWin::NotifyDoubleClick(Point pt, int modifiers) {
+	//Platform::DebugPrintf("ScintillaWin Double click 0\n");
+	ScintillaBase::NotifyDoubleClick(pt, modifiers);
+	// Send myself a WM_LBUTTONDBLCLK, so the container can handle it too.
+	::SendMessage(MainHWND(),
+			  WM_LBUTTONDBLCLK,
+			  (modifiers & SCI_SHIFT) ? MK_SHIFT : 0,
+			  MAKELPARAM(pt.x, pt.y));
+}
+
+class CaseFolderDBCS : public CaseFolderTable {
+	// Allocate the expandable storage here so that it does not need to be reallocated
+	// for each call to Fold.
+	std::vector<wchar_t> utf16Mixed;
+	std::vector<wchar_t> utf16Folded;
+	UINT cp;
+public:
+	explicit CaseFolderDBCS(UINT cp_) : cp(cp_) {
+		StandardASCII();
+	}
+	size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) override {
+		if ((lenMixed == 1) && (sizeFolded > 0)) {
+			folded[0] = mapping[static_cast<unsigned char>(mixed[0])];
+			return 1;
+		} else {
+			if (lenMixed > utf16Mixed.size()) {
+				utf16Mixed.resize(lenMixed + 8);
+			}
+			const size_t nUtf16Mixed = WideCharFromMultiByte(cp,
+				std::string_view(mixed, lenMixed),
+				&utf16Mixed[0],
+				utf16Mixed.size());
+
+			if (nUtf16Mixed == 0) {
+				// Failed to convert -> bad input
+				folded[0] = '\0';
+				return 1;
+			}
+
+			size_t lenFlat = 0;
+			for (size_t mixIndex=0; mixIndex < nUtf16Mixed; mixIndex++) {
+				if ((lenFlat + 20) > utf16Folded.size())
+					utf16Folded.resize(lenFlat + 60);
+				const char *foldedUTF8 = CaseConvert(utf16Mixed[mixIndex], CaseConversionFold);
+				if (foldedUTF8) {
+					// Maximum length of a case conversion is 6 bytes, 3 characters
+					wchar_t wFolded[20];
+					const size_t charsConverted = UTF16FromUTF8(std::string_view(foldedUTF8),
+							wFolded, std::size(wFolded));
+					for (size_t j=0; j<charsConverted; j++)
+						utf16Folded[lenFlat++] = wFolded[j];
+				} else {
+					utf16Folded[lenFlat++] = utf16Mixed[mixIndex];
+				}
+			}
+
+			const std::wstring_view wsvFolded(&utf16Folded[0], lenFlat);
+			const size_t lenOut = MultiByteLenFromWideChar(cp, wsvFolded);
+
+			if (lenOut < sizeFolded) {
+				MultiByteFromWideChar(cp, wsvFolded, folded, lenOut);
+				return lenOut;
+			} else {
+				return 0;
+			}
+		}
+	}
+};
+
+CaseFolder *ScintillaWin::CaseFolderForEncoding() {
+	const UINT cpDest = CodePageOfDocument();
+	if (cpDest == SC_CP_UTF8) {
+		return new CaseFolderUnicode();
+	} else {
+		if (pdoc->dbcsCodePage == 0) {
+			CaseFolderTable *pcf = new CaseFolderTable();
+			pcf->StandardASCII();
+			// Only for single byte encodings
+			for (int i=0x80; i<0x100; i++) {
+				char sCharacter[2] = "A";
+				sCharacter[0] = static_cast<char>(i);
+				wchar_t wCharacter[20];
+				const unsigned int lengthUTF16 = WideCharFromMultiByte(cpDest, sCharacter,
+					wCharacter, std::size(wCharacter));
+				if (lengthUTF16 == 1) {
+					const char *caseFolded = CaseConvert(wCharacter[0], CaseConversionFold);
+					if (caseFolded) {
+						wchar_t wLower[20];
+						const size_t charsConverted = UTF16FromUTF8(std::string_view(caseFolded),
+							wLower, std::size(wLower));
+						if (charsConverted == 1) {
+							char sCharacterLowered[20];
+							const unsigned int lengthConverted = MultiByteFromWideChar(cpDest,
+								std::wstring_view(wLower, charsConverted),
+								sCharacterLowered, std::size(sCharacterLowered));
+							if ((lengthConverted == 1) && (sCharacter[0] != sCharacterLowered[0])) {
+								pcf->SetTranslation(sCharacter[0], sCharacterLowered[0]);
+							}
+						}
+					}
+				}
+			}
+			return pcf;
+		} else {
+			return new CaseFolderDBCS(cpDest);
+		}
+	}
+}
+
+std::string ScintillaWin::CaseMapString(const std::string &s, int caseMapping) {
+	if ((s.size() == 0) || (caseMapping == cmSame))
+		return s;
+
+	const UINT cpDoc = CodePageOfDocument();
+	if (cpDoc == SC_CP_UTF8) {
+		return CaseConvertString(s, (caseMapping == cmUpper) ? CaseConversionUpper : CaseConversionLower);
+	}
 
-void ScintillaWin::NotifyChange() {
-	::SendMessage(::GetParent(MainHWND()), WM_COMMAND,
-	        MAKELONG(GetCtrlID(), SCEN_CHANGE),
-		reinterpret_cast<LPARAM>(MainHWND()));
-}
+	// Change text to UTF-16
+	const std::wstring wsText = StringDecode(s, cpDoc);
 
-void ScintillaWin::NotifyFocus(bool focus) {
-	::SendMessage(::GetParent(MainHWND()), WM_COMMAND,
-	        MAKELONG(GetCtrlID(), focus ? SCEN_SETFOCUS : SCEN_KILLFOCUS),
-		reinterpret_cast<LPARAM>(MainHWND()));
-}
+	const DWORD mapFlags = LCMAP_LINGUISTIC_CASING |
+		((caseMapping == cmUpper) ? LCMAP_UPPERCASE : LCMAP_LOWERCASE);
 
-int ScintillaWin::GetCtrlID() {
-	return ::GetDlgCtrlID(reinterpret_cast<HWND>(wMain.GetID()));
-}
+	// Change case
+	const std::wstring wsConverted = StringMapCase(wsText, mapFlags);
 
-void ScintillaWin::NotifyParent(SCNotification scn) {
-	scn.nmhdr.hwndFrom = MainHWND();
-	scn.nmhdr.idFrom = GetCtrlID();
-	::SendMessage(::GetParent(MainHWND()), WM_NOTIFY,
-	              GetCtrlID(), reinterpret_cast<LPARAM>(&scn));
-}
+	// Change back to document encoding
+	std::string sConverted = StringEncode(wsConverted, cpDoc);
 
-void ScintillaWin::NotifyDoubleClick(Point pt, bool shift, bool ctrl, bool alt) {
-	//Platform::DebugPrintf("ScintillaWin Double click 0\n");
-	ScintillaBase::NotifyDoubleClick(pt, shift, ctrl, alt);
-	// Send myself a WM_LBUTTONDBLCLK, so the container can handle it too.
-	::SendMessage(MainHWND(),
-			  WM_LBUTTONDBLCLK,
-			  shift ? MK_SHIFT : 0,
-			  MAKELPARAM(pt.x, pt.y));
+	return sConverted;
 }
 
 void ScintillaWin::Copy() {
 	//Platform::DebugPrintf("Copy\n");
-	if (currentPos != anchor) {
+	if (!sel.Empty()) {
 		SelectionText selectedText;
 		CopySelectionRange(&selectedText);
 		CopyToClipboard(selectedText);
 	}
 }
 
-void ScintillaWin::CopyAllowLine() {
-	SelectionText selectedText;
-	CopySelectionRange(&selectedText, true);
-	CopyToClipboard(selectedText);
-}
-
 bool ScintillaWin::CanPaste() {
 	if (!Editor::CanPaste())
 		return false;
-	if (::IsClipboardFormatAvailable(CF_TEXT))
-		return true;
-	if (IsUnicodeMode())
-		return ::IsClipboardFormatAvailable(CF_UNICODETEXT) != 0;
-	return false;
+	return ::IsClipboardFormatAvailable(CF_UNICODETEXT) != FALSE;
 }
 
+namespace {
+
 class GlobalMemory {
-	HGLOBAL hand;
+	HGLOBAL hand {};
 public:
-	void *ptr;
-	GlobalMemory() : hand(0), ptr(0) {
+	void *ptr {};
+	GlobalMemory() noexcept {
 	}
-	GlobalMemory(HGLOBAL hand_) : hand(hand_), ptr(0) {
+	explicit GlobalMemory(HGLOBAL hand_) noexcept : hand(hand_) {
 		if (hand) {
 			ptr = ::GlobalLock(hand);
 		}
 	}
+	// Deleted so GlobalMemory objects can not be copied.
+	GlobalMemory(const GlobalMemory &) = delete;
+	GlobalMemory(GlobalMemory &&) = delete;
+	GlobalMemory &operator=(const GlobalMemory &) = delete;
+	GlobalMemory &operator=(GlobalMemory &&) = delete;
 	~GlobalMemory() {
-		PLATFORM_ASSERT(!ptr);
+		assert(!ptr);
+		assert(!hand);
 	}
-	void Allocate(size_t bytes) {
+	void Allocate(size_t bytes) noexcept {
+		assert(!hand);
 		hand = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, bytes);
 		if (hand) {
 			ptr = ::GlobalLock(hand);
 		}
 	}
-	HGLOBAL Unlock() {
-		PLATFORM_ASSERT(ptr);
+	HGLOBAL Unlock() noexcept {
+		assert(ptr);
 		HGLOBAL handCopy = hand;
 		::GlobalUnlock(hand);
-		ptr = 0;
-		hand = 0;
+		ptr = nullptr;
+		hand = {};
 		return handCopy;
 	}
-	void SetClip(UINT uFormat) {
+	void SetClip(UINT uFormat) noexcept {
 		::SetClipboardData(uFormat, Unlock());
 	}
-	operator bool() {
-		return ptr != 0;
+	operator bool() const noexcept {
+		return ptr != nullptr;
 	}
-	SIZE_T Size() {
+	SIZE_T Size() const noexcept {
 		return ::GlobalSize(hand);
 	}
 };
 
-void ScintillaWin::InsertPasteText(const char *text, int len, int selStart, bool isRectangular, bool isLine) {
-	if (isRectangular) {
-		PasteRectangular(selStart, text, len);
-	} else {
-		char *convertedText = 0;
-		if (convertPastes) {
-			// Convert line endings of the paste into our local line-endings mode
-			convertedText = Document::TransformLineEnds(&len, text, len, pdoc->eolMode);
-			text = convertedText;
-		}
-		if (isLine) {
-			int insertPos = pdoc->LineStart(pdoc->LineFromPosition(currentPos));
-			pdoc->InsertString(insertPos, text, len);
-			// add the newline if necessary
-			if ((len > 0) && (text[len-1] != '\n' && text[len-1] != '\r')) {
-				const char *endline = StringFromEOLMode(pdoc->eolMode);
-				pdoc->InsertString(insertPos + len, endline, strlen(endline));
-				len += strlen(endline);
-			}
-			if (currentPos == insertPos) {
-				SetEmptySelection(currentPos + len);
-			}
-		} else if (pdoc->InsertString(currentPos, text, len)) {
-			SetEmptySelection(currentPos + len);
+// OpenClipboard may fail if another application has opened the clipboard.
+// Try up to 8 times, with an initial delay of 1 ms and an exponential back off
+// for a maximum total delay of 127 ms (1+2+4+8+16+32+64).
+bool OpenClipboardRetry(HWND hwnd) noexcept {
+	for (int attempt=0; attempt<8; attempt++) {
+		if (attempt > 0) {
+			::Sleep(1 << (attempt-1));
+		}
+		if (::OpenClipboard(hwnd)) {
+			return true;
 		}
-		delete []convertedText;
 	}
+	return false;
+}
+
+bool IsValidFormatEtc(const FORMATETC *pFE) noexcept {
+	return pFE->ptd == nullptr &&
+		(pFE->dwAspect & DVASPECT_CONTENT) != 0 &&
+		pFE->lindex == -1 &&
+		(pFE->tymed & TYMED_HGLOBAL) != 0;
+}
+
+bool SupportedFormat(const FORMATETC *pFE) noexcept {
+	return pFE->cfFormat == CF_UNICODETEXT &&
+		IsValidFormatEtc(pFE);
+}
+
 }
 
 void ScintillaWin::Paste() {
-	if (!::OpenClipboard(MainHWND()))
+	if (!::OpenClipboardRetry(MainHWND())) {
 		return;
-	pdoc->BeginUndoAction();
-	bool isLine = SelectionEmpty() && (::IsClipboardFormatAvailable(cfLineSelect) != 0);
-	ClearSelection();
-	int selStart = SelectionStart();
-	bool isRectangular = ::IsClipboardFormatAvailable(cfColumnSelect) != 0;
+	}
+	UndoGroup ug(pdoc);
+	const bool isLine = SelectionEmpty() &&
+		(::IsClipboardFormatAvailable(cfLineSelect) || ::IsClipboardFormatAvailable(cfVSLineTag));
+	ClearSelection(multiPasteMode == SC_MULTIPASTE_EACH);
+	bool isRectangular = (::IsClipboardFormatAvailable(cfColumnSelect) != 0);
+
+	if (!isRectangular) {
+		// Evaluate "Borland IDE Block Type" explicitly
+		GlobalMemory memBorlandSelection(::GetClipboardData(cfBorlandIDEBlockType));
+		if (memBorlandSelection) {
+			isRectangular = (memBorlandSelection.Size() == 1) && (static_cast<BYTE *>(memBorlandSelection.ptr)[0] == 0x02);
+			memBorlandSelection.Unlock();
+		}
+	}
+	const PasteShape pasteShape = isRectangular ? pasteRectangular : (isLine ? pasteLine : pasteStream);
 
-	// Always use CF_UNICODETEXT if available
+	// Use CF_UNICODETEXT if available
 	GlobalMemory memUSelection(::GetClipboardData(CF_UNICODETEXT));
-	if (memUSelection) {
-		wchar_t *uptr = static_cast<wchar_t *>(memUSelection.ptr);
-		if (uptr) {
-			unsigned int len;
-			char *putf;
-			// Default Scintilla behaviour in Unicode mode
-			if (IsUnicodeMode()) {
-				unsigned int bytes = memUSelection.Size();
-				len = UTF8Length(uptr, bytes / 2);
-				putf = new char[len + 1];
-				if (putf) {
-					UTF8FromUTF16(uptr, bytes / 2, putf, len);
-				}
-			} else {
-				// CF_UNICODETEXT available, but not in Unicode mode
-				// Convert from Unicode to current Scintilla code page
-				UINT cpDest = CodePageFromCharSet(
-					vs.styles[STYLE_DEFAULT].characterSet, pdoc->dbcsCodePage);
-				len = ::WideCharToMultiByte(cpDest, 0, uptr, -1,
-				                            NULL, 0, NULL, NULL) - 1; // subtract 0 terminator
-				putf = new char[len + 1];
-				if (putf) {
-					::WideCharToMultiByte(cpDest, 0, uptr, -1,
-					                      putf, len + 1, NULL, NULL);
-				}
-			}
-
-			if (putf) {
-				InsertPasteText(putf, len, selStart, isRectangular, isLine);
-				delete []putf;
-			}
-		}
+	if (const wchar_t *uptr = static_cast<const wchar_t *>(memUSelection.ptr)) {
+		const std::string putf = EncodeWString(uptr);
+		InsertPasteShape(putf.c_str(), putf.length(), pasteShape);
 		memUSelection.Unlock();
-	} else {
-		// CF_UNICODETEXT not available, paste ANSI text
-		GlobalMemory memSelection(::GetClipboardData(CF_TEXT));
-		if (memSelection) {
-			char *ptr = static_cast<char *>(memSelection.ptr);
-			if (ptr) {
-				unsigned int bytes = memSelection.Size();
-				unsigned int len = bytes;
-				for (unsigned int i = 0; i < bytes; i++) {
-					if ((len == bytes) && (0 == ptr[i]))
-						len = i;
-				}
-
-				// In Unicode mode, convert clipboard text to UTF-8
-				if (IsUnicodeMode()) {
-					wchar_t *uptr = new wchar_t[len+1];
-
-					unsigned int ulen = ::MultiByteToWideChar(CP_ACP, 0,
-					                    ptr, len, uptr, len+1);
-
-					unsigned int mlen = UTF8Length(uptr, ulen);
-					char *putf = new char[mlen + 1];
-					if (putf) {
-						// CP_UTF8 not available on Windows 95, so use UTF8FromUTF16()
-						UTF8FromUTF16(uptr, ulen, putf, mlen);
-					}
-
-					delete []uptr;
-
-					if (putf) {
-						InsertPasteText(putf, mlen, selStart, isRectangular, isLine);
-						delete []putf;
-					}
-				} else {
-					InsertPasteText(ptr, len, selStart, isRectangular, isLine);
-				}
-			}
-			memSelection.Unlock();
-		}
 	}
 	::CloseClipboard();
-	pdoc->EndUndoAction();
-	NotifyChange();
 	Redraw();
 }
 
 void ScintillaWin::CreateCallTipWindow(PRectangle) {
-#ifdef TOTAL_CONTROL
 	if (!ct.wCallTip.Created()) {
-		ct.wCallTip = ::CreateWindow(callClassName, TEXT("ACallTip"),
+		HWND wnd = ::CreateWindow(callClassName, TEXT("ACallTip"),
 					     WS_POPUP, 100, 100, 150, 20,
 					     MainHWND(), 0,
 					     GetWindowInstance(MainHWND()),
 					     this);
-		ct.wDraw = ct.wCallTip;
+		ct.wCallTip = wnd;
+		ct.wDraw = wnd;
 	}
-#endif
 }
 
 void ScintillaWin::AddToPopUp(const char *label, int cmd, bool enabled) {
-#ifdef TOTAL_CONTROL
-	HMENU hmenuPopup = reinterpret_cast<HMENU>(popup.GetID());
+	HMENU hmenuPopup = static_cast<HMENU>(popup.GetID());
 	if (!label[0])
 		::AppendMenuA(hmenuPopup, MF_SEPARATOR, 0, "");
 	else if (enabled)
 		::AppendMenuA(hmenuPopup, MF_STRING, cmd, label);
 	else
 		::AppendMenuA(hmenuPopup, MF_STRING | MF_DISABLED | MF_GRAYED, cmd, label);
-#endif
 }
 
 void ScintillaWin::ClaimSelection() {
 	// Windows does not have a primary selection
 }
 
-#ifdef SCI_LEXER
-
-/*
-
-  Initial Windows-Only implementation of the external lexer
-  system in ScintillaWin class. Intention is to create a LexerModule
-  subclass (?) to have lex and fold methods which will call out to their
-  relevant DLLs...
-
-*/
-
-void ScintillaWin::SetLexer(uptr_t wParam) {
-	lexLanguage = wParam;
-	lexCurrent = LexerModule::Find(lexLanguage);
-	if (!lexCurrent)
-		lexCurrent = LexerModule::Find(SCLEX_NULL);
-}
-
-void ScintillaWin::SetLexerLanguage(const char *languageName) {
-	lexLanguage = SCLEX_CONTAINER;
-	lexCurrent = LexerModule::Find(languageName);
-	if (!lexCurrent)
-		lexCurrent = LexerModule::Find(SCLEX_NULL);
-	if (lexCurrent)
-		lexLanguage = lexCurrent->GetLanguage();
-}
-
-#endif
-
 /// Implement IUnknown
 
 STDMETHODIMP_(ULONG)FormatEnumerator_AddRef(FormatEnumerator *fe);
 STDMETHODIMP FormatEnumerator_QueryInterface(FormatEnumerator *fe, REFIID riid, PVOID *ppv) {
 	//Platform::DebugPrintf("EFE QI");
-	*ppv = NULL;
+	*ppv = nullptr;
 	if (riid == IID_IUnknown)
 		*ppv = reinterpret_cast<IEnumFORMATETC *>(fe);
 	if (riid == IID_IEnumFORMATETC)
@@ -1518,16 +2593,15 @@ STDMETHODIMP_(ULONG)FormatEnumerator_Release(FormatEnumerator *fe) {
 }
 /// Implement IEnumFORMATETC
 STDMETHODIMP FormatEnumerator_Next(FormatEnumerator *fe, ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched) {
-	//Platform::DebugPrintf("EFE Next %d %d", fe->pos, celt);
-	if (rgelt == NULL) return E_POINTER;
-	// We only support one format, so this is simple.
-	unsigned int putPos = 0;
-	while ((fe->pos < fe->formatsLen) && (putPos < celt)) {
+	if (!rgelt) return E_POINTER;
+	ULONG putPos = 0;
+	while ((fe->pos < fe->formats.size()) && (putPos < celt)) {
 		rgelt->cfFormat = fe->formats[fe->pos];
-		rgelt->ptd = 0;
+		rgelt->ptd = nullptr;
 		rgelt->dwAspect = DVASPECT_CONTENT;
 		rgelt->lindex = -1;
 		rgelt->tymed = TYMED_HGLOBAL;
+		rgelt++;
 		fe->pos++;
 		putPos++;
 	}
@@ -1544,28 +2618,31 @@ STDMETHODIMP FormatEnumerator_Reset(FormatEnumerator *fe) {
 	return S_OK;
 }
 STDMETHODIMP FormatEnumerator_Clone(FormatEnumerator *fe, IEnumFORMATETC **ppenum) {
-	FormatEnumerator *pfe = new FormatEnumerator(fe->pos, fe->formats, fe->formatsLen);
+	FormatEnumerator *pfe;
+	try {
+		pfe = new FormatEnumerator(fe->pos, &fe->formats[0], fe->formats.size());
+	} catch (...) {
+		return E_OUTOFMEMORY;
+	}
 	return FormatEnumerator_QueryInterface(pfe, IID_IEnumFORMATETC,
 	                                       reinterpret_cast<void **>(ppenum));
 }
 
-static void *vtFormatEnumerator[] = {
-	(void *)(FormatEnumerator_QueryInterface),
-	(void *)(FormatEnumerator_AddRef),
-	(void *)(FormatEnumerator_Release),
-	(void *)(FormatEnumerator_Next),
-	(void *)(FormatEnumerator_Skip),
-	(void *)(FormatEnumerator_Reset),
-	(void *)(FormatEnumerator_Clone)
+static VFunction *vtFormatEnumerator[] = {
+	(VFunction *)(FormatEnumerator_QueryInterface),
+	(VFunction *)(FormatEnumerator_AddRef),
+	(VFunction *)(FormatEnumerator_Release),
+	(VFunction *)(FormatEnumerator_Next),
+	(VFunction *)(FormatEnumerator_Skip),
+	(VFunction *)(FormatEnumerator_Reset),
+	(VFunction *)(FormatEnumerator_Clone)
 };
 
-FormatEnumerator::FormatEnumerator(int pos_, CLIPFORMAT formats_[], int formatsLen_) {
+FormatEnumerator::FormatEnumerator(ULONG pos_, const CLIPFORMAT formats_[], size_t formatsLen_) {
 	vtbl = vtFormatEnumerator;
 	ref = 0;   // First QI adds first reference...
 	pos = pos_;
-	formatsLen = formatsLen_;
-	for (int i=0;i<formatsLen;i++)
-		formats[i] = formats_[i];
+	formats.insert(formats.begin(), formats_, formats_+formatsLen_);
 }
 
 /// Implement IUnknown
@@ -1592,17 +2669,17 @@ STDMETHODIMP DropSource_GiveFeedback(DropSource *, DWORD) {
 	return DRAGDROP_S_USEDEFAULTCURSORS;
 }
 
-static void *vtDropSource[] = {
-	(void *)(DropSource_QueryInterface),
-	(void *)(DropSource_AddRef),
-	(void *)(DropSource_Release),
-	(void *)(DropSource_QueryContinueDrag),
-	(void *)(DropSource_GiveFeedback)
+static VFunction *vtDropSource[] = {
+	(VFunction *)(DropSource_QueryInterface),
+	(VFunction *)(DropSource_AddRef),
+	(VFunction *)(DropSource_Release),
+	(VFunction *)(DropSource_QueryContinueDrag),
+	(VFunction *)(DropSource_GiveFeedback)
 };
 
-DropSource::DropSource() {
+DropSource::DropSource() noexcept {
 	vtbl = vtDropSource;
-	sci = 0;
+	sci = nullptr;
 }
 
 /// Implement IUnkown
@@ -1627,38 +2704,21 @@ STDMETHODIMP DataObject_GetDataHere(DataObject *, FORMATETC *, STGMEDIUM *) {
 }
 
 STDMETHODIMP DataObject_QueryGetData(DataObject *pd, FORMATETC *pFE) {
-	if (pd->sci->DragIsRectangularOK(pFE->cfFormat) &&
-	    pFE->ptd == 0 &&
-	    (pFE->dwAspect & DVASPECT_CONTENT) != 0 &&
-	    pFE->lindex == -1 &&
-	    (pFE->tymed & TYMED_HGLOBAL) != 0
-	) {
+	if (pd->sci->DragIsRectangularOK(pFE->cfFormat) && IsValidFormatEtc(pFE)) {
 		return S_OK;
 	}
 
-	bool formatOK = (pFE->cfFormat == CF_TEXT) ||
-		((pFE->cfFormat == CF_UNICODETEXT) && pd->sci->IsUnicodeMode());
-	if (!formatOK ||
-	    pFE->ptd != 0 ||
-	    (pFE->dwAspect & DVASPECT_CONTENT) == 0 ||
-	    pFE->lindex != -1 ||
-	    (pFE->tymed & TYMED_HGLOBAL) == 0
-	) {
-		//Platform::DebugPrintf("DOB QueryGetData No %x\n",pFE->cfFormat);
-		//return DATA_E_FORMATETC;
+	if (SupportedFormat(pFE)) {
+		return S_OK;
+	} else {
 		return S_FALSE;
 	}
-	//Platform::DebugPrintf("DOB QueryGetData OK %x\n",pFE->cfFormat);
-	return S_OK;
 }
 
-STDMETHODIMP DataObject_GetCanonicalFormatEtc(DataObject *pd, FORMATETC *, FORMATETC *pFEOut) {
+STDMETHODIMP DataObject_GetCanonicalFormatEtc(DataObject *, FORMATETC *, FORMATETC *pFEOut) {
 	//Platform::DebugPrintf("DOB GetCanon\n");
-	if (pd->sci->IsUnicodeMode())
-		pFEOut->cfFormat = CF_UNICODETEXT;
-	else
-		pFEOut->cfFormat = CF_TEXT;
-	pFEOut->ptd = 0;
+	pFEOut->cfFormat = CF_UNICODETEXT;
+	pFEOut->ptd = nullptr;
 	pFEOut->dwAspect = DVASPECT_CONTENT;
 	pFEOut->lindex = -1;
 	pFEOut->tymed = TYMED_HGLOBAL;
@@ -1671,21 +2731,24 @@ STDMETHODIMP DataObject_SetData(DataObject *, FORMATETC *, STGMEDIUM *, BOOL) {
 }
 
 STDMETHODIMP DataObject_EnumFormatEtc(DataObject *pd, DWORD dwDirection, IEnumFORMATETC **ppEnum) {
-	//Platform::DebugPrintf("DOB EnumFormatEtc %d\n", dwDirection);
-	if (dwDirection != DATADIR_GET) {
-		*ppEnum = 0;
+	try {
+		//Platform::DebugPrintf("DOB EnumFormatEtc %d\n", dwDirection);
+		if (dwDirection != DATADIR_GET) {
+			*ppEnum = nullptr;
+			return E_FAIL;
+		}
+
+		const CLIPFORMAT formats[] = {CF_UNICODETEXT};
+		FormatEnumerator *pfe = new FormatEnumerator(0, formats, std::size(formats));
+		return FormatEnumerator_QueryInterface(pfe, IID_IEnumFORMATETC,
+											   reinterpret_cast<void **>(ppEnum));
+	} catch (std::bad_alloc &) {
+		pd->sci->errorStatus = SC_STATUS_BADALLOC;
+		return E_OUTOFMEMORY;
+	} catch (...) {
+		pd->sci->errorStatus = SC_STATUS_FAILURE;
 		return E_FAIL;
 	}
-	FormatEnumerator *pfe;
-	if (pd->sci->IsUnicodeMode()) {
-		CLIPFORMAT formats[] = {CF_UNICODETEXT, CF_TEXT};
-		pfe = new FormatEnumerator(0, formats, 2);
-	} else {
-		CLIPFORMAT formats[] = {CF_TEXT};
-		pfe = new FormatEnumerator(0, formats, 1);
-	}
-	return FormatEnumerator_QueryInterface(pfe, IID_IEnumFORMATETC,
-	                                       reinterpret_cast<void **>(ppEnum));
 }
 
 STDMETHODIMP DataObject_DAdvise(DataObject *, FORMATETC *, DWORD, IAdviseSink *, PDWORD) {
@@ -1703,24 +2766,24 @@ STDMETHODIMP DataObject_EnumDAdvise(DataObject *, IEnumSTATDATA **) {
 	return E_FAIL;
 }
 
-static void *vtDataObject[] = {
-	(void *)(DataObject_QueryInterface),
-	(void *)(DataObject_AddRef),
-	(void *)(DataObject_Release),
-	(void *)(DataObject_GetData),
-	(void *)(DataObject_GetDataHere),
-	(void *)(DataObject_QueryGetData),
-	(void *)(DataObject_GetCanonicalFormatEtc),
-	(void *)(DataObject_SetData),
-	(void *)(DataObject_EnumFormatEtc),
-	(void *)(DataObject_DAdvise),
-	(void *)(DataObject_DUnadvise),
-	(void *)(DataObject_EnumDAdvise)
+static VFunction *vtDataObject[] = {
+	(VFunction *)(DataObject_QueryInterface),
+	(VFunction *)(DataObject_AddRef),
+	(VFunction *)(DataObject_Release),
+	(VFunction *)(DataObject_GetData),
+	(VFunction *)(DataObject_GetDataHere),
+	(VFunction *)(DataObject_QueryGetData),
+	(VFunction *)(DataObject_GetCanonicalFormatEtc),
+	(VFunction *)(DataObject_SetData),
+	(VFunction *)(DataObject_EnumFormatEtc),
+	(VFunction *)(DataObject_DAdvise),
+	(VFunction *)(DataObject_DUnadvise),
+	(VFunction *)(DataObject_EnumDAdvise)
 };
 
-DataObject::DataObject() {
+DataObject::DataObject() noexcept {
 	vtbl = vtDataObject;
-	sci = 0;
+	sci = nullptr;
 }
 
 /// Implement IUnknown
@@ -1738,32 +2801,52 @@ STDMETHODIMP_(ULONG)DropTarget_Release(DropTarget *dt) {
 /// Implement IDropTarget by forwarding to Scintilla
 STDMETHODIMP DropTarget_DragEnter(DropTarget *dt, LPDATAOBJECT pIDataSource, DWORD grfKeyState,
                                   POINTL pt, PDWORD pdwEffect) {
-	return dt->sci->DragEnter(pIDataSource, grfKeyState, pt, pdwEffect);
+	try {
+		return dt->sci->DragEnter(pIDataSource, grfKeyState, pt, pdwEffect);
+	} catch (...) {
+		dt->sci->errorStatus = SC_STATUS_FAILURE;
+	}
+	return E_FAIL;
 }
 STDMETHODIMP DropTarget_DragOver(DropTarget *dt, DWORD grfKeyState, POINTL pt, PDWORD pdwEffect) {
-	return dt->sci->DragOver(grfKeyState, pt, pdwEffect);
+	try {
+		return dt->sci->DragOver(grfKeyState, pt, pdwEffect);
+	} catch (...) {
+		dt->sci->errorStatus = SC_STATUS_FAILURE;
+	}
+	return E_FAIL;
 }
 STDMETHODIMP DropTarget_DragLeave(DropTarget *dt) {
-	return dt->sci->DragLeave();
+	try {
+		return dt->sci->DragLeave();
+	} catch (...) {
+		dt->sci->errorStatus = SC_STATUS_FAILURE;
+	}
+	return E_FAIL;
 }
 STDMETHODIMP DropTarget_Drop(DropTarget *dt, LPDATAOBJECT pIDataSource, DWORD grfKeyState,
                              POINTL pt, PDWORD pdwEffect) {
-	return dt->sci->Drop(pIDataSource, grfKeyState, pt, pdwEffect);
+	try {
+		return dt->sci->Drop(pIDataSource, grfKeyState, pt, pdwEffect);
+	} catch (...) {
+		dt->sci->errorStatus = SC_STATUS_FAILURE;
+	}
+	return E_FAIL;
 }
 
-static void *vtDropTarget[] = {
-	(void *)(DropTarget_QueryInterface),
-	(void *)(DropTarget_AddRef),
-	(void *)(DropTarget_Release),
-	(void *)(DropTarget_DragEnter),
-	(void *)(DropTarget_DragOver),
-	(void *)(DropTarget_DragLeave),
-	(void *)(DropTarget_Drop)
+static VFunction *vtDropTarget[] = {
+	(VFunction *)(DropTarget_QueryInterface),
+	(VFunction *)(DropTarget_AddRef),
+	(VFunction *)(DropTarget_Release),
+	(VFunction *)(DropTarget_DragEnter),
+	(VFunction *)(DropTarget_DragOver),
+	(VFunction *)(DropTarget_DragLeave),
+	(VFunction *)(DropTarget_Drop)
 };
 
-DropTarget::DropTarget() {
+DropTarget::DropTarget() noexcept {
 	vtbl = vtDropTarget;
-	sci = 0;
+	sci = nullptr;
 }
 
 /**
@@ -1771,150 +2854,187 @@ DropTarget::DropTarget() {
  * Called when IME Window opened.
  */
 void ScintillaWin::ImeStartComposition() {
-#ifndef __DMC__
-	// Digital Mars compiler does not include Imm library
 	if (caret.active) {
 		// Move IME Window to current caret position
-		HIMC hIMC = ::ImmGetContext(MainHWND());
-		Point pos = LocationFromPosition(currentPos);
+		IMContext imc(MainHWND());
+		const Point pos = PointMainCaret();
 		COMPOSITIONFORM CompForm;
 		CompForm.dwStyle = CFS_POINT;
-		CompForm.ptCurrentPos.x = pos.x;
-		CompForm.ptCurrentPos.y = pos.y;
+		CompForm.ptCurrentPos = POINTFromPoint(pos);
 
-		::ImmSetCompositionWindow(hIMC, &CompForm);
+		::ImmSetCompositionWindow(imc.hIMC, &CompForm);
 
 		// Set font of IME window to same as surrounded text.
 		if (stylesValid) {
 			// Since the style creation code has been made platform independent,
 			// The logfont for the IME is recreated here.
-			int styleHere = (pdoc->StyleAt(currentPos)) & 31;
-			LOGFONTA lf = {0,0,0,0,0,0,0,0,0,0,0,0,0, ""};
-			int sizeZoomed = vs.styles[styleHere].size + vs.zoomLevel;
-			if (sizeZoomed <= 2)	// Hangs if sizeZoomed <= 1
-				sizeZoomed = 2;
-			AutoSurface surface(this);
-			int deviceHeight = sizeZoomed;
-			if (surface) {
-				deviceHeight = (sizeZoomed * surface->LogPixelsY()) / 72;
-			}
+			const int styleHere = pdoc->StyleIndexAt(sel.MainCaret());
+			LOGFONTW lf = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, L""};
+			int sizeZoomed = vs.styles[styleHere].size + vs.zoomLevel * SC_FONT_SIZE_MULTIPLIER;
+			if (sizeZoomed <= 2 * SC_FONT_SIZE_MULTIPLIER)	// Hangs if sizeZoomed <= 1
+				sizeZoomed = 2 * SC_FONT_SIZE_MULTIPLIER;
 			// The negative is to allow for leading
-			lf.lfHeight = -(abs(deviceHeight));
-			lf.lfWeight = vs.styles[styleHere].bold ? FW_BOLD : FW_NORMAL;
-			lf.lfItalic = static_cast<BYTE>(vs.styles[styleHere].italic ? 1 : 0);
+			lf.lfHeight = -::MulDiv(sizeZoomed, dpi, 72*SC_FONT_SIZE_MULTIPLIER);
+			lf.lfWeight = vs.styles[styleHere].weight;
+			lf.lfItalic = vs.styles[styleHere].italic ? 1 : 0;
 			lf.lfCharSet = DEFAULT_CHARSET;
-			lf.lfFaceName[0] = '\0';
-			if (vs.styles[styleHere].fontName)
-				strcpy(lf.lfFaceName, vs.styles[styleHere].fontName);
+			lf.lfFaceName[0] = L'\0';
+			if (vs.styles[styleHere].fontName) {
+				const char* fontName = vs.styles[styleHere].fontName;
+				UTF16FromUTF8(std::string_view(fontName), lf.lfFaceName, LF_FACESIZE);
+			}
 
-			::ImmSetCompositionFontA(hIMC, &lf);
+			::ImmSetCompositionFontW(imc.hIMC, &lf);
 		}
-		::ImmReleaseContext(MainHWND(), hIMC);
 		// Caret is displayed in IME window. So, caret in Scintilla is useless.
 		DropCaret();
 	}
-#endif
 }
 
 /** Called when IME Window closed. */
 void ScintillaWin::ImeEndComposition() {
+	// clear IME composition state.
+	view.imeCaretBlockOverride = false;
+	pdoc->TentativeUndo();
 	ShowCaretAtCurrentPosition();
 }
 
-void ScintillaWin::AddCharBytes(char b0, char b1) {
+LRESULT ScintillaWin::ImeOnReconvert(LPARAM lParam) {
+	// Reconversion on windows limits within one line without eol.
+	// Look around:   baseStart  <--  (|mainStart|  -- mainEnd)  --> baseEnd.
+	const Sci::Position mainStart = sel.RangeMain().Start().Position();
+	const Sci::Position mainEnd = sel.RangeMain().End().Position();
+	const Sci::Line curLine = pdoc->SciLineFromPosition(mainStart);
+	if (curLine != pdoc->LineFromPosition(mainEnd))
+		return 0;
+	const Sci::Position baseStart = pdoc->LineStart(curLine);
+	const Sci::Position baseEnd = pdoc->LineEnd(curLine);
+	if ((baseStart == baseEnd) || (mainEnd > baseEnd))
+		return 0;
+
+	const int codePage = CodePageOfDocument();
+	const std::wstring rcFeed = StringDecode(RangeText(baseStart, baseEnd), codePage);
+	const int rcFeedLen = static_cast<int>(rcFeed.length()) * sizeof(wchar_t);
+	const int rcSize = sizeof(RECONVERTSTRING) + rcFeedLen + sizeof(wchar_t);
+
+	RECONVERTSTRING *rc = static_cast<RECONVERTSTRING *>(PtrFromSPtr(lParam));
+	if (!rc)
+		return rcSize; // Immediately be back with rcSize of memory block.
+
+	wchar_t *rcFeedStart = reinterpret_cast<wchar_t*>(rc + 1);
+	memcpy(rcFeedStart, &rcFeed[0], rcFeedLen);
+
+	std::string rcCompString = RangeText(mainStart, mainEnd);
+	std::wstring rcCompWstring = StringDecode(rcCompString, codePage);
+	std::string rcCompStart = RangeText(baseStart, mainStart);
+	std::wstring rcCompWstart = StringDecode(rcCompStart, codePage);
+
+	// Map selection to dwCompStr.
+	// No selection assumes current caret as rcCompString without length.
+	rc->dwVersion = 0; // It should be absolutely 0.
+	rc->dwStrLen = static_cast<DWORD>(rcFeed.length());
+	rc->dwStrOffset = sizeof(RECONVERTSTRING);
+	rc->dwCompStrLen = static_cast<DWORD>(rcCompWstring.length());
+	rc->dwCompStrOffset = static_cast<DWORD>(rcCompWstart.length()) * sizeof(wchar_t);
+	rc->dwTargetStrLen = rc->dwCompStrLen;
+	rc->dwTargetStrOffset =rc->dwCompStrOffset;
+
+	IMContext imc(MainHWND());
+	if (!imc.hIMC)
+		return 0;
+
+	if (!::ImmSetCompositionStringW(imc.hIMC, SCS_QUERYRECONVERTSTRING, rc, rcSize, nullptr, 0))
+		return 0;
+
+	// No selection asks IME to fill target fields with its own value.
+	const int tgWlen = rc->dwTargetStrLen;
+	const int tgWstart = rc->dwTargetStrOffset / sizeof(wchar_t);
 
-	int inputCodePage = InputCodePage();
-	if (inputCodePage && IsUnicodeMode()) {
-		char utfval[4]="\0\0\0";
-		char ansiChars[3];
-		wchar_t wcs[2];
-		if (b0) {	// Two bytes from IME
-			ansiChars[0] = b0;
-			ansiChars[1] = b1;
-			ansiChars[2] = '\0';
-			::MultiByteToWideChar(inputCodePage, 0, ansiChars, 2, wcs, 1);
+	std::string tgCompStart = StringEncode(rcFeed.substr(0, tgWstart), codePage);
+	std::string tgComp = StringEncode(rcFeed.substr(tgWstart, tgWlen), codePage);
+
+	// No selection needs to adjust reconvert start position for IME set.
+	const int adjust = static_cast<int>(tgCompStart.length() - rcCompStart.length());
+	const int docCompLen = static_cast<int>(tgComp.length());
+
+	// Make place for next composition string to sit in.
+	for (size_t r=0; r<sel.Count(); r++) {
+		const Sci::Position rBase = sel.Range(r).Start().Position();
+		const Sci::Position docCompStart = rBase + adjust;
+
+		if (inOverstrike) { // the docCompLen of bytes will be overstriked.
+			sel.Range(r).caret.SetPosition(docCompStart);
+			sel.Range(r).anchor.SetPosition(docCompStart);
 		} else {
-			ansiChars[0] = b1;
-			ansiChars[1] = '\0';
-			::MultiByteToWideChar(inputCodePage, 0, ansiChars, 1, wcs, 1);
-		}
-		unsigned int len = UTF8Length(wcs, 1);
-		UTF8FromUTF16(wcs, 1, utfval, len);
-		utfval[len] = '\0';
-		AddCharUTF(utfval, len ? len : 1);
-	} else if (b0) {
-		char dbcsChars[3];
-		dbcsChars[0] = b0;
-		dbcsChars[1] = b1;
-		dbcsChars[2] = '\0';
-		AddCharUTF(dbcsChars, 2, true);
-	} else {
-		AddChar(b1);
+			// Ensure docCompStart+docCompLen be not beyond lineEnd.
+			// since docCompLen by byte might break eol.
+			const Sci::Position lineEnd = pdoc->LineEnd(pdoc->LineFromPosition(rBase));
+			const Sci::Position overflow = (docCompStart + docCompLen) - lineEnd;
+			if (overflow > 0) {
+				pdoc->DeleteChars(docCompStart, docCompLen - overflow);
+			} else {
+				pdoc->DeleteChars(docCompStart, docCompLen);
+			}
+		}
 	}
+	// Immediately Target Input or candidate box choice with GCS_COMPSTR.
+	return rcSize;
 }
 
-void ScintillaWin::GetIntelliMouseParameters() {
-	// This retrieves the number of lines per scroll as configured inthe Mouse Properties sheet in Control Panel
+void ScintillaWin::GetIntelliMouseParameters() noexcept {
+	// This retrieves the number of lines per scroll as configured in the Mouse Properties sheet in Control Panel
 	::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &linesPerScroll, 0);
 }
 
-void ScintillaWin::CopyToClipboard(const SelectionText &selectedText) {
-	if (!::OpenClipboard(MainHWND()))
-		return ;
-	::EmptyClipboard();
-
-	GlobalMemory uniText;
-
-	// Default Scintilla behaviour in Unicode mode
+void ScintillaWin::CopyToGlobal(GlobalMemory &gmUnicode, const SelectionText &selectedText) {
+	const std::string_view svSelected(selectedText.Data(), selectedText.LengthWithTerminator());
 	if (IsUnicodeMode()) {
-		int uchars = UTF16Length(selectedText.s, selectedText.len);
-		uniText.Allocate(2 * uchars);
-		if (uniText) {
-			UTF16FromUTF8(selectedText.s, selectedText.len, static_cast<wchar_t *>(uniText.ptr), uchars);
+		const size_t uchars = UTF16Length(svSelected);
+		gmUnicode.Allocate(2 * uchars);
+		if (gmUnicode) {
+			UTF16FromUTF8(svSelected,
+				static_cast<wchar_t *>(gmUnicode.ptr), uchars);
 		}
 	} else {
 		// Not Unicode mode
 		// Convert to Unicode using the current Scintilla code page
-		UINT cpSrc = CodePageFromCharSet(
-					selectedText.characterSet, selectedText.codePage);
-		uniText.Allocate(2 * selectedText.len);
-		if (uniText) {
-			::MultiByteToWideChar(cpSrc, 0, selectedText.s, selectedText.len,
-				static_cast<wchar_t *>(uniText.ptr), selectedText.len);
+		const UINT cpSrc = CodePageFromCharSet(
+			selectedText.characterSet, selectedText.codePage);
+		const size_t uLen = WideCharLenFromMultiByte(cpSrc, svSelected);
+		gmUnicode.Allocate(2 * uLen);
+		if (gmUnicode) {
+			WideCharFromMultiByte(cpSrc, svSelected,
+				static_cast<wchar_t *>(gmUnicode.ptr), uLen);
 		}
 	}
+}
+
+void ScintillaWin::CopyToClipboard(const SelectionText &selectedText) {
+	if (!::OpenClipboardRetry(MainHWND())) {
+		return;
+	}
+	::EmptyClipboard();
 
+	GlobalMemory uniText;
+	CopyToGlobal(uniText, selectedText);
 	if (uniText) {
-		if (!IsNT()) {
-			// Copy ANSI text to clipboard on Windows 9x
-			// Convert from Unicode text, so other ANSI programs can
-			// paste the text
-			// Windows NT, 2k, XP automatically generates CF_TEXT
-			GlobalMemory ansiText;
-			ansiText.Allocate(selectedText.len);
-			if (ansiText) {
-				::WideCharToMultiByte(CP_ACP, 0, static_cast<wchar_t *>(uniText.ptr), -1,
-					static_cast<char *>(ansiText.ptr), selectedText.len, NULL, NULL);
-				ansiText.SetClip(CF_TEXT);
-			}
-		}
 		uniText.SetClip(CF_UNICODETEXT);
-	} else {
-		// There was a failure - try to copy at least ANSI text
-		GlobalMemory ansiText;
-		ansiText.Allocate(selectedText.len);
-		if (ansiText) {
-			memcpy(static_cast<char *>(ansiText.ptr), selectedText.s, selectedText.len);
-			ansiText.SetClip(CF_TEXT);
-		}
 	}
 
 	if (selectedText.rectangular) {
 		::SetClipboardData(cfColumnSelect, 0);
+
+		GlobalMemory borlandSelection;
+		borlandSelection.Allocate(1);
+		if (borlandSelection) {
+			static_cast<BYTE *>(borlandSelection.ptr)[0] = 0x02;
+			borlandSelection.SetClip(cfBorlandIDEBlockType);
+		}
 	}
 
 	if (selectedText.lineCopy) {
 		::SetClipboardData(cfLineSelect, 0);
+		::SetClipboardData(cfVSLineTag, 0);
 	}
 
 	::CloseClipboard();
@@ -1924,8 +3044,7 @@ void ScintillaWin::ScrollMessage(WPARAM wParam) {
 	//DWORD dwStart = timeGetTime();
 	//Platform::DebugPrintf("Scroll %x %d\n", wParam, lParam);
 
-	SCROLLINFO sci;
-	memset(&sci, 0, sizeof(sci));
+	SCROLLINFO sci = {};
 	sci.cbSize = sizeof(sci);
 	sci.fMask = SIF_ALL;
 
@@ -1933,9 +3052,8 @@ void ScintillaWin::ScrollMessage(WPARAM wParam) {
 
 	//Platform::DebugPrintf("ScrollInfo %d mask=%x min=%d max=%d page=%d pos=%d track=%d\n", b,sci.fMask,
 	//sci.nMin, sci.nMax, sci.nPage, sci.nPos, sci.nTrackPos);
-
-	int topLineNew = topLine;
-	switch (LoWord(wParam)) {
+	Sci::Line topLineNew = topLine;
+	switch (LOWORD(wParam)) {
 	case SB_LINEUP:
 		topLineNew -= 1;
 		break;
@@ -1955,9 +3073,9 @@ void ScintillaWin::ScrollMessage(WPARAM wParam) {
 
 void ScintillaWin::HorizontalScrollMessage(WPARAM wParam) {
 	int xPos = xOffset;
-	PRectangle rcText = GetTextRectangle();
-	int pageWidth = rcText.Width() * 2 / 3;
-	switch (LoWord(wParam)) {
+	const PRectangle rcText = GetTextRectangle();
+	const int pageWidth = static_cast<int>(rcText.Width() * 2 / 3);
+	switch (LOWORD(wParam)) {
 	case SB_LINEUP:
 		xPos -= 20;
 		break;
@@ -1970,7 +3088,7 @@ void ScintillaWin::HorizontalScrollMessage(WPARAM wParam) {
 	case SB_PAGEDOWN:
 		xPos += pageWidth;
 		if (xPos > scrollWidth - rcText.Width()) {	// Hit the end exactly
-			xPos = scrollWidth - rcText.Width();
+			xPos = scrollWidth - static_cast<int>(rcText.Width());
 		}
 		break;
 	case SB_TOP:
@@ -1994,29 +3112,18 @@ void ScintillaWin::HorizontalScrollMessage(WPARAM wParam) {
 	HorizontalScrollTo(xPos);
 }
 
-void ScintillaWin::RealizeWindowPalette(bool inBackGround) {
-	RefreshStyleData();
-	HDC hdc = ::GetDC(MainHWND());
-	// Select a stock font to prevent warnings from BoundsChecker
-	::SelectObject(hdc, GetStockFont(DEFAULT_GUI_FONT));
-	AutoSurface surfaceWindow(hdc, this);
-	if (surfaceWindow) {
-		int changes = surfaceWindow->SetPalette(&palette, inBackGround);
-		if (changes > 0)
-			Redraw();
-		surfaceWindow->Release();
-	}
-	::ReleaseDC(MainHWND(), hdc);
-}
-
 /**
  * Redraw all of text area.
  * This paint will not be abandoned.
  */
 void ScintillaWin::FullPaint() {
-	HDC hdc = ::GetDC(MainHWND());
-	FullPaintDC(hdc);
-	::ReleaseDC(MainHWND(), hdc);
+	if ((technology == SC_TECHNOLOGY_DEFAULT) || (technology == SC_TECHNOLOGY_DIRECTWRITEDC)) {
+		HDC hdc = ::GetDC(MainHWND());
+		FullPaintDC(hdc);
+		::ReleaseDC(MainHWND(), hdc);
+	} else {
+		FullPaintDC({});
+	}
 }
 
 /**
@@ -2027,21 +3134,21 @@ void ScintillaWin::FullPaintDC(HDC hdc) {
 	paintState = painting;
 	rcPaint = GetClientRectangle();
 	paintingAllText = true;
-	AutoSurface surfaceWindow(hdc, this);
-	if (surfaceWindow) {
-		Paint(surfaceWindow, rcPaint);
-		surfaceWindow->Release();
-	}
+	PaintDC(hdc);
 	paintState = notPainting;
 }
 
-static bool CompareDevCap(HDC hdc, HDC hOtherDC, int nIndex) {
+namespace {
+
+bool CompareDevCap(HDC hdc, HDC hOtherDC, int nIndex) noexcept {
 	return ::GetDeviceCaps(hdc, nIndex) == ::GetDeviceCaps(hOtherDC, nIndex);
 }
 
-bool ScintillaWin::IsCompatibleDC(HDC hOtherDC) {
+}
+
+bool ScintillaWin::IsCompatibleDC(HDC hOtherDC) noexcept {
 	HDC hdc = ::GetDC(MainHWND());
-	bool isCompatible =
+	const bool isCompatible =
 		CompareDevCap(hdc, hOtherDC, TECHNOLOGY) &&
 		CompareDevCap(hdc, hOtherDC, LOGPIXELSY) &&
 		CompareDevCap(hdc, hOtherDC, LOGPIXELSX) &&
@@ -2051,7 +3158,7 @@ bool ScintillaWin::IsCompatibleDC(HDC hOtherDC) {
 	return isCompatible;
 }
 
-DWORD ScintillaWin::EffectFromState(DWORD grfKeyState) {
+DWORD ScintillaWin::EffectFromState(DWORD grfKeyState) const noexcept {
 	// These are the Wordpad semantics.
 	DWORD dwEffect;
 	if (inDragDrop == ddDragging)	// Internal defaults to move
@@ -2067,7 +3174,7 @@ DWORD ScintillaWin::EffectFromState(DWORD grfKeyState) {
 
 /// Implement IUnknown
 STDMETHODIMP ScintillaWin::QueryInterface(REFIID riid, PVOID *ppv) {
-	*ppv = NULL;
+	*ppv = nullptr;
 	if (riid == IID_IUnknown)
 		*ppv = reinterpret_cast<IDropTarget *>(&dt);
 	if (riid == IID_IDropSource)
@@ -2092,238 +3199,172 @@ STDMETHODIMP_(ULONG) ScintillaWin::Release() {
 /// Implement IDropTarget
 STDMETHODIMP ScintillaWin::DragEnter(LPDATAOBJECT pIDataSource, DWORD grfKeyState,
                                      POINTL, PDWORD pdwEffect) {
-	if (pIDataSource == NULL)
+	if (!pIDataSource )
 		return E_POINTER;
-	FORMATETC fmtu = {CF_UNICODETEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
-	HRESULT hrHasUText = pIDataSource->QueryGetData(&fmtu);
+	FORMATETC fmtu = {CF_UNICODETEXT, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
+	const HRESULT hrHasUText = pIDataSource->QueryGetData(&fmtu);
 	hasOKText = (hrHasUText == S_OK);
-	if (!hasOKText) {
-		FORMATETC fmte = {CF_TEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
-		HRESULT hrHasText = pIDataSource->QueryGetData(&fmte);
-		hasOKText = (hrHasText == S_OK);
-	}
-	if (!hasOKText) {
+	if (hasOKText) {
+		*pdwEffect = EffectFromState(grfKeyState);
+	} else {
 		*pdwEffect = DROPEFFECT_NONE;
-		return S_OK;
 	}
 
-	*pdwEffect = EffectFromState(grfKeyState);
 	return S_OK;
 }
 
 STDMETHODIMP ScintillaWin::DragOver(DWORD grfKeyState, POINTL pt, PDWORD pdwEffect) {
-	if (!hasOKText || pdoc->IsReadOnly()) {
-		*pdwEffect = DROPEFFECT_NONE;
-		return S_OK;
-	}
+	try {
+		if (!hasOKText || pdoc->IsReadOnly()) {
+			*pdwEffect = DROPEFFECT_NONE;
+			return S_OK;
+		}
 
-	*pdwEffect = EffectFromState(grfKeyState);
+		*pdwEffect = EffectFromState(grfKeyState);
 
-	// Update the cursor.
-	POINT rpt = {pt.x, pt.y};
-	::ScreenToClient(MainHWND(), &rpt);
-	SetDragPosition(PositionFromLocation(Point(rpt.x, rpt.y)));
+		// Update the cursor.
+		POINT rpt = {pt.x, pt.y};
+		::ScreenToClient(MainHWND(), &rpt);
+		SetDragPosition(SPositionFromLocation(PointFromPOINT(rpt), false, false, UserVirtualSpace()));
 
-	return S_OK;
+		return S_OK;
+	} catch (...) {
+		errorStatus = SC_STATUS_FAILURE;
+	}
+	return E_FAIL;
 }
 
 STDMETHODIMP ScintillaWin::DragLeave() {
-	SetDragPosition(invalidPosition);
-	return S_OK;
+	try {
+		SetDragPosition(SelectionPosition(Sci::invalidPosition));
+		return S_OK;
+	} catch (...) {
+		errorStatus = SC_STATUS_FAILURE;
+	}
+	return E_FAIL;
 }
 
 STDMETHODIMP ScintillaWin::Drop(LPDATAOBJECT pIDataSource, DWORD grfKeyState,
                                 POINTL pt, PDWORD pdwEffect) {
-	*pdwEffect = EffectFromState(grfKeyState);
+	try {
+		*pdwEffect = EffectFromState(grfKeyState);
 
-	if (pIDataSource == NULL)
-		return E_POINTER;
+		if (!pIDataSource)
+			return E_POINTER;
 
-	SetDragPosition(invalidPosition);
-
-	STGMEDIUM medium={0,{0},0};
-
-	char *data = 0;
-	bool dataAllocated = false;
-
-	FORMATETC fmtu = {CF_UNICODETEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
-	HRESULT hr = pIDataSource->GetData(&fmtu, &medium);
-	if (SUCCEEDED(hr) && medium.hGlobal) {
-		wchar_t *udata = static_cast<wchar_t *>(::GlobalLock(medium.hGlobal));
-		if (IsUnicodeMode()) {
-			int tlen = ::GlobalSize(medium.hGlobal);
-			// Convert UTF-16 to UTF-8
-			int dataLen = UTF8Length(udata, tlen/2);
-			data = new char[dataLen+1];
-			if (data) {
-				UTF8FromUTF16(udata, tlen/2, data, dataLen);
-				dataAllocated = true;
-			}
-		} else {
-			// Convert UTF-16 to ANSI
-			//
-			// Default Scintilla behavior in Unicode mode
-			// CF_UNICODETEXT available, but not in Unicode mode
-			// Convert from Unicode to current Scintilla code page
-			UINT cpDest = CodePageFromCharSet(
-				vs.styles[STYLE_DEFAULT].characterSet, pdoc->dbcsCodePage);
-			int tlen = ::WideCharToMultiByte(cpDest, 0, udata, -1,
-				NULL, 0, NULL, NULL) - 1; // subtract 0 terminator
-			data = new char[tlen + 1];
-			if (data) {
-				memset(data, 0, (tlen+1));
-				::WideCharToMultiByte(cpDest, 0, udata, -1,
-						data, tlen + 1, NULL, NULL);
-				dataAllocated = true;
+		SetDragPosition(SelectionPosition(Sci::invalidPosition));
+
+		std::string putf;
+		FORMATETC fmtu = {CF_UNICODETEXT, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
+		STGMEDIUM medium{};
+		const HRESULT hr = pIDataSource->GetData(&fmtu, &medium);
+		if (!SUCCEEDED(hr)) {
+			return hr;
+		}
+		if (medium.hGlobal) {
+			GlobalMemory memUDrop(medium.hGlobal);
+			if (const wchar_t *uptr = static_cast<const wchar_t *>(memUDrop.ptr)) {
+				putf = EncodeWString(uptr);
 			}
+			memUDrop.Unlock();
 		}
-	}
 
-	if (!data) {
-		FORMATETC fmte = {CF_TEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
-		hr = pIDataSource->GetData(&fmte, &medium);
-		if (SUCCEEDED(hr) && medium.hGlobal) {
-			data = static_cast<char *>(::GlobalLock(medium.hGlobal));
+		if (putf.empty()) {
+			return S_OK;
 		}
-	}
-
-	if (!data) {
-		//Platform::DebugPrintf("Bad data format: 0x%x\n", hres);
-		return hr;
-	}
-
-	FORMATETC fmtr = {cfColumnSelect, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
-	HRESULT hrRectangular = pIDataSource->QueryGetData(&fmtr);
-
-	POINT rpt = {pt.x, pt.y};
-	::ScreenToClient(MainHWND(), &rpt);
-	int movePos = PositionFromLocation(Point(rpt.x, rpt.y));
 
-	DropAt(movePos, data, *pdwEffect == DROPEFFECT_MOVE, hrRectangular == S_OK);
+		FORMATETC fmtr = {cfColumnSelect, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
+		const bool isRectangular = S_OK == pIDataSource->QueryGetData(&fmtr);
 
-	::GlobalUnlock(medium.hGlobal);
+		POINT rpt = {pt.x, pt.y};
+		::ScreenToClient(MainHWND(), &rpt);
+		const SelectionPosition movePos = SPositionFromLocation(PointFromPOINT(rpt), false, false, UserVirtualSpace());
 
-	// Free data
-	if (medium.pUnkForRelease != NULL)
-		medium.pUnkForRelease->Release();
-	else
-		::GlobalFree(medium.hGlobal);
+		DropAt(movePos, putf.c_str(), putf.size(), *pdwEffect == DROPEFFECT_MOVE, isRectangular);
 
-	if (dataAllocated)
-		delete []data;
+		// Free data
+		::ReleaseStgMedium(&medium);
 
-	return S_OK;
+		return S_OK;
+	} catch (...) {
+		errorStatus = SC_STATUS_FAILURE;
+	}
+	return E_FAIL;
 }
 
 /// Implement important part of IDataObject
 STDMETHODIMP ScintillaWin::GetData(FORMATETC *pFEIn, STGMEDIUM *pSTM) {
-	bool formatOK = (pFEIn->cfFormat == CF_TEXT) ||
-		((pFEIn->cfFormat == CF_UNICODETEXT) && IsUnicodeMode());
-	if (!formatOK ||
-	    pFEIn->ptd != 0 ||
-	    (pFEIn->dwAspect & DVASPECT_CONTENT) == 0 ||
-	    pFEIn->lindex != -1 ||
-	    (pFEIn->tymed & TYMED_HGLOBAL) == 0
-	) {
+	if (!SupportedFormat(pFEIn)) {
 		//Platform::DebugPrintf("DOB GetData No %d %x %x fmt=%x\n", lenDrag, pFEIn, pSTM, pFEIn->cfFormat);
 		return DATA_E_FORMATETC;
 	}
+
 	pSTM->tymed = TYMED_HGLOBAL;
 	//Platform::DebugPrintf("DOB GetData OK %d %x %x\n", lenDrag, pFEIn, pSTM);
 
-	GlobalMemory text;
-	if (pFEIn->cfFormat == CF_UNICODETEXT) {
-		int uchars = UTF16Length(drag.s, drag.len);
-		text.Allocate(2 * uchars);
-		if (text) {
-			UTF16FromUTF8(drag.s, drag.len, static_cast<wchar_t *>(text.ptr), uchars);
-		}
-	} else {
-		text.Allocate(drag.len);
-		if (text) {
-			memcpy(static_cast<char *>(text.ptr), drag.s, drag.len);
-		}
-	}
-	pSTM->hGlobal = text ? text.Unlock() : 0;
-	pSTM->pUnkForRelease = 0;
+	GlobalMemory uniText;
+	CopyToGlobal(uniText, drag);
+	pSTM->hGlobal = uniText ? uniText.Unlock() : 0;
+	pSTM->pUnkForRelease = nullptr;
 	return S_OK;
 }
 
-bool ScintillaWin::Register(HINSTANCE hInstance_) {
+void ScintillaWin::Prepare() noexcept {
+	Platform_Initialise(hInstance);
+
+	// Register the CallTip class
+	WNDCLASSEX wndclassc{};
+	wndclassc.cbSize = sizeof(wndclassc);
+	wndclassc.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
+	wndclassc.cbWndExtra = sizeof(ScintillaWin *);
+	wndclassc.hInstance = hInstance;
+	wndclassc.lpfnWndProc = ScintillaWin::CTWndProc;
+	wndclassc.hCursor = ::LoadCursor(NULL, IDC_ARROW);
+	wndclassc.lpszClassName = callClassName;
+
+	callClassAtom = ::RegisterClassEx(&wndclassc);
+}
+
+bool ScintillaWin::Register(HINSTANCE hInstance_) noexcept {
 
 	hInstance = hInstance_;
-	bool result;
 
 	// Register the Scintilla class
-	if (IsNT()) {
-
-		// Register Scintilla as a wide character window
-		WNDCLASSEXW wndclass;
-		wndclass.cbSize = sizeof(wndclass);
-		wndclass.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
-		wndclass.lpfnWndProc = ScintillaWin::SWndProc;
-		wndclass.cbClsExtra = 0;
-		wndclass.cbWndExtra = sizeof(ScintillaWin *);
-		wndclass.hInstance = hInstance;
-		wndclass.hIcon = NULL;
-		wndclass.hCursor = NULL;
-		wndclass.hbrBackground = NULL;
-		wndclass.lpszMenuName = NULL;
-		wndclass.lpszClassName = L"Scintilla";
-		wndclass.hIconSm = 0;
-		result = ::RegisterClassExW(&wndclass) != 0;
-	} else {
-
-		// Register Scintilla as a normal character window
-		WNDCLASSEX wndclass;
-		wndclass.cbSize = sizeof(wndclass);
-		wndclass.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
-		wndclass.lpfnWndProc = ScintillaWin::SWndProc;
-		wndclass.cbClsExtra = 0;
-		wndclass.cbWndExtra = sizeof(ScintillaWin *);
-		wndclass.hInstance = hInstance;
-		wndclass.hIcon = NULL;
-		wndclass.hCursor = NULL;
-		wndclass.hbrBackground = NULL;
-		wndclass.lpszMenuName = NULL;
-		wndclass.lpszClassName = scintillaClassName;
-		wndclass.hIconSm = 0;
-		result = ::RegisterClassEx(&wndclass) != 0;
-	}
-
-	if (result) {
-		// Register the CallTip class
-		WNDCLASSEX wndclassc;
-		wndclassc.cbSize = sizeof(wndclassc);
-		wndclassc.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
-		wndclassc.cbClsExtra = 0;
-		wndclassc.cbWndExtra = sizeof(ScintillaWin *);
-		wndclassc.hInstance = hInstance;
-		wndclassc.hIcon = NULL;
-		wndclassc.hbrBackground = NULL;
-		wndclassc.lpszMenuName = NULL;
-		wndclassc.lpfnWndProc = ScintillaWin::CTWndProc;
-		wndclassc.hCursor = ::LoadCursor(NULL, IDC_ARROW);
-		wndclassc.lpszClassName = callClassName;
-		wndclassc.hIconSm = 0;
-
-		result = ::RegisterClassEx(&wndclassc) != 0;
-	}
+	// Register Scintilla as a wide character window
+	WNDCLASSEXW wndclass {};
+	wndclass.cbSize = sizeof(wndclass);
+	wndclass.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
+	wndclass.lpfnWndProc = ScintillaWin::SWndProc;
+	wndclass.cbWndExtra = sizeof(ScintillaWin *);
+	wndclass.hInstance = hInstance;
+	wndclass.lpszClassName = L"Scintilla";
+	scintillaClassAtom = ::RegisterClassExW(&wndclass);
+	const bool result = 0 != scintillaClassAtom;
 
 	return result;
 }
 
-bool ScintillaWin::Unregister() {
-	bool result = ::UnregisterClass(scintillaClassName, hInstance) != 0;
-	if (::UnregisterClass(callClassName, hInstance) == 0)
-		result = false;
+bool ScintillaWin::Unregister() noexcept {
+	bool result = true;
+	if (0 != scintillaClassAtom) {
+		if (::UnregisterClass(MAKEINTATOM(scintillaClassAtom), hInstance) == 0) {
+			result = false;
+		}
+		scintillaClassAtom = 0;
+	}
+	if (0 != callClassAtom) {
+		if (::UnregisterClass(MAKEINTATOM(callClassAtom), hInstance) == 0) {
+			result = false;
+		}
+		callClassAtom = 0;
+	}
 	return result;
 }
 
-bool ScintillaWin::HasCaretSizeChanged() {
+bool ScintillaWin::HasCaretSizeChanged() const noexcept {
 	if (
 		( (0 != vs.caretWidth) && (sysCaretWidth != vs.caretWidth) )
-		|| (0 != vs.lineHeight) && (sysCaretHeight != vs.lineHeight)
+		|| ((0 != vs.lineHeight) && (sysCaretHeight != vs.lineHeight))
 		) {
 		return true;
 	}
@@ -2336,140 +3377,175 @@ BOOL ScintillaWin::CreateSystemCaret() {
 		sysCaretWidth = 1;
 	}
 	sysCaretHeight = vs.lineHeight;
-	int bitmapSize = (((sysCaretWidth + 15) & ~15) >> 3) *
+	const int bitmapSize = (((sysCaretWidth + 15) & ~15) >> 3) *
 		sysCaretHeight;
-	char *bits = new char[bitmapSize];
-	memset(bits, 0, bitmapSize);
+	std::vector<BYTE> bits(bitmapSize);
 	sysCaretBitmap = ::CreateBitmap(sysCaretWidth, sysCaretHeight, 1,
-		1, reinterpret_cast<BYTE *>(bits));
-	delete []bits;
-	BOOL retval = ::CreateCaret(
+		1, &bits[0]);
+	const BOOL retval = ::CreateCaret(
 		MainHWND(), sysCaretBitmap,
 		sysCaretWidth, sysCaretHeight);
-	::ShowCaret(MainHWND());
+	if (technology == SC_TECHNOLOGY_DEFAULT) {
+		// System caret interferes with Direct2D drawing so only show it for GDI.
+		::ShowCaret(MainHWND());
+	}
 	return retval;
 }
 
-BOOL ScintillaWin::DestroySystemCaret() {
+BOOL ScintillaWin::DestroySystemCaret() noexcept {
 	::HideCaret(MainHWND());
-	BOOL retval = ::DestroyCaret();
+	const BOOL retval = ::DestroyCaret();
 	if (sysCaretBitmap) {
 		::DeleteObject(sysCaretBitmap);
-		sysCaretBitmap = 0;
+		sysCaretBitmap = {};
 	}
 	return retval;
 }
 
-// Take care of 32/64 bit pointers
-#ifdef GetWindowLongPtr
-static void *PointerFromWindow(HWND hWnd) {
-	return reinterpret_cast<void *>(::GetWindowLongPtr(hWnd, 0));
-}
-static void SetWindowPointer(HWND hWnd, void *ptr) {
-	::SetWindowLongPtr(hWnd, 0, reinterpret_cast<LONG_PTR>(ptr));
-}
-#else
-static void *PointerFromWindow(HWND hWnd) {
-	return reinterpret_cast<void *>(::GetWindowLong(hWnd, 0));
-}
-static void SetWindowPointer(HWND hWnd, void *ptr) {
-	::SetWindowLong(hWnd, 0, reinterpret_cast<LONG>(ptr));
-}
-#endif
-
-sptr_t PASCAL ScintillaWin::CTWndProc(
-    HWND hWnd, UINT iMessage, WPARAM wParam, sptr_t lParam) {
-
+LRESULT PASCAL ScintillaWin::CTWndProc(
+	HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
 	// Find C++ object associated with window.
-	ScintillaWin *sciThis = reinterpret_cast<ScintillaWin *>(PointerFromWindow(hWnd));
-	// ctp will be zero if WM_CREATE not seen yet
-	if (sciThis == 0) {
-		if (iMessage == WM_CREATE) {
-			// Associate CallTip object with window
-			CREATESTRUCT *pCreate = reinterpret_cast<CREATESTRUCT *>(lParam);
-			SetWindowPointer(hWnd, pCreate->lpCreateParams);
-			return 0;
+	ScintillaWin *sciThis = static_cast<ScintillaWin *>(PointerFromWindow(hWnd));
+	try {
+		// ctp will be zero if WM_CREATE not seen yet
+		if (sciThis == nullptr) {
+			if (iMessage == WM_CREATE) {
+				// Associate CallTip object with window
+				CREATESTRUCT *pCreate = static_cast<CREATESTRUCT *>(PtrFromSPtr(lParam));
+				SetWindowPointer(hWnd, pCreate->lpCreateParams);
+				return 0;
+			} else {
+				return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+			}
 		} else {
-			return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
-		}
-	} else {
-		if (iMessage == WM_NCDESTROY) {
-			::SetWindowLong(hWnd, 0, 0);
-			return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
-		} else if (iMessage == WM_PAINT) {
-			PAINTSTRUCT ps;
-			::BeginPaint(hWnd, &ps);
-			Surface *surfaceWindow = Surface::Allocate();
-			if (surfaceWindow) {
-				surfaceWindow->Init(ps.hdc, hWnd);
+			if (iMessage == WM_NCDESTROY) {
+				SetWindowPointer(hWnd, nullptr);
+				return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+			} else if (iMessage == WM_PAINT) {
+				PAINTSTRUCT ps;
+				::BeginPaint(hWnd, &ps);
+				std::unique_ptr<Surface> surfaceWindow(Surface::Allocate(sciThis->technology));
+#if defined(USE_D2D)
+				ID2D1HwndRenderTarget *pCTRenderTarget = nullptr;
+#endif
+				RECT rc;
+				GetClientRect(hWnd, &rc);
+				// Create a Direct2D render target.
+				if (sciThis->technology == SC_TECHNOLOGY_DEFAULT) {
+					surfaceWindow->Init(ps.hdc, hWnd);
+				} else {
+#if defined(USE_D2D)
+					D2D1_HWND_RENDER_TARGET_PROPERTIES dhrtp;
+					dhrtp.hwnd = hWnd;
+					dhrtp.pixelSize = D2D1::SizeU(rc.right - rc.left, rc.bottom - rc.top);
+					dhrtp.presentOptions = (sciThis->technology == SC_TECHNOLOGY_DIRECTWRITERETAIN) ?
+						D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS : D2D1_PRESENT_OPTIONS_NONE;
+
+					D2D1_RENDER_TARGET_PROPERTIES drtp;
+					drtp.type = D2D1_RENDER_TARGET_TYPE_DEFAULT;
+					drtp.pixelFormat.format = DXGI_FORMAT_UNKNOWN;
+					drtp.pixelFormat.alphaMode = D2D1_ALPHA_MODE_UNKNOWN;
+					drtp.dpiX = 96.0;
+					drtp.dpiY = 96.0;
+					drtp.usage = D2D1_RENDER_TARGET_USAGE_NONE;
+					drtp.minLevel = D2D1_FEATURE_LEVEL_DEFAULT;
+
+					if (!SUCCEEDED(pD2DFactory->CreateHwndRenderTarget(drtp, dhrtp, &pCTRenderTarget))) {
+						surfaceWindow->Release();
+						::EndPaint(hWnd, &ps);
+						return 0;
+					}
+					// If above SUCCEEDED, then pCTRenderTarget not nullptr
+					assert(pCTRenderTarget);
+					if (pCTRenderTarget) {
+						surfaceWindow->Init(pCTRenderTarget, hWnd);
+						pCTRenderTarget->BeginDraw();
+					}
+#endif
+				}
 				surfaceWindow->SetUnicodeMode(SC_CP_UTF8 == sciThis->ct.codePage);
 				surfaceWindow->SetDBCSMode(sciThis->ct.codePage);
-				sciThis->ct.PaintCT(surfaceWindow);
+				surfaceWindow->SetBidiR2L(sciThis->BidirectionalR2L());
+				sciThis->ct.PaintCT(surfaceWindow.get());
+#if defined(USE_D2D)
+				if (pCTRenderTarget)
+					pCTRenderTarget->EndDraw();
+#endif
 				surfaceWindow->Release();
-				delete surfaceWindow;
+#if defined(USE_D2D)
+				ReleaseUnknown(pCTRenderTarget);
+#endif
+				::EndPaint(hWnd, &ps);
+				return 0;
+			} else if ((iMessage == WM_NCLBUTTONDOWN) || (iMessage == WM_NCLBUTTONDBLCLK)) {
+				POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
+				ScreenToClient(hWnd, &pt);
+				sciThis->ct.MouseClick(PointFromPOINT(pt));
+				sciThis->CallTipClick();
+				return 0;
+			} else if (iMessage == WM_LBUTTONDOWN) {
+				// This does not fire due to the hit test code
+				sciThis->ct.MouseClick(PointFromLParam(lParam));
+				sciThis->CallTipClick();
+				return 0;
+			} else if (iMessage == WM_SETCURSOR) {
+				::SetCursor(::LoadCursor(NULL, IDC_ARROW));
+				return 0;
+			} else if (iMessage == WM_NCHITTEST) {
+				return HTCAPTION;
+			} else {
+				return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 			}
-			::EndPaint(hWnd, &ps);
-			return 0;
-		} else if ((iMessage == WM_NCLBUTTONDOWN) || (iMessage == WM_NCLBUTTONDBLCLK)) {
-			POINT pt;
-			pt.x = static_cast<short>(LOWORD(lParam));
-			pt.y = static_cast<short>(HIWORD(lParam));
-			ScreenToClient(hWnd, &pt);
-			sciThis->ct.MouseClick(Point(pt.x, pt.y));
-			sciThis->CallTipClick();
-			return 0;
-		} else if (iMessage == WM_LBUTTONDOWN) {
-			// This does not fire due to the hit test code
-			sciThis->ct.MouseClick(Point::FromLong(lParam));
-			sciThis->CallTipClick();
-			return 0;
-		} else if (iMessage == WM_SETCURSOR) {
-			::SetCursor(::LoadCursor(NULL,IDC_ARROW));
-			return 0;
-		} else if (iMessage == WM_NCHITTEST) {
-			return HTCAPTION;
-		} else {
-			return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 		}
+	} catch (...) {
+		sciThis->errorStatus = SC_STATUS_FAILURE;
 	}
+	return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 }
 
 sptr_t ScintillaWin::DirectFunction(
-    ScintillaWin *sci, UINT iMessage, uptr_t wParam, sptr_t lParam) {
-	PLATFORM_ASSERT(::GetCurrentThreadId() == ::GetWindowThreadProcessId(sci->MainHWND(), NULL));
-	return sci->WndProc(iMessage, wParam, lParam);
+    sptr_t ptr, UINT iMessage, uptr_t wParam, sptr_t lParam) {
+	PLATFORM_ASSERT(::GetCurrentThreadId() == ::GetWindowThreadProcessId(reinterpret_cast<ScintillaWin *>(ptr)->MainHWND(), nullptr));
+	return reinterpret_cast<ScintillaWin *>(ptr)->WndProc(iMessage, wParam, lParam);
 }
 
-extern "C"
-#ifndef STATIC_BUILD
-__declspec(dllexport)
-#endif
-sptr_t __stdcall Scintilla_DirectFunction(
+namespace Scintilla {
+
+sptr_t DirectFunction(
     ScintillaWin *sci, UINT iMessage, uptr_t wParam, sptr_t lParam) {
 	return sci->WndProc(iMessage, wParam, lParam);
 }
 
-sptr_t PASCAL ScintillaWin::SWndProc(
-    HWND hWnd, UINT iMessage, WPARAM wParam, sptr_t lParam) {
+}
+
+LRESULT PASCAL ScintillaWin::SWndProc(
+	HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam) {
 	//Platform::DebugPrintf("S W:%x M:%x WP:%x L:%x\n", hWnd, iMessage, wParam, lParam);
 
 	// Find C++ object associated with window.
-	ScintillaWin *sci = reinterpret_cast<ScintillaWin *>(PointerFromWindow(hWnd));
+	ScintillaWin *sci = static_cast<ScintillaWin *>(PointerFromWindow(hWnd));
 	// sci will be zero if WM_CREATE not seen yet
-	if (sci == 0) {
-		if (iMessage == WM_CREATE) {
-			// Create C++ object associated with window
-			sci = new ScintillaWin(hWnd);
-			SetWindowPointer(hWnd, sci);
-			return sci->WndProc(iMessage, wParam, lParam);
-		} else {
-			return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
+	if (sci == nullptr) {
+		try {
+			if (iMessage == WM_CREATE) {
+				static std::once_flag once;
+				std::call_once(once, Prepare);
+				// Create C++ object associated with window
+				sci = new ScintillaWin(hWnd);
+				SetWindowPointer(hWnd, sci);
+				return sci->WndProc(iMessage, wParam, lParam);
+			}
+		} catch (...) {
 		}
+		return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 	} else {
 		if (iMessage == WM_NCDESTROY) {
-			sci->Finalise();
-			delete sci;
-			::SetWindowLong(hWnd, 0, 0);
+			try {
+				sci->Finalise();
+				delete sci;
+			} catch (...) {
+			}
+			SetWindowPointer(hWnd, nullptr);
 			return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
 		} else {
 			return sci->WndProc(iMessage, wParam, lParam);
@@ -2479,31 +3555,22 @@ sptr_t PASCAL ScintillaWin::SWndProc(
 
 // This function is externally visible so it can be called from container when building statically.
 // Must be called once only.
-bool Scintilla_RegisterClasses(void *hInstance) {
-	Platform_Initialise(hInstance);
-	bool result = ScintillaWin::Register(reinterpret_cast<HINSTANCE>(hInstance));
-#ifdef SCI_LEXER
-	Scintilla_LinkLexers();
-#endif
+int Scintilla_RegisterClasses(void *hInstance) {
+	const bool result = ScintillaWin::Register(static_cast<HINSTANCE>(hInstance));
 	return result;
 }
 
-// This function is externally visible so it can be called from container when building statically.
-bool Scintilla_ReleaseResources() {
-	bool result = ScintillaWin::Unregister();
-	Platform_Finalise();
+namespace Scintilla {
+
+int ResourcesRelease(bool fromDllMain) noexcept {
+	const bool result = ScintillaWin::Unregister();
+	Platform_Finalise(fromDllMain);
 	return result;
 }
 
-#ifndef STATIC_BUILD
-extern "C" int APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID) {
-	//Platform::DebugPrintf("Scintilla::DllMain %d %d\n", hInstance, dwReason);
-	if (dwReason == DLL_PROCESS_ATTACH) {
-		if (!Scintilla_RegisterClasses(hInstance))
-			return FALSE;
-	} else if (dwReason == DLL_PROCESS_DETACH) {
-		Scintilla_ReleaseResources();
-	}
-	return TRUE;
 }
-#endif
+
+// This function is externally visible so it can be called from container when building statically.
+int Scintilla_ReleaseResources() {
+	return Scintilla::ResourcesRelease(false);
+}
diff --git a/Pythonwin/Scintilla/win32/ScintillaWin.h b/Pythonwin/Scintilla/win32/ScintillaWin.h
new file mode 100644
index 000000000..cce72587d
--- /dev/null
+++ b/Pythonwin/Scintilla/win32/ScintillaWin.h
@@ -0,0 +1,20 @@
+// Scintilla source code edit control
+/** @file ScintillaWin.h
+ ** Define functions from ScintillaWin.cxx that can be called from ScintillaDLL.cxx.
+ **/
+// Copyright 1998-2018 by Neil Hodgson <neilh@scintilla.org>
+// The License.txt file describes the conditions under which this software may be distributed.
+
+#ifndef SCINTILLAWIN_H
+#define SCINTILLAWIN_H
+
+class ScintillaWin;
+
+namespace Scintilla {
+
+int ResourcesRelease(bool fromDllMain) noexcept;
+sptr_t DirectFunction(ScintillaWin *sci, UINT iMessage, uptr_t wParam, sptr_t lParam);
+
+}
+
+#endif
diff --git a/Pythonwin/Scintilla/win32/deps.mak b/Pythonwin/Scintilla/win32/deps.mak
new file mode 100644
index 000000000..adacc965c
--- /dev/null
+++ b/Pythonwin/Scintilla/win32/deps.mak
@@ -0,0 +1,1991 @@
+# Created by DepGen.py. To recreate, run DepGen.py.
+HanjaDic.o: \
+	HanjaDic.cxx \
+	../src/UniConversion.h \
+	HanjaDic.h
+PlatWin.o: \
+	PlatWin.cxx \
+	../include/Platform.h \
+	../src/XPM.h \
+	../src/UniConversion.h \
+	../src/DBCS.h \
+	../src/FontQuality.h \
+	PlatWin.h
+ScintillaDLL.o: \
+	ScintillaDLL.cxx \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	ScintillaWin.h
+ScintillaWin.o: \
+	ScintillaWin.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/CallTip.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/CaseConvert.h \
+	../src/UniConversion.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h \
+	../src/MarginView.h \
+	../src/EditView.h \
+	../src/Editor.h \
+	../src/ElapsedPeriod.h \
+	../src/AutoComplete.h \
+	../src/ScintillaBase.h \
+	PlatWin.h \
+	HanjaDic.h \
+	ScintillaWin.h
+AutoComplete.o: \
+	../src/AutoComplete.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../lexlib/CharacterSet.h \
+	../src/Position.h \
+	../src/AutoComplete.h
+CallTip.o: \
+	../src/CallTip.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/IntegerRectangle.h \
+	../src/CallTip.h
+CaseConvert.o: \
+	../src/CaseConvert.cxx \
+	../src/CaseConvert.h \
+	../src/UniConversion.h
+CaseFolder.o: \
+	../src/CaseFolder.cxx \
+	../src/CaseFolder.h \
+	../src/CaseConvert.h
+Catalogue.o: \
+	../src/Catalogue.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/LexerModule.h \
+	../lexlib/CatalogueModules.h \
+	../src/Catalogue.h
+CatalogueL.o: \
+	../src/Catalogue.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/LexerModule.h \
+	../lexlib/CatalogueModules.h \
+	../src/Catalogue.h
+CellBuffer.o: \
+	../src/CellBuffer.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/CellBuffer.h \
+	../src/UniConversion.h
+CharClassify.o: \
+	../src/CharClassify.cxx \
+	../lexlib/CharacterSet.h \
+	../src/CharClassify.h
+ContractionState.o: \
+	../src/ContractionState.cxx \
+	../include/Platform.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/SparseVector.h \
+	../src/ContractionState.h
+DBCS.o: \
+	../src/DBCS.cxx \
+	../src/DBCS.h
+Decoration.o: \
+	../src/Decoration.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/Decoration.h
+Document.o: \
+	../src/Document.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/CellBuffer.h \
+	../src/PerLine.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/RESearch.h \
+	../src/UniConversion.h \
+	../src/ElapsedPeriod.h
+EditModel.o: \
+	../src/EditModel.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/UniConversion.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h
+Editor.o: \
+	../src/Editor.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/PerLine.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/UniConversion.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h \
+	../src/MarginView.h \
+	../src/EditView.h \
+	../src/Editor.h \
+	../src/ElapsedPeriod.h
+EditView.o: \
+	../src/EditView.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/IntegerRectangle.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/PerLine.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/UniConversion.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h \
+	../src/MarginView.h \
+	../src/EditView.h \
+	../src/ElapsedPeriod.h
+ExternalLexer.o: \
+	../src/ExternalLexer.cxx \
+	../include/Platform.h \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/LexerModule.h \
+	../src/Catalogue.h \
+	../src/ExternalLexer.h
+Indicator.o: \
+	../src/Indicator.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/IntegerRectangle.h \
+	../src/Indicator.h \
+	../src/XPM.h
+KeyMap.o: \
+	../src/KeyMap.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/KeyMap.h
+LineMarker.o: \
+	../src/LineMarker.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/IntegerRectangle.h \
+	../src/XPM.h \
+	../src/LineMarker.h
+MarginView.o: \
+	../src/MarginView.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/IntegerRectangle.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/UniConversion.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h \
+	../src/MarginView.h \
+	../src/EditView.h
+PerLine.o: \
+	../src/PerLine.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/CellBuffer.h \
+	../src/PerLine.h
+PositionCache.o: \
+	../src/PositionCache.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/UniConversion.h \
+	../src/Selection.h \
+	../src/PositionCache.h
+RESearch.o: \
+	../src/RESearch.cxx \
+	../src/Position.h \
+	../src/CharClassify.h \
+	../src/RESearch.h
+RunStyles.o: \
+	../src/RunStyles.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h
+ScintillaBase.o: \
+	../src/ScintillaBase.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/CharacterCategory.h \
+	../lexlib/LexerModule.h \
+	../src/Catalogue.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/CallTip.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h \
+	../src/MarginView.h \
+	../src/EditView.h \
+	../src/Editor.h \
+	../src/AutoComplete.h \
+	../src/ScintillaBase.h \
+	../src/ExternalLexer.h
+ScintillaBaseL.o: \
+	../src/ScintillaBase.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/CharacterCategory.h \
+	../lexlib/LexerModule.h \
+	../src/Catalogue.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/CallTip.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h \
+	../src/MarginView.h \
+	../src/EditView.h \
+	../src/Editor.h \
+	../src/AutoComplete.h \
+	../src/ScintillaBase.h \
+	../src/ExternalLexer.h
+Selection.o: \
+	../src/Selection.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/Selection.h
+Style.o: \
+	../src/Style.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Style.h
+UniConversion.o: \
+	../src/UniConversion.cxx \
+	../src/UniConversion.h
+UniqueString.o: \
+	../src/UniqueString.cxx \
+	../src/UniqueString.h
+ViewStyle.o: \
+	../src/ViewStyle.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/Indicator.h \
+	../src/XPM.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h
+XPM.o: \
+	../src/XPM.cxx \
+	../include/Platform.h \
+	../src/XPM.h
+Accessor.o: \
+	../lexlib/Accessor.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h
+CharacterCategory.o: \
+	../lexlib/CharacterCategory.cxx \
+	../lexlib/CharacterCategory.h
+CharacterSet.o: \
+	../lexlib/CharacterSet.cxx \
+	../lexlib/CharacterSet.h
+DefaultLexer.o: \
+	../lexlib/DefaultLexer.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/LexerModule.h \
+	../lexlib/DefaultLexer.h
+LexerBase.o: \
+	../lexlib/LexerBase.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/LexerModule.h \
+	../lexlib/LexerBase.h
+LexerModule.o: \
+	../lexlib/LexerModule.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/LexerModule.h \
+	../lexlib/LexerBase.h \
+	../lexlib/LexerSimple.h
+LexerNoExceptions.o: \
+	../lexlib/LexerNoExceptions.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/LexerModule.h \
+	../lexlib/LexerBase.h \
+	../lexlib/LexerNoExceptions.h
+LexerSimple.o: \
+	../lexlib/LexerSimple.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/LexerModule.h \
+	../lexlib/LexerBase.h \
+	../lexlib/LexerSimple.h
+PropSetSimple.o: \
+	../lexlib/PropSetSimple.cxx \
+	../lexlib/PropSetSimple.h
+StyleContext.o: \
+	../lexlib/StyleContext.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h
+WordList.o: \
+	../lexlib/WordList.cxx \
+	../lexlib/WordList.h
+LexA68k.o: \
+	../lexers/LexA68k.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexAbaqus.o: \
+	../lexers/LexAbaqus.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexAda.o: \
+	../lexers/LexAda.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexAPDL.o: \
+	../lexers/LexAPDL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexAsm.o: \
+	../lexers/LexAsm.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexAsn1.o: \
+	../lexers/LexAsn1.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexASY.o: \
+	../lexers/LexASY.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexAU3.o: \
+	../lexers/LexAU3.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexAVE.o: \
+	../lexers/LexAVE.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexAVS.o: \
+	../lexers/LexAVS.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexBaan.o: \
+	../lexers/LexBaan.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexBash.o: \
+	../lexers/LexBash.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/StringCopy.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SubStyles.h \
+	../lexlib/DefaultLexer.h
+LexBasic.o: \
+	../lexers/LexBasic.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexBatch.o: \
+	../lexers/LexBatch.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexBibTeX.o: \
+	../lexers/LexBibTeX.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexBullant.o: \
+	../lexers/LexBullant.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexCaml.o: \
+	../lexers/LexCaml.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../src/ExternalLexer.h
+LexCIL.o: \
+	../lexers/LexCIL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/StringCopy.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexCLW.o: \
+	../lexers/LexCLW.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexCmake.o: \
+	../lexers/LexCmake.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexCOBOL.o: \
+	../lexers/LexCOBOL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexCoffeeScript.o: \
+	../lexers/LexCoffeeScript.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexConf.o: \
+	../lexers/LexConf.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexCPP.o: \
+	../lexers/LexCPP.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/StringCopy.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SparseState.h \
+	../lexlib/SubStyles.h
+LexCrontab.o: \
+	../lexers/LexCrontab.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexCsound.o: \
+	../lexers/LexCsound.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexCSS.o: \
+	../lexers/LexCSS.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexD.o: \
+	../lexers/LexD.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexDataflex.o: \
+	../lexers/LexDataflex.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexDiff.o: \
+	../lexers/LexDiff.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexDMAP.o: \
+	../lexers/LexDMAP.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexDMIS.o: \
+	../lexers/LexDMIS.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/DefaultLexer.h
+LexECL.o: \
+	../lexers/LexECL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h
+LexEDIFACT.o: \
+	../lexers/LexEDIFACT.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/LexerModule.h \
+	../lexlib/DefaultLexer.h
+LexEiffel.o: \
+	../lexers/LexEiffel.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexErlang.o: \
+	../lexers/LexErlang.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexErrorList.o: \
+	../lexers/LexErrorList.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexEScript.o: \
+	../lexers/LexEScript.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexFlagship.o: \
+	../lexers/LexFlagship.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexForth.o: \
+	../lexers/LexForth.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexFortran.o: \
+	../lexers/LexFortran.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexGAP.o: \
+	../lexers/LexGAP.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexGui4Cli.o: \
+	../lexers/LexGui4Cli.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexHaskell.o: \
+	../lexers/LexHaskell.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexHex.o: \
+	../lexers/LexHex.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexHollywood.o: \
+	../lexers/LexHollywood.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexHTML.o: \
+	../lexers/LexHTML.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexIndent.o: \
+	../lexers/LexIndent.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexInno.o: \
+	../lexers/LexInno.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexJSON.o: \
+	../lexers/LexJSON.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexKix.o: \
+	../lexers/LexKix.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexKVIrc.o: \
+	../lexers/LexKVIrc.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexLaTeX.o: \
+	../lexers/LexLaTeX.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/DefaultLexer.h \
+	../lexlib/LexerBase.h
+LexLisp.o: \
+	../lexers/LexLisp.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexLout.o: \
+	../lexers/LexLout.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexLua.o: \
+	../lexers/LexLua.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/StringCopy.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexMagik.o: \
+	../lexers/LexMagik.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexMake.o: \
+	../lexers/LexMake.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexMarkdown.o: \
+	../lexers/LexMarkdown.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexMatlab.o: \
+	../lexers/LexMatlab.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexMaxima.o: \
+	../lexers/LexMaxima.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexMetapost.o: \
+	../lexers/LexMetapost.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexMMIXAL.o: \
+	../lexers/LexMMIXAL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexModula.o: \
+	../lexers/LexModula.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexMPT.o: \
+	../lexers/LexMPT.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexMSSQL.o: \
+	../lexers/LexMSSQL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexMySQL.o: \
+	../lexers/LexMySQL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexNim.o: \
+	../lexers/LexNim.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/StringCopy.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexNimrod.o: \
+	../lexers/LexNimrod.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexNsis.o: \
+	../lexers/LexNsis.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexNull.o: \
+	../lexers/LexNull.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexOpal.o: \
+	../lexers/LexOpal.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexOScript.o: \
+	../lexers/LexOScript.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexPascal.o: \
+	../lexers/LexPascal.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexPB.o: \
+	../lexers/LexPB.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexPerl.o: \
+	../lexers/LexPerl.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexPLM.o: \
+	../lexers/LexPLM.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexPO.o: \
+	../lexers/LexPO.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexPOV.o: \
+	../lexers/LexPOV.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexPowerPro.o: \
+	../lexers/LexPowerPro.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexPowerShell.o: \
+	../lexers/LexPowerShell.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexProgress.o: \
+	../lexers/LexProgress.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SparseState.h \
+	../lexlib/DefaultLexer.h
+LexProps.o: \
+	../lexers/LexProps.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexPS.o: \
+	../lexers/LexPS.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexPython.o: \
+	../lexers/LexPython.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/StringCopy.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SubStyles.h \
+	../lexlib/DefaultLexer.h
+LexR.o: \
+	../lexers/LexR.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexRaku.o: \
+	../lexers/LexRaku.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexRebol.o: \
+	../lexers/LexRebol.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexRegistry.o: \
+	../lexers/LexRegistry.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexRuby.o: \
+	../lexers/LexRuby.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexRust.o: \
+	../lexers/LexRust.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexSAS.o: \
+	../lexers/LexSAS.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexScriptol.o: \
+	../lexers/LexScriptol.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexSmalltalk.o: \
+	../lexers/LexSmalltalk.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexSML.o: \
+	../lexers/LexSML.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexSorcus.o: \
+	../lexers/LexSorcus.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexSpecman.o: \
+	../lexers/LexSpecman.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexSpice.o: \
+	../lexers/LexSpice.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexSQL.o: \
+	../lexers/LexSQL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SparseState.h \
+	../lexlib/DefaultLexer.h
+LexStata.o: \
+	../lexers/LexStata.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexSTTXT.o: \
+	../lexers/LexSTTXT.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexTACL.o: \
+	../lexers/LexTACL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexTADS3.o: \
+	../lexers/LexTADS3.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexTAL.o: \
+	../lexers/LexTAL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexTCL.o: \
+	../lexers/LexTCL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexTCMD.o: \
+	../lexers/LexTCMD.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexTeX.o: \
+	../lexers/LexTeX.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexTxt2tags.o: \
+	../lexers/LexTxt2tags.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexVB.o: \
+	../lexers/LexVB.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexVerilog.o: \
+	../lexers/LexVerilog.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SubStyles.h \
+	../lexlib/DefaultLexer.h
+LexVHDL.o: \
+	../lexers/LexVHDL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+LexVisualProlog.o: \
+	../lexers/LexVisualProlog.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+LexX12.o: \
+	../lexers/LexX12.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/LexerModule.h \
+	../lexlib/DefaultLexer.h
+LexYAML.o: \
+	../lexers/LexYAML.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
diff --git a/Pythonwin/Scintilla/win32/makefile b/Pythonwin/Scintilla/win32/makefile
new file mode 100644
index 000000000..a722fbd84
--- /dev/null
+++ b/Pythonwin/Scintilla/win32/makefile
@@ -0,0 +1,184 @@
+# Make file for Scintilla on Windows
+# @file makefile
+# Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
+# The License.txt file describes the conditions under which this software may be distributed.
+# This makefile assumes Mingw-w64 GCC 9.0+ is used and changes will be needed to use other compilers.
+# Clang 9.0+ can be used with CLANG=1 on command line.
+
+.PHONY: all clean analyze depend
+
+.SUFFIXES: .cxx .c .o .h .a
+
+DIR_BIN=../bin
+
+COMPONENT = $(DIR_BIN)/Scintilla.dll
+LEXCOMPONENT = $(DIR_BIN)/SciLexer.dll
+LIBSCI = $(DIR_BIN)/libscintilla.a
+
+WARNINGS = -Wpedantic -Wall
+
+ifdef CLANG
+CXX = clang++
+DEFINES += -D_CRT_SECURE_NO_DEPRECATE
+else
+# MinGW GCC
+LIBSMINGW = -lstdc++
+STRIPOPTION = -s
+endif
+ARFLAGS = rc
+RANLIB ?= ranlib
+WINDRES ?= windres
+
+# Environment variable windir always defined on Win32
+
+# Take care of changing Unix style '/' directory separator to '\' on Windows
+normalize = $(if $(windir),$(subst /,\,$1),$1)
+
+PYTHON = $(if $(windir),pyw,python3)
+
+ifdef windir
+DEL = $(if $(wildcard $(dir $(SHELL))rm.exe), $(dir $(SHELL))rm.exe -f, del /q)
+else
+DEL = rm -f
+endif
+
+vpath %.h ../src ../include ../lexlib
+vpath %.cxx ../src ../lexlib ../lexers
+
+LDFLAGS=-shared -static -mwindows
+LIBS=-lgdi32 -luser32 -limm32 -lole32 -luuid -loleaut32 -lmsimg32 $(LIBSMINGW)
+
+INCLUDES=-I ../include -I ../src -I../lexlib
+
+BASE_FLAGS += $(WARNINGS)
+
+ifdef NO_CXX11_REGEX
+DEFINES += -DNO_CXX11_REGEX
+endif
+
+DEFINES += -D$(if $(DEBUG),DEBUG,NDEBUG)
+BASE_FLAGS += $(if $(DEBUG),-g,-Os)
+
+ifndef DEBUG
+STRIPFLAG=$(STRIPOPTION)
+endif
+
+CXX_BASE_FLAGS =--std=c++17 $(BASE_FLAGS)
+CXX_ALL_FLAGS =$(DEFINES) $(INCLUDES) $(CXX_BASE_FLAGS)
+
+all:	$(COMPONENT) $(LEXCOMPONENT) $(LIBSCI)
+
+clean:
+	$(DEL) *.exe *.o *.a *.obj *.dll *.res *.map *.plist $(call normalize,$(LIBSCI))
+
+%.o: %.cxx
+	$(CXX) $(CXX_ALL_FLAGS) $(CXXFLAGS) -c $<
+
+analyze:
+	$(CXX) --analyze $(CXX_ALL_FLAGS) $(CXXFLAGS) *.cxx ../src/*.cxx ../lexlib/*.cxx ../lexers/*.cxx
+
+depend deps.mak:
+	$(PYTHON) DepGen.py
+
+LEX_OBJS:=$(addsuffix .o,$(basename $(sort $(notdir $(wildcard ../lexers/Lex*.cxx)))))
+
+# Required for base Scintilla
+SRC_OBJS = \
+	AutoComplete.o \
+	CallTip.o \
+	CaseConvert.o \
+	CaseFolder.o \
+	CellBuffer.o \
+	CharacterCategory.o \
+	CharacterSet.o \
+	CharClassify.o \
+	ContractionState.o \
+	DBCS.o \
+	Decoration.o \
+	Document.o \
+	EditModel.o \
+	Editor.o \
+	EditView.o \
+	Indicator.o \
+	KeyMap.o \
+	LineMarker.o \
+	MarginView.o \
+	PerLine.o \
+	PositionCache.o \
+	PropSetSimple.o \
+	RESearch.o \
+	RunStyles.o \
+	Selection.o \
+	Style.o \
+	UniConversion.o \
+	UniqueString.o \
+	ViewStyle.o \
+	XPM.o
+
+# Required by lexers
+LEXLIB_OBJS = \
+	Accessor.o \
+	CatalogueL.o \
+	DefaultLexer.o \
+	ExternalLexer.o \
+	LexerBase.o \
+	LexerModule.o \
+	LexerSimple.o \
+	StyleContext.o \
+	WordList.o
+
+# Required by libraries and DLLs that include lexing
+SCILEX_OBJS=\
+	$(SRC_OBJS) \
+	$(LEXLIB_OBJS) \
+	$(LEX_OBJS) \
+	HanjaDic.o \
+	PlatWin.o \
+	ScintillaBaseL.o \
+	ScintillaWin.o
+
+COMPONENT_OBJS = \
+	$(SRC_OBJS) \
+	Accessor.o \
+	Catalogue.o \
+	HanjaDic.o \
+	LexerBase.o \
+	LexerModule.o \
+	LexerSimple.o \
+	PlatWin.o \
+	ScintillaBase.o \
+	ScintillaDLL.o \
+	ScintillaWin.o \
+	ScintRes.o \
+	WordList.o
+
+LEXCOMPONENT_OBJS = \
+	$(SCILEX_OBJS) \
+	ScintillaDLL.o \
+	ScintRes.o
+
+$(COMPONENT): $(COMPONENT_OBJS)
+	$(CXX) $(LDFLAGS) -o $@ $(STRIPFLAG) $^ $(CXXFLAGS) $(LIBS)
+
+$(LEXCOMPONENT): $(LEXCOMPONENT_OBJS)
+	$(CXX) $(LDFLAGS) -o $@ $(STRIPFLAG) $^ $(CXXFLAGS) $(LIBS)
+
+$(LIBSCI): $(COMPONENT_OBJS)
+	$(AR) $(ARFLAGS) $@ $^
+	$(RANLIB) $@
+
+# Automatically generate dependencies for most files with "make deps"
+include deps.mak
+
+ScintillaBaseL.o:
+	$(CXX) $(CXX_ALL_FLAGS) $(CXXFLAGS) -D SCI_LEXER -c $< -o $@
+
+Catalogue.o: Catalogue.cxx
+	$(CXX) $(CXX_ALL_FLAGS) $(CXXFLAGS) -D SCI_LEXER -D SCI_EMPTYCATALOGUE -c $< -o $@
+
+CatalogueL.o: Catalogue.cxx
+	$(CXX) $(CXX_ALL_FLAGS) $(CXXFLAGS) -D SCI_LEXER -c $< -o $@
+
+ScintRes.o:	ScintRes.rc
+	$(WINDRES) ScintRes.rc $@
+
diff --git a/Pythonwin/Scintilla/win32/nmdeps.mak b/Pythonwin/Scintilla/win32/nmdeps.mak
new file mode 100644
index 000000000..7d51e164e
--- /dev/null
+++ b/Pythonwin/Scintilla/win32/nmdeps.mak
@@ -0,0 +1,1991 @@
+# Created by DepGen.py. To recreate, run DepGen.py.
+$(DIR_O)/HanjaDic.obj: \
+	HanjaDic.cxx \
+	../src/UniConversion.h \
+	HanjaDic.h
+$(DIR_O)/PlatWin.obj: \
+	PlatWin.cxx \
+	../include/Platform.h \
+	../src/XPM.h \
+	../src/UniConversion.h \
+	../src/DBCS.h \
+	../src/FontQuality.h \
+	PlatWin.h
+$(DIR_O)/ScintillaDLL.obj: \
+	ScintillaDLL.cxx \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	ScintillaWin.h
+$(DIR_O)/ScintillaWin.obj: \
+	ScintillaWin.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/CallTip.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/CaseConvert.h \
+	../src/UniConversion.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h \
+	../src/MarginView.h \
+	../src/EditView.h \
+	../src/Editor.h \
+	../src/ElapsedPeriod.h \
+	../src/AutoComplete.h \
+	../src/ScintillaBase.h \
+	PlatWin.h \
+	HanjaDic.h \
+	ScintillaWin.h
+$(DIR_O)/AutoComplete.obj: \
+	../src/AutoComplete.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../lexlib/CharacterSet.h \
+	../src/Position.h \
+	../src/AutoComplete.h
+$(DIR_O)/CallTip.obj: \
+	../src/CallTip.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/IntegerRectangle.h \
+	../src/CallTip.h
+$(DIR_O)/CaseConvert.obj: \
+	../src/CaseConvert.cxx \
+	../src/CaseConvert.h \
+	../src/UniConversion.h
+$(DIR_O)/CaseFolder.obj: \
+	../src/CaseFolder.cxx \
+	../src/CaseFolder.h \
+	../src/CaseConvert.h
+$(DIR_O)/Catalogue.obj: \
+	../src/Catalogue.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/LexerModule.h \
+	../lexlib/CatalogueModules.h \
+	../src/Catalogue.h
+$(DIR_O)/CatalogueL.obj: \
+	../src/Catalogue.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/LexerModule.h \
+	../lexlib/CatalogueModules.h \
+	../src/Catalogue.h
+$(DIR_O)/CellBuffer.obj: \
+	../src/CellBuffer.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/CellBuffer.h \
+	../src/UniConversion.h
+$(DIR_O)/CharClassify.obj: \
+	../src/CharClassify.cxx \
+	../lexlib/CharacterSet.h \
+	../src/CharClassify.h
+$(DIR_O)/ContractionState.obj: \
+	../src/ContractionState.cxx \
+	../include/Platform.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/SparseVector.h \
+	../src/ContractionState.h
+$(DIR_O)/DBCS.obj: \
+	../src/DBCS.cxx \
+	../src/DBCS.h
+$(DIR_O)/Decoration.obj: \
+	../src/Decoration.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/Decoration.h
+$(DIR_O)/Document.obj: \
+	../src/Document.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/CellBuffer.h \
+	../src/PerLine.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/RESearch.h \
+	../src/UniConversion.h \
+	../src/ElapsedPeriod.h
+$(DIR_O)/EditModel.obj: \
+	../src/EditModel.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/UniConversion.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h
+$(DIR_O)/Editor.obj: \
+	../src/Editor.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/PerLine.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/UniConversion.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h \
+	../src/MarginView.h \
+	../src/EditView.h \
+	../src/Editor.h \
+	../src/ElapsedPeriod.h
+$(DIR_O)/EditView.obj: \
+	../src/EditView.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/IntegerRectangle.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/PerLine.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/UniConversion.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h \
+	../src/MarginView.h \
+	../src/EditView.h \
+	../src/ElapsedPeriod.h
+$(DIR_O)/ExternalLexer.obj: \
+	../src/ExternalLexer.cxx \
+	../include/Platform.h \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/LexerModule.h \
+	../src/Catalogue.h \
+	../src/ExternalLexer.h
+$(DIR_O)/Indicator.obj: \
+	../src/Indicator.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/IntegerRectangle.h \
+	../src/Indicator.h \
+	../src/XPM.h
+$(DIR_O)/KeyMap.obj: \
+	../src/KeyMap.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/KeyMap.h
+$(DIR_O)/LineMarker.obj: \
+	../src/LineMarker.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/IntegerRectangle.h \
+	../src/XPM.h \
+	../src/LineMarker.h
+$(DIR_O)/MarginView.obj: \
+	../src/MarginView.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/IntegerRectangle.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/UniConversion.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h \
+	../src/MarginView.h \
+	../src/EditView.h
+$(DIR_O)/PerLine.obj: \
+	../src/PerLine.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/CellBuffer.h \
+	../src/PerLine.h
+$(DIR_O)/PositionCache.obj: \
+	../src/PositionCache.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../lexlib/CharacterCategory.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/UniConversion.h \
+	../src/Selection.h \
+	../src/PositionCache.h
+$(DIR_O)/RESearch.obj: \
+	../src/RESearch.cxx \
+	../src/Position.h \
+	../src/CharClassify.h \
+	../src/RESearch.h
+$(DIR_O)/RunStyles.obj: \
+	../src/RunStyles.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h
+$(DIR_O)/ScintillaBase.obj: \
+	../src/ScintillaBase.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/CharacterCategory.h \
+	../lexlib/LexerModule.h \
+	../src/Catalogue.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/CallTip.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h \
+	../src/MarginView.h \
+	../src/EditView.h \
+	../src/Editor.h \
+	../src/AutoComplete.h \
+	../src/ScintillaBase.h \
+	../src/ExternalLexer.h
+$(DIR_O)/ScintillaBaseL.obj: \
+	../src/ScintillaBase.cxx \
+	../include/Platform.h \
+	../include/ILoader.h \
+	../include/Sci_Position.h \
+	../include/ILexer.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/CharacterCategory.h \
+	../lexlib/LexerModule.h \
+	../src/Catalogue.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/SplitVector.h \
+	../src/Partitioning.h \
+	../src/RunStyles.h \
+	../src/ContractionState.h \
+	../src/CellBuffer.h \
+	../src/CallTip.h \
+	../src/KeyMap.h \
+	../src/Indicator.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h \
+	../src/CharClassify.h \
+	../src/Decoration.h \
+	../src/CaseFolder.h \
+	../src/Document.h \
+	../src/Selection.h \
+	../src/PositionCache.h \
+	../src/EditModel.h \
+	../src/MarginView.h \
+	../src/EditView.h \
+	../src/Editor.h \
+	../src/AutoComplete.h \
+	../src/ScintillaBase.h \
+	../src/ExternalLexer.h
+$(DIR_O)/Selection.obj: \
+	../src/Selection.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/Selection.h
+$(DIR_O)/Style.obj: \
+	../src/Style.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Style.h
+$(DIR_O)/UniConversion.obj: \
+	../src/UniConversion.cxx \
+	../src/UniConversion.h
+$(DIR_O)/UniqueString.obj: \
+	../src/UniqueString.cxx \
+	../src/UniqueString.h
+$(DIR_O)/ViewStyle.obj: \
+	../src/ViewStyle.cxx \
+	../include/Platform.h \
+	../include/Scintilla.h \
+	../include/Sci_Position.h \
+	../src/Position.h \
+	../src/UniqueString.h \
+	../src/Indicator.h \
+	../src/XPM.h \
+	../src/LineMarker.h \
+	../src/Style.h \
+	../src/ViewStyle.h
+$(DIR_O)/XPM.obj: \
+	../src/XPM.cxx \
+	../include/Platform.h \
+	../src/XPM.h
+$(DIR_O)/Accessor.obj: \
+	../lexlib/Accessor.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h
+$(DIR_O)/CharacterCategory.obj: \
+	../lexlib/CharacterCategory.cxx \
+	../lexlib/CharacterCategory.h
+$(DIR_O)/CharacterSet.obj: \
+	../lexlib/CharacterSet.cxx \
+	../lexlib/CharacterSet.h
+$(DIR_O)/DefaultLexer.obj: \
+	../lexlib/DefaultLexer.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/LexerModule.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexerBase.obj: \
+	../lexlib/LexerBase.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/LexerModule.h \
+	../lexlib/LexerBase.h
+$(DIR_O)/LexerModule.obj: \
+	../lexlib/LexerModule.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/LexerModule.h \
+	../lexlib/LexerBase.h \
+	../lexlib/LexerSimple.h
+$(DIR_O)/LexerNoExceptions.obj: \
+	../lexlib/LexerNoExceptions.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/LexerModule.h \
+	../lexlib/LexerBase.h \
+	../lexlib/LexerNoExceptions.h
+$(DIR_O)/LexerSimple.obj: \
+	../lexlib/LexerSimple.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/LexerModule.h \
+	../lexlib/LexerBase.h \
+	../lexlib/LexerSimple.h
+$(DIR_O)/PropSetSimple.obj: \
+	../lexlib/PropSetSimple.cxx \
+	../lexlib/PropSetSimple.h
+$(DIR_O)/StyleContext.obj: \
+	../lexlib/StyleContext.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h
+$(DIR_O)/WordList.obj: \
+	../lexlib/WordList.cxx \
+	../lexlib/WordList.h
+$(DIR_O)/LexA68k.obj: \
+	../lexers/LexA68k.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexAbaqus.obj: \
+	../lexers/LexAbaqus.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexAda.obj: \
+	../lexers/LexAda.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexAPDL.obj: \
+	../lexers/LexAPDL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexAsm.obj: \
+	../lexers/LexAsm.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexAsn1.obj: \
+	../lexers/LexAsn1.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexASY.obj: \
+	../lexers/LexASY.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexAU3.obj: \
+	../lexers/LexAU3.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexAVE.obj: \
+	../lexers/LexAVE.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexAVS.obj: \
+	../lexers/LexAVS.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexBaan.obj: \
+	../lexers/LexBaan.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexBash.obj: \
+	../lexers/LexBash.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/StringCopy.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SubStyles.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexBasic.obj: \
+	../lexers/LexBasic.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexBatch.obj: \
+	../lexers/LexBatch.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexBibTeX.obj: \
+	../lexers/LexBibTeX.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexBullant.obj: \
+	../lexers/LexBullant.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexCaml.obj: \
+	../lexers/LexCaml.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../src/ExternalLexer.h
+$(DIR_O)/LexCIL.obj: \
+	../lexers/LexCIL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/StringCopy.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexCLW.obj: \
+	../lexers/LexCLW.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexCmake.obj: \
+	../lexers/LexCmake.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexCOBOL.obj: \
+	../lexers/LexCOBOL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexCoffeeScript.obj: \
+	../lexers/LexCoffeeScript.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexConf.obj: \
+	../lexers/LexConf.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexCPP.obj: \
+	../lexers/LexCPP.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/StringCopy.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SparseState.h \
+	../lexlib/SubStyles.h
+$(DIR_O)/LexCrontab.obj: \
+	../lexers/LexCrontab.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexCsound.obj: \
+	../lexers/LexCsound.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexCSS.obj: \
+	../lexers/LexCSS.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexD.obj: \
+	../lexers/LexD.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexDataflex.obj: \
+	../lexers/LexDataflex.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexDiff.obj: \
+	../lexers/LexDiff.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexDMAP.obj: \
+	../lexers/LexDMAP.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexDMIS.obj: \
+	../lexers/LexDMIS.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexECL.obj: \
+	../lexers/LexECL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h
+$(DIR_O)/LexEDIFACT.obj: \
+	../lexers/LexEDIFACT.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/LexerModule.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexEiffel.obj: \
+	../lexers/LexEiffel.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexErlang.obj: \
+	../lexers/LexErlang.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexErrorList.obj: \
+	../lexers/LexErrorList.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexEScript.obj: \
+	../lexers/LexEScript.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexFlagship.obj: \
+	../lexers/LexFlagship.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexForth.obj: \
+	../lexers/LexForth.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexFortran.obj: \
+	../lexers/LexFortran.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexGAP.obj: \
+	../lexers/LexGAP.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexGui4Cli.obj: \
+	../lexers/LexGui4Cli.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexHaskell.obj: \
+	../lexers/LexHaskell.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexHex.obj: \
+	../lexers/LexHex.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexHollywood.obj: \
+	../lexers/LexHollywood.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexHTML.obj: \
+	../lexers/LexHTML.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexIndent.obj: \
+	../lexers/LexIndent.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexInno.obj: \
+	../lexers/LexInno.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexJSON.obj: \
+	../lexers/LexJSON.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexKix.obj: \
+	../lexers/LexKix.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexKVIrc.obj: \
+	../lexers/LexKVIrc.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexLaTeX.obj: \
+	../lexers/LexLaTeX.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/DefaultLexer.h \
+	../lexlib/LexerBase.h
+$(DIR_O)/LexLisp.obj: \
+	../lexers/LexLisp.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexLout.obj: \
+	../lexers/LexLout.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexLua.obj: \
+	../lexers/LexLua.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/StringCopy.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexMagik.obj: \
+	../lexers/LexMagik.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexMake.obj: \
+	../lexers/LexMake.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexMarkdown.obj: \
+	../lexers/LexMarkdown.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexMatlab.obj: \
+	../lexers/LexMatlab.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexMaxima.obj: \
+	../lexers/LexMaxima.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexMetapost.obj: \
+	../lexers/LexMetapost.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexMMIXAL.obj: \
+	../lexers/LexMMIXAL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexModula.obj: \
+	../lexers/LexModula.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexMPT.obj: \
+	../lexers/LexMPT.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexMSSQL.obj: \
+	../lexers/LexMSSQL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexMySQL.obj: \
+	../lexers/LexMySQL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexNim.obj: \
+	../lexers/LexNim.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/StringCopy.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexNimrod.obj: \
+	../lexers/LexNimrod.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexNsis.obj: \
+	../lexers/LexNsis.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexNull.obj: \
+	../lexers/LexNull.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexOpal.obj: \
+	../lexers/LexOpal.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexOScript.obj: \
+	../lexers/LexOScript.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexPascal.obj: \
+	../lexers/LexPascal.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexPB.obj: \
+	../lexers/LexPB.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexPerl.obj: \
+	../lexers/LexPerl.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexPLM.obj: \
+	../lexers/LexPLM.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexPO.obj: \
+	../lexers/LexPO.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexPOV.obj: \
+	../lexers/LexPOV.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexPowerPro.obj: \
+	../lexers/LexPowerPro.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexPowerShell.obj: \
+	../lexers/LexPowerShell.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexProgress.obj: \
+	../lexers/LexProgress.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SparseState.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexProps.obj: \
+	../lexers/LexProps.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexPS.obj: \
+	../lexers/LexPS.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexPython.obj: \
+	../lexers/LexPython.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/StringCopy.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SubStyles.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexR.obj: \
+	../lexers/LexR.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexRaku.obj: \
+	../lexers/LexRaku.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexRebol.obj: \
+	../lexers/LexRebol.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexRegistry.obj: \
+	../lexers/LexRegistry.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexRuby.obj: \
+	../lexers/LexRuby.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexRust.obj: \
+	../lexers/LexRust.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/PropSetSimple.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexSAS.obj: \
+	../lexers/LexSAS.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexScriptol.obj: \
+	../lexers/LexScriptol.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexSmalltalk.obj: \
+	../lexers/LexSmalltalk.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexSML.obj: \
+	../lexers/LexSML.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexSorcus.obj: \
+	../lexers/LexSorcus.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexSpecman.obj: \
+	../lexers/LexSpecman.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexSpice.obj: \
+	../lexers/LexSpice.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexSQL.obj: \
+	../lexers/LexSQL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SparseState.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexStata.obj: \
+	../lexers/LexStata.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexSTTXT.obj: \
+	../lexers/LexSTTXT.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexTACL.obj: \
+	../lexers/LexTACL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexTADS3.obj: \
+	../lexers/LexTADS3.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexTAL.obj: \
+	../lexers/LexTAL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexTCL.obj: \
+	../lexers/LexTCL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexTCMD.obj: \
+	../lexers/LexTCMD.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexTeX.obj: \
+	../lexers/LexTeX.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexTxt2tags.obj: \
+	../lexers/LexTxt2tags.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexVB.obj: \
+	../lexers/LexVB.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexVerilog.obj: \
+	../lexers/LexVerilog.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/SubStyles.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexVHDL.obj: \
+	../lexers/LexVHDL.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
+$(DIR_O)/LexVisualProlog.obj: \
+	../lexers/LexVisualProlog.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/CharacterCategory.h \
+	../lexlib/LexerModule.h \
+	../lexlib/OptionSet.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexX12.obj: \
+	../lexers/LexX12.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/LexerModule.h \
+	../lexlib/DefaultLexer.h
+$(DIR_O)/LexYAML.obj: \
+	../lexers/LexYAML.cxx \
+	../include/ILexer.h \
+	../include/Sci_Position.h \
+	../include/Scintilla.h \
+	../include/SciLexer.h \
+	../lexlib/WordList.h \
+	../lexlib/LexAccessor.h \
+	../lexlib/Accessor.h \
+	../lexlib/StyleContext.h \
+	../lexlib/CharacterSet.h \
+	../lexlib/LexerModule.h
diff --git a/Pythonwin/Scintilla/win32/scintilla.mak b/Pythonwin/Scintilla/win32/scintilla.mak
index b1cfa250e..bb850e295 100644
--- a/Pythonwin/Scintilla/win32/scintilla.mak
+++ b/Pythonwin/Scintilla/win32/scintilla.mak
@@ -1,15 +1,11 @@
-# Make file for Scintilla on Windows Visual C++ and Borland C++ version
-# Copyright 1998-2003 by Neil Hodgson <neilh@scintilla.org>
+# Make file for Scintilla on Windows Visual C++ version
+# Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
 # The License.txt file describes the conditions under which this software may be distributed.
-# This makefile is for using Visual C++ with nmake or Borland C++ with make depending on
-# the setting of the VENDOR macro. If no VENDOR is defined n the command line then
-# the tool used is automatically detected.
+# This makefile is for using Visual C++ with nmake.
 # Usage for Microsoft:
 #     nmake -f scintilla.mak
-# Usage for Borland:
-#     make -f scintilla.mak
-# For debug versions define DEBUG on the command line, for Borland:
-#     make DEBUG=1 -f scintilla.mak
+# For debug versions define DEBUG on the command line:
+#     nmake DEBUG=1 -f scintilla.mak
 # The main makefile uses mingw32 gcc and may be more current than this file.
 
 .SUFFIXES: .cxx
@@ -19,59 +15,44 @@ DIR_BIN=..\bin
 
 COMPONENT=$(DIR_BIN)\Scintilla.dll
 LEXCOMPONENT=$(DIR_BIN)\SciLexer.dll
+LIBSCI=$(DIR_BIN)\libscintilla.lib
 
-!IFNDEF VENDOR
-!IFDEF _NMAKE_VER
-#Microsoft nmake so make default VENDOR MICROSOFT
-VENDOR=MICROSOFT
+LD=link
+
+!IFDEF SUPPORT_XP
+ADD_DEFINE=-D_USING_V110_SDK71_
+# Different subsystems for 32-bit and 64-bit Windows XP so detect based on Platform
+# environment vairable set by vcvars*.bat to be either x86 or x64
+!IF "$(PLATFORM)" == "x64"
+SUBSYSTEM=-SUBSYSTEM:WINDOWS,5.02
 !ELSE
-VENDOR=BORLAND
+SUBSYSTEM=-SUBSYSTEM:WINDOWS,5.01
 !ENDIF
+!ELSEIFDEF ARM64
+ADD_DEFINE=-D_ARM64_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1
+SUBSYSTEM=-SUBSYSTEM:WINDOWS,10.00
 !ENDIF
 
-!IF "$(VENDOR)"=="MICROSOFT"
-
-CC=cl
-RC=rc
-LD=link
-
-#~ -Zc:forScope -Zc:wchar_t -D_CRT_SECURE_NO_DEPRECATE=1
-CXXFLAGS=-Zi -TP -W4
-# For something scary:-Wp64
+CRTFLAGS=-D_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES=1 -D_CRT_SECURE_NO_DEPRECATE=1 -D_SCL_SECURE_NO_WARNINGS=1 $(ADD_DEFINE)
+CXXFLAGS=-Zi -TP -MP -W4 -EHsc -std:c++17 $(CRTFLAGS)
 CXXDEBUG=-Od -MTd -DDEBUG
-CXXNDEBUG=-O1 -MT -DNDEBUG
-#~ -GL
+CXXNDEBUG=-O1 -MT -DNDEBUG -GL
 NAME=-Fo
-#~ LDFLAGS=-OPT:NOWIN98 -OPT:REF -LTCG -DEBUG
+LDFLAGS=-OPT:REF -LTCG -IGNORE:4197 -DEBUG $(SUBSYSTEM)
 LDDEBUG=
-LIBS=KERNEL32.lib USER32.lib GDI32.lib IMM32.lib OLE32.LIB
+LIBS=KERNEL32.lib USER32.lib GDI32.lib IMM32.lib OLE32.lib OLEAUT32.lib MSIMG32.lib
 NOLOGO=-nologo
 
-!ELSE
-# BORLAND
-
-CC=bcc32
-RC=brcc32 -r
-LD=ilink32
-
-CXXFLAGS=-P -tWM -w -w-prc -w-inl -w-pin -RT- -x-
-# Above turns off warnings for clarfying parentheses and inlines with for not expanded
-CXXDEBUG=-Od -v -DDEBUG
-CXXNDEBUG=-O1 -DNDEBUG
-NAME=-o
-LDFLAGS=-Gn -x -c
-LDDEBUG=-v
-LIBS=import32 cw32mt
-NOLOGO=-q
-
-!ENDIF
-
 !IFDEF QUIET
-CC=@$(CC)
+CXX=@$(CXX)
 CXXFLAGS=$(CXXFLAGS) $(NOLOGO)
 LDFLAGS=$(LDFLAGS) $(NOLOGO)
 !ENDIF
 
+!IFDEF NO_CXX11_REGEX
+CXXFLAGS=$(CXXFLAGS) -DNO_CXX11_REGEX
+!ENDIF
+
 !IFDEF DEBUG
 CXXFLAGS=$(CXXFLAGS) $(CXXDEBUG)
 LDFLAGS=$(LDDEBUG) $(LDFLAGS)
@@ -79,42 +60,56 @@ LDFLAGS=$(LDDEBUG) $(LDFLAGS)
 CXXFLAGS=$(CXXFLAGS) $(CXXNDEBUG)
 !ENDIF
 
-INCLUDEDIRS=-I../include -I../src
-CXXFLAGS=$(CXXFLAGS) $(INCLUDEDIRS)
+INCLUDES=-I../include -I../src -I../lexlib
+CXXFLAGS=$(CXXFLAGS) $(INCLUDES)
 
-ALL:	$(COMPONENT) $(LEXCOMPONENT) $(DIR_O)\ScintillaWinS.obj $(DIR_O)\WindowAccessor.obj
+all:	$(COMPONENT) $(LEXCOMPONENT) $(LIBSCI)
 
 clean:
-	-del /q $(DIR_O)\*.obj $(DIR_O)\*.pdb $(COMPONENT) $(LEXCOMPONENT) \
-	$(DIR_O)\*.res $(DIR_BIN)\*.map $(DIR_BIN)\*.exp $(DIR_BIN)\*.pdb $(DIR_BIN)\*.lib
+	-del /q $(DIR_O)\*.obj $(DIR_O)\*.pdb $(DIR_O)\*.asm $(COMPONENT) $(LEXCOMPONENT) \
+	$(DIR_O)\*.res $(DIR_BIN)\*.map $(DIR_BIN)\*.exp $(DIR_BIN)\*.pdb \
+	$(DIR_BIN)\Scintilla.lib $(DIR_BIN)\SciLexer.lib $(LIBSCI)
+
+depend:
+	pyw DepGen.py
 
-SOBJS=\
+# Required for base Scintilla
+SRC_OBJS=\
 	$(DIR_O)\AutoComplete.obj \
 	$(DIR_O)\CallTip.obj \
+	$(DIR_O)\CaseConvert.obj \
+	$(DIR_O)\CaseFolder.obj \
 	$(DIR_O)\CellBuffer.obj \
+	$(DIR_O)\CharacterCategory.obj \
+	$(DIR_O)\CharacterSet.obj \
 	$(DIR_O)\CharClassify.obj \
 	$(DIR_O)\ContractionState.obj \
+	$(DIR_O)\DBCS.obj \
 	$(DIR_O)\Decoration.obj \
 	$(DIR_O)\Document.obj \
+	$(DIR_O)\EditModel.obj \
 	$(DIR_O)\Editor.obj \
+	$(DIR_O)\EditView.obj \
 	$(DIR_O)\Indicator.obj \
 	$(DIR_O)\KeyMap.obj \
 	$(DIR_O)\LineMarker.obj \
-	$(DIR_O)\PlatWin.obj \
+	$(DIR_O)\MarginView.obj \
+	$(DIR_O)\PerLine.obj \
 	$(DIR_O)\PositionCache.obj \
-	$(DIR_O)\PropSet.obj \
+	$(DIR_O)\PropSetSimple.obj \
 	$(DIR_O)\RESearch.obj \
 	$(DIR_O)\RunStyles.obj \
-	$(DIR_O)\ScintillaBase.obj \
-	$(DIR_O)\ScintillaWin.obj \
+	$(DIR_O)\Selection.obj \
 	$(DIR_O)\Style.obj \
 	$(DIR_O)\UniConversion.obj \
+	$(DIR_O)\UniqueString.obj \
 	$(DIR_O)\ViewStyle.obj \
 	$(DIR_O)\XPM.obj
 
-#++Autogenerated -- run src/LexGen.py to regenerate
-#**LEXOBJS=\\\n\(\t$(DIR_O)\\\*.obj \\\n\)
-LEXOBJS=\
+#++Autogenerated -- run scripts/LexGen.py to regenerate
+#**LEX_OBJS=\\\n\(\t$(DIR_O)\\\*.obj \\\n\)
+LEX_OBJS=\
+	$(DIR_O)\LexA68k.obj \
 	$(DIR_O)\LexAbaqus.obj \
 	$(DIR_O)\LexAda.obj \
 	$(DIR_O)\LexAPDL.obj \
@@ -123,21 +118,34 @@ LEXOBJS=\
 	$(DIR_O)\LexASY.obj \
 	$(DIR_O)\LexAU3.obj \
 	$(DIR_O)\LexAVE.obj \
+	$(DIR_O)\LexAVS.obj \
 	$(DIR_O)\LexBaan.obj \
 	$(DIR_O)\LexBash.obj \
 	$(DIR_O)\LexBasic.obj \
+	$(DIR_O)\LexBatch.obj \
+	$(DIR_O)\LexBibTeX.obj \
 	$(DIR_O)\LexBullant.obj \
 	$(DIR_O)\LexCaml.obj \
+	$(DIR_O)\LexCIL.obj \
 	$(DIR_O)\LexCLW.obj \
 	$(DIR_O)\LexCmake.obj \
+	$(DIR_O)\LexCOBOL.obj \
+	$(DIR_O)\LexCoffeeScript.obj \
 	$(DIR_O)\LexConf.obj \
 	$(DIR_O)\LexCPP.obj \
 	$(DIR_O)\LexCrontab.obj \
 	$(DIR_O)\LexCsound.obj \
 	$(DIR_O)\LexCSS.obj \
 	$(DIR_O)\LexD.obj \
+	$(DIR_O)\LexDataflex.obj \
+	$(DIR_O)\LexDiff.obj \
+	$(DIR_O)\LexDMAP.obj \
+	$(DIR_O)\LexDMIS.obj \
+	$(DIR_O)\LexECL.obj \
+	$(DIR_O)\LexEDIFACT.obj \
 	$(DIR_O)\LexEiffel.obj \
 	$(DIR_O)\LexErlang.obj \
+	$(DIR_O)\LexErrorList.obj \
 	$(DIR_O)\LexEScript.obj \
 	$(DIR_O)\LexFlagship.obj \
 	$(DIR_O)\LexForth.obj \
@@ -145,379 +153,159 @@ LEXOBJS=\
 	$(DIR_O)\LexGAP.obj \
 	$(DIR_O)\LexGui4Cli.obj \
 	$(DIR_O)\LexHaskell.obj \
+	$(DIR_O)\LexHex.obj \
+	$(DIR_O)\LexHollywood.obj \
 	$(DIR_O)\LexHTML.obj \
+	$(DIR_O)\LexIndent.obj \
 	$(DIR_O)\LexInno.obj \
+	$(DIR_O)\LexJSON.obj \
 	$(DIR_O)\LexKix.obj \
+	$(DIR_O)\LexKVIrc.obj \
+	$(DIR_O)\LexLaTeX.obj \
 	$(DIR_O)\LexLisp.obj \
 	$(DIR_O)\LexLout.obj \
 	$(DIR_O)\LexLua.obj \
 	$(DIR_O)\LexMagik.obj \
+	$(DIR_O)\LexMake.obj \
+	$(DIR_O)\LexMarkdown.obj \
 	$(DIR_O)\LexMatlab.obj \
+	$(DIR_O)\LexMaxima.obj \
 	$(DIR_O)\LexMetapost.obj \
 	$(DIR_O)\LexMMIXAL.obj \
+	$(DIR_O)\LexModula.obj \
 	$(DIR_O)\LexMPT.obj \
 	$(DIR_O)\LexMSSQL.obj \
 	$(DIR_O)\LexMySQL.obj \
+	$(DIR_O)\LexNim.obj \
+	$(DIR_O)\LexNimrod.obj \
 	$(DIR_O)\LexNsis.obj \
+	$(DIR_O)\LexNull.obj \
 	$(DIR_O)\LexOpal.obj \
-	$(DIR_O)\LexOthers.obj \
+	$(DIR_O)\LexOScript.obj \
 	$(DIR_O)\LexPascal.obj \
 	$(DIR_O)\LexPB.obj \
 	$(DIR_O)\LexPerl.obj \
 	$(DIR_O)\LexPLM.obj \
+	$(DIR_O)\LexPO.obj \
 	$(DIR_O)\LexPOV.obj \
+	$(DIR_O)\LexPowerPro.obj \
 	$(DIR_O)\LexPowerShell.obj \
 	$(DIR_O)\LexProgress.obj \
+	$(DIR_O)\LexProps.obj \
 	$(DIR_O)\LexPS.obj \
 	$(DIR_O)\LexPython.obj \
 	$(DIR_O)\LexR.obj \
+	$(DIR_O)\LexRaku.obj \
 	$(DIR_O)\LexRebol.obj \
+	$(DIR_O)\LexRegistry.obj \
 	$(DIR_O)\LexRuby.obj \
+	$(DIR_O)\LexRust.obj \
+	$(DIR_O)\LexSAS.obj \
 	$(DIR_O)\LexScriptol.obj \
 	$(DIR_O)\LexSmalltalk.obj \
+	$(DIR_O)\LexSML.obj \
+	$(DIR_O)\LexSorcus.obj \
 	$(DIR_O)\LexSpecman.obj \
 	$(DIR_O)\LexSpice.obj \
 	$(DIR_O)\LexSQL.obj \
+	$(DIR_O)\LexStata.obj \
+	$(DIR_O)\LexSTTXT.obj \
+	$(DIR_O)\LexTACL.obj \
 	$(DIR_O)\LexTADS3.obj \
+	$(DIR_O)\LexTAL.obj \
 	$(DIR_O)\LexTCL.obj \
+	$(DIR_O)\LexTCMD.obj \
 	$(DIR_O)\LexTeX.obj \
+	$(DIR_O)\LexTxt2tags.obj \
 	$(DIR_O)\LexVB.obj \
 	$(DIR_O)\LexVerilog.obj \
 	$(DIR_O)\LexVHDL.obj \
+	$(DIR_O)\LexVisualProlog.obj \
+	$(DIR_O)\LexX12.obj \
 	$(DIR_O)\LexYAML.obj \
 
 #--Autogenerated -- end of automatically generated section
 
-LOBJS=\
-	$(DIR_O)\AutoComplete.obj \
-	$(DIR_O)\CallTip.obj \
-	$(DIR_O)\CellBuffer.obj \
-	$(DIR_O)\CharClassify.obj \
-	$(DIR_O)\ContractionState.obj \
-	$(DIR_O)\Decoration.obj \
-	$(DIR_O)\Document.obj \
-	$(DIR_O)\DocumentAccessor.obj \
-	$(DIR_O)\Editor.obj \
+# Required by lexers
+LEXLIB_OBJS = \
+	$(DIR_O)\Accessor.obj \
+	$(DIR_O)\CatalogueL.obj \
 	$(DIR_O)\ExternalLexer.obj \
-	$(DIR_O)\Indicator.obj \
-	$(DIR_O)\KeyMap.obj \
-	$(DIR_O)\KeyWords.obj \
-	$(DIR_O)\LineMarker.obj \
+	$(DIR_O)\DefaultLexer.obj \
+	$(DIR_O)\LexerBase.obj \
+	$(DIR_O)\LexerModule.obj \
+	$(DIR_O)\LexerSimple.obj \
+	$(DIR_O)\StyleContext.obj \
+	$(DIR_O)\WordList.obj
+
+# Required by libraries and DLLs that include lexing
+SCILEX_OBJS = \
+	$(SRC_OBJS) \
+	$(LEXLIB_OBJS) \
+	$(LEX_OBJS) \
+	$(DIR_O)\HanjaDic.obj \
 	$(DIR_O)\PlatWin.obj \
-	$(DIR_O)\PositionCache.obj \
-	$(DIR_O)\PropSet.obj \
-	$(DIR_O)\RESearch.obj \
-	$(DIR_O)\RunStyles.obj \
 	$(DIR_O)\ScintillaBaseL.obj \
-	$(DIR_O)\ScintillaWinL.obj \
-	$(DIR_O)\Style.obj \
-	$(DIR_O)\StyleContext.obj \
-	$(DIR_O)\UniConversion.obj \
-	$(DIR_O)\ViewStyle.obj \
-	$(DIR_O)\XPM.obj \
-	$(LEXOBJS)
+	$(DIR_O)\ScintillaWin.obj
+
+COMPONENT_OBJS = \
+	$(DIR_O)\Accessor.obj \
+	$(DIR_O)\Catalogue.obj \
+	$(DIR_O)\HanjaDic.obj \
+	$(DIR_O)\LexerBase.obj \
+	$(DIR_O)\LexerModule.obj \
+	$(DIR_O)\LexerSimple.obj \
+	$(DIR_O)\PlatWin.obj \
+	$(DIR_O)\ScintillaBase.obj \
+	$(DIR_O)\ScintillaDLL.obj \
+	$(DIR_O)\ScintillaWin.obj \
+	$(DIR_O)\WordList.obj \
+	$(SRC_OBJS)
+
+LEXCOMPONENT_OBJS = \
+	$(DIR_O)\ScintillaDLL.obj \
+	$(SCILEX_OBJS)
 
 $(DIR_O)\ScintRes.res : ScintRes.rc
 	$(RC) -fo$@ $**
 
-!IF "$(VENDOR)"=="MICROSOFT"
-
-$(COMPONENT): $(SOBJS) $(DIR_O)\ScintRes.res
+$(COMPONENT): $(COMPONENT_OBJS) $(DIR_O)\ScintRes.res
 	$(LD) $(LDFLAGS) -DEF:Scintilla.def -DLL -OUT:$@ $** $(LIBS)
 
-$(LEXCOMPONENT): $(LOBJS) $(DIR_O)\ScintRes.res
+$(LEXCOMPONENT): $(LEXCOMPONENT_OBJS) $(DIR_O)\ScintRes.res
 	$(LD) $(LDFLAGS) -DEF:Scintilla.def -DLL -OUT:$@ $** $(LIBS)
 
-!ELSE
-
-$(COMPONENT): $(SOBJS) $(DIR_O)\ScintRes.res
-	$(LD) $(LDFLAGS) -Tpd c0d32 $(SOBJS), $@, , $(LIBS), , $(DIR_O)\ScintRes.res
-
-$(LEXCOMPONENT): $(LOBJS) $(DIR_O)\ScintRes.res
-	$(LD) $(LDFLAGS) -Tpd c0d32 $(LOBJS), $@, , $(LIBS), , $(DIR_O)\ScintRes.res
-
-!ENDIF
+$(LIBSCI): $(COMPONENT_OBJS)
+	LIB /OUT:$@ $**
 
 # Define how to build all the objects and what they depend on
 
-# Most of the source is in ..\src with a couple in this directory
-{..\src}.cxx{$(DIR_O)}.obj:
-	$(CC) $(CXXFLAGS) -c $(NAME)$@ $<
-{.}.cxx{$(DIR_O)}.obj:
-	$(CC) $(CXXFLAGS) -c $(NAME)$@ $<
+{..\src}.cxx{$(DIR_O)}.obj::
+	$(CXX) $(CXXFLAGS) -c $(NAME)$(DIR_O)\ $<
+{..\lexlib}.cxx{$(DIR_O)}.obj::
+	$(CXX) $(CXXFLAGS) -c $(NAME)$(DIR_O)\ $<
+{..\lexers}.cxx{$(DIR_O)}.obj::
+	$(CXX) $(CXXFLAGS) -c $(NAME)$(DIR_O)\ $<
+{.}.cxx{$(DIR_O)}.obj::
+	$(CXX) $(CXXFLAGS) -c $(NAME)$(DIR_O)\ $<
 
 # Some source files are compiled into more than one object because of different conditional compilation
 $(DIR_O)\ScintillaBaseL.obj: ..\src\ScintillaBase.cxx
-	$(CC) $(CXXFLAGS) -DSCI_LEXER -c $(NAME)$@ ..\src\ScintillaBase.cxx
+	$(CXX) $(CXXFLAGS) -DSCI_LEXER -c $(NAME)$@ ..\src\ScintillaBase.cxx
 
-$(DIR_O)\ScintillaWinL.obj: ScintillaWin.cxx
-	$(CC) $(CXXFLAGS) -DSCI_LEXER -c $(NAME)$@ ScintillaWin.cxx
+$(DIR_O)\CatalogueL.obj: ..\src\Catalogue.cxx
+	$(CXX) $(CXXFLAGS) -DSCI_LEXER -c $(NAME)$@ ..\src\Catalogue.cxx
 
-$(DIR_O)\ScintillaWinS.obj: ScintillaWin.cxx
-	$(CC) $(CXXFLAGS) -DSTATIC_BUILD -c $(NAME)$@ ScintillaWin.cxx
+$(DIR_O)\Catalogue.obj: ..\src\Catalogue.cxx
+	$(CXX) $(CXXFLAGS) -DSCI_LEXER -DSCI_EMPTYCATALOGUE -c $(NAME)$@ ..\src\Catalogue.cxx
 
 # Dependencies
 
-# All lexers depend on this set of headers
-LEX_HEADERS=..\include\Platform.h ..\include\PropSet.h \
- ..\include\SString.h ..\include\Accessor.h ..\include\KeyWords.h \
- ..\include\Scintilla.h ..\include\SciLexer.h ..\src\StyleContext.h
-
-$(DIR_O)\AutoComplete.obj: ../src/AutoComplete.cxx ../include/Platform.h \
-  ../include/PropSet.h ../include/SString.h ../src/AutoComplete.h
-$(DIR_O)\CallTip.obj: ../src/CallTip.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/CallTip.h
-$(DIR_O)\CellBuffer.obj: ../src/CellBuffer.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/SVector.h ../src/SplitVector.h \
-  ../src/Partitioning.h ../src/CellBuffer.h
-$(DIR_O)\CharClassify.obj: ../src/CharClassify.cxx ../src/CharClassify.h
-$(DIR_O)\ContractionState.obj: ../src/ContractionState.cxx ../include/Platform.h \
-  ../src/ContractionState.h
-$(DIR_O)\Decoration.obj: ../src/Decoration.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/SplitVector.h ../src/Partitioning.h \
-  ../src/RunStyles.h ../src/Decoration.h
-$(DIR_O)\Document.obj: ../src/Document.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/SVector.h ../src/SplitVector.h \
-  ../src/Partitioning.h ../src/RunStyles.h ../src/CellBuffer.h \
-  ../src/CharClassify.h ../src/Decoration.h ../src/Document.h \
-  ../src/RESearch.h
-$(DIR_O)\DocumentAccessor.obj: ../src/DocumentAccessor.cxx ../include/Platform.h \
-  ../include/PropSet.h ../include/SString.h ../src/SVector.h \
-  ../include/Accessor.h ../src/DocumentAccessor.h ../src/SplitVector.h \
-  ../src/Partitioning.h ../src/RunStyles.h ../src/CellBuffer.h \
-  ../include/Scintilla.h ../src/CharClassify.h ../src/Decoration.h \
-  ../src/Document.h
-$(DIR_O)\Editor.obj: ../src/Editor.cxx ../include/Platform.h ../include/Scintilla.h \
-  ../src/ContractionState.h ../src/SVector.h ../src/SplitVector.h \
-  ../src/Partitioning.h ../src/CellBuffer.h ../src/KeyMap.h \
-  ../src/RunStyles.h ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h \
-  ../src/Style.h ../src/ViewStyle.h ../src/CharClassify.h \
-  ../src/Decoration.h ../src/Document.h ../src/Editor.h ../src/PositionCache.h
-$(DIR_O)\ExternalLexer.obj: ../src/ExternalLexer.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../include/SciLexer.h ../include/PropSet.h \
-  ../include/SString.h ../include/Accessor.h ../src/DocumentAccessor.h \
-  ../include/KeyWords.h ../src/ExternalLexer.h
-$(DIR_O)\Indicator.obj: ../src/Indicator.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/Indicator.h
-$(DIR_O)\KeyMap.obj: ../src/KeyMap.cxx ../include/Platform.h ../include/Scintilla.h \
-  ../src/KeyMap.h
-$(DIR_O)\KeyWords.obj: ../src/KeyWords.cxx ../include/Platform.h \
-  ../include/PropSet.h ../include/SString.h ../include/Accessor.h \
-  ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-
-#++Autogenerated -- run src/LexGen.py to regenerate
-#**\n\($(DIR_O)\\\*.obj: ..\\src\\\*.cxx $(LEX_HEADERS)\n\n\)
-
-$(DIR_O)\LexAbaqus.obj: ..\src\LexAbaqus.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexAda.obj: ..\src\LexAda.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexAPDL.obj: ..\src\LexAPDL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexAsm.obj: ..\src\LexAsm.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexAsn1.obj: ..\src\LexAsn1.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexASY.obj: ..\src\LexASY.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexAU3.obj: ..\src\LexAU3.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexAVE.obj: ..\src\LexAVE.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexBaan.obj: ..\src\LexBaan.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexBash.obj: ..\src\LexBash.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexBasic.obj: ..\src\LexBasic.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexBullant.obj: ..\src\LexBullant.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexCaml.obj: ..\src\LexCaml.cxx $(LEX_HEADERS)
+!IF EXISTS(nmdeps.mak)
 
-$(DIR_O)\LexCLW.obj: ..\src\LexCLW.cxx $(LEX_HEADERS)
+# Protect with !IF EXISTS to handle accidental deletion - just 'nmake -f scintilla.mak deps'
 
-$(DIR_O)\LexCmake.obj: ..\src\LexCmake.cxx $(LEX_HEADERS)
+!INCLUDE nmdeps.mak
 
-$(DIR_O)\LexConf.obj: ..\src\LexConf.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexCPP.obj: ..\src\LexCPP.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexCrontab.obj: ..\src\LexCrontab.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexCsound.obj: ..\src\LexCsound.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexCSS.obj: ..\src\LexCSS.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexD.obj: ..\src\LexD.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexEiffel.obj: ..\src\LexEiffel.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexErlang.obj: ..\src\LexErlang.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexEScript.obj: ..\src\LexEScript.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexFlagship.obj: ..\src\LexFlagship.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexForth.obj: ..\src\LexForth.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexFortran.obj: ..\src\LexFortran.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexGAP.obj: ..\src\LexGAP.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexGui4Cli.obj: ..\src\LexGui4Cli.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexHaskell.obj: ..\src\LexHaskell.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexHTML.obj: ..\src\LexHTML.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexInno.obj: ..\src\LexInno.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexKix.obj: ..\src\LexKix.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexLisp.obj: ..\src\LexLisp.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexLout.obj: ..\src\LexLout.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexLua.obj: ..\src\LexLua.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMagik.obj: ..\src\LexMagik.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMatlab.obj: ..\src\LexMatlab.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMetapost.obj: ..\src\LexMetapost.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMMIXAL.obj: ..\src\LexMMIXAL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMPT.obj: ..\src\LexMPT.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMSSQL.obj: ..\src\LexMSSQL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMySQL.obj: ..\src\LexMySQL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexNsis.obj: ..\src\LexNsis.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexOpal.obj: ..\src\LexOpal.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexOthers.obj: ..\src\LexOthers.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPascal.obj: ..\src\LexPascal.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPB.obj: ..\src\LexPB.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPerl.obj: ..\src\LexPerl.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPLM.obj: ..\src\LexPLM.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPOV.obj: ..\src\LexPOV.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPowerShell.obj: ..\src\LexPowerShell.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexProgress.obj: ..\src\LexProgress.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPS.obj: ..\src\LexPS.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPython.obj: ..\src\LexPython.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexR.obj: ..\src\LexR.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexRebol.obj: ..\src\LexRebol.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexRuby.obj: ..\src\LexRuby.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexScriptol.obj: ..\src\LexScriptol.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexSmalltalk.obj: ..\src\LexSmalltalk.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexSpecman.obj: ..\src\LexSpecman.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexSpice.obj: ..\src\LexSpice.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexSQL.obj: ..\src\LexSQL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexTADS3.obj: ..\src\LexTADS3.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexTCL.obj: ..\src\LexTCL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexTeX.obj: ..\src\LexTeX.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexVB.obj: ..\src\LexVB.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexVerilog.obj: ..\src\LexVerilog.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexVHDL.obj: ..\src\LexVHDL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexYAML.obj: ..\src\LexYAML.cxx $(LEX_HEADERS)
-
-
-#--Autogenerated -- end of automatically generated section
+!ENDIF
 
-$(DIR_O)\LineMarker.obj: ../src/LineMarker.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/XPM.h ../src/LineMarker.h
-$(DIR_O)\PlatWin.obj: PlatWin.cxx ../include/Platform.h PlatformRes.h \
-  ../src/UniConversion.h ../src/XPM.h
-$(DIR_O)\PositionCache.obj: ../src/Editor.cxx ../include/Platform.h ../include/Scintilla.h \
-  ../src/ContractionState.h ../src/SVector.h ../src/SplitVector.h \
-  ../src/Partitioning.h ../src/CellBuffer.h ../src/KeyMap.h \
-  ../src/RunStyles.h ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h \
-  ../src/Style.h ../src/ViewStyle.h ../src/CharClassify.h \
-  ../src/Decoration.h ../src/Document.h ../src/Editor.h ../src/PositionCache.h
-$(DIR_O)\PropSet.obj: ../src/PropSet.cxx ../include/Platform.h ../include/PropSet.h \
-  ../include/SString.h
-$(DIR_O)\RESearch.obj: ../src/RESearch.cxx ../src/CharClassify.h ../src/RESearch.h
-$(DIR_O)\RunStyles.obj: ../src/RunStyles.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/SplitVector.h ../src/Partitioning.h \
-  ../src/RunStyles.h
-$(DIR_O)\ScintillaBase.obj: ../src/ScintillaBase.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../include/PropSet.h ../include/SString.h \
-  ../src/ContractionState.h ../src/SVector.h ../src/SplitVector.h \
-  ../src/Partitioning.h ../src/RunStyles.h ../src/CellBuffer.h \
-  ../src/CallTip.h ../src/KeyMap.h ../src/Indicator.h ../src/XPM.h \
-  ../src/LineMarker.h ../src/Style.h ../src/ViewStyle.h \
-  ../src/AutoComplete.h ../src/CharClassify.h ../src/Decoration.h \
-  ../src/Document.h ../src/Editor.h ../src/ScintillaBase.h
-$(DIR_O)\ScintillaBaseL.obj: ../src/ScintillaBase.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../include/PropSet.h ../include/SString.h \
-  ../src/ContractionState.h ../src/SVector.h ../src/SplitVector.h \
-  ../src/Partitioning.h ../src/RunStyles.h ../src/CellBuffer.h \
-  ../src/CallTip.h ../src/KeyMap.h ../src/Indicator.h ../src/XPM.h \
-  ../src/LineMarker.h ../src/Style.h ../src/ViewStyle.h \
-  ../src/AutoComplete.h ../src/CharClassify.h ../src/Decoration.h \
-  ../src/Document.h ../src/Editor.h ../src/ScintillaBase.h
-$(DIR_O)\ScintillaWin.obj: ScintillaWin.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../include/SString.h ../src/ContractionState.h \
-  ../src/SVector.h ../src/SplitVector.h ../src/Partitioning.h \
-  ../src/RunStyles.h ../src/CellBuffer.h ../src/CallTip.h ../src/KeyMap.h \
-  ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h ../src/Style.h \
-  ../src/AutoComplete.h ../src/ViewStyle.h ../src/CharClassify.h \
-  ../src/Decoration.h ../src/Document.h ../src/Editor.h \
-  ../src/ScintillaBase.h ../src/UniConversion.h
-$(DIR_O)\ScintillaWinS.obj: ScintillaWin.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../include/SString.h ../src/ContractionState.h \
-  ../src/SVector.h ../src/SplitVector.h ../src/Partitioning.h \
-  ../src/RunStyles.h ../src/CellBuffer.h ../src/CallTip.h ../src/KeyMap.h \
-  ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h ../src/Style.h \
-  ../src/AutoComplete.h ../src/ViewStyle.h ../src/CharClassify.h \
-  ../src/Decoration.h ../src/Document.h ../src/Editor.h \
-  ../src/ScintillaBase.h ../src/UniConversion.h
-$(DIR_O)\ScintillaWinL.obj: ScintillaWin.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../include/SString.h ../src/ContractionState.h \
-  ../src/SVector.h ../src/SplitVector.h ../src/Partitioning.h \
-  ../src/RunStyles.h ../src/CellBuffer.h ../src/CallTip.h ../src/KeyMap.h \
-  ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h ../src/Style.h \
-  ../src/AutoComplete.h ../src/ViewStyle.h ../src/CharClassify.h \
-  ../src/Decoration.h ../src/Document.h ../src/Editor.h \
-  ../src/ScintillaBase.h ../src/UniConversion.h
-$(DIR_O)\Style.obj: ../src/Style.cxx ../include/Platform.h ../include/Scintilla.h \
-  ../src/Style.h
-$(DIR_O)\StyleContext.obj: ../src/StyleContext.cxx ../include/Platform.h \
-  ../include/PropSet.h ../include/SString.h ../include/Accessor.h \
-  ../src/StyleContext.h
-$(DIR_O)\UniConversion.obj: ../src/UniConversion.cxx ../src/UniConversion.h
-$(DIR_O)\ViewStyle.obj: ../src/ViewStyle.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/SplitVector.h ../src/Partitioning.h \
-  ../src/RunStyles.h ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h \
-  ../src/Style.h ../src/ViewStyle.h
-$(DIR_O)\WindowAccessor.obj: ../src/WindowAccessor.cxx ../include/Platform.h \
-  ../include/PropSet.h ../include/SString.h ../include/Accessor.h \
-  ../include/WindowAccessor.h ../include/Scintilla.h
-$(DIR_O)\XPM.obj: ../src/XPM.cxx ../include/Platform.h ../src/XPM.h
diff --git a/Pythonwin/Scintilla/win32/scintilla_vc6.mak b/Pythonwin/Scintilla/win32/scintilla_vc6.mak
deleted file mode 100644
index cccef492d..000000000
--- a/Pythonwin/Scintilla/win32/scintilla_vc6.mak
+++ /dev/null
@@ -1,517 +0,0 @@
-# Make file for Scintilla on Windows Visual C++ and Borland C++ version
-# Copyright 1998-2002 by Neil Hodgson <neilh@scintilla.org>
-# The License.txt file describes the conditions under which this software may be distributed.
-# This makefile is for using Visual C++ with nmake or Borland C++ with make depending on
-# the setting of the VENDOR macro. If no VENDOR is defined n the command line then
-# the tool used is automatically detected.
-# Usage for Microsoft:
-#     nmake -f scintilla.mak
-# Usage for Borland:
-#     make -f scintilla.mak
-# For debug versions define DEBUG on the command line, for Borland:
-#     make DEBUG=1 -f scintilla.mak
-# The main makefile uses mingw32 gcc and may be more current than this file.
-
-.SUFFIXES: .cxx
-
-DIR_O=.
-DIR_BIN=..\bin
-
-COMPONENT=$(DIR_BIN)\Scintilla.dll
-LEXCOMPONENT=$(DIR_BIN)\SciLexer.dll
-
-!IFNDEF VENDOR
-!IFDEF _NMAKE_VER
-#Microsoft nmake so make default VENDOR MICROSOFT
-VENDOR=MICROSOFT
-!ELSE
-VENDOR=BORLAND
-!ENDIF
-!ENDIF
-
-!IF "$(VENDOR)"=="MICROSOFT"
-
-CC=cl
-RC=rc
-LD=link
-
-#-Zc:forScope -Zc:wchar_t
-CXXFLAGS=-Zi -TP -W4
-# For something scary:-Wp64
-CXXDEBUG=-Od -MTd -DDEBUG
-CXXNDEBUG=-O1 -MT -DNDEBUG
-NAME=-Fo
-# If you have problems with lexers being linked, try removing -OPT:REF and replacing with -OPT:NOREF
-#LDFLAGS=-OPT:NOWIN98 -OPT:REF
-LDDEBUG=
-LIBS=KERNEL32.lib USER32.lib GDI32.lib IMM32.lib OLE32.LIB
-NOLOGO=-nologo
-
-!ELSE
-# BORLAND
-
-CC=bcc32
-RC=brcc32 -r
-LD=ilink32
-
-CXXFLAGS=-P -tWM -w -w-prc -w-inl -RT- -x-
-# Above turns off warnings for clarfying parentheses and inlines with for not expanded
-CXXDEBUG=-Od -v -DDEBUG
-CXXNDEBUG=-O1 -DNDEBUG
-NAME=-o
-LDFLAGS=-Gn -x -c
-LDDEBUG=-v
-LIBS=import32 cw32mt
-NOLOGO=-q
-
-!ENDIF
-
-!IFDEF QUIET
-CC=@$(CC)
-CXXFLAGS=$(CXXFLAGS) $(NOLOGO)
-LDFLAGS=$(LDFLAGS) $(NOLOGO)
-!ENDIF
-
-!IFDEF DEBUG
-CXXFLAGS=$(CXXFLAGS) $(CXXDEBUG)
-LDFLAGS=$(LDDEBUG) $(LDFLAGS)
-!ELSE
-CXXFLAGS=$(CXXFLAGS) $(CXXNDEBUG)
-!ENDIF
-
-INCLUDEDIRS=-I../include -I../src
-CXXFLAGS=$(CXXFLAGS) $(INCLUDEDIRS)
-
-ALL:	$(COMPONENT) $(LEXCOMPONENT) $(DIR_O)\ScintillaWinS.obj $(DIR_O)\WindowAccessor.obj
-
-clean:
-	-del /q $(DIR_O)\*.obj $(DIR_O)\*.pdb $(COMPONENT) $(LEXCOMPONENT) \
-	$(DIR_O)\*.res $(DIR_BIN)\*.map $(DIR_BIN)\*.exp $(DIR_BIN)\*.pdb $(DIR_BIN)\*.lib
-
-SOBJS=\
-	$(DIR_O)\AutoComplete.obj \
-	$(DIR_O)\CallTip.obj \
-	$(DIR_O)\CellBuffer.obj \
-	$(DIR_O)\CharClassify.obj \
-	$(DIR_O)\ContractionState.obj \
-	$(DIR_O)\Decoration.obj \
-	$(DIR_O)\Document.obj \
-	$(DIR_O)\Editor.obj \
-	$(DIR_O)\Indicator.obj \
-	$(DIR_O)\KeyMap.obj \
-	$(DIR_O)\LineMarker.obj \
-	$(DIR_O)\PlatWin.obj \
-	$(DIR_O)\PositionCache.obj \
-	$(DIR_O)\PropSet.obj \
-	$(DIR_O)\RESearch.obj \
-	$(DIR_O)\RunStyles.obj \
-	$(DIR_O)\ScintillaBase.obj \
-	$(DIR_O)\ScintillaWin.obj \
-	$(DIR_O)\Style.obj \
-	$(DIR_O)\UniConversion.obj \
-	$(DIR_O)\ViewStyle.obj \
-	$(DIR_O)\XPM.obj
-
-#++Autogenerated -- run src/LexGen.py to regenerate
-#**LEXOBJS=\\\n\(\t$(DIR_O)\\\*.obj \\\n\)
-LEXOBJS=\
-	$(DIR_O)\LexAbaqus.obj \
-	$(DIR_O)\LexAda.obj \
-	$(DIR_O)\LexAPDL.obj \
-	$(DIR_O)\LexAsm.obj \
-	$(DIR_O)\LexAsn1.obj \
-	$(DIR_O)\LexASY.obj \
-	$(DIR_O)\LexAU3.obj \
-	$(DIR_O)\LexAVE.obj \
-	$(DIR_O)\LexBaan.obj \
-	$(DIR_O)\LexBash.obj \
-	$(DIR_O)\LexBasic.obj \
-	$(DIR_O)\LexBullant.obj \
-	$(DIR_O)\LexCaml.obj \
-	$(DIR_O)\LexCLW.obj \
-	$(DIR_O)\LexCmake.obj \
-	$(DIR_O)\LexConf.obj \
-	$(DIR_O)\LexCPP.obj \
-	$(DIR_O)\LexCrontab.obj \
-	$(DIR_O)\LexCsound.obj \
-	$(DIR_O)\LexCSS.obj \
-	$(DIR_O)\LexD.obj \
-	$(DIR_O)\LexEiffel.obj \
-	$(DIR_O)\LexErlang.obj \
-	$(DIR_O)\LexEScript.obj \
-	$(DIR_O)\LexFlagship.obj \
-	$(DIR_O)\LexForth.obj \
-	$(DIR_O)\LexFortran.obj \
-	$(DIR_O)\LexGAP.obj \
-	$(DIR_O)\LexGui4Cli.obj \
-	$(DIR_O)\LexHaskell.obj \
-	$(DIR_O)\LexHTML.obj \
-	$(DIR_O)\LexInno.obj \
-	$(DIR_O)\LexKix.obj \
-	$(DIR_O)\LexLisp.obj \
-	$(DIR_O)\LexLout.obj \
-	$(DIR_O)\LexLua.obj \
-	$(DIR_O)\LexMagik.obj \
-	$(DIR_O)\LexMatlab.obj \
-	$(DIR_O)\LexMetapost.obj \
-	$(DIR_O)\LexMMIXAL.obj \
-	$(DIR_O)\LexMPT.obj \
-	$(DIR_O)\LexMSSQL.obj \
-	$(DIR_O)\LexMySQL.obj \
-	$(DIR_O)\LexNsis.obj \
-	$(DIR_O)\LexOpal.obj \
-	$(DIR_O)\LexOthers.obj \
-	$(DIR_O)\LexPascal.obj \
-	$(DIR_O)\LexPB.obj \
-	$(DIR_O)\LexPerl.obj \
-	$(DIR_O)\LexPLM.obj \
-	$(DIR_O)\LexPOV.obj \
-	$(DIR_O)\LexPowerShell.obj \
-	$(DIR_O)\LexProgress.obj \
-	$(DIR_O)\LexPS.obj \
-	$(DIR_O)\LexPython.obj \
-	$(DIR_O)\LexR.obj \
-	$(DIR_O)\LexRebol.obj \
-	$(DIR_O)\LexRuby.obj \
-	$(DIR_O)\LexScriptol.obj \
-	$(DIR_O)\LexSmalltalk.obj \
-	$(DIR_O)\LexSpecman.obj \
-	$(DIR_O)\LexSpice.obj \
-	$(DIR_O)\LexSQL.obj \
-	$(DIR_O)\LexTADS3.obj \
-	$(DIR_O)\LexTCL.obj \
-	$(DIR_O)\LexTeX.obj \
-	$(DIR_O)\LexVB.obj \
-	$(DIR_O)\LexVerilog.obj \
-	$(DIR_O)\LexVHDL.obj \
-	$(DIR_O)\LexYAML.obj \
-
-#--Autogenerated -- end of automatically generated section
-
-LOBJS=\
-	$(DIR_O)\AutoComplete.obj \
-	$(DIR_O)\CallTip.obj \
-	$(DIR_O)\CellBuffer.obj \
-	$(DIR_O)\CharClassify.obj \
-	$(DIR_O)\ContractionState.obj \
-	$(DIR_O)\Decoration.obj \
-	$(DIR_O)\Document.obj \
-	$(DIR_O)\DocumentAccessor.obj \
-	$(DIR_O)\Editor.obj \
-	$(DIR_O)\ExternalLexer.obj \
-	$(DIR_O)\Indicator.obj \
-	$(DIR_O)\KeyMap.obj \
-	$(DIR_O)\KeyWords.obj \
-	$(DIR_O)\LineMarker.obj \
-	$(DIR_O)\PlatWin.obj \
-	$(DIR_O)\PositionCache.obj \
-	$(DIR_O)\RunStyles.obj \
-	$(DIR_O)\RESearch.obj \
-	$(DIR_O)\PropSet.obj \
-	$(DIR_O)\ScintillaBaseL.obj \
-	$(DIR_O)\ScintillaWinL.obj \
-	$(DIR_O)\Style.obj \
-	$(DIR_O)\StyleContext.obj \
-	$(DIR_O)\UniConversion.obj \
-	$(DIR_O)\ViewStyle.obj \
-	$(DIR_O)\XPM.obj \
-	$(LEXOBJS)
-
-$(DIR_O)\ScintRes.res : ScintRes.rc
-	$(RC) -fo$@ $**
-
-!IF "$(VENDOR)"=="MICROSOFT"
-
-$(COMPONENT): $(SOBJS) $(DIR_O)\ScintRes.res
-	$(LD) $(LDFLAGS) -DEF:Scintilla.def -DLL -OUT:$@ $** $(LIBS)
-
-$(LEXCOMPONENT): $(LOBJS) $(DIR_O)\ScintRes.res
-	$(LD) $(LDFLAGS) -DEF:Scintilla.def -DLL -OUT:$@ $** $(LIBS)
-
-!ELSE
-
-$(COMPONENT): $(SOBJS) $(DIR_O)\ScintRes.res
-	$(LD) $(LDFLAGS) -Tpd c0d32 $(SOBJS), $@, , $(LIBS), , $(DIR_O)\ScintRes.res
-
-$(LEXCOMPONENT): $(LOBJS) $(DIR_O)\ScintRes.res
-	$(LD) $(LDFLAGS) -Tpd c0d32 $(LOBJS), $@, , $(LIBS), , $(DIR_O)\ScintRes.res
-
-!ENDIF
-
-# Define how to build all the objects and what they depend on
-
-# Most of the source is in ..\src with a couple in this directory
-{..\src}.cxx{$(DIR_O)}.obj:
-	$(CC) $(CXXFLAGS) -c $(NAME)$@ $<
-{.}.cxx{$(DIR_O)}.obj:
-	$(CC) $(CXXFLAGS) -c $(NAME)$@ $<
-
-# Some source files are compiled into more than one object because of different conditional compilation
-$(DIR_O)\ScintillaBaseL.obj: ..\src\ScintillaBase.cxx
-	$(CC) $(CXXFLAGS) -DSCI_LEXER -c $(NAME)$@ ..\src\ScintillaBase.cxx
-
-$(DIR_O)\ScintillaWinL.obj: ScintillaWin.cxx
-	$(CC) $(CXXFLAGS) -DSCI_LEXER -c $(NAME)$@ ScintillaWin.cxx
-
-$(DIR_O)\ScintillaWinS.obj: ScintillaWin.cxx
-	$(CC) $(CXXFLAGS) -DSTATIC_BUILD -c $(NAME)$@ ScintillaWin.cxx
-
-# Dependencies
-
-# All lexers depend on this set of headers
-LEX_HEADERS=..\include\Platform.h ..\include\PropSet.h \
- ..\include\SString.h ..\include\Accessor.h ..\include\KeyWords.h \
- ..\include\Scintilla.h ..\include\SciLexer.h ..\src\StyleContext.h
-
-$(DIR_O)\AutoComplete.obj: ../src/AutoComplete.cxx ../include/Platform.h \
-  ../include/PropSet.h ../include/SString.h ../src/AutoComplete.h
-$(DIR_O)\CallTip.obj: ../src/CallTip.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/CallTip.h
-$(DIR_O)\CellBuffer.obj: ../src/CellBuffer.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/SVector.h ../src/SplitVector.h \
-  ../src/Partitioning.h ../src/CellBuffer.h
-$(DIR_O)\CharClassify.obj: ../src/CharClassify.cxx ../src/CharClassify.h
-$(DIR_O)\ContractionState.obj: ../src/ContractionState.cxx ../include/Platform.h \
-  ../src/ContractionState.h
-$(DIR_O)\Decoration.obj: ../src/Decoration.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/SplitVector.h ../src/Partitioning.h \
-  ../src/RunStyles.h ../src/Decoration.h
-$(DIR_O)\Document.obj: ../src/Document.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/SVector.h ../src/SplitVector.h \
-  ../src/Partitioning.h ../src/RunStyles.h ../src/CellBuffer.h \
-  ../src/CharClassify.h ../src/Decoration.h ../src/Document.h \
-  ../src/RESearch.h
-$(DIR_O)\DocumentAccessor.obj: ../src/DocumentAccessor.cxx ../include/Platform.h \
-  ../include/PropSet.h ../include/SString.h ../src/SVector.h \
-  ../include/Accessor.h ../src/DocumentAccessor.h ../src/SplitVector.h \
-  ../src/Partitioning.h ../src/RunStyles.h ../src/CellBuffer.h \
-  ../include/Scintilla.h ../src/CharClassify.h ../src/Decoration.h \
-  ../src/Document.h
-$(DIR_O)\Editor.obj: ../src/Editor.cxx ../include/Platform.h ../include/Scintilla.h \
-  ../src/ContractionState.h ../src/SVector.h ../src/SplitVector.h \
-  ../src/Partitioning.h ../src/CellBuffer.h ../src/KeyMap.h \
-  ../src/RunStyles.h ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h \
-  ../src/Style.h ../src/ViewStyle.h ../src/CharClassify.h \
-  ../src/Decoration.h ../src/Document.h ../src/Editor.h
-$(DIR_O)\ExternalLexer.obj: ../src/ExternalLexer.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../include/SciLexer.h ../include/PropSet.h \
-  ../include/SString.h ../include/Accessor.h ../src/DocumentAccessor.h \
-  ../include/KeyWords.h ../src/ExternalLexer.h
-$(DIR_O)\Indicator.obj: ../src/Indicator.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/Indicator.h
-$(DIR_O)\KeyMap.obj: ../src/KeyMap.cxx ../include/Platform.h ../include/Scintilla.h \
-  ../src/KeyMap.h
-$(DIR_O)\KeyWords.obj: ../src/KeyWords.cxx ../include/Platform.h \
-  ../include/PropSet.h ../include/SString.h ../include/Accessor.h \
-  ../include/KeyWords.h ../include/Scintilla.h ../include/SciLexer.h
-
-#++Autogenerated -- run src/LexGen.py to regenerate
-#**\n\($(DIR_O)\\\*.obj: ..\\src\\\*.cxx $(LEX_HEADERS)\n\n\)
-
-$(DIR_O)\LexAbaqus.obj: ..\src\LexAbaqus.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexAda.obj: ..\src\LexAda.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexAPDL.obj: ..\src\LexAPDL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexAsm.obj: ..\src\LexAsm.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexAsn1.obj: ..\src\LexAsn1.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexASY.obj: ..\src\LexASY.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexAU3.obj: ..\src\LexAU3.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexAVE.obj: ..\src\LexAVE.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexBaan.obj: ..\src\LexBaan.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexBash.obj: ..\src\LexBash.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexBasic.obj: ..\src\LexBasic.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexBullant.obj: ..\src\LexBullant.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexCaml.obj: ..\src\LexCaml.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexCLW.obj: ..\src\LexCLW.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexCmake.obj: ..\src\LexCmake.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexConf.obj: ..\src\LexConf.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexCPP.obj: ..\src\LexCPP.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexCrontab.obj: ..\src\LexCrontab.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexCsound.obj: ..\src\LexCsound.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexCSS.obj: ..\src\LexCSS.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexD.obj: ..\src\LexD.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexEiffel.obj: ..\src\LexEiffel.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexErlang.obj: ..\src\LexErlang.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexEScript.obj: ..\src\LexEScript.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexFlagship.obj: ..\src\LexFlagship.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexForth.obj: ..\src\LexForth.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexFortran.obj: ..\src\LexFortran.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexGAP.obj: ..\src\LexGAP.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexGui4Cli.obj: ..\src\LexGui4Cli.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexHaskell.obj: ..\src\LexHaskell.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexHTML.obj: ..\src\LexHTML.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexInno.obj: ..\src\LexInno.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexKix.obj: ..\src\LexKix.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexLisp.obj: ..\src\LexLisp.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexLout.obj: ..\src\LexLout.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexLua.obj: ..\src\LexLua.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMagik.obj: ..\src\LexMagik.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMatlab.obj: ..\src\LexMatlab.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMetapost.obj: ..\src\LexMetapost.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMMIXAL.obj: ..\src\LexMMIXAL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMPT.obj: ..\src\LexMPT.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMSSQL.obj: ..\src\LexMSSQL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexMySQL.obj: ..\src\LexMySQL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexNsis.obj: ..\src\LexNsis.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexOpal.obj: ..\src\LexOpal.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexOthers.obj: ..\src\LexOthers.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPascal.obj: ..\src\LexPascal.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPB.obj: ..\src\LexPB.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPerl.obj: ..\src\LexPerl.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPLM.obj: ..\src\LexPLM.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPOV.obj: ..\src\LexPOV.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPowerShell.obj: ..\src\LexPowerShell.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexProgress.obj: ..\src\LexProgress.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPS.obj: ..\src\LexPS.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexPython.obj: ..\src\LexPython.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexR.obj: ..\src\LexR.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexRebol.obj: ..\src\LexRebol.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexRuby.obj: ..\src\LexRuby.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexScriptol.obj: ..\src\LexScriptol.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexSmalltalk.obj: ..\src\LexSmalltalk.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexSpecman.obj: ..\src\LexSpecman.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexSpice.obj: ..\src\LexSpice.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexSQL.obj: ..\src\LexSQL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexTADS3.obj: ..\src\LexTADS3.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexTCL.obj: ..\src\LexTCL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexTeX.obj: ..\src\LexTeX.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexVB.obj: ..\src\LexVB.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexVerilog.obj: ..\src\LexVerilog.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexVHDL.obj: ..\src\LexVHDL.cxx $(LEX_HEADERS)
-
-$(DIR_O)\LexYAML.obj: ..\src\LexYAML.cxx $(LEX_HEADERS)
-
-
-#--Autogenerated -- end of automatically generated section
-
-$(DIR_O)\LineMarker.obj: ../src/LineMarker.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/XPM.h ../src/LineMarker.h
-$(DIR_O)\PlatWin.obj: PlatWin.cxx ../include/Platform.h PlatformRes.h \
-  ../src/UniConversion.h ../src/XPM.h
-$(DIR_O)\PropSet.obj: ../src/PropSet.cxx ../include/Platform.h ../include/PropSet.h \
-  ../include/SString.h
-$(DIR_O)\RESearch.obj: ../src/RESearch.cxx ../src/CharClassify.h ../src/RESearch.h
-$(DIR_O)\RunStyles.obj: ../src/RunStyles.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/SplitVector.h ../src/Partitioning.h \
-  ../src/RunStyles.h
-$(DIR_O)\ScintillaBase.obj: ../src/ScintillaBase.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../include/PropSet.h ../include/SString.h \
-  ../src/ContractionState.h ../src/SVector.h ../src/SplitVector.h \
-  ../src/Partitioning.h ../src/RunStyles.h ../src/CellBuffer.h \
-  ../src/CallTip.h ../src/KeyMap.h ../src/Indicator.h ../src/XPM.h \
-  ../src/LineMarker.h ../src/Style.h ../src/ViewStyle.h \
-  ../src/AutoComplete.h ../src/CharClassify.h ../src/Decoration.h \
-  ../src/Document.h ../src/Editor.h ../src/ScintillaBase.h
-$(DIR_O)\ScintillaBaseL.obj: ../src/ScintillaBase.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../include/PropSet.h ../include/SString.h \
-  ../src/ContractionState.h ../src/SVector.h ../src/SplitVector.h \
-  ../src/Partitioning.h ../src/RunStyles.h ../src/CellBuffer.h \
-  ../src/CallTip.h ../src/KeyMap.h ../src/Indicator.h ../src/XPM.h \
-  ../src/LineMarker.h ../src/Style.h ../src/ViewStyle.h \
-  ../src/AutoComplete.h ../src/CharClassify.h ../src/Decoration.h \
-  ../src/Document.h ../src/Editor.h ../src/ScintillaBase.h
-$(DIR_O)\ScintillaWin.obj: ScintillaWin.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../include/SString.h ../src/ContractionState.h \
-  ../src/SVector.h ../src/SplitVector.h ../src/Partitioning.h \
-  ../src/RunStyles.h ../src/CellBuffer.h ../src/CallTip.h ../src/KeyMap.h \
-  ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h ../src/Style.h \
-  ../src/AutoComplete.h ../src/ViewStyle.h ../src/CharClassify.h \
-  ../src/Decoration.h ../src/Document.h ../src/Editor.h \
-  ../src/ScintillaBase.h ../src/UniConversion.h
-$(DIR_O)\ScintillaWinS.obj: ScintillaWin.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../include/SString.h ../src/ContractionState.h \
-  ../src/SVector.h ../src/SplitVector.h ../src/Partitioning.h \
-  ../src/RunStyles.h ../src/CellBuffer.h ../src/CallTip.h ../src/KeyMap.h \
-  ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h ../src/Style.h \
-  ../src/AutoComplete.h ../src/ViewStyle.h ../src/CharClassify.h \
-  ../src/Decoration.h ../src/Document.h ../src/Editor.h \
-  ../src/ScintillaBase.h ../src/UniConversion.h
-$(DIR_O)\ScintillaWinL.obj: ScintillaWin.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../include/SString.h ../src/ContractionState.h \
-  ../src/SVector.h ../src/SplitVector.h ../src/Partitioning.h \
-  ../src/RunStyles.h ../src/CellBuffer.h ../src/CallTip.h ../src/KeyMap.h \
-  ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h ../src/Style.h \
-  ../src/AutoComplete.h ../src/ViewStyle.h ../src/CharClassify.h \
-  ../src/Decoration.h ../src/Document.h ../src/Editor.h \
-  ../src/ScintillaBase.h ../src/UniConversion.h
-$(DIR_O)\Style.obj: ../src/Style.cxx ../include/Platform.h ../include/Scintilla.h \
-  ../src/Style.h
-$(DIR_O)\StyleContext.obj: ../src/StyleContext.cxx ../include/Platform.h \
-  ../include/PropSet.h ../include/SString.h ../include/Accessor.h \
-  ../src/StyleContext.h
-$(DIR_O)\UniConversion.obj: ../src/UniConversion.cxx ../src/UniConversion.h
-$(DIR_O)\ViewStyle.obj: ../src/ViewStyle.cxx ../include/Platform.h \
-  ../include/Scintilla.h ../src/SplitVector.h ../src/Partitioning.h \
-  ../src/RunStyles.h ../src/Indicator.h ../src/XPM.h ../src/LineMarker.h \
-  ../src/Style.h ../src/ViewStyle.h
-$(DIR_O)\WindowAccessor.obj: ../src/WindowAccessor.cxx ../include/Platform.h \
-  ../include/PropSet.h ../include/SString.h ../include/Accessor.h \
-  ../include/WindowAccessor.h ../include/Scintilla.h
-$(DIR_O)\XPM.obj: ../src/XPM.cxx ../include/Platform.h ../src/XPM.h
diff --git a/Pythonwin/pywin/dialogs/ideoptions.py b/Pythonwin/pywin/dialogs/ideoptions.py
index cee8ee893..da7c4c577 100644
--- a/Pythonwin/pywin/dialogs/ideoptions.py
+++ b/Pythonwin/pywin/dialogs/ideoptions.py
@@ -114,26 +114,23 @@ def ChangeFormat(self, fmtAttribute, fmt):
     def OnFormatTitle(self, command, code):
         fmt = self.GetFormat(interact.formatTitle)
         if fmt:
-            formatTitle = fmt
+            interact.formatTitle = fmt
             interact.SaveFontPreferences()
 
     def OnFormatInput(self, command, code):
-        global formatInput
-        fmt = self.GetFormat(formatInput)
+        fmt = self.GetFormat(interact.formatInput)
         if fmt:
-            formatInput = fmt
+            interact.formatInput = fmt
             interact.SaveFontPreferences()
 
     def OnFormatOutput(self, command, code):
-        global formatOutput
-        fmt = self.GetFormat(formatOutput)
+        fmt = self.GetFormat(interact.formatOutput)
         if fmt:
-            formatOutput = fmt
+            interact.formatOutput = fmt
             interact.SaveFontPreferences()
 
     def OnFormatError(self, command, code):
-        global formatOutputError
-        fmt = self.GetFormat(formatOutputError)
+        fmt = self.GetFormat(interact.formatOutputError)
         if fmt:
-            formatOutputError = fmt
+            interact.formatOutputError = fmt
             interact.SaveFontPreferences()
diff --git a/Pythonwin/pywin/framework/app.py b/Pythonwin/pywin/framework/app.py
index 9899e62fa..4b19a5b71 100644
--- a/Pythonwin/pywin/framework/app.py
+++ b/Pythonwin/pywin/framework/app.py
@@ -6,6 +6,7 @@
 
 from __future__ import annotations
 
+import builtins
 import os
 import sys
 import traceback
@@ -330,7 +331,7 @@ def _GetRegistryValue(key, val, default=None):
             return default
 
 
-scintilla = "Scintilla is Copyright 1998-2008 Neil Hodgson (http://www.scintilla.org)"
+scintilla = "Scintilla is Copyright 1998-2020 Neil Hodgson (https://www.scintilla.org)"
 idle = "This program uses IDLE extensions by Guido van Rossum, Tim Peters and others."
 contributors = "Thanks to the following people for making significant contributions: Roger Upole, Sidnei da Silva, Sam Rushing, Curt Hagenlocher, Dave Brennan, Roger Burnham, Gordon McMillan, Neil Hodgson, Laramie Leavitt. (let me know if I have forgotten you!)"
 
@@ -393,9 +394,7 @@ def Win32Input(prompt=None):
 
 
 def HookInput():
-    import code
-
-    sys.modules["builtins"].input = Win32Input
+    builtins.input = Win32Input
 
 
 def HaveGoodGUI():
diff --git a/Pythonwin/win32win.cpp b/Pythonwin/win32win.cpp
index f7db04170..4d8f9996e 100644
--- a/Pythonwin/win32win.cpp
+++ b/Pythonwin/win32win.cpp
@@ -25,7 +25,7 @@ generates Windows .hlp files.
 #include "win32cmdui.h"
 #include "win32rgn.h"
 #include "reswin32ui.h"
-#include "AFXSTAT_.H"
+#include "afxstat_.h"
 
 static char *szErrMsgBadHandle = "The window handle does not specify a valid window";
 #define CHECK_HWND_VALID(pWnd)       \
diff --git a/adodbapi/process_connect_string.py b/adodbapi/process_connect_string.py
index b1d4e4e93..320d1bb35 100644
--- a/adodbapi/process_connect_string.py
+++ b/adodbapi/process_connect_string.py
@@ -1,135 +1,137 @@
-"""a clumsy attempt at a macro language to let the programmer execute code on the server (ex: determine 64bit)"""
-
-from . import is64bit
-
-
-def macro_call(macro_name, args, kwargs):
-    """allow the programmer to perform limited processing on the server by passing macro names and args
-
-    :new_key - the key name the macro will create
-    :args[0] - macro name
-    :args[1:] - any arguments
-    :code - the value of the keyword item
-    :kwargs - the connection keyword dictionary. ??key has been removed
-    --> the value to put in for kwargs['name'] = value
-    """
-    if isinstance(args, (str, str)):
-        args = [
-            args
-        ]  # the user forgot to pass a sequence, so make a string into args[0]
-    new_key = args[0]
-    try:
-        if macro_name == "is64bit":
-            if is64bit.Python():  # if on 64 bit Python
-                return new_key, args[1]  # return first argument
-            else:
-                try:
-                    return new_key, args[2]  # else return second argument (if defined)
-                except IndexError:
-                    return new_key, ""  # else return blank
-
-        elif (
-            macro_name == "getuser"
-        ):  # get the name of the user the server is logged in under
-            if not new_key in kwargs:
-                import getpass
-
-                return new_key, getpass.getuser()
-
-        elif macro_name == "getnode":  # get the name of the computer running the server
-            import platform
-
-            try:
-                return new_key, args[1] % platform.node()
-            except IndexError:
-                return new_key, platform.node()
-
-        elif macro_name == "getenv":  # expand the server's environment variable args[1]
-            try:
-                dflt = args[2]  # if not found, default from args[2]
-            except IndexError:  # or blank
-                dflt = ""
-            return new_key, os.environ.get(args[1], dflt)
-
-        elif macro_name == "auto_security":
-            if (
-                not "user" in kwargs or not kwargs["user"]
-            ):  # missing, blank, or Null username
-                return new_key, "Integrated Security=SSPI"
-            return new_key, "User ID=%(user)s; Password=%(password)s" % kwargs
-
-        elif (
-            macro_name == "find_temp_test_path"
-        ):  # helper function for testing ado operation -- undocumented
-            import os
-            import tempfile
-
-            return new_key, os.path.join(
-                tempfile.gettempdir(), "adodbapi_test", args[1]
-            )
-
-        raise ValueError(f"Unknown connect string macro={macro_name}")
-    except:
-        raise ValueError(f"Error in macro processing {macro_name} {args!r}")
-
-
-def process(
-    args, kwargs, expand_macros=False
-):  # --> connection string with keyword arguments processed.
-    """attempts to inject arguments into a connection string using Python "%" operator for strings
-
-    co: adodbapi connection object
-    args: positional parameters from the .connect() call
-    kvargs: keyword arguments from the .connect() call
-    """
-    try:
-        dsn = args[0]
-    except IndexError:
-        dsn = None
-    # as a convenience the first argument may be django settings
-    if isinstance(dsn, dict):
-        kwargs.update(dsn)
-    # the connection string is passed to the connection as part of the keyword dictionary
-    elif dsn:
-        kwargs["connection_string"] = dsn
-    try:
-        a1 = args[1]
-    except IndexError:
-        a1 = None
-    # historically, the second positional argument might be a timeout value
-    if isinstance(a1, int):
-        kwargs["timeout"] = a1
-    # if the second positional argument is a string, then it is user
-    elif isinstance(a1, str):
-        kwargs["user"] = a1
-    # if the second positional argument is a dictionary, use it as keyword arguments, too
-    elif isinstance(a1, dict):
-        kwargs.update(a1)
-    try:
-        kwargs["password"] = args[2]  # the third positional argument is password
-        kwargs["host"] = args[3]  # the fourth positional argument is host name
-        kwargs["database"] = args[4]  # the fifth positional argument is database name
-    except IndexError:
-        pass
-
-    # make sure connection string is defined somehow
-    if not "connection_string" in kwargs:
-        try:  # perhaps 'dsn' was defined
-            kwargs["connection_string"] = kwargs["dsn"]
-        except KeyError:
-            try:  # as a last effort, use the "host" keyword
-                kwargs["connection_string"] = kwargs["host"]
-            except KeyError:
-                raise TypeError("Must define 'connection_string' for ado connections")
-    if expand_macros:
-        for kwarg in list(kwargs.keys()):
-            if kwarg.startswith("macro_"):  # If a key defines a macro
-                macro_name = kwarg[6:]  # name without the "macro_"
-                macro_code = kwargs.pop(
-                    kwarg
-                )  # we remove the macro_key and get the code to execute
-                new_key, rslt = macro_call(
-                    macro_name, macro_code, kwargs
-                )  # run the code in the local context
-                kwargs[new_key] = rslt  # put the result back in the keywords dict
-    return kwargs
+"""a clumsy attempt at a macro language to let the programmer execute code on the server (ex: determine 64bit)"""
+
+from . import is64bit
+
+
+def macro_call(macro_name, args, kwargs):
+    """allow the programmer to perform limited processing on the server by passing macro names and args
+
+    :new_key - the key name the macro will create
+    :args[0] - macro name
+    :args[1:] - any arguments
+    :code - the value of the keyword item
+    :kwargs - the connection keyword dictionary. ??key has been removed
+    --> the value to put in for kwargs['name'] = value
+    """
+    if isinstance(args, (str, str)):
+        args = [
+            args
+        ]  # the user forgot to pass a sequence, so make a string into args[0]
+    new_key = args[0]
+    try:
+        if macro_name == "is64bit":
+            if is64bit.Python():  # if on 64 bit Python
+                return new_key, args[1]  # return first argument
+            else:
+                try:
+                    return new_key, args[2]  # else return second argument (if defined)
+                except IndexError:
+                    return new_key, ""  # else return blank
+
+        elif (
+            macro_name == "getuser"
+        ):  # get the name of the user the server is logged in under
+            if not new_key in kwargs:
+                import getpass
+
+                return new_key, getpass.getuser()
+
+        elif macro_name == "getnode":  # get the name of the computer running the server
+            import platform
+
+            try:
+                return new_key, args[1] % platform.node()
+            except IndexError:
+                return new_key, platform.node()
+
+        elif macro_name == "getenv":  # expand the server's environment variable args[1]
+            import os
+
+            try:
+                dflt = args[2]  # if not found, default from args[2]
+            except IndexError:  # or blank
+                dflt = ""
+            return new_key, os.environ.get(args[1], dflt)
+
+        elif macro_name == "auto_security":
+            if (
+                not "user" in kwargs or not kwargs["user"]
+            ):  # missing, blank, or Null username
+                return new_key, "Integrated Security=SSPI"
+            return new_key, "User ID=%(user)s; Password=%(password)s" % kwargs
+
+        elif (
+            macro_name == "find_temp_test_path"
+        ):  # helper function for testing ado operation -- undocumented
+            import os
+            import tempfile
+
+            return new_key, os.path.join(
+                tempfile.gettempdir(), "adodbapi_test", args[1]
+            )
+
+        raise ValueError(f"Unknown connect string macro={macro_name}")
+    except:
+        raise ValueError(f"Error in macro processing {macro_name} {args!r}")
+
+
+def process(
+    args, kwargs, expand_macros=False
+):  # --> connection string with keyword arguments processed.
+    """attempts to inject arguments into a connection string using Python "%" operator for strings
+
+    co: adodbapi connection object
+    args: positional parameters from the .connect() call
+    kvargs: keyword arguments from the .connect() call
+    """
+    try:
+        dsn = args[0]
+    except IndexError:
+        dsn = None
+    # as a convenience the first argument may be django settings
+    if isinstance(dsn, dict):
+        kwargs.update(dsn)
+    # the connection string is passed to the connection as part of the keyword dictionary
+    elif dsn:
+        kwargs["connection_string"] = dsn
+    try:
+        a1 = args[1]
+    except IndexError:
+        a1 = None
+    # historically, the second positional argument might be a timeout value
+    if isinstance(a1, int):
+        kwargs["timeout"] = a1
+    # if the second positional argument is a string, then it is user
+    elif isinstance(a1, str):
+        kwargs["user"] = a1
+    # if the second positional argument is a dictionary, use it as keyword arguments, too
+    elif isinstance(a1, dict):
+        kwargs.update(a1)
+    try:
+        kwargs["password"] = args[2]  # the third positional argument is password
+        kwargs["host"] = args[3]  # the fourth positional argument is host name
+        kwargs["database"] = args[4]  # the fifth positional argument is database name
+    except IndexError:
+        pass
+
+    # make sure connection string is defined somehow
+    if not "connection_string" in kwargs:
+        try:  # perhaps 'dsn' was defined
+            kwargs["connection_string"] = kwargs["dsn"]
+        except KeyError:
+            try:  # as a last effort, use the "host" keyword
+                kwargs["connection_string"] = kwargs["host"]
+            except KeyError:
+                raise TypeError("Must define 'connection_string' for ado connections")
+    if expand_macros:
+        for kwarg in list(kwargs.keys()):
+            if kwarg.startswith("macro_"):  # If a key defines a macro
+                macro_name = kwarg[6:]  # name without the "macro_"
+                macro_code = kwargs.pop(
+                    kwarg
+                )  # we remove the macro_key and get the code to execute
+                new_key, rslt = macro_call(
+                    macro_name, macro_code, kwargs
+                )  # run the code in the local context
+                kwargs[new_key] = rslt  # put the result back in the keywords dict
+    return kwargs
diff --git a/com/win32com/client/build.py b/com/win32com/client/build.py
index c0d660800..a1c7d52a5 100644
--- a/com/win32com/client/build.py
+++ b/com/win32com/client/build.py
@@ -16,6 +16,7 @@
 #
 #        OleItem, DispatchItem, MapEntry, BuildCallList() is used by makepy
 
+import builtins
 import datetime
 import string
 from itertools import chain
@@ -656,7 +657,7 @@ def MakePublicAttributeName(className, is_global=False):
         if ret == className:
             ret = ret.upper()
         return ret
-    elif is_global and hasattr(__builtins__, className):
+    elif is_global and hasattr(builtins, className):
         # builtins may be mixed case.  If capitalizing it doesn't change it,
         # force to all uppercase (eg, "None", "True" become "NONE", "TRUE"
         ret = className.capitalize()
diff --git a/com/win32com/makegw/makegw.py b/com/win32com/makegw/makegw.py
index 2a12239c8..e3c85d61a 100644
--- a/com/win32com/makegw/makegw.py
+++ b/com/win32com/makegw/makegw.py
@@ -20,7 +20,7 @@
 any result values.
 
 This module automates the generation of such code.  It has the ability to
-parse a .H file generated by the MIDL tool (ie, almost all COM .h files)
+parse a .h file generated by the MIDL tool (ie, almost all COM .h files)
 and build almost totally complete C++ code.
 
 The module understands some of the well known data types, and how to
@@ -61,7 +61,7 @@ def make_framework_support(
 ):
     """Generate C++ code for a Python Interface and Gateway
 
-    header_file_name -- The full path to the .H file which defines the interface.
+    header_file_name -- The full path to the .h file which defines the interface.
     interface_name -- The name of the interface to search for, and to generate.
     bMakeInterface = 1 -- Should interface (ie, client) support be generated.
     bMakeGatewayInterface = 1 -- Should gateway (ie, server) support be generated.
diff --git a/com/win32com/olectl.py b/com/win32com/olectl.py
index 3ec5bf6ef..e2e16b42d 100644
--- a/com/win32com/olectl.py
+++ b/com/win32com/olectl.py
@@ -1,6 +1,6 @@
 """Constants used by COM Controls
 
-Hand created version of OLECTL.H constants.
+Hand created version of olectl.h constants.
 """
 
 import winerror
diff --git a/com/win32com/src/ErrorUtils.cpp b/com/win32com/src/ErrorUtils.cpp
index ff16d9985..c774e9f99 100644
--- a/com/win32com/src/ErrorUtils.cpp
+++ b/com/win32com/src/ErrorUtils.cpp
@@ -1115,7 +1115,7 @@ LPCTSTR GetFacilityString(HRESULT hr)
         _T("FACILITY_0x06"),
         _T("FACILITY_WIN32"),
         _T("FACILITY_WINDOWS"),
-        _T("FACILITY_SSPI/FACILITY_MQ"),  // SSPI from ADSERR.H, MQ from mq.h
+        _T("FACILITY_SSPI/FACILITY_MQ"),  // SSPI from AdsErr.h, MQ from mq.h
         _T("FACILITY_CONTROL"),
         _T("FACILITY_EDK"),
         _T("FACILITY_INTERNET"),
diff --git a/com/win32com/test/GenTestScripts.py b/com/win32com/test/GenTestScripts.py
index 079f6a984..8b09df077 100644
--- a/com/win32com/test/GenTestScripts.py
+++ b/com/win32com/test/GenTestScripts.py
@@ -3,6 +3,7 @@
 #
 import os
 import sys
+import traceback
 
 import pythoncom
 import win32com
@@ -60,10 +61,7 @@ def GenerateAll():
 
 def CleanAll():
     print("Cleaning generated test scripts...")
-    try:  # Clear exceptions!
-        1 / 0
-    except:
-        pass
+    traceback.clear_frames(sys.exc_info()[2])  # Clear exceptions!
     genPath = GetGenPath()
     for args in genList:
         try:
diff --git a/com/win32com/test/testPippo.py b/com/win32com/test/testPippo.py
index 414483b53..765acf97f 100644
--- a/com/win32com/test/testPippo.py
+++ b/com/win32com/test/testPippo.py
@@ -51,9 +51,8 @@ def testNumpyArrays(self):
         self._testArray(numpy.array([-3.14, -2, -0.1, 0.0, 1.1, 2.5, 3]))
 
     def testByteArrays(self):
-        if "bytes" in dir(__builtins__):
-            self._testArray(b"abcdef")
-            self._testArray(bytearray(b"abcdef"))
+        self._testArray(b"abcdef")
+        self._testArray(bytearray(b"abcdef"))
 
     def _testArray(self, inArray):
         outArray = self.object.Method3(inArray)
diff --git a/com/win32comext/adsi/src/PyADSIUtil.cpp b/com/win32comext/adsi/src/PyADSIUtil.cpp
index 07f3093d1..06c0ec209 100644
--- a/com/win32comext/adsi/src/PyADSIUtil.cpp
+++ b/com/win32comext/adsi/src/PyADSIUtil.cpp
@@ -672,11 +672,11 @@ BOOL PyADSIObject_AsADS_SEARCHPREF_INFOs(PyObject *ob, ADS_SEARCHPREF_INFO **ppr
 //
 // Error string utility.
 //
-// ADSERR.h is built from a message file.
+// AdsErr.h is built from a message file.
 // Therefore, there _must_ be a DLL around we can call
 // FormatMessage with.
 // However, it's not obvious, and this code was cut directly from MSDN.
-#include "adserr.h"
+#include "AdsErr.h"
 typedef struct tagADSERRMSG {
     HRESULT hr;
     LPCWSTR pszError;
diff --git a/com/win32comext/axdebug/util.py b/com/win32comext/axdebug/util.py
index 424c529df..a9796a485 100644
--- a/com/win32comext/axdebug/util.py
+++ b/com/win32comext/axdebug/util.py
@@ -3,6 +3,7 @@
 
 import os
 import sys
+import traceback
 
 import win32api
 import win32com.server.dispatcher
@@ -43,13 +44,8 @@ def RaiseNotImpl(who=None):
         print(f"********* Function {who} Raising E_NOTIMPL  ************")
 
     # Print a sort-of "traceback", dumping all the frames leading to here.
-    try:
-        1 / 0
-    except:
-        frame = sys.exc_info()[2].tb_frame
-    while frame:
+    for frame, i in traceback.walk_stack(sys._getframe()):
         print(f"File: {frame.f_code.co_filename}, Line: {frame.f_lineno}")
-        frame = frame.f_back
 
     # and raise the exception for COM
     raise COMException(scode=winerror.E_NOTIMPL)
diff --git a/com/win32comext/axscript/client/debug.py b/com/win32comext/axscript/client/debug.py
index 352b86453..bf7ef960a 100644
--- a/com/win32comext/axscript/client/debug.py
+++ b/com/win32comext/axscript/client/debug.py
@@ -125,12 +125,7 @@ def _query_interface_for_debugger_(self, iid):
 
     def OnEnterScript(self):
         trace("OnEnterScript")
-        try:
-            1 / 0
-        except:
-            # Bit of a hack - reach into engine.
-            baseFrame = sys.exc_info()[2].tb_frame.f_back
-        self.adb.SetupAXDebugging(baseFrame)
+        self.adb.SetupAXDebugging(sys._getframe().f_back)
 
     def OnLeaveScript(self):
         trace("OnLeaveScript")
diff --git a/com/win32comext/axscript/src/GUIDS.CPP b/com/win32comext/axscript/src/GUIDs.cpp
similarity index 72%
rename from com/win32comext/axscript/src/GUIDS.CPP
rename to com/win32comext/axscript/src/GUIDs.cpp
index bce8d8807..9038c1225 100644
--- a/com/win32comext/axscript/src/GUIDS.CPP
+++ b/com/win32comext/axscript/src/GUIDs.cpp
@@ -1,10 +1,10 @@
 /*
  * FILENAME:
- *	guids.cpp
+ *	GUIDs.cpp
  *
  * DESCRIPTION:
- *	Define the guids used by the project. Both internally defined
- *	guids as well as guids from external sources.
+ *	Define the GUIDs used by the project. Both internally defined
+ *	GUIDs as well as GUIDs from external sources.
  */
 #include <objbase.h>
 #pragma data_seg(".text")
@@ -17,7 +17,7 @@
 #endif
 
 // === Project Guids ===
-#include "GUIDS.H"
+#include "GUIDs.h"
 // NOTE - The standard "activscp.h" header is not good enough -
 // need to use IE4 SDK or MSVC6 etc
 #include "activscp.h"
diff --git a/com/win32comext/axscript/src/GUIDS.H b/com/win32comext/axscript/src/GUIDs.h
similarity index 98%
rename from com/win32comext/axscript/src/GUIDS.H
rename to com/win32comext/axscript/src/GUIDs.h
index 20355e4d9..857a5b43d 100644
--- a/com/win32comext/axscript/src/GUIDS.H
+++ b/com/win32comext/axscript/src/GUIDs.h
@@ -3,7 +3,7 @@
 
 /*
  * FILENAME:
- *	guids.h
+ *	GUIDs.h
  *
  * DESCRIPTION:
  *	GUID definitions for the project.
diff --git a/com/win32comext/axscript/src/MULTINFO.H b/com/win32comext/axscript/src/multinfo.h
similarity index 100%
rename from com/win32comext/axscript/src/MULTINFO.H
rename to com/win32comext/axscript/src/multinfo.h
diff --git a/com/win32comext/mapi/mapitags.py b/com/win32comext/mapi/mapitags.py
index e6e9667e0..e3238b662 100644
--- a/com/win32comext/mapi/mapitags.py
+++ b/com/win32comext/mapi/mapitags.py
@@ -824,7 +824,7 @@ def PROP_TAG(ulPropType, ulPropID):
 PROP_ID_SECURE_MIN = 26608
 PROP_ID_SECURE_MAX = 26623
 
-# From EDKMDB.H
+# From EdkMdb.h
 pidExchangeXmitReservedMin = 16352
 pidExchangeNonXmitReservedMin = 26080
 pidProfileMin = 26112
diff --git a/com/win32comext/mapi/src/PyIExchangeManageStore.i b/com/win32comext/mapi/src/PyIExchangeManageStore.i
index 36e71e6bd..013136512 100644
--- a/com/win32comext/mapi/src/PyIExchangeManageStore.i
+++ b/com/win32comext/mapi/src/PyIExchangeManageStore.i
@@ -11,7 +11,7 @@
 %include "mapilib.i"
 
 %{
-#include <edkmdb.h>
+#include <EdkMdb.h>
 #define INITGUID
 #include <initguid.h>
 #define USES_IID_IExchangeManageStore
diff --git a/com/win32comext/mapi/src/exchange.i b/com/win32comext/mapi/src/exchange.i
index 8afdf76b0..8287cb008 100644
--- a/com/win32comext/mapi/src/exchange.i
+++ b/com/win32comext/mapi/src/exchange.i
@@ -26,8 +26,8 @@
 #include "PythonCOMServer.h"
 #include "PythonCOMRegister.h"
 
-#include "MAPIUTIL.H"
-#include "EDKMDB.H"
+#include "MAPIUtil.h"
+#include "EdkMdb.h"
 
 #define USES_IID_IExchangeManageStore
 #include <edkguid.h>
@@ -75,9 +75,9 @@ static int AddIID(PyObject *dict, const char *key, REFGUID guid)
 */
 #ifdef SWIG_PY32BIT
 %{
-#include "EDKMAPI.H"
-#include "EDKCFG.H"
-#include "EDKUTILS.H"
+#include "EdkMAPI.h"
+#include "EdkCfg.h"
+#include "EdkUtils.h"
 %}
 
 // @pyswig int, int|HrGetExchangeStatus|Obtains the current state of the server on a computer.
diff --git a/com/win32comext/mapi/src/mapi.i b/com/win32comext/mapi/src/mapi.i
index b66133443..be270f51d 100644
--- a/com/win32comext/mapi/src/mapi.i
+++ b/com/win32comext/mapi/src/mapi.i
@@ -52,9 +52,8 @@
 #include "IConverterSession.h"
 #include "PyIConverterSession.h"
 
-#include "MAPISPI.H"
-#include "MAPISPI.H"
-#include "IMESSAGE.H"
+#include "MAPISPI.h"
+#include "IMessage.h"
 #include "MSPST.h"
 
 #include "extraMAPIGuids.h"
diff --git a/isapi/src/pyISAPI.cpp b/isapi/src/pyISAPI.cpp
index 453cc2b99..6cf639351 100644
--- a/isapi/src/pyISAPI.cpp
+++ b/isapi/src/pyISAPI.cpp
@@ -23,7 +23,7 @@
  ======================================================================
  */
 
-// PYISAPI.CPP - Implementation file for your Internet Server
+// pyISAPI.cpp - Implementation file for your Internet Server
 //    Python ISAPI Extension
 
 #include "stdafx.h"
diff --git a/isapi/src/pyISAPI.h b/isapi/src/pyISAPI.h
index b5931e538..6a82a9a91 100644
--- a/isapi/src/pyISAPI.h
+++ b/isapi/src/pyISAPI.h
@@ -25,7 +25,7 @@
 #ifndef __PYISAPI_H__
 #define __PYISAPI_H__
 
-// PYISAPI.H - Header file for your Internet Server
+// pyISAPI.h - Header file for your Internet Server
 //    Python ISAPI Extension
 
 #include "PythonEng.h"
diff --git a/pyrightconfig.json b/pyrightconfig.json
index d96b3fc9d..c35e4a565 100644
--- a/pyrightconfig.json
+++ b/pyrightconfig.json
@@ -6,6 +6,7 @@
   "enableTypeIgnoreComments": true,
   // Exclude from scanning when running pyright
   "exclude": [
+    ".git/",
     "build/",
     // Vendored
     "Pythonwin/Scintilla/",
@@ -39,8 +40,6 @@
   "reportOptionalSubscript": "warning",
   // Needs fixes in types-pywin32 and requires Python 3.8 to annotate ambiguous global variables
   "reportUnnecessaryComparison": "warning",
-  // TODO: Leave Unbound its own PR(s)
-  "reportUnboundVariable": "warning",
   // Too many dynamically generated modules. This will require type stubs to properly fix.
   "reportMissingImports": "warning",
   // IDEM, but happens when pywin32 is not in site-packages but module is found from typeshed.
diff --git a/setup.py b/setup.py
index e72edf0ad..bd63dead1 100644
--- a/setup.py
+++ b/setup.py
@@ -921,13 +921,6 @@ def my_new_compiler(**kw):
 
 
 class my_compiler(MSVCCompiler):
-    # Just one GUIDS.CPP and it gives trouble on mainwin too. Maybe I
-    # should just rename the file, but a case-only rename is likely to be
-    # worse!  This can probably go away once we kill the VS project files
-    # though, as we can just specify the lowercase name in the module def.
-    _cpp_extensions = MSVCCompiler._cpp_extensions + [".CPP"]
-    src_extensions = MSVCCompiler.src_extensions + [".CPP"]
-
     def link(
         self,
         target_desc,
@@ -1422,7 +1415,7 @@ def finalize_options(self):
         sources=(
             """
                         {axscript}/AXScript.cpp
-                        {axscript}/GUIDS.CPP                   {axscript}/PyGActiveScript.cpp
+                        {axscript}/GUIDS.cpp                   {axscript}/PyGActiveScript.cpp
                         {axscript}/PyGActiveScriptError.cpp    {axscript}/PyGActiveScriptParse.cpp
                         {axscript}/PyGActiveScriptSite.cpp     {axscript}/PyGObjectSafety.cpp
                         {axscript}/PyIActiveScript.cpp         {axscript}/PyIActiveScriptError.cpp
@@ -1434,7 +1427,7 @@ def finalize_options(self):
         depends=(
             """
                              {axscript}/AXScript.h
-                             {axscript}/guids.h                {axscript}/PyGActiveScriptError.h
+                             {axscript}/GUIDs.h                {axscript}/PyGActiveScriptError.h
                              {axscript}/PyIActiveScriptError.h {axscript}/PyIObjectSafety.h
                              {axscript}/PyIProvideMultipleClassInfo.h
                              {axscript}/stdafx.h
diff --git a/win32/Demos/EvtSubscribe_push.py b/win32/Demos/EvtSubscribe_push.py
index 519ef0d72..fa4feb729 100644
--- a/win32/Demos/EvtSubscribe_push.py
+++ b/win32/Demos/EvtSubscribe_push.py
@@ -1,4 +1,8 @@
 ## Demonstrates a "push" subscription with a callback function
+from __future__ import annotations
+
+from time import sleep
+
 import win32evtlog
 
 query_text = '*[System[Provider[@Name="Microsoft-Windows-Winlogon"]]]'
@@ -15,7 +19,7 @@ def c(reason, context, evt):
     return 0
 
 
-evttext = []
+evttext: list[str] = []
 s = win32evtlog.EvtSubscribe(
     "System",
     win32evtlog.EvtSubscribeStartAtOldestRecord,
@@ -23,3 +27,6 @@ def c(reason, context, evt):
     Callback=c,
     Context=evttext,
 )
+
+sleep(0.001)
+print("\n".join(evttext))
diff --git a/win32/Demos/dde/ddeclient.py b/win32/Demos/dde/ddeclient.py
index f140e2438..6e63c4d6f 100644
--- a/win32/Demos/dde/ddeclient.py
+++ b/win32/Demos/dde/ddeclient.py
@@ -1,7 +1,7 @@
 # 'Request' example added jjk  11/20/98
 
+import win32ui  # isort: skip # Must be imported before dde !
 import dde
-import win32ui
 
 server = dde.CreateServer()
 server.Create("TestClient")
diff --git a/win32/Demos/dde/ddeserver.py b/win32/Demos/dde/ddeserver.py
index 0374827f0..57924aba6 100644
--- a/win32/Demos/dde/ddeserver.py
+++ b/win32/Demos/dde/ddeserver.py
@@ -1,7 +1,7 @@
 # 'Request' example added jjk  11/20/98
 
+import win32ui  # isort: skip # Must be imported before dde !
 import dde
-import win32ui
 from pywin.mfc import object
 
 
diff --git a/win32/Lib/commctrl.py b/win32/Lib/commctrl.py
index 26641e845..452fe62ef 100644
--- a/win32/Lib/commctrl.py
+++ b/win32/Lib/commctrl.py
@@ -1,4 +1,4 @@
-# Generated by h2py from COMMCTRL.H
+# Generated by h2py from CommCtrl.h
 WM_USER = 1024
 ICC_LISTVIEW_CLASSES = 1  # listview, header
 ICC_TREEVIEW_CLASSES = 2  # treeview, tooltips
diff --git a/win32/Lib/win32pdhquery.py b/win32/Lib/win32pdhquery.py
index 724a668a7..301b85c16 100644
--- a/win32/Lib/win32pdhquery.py
+++ b/win32/Lib/win32pdhquery.py
@@ -560,11 +560,11 @@ def __setstate__(self, volatilecounters):
         self.volatilecounters = volatilecounters
 
 
-class QueryError:
-    def __init__(self, query):
+class QueryError(Exception):
+    def __init__(self, query: BaseQuery):
         self.query = query
 
     def __repr__(self):
-        return "<Query Error in %s>" % repr(self.query)
+        return f"<Query Error in {self.query!r}>"
 
     __str__ = __repr__
diff --git a/win32/src/_winxptheme.i b/win32/src/_winxptheme.i
index 3ef07bbb9..2320b881e 100644
--- a/win32/src/_winxptheme.i
+++ b/win32/src/_winxptheme.i
@@ -21,7 +21,7 @@
 #include "pywinobjects.h"
 #include "windows.h"
 #include "Uxtheme.h"
-#include "commctrl.h"
+#include "CommCtrl.h"
 
 
 %}
diff --git a/win32/src/stddde.h b/win32/src/stddde.h
index 85688c1f9..3263f4fbd 100644
--- a/win32/src/stddde.h
+++ b/win32/src/stddde.h
@@ -26,7 +26,7 @@
 
 //
 // String names for some standard DDE strings not
-// defined in DDEML.H
+// defined in ddeml.h
 //
 
 #define SZ_READY "Ready"
diff --git a/win32/src/win32dynamicdialog.cpp b/win32/src/win32dynamicdialog.cpp
index bef647374..2b1992d67 100644
--- a/win32/src/win32dynamicdialog.cpp
+++ b/win32/src/win32dynamicdialog.cpp
@@ -34,7 +34,7 @@
 #include "python.h"
 #undef PyHANDLE
 #include <windows.h>
-#include "commctrl.h"
+#include "CommCtrl.h"
 #include "windowsx.h"  // For edit control hacks.
 
 #include "pywintypes.h"
diff --git a/win32/src/win32gui.i b/win32/src/win32gui.i
index fa0906b7e..172218879 100644
--- a/win32/src/win32gui.i
+++ b/win32/src/win32gui.i
@@ -14,7 +14,7 @@
 #undef PyHANDLE
 #include "pywinobjects.h"
 #include "winuser.h"
-#include "commctrl.h"
+#include "CommCtrl.h"
 #include "windowsx.h" // For edit control hacks.
 #include "Dbt.h" // device notification
 #include "malloc.h"
diff --git a/win32/src/win32security.i b/win32/src/win32security.i
index c614d3081..48b4d2dc8 100644
--- a/win32/src/win32security.i
+++ b/win32/src/win32security.i
@@ -1246,9 +1246,9 @@ done:
     if it fails. If the SID can be constructed successfully,
     a valid binary SID is returned.
 
-    This function requires TCHAR.H and the C runtime library.
+    This function requires tchar.h and the C runtime library.
 
-    The following are macros defined in TCHAR.H that allow this
+    The following are macros defined in tchar.h that allow this
     function to be compiled with or without UNICODE defined. To
     replace these macros with direct calls to their corresponding
     ANSI functions first make sure this module is not compiled
diff --git a/win32/test/handles.py b/win32/test/handles.py
index 01b7f17ef..9e4f63358 100644
--- a/win32/test/handles.py
+++ b/win32/test/handles.py
@@ -5,6 +5,14 @@
 import win32api
 
 
+class TestError1(Exception):
+    pass
+
+
+class TestError2(Exception):
+    pass
+
+
 # A class that will never die vie refcounting, but will die via GC.
 class Cycle:
     def __init__(self, handle):
@@ -21,7 +29,7 @@ def f1(invalidate):
             h = win32event.CreateEvent(None, 0, 0, None)
             if invalidate:
                 win32api.CloseHandle(int(h))
-            1 / 0
+            raise TestError1
             # If we invalidated, then the object destruction code will attempt
             # to close an invalid handle.  We don't wan't an exception in
             # this case
@@ -30,13 +38,13 @@ def f2(invalidate):
             """This function should throw an OSError."""
             try:
                 f1(invalidate)
-            except ZeroDivisionError as exc:
-                raise OSError("raise 2")
+            except TestError1:
+                raise TestError2
 
-        self.assertRaises(OSError, f2, False)
+        self.assertRaises(TestError2, f2, False)
         # Now do it again, but so the auto object destruction
         # actually fails.
-        self.assertRaises(OSError, f2, True)
+        self.assertRaises(TestError2, f2, True)
 
     def testCleanup2(self):
         # Cause an exception during object destruction.
diff --git a/win32/test/test_win32api.py b/win32/test/test_win32api.py
index 446315f54..887ff2a36 100644
--- a/win32/test/test_win32api.py
+++ b/win32/test/test_win32api.py
@@ -14,6 +14,10 @@
 from pywin32_testutil import TestSkipped
 
 
+class TestError(Exception):
+    pass
+
+
 class CurrentUserTestCase(unittest.TestCase):
     def testGetCurrentUser(self):
         domain = win32api.GetDomainName()
@@ -63,7 +67,7 @@ def test1(self):
         # This used to leave a stale exception behind.
         def reg_operation():
             hkey = win32api.RegCreateKey(win32con.HKEY_CURRENT_USER, self.key_name)
-            x = 3 / 0  # or a statement like: raise Exception
+            raise TestError
 
         # do the test
         try:
@@ -71,10 +75,10 @@ def reg_operation():
                 try:
                     reg_operation()
                 except:
-                    1 / 0  # Force exception
+                    raise TestError  # Force a TestError
             finally:
                 win32api.RegDeleteKey(win32con.HKEY_CURRENT_USER, self.key_name)
-        except ZeroDivisionError:
+        except TestError:
             pass
 
     def testValues(self):